Ruby  1.9.3p547(2014-05-14revision45962)
parse.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 "parse.y"
70 
71 
72 #define YYDEBUG 1
73 #define YYERROR_VERBOSE 1
74 #define YYSTACK_USE_ALLOCA 0
75 
76 #include "ruby/ruby.h"
77 #include "ruby/st.h"
78 #include "ruby/encoding.h"
79 #include "internal.h"
80 #include "node.h"
81 #include "parse.h"
82 #include "id.h"
83 #include "regenc.h"
84 #include <stdio.h>
85 #include <errno.h>
86 #include <ctype.h>
87 
88 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
89 
90 #define YYMALLOC(size) rb_parser_malloc(parser, (size))
91 #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
92 #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
93 #define YYFREE(ptr) rb_parser_free(parser, (ptr))
94 #define malloc YYMALLOC
95 #define realloc YYREALLOC
96 #define calloc YYCALLOC
97 #define free YYFREE
98 
99 #ifndef RIPPER
100 static ID register_symid(ID, const char *, long, rb_encoding *);
101 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
102 #include "id.c"
103 #endif
104 
105 #define is_notop_id(id) ((id)>tLAST_TOKEN)
106 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
107 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
108 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
109 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
110 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
111 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
112 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
113 
114 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
115  (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
116  ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
117  ((id)&ID_SCOPE_MASK) == ID_CLASS))
118 
120  EXPR_BEG, /* ignore newline, +/- is a sign. */
121  EXPR_END, /* newline significant, +/- is an operator. */
122  EXPR_ENDARG, /* ditto, and unbound braces. */
123  EXPR_ENDFN, /* ditto, and unbound braces. */
124  EXPR_ARG, /* newline significant, +/- is an operator. */
125  EXPR_CMDARG, /* newline significant, +/- is an operator. */
126  EXPR_MID, /* newline significant, +/- is an operator. */
127  EXPR_FNAME, /* ignore newline, no reserved words. */
128  EXPR_DOT, /* right after `.' or `::', no reserved words. */
129  EXPR_CLASS, /* immediate after `class', no here document. */
130  EXPR_VALUE, /* alike EXPR_BEG but label is disallowed. */
132 };
133 
135 
136 # define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
137 # define BITSTACK_POP(stack) ((stack) = (stack) >> 1)
138 # define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
139 # define BITSTACK_SET_P(stack) ((stack)&1)
140 
141 #define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n))
142 #define COND_POP() BITSTACK_POP(cond_stack)
143 #define COND_LEXPOP() BITSTACK_LEXPOP(cond_stack)
144 #define COND_P() BITSTACK_SET_P(cond_stack)
145 
146 #define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n))
147 #define CMDARG_POP() BITSTACK_POP(cmdarg_stack)
148 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
149 #define CMDARG_P() BITSTACK_SET_P(cmdarg_stack)
150 
151 struct vtable {
152  ID *tbl;
153  int pos;
154  int capa;
155  struct vtable *prev;
156 };
157 
158 struct local_vars {
159  struct vtable *args;
160  struct vtable *vars;
161  struct vtable *used;
162  struct local_vars *prev;
164 };
165 
166 #define DVARS_INHERIT ((void*)1)
167 #define DVARS_TOPSCOPE NULL
168 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
169 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
170 
171 static int
172 vtable_size(const struct vtable *tbl)
173 {
174  if (POINTER_P(tbl)) {
175  return tbl->pos;
176  }
177  else {
178  return 0;
179  }
180 }
181 
182 #define VTBL_DEBUG 0
183 
184 static struct vtable *
186 {
187  struct vtable *tbl = ALLOC(struct vtable);
188  tbl->pos = 0;
189  tbl->capa = 8;
190  tbl->tbl = ALLOC_N(ID, tbl->capa);
191  tbl->prev = prev;
192  if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
193  return tbl;
194 }
195 
196 static void
198 {
199  if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
200  if (POINTER_P(tbl)) {
201  if (tbl->tbl) {
202  xfree(tbl->tbl);
203  }
204  xfree(tbl);
205  }
206 }
207 
208 static void
209 vtable_add(struct vtable *tbl, ID id)
210 {
211  if (!POINTER_P(tbl)) {
212  rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
213  }
214  if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
215 
216  if (tbl->pos == tbl->capa) {
217  tbl->capa = tbl->capa * 2;
218  REALLOC_N(tbl->tbl, ID, tbl->capa);
219  }
220  tbl->tbl[tbl->pos++] = id;
221 }
222 
223 static int
224 vtable_included(const struct vtable * tbl, ID id)
225 {
226  int i;
227 
228  if (POINTER_P(tbl)) {
229  for (i = 0; i < tbl->pos; i++) {
230  if (tbl->tbl[i] == id) {
231  return i+1;
232  }
233  }
234  }
235  return 0;
236 }
237 
238 
239 #ifndef RIPPER
240 typedef struct token_info {
241  const char *token;
242  int linenum;
243  int column;
244  int nonspc;
245  struct token_info *next;
246 } token_info;
247 #endif
248 
249 /*
250  Structure of Lexer Buffer:
251 
252  lex_pbeg tokp lex_p lex_pend
253  | | | |
254  |-----------+--------------+------------|
255  |<------------>|
256  token
257 */
258 struct parser_params {
259  int is_ripper;
260  NODE *heap;
261 
263  VALUE eofp;
264 
269  int parser_class_nest;
270  int parser_paren_nest;
271  int parser_lpar_beg;
272  int parser_in_single;
273  int parser_in_def;
276  int parser_in_defined;
277  char *parser_tokenbuf;
278  int parser_tokidx;
279  int parser_toksiz;
283  const char *parser_lex_pbeg;
284  const char *parser_lex_p;
285  const char *parser_lex_pend;
286  int parser_heredoc_end;
289  long parser_lex_gets_ptr;
291  struct local_vars *parser_lvtbl;
293  int line_count;
294  int has_shebang;
295  char *parser_ruby_sourcefile; /* current source file */
296  int parser_ruby_sourceline; /* current line no. */
297  rb_encoding *enc;
298  rb_encoding *utf8;
299 
300  int parser_yydebug;
301 
302 #ifndef RIPPER
303  /* Ruby core only */
307  VALUE coverage;
308  int nerr;
309 
312 #else
313  /* Ripper only */
314  VALUE parser_ruby_sourcefile_string;
315  const char *tokp;
316  VALUE delayed;
317  int delayed_line;
318  int delayed_col;
319 
320  VALUE value;
321  VALUE result;
322  VALUE parsing_thread;
323  int toplevel_p;
324 #endif
325 };
326 
327 #define UTF8_ENC() (parser->utf8 ? parser->utf8 : \
328  (parser->utf8 = rb_utf8_encoding()))
329 #define STR_NEW(p,n) rb_enc_str_new((p),(n),parser->enc)
330 #define STR_NEW0() rb_enc_str_new(0,0,parser->enc)
331 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),parser->enc)
332 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),parser->enc)
333 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
334 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), parser->enc)
335 
336 static int parser_yyerror(struct parser_params*, const char*);
337 #define yyerror(msg) parser_yyerror(parser, (msg))
338 
339 #define lex_strterm (parser->parser_lex_strterm)
340 #define lex_state (parser->parser_lex_state)
341 #define cond_stack (parser->parser_cond_stack)
342 #define cmdarg_stack (parser->parser_cmdarg_stack)
343 #define class_nest (parser->parser_class_nest)
344 #define paren_nest (parser->parser_paren_nest)
345 #define lpar_beg (parser->parser_lpar_beg)
346 #define in_single (parser->parser_in_single)
347 #define in_def (parser->parser_in_def)
348 #define compile_for_eval (parser->parser_compile_for_eval)
349 #define cur_mid (parser->parser_cur_mid)
350 #define in_defined (parser->parser_in_defined)
351 #define tokenbuf (parser->parser_tokenbuf)
352 #define tokidx (parser->parser_tokidx)
353 #define toksiz (parser->parser_toksiz)
354 #define lex_input (parser->parser_lex_input)
355 #define lex_lastline (parser->parser_lex_lastline)
356 #define lex_nextline (parser->parser_lex_nextline)
357 #define lex_pbeg (parser->parser_lex_pbeg)
358 #define lex_p (parser->parser_lex_p)
359 #define lex_pend (parser->parser_lex_pend)
360 #define heredoc_end (parser->parser_heredoc_end)
361 #define command_start (parser->parser_command_start)
362 #define deferred_nodes (parser->parser_deferred_nodes)
363 #define lex_gets_ptr (parser->parser_lex_gets_ptr)
364 #define lex_gets (parser->parser_lex_gets)
365 #define lvtbl (parser->parser_lvtbl)
366 #define ruby__end__seen (parser->parser_ruby__end__seen)
367 #define ruby_sourceline (parser->parser_ruby_sourceline)
368 #define ruby_sourcefile (parser->parser_ruby_sourcefile)
369 #define current_enc (parser->enc)
370 #define yydebug (parser->parser_yydebug)
371 #ifdef RIPPER
372 #else
373 #define ruby_eval_tree (parser->parser_eval_tree)
374 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin)
375 #define ruby_debug_lines (parser->debug_lines)
376 #define ruby_coverage (parser->coverage)
377 #endif
378 
379 #if YYPURE
380 static int yylex(void*, void*);
381 #else
382 static int yylex(void*);
383 #endif
384 
385 #ifndef RIPPER
386 #define yyparse ruby_yyparse
387 
388 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
389 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
390 
391 static NODE *cond_gen(struct parser_params*,NODE*);
392 #define cond(node) cond_gen(parser, (node))
393 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
394 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
395 
396 static NODE *newline_node(NODE*);
397 static void fixpos(NODE*,NODE*);
398 
399 static int value_expr_gen(struct parser_params*,NODE*);
400 static void void_expr_gen(struct parser_params*,NODE*);
401 static NODE *remove_begin(NODE*);
402 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
403 #define void_expr0(node) void_expr_gen(parser, (node))
404 #define void_expr(node) void_expr0((node) = remove_begin(node))
405 static void void_stmts_gen(struct parser_params*,NODE*);
406 #define void_stmts(node) void_stmts_gen(parser, (node))
407 static void reduce_nodes_gen(struct parser_params*,NODE**);
408 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
409 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
410 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
411 
412 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
413 #define block_append(h,t) block_append_gen(parser,(h),(t))
414 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
415 #define list_append(l,i) list_append_gen(parser,(l),(i))
416 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
417 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
418 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
419 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
420 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
421 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
422 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
423 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
424 static int literal_concat0(struct parser_params *, VALUE, VALUE);
425 static NODE *new_evstr_gen(struct parser_params*,NODE*);
426 #define new_evstr(n) new_evstr_gen(parser,(n))
427 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
428 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
429 static NODE *splat_array(NODE*);
430 
431 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
432 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
433 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
434 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
435 
436 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,ID);
437 #define new_args(f,o,r,p,b) new_args_gen(parser, (f),(o),(r),(p),(b))
438 
439 static NODE *negate_lit(NODE*);
440 static NODE *ret_args_gen(struct parser_params*,NODE*);
441 #define ret_args(node) ret_args_gen(parser, (node))
442 static NODE *arg_blk_pass(NODE*,NODE*);
443 static NODE *new_yield_gen(struct parser_params*,NODE*);
444 #define new_yield(node) new_yield_gen(parser, (node))
445 
446 static NODE *gettable_gen(struct parser_params*,ID);
447 #define gettable(id) gettable_gen(parser,(id))
448 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
449 #define assignable(id,node) assignable_gen(parser, (id), (node))
450 
451 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
452 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
453 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
454 #define attrset(node,id) attrset_gen(parser, (node), (id))
455 
456 static void rb_backref_error_gen(struct parser_params*,NODE*);
457 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
458 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
459 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
460 
461 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
462 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
463 
464 static ID *local_tbl_gen(struct parser_params*);
465 #define local_tbl() local_tbl_gen(parser)
466 
467 static void fixup_nodes(NODE **);
468 
469 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
470 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
471 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
472 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
473 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
474 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
475 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
476 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
477 
478 #define get_id(id) (id)
479 #define get_value(val) (val)
480 #else
481 #define remove_begin(node) (node)
482 #define rb_dvar_defined(id) 0
483 #define rb_local_defined(id) 0
484 static ID ripper_get_id(VALUE);
485 #define get_id(id) ripper_get_id(id)
486 static VALUE ripper_get_value(VALUE);
487 #define get_value(val) ripper_get_value(val)
488 static VALUE assignable_gen(struct parser_params*,VALUE);
489 #define assignable(lhs,node) assignable_gen(parser, (lhs))
490 static int id_is_var_gen(struct parser_params *parser, ID id);
491 #define id_is_var(id) id_is_var_gen(parser, (id))
492 #endif /* !RIPPER */
493 
494 static ID formal_argument_gen(struct parser_params*, ID);
495 #define formal_argument(id) formal_argument_gen(parser, (id))
496 static ID shadowing_lvar_gen(struct parser_params*,ID);
497 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
498 static void new_bv_gen(struct parser_params*,ID);
499 #define new_bv(id) new_bv_gen(parser, (id))
500 
501 static void local_push_gen(struct parser_params*,int);
502 #define local_push(top) local_push_gen(parser,(top))
503 static void local_pop_gen(struct parser_params*);
504 #define local_pop() local_pop_gen(parser)
505 static int local_var_gen(struct parser_params*, ID);
506 #define local_var(id) local_var_gen(parser, (id));
507 static int arg_var_gen(struct parser_params*, ID);
508 #define arg_var(id) arg_var_gen(parser, (id))
509 static int local_id_gen(struct parser_params*, ID);
510 #define local_id(id) local_id_gen(parser, (id))
511 static ID internal_id_gen(struct parser_params*);
512 #define internal_id() internal_id_gen(parser)
513 
514 static const struct vtable *dyna_push_gen(struct parser_params *);
515 #define dyna_push() dyna_push_gen(parser)
516 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
517 #define dyna_pop(node) dyna_pop_gen(parser, (node))
518 static int dyna_in_block_gen(struct parser_params*);
519 #define dyna_in_block() dyna_in_block_gen(parser)
520 #define dyna_var(id) local_var(id)
521 static int dvar_defined_gen(struct parser_params*,ID,int);
522 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
523 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
524 static int dvar_curr_gen(struct parser_params*,ID);
525 #define dvar_curr(id) dvar_curr_gen(parser, (id))
526 
527 static int lvar_defined_gen(struct parser_params*, ID);
528 #define lvar_defined(id) lvar_defined_gen(parser, (id))
529 
530 #define RE_OPTION_ONCE (1<<16)
531 #define RE_OPTION_ENCODING_SHIFT 8
532 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
533 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
534 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
535 #define RE_OPTION_MASK 0xff
536 #define RE_OPTION_ARG_ENCODING_NONE 32
537 
538 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
539 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
540 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
541 #define nd_func u1.id
542 #if SIZEOF_SHORT == 2
543 #define nd_term(node) ((signed short)(node)->u2.id)
544 #else
545 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
546 #endif
547 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
548 #define nd_nest u3.cnt
549 
550 /****** Ripper *******/
551 
552 #ifdef RIPPER
553 #define RIPPER_VERSION "0.1.0"
554 
555 #include "eventids1.c"
556 #include "eventids2.c"
557 static ID ripper_id_gets;
558 
559 static VALUE ripper_dispatch0(struct parser_params*,ID);
560 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
561 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
562 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
563 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
564 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
565 
566 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
567 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
568 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
569 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
570 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
571 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
572 
573 #define yyparse ripper_yyparse
574 
575 #define ripper_intern(s) ID2SYM(rb_intern(s))
576 static VALUE ripper_id2sym(ID);
577 #ifdef __GNUC__
578 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
579  ID2SYM(id) : ripper_id2sym(id))
580 #endif
581 
582 #define arg_new() dispatch0(args_new)
583 #define arg_add(l,a) dispatch2(args_add, (l), (a))
584 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
585 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
586 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
587 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
588 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
589 
590 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
591 #define mrhs_new() dispatch0(mrhs_new)
592 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
593 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
594 
595 #define mlhs_new() dispatch0(mlhs_new)
596 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
597 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
598 
599 #define params_new(pars, opts, rest, pars2, blk) \
600  dispatch5(params, (pars), (opts), (rest), (pars2), (blk))
601 
602 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
603 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
604 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
605 
606 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
607 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
608 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
609 
610 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
611 
612 #define FIXME 0
613 
614 #endif /* RIPPER */
615 
616 #ifndef RIPPER
617 # define ifndef_ripper(x) (x)
618 #else
619 # define ifndef_ripper(x)
620 #endif
621 
622 #ifndef RIPPER
623 # define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
624 # define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
625 # define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
626 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
627 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
628 #else
629 # define rb_warn0(fmt) ripper_warn0(parser, (fmt))
630 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))
631 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))
632 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
633 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
634 static void ripper_warn0(struct parser_params*, const char*);
635 static void ripper_warnI(struct parser_params*, const char*, int);
636 #if 0
637 static void ripper_warnS(struct parser_params*, const char*, const char*);
638 #endif
639 static void ripper_warning0(struct parser_params*, const char*);
640 static void ripper_warningS(struct parser_params*, const char*, const char*);
641 #endif
642 
643 #ifdef RIPPER
644 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
645 # define rb_compile_error ripper_compile_error
646 # define compile_error ripper_compile_error
647 # define PARSER_ARG parser,
648 #else
649 # define rb_compile_error rb_compile_error_with_enc
650 # define compile_error parser->nerr++,rb_compile_error_with_enc
651 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
652 #endif
653 
654 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
655  for instance). This is too low for Ruby to parse some files, such as
656  date/format.rb, therefore bump the value up to at least Bison's default. */
657 #ifdef OLD_YACC
658 #ifndef YYMAXDEPTH
659 #define YYMAXDEPTH 10000
660 #endif
661 #endif
662 
663 #ifndef RIPPER
664 static void token_info_push(struct parser_params*, const char *token);
665 static void token_info_pop(struct parser_params*, const char *token);
666 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
667 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
668 #else
669 #define token_info_push(token) /* nothing */
670 #define token_info_pop(token) /* nothing */
671 #endif
672 
673 
674 /* Line 268 of yacc.c */
675 #line 676 "parse.c"
676 
677 /* Enabling traces. */
678 #ifndef YYDEBUG
679 # define YYDEBUG 0
680 #endif
681 
682 /* Enabling verbose error messages. */
683 #ifdef YYERROR_VERBOSE
684 # undef YYERROR_VERBOSE
685 # define YYERROR_VERBOSE 1
686 #else
687 # define YYERROR_VERBOSE 0
688 #endif
689 
690 /* Enabling the token table. */
691 #ifndef YYTOKEN_TABLE
692 # define YYTOKEN_TABLE 0
693 #endif
694 
695 
696 /* Tokens. */
697 #ifndef YYTOKENTYPE
698 # define YYTOKENTYPE
699  /* Put the tokens into the symbol table, so that GDB and other debuggers
700  know about them. */
701  enum yytokentype {
702  keyword_class = 258,
703  keyword_module = 259,
704  keyword_def = 260,
705  keyword_undef = 261,
706  keyword_begin = 262,
707  keyword_rescue = 263,
708  keyword_ensure = 264,
709  keyword_end = 265,
710  keyword_if = 266,
711  keyword_unless = 267,
712  keyword_then = 268,
713  keyword_elsif = 269,
714  keyword_else = 270,
715  keyword_case = 271,
716  keyword_when = 272,
717  keyword_while = 273,
718  keyword_until = 274,
719  keyword_for = 275,
720  keyword_break = 276,
721  keyword_next = 277,
722  keyword_redo = 278,
723  keyword_retry = 279,
724  keyword_in = 280,
725  keyword_do = 281,
726  keyword_do_cond = 282,
727  keyword_do_block = 283,
728  keyword_do_LAMBDA = 284,
729  keyword_return = 285,
730  keyword_yield = 286,
731  keyword_super = 287,
732  keyword_self = 288,
733  keyword_nil = 289,
734  keyword_true = 290,
735  keyword_false = 291,
736  keyword_and = 292,
737  keyword_or = 293,
738  keyword_not = 294,
739  modifier_if = 295,
740  modifier_unless = 296,
741  modifier_while = 297,
742  modifier_until = 298,
743  modifier_rescue = 299,
744  keyword_alias = 300,
745  keyword_defined = 301,
746  keyword_BEGIN = 302,
747  keyword_END = 303,
748  keyword__LINE__ = 304,
749  keyword__FILE__ = 305,
750  keyword__ENCODING__ = 306,
751  tIDENTIFIER = 307,
752  tFID = 308,
753  tGVAR = 309,
754  tIVAR = 310,
755  tCONSTANT = 311,
756  tCVAR = 312,
757  tLABEL = 313,
758  tINTEGER = 314,
759  tFLOAT = 315,
760  tSTRING_CONTENT = 316,
761  tCHAR = 317,
762  tNTH_REF = 318,
763  tBACK_REF = 319,
764  tREGEXP_END = 320,
765  tUPLUS = 321,
766  tUMINUS = 322,
767  tPOW = 323,
768  tCMP = 324,
769  tEQ = 325,
770  tEQQ = 326,
771  tNEQ = 327,
772  tGEQ = 328,
773  tLEQ = 329,
774  tANDOP = 330,
775  tOROP = 331,
776  tMATCH = 332,
777  tNMATCH = 333,
778  tDOT2 = 334,
779  tDOT3 = 335,
780  tAREF = 336,
781  tASET = 337,
782  tLSHFT = 338,
783  tRSHFT = 339,
784  tCOLON2 = 340,
785  tCOLON3 = 341,
786  tOP_ASGN = 342,
787  tASSOC = 343,
788  tLPAREN = 344,
789  tLPAREN_ARG = 345,
790  tRPAREN = 346,
791  tLBRACK = 347,
792  tLBRACE = 348,
793  tLBRACE_ARG = 349,
794  tSTAR = 350,
795  tAMPER = 351,
796  tLAMBDA = 352,
797  tSYMBEG = 353,
798  tSTRING_BEG = 354,
799  tXSTRING_BEG = 355,
800  tREGEXP_BEG = 356,
801  tWORDS_BEG = 357,
802  tQWORDS_BEG = 358,
803  tSTRING_DBEG = 359,
804  tSTRING_DVAR = 360,
805  tSTRING_END = 361,
806  tLAMBEG = 362,
807  tLOWEST = 363,
808  tUMINUS_NUM = 364,
809  idNULL = 365,
810  idRespond_to = 366,
811  idIFUNC = 367,
812  idCFUNC = 368,
815  id_core_undef_method = 371,
816  id_core_define_method = 372,
818  id_core_set_postexe = 374,
819  tLAST_TOKEN = 375
820  };
821 #endif
822 
823 
824 
825 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
826 typedef union YYSTYPE
827 {
828 
829 /* Line 293 of yacc.c */
830 #line 620 "parse.y"
831 
832  VALUE val;
833  NODE *node;
834  ID id;
835  int num;
836  const struct vtable *vars;
837 
838 
839 
840 /* Line 293 of yacc.c */
841 #line 842 "parse.c"
842 } YYSTYPE;
843 # define YYSTYPE_IS_TRIVIAL 1
844 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
845 # define YYSTYPE_IS_DECLARED 1
846 #endif
847 
848 
849 /* Copy the second part of user declarations. */
850 
851 
852 /* Line 343 of yacc.c */
853 #line 854 "parse.c"
854 
855 #ifdef short
856 # undef short
857 #endif
858 
859 #ifdef YYTYPE_UINT8
860 typedef YYTYPE_UINT8 yytype_uint8;
861 #else
862 typedef unsigned char yytype_uint8;
863 #endif
864 
865 #ifdef YYTYPE_INT8
866 typedef YYTYPE_INT8 yytype_int8;
867 #elif (defined __STDC__ || defined __C99__FUNC__ \
868  || defined __cplusplus || defined _MSC_VER)
869 typedef signed char yytype_int8;
870 #else
871 typedef short int yytype_int8;
872 #endif
873 
874 #ifdef YYTYPE_UINT16
875 typedef YYTYPE_UINT16 yytype_uint16;
876 #else
877 typedef unsigned short int yytype_uint16;
878 #endif
879 
880 #ifdef YYTYPE_INT16
881 typedef YYTYPE_INT16 yytype_int16;
882 #else
883 typedef short int yytype_int16;
884 #endif
885 
886 #ifndef YYSIZE_T
887 # ifdef __SIZE_TYPE__
888 # define YYSIZE_T __SIZE_TYPE__
889 # elif defined size_t
890 # define YYSIZE_T size_t
891 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
892  || defined __cplusplus || defined _MSC_VER)
893 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
894 # define YYSIZE_T size_t
895 # else
896 # define YYSIZE_T unsigned int
897 # endif
898 #endif
899 
900 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
901 
902 #ifndef YY_
903 # if defined YYENABLE_NLS && YYENABLE_NLS
904 # if ENABLE_NLS
905 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
906 # define YY_(msgid) dgettext ("bison-runtime", msgid)
907 # endif
908 # endif
909 # ifndef YY_
910 # define YY_(msgid) msgid
911 # endif
912 #endif
913 
914 /* Suppress unused-variable warnings by "using" E. */
915 #if ! defined lint || defined __GNUC__
916 # define YYUSE(e) ((void) (e))
917 #else
918 # define YYUSE(e) /* empty */
919 #endif
920 
921 /* Identity function, used to suppress warnings about constant conditions. */
922 #ifndef lint
923 # define YYID(n) (n)
924 #else
925 #if (defined __STDC__ || defined __C99__FUNC__ \
926  || defined __cplusplus || defined _MSC_VER)
927 static int
928 YYID (int yyi)
929 #else
930 static int
931 YYID (yyi)
932  int yyi;
933 #endif
934 {
935  return yyi;
936 }
937 #endif
938 
939 #if ! defined yyoverflow || YYERROR_VERBOSE
940 
941 /* The parser invokes alloca or malloc; define the necessary symbols. */
942 
943 # ifdef YYSTACK_USE_ALLOCA
944 # if YYSTACK_USE_ALLOCA
945 # ifdef __GNUC__
946 # define YYSTACK_ALLOC __builtin_alloca
947 # elif defined __BUILTIN_VA_ARG_INCR
948 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
949 # elif defined _AIX
950 # define YYSTACK_ALLOC __alloca
951 # elif defined _MSC_VER
952 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
953 # define alloca _alloca
954 # else
955 # define YYSTACK_ALLOC alloca
956 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
957  || defined __cplusplus || defined _MSC_VER)
958 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
959 # ifndef EXIT_SUCCESS
960 # define EXIT_SUCCESS 0
961 # endif
962 # endif
963 # endif
964 # endif
965 # endif
966 
967 # ifdef YYSTACK_ALLOC
968  /* Pacify GCC's `empty if-body' warning. */
969 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
970 # ifndef YYSTACK_ALLOC_MAXIMUM
971  /* The OS might guarantee only one guard page at the bottom of the stack,
972  and a page size can be as small as 4096 bytes. So we cannot safely
973  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
974  to allow for a few compiler-allocated temporary stack slots. */
975 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
976 # endif
977 # else
978 # define YYSTACK_ALLOC YYMALLOC
979 # define YYSTACK_FREE YYFREE
980 # ifndef YYSTACK_ALLOC_MAXIMUM
981 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
982 # endif
983 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
984  && ! ((defined YYMALLOC || defined malloc) \
985  && (defined YYFREE || defined free)))
986 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
987 # ifndef EXIT_SUCCESS
988 # define EXIT_SUCCESS 0
989 # endif
990 # endif
991 # ifndef YYMALLOC
992 # define YYMALLOC malloc
993 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
994  || defined __cplusplus || defined _MSC_VER)
995 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
996 # endif
997 # endif
998 # ifndef YYFREE
999 # define YYFREE free
1000 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1001  || defined __cplusplus || defined _MSC_VER)
1002 void free (void *); /* INFRINGES ON USER NAME SPACE */
1003 # endif
1004 # endif
1005 # endif
1006 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1007 
1008 
1009 #if (! defined yyoverflow \
1010  && (! defined __cplusplus \
1011  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1012 
1013 /* A type that is properly aligned for any stack member. */
1014 union yyalloc
1015 {
1018 };
1019 
1020 /* The size of the maximum gap between one aligned stack and the next. */
1021 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1022 
1023 /* The size of an array large to enough to hold all stacks, each with
1024  N elements. */
1025 # define YYSTACK_BYTES(N) \
1026  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1027  + YYSTACK_GAP_MAXIMUM)
1028 
1029 # define YYCOPY_NEEDED 1
1030 
1031 /* Relocate STACK from its old location to the new one. The
1032  local variables YYSIZE and YYSTACKSIZE give the old and new number of
1033  elements in the stack, and YYPTR gives the new location of the
1034  stack. Advance YYPTR to a properly aligned location for the next
1035  stack. */
1036 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1037  do \
1038  { \
1039  YYSIZE_T yynewbytes; \
1040  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1041  Stack = &yyptr->Stack_alloc; \
1042  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1043  yyptr += yynewbytes / sizeof (*yyptr); \
1044  } \
1045  while (YYID (0))
1046 
1047 #endif
1048 
1049 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1050 /* Copy COUNT objects from FROM to TO. The source and destination do
1051  not overlap. */
1052 # ifndef YYCOPY
1053 # if defined __GNUC__ && 1 < __GNUC__
1054 # define YYCOPY(To, From, Count) \
1055  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1056 # else
1057 # define YYCOPY(To, From, Count) \
1058  do \
1059  { \
1060  YYSIZE_T yyi; \
1061  for (yyi = 0; yyi < (Count); yyi++) \
1062  (To)[yyi] = (From)[yyi]; \
1063  } \
1064  while (YYID (0))
1065 # endif
1066 # endif
1067 #endif /* !YYCOPY_NEEDED */
1068 
1069 /* YYFINAL -- State number of the termination state. */
1070 #define YYFINAL 3
1071 /* YYLAST -- Last index in YYTABLE. */
1072 #define YYLAST 10748
1073 
1074 /* YYNTOKENS -- Number of terminals. */
1075 #define YYNTOKENS 148
1076 /* YYNNTS -- Number of nonterminals. */
1077 #define YYNNTS 174
1078 /* YYNRULES -- Number of rules. */
1079 #define YYNRULES 573
1080 /* YYNRULES -- Number of states. */
1081 #define YYNSTATES 991
1082 
1083 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1084 #define YYUNDEFTOK 2
1085 #define YYMAXUTOK 375
1086 
1087 #define YYTRANSLATE(YYX) \
1088  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1089 
1090 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1091 static const yytype_uint8 yytranslate[] =
1092 {
1093  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1094  147, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1095  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1096  2, 2, 146, 123, 2, 2, 2, 121, 116, 2,
1097  142, 143, 119, 117, 140, 118, 139, 120, 2, 2,
1098  2, 2, 2, 2, 2, 2, 2, 2, 111, 145,
1099  113, 109, 112, 110, 2, 2, 2, 2, 2, 2,
1100  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1101  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1102  2, 138, 2, 144, 115, 2, 141, 2, 2, 2,
1103  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1104  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1105  2, 2, 2, 136, 114, 137, 124, 2, 2, 2,
1106  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1107  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1108  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1109  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1110  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1111  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1112  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1113  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1114  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1115  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1116  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1117  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1118  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1119  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1120  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1121  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1122  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1123  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1124  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1125  65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1126  75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
1127  85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
1128  95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
1129  105, 106, 107, 108, 122, 125, 126, 127, 128, 129,
1130  130, 131, 132, 133, 134, 135
1131 };
1132 
1133 #if YYDEBUG
1134 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1135  YYRHS. */
1136 static const yytype_uint16 yyprhs[] =
1137 {
1138  0, 0, 3, 4, 7, 10, 12, 14, 18, 21,
1139  23, 24, 30, 35, 38, 40, 42, 46, 49, 50,
1140  55, 59, 63, 67, 70, 74, 78, 82, 86, 90,
1141  95, 97, 101, 105, 112, 118, 124, 130, 136, 140,
1142  144, 148, 152, 154, 158, 162, 164, 168, 172, 176,
1143  179, 181, 183, 185, 187, 189, 194, 199, 200, 206,
1144  209, 213, 218, 224, 229, 235, 238, 241, 244, 247,
1145  250, 252, 256, 258, 262, 264, 267, 271, 277, 280,
1146  285, 288, 293, 295, 299, 301, 305, 308, 312, 314,
1147  318, 320, 322, 327, 331, 335, 339, 343, 346, 348,
1148  350, 352, 357, 361, 365, 369, 373, 376, 378, 380,
1149  382, 385, 387, 391, 393, 395, 397, 399, 401, 403,
1150  405, 407, 409, 411, 412, 417, 419, 421, 423, 425,
1151  427, 429, 431, 433, 435, 437, 439, 441, 443, 445,
1152  447, 449, 451, 453, 455, 457, 459, 461, 463, 465,
1153  467, 469, 471, 473, 475, 477, 479, 481, 483, 485,
1154  487, 489, 491, 493, 495, 497, 499, 501, 503, 505,
1155  507, 509, 511, 513, 515, 517, 519, 521, 523, 525,
1156  527, 529, 531, 533, 535, 537, 539, 541, 543, 545,
1157  547, 549, 551, 553, 555, 557, 561, 567, 571, 577,
1158  584, 590, 596, 602, 608, 613, 617, 621, 625, 629,
1159  633, 637, 641, 645, 649, 654, 659, 662, 665, 669,
1160  673, 677, 681, 685, 689, 693, 697, 701, 705, 709,
1161  713, 717, 720, 723, 727, 731, 735, 739, 740, 745,
1162  752, 754, 756, 758, 761, 766, 769, 773, 775, 777,
1163  779, 781, 784, 789, 792, 794, 797, 800, 805, 807,
1164  808, 811, 814, 817, 819, 821, 824, 828, 833, 837,
1165  842, 845, 847, 849, 851, 853, 855, 857, 859, 861,
1166  863, 864, 869, 870, 875, 879, 883, 886, 890, 894,
1167  896, 901, 905, 907, 908, 915, 920, 924, 927, 929,
1168  932, 935, 942, 949, 950, 951, 959, 960, 961, 969,
1169  975, 980, 981, 982, 992, 993, 1000, 1001, 1002, 1011,
1170  1012, 1018, 1019, 1026, 1027, 1028, 1038, 1040, 1042, 1044,
1171  1046, 1048, 1050, 1052, 1054, 1056, 1058, 1060, 1062, 1064,
1172  1066, 1068, 1070, 1072, 1074, 1077, 1079, 1081, 1083, 1089,
1173  1091, 1094, 1096, 1098, 1100, 1104, 1106, 1110, 1112, 1117,
1174  1124, 1128, 1134, 1137, 1142, 1144, 1148, 1155, 1164, 1169,
1175  1176, 1181, 1184, 1191, 1194, 1199, 1206, 1209, 1214, 1217,
1176  1222, 1224, 1226, 1228, 1232, 1234, 1239, 1241, 1244, 1246,
1177  1250, 1252, 1254, 1255, 1256, 1261, 1266, 1268, 1272, 1276,
1178  1277, 1283, 1286, 1291, 1296, 1299, 1304, 1309, 1313, 1317,
1179  1321, 1324, 1326, 1331, 1332, 1338, 1339, 1345, 1351, 1353,
1180  1355, 1362, 1364, 1366, 1368, 1370, 1373, 1375, 1378, 1380,
1181  1382, 1384, 1386, 1388, 1390, 1392, 1395, 1399, 1403, 1407,
1182  1411, 1415, 1416, 1420, 1422, 1425, 1429, 1433, 1434, 1438,
1183  1439, 1442, 1443, 1446, 1447, 1450, 1452, 1453, 1457, 1458,
1184  1459, 1465, 1467, 1469, 1471, 1473, 1476, 1478, 1480, 1482,
1185  1484, 1488, 1490, 1492, 1495, 1498, 1500, 1502, 1504, 1506,
1186  1508, 1510, 1512, 1514, 1516, 1518, 1520, 1522, 1524, 1526,
1187  1528, 1530, 1532, 1534, 1536, 1537, 1542, 1545, 1549, 1552,
1188  1559, 1568, 1573, 1580, 1585, 1592, 1595, 1600, 1607, 1610,
1189  1615, 1618, 1623, 1625, 1626, 1628, 1630, 1632, 1634, 1636,
1190  1638, 1640, 1644, 1646, 1650, 1654, 1658, 1660, 1664, 1666,
1191  1670, 1672, 1674, 1677, 1679, 1681, 1683, 1686, 1689, 1691,
1192  1693, 1694, 1699, 1701, 1704, 1706, 1710, 1714, 1717, 1719,
1193  1721, 1723, 1725, 1727, 1729, 1731, 1733, 1735, 1737, 1739,
1194  1741, 1742, 1744, 1745, 1747, 1750, 1753, 1754, 1756, 1758,
1195  1760, 1762, 1764, 1767
1196 };
1197 
1198 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1199 static const yytype_int16 yyrhs[] =
1200 {
1201  149, 0, -1, -1, 150, 151, -1, 152, 314, -1,
1202  321, -1, 153, -1, 152, 320, 153, -1, 1, 153,
1203  -1, 158, -1, -1, 47, 154, 136, 151, 137, -1,
1204  156, 256, 231, 259, -1, 157, 314, -1, 321, -1,
1205  158, -1, 157, 320, 158, -1, 1, 158, -1, -1,
1206  45, 180, 159, 180, -1, 45, 54, 54, -1, 45,
1207  54, 64, -1, 45, 54, 63, -1, 6, 181, -1,
1208  158, 40, 162, -1, 158, 41, 162, -1, 158, 42,
1209  162, -1, 158, 43, 162, -1, 158, 44, 158, -1,
1210  48, 136, 156, 137, -1, 160, -1, 168, 109, 163,
1211  -1, 286, 87, 163, -1, 216, 138, 191, 317, 87,
1212  163, -1, 216, 139, 52, 87, 163, -1, 216, 139,
1213  56, 87, 163, -1, 216, 85, 56, 87, 163, -1,
1214  216, 85, 52, 87, 163, -1, 287, 87, 163, -1,
1215  175, 109, 198, -1, 168, 109, 187, -1, 168, 109,
1216  198, -1, 161, -1, 175, 109, 163, -1, 175, 109,
1217  160, -1, 163, -1, 161, 37, 161, -1, 161, 38,
1218  161, -1, 39, 315, 161, -1, 123, 163, -1, 185,
1219  -1, 161, -1, 167, -1, 164, -1, 249, -1, 249,
1220  139, 311, 193, -1, 249, 85, 311, 193, -1, -1,
1221  94, 166, 237, 156, 137, -1, 310, 193, -1, 310,
1222  193, 165, -1, 216, 139, 311, 193, -1, 216, 139,
1223  311, 193, 165, -1, 216, 85, 311, 193, -1, 216,
1224  85, 311, 193, 165, -1, 32, 193, -1, 31, 193,
1225  -1, 30, 192, -1, 21, 192, -1, 22, 192, -1,
1226  170, -1, 89, 169, 316, -1, 170, -1, 89, 169,
1227  316, -1, 172, -1, 172, 171, -1, 172, 95, 174,
1228  -1, 172, 95, 174, 140, 173, -1, 172, 95, -1,
1229  172, 95, 140, 173, -1, 95, 174, -1, 95, 174,
1230  140, 173, -1, 95, -1, 95, 140, 173, -1, 174,
1231  -1, 89, 169, 316, -1, 171, 140, -1, 172, 171,
1232  140, -1, 171, -1, 173, 140, 171, -1, 283, -1,
1233  284, -1, 216, 138, 191, 317, -1, 216, 139, 52,
1234  -1, 216, 85, 52, -1, 216, 139, 56, -1, 216,
1235  85, 56, -1, 86, 56, -1, 287, -1, 283, -1,
1236  284, -1, 216, 138, 191, 317, -1, 216, 139, 52,
1237  -1, 216, 85, 52, -1, 216, 139, 56, -1, 216,
1238  85, 56, -1, 86, 56, -1, 287, -1, 52, -1,
1239  56, -1, 86, 176, -1, 176, -1, 216, 85, 176,
1240  -1, 52, -1, 56, -1, 53, -1, 183, -1, 184,
1241  -1, 178, -1, 279, -1, 179, -1, 281, -1, 180,
1242  -1, -1, 181, 140, 182, 180, -1, 114, -1, 115,
1243  -1, 116, -1, 69, -1, 70, -1, 71, -1, 77,
1244  -1, 78, -1, 112, -1, 73, -1, 113, -1, 74,
1245  -1, 72, -1, 83, -1, 84, -1, 117, -1, 118,
1246  -1, 119, -1, 95, -1, 120, -1, 121, -1, 68,
1247  -1, 123, -1, 124, -1, 66, -1, 67, -1, 81,
1248  -1, 82, -1, 141, -1, 49, -1, 50, -1, 51,
1249  -1, 47, -1, 48, -1, 45, -1, 37, -1, 7,
1250  -1, 21, -1, 16, -1, 3, -1, 5, -1, 46,
1251  -1, 26, -1, 15, -1, 14, -1, 10, -1, 9,
1252  -1, 36, -1, 20, -1, 25, -1, 4, -1, 22,
1253  -1, 34, -1, 39, -1, 38, -1, 23, -1, 8,
1254  -1, 24, -1, 30, -1, 33, -1, 32, -1, 13,
1255  -1, 35, -1, 6, -1, 17, -1, 31, -1, 11,
1256  -1, 12, -1, 18, -1, 19, -1, 175, 109, 185,
1257  -1, 175, 109, 185, 44, 185, -1, 286, 87, 185,
1258  -1, 286, 87, 185, 44, 185, -1, 216, 138, 191,
1259  317, 87, 185, -1, 216, 139, 52, 87, 185, -1,
1260  216, 139, 56, 87, 185, -1, 216, 85, 52, 87,
1261  185, -1, 216, 85, 56, 87, 185, -1, 86, 56,
1262  87, 185, -1, 287, 87, 185, -1, 185, 79, 185,
1263  -1, 185, 80, 185, -1, 185, 117, 185, -1, 185,
1264  118, 185, -1, 185, 119, 185, -1, 185, 120, 185,
1265  -1, 185, 121, 185, -1, 185, 68, 185, -1, 122,
1266  59, 68, 185, -1, 122, 60, 68, 185, -1, 66,
1267  185, -1, 67, 185, -1, 185, 114, 185, -1, 185,
1268  115, 185, -1, 185, 116, 185, -1, 185, 69, 185,
1269  -1, 185, 112, 185, -1, 185, 73, 185, -1, 185,
1270  113, 185, -1, 185, 74, 185, -1, 185, 70, 185,
1271  -1, 185, 71, 185, -1, 185, 72, 185, -1, 185,
1272  77, 185, -1, 185, 78, 185, -1, 123, 185, -1,
1273  124, 185, -1, 185, 83, 185, -1, 185, 84, 185,
1274  -1, 185, 75, 185, -1, 185, 76, 185, -1, -1,
1275  46, 315, 186, 185, -1, 185, 110, 185, 315, 111,
1276  185, -1, 199, -1, 185, -1, 321, -1, 197, 318,
1277  -1, 197, 140, 308, 318, -1, 308, 318, -1, 142,
1278  191, 316, -1, 321, -1, 189, -1, 321, -1, 192,
1279  -1, 197, 140, -1, 197, 140, 308, 140, -1, 308,
1280  140, -1, 167, -1, 197, 196, -1, 308, 196, -1,
1281  197, 140, 308, 196, -1, 195, -1, -1, 194, 192,
1282  -1, 96, 187, -1, 140, 195, -1, 321, -1, 187,
1283  -1, 95, 187, -1, 197, 140, 187, -1, 197, 140,
1284  95, 187, -1, 197, 140, 187, -1, 197, 140, 95,
1285  187, -1, 95, 187, -1, 260, -1, 261, -1, 264,
1286  -1, 265, -1, 266, -1, 269, -1, 285, -1, 287,
1287  -1, 53, -1, -1, 217, 200, 155, 227, -1, -1,
1288  90, 161, 201, 316, -1, 89, 156, 143, -1, 216,
1289  85, 56, -1, 86, 56, -1, 92, 188, 144, -1,
1290  93, 307, 137, -1, 30, -1, 31, 142, 192, 316,
1291  -1, 31, 142, 316, -1, 31, -1, -1, 46, 315,
1292  142, 202, 161, 316, -1, 39, 142, 161, 316, -1,
1293  39, 142, 316, -1, 310, 251, -1, 250, -1, 250,
1294  251, -1, 97, 242, -1, 218, 162, 228, 156, 230,
1295  227, -1, 219, 162, 228, 156, 231, 227, -1, -1,
1296  -1, 220, 203, 162, 229, 204, 156, 227, -1, -1,
1297  -1, 221, 205, 162, 229, 206, 156, 227, -1, 222,
1298  162, 314, 254, 227, -1, 222, 314, 254, 227, -1,
1299  -1, -1, 223, 232, 25, 207, 162, 229, 208, 156,
1300  227, -1, -1, 224, 177, 288, 209, 155, 227, -1,
1301  -1, -1, 224, 83, 161, 210, 319, 211, 155, 227,
1302  -1, -1, 225, 177, 212, 155, 227, -1, -1, 226,
1303  178, 213, 290, 155, 227, -1, -1, -1, 226, 305,
1304  313, 214, 178, 215, 290, 155, 227, -1, 21, -1,
1305  22, -1, 23, -1, 24, -1, 199, -1, 7, -1,
1306  11, -1, 12, -1, 18, -1, 19, -1, 16, -1,
1307  20, -1, 3, -1, 4, -1, 5, -1, 10, -1,
1308  319, -1, 13, -1, 319, 13, -1, 319, -1, 27,
1309  -1, 231, -1, 14, 162, 228, 156, 230, -1, 321,
1310  -1, 15, 156, -1, 175, -1, 168, -1, 293, -1,
1311  89, 235, 316, -1, 233, -1, 234, 140, 233, -1,
1312  234, -1, 234, 140, 95, 293, -1, 234, 140, 95,
1313  293, 140, 234, -1, 234, 140, 95, -1, 234, 140,
1314  95, 140, 234, -1, 95, 293, -1, 95, 293, 140,
1315  234, -1, 95, -1, 95, 140, 234, -1, 295, 140,
1316  298, 140, 301, 304, -1, 295, 140, 298, 140, 301,
1317  140, 295, 304, -1, 295, 140, 298, 304, -1, 295,
1318  140, 298, 140, 295, 304, -1, 295, 140, 301, 304,
1319  -1, 295, 140, -1, 295, 140, 301, 140, 295, 304,
1320  -1, 295, 304, -1, 298, 140, 301, 304, -1, 298,
1321  140, 301, 140, 295, 304, -1, 298, 304, -1, 298,
1322  140, 295, 304, -1, 301, 304, -1, 301, 140, 295,
1323  304, -1, 303, -1, 321, -1, 238, -1, 114, 239,
1324  114, -1, 76, -1, 114, 236, 239, 114, -1, 321,
1325  -1, 145, 240, -1, 241, -1, 240, 140, 241, -1,
1326  52, -1, 292, -1, -1, -1, 243, 244, 245, 246,
1327  -1, 142, 291, 239, 316, -1, 291, -1, 107, 156,
1328  137, -1, 29, 156, 10, -1, -1, 28, 248, 237,
1329  156, 10, -1, 167, 247, -1, 249, 139, 311, 190,
1330  -1, 249, 85, 311, 190, -1, 310, 189, -1, 216,
1331  139, 311, 190, -1, 216, 85, 311, 189, -1, 216,
1332  85, 312, -1, 216, 139, 189, -1, 216, 85, 189,
1333  -1, 32, 189, -1, 32, -1, 216, 138, 191, 317,
1334  -1, -1, 136, 252, 237, 156, 137, -1, -1, 26,
1335  253, 237, 156, 10, -1, 17, 197, 228, 156, 255,
1336  -1, 231, -1, 254, -1, 8, 257, 258, 228, 156,
1337  256, -1, 321, -1, 187, -1, 198, -1, 321, -1,
1338  88, 175, -1, 321, -1, 9, 156, -1, 321, -1,
1339  282, -1, 279, -1, 281, -1, 262, -1, 62, -1,
1340  263, -1, 262, 263, -1, 99, 271, 106, -1, 100,
1341  272, 106, -1, 101, 273, 65, -1, 102, 146, 106,
1342  -1, 102, 267, 106, -1, -1, 267, 268, 146, -1,
1343  274, -1, 268, 274, -1, 103, 146, 106, -1, 103,
1344  270, 106, -1, -1, 270, 61, 146, -1, -1, 271,
1345  274, -1, -1, 272, 274, -1, -1, 273, 274, -1,
1346  61, -1, -1, 105, 275, 278, -1, -1, -1, 104,
1347  276, 277, 156, 137, -1, 54, -1, 55, -1, 57,
1348  -1, 287, -1, 98, 280, -1, 178, -1, 55, -1,
1349  54, -1, 57, -1, 98, 272, 106, -1, 59, -1,
1350  60, -1, 122, 59, -1, 122, 60, -1, 52, -1,
1351  55, -1, 54, -1, 56, -1, 57, -1, 34, -1,
1352  33, -1, 35, -1, 36, -1, 50, -1, 49, -1,
1353  51, -1, 283, -1, 284, -1, 283, -1, 284, -1,
1354  63, -1, 64, -1, 319, -1, -1, 113, 289, 162,
1355  319, -1, 1, 319, -1, 142, 291, 316, -1, 291,
1356  319, -1, 295, 140, 299, 140, 301, 304, -1, 295,
1357  140, 299, 140, 301, 140, 295, 304, -1, 295, 140,
1358  299, 304, -1, 295, 140, 299, 140, 295, 304, -1,
1359  295, 140, 301, 304, -1, 295, 140, 301, 140, 295,
1360  304, -1, 295, 304, -1, 299, 140, 301, 304, -1,
1361  299, 140, 301, 140, 295, 304, -1, 299, 304, -1,
1362  299, 140, 295, 304, -1, 301, 304, -1, 301, 140,
1363  295, 304, -1, 303, -1, -1, 56, -1, 55, -1,
1364  54, -1, 57, -1, 292, -1, 52, -1, 293, -1,
1365  89, 235, 316, -1, 294, -1, 295, 140, 294, -1,
1366  52, 109, 187, -1, 52, 109, 216, -1, 297, -1,
1367  298, 140, 297, -1, 296, -1, 299, 140, 296, -1,
1368  119, -1, 95, -1, 300, 52, -1, 300, -1, 116,
1369  -1, 96, -1, 302, 52, -1, 140, 303, -1, 321,
1370  -1, 285, -1, -1, 142, 306, 161, 316, -1, 321,
1371  -1, 308, 318, -1, 309, -1, 308, 140, 309, -1,
1372  187, 88, 187, -1, 58, 187, -1, 52, -1, 56,
1373  -1, 53, -1, 52, -1, 56, -1, 53, -1, 183,
1374  -1, 52, -1, 53, -1, 183, -1, 139, -1, 85,
1375  -1, -1, 320, -1, -1, 147, -1, 315, 143, -1,
1376  315, 144, -1, -1, 147, -1, 140, -1, 145, -1,
1377  147, -1, 319, -1, 320, 145, -1, -1
1378 };
1379 
1380 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1381 static const yytype_uint16 yyrline[] =
1382 {
1383  0, 786, 786, 786, 817, 828, 837, 845, 853, 859,
1384  861, 860, 884, 917, 928, 937, 945, 953, 959, 959,
1385  967, 975, 986, 996, 1004, 1013, 1022, 1035, 1048, 1057,
1386  1069, 1070, 1080, 1109, 1130, 1147, 1164, 1175, 1192, 1202,
1387  1211, 1220, 1229, 1232, 1241, 1253, 1254, 1262, 1270, 1278,
1388  1286, 1289, 1301, 1302, 1305, 1306, 1315, 1327, 1326, 1348,
1389  1357, 1369, 1378, 1390, 1399, 1411, 1420, 1429, 1437, 1445,
1390  1455, 1456, 1466, 1467, 1477, 1485, 1493, 1501, 1510, 1518,
1391  1527, 1535, 1544, 1552, 1563, 1564, 1574, 1582, 1592, 1600,
1392  1610, 1614, 1618, 1626, 1634, 1642, 1650, 1662, 1672, 1684,
1393  1693, 1702, 1710, 1718, 1726, 1734, 1747, 1760, 1771, 1779,
1394  1782, 1790, 1798, 1808, 1809, 1810, 1811, 1816, 1827, 1828,
1395  1831, 1839, 1842, 1850, 1850, 1860, 1861, 1862, 1863, 1864,
1396  1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874,
1397  1875, 1876, 1877, 1878, 1879, 1880, 1881, 1882, 1883, 1884,
1398  1885, 1886, 1887, 1888, 1891, 1891, 1891, 1892, 1892, 1893,
1399  1893, 1893, 1894, 1894, 1894, 1894, 1895, 1895, 1895, 1895,
1400  1896, 1896, 1896, 1897, 1897, 1897, 1897, 1898, 1898, 1898,
1401  1898, 1899, 1899, 1899, 1899, 1900, 1900, 1900, 1900, 1901,
1402  1901, 1901, 1901, 1902, 1902, 1905, 1914, 1924, 1953, 1984,
1403  2010, 2027, 2044, 2061, 2072, 2083, 2094, 2108, 2122, 2130,
1404  2138, 2146, 2154, 2162, 2170, 2179, 2188, 2196, 2204, 2212,
1405  2220, 2228, 2236, 2244, 2252, 2260, 2268, 2276, 2284, 2292,
1406  2303, 2311, 2319, 2327, 2335, 2343, 2351, 2359, 2359, 2369,
1407  2379, 2385, 2397, 2398, 2402, 2410, 2420, 2430, 2431, 2434,
1408  2435, 2436, 2440, 2448, 2458, 2467, 2475, 2485, 2494, 2503,
1409  2503, 2515, 2525, 2529, 2535, 2543, 2551, 2565, 2581, 2595,
1410  2610, 2620, 2621, 2622, 2623, 2624, 2625, 2626, 2627, 2628,
1411  2637, 2636, 2661, 2661, 2670, 2678, 2686, 2694, 2707, 2715,
1412  2723, 2731, 2739, 2747, 2747, 2757, 2765, 2773, 2784, 2785,
1413  2796, 2800, 2812, 2824, 2824, 2824, 2835, 2835, 2835, 2846,
1414  2857, 2866, 2868, 2865, 2932, 2931, 2953, 2958, 2952, 2977,
1415  2976, 2998, 2997, 3020, 3021, 3020, 3041, 3049, 3057, 3065,
1416  3075, 3087, 3093, 3099, 3105, 3111, 3117, 3123, 3129, 3135,
1417  3141, 3151, 3157, 3162, 3163, 3170, 3175, 3178, 3179, 3192,
1418  3193, 3203, 3204, 3207, 3215, 3225, 3233, 3243, 3251, 3260,
1419  3269, 3277, 3285, 3294, 3306, 3314, 3324, 3332, 3340, 3348,
1420  3356, 3364, 3373, 3381, 3389, 3397, 3405, 3413, 3421, 3429,
1421  3437, 3447, 3448, 3454, 3463, 3472, 3483, 3484, 3494, 3501,
1422  3510, 3518, 3524, 3527, 3524, 3545, 3553, 3563, 3567, 3574,
1423  3573, 3594, 3610, 3619, 3630, 3639, 3649, 3659, 3667, 3678,
1424  3689, 3697, 3705, 3720, 3719, 3739, 3738, 3759, 3771, 3772,
1425  3775, 3794, 3797, 3805, 3813, 3816, 3820, 3823, 3831, 3834,
1426  3835, 3843, 3846, 3863, 3864, 3865, 3875, 3885, 3912, 3977,
1427  3986, 3997, 4004, 4014, 4022, 4032, 4041, 4052, 4059, 4070,
1428  4077, 4088, 4095, 4106, 4113, 4142, 4144, 4143, 4160, 4166,
1429  4159, 4185, 4193, 4201, 4209, 4212, 4223, 4224, 4225, 4226,
1430  4229, 4259, 4260, 4261, 4269, 4279, 4280, 4281, 4282, 4283,
1431  4286, 4287, 4288, 4289, 4290, 4291, 4292, 4295, 4308, 4318,
1432  4326, 4336, 4337, 4340, 4349, 4348, 4356, 4368, 4378, 4386,
1433  4394, 4402, 4410, 4418, 4426, 4434, 4442, 4450, 4458, 4466,
1434  4474, 4482, 4490, 4499, 4508, 4517, 4526, 4535, 4546, 4547,
1435  4554, 4563, 4582, 4589, 4602, 4614, 4626, 4634, 4650, 4658,
1436  4674, 4675, 4678, 4691, 4702, 4703, 4706, 4723, 4727, 4737,
1437  4747, 4747, 4776, 4777, 4787, 4794, 4804, 4812, 4822, 4823,
1438  4824, 4827, 4828, 4829, 4830, 4833, 4834, 4835, 4838, 4843,
1439  4850, 4851, 4854, 4855, 4858, 4861, 4864, 4865, 4866, 4869,
1440  4870, 4873, 4874, 4878
1441 };
1442 #endif
1443 
1444 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1445 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1446  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1447 static const char *const yytname[] =
1448 {
1449  "$end", "error", "$undefined", "keyword_class", "keyword_module",
1450  "keyword_def", "keyword_undef", "keyword_begin", "keyword_rescue",
1451  "keyword_ensure", "keyword_end", "keyword_if", "keyword_unless",
1452  "keyword_then", "keyword_elsif", "keyword_else", "keyword_case",
1453  "keyword_when", "keyword_while", "keyword_until", "keyword_for",
1454  "keyword_break", "keyword_next", "keyword_redo", "keyword_retry",
1455  "keyword_in", "keyword_do", "keyword_do_cond", "keyword_do_block",
1456  "keyword_do_LAMBDA", "keyword_return", "keyword_yield", "keyword_super",
1457  "keyword_self", "keyword_nil", "keyword_true", "keyword_false",
1458  "keyword_and", "keyword_or", "keyword_not", "modifier_if",
1459  "modifier_unless", "modifier_while", "modifier_until", "modifier_rescue",
1460  "keyword_alias", "keyword_defined", "keyword_BEGIN", "keyword_END",
1461  "keyword__LINE__", "keyword__FILE__", "keyword__ENCODING__",
1462  "tIDENTIFIER", "tFID", "tGVAR", "tIVAR", "tCONSTANT", "tCVAR", "tLABEL",
1463  "tINTEGER", "tFLOAT", "tSTRING_CONTENT", "tCHAR", "tNTH_REF",
1464  "tBACK_REF", "tREGEXP_END", "tUPLUS", "tUMINUS", "tPOW", "tCMP", "tEQ",
1465  "tEQQ", "tNEQ", "tGEQ", "tLEQ", "tANDOP", "tOROP", "tMATCH", "tNMATCH",
1466  "tDOT2", "tDOT3", "tAREF", "tASET", "tLSHFT", "tRSHFT", "tCOLON2",
1467  "tCOLON3", "tOP_ASGN", "tASSOC", "tLPAREN", "tLPAREN_ARG", "tRPAREN",
1468  "tLBRACK", "tLBRACE", "tLBRACE_ARG", "tSTAR", "tAMPER", "tLAMBDA",
1469  "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG", "tWORDS_BEG",
1470  "tQWORDS_BEG", "tSTRING_DBEG", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
1471  "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
1472  "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "idNULL",
1473  "idRespond_to", "idIFUNC", "idCFUNC", "id_core_set_method_alias",
1474  "id_core_set_variable_alias", "id_core_undef_method",
1475  "id_core_define_method", "id_core_define_singleton_method",
1476  "id_core_set_postexe", "tLAST_TOKEN", "'{'", "'}'", "'['", "'.'", "','",
1477  "'`'", "'('", "')'", "']'", "';'", "' '", "'\\n'", "$accept", "program",
1478  "$@1", "top_compstmt", "top_stmts", "top_stmt", "$@2", "bodystmt",
1479  "compstmt", "stmts", "stmt", "$@3", "command_asgn", "expr", "expr_value",
1480  "command_call", "block_command", "cmd_brace_block", "@4", "command",
1481  "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head",
1482  "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
1483  "fitem", "undef_list", "$@5", "op", "reswords", "arg", "$@6",
1484  "arg_value", "aref_args", "paren_args", "opt_paren_args",
1485  "opt_call_args", "call_args", "command_args", "@7", "block_arg",
1486  "opt_block_arg", "args", "mrhs", "primary", "@8", "$@9", "$@10", "$@11",
1487  "$@12", "$@13", "$@14", "$@15", "$@16", "@17", "@18", "@19", "@20",
1488  "@21", "$@22", "$@23", "primary_value", "k_begin", "k_if", "k_unless",
1489  "k_while", "k_until", "k_case", "k_for", "k_class", "k_module", "k_def",
1490  "k_end", "then", "do", "if_tail", "opt_else", "for_var", "f_marg",
1491  "f_marg_list", "f_margs", "block_param", "opt_block_param",
1492  "block_param_def", "opt_bv_decl", "bv_decls", "bvar", "lambda", "@24",
1493  "@25", "f_larglist", "lambda_body", "do_block", "@26", "block_call",
1494  "method_call", "brace_block", "@27", "@28", "case_body", "cases",
1495  "opt_rescue", "exc_list", "exc_var", "opt_ensure", "literal", "strings",
1496  "string", "string1", "xstring", "regexp", "words", "word_list", "word",
1497  "qwords", "qword_list", "string_contents", "xstring_contents",
1498  "regexp_contents", "string_content", "@29", "@30", "@31", "string_dvar",
1499  "symbol", "sym", "dsym", "numeric", "user_variable", "keyword_variable",
1500  "var_ref", "var_lhs", "backref", "superclass", "$@32", "f_arglist",
1501  "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_opt",
1502  "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
1503  "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
1504  "singleton", "$@33", "assoc_list", "assocs", "assoc", "operation",
1505  "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
1506  "rparen", "rbracket", "trailer", "term", "terms", "none", 0
1507 };
1508 #endif
1509 
1510 # ifdef YYPRINT
1511 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1512  token YYLEX-NUM. */
1513 static const yytype_uint16 yytoknum[] =
1514 {
1515  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1516  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1517  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1518  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1519  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1520  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1521  315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
1522  325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
1523  335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
1524  345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1525  355, 356, 357, 358, 359, 360, 361, 362, 363, 61,
1526  63, 58, 62, 60, 124, 94, 38, 43, 45, 42,
1527  47, 37, 364, 33, 126, 365, 366, 367, 368, 369,
1528  370, 371, 372, 373, 374, 375, 123, 125, 91, 46,
1529  44, 96, 40, 41, 93, 59, 32, 10
1530 };
1531 # endif
1532 
1533 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1534 static const yytype_uint16 yyr1[] =
1535 {
1536  0, 148, 150, 149, 151, 152, 152, 152, 152, 153,
1537  154, 153, 155, 156, 157, 157, 157, 157, 159, 158,
1538  158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
1539  158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
1540  158, 158, 158, 160, 160, 161, 161, 161, 161, 161,
1541  161, 162, 163, 163, 164, 164, 164, 166, 165, 167,
1542  167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
1543  168, 168, 169, 169, 170, 170, 170, 170, 170, 170,
1544  170, 170, 170, 170, 171, 171, 172, 172, 173, 173,
1545  174, 174, 174, 174, 174, 174, 174, 174, 174, 175,
1546  175, 175, 175, 175, 175, 175, 175, 175, 176, 176,
1547  177, 177, 177, 178, 178, 178, 178, 178, 179, 179,
1548  180, 180, 181, 182, 181, 183, 183, 183, 183, 183,
1549  183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
1550  183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
1551  183, 183, 183, 183, 184, 184, 184, 184, 184, 184,
1552  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1553  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1554  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1555  184, 184, 184, 184, 184, 185, 185, 185, 185, 185,
1556  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
1557  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
1558  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
1559  185, 185, 185, 185, 185, 185, 185, 186, 185, 185,
1560  185, 187, 188, 188, 188, 188, 189, 190, 190, 191,
1561  191, 191, 191, 191, 192, 192, 192, 192, 192, 194,
1562  193, 195, 196, 196, 197, 197, 197, 197, 198, 198,
1563  198, 199, 199, 199, 199, 199, 199, 199, 199, 199,
1564  200, 199, 201, 199, 199, 199, 199, 199, 199, 199,
1565  199, 199, 199, 202, 199, 199, 199, 199, 199, 199,
1566  199, 199, 199, 203, 204, 199, 205, 206, 199, 199,
1567  199, 207, 208, 199, 209, 199, 210, 211, 199, 212,
1568  199, 213, 199, 214, 215, 199, 199, 199, 199, 199,
1569  216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1570  226, 227, 228, 228, 228, 229, 229, 230, 230, 231,
1571  231, 232, 232, 233, 233, 234, 234, 235, 235, 235,
1572  235, 235, 235, 235, 235, 235, 236, 236, 236, 236,
1573  236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
1574  236, 237, 237, 238, 238, 238, 239, 239, 240, 240,
1575  241, 241, 243, 244, 242, 245, 245, 246, 246, 248,
1576  247, 249, 249, 249, 250, 250, 250, 250, 250, 250,
1577  250, 250, 250, 252, 251, 253, 251, 254, 255, 255,
1578  256, 256, 257, 257, 257, 258, 258, 259, 259, 260,
1579  260, 260, 261, 262, 262, 262, 263, 264, 265, 266,
1580  266, 267, 267, 268, 268, 269, 269, 270, 270, 271,
1581  271, 272, 272, 273, 273, 274, 275, 274, 276, 277,
1582  274, 278, 278, 278, 278, 279, 280, 280, 280, 280,
1583  281, 282, 282, 282, 282, 283, 283, 283, 283, 283,
1584  284, 284, 284, 284, 284, 284, 284, 285, 285, 286,
1585  286, 287, 287, 288, 289, 288, 288, 290, 290, 291,
1586  291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
1587  291, 291, 291, 291, 292, 292, 292, 292, 293, 293,
1588  294, 294, 295, 295, 296, 297, 298, 298, 299, 299,
1589  300, 300, 301, 301, 302, 302, 303, 304, 304, 305,
1590  306, 305, 307, 307, 308, 308, 309, 309, 310, 310,
1591  310, 311, 311, 311, 311, 312, 312, 312, 313, 313,
1592  314, 314, 315, 315, 316, 317, 318, 318, 318, 319,
1593  319, 320, 320, 321
1594 };
1595 
1596 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1597 static const yytype_uint8 yyr2[] =
1598 {
1599  0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
1600  0, 5, 4, 2, 1, 1, 3, 2, 0, 4,
1601  3, 3, 3, 2, 3, 3, 3, 3, 3, 4,
1602  1, 3, 3, 6, 5, 5, 5, 5, 3, 3,
1603  3, 3, 1, 3, 3, 1, 3, 3, 3, 2,
1604  1, 1, 1, 1, 1, 4, 4, 0, 5, 2,
1605  3, 4, 5, 4, 5, 2, 2, 2, 2, 2,
1606  1, 3, 1, 3, 1, 2, 3, 5, 2, 4,
1607  2, 4, 1, 3, 1, 3, 2, 3, 1, 3,
1608  1, 1, 4, 3, 3, 3, 3, 2, 1, 1,
1609  1, 4, 3, 3, 3, 3, 2, 1, 1, 1,
1610  2, 1, 3, 1, 1, 1, 1, 1, 1, 1,
1611  1, 1, 1, 0, 4, 1, 1, 1, 1, 1,
1612  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1613  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1614  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1615  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1616  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1617  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1618  1, 1, 1, 1, 1, 3, 5, 3, 5, 6,
1619  5, 5, 5, 5, 4, 3, 3, 3, 3, 3,
1620  3, 3, 3, 3, 4, 4, 2, 2, 3, 3,
1621  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1622  3, 2, 2, 3, 3, 3, 3, 0, 4, 6,
1623  1, 1, 1, 2, 4, 2, 3, 1, 1, 1,
1624  1, 2, 4, 2, 1, 2, 2, 4, 1, 0,
1625  2, 2, 2, 1, 1, 2, 3, 4, 3, 4,
1626  2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1627  0, 4, 0, 4, 3, 3, 2, 3, 3, 1,
1628  4, 3, 1, 0, 6, 4, 3, 2, 1, 2,
1629  2, 6, 6, 0, 0, 7, 0, 0, 7, 5,
1630  4, 0, 0, 9, 0, 6, 0, 0, 8, 0,
1631  5, 0, 6, 0, 0, 9, 1, 1, 1, 1,
1632  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1633  1, 1, 1, 1, 2, 1, 1, 1, 5, 1,
1634  2, 1, 1, 1, 3, 1, 3, 1, 4, 6,
1635  3, 5, 2, 4, 1, 3, 6, 8, 4, 6,
1636  4, 2, 6, 2, 4, 6, 2, 4, 2, 4,
1637  1, 1, 1, 3, 1, 4, 1, 2, 1, 3,
1638  1, 1, 0, 0, 4, 4, 1, 3, 3, 0,
1639  5, 2, 4, 4, 2, 4, 4, 3, 3, 3,
1640  2, 1, 4, 0, 5, 0, 5, 5, 1, 1,
1641  6, 1, 1, 1, 1, 2, 1, 2, 1, 1,
1642  1, 1, 1, 1, 1, 2, 3, 3, 3, 3,
1643  3, 0, 3, 1, 2, 3, 3, 0, 3, 0,
1644  2, 0, 2, 0, 2, 1, 0, 3, 0, 0,
1645  5, 1, 1, 1, 1, 2, 1, 1, 1, 1,
1646  3, 1, 1, 2, 2, 1, 1, 1, 1, 1,
1647  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1648  1, 1, 1, 1, 0, 4, 2, 3, 2, 6,
1649  8, 4, 6, 4, 6, 2, 4, 6, 2, 4,
1650  2, 4, 1, 0, 1, 1, 1, 1, 1, 1,
1651  1, 3, 1, 3, 3, 3, 1, 3, 1, 3,
1652  1, 1, 2, 1, 1, 1, 2, 2, 1, 1,
1653  0, 4, 1, 2, 1, 3, 3, 2, 1, 1,
1654  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1655  0, 1, 0, 1, 2, 2, 0, 1, 1, 1,
1656  1, 1, 2, 0
1657 };
1658 
1659 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1660  Performed when YYTABLE doesn't specify something else to do. Zero
1661  means the default is an error. */
1662 static const yytype_uint16 yydefact[] =
1663 {
1664  2, 0, 0, 1, 0, 338, 339, 340, 0, 331,
1665  332, 333, 336, 334, 335, 337, 326, 327, 328, 329,
1666  289, 259, 259, 481, 480, 482, 483, 562, 0, 562,
1667  10, 0, 485, 484, 486, 475, 550, 477, 476, 478,
1668  479, 471, 472, 433, 491, 492, 0, 0, 0, 0,
1669  0, 573, 573, 82, 392, 451, 449, 451, 453, 441,
1670  447, 0, 0, 0, 3, 560, 6, 9, 30, 42,
1671  45, 53, 52, 0, 70, 0, 74, 84, 0, 50,
1672  240, 0, 280, 0, 0, 303, 306, 560, 0, 0,
1673  0, 0, 54, 298, 271, 272, 432, 434, 273, 274,
1674  275, 276, 430, 431, 429, 487, 488, 277, 0, 278,
1675  259, 5, 8, 164, 175, 165, 188, 161, 181, 171,
1676  170, 191, 192, 186, 169, 168, 163, 189, 193, 194,
1677  173, 162, 176, 180, 182, 174, 167, 183, 190, 185,
1678  184, 177, 187, 172, 160, 179, 178, 159, 166, 157,
1679  158, 154, 155, 156, 113, 115, 114, 149, 150, 146,
1680  128, 129, 130, 137, 134, 136, 131, 132, 151, 152,
1681  138, 139, 143, 133, 135, 125, 126, 127, 140, 141,
1682  142, 144, 145, 147, 148, 153, 118, 120, 122, 23,
1683  116, 117, 119, 121, 0, 0, 0, 0, 0, 0,
1684  0, 254, 0, 241, 264, 68, 258, 573, 0, 487,
1685  488, 0, 278, 573, 544, 69, 67, 562, 66, 0,
1686  573, 410, 65, 562, 563, 0, 0, 18, 237, 0,
1687  0, 326, 327, 289, 292, 411, 216, 0, 0, 217,
1688  286, 0, 0, 0, 560, 15, 562, 72, 14, 282,
1689  0, 566, 566, 242, 0, 0, 566, 542, 562, 0,
1690  0, 0, 80, 330, 0, 90, 91, 98, 300, 393,
1691  468, 467, 469, 466, 0, 465, 0, 0, 0, 0,
1692  0, 0, 0, 473, 474, 49, 231, 232, 569, 570,
1693  4, 571, 561, 0, 0, 0, 0, 0, 0, 0,
1694  399, 401, 0, 86, 0, 78, 75, 0, 0, 0,
1695  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1696  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1697  0, 0, 0, 0, 0, 573, 0, 0, 51, 0,
1698  0, 0, 0, 560, 0, 561, 0, 352, 351, 0,
1699  0, 487, 488, 278, 108, 109, 0, 0, 111, 0,
1700  0, 487, 488, 278, 319, 184, 177, 187, 172, 154,
1701  155, 156, 113, 114, 540, 321, 539, 0, 0, 0,
1702  415, 413, 299, 435, 0, 0, 404, 59, 297, 123,
1703  547, 286, 265, 261, 0, 0, 0, 255, 263, 0,
1704  573, 0, 0, 0, 0, 256, 562, 0, 291, 260,
1705  562, 250, 573, 573, 249, 562, 296, 48, 20, 22,
1706  21, 0, 293, 0, 0, 0, 0, 0, 0, 17,
1707  562, 284, 13, 561, 71, 562, 287, 568, 567, 243,
1708  568, 245, 288, 543, 0, 97, 473, 474, 88, 83,
1709  0, 0, 573, 0, 513, 455, 458, 456, 470, 452,
1710  436, 450, 437, 438, 454, 439, 440, 0, 443, 445,
1711  0, 446, 0, 0, 572, 7, 24, 25, 26, 27,
1712  28, 46, 47, 573, 0, 31, 40, 0, 41, 562,
1713  0, 76, 87, 44, 43, 0, 195, 264, 39, 213,
1714  221, 226, 227, 228, 223, 225, 235, 236, 229, 230,
1715  206, 207, 233, 234, 562, 222, 224, 218, 219, 220,
1716  208, 209, 210, 211, 212, 551, 556, 552, 557, 409,
1717  259, 407, 562, 551, 553, 552, 554, 408, 259, 0,
1718  573, 343, 0, 342, 0, 0, 0, 0, 0, 0,
1719  286, 0, 573, 0, 311, 316, 108, 109, 110, 0,
1720  494, 314, 493, 0, 573, 0, 0, 0, 513, 559,
1721  558, 323, 551, 552, 259, 259, 573, 573, 32, 197,
1722  38, 205, 57, 60, 0, 195, 546, 0, 266, 262,
1723  573, 555, 552, 562, 551, 552, 545, 290, 564, 246,
1724  251, 253, 295, 19, 0, 238, 0, 29, 0, 573,
1725  204, 73, 16, 283, 566, 0, 81, 94, 96, 562,
1726  551, 552, 519, 516, 515, 514, 517, 0, 531, 535,
1727  534, 530, 513, 0, 396, 518, 520, 522, 573, 528,
1728  573, 533, 573, 0, 512, 459, 0, 442, 444, 448,
1729  214, 215, 384, 573, 0, 382, 381, 270, 0, 85,
1730  79, 0, 0, 0, 0, 0, 0, 406, 63, 0,
1731  412, 0, 0, 248, 405, 61, 247, 341, 281, 573,
1732  573, 421, 573, 344, 573, 346, 304, 345, 307, 0,
1733  0, 310, 555, 285, 562, 551, 552, 0, 0, 496,
1734  0, 0, 108, 109, 112, 562, 0, 562, 513, 0,
1735  0, 0, 403, 56, 402, 55, 0, 0, 0, 573,
1736  124, 267, 257, 0, 0, 412, 0, 0, 573, 562,
1737  11, 244, 89, 92, 0, 519, 0, 364, 355, 357,
1738  562, 353, 573, 0, 0, 394, 0, 505, 538, 0,
1739  508, 532, 0, 510, 536, 0, 461, 462, 463, 457,
1740  464, 519, 0, 573, 0, 573, 526, 573, 573, 380,
1741  386, 0, 0, 268, 77, 196, 0, 37, 202, 36,
1742  203, 64, 565, 0, 34, 200, 35, 201, 62, 422,
1743  423, 573, 424, 0, 573, 349, 0, 0, 347, 0,
1744  0, 0, 309, 0, 0, 412, 0, 317, 0, 0,
1745  412, 320, 541, 562, 0, 498, 324, 0, 0, 198,
1746  0, 0, 252, 294, 524, 562, 0, 362, 0, 521,
1747  562, 0, 0, 523, 573, 573, 537, 573, 529, 573,
1748  573, 0, 0, 390, 387, 388, 391, 0, 383, 371,
1749  373, 0, 376, 0, 378, 400, 269, 239, 33, 199,
1750  0, 0, 426, 350, 0, 12, 428, 0, 301, 302,
1751  0, 0, 266, 573, 312, 0, 495, 315, 497, 322,
1752  513, 416, 414, 0, 354, 365, 0, 360, 356, 395,
1753  398, 397, 0, 501, 0, 503, 0, 509, 0, 506,
1754  511, 460, 0, 525, 0, 385, 573, 573, 573, 527,
1755  573, 573, 0, 425, 0, 99, 100, 107, 0, 427,
1756  0, 305, 308, 418, 419, 417, 0, 0, 0, 58,
1757  0, 363, 0, 358, 573, 573, 573, 573, 286, 0,
1758  389, 0, 368, 0, 370, 377, 0, 374, 379, 106,
1759  0, 573, 0, 573, 573, 0, 318, 0, 361, 0,
1760  502, 0, 499, 504, 507, 555, 285, 573, 573, 573,
1761  573, 555, 105, 562, 551, 552, 420, 348, 313, 325,
1762  359, 573, 369, 0, 366, 372, 375, 412, 500, 573,
1763  367
1764 };
1765 
1766 /* YYDEFGOTO[NTERM-NUM]. */
1767 static const yytype_int16 yydefgoto[] =
1768 {
1769  -1, 1, 2, 64, 65, 66, 229, 539, 540, 244,
1770  245, 421, 68, 69, 339, 70, 71, 583, 719, 72,
1771  73, 246, 74, 75, 76, 449, 77, 202, 358, 359,
1772  186, 187, 188, 189, 584, 536, 191, 79, 423, 204,
1773  250, 529, 674, 410, 411, 218, 219, 206, 397, 412,
1774  488, 80, 337, 435, 604, 341, 800, 342, 801, 697,
1775  926, 701, 698, 875, 566, 568, 711, 880, 237, 82,
1776  83, 84, 85, 86, 87, 88, 89, 90, 91, 678,
1777  542, 686, 797, 798, 350, 738, 739, 740, 763, 654,
1778  655, 764, 844, 845, 268, 269, 454, 633, 745, 301,
1779  483, 92, 93, 388, 577, 576, 549, 925, 680, 791,
1780  861, 865, 94, 95, 96, 97, 98, 99, 100, 280,
1781  467, 101, 282, 276, 274, 278, 459, 646, 645, 755,
1782  759, 102, 275, 103, 104, 209, 210, 107, 211, 212,
1783  561, 700, 709, 710, 635, 636, 637, 638, 639, 766,
1784  767, 640, 641, 642, 643, 836, 747, 377, 567, 255,
1785  413, 214, 238, 608, 531, 571, 290, 407, 408, 670,
1786  439, 543, 345, 248
1787 };
1788 
1789 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1790  STATE-NUM. */
1791 #define YYPACT_NINF -747
1792 static const yytype_int16 yypact[] =
1793 {
1794  -747, 81, 2552, -747, 7102, -747, -747, -747, 6615, -747,
1795  -747, -747, -747, -747, -747, -747, 7320, 7320, -747, -747,
1796  7320, 3237, 2814, -747, -747, -747, -747, 100, 6476, -31,
1797  -747, -26, -747, -747, -747, 5715, 2955, -747, -747, 5842,
1798  -747, -747, -747, -747, -747, -747, 8519, 8519, 83, 4434,
1799  8628, 7538, 7865, 6878, -747, 6337, -747, -747, -747, -24,
1800  29, 252, 8737, 8519, -747, 193, -747, 1104, -747, 458,
1801  -747, -747, 129, 77, -747, 69, 8846, -747, 139, 2797,
1802  22, 41, -747, 8628, 8628, -747, -747, 5078, 8951, 9056,
1803  9161, 5588, 33, 46, -747, -747, 157, -747, -747, -747,
1804  -747, -747, -747, -747, -747, 25, 58, -747, 179, 613,
1805  51, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1806  -747, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1807  -747, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1808  -747, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1809  -747, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1810  -747, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1811  -747, -747, -747, -747, -747, -747, -747, -747, -747, -747,
1812  -747, -747, -747, -747, -747, -747, -747, -747, -747, 134,
1813  -747, -747, -747, -747, 182, 8519, 279, 4564, 8519, 8519,
1814  8519, -747, 263, 2797, 260, -747, -747, 237, 207, 43,
1815  206, 298, 254, 265, -747, -747, -747, 4969, -747, 7320,
1816  7320, -747, -747, 5208, -747, 8628, 661, -747, 272, 287,
1817  4694, -747, -747, -747, 295, 307, -747, 304, 51, 416,
1818  619, 7211, 4434, 384, 193, 1104, -31, 399, -747, 458,
1819  419, 221, 300, -747, 260, 430, 300, -747, -31, 497,
1820  501, 9266, 442, -747, 351, 366, 383, 409, -747, -747,
1821  -747, -747, -747, -747, 644, -747, 754, 813, 605, 464,
1822  819, 478, 68, 530, 532, -747, -747, -747, -747, -747,
1823  -747, -747, 5317, 8628, 8628, 8628, 8628, 7211, 8628, 8628,
1824  -747, -747, 7974, -747, 4434, 6990, 470, 7974, 8519, 8519,
1825  8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519,
1826  8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519, 8519,
1827  8519, 8519, 8519, 8519, 9548, 7320, 9625, 3609, 458, 86,
1828  86, 8628, 8628, 193, 597, 480, 562, -747, -747, 454,
1829  601, 54, 76, 99, 331, 349, 8628, 481, -747, 45,
1830  473, -747, -747, -747, -747, 217, 286, 305, 318, 321,
1831  347, 363, 376, 381, -747, -747, -747, 391, 10549, 10549,
1832  -747, -747, -747, -747, 8737, 8737, -747, 535, -747, -747,
1833  -747, 388, -747, -747, 8519, 8519, 7429, -747, -747, 9702,
1834  7320, 9779, 8519, 8519, 7647, -747, -31, 492, -747, -747,
1835  -31, -747, 506, 539, -747, 106, -747, -747, -747, -747,
1836  -747, 6615, -747, 8519, 4029, 508, 9702, 9779, 8519, 1104,
1837  -31, -747, -747, 5445, 541, -31, -747, 7756, -747, -747,
1838  7865, -747, -747, -747, 272, 510, -747, -747, -747, 543,
1839  9266, 9856, 7320, 9933, 774, -747, -747, -747, -747, -747,
1840  -747, -747, -747, -747, -747, -747, -747, 313, -747, -747,
1841  491, -747, 8519, 8519, -747, -747, -747, -747, -747, -747,
1842  -747, -747, -747, 32, 8519, -747, 545, 546, -747, -31,
1843  9266, 551, -747, -747, -747, 566, 9473, -747, -747, 416,
1844  2184, 2184, 2184, 2184, 781, 781, 2273, 2938, 2184, 2184,
1845  1364, 1364, 662, 662, 2656, 781, 781, 927, 927, 768,
1846  397, 397, 416, 416, 416, 3378, 6083, 3464, 6197, -747,
1847  307, -747, -31, 647, -747, 660, -747, -747, 3096, 650,
1848  688, -747, 3754, 685, 4174, 56, 56, 597, 8083, 650,
1849  112, 10010, 7320, 10087, -747, 458, -747, 510, -747, 193,
1850  -747, -747, -747, 10164, 7320, 10241, 3609, 8628, 1131, -747,
1851  -747, -747, -747, -747, 1739, 1739, 32, 32, -747, 10608,
1852  -747, 2797, -747, -747, 6615, 10627, -747, 8519, 260, -747,
1853  265, 5969, 2673, -31, 490, 500, -747, -747, -747, -747,
1854  7429, 7647, -747, -747, 8628, 2797, 570, -747, 307, 307,
1855  2797, 213, 1104, -747, 300, 9266, 543, 505, 282, -31,
1856  38, 261, 603, -747, -747, -747, -747, 972, -747, -747,
1857  -747, -747, 1223, 66, -747, -747, -747, -747, 580, -747,
1858  583, 683, 589, 687, -747, -747, 893, -747, -747, -747,
1859  416, 416, -747, 576, 4839, -747, -747, 604, 8192, -747,
1860  543, 9266, 8737, 8519, 630, 8737, 8737, -747, 535, 608,
1861  677, 8737, 8737, -747, -747, 535, -747, -747, -747, 8301,
1862  740, -747, 588, -747, 740, -747, -747, -747, -747, 650,
1863  44, -747, 239, 257, -31, 141, 145, 8628, 193, -747,
1864  8628, 3609, 505, 282, -747, -31, 650, 106, 1223, 3609,
1865  193, 6754, -747, -747, -747, -747, 4839, 4694, 8519, 32,
1866  -747, -747, -747, 8519, 8519, 507, 8519, 8519, 636, 106,
1867  -747, -747, -747, 291, 8519, -747, 972, 457, -747, 651,
1868  -31, -747, 639, 4839, 4694, -747, 1223, -747, -747, 1223,
1869  -747, -747, 598, -747, -747, 4694, -747, -747, -747, -747,
1870  -747, 681, 1017, 639, 679, 654, -747, 656, 657, -747,
1871  -747, 789, 8519, 664, 543, 2797, 8519, -747, 2797, -747,
1872  2797, -747, -747, 8737, -747, 2797, -747, 2797, -747, 545,
1873  -747, 713, -747, 4304, 796, -747, 8628, 650, -747, 650,
1874  4839, 4839, -747, 8410, 3899, 189, 56, -747, 193, 650,
1875  -747, -747, -747, -31, 650, -747, -747, 799, 673, 2797,
1876  4694, 8519, 7647, -747, -747, -31, 884, 671, 1079, -747,
1877  -31, 803, 686, -747, 676, 678, -747, 684, -747, 694,
1878  684, 690, 9371, -747, 699, -747, -747, 711, -747, 1251,
1879  -747, 1251, -747, 598, -747, -747, 700, 2797, -747, 2797,
1880  9476, 86, -747, -747, 4839, -747, -747, 86, -747, -747,
1881  650, 650, -747, 365, -747, 3609, -747, -747, -747, -747,
1882  1131, -747, -747, 706, -747, 707, 884, 716, -747, -747,
1883  -747, -747, 1223, -747, 598, -747, 598, -747, 598, -747,
1884  -747, -747, 790, 520, 1017, -747, 708, 715, 684, -747,
1885  717, 684, 797, -747, 523, 366, 383, 409, 3609, -747,
1886  3754, -747, -747, -747, -747, -747, 4839, 650, 3609, -747,
1887  884, 707, 884, 721, 684, 727, 684, 684, -747, 10318,
1888  -747, 1251, -747, 598, -747, -747, 598, -747, -747, 510,
1889  10395, 7320, 10472, 688, 588, 650, -747, 650, 707, 884,
1890  -747, 598, -747, -747, -747, 730, 731, 684, 735, 684,
1891  684, 55, 282, -31, 128, 158, -747, -747, -747, -747,
1892  707, 684, -747, 598, -747, -747, -747, 163, -747, 684,
1893  -747
1894 };
1895 
1896 /* YYPGOTO[NTERM-NUM]. */
1897 static const yytype_int16 yypgoto[] =
1898 {
1899  -747, -747, -747, 452, -747, 28, -747, -545, 277, -747,
1900  39, -747, -293, 184, -58, 71, -747, -169, -747, -7,
1901  791, -142, -13, -37, -747, -396, -29, 1623, -312, 788,
1902  -54, -747, -25, -747, -747, 20, -747, 1066, -747, -45,
1903  -747, 11, 47, -324, 115, 5, -747, -322, -196, 53,
1904  -295, 8, -747, -747, -747, -747, -747, -747, -747, -747,
1905  -747, -747, -747, -747, -747, -747, -747, -747, 2, -747,
1906  -747, -747, -747, -747, -747, -747, -747, -747, -747, 205,
1907  -338, -516, -72, -618, -747, -722, -671, 147, -747, -489,
1908  -747, -600, -747, -12, -747, -747, -747, -747, -747, -747,
1909  -747, -747, -747, 798, -747, -747, -531, -747, -50, -747,
1910  -747, -747, -747, -747, -747, 811, -747, -747, -747, -747,
1911  -747, -747, -747, -747, 856, -747, -140, -747, -747, -747,
1912  -747, 7, -747, 12, -747, 1268, 1605, 823, 1289, 1575,
1913  -747, -747, 35, -387, -697, -568, -690, 273, -696, -746,
1914  72, 181, -747, -526, -747, -449, 270, -747, -747, -747,
1915  97, -360, 758, -276, -747, -747, -56, -4, 278, -585,
1916  -214, 6, -18, -2
1917 };
1918 
1919 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1920  positive, shift that token. If negative, reduce the rule which
1921  number is the opposite. If YYTABLE_NINF, syntax error. */
1922 #define YYTABLE_NINF -574
1923 static const yytype_int16 yytable[] =
1924 {
1925  111, 273, 544, 227, 81, 644, 81, 254, 725, 201,
1926  201, 532, 498, 201, 493, 192, 689, 405, 208, 208,
1927  193, 706, 208, 225, 262, 228, 340, 222, 190, 343,
1928  688, 344, 112, 221, 733, 192, 247, 375, 441, 306,
1929  193, 67, 443, 67, 596, 558, 559, 292, 190, 253,
1930  257, 81, 208, 838, 616, 264, 833, 541, 530, 741,
1931  538, 263, 794, -93, 208, 846, 799, 634, -103, 207,
1932  207, 291, 380, 207, 589, 190, 593, 380, 264, -99,
1933  596, 3, 589, 685, 263, 208, 208, 716, 717, 208,
1934  349, 360, 360, 291, 660, 743, 263, 263, 263, 541,
1935  430, -100, 574, 575, 251, 909, 888, -330, 652, 805,
1936  230, 190, -489, 213, 213, 387, 224, 213, 378, 644,
1937  810, 386, 279, 530, -107, 538, 334, 768, 619, 470,
1938  -489, 205, 215, 285, -99, 216, 461, -106, 464, 240,
1939  468, -102, 830, 298, 299, -490, 653, -93, 252, 256,
1940  390, 609, -99, 392, 393, 885, 809, 300, 560, 833,
1941  -330, -330, 489, 847, 814, -90, -102, -100, 741, 827,
1942  -104, -104, 379, 744, 471, 281, -101, 609, -93, 335,
1943  336, -93, 381, 644, 803, -93, 302, 381, 432, 288,
1944  288, 289, 289, 220, -90, 909, 838, -551, -91, 81,
1945  -103, 288, -103, 289, 769, 398, 833, 846, 888, 303,
1946  201, 398, 201, 201, -101, 931, -91, 405, 414, 208,
1947  835, 208, 208, 839, 448, 208, 433, 208, 694, 247,
1948  820, 288, 81, 289, 249, 476, 477, 478, 479, -98,
1949  705, 596, 223, 81, 81, 742, 221, 224, 307, 386,
1950  291, 704, -97, 224, 444, 923, 56, 486, 741, 644,
1951  741, 958, 497, 264, -103, 774, 384, 338, 338, 263,
1952  207, 338, 207, -102, 389, -102, 491, 609, 589, 589,
1953  429, -93, -105, 545, 546, -95, -95, 547, 980, 609,
1954  874, 247, 399, -490, 81, 208, 208, 208, 208, 81,
1955  208, 208, -481, -104, 208, -104, 81, 264, -101, 208,
1956  -101, 283, 284, 263, 213, -100, 213, -412, 741, 933,
1957  475, 813, -71, 907, 223, 910, 243, 648, 201, -92,
1958  927, 67, 406, 414, 409, 391, 480, 208, 288, 81,
1959  289, 403, 924, 208, 208, 400, 401, 537, 395, 291,
1960  586, 588, 804, -85, 528, 487, -481, -548, 208, 254,
1961  487, 437, 741, -107, 741, 562, 935, -285, 438, 493,
1962  -95, -480, 394, 485, 455, -549, -412, 396, 494, -94,
1963  793, -551, 548, 957, 790, 402, 208, 208, 987, 426,
1964  -482, 741, 588, 201, 722, 254, 603, -96, 414, -552,
1965  731, -95, 208, -483, -95, 404, -485, 415, -95, 417,
1966  398, 398, 537, 448, 422, 968, -475, 456, 457, 528,
1967  -285, -285, 111, 424, -552, -480, 81, -412, 192, -412,
1968  -412, 644, -484, 193, -478, 81, 451, 217, 537, 657,
1969  440, 190, 400, 427, -482, 201, 528, 438, -486, 220,
1970  414, -487, 264, 448, 208, 578, 580, -483, 263, 647,
1971  -485, -475, 596, 67, 537, 308, -478, -548, -488, -475,
1972  -475, 528, 612, -548, 243, 428, 569, 338, 338, 338,
1973  338, 656, 481, 482, 308, -549, -484, -478, -478, 452,
1974  453, -549, 264, 590, -278, 298, 299, -106, 263, 781,
1975  589, 416, -486, 497, -487, -487, 788, 425, -70, 735,
1976  664, 623, 624, 625, 626, -475, 331, 332, 333, 243,
1977  -478, -488, -488, 918, 434, 338, 338, 431, 669, 920,
1978  570, -555, 722, 556, 614, 668, 676, 557, 681, 551,
1979  555, 667, 721, 675, 81, 201, 81, -278, -278, 673,
1980  414, 687, 687, 445, 208, 588, 254, 201, 563, 720,
1981  446, 447, 414, 436, 537, 699, 208, 442, 81, 208,
1982  465, 528, 676, 676, 656, 656, 537, 726, 732, 713,
1983  715, 243, 450, 528, 469, 673, 673, 727, 398, 669,
1984  -555, 192, 552, 553, 821, -286, 193, 826, 472, -102,
1985  473, 690, 796, 793, 190, 939, 208, 676, 950, -104,
1986  492, 564, 565, 773, 548, 669, -101, 264, 550, 667,
1987  673, 712, 714, 263, 448, 474, 554, 973, 761, 582,
1988  623, 624, 625, 626, 789, 598, 748, 649, 748, 806,
1989  748, -555, 808, -555, -555, 607, 600, -551, -286, -286,
1990  735, 770, 623, 624, 625, 626, 81, 816, 564, 565,
1991  677, 951, 952, 264, 208, 627, 455, 208, 208, 263,
1992  463, 628, 629, 208, 208, 662, 609, 792, 795, 601,
1993  795, -85, 795, 615, 597, -264, 658, 627, 599, 824,
1994  669, 661, 630, 602, 629, 631, 679, 728, 683, 208,
1995  385, 669, 208, 81, 807, 455, 428, 730, 611, 456,
1996  457, 81, 734, 613, 630, 418, 815, 656, 81, 81,
1997  746, 762, -107, 749, 419, 420, 398, 856, -106, 752,
1998  308, 190, 487, 494, 671, 751, 777, 779, 867, 754,
1999  770, 776, 784, 786, -265, 81, 81, 672, 456, 457,
2000  458, 707, 782, -98, 691, 793, -102, 81, 872, -97,
2001  110, 770, 110, 748, 783, 748, 748, 659, 735, -104,
2002  623, 624, 625, 626, 110, 110, 822, 254, 110, 329,
2003  330, 331, 332, 333, 762, 208, -101, -93, 729, 862,
2004  842, 828, 866, 848, 849, 81, 851, 853, 208, 855,
2005  -95, 860, 81, 81, -266, 864, 81, 110, 110, 881,
2006  882, 886, 687, 890, 876, 455, 892, -92, 894, 682,
2007  110, 684, 81, 891, 896, 905, 622, 901, 623, 624,
2008  625, 626, 748, 748, 898, 748, 308, 748, 748, 904,
2009  -267, 110, 110, 929, 903, 110, 938, 930, 941, 308,
2010  263, 321, 322, 949, 858, 943, 932, 946, 456, 457,
2011  460, 959, 914, 627, 321, 322, 81, 961, 263, 628,
2012  629, 795, -551, -552, 455, 983, 606, 81, 364, 347,
2013  455, 338, 977, 825, 338, 329, 330, 331, 332, 333,
2014  630, 382, 940, 631, 802, 326, 327, 328, 329, 330,
2015  331, 332, 333, 976, 748, 748, 748, 383, 748, 748,
2016  750, 811, 753, 277, 376, 928, 632, 456, 457, 462,
2017  81, 906, 81, 456, 457, 466, 765, 834, 81, 0,
2018  81, 771, 748, 748, 748, 748, 735, 0, 623, 624,
2019  625, 626, 0, 0, 201, 0, 0, 756, 757, 414,
2020  758, 681, 795, 208, 0, 110, 44, 45, 0, 528,
2021  0, 0, 0, 537, 0, 748, 748, 748, 748, 669,
2022  528, 0, 0, 736, 0, 110, 0, 110, 110, 748,
2023  338, 110, 0, 110, 0, 812, 0, 748, 110, 0,
2024  0, 0, 0, 817, 818, 308, 0, 0, 0, 110,
2025  110, 0, 868, 0, 869, 0, 0, 823, 0, 0,
2026  321, 322, 0, 0, 877, 0, 0, 0, 829, 879,
2027  831, 832, 837, 0, 735, 840, 623, 624, 625, 626,
2028  0, 0, 841, 0, 0, 850, 0, 852, 854, 0,
2029  0, 0, 0, 328, 329, 330, 331, 332, 333, 0,
2030  110, 110, 110, 110, 110, 110, 110, 110, 0, 0,
2031  110, 736, 110, 0, 0, 110, 0, 737, 0, 843,
2032  863, 623, 624, 625, 626, 921, 922, 870, 871, 0,
2033  0, 873, 203, 203, 0, 0, 203, 0, 0, 0,
2034  0, 878, 0, 110, 0, 110, 0, 883, 0, 110,
2035  110, 0, 0, 884, 893, 895, 0, 897, 889, 899,
2036  900, 0, 236, 239, 110, 0, 0, 203, 203, 0,
2037  0, 0, 0, 0, 908, 0, 911, 0, 286, 287,
2038  0, 735, 956, 623, 624, 625, 626, 0, 0, 0,
2039  0, 919, 110, 110, 293, 294, 295, 296, 297, 0,
2040  0, 0, 0, 0, 0, 0, 0, 0, 110, 0,
2041  978, 0, 979, 0, 0, 934, 0, 936, 736, 0,
2042  0, 937, 0, 0, 887, 0, 942, 944, 945, 0,
2043  947, 948, 110, 622, 0, 623, 624, 625, 626, 0,
2044  0, 110, 0, 0, 0, 953, 0, 954, 0, 0,
2045  0, 0, 0, 955, 960, 962, 963, 964, 0, 0,
2046  110, 0, 0, 0, 967, 0, 969, 0, 0, 970,
2047  627, 0, 0, 0, 0, 0, 628, 629, 0, 0,
2048  0, 0, 0, 0, 981, 0, 0, 982, 984, 985,
2049  986, 0, 0, 0, 0, 0, 0, 630, 0, 0,
2050  631, 988, 0, 0, 0, 0, 989, 0, 0, 990,
2051  0, 203, 0, 0, 203, 203, 286, 0, 0, 0,
2052  105, 0, 105, 708, 0, 622, 0, 623, 624, 625,
2053  626, 0, 0, 203, 0, 203, 203, 0, 0, 0,
2054  0, 108, 0, 108, 0, 0, 0, 0, 0, 0,
2055  110, 0, 110, 761, 0, 623, 624, 625, 626, 0,
2056  110, 0, 627, 0, 0, 0, 0, 105, 628, 629,
2057  0, 265, 110, 0, 110, 110, 0, 0, 0, 0,
2058  0, 0, 0, 0, 0, 0, 0, 0, 108, 630,
2059  627, 0, 631, 0, 265, 0, 628, 629, 0, 0,
2060  0, 0, 0, 0, 0, 0, 351, 361, 361, 361,
2061  0, 0, 110, 0, 0, 0, 0, 630, 203, 0,
2062  631, 0, 0, 496, 499, 500, 501, 502, 503, 504,
2063  505, 506, 507, 508, 509, 510, 511, 512, 513, 514,
2064  515, 516, 517, 518, 519, 520, 521, 522, 523, 524,
2065  0, 203, 0, 0, 0, 0, 0, 0, 0, 0,
2066  0, 0, 110, 0, 0, 0, 0, 0, 0, 0,
2067  110, 0, 0, 110, 110, 0, 0, 0, 0, 110,
2068  110, 0, 308, 309, 310, 311, 312, 313, 314, 315,
2069  316, 317, 318, -574, -574, 0, 0, 321, 322, 0,
2070  579, 581, 0, 0, 0, 110, 0, 0, 110, 110,
2071  585, 203, 203, 0, 0, 105, 203, 110, 579, 581,
2072  203, 0, 0, 0, 110, 110, 324, 325, 326, 327,
2073  328, 329, 330, 331, 332, 333, 108, 0, 0, 605,
2074  0, 0, 0, 0, 610, 0, 0, 0, 105, 0,
2075  0, 110, 110, 203, 0, 0, 203, 0, 0, 105,
2076  105, 0, 0, 110, 0, 0, 0, 0, 203, 108,
2077  0, 0, 0, 0, 0, 0, 0, 0, 0, 265,
2078  108, 108, 0, 0, 0, 0, 0, 0, 650, 651,
2079  0, 110, 0, 0, 0, 0, 0, 0, 0, 0,
2080  203, 110, 0, 0, 110, 0, 0, 0, 110, 110,
2081  105, 0, 110, 0, 0, 105, 0, 0, 0, 0,
2082  0, 0, 105, 265, 0, 0, 0, 109, 110, 109,
2083  0, 108, 0, 0, 0, 0, 108, 0, 0, 0,
2084  0, 0, 0, 108, 0, 0, 0, 0, 0, 0,
2085  0, 0, 0, 0, 0, 105, 0, 106, 0, 106,
2086  0, 0, 0, 0, 203, 0, 0, 0, 203, 0,
2087  0, 0, 110, 0, 109, 78, 108, 78, 267, 0,
2088  203, 0, 0, 110, 0, 0, 0, 0, 0, 0,
2089  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2090  0, 267, 0, 203, 106, 0, 0, 0, 266, 0,
2091  0, 0, 0, 353, 363, 363, 203, 203, 0, 0,
2092  0, 0, 78, 0, 0, 0, 110, 0, 110, 0,
2093  0, 266, 0, 0, 110, 0, 110, 0, 0, 0,
2094  0, 0, 105, 352, 362, 362, 362, 0, 0, 0,
2095  0, 105, 0, 0, 0, 0, 0, 0, 0, 110,
2096  0, 348, 0, 108, 0, 0, 0, 0, 265, 0,
2097  0, 0, 108, 0, 203, 0, 0, 0, 585, 775,
2098  0, 778, 780, 0, 0, 0, 0, 785, 787, -573,
2099  0, 0, 0, 0, 0, 203, 0, -573, -573, -573,
2100  0, 0, -573, -573, -573, 0, -573, 0, 265, 0,
2101  0, 0, 0, 0, 0, 0, -573, 0, 0, 0,
2102  0, 0, 109, 0, 0, 0, -573, -573, 0, -573,
2103  -573, -573, -573, -573, 819, 0, 0, 0, 0, 778,
2104  780, 0, 785, 787, 0, 0, 0, 0, 0, 0,
2105  203, 0, 106, 0, 0, 109, 0, 0, 0, 0,
2106  105, 0, 105, 0, 0, 0, 109, 109, 0, 0,
2107  78, 0, 0, 0, -573, 0, 0, 0, 0, 0,
2108  0, 108, 0, 108, 105, 106, 267, 0, 203, 0,
2109  0, 0, 857, 0, 0, 0, 106, 106, 0, 859,
2110  0, 0, 0, 78, 0, 108, 0, 0, 0, 0,
2111  0, 0, 0, 0, 78, 78, 266, 109, 0, 203,
2112  0, 0, 109, 0, 0, 0, -573, 0, -573, 109,
2113  267, 220, -573, 265, -573, 0, -573, 859, 203, 0,
2114  0, 0, 0, 0, 0, 0, 0, 106, 0, 0,
2115  0, 0, 106, 0, 0, 0, 0, 0, 0, 106,
2116  266, 0, 109, 0, 0, 78, 0, 0, 0, 0,
2117  78, 0, 105, 0, 0, 0, 0, 78, 0, 265,
2118  495, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2119  0, 0, 106, 108, 0, 0, 0, 0, 0, 0,
2120  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2121  78, 0, 0, 0, 0, 0, 0, 0, 0, 105,
2122  0, 0, 0, 0, 0, 0, 0, 105, 0, 0,
2123  0, 0, 0, 0, 105, 105, 0, 0, 0, 0,
2124  108, 0, 0, 0, 0, 0, 0, 0, 108, 109,
2125  0, 0, 0, 0, 0, 108, 108, 0, 109, 0,
2126  0, 105, 105, 0, 0, 0, 0, 203, 0, 0,
2127  0, 0, 0, 105, 0, 267, 0, 0, 0, 106,
2128  0, 0, 108, 108, 0, 0, 0, 0, 106, 0,
2129  0, 0, 0, 0, 108, 0, 0, 78, 0, 0,
2130  0, 0, 0, 0, 0, 266, 78, 0, 0, 0,
2131  0, 105, 0, 0, 0, 267, 0, 0, 105, 105,
2132  0, 0, 105, 0, 0, 0, 0, 0, 0, 0,
2133  0, 0, 108, 0, 0, 0, 0, 0, 105, 108,
2134  108, 0, 0, 108, 0, 266, 0, 0, 0, 0,
2135  0, 0, 0, 0, 0, 0, 0, 0, 0, 108,
2136  361, 0, 0, 0, 0, 0, 0, 109, 0, 109,
2137  0, 0, 0, 0, 0, 0, 0, 0, 915, 0,
2138  0, 0, 105, 0, 0, 0, 0, 0, 0, 0,
2139  0, 109, 0, 105, 0, 0, 0, 106, 0, 106,
2140  0, 0, 0, 108, 0, 0, 0, 0, 0, 0,
2141  0, 0, 0, 0, 108, 78, 0, 78, 0, 0,
2142  0, 106, 0, 0, 0, 0, 0, 0, 0, 0,
2143  0, 0, 0, 0, 0, 0, 105, 0, 105, 78,
2144  267, 0, 0, 0, 105, 0, 105, 0, 0, 0,
2145  0, 0, 0, 0, 0, 0, 0, 108, 0, 108,
2146  0, 0, 0, 0, 0, 108, 0, 108, 0, 0,
2147  266, 760, 0, 0, 0, 0, 0, 0, 0, 109,
2148  0, 0, 0, 0, 0, 0, 267, 0, 0, 0,
2149  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2150  0, 0, 308, -574, -574, -574, -574, 313, 314, 106,
2151  0, -574, -574, 0, 0, 0, 266, 321, 322, 0,
2152  0, 0, 0, 0, 0, 0, 109, 78, 0, 0,
2153  0, 0, 0, 0, 109, 495, 0, 0, 0, 0,
2154  0, 109, 109, 0, 0, 0, 324, 325, 326, 327,
2155  328, 329, 330, 331, 332, 333, 106, 0, 0, 0,
2156  0, 0, 0, 0, 106, 0, 0, 0, 109, 109,
2157  0, 106, 106, 0, 78, 0, 0, 0, 0, 0,
2158  109, 0, 78, 0, 0, 0, 0, 0, 0, 78,
2159  78, 308, 309, 310, 311, 312, 313, 314, 106, 106,
2160  317, 318, 0, 0, 0, 0, 321, 322, 0, 0,
2161  106, 0, 0, 0, 0, 0, 78, 78, 109, 0,
2162  0, 0, 0, 0, 0, 109, 109, 0, 78, 109,
2163  0, 0, 0, 0, 0, 324, 325, 326, 327, 328,
2164  329, 330, 331, 332, 333, 109, 0, 0, 106, 0,
2165  0, 0, 0, 0, 0, 106, 106, 0, 0, 106,
2166  0, 0, 0, 0, 0, 0, 78, 363, 0, 0,
2167  0, 0, 0, 78, 78, 106, 0, 78, 0, 0,
2168  0, 0, 0, 0, 0, 917, 0, 0, 0, 109,
2169  0, 0, 0, 78, 0, 0, 0, 362, 0, 0,
2170  109, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2171  0, 0, 0, 0, 0, 916, 0, 0, 0, 106,
2172  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2173  106, 0, 0, 913, 0, 0, 0, 78, 0, 0,
2174  0, 0, 0, 109, 0, 109, 0, 0, 78, 0,
2175  0, 109, 0, 109, 0, 0, 0, 0, 0, 0,
2176  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2177  0, 0, 0, 106, 0, 106, 0, 0, 0, 0,
2178  0, 106, 0, 106, 0, 0, 0, 0, 0, 0,
2179  0, 78, 0, 78, 0, 0, 0, 0, 0, 78,
2180  0, 78, -573, 4, 0, 5, 6, 7, 8, 9,
2181  0, 0, 0, 10, 11, 0, 0, 0, 12, 0,
2182  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2183  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2184  0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
2185  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2186  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2187  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2188  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2189  0, 49, 50, 0, 51, 52, 0, 53, 0, 54,
2190  55, 56, 57, 58, 59, 60, 0, 0, 0, 0,
2191  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2192  0, 0, 0, -285, 61, 62, 63, 0, 0, 0,
2193  0, -285, -285, -285, 0, 0, -285, -285, -285, 0,
2194  -285, 0, 0, 0, 0, 0, 0, -573, 0, -573,
2195  -285, -285, -285, 0, 0, 0, 0, 0, 0, 0,
2196  -285, -285, 0, -285, -285, -285, -285, -285, 0, 0,
2197  0, 0, 0, 0, 308, 309, 310, 311, 312, 313,
2198  314, 315, 316, 317, 318, 319, 320, 0, 0, 321,
2199  322, -285, -285, -285, -285, -285, -285, -285, -285, -285,
2200  -285, -285, -285, -285, 0, 0, -285, -285, -285, 0,
2201  724, -285, 0, 0, 0, 0, 323, -285, 324, 325,
2202  326, 327, 328, 329, 330, 331, 332, 333, 0, 0,
2203  -285, 0, -105, -285, -285, -285, -285, -285, -285, -285,
2204  -285, -285, -285, -285, -285, 0, 0, 0, 0, 0,
2205  0, 0, 0, 224, 0, 0, 0, 0, 0, 0,
2206  -285, -285, -285, -285, -411, 0, -285, -285, -285, 0,
2207  -285, 0, -411, -411, -411, 0, 0, -411, -411, -411,
2208  0, -411, 0, 0, 0, 0, 0, 0, 0, 0,
2209  -411, -411, -411, 0, 0, 0, 0, 0, 0, 0,
2210  0, -411, -411, 0, -411, -411, -411, -411, -411, 0,
2211  0, 0, 0, 0, 0, 308, 309, 310, 311, 312,
2212  313, 314, 315, 316, 317, 318, 319, 320, 0, 0,
2213  321, 322, -411, -411, -411, -411, -411, -411, -411, -411,
2214  -411, -411, -411, -411, -411, 0, 0, -411, -411, -411,
2215  0, 0, -411, 0, 0, 0, 0, 323, -411, 324,
2216  325, 326, 327, 328, 329, 330, 331, 332, 333, 0,
2217  0, 0, 0, 0, -411, 0, -411, -411, -411, -411,
2218  -411, -411, -411, -411, -411, -411, 0, 0, 0, 0,
2219  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2220  -411, -411, -411, -411, -411, -279, 220, -411, -411, -411,
2221  0, -411, 0, -279, -279, -279, 0, 0, -279, -279,
2222  -279, 0, -279, 0, 0, 0, 0, 0, 0, 0,
2223  0, 0, -279, -279, -279, 0, 0, 0, 0, 0,
2224  0, 0, -279, -279, 0, -279, -279, -279, -279, -279,
2225  0, 0, 0, 0, 0, 0, 308, 309, 310, 311,
2226  312, 313, 314, 315, 0, 317, 318, 0, 0, 0,
2227  0, 321, 322, -279, -279, -279, -279, -279, -279, -279,
2228  -279, -279, -279, -279, -279, -279, 0, 0, -279, -279,
2229  -279, 0, 0, -279, 0, 0, 0, 0, 0, -279,
2230  324, 325, 326, 327, 328, 329, 330, 331, 332, 333,
2231  0, 0, -279, 0, 0, -279, -279, -279, -279, -279,
2232  -279, -279, -279, -279, -279, -279, -279, 0, 0, 0,
2233  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2234  0, 0, -279, -279, -279, -279, -573, 0, -279, -279,
2235  -279, 0, -279, 0, -573, -573, -573, 0, 0, -573,
2236  -573, -573, 0, -573, 0, 0, 0, 0, 0, 0,
2237  0, 0, -573, -573, -573, 0, 0, 0, 0, 0,
2238  0, 0, 0, -573, -573, 0, -573, -573, -573, -573,
2239  -573, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2240  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2241  0, 0, 0, 0, -573, -573, -573, -573, -573, -573,
2242  -573, -573, -573, -573, -573, -573, -573, 0, 0, -573,
2243  -573, -573, 0, 0, -573, 0, 0, 0, 0, 0,
2244  -573, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2245  0, 0, 0, 0, 0, 0, -573, 0, -573, -573,
2246  -573, -573, -573, -573, -573, -573, -573, -573, 0, 0,
2247  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2248  0, 0, -573, -573, -573, -573, -573, -292, 220, -573,
2249  -573, -573, 0, -573, 0, -292, -292, -292, 0, 0,
2250  -292, -292, -292, 0, -292, 0, 0, 0, 0, 0,
2251  0, 0, 0, 0, -292, -292, 0, 0, 0, 0,
2252  0, 0, 0, 0, -292, -292, 0, -292, -292, -292,
2253  -292, -292, 0, 0, 0, 0, 0, 0, 0, 0,
2254  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2255  0, 0, 0, 0, 0, -292, -292, -292, -292, -292,
2256  -292, -292, -292, -292, -292, -292, -292, -292, 0, 0,
2257  -292, -292, -292, 0, 0, -292, 0, 0, 0, 0,
2258  0, -292, 0, 0, 0, 0, 0, 0, 0, 0,
2259  0, 0, 0, 0, 0, 0, 0, -292, 0, -292,
2260  -292, -292, -292, -292, -292, -292, -292, -292, -292, 0,
2261  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2262  0, 0, 0, 0, -292, -292, -292, -292, -555, 217,
2263  -292, -292, -292, 0, -292, 0, -555, -555, -555, 0,
2264  0, 0, -555, -555, 0, -555, 0, 0, 0, 0,
2265  0, 0, 0, 0, -555, 0, 0, 0, 0, 0,
2266  0, 0, 0, 0, 0, -555, -555, 0, -555, -555,
2267  -555, -555, -555, 0, 0, 0, 0, 0, 0, 0,
2268  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2269  0, 0, 0, 0, 0, 0, -555, -555, -555, -555,
2270  -555, -555, -555, -555, -555, -555, -555, -555, -555, 0,
2271  0, -555, -555, -555, -285, 665, 0, 0, 0, 0,
2272  0, 0, -285, -285, -285, 0, 0, 0, -285, -285,
2273  0, -285, 0, 0, 0, 0, 0, -103, -555, 0,
2274  -555, -555, -555, -555, -555, -555, -555, -555, -555, -555,
2275  0, -285, -285, 0, -285, -285, -285, -285, -285, 0,
2276  0, 0, 0, 0, -555, -555, -555, -555, -94, 0,
2277  0, -555, 0, -555, 0, -555, 0, 0, 0, 0,
2278  0, 0, -285, -285, -285, -285, -285, -285, -285, -285,
2279  -285, -285, -285, -285, -285, 0, 0, -285, -285, -285,
2280  0, 666, 0, 0, 0, 0, 0, 0, 0, 0,
2281  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2282  0, 0, 0, -105, -285, 0, -285, -285, -285, -285,
2283  -285, -285, -285, -285, -285, -285, 0, 0, 0, 0,
2284  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2285  0, -285, -285, -285, -96, 0, 0, -285, 0, -285,
2286  241, -285, 5, 6, 7, 8, 9, -573, -573, -573,
2287  10, 11, 0, 0, -573, 12, 0, 13, 14, 15,
2288  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2289  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2290  0, 0, 0, 0, 28, 29, 0, 31, 32, 33,
2291  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2292  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2293  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2294  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2295  0, 51, 52, 0, 53, 0, 54, 55, 56, 57,
2296  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2297  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2298  0, 61, 62, 63, 0, 0, 0, 0, 0, 0,
2299  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2300  0, 0, 0, 0, -573, 241, -573, 5, 6, 7,
2301  8, 9, 0, 0, -573, 10, 11, 0, -573, -573,
2302  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2303  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2304  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2305  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2306  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2307  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2308  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2309  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2310  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2311  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2312  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2313  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2314  0, 0, 0, 0, 0, 0, 0, 0, 0, -573,
2315  241, -573, 5, 6, 7, 8, 9, 0, 0, -573,
2316  10, 11, 0, 0, -573, 12, -573, 13, 14, 15,
2317  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2318  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2319  0, 0, 0, 0, 28, 29, 0, 31, 32, 33,
2320  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2321  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2322  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2323  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2324  0, 51, 52, 0, 53, 0, 54, 55, 56, 57,
2325  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2326  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2327  0, 61, 62, 63, 0, 0, 0, 0, 0, 0,
2328  4, 0, 5, 6, 7, 8, 9, 0, 0, 0,
2329  10, 11, 0, 0, -573, 12, -573, 13, 14, 15,
2330  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2331  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2332  0, 0, 0, 0, 28, 29, 30, 31, 32, 33,
2333  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2334  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2335  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2336  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2337  0, 51, 52, 0, 53, 0, 54, 55, 56, 57,
2338  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2339  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2340  0, 61, 62, 63, 0, 0, 0, 0, 0, 0,
2341  0, 0, 0, 0, 0, 0, -573, 0, 0, 0,
2342  0, 0, 0, 0, -573, 241, -573, 5, 6, 7,
2343  8, 9, 0, 0, -573, 10, 11, 0, 0, -573,
2344  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2345  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2346  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2347  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2348  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2349  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2350  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2351  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2352  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2353  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2354  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2355  0, 0, 0, 0, 0, 241, 0, 5, 6, 7,
2356  8, 9, 0, -573, -573, 10, 11, 0, 0, -573,
2357  12, -573, 13, 14, 15, 16, 17, 18, 19, 0,
2358  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2359  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2360  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2361  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2362  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2363  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2364  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2365  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2366  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2367  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2368  0, 0, 0, 0, 0, 241, 0, 5, 6, 7,
2369  8, 9, 0, 0, 0, 10, 11, 0, 0, -573,
2370  12, -573, 13, 14, 15, 16, 17, 18, 19, 0,
2371  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2372  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2373  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2374  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2375  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2376  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2377  48, 0, 0, 242, 50, 0, 51, 52, 0, 53,
2378  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2379  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2380  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2381  0, 0, 0, 0, 0, 241, 0, 5, 6, 7,
2382  8, 9, 0, 0, 0, 10, 11, -573, 0, -573,
2383  12, -573, 13, 14, 15, 16, 17, 18, 19, 0,
2384  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2385  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2386  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2387  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2388  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2389  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2390  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2391  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2392  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2393  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2394  0, 0, 0, 0, 0, 241, 0, 5, 6, 7,
2395  8, 9, 0, 0, 0, 10, 11, -573, 0, -573,
2396  12, -573, 13, 14, 15, 16, 17, 18, 19, 0,
2397  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2398  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2399  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2400  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2401  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2402  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2403  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2404  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2405  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2406  0, 0, 0, 0, 0, 0, 61, 62, 63, 0,
2407  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2408  0, -573, 0, 0, 0, 0, 0, 0, 0, -573,
2409  241, -573, 5, 6, 7, 8, 9, 0, 0, -573,
2410  10, 11, 0, 0, 0, 12, 0, 13, 14, 15,
2411  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2412  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2413  0, 0, 0, 0, 28, 29, 0, 31, 32, 33,
2414  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2415  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2416  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2417  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2418  0, 51, 52, 0, 53, 0, 54, 55, 56, 57,
2419  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2420  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2421  0, 61, 62, 63, 0, 0, 0, 0, 0, 0,
2422  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2423  10, 11, 0, 0, -573, 12, -573, 13, 14, 15,
2424  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2425  21, 22, 23, 24, 25, 26, 0, 0, 194, 0,
2426  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2427  34, 35, 36, 37, 38, 39, 40, 195, 41, 42,
2428  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2429  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2430  0, 0, 0, 0, 0, 196, 0, 0, 197, 50,
2431  0, 51, 52, 0, 198, 199, 54, 55, 56, 57,
2432  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2433  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2434  11, 61, 200, 63, 12, 0, 13, 14, 15, 16,
2435  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2436  22, 23, 24, 25, 26, 0, 224, 27, 0, 0,
2437  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2438  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2439  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2440  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2441  0, 0, 0, 0, 196, 0, 0, 197, 50, 0,
2442  51, 52, 0, 0, 0, 54, 55, 56, 57, 58,
2443  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2444  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2445  61, 62, 63, 0, 0, 0, 0, 0, 0, 0,
2446  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2447  11, 0, 0, 288, 12, 289, 13, 14, 15, 16,
2448  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2449  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2450  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2451  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2452  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2453  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2454  0, 0, 0, 0, 196, 0, 0, 197, 50, 0,
2455  51, 52, 0, 0, 0, 54, 55, 56, 57, 58,
2456  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2457  5, 6, 7, 8, 9, 0, 0, 0, 10, 11,
2458  61, 62, 63, 12, 0, 13, 14, 15, 16, 17,
2459  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2460  23, 24, 25, 26, 0, 224, 27, 0, 0, 0,
2461  0, 0, 28, 29, 30, 31, 32, 33, 34, 35,
2462  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2463  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2464  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2465  0, 0, 0, 48, 0, 0, 49, 50, 0, 51,
2466  52, 0, 53, 0, 54, 55, 56, 57, 58, 59,
2467  60, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2468  0, 0, 0, 0, 0, 0, 0, 0, 0, 61,
2469  62, 63, 0, 0, 0, 0, 0, 0, 5, 6,
2470  7, 8, 9, 0, 0, 0, 10, 11, 0, 0,
2471  0, 12, 474, 13, 14, 15, 16, 17, 18, 19,
2472  0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2473  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2474  28, 29, 0, 31, 32, 33, 34, 35, 36, 37,
2475  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2476  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2477  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2478  0, 48, 0, 0, 49, 50, 0, 51, 52, 0,
2479  53, 0, 54, 55, 56, 57, 58, 59, 60, 0,
2480  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2481  0, 0, 0, 0, 0, 0, 0, 61, 62, 63,
2482  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2483  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2484  474, 113, 114, 115, 116, 117, 118, 119, 120, 121,
2485  122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
2486  132, 133, 134, 135, 136, 0, 0, 0, 137, 138,
2487  139, 365, 366, 367, 368, 144, 145, 146, 0, 0,
2488  0, 0, 0, 147, 148, 149, 150, 369, 370, 371,
2489  372, 155, 37, 38, 373, 40, 0, 0, 0, 0,
2490  0, 0, 0, 0, 157, 158, 159, 160, 161, 162,
2491  163, 164, 165, 0, 0, 166, 167, 0, 0, 168,
2492  169, 170, 171, 0, 0, 0, 0, 0, 0, 0,
2493  0, 0, 0, 172, 0, 0, 0, 0, 0, 0,
2494  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2495  173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
2496  0, 183, 184, 0, 0, 0, 0, 0, -548, -548,
2497  -548, 0, -548, 0, 0, 0, -548, -548, 0, 185,
2498  374, -548, 0, -548, -548, -548, -548, -548, -548, -548,
2499  0, -548, 0, 0, 0, -548, -548, -548, -548, -548,
2500  -548, -548, 0, 0, -548, 0, 0, 0, 0, 0,
2501  0, -548, 0, 0, -548, -548, -548, -548, -548, -548,
2502  -548, -548, -548, -548, -548, -548, 0, -548, -548, -548,
2503  0, -548, -548, 0, 0, 0, 0, 0, 0, 0,
2504  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2505  0, -548, 0, 0, -548, -548, 0, -548, -548, 0,
2506  -548, -548, -548, -548, -548, -548, -548, -548, -548, 0,
2507  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2508  0, 0, 0, 0, 0, 0, 0, -548, -548, -548,
2509  0, 0, 0, 0, 0, -549, -549, -549, 0, -549,
2510  0, -548, 0, -549, -549, 0, 0, -548, -549, 0,
2511  -549, -549, -549, -549, -549, -549, -549, 0, -549, 0,
2512  0, 0, -549, -549, -549, -549, -549, -549, -549, 0,
2513  0, -549, 0, 0, 0, 0, 0, 0, -549, 0,
2514  0, -549, -549, -549, -549, -549, -549, -549, -549, -549,
2515  -549, -549, -549, 0, -549, -549, -549, 0, -549, -549,
2516  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2517  0, 0, 0, 0, 0, 0, 0, 0, -549, 0,
2518  0, -549, -549, 0, -549, -549, 0, -549, -549, -549,
2519  -549, -549, -549, -549, -549, -549, 0, 0, 0, 0,
2520  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2521  0, 0, 0, 0, -549, -549, -549, 0, 0, 0,
2522  0, 0, -551, -551, -551, 0, -551, 0, -549, 0,
2523  -551, -551, 0, 0, -549, -551, 0, -551, -551, -551,
2524  -551, -551, -551, -551, 0, 0, 0, 0, 0, -551,
2525  -551, -551, -551, -551, -551, -551, 0, 0, -551, 0,
2526  0, 0, 0, 0, 0, -551, 0, 0, -551, -551,
2527  -551, -551, -551, -551, -551, -551, -551, -551, -551, -551,
2528  0, -551, -551, -551, 0, -551, -551, 0, 0, 0,
2529  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2530  0, 0, 0, 0, 0, -551, 723, 0, -551, -551,
2531  0, -551, -551, 0, -551, -551, -551, -551, -551, -551,
2532  -551, -551, -551, 0, 0, 0, 0, 0, -103, 0,
2533  0, 0, 0, 0, 0, 0, -553, -553, -553, 0,
2534  -553, -551, -551, -551, -553, -553, 0, 0, 0, -553,
2535  0, -553, -553, -553, -553, -553, -553, -553, 0, 0,
2536  0, -551, 0, -553, -553, -553, -553, -553, -553, -553,
2537  0, 0, -553, 0, 0, 0, 0, 0, 0, -553,
2538  0, 0, -553, -553, -553, -553, -553, -553, -553, -553,
2539  -553, -553, -553, -553, 0, -553, -553, -553, 0, -553,
2540  -553, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2541  0, 0, 0, 0, 0, 0, 0, 0, 0, -553,
2542  0, 0, -553, -553, 0, -553, -553, 0, -553, -553,
2543  -553, -553, -553, -553, -553, -553, -553, 0, 0, 0,
2544  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2545  -554, -554, -554, 0, -554, -553, -553, -553, -554, -554,
2546  0, 0, 0, -554, 0, -554, -554, -554, -554, -554,
2547  -554, -554, 0, 0, 0, -553, 0, -554, -554, -554,
2548  -554, -554, -554, -554, 0, 0, -554, 0, 0, 0,
2549  0, 0, 0, -554, 0, 0, -554, -554, -554, -554,
2550  -554, -554, -554, -554, -554, -554, -554, -554, 0, -554,
2551  -554, -554, 0, -554, -554, 0, 0, 0, 0, 0,
2552  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2553  0, 0, 0, -554, 0, 0, -554, -554, 0, -554,
2554  -554, 0, -554, -554, -554, -554, -554, -554, -554, -554,
2555  -554, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2556  0, 0, 0, 0, 0, 0, 0, 0, 0, -554,
2557  -554, -554, 0, 0, 0, 0, 0, 0, 0, 0,
2558  0, 0, 0, 0, 0, 0, 0, 0, 0, -554,
2559  113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
2560  123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
2561  133, 134, 135, 136, 0, 0, 0, 137, 138, 139,
2562  140, 141, 142, 143, 144, 145, 146, 0, 0, 0,
2563  0, 0, 147, 148, 149, 150, 151, 152, 153, 154,
2564  155, 270, 271, 156, 272, 0, 0, 0, 0, 0,
2565  0, 0, 0, 157, 158, 159, 160, 161, 162, 163,
2566  164, 165, 0, 0, 166, 167, 0, 0, 168, 169,
2567  170, 171, 0, 0, 0, 0, 0, 0, 0, 0,
2568  0, 0, 172, 0, 0, 0, 0, 0, 0, 0,
2569  0, 0, 0, 0, 0, 0, 0, 0, 0, 173,
2570  174, 175, 176, 177, 178, 179, 180, 181, 182, 0,
2571  183, 184, 0, 0, 0, 0, 0, 0, 0, 0,
2572  0, 0, 0, 0, 0, 0, 0, 0, 185, 113,
2573  114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
2574  124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
2575  134, 135, 136, 0, 0, 0, 137, 138, 139, 140,
2576  141, 142, 143, 144, 145, 146, 0, 0, 0, 0,
2577  0, 147, 148, 149, 150, 151, 152, 153, 154, 155,
2578  226, 0, 156, 0, 0, 0, 0, 0, 0, 0,
2579  0, 0, 157, 158, 159, 160, 161, 162, 163, 164,
2580  165, 0, 0, 166, 167, 0, 0, 168, 169, 170,
2581  171, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2582  0, 172, 0, 0, 55, 0, 0, 0, 0, 0,
2583  0, 0, 0, 0, 0, 0, 0, 0, 173, 174,
2584  175, 176, 177, 178, 179, 180, 181, 182, 0, 183,
2585  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2586  0, 0, 0, 0, 0, 0, 0, 185, 113, 114,
2587  115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
2588  125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
2589  135, 136, 0, 0, 0, 137, 138, 139, 140, 141,
2590  142, 143, 144, 145, 146, 0, 0, 0, 0, 0,
2591  147, 148, 149, 150, 151, 152, 153, 154, 155, 0,
2592  0, 156, 0, 0, 0, 0, 0, 0, 0, 0,
2593  0, 157, 158, 159, 160, 161, 162, 163, 164, 165,
2594  0, 0, 166, 167, 0, 0, 168, 169, 170, 171,
2595  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2596  172, 0, 0, 55, 0, 0, 0, 0, 0, 0,
2597  0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
2598  176, 177, 178, 179, 180, 181, 182, 0, 183, 184,
2599  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2600  0, 0, 0, 0, 0, 0, 185, 113, 114, 115,
2601  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
2602  126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
2603  136, 0, 0, 0, 137, 138, 139, 140, 141, 142,
2604  143, 144, 145, 146, 0, 0, 0, 0, 0, 147,
2605  148, 149, 150, 151, 152, 153, 154, 155, 0, 0,
2606  156, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2607  157, 158, 159, 160, 161, 162, 163, 164, 165, 0,
2608  0, 166, 167, 0, 0, 168, 169, 170, 171, 0,
2609  0, 0, 0, 0, 0, 0, 0, 0, 0, 172,
2610  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2611  0, 0, 0, 0, 0, 0, 173, 174, 175, 176,
2612  177, 178, 179, 180, 181, 182, 0, 183, 184, 0,
2613  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2614  11, 0, 0, 0, 12, 185, 13, 14, 15, 231,
2615  232, 18, 19, 0, 0, 0, 0, 0, 233, 234,
2616  235, 23, 24, 25, 26, 0, 0, 194, 0, 0,
2617  0, 0, 0, 0, 258, 0, 0, 32, 33, 34,
2618  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2619  43, 44, 45, 0, 0, 0, 0, 0, 0, 0,
2620  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2621  0, 0, 0, 0, 259, 0, 0, 197, 50, 0,
2622  51, 52, 0, 0, 0, 54, 55, 56, 57, 58,
2623  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2624  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2625  260, 10, 11, 0, 0, 0, 12, 0, 13, 14,
2626  15, 231, 232, 18, 19, 0, 0, 0, 261, 0,
2627  233, 234, 235, 23, 24, 25, 26, 0, 0, 194,
2628  0, 0, 0, 0, 0, 0, 258, 0, 0, 32,
2629  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2630  42, 0, 43, 44, 45, 0, 0, 0, 0, 0,
2631  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2632  0, 0, 0, 0, 0, 0, 259, 0, 0, 197,
2633  50, 0, 51, 52, 0, 0, 0, 54, 55, 56,
2634  57, 58, 59, 60, 0, 0, 0, 0, 0, 0,
2635  0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
2636  0, 0, 260, 10, 11, 0, 0, 0, 12, 0,
2637  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2638  490, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2639  0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
2640  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2641  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2642  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2643  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2644  0, 49, 50, 0, 51, 52, 0, 53, 0, 54,
2645  55, 56, 57, 58, 59, 60, 0, 0, 0, 0,
2646  0, 0, 0, 0, 5, 6, 7, 8, 9, 0,
2647  0, 0, 10, 11, 61, 62, 63, 12, 0, 13,
2648  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2649  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2650  27, 0, 0, 0, 0, 0, 28, 29, 0, 31,
2651  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2652  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2653  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2654  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2655  49, 50, 0, 51, 52, 0, 53, 0, 54, 55,
2656  56, 57, 58, 59, 60, 0, 0, 0, 0, 0,
2657  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2658  0, 10, 11, 61, 62, 63, 12, 0, 13, 14,
2659  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2660  20, 21, 22, 23, 24, 25, 26, 0, 0, 194,
2661  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
2662  33, 34, 35, 36, 37, 38, 39, 40, 195, 41,
2663  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2664  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2665  0, 0, 0, 0, 0, 0, 196, 0, 0, 197,
2666  50, 0, 51, 52, 0, 198, 199, 54, 55, 56,
2667  57, 58, 59, 60, 0, 0, 0, 0, 0, 0,
2668  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2669  10, 11, 61, 200, 63, 12, 0, 13, 14, 15,
2670  231, 232, 18, 19, 0, 0, 0, 0, 0, 233,
2671  234, 235, 23, 24, 25, 26, 0, 0, 194, 0,
2672  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2673  34, 35, 36, 37, 38, 39, 40, 195, 41, 42,
2674  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2675  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2676  0, 0, 0, 0, 0, 196, 0, 0, 197, 50,
2677  0, 51, 52, 0, 587, 199, 54, 55, 56, 57,
2678  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2679  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2680  11, 61, 200, 63, 12, 0, 13, 14, 15, 231,
2681  232, 18, 19, 0, 0, 0, 0, 0, 233, 234,
2682  235, 23, 24, 25, 26, 0, 0, 194, 0, 0,
2683  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2684  35, 36, 37, 38, 39, 40, 195, 41, 42, 0,
2685  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2686  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2687  0, 0, 0, 0, 196, 0, 0, 197, 50, 0,
2688  51, 52, 0, 198, 0, 54, 55, 56, 57, 58,
2689  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2690  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2691  61, 200, 63, 12, 0, 13, 14, 15, 231, 232,
2692  18, 19, 0, 0, 0, 0, 0, 233, 234, 235,
2693  23, 24, 25, 26, 0, 0, 194, 0, 0, 0,
2694  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2695  36, 37, 38, 39, 40, 195, 41, 42, 0, 43,
2696  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2697  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2698  0, 0, 0, 196, 0, 0, 197, 50, 0, 51,
2699  52, 0, 0, 199, 54, 55, 56, 57, 58, 59,
2700  60, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2701  6, 7, 0, 9, 0, 0, 0, 10, 11, 61,
2702  200, 63, 12, 0, 13, 14, 15, 231, 232, 18,
2703  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2704  24, 25, 26, 0, 0, 194, 0, 0, 0, 0,
2705  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2706  37, 38, 39, 40, 195, 41, 42, 0, 43, 44,
2707  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2708  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2709  0, 0, 196, 0, 0, 197, 50, 0, 51, 52,
2710  0, 587, 0, 54, 55, 56, 57, 58, 59, 60,
2711  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2712  7, 0, 9, 0, 0, 0, 10, 11, 61, 200,
2713  63, 12, 0, 13, 14, 15, 231, 232, 18, 19,
2714  0, 0, 0, 0, 0, 233, 234, 235, 23, 24,
2715  25, 26, 0, 0, 194, 0, 0, 0, 0, 0,
2716  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2717  38, 39, 40, 195, 41, 42, 0, 43, 44, 45,
2718  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2719  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2720  0, 196, 0, 0, 197, 50, 0, 51, 52, 0,
2721  0, 0, 54, 55, 56, 57, 58, 59, 60, 0,
2722  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2723  0, 9, 0, 0, 0, 10, 11, 61, 200, 63,
2724  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2725  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2726  26, 0, 0, 194, 0, 0, 0, 0, 0, 0,
2727  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2728  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2729  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2730  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2731  196, 0, 0, 197, 50, 0, 51, 52, 0, 484,
2732  0, 54, 55, 56, 57, 58, 59, 60, 0, 0,
2733  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2734  9, 0, 0, 0, 10, 11, 61, 200, 63, 12,
2735  0, 13, 14, 15, 231, 232, 18, 19, 0, 0,
2736  0, 0, 0, 233, 234, 235, 23, 24, 25, 26,
2737  0, 0, 194, 0, 0, 0, 0, 0, 0, 29,
2738  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2739  40, 0, 41, 42, 0, 43, 44, 45, 0, 46,
2740  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2741  0, 0, 0, 0, 0, 0, 0, 0, 0, 196,
2742  0, 0, 197, 50, 0, 51, 52, 0, 198, 0,
2743  54, 55, 56, 57, 58, 59, 60, 0, 0, 0,
2744  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2745  0, 0, 0, 10, 11, 61, 200, 63, 12, 0,
2746  13, 14, 15, 231, 232, 18, 19, 0, 0, 0,
2747  0, 0, 233, 234, 235, 23, 24, 25, 26, 0,
2748  0, 194, 0, 0, 0, 0, 0, 0, 29, 0,
2749  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2750  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2751  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2752  0, 0, 0, 0, 0, 0, 0, 0, 196, 0,
2753  0, 197, 50, 0, 51, 52, 0, 772, 0, 54,
2754  55, 56, 57, 58, 59, 60, 0, 0, 0, 0,
2755  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2756  0, 0, 10, 11, 61, 200, 63, 12, 0, 13,
2757  14, 15, 231, 232, 18, 19, 0, 0, 0, 0,
2758  0, 233, 234, 235, 23, 24, 25, 26, 0, 0,
2759  194, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2760  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2761  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2762  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2763  0, 0, 0, 0, 0, 0, 0, 196, 0, 0,
2764  197, 50, 0, 51, 52, 0, 484, 0, 54, 55,
2765  56, 57, 58, 59, 60, 0, 0, 0, 0, 0,
2766  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2767  0, 10, 11, 61, 200, 63, 12, 0, 13, 14,
2768  15, 231, 232, 18, 19, 0, 0, 0, 0, 0,
2769  233, 234, 235, 23, 24, 25, 26, 0, 0, 194,
2770  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
2771  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2772  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2773  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2774  0, 0, 0, 0, 0, 0, 196, 0, 0, 197,
2775  50, 0, 51, 52, 0, 587, 0, 54, 55, 56,
2776  57, 58, 59, 60, 0, 0, 0, 0, 0, 0,
2777  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2778  10, 11, 61, 200, 63, 12, 0, 13, 14, 15,
2779  231, 232, 18, 19, 0, 0, 0, 0, 0, 233,
2780  234, 235, 23, 24, 25, 26, 0, 0, 194, 0,
2781  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2782  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2783  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2784  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2785  0, 0, 0, 0, 0, 196, 0, 0, 197, 50,
2786  0, 51, 52, 0, 0, 0, 54, 55, 56, 57,
2787  58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
2788  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2789  11, 61, 200, 63, 12, 0, 13, 14, 15, 16,
2790  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2791  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2792  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2793  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2794  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2795  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2796  0, 0, 0, 0, 196, 0, 0, 197, 50, 0,
2797  51, 52, 0, 0, 0, 54, 55, 56, 57, 58,
2798  59, 60, 0, 0, 0, 0, 0, 0, 0, 0,
2799  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2800  61, 62, 63, 12, 0, 13, 14, 15, 16, 17,
2801  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2802  23, 24, 25, 26, 0, 0, 194, 0, 0, 0,
2803  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2804  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2805  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2806  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2807  0, 0, 0, 196, 0, 0, 197, 50, 0, 51,
2808  52, 0, 0, 0, 54, 55, 56, 57, 58, 59,
2809  60, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2810  6, 7, 0, 9, 0, 0, 0, 10, 11, 61,
2811  200, 63, 12, 0, 13, 14, 15, 231, 232, 18,
2812  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2813  24, 25, 26, 0, 0, 194, 0, 0, 0, 0,
2814  0, 0, 258, 0, 0, 32, 33, 34, 35, 36,
2815  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2816  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2817  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2818  0, 0, 259, 0, 0, 304, 50, 0, 51, 52,
2819  0, 305, 0, 54, 55, 56, 57, 58, 59, 60,
2820  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2821  0, 0, 10, 11, 0, 0, 0, 12, 260, 13,
2822  14, 15, 231, 232, 18, 19, 0, 0, 0, 0,
2823  0, 233, 234, 235, 23, 24, 25, 26, 0, 0,
2824  194, 0, 0, 0, 0, 0, 0, 258, 0, 0,
2825  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2826  41, 42, 0, 43, 44, 45, 0, 0, 0, 0,
2827  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2828  0, 0, 0, 0, 0, 0, 0, 346, 0, 0,
2829  49, 50, 0, 51, 52, 0, 53, 0, 54, 55,
2830  56, 57, 58, 59, 60, 0, 0, 0, 0, 5,
2831  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
2832  0, 0, 12, 260, 13, 14, 15, 231, 232, 18,
2833  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2834  24, 25, 26, 0, 0, 194, 0, 0, 0, 0,
2835  0, 0, 258, 0, 0, 32, 33, 34, 354, 36,
2836  37, 38, 355, 40, 0, 41, 42, 0, 43, 44,
2837  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2838  0, 0, 0, 0, 0, 0, 0, 0, 0, 356,
2839  0, 0, 357, 0, 0, 197, 50, 0, 51, 52,
2840  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2841  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2842  0, 0, 10, 11, 0, 0, 0, 12, 260, 13,
2843  14, 15, 231, 232, 18, 19, 0, 0, 0, 0,
2844  0, 233, 234, 235, 23, 24, 25, 26, 0, 0,
2845  194, 0, 0, 0, 0, 0, 0, 258, 0, 0,
2846  32, 33, 34, 354, 36, 37, 38, 355, 40, 0,
2847  41, 42, 0, 43, 44, 45, 0, 0, 0, 0,
2848  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2849  0, 0, 0, 0, 0, 0, 0, 357, 0, 0,
2850  197, 50, 0, 51, 52, 0, 0, 0, 54, 55,
2851  56, 57, 58, 59, 60, 0, 0, 0, 0, 5,
2852  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
2853  0, 0, 12, 260, 13, 14, 15, 231, 232, 18,
2854  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2855  24, 25, 26, 0, 0, 194, 0, 0, 0, 0,
2856  0, 0, 258, 0, 0, 32, 33, 34, 35, 36,
2857  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2858  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2859  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2860  0, 0, 259, 0, 0, 304, 50, 0, 51, 52,
2861  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2862  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2863  0, 0, 10, 11, 0, 0, 0, 12, 260, 13,
2864  14, 15, 231, 232, 18, 19, 0, 0, 0, 0,
2865  0, 233, 234, 235, 23, 24, 25, 26, 0, 0,
2866  194, 0, 0, 0, 0, 0, 0, 258, 0, 0,
2867  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2868  41, 42, 0, 43, 44, 45, 0, 0, 0, 0,
2869  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2870  0, 0, 0, 0, 0, 0, 0, 902, 0, 0,
2871  197, 50, 0, 51, 52, 0, 0, 0, 54, 55,
2872  56, 57, 58, 59, 60, 0, 0, 0, 0, 5,
2873  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
2874  0, 0, 12, 260, 13, 14, 15, 231, 232, 18,
2875  19, 0, 0, 0, 0, 0, 233, 234, 235, 23,
2876  24, 25, 26, 0, 0, 194, 0, 663, 0, 0,
2877  0, 0, 258, 0, 0, 32, 33, 34, 35, 36,
2878  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2879  45, 308, 309, 310, 311, 312, 313, 314, 315, 316,
2880  317, 318, 319, 320, 0, 0, 321, 322, 0, 0,
2881  0, 0, 912, 0, 0, 197, 50, 0, 51, 52,
2882  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2883  0, 0, 0, 323, 0, 324, 325, 326, 327, 328,
2884  329, 330, 331, 332, 333, 0, 0, 0, 260, 0,
2885  525, 526, 0, 0, 527, 0, 0, 0, 0, 0,
2886  0, 0, 0, -241, 157, 158, 159, 160, 161, 162,
2887  163, 164, 165, 0, 0, 166, 167, 0, 0, 168,
2888  169, 170, 171, 0, 0, 0, 0, 0, 0, 0,
2889  0, 0, 0, 172, 0, 0, 0, 0, 0, 0,
2890  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2891  173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
2892  0, 183, 184, 0, 0, 0, 0, 533, 534, 0,
2893  0, 535, 0, 0, 0, 0, 0, 0, 0, 185,
2894  220, 157, 158, 159, 160, 161, 162, 163, 164, 165,
2895  0, 0, 166, 167, 0, 0, 168, 169, 170, 171,
2896  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2897  172, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2898  0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
2899  176, 177, 178, 179, 180, 181, 182, 0, 183, 184,
2900  0, 0, 0, 0, 591, 526, 0, 0, 592, 0,
2901  0, 0, 0, 0, 0, 0, 185, 220, 157, 158,
2902  159, 160, 161, 162, 163, 164, 165, 0, 0, 166,
2903  167, 0, 0, 168, 169, 170, 171, 0, 0, 0,
2904  0, 0, 0, 0, 0, 0, 0, 172, 0, 0,
2905  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2906  0, 0, 0, 0, 173, 174, 175, 176, 177, 178,
2907  179, 180, 181, 182, 0, 183, 184, 0, 0, 0,
2908  0, 594, 534, 0, 0, 595, 0, 0, 0, 0,
2909  0, 0, 0, 185, 220, 157, 158, 159, 160, 161,
2910  162, 163, 164, 165, 0, 0, 166, 167, 0, 0,
2911  168, 169, 170, 171, 0, 0, 0, 0, 0, 0,
2912  0, 0, 0, 0, 172, 0, 0, 0, 0, 0,
2913  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2914  0, 173, 174, 175, 176, 177, 178, 179, 180, 181,
2915  182, 0, 183, 184, 0, 0, 0, 0, 617, 526,
2916  0, 0, 618, 0, 0, 0, 0, 0, 0, 0,
2917  185, 220, 157, 158, 159, 160, 161, 162, 163, 164,
2918  165, 0, 0, 166, 167, 0, 0, 168, 169, 170,
2919  171, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2920  0, 172, 0, 0, 0, 0, 0, 0, 0, 0,
2921  0, 0, 0, 0, 0, 0, 0, 0, 173, 174,
2922  175, 176, 177, 178, 179, 180, 181, 182, 0, 183,
2923  184, 0, 0, 0, 0, 620, 534, 0, 0, 621,
2924  0, 0, 0, 0, 0, 0, 0, 185, 220, 157,
2925  158, 159, 160, 161, 162, 163, 164, 165, 0, 0,
2926  166, 167, 0, 0, 168, 169, 170, 171, 0, 0,
2927  0, 0, 0, 0, 0, 0, 0, 0, 172, 0,
2928  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2929  0, 0, 0, 0, 0, 173, 174, 175, 176, 177,
2930  178, 179, 180, 181, 182, 0, 183, 184, 0, 0,
2931  0, 0, 692, 526, 0, 0, 693, 0, 0, 0,
2932  0, 0, 0, 0, 185, 220, 157, 158, 159, 160,
2933  161, 162, 163, 164, 165, 0, 0, 166, 167, 0,
2934  0, 168, 169, 170, 171, 0, 0, 0, 0, 0,
2935  0, 0, 0, 0, 0, 172, 0, 0, 0, 0,
2936  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2937  0, 0, 173, 174, 175, 176, 177, 178, 179, 180,
2938  181, 182, 0, 183, 184, 0, 0, 0, 0, 695,
2939  534, 0, 0, 696, 0, 0, 0, 0, 0, 0,
2940  0, 185, 220, 157, 158, 159, 160, 161, 162, 163,
2941  164, 165, 0, 0, 166, 167, 0, 0, 168, 169,
2942  170, 171, 0, 0, 0, 0, 0, 0, 0, 0,
2943  0, 0, 172, 0, 0, 0, 0, 0, 0, 0,
2944  0, 0, 0, 0, 0, 0, 0, 0, 0, 173,
2945  174, 175, 176, 177, 178, 179, 180, 181, 182, 0,
2946  183, 184, 0, 0, 0, 0, 702, 526, 0, 0,
2947  703, 0, 0, 0, 0, 0, 0, 0, 185, 220,
2948  157, 158, 159, 160, 161, 162, 163, 164, 165, 0,
2949  0, 166, 167, 0, 0, 168, 169, 170, 171, 0,
2950  0, 0, 0, 0, 0, 0, 0, 0, 0, 172,
2951  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2952  0, 0, 0, 0, 0, 0, 173, 174, 175, 176,
2953  177, 178, 179, 180, 181, 182, 0, 183, 184, 0,
2954  0, 0, 0, 572, 534, 0, 0, 573, 0, 0,
2955  0, 0, 0, 0, 0, 185, 220, 157, 158, 159,
2956  160, 161, 162, 163, 164, 165, 0, 0, 166, 167,
2957  0, 0, 168, 169, 170, 171, 0, 0, 0, 0,
2958  0, 0, 0, 0, 0, 0, 172, 0, 0, 0,
2959  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2960  0, 0, 0, 173, 174, 175, 176, 177, 178, 179,
2961  180, 181, 182, 0, 183, 184, 0, 0, 0, 0,
2962  965, 526, 0, 0, 966, 0, 0, 0, 0, 0,
2963  0, 0, 185, 220, 157, 158, 159, 160, 161, 162,
2964  163, 164, 165, 0, 0, 166, 167, 0, 0, 168,
2965  169, 170, 171, 0, 0, 0, 0, 0, 0, 0,
2966  0, 0, 0, 172, 0, 0, 0, 0, 0, 0,
2967  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2968  173, 174, 175, 176, 177, 178, 179, 180, 181, 182,
2969  0, 183, 184, 0, 0, 0, 0, 971, 526, 0,
2970  0, 972, 0, 0, 0, 0, 0, 0, 0, 185,
2971  220, 157, 158, 159, 160, 161, 162, 163, 164, 165,
2972  0, 0, 166, 167, 0, 0, 168, 169, 170, 171,
2973  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2974  172, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2975  0, 0, 0, 0, 0, 0, 0, 173, 174, 175,
2976  176, 177, 178, 179, 180, 181, 182, 0, 183, 184,
2977  0, 0, 0, 0, 974, 534, 0, 0, 975, 0,
2978  0, 0, 0, 0, 0, 0, 185, 220, 157, 158,
2979  159, 160, 161, 162, 163, 164, 165, 0, 0, 166,
2980  167, 0, 0, 168, 169, 170, 171, 0, 0, 0,
2981  0, 0, 0, 0, 0, 0, 0, 172, 0, 0,
2982  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2983  0, 0, 0, 0, 173, 174, 175, 176, 177, 178,
2984  179, 180, 181, 182, 0, 183, 184, 0, 0, 0,
2985  0, 572, 534, 0, 0, 573, 0, 0, 0, 0,
2986  0, 0, 0, 185, 220, 157, 158, 159, 160, 161,
2987  162, 163, 164, 165, 0, 0, 166, 167, 0, 0,
2988  168, 169, 170, 171, 0, 0, 0, 0, 0, 0,
2989  0, 0, 0, 0, 172, 0, 0, 0, 0, 0,
2990  0, 0, 718, 0, 0, 0, 0, 0, 0, 0,
2991  0, 173, 174, 175, 176, 177, 178, 179, 180, 181,
2992  182, 663, 183, 184, 0, 0, 308, 309, 310, 311,
2993  312, 313, 314, 315, 316, 317, 318, 319, 320, 0,
2994  185, 321, 322, 0, 0, 308, 309, 310, 311, 312,
2995  313, 314, 315, 316, 317, 318, 319, 320, 0, 0,
2996  321, 322, 0, 0, 0, 0, 0, 0, 323, 0,
2997  324, 325, 326, 327, 328, 329, 330, 331, 332, 333,
2998  0, 0, 0, 0, 0, 0, 0, 323, 0, 324,
2999  325, 326, 327, 328, 329, 330, 331, 332, 333
3000 };
3001 
3002 #define yypact_value_is_default(yystate) \
3003  ((yystate) == (-747))
3004 
3005 #define yytable_value_is_error(yytable_value) \
3006  ((yytable_value) == (-574))
3007 
3008 static const yytype_int16 yycheck[] =
3009 {
3010  2, 55, 340, 28, 2, 454, 4, 52, 593, 16,
3011  17, 335, 307, 20, 307, 8, 547, 213, 16, 17,
3012  8, 566, 20, 27, 53, 29, 84, 22, 8, 87,
3013  546, 87, 4, 22, 619, 28, 49, 91, 252, 76,
3014  28, 2, 256, 4, 404, 357, 1, 65, 28, 51,
3015  52, 49, 50, 749, 450, 53, 746, 13, 334, 627,
3016  336, 53, 680, 25, 62, 762, 684, 454, 13, 16,
3017  17, 65, 26, 20, 396, 55, 400, 26, 76, 25,
3018  440, 0, 404, 27, 76, 83, 84, 576, 577, 87,
3019  88, 89, 90, 87, 490, 29, 88, 89, 90, 13,
3020  242, 25, 378, 379, 51, 851, 828, 85, 76, 694,
3021  136, 91, 87, 16, 17, 110, 147, 20, 85, 568,
3022  705, 110, 146, 399, 25, 401, 85, 653, 452, 61,
3023  87, 16, 17, 62, 109, 20, 276, 25, 278, 56,
3024  280, 13, 742, 37, 38, 87, 114, 109, 51, 52,
3025  195, 427, 109, 198, 199, 826, 701, 28, 113, 849,
3026  138, 139, 304, 763, 709, 140, 25, 109, 736, 737,
3027  25, 13, 139, 107, 106, 146, 13, 453, 140, 138,
3028  139, 143, 136, 632, 140, 147, 109, 136, 244, 145,
3029  145, 147, 147, 142, 140, 941, 892, 142, 140, 197,
3030  145, 145, 147, 147, 653, 207, 896, 904, 930, 140,
3031  217, 213, 219, 220, 25, 886, 140, 413, 220, 217,
3032  746, 219, 220, 749, 261, 223, 244, 225, 552, 242,
3033  719, 145, 230, 147, 50, 293, 294, 295, 296, 140,
3034  564, 601, 142, 241, 242, 632, 235, 147, 109, 238,
3035  244, 563, 140, 147, 258, 873, 99, 302, 826, 708,
3036  828, 932, 307, 261, 25, 661, 87, 83, 84, 261,
3037  217, 87, 219, 145, 140, 147, 305, 553, 600, 601,
3038  241, 140, 25, 341, 342, 140, 25, 343, 959, 565,
3039  806, 304, 85, 87, 292, 293, 294, 295, 296, 297,
3040  298, 299, 85, 145, 302, 147, 304, 305, 145, 307,
3041  147, 59, 60, 305, 217, 109, 219, 26, 886, 887,
3042  292, 708, 109, 849, 142, 851, 49, 467, 335, 140,
3043  875, 292, 217, 335, 219, 56, 297, 335, 145, 337,
3044  147, 87, 873, 341, 342, 138, 139, 336, 88, 343,
3045  395, 396, 690, 140, 334, 302, 139, 26, 356, 404,
3046  307, 140, 930, 109, 932, 359, 892, 85, 147, 662,
3047  109, 85, 109, 302, 61, 26, 85, 140, 307, 140,
3048  15, 142, 17, 928, 679, 87, 384, 385, 973, 85,
3049  85, 959, 437, 400, 590, 440, 421, 140, 400, 142,
3050  614, 140, 400, 85, 143, 140, 85, 223, 147, 225,
3051  412, 413, 401, 450, 142, 941, 85, 104, 105, 399,
3052  138, 139, 424, 136, 142, 139, 424, 136, 421, 138,
3053  139, 880, 85, 421, 85, 433, 85, 142, 427, 484,
3054  140, 421, 138, 139, 139, 452, 426, 147, 85, 142,
3055  452, 85, 450, 490, 452, 384, 385, 139, 450, 146,
3056  139, 85, 822, 424, 453, 68, 85, 136, 85, 138,
3057  139, 451, 433, 142, 197, 87, 85, 293, 294, 295,
3058  296, 483, 298, 299, 68, 136, 139, 138, 139, 138,
3059  139, 142, 490, 396, 85, 37, 38, 109, 490, 668,
3060  822, 223, 139, 548, 138, 139, 675, 230, 109, 52,
3061  514, 54, 55, 56, 57, 139, 119, 120, 121, 242,
3062  139, 138, 139, 861, 246, 341, 342, 143, 532, 867,
3063  139, 26, 728, 52, 437, 530, 538, 56, 540, 85,
3064  356, 530, 587, 538, 542, 552, 544, 138, 139, 538,
3065  552, 545, 546, 56, 552, 600, 601, 564, 85, 584,
3066  59, 60, 564, 144, 553, 559, 564, 137, 566, 567,
3067  106, 551, 574, 575, 576, 577, 565, 87, 615, 574,
3068  575, 304, 140, 563, 106, 574, 575, 87, 590, 593,
3069  85, 584, 138, 139, 87, 85, 584, 140, 68, 109,
3070  68, 548, 14, 15, 584, 85, 604, 609, 85, 109,
3071  140, 138, 139, 658, 17, 619, 109, 615, 56, 608,
3072  609, 574, 575, 615, 661, 145, 25, 951, 52, 94,
3073  54, 55, 56, 57, 679, 143, 638, 146, 640, 697,
3074  642, 136, 700, 138, 139, 137, 140, 142, 138, 139,
3075  52, 653, 54, 55, 56, 57, 654, 711, 138, 139,
3076  10, 138, 139, 661, 662, 89, 61, 665, 666, 661,
3077  65, 95, 96, 671, 672, 109, 952, 679, 680, 140,
3078  682, 140, 684, 140, 406, 140, 140, 89, 410, 734,
3079  694, 140, 116, 415, 96, 119, 8, 600, 13, 697,
3080  87, 705, 700, 701, 698, 61, 87, 137, 430, 104,
3081  105, 709, 109, 435, 116, 54, 710, 719, 716, 717,
3082  140, 145, 109, 140, 63, 64, 728, 772, 109, 140,
3083  68, 711, 679, 662, 87, 52, 665, 666, 796, 52,
3084  742, 111, 671, 672, 140, 743, 744, 87, 104, 105,
3085  106, 567, 144, 140, 549, 15, 109, 755, 803, 140,
3086  2, 763, 4, 765, 87, 767, 768, 489, 52, 109,
3087  54, 55, 56, 57, 16, 17, 140, 822, 20, 117,
3088  118, 119, 120, 121, 145, 783, 109, 140, 604, 791,
3089  109, 140, 794, 114, 140, 793, 140, 140, 796, 10,
3090  140, 88, 800, 801, 140, 9, 804, 49, 50, 10,
3091  137, 140, 806, 10, 808, 61, 140, 140, 140, 542,
3092  62, 544, 820, 137, 140, 114, 52, 137, 54, 55,
3093  56, 57, 834, 835, 140, 837, 68, 839, 840, 140,
3094  140, 83, 84, 137, 842, 87, 56, 140, 140, 68,
3095  842, 83, 84, 56, 783, 140, 140, 140, 104, 105,
3096  106, 140, 860, 89, 83, 84, 864, 140, 860, 95,
3097  96, 873, 142, 142, 61, 140, 424, 875, 90, 88,
3098  61, 697, 954, 736, 700, 117, 118, 119, 120, 121,
3099  116, 93, 904, 119, 689, 114, 115, 116, 117, 118,
3100  119, 120, 121, 953, 906, 907, 908, 96, 910, 911,
3101  640, 706, 642, 57, 91, 880, 142, 104, 105, 106,
3102  918, 849, 920, 104, 105, 106, 653, 746, 926, -1,
3103  928, 654, 934, 935, 936, 937, 52, -1, 54, 55,
3104  56, 57, -1, -1, 951, -1, -1, 54, 55, 951,
3105  57, 953, 954, 951, -1, 197, 63, 64, -1, 939,
3106  -1, -1, -1, 952, -1, 967, 968, 969, 970, 973,
3107  950, -1, -1, 89, -1, 217, -1, 219, 220, 981,
3108  796, 223, -1, 225, -1, 707, -1, 989, 230, -1,
3109  -1, -1, -1, 716, 717, 68, -1, -1, -1, 241,
3110  242, -1, 797, -1, 799, -1, -1, 729, -1, -1,
3111  83, 84, -1, -1, 809, -1, -1, -1, 740, 814,
3112  743, 744, 749, -1, 52, 752, 54, 55, 56, 57,
3113  -1, -1, 755, -1, -1, 765, -1, 767, 768, -1,
3114  -1, -1, -1, 116, 117, 118, 119, 120, 121, -1,
3115  292, 293, 294, 295, 296, 297, 298, 299, -1, -1,
3116  302, 89, 304, -1, -1, 307, -1, 95, -1, 52,
3117  793, 54, 55, 56, 57, 870, 871, 800, 801, -1,
3118  -1, 804, 16, 17, -1, -1, 20, -1, -1, -1,
3119  -1, 813, -1, 335, -1, 337, -1, 820, -1, 341,
3120  342, -1, -1, 825, 834, 835, -1, 837, 830, 839,
3121  840, -1, 46, 47, 356, -1, -1, 51, 52, -1,
3122  -1, -1, -1, -1, 851, -1, 853, -1, 62, 63,
3123  -1, 52, 927, 54, 55, 56, 57, -1, -1, -1,
3124  -1, 864, 384, 385, 40, 41, 42, 43, 44, -1,
3125  -1, -1, -1, -1, -1, -1, -1, -1, 400, -1,
3126  955, -1, 957, -1, -1, 892, -1, 894, 89, -1,
3127  -1, 898, -1, -1, 95, -1, 906, 907, 908, -1,
3128  910, 911, 424, 52, -1, 54, 55, 56, 57, -1,
3129  -1, 433, -1, -1, -1, 918, -1, 920, -1, -1,
3130  -1, -1, -1, 926, 934, 935, 936, 937, -1, -1,
3131  452, -1, -1, -1, 941, -1, 943, -1, -1, 946,
3132  89, -1, -1, -1, -1, -1, 95, 96, -1, -1,
3133  -1, -1, -1, -1, 961, -1, -1, 967, 968, 969,
3134  970, -1, -1, -1, -1, -1, -1, 116, -1, -1,
3135  119, 981, -1, -1, -1, -1, 983, -1, -1, 989,
3136  -1, 195, -1, -1, 198, 199, 200, -1, -1, -1,
3137  2, -1, 4, 142, -1, 52, -1, 54, 55, 56,
3138  57, -1, -1, 217, -1, 219, 220, -1, -1, -1,
3139  -1, 2, -1, 4, -1, -1, -1, -1, -1, -1,
3140  542, -1, 544, 52, -1, 54, 55, 56, 57, -1,
3141  552, -1, 89, -1, -1, -1, -1, 49, 95, 96,
3142  -1, 53, 564, -1, 566, 567, -1, -1, -1, -1,
3143  -1, -1, -1, -1, -1, -1, -1, -1, 49, 116,
3144  89, -1, 119, -1, 76, -1, 95, 96, -1, -1,
3145  -1, -1, -1, -1, -1, -1, 88, 89, 90, 91,
3146  -1, -1, 604, -1, -1, -1, -1, 116, 302, -1,
3147  119, -1, -1, 307, 308, 309, 310, 311, 312, 313,
3148  314, 315, 316, 317, 318, 319, 320, 321, 322, 323,
3149  324, 325, 326, 327, 328, 329, 330, 331, 332, 333,
3150  -1, 335, -1, -1, -1, -1, -1, -1, -1, -1,
3151  -1, -1, 654, -1, -1, -1, -1, -1, -1, -1,
3152  662, -1, -1, 665, 666, -1, -1, -1, -1, 671,
3153  672, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3154  76, 77, 78, 79, 80, -1, -1, 83, 84, -1,
3155  384, 385, -1, -1, -1, 697, -1, -1, 700, 701,
3156  394, 395, 396, -1, -1, 197, 400, 709, 402, 403,
3157  404, -1, -1, -1, 716, 717, 112, 113, 114, 115,
3158  116, 117, 118, 119, 120, 121, 197, -1, -1, 423,
3159  -1, -1, -1, -1, 428, -1, -1, -1, 230, -1,
3160  -1, 743, 744, 437, -1, -1, 440, -1, -1, 241,
3161  242, -1, -1, 755, -1, -1, -1, -1, 452, 230,
3162  -1, -1, -1, -1, -1, -1, -1, -1, -1, 261,
3163  241, 242, -1, -1, -1, -1, -1, -1, 472, 473,
3164  -1, 783, -1, -1, -1, -1, -1, -1, -1, -1,
3165  484, 793, -1, -1, 796, -1, -1, -1, 800, 801,
3166  292, -1, 804, -1, -1, 297, -1, -1, -1, -1,
3167  -1, -1, 304, 305, -1, -1, -1, 2, 820, 4,
3168  -1, 292, -1, -1, -1, -1, 297, -1, -1, -1,
3169  -1, -1, -1, 304, -1, -1, -1, -1, -1, -1,
3170  -1, -1, -1, -1, -1, 337, -1, 2, -1, 4,
3171  -1, -1, -1, -1, 548, -1, -1, -1, 552, -1,
3172  -1, -1, 864, -1, 49, 2, 337, 4, 53, -1,
3173  564, -1, -1, 875, -1, -1, -1, -1, -1, -1,
3174  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3175  -1, 76, -1, 587, 49, -1, -1, -1, 53, -1,
3176  -1, -1, -1, 88, 89, 90, 600, 601, -1, -1,
3177  -1, -1, 49, -1, -1, -1, 918, -1, 920, -1,
3178  -1, 76, -1, -1, 926, -1, 928, -1, -1, -1,
3179  -1, -1, 424, 88, 89, 90, 91, -1, -1, -1,
3180  -1, 433, -1, -1, -1, -1, -1, -1, -1, 951,
3181  -1, 88, -1, 424, -1, -1, -1, -1, 450, -1,
3182  -1, -1, 433, -1, 658, -1, -1, -1, 662, 663,
3183  -1, 665, 666, -1, -1, -1, -1, 671, 672, 0,
3184  -1, -1, -1, -1, -1, 679, -1, 8, 9, 10,
3185  -1, -1, 13, 14, 15, -1, 17, -1, 490, -1,
3186  -1, -1, -1, -1, -1, -1, 27, -1, -1, -1,
3187  -1, -1, 197, -1, -1, -1, 37, 38, -1, 40,
3188  41, 42, 43, 44, 718, -1, -1, -1, -1, 723,
3189  724, -1, 726, 727, -1, -1, -1, -1, -1, -1,
3190  734, -1, 197, -1, -1, 230, -1, -1, -1, -1,
3191  542, -1, 544, -1, -1, -1, 241, 242, -1, -1,
3192  197, -1, -1, -1, 85, -1, -1, -1, -1, -1,
3193  -1, 542, -1, 544, 566, 230, 261, -1, 772, -1,
3194  -1, -1, 776, -1, -1, -1, 241, 242, -1, 783,
3195  -1, -1, -1, 230, -1, 566, -1, -1, -1, -1,
3196  -1, -1, -1, -1, 241, 242, 261, 292, -1, 803,
3197  -1, -1, 297, -1, -1, -1, 137, -1, 139, 304,
3198  305, 142, 143, 615, 145, -1, 147, 821, 822, -1,
3199  -1, -1, -1, -1, -1, -1, -1, 292, -1, -1,
3200  -1, -1, 297, -1, -1, -1, -1, -1, -1, 304,
3201  305, -1, 337, -1, -1, 292, -1, -1, -1, -1,
3202  297, -1, 654, -1, -1, -1, -1, 304, -1, 661,
3203  307, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3204  -1, -1, 337, 654, -1, -1, -1, -1, -1, -1,
3205  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3206  337, -1, -1, -1, -1, -1, -1, -1, -1, 701,
3207  -1, -1, -1, -1, -1, -1, -1, 709, -1, -1,
3208  -1, -1, -1, -1, 716, 717, -1, -1, -1, -1,
3209  701, -1, -1, -1, -1, -1, -1, -1, 709, 424,
3210  -1, -1, -1, -1, -1, 716, 717, -1, 433, -1,
3211  -1, 743, 744, -1, -1, -1, -1, 951, -1, -1,
3212  -1, -1, -1, 755, -1, 450, -1, -1, -1, 424,
3213  -1, -1, 743, 744, -1, -1, -1, -1, 433, -1,
3214  -1, -1, -1, -1, 755, -1, -1, 424, -1, -1,
3215  -1, -1, -1, -1, -1, 450, 433, -1, -1, -1,
3216  -1, 793, -1, -1, -1, 490, -1, -1, 800, 801,
3217  -1, -1, 804, -1, -1, -1, -1, -1, -1, -1,
3218  -1, -1, 793, -1, -1, -1, -1, -1, 820, 800,
3219  801, -1, -1, 804, -1, 490, -1, -1, -1, -1,
3220  -1, -1, -1, -1, -1, -1, -1, -1, -1, 820,
3221  842, -1, -1, -1, -1, -1, -1, 542, -1, 544,
3222  -1, -1, -1, -1, -1, -1, -1, -1, 860, -1,
3223  -1, -1, 864, -1, -1, -1, -1, -1, -1, -1,
3224  -1, 566, -1, 875, -1, -1, -1, 542, -1, 544,
3225  -1, -1, -1, 864, -1, -1, -1, -1, -1, -1,
3226  -1, -1, -1, -1, 875, 542, -1, 544, -1, -1,
3227  -1, 566, -1, -1, -1, -1, -1, -1, -1, -1,
3228  -1, -1, -1, -1, -1, -1, 918, -1, 920, 566,
3229  615, -1, -1, -1, 926, -1, 928, -1, -1, -1,
3230  -1, -1, -1, -1, -1, -1, -1, 918, -1, 920,
3231  -1, -1, -1, -1, -1, 926, -1, 928, -1, -1,
3232  615, 646, -1, -1, -1, -1, -1, -1, -1, 654,
3233  -1, -1, -1, -1, -1, -1, 661, -1, -1, -1,
3234  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3235  -1, -1, 68, 69, 70, 71, 72, 73, 74, 654,
3236  -1, 77, 78, -1, -1, -1, 661, 83, 84, -1,
3237  -1, -1, -1, -1, -1, -1, 701, 654, -1, -1,
3238  -1, -1, -1, -1, 709, 662, -1, -1, -1, -1,
3239  -1, 716, 717, -1, -1, -1, 112, 113, 114, 115,
3240  116, 117, 118, 119, 120, 121, 701, -1, -1, -1,
3241  -1, -1, -1, -1, 709, -1, -1, -1, 743, 744,
3242  -1, 716, 717, -1, 701, -1, -1, -1, -1, -1,
3243  755, -1, 709, -1, -1, -1, -1, -1, -1, 716,
3244  717, 68, 69, 70, 71, 72, 73, 74, 743, 744,
3245  77, 78, -1, -1, -1, -1, 83, 84, -1, -1,
3246  755, -1, -1, -1, -1, -1, 743, 744, 793, -1,
3247  -1, -1, -1, -1, -1, 800, 801, -1, 755, 804,
3248  -1, -1, -1, -1, -1, 112, 113, 114, 115, 116,
3249  117, 118, 119, 120, 121, 820, -1, -1, 793, -1,
3250  -1, -1, -1, -1, -1, 800, 801, -1, -1, 804,
3251  -1, -1, -1, -1, -1, -1, 793, 842, -1, -1,
3252  -1, -1, -1, 800, 801, 820, -1, 804, -1, -1,
3253  -1, -1, -1, -1, -1, 860, -1, -1, -1, 864,
3254  -1, -1, -1, 820, -1, -1, -1, 842, -1, -1,
3255  875, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3256  -1, -1, -1, -1, -1, 860, -1, -1, -1, 864,
3257  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3258  875, -1, -1, 860, -1, -1, -1, 864, -1, -1,
3259  -1, -1, -1, 918, -1, 920, -1, -1, 875, -1,
3260  -1, 926, -1, 928, -1, -1, -1, -1, -1, -1,
3261  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3262  -1, -1, -1, 918, -1, 920, -1, -1, -1, -1,
3263  -1, 926, -1, 928, -1, -1, -1, -1, -1, -1,
3264  -1, 918, -1, 920, -1, -1, -1, -1, -1, 926,
3265  -1, 928, 0, 1, -1, 3, 4, 5, 6, 7,
3266  -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
3267  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3268  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3269  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3270  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3271  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3272  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3273  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3274  -1, 89, 90, -1, 92, 93, -1, 95, -1, 97,
3275  98, 99, 100, 101, 102, 103, -1, -1, -1, -1,
3276  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3277  -1, -1, -1, 0, 122, 123, 124, -1, -1, -1,
3278  -1, 8, 9, 10, -1, -1, 13, 14, 15, -1,
3279  17, -1, -1, -1, -1, -1, -1, 145, -1, 147,
3280  27, 28, 29, -1, -1, -1, -1, -1, -1, -1,
3281  37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
3282  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
3283  74, 75, 76, 77, 78, 79, 80, -1, -1, 83,
3284  84, 68, 69, 70, 71, 72, 73, 74, 75, 76,
3285  77, 78, 79, 80, -1, -1, 83, 84, 85, -1,
3286  87, 88, -1, -1, -1, -1, 110, 94, 112, 113,
3287  114, 115, 116, 117, 118, 119, 120, 121, -1, -1,
3288  107, -1, 109, 110, 111, 112, 113, 114, 115, 116,
3289  117, 118, 119, 120, 121, -1, -1, -1, -1, -1,
3290  -1, -1, -1, 147, -1, -1, -1, -1, -1, -1,
3291  137, 138, 139, 140, 0, -1, 143, 144, 145, -1,
3292  147, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3293  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3294  26, 27, 28, -1, -1, -1, -1, -1, -1, -1,
3295  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3296  -1, -1, -1, -1, -1, 68, 69, 70, 71, 72,
3297  73, 74, 75, 76, 77, 78, 79, 80, -1, -1,
3298  83, 84, 68, 69, 70, 71, 72, 73, 74, 75,
3299  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3300  -1, -1, 88, -1, -1, -1, -1, 110, 94, 112,
3301  113, 114, 115, 116, 117, 118, 119, 120, 121, -1,
3302  -1, -1, -1, -1, 110, -1, 112, 113, 114, 115,
3303  116, 117, 118, 119, 120, 121, -1, -1, -1, -1,
3304  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3305  136, 137, 138, 139, 140, 0, 142, 143, 144, 145,
3306  -1, 147, -1, 8, 9, 10, -1, -1, 13, 14,
3307  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3308  -1, -1, 27, 28, 29, -1, -1, -1, -1, -1,
3309  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3310  -1, -1, -1, -1, -1, -1, 68, 69, 70, 71,
3311  72, 73, 74, 75, -1, 77, 78, -1, -1, -1,
3312  -1, 83, 84, 68, 69, 70, 71, 72, 73, 74,
3313  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3314  85, -1, -1, 88, -1, -1, -1, -1, -1, 94,
3315  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
3316  -1, -1, 107, -1, -1, 110, 111, 112, 113, 114,
3317  115, 116, 117, 118, 119, 120, 121, -1, -1, -1,
3318  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3319  -1, -1, 137, 138, 139, 140, 0, -1, 143, 144,
3320  145, -1, 147, -1, 8, 9, 10, -1, -1, 13,
3321  14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
3322  -1, -1, 26, 27, 28, -1, -1, -1, -1, -1,
3323  -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
3324  44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3325  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3326  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
3327  74, 75, 76, 77, 78, 79, 80, -1, -1, 83,
3328  84, 85, -1, -1, 88, -1, -1, -1, -1, -1,
3329  94, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3330  -1, -1, -1, -1, -1, -1, 110, -1, 112, 113,
3331  114, 115, 116, 117, 118, 119, 120, 121, -1, -1,
3332  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3333  -1, -1, 136, 137, 138, 139, 140, 0, 142, 143,
3334  144, 145, -1, 147, -1, 8, 9, 10, -1, -1,
3335  13, 14, 15, -1, 17, -1, -1, -1, -1, -1,
3336  -1, -1, -1, -1, 27, 28, -1, -1, -1, -1,
3337  -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
3338  43, 44, -1, -1, -1, -1, -1, -1, -1, -1,
3339  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3340  -1, -1, -1, -1, -1, 68, 69, 70, 71, 72,
3341  73, 74, 75, 76, 77, 78, 79, 80, -1, -1,
3342  83, 84, 85, -1, -1, 88, -1, -1, -1, -1,
3343  -1, 94, -1, -1, -1, -1, -1, -1, -1, -1,
3344  -1, -1, -1, -1, -1, -1, -1, 110, -1, 112,
3345  113, 114, 115, 116, 117, 118, 119, 120, 121, -1,
3346  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3347  -1, -1, -1, -1, 137, 138, 139, 140, 0, 142,
3348  143, 144, 145, -1, 147, -1, 8, 9, 10, -1,
3349  -1, -1, 14, 15, -1, 17, -1, -1, -1, -1,
3350  -1, -1, -1, -1, 26, -1, -1, -1, -1, -1,
3351  -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
3352  42, 43, 44, -1, -1, -1, -1, -1, -1, -1,
3353  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3354  -1, -1, -1, -1, -1, -1, 68, 69, 70, 71,
3355  72, 73, 74, 75, 76, 77, 78, 79, 80, -1,
3356  -1, 83, 84, 85, 0, 87, -1, -1, -1, -1,
3357  -1, -1, 8, 9, 10, -1, -1, -1, 14, 15,
3358  -1, 17, -1, -1, -1, -1, -1, 109, 110, -1,
3359  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
3360  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3361  -1, -1, -1, -1, 136, 137, 138, 139, 140, -1,
3362  -1, 143, -1, 145, -1, 147, -1, -1, -1, -1,
3363  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3364  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3365  -1, 87, -1, -1, -1, -1, -1, -1, -1, -1,
3366  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3367  -1, -1, -1, 109, 110, -1, 112, 113, 114, 115,
3368  116, 117, 118, 119, 120, 121, -1, -1, -1, -1,
3369  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3370  -1, 137, 138, 139, 140, -1, -1, 143, -1, 145,
3371  1, 147, 3, 4, 5, 6, 7, 8, 9, 10,
3372  11, 12, -1, -1, 15, 16, -1, 18, 19, 20,
3373  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3374  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3375  -1, -1, -1, -1, 45, 46, -1, 48, 49, 50,
3376  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3377  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3378  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3379  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3380  -1, 92, 93, -1, 95, -1, 97, 98, 99, 100,
3381  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3382  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3383  -1, 122, 123, 124, -1, -1, -1, -1, -1, -1,
3384  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3385  -1, -1, -1, -1, 145, 1, 147, 3, 4, 5,
3386  6, 7, -1, -1, 10, 11, 12, -1, 14, 15,
3387  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3388  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3389  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3390  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3391  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3392  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3393  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3394  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3395  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3396  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3397  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3398  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3399  -1, -1, -1, -1, -1, -1, -1, -1, -1, 145,
3400  1, 147, 3, 4, 5, 6, 7, -1, -1, 10,
3401  11, 12, -1, -1, 15, 16, 17, 18, 19, 20,
3402  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3403  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3404  -1, -1, -1, -1, 45, 46, -1, 48, 49, 50,
3405  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3406  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3407  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3408  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3409  -1, 92, 93, -1, 95, -1, 97, 98, 99, 100,
3410  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3411  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3412  -1, 122, 123, 124, -1, -1, -1, -1, -1, -1,
3413  1, -1, 3, 4, 5, 6, 7, -1, -1, -1,
3414  11, 12, -1, -1, 145, 16, 147, 18, 19, 20,
3415  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3416  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3417  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3418  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3419  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3420  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3421  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3422  -1, 92, 93, -1, 95, -1, 97, 98, 99, 100,
3423  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3424  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3425  -1, 122, 123, 124, -1, -1, -1, -1, -1, -1,
3426  -1, -1, -1, -1, -1, -1, 137, -1, -1, -1,
3427  -1, -1, -1, -1, 145, 1, 147, 3, 4, 5,
3428  6, 7, -1, -1, 10, 11, 12, -1, -1, 15,
3429  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3430  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3431  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3432  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3433  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3434  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3435  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3436  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3437  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3438  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3439  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3440  -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
3441  6, 7, -1, 9, 10, 11, 12, -1, -1, 145,
3442  16, 147, 18, 19, 20, 21, 22, 23, 24, -1,
3443  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3444  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3445  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3446  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3447  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3448  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3449  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3450  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3451  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3452  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3453  -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
3454  6, 7, -1, -1, -1, 11, 12, -1, -1, 145,
3455  16, 147, 18, 19, 20, 21, 22, 23, 24, -1,
3456  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3457  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3458  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3459  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3460  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3461  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3462  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3463  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3464  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3465  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3466  -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
3467  6, 7, -1, -1, -1, 11, 12, 143, -1, 145,
3468  16, 147, 18, 19, 20, 21, 22, 23, 24, -1,
3469  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3470  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3471  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3472  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3473  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3474  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3475  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3476  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3477  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3478  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3479  -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
3480  6, 7, -1, -1, -1, 11, 12, 143, -1, 145,
3481  16, 147, 18, 19, 20, 21, 22, 23, 24, -1,
3482  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3483  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3484  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3485  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3486  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3487  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3488  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3489  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3490  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3491  -1, -1, -1, -1, -1, -1, 122, 123, 124, -1,
3492  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3493  -1, 137, -1, -1, -1, -1, -1, -1, -1, 145,
3494  1, 147, 3, 4, 5, 6, 7, -1, -1, 10,
3495  11, 12, -1, -1, -1, 16, -1, 18, 19, 20,
3496  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3497  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3498  -1, -1, -1, -1, 45, 46, -1, 48, 49, 50,
3499  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3500  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3501  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3502  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3503  -1, 92, 93, -1, 95, -1, 97, 98, 99, 100,
3504  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3505  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3506  -1, 122, 123, 124, -1, -1, -1, -1, -1, -1,
3507  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3508  11, 12, -1, -1, 145, 16, 147, 18, 19, 20,
3509  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3510  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3511  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3512  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3513  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3514  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3515  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3516  -1, 92, 93, -1, 95, 96, 97, 98, 99, 100,
3517  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3518  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3519  12, 122, 123, 124, 16, -1, 18, 19, 20, 21,
3520  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3521  32, 33, 34, 35, 36, -1, 147, 39, -1, -1,
3522  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3523  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3524  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3525  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3526  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3527  92, 93, -1, -1, -1, 97, 98, 99, 100, 101,
3528  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3529  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3530  122, 123, 124, -1, -1, -1, -1, -1, -1, -1,
3531  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3532  12, -1, -1, 145, 16, 147, 18, 19, 20, 21,
3533  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3534  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3535  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3536  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3537  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3538  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3539  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3540  92, 93, -1, -1, -1, 97, 98, 99, 100, 101,
3541  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3542  3, 4, 5, 6, 7, -1, -1, -1, 11, 12,
3543  122, 123, 124, 16, -1, 18, 19, 20, 21, 22,
3544  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3545  33, 34, 35, 36, -1, 147, 39, -1, -1, -1,
3546  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3547  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
3548  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3549  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3550  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3551  93, -1, 95, -1, 97, 98, 99, 100, 101, 102,
3552  103, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3553  -1, -1, -1, -1, -1, -1, -1, -1, -1, 122,
3554  123, 124, -1, -1, -1, -1, -1, -1, 3, 4,
3555  5, 6, 7, -1, -1, -1, 11, 12, -1, -1,
3556  -1, 16, 145, 18, 19, 20, 21, 22, 23, 24,
3557  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3558  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3559  45, 46, -1, 48, 49, 50, 51, 52, 53, 54,
3560  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3561  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3562  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3563  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3564  95, -1, 97, 98, 99, 100, 101, 102, 103, -1,
3565  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3566  -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
3567  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3568  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3569  145, 3, 4, 5, 6, 7, 8, 9, 10, 11,
3570  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
3571  22, 23, 24, 25, 26, -1, -1, -1, 30, 31,
3572  32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
3573  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3574  52, 53, 54, 55, 56, 57, -1, -1, -1, -1,
3575  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
3576  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
3577  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
3578  -1, -1, -1, 95, -1, -1, -1, -1, -1, -1,
3579  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3580  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
3581  -1, 123, 124, -1, -1, -1, -1, -1, 3, 4,
3582  5, -1, 7, -1, -1, -1, 11, 12, -1, 141,
3583  142, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3584  -1, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3585  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3586  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3587  55, 56, 57, 58, 59, 60, -1, 62, 63, 64,
3588  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3589  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3590  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3591  95, 96, 97, 98, 99, 100, 101, 102, 103, -1,
3592  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3593  -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
3594  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
3595  -1, 136, -1, 11, 12, -1, -1, 142, 16, -1,
3596  18, 19, 20, 21, 22, 23, 24, -1, 26, -1,
3597  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3598  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3599  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3600  58, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3601  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3602  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3603  -1, 89, 90, -1, 92, 93, -1, 95, 96, 97,
3604  98, 99, 100, 101, 102, 103, -1, -1, -1, -1,
3605  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3606  -1, -1, -1, -1, 122, 123, 124, -1, -1, -1,
3607  -1, -1, 3, 4, 5, -1, 7, -1, 136, -1,
3608  11, 12, -1, -1, 142, 16, -1, 18, 19, 20,
3609  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3610  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3611  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3612  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3613  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3614  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3615  -1, -1, -1, -1, -1, 86, 87, -1, 89, 90,
3616  -1, 92, 93, -1, 95, 96, 97, 98, 99, 100,
3617  101, 102, 103, -1, -1, -1, -1, -1, 109, -1,
3618  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3619  7, 122, 123, 124, 11, 12, -1, -1, -1, 16,
3620  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3621  -1, 142, -1, 30, 31, 32, 33, 34, 35, 36,
3622  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3623  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3624  57, 58, 59, 60, -1, 62, 63, 64, -1, 66,
3625  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3626  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3627  -1, -1, 89, 90, -1, 92, 93, -1, 95, 96,
3628  97, 98, 99, 100, 101, 102, 103, -1, -1, -1,
3629  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3630  3, 4, 5, -1, 7, 122, 123, 124, 11, 12,
3631  -1, -1, -1, 16, -1, 18, 19, 20, 21, 22,
3632  23, 24, -1, -1, -1, 142, -1, 30, 31, 32,
3633  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3634  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3635  53, 54, 55, 56, 57, 58, 59, 60, -1, 62,
3636  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3637  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3638  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3639  93, -1, 95, 96, 97, 98, 99, 100, 101, 102,
3640  103, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3641  -1, -1, -1, -1, -1, -1, -1, -1, -1, 122,
3642  123, 124, -1, -1, -1, -1, -1, -1, -1, -1,
3643  -1, -1, -1, -1, -1, -1, -1, -1, -1, 142,
3644  3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
3645  13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
3646  23, 24, 25, 26, -1, -1, -1, 30, 31, 32,
3647  33, 34, 35, 36, 37, 38, 39, -1, -1, -1,
3648  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3649  53, 54, 55, 56, 57, -1, -1, -1, -1, -1,
3650  -1, -1, -1, 66, 67, 68, 69, 70, 71, 72,
3651  73, 74, -1, -1, 77, 78, -1, -1, 81, 82,
3652  83, 84, -1, -1, -1, -1, -1, -1, -1, -1,
3653  -1, -1, 95, -1, -1, -1, -1, -1, -1, -1,
3654  -1, -1, -1, -1, -1, -1, -1, -1, -1, 112,
3655  113, 114, 115, 116, 117, 118, 119, 120, 121, -1,
3656  123, 124, -1, -1, -1, -1, -1, -1, -1, -1,
3657  -1, -1, -1, -1, -1, -1, -1, -1, 141, 3,
3658  4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3659  14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
3660  24, 25, 26, -1, -1, -1, 30, 31, 32, 33,
3661  34, 35, 36, 37, 38, 39, -1, -1, -1, -1,
3662  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3663  54, -1, 56, -1, -1, -1, -1, -1, -1, -1,
3664  -1, -1, 66, 67, 68, 69, 70, 71, 72, 73,
3665  74, -1, -1, 77, 78, -1, -1, 81, 82, 83,
3666  84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3667  -1, 95, -1, -1, 98, -1, -1, -1, -1, -1,
3668  -1, -1, -1, -1, -1, -1, -1, -1, 112, 113,
3669  114, 115, 116, 117, 118, 119, 120, 121, -1, 123,
3670  124, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3671  -1, -1, -1, -1, -1, -1, -1, 141, 3, 4,
3672  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3673  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3674  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3675  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
3676  45, 46, 47, 48, 49, 50, 51, 52, 53, -1,
3677  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
3678  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3679  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3680  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3681  95, -1, -1, 98, -1, -1, -1, -1, -1, -1,
3682  -1, -1, -1, -1, -1, -1, -1, 112, 113, 114,
3683  115, 116, 117, 118, 119, 120, 121, -1, 123, 124,
3684  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3685  -1, -1, -1, -1, -1, -1, 141, 3, 4, 5,
3686  6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
3687  16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3688  26, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3689  36, 37, 38, 39, -1, -1, -1, -1, -1, 45,
3690  46, 47, 48, 49, 50, 51, 52, 53, -1, -1,
3691  56, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3692  66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
3693  -1, 77, 78, -1, -1, 81, 82, 83, 84, -1,
3694  -1, -1, -1, -1, -1, -1, -1, -1, -1, 95,
3695  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3696  -1, -1, -1, -1, -1, -1, 112, 113, 114, 115,
3697  116, 117, 118, 119, 120, 121, -1, 123, 124, -1,
3698  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3699  12, -1, -1, -1, 16, 141, 18, 19, 20, 21,
3700  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3701  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3702  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3703  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3704  62, 63, 64, -1, -1, -1, -1, -1, -1, -1,
3705  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3706  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3707  92, 93, -1, -1, -1, 97, 98, 99, 100, 101,
3708  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3709  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3710  122, 11, 12, -1, -1, -1, 16, -1, 18, 19,
3711  20, 21, 22, 23, 24, -1, -1, -1, 140, -1,
3712  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3713  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3714  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3715  60, -1, 62, 63, 64, -1, -1, -1, -1, -1,
3716  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3717  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3718  90, -1, 92, 93, -1, -1, -1, 97, 98, 99,
3719  100, 101, 102, 103, -1, -1, -1, -1, -1, -1,
3720  -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
3721  -1, -1, 122, 11, 12, -1, -1, -1, 16, -1,
3722  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3723  140, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3724  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3725  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3726  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3727  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3728  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3729  -1, 89, 90, -1, 92, 93, -1, 95, -1, 97,
3730  98, 99, 100, 101, 102, 103, -1, -1, -1, -1,
3731  -1, -1, -1, -1, 3, 4, 5, 6, 7, -1,
3732  -1, -1, 11, 12, 122, 123, 124, 16, -1, 18,
3733  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3734  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3735  39, -1, -1, -1, -1, -1, 45, 46, -1, 48,
3736  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3737  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3738  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3739  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3740  89, 90, -1, 92, 93, -1, 95, -1, 97, 98,
3741  99, 100, 101, 102, 103, -1, -1, -1, -1, -1,
3742  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3743  -1, 11, 12, 122, 123, 124, 16, -1, 18, 19,
3744  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3745  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3746  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3747  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
3748  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3749  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3750  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3751  90, -1, 92, 93, -1, 95, 96, 97, 98, 99,
3752  100, 101, 102, 103, -1, -1, -1, -1, -1, -1,
3753  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3754  11, 12, 122, 123, 124, 16, -1, 18, 19, 20,
3755  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3756  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3757  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3758  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3759  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3760  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3761  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3762  -1, 92, 93, -1, 95, 96, 97, 98, 99, 100,
3763  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3764  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3765  12, 122, 123, 124, 16, -1, 18, 19, 20, 21,
3766  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3767  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3768  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3769  52, 53, 54, 55, 56, 57, 58, 59, 60, -1,
3770  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3771  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3772  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3773  92, 93, -1, 95, -1, 97, 98, 99, 100, 101,
3774  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3775  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
3776  122, 123, 124, 16, -1, 18, 19, 20, 21, 22,
3777  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3778  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3779  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3780  53, 54, 55, 56, 57, 58, 59, 60, -1, 62,
3781  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3782  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3783  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3784  93, -1, -1, 96, 97, 98, 99, 100, 101, 102,
3785  103, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3786  4, 5, -1, 7, -1, -1, -1, 11, 12, 122,
3787  123, 124, 16, -1, 18, 19, 20, 21, 22, 23,
3788  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3789  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3790  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3791  54, 55, 56, 57, 58, 59, 60, -1, 62, 63,
3792  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
3793  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3794  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3795  -1, 95, -1, 97, 98, 99, 100, 101, 102, 103,
3796  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
3797  5, -1, 7, -1, -1, -1, 11, 12, 122, 123,
3798  124, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3799  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3800  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3801  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3802  55, 56, 57, 58, 59, 60, -1, 62, 63, 64,
3803  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3804  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3805  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3806  -1, -1, 97, 98, 99, 100, 101, 102, 103, -1,
3807  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3808  -1, 7, -1, -1, -1, 11, 12, 122, 123, 124,
3809  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3810  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3811  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3812  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3813  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3814  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3815  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3816  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3817  -1, 97, 98, 99, 100, 101, 102, 103, -1, -1,
3818  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3819  7, -1, -1, -1, 11, 12, 122, 123, 124, 16,
3820  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3821  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3822  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3823  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3824  57, -1, 59, 60, -1, 62, 63, 64, -1, 66,
3825  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3826  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3827  -1, -1, 89, 90, -1, 92, 93, -1, 95, -1,
3828  97, 98, 99, 100, 101, 102, 103, -1, -1, -1,
3829  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
3830  -1, -1, -1, 11, 12, 122, 123, 124, 16, -1,
3831  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3832  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3833  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3834  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3835  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3836  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3837  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3838  -1, 89, 90, -1, 92, 93, -1, 95, -1, 97,
3839  98, 99, 100, 101, 102, 103, -1, -1, -1, -1,
3840  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3841  -1, -1, 11, 12, 122, 123, 124, 16, -1, 18,
3842  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3843  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3844  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3845  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3846  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3847  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3848  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3849  89, 90, -1, 92, 93, -1, 95, -1, 97, 98,
3850  99, 100, 101, 102, 103, -1, -1, -1, -1, -1,
3851  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3852  -1, 11, 12, 122, 123, 124, 16, -1, 18, 19,
3853  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3854  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3855  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3856  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3857  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3858  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3859  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3860  90, -1, 92, 93, -1, 95, -1, 97, 98, 99,
3861  100, 101, 102, 103, -1, -1, -1, -1, -1, -1,
3862  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3863  11, 12, 122, 123, 124, 16, -1, 18, 19, 20,
3864  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3865  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3866  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3867  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3868  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3869  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3870  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3871  -1, 92, 93, -1, -1, -1, 97, 98, 99, 100,
3872  101, 102, 103, -1, -1, -1, -1, -1, -1, -1,
3873  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3874  12, 122, 123, 124, 16, -1, 18, 19, 20, 21,
3875  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3876  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3877  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3878  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3879  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3880  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3881  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3882  92, 93, -1, -1, -1, 97, 98, 99, 100, 101,
3883  102, 103, -1, -1, -1, -1, -1, -1, -1, -1,
3884  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
3885  122, 123, 124, 16, -1, 18, 19, 20, 21, 22,
3886  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3887  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3888  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3889  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
3890  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3891  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3892  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3893  93, -1, -1, -1, 97, 98, 99, 100, 101, 102,
3894  103, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3895  4, 5, -1, 7, -1, -1, -1, 11, 12, 122,
3896  123, 124, 16, -1, 18, 19, 20, 21, 22, 23,
3897  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3898  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3899  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3900  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3901  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3902  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3903  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3904  -1, 95, -1, 97, 98, 99, 100, 101, 102, 103,
3905  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3906  -1, -1, 11, 12, -1, -1, -1, 16, 122, 18,
3907  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3908  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3909  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3910  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3911  59, 60, -1, 62, 63, 64, -1, -1, -1, -1,
3912  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3913  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3914  89, 90, -1, 92, 93, -1, 95, -1, 97, 98,
3915  99, 100, 101, 102, 103, -1, -1, -1, -1, 3,
3916  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
3917  -1, -1, 16, 122, 18, 19, 20, 21, 22, 23,
3918  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3919  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3920  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3921  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3922  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3923  -1, -1, -1, -1, -1, -1, -1, -1, -1, 83,
3924  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3925  -1, -1, -1, 97, 98, 99, 100, 101, 102, 103,
3926  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3927  -1, -1, 11, 12, -1, -1, -1, 16, 122, 18,
3928  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3929  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3930  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3931  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3932  59, 60, -1, 62, 63, 64, -1, -1, -1, -1,
3933  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3934  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3935  89, 90, -1, 92, 93, -1, -1, -1, 97, 98,
3936  99, 100, 101, 102, 103, -1, -1, -1, -1, 3,
3937  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
3938  -1, -1, 16, 122, 18, 19, 20, 21, 22, 23,
3939  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3940  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3941  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3942  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3943  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3944  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3945  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3946  -1, -1, -1, 97, 98, 99, 100, 101, 102, 103,
3947  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3948  -1, -1, 11, 12, -1, -1, -1, 16, 122, 18,
3949  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3950  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3951  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3952  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3953  59, 60, -1, 62, 63, 64, -1, -1, -1, -1,
3954  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3955  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3956  89, 90, -1, 92, 93, -1, -1, -1, 97, 98,
3957  99, 100, 101, 102, 103, -1, -1, -1, -1, 3,
3958  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
3959  -1, -1, 16, 122, 18, 19, 20, 21, 22, 23,
3960  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3961  34, 35, 36, -1, -1, 39, -1, 44, -1, -1,
3962  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3963  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3964  64, 68, 69, 70, 71, 72, 73, 74, 75, 76,
3965  77, 78, 79, 80, -1, -1, 83, 84, -1, -1,
3966  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3967  -1, -1, -1, 97, 98, 99, 100, 101, 102, 103,
3968  -1, -1, -1, 110, -1, 112, 113, 114, 115, 116,
3969  117, 118, 119, 120, 121, -1, -1, -1, 122, -1,
3970  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
3971  -1, -1, -1, 140, 66, 67, 68, 69, 70, 71,
3972  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
3973  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
3974  -1, -1, -1, 95, -1, -1, -1, -1, -1, -1,
3975  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3976  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
3977  -1, 123, 124, -1, -1, -1, -1, 52, 53, -1,
3978  -1, 56, -1, -1, -1, -1, -1, -1, -1, 141,
3979  142, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3980  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3981  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3982  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3983  -1, -1, -1, -1, -1, -1, -1, 112, 113, 114,
3984  115, 116, 117, 118, 119, 120, 121, -1, 123, 124,
3985  -1, -1, -1, -1, 52, 53, -1, -1, 56, -1,
3986  -1, -1, -1, -1, -1, -1, 141, 142, 66, 67,
3987  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
3988  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
3989  -1, -1, -1, -1, -1, -1, -1, 95, -1, -1,
3990  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3991  -1, -1, -1, -1, 112, 113, 114, 115, 116, 117,
3992  118, 119, 120, 121, -1, 123, 124, -1, -1, -1,
3993  -1, 52, 53, -1, -1, 56, -1, -1, -1, -1,
3994  -1, -1, -1, 141, 142, 66, 67, 68, 69, 70,
3995  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
3996  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
3997  -1, -1, -1, -1, 95, -1, -1, -1, -1, -1,
3998  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3999  -1, 112, 113, 114, 115, 116, 117, 118, 119, 120,
4000  121, -1, 123, 124, -1, -1, -1, -1, 52, 53,
4001  -1, -1, 56, -1, -1, -1, -1, -1, -1, -1,
4002  141, 142, 66, 67, 68, 69, 70, 71, 72, 73,
4003  74, -1, -1, 77, 78, -1, -1, 81, 82, 83,
4004  84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4005  -1, 95, -1, -1, -1, -1, -1, -1, -1, -1,
4006  -1, -1, -1, -1, -1, -1, -1, -1, 112, 113,
4007  114, 115, 116, 117, 118, 119, 120, 121, -1, 123,
4008  124, -1, -1, -1, -1, 52, 53, -1, -1, 56,
4009  -1, -1, -1, -1, -1, -1, -1, 141, 142, 66,
4010  67, 68, 69, 70, 71, 72, 73, 74, -1, -1,
4011  77, 78, -1, -1, 81, 82, 83, 84, -1, -1,
4012  -1, -1, -1, -1, -1, -1, -1, -1, 95, -1,
4013  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4014  -1, -1, -1, -1, -1, 112, 113, 114, 115, 116,
4015  117, 118, 119, 120, 121, -1, 123, 124, -1, -1,
4016  -1, -1, 52, 53, -1, -1, 56, -1, -1, -1,
4017  -1, -1, -1, -1, 141, 142, 66, 67, 68, 69,
4018  70, 71, 72, 73, 74, -1, -1, 77, 78, -1,
4019  -1, 81, 82, 83, 84, -1, -1, -1, -1, -1,
4020  -1, -1, -1, -1, -1, 95, -1, -1, -1, -1,
4021  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4022  -1, -1, 112, 113, 114, 115, 116, 117, 118, 119,
4023  120, 121, -1, 123, 124, -1, -1, -1, -1, 52,
4024  53, -1, -1, 56, -1, -1, -1, -1, -1, -1,
4025  -1, 141, 142, 66, 67, 68, 69, 70, 71, 72,
4026  73, 74, -1, -1, 77, 78, -1, -1, 81, 82,
4027  83, 84, -1, -1, -1, -1, -1, -1, -1, -1,
4028  -1, -1, 95, -1, -1, -1, -1, -1, -1, -1,
4029  -1, -1, -1, -1, -1, -1, -1, -1, -1, 112,
4030  113, 114, 115, 116, 117, 118, 119, 120, 121, -1,
4031  123, 124, -1, -1, -1, -1, 52, 53, -1, -1,
4032  56, -1, -1, -1, -1, -1, -1, -1, 141, 142,
4033  66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
4034  -1, 77, 78, -1, -1, 81, 82, 83, 84, -1,
4035  -1, -1, -1, -1, -1, -1, -1, -1, -1, 95,
4036  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4037  -1, -1, -1, -1, -1, -1, 112, 113, 114, 115,
4038  116, 117, 118, 119, 120, 121, -1, 123, 124, -1,
4039  -1, -1, -1, 52, 53, -1, -1, 56, -1, -1,
4040  -1, -1, -1, -1, -1, 141, 142, 66, 67, 68,
4041  69, 70, 71, 72, 73, 74, -1, -1, 77, 78,
4042  -1, -1, 81, 82, 83, 84, -1, -1, -1, -1,
4043  -1, -1, -1, -1, -1, -1, 95, -1, -1, -1,
4044  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4045  -1, -1, -1, 112, 113, 114, 115, 116, 117, 118,
4046  119, 120, 121, -1, 123, 124, -1, -1, -1, -1,
4047  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
4048  -1, -1, 141, 142, 66, 67, 68, 69, 70, 71,
4049  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
4050  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
4051  -1, -1, -1, 95, -1, -1, -1, -1, -1, -1,
4052  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4053  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
4054  -1, 123, 124, -1, -1, -1, -1, 52, 53, -1,
4055  -1, 56, -1, -1, -1, -1, -1, -1, -1, 141,
4056  142, 66, 67, 68, 69, 70, 71, 72, 73, 74,
4057  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
4058  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4059  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4060  -1, -1, -1, -1, -1, -1, -1, 112, 113, 114,
4061  115, 116, 117, 118, 119, 120, 121, -1, 123, 124,
4062  -1, -1, -1, -1, 52, 53, -1, -1, 56, -1,
4063  -1, -1, -1, -1, -1, -1, 141, 142, 66, 67,
4064  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
4065  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
4066  -1, -1, -1, -1, -1, -1, -1, 95, -1, -1,
4067  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4068  -1, -1, -1, -1, 112, 113, 114, 115, 116, 117,
4069  118, 119, 120, 121, -1, 123, 124, -1, -1, -1,
4070  -1, 52, 53, -1, -1, 56, -1, -1, -1, -1,
4071  -1, -1, -1, 141, 142, 66, 67, 68, 69, 70,
4072  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
4073  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
4074  -1, -1, -1, -1, 95, -1, -1, -1, -1, -1,
4075  -1, -1, 44, -1, -1, -1, -1, -1, -1, -1,
4076  -1, 112, 113, 114, 115, 116, 117, 118, 119, 120,
4077  121, 44, 123, 124, -1, -1, 68, 69, 70, 71,
4078  72, 73, 74, 75, 76, 77, 78, 79, 80, -1,
4079  141, 83, 84, -1, -1, 68, 69, 70, 71, 72,
4080  73, 74, 75, 76, 77, 78, 79, 80, -1, -1,
4081  83, 84, -1, -1, -1, -1, -1, -1, 110, -1,
4082  112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
4083  -1, -1, -1, -1, -1, -1, -1, 110, -1, 112,
4084  113, 114, 115, 116, 117, 118, 119, 120, 121
4085 };
4086 
4087 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4088  symbol of state STATE-NUM. */
4089 static const yytype_uint16 yystos[] =
4090 {
4091  0, 149, 150, 0, 1, 3, 4, 5, 6, 7,
4092  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4093  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4094  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4095  57, 59, 60, 62, 63, 64, 66, 67, 86, 89,
4096  90, 92, 93, 95, 97, 98, 99, 100, 101, 102,
4097  103, 122, 123, 124, 151, 152, 153, 158, 160, 161,
4098  163, 164, 167, 168, 170, 171, 172, 174, 175, 185,
4099  199, 216, 217, 218, 219, 220, 221, 222, 223, 224,
4100  225, 226, 249, 250, 260, 261, 262, 263, 264, 265,
4101  266, 269, 279, 281, 282, 283, 284, 285, 286, 287,
4102  310, 321, 153, 3, 4, 5, 6, 7, 8, 9,
4103  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
4104  20, 21, 22, 23, 24, 25, 26, 30, 31, 32,
4105  33, 34, 35, 36, 37, 38, 39, 45, 46, 47,
4106  48, 49, 50, 51, 52, 53, 56, 66, 67, 68,
4107  69, 70, 71, 72, 73, 74, 77, 78, 81, 82,
4108  83, 84, 95, 112, 113, 114, 115, 116, 117, 118,
4109  119, 120, 121, 123, 124, 141, 178, 179, 180, 181,
4110  183, 184, 279, 281, 39, 58, 86, 89, 95, 96,
4111  123, 167, 175, 185, 187, 192, 195, 197, 216, 283,
4112  284, 286, 287, 308, 309, 192, 192, 142, 193, 194,
4113  142, 189, 193, 142, 147, 315, 54, 180, 315, 154,
4114  136, 21, 22, 30, 31, 32, 185, 216, 310, 185,
4115  56, 1, 89, 156, 157, 158, 169, 170, 321, 161,
4116  188, 197, 308, 321, 187, 307, 308, 321, 46, 86,
4117  122, 140, 174, 199, 216, 283, 284, 287, 242, 243,
4118  54, 55, 57, 178, 272, 280, 271, 272, 273, 146,
4119  267, 146, 270, 59, 60, 163, 185, 185, 145, 147,
4120  314, 319, 320, 40, 41, 42, 43, 44, 37, 38,
4121  28, 247, 109, 140, 89, 95, 171, 109, 68, 69,
4122  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
4123  80, 83, 84, 110, 112, 113, 114, 115, 116, 117,
4124  118, 119, 120, 121, 85, 138, 139, 200, 161, 162,
4125  162, 203, 205, 162, 314, 320, 86, 168, 175, 216,
4126  232, 283, 284, 287, 52, 56, 83, 86, 176, 177,
4127  216, 283, 284, 287, 177, 33, 34, 35, 36, 49,
4128  50, 51, 52, 56, 142, 178, 285, 305, 85, 139,
4129  26, 136, 251, 263, 87, 87, 189, 193, 251, 140,
4130  187, 56, 187, 187, 109, 88, 140, 196, 321, 85,
4131  138, 139, 87, 87, 140, 196, 192, 315, 316, 192,
4132  191, 192, 197, 308, 321, 161, 316, 161, 54, 63,
4133  64, 159, 142, 186, 136, 156, 85, 139, 87, 158,
4134  169, 143, 314, 320, 316, 201, 144, 140, 147, 318,
4135  140, 318, 137, 318, 315, 56, 59, 60, 171, 173,
4136  140, 85, 138, 139, 244, 61, 104, 105, 106, 274,
4137  106, 274, 106, 65, 274, 106, 106, 268, 274, 106,
4138  61, 106, 68, 68, 145, 153, 162, 162, 162, 162,
4139  158, 161, 161, 248, 95, 163, 187, 197, 198, 169,
4140  140, 174, 140, 160, 163, 175, 185, 187, 198, 185,
4141  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
4142  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
4143  185, 185, 185, 185, 185, 52, 53, 56, 183, 189,
4144  311, 312, 191, 52, 53, 56, 183, 189, 311, 155,
4145  156, 13, 228, 319, 228, 162, 162, 314, 17, 254,
4146  56, 85, 138, 139, 25, 161, 52, 56, 176, 1,
4147  113, 288, 319, 85, 138, 139, 212, 306, 213, 85,
4148  139, 313, 52, 56, 311, 311, 253, 252, 163, 185,
4149  163, 185, 94, 165, 182, 185, 187, 95, 187, 195,
4150  308, 52, 56, 191, 52, 56, 309, 316, 143, 316,
4151  140, 140, 316, 180, 202, 185, 151, 137, 311, 311,
4152  185, 316, 158, 316, 308, 140, 173, 52, 56, 191,
4153  52, 56, 52, 54, 55, 56, 57, 89, 95, 96,
4154  116, 119, 142, 245, 291, 292, 293, 294, 295, 296,
4155  299, 300, 301, 302, 303, 276, 275, 146, 274, 146,
4156  185, 185, 76, 114, 237, 238, 321, 187, 140, 316,
4157  173, 140, 109, 44, 315, 87, 87, 189, 193, 315,
4158  317, 87, 87, 189, 190, 193, 321, 10, 227, 8,
4159  256, 321, 156, 13, 156, 27, 229, 319, 229, 254,
4160  197, 227, 52, 56, 191, 52, 56, 207, 210, 319,
4161  289, 209, 52, 56, 176, 191, 155, 161, 142, 290,
4162  291, 214, 190, 193, 190, 193, 237, 237, 44, 166,
4163  180, 187, 196, 87, 87, 317, 87, 87, 308, 161,
4164  137, 318, 171, 317, 109, 52, 89, 95, 233, 234,
4165  235, 293, 291, 29, 107, 246, 140, 304, 321, 140,
4166  304, 52, 140, 304, 52, 277, 54, 55, 57, 278,
4167  287, 52, 145, 236, 239, 295, 297, 298, 301, 303,
4168  321, 156, 95, 187, 173, 185, 111, 163, 185, 163,
4169  185, 165, 144, 87, 163, 185, 163, 185, 165, 187,
4170  198, 257, 321, 15, 231, 321, 14, 230, 231, 231,
4171  204, 206, 227, 140, 228, 317, 162, 319, 162, 155,
4172  317, 227, 316, 291, 155, 319, 178, 156, 156, 185,
4173  237, 87, 140, 316, 187, 235, 140, 293, 140, 316,
4174  239, 156, 156, 294, 299, 301, 303, 295, 296, 301,
4175  295, 156, 109, 52, 240, 241, 292, 239, 114, 140,
4176  304, 140, 304, 140, 304, 10, 187, 185, 163, 185,
4177  88, 258, 321, 156, 9, 259, 321, 162, 227, 227,
4178  156, 156, 187, 156, 229, 211, 319, 227, 316, 227,
4179  215, 10, 137, 156, 316, 234, 140, 95, 233, 316,
4180  10, 137, 140, 304, 140, 304, 140, 304, 140, 304,
4181  304, 137, 86, 216, 140, 114, 298, 301, 295, 297,
4182  301, 295, 86, 175, 216, 283, 284, 287, 228, 156,
4183  228, 227, 227, 231, 254, 255, 208, 155, 290, 137,
4184  140, 234, 140, 293, 295, 301, 295, 295, 56, 85,
4185  241, 140, 304, 140, 304, 304, 140, 304, 304, 56,
4186  85, 138, 139, 156, 156, 156, 227, 155, 234, 140,
4187  304, 140, 304, 304, 304, 52, 56, 295, 301, 295,
4188  295, 52, 56, 191, 52, 56, 256, 230, 227, 227,
4189  234, 295, 304, 140, 304, 304, 304, 317, 304, 295,
4190  304
4191 };
4192 
4193 #define yyerrok (yyerrstatus = 0)
4194 #define yyclearin (yychar = YYEMPTY)
4195 #define YYEMPTY (-2)
4196 #define YYEOF 0
4197 
4198 #define YYACCEPT goto yyacceptlab
4199 #define YYABORT goto yyabortlab
4200 #define YYERROR goto yyerrorlab
4201 
4202 
4203 /* Like YYERROR except do call yyerror. This remains here temporarily
4204  to ease the transition to the new meaning of YYERROR, for GCC.
4205  Once GCC version 2 has supplanted version 1, this can go. However,
4206  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
4207  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
4208  discussed. */
4209 
4210 #define YYFAIL goto yyerrlab
4211 #if defined YYFAIL
4212  /* This is here to suppress warnings from the GCC cpp's
4213  -Wunused-macros. Normally we don't worry about that warning, but
4214  some users do, and we want to make it easy for users to remove
4215  YYFAIL uses, which will produce warnings from Bison 2.5. */
4216 #endif
4217 
4218 #define YYRECOVERING() (!!yyerrstatus)
4219 
4220 #define YYBACKUP(Token, Value) \
4221 do \
4222  if (yychar == YYEMPTY && yylen == 1) \
4223  { \
4224  yychar = (Token); \
4225  yylval = (Value); \
4226  YYPOPSTACK (1); \
4227  goto yybackup; \
4228  } \
4229  else \
4230  { \
4231  parser_yyerror (parser, YY_("syntax error: cannot back up")); \
4232  YYERROR; \
4233  } \
4234 while (YYID (0))
4235 
4236 
4237 #define YYTERROR 1
4238 #define YYERRCODE 256
4239 
4240 
4241 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
4242  If N is 0, then set CURRENT to the empty location which ends
4243  the previous symbol: RHS[0] (always defined). */
4244 
4245 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
4246 #ifndef YYLLOC_DEFAULT
4247 # define YYLLOC_DEFAULT(Current, Rhs, N) \
4248  do \
4249  if (YYID (N)) \
4250  { \
4251  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
4252  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
4253  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
4254  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
4255  } \
4256  else \
4257  { \
4258  (Current).first_line = (Current).last_line = \
4259  YYRHSLOC (Rhs, 0).last_line; \
4260  (Current).first_column = (Current).last_column = \
4261  YYRHSLOC (Rhs, 0).last_column; \
4262  } \
4263  while (YYID (0))
4264 #endif
4265 
4266 
4267 /* This macro is provided for backward compatibility. */
4268 
4269 #ifndef YY_LOCATION_PRINT
4270 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
4271 #endif
4272 
4273 
4274 /* YYLEX -- calling `yylex' with the right arguments. */
4275 
4276 #ifdef YYLEX_PARAM
4277 # define YYLEX yylex (&yylval, YYLEX_PARAM)
4278 #else
4279 # define YYLEX yylex (&yylval, parser)
4280 #endif
4281 
4282 /* Enable debugging if requested. */
4283 #if YYDEBUG
4284 
4285 # ifndef YYFPRINTF
4286 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
4287 # define YYFPRINTF fprintf
4288 # endif
4289 
4290 # define YYDPRINTF(Args) \
4291 do { \
4292  if (yydebug) \
4293  YYFPRINTF Args; \
4294 } while (YYID (0))
4295 
4296 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
4297 do { \
4298  if (yydebug) \
4299  { \
4300  YYFPRINTF (stderr, "%s ", Title); \
4301  yy_symbol_print (stderr, \
4302  Type, Value, parser); \
4303  YYFPRINTF (stderr, "\n"); \
4304  } \
4305 } while (YYID (0))
4306 
4307 
4308 /*--------------------------------.
4309 | Print this symbol on YYOUTPUT. |
4310 `--------------------------------*/
4311 
4312 /*ARGSUSED*/
4313 #if (defined __STDC__ || defined __C99__FUNC__ \
4314  || defined __cplusplus || defined _MSC_VER)
4315 static void
4316 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4317 #else
4318 static void
4319 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
4320  FILE *yyoutput;
4321  int yytype;
4322  YYSTYPE const * const yyvaluep;
4323  struct parser_params *parser;
4324 #endif
4325 {
4326  if (!yyvaluep)
4327  return;
4328  YYUSE (parser);
4329 # ifdef YYPRINT
4330  if (yytype < YYNTOKENS)
4331  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4332 # else
4333  YYUSE (yyoutput);
4334 # endif
4335  switch (yytype)
4336  {
4337  default:
4338  break;
4339  }
4340 }
4341 
4342 
4343 /*--------------------------------.
4344 | Print this symbol on YYOUTPUT. |
4345 `--------------------------------*/
4346 
4347 #if (defined __STDC__ || defined __C99__FUNC__ \
4348  || defined __cplusplus || defined _MSC_VER)
4349 static void
4350 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4351 #else
4352 static void
4353 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
4354  FILE *yyoutput;
4355  int yytype;
4356  YYSTYPE const * const yyvaluep;
4357  struct parser_params *parser;
4358 #endif
4359 {
4360  if (yytype < YYNTOKENS)
4361  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4362  else
4363  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4364 
4365  yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
4366  YYFPRINTF (yyoutput, ")");
4367 }
4368 
4369 /*------------------------------------------------------------------.
4370 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4371 | TOP (included). |
4372 `------------------------------------------------------------------*/
4373 
4374 #if (defined __STDC__ || defined __C99__FUNC__ \
4375  || defined __cplusplus || defined _MSC_VER)
4376 static void
4377 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4378 #else
4379 static void
4380 yy_stack_print (yybottom, yytop)
4381  yytype_int16 *yybottom;
4382  yytype_int16 *yytop;
4383 #endif
4384 {
4385  YYFPRINTF (stderr, "Stack now");
4386  for (; yybottom <= yytop; yybottom++)
4387  {
4388  int yybot = *yybottom;
4389  YYFPRINTF (stderr, " %d", yybot);
4390  }
4391  YYFPRINTF (stderr, "\n");
4392 }
4393 
4394 # define YY_STACK_PRINT(Bottom, Top) \
4395 do { \
4396  if (yydebug) \
4397  yy_stack_print ((Bottom), (Top)); \
4398 } while (YYID (0))
4399 
4400 
4401 /*------------------------------------------------.
4402 | Report that the YYRULE is going to be reduced. |
4403 `------------------------------------------------*/
4404 
4405 #if (defined __STDC__ || defined __C99__FUNC__ \
4406  || defined __cplusplus || defined _MSC_VER)
4407 static void
4408 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
4409 #else
4410 static void
4411 yy_reduce_print (yyvsp, yyrule, parser)
4412  YYSTYPE *yyvsp;
4413  int yyrule;
4414  struct parser_params *parser;
4415 #endif
4416 {
4417  int yynrhs = yyr2[yyrule];
4418  int yyi;
4419  unsigned long int yylno = yyrline[yyrule];
4420  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4421  yyrule - 1, yylno);
4422  /* The symbols being reduced. */
4423  for (yyi = 0; yyi < yynrhs; yyi++)
4424  {
4425  YYFPRINTF (stderr, " $%d = ", yyi + 1);
4426  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4427  &(yyvsp[(yyi + 1) - (yynrhs)])
4428  , parser);
4429  YYFPRINTF (stderr, "\n");
4430  }
4431 }
4432 
4433 # define YY_REDUCE_PRINT(Rule) \
4434 do { \
4435  if (yydebug) \
4436  yy_reduce_print (yyvsp, Rule, parser); \
4437 } while (YYID (0))
4438 
4439 /* Nonzero means print parse trace. It is left uninitialized so that
4440  multiple parsers can coexist. */
4441 #ifndef yydebug
4442 int yydebug;
4443 #endif
4444 #else /* !YYDEBUG */
4445 # define YYDPRINTF(Args)
4446 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4447 # define YY_STACK_PRINT(Bottom, Top)
4448 # define YY_REDUCE_PRINT(Rule)
4449 #endif /* !YYDEBUG */
4450 
4451 
4452 /* YYINITDEPTH -- initial size of the parser's stacks. */
4453 #ifndef YYINITDEPTH
4454 # define YYINITDEPTH 200
4455 #endif
4456 
4457 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4458  if the built-in stack extension method is used).
4459 
4460  Do not make this value too large; the results are undefined if
4461  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4462  evaluated with infinite-precision integer arithmetic. */
4463 
4464 #ifndef YYMAXDEPTH
4465 # define YYMAXDEPTH 10000
4466 #endif
4467 
4468 
4469 #if YYERROR_VERBOSE
4470 
4471 # ifndef yystrlen
4472 # if defined __GLIBC__ && defined _STRING_H
4473 # define yystrlen strlen
4474 # else
4475 /* Return the length of YYSTR. */
4476 #if (defined __STDC__ || defined __C99__FUNC__ \
4477  || defined __cplusplus || defined _MSC_VER)
4478 static YYSIZE_T
4479 yystrlen (const char *yystr)
4480 #else
4481 static YYSIZE_T
4482 yystrlen (yystr)
4483  const char *yystr;
4484 #endif
4485 {
4486  YYSIZE_T yylen;
4487  for (yylen = 0; yystr[yylen]; yylen++)
4488  continue;
4489  return yylen;
4490 }
4491 # endif
4492 # endif
4493 
4494 # ifndef yystpcpy
4495 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4496 # define yystpcpy stpcpy
4497 # else
4498 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4499  YYDEST. */
4500 #if (defined __STDC__ || defined __C99__FUNC__ \
4501  || defined __cplusplus || defined _MSC_VER)
4502 static char *
4503 yystpcpy (char *yydest, const char *yysrc)
4504 #else
4505 static char *
4506 yystpcpy (yydest, yysrc)
4507  char *yydest;
4508  const char *yysrc;
4509 #endif
4510 {
4511  char *yyd = yydest;
4512  const char *yys = yysrc;
4513 
4514  while ((*yyd++ = *yys++) != '\0')
4515  continue;
4516 
4517  return yyd - 1;
4518 }
4519 # endif
4520 # endif
4521 
4522 # ifndef yytnamerr
4523 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4524  quotes and backslashes, so that it's suitable for yyerror. The
4525  heuristic is that double-quoting is unnecessary unless the string
4526  contains an apostrophe, a comma, or backslash (other than
4527  backslash-backslash). YYSTR is taken from yytname. If YYRES is
4528  null, do not copy; instead, return the length of what the result
4529  would have been. */
4530 static YYSIZE_T
4531 yytnamerr (char *yyres, const char *yystr)
4532 {
4533  if (*yystr == '"')
4534  {
4535  YYSIZE_T yyn = 0;
4536  char const *yyp = yystr;
4537 
4538  for (;;)
4539  switch (*++yyp)
4540  {
4541  case '\'':
4542  case ',':
4543  goto do_not_strip_quotes;
4544 
4545  case '\\':
4546  if (*++yyp != '\\')
4547  goto do_not_strip_quotes;
4548  /* Fall through. */
4549  default:
4550  if (yyres)
4551  yyres[yyn] = *yyp;
4552  yyn++;
4553  break;
4554 
4555  case '"':
4556  if (yyres)
4557  yyres[yyn] = '\0';
4558  return yyn;
4559  }
4560  do_not_strip_quotes: ;
4561  }
4562 
4563  if (! yyres)
4564  return yystrlen (yystr);
4565 
4566  return yystpcpy (yyres, yystr) - yyres;
4567 }
4568 # endif
4569 
4570 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
4571  about the unexpected token YYTOKEN for the state stack whose top is
4572  YYSSP.
4573 
4574  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
4575  not large enough to hold the message. In that case, also set
4576  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
4577  required number of bytes is too large to store. */
4578 static int
4579 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
4580  yytype_int16 *yyssp, int yytoken)
4581 {
4582  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
4583  YYSIZE_T yysize = yysize0;
4584  YYSIZE_T yysize1;
4585  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4586  /* Internationalized format string. */
4587  const char *yyformat = 0;
4588  /* Arguments of yyformat. */
4589  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4590  /* Number of reported tokens (one for the "unexpected", one per
4591  "expected"). */
4592  int yycount = 0;
4593 
4594  /* There are many possibilities here to consider:
4595  - Assume YYFAIL is not used. It's too flawed to consider. See
4596  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
4597  for details. YYERROR is fine as it does not invoke this
4598  function.
4599  - If this state is a consistent state with a default action, then
4600  the only way this function was invoked is if the default action
4601  is an error action. In that case, don't check for expected
4602  tokens because there are none.
4603  - The only way there can be no lookahead present (in yychar) is if
4604  this state is a consistent state with a default action. Thus,
4605  detecting the absence of a lookahead is sufficient to determine
4606  that there is no unexpected or expected token to report. In that
4607  case, just report a simple "syntax error".
4608  - Don't assume there isn't a lookahead just because this state is a
4609  consistent state with a default action. There might have been a
4610  previous inconsistent state, consistent state with a non-default
4611  action, or user semantic action that manipulated yychar.
4612  - Of course, the expected token list depends on states to have
4613  correct lookahead information, and it depends on the parser not
4614  to perform extra reductions after fetching a lookahead from the
4615  scanner and before detecting a syntax error. Thus, state merging
4616  (from LALR or IELR) and default reductions corrupt the expected
4617  token list. However, the list is correct for canonical LR with
4618  one exception: it will still contain any token that will not be
4619  accepted due to an error action in a later state.
4620  */
4621  if (yytoken != YYEMPTY)
4622  {
4623  int yyn = yypact[*yyssp];
4624  yyarg[yycount++] = yytname[yytoken];
4625  if (!yypact_value_is_default (yyn))
4626  {
4627  /* Start YYX at -YYN if negative to avoid negative indexes in
4628  YYCHECK. In other words, skip the first -YYN actions for
4629  this state because they are default actions. */
4630  int yyxbegin = yyn < 0 ? -yyn : 0;
4631  /* Stay within bounds of both yycheck and yytname. */
4632  int yychecklim = YYLAST - yyn + 1;
4633  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4634  int yyx;
4635 
4636  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4637  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
4638  && !yytable_value_is_error (yytable[yyx + yyn]))
4639  {
4640  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4641  {
4642  yycount = 1;
4643  yysize = yysize0;
4644  break;
4645  }
4646  yyarg[yycount++] = yytname[yyx];
4647  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4648  if (! (yysize <= yysize1
4649  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4650  return 2;
4651  yysize = yysize1;
4652  }
4653  }
4654  }
4655 
4656  switch (yycount)
4657  {
4658 # define YYCASE_(N, S) \
4659  case N: \
4660  yyformat = S; \
4661  break
4662  YYCASE_(0, YY_("syntax error"));
4663  YYCASE_(1, YY_("syntax error, unexpected %s"));
4664  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
4665  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
4666  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
4667  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
4668 # undef YYCASE_
4669  }
4670 
4671  yysize1 = yysize + yystrlen (yyformat);
4672  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4673  return 2;
4674  yysize = yysize1;
4675 
4676  if (*yymsg_alloc < yysize)
4677  {
4678  *yymsg_alloc = 2 * yysize;
4679  if (! (yysize <= *yymsg_alloc
4680  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
4681  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
4682  return 1;
4683  }
4684 
4685  /* Avoid sprintf, as that infringes on the user's name space.
4686  Don't have undefined behavior even if the translation
4687  produced a string with the wrong number of "%s"s. */
4688  {
4689  char *yyp = *yymsg;
4690  int yyi = 0;
4691  while ((*yyp = *yyformat) != '\0')
4692  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
4693  {
4694  yyp += yytnamerr (yyp, yyarg[yyi++]);
4695  yyformat += 2;
4696  }
4697  else
4698  {
4699  yyp++;
4700  yyformat++;
4701  }
4702  }
4703  return 0;
4704 }
4705 #endif /* YYERROR_VERBOSE */
4706 
4707 /*-----------------------------------------------.
4708 | Release the memory associated to this symbol. |
4709 `-----------------------------------------------*/
4710 
4711 /*ARGSUSED*/
4712 #if (defined __STDC__ || defined __C99__FUNC__ \
4713  || defined __cplusplus || defined _MSC_VER)
4714 static void
4715 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
4716 #else
4717 static void
4718 yydestruct (yymsg, yytype, yyvaluep, parser)
4719  const char *yymsg;
4720  int yytype;
4721  YYSTYPE *yyvaluep;
4722  struct parser_params *parser;
4723 #endif
4724 {
4725  YYUSE (yyvaluep);
4726  YYUSE (parser);
4727 
4728  if (!yymsg)
4729  yymsg = "Deleting";
4730  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4731 
4732  switch (yytype)
4733  {
4734 
4735  default:
4736  break;
4737  }
4738 }
4739 
4740 
4741 /* Prevent warnings from -Wmissing-prototypes. */
4742 #ifdef YYPARSE_PARAM
4743 #if defined __STDC__ || defined __cplusplus
4744 int yyparse (void *YYPARSE_PARAM);
4745 #else
4746 int yyparse ();
4747 #endif
4748 #else /* ! YYPARSE_PARAM */
4749 #if defined __STDC__ || defined __cplusplus
4750 int yyparse (struct parser_params *parser);
4751 #else
4752 int yyparse ();
4753 #endif
4754 #endif /* ! YYPARSE_PARAM */
4755 
4756 
4757 /*----------.
4758 | yyparse. |
4759 `----------*/
4760 
4761 #ifdef YYPARSE_PARAM
4762 #if (defined __STDC__ || defined __C99__FUNC__ \
4763  || defined __cplusplus || defined _MSC_VER)
4764 int
4765 yyparse (void *YYPARSE_PARAM)
4766 #else
4767 int
4768 yyparse (YYPARSE_PARAM)
4769  void *YYPARSE_PARAM;
4770 #endif
4771 #else /* ! YYPARSE_PARAM */
4772 #if (defined __STDC__ || defined __C99__FUNC__ \
4773  || defined __cplusplus || defined _MSC_VER)
4774 int
4775 yyparse (struct parser_params *parser)
4776 #else
4777 int
4778 yyparse (parser)
4779  struct parser_params *parser;
4780 #endif
4781 #endif
4782 {
4783 /* The lookahead symbol. */
4784 int yychar;
4785 
4786 /* The semantic value of the lookahead symbol. */
4787 YYSTYPE yylval;
4788 
4789  /* Number of syntax errors so far. */
4790  int yynerrs;
4791 
4792  int yystate;
4793  /* Number of tokens to shift before error messages enabled. */
4794  int yyerrstatus;
4795 
4796  /* The stacks and their tools:
4797  `yyss': related to states.
4798  `yyvs': related to semantic values.
4799 
4800  Refer to the stacks thru separate pointers, to allow yyoverflow
4801  to reallocate them elsewhere. */
4802 
4803  /* The state stack. */
4804  yytype_int16 yyssa[YYINITDEPTH];
4805  yytype_int16 *yyss;
4806  yytype_int16 *yyssp;
4807 
4808  /* The semantic value stack. */
4809  YYSTYPE yyvsa[YYINITDEPTH];
4810  YYSTYPE *yyvs;
4811  YYSTYPE *yyvsp;
4812 
4813  YYSIZE_T yystacksize;
4814 
4815  int yyn;
4816  int yyresult;
4817  /* Lookahead token as an internal (translated) token number. */
4818  int yytoken;
4819  /* The variables used to return semantic value and location from the
4820  action routines. */
4821  YYSTYPE yyval;
4822 
4823 #if YYERROR_VERBOSE
4824  /* Buffer for error messages, and its allocated size. */
4825  char yymsgbuf[128];
4826  char *yymsg = yymsgbuf;
4827  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
4828 #endif
4829 
4830 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
4831 
4832  /* The number of symbols on the RHS of the reduced rule.
4833  Keep to zero when no symbol should be popped. */
4834  int yylen = 0;
4835 
4836  yytoken = 0;
4837  yyss = yyssa;
4838  yyvs = yyvsa;
4839  yystacksize = YYINITDEPTH;
4840 
4841  YYDPRINTF ((stderr, "Starting parse\n"));
4842 
4843  yystate = 0;
4844  yyerrstatus = 0;
4845  yynerrs = 0;
4846  yychar = YYEMPTY; /* Cause a token to be read. */
4847 
4848  /* Initialize stack pointers.
4849  Waste one element of value and location stack
4850  so that they stay on the same level as the state stack.
4851  The wasted elements are never initialized. */
4852  yyssp = yyss;
4853  yyvsp = yyvs;
4854 
4855  goto yysetstate;
4856 
4857 /*------------------------------------------------------------.
4858 | yynewstate -- Push a new state, which is found in yystate. |
4859 `------------------------------------------------------------*/
4860  yynewstate:
4861  /* In all cases, when you get here, the value and location stacks
4862  have just been pushed. So pushing a state here evens the stacks. */
4863  yyssp++;
4864 
4865  yysetstate:
4866  *yyssp = yystate;
4867 
4868  if (yyss + yystacksize - 1 <= yyssp)
4869  {
4870  /* Get the current used size of the three stacks, in elements. */
4871  YYSIZE_T yysize = yyssp - yyss + 1;
4872 
4873 #ifdef yyoverflow
4874  {
4875  /* Give user a chance to reallocate the stack. Use copies of
4876  these so that the &'s don't force the real ones into
4877  memory. */
4878  YYSTYPE *yyvs1 = yyvs;
4879  yytype_int16 *yyss1 = yyss;
4880 
4881  /* Each stack pointer address is followed by the size of the
4882  data in use in that stack, in bytes. This used to be a
4883  conditional around just the two extra args, but that might
4884  be undefined if yyoverflow is a macro. */
4885  yyoverflow (YY_("memory exhausted"),
4886  &yyss1, yysize * sizeof (*yyssp),
4887  &yyvs1, yysize * sizeof (*yyvsp),
4888  &yystacksize);
4889 
4890  yyss = yyss1;
4891  yyvs = yyvs1;
4892  }
4893 #else /* no yyoverflow */
4894 # ifndef YYSTACK_RELOCATE
4895  goto yyexhaustedlab;
4896 # else
4897  /* Extend the stack our own way. */
4898  if (YYMAXDEPTH <= yystacksize)
4899  goto yyexhaustedlab;
4900  yystacksize *= 2;
4901  if (YYMAXDEPTH < yystacksize)
4902  yystacksize = YYMAXDEPTH;
4903 
4904  {
4905  yytype_int16 *yyss1 = yyss;
4906  union yyalloc *yyptr =
4907  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
4908  if (! yyptr)
4909  goto yyexhaustedlab;
4910  YYSTACK_RELOCATE (yyss_alloc, yyss);
4911  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
4912 # undef YYSTACK_RELOCATE
4913  if (yyss1 != yyssa)
4914  YYSTACK_FREE (yyss1);
4915  }
4916 # endif
4917 #endif /* no yyoverflow */
4918 
4919  yyssp = yyss + yysize - 1;
4920  yyvsp = yyvs + yysize - 1;
4921 
4922  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
4923  (unsigned long int) yystacksize));
4924 
4925  if (yyss + yystacksize - 1 <= yyssp)
4926  YYABORT;
4927  }
4928 
4929  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
4930 
4931  if (yystate == YYFINAL)
4932  YYACCEPT;
4933 
4934  goto yybackup;
4935 
4936 /*-----------.
4937 | yybackup. |
4938 `-----------*/
4939 yybackup:
4940 
4941  /* Do appropriate processing given the current state. Read a
4942  lookahead token if we need one and don't already have one. */
4943 
4944  /* First try to decide what to do without reference to lookahead token. */
4945  yyn = yypact[yystate];
4946  if (yypact_value_is_default (yyn))
4947  goto yydefault;
4948 
4949  /* Not known => get a lookahead token if don't already have one. */
4950 
4951  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
4952  if (yychar == YYEMPTY)
4953  {
4954  YYDPRINTF ((stderr, "Reading a token: "));
4955  yychar = YYLEX;
4956  }
4957 
4958  if (yychar <= YYEOF)
4959  {
4960  yychar = yytoken = YYEOF;
4961  YYDPRINTF ((stderr, "Now at end of input.\n"));
4962  }
4963  else
4964  {
4965  yytoken = YYTRANSLATE (yychar);
4966  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
4967  }
4968 
4969  /* If the proper action on seeing token YYTOKEN is to reduce or to
4970  detect an error, take that action. */
4971  yyn += yytoken;
4972  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
4973  goto yydefault;
4974  yyn = yytable[yyn];
4975  if (yyn <= 0)
4976  {
4977  if (yytable_value_is_error (yyn))
4978  goto yyerrlab;
4979  yyn = -yyn;
4980  goto yyreduce;
4981  }
4982 
4983  /* Count tokens shifted since error; after three, turn off error
4984  status. */
4985  if (yyerrstatus)
4986  yyerrstatus--;
4987 
4988  /* Shift the lookahead token. */
4989  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
4990 
4991  /* Discard the shifted token. */
4992  yychar = YYEMPTY;
4993 
4994  yystate = yyn;
4995  *++yyvsp = yylval;
4996 
4997  goto yynewstate;
4998 
4999 
5000 /*-----------------------------------------------------------.
5001 | yydefault -- do the default action for the current state. |
5002 `-----------------------------------------------------------*/
5003 yydefault:
5004  yyn = yydefact[yystate];
5005  if (yyn == 0)
5006  goto yyerrlab;
5007  goto yyreduce;
5008 
5009 
5010 /*-----------------------------.
5011 | yyreduce -- Do a reduction. |
5012 `-----------------------------*/
5013 yyreduce:
5014  /* yyn is the number of a rule to reduce with. */
5015  yylen = yyr2[yyn];
5016 
5017  /* If YYLEN is nonzero, implement the default value of the action:
5018  `$$ = $1'.
5019 
5020  Otherwise, the following line sets YYVAL to garbage.
5021  This behavior is undocumented and Bison
5022  users should not rely upon it. Assigning to YYVAL
5023  unconditionally makes the parser a bit smaller, and it avoids a
5024  GCC warning that YYVAL may be used uninitialized. */
5025  yyval = yyvsp[1-yylen];
5026 
5027 
5028  YY_REDUCE_PRINT (yyn);
5029  switch (yyn)
5030  {
5031  case 2:
5032 
5033 /* Line 1806 of yacc.c */
5034 #line 786 "parse.y"
5035  {
5036  lex_state = EXPR_BEG;
5037  /*%%%*/
5039  /*%
5040  local_push(0);
5041  %*/
5042  }
5043  break;
5044 
5045  case 3:
5046 
5047 /* Line 1806 of yacc.c */
5048 #line 795 "parse.y"
5049  {
5050  /*%%%*/
5051  if ((yyvsp[(2) - (2)].node) && !compile_for_eval) {
5052  /* last expression should not be void */
5053  if (nd_type((yyvsp[(2) - (2)].node)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].node));
5054  else {
5055  NODE *node = (yyvsp[(2) - (2)].node);
5056  while (node->nd_next) {
5057  node = node->nd_next;
5058  }
5059  void_expr(node->nd_head);
5060  }
5061  }
5062  ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].node)));
5063  /*%
5064  $$ = $2;
5065  parser->result = dispatch1(program, $$);
5066  %*/
5067  local_pop();
5068  }
5069  break;
5070 
5071  case 4:
5072 
5073 /* Line 1806 of yacc.c */
5074 #line 818 "parse.y"
5075  {
5076  /*%%%*/
5077  void_stmts((yyvsp[(1) - (2)].node));
5079  /*%
5080  %*/
5081  (yyval.node) = (yyvsp[(1) - (2)].node);
5082  }
5083  break;
5084 
5085  case 5:
5086 
5087 /* Line 1806 of yacc.c */
5088 #line 829 "parse.y"
5089  {
5090  /*%%%*/
5091  (yyval.node) = NEW_BEGIN(0);
5092  /*%
5093  $$ = dispatch2(stmts_add, dispatch0(stmts_new),
5094  dispatch0(void_stmt));
5095  %*/
5096  }
5097  break;
5098 
5099  case 6:
5100 
5101 /* Line 1806 of yacc.c */
5102 #line 838 "parse.y"
5103  {
5104  /*%%%*/
5105  (yyval.node) = newline_node((yyvsp[(1) - (1)].node));
5106  /*%
5107  $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
5108  %*/
5109  }
5110  break;
5111 
5112  case 7:
5113 
5114 /* Line 1806 of yacc.c */
5115 #line 846 "parse.y"
5116  {
5117  /*%%%*/
5118  (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node)));
5119  /*%
5120  $$ = dispatch2(stmts_add, $1, $3);
5121  %*/
5122  }
5123  break;
5124 
5125  case 8:
5126 
5127 /* Line 1806 of yacc.c */
5128 #line 854 "parse.y"
5129  {
5130  (yyval.node) = remove_begin((yyvsp[(2) - (2)].node));
5131  }
5132  break;
5133 
5134  case 10:
5135 
5136 /* Line 1806 of yacc.c */
5137 #line 861 "parse.y"
5138  {
5139  if (in_def || in_single) {
5140  yyerror("BEGIN in method");
5141  }
5142  /*%%%*/
5143  /* local_push(0); */
5144  /*%
5145  %*/
5146  }
5147  break;
5148 
5149  case 11:
5150 
5151 /* Line 1806 of yacc.c */
5152 #line 871 "parse.y"
5153  {
5154  /*%%%*/
5156  (yyvsp[(4) - (5)].node));
5157  /* NEW_PREEXE($4)); */
5158  /* local_pop(); */
5159  (yyval.node) = NEW_BEGIN(0);
5160  /*%
5161  $$ = dispatch1(BEGIN, $4);
5162  %*/
5163  }
5164  break;
5165 
5166  case 12:
5167 
5168 /* Line 1806 of yacc.c */
5169 #line 888 "parse.y"
5170  {
5171  /*%%%*/
5172  (yyval.node) = (yyvsp[(1) - (4)].node);
5173  if ((yyvsp[(2) - (4)].node)) {
5174  (yyval.node) = NEW_RESCUE((yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].node), (yyvsp[(3) - (4)].node));
5175  }
5176  else if ((yyvsp[(3) - (4)].node)) {
5177  rb_warn0("else without rescue is useless");
5178  (yyval.node) = block_append((yyval.node), (yyvsp[(3) - (4)].node));
5179  }
5180  if ((yyvsp[(4) - (4)].node)) {
5181  if ((yyval.node)) {
5182  (yyval.node) = NEW_ENSURE((yyval.node), (yyvsp[(4) - (4)].node));
5183  }
5184  else {
5185  (yyval.node) = block_append((yyvsp[(4) - (4)].node), NEW_NIL());
5186  }
5187  }
5188  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
5189  /*%
5190  $$ = dispatch4(bodystmt,
5191  escape_Qundef($1),
5192  escape_Qundef($2),
5193  escape_Qundef($3),
5194  escape_Qundef($4));
5195  %*/
5196  }
5197  break;
5198 
5199  case 13:
5200 
5201 /* Line 1806 of yacc.c */
5202 #line 918 "parse.y"
5203  {
5204  /*%%%*/
5205  void_stmts((yyvsp[(1) - (2)].node));
5207  /*%
5208  %*/
5209  (yyval.node) = (yyvsp[(1) - (2)].node);
5210  }
5211  break;
5212 
5213  case 14:
5214 
5215 /* Line 1806 of yacc.c */
5216 #line 929 "parse.y"
5217  {
5218  /*%%%*/
5219  (yyval.node) = NEW_BEGIN(0);
5220  /*%
5221  $$ = dispatch2(stmts_add, dispatch0(stmts_new),
5222  dispatch0(void_stmt));
5223  %*/
5224  }
5225  break;
5226 
5227  case 15:
5228 
5229 /* Line 1806 of yacc.c */
5230 #line 938 "parse.y"
5231  {
5232  /*%%%*/
5233  (yyval.node) = newline_node((yyvsp[(1) - (1)].node));
5234  /*%
5235  $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
5236  %*/
5237  }
5238  break;
5239 
5240  case 16:
5241 
5242 /* Line 1806 of yacc.c */
5243 #line 946 "parse.y"
5244  {
5245  /*%%%*/
5246  (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node)));
5247  /*%
5248  $$ = dispatch2(stmts_add, $1, $3);
5249  %*/
5250  }
5251  break;
5252 
5253  case 17:
5254 
5255 /* Line 1806 of yacc.c */
5256 #line 954 "parse.y"
5257  {
5258  (yyval.node) = remove_begin((yyvsp[(2) - (2)].node));
5259  }
5260  break;
5261 
5262  case 18:
5263 
5264 /* Line 1806 of yacc.c */
5265 #line 959 "parse.y"
5266  {lex_state = EXPR_FNAME;}
5267  break;
5268 
5269  case 19:
5270 
5271 /* Line 1806 of yacc.c */
5272 #line 960 "parse.y"
5273  {
5274  /*%%%*/
5275  (yyval.node) = NEW_ALIAS((yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].node));
5276  /*%
5277  $$ = dispatch2(alias, $2, $4);
5278  %*/
5279  }
5280  break;
5281 
5282  case 20:
5283 
5284 /* Line 1806 of yacc.c */
5285 #line 968 "parse.y"
5286  {
5287  /*%%%*/
5288  (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].id));
5289  /*%
5290  $$ = dispatch2(var_alias, $2, $3);
5291  %*/
5292  }
5293  break;
5294 
5295  case 21:
5296 
5297 /* Line 1806 of yacc.c */
5298 #line 976 "parse.y"
5299  {
5300  /*%%%*/
5301  char buf[2];
5302  buf[0] = '$';
5303  buf[1] = (char)(yyvsp[(3) - (3)].node)->nd_nth;
5304  (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), rb_intern2(buf, 2));
5305  /*%
5306  $$ = dispatch2(var_alias, $2, $3);
5307  %*/
5308  }
5309  break;
5310 
5311  case 22:
5312 
5313 /* Line 1806 of yacc.c */
5314 #line 987 "parse.y"
5315  {
5316  /*%%%*/
5317  yyerror("can't make alias for the number variables");
5318  (yyval.node) = NEW_BEGIN(0);
5319  /*%
5320  $$ = dispatch2(var_alias, $2, $3);
5321  $$ = dispatch1(alias_error, $$);
5322  %*/
5323  }
5324  break;
5325 
5326  case 23:
5327 
5328 /* Line 1806 of yacc.c */
5329 #line 997 "parse.y"
5330  {
5331  /*%%%*/
5332  (yyval.node) = (yyvsp[(2) - (2)].node);
5333  /*%
5334  $$ = dispatch1(undef, $2);
5335  %*/
5336  }
5337  break;
5338 
5339  case 24:
5340 
5341 /* Line 1806 of yacc.c */
5342 #line 1005 "parse.y"
5343  {
5344  /*%%%*/
5345  (yyval.node) = NEW_IF(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0);
5346  fixpos((yyval.node), (yyvsp[(3) - (3)].node));
5347  /*%
5348  $$ = dispatch2(if_mod, $3, $1);
5349  %*/
5350  }
5351  break;
5352 
5353  case 25:
5354 
5355 /* Line 1806 of yacc.c */
5356 #line 1014 "parse.y"
5357  {
5358  /*%%%*/
5359  (yyval.node) = NEW_UNLESS(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0);
5360  fixpos((yyval.node), (yyvsp[(3) - (3)].node));
5361  /*%
5362  $$ = dispatch2(unless_mod, $3, $1);
5363  %*/
5364  }
5365  break;
5366 
5367  case 26:
5368 
5369 /* Line 1806 of yacc.c */
5370 #line 1023 "parse.y"
5371  {
5372  /*%%%*/
5373  if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) {
5374  (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0);
5375  }
5376  else {
5377  (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1);
5378  }
5379  /*%
5380  $$ = dispatch2(while_mod, $3, $1);
5381  %*/
5382  }
5383  break;
5384 
5385  case 27:
5386 
5387 /* Line 1806 of yacc.c */
5388 #line 1036 "parse.y"
5389  {
5390  /*%%%*/
5391  if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) {
5392  (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0);
5393  }
5394  else {
5395  (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1);
5396  }
5397  /*%
5398  $$ = dispatch2(until_mod, $3, $1);
5399  %*/
5400  }
5401  break;
5402 
5403  case 28:
5404 
5405 /* Line 1806 of yacc.c */
5406 #line 1049 "parse.y"
5407  {
5408  /*%%%*/
5409  NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].node)), 0);
5410  (yyval.node) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].node)), resq, 0);
5411  /*%
5412  $$ = dispatch2(rescue_mod, $1, $3);
5413  %*/
5414  }
5415  break;
5416 
5417  case 29:
5418 
5419 /* Line 1806 of yacc.c */
5420 #line 1058 "parse.y"
5421  {
5422  if (in_def || in_single) {
5423  rb_warn0("END in method; use at_exit");
5424  }
5425  /*%%%*/
5426  (yyval.node) = NEW_POSTEXE(NEW_NODE(
5427  NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].node) /* body */, 0 /* args */));
5428  /*%
5429  $$ = dispatch1(END, $3);
5430  %*/
5431  }
5432  break;
5433 
5434  case 31:
5435 
5436 /* Line 1806 of yacc.c */
5437 #line 1071 "parse.y"
5438  {
5439  /*%%%*/
5440  value_expr((yyvsp[(3) - (3)].node));
5441  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
5442  (yyval.node) = (yyvsp[(1) - (3)].node);
5443  /*%
5444  $$ = dispatch2(massign, $1, $3);
5445  %*/
5446  }
5447  break;
5448 
5449  case 32:
5450 
5451 /* Line 1806 of yacc.c */
5452 #line 1081 "parse.y"
5453  {
5454  /*%%%*/
5455  value_expr((yyvsp[(3) - (3)].node));
5456  if ((yyvsp[(1) - (3)].node)) {
5457  ID vid = (yyvsp[(1) - (3)].node)->nd_vid;
5458  if ((yyvsp[(2) - (3)].id) == tOROP) {
5459  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
5460  (yyval.node) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (3)].node));
5461  if (is_asgn_or_id(vid)) {
5462  (yyval.node)->nd_aid = vid;
5463  }
5464  }
5465  else if ((yyvsp[(2) - (3)].id) == tANDOP) {
5466  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
5467  (yyval.node) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (3)].node));
5468  }
5469  else {
5470  (yyval.node) = (yyvsp[(1) - (3)].node);
5471  (yyval.node)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (3)].id), NEW_LIST((yyvsp[(3) - (3)].node)));
5472  }
5473  }
5474  else {
5475  (yyval.node) = NEW_BEGIN(0);
5476  }
5477  /*%
5478  $$ = dispatch3(opassign, $1, $2, $3);
5479  %*/
5480  }
5481  break;
5482 
5483  case 33:
5484 
5485 /* Line 1806 of yacc.c */
5486 #line 1110 "parse.y"
5487  {
5488  /*%%%*/
5489  NODE *args;
5490 
5491  value_expr((yyvsp[(6) - (6)].node));
5492  if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY();
5493  args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
5494  if ((yyvsp[(5) - (6)].id) == tOROP) {
5495  (yyvsp[(5) - (6)].id) = 0;
5496  }
5497  else if ((yyvsp[(5) - (6)].id) == tANDOP) {
5498  (yyvsp[(5) - (6)].id) = 1;
5499  }
5500  (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args);
5501  fixpos((yyval.node), (yyvsp[(1) - (6)].node));
5502  /*%
5503  $$ = dispatch2(aref_field, $1, escape_Qundef($3));
5504  $$ = dispatch3(opassign, $$, $5, $6);
5505  %*/
5506  }
5507  break;
5508 
5509  case 34:
5510 
5511 /* Line 1806 of yacc.c */
5512 #line 1131 "parse.y"
5513  {
5514  /*%%%*/
5515  value_expr((yyvsp[(5) - (5)].node));
5516  if ((yyvsp[(4) - (5)].id) == tOROP) {
5517  (yyvsp[(4) - (5)].id) = 0;
5518  }
5519  else if ((yyvsp[(4) - (5)].id) == tANDOP) {
5520  (yyvsp[(4) - (5)].id) = 1;
5521  }
5522  (yyval.node) = NEW_OP_ASGN2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5523  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
5524  /*%
5525  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
5526  $$ = dispatch3(opassign, $$, $4, $5);
5527  %*/
5528  }
5529  break;
5530 
5531  case 35:
5532 
5533 /* Line 1806 of yacc.c */
5534 #line 1148 "parse.y"
5535  {
5536  /*%%%*/
5537  value_expr((yyvsp[(5) - (5)].node));
5538  if ((yyvsp[(4) - (5)].id) == tOROP) {
5539  (yyvsp[(4) - (5)].id) = 0;
5540  }
5541  else if ((yyvsp[(4) - (5)].id) == tANDOP) {
5542  (yyvsp[(4) - (5)].id) = 1;
5543  }
5544  (yyval.node) = NEW_OP_ASGN2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5545  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
5546  /*%
5547  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
5548  $$ = dispatch3(opassign, $$, $4, $5);
5549  %*/
5550  }
5551  break;
5552 
5553  case 36:
5554 
5555 /* Line 1806 of yacc.c */
5556 #line 1165 "parse.y"
5557  {
5558  /*%%%*/
5559  yyerror("constant re-assignment");
5560  (yyval.node) = 0;
5561  /*%
5562  $$ = dispatch2(const_path_field, $1, $3);
5563  $$ = dispatch3(opassign, $$, $4, $5);
5564  $$ = dispatch1(assign_error, $$);
5565  %*/
5566  }
5567  break;
5568 
5569  case 37:
5570 
5571 /* Line 1806 of yacc.c */
5572 #line 1176 "parse.y"
5573  {
5574  /*%%%*/
5575  value_expr((yyvsp[(5) - (5)].node));
5576  if ((yyvsp[(4) - (5)].id) == tOROP) {
5577  (yyvsp[(4) - (5)].id) = 0;
5578  }
5579  else if ((yyvsp[(4) - (5)].id) == tANDOP) {
5580  (yyvsp[(4) - (5)].id) = 1;
5581  }
5582  (yyval.node) = NEW_OP_ASGN2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5583  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
5584  /*%
5585  $$ = dispatch3(field, $1, ripper_intern("::"), $3);
5586  $$ = dispatch3(opassign, $$, $4, $5);
5587  %*/
5588  }
5589  break;
5590 
5591  case 38:
5592 
5593 /* Line 1806 of yacc.c */
5594 #line 1193 "parse.y"
5595  {
5596  /*%%%*/
5597  rb_backref_error((yyvsp[(1) - (3)].node));
5598  (yyval.node) = NEW_BEGIN(0);
5599  /*%
5600  $$ = dispatch2(assign, dispatch1(var_field, $1), $3);
5601  $$ = dispatch1(assign_error, $$);
5602  %*/
5603  }
5604  break;
5605 
5606  case 39:
5607 
5608 /* Line 1806 of yacc.c */
5609 #line 1203 "parse.y"
5610  {
5611  /*%%%*/
5612  value_expr((yyvsp[(3) - (3)].node));
5613  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5614  /*%
5615  $$ = dispatch2(assign, $1, $3);
5616  %*/
5617  }
5618  break;
5619 
5620  case 40:
5621 
5622 /* Line 1806 of yacc.c */
5623 #line 1212 "parse.y"
5624  {
5625  /*%%%*/
5626  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
5627  (yyval.node) = (yyvsp[(1) - (3)].node);
5628  /*%
5629  $$ = dispatch2(massign, $1, $3);
5630  %*/
5631  }
5632  break;
5633 
5634  case 41:
5635 
5636 /* Line 1806 of yacc.c */
5637 #line 1221 "parse.y"
5638  {
5639  /*%%%*/
5640  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
5641  (yyval.node) = (yyvsp[(1) - (3)].node);
5642  /*%
5643  $$ = dispatch2(massign, $1, $3);
5644  %*/
5645  }
5646  break;
5647 
5648  case 43:
5649 
5650 /* Line 1806 of yacc.c */
5651 #line 1233 "parse.y"
5652  {
5653  /*%%%*/
5654  value_expr((yyvsp[(3) - (3)].node));
5655  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5656  /*%
5657  $$ = dispatch2(assign, $1, $3);
5658  %*/
5659  }
5660  break;
5661 
5662  case 44:
5663 
5664 /* Line 1806 of yacc.c */
5665 #line 1242 "parse.y"
5666  {
5667  /*%%%*/
5668  value_expr((yyvsp[(3) - (3)].node));
5669  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5670  /*%
5671  $$ = dispatch2(assign, $1, $3);
5672  %*/
5673  }
5674  break;
5675 
5676  case 46:
5677 
5678 /* Line 1806 of yacc.c */
5679 #line 1255 "parse.y"
5680  {
5681  /*%%%*/
5682  (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5683  /*%
5684  $$ = dispatch3(binary, $1, ripper_intern("and"), $3);
5685  %*/
5686  }
5687  break;
5688 
5689  case 47:
5690 
5691 /* Line 1806 of yacc.c */
5692 #line 1263 "parse.y"
5693  {
5694  /*%%%*/
5695  (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5696  /*%
5697  $$ = dispatch3(binary, $1, ripper_intern("or"), $3);
5698  %*/
5699  }
5700  break;
5701 
5702  case 48:
5703 
5704 /* Line 1806 of yacc.c */
5705 #line 1271 "parse.y"
5706  {
5707  /*%%%*/
5708  (yyval.node) = call_uni_op(cond((yyvsp[(3) - (3)].node)), '!');
5709  /*%
5710  $$ = dispatch2(unary, ripper_intern("not"), $3);
5711  %*/
5712  }
5713  break;
5714 
5715  case 49:
5716 
5717 /* Line 1806 of yacc.c */
5718 #line 1279 "parse.y"
5719  {
5720  /*%%%*/
5721  (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!');
5722  /*%
5723  $$ = dispatch2(unary, ripper_id2sym('!'), $2);
5724  %*/
5725  }
5726  break;
5727 
5728  case 51:
5729 
5730 /* Line 1806 of yacc.c */
5731 #line 1290 "parse.y"
5732  {
5733  /*%%%*/
5734  value_expr((yyvsp[(1) - (1)].node));
5735  (yyval.node) = (yyvsp[(1) - (1)].node);
5736  if (!(yyval.node)) (yyval.node) = NEW_NIL();
5737  /*%
5738  $$ = $1;
5739  %*/
5740  }
5741  break;
5742 
5743  case 55:
5744 
5745 /* Line 1806 of yacc.c */
5746 #line 1307 "parse.y"
5747  {
5748  /*%%%*/
5749  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
5750  /*%
5751  $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
5752  $$ = method_arg($$, $4);
5753  %*/
5754  }
5755  break;
5756 
5757  case 56:
5758 
5759 /* Line 1806 of yacc.c */
5760 #line 1316 "parse.y"
5761  {
5762  /*%%%*/
5763  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
5764  /*%
5765  $$ = dispatch3(call, $1, ripper_intern("::"), $3);
5766  $$ = method_arg($$, $4);
5767  %*/
5768  }
5769  break;
5770 
5771  case 57:
5772 
5773 /* Line 1806 of yacc.c */
5774 #line 1327 "parse.y"
5775  {
5776  (yyvsp[(1) - (1)].vars) = dyna_push();
5777  /*%%%*/
5778  (yyval.num) = ruby_sourceline;
5779  /*%
5780  %*/
5781  }
5782  break;
5783 
5784  case 58:
5785 
5786 /* Line 1806 of yacc.c */
5787 #line 1337 "parse.y"
5788  {
5789  /*%%%*/
5790  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
5791  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
5792  /*%
5793  $$ = dispatch2(brace_block, escape_Qundef($3), $4);
5794  %*/
5795  dyna_pop((yyvsp[(1) - (5)].vars));
5796  }
5797  break;
5798 
5799  case 59:
5800 
5801 /* Line 1806 of yacc.c */
5802 #line 1349 "parse.y"
5803  {
5804  /*%%%*/
5805  (yyval.node) = NEW_FCALL((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node));
5806  fixpos((yyval.node), (yyvsp[(2) - (2)].node));
5807  /*%
5808  $$ = dispatch2(command, $1, $2);
5809  %*/
5810  }
5811  break;
5812 
5813  case 60:
5814 
5815 /* Line 1806 of yacc.c */
5816 #line 1358 "parse.y"
5817  {
5818  /*%%%*/
5819  block_dup_check((yyvsp[(2) - (3)].node),(yyvsp[(3) - (3)].node));
5820  (yyvsp[(3) - (3)].node)->nd_iter = NEW_FCALL((yyvsp[(1) - (3)].id), (yyvsp[(2) - (3)].node));
5821  (yyval.node) = (yyvsp[(3) - (3)].node);
5822  fixpos((yyval.node), (yyvsp[(2) - (3)].node));
5823  /*%
5824  $$ = dispatch2(command, $1, $2);
5825  $$ = method_add_block($$, $3);
5826  %*/
5827  }
5828  break;
5829 
5830  case 61:
5831 
5832 /* Line 1806 of yacc.c */
5833 #line 1370 "parse.y"
5834  {
5835  /*%%%*/
5836  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
5837  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
5838  /*%
5839  $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
5840  %*/
5841  }
5842  break;
5843 
5844  case 62:
5845 
5846 /* Line 1806 of yacc.c */
5847 #line 1379 "parse.y"
5848  {
5849  /*%%%*/
5850  block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node));
5851  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
5852  (yyval.node) = (yyvsp[(5) - (5)].node);
5853  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
5854  /*%
5855  $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
5856  $$ = method_add_block($$, $5);
5857  %*/
5858  }
5859  break;
5860 
5861  case 63:
5862 
5863 /* Line 1806 of yacc.c */
5864 #line 1391 "parse.y"
5865  {
5866  /*%%%*/
5867  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
5868  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
5869  /*%
5870  $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
5871  %*/
5872  }
5873  break;
5874 
5875  case 64:
5876 
5877 /* Line 1806 of yacc.c */
5878 #line 1400 "parse.y"
5879  {
5880  /*%%%*/
5881  block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node));
5882  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
5883  (yyval.node) = (yyvsp[(5) - (5)].node);
5884  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
5885  /*%
5886  $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
5887  $$ = method_add_block($$, $5);
5888  %*/
5889  }
5890  break;
5891 
5892  case 65:
5893 
5894 /* Line 1806 of yacc.c */
5895 #line 1412 "parse.y"
5896  {
5897  /*%%%*/
5898  (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node));
5899  fixpos((yyval.node), (yyvsp[(2) - (2)].node));
5900  /*%
5901  $$ = dispatch1(super, $2);
5902  %*/
5903  }
5904  break;
5905 
5906  case 66:
5907 
5908 /* Line 1806 of yacc.c */
5909 #line 1421 "parse.y"
5910  {
5911  /*%%%*/
5912  (yyval.node) = new_yield((yyvsp[(2) - (2)].node));
5913  fixpos((yyval.node), (yyvsp[(2) - (2)].node));
5914  /*%
5915  $$ = dispatch1(yield, $2);
5916  %*/
5917  }
5918  break;
5919 
5920  case 67:
5921 
5922 /* Line 1806 of yacc.c */
5923 #line 1430 "parse.y"
5924  {
5925  /*%%%*/
5926  (yyval.node) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].node)));
5927  /*%
5928  $$ = dispatch1(return, $2);
5929  %*/
5930  }
5931  break;
5932 
5933  case 68:
5934 
5935 /* Line 1806 of yacc.c */
5936 #line 1438 "parse.y"
5937  {
5938  /*%%%*/
5939  (yyval.node) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].node)));
5940  /*%
5941  $$ = dispatch1(break, $2);
5942  %*/
5943  }
5944  break;
5945 
5946  case 69:
5947 
5948 /* Line 1806 of yacc.c */
5949 #line 1446 "parse.y"
5950  {
5951  /*%%%*/
5952  (yyval.node) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].node)));
5953  /*%
5954  $$ = dispatch1(next, $2);
5955  %*/
5956  }
5957  break;
5958 
5959  case 71:
5960 
5961 /* Line 1806 of yacc.c */
5962 #line 1457 "parse.y"
5963  {
5964  /*%%%*/
5965  (yyval.node) = (yyvsp[(2) - (3)].node);
5966  /*%
5967  $$ = dispatch1(mlhs_paren, $2);
5968  %*/
5969  }
5970  break;
5971 
5972  case 73:
5973 
5974 /* Line 1806 of yacc.c */
5975 #line 1468 "parse.y"
5976  {
5977  /*%%%*/
5978  (yyval.node) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].node)), 0);
5979  /*%
5980  $$ = dispatch1(mlhs_paren, $2);
5981  %*/
5982  }
5983  break;
5984 
5985  case 74:
5986 
5987 /* Line 1806 of yacc.c */
5988 #line 1478 "parse.y"
5989  {
5990  /*%%%*/
5991  (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0);
5992  /*%
5993  $$ = $1;
5994  %*/
5995  }
5996  break;
5997 
5998  case 75:
5999 
6000 /* Line 1806 of yacc.c */
6001 #line 1486 "parse.y"
6002  {
6003  /*%%%*/
6004  (yyval.node) = NEW_MASGN(list_append((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node)), 0);
6005  /*%
6006  $$ = mlhs_add($1, $2);
6007  %*/
6008  }
6009  break;
6010 
6011  case 76:
6012 
6013 /* Line 1806 of yacc.c */
6014 #line 1494 "parse.y"
6015  {
6016  /*%%%*/
6017  (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
6018  /*%
6019  $$ = mlhs_add_star($1, $3);
6020  %*/
6021  }
6022  break;
6023 
6024  case 77:
6025 
6026 /* Line 1806 of yacc.c */
6027 #line 1502 "parse.y"
6028  {
6029  /*%%%*/
6030  (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG((yyvsp[(3) - (5)].node),(yyvsp[(5) - (5)].node)));
6031  /*%
6032  $1 = mlhs_add_star($1, $3);
6033  $$ = mlhs_add($1, $5);
6034  %*/
6035  }
6036  break;
6037 
6038  case 78:
6039 
6040 /* Line 1806 of yacc.c */
6041 #line 1511 "parse.y"
6042  {
6043  /*%%%*/
6044  (yyval.node) = NEW_MASGN((yyvsp[(1) - (2)].node), -1);
6045  /*%
6046  $$ = mlhs_add_star($1, Qnil);
6047  %*/
6048  }
6049  break;
6050 
6051  case 79:
6052 
6053 /* Line 1806 of yacc.c */
6054 #line 1519 "parse.y"
6055  {
6056  /*%%%*/
6057  (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), NEW_POSTARG(-1, (yyvsp[(4) - (4)].node)));
6058  /*%
6059  $1 = mlhs_add_star($1, Qnil);
6060  $$ = mlhs_add($1, $4);
6061  %*/
6062  }
6063  break;
6064 
6065  case 80:
6066 
6067 /* Line 1806 of yacc.c */
6068 #line 1528 "parse.y"
6069  {
6070  /*%%%*/
6071  (yyval.node) = NEW_MASGN(0, (yyvsp[(2) - (2)].node));
6072  /*%
6073  $$ = mlhs_add_star(mlhs_new(), $2);
6074  %*/
6075  }
6076  break;
6077 
6078  case 81:
6079 
6080 /* Line 1806 of yacc.c */
6081 #line 1536 "parse.y"
6082  {
6083  /*%%%*/
6084  (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].node),(yyvsp[(4) - (4)].node)));
6085  /*%
6086  $2 = mlhs_add_star(mlhs_new(), $2);
6087  $$ = mlhs_add($2, $4);
6088  %*/
6089  }
6090  break;
6091 
6092  case 82:
6093 
6094 /* Line 1806 of yacc.c */
6095 #line 1545 "parse.y"
6096  {
6097  /*%%%*/
6098  (yyval.node) = NEW_MASGN(0, -1);
6099  /*%
6100  $$ = mlhs_add_star(mlhs_new(), Qnil);
6101  %*/
6102  }
6103  break;
6104 
6105  case 83:
6106 
6107 /* Line 1806 of yacc.c */
6108 #line 1553 "parse.y"
6109  {
6110  /*%%%*/
6111  (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node)));
6112  /*%
6113  $$ = mlhs_add_star(mlhs_new(), Qnil);
6114  $$ = mlhs_add($$, $3);
6115  %*/
6116  }
6117  break;
6118 
6119  case 85:
6120 
6121 /* Line 1806 of yacc.c */
6122 #line 1565 "parse.y"
6123  {
6124  /*%%%*/
6125  (yyval.node) = (yyvsp[(2) - (3)].node);
6126  /*%
6127  $$ = dispatch1(mlhs_paren, $2);
6128  %*/
6129  }
6130  break;
6131 
6132  case 86:
6133 
6134 /* Line 1806 of yacc.c */
6135 #line 1575 "parse.y"
6136  {
6137  /*%%%*/
6138  (yyval.node) = NEW_LIST((yyvsp[(1) - (2)].node));
6139  /*%
6140  $$ = mlhs_add(mlhs_new(), $1);
6141  %*/
6142  }
6143  break;
6144 
6145  case 87:
6146 
6147 /* Line 1806 of yacc.c */
6148 #line 1583 "parse.y"
6149  {
6150  /*%%%*/
6151  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
6152  /*%
6153  $$ = mlhs_add($1, $2);
6154  %*/
6155  }
6156  break;
6157 
6158  case 88:
6159 
6160 /* Line 1806 of yacc.c */
6161 #line 1593 "parse.y"
6162  {
6163  /*%%%*/
6164  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
6165  /*%
6166  $$ = mlhs_add(mlhs_new(), $1);
6167  %*/
6168  }
6169  break;
6170 
6171  case 89:
6172 
6173 /* Line 1806 of yacc.c */
6174 #line 1601 "parse.y"
6175  {
6176  /*%%%*/
6177  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
6178  /*%
6179  $$ = mlhs_add($1, $3);
6180  %*/
6181  }
6182  break;
6183 
6184  case 90:
6185 
6186 /* Line 1806 of yacc.c */
6187 #line 1611 "parse.y"
6188  {
6189  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6190  }
6191  break;
6192 
6193  case 91:
6194 
6195 /* Line 1806 of yacc.c */
6196 #line 1615 "parse.y"
6197  {
6198  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6199  }
6200  break;
6201 
6202  case 92:
6203 
6204 /* Line 1806 of yacc.c */
6205 #line 1619 "parse.y"
6206  {
6207  /*%%%*/
6208  (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
6209  /*%
6210  $$ = dispatch2(aref_field, $1, escape_Qundef($3));
6211  %*/
6212  }
6213  break;
6214 
6215  case 93:
6216 
6217 /* Line 1806 of yacc.c */
6218 #line 1627 "parse.y"
6219  {
6220  /*%%%*/
6221  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6222  /*%
6223  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6224  %*/
6225  }
6226  break;
6227 
6228  case 94:
6229 
6230 /* Line 1806 of yacc.c */
6231 #line 1635 "parse.y"
6232  {
6233  /*%%%*/
6234  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6235  /*%
6236  $$ = dispatch2(const_path_field, $1, $3);
6237  %*/
6238  }
6239  break;
6240 
6241  case 95:
6242 
6243 /* Line 1806 of yacc.c */
6244 #line 1643 "parse.y"
6245  {
6246  /*%%%*/
6247  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6248  /*%
6249  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6250  %*/
6251  }
6252  break;
6253 
6254  case 96:
6255 
6256 /* Line 1806 of yacc.c */
6257 #line 1651 "parse.y"
6258  {
6259  /*%%%*/
6260  if (in_def || in_single)
6261  yyerror("dynamic constant assignment");
6262  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)));
6263  /*%
6264  if (in_def || in_single)
6265  yyerror("dynamic constant assignment");
6266  $$ = dispatch2(const_path_field, $1, $3);
6267  %*/
6268  }
6269  break;
6270 
6271  case 97:
6272 
6273 /* Line 1806 of yacc.c */
6274 #line 1663 "parse.y"
6275  {
6276  /*%%%*/
6277  if (in_def || in_single)
6278  yyerror("dynamic constant assignment");
6279  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id)));
6280  /*%
6281  $$ = dispatch1(top_const_field, $2);
6282  %*/
6283  }
6284  break;
6285 
6286  case 98:
6287 
6288 /* Line 1806 of yacc.c */
6289 #line 1673 "parse.y"
6290  {
6291  /*%%%*/
6292  rb_backref_error((yyvsp[(1) - (1)].node));
6293  (yyval.node) = NEW_BEGIN(0);
6294  /*%
6295  $$ = dispatch1(var_field, $1);
6296  $$ = dispatch1(assign_error, $$);
6297  %*/
6298  }
6299  break;
6300 
6301  case 99:
6302 
6303 /* Line 1806 of yacc.c */
6304 #line 1685 "parse.y"
6305  {
6306  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6307  /*%%%*/
6308  if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0);
6309  /*%
6310  $$ = dispatch1(var_field, $$);
6311  %*/
6312  }
6313  break;
6314 
6315  case 100:
6316 
6317 /* Line 1806 of yacc.c */
6318 #line 1694 "parse.y"
6319  {
6320  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6321  /*%%%*/
6322  if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0);
6323  /*%
6324  $$ = dispatch1(var_field, $$);
6325  %*/
6326  }
6327  break;
6328 
6329  case 101:
6330 
6331 /* Line 1806 of yacc.c */
6332 #line 1703 "parse.y"
6333  {
6334  /*%%%*/
6335  (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
6336  /*%
6337  $$ = dispatch2(aref_field, $1, escape_Qundef($3));
6338  %*/
6339  }
6340  break;
6341 
6342  case 102:
6343 
6344 /* Line 1806 of yacc.c */
6345 #line 1711 "parse.y"
6346  {
6347  /*%%%*/
6348  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6349  /*%
6350  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6351  %*/
6352  }
6353  break;
6354 
6355  case 103:
6356 
6357 /* Line 1806 of yacc.c */
6358 #line 1719 "parse.y"
6359  {
6360  /*%%%*/
6361  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6362  /*%
6363  $$ = dispatch3(field, $1, ripper_intern("::"), $3);
6364  %*/
6365  }
6366  break;
6367 
6368  case 104:
6369 
6370 /* Line 1806 of yacc.c */
6371 #line 1727 "parse.y"
6372  {
6373  /*%%%*/
6374  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6375  /*%
6376  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6377  %*/
6378  }
6379  break;
6380 
6381  case 105:
6382 
6383 /* Line 1806 of yacc.c */
6384 #line 1735 "parse.y"
6385  {
6386  /*%%%*/
6387  if (in_def || in_single)
6388  yyerror("dynamic constant assignment");
6389  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)));
6390  /*%
6391  $$ = dispatch2(const_path_field, $1, $3);
6392  if (in_def || in_single) {
6393  $$ = dispatch1(assign_error, $$);
6394  }
6395  %*/
6396  }
6397  break;
6398 
6399  case 106:
6400 
6401 /* Line 1806 of yacc.c */
6402 #line 1748 "parse.y"
6403  {
6404  /*%%%*/
6405  if (in_def || in_single)
6406  yyerror("dynamic constant assignment");
6407  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id)));
6408  /*%
6409  $$ = dispatch1(top_const_field, $2);
6410  if (in_def || in_single) {
6411  $$ = dispatch1(assign_error, $$);
6412  }
6413  %*/
6414  }
6415  break;
6416 
6417  case 107:
6418 
6419 /* Line 1806 of yacc.c */
6420 #line 1761 "parse.y"
6421  {
6422  /*%%%*/
6423  rb_backref_error((yyvsp[(1) - (1)].node));
6424  (yyval.node) = NEW_BEGIN(0);
6425  /*%
6426  $$ = dispatch1(assign_error, $1);
6427  %*/
6428  }
6429  break;
6430 
6431  case 108:
6432 
6433 /* Line 1806 of yacc.c */
6434 #line 1772 "parse.y"
6435  {
6436  /*%%%*/
6437  yyerror("class/module name must be CONSTANT");
6438  /*%
6439  $$ = dispatch1(class_name_error, $1);
6440  %*/
6441  }
6442  break;
6443 
6444  case 110:
6445 
6446 /* Line 1806 of yacc.c */
6447 #line 1783 "parse.y"
6448  {
6449  /*%%%*/
6450  (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id));
6451  /*%
6452  $$ = dispatch1(top_const_ref, $2);
6453  %*/
6454  }
6455  break;
6456 
6457  case 111:
6458 
6459 /* Line 1806 of yacc.c */
6460 #line 1791 "parse.y"
6461  {
6462  /*%%%*/
6463  (yyval.node) = NEW_COLON2(0, (yyval.node));
6464  /*%
6465  $$ = dispatch1(const_ref, $1);
6466  %*/
6467  }
6468  break;
6469 
6470  case 112:
6471 
6472 /* Line 1806 of yacc.c */
6473 #line 1799 "parse.y"
6474  {
6475  /*%%%*/
6476  (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6477  /*%
6478  $$ = dispatch2(const_path_ref, $1, $3);
6479  %*/
6480  }
6481  break;
6482 
6483  case 116:
6484 
6485 /* Line 1806 of yacc.c */
6486 #line 1812 "parse.y"
6487  {
6489  (yyval.id) = (yyvsp[(1) - (1)].id);
6490  }
6491  break;
6492 
6493  case 117:
6494 
6495 /* Line 1806 of yacc.c */
6496 #line 1817 "parse.y"
6497  {
6499  /*%%%*/
6500  (yyval.id) = (yyvsp[(1) - (1)].id);
6501  /*%
6502  $$ = $1;
6503  %*/
6504  }
6505  break;
6506 
6507  case 120:
6508 
6509 /* Line 1806 of yacc.c */
6510 #line 1832 "parse.y"
6511  {
6512  /*%%%*/
6513  (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id)));
6514  /*%
6515  $$ = dispatch1(symbol_literal, $1);
6516  %*/
6517  }
6518  break;
6519 
6520  case 122:
6521 
6522 /* Line 1806 of yacc.c */
6523 #line 1843 "parse.y"
6524  {
6525  /*%%%*/
6526  (yyval.node) = NEW_UNDEF((yyvsp[(1) - (1)].node));
6527  /*%
6528  $$ = rb_ary_new3(1, $1);
6529  %*/
6530  }
6531  break;
6532 
6533  case 123:
6534 
6535 /* Line 1806 of yacc.c */
6536 #line 1850 "parse.y"
6537  {lex_state = EXPR_FNAME;}
6538  break;
6539 
6540  case 124:
6541 
6542 /* Line 1806 of yacc.c */
6543 #line 1851 "parse.y"
6544  {
6545  /*%%%*/
6546  (yyval.node) = block_append((yyvsp[(1) - (4)].node), NEW_UNDEF((yyvsp[(4) - (4)].node)));
6547  /*%
6548  rb_ary_push($1, $4);
6549  %*/
6550  }
6551  break;
6552 
6553  case 125:
6554 
6555 /* Line 1806 of yacc.c */
6556 #line 1860 "parse.y"
6557  { ifndef_ripper((yyval.id) = '|'); }
6558  break;
6559 
6560  case 126:
6561 
6562 /* Line 1806 of yacc.c */
6563 #line 1861 "parse.y"
6564  { ifndef_ripper((yyval.id) = '^'); }
6565  break;
6566 
6567  case 127:
6568 
6569 /* Line 1806 of yacc.c */
6570 #line 1862 "parse.y"
6571  { ifndef_ripper((yyval.id) = '&'); }
6572  break;
6573 
6574  case 128:
6575 
6576 /* Line 1806 of yacc.c */
6577 #line 1863 "parse.y"
6578  { ifndef_ripper((yyval.id) = tCMP); }
6579  break;
6580 
6581  case 129:
6582 
6583 /* Line 1806 of yacc.c */
6584 #line 1864 "parse.y"
6585  { ifndef_ripper((yyval.id) = tEQ); }
6586  break;
6587 
6588  case 130:
6589 
6590 /* Line 1806 of yacc.c */
6591 #line 1865 "parse.y"
6592  { ifndef_ripper((yyval.id) = tEQQ); }
6593  break;
6594 
6595  case 131:
6596 
6597 /* Line 1806 of yacc.c */
6598 #line 1866 "parse.y"
6599  { ifndef_ripper((yyval.id) = tMATCH); }
6600  break;
6601 
6602  case 132:
6603 
6604 /* Line 1806 of yacc.c */
6605 #line 1867 "parse.y"
6606  { ifndef_ripper((yyval.id) = tNMATCH); }
6607  break;
6608 
6609  case 133:
6610 
6611 /* Line 1806 of yacc.c */
6612 #line 1868 "parse.y"
6613  { ifndef_ripper((yyval.id) = '>'); }
6614  break;
6615 
6616  case 134:
6617 
6618 /* Line 1806 of yacc.c */
6619 #line 1869 "parse.y"
6620  { ifndef_ripper((yyval.id) = tGEQ); }
6621  break;
6622 
6623  case 135:
6624 
6625 /* Line 1806 of yacc.c */
6626 #line 1870 "parse.y"
6627  { ifndef_ripper((yyval.id) = '<'); }
6628  break;
6629 
6630  case 136:
6631 
6632 /* Line 1806 of yacc.c */
6633 #line 1871 "parse.y"
6634  { ifndef_ripper((yyval.id) = tLEQ); }
6635  break;
6636 
6637  case 137:
6638 
6639 /* Line 1806 of yacc.c */
6640 #line 1872 "parse.y"
6641  { ifndef_ripper((yyval.id) = tNEQ); }
6642  break;
6643 
6644  case 138:
6645 
6646 /* Line 1806 of yacc.c */
6647 #line 1873 "parse.y"
6648  { ifndef_ripper((yyval.id) = tLSHFT); }
6649  break;
6650 
6651  case 139:
6652 
6653 /* Line 1806 of yacc.c */
6654 #line 1874 "parse.y"
6655  { ifndef_ripper((yyval.id) = tRSHFT); }
6656  break;
6657 
6658  case 140:
6659 
6660 /* Line 1806 of yacc.c */
6661 #line 1875 "parse.y"
6662  { ifndef_ripper((yyval.id) = '+'); }
6663  break;
6664 
6665  case 141:
6666 
6667 /* Line 1806 of yacc.c */
6668 #line 1876 "parse.y"
6669  { ifndef_ripper((yyval.id) = '-'); }
6670  break;
6671 
6672  case 142:
6673 
6674 /* Line 1806 of yacc.c */
6675 #line 1877 "parse.y"
6676  { ifndef_ripper((yyval.id) = '*'); }
6677  break;
6678 
6679  case 143:
6680 
6681 /* Line 1806 of yacc.c */
6682 #line 1878 "parse.y"
6683  { ifndef_ripper((yyval.id) = '*'); }
6684  break;
6685 
6686  case 144:
6687 
6688 /* Line 1806 of yacc.c */
6689 #line 1879 "parse.y"
6690  { ifndef_ripper((yyval.id) = '/'); }
6691  break;
6692 
6693  case 145:
6694 
6695 /* Line 1806 of yacc.c */
6696 #line 1880 "parse.y"
6697  { ifndef_ripper((yyval.id) = '%'); }
6698  break;
6699 
6700  case 146:
6701 
6702 /* Line 1806 of yacc.c */
6703 #line 1881 "parse.y"
6704  { ifndef_ripper((yyval.id) = tPOW); }
6705  break;
6706 
6707  case 147:
6708 
6709 /* Line 1806 of yacc.c */
6710 #line 1882 "parse.y"
6711  { ifndef_ripper((yyval.id) = '!'); }
6712  break;
6713 
6714  case 148:
6715 
6716 /* Line 1806 of yacc.c */
6717 #line 1883 "parse.y"
6718  { ifndef_ripper((yyval.id) = '~'); }
6719  break;
6720 
6721  case 149:
6722 
6723 /* Line 1806 of yacc.c */
6724 #line 1884 "parse.y"
6725  { ifndef_ripper((yyval.id) = tUPLUS); }
6726  break;
6727 
6728  case 150:
6729 
6730 /* Line 1806 of yacc.c */
6731 #line 1885 "parse.y"
6732  { ifndef_ripper((yyval.id) = tUMINUS); }
6733  break;
6734 
6735  case 151:
6736 
6737 /* Line 1806 of yacc.c */
6738 #line 1886 "parse.y"
6739  { ifndef_ripper((yyval.id) = tAREF); }
6740  break;
6741 
6742  case 152:
6743 
6744 /* Line 1806 of yacc.c */
6745 #line 1887 "parse.y"
6746  { ifndef_ripper((yyval.id) = tASET); }
6747  break;
6748 
6749  case 153:
6750 
6751 /* Line 1806 of yacc.c */
6752 #line 1888 "parse.y"
6753  { ifndef_ripper((yyval.id) = '`'); }
6754  break;
6755 
6756  case 195:
6757 
6758 /* Line 1806 of yacc.c */
6759 #line 1906 "parse.y"
6760  {
6761  /*%%%*/
6762  value_expr((yyvsp[(3) - (3)].node));
6763  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
6764  /*%
6765  $$ = dispatch2(assign, $1, $3);
6766  %*/
6767  }
6768  break;
6769 
6770  case 196:
6771 
6772 /* Line 1806 of yacc.c */
6773 #line 1915 "parse.y"
6774  {
6775  /*%%%*/
6776  value_expr((yyvsp[(3) - (5)].node));
6777  (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0);
6778  (yyval.node) = node_assign((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node));
6779  /*%
6780  $$ = dispatch2(assign, $1, dispatch2(rescue_mod, $3, $5));
6781  %*/
6782  }
6783  break;
6784 
6785  case 197:
6786 
6787 /* Line 1806 of yacc.c */
6788 #line 1925 "parse.y"
6789  {
6790  /*%%%*/
6791  value_expr((yyvsp[(3) - (3)].node));
6792  if ((yyvsp[(1) - (3)].node)) {
6793  ID vid = (yyvsp[(1) - (3)].node)->nd_vid;
6794  if ((yyvsp[(2) - (3)].id) == tOROP) {
6795  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
6796  (yyval.node) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (3)].node));
6797  if (is_asgn_or_id(vid)) {
6798  (yyval.node)->nd_aid = vid;
6799  }
6800  }
6801  else if ((yyvsp[(2) - (3)].id) == tANDOP) {
6802  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
6803  (yyval.node) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (3)].node));
6804  }
6805  else {
6806  (yyval.node) = (yyvsp[(1) - (3)].node);
6807  (yyval.node)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (3)].id), NEW_LIST((yyvsp[(3) - (3)].node)));
6808  }
6809  }
6810  else {
6811  (yyval.node) = NEW_BEGIN(0);
6812  }
6813  /*%
6814  $$ = dispatch3(opassign, $1, $2, $3);
6815  %*/
6816  }
6817  break;
6818 
6819  case 198:
6820 
6821 /* Line 1806 of yacc.c */
6822 #line 1954 "parse.y"
6823  {
6824  /*%%%*/
6825  value_expr((yyvsp[(3) - (5)].node));
6826  (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0);
6827  if ((yyvsp[(1) - (5)].node)) {
6828  ID vid = (yyvsp[(1) - (5)].node)->nd_vid;
6829  if ((yyvsp[(2) - (5)].id) == tOROP) {
6830  (yyvsp[(1) - (5)].node)->nd_value = (yyvsp[(3) - (5)].node);
6831  (yyval.node) = NEW_OP_ASGN_OR(gettable(vid), (yyvsp[(1) - (5)].node));
6832  if (is_asgn_or_id(vid)) {
6833  (yyval.node)->nd_aid = vid;
6834  }
6835  }
6836  else if ((yyvsp[(2) - (5)].id) == tANDOP) {
6837  (yyvsp[(1) - (5)].node)->nd_value = (yyvsp[(3) - (5)].node);
6838  (yyval.node) = NEW_OP_ASGN_AND(gettable(vid), (yyvsp[(1) - (5)].node));
6839  }
6840  else {
6841  (yyval.node) = (yyvsp[(1) - (5)].node);
6842  (yyval.node)->nd_value = NEW_CALL(gettable(vid), (yyvsp[(2) - (5)].id), NEW_LIST((yyvsp[(3) - (5)].node)));
6843  }
6844  }
6845  else {
6846  (yyval.node) = NEW_BEGIN(0);
6847  }
6848  /*%
6849  $3 = dispatch2(rescue_mod, $3, $5);
6850  $$ = dispatch3(opassign, $1, $2, $3);
6851  %*/
6852  }
6853  break;
6854 
6855  case 199:
6856 
6857 /* Line 1806 of yacc.c */
6858 #line 1985 "parse.y"
6859  {
6860  /*%%%*/
6861  NODE *args;
6862 
6863  value_expr((yyvsp[(6) - (6)].node));
6864  if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY();
6865  if (nd_type((yyvsp[(3) - (6)].node)) == NODE_BLOCK_PASS) {
6866  args = NEW_ARGSCAT((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
6867  }
6868  else {
6869  args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
6870  }
6871  if ((yyvsp[(5) - (6)].id) == tOROP) {
6872  (yyvsp[(5) - (6)].id) = 0;
6873  }
6874  else if ((yyvsp[(5) - (6)].id) == tANDOP) {
6875  (yyvsp[(5) - (6)].id) = 1;
6876  }
6877  (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args);
6878  fixpos((yyval.node), (yyvsp[(1) - (6)].node));
6879  /*%
6880  $1 = dispatch2(aref_field, $1, escape_Qundef($3));
6881  $$ = dispatch3(opassign, $1, $5, $6);
6882  %*/
6883  }
6884  break;
6885 
6886  case 200:
6887 
6888 /* Line 1806 of yacc.c */
6889 #line 2011 "parse.y"
6890  {
6891  /*%%%*/
6892  value_expr((yyvsp[(5) - (5)].node));
6893  if ((yyvsp[(4) - (5)].id) == tOROP) {
6894  (yyvsp[(4) - (5)].id) = 0;
6895  }
6896  else if ((yyvsp[(4) - (5)].id) == tANDOP) {
6897  (yyvsp[(4) - (5)].id) = 1;
6898  }
6899  (yyval.node) = NEW_OP_ASGN2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
6900  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
6901  /*%
6902  $1 = dispatch3(field, $1, ripper_id2sym('.'), $3);
6903  $$ = dispatch3(opassign, $1, $4, $5);
6904  %*/
6905  }
6906  break;
6907 
6908  case 201:
6909 
6910 /* Line 1806 of yacc.c */
6911 #line 2028 "parse.y"
6912  {
6913  /*%%%*/
6914  value_expr((yyvsp[(5) - (5)].node));
6915  if ((yyvsp[(4) - (5)].id) == tOROP) {
6916  (yyvsp[(4) - (5)].id) = 0;
6917  }
6918  else if ((yyvsp[(4) - (5)].id) == tANDOP) {
6919  (yyvsp[(4) - (5)].id) = 1;
6920  }
6921  (yyval.node) = NEW_OP_ASGN2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
6922  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
6923  /*%
6924  $1 = dispatch3(field, $1, ripper_id2sym('.'), $3);
6925  $$ = dispatch3(opassign, $1, $4, $5);
6926  %*/
6927  }
6928  break;
6929 
6930  case 202:
6931 
6932 /* Line 1806 of yacc.c */
6933 #line 2045 "parse.y"
6934  {
6935  /*%%%*/
6936  value_expr((yyvsp[(5) - (5)].node));
6937  if ((yyvsp[(4) - (5)].id) == tOROP) {
6938  (yyvsp[(4) - (5)].id) = 0;
6939  }
6940  else if ((yyvsp[(4) - (5)].id) == tANDOP) {
6941  (yyvsp[(4) - (5)].id) = 1;
6942  }
6943  (yyval.node) = NEW_OP_ASGN2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
6944  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
6945  /*%
6946  $1 = dispatch3(field, $1, ripper_intern("::"), $3);
6947  $$ = dispatch3(opassign, $1, $4, $5);
6948  %*/
6949  }
6950  break;
6951 
6952  case 203:
6953 
6954 /* Line 1806 of yacc.c */
6955 #line 2062 "parse.y"
6956  {
6957  /*%%%*/
6958  yyerror("constant re-assignment");
6959  (yyval.node) = NEW_BEGIN(0);
6960  /*%
6961  $$ = dispatch2(const_path_field, $1, $3);
6962  $$ = dispatch3(opassign, $$, $4, $5);
6963  $$ = dispatch1(assign_error, $$);
6964  %*/
6965  }
6966  break;
6967 
6968  case 204:
6969 
6970 /* Line 1806 of yacc.c */
6971 #line 2073 "parse.y"
6972  {
6973  /*%%%*/
6974  yyerror("constant re-assignment");
6975  (yyval.node) = NEW_BEGIN(0);
6976  /*%
6977  $$ = dispatch1(top_const_field, $2);
6978  $$ = dispatch3(opassign, $$, $3, $4);
6979  $$ = dispatch1(assign_error, $$);
6980  %*/
6981  }
6982  break;
6983 
6984  case 205:
6985 
6986 /* Line 1806 of yacc.c */
6987 #line 2084 "parse.y"
6988  {
6989  /*%%%*/
6990  rb_backref_error((yyvsp[(1) - (3)].node));
6991  (yyval.node) = NEW_BEGIN(0);
6992  /*%
6993  $$ = dispatch1(var_field, $1);
6994  $$ = dispatch3(opassign, $$, $2, $3);
6995  $$ = dispatch1(assign_error, $$);
6996  %*/
6997  }
6998  break;
6999 
7000  case 206:
7001 
7002 /* Line 1806 of yacc.c */
7003 #line 2095 "parse.y"
7004  {
7005  /*%%%*/
7006  value_expr((yyvsp[(1) - (3)].node));
7007  value_expr((yyvsp[(3) - (3)].node));
7008  (yyval.node) = NEW_DOT2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7009  if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) &&
7010  nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) {
7012  }
7013  /*%
7014  $$ = dispatch2(dot2, $1, $3);
7015  %*/
7016  }
7017  break;
7018 
7019  case 207:
7020 
7021 /* Line 1806 of yacc.c */
7022 #line 2109 "parse.y"
7023  {
7024  /*%%%*/
7025  value_expr((yyvsp[(1) - (3)].node));
7026  value_expr((yyvsp[(3) - (3)].node));
7027  (yyval.node) = NEW_DOT3((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7028  if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) &&
7029  nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) {
7031  }
7032  /*%
7033  $$ = dispatch2(dot3, $1, $3);
7034  %*/
7035  }
7036  break;
7037 
7038  case 208:
7039 
7040 /* Line 1806 of yacc.c */
7041 #line 2123 "parse.y"
7042  {
7043  /*%%%*/
7044  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '+', (yyvsp[(3) - (3)].node));
7045  /*%
7046  $$ = dispatch3(binary, $1, ID2SYM('+'), $3);
7047  %*/
7048  }
7049  break;
7050 
7051  case 209:
7052 
7053 /* Line 1806 of yacc.c */
7054 #line 2131 "parse.y"
7055  {
7056  /*%%%*/
7057  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '-', (yyvsp[(3) - (3)].node));
7058  /*%
7059  $$ = dispatch3(binary, $1, ID2SYM('-'), $3);
7060  %*/
7061  }
7062  break;
7063 
7064  case 210:
7065 
7066 /* Line 1806 of yacc.c */
7067 #line 2139 "parse.y"
7068  {
7069  /*%%%*/
7070  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '*', (yyvsp[(3) - (3)].node));
7071  /*%
7072  $$ = dispatch3(binary, $1, ID2SYM('*'), $3);
7073  %*/
7074  }
7075  break;
7076 
7077  case 211:
7078 
7079 /* Line 1806 of yacc.c */
7080 #line 2147 "parse.y"
7081  {
7082  /*%%%*/
7083  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '/', (yyvsp[(3) - (3)].node));
7084  /*%
7085  $$ = dispatch3(binary, $1, ID2SYM('/'), $3);
7086  %*/
7087  }
7088  break;
7089 
7090  case 212:
7091 
7092 /* Line 1806 of yacc.c */
7093 #line 2155 "parse.y"
7094  {
7095  /*%%%*/
7096  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '%', (yyvsp[(3) - (3)].node));
7097  /*%
7098  $$ = dispatch3(binary, $1, ID2SYM('%'), $3);
7099  %*/
7100  }
7101  break;
7102 
7103  case 213:
7104 
7105 /* Line 1806 of yacc.c */
7106 #line 2163 "parse.y"
7107  {
7108  /*%%%*/
7109  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tPOW, (yyvsp[(3) - (3)].node));
7110  /*%
7111  $$ = dispatch3(binary, $1, ripper_intern("**"), $3);
7112  %*/
7113  }
7114  break;
7115 
7116  case 214:
7117 
7118 /* Line 1806 of yacc.c */
7119 #line 2171 "parse.y"
7120  {
7121  /*%%%*/
7122  (yyval.node) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].node), tPOW, (yyvsp[(4) - (4)].node)), tUMINUS, 0);
7123  /*%
7124  $$ = dispatch3(binary, $2, ripper_intern("**"), $4);
7125  $$ = dispatch2(unary, ripper_intern("-@"), $$);
7126  %*/
7127  }
7128  break;
7129 
7130  case 215:
7131 
7132 /* Line 1806 of yacc.c */
7133 #line 2180 "parse.y"
7134  {
7135  /*%%%*/
7136  (yyval.node) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].node), tPOW, (yyvsp[(4) - (4)].node)), tUMINUS, 0);
7137  /*%
7138  $$ = dispatch3(binary, $2, ripper_intern("**"), $4);
7139  $$ = dispatch2(unary, ripper_intern("-@"), $$);
7140  %*/
7141  }
7142  break;
7143 
7144  case 216:
7145 
7146 /* Line 1806 of yacc.c */
7147 #line 2189 "parse.y"
7148  {
7149  /*%%%*/
7150  (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUPLUS);
7151  /*%
7152  $$ = dispatch2(unary, ripper_intern("+@"), $2);
7153  %*/
7154  }
7155  break;
7156 
7157  case 217:
7158 
7159 /* Line 1806 of yacc.c */
7160 #line 2197 "parse.y"
7161  {
7162  /*%%%*/
7163  (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUMINUS);
7164  /*%
7165  $$ = dispatch2(unary, ripper_intern("-@"), $2);
7166  %*/
7167  }
7168  break;
7169 
7170  case 218:
7171 
7172 /* Line 1806 of yacc.c */
7173 #line 2205 "parse.y"
7174  {
7175  /*%%%*/
7176  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '|', (yyvsp[(3) - (3)].node));
7177  /*%
7178  $$ = dispatch3(binary, $1, ID2SYM('|'), $3);
7179  %*/
7180  }
7181  break;
7182 
7183  case 219:
7184 
7185 /* Line 1806 of yacc.c */
7186 #line 2213 "parse.y"
7187  {
7188  /*%%%*/
7189  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '^', (yyvsp[(3) - (3)].node));
7190  /*%
7191  $$ = dispatch3(binary, $1, ID2SYM('^'), $3);
7192  %*/
7193  }
7194  break;
7195 
7196  case 220:
7197 
7198 /* Line 1806 of yacc.c */
7199 #line 2221 "parse.y"
7200  {
7201  /*%%%*/
7202  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '&', (yyvsp[(3) - (3)].node));
7203  /*%
7204  $$ = dispatch3(binary, $1, ID2SYM('&'), $3);
7205  %*/
7206  }
7207  break;
7208 
7209  case 221:
7210 
7211 /* Line 1806 of yacc.c */
7212 #line 2229 "parse.y"
7213  {
7214  /*%%%*/
7215  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tCMP, (yyvsp[(3) - (3)].node));
7216  /*%
7217  $$ = dispatch3(binary, $1, ripper_intern("<=>"), $3);
7218  %*/
7219  }
7220  break;
7221 
7222  case 222:
7223 
7224 /* Line 1806 of yacc.c */
7225 #line 2237 "parse.y"
7226  {
7227  /*%%%*/
7228  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '>', (yyvsp[(3) - (3)].node));
7229  /*%
7230  $$ = dispatch3(binary, $1, ID2SYM('>'), $3);
7231  %*/
7232  }
7233  break;
7234 
7235  case 223:
7236 
7237 /* Line 1806 of yacc.c */
7238 #line 2245 "parse.y"
7239  {
7240  /*%%%*/
7241  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tGEQ, (yyvsp[(3) - (3)].node));
7242  /*%
7243  $$ = dispatch3(binary, $1, ripper_intern(">="), $3);
7244  %*/
7245  }
7246  break;
7247 
7248  case 224:
7249 
7250 /* Line 1806 of yacc.c */
7251 #line 2253 "parse.y"
7252  {
7253  /*%%%*/
7254  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '<', (yyvsp[(3) - (3)].node));
7255  /*%
7256  $$ = dispatch3(binary, $1, ID2SYM('<'), $3);
7257  %*/
7258  }
7259  break;
7260 
7261  case 225:
7262 
7263 /* Line 1806 of yacc.c */
7264 #line 2261 "parse.y"
7265  {
7266  /*%%%*/
7267  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLEQ, (yyvsp[(3) - (3)].node));
7268  /*%
7269  $$ = dispatch3(binary, $1, ripper_intern("<="), $3);
7270  %*/
7271  }
7272  break;
7273 
7274  case 226:
7275 
7276 /* Line 1806 of yacc.c */
7277 #line 2269 "parse.y"
7278  {
7279  /*%%%*/
7280  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQ, (yyvsp[(3) - (3)].node));
7281  /*%
7282  $$ = dispatch3(binary, $1, ripper_intern("=="), $3);
7283  %*/
7284  }
7285  break;
7286 
7287  case 227:
7288 
7289 /* Line 1806 of yacc.c */
7290 #line 2277 "parse.y"
7291  {
7292  /*%%%*/
7293  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQQ, (yyvsp[(3) - (3)].node));
7294  /*%
7295  $$ = dispatch3(binary, $1, ripper_intern("==="), $3);
7296  %*/
7297  }
7298  break;
7299 
7300  case 228:
7301 
7302 /* Line 1806 of yacc.c */
7303 #line 2285 "parse.y"
7304  {
7305  /*%%%*/
7306  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNEQ, (yyvsp[(3) - (3)].node));
7307  /*%
7308  $$ = dispatch3(binary, $1, ripper_intern("!="), $3);
7309  %*/
7310  }
7311  break;
7312 
7313  case 229:
7314 
7315 /* Line 1806 of yacc.c */
7316 #line 2293 "parse.y"
7317  {
7318  /*%%%*/
7319  (yyval.node) = match_op((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7320  if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && TYPE((yyvsp[(1) - (3)].node)->nd_lit) == T_REGEXP) {
7321  (yyval.node) = reg_named_capture_assign((yyvsp[(1) - (3)].node)->nd_lit, (yyval.node));
7322  }
7323  /*%
7324  $$ = dispatch3(binary, $1, ripper_intern("=~"), $3);
7325  %*/
7326  }
7327  break;
7328 
7329  case 230:
7330 
7331 /* Line 1806 of yacc.c */
7332 #line 2304 "parse.y"
7333  {
7334  /*%%%*/
7335  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNMATCH, (yyvsp[(3) - (3)].node));
7336  /*%
7337  $$ = dispatch3(binary, $1, ripper_intern("!~"), $3);
7338  %*/
7339  }
7340  break;
7341 
7342  case 231:
7343 
7344 /* Line 1806 of yacc.c */
7345 #line 2312 "parse.y"
7346  {
7347  /*%%%*/
7348  (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!');
7349  /*%
7350  $$ = dispatch2(unary, ID2SYM('!'), $2);
7351  %*/
7352  }
7353  break;
7354 
7355  case 232:
7356 
7357 /* Line 1806 of yacc.c */
7358 #line 2320 "parse.y"
7359  {
7360  /*%%%*/
7361  (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), '~');
7362  /*%
7363  $$ = dispatch2(unary, ID2SYM('~'), $2);
7364  %*/
7365  }
7366  break;
7367 
7368  case 233:
7369 
7370 /* Line 1806 of yacc.c */
7371 #line 2328 "parse.y"
7372  {
7373  /*%%%*/
7374  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLSHFT, (yyvsp[(3) - (3)].node));
7375  /*%
7376  $$ = dispatch3(binary, $1, ripper_intern("<<"), $3);
7377  %*/
7378  }
7379  break;
7380 
7381  case 234:
7382 
7383 /* Line 1806 of yacc.c */
7384 #line 2336 "parse.y"
7385  {
7386  /*%%%*/
7387  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tRSHFT, (yyvsp[(3) - (3)].node));
7388  /*%
7389  $$ = dispatch3(binary, $1, ripper_intern(">>"), $3);
7390  %*/
7391  }
7392  break;
7393 
7394  case 235:
7395 
7396 /* Line 1806 of yacc.c */
7397 #line 2344 "parse.y"
7398  {
7399  /*%%%*/
7400  (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7401  /*%
7402  $$ = dispatch3(binary, $1, ripper_intern("&&"), $3);
7403  %*/
7404  }
7405  break;
7406 
7407  case 236:
7408 
7409 /* Line 1806 of yacc.c */
7410 #line 2352 "parse.y"
7411  {
7412  /*%%%*/
7413  (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7414  /*%
7415  $$ = dispatch3(binary, $1, ripper_intern("||"), $3);
7416  %*/
7417  }
7418  break;
7419 
7420  case 237:
7421 
7422 /* Line 1806 of yacc.c */
7423 #line 2359 "parse.y"
7424  {in_defined = 1;}
7425  break;
7426 
7427  case 238:
7428 
7429 /* Line 1806 of yacc.c */
7430 #line 2360 "parse.y"
7431  {
7432  /*%%%*/
7433  in_defined = 0;
7434  (yyval.node) = NEW_DEFINED((yyvsp[(4) - (4)].node));
7435  /*%
7436  in_defined = 0;
7437  $$ = dispatch1(defined, $4);
7438  %*/
7439  }
7440  break;
7441 
7442  case 239:
7443 
7444 /* Line 1806 of yacc.c */
7445 #line 2370 "parse.y"
7446  {
7447  /*%%%*/
7448  value_expr((yyvsp[(1) - (6)].node));
7449  (yyval.node) = NEW_IF(cond((yyvsp[(1) - (6)].node)), (yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
7450  fixpos((yyval.node), (yyvsp[(1) - (6)].node));
7451  /*%
7452  $$ = dispatch3(ifop, $1, $3, $6);
7453  %*/
7454  }
7455  break;
7456 
7457  case 240:
7458 
7459 /* Line 1806 of yacc.c */
7460 #line 2380 "parse.y"
7461  {
7462  (yyval.node) = (yyvsp[(1) - (1)].node);
7463  }
7464  break;
7465 
7466  case 241:
7467 
7468 /* Line 1806 of yacc.c */
7469 #line 2386 "parse.y"
7470  {
7471  /*%%%*/
7472  value_expr((yyvsp[(1) - (1)].node));
7473  (yyval.node) = (yyvsp[(1) - (1)].node);
7474  if (!(yyval.node)) (yyval.node) = NEW_NIL();
7475  /*%
7476  $$ = $1;
7477  %*/
7478  }
7479  break;
7480 
7481  case 243:
7482 
7483 /* Line 1806 of yacc.c */
7484 #line 2399 "parse.y"
7485  {
7486  (yyval.node) = (yyvsp[(1) - (2)].node);
7487  }
7488  break;
7489 
7490  case 244:
7491 
7492 /* Line 1806 of yacc.c */
7493 #line 2403 "parse.y"
7494  {
7495  /*%%%*/
7496  (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
7497  /*%
7498  $$ = arg_add_assocs($1, $3);
7499  %*/
7500  }
7501  break;
7502 
7503  case 245:
7504 
7505 /* Line 1806 of yacc.c */
7506 #line 2411 "parse.y"
7507  {
7508  /*%%%*/
7509  (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
7510  /*%
7511  $$ = arg_add_assocs(arg_new(), $1);
7512  %*/
7513  }
7514  break;
7515 
7516  case 246:
7517 
7518 /* Line 1806 of yacc.c */
7519 #line 2421 "parse.y"
7520  {
7521  /*%%%*/
7522  (yyval.node) = (yyvsp[(2) - (3)].node);
7523  /*%
7524  $$ = dispatch1(arg_paren, escape_Qundef($2));
7525  %*/
7526  }
7527  break;
7528 
7529  case 251:
7530 
7531 /* Line 1806 of yacc.c */
7532 #line 2437 "parse.y"
7533  {
7534  (yyval.node) = (yyvsp[(1) - (2)].node);
7535  }
7536  break;
7537 
7538  case 252:
7539 
7540 /* Line 1806 of yacc.c */
7541 #line 2441 "parse.y"
7542  {
7543  /*%%%*/
7544  (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
7545  /*%
7546  $$ = arg_add_assocs($1, $3);
7547  %*/
7548  }
7549  break;
7550 
7551  case 253:
7552 
7553 /* Line 1806 of yacc.c */
7554 #line 2449 "parse.y"
7555  {
7556  /*%%%*/
7557  (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
7558  /*%
7559  $$ = arg_add_assocs(arg_new(), $1);
7560  %*/
7561  }
7562  break;
7563 
7564  case 254:
7565 
7566 /* Line 1806 of yacc.c */
7567 #line 2459 "parse.y"
7568  {
7569  /*%%%*/
7570  value_expr((yyvsp[(1) - (1)].node));
7571  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
7572  /*%
7573  $$ = arg_add(arg_new(), $1);
7574  %*/
7575  }
7576  break;
7577 
7578  case 255:
7579 
7580 /* Line 1806 of yacc.c */
7581 #line 2468 "parse.y"
7582  {
7583  /*%%%*/
7584  (yyval.node) = arg_blk_pass((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
7585  /*%
7586  $$ = arg_add_optblock($1, $2);
7587  %*/
7588  }
7589  break;
7590 
7591  case 256:
7592 
7593 /* Line 1806 of yacc.c */
7594 #line 2476 "parse.y"
7595  {
7596  /*%%%*/
7597  (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
7598  (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(2) - (2)].node));
7599  /*%
7600  $$ = arg_add_assocs(arg_new(), $1);
7601  $$ = arg_add_optblock($$, $2);
7602  %*/
7603  }
7604  break;
7605 
7606  case 257:
7607 
7608 /* Line 1806 of yacc.c */
7609 #line 2486 "parse.y"
7610  {
7611  /*%%%*/
7612  (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
7613  (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(4) - (4)].node));
7614  /*%
7615  $$ = arg_add_optblock(arg_add_assocs($1, $3), $4);
7616  %*/
7617  }
7618  break;
7619 
7620  case 259:
7621 
7622 /* Line 1806 of yacc.c */
7623 #line 2503 "parse.y"
7624  {
7625  (yyval.val) = cmdarg_stack;
7626  CMDARG_PUSH(1);
7627  }
7628  break;
7629 
7630  case 260:
7631 
7632 /* Line 1806 of yacc.c */
7633 #line 2508 "parse.y"
7634  {
7635  /* CMDARG_POP() */
7636  cmdarg_stack = (yyvsp[(1) - (2)].val);
7637  (yyval.node) = (yyvsp[(2) - (2)].node);
7638  }
7639  break;
7640 
7641  case 261:
7642 
7643 /* Line 1806 of yacc.c */
7644 #line 2516 "parse.y"
7645  {
7646  /*%%%*/
7647  (yyval.node) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].node));
7648  /*%
7649  $$ = $2;
7650  %*/
7651  }
7652  break;
7653 
7654  case 262:
7655 
7656 /* Line 1806 of yacc.c */
7657 #line 2526 "parse.y"
7658  {
7659  (yyval.node) = (yyvsp[(2) - (2)].node);
7660  }
7661  break;
7662 
7663  case 263:
7664 
7665 /* Line 1806 of yacc.c */
7666 #line 2530 "parse.y"
7667  {
7668  (yyval.node) = 0;
7669  }
7670  break;
7671 
7672  case 264:
7673 
7674 /* Line 1806 of yacc.c */
7675 #line 2536 "parse.y"
7676  {
7677  /*%%%*/
7678  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
7679  /*%
7680  $$ = arg_add(arg_new(), $1);
7681  %*/
7682  }
7683  break;
7684 
7685  case 265:
7686 
7687 /* Line 1806 of yacc.c */
7688 #line 2544 "parse.y"
7689  {
7690  /*%%%*/
7691  (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node));
7692  /*%
7693  $$ = arg_add_star(arg_new(), $2);
7694  %*/
7695  }
7696  break;
7697 
7698  case 266:
7699 
7700 /* Line 1806 of yacc.c */
7701 #line 2552 "parse.y"
7702  {
7703  /*%%%*/
7704  NODE *n1;
7705  if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) {
7706  (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node));
7707  }
7708  else {
7709  (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7710  }
7711  /*%
7712  $$ = arg_add($1, $3);
7713  %*/
7714  }
7715  break;
7716 
7717  case 267:
7718 
7719 /* Line 1806 of yacc.c */
7720 #line 2566 "parse.y"
7721  {
7722  /*%%%*/
7723  NODE *n1;
7724  if ((nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) {
7725  (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node));
7726  }
7727  else {
7728  (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
7729  }
7730  /*%
7731  $$ = arg_add_star($1, $4);
7732  %*/
7733  }
7734  break;
7735 
7736  case 268:
7737 
7738 /* Line 1806 of yacc.c */
7739 #line 2582 "parse.y"
7740  {
7741  /*%%%*/
7742  NODE *n1;
7743  if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) {
7744  (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node));
7745  }
7746  else {
7747  (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7748  }
7749  /*%
7750  $$ = mrhs_add(args2mrhs($1), $3);
7751  %*/
7752  }
7753  break;
7754 
7755  case 269:
7756 
7757 /* Line 1806 of yacc.c */
7758 #line 2596 "parse.y"
7759  {
7760  /*%%%*/
7761  NODE *n1;
7762  if (nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY &&
7763  (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) {
7764  (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node));
7765  }
7766  else {
7767  (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
7768  }
7769  /*%
7770  $$ = mrhs_add_star(args2mrhs($1), $4);
7771  %*/
7772  }
7773  break;
7774 
7775  case 270:
7776 
7777 /* Line 1806 of yacc.c */
7778 #line 2611 "parse.y"
7779  {
7780  /*%%%*/
7781  (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node));
7782  /*%
7783  $$ = mrhs_add_star(mrhs_new(), $2);
7784  %*/
7785  }
7786  break;
7787 
7788  case 279:
7789 
7790 /* Line 1806 of yacc.c */
7791 #line 2629 "parse.y"
7792  {
7793  /*%%%*/
7794  (yyval.node) = NEW_FCALL((yyvsp[(1) - (1)].id), 0);
7795  /*%
7796  $$ = method_arg(dispatch1(fcall, $1), arg_new());
7797  %*/
7798  }
7799  break;
7800 
7801  case 280:
7802 
7803 /* Line 1806 of yacc.c */
7804 #line 2637 "parse.y"
7805  {
7806  /*%%%*/
7807  (yyval.num) = ruby_sourceline;
7808  /*%
7809  %*/
7810  }
7811  break;
7812 
7813  case 281:
7814 
7815 /* Line 1806 of yacc.c */
7816 #line 2645 "parse.y"
7817  {
7818  /*%%%*/
7819  if ((yyvsp[(3) - (4)].node) == NULL) {
7820  (yyval.node) = NEW_NIL();
7821  }
7822  else {
7823  if (nd_type((yyvsp[(3) - (4)].node)) == NODE_RESCUE ||
7824  nd_type((yyvsp[(3) - (4)].node)) == NODE_ENSURE)
7825  nd_set_line((yyvsp[(3) - (4)].node), (yyvsp[(2) - (4)].num));
7826  (yyval.node) = NEW_BEGIN((yyvsp[(3) - (4)].node));
7827  }
7828  nd_set_line((yyval.node), (yyvsp[(2) - (4)].num));
7829  /*%
7830  $$ = dispatch1(begin, $3);
7831  %*/
7832  }
7833  break;
7834 
7835  case 282:
7836 
7837 /* Line 1806 of yacc.c */
7838 #line 2661 "parse.y"
7839  {lex_state = EXPR_ENDARG;}
7840  break;
7841 
7842  case 283:
7843 
7844 /* Line 1806 of yacc.c */
7845 #line 2662 "parse.y"
7846  {
7847  rb_warning0("(...) interpreted as grouped expression");
7848  /*%%%*/
7849  (yyval.node) = (yyvsp[(2) - (4)].node);
7850  /*%
7851  $$ = dispatch1(paren, $2);
7852  %*/
7853  }
7854  break;
7855 
7856  case 284:
7857 
7858 /* Line 1806 of yacc.c */
7859 #line 2671 "parse.y"
7860  {
7861  /*%%%*/
7862  (yyval.node) = (yyvsp[(2) - (3)].node);
7863  /*%
7864  $$ = dispatch1(paren, $2);
7865  %*/
7866  }
7867  break;
7868 
7869  case 285:
7870 
7871 /* Line 1806 of yacc.c */
7872 #line 2679 "parse.y"
7873  {
7874  /*%%%*/
7875  (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
7876  /*%
7877  $$ = dispatch2(const_path_ref, $1, $3);
7878  %*/
7879  }
7880  break;
7881 
7882  case 286:
7883 
7884 /* Line 1806 of yacc.c */
7885 #line 2687 "parse.y"
7886  {
7887  /*%%%*/
7888  (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id));
7889  /*%
7890  $$ = dispatch1(top_const_ref, $2);
7891  %*/
7892  }
7893  break;
7894 
7895  case 287:
7896 
7897 /* Line 1806 of yacc.c */
7898 #line 2695 "parse.y"
7899  {
7900  /*%%%*/
7901  if ((yyvsp[(2) - (3)].node) == 0) {
7902  (yyval.node) = NEW_ZARRAY(); /* zero length array*/
7903  }
7904  else {
7905  (yyval.node) = (yyvsp[(2) - (3)].node);
7906  }
7907  /*%
7908  $$ = dispatch1(array, escape_Qundef($2));
7909  %*/
7910  }
7911  break;
7912 
7913  case 288:
7914 
7915 /* Line 1806 of yacc.c */
7916 #line 2708 "parse.y"
7917  {
7918  /*%%%*/
7919  (yyval.node) = NEW_HASH((yyvsp[(2) - (3)].node));
7920  /*%
7921  $$ = dispatch1(hash, escape_Qundef($2));
7922  %*/
7923  }
7924  break;
7925 
7926  case 289:
7927 
7928 /* Line 1806 of yacc.c */
7929 #line 2716 "parse.y"
7930  {
7931  /*%%%*/
7932  (yyval.node) = NEW_RETURN(0);
7933  /*%
7934  $$ = dispatch0(return0);
7935  %*/
7936  }
7937  break;
7938 
7939  case 290:
7940 
7941 /* Line 1806 of yacc.c */
7942 #line 2724 "parse.y"
7943  {
7944  /*%%%*/
7945  (yyval.node) = new_yield((yyvsp[(3) - (4)].node));
7946  /*%
7947  $$ = dispatch1(yield, dispatch1(paren, $3));
7948  %*/
7949  }
7950  break;
7951 
7952  case 291:
7953 
7954 /* Line 1806 of yacc.c */
7955 #line 2732 "parse.y"
7956  {
7957  /*%%%*/
7958  (yyval.node) = NEW_YIELD(0, Qfalse);
7959  /*%
7960  $$ = dispatch1(yield, dispatch1(paren, arg_new()));
7961  %*/
7962  }
7963  break;
7964 
7965  case 292:
7966 
7967 /* Line 1806 of yacc.c */
7968 #line 2740 "parse.y"
7969  {
7970  /*%%%*/
7971  (yyval.node) = NEW_YIELD(0, Qfalse);
7972  /*%
7973  $$ = dispatch0(yield0);
7974  %*/
7975  }
7976  break;
7977 
7978  case 293:
7979 
7980 /* Line 1806 of yacc.c */
7981 #line 2747 "parse.y"
7982  {in_defined = 1;}
7983  break;
7984 
7985  case 294:
7986 
7987 /* Line 1806 of yacc.c */
7988 #line 2748 "parse.y"
7989  {
7990  /*%%%*/
7991  in_defined = 0;
7992  (yyval.node) = NEW_DEFINED((yyvsp[(5) - (6)].node));
7993  /*%
7994  in_defined = 0;
7995  $$ = dispatch1(defined, $5);
7996  %*/
7997  }
7998  break;
7999 
8000  case 295:
8001 
8002 /* Line 1806 of yacc.c */
8003 #line 2758 "parse.y"
8004  {
8005  /*%%%*/
8006  (yyval.node) = call_uni_op(cond((yyvsp[(3) - (4)].node)), '!');
8007  /*%
8008  $$ = dispatch2(unary, ripper_intern("not"), $3);
8009  %*/
8010  }
8011  break;
8012 
8013  case 296:
8014 
8015 /* Line 1806 of yacc.c */
8016 #line 2766 "parse.y"
8017  {
8018  /*%%%*/
8019  (yyval.node) = call_uni_op(cond(NEW_NIL()), '!');
8020  /*%
8021  $$ = dispatch2(unary, ripper_intern("not"), Qnil);
8022  %*/
8023  }
8024  break;
8025 
8026  case 297:
8027 
8028 /* Line 1806 of yacc.c */
8029 #line 2774 "parse.y"
8030  {
8031  /*%%%*/
8032  (yyvsp[(2) - (2)].node)->nd_iter = NEW_FCALL((yyvsp[(1) - (2)].id), 0);
8033  (yyval.node) = (yyvsp[(2) - (2)].node);
8034  fixpos((yyvsp[(2) - (2)].node)->nd_iter, (yyvsp[(2) - (2)].node));
8035  /*%
8036  $$ = method_arg(dispatch1(fcall, $1), arg_new());
8037  $$ = method_add_block($$, $2);
8038  %*/
8039  }
8040  break;
8041 
8042  case 299:
8043 
8044 /* Line 1806 of yacc.c */
8045 #line 2786 "parse.y"
8046  {
8047  /*%%%*/
8048  block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node));
8049  (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
8050  (yyval.node) = (yyvsp[(2) - (2)].node);
8051  fixpos((yyval.node), (yyvsp[(1) - (2)].node));
8052  /*%
8053  $$ = method_add_block($1, $2);
8054  %*/
8055  }
8056  break;
8057 
8058  case 300:
8059 
8060 /* Line 1806 of yacc.c */
8061 #line 2797 "parse.y"
8062  {
8063  (yyval.node) = (yyvsp[(2) - (2)].node);
8064  }
8065  break;
8066 
8067  case 301:
8068 
8069 /* Line 1806 of yacc.c */
8070 #line 2804 "parse.y"
8071  {
8072  /*%%%*/
8073  (yyval.node) = NEW_IF(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node));
8074  fixpos((yyval.node), (yyvsp[(2) - (6)].node));
8075  /*%
8076  $$ = dispatch3(if, $2, $4, escape_Qundef($5));
8077  %*/
8078  }
8079  break;
8080 
8081  case 302:
8082 
8083 /* Line 1806 of yacc.c */
8084 #line 2816 "parse.y"
8085  {
8086  /*%%%*/
8087  (yyval.node) = NEW_UNLESS(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node));
8088  fixpos((yyval.node), (yyvsp[(2) - (6)].node));
8089  /*%
8090  $$ = dispatch3(unless, $2, $4, escape_Qundef($5));
8091  %*/
8092  }
8093  break;
8094 
8095  case 303:
8096 
8097 /* Line 1806 of yacc.c */
8098 #line 2824 "parse.y"
8099  {COND_PUSH(1);}
8100  break;
8101 
8102  case 304:
8103 
8104 /* Line 1806 of yacc.c */
8105 #line 2824 "parse.y"
8106  {COND_POP();}
8107  break;
8108 
8109  case 305:
8110 
8111 /* Line 1806 of yacc.c */
8112 #line 2827 "parse.y"
8113  {
8114  /*%%%*/
8115  (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1);
8116  fixpos((yyval.node), (yyvsp[(3) - (7)].node));
8117  /*%
8118  $$ = dispatch2(while, $3, $6);
8119  %*/
8120  }
8121  break;
8122 
8123  case 306:
8124 
8125 /* Line 1806 of yacc.c */
8126 #line 2835 "parse.y"
8127  {COND_PUSH(1);}
8128  break;
8129 
8130  case 307:
8131 
8132 /* Line 1806 of yacc.c */
8133 #line 2835 "parse.y"
8134  {COND_POP();}
8135  break;
8136 
8137  case 308:
8138 
8139 /* Line 1806 of yacc.c */
8140 #line 2838 "parse.y"
8141  {
8142  /*%%%*/
8143  (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1);
8144  fixpos((yyval.node), (yyvsp[(3) - (7)].node));
8145  /*%
8146  $$ = dispatch2(until, $3, $6);
8147  %*/
8148  }
8149  break;
8150 
8151  case 309:
8152 
8153 /* Line 1806 of yacc.c */
8154 #line 2849 "parse.y"
8155  {
8156  /*%%%*/
8157  (yyval.node) = NEW_CASE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node));
8158  fixpos((yyval.node), (yyvsp[(2) - (5)].node));
8159  /*%
8160  $$ = dispatch2(case, $2, $4);
8161  %*/
8162  }
8163  break;
8164 
8165  case 310:
8166 
8167 /* Line 1806 of yacc.c */
8168 #line 2858 "parse.y"
8169  {
8170  /*%%%*/
8171  (yyval.node) = NEW_CASE(0, (yyvsp[(3) - (4)].node));
8172  /*%
8173  $$ = dispatch2(case, Qnil, $3);
8174  %*/
8175  }
8176  break;
8177 
8178  case 311:
8179 
8180 /* Line 1806 of yacc.c */
8181 #line 2866 "parse.y"
8182  {COND_PUSH(1);}
8183  break;
8184 
8185  case 312:
8186 
8187 /* Line 1806 of yacc.c */
8188 #line 2868 "parse.y"
8189  {COND_POP();}
8190  break;
8191 
8192  case 313:
8193 
8194 /* Line 1806 of yacc.c */
8195 #line 2871 "parse.y"
8196  {
8197  /*%%%*/
8198  /*
8199  * for a, b, c in e
8200  * #=>
8201  * e.each{|*x| a, b, c = x
8202  *
8203  * for a in e
8204  * #=>
8205  * e.each{|x| a, = x}
8206  */
8207  ID id = internal_id();
8208  ID *tbl = ALLOC_N(ID, 2);
8209  NODE *m = NEW_ARGS_AUX(0, 0);
8210  NODE *args, *scope;
8211 
8212  if (nd_type((yyvsp[(2) - (9)].node)) == NODE_MASGN) {
8213  /* if args.length == 1 && args[0].kind_of?(Array)
8214  * args = args[0]
8215  * end
8216  */
8217  NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
8218  NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
8219  m->nd_next = block_append(
8220  NEW_IF(
8222  NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("length"), 0),
8223  rb_intern("=="), one),
8224  NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero),
8225  rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
8226  0),
8227  NEW_DASGN_CURR(id,
8228  NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero)),
8229  0),
8230  node_assign((yyvsp[(2) - (9)].node), NEW_DVAR(id)));
8231 
8232  args = new_args(m, 0, id, 0, 0);
8233  }
8234  else {
8235  if (nd_type((yyvsp[(2) - (9)].node)) == NODE_LASGN ||
8236  nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN ||
8237  nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN_CURR) {
8238  (yyvsp[(2) - (9)].node)->nd_value = NEW_DVAR(id);
8239  m->nd_plen = 1;
8240  m->nd_next = (yyvsp[(2) - (9)].node);
8241  args = new_args(m, 0, 0, 0, 0);
8242  }
8243  else {
8244  m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].node)), 0), NEW_DVAR(id));
8245  args = new_args(m, 0, id, 0, 0);
8246  }
8247  }
8248  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].node), args);
8249  tbl[0] = 1; tbl[1] = id;
8250  (yyval.node) = NEW_FOR(0, (yyvsp[(5) - (9)].node), scope);
8251  fixpos((yyval.node), (yyvsp[(2) - (9)].node));
8252  /*%
8253  $$ = dispatch3(for, $2, $5, $8);
8254  %*/
8255  }
8256  break;
8257 
8258  case 314:
8259 
8260 /* Line 1806 of yacc.c */
8261 #line 2932 "parse.y"
8262  {
8263  if (in_def || in_single)
8264  yyerror("class definition in method body");
8265  local_push(0);
8266  /*%%%*/
8267  (yyval.num) = ruby_sourceline;
8268  /*%
8269  %*/
8270  }
8271  break;
8272 
8273  case 315:
8274 
8275 /* Line 1806 of yacc.c */
8276 #line 2943 "parse.y"
8277  {
8278  /*%%%*/
8279  (yyval.node) = NEW_CLASS((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(3) - (6)].node));
8280  nd_set_line((yyval.node), (yyvsp[(4) - (6)].num));
8281  /*%
8282  $$ = dispatch3(class, $2, $3, $5);
8283  %*/
8284  local_pop();
8285  }
8286  break;
8287 
8288  case 316:
8289 
8290 /* Line 1806 of yacc.c */
8291 #line 2953 "parse.y"
8292  {
8293  (yyval.num) = in_def;
8294  in_def = 0;
8295  }
8296  break;
8297 
8298  case 317:
8299 
8300 /* Line 1806 of yacc.c */
8301 #line 2958 "parse.y"
8302  {
8303  (yyval.num) = in_single;
8304  in_single = 0;
8305  local_push(0);
8306  }
8307  break;
8308 
8309  case 318:
8310 
8311 /* Line 1806 of yacc.c */
8312 #line 2965 "parse.y"
8313  {
8314  /*%%%*/
8315  (yyval.node) = NEW_SCLASS((yyvsp[(3) - (8)].node), (yyvsp[(7) - (8)].node));
8316  fixpos((yyval.node), (yyvsp[(3) - (8)].node));
8317  /*%
8318  $$ = dispatch2(sclass, $3, $7);
8319  %*/
8320  local_pop();
8321  in_def = (yyvsp[(4) - (8)].num);
8322  in_single = (yyvsp[(6) - (8)].num);
8323  }
8324  break;
8325 
8326  case 319:
8327 
8328 /* Line 1806 of yacc.c */
8329 #line 2977 "parse.y"
8330  {
8331  if (in_def || in_single)
8332  yyerror("module definition in method body");
8333  local_push(0);
8334  /*%%%*/
8335  (yyval.num) = ruby_sourceline;
8336  /*%
8337  %*/
8338  }
8339  break;
8340 
8341  case 320:
8342 
8343 /* Line 1806 of yacc.c */
8344 #line 2988 "parse.y"
8345  {
8346  /*%%%*/
8347  (yyval.node) = NEW_MODULE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node));
8348  nd_set_line((yyval.node), (yyvsp[(3) - (5)].num));
8349  /*%
8350  $$ = dispatch2(module, $2, $4);
8351  %*/
8352  local_pop();
8353  }
8354  break;
8355 
8356  case 321:
8357 
8358 /* Line 1806 of yacc.c */
8359 #line 2998 "parse.y"
8360  {
8361  (yyval.id) = cur_mid;
8362  cur_mid = (yyvsp[(2) - (2)].id);
8363  in_def++;
8364  local_push(0);
8365  }
8366  break;
8367 
8368  case 322:
8369 
8370 /* Line 1806 of yacc.c */
8371 #line 3007 "parse.y"
8372  {
8373  /*%%%*/
8374  NODE *body = remove_begin((yyvsp[(5) - (6)].node));
8375  reduce_nodes(&body);
8376  (yyval.node) = NEW_DEFN((yyvsp[(2) - (6)].id), (yyvsp[(4) - (6)].node), body, NOEX_PRIVATE);
8377  nd_set_line((yyval.node), (yyvsp[(1) - (6)].num));
8378  /*%
8379  $$ = dispatch3(def, $2, $4, $5);
8380  %*/
8381  local_pop();
8382  in_def--;
8383  cur_mid = (yyvsp[(3) - (6)].id);
8384  }
8385  break;
8386 
8387  case 323:
8388 
8389 /* Line 1806 of yacc.c */
8390 #line 3020 "parse.y"
8391  {lex_state = EXPR_FNAME;}
8392  break;
8393 
8394  case 324:
8395 
8396 /* Line 1806 of yacc.c */
8397 #line 3021 "parse.y"
8398  {
8399  in_single++;
8400  lex_state = EXPR_ENDFN; /* force for args */
8401  local_push(0);
8402  }
8403  break;
8404 
8405  case 325:
8406 
8407 /* Line 1806 of yacc.c */
8408 #line 3029 "parse.y"
8409  {
8410  /*%%%*/
8411  NODE *body = remove_begin((yyvsp[(8) - (9)].node));
8412  reduce_nodes(&body);
8413  (yyval.node) = NEW_DEFS((yyvsp[(2) - (9)].node), (yyvsp[(5) - (9)].id), (yyvsp[(7) - (9)].node), body);
8414  nd_set_line((yyval.node), (yyvsp[(1) - (9)].num));
8415  /*%
8416  $$ = dispatch5(defs, $2, $3, $5, $7, $8);
8417  %*/
8418  local_pop();
8419  in_single--;
8420  }
8421  break;
8422 
8423  case 326:
8424 
8425 /* Line 1806 of yacc.c */
8426 #line 3042 "parse.y"
8427  {
8428  /*%%%*/
8429  (yyval.node) = NEW_BREAK(0);
8430  /*%
8431  $$ = dispatch1(break, arg_new());
8432  %*/
8433  }
8434  break;
8435 
8436  case 327:
8437 
8438 /* Line 1806 of yacc.c */
8439 #line 3050 "parse.y"
8440  {
8441  /*%%%*/
8442  (yyval.node) = NEW_NEXT(0);
8443  /*%
8444  $$ = dispatch1(next, arg_new());
8445  %*/
8446  }
8447  break;
8448 
8449  case 328:
8450 
8451 /* Line 1806 of yacc.c */
8452 #line 3058 "parse.y"
8453  {
8454  /*%%%*/
8455  (yyval.node) = NEW_REDO();
8456  /*%
8457  $$ = dispatch0(redo);
8458  %*/
8459  }
8460  break;
8461 
8462  case 329:
8463 
8464 /* Line 1806 of yacc.c */
8465 #line 3066 "parse.y"
8466  {
8467  /*%%%*/
8468  (yyval.node) = NEW_RETRY();
8469  /*%
8470  $$ = dispatch0(retry);
8471  %*/
8472  }
8473  break;
8474 
8475  case 330:
8476 
8477 /* Line 1806 of yacc.c */
8478 #line 3076 "parse.y"
8479  {
8480  /*%%%*/
8481  value_expr((yyvsp[(1) - (1)].node));
8482  (yyval.node) = (yyvsp[(1) - (1)].node);
8483  if (!(yyval.node)) (yyval.node) = NEW_NIL();
8484  /*%
8485  $$ = $1;
8486  %*/
8487  }
8488  break;
8489 
8490  case 331:
8491 
8492 /* Line 1806 of yacc.c */
8493 #line 3088 "parse.y"
8494  {
8495  token_info_push("begin");
8496  }
8497  break;
8498 
8499  case 332:
8500 
8501 /* Line 1806 of yacc.c */
8502 #line 3094 "parse.y"
8503  {
8504  token_info_push("if");
8505  }
8506  break;
8507 
8508  case 333:
8509 
8510 /* Line 1806 of yacc.c */
8511 #line 3100 "parse.y"
8512  {
8513  token_info_push("unless");
8514  }
8515  break;
8516 
8517  case 334:
8518 
8519 /* Line 1806 of yacc.c */
8520 #line 3106 "parse.y"
8521  {
8522  token_info_push("while");
8523  }
8524  break;
8525 
8526  case 335:
8527 
8528 /* Line 1806 of yacc.c */
8529 #line 3112 "parse.y"
8530  {
8531  token_info_push("until");
8532  }
8533  break;
8534 
8535  case 336:
8536 
8537 /* Line 1806 of yacc.c */
8538 #line 3118 "parse.y"
8539  {
8540  token_info_push("case");
8541  }
8542  break;
8543 
8544  case 337:
8545 
8546 /* Line 1806 of yacc.c */
8547 #line 3124 "parse.y"
8548  {
8549  token_info_push("for");
8550  }
8551  break;
8552 
8553  case 338:
8554 
8555 /* Line 1806 of yacc.c */
8556 #line 3130 "parse.y"
8557  {
8558  token_info_push("class");
8559  }
8560  break;
8561 
8562  case 339:
8563 
8564 /* Line 1806 of yacc.c */
8565 #line 3136 "parse.y"
8566  {
8567  token_info_push("module");
8568  }
8569  break;
8570 
8571  case 340:
8572 
8573 /* Line 1806 of yacc.c */
8574 #line 3142 "parse.y"
8575  {
8576  token_info_push("def");
8577  /*%%%*/
8578  (yyval.num) = ruby_sourceline;
8579  /*%
8580  %*/
8581  }
8582  break;
8583 
8584  case 341:
8585 
8586 /* Line 1806 of yacc.c */
8587 #line 3152 "parse.y"
8588  {
8589  token_info_pop("end");
8590  }
8591  break;
8592 
8593  case 348:
8594 
8595 /* Line 1806 of yacc.c */
8596 #line 3182 "parse.y"
8597  {
8598  /*%%%*/
8599  (yyval.node) = NEW_IF(cond((yyvsp[(2) - (5)].node)), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
8600  fixpos((yyval.node), (yyvsp[(2) - (5)].node));
8601  /*%
8602  $$ = dispatch3(elsif, $2, $4, escape_Qundef($5));
8603  %*/
8604  }
8605  break;
8606 
8607  case 350:
8608 
8609 /* Line 1806 of yacc.c */
8610 #line 3194 "parse.y"
8611  {
8612  /*%%%*/
8613  (yyval.node) = (yyvsp[(2) - (2)].node);
8614  /*%
8615  $$ = dispatch1(else, $2);
8616  %*/
8617  }
8618  break;
8619 
8620  case 353:
8621 
8622 /* Line 1806 of yacc.c */
8623 #line 3208 "parse.y"
8624  {
8625  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
8626  /*%%%*/
8627  /*%
8628  $$ = dispatch1(mlhs_paren, $$);
8629  %*/
8630  }
8631  break;
8632 
8633  case 354:
8634 
8635 /* Line 1806 of yacc.c */
8636 #line 3216 "parse.y"
8637  {
8638  /*%%%*/
8639  (yyval.node) = (yyvsp[(2) - (3)].node);
8640  /*%
8641  $$ = dispatch1(mlhs_paren, $2);
8642  %*/
8643  }
8644  break;
8645 
8646  case 355:
8647 
8648 /* Line 1806 of yacc.c */
8649 #line 3226 "parse.y"
8650  {
8651  /*%%%*/
8652  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
8653  /*%
8654  $$ = mlhs_add(mlhs_new(), $1);
8655  %*/
8656  }
8657  break;
8658 
8659  case 356:
8660 
8661 /* Line 1806 of yacc.c */
8662 #line 3234 "parse.y"
8663  {
8664  /*%%%*/
8665  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
8666  /*%
8667  $$ = mlhs_add($1, $3);
8668  %*/
8669  }
8670  break;
8671 
8672  case 357:
8673 
8674 /* Line 1806 of yacc.c */
8675 #line 3244 "parse.y"
8676  {
8677  /*%%%*/
8678  (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0);
8679  /*%
8680  $$ = $1;
8681  %*/
8682  }
8683  break;
8684 
8685  case 358:
8686 
8687 /* Line 1806 of yacc.c */
8688 #line 3252 "parse.y"
8689  {
8690  (yyval.node) = assignable((yyvsp[(4) - (4)].id), 0);
8691  /*%%%*/
8692  (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), (yyval.node));
8693  /*%
8694  $$ = mlhs_add_star($1, $$);
8695  %*/
8696  }
8697  break;
8698 
8699  case 359:
8700 
8701 /* Line 1806 of yacc.c */
8702 #line 3261 "parse.y"
8703  {
8704  (yyval.node) = assignable((yyvsp[(4) - (6)].id), 0);
8705  /*%%%*/
8706  (yyval.node) = NEW_MASGN((yyvsp[(1) - (6)].node), NEW_POSTARG((yyval.node), (yyvsp[(6) - (6)].node)));
8707  /*%
8708  $$ = mlhs_add_star($1, $$);
8709  %*/
8710  }
8711  break;
8712 
8713  case 360:
8714 
8715 /* Line 1806 of yacc.c */
8716 #line 3270 "parse.y"
8717  {
8718  /*%%%*/
8719  (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), -1);
8720  /*%
8721  $$ = mlhs_add_star($1, Qnil);
8722  %*/
8723  }
8724  break;
8725 
8726  case 361:
8727 
8728 /* Line 1806 of yacc.c */
8729 #line 3278 "parse.y"
8730  {
8731  /*%%%*/
8732  (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG(-1, (yyvsp[(5) - (5)].node)));
8733  /*%
8734  $$ = mlhs_add_star($1, $5);
8735  %*/
8736  }
8737  break;
8738 
8739  case 362:
8740 
8741 /* Line 1806 of yacc.c */
8742 #line 3286 "parse.y"
8743  {
8744  (yyval.node) = assignable((yyvsp[(2) - (2)].id), 0);
8745  /*%%%*/
8746  (yyval.node) = NEW_MASGN(0, (yyval.node));
8747  /*%
8748  $$ = mlhs_add_star(mlhs_new(), $$);
8749  %*/
8750  }
8751  break;
8752 
8753  case 363:
8754 
8755 /* Line 1806 of yacc.c */
8756 #line 3295 "parse.y"
8757  {
8758  (yyval.node) = assignable((yyvsp[(2) - (4)].id), 0);
8759  /*%%%*/
8760  (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyval.node), (yyvsp[(4) - (4)].node)));
8761  /*%
8762  #if 0
8763  TODO: Check me
8764  #endif
8765  $$ = mlhs_add_star($$, $4);
8766  %*/
8767  }
8768  break;
8769 
8770  case 364:
8771 
8772 /* Line 1806 of yacc.c */
8773 #line 3307 "parse.y"
8774  {
8775  /*%%%*/
8776  (yyval.node) = NEW_MASGN(0, -1);
8777  /*%
8778  $$ = mlhs_add_star(mlhs_new(), Qnil);
8779  %*/
8780  }
8781  break;
8782 
8783  case 365:
8784 
8785 /* Line 1806 of yacc.c */
8786 #line 3315 "parse.y"
8787  {
8788  /*%%%*/
8789  (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node)));
8790  /*%
8791  $$ = mlhs_add_star(mlhs_new(), Qnil);
8792  %*/
8793  }
8794  break;
8795 
8796  case 366:
8797 
8798 /* Line 1806 of yacc.c */
8799 #line 3325 "parse.y"
8800  {
8801  /*%%%*/
8802  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), 0, (yyvsp[(6) - (6)].id));
8803  /*%
8804  $$ = params_new($1, $3, $5, Qnil, escape_Qundef($6));
8805  %*/
8806  }
8807  break;
8808 
8809  case 367:
8810 
8811 /* Line 1806 of yacc.c */
8812 #line 3333 "parse.y"
8813  {
8814  /*%%%*/
8815  (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].id));
8816  /*%
8817  $$ = params_new($1, $3, $5, $7, escape_Qundef($8));
8818  %*/
8819  }
8820  break;
8821 
8822  case 368:
8823 
8824 /* Line 1806 of yacc.c */
8825 #line 3341 "parse.y"
8826  {
8827  /*%%%*/
8828  (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), 0, 0, (yyvsp[(4) - (4)].id));
8829  /*%
8830  $$ = params_new($1, $3, Qnil, Qnil, escape_Qundef($4));
8831  %*/
8832  }
8833  break;
8834 
8835  case 369:
8836 
8837 /* Line 1806 of yacc.c */
8838 #line 3349 "parse.y"
8839  {
8840  /*%%%*/
8841  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), 0, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].id));
8842  /*%
8843  $$ = params_new($1, $3, Qnil, $5, escape_Qundef($6));
8844  %*/
8845  }
8846  break;
8847 
8848  case 370:
8849 
8850 /* Line 1806 of yacc.c */
8851 #line 3357 "parse.y"
8852  {
8853  /*%%%*/
8854  (yyval.node) = new_args((yyvsp[(1) - (4)].node), 0, (yyvsp[(3) - (4)].id), 0, (yyvsp[(4) - (4)].id));
8855  /*%
8856  $$ = params_new($1, Qnil, $3, Qnil, escape_Qundef($4));
8857  %*/
8858  }
8859  break;
8860 
8861  case 371:
8862 
8863 /* Line 1806 of yacc.c */
8864 #line 3365 "parse.y"
8865  {
8866  /*%%%*/
8867  (yyval.node) = new_args((yyvsp[(1) - (2)].node), 0, 1, 0, 0);
8868  /*%
8869  $$ = params_new($1, Qnil, Qnil, Qnil, Qnil);
8870  dispatch1(excessed_comma, $$);
8871  %*/
8872  }
8873  break;
8874 
8875  case 372:
8876 
8877 /* Line 1806 of yacc.c */
8878 #line 3374 "parse.y"
8879  {
8880  /*%%%*/
8881  (yyval.node) = new_args((yyvsp[(1) - (6)].node), 0, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].id));
8882  /*%
8883  $$ = params_new($1, Qnil, $3, $5, escape_Qundef($6));
8884  %*/
8885  }
8886  break;
8887 
8888  case 373:
8889 
8890 /* Line 1806 of yacc.c */
8891 #line 3382 "parse.y"
8892  {
8893  /*%%%*/
8894  (yyval.node) = new_args((yyvsp[(1) - (2)].node), 0, 0, 0, (yyvsp[(2) - (2)].id));
8895  /*%
8896  $$ = params_new($1, Qnil,Qnil, Qnil, escape_Qundef($2));
8897  %*/
8898  }
8899  break;
8900 
8901  case 374:
8902 
8903 /* Line 1806 of yacc.c */
8904 #line 3390 "parse.y"
8905  {
8906  /*%%%*/
8907  (yyval.node) = new_args(0, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), 0, (yyvsp[(4) - (4)].id));
8908  /*%
8909  $$ = params_new(Qnil, $1, $3, Qnil, escape_Qundef($4));
8910  %*/
8911  }
8912  break;
8913 
8914  case 375:
8915 
8916 /* Line 1806 of yacc.c */
8917 #line 3398 "parse.y"
8918  {
8919  /*%%%*/
8920  (yyval.node) = new_args(0, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].id));
8921  /*%
8922  $$ = params_new(Qnil, $1, $3, $5, escape_Qundef($6));
8923  %*/
8924  }
8925  break;
8926 
8927  case 376:
8928 
8929 /* Line 1806 of yacc.c */
8930 #line 3406 "parse.y"
8931  {
8932  /*%%%*/
8933  (yyval.node) = new_args(0, (yyvsp[(1) - (2)].node), 0, 0, (yyvsp[(2) - (2)].id));
8934  /*%
8935  $$ = params_new(Qnil, $1, Qnil, Qnil,escape_Qundef($2));
8936  %*/
8937  }
8938  break;
8939 
8940  case 377:
8941 
8942 /* Line 1806 of yacc.c */
8943 #line 3414 "parse.y"
8944  {
8945  /*%%%*/
8946  (yyval.node) = new_args(0, (yyvsp[(1) - (4)].node), 0, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].id));
8947  /*%
8948  $$ = params_new(Qnil, $1, Qnil, $3, escape_Qundef($4));
8949  %*/
8950  }
8951  break;
8952 
8953  case 378:
8954 
8955 /* Line 1806 of yacc.c */
8956 #line 3422 "parse.y"
8957  {
8958  /*%%%*/
8959  (yyval.node) = new_args(0, 0, (yyvsp[(1) - (2)].id), 0, (yyvsp[(2) - (2)].id));
8960  /*%
8961  $$ = params_new(Qnil, Qnil, $1, Qnil, escape_Qundef($2));
8962  %*/
8963  }
8964  break;
8965 
8966  case 379:
8967 
8968 /* Line 1806 of yacc.c */
8969 #line 3430 "parse.y"
8970  {
8971  /*%%%*/
8972  (yyval.node) = new_args(0, 0, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].id));
8973  /*%
8974  $$ = params_new(Qnil, Qnil, $1, $3, escape_Qundef($4));
8975  %*/
8976  }
8977  break;
8978 
8979  case 380:
8980 
8981 /* Line 1806 of yacc.c */
8982 #line 3438 "parse.y"
8983  {
8984  /*%%%*/
8985  (yyval.node) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].id));
8986  /*%
8987  $$ = params_new(Qnil, Qnil, Qnil, Qnil, $1);
8988  %*/
8989  }
8990  break;
8991 
8992  case 382:
8993 
8994 /* Line 1806 of yacc.c */
8995 #line 3449 "parse.y"
8996  {
8997  command_start = TRUE;
8998  }
8999  break;
9000 
9001  case 383:
9002 
9003 /* Line 1806 of yacc.c */
9004 #line 3455 "parse.y"
9005  {
9006  /*%%%*/
9007  (yyval.node) = 0;
9008  /*%
9009  $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
9010  escape_Qundef($2));
9011  %*/
9012  }
9013  break;
9014 
9015  case 384:
9016 
9017 /* Line 1806 of yacc.c */
9018 #line 3464 "parse.y"
9019  {
9020  /*%%%*/
9021  (yyval.node) = 0;
9022  /*%
9023  $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
9024  Qnil);
9025  %*/
9026  }
9027  break;
9028 
9029  case 385:
9030 
9031 /* Line 1806 of yacc.c */
9032 #line 3473 "parse.y"
9033  {
9034  /*%%%*/
9035  (yyval.node) = (yyvsp[(2) - (4)].node);
9036  /*%
9037  $$ = blockvar_new(escape_Qundef($2), escape_Qundef($3));
9038  %*/
9039  }
9040  break;
9041 
9042  case 387:
9043 
9044 /* Line 1806 of yacc.c */
9045 #line 3485 "parse.y"
9046  {
9047  /*%%%*/
9048  (yyval.node) = 0;
9049  /*%
9050  $$ = $2;
9051  %*/
9052  }
9053  break;
9054 
9055  case 390:
9056 
9057 /* Line 1806 of yacc.c */
9058 #line 3511 "parse.y"
9059  {
9060  new_bv(get_id((yyvsp[(1) - (1)].id)));
9061  /*%%%*/
9062  /*%
9063  $$ = get_value($1);
9064  %*/
9065  }
9066  break;
9067 
9068  case 391:
9069 
9070 /* Line 1806 of yacc.c */
9071 #line 3519 "parse.y"
9072  {
9073  (yyval.node) = 0;
9074  }
9075  break;
9076 
9077  case 392:
9078 
9079 /* Line 1806 of yacc.c */
9080 #line 3524 "parse.y"
9081  {
9082  (yyval.vars) = dyna_push();
9083  }
9084  break;
9085 
9086  case 393:
9087 
9088 /* Line 1806 of yacc.c */
9089 #line 3527 "parse.y"
9090  {
9091  (yyval.num) = lpar_beg;
9092  lpar_beg = ++paren_nest;
9093  }
9094  break;
9095 
9096  case 394:
9097 
9098 /* Line 1806 of yacc.c */
9099 #line 3533 "parse.y"
9100  {
9101  lpar_beg = (yyvsp[(2) - (4)].num);
9102  /*%%%*/
9103  (yyval.node) = (yyvsp[(3) - (4)].node);
9104  (yyval.node)->nd_body = NEW_SCOPE((yyvsp[(3) - (4)].node)->nd_head, (yyvsp[(4) - (4)].node));
9105  /*%
9106  $$ = dispatch2(lambda, $3, $4);
9107  %*/
9108  dyna_pop((yyvsp[(1) - (4)].vars));
9109  }
9110  break;
9111 
9112  case 395:
9113 
9114 /* Line 1806 of yacc.c */
9115 #line 3546 "parse.y"
9116  {
9117  /*%%%*/
9118  (yyval.node) = NEW_LAMBDA((yyvsp[(2) - (4)].node));
9119  /*%
9120  $$ = dispatch1(paren, $2);
9121  %*/
9122  }
9123  break;
9124 
9125  case 396:
9126 
9127 /* Line 1806 of yacc.c */
9128 #line 3554 "parse.y"
9129  {
9130  /*%%%*/
9131  (yyval.node) = NEW_LAMBDA((yyvsp[(1) - (1)].node));
9132  /*%
9133  $$ = $1;
9134  %*/
9135  }
9136  break;
9137 
9138  case 397:
9139 
9140 /* Line 1806 of yacc.c */
9141 #line 3564 "parse.y"
9142  {
9143  (yyval.node) = (yyvsp[(2) - (3)].node);
9144  }
9145  break;
9146 
9147  case 398:
9148 
9149 /* Line 1806 of yacc.c */
9150 #line 3568 "parse.y"
9151  {
9152  (yyval.node) = (yyvsp[(2) - (3)].node);
9153  }
9154  break;
9155 
9156  case 399:
9157 
9158 /* Line 1806 of yacc.c */
9159 #line 3574 "parse.y"
9160  {
9161  (yyvsp[(1) - (1)].vars) = dyna_push();
9162  /*%%%*/
9163  (yyval.num) = ruby_sourceline;
9164  /*% %*/
9165  }
9166  break;
9167 
9168  case 400:
9169 
9170 /* Line 1806 of yacc.c */
9171 #line 3583 "parse.y"
9172  {
9173  /*%%%*/
9174  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
9175  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
9176  /*%
9177  $$ = dispatch2(do_block, escape_Qundef($3), $4);
9178  %*/
9179  dyna_pop((yyvsp[(1) - (5)].vars));
9180  }
9181  break;
9182 
9183  case 401:
9184 
9185 /* Line 1806 of yacc.c */
9186 #line 3595 "parse.y"
9187  {
9188  /*%%%*/
9189  if (nd_type((yyvsp[(1) - (2)].node)) == NODE_YIELD) {
9190  compile_error(PARSER_ARG "block given to yield");
9191  }
9192  else {
9193  block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node));
9194  }
9195  (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
9196  (yyval.node) = (yyvsp[(2) - (2)].node);
9197  fixpos((yyval.node), (yyvsp[(1) - (2)].node));
9198  /*%
9199  $$ = method_add_block($1, $2);
9200  %*/
9201  }
9202  break;
9203 
9204  case 402:
9205 
9206 /* Line 1806 of yacc.c */
9207 #line 3611 "parse.y"
9208  {
9209  /*%%%*/
9210  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
9211  /*%
9212  $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
9213  $$ = method_optarg($$, $4);
9214  %*/
9215  }
9216  break;
9217 
9218  case 403:
9219 
9220 /* Line 1806 of yacc.c */
9221 #line 3620 "parse.y"
9222  {
9223  /*%%%*/
9224  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
9225  /*%
9226  $$ = dispatch3(call, $1, ripper_intern("::"), $3);
9227  $$ = method_optarg($$, $4);
9228  %*/
9229  }
9230  break;
9231 
9232  case 404:
9233 
9234 /* Line 1806 of yacc.c */
9235 #line 3631 "parse.y"
9236  {
9237  /*%%%*/
9238  (yyval.node) = NEW_FCALL((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node));
9239  fixpos((yyval.node), (yyvsp[(2) - (2)].node));
9240  /*%
9241  $$ = method_arg(dispatch1(fcall, $1), $2);
9242  %*/
9243  }
9244  break;
9245 
9246  case 405:
9247 
9248 /* Line 1806 of yacc.c */
9249 #line 3640 "parse.y"
9250  {
9251  /*%%%*/
9252  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
9253  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
9254  /*%
9255  $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
9256  $$ = method_optarg($$, $4);
9257  %*/
9258  }
9259  break;
9260 
9261  case 406:
9262 
9263 /* Line 1806 of yacc.c */
9264 #line 3650 "parse.y"
9265  {
9266  /*%%%*/
9267  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
9268  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
9269  /*%
9270  $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
9271  $$ = method_optarg($$, $4);
9272  %*/
9273  }
9274  break;
9275 
9276  case 407:
9277 
9278 /* Line 1806 of yacc.c */
9279 #line 3660 "parse.y"
9280  {
9281  /*%%%*/
9282  (yyval.node) = NEW_CALL((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id), 0);
9283  /*%
9284  $$ = dispatch3(call, $1, ripper_intern("::"), $3);
9285  %*/
9286  }
9287  break;
9288 
9289  case 408:
9290 
9291 /* Line 1806 of yacc.c */
9292 #line 3668 "parse.y"
9293  {
9294  /*%%%*/
9295  (yyval.node) = NEW_CALL((yyvsp[(1) - (3)].node), rb_intern("call"), (yyvsp[(3) - (3)].node));
9296  fixpos((yyval.node), (yyvsp[(1) - (3)].node));
9297  /*%
9298  $$ = dispatch3(call, $1, ripper_id2sym('.'),
9299  ripper_intern("call"));
9300  $$ = method_optarg($$, $3);
9301  %*/
9302  }
9303  break;
9304 
9305  case 409:
9306 
9307 /* Line 1806 of yacc.c */
9308 #line 3679 "parse.y"
9309  {
9310  /*%%%*/
9311  (yyval.node) = NEW_CALL((yyvsp[(1) - (3)].node), rb_intern("call"), (yyvsp[(3) - (3)].node));
9312  fixpos((yyval.node), (yyvsp[(1) - (3)].node));
9313  /*%
9314  $$ = dispatch3(call, $1, ripper_intern("::"),
9315  ripper_intern("call"));
9316  $$ = method_optarg($$, $3);
9317  %*/
9318  }
9319  break;
9320 
9321  case 410:
9322 
9323 /* Line 1806 of yacc.c */
9324 #line 3690 "parse.y"
9325  {
9326  /*%%%*/
9327  (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node));
9328  /*%
9329  $$ = dispatch1(super, $2);
9330  %*/
9331  }
9332  break;
9333 
9334  case 411:
9335 
9336 /* Line 1806 of yacc.c */
9337 #line 3698 "parse.y"
9338  {
9339  /*%%%*/
9340  (yyval.node) = NEW_ZSUPER();
9341  /*%
9342  $$ = dispatch0(zsuper);
9343  %*/
9344  }
9345  break;
9346 
9347  case 412:
9348 
9349 /* Line 1806 of yacc.c */
9350 #line 3706 "parse.y"
9351  {
9352  /*%%%*/
9353  if ((yyvsp[(1) - (4)].node) && nd_type((yyvsp[(1) - (4)].node)) == NODE_SELF)
9354  (yyval.node) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].node));
9355  else
9356  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), tAREF, (yyvsp[(3) - (4)].node));
9357  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
9358  /*%
9359  $$ = dispatch2(aref, $1, escape_Qundef($3));
9360  %*/
9361  }
9362  break;
9363 
9364  case 413:
9365 
9366 /* Line 1806 of yacc.c */
9367 #line 3720 "parse.y"
9368  {
9369  (yyvsp[(1) - (1)].vars) = dyna_push();
9370  /*%%%*/
9371  (yyval.num) = ruby_sourceline;
9372  /*%
9373  %*/
9374  }
9375  break;
9376 
9377  case 414:
9378 
9379 /* Line 1806 of yacc.c */
9380 #line 3729 "parse.y"
9381  {
9382  /*%%%*/
9383  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
9384  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
9385  /*%
9386  $$ = dispatch2(brace_block, escape_Qundef($3), $4);
9387  %*/
9388  dyna_pop((yyvsp[(1) - (5)].vars));
9389  }
9390  break;
9391 
9392  case 415:
9393 
9394 /* Line 1806 of yacc.c */
9395 #line 3739 "parse.y"
9396  {
9397  (yyvsp[(1) - (1)].vars) = dyna_push();
9398  /*%%%*/
9399  (yyval.num) = ruby_sourceline;
9400  /*%
9401  %*/
9402  }
9403  break;
9404 
9405  case 416:
9406 
9407 /* Line 1806 of yacc.c */
9408 #line 3748 "parse.y"
9409  {
9410  /*%%%*/
9411  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
9412  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
9413  /*%
9414  $$ = dispatch2(do_block, escape_Qundef($3), $4);
9415  %*/
9416  dyna_pop((yyvsp[(1) - (5)].vars));
9417  }
9418  break;
9419 
9420  case 417:
9421 
9422 /* Line 1806 of yacc.c */
9423 #line 3762 "parse.y"
9424  {
9425  /*%%%*/
9426  (yyval.node) = NEW_WHEN((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
9427  /*%
9428  $$ = dispatch3(when, $2, $4, escape_Qundef($5));
9429  %*/
9430  }
9431  break;
9432 
9433  case 420:
9434 
9435 /* Line 1806 of yacc.c */
9436 #line 3778 "parse.y"
9437  {
9438  /*%%%*/
9439  if ((yyvsp[(3) - (6)].node)) {
9440  (yyvsp[(3) - (6)].node) = node_assign((yyvsp[(3) - (6)].node), NEW_ERRINFO());
9441  (yyvsp[(5) - (6)].node) = block_append((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node));
9442  }
9443  (yyval.node) = NEW_RESBODY((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
9444  fixpos((yyval.node), (yyvsp[(2) - (6)].node)?(yyvsp[(2) - (6)].node):(yyvsp[(5) - (6)].node));
9445  /*%
9446  $$ = dispatch4(rescue,
9447  escape_Qundef($2),
9448  escape_Qundef($3),
9449  escape_Qundef($5),
9450  escape_Qundef($6));
9451  %*/
9452  }
9453  break;
9454 
9455  case 422:
9456 
9457 /* Line 1806 of yacc.c */
9458 #line 3798 "parse.y"
9459  {
9460  /*%%%*/
9461  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
9462  /*%
9463  $$ = rb_ary_new3(1, $1);
9464  %*/
9465  }
9466  break;
9467 
9468  case 423:
9469 
9470 /* Line 1806 of yacc.c */
9471 #line 3806 "parse.y"
9472  {
9473  /*%%%*/
9474  if (!((yyval.node) = splat_array((yyvsp[(1) - (1)].node)))) (yyval.node) = (yyvsp[(1) - (1)].node);
9475  /*%
9476  $$ = $1;
9477  %*/
9478  }
9479  break;
9480 
9481  case 425:
9482 
9483 /* Line 1806 of yacc.c */
9484 #line 3817 "parse.y"
9485  {
9486  (yyval.node) = (yyvsp[(2) - (2)].node);
9487  }
9488  break;
9489 
9490  case 427:
9491 
9492 /* Line 1806 of yacc.c */
9493 #line 3824 "parse.y"
9494  {
9495  /*%%%*/
9496  (yyval.node) = (yyvsp[(2) - (2)].node);
9497  /*%
9498  $$ = dispatch1(ensure, $2);
9499  %*/
9500  }
9501  break;
9502 
9503  case 430:
9504 
9505 /* Line 1806 of yacc.c */
9506 #line 3836 "parse.y"
9507  {
9508  /*%%%*/
9509  (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id)));
9510  /*%
9511  $$ = dispatch1(symbol_literal, $1);
9512  %*/
9513  }
9514  break;
9515 
9516  case 432:
9517 
9518 /* Line 1806 of yacc.c */
9519 #line 3847 "parse.y"
9520  {
9521  /*%%%*/
9522  NODE *node = (yyvsp[(1) - (1)].node);
9523  if (!node) {
9524  node = NEW_STR(STR_NEW0());
9525  }
9526  else {
9527  node = evstr2dstr(node);
9528  }
9529  (yyval.node) = node;
9530  /*%
9531  $$ = $1;
9532  %*/
9533  }
9534  break;
9535 
9536  case 435:
9537 
9538 /* Line 1806 of yacc.c */
9539 #line 3866 "parse.y"
9540  {
9541  /*%%%*/
9542  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
9543  /*%
9544  $$ = dispatch2(string_concat, $1, $2);
9545  %*/
9546  }
9547  break;
9548 
9549  case 436:
9550 
9551 /* Line 1806 of yacc.c */
9552 #line 3876 "parse.y"
9553  {
9554  /*%%%*/
9555  (yyval.node) = (yyvsp[(2) - (3)].node);
9556  /*%
9557  $$ = dispatch1(string_literal, $2);
9558  %*/
9559  }
9560  break;
9561 
9562  case 437:
9563 
9564 /* Line 1806 of yacc.c */
9565 #line 3886 "parse.y"
9566  {
9567  /*%%%*/
9568  NODE *node = (yyvsp[(2) - (3)].node);
9569  if (!node) {
9570  node = NEW_XSTR(STR_NEW0());
9571  }
9572  else {
9573  switch (nd_type(node)) {
9574  case NODE_STR:
9575  nd_set_type(node, NODE_XSTR);
9576  break;
9577  case NODE_DSTR:
9578  nd_set_type(node, NODE_DXSTR);
9579  break;
9580  default:
9581  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
9582  break;
9583  }
9584  }
9585  (yyval.node) = node;
9586  /*%
9587  $$ = dispatch1(xstring_literal, $2);
9588  %*/
9589  }
9590  break;
9591 
9592  case 438:
9593 
9594 /* Line 1806 of yacc.c */
9595 #line 3913 "parse.y"
9596  {
9597  /*%%%*/
9598  int options = (yyvsp[(3) - (3)].num);
9599  NODE *node = (yyvsp[(2) - (3)].node);
9600  NODE *list, *prev;
9601  if (!node) {
9602  node = NEW_LIT(reg_compile(STR_NEW0(), options));
9603  }
9604  else switch (nd_type(node)) {
9605  case NODE_STR:
9606  {
9607  VALUE src = node->nd_lit;
9608  nd_set_type(node, NODE_LIT);
9609  node->nd_lit = reg_compile(src, options);
9610  }
9611  break;
9612  default:
9613  node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
9614  case NODE_DSTR:
9615  if (options & RE_OPTION_ONCE) {
9617  }
9618  else {
9619  nd_set_type(node, NODE_DREGX);
9620  }
9621  node->nd_cflag = options & RE_OPTION_MASK;
9622  if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
9623  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
9624  if (nd_type(list->nd_head) == NODE_STR) {
9625  VALUE tail = list->nd_head->nd_lit;
9626  if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
9627  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
9628  if (!literal_concat0(parser, lit, tail)) {
9629  node = 0;
9630  break;
9631  }
9632  rb_str_resize(tail, 0);
9633  prev->nd_next = list->nd_next;
9634  rb_gc_force_recycle((VALUE)list->nd_head);
9635  rb_gc_force_recycle((VALUE)list);
9636  list = prev;
9637  }
9638  else {
9639  prev = list;
9640  }
9641  }
9642  else {
9643  prev = 0;
9644  }
9645  }
9646  if (!node->nd_next) {
9647  VALUE src = node->nd_lit;
9648  nd_set_type(node, NODE_LIT);
9649  node->nd_lit = reg_compile(src, options);
9650  }
9651  break;
9652  }
9653  (yyval.node) = node;
9654  /*%
9655  $$ = dispatch2(regexp_literal, $2, $3);
9656  %*/
9657  }
9658  break;
9659 
9660  case 439:
9661 
9662 /* Line 1806 of yacc.c */
9663 #line 3978 "parse.y"
9664  {
9665  /*%%%*/
9666  (yyval.node) = NEW_ZARRAY();
9667  /*%
9668  $$ = dispatch0(words_new);
9669  $$ = dispatch1(array, $$);
9670  %*/
9671  }
9672  break;
9673 
9674  case 440:
9675 
9676 /* Line 1806 of yacc.c */
9677 #line 3987 "parse.y"
9678  {
9679  /*%%%*/
9680  (yyval.node) = (yyvsp[(2) - (3)].node);
9681  /*%
9682  $$ = dispatch1(array, $2);
9683  %*/
9684  }
9685  break;
9686 
9687  case 441:
9688 
9689 /* Line 1806 of yacc.c */
9690 #line 3997 "parse.y"
9691  {
9692  /*%%%*/
9693  (yyval.node) = 0;
9694  /*%
9695  $$ = dispatch0(words_new);
9696  %*/
9697  }
9698  break;
9699 
9700  case 442:
9701 
9702 /* Line 1806 of yacc.c */
9703 #line 4005 "parse.y"
9704  {
9705  /*%%%*/
9706  (yyval.node) = list_append((yyvsp[(1) - (3)].node), evstr2dstr((yyvsp[(2) - (3)].node)));
9707  /*%
9708  $$ = dispatch2(words_add, $1, $2);
9709  %*/
9710  }
9711  break;
9712 
9713  case 444:
9714 
9715 /* Line 1806 of yacc.c */
9716 #line 4023 "parse.y"
9717  {
9718  /*%%%*/
9719  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
9720  /*%
9721  $$ = dispatch2(word_add, $1, $2);
9722  %*/
9723  }
9724  break;
9725 
9726  case 445:
9727 
9728 /* Line 1806 of yacc.c */
9729 #line 4033 "parse.y"
9730  {
9731  /*%%%*/
9732  (yyval.node) = NEW_ZARRAY();
9733  /*%
9734  $$ = dispatch0(qwords_new);
9735  $$ = dispatch1(array, $$);
9736  %*/
9737  }
9738  break;
9739 
9740  case 446:
9741 
9742 /* Line 1806 of yacc.c */
9743 #line 4042 "parse.y"
9744  {
9745  /*%%%*/
9746  (yyval.node) = (yyvsp[(2) - (3)].node);
9747  /*%
9748  $$ = dispatch1(array, $2);
9749  %*/
9750  }
9751  break;
9752 
9753  case 447:
9754 
9755 /* Line 1806 of yacc.c */
9756 #line 4052 "parse.y"
9757  {
9758  /*%%%*/
9759  (yyval.node) = 0;
9760  /*%
9761  $$ = dispatch0(qwords_new);
9762  %*/
9763  }
9764  break;
9765 
9766  case 448:
9767 
9768 /* Line 1806 of yacc.c */
9769 #line 4060 "parse.y"
9770  {
9771  /*%%%*/
9772  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
9773  /*%
9774  $$ = dispatch2(qwords_add, $1, $2);
9775  %*/
9776  }
9777  break;
9778 
9779  case 449:
9780 
9781 /* Line 1806 of yacc.c */
9782 #line 4070 "parse.y"
9783  {
9784  /*%%%*/
9785  (yyval.node) = 0;
9786  /*%
9787  $$ = dispatch0(string_content);
9788  %*/
9789  }
9790  break;
9791 
9792  case 450:
9793 
9794 /* Line 1806 of yacc.c */
9795 #line 4078 "parse.y"
9796  {
9797  /*%%%*/
9798  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
9799  /*%
9800  $$ = dispatch2(string_add, $1, $2);
9801  %*/
9802  }
9803  break;
9804 
9805  case 451:
9806 
9807 /* Line 1806 of yacc.c */
9808 #line 4088 "parse.y"
9809  {
9810  /*%%%*/
9811  (yyval.node) = 0;
9812  /*%
9813  $$ = dispatch0(xstring_new);
9814  %*/
9815  }
9816  break;
9817 
9818  case 452:
9819 
9820 /* Line 1806 of yacc.c */
9821 #line 4096 "parse.y"
9822  {
9823  /*%%%*/
9824  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
9825  /*%
9826  $$ = dispatch2(xstring_add, $1, $2);
9827  %*/
9828  }
9829  break;
9830 
9831  case 453:
9832 
9833 /* Line 1806 of yacc.c */
9834 #line 4106 "parse.y"
9835  {
9836  /*%%%*/
9837  (yyval.node) = 0;
9838  /*%
9839  $$ = dispatch0(regexp_new);
9840  %*/
9841  }
9842  break;
9843 
9844  case 454:
9845 
9846 /* Line 1806 of yacc.c */
9847 #line 4114 "parse.y"
9848  {
9849  /*%%%*/
9850  NODE *head = (yyvsp[(1) - (2)].node), *tail = (yyvsp[(2) - (2)].node);
9851  if (!head) {
9852  (yyval.node) = tail;
9853  }
9854  else if (!tail) {
9855  (yyval.node) = head;
9856  }
9857  else {
9858  switch (nd_type(head)) {
9859  case NODE_STR:
9860  nd_set_type(head, NODE_DSTR);
9861  break;
9862  case NODE_DSTR:
9863  break;
9864  default:
9865  head = list_append(NEW_DSTR(Qnil), head);
9866  break;
9867  }
9868  (yyval.node) = list_append(head, tail);
9869  }
9870  /*%
9871  $$ = dispatch2(regexp_add, $1, $2);
9872  %*/
9873  }
9874  break;
9875 
9876  case 456:
9877 
9878 /* Line 1806 of yacc.c */
9879 #line 4144 "parse.y"
9880  {
9881  (yyval.node) = lex_strterm;
9882  lex_strterm = 0;
9883  lex_state = EXPR_BEG;
9884  }
9885  break;
9886 
9887  case 457:
9888 
9889 /* Line 1806 of yacc.c */
9890 #line 4150 "parse.y"
9891  {
9892  /*%%%*/
9893  lex_strterm = (yyvsp[(2) - (3)].node);
9894  (yyval.node) = NEW_EVSTR((yyvsp[(3) - (3)].node));
9895  /*%
9896  lex_strterm = $<node>2;
9897  $$ = dispatch1(string_dvar, $3);
9898  %*/
9899  }
9900  break;
9901 
9902  case 458:
9903 
9904 /* Line 1806 of yacc.c */
9905 #line 4160 "parse.y"
9906  {
9907  (yyvsp[(1) - (1)].val) = cond_stack;
9908  (yyval.val) = cmdarg_stack;
9909  cond_stack = 0;
9910  cmdarg_stack = 0;
9911  }
9912  break;
9913 
9914  case 459:
9915 
9916 /* Line 1806 of yacc.c */
9917 #line 4166 "parse.y"
9918  {
9919  (yyval.node) = lex_strterm;
9920  lex_strterm = 0;
9921  lex_state = EXPR_BEG;
9922  }
9923  break;
9924 
9925  case 460:
9926 
9927 /* Line 1806 of yacc.c */
9928 #line 4172 "parse.y"
9929  {
9930  cond_stack = (yyvsp[(1) - (5)].val);
9931  cmdarg_stack = (yyvsp[(2) - (5)].val);
9932  lex_strterm = (yyvsp[(3) - (5)].node);
9933  /*%%%*/
9934  if ((yyvsp[(4) - (5)].node)) (yyvsp[(4) - (5)].node)->flags &= ~NODE_FL_NEWLINE;
9935  (yyval.node) = new_evstr((yyvsp[(4) - (5)].node));
9936  /*%
9937  $$ = dispatch1(string_embexpr, $4);
9938  %*/
9939  }
9940  break;
9941 
9942  case 461:
9943 
9944 /* Line 1806 of yacc.c */
9945 #line 4186 "parse.y"
9946  {
9947  /*%%%*/
9948  (yyval.node) = NEW_GVAR((yyvsp[(1) - (1)].id));
9949  /*%
9950  $$ = dispatch1(var_ref, $1);
9951  %*/
9952  }
9953  break;
9954 
9955  case 462:
9956 
9957 /* Line 1806 of yacc.c */
9958 #line 4194 "parse.y"
9959  {
9960  /*%%%*/
9961  (yyval.node) = NEW_IVAR((yyvsp[(1) - (1)].id));
9962  /*%
9963  $$ = dispatch1(var_ref, $1);
9964  %*/
9965  }
9966  break;
9967 
9968  case 463:
9969 
9970 /* Line 1806 of yacc.c */
9971 #line 4202 "parse.y"
9972  {
9973  /*%%%*/
9974  (yyval.node) = NEW_CVAR((yyvsp[(1) - (1)].id));
9975  /*%
9976  $$ = dispatch1(var_ref, $1);
9977  %*/
9978  }
9979  break;
9980 
9981  case 465:
9982 
9983 /* Line 1806 of yacc.c */
9984 #line 4213 "parse.y"
9985  {
9986  lex_state = EXPR_END;
9987  /*%%%*/
9988  (yyval.id) = (yyvsp[(2) - (2)].id);
9989  /*%
9990  $$ = dispatch1(symbol, $2);
9991  %*/
9992  }
9993  break;
9994 
9995  case 470:
9996 
9997 /* Line 1806 of yacc.c */
9998 #line 4230 "parse.y"
9999  {
10000  lex_state = EXPR_END;
10001  /*%%%*/
10002  if (!((yyval.node) = (yyvsp[(2) - (3)].node))) {
10003  (yyval.node) = NEW_LIT(ID2SYM(rb_intern("")));
10004  }
10005  else {
10006  VALUE lit;
10007 
10008  switch (nd_type((yyval.node))) {
10009  case NODE_DSTR:
10010  nd_set_type((yyval.node), NODE_DSYM);
10011  break;
10012  case NODE_STR:
10013  lit = (yyval.node)->nd_lit;
10014  (yyval.node)->nd_lit = ID2SYM(rb_intern_str(lit));
10015  nd_set_type((yyval.node), NODE_LIT);
10016  break;
10017  default:
10018  (yyval.node) = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST((yyval.node)));
10019  break;
10020  }
10021  }
10022  /*%
10023  $$ = dispatch1(dyna_symbol, $2);
10024  %*/
10025  }
10026  break;
10027 
10028  case 473:
10029 
10030 /* Line 1806 of yacc.c */
10031 #line 4262 "parse.y"
10032  {
10033  /*%%%*/
10034  (yyval.node) = negate_lit((yyvsp[(2) - (2)].node));
10035  /*%
10036  $$ = dispatch2(unary, ripper_intern("-@"), $2);
10037  %*/
10038  }
10039  break;
10040 
10041  case 474:
10042 
10043 /* Line 1806 of yacc.c */
10044 #line 4270 "parse.y"
10045  {
10046  /*%%%*/
10047  (yyval.node) = negate_lit((yyvsp[(2) - (2)].node));
10048  /*%
10049  $$ = dispatch2(unary, ripper_intern("-@"), $2);
10050  %*/
10051  }
10052  break;
10053 
10054  case 480:
10055 
10056 /* Line 1806 of yacc.c */
10057 #line 4286 "parse.y"
10058  {ifndef_ripper((yyval.id) = keyword_nil);}
10059  break;
10060 
10061  case 481:
10062 
10063 /* Line 1806 of yacc.c */
10064 #line 4287 "parse.y"
10065  {ifndef_ripper((yyval.id) = keyword_self);}
10066  break;
10067 
10068  case 482:
10069 
10070 /* Line 1806 of yacc.c */
10071 #line 4288 "parse.y"
10072  {ifndef_ripper((yyval.id) = keyword_true);}
10073  break;
10074 
10075  case 483:
10076 
10077 /* Line 1806 of yacc.c */
10078 #line 4289 "parse.y"
10079  {ifndef_ripper((yyval.id) = keyword_false);}
10080  break;
10081 
10082  case 484:
10083 
10084 /* Line 1806 of yacc.c */
10085 #line 4290 "parse.y"
10086  {ifndef_ripper((yyval.id) = keyword__FILE__);}
10087  break;
10088 
10089  case 485:
10090 
10091 /* Line 1806 of yacc.c */
10092 #line 4291 "parse.y"
10093  {ifndef_ripper((yyval.id) = keyword__LINE__);}
10094  break;
10095 
10096  case 486:
10097 
10098 /* Line 1806 of yacc.c */
10099 #line 4292 "parse.y"
10100  {ifndef_ripper((yyval.id) = keyword__ENCODING__);}
10101  break;
10102 
10103  case 487:
10104 
10105 /* Line 1806 of yacc.c */
10106 #line 4296 "parse.y"
10107  {
10108  /*%%%*/
10109  if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0);
10110  /*%
10111  if (id_is_var(get_id($1))) {
10112  $$ = dispatch1(var_ref, $1);
10113  }
10114  else {
10115  $$ = dispatch1(vcall, $1);
10116  }
10117  %*/
10118  }
10119  break;
10120 
10121  case 488:
10122 
10123 /* Line 1806 of yacc.c */
10124 #line 4309 "parse.y"
10125  {
10126  /*%%%*/
10127  if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0);
10128  /*%
10129  $$ = dispatch1(var_ref, $1);
10130  %*/
10131  }
10132  break;
10133 
10134  case 489:
10135 
10136 /* Line 1806 of yacc.c */
10137 #line 4319 "parse.y"
10138  {
10139  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
10140  /*%%%*/
10141  /*%
10142  $$ = dispatch1(var_field, $$);
10143  %*/
10144  }
10145  break;
10146 
10147  case 490:
10148 
10149 /* Line 1806 of yacc.c */
10150 #line 4327 "parse.y"
10151  {
10152  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
10153  /*%%%*/
10154  /*%
10155  $$ = dispatch1(var_field, $$);
10156  %*/
10157  }
10158  break;
10159 
10160  case 493:
10161 
10162 /* Line 1806 of yacc.c */
10163 #line 4341 "parse.y"
10164  {
10165  /*%%%*/
10166  (yyval.node) = 0;
10167  /*%
10168  $$ = Qnil;
10169  %*/
10170  }
10171  break;
10172 
10173  case 494:
10174 
10175 /* Line 1806 of yacc.c */
10176 #line 4349 "parse.y"
10177  {
10178  lex_state = EXPR_BEG;
10179  }
10180  break;
10181 
10182  case 495:
10183 
10184 /* Line 1806 of yacc.c */
10185 #line 4353 "parse.y"
10186  {
10187  (yyval.node) = (yyvsp[(3) - (4)].node);
10188  }
10189  break;
10190 
10191  case 496:
10192 
10193 /* Line 1806 of yacc.c */
10194 #line 4357 "parse.y"
10195  {
10196  /*%%%*/
10197  yyerrok;
10198  (yyval.node) = 0;
10199  /*%
10200  yyerrok;
10201  $$ = Qnil;
10202  %*/
10203  }
10204  break;
10205 
10206  case 497:
10207 
10208 /* Line 1806 of yacc.c */
10209 #line 4369 "parse.y"
10210  {
10211  /*%%%*/
10212  (yyval.node) = (yyvsp[(2) - (3)].node);
10213  /*%
10214  $$ = dispatch1(paren, $2);
10215  %*/
10216  lex_state = EXPR_BEG;
10217  command_start = TRUE;
10218  }
10219  break;
10220 
10221  case 498:
10222 
10223 /* Line 1806 of yacc.c */
10224 #line 4379 "parse.y"
10225  {
10226  (yyval.node) = (yyvsp[(1) - (2)].node);
10227  lex_state = EXPR_BEG;
10228  command_start = TRUE;
10229  }
10230  break;
10231 
10232  case 499:
10233 
10234 /* Line 1806 of yacc.c */
10235 #line 4387 "parse.y"
10236  {
10237  /*%%%*/
10238  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), 0, (yyvsp[(6) - (6)].id));
10239  /*%
10240  $$ = params_new($1, $3, $5, Qnil, escape_Qundef($6));
10241  %*/
10242  }
10243  break;
10244 
10245  case 500:
10246 
10247 /* Line 1806 of yacc.c */
10248 #line 4395 "parse.y"
10249  {
10250  /*%%%*/
10251  (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].id));
10252  /*%
10253  $$ = params_new($1, $3, $5, $7, escape_Qundef($8));
10254  %*/
10255  }
10256  break;
10257 
10258  case 501:
10259 
10260 /* Line 1806 of yacc.c */
10261 #line 4403 "parse.y"
10262  {
10263  /*%%%*/
10264  (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), 0, 0, (yyvsp[(4) - (4)].id));
10265  /*%
10266  $$ = params_new($1, $3, Qnil, Qnil, escape_Qundef($4));
10267  %*/
10268  }
10269  break;
10270 
10271  case 502:
10272 
10273 /* Line 1806 of yacc.c */
10274 #line 4411 "parse.y"
10275  {
10276  /*%%%*/
10277  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), 0, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].id));
10278  /*%
10279  $$ = params_new($1, $3, Qnil, $5, escape_Qundef($6));
10280  %*/
10281  }
10282  break;
10283 
10284  case 503:
10285 
10286 /* Line 1806 of yacc.c */
10287 #line 4419 "parse.y"
10288  {
10289  /*%%%*/
10290  (yyval.node) = new_args((yyvsp[(1) - (4)].node), 0, (yyvsp[(3) - (4)].id), 0, (yyvsp[(4) - (4)].id));
10291  /*%
10292  $$ = params_new($1, Qnil, $3, Qnil, escape_Qundef($4));
10293  %*/
10294  }
10295  break;
10296 
10297  case 504:
10298 
10299 /* Line 1806 of yacc.c */
10300 #line 4427 "parse.y"
10301  {
10302  /*%%%*/
10303  (yyval.node) = new_args((yyvsp[(1) - (6)].node), 0, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].id));
10304  /*%
10305  $$ = params_new($1, Qnil, $3, $5, escape_Qundef($6));
10306  %*/
10307  }
10308  break;
10309 
10310  case 505:
10311 
10312 /* Line 1806 of yacc.c */
10313 #line 4435 "parse.y"
10314  {
10315  /*%%%*/
10316  (yyval.node) = new_args((yyvsp[(1) - (2)].node), 0, 0, 0, (yyvsp[(2) - (2)].id));
10317  /*%
10318  $$ = params_new($1, Qnil, Qnil, Qnil,escape_Qundef($2));
10319  %*/
10320  }
10321  break;
10322 
10323  case 506:
10324 
10325 /* Line 1806 of yacc.c */
10326 #line 4443 "parse.y"
10327  {
10328  /*%%%*/
10329  (yyval.node) = new_args(0, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), 0, (yyvsp[(4) - (4)].id));
10330  /*%
10331  $$ = params_new(Qnil, $1, $3, Qnil, escape_Qundef($4));
10332  %*/
10333  }
10334  break;
10335 
10336  case 507:
10337 
10338 /* Line 1806 of yacc.c */
10339 #line 4451 "parse.y"
10340  {
10341  /*%%%*/
10342  (yyval.node) = new_args(0, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].id));
10343  /*%
10344  $$ = params_new(Qnil, $1, $3, $5, escape_Qundef($6));
10345  %*/
10346  }
10347  break;
10348 
10349  case 508:
10350 
10351 /* Line 1806 of yacc.c */
10352 #line 4459 "parse.y"
10353  {
10354  /*%%%*/
10355  (yyval.node) = new_args(0, (yyvsp[(1) - (2)].node), 0, 0, (yyvsp[(2) - (2)].id));
10356  /*%
10357  $$ = params_new(Qnil, $1, Qnil, Qnil,escape_Qundef($2));
10358  %*/
10359  }
10360  break;
10361 
10362  case 509:
10363 
10364 /* Line 1806 of yacc.c */
10365 #line 4467 "parse.y"
10366  {
10367  /*%%%*/
10368  (yyval.node) = new_args(0, (yyvsp[(1) - (4)].node), 0, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].id));
10369  /*%
10370  $$ = params_new(Qnil, $1, Qnil, $3, escape_Qundef($4));
10371  %*/
10372  }
10373  break;
10374 
10375  case 510:
10376 
10377 /* Line 1806 of yacc.c */
10378 #line 4475 "parse.y"
10379  {
10380  /*%%%*/
10381  (yyval.node) = new_args(0, 0, (yyvsp[(1) - (2)].id), 0, (yyvsp[(2) - (2)].id));
10382  /*%
10383  $$ = params_new(Qnil, Qnil, $1, Qnil,escape_Qundef($2));
10384  %*/
10385  }
10386  break;
10387 
10388  case 511:
10389 
10390 /* Line 1806 of yacc.c */
10391 #line 4483 "parse.y"
10392  {
10393  /*%%%*/
10394  (yyval.node) = new_args(0, 0, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].id));
10395  /*%
10396  $$ = params_new(Qnil, Qnil, $1, $3, escape_Qundef($4));
10397  %*/
10398  }
10399  break;
10400 
10401  case 512:
10402 
10403 /* Line 1806 of yacc.c */
10404 #line 4491 "parse.y"
10405  {
10406  /*%%%*/
10407  (yyval.node) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].id));
10408  /*%
10409  $$ = params_new(Qnil, Qnil, Qnil, Qnil, $1);
10410  %*/
10411  }
10412  break;
10413 
10414  case 513:
10415 
10416 /* Line 1806 of yacc.c */
10417 #line 4499 "parse.y"
10418  {
10419  /*%%%*/
10420  (yyval.node) = new_args(0, 0, 0, 0, 0);
10421  /*%
10422  $$ = params_new(Qnil, Qnil, Qnil, Qnil, Qnil);
10423  %*/
10424  }
10425  break;
10426 
10427  case 514:
10428 
10429 /* Line 1806 of yacc.c */
10430 #line 4509 "parse.y"
10431  {
10432  /*%%%*/
10433  yyerror("formal argument cannot be a constant");
10434  (yyval.id) = 0;
10435  /*%
10436  $$ = dispatch1(param_error, $1);
10437  %*/
10438  }
10439  break;
10440 
10441  case 515:
10442 
10443 /* Line 1806 of yacc.c */
10444 #line 4518 "parse.y"
10445  {
10446  /*%%%*/
10447  yyerror("formal argument cannot be an instance variable");
10448  (yyval.id) = 0;
10449  /*%
10450  $$ = dispatch1(param_error, $1);
10451  %*/
10452  }
10453  break;
10454 
10455  case 516:
10456 
10457 /* Line 1806 of yacc.c */
10458 #line 4527 "parse.y"
10459  {
10460  /*%%%*/
10461  yyerror("formal argument cannot be a global variable");
10462  (yyval.id) = 0;
10463  /*%
10464  $$ = dispatch1(param_error, $1);
10465  %*/
10466  }
10467  break;
10468 
10469  case 517:
10470 
10471 /* Line 1806 of yacc.c */
10472 #line 4536 "parse.y"
10473  {
10474  /*%%%*/
10475  yyerror("formal argument cannot be a class variable");
10476  (yyval.id) = 0;
10477  /*%
10478  $$ = dispatch1(param_error, $1);
10479  %*/
10480  }
10481  break;
10482 
10483  case 519:
10484 
10485 /* Line 1806 of yacc.c */
10486 #line 4548 "parse.y"
10487  {
10488  formal_argument(get_id((yyvsp[(1) - (1)].id)));
10489  (yyval.id) = (yyvsp[(1) - (1)].id);
10490  }
10491  break;
10492 
10493  case 520:
10494 
10495 /* Line 1806 of yacc.c */
10496 #line 4555 "parse.y"
10497  {
10498  arg_var(get_id((yyvsp[(1) - (1)].id)));
10499  /*%%%*/
10500  (yyval.node) = NEW_ARGS_AUX((yyvsp[(1) - (1)].id), 1);
10501  /*%
10502  $$ = get_value($1);
10503  %*/
10504  }
10505  break;
10506 
10507  case 521:
10508 
10509 /* Line 1806 of yacc.c */
10510 #line 4564 "parse.y"
10511  {
10512  ID tid = internal_id();
10513  arg_var(tid);
10514  /*%%%*/
10515  if (dyna_in_block()) {
10516  (yyvsp[(2) - (3)].node)->nd_value = NEW_DVAR(tid);
10517  }
10518  else {
10519  (yyvsp[(2) - (3)].node)->nd_value = NEW_LVAR(tid);
10520  }
10521  (yyval.node) = NEW_ARGS_AUX(tid, 1);
10522  (yyval.node)->nd_next = (yyvsp[(2) - (3)].node);
10523  /*%
10524  $$ = dispatch1(mlhs_paren, $2);
10525  %*/
10526  }
10527  break;
10528 
10529  case 523:
10530 
10531 /* Line 1806 of yacc.c */
10532 #line 4590 "parse.y"
10533  {
10534  /*%%%*/
10535  (yyval.node) = (yyvsp[(1) - (3)].node);
10536  (yyval.node)->nd_plen++;
10537  (yyval.node)->nd_next = block_append((yyval.node)->nd_next, (yyvsp[(3) - (3)].node)->nd_next);
10538  rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].node));
10539  /*%
10540  $$ = rb_ary_push($1, $3);
10541  %*/
10542  }
10543  break;
10544 
10545  case 524:
10546 
10547 /* Line 1806 of yacc.c */
10548 #line 4603 "parse.y"
10549  {
10550  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].id))));
10551  (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node));
10552  /*%%%*/
10553  (yyval.node) = NEW_OPT_ARG(0, (yyval.node));
10554  /*%
10555  $$ = rb_assoc_new($$, $3);
10556  %*/
10557  }
10558  break;
10559 
10560  case 525:
10561 
10562 /* Line 1806 of yacc.c */
10563 #line 4615 "parse.y"
10564  {
10565  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].id))));
10566  (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node));
10567  /*%%%*/
10568  (yyval.node) = NEW_OPT_ARG(0, (yyval.node));
10569  /*%
10570  $$ = rb_assoc_new($$, $3);
10571  %*/
10572  }
10573  break;
10574 
10575  case 526:
10576 
10577 /* Line 1806 of yacc.c */
10578 #line 4627 "parse.y"
10579  {
10580  /*%%%*/
10581  (yyval.node) = (yyvsp[(1) - (1)].node);
10582  /*%
10583  $$ = rb_ary_new3(1, $1);
10584  %*/
10585  }
10586  break;
10587 
10588  case 527:
10589 
10590 /* Line 1806 of yacc.c */
10591 #line 4635 "parse.y"
10592  {
10593  /*%%%*/
10594  NODE *opts = (yyvsp[(1) - (3)].node);
10595 
10596  while (opts->nd_next) {
10597  opts = opts->nd_next;
10598  }
10599  opts->nd_next = (yyvsp[(3) - (3)].node);
10600  (yyval.node) = (yyvsp[(1) - (3)].node);
10601  /*%
10602  $$ = rb_ary_push($1, $3);
10603  %*/
10604  }
10605  break;
10606 
10607  case 528:
10608 
10609 /* Line 1806 of yacc.c */
10610 #line 4651 "parse.y"
10611  {
10612  /*%%%*/
10613  (yyval.node) = (yyvsp[(1) - (1)].node);
10614  /*%
10615  $$ = rb_ary_new3(1, $1);
10616  %*/
10617  }
10618  break;
10619 
10620  case 529:
10621 
10622 /* Line 1806 of yacc.c */
10623 #line 4659 "parse.y"
10624  {
10625  /*%%%*/
10626  NODE *opts = (yyvsp[(1) - (3)].node);
10627 
10628  while (opts->nd_next) {
10629  opts = opts->nd_next;
10630  }
10631  opts->nd_next = (yyvsp[(3) - (3)].node);
10632  (yyval.node) = (yyvsp[(1) - (3)].node);
10633  /*%
10634  $$ = rb_ary_push($1, $3);
10635  %*/
10636  }
10637  break;
10638 
10639  case 532:
10640 
10641 /* Line 1806 of yacc.c */
10642 #line 4679 "parse.y"
10643  {
10644  /*%%%*/
10645  if (!is_local_id((yyvsp[(2) - (2)].id)))
10646  yyerror("rest argument must be local variable");
10647  /*% %*/
10648  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id))));
10649  /*%%%*/
10650  (yyval.id) = (yyvsp[(2) - (2)].id);
10651  /*%
10652  $$ = dispatch1(rest_param, $2);
10653  %*/
10654  }
10655  break;
10656 
10657  case 533:
10658 
10659 /* Line 1806 of yacc.c */
10660 #line 4692 "parse.y"
10661  {
10662  /*%%%*/
10663  (yyval.id) = internal_id();
10664  arg_var((yyval.id));
10665  /*%
10666  $$ = dispatch1(rest_param, Qnil);
10667  %*/
10668  }
10669  break;
10670 
10671  case 536:
10672 
10673 /* Line 1806 of yacc.c */
10674 #line 4707 "parse.y"
10675  {
10676  /*%%%*/
10677  if (!is_local_id((yyvsp[(2) - (2)].id)))
10678  yyerror("block argument must be local variable");
10679  else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].id)))
10680  yyerror("duplicated block argument name");
10681  /*% %*/
10682  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id))));
10683  /*%%%*/
10684  (yyval.id) = (yyvsp[(2) - (2)].id);
10685  /*%
10686  $$ = dispatch1(blockarg, $2);
10687  %*/
10688  }
10689  break;
10690 
10691  case 537:
10692 
10693 /* Line 1806 of yacc.c */
10694 #line 4724 "parse.y"
10695  {
10696  (yyval.id) = (yyvsp[(2) - (2)].id);
10697  }
10698  break;
10699 
10700  case 538:
10701 
10702 /* Line 1806 of yacc.c */
10703 #line 4728 "parse.y"
10704  {
10705  /*%%%*/
10706  (yyval.id) = 0;
10707  /*%
10708  $$ = Qundef;
10709  %*/
10710  }
10711  break;
10712 
10713  case 539:
10714 
10715 /* Line 1806 of yacc.c */
10716 #line 4738 "parse.y"
10717  {
10718  /*%%%*/
10719  value_expr((yyvsp[(1) - (1)].node));
10720  (yyval.node) = (yyvsp[(1) - (1)].node);
10721  if (!(yyval.node)) (yyval.node) = NEW_NIL();
10722  /*%
10723  $$ = $1;
10724  %*/
10725  }
10726  break;
10727 
10728  case 540:
10729 
10730 /* Line 1806 of yacc.c */
10731 #line 4747 "parse.y"
10732  {lex_state = EXPR_BEG;}
10733  break;
10734 
10735  case 541:
10736 
10737 /* Line 1806 of yacc.c */
10738 #line 4748 "parse.y"
10739  {
10740  /*%%%*/
10741  if ((yyvsp[(3) - (4)].node) == 0) {
10742  yyerror("can't define singleton method for ().");
10743  }
10744  else {
10745  switch (nd_type((yyvsp[(3) - (4)].node))) {
10746  case NODE_STR:
10747  case NODE_DSTR:
10748  case NODE_XSTR:
10749  case NODE_DXSTR:
10750  case NODE_DREGX:
10751  case NODE_LIT:
10752  case NODE_ARRAY:
10753  case NODE_ZARRAY:
10754  yyerror("can't define singleton method for literals");
10755  default:
10756  value_expr((yyvsp[(3) - (4)].node));
10757  break;
10758  }
10759  }
10760  (yyval.node) = (yyvsp[(3) - (4)].node);
10761  /*%
10762  $$ = dispatch1(paren, $3);
10763  %*/
10764  }
10765  break;
10766 
10767  case 543:
10768 
10769 /* Line 1806 of yacc.c */
10770 #line 4778 "parse.y"
10771  {
10772  /*%%%*/
10773  (yyval.node) = (yyvsp[(1) - (2)].node);
10774  /*%
10775  $$ = dispatch1(assoclist_from_args, $1);
10776  %*/
10777  }
10778  break;
10779 
10780  case 545:
10781 
10782 /* Line 1806 of yacc.c */
10783 #line 4795 "parse.y"
10784  {
10785  /*%%%*/
10786  (yyval.node) = list_concat((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
10787  /*%
10788  $$ = rb_ary_push($1, $3);
10789  %*/
10790  }
10791  break;
10792 
10793  case 546:
10794 
10795 /* Line 1806 of yacc.c */
10796 #line 4805 "parse.y"
10797  {
10798  /*%%%*/
10799  (yyval.node) = list_append(NEW_LIST((yyvsp[(1) - (3)].node)), (yyvsp[(3) - (3)].node));
10800  /*%
10801  $$ = dispatch2(assoc_new, $1, $3);
10802  %*/
10803  }
10804  break;
10805 
10806  case 547:
10807 
10808 /* Line 1806 of yacc.c */
10809 #line 4813 "parse.y"
10810  {
10811  /*%%%*/
10812  (yyval.node) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].id)))), (yyvsp[(2) - (2)].node));
10813  /*%
10814  $$ = dispatch2(assoc_new, $1, $2);
10815  %*/
10816  }
10817  break;
10818 
10819  case 569:
10820 
10821 /* Line 1806 of yacc.c */
10822 #line 4869 "parse.y"
10823  {yyerrok;}
10824  break;
10825 
10826  case 572:
10827 
10828 /* Line 1806 of yacc.c */
10829 #line 4874 "parse.y"
10830  {yyerrok;}
10831  break;
10832 
10833  case 573:
10834 
10835 /* Line 1806 of yacc.c */
10836 #line 4878 "parse.y"
10837  {
10838  /*%%%*/
10839  (yyval.node) = 0;
10840  /*%
10841  $$ = Qundef;
10842  %*/
10843  }
10844  break;
10845 
10846 
10847 
10848 /* Line 1806 of yacc.c */
10849 #line 10848 "parse.c"
10850  default: break;
10851  }
10852  /* User semantic actions sometimes alter yychar, and that requires
10853  that yytoken be updated with the new translation. We take the
10854  approach of translating immediately before every use of yytoken.
10855  One alternative is translating here after every semantic action,
10856  but that translation would be missed if the semantic action invokes
10857  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
10858  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
10859  incorrect destructor might then be invoked immediately. In the
10860  case of YYERROR or YYBACKUP, subsequent parser actions might lead
10861  to an incorrect destructor call or verbose syntax error message
10862  before the lookahead is translated. */
10863  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
10864 
10865  YYPOPSTACK (yylen);
10866  yylen = 0;
10867  YY_STACK_PRINT (yyss, yyssp);
10868 
10869  *++yyvsp = yyval;
10870 
10871  /* Now `shift' the result of the reduction. Determine what state
10872  that goes to, based on the state we popped back to and the rule
10873  number reduced by. */
10874 
10875  yyn = yyr1[yyn];
10876 
10877  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
10878  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
10879  yystate = yytable[yystate];
10880  else
10881  yystate = yydefgoto[yyn - YYNTOKENS];
10882 
10883  goto yynewstate;
10884 
10885 
10886 /*------------------------------------.
10887 | yyerrlab -- here on detecting error |
10888 `------------------------------------*/
10889 yyerrlab:
10890  /* Make sure we have latest lookahead translation. See comments at
10891  user semantic actions for why this is necessary. */
10892  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
10893 
10894  /* If not already recovering from an error, report this error. */
10895  if (!yyerrstatus)
10896  {
10897  ++yynerrs;
10898 #if ! YYERROR_VERBOSE
10899  parser_yyerror (parser, YY_("syntax error"));
10900 #else
10901 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
10902  yyssp, yytoken)
10903  {
10904  char const *yymsgp = YY_("syntax error");
10905  int yysyntax_error_status;
10906  yysyntax_error_status = YYSYNTAX_ERROR;
10907  if (yysyntax_error_status == 0)
10908  yymsgp = yymsg;
10909  else if (yysyntax_error_status == 1)
10910  {
10911  if (yymsg != yymsgbuf)
10912  YYSTACK_FREE (yymsg);
10913  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
10914  if (!yymsg)
10915  {
10916  yymsg = yymsgbuf;
10917  yymsg_alloc = sizeof yymsgbuf;
10918  yysyntax_error_status = 2;
10919  }
10920  else
10921  {
10922  yysyntax_error_status = YYSYNTAX_ERROR;
10923  yymsgp = yymsg;
10924  }
10925  }
10926  parser_yyerror (parser, yymsgp);
10927  if (yysyntax_error_status == 2)
10928  goto yyexhaustedlab;
10929  }
10930 # undef YYSYNTAX_ERROR
10931 #endif
10932  }
10933 
10934 
10935 
10936  if (yyerrstatus == 3)
10937  {
10938  /* If just tried and failed to reuse lookahead token after an
10939  error, discard it. */
10940 
10941  if (yychar <= YYEOF)
10942  {
10943  /* Return failure if at end of input. */
10944  if (yychar == YYEOF)
10945  YYABORT;
10946  }
10947  else
10948  {
10949  yydestruct ("Error: discarding",
10950  yytoken, &yylval, parser);
10951  yychar = YYEMPTY;
10952  }
10953  }
10954 
10955  /* Else will try to reuse lookahead token after shifting the error
10956  token. */
10957  goto yyerrlab1;
10958 
10959 
10960 /*---------------------------------------------------.
10961 | yyerrorlab -- error raised explicitly by YYERROR. |
10962 `---------------------------------------------------*/
10963 yyerrorlab:
10964 
10965  /* Pacify compilers like GCC when the user code never invokes
10966  YYERROR and the label yyerrorlab therefore never appears in user
10967  code. */
10968  if (/*CONSTCOND*/ 0)
10969  goto yyerrorlab;
10970 
10971  /* Do not reclaim the symbols of the rule which action triggered
10972  this YYERROR. */
10973  YYPOPSTACK (yylen);
10974  yylen = 0;
10975  YY_STACK_PRINT (yyss, yyssp);
10976  yystate = *yyssp;
10977  goto yyerrlab1;
10978 
10979 
10980 /*-------------------------------------------------------------.
10981 | yyerrlab1 -- common code for both syntax error and YYERROR. |
10982 `-------------------------------------------------------------*/
10983 yyerrlab1:
10984  yyerrstatus = 3; /* Each real token shifted decrements this. */
10985 
10986  for (;;)
10987  {
10988  yyn = yypact[yystate];
10989  if (!yypact_value_is_default (yyn))
10990  {
10991  yyn += YYTERROR;
10992  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
10993  {
10994  yyn = yytable[yyn];
10995  if (0 < yyn)
10996  break;
10997  }
10998  }
10999 
11000  /* Pop the current state because it cannot handle the error token. */
11001  if (yyssp == yyss)
11002  YYABORT;
11003 
11004 
11005  yydestruct ("Error: popping",
11006  yystos[yystate], yyvsp, parser);
11007  YYPOPSTACK (1);
11008  yystate = *yyssp;
11009  YY_STACK_PRINT (yyss, yyssp);
11010  }
11011 
11012  *++yyvsp = yylval;
11013 
11014 
11015  /* Shift the error token. */
11016  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11017 
11018  yystate = yyn;
11019  goto yynewstate;
11020 
11021 
11022 /*-------------------------------------.
11023 | yyacceptlab -- YYACCEPT comes here. |
11024 `-------------------------------------*/
11025 yyacceptlab:
11026  yyresult = 0;
11027  goto yyreturn;
11028 
11029 /*-----------------------------------.
11030 | yyabortlab -- YYABORT comes here. |
11031 `-----------------------------------*/
11032 yyabortlab:
11033  yyresult = 1;
11034  goto yyreturn;
11035 
11036 #if !defined(yyoverflow) || YYERROR_VERBOSE
11037 /*-------------------------------------------------.
11038 | yyexhaustedlab -- memory exhaustion comes here. |
11039 `-------------------------------------------------*/
11040 yyexhaustedlab:
11041  parser_yyerror (parser, YY_("memory exhausted"));
11042  yyresult = 2;
11043  /* Fall through. */
11044 #endif
11045 
11046 yyreturn:
11047  if (yychar != YYEMPTY)
11048  {
11049  /* Make sure we have latest lookahead translation. See comments at
11050  user semantic actions for why this is necessary. */
11051  yytoken = YYTRANSLATE (yychar);
11052  yydestruct ("Cleanup: discarding lookahead",
11053  yytoken, &yylval, parser);
11054  }
11055  /* Do not reclaim the symbols of the rule which action triggered
11056  this YYABORT or YYACCEPT. */
11057  YYPOPSTACK (yylen);
11058  YY_STACK_PRINT (yyss, yyssp);
11059  while (yyssp != yyss)
11060  {
11061  yydestruct ("Cleanup: popping",
11062  yystos[*yyssp], yyvsp, parser);
11063  YYPOPSTACK (1);
11064  }
11065 #ifndef yyoverflow
11066  if (yyss != yyssa)
11067  YYSTACK_FREE (yyss);
11068 #endif
11069 #if YYERROR_VERBOSE
11070  if (yymsg != yymsgbuf)
11071  YYSTACK_FREE (yymsg);
11072 #endif
11073  /* Make sure YYID is used. */
11074  return YYID (yyresult);
11075 }
11076 
11077 
11078 
11079 /* Line 2067 of yacc.c */
11080 #line 4886 "parse.y"
11081 
11082 # undef parser
11083 # undef yylex
11084 # undef yylval
11085 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
11086 
11087 static int parser_regx_options(struct parser_params*);
11088 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11089 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11090 static int parser_parse_string(struct parser_params*,NODE*);
11091 static int parser_here_document(struct parser_params*,NODE*);
11092 
11093 
11094 # define nextc() parser_nextc(parser)
11095 # define pushback(c) parser_pushback(parser, (c))
11096 # define newtok() parser_newtok(parser)
11097 # define tokspace(n) parser_tokspace(parser, (n))
11098 # define tokadd(c) parser_tokadd(parser, (c))
11099 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
11100 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
11101 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
11102 # define regx_options() parser_regx_options(parser)
11103 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11104 # define parse_string(n) parser_parse_string(parser,(n))
11105 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
11106 # define here_document(n) parser_here_document(parser,(n))
11107 # define heredoc_identifier() parser_heredoc_identifier(parser)
11108 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
11109 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
11110 
11111 #ifndef RIPPER
11112 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11113 # define set_yylval_num(x) (yylval.num = (x))
11114 # define set_yylval_id(x) (yylval.id = (x))
11115 # define set_yylval_name(x) (yylval.id = (x))
11116 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11117 # define set_yylval_node(x) (yylval.node = (x))
11118 # define yylval_id() (yylval.id)
11119 #else
11120 static inline VALUE
11121 ripper_yylval_id(ID x)
11122 {
11123  return (VALUE)NEW_LASGN(x, ID2SYM(x));
11124 }
11125 # define set_yylval_str(x) (void)(x)
11126 # define set_yylval_num(x) (void)(x)
11127 # define set_yylval_id(x) (void)(x)
11128 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11129 # define set_yylval_literal(x) (void)(x)
11130 # define set_yylval_node(x) (void)(x)
11131 # define yylval_id() yylval.id
11132 #endif
11133 
11134 #ifndef RIPPER
11135 #define ripper_flush(p) (void)(p)
11136 #else
11137 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11138 
11139 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11140 
11141 static int
11142 ripper_has_scan_event(struct parser_params *parser)
11143 {
11144 
11145  if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11146  return lex_p > parser->tokp;
11147 }
11148 
11149 static VALUE
11150 ripper_scan_event_val(struct parser_params *parser, int t)
11151 {
11152  VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11153  VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11154  ripper_flush(parser);
11155  return rval;
11156 }
11157 
11158 static void
11159 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11160 {
11161  if (!ripper_has_scan_event(parser)) return;
11162  yylval_rval = ripper_scan_event_val(parser, t);
11163 }
11164 
11165 static void
11166 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11167 {
11168  if (!ripper_has_scan_event(parser)) return;
11169  (void)ripper_scan_event_val(parser, t);
11170 }
11171 
11172 static void
11173 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11174 {
11175  int saved_line = ruby_sourceline;
11176  const char *saved_tokp = parser->tokp;
11177 
11178  ruby_sourceline = parser->delayed_line;
11179  parser->tokp = lex_pbeg + parser->delayed_col;
11180  yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11181  parser->delayed = Qnil;
11182  ruby_sourceline = saved_line;
11183  parser->tokp = saved_tokp;
11184 }
11185 #endif /* RIPPER */
11186 
11187 #include "ruby/regex.h"
11188 #include "ruby/util.h"
11189 
11190 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11191  since ours (we hope) works properly with all combinations of
11192  machines, compilers, `char' and `unsigned char' argument types.
11193  (Per Bothner suggested the basic approach.) */
11194 #undef SIGN_EXTEND_CHAR
11195 #if __STDC__
11196 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11197 #else /* not __STDC__ */
11198 /* As in Harbison and Steele. */
11199 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11200 #endif
11201 
11202 #define parser_encoding_name() (parser->enc->name)
11203 #define parser_mbclen() mbclen((lex_p-1),lex_pend,parser->enc)
11204 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,parser->enc)
11205 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11206 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,parser->enc))
11207 
11208 #define parser_isascii() ISASCII(*(lex_p-1))
11209 
11210 #ifndef RIPPER
11211 static int
11212 token_info_get_column(struct parser_params *parser, const char *token)
11213 {
11214  int column = 1;
11215  const char *p, *pend = lex_p - strlen(token);
11216  for (p = lex_pbeg; p < pend; p++) {
11217  if (*p == '\t') {
11218  column = (((column - 1) / 8) + 1) * 8;
11219  }
11220  column++;
11221  }
11222  return column;
11223 }
11224 
11225 static int
11226 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11227 {
11228  const char *p, *pend = lex_p - strlen(token);
11229  for (p = lex_pbeg; p < pend; p++) {
11230  if (*p != ' ' && *p != '\t') {
11231  return 1;
11232  }
11233  }
11234  return 0;
11235 }
11236 
11237 #undef token_info_push
11238 static void
11239 token_info_push(struct parser_params *parser, const char *token)
11240 {
11241  token_info *ptinfo;
11242 
11243  if (!parser->parser_token_info_enabled) return;
11244  ptinfo = ALLOC(token_info);
11245  ptinfo->token = token;
11246  ptinfo->linenum = ruby_sourceline;
11247  ptinfo->column = token_info_get_column(parser, token);
11248  ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11249  ptinfo->next = parser->parser_token_info;
11250 
11251  parser->parser_token_info = ptinfo;
11252 }
11253 
11254 #undef token_info_pop
11255 static void
11256 token_info_pop(struct parser_params *parser, const char *token)
11257 {
11258  int linenum;
11259  token_info *ptinfo = parser->parser_token_info;
11260 
11261  if (!ptinfo) return;
11262  parser->parser_token_info = ptinfo->next;
11263  if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11264  goto finish;
11265  }
11266  linenum = ruby_sourceline;
11267  if (linenum == ptinfo->linenum) { /* SKIP */
11268  goto finish;
11269  }
11270  if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11271  goto finish;
11272  }
11273  if (parser->parser_token_info_enabled) {
11275  "mismatched indentations at '%s' with '%s' at %d",
11276  token, ptinfo->token, ptinfo->linenum);
11277  }
11278 
11279  finish:
11280  xfree(ptinfo);
11281 }
11282 #endif /* RIPPER */
11283 
11284 static int
11285 parser_yyerror(struct parser_params *parser, const char *msg)
11286 {
11287 #ifndef RIPPER
11288  const int max_line_margin = 30;
11289  const char *p, *pe;
11290  char *buf;
11291  long len;
11292  int i;
11293 
11294  compile_error(PARSER_ARG "%s", msg);
11295  p = lex_p;
11296  while (lex_pbeg <= p) {
11297  if (*p == '\n') break;
11298  p--;
11299  }
11300  p++;
11301 
11302  pe = lex_p;
11303  while (pe < lex_pend) {
11304  if (*pe == '\n') break;
11305  pe++;
11306  }
11307 
11308  len = pe - p;
11309  if (len > 4) {
11310  char *p2;
11311  const char *pre = "", *post = "";
11312 
11313  if (len > max_line_margin * 2 + 10) {
11314  if (lex_p - p > max_line_margin) {
11315  p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11316  pre = "...";
11317  }
11318  if (pe - lex_p > max_line_margin) {
11319  pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11320  post = "...";
11321  }
11322  len = pe - p;
11323  }
11324  buf = ALLOCA_N(char, len+2);
11325  MEMCPY(buf, p, char, len);
11326  buf[len] = '\0';
11327  rb_compile_error_append("%s%s%s", pre, buf, post);
11328 
11329  i = (int)(lex_p - p);
11330  p2 = buf; pe = buf + len;
11331 
11332  while (p2 < pe) {
11333  if (*p2 != '\t') *p2 = ' ';
11334  p2++;
11335  }
11336  buf[i] = '^';
11337  buf[i+1] = '\0';
11338  rb_compile_error_append("%s%s", pre, buf);
11339  }
11340 #else
11341  dispatch1(parse_error, STR_NEW2(msg));
11342 #endif /* !RIPPER */
11343  return 0;
11344 }
11345 
11346 static void parser_prepare(struct parser_params *parser);
11347 
11348 #ifndef RIPPER
11349 static VALUE
11350 debug_lines(const char *f)
11351 {
11352  ID script_lines;
11353  CONST_ID(script_lines, "SCRIPT_LINES__");
11354  if (rb_const_defined_at(rb_cObject, script_lines)) {
11355  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11356  if (TYPE(hash) == T_HASH) {
11358  VALUE lines = rb_ary_new();
11359  rb_hash_aset(hash, fname, lines);
11360  return lines;
11361  }
11362  }
11363  return 0;
11364 }
11365 
11366 static VALUE
11367 coverage(const char *f, int n)
11368 {
11369  VALUE coverages = rb_get_coverages();
11370  if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11372  VALUE lines = rb_ary_new2(n);
11373  int i;
11374  RBASIC(lines)->klass = 0;
11375  for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11376  RARRAY(lines)->as.heap.len = n;
11377  rb_hash_aset(coverages, fname, lines);
11378  return lines;
11379  }
11380  return 0;
11381 }
11382 
11383 static int
11385 {
11386  return strcmp(ruby_sourcefile, "-e") == 0;
11387 }
11388 
11389 static VALUE
11390 yycompile0(VALUE arg, int tracing)
11391 {
11392  int n;
11393  NODE *tree;
11394  struct parser_params *parser = (struct parser_params *)arg;
11395 
11396  if (!compile_for_eval && rb_safe_level() == 0) {
11398  if (ruby_debug_lines && ruby_sourceline > 0) {
11399  VALUE str = STR_NEW0();
11400  n = ruby_sourceline;
11401  do {
11403  } while (--n);
11404  }
11405 
11406  if (!e_option_supplied(parser)) {
11408  }
11409  }
11410 
11411  parser_prepare(parser);
11412  deferred_nodes = 0;
11413 #ifndef RIPPER
11415 #endif
11416  n = yyparse((void*)parser);
11417  ruby_debug_lines = 0;
11418  ruby_coverage = 0;
11419  compile_for_eval = 0;
11420 
11421  lex_strterm = 0;
11422  lex_p = lex_pbeg = lex_pend = 0;
11423  lex_lastline = lex_nextline = 0;
11424  if (parser->nerr) {
11425  return 0;
11426  }
11427  tree = ruby_eval_tree;
11428  if (!tree) {
11429  tree = NEW_NIL();
11430  }
11431  else if (ruby_eval_tree_begin) {
11432  tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11433  }
11434  return (VALUE)tree;
11435 }
11436 
11437 static NODE*
11438 yycompile(struct parser_params *parser, const char *f, int line)
11439 {
11441  ruby_sourceline = line - 1;
11442  return (NODE *)ruby_suppress_tracing(yycompile0, (VALUE)parser, TRUE);
11443 }
11444 #endif /* !RIPPER */
11445 
11446 static rb_encoding *
11448 {
11449  rb_encoding *enc = rb_enc_get(s);
11450  if (!rb_enc_asciicompat(enc)) {
11451  rb_raise(rb_eArgError, "invalid source encoding");
11452  }
11453  return enc;
11454 }
11455 
11456 static VALUE
11457 lex_get_str(struct parser_params *parser, VALUE s)
11458 {
11459  char *beg, *end, *pend;
11461 
11462  beg = RSTRING_PTR(s);
11463  if (lex_gets_ptr) {
11464  if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11465  beg += lex_gets_ptr;
11466  }
11467  pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11468  end = beg;
11469  while (end < pend) {
11470  if (*end++ == '\n') break;
11471  }
11472  lex_gets_ptr = end - RSTRING_PTR(s);
11473  return rb_enc_str_new(beg, end - beg, enc);
11474 }
11475 
11476 static VALUE
11478 {
11479  VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11480  if (NIL_P(line)) return line;
11482 #ifndef RIPPER
11483  if (ruby_debug_lines) {
11484  rb_enc_associate(line, parser->enc);
11486  }
11487  if (ruby_coverage) {
11489  }
11490 #endif
11491  return line;
11492 }
11493 
11494 #ifdef RIPPER
11496 #else
11498 
11499 static NODE*
11500 parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11501 {
11502  struct parser_params *parser;
11503  NODE *node;
11504  volatile VALUE tmp;
11505 
11506  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11508  lex_gets_ptr = 0;
11509  lex_input = s;
11510  lex_pbeg = lex_p = lex_pend = 0;
11512 
11513  node = yycompile(parser, f, line);
11514  tmp = vparser; /* prohibit tail call optimization */
11515 
11516  return node;
11517 }
11518 
11519 NODE*
11520 rb_compile_string(const char *f, VALUE s, int line)
11521 {
11523  return parser_compile_string(rb_parser_new(), f, s, line);
11524 }
11525 
11526 NODE*
11527 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11528 {
11530  return parser_compile_string(vparser, f, s, line);
11531 }
11532 
11533 NODE*
11534 rb_compile_cstr(const char *f, const char *s, int len, int line)
11535 {
11536  VALUE str = rb_str_new(s, len);
11537  return parser_compile_string(rb_parser_new(), f, str, line);
11538 }
11539 
11540 NODE*
11541 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
11542 {
11543  VALUE str = rb_str_new(s, len);
11544  return parser_compile_string(vparser, f, str, line);
11545 }
11546 
11547 static VALUE
11548 lex_io_gets(struct parser_params *parser, VALUE io)
11549 {
11550  return rb_io_gets(io);
11551 }
11552 
11553 NODE*
11554 rb_compile_file(const char *f, VALUE file, int start)
11555 {
11556  VALUE volatile vparser = rb_parser_new();
11557 
11558  return rb_parser_compile_file(vparser, f, file, start);
11559 }
11560 
11561 NODE*
11562 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
11563 {
11564  struct parser_params *parser;
11565  volatile VALUE tmp;
11566  NODE *node;
11567 
11568  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11570  lex_input = file;
11571  lex_pbeg = lex_p = lex_pend = 0;
11573 
11574  node = yycompile(parser, f, start);
11575  tmp = vparser; /* prohibit tail call optimization */
11576 
11577  return node;
11578 }
11579 #endif /* !RIPPER */
11580 
11581 #define STR_FUNC_ESCAPE 0x01
11582 #define STR_FUNC_EXPAND 0x02
11583 #define STR_FUNC_REGEXP 0x04
11584 #define STR_FUNC_QWORDS 0x08
11585 #define STR_FUNC_SYMBOL 0x10
11586 #define STR_FUNC_INDENT 0x20
11587 
11589  str_squote = (0),
11597 };
11598 
11599 static VALUE
11600 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
11601 {
11602  VALUE str;
11603 
11604  str = rb_enc_str_new(p, n, enc);
11605  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
11607  }
11608  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
11610  }
11611  }
11612 
11613  return str;
11614 }
11615 
11616 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
11617 #define lex_eol_p() (lex_p >= lex_pend)
11618 #define peek(c) peek_n((c), 0)
11619 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
11620 
11621 static inline int
11623 {
11624  int c;
11625 
11626  if (lex_p == lex_pend) {
11627  VALUE v = lex_nextline;
11628  lex_nextline = 0;
11629  if (!v) {
11630  if (parser->eofp)
11631  return -1;
11632 
11633  if (!lex_input || NIL_P(v = lex_getline(parser))) {
11634  parser->eofp = Qtrue;
11635  lex_goto_eol(parser);
11636  return -1;
11637  }
11638  }
11639  {
11640 #ifdef RIPPER
11641  if (parser->tokp < lex_pend) {
11642  if (NIL_P(parser->delayed)) {
11643  parser->delayed = rb_str_buf_new(1024);
11644  rb_enc_associate(parser->delayed, parser->enc);
11645  rb_str_buf_cat(parser->delayed,
11646  parser->tokp, lex_pend - parser->tokp);
11647  parser->delayed_line = ruby_sourceline;
11648  parser->delayed_col = (int)(parser->tokp - lex_pbeg);
11649  }
11650  else {
11651  rb_str_buf_cat(parser->delayed,
11652  parser->tokp, lex_pend - parser->tokp);
11653  }
11654  }
11655 #endif
11656  if (heredoc_end > 0) {
11658  heredoc_end = 0;
11659  }
11660  ruby_sourceline++;
11661  parser->line_count++;
11662  lex_pbeg = lex_p = RSTRING_PTR(v);
11663  lex_pend = lex_p + RSTRING_LEN(v);
11664  ripper_flush(parser);
11665  lex_lastline = v;
11666  }
11667  }
11668  c = (unsigned char)*lex_p++;
11669  if (c == '\r' && peek('\n')) {
11670  lex_p++;
11671  c = '\n';
11672  }
11673 
11674  return c;
11675 }
11676 
11677 static void
11678 parser_pushback(struct parser_params *parser, int c)
11679 {
11680  if (c == -1) return;
11681  lex_p--;
11682  if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
11683  lex_p--;
11684  }
11685 }
11686 
11687 #define was_bol() (lex_p == lex_pbeg + 1)
11688 
11689 #define tokfix() (tokenbuf[tokidx]='\0')
11690 #define tok() tokenbuf
11691 #define toklen() tokidx
11692 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
11693 
11694 static char*
11696 {
11697  tokidx = 0;
11698  if (!tokenbuf) {
11699  toksiz = 60;
11700  tokenbuf = ALLOC_N(char, 60);
11701  }
11702  if (toksiz > 4096) {
11703  toksiz = 60;
11704  REALLOC_N(tokenbuf, char, 60);
11705  }
11706  return tokenbuf;
11707 }
11708 
11709 static char *
11710 parser_tokspace(struct parser_params *parser, int n)
11711 {
11712  tokidx += n;
11713 
11714  if (tokidx >= toksiz) {
11715  do {toksiz *= 2;} while (toksiz < tokidx);
11716  REALLOC_N(tokenbuf, char, toksiz);
11717  }
11718  return &tokenbuf[tokidx-n];
11719 }
11720 
11721 static void
11722 parser_tokadd(struct parser_params *parser, int c)
11723 {
11724  tokenbuf[tokidx++] = (char)c;
11725  if (tokidx >= toksiz) {
11726  toksiz *= 2;
11727  REALLOC_N(tokenbuf, char, toksiz);
11728  }
11729 }
11730 
11731 static int
11732 parser_tok_hex(struct parser_params *parser, size_t *numlen)
11733 {
11734  int c;
11735 
11736  c = scan_hex(lex_p, 2, numlen);
11737  if (!*numlen) {
11738  yyerror("invalid hex escape");
11739  return 0;
11740  }
11741  lex_p += *numlen;
11742  return c;
11743 }
11744 
11745 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
11746 
11747 static int
11749  int string_literal, int symbol_literal, int regexp_literal)
11750 {
11751  /*
11752  * If string_literal is true, then we allow multiple codepoints
11753  * in \u{}, and add the codepoints to the current token.
11754  * Otherwise we're parsing a character literal and return a single
11755  * codepoint without adding it
11756  */
11757 
11758  int codepoint;
11759  size_t numlen;
11760 
11761  if (regexp_literal) { tokadd('\\'); tokadd('u'); }
11762 
11763  if (peek('{')) { /* handle \u{...} form */
11764  do {
11765  if (regexp_literal) { tokadd(*lex_p); }
11766  nextc();
11767  codepoint = scan_hex(lex_p, 6, &numlen);
11768  if (numlen == 0) {
11769  yyerror("invalid Unicode escape");
11770  return 0;
11771  }
11772  if (codepoint > 0x10ffff) {
11773  yyerror("invalid Unicode codepoint (too large)");
11774  return 0;
11775  }
11776  lex_p += numlen;
11777  if (regexp_literal) {
11778  tokcopy((int)numlen);
11779  }
11780  else if (codepoint >= 0x80) {
11781  *encp = UTF8_ENC();
11782  if (string_literal) tokaddmbc(codepoint, *encp);
11783  }
11784  else if (string_literal) {
11785  tokadd(codepoint);
11786  }
11787  } while (string_literal && (peek(' ') || peek('\t')));
11788 
11789  if (!peek('}')) {
11790  yyerror("unterminated Unicode escape");
11791  return 0;
11792  }
11793 
11794  if (regexp_literal) { tokadd('}'); }
11795  nextc();
11796  }
11797  else { /* handle \uxxxx form */
11798  codepoint = scan_hex(lex_p, 4, &numlen);
11799  if (numlen < 4) {
11800  yyerror("invalid Unicode escape");
11801  return 0;
11802  }
11803  lex_p += 4;
11804  if (regexp_literal) {
11805  tokcopy(4);
11806  }
11807  else if (codepoint >= 0x80) {
11808  *encp = UTF8_ENC();
11809  if (string_literal) tokaddmbc(codepoint, *encp);
11810  }
11811  else if (string_literal) {
11812  tokadd(codepoint);
11813  }
11814  }
11815 
11816  return codepoint;
11817 }
11818 
11819 #define ESCAPE_CONTROL 1
11820 #define ESCAPE_META 2
11821 
11822 static int
11823 parser_read_escape(struct parser_params *parser, int flags,
11824  rb_encoding **encp)
11825 {
11826  int c;
11827  size_t numlen;
11828 
11829  switch (c = nextc()) {
11830  case '\\': /* Backslash */
11831  return c;
11832 
11833  case 'n': /* newline */
11834  return '\n';
11835 
11836  case 't': /* horizontal tab */
11837  return '\t';
11838 
11839  case 'r': /* carriage-return */
11840  return '\r';
11841 
11842  case 'f': /* form-feed */
11843  return '\f';
11844 
11845  case 'v': /* vertical tab */
11846  return '\13';
11847 
11848  case 'a': /* alarm(bell) */
11849  return '\007';
11850 
11851  case 'e': /* escape */
11852  return 033;
11853 
11854  case '0': case '1': case '2': case '3': /* octal constant */
11855  case '4': case '5': case '6': case '7':
11856  pushback(c);
11857  c = scan_oct(lex_p, 3, &numlen);
11858  lex_p += numlen;
11859  return c;
11860 
11861  case 'x': /* hex constant */
11862  c = tok_hex(&numlen);
11863  if (numlen == 0) return 0;
11864  return c;
11865 
11866  case 'b': /* backspace */
11867  return '\010';
11868 
11869  case 's': /* space */
11870  return ' ';
11871 
11872  case 'M':
11873  if (flags & ESCAPE_META) goto eof;
11874  if ((c = nextc()) != '-') {
11875  pushback(c);
11876  goto eof;
11877  }
11878  if ((c = nextc()) == '\\') {
11879  if (peek('u')) goto eof;
11880  return read_escape(flags|ESCAPE_META, encp) | 0x80;
11881  }
11882  else if (c == -1 || !ISASCII(c)) goto eof;
11883  else {
11884  return ((c & 0xff) | 0x80);
11885  }
11886 
11887  case 'C':
11888  if ((c = nextc()) != '-') {
11889  pushback(c);
11890  goto eof;
11891  }
11892  case 'c':
11893  if (flags & ESCAPE_CONTROL) goto eof;
11894  if ((c = nextc())== '\\') {
11895  if (peek('u')) goto eof;
11896  c = read_escape(flags|ESCAPE_CONTROL, encp);
11897  }
11898  else if (c == '?')
11899  return 0177;
11900  else if (c == -1 || !ISASCII(c)) goto eof;
11901  return c & 0x9f;
11902 
11903  eof:
11904  case -1:
11905  yyerror("Invalid escape character syntax");
11906  return '\0';
11907 
11908  default:
11909  return c;
11910  }
11911 }
11912 
11913 static void
11915 {
11916  int len = rb_enc_codelen(c, enc);
11917  rb_enc_mbcput(c, tokspace(len), enc);
11918 }
11919 
11920 static int
11922 {
11923  int c;
11924  int flags = 0;
11925  size_t numlen;
11926 
11927  first:
11928  switch (c = nextc()) {
11929  case '\n':
11930  return 0; /* just ignore */
11931 
11932  case '0': case '1': case '2': case '3': /* octal constant */
11933  case '4': case '5': case '6': case '7':
11934  {
11935  ruby_scan_oct(--lex_p, 3, &numlen);
11936  if (numlen == 0) goto eof;
11937  lex_p += numlen;
11938  tokcopy((int)numlen + 1);
11939  }
11940  return 0;
11941 
11942  case 'x': /* hex constant */
11943  {
11944  tok_hex(&numlen);
11945  if (numlen == 0) return -1;
11946  tokcopy((int)numlen + 2);
11947  }
11948  return 0;
11949 
11950  case 'M':
11951  if (flags & ESCAPE_META) goto eof;
11952  if ((c = nextc()) != '-') {
11953  pushback(c);
11954  goto eof;
11955  }
11956  tokcopy(3);
11957  flags |= ESCAPE_META;
11958  goto escaped;
11959 
11960  case 'C':
11961  if (flags & ESCAPE_CONTROL) goto eof;
11962  if ((c = nextc()) != '-') {
11963  pushback(c);
11964  goto eof;
11965  }
11966  tokcopy(3);
11967  goto escaped;
11968 
11969  case 'c':
11970  if (flags & ESCAPE_CONTROL) goto eof;
11971  tokcopy(2);
11972  flags |= ESCAPE_CONTROL;
11973  escaped:
11974  if ((c = nextc()) == '\\') {
11975  goto first;
11976  }
11977  else if (c == -1) goto eof;
11978  tokadd(c);
11979  return 0;
11980 
11981  eof:
11982  case -1:
11983  yyerror("Invalid escape character syntax");
11984  return -1;
11985 
11986  default:
11987  tokadd('\\');
11988  tokadd(c);
11989  }
11990  return 0;
11991 }
11992 
11993 static int
11995 {
11996  int kcode = 0;
11997  int kopt = 0;
11998  int options = 0;
11999  int c, opt, kc;
12000 
12001  newtok();
12002  while (c = nextc(), ISALPHA(c)) {
12003  if (c == 'o') {
12004  options |= RE_OPTION_ONCE;
12005  }
12006  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12007  if (kc >= 0) {
12008  if (kc != rb_ascii8bit_encindex()) kcode = c;
12009  kopt = opt;
12010  }
12011  else {
12012  options |= opt;
12013  }
12014  }
12015  else {
12016  tokadd(c);
12017  }
12018  }
12019  options |= kopt;
12020  pushback(c);
12021  if (toklen()) {
12022  tokfix();
12023  compile_error(PARSER_ARG "unknown regexp option%s - %s",
12024  toklen() > 1 ? "s" : "", tok());
12025  }
12026  return options | RE_OPTION_ENCODING(kcode);
12027 }
12028 
12029 static void
12031 {
12032  /* TODO: should use another API? */
12033  if (RBASIC(str)->flags & RSTRING_NOEMBED)
12034  xfree(RSTRING_PTR(str));
12035  rb_gc_force_recycle(str);
12036 }
12037 
12038 static int
12039 parser_tokadd_mbchar(struct parser_params *parser, int c)
12040 {
12041  int len = parser_precise_mbclen();
12042  if (!MBCLEN_CHARFOUND_P(len)) {
12043  compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12044  return -1;
12045  }
12046  tokadd(c);
12047  lex_p += --len;
12048  if (len > 0) tokcopy(len);
12049  return c;
12050 }
12051 
12052 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12053 
12054 static int
12056  int func, int term, int paren, long *nest,
12057  rb_encoding **encp)
12058 {
12059  int c;
12060  int has_nonascii = 0;
12061  rb_encoding *enc = *encp;
12062  char *errbuf = 0;
12063  static const char mixed_msg[] = "%s mixed within %s source";
12064 
12065 #define mixed_error(enc1, enc2) if (!errbuf) { \
12066  size_t len = sizeof(mixed_msg) - 4; \
12067  len += strlen(rb_enc_name(enc1)); \
12068  len += strlen(rb_enc_name(enc2)); \
12069  errbuf = ALLOCA_N(char, len); \
12070  snprintf(errbuf, len, mixed_msg, \
12071  rb_enc_name(enc1), \
12072  rb_enc_name(enc2)); \
12073  yyerror(errbuf); \
12074  }
12075 #define mixed_escape(beg, enc1, enc2) do { \
12076  const char *pos = lex_p; \
12077  lex_p = (beg); \
12078  mixed_error((enc1), (enc2)); \
12079  lex_p = pos; \
12080  } while (0)
12081 
12082  while ((c = nextc()) != -1) {
12083  if (paren && c == paren) {
12084  ++*nest;
12085  }
12086  else if (c == term) {
12087  if (!nest || !*nest) {
12088  pushback(c);
12089  break;
12090  }
12091  --*nest;
12092  }
12093  else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12094  int c2 = *lex_p;
12095  if (c2 == '$' || c2 == '@' || c2 == '{') {
12096  pushback(c);
12097  break;
12098  }
12099  }
12100  else if (c == '\\') {
12101  const char *beg = lex_p - 1;
12102  c = nextc();
12103  switch (c) {
12104  case '\n':
12105  if (func & STR_FUNC_QWORDS) break;
12106  if (func & STR_FUNC_EXPAND) continue;
12107  tokadd('\\');
12108  break;
12109 
12110  case '\\':
12111  if (func & STR_FUNC_ESCAPE) tokadd(c);
12112  break;
12113 
12114  case 'u':
12115  if ((func & STR_FUNC_EXPAND) == 0) {
12116  tokadd('\\');
12117  break;
12118  }
12119  parser_tokadd_utf8(parser, &enc, 1,
12120  func & STR_FUNC_SYMBOL,
12121  func & STR_FUNC_REGEXP);
12122  if (has_nonascii && enc != *encp) {
12123  mixed_escape(beg, enc, *encp);
12124  }
12125  continue;
12126 
12127  default:
12128  if (c == -1) return -1;
12129  if (!ISASCII(c)) {
12130  if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12131  goto non_ascii;
12132  }
12133  if (func & STR_FUNC_REGEXP) {
12134  pushback(c);
12135  if ((c = tokadd_escape(&enc)) < 0)
12136  return -1;
12137  if (has_nonascii && enc != *encp) {
12138  mixed_escape(beg, enc, *encp);
12139  }
12140  continue;
12141  }
12142  else if (func & STR_FUNC_EXPAND) {
12143  pushback(c);
12144  if (func & STR_FUNC_ESCAPE) tokadd('\\');
12145  c = read_escape(0, &enc);
12146  }
12147  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12148  /* ignore backslashed spaces in %w */
12149  }
12150  else if (c != term && !(paren && c == paren)) {
12151  tokadd('\\');
12152  pushback(c);
12153  continue;
12154  }
12155  }
12156  }
12157  else if (!parser_isascii()) {
12158  non_ascii:
12159  has_nonascii = 1;
12160  if (enc != *encp) {
12161  mixed_error(enc, *encp);
12162  continue;
12163  }
12164  if (tokadd_mbchar(c) == -1) return -1;
12165  continue;
12166  }
12167  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12168  pushback(c);
12169  break;
12170  }
12171  if (c & 0x80) {
12172  has_nonascii = 1;
12173  if (enc != *encp) {
12174  mixed_error(enc, *encp);
12175  continue;
12176  }
12177  }
12178  tokadd(c);
12179  }
12180  *encp = enc;
12181  return c;
12182 }
12183 
12184 #define NEW_STRTERM(func, term, paren) \
12185  rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12186 
12187 #ifdef RIPPER
12188 static void
12189 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12190 {
12191  if (!NIL_P(parser->delayed)) {
12192  ptrdiff_t len = lex_p - parser->tokp;
12193  if (len > 0) {
12194  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12195  }
12196  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12197  parser->tokp = lex_p;
12198  }
12199 }
12200 
12201 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12202 #else
12203 #define flush_string_content(enc) ((void)(enc))
12204 #endif
12205 
12206 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12207 /* this can be shared with ripper, since it's independent from struct
12208  * parser_params. */
12209 #ifndef RIPPER
12210 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12211 #define SPECIAL_PUNCT(idx) ( \
12212  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12213  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12214  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12215  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12216  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12217  BIT('0', idx))
12218 const unsigned int ruby_global_name_punct_bits[] = {
12219  SPECIAL_PUNCT(0),
12220  SPECIAL_PUNCT(1),
12221  SPECIAL_PUNCT(2),
12222 };
12223 #undef BIT
12224 #undef SPECIAL_PUNCT
12225 #endif
12226 
12227 static inline int
12229 {
12230  if (c <= 0x20 || 0x7e < c) return 0;
12231  return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12232 }
12233 
12234 static int
12236 {
12237  int c;
12238  const char *p = lex_p;
12239 
12240  if (p + 1 >= lex_pend) return 0;
12241  c = *p++;
12242  switch (c) {
12243  case '$':
12244  if ((c = *p) == '-') {
12245  if (++p >= lex_pend) return 0;
12246  c = *p;
12247  }
12248  else if (is_global_name_punct(c) || ISDIGIT(c)) {
12249  return tSTRING_DVAR;
12250  }
12251  break;
12252  case '@':
12253  if ((c = *p) == '@') {
12254  if (++p >= lex_pend) return 0;
12255  c = *p;
12256  }
12257  break;
12258  case '{':
12259  lex_p = p;
12260  command_start = TRUE;
12261  return tSTRING_DBEG;
12262  default:
12263  return 0;
12264  }
12265  if (!ISASCII(c) || c == '_' || ISALPHA(c))
12266  return tSTRING_DVAR;
12267  return 0;
12268 }
12269 
12270 static int
12271 parser_parse_string(struct parser_params *parser, NODE *quote)
12272 {
12273  int func = (int)quote->nd_func;
12274  int term = nd_term(quote);
12275  int paren = nd_paren(quote);
12276  int c, space = 0;
12277  rb_encoding *enc = parser->enc;
12278 
12279  if (func == -1) return tSTRING_END;
12280  c = nextc();
12281  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12282  do {c = nextc();} while (ISSPACE(c));
12283  space = 1;
12284  }
12285  if (c == term && !quote->nd_nest) {
12286  if (func & STR_FUNC_QWORDS) {
12287  quote->nd_func = -1;
12288  return ' ';
12289  }
12290  if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12292  return tREGEXP_END;
12293  }
12294  if (space) {
12295  pushback(c);
12296  return ' ';
12297  }
12298  newtok();
12299  if ((func & STR_FUNC_EXPAND) && c == '#') {
12300  int t = parser_peek_variable_name(parser);
12301  if (t) return t;
12302  tokadd('#');
12303  c = nextc();
12304  }
12305  pushback(c);
12306  if (tokadd_string(func, term, paren, &quote->nd_nest,
12307  &enc) == -1) {
12308  ruby_sourceline = nd_line(quote);
12309  if (func & STR_FUNC_REGEXP) {
12310  if (parser->eofp)
12311  compile_error(PARSER_ARG "unterminated regexp meets end of file");
12312  return tREGEXP_END;
12313  }
12314  else {
12315  if (parser->eofp)
12316  compile_error(PARSER_ARG "unterminated string meets end of file");
12317  return tSTRING_END;
12318  }
12319  }
12320 
12321  tokfix();
12322  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12323  flush_string_content(enc);
12324 
12325  return tSTRING_CONTENT;
12326 }
12327 
12328 static int
12330 {
12331  int c = nextc(), term, func = 0;
12332  long len;
12333 
12334  if (c == '-') {
12335  c = nextc();
12336  func = STR_FUNC_INDENT;
12337  }
12338  switch (c) {
12339  case '\'':
12340  func |= str_squote; goto quoted;
12341  case '"':
12342  func |= str_dquote; goto quoted;
12343  case '`':
12344  func |= str_xquote;
12345  quoted:
12346  newtok();
12347  tokadd(func);
12348  term = c;
12349  while ((c = nextc()) != -1 && c != term) {
12350  if (tokadd_mbchar(c) == -1) return 0;
12351  }
12352  if (c == -1) {
12353  compile_error(PARSER_ARG "unterminated here document identifier");
12354  return 0;
12355  }
12356  break;
12357 
12358  default:
12359  if (!parser_is_identchar()) {
12360  pushback(c);
12361  if (func & STR_FUNC_INDENT) {
12362  pushback('-');
12363  }
12364  return 0;
12365  }
12366  newtok();
12367  term = '"';
12368  tokadd(func |= str_dquote);
12369  do {
12370  if (tokadd_mbchar(c) == -1) return 0;
12371  } while ((c = nextc()) != -1 && parser_is_identchar());
12372  pushback(c);
12373  break;
12374  }
12375 
12376  tokfix();
12377 #ifdef RIPPER
12378  ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12379 #endif
12380  len = lex_p - lex_pbeg;
12381  lex_goto_eol(parser);
12383  STR_NEW(tok(), toklen()), /* nd_lit */
12384  len, /* nd_nth */
12385  lex_lastline); /* nd_orig */
12387  ripper_flush(parser);
12388  return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12389 }
12390 
12391 static void
12393 {
12394  VALUE line;
12395 
12396  line = here->nd_orig;
12397  lex_lastline = line;
12398  lex_pbeg = RSTRING_PTR(line);
12399  lex_pend = lex_pbeg + RSTRING_LEN(line);
12400  lex_p = lex_pbeg + here->nd_nth;
12402  ruby_sourceline = nd_line(here);
12403  dispose_string(here->nd_lit);
12404  rb_gc_force_recycle((VALUE)here);
12405  ripper_flush(parser);
12406 }
12407 
12408 static int
12410  const char *eos, long len, int indent)
12411 {
12412  const char *p = lex_pbeg;
12413  long n;
12414 
12415  if (indent) {
12416  while (*p && ISSPACE(*p)) p++;
12417  }
12418  n = lex_pend - (p + len);
12419  if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12420  return strncmp(eos, p, len) == 0;
12421 }
12422 
12423 #ifdef RIPPER
12424 static void
12425 ripper_dispatch_heredoc_end(struct parser_params *parser)
12426 {
12427  if (!NIL_P(parser->delayed))
12428  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12429  lex_goto_eol(parser);
12430  ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12431 }
12432 
12433 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12434 #else
12435 #define dispatch_heredoc_end() ((void)0)
12436 #endif
12437 
12438 static int
12440 {
12441  int c, func, indent = 0;
12442  const char *eos, *p, *pend;
12443  long len;
12444  VALUE str = 0;
12445  rb_encoding *enc = parser->enc;
12446 
12447  eos = RSTRING_PTR(here->nd_lit);
12448  len = RSTRING_LEN(here->nd_lit) - 1;
12449  indent = (func = *eos++) & STR_FUNC_INDENT;
12450 
12451  if ((c = nextc()) == -1) {
12452  error:
12453  compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12454 #ifdef RIPPER
12455  if (NIL_P(parser->delayed)) {
12456  ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12457  }
12458  else {
12459  if (str ||
12460  ((len = lex_p - parser->tokp) > 0 &&
12461  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12462  rb_str_append(parser->delayed, str);
12463  }
12464  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12465  }
12466  lex_goto_eol(parser);
12467 #endif
12468  restore:
12470  lex_strterm = 0;
12471  return 0;
12472  }
12473  if (was_bol() && whole_match_p(eos, len, indent)) {
12476  return tSTRING_END;
12477  }
12478 
12479  if (!(func & STR_FUNC_EXPAND)) {
12480  do {
12482  pend = lex_pend;
12483  if (pend > p) {
12484  switch (pend[-1]) {
12485  case '\n':
12486  if (--pend == p || pend[-1] != '\r') {
12487  pend++;
12488  break;
12489  }
12490  case '\r':
12491  --pend;
12492  }
12493  }
12494  if (str)
12495  rb_str_cat(str, p, pend - p);
12496  else
12497  str = STR_NEW(p, pend - p);
12498  if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12499  lex_goto_eol(parser);
12500  if (nextc() == -1) {
12501  if (str) dispose_string(str);
12502  goto error;
12503  }
12504  } while (!whole_match_p(eos, len, indent));
12505  }
12506  else {
12507  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12508  newtok();
12509  if (c == '#') {
12510  int t = parser_peek_variable_name(parser);
12511  if (t) return t;
12512  tokadd('#');
12513  c = nextc();
12514  }
12515  do {
12516  pushback(c);
12517  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
12518  if (parser->eofp) goto error;
12519  goto restore;
12520  }
12521  if (c != '\n') {
12522  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12523  flush_string_content(enc);
12524  return tSTRING_CONTENT;
12525  }
12526  tokadd(nextc());
12527  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
12528  if ((c = nextc()) == -1) goto error;
12529  } while (!whole_match_p(eos, len, indent));
12530  str = STR_NEW3(tok(), toklen(), enc, func);
12531  }
12534  lex_strterm = NEW_STRTERM(-1, 0, 0);
12535  set_yylval_str(str);
12536  return tSTRING_CONTENT;
12537 }
12538 
12539 #include "lex.c"
12540 
12541 static void
12543 {
12544 #ifndef RIPPER
12545  rb_warning0("ambiguous first argument; put parentheses or even spaces");
12546 #else
12548 #endif
12549 }
12550 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
12551 
12552 static ID
12554 {
12555 #ifndef RIPPER
12556  if (!is_local_id(lhs))
12557  yyerror("formal argument must be local variable");
12558 #endif
12559  shadowing_lvar(lhs);
12560  return lhs;
12561 }
12562 
12563 static int
12564 lvar_defined_gen(struct parser_params *parser, ID id)
12565 {
12566  return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
12567 }
12568 
12569 /* emacsen -*- hack */
12570 static long
12571 parser_encode_length(struct parser_params *parser, const char *name, long len)
12572 {
12573  long nlen;
12574 
12575  if (len > 5 && name[nlen = len - 5] == '-') {
12576  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
12577  return nlen;
12578  }
12579  if (len > 4 && name[nlen = len - 4] == '-') {
12580  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
12581  return nlen;
12582  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
12583  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
12584  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
12585  return nlen;
12586  }
12587  return len;
12588 }
12589 
12590 static void
12591 parser_set_encode(struct parser_params *parser, const char *name)
12592 {
12593  int idx = rb_enc_find_index(name);
12594  rb_encoding *enc;
12595  VALUE excargs[3];
12596 
12597  if (idx < 0) {
12598  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
12599  error:
12600  excargs[0] = rb_eArgError;
12601  excargs[2] = rb_make_backtrace();
12602  rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
12603  rb_exc_raise(rb_make_exception(3, excargs));
12604  }
12605  enc = rb_enc_from_index(idx);
12606  if (!rb_enc_asciicompat(enc)) {
12607  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
12608  goto error;
12609  }
12610  parser->enc = enc;
12611 #ifndef RIPPER
12612  if (ruby_debug_lines) {
12613  long i, n = RARRAY_LEN(ruby_debug_lines);
12614  const VALUE *p = RARRAY_PTR(ruby_debug_lines);
12615  for (i = 0; i < n; ++i) {
12616  rb_enc_associate_index(*p, idx);
12617  }
12618  }
12619 #endif
12620 }
12621 
12622 static int
12624 {
12625  const char *p = lex_pbeg, *pend = lex_p - 1;
12626  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
12627  while (p < pend) {
12628  if (!ISSPACE(*p)) return 0;
12629  p++;
12630  }
12631  return 1;
12632 }
12633 
12634 #ifndef RIPPER
12635 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
12636 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
12637 
12638 static void
12639 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
12640 {
12641  if (!comment_at_top(parser)) {
12642  return;
12643  }
12644  parser_set_encode(parser, val);
12645 }
12646 
12647 static void
12648 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
12649 {
12650  int *p = &parser->parser_token_info_enabled;
12651 
12652  switch (*val) {
12653  case 't': case 'T':
12654  if (strcasecmp(val, "true") == 0) {
12655  *p = TRUE;
12656  return;
12657  }
12658  break;
12659  case 'f': case 'F':
12660  if (strcasecmp(val, "false") == 0) {
12661  *p = FALSE;
12662  return;
12663  }
12664  break;
12665  }
12666  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
12667 }
12668 
12669 struct magic_comment {
12670  const char *name;
12673 };
12674 
12675 static const struct magic_comment magic_comments[] = {
12678  {"warn_indent", parser_set_token_info},
12679 };
12680 #endif
12681 
12682 static const char *
12683 magic_comment_marker(const char *str, long len)
12684 {
12685  long i = 2;
12686 
12687  while (i < len) {
12688  switch (str[i]) {
12689  case '-':
12690  if (str[i-1] == '*' && str[i-2] == '-') {
12691  return str + i + 1;
12692  }
12693  i += 2;
12694  break;
12695  case '*':
12696  if (i + 1 >= len) return 0;
12697  if (str[i+1] != '-') {
12698  i += 4;
12699  }
12700  else if (str[i-1] != '-') {
12701  i += 2;
12702  }
12703  else {
12704  return str + i + 2;
12705  }
12706  break;
12707  default:
12708  i += 3;
12709  break;
12710  }
12711  }
12712  return 0;
12713 }
12714 
12715 static int
12716 parser_magic_comment(struct parser_params *parser, const char *str, long len)
12717 {
12718  VALUE name = 0, val = 0;
12719  const char *beg, *end, *vbeg, *vend;
12720 #define str_copy(_s, _p, _n) ((_s) \
12721  ? (void)(rb_str_resize((_s), (_n)), \
12722  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
12723  : (void)((_s) = STR_NEW((_p), (_n))))
12724 
12725  if (len <= 7) return FALSE;
12726  if (!(beg = magic_comment_marker(str, len))) return FALSE;
12727  if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
12728  str = beg;
12729  len = end - beg - 3;
12730 
12731  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
12732  while (len > 0) {
12733 #ifndef RIPPER
12734  const struct magic_comment *p = magic_comments;
12735 #endif
12736  char *s;
12737  int i;
12738  long n = 0;
12739 
12740  for (; len > 0 && *str; str++, --len) {
12741  switch (*str) {
12742  case '\'': case '"': case ':': case ';':
12743  continue;
12744  }
12745  if (!ISSPACE(*str)) break;
12746  }
12747  for (beg = str; len > 0; str++, --len) {
12748  switch (*str) {
12749  case '\'': case '"': case ':': case ';':
12750  break;
12751  default:
12752  if (ISSPACE(*str)) break;
12753  continue;
12754  }
12755  break;
12756  }
12757  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
12758  if (!len) break;
12759  if (*str != ':') continue;
12760 
12761  do str++; while (--len > 0 && ISSPACE(*str));
12762  if (!len) break;
12763  if (*str == '"') {
12764  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
12765  if (*str == '\\') {
12766  --len;
12767  ++str;
12768  }
12769  }
12770  vend = str;
12771  if (len) {
12772  --len;
12773  ++str;
12774  }
12775  }
12776  else {
12777  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
12778  vend = str;
12779  }
12780  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
12781 
12782  n = end - beg;
12783  str_copy(name, beg, n);
12784  s = RSTRING_PTR(name);
12785  for (i = 0; i < n; ++i) {
12786  if (s[i] == '-') s[i] = '_';
12787  }
12788 #ifndef RIPPER
12789  do {
12790  if (STRNCASECMP(p->name, s, n) == 0) {
12791  n = vend - vbeg;
12792  if (p->length) {
12793  n = (*p->length)(parser, vbeg, n);
12794  }
12795  str_copy(val, vbeg, n);
12796  (*p->func)(parser, s, RSTRING_PTR(val));
12797  break;
12798  }
12799  } while (++p < magic_comments + numberof(magic_comments));
12800 #else
12801  str_copy(val, vbeg, vend - vbeg);
12802  dispatch2(magic_comment, name, val);
12803 #endif
12804  }
12805 
12806  return TRUE;
12807 }
12808 
12809 static void
12810 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
12811 {
12812  int sep = 0;
12813  const char *beg = str;
12814  VALUE s;
12815 
12816  for (;;) {
12817  if (send - str <= 6) return;
12818  switch (str[6]) {
12819  case 'C': case 'c': str += 6; continue;
12820  case 'O': case 'o': str += 5; continue;
12821  case 'D': case 'd': str += 4; continue;
12822  case 'I': case 'i': str += 3; continue;
12823  case 'N': case 'n': str += 2; continue;
12824  case 'G': case 'g': str += 1; continue;
12825  case '=': case ':':
12826  sep = 1;
12827  str += 6;
12828  break;
12829  default:
12830  str += 6;
12831  if (ISSPACE(*str)) break;
12832  continue;
12833  }
12834  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
12835  }
12836  for (;;) {
12837  do {
12838  if (++str >= send) return;
12839  } while (ISSPACE(*str));
12840  if (sep) break;
12841  if (*str != '=' && *str != ':') return;
12842  sep = 1;
12843  str++;
12844  }
12845  beg = str;
12846  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
12847  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
12848  parser_set_encode(parser, RSTRING_PTR(s));
12849  rb_str_resize(s, 0);
12850 }
12851 
12852 static void
12854 {
12855  int c = nextc();
12856  switch (c) {
12857  case '#':
12858  if (peek('!')) parser->has_shebang = 1;
12859  break;
12860  case 0xef: /* UTF-8 BOM marker */
12861  if (lex_pend - lex_p >= 2 &&
12862  (unsigned char)lex_p[0] == 0xbb &&
12863  (unsigned char)lex_p[1] == 0xbf) {
12864  parser->enc = rb_utf8_encoding();
12865  lex_p += 2;
12866  lex_pbeg = lex_p;
12867  return;
12868  }
12869  break;
12870  case EOF:
12871  return;
12872  }
12873  pushback(c);
12874  parser->enc = rb_enc_get(lex_lastline);
12875 }
12876 
12877 #define IS_ARG() (lex_state == EXPR_ARG || lex_state == EXPR_CMDARG)
12878 #define IS_END() (lex_state == EXPR_END || lex_state == EXPR_ENDARG || lex_state == EXPR_ENDFN)
12879 #define IS_BEG() (lex_state == EXPR_BEG || lex_state == EXPR_MID || lex_state == EXPR_VALUE || lex_state == EXPR_CLASS)
12880 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
12881 #define IS_LABEL_POSSIBLE() ((lex_state == EXPR_BEG && !cmd_state) || IS_ARG())
12882 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
12883 
12884 #ifndef RIPPER
12885 #define ambiguous_operator(op, syn) ( \
12886  rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
12887  rb_warning0("even though it seems like "syn""))
12888 #else
12889 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
12890 #endif
12891 #define warn_balanced(op, syn) ((void) \
12892  (last_state != EXPR_CLASS && last_state != EXPR_DOT && \
12893  last_state != EXPR_FNAME && last_state != EXPR_ENDFN && \
12894  last_state != EXPR_ENDARG && \
12895  space_seen && !ISSPACE(c) && \
12896  (ambiguous_operator(op, syn), 0)))
12897 
12898 static int
12900 {
12901  register int c;
12902  int space_seen = 0;
12903  int cmd_state;
12904  enum lex_state_e last_state;
12905  rb_encoding *enc;
12906  int mb;
12907 #ifdef RIPPER
12908  int fallthru = FALSE;
12909 #endif
12910 
12911  if (lex_strterm) {
12912  int token;
12913  if (nd_type(lex_strterm) == NODE_HEREDOC) {
12914  token = here_document(lex_strterm);
12915  if (token == tSTRING_END) {
12916  lex_strterm = 0;
12917  lex_state = EXPR_END;
12918  }
12919  }
12920  else {
12921  token = parse_string(lex_strterm);
12922  if (token == tSTRING_END || token == tREGEXP_END) {
12924  lex_strterm = 0;
12925  lex_state = EXPR_END;
12926  }
12927  }
12928  return token;
12929  }
12930  cmd_state = command_start;
12931  command_start = FALSE;
12932  retry:
12933  last_state = lex_state;
12934  switch (c = nextc()) {
12935  case '\0': /* NUL */
12936  case '\004': /* ^D */
12937  case '\032': /* ^Z */
12938  case -1: /* end of script. */
12939  return 0;
12940 
12941  /* white spaces */
12942  case ' ': case '\t': case '\f': case '\r':
12943  case '\13': /* '\v' */
12944  space_seen = 1;
12945 #ifdef RIPPER
12946  while ((c = nextc())) {
12947  switch (c) {
12948  case ' ': case '\t': case '\f': case '\r':
12949  case '\13': /* '\v' */
12950  break;
12951  default:
12952  goto outofloop;
12953  }
12954  }
12955  outofloop:
12956  pushback(c);
12957  ripper_dispatch_scan_event(parser, tSP);
12958 #endif
12959  goto retry;
12960 
12961  case '#': /* it's a comment */
12962  /* no magic_comment in shebang line */
12963  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
12964  if (comment_at_top(parser)) {
12965  set_file_encoding(parser, lex_p, lex_pend);
12966  }
12967  }
12968  lex_p = lex_pend;
12969 #ifdef RIPPER
12970  ripper_dispatch_scan_event(parser, tCOMMENT);
12971  fallthru = TRUE;
12972 #endif
12973  /* fall through */
12974  case '\n':
12975  switch (lex_state) {
12976  case EXPR_BEG:
12977  case EXPR_FNAME:
12978  case EXPR_DOT:
12979  case EXPR_CLASS:
12980  case EXPR_VALUE:
12981 #ifdef RIPPER
12982  if (!fallthru) {
12983  ripper_dispatch_scan_event(parser, tIGNORED_NL);
12984  }
12985  fallthru = FALSE;
12986 #endif
12987  goto retry;
12988  default:
12989  break;
12990  }
12991  while ((c = nextc())) {
12992  switch (c) {
12993  case ' ': case '\t': case '\f': case '\r':
12994  case '\13': /* '\v' */
12995  space_seen = 1;
12996  break;
12997  case '.': {
12998  if ((c = nextc()) != '.') {
12999  pushback(c);
13000  pushback('.');
13001  goto retry;
13002  }
13003  }
13004  default:
13005  --ruby_sourceline;
13007  case -1: /* EOF no decrement*/
13008  lex_goto_eol(parser);
13009 #ifdef RIPPER
13010  if (c != -1) {
13011  parser->tokp = lex_p;
13012  }
13013 #endif
13014  goto normal_newline;
13015  }
13016  }
13017  normal_newline:
13018  command_start = TRUE;
13019  lex_state = EXPR_BEG;
13020  return '\n';
13021 
13022  case '*':
13023  if ((c = nextc()) == '*') {
13024  if ((c = nextc()) == '=') {
13026  lex_state = EXPR_BEG;
13027  return tOP_ASGN;
13028  }
13029  pushback(c);
13030  c = tPOW;
13031  }
13032  else {
13033  if (c == '=') {
13034  set_yylval_id('*');
13035  lex_state = EXPR_BEG;
13036  return tOP_ASGN;
13037  }
13038  pushback(c);
13039  if (IS_SPCARG(c)) {
13040  rb_warning0("`*' interpreted as argument prefix");
13041  c = tSTAR;
13042  }
13043  else if (IS_BEG()) {
13044  c = tSTAR;
13045  }
13046  else {
13047  warn_balanced("*", "argument prefix");
13048  c = '*';
13049  }
13050  }
13051  switch (lex_state) {
13052  case EXPR_FNAME: case EXPR_DOT:
13053  lex_state = EXPR_ARG; break;
13054  default:
13055  lex_state = EXPR_BEG; break;
13056  }
13057  return c;
13058 
13059  case '!':
13060  c = nextc();
13061  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13062  lex_state = EXPR_ARG;
13063  if (c == '@') {
13064  return '!';
13065  }
13066  }
13067  else {
13068  lex_state = EXPR_BEG;
13069  }
13070  if (c == '=') {
13071  return tNEQ;
13072  }
13073  if (c == '~') {
13074  return tNMATCH;
13075  }
13076  pushback(c);
13077  return '!';
13078 
13079  case '=':
13080  if (was_bol()) {
13081  /* skip embedded rd document */
13082  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13083 #ifdef RIPPER
13084  int first_p = TRUE;
13085 
13086  lex_goto_eol(parser);
13087  ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13088 #endif
13089  for (;;) {
13090  lex_goto_eol(parser);
13091 #ifdef RIPPER
13092  if (!first_p) {
13093  ripper_dispatch_scan_event(parser, tEMBDOC);
13094  }
13095  first_p = FALSE;
13096 #endif
13097  c = nextc();
13098  if (c == -1) {
13099  compile_error(PARSER_ARG "embedded document meets end of file");
13100  return 0;
13101  }
13102  if (c != '=') continue;
13103  if (strncmp(lex_p, "end", 3) == 0 &&
13104  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13105  break;
13106  }
13107  }
13108  lex_goto_eol(parser);
13109 #ifdef RIPPER
13110  ripper_dispatch_scan_event(parser, tEMBDOC_END);
13111 #endif
13112  goto retry;
13113  }
13114  }
13115 
13116  switch (lex_state) {
13117  case EXPR_FNAME: case EXPR_DOT:
13118  lex_state = EXPR_ARG; break;
13119  default:
13120  lex_state = EXPR_BEG; break;
13121  }
13122  if ((c = nextc()) == '=') {
13123  if ((c = nextc()) == '=') {
13124  return tEQQ;
13125  }
13126  pushback(c);
13127  return tEQ;
13128  }
13129  if (c == '~') {
13130  return tMATCH;
13131  }
13132  else if (c == '>') {
13133  return tASSOC;
13134  }
13135  pushback(c);
13136  return '=';
13137 
13138  case '<':
13139  last_state = lex_state;
13140  c = nextc();
13141  if (c == '<' &&
13142  lex_state != EXPR_DOT &&
13143  lex_state != EXPR_CLASS &&
13144  !IS_END() &&
13145  (!IS_ARG() || space_seen)) {
13146  int token = heredoc_identifier();
13147  if (token) return token;
13148  }
13149  switch (lex_state) {
13150  case EXPR_FNAME: case EXPR_DOT:
13151  lex_state = EXPR_ARG; break;
13152  default:
13153  lex_state = EXPR_BEG; break;
13154  }
13155  if (c == '=') {
13156  if ((c = nextc()) == '>') {
13157  return tCMP;
13158  }
13159  pushback(c);
13160  return tLEQ;
13161  }
13162  if (c == '<') {
13163  if ((c = nextc()) == '=') {
13165  lex_state = EXPR_BEG;
13166  return tOP_ASGN;
13167  }
13168  pushback(c);
13169  warn_balanced("<<", "here document");
13170  return tLSHFT;
13171  }
13172  pushback(c);
13173  return '<';
13174 
13175  case '>':
13176  switch (lex_state) {
13177  case EXPR_FNAME: case EXPR_DOT:
13178  lex_state = EXPR_ARG; break;
13179  default:
13180  lex_state = EXPR_BEG; break;
13181  }
13182  if ((c = nextc()) == '=') {
13183  return tGEQ;
13184  }
13185  if (c == '>') {
13186  if ((c = nextc()) == '=') {
13188  lex_state = EXPR_BEG;
13189  return tOP_ASGN;
13190  }
13191  pushback(c);
13192  return tRSHFT;
13193  }
13194  pushback(c);
13195  return '>';
13196 
13197  case '"':
13198  lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13199  return tSTRING_BEG;
13200 
13201  case '`':
13202  if (lex_state == EXPR_FNAME) {
13204  return c;
13205  }
13206  if (lex_state == EXPR_DOT) {
13207  if (cmd_state)
13209  else
13210  lex_state = EXPR_ARG;
13211  return c;
13212  }
13213  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13214  return tXSTRING_BEG;
13215 
13216  case '\'':
13217  lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13218  return tSTRING_BEG;
13219 
13220  case '?':
13221  if (IS_END()) {
13223  return '?';
13224  }
13225  c = nextc();
13226  if (c == -1) {
13227  compile_error(PARSER_ARG "incomplete character syntax");
13228  return 0;
13229  }
13230  if (rb_enc_isspace(c, parser->enc)) {
13231  if (!IS_ARG()) {
13232  int c2 = 0;
13233  switch (c) {
13234  case ' ':
13235  c2 = 's';
13236  break;
13237  case '\n':
13238  c2 = 'n';
13239  break;
13240  case '\t':
13241  c2 = 't';
13242  break;
13243  case '\v':
13244  c2 = 'v';
13245  break;
13246  case '\r':
13247  c2 = 'r';
13248  break;
13249  case '\f':
13250  c2 = 'f';
13251  break;
13252  }
13253  if (c2) {
13254  rb_warnI("invalid character syntax; use ?\\%c", c2);
13255  }
13256  }
13257  ternary:
13258  pushback(c);
13260  return '?';
13261  }
13262  newtok();
13263  enc = parser->enc;
13264  if (!parser_isascii()) {
13265  if (tokadd_mbchar(c) == -1) return 0;
13266  }
13267  else if ((rb_enc_isalnum(c, parser->enc) || c == '_') &&
13268  lex_p < lex_pend && is_identchar(lex_p, lex_pend, parser->enc)) {
13269  goto ternary;
13270  }
13271  else if (c == '\\') {
13272  if (peek('u')) {
13273  nextc();
13274  c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13275  if (0x80 <= c) {
13276  tokaddmbc(c, enc);
13277  }
13278  else {
13279  tokadd(c);
13280  }
13281  }
13282  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13283  nextc();
13284  if (tokadd_mbchar(c) == -1) return 0;
13285  }
13286  else {
13287  c = read_escape(0, &enc);
13288  tokadd(c);
13289  }
13290  }
13291  else {
13292  tokadd(c);
13293  }
13294  tokfix();
13295  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13296  lex_state = EXPR_END;
13297  return tCHAR;
13298 
13299  case '&':
13300  if ((c = nextc()) == '&') {
13301  lex_state = EXPR_BEG;
13302  if ((c = nextc()) == '=') {
13304  lex_state = EXPR_BEG;
13305  return tOP_ASGN;
13306  }
13307  pushback(c);
13308  return tANDOP;
13309  }
13310  else if (c == '=') {
13311  set_yylval_id('&');
13312  lex_state = EXPR_BEG;
13313  return tOP_ASGN;
13314  }
13315  pushback(c);
13316  if (IS_SPCARG(c)) {
13317  rb_warning0("`&' interpreted as argument prefix");
13318  c = tAMPER;
13319  }
13320  else if (IS_BEG()) {
13321  c = tAMPER;
13322  }
13323  else {
13324  warn_balanced("&", "argument prefix");
13325  c = '&';
13326  }
13327  switch (lex_state) {
13328  case EXPR_FNAME: case EXPR_DOT:
13329  lex_state = EXPR_ARG; break;
13330  default:
13331  lex_state = EXPR_BEG;
13332  }
13333  return c;
13334 
13335  case '|':
13336  if ((c = nextc()) == '|') {
13337  lex_state = EXPR_BEG;
13338  if ((c = nextc()) == '=') {
13340  lex_state = EXPR_BEG;
13341  return tOP_ASGN;
13342  }
13343  pushback(c);
13344  return tOROP;
13345  }
13346  if (c == '=') {
13347  set_yylval_id('|');
13348  lex_state = EXPR_BEG;
13349  return tOP_ASGN;
13350  }
13351  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13352  lex_state = EXPR_ARG;
13353  }
13354  else {
13355  lex_state = EXPR_BEG;
13356  }
13357  pushback(c);
13358  return '|';
13359 
13360  case '+':
13361  c = nextc();
13362  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13363  lex_state = EXPR_ARG;
13364  if (c == '@') {
13365  return tUPLUS;
13366  }
13367  pushback(c);
13368  return '+';
13369  }
13370  if (c == '=') {
13371  set_yylval_id('+');
13372  lex_state = EXPR_BEG;
13373  return tOP_ASGN;
13374  }
13375  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13376  lex_state = EXPR_BEG;
13377  pushback(c);
13378  if (c != -1 && ISDIGIT(c)) {
13379  c = '+';
13380  goto start_num;
13381  }
13382  return tUPLUS;
13383  }
13384  lex_state = EXPR_BEG;
13385  pushback(c);
13386  warn_balanced("+", "unary operator");
13387  return '+';
13388 
13389  case '-':
13390  c = nextc();
13391  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13392  lex_state = EXPR_ARG;
13393  if (c == '@') {
13394  return tUMINUS;
13395  }
13396  pushback(c);
13397  return '-';
13398  }
13399  if (c == '=') {
13400  set_yylval_id('-');
13401  lex_state = EXPR_BEG;
13402  return tOP_ASGN;
13403  }
13404  if (c == '>') {
13405  lex_state = EXPR_ARG;
13406  return tLAMBDA;
13407  }
13408  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13409  lex_state = EXPR_BEG;
13410  pushback(c);
13411  if (c != -1 && ISDIGIT(c)) {
13412  return tUMINUS_NUM;
13413  }
13414  return tUMINUS;
13415  }
13416  lex_state = EXPR_BEG;
13417  pushback(c);
13418  warn_balanced("-", "unary operator");
13419  return '-';
13420 
13421  case '.':
13422  lex_state = EXPR_BEG;
13423  if ((c = nextc()) == '.') {
13424  if ((c = nextc()) == '.') {
13425  return tDOT3;
13426  }
13427  pushback(c);
13428  return tDOT2;
13429  }
13430  pushback(c);
13431  if (c != -1 && ISDIGIT(c)) {
13432  yyerror("no .<digit> floating literal anymore; put 0 before dot");
13433  }
13434  lex_state = EXPR_DOT;
13435  return '.';
13436 
13437  start_num:
13438  case '0': case '1': case '2': case '3': case '4':
13439  case '5': case '6': case '7': case '8': case '9':
13440  {
13441  int is_float, seen_point, seen_e, nondigit;
13442 
13443  is_float = seen_point = seen_e = nondigit = 0;
13444  lex_state = EXPR_END;
13445  newtok();
13446  if (c == '-' || c == '+') {
13447  tokadd(c);
13448  c = nextc();
13449  }
13450  if (c == '0') {
13451 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13452  int start = toklen();
13453  c = nextc();
13454  if (c == 'x' || c == 'X') {
13455  /* hexadecimal */
13456  c = nextc();
13457  if (c != -1 && ISXDIGIT(c)) {
13458  do {
13459  if (c == '_') {
13460  if (nondigit) break;
13461  nondigit = c;
13462  continue;
13463  }
13464  if (!ISXDIGIT(c)) break;
13465  nondigit = 0;
13466  tokadd(c);
13467  } while ((c = nextc()) != -1);
13468  }
13469  pushback(c);
13470  tokfix();
13471  if (toklen() == start) {
13472  no_digits();
13473  }
13474  else if (nondigit) goto trailing_uc;
13476  return tINTEGER;
13477  }
13478  if (c == 'b' || c == 'B') {
13479  /* binary */
13480  c = nextc();
13481  if (c == '0' || c == '1') {
13482  do {
13483  if (c == '_') {
13484  if (nondigit) break;
13485  nondigit = c;
13486  continue;
13487  }
13488  if (c != '0' && c != '1') break;
13489  nondigit = 0;
13490  tokadd(c);
13491  } while ((c = nextc()) != -1);
13492  }
13493  pushback(c);
13494  tokfix();
13495  if (toklen() == start) {
13496  no_digits();
13497  }
13498  else if (nondigit) goto trailing_uc;
13500  return tINTEGER;
13501  }
13502  if (c == 'd' || c == 'D') {
13503  /* decimal */
13504  c = nextc();
13505  if (c != -1 && ISDIGIT(c)) {
13506  do {
13507  if (c == '_') {
13508  if (nondigit) break;
13509  nondigit = c;
13510  continue;
13511  }
13512  if (!ISDIGIT(c)) break;
13513  nondigit = 0;
13514  tokadd(c);
13515  } while ((c = nextc()) != -1);
13516  }
13517  pushback(c);
13518  tokfix();
13519  if (toklen() == start) {
13520  no_digits();
13521  }
13522  else if (nondigit) goto trailing_uc;
13524  return tINTEGER;
13525  }
13526  if (c == '_') {
13527  /* 0_0 */
13528  goto octal_number;
13529  }
13530  if (c == 'o' || c == 'O') {
13531  /* prefixed octal */
13532  c = nextc();
13533  if (c == -1 || c == '_' || !ISDIGIT(c)) {
13534  no_digits();
13535  }
13536  }
13537  if (c >= '0' && c <= '7') {
13538  /* octal */
13539  octal_number:
13540  do {
13541  if (c == '_') {
13542  if (nondigit) break;
13543  nondigit = c;
13544  continue;
13545  }
13546  if (c < '0' || c > '9') break;
13547  if (c > '7') goto invalid_octal;
13548  nondigit = 0;
13549  tokadd(c);
13550  } while ((c = nextc()) != -1);
13551  if (toklen() > start) {
13552  pushback(c);
13553  tokfix();
13554  if (nondigit) goto trailing_uc;
13556  return tINTEGER;
13557  }
13558  if (nondigit) {
13559  pushback(c);
13560  goto trailing_uc;
13561  }
13562  }
13563  if (c > '7' && c <= '9') {
13564  invalid_octal:
13565  yyerror("Invalid octal digit");
13566  }
13567  else if (c == '.' || c == 'e' || c == 'E') {
13568  tokadd('0');
13569  }
13570  else {
13571  pushback(c);
13573  return tINTEGER;
13574  }
13575  }
13576 
13577  for (;;) {
13578  switch (c) {
13579  case '0': case '1': case '2': case '3': case '4':
13580  case '5': case '6': case '7': case '8': case '9':
13581  nondigit = 0;
13582  tokadd(c);
13583  break;
13584 
13585  case '.':
13586  if (nondigit) goto trailing_uc;
13587  if (seen_point || seen_e) {
13588  goto decode_num;
13589  }
13590  else {
13591  int c0 = nextc();
13592  if (c0 == -1 || !ISDIGIT(c0)) {
13593  pushback(c0);
13594  goto decode_num;
13595  }
13596  c = c0;
13597  }
13598  tokadd('.');
13599  tokadd(c);
13600  is_float++;
13601  seen_point++;
13602  nondigit = 0;
13603  break;
13604 
13605  case 'e':
13606  case 'E':
13607  if (nondigit) {
13608  pushback(c);
13609  c = nondigit;
13610  goto decode_num;
13611  }
13612  if (seen_e) {
13613  goto decode_num;
13614  }
13615  tokadd(c);
13616  seen_e++;
13617  is_float++;
13618  nondigit = c;
13619  c = nextc();
13620  if (c != '-' && c != '+') continue;
13621  tokadd(c);
13622  nondigit = c;
13623  break;
13624 
13625  case '_': /* `_' in number just ignored */
13626  if (nondigit) goto decode_num;
13627  nondigit = c;
13628  break;
13629 
13630  default:
13631  goto decode_num;
13632  }
13633  c = nextc();
13634  }
13635 
13636  decode_num:
13637  pushback(c);
13638  if (nondigit) {
13639  char tmp[30];
13640  trailing_uc:
13641  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
13642  yyerror(tmp);
13643  }
13644  tokfix();
13645  if (is_float) {
13646  double d = strtod(tok(), 0);
13647  if (errno == ERANGE) {
13648  rb_warningS("Float %s out of range", tok());
13649  errno = 0;
13650  }
13652  return tFLOAT;
13653  }
13655  return tINTEGER;
13656  }
13657 
13658  case ')':
13659  case ']':
13660  paren_nest--;
13661  case '}':
13662  COND_LEXPOP();
13663  CMDARG_LEXPOP();
13664  if (c == ')')
13666  else
13668  return c;
13669 
13670  case ':':
13671  c = nextc();
13672  if (c == ':') {
13673  if (IS_BEG() || lex_state == EXPR_CLASS || IS_SPCARG(-1)) {
13674  lex_state = EXPR_BEG;
13675  return tCOLON3;
13676  }
13677  lex_state = EXPR_DOT;
13678  return tCOLON2;
13679  }
13680  if (IS_END() || ISSPACE(c)) {
13681  pushback(c);
13682  warn_balanced(":", "symbol literal");
13683  lex_state = EXPR_BEG;
13684  return ':';
13685  }
13686  switch (c) {
13687  case '\'':
13688  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
13689  break;
13690  case '"':
13691  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
13692  break;
13693  default:
13694  pushback(c);
13695  break;
13696  }
13698  return tSYMBEG;
13699 
13700  case '/':
13701  if (IS_BEG()) {
13702  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13703  return tREGEXP_BEG;
13704  }
13705  if ((c = nextc()) == '=') {
13706  set_yylval_id('/');
13707  lex_state = EXPR_BEG;
13708  return tOP_ASGN;
13709  }
13710  pushback(c);
13711  if (IS_SPCARG(c)) {
13712  (void)arg_ambiguous();
13713  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
13714  return tREGEXP_BEG;
13715  }
13716  switch (lex_state) {
13717  case EXPR_FNAME: case EXPR_DOT:
13718  lex_state = EXPR_ARG; break;
13719  default:
13720  lex_state = EXPR_BEG; break;
13721  }
13722  warn_balanced("/", "regexp literal");
13723  return '/';
13724 
13725  case '^':
13726  if ((c = nextc()) == '=') {
13727  set_yylval_id('^');
13728  lex_state = EXPR_BEG;
13729  return tOP_ASGN;
13730  }
13731  switch (lex_state) {
13732  case EXPR_FNAME: case EXPR_DOT:
13733  lex_state = EXPR_ARG; break;
13734  default:
13735  lex_state = EXPR_BEG; break;
13736  }
13737  pushback(c);
13738  return '^';
13739 
13740  case ';':
13741  lex_state = EXPR_BEG;
13742  command_start = TRUE;
13743  return ';';
13744 
13745  case ',':
13746  lex_state = EXPR_BEG;
13747  return ',';
13748 
13749  case '~':
13750  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13751  if ((c = nextc()) != '@') {
13752  pushback(c);
13753  }
13754  lex_state = EXPR_ARG;
13755  }
13756  else {
13757  lex_state = EXPR_BEG;
13758  }
13759  return '~';
13760 
13761  case '(':
13762  if (IS_BEG()) {
13763  c = tLPAREN;
13764  }
13765  else if (IS_SPCARG(-1)) {
13766  c = tLPAREN_ARG;
13767  }
13768  paren_nest++;
13769  COND_PUSH(0);
13770  CMDARG_PUSH(0);
13771  lex_state = EXPR_BEG;
13772  return c;
13773 
13774  case '[':
13775  paren_nest++;
13776  if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
13777  lex_state = EXPR_ARG;
13778  if ((c = nextc()) == ']') {
13779  if ((c = nextc()) == '=') {
13780  return tASET;
13781  }
13782  pushback(c);
13783  return tAREF;
13784  }
13785  pushback(c);
13786  return '[';
13787  }
13788  else if (IS_BEG()) {
13789  c = tLBRACK;
13790  }
13791  else if (IS_ARG() && space_seen) {
13792  c = tLBRACK;
13793  }
13794  lex_state = EXPR_BEG;
13795  COND_PUSH(0);
13796  CMDARG_PUSH(0);
13797  return c;
13798 
13799  case '{':
13800  if (lpar_beg && lpar_beg == paren_nest) {
13801  lex_state = EXPR_BEG;
13802  lpar_beg = 0;
13803  --paren_nest;
13804  COND_PUSH(0);
13805  CMDARG_PUSH(0);
13806  return tLAMBEG;
13807  }
13808  if (IS_ARG() || lex_state == EXPR_END || lex_state == EXPR_ENDFN)
13809  c = '{'; /* block (primary) */
13810  else if (lex_state == EXPR_ENDARG)
13811  c = tLBRACE_ARG; /* block (expr) */
13812  else
13813  c = tLBRACE; /* hash */
13814  COND_PUSH(0);
13815  CMDARG_PUSH(0);
13816  lex_state = EXPR_BEG;
13817  if (c != tLBRACE) command_start = TRUE;
13818  return c;
13819 
13820  case '\\':
13821  c = nextc();
13822  if (c == '\n') {
13823  space_seen = 1;
13824 #ifdef RIPPER
13825  ripper_dispatch_scan_event(parser, tSP);
13826 #endif
13827  goto retry; /* skip \\n */
13828  }
13829  pushback(c);
13830  return '\\';
13831 
13832  case '%':
13833  if (IS_BEG()) {
13834  int term;
13835  int paren;
13836 
13837  c = nextc();
13838  quotation:
13839  if (c == -1 || !ISALNUM(c)) {
13840  term = c;
13841  c = 'Q';
13842  }
13843  else {
13844  term = nextc();
13845  if (rb_enc_isalnum(term, parser->enc) || !parser_isascii()) {
13846  yyerror("unknown type of %string");
13847  return 0;
13848  }
13849  }
13850  if (c == -1 || term == -1) {
13851  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
13852  return 0;
13853  }
13854  paren = term;
13855  if (term == '(') term = ')';
13856  else if (term == '[') term = ']';
13857  else if (term == '{') term = '}';
13858  else if (term == '<') term = '>';
13859  else paren = 0;
13860 
13861  switch (c) {
13862  case 'Q':
13863  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
13864  return tSTRING_BEG;
13865 
13866  case 'q':
13867  lex_strterm = NEW_STRTERM(str_squote, term, paren);
13868  return tSTRING_BEG;
13869 
13870  case 'W':
13871  lex_strterm = NEW_STRTERM(str_dword, term, paren);
13872  do {c = nextc();} while (ISSPACE(c));
13873  pushback(c);
13874  return tWORDS_BEG;
13875 
13876  case 'w':
13877  lex_strterm = NEW_STRTERM(str_sword, term, paren);
13878  do {c = nextc();} while (ISSPACE(c));
13879  pushback(c);
13880  return tQWORDS_BEG;
13881 
13882  case 'x':
13883  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
13884  return tXSTRING_BEG;
13885 
13886  case 'r':
13887  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
13888  return tREGEXP_BEG;
13889 
13890  case 's':
13891  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
13893  return tSYMBEG;
13894 
13895  default:
13896  yyerror("unknown type of %string");
13897  return 0;
13898  }
13899  }
13900  if ((c = nextc()) == '=') {
13901  set_yylval_id('%');
13902  lex_state = EXPR_BEG;
13903  return tOP_ASGN;
13904  }
13905  if (IS_SPCARG(c)) {
13906  goto quotation;
13907  }
13908  switch (lex_state) {
13909  case EXPR_FNAME: case EXPR_DOT:
13910  lex_state = EXPR_ARG; break;
13911  default:
13912  lex_state = EXPR_BEG; break;
13913  }
13914  pushback(c);
13915  warn_balanced("%%", "string literal");
13916  return '%';
13917 
13918  case '$':
13919  lex_state = EXPR_END;
13920  newtok();
13921  c = nextc();
13922  switch (c) {
13923  case '_': /* $_: last read line string */
13924  c = nextc();
13925  if (parser_is_identchar()) {
13926  tokadd('$');
13927  tokadd('_');
13928  break;
13929  }
13930  pushback(c);
13931  c = '_';
13932  /* fall through */
13933  case '~': /* $~: match-data */
13934  case '*': /* $*: argv */
13935  case '$': /* $$: pid */
13936  case '?': /* $?: last status */
13937  case '!': /* $!: error string */
13938  case '@': /* $@: error position */
13939  case '/': /* $/: input record separator */
13940  case '\\': /* $\: output record separator */
13941  case ';': /* $;: field separator */
13942  case ',': /* $,: output field separator */
13943  case '.': /* $.: last read line number */
13944  case '=': /* $=: ignorecase */
13945  case ':': /* $:: load path */
13946  case '<': /* $<: reading filename */
13947  case '>': /* $>: default output handle */
13948  case '\"': /* $": already loaded files */
13949  tokadd('$');
13950  tokadd(c);
13951  tokfix();
13953  return tGVAR;
13954 
13955  case '-':
13956  tokadd('$');
13957  tokadd(c);
13958  c = nextc();
13959  if (parser_is_identchar()) {
13960  if (tokadd_mbchar(c) == -1) return 0;
13961  }
13962  else {
13963  pushback(c);
13964  }
13965  gvar:
13966  tokfix();
13968  return tGVAR;
13969 
13970  case '&': /* $&: last match */
13971  case '`': /* $`: string before last match */
13972  case '\'': /* $': string after last match */
13973  case '+': /* $+: string matches last paren. */
13974  if (last_state == EXPR_FNAME) {
13975  tokadd('$');
13976  tokadd(c);
13977  goto gvar;
13978  }
13980  return tBACK_REF;
13981 
13982  case '1': case '2': case '3':
13983  case '4': case '5': case '6':
13984  case '7': case '8': case '9':
13985  tokadd('$');
13986  do {
13987  tokadd(c);
13988  c = nextc();
13989  } while (c != -1 && ISDIGIT(c));
13990  pushback(c);
13991  if (last_state == EXPR_FNAME) goto gvar;
13992  tokfix();
13993  set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
13994  return tNTH_REF;
13995 
13996  default:
13997  if (!parser_is_identchar()) {
13998  pushback(c);
13999  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14000  return 0;
14001  }
14002  case '0':
14003  tokadd('$');
14004  }
14005  break;
14006 
14007  case '@':
14008  c = nextc();
14009  newtok();
14010  tokadd('@');
14011  if (c == '@') {
14012  tokadd('@');
14013  c = nextc();
14014  }
14015  if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14016  pushback(c);
14017  if (tokidx == 1) {
14018  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14019  }
14020  else {
14021  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14022  }
14023  return 0;
14024  }
14025  break;
14026 
14027  case '_':
14028  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14029  ruby__end__seen = 1;
14030  parser->eofp = Qtrue;
14031 #ifndef RIPPER
14032  return -1;
14033 #else
14034  lex_goto_eol(parser);
14035  ripper_dispatch_scan_event(parser, k__END__);
14036  return 0;
14037 #endif
14038  }
14039  newtok();
14040  break;
14041 
14042  default:
14043  if (!parser_is_identchar()) {
14044  rb_compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14045  goto retry;
14046  }
14047 
14048  newtok();
14049  break;
14050  }
14051 
14052  mb = ENC_CODERANGE_7BIT;
14053  do {
14054  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14055  if (tokadd_mbchar(c) == -1) return 0;
14056  c = nextc();
14057  } while (parser_is_identchar());
14058  switch (tok()[0]) {
14059  case '@': case '$':
14060  pushback(c);
14061  break;
14062  default:
14063  if ((c == '!' || c == '?') && !peek('=')) {
14064  tokadd(c);
14065  }
14066  else {
14067  pushback(c);
14068  }
14069  }
14070  tokfix();
14071 
14072  {
14073  int result = 0;
14074 
14075  last_state = lex_state;
14076  switch (tok()[0]) {
14077  case '$':
14078  lex_state = EXPR_END;
14079  result = tGVAR;
14080  break;
14081  case '@':
14082  lex_state = EXPR_END;
14083  if (tok()[1] == '@')
14084  result = tCVAR;
14085  else
14086  result = tIVAR;
14087  break;
14088 
14089  default:
14090  if (toklast() == '!' || toklast() == '?') {
14091  result = tFID;
14092  }
14093  else {
14094  if (lex_state == EXPR_FNAME) {
14095  if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14096  (!peek('=') || (peek_n('>', 1)))) {
14097  result = tIDENTIFIER;
14098  tokadd(c);
14099  tokfix();
14100  }
14101  else {
14102  pushback(c);
14103  }
14104  }
14105  if (result == 0 && ISUPPER(tok()[0])) {
14106  result = tCONSTANT;
14107  }
14108  else {
14109  result = tIDENTIFIER;
14110  }
14111  }
14112 
14113  if (IS_LABEL_POSSIBLE()) {
14114  if (IS_LABEL_SUFFIX(0)) {
14115  lex_state = EXPR_BEG;
14116  nextc();
14118  return tLABEL;
14119  }
14120  }
14121  if (mb == ENC_CODERANGE_7BIT && lex_state != EXPR_DOT) {
14122  const struct kwtable *kw;
14123 
14124  /* See if it is a reserved word. */
14125  kw = rb_reserved_word(tok(), toklen());
14126  if (kw) {
14127  enum lex_state_e state = lex_state;
14128  lex_state = kw->state;
14129  if (state == EXPR_FNAME) {
14131  return kw->id[0];
14132  }
14133  if (kw->id[0] == keyword_do) {
14134  command_start = TRUE;
14135  if (lpar_beg && lpar_beg == paren_nest) {
14136  lpar_beg = 0;
14137  --paren_nest;
14138  return keyword_do_LAMBDA;
14139  }
14140  if (COND_P()) return keyword_do_cond;
14141  if (CMDARG_P() && state != EXPR_CMDARG)
14142  return keyword_do_block;
14143  if (state == EXPR_ENDARG || state == EXPR_BEG)
14144  return keyword_do_block;
14145  return keyword_do;
14146  }
14147  if (state == EXPR_BEG || state == EXPR_VALUE)
14148  return kw->id[0];
14149  else {
14150  if (kw->id[0] != kw->id[1])
14151  lex_state = EXPR_BEG;
14152  return kw->id[1];
14153  }
14154  }
14155  }
14156 
14157  if (IS_BEG() ||
14158  lex_state == EXPR_DOT ||
14159  IS_ARG()) {
14160  if (cmd_state) {
14162  }
14163  else {
14164  lex_state = EXPR_ARG;
14165  }
14166  }
14167  else if (lex_state == EXPR_FNAME) {
14169  }
14170  else {
14171  lex_state = EXPR_END;
14172  }
14173  }
14174  {
14175  ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14176 
14177  set_yylval_name(ident);
14178  if (last_state != EXPR_DOT && last_state != EXPR_FNAME &&
14179  is_local_id(ident) && lvar_defined(ident)) {
14180  lex_state = EXPR_END;
14181  }
14182  }
14183  return result;
14184  }
14185 }
14186 
14187 #if YYPURE
14188 static int
14189 yylex(void *lval, void *p)
14190 #else
14191 yylex(void *p)
14192 #endif
14193 {
14194  struct parser_params *parser = (struct parser_params*)p;
14195  int t;
14196 
14197 #if YYPURE
14198  parser->parser_yylval = lval;
14199  parser->parser_yylval->val = Qundef;
14200 #endif
14201  t = parser_yylex(parser);
14202 #ifdef RIPPER
14203  if (!NIL_P(parser->delayed)) {
14204  ripper_dispatch_delayed_token(parser, t);
14205  return t;
14206  }
14207  if (t != 0)
14208  ripper_dispatch_scan_event(parser, t);
14209 #endif
14210 
14211  return t;
14212 }
14213 
14214 #ifndef RIPPER
14215 static NODE*
14216 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14217 {
14218  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14220  return n;
14221 }
14222 
14223 enum node_type
14224 nodetype(NODE *node) /* for debug */
14225 {
14226  return (enum node_type)nd_type(node);
14227 }
14228 
14229 int
14231 {
14232  return nd_line(node);
14233 }
14234 
14235 static NODE*
14237 {
14238  if (node) {
14239  node = remove_begin(node);
14240  node->flags |= NODE_FL_NEWLINE;
14241  }
14242  return node;
14243 }
14244 
14245 static void
14246 fixpos(NODE *node, NODE *orig)
14247 {
14248  if (!node) return;
14249  if (!orig) return;
14250  if (orig == (NODE*)1) return;
14251  nd_set_line(node, nd_line(orig));
14252 }
14253 
14254 static void
14255 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14256 {
14257  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14258 }
14259 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14260 
14261 static void
14262 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14263 {
14264  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14265 }
14266 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14267 
14268 static NODE*
14269 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14270 {
14271  NODE *end, *h = head, *nd;
14272 
14273  if (tail == 0) return head;
14274 
14275  if (h == 0) return tail;
14276  switch (nd_type(h)) {
14277  case NODE_LIT:
14278  case NODE_STR:
14279  case NODE_SELF:
14280  case NODE_TRUE:
14281  case NODE_FALSE:
14282  case NODE_NIL:
14283  parser_warning(h, "unused literal ignored");
14284  return tail;
14285  default:
14286  h = end = NEW_BLOCK(head);
14287  end->nd_end = end;
14288  fixpos(end, head);
14289  head = end;
14290  break;
14291  case NODE_BLOCK:
14292  end = h->nd_end;
14293  break;
14294  }
14295 
14296  nd = end->nd_head;
14297  switch (nd_type(nd)) {
14298  case NODE_RETURN:
14299  case NODE_BREAK:
14300  case NODE_NEXT:
14301  case NODE_REDO:
14302  case NODE_RETRY:
14303  if (RTEST(ruby_verbose)) {
14304  parser_warning(nd, "statement not reached");
14305  }
14306  break;
14307 
14308  default:
14309  break;
14310  }
14311 
14312  if (nd_type(tail) != NODE_BLOCK) {
14313  tail = NEW_BLOCK(tail);
14314  tail->nd_end = tail;
14315  }
14316  end->nd_next = tail;
14317  h->nd_end = tail->nd_end;
14318  return head;
14319 }
14320 
14321 /* append item to the list */
14322 static NODE*
14323 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14324 {
14325  NODE *last;
14326 
14327  if (list == 0) return NEW_LIST(item);
14328  if (list->nd_next) {
14329  last = list->nd_next->nd_end;
14330  }
14331  else {
14332  last = list;
14333  }
14334 
14335  list->nd_alen += 1;
14336  last->nd_next = NEW_LIST(item);
14337  list->nd_next->nd_end = last->nd_next;
14338  return list;
14339 }
14340 
14341 /* concat two lists */
14342 static NODE*
14343 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14344 {
14345  NODE *last;
14346 
14347  if (head->nd_next) {
14348  last = head->nd_next->nd_end;
14349  }
14350  else {
14351  last = head;
14352  }
14353 
14354  head->nd_alen += tail->nd_alen;
14355  last->nd_next = tail;
14356  if (tail->nd_next) {
14357  head->nd_next->nd_end = tail->nd_next->nd_end;
14358  }
14359  else {
14360  head->nd_next->nd_end = tail;
14361  }
14362 
14363  return head;
14364 }
14365 
14366 static int
14367 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
14368 {
14369  if (NIL_P(tail)) return 1;
14370  if (!rb_enc_compatible(head, tail)) {
14371  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14372  rb_enc_name(rb_enc_get(head)),
14373  rb_enc_name(rb_enc_get(tail)));
14374  rb_str_resize(head, 0);
14375  rb_str_resize(tail, 0);
14376  return 0;
14377  }
14378  rb_str_buf_append(head, tail);
14379  return 1;
14380 }
14381 
14382 /* concat two string literals */
14383 static NODE *
14384 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14385 {
14386  enum node_type htype;
14387 
14388  if (!head) return tail;
14389  if (!tail) return head;
14390 
14391  htype = nd_type(head);
14392  if (htype == NODE_EVSTR) {
14393  NODE *node = NEW_DSTR(Qnil);
14394  head = list_append(node, head);
14395  }
14396  switch (nd_type(tail)) {
14397  case NODE_STR:
14398  if (htype == NODE_STR) {
14399  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit)) {
14400  error:
14401  rb_gc_force_recycle((VALUE)head);
14402  rb_gc_force_recycle((VALUE)tail);
14403  return 0;
14404  }
14405  rb_gc_force_recycle((VALUE)tail);
14406  }
14407  else {
14408  list_append(head, tail);
14409  }
14410  break;
14411 
14412  case NODE_DSTR:
14413  if (htype == NODE_STR) {
14414  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14415  goto error;
14416  tail->nd_lit = head->nd_lit;
14417  rb_gc_force_recycle((VALUE)head);
14418  head = tail;
14419  }
14420  else if (NIL_P(tail->nd_lit)) {
14421  head->nd_alen += tail->nd_alen - 1;
14422  head->nd_next->nd_end->nd_next = tail->nd_next;
14423  head->nd_next->nd_end = tail->nd_next->nd_end;
14424  rb_gc_force_recycle((VALUE)tail);
14425  }
14426  else {
14427  nd_set_type(tail, NODE_ARRAY);
14428  tail->nd_head = NEW_STR(tail->nd_lit);
14429  list_concat(head, tail);
14430  }
14431  break;
14432 
14433  case NODE_EVSTR:
14434  if (htype == NODE_STR) {
14435  nd_set_type(head, NODE_DSTR);
14436  head->nd_alen = 1;
14437  }
14438  list_append(head, tail);
14439  break;
14440  }
14441  return head;
14442 }
14443 
14444 static NODE *
14445 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14446 {
14447  if (nd_type(node) == NODE_EVSTR) {
14448  node = list_append(NEW_DSTR(Qnil), node);
14449  }
14450  return node;
14451 }
14452 
14453 static NODE *
14454 new_evstr_gen(struct parser_params *parser, NODE *node)
14455 {
14456  NODE *head = node;
14457 
14458  if (node) {
14459  switch (nd_type(node)) {
14460  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14461  return node;
14462  }
14463  }
14464  return NEW_EVSTR(head);
14465 }
14466 
14467 static NODE *
14468 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14469 {
14470  value_expr(recv);
14471  value_expr(arg1);
14472  return NEW_CALL(recv, id, NEW_LIST(arg1));
14473 }
14474 
14475 static NODE *
14476 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
14477 {
14478  value_expr(recv);
14479  return NEW_CALL(recv, id, 0);
14480 }
14481 
14482 static NODE*
14483 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14484 {
14485  value_expr(node1);
14486  value_expr(node2);
14487  if (node1) {
14488  switch (nd_type(node1)) {
14489  case NODE_DREGX:
14490  case NODE_DREGX_ONCE:
14491  return NEW_MATCH2(node1, node2);
14492 
14493  case NODE_LIT:
14494  if (TYPE(node1->nd_lit) == T_REGEXP) {
14495  return NEW_MATCH2(node1, node2);
14496  }
14497  }
14498  }
14499 
14500  if (node2) {
14501  switch (nd_type(node2)) {
14502  case NODE_DREGX:
14503  case NODE_DREGX_ONCE:
14504  return NEW_MATCH3(node2, node1);
14505 
14506  case NODE_LIT:
14507  if (TYPE(node2->nd_lit) == T_REGEXP) {
14508  return NEW_MATCH3(node2, node1);
14509  }
14510  }
14511  }
14512 
14513  return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
14514 }
14515 
14516 static NODE*
14517 gettable_gen(struct parser_params *parser, ID id)
14518 {
14519  if (id == keyword_self) {
14520  return NEW_SELF();
14521  }
14522  else if (id == keyword_nil) {
14523  return NEW_NIL();
14524  }
14525  else if (id == keyword_true) {
14526  return NEW_TRUE();
14527  }
14528  else if (id == keyword_false) {
14529  return NEW_FALSE();
14530  }
14531  else if (id == keyword__FILE__) {
14534  }
14535  else if (id == keyword__LINE__) {
14536  return NEW_LIT(INT2FIX(ruby_sourceline));
14537  }
14538  else if (id == keyword__ENCODING__) {
14539  return NEW_LIT(rb_enc_from_encoding(parser->enc));
14540  }
14541  else if (is_local_id(id)) {
14542  if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
14543  if (local_id(id)) return NEW_LVAR(id);
14544  /* method call without arguments */
14545  return NEW_VCALL(id);
14546  }
14547  else if (is_global_id(id)) {
14548  return NEW_GVAR(id);
14549  }
14550  else if (is_instance_id(id)) {
14551  return NEW_IVAR(id);
14552  }
14553  else if (is_const_id(id)) {
14554  return NEW_CONST(id);
14555  }
14556  else if (is_class_id(id)) {
14557  return NEW_CVAR(id);
14558  }
14559  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14560  return 0;
14561 }
14562 #else /* !RIPPER */
14563 static int
14564 id_is_var_gen(struct parser_params *parser, ID id)
14565 {
14566  if (is_notop_id(id)) {
14567  switch (id & ID_SCOPE_MASK) {
14568  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
14569  return 1;
14570  case ID_LOCAL:
14571  if (dyna_in_block() && dvar_defined(id)) return 1;
14572  if (local_id(id)) return 1;
14573  /* method call without arguments */
14574  return 0;
14575  }
14576  }
14577  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14578  return 0;
14579 }
14580 #endif /* !RIPPER */
14581 
14582 #ifdef RIPPER
14583 static VALUE
14584 assignable_gen(struct parser_params *parser, VALUE lhs)
14585 #else
14586 static NODE*
14587 assignable_gen(struct parser_params *parser, ID id, NODE *val)
14588 #endif
14589 {
14590 #ifdef RIPPER
14591  ID id = get_id(lhs);
14592 # define assignable_result(x) get_value(lhs)
14593 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
14594 #else
14595 # define assignable_result(x) (x)
14596 #endif
14597  if (!id) return assignable_result(0);
14598  if (id == keyword_self) {
14599  yyerror("Can't change the value of self");
14600  }
14601  else if (id == keyword_nil) {
14602  yyerror("Can't assign to nil");
14603  }
14604  else if (id == keyword_true) {
14605  yyerror("Can't assign to true");
14606  }
14607  else if (id == keyword_false) {
14608  yyerror("Can't assign to false");
14609  }
14610  else if (id == keyword__FILE__) {
14611  yyerror("Can't assign to __FILE__");
14612  }
14613  else if (id == keyword__LINE__) {
14614  yyerror("Can't assign to __LINE__");
14615  }
14616  else if (id == keyword__ENCODING__) {
14617  yyerror("Can't assign to __ENCODING__");
14618  }
14619  else if (is_local_id(id)) {
14620  if (dyna_in_block()) {
14621  if (dvar_curr(id)) {
14622  return assignable_result(NEW_DASGN_CURR(id, val));
14623  }
14624  else if (dvar_defined(id)) {
14625  return assignable_result(NEW_DASGN(id, val));
14626  }
14627  else if (local_id(id)) {
14628  return assignable_result(NEW_LASGN(id, val));
14629  }
14630  else {
14631  dyna_var(id);
14632  return assignable_result(NEW_DASGN_CURR(id, val));
14633  }
14634  }
14635  else {
14636  if (!local_id(id)) {
14637  local_var(id);
14638  }
14639  return assignable_result(NEW_LASGN(id, val));
14640  }
14641  }
14642  else if (is_global_id(id)) {
14643  return assignable_result(NEW_GASGN(id, val));
14644  }
14645  else if (is_instance_id(id)) {
14646  return assignable_result(NEW_IASGN(id, val));
14647  }
14648  else if (is_const_id(id)) {
14649  if (!in_def && !in_single)
14650  return assignable_result(NEW_CDECL(id, val, 0));
14651  yyerror("dynamic constant assignment");
14652  }
14653  else if (is_class_id(id)) {
14654  return assignable_result(NEW_CVASGN(id, val));
14655  }
14656  else {
14657  compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
14658  }
14659  return assignable_result(0);
14660 #undef assignable_result
14661 #undef parser_yyerror
14662 }
14663 
14664 #define LVAR_USED ((int)1 << (sizeof(int) * CHAR_BIT - 1))
14665 
14666 static ID
14667 shadowing_lvar_gen(struct parser_params *parser, ID name)
14668 {
14669  if (idUScore == name) return name;
14670  if (dyna_in_block()) {
14671  if (dvar_curr(name)) {
14672  yyerror("duplicated argument name");
14673  }
14674  else if (dvar_defined_get(name) || local_id(name)) {
14675  rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
14676  vtable_add(lvtbl->vars, name);
14677  if (lvtbl->used) {
14679  }
14680  }
14681  }
14682  else {
14683  if (local_id(name)) {
14684  yyerror("duplicated argument name");
14685  }
14686  }
14687  return name;
14688 }
14689 
14690 static void
14691 new_bv_gen(struct parser_params *parser, ID name)
14692 {
14693  if (!name) return;
14694  if (!is_local_id(name)) {
14695  compile_error(PARSER_ARG "invalid local variable - %s",
14696  rb_id2name(name));
14697  return;
14698  }
14699  shadowing_lvar(name);
14700  dyna_var(name);
14701 }
14702 
14703 #ifndef RIPPER
14704 static NODE *
14705 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
14706 {
14707  if (recv && nd_type(recv) == NODE_SELF)
14708  recv = (NODE *)1;
14709  return NEW_ATTRASGN(recv, tASET, idx);
14710 }
14711 
14712 static void
14713 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14714 {
14715  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
14716  compile_error(PARSER_ARG "both block arg and actual block given");
14717  }
14718 }
14719 
14720 ID
14722 {
14723  id &= ~ID_SCOPE_MASK;
14724  id |= ID_ATTRSET;
14725  return id;
14726 }
14727 
14728 static NODE *
14729 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
14730 {
14731  if (recv && nd_type(recv) == NODE_SELF)
14732  recv = (NODE *)1;
14733  return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
14734 }
14735 
14736 static void
14738 {
14739  switch (nd_type(node)) {
14740  case NODE_NTH_REF:
14741  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
14742  break;
14743  case NODE_BACK_REF:
14744  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
14745  break;
14746  }
14747 }
14748 
14749 static NODE *
14750 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14751 {
14752  if (!node2) return node1;
14753  switch (nd_type(node1)) {
14754  case NODE_BLOCK_PASS:
14755  if (node1->nd_head)
14756  node1->nd_head = arg_concat(node1->nd_head, node2);
14757  else
14758  node1->nd_head = NEW_LIST(node2);
14759  return node1;
14760  case NODE_ARGSPUSH:
14761  if (nd_type(node2) != NODE_ARRAY) break;
14762  node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
14763  nd_set_type(node1, NODE_ARGSCAT);
14764  return node1;
14765  case NODE_ARGSCAT:
14766  if (nd_type(node2) != NODE_ARRAY ||
14767  nd_type(node1->nd_body) != NODE_ARRAY) break;
14768  node1->nd_body = list_concat(node1->nd_body, node2);
14769  return node1;
14770  }
14771  return NEW_ARGSCAT(node1, node2);
14772 }
14773 
14774 static NODE *
14775 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14776 {
14777  if (!node1) return NEW_LIST(node2);
14778  switch (nd_type(node1)) {
14779  case NODE_ARRAY:
14780  return list_append(node1, node2);
14781  case NODE_BLOCK_PASS:
14782  node1->nd_head = arg_append(node1->nd_head, node2);
14783  return node1;
14784  case NODE_ARGSPUSH:
14785  node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
14786  nd_set_type(node1, NODE_ARGSCAT);
14787  return node1;
14788  }
14789  return NEW_ARGSPUSH(node1, node2);
14790 }
14791 
14792 static NODE *
14794 {
14795  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
14796  if (nd_type(node) == NODE_ARRAY) return node;
14797  return 0;
14798 }
14799 
14800 static NODE *
14801 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
14802 {
14803  if (!lhs) return 0;
14804 
14805  switch (nd_type(lhs)) {
14806  case NODE_GASGN:
14807  case NODE_IASGN:
14808  case NODE_IASGN2:
14809  case NODE_LASGN:
14810  case NODE_DASGN:
14811  case NODE_DASGN_CURR:
14812  case NODE_MASGN:
14813  case NODE_CDECL:
14814  case NODE_CVASGN:
14815  lhs->nd_value = rhs;
14816  break;
14817 
14818  case NODE_ATTRASGN:
14819  case NODE_CALL:
14820  lhs->nd_args = arg_append(lhs->nd_args, rhs);
14821  break;
14822 
14823  default:
14824  /* should not happen */
14825  break;
14826  }
14827 
14828  return lhs;
14829 }
14830 
14831 static int
14832 value_expr_gen(struct parser_params *parser, NODE *node)
14833 {
14834  int cond = 0;
14835 
14836  if (!node) {
14837  rb_warning0("empty expression");
14838  }
14839  while (node) {
14840  switch (nd_type(node)) {
14841  case NODE_DEFN:
14842  case NODE_DEFS:
14843  parser_warning(node, "void value expression");
14844  return FALSE;
14845 
14846  case NODE_RETURN:
14847  case NODE_BREAK:
14848  case NODE_NEXT:
14849  case NODE_REDO:
14850  case NODE_RETRY:
14851  if (!cond) yyerror("void value expression");
14852  /* or "control never reach"? */
14853  return FALSE;
14854 
14855  case NODE_BLOCK:
14856  while (node->nd_next) {
14857  node = node->nd_next;
14858  }
14859  node = node->nd_head;
14860  break;
14861 
14862  case NODE_BEGIN:
14863  node = node->nd_body;
14864  break;
14865 
14866  case NODE_IF:
14867  if (!node->nd_body) {
14868  node = node->nd_else;
14869  break;
14870  }
14871  else if (!node->nd_else) {
14872  node = node->nd_body;
14873  break;
14874  }
14875  if (!value_expr(node->nd_body)) return FALSE;
14876  node = node->nd_else;
14877  break;
14878 
14879  case NODE_AND:
14880  case NODE_OR:
14881  cond = 1;
14882  node = node->nd_2nd;
14883  break;
14884 
14885  default:
14886  return TRUE;
14887  }
14888  }
14889 
14890  return TRUE;
14891 }
14892 
14893 static void
14894 void_expr_gen(struct parser_params *parser, NODE *node)
14895 {
14896  const char *useless = 0;
14897 
14898  if (!RTEST(ruby_verbose)) return;
14899 
14900  if (!node) return;
14901  switch (nd_type(node)) {
14902  case NODE_CALL:
14903  switch (node->nd_mid) {
14904  case '+':
14905  case '-':
14906  case '*':
14907  case '/':
14908  case '%':
14909  case tPOW:
14910  case tUPLUS:
14911  case tUMINUS:
14912  case '|':
14913  case '^':
14914  case '&':
14915  case tCMP:
14916  case '>':
14917  case tGEQ:
14918  case '<':
14919  case tLEQ:
14920  case tEQ:
14921  case tNEQ:
14922  useless = rb_id2name(node->nd_mid);
14923  break;
14924  }
14925  break;
14926 
14927  case NODE_LVAR:
14928  case NODE_DVAR:
14929  case NODE_GVAR:
14930  case NODE_IVAR:
14931  case NODE_CVAR:
14932  case NODE_NTH_REF:
14933  case NODE_BACK_REF:
14934  useless = "a variable";
14935  break;
14936  case NODE_CONST:
14937  useless = "a constant";
14938  break;
14939  case NODE_LIT:
14940  case NODE_STR:
14941  case NODE_DSTR:
14942  case NODE_DREGX:
14943  case NODE_DREGX_ONCE:
14944  useless = "a literal";
14945  break;
14946  case NODE_COLON2:
14947  case NODE_COLON3:
14948  useless = "::";
14949  break;
14950  case NODE_DOT2:
14951  useless = "..";
14952  break;
14953  case NODE_DOT3:
14954  useless = "...";
14955  break;
14956  case NODE_SELF:
14957  useless = "self";
14958  break;
14959  case NODE_NIL:
14960  useless = "nil";
14961  break;
14962  case NODE_TRUE:
14963  useless = "true";
14964  break;
14965  case NODE_FALSE:
14966  useless = "false";
14967  break;
14968  case NODE_DEFINED:
14969  useless = "defined?";
14970  break;
14971  }
14972 
14973  if (useless) {
14974  int line = ruby_sourceline;
14975 
14976  ruby_sourceline = nd_line(node);
14977  rb_warnS("possibly useless use of %s in void context", useless);
14978  ruby_sourceline = line;
14979  }
14980 }
14981 
14982 static void
14983 void_stmts_gen(struct parser_params *parser, NODE *node)
14984 {
14985  if (!RTEST(ruby_verbose)) return;
14986  if (!node) return;
14987  if (nd_type(node) != NODE_BLOCK) return;
14988 
14989  for (;;) {
14990  if (!node->nd_next) return;
14991  void_expr0(node->nd_head);
14992  node = node->nd_next;
14993  }
14994 }
14995 
14996 static NODE *
14998 {
14999  NODE **n = &node, *n1 = node;
15000  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15001  *n = n1 = n1->nd_body;
15002  }
15003  return node;
15004 }
15005 
15006 static void
15007 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15008 {
15009  NODE *node = *body;
15010 
15011  if (!node) {
15012  *body = NEW_NIL();
15013  return;
15014  }
15015 #define subnodes(n1, n2) \
15016  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15017  (!node->n2) ? (body = &node->n1, 1) : \
15018  (reduce_nodes(&node->n1), body = &node->n2, 1))
15019 
15020  while (node) {
15021  int newline = (int)(node->flags & NODE_FL_NEWLINE);
15022  switch (nd_type(node)) {
15023  end:
15024  case NODE_NIL:
15025  *body = 0;
15026  return;
15027  case NODE_RETURN:
15028  *body = node = node->nd_stts;
15029  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15030  continue;
15031  case NODE_BEGIN:
15032  *body = node = node->nd_body;
15033  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15034  continue;
15035  case NODE_BLOCK:
15036  body = &node->nd_end->nd_head;
15037  break;
15038  case NODE_IF:
15039  if (subnodes(nd_body, nd_else)) break;
15040  return;
15041  case NODE_CASE:
15042  body = &node->nd_body;
15043  break;
15044  case NODE_WHEN:
15045  if (!subnodes(nd_body, nd_next)) goto end;
15046  break;
15047  case NODE_ENSURE:
15048  if (!subnodes(nd_head, nd_resq)) goto end;
15049  break;
15050  case NODE_RESCUE:
15051  if (node->nd_else) {
15052  body = &node->nd_resq;
15053  break;
15054  }
15055  if (!subnodes(nd_head, nd_resq)) goto end;
15056  break;
15057  default:
15058  return;
15059  }
15060  node = *body;
15061  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15062  }
15063 
15064 #undef subnodes
15065 }
15066 
15067 static int
15068 assign_in_cond(struct parser_params *parser, NODE *node)
15069 {
15070  switch (nd_type(node)) {
15071  case NODE_MASGN:
15072  yyerror("multiple assignment in conditional");
15073  return 1;
15074 
15075  case NODE_LASGN:
15076  case NODE_DASGN:
15077  case NODE_DASGN_CURR:
15078  case NODE_GASGN:
15079  case NODE_IASGN:
15080  break;
15081 
15082  default:
15083  return 0;
15084  }
15085 
15086  if (!node->nd_value) return 1;
15087  switch (nd_type(node->nd_value)) {
15088  case NODE_LIT:
15089  case NODE_STR:
15090  case NODE_NIL:
15091  case NODE_TRUE:
15092  case NODE_FALSE:
15093  /* reports always */
15094  parser_warn(node->nd_value, "found = in conditional, should be ==");
15095  return 1;
15096 
15097  case NODE_DSTR:
15098  case NODE_XSTR:
15099  case NODE_DXSTR:
15100  case NODE_EVSTR:
15101  case NODE_DREGX:
15102  default:
15103  break;
15104  }
15105  return 1;
15106 }
15107 
15108 static void
15109 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15110 {
15111  if (!e_option_supplied(parser)) parser_warn(node, str);
15112 }
15113 
15114 static void
15115 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15116 {
15117  if (!e_option_supplied(parser)) parser_warning(node, str);
15118 }
15119 
15120 static void
15121 fixup_nodes(NODE **rootnode)
15122 {
15123  NODE *node, *next, *head;
15124 
15125  for (node = *rootnode; node; node = next) {
15126  enum node_type type;
15127  VALUE val;
15128 
15129  next = node->nd_next;
15130  head = node->nd_head;
15131  rb_gc_force_recycle((VALUE)node);
15132  *rootnode = next;
15133  switch (type = nd_type(head)) {
15134  case NODE_DOT2:
15135  case NODE_DOT3:
15136  val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15137  type == NODE_DOT3);
15138  rb_gc_force_recycle((VALUE)head->nd_beg);
15139  rb_gc_force_recycle((VALUE)head->nd_end);
15140  nd_set_type(head, NODE_LIT);
15141  head->nd_lit = val;
15142  break;
15143  default:
15144  break;
15145  }
15146  }
15147 }
15148 
15149 static NODE *cond0(struct parser_params*,NODE*);
15150 
15151 static NODE*
15152 range_op(struct parser_params *parser, NODE *node)
15153 {
15154  enum node_type type;
15155 
15156  if (node == 0) return 0;
15157 
15158  type = nd_type(node);
15159  value_expr(node);
15160  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15161  warn_unless_e_option(parser, node, "integer literal in conditional range");
15162  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15163  }
15164  return cond0(parser, node);
15165 }
15166 
15167 static int
15169 {
15170  if (!node) return 1; /* same as NODE_NIL */
15171  switch (nd_type(node)) {
15172  case NODE_LIT:
15173  case NODE_STR:
15174  case NODE_DSTR:
15175  case NODE_EVSTR:
15176  case NODE_DREGX:
15177  case NODE_DREGX_ONCE:
15178  case NODE_DSYM:
15179  return 2;
15180  case NODE_TRUE:
15181  case NODE_FALSE:
15182  case NODE_NIL:
15183  return 1;
15184  }
15185  return 0;
15186 }
15187 
15188 static NODE*
15189 cond0(struct parser_params *parser, NODE *node)
15190 {
15191  if (node == 0) return 0;
15192  assign_in_cond(parser, node);
15193 
15194  switch (nd_type(node)) {
15195  case NODE_DSTR:
15196  case NODE_EVSTR:
15197  case NODE_STR:
15198  rb_warn0("string literal in condition");
15199  break;
15200 
15201  case NODE_DREGX:
15202  case NODE_DREGX_ONCE:
15203  warning_unless_e_option(parser, node, "regex literal in condition");
15204  return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15205 
15206  case NODE_AND:
15207  case NODE_OR:
15208  node->nd_1st = cond0(parser, node->nd_1st);
15209  node->nd_2nd = cond0(parser, node->nd_2nd);
15210  break;
15211 
15212  case NODE_DOT2:
15213  case NODE_DOT3:
15214  node->nd_beg = range_op(parser, node->nd_beg);
15215  node->nd_end = range_op(parser, node->nd_end);
15216  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15217  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15218  if (!e_option_supplied(parser)) {
15219  int b = literal_node(node->nd_beg);
15220  int e = literal_node(node->nd_end);
15221  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15222  parser_warn(node, "range literal in condition");
15223  }
15224  }
15225  break;
15226 
15227  case NODE_DSYM:
15228  parser_warning(node, "literal in condition");
15229  break;
15230 
15231  case NODE_LIT:
15232  if (TYPE(node->nd_lit) == T_REGEXP) {
15233  warn_unless_e_option(parser, node, "regex literal in condition");
15234  nd_set_type(node, NODE_MATCH);
15235  }
15236  else {
15237  parser_warning(node, "literal in condition");
15238  }
15239  default:
15240  break;
15241  }
15242  return node;
15243 }
15244 
15245 static NODE*
15246 cond_gen(struct parser_params *parser, NODE *node)
15247 {
15248  if (node == 0) return 0;
15249  return cond0(parser, node);
15250 }
15251 
15252 static NODE*
15253 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15254 {
15255  value_expr(left);
15256  if (left && (enum node_type)nd_type(left) == type) {
15257  NODE *node = left, *second;
15258  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15259  node = second;
15260  }
15261  node->nd_2nd = NEW_NODE(type, second, right, 0);
15262  return left;
15263  }
15264  return NEW_NODE(type, left, right, 0);
15265 }
15266 
15267 static void
15268 no_blockarg(struct parser_params *parser, NODE *node)
15269 {
15270  if (node && nd_type(node) == NODE_BLOCK_PASS) {
15271  compile_error(PARSER_ARG "block argument should not be given");
15272  }
15273 }
15274 
15275 static NODE *
15276 ret_args_gen(struct parser_params *parser, NODE *node)
15277 {
15278  if (node) {
15279  no_blockarg(parser, node);
15280  if (nd_type(node) == NODE_ARRAY) {
15281  if (node->nd_next == 0) {
15282  node = node->nd_head;
15283  }
15284  else {
15285  nd_set_type(node, NODE_VALUES);
15286  }
15287  }
15288  }
15289  return node;
15290 }
15291 
15292 static NODE *
15293 new_yield_gen(struct parser_params *parser, NODE *node)
15294 {
15295  long state = Qtrue;
15296 
15297  if (node) {
15298  no_blockarg(parser, node);
15299  if (node && nd_type(node) == NODE_SPLAT) {
15300  state = Qtrue;
15301  }
15302  }
15303  else {
15304  state = Qfalse;
15305  }
15306  return NEW_YIELD(node, state);
15307 }
15308 
15309 static NODE*
15311 {
15312  switch (TYPE(node->nd_lit)) {
15313  case T_FIXNUM:
15314  node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15315  break;
15316  case T_BIGNUM:
15317  node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15318  break;
15319  case T_FLOAT:
15320  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15321  break;
15322  default:
15323  break;
15324  }
15325  return node;
15326 }
15327 
15328 static NODE *
15329 arg_blk_pass(NODE *node1, NODE *node2)
15330 {
15331  if (node2) {
15332  node2->nd_head = node1;
15333  return node2;
15334  }
15335  return node1;
15336 }
15337 
15338 static NODE*
15339 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, ID b)
15340 {
15341  int saved_line = ruby_sourceline;
15342  NODE *node;
15343  NODE *i1, *i2 = 0;
15344 
15345  node = NEW_ARGS(m ? m->nd_plen : 0, o);
15346  i1 = m ? m->nd_next : 0;
15347  node->nd_next = NEW_ARGS_AUX(r, b);
15348 
15349  if (p) {
15350  i2 = p->nd_next;
15351  node->nd_next->nd_next = NEW_ARGS_AUX(p->nd_pid, p->nd_plen);
15352  }
15353  else if (i1) {
15354  node->nd_next->nd_next = NEW_ARGS_AUX(0, 0);
15355  }
15356  if (i1 || i2) {
15357  node->nd_next->nd_next->nd_next = NEW_NODE(NODE_AND, i1, i2, 0);
15358  }
15359  ruby_sourceline = saved_line;
15360  return node;
15361 }
15362 #endif /* !RIPPER */
15363 
15364 static void
15365 warn_unused_var(struct parser_params *parser, struct local_vars *local)
15366 {
15367  int i, cnt;
15368  ID *v, *u;
15369 
15370  if (!local->used) return;
15371  v = local->vars->tbl;
15372  u = local->used->tbl;
15373  cnt = local->used->pos;
15374  if (cnt != local->vars->pos) {
15375  rb_bug("local->used->pos != local->vars->pos");
15376  }
15377  for (i = 0; i < cnt; ++i) {
15378  if (!v[i] || (u[i] & LVAR_USED)) continue;
15379  if (idUScore == v[i]) continue;
15380  rb_compile_warn(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
15381  }
15382 }
15383 
15384 static void
15385 local_push_gen(struct parser_params *parser, int inherit_dvars)
15386 {
15387  struct local_vars *local;
15388 
15389  local = ALLOC(struct local_vars);
15390  local->prev = lvtbl;
15391  local->args = vtable_alloc(0);
15392  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
15393  local->used = !inherit_dvars && RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
15394  local->cmdargs = cmdarg_stack;
15395  cmdarg_stack = 0;
15396  lvtbl = local;
15397 }
15398 
15399 static void
15401 {
15402  struct local_vars *local = lvtbl->prev;
15403  if (lvtbl->used) {
15404  warn_unused_var(parser, lvtbl);
15405  vtable_free(lvtbl->used);
15406  }
15407  vtable_free(lvtbl->args);
15408  vtable_free(lvtbl->vars);
15409  cmdarg_stack = lvtbl->cmdargs;
15410  xfree(lvtbl);
15411  lvtbl = local;
15412 }
15413 
15414 #ifndef RIPPER
15415 static ID*
15416 vtable_tblcpy(ID *buf, const struct vtable *src)
15417 {
15418  int i, cnt = vtable_size(src);
15419 
15420  if (cnt > 0) {
15421  buf[0] = cnt;
15422  for (i = 0; i < cnt; i++) {
15423  buf[i] = src->tbl[i];
15424  }
15425  return buf;
15426  }
15427  return 0;
15428 }
15429 
15430 static ID*
15432 {
15433  int cnt = vtable_size(lvtbl->args) + vtable_size(lvtbl->vars);
15434  ID *buf;
15435 
15436  if (cnt <= 0) return 0;
15437  buf = ALLOC_N(ID, cnt + 1);
15438  vtable_tblcpy(buf+1, lvtbl->args);
15439  vtable_tblcpy(buf+vtable_size(lvtbl->args)+1, lvtbl->vars);
15440  buf[0] = cnt;
15441  return buf;
15442 }
15443 #endif
15444 
15445 static int
15446 arg_var_gen(struct parser_params *parser, ID id)
15447 {
15448  vtable_add(lvtbl->args, id);
15449  return vtable_size(lvtbl->args) - 1;
15450 }
15451 
15452 static int
15453 local_var_gen(struct parser_params *parser, ID id)
15454 {
15455  vtable_add(lvtbl->vars, id);
15456  if (lvtbl->used) {
15458  }
15459  return vtable_size(lvtbl->vars) - 1;
15460 }
15461 
15462 static int
15463 local_id_gen(struct parser_params *parser, ID id)
15464 {
15465  struct vtable *vars, *args, *used;
15466 
15467  vars = lvtbl->vars;
15468  args = lvtbl->args;
15469  used = lvtbl->used;
15470 
15471  while (vars && POINTER_P(vars->prev)) {
15472  vars = vars->prev;
15473  args = args->prev;
15474  if (used) used = used->prev;
15475  }
15476 
15477  if (vars && vars->prev == DVARS_INHERIT) {
15478  return rb_local_defined(id);
15479  }
15480  else if (vtable_included(args, id)) {
15481  return 1;
15482  }
15483  else {
15484  int i = vtable_included(vars, id);
15485  if (i && used) used->tbl[i-1] |= LVAR_USED;
15486  return i != 0;
15487  }
15488 }
15489 
15490 static const struct vtable *
15492 {
15493  lvtbl->args = vtable_alloc(lvtbl->args);
15494  lvtbl->vars = vtable_alloc(lvtbl->vars);
15495  if (lvtbl->used) {
15496  lvtbl->used = vtable_alloc(lvtbl->used);
15497  }
15498  return lvtbl->args;
15499 }
15500 
15501 static void
15502 dyna_pop_1(struct parser_params *parser)
15503 {
15504  struct vtable *tmp;
15505 
15506  if ((tmp = lvtbl->used) != 0) {
15507  warn_unused_var(parser, lvtbl);
15508  lvtbl->used = lvtbl->used->prev;
15509  vtable_free(tmp);
15510  }
15511  tmp = lvtbl->args;
15512  lvtbl->args = lvtbl->args->prev;
15513  vtable_free(tmp);
15514  tmp = lvtbl->vars;
15515  lvtbl->vars = lvtbl->vars->prev;
15516  vtable_free(tmp);
15517 }
15518 
15519 static void
15520 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
15521 {
15522  while (lvtbl->args != lvargs) {
15523  dyna_pop_1(parser);
15524  if (!lvtbl->args) {
15525  struct local_vars *local = lvtbl->prev;
15526  xfree(lvtbl);
15527  lvtbl = local;
15528  }
15529  }
15530  dyna_pop_1(parser);
15531 }
15532 
15533 static int
15535 {
15536  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
15537 }
15538 
15539 static int
15540 dvar_defined_gen(struct parser_params *parser, ID id, int get)
15541 {
15542  struct vtable *vars, *args, *used;
15543  int i;
15544 
15545  args = lvtbl->args;
15546  vars = lvtbl->vars;
15547  used = lvtbl->used;
15548 
15549  while (POINTER_P(vars)) {
15550  if (vtable_included(args, id)) {
15551  return 1;
15552  }
15553  if ((i = vtable_included(vars, id)) != 0) {
15554  if (used) used->tbl[i-1] |= LVAR_USED;
15555  return 1;
15556  }
15557  args = args->prev;
15558  vars = vars->prev;
15559  if (get) used = 0;
15560  if (used) used = used->prev;
15561  }
15562 
15563  if (vars == DVARS_INHERIT) {
15564  return rb_dvar_defined(id);
15565  }
15566 
15567  return 0;
15568 }
15569 
15570 static int
15571 dvar_curr_gen(struct parser_params *parser, ID id)
15572 {
15573  return (vtable_included(lvtbl->args, id) ||
15574  vtable_included(lvtbl->vars, id));
15575 }
15576 
15577 #ifndef RIPPER
15578 static void
15580 {
15581  int c = RE_OPTION_ENCODING_IDX(options);
15582 
15583  if (c) {
15584  int opt, idx;
15585  rb_char_to_option_kcode(c, &opt, &idx);
15586  if (idx != ENCODING_GET(str) &&
15588  goto error;
15589  }
15590  ENCODING_SET(str, idx);
15591  }
15592  else if (RE_OPTION_ENCODING_NONE(options)) {
15593  if (!ENCODING_IS_ASCII8BIT(str) &&
15595  c = 'n';
15596  goto error;
15597  }
15599  }
15600  else if (parser->enc == rb_usascii_encoding()) {
15602  /* raise in re.c */
15604  }
15605  else {
15607  }
15608  }
15609  return;
15610 
15611  error:
15613  "regexp encoding option '%c' differs from source encoding '%s'",
15614  c, rb_enc_name(rb_enc_get(str)));
15615 }
15616 
15617 static int
15619 {
15620  VALUE err;
15621  reg_fragment_setenc(str, options);
15622  err = rb_reg_check_preprocess(str);
15623  if (err != Qnil) {
15624  err = rb_obj_as_string(err);
15625  compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
15626  RB_GC_GUARD(err);
15627  return 0;
15628  }
15629  return 1;
15630 }
15631 
15632 typedef struct {
15633  struct parser_params* parser;
15634  rb_encoding *enc;
15635  NODE *succ_block;
15636  NODE *fail_block;
15637  int num;
15639 
15640 static int
15642  int back_num, int *back_refs, OnigRegex regex, void *arg0)
15643 {
15645  struct parser_params* parser = arg->parser;
15646  rb_encoding *enc = arg->enc;
15647  long len = name_end - name;
15648  const char *s = (const char *)name;
15649  ID var;
15650 
15651  arg->num++;
15652 
15653  if (arg->succ_block == 0) {
15654  arg->succ_block = NEW_BEGIN(0);
15655  arg->fail_block = NEW_BEGIN(0);
15656  }
15657 
15658  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
15659  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
15660  !rb_enc_symname2_p(s, len, enc)) {
15661  return ST_CONTINUE;
15662  }
15663  var = rb_intern3(s, len, enc);
15664  if (dvar_defined(var) || local_id(var)) {
15665  rb_warningS("named capture conflicts a local variable - %s",
15666  rb_id2name(var));
15667  }
15668  arg->succ_block = block_append(arg->succ_block,
15670  NEW_CALL(
15671  gettable(rb_intern("$~")),
15672  idAREF,
15673  NEW_LIST(NEW_LIT(ID2SYM(var))))
15674  )));
15675  arg->fail_block = block_append(arg->fail_block,
15677  return ST_CONTINUE;
15678 }
15679 
15680 static NODE *
15682 {
15684 
15685  arg.parser = parser;
15686  arg.enc = rb_enc_get(regexp);
15687  arg.succ_block = 0;
15688  arg.fail_block = 0;
15689  arg.num = 0;
15690  onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
15691 
15692  if (arg.num == 0)
15693  return match;
15694 
15695  return
15696  block_append(
15697  newline_node(match),
15698  NEW_IF(gettable(rb_intern("$~")),
15699  block_append(
15700  newline_node(arg.succ_block),
15701  newline_node(
15702  NEW_CALL(
15703  gettable(rb_intern("$~")),
15704  rb_intern("begin"),
15705  NEW_LIST(NEW_LIT(INT2FIX(0)))))),
15706  block_append(
15707  newline_node(arg.fail_block),
15708  newline_node(
15709  NEW_LIT(Qnil)))));
15710 }
15711 
15712 static VALUE
15713 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
15714 {
15715  VALUE re;
15716  VALUE err;
15717 
15718  reg_fragment_setenc(str, options);
15719  err = rb_errinfo();
15721  if (NIL_P(re)) {
15722  ID mesg = rb_intern("mesg");
15723  VALUE m = rb_attr_get(rb_errinfo(), mesg);
15724  rb_set_errinfo(err);
15725  if (!NIL_P(err)) {
15726  rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
15727  }
15728  else {
15730  }
15731  return Qnil;
15732  }
15733  return re;
15734 }
15735 
15736 void
15738 {
15739 }
15740 
15741 NODE*
15743 {
15744  NODE *prelude = 0;
15745  NODE *scope = node;
15746  struct parser_params *parser;
15747 
15748  if (!node) return node;
15749 
15750  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15751 
15752  node = node->nd_body;
15753 
15754  if (nd_type(node) == NODE_PRELUDE) {
15755  prelude = node;
15756  node = node->nd_body;
15757  }
15758 
15759  node = block_append(node,
15760  NEW_FCALL(rb_intern("print"),
15761  NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
15762  if (prelude) {
15763  prelude->nd_body = node;
15764  scope->nd_body = prelude;
15765  }
15766  else {
15767  scope->nd_body = node;
15768  }
15769 
15770  return scope;
15771 }
15772 
15773 NODE *
15774 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
15775 {
15776  NODE *prelude = 0;
15777  NODE *scope = node;
15778  struct parser_params *parser;
15779 
15780  if (!node) return node;
15781 
15782  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
15783 
15784  node = node->nd_body;
15785 
15786  if (nd_type(node) == NODE_PRELUDE) {
15787  prelude = node;
15788  node = node->nd_body;
15789  }
15790  if (split) {
15791  node = block_append(NEW_GASGN(rb_intern("$F"),
15792  NEW_CALL(NEW_GVAR(rb_intern("$_")),
15793  rb_intern("split"), 0)),
15794  node);
15795  }
15796  if (chop) {
15797  node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
15798  rb_intern("chop!"), 0), node);
15799  }
15800 
15801  node = NEW_OPT_N(node);
15802 
15803  if (prelude) {
15804  prelude->nd_body = node;
15805  scope->nd_body = prelude;
15806  }
15807  else {
15808  scope->nd_body = node;
15809  }
15810 
15811  return scope;
15812 }
15813 
15814 static const struct {
15816  const char *name;
15817 } op_tbl[] = {
15818  {tDOT2, ".."},
15819  {tDOT3, "..."},
15820  {tPOW, "**"},
15821  {tUPLUS, "+@"},
15822  {tUMINUS, "-@"},
15823  {tCMP, "<=>"},
15824  {tGEQ, ">="},
15825  {tLEQ, "<="},
15826  {tEQ, "=="},
15827  {tEQQ, "==="},
15828  {tNEQ, "!="},
15829  {tMATCH, "=~"},
15830  {tNMATCH, "!~"},
15831  {tAREF, "[]"},
15832  {tASET, "[]="},
15833  {tLSHFT, "<<"},
15834  {tRSHFT, ">>"},
15835  {tCOLON2, "::"},
15836 };
15837 
15838 #define op_tbl_count numberof(op_tbl)
15839 
15840 #ifndef ENABLE_SELECTOR_NAMESPACE
15841 #define ENABLE_SELECTOR_NAMESPACE 0
15842 #endif
15843 
15844 static struct symbols {
15845  ID last_id;
15846  st_table *sym_id;
15847  st_table *id_str;
15848 #if ENABLE_SELECTOR_NAMESPACE
15849  st_table *ivar2_id;
15850  st_table *id_ivar2;
15851 #endif
15853 } global_symbols = {tLAST_ID};
15854 
15855 static const struct st_hash_type symhash = {
15857  rb_str_hash,
15858 };
15859 
15860 #if ENABLE_SELECTOR_NAMESPACE
15861 struct ivar2_key {
15862  ID id;
15863  VALUE klass;
15864 };
15865 
15866 static int
15867 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
15868 {
15869  if (key1->id == key2->id && key1->klass == key2->klass) {
15870  return 0;
15871  }
15872  return 1;
15873 }
15874 
15875 static int
15876 ivar2_hash(struct ivar2_key *key)
15877 {
15878  return (key->id << 8) ^ (key->klass >> 2);
15879 }
15880 
15881 static const struct st_hash_type ivar2_hash_type = {
15882  ivar2_cmp,
15883  ivar2_hash,
15884 };
15885 #endif
15886 
15887 void
15889 {
15890  global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
15892 #if ENABLE_SELECTOR_NAMESPACE
15893  global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
15894  global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
15895 #endif
15896 
15897  Init_id();
15898 }
15899 
15900 void
15902 {
15906 }
15907 #endif /* !RIPPER */
15908 
15909 static ID
15911 {
15912  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
15913  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
15914  return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
15915 }
15916 
15917 #ifndef RIPPER
15918 static int
15919 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
15920 {
15921  int mb = 0;
15922 
15923  if (m >= e) return 0;
15924  if (is_global_name_punct(*m)) {
15925  ++m;
15926  }
15927  else if (*m == '-') {
15928  ++m;
15929  if (m < e && is_identchar(m, e, enc)) {
15930  if (!ISASCII(*m)) mb = 1;
15931  m += rb_enc_mbclen(m, e, enc);
15932  }
15933  }
15934  else {
15935  if (!rb_enc_isdigit(*m, enc)) return 0;
15936  do {
15937  if (!ISASCII(*m)) mb = 1;
15938  ++m;
15939  } while (m < e && rb_enc_isdigit(*m, enc));
15940  }
15941  return m == e ? mb + 1 : 0;
15942 }
15943 
15944 int
15945 rb_symname_p(const char *name)
15946 {
15947  return rb_enc_symname_p(name, rb_ascii8bit_encoding());
15948 }
15949 
15950 int
15951 rb_enc_symname_p(const char *name, rb_encoding *enc)
15952 {
15953  return rb_enc_symname2_p(name, strlen(name), enc);
15954 }
15955 
15956 int
15957 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
15958 {
15959  const char *m = name;
15960  const char *e = m + len;
15961  int localid = FALSE;
15962 
15963  if (!m || len <= 0) return FALSE;
15964  switch (*m) {
15965  case '\0':
15966  return FALSE;
15967 
15968  case '$':
15969  if (is_special_global_name(++m, e, enc)) return TRUE;
15970  goto id;
15971 
15972  case '@':
15973  if (*++m == '@') ++m;
15974  goto id;
15975 
15976  case '<':
15977  switch (*++m) {
15978  case '<': ++m; break;
15979  case '=': if (*++m == '>') ++m; break;
15980  default: break;
15981  }
15982  break;
15983 
15984  case '>':
15985  switch (*++m) {
15986  case '>': case '=': ++m; break;
15987  }
15988  break;
15989 
15990  case '=':
15991  switch (*++m) {
15992  case '~': ++m; break;
15993  case '=': if (*++m == '=') ++m; break;
15994  default: return FALSE;
15995  }
15996  break;
15997 
15998  case '*':
15999  if (*++m == '*') ++m;
16000  break;
16001 
16002  case '+': case '-':
16003  if (*++m == '@') ++m;
16004  break;
16005 
16006  case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16007  ++m;
16008  break;
16009 
16010  case '[':
16011  if (*++m != ']') return FALSE;
16012  if (*++m == '=') ++m;
16013  break;
16014 
16015  case '!':
16016  if (len == 1) return TRUE;
16017  switch (*++m) {
16018  case '=': case '~': ++m; break;
16019  default: return FALSE;
16020  }
16021  break;
16022 
16023  default:
16024  localid = !rb_enc_isupper(*m, enc);
16025  id:
16026  if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16027  return FALSE;
16028  while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16029  if (localid) {
16030  switch (*m) {
16031  case '!': case '?': case '=': ++m;
16032  }
16033  }
16034  break;
16035  }
16036  return m == e;
16037 }
16038 
16039 static ID
16040 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16041 {
16042  VALUE str = rb_enc_str_new(name, len, enc);
16043  OBJ_FREEZE(str);
16046  return id;
16047 }
16048 
16049 ID
16050 rb_intern3(const char *name, long len, rb_encoding *enc)
16051 {
16052  const char *m = name;
16053  const char *e = m + len;
16054  unsigned char c;
16055  VALUE str;
16056  ID id;
16057  long last;
16058  int mb;
16059  st_data_t data;
16060  struct RString fake_str;
16061  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
16062  fake_str.basic.klass = rb_cString;
16063  fake_str.as.heap.len = len;
16064  fake_str.as.heap.ptr = (char *)name;
16065  fake_str.as.heap.aux.capa = len;
16066  str = (VALUE)&fake_str;
16067  rb_enc_associate(str, enc);
16068  OBJ_FREEZE(str);
16069 
16071  rb_raise(rb_eEncodingError, "invalid encoding symbol");
16072  }
16073 
16074  if (st_lookup(global_symbols.sym_id, str, &data))
16075  return (ID)data;
16076 
16077  if (rb_cString && !rb_enc_asciicompat(enc)) {
16078  id = ID_JUNK;
16079  goto new_id;
16080  }
16081  last = len-1;
16082  id = 0;
16083  switch (*m) {
16084  case '$':
16085  id |= ID_GLOBAL;
16086  if ((mb = is_special_global_name(++m, e, enc)) != 0) {
16087  if (!--mb) enc = rb_ascii8bit_encoding();
16088  goto new_id;
16089  }
16090  break;
16091  case '@':
16092  if (m[1] == '@') {
16093  m++;
16094  id |= ID_CLASS;
16095  }
16096  else {
16097  id |= ID_INSTANCE;
16098  }
16099  m++;
16100  break;
16101  default:
16102  c = m[0];
16103  if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
16104  /* operators */
16105  int i;
16106 
16107  if (len == 1) {
16108  id = c;
16109  goto id_register;
16110  }
16111  for (i = 0; i < op_tbl_count; i++) {
16112  if (*op_tbl[i].name == *m &&
16113  strcmp(op_tbl[i].name, m) == 0) {
16114  id = op_tbl[i].token;
16115  goto id_register;
16116  }
16117  }
16118  }
16119 
16120  if (m[last] == '=') {
16121  /* attribute assignment */
16122  id = rb_intern3(name, last, enc);
16123  if (id > tLAST_TOKEN && !is_attrset_id(id)) {
16124  enc = rb_enc_get(rb_id2str(id));
16125  id = rb_id_attrset(id);
16126  goto id_register;
16127  }
16128  id = ID_ATTRSET;
16129  }
16130  else if (rb_enc_isupper(m[0], enc)) {
16131  id = ID_CONST;
16132  }
16133  else {
16134  id = ID_LOCAL;
16135  }
16136  break;
16137  }
16138  mb = 0;
16139  if (!rb_enc_isdigit(*m, enc)) {
16140  while (m <= name + last && is_identchar(m, e, enc)) {
16141  if (ISASCII(*m)) {
16142  m++;
16143  }
16144  else {
16145  mb = 1;
16146  m += rb_enc_mbclen(m, e, enc);
16147  }
16148  }
16149  }
16150  if (m - name < len) id = ID_JUNK;
16151  if (enc != rb_usascii_encoding()) {
16152  /*
16153  * this clause makes sense only when called from other than
16154  * rb_intern_str() taking care of code-range.
16155  */
16156  if (!mb) {
16157  for (; m <= name + len; ++m) {
16158  if (!ISASCII(*m)) goto mbstr;
16159  }
16160  enc = rb_usascii_encoding();
16161  }
16162  mbstr:;
16163  }
16164  new_id:
16166  if (len > 20) {
16167  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
16168  name);
16169  }
16170  else {
16171  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
16172  (int)len, name);
16173  }
16174  }
16176  id_register:
16177  return register_symid(id, name, len, enc);
16178 }
16179 
16180 ID
16181 rb_intern2(const char *name, long len)
16182 {
16183  return rb_intern3(name, len, rb_usascii_encoding());
16184 }
16185 
16186 #undef rb_intern
16187 ID
16188 rb_intern(const char *name)
16189 {
16190  return rb_intern2(name, strlen(name));
16191 }
16192 
16193 ID
16195 {
16196  rb_encoding *enc;
16197  ID id;
16198 
16200  enc = rb_usascii_encoding();
16201  }
16202  else {
16203  enc = rb_enc_get(str);
16204  }
16205  id = rb_intern3(RSTRING_PTR(str), RSTRING_LEN(str), enc);
16206  RB_GC_GUARD(str);
16207  return id;
16208 }
16209 
16210 VALUE
16212 {
16213  st_data_t data;
16214 
16215  if (id < tLAST_TOKEN) {
16216  int i = 0;
16217 
16218  if (id < INT_MAX && rb_ispunct((int)id)) {
16219  VALUE str = global_symbols.op_sym[i = (int)id];
16220  if (!str) {
16221  char name[2];
16222  name[0] = (char)id;
16223  name[1] = 0;
16224  str = rb_usascii_str_new(name, 1);
16225  OBJ_FREEZE(str);
16226  global_symbols.op_sym[i] = str;
16227  }
16228  return str;
16229  }
16230  for (i = 0; i < op_tbl_count; i++) {
16231  if (op_tbl[i].token == id) {
16232  VALUE str = global_symbols.op_sym[i];
16233  if (!str) {
16234  str = rb_usascii_str_new2(op_tbl[i].name);
16235  OBJ_FREEZE(str);
16236  global_symbols.op_sym[i] = str;
16237  }
16238  return str;
16239  }
16240  }
16241  }
16242 
16243  if (st_lookup(global_symbols.id_str, id, &data)) {
16244  VALUE str = (VALUE)data;
16245  if (RBASIC(str)->klass == 0)
16246  RBASIC(str)->klass = rb_cString;
16247  return str;
16248  }
16249 
16250  if (is_attrset_id(id)) {
16251  ID id2 = (id & ~ID_SCOPE_MASK) | ID_LOCAL;
16252  VALUE str;
16253 
16254  while (!(str = rb_id2str(id2))) {
16255  if (!is_local_id(id2)) return 0;
16256  id2 = (id & ~ID_SCOPE_MASK) | ID_CONST;
16257  }
16258  str = rb_str_dup(str);
16259  rb_str_cat(str, "=", 1);
16260  rb_intern_str(str);
16261  if (st_lookup(global_symbols.id_str, id, &data)) {
16262  VALUE str = (VALUE)data;
16263  if (RBASIC(str)->klass == 0)
16264  RBASIC(str)->klass = rb_cString;
16265  return str;
16266  }
16267  }
16268  return 0;
16269 }
16270 
16271 const char *
16273 {
16274  VALUE str = rb_id2str(id);
16275 
16276  if (!str) return 0;
16277  return RSTRING_PTR(str);
16278 }
16279 
16280 static int
16282 {
16283  rb_ary_push(ary, ID2SYM(value));
16284  return ST_CONTINUE;
16285 }
16286 
16287 /*
16288  * call-seq:
16289  * Symbol.all_symbols => array
16290  *
16291  * Returns an array of all the symbols currently in Ruby's symbol
16292  * table.
16293  *
16294  * Symbol.all_symbols.size #=> 903
16295  * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
16296  * :chown, :EOFError, :$;, :String,
16297  * :LOCK_SH, :"setuid?", :$<,
16298  * :default_proc, :compact, :extend,
16299  * :Tms, :getwd, :$=, :ThreadGroup,
16300  * :wait2, :$>]
16301  */
16302 
16303 VALUE
16305 {
16307 
16309  return ary;
16310 }
16311 
16312 int
16314 {
16315  return is_const_id(id);
16316 }
16317 
16318 int
16320 {
16321  return is_class_id(id);
16322 }
16323 
16324 int
16326 {
16327  return is_instance_id(id);
16328 }
16329 
16330 int
16332 {
16333  return is_local_id(id);
16334 }
16335 
16336 int
16338 {
16339  return is_junk_id(id);
16340 }
16341 
16342 #endif /* !RIPPER */
16343 
16344 static void
16346 {
16347  parser->eofp = Qfalse;
16348 
16349  parser->parser_lex_strterm = 0;
16350  parser->parser_cond_stack = 0;
16351  parser->parser_cmdarg_stack = 0;
16352  parser->parser_class_nest = 0;
16353  parser->parser_paren_nest = 0;
16354  parser->parser_lpar_beg = 0;
16355  parser->parser_in_single = 0;
16356  parser->parser_in_def = 0;
16357  parser->parser_in_defined = 0;
16358  parser->parser_compile_for_eval = 0;
16359  parser->parser_cur_mid = 0;
16360  parser->parser_tokenbuf = NULL;
16361  parser->parser_tokidx = 0;
16362  parser->parser_toksiz = 0;
16363  parser->parser_heredoc_end = 0;
16364  parser->parser_command_start = TRUE;
16365  parser->parser_deferred_nodes = 0;
16366  parser->parser_lex_pbeg = 0;
16367  parser->parser_lex_p = 0;
16368  parser->parser_lex_pend = 0;
16369  parser->parser_lvtbl = 0;
16370  parser->parser_ruby__end__seen = 0;
16371  parser->parser_ruby_sourcefile = 0;
16372 #ifndef RIPPER
16373  parser->is_ripper = 0;
16374  parser->parser_eval_tree_begin = 0;
16375  parser->parser_eval_tree = 0;
16376 #else
16377  parser->is_ripper = 1;
16378  parser->parser_ruby_sourcefile_string = Qnil;
16379  parser->delayed = Qnil;
16380 
16381  parser->result = Qnil;
16382  parser->parsing_thread = Qnil;
16383  parser->toplevel_p = TRUE;
16384 #endif
16385 #ifdef YYMALLOC
16386  parser->heap = NULL;
16387 #endif
16388  parser->enc = rb_usascii_encoding();
16389 }
16390 
16391 #ifdef RIPPER
16392 #define parser_mark ripper_parser_mark
16393 #define parser_free ripper_parser_free
16394 #endif
16395 
16396 static void
16398 {
16399  struct parser_params *p = (struct parser_params*)ptr;
16400 
16406 #ifndef RIPPER
16409  rb_gc_mark(p->debug_lines);
16410 #else
16411  rb_gc_mark(p->parser_ruby_sourcefile_string);
16412  rb_gc_mark(p->delayed);
16413  rb_gc_mark(p->value);
16414  rb_gc_mark(p->result);
16415  rb_gc_mark(p->parsing_thread);
16416 #endif
16417 #ifdef YYMALLOC
16418  rb_gc_mark((VALUE)p->heap);
16419 #endif
16420 }
16421 
16422 static void
16423 parser_free(void *ptr)
16424 {
16425  struct parser_params *p = (struct parser_params*)ptr;
16426  struct local_vars *local, *prev;
16427 
16428  if (p->parser_tokenbuf) {
16429  xfree(p->parser_tokenbuf);
16430  }
16431  for (local = p->parser_lvtbl; local; local = prev) {
16432  if (local->vars) xfree(local->vars);
16433  prev = local->prev;
16434  xfree(local);
16435  }
16436 #ifndef RIPPER
16438 #endif
16439  xfree(p);
16440 }
16441 
16442 static size_t
16443 parser_memsize(const void *ptr)
16444 {
16445  struct parser_params *p = (struct parser_params*)ptr;
16446  struct local_vars *local;
16447  size_t size = sizeof(*p);
16448 
16449  if (!ptr) return 0;
16450  size += p->parser_toksiz;
16451  for (local = p->parser_lvtbl; local; local = local->prev) {
16452  size += sizeof(*local);
16453  if (local->vars) size += local->vars->capa * sizeof(ID);
16454  }
16455 #ifndef RIPPER
16456  if (p->parser_ruby_sourcefile) {
16457  size += strlen(p->parser_ruby_sourcefile) + 1;
16458  }
16459 #endif
16460  return size;
16461 }
16462 
16463 static
16464 #ifndef RIPPER
16465 const
16466 #endif
16467 rb_data_type_t parser_data_type = {
16468  "parser",
16469  {
16470  parser_mark,
16471  parser_free,
16473  },
16474 };
16475 
16476 #ifndef RIPPER
16477 #undef rb_reserved_word
16478 
16479 const struct kwtable *
16480 rb_reserved_word(const char *str, unsigned int len)
16481 {
16482  return reserved_word(str, len);
16483 }
16484 
16485 static struct parser_params *
16487 {
16488  struct parser_params *p;
16489 
16490  p = ALLOC_N(struct parser_params, 1);
16491  MEMZERO(p, struct parser_params, 1);
16492  parser_initialize(p);
16493  return p;
16494 }
16495 
16496 VALUE
16498 {
16499  struct parser_params *p = parser_new();
16500 
16501  return TypedData_Wrap_Struct(0, &parser_data_type, p);
16502 }
16503 
16504 /*
16505  * call-seq:
16506  * ripper#end_seen? -> Boolean
16507  *
16508  * Return true if parsed source ended by +\_\_END\_\_+.
16509  */
16510 VALUE
16512 {
16513  struct parser_params *parser;
16514 
16515  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16516  return ruby__end__seen ? Qtrue : Qfalse;
16517 }
16518 
16519 /*
16520  * call-seq:
16521  * ripper#encoding -> encoding
16522  *
16523  * Return encoding of the source.
16524  */
16525 VALUE
16527 {
16528  struct parser_params *parser;
16529 
16530  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16531  return rb_enc_from_encoding(parser->enc);
16532 }
16533 
16534 /*
16535  * call-seq:
16536  * ripper.yydebug -> true or false
16537  *
16538  * Get yydebug.
16539  */
16540 VALUE
16542 {
16543  struct parser_params *parser;
16544 
16545  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16546  return yydebug ? Qtrue : Qfalse;
16547 }
16548 
16549 /*
16550  * call-seq:
16551  * ripper.yydebug = flag
16552  *
16553  * Set yydebug.
16554  */
16555 VALUE
16557 {
16558  struct parser_params *parser;
16559 
16560  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16561  yydebug = RTEST(flag);
16562  return flag;
16563 }
16564 
16565 #ifdef YYMALLOC
16566 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
16567 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
16568 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
16569  (n)->u3.cnt = (c), (p))
16570 
16571 void *
16572 rb_parser_malloc(struct parser_params *parser, size_t size)
16573 {
16574  size_t cnt = HEAPCNT(1, size);
16575  NODE *n = NEWHEAP();
16576  void *ptr = xmalloc(size);
16577 
16578  return ADD2HEAP(n, cnt, ptr);
16579 }
16580 
16581 void *
16582 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
16583 {
16584  size_t cnt = HEAPCNT(nelem, size);
16585  NODE *n = NEWHEAP();
16586  void *ptr = xcalloc(nelem, size);
16587 
16588  return ADD2HEAP(n, cnt, ptr);
16589 }
16590 
16591 void *
16592 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
16593 {
16594  NODE *n;
16595  size_t cnt = HEAPCNT(1, size);
16596 
16597  if (ptr && (n = parser->heap) != NULL) {
16598  do {
16599  if (n->u1.node == ptr) {
16600  n->u1.node = ptr = xrealloc(ptr, size);
16601  if (n->u3.cnt) n->u3.cnt = cnt;
16602  return ptr;
16603  }
16604  } while ((n = n->u2.node) != NULL);
16605  }
16606  n = NEWHEAP();
16607  ptr = xrealloc(ptr, size);
16608  return ADD2HEAP(n, cnt, ptr);
16609 }
16610 
16611 void
16612 rb_parser_free(struct parser_params *parser, void *ptr)
16613 {
16614  NODE **prev = &parser->heap, *n;
16615 
16616  while ((n = *prev) != NULL) {
16617  if (n->u1.node == ptr) {
16618  *prev = n->u2.node;
16620  break;
16621  }
16622  prev = &n->u2.node;
16623  }
16624  xfree(ptr);
16625 }
16626 #endif
16627 #endif
16628 
16629 #ifdef RIPPER
16630 #ifdef RIPPER_DEBUG
16631 extern int rb_is_pointer_to_heap(VALUE);
16632 
16633 /* :nodoc: */
16634 static VALUE
16635 ripper_validate_object(VALUE self, VALUE x)
16636 {
16637  if (x == Qfalse) return x;
16638  if (x == Qtrue) return x;
16639  if (x == Qnil) return x;
16640  if (x == Qundef)
16641  rb_raise(rb_eArgError, "Qundef given");
16642  if (FIXNUM_P(x)) return x;
16643  if (SYMBOL_P(x)) return x;
16644  if (!rb_is_pointer_to_heap(x))
16645  rb_raise(rb_eArgError, "invalid pointer: %p", x);
16646  switch (TYPE(x)) {
16647  case T_STRING:
16648  case T_OBJECT:
16649  case T_ARRAY:
16650  case T_BIGNUM:
16651  case T_FLOAT:
16652  return x;
16653  case T_NODE:
16654  if (nd_type(x) != NODE_LASGN) {
16655  rb_raise(rb_eArgError, "NODE given: %p", x);
16656  }
16657  return ((NODE *)x)->nd_rval;
16658  default:
16659  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
16660  x, rb_obj_classname(x));
16661  }
16662  return x;
16663 }
16664 #endif
16665 
16666 #define validate(x) ((x) = get_value(x))
16667 
16668 static VALUE
16669 ripper_dispatch0(struct parser_params *parser, ID mid)
16670 {
16671  return rb_funcall(parser->value, mid, 0);
16672 }
16673 
16674 static VALUE
16675 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
16676 {
16677  validate(a);
16678  return rb_funcall(parser->value, mid, 1, a);
16679 }
16680 
16681 static VALUE
16682 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
16683 {
16684  validate(a);
16685  validate(b);
16686  return rb_funcall(parser->value, mid, 2, a, b);
16687 }
16688 
16689 static VALUE
16690 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
16691 {
16692  validate(a);
16693  validate(b);
16694  validate(c);
16695  return rb_funcall(parser->value, mid, 3, a, b, c);
16696 }
16697 
16698 static VALUE
16699 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
16700 {
16701  validate(a);
16702  validate(b);
16703  validate(c);
16704  validate(d);
16705  return rb_funcall(parser->value, mid, 4, a, b, c, d);
16706 }
16707 
16708 static VALUE
16709 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
16710 {
16711  validate(a);
16712  validate(b);
16713  validate(c);
16714  validate(d);
16715  validate(e);
16716  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
16717 }
16718 
16719 static const struct kw_assoc {
16720  ID id;
16721  const char *name;
16722 } keyword_to_name[] = {
16723  {keyword_class, "class"},
16724  {keyword_module, "module"},
16725  {keyword_def, "def"},
16726  {keyword_undef, "undef"},
16727  {keyword_begin, "begin"},
16728  {keyword_rescue, "rescue"},
16729  {keyword_ensure, "ensure"},
16730  {keyword_end, "end"},
16731  {keyword_if, "if"},
16732  {keyword_unless, "unless"},
16733  {keyword_then, "then"},
16734  {keyword_elsif, "elsif"},
16735  {keyword_else, "else"},
16736  {keyword_case, "case"},
16737  {keyword_when, "when"},
16738  {keyword_while, "while"},
16739  {keyword_until, "until"},
16740  {keyword_for, "for"},
16741  {keyword_break, "break"},
16742  {keyword_next, "next"},
16743  {keyword_redo, "redo"},
16744  {keyword_retry, "retry"},
16745  {keyword_in, "in"},
16746  {keyword_do, "do"},
16747  {keyword_do_cond, "do"},
16748  {keyword_do_block, "do"},
16749  {keyword_return, "return"},
16750  {keyword_yield, "yield"},
16751  {keyword_super, "super"},
16752  {keyword_self, "self"},
16753  {keyword_nil, "nil"},
16754  {keyword_true, "true"},
16755  {keyword_false, "false"},
16756  {keyword_and, "and"},
16757  {keyword_or, "or"},
16758  {keyword_not, "not"},
16759  {modifier_if, "if"},
16760  {modifier_unless, "unless"},
16761  {modifier_while, "while"},
16762  {modifier_until, "until"},
16763  {modifier_rescue, "rescue"},
16764  {keyword_alias, "alias"},
16765  {keyword_defined, "defined?"},
16766  {keyword_BEGIN, "BEGIN"},
16767  {keyword_END, "END"},
16768  {keyword__LINE__, "__LINE__"},
16769  {keyword__FILE__, "__FILE__"},
16770  {keyword__ENCODING__, "__ENCODING__"},
16771  {0, NULL}
16772 };
16773 
16774 static const char*
16775 keyword_id_to_str(ID id)
16776 {
16777  const struct kw_assoc *a;
16778 
16779  for (a = keyword_to_name; a->id; a++) {
16780  if (a->id == id)
16781  return a->name;
16782  }
16783  return NULL;
16784 }
16785 
16786 #undef ripper_id2sym
16787 static VALUE
16788 ripper_id2sym(ID id)
16789 {
16790  const char *name;
16791  char buf[8];
16792 
16793  if (id <= 256) {
16794  buf[0] = (char)id;
16795  buf[1] = '\0';
16796  return ID2SYM(rb_intern2(buf, 1));
16797  }
16798  if ((name = keyword_id_to_str(id))) {
16799  return ID2SYM(rb_intern(name));
16800  }
16801  switch (id) {
16802  case tOROP:
16803  name = "||";
16804  break;
16805  case tANDOP:
16806  name = "&&";
16807  break;
16808  default:
16809  name = rb_id2name(id);
16810  if (!name) {
16811  rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
16812  }
16813  return ID2SYM(id);
16814  }
16815  return ID2SYM(rb_intern(name));
16816 }
16817 
16818 static ID
16819 ripper_get_id(VALUE v)
16820 {
16821  NODE *nd;
16822  if (!RB_TYPE_P(v, T_NODE)) return 0;
16823  nd = (NODE *)v;
16824  if (nd_type(nd) != NODE_LASGN) return 0;
16825  return nd->nd_vid;
16826 }
16827 
16828 static VALUE
16829 ripper_get_value(VALUE v)
16830 {
16831  NODE *nd;
16832  if (v == Qundef) return Qnil;
16833  if (!RB_TYPE_P(v, T_NODE)) return v;
16834  nd = (NODE *)v;
16835  if (nd_type(nd) != NODE_LASGN) return Qnil;
16836  return nd->nd_rval;
16837 }
16838 
16839 static void
16840 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
16841 {
16842  VALUE str;
16843  va_list args;
16844 
16845  va_start(args, fmt);
16846  str = rb_vsprintf(fmt, args);
16847  va_end(args);
16848  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
16849 }
16850 
16851 static void
16852 ripper_warn0(struct parser_params *parser, const char *fmt)
16853 {
16854  rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
16855 }
16856 
16857 static void
16858 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
16859 {
16860  rb_funcall(parser->value, rb_intern("warn"), 2,
16861  STR_NEW2(fmt), INT2NUM(a));
16862 }
16863 
16864 #if 0
16865 static void
16866 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
16867 {
16868  rb_funcall(parser->value, rb_intern("warn"), 2,
16869  STR_NEW2(fmt), STR_NEW2(str));
16870 }
16871 #endif
16872 
16873 static void
16874 ripper_warning0(struct parser_params *parser, const char *fmt)
16875 {
16876  rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
16877 }
16878 
16879 static void
16880 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
16881 {
16882  rb_funcall(parser->value, rb_intern("warning"), 2,
16883  STR_NEW2(fmt), STR_NEW2(str));
16884 }
16885 
16886 static VALUE
16887 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
16888 {
16889  return rb_funcall(src, ripper_id_gets, 0);
16890 }
16891 
16892 static VALUE
16893 ripper_s_allocate(VALUE klass)
16894 {
16895  struct parser_params *p;
16896  VALUE self;
16897 
16898  p = ALLOC_N(struct parser_params, 1);
16899  MEMZERO(p, struct parser_params, 1);
16900  self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
16901  p->value = self;
16902  return self;
16903 }
16904 
16905 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
16906 
16907 /*
16908  * call-seq:
16909  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
16910  *
16911  * Create a new Ripper object.
16912  * _src_ must be a String, an IO, or an Object which has #gets method.
16913  *
16914  * This method does not starts parsing.
16915  * See also Ripper#parse and Ripper.parse.
16916  */
16917 static VALUE
16918 ripper_initialize(int argc, VALUE *argv, VALUE self)
16919 {
16920  struct parser_params *parser;
16921  VALUE src, fname, lineno;
16922 
16923  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16924  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
16925  if (rb_obj_respond_to(src, ripper_id_gets, 0)) {
16926  parser->parser_lex_gets = ripper_lex_get_generic;
16927  }
16928  else {
16929  StringValue(src);
16930  parser->parser_lex_gets = lex_get_str;
16931  }
16932  parser->parser_lex_input = src;
16933  parser->eofp = Qfalse;
16934  if (NIL_P(fname)) {
16935  fname = STR_NEW2("(ripper)");
16936  }
16937  else {
16938  StringValue(fname);
16939  }
16940  parser_initialize(parser);
16941 
16942  parser->parser_ruby_sourcefile_string = fname;
16943  parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
16944  parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
16945 
16946  return Qnil;
16947 }
16948 
16949 struct ripper_args {
16950  struct parser_params *parser;
16951  int argc;
16952  VALUE *argv;
16953 };
16954 
16955 static VALUE
16956 ripper_parse0(VALUE parser_v)
16957 {
16958  struct parser_params *parser;
16959 
16960  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
16961  parser_prepare(parser);
16962  ripper_yyparse((void*)parser);
16963  return parser->result;
16964 }
16965 
16966 static VALUE
16967 ripper_ensure(VALUE parser_v)
16968 {
16969  struct parser_params *parser;
16970 
16971  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
16972  parser->parsing_thread = Qnil;
16973  return Qnil;
16974 }
16975 
16976 /*
16977  * call-seq:
16978  * ripper#parse
16979  *
16980  * Start parsing and returns the value of the root action.
16981  */
16982 static VALUE
16983 ripper_parse(VALUE self)
16984 {
16985  struct parser_params *parser;
16986 
16987  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
16988  if (!ripper_initialized_p(parser)) {
16989  rb_raise(rb_eArgError, "method called for uninitialized object");
16990  }
16991  if (!NIL_P(parser->parsing_thread)) {
16992  if (parser->parsing_thread == rb_thread_current())
16993  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
16994  else
16995  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
16996  }
16997  parser->parsing_thread = rb_thread_current();
16998  rb_ensure(ripper_parse0, self, ripper_ensure, self);
16999 
17000  return parser->result;
17001 }
17002 
17003 /*
17004  * call-seq:
17005  * ripper#column -> Integer
17006  *
17007  * Return column number of current parsing line.
17008  * This number starts from 0.
17009  */
17010 static VALUE
17011 ripper_column(VALUE self)
17012 {
17013  struct parser_params *parser;
17014  long col;
17015 
17016  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17017  if (!ripper_initialized_p(parser)) {
17018  rb_raise(rb_eArgError, "method called for uninitialized object");
17019  }
17020  if (NIL_P(parser->parsing_thread)) return Qnil;
17021  col = parser->tokp - parser->parser_lex_pbeg;
17022  return LONG2NUM(col);
17023 }
17024 
17025 /*
17026  * call-seq:
17027  * ripper#filename -> String
17028  *
17029  * Return current parsing filename.
17030  */
17031 static VALUE
17032 ripper_filename(VALUE self)
17033 {
17034  struct parser_params *parser;
17035 
17036  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17037  if (!ripper_initialized_p(parser)) {
17038  rb_raise(rb_eArgError, "method called for uninitialized object");
17039  }
17040  return parser->parser_ruby_sourcefile_string;
17041 }
17042 
17043 /*
17044  * call-seq:
17045  * ripper#lineno -> Integer
17046  *
17047  * Return line number of current parsing line.
17048  * This number starts from 1.
17049  */
17050 static VALUE
17051 ripper_lineno(VALUE self)
17052 {
17053  struct parser_params *parser;
17054 
17055  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17056  if (!ripper_initialized_p(parser)) {
17057  rb_raise(rb_eArgError, "method called for uninitialized object");
17058  }
17059  if (NIL_P(parser->parsing_thread)) return Qnil;
17060  return INT2NUM(parser->parser_ruby_sourceline);
17061 }
17062 
17063 #ifdef RIPPER_DEBUG
17064 /* :nodoc: */
17065 static VALUE
17066 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
17067 {
17068  StringValue(msg);
17069  if (obj == Qundef) {
17070  rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
17071  }
17072  return Qnil;
17073 }
17074 
17075 /* :nodoc: */
17076 static VALUE
17077 ripper_value(VALUE self, VALUE obj)
17078 {
17079  return ULONG2NUM(obj);
17080 }
17081 #endif
17082 
17083 
17084 void
17085 InitVM_ripper(void)
17086 {
17087  parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
17088 }
17089 
17090 void
17091 Init_ripper(void)
17092 {
17093  VALUE Ripper;
17094 
17095  InitVM(ripper);
17096  Ripper = rb_define_class("Ripper", rb_cObject);
17097  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
17098  rb_define_alloc_func(Ripper, ripper_s_allocate);
17099  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
17100  rb_define_method(Ripper, "parse", ripper_parse, 0);
17101  rb_define_method(Ripper, "column", ripper_column, 0);
17102  rb_define_method(Ripper, "filename", ripper_filename, 0);
17103  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
17104  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
17105  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
17106  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
17107  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
17108 #ifdef RIPPER_DEBUG
17109  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
17110  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
17111  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
17112 #endif
17113 
17114  ripper_id_gets = rb_intern("gets");
17115  ripper_init_eventids1(Ripper);
17116  ripper_init_eventids2(Ripper);
17117  /* ensure existing in symbol table */
17118  (void)rb_intern("||");
17119  (void)rb_intern("&&");
17120 
17121 # if 0
17122  /* Hack to let RDoc document SCRIPT_LINES__ */
17123 
17124  /*
17125  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
17126  * after the assignment will be added as an Array of lines with the file
17127  * name as the key.
17128  */
17129  rb_define_global_const("SCRIPT_LINES__", Qnil);
17130 #endif
17131 
17132 }
17133 #endif /* RIPPER */
17134 
#define STRNCASECMP(s1, s2, n)
Definition: ruby.h:1467
#define toklast()
Definition: parse.c:11692
RUBY_EXTERN VALUE rb_cString
Definition: ruby.h:1276
#define tokadd_mbchar(c)
Definition: parse.c:12052
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:1937
#define command_start
Definition: parse.c:361
char * parser_ruby_sourcefile
Definition: ripper.c:295
VALUE val
Definition: ripper.c:832
#define YYFPRINTF
Definition: parse.c:4287
#define YYLAST
Definition: parse.c:1072
#define RSTRING_LEN(string)
Definition: generator.h:45
#define evstr2dstr(n)
Definition: parse.c:428
#define nd_aid
Definition: parse.y:312
int nodeline(NODE *node)
Definition: parse.c:14230
#define T_OBJECT
Definition: ruby.h:413
Definition: node.h:91
Definition: node.h:29
static NODE * call_bin_op_gen(struct parser_params *, NODE *, ID, NODE *)
Definition: parse.c:14468
stack_type cmdargs
Definition: ripper.c:163
#define NEW_RETURN(s)
Definition: parse.y:375
enum lex_state_e state
Definition: lex.c:33
struct local_vars * parser_lvtbl
Definition: ripper.c:291
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: parse.c:4531
VALUE rb_ary_unshift(VALUE ary, VALUE item)
Definition: array.c:939
static ID ripper_token2eventid(int tok)
Definition: eventids2.c:267
static ID internal_id_gen(struct parser_params *)
Definition: parse.c:15910
Definition: lex.c:33
#define tokenbuf
Definition: parse.c:351
int rb_enc_codelen(int c, rb_encoding *enc)
Definition: encoding.c:916
#define NEW_OP_ASGN_AND(i, val)
Definition: parse.y:395
static double zero(void)
Definition: isinf.c:51
#define YY_REDUCE_PRINT(Rule)
Definition: parse.c:4433
#define shadowing_lvar(name)
Definition: parse.c:497
#define MBCLEN_CHARFOUND_P(ret)
Definition: encoding.h:135
static void arg_ambiguous_gen(struct parser_params *parser)
Definition: parse.c:12542
#define nextc()
Definition: parse.c:11094
static long parser_encode_length(struct parser_params *parser, const char *name, long len)
Definition: parse.c:12571
Definition: ripper.c:753
#define RE_OPTION_ENCODING_IDX(o)
Definition: parse.c:533
#define NEW_OP_ASGN1(p, id, a)
Definition: parse.y:391
int onig_foreach_name(regex_t *reg, int(*func)(const UChar *, const UChar *, int, int *, regex_t *, void *), void *arg)
Definition: regparse.c:530
void * rb_parser_malloc(struct parser_params *parser, size_t size)
Definition: parse.c:16572
#define NEW_SCLASS(r, b)
Definition: parse.y:433
#define lex_strterm
Definition: parse.c:339
static void Init_id(void)
Definition: id.c:17
Definition: ripper.c:778
void rb_bug(const char *fmt,...)
Definition: error.c:265
int num
Definition: ripper.c:835
#define mixed_escape(beg, enc1, enc2)
static const yytype_uint8 yyr2[]
Definition: parse.c:1597
struct token_info * next
Definition: ripper.c:245
static NODE * attrset_gen(struct parser_params *, NODE *, ID)
Definition: parse.c:14729
#define FALSE
Definition: nkf.h:185
static const struct kwtable * reserved_word(const char *, unsigned int)
#define CMDARG_P()
Definition: parse.c:149
#define heredoc_end
Definition: parse.c:360
#define NEW_LIST(a)
Definition: parse.y:377
#define NEW_DEFINED(e)
Definition: parse.y:444
struct vtable * used
Definition: ripper.c:161
#define tHEREDOC_BEG
Definition: eventids2.c:7
#define pushback(c)
Definition: parse.c:11095
#define rb_gc_mark_locations(start, end)
Definition: gc.c:1571
size_t strlen(const char *)
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2516
int i
Definition: win32ole.c:776
VALUE parser_lex_nextline
Definition: ripper.c:282
VALUE rb_make_exception(int argc, VALUE *argv)
Definition: eval.c:574
#define is_const_id(id)
Definition: parse.c:110
union RNode::@43 u3
#define scan_oct(s, l, e)
Definition: util.h:52
#define nd_plen
Definition: parse.y:320
#define compile_error
Definition: parse.c:650
#define T_FIXNUM
Definition: ruby.h:425
Definition: st.h:77
static NODE * negate_lit(NODE *)
Definition: parse.c:15310
VALUE stack_type
Definition: ripper.c:134
#define toklen()
Definition: parse.c:11691
#define new_yield(node)
Definition: parse.c:444
#define dispatch_heredoc_end()
Definition: parse.c:12435
static NODE * node_assign_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14801
Definition: node.h:47
#define NEW_XSTR(s)
Definition: parse.y:410
int parser_ruby__end__seen
Definition: ripper.c:292
static void ripper_init_eventids2(VALUE self)
Definition: eventids2.c:62
static void local_push_gen(struct parser_params *, int)
Definition: parse.c:15385
static int vtable_size(const struct vtable *tbl)
Definition: parse.c:172
#define formal_argument(id)
Definition: parse.c:495
int parser_command_start
Definition: ripper.c:287
const struct kwtable * rb_reserved_word(const char *str, unsigned int len)
Definition: parse.c:16480
VALUE rb_range_new(VALUE, VALUE, int)
Definition: range.c:61
#define YY_STACK_PRINT(Bottom, Top)
Definition: parse.c:4394
static NODE * arg_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14750
#define NUM2INT(x)
Definition: ruby.h:536
#define is_notop_id(id)
Definition: parse.c:105
#define NEW_DOT2(b, e)
Definition: parse.y:437
#define tokfix()
Definition: parse.c:11689
static NODE * evstr2dstr_gen(struct parser_params *, NODE *)
Definition: parse.c:14445
#define local_pop()
Definition: parse.c:504
static void yy_reduce_print(YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
Definition: parse.c:4411
static int token_info_has_nonspaces(struct parser_params *parser, const char *token)
Definition: parse.c:11226
#define malloc
Definition: parse.c:94
Definition: ripper.c:794
#define local_var(id)
Definition: parse.c:506
static NODE * arg_blk_pass(NODE *, NODE *)
Definition: parse.c:15329
#define IS_LABEL_POSSIBLE()
Definition: parse.c:12881
#define is_asgn_or_id(id)
Definition: parse.c:114
const char * name
Definition: lex.c:33
#define tEMBDOC_BEG
Definition: eventids2.c:3
static void reg_fragment_setenc_gen(struct parser_params *, VALUE, int)
Definition: parse.c:15579
#define POINTER_P(val)
Definition: parse.c:169
int parser_compile_for_eval
Definition: ripper.c:274
int parser_token_info_enabled
Definition: ripper.c:310
#define parser_precise_mbclen()
Definition: parse.c:11204
static ID formal_argument_gen(struct parser_params *, ID)
Definition: parse.c:12553
static int parser_read_escape(struct parser_params *parser, int flags, rb_encoding **encp)
Definition: parse.c:11823
#define internal_id()
Definition: parse.c:512
static VALUE reg_compile_gen(struct parser_params *, VALUE, int)
Definition: parse.c:15713
VALUE op_sym[tLAST_TOKEN]
Definition: ripper.c:15942
static ID register_symid(ID, const char *, long, rb_encoding *)
Definition: parse.c:16040
unsigned short int yytype_uint16
Definition: parse.c:877
static VALUE yycompile0(VALUE arg, int tracing)
Definition: parse.c:11390
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:1889
#define lex_nextline
Definition: parse.c:356
#define st_foreach
Definition: regint.h:150
union YYSTYPE YYSTYPE
ID rb_intern_str(VALUE str)
Definition: parse.c:16194
Definition: ripper.c:772
#define nd_line(n)
Definition: parse.y:277
#define LONG2NUM(i)
Definition: cparse.c:72
#define Qtrue
Definition: ruby.h:366
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2289
#define RE_OPTION_ENCODING(e)
Definition: parse.c:532
NODE * rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
Definition: parse.c:15774
static ID * vtable_tblcpy(ID *buf, const struct vtable *src)
Definition: parse.c:15416
#define yyparse
Definition: parse.c:386
Definition: ripper.c:756
#define DVARS_TOPSCOPE
Definition: parse.c:167
#define RFLOAT_VALUE(val)
Definition: generator.h:32
#define set_yylval_str(x)
Definition: parse.c:11112
static const yytype_uint16 yyr1[]
Definition: parse.c:1534
#define gettable(id)
Definition: parse.c:447
#define set_yylval_literal(x)
Definition: parse.c:11116
Definition: ripper.c:761
#define TypedData_Wrap_Struct(klass, data_type, sval)
Definition: ruby.h:826
#define yytable_value_is_error(yytable_value)
Definition: parse.c:3005
#define YYPARSE_PARAM
Definition: gram.c:103
#define YYPOPSTACK(N)
Definition: ripper.c:795
#define ADD2HEAP(n, c, p)
Definition: parse.c:16568
VALUE rb_parser_encoding(VALUE vparser)
Definition: parse.c:16526
#define TypedData_Get_Struct(obj, type, data_type, sval)
Definition: ruby.h:840
#define literal_concat(h, t)
Definition: parse.c:423
const int id
Definition: nkf.c:209
static void block_dup_check_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14713
int line_count
Definition: ripper.c:293
stack_type parser_cmdarg_stack
Definition: ripper.c:268
node_type
Definition: node.h:22
Definition: ripper.c:759
VALUE rb_external_str_new_with_enc(const char *ptr, long len, rb_encoding *)
Definition: string.c:534
#define strcasecmp
Definition: win32.h:208
#define STR_NEW2(p)
Definition: parse.c:331
static int lvar_defined_gen(struct parser_params *, ID)
Definition: parse.c:12564
#define ID_CONST
Definition: parse.y:23
#define tokspace(n)
Definition: parse.c:11097
VALUE rb_enc_from_encoding(rb_encoding *encoding)
Definition: encoding.c:102
#define NEW_ARGS(m, o)
Definition: parse.y:419
static ID * local_tbl_gen(struct parser_params *)
Definition: parse.c:15431
#define rb_warnI(fmt, a)
Definition: parse.c:624
#define PARSER_ARG
Definition: parse.c:651
#define ID_JUNK
Definition: parse.y:25
#define lvar_defined(id)
Definition: parse.c:528
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:740
Definition: ripper.c:767
ID rb_intern3(const char *name, long len, rb_encoding *enc)
Definition: parse.c:16050
#define NEW_CLASS(n, b, s)
Definition: parse.y:432
#define lex_pbeg
Definition: parse.c:357
Definition: ripper.c:780
Definition: ripper.c:757
VALUE rb_eEncodingError
Definition: error.c:473
NODE * rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
Definition: parse.c:11562
#define subnodes(n1, n2)
#define yydebug
Definition: parse.c:370
struct RBasic basic
Definition: ruby.h:653
#define YYSTACK_BYTES(N)
Definition: parse.c:1025
#define nd_term(node)
Definition: parse.c:545
unsigned short int yytype_uint16
Definition: ripper.c:877
static int parser_yylex(struct parser_params *parser)
Definition: parse.c:12899
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:750
#define NEW_OPT_N(b)
Definition: parse.y:361
#define CMDARG_LEXPOP()
Definition: parse.c:148
static VALUE INT2NUM(int v)
Definition: ruby.h:981
rb_encoding * utf8
Definition: ripper.c:298
static NODE * new_evstr_gen(struct parser_params *, NODE *)
Definition: parse.c:14454
Definition: ripper.c:779
VALUE debug_lines
Definition: ripper.c:306
static int parser_regx_options(struct parser_params *)
Definition: parse.c:11994
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
Definition: vm_eval.c:638
ID id
Definition: ripper.c:834
#define RSTRING_PTR(string)
Definition: generator.h:42
static void set_file_encoding(struct parser_params *parser, const char *str, const char *send)
Definition: parse.c:12810
static NODE * newline_node(NODE *)
Definition: parse.c:14236
int rb_enc_str_coderange(VALUE)
Definition: string.c:324
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1574
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: parse.c:4296
#define RE_OPTION_ONCE
Definition: parse.c:530
#define NEW_NIL()
Definition: parse.y:440
static const yytype_uint16 yyprhs[]
Definition: parse.c:1136
#define block_dup_check(n1, n2)
Definition: parse.c:410
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
Definition: encoding.c:727
static void warn_unused_var(struct parser_params *parser, struct local_vars *local)
Definition: parse.c:15365
ID * tbl
Definition: ripper.c:152
#define MAX_WORD_LENGTH
Definition: name2ctype.h:22187
const rb_data_type_t * parent
Definition: ruby.h:779
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:153
#define attrset(node, id)
Definition: parse.c:454
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
#define T_HASH
Definition: ruby.h:421
int parser_toksiz
Definition: ripper.c:279
static NODE * assignable_gen(struct parser_params *, ID, NODE *)
Definition: parse.c:14587
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
Definition: encoding.c:847
Definition: ripper.c:783
#define ID_LOCAL
Definition: parse.y:19
st_index_t rb_str_hash(VALUE)
Definition: string.c:2170
#define nd_args
Definition: parse.y:324
#define RARRAY_LEN(ARRAY)
Definition: generator.h:39
#define nd_set_type(n, t)
Definition: parse.y:272
ID last_id
Definition: ripper.c:15935
static size_t parser_memsize(const void *ptr)
Definition: parse.c:16443
nd_set_line($$,$< num >2)
static void fixpos(NODE *, NODE *)
Definition: parse.c:14246
void rb_gc_mark(VALUE ptr)
Definition: gc.c:1764
#define lex_pend
Definition: parse.c:359
static NODE * gettable_gen(struct parser_params *, ID)
Definition: parse.c:14517
#define T_ARRAY
Definition: ruby.h:420
#define NEW_DOT3(b, e)
Definition: parse.y:438
#define nd_paren(node)
Definition: parse.c:547
#define st_lookup
Definition: regint.h:149
#define cmdarg_stack
Definition: parse.c:342
#define rb_enc_islower(c, enc)
Definition: encoding.h:173
static struct symbols global_symbols
#define is_class_id(id)
Definition: parse.c:111
static NODE * cond0(struct parser_params *, NODE *)
Definition: parse.c:15189
#define NEW_ITER(a, b)
Definition: parse.y:365
#define STR_NEW0()
Definition: parse.c:330
void rb_gc_mark_parser(void)
Definition: parse.c:15737
#define numberof(array)
Definition: parse.c:88
#define reg_compile(str, options)
Definition: parse.c:470
#define ISDIGIT(c)
static int local_var_gen(struct parser_params *, ID)
Definition: parse.c:15453
#define str_copy(_s, _p, _n)
#define NEW_IVAR(v)
Definition: parse.y:399
unsigned int last
Definition: nkf.c:3915
static NODE * match_op_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14483
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
Definition: parse.c:4380
struct RNode * node
Definition: node.h:239
#define NEW_IASGN(v, val)
Definition: parse.y:386
#define FIXNUM_P(f)
Definition: ruby.h:338
rb_encoding * rb_utf8_encoding(void)
Definition: encoding.c:1125
VALUE parser_lex_input
Definition: ripper.c:280
static int dvar_defined_gen(struct parser_params *, ID, int)
Definition: parse.c:15540
#define nd_type(n)
Definition: parse.y:271
static NODE * new_yield_gen(struct parser_params *, NODE *)
Definition: parse.c:15293
#define RE_OPTION_ENCODING_NONE(o)
Definition: parse.c:534
#define YYNTOKENS
Definition: parse.c:1075
static char * parser_tokspace(struct parser_params *parser, int n)
Definition: parse.c:11710
VALUE klass
Definition: ruby.h:598
int rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
Definition: parse.c:15957
#define tokadd_string(f, t, p, n, e)
Definition: parse.c:11103
#define paren_nest
Definition: parse.c:344
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2031
#define is_identchar(p, e, enc)
Definition: parse.c:11205
#define ID2SYM(i)
Definition: cparse.c:63
int pos
Definition: ripper.c:153
static void parser_heredoc_restore(struct parser_params *parser, NODE *here)
Definition: parse.c:12392
static NODE * remove_begin(NODE *)
Definition: parse.c:14997
static int is_global_name_punct(const char c)
Definition: parse.c:12228
NODE * rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: parse.c:11527
#define st_init_numtable_with_size
Definition: regint.h:143
#define ENC_CODERANGE_7BIT
Definition: encoding.h:58
const char * rb_obj_classname(VALUE)
Definition: variable.c:318
void rb_gc_force_recycle(VALUE p)
Definition: gc.c:2345
#define lex_lastline
Definition: parse.c:355
#define NEW_SCOPE(a, b)
Definition: parse.y:355
#define tok_hex(numlen)
Definition: parse.c:11099
unsigned char OnigUChar
Definition: oniguruma.h:110
int parser_yydebug
Definition: ripper.c:300
Definition: node.h:27
st_table * id_str
Definition: ripper.c:15937
static const yytype_int16 yytable[]
Definition: parse.c:1923
NODE * parser_eval_tree
Definition: ripper.c:305
NODE * parser_deferred_nodes
Definition: ripper.c:288
#define sym(x)
Definition: date_core.c:3748
VALUE rb_str_buf_cat(VALUE, const char *, long)
Definition: string.c:1873
command_asgn lhs
Definition: ripper.y:1241
static int dyna_in_block_gen(struct parser_params *)
Definition: parse.c:15534
static const rb_data_type_t parser_data_type
Definition: parse.c:11497
Definition: node.h:235
#define YYSYNTAX_ERROR
#define YYABORT
Definition: parse.c:4199
int has_shebang
Definition: ripper.c:294
Win32OLEIDispatch * p
Definition: win32ole.c:778
#define logop(type, node1, node2)
Definition: parse.c:394
static rb_encoding * must_be_ascii_compatible(VALUE s)
Definition: parse.c:11447
#define ISALPHA(c)
Definition: ruby.h:1457
static void dyna_pop_1(struct parser_params *parser)
Definition: parse.c:15502
void rb_exc_raise(VALUE mesg)
Definition: eval.c:460
block_command ripper_id2sym('.')
#define in_single
Definition: parse.c:346
#define NEW_VCALL(m)
Definition: parse.y:416
int args
Definition: win32ole.c:777
#define strtod(s, e)
Definition: util.h:76
#define parser_warn(node, mesg)
Definition: parse.c:14266
struct vtable * prev
Definition: ripper.c:155
#define NEW_VALIAS(n, o)
Definition: parse.y:430
#define RB_TYPE_P(obj, type)
Definition: ruby.h:1353
#define NEW_LVAR(v)
Definition: parse.y:397
static void warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: parse.c:15109
#define NEW_ATTRASGN(r, m, a)
Definition: parse.y:448
#define MEMZERO(p, type, n)
Definition: ruby.h:1052
#define toksiz
Definition: parse.c:353
Definition: ruby.h:652
Definition: ripper.c:765
#define ID_SCOPE_MASK
Definition: parse.y:18
static VALUE coverage(const char *f, int n)
Definition: parse.c:11367
rb_encoding * enc
Definition: ripper.c:297
static void parser_free(void *ptr)
Definition: parse.c:16423
#define free
Definition: parse.c:97
enum lex_state_e parser_lex_state
Definition: ripper.c:266
int rb_is_local_id(ID id)
Definition: parse.c:16331
#define lex_gets
Definition: parse.c:364
#define NEW_POSTEXE(b)
Definition: parse.y:446
int capa
Definition: ripper.c:154
VALUE parser_lex_lastline
Definition: ripper.c:281
void * rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
Definition: parse.c:16592
#define void_expr(node)
Definition: parse.c:404
static void parser_initialize(struct parser_params *parser)
Definition: parse.c:16345
#define scan_hex(s, l, e)
Definition: util.h:54
static void parser_set_encode(struct parser_params *parser, const char *name)
Definition: parse.c:12591
#define NEW_IF(c, t, e)
Definition: parse.y:357
#define local_id(id)
Definition: parse.c:510
#define here_document(n)
Definition: parse.c:11106
#define lex_goto_eol(parser)
Definition: parse.c:11616
#define RARRAY(obj)
Definition: ruby.h:911
Definition: ripper.c:752
#define ruby_sourcefile
Definition: parse.c:368
#define ALLOC_N(type, n)
Definition: ruby.h:1034
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
Definition: hash.c:1133
void rb_compile_error_append(const char *fmt,...)
Definition: error.c:129
VALUE rb_parser_get_yydebug(VALUE self)
Definition: parse.c:16541
#define YYTRANSLATE(YYX)
Definition: parse.c:1087
#define NEW_PRELUDE(p, b)
Definition: parse.y:449
const struct vtable * vars
Definition: ripper.c:836
int rb_ispunct(int c)
Definition: encoding.c:1646
#define NEW_ARRAY(a)
Definition: parse.y:378
#define tokidx
Definition: parse.c:352
RUBY_EXTERN VALUE rb_cObject
Definition: ruby.h:1246
VALUE rb_eRuntimeError
Definition: error.c:466
#define match_op(node1, node2)
Definition: parse.c:462
#define NEW_STRTERM(func, term, paren)
Definition: parse.c:12184
#define ID_INSTANCE
Definition: parse.y:20
static const struct magic_comment magic_comments[]
Definition: parse.c:12675
#define rb_enc_isascii(c, enc)
Definition: encoding.h:171
#define CMDARG_PUSH(n)
Definition: parse.c:146
#define reg_named_capture_assign(regexp, match)
Definition: parse.c:476
#define st_init_table_with_size
Definition: regint.h:141
#define arg_concat(h, t)
Definition: parse.c:421
struct parser_params * parser
Definition: ripper.c:15723
static void magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
Definition: parse.c:12639
#define RE_OPTION_MASK
Definition: parse.c:535
void * rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
Definition: parse.c:16582
char * ruby_strdup(const char *)
Definition: util.c:425
#define NEW_HASH(a)
Definition: parse.y:380
VALUE rb_get_coverages(void)
Definition: thread.c:4886
static int e_option_supplied(struct parser_params *parser)
Definition: parse.c:11384
#define NEW_ZARRAY()
Definition: parse.y:379
static struct vtable * vtable_alloc(struct vtable *prev)
Definition: parse.c:185
Definition: ripper.c:771
#define NEW_FALSE()
Definition: parse.y:442
#define token_info_push(token)
Definition: parse.c:666
VALUE rb_obj_as_string(VALUE)
Definition: string.c:854
int parser_paren_nest
Definition: ripper.c:270
VALUE rb_ary_new(void)
Definition: array.c:339
#define YY_(msgid)
Definition: parse.c:910
#define NODE_HEREDOC
Definition: parse.c:539
int rb_ascii8bit_encindex(void)
Definition: encoding.c:1119
#define NEW_ARGSPUSH(a, b)
Definition: parse.y:424
#define VTBL_DEBUG
Definition: parse.c:182
#define cond_stack
Definition: parse.c:341
static int is_special_global_name(const char *m, const char *e, rb_encoding *enc)
Definition: parse.c:15919
static const yytype_uint16 yyrline[]
Definition: parse.c:1381
#define NEW_REDO()
Definition: parse.y:369
#define NEW_NTH_REF(n)
Definition: parse.y:402
#define NEW_UNLESS(c, t, e)
Definition: parse.y:358
RUBY_EXTERN VALUE rb_mKernel
Definition: ruby.h:1234
#define snprintf
Definition: subst.h:6
VALUE rb_thread_current(void)
Definition: thread.c:1742
#define IS_SPCARG(c)
Definition: parse.c:12880
#define set_yylval_id(x)
Definition: parse.c:11114
#define NIL_P(v)
Definition: ruby.h:374
#define ISASCII(c)
Definition: ruby.h:1450
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:469
static char msg[50]
Definition: strerror.c:8
#define NEW_GVAR(v)
Definition: parse.y:396
static int reg_fragment_check_gen(struct parser_params *, VALUE, int)
Definition: parse.c:15618
#define YYSTACK_ALLOC
Definition: parse.c:978
long(* rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len)
Definition: parse.c:12635
#define STR_FUNC_REGEXP
Definition: parse.c:11583
NODE * rb_compile_string(const char *f, VALUE s, int line)
Definition: parse.c:11520
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:1923
VALUE ruby_suppress_tracing(VALUE(*func)(VALUE, int), VALUE arg, int always)
Definition: thread.c:4603
Definition: ripper.c:770
#define ID_SCOPE_SHIFT
Definition: parse.y:17
#define k__END__
Definition: eventids2.c:9
#define ISALNUM(c)
Definition: ruby.h:1456
#define NEW_CASE(h, b)
Definition: parse.y:359
rb_atomic_t cnt[RUBY_NSIG]
Definition: signal.c:420
#define RFLOAT(obj)
Definition: ruby.h:908
static void no_blockarg(struct parser_params *parser, NODE *node)
Definition: parse.c:15268
static double one(void)
Definition: isinf.c:52
static NODE * splat_array(NODE *)
Definition: parse.c:14793
static void parser_mark(void *ptr)
Definition: parse.c:16397
#define T_FLOAT
Definition: ruby.h:417
static void parser_tokadd(struct parser_params *parser, int c)
Definition: parse.c:11722
#define is_local_id(id)
Definition: parse.c:106
static YYSIZE_T yystrlen(char *yystr) const
Definition: parse.c:4482
#define LVAR_USED
Definition: parse.c:14664
#define TYPE(x)
Definition: ruby.h:441
int argc
Definition: ruby.c:120
Definition: node.h:59
yytype_int16 yyss_alloc
Definition: ripper.c:1016
#define STR_FUNC_INDENT
Definition: parse.c:11586
enum node_type nodetype(NODE *node)
Definition: parse.c:14224
char ary[RSTRING_EMBED_LEN_MAX+1]
Definition: ruby.h:663
#define Qfalse
Definition: ruby.h:365
#define NEW_EVSTR(n)
Definition: parse.y:413
#define arg_append(h, t)
Definition: parse.c:419
static VALUE lex_get_str(struct parser_params *parser, VALUE s)
Definition: parse.c:11457
#define ALLOCA_N(type, n)
Definition: ruby.h:1038
static int assign_in_cond(struct parser_params *parser, NODE *node)
Definition: parse.c:15068
#define op_tbl_count
Definition: parse.c:15838
#define warn_balanced(op, syn)
Definition: parse.c:12891
#define tokadd(c)
Definition: parse.c:11098
#define no_digits()
#define peek_n(c, n)
Definition: parse.c:11619
#define T_BIGNUM
Definition: ruby.h:423
#define ENC_CODERANGE_UNKNOWN
Definition: encoding.h:57
#define YYFINAL
Definition: parse.c:1070
#define ISUPPER(c)
Definition: ruby.h:1454
static void void_expr_gen(struct parser_params *, NODE *)
Definition: parse.c:14894
static int reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end, int back_num, int *back_refs, OnigRegex regex, void *arg0)
Definition: parse.c:15641
#define RUBY_FUNC_EXPORTED
Definition: defines.h:254
#define MEMCPY(p1, p2, type, n)
Definition: ruby.h:1053
#define T_NODE
Definition: ruby.h:434
#define ENC_CODERANGE_BROKEN
Definition: encoding.h:60
#define rb_enc_isupper(c, enc)
Definition: encoding.h:174
VALUE rb_enc_associate_index(VALUE obj, int idx)
Definition: encoding.c:709
int rb_parse_in_main(void)
Definition: compile.c:5576
Definition: ripper.c:775
#define YYCASE_(N, S)
int err
Definition: win32.c:78
arg
Definition: ripper.y:1287
#define OBJ_FREEZE(x)
Definition: ruby.h:970
const char * parser_lex_pend
Definition: ripper.c:285
static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
Definition: parse.c:11914
#define nd_else
Definition: parse.y:287
#define set_yylval_num(x)
Definition: parse.c:11113
long cnt
Definition: node.h:256
#define parser_encoding_name()
Definition: parse.c:11202
token_info * parser_token_info
Definition: ripper.c:311
int column
Definition: ripper.c:243
#define YYSIZE_T
Definition: parse.c:896
VALUE rb_make_backtrace(void)
Definition: vm_eval.c:1657
#define ALLOC(type)
Definition: ruby.h:1035
#define NEW_FOR(v, i, b)
Definition: parse.y:364
#define EOF
Definition: vsnprintf.c:206
static NODE * list_append_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14323
Definition: id.h:117
#define NEW_WHEN(c, t, e)
Definition: parse.y:360
static const yytype_int16 yycheck[]
Definition: parse.c:3008
VALUE rb_str_resize(VALUE, long)
Definition: string.c:1779
static int literal_node(NODE *node)
Definition: parse.c:15168
Definition: ripper.c:768
static int dvar_curr_gen(struct parser_params *, ID)
Definition: parse.c:15571
#define tHEREDOC_END
Definition: eventids2.c:8
#define NEW_DASGN(v, val)
Definition: parse.y:384
YYSTYPE yyvs_alloc
Definition: ripper.c:1017
#define flush_string_content(enc)
Definition: parse.c:12203
int rb_str_hash_cmp(VALUE, VALUE)
Definition: string.c:2180
#define NEW_ERRINFO()
Definition: parse.y:443
#define NEW_BLOCK_PASS(b)
Definition: parse.y:428
string_type
Definition: ripper.c:11678
int rb_dvar_defined(ID id)
Definition: compile.c:5526
int parser_in_single
Definition: ripper.c:272
#define ret_args(node)
Definition: parse.c:441
static int parser_yyerror(struct parser_params *, const char *)
Definition: parse.c:11285
#define COND_LEXPOP()
Definition: parse.c:143
#define REALLOC_N(var, type, n)
Definition: ruby.h:1036
static const yytype_int16 yypgoto[]
Definition: parse.c:1897
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:104
int errno
#define TRUE
Definition: nkf.h:186
static int parser_tokadd_mbchar(struct parser_params *parser, int c)
Definition: parse.c:12039
#define nd_next
Definition: parse.y:283
void rb_gc_mark_symbols(void)
Definition: parse.c:15901
#define NEW_CONST(v)
Definition: parse.y:400
int rb_symname_p(const char *name)
Definition: parse.c:15945
#define COND_POP()
Definition: parse.c:142
#define TOK_INTERN(mb)
Definition: parse.c:334
#define NEW_LIT(l)
Definition: parse.y:407
VALUE rb_io_gets(VALUE)
Definition: io.c:2892
int rb_is_junk_id(ID id)
Definition: parse.c:16337
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1203
#define COND_P()
Definition: parse.c:144
#define ruby_coverage
Definition: parse.c:376
static VALUE debug_lines(const char *f)
Definition: parse.c:11350
#define NEW_OP_ASGN_OR(i, val)
Definition: parse.y:394
static void yydestruct(char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser) const
Definition: parse.c:4718
#define rb_enc_isspace(c, enc)
Definition: encoding.h:178
#define NEW_NEXT(s)
Definition: parse.y:368
#define rb_warnS(fmt, a)
Definition: parse.c:625
#define parser_warning(node, mesg)
Definition: parse.c:14259
int rb_obj_respond_to(VALUE, ID, int)
Definition: vm_method.c:1218
#define mixed_error(enc1, enc2)
#define RB_GC_GUARD(object)
Definition: generator.h:50
#define const
Definition: strftime.c:101
#define rb_enc_name(enc)
Definition: encoding.h:121
RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e-0x20+31)/32]
Definition: parse.c:12206
#define value_expr(node)
Definition: parse.c:402
#define rb_warning0(fmt)
Definition: parse.c:626
#define reg_fragment_setenc(str, options)
Definition: parse.c:472
static int value_expr_gen(struct parser_params *, NODE *)
Definition: parse.c:14832
static const yytype_int16 yyrhs[]
Definition: parse.c:1199
const char * rb_id2name(ID id)
Definition: parse.c:16272
static int parser_whole_match_p(struct parser_params *parser, const char *eos, long len, int indent)
Definition: parse.c:12409
#define NEW_RESCUE(b, res, e)
Definition: parse.y:372
#define YYDPRINTF(Args)
Definition: parse.c:4290
Definition: ripper.c:787
static const char * magic_comment_marker(const char *str, long len)
Definition: parse.c:12683
#define rb_warn0(fmt)
Definition: parse.c:623
rb_magic_comment_length_t length
Definition: ripper.c:12762
int parser_in_def
Definition: ripper.c:273
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1416
static const yytype_uint8 yytranslate[]
Definition: parse.c:1091
#define new_bv(id)
Definition: parse.c:499
#define YYEMPTY
Definition: parse.c:4195
#define YYSTACK_FREE
Definition: parse.c:979
#define YYID(n)
Definition: parse.c:923
VALUE parser_cur_mid
Definition: ripper.c:275
VALUE stack_type
Definition: parse.c:134
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:3913
short int yytype_int16
Definition: ripper.c:883
static char * parser_newtok(struct parser_params *parser)
Definition: parse.c:11695
long parser_lex_gets_ptr
Definition: ripper.c:289
unsigned long ID
Definition: ruby.h:89
NODE * node
Definition: ripper.c:833
static void fixup_nodes(NODE **)
Definition: parse.c:15121
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1140
#define rb_enc_isalnum(c, enc)
Definition: encoding.h:176
#define dyna_pop(node)
Definition: parse.c:517
#define rb_enc_isdigit(c, enc)
Definition: encoding.h:179
unsigned char yytype_uint8
Definition: ripper.c:862
#define nd_resq
Definition: parse.y:291
#define list_concat(h, t)
Definition: parse.c:417
#define dyna_in_block()
Definition: parse.c:519
#define Qnil
Definition: ruby.h:367
#define dyna_var(id)
Definition: parse.c:520
#define NEW_BACK_REF(n)
Definition: parse.y:403
#define STR_FUNC_ESCAPE
Definition: parse.c:11581
int type
Definition: tcltklib.c:107
int id[2]
Definition: lex.c:33
#define NODE_FL_NEWLINE
Definition: parse.y:265
static int options(unsigned char *cp)
Definition: nkf.c:5883
#define NEW_MASGN(l, r)
Definition: parse.y:381
#define heredoc_restore(n)
Definition: parse.c:11108
#define NEW_COLON2(c, i)
Definition: parse.y:435
unsigned long VALUE
Definition: ruby.h:88
#define yyerror(msg)
Definition: parse.c:337
#define peek(c)
Definition: parse.c:11618
stack_type parser_cond_stack
Definition: ripper.c:267
static VALUE result
Definition: nkf.c:40
static const struct @44 op_tbl[]
static NODE * arg_append_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14775
#define RBASIC(obj)
Definition: ruby.h:904
#define heredoc_identifier()
Definition: parse.c:11107
int parser_heredoc_end
Definition: ripper.c:286
#define rb_enc_ispunct(c, enc)
Definition: encoding.h:175
static void ripper_init_eventids1(VALUE self)
Definition: eventids1.c:129
static VALUE parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
Definition: parse.c:11600
#define ripper_flush(p)
Definition: parse.c:11135
void rb_mark_tbl(st_table *tbl)
Definition: gc.c:1735
#define regx_options()
Definition: parse.c:11102
static int parser_magic_comment(struct parser_params *parser, const char *str, long len)
Definition: parse.c:12716
#define NEW_ENSURE(b, en)
Definition: parse.y:374
#define token_info_pop(token)
Definition: parse.c:667
static int arg_var_gen(struct parser_params *, ID)
Definition: parse.c:15446
register unsigned int len
Definition: name2ctype.h:22210
#define call_bin_op(recv, id, arg1)
Definition: parse.c:432
#define RARRAY_PTR(ARRAY)
Definition: generator.h:36
static NODE * new_args_gen(struct parser_params *, NODE *, NODE *, ID, NODE *, ID)
Definition: parse.c:15339
#define NEW_ZSUPER()
Definition: parse.y:418
#define rb_enc_asciicompat(enc)
Definition: encoding.h:181
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
Definition: eval.c:737
VALUE flags
Definition: ruby.h:597
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Definition: re.c:285
#define NEW_COLON3(i)
Definition: parse.y:436
#define NEW_BLOCK(a)
Definition: parse.y:356
struct RString::@28::@29 heap
#define assignable_result(x)
#define NEW_LAMBDA(a)
Definition: parse.y:366
static int parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
Definition: parse.c:11921
static int parser_tokadd_string(struct parser_params *, int, int, int, long *, rb_encoding **)
Definition: parse.c:12055
#define nd_body
Definition: parse.y:286
VALUE flags
Definition: node.h:236
const char * token
Definition: ripper.c:241
#define ENCODING_IS_ASCII8BIT(obj)
Definition: encoding.h:52
VALUE rb_str_dup(VALUE)
Definition: string.c:905
#define dvar_defined_get(id)
Definition: parse.c:523
#define tLAST_TOKEN
Definition: parse.y:37
#define rb_enc_isalpha(c, enc)
Definition: encoding.h:172
#define ruby_sourceline
Definition: parse.c:367
#define is_global_id(id)
Definition: parse.c:107
#define lex_input
Definition: parse.c:354
long st_data_t
Definition: syck.h:69
void xfree(void *)
#define STR_FUNC_QWORDS
Definition: parse.c:11584
static int vtable_included(const struct vtable *tbl, ID id)
Definition: parse.c:224
ID rb_intern(const char *name)
Definition: parse.c:16188
int parser_in_defined
Definition: ripper.c:276
#define ruby_eval_tree
Definition: parse.c:373
int parser_class_nest
Definition: ripper.c:269
ID token
Definition: parse.c:15815
static VALUE lex_io_gets(struct parser_params *parser, VALUE io)
Definition: parse.c:11548
NODE * rb_compile_cstr(const char *f, const char *s, int len, int line)
Definition: parse.c:11534
#define parser_is_identchar()
Definition: parse.c:11206
#define NEW_BEGIN(b)
Definition: parse.y:371
#define ruby__end__seen
Definition: parse.c:366
#define dvar_curr(id)
Definition: parse.c:525
#define set_yylval_node(x)
Definition: parse.c:11117
static void yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: parse.c:4319
nd_iter
Definition: parse.y:1361
static void vtable_free(struct vtable *tbl)
Definition: parse.c:197
#define rb_compile_error
Definition: parse.c:649
#define NEW_SPLAT(a)
Definition: parse.y:425
#define SYMBOL_P(v)
Definition: cparse.c:69
#define reg_fragment_check(str, options)
Definition: parse.c:474
VALUE rb_usascii_str_new2(const char *)
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:1853
#define ENCODING_GET(obj)
Definition: encoding.h:47
#define lex_state
Definition: parse.c:340
#define arg_ambiguous()
Definition: parse.c:12550
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:733
static void reduce_nodes_gen(struct parser_params *, NODE **)
Definition: parse.c:15007
Definition: ripper.c:773
int nonspc
Definition: ripper.c:244
int size
Definition: encoding.c:51
#define YYSTACK_ALLOC_MAXIMUM
Definition: parse.c:981
#define NEW_DSTR(s)
Definition: parse.y:409
#define yynerrs
Definition: gram.c:56
#define newtok()
Definition: parse.c:11096
#define yylval
Definition: parse.c:11085
#define INT2FIX(i)
Definition: ruby.h:225
#define set_yylval_name(x)
Definition: parse.c:11115
#define NEW_GASGN(v, val)
Definition: parse.y:382
Definition: ripper.c:769
#define NEW_BREAK(s)
Definition: parse.y:367
yytokentype
Definition: ripper.c:701
static NODE * reg_named_capture_assign_gen(struct parser_params *parser, VALUE regexp, NODE *match)
Definition: parse.c:15681
static void parser_pushback(struct parser_params *parser, int c)
Definition: parse.c:11678
int rb_enc_symname_p(const char *name, rb_encoding *enc)
Definition: parse.c:15951
int parser_tokidx
Definition: ripper.c:278
static const yytype_uint16 yydefact[]
Definition: parse.c:1662
Definition: node.h:45
static VALUE ULONG2NUM(unsigned long v)
Definition: ruby.h:1015
#define lpar_beg
Definition: parse.c:345
static int parser_here_document(struct parser_params *, NODE *)
Definition: parse.c:12439
#define YYUSE(e)
Definition: parse.c:916
#define COND_PUSH(n)
Definition: parse.c:141
#define xmalloc
Definition: defines.h:64
static NODE * ret_args_gen(struct parser_params *, NODE *)
Definition: parse.c:15276
#define YYACCEPT
Definition: parse.c:4198
VALUE coverage
Definition: ripper.c:307
void rb_set_errinfo(VALUE err)
Definition: eval.c:1065
#define lex_gets_ptr
Definition: parse.c:363
#define NEW_TRUE()
Definition: parse.y:441
static void dyna_pop_gen(struct parser_params *, const struct vtable *)
Definition: parse.c:15520
NODE * parser_lex_strterm
Definition: ripper.c:265
const char * name
Definition: parse.c:15816
const char * name
Definition: ripper.c:12760
top_stmts dispatch0(stmts_new)
static void local_pop_gen(struct parser_params *)
Definition: parse.c:15400
#define tSP
Definition: eventids2.c:6
Definition: node.h:201
#define NEW_UNTIL(c, b, n)
Definition: parse.y:363
#define lvtbl
Definition: parse.c:365
#define aryset(node1, node2)
Definition: parse.c:452
#define NEW_MODULE(n, b)
Definition: parse.y:434
static const struct st_hash_type symhash
Definition: parse.c:15855
#define list_append(l, i)
Definition: parse.c:415
#define tokaddmbc(c, enc)
Definition: parse.c:11105
short int yytype_int16
Definition: parse.c:883
#define cur_mid
Definition: parse.c:349
#define STR_NEW3(p, n, e, func)
Definition: parse.c:332
#define IS_BEG()
Definition: parse.c:12879
rb_magic_comment_setter_t func
Definition: ripper.c:12761
static const yytype_int16 yypact[]
Definition: parse.c:1792
#define dvar_defined(id)
Definition: parse.c:522
int parser_lpar_beg
Definition: ripper.c:271
#define ESCAPE_CONTROL
Definition: parse.c:11819
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:169
st_table * sym_id
Definition: ripper.c:15936
static void warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: parse.c:15115
#define yypact_value_is_default(yystate)
Definition: parse.c:3002
uint8_t key[16]
Definition: random.c:1284
static int symbols_i(VALUE sym, ID value, VALUE ary)
Definition: parse.c:16281
#define nd_head
Definition: parse.y:281
struct local_vars * prev
Definition: ripper.c:162
#define IS_END()
Definition: parse.c:12878
static void parser_prepare(struct parser_params *parser)
Definition: parse.c:12853
#define LONG2FIX(i)
Definition: ruby.h:226
ID rb_id_attrset(ID id)
Definition: parse.c:14721
static struct parser_params * parser_new(void)
Definition: parse.c:16486
#define NEW_WHILE(c, b, n)
Definition: parse.y:362
struct vtable * vars
Definition: ripper.c:160
#define RTEST(v)
Definition: ruby.h:373
static void yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: parse.c:4353
Definition: node.h:137
#define T_STRING
Definition: ruby.h:418
static void rb_backref_error_gen(struct parser_params *, NODE *)
Definition: parse.c:14737
VALUE rb_id2str(ID id)
Definition: parse.c:16211
#define NEW_POSTARG(i, v)
Definition: parse.y:422
#define YYINITDEPTH
Definition: parse.c:4454
Definition: ripper.c:754
#define RREGEXP(obj)
Definition: ruby.h:910
static NODE * logop_gen(struct parser_params *, enum node_type, NODE *, NODE *)
Definition: parse.c:15253
VALUE rb_parser_new(void)
Definition: parse.c:16497
static void void_stmts_gen(struct parser_params *, NODE *)
Definition: parse.c:14983
#define ENC_SINGLE(cr)
Definition: parse.c:333
#define NEW_UNDEF(i)
Definition: parse.y:431
struct rb_encoding_entry * list
Definition: encoding.c:49
Definition: ripper.c:782
static const yytype_int16 yydefgoto[]
Definition: parse.c:1767
rb_encoding * rb_filesystem_encoding(void)
Definition: encoding.c:1205
#define st_add_direct
Definition: regint.h:151
v
Definition: win32ole.c:790
#define parse_string(n)
Definition: parse.c:11104
#define ID_ATTRSET
Definition: parse.y:22
#define NEWHEAP()
Definition: parse.c:16567
#define NEW_CVASGN(v, val)
Definition: parse.y:389
static int yylex(void *, void *)
Definition: parse.c:14189
#define NEW_FCALL(m, a)
Definition: parse.y:415
int linenum
Definition: ripper.c:242
union RNode::@42 u2
#define YYEOF
Definition: parse.c:4196
#define tEMBDOC
Definition: eventids2.c:4
#define NEW_MATCH3(r, n2)
Definition: parse.y:406
#define NEW_OP_ASGN2(r, i, o, val)
Definition: parse.y:392
#define deferred_nodes
Definition: parse.c:362
Definition: ripper.c:809
char * parser_tokenbuf
Definition: ripper.c:277
#define node_assign(node1, node2)
Definition: parse.c:459
#define get_id(id)
Definition: parse.c:478
VALUE rb_cArray
Definition: array.c:27
#define NEW_OPT_ARG(i, v)
Definition: parse.y:421
Definition: id.h:97
short int yytype_int8
Definition: parse.c:871
static unsigned int hash(const char *str, unsigned int len)
Definition: lex.c:56
#define YYTERROR
Definition: parse.c:4237
static int parser_parse_string(struct parser_params *, NODE *)
Definition: parse.c:12271
#define tok()
Definition: parse.c:11690
#define cond(node)
Definition: parse.c:392
VALUE rb_ary_new2(long capa)
Definition: array.c:332
#define ruby_eval_tree_begin
Definition: parse.c:374
#define is_instance_id(id)
Definition: parse.c:108
NODE * rb_parser_append_print(VALUE vparser, NODE *node)
Definition: parse.c:15742
ID rb_intern2(const char *name, long len)
Definition: parse.c:16181
const char * parser_lex_pbeg
Definition: ripper.c:283
static NODE * cond_gen(struct parser_params *, NODE *)
Definition: parse.c:15246
NODE * rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
Definition: parse.c:11541
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
Definition: string.c:424
#define rb_safe_level()
Definition: tcltklib.c:90
static NODE * list_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14343
Definition: ripper.c:151
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:1641
#define yychar
Definition: gram.c:54
#define NEW_YIELD(a, s)
Definition: parse.y:376
#define lex_p
Definition: parse.c:358
static int comment_at_top(struct parser_params *parser)
Definition: parse.c:12623
const char * parser_lex_p
Definition: ripper.c:284
static void dispose_string(VALUE str)
Definition: parse.c:12030
#define xrealloc
Definition: defines.h:67
Definition: ripper.c:774
static int parser_nextc(struct parser_params *parser)
Definition: parse.c:11622
lex_state_e
Definition: ripper.c:119
#define read_escape(flags, e)
Definition: parse.c:11100
#define parser_isascii()
Definition: parse.c:11208
Definition: ripper.c:781
static const char *const yytname[]
Definition: parse.c:1447
Definition: node.h:61
static char * yystpcpy(char *yydest, const char *yysrc)
Definition: parse.c:4506
int parser_ruby_sourceline
Definition: ripper.c:296
#define NEW_RETRY()
Definition: parse.y:370
#define call_uni_op(recv, id)
Definition: parse.c:434
#define rb_errinfo()
Definition: tcltklib.c:85
#define STR_FUNC_SYMBOL
Definition: parse.c:11585
#define nd_value
Definition: parse.y:311
#define DVARS_INHERIT
Definition: parse.c:166
#define ID_INTERNAL
Definition: parse.y:26
static ID shadowing_lvar_gen(struct parser_params *, ID)
Definition: parse.c:14667
YYSTYPE * parser_yylval
Definition: ripper.c:262
static int token_info_get_column(struct parser_params *parser, const char *token)
Definition: parse.c:11212
unsigned char yytype_uint8
Definition: parse.c:862
#define NEW_RESBODY(a, ex, n)
Definition: parse.y:373
#define NEW_ARGSCAT(a, b)
Definition: parse.y:423
#define arg_var(id)
Definition: parse.c:508
#define NEW_DASGN_CURR(v, val)
Definition: parse.y:385
#define is_junk_id(id)
Definition: parse.c:112
static NODE * yycompile(struct parser_params *parser, const char *f, int line)
Definition: parse.c:11438
static void vtable_add(struct vtable *tbl, ID id)
Definition: parse.c:209
int rb_is_class_id(ID id)
Definition: parse.c:16319
#define NEW_SUPER(a)
Definition: parse.y:417
#define NEW_CALL(r, m, a)
Definition: parse.y:414
static const yytype_uint16 yystos[]
Definition: parse.c:4089
int is_ripper
Definition: ripper.c:259
#define in_defined
Definition: parse.c:350
rb_encoding * rb_ascii8bit_encoding(void)
Definition: encoding.c:1110
int rb_enc_find_index(const char *name)
Definition: encoding.c:596
VALUE eofp
Definition: ripper.c:263
static NODE * aryset_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14705
VALUE rb_parser_end_seen_p(VALUE vparser)
Definition: parse.c:16511
static int parser_heredoc_identifier(struct parser_params *parser)
Definition: parse.c:12329
Definition: node.h:31
int rb_is_const_id(ID id)
Definition: parse.c:16313
static int parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp, int string_literal, int symbol_literal, int regexp_literal)
Definition: parse.c:11748
static const struct vtable * dyna_push_gen(struct parser_params *)
Definition: parse.c:15491
#define CONST_ID(var, str)
Definition: ruby.h:1127
NODE * heap
Definition: ripper.c:260
static NODE * block_append_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14269
#define NEW_CVAR(v)
Definition: parse.y:401
#define ESCAPE_META
Definition: parse.c:11820
#define local_push(top)
Definition: parse.c:502
#define new_args(f, o, r, p, b)
Definition: parse.c:437
state
Definition: gb18030.c:213
#define NEW_MATCH2(n1, n2)
Definition: parse.y:405
#define long
Definition: name2ctype.h:37
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: parse.c:16556
static void new_bv_gen(struct parser_params *, ID)
Definition: parse.c:14691
#define assignable(id, node)
Definition: parse.c:449
union RNode::@41 u1
VALUE rb_cstr_to_inum(const char *str, int base, int badcheck)
Definition: bignum.c:567
static NODE * range_op(struct parser_params *parser, NODE *node)
Definition: parse.c:15152
#define ruby_debug_lines
Definition: parse.c:375
union RString::@28 as
#define rb_enc_mbcput(c, buf, enc)
Definition: encoding.h:158
#define IS_ARG()
Definition: parse.c:12877
#define NEW_DVAR(v)
Definition: parse.y:398
#define NEW_DEFN(i, a, d, p)
Definition: parse.y:352
static int parser_tok_hex(struct parser_params *parser, size_t *numlen)
Definition: parse.c:11732
#define new_evstr(n)
Definition: parse.c:426
int rb_parse_in_eval(void)
Definition: compile.c:5570
NODE * rb_compile_file(const char *f, VALUE file, int start)
Definition: parse.c:11554
VALUE rb_str_buf_new(long)
Definition: string.c:736
VALUE rb_usascii_str_new(const char *, long)
Definition: string.c:416
#define lex_eol_p()
Definition: parse.c:11617
#define rb_node_newnode(type, a1, a2, a3)
Definition: parse.c:389
#define tCOMMENT
Definition: eventids2.c:2
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1197
#define void_stmts(node)
Definition: parse.c:406
#define block_append(h, t)
Definition: parse.c:413
VALUE(* parser_lex_gets)(struct parser_params *, VALUE)
Definition: ripper.c:290
#define NULL
Definition: _sdbm.c:107
#define compile_for_eval
Definition: parse.c:348
#define RTYPEDDATA_TYPE(v)
Definition: ruby.h:798
#define NEW_LASGN(v, val)
Definition: parse.y:383
struct token_info token_info
#define FIX2LONG(x)
Definition: ruby.h:336
#define Qundef
Definition: ruby.h:368
static NODE * literal_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14384
#define tIGNORED_NL
Definition: eventids2.c:1
#define yyerrok
Definition: parse.c:4193
#define NEW_STR(s)
Definition: parse.y:408
static NODE * call_uni_op_gen(struct parser_params *, NODE *, ID)
Definition: parse.c:14476
#define YYMAXDEPTH
Definition: parse.c:4465
static int literal_concat0(struct parser_params *, VALUE, VALUE)
Definition: parse.c:14367
int rb_is_instance_id(ID id)
Definition: parse.c:16325
void rb_parser_free(struct parser_params *parser, void *ptr)
Definition: parse.c:16612
#define ID_GLOBAL
Definition: parse.y:21
#define in_def
Definition: parse.c:347
#define ISXDIGIT(c)
Definition: ruby.h:1459
#define ENCODING_SET(obj, i)
Definition: encoding.h:37
int rb_local_defined(ID id)
Definition: compile.c:5551
st_index_t num_entries
Definition: st.h:93
#define IS_LABEL_SUFFIX(n)
Definition: parse.c:12882
#define NEW_SELF()
Definition: parse.y:439
NODE * parser_eval_tree_begin
Definition: ripper.c:304
static int match(VALUE str, VALUE pat, VALUE hash, int(*cb)(VALUE, VALUE))
Definition: date_parse.c:245
static NODE * parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: parse.c:11500
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1210
#define ruby_verbose
Definition: ruby.h:1169
VALUE rb_str_append(VALUE, VALUE)
Definition: string.c:2047
static void parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
Definition: parse.c:12648
#define NEW_NODE(t, a0, a1, a2)
Definition: parse.y:350
#define NEW_ARGS_AUX(r, b)
Definition: parse.y:420
#define RSTRING_NOEMBED
Definition: ruby.h:666
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:80
#define NEW_ALIAS(n, o)
Definition: parse.y:429
Definition: ripper.c:776
#define ifndef_ripper(x)
Definition: parse.c:617
void(* rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val)
Definition: parse.c:12636
#define YYLEX
Definition: parse.c:4279
static VALUE lex_getline(struct parser_params *parser)
Definition: parse.c:11477
VALUE rb_sym_all_symbols(void)
Definition: parse.c:16304
VALUE rb_eArgError
Definition: error.c:468
#define nd_lit
Definition: parse.y:314
#define rb_enc_prev_char(s, p, e, enc)
Definition: encoding.h:161
#define T_REGEXP
Definition: ruby.h:419
#define tokadd_escape(e)
Definition: parse.c:11101
static NODE * node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE)
Definition: parse.c:14216
Definition: node.h:135
#define dyna_push()
Definition: parse.c:515
#define whole_match_p(e, l, i)
Definition: parse.c:11109
#define was_bol()
Definition: parse.c:11687
unsigned long ruby_scan_oct(const char *, size_t, size_t *)
Definition: util.c:28
static int yysyntax_error(YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
Definition: parse.c:4579
#define HEAPCNT(n, size)
Definition: parse.c:16566
#define STR_FUNC_EXPAND
Definition: parse.c:11582
static int parser_peek_variable_name(struct parser_params *parser)
Definition: parse.c:12235
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1032
#define is_attrset_id(id)
Definition: parse.c:109
#define UTF8_ENC()
Definition: parse.c:327
struct vtable * args
Definition: ripper.c:159
static int local_id_gen(struct parser_params *, ID)
Definition: parse.c:15463
#define SPECIAL_PUNCT(idx)
Definition: parse.c:12211
#define NEW_CDECL(v, val, path)
Definition: parse.y:388
#define rb_backref_error(n)
Definition: parse.c:457
#define NEW_DEFS(r, i, a, d)
Definition: parse.y:353
char ** argv
Definition: ruby.c:121
#define tEMBDOC_END
Definition: eventids2.c:5
char * ptr
Definition: ruby.h:657
#define DBL2NUM(dbl)
Definition: ruby.h:647
#define ISSPACE(c)
Definition: ruby.h:1453
#define StringValue(v)
Definition: ruby.h:466
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:2000
#define STR_NEW(p, n)
Definition: parse.c:329
#define rb_warningS(fmt, a)
Definition: parse.c:627
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: parse.c:1036
#define nd_vid
Definition: parse.y:300
#define reduce_nodes(n)
Definition: parse.c:408
#define void_expr0(node)
Definition: parse.c:403
rb_encoding * rb_enc_from_index(int index)
Definition: encoding.c:512
#define tokcopy(n)
Definition: parse.c:11745
#define InitVM(ext)
Definition: console.c:89
void Init_sym(void)
Definition: parse.c:15888
VALUE rb_str_new(const char *, long)
Definition: string.c:410
#define xcalloc
Definition: defines.h:66
#define ID_CLASS
Definition: parse.y:24