Ruby  2.0.0p648(2015-12-16revision53162)
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 #ifndef PARSER_DEBUG
73 #define PARSER_DEBUG 0
74 #endif
75 #define YYDEBUG 1
76 #define YYERROR_VERBOSE 1
77 #define YYSTACK_USE_ALLOCA 0
78 
79 #include "ruby/ruby.h"
80 #include "ruby/st.h"
81 #include "ruby/encoding.h"
82 #include "internal.h"
83 #include "node.h"
84 #include "parse.h"
85 #include "id.h"
86 #include "regenc.h"
87 #include <stdio.h>
88 #include <errno.h>
89 #include <ctype.h>
90 #include "probes.h"
91 
92 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
93 
94 #define YYMALLOC(size) rb_parser_malloc(parser, (size))
95 #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
96 #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
97 #define YYFREE(ptr) rb_parser_free(parser, (ptr))
98 #define malloc YYMALLOC
99 #define realloc YYREALLOC
100 #define calloc YYCALLOC
101 #define free YYFREE
102 
103 #ifndef RIPPER
104 static ID register_symid(ID, const char *, long, rb_encoding *);
105 static ID register_symid_str(ID, VALUE);
106 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
107 #include "id.c"
108 #endif
109 
110 #define is_notop_id(id) ((id)>tLAST_OP_ID)
111 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
112 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
113 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
114 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
115 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
116 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
117 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
118 #define id_type(id) (is_notop_id(id) ? (int)((id)&ID_SCOPE_MASK) : -1)
119 
120 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
121  (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
122  ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
123  ((id)&ID_SCOPE_MASK) == ID_CLASS))
124 
126  EXPR_BEG_bit, /* ignore newline, +/- is a sign. */
127  EXPR_END_bit, /* newline significant, +/- is an operator. */
128  EXPR_ENDARG_bit, /* ditto, and unbound braces. */
129  EXPR_ENDFN_bit, /* ditto, and unbound braces. */
130  EXPR_ARG_bit, /* newline significant, +/- is an operator. */
131  EXPR_CMDARG_bit, /* newline significant, +/- is an operator. */
132  EXPR_MID_bit, /* newline significant, +/- is an operator. */
133  EXPR_FNAME_bit, /* ignore newline, no reserved words. */
134  EXPR_DOT_bit, /* right after `.' or `::', no reserved words. */
135  EXPR_CLASS_bit, /* immediate after `class', no here document. */
136  EXPR_VALUE_bit, /* alike EXPR_BEG but label is disallowed. */
138 };
139 /* examine combinations */
141 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
143  DEF_EXPR(END),
144  DEF_EXPR(ENDARG),
145  DEF_EXPR(ENDFN),
146  DEF_EXPR(ARG),
147  DEF_EXPR(CMDARG),
148  DEF_EXPR(MID),
149  DEF_EXPR(FNAME),
150  DEF_EXPR(DOT),
151  DEF_EXPR(CLASS),
152  DEF_EXPR(VALUE),
153  EXPR_BEG_ANY = (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS),
154  EXPR_ARG_ANY = (EXPR_ARG | EXPR_CMDARG),
155  EXPR_END_ANY = (EXPR_END | EXPR_ENDARG | EXPR_ENDFN)
156 };
157 #define IS_lex_state_for(x, ls) ((x) & (ls))
158 #define IS_lex_state(ls) IS_lex_state_for(lex_state, (ls))
159 
160 #if PARSER_DEBUG
161 static const char *lex_state_name(enum lex_state_e state);
162 #endif
163 
165 
166 # define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
167 # define BITSTACK_POP(stack) ((stack) = (stack) >> 1)
168 # define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
169 # define BITSTACK_SET_P(stack) ((stack)&1)
170 
171 #define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n))
172 #define COND_POP() BITSTACK_POP(cond_stack)
173 #define COND_LEXPOP() BITSTACK_LEXPOP(cond_stack)
174 #define COND_P() BITSTACK_SET_P(cond_stack)
175 
176 #define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n))
177 #define CMDARG_POP() BITSTACK_POP(cmdarg_stack)
178 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
179 #define CMDARG_P() BITSTACK_SET_P(cmdarg_stack)
180 
181 struct vtable {
182  ID *tbl;
183  int pos;
184  int capa;
185  struct vtable *prev;
186 };
187 
188 struct local_vars {
189  struct vtable *args;
190  struct vtable *vars;
191  struct vtable *used;
192  struct local_vars *prev;
193  stack_type cmdargs;
194 };
195 
196 #define DVARS_INHERIT ((void*)1)
197 #define DVARS_TOPSCOPE NULL
198 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
199 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
200 
201 static int
202 vtable_size(const struct vtable *tbl)
203 {
204  if (POINTER_P(tbl)) {
205  return tbl->pos;
206  }
207  else {
208  return 0;
209  }
210 }
211 
212 #define VTBL_DEBUG 0
213 
214 static struct vtable *
216 {
217  struct vtable *tbl = ALLOC(struct vtable);
218  tbl->pos = 0;
219  tbl->capa = 8;
220  tbl->tbl = ALLOC_N(ID, tbl->capa);
221  tbl->prev = prev;
222  if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
223  return tbl;
224 }
225 
226 static void
228 {
229  if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
230  if (POINTER_P(tbl)) {
231  if (tbl->tbl) {
232  xfree(tbl->tbl);
233  }
234  xfree(tbl);
235  }
236 }
237 
238 static void
239 vtable_add(struct vtable *tbl, ID id)
240 {
241  if (!POINTER_P(tbl)) {
242  rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
243  }
244  if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
245 
246  if (tbl->pos == tbl->capa) {
247  tbl->capa = tbl->capa * 2;
248  REALLOC_N(tbl->tbl, ID, tbl->capa);
249  }
250  tbl->tbl[tbl->pos++] = id;
251 }
252 
253 static int
254 vtable_included(const struct vtable * tbl, ID id)
255 {
256  int i;
257 
258  if (POINTER_P(tbl)) {
259  for (i = 0; i < tbl->pos; i++) {
260  if (tbl->tbl[i] == id) {
261  return i+1;
262  }
263  }
264  }
265  return 0;
266 }
267 
268 
269 #ifndef RIPPER
270 typedef struct token_info {
271  const char *token;
272  int linenum;
273  int column;
274  int nonspc;
275  struct token_info *next;
276 } token_info;
277 #endif
278 
279 /*
280  Structure of Lexer Buffer:
281 
282  lex_pbeg tokp lex_p lex_pend
283  | | | |
284  |-----------+--------------+------------|
285  |<------------>|
286  token
287 */
288 struct parser_params {
289  int is_ripper;
290  NODE *heap;
291 
293  VALUE eofp;
294 
297  stack_type parser_cond_stack;
298  stack_type parser_cmdarg_stack;
299  int parser_class_nest;
300  int parser_paren_nest;
301  int parser_lpar_beg;
302  int parser_in_single;
303  int parser_in_def;
304  int parser_brace_nest;
307  int parser_in_defined;
308  char *parser_tokenbuf;
309  int parser_tokidx;
310  int parser_toksiz;
311  int parser_tokline;
315  const char *parser_lex_pbeg;
316  const char *parser_lex_p;
317  const char *parser_lex_pend;
318  int parser_heredoc_end;
321  long parser_lex_gets_ptr;
323  struct local_vars *parser_lvtbl;
325  int line_count;
326  int has_shebang;
327  char *parser_ruby_sourcefile; /* current source file */
328  int parser_ruby_sourceline; /* current line no. */
330  rb_encoding *enc;
331 
332  int parser_yydebug;
333 
334 #ifndef RIPPER
335  /* Ruby core only */
339  VALUE coverage;
340  int nerr;
341 
344 #else
345  /* Ripper only */
346  const char *tokp;
347  VALUE delayed;
348  int delayed_line;
349  int delayed_col;
350 
351  VALUE value;
352  VALUE result;
353  VALUE parsing_thread;
354  int toplevel_p;
355 #endif
356 };
357 
358 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)
359 #define STR_NEW0() rb_enc_str_new(0,0,current_enc)
360 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)
361 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)
362 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
363 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc)
364 
365 static int parser_yyerror(struct parser_params*, const char*);
366 #define yyerror(msg) parser_yyerror(parser, (msg))
367 
368 #define lex_strterm (parser->parser_lex_strterm)
369 #define lex_state (parser->parser_lex_state)
370 #define cond_stack (parser->parser_cond_stack)
371 #define cmdarg_stack (parser->parser_cmdarg_stack)
372 #define class_nest (parser->parser_class_nest)
373 #define paren_nest (parser->parser_paren_nest)
374 #define lpar_beg (parser->parser_lpar_beg)
375 #define brace_nest (parser->parser_brace_nest)
376 #define in_single (parser->parser_in_single)
377 #define in_def (parser->parser_in_def)
378 #define compile_for_eval (parser->parser_compile_for_eval)
379 #define cur_mid (parser->parser_cur_mid)
380 #define in_defined (parser->parser_in_defined)
381 #define tokenbuf (parser->parser_tokenbuf)
382 #define tokidx (parser->parser_tokidx)
383 #define toksiz (parser->parser_toksiz)
384 #define tokline (parser->parser_tokline)
385 #define lex_input (parser->parser_lex_input)
386 #define lex_lastline (parser->parser_lex_lastline)
387 #define lex_nextline (parser->parser_lex_nextline)
388 #define lex_pbeg (parser->parser_lex_pbeg)
389 #define lex_p (parser->parser_lex_p)
390 #define lex_pend (parser->parser_lex_pend)
391 #define heredoc_end (parser->parser_heredoc_end)
392 #define command_start (parser->parser_command_start)
393 #define deferred_nodes (parser->parser_deferred_nodes)
394 #define lex_gets_ptr (parser->parser_lex_gets_ptr)
395 #define lex_gets (parser->parser_lex_gets)
396 #define lvtbl (parser->parser_lvtbl)
397 #define ruby__end__seen (parser->parser_ruby__end__seen)
398 #define ruby_sourceline (parser->parser_ruby_sourceline)
399 #define ruby_sourcefile (parser->parser_ruby_sourcefile)
400 #define ruby_sourcefile_string (parser->parser_ruby_sourcefile_string)
401 #define current_enc (parser->enc)
402 #define yydebug (parser->parser_yydebug)
403 #ifdef RIPPER
404 #else
405 #define ruby_eval_tree (parser->parser_eval_tree)
406 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin)
407 #define ruby_debug_lines (parser->debug_lines)
408 #define ruby_coverage (parser->coverage)
409 #endif
410 
411 #if YYPURE
412 static int yylex(void*, void*);
413 #else
414 static int yylex(void*);
415 #endif
416 
417 #ifndef RIPPER
418 #define yyparse ruby_yyparse
419 
420 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
421 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
422 
423 static NODE *cond_gen(struct parser_params*,NODE*);
424 #define cond(node) cond_gen(parser, (node))
425 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
426 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
427 
428 static NODE *newline_node(NODE*);
429 static void fixpos(NODE*,NODE*);
430 
431 static int value_expr_gen(struct parser_params*,NODE*);
432 static void void_expr_gen(struct parser_params*,NODE*);
433 static NODE *remove_begin(NODE*);
434 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
435 #define void_expr0(node) void_expr_gen(parser, (node))
436 #define void_expr(node) void_expr0((node) = remove_begin(node))
437 static void void_stmts_gen(struct parser_params*,NODE*);
438 #define void_stmts(node) void_stmts_gen(parser, (node))
439 static void reduce_nodes_gen(struct parser_params*,NODE**);
440 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
441 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
442 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
443 
444 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
445 #define block_append(h,t) block_append_gen(parser,(h),(t))
446 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
447 #define list_append(l,i) list_append_gen(parser,(l),(i))
448 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
449 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
450 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
451 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
452 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
453 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
454 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
455 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
456 static int literal_concat0(struct parser_params *, VALUE, VALUE);
457 static NODE *new_evstr_gen(struct parser_params*,NODE*);
458 #define new_evstr(n) new_evstr_gen(parser,(n))
459 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
460 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
461 static NODE *splat_array(NODE*);
462 
463 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
464 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
465 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
466 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
467 
468 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
469 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
470 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);
471 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
472 
473 static NODE *negate_lit(NODE*);
474 static NODE *ret_args_gen(struct parser_params*,NODE*);
475 #define ret_args(node) ret_args_gen(parser, (node))
476 static NODE *arg_blk_pass(NODE*,NODE*);
477 static NODE *new_yield_gen(struct parser_params*,NODE*);
478 #define new_yield(node) new_yield_gen(parser, (node))
479 static NODE *dsym_node_gen(struct parser_params*,NODE*);
480 #define dsym_node(node) dsym_node_gen(parser, (node))
481 
482 static NODE *gettable_gen(struct parser_params*,ID);
483 #define gettable(id) gettable_gen(parser,(id))
484 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
485 #define assignable(id,node) assignable_gen(parser, (id), (node))
486 
487 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
488 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
489 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
490 #define attrset(node,id) attrset_gen(parser, (node), (id))
491 
492 static void rb_backref_error_gen(struct parser_params*,NODE*);
493 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
494 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
495 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
496 
497 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
498 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
499 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
500 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
501 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
502 
503 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
504 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
505 
506 static ID *local_tbl_gen(struct parser_params*);
507 #define local_tbl() local_tbl_gen(parser)
508 
509 static void fixup_nodes(NODE **);
510 
511 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
512 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
513 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
514 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
515 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
516 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
517 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
518 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
519 
520 #define get_id(id) (id)
521 #define get_value(val) (val)
522 #else
523 #define value_expr(node) ((void)(node))
524 #define remove_begin(node) (node)
525 #define rb_dvar_defined(id) 0
526 #define rb_local_defined(id) 0
527 static ID ripper_get_id(VALUE);
528 #define get_id(id) ripper_get_id(id)
529 static VALUE ripper_get_value(VALUE);
530 #define get_value(val) ripper_get_value(val)
531 static VALUE assignable_gen(struct parser_params*,VALUE);
532 #define assignable(lhs,node) assignable_gen(parser, (lhs))
533 static int id_is_var_gen(struct parser_params *parser, ID id);
534 #define id_is_var(id) id_is_var_gen(parser, (id))
535 
536 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2))
537 
538 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
539 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);
540 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
541 
542 #endif /* !RIPPER */
543 
544 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
545 
546 static ID formal_argument_gen(struct parser_params*, ID);
547 #define formal_argument(id) formal_argument_gen(parser, (id))
548 static ID shadowing_lvar_gen(struct parser_params*,ID);
549 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
550 static void new_bv_gen(struct parser_params*,ID);
551 #define new_bv(id) new_bv_gen(parser, (id))
552 
553 static void local_push_gen(struct parser_params*,int);
554 #define local_push(top) local_push_gen(parser,(top))
555 static void local_pop_gen(struct parser_params*);
556 #define local_pop() local_pop_gen(parser)
557 static int local_var_gen(struct parser_params*, ID);
558 #define local_var(id) local_var_gen(parser, (id))
559 static int arg_var_gen(struct parser_params*, ID);
560 #define arg_var(id) arg_var_gen(parser, (id))
561 static int local_id_gen(struct parser_params*, ID);
562 #define local_id(id) local_id_gen(parser, (id))
563 static ID internal_id_gen(struct parser_params*);
564 #define internal_id() internal_id_gen(parser)
565 
566 static const struct vtable *dyna_push_gen(struct parser_params *);
567 #define dyna_push() dyna_push_gen(parser)
568 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
569 #define dyna_pop(node) dyna_pop_gen(parser, (node))
570 static int dyna_in_block_gen(struct parser_params*);
571 #define dyna_in_block() dyna_in_block_gen(parser)
572 #define dyna_var(id) local_var(id)
573 static int dvar_defined_gen(struct parser_params*,ID,int);
574 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
575 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
576 static int dvar_curr_gen(struct parser_params*,ID);
577 #define dvar_curr(id) dvar_curr_gen(parser, (id))
578 
579 static int lvar_defined_gen(struct parser_params*, ID);
580 #define lvar_defined(id) lvar_defined_gen(parser, (id))
581 
582 #define RE_OPTION_ONCE (1<<16)
583 #define RE_OPTION_ENCODING_SHIFT 8
584 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
585 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
586 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
587 #define RE_OPTION_MASK 0xff
588 #define RE_OPTION_ARG_ENCODING_NONE 32
589 
590 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
591 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
592 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
593 #define nd_func u1.id
594 #if SIZEOF_SHORT == 2
595 #define nd_term(node) ((signed short)(node)->u2.id)
596 #else
597 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
598 #endif
599 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
600 #define nd_nest u3.cnt
601 
602 /****** Ripper *******/
603 
604 #ifdef RIPPER
605 #define RIPPER_VERSION "0.1.0"
606 
607 #include "eventids1.c"
608 #include "eventids2.c"
609 
610 static VALUE ripper_dispatch0(struct parser_params*,ID);
611 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
612 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
613 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
614 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
615 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
616 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
617 
618 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
619 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
620 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
621 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
622 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
623 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
624 #define dispatch7(n,a,b,c,d,e,f,g) ripper_dispatch7(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e), (f), (g))
625 
626 #define yyparse ripper_yyparse
627 
628 #define ripper_intern(s) ID2SYM(rb_intern(s))
629 static VALUE ripper_id2sym(ID);
630 #ifdef __GNUC__
631 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
632  ID2SYM(id) : ripper_id2sym(id))
633 #endif
634 
635 #define arg_new() dispatch0(args_new)
636 #define arg_add(l,a) dispatch2(args_add, (l), (a))
637 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
638 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
639 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
640 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
641 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
642 
643 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
644 #define mrhs_new() dispatch0(mrhs_new)
645 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
646 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
647 
648 #define mlhs_new() dispatch0(mlhs_new)
649 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
650 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
651 
652 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
653  dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
654 
655 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
656 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
657 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
658 
659 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
660 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
661 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
662 
663 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
664 
665 static inline VALUE
666 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
667 {
668  NODE *t = (NODE *)tail;
669  VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
670  return params_new(f, o, r, p, k, kr, escape_Qundef(b));
671 }
672 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
673 
674 static inline VALUE
675 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
676 {
677  return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);
678 }
679 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
680 
681 #define FIXME 0
682 
683 #endif /* RIPPER */
684 
685 #ifndef RIPPER
686 # define Qnone 0
687 # define ifndef_ripper(x) (x)
688 #else
689 # define Qnone Qnil
690 # define ifndef_ripper(x)
691 #endif
692 
693 #ifndef RIPPER
694 # define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
695 # define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
696 # define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
697 # define rb_warn4S(file,line,fmt,a) rb_compile_warn((file), (line), (fmt), (a))
698 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
699 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
700 #else
701 # define rb_warn0(fmt) ripper_warn0(parser, (fmt))
702 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))
703 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))
704 # define rb_warn4S(file,line,fmt,a) ripper_warnS(parser, (fmt), (a))
705 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
706 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
707 static void ripper_warn0(struct parser_params*, const char*);
708 static void ripper_warnI(struct parser_params*, const char*, int);
709 static void ripper_warnS(struct parser_params*, const char*, const char*);
710 static void ripper_warning0(struct parser_params*, const char*);
711 static void ripper_warningS(struct parser_params*, const char*, const char*);
712 #endif
713 
714 #ifdef RIPPER
715 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
716 # define rb_compile_error ripper_compile_error
717 # define compile_error ripper_compile_error
718 # define PARSER_ARG parser,
719 #else
720 # define rb_compile_error rb_compile_error_with_enc
721 # define compile_error parser->nerr++,rb_compile_error_with_enc
722 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
723 #endif
724 
725 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
726  for instance). This is too low for Ruby to parse some files, such as
727  date/format.rb, therefore bump the value up to at least Bison's default. */
728 #ifdef OLD_YACC
729 #ifndef YYMAXDEPTH
730 #define YYMAXDEPTH 10000
731 #endif
732 #endif
733 
734 #ifndef RIPPER
735 static void token_info_push(struct parser_params*, const char *token);
736 static void token_info_pop(struct parser_params*, const char *token);
737 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
738 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
739 #else
740 #define token_info_push(token) /* nothing */
741 #define token_info_pop(token) /* nothing */
742 #endif
743 
744 
745 /* Line 268 of yacc.c */
746 #line 747 "parse.c"
747 
748 /* Enabling traces. */
749 #ifndef YYDEBUG
750 # define YYDEBUG 0
751 #endif
752 
753 /* Enabling verbose error messages. */
754 #ifdef YYERROR_VERBOSE
755 # undef YYERROR_VERBOSE
756 # define YYERROR_VERBOSE 1
757 #else
758 # define YYERROR_VERBOSE 0
759 #endif
760 
761 /* Enabling the token table. */
762 #ifndef YYTOKEN_TABLE
763 # define YYTOKEN_TABLE 0
764 #endif
765 
766 
767 /* Tokens. */
768 #ifndef YYTOKENTYPE
769 # define YYTOKENTYPE
770  /* Put the tokens into the symbol table, so that GDB and other debuggers
771  know about them. */
772  enum yytokentype {
776  keyword_def = 260,
781  keyword_end = 265,
782  keyword_if = 266,
791  keyword_for = 275,
796  keyword_in = 280,
797  keyword_do = 281,
805  keyword_nil = 289,
808  keyword_and = 292,
809  keyword_or = 293,
810  keyword_not = 294,
811  modifier_if = 295,
819  keyword_END = 303,
823  tIDENTIFIER = 307,
824  tFID = 308,
825  tGVAR = 309,
826  tIVAR = 310,
827  tCONSTANT = 311,
828  tCVAR = 312,
829  tLABEL = 313,
830  tINTEGER = 314,
831  tFLOAT = 315,
833  tCHAR = 317,
834  tNTH_REF = 318,
835  tBACK_REF = 319,
836  tREGEXP_END = 320,
837  tUPLUS = 130,
838  tUMINUS = 131,
839  tPOW = 132,
840  tCMP = 134,
841  tEQ = 139,
842  tEQQ = 140,
843  tNEQ = 141,
844  tGEQ = 138,
845  tLEQ = 137,
846  tANDOP = 321,
847  tOROP = 322,
848  tMATCH = 142,
849  tNMATCH = 143,
850  tDOT2 = 128,
851  tDOT3 = 129,
852  tAREF = 144,
853  tASET = 145,
854  tLSHFT = 135,
855  tRSHFT = 136,
856  tCOLON2 = 323,
857  tCOLON3 = 324,
858  tOP_ASGN = 325,
859  tASSOC = 326,
860  tLPAREN = 327,
861  tLPAREN_ARG = 328,
862  tRPAREN = 329,
863  tLBRACK = 330,
864  tLBRACE = 331,
865  tLBRACE_ARG = 332,
866  tSTAR = 333,
867  tDSTAR = 334,
868  tAMPER = 335,
869  tLAMBDA = 336,
870  tSYMBEG = 337,
871  tSTRING_BEG = 338,
873  tREGEXP_BEG = 340,
874  tWORDS_BEG = 341,
875  tQWORDS_BEG = 342,
881  tSTRING_END = 348,
882  tLAMBEG = 349,
883  tLOWEST = 350,
884  tUMINUS_NUM = 351,
886  };
887 #endif
888 
889 
890 
891 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
892 typedef union YYSTYPE
893 {
894 
895 /* Line 293 of yacc.c */
896 #line 691 "parse.y"
897 
898  VALUE val;
899  NODE *node;
900  ID id;
901  int num;
902  const struct vtable *vars;
903 
904 
905 
906 /* Line 293 of yacc.c */
907 #line 908 "parse.c"
908 } YYSTYPE;
909 # define YYSTYPE_IS_TRIVIAL 1
910 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
911 # define YYSTYPE_IS_DECLARED 1
912 #endif
913 
914 
915 /* Copy the second part of user declarations. */
916 
917 
918 /* Line 343 of yacc.c */
919 #line 920 "parse.c"
920 
921 #ifdef short
922 # undef short
923 #endif
924 
925 #ifdef YYTYPE_UINT8
926 typedef YYTYPE_UINT8 yytype_uint8;
927 #else
928 typedef unsigned char yytype_uint8;
929 #endif
930 
931 #ifdef YYTYPE_INT8
932 typedef YYTYPE_INT8 yytype_int8;
933 #elif (defined __STDC__ || defined __C99__FUNC__ \
934  || defined __cplusplus || defined _MSC_VER)
935 typedef signed char yytype_int8;
936 #else
937 typedef short int yytype_int8;
938 #endif
939 
940 #ifdef YYTYPE_UINT16
941 typedef YYTYPE_UINT16 yytype_uint16;
942 #else
943 typedef unsigned short int yytype_uint16;
944 #endif
945 
946 #ifdef YYTYPE_INT16
947 typedef YYTYPE_INT16 yytype_int16;
948 #else
949 typedef short int yytype_int16;
950 #endif
951 
952 #ifndef YYSIZE_T
953 # ifdef __SIZE_TYPE__
954 # define YYSIZE_T __SIZE_TYPE__
955 # elif defined size_t
956 # define YYSIZE_T size_t
957 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
958  || defined __cplusplus || defined _MSC_VER)
959 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
960 # define YYSIZE_T size_t
961 # else
962 # define YYSIZE_T unsigned int
963 # endif
964 #endif
965 
966 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
967 
968 #ifndef YY_
969 # if defined YYENABLE_NLS && YYENABLE_NLS
970 # if ENABLE_NLS
971 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
972 # define YY_(msgid) dgettext ("bison-runtime", msgid)
973 # endif
974 # endif
975 # ifndef YY_
976 # define YY_(msgid) msgid
977 # endif
978 #endif
979 
980 /* Suppress unused-variable warnings by "using" E. */
981 #if ! defined lint || defined __GNUC__
982 # define YYUSE(e) ((void) (e))
983 #else
984 # define YYUSE(e) /* empty */
985 #endif
986 
987 /* Identity function, used to suppress warnings about constant conditions. */
988 #ifndef lint
989 # define YYID(n) (n)
990 #else
991 #if (defined __STDC__ || defined __C99__FUNC__ \
992  || defined __cplusplus || defined _MSC_VER)
993 static int
994 YYID (int yyi)
995 #else
996 static int
997 YYID (yyi)
998  int yyi;
999 #endif
1000 {
1001  return yyi;
1002 }
1003 #endif
1004 
1005 #if ! defined yyoverflow || YYERROR_VERBOSE
1006 
1007 /* The parser invokes alloca or malloc; define the necessary symbols. */
1008 
1009 # ifdef YYSTACK_USE_ALLOCA
1010 # if YYSTACK_USE_ALLOCA
1011 # ifdef __GNUC__
1012 # define YYSTACK_ALLOC __builtin_alloca
1013 # elif defined __BUILTIN_VA_ARG_INCR
1014 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1015 # elif defined _AIX
1016 # define YYSTACK_ALLOC __alloca
1017 # elif defined _MSC_VER
1018 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1019 # define alloca _alloca
1020 # else
1021 # define YYSTACK_ALLOC alloca
1022 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1023  || defined __cplusplus || defined _MSC_VER)
1024 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1025 # ifndef EXIT_SUCCESS
1026 # define EXIT_SUCCESS 0
1027 # endif
1028 # endif
1029 # endif
1030 # endif
1031 # endif
1032 
1033 # ifdef YYSTACK_ALLOC
1034  /* Pacify GCC's `empty if-body' warning. */
1035 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1036 # ifndef YYSTACK_ALLOC_MAXIMUM
1037  /* The OS might guarantee only one guard page at the bottom of the stack,
1038  and a page size can be as small as 4096 bytes. So we cannot safely
1039  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1040  to allow for a few compiler-allocated temporary stack slots. */
1041 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1042 # endif
1043 # else
1044 # define YYSTACK_ALLOC YYMALLOC
1045 # define YYSTACK_FREE YYFREE
1046 # ifndef YYSTACK_ALLOC_MAXIMUM
1047 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1048 # endif
1049 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
1050  && ! ((defined YYMALLOC || defined malloc) \
1051  && (defined YYFREE || defined free)))
1052 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1053 # ifndef EXIT_SUCCESS
1054 # define EXIT_SUCCESS 0
1055 # endif
1056 # endif
1057 # ifndef YYMALLOC
1058 # define YYMALLOC malloc
1059 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1060  || defined __cplusplus || defined _MSC_VER)
1061 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1062 # endif
1063 # endif
1064 # ifndef YYFREE
1065 # define YYFREE free
1066 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1067  || defined __cplusplus || defined _MSC_VER)
1068 void free (void *); /* INFRINGES ON USER NAME SPACE */
1069 # endif
1070 # endif
1071 # endif
1072 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1073 
1074 
1075 #if (! defined yyoverflow \
1076  && (! defined __cplusplus \
1077  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1078 
1079 /* A type that is properly aligned for any stack member. */
1080 union yyalloc
1081 {
1082  yytype_int16 yyss_alloc;
1084 };
1085 
1086 /* The size of the maximum gap between one aligned stack and the next. */
1087 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1088 
1089 /* The size of an array large to enough to hold all stacks, each with
1090  N elements. */
1091 # define YYSTACK_BYTES(N) \
1092  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1093  + YYSTACK_GAP_MAXIMUM)
1094 
1095 # define YYCOPY_NEEDED 1
1096 
1097 /* Relocate STACK from its old location to the new one. The
1098  local variables YYSIZE and YYSTACKSIZE give the old and new number of
1099  elements in the stack, and YYPTR gives the new location of the
1100  stack. Advance YYPTR to a properly aligned location for the next
1101  stack. */
1102 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1103  do \
1104  { \
1105  YYSIZE_T yynewbytes; \
1106  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1107  Stack = &yyptr->Stack_alloc; \
1108  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1109  yyptr += yynewbytes / sizeof (*yyptr); \
1110  } \
1111  while (YYID (0))
1112 
1113 #endif
1114 
1115 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1116 /* Copy COUNT objects from FROM to TO. The source and destination do
1117  not overlap. */
1118 # ifndef YYCOPY
1119 # if defined __GNUC__ && 1 < __GNUC__
1120 # define YYCOPY(To, From, Count) \
1121  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1122 # else
1123 # define YYCOPY(To, From, Count) \
1124  do \
1125  { \
1126  YYSIZE_T yyi; \
1127  for (yyi = 0; yyi < (Count); yyi++) \
1128  (To)[yyi] = (From)[yyi]; \
1129  } \
1130  while (YYID (0))
1131 # endif
1132 # endif
1133 #endif /* !YYCOPY_NEEDED */
1134 
1135 /* YYFINAL -- State number of the termination state. */
1136 #define YYFINAL 3
1137 /* YYLAST -- Last index in YYTABLE. */
1138 #define YYLAST 10700
1139 
1140 /* YYNTOKENS -- Number of terminals. */
1141 #define YYNTOKENS 142
1142 /* YYNNTS -- Number of nonterminals. */
1143 #define YYNNTS 199
1144 /* YYNRULES -- Number of rules. */
1145 #define YYNRULES 620
1146 /* YYNRULES -- Number of states. */
1147 #define YYNSTATES 1057
1148 
1149 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1150 #define YYUNDEFTOK 2
1151 #define YYMAXUTOK 352
1152 
1153 #define YYTRANSLATE(YYX) \
1154  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1155 
1156 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1157 static const yytype_uint8 yytranslate[] =
1158 {
1159  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1160  141, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1161  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1162  2, 2, 140, 127, 2, 2, 2, 125, 120, 2,
1163  136, 137, 123, 121, 134, 122, 133, 124, 2, 2,
1164  2, 2, 2, 2, 2, 2, 2, 2, 115, 139,
1165  117, 113, 116, 114, 2, 2, 2, 2, 2, 2,
1166  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1167  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1168  2, 132, 2, 138, 119, 2, 135, 2, 2, 2,
1169  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1170  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1171  2, 2, 2, 130, 118, 131, 128, 2, 79, 80,
1172  66, 67, 68, 2, 69, 83, 84, 74, 73, 70,
1173  71, 72, 77, 78, 81, 82, 2, 2, 2, 2,
1174  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1175  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1176  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1177  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1178  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1179  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1180  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1181  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1182  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1183  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1184  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1185  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1186  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1187  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1188  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1189  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1190  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1191  65, 75, 76, 85, 86, 87, 88, 89, 90, 91,
1192  92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
1193  102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
1194  112, 126, 129
1195 };
1196 
1197 #if YYDEBUG
1198 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1199  YYRHS. */
1200 static const yytype_uint16 yyprhs[] =
1201 {
1202  0, 0, 3, 4, 7, 10, 12, 14, 18, 21,
1203  23, 24, 30, 35, 38, 40, 42, 46, 49, 51,
1204  52, 58, 59, 64, 68, 72, 76, 79, 83, 87,
1205  91, 95, 99, 104, 106, 110, 114, 121, 127, 133,
1206  139, 145, 149, 153, 157, 161, 163, 167, 171, 173,
1207  177, 181, 185, 188, 190, 192, 194, 196, 198, 203,
1208  204, 210, 212, 215, 219, 224, 230, 235, 241, 244,
1209  247, 250, 253, 256, 258, 262, 264, 268, 270, 273,
1210  277, 283, 286, 291, 294, 299, 301, 305, 307, 311,
1211  314, 318, 320, 324, 326, 328, 333, 337, 341, 345,
1212  349, 352, 354, 356, 358, 363, 367, 371, 375, 379,
1213  382, 384, 386, 388, 391, 393, 397, 399, 401, 403,
1214  405, 407, 409, 411, 413, 415, 417, 418, 423, 425,
1215  427, 429, 431, 433, 435, 437, 439, 441, 443, 445,
1216  447, 449, 451, 453, 455, 457, 459, 461, 463, 465,
1217  467, 469, 471, 473, 475, 477, 479, 481, 483, 485,
1218  487, 489, 491, 493, 495, 497, 499, 501, 503, 505,
1219  507, 509, 511, 513, 515, 517, 519, 521, 523, 525,
1220  527, 529, 531, 533, 535, 537, 539, 541, 543, 545,
1221  547, 549, 551, 553, 555, 557, 559, 561, 563, 565,
1222  569, 575, 579, 585, 592, 598, 604, 610, 616, 621,
1223  625, 629, 633, 637, 641, 645, 649, 653, 657, 662,
1224  667, 670, 673, 677, 681, 685, 689, 693, 697, 701,
1225  705, 709, 713, 717, 721, 725, 728, 731, 735, 739,
1226  743, 747, 748, 753, 760, 762, 764, 766, 769, 774,
1227  777, 781, 783, 785, 787, 789, 792, 797, 800, 802,
1228  805, 808, 813, 815, 816, 819, 822, 825, 827, 829,
1229  832, 836, 841, 845, 850, 853, 855, 857, 859, 861,
1230  863, 865, 867, 869, 871, 873, 875, 876, 881, 882,
1231  886, 887, 888, 894, 898, 902, 905, 909, 913, 915,
1232  920, 924, 926, 927, 934, 939, 943, 946, 948, 951,
1233  954, 961, 968, 969, 970, 978, 979, 980, 988, 994,
1234  999, 1000, 1001, 1011, 1012, 1019, 1020, 1021, 1030, 1031,
1235  1037, 1038, 1045, 1046, 1047, 1057, 1059, 1061, 1063, 1065,
1236  1067, 1069, 1071, 1073, 1075, 1077, 1079, 1081, 1083, 1085,
1237  1087, 1089, 1091, 1093, 1096, 1098, 1100, 1102, 1108, 1110,
1238  1113, 1115, 1117, 1119, 1123, 1125, 1129, 1131, 1136, 1143,
1239  1147, 1153, 1156, 1161, 1163, 1167, 1172, 1175, 1178, 1180,
1240  1183, 1184, 1191, 1200, 1205, 1212, 1217, 1220, 1227, 1230,
1241  1235, 1242, 1245, 1250, 1253, 1258, 1260, 1262, 1264, 1268,
1242  1270, 1275, 1277, 1282, 1284, 1288, 1290, 1292, 1293, 1294,
1243  1295, 1301, 1306, 1308, 1312, 1316, 1317, 1323, 1326, 1331,
1244  1337, 1343, 1346, 1347, 1353, 1354, 1360, 1364, 1365, 1370,
1245  1371, 1376, 1379, 1381, 1386, 1387, 1393, 1394, 1400, 1406,
1246  1408, 1410, 1417, 1419, 1421, 1423, 1425, 1428, 1430, 1433,
1247  1435, 1437, 1439, 1441, 1443, 1445, 1447, 1450, 1454, 1458,
1248  1462, 1466, 1470, 1471, 1475, 1477, 1480, 1484, 1488, 1489,
1249  1493, 1497, 1501, 1505, 1509, 1510, 1514, 1515, 1519, 1520,
1250  1523, 1524, 1527, 1528, 1531, 1533, 1534, 1538, 1539, 1540,
1251  1541, 1548, 1550, 1552, 1554, 1556, 1559, 1561, 1563, 1565,
1252  1567, 1571, 1573, 1575, 1578, 1581, 1583, 1585, 1587, 1589,
1253  1591, 1593, 1595, 1597, 1599, 1601, 1603, 1605, 1607, 1609,
1254  1611, 1613, 1615, 1617, 1619, 1620, 1625, 1628, 1632, 1635,
1255  1640, 1643, 1646, 1648, 1651, 1652, 1659, 1668, 1673, 1680,
1256  1685, 1692, 1695, 1700, 1707, 1710, 1715, 1718, 1723, 1725,
1257  1726, 1728, 1730, 1732, 1734, 1736, 1738, 1740, 1744, 1746,
1258  1750, 1753, 1756, 1758, 1762, 1764, 1768, 1770, 1772, 1775,
1259  1777, 1781, 1785, 1787, 1791, 1793, 1797, 1799, 1801, 1804,
1260  1806, 1808, 1810, 1813, 1816, 1818, 1820, 1821, 1826, 1828,
1261  1831, 1833, 1837, 1841, 1844, 1847, 1849, 1851, 1853, 1855,
1262  1857, 1859, 1861, 1863, 1865, 1867, 1869, 1871, 1872, 1874,
1263  1875, 1877, 1880, 1883, 1884, 1886, 1888, 1890, 1892, 1894,
1264  1897
1265 };
1266 
1267 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1268 static const yytype_int16 yyrhs[] =
1269 {
1270  143, 0, -1, -1, 144, 145, -1, 146, 333, -1,
1271  340, -1, 147, -1, 146, 339, 147, -1, 1, 147,
1272  -1, 154, -1, -1, 47, 148, 130, 145, 131, -1,
1273  150, 262, 230, 265, -1, 151, 333, -1, 340, -1,
1274  152, -1, 151, 339, 152, -1, 1, 154, -1, 154,
1275  -1, -1, 47, 153, 130, 145, 131, -1, -1, 45,
1276  177, 155, 177, -1, 45, 54, 54, -1, 45, 54,
1277  64, -1, 45, 54, 63, -1, 6, 178, -1, 154,
1278  40, 158, -1, 154, 41, 158, -1, 154, 42, 158,
1279  -1, 154, 43, 158, -1, 154, 44, 154, -1, 48,
1280  130, 150, 131, -1, 156, -1, 165, 113, 159, -1,
1281  297, 87, 159, -1, 215, 132, 188, 336, 87, 159,
1282  -1, 215, 133, 52, 87, 159, -1, 215, 133, 56,
1283  87, 159, -1, 215, 85, 56, 87, 159, -1, 215,
1284  85, 52, 87, 159, -1, 298, 87, 159, -1, 172,
1285  113, 195, -1, 165, 113, 184, -1, 165, 113, 195,
1286  -1, 157, -1, 172, 113, 159, -1, 172, 113, 156,
1287  -1, 159, -1, 157, 37, 157, -1, 157, 38, 157,
1288  -1, 39, 334, 157, -1, 127, 159, -1, 182, -1,
1289  157, -1, 164, -1, 160, -1, 251, -1, 251, 332,
1290  330, 190, -1, -1, 94, 162, 238, 150, 131, -1,
1291  329, -1, 163, 190, -1, 163, 190, 161, -1, 215,
1292  133, 330, 190, -1, 215, 133, 330, 190, 161, -1,
1293  215, 85, 330, 190, -1, 215, 85, 330, 190, 161,
1294  -1, 32, 190, -1, 31, 190, -1, 30, 189, -1,
1295  21, 189, -1, 22, 189, -1, 167, -1, 89, 166,
1296  335, -1, 167, -1, 89, 166, 335, -1, 169, -1,
1297  169, 168, -1, 169, 95, 171, -1, 169, 95, 171,
1298  134, 170, -1, 169, 95, -1, 169, 95, 134, 170,
1299  -1, 95, 171, -1, 95, 171, 134, 170, -1, 95,
1300  -1, 95, 134, 170, -1, 171, -1, 89, 166, 335,
1301  -1, 168, 134, -1, 169, 168, 134, -1, 168, -1,
1302  170, 134, 168, -1, 294, -1, 295, -1, 215, 132,
1303  188, 336, -1, 215, 133, 52, -1, 215, 85, 52,
1304  -1, 215, 133, 56, -1, 215, 85, 56, -1, 86,
1305  56, -1, 298, -1, 294, -1, 295, -1, 215, 132,
1306  188, 336, -1, 215, 133, 52, -1, 215, 85, 52,
1307  -1, 215, 133, 56, -1, 215, 85, 56, -1, 86,
1308  56, -1, 298, -1, 52, -1, 56, -1, 86, 173,
1309  -1, 173, -1, 215, 85, 173, -1, 52, -1, 56,
1310  -1, 53, -1, 180, -1, 181, -1, 175, -1, 290,
1311  -1, 176, -1, 292, -1, 177, -1, -1, 178, 134,
1312  179, 177, -1, 118, -1, 119, -1, 120, -1, 69,
1313  -1, 70, -1, 71, -1, 77, -1, 78, -1, 116,
1314  -1, 73, -1, 117, -1, 74, -1, 72, -1, 83,
1315  -1, 84, -1, 121, -1, 122, -1, 123, -1, 95,
1316  -1, 124, -1, 125, -1, 68, -1, 96, -1, 127,
1317  -1, 128, -1, 66, -1, 67, -1, 81, -1, 82,
1318  -1, 135, -1, 49, -1, 50, -1, 51, -1, 47,
1319  -1, 48, -1, 45, -1, 37, -1, 7, -1, 21,
1320  -1, 16, -1, 3, -1, 5, -1, 46, -1, 26,
1321  -1, 15, -1, 14, -1, 10, -1, 9, -1, 36,
1322  -1, 20, -1, 25, -1, 4, -1, 22, -1, 34,
1323  -1, 39, -1, 38, -1, 23, -1, 8, -1, 24,
1324  -1, 30, -1, 33, -1, 32, -1, 13, -1, 35,
1325  -1, 6, -1, 17, -1, 31, -1, 11, -1, 12,
1326  -1, 18, -1, 19, -1, 172, 113, 182, -1, 172,
1327  113, 182, 44, 182, -1, 297, 87, 182, -1, 297,
1328  87, 182, 44, 182, -1, 215, 132, 188, 336, 87,
1329  182, -1, 215, 133, 52, 87, 182, -1, 215, 133,
1330  56, 87, 182, -1, 215, 85, 52, 87, 182, -1,
1331  215, 85, 56, 87, 182, -1, 86, 56, 87, 182,
1332  -1, 298, 87, 182, -1, 182, 79, 182, -1, 182,
1333  80, 182, -1, 182, 121, 182, -1, 182, 122, 182,
1334  -1, 182, 123, 182, -1, 182, 124, 182, -1, 182,
1335  125, 182, -1, 182, 68, 182, -1, 126, 59, 68,
1336  182, -1, 126, 60, 68, 182, -1, 66, 182, -1,
1337  67, 182, -1, 182, 118, 182, -1, 182, 119, 182,
1338  -1, 182, 120, 182, -1, 182, 69, 182, -1, 182,
1339  116, 182, -1, 182, 73, 182, -1, 182, 117, 182,
1340  -1, 182, 74, 182, -1, 182, 70, 182, -1, 182,
1341  71, 182, -1, 182, 72, 182, -1, 182, 77, 182,
1342  -1, 182, 78, 182, -1, 127, 182, -1, 128, 182,
1343  -1, 182, 83, 182, -1, 182, 84, 182, -1, 182,
1344  75, 182, -1, 182, 76, 182, -1, -1, 46, 334,
1345  183, 182, -1, 182, 114, 182, 334, 115, 182, -1,
1346  196, -1, 182, -1, 340, -1, 194, 337, -1, 194,
1347  134, 327, 337, -1, 327, 337, -1, 136, 188, 335,
1348  -1, 340, -1, 186, -1, 340, -1, 189, -1, 194,
1349  134, -1, 194, 134, 327, 134, -1, 327, 134, -1,
1350  164, -1, 194, 193, -1, 327, 193, -1, 194, 134,
1351  327, 193, -1, 192, -1, -1, 191, 189, -1, 97,
1352  184, -1, 134, 192, -1, 340, -1, 184, -1, 95,
1353  184, -1, 194, 134, 184, -1, 194, 134, 95, 184,
1354  -1, 194, 134, 184, -1, 194, 134, 95, 184, -1,
1355  95, 184, -1, 266, -1, 267, -1, 270, -1, 271,
1356  -1, 272, -1, 277, -1, 275, -1, 278, -1, 296,
1357  -1, 298, -1, 53, -1, -1, 216, 197, 149, 226,
1358  -1, -1, 90, 198, 335, -1, -1, -1, 90, 199,
1359  157, 200, 335, -1, 89, 150, 137, -1, 215, 85,
1360  56, -1, 86, 56, -1, 92, 185, 138, -1, 93,
1361  326, 131, -1, 30, -1, 31, 136, 189, 335, -1,
1362  31, 136, 335, -1, 31, -1, -1, 46, 334, 136,
1363  201, 157, 335, -1, 39, 136, 157, 335, -1, 39,
1364  136, 335, -1, 163, 257, -1, 252, -1, 252, 257,
1365  -1, 98, 243, -1, 217, 158, 227, 150, 229, 226,
1366  -1, 218, 158, 227, 150, 230, 226, -1, -1, -1,
1367  219, 202, 158, 228, 203, 150, 226, -1, -1, -1,
1368  220, 204, 158, 228, 205, 150, 226, -1, 221, 158,
1369  333, 260, 226, -1, 221, 333, 260, 226, -1, -1,
1370  -1, 222, 231, 25, 206, 158, 228, 207, 150, 226,
1371  -1, -1, 223, 174, 299, 208, 149, 226, -1, -1,
1372  -1, 223, 83, 157, 209, 338, 210, 149, 226, -1,
1373  -1, 224, 174, 211, 149, 226, -1, -1, 225, 175,
1374  212, 301, 149, 226, -1, -1, -1, 225, 324, 332,
1375  213, 175, 214, 301, 149, 226, -1, 21, -1, 22,
1376  -1, 23, -1, 24, -1, 196, -1, 7, -1, 11,
1377  -1, 12, -1, 18, -1, 19, -1, 16, -1, 20,
1378  -1, 3, -1, 4, -1, 5, -1, 10, -1, 338,
1379  -1, 13, -1, 338, 13, -1, 338, -1, 27, -1,
1380  230, -1, 14, 158, 227, 150, 229, -1, 340, -1,
1381  15, 150, -1, 172, -1, 165, -1, 306, -1, 89,
1382  234, 335, -1, 232, -1, 233, 134, 232, -1, 233,
1383  -1, 233, 134, 95, 306, -1, 233, 134, 95, 306,
1384  134, 233, -1, 233, 134, 95, -1, 233, 134, 95,
1385  134, 233, -1, 95, 306, -1, 95, 306, 134, 233,
1386  -1, 95, -1, 95, 134, 233, -1, 311, 134, 314,
1387  323, -1, 311, 323, -1, 314, 323, -1, 322, -1,
1388  134, 235, -1, -1, 308, 134, 317, 134, 320, 236,
1389  -1, 308, 134, 317, 134, 320, 134, 308, 236, -1,
1390  308, 134, 317, 236, -1, 308, 134, 317, 134, 308,
1391  236, -1, 308, 134, 320, 236, -1, 308, 134, -1,
1392  308, 134, 320, 134, 308, 236, -1, 308, 236, -1,
1393  317, 134, 320, 236, -1, 317, 134, 320, 134, 308,
1394  236, -1, 317, 236, -1, 317, 134, 308, 236, -1,
1395  320, 236, -1, 320, 134, 308, 236, -1, 235, -1,
1396  340, -1, 239, -1, 118, 240, 118, -1, 76, -1,
1397  118, 237, 240, 118, -1, 334, -1, 334, 139, 241,
1398  334, -1, 242, -1, 241, 134, 242, -1, 52, -1,
1399  305, -1, -1, -1, -1, 244, 245, 247, 246, 248,
1400  -1, 136, 304, 240, 137, -1, 304, -1, 111, 150,
1401  131, -1, 29, 150, 10, -1, -1, 28, 250, 238,
1402  150, 10, -1, 164, 249, -1, 251, 332, 330, 187,
1403  -1, 251, 332, 330, 187, 257, -1, 251, 332, 330,
1404  190, 249, -1, 163, 186, -1, -1, 215, 133, 330,
1405  253, 187, -1, -1, 215, 85, 330, 254, 186, -1,
1406  215, 85, 331, -1, -1, 215, 133, 255, 186, -1,
1407  -1, 215, 85, 256, 186, -1, 32, 186, -1, 32,
1408  -1, 215, 132, 188, 336, -1, -1, 130, 258, 238,
1409  150, 131, -1, -1, 26, 259, 238, 150, 10, -1,
1410  17, 194, 227, 150, 261, -1, 230, -1, 260, -1,
1411  8, 263, 264, 227, 150, 262, -1, 340, -1, 184,
1412  -1, 195, -1, 340, -1, 88, 172, -1, 340, -1,
1413  9, 150, -1, 340, -1, 293, -1, 290, -1, 292,
1414  -1, 268, -1, 62, -1, 269, -1, 268, 269, -1,
1415  100, 281, 110, -1, 101, 282, 110, -1, 102, 283,
1416  65, -1, 103, 140, 110, -1, 103, 273, 110, -1,
1417  -1, 273, 274, 140, -1, 284, -1, 274, 284, -1,
1418  105, 140, 110, -1, 105, 276, 110, -1, -1, 276,
1419  274, 140, -1, 104, 140, 110, -1, 104, 279, 110,
1420  -1, 106, 140, 110, -1, 106, 280, 110, -1, -1,
1421  279, 61, 140, -1, -1, 280, 61, 140, -1, -1,
1422  281, 284, -1, -1, 282, 284, -1, -1, 283, 284,
1423  -1, 61, -1, -1, 109, 285, 289, -1, -1, -1,
1424  -1, 107, 286, 287, 288, 150, 108, -1, 54, -1,
1425  55, -1, 57, -1, 298, -1, 99, 291, -1, 175,
1426  -1, 55, -1, 54, -1, 57, -1, 99, 282, 110,
1427  -1, 59, -1, 60, -1, 126, 59, -1, 126, 60,
1428  -1, 52, -1, 55, -1, 54, -1, 56, -1, 57,
1429  -1, 34, -1, 33, -1, 35, -1, 36, -1, 50,
1430  -1, 49, -1, 51, -1, 294, -1, 295, -1, 294,
1431  -1, 295, -1, 63, -1, 64, -1, 338, -1, -1,
1432  117, 300, 158, 338, -1, 1, 338, -1, 136, 304,
1433  335, -1, 304, 338, -1, 312, 134, 314, 323, -1,
1434  312, 323, -1, 314, 323, -1, 322, -1, 134, 302,
1435  -1, -1, 308, 134, 318, 134, 320, 303, -1, 308,
1436  134, 318, 134, 320, 134, 308, 303, -1, 308, 134,
1437  318, 303, -1, 308, 134, 318, 134, 308, 303, -1,
1438  308, 134, 320, 303, -1, 308, 134, 320, 134, 308,
1439  303, -1, 308, 303, -1, 318, 134, 320, 303, -1,
1440  318, 134, 320, 134, 308, 303, -1, 318, 303, -1,
1441  318, 134, 308, 303, -1, 320, 303, -1, 320, 134,
1442  308, 303, -1, 302, -1, -1, 56, -1, 55, -1,
1443  54, -1, 57, -1, 305, -1, 52, -1, 306, -1,
1444  89, 234, 335, -1, 307, -1, 308, 134, 307, -1,
1445  58, 184, -1, 58, 215, -1, 310, -1, 311, 134,
1446  310, -1, 309, -1, 312, 134, 309, -1, 68, -1,
1447  96, -1, 313, 52, -1, 313, -1, 52, 113, 184,
1448  -1, 52, 113, 215, -1, 316, -1, 317, 134, 316,
1449  -1, 315, -1, 318, 134, 315, -1, 123, -1, 95,
1450  -1, 319, 52, -1, 319, -1, 120, -1, 97, -1,
1451  321, 52, -1, 134, 322, -1, 340, -1, 296, -1,
1452  -1, 136, 325, 157, 335, -1, 340, -1, 327, 337,
1453  -1, 328, -1, 327, 134, 328, -1, 184, 88, 184,
1454  -1, 58, 184, -1, 96, 184, -1, 52, -1, 56,
1455  -1, 53, -1, 52, -1, 56, -1, 53, -1, 180,
1456  -1, 52, -1, 53, -1, 180, -1, 133, -1, 85,
1457  -1, -1, 339, -1, -1, 141, -1, 334, 137, -1,
1458  334, 138, -1, -1, 141, -1, 134, -1, 139, -1,
1459  141, -1, 338, -1, 339, 139, -1, -1
1460 };
1461 
1462 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1463 static const yytype_uint16 yyrline[] =
1464 {
1465  0, 855, 855, 855, 886, 897, 906, 914, 922, 928,
1466  930, 929, 950, 983, 994, 1003, 1011, 1019, 1025, 1030,
1467  1029, 1050, 1050, 1058, 1066, 1077, 1087, 1095, 1104, 1113,
1468  1126, 1139, 1148, 1160, 1161, 1171, 1176, 1197, 1202, 1207,
1469  1217, 1222, 1232, 1241, 1250, 1259, 1262, 1271, 1283, 1284,
1470  1292, 1300, 1308, 1316, 1319, 1331, 1332, 1335, 1336, 1348,
1471  1347, 1369, 1379, 1388, 1401, 1410, 1422, 1431, 1443, 1452,
1472  1461, 1469, 1477, 1487, 1488, 1498, 1499, 1509, 1517, 1525,
1473  1533, 1542, 1550, 1559, 1567, 1576, 1584, 1595, 1596, 1606,
1474  1614, 1624, 1632, 1642, 1646, 1650, 1658, 1666, 1674, 1682,
1475  1694, 1704, 1716, 1725, 1734, 1742, 1750, 1758, 1766, 1779,
1476  1792, 1803, 1811, 1814, 1822, 1830, 1840, 1841, 1842, 1843,
1477  1848, 1859, 1860, 1863, 1871, 1874, 1882, 1882, 1892, 1893,
1478  1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1903,
1479  1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913,
1480  1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1924, 1924,
1481  1924, 1925, 1925, 1926, 1926, 1926, 1927, 1927, 1927, 1927,
1482  1928, 1928, 1928, 1928, 1929, 1929, 1929, 1930, 1930, 1930,
1483  1930, 1931, 1931, 1931, 1931, 1932, 1932, 1932, 1932, 1933,
1484  1933, 1933, 1933, 1934, 1934, 1934, 1934, 1935, 1935, 1938,
1485  1947, 1957, 1962, 1972, 1998, 2003, 2008, 2013, 2023, 2033,
1486  2044, 2058, 2072, 2080, 2088, 2096, 2104, 2112, 2120, 2129,
1487  2138, 2146, 2154, 2162, 2170, 2178, 2186, 2194, 2202, 2210,
1488  2218, 2226, 2234, 2242, 2253, 2261, 2269, 2277, 2285, 2293,
1489  2301, 2309, 2309, 2319, 2329, 2335, 2347, 2348, 2352, 2360,
1490  2370, 2380, 2381, 2384, 2385, 2386, 2390, 2398, 2408, 2417,
1491  2425, 2435, 2444, 2453, 2453, 2465, 2475, 2479, 2485, 2493,
1492  2501, 2515, 2531, 2545, 2560, 2570, 2571, 2572, 2573, 2574,
1493  2575, 2576, 2577, 2578, 2579, 2580, 2589, 2588, 2616, 2616,
1494  2625, 2629, 2624, 2638, 2646, 2654, 2662, 2675, 2683, 2691,
1495  2699, 2707, 2715, 2715, 2725, 2733, 2741, 2751, 2752, 2762,
1496  2766, 2778, 2790, 2790, 2790, 2801, 2801, 2801, 2812, 2823,
1497  2832, 2834, 2831, 2898, 2897, 2919, 2924, 2918, 2943, 2942,
1498  2964, 2963, 2986, 2987, 2986, 3007, 3015, 3023, 3031, 3041,
1499  3053, 3059, 3065, 3071, 3077, 3083, 3089, 3095, 3101, 3107,
1500  3117, 3123, 3128, 3129, 3136, 3141, 3144, 3145, 3158, 3159,
1501  3169, 3170, 3173, 3181, 3191, 3199, 3209, 3217, 3226, 3235,
1502  3243, 3251, 3260, 3272, 3280, 3291, 3295, 3299, 3303, 3309,
1503  3314, 3319, 3323, 3327, 3331, 3335, 3339, 3347, 3351, 3355,
1504  3359, 3363, 3367, 3371, 3375, 3379, 3385, 3386, 3392, 3401,
1505  3410, 3421, 3425, 3435, 3442, 3451, 3459, 3465, 3468, 3473,
1506  3465, 3489, 3497, 3507, 3511, 3518, 3517, 3538, 3554, 3563,
1507  3575, 3589, 3599, 3598, 3615, 3614, 3630, 3639, 3638, 3656,
1508  3655, 3672, 3680, 3688, 3703, 3702, 3722, 3721, 3742, 3754,
1509  3755, 3758, 3777, 3780, 3788, 3796, 3799, 3803, 3806, 3814,
1510  3817, 3818, 3826, 3829, 3846, 3847, 3848, 3858, 3868, 3895,
1511  3960, 3969, 3980, 3987, 3997, 4005, 4015, 4024, 4035, 4042,
1512  4060, 4069, 4079, 4088, 4099, 4106, 4117, 4124, 4139, 4146,
1513  4157, 4164, 4175, 4182, 4211, 4213, 4212, 4229, 4235, 4240,
1514  4228, 4259, 4267, 4275, 4283, 4286, 4297, 4298, 4299, 4300,
1515  4303, 4314, 4315, 4316, 4324, 4334, 4335, 4336, 4337, 4338,
1516  4341, 4342, 4343, 4344, 4345, 4346, 4347, 4350, 4363, 4373,
1517  4381, 4391, 4392, 4395, 4404, 4403, 4412, 4424, 4434, 4442,
1518  4446, 4450, 4454, 4460, 4465, 4470, 4474, 4478, 4482, 4486,
1519  4490, 4494, 4498, 4502, 4506, 4510, 4514, 4518, 4522, 4527,
1520  4533, 4542, 4551, 4560, 4571, 4572, 4579, 4588, 4607, 4614,
1521  4627, 4639, 4651, 4659, 4676, 4684, 4700, 4701, 4704, 4709,
1522  4715, 4727, 4739, 4747, 4763, 4771, 4787, 4788, 4791, 4804,
1523  4815, 4816, 4819, 4836, 4840, 4850, 4860, 4860, 4889, 4890,
1524  4900, 4907, 4917, 4925, 4933, 4945, 4946, 4947, 4950, 4951,
1525  4952, 4953, 4956, 4957, 4958, 4961, 4966, 4973, 4974, 4977,
1526  4978, 4981, 4984, 4987, 4988, 4989, 4992, 4993, 4996, 4997,
1527  5001
1528 };
1529 #endif
1530 
1531 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1532 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1533  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1534 static const char *const yytname[] =
1535 {
1536  "\"end-of-input\"", "error", "$undefined", "keyword_class",
1537  "keyword_module", "keyword_def", "keyword_undef", "keyword_begin",
1538  "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if",
1539  "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else",
1540  "keyword_case", "keyword_when", "keyword_while", "keyword_until",
1541  "keyword_for", "keyword_break", "keyword_next", "keyword_redo",
1542  "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond",
1543  "keyword_do_block", "keyword_do_LAMBDA", "keyword_return",
1544  "keyword_yield", "keyword_super", "keyword_self", "keyword_nil",
1545  "keyword_true", "keyword_false", "keyword_and", "keyword_or",
1546  "keyword_not", "modifier_if", "modifier_unless", "modifier_while",
1547  "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined",
1548  "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__",
1549  "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR",
1550  "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tSTRING_CONTENT",
1551  "tCHAR", "tNTH_REF", "tBACK_REF", "tREGEXP_END", "\"unary+\"",
1552  "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"", "\"===\"", "\"!=\"",
1553  "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"", "\"!~\"", "\"..\"",
1554  "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"", "\"::\"",
1555  "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"", "\"( arg\"",
1556  "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"", "\"**arg\"", "\"&\"",
1557  "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG",
1558  "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG", "tQSYMBOLS_BEG",
1559  "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
1560  "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
1561  "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "tLAST_TOKEN",
1562  "'{'", "'}'", "'['", "'.'", "','", "'`'", "'('", "')'", "']'", "';'",
1563  "' '", "'\\n'", "$accept", "program", "$@1", "top_compstmt", "top_stmts",
1564  "top_stmt", "$@2", "bodystmt", "compstmt", "stmts", "stmt_or_begin",
1565  "$@3", "stmt", "$@4", "command_asgn", "expr", "expr_value",
1566  "command_call", "block_command", "cmd_brace_block", "@5", "fcall",
1567  "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head",
1568  "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
1569  "fitem", "undef_list", "$@6", "op", "reswords", "arg", "$@7",
1570  "arg_value", "aref_args", "paren_args", "opt_paren_args",
1571  "opt_call_args", "call_args", "command_args", "@8", "block_arg",
1572  "opt_block_arg", "args", "mrhs", "primary", "@9", "$@10", "$@11", "$@12",
1573  "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "$@19", "@20", "@21",
1574  "@22", "@23", "@24", "$@25", "$@26", "primary_value", "k_begin", "k_if",
1575  "k_unless", "k_while", "k_until", "k_case", "k_for", "k_class",
1576  "k_module", "k_def", "k_end", "then", "do", "if_tail", "opt_else",
1577  "for_var", "f_marg", "f_marg_list", "f_margs", "block_args_tail",
1578  "opt_block_args_tail", "block_param", "opt_block_param",
1579  "block_param_def", "opt_bv_decl", "bv_decls", "bvar", "lambda", "@27",
1580  "@28", "@29", "f_larglist", "lambda_body", "do_block", "@30",
1581  "block_call", "method_call", "@31", "@32", "@33", "@34", "brace_block",
1582  "@35", "@36", "case_body", "cases", "opt_rescue", "exc_list", "exc_var",
1583  "opt_ensure", "literal", "strings", "string", "string1", "xstring",
1584  "regexp", "words", "word_list", "word", "symbols", "symbol_list",
1585  "qwords", "qsymbols", "qword_list", "qsym_list", "string_contents",
1586  "xstring_contents", "regexp_contents", "string_content", "@37", "@38",
1587  "@39", "@40", "string_dvar", "symbol", "sym", "dsym", "numeric",
1588  "user_variable", "keyword_variable", "var_ref", "var_lhs", "backref",
1589  "superclass", "$@41", "f_arglist", "args_tail", "opt_args_tail",
1590  "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_kw",
1591  "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest",
1592  "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
1593  "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
1594  "singleton", "$@42", "assoc_list", "assocs", "assoc", "operation",
1595  "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
1596  "rparen", "rbracket", "trailer", "term", "terms", "none", 0
1597 };
1598 #endif
1599 
1600 # ifdef YYPRINT
1601 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1602  token YYLEX-NUM. */
1603 static const yytype_uint16 yytoknum[] =
1604 {
1605  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1606  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1607  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1608  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1609  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1610  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1611  315, 316, 317, 318, 319, 320, 130, 131, 132, 134,
1612  139, 140, 141, 138, 137, 321, 322, 142, 143, 128,
1613  129, 144, 145, 135, 136, 323, 324, 325, 326, 327,
1614  328, 329, 330, 331, 332, 333, 334, 335, 336, 337,
1615  338, 339, 340, 341, 342, 343, 344, 345, 346, 347,
1616  348, 349, 350, 61, 63, 58, 62, 60, 124, 94,
1617  38, 43, 45, 42, 47, 37, 351, 33, 126, 352,
1618  123, 125, 91, 46, 44, 96, 40, 41, 93, 59,
1619  32, 10
1620 };
1621 # endif
1622 
1623 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1624 static const yytype_uint16 yyr1[] =
1625 {
1626  0, 142, 144, 143, 145, 146, 146, 146, 146, 147,
1627  148, 147, 149, 150, 151, 151, 151, 151, 152, 153,
1628  152, 155, 154, 154, 154, 154, 154, 154, 154, 154,
1629  154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1630  154, 154, 154, 154, 154, 154, 156, 156, 157, 157,
1631  157, 157, 157, 157, 158, 159, 159, 160, 160, 162,
1632  161, 163, 164, 164, 164, 164, 164, 164, 164, 164,
1633  164, 164, 164, 165, 165, 166, 166, 167, 167, 167,
1634  167, 167, 167, 167, 167, 167, 167, 168, 168, 169,
1635  169, 170, 170, 171, 171, 171, 171, 171, 171, 171,
1636  171, 171, 172, 172, 172, 172, 172, 172, 172, 172,
1637  172, 173, 173, 174, 174, 174, 175, 175, 175, 175,
1638  175, 176, 176, 177, 177, 178, 179, 178, 180, 180,
1639  180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
1640  180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
1641  180, 180, 180, 180, 180, 180, 180, 180, 181, 181,
1642  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1643  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1644  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1645  181, 181, 181, 181, 181, 181, 181, 181, 181, 182,
1646  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1647  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1648  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1649  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1650  182, 183, 182, 182, 182, 184, 185, 185, 185, 185,
1651  186, 187, 187, 188, 188, 188, 188, 188, 189, 189,
1652  189, 189, 189, 191, 190, 192, 193, 193, 194, 194,
1653  194, 194, 195, 195, 195, 196, 196, 196, 196, 196,
1654  196, 196, 196, 196, 196, 196, 197, 196, 198, 196,
1655  199, 200, 196, 196, 196, 196, 196, 196, 196, 196,
1656  196, 196, 201, 196, 196, 196, 196, 196, 196, 196,
1657  196, 196, 202, 203, 196, 204, 205, 196, 196, 196,
1658  206, 207, 196, 208, 196, 209, 210, 196, 211, 196,
1659  212, 196, 213, 214, 196, 196, 196, 196, 196, 215,
1660  216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1661  226, 227, 227, 227, 228, 228, 229, 229, 230, 230,
1662  231, 231, 232, 232, 233, 233, 234, 234, 234, 234,
1663  234, 234, 234, 234, 234, 235, 235, 235, 235, 236,
1664  236, 237, 237, 237, 237, 237, 237, 237, 237, 237,
1665  237, 237, 237, 237, 237, 237, 238, 238, 239, 239,
1666  239, 240, 240, 241, 241, 242, 242, 244, 245, 246,
1667  243, 247, 247, 248, 248, 250, 249, 251, 251, 251,
1668  251, 252, 253, 252, 254, 252, 252, 255, 252, 256,
1669  252, 252, 252, 252, 258, 257, 259, 257, 260, 261,
1670  261, 262, 262, 263, 263, 263, 264, 264, 265, 265,
1671  266, 266, 266, 267, 268, 268, 268, 269, 270, 271,
1672  272, 272, 273, 273, 274, 274, 275, 275, 276, 276,
1673  277, 277, 278, 278, 279, 279, 280, 280, 281, 281,
1674  282, 282, 283, 283, 284, 285, 284, 286, 287, 288,
1675  284, 289, 289, 289, 289, 290, 291, 291, 291, 291,
1676  292, 293, 293, 293, 293, 294, 294, 294, 294, 294,
1677  295, 295, 295, 295, 295, 295, 295, 296, 296, 297,
1678  297, 298, 298, 299, 300, 299, 299, 301, 301, 302,
1679  302, 302, 302, 303, 303, 304, 304, 304, 304, 304,
1680  304, 304, 304, 304, 304, 304, 304, 304, 304, 304,
1681  305, 305, 305, 305, 306, 306, 307, 307, 308, 308,
1682  309, 310, 311, 311, 312, 312, 313, 313, 314, 314,
1683  315, 316, 317, 317, 318, 318, 319, 319, 320, 320,
1684  321, 321, 322, 323, 323, 324, 325, 324, 326, 326,
1685  327, 327, 328, 328, 328, 329, 329, 329, 330, 330,
1686  330, 330, 331, 331, 331, 332, 332, 333, 333, 334,
1687  334, 335, 336, 337, 337, 337, 338, 338, 339, 339,
1688  340
1689 };
1690 
1691 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1692 static const yytype_uint8 yyr2[] =
1693 {
1694  0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
1695  0, 5, 4, 2, 1, 1, 3, 2, 1, 0,
1696  5, 0, 4, 3, 3, 3, 2, 3, 3, 3,
1697  3, 3, 4, 1, 3, 3, 6, 5, 5, 5,
1698  5, 3, 3, 3, 3, 1, 3, 3, 1, 3,
1699  3, 3, 2, 1, 1, 1, 1, 1, 4, 0,
1700  5, 1, 2, 3, 4, 5, 4, 5, 2, 2,
1701  2, 2, 2, 1, 3, 1, 3, 1, 2, 3,
1702  5, 2, 4, 2, 4, 1, 3, 1, 3, 2,
1703  3, 1, 3, 1, 1, 4, 3, 3, 3, 3,
1704  2, 1, 1, 1, 4, 3, 3, 3, 3, 2,
1705  1, 1, 1, 2, 1, 3, 1, 1, 1, 1,
1706  1, 1, 1, 1, 1, 1, 0, 4, 1, 1,
1707  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1708  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1709  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1710  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1711  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1712  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1713  1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
1714  5, 3, 5, 6, 5, 5, 5, 5, 4, 3,
1715  3, 3, 3, 3, 3, 3, 3, 3, 4, 4,
1716  2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
1717  3, 3, 3, 3, 3, 2, 2, 3, 3, 3,
1718  3, 0, 4, 6, 1, 1, 1, 2, 4, 2,
1719  3, 1, 1, 1, 1, 2, 4, 2, 1, 2,
1720  2, 4, 1, 0, 2, 2, 2, 1, 1, 2,
1721  3, 4, 3, 4, 2, 1, 1, 1, 1, 1,
1722  1, 1, 1, 1, 1, 1, 0, 4, 0, 3,
1723  0, 0, 5, 3, 3, 2, 3, 3, 1, 4,
1724  3, 1, 0, 6, 4, 3, 2, 1, 2, 2,
1725  6, 6, 0, 0, 7, 0, 0, 7, 5, 4,
1726  0, 0, 9, 0, 6, 0, 0, 8, 0, 5,
1727  0, 6, 0, 0, 9, 1, 1, 1, 1, 1,
1728  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1729  1, 1, 1, 2, 1, 1, 1, 5, 1, 2,
1730  1, 1, 1, 3, 1, 3, 1, 4, 6, 3,
1731  5, 2, 4, 1, 3, 4, 2, 2, 1, 2,
1732  0, 6, 8, 4, 6, 4, 2, 6, 2, 4,
1733  6, 2, 4, 2, 4, 1, 1, 1, 3, 1,
1734  4, 1, 4, 1, 3, 1, 1, 0, 0, 0,
1735  5, 4, 1, 3, 3, 0, 5, 2, 4, 5,
1736  5, 2, 0, 5, 0, 5, 3, 0, 4, 0,
1737  4, 2, 1, 4, 0, 5, 0, 5, 5, 1,
1738  1, 6, 1, 1, 1, 1, 2, 1, 2, 1,
1739  1, 1, 1, 1, 1, 1, 2, 3, 3, 3,
1740  3, 3, 0, 3, 1, 2, 3, 3, 0, 3,
1741  3, 3, 3, 3, 0, 3, 0, 3, 0, 2,
1742  0, 2, 0, 2, 1, 0, 3, 0, 0, 0,
1743  6, 1, 1, 1, 1, 2, 1, 1, 1, 1,
1744  3, 1, 1, 2, 2, 1, 1, 1, 1, 1,
1745  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1746  1, 1, 1, 1, 0, 4, 2, 3, 2, 4,
1747  2, 2, 1, 2, 0, 6, 8, 4, 6, 4,
1748  6, 2, 4, 6, 2, 4, 2, 4, 1, 0,
1749  1, 1, 1, 1, 1, 1, 1, 3, 1, 3,
1750  2, 2, 1, 3, 1, 3, 1, 1, 2, 1,
1751  3, 3, 1, 3, 1, 3, 1, 1, 2, 1,
1752  1, 1, 2, 2, 1, 1, 0, 4, 1, 2,
1753  1, 3, 3, 2, 2, 1, 1, 1, 1, 1,
1754  1, 1, 1, 1, 1, 1, 1, 0, 1, 0,
1755  1, 2, 2, 0, 1, 1, 1, 1, 1, 2,
1756  0
1757 };
1758 
1759 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1760  Performed when YYTABLE doesn't specify something else to do. Zero
1761  means the default is an error. */
1762 static const yytype_uint16 yydefact[] =
1763 {
1764  2, 0, 0, 1, 0, 347, 348, 349, 0, 340,
1765  341, 342, 345, 343, 344, 346, 335, 336, 337, 338,
1766  298, 263, 263, 511, 510, 512, 513, 609, 0, 609,
1767  10, 0, 515, 514, 516, 595, 597, 507, 506, 596,
1768  509, 501, 502, 454, 521, 522, 0, 0, 0, 0,
1769  290, 620, 620, 85, 407, 480, 478, 480, 482, 462,
1770  474, 468, 476, 0, 0, 0, 3, 607, 6, 9,
1771  33, 45, 48, 56, 263, 55, 0, 73, 0, 77,
1772  87, 0, 53, 244, 0, 286, 0, 0, 312, 315,
1773  607, 0, 0, 0, 0, 57, 307, 275, 276, 453,
1774  455, 277, 278, 279, 281, 280, 282, 451, 452, 450,
1775  517, 518, 283, 0, 284, 61, 5, 8, 168, 179,
1776  169, 192, 165, 185, 175, 174, 195, 196, 190, 173,
1777  172, 167, 193, 197, 198, 177, 166, 180, 184, 186,
1778  178, 171, 187, 194, 189, 188, 181, 191, 176, 164,
1779  183, 182, 163, 170, 161, 162, 158, 159, 160, 116,
1780  118, 117, 153, 154, 149, 131, 132, 133, 140, 137,
1781  139, 134, 135, 155, 156, 141, 142, 146, 150, 136,
1782  138, 128, 129, 130, 143, 144, 145, 147, 148, 151,
1783  152, 157, 121, 123, 125, 26, 119, 120, 122, 124,
1784  0, 0, 0, 0, 0, 0, 0, 0, 258, 0,
1785  245, 268, 71, 262, 620, 0, 517, 518, 0, 284,
1786  620, 590, 72, 70, 609, 69, 0, 620, 431, 68,
1787  609, 610, 0, 0, 21, 241, 0, 0, 335, 336,
1788  298, 301, 432, 0, 220, 0, 221, 295, 0, 19,
1789  0, 0, 607, 15, 18, 609, 75, 14, 609, 0,
1790  0, 613, 613, 246, 0, 0, 613, 588, 609, 0,
1791  0, 0, 83, 339, 0, 93, 94, 101, 309, 408,
1792  498, 497, 499, 496, 0, 495, 0, 0, 0, 0,
1793  0, 0, 0, 0, 0, 0, 0, 503, 504, 52,
1794  235, 236, 616, 617, 4, 618, 608, 0, 0, 0,
1795  0, 0, 0, 0, 436, 434, 421, 62, 306, 415,
1796  417, 0, 89, 0, 81, 78, 0, 0, 0, 0,
1797  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1798  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1799  0, 0, 0, 429, 620, 427, 0, 54, 0, 0,
1800  0, 0, 607, 0, 608, 0, 361, 360, 0, 0,
1801  517, 518, 284, 111, 112, 0, 0, 114, 0, 0,
1802  517, 518, 284, 328, 188, 181, 191, 176, 158, 159,
1803  160, 116, 117, 586, 330, 585, 0, 606, 605, 0,
1804  308, 456, 0, 0, 126, 593, 295, 269, 594, 265,
1805  0, 0, 0, 259, 267, 429, 620, 427, 0, 0,
1806  0, 260, 609, 0, 300, 264, 609, 254, 620, 620,
1807  253, 609, 305, 51, 23, 25, 24, 0, 302, 0,
1808  0, 0, 429, 427, 0, 17, 0, 609, 293, 13,
1809  608, 74, 289, 291, 296, 615, 614, 247, 615, 249,
1810  297, 589, 0, 100, 503, 504, 91, 86, 0, 429,
1811  620, 427, 549, 484, 487, 485, 500, 481, 457, 479,
1812  458, 459, 483, 460, 461, 0, 464, 470, 0, 471,
1813  466, 467, 0, 472, 0, 473, 0, 0, 619, 7,
1814  27, 28, 29, 30, 31, 49, 50, 620, 620, 59,
1815  63, 620, 0, 34, 43, 0, 44, 609, 0, 79,
1816  90, 47, 46, 0, 199, 268, 42, 217, 225, 230,
1817  231, 232, 227, 229, 239, 240, 233, 234, 210, 211,
1818  237, 238, 609, 226, 228, 222, 223, 224, 212, 213,
1819  214, 215, 216, 598, 600, 599, 601, 0, 263, 426,
1820  609, 598, 600, 599, 601, 0, 263, 0, 620, 352,
1821  0, 351, 0, 0, 0, 0, 0, 0, 295, 429,
1822  620, 427, 320, 325, 111, 112, 113, 0, 524, 323,
1823  523, 429, 620, 427, 0, 0, 549, 332, 598, 599,
1824  263, 35, 201, 41, 209, 0, 199, 592, 0, 270,
1825  266, 620, 598, 599, 609, 598, 599, 591, 299, 611,
1826  250, 255, 257, 304, 22, 0, 242, 0, 32, 424,
1827  422, 208, 0, 76, 16, 609, 613, 0, 84, 97,
1828  99, 609, 598, 599, 555, 552, 551, 550, 553, 0,
1829  566, 0, 577, 567, 581, 580, 576, 549, 409, 548,
1830  412, 554, 556, 558, 534, 564, 620, 569, 620, 574,
1831  534, 579, 534, 0, 532, 488, 0, 463, 465, 475,
1832  469, 477, 218, 219, 399, 609, 0, 397, 396, 0,
1833  620, 0, 274, 0, 88, 82, 0, 0, 0, 0,
1834  0, 0, 430, 66, 0, 0, 433, 0, 0, 428,
1835  64, 620, 350, 287, 620, 620, 442, 620, 353, 620,
1836  355, 313, 354, 316, 0, 0, 319, 602, 294, 609,
1837  598, 599, 0, 0, 526, 0, 0, 111, 112, 115,
1838  609, 0, 609, 549, 0, 0, 0, 252, 418, 58,
1839  251, 0, 127, 271, 261, 0, 0, 433, 0, 0,
1840  620, 609, 11, 0, 292, 248, 92, 95, 0, 560,
1841  555, 0, 373, 364, 366, 609, 362, 609, 0, 0,
1842  541, 0, 530, 584, 568, 0, 531, 0, 544, 578,
1843  0, 546, 582, 489, 491, 492, 493, 486, 494, 555,
1844  0, 395, 609, 0, 380, 562, 620, 620, 572, 380,
1845  380, 378, 401, 0, 0, 0, 0, 0, 272, 80,
1846  200, 0, 40, 206, 39, 207, 67, 425, 612, 0,
1847  37, 204, 38, 205, 65, 423, 443, 444, 620, 445,
1848  0, 620, 358, 0, 0, 356, 0, 0, 0, 318,
1849  0, 0, 433, 0, 326, 0, 0, 433, 329, 587,
1850  609, 0, 528, 333, 419, 420, 202, 0, 256, 303,
1851  20, 570, 609, 0, 371, 0, 557, 0, 0, 0,
1852  410, 533, 559, 534, 534, 565, 620, 583, 534, 575,
1853  534, 534, 0, 0, 0, 561, 0, 398, 386, 388,
1854  0, 376, 377, 0, 391, 0, 393, 0, 437, 435,
1855  0, 416, 273, 243, 36, 203, 0, 0, 447, 359,
1856  0, 12, 449, 0, 310, 311, 0, 0, 270, 620,
1857  321, 0, 525, 324, 527, 331, 549, 363, 374, 0,
1858  369, 365, 411, 0, 0, 0, 537, 0, 539, 529,
1859  0, 545, 0, 542, 547, 0, 571, 295, 429, 400,
1860  379, 380, 380, 563, 620, 380, 573, 380, 380, 405,
1861  609, 403, 406, 60, 0, 446, 0, 102, 103, 110,
1862  0, 448, 0, 314, 317, 439, 440, 438, 0, 0,
1863  0, 0, 372, 0, 367, 414, 413, 534, 534, 534,
1864  534, 490, 602, 294, 0, 383, 0, 385, 375, 0,
1865  392, 0, 389, 394, 0, 402, 109, 429, 620, 427,
1866  620, 620, 0, 327, 0, 370, 0, 538, 0, 535,
1867  540, 543, 380, 380, 380, 380, 404, 602, 108, 609,
1868  598, 599, 441, 357, 322, 334, 368, 534, 384, 0,
1869  381, 387, 390, 433, 536, 380, 382
1870 };
1871 
1872 /* YYDEFGOTO[NTERM-NUM]. */
1873 static const yytype_int16 yydefgoto[] =
1874 {
1875  -1, 1, 2, 66, 67, 68, 236, 567, 568, 252,
1876  253, 446, 254, 437, 70, 71, 358, 72, 73, 510,
1877  690, 243, 75, 76, 255, 77, 78, 79, 467, 80,
1878  209, 377, 378, 192, 193, 194, 195, 605, 556, 197,
1879  82, 439, 211, 260, 228, 748, 426, 427, 225, 226,
1880  213, 413, 428, 516, 83, 356, 258, 259, 635, 625,
1881  360, 847, 361, 848, 732, 988, 736, 733, 931, 594,
1882  596, 746, 936, 245, 85, 86, 87, 88, 89, 90,
1883  91, 92, 93, 94, 713, 570, 721, 844, 845, 369,
1884  773, 774, 775, 960, 899, 802, 686, 687, 803, 970,
1885  971, 278, 279, 472, 778, 658, 880, 320, 511, 95,
1886  96, 711, 704, 565, 557, 318, 508, 507, 577, 987,
1887  715, 838, 917, 921, 97, 98, 99, 100, 101, 102,
1888  103, 290, 485, 104, 294, 105, 106, 292, 296, 286,
1889  284, 288, 477, 676, 675, 793, 892, 797, 107, 285,
1890  108, 109, 216, 217, 112, 218, 219, 589, 735, 744,
1891  881, 780, 745, 661, 662, 663, 664, 665, 805, 806,
1892  666, 667, 668, 669, 808, 809, 670, 671, 672, 673,
1893  674, 782, 396, 595, 265, 429, 221, 115, 629, 559,
1894  399, 304, 423, 424, 706, 457, 571, 364, 257
1895 };
1896 
1897 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1898  STATE-NUM. */
1899 #define YYPACT_NINF -808
1900 static const yytype_int16 yypact[] =
1901 {
1902  -808, 134, 2562, -808, 7195, -808, -808, -808, 6718, -808,
1903  -808, -808, -808, -808, -808, -808, 7308, 7308, -808, -808,
1904  7308, 3884, 3479, -808, -808, -808, -808, 455, 6585, 17,
1905  -808, 60, -808, -808, -808, 2804, 3614, -808, -808, 2939,
1906  -808, -808, -808, -808, -808, -808, 8664, 8664, 140, 4955,
1907  462, 7647, 7986, 6977, -808, 6452, -808, -808, -808, 103,
1908  115, 126, 206, 117, 8777, 8664, -808, -25, -808, 1007,
1909  -808, 322, -808, -808, 141, 372, 352, -808, 337, 9003,
1910  -808, 379, 2918, 247, 278, -808, 8890, 8890, -808, -808,
1911  5842, 9112, 9221, 9330, 6318, 33, 65, -808, -808, 410,
1912  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1913  205, 409, -808, 441, 433, -808, -808, -808, -808, -808,
1914  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1915  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1916  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1917  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1918  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1919  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1920  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
1921  -808, -808, -808, -808, -808, 396, -808, -808, -808, -808,
1922  427, 8664, 519, 5094, 8664, 8664, 8664, 8664, -808, 468,
1923  2918, 500, -808, -808, 463, 304, 22, 344, 517, 363,
1924  479, -808, -808, -808, 5729, -808, 7308, 7308, -808, -808,
1925  5955, -808, 8890, 498, -808, 482, 491, 5233, -808, -808,
1926  -808, 497, 499, 141, -808, 361, 570, 458, 7421, -808,
1927  4955, 505, -25, -808, 1007, 17, 538, -808, 17, 8890,
1928  515, 188, 318, -808, 500, 523, 318, -808, 17, 617,
1929  338, 9439, 540, -808, 474, 572, 613, 674, -808, -808,
1930  -808, -808, -808, -808, 522, -808, 601, 669, 284, 576,
1931  752, 577, 58, 582, 759, 584, 68, 609, 612, -808,
1932  -808, -808, -808, -808, -808, -808, 6068, 8890, 8890, 8890,
1933  8890, 7421, 8890, 8890, -808, -808, -808, 588, -808, -808,
1934  -808, 8099, -808, 4955, 7086, 561, 8099, 8664, 8664, 8664,
1935  8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664,
1936  8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664, 8664,
1937  8664, 8664, 8664, 2012, 7308, 9718, 4312, 322, 109, 109,
1938  8890, 8890, -25, 689, 563, 651, -808, -808, 685, 691,
1939  53, 57, 100, 328, 393, 8890, 568, -808, 199, 708,
1940  -808, -808, -808, -808, 55, 223, 249, 279, 283, 301,
1941  316, 384, 417, -808, -808, -808, 33, -808, -808, 9795,
1942  -808, -808, 8777, 8777, -808, -808, 414, -808, -808, -808,
1943  8664, 8664, 7534, -808, -808, 9872, 7308, 9949, 8664, 8664,
1944  7760, -808, 17, 595, -808, -808, 17, -808, 580, 599,
1945  -808, 61, -808, -808, -808, -808, -808, 6718, -808, 8664,
1946  5364, 604, 9872, 9949, 8664, 1007, 607, 17, -808, -808,
1947  6181, 618, -808, 322, -808, 7873, -808, -808, 7986, -808,
1948  -808, -808, 482, 769, -808, -808, -808, 622, 9439, 10026,
1949  7308, 10103, 1417, -808, -808, -808, -808, -808, -808, -808,
1950  -808, -808, -808, -808, -808, 244, -808, -808, 611, -808,
1951  -808, -808, 347, -808, 623, -808, 8664, 8664, -808, -808,
1952  -808, -808, -808, -808, -808, -808, -808, 51, 51, -808,
1953  -808, 51, 8664, -808, 628, 634, -808, 17, 9439, 655,
1954  -808, -808, -808, 678, 1866, -808, -808, 570, 2240, 2240,
1955  2240, 2240, 727, 727, 3323, 3188, 2240, 2240, 3053, 3053,
1956  415, 415, 1674, 727, 727, 907, 907, 660, 40, 40,
1957  570, 570, 570, 4019, 3074, 4154, 3209, 499, 661, -808,
1958  17, 535, -808, 688, -808, 499, 3749, 737, 790, -808,
1959  4451, 799, 4729, 66, 66, 689, 8212, 737, 147, 10180,
1960  7308, 10257, -808, 322, -808, 769, -808, -25, -808, -808,
1961  -808, 10334, 7308, 9795, 4312, 8890, 1538, -808, -808, -808,
1962  4173, -808, 2648, -808, 2918, 6718, 2783, -808, 8664, 500,
1963  -808, 479, 2669, 3344, 17, 420, 444, -808, -808, -808,
1964  -808, 7534, 7760, -808, -808, 8890, 2918, 672, -808, -808,
1965  -808, 2918, 5364, 2, -808, 17, 318, 9439, 622, 701,
1966  469, 17, 207, 224, 711, -808, -808, -808, -808, 8664,
1967  -808, 947, -808, -808, -808, -808, -808, 1789, -808, -808,
1968  -808, -808, -808, -808, 680, -808, 687, 773, 694, -808,
1969  698, 783, 704, 791, -808, -808, 834, -808, -808, -808,
1970  -808, -808, 570, 570, -808, 1322, 5503, -808, -808, 5233,
1971  51, 5503, 721, 8325, -808, 622, 9439, 8777, 8664, 741,
1972  8777, 8777, -808, 588, 499, 722, 818, 8777, 8777, -808,
1973  588, 499, -808, -808, 8438, 827, -808, 597, -808, 827,
1974  -808, -808, -808, -808, 737, 70, -808, 67, 136, 17,
1975  148, 149, 8890, -25, -808, 8890, 4312, 701, 469, -808,
1976  17, 737, 61, 1789, 4312, -25, 6851, -808, 65, 372,
1977  -808, 8664, -808, -808, -808, 8664, 8664, 466, 8664, 8664,
1978  731, 61, -808, 736, -808, -808, -808, 567, 8664, -808,
1979  -808, 947, 350, -808, 738, 17, -808, 17, 72, 1789,
1980  -808, 42, -808, -808, -808, 272, -808, 1789, -808, -808,
1981  892, -808, -808, -808, -808, -808, -808, -808, -808, 762,
1982  9548, -808, 17, 764, 746, -808, 751, 694, -808, 758,
1983  760, -808, 761, 893, 775, 5233, 899, 8664, 776, 622,
1984  2918, 8664, -808, 2918, -808, 2918, -808, -808, -808, 8777,
1985  -808, 2918, -808, 2918, -808, -808, 628, -808, 826, -808,
1986  4842, 909, -808, 8890, 737, -808, 737, 5503, 5503, -808,
1987  8551, 4590, 155, 66, -808, -25, 737, -808, -808, -808,
1988  17, 737, -808, -808, -808, -808, 2918, 8664, 7760, -808,
1989  -808, -808, 17, 1011, 789, 1003, -808, 793, 5503, 5233,
1990  -808, -808, -808, 798, 803, -808, 694, -808, 804, -808,
1991  811, 804, 5616, 9548, 877, 792, 808, -808, 1910, -808,
1992  490, -808, -808, 1910, -808, 1368, -808, 1032, -808, -808,
1993  820, -808, 819, 2918, -808, 2918, 9657, 109, -808, -808,
1994  5503, -808, -808, 109, -808, -808, 737, 737, -808, 130,
1995  -808, 4312, -808, -808, -808, -808, 1538, -808, 821, 1011,
1996  434, -808, -808, 944, 832, 1789, -808, 892, -808, -808,
1997  892, -808, 892, -808, -808, 850, 792, -808, 10411, -808,
1998  -808, 830, 831, -808, 694, 835, -808, 837, 835, -808,
1999  443, -808, -808, -808, 910, -808, 796, 572, 613, 674,
2000  4312, -808, 4451, -808, -808, -808, -808, -808, 5503, 737,
2001  4312, 1011, 821, 1011, 838, -808, -808, 804, 839, 804,
2002  804, -808, 840, 841, 1910, -808, 1368, -808, -808, 1368,
2003  -808, 1368, -808, -808, 1032, -808, 769, 10488, 7308, 10565,
2004  790, 597, 737, -808, 737, 821, 1011, -808, 892, -808,
2005  -808, -808, 835, 844, 835, 835, -808, 74, 469, 17,
2006  146, 158, -808, -808, -808, -808, 821, 804, -808, 1368,
2007  -808, -808, -808, 176, -808, 835, -808
2008 };
2009 
2010 /* YYPGOTO[NTERM-NUM]. */
2011 static const yytype_int16 yypgoto[] =
2012 {
2013  -808, -808, -808, -363, -808, 27, -808, -550, -21, -808,
2014  518, -808, 15, -808, -301, -51, -86, 41, -808, -268,
2015  -808, 413, -7, 888, -153, -4, -73, -808, -416, 7,
2016  1571, -315, 889, -53, -808, -5, -808, -808, 98, -808,
2017  870, -808, 735, -808, -44, 275, -340, 87, -11, -808,
2018  -386, -188, 4, -311, -20, -808, -808, -808, -808, -808,
2019  -808, -808, -808, -808, -808, -808, -808, -808, -808, -808,
2020  -808, -808, -808, 64, -808, -808, -808, -808, -808, -808,
2021  -808, -808, -808, -808, 154, -347, -526, -34, -645, -808,
2022  -785, -779, 221, 309, 374, -808, -446, -808, -665, -808,
2023  -18, -808, -808, -808, -808, -808, -808, 248, -808, -808,
2024  -808, -808, -808, -808, -808, -93, -808, -808, -535, -808,
2025  -6, -808, -808, -808, -808, -808, -808, 918, -808, -808,
2026  -808, -808, 712, -808, -808, -808, -808, -808, -808, -808,
2027  963, -808, -142, -808, -808, -808, -808, -808, 10, -808,
2028  14, -808, 1081, 1361, 928, 1531, 1552, -808, -808, 89,
2029  -464, -372, -415, -783, -518, -723, 234, 242, 133, -808,
2030  -808, -808, 289, -708, -807, 128, 255, -808, -638, -808,
2031  228, -622, -808, -808, -808, 69, -383, -808, -348, -808,
2032  639, -26, 0, 48, -598, -208, 21, -14, -2
2033 };
2034 
2035 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2036  positive, shift that token. If negative, reduce the rule which
2037  number is the opposite. If YYTABLE_NINF, syntax error. */
2038 #define YYTABLE_NINF -621
2039 static const yytype_int16 yytable[] =
2040 {
2041  116, 359, 283, 400, 362, 558, 325, 566, 659, 208,
2042  208, 229, 572, 208, 560, 526, 757, 69, 198, 69,
2043  214, 214, 199, 234, 214, 521, 610, 232, 251, 235,
2044  316, 117, 421, 273, 610, 357, 357, 617, 198, 357,
2045  724, 394, 199, 767, 741, 256, 786, 810, 723, 263,
2046  267, 600, 638, 306, 459, 261, 882, 660, 461, 273,
2047  272, 586, 689, 317, 363, 691, 84, 558, 84, 566,
2048  841, 273, 273, 273, 846, 617, 614, 627, -102, 889,
2049  215, 215, -103, 569, 215, 220, 220, -106, 305, 220,
2050  941, 314, -106, 720, 938, 630, 966, 447, 312, 313,
2051  649, 878, 695, 212, 222, 299, 196, 223, 327, -519,
2052  650, 305, 877, 84, 302, -74, 303, 274, 397, 488,
2053  262, 266, 569, 630, 972, -110, 196, 684, 215, 494,
2054  641, 852, 659, 776, 3, -102, -88, 896, 653, 654,
2055  -511, 884, 857, 274, 479, 840, 482, 576, 486, 890,
2056  215, 215, 486, 196, 215, 368, 379, 379, 231, -105,
2057  992, -108, 655, 350, 351, 352, 398, 314, 489, 685,
2058  517, -107, -109, -105, -107, 882, 297, 298, 495, 431,
2059  -104, 433, 251, 879, 901, 902, 856, -93, -511, -104,
2060  237, -94, 196, 659, 861, 315, 247, 966, 466, 316,
2061  587, -97, 231, -598, 850, 302, 941, 303, 453, 302,
2062  -598, 303, 414, -106, 1025, -106, 441, 208, 414, 208,
2063  208, 500, 501, 502, 503, 430, 449, 882, 214, 251,
2064  214, 972, -96, 630, -101, 610, 610, 889, 450, 617,
2065  729, 421, 777, 289, 815, 630, 256, 1046, 302, -98,
2066  303, 273, 740, 776, 874, 291, 357, 357, 357, 357,
2067  962, 505, 506, 445, 949, 967, 293, 84, 462, 763,
2068  -99, 315, -599, 305, 573, 574, 739, 227, 432, 659,
2069  819, -100, -96, -98, 985, -105, 882, -105, 215, -95,
2070  215, 215, -519, 220, 215, 220, 215, -107, 788, -107,
2071  791, 84, 251, 451, 273, 473, 452, 998, -510, 357,
2072  357, 422, 84, 425, 84, -104, 588, -104, -102, 256,
2073  -96, 69, 455, 215, 583, 515, 504, 930, 860, 456,
2074  515, 519, -339, 499, -512, 274, 575, -98, 302, -93,
2075  303, -96, 1008, 678, -96, 473, 295, 208, -96, 481,
2076  678, 474, 430, 475, -595, 776, -510, 776, -98, 312,
2077  313, -98, 513, 353, -513, -98, 1033, 522, -515, 654,
2078  84, 215, 215, 215, 215, 84, 215, 215, 851, -339,
2079  -339, 989, -512, 305, 677, 215, -514, 84, 274, 415,
2080  215, 474, 655, 475, 986, 466, 521, 464, 465, 590,
2081  319, -516, 770, 837, 645, 646, 647, 648, 473, 208,
2082  354, 355, -513, -505, 430, 74, -515, 74, 215, -596,
2083  84, 776, 994, 754, 215, 215, 414, 414, 765, 74,
2084  74, -520, 624, 74, -514, 826, 416, 417, 116, 215,
2085  1024, 1053, 834, 601, 603, 466, 442, 198, 273, -516,
2086  419, 199, 458, 564, 474, 69, 475, -103, -595, 456,
2087  -505, -505, 74, 208, -595, 321, 215, 215, 430, -505,
2088  618, 322, 659, 776, 620, 776, -110, 74, -508, 623,
2089  215, 611, 610, 327, 873, 617, 770, 680, 645, 646,
2090  647, 648, 326, 416, 443, 633, -520, 564, 273, 74,
2091  74, 444, -508, 74, 84, 688, 688, 758, 776, 688,
2092  56, 946, 948, 702, 84, 564, 951, -505, 953, 954,
2093  403, 709, -103, -596, 636, -508, -508, -109, 402, -596,
2094  404, 759, 274, -105, 215, 196, 348, 349, 350, 351,
2095  352, 564, 699, -94, 742, 444, -110, 703, 800, 717,
2096  -508, 719, 434, 867, -294, 710, 747, -107, 650, 469,
2097  705, 435, 436, 230, 766, 694, 716, -101, 993, 564,
2098  980, -109, 754, 208, 761, 406, 982, 1014, 430, -104,
2099  725, 410, 274, 473, 231, 208, 653, 654, 411, 749,
2100  430, 230, -100, -433, 722, 722, 231, 412, 750, -288,
2101  752, -294, -294, -288, 418, -599, 470, 471, 734, 414,
2102  655, 843, 840, 420, 705, 198, 74, 273, 438, 199,
2103  584, 440, 707, 466, 585, 1027, 1029, 1030, 1031, 474,
2104  116, 475, 476, 224, 84, 227, 84, 74, 327, 74,
2105  74, 705, 448, 74, 215, 74, 853, 69, -105, 855,
2106  74, -73, -433, 454, 460, 864, 215, -517, 84, 215,
2107  827, 74, 473, 74, 783, 813, 783, 747, 814, -96,
2108  816, 630, 74, 463, 468, 1054, 273, 496, 1039, 564,
2109  497, 357, 509, 764, 357, 812, 483, 487, 688, 215,
2110  760, 564, 490, 863, 493, 520, 84, -433, -518, -433,
2111  -433, 274, 498, 196, -517, -517, 576, 578, 474, 750,
2112  475, 478, 839, 842, 621, 842, 582, 842, 515, 74,
2113  74, 74, 74, 74, 74, 74, 74, -602, 327, 705,
2114  473, 726, 619, 622, 74, 628, 74, 632, 522, 74,
2115  705, 822, 824, 340, 341, -518, -518, 712, 830, 832,
2116  84, 679, -88, 84, 854, 84, 637, 923, 414, -284,
2117  274, 215, -268, 681, 215, 215, 862, 74, 693, 74,
2118  579, 215, 215, 74, 74, 708, 474, 812, 475, 480,
2119  273, 348, 349, 350, 351, 352, -602, 264, 74, 696,
2120  859, 697, 357, 591, 910, 327, 215, -424, 714, 215,
2121  84, -107, 812, 762, 783, 783, -284, -284, 84, 869,
2122  340, 341, 718, 473, 779, 74, 74, 580, 581, 919,
2123  473, 781, -98, 876, 768, 784, 926, 927, 785, 74,
2124  929, -602, 787, -602, -602, 789, 918, -598, 790, 922,
2125  592, 593, 840, 792, 196, 345, 346, 347, 348, 349,
2126  350, 351, 352, 74, -295, -269, 821, 943, 944, 474,
2127  828, 475, 484, 74, 895, 868, 474, 870, 475, 491,
2128  914, 955, 875, 273, 722, 893, 932, 958, 849, 84,
2129  898, 1017, 897, 74, 783, 900, 210, 210, 794, 795,
2130  210, 796, 903, 215, 905, 858, 273, 44, 45, 981,
2131  907, -295, -295, 908, 84, 829, 909, 215, 934, 911,
2132  -270, 84, 84, 811, 916, 84, 244, 246, 920, 804,
2133  937, 210, 210, 939, 592, 593, 959, 842, 1018, 1019,
2134  942, -104, 945, 957, 300, 301, 405, 947, 950, 407,
2135  408, 409, 84, 84, 770, 952, 645, 646, 647, 648,
2136  649, 973, -95, -271, 995, 991, 84, 956, 1001, 1020,
2137  650, 1021, 783, 996, 1004, 1006, 1016, 1022, 634, 1009,
2138  1015, 1011, 1026, 1028, 807, 327, -598, -599, 1049, 366,
2139  976, 651, 383, 74, 84, 74, 835, 1043, 653, 654,
2140  340, 341, 872, 74, 801, 84, 1036, 865, 924, 770,
2141  925, 645, 646, 647, 648, 74, 492, 74, 74, 887,
2142  933, 208, 655, 887, 1042, 935, 430, 401, 716, 842,
2143  287, 888, 395, 885, 891, 990, 961, 347, 348, 349,
2144  350, 351, 352, 963, 883, 597, 771, 0, 74, 705,
2145  0, 0, 772, 0, 84, 74, 84, 307, 308, 309,
2146  310, 311, 84, 0, 84, 770, 514, 645, 646, 647,
2147  648, 525, 0, 770, 0, 645, 646, 647, 648, 0,
2148  886, 210, 0, 0, 210, 210, 210, 300, 0, 0,
2149  983, 984, 215, 110, 969, 110, 645, 646, 647, 648,
2150  0, 0, 771, 0, 210, 0, 210, 210, 940, 74,
2151  771, 0, 74, 0, 74, 0, 0, 0, 0, 0,
2152  74, 0, 0, 74, 74, 0, 0, 564, 0, 0,
2153  74, 74, 0, 0, 0, 0, 811, 0, 887, 0,
2154  110, 811, 0, 811, 275, 0, 0, 965, 0, 968,
2155  0, 0, 0, 1023, 0, 74, 607, 609, 74, 74,
2156  0, 0, 0, 0, 0, 264, 0, 74, 0, 0,
2157  275, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2158  0, 0, 370, 380, 380, 380, 1044, 0, 1045, 997,
2159  0, 999, 0, 904, 906, 0, 1000, 807, 0, 964,
2160  609, 210, 807, 264, 807, 0, 524, 527, 528, 529,
2161  530, 531, 532, 533, 534, 535, 536, 537, 538, 539,
2162  540, 541, 542, 543, 544, 545, 546, 547, 548, 549,
2163  550, 551, 552, 0, 210, 0, 0, 0, 74, 0,
2164  0, 0, 811, 0, 811, 0, 0, 811, 1032, 811,
2165  1034, 0, 74, 0, 0, 1035, 0, 692, 0, 0,
2166  0, 0, 0, 74, 0, 0, 74, 0, 0, 0,
2167  74, 74, 1047, 0, 74, 0, 0, 0, 0, 0,
2168  0, 0, 602, 604, 0, 0, 0, 811, 0, 0,
2169  606, 210, 210, 1055, 110, 0, 210, 0, 602, 604,
2170  210, 74, 74, 807, 0, 807, 0, 0, 807, 0,
2171  807, 0, 0, 0, 0, 74, 0, 0, 0, 626,
2172  0, 525, 0, 0, 631, 0, 0, 0, 110, 0,
2173  0, 0, 0, 0, 0, 210, 0, 0, 210, 110,
2174  0, 110, 0, 74, 0, 1005, 1007, 0, 807, 1010,
2175  210, 1012, 1013, 753, 74, 0, 0, 0, 0, 0,
2176  0, 0, 275, 0, 0, 0, 609, 264, 0, 0,
2177  0, 0, 0, 111, 0, 111, 682, 683, 0, 0,
2178  0, 0, 0, 0, 799, 0, 645, 646, 647, 648,
2179  800, 0, 210, 0, 769, 0, 0, 110, 0, 0,
2180  650, 0, 110, 74, 0, 74, 0, 0, 0, 0,
2181  0, 74, 0, 74, 110, 275, 1048, 1050, 1051, 1052,
2182  111, 651, 0, 0, 276, 0, 0, 652, 653, 654,
2183  770, 0, 645, 646, 647, 648, 800, 0, 818, 1056,
2184  0, 74, 0, 0, 0, 0, 650, 110, 0, 0,
2185  276, 0, 655, 0, 0, 656, 210, 0, 0, 836,
2186  210, 0, 371, 381, 381, 381, 0, 651, 0, 0,
2187  0, 0, 210, 231, 653, 654, 0, 0, 0, 644,
2188  0, 645, 646, 647, 648, 649, 0, 0, 210, 0,
2189  0, 0, 0, 0, 0, 650, 0, 0, 655, 0,
2190  0, 210, 210, 0, 0, 0, 0, 0, 0, 0,
2191  0, 0, 0, 871, 0, 0, 651, 0, 0, 0,
2192  0, 0, 652, 653, 654, 0, 0, 0, 0, 210,
2193  0, 110, 0, 0, 0, 0, 0, 0, 0, 0,
2194  0, 110, 0, 113, 0, 113, 0, 655, 0, 0,
2195  656, 0, 0, 0, 0, 0, 0, 0, 0, 275,
2196  0, 0, 912, 657, 114, 0, 114, 0, 0, 0,
2197  0, 0, 0, 210, 111, 0, 0, 606, 820, 0,
2198  823, 825, 0, 81, 0, 81, 0, 831, 833, 0,
2199  113, 0, 0, 0, 210, 928, 0, 0, 0, 0,
2200  644, 0, 645, 646, 647, 648, 649, 0, 111, 275,
2201  0, 114, 0, 264, 0, 277, 650, 0, 0, 111,
2202  0, 111, 0, 0, 0, 0, 0, 0, 0, 0,
2203  81, 866, 0, 0, 0, 823, 825, 651, 831, 833,
2204  0, 277, 276, 652, 653, 654, 0, 0, 210, 0,
2205  0, 0, 0, 372, 382, 382, 0, 0, 0, 0,
2206  0, 110, 0, 110, 0, 0, 0, 0, 655, 0,
2207  0, 656, 367, 0, 0, 0, 0, 111, 0, 0,
2208  0, 0, 111, 0, 743, 110, 0, 0, 0, 0,
2209  0, 0, 0, 0, 111, 276, 0, 210, 0, 0,
2210  0, 913, 0, 0, 0, 0, 0, 0, 0, 915,
2211  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2212  0, 0, 0, 110, 0, 0, 0, 111, 275, 0,
2213  210, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2214  0, 0, 0, 0, 113, 0, 0, 915, 210, 0,
2215  0, 0, 327, 328, 329, 330, 331, 332, 333, 334,
2216  335, 336, 337, 338, 339, 114, 0, 340, 341, 0,
2217  0, 0, 0, 0, 0, 0, 0, 110, 113, 0,
2218  110, 0, 110, 0, 81, 0, 0, 275, 0, 113,
2219  0, 113, 0, 0, 0, 0, 0, 0, 342, 114,
2220  343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
2221  114, 111, 114, 0, 0, 0, 0, 0, 81, 0,
2222  0, 111, 0, 0, 0, 231, 0, 110, 0, 81,
2223  0, 81, 0, 277, 0, 110, 0, 0, 0, 276,
2224  0, 0, 0, 0, 0, 0, 0, 113, 0, 0,
2225  0, 644, 113, 645, 646, 647, 648, 649, 0, 0,
2226  0, 0, 0, 0, 113, 0, 0, 650, 114, 0,
2227  0, 0, 0, 114, 0, 0, 0, 0, 0, 0,
2228  0, 0, 0, 0, 0, 114, 277, 81, 651, 276,
2229  0, 380, 81, 0, 652, 653, 654, 113, 210, 0,
2230  0, 0, 0, 0, 81, 0, 110, 523, 0, 0,
2231  0, 0, 0, 0, 0, 0, 0, 0, 114, 655,
2232  698, 0, 656, 0, 0, 0, 0, 0, 0, 0,
2233  0, 110, 0, 0, 0, 0, 0, 81, 110, 110,
2234  0, 111, 110, 111, 327, 328, 329, 330, 331, 332,
2235  333, 334, 335, 336, 337, 338, 339, 0, 0, 340,
2236  341, 0, 0, 0, 0, 111, 0, 0, 0, 110,
2237  110, 0, 799, 0, 645, 646, 647, 648, 800, 0,
2238  0, 113, 0, 110, 380, 0, 0, 0, 650, 0,
2239  342, 113, 343, 344, 345, 346, 347, 348, 349, 350,
2240  351, 352, 114, 111, 0, 0, 0, 977, 276, 651,
2241  -245, 110, 114, 0, 0, 652, 653, 654, 0, 0,
2242  0, 81, 110, 0, 0, 0, 0, 0, 0, 0,
2243  277, 81, 0, 0, 0, 0, 0, 0, 0, 0,
2244  655, 0, 0, 656, 0, 0, 0, 0, 0, 0,
2245  0, 0, 0, 0, 0, 0, 0, 111, 0, 0,
2246  111, 0, 111, 0, 0, 0, 0, 276, 0, 0,
2247  0, 110, 0, 110, 553, 554, 0, 0, 555, 110,
2248  277, 110, 0, 0, 0, 0, 0, 0, 162, 163,
2249  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
2250  172, 0, 0, 173, 174, 175, 176, 111, 0, 0,
2251  0, 113, 0, 113, 0, 111, 0, 177, 178, 0,
2252  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2253  0, 0, 114, 0, 114, 113, 0, 0, 179, 180,
2254  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
2255  190, 81, 0, 81, 0, 0, 114, 191, 0, 0,
2256  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2257  0, 381, 0, 113, 0, 81, 0, 0, 0, 0,
2258  0, 0, 0, 0, 0, 0, 111, 0, 0, 0,
2259  0, 0, 0, 0, 114, 0, 0, 0, 0, 277,
2260  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2261  0, 111, 0, 81, 0, 0, 0, 0, 111, 111,
2262  0, 0, 111, 0, 0, 0, 0, 113, 0, 0,
2263  113, 0, 113, 0, 0, 0, 0, 0, 798, 0,
2264  0, 0, 0, 0, 0, 0, 0, 0, 114, 111,
2265  111, 114, 0, 114, 0, 0, 0, 0, 277, 0,
2266  0, 0, 0, 111, 381, 0, 0, 81, 0, 0,
2267  81, 0, 81, 0, 0, 0, 0, 113, 523, 0,
2268  0, 0, 0, 0, 0, 113, 0, 978, 0, 0,
2269  0, 111, 0, 0, 0, 0, 0, 0, 114, 0,
2270  0, 0, 111, 0, 0, 0, 114, 0, 0, 0,
2271  0, 0, 0, 0, 0, 0, 0, 81, 327, -621,
2272  -621, -621, -621, 332, 333, 81, 0, -621, -621, 0,
2273  0, 0, 0, 340, 341, 0, 0, 0, 0, 0,
2274  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2275  0, 111, 0, 111, 0, 0, 113, 0, 0, 111,
2276  0, 111, 382, 0, 0, 0, 343, 344, 345, 346,
2277  347, 348, 349, 350, 351, 352, 0, 114, 0, 0,
2278  0, 113, 0, 0, 0, 0, 0, 0, 113, 113,
2279  0, 0, 113, 0, 0, 0, 81, 0, 0, 0,
2280  0, 0, 114, 0, 0, 0, 0, 0, 0, 114,
2281  114, 0, 0, 114, 0, 0, 0, 0, 0, 113,
2282  113, 81, 0, 0, 0, 0, 0, 0, 81, 81,
2283  0, 0, 81, 113, 0, 0, 0, 0, 0, 0,
2284  114, 114, 0, 0, 0, 0, 0, 0, 0, 0,
2285  0, 0, 0, 0, 114, 382, 0, 0, 0, 81,
2286  81, 113, 0, 0, 0, 0, 0, 0, 0, 0,
2287  0, 0, 113, 81, 0, 0, 0, 0, 979, 0,
2288  0, 0, 114, 0, 0, 0, 0, 0, 0, 0,
2289  0, 0, 0, 114, 0, 0, 0, 975, 0, 0,
2290  0, 81, 0, 0, 0, 0, 0, 0, 0, 0,
2291  0, 0, 81, 0, 0, 0, 0, 0, 0, 0,
2292  0, 113, 0, 113, 0, 0, 0, 0, 0, 113,
2293  0, 113, 0, 0, 0, 0, 0, 0, 0, 0,
2294  0, 0, 114, 0, 114, 0, 0, 0, 0, 0,
2295  114, 0, 114, 0, 0, 0, 0, 0, 0, 0,
2296  0, 81, 0, 81, 0, 0, 0, 0, 0, 81,
2297  0, 81, -620, 4, 0, 5, 6, 7, 8, 9,
2298  0, 0, 0, 10, 11, 0, 0, 0, 12, 0,
2299  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2300  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2301  0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
2302  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2303  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2304  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2305  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2306  0, 49, 50, 0, 51, 52, 0, 53, 0, 0,
2307  54, 55, 56, 57, 58, 59, 60, 61, 62, -602,
2308  0, 0, 0, 0, 0, 0, 0, -602, -602, -602,
2309  0, 0, -602, -602, -602, 0, -602, 0, 63, 64,
2310  65, 0, 751, 0, 0, -602, -602, -602, -602, 0,
2311  0, -620, 0, -620, 0, 0, -602, -602, 0, -602,
2312  -602, -602, -602, -602, 0, 0, 327, 328, 329, 330,
2313  331, 332, 333, 334, 335, 336, 337, 338, 339, 0,
2314  0, 340, 341, 0, 0, 0, 0, -602, -602, -602,
2315  -602, -602, -602, -602, -602, -602, -602, -602, -602, -602,
2316  0, 0, -602, -602, -602, 0, 755, -602, 0, 0,
2317  0, 0, 342, -602, 343, 344, 345, 346, 347, 348,
2318  349, 350, 351, 352, 0, 0, 0, -602, 0, 0,
2319  -602, 0, -106, -602, -602, -602, -602, -602, -602, -602,
2320  -602, -602, -602, -602, -602, 0, 0, 0, 0, -602,
2321  -602, -602, -602, -602, -505, 0, -602, -602, -602, 0,
2322  -602, 0, -505, -505, -505, 0, 0, -505, -505, -505,
2323  0, -505, 0, 0, 0, 0, 0, 698, 0, -505,
2324  0, -505, -505, -505, 0, 0, 0, 0, 0, 0,
2325  0, -505, -505, 0, -505, -505, -505, -505, -505, 0,
2326  0, 327, 328, 329, 330, 331, 332, 333, 334, 335,
2327  336, 337, 338, 339, 0, 0, 340, 341, 0, 0,
2328  0, 0, -505, -505, -505, -505, -505, -505, -505, -505,
2329  -505, -505, -505, -505, -505, 0, 0, -505, -505, -505,
2330  0, -505, -505, 0, 0, 0, 0, 342, -505, 343,
2331  344, 345, 346, 347, 348, 349, 350, 351, 352, 0,
2332  0, 0, -505, 0, 0, -505, 0, -505, -505, -505,
2333  -505, -505, -505, -505, -505, -505, -505, -505, -505, -505,
2334  0, 0, 0, 0, 0, -505, -505, -505, -505, -508,
2335  0, -505, -505, -505, 0, -505, 0, -508, -508, -508,
2336  0, 0, -508, -508, -508, 0, -508, 0, 0, 0,
2337  0, 0, 0, 0, -508, 0, -508, -508, -508, 0,
2338  0, 0, 0, 0, 0, 0, -508, -508, 0, -508,
2339  -508, -508, -508, -508, 0, 0, 327, 328, 329, 330,
2340  331, 332, 333, 334, 335, 336, 337, 338, 339, 0,
2341  0, 340, 341, 0, 0, 0, 0, -508, -508, -508,
2342  -508, -508, -508, -508, -508, -508, -508, -508, -508, -508,
2343  0, 0, -508, -508, -508, 0, -508, -508, 0, 0,
2344  0, 0, 342, -508, 343, 344, 345, 346, 347, 348,
2345  349, 350, 351, 352, 0, 0, 0, -508, 0, 0,
2346  -508, 0, -508, -508, -508, -508, -508, -508, -508, -508,
2347  -508, -508, -508, -508, -508, 0, 0, 0, 0, 0,
2348  -508, -508, -508, -508, -603, 0, -508, -508, -508, 0,
2349  -508, 0, -603, -603, -603, 0, 0, -603, -603, -603,
2350  0, -603, 0, 0, 0, 0, 0, 0, 0, 0,
2351  -603, -603, -603, -603, 0, 0, 0, 0, 0, 0,
2352  0, -603, -603, 0, -603, -603, -603, -603, -603, 0,
2353  0, 327, 328, 329, 330, 331, 332, 333, 334, 335,
2354  336, 337, -621, -621, 0, 0, 340, 341, 0, 0,
2355  0, 0, -603, -603, -603, -603, -603, -603, -603, -603,
2356  -603, -603, -603, -603, -603, 0, 0, -603, -603, -603,
2357  0, 0, -603, 0, 0, 0, 0, 0, -603, 343,
2358  344, 345, 346, 347, 348, 349, 350, 351, 352, 0,
2359  0, 0, -603, 0, 0, -603, 0, 0, -603, -603,
2360  -603, -603, -603, -603, -603, -603, -603, -603, -603, -603,
2361  0, 0, 0, 0, -603, -603, -603, -603, -603, -604,
2362  0, -603, -603, -603, 0, -603, 0, -604, -604, -604,
2363  0, 0, -604, -604, -604, 0, -604, 0, 0, 0,
2364  0, 0, 0, 0, 0, -604, -604, -604, -604, 0,
2365  0, 0, 0, 0, 0, 0, -604, -604, 0, -604,
2366  -604, -604, -604, -604, 0, 0, 327, 328, 329, 330,
2367  331, 332, 333, 334, 0, 336, 337, 0, 0, 0,
2368  0, 340, 341, 0, 0, 0, 0, -604, -604, -604,
2369  -604, -604, -604, -604, -604, -604, -604, -604, -604, -604,
2370  0, 0, -604, -604, -604, 0, 0, -604, 0, 0,
2371  0, 0, 0, -604, 343, 344, 345, 346, 347, 348,
2372  349, 350, 351, 352, 0, 0, 0, -604, 0, 0,
2373  -604, 0, 0, -604, -604, -604, -604, -604, -604, -604,
2374  -604, -604, -604, -604, -604, 0, 0, 0, 0, -604,
2375  -604, -604, -604, -604, -294, 0, -604, -604, -604, 0,
2376  -604, 0, -294, -294, -294, 0, 0, -294, -294, -294,
2377  0, -294, 0, 0, 0, 0, 0, 0, 0, 0,
2378  0, -294, -294, -294, 0, 0, 0, 0, 0, 0,
2379  0, -294, -294, 0, -294, -294, -294, -294, -294, 0,
2380  0, 327, 328, 329, 330, 331, 332, 333, 0, 0,
2381  336, 337, 0, 0, 0, 0, 340, 341, 0, 0,
2382  0, 0, -294, -294, -294, -294, -294, -294, -294, -294,
2383  -294, -294, -294, -294, -294, 0, 0, -294, -294, -294,
2384  0, 756, -294, 0, 0, 0, 0, 0, -294, 343,
2385  344, 345, 346, 347, 348, 349, 350, 351, 352, 0,
2386  0, 0, -294, 0, 0, -294, 0, -108, -294, -294,
2387  -294, -294, -294, -294, -294, -294, -294, -294, -294, -294,
2388  0, 0, 0, 0, 0, -294, -294, -294, -294, -432,
2389  0, -294, -294, -294, 0, -294, 0, -432, -432, -432,
2390  0, 0, -432, -432, -432, 0, -432, 0, 0, 0,
2391  0, 0, 0, 0, 0, -432, -432, -432, 0, 0,
2392  0, 0, 0, 0, 0, 0, -432, -432, 0, -432,
2393  -432, -432, -432, -432, 0, 0, 0, 0, 0, 0,
2394  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2395  0, 0, 0, 0, 0, 0, 0, -432, -432, -432,
2396  -432, -432, -432, -432, -432, -432, -432, -432, -432, -432,
2397  0, 0, -432, -432, -432, 0, 0, -432, 0, 0,
2398  0, 0, 0, -432, 0, 0, 0, 0, 0, 0,
2399  0, 0, 0, 0, 0, 0, 0, -432, 0, 0,
2400  0, 0, 0, -432, 0, -432, -432, -432, -432, -432,
2401  -432, -432, -432, -432, -432, 0, 0, 0, 0, -432,
2402  -432, -432, -432, -432, -285, 227, -432, -432, -432, 0,
2403  -432, 0, -285, -285, -285, 0, 0, -285, -285, -285,
2404  0, -285, 0, 0, 0, 0, 0, 0, 0, 0,
2405  0, -285, -285, -285, 0, 0, 0, 0, 0, 0,
2406  0, -285, -285, 0, -285, -285, -285, -285, -285, 0,
2407  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2408  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2409  0, 0, -285, -285, -285, -285, -285, -285, -285, -285,
2410  -285, -285, -285, -285, -285, 0, 0, -285, -285, -285,
2411  0, 0, -285, 0, 0, 0, 0, 0, -285, 0,
2412  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2413  0, 0, -285, 0, 0, -285, 0, 0, -285, -285,
2414  -285, -285, -285, -285, -285, -285, -285, -285, -285, -285,
2415  0, 0, 0, 0, 0, -285, -285, -285, -285, -422,
2416  0, -285, -285, -285, 0, -285, 0, -422, -422, -422,
2417  0, 0, -422, -422, -422, 0, -422, 0, 0, 0,
2418  0, 0, 0, 0, 0, -422, -422, -422, 0, 0,
2419  0, 0, 0, 0, 0, 0, -422, -422, 0, -422,
2420  -422, -422, -422, -422, 0, 0, 0, 0, 0, 0,
2421  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2422  0, 0, 0, 0, 0, 0, 0, -422, -422, -422,
2423  -422, -422, -422, -422, -422, -422, -422, -422, -422, -422,
2424  0, 0, -422, -422, -422, 0, 0, -422, 0, 0,
2425  0, 0, 0, -422, 0, 0, 0, 0, 0, 0,
2426  0, 0, 0, 0, 0, 0, 0, -422, 0, 0,
2427  0, 0, 0, -422, 0, -422, -422, -422, -422, -422,
2428  -422, -422, -422, -422, -422, 0, 0, 0, 0, -422,
2429  -422, -422, -422, -422, -301, -422, -422, -422, -422, 0,
2430  -422, 0, -301, -301, -301, 0, 0, -301, -301, -301,
2431  0, -301, 0, 0, 0, 0, 0, 0, 0, 0,
2432  0, -301, -301, 0, 0, 0, 0, 0, 0, 0,
2433  0, -301, -301, 0, -301, -301, -301, -301, -301, 0,
2434  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2435  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2436  0, 0, -301, -301, -301, -301, -301, -301, -301, -301,
2437  -301, -301, -301, -301, -301, 0, 0, -301, -301, -301,
2438  0, 0, -301, 0, 0, 0, 0, 0, -301, 0,
2439  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2440  0, 0, -301, 0, 0, 0, 0, 0, -301, 0,
2441  -301, -301, -301, -301, -301, -301, -301, -301, -301, -301,
2442  0, 0, 0, 0, 0, -301, -301, -301, -301, -602,
2443  224, -301, -301, -301, 0, -301, 0, -602, -602, -602,
2444  0, 0, 0, -602, -602, 0, -602, 0, 0, 0,
2445  0, 0, 0, 0, 0, -602, 0, 0, 0, 0,
2446  0, 0, 0, 0, 0, 0, -602, -602, 0, -602,
2447  -602, -602, -602, -602, 0, 0, 0, 0, 0, 0,
2448  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2449  0, 0, 0, 0, 0, 0, 0, -602, -602, -602,
2450  -602, -602, -602, -602, -602, -602, -602, -602, -602, -602,
2451  0, 0, -602, -602, -602, 0, 700, 0, 0, 0,
2452  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2453  0, 0, 0, 0, 0, 0, 0, -602, 0, 0,
2454  0, 0, -106, -602, 0, -602, -602, -602, -602, -602,
2455  -602, -602, -602, -602, -602, 0, 0, 0, 0, -602,
2456  -602, -602, -602, -97, -294, 0, -602, 0, -602, 0,
2457  -602, 0, -294, -294, -294, 0, 0, 0, -294, -294,
2458  0, -294, 0, -620, 0, 0, 0, 0, 0, 0,
2459  0, -620, -620, -620, 0, 0, -620, -620, -620, 0,
2460  -620, -294, -294, 0, -294, -294, -294, -294, -294, -620,
2461  -620, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2462  -620, -620, 0, -620, -620, -620, -620, -620, 0, 0,
2463  0, 0, -294, -294, -294, -294, -294, -294, -294, -294,
2464  -294, -294, -294, -294, -294, 0, 0, -294, -294, -294,
2465  0, 701, 0, 0, 0, 0, 0, 0, 0, 0,
2466  0, 0, 0, 0, 0, 0, 0, 0, -620, 0,
2467  0, 0, -294, 0, 0, 0, 0, -108, -294, 0,
2468  -294, -294, -294, -294, -294, -294, -294, -294, -294, -294,
2469  0, -620, 0, 0, 0, -294, -294, -294, -99, 0,
2470  0, -294, 0, -294, 0, -294, 0, 0, 0, 0,
2471  0, 0, 0, -620, -620, 0, -620, 0, 0, 227,
2472  -620, 0, -620, 248, -620, 5, 6, 7, 8, 9,
2473  -620, -620, -620, 10, 11, 0, 0, -620, 12, 0,
2474  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2475  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2476  0, 27, 0, 0, 0, 0, 0, 28, 29, 249,
2477  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2478  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2479  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2480  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2481  0, 49, 50, 0, 51, 52, 0, 53, 0, 0,
2482  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2483  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2484  0, 0, 0, 0, 0, 0, 0, 0, 63, 64,
2485  65, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2486  0, -620, 248, -620, 5, 6, 7, 8, 9, 0,
2487  0, -620, 10, 11, 0, -620, -620, 12, 0, 13,
2488  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2489  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2490  27, 0, 0, 0, 0, 0, 28, 29, 249, 31,
2491  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2492  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2493  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2494  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2495  49, 50, 0, 51, 52, 0, 53, 0, 0, 54,
2496  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2497  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2498  0, 0, 0, 0, 0, 0, 0, 63, 64, 65,
2499  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2500  -620, 248, -620, 5, 6, 7, 8, 9, 0, 0,
2501  -620, 10, 11, 0, 0, -620, 12, -620, 13, 14,
2502  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2503  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2504  0, 0, 0, 0, 0, 28, 29, 249, 31, 32,
2505  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2506  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2507  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2508  0, 0, 0, 0, 0, 0, 48, 0, 0, 49,
2509  50, 0, 51, 52, 0, 53, 0, 0, 54, 55,
2510  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2511  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2512  0, 0, 0, 0, 0, 0, 63, 64, 65, 0,
2513  0, 0, 0, 0, 0, 0, 0, 0, 0, -620,
2514  248, -620, 5, 6, 7, 8, 9, 0, 0, -620,
2515  10, 11, 0, 0, -620, 12, 0, 13, 14, 15,
2516  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2517  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2518  0, 0, 0, 0, 28, 29, 249, 31, 32, 33,
2519  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2520  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2521  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2522  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2523  0, 51, 52, 0, 53, 0, 0, 54, 55, 56,
2524  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2525  0, 0, 0, 248, 0, 5, 6, 7, 8, 9,
2526  0, -620, -620, 10, 11, 63, 64, 65, 12, 0,
2527  13, 14, 15, 16, 17, 18, 19, 0, -620, 0,
2528  -620, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2529  0, 27, 0, 0, 0, 0, 0, 28, 29, 249,
2530  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2531  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2532  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2533  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2534  0, 49, 50, 0, 51, 52, 0, 53, 0, 0,
2535  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2536  0, 0, 0, 0, 0, 0, 248, 0, 5, 6,
2537  7, 8, 9, 0, 0, 0, 10, 11, 63, 64,
2538  65, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2539  0, -620, 0, -620, 0, 20, 21, 22, 23, 24,
2540  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2541  28, 29, 249, 31, 32, 33, 34, 35, 36, 37,
2542  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2543  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2544  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2545  0, 48, 0, 0, 250, 50, 0, 51, 52, 0,
2546  53, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2547  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2548  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2549  0, 63, 64, 65, 0, 0, 0, 0, 0, 0,
2550  0, 0, -620, 0, -620, 248, -620, 5, 6, 7,
2551  8, 9, 0, 0, 0, 10, 11, 0, 0, 0,
2552  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2553  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2554  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2555  29, 249, 31, 32, 33, 34, 35, 36, 37, 38,
2556  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2557  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2558  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2559  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2560  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2561  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2562  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2563  63, 64, 65, 0, 0, 0, 0, 0, 0, 0,
2564  0, -620, 0, -620, 248, -620, 5, 6, 7, 8,
2565  9, 0, 0, 0, 10, 11, 0, 0, 0, 12,
2566  0, 13, 14, 15, 16, 17, 18, 19, 0, 0,
2567  0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
2568  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2569  249, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2570  40, 0, 41, 42, 0, 43, 44, 45, 0, 46,
2571  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2572  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
2573  0, 0, 49, 50, 0, 51, 52, 0, 53, 0,
2574  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2575  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2576  0, 0, 0, 0, 0, 0, 0, 0, 0, 63,
2577  64, 65, 0, 0, -620, 4, 0, 5, 6, 7,
2578  8, 9, -620, 0, -620, 10, 11, 0, 0, 0,
2579  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2580  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2581  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2582  29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
2583  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2584  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2585  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2586  48, 0, 0, 49, 50, 0, 51, 52, 0, 53,
2587  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2588  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2589  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2590  63, 64, 65, 0, 0, -620, 0, 0, 0, 0,
2591  0, 0, 0, -620, 248, -620, 5, 6, 7, 8,
2592  9, 0, 0, -620, 10, 11, 0, 0, 0, 12,
2593  0, 13, 14, 15, 16, 17, 18, 19, 0, 0,
2594  0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
2595  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2596  249, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2597  40, 0, 41, 42, 0, 43, 44, 45, 0, 46,
2598  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2599  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
2600  0, 0, 49, 50, 0, 51, 52, 0, 53, 0,
2601  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2602  0, 0, 0, 0, 0, 0, 0, 248, 0, 5,
2603  6, 7, 8, 9, 0, 0, 0, 10, 11, 63,
2604  64, 65, 12, 0, 13, 14, 15, 16, 17, 18,
2605  19, 0, -620, 0, -620, 0, 20, 21, 22, 23,
2606  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2607  0, 28, 29, 249, 31, 32, 33, 34, 35, 36,
2608  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2609  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2610  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2611  0, 0, 48, 0, 0, 49, 50, 0, 51, 52,
2612  0, 53, 0, 0, 54, 55, 56, 57, 58, 59,
2613  60, 61, 62, 0, -620, 0, 0, 0, 0, 0,
2614  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2615  10, 11, 63, 64, 65, 12, 0, 13, 14, 15,
2616  16, 17, 18, 19, 0, -620, 0, -620, 0, 20,
2617  21, 22, 23, 24, 25, 26, 0, 0, 200, 0,
2618  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2619  34, 35, 36, 37, 38, 39, 40, 201, 41, 42,
2620  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2621  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2622  0, 0, 0, 0, 0, 202, 0, 0, 203, 50,
2623  0, 51, 52, 0, 204, 205, 206, 54, 55, 56,
2624  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2625  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2626  0, 0, 0, 10, 11, 63, 207, 65, 12, 0,
2627  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2628  231, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2629  0, 27, 0, 0, 0, 0, 0, 0, 29, 0,
2630  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2631  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2632  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2633  0, 0, 0, 0, 0, 0, 0, 0, 202, 0,
2634  0, 203, 50, 0, 51, 52, 0, 0, 0, 0,
2635  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2636  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2637  7, 0, 9, 0, 0, 0, 10, 11, 63, 64,
2638  65, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2639  0, 302, 0, 303, 0, 20, 21, 22, 23, 24,
2640  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2641  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2642  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2643  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2644  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2645  0, 202, 0, 0, 203, 50, 0, 51, 52, 0,
2646  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2647  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2648  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2649  11, 63, 64, 65, 12, 0, 13, 14, 15, 16,
2650  17, 18, 19, 0, 0, 0, 231, 0, 20, 21,
2651  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2652  0, 0, 0, 28, 29, 30, 31, 32, 33, 34,
2653  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2654  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2655  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2656  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2657  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2658  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2659  0, 0, 0, 0, 5, 6, 7, 8, 9, 0,
2660  0, 0, 10, 11, 63, 64, 65, 12, 0, 13,
2661  14, 15, 16, 17, 18, 19, 0, 498, 0, 0,
2662  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2663  27, 0, 0, 0, 0, 0, 28, 29, 249, 31,
2664  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2665  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2666  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2667  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2668  49, 50, 0, 51, 52, 0, 53, 0, 0, 54,
2669  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2670  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2671  0, 0, 0, 0, 0, 0, 0, 63, 64, 65,
2672  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2673  498, 118, 119, 120, 121, 122, 123, 124, 125, 126,
2674  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
2675  137, 138, 139, 140, 141, 0, 0, 0, 142, 143,
2676  144, 384, 385, 386, 387, 149, 150, 151, 0, 0,
2677  0, 0, 0, 152, 153, 154, 155, 388, 389, 390,
2678  391, 160, 37, 38, 392, 40, 0, 0, 0, 0,
2679  0, 0, 0, 0, 162, 163, 164, 165, 166, 167,
2680  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
2681  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
2682  0, 0, 0, 177, 178, 0, 0, 0, 0, 0,
2683  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2684  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
2685  185, 186, 187, 188, 0, 189, 190, 0, 0, 0,
2686  0, 0, 0, 191, 393, 118, 119, 120, 121, 122,
2687  123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
2688  133, 134, 135, 136, 137, 138, 139, 140, 141, 0,
2689  0, 0, 142, 143, 144, 145, 146, 147, 148, 149,
2690  150, 151, 0, 0, 0, 0, 0, 152, 153, 154,
2691  155, 156, 157, 158, 159, 160, 280, 281, 161, 282,
2692  0, 0, 0, 0, 0, 0, 0, 0, 162, 163,
2693  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
2694  172, 0, 0, 173, 174, 175, 176, 0, 0, 0,
2695  0, 0, 0, 0, 0, 0, 0, 177, 178, 0,
2696  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2697  0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
2698  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
2699  190, 0, 0, 0, 0, 0, 0, 191, 118, 119,
2700  120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
2701  130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2702  140, 141, 0, 0, 0, 142, 143, 144, 145, 146,
2703  147, 148, 149, 150, 151, 0, 0, 0, 0, 0,
2704  152, 153, 154, 155, 156, 157, 158, 159, 160, 233,
2705  0, 161, 0, 0, 0, 0, 0, 0, 0, 0,
2706  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
2707  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
2708  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2709  177, 178, 0, 0, 55, 0, 0, 0, 0, 0,
2710  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2711  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
2712  188, 0, 189, 190, 0, 0, 0, 0, 0, 0,
2713  191, 118, 119, 120, 121, 122, 123, 124, 125, 126,
2714  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
2715  137, 138, 139, 140, 141, 0, 0, 0, 142, 143,
2716  144, 145, 146, 147, 148, 149, 150, 151, 0, 0,
2717  0, 0, 0, 152, 153, 154, 155, 156, 157, 158,
2718  159, 160, 0, 0, 161, 0, 0, 0, 0, 0,
2719  0, 0, 0, 0, 162, 163, 164, 165, 166, 167,
2720  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
2721  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
2722  0, 0, 0, 177, 178, 0, 0, 55, 0, 0,
2723  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2724  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
2725  185, 186, 187, 188, 0, 189, 190, 0, 0, 0,
2726  0, 0, 0, 191, 118, 119, 120, 121, 122, 123,
2727  124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
2728  134, 135, 136, 137, 138, 139, 140, 141, 0, 0,
2729  0, 142, 143, 144, 145, 146, 147, 148, 149, 150,
2730  151, 0, 0, 0, 0, 0, 152, 153, 154, 155,
2731  156, 157, 158, 159, 160, 0, 0, 161, 0, 0,
2732  0, 0, 0, 0, 0, 0, 0, 162, 163, 164,
2733  165, 166, 167, 168, 169, 170, 0, 0, 171, 172,
2734  0, 0, 173, 174, 175, 176, 0, 0, 0, 0,
2735  0, 0, 0, 0, 0, 0, 177, 178, 0, 0,
2736  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2737  0, 0, 0, 0, 0, 0, 0, 179, 180, 181,
2738  182, 183, 184, 185, 186, 187, 188, 0, 189, 190,
2739  5, 6, 7, 0, 9, 0, 191, 0, 10, 11,
2740  0, 0, 0, 12, 0, 13, 14, 15, 238, 239,
2741  18, 19, 0, 0, 0, 0, 0, 240, 241, 242,
2742  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
2743  0, 0, 0, 268, 0, 0, 32, 33, 34, 35,
2744  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2745  44, 45, 0, 0, 0, 0, 0, 0, 0, 0,
2746  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2747  0, 0, 0, 269, 0, 0, 203, 50, 0, 51,
2748  52, 0, 0, 0, 0, 54, 55, 56, 57, 58,
2749  59, 60, 61, 62, 0, 0, 0, 0, 0, 5,
2750  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
2751  0, 0, 12, 270, 13, 14, 15, 238, 239, 18,
2752  19, 271, 0, 0, 0, 0, 240, 241, 242, 23,
2753  24, 25, 26, 0, 0, 200, 0, 0, 0, 0,
2754  0, 0, 268, 0, 0, 32, 33, 34, 35, 36,
2755  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2756  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2757  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2758  0, 0, 269, 0, 0, 203, 50, 0, 51, 52,
2759  0, 0, 0, 0, 54, 55, 56, 57, 58, 59,
2760  60, 61, 62, 0, 0, 0, 0, 0, 5, 6,
2761  7, 8, 9, 0, 0, 0, 10, 11, 0, 0,
2762  0, 12, 270, 13, 14, 15, 16, 17, 18, 19,
2763  518, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2764  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2765  28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
2766  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2767  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2768  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2769  0, 48, 0, 0, 49, 50, 0, 51, 52, 0,
2770  53, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2771  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2772  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2773  11, 63, 64, 65, 12, 0, 13, 14, 15, 16,
2774  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2775  22, 23, 24, 25, 26, 0, 0, 200, 0, 0,
2776  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2777  35, 36, 37, 38, 39, 40, 201, 41, 42, 0,
2778  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2779  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2780  0, 0, 0, 0, 202, 0, 0, 203, 50, 0,
2781  51, 52, 0, 204, 205, 206, 54, 55, 56, 57,
2782  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2783  0, 0, 0, 0, 5, 6, 7, 8, 9, 0,
2784  0, 0, 10, 11, 63, 207, 65, 12, 0, 13,
2785  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2786  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2787  27, 0, 0, 0, 0, 0, 28, 29, 0, 31,
2788  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2789  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2790  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2791  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2792  49, 50, 0, 51, 52, 0, 53, 0, 0, 54,
2793  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2794  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2795  0, 9, 0, 0, 0, 10, 11, 63, 64, 65,
2796  12, 0, 13, 14, 15, 238, 239, 18, 19, 0,
2797  0, 0, 0, 0, 240, 241, 242, 23, 24, 25,
2798  26, 0, 0, 200, 0, 0, 0, 0, 0, 0,
2799  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2800  39, 40, 201, 41, 42, 0, 43, 44, 45, 0,
2801  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2802  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2803  202, 0, 0, 203, 50, 0, 51, 52, 0, 608,
2804  205, 206, 54, 55, 56, 57, 58, 59, 60, 61,
2805  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2806  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2807  63, 207, 65, 12, 0, 13, 14, 15, 238, 239,
2808  18, 19, 0, 0, 0, 0, 0, 240, 241, 242,
2809  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
2810  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2811  36, 37, 38, 39, 40, 201, 41, 42, 0, 43,
2812  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2813  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2814  0, 0, 0, 202, 0, 0, 203, 50, 0, 51,
2815  52, 0, 204, 205, 0, 54, 55, 56, 57, 58,
2816  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
2817  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2818  0, 10, 11, 63, 207, 65, 12, 0, 13, 14,
2819  15, 238, 239, 18, 19, 0, 0, 0, 0, 0,
2820  240, 241, 242, 23, 24, 25, 26, 0, 0, 200,
2821  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
2822  33, 34, 35, 36, 37, 38, 39, 40, 201, 41,
2823  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2824  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2825  0, 0, 0, 0, 0, 0, 202, 0, 0, 203,
2826  50, 0, 51, 52, 0, 0, 205, 206, 54, 55,
2827  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2828  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2829  9, 0, 0, 0, 10, 11, 63, 207, 65, 12,
2830  0, 13, 14, 15, 238, 239, 18, 19, 0, 0,
2831  0, 0, 0, 240, 241, 242, 23, 24, 25, 26,
2832  0, 0, 200, 0, 0, 0, 0, 0, 0, 29,
2833  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2834  40, 201, 41, 42, 0, 43, 44, 45, 0, 46,
2835  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2836  0, 0, 0, 0, 0, 0, 0, 0, 0, 202,
2837  0, 0, 203, 50, 0, 51, 52, 0, 608, 205,
2838  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2839  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2840  6, 7, 0, 9, 0, 0, 0, 10, 11, 63,
2841  207, 65, 12, 0, 13, 14, 15, 238, 239, 18,
2842  19, 0, 0, 0, 0, 0, 240, 241, 242, 23,
2843  24, 25, 26, 0, 0, 200, 0, 0, 0, 0,
2844  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2845  37, 38, 39, 40, 201, 41, 42, 0, 43, 44,
2846  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2847  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2848  0, 0, 202, 0, 0, 203, 50, 0, 51, 52,
2849  0, 0, 205, 0, 54, 55, 56, 57, 58, 59,
2850  60, 61, 62, 0, 0, 0, 0, 0, 0, 0,
2851  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2852  10, 11, 63, 207, 65, 12, 0, 13, 14, 15,
2853  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2854  21, 22, 23, 24, 25, 26, 0, 0, 200, 0,
2855  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2856  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2857  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2858  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2859  0, 0, 0, 0, 0, 202, 0, 0, 203, 50,
2860  0, 51, 52, 0, 512, 0, 0, 54, 55, 56,
2861  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2862  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2863  0, 0, 0, 10, 11, 63, 207, 65, 12, 0,
2864  13, 14, 15, 238, 239, 18, 19, 0, 0, 0,
2865  0, 0, 240, 241, 242, 23, 24, 25, 26, 0,
2866  0, 200, 0, 0, 0, 0, 0, 0, 29, 0,
2867  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2868  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2869  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2870  0, 0, 0, 0, 0, 0, 0, 0, 202, 0,
2871  0, 203, 50, 0, 51, 52, 0, 204, 0, 0,
2872  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2873  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2874  7, 0, 9, 0, 0, 0, 10, 11, 63, 207,
2875  65, 12, 0, 13, 14, 15, 238, 239, 18, 19,
2876  0, 0, 0, 0, 0, 240, 241, 242, 23, 24,
2877  25, 26, 0, 0, 200, 0, 0, 0, 0, 0,
2878  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2879  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2880  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2881  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2882  0, 202, 0, 0, 203, 50, 0, 51, 52, 0,
2883  817, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2884  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2885  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2886  11, 63, 207, 65, 12, 0, 13, 14, 15, 238,
2887  239, 18, 19, 0, 0, 0, 0, 0, 240, 241,
2888  242, 23, 24, 25, 26, 0, 0, 200, 0, 0,
2889  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2890  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2891  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2892  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2893  0, 0, 0, 0, 202, 0, 0, 203, 50, 0,
2894  51, 52, 0, 512, 0, 0, 54, 55, 56, 57,
2895  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2896  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2897  0, 0, 10, 11, 63, 207, 65, 12, 0, 13,
2898  14, 15, 238, 239, 18, 19, 0, 0, 0, 0,
2899  0, 240, 241, 242, 23, 24, 25, 26, 0, 0,
2900  200, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2901  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2902  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2903  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2904  0, 0, 0, 0, 0, 0, 0, 202, 0, 0,
2905  203, 50, 0, 51, 52, 0, 608, 0, 0, 54,
2906  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2907  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2908  0, 9, 0, 0, 0, 10, 11, 63, 207, 65,
2909  12, 0, 13, 14, 15, 238, 239, 18, 19, 0,
2910  0, 0, 0, 0, 240, 241, 242, 23, 24, 25,
2911  26, 0, 0, 200, 0, 0, 0, 0, 0, 0,
2912  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2913  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2914  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2915  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2916  202, 0, 0, 203, 50, 0, 51, 52, 0, 0,
2917  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2918  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2919  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2920  63, 207, 65, 12, 0, 13, 14, 15, 16, 17,
2921  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2922  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
2923  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2924  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2925  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2926  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2927  0, 0, 0, 202, 0, 0, 203, 50, 0, 51,
2928  52, 0, 0, 0, 0, 54, 55, 56, 57, 58,
2929  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
2930  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2931  0, 10, 11, 63, 207, 65, 12, 0, 13, 14,
2932  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2933  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2934  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
2935  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2936  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2937  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2938  0, 0, 0, 0, 0, 0, 202, 0, 0, 203,
2939  50, 0, 51, 52, 0, 0, 0, 0, 54, 55,
2940  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2941  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2942  9, 0, 0, 0, 10, 11, 63, 64, 65, 12,
2943  0, 13, 14, 15, 238, 239, 18, 19, 0, 0,
2944  0, 0, 0, 240, 241, 242, 23, 24, 25, 26,
2945  0, 0, 200, 0, 0, 0, 0, 0, 0, 268,
2946  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2947  40, 0, 41, 42, 0, 43, 44, 45, 0, 0,
2948  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2949  0, 0, 0, 0, 0, 0, 0, 0, 0, 269,
2950  0, 0, 323, 50, 0, 51, 52, 0, 324, 0,
2951  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2952  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2953  0, 0, 0, 10, 11, 0, 0, 0, 12, 270,
2954  13, 14, 15, 238, 239, 18, 19, 0, 0, 0,
2955  0, 0, 240, 241, 242, 23, 24, 25, 26, 0,
2956  0, 200, 0, 0, 0, 0, 0, 0, 268, 0,
2957  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2958  0, 41, 42, 0, 43, 44, 45, 0, 0, 0,
2959  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2960  0, 0, 0, 0, 0, 0, 0, 0, 365, 0,
2961  0, 49, 50, 0, 51, 52, 0, 53, 0, 0,
2962  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2963  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2964  0, 0, 10, 11, 0, 0, 0, 12, 270, 13,
2965  14, 15, 238, 239, 18, 19, 0, 0, 0, 0,
2966  0, 240, 241, 242, 23, 24, 25, 26, 0, 0,
2967  200, 0, 0, 0, 0, 0, 0, 268, 0, 0,
2968  32, 33, 34, 373, 36, 37, 38, 374, 40, 0,
2969  41, 42, 0, 43, 44, 45, 0, 0, 0, 0,
2970  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2971  0, 0, 0, 0, 375, 0, 0, 376, 0, 0,
2972  203, 50, 0, 51, 52, 0, 0, 0, 0, 54,
2973  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2974  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2975  0, 10, 11, 0, 0, 0, 12, 270, 13, 14,
2976  15, 238, 239, 18, 19, 0, 0, 0, 0, 0,
2977  240, 241, 242, 23, 24, 25, 26, 0, 0, 200,
2978  0, 0, 0, 0, 0, 0, 268, 0, 0, 32,
2979  33, 34, 373, 36, 37, 38, 374, 40, 0, 41,
2980  42, 0, 43, 44, 45, 0, 0, 0, 0, 0,
2981  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2982  0, 0, 0, 0, 0, 0, 376, 0, 0, 203,
2983  50, 0, 51, 52, 0, 0, 0, 0, 54, 55,
2984  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2985  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2986  10, 11, 0, 0, 0, 12, 270, 13, 14, 15,
2987  238, 239, 18, 19, 0, 0, 0, 0, 0, 240,
2988  241, 242, 23, 24, 25, 26, 0, 0, 200, 0,
2989  0, 0, 0, 0, 0, 268, 0, 0, 32, 33,
2990  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2991  0, 43, 44, 45, 0, 0, 0, 0, 0, 0,
2992  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2993  0, 0, 0, 0, 0, 269, 0, 0, 323, 50,
2994  0, 51, 52, 0, 0, 0, 0, 54, 55, 56,
2995  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2996  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2997  11, 0, 0, 0, 12, 270, 13, 14, 15, 238,
2998  239, 18, 19, 0, 0, 0, 0, 0, 240, 241,
2999  242, 23, 24, 25, 26, 0, 0, 200, 0, 0,
3000  0, 0, 0, 0, 268, 0, 0, 32, 33, 34,
3001  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
3002  43, 44, 45, 0, 0, 0, 0, 0, 0, 0,
3003  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3004  0, 0, 0, 0, 894, 0, 0, 203, 50, 0,
3005  51, 52, 0, 0, 0, 0, 54, 55, 56, 57,
3006  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
3007  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
3008  0, 0, 0, 12, 270, 13, 14, 15, 238, 239,
3009  18, 19, 0, 0, 0, 0, 0, 240, 241, 242,
3010  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
3011  0, 0, 0, 268, 0, 0, 32, 33, 34, 35,
3012  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
3013  44, 45, 0, 0, 0, 0, 0, 0, 0, 0,
3014  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3015  0, 0, 0, 974, 0, 0, 203, 50, 0, 51,
3016  52, 0, 0, 0, 0, 54, 55, 56, 57, 58,
3017  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
3018  561, 562, 0, 0, 563, 0, 0, 0, 0, 0,
3019  0, 0, 0, 270, 162, 163, 164, 165, 166, 167,
3020  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
3021  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
3022  0, 0, 0, 177, 178, 0, 0, 0, 0, 0,
3023  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3024  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
3025  185, 186, 187, 188, 0, 189, 190, 598, 562, 0,
3026  0, 599, 0, 191, 0, 0, 0, 0, 0, 0,
3027  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
3028  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
3029  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3030  177, 178, 0, 0, 0, 0, 0, 0, 0, 0,
3031  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3032  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
3033  188, 0, 189, 190, 612, 554, 0, 0, 613, 0,
3034  191, 0, 0, 0, 0, 0, 0, 0, 162, 163,
3035  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
3036  172, 0, 0, 173, 174, 175, 176, 0, 0, 0,
3037  0, 0, 0, 0, 0, 0, 0, 177, 178, 0,
3038  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3039  0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
3040  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
3041  190, 615, 562, 0, 0, 616, 0, 191, 0, 0,
3042  0, 0, 0, 0, 0, 162, 163, 164, 165, 166,
3043  167, 168, 169, 170, 0, 0, 171, 172, 0, 0,
3044  173, 174, 175, 176, 0, 0, 0, 0, 0, 0,
3045  0, 0, 0, 0, 177, 178, 0, 0, 0, 0,
3046  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3047  0, 0, 0, 0, 0, 179, 180, 181, 182, 183,
3048  184, 185, 186, 187, 188, 0, 189, 190, 639, 554,
3049  0, 0, 640, 0, 191, 0, 0, 0, 0, 0,
3050  0, 0, 162, 163, 164, 165, 166, 167, 168, 169,
3051  170, 0, 0, 171, 172, 0, 0, 173, 174, 175,
3052  176, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3053  0, 177, 178, 0, 0, 0, 0, 0, 0, 0,
3054  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3055  0, 0, 179, 180, 181, 182, 183, 184, 185, 186,
3056  187, 188, 0, 189, 190, 642, 562, 0, 0, 643,
3057  0, 191, 0, 0, 0, 0, 0, 0, 0, 162,
3058  163, 164, 165, 166, 167, 168, 169, 170, 0, 0,
3059  171, 172, 0, 0, 173, 174, 175, 176, 0, 0,
3060  0, 0, 0, 0, 0, 0, 0, 0, 177, 178,
3061  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3062  0, 0, 0, 0, 0, 0, 0, 0, 0, 179,
3063  180, 181, 182, 183, 184, 185, 186, 187, 188, 0,
3064  189, 190, 727, 554, 0, 0, 728, 0, 191, 0,
3065  0, 0, 0, 0, 0, 0, 162, 163, 164, 165,
3066  166, 167, 168, 169, 170, 0, 0, 171, 172, 0,
3067  0, 173, 174, 175, 176, 0, 0, 0, 0, 0,
3068  0, 0, 0, 0, 0, 177, 178, 0, 0, 0,
3069  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3070  0, 0, 0, 0, 0, 0, 179, 180, 181, 182,
3071  183, 184, 185, 186, 187, 188, 0, 189, 190, 730,
3072  562, 0, 0, 731, 0, 191, 0, 0, 0, 0,
3073  0, 0, 0, 162, 163, 164, 165, 166, 167, 168,
3074  169, 170, 0, 0, 171, 172, 0, 0, 173, 174,
3075  175, 176, 0, 0, 0, 0, 0, 0, 0, 0,
3076  0, 0, 177, 178, 0, 0, 0, 0, 0, 0,
3077  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3078  0, 0, 0, 179, 180, 181, 182, 183, 184, 185,
3079  186, 187, 188, 0, 189, 190, 737, 554, 0, 0,
3080  738, 0, 191, 0, 0, 0, 0, 0, 0, 0,
3081  162, 163, 164, 165, 166, 167, 168, 169, 170, 0,
3082  0, 171, 172, 0, 0, 173, 174, 175, 176, 0,
3083  0, 0, 0, 0, 0, 0, 0, 0, 0, 177,
3084  178, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3085  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3086  179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
3087  0, 189, 190, 1002, 554, 0, 0, 1003, 0, 191,
3088  0, 0, 0, 0, 0, 0, 0, 162, 163, 164,
3089  165, 166, 167, 168, 169, 170, 0, 0, 171, 172,
3090  0, 0, 173, 174, 175, 176, 0, 0, 0, 0,
3091  0, 0, 0, 0, 0, 0, 177, 178, 0, 0,
3092  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3093  0, 0, 0, 0, 0, 0, 0, 179, 180, 181,
3094  182, 183, 184, 185, 186, 187, 188, 0, 189, 190,
3095  1037, 554, 0, 0, 1038, 0, 191, 0, 0, 0,
3096  0, 0, 0, 0, 162, 163, 164, 165, 166, 167,
3097  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
3098  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
3099  0, 0, 0, 177, 178, 0, 0, 0, 0, 0,
3100  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3101  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
3102  185, 186, 187, 188, 0, 189, 190, 1040, 562, 0,
3103  0, 1041, 0, 191, 0, 0, 0, 0, 0, 0,
3104  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
3105  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
3106  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3107  177, 178, 0, 0, 0, 0, 0, 0, 0, 0,
3108  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3109  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
3110  188, 0, 189, 190, 0, 0, 0, 0, 0, 0,
3111  191
3112 };
3113 
3114 #define yypact_value_is_default(yystate) \
3115  ((yystate) == (-808))
3116 
3117 #define yytable_value_is_error(yytable_value) \
3118  ((yytable_value) == (-621))
3119 
3120 static const yytype_int16 yycheck[] =
3121 {
3122  2, 87, 55, 96, 90, 353, 79, 355, 472, 16,
3123  17, 22, 359, 20, 354, 326, 614, 2, 8, 4,
3124  16, 17, 8, 28, 20, 326, 412, 27, 49, 29,
3125  74, 4, 220, 53, 420, 86, 87, 420, 28, 90,
3126  575, 94, 28, 641, 594, 49, 668, 685, 574, 51,
3127  52, 399, 468, 67, 262, 51, 779, 472, 266, 79,
3128  53, 376, 508, 74, 90, 511, 2, 415, 4, 417,
3129  715, 91, 92, 93, 719, 458, 416, 440, 25, 787,
3130  16, 17, 25, 13, 20, 16, 17, 13, 67, 20,
3131  875, 26, 25, 27, 873, 443, 903, 250, 37, 38,
3132  58, 29, 518, 16, 17, 64, 8, 20, 68, 87,
3133  68, 90, 777, 49, 139, 113, 141, 53, 85, 61,
3134  51, 52, 13, 471, 907, 25, 28, 76, 64, 61,
3135  470, 729, 596, 651, 0, 113, 134, 802, 96, 97,
3136  85, 779, 740, 79, 286, 15, 288, 17, 290, 787,
3137  86, 87, 294, 55, 90, 91, 92, 93, 141, 13,
3138  939, 25, 120, 123, 124, 125, 133, 26, 110, 118,
3139  323, 13, 25, 25, 25, 898, 59, 60, 110, 230,
3140  25, 232, 203, 111, 806, 807, 736, 134, 133, 13,
3141  130, 134, 94, 657, 744, 130, 56, 1004, 271, 243,
3142  1, 134, 141, 136, 134, 139, 991, 141, 259, 139,
3143  136, 141, 214, 139, 993, 141, 237, 224, 220, 226,
3144  227, 307, 308, 309, 310, 227, 252, 950, 224, 250,
3145  226, 1014, 25, 581, 134, 621, 622, 945, 252, 622,
3146  580, 429, 657, 140, 690, 593, 250, 1026, 139, 25,
3147  141, 271, 592, 771, 772, 140, 307, 308, 309, 310,
3148  898, 312, 313, 248, 886, 903, 140, 203, 268, 632,
3149  134, 130, 136, 252, 360, 361, 591, 136, 230, 743,
3150  696, 134, 134, 134, 929, 139, 1009, 141, 224, 134,
3151  226, 227, 87, 224, 230, 226, 232, 139, 670, 141,
3152  672, 237, 323, 255, 324, 61, 258, 945, 85, 360,
3153  361, 224, 248, 226, 250, 139, 117, 141, 113, 323,
3154  113, 306, 134, 259, 375, 321, 311, 853, 743, 141,
3155  326, 324, 85, 306, 85, 271, 362, 113, 139, 134,
3156  141, 134, 964, 485, 137, 61, 140, 354, 141, 65,
3157  492, 107, 354, 109, 26, 873, 133, 875, 134, 37,
3158  38, 137, 321, 85, 85, 141, 1004, 326, 85, 97,
3159  306, 307, 308, 309, 310, 311, 312, 313, 725, 132,
3160  133, 931, 133, 362, 140, 321, 85, 323, 324, 85,
3161  326, 107, 120, 109, 929, 468, 697, 59, 60, 378,
3162  28, 85, 52, 714, 54, 55, 56, 57, 61, 416,
3163  132, 133, 133, 85, 416, 2, 133, 4, 354, 26,
3164  356, 939, 940, 611, 360, 361, 428, 429, 636, 16,
3165  17, 87, 437, 20, 133, 703, 132, 133, 440, 375,
3166  990, 1039, 710, 402, 403, 518, 85, 437, 468, 133,
3167  87, 437, 134, 355, 107, 440, 109, 113, 130, 141,
3168  132, 133, 49, 470, 136, 113, 402, 403, 470, 85,
3169  422, 134, 936, 991, 426, 993, 113, 64, 85, 431,
3170  416, 412, 868, 68, 134, 868, 52, 140, 54, 55,
3171  56, 57, 113, 132, 133, 447, 87, 399, 518, 86,
3172  87, 87, 85, 90, 440, 507, 508, 87, 1026, 511,
3173  100, 883, 884, 557, 450, 417, 888, 133, 890, 891,
3174  87, 565, 113, 130, 455, 132, 133, 113, 87, 136,
3175  134, 87, 468, 113, 470, 437, 121, 122, 123, 124,
3176  125, 443, 542, 134, 595, 87, 113, 558, 58, 570,
3177  133, 572, 54, 87, 85, 566, 600, 113, 68, 85,
3178  560, 63, 64, 136, 637, 517, 568, 134, 134, 471,
3179  917, 113, 760, 580, 625, 56, 923, 134, 580, 113,
3180  576, 113, 518, 61, 141, 592, 96, 97, 88, 600,
3181  592, 136, 134, 26, 573, 574, 141, 134, 600, 137,
3182  605, 132, 133, 141, 87, 136, 132, 133, 587, 611,
3183  120, 14, 15, 134, 614, 605, 203, 637, 136, 605,
3184  52, 130, 87, 696, 56, 997, 998, 999, 1000, 107,
3185  632, 109, 110, 136, 570, 136, 572, 224, 68, 226,
3186  227, 641, 137, 230, 580, 232, 732, 632, 113, 735,
3187  237, 113, 85, 138, 131, 748, 592, 85, 594, 595,
3188  704, 248, 61, 250, 666, 686, 668, 711, 689, 134,
3189  691, 1019, 259, 56, 134, 1047, 696, 68, 1018, 581,
3190  68, 732, 94, 635, 735, 685, 110, 110, 690, 625,
3191  621, 593, 110, 746, 110, 134, 632, 130, 85, 132,
3192  133, 637, 139, 605, 132, 133, 17, 56, 107, 711,
3193  109, 110, 714, 715, 134, 717, 25, 719, 714, 306,
3194  307, 308, 309, 310, 311, 312, 313, 26, 68, 729,
3195  61, 577, 137, 134, 321, 131, 323, 130, 697, 326,
3196  740, 700, 701, 83, 84, 132, 133, 10, 707, 708,
3197  686, 140, 134, 689, 733, 691, 134, 843, 760, 85,
3198  696, 697, 134, 140, 700, 701, 745, 354, 134, 356,
3199  85, 707, 708, 360, 361, 87, 107, 777, 109, 110,
3200  800, 121, 122, 123, 124, 125, 85, 52, 375, 134,
3201  742, 113, 843, 85, 815, 68, 732, 136, 8, 735,
3202  736, 113, 802, 131, 806, 807, 132, 133, 744, 761,
3203  83, 84, 13, 61, 134, 402, 403, 132, 133, 840,
3204  61, 134, 134, 775, 113, 52, 847, 848, 134, 416,
3205  851, 130, 134, 132, 133, 52, 838, 136, 134, 841,
3206  132, 133, 15, 52, 746, 118, 119, 120, 121, 122,
3207  123, 124, 125, 440, 85, 134, 115, 878, 879, 107,
3208  138, 109, 110, 450, 800, 134, 107, 131, 109, 110,
3209  829, 892, 134, 893, 853, 113, 855, 85, 724, 815,
3210  134, 85, 118, 470, 886, 134, 16, 17, 54, 55,
3211  20, 57, 134, 829, 134, 741, 916, 63, 64, 920,
3212  139, 132, 133, 10, 840, 87, 131, 843, 860, 10,
3213  134, 847, 848, 685, 88, 851, 46, 47, 9, 685,
3214  872, 51, 52, 134, 132, 133, 118, 929, 132, 133,
3215  137, 113, 134, 56, 64, 65, 201, 134, 134, 204,
3216  205, 206, 878, 879, 52, 134, 54, 55, 56, 57,
3217  58, 131, 134, 134, 10, 134, 892, 893, 108, 980,
3218  68, 982, 964, 131, 134, 134, 56, 988, 450, 134,
3219  970, 134, 134, 134, 685, 68, 136, 136, 134, 91,
3220  916, 89, 93, 570, 920, 572, 711, 1021, 96, 97,
3221  83, 84, 771, 580, 685, 931, 1014, 749, 844, 52,
3222  846, 54, 55, 56, 57, 592, 294, 594, 595, 781,
3223  856, 1018, 120, 785, 1020, 861, 1018, 99, 1020, 1021,
3224  57, 787, 94, 781, 790, 936, 898, 120, 121, 122,
3225  123, 124, 125, 900, 779, 396, 89, -1, 625, 1039,
3226  -1, -1, 95, -1, 980, 632, 982, 40, 41, 42,
3227  43, 44, 988, -1, 990, 52, 321, 54, 55, 56,
3228  57, 326, -1, 52, -1, 54, 55, 56, 57, -1,
3229  781, 201, -1, -1, 204, 205, 206, 207, -1, -1,
3230  926, 927, 1018, 2, 52, 4, 54, 55, 56, 57,
3231  -1, -1, 89, -1, 224, -1, 226, 227, 95, 686,
3232  89, -1, 689, -1, 691, -1, -1, -1, -1, -1,
3233  697, -1, -1, 700, 701, -1, -1, 1019, -1, -1,
3234  707, 708, -1, -1, -1, -1, 898, -1, 900, -1,
3235  49, 903, -1, 905, 53, -1, -1, 903, -1, 905,
3236  -1, -1, -1, 989, -1, 732, 411, 412, 735, 736,
3237  -1, -1, -1, -1, -1, 420, -1, 744, -1, -1,
3238  79, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3239  -1, -1, 91, 92, 93, 94, 1022, -1, 1024, 945,
3240  -1, 947, -1, 809, 810, -1, 952, 898, -1, 900,
3241  455, 321, 903, 458, 905, -1, 326, 327, 328, 329,
3242  330, 331, 332, 333, 334, 335, 336, 337, 338, 339,
3243  340, 341, 342, 343, 344, 345, 346, 347, 348, 349,
3244  350, 351, 352, -1, 354, -1, -1, -1, 815, -1,
3245  -1, -1, 1004, -1, 1006, -1, -1, 1009, 1004, 1011,
3246  1006, -1, 829, -1, -1, 1011, -1, 512, -1, -1,
3247  -1, -1, -1, 840, -1, -1, 843, -1, -1, -1,
3248  847, 848, 1028, -1, 851, -1, -1, -1, -1, -1,
3249  -1, -1, 402, 403, -1, -1, -1, 1049, -1, -1,
3250  410, 411, 412, 1049, 203, -1, 416, -1, 418, 419,
3251  420, 878, 879, 1004, -1, 1006, -1, -1, 1009, -1,
3252  1011, -1, -1, -1, -1, 892, -1, -1, -1, 439,
3253  -1, 576, -1, -1, 444, -1, -1, -1, 237, -1,
3254  -1, -1, -1, -1, -1, 455, -1, -1, 458, 248,
3255  -1, 250, -1, 920, -1, 961, 962, -1, 1049, 965,
3256  470, 967, 968, 608, 931, -1, -1, -1, -1, -1,
3257  -1, -1, 271, -1, -1, -1, 621, 622, -1, -1,
3258  -1, -1, -1, 2, -1, 4, 496, 497, -1, -1,
3259  -1, -1, -1, -1, 52, -1, 54, 55, 56, 57,
3260  58, -1, 512, -1, 649, -1, -1, 306, -1, -1,
3261  68, -1, 311, 980, -1, 982, -1, -1, -1, -1,
3262  -1, 988, -1, 990, 323, 324, 1032, 1033, 1034, 1035,
3263  49, 89, -1, -1, 53, -1, -1, 95, 96, 97,
3264  52, -1, 54, 55, 56, 57, 58, -1, 693, 1055,
3265  -1, 1018, -1, -1, -1, -1, 68, 356, -1, -1,
3266  79, -1, 120, -1, -1, 123, 576, -1, -1, 714,
3267  580, -1, 91, 92, 93, 94, -1, 89, -1, -1,
3268  -1, -1, 592, 141, 96, 97, -1, -1, -1, 52,
3269  -1, 54, 55, 56, 57, 58, -1, -1, 608, -1,
3270  -1, -1, -1, -1, -1, 68, -1, -1, 120, -1,
3271  -1, 621, 622, -1, -1, -1, -1, -1, -1, -1,
3272  -1, -1, -1, 768, -1, -1, 89, -1, -1, -1,
3273  -1, -1, 95, 96, 97, -1, -1, -1, -1, 649,
3274  -1, 440, -1, -1, -1, -1, -1, -1, -1, -1,
3275  -1, 450, -1, 2, -1, 4, -1, 120, -1, -1,
3276  123, -1, -1, -1, -1, -1, -1, -1, -1, 468,
3277  -1, -1, 817, 136, 2, -1, 4, -1, -1, -1,
3278  -1, -1, -1, 693, 203, -1, -1, 697, 698, -1,
3279  700, 701, -1, 2, -1, 4, -1, 707, 708, -1,
3280  49, -1, -1, -1, 714, 850, -1, -1, -1, -1,
3281  52, -1, 54, 55, 56, 57, 58, -1, 237, 518,
3282  -1, 49, -1, 868, -1, 53, 68, -1, -1, 248,
3283  -1, 250, -1, -1, -1, -1, -1, -1, -1, -1,
3284  49, 751, -1, -1, -1, 755, 756, 89, 758, 759,
3285  -1, 79, 271, 95, 96, 97, -1, -1, 768, -1,
3286  -1, -1, -1, 91, 92, 93, -1, -1, -1, -1,
3287  -1, 570, -1, 572, -1, -1, -1, -1, 120, -1,
3288  -1, 123, 91, -1, -1, -1, -1, 306, -1, -1,
3289  -1, -1, 311, -1, 136, 594, -1, -1, -1, -1,
3290  -1, -1, -1, -1, 323, 324, -1, 817, -1, -1,
3291  -1, 821, -1, -1, -1, -1, -1, -1, -1, 829,
3292  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3293  -1, -1, -1, 632, -1, -1, -1, 356, 637, -1,
3294  850, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3295  -1, -1, -1, -1, 203, -1, -1, 867, 868, -1,
3296  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3297  76, 77, 78, 79, 80, 203, -1, 83, 84, -1,
3298  -1, -1, -1, -1, -1, -1, -1, 686, 237, -1,
3299  689, -1, 691, -1, 203, -1, -1, 696, -1, 248,
3300  -1, 250, -1, -1, -1, -1, -1, -1, 114, 237,
3301  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3302  248, 440, 250, -1, -1, -1, -1, -1, 237, -1,
3303  -1, 450, -1, -1, -1, 141, -1, 736, -1, 248,
3304  -1, 250, -1, 271, -1, 744, -1, -1, -1, 468,
3305  -1, -1, -1, -1, -1, -1, -1, 306, -1, -1,
3306  -1, 52, 311, 54, 55, 56, 57, 58, -1, -1,
3307  -1, -1, -1, -1, 323, -1, -1, 68, 306, -1,
3308  -1, -1, -1, 311, -1, -1, -1, -1, -1, -1,
3309  -1, -1, -1, -1, -1, 323, 324, 306, 89, 518,
3310  -1, 800, 311, -1, 95, 96, 97, 356, 1018, -1,
3311  -1, -1, -1, -1, 323, -1, 815, 326, -1, -1,
3312  -1, -1, -1, -1, -1, -1, -1, -1, 356, 120,
3313  44, -1, 123, -1, -1, -1, -1, -1, -1, -1,
3314  -1, 840, -1, -1, -1, -1, -1, 356, 847, 848,
3315  -1, 570, 851, 572, 68, 69, 70, 71, 72, 73,
3316  74, 75, 76, 77, 78, 79, 80, -1, -1, 83,
3317  84, -1, -1, -1, -1, 594, -1, -1, -1, 878,
3318  879, -1, 52, -1, 54, 55, 56, 57, 58, -1,
3319  -1, 440, -1, 892, 893, -1, -1, -1, 68, -1,
3320  114, 450, 116, 117, 118, 119, 120, 121, 122, 123,
3321  124, 125, 440, 632, -1, -1, -1, 916, 637, 89,
3322  134, 920, 450, -1, -1, 95, 96, 97, -1, -1,
3323  -1, 440, 931, -1, -1, -1, -1, -1, -1, -1,
3324  468, 450, -1, -1, -1, -1, -1, -1, -1, -1,
3325  120, -1, -1, 123, -1, -1, -1, -1, -1, -1,
3326  -1, -1, -1, -1, -1, -1, -1, 686, -1, -1,
3327  689, -1, 691, -1, -1, -1, -1, 696, -1, -1,
3328  -1, 980, -1, 982, 52, 53, -1, -1, 56, 988,
3329  518, 990, -1, -1, -1, -1, -1, -1, 66, 67,
3330  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
3331  78, -1, -1, 81, 82, 83, 84, 736, -1, -1,
3332  -1, 570, -1, 572, -1, 744, -1, 95, 96, -1,
3333  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3334  -1, -1, 570, -1, 572, 594, -1, -1, 116, 117,
3335  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
3336  128, 570, -1, 572, -1, -1, 594, 135, -1, -1,
3337  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3338  -1, 800, -1, 632, -1, 594, -1, -1, -1, -1,
3339  -1, -1, -1, -1, -1, -1, 815, -1, -1, -1,
3340  -1, -1, -1, -1, 632, -1, -1, -1, -1, 637,
3341  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3342  -1, 840, -1, 632, -1, -1, -1, -1, 847, 848,
3343  -1, -1, 851, -1, -1, -1, -1, 686, -1, -1,
3344  689, -1, 691, -1, -1, -1, -1, -1, 676, -1,
3345  -1, -1, -1, -1, -1, -1, -1, -1, 686, 878,
3346  879, 689, -1, 691, -1, -1, -1, -1, 696, -1,
3347  -1, -1, -1, 892, 893, -1, -1, 686, -1, -1,
3348  689, -1, 691, -1, -1, -1, -1, 736, 697, -1,
3349  -1, -1, -1, -1, -1, 744, -1, 916, -1, -1,
3350  -1, 920, -1, -1, -1, -1, -1, -1, 736, -1,
3351  -1, -1, 931, -1, -1, -1, 744, -1, -1, -1,
3352  -1, -1, -1, -1, -1, -1, -1, 736, 68, 69,
3353  70, 71, 72, 73, 74, 744, -1, 77, 78, -1,
3354  -1, -1, -1, 83, 84, -1, -1, -1, -1, -1,
3355  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3356  -1, 980, -1, 982, -1, -1, 815, -1, -1, 988,
3357  -1, 990, 800, -1, -1, -1, 116, 117, 118, 119,
3358  120, 121, 122, 123, 124, 125, -1, 815, -1, -1,
3359  -1, 840, -1, -1, -1, -1, -1, -1, 847, 848,
3360  -1, -1, 851, -1, -1, -1, 815, -1, -1, -1,
3361  -1, -1, 840, -1, -1, -1, -1, -1, -1, 847,
3362  848, -1, -1, 851, -1, -1, -1, -1, -1, 878,
3363  879, 840, -1, -1, -1, -1, -1, -1, 847, 848,
3364  -1, -1, 851, 892, -1, -1, -1, -1, -1, -1,
3365  878, 879, -1, -1, -1, -1, -1, -1, -1, -1,
3366  -1, -1, -1, -1, 892, 893, -1, -1, -1, 878,
3367  879, 920, -1, -1, -1, -1, -1, -1, -1, -1,
3368  -1, -1, 931, 892, -1, -1, -1, -1, 916, -1,
3369  -1, -1, 920, -1, -1, -1, -1, -1, -1, -1,
3370  -1, -1, -1, 931, -1, -1, -1, 916, -1, -1,
3371  -1, 920, -1, -1, -1, -1, -1, -1, -1, -1,
3372  -1, -1, 931, -1, -1, -1, -1, -1, -1, -1,
3373  -1, 980, -1, 982, -1, -1, -1, -1, -1, 988,
3374  -1, 990, -1, -1, -1, -1, -1, -1, -1, -1,
3375  -1, -1, 980, -1, 982, -1, -1, -1, -1, -1,
3376  988, -1, 990, -1, -1, -1, -1, -1, -1, -1,
3377  -1, 980, -1, 982, -1, -1, -1, -1, -1, 988,
3378  -1, 990, 0, 1, -1, 3, 4, 5, 6, 7,
3379  -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
3380  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3381  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3382  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3383  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3384  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3385  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3386  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3387  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3388  98, 99, 100, 101, 102, 103, 104, 105, 106, 0,
3389  -1, -1, -1, -1, -1, -1, -1, 8, 9, 10,
3390  -1, -1, 13, 14, 15, -1, 17, -1, 126, 127,
3391  128, -1, 44, -1, -1, 26, 27, 28, 29, -1,
3392  -1, 139, -1, 141, -1, -1, 37, 38, -1, 40,
3393  41, 42, 43, 44, -1, -1, 68, 69, 70, 71,
3394  72, 73, 74, 75, 76, 77, 78, 79, 80, -1,
3395  -1, 83, 84, -1, -1, -1, -1, 68, 69, 70,
3396  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3397  -1, -1, 83, 84, 85, -1, 87, 88, -1, -1,
3398  -1, -1, 114, 94, 116, 117, 118, 119, 120, 121,
3399  122, 123, 124, 125, -1, -1, -1, 108, -1, -1,
3400  111, -1, 113, 114, 115, 116, 117, 118, 119, 120,
3401  121, 122, 123, 124, 125, -1, -1, -1, -1, 130,
3402  131, 132, 133, 134, 0, -1, 137, 138, 139, -1,
3403  141, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3404  -1, 17, -1, -1, -1, -1, -1, 44, -1, 25,
3405  -1, 27, 28, 29, -1, -1, -1, -1, -1, -1,
3406  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3407  -1, 68, 69, 70, 71, 72, 73, 74, 75, 76,
3408  77, 78, 79, 80, -1, -1, 83, 84, -1, -1,
3409  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3410  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3411  -1, 87, 88, -1, -1, -1, -1, 114, 94, 116,
3412  117, 118, 119, 120, 121, 122, 123, 124, 125, -1,
3413  -1, -1, 108, -1, -1, 111, -1, 113, 114, 115,
3414  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3415  -1, -1, -1, -1, -1, 131, 132, 133, 134, 0,
3416  -1, 137, 138, 139, -1, 141, -1, 8, 9, 10,
3417  -1, -1, 13, 14, 15, -1, 17, -1, -1, -1,
3418  -1, -1, -1, -1, 25, -1, 27, 28, 29, -1,
3419  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3420  41, 42, 43, 44, -1, -1, 68, 69, 70, 71,
3421  72, 73, 74, 75, 76, 77, 78, 79, 80, -1,
3422  -1, 83, 84, -1, -1, -1, -1, 68, 69, 70,
3423  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3424  -1, -1, 83, 84, 85, -1, 87, 88, -1, -1,
3425  -1, -1, 114, 94, 116, 117, 118, 119, 120, 121,
3426  122, 123, 124, 125, -1, -1, -1, 108, -1, -1,
3427  111, -1, 113, 114, 115, 116, 117, 118, 119, 120,
3428  121, 122, 123, 124, 125, -1, -1, -1, -1, -1,
3429  131, 132, 133, 134, 0, -1, 137, 138, 139, -1,
3430  141, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3431  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3432  26, 27, 28, 29, -1, -1, -1, -1, -1, -1,
3433  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3434  -1, 68, 69, 70, 71, 72, 73, 74, 75, 76,
3435  77, 78, 79, 80, -1, -1, 83, 84, -1, -1,
3436  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3437  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3438  -1, -1, 88, -1, -1, -1, -1, -1, 94, 116,
3439  117, 118, 119, 120, 121, 122, 123, 124, 125, -1,
3440  -1, -1, 108, -1, -1, 111, -1, -1, 114, 115,
3441  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3442  -1, -1, -1, -1, 130, 131, 132, 133, 134, 0,
3443  -1, 137, 138, 139, -1, 141, -1, 8, 9, 10,
3444  -1, -1, 13, 14, 15, -1, 17, -1, -1, -1,
3445  -1, -1, -1, -1, -1, 26, 27, 28, 29, -1,
3446  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3447  41, 42, 43, 44, -1, -1, 68, 69, 70, 71,
3448  72, 73, 74, 75, -1, 77, 78, -1, -1, -1,
3449  -1, 83, 84, -1, -1, -1, -1, 68, 69, 70,
3450  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3451  -1, -1, 83, 84, 85, -1, -1, 88, -1, -1,
3452  -1, -1, -1, 94, 116, 117, 118, 119, 120, 121,
3453  122, 123, 124, 125, -1, -1, -1, 108, -1, -1,
3454  111, -1, -1, 114, 115, 116, 117, 118, 119, 120,
3455  121, 122, 123, 124, 125, -1, -1, -1, -1, 130,
3456  131, 132, 133, 134, 0, -1, 137, 138, 139, -1,
3457  141, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3458  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3459  -1, 27, 28, 29, -1, -1, -1, -1, -1, -1,
3460  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3461  -1, 68, 69, 70, 71, 72, 73, 74, -1, -1,
3462  77, 78, -1, -1, -1, -1, 83, 84, -1, -1,
3463  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3464  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3465  -1, 87, 88, -1, -1, -1, -1, -1, 94, 116,
3466  117, 118, 119, 120, 121, 122, 123, 124, 125, -1,
3467  -1, -1, 108, -1, -1, 111, -1, 113, 114, 115,
3468  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3469  -1, -1, -1, -1, -1, 131, 132, 133, 134, 0,
3470  -1, 137, 138, 139, -1, 141, -1, 8, 9, 10,
3471  -1, -1, 13, 14, 15, -1, 17, -1, -1, -1,
3472  -1, -1, -1, -1, -1, 26, 27, 28, -1, -1,
3473  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3474  41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
3475  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3476  -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
3477  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3478  -1, -1, 83, 84, 85, -1, -1, 88, -1, -1,
3479  -1, -1, -1, 94, -1, -1, -1, -1, -1, -1,
3480  -1, -1, -1, -1, -1, -1, -1, 108, -1, -1,
3481  -1, -1, -1, 114, -1, 116, 117, 118, 119, 120,
3482  121, 122, 123, 124, 125, -1, -1, -1, -1, 130,
3483  131, 132, 133, 134, 0, 136, 137, 138, 139, -1,
3484  141, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3485  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3486  -1, 27, 28, 29, -1, -1, -1, -1, -1, -1,
3487  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3488  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3489  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3490  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3491  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3492  -1, -1, 88, -1, -1, -1, -1, -1, 94, -1,
3493  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3494  -1, -1, 108, -1, -1, 111, -1, -1, 114, 115,
3495  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3496  -1, -1, -1, -1, -1, 131, 132, 133, 134, 0,
3497  -1, 137, 138, 139, -1, 141, -1, 8, 9, 10,
3498  -1, -1, 13, 14, 15, -1, 17, -1, -1, -1,
3499  -1, -1, -1, -1, -1, 26, 27, 28, -1, -1,
3500  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3501  41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
3502  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3503  -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
3504  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3505  -1, -1, 83, 84, 85, -1, -1, 88, -1, -1,
3506  -1, -1, -1, 94, -1, -1, -1, -1, -1, -1,
3507  -1, -1, -1, -1, -1, -1, -1, 108, -1, -1,
3508  -1, -1, -1, 114, -1, 116, 117, 118, 119, 120,
3509  121, 122, 123, 124, 125, -1, -1, -1, -1, 130,
3510  131, 132, 133, 134, 0, 136, 137, 138, 139, -1,
3511  141, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3512  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3513  -1, 27, 28, -1, -1, -1, -1, -1, -1, -1,
3514  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3515  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3516  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3517  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3518  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3519  -1, -1, 88, -1, -1, -1, -1, -1, 94, -1,
3520  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3521  -1, -1, 108, -1, -1, -1, -1, -1, 114, -1,
3522  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3523  -1, -1, -1, -1, -1, 131, 132, 133, 134, 0,
3524  136, 137, 138, 139, -1, 141, -1, 8, 9, 10,
3525  -1, -1, -1, 14, 15, -1, 17, -1, -1, -1,
3526  -1, -1, -1, -1, -1, 26, -1, -1, -1, -1,
3527  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3528  41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
3529  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3530  -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
3531  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3532  -1, -1, 83, 84, 85, -1, 87, -1, -1, -1,
3533  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3534  -1, -1, -1, -1, -1, -1, -1, 108, -1, -1,
3535  -1, -1, 113, 114, -1, 116, 117, 118, 119, 120,
3536  121, 122, 123, 124, 125, -1, -1, -1, -1, 130,
3537  131, 132, 133, 134, 0, -1, 137, -1, 139, -1,
3538  141, -1, 8, 9, 10, -1, -1, -1, 14, 15,
3539  -1, 17, -1, 0, -1, -1, -1, -1, -1, -1,
3540  -1, 8, 9, 10, -1, -1, 13, 14, 15, -1,
3541  17, 37, 38, -1, 40, 41, 42, 43, 44, 26,
3542  27, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3543  37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
3544  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3545  76, 77, 78, 79, 80, -1, -1, 83, 84, 85,
3546  -1, 87, -1, -1, -1, -1, -1, -1, -1, -1,
3547  -1, -1, -1, -1, -1, -1, -1, -1, 85, -1,
3548  -1, -1, 108, -1, -1, -1, -1, 113, 114, -1,
3549  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3550  -1, 108, -1, -1, -1, 131, 132, 133, 134, -1,
3551  -1, 137, -1, 139, -1, 141, -1, -1, -1, -1,
3552  -1, -1, -1, 130, 131, -1, 133, -1, -1, 136,
3553  137, -1, 139, 1, 141, 3, 4, 5, 6, 7,
3554  8, 9, 10, 11, 12, -1, -1, 15, 16, -1,
3555  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3556  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3557  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3558  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3559  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3560  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3561  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3562  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3563  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3564  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3565  -1, -1, -1, -1, -1, -1, -1, -1, 126, 127,
3566  128, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3567  -1, 139, 1, 141, 3, 4, 5, 6, 7, -1,
3568  -1, 10, 11, 12, -1, 14, 15, 16, -1, 18,
3569  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3570  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3571  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3572  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3573  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3574  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3575  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3576  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3577  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3578  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3579  -1, -1, -1, -1, -1, -1, -1, 126, 127, 128,
3580  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3581  139, 1, 141, 3, 4, 5, 6, 7, -1, -1,
3582  10, 11, 12, -1, -1, 15, 16, 17, 18, 19,
3583  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3584  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3585  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
3586  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3587  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3588  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3589  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3590  90, -1, 92, 93, -1, 95, -1, -1, 98, 99,
3591  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
3592  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3593  -1, -1, -1, -1, -1, -1, 126, 127, 128, -1,
3594  -1, -1, -1, -1, -1, -1, -1, -1, -1, 139,
3595  1, 141, 3, 4, 5, 6, 7, -1, -1, 10,
3596  11, 12, -1, -1, 15, 16, -1, 18, 19, 20,
3597  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3598  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3599  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3600  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3601  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3602  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3603  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3604  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
3605  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3606  -1, -1, -1, 1, -1, 3, 4, 5, 6, 7,
3607  -1, 9, 10, 11, 12, 126, 127, 128, 16, -1,
3608  18, 19, 20, 21, 22, 23, 24, -1, 139, -1,
3609  141, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3610  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3611  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3612  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3613  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3614  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3615  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3616  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3617  -1, -1, -1, -1, -1, -1, 1, -1, 3, 4,
3618  5, 6, 7, -1, -1, -1, 11, 12, 126, 127,
3619  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3620  -1, 139, -1, 141, -1, 30, 31, 32, 33, 34,
3621  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3622  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3623  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3624  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3625  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3626  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3627  95, -1, -1, 98, 99, 100, 101, 102, 103, 104,
3628  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3629  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3630  -1, 126, 127, 128, -1, -1, -1, -1, -1, -1,
3631  -1, -1, 137, -1, 139, 1, 141, 3, 4, 5,
3632  6, 7, -1, -1, -1, 11, 12, -1, -1, -1,
3633  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3634  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3635  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3636  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
3637  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3638  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3639  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3640  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3641  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
3642  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3643  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3644  126, 127, 128, -1, -1, -1, -1, -1, -1, -1,
3645  -1, 137, -1, 139, 1, 141, 3, 4, 5, 6,
3646  7, -1, -1, -1, 11, 12, -1, -1, -1, 16,
3647  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3648  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3649  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
3650  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
3651  57, -1, 59, 60, -1, 62, 63, 64, -1, 66,
3652  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3653  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3654  -1, -1, 89, 90, -1, 92, 93, -1, 95, -1,
3655  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3656  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3657  -1, -1, -1, -1, -1, -1, -1, -1, -1, 126,
3658  127, 128, -1, -1, 131, 1, -1, 3, 4, 5,
3659  6, 7, 139, -1, 141, 11, 12, -1, -1, -1,
3660  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3661  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3662  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3663  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
3664  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3665  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3666  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3667  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3668  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
3669  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3670  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3671  126, 127, 128, -1, -1, 131, -1, -1, -1, -1,
3672  -1, -1, -1, 139, 1, 141, 3, 4, 5, 6,
3673  7, -1, -1, 10, 11, 12, -1, -1, -1, 16,
3674  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3675  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3676  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
3677  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
3678  57, -1, 59, 60, -1, 62, 63, 64, -1, 66,
3679  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3680  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3681  -1, -1, 89, 90, -1, 92, 93, -1, 95, -1,
3682  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3683  -1, -1, -1, -1, -1, -1, -1, 1, -1, 3,
3684  4, 5, 6, 7, -1, -1, -1, 11, 12, 126,
3685  127, 128, 16, -1, 18, 19, 20, 21, 22, 23,
3686  24, -1, 139, -1, 141, -1, 30, 31, 32, 33,
3687  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3688  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3689  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3690  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
3691  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3692  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3693  -1, 95, -1, -1, 98, 99, 100, 101, 102, 103,
3694  104, 105, 106, -1, 108, -1, -1, -1, -1, -1,
3695  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3696  11, 12, 126, 127, 128, 16, -1, 18, 19, 20,
3697  21, 22, 23, 24, -1, 139, -1, 141, -1, 30,
3698  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3699  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3700  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3701  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3702  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3703  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3704  -1, 92, 93, -1, 95, 96, 97, 98, 99, 100,
3705  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3706  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
3707  -1, -1, -1, 11, 12, 126, 127, 128, 16, -1,
3708  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3709  141, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3710  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3711  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3712  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3713  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3714  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3715  -1, 89, 90, -1, 92, 93, -1, -1, -1, -1,
3716  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3717  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
3718  5, -1, 7, -1, -1, -1, 11, 12, 126, 127,
3719  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3720  -1, 139, -1, 141, -1, 30, 31, 32, 33, 34,
3721  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3722  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3723  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3724  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3725  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3726  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3727  -1, -1, -1, 98, 99, 100, 101, 102, 103, 104,
3728  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3729  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
3730  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
3731  22, 23, 24, -1, -1, -1, 141, -1, 30, 31,
3732  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3733  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3734  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3735  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3736  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3737  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3738  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3739  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3740  -1, -1, -1, -1, 3, 4, 5, 6, 7, -1,
3741  -1, -1, 11, 12, 126, 127, 128, 16, -1, 18,
3742  19, 20, 21, 22, 23, 24, -1, 139, -1, -1,
3743  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3744  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3745  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3746  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3747  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3748  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3749  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3750  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3751  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3752  -1, -1, -1, -1, -1, -1, -1, 126, 127, 128,
3753  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3754  139, 3, 4, 5, 6, 7, 8, 9, 10, 11,
3755  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
3756  22, 23, 24, 25, 26, -1, -1, -1, 30, 31,
3757  32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
3758  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3759  52, 53, 54, 55, 56, 57, -1, -1, -1, -1,
3760  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
3761  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
3762  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
3763  -1, -1, -1, 95, 96, -1, -1, -1, -1, -1,
3764  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3765  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
3766  122, 123, 124, 125, -1, 127, 128, -1, -1, -1,
3767  -1, -1, -1, 135, 136, 3, 4, 5, 6, 7,
3768  8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
3769  18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
3770  -1, -1, 30, 31, 32, 33, 34, 35, 36, 37,
3771  38, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3772  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3773  -1, -1, -1, -1, -1, -1, -1, -1, 66, 67,
3774  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
3775  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
3776  -1, -1, -1, -1, -1, -1, -1, 95, 96, -1,
3777  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3778  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
3779  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
3780  128, -1, -1, -1, -1, -1, -1, 135, 3, 4,
3781  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3782  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3783  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3784  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
3785  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3786  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
3787  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3788  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3789  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3790  95, 96, -1, -1, 99, -1, -1, -1, -1, -1,
3791  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3792  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3793  125, -1, 127, 128, -1, -1, -1, -1, -1, -1,
3794  135, 3, 4, 5, 6, 7, 8, 9, 10, 11,
3795  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
3796  22, 23, 24, 25, 26, -1, -1, -1, 30, 31,
3797  32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
3798  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3799  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
3800  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
3801  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
3802  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
3803  -1, -1, -1, 95, 96, -1, -1, 99, -1, -1,
3804  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3805  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
3806  122, 123, 124, 125, -1, 127, 128, -1, -1, -1,
3807  -1, -1, -1, 135, 3, 4, 5, 6, 7, 8,
3808  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
3809  19, 20, 21, 22, 23, 24, 25, 26, -1, -1,
3810  -1, 30, 31, 32, 33, 34, 35, 36, 37, 38,
3811  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3812  49, 50, 51, 52, 53, -1, -1, 56, -1, -1,
3813  -1, -1, -1, -1, -1, -1, -1, 66, 67, 68,
3814  69, 70, 71, 72, 73, 74, -1, -1, 77, 78,
3815  -1, -1, 81, 82, 83, 84, -1, -1, -1, -1,
3816  -1, -1, -1, -1, -1, -1, 95, 96, -1, -1,
3817  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3818  -1, -1, -1, -1, -1, -1, -1, 116, 117, 118,
3819  119, 120, 121, 122, 123, 124, 125, -1, 127, 128,
3820  3, 4, 5, -1, 7, -1, 135, -1, 11, 12,
3821  -1, -1, -1, 16, -1, 18, 19, 20, 21, 22,
3822  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3823  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3824  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3825  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
3826  63, 64, -1, -1, -1, -1, -1, -1, -1, -1,
3827  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3828  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3829  93, -1, -1, -1, -1, 98, 99, 100, 101, 102,
3830  103, 104, 105, 106, -1, -1, -1, -1, -1, 3,
3831  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
3832  -1, -1, 16, 126, 18, 19, 20, 21, 22, 23,
3833  24, 134, -1, -1, -1, -1, 30, 31, 32, 33,
3834  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3835  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3836  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3837  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3838  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3839  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3840  -1, -1, -1, -1, 98, 99, 100, 101, 102, 103,
3841  104, 105, 106, -1, -1, -1, -1, -1, 3, 4,
3842  5, 6, 7, -1, -1, -1, 11, 12, -1, -1,
3843  -1, 16, 126, 18, 19, 20, 21, 22, 23, 24,
3844  134, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3845  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3846  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3847  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3848  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3849  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3850  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3851  95, -1, -1, 98, 99, 100, 101, 102, 103, 104,
3852  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3853  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3854  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
3855  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3856  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3857  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3858  52, 53, 54, 55, 56, 57, 58, 59, 60, -1,
3859  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3860  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3861  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3862  92, 93, -1, 95, 96, 97, 98, 99, 100, 101,
3863  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3864  -1, -1, -1, -1, 3, 4, 5, 6, 7, -1,
3865  -1, -1, 11, 12, 126, 127, 128, 16, -1, 18,
3866  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3867  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3868  39, -1, -1, -1, -1, -1, 45, 46, -1, 48,
3869  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3870  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3871  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3872  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3873  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3874  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3875  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3876  -1, 7, -1, -1, -1, 11, 12, 126, 127, 128,
3877  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3878  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3879  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3880  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3881  56, 57, 58, 59, 60, -1, 62, 63, 64, -1,
3882  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3883  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3884  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3885  96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
3886  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3887  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
3888  126, 127, 128, 16, -1, 18, 19, 20, 21, 22,
3889  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3890  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3891  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3892  53, 54, 55, 56, 57, 58, 59, 60, -1, 62,
3893  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3894  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3895  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3896  93, -1, 95, 96, -1, 98, 99, 100, 101, 102,
3897  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
3898  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3899  -1, 11, 12, 126, 127, 128, 16, -1, 18, 19,
3900  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3901  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3902  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3903  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
3904  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3905  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3906  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3907  90, -1, 92, 93, -1, -1, 96, 97, 98, 99,
3908  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
3909  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3910  7, -1, -1, -1, 11, 12, 126, 127, 128, 16,
3911  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3912  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3913  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3914  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3915  57, 58, 59, 60, -1, 62, 63, 64, -1, 66,
3916  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3917  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3918  -1, -1, 89, 90, -1, 92, 93, -1, 95, 96,
3919  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3920  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3921  4, 5, -1, 7, -1, -1, -1, 11, 12, 126,
3922  127, 128, 16, -1, 18, 19, 20, 21, 22, 23,
3923  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3924  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3925  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3926  54, 55, 56, 57, 58, 59, 60, -1, 62, 63,
3927  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
3928  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3929  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3930  -1, -1, 96, -1, 98, 99, 100, 101, 102, 103,
3931  104, 105, 106, -1, -1, -1, -1, -1, -1, -1,
3932  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3933  11, 12, 126, 127, 128, 16, -1, 18, 19, 20,
3934  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3935  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3936  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3937  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3938  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3939  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3940  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3941  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
3942  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3943  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
3944  -1, -1, -1, 11, 12, 126, 127, 128, 16, -1,
3945  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3946  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3947  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3948  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3949  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3950  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3951  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3952  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3953  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3954  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
3955  5, -1, 7, -1, -1, -1, 11, 12, 126, 127,
3956  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3957  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3958  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3959  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3960  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3961  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3962  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3963  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3964  95, -1, -1, 98, 99, 100, 101, 102, 103, 104,
3965  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3966  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
3967  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
3968  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3969  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3970  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
3971  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3972  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3973  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3974  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3975  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3976  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3977  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3978  -1, -1, 11, 12, 126, 127, 128, 16, -1, 18,
3979  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3980  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3981  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3982  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3983  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3984  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3985  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3986  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3987  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3988  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3989  -1, 7, -1, -1, -1, 11, 12, 126, 127, 128,
3990  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3991  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3992  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3993  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3994  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3995  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3996  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3997  86, -1, -1, 89, 90, -1, 92, 93, -1, -1,
3998  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
3999  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4000  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4001  126, 127, 128, 16, -1, 18, 19, 20, 21, 22,
4002  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4003  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4004  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4005  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
4006  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
4007  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4008  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
4009  93, -1, -1, -1, -1, 98, 99, 100, 101, 102,
4010  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
4011  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4012  -1, 11, 12, 126, 127, 128, 16, -1, 18, 19,
4013  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4014  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4015  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4016  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4017  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
4018  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4019  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
4020  90, -1, 92, 93, -1, -1, -1, -1, 98, 99,
4021  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
4022  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
4023  7, -1, -1, -1, 11, 12, 126, 127, 128, 16,
4024  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
4025  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4026  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
4027  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
4028  57, -1, 59, 60, -1, 62, 63, 64, -1, -1,
4029  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4030  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
4031  -1, -1, 89, 90, -1, 92, 93, -1, 95, -1,
4032  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
4033  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4034  -1, -1, -1, 11, 12, -1, -1, -1, 16, 126,
4035  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4036  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4037  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4038  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4039  -1, 59, 60, -1, 62, 63, 64, -1, -1, -1,
4040  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4041  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
4042  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
4043  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
4044  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4045  -1, -1, 11, 12, -1, -1, -1, 16, 126, 18,
4046  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4047  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4048  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4049  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4050  59, 60, -1, 62, 63, 64, -1, -1, -1, -1,
4051  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4052  -1, -1, -1, -1, 83, -1, -1, 86, -1, -1,
4053  89, 90, -1, 92, 93, -1, -1, -1, -1, 98,
4054  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
4055  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4056  -1, 11, 12, -1, -1, -1, 16, 126, 18, 19,
4057  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4058  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4059  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4060  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4061  60, -1, 62, 63, 64, -1, -1, -1, -1, -1,
4062  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4063  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
4064  90, -1, 92, 93, -1, -1, -1, -1, 98, 99,
4065  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
4066  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4067  11, 12, -1, -1, -1, 16, 126, 18, 19, 20,
4068  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4069  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4070  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4071  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4072  -1, 62, 63, 64, -1, -1, -1, -1, -1, -1,
4073  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4074  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
4075  -1, 92, 93, -1, -1, -1, -1, 98, 99, 100,
4076  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
4077  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4078  12, -1, -1, -1, 16, 126, 18, 19, 20, 21,
4079  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4080  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4081  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4082  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
4083  62, 63, 64, -1, -1, -1, -1, -1, -1, -1,
4084  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4085  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
4086  92, 93, -1, -1, -1, -1, 98, 99, 100, 101,
4087  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
4088  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4089  -1, -1, -1, 16, 126, 18, 19, 20, 21, 22,
4090  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4091  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4092  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4093  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
4094  63, 64, -1, -1, -1, -1, -1, -1, -1, -1,
4095  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4096  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
4097  93, -1, -1, -1, -1, 98, 99, 100, 101, 102,
4098  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
4099  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
4100  -1, -1, -1, 126, 66, 67, 68, 69, 70, 71,
4101  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
4102  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
4103  -1, -1, -1, 95, 96, -1, -1, -1, -1, -1,
4104  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4105  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
4106  122, 123, 124, 125, -1, 127, 128, 52, 53, -1,
4107  -1, 56, -1, 135, -1, -1, -1, -1, -1, -1,
4108  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
4109  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
4110  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4111  95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
4112  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4113  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
4114  125, -1, 127, 128, 52, 53, -1, -1, 56, -1,
4115  135, -1, -1, -1, -1, -1, -1, -1, 66, 67,
4116  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
4117  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
4118  -1, -1, -1, -1, -1, -1, -1, 95, 96, -1,
4119  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4120  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
4121  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
4122  128, 52, 53, -1, -1, 56, -1, 135, -1, -1,
4123  -1, -1, -1, -1, -1, 66, 67, 68, 69, 70,
4124  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
4125  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
4126  -1, -1, -1, -1, 95, 96, -1, -1, -1, -1,
4127  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4128  -1, -1, -1, -1, -1, 116, 117, 118, 119, 120,
4129  121, 122, 123, 124, 125, -1, 127, 128, 52, 53,
4130  -1, -1, 56, -1, 135, -1, -1, -1, -1, -1,
4131  -1, -1, 66, 67, 68, 69, 70, 71, 72, 73,
4132  74, -1, -1, 77, 78, -1, -1, 81, 82, 83,
4133  84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4134  -1, 95, 96, -1, -1, -1, -1, -1, -1, -1,
4135  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4136  -1, -1, 116, 117, 118, 119, 120, 121, 122, 123,
4137  124, 125, -1, 127, 128, 52, 53, -1, -1, 56,
4138  -1, 135, -1, -1, -1, -1, -1, -1, -1, 66,
4139  67, 68, 69, 70, 71, 72, 73, 74, -1, -1,
4140  77, 78, -1, -1, 81, 82, 83, 84, -1, -1,
4141  -1, -1, -1, -1, -1, -1, -1, -1, 95, 96,
4142  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4143  -1, -1, -1, -1, -1, -1, -1, -1, -1, 116,
4144  117, 118, 119, 120, 121, 122, 123, 124, 125, -1,
4145  127, 128, 52, 53, -1, -1, 56, -1, 135, -1,
4146  -1, -1, -1, -1, -1, -1, 66, 67, 68, 69,
4147  70, 71, 72, 73, 74, -1, -1, 77, 78, -1,
4148  -1, 81, 82, 83, 84, -1, -1, -1, -1, -1,
4149  -1, -1, -1, -1, -1, 95, 96, -1, -1, -1,
4150  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4151  -1, -1, -1, -1, -1, -1, 116, 117, 118, 119,
4152  120, 121, 122, 123, 124, 125, -1, 127, 128, 52,
4153  53, -1, -1, 56, -1, 135, -1, -1, -1, -1,
4154  -1, -1, -1, 66, 67, 68, 69, 70, 71, 72,
4155  73, 74, -1, -1, 77, 78, -1, -1, 81, 82,
4156  83, 84, -1, -1, -1, -1, -1, -1, -1, -1,
4157  -1, -1, 95, 96, -1, -1, -1, -1, -1, -1,
4158  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4159  -1, -1, -1, 116, 117, 118, 119, 120, 121, 122,
4160  123, 124, 125, -1, 127, 128, 52, 53, -1, -1,
4161  56, -1, 135, -1, -1, -1, -1, -1, -1, -1,
4162  66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
4163  -1, 77, 78, -1, -1, 81, 82, 83, 84, -1,
4164  -1, -1, -1, -1, -1, -1, -1, -1, -1, 95,
4165  96, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4166  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4167  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
4168  -1, 127, 128, 52, 53, -1, -1, 56, -1, 135,
4169  -1, -1, -1, -1, -1, -1, -1, 66, 67, 68,
4170  69, 70, 71, 72, 73, 74, -1, -1, 77, 78,
4171  -1, -1, 81, 82, 83, 84, -1, -1, -1, -1,
4172  -1, -1, -1, -1, -1, -1, 95, 96, -1, -1,
4173  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4174  -1, -1, -1, -1, -1, -1, -1, 116, 117, 118,
4175  119, 120, 121, 122, 123, 124, 125, -1, 127, 128,
4176  52, 53, -1, -1, 56, -1, 135, -1, -1, -1,
4177  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
4178  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
4179  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
4180  -1, -1, -1, 95, 96, -1, -1, -1, -1, -1,
4181  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4182  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
4183  122, 123, 124, 125, -1, 127, 128, 52, 53, -1,
4184  -1, 56, -1, 135, -1, -1, -1, -1, -1, -1,
4185  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
4186  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
4187  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4188  95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
4189  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4190  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
4191  125, -1, 127, 128, -1, -1, -1, -1, -1, -1,
4192  135
4193 };
4194 
4195 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4196  symbol of state STATE-NUM. */
4197 static const yytype_uint16 yystos[] =
4198 {
4199  0, 143, 144, 0, 1, 3, 4, 5, 6, 7,
4200  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4201  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4202  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4203  57, 59, 60, 62, 63, 64, 66, 67, 86, 89,
4204  90, 92, 93, 95, 98, 99, 100, 101, 102, 103,
4205  104, 105, 106, 126, 127, 128, 145, 146, 147, 154,
4206  156, 157, 159, 160, 163, 164, 165, 167, 168, 169,
4207  171, 172, 182, 196, 215, 216, 217, 218, 219, 220,
4208  221, 222, 223, 224, 225, 251, 252, 266, 267, 268,
4209  269, 270, 271, 272, 275, 277, 278, 290, 292, 293,
4210  294, 295, 296, 297, 298, 329, 340, 147, 3, 4,
4211  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
4212  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
4213  25, 26, 30, 31, 32, 33, 34, 35, 36, 37,
4214  38, 39, 45, 46, 47, 48, 49, 50, 51, 52,
4215  53, 56, 66, 67, 68, 69, 70, 71, 72, 73,
4216  74, 77, 78, 81, 82, 83, 84, 95, 96, 116,
4217  117, 118, 119, 120, 121, 122, 123, 124, 125, 127,
4218  128, 135, 175, 176, 177, 178, 180, 181, 290, 292,
4219  39, 58, 86, 89, 95, 96, 97, 127, 164, 172,
4220  182, 184, 189, 192, 194, 215, 294, 295, 297, 298,
4221  327, 328, 189, 189, 136, 190, 191, 136, 186, 190,
4222  136, 141, 334, 54, 177, 334, 148, 130, 21, 22,
4223  30, 31, 32, 163, 182, 215, 182, 56, 1, 47,
4224  89, 150, 151, 152, 154, 166, 167, 340, 198, 199,
4225  185, 194, 327, 340, 184, 326, 327, 340, 46, 86,
4226  126, 134, 171, 196, 215, 294, 295, 298, 243, 244,
4227  54, 55, 57, 175, 282, 291, 281, 282, 283, 140,
4228  273, 140, 279, 140, 276, 140, 280, 59, 60, 159,
4229  182, 182, 139, 141, 333, 338, 339, 40, 41, 42,
4230  43, 44, 37, 38, 26, 130, 186, 190, 257, 28,
4231  249, 113, 134, 89, 95, 168, 113, 68, 69, 70,
4232  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
4233  83, 84, 114, 116, 117, 118, 119, 120, 121, 122,
4234  123, 124, 125, 85, 132, 133, 197, 157, 158, 158,
4235  202, 204, 158, 333, 339, 86, 165, 172, 215, 231,
4236  294, 295, 298, 52, 56, 83, 86, 173, 174, 215,
4237  294, 295, 298, 174, 33, 34, 35, 36, 49, 50,
4238  51, 52, 56, 136, 175, 296, 324, 85, 133, 332,
4239  257, 269, 87, 87, 134, 184, 56, 184, 184, 184,
4240  113, 88, 134, 193, 340, 85, 132, 133, 87, 87,
4241  134, 193, 189, 334, 335, 189, 188, 189, 194, 327,
4242  340, 157, 335, 157, 54, 63, 64, 155, 136, 183,
4243  130, 150, 85, 133, 87, 154, 153, 166, 137, 333,
4244  339, 335, 335, 157, 138, 134, 141, 337, 134, 337,
4245  131, 337, 334, 56, 59, 60, 168, 170, 134, 85,
4246  132, 133, 245, 61, 107, 109, 110, 284, 110, 284,
4247  110, 65, 284, 110, 110, 274, 284, 110, 61, 110,
4248  110, 110, 274, 110, 61, 110, 68, 68, 139, 147,
4249  158, 158, 158, 158, 154, 157, 157, 259, 258, 94,
4250  161, 250, 95, 159, 184, 194, 195, 166, 134, 171,
4251  134, 156, 159, 172, 182, 184, 195, 182, 182, 182,
4252  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
4253  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
4254  182, 182, 182, 52, 53, 56, 180, 256, 330, 331,
4255  188, 52, 53, 56, 180, 255, 330, 149, 150, 13,
4256  227, 338, 227, 158, 158, 333, 17, 260, 56, 85,
4257  132, 133, 25, 157, 52, 56, 173, 1, 117, 299,
4258  338, 85, 132, 133, 211, 325, 212, 332, 52, 56,
4259  330, 159, 182, 159, 182, 179, 182, 184, 95, 184,
4260  192, 327, 52, 56, 188, 52, 56, 328, 335, 137,
4261  335, 134, 134, 335, 177, 201, 182, 145, 131, 330,
4262  330, 182, 130, 335, 152, 200, 327, 134, 170, 52,
4263  56, 188, 52, 56, 52, 54, 55, 56, 57, 58,
4264  68, 89, 95, 96, 97, 120, 123, 136, 247, 302,
4265  304, 305, 306, 307, 308, 309, 312, 313, 314, 315,
4266  318, 319, 320, 321, 322, 286, 285, 140, 284, 140,
4267  140, 140, 182, 182, 76, 118, 238, 239, 340, 238,
4268  162, 238, 184, 134, 335, 170, 134, 113, 44, 334,
4269  87, 87, 186, 190, 254, 334, 336, 87, 87, 186,
4270  190, 253, 10, 226, 8, 262, 340, 150, 13, 150,
4271  27, 228, 338, 228, 260, 194, 226, 52, 56, 188,
4272  52, 56, 206, 209, 338, 300, 208, 52, 56, 173,
4273  188, 149, 157, 136, 301, 304, 213, 186, 187, 190,
4274  340, 44, 177, 184, 193, 87, 87, 336, 87, 87,
4275  327, 157, 131, 145, 335, 337, 168, 336, 113, 184,
4276  52, 89, 95, 232, 233, 234, 306, 304, 246, 134,
4277  303, 134, 323, 340, 52, 134, 323, 134, 303, 52,
4278  134, 303, 52, 287, 54, 55, 57, 289, 298, 52,
4279  58, 235, 237, 240, 308, 310, 311, 314, 316, 317,
4280  320, 322, 334, 150, 150, 238, 150, 95, 184, 170,
4281  182, 115, 159, 182, 159, 182, 161, 186, 138, 87,
4282  159, 182, 159, 182, 161, 187, 184, 195, 263, 340,
4283  15, 230, 340, 14, 229, 230, 230, 203, 205, 226,
4284  134, 227, 336, 158, 338, 158, 149, 336, 226, 335,
4285  304, 149, 338, 175, 257, 249, 182, 87, 134, 335,
4286  131, 184, 234, 134, 306, 134, 335, 240, 29, 111,
4287  248, 302, 307, 318, 320, 309, 314, 322, 308, 315,
4288  320, 308, 288, 113, 86, 215, 240, 118, 134, 236,
4289  134, 323, 323, 134, 236, 134, 236, 139, 10, 131,
4290  150, 10, 184, 182, 159, 182, 88, 264, 340, 150,
4291  9, 265, 340, 158, 226, 226, 150, 150, 184, 150,
4292  228, 210, 338, 226, 335, 226, 214, 335, 233, 134,
4293  95, 232, 137, 150, 150, 134, 303, 134, 303, 323,
4294  134, 303, 134, 303, 303, 150, 215, 56, 85, 118,
4295  235, 317, 320, 310, 314, 308, 316, 320, 308, 52,
4296  241, 242, 305, 131, 86, 172, 215, 294, 295, 298,
4297  227, 150, 227, 226, 226, 230, 260, 261, 207, 149,
4298  301, 134, 233, 134, 306, 10, 131, 308, 320, 308,
4299  308, 108, 52, 56, 134, 236, 134, 236, 323, 134,
4300  236, 134, 236, 236, 134, 334, 56, 85, 132, 133,
4301  150, 150, 150, 226, 149, 233, 134, 303, 134, 303,
4302  303, 303, 308, 320, 308, 308, 242, 52, 56, 188,
4303  52, 56, 262, 229, 226, 226, 233, 308, 236, 134,
4304  236, 236, 236, 336, 303, 308, 236
4305 };
4306 
4307 #define yyerrok (yyerrstatus = 0)
4308 #define yyclearin (yychar = YYEMPTY)
4309 #define YYEMPTY (-2)
4310 #define YYEOF 0
4311 
4312 #define YYACCEPT goto yyacceptlab
4313 #define YYABORT goto yyabortlab
4314 #define YYERROR goto yyerrorlab
4315 
4316 
4317 /* Like YYERROR except do call yyerror. This remains here temporarily
4318  to ease the transition to the new meaning of YYERROR, for GCC.
4319  Once GCC version 2 has supplanted version 1, this can go. However,
4320  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
4321  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
4322  discussed. */
4323 
4324 #define YYFAIL goto yyerrlab
4325 #if defined YYFAIL
4326  /* This is here to suppress warnings from the GCC cpp's
4327  -Wunused-macros. Normally we don't worry about that warning, but
4328  some users do, and we want to make it easy for users to remove
4329  YYFAIL uses, which will produce warnings from Bison 2.5. */
4330 #endif
4331 
4332 #define YYRECOVERING() (!!yyerrstatus)
4333 
4334 #define YYBACKUP(Token, Value) \
4335 do \
4336  if (yychar == YYEMPTY && yylen == 1) \
4337  { \
4338  yychar = (Token); \
4339  yylval = (Value); \
4340  YYPOPSTACK (1); \
4341  goto yybackup; \
4342  } \
4343  else \
4344  { \
4345  parser_yyerror (parser, YY_("syntax error: cannot back up")); \
4346  YYERROR; \
4347  } \
4348 while (YYID (0))
4349 
4350 
4351 #define YYTERROR 1
4352 #define YYERRCODE 256
4353 
4354 
4355 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
4356  If N is 0, then set CURRENT to the empty location which ends
4357  the previous symbol: RHS[0] (always defined). */
4358 
4359 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
4360 #ifndef YYLLOC_DEFAULT
4361 # define YYLLOC_DEFAULT(Current, Rhs, N) \
4362  do \
4363  if (YYID (N)) \
4364  { \
4365  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
4366  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
4367  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
4368  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
4369  } \
4370  else \
4371  { \
4372  (Current).first_line = (Current).last_line = \
4373  YYRHSLOC (Rhs, 0).last_line; \
4374  (Current).first_column = (Current).last_column = \
4375  YYRHSLOC (Rhs, 0).last_column; \
4376  } \
4377  while (YYID (0))
4378 #endif
4379 
4380 
4381 /* This macro is provided for backward compatibility. */
4382 
4383 #ifndef YY_LOCATION_PRINT
4384 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
4385 #endif
4386 
4387 
4388 /* YYLEX -- calling `yylex' with the right arguments. */
4389 
4390 #ifdef YYLEX_PARAM
4391 # define YYLEX yylex (&yylval, YYLEX_PARAM)
4392 #else
4393 # define YYLEX yylex (&yylval, parser)
4394 #endif
4395 
4396 /* Enable debugging if requested. */
4397 #if YYDEBUG
4398 
4399 # ifndef YYFPRINTF
4400 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
4401 # define YYFPRINTF fprintf
4402 # endif
4403 
4404 # define YYDPRINTF(Args) \
4405 do { \
4406  if (yydebug) \
4407  YYFPRINTF Args; \
4408 } while (YYID (0))
4409 
4410 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
4411 do { \
4412  if (yydebug) \
4413  { \
4414  YYFPRINTF (stderr, "%s ", Title); \
4415  yy_symbol_print (stderr, \
4416  Type, Value, parser); \
4417  YYFPRINTF (stderr, "\n"); \
4418  } \
4419 } while (YYID (0))
4420 
4421 
4422 /*--------------------------------.
4423 | Print this symbol on YYOUTPUT. |
4424 `--------------------------------*/
4425 
4426 /*ARGSUSED*/
4427 #if (defined __STDC__ || defined __C99__FUNC__ \
4428  || defined __cplusplus || defined _MSC_VER)
4429 static void
4430 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4431 #else
4432 static void
4433 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
4434  FILE *yyoutput;
4435  int yytype;
4436  YYSTYPE const * const yyvaluep;
4437  struct parser_params *parser;
4438 #endif
4439 {
4440  if (!yyvaluep)
4441  return;
4442  YYUSE (parser);
4443 # ifdef YYPRINT
4444  if (yytype < YYNTOKENS)
4445  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4446 # else
4447  YYUSE (yyoutput);
4448 # endif
4449  switch (yytype)
4450  {
4451  default:
4452  break;
4453  }
4454 }
4455 
4456 
4457 /*--------------------------------.
4458 | Print this symbol on YYOUTPUT. |
4459 `--------------------------------*/
4460 
4461 #if (defined __STDC__ || defined __C99__FUNC__ \
4462  || defined __cplusplus || defined _MSC_VER)
4463 static void
4464 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4465 #else
4466 static void
4467 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
4468  FILE *yyoutput;
4469  int yytype;
4470  YYSTYPE const * const yyvaluep;
4471  struct parser_params *parser;
4472 #endif
4473 {
4474  if (yytype < YYNTOKENS)
4475  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4476  else
4477  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4478 
4479  yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
4480  YYFPRINTF (yyoutput, ")");
4481 }
4482 
4483 /*------------------------------------------------------------------.
4484 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4485 | TOP (included). |
4486 `------------------------------------------------------------------*/
4487 
4488 #if (defined __STDC__ || defined __C99__FUNC__ \
4489  || defined __cplusplus || defined _MSC_VER)
4490 static void
4491 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4492 #else
4493 static void
4494 yy_stack_print (yybottom, yytop)
4495  yytype_int16 *yybottom;
4496  yytype_int16 *yytop;
4497 #endif
4498 {
4499  YYFPRINTF (stderr, "Stack now");
4500  for (; yybottom <= yytop; yybottom++)
4501  {
4502  int yybot = *yybottom;
4503  YYFPRINTF (stderr, " %d", yybot);
4504  }
4505  YYFPRINTF (stderr, "\n");
4506 }
4507 
4508 # define YY_STACK_PRINT(Bottom, Top) \
4509 do { \
4510  if (yydebug) \
4511  yy_stack_print ((Bottom), (Top)); \
4512 } while (YYID (0))
4513 
4514 
4515 /*------------------------------------------------.
4516 | Report that the YYRULE is going to be reduced. |
4517 `------------------------------------------------*/
4518 
4519 #if (defined __STDC__ || defined __C99__FUNC__ \
4520  || defined __cplusplus || defined _MSC_VER)
4521 static void
4522 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
4523 #else
4524 static void
4525 yy_reduce_print (yyvsp, yyrule, parser)
4526  YYSTYPE *yyvsp;
4527  int yyrule;
4528  struct parser_params *parser;
4529 #endif
4530 {
4531  int yynrhs = yyr2[yyrule];
4532  int yyi;
4533  unsigned long int yylno = yyrline[yyrule];
4534  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4535  yyrule - 1, yylno);
4536  /* The symbols being reduced. */
4537  for (yyi = 0; yyi < yynrhs; yyi++)
4538  {
4539  YYFPRINTF (stderr, " $%d = ", yyi + 1);
4540  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4541  &(yyvsp[(yyi + 1) - (yynrhs)])
4542  , parser);
4543  YYFPRINTF (stderr, "\n");
4544  }
4545 }
4546 
4547 # define YY_REDUCE_PRINT(Rule) \
4548 do { \
4549  if (yydebug) \
4550  yy_reduce_print (yyvsp, Rule, parser); \
4551 } while (YYID (0))
4552 
4553 /* Nonzero means print parse trace. It is left uninitialized so that
4554  multiple parsers can coexist. */
4555 #ifndef yydebug
4556 int yydebug;
4557 #endif
4558 #else /* !YYDEBUG */
4559 # define YYDPRINTF(Args)
4560 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4561 # define YY_STACK_PRINT(Bottom, Top)
4562 # define YY_REDUCE_PRINT(Rule)
4563 #endif /* !YYDEBUG */
4564 
4565 
4566 /* YYINITDEPTH -- initial size of the parser's stacks. */
4567 #ifndef YYINITDEPTH
4568 # define YYINITDEPTH 200
4569 #endif
4570 
4571 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4572  if the built-in stack extension method is used).
4573 
4574  Do not make this value too large; the results are undefined if
4575  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4576  evaluated with infinite-precision integer arithmetic. */
4577 
4578 #ifndef YYMAXDEPTH
4579 # define YYMAXDEPTH 10000
4580 #endif
4581 
4582 
4583 #if YYERROR_VERBOSE
4584 
4585 # ifndef yystrlen
4586 # if defined __GLIBC__ && defined _STRING_H
4587 # define yystrlen strlen
4588 # else
4589 /* Return the length of YYSTR. */
4590 #if (defined __STDC__ || defined __C99__FUNC__ \
4591  || defined __cplusplus || defined _MSC_VER)
4592 static YYSIZE_T
4593 yystrlen (const char *yystr)
4594 #else
4595 static YYSIZE_T
4596 yystrlen (yystr)
4597  const char *yystr;
4598 #endif
4599 {
4600  YYSIZE_T yylen;
4601  for (yylen = 0; yystr[yylen]; yylen++)
4602  continue;
4603  return yylen;
4604 }
4605 # endif
4606 # endif
4607 
4608 # ifndef yystpcpy
4609 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4610 # define yystpcpy stpcpy
4611 # else
4612 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4613  YYDEST. */
4614 #if (defined __STDC__ || defined __C99__FUNC__ \
4615  || defined __cplusplus || defined _MSC_VER)
4616 static char *
4617 yystpcpy (char *yydest, const char *yysrc)
4618 #else
4619 static char *
4620 yystpcpy (yydest, yysrc)
4621  char *yydest;
4622  const char *yysrc;
4623 #endif
4624 {
4625  char *yyd = yydest;
4626  const char *yys = yysrc;
4627 
4628  while ((*yyd++ = *yys++) != '\0')
4629  continue;
4630 
4631  return yyd - 1;
4632 }
4633 # endif
4634 # endif
4635 
4636 # ifndef yytnamerr
4637 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4638  quotes and backslashes, so that it's suitable for yyerror. The
4639  heuristic is that double-quoting is unnecessary unless the string
4640  contains an apostrophe, a comma, or backslash (other than
4641  backslash-backslash). YYSTR is taken from yytname. If YYRES is
4642  null, do not copy; instead, return the length of what the result
4643  would have been. */
4644 static YYSIZE_T
4645 yytnamerr (char *yyres, const char *yystr)
4646 {
4647  if (*yystr == '"')
4648  {
4649  YYSIZE_T yyn = 0;
4650  char const *yyp = yystr;
4651 
4652  for (;;)
4653  switch (*++yyp)
4654  {
4655  case '\'':
4656  case ',':
4657  goto do_not_strip_quotes;
4658 
4659  case '\\':
4660  if (*++yyp != '\\')
4661  goto do_not_strip_quotes;
4662  /* Fall through. */
4663  default:
4664  if (yyres)
4665  yyres[yyn] = *yyp;
4666  yyn++;
4667  break;
4668 
4669  case '"':
4670  if (yyres)
4671  yyres[yyn] = '\0';
4672  return yyn;
4673  }
4674  do_not_strip_quotes: ;
4675  }
4676 
4677  if (! yyres)
4678  return yystrlen (yystr);
4679 
4680  return yystpcpy (yyres, yystr) - yyres;
4681 }
4682 # endif
4683 
4684 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
4685  about the unexpected token YYTOKEN for the state stack whose top is
4686  YYSSP.
4687 
4688  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
4689  not large enough to hold the message. In that case, also set
4690  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
4691  required number of bytes is too large to store. */
4692 static int
4693 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
4694  yytype_int16 *yyssp, int yytoken)
4695 {
4696  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
4697  YYSIZE_T yysize = yysize0;
4698  YYSIZE_T yysize1;
4699  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4700  /* Internationalized format string. */
4701  const char *yyformat = 0;
4702  /* Arguments of yyformat. */
4703  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4704  /* Number of reported tokens (one for the "unexpected", one per
4705  "expected"). */
4706  int yycount = 0;
4707 
4708  /* There are many possibilities here to consider:
4709  - Assume YYFAIL is not used. It's too flawed to consider. See
4710  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
4711  for details. YYERROR is fine as it does not invoke this
4712  function.
4713  - If this state is a consistent state with a default action, then
4714  the only way this function was invoked is if the default action
4715  is an error action. In that case, don't check for expected
4716  tokens because there are none.
4717  - The only way there can be no lookahead present (in yychar) is if
4718  this state is a consistent state with a default action. Thus,
4719  detecting the absence of a lookahead is sufficient to determine
4720  that there is no unexpected or expected token to report. In that
4721  case, just report a simple "syntax error".
4722  - Don't assume there isn't a lookahead just because this state is a
4723  consistent state with a default action. There might have been a
4724  previous inconsistent state, consistent state with a non-default
4725  action, or user semantic action that manipulated yychar.
4726  - Of course, the expected token list depends on states to have
4727  correct lookahead information, and it depends on the parser not
4728  to perform extra reductions after fetching a lookahead from the
4729  scanner and before detecting a syntax error. Thus, state merging
4730  (from LALR or IELR) and default reductions corrupt the expected
4731  token list. However, the list is correct for canonical LR with
4732  one exception: it will still contain any token that will not be
4733  accepted due to an error action in a later state.
4734  */
4735  if (yytoken != YYEMPTY)
4736  {
4737  int yyn = yypact[*yyssp];
4738  yyarg[yycount++] = yytname[yytoken];
4739  if (!yypact_value_is_default (yyn))
4740  {
4741  /* Start YYX at -YYN if negative to avoid negative indexes in
4742  YYCHECK. In other words, skip the first -YYN actions for
4743  this state because they are default actions. */
4744  int yyxbegin = yyn < 0 ? -yyn : 0;
4745  /* Stay within bounds of both yycheck and yytname. */
4746  int yychecklim = YYLAST - yyn + 1;
4747  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4748  int yyx;
4749 
4750  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4751  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
4752  && !yytable_value_is_error (yytable[yyx + yyn]))
4753  {
4754  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4755  {
4756  yycount = 1;
4757  yysize = yysize0;
4758  break;
4759  }
4760  yyarg[yycount++] = yytname[yyx];
4761  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4762  if (! (yysize <= yysize1
4763  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4764  return 2;
4765  yysize = yysize1;
4766  }
4767  }
4768  }
4769 
4770  switch (yycount)
4771  {
4772 # define YYCASE_(N, S) \
4773  case N: \
4774  yyformat = S; \
4775  break
4776  YYCASE_(0, YY_("syntax error"));
4777  YYCASE_(1, YY_("syntax error, unexpected %s"));
4778  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
4779  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
4780  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
4781  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
4782 # undef YYCASE_
4783  }
4784 
4785  yysize1 = yysize + yystrlen (yyformat);
4786  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4787  return 2;
4788  yysize = yysize1;
4789 
4790  if (*yymsg_alloc < yysize)
4791  {
4792  *yymsg_alloc = 2 * yysize;
4793  if (! (yysize <= *yymsg_alloc
4794  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
4795  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
4796  return 1;
4797  }
4798 
4799  /* Avoid sprintf, as that infringes on the user's name space.
4800  Don't have undefined behavior even if the translation
4801  produced a string with the wrong number of "%s"s. */
4802  {
4803  char *yyp = *yymsg;
4804  int yyi = 0;
4805  while ((*yyp = *yyformat) != '\0')
4806  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
4807  {
4808  yyp += yytnamerr (yyp, yyarg[yyi++]);
4809  yyformat += 2;
4810  }
4811  else
4812  {
4813  yyp++;
4814  yyformat++;
4815  }
4816  }
4817  return 0;
4818 }
4819 #endif /* YYERROR_VERBOSE */
4820 
4821 /*-----------------------------------------------.
4822 | Release the memory associated to this symbol. |
4823 `-----------------------------------------------*/
4824 
4825 /*ARGSUSED*/
4826 #if (defined __STDC__ || defined __C99__FUNC__ \
4827  || defined __cplusplus || defined _MSC_VER)
4828 static void
4829 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
4830 #else
4831 static void
4832 yydestruct (yymsg, yytype, yyvaluep, parser)
4833  const char *yymsg;
4834  int yytype;
4835  YYSTYPE *yyvaluep;
4836  struct parser_params *parser;
4837 #endif
4838 {
4839  YYUSE (yyvaluep);
4840  YYUSE (parser);
4841 
4842  if (!yymsg)
4843  yymsg = "Deleting";
4844  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4845 
4846  switch (yytype)
4847  {
4848 
4849  default:
4850  break;
4851  }
4852 }
4853 
4854 
4855 /* Prevent warnings from -Wmissing-prototypes. */
4856 #ifdef YYPARSE_PARAM
4857 #if defined __STDC__ || defined __cplusplus
4858 int yyparse (void *YYPARSE_PARAM);
4859 #else
4860 int yyparse ();
4861 #endif
4862 #else /* ! YYPARSE_PARAM */
4863 #if defined __STDC__ || defined __cplusplus
4864 int yyparse (struct parser_params *parser);
4865 #else
4866 int yyparse ();
4867 #endif
4868 #endif /* ! YYPARSE_PARAM */
4869 
4870 
4871 /*----------.
4872 | yyparse. |
4873 `----------*/
4874 
4875 #ifdef YYPARSE_PARAM
4876 #if (defined __STDC__ || defined __C99__FUNC__ \
4877  || defined __cplusplus || defined _MSC_VER)
4878 int
4879 yyparse (void *YYPARSE_PARAM)
4880 #else
4881 int
4882 yyparse (YYPARSE_PARAM)
4883  void *YYPARSE_PARAM;
4884 #endif
4885 #else /* ! YYPARSE_PARAM */
4886 #if (defined __STDC__ || defined __C99__FUNC__ \
4887  || defined __cplusplus || defined _MSC_VER)
4888 int
4889 yyparse (struct parser_params *parser)
4890 #else
4891 int
4892 yyparse (parser)
4893  struct parser_params *parser;
4894 #endif
4895 #endif
4896 {
4897 /* The lookahead symbol. */
4898 int yychar;
4899 
4900 /* The semantic value of the lookahead symbol. */
4901 YYSTYPE yylval;
4902 
4903  /* Number of syntax errors so far. */
4904  int yynerrs;
4905 
4906  int yystate;
4907  /* Number of tokens to shift before error messages enabled. */
4908  int yyerrstatus;
4909 
4910  /* The stacks and their tools:
4911  `yyss': related to states.
4912  `yyvs': related to semantic values.
4913 
4914  Refer to the stacks thru separate pointers, to allow yyoverflow
4915  to reallocate them elsewhere. */
4916 
4917  /* The state stack. */
4918  yytype_int16 yyssa[YYINITDEPTH];
4919  yytype_int16 *yyss;
4920  yytype_int16 *yyssp;
4921 
4922  /* The semantic value stack. */
4923  YYSTYPE yyvsa[YYINITDEPTH];
4924  YYSTYPE *yyvs;
4925  YYSTYPE *yyvsp;
4926 
4927  YYSIZE_T yystacksize;
4928 
4929  int yyn;
4930  int yyresult;
4931  /* Lookahead token as an internal (translated) token number. */
4932  int yytoken;
4933  /* The variables used to return semantic value and location from the
4934  action routines. */
4935  YYSTYPE yyval;
4936 
4937 #if YYERROR_VERBOSE
4938  /* Buffer for error messages, and its allocated size. */
4939  char yymsgbuf[128];
4940  char *yymsg = yymsgbuf;
4941  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
4942 #endif
4943 
4944 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
4945 
4946  /* The number of symbols on the RHS of the reduced rule.
4947  Keep to zero when no symbol should be popped. */
4948  int yylen = 0;
4949 
4950  yytoken = 0;
4951  yyss = yyssa;
4952  yyvs = yyvsa;
4953  yystacksize = YYINITDEPTH;
4954 
4955  YYDPRINTF ((stderr, "Starting parse\n"));
4956 
4957  yystate = 0;
4958  yyerrstatus = 0;
4959  yynerrs = 0;
4960  yychar = YYEMPTY; /* Cause a token to be read. */
4961 
4962  /* Initialize stack pointers.
4963  Waste one element of value and location stack
4964  so that they stay on the same level as the state stack.
4965  The wasted elements are never initialized. */
4966  yyssp = yyss;
4967  yyvsp = yyvs;
4968 
4969  goto yysetstate;
4970 
4971 /*------------------------------------------------------------.
4972 | yynewstate -- Push a new state, which is found in yystate. |
4973 `------------------------------------------------------------*/
4974  yynewstate:
4975  /* In all cases, when you get here, the value and location stacks
4976  have just been pushed. So pushing a state here evens the stacks. */
4977  yyssp++;
4978 
4979  yysetstate:
4980  *yyssp = yystate;
4981 
4982  if (yyss + yystacksize - 1 <= yyssp)
4983  {
4984  /* Get the current used size of the three stacks, in elements. */
4985  YYSIZE_T yysize = yyssp - yyss + 1;
4986 
4987 #ifdef yyoverflow
4988  {
4989  /* Give user a chance to reallocate the stack. Use copies of
4990  these so that the &'s don't force the real ones into
4991  memory. */
4992  YYSTYPE *yyvs1 = yyvs;
4993  yytype_int16 *yyss1 = yyss;
4994 
4995  /* Each stack pointer address is followed by the size of the
4996  data in use in that stack, in bytes. This used to be a
4997  conditional around just the two extra args, but that might
4998  be undefined if yyoverflow is a macro. */
4999  yyoverflow (YY_("memory exhausted"),
5000  &yyss1, yysize * sizeof (*yyssp),
5001  &yyvs1, yysize * sizeof (*yyvsp),
5002  &yystacksize);
5003 
5004  yyss = yyss1;
5005  yyvs = yyvs1;
5006  }
5007 #else /* no yyoverflow */
5008 # ifndef YYSTACK_RELOCATE
5009  goto yyexhaustedlab;
5010 # else
5011  /* Extend the stack our own way. */
5012  if (YYMAXDEPTH <= yystacksize)
5013  goto yyexhaustedlab;
5014  yystacksize *= 2;
5015  if (YYMAXDEPTH < yystacksize)
5016  yystacksize = YYMAXDEPTH;
5017 
5018  {
5019  yytype_int16 *yyss1 = yyss;
5020  union yyalloc *yyptr =
5021  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
5022  if (! yyptr)
5023  goto yyexhaustedlab;
5024  YYSTACK_RELOCATE (yyss_alloc, yyss);
5025  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
5026 # undef YYSTACK_RELOCATE
5027  if (yyss1 != yyssa)
5028  YYSTACK_FREE (yyss1);
5029  }
5030 # endif
5031 #endif /* no yyoverflow */
5032 
5033  yyssp = yyss + yysize - 1;
5034  yyvsp = yyvs + yysize - 1;
5035 
5036  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
5037  (unsigned long int) yystacksize));
5038 
5039  if (yyss + yystacksize - 1 <= yyssp)
5040  YYABORT;
5041  }
5042 
5043  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
5044 
5045  if (yystate == YYFINAL)
5046  YYACCEPT;
5047 
5048  goto yybackup;
5049 
5050 /*-----------.
5051 | yybackup. |
5052 `-----------*/
5053 yybackup:
5054 
5055  /* Do appropriate processing given the current state. Read a
5056  lookahead token if we need one and don't already have one. */
5057 
5058  /* First try to decide what to do without reference to lookahead token. */
5059  yyn = yypact[yystate];
5060  if (yypact_value_is_default (yyn))
5061  goto yydefault;
5062 
5063  /* Not known => get a lookahead token if don't already have one. */
5064 
5065  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5066  if (yychar == YYEMPTY)
5067  {
5068  YYDPRINTF ((stderr, "Reading a token: "));
5069  yychar = YYLEX;
5070  }
5071 
5072  if (yychar <= YYEOF)
5073  {
5074  yychar = yytoken = YYEOF;
5075  YYDPRINTF ((stderr, "Now at end of input.\n"));
5076  }
5077  else
5078  {
5079  yytoken = YYTRANSLATE (yychar);
5080  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
5081  }
5082 
5083  /* If the proper action on seeing token YYTOKEN is to reduce or to
5084  detect an error, take that action. */
5085  yyn += yytoken;
5086  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
5087  goto yydefault;
5088  yyn = yytable[yyn];
5089  if (yyn <= 0)
5090  {
5091  if (yytable_value_is_error (yyn))
5092  goto yyerrlab;
5093  yyn = -yyn;
5094  goto yyreduce;
5095  }
5096 
5097  /* Count tokens shifted since error; after three, turn off error
5098  status. */
5099  if (yyerrstatus)
5100  yyerrstatus--;
5101 
5102  /* Shift the lookahead token. */
5103  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
5104 
5105  /* Discard the shifted token. */
5106  yychar = YYEMPTY;
5107 
5108  yystate = yyn;
5109  *++yyvsp = yylval;
5110 
5111  goto yynewstate;
5112 
5113 
5114 /*-----------------------------------------------------------.
5115 | yydefault -- do the default action for the current state. |
5116 `-----------------------------------------------------------*/
5117 yydefault:
5118  yyn = yydefact[yystate];
5119  if (yyn == 0)
5120  goto yyerrlab;
5121  goto yyreduce;
5122 
5123 
5124 /*-----------------------------.
5125 | yyreduce -- Do a reduction. |
5126 `-----------------------------*/
5127 yyreduce:
5128  /* yyn is the number of a rule to reduce with. */
5129  yylen = yyr2[yyn];
5130 
5131  /* If YYLEN is nonzero, implement the default value of the action:
5132  `$$ = $1'.
5133 
5134  Otherwise, the following line sets YYVAL to garbage.
5135  This behavior is undocumented and Bison
5136  users should not rely upon it. Assigning to YYVAL
5137  unconditionally makes the parser a bit smaller, and it avoids a
5138  GCC warning that YYVAL may be used uninitialized. */
5139  yyval = yyvsp[1-yylen];
5140 
5141 
5142  YY_REDUCE_PRINT (yyn);
5143  switch (yyn)
5144  {
5145  case 2:
5146 
5147 /* Line 1806 of yacc.c */
5148 #line 855 "parse.y"
5149  {
5150  lex_state = EXPR_BEG;
5151  /*%%%*/
5153  /*%
5154  local_push(0);
5155  %*/
5156  }
5157  break;
5158 
5159  case 3:
5160 
5161 /* Line 1806 of yacc.c */
5162 #line 864 "parse.y"
5163  {
5164  /*%%%*/
5165  if ((yyvsp[(2) - (2)].node) && !compile_for_eval) {
5166  /* last expression should not be void */
5167  if (nd_type((yyvsp[(2) - (2)].node)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].node));
5168  else {
5169  NODE *node = (yyvsp[(2) - (2)].node);
5170  while (node->nd_next) {
5171  node = node->nd_next;
5172  }
5173  void_expr(node->nd_head);
5174  }
5175  }
5176  ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].node)));
5177  /*%
5178  $$ = $2;
5179  parser->result = dispatch1(program, $$);
5180  %*/
5181  local_pop();
5182  }
5183  break;
5184 
5185  case 4:
5186 
5187 /* Line 1806 of yacc.c */
5188 #line 887 "parse.y"
5189  {
5190  /*%%%*/
5191  void_stmts((yyvsp[(1) - (2)].node));
5193  /*%
5194  %*/
5195  (yyval.node) = (yyvsp[(1) - (2)].node);
5196  }
5197  break;
5198 
5199  case 5:
5200 
5201 /* Line 1806 of yacc.c */
5202 #line 898 "parse.y"
5203  {
5204  /*%%%*/
5205  (yyval.node) = NEW_BEGIN(0);
5206  /*%
5207  $$ = dispatch2(stmts_add, dispatch0(stmts_new),
5208  dispatch0(void_stmt));
5209  %*/
5210  }
5211  break;
5212 
5213  case 6:
5214 
5215 /* Line 1806 of yacc.c */
5216 #line 907 "parse.y"
5217  {
5218  /*%%%*/
5219  (yyval.node) = newline_node((yyvsp[(1) - (1)].node));
5220  /*%
5221  $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
5222  %*/
5223  }
5224  break;
5225 
5226  case 7:
5227 
5228 /* Line 1806 of yacc.c */
5229 #line 915 "parse.y"
5230  {
5231  /*%%%*/
5232  (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node)));
5233  /*%
5234  $$ = dispatch2(stmts_add, $1, $3);
5235  %*/
5236  }
5237  break;
5238 
5239  case 8:
5240 
5241 /* Line 1806 of yacc.c */
5242 #line 923 "parse.y"
5243  {
5244  (yyval.node) = remove_begin((yyvsp[(2) - (2)].node));
5245  }
5246  break;
5247 
5248  case 10:
5249 
5250 /* Line 1806 of yacc.c */
5251 #line 930 "parse.y"
5252  {
5253  /*%%%*/
5254  /* local_push(0); */
5255  /*%
5256  %*/
5257  }
5258  break;
5259 
5260  case 11:
5261 
5262 /* Line 1806 of yacc.c */
5263 #line 937 "parse.y"
5264  {
5265  /*%%%*/
5267  (yyvsp[(4) - (5)].node));
5268  /* NEW_PREEXE($4)); */
5269  /* local_pop(); */
5270  (yyval.node) = NEW_BEGIN(0);
5271  /*%
5272  $$ = dispatch1(BEGIN, $4);
5273  %*/
5274  }
5275  break;
5276 
5277  case 12:
5278 
5279 /* Line 1806 of yacc.c */
5280 #line 954 "parse.y"
5281  {
5282  /*%%%*/
5283  (yyval.node) = (yyvsp[(1) - (4)].node);
5284  if ((yyvsp[(2) - (4)].node)) {
5285  (yyval.node) = NEW_RESCUE((yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].node), (yyvsp[(3) - (4)].node));
5286  }
5287  else if ((yyvsp[(3) - (4)].node)) {
5288  rb_warn0("else without rescue is useless");
5289  (yyval.node) = block_append((yyval.node), (yyvsp[(3) - (4)].node));
5290  }
5291  if ((yyvsp[(4) - (4)].node)) {
5292  if ((yyval.node)) {
5293  (yyval.node) = NEW_ENSURE((yyval.node), (yyvsp[(4) - (4)].node));
5294  }
5295  else {
5296  (yyval.node) = block_append((yyvsp[(4) - (4)].node), NEW_NIL());
5297  }
5298  }
5299  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
5300  /*%
5301  $$ = dispatch4(bodystmt,
5302  escape_Qundef($1),
5303  escape_Qundef($2),
5304  escape_Qundef($3),
5305  escape_Qundef($4));
5306  %*/
5307  }
5308  break;
5309 
5310  case 13:
5311 
5312 /* Line 1806 of yacc.c */
5313 #line 984 "parse.y"
5314  {
5315  /*%%%*/
5316  void_stmts((yyvsp[(1) - (2)].node));
5318  /*%
5319  %*/
5320  (yyval.node) = (yyvsp[(1) - (2)].node);
5321  }
5322  break;
5323 
5324  case 14:
5325 
5326 /* Line 1806 of yacc.c */
5327 #line 995 "parse.y"
5328  {
5329  /*%%%*/
5330  (yyval.node) = NEW_BEGIN(0);
5331  /*%
5332  $$ = dispatch2(stmts_add, dispatch0(stmts_new),
5333  dispatch0(void_stmt));
5334  %*/
5335  }
5336  break;
5337 
5338  case 15:
5339 
5340 /* Line 1806 of yacc.c */
5341 #line 1004 "parse.y"
5342  {
5343  /*%%%*/
5344  (yyval.node) = newline_node((yyvsp[(1) - (1)].node));
5345  /*%
5346  $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
5347  %*/
5348  }
5349  break;
5350 
5351  case 16:
5352 
5353 /* Line 1806 of yacc.c */
5354 #line 1012 "parse.y"
5355  {
5356  /*%%%*/
5357  (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node)));
5358  /*%
5359  $$ = dispatch2(stmts_add, $1, $3);
5360  %*/
5361  }
5362  break;
5363 
5364  case 17:
5365 
5366 /* Line 1806 of yacc.c */
5367 #line 1020 "parse.y"
5368  {
5369  (yyval.node) = remove_begin((yyvsp[(2) - (2)].node));
5370  }
5371  break;
5372 
5373  case 18:
5374 
5375 /* Line 1806 of yacc.c */
5376 #line 1026 "parse.y"
5377  {
5378  (yyval.node) = (yyvsp[(1) - (1)].node);
5379  }
5380  break;
5381 
5382  case 19:
5383 
5384 /* Line 1806 of yacc.c */
5385 #line 1030 "parse.y"
5386  {
5387  yyerror("BEGIN is permitted only at toplevel");
5388  /*%%%*/
5389  /* local_push(0); */
5390  /*%
5391  %*/
5392  }
5393  break;
5394 
5395  case 20:
5396 
5397 /* Line 1806 of yacc.c */
5398 #line 1038 "parse.y"
5399  {
5400  /*%%%*/
5402  (yyvsp[(4) - (5)].node));
5403  /* NEW_PREEXE($4)); */
5404  /* local_pop(); */
5405  (yyval.node) = NEW_BEGIN(0);
5406  /*%
5407  $$ = dispatch1(BEGIN, $4);
5408  %*/
5409  }
5410  break;
5411 
5412  case 21:
5413 
5414 /* Line 1806 of yacc.c */
5415 #line 1050 "parse.y"
5416  {lex_state = EXPR_FNAME;}
5417  break;
5418 
5419  case 22:
5420 
5421 /* Line 1806 of yacc.c */
5422 #line 1051 "parse.y"
5423  {
5424  /*%%%*/
5425  (yyval.node) = NEW_ALIAS((yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].node));
5426  /*%
5427  $$ = dispatch2(alias, $2, $4);
5428  %*/
5429  }
5430  break;
5431 
5432  case 23:
5433 
5434 /* Line 1806 of yacc.c */
5435 #line 1059 "parse.y"
5436  {
5437  /*%%%*/
5438  (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].id));
5439  /*%
5440  $$ = dispatch2(var_alias, $2, $3);
5441  %*/
5442  }
5443  break;
5444 
5445  case 24:
5446 
5447 /* Line 1806 of yacc.c */
5448 #line 1067 "parse.y"
5449  {
5450  /*%%%*/
5451  char buf[2];
5452  buf[0] = '$';
5453  buf[1] = (char)(yyvsp[(3) - (3)].node)->nd_nth;
5454  (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), rb_intern2(buf, 2));
5455  /*%
5456  $$ = dispatch2(var_alias, $2, $3);
5457  %*/
5458  }
5459  break;
5460 
5461  case 25:
5462 
5463 /* Line 1806 of yacc.c */
5464 #line 1078 "parse.y"
5465  {
5466  /*%%%*/
5467  yyerror("can't make alias for the number variables");
5468  (yyval.node) = NEW_BEGIN(0);
5469  /*%
5470  $$ = dispatch2(var_alias, $2, $3);
5471  $$ = dispatch1(alias_error, $$);
5472  %*/
5473  }
5474  break;
5475 
5476  case 26:
5477 
5478 /* Line 1806 of yacc.c */
5479 #line 1088 "parse.y"
5480  {
5481  /*%%%*/
5482  (yyval.node) = (yyvsp[(2) - (2)].node);
5483  /*%
5484  $$ = dispatch1(undef, $2);
5485  %*/
5486  }
5487  break;
5488 
5489  case 27:
5490 
5491 /* Line 1806 of yacc.c */
5492 #line 1096 "parse.y"
5493  {
5494  /*%%%*/
5495  (yyval.node) = NEW_IF(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0);
5496  fixpos((yyval.node), (yyvsp[(3) - (3)].node));
5497  /*%
5498  $$ = dispatch2(if_mod, $3, $1);
5499  %*/
5500  }
5501  break;
5502 
5503  case 28:
5504 
5505 /* Line 1806 of yacc.c */
5506 #line 1105 "parse.y"
5507  {
5508  /*%%%*/
5509  (yyval.node) = NEW_UNLESS(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0);
5510  fixpos((yyval.node), (yyvsp[(3) - (3)].node));
5511  /*%
5512  $$ = dispatch2(unless_mod, $3, $1);
5513  %*/
5514  }
5515  break;
5516 
5517  case 29:
5518 
5519 /* Line 1806 of yacc.c */
5520 #line 1114 "parse.y"
5521  {
5522  /*%%%*/
5523  if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) {
5524  (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0);
5525  }
5526  else {
5527  (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1);
5528  }
5529  /*%
5530  $$ = dispatch2(while_mod, $3, $1);
5531  %*/
5532  }
5533  break;
5534 
5535  case 30:
5536 
5537 /* Line 1806 of yacc.c */
5538 #line 1127 "parse.y"
5539  {
5540  /*%%%*/
5541  if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) {
5542  (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0);
5543  }
5544  else {
5545  (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1);
5546  }
5547  /*%
5548  $$ = dispatch2(until_mod, $3, $1);
5549  %*/
5550  }
5551  break;
5552 
5553  case 31:
5554 
5555 /* Line 1806 of yacc.c */
5556 #line 1140 "parse.y"
5557  {
5558  /*%%%*/
5559  NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].node)), 0);
5560  (yyval.node) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].node)), resq, 0);
5561  /*%
5562  $$ = dispatch2(rescue_mod, $1, $3);
5563  %*/
5564  }
5565  break;
5566 
5567  case 32:
5568 
5569 /* Line 1806 of yacc.c */
5570 #line 1149 "parse.y"
5571  {
5572  if (in_def || in_single) {
5573  rb_warn0("END in method; use at_exit");
5574  }
5575  /*%%%*/
5576  (yyval.node) = NEW_POSTEXE(NEW_NODE(
5577  NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].node) /* body */, 0 /* args */));
5578  /*%
5579  $$ = dispatch1(END, $3);
5580  %*/
5581  }
5582  break;
5583 
5584  case 34:
5585 
5586 /* Line 1806 of yacc.c */
5587 #line 1162 "parse.y"
5588  {
5589  /*%%%*/
5590  value_expr((yyvsp[(3) - (3)].node));
5591  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
5592  (yyval.node) = (yyvsp[(1) - (3)].node);
5593  /*%
5594  $$ = dispatch2(massign, $1, $3);
5595  %*/
5596  }
5597  break;
5598 
5599  case 35:
5600 
5601 /* Line 1806 of yacc.c */
5602 #line 1172 "parse.y"
5603  {
5604  value_expr((yyvsp[(3) - (3)].node));
5605  (yyval.node) = new_op_assign((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].node));
5606  }
5607  break;
5608 
5609  case 36:
5610 
5611 /* Line 1806 of yacc.c */
5612 #line 1177 "parse.y"
5613  {
5614  /*%%%*/
5615  NODE *args;
5616 
5617  value_expr((yyvsp[(6) - (6)].node));
5618  if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY();
5619  args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
5620  if ((yyvsp[(5) - (6)].id) == tOROP) {
5621  (yyvsp[(5) - (6)].id) = 0;
5622  }
5623  else if ((yyvsp[(5) - (6)].id) == tANDOP) {
5624  (yyvsp[(5) - (6)].id) = 1;
5625  }
5626  (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args);
5627  fixpos((yyval.node), (yyvsp[(1) - (6)].node));
5628  /*%
5629  $$ = dispatch2(aref_field, $1, escape_Qundef($3));
5630  $$ = dispatch3(opassign, $$, $5, $6);
5631  %*/
5632  }
5633  break;
5634 
5635  case 37:
5636 
5637 /* Line 1806 of yacc.c */
5638 #line 1198 "parse.y"
5639  {
5640  value_expr((yyvsp[(5) - (5)].node));
5641  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5642  }
5643  break;
5644 
5645  case 38:
5646 
5647 /* Line 1806 of yacc.c */
5648 #line 1203 "parse.y"
5649  {
5650  value_expr((yyvsp[(5) - (5)].node));
5651  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5652  }
5653  break;
5654 
5655  case 39:
5656 
5657 /* Line 1806 of yacc.c */
5658 #line 1208 "parse.y"
5659  {
5660  /*%%%*/
5661  (yyval.node) = NEW_COLON2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id));
5662  (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5663  /*%
5664  $$ = dispatch2(const_path_field, $1, $3);
5665  $$ = dispatch3(opassign, $$, $4, $5);
5666  %*/
5667  }
5668  break;
5669 
5670  case 40:
5671 
5672 /* Line 1806 of yacc.c */
5673 #line 1218 "parse.y"
5674  {
5675  value_expr((yyvsp[(5) - (5)].node));
5676  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_intern("::"), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5677  }
5678  break;
5679 
5680  case 41:
5681 
5682 /* Line 1806 of yacc.c */
5683 #line 1223 "parse.y"
5684  {
5685  /*%%%*/
5686  rb_backref_error((yyvsp[(1) - (3)].node));
5687  (yyval.node) = NEW_BEGIN(0);
5688  /*%
5689  $$ = dispatch2(assign, dispatch1(var_field, $1), $3);
5690  $$ = dispatch1(assign_error, $$);
5691  %*/
5692  }
5693  break;
5694 
5695  case 42:
5696 
5697 /* Line 1806 of yacc.c */
5698 #line 1233 "parse.y"
5699  {
5700  /*%%%*/
5701  value_expr((yyvsp[(3) - (3)].node));
5702  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5703  /*%
5704  $$ = dispatch2(assign, $1, $3);
5705  %*/
5706  }
5707  break;
5708 
5709  case 43:
5710 
5711 /* Line 1806 of yacc.c */
5712 #line 1242 "parse.y"
5713  {
5714  /*%%%*/
5715  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
5716  (yyval.node) = (yyvsp[(1) - (3)].node);
5717  /*%
5718  $$ = dispatch2(massign, $1, $3);
5719  %*/
5720  }
5721  break;
5722 
5723  case 44:
5724 
5725 /* Line 1806 of yacc.c */
5726 #line 1251 "parse.y"
5727  {
5728  /*%%%*/
5729  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
5730  (yyval.node) = (yyvsp[(1) - (3)].node);
5731  /*%
5732  $$ = dispatch2(massign, $1, $3);
5733  %*/
5734  }
5735  break;
5736 
5737  case 46:
5738 
5739 /* Line 1806 of yacc.c */
5740 #line 1263 "parse.y"
5741  {
5742  /*%%%*/
5743  value_expr((yyvsp[(3) - (3)].node));
5744  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5745  /*%
5746  $$ = dispatch2(assign, $1, $3);
5747  %*/
5748  }
5749  break;
5750 
5751  case 47:
5752 
5753 /* Line 1806 of yacc.c */
5754 #line 1272 "parse.y"
5755  {
5756  /*%%%*/
5757  value_expr((yyvsp[(3) - (3)].node));
5758  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5759  /*%
5760  $$ = dispatch2(assign, $1, $3);
5761  %*/
5762  }
5763  break;
5764 
5765  case 49:
5766 
5767 /* Line 1806 of yacc.c */
5768 #line 1285 "parse.y"
5769  {
5770  /*%%%*/
5771  (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5772  /*%
5773  $$ = dispatch3(binary, $1, ripper_intern("and"), $3);
5774  %*/
5775  }
5776  break;
5777 
5778  case 50:
5779 
5780 /* Line 1806 of yacc.c */
5781 #line 1293 "parse.y"
5782  {
5783  /*%%%*/
5784  (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5785  /*%
5786  $$ = dispatch3(binary, $1, ripper_intern("or"), $3);
5787  %*/
5788  }
5789  break;
5790 
5791  case 51:
5792 
5793 /* Line 1806 of yacc.c */
5794 #line 1301 "parse.y"
5795  {
5796  /*%%%*/
5797  (yyval.node) = call_uni_op(cond((yyvsp[(3) - (3)].node)), '!');
5798  /*%
5799  $$ = dispatch2(unary, ripper_intern("not"), $3);
5800  %*/
5801  }
5802  break;
5803 
5804  case 52:
5805 
5806 /* Line 1806 of yacc.c */
5807 #line 1309 "parse.y"
5808  {
5809  /*%%%*/
5810  (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!');
5811  /*%
5812  $$ = dispatch2(unary, ripper_id2sym('!'), $2);
5813  %*/
5814  }
5815  break;
5816 
5817  case 54:
5818 
5819 /* Line 1806 of yacc.c */
5820 #line 1320 "parse.y"
5821  {
5822  /*%%%*/
5823  value_expr((yyvsp[(1) - (1)].node));
5824  (yyval.node) = (yyvsp[(1) - (1)].node);
5825  if (!(yyval.node)) (yyval.node) = NEW_NIL();
5826  /*%
5827  $$ = $1;
5828  %*/
5829  }
5830  break;
5831 
5832  case 58:
5833 
5834 /* Line 1806 of yacc.c */
5835 #line 1337 "parse.y"
5836  {
5837  /*%%%*/
5838  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
5839  /*%
5840  $$ = dispatch3(call, $1, $2, $3);
5841  $$ = method_arg($$, $4);
5842  %*/
5843  }
5844  break;
5845 
5846  case 59:
5847 
5848 /* Line 1806 of yacc.c */
5849 #line 1348 "parse.y"
5850  {
5851  (yyvsp[(1) - (1)].vars) = dyna_push();
5852  /*%%%*/
5853  (yyval.num) = ruby_sourceline;
5854  /*%
5855  %*/
5856  }
5857  break;
5858 
5859  case 60:
5860 
5861 /* Line 1806 of yacc.c */
5862 #line 1358 "parse.y"
5863  {
5864  /*%%%*/
5865  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
5866  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
5867  /*%
5868  $$ = dispatch2(brace_block, escape_Qundef($3), $4);
5869  %*/
5870  dyna_pop((yyvsp[(1) - (5)].vars));
5871  }
5872  break;
5873 
5874  case 61:
5875 
5876 /* Line 1806 of yacc.c */
5877 #line 1370 "parse.y"
5878  {
5879  /*%%%*/
5880  (yyval.node) = NEW_FCALL((yyvsp[(1) - (1)].id), 0);
5881  nd_set_line((yyval.node), tokline);
5882  /*%
5883  %*/
5884  }
5885  break;
5886 
5887  case 62:
5888 
5889 /* Line 1806 of yacc.c */
5890 #line 1380 "parse.y"
5891  {
5892  /*%%%*/
5893  (yyval.node) = (yyvsp[(1) - (2)].node);
5894  (yyval.node)->nd_args = (yyvsp[(2) - (2)].node);
5895  /*%
5896  $$ = dispatch2(command, $1, $2);
5897  %*/
5898  }
5899  break;
5900 
5901  case 63:
5902 
5903 /* Line 1806 of yacc.c */
5904 #line 1389 "parse.y"
5905  {
5906  /*%%%*/
5907  block_dup_check((yyvsp[(2) - (3)].node),(yyvsp[(3) - (3)].node));
5908  (yyvsp[(1) - (3)].node)->nd_args = (yyvsp[(2) - (3)].node);
5909  (yyvsp[(3) - (3)].node)->nd_iter = (yyvsp[(1) - (3)].node);
5910  (yyval.node) = (yyvsp[(3) - (3)].node);
5911  fixpos((yyval.node), (yyvsp[(1) - (3)].node));
5912  /*%
5913  $$ = dispatch2(command, $1, $2);
5914  $$ = method_add_block($$, $3);
5915  %*/
5916  }
5917  break;
5918 
5919  case 64:
5920 
5921 /* Line 1806 of yacc.c */
5922 #line 1402 "parse.y"
5923  {
5924  /*%%%*/
5925  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
5926  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
5927  /*%
5928  $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
5929  %*/
5930  }
5931  break;
5932 
5933  case 65:
5934 
5935 /* Line 1806 of yacc.c */
5936 #line 1411 "parse.y"
5937  {
5938  /*%%%*/
5939  block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node));
5940  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
5941  (yyval.node) = (yyvsp[(5) - (5)].node);
5942  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
5943  /*%
5944  $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
5945  $$ = method_add_block($$, $5);
5946  %*/
5947  }
5948  break;
5949 
5950  case 66:
5951 
5952 /* Line 1806 of yacc.c */
5953 #line 1423 "parse.y"
5954  {
5955  /*%%%*/
5956  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
5957  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
5958  /*%
5959  $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
5960  %*/
5961  }
5962  break;
5963 
5964  case 67:
5965 
5966 /* Line 1806 of yacc.c */
5967 #line 1432 "parse.y"
5968  {
5969  /*%%%*/
5970  block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node));
5971  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
5972  (yyval.node) = (yyvsp[(5) - (5)].node);
5973  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
5974  /*%
5975  $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
5976  $$ = method_add_block($$, $5);
5977  %*/
5978  }
5979  break;
5980 
5981  case 68:
5982 
5983 /* Line 1806 of yacc.c */
5984 #line 1444 "parse.y"
5985  {
5986  /*%%%*/
5987  (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node));
5988  fixpos((yyval.node), (yyvsp[(2) - (2)].node));
5989  /*%
5990  $$ = dispatch1(super, $2);
5991  %*/
5992  }
5993  break;
5994 
5995  case 69:
5996 
5997 /* Line 1806 of yacc.c */
5998 #line 1453 "parse.y"
5999  {
6000  /*%%%*/
6001  (yyval.node) = new_yield((yyvsp[(2) - (2)].node));
6002  fixpos((yyval.node), (yyvsp[(2) - (2)].node));
6003  /*%
6004  $$ = dispatch1(yield, $2);
6005  %*/
6006  }
6007  break;
6008 
6009  case 70:
6010 
6011 /* Line 1806 of yacc.c */
6012 #line 1462 "parse.y"
6013  {
6014  /*%%%*/
6015  (yyval.node) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].node)));
6016  /*%
6017  $$ = dispatch1(return, $2);
6018  %*/
6019  }
6020  break;
6021 
6022  case 71:
6023 
6024 /* Line 1806 of yacc.c */
6025 #line 1470 "parse.y"
6026  {
6027  /*%%%*/
6028  (yyval.node) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].node)));
6029  /*%
6030  $$ = dispatch1(break, $2);
6031  %*/
6032  }
6033  break;
6034 
6035  case 72:
6036 
6037 /* Line 1806 of yacc.c */
6038 #line 1478 "parse.y"
6039  {
6040  /*%%%*/
6041  (yyval.node) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].node)));
6042  /*%
6043  $$ = dispatch1(next, $2);
6044  %*/
6045  }
6046  break;
6047 
6048  case 74:
6049 
6050 /* Line 1806 of yacc.c */
6051 #line 1489 "parse.y"
6052  {
6053  /*%%%*/
6054  (yyval.node) = (yyvsp[(2) - (3)].node);
6055  /*%
6056  $$ = dispatch1(mlhs_paren, $2);
6057  %*/
6058  }
6059  break;
6060 
6061  case 76:
6062 
6063 /* Line 1806 of yacc.c */
6064 #line 1500 "parse.y"
6065  {
6066  /*%%%*/
6067  (yyval.node) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].node)), 0);
6068  /*%
6069  $$ = dispatch1(mlhs_paren, $2);
6070  %*/
6071  }
6072  break;
6073 
6074  case 77:
6075 
6076 /* Line 1806 of yacc.c */
6077 #line 1510 "parse.y"
6078  {
6079  /*%%%*/
6080  (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0);
6081  /*%
6082  $$ = $1;
6083  %*/
6084  }
6085  break;
6086 
6087  case 78:
6088 
6089 /* Line 1806 of yacc.c */
6090 #line 1518 "parse.y"
6091  {
6092  /*%%%*/
6093  (yyval.node) = NEW_MASGN(list_append((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node)), 0);
6094  /*%
6095  $$ = mlhs_add($1, $2);
6096  %*/
6097  }
6098  break;
6099 
6100  case 79:
6101 
6102 /* Line 1806 of yacc.c */
6103 #line 1526 "parse.y"
6104  {
6105  /*%%%*/
6106  (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
6107  /*%
6108  $$ = mlhs_add_star($1, $3);
6109  %*/
6110  }
6111  break;
6112 
6113  case 80:
6114 
6115 /* Line 1806 of yacc.c */
6116 #line 1534 "parse.y"
6117  {
6118  /*%%%*/
6119  (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG((yyvsp[(3) - (5)].node),(yyvsp[(5) - (5)].node)));
6120  /*%
6121  $1 = mlhs_add_star($1, $3);
6122  $$ = mlhs_add($1, $5);
6123  %*/
6124  }
6125  break;
6126 
6127  case 81:
6128 
6129 /* Line 1806 of yacc.c */
6130 #line 1543 "parse.y"
6131  {
6132  /*%%%*/
6133  (yyval.node) = NEW_MASGN((yyvsp[(1) - (2)].node), -1);
6134  /*%
6135  $$ = mlhs_add_star($1, Qnil);
6136  %*/
6137  }
6138  break;
6139 
6140  case 82:
6141 
6142 /* Line 1806 of yacc.c */
6143 #line 1551 "parse.y"
6144  {
6145  /*%%%*/
6146  (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), NEW_POSTARG(-1, (yyvsp[(4) - (4)].node)));
6147  /*%
6148  $1 = mlhs_add_star($1, Qnil);
6149  $$ = mlhs_add($1, $4);
6150  %*/
6151  }
6152  break;
6153 
6154  case 83:
6155 
6156 /* Line 1806 of yacc.c */
6157 #line 1560 "parse.y"
6158  {
6159  /*%%%*/
6160  (yyval.node) = NEW_MASGN(0, (yyvsp[(2) - (2)].node));
6161  /*%
6162  $$ = mlhs_add_star(mlhs_new(), $2);
6163  %*/
6164  }
6165  break;
6166 
6167  case 84:
6168 
6169 /* Line 1806 of yacc.c */
6170 #line 1568 "parse.y"
6171  {
6172  /*%%%*/
6173  (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].node),(yyvsp[(4) - (4)].node)));
6174  /*%
6175  $2 = mlhs_add_star(mlhs_new(), $2);
6176  $$ = mlhs_add($2, $4);
6177  %*/
6178  }
6179  break;
6180 
6181  case 85:
6182 
6183 /* Line 1806 of yacc.c */
6184 #line 1577 "parse.y"
6185  {
6186  /*%%%*/
6187  (yyval.node) = NEW_MASGN(0, -1);
6188  /*%
6189  $$ = mlhs_add_star(mlhs_new(), Qnil);
6190  %*/
6191  }
6192  break;
6193 
6194  case 86:
6195 
6196 /* Line 1806 of yacc.c */
6197 #line 1585 "parse.y"
6198  {
6199  /*%%%*/
6200  (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node)));
6201  /*%
6202  $$ = mlhs_add_star(mlhs_new(), Qnil);
6203  $$ = mlhs_add($$, $3);
6204  %*/
6205  }
6206  break;
6207 
6208  case 88:
6209 
6210 /* Line 1806 of yacc.c */
6211 #line 1597 "parse.y"
6212  {
6213  /*%%%*/
6214  (yyval.node) = (yyvsp[(2) - (3)].node);
6215  /*%
6216  $$ = dispatch1(mlhs_paren, $2);
6217  %*/
6218  }
6219  break;
6220 
6221  case 89:
6222 
6223 /* Line 1806 of yacc.c */
6224 #line 1607 "parse.y"
6225  {
6226  /*%%%*/
6227  (yyval.node) = NEW_LIST((yyvsp[(1) - (2)].node));
6228  /*%
6229  $$ = mlhs_add(mlhs_new(), $1);
6230  %*/
6231  }
6232  break;
6233 
6234  case 90:
6235 
6236 /* Line 1806 of yacc.c */
6237 #line 1615 "parse.y"
6238  {
6239  /*%%%*/
6240  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
6241  /*%
6242  $$ = mlhs_add($1, $2);
6243  %*/
6244  }
6245  break;
6246 
6247  case 91:
6248 
6249 /* Line 1806 of yacc.c */
6250 #line 1625 "parse.y"
6251  {
6252  /*%%%*/
6253  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
6254  /*%
6255  $$ = mlhs_add(mlhs_new(), $1);
6256  %*/
6257  }
6258  break;
6259 
6260  case 92:
6261 
6262 /* Line 1806 of yacc.c */
6263 #line 1633 "parse.y"
6264  {
6265  /*%%%*/
6266  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
6267  /*%
6268  $$ = mlhs_add($1, $3);
6269  %*/
6270  }
6271  break;
6272 
6273  case 93:
6274 
6275 /* Line 1806 of yacc.c */
6276 #line 1643 "parse.y"
6277  {
6278  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6279  }
6280  break;
6281 
6282  case 94:
6283 
6284 /* Line 1806 of yacc.c */
6285 #line 1647 "parse.y"
6286  {
6287  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6288  }
6289  break;
6290 
6291  case 95:
6292 
6293 /* Line 1806 of yacc.c */
6294 #line 1651 "parse.y"
6295  {
6296  /*%%%*/
6297  (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
6298  /*%
6299  $$ = dispatch2(aref_field, $1, escape_Qundef($3));
6300  %*/
6301  }
6302  break;
6303 
6304  case 96:
6305 
6306 /* Line 1806 of yacc.c */
6307 #line 1659 "parse.y"
6308  {
6309  /*%%%*/
6310  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6311  /*%
6312  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6313  %*/
6314  }
6315  break;
6316 
6317  case 97:
6318 
6319 /* Line 1806 of yacc.c */
6320 #line 1667 "parse.y"
6321  {
6322  /*%%%*/
6323  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6324  /*%
6325  $$ = dispatch2(const_path_field, $1, $3);
6326  %*/
6327  }
6328  break;
6329 
6330  case 98:
6331 
6332 /* Line 1806 of yacc.c */
6333 #line 1675 "parse.y"
6334  {
6335  /*%%%*/
6336  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6337  /*%
6338  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6339  %*/
6340  }
6341  break;
6342 
6343  case 99:
6344 
6345 /* Line 1806 of yacc.c */
6346 #line 1683 "parse.y"
6347  {
6348  /*%%%*/
6349  if (in_def || in_single)
6350  yyerror("dynamic constant assignment");
6351  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)));
6352  /*%
6353  if (in_def || in_single)
6354  yyerror("dynamic constant assignment");
6355  $$ = dispatch2(const_path_field, $1, $3);
6356  %*/
6357  }
6358  break;
6359 
6360  case 100:
6361 
6362 /* Line 1806 of yacc.c */
6363 #line 1695 "parse.y"
6364  {
6365  /*%%%*/
6366  if (in_def || in_single)
6367  yyerror("dynamic constant assignment");
6368  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id)));
6369  /*%
6370  $$ = dispatch1(top_const_field, $2);
6371  %*/
6372  }
6373  break;
6374 
6375  case 101:
6376 
6377 /* Line 1806 of yacc.c */
6378 #line 1705 "parse.y"
6379  {
6380  /*%%%*/
6381  rb_backref_error((yyvsp[(1) - (1)].node));
6382  (yyval.node) = NEW_BEGIN(0);
6383  /*%
6384  $$ = dispatch1(var_field, $1);
6385  $$ = dispatch1(assign_error, $$);
6386  %*/
6387  }
6388  break;
6389 
6390  case 102:
6391 
6392 /* Line 1806 of yacc.c */
6393 #line 1717 "parse.y"
6394  {
6395  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6396  /*%%%*/
6397  if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0);
6398  /*%
6399  $$ = dispatch1(var_field, $$);
6400  %*/
6401  }
6402  break;
6403 
6404  case 103:
6405 
6406 /* Line 1806 of yacc.c */
6407 #line 1726 "parse.y"
6408  {
6409  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6410  /*%%%*/
6411  if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0);
6412  /*%
6413  $$ = dispatch1(var_field, $$);
6414  %*/
6415  }
6416  break;
6417 
6418  case 104:
6419 
6420 /* Line 1806 of yacc.c */
6421 #line 1735 "parse.y"
6422  {
6423  /*%%%*/
6424  (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
6425  /*%
6426  $$ = dispatch2(aref_field, $1, escape_Qundef($3));
6427  %*/
6428  }
6429  break;
6430 
6431  case 105:
6432 
6433 /* Line 1806 of yacc.c */
6434 #line 1743 "parse.y"
6435  {
6436  /*%%%*/
6437  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6438  /*%
6439  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6440  %*/
6441  }
6442  break;
6443 
6444  case 106:
6445 
6446 /* Line 1806 of yacc.c */
6447 #line 1751 "parse.y"
6448  {
6449  /*%%%*/
6450  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6451  /*%
6452  $$ = dispatch3(field, $1, ripper_intern("::"), $3);
6453  %*/
6454  }
6455  break;
6456 
6457  case 107:
6458 
6459 /* Line 1806 of yacc.c */
6460 #line 1759 "parse.y"
6461  {
6462  /*%%%*/
6463  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6464  /*%
6465  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6466  %*/
6467  }
6468  break;
6469 
6470  case 108:
6471 
6472 /* Line 1806 of yacc.c */
6473 #line 1767 "parse.y"
6474  {
6475  /*%%%*/
6476  if (in_def || in_single)
6477  yyerror("dynamic constant assignment");
6478  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)));
6479  /*%
6480  $$ = dispatch2(const_path_field, $1, $3);
6481  if (in_def || in_single) {
6482  $$ = dispatch1(assign_error, $$);
6483  }
6484  %*/
6485  }
6486  break;
6487 
6488  case 109:
6489 
6490 /* Line 1806 of yacc.c */
6491 #line 1780 "parse.y"
6492  {
6493  /*%%%*/
6494  if (in_def || in_single)
6495  yyerror("dynamic constant assignment");
6496  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id)));
6497  /*%
6498  $$ = dispatch1(top_const_field, $2);
6499  if (in_def || in_single) {
6500  $$ = dispatch1(assign_error, $$);
6501  }
6502  %*/
6503  }
6504  break;
6505 
6506  case 110:
6507 
6508 /* Line 1806 of yacc.c */
6509 #line 1793 "parse.y"
6510  {
6511  /*%%%*/
6512  rb_backref_error((yyvsp[(1) - (1)].node));
6513  (yyval.node) = NEW_BEGIN(0);
6514  /*%
6515  $$ = dispatch1(assign_error, $1);
6516  %*/
6517  }
6518  break;
6519 
6520  case 111:
6521 
6522 /* Line 1806 of yacc.c */
6523 #line 1804 "parse.y"
6524  {
6525  /*%%%*/
6526  yyerror("class/module name must be CONSTANT");
6527  /*%
6528  $$ = dispatch1(class_name_error, $1);
6529  %*/
6530  }
6531  break;
6532 
6533  case 113:
6534 
6535 /* Line 1806 of yacc.c */
6536 #line 1815 "parse.y"
6537  {
6538  /*%%%*/
6539  (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id));
6540  /*%
6541  $$ = dispatch1(top_const_ref, $2);
6542  %*/
6543  }
6544  break;
6545 
6546  case 114:
6547 
6548 /* Line 1806 of yacc.c */
6549 #line 1823 "parse.y"
6550  {
6551  /*%%%*/
6552  (yyval.node) = NEW_COLON2(0, (yyval.node));
6553  /*%
6554  $$ = dispatch1(const_ref, $1);
6555  %*/
6556  }
6557  break;
6558 
6559  case 115:
6560 
6561 /* Line 1806 of yacc.c */
6562 #line 1831 "parse.y"
6563  {
6564  /*%%%*/
6565  (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6566  /*%
6567  $$ = dispatch2(const_path_ref, $1, $3);
6568  %*/
6569  }
6570  break;
6571 
6572  case 119:
6573 
6574 /* Line 1806 of yacc.c */
6575 #line 1844 "parse.y"
6576  {
6577  lex_state = EXPR_ENDFN;
6578  (yyval.id) = (yyvsp[(1) - (1)].id);
6579  }
6580  break;
6581 
6582  case 120:
6583 
6584 /* Line 1806 of yacc.c */
6585 #line 1849 "parse.y"
6586  {
6587  lex_state = EXPR_ENDFN;
6588  /*%%%*/
6589  (yyval.id) = (yyvsp[(1) - (1)].id);
6590  /*%
6591  $$ = $1;
6592  %*/
6593  }
6594  break;
6595 
6596  case 123:
6597 
6598 /* Line 1806 of yacc.c */
6599 #line 1864 "parse.y"
6600  {
6601  /*%%%*/
6602  (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id)));
6603  /*%
6604  $$ = dispatch1(symbol_literal, $1);
6605  %*/
6606  }
6607  break;
6608 
6609  case 125:
6610 
6611 /* Line 1806 of yacc.c */
6612 #line 1875 "parse.y"
6613  {
6614  /*%%%*/
6615  (yyval.node) = NEW_UNDEF((yyvsp[(1) - (1)].node));
6616  /*%
6617  $$ = rb_ary_new3(1, $1);
6618  %*/
6619  }
6620  break;
6621 
6622  case 126:
6623 
6624 /* Line 1806 of yacc.c */
6625 #line 1882 "parse.y"
6626  {lex_state = EXPR_FNAME;}
6627  break;
6628 
6629  case 127:
6630 
6631 /* Line 1806 of yacc.c */
6632 #line 1883 "parse.y"
6633  {
6634  /*%%%*/
6635  (yyval.node) = block_append((yyvsp[(1) - (4)].node), NEW_UNDEF((yyvsp[(4) - (4)].node)));
6636  /*%
6637  rb_ary_push($1, $4);
6638  %*/
6639  }
6640  break;
6641 
6642  case 128:
6643 
6644 /* Line 1806 of yacc.c */
6645 #line 1892 "parse.y"
6646  { ifndef_ripper((yyval.id) = '|'); }
6647  break;
6648 
6649  case 129:
6650 
6651 /* Line 1806 of yacc.c */
6652 #line 1893 "parse.y"
6653  { ifndef_ripper((yyval.id) = '^'); }
6654  break;
6655 
6656  case 130:
6657 
6658 /* Line 1806 of yacc.c */
6659 #line 1894 "parse.y"
6660  { ifndef_ripper((yyval.id) = '&'); }
6661  break;
6662 
6663  case 131:
6664 
6665 /* Line 1806 of yacc.c */
6666 #line 1895 "parse.y"
6667  { ifndef_ripper((yyval.id) = tCMP); }
6668  break;
6669 
6670  case 132:
6671 
6672 /* Line 1806 of yacc.c */
6673 #line 1896 "parse.y"
6674  { ifndef_ripper((yyval.id) = tEQ); }
6675  break;
6676 
6677  case 133:
6678 
6679 /* Line 1806 of yacc.c */
6680 #line 1897 "parse.y"
6681  { ifndef_ripper((yyval.id) = tEQQ); }
6682  break;
6683 
6684  case 134:
6685 
6686 /* Line 1806 of yacc.c */
6687 #line 1898 "parse.y"
6688  { ifndef_ripper((yyval.id) = tMATCH); }
6689  break;
6690 
6691  case 135:
6692 
6693 /* Line 1806 of yacc.c */
6694 #line 1899 "parse.y"
6695  { ifndef_ripper((yyval.id) = tNMATCH); }
6696  break;
6697 
6698  case 136:
6699 
6700 /* Line 1806 of yacc.c */
6701 #line 1900 "parse.y"
6702  { ifndef_ripper((yyval.id) = '>'); }
6703  break;
6704 
6705  case 137:
6706 
6707 /* Line 1806 of yacc.c */
6708 #line 1901 "parse.y"
6709  { ifndef_ripper((yyval.id) = tGEQ); }
6710  break;
6711 
6712  case 138:
6713 
6714 /* Line 1806 of yacc.c */
6715 #line 1902 "parse.y"
6716  { ifndef_ripper((yyval.id) = '<'); }
6717  break;
6718 
6719  case 139:
6720 
6721 /* Line 1806 of yacc.c */
6722 #line 1903 "parse.y"
6723  { ifndef_ripper((yyval.id) = tLEQ); }
6724  break;
6725 
6726  case 140:
6727 
6728 /* Line 1806 of yacc.c */
6729 #line 1904 "parse.y"
6730  { ifndef_ripper((yyval.id) = tNEQ); }
6731  break;
6732 
6733  case 141:
6734 
6735 /* Line 1806 of yacc.c */
6736 #line 1905 "parse.y"
6737  { ifndef_ripper((yyval.id) = tLSHFT); }
6738  break;
6739 
6740  case 142:
6741 
6742 /* Line 1806 of yacc.c */
6743 #line 1906 "parse.y"
6744  { ifndef_ripper((yyval.id) = tRSHFT); }
6745  break;
6746 
6747  case 143:
6748 
6749 /* Line 1806 of yacc.c */
6750 #line 1907 "parse.y"
6751  { ifndef_ripper((yyval.id) = '+'); }
6752  break;
6753 
6754  case 144:
6755 
6756 /* Line 1806 of yacc.c */
6757 #line 1908 "parse.y"
6758  { ifndef_ripper((yyval.id) = '-'); }
6759  break;
6760 
6761  case 145:
6762 
6763 /* Line 1806 of yacc.c */
6764 #line 1909 "parse.y"
6765  { ifndef_ripper((yyval.id) = '*'); }
6766  break;
6767 
6768  case 146:
6769 
6770 /* Line 1806 of yacc.c */
6771 #line 1910 "parse.y"
6772  { ifndef_ripper((yyval.id) = '*'); }
6773  break;
6774 
6775  case 147:
6776 
6777 /* Line 1806 of yacc.c */
6778 #line 1911 "parse.y"
6779  { ifndef_ripper((yyval.id) = '/'); }
6780  break;
6781 
6782  case 148:
6783 
6784 /* Line 1806 of yacc.c */
6785 #line 1912 "parse.y"
6786  { ifndef_ripper((yyval.id) = '%'); }
6787  break;
6788 
6789  case 149:
6790 
6791 /* Line 1806 of yacc.c */
6792 #line 1913 "parse.y"
6793  { ifndef_ripper((yyval.id) = tPOW); }
6794  break;
6795 
6796  case 150:
6797 
6798 /* Line 1806 of yacc.c */
6799 #line 1914 "parse.y"
6800  { ifndef_ripper((yyval.id) = tDSTAR); }
6801  break;
6802 
6803  case 151:
6804 
6805 /* Line 1806 of yacc.c */
6806 #line 1915 "parse.y"
6807  { ifndef_ripper((yyval.id) = '!'); }
6808  break;
6809 
6810  case 152:
6811 
6812 /* Line 1806 of yacc.c */
6813 #line 1916 "parse.y"
6814  { ifndef_ripper((yyval.id) = '~'); }
6815  break;
6816 
6817  case 153:
6818 
6819 /* Line 1806 of yacc.c */
6820 #line 1917 "parse.y"
6821  { ifndef_ripper((yyval.id) = tUPLUS); }
6822  break;
6823 
6824  case 154:
6825 
6826 /* Line 1806 of yacc.c */
6827 #line 1918 "parse.y"
6828  { ifndef_ripper((yyval.id) = tUMINUS); }
6829  break;
6830 
6831  case 155:
6832 
6833 /* Line 1806 of yacc.c */
6834 #line 1919 "parse.y"
6835  { ifndef_ripper((yyval.id) = tAREF); }
6836  break;
6837 
6838  case 156:
6839 
6840 /* Line 1806 of yacc.c */
6841 #line 1920 "parse.y"
6842  { ifndef_ripper((yyval.id) = tASET); }
6843  break;
6844 
6845  case 157:
6846 
6847 /* Line 1806 of yacc.c */
6848 #line 1921 "parse.y"
6849  { ifndef_ripper((yyval.id) = '`'); }
6850  break;
6851 
6852  case 199:
6853 
6854 /* Line 1806 of yacc.c */
6855 #line 1939 "parse.y"
6856  {
6857  /*%%%*/
6858  value_expr((yyvsp[(3) - (3)].node));
6859  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
6860  /*%
6861  $$ = dispatch2(assign, $1, $3);
6862  %*/
6863  }
6864  break;
6865 
6866  case 200:
6867 
6868 /* Line 1806 of yacc.c */
6869 #line 1948 "parse.y"
6870  {
6871  /*%%%*/
6872  value_expr((yyvsp[(3) - (5)].node));
6873  (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0);
6874  (yyval.node) = node_assign((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node));
6875  /*%
6876  $$ = dispatch2(assign, $1, dispatch2(rescue_mod, $3, $5));
6877  %*/
6878  }
6879  break;
6880 
6881  case 201:
6882 
6883 /* Line 1806 of yacc.c */
6884 #line 1958 "parse.y"
6885  {
6886  value_expr((yyvsp[(3) - (3)].node));
6887  (yyval.node) = new_op_assign((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].node));
6888  }
6889  break;
6890 
6891  case 202:
6892 
6893 /* Line 1806 of yacc.c */
6894 #line 1963 "parse.y"
6895  {
6896  /*%%%*/
6897  value_expr((yyvsp[(3) - (5)].node));
6898  (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0);
6899  /*%
6900  $3 = dispatch2(rescue_mod, $3, $5);
6901  %*/
6902  (yyval.node) = new_op_assign((yyvsp[(1) - (5)].node), (yyvsp[(2) - (5)].id), (yyvsp[(3) - (5)].node));
6903  }
6904  break;
6905 
6906  case 203:
6907 
6908 /* Line 1806 of yacc.c */
6909 #line 1973 "parse.y"
6910  {
6911  /*%%%*/
6912  NODE *args;
6913 
6914  value_expr((yyvsp[(6) - (6)].node));
6915  if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY();
6916  if (nd_type((yyvsp[(3) - (6)].node)) == NODE_BLOCK_PASS) {
6917  args = NEW_ARGSCAT((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
6918  }
6919  else {
6920  args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
6921  }
6922  if ((yyvsp[(5) - (6)].id) == tOROP) {
6923  (yyvsp[(5) - (6)].id) = 0;
6924  }
6925  else if ((yyvsp[(5) - (6)].id) == tANDOP) {
6926  (yyvsp[(5) - (6)].id) = 1;
6927  }
6928  (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args);
6929  fixpos((yyval.node), (yyvsp[(1) - (6)].node));
6930  /*%
6931  $1 = dispatch2(aref_field, $1, escape_Qundef($3));
6932  $$ = dispatch3(opassign, $1, $5, $6);
6933  %*/
6934  }
6935  break;
6936 
6937  case 204:
6938 
6939 /* Line 1806 of yacc.c */
6940 #line 1999 "parse.y"
6941  {
6942  value_expr((yyvsp[(5) - (5)].node));
6943  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
6944  }
6945  break;
6946 
6947  case 205:
6948 
6949 /* Line 1806 of yacc.c */
6950 #line 2004 "parse.y"
6951  {
6952  value_expr((yyvsp[(5) - (5)].node));
6953  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
6954  }
6955  break;
6956 
6957  case 206:
6958 
6959 /* Line 1806 of yacc.c */
6960 #line 2009 "parse.y"
6961  {
6962  value_expr((yyvsp[(5) - (5)].node));
6963  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_intern("::"), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
6964  }
6965  break;
6966 
6967  case 207:
6968 
6969 /* Line 1806 of yacc.c */
6970 #line 2014 "parse.y"
6971  {
6972  /*%%%*/
6973  (yyval.node) = NEW_COLON2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id));
6974  (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
6975  /*%
6976  $$ = dispatch2(const_path_field, $1, $3);
6977  $$ = dispatch3(opassign, $$, $4, $5);
6978  %*/
6979  }
6980  break;
6981 
6982  case 208:
6983 
6984 /* Line 1806 of yacc.c */
6985 #line 2024 "parse.y"
6986  {
6987  /*%%%*/
6988  (yyval.node) = NEW_COLON3((yyvsp[(2) - (4)].id));
6989  (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
6990  /*%
6991  $$ = dispatch1(top_const_field, $2);
6992  $$ = dispatch3(opassign, $$, $3, $4);
6993  %*/
6994  }
6995  break;
6996 
6997  case 209:
6998 
6999 /* Line 1806 of yacc.c */
7000 #line 2034 "parse.y"
7001  {
7002  /*%%%*/
7003  rb_backref_error((yyvsp[(1) - (3)].node));
7004  (yyval.node) = NEW_BEGIN(0);
7005  /*%
7006  $$ = dispatch1(var_field, $1);
7007  $$ = dispatch3(opassign, $$, $2, $3);
7008  $$ = dispatch1(assign_error, $$);
7009  %*/
7010  }
7011  break;
7012 
7013  case 210:
7014 
7015 /* Line 1806 of yacc.c */
7016 #line 2045 "parse.y"
7017  {
7018  /*%%%*/
7019  value_expr((yyvsp[(1) - (3)].node));
7020  value_expr((yyvsp[(3) - (3)].node));
7021  (yyval.node) = NEW_DOT2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7022  if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) &&
7023  nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) {
7025  }
7026  /*%
7027  $$ = dispatch2(dot2, $1, $3);
7028  %*/
7029  }
7030  break;
7031 
7032  case 211:
7033 
7034 /* Line 1806 of yacc.c */
7035 #line 2059 "parse.y"
7036  {
7037  /*%%%*/
7038  value_expr((yyvsp[(1) - (3)].node));
7039  value_expr((yyvsp[(3) - (3)].node));
7040  (yyval.node) = NEW_DOT3((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7041  if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) &&
7042  nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) {
7044  }
7045  /*%
7046  $$ = dispatch2(dot3, $1, $3);
7047  %*/
7048  }
7049  break;
7050 
7051  case 212:
7052 
7053 /* Line 1806 of yacc.c */
7054 #line 2073 "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 213:
7065 
7066 /* Line 1806 of yacc.c */
7067 #line 2081 "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 214:
7078 
7079 /* Line 1806 of yacc.c */
7080 #line 2089 "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 215:
7091 
7092 /* Line 1806 of yacc.c */
7093 #line 2097 "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 216:
7104 
7105 /* Line 1806 of yacc.c */
7106 #line 2105 "parse.y"
7107  {
7108  /*%%%*/
7109  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '%', (yyvsp[(3) - (3)].node));
7110  /*%
7111  $$ = dispatch3(binary, $1, ID2SYM('%'), $3);
7112  %*/
7113  }
7114  break;
7115 
7116  case 217:
7117 
7118 /* Line 1806 of yacc.c */
7119 #line 2113 "parse.y"
7120  {
7121  /*%%%*/
7122  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tPOW, (yyvsp[(3) - (3)].node));
7123  /*%
7124  $$ = dispatch3(binary, $1, ripper_intern("**"), $3);
7125  %*/
7126  }
7127  break;
7128 
7129  case 218:
7130 
7131 /* Line 1806 of yacc.c */
7132 #line 2121 "parse.y"
7133  {
7134  /*%%%*/
7135  (yyval.node) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].node), tPOW, (yyvsp[(4) - (4)].node)), tUMINUS, 0);
7136  /*%
7137  $$ = dispatch3(binary, $2, ripper_intern("**"), $4);
7138  $$ = dispatch2(unary, ripper_intern("-@"), $$);
7139  %*/
7140  }
7141  break;
7142 
7143  case 219:
7144 
7145 /* Line 1806 of yacc.c */
7146 #line 2130 "parse.y"
7147  {
7148  /*%%%*/
7149  (yyval.node) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].node), tPOW, (yyvsp[(4) - (4)].node)), tUMINUS, 0);
7150  /*%
7151  $$ = dispatch3(binary, $2, ripper_intern("**"), $4);
7152  $$ = dispatch2(unary, ripper_intern("-@"), $$);
7153  %*/
7154  }
7155  break;
7156 
7157  case 220:
7158 
7159 /* Line 1806 of yacc.c */
7160 #line 2139 "parse.y"
7161  {
7162  /*%%%*/
7163  (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUPLUS);
7164  /*%
7165  $$ = dispatch2(unary, ripper_intern("+@"), $2);
7166  %*/
7167  }
7168  break;
7169 
7170  case 221:
7171 
7172 /* Line 1806 of yacc.c */
7173 #line 2147 "parse.y"
7174  {
7175  /*%%%*/
7176  (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUMINUS);
7177  /*%
7178  $$ = dispatch2(unary, ripper_intern("-@"), $2);
7179  %*/
7180  }
7181  break;
7182 
7183  case 222:
7184 
7185 /* Line 1806 of yacc.c */
7186 #line 2155 "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 223:
7197 
7198 /* Line 1806 of yacc.c */
7199 #line 2163 "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 224:
7210 
7211 /* Line 1806 of yacc.c */
7212 #line 2171 "parse.y"
7213  {
7214  /*%%%*/
7215  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '&', (yyvsp[(3) - (3)].node));
7216  /*%
7217  $$ = dispatch3(binary, $1, ID2SYM('&'), $3);
7218  %*/
7219  }
7220  break;
7221 
7222  case 225:
7223 
7224 /* Line 1806 of yacc.c */
7225 #line 2179 "parse.y"
7226  {
7227  /*%%%*/
7228  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tCMP, (yyvsp[(3) - (3)].node));
7229  /*%
7230  $$ = dispatch3(binary, $1, ripper_intern("<=>"), $3);
7231  %*/
7232  }
7233  break;
7234 
7235  case 226:
7236 
7237 /* Line 1806 of yacc.c */
7238 #line 2187 "parse.y"
7239  {
7240  /*%%%*/
7241  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '>', (yyvsp[(3) - (3)].node));
7242  /*%
7243  $$ = dispatch3(binary, $1, ID2SYM('>'), $3);
7244  %*/
7245  }
7246  break;
7247 
7248  case 227:
7249 
7250 /* Line 1806 of yacc.c */
7251 #line 2195 "parse.y"
7252  {
7253  /*%%%*/
7254  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tGEQ, (yyvsp[(3) - (3)].node));
7255  /*%
7256  $$ = dispatch3(binary, $1, ripper_intern(">="), $3);
7257  %*/
7258  }
7259  break;
7260 
7261  case 228:
7262 
7263 /* Line 1806 of yacc.c */
7264 #line 2203 "parse.y"
7265  {
7266  /*%%%*/
7267  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '<', (yyvsp[(3) - (3)].node));
7268  /*%
7269  $$ = dispatch3(binary, $1, ID2SYM('<'), $3);
7270  %*/
7271  }
7272  break;
7273 
7274  case 229:
7275 
7276 /* Line 1806 of yacc.c */
7277 #line 2211 "parse.y"
7278  {
7279  /*%%%*/
7280  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLEQ, (yyvsp[(3) - (3)].node));
7281  /*%
7282  $$ = dispatch3(binary, $1, ripper_intern("<="), $3);
7283  %*/
7284  }
7285  break;
7286 
7287  case 230:
7288 
7289 /* Line 1806 of yacc.c */
7290 #line 2219 "parse.y"
7291  {
7292  /*%%%*/
7293  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQ, (yyvsp[(3) - (3)].node));
7294  /*%
7295  $$ = dispatch3(binary, $1, ripper_intern("=="), $3);
7296  %*/
7297  }
7298  break;
7299 
7300  case 231:
7301 
7302 /* Line 1806 of yacc.c */
7303 #line 2227 "parse.y"
7304  {
7305  /*%%%*/
7306  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQQ, (yyvsp[(3) - (3)].node));
7307  /*%
7308  $$ = dispatch3(binary, $1, ripper_intern("==="), $3);
7309  %*/
7310  }
7311  break;
7312 
7313  case 232:
7314 
7315 /* Line 1806 of yacc.c */
7316 #line 2235 "parse.y"
7317  {
7318  /*%%%*/
7319  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNEQ, (yyvsp[(3) - (3)].node));
7320  /*%
7321  $$ = dispatch3(binary, $1, ripper_intern("!="), $3);
7322  %*/
7323  }
7324  break;
7325 
7326  case 233:
7327 
7328 /* Line 1806 of yacc.c */
7329 #line 2243 "parse.y"
7330  {
7331  /*%%%*/
7332  (yyval.node) = match_op((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7333  if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].node)->nd_lit, T_REGEXP)) {
7334  (yyval.node) = reg_named_capture_assign((yyvsp[(1) - (3)].node)->nd_lit, (yyval.node));
7335  }
7336  /*%
7337  $$ = dispatch3(binary, $1, ripper_intern("=~"), $3);
7338  %*/
7339  }
7340  break;
7341 
7342  case 234:
7343 
7344 /* Line 1806 of yacc.c */
7345 #line 2254 "parse.y"
7346  {
7347  /*%%%*/
7348  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNMATCH, (yyvsp[(3) - (3)].node));
7349  /*%
7350  $$ = dispatch3(binary, $1, ripper_intern("!~"), $3);
7351  %*/
7352  }
7353  break;
7354 
7355  case 235:
7356 
7357 /* Line 1806 of yacc.c */
7358 #line 2262 "parse.y"
7359  {
7360  /*%%%*/
7361  (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!');
7362  /*%
7363  $$ = dispatch2(unary, ID2SYM('!'), $2);
7364  %*/
7365  }
7366  break;
7367 
7368  case 236:
7369 
7370 /* Line 1806 of yacc.c */
7371 #line 2270 "parse.y"
7372  {
7373  /*%%%*/
7374  (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), '~');
7375  /*%
7376  $$ = dispatch2(unary, ID2SYM('~'), $2);
7377  %*/
7378  }
7379  break;
7380 
7381  case 237:
7382 
7383 /* Line 1806 of yacc.c */
7384 #line 2278 "parse.y"
7385  {
7386  /*%%%*/
7387  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLSHFT, (yyvsp[(3) - (3)].node));
7388  /*%
7389  $$ = dispatch3(binary, $1, ripper_intern("<<"), $3);
7390  %*/
7391  }
7392  break;
7393 
7394  case 238:
7395 
7396 /* Line 1806 of yacc.c */
7397 #line 2286 "parse.y"
7398  {
7399  /*%%%*/
7400  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tRSHFT, (yyvsp[(3) - (3)].node));
7401  /*%
7402  $$ = dispatch3(binary, $1, ripper_intern(">>"), $3);
7403  %*/
7404  }
7405  break;
7406 
7407  case 239:
7408 
7409 /* Line 1806 of yacc.c */
7410 #line 2294 "parse.y"
7411  {
7412  /*%%%*/
7413  (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7414  /*%
7415  $$ = dispatch3(binary, $1, ripper_intern("&&"), $3);
7416  %*/
7417  }
7418  break;
7419 
7420  case 240:
7421 
7422 /* Line 1806 of yacc.c */
7423 #line 2302 "parse.y"
7424  {
7425  /*%%%*/
7426  (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7427  /*%
7428  $$ = dispatch3(binary, $1, ripper_intern("||"), $3);
7429  %*/
7430  }
7431  break;
7432 
7433  case 241:
7434 
7435 /* Line 1806 of yacc.c */
7436 #line 2309 "parse.y"
7437  {in_defined = 1;}
7438  break;
7439 
7440  case 242:
7441 
7442 /* Line 1806 of yacc.c */
7443 #line 2310 "parse.y"
7444  {
7445  /*%%%*/
7446  in_defined = 0;
7447  (yyval.node) = NEW_DEFINED((yyvsp[(4) - (4)].node));
7448  /*%
7449  in_defined = 0;
7450  $$ = dispatch1(defined, $4);
7451  %*/
7452  }
7453  break;
7454 
7455  case 243:
7456 
7457 /* Line 1806 of yacc.c */
7458 #line 2320 "parse.y"
7459  {
7460  /*%%%*/
7461  value_expr((yyvsp[(1) - (6)].node));
7462  (yyval.node) = NEW_IF(cond((yyvsp[(1) - (6)].node)), (yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
7463  fixpos((yyval.node), (yyvsp[(1) - (6)].node));
7464  /*%
7465  $$ = dispatch3(ifop, $1, $3, $6);
7466  %*/
7467  }
7468  break;
7469 
7470  case 244:
7471 
7472 /* Line 1806 of yacc.c */
7473 #line 2330 "parse.y"
7474  {
7475  (yyval.node) = (yyvsp[(1) - (1)].node);
7476  }
7477  break;
7478 
7479  case 245:
7480 
7481 /* Line 1806 of yacc.c */
7482 #line 2336 "parse.y"
7483  {
7484  /*%%%*/
7485  value_expr((yyvsp[(1) - (1)].node));
7486  (yyval.node) = (yyvsp[(1) - (1)].node);
7487  if (!(yyval.node)) (yyval.node) = NEW_NIL();
7488  /*%
7489  $$ = $1;
7490  %*/
7491  }
7492  break;
7493 
7494  case 247:
7495 
7496 /* Line 1806 of yacc.c */
7497 #line 2349 "parse.y"
7498  {
7499  (yyval.node) = (yyvsp[(1) - (2)].node);
7500  }
7501  break;
7502 
7503  case 248:
7504 
7505 /* Line 1806 of yacc.c */
7506 #line 2353 "parse.y"
7507  {
7508  /*%%%*/
7509  (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
7510  /*%
7511  $$ = arg_add_assocs($1, $3);
7512  %*/
7513  }
7514  break;
7515 
7516  case 249:
7517 
7518 /* Line 1806 of yacc.c */
7519 #line 2361 "parse.y"
7520  {
7521  /*%%%*/
7522  (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
7523  /*%
7524  $$ = arg_add_assocs(arg_new(), $1);
7525  %*/
7526  }
7527  break;
7528 
7529  case 250:
7530 
7531 /* Line 1806 of yacc.c */
7532 #line 2371 "parse.y"
7533  {
7534  /*%%%*/
7535  (yyval.node) = (yyvsp[(2) - (3)].node);
7536  /*%
7537  $$ = dispatch1(arg_paren, escape_Qundef($2));
7538  %*/
7539  }
7540  break;
7541 
7542  case 255:
7543 
7544 /* Line 1806 of yacc.c */
7545 #line 2387 "parse.y"
7546  {
7547  (yyval.node) = (yyvsp[(1) - (2)].node);
7548  }
7549  break;
7550 
7551  case 256:
7552 
7553 /* Line 1806 of yacc.c */
7554 #line 2391 "parse.y"
7555  {
7556  /*%%%*/
7557  (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
7558  /*%
7559  $$ = arg_add_assocs($1, $3);
7560  %*/
7561  }
7562  break;
7563 
7564  case 257:
7565 
7566 /* Line 1806 of yacc.c */
7567 #line 2399 "parse.y"
7568  {
7569  /*%%%*/
7570  (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
7571  /*%
7572  $$ = arg_add_assocs(arg_new(), $1);
7573  %*/
7574  }
7575  break;
7576 
7577  case 258:
7578 
7579 /* Line 1806 of yacc.c */
7580 #line 2409 "parse.y"
7581  {
7582  /*%%%*/
7583  value_expr((yyvsp[(1) - (1)].node));
7584  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
7585  /*%
7586  $$ = arg_add(arg_new(), $1);
7587  %*/
7588  }
7589  break;
7590 
7591  case 259:
7592 
7593 /* Line 1806 of yacc.c */
7594 #line 2418 "parse.y"
7595  {
7596  /*%%%*/
7597  (yyval.node) = arg_blk_pass((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
7598  /*%
7599  $$ = arg_add_optblock($1, $2);
7600  %*/
7601  }
7602  break;
7603 
7604  case 260:
7605 
7606 /* Line 1806 of yacc.c */
7607 #line 2426 "parse.y"
7608  {
7609  /*%%%*/
7610  (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
7611  (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(2) - (2)].node));
7612  /*%
7613  $$ = arg_add_assocs(arg_new(), $1);
7614  $$ = arg_add_optblock($$, $2);
7615  %*/
7616  }
7617  break;
7618 
7619  case 261:
7620 
7621 /* Line 1806 of yacc.c */
7622 #line 2436 "parse.y"
7623  {
7624  /*%%%*/
7625  (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
7626  (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(4) - (4)].node));
7627  /*%
7628  $$ = arg_add_optblock(arg_add_assocs($1, $3), $4);
7629  %*/
7630  }
7631  break;
7632 
7633  case 263:
7634 
7635 /* Line 1806 of yacc.c */
7636 #line 2453 "parse.y"
7637  {
7638  (yyval.val) = cmdarg_stack;
7639  CMDARG_PUSH(1);
7640  }
7641  break;
7642 
7643  case 264:
7644 
7645 /* Line 1806 of yacc.c */
7646 #line 2458 "parse.y"
7647  {
7648  /* CMDARG_POP() */
7649  cmdarg_stack = (yyvsp[(1) - (2)].val);
7650  (yyval.node) = (yyvsp[(2) - (2)].node);
7651  }
7652  break;
7653 
7654  case 265:
7655 
7656 /* Line 1806 of yacc.c */
7657 #line 2466 "parse.y"
7658  {
7659  /*%%%*/
7660  (yyval.node) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].node));
7661  /*%
7662  $$ = $2;
7663  %*/
7664  }
7665  break;
7666 
7667  case 266:
7668 
7669 /* Line 1806 of yacc.c */
7670 #line 2476 "parse.y"
7671  {
7672  (yyval.node) = (yyvsp[(2) - (2)].node);
7673  }
7674  break;
7675 
7676  case 267:
7677 
7678 /* Line 1806 of yacc.c */
7679 #line 2480 "parse.y"
7680  {
7681  (yyval.node) = 0;
7682  }
7683  break;
7684 
7685  case 268:
7686 
7687 /* Line 1806 of yacc.c */
7688 #line 2486 "parse.y"
7689  {
7690  /*%%%*/
7691  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
7692  /*%
7693  $$ = arg_add(arg_new(), $1);
7694  %*/
7695  }
7696  break;
7697 
7698  case 269:
7699 
7700 /* Line 1806 of yacc.c */
7701 #line 2494 "parse.y"
7702  {
7703  /*%%%*/
7704  (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node));
7705  /*%
7706  $$ = arg_add_star(arg_new(), $2);
7707  %*/
7708  }
7709  break;
7710 
7711  case 270:
7712 
7713 /* Line 1806 of yacc.c */
7714 #line 2502 "parse.y"
7715  {
7716  /*%%%*/
7717  NODE *n1;
7718  if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) {
7719  (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node));
7720  }
7721  else {
7722  (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7723  }
7724  /*%
7725  $$ = arg_add($1, $3);
7726  %*/
7727  }
7728  break;
7729 
7730  case 271:
7731 
7732 /* Line 1806 of yacc.c */
7733 #line 2516 "parse.y"
7734  {
7735  /*%%%*/
7736  NODE *n1;
7737  if ((nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) {
7738  (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node));
7739  }
7740  else {
7741  (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
7742  }
7743  /*%
7744  $$ = arg_add_star($1, $4);
7745  %*/
7746  }
7747  break;
7748 
7749  case 272:
7750 
7751 /* Line 1806 of yacc.c */
7752 #line 2532 "parse.y"
7753  {
7754  /*%%%*/
7755  NODE *n1;
7756  if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) {
7757  (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node));
7758  }
7759  else {
7760  (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7761  }
7762  /*%
7763  $$ = mrhs_add(args2mrhs($1), $3);
7764  %*/
7765  }
7766  break;
7767 
7768  case 273:
7769 
7770 /* Line 1806 of yacc.c */
7771 #line 2546 "parse.y"
7772  {
7773  /*%%%*/
7774  NODE *n1;
7775  if (nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY &&
7776  (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) {
7777  (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node));
7778  }
7779  else {
7780  (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
7781  }
7782  /*%
7783  $$ = mrhs_add_star(args2mrhs($1), $4);
7784  %*/
7785  }
7786  break;
7787 
7788  case 274:
7789 
7790 /* Line 1806 of yacc.c */
7791 #line 2561 "parse.y"
7792  {
7793  /*%%%*/
7794  (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node));
7795  /*%
7796  $$ = mrhs_add_star(mrhs_new(), $2);
7797  %*/
7798  }
7799  break;
7800 
7801  case 285:
7802 
7803 /* Line 1806 of yacc.c */
7804 #line 2581 "parse.y"
7805  {
7806  /*%%%*/
7807  (yyval.node) = NEW_FCALL((yyvsp[(1) - (1)].id), 0);
7808  /*%
7809  $$ = method_arg(dispatch1(fcall, $1), arg_new());
7810  %*/
7811  }
7812  break;
7813 
7814  case 286:
7815 
7816 /* Line 1806 of yacc.c */
7817 #line 2589 "parse.y"
7818  {
7819  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7820  cmdarg_stack = 0;
7821  /*%%%*/
7822  (yyval.num) = ruby_sourceline;
7823  /*%
7824  %*/
7825  }
7826  break;
7827 
7828  case 287:
7829 
7830 /* Line 1806 of yacc.c */
7831 #line 2599 "parse.y"
7832  {
7833  cmdarg_stack = (yyvsp[(1) - (4)].val);
7834  /*%%%*/
7835  if ((yyvsp[(3) - (4)].node) == NULL) {
7836  (yyval.node) = NEW_NIL();
7837  }
7838  else {
7839  if (nd_type((yyvsp[(3) - (4)].node)) == NODE_RESCUE ||
7840  nd_type((yyvsp[(3) - (4)].node)) == NODE_ENSURE)
7841  nd_set_line((yyvsp[(3) - (4)].node), (yyvsp[(2) - (4)].num));
7842  (yyval.node) = NEW_BEGIN((yyvsp[(3) - (4)].node));
7843  }
7844  nd_set_line((yyval.node), (yyvsp[(2) - (4)].num));
7845  /*%
7846  $$ = dispatch1(begin, $3);
7847  %*/
7848  }
7849  break;
7850 
7851  case 288:
7852 
7853 /* Line 1806 of yacc.c */
7854 #line 2616 "parse.y"
7855  {lex_state = EXPR_ENDARG;}
7856  break;
7857 
7858  case 289:
7859 
7860 /* Line 1806 of yacc.c */
7861 #line 2617 "parse.y"
7862  {
7863  /*%%%*/
7864  (yyval.node) = 0;
7865  /*%
7866  $$ = dispatch1(paren, 0);
7867  %*/
7868  }
7869  break;
7870 
7871  case 290:
7872 
7873 /* Line 1806 of yacc.c */
7874 #line 2625 "parse.y"
7875  {
7876  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7877  cmdarg_stack = 0;
7878  }
7879  break;
7880 
7881  case 291:
7882 
7883 /* Line 1806 of yacc.c */
7884 #line 2629 "parse.y"
7885  {lex_state = EXPR_ENDARG;}
7886  break;
7887 
7888  case 292:
7889 
7890 /* Line 1806 of yacc.c */
7891 #line 2630 "parse.y"
7892  {
7893  cmdarg_stack = (yyvsp[(1) - (5)].val);
7894  /*%%%*/
7895  (yyval.node) = (yyvsp[(3) - (5)].node);
7896  /*%
7897  $$ = dispatch1(paren, $3);
7898  %*/
7899  }
7900  break;
7901 
7902  case 293:
7903 
7904 /* Line 1806 of yacc.c */
7905 #line 2639 "parse.y"
7906  {
7907  /*%%%*/
7908  (yyval.node) = (yyvsp[(2) - (3)].node);
7909  /*%
7910  $$ = dispatch1(paren, $2);
7911  %*/
7912  }
7913  break;
7914 
7915  case 294:
7916 
7917 /* Line 1806 of yacc.c */
7918 #line 2647 "parse.y"
7919  {
7920  /*%%%*/
7921  (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
7922  /*%
7923  $$ = dispatch2(const_path_ref, $1, $3);
7924  %*/
7925  }
7926  break;
7927 
7928  case 295:
7929 
7930 /* Line 1806 of yacc.c */
7931 #line 2655 "parse.y"
7932  {
7933  /*%%%*/
7934  (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id));
7935  /*%
7936  $$ = dispatch1(top_const_ref, $2);
7937  %*/
7938  }
7939  break;
7940 
7941  case 296:
7942 
7943 /* Line 1806 of yacc.c */
7944 #line 2663 "parse.y"
7945  {
7946  /*%%%*/
7947  if ((yyvsp[(2) - (3)].node) == 0) {
7948  (yyval.node) = NEW_ZARRAY(); /* zero length array*/
7949  }
7950  else {
7951  (yyval.node) = (yyvsp[(2) - (3)].node);
7952  }
7953  /*%
7954  $$ = dispatch1(array, escape_Qundef($2));
7955  %*/
7956  }
7957  break;
7958 
7959  case 297:
7960 
7961 /* Line 1806 of yacc.c */
7962 #line 2676 "parse.y"
7963  {
7964  /*%%%*/
7965  (yyval.node) = NEW_HASH((yyvsp[(2) - (3)].node));
7966  /*%
7967  $$ = dispatch1(hash, escape_Qundef($2));
7968  %*/
7969  }
7970  break;
7971 
7972  case 298:
7973 
7974 /* Line 1806 of yacc.c */
7975 #line 2684 "parse.y"
7976  {
7977  /*%%%*/
7978  (yyval.node) = NEW_RETURN(0);
7979  /*%
7980  $$ = dispatch0(return0);
7981  %*/
7982  }
7983  break;
7984 
7985  case 299:
7986 
7987 /* Line 1806 of yacc.c */
7988 #line 2692 "parse.y"
7989  {
7990  /*%%%*/
7991  (yyval.node) = new_yield((yyvsp[(3) - (4)].node));
7992  /*%
7993  $$ = dispatch1(yield, dispatch1(paren, $3));
7994  %*/
7995  }
7996  break;
7997 
7998  case 300:
7999 
8000 /* Line 1806 of yacc.c */
8001 #line 2700 "parse.y"
8002  {
8003  /*%%%*/
8004  (yyval.node) = NEW_YIELD(0);
8005  /*%
8006  $$ = dispatch1(yield, dispatch1(paren, arg_new()));
8007  %*/
8008  }
8009  break;
8010 
8011  case 301:
8012 
8013 /* Line 1806 of yacc.c */
8014 #line 2708 "parse.y"
8015  {
8016  /*%%%*/
8017  (yyval.node) = NEW_YIELD(0);
8018  /*%
8019  $$ = dispatch0(yield0);
8020  %*/
8021  }
8022  break;
8023 
8024  case 302:
8025 
8026 /* Line 1806 of yacc.c */
8027 #line 2715 "parse.y"
8028  {in_defined = 1;}
8029  break;
8030 
8031  case 303:
8032 
8033 /* Line 1806 of yacc.c */
8034 #line 2716 "parse.y"
8035  {
8036  /*%%%*/
8037  in_defined = 0;
8038  (yyval.node) = NEW_DEFINED((yyvsp[(5) - (6)].node));
8039  /*%
8040  in_defined = 0;
8041  $$ = dispatch1(defined, $5);
8042  %*/
8043  }
8044  break;
8045 
8046  case 304:
8047 
8048 /* Line 1806 of yacc.c */
8049 #line 2726 "parse.y"
8050  {
8051  /*%%%*/
8052  (yyval.node) = call_uni_op(cond((yyvsp[(3) - (4)].node)), '!');
8053  /*%
8054  $$ = dispatch2(unary, ripper_intern("not"), $3);
8055  %*/
8056  }
8057  break;
8058 
8059  case 305:
8060 
8061 /* Line 1806 of yacc.c */
8062 #line 2734 "parse.y"
8063  {
8064  /*%%%*/
8065  (yyval.node) = call_uni_op(cond(NEW_NIL()), '!');
8066  /*%
8067  $$ = dispatch2(unary, ripper_intern("not"), Qnil);
8068  %*/
8069  }
8070  break;
8071 
8072  case 306:
8073 
8074 /* Line 1806 of yacc.c */
8075 #line 2742 "parse.y"
8076  {
8077  /*%%%*/
8078  (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
8079  (yyval.node) = (yyvsp[(2) - (2)].node);
8080  /*%
8081  $$ = method_arg(dispatch1(fcall, $1), arg_new());
8082  $$ = method_add_block($$, $2);
8083  %*/
8084  }
8085  break;
8086 
8087  case 308:
8088 
8089 /* Line 1806 of yacc.c */
8090 #line 2753 "parse.y"
8091  {
8092  /*%%%*/
8093  block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node));
8094  (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
8095  (yyval.node) = (yyvsp[(2) - (2)].node);
8096  /*%
8097  $$ = method_add_block($1, $2);
8098  %*/
8099  }
8100  break;
8101 
8102  case 309:
8103 
8104 /* Line 1806 of yacc.c */
8105 #line 2763 "parse.y"
8106  {
8107  (yyval.node) = (yyvsp[(2) - (2)].node);
8108  }
8109  break;
8110 
8111  case 310:
8112 
8113 /* Line 1806 of yacc.c */
8114 #line 2770 "parse.y"
8115  {
8116  /*%%%*/
8117  (yyval.node) = NEW_IF(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node));
8118  fixpos((yyval.node), (yyvsp[(2) - (6)].node));
8119  /*%
8120  $$ = dispatch3(if, $2, $4, escape_Qundef($5));
8121  %*/
8122  }
8123  break;
8124 
8125  case 311:
8126 
8127 /* Line 1806 of yacc.c */
8128 #line 2782 "parse.y"
8129  {
8130  /*%%%*/
8131  (yyval.node) = NEW_UNLESS(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node));
8132  fixpos((yyval.node), (yyvsp[(2) - (6)].node));
8133  /*%
8134  $$ = dispatch3(unless, $2, $4, escape_Qundef($5));
8135  %*/
8136  }
8137  break;
8138 
8139  case 312:
8140 
8141 /* Line 1806 of yacc.c */
8142 #line 2790 "parse.y"
8143  {COND_PUSH(1);}
8144  break;
8145 
8146  case 313:
8147 
8148 /* Line 1806 of yacc.c */
8149 #line 2790 "parse.y"
8150  {COND_POP();}
8151  break;
8152 
8153  case 314:
8154 
8155 /* Line 1806 of yacc.c */
8156 #line 2793 "parse.y"
8157  {
8158  /*%%%*/
8159  (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1);
8160  fixpos((yyval.node), (yyvsp[(3) - (7)].node));
8161  /*%
8162  $$ = dispatch2(while, $3, $6);
8163  %*/
8164  }
8165  break;
8166 
8167  case 315:
8168 
8169 /* Line 1806 of yacc.c */
8170 #line 2801 "parse.y"
8171  {COND_PUSH(1);}
8172  break;
8173 
8174  case 316:
8175 
8176 /* Line 1806 of yacc.c */
8177 #line 2801 "parse.y"
8178  {COND_POP();}
8179  break;
8180 
8181  case 317:
8182 
8183 /* Line 1806 of yacc.c */
8184 #line 2804 "parse.y"
8185  {
8186  /*%%%*/
8187  (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1);
8188  fixpos((yyval.node), (yyvsp[(3) - (7)].node));
8189  /*%
8190  $$ = dispatch2(until, $3, $6);
8191  %*/
8192  }
8193  break;
8194 
8195  case 318:
8196 
8197 /* Line 1806 of yacc.c */
8198 #line 2815 "parse.y"
8199  {
8200  /*%%%*/
8201  (yyval.node) = NEW_CASE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node));
8202  fixpos((yyval.node), (yyvsp[(2) - (5)].node));
8203  /*%
8204  $$ = dispatch2(case, $2, $4);
8205  %*/
8206  }
8207  break;
8208 
8209  case 319:
8210 
8211 /* Line 1806 of yacc.c */
8212 #line 2824 "parse.y"
8213  {
8214  /*%%%*/
8215  (yyval.node) = NEW_CASE(0, (yyvsp[(3) - (4)].node));
8216  /*%
8217  $$ = dispatch2(case, Qnil, $3);
8218  %*/
8219  }
8220  break;
8221 
8222  case 320:
8223 
8224 /* Line 1806 of yacc.c */
8225 #line 2832 "parse.y"
8226  {COND_PUSH(1);}
8227  break;
8228 
8229  case 321:
8230 
8231 /* Line 1806 of yacc.c */
8232 #line 2834 "parse.y"
8233  {COND_POP();}
8234  break;
8235 
8236  case 322:
8237 
8238 /* Line 1806 of yacc.c */
8239 #line 2837 "parse.y"
8240  {
8241  /*%%%*/
8242  /*
8243  * for a, b, c in e
8244  * #=>
8245  * e.each{|*x| a, b, c = x
8246  *
8247  * for a in e
8248  * #=>
8249  * e.each{|x| a, = x}
8250  */
8251  ID id = internal_id();
8252  ID *tbl = ALLOC_N(ID, 2);
8253  NODE *m = NEW_ARGS_AUX(0, 0);
8254  NODE *args, *scope;
8255 
8256  if (nd_type((yyvsp[(2) - (9)].node)) == NODE_MASGN) {
8257  /* if args.length == 1 && args[0].kind_of?(Array)
8258  * args = args[0]
8259  * end
8260  */
8261  NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
8262  NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
8263  m->nd_next = block_append(
8264  NEW_IF(
8266  NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
8267  idEq, one),
8268  NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero),
8269  rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
8270  0),
8271  NEW_DASGN_CURR(id,
8272  NEW_CALL(NEW_DVAR(id), idAREF, zero)),
8273  0),
8274  node_assign((yyvsp[(2) - (9)].node), NEW_DVAR(id)));
8275 
8276  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8277  }
8278  else {
8279  if (nd_type((yyvsp[(2) - (9)].node)) == NODE_LASGN ||
8280  nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN ||
8281  nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN_CURR) {
8282  (yyvsp[(2) - (9)].node)->nd_value = NEW_DVAR(id);
8283  m->nd_plen = 1;
8284  m->nd_next = (yyvsp[(2) - (9)].node);
8285  args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
8286  }
8287  else {
8288  m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].node)), 0), NEW_DVAR(id));
8289  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8290  }
8291  }
8292  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].node), args);
8293  tbl[0] = 1; tbl[1] = id;
8294  (yyval.node) = NEW_FOR(0, (yyvsp[(5) - (9)].node), scope);
8295  fixpos((yyval.node), (yyvsp[(2) - (9)].node));
8296  /*%
8297  $$ = dispatch3(for, $2, $5, $8);
8298  %*/
8299  }
8300  break;
8301 
8302  case 323:
8303 
8304 /* Line 1806 of yacc.c */
8305 #line 2898 "parse.y"
8306  {
8307  if (in_def || in_single)
8308  yyerror("class definition in method body");
8309  local_push(0);
8310  /*%%%*/
8311  (yyval.num) = ruby_sourceline;
8312  /*%
8313  %*/
8314  }
8315  break;
8316 
8317  case 324:
8318 
8319 /* Line 1806 of yacc.c */
8320 #line 2909 "parse.y"
8321  {
8322  /*%%%*/
8323  (yyval.node) = NEW_CLASS((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(3) - (6)].node));
8324  nd_set_line((yyval.node), (yyvsp[(4) - (6)].num));
8325  /*%
8326  $$ = dispatch3(class, $2, $3, $5);
8327  %*/
8328  local_pop();
8329  }
8330  break;
8331 
8332  case 325:
8333 
8334 /* Line 1806 of yacc.c */
8335 #line 2919 "parse.y"
8336  {
8337  (yyval.num) = in_def;
8338  in_def = 0;
8339  }
8340  break;
8341 
8342  case 326:
8343 
8344 /* Line 1806 of yacc.c */
8345 #line 2924 "parse.y"
8346  {
8347  (yyval.num) = in_single;
8348  in_single = 0;
8349  local_push(0);
8350  }
8351  break;
8352 
8353  case 327:
8354 
8355 /* Line 1806 of yacc.c */
8356 #line 2931 "parse.y"
8357  {
8358  /*%%%*/
8359  (yyval.node) = NEW_SCLASS((yyvsp[(3) - (8)].node), (yyvsp[(7) - (8)].node));
8360  fixpos((yyval.node), (yyvsp[(3) - (8)].node));
8361  /*%
8362  $$ = dispatch2(sclass, $3, $7);
8363  %*/
8364  local_pop();
8365  in_def = (yyvsp[(4) - (8)].num);
8366  in_single = (yyvsp[(6) - (8)].num);
8367  }
8368  break;
8369 
8370  case 328:
8371 
8372 /* Line 1806 of yacc.c */
8373 #line 2943 "parse.y"
8374  {
8375  if (in_def || in_single)
8376  yyerror("module definition in method body");
8377  local_push(0);
8378  /*%%%*/
8379  (yyval.num) = ruby_sourceline;
8380  /*%
8381  %*/
8382  }
8383  break;
8384 
8385  case 329:
8386 
8387 /* Line 1806 of yacc.c */
8388 #line 2954 "parse.y"
8389  {
8390  /*%%%*/
8391  (yyval.node) = NEW_MODULE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node));
8392  nd_set_line((yyval.node), (yyvsp[(3) - (5)].num));
8393  /*%
8394  $$ = dispatch2(module, $2, $4);
8395  %*/
8396  local_pop();
8397  }
8398  break;
8399 
8400  case 330:
8401 
8402 /* Line 1806 of yacc.c */
8403 #line 2964 "parse.y"
8404  {
8405  (yyval.id) = cur_mid;
8406  cur_mid = (yyvsp[(2) - (2)].id);
8407  in_def++;
8408  local_push(0);
8409  }
8410  break;
8411 
8412  case 331:
8413 
8414 /* Line 1806 of yacc.c */
8415 #line 2973 "parse.y"
8416  {
8417  /*%%%*/
8418  NODE *body = remove_begin((yyvsp[(5) - (6)].node));
8419  reduce_nodes(&body);
8420  (yyval.node) = NEW_DEFN((yyvsp[(2) - (6)].id), (yyvsp[(4) - (6)].node), body, NOEX_PRIVATE);
8421  nd_set_line((yyval.node), (yyvsp[(1) - (6)].num));
8422  /*%
8423  $$ = dispatch3(def, $2, $4, $5);
8424  %*/
8425  local_pop();
8426  in_def--;
8427  cur_mid = (yyvsp[(3) - (6)].id);
8428  }
8429  break;
8430 
8431  case 332:
8432 
8433 /* Line 1806 of yacc.c */
8434 #line 2986 "parse.y"
8435  {lex_state = EXPR_FNAME;}
8436  break;
8437 
8438  case 333:
8439 
8440 /* Line 1806 of yacc.c */
8441 #line 2987 "parse.y"
8442  {
8443  in_single++;
8444  lex_state = EXPR_ENDFN; /* force for args */
8445  local_push(0);
8446  }
8447  break;
8448 
8449  case 334:
8450 
8451 /* Line 1806 of yacc.c */
8452 #line 2995 "parse.y"
8453  {
8454  /*%%%*/
8455  NODE *body = remove_begin((yyvsp[(8) - (9)].node));
8456  reduce_nodes(&body);
8457  (yyval.node) = NEW_DEFS((yyvsp[(2) - (9)].node), (yyvsp[(5) - (9)].id), (yyvsp[(7) - (9)].node), body);
8458  nd_set_line((yyval.node), (yyvsp[(1) - (9)].num));
8459  /*%
8460  $$ = dispatch5(defs, $2, $3, $5, $7, $8);
8461  %*/
8462  local_pop();
8463  in_single--;
8464  }
8465  break;
8466 
8467  case 335:
8468 
8469 /* Line 1806 of yacc.c */
8470 #line 3008 "parse.y"
8471  {
8472  /*%%%*/
8473  (yyval.node) = NEW_BREAK(0);
8474  /*%
8475  $$ = dispatch1(break, arg_new());
8476  %*/
8477  }
8478  break;
8479 
8480  case 336:
8481 
8482 /* Line 1806 of yacc.c */
8483 #line 3016 "parse.y"
8484  {
8485  /*%%%*/
8486  (yyval.node) = NEW_NEXT(0);
8487  /*%
8488  $$ = dispatch1(next, arg_new());
8489  %*/
8490  }
8491  break;
8492 
8493  case 337:
8494 
8495 /* Line 1806 of yacc.c */
8496 #line 3024 "parse.y"
8497  {
8498  /*%%%*/
8499  (yyval.node) = NEW_REDO();
8500  /*%
8501  $$ = dispatch0(redo);
8502  %*/
8503  }
8504  break;
8505 
8506  case 338:
8507 
8508 /* Line 1806 of yacc.c */
8509 #line 3032 "parse.y"
8510  {
8511  /*%%%*/
8512  (yyval.node) = NEW_RETRY();
8513  /*%
8514  $$ = dispatch0(retry);
8515  %*/
8516  }
8517  break;
8518 
8519  case 339:
8520 
8521 /* Line 1806 of yacc.c */
8522 #line 3042 "parse.y"
8523  {
8524  /*%%%*/
8525  value_expr((yyvsp[(1) - (1)].node));
8526  (yyval.node) = (yyvsp[(1) - (1)].node);
8527  if (!(yyval.node)) (yyval.node) = NEW_NIL();
8528  /*%
8529  $$ = $1;
8530  %*/
8531  }
8532  break;
8533 
8534  case 340:
8535 
8536 /* Line 1806 of yacc.c */
8537 #line 3054 "parse.y"
8538  {
8539  token_info_push("begin");
8540  }
8541  break;
8542 
8543  case 341:
8544 
8545 /* Line 1806 of yacc.c */
8546 #line 3060 "parse.y"
8547  {
8548  token_info_push("if");
8549  }
8550  break;
8551 
8552  case 342:
8553 
8554 /* Line 1806 of yacc.c */
8555 #line 3066 "parse.y"
8556  {
8557  token_info_push("unless");
8558  }
8559  break;
8560 
8561  case 343:
8562 
8563 /* Line 1806 of yacc.c */
8564 #line 3072 "parse.y"
8565  {
8566  token_info_push("while");
8567  }
8568  break;
8569 
8570  case 344:
8571 
8572 /* Line 1806 of yacc.c */
8573 #line 3078 "parse.y"
8574  {
8575  token_info_push("until");
8576  }
8577  break;
8578 
8579  case 345:
8580 
8581 /* Line 1806 of yacc.c */
8582 #line 3084 "parse.y"
8583  {
8584  token_info_push("case");
8585  }
8586  break;
8587 
8588  case 346:
8589 
8590 /* Line 1806 of yacc.c */
8591 #line 3090 "parse.y"
8592  {
8593  token_info_push("for");
8594  }
8595  break;
8596 
8597  case 347:
8598 
8599 /* Line 1806 of yacc.c */
8600 #line 3096 "parse.y"
8601  {
8602  token_info_push("class");
8603  }
8604  break;
8605 
8606  case 348:
8607 
8608 /* Line 1806 of yacc.c */
8609 #line 3102 "parse.y"
8610  {
8611  token_info_push("module");
8612  }
8613  break;
8614 
8615  case 349:
8616 
8617 /* Line 1806 of yacc.c */
8618 #line 3108 "parse.y"
8619  {
8620  token_info_push("def");
8621  /*%%%*/
8622  (yyval.num) = ruby_sourceline;
8623  /*%
8624  %*/
8625  }
8626  break;
8627 
8628  case 350:
8629 
8630 /* Line 1806 of yacc.c */
8631 #line 3118 "parse.y"
8632  {
8633  token_info_pop("end");
8634  }
8635  break;
8636 
8637  case 357:
8638 
8639 /* Line 1806 of yacc.c */
8640 #line 3148 "parse.y"
8641  {
8642  /*%%%*/
8643  (yyval.node) = NEW_IF(cond((yyvsp[(2) - (5)].node)), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
8644  fixpos((yyval.node), (yyvsp[(2) - (5)].node));
8645  /*%
8646  $$ = dispatch3(elsif, $2, $4, escape_Qundef($5));
8647  %*/
8648  }
8649  break;
8650 
8651  case 359:
8652 
8653 /* Line 1806 of yacc.c */
8654 #line 3160 "parse.y"
8655  {
8656  /*%%%*/
8657  (yyval.node) = (yyvsp[(2) - (2)].node);
8658  /*%
8659  $$ = dispatch1(else, $2);
8660  %*/
8661  }
8662  break;
8663 
8664  case 362:
8665 
8666 /* Line 1806 of yacc.c */
8667 #line 3174 "parse.y"
8668  {
8669  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
8670  /*%%%*/
8671  /*%
8672  $$ = dispatch1(mlhs_paren, $$);
8673  %*/
8674  }
8675  break;
8676 
8677  case 363:
8678 
8679 /* Line 1806 of yacc.c */
8680 #line 3182 "parse.y"
8681  {
8682  /*%%%*/
8683  (yyval.node) = (yyvsp[(2) - (3)].node);
8684  /*%
8685  $$ = dispatch1(mlhs_paren, $2);
8686  %*/
8687  }
8688  break;
8689 
8690  case 364:
8691 
8692 /* Line 1806 of yacc.c */
8693 #line 3192 "parse.y"
8694  {
8695  /*%%%*/
8696  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
8697  /*%
8698  $$ = mlhs_add(mlhs_new(), $1);
8699  %*/
8700  }
8701  break;
8702 
8703  case 365:
8704 
8705 /* Line 1806 of yacc.c */
8706 #line 3200 "parse.y"
8707  {
8708  /*%%%*/
8709  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
8710  /*%
8711  $$ = mlhs_add($1, $3);
8712  %*/
8713  }
8714  break;
8715 
8716  case 366:
8717 
8718 /* Line 1806 of yacc.c */
8719 #line 3210 "parse.y"
8720  {
8721  /*%%%*/
8722  (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0);
8723  /*%
8724  $$ = $1;
8725  %*/
8726  }
8727  break;
8728 
8729  case 367:
8730 
8731 /* Line 1806 of yacc.c */
8732 #line 3218 "parse.y"
8733  {
8734  (yyval.node) = assignable((yyvsp[(4) - (4)].id), 0);
8735  /*%%%*/
8736  (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), (yyval.node));
8737  /*%
8738  $$ = mlhs_add_star($1, $$);
8739  %*/
8740  }
8741  break;
8742 
8743  case 368:
8744 
8745 /* Line 1806 of yacc.c */
8746 #line 3227 "parse.y"
8747  {
8748  (yyval.node) = assignable((yyvsp[(4) - (6)].id), 0);
8749  /*%%%*/
8750  (yyval.node) = NEW_MASGN((yyvsp[(1) - (6)].node), NEW_POSTARG((yyval.node), (yyvsp[(6) - (6)].node)));
8751  /*%
8752  $$ = mlhs_add_star($1, $$);
8753  %*/
8754  }
8755  break;
8756 
8757  case 369:
8758 
8759 /* Line 1806 of yacc.c */
8760 #line 3236 "parse.y"
8761  {
8762  /*%%%*/
8763  (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), -1);
8764  /*%
8765  $$ = mlhs_add_star($1, Qnil);
8766  %*/
8767  }
8768  break;
8769 
8770  case 370:
8771 
8772 /* Line 1806 of yacc.c */
8773 #line 3244 "parse.y"
8774  {
8775  /*%%%*/
8776  (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG(-1, (yyvsp[(5) - (5)].node)));
8777  /*%
8778  $$ = mlhs_add_star($1, $5);
8779  %*/
8780  }
8781  break;
8782 
8783  case 371:
8784 
8785 /* Line 1806 of yacc.c */
8786 #line 3252 "parse.y"
8787  {
8788  (yyval.node) = assignable((yyvsp[(2) - (2)].id), 0);
8789  /*%%%*/
8790  (yyval.node) = NEW_MASGN(0, (yyval.node));
8791  /*%
8792  $$ = mlhs_add_star(mlhs_new(), $$);
8793  %*/
8794  }
8795  break;
8796 
8797  case 372:
8798 
8799 /* Line 1806 of yacc.c */
8800 #line 3261 "parse.y"
8801  {
8802  (yyval.node) = assignable((yyvsp[(2) - (4)].id), 0);
8803  /*%%%*/
8804  (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyval.node), (yyvsp[(4) - (4)].node)));
8805  /*%
8806  #if 0
8807  TODO: Check me
8808  #endif
8809  $$ = mlhs_add_star($$, $4);
8810  %*/
8811  }
8812  break;
8813 
8814  case 373:
8815 
8816 /* Line 1806 of yacc.c */
8817 #line 3273 "parse.y"
8818  {
8819  /*%%%*/
8820  (yyval.node) = NEW_MASGN(0, -1);
8821  /*%
8822  $$ = mlhs_add_star(mlhs_new(), Qnil);
8823  %*/
8824  }
8825  break;
8826 
8827  case 374:
8828 
8829 /* Line 1806 of yacc.c */
8830 #line 3281 "parse.y"
8831  {
8832  /*%%%*/
8833  (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node)));
8834  /*%
8835  $$ = mlhs_add_star(mlhs_new(), Qnil);
8836  %*/
8837  }
8838  break;
8839 
8840  case 375:
8841 
8842 /* Line 1806 of yacc.c */
8843 #line 3292 "parse.y"
8844  {
8845  (yyval.node) = new_args_tail((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id));
8846  }
8847  break;
8848 
8849  case 376:
8850 
8851 /* Line 1806 of yacc.c */
8852 #line 3296 "parse.y"
8853  {
8854  (yyval.node) = new_args_tail((yyvsp[(1) - (2)].node), Qnone, (yyvsp[(2) - (2)].id));
8855  }
8856  break;
8857 
8858  case 377:
8859 
8860 /* Line 1806 of yacc.c */
8861 #line 3300 "parse.y"
8862  {
8863  (yyval.node) = new_args_tail(Qnone, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id));
8864  }
8865  break;
8866 
8867  case 378:
8868 
8869 /* Line 1806 of yacc.c */
8870 #line 3304 "parse.y"
8871  {
8872  (yyval.node) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].id));
8873  }
8874  break;
8875 
8876  case 379:
8877 
8878 /* Line 1806 of yacc.c */
8879 #line 3310 "parse.y"
8880  {
8881  (yyval.node) = (yyvsp[(2) - (2)].node);
8882  }
8883  break;
8884 
8885  case 380:
8886 
8887 /* Line 1806 of yacc.c */
8888 #line 3314 "parse.y"
8889  {
8890  (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
8891  }
8892  break;
8893 
8894  case 381:
8895 
8896 /* Line 1806 of yacc.c */
8897 #line 3320 "parse.y"
8898  {
8899  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), Qnone, (yyvsp[(6) - (6)].node));
8900  }
8901  break;
8902 
8903  case 382:
8904 
8905 /* Line 1806 of yacc.c */
8906 #line 3324 "parse.y"
8907  {
8908  (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].node));
8909  }
8910  break;
8911 
8912  case 383:
8913 
8914 /* Line 1806 of yacc.c */
8915 #line 3328 "parse.y"
8916  {
8917  (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), Qnone, Qnone, (yyvsp[(4) - (4)].node));
8918  }
8919  break;
8920 
8921  case 384:
8922 
8923 /* Line 1806 of yacc.c */
8924 #line 3332 "parse.y"
8925  {
8926  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), Qnone, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
8927  }
8928  break;
8929 
8930  case 385:
8931 
8932 /* Line 1806 of yacc.c */
8933 #line 3336 "parse.y"
8934  {
8935  (yyval.node) = new_args((yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
8936  }
8937  break;
8938 
8939  case 386:
8940 
8941 /* Line 1806 of yacc.c */
8942 #line 3340 "parse.y"
8943  {
8944  (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
8945  /*%%%*/
8946  /*%
8947  dispatch1(excessed_comma, $$);
8948  %*/
8949  }
8950  break;
8951 
8952  case 387:
8953 
8954 /* Line 1806 of yacc.c */
8955 #line 3348 "parse.y"
8956  {
8957  (yyval.node) = new_args((yyvsp[(1) - (6)].node), Qnone, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
8958  }
8959  break;
8960 
8961  case 388:
8962 
8963 /* Line 1806 of yacc.c */
8964 #line 3352 "parse.y"
8965  {
8966  (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].node));
8967  }
8968  break;
8969 
8970  case 389:
8971 
8972 /* Line 1806 of yacc.c */
8973 #line 3356 "parse.y"
8974  {
8975  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
8976  }
8977  break;
8978 
8979  case 390:
8980 
8981 /* Line 1806 of yacc.c */
8982 #line 3360 "parse.y"
8983  {
8984  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
8985  }
8986  break;
8987 
8988  case 391:
8989 
8990 /* Line 1806 of yacc.c */
8991 #line 3364 "parse.y"
8992  {
8993  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (2)].node), Qnone, Qnone, (yyvsp[(2) - (2)].node));
8994  }
8995  break;
8996 
8997  case 392:
8998 
8999 /* Line 1806 of yacc.c */
9000 #line 3368 "parse.y"
9001  {
9002  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
9003  }
9004  break;
9005 
9006  case 393:
9007 
9008 /* Line 1806 of yacc.c */
9009 #line 3372 "parse.y"
9010  {
9011  (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].id), Qnone, (yyvsp[(2) - (2)].node));
9012  }
9013  break;
9014 
9015  case 394:
9016 
9017 /* Line 1806 of yacc.c */
9018 #line 3376 "parse.y"
9019  {
9020  (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
9021  }
9022  break;
9023 
9024  case 395:
9025 
9026 /* Line 1806 of yacc.c */
9027 #line 3380 "parse.y"
9028  {
9029  (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].node));
9030  }
9031  break;
9032 
9033  case 397:
9034 
9035 /* Line 1806 of yacc.c */
9036 #line 3387 "parse.y"
9037  {
9038  command_start = TRUE;
9039  }
9040  break;
9041 
9042  case 398:
9043 
9044 /* Line 1806 of yacc.c */
9045 #line 3393 "parse.y"
9046  {
9047  /*%%%*/
9048  (yyval.node) = 0;
9049  /*%
9050  $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9051  escape_Qundef($2));
9052  %*/
9053  }
9054  break;
9055 
9056  case 399:
9057 
9058 /* Line 1806 of yacc.c */
9059 #line 3402 "parse.y"
9060  {
9061  /*%%%*/
9062  (yyval.node) = 0;
9063  /*%
9064  $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9065  Qnil);
9066  %*/
9067  }
9068  break;
9069 
9070  case 400:
9071 
9072 /* Line 1806 of yacc.c */
9073 #line 3411 "parse.y"
9074  {
9075  /*%%%*/
9076  (yyval.node) = (yyvsp[(2) - (4)].node);
9077  /*%
9078  $$ = blockvar_new(escape_Qundef($2), escape_Qundef($3));
9079  %*/
9080  }
9081  break;
9082 
9083  case 401:
9084 
9085 /* Line 1806 of yacc.c */
9086 #line 3422 "parse.y"
9087  {
9088  (yyval.node) = 0;
9089  }
9090  break;
9091 
9092  case 402:
9093 
9094 /* Line 1806 of yacc.c */
9095 #line 3426 "parse.y"
9096  {
9097  /*%%%*/
9098  (yyval.node) = 0;
9099  /*%
9100  $$ = $3;
9101  %*/
9102  }
9103  break;
9104 
9105  case 405:
9106 
9107 /* Line 1806 of yacc.c */
9108 #line 3452 "parse.y"
9109  {
9110  new_bv(get_id((yyvsp[(1) - (1)].id)));
9111  /*%%%*/
9112  /*%
9113  $$ = get_value($1);
9114  %*/
9115  }
9116  break;
9117 
9118  case 406:
9119 
9120 /* Line 1806 of yacc.c */
9121 #line 3460 "parse.y"
9122  {
9123  (yyval.node) = 0;
9124  }
9125  break;
9126 
9127  case 407:
9128 
9129 /* Line 1806 of yacc.c */
9130 #line 3465 "parse.y"
9131  {
9132  (yyval.vars) = dyna_push();
9133  }
9134  break;
9135 
9136  case 408:
9137 
9138 /* Line 1806 of yacc.c */
9139 #line 3468 "parse.y"
9140  {
9141  (yyval.num) = lpar_beg;
9142  lpar_beg = ++paren_nest;
9143  }
9144  break;
9145 
9146  case 409:
9147 
9148 /* Line 1806 of yacc.c */
9149 #line 3473 "parse.y"
9150  {
9151  (yyval.num) = ruby_sourceline;
9152  }
9153  break;
9154 
9155  case 410:
9156 
9157 /* Line 1806 of yacc.c */
9158 #line 3477 "parse.y"
9159  {
9160  lpar_beg = (yyvsp[(2) - (5)].num);
9161  /*%%%*/
9162  (yyval.node) = NEW_LAMBDA((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));
9163  nd_set_line((yyval.node), (yyvsp[(4) - (5)].num));
9164  /*%
9165  $$ = dispatch2(lambda, $3, $5);
9166  %*/
9167  dyna_pop((yyvsp[(1) - (5)].vars));
9168  }
9169  break;
9170 
9171  case 411:
9172 
9173 /* Line 1806 of yacc.c */
9174 #line 3490 "parse.y"
9175  {
9176  /*%%%*/
9177  (yyval.node) = (yyvsp[(2) - (4)].node);
9178  /*%
9179  $$ = dispatch1(paren, $2);
9180  %*/
9181  }
9182  break;
9183 
9184  case 412:
9185 
9186 /* Line 1806 of yacc.c */
9187 #line 3498 "parse.y"
9188  {
9189  /*%%%*/
9190  (yyval.node) = (yyvsp[(1) - (1)].node);
9191  /*%
9192  $$ = $1;
9193  %*/
9194  }
9195  break;
9196 
9197  case 413:
9198 
9199 /* Line 1806 of yacc.c */
9200 #line 3508 "parse.y"
9201  {
9202  (yyval.node) = (yyvsp[(2) - (3)].node);
9203  }
9204  break;
9205 
9206  case 414:
9207 
9208 /* Line 1806 of yacc.c */
9209 #line 3512 "parse.y"
9210  {
9211  (yyval.node) = (yyvsp[(2) - (3)].node);
9212  }
9213  break;
9214 
9215  case 415:
9216 
9217 /* Line 1806 of yacc.c */
9218 #line 3518 "parse.y"
9219  {
9220  (yyvsp[(1) - (1)].vars) = dyna_push();
9221  /*%%%*/
9222  (yyval.num) = ruby_sourceline;
9223  /*% %*/
9224  }
9225  break;
9226 
9227  case 416:
9228 
9229 /* Line 1806 of yacc.c */
9230 #line 3527 "parse.y"
9231  {
9232  /*%%%*/
9233  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
9234  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
9235  /*%
9236  $$ = dispatch2(do_block, escape_Qundef($3), $4);
9237  %*/
9238  dyna_pop((yyvsp[(1) - (5)].vars));
9239  }
9240  break;
9241 
9242  case 417:
9243 
9244 /* Line 1806 of yacc.c */
9245 #line 3539 "parse.y"
9246  {
9247  /*%%%*/
9248  if (nd_type((yyvsp[(1) - (2)].node)) == NODE_YIELD) {
9249  compile_error(PARSER_ARG "block given to yield");
9250  }
9251  else {
9252  block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node));
9253  }
9254  (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
9255  (yyval.node) = (yyvsp[(2) - (2)].node);
9256  fixpos((yyval.node), (yyvsp[(1) - (2)].node));
9257  /*%
9258  $$ = method_add_block($1, $2);
9259  %*/
9260  }
9261  break;
9262 
9263  case 418:
9264 
9265 /* Line 1806 of yacc.c */
9266 #line 3555 "parse.y"
9267  {
9268  /*%%%*/
9269  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
9270  /*%
9271  $$ = dispatch3(call, $1, $2, $3);
9272  $$ = method_optarg($$, $4);
9273  %*/
9274  }
9275  break;
9276 
9277  case 419:
9278 
9279 /* Line 1806 of yacc.c */
9280 #line 3564 "parse.y"
9281  {
9282  /*%%%*/
9283  block_dup_check((yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
9284  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
9285  (yyval.node) = (yyvsp[(5) - (5)].node);
9286  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
9287  /*%
9288  $$ = dispatch4(command_call, $1, $2, $3, $4);
9289  $$ = method_add_block($$, $5);
9290  %*/
9291  }
9292  break;
9293 
9294  case 420:
9295 
9296 /* Line 1806 of yacc.c */
9297 #line 3576 "parse.y"
9298  {
9299  /*%%%*/
9300  block_dup_check((yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
9301  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
9302  (yyval.node) = (yyvsp[(5) - (5)].node);
9303  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
9304  /*%
9305  $$ = dispatch4(command_call, $1, $2, $3, $4);
9306  $$ = method_add_block($$, $5);
9307  %*/
9308  }
9309  break;
9310 
9311  case 421:
9312 
9313 /* Line 1806 of yacc.c */
9314 #line 3590 "parse.y"
9315  {
9316  /*%%%*/
9317  (yyval.node) = (yyvsp[(1) - (2)].node);
9318  (yyval.node)->nd_args = (yyvsp[(2) - (2)].node);
9319  /*%
9320  $$ = method_arg(dispatch1(fcall, $1), $2);
9321  %*/
9322  }
9323  break;
9324 
9325  case 422:
9326 
9327 /* Line 1806 of yacc.c */
9328 #line 3599 "parse.y"
9329  {
9330  /*%%%*/
9331  (yyval.num) = ruby_sourceline;
9332  /*% %*/
9333  }
9334  break;
9335 
9336  case 423:
9337 
9338 /* Line 1806 of yacc.c */
9339 #line 3605 "parse.y"
9340  {
9341  /*%%%*/
9342  (yyval.node) = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].node));
9343  nd_set_line((yyval.node), (yyvsp[(4) - (5)].num));
9344  /*%
9345  $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
9346  $$ = method_optarg($$, $5);
9347  %*/
9348  }
9349  break;
9350 
9351  case 424:
9352 
9353 /* Line 1806 of yacc.c */
9354 #line 3615 "parse.y"
9355  {
9356  /*%%%*/
9357  (yyval.num) = ruby_sourceline;
9358  /*% %*/
9359  }
9360  break;
9361 
9362  case 425:
9363 
9364 /* Line 1806 of yacc.c */
9365 #line 3621 "parse.y"
9366  {
9367  /*%%%*/
9368  (yyval.node) = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].node));
9369  nd_set_line((yyval.node), (yyvsp[(4) - (5)].num));
9370  /*%
9371  $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
9372  $$ = method_optarg($$, $5);
9373  %*/
9374  }
9375  break;
9376 
9377  case 426:
9378 
9379 /* Line 1806 of yacc.c */
9380 #line 3631 "parse.y"
9381  {
9382  /*%%%*/
9383  (yyval.node) = NEW_CALL((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id), 0);
9384  /*%
9385  $$ = dispatch3(call, $1, ripper_intern("::"), $3);
9386  %*/
9387  }
9388  break;
9389 
9390  case 427:
9391 
9392 /* Line 1806 of yacc.c */
9393 #line 3639 "parse.y"
9394  {
9395  /*%%%*/
9396  (yyval.num) = ruby_sourceline;
9397  /*% %*/
9398  }
9399  break;
9400 
9401  case 428:
9402 
9403 /* Line 1806 of yacc.c */
9404 #line 3645 "parse.y"
9405  {
9406  /*%%%*/
9407  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), rb_intern("call"), (yyvsp[(4) - (4)].node));
9408  nd_set_line((yyval.node), (yyvsp[(3) - (4)].num));
9409  /*%
9410  $$ = dispatch3(call, $1, ripper_id2sym('.'),
9411  ripper_intern("call"));
9412  $$ = method_optarg($$, $4);
9413  %*/
9414  }
9415  break;
9416 
9417  case 429:
9418 
9419 /* Line 1806 of yacc.c */
9420 #line 3656 "parse.y"
9421  {
9422  /*%%%*/
9423  (yyval.num) = ruby_sourceline;
9424  /*% %*/
9425  }
9426  break;
9427 
9428  case 430:
9429 
9430 /* Line 1806 of yacc.c */
9431 #line 3662 "parse.y"
9432  {
9433  /*%%%*/
9434  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), rb_intern("call"), (yyvsp[(4) - (4)].node));
9435  nd_set_line((yyval.node), (yyvsp[(3) - (4)].num));
9436  /*%
9437  $$ = dispatch3(call, $1, ripper_intern("::"),
9438  ripper_intern("call"));
9439  $$ = method_optarg($$, $4);
9440  %*/
9441  }
9442  break;
9443 
9444  case 431:
9445 
9446 /* Line 1806 of yacc.c */
9447 #line 3673 "parse.y"
9448  {
9449  /*%%%*/
9450  (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node));
9451  /*%
9452  $$ = dispatch1(super, $2);
9453  %*/
9454  }
9455  break;
9456 
9457  case 432:
9458 
9459 /* Line 1806 of yacc.c */
9460 #line 3681 "parse.y"
9461  {
9462  /*%%%*/
9463  (yyval.node) = NEW_ZSUPER();
9464  /*%
9465  $$ = dispatch0(zsuper);
9466  %*/
9467  }
9468  break;
9469 
9470  case 433:
9471 
9472 /* Line 1806 of yacc.c */
9473 #line 3689 "parse.y"
9474  {
9475  /*%%%*/
9476  if ((yyvsp[(1) - (4)].node) && nd_type((yyvsp[(1) - (4)].node)) == NODE_SELF)
9477  (yyval.node) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].node));
9478  else
9479  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), tAREF, (yyvsp[(3) - (4)].node));
9480  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
9481  /*%
9482  $$ = dispatch2(aref, $1, escape_Qundef($3));
9483  %*/
9484  }
9485  break;
9486 
9487  case 434:
9488 
9489 /* Line 1806 of yacc.c */
9490 #line 3703 "parse.y"
9491  {
9492  (yyvsp[(1) - (1)].vars) = dyna_push();
9493  /*%%%*/
9494  (yyval.num) = ruby_sourceline;
9495  /*%
9496  %*/
9497  }
9498  break;
9499 
9500  case 435:
9501 
9502 /* Line 1806 of yacc.c */
9503 #line 3712 "parse.y"
9504  {
9505  /*%%%*/
9506  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
9507  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
9508  /*%
9509  $$ = dispatch2(brace_block, escape_Qundef($3), $4);
9510  %*/
9511  dyna_pop((yyvsp[(1) - (5)].vars));
9512  }
9513  break;
9514 
9515  case 436:
9516 
9517 /* Line 1806 of yacc.c */
9518 #line 3722 "parse.y"
9519  {
9520  (yyvsp[(1) - (1)].vars) = dyna_push();
9521  /*%%%*/
9522  (yyval.num) = ruby_sourceline;
9523  /*%
9524  %*/
9525  }
9526  break;
9527 
9528  case 437:
9529 
9530 /* Line 1806 of yacc.c */
9531 #line 3731 "parse.y"
9532  {
9533  /*%%%*/
9534  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
9535  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
9536  /*%
9537  $$ = dispatch2(do_block, escape_Qundef($3), $4);
9538  %*/
9539  dyna_pop((yyvsp[(1) - (5)].vars));
9540  }
9541  break;
9542 
9543  case 438:
9544 
9545 /* Line 1806 of yacc.c */
9546 #line 3745 "parse.y"
9547  {
9548  /*%%%*/
9549  (yyval.node) = NEW_WHEN((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
9550  /*%
9551  $$ = dispatch3(when, $2, $4, escape_Qundef($5));
9552  %*/
9553  }
9554  break;
9555 
9556  case 441:
9557 
9558 /* Line 1806 of yacc.c */
9559 #line 3761 "parse.y"
9560  {
9561  /*%%%*/
9562  if ((yyvsp[(3) - (6)].node)) {
9563  (yyvsp[(3) - (6)].node) = node_assign((yyvsp[(3) - (6)].node), NEW_ERRINFO());
9564  (yyvsp[(5) - (6)].node) = block_append((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node));
9565  }
9566  (yyval.node) = NEW_RESBODY((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
9567  fixpos((yyval.node), (yyvsp[(2) - (6)].node)?(yyvsp[(2) - (6)].node):(yyvsp[(5) - (6)].node));
9568  /*%
9569  $$ = dispatch4(rescue,
9570  escape_Qundef($2),
9571  escape_Qundef($3),
9572  escape_Qundef($5),
9573  escape_Qundef($6));
9574  %*/
9575  }
9576  break;
9577 
9578  case 443:
9579 
9580 /* Line 1806 of yacc.c */
9581 #line 3781 "parse.y"
9582  {
9583  /*%%%*/
9584  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
9585  /*%
9586  $$ = rb_ary_new3(1, $1);
9587  %*/
9588  }
9589  break;
9590 
9591  case 444:
9592 
9593 /* Line 1806 of yacc.c */
9594 #line 3789 "parse.y"
9595  {
9596  /*%%%*/
9597  if (!((yyval.node) = splat_array((yyvsp[(1) - (1)].node)))) (yyval.node) = (yyvsp[(1) - (1)].node);
9598  /*%
9599  $$ = $1;
9600  %*/
9601  }
9602  break;
9603 
9604  case 446:
9605 
9606 /* Line 1806 of yacc.c */
9607 #line 3800 "parse.y"
9608  {
9609  (yyval.node) = (yyvsp[(2) - (2)].node);
9610  }
9611  break;
9612 
9613  case 448:
9614 
9615 /* Line 1806 of yacc.c */
9616 #line 3807 "parse.y"
9617  {
9618  /*%%%*/
9619  (yyval.node) = (yyvsp[(2) - (2)].node);
9620  /*%
9621  $$ = dispatch1(ensure, $2);
9622  %*/
9623  }
9624  break;
9625 
9626  case 451:
9627 
9628 /* Line 1806 of yacc.c */
9629 #line 3819 "parse.y"
9630  {
9631  /*%%%*/
9632  (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id)));
9633  /*%
9634  $$ = dispatch1(symbol_literal, $1);
9635  %*/
9636  }
9637  break;
9638 
9639  case 453:
9640 
9641 /* Line 1806 of yacc.c */
9642 #line 3830 "parse.y"
9643  {
9644  /*%%%*/
9645  NODE *node = (yyvsp[(1) - (1)].node);
9646  if (!node) {
9647  node = NEW_STR(STR_NEW0());
9648  }
9649  else {
9650  node = evstr2dstr(node);
9651  }
9652  (yyval.node) = node;
9653  /*%
9654  $$ = $1;
9655  %*/
9656  }
9657  break;
9658 
9659  case 456:
9660 
9661 /* Line 1806 of yacc.c */
9662 #line 3849 "parse.y"
9663  {
9664  /*%%%*/
9665  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
9666  /*%
9667  $$ = dispatch2(string_concat, $1, $2);
9668  %*/
9669  }
9670  break;
9671 
9672  case 457:
9673 
9674 /* Line 1806 of yacc.c */
9675 #line 3859 "parse.y"
9676  {
9677  /*%%%*/
9678  (yyval.node) = (yyvsp[(2) - (3)].node);
9679  /*%
9680  $$ = dispatch1(string_literal, $2);
9681  %*/
9682  }
9683  break;
9684 
9685  case 458:
9686 
9687 /* Line 1806 of yacc.c */
9688 #line 3869 "parse.y"
9689  {
9690  /*%%%*/
9691  NODE *node = (yyvsp[(2) - (3)].node);
9692  if (!node) {
9693  node = NEW_XSTR(STR_NEW0());
9694  }
9695  else {
9696  switch (nd_type(node)) {
9697  case NODE_STR:
9698  nd_set_type(node, NODE_XSTR);
9699  break;
9700  case NODE_DSTR:
9701  nd_set_type(node, NODE_DXSTR);
9702  break;
9703  default:
9704  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
9705  break;
9706  }
9707  }
9708  (yyval.node) = node;
9709  /*%
9710  $$ = dispatch1(xstring_literal, $2);
9711  %*/
9712  }
9713  break;
9714 
9715  case 459:
9716 
9717 /* Line 1806 of yacc.c */
9718 #line 3896 "parse.y"
9719  {
9720  /*%%%*/
9721  int options = (yyvsp[(3) - (3)].num);
9722  NODE *node = (yyvsp[(2) - (3)].node);
9723  NODE *list, *prev;
9724  if (!node) {
9725  node = NEW_LIT(reg_compile(STR_NEW0(), options));
9726  }
9727  else switch (nd_type(node)) {
9728  case NODE_STR:
9729  {
9730  VALUE src = node->nd_lit;
9731  nd_set_type(node, NODE_LIT);
9732  node->nd_lit = reg_compile(src, options);
9733  }
9734  break;
9735  default:
9736  node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
9737  case NODE_DSTR:
9738  if (options & RE_OPTION_ONCE) {
9740  }
9741  else {
9742  nd_set_type(node, NODE_DREGX);
9743  }
9744  node->nd_cflag = options & RE_OPTION_MASK;
9745  if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
9746  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
9747  if (nd_type(list->nd_head) == NODE_STR) {
9748  VALUE tail = list->nd_head->nd_lit;
9749  if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
9750  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
9751  if (!literal_concat0(parser, lit, tail)) {
9752  node = 0;
9753  break;
9754  }
9755  rb_str_resize(tail, 0);
9756  prev->nd_next = list->nd_next;
9757  rb_gc_force_recycle((VALUE)list->nd_head);
9758  rb_gc_force_recycle((VALUE)list);
9759  list = prev;
9760  }
9761  else {
9762  prev = list;
9763  }
9764  }
9765  else {
9766  prev = 0;
9767  }
9768  }
9769  if (!node->nd_next) {
9770  VALUE src = node->nd_lit;
9771  nd_set_type(node, NODE_LIT);
9772  node->nd_lit = reg_compile(src, options);
9773  }
9774  break;
9775  }
9776  (yyval.node) = node;
9777  /*%
9778  $$ = dispatch2(regexp_literal, $2, $3);
9779  %*/
9780  }
9781  break;
9782 
9783  case 460:
9784 
9785 /* Line 1806 of yacc.c */
9786 #line 3961 "parse.y"
9787  {
9788  /*%%%*/
9789  (yyval.node) = NEW_ZARRAY();
9790  /*%
9791  $$ = dispatch0(words_new);
9792  $$ = dispatch1(array, $$);
9793  %*/
9794  }
9795  break;
9796 
9797  case 461:
9798 
9799 /* Line 1806 of yacc.c */
9800 #line 3970 "parse.y"
9801  {
9802  /*%%%*/
9803  (yyval.node) = (yyvsp[(2) - (3)].node);
9804  /*%
9805  $$ = dispatch1(array, $2);
9806  %*/
9807  }
9808  break;
9809 
9810  case 462:
9811 
9812 /* Line 1806 of yacc.c */
9813 #line 3980 "parse.y"
9814  {
9815  /*%%%*/
9816  (yyval.node) = 0;
9817  /*%
9818  $$ = dispatch0(words_new);
9819  %*/
9820  }
9821  break;
9822 
9823  case 463:
9824 
9825 /* Line 1806 of yacc.c */
9826 #line 3988 "parse.y"
9827  {
9828  /*%%%*/
9829  (yyval.node) = list_append((yyvsp[(1) - (3)].node), evstr2dstr((yyvsp[(2) - (3)].node)));
9830  /*%
9831  $$ = dispatch2(words_add, $1, $2);
9832  %*/
9833  }
9834  break;
9835 
9836  case 465:
9837 
9838 /* Line 1806 of yacc.c */
9839 #line 4006 "parse.y"
9840  {
9841  /*%%%*/
9842  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
9843  /*%
9844  $$ = dispatch2(word_add, $1, $2);
9845  %*/
9846  }
9847  break;
9848 
9849  case 466:
9850 
9851 /* Line 1806 of yacc.c */
9852 #line 4016 "parse.y"
9853  {
9854  /*%%%*/
9855  (yyval.node) = NEW_ZARRAY();
9856  /*%
9857  $$ = dispatch0(symbols_new);
9858  $$ = dispatch1(array, $$);
9859  %*/
9860  }
9861  break;
9862 
9863  case 467:
9864 
9865 /* Line 1806 of yacc.c */
9866 #line 4025 "parse.y"
9867  {
9868  /*%%%*/
9869  (yyval.node) = (yyvsp[(2) - (3)].node);
9870  /*%
9871  $$ = dispatch1(array, $2);
9872  %*/
9873  }
9874  break;
9875 
9876  case 468:
9877 
9878 /* Line 1806 of yacc.c */
9879 #line 4035 "parse.y"
9880  {
9881  /*%%%*/
9882  (yyval.node) = 0;
9883  /*%
9884  $$ = dispatch0(symbols_new);
9885  %*/
9886  }
9887  break;
9888 
9889  case 469:
9890 
9891 /* Line 1806 of yacc.c */
9892 #line 4043 "parse.y"
9893  {
9894  /*%%%*/
9895  (yyvsp[(2) - (3)].node) = evstr2dstr((yyvsp[(2) - (3)].node));
9896  if (nd_type((yyvsp[(2) - (3)].node)) == NODE_DSTR) {
9897  nd_set_type((yyvsp[(2) - (3)].node), NODE_DSYM);
9898  }
9899  else {
9900  nd_set_type((yyvsp[(2) - (3)].node), NODE_LIT);
9901  (yyvsp[(2) - (3)].node)->nd_lit = rb_str_intern((yyvsp[(2) - (3)].node)->nd_lit);
9902  }
9903  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
9904  /*%
9905  $$ = dispatch2(symbols_add, $1, $2);
9906  %*/
9907  }
9908  break;
9909 
9910  case 470:
9911 
9912 /* Line 1806 of yacc.c */
9913 #line 4061 "parse.y"
9914  {
9915  /*%%%*/
9916  (yyval.node) = NEW_ZARRAY();
9917  /*%
9918  $$ = dispatch0(qwords_new);
9919  $$ = dispatch1(array, $$);
9920  %*/
9921  }
9922  break;
9923 
9924  case 471:
9925 
9926 /* Line 1806 of yacc.c */
9927 #line 4070 "parse.y"
9928  {
9929  /*%%%*/
9930  (yyval.node) = (yyvsp[(2) - (3)].node);
9931  /*%
9932  $$ = dispatch1(array, $2);
9933  %*/
9934  }
9935  break;
9936 
9937  case 472:
9938 
9939 /* Line 1806 of yacc.c */
9940 #line 4080 "parse.y"
9941  {
9942  /*%%%*/
9943  (yyval.node) = NEW_ZARRAY();
9944  /*%
9945  $$ = dispatch0(qsymbols_new);
9946  $$ = dispatch1(array, $$);
9947  %*/
9948  }
9949  break;
9950 
9951  case 473:
9952 
9953 /* Line 1806 of yacc.c */
9954 #line 4089 "parse.y"
9955  {
9956  /*%%%*/
9957  (yyval.node) = (yyvsp[(2) - (3)].node);
9958  /*%
9959  $$ = dispatch1(array, $2);
9960  %*/
9961  }
9962  break;
9963 
9964  case 474:
9965 
9966 /* Line 1806 of yacc.c */
9967 #line 4099 "parse.y"
9968  {
9969  /*%%%*/
9970  (yyval.node) = 0;
9971  /*%
9972  $$ = dispatch0(qwords_new);
9973  %*/
9974  }
9975  break;
9976 
9977  case 475:
9978 
9979 /* Line 1806 of yacc.c */
9980 #line 4107 "parse.y"
9981  {
9982  /*%%%*/
9983  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
9984  /*%
9985  $$ = dispatch2(qwords_add, $1, $2);
9986  %*/
9987  }
9988  break;
9989 
9990  case 476:
9991 
9992 /* Line 1806 of yacc.c */
9993 #line 4117 "parse.y"
9994  {
9995  /*%%%*/
9996  (yyval.node) = 0;
9997  /*%
9998  $$ = dispatch0(qsymbols_new);
9999  %*/
10000  }
10001  break;
10002 
10003  case 477:
10004 
10005 /* Line 1806 of yacc.c */
10006 #line 4125 "parse.y"
10007  {
10008  /*%%%*/
10009  VALUE lit;
10010  lit = (yyvsp[(2) - (3)].node)->nd_lit;
10011  (yyvsp[(2) - (3)].node)->nd_lit = ID2SYM(rb_intern_str(lit));
10012  nd_set_type((yyvsp[(2) - (3)].node), NODE_LIT);
10013  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
10014  /*%
10015  $$ = dispatch2(qsymbols_add, $1, $2);
10016  %*/
10017  }
10018  break;
10019 
10020  case 478:
10021 
10022 /* Line 1806 of yacc.c */
10023 #line 4139 "parse.y"
10024  {
10025  /*%%%*/
10026  (yyval.node) = 0;
10027  /*%
10028  $$ = dispatch0(string_content);
10029  %*/
10030  }
10031  break;
10032 
10033  case 479:
10034 
10035 /* Line 1806 of yacc.c */
10036 #line 4147 "parse.y"
10037  {
10038  /*%%%*/
10039  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
10040  /*%
10041  $$ = dispatch2(string_add, $1, $2);
10042  %*/
10043  }
10044  break;
10045 
10046  case 480:
10047 
10048 /* Line 1806 of yacc.c */
10049 #line 4157 "parse.y"
10050  {
10051  /*%%%*/
10052  (yyval.node) = 0;
10053  /*%
10054  $$ = dispatch0(xstring_new);
10055  %*/
10056  }
10057  break;
10058 
10059  case 481:
10060 
10061 /* Line 1806 of yacc.c */
10062 #line 4165 "parse.y"
10063  {
10064  /*%%%*/
10065  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
10066  /*%
10067  $$ = dispatch2(xstring_add, $1, $2);
10068  %*/
10069  }
10070  break;
10071 
10072  case 482:
10073 
10074 /* Line 1806 of yacc.c */
10075 #line 4175 "parse.y"
10076  {
10077  /*%%%*/
10078  (yyval.node) = 0;
10079  /*%
10080  $$ = dispatch0(regexp_new);
10081  %*/
10082  }
10083  break;
10084 
10085  case 483:
10086 
10087 /* Line 1806 of yacc.c */
10088 #line 4183 "parse.y"
10089  {
10090  /*%%%*/
10091  NODE *head = (yyvsp[(1) - (2)].node), *tail = (yyvsp[(2) - (2)].node);
10092  if (!head) {
10093  (yyval.node) = tail;
10094  }
10095  else if (!tail) {
10096  (yyval.node) = head;
10097  }
10098  else {
10099  switch (nd_type(head)) {
10100  case NODE_STR:
10101  nd_set_type(head, NODE_DSTR);
10102  break;
10103  case NODE_DSTR:
10104  break;
10105  default:
10106  head = list_append(NEW_DSTR(Qnil), head);
10107  break;
10108  }
10109  (yyval.node) = list_append(head, tail);
10110  }
10111  /*%
10112  $$ = dispatch2(regexp_add, $1, $2);
10113  %*/
10114  }
10115  break;
10116 
10117  case 485:
10118 
10119 /* Line 1806 of yacc.c */
10120 #line 4213 "parse.y"
10121  {
10122  (yyval.node) = lex_strterm;
10123  lex_strterm = 0;
10124  lex_state = EXPR_BEG;
10125  }
10126  break;
10127 
10128  case 486:
10129 
10130 /* Line 1806 of yacc.c */
10131 #line 4219 "parse.y"
10132  {
10133  /*%%%*/
10134  lex_strterm = (yyvsp[(2) - (3)].node);
10135  (yyval.node) = NEW_EVSTR((yyvsp[(3) - (3)].node));
10136  /*%
10137  lex_strterm = $<node>2;
10138  $$ = dispatch1(string_dvar, $3);
10139  %*/
10140  }
10141  break;
10142 
10143  case 487:
10144 
10145 /* Line 1806 of yacc.c */
10146 #line 4229 "parse.y"
10147  {
10148  (yyvsp[(1) - (1)].val) = cond_stack;
10149  (yyval.val) = cmdarg_stack;
10150  cond_stack = 0;
10151  cmdarg_stack = 0;
10152  }
10153  break;
10154 
10155  case 488:
10156 
10157 /* Line 1806 of yacc.c */
10158 #line 4235 "parse.y"
10159  {
10160  (yyval.node) = lex_strterm;
10161  lex_strterm = 0;
10162  lex_state = EXPR_BEG;
10163  }
10164  break;
10165 
10166  case 489:
10167 
10168 /* Line 1806 of yacc.c */
10169 #line 4240 "parse.y"
10170  {
10171  (yyval.num) = brace_nest;
10172  brace_nest = 0;
10173  }
10174  break;
10175 
10176  case 490:
10177 
10178 /* Line 1806 of yacc.c */
10179 #line 4245 "parse.y"
10180  {
10181  cond_stack = (yyvsp[(1) - (6)].val);
10182  cmdarg_stack = (yyvsp[(2) - (6)].val);
10183  lex_strterm = (yyvsp[(3) - (6)].node);
10184  brace_nest = (yyvsp[(4) - (6)].num);
10185  /*%%%*/
10186  if ((yyvsp[(5) - (6)].node)) (yyvsp[(5) - (6)].node)->flags &= ~NODE_FL_NEWLINE;
10187  (yyval.node) = new_evstr((yyvsp[(5) - (6)].node));
10188  /*%
10189  $$ = dispatch1(string_embexpr, $5);
10190  %*/
10191  }
10192  break;
10193 
10194  case 491:
10195 
10196 /* Line 1806 of yacc.c */
10197 #line 4260 "parse.y"
10198  {
10199  /*%%%*/
10200  (yyval.node) = NEW_GVAR((yyvsp[(1) - (1)].id));
10201  /*%
10202  $$ = dispatch1(var_ref, $1);
10203  %*/
10204  }
10205  break;
10206 
10207  case 492:
10208 
10209 /* Line 1806 of yacc.c */
10210 #line 4268 "parse.y"
10211  {
10212  /*%%%*/
10213  (yyval.node) = NEW_IVAR((yyvsp[(1) - (1)].id));
10214  /*%
10215  $$ = dispatch1(var_ref, $1);
10216  %*/
10217  }
10218  break;
10219 
10220  case 493:
10221 
10222 /* Line 1806 of yacc.c */
10223 #line 4276 "parse.y"
10224  {
10225  /*%%%*/
10226  (yyval.node) = NEW_CVAR((yyvsp[(1) - (1)].id));
10227  /*%
10228  $$ = dispatch1(var_ref, $1);
10229  %*/
10230  }
10231  break;
10232 
10233  case 495:
10234 
10235 /* Line 1806 of yacc.c */
10236 #line 4287 "parse.y"
10237  {
10238  lex_state = EXPR_END;
10239  /*%%%*/
10240  (yyval.id) = (yyvsp[(2) - (2)].id);
10241  /*%
10242  $$ = dispatch1(symbol, $2);
10243  %*/
10244  }
10245  break;
10246 
10247  case 500:
10248 
10249 /* Line 1806 of yacc.c */
10250 #line 4304 "parse.y"
10251  {
10252  lex_state = EXPR_END;
10253  /*%%%*/
10254  (yyval.node) = dsym_node((yyvsp[(2) - (3)].node));
10255  /*%
10256  $$ = dispatch1(dyna_symbol, $2);
10257  %*/
10258  }
10259  break;
10260 
10261  case 503:
10262 
10263 /* Line 1806 of yacc.c */
10264 #line 4317 "parse.y"
10265  {
10266  /*%%%*/
10267  (yyval.node) = negate_lit((yyvsp[(2) - (2)].node));
10268  /*%
10269  $$ = dispatch2(unary, ripper_intern("-@"), $2);
10270  %*/
10271  }
10272  break;
10273 
10274  case 504:
10275 
10276 /* Line 1806 of yacc.c */
10277 #line 4325 "parse.y"
10278  {
10279  /*%%%*/
10280  (yyval.node) = negate_lit((yyvsp[(2) - (2)].node));
10281  /*%
10282  $$ = dispatch2(unary, ripper_intern("-@"), $2);
10283  %*/
10284  }
10285  break;
10286 
10287  case 510:
10288 
10289 /* Line 1806 of yacc.c */
10290 #line 4341 "parse.y"
10291  {ifndef_ripper((yyval.id) = keyword_nil);}
10292  break;
10293 
10294  case 511:
10295 
10296 /* Line 1806 of yacc.c */
10297 #line 4342 "parse.y"
10298  {ifndef_ripper((yyval.id) = keyword_self);}
10299  break;
10300 
10301  case 512:
10302 
10303 /* Line 1806 of yacc.c */
10304 #line 4343 "parse.y"
10305  {ifndef_ripper((yyval.id) = keyword_true);}
10306  break;
10307 
10308  case 513:
10309 
10310 /* Line 1806 of yacc.c */
10311 #line 4344 "parse.y"
10312  {ifndef_ripper((yyval.id) = keyword_false);}
10313  break;
10314 
10315  case 514:
10316 
10317 /* Line 1806 of yacc.c */
10318 #line 4345 "parse.y"
10319  {ifndef_ripper((yyval.id) = keyword__FILE__);}
10320  break;
10321 
10322  case 515:
10323 
10324 /* Line 1806 of yacc.c */
10325 #line 4346 "parse.y"
10326  {ifndef_ripper((yyval.id) = keyword__LINE__);}
10327  break;
10328 
10329  case 516:
10330 
10331 /* Line 1806 of yacc.c */
10332 #line 4347 "parse.y"
10333  {ifndef_ripper((yyval.id) = keyword__ENCODING__);}
10334  break;
10335 
10336  case 517:
10337 
10338 /* Line 1806 of yacc.c */
10339 #line 4351 "parse.y"
10340  {
10341  /*%%%*/
10342  if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0);
10343  /*%
10344  if (id_is_var(get_id($1))) {
10345  $$ = dispatch1(var_ref, $1);
10346  }
10347  else {
10348  $$ = dispatch1(vcall, $1);
10349  }
10350  %*/
10351  }
10352  break;
10353 
10354  case 518:
10355 
10356 /* Line 1806 of yacc.c */
10357 #line 4364 "parse.y"
10358  {
10359  /*%%%*/
10360  if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0);
10361  /*%
10362  $$ = dispatch1(var_ref, $1);
10363  %*/
10364  }
10365  break;
10366 
10367  case 519:
10368 
10369 /* Line 1806 of yacc.c */
10370 #line 4374 "parse.y"
10371  {
10372  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
10373  /*%%%*/
10374  /*%
10375  $$ = dispatch1(var_field, $$);
10376  %*/
10377  }
10378  break;
10379 
10380  case 520:
10381 
10382 /* Line 1806 of yacc.c */
10383 #line 4382 "parse.y"
10384  {
10385  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
10386  /*%%%*/
10387  /*%
10388  $$ = dispatch1(var_field, $$);
10389  %*/
10390  }
10391  break;
10392 
10393  case 523:
10394 
10395 /* Line 1806 of yacc.c */
10396 #line 4396 "parse.y"
10397  {
10398  /*%%%*/
10399  (yyval.node) = 0;
10400  /*%
10401  $$ = Qnil;
10402  %*/
10403  }
10404  break;
10405 
10406  case 524:
10407 
10408 /* Line 1806 of yacc.c */
10409 #line 4404 "parse.y"
10410  {
10411  lex_state = EXPR_BEG;
10412  command_start = TRUE;
10413  }
10414  break;
10415 
10416  case 525:
10417 
10418 /* Line 1806 of yacc.c */
10419 #line 4409 "parse.y"
10420  {
10421  (yyval.node) = (yyvsp[(3) - (4)].node);
10422  }
10423  break;
10424 
10425  case 526:
10426 
10427 /* Line 1806 of yacc.c */
10428 #line 4413 "parse.y"
10429  {
10430  /*%%%*/
10431  yyerrok;
10432  (yyval.node) = 0;
10433  /*%
10434  yyerrok;
10435  $$ = Qnil;
10436  %*/
10437  }
10438  break;
10439 
10440  case 527:
10441 
10442 /* Line 1806 of yacc.c */
10443 #line 4425 "parse.y"
10444  {
10445  /*%%%*/
10446  (yyval.node) = (yyvsp[(2) - (3)].node);
10447  /*%
10448  $$ = dispatch1(paren, $2);
10449  %*/
10450  lex_state = EXPR_BEG;
10451  command_start = TRUE;
10452  }
10453  break;
10454 
10455  case 528:
10456 
10457 /* Line 1806 of yacc.c */
10458 #line 4435 "parse.y"
10459  {
10460  (yyval.node) = (yyvsp[(1) - (2)].node);
10461  lex_state = EXPR_BEG;
10462  command_start = TRUE;
10463  }
10464  break;
10465 
10466  case 529:
10467 
10468 /* Line 1806 of yacc.c */
10469 #line 4443 "parse.y"
10470  {
10471  (yyval.node) = new_args_tail((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id));
10472  }
10473  break;
10474 
10475  case 530:
10476 
10477 /* Line 1806 of yacc.c */
10478 #line 4447 "parse.y"
10479  {
10480  (yyval.node) = new_args_tail((yyvsp[(1) - (2)].node), Qnone, (yyvsp[(2) - (2)].id));
10481  }
10482  break;
10483 
10484  case 531:
10485 
10486 /* Line 1806 of yacc.c */
10487 #line 4451 "parse.y"
10488  {
10489  (yyval.node) = new_args_tail(Qnone, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id));
10490  }
10491  break;
10492 
10493  case 532:
10494 
10495 /* Line 1806 of yacc.c */
10496 #line 4455 "parse.y"
10497  {
10498  (yyval.node) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].id));
10499  }
10500  break;
10501 
10502  case 533:
10503 
10504 /* Line 1806 of yacc.c */
10505 #line 4461 "parse.y"
10506  {
10507  (yyval.node) = (yyvsp[(2) - (2)].node);
10508  }
10509  break;
10510 
10511  case 534:
10512 
10513 /* Line 1806 of yacc.c */
10514 #line 4465 "parse.y"
10515  {
10516  (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
10517  }
10518  break;
10519 
10520  case 535:
10521 
10522 /* Line 1806 of yacc.c */
10523 #line 4471 "parse.y"
10524  {
10525  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), Qnone, (yyvsp[(6) - (6)].node));
10526  }
10527  break;
10528 
10529  case 536:
10530 
10531 /* Line 1806 of yacc.c */
10532 #line 4475 "parse.y"
10533  {
10534  (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].node));
10535  }
10536  break;
10537 
10538  case 537:
10539 
10540 /* Line 1806 of yacc.c */
10541 #line 4479 "parse.y"
10542  {
10543  (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), Qnone, Qnone, (yyvsp[(4) - (4)].node));
10544  }
10545  break;
10546 
10547  case 538:
10548 
10549 /* Line 1806 of yacc.c */
10550 #line 4483 "parse.y"
10551  {
10552  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), Qnone, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10553  }
10554  break;
10555 
10556  case 539:
10557 
10558 /* Line 1806 of yacc.c */
10559 #line 4487 "parse.y"
10560  {
10561  (yyval.node) = new_args((yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
10562  }
10563  break;
10564 
10565  case 540:
10566 
10567 /* Line 1806 of yacc.c */
10568 #line 4491 "parse.y"
10569  {
10570  (yyval.node) = new_args((yyvsp[(1) - (6)].node), Qnone, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10571  }
10572  break;
10573 
10574  case 541:
10575 
10576 /* Line 1806 of yacc.c */
10577 #line 4495 "parse.y"
10578  {
10579  (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].node));
10580  }
10581  break;
10582 
10583  case 542:
10584 
10585 /* Line 1806 of yacc.c */
10586 #line 4499 "parse.y"
10587  {
10588  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
10589  }
10590  break;
10591 
10592  case 543:
10593 
10594 /* Line 1806 of yacc.c */
10595 #line 4503 "parse.y"
10596  {
10597  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10598  }
10599  break;
10600 
10601  case 544:
10602 
10603 /* Line 1806 of yacc.c */
10604 #line 4507 "parse.y"
10605  {
10606  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (2)].node), Qnone, Qnone, (yyvsp[(2) - (2)].node));
10607  }
10608  break;
10609 
10610  case 545:
10611 
10612 /* Line 1806 of yacc.c */
10613 #line 4511 "parse.y"
10614  {
10615  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
10616  }
10617  break;
10618 
10619  case 546:
10620 
10621 /* Line 1806 of yacc.c */
10622 #line 4515 "parse.y"
10623  {
10624  (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].id), Qnone, (yyvsp[(2) - (2)].node));
10625  }
10626  break;
10627 
10628  case 547:
10629 
10630 /* Line 1806 of yacc.c */
10631 #line 4519 "parse.y"
10632  {
10633  (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
10634  }
10635  break;
10636 
10637  case 548:
10638 
10639 /* Line 1806 of yacc.c */
10640 #line 4523 "parse.y"
10641  {
10642  (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].node));
10643  }
10644  break;
10645 
10646  case 549:
10647 
10648 /* Line 1806 of yacc.c */
10649 #line 4527 "parse.y"
10650  {
10651  (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
10652  (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.node));
10653  }
10654  break;
10655 
10656  case 550:
10657 
10658 /* Line 1806 of yacc.c */
10659 #line 4534 "parse.y"
10660  {
10661  /*%%%*/
10662  yyerror("formal argument cannot be a constant");
10663  (yyval.id) = 0;
10664  /*%
10665  $$ = dispatch1(param_error, $1);
10666  %*/
10667  }
10668  break;
10669 
10670  case 551:
10671 
10672 /* Line 1806 of yacc.c */
10673 #line 4543 "parse.y"
10674  {
10675  /*%%%*/
10676  yyerror("formal argument cannot be an instance variable");
10677  (yyval.id) = 0;
10678  /*%
10679  $$ = dispatch1(param_error, $1);
10680  %*/
10681  }
10682  break;
10683 
10684  case 552:
10685 
10686 /* Line 1806 of yacc.c */
10687 #line 4552 "parse.y"
10688  {
10689  /*%%%*/
10690  yyerror("formal argument cannot be a global variable");
10691  (yyval.id) = 0;
10692  /*%
10693  $$ = dispatch1(param_error, $1);
10694  %*/
10695  }
10696  break;
10697 
10698  case 553:
10699 
10700 /* Line 1806 of yacc.c */
10701 #line 4561 "parse.y"
10702  {
10703  /*%%%*/
10704  yyerror("formal argument cannot be a class variable");
10705  (yyval.id) = 0;
10706  /*%
10707  $$ = dispatch1(param_error, $1);
10708  %*/
10709  }
10710  break;
10711 
10712  case 555:
10713 
10714 /* Line 1806 of yacc.c */
10715 #line 4573 "parse.y"
10716  {
10717  formal_argument(get_id((yyvsp[(1) - (1)].id)));
10718  (yyval.id) = (yyvsp[(1) - (1)].id);
10719  }
10720  break;
10721 
10722  case 556:
10723 
10724 /* Line 1806 of yacc.c */
10725 #line 4580 "parse.y"
10726  {
10727  arg_var(get_id((yyvsp[(1) - (1)].id)));
10728  /*%%%*/
10729  (yyval.node) = NEW_ARGS_AUX((yyvsp[(1) - (1)].id), 1);
10730  /*%
10731  $$ = get_value($1);
10732  %*/
10733  }
10734  break;
10735 
10736  case 557:
10737 
10738 /* Line 1806 of yacc.c */
10739 #line 4589 "parse.y"
10740  {
10741  ID tid = internal_id();
10742  arg_var(tid);
10743  /*%%%*/
10744  if (dyna_in_block()) {
10745  (yyvsp[(2) - (3)].node)->nd_value = NEW_DVAR(tid);
10746  }
10747  else {
10748  (yyvsp[(2) - (3)].node)->nd_value = NEW_LVAR(tid);
10749  }
10750  (yyval.node) = NEW_ARGS_AUX(tid, 1);
10751  (yyval.node)->nd_next = (yyvsp[(2) - (3)].node);
10752  /*%
10753  $$ = dispatch1(mlhs_paren, $2);
10754  %*/
10755  }
10756  break;
10757 
10758  case 559:
10759 
10760 /* Line 1806 of yacc.c */
10761 #line 4615 "parse.y"
10762  {
10763  /*%%%*/
10764  (yyval.node) = (yyvsp[(1) - (3)].node);
10765  (yyval.node)->nd_plen++;
10766  (yyval.node)->nd_next = block_append((yyval.node)->nd_next, (yyvsp[(3) - (3)].node)->nd_next);
10767  rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].node));
10768  /*%
10769  $$ = rb_ary_push($1, $3);
10770  %*/
10771  }
10772  break;
10773 
10774  case 560:
10775 
10776 /* Line 1806 of yacc.c */
10777 #line 4628 "parse.y"
10778  {
10779  arg_var(formal_argument(get_id((yyvsp[(1) - (2)].id))));
10780  (yyval.node) = assignable((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node));
10781  /*%%%*/
10782  (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10783  /*%
10784  $$ = rb_assoc_new($$, $2);
10785  %*/
10786  }
10787  break;
10788 
10789  case 561:
10790 
10791 /* Line 1806 of yacc.c */
10792 #line 4640 "parse.y"
10793  {
10794  arg_var(formal_argument(get_id((yyvsp[(1) - (2)].id))));
10795  (yyval.node) = assignable((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node));
10796  /*%%%*/
10797  (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10798  /*%
10799  $$ = rb_assoc_new($$, $2);
10800  %*/
10801  }
10802  break;
10803 
10804  case 562:
10805 
10806 /* Line 1806 of yacc.c */
10807 #line 4652 "parse.y"
10808  {
10809  /*%%%*/
10810  (yyval.node) = (yyvsp[(1) - (1)].node);
10811  /*%
10812  $$ = rb_ary_new3(1, $1);
10813  %*/
10814  }
10815  break;
10816 
10817  case 563:
10818 
10819 /* Line 1806 of yacc.c */
10820 #line 4660 "parse.y"
10821  {
10822  /*%%%*/
10823  NODE *kws = (yyvsp[(1) - (3)].node);
10824 
10825  while (kws->nd_next) {
10826  kws = kws->nd_next;
10827  }
10828  kws->nd_next = (yyvsp[(3) - (3)].node);
10829  (yyval.node) = (yyvsp[(1) - (3)].node);
10830  /*%
10831  $$ = rb_ary_push($1, $3);
10832  %*/
10833  }
10834  break;
10835 
10836  case 564:
10837 
10838 /* Line 1806 of yacc.c */
10839 #line 4677 "parse.y"
10840  {
10841  /*%%%*/
10842  (yyval.node) = (yyvsp[(1) - (1)].node);
10843  /*%
10844  $$ = rb_ary_new3(1, $1);
10845  %*/
10846  }
10847  break;
10848 
10849  case 565:
10850 
10851 /* Line 1806 of yacc.c */
10852 #line 4685 "parse.y"
10853  {
10854  /*%%%*/
10855  NODE *kws = (yyvsp[(1) - (3)].node);
10856 
10857  while (kws->nd_next) {
10858  kws = kws->nd_next;
10859  }
10860  kws->nd_next = (yyvsp[(3) - (3)].node);
10861  (yyval.node) = (yyvsp[(1) - (3)].node);
10862  /*%
10863  $$ = rb_ary_push($1, $3);
10864  %*/
10865  }
10866  break;
10867 
10868  case 568:
10869 
10870 /* Line 1806 of yacc.c */
10871 #line 4705 "parse.y"
10872  {
10873  shadowing_lvar(get_id((yyvsp[(2) - (2)].id)));
10874  (yyval.id) = (yyvsp[(2) - (2)].id);
10875  }
10876  break;
10877 
10878  case 569:
10879 
10880 /* Line 1806 of yacc.c */
10881 #line 4710 "parse.y"
10882  {
10883  (yyval.id) = internal_id();
10884  }
10885  break;
10886 
10887  case 570:
10888 
10889 /* Line 1806 of yacc.c */
10890 #line 4716 "parse.y"
10891  {
10892  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].id))));
10893  (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node));
10894  /*%%%*/
10895  (yyval.node) = NEW_OPT_ARG(0, (yyval.node));
10896  /*%
10897  $$ = rb_assoc_new($$, $3);
10898  %*/
10899  }
10900  break;
10901 
10902  case 571:
10903 
10904 /* Line 1806 of yacc.c */
10905 #line 4728 "parse.y"
10906  {
10907  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].id))));
10908  (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node));
10909  /*%%%*/
10910  (yyval.node) = NEW_OPT_ARG(0, (yyval.node));
10911  /*%
10912  $$ = rb_assoc_new($$, $3);
10913  %*/
10914  }
10915  break;
10916 
10917  case 572:
10918 
10919 /* Line 1806 of yacc.c */
10920 #line 4740 "parse.y"
10921  {
10922  /*%%%*/
10923  (yyval.node) = (yyvsp[(1) - (1)].node);
10924  /*%
10925  $$ = rb_ary_new3(1, $1);
10926  %*/
10927  }
10928  break;
10929 
10930  case 573:
10931 
10932 /* Line 1806 of yacc.c */
10933 #line 4748 "parse.y"
10934  {
10935  /*%%%*/
10936  NODE *opts = (yyvsp[(1) - (3)].node);
10937 
10938  while (opts->nd_next) {
10939  opts = opts->nd_next;
10940  }
10941  opts->nd_next = (yyvsp[(3) - (3)].node);
10942  (yyval.node) = (yyvsp[(1) - (3)].node);
10943  /*%
10944  $$ = rb_ary_push($1, $3);
10945  %*/
10946  }
10947  break;
10948 
10949  case 574:
10950 
10951 /* Line 1806 of yacc.c */
10952 #line 4764 "parse.y"
10953  {
10954  /*%%%*/
10955  (yyval.node) = (yyvsp[(1) - (1)].node);
10956  /*%
10957  $$ = rb_ary_new3(1, $1);
10958  %*/
10959  }
10960  break;
10961 
10962  case 575:
10963 
10964 /* Line 1806 of yacc.c */
10965 #line 4772 "parse.y"
10966  {
10967  /*%%%*/
10968  NODE *opts = (yyvsp[(1) - (3)].node);
10969 
10970  while (opts->nd_next) {
10971  opts = opts->nd_next;
10972  }
10973  opts->nd_next = (yyvsp[(3) - (3)].node);
10974  (yyval.node) = (yyvsp[(1) - (3)].node);
10975  /*%
10976  $$ = rb_ary_push($1, $3);
10977  %*/
10978  }
10979  break;
10980 
10981  case 578:
10982 
10983 /* Line 1806 of yacc.c */
10984 #line 4792 "parse.y"
10985  {
10986  /*%%%*/
10987  if (!is_local_id((yyvsp[(2) - (2)].id)))
10988  yyerror("rest argument must be local variable");
10989  /*% %*/
10990  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id))));
10991  /*%%%*/
10992  (yyval.id) = (yyvsp[(2) - (2)].id);
10993  /*%
10994  $$ = dispatch1(rest_param, $2);
10995  %*/
10996  }
10997  break;
10998 
10999  case 579:
11000 
11001 /* Line 1806 of yacc.c */
11002 #line 4805 "parse.y"
11003  {
11004  /*%%%*/
11005  (yyval.id) = internal_id();
11006  arg_var((yyval.id));
11007  /*%
11008  $$ = dispatch1(rest_param, Qnil);
11009  %*/
11010  }
11011  break;
11012 
11013  case 582:
11014 
11015 /* Line 1806 of yacc.c */
11016 #line 4820 "parse.y"
11017  {
11018  /*%%%*/
11019  if (!is_local_id((yyvsp[(2) - (2)].id)))
11020  yyerror("block argument must be local variable");
11021  else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].id)))
11022  yyerror("duplicated block argument name");
11023  /*% %*/
11024  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id))));
11025  /*%%%*/
11026  (yyval.id) = (yyvsp[(2) - (2)].id);
11027  /*%
11028  $$ = dispatch1(blockarg, $2);
11029  %*/
11030  }
11031  break;
11032 
11033  case 583:
11034 
11035 /* Line 1806 of yacc.c */
11036 #line 4837 "parse.y"
11037  {
11038  (yyval.id) = (yyvsp[(2) - (2)].id);
11039  }
11040  break;
11041 
11042  case 584:
11043 
11044 /* Line 1806 of yacc.c */
11045 #line 4841 "parse.y"
11046  {
11047  /*%%%*/
11048  (yyval.id) = 0;
11049  /*%
11050  $$ = Qundef;
11051  %*/
11052  }
11053  break;
11054 
11055  case 585:
11056 
11057 /* Line 1806 of yacc.c */
11058 #line 4851 "parse.y"
11059  {
11060  /*%%%*/
11061  value_expr((yyvsp[(1) - (1)].node));
11062  (yyval.node) = (yyvsp[(1) - (1)].node);
11063  if (!(yyval.node)) (yyval.node) = NEW_NIL();
11064  /*%
11065  $$ = $1;
11066  %*/
11067  }
11068  break;
11069 
11070  case 586:
11071 
11072 /* Line 1806 of yacc.c */
11073 #line 4860 "parse.y"
11074  {lex_state = EXPR_BEG;}
11075  break;
11076 
11077  case 587:
11078 
11079 /* Line 1806 of yacc.c */
11080 #line 4861 "parse.y"
11081  {
11082  /*%%%*/
11083  if ((yyvsp[(3) - (4)].node) == 0) {
11084  yyerror("can't define singleton method for ().");
11085  }
11086  else {
11087  switch (nd_type((yyvsp[(3) - (4)].node))) {
11088  case NODE_STR:
11089  case NODE_DSTR:
11090  case NODE_XSTR:
11091  case NODE_DXSTR:
11092  case NODE_DREGX:
11093  case NODE_LIT:
11094  case NODE_ARRAY:
11095  case NODE_ZARRAY:
11096  yyerror("can't define singleton method for literals");
11097  default:
11098  value_expr((yyvsp[(3) - (4)].node));
11099  break;
11100  }
11101  }
11102  (yyval.node) = (yyvsp[(3) - (4)].node);
11103  /*%
11104  $$ = dispatch1(paren, $3);
11105  %*/
11106  }
11107  break;
11108 
11109  case 589:
11110 
11111 /* Line 1806 of yacc.c */
11112 #line 4891 "parse.y"
11113  {
11114  /*%%%*/
11115  (yyval.node) = (yyvsp[(1) - (2)].node);
11116  /*%
11117  $$ = dispatch1(assoclist_from_args, $1);
11118  %*/
11119  }
11120  break;
11121 
11122  case 591:
11123 
11124 /* Line 1806 of yacc.c */
11125 #line 4908 "parse.y"
11126  {
11127  /*%%%*/
11128  (yyval.node) = list_concat((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
11129  /*%
11130  $$ = rb_ary_push($1, $3);
11131  %*/
11132  }
11133  break;
11134 
11135  case 592:
11136 
11137 /* Line 1806 of yacc.c */
11138 #line 4918 "parse.y"
11139  {
11140  /*%%%*/
11141  (yyval.node) = list_append(NEW_LIST((yyvsp[(1) - (3)].node)), (yyvsp[(3) - (3)].node));
11142  /*%
11143  $$ = dispatch2(assoc_new, $1, $3);
11144  %*/
11145  }
11146  break;
11147 
11148  case 593:
11149 
11150 /* Line 1806 of yacc.c */
11151 #line 4926 "parse.y"
11152  {
11153  /*%%%*/
11154  (yyval.node) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].id)))), (yyvsp[(2) - (2)].node));
11155  /*%
11156  $$ = dispatch2(assoc_new, $1, $2);
11157  %*/
11158  }
11159  break;
11160 
11161  case 594:
11162 
11163 /* Line 1806 of yacc.c */
11164 #line 4934 "parse.y"
11165  {
11166  /*%%%*/
11167  (yyval.node) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].node));
11168  /*%
11169  $$ = dispatch1(assoc_splat, $2);
11170  %*/
11171  }
11172  break;
11173 
11174  case 616:
11175 
11176 /* Line 1806 of yacc.c */
11177 #line 4992 "parse.y"
11178  {yyerrok;}
11179  break;
11180 
11181  case 619:
11182 
11183 /* Line 1806 of yacc.c */
11184 #line 4997 "parse.y"
11185  {yyerrok;}
11186  break;
11187 
11188  case 620:
11189 
11190 /* Line 1806 of yacc.c */
11191 #line 5001 "parse.y"
11192  {
11193  /*%%%*/
11194  (yyval.node) = 0;
11195  /*%
11196  $$ = Qundef;
11197  %*/
11198  }
11199  break;
11200 
11201 
11202 
11203 /* Line 1806 of yacc.c */
11204 #line 11203 "parse.c"
11205  default: break;
11206  }
11207  /* User semantic actions sometimes alter yychar, and that requires
11208  that yytoken be updated with the new translation. We take the
11209  approach of translating immediately before every use of yytoken.
11210  One alternative is translating here after every semantic action,
11211  but that translation would be missed if the semantic action invokes
11212  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11213  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
11214  incorrect destructor might then be invoked immediately. In the
11215  case of YYERROR or YYBACKUP, subsequent parser actions might lead
11216  to an incorrect destructor call or verbose syntax error message
11217  before the lookahead is translated. */
11218  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11219 
11220  YYPOPSTACK (yylen);
11221  yylen = 0;
11222  YY_STACK_PRINT (yyss, yyssp);
11223 
11224  *++yyvsp = yyval;
11225 
11226  /* Now `shift' the result of the reduction. Determine what state
11227  that goes to, based on the state we popped back to and the rule
11228  number reduced by. */
11229 
11230  yyn = yyr1[yyn];
11231 
11232  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
11233  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
11234  yystate = yytable[yystate];
11235  else
11236  yystate = yydefgoto[yyn - YYNTOKENS];
11237 
11238  goto yynewstate;
11239 
11240 
11241 /*------------------------------------.
11242 | yyerrlab -- here on detecting error |
11243 `------------------------------------*/
11244 yyerrlab:
11245  /* Make sure we have latest lookahead translation. See comments at
11246  user semantic actions for why this is necessary. */
11247  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
11248 
11249  /* If not already recovering from an error, report this error. */
11250  if (!yyerrstatus)
11251  {
11252  ++yynerrs;
11253 #if ! YYERROR_VERBOSE
11254  parser_yyerror (parser, YY_("syntax error"));
11255 #else
11256 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
11257  yyssp, yytoken)
11258  {
11259  char const *yymsgp = YY_("syntax error");
11260  int yysyntax_error_status;
11261  yysyntax_error_status = YYSYNTAX_ERROR;
11262  if (yysyntax_error_status == 0)
11263  yymsgp = yymsg;
11264  else if (yysyntax_error_status == 1)
11265  {
11266  if (yymsg != yymsgbuf)
11267  YYSTACK_FREE (yymsg);
11268  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11269  if (!yymsg)
11270  {
11271  yymsg = yymsgbuf;
11272  yymsg_alloc = sizeof yymsgbuf;
11273  yysyntax_error_status = 2;
11274  }
11275  else
11276  {
11277  yysyntax_error_status = YYSYNTAX_ERROR;
11278  yymsgp = yymsg;
11279  }
11280  }
11281  parser_yyerror (parser, yymsgp);
11282  if (yysyntax_error_status == 2)
11283  goto yyexhaustedlab;
11284  }
11285 # undef YYSYNTAX_ERROR
11286 #endif
11287  }
11288 
11289 
11290 
11291  if (yyerrstatus == 3)
11292  {
11293  /* If just tried and failed to reuse lookahead token after an
11294  error, discard it. */
11295 
11296  if (yychar <= YYEOF)
11297  {
11298  /* Return failure if at end of input. */
11299  if (yychar == YYEOF)
11300  YYABORT;
11301  }
11302  else
11303  {
11304  yydestruct ("Error: discarding",
11305  yytoken, &yylval, parser);
11306  yychar = YYEMPTY;
11307  }
11308  }
11309 
11310  /* Else will try to reuse lookahead token after shifting the error
11311  token. */
11312  goto yyerrlab1;
11313 
11314 
11315 /*---------------------------------------------------.
11316 | yyerrorlab -- error raised explicitly by YYERROR. |
11317 `---------------------------------------------------*/
11318 yyerrorlab:
11319 
11320  /* Pacify compilers like GCC when the user code never invokes
11321  YYERROR and the label yyerrorlab therefore never appears in user
11322  code. */
11323  if (/*CONSTCOND*/ 0)
11324  goto yyerrorlab;
11325 
11326  /* Do not reclaim the symbols of the rule which action triggered
11327  this YYERROR. */
11328  YYPOPSTACK (yylen);
11329  yylen = 0;
11330  YY_STACK_PRINT (yyss, yyssp);
11331  yystate = *yyssp;
11332  goto yyerrlab1;
11333 
11334 
11335 /*-------------------------------------------------------------.
11336 | yyerrlab1 -- common code for both syntax error and YYERROR. |
11337 `-------------------------------------------------------------*/
11338 yyerrlab1:
11339  yyerrstatus = 3; /* Each real token shifted decrements this. */
11340 
11341  for (;;)
11342  {
11343  yyn = yypact[yystate];
11344  if (!yypact_value_is_default (yyn))
11345  {
11346  yyn += YYTERROR;
11347  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11348  {
11349  yyn = yytable[yyn];
11350  if (0 < yyn)
11351  break;
11352  }
11353  }
11354 
11355  /* Pop the current state because it cannot handle the error token. */
11356  if (yyssp == yyss)
11357  YYABORT;
11358 
11359 
11360  yydestruct ("Error: popping",
11361  yystos[yystate], yyvsp, parser);
11362  YYPOPSTACK (1);
11363  yystate = *yyssp;
11364  YY_STACK_PRINT (yyss, yyssp);
11365  }
11366 
11367  *++yyvsp = yylval;
11368 
11369 
11370  /* Shift the error token. */
11371  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11372 
11373  yystate = yyn;
11374  goto yynewstate;
11375 
11376 
11377 /*-------------------------------------.
11378 | yyacceptlab -- YYACCEPT comes here. |
11379 `-------------------------------------*/
11380 yyacceptlab:
11381  yyresult = 0;
11382  goto yyreturn;
11383 
11384 /*-----------------------------------.
11385 | yyabortlab -- YYABORT comes here. |
11386 `-----------------------------------*/
11387 yyabortlab:
11388  yyresult = 1;
11389  goto yyreturn;
11390 
11391 #if !defined(yyoverflow) || YYERROR_VERBOSE
11392 /*-------------------------------------------------.
11393 | yyexhaustedlab -- memory exhaustion comes here. |
11394 `-------------------------------------------------*/
11395 yyexhaustedlab:
11396  parser_yyerror (parser, YY_("memory exhausted"));
11397  yyresult = 2;
11398  /* Fall through. */
11399 #endif
11400 
11401 yyreturn:
11402  if (yychar != YYEMPTY)
11403  {
11404  /* Make sure we have latest lookahead translation. See comments at
11405  user semantic actions for why this is necessary. */
11406  yytoken = YYTRANSLATE (yychar);
11407  yydestruct ("Cleanup: discarding lookahead",
11408  yytoken, &yylval, parser);
11409  }
11410  /* Do not reclaim the symbols of the rule which action triggered
11411  this YYABORT or YYACCEPT. */
11412  YYPOPSTACK (yylen);
11413  YY_STACK_PRINT (yyss, yyssp);
11414  while (yyssp != yyss)
11415  {
11416  yydestruct ("Cleanup: popping",
11417  yystos[*yyssp], yyvsp, parser);
11418  YYPOPSTACK (1);
11419  }
11420 #ifndef yyoverflow
11421  if (yyss != yyssa)
11422  YYSTACK_FREE (yyss);
11423 #endif
11424 #if YYERROR_VERBOSE
11425  if (yymsg != yymsgbuf)
11426  YYSTACK_FREE (yymsg);
11427 #endif
11428  /* Make sure YYID is used. */
11429  return YYID (yyresult);
11430 }
11431 
11432 
11433 
11434 /* Line 2067 of yacc.c */
11435 #line 5009 "parse.y"
11436 
11437 # undef parser
11438 # undef yylex
11439 # undef yylval
11440 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
11441 
11442 static int parser_regx_options(struct parser_params*);
11443 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11444 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11445 static int parser_parse_string(struct parser_params*,NODE*);
11446 static int parser_here_document(struct parser_params*,NODE*);
11447 
11448 
11449 # define nextc() parser_nextc(parser)
11450 # define pushback(c) parser_pushback(parser, (c))
11451 # define newtok() parser_newtok(parser)
11452 # define tokspace(n) parser_tokspace(parser, (n))
11453 # define tokadd(c) parser_tokadd(parser, (c))
11454 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
11455 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
11456 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
11457 # define regx_options() parser_regx_options(parser)
11458 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11459 # define parse_string(n) parser_parse_string(parser,(n))
11460 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
11461 # define here_document(n) parser_here_document(parser,(n))
11462 # define heredoc_identifier() parser_heredoc_identifier(parser)
11463 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
11464 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
11465 
11466 #ifndef RIPPER
11467 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11468 # define set_yylval_num(x) (yylval.num = (x))
11469 # define set_yylval_id(x) (yylval.id = (x))
11470 # define set_yylval_name(x) (yylval.id = (x))
11471 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11472 # define set_yylval_node(x) (yylval.node = (x))
11473 # define yylval_id() (yylval.id)
11474 #else
11475 static inline VALUE
11476 ripper_yylval_id(ID x)
11477 {
11478  return (VALUE)NEW_LASGN(x, ID2SYM(x));
11479 }
11480 # define set_yylval_str(x) (void)(x)
11481 # define set_yylval_num(x) (void)(x)
11482 # define set_yylval_id(x) (void)(x)
11483 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11484 # define set_yylval_literal(x) (void)(x)
11485 # define set_yylval_node(x) (void)(x)
11486 # define yylval_id() yylval.id
11487 #endif
11488 
11489 #ifndef RIPPER
11490 #define ripper_flush(p) (void)(p)
11491 #else
11492 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11493 
11494 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11495 
11496 static int
11497 ripper_has_scan_event(struct parser_params *parser)
11498 {
11499 
11500  if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11501  return lex_p > parser->tokp;
11502 }
11503 
11504 static VALUE
11505 ripper_scan_event_val(struct parser_params *parser, int t)
11506 {
11507  VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11508  VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11509  ripper_flush(parser);
11510  return rval;
11511 }
11512 
11513 static void
11514 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11515 {
11516  if (!ripper_has_scan_event(parser)) return;
11517  yylval_rval = ripper_scan_event_val(parser, t);
11518 }
11519 
11520 static void
11521 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11522 {
11523  if (!ripper_has_scan_event(parser)) return;
11524  (void)ripper_scan_event_val(parser, t);
11525 }
11526 
11527 static void
11528 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11529 {
11530  int saved_line = ruby_sourceline;
11531  const char *saved_tokp = parser->tokp;
11532 
11533  ruby_sourceline = parser->delayed_line;
11534  parser->tokp = lex_pbeg + parser->delayed_col;
11535  yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11536  parser->delayed = Qnil;
11537  ruby_sourceline = saved_line;
11538  parser->tokp = saved_tokp;
11539 }
11540 #endif /* RIPPER */
11541 
11542 #include "ruby/regex.h"
11543 #include "ruby/util.h"
11544 
11545 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11546  since ours (we hope) works properly with all combinations of
11547  machines, compilers, `char' and `unsigned char' argument types.
11548  (Per Bothner suggested the basic approach.) */
11549 #undef SIGN_EXTEND_CHAR
11550 #if __STDC__
11551 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11552 #else /* not __STDC__ */
11553 /* As in Harbison and Steele. */
11554 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11555 #endif
11556 
11557 #define parser_encoding_name() (current_enc->name)
11558 #define parser_mbclen() mbclen((lex_p-1),lex_pend,current_enc)
11559 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
11560 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11561 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11562 
11563 #define parser_isascii() ISASCII(*(lex_p-1))
11564 
11565 #ifndef RIPPER
11566 static int
11567 token_info_get_column(struct parser_params *parser, const char *token)
11568 {
11569  int column = 1;
11570  const char *p, *pend = lex_p - strlen(token);
11571  for (p = lex_pbeg; p < pend; p++) {
11572  if (*p == '\t') {
11573  column = (((column - 1) / 8) + 1) * 8;
11574  }
11575  column++;
11576  }
11577  return column;
11578 }
11579 
11580 static int
11581 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11582 {
11583  const char *p, *pend = lex_p - strlen(token);
11584  for (p = lex_pbeg; p < pend; p++) {
11585  if (*p != ' ' && *p != '\t') {
11586  return 1;
11587  }
11588  }
11589  return 0;
11590 }
11591 
11592 #undef token_info_push
11593 static void
11594 token_info_push(struct parser_params *parser, const char *token)
11595 {
11596  token_info *ptinfo;
11597 
11598  if (!parser->parser_token_info_enabled) return;
11599  ptinfo = ALLOC(token_info);
11600  ptinfo->token = token;
11601  ptinfo->linenum = ruby_sourceline;
11602  ptinfo->column = token_info_get_column(parser, token);
11603  ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11604  ptinfo->next = parser->parser_token_info;
11605 
11606  parser->parser_token_info = ptinfo;
11607 }
11608 
11609 #undef token_info_pop
11610 static void
11611 token_info_pop(struct parser_params *parser, const char *token)
11612 {
11613  int linenum;
11614  token_info *ptinfo = parser->parser_token_info;
11615 
11616  if (!ptinfo) return;
11617  parser->parser_token_info = ptinfo->next;
11618  if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11619  goto finish;
11620  }
11621  linenum = ruby_sourceline;
11622  if (linenum == ptinfo->linenum) { /* SKIP */
11623  goto finish;
11624  }
11625  if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11626  goto finish;
11627  }
11628  if (parser->parser_token_info_enabled) {
11630  "mismatched indentations at '%s' with '%s' at %d",
11631  token, ptinfo->token, ptinfo->linenum);
11632  }
11633 
11634  finish:
11635  xfree(ptinfo);
11636 }
11637 #endif /* RIPPER */
11638 
11639 static int
11640 parser_yyerror(struct parser_params *parser, const char *msg)
11641 {
11642 #ifndef RIPPER
11643  const int max_line_margin = 30;
11644  const char *p, *pe;
11645  char *buf;
11646  long len;
11647  int i;
11648 
11649  compile_error(PARSER_ARG "%s", msg);
11650  p = lex_p;
11651  while (lex_pbeg <= p) {
11652  if (*p == '\n') break;
11653  p--;
11654  }
11655  p++;
11656 
11657  pe = lex_p;
11658  while (pe < lex_pend) {
11659  if (*pe == '\n') break;
11660  pe++;
11661  }
11662 
11663  len = pe - p;
11664  if (len > 4) {
11665  char *p2;
11666  const char *pre = "", *post = "";
11667 
11668  if (len > max_line_margin * 2 + 10) {
11669  if (lex_p - p > max_line_margin) {
11670  p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11671  pre = "...";
11672  }
11673  if (pe - lex_p > max_line_margin) {
11674  pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11675  post = "...";
11676  }
11677  len = pe - p;
11678  }
11679  buf = ALLOCA_N(char, len+2);
11680  MEMCPY(buf, p, char, len);
11681  buf[len] = '\0';
11682  rb_compile_error_with_enc(NULL, 0, (void *)current_enc, "%s%s%s", pre, buf, post);
11683 
11684  i = (int)(lex_p - p);
11685  p2 = buf; pe = buf + len;
11686 
11687  while (p2 < pe) {
11688  if (*p2 != '\t') *p2 = ' ';
11689  p2++;
11690  }
11691  buf[i] = '^';
11692  buf[i+1] = '\0';
11693  rb_compile_error_append("%s%s", pre, buf);
11694  }
11695 #else
11696  dispatch1(parse_error, STR_NEW2(msg));
11697 #endif /* !RIPPER */
11698  return 0;
11699 }
11700 
11701 static void parser_prepare(struct parser_params *parser);
11702 
11703 #ifndef RIPPER
11704 static VALUE
11706 {
11707  ID script_lines;
11708  CONST_ID(script_lines, "SCRIPT_LINES__");
11709  if (rb_const_defined_at(rb_cObject, script_lines)) {
11710  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11711  if (RB_TYPE_P(hash, T_HASH)) {
11712  VALUE lines = rb_ary_new();
11713  rb_hash_aset(hash, fname, lines);
11714  return lines;
11715  }
11716  }
11717  return 0;
11718 }
11719 
11720 static VALUE
11721 coverage(VALUE fname, int n)
11722 {
11723  VALUE coverages = rb_get_coverages();
11724  if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11725  VALUE lines = rb_ary_new2(n);
11726  int i;
11727  RBASIC(lines)->klass = 0;
11728  for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11729  RARRAY(lines)->as.heap.len = n;
11730  rb_hash_aset(coverages, fname, lines);
11731  return lines;
11732  }
11733  return 0;
11734 }
11735 
11736 static int
11738 {
11739  return strcmp(ruby_sourcefile, "-e") == 0;
11740 }
11741 
11742 static VALUE
11744 {
11745  int n;
11746  NODE *tree;
11747  struct parser_params *parser = (struct parser_params *)arg;
11748 
11749  if (!compile_for_eval && rb_safe_level() == 0) {
11751  if (ruby_debug_lines && ruby_sourceline > 0) {
11752  VALUE str = STR_NEW0();
11753  n = ruby_sourceline;
11754  do {
11756  } while (--n);
11757  }
11758 
11759  if (!e_option_supplied(parser)) {
11761  }
11762  }
11763 
11764  parser_prepare(parser);
11765  deferred_nodes = 0;
11766 #ifndef RIPPER
11768 #endif
11769 #ifndef RIPPER
11772  parser->parser_ruby_sourceline);
11773  }
11774 #endif
11775  n = yyparse((void*)parser);
11776 #ifndef RIPPER
11779  parser->parser_ruby_sourceline);
11780  }
11781 #endif
11782  ruby_debug_lines = 0;
11783  ruby_coverage = 0;
11784  compile_for_eval = 0;
11785 
11786  lex_strterm = 0;
11787  lex_p = lex_pbeg = lex_pend = 0;
11788  lex_lastline = lex_nextline = 0;
11789  if (parser->nerr) {
11790  return 0;
11791  }
11792  tree = ruby_eval_tree;
11793  if (!tree) {
11794  tree = NEW_NIL();
11795  }
11796  else if (ruby_eval_tree_begin) {
11797  tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11798  }
11799  return (VALUE)tree;
11800 }
11801 
11802 static NODE*
11803 yycompile(struct parser_params *parser, VALUE fname, int line)
11804 {
11806  ruby_sourcefile = RSTRING_PTR(fname);
11807  ruby_sourceline = line - 1;
11808  return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
11809 }
11810 #endif /* !RIPPER */
11811 
11812 static rb_encoding *
11814 {
11815  rb_encoding *enc = rb_enc_get(s);
11816  if (!rb_enc_asciicompat(enc)) {
11817  rb_raise(rb_eArgError, "invalid source encoding");
11818  }
11819  return enc;
11820 }
11821 
11822 static VALUE
11823 lex_get_str(struct parser_params *parser, VALUE s)
11824 {
11825  char *beg, *end, *pend;
11827 
11828  beg = RSTRING_PTR(s);
11829  if (lex_gets_ptr) {
11830  if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11831  beg += lex_gets_ptr;
11832  }
11833  pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11834  end = beg;
11835  while (end < pend) {
11836  if (*end++ == '\n') break;
11837  }
11838  lex_gets_ptr = end - RSTRING_PTR(s);
11839  return rb_enc_str_new(beg, end - beg, enc);
11840 }
11841 
11842 static VALUE
11844 {
11845  VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11846  if (NIL_P(line)) return line;
11848 #ifndef RIPPER
11849  if (ruby_debug_lines) {
11852  }
11853  if (ruby_coverage) {
11855  }
11856 #endif
11857  return line;
11858 }
11859 
11860 #ifdef RIPPER
11862 #else
11864 
11865 static NODE*
11866 parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
11867 {
11868  struct parser_params *parser;
11869  NODE *node;
11870 
11871  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11873  lex_gets_ptr = 0;
11874  lex_input = s;
11875  lex_pbeg = lex_p = lex_pend = 0;
11877 
11878  node = yycompile(parser, fname, line);
11879  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11880 
11881  return node;
11882 }
11883 
11884 NODE*
11885 rb_compile_string(const char *f, VALUE s, int line)
11886 {
11889 }
11890 
11891 NODE*
11892 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11893 {
11894  return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
11895 }
11896 
11897 NODE*
11898 rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
11899 {
11901  return parser_compile_string(vparser, f, s, line);
11902 }
11903 
11904 NODE*
11905 rb_compile_cstr(const char *f, const char *s, int len, int line)
11906 {
11907  VALUE str = rb_str_new(s, len);
11909 }
11910 
11911 NODE*
11912 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
11913 {
11914  VALUE str = rb_str_new(s, len);
11915  return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line);
11916 }
11917 
11918 static VALUE
11919 lex_io_gets(struct parser_params *parser, VALUE io)
11920 {
11921  return rb_io_gets(io);
11922 }
11923 
11924 NODE*
11925 rb_compile_file(const char *f, VALUE file, int start)
11926 {
11927  VALUE volatile vparser = rb_parser_new();
11928 
11929  return rb_parser_compile_file(vparser, f, file, start);
11930 }
11931 
11932 NODE*
11933 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
11934 {
11935  return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start);
11936 }
11937 
11938 NODE*
11939 rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
11940 {
11941  struct parser_params *parser;
11942  NODE *node;
11943 
11944  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11946  lex_input = file;
11947  lex_pbeg = lex_p = lex_pend = 0;
11949 
11950  node = yycompile(parser, fname, start);
11951  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11952 
11953  return node;
11954 }
11955 #endif /* !RIPPER */
11956 
11957 #define STR_FUNC_ESCAPE 0x01
11958 #define STR_FUNC_EXPAND 0x02
11959 #define STR_FUNC_REGEXP 0x04
11960 #define STR_FUNC_QWORDS 0x08
11961 #define STR_FUNC_SYMBOL 0x10
11962 #define STR_FUNC_INDENT 0x20
11963 
11965  str_squote = (0),
11973 };
11974 
11975 static VALUE
11976 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
11977 {
11978  VALUE str;
11979 
11980  str = rb_enc_str_new(p, n, enc);
11981  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
11983  }
11984  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
11986  }
11987  }
11988 
11989  return str;
11990 }
11991 
11992 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
11993 #define lex_eol_p() (lex_p >= lex_pend)
11994 #define peek(c) peek_n((c), 0)
11995 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
11996 
11997 static inline int
11999 {
12000  int c;
12001 
12002  if (lex_p == lex_pend) {
12003  VALUE v = lex_nextline;
12004  lex_nextline = 0;
12005  if (!v) {
12006  if (parser->eofp)
12007  return -1;
12008 
12009  if (!lex_input || NIL_P(v = lex_getline(parser))) {
12010  parser->eofp = Qtrue;
12011  lex_goto_eol(parser);
12012  return -1;
12013  }
12014  }
12015  {
12016 #ifdef RIPPER
12017  if (parser->tokp < lex_pend) {
12018  if (NIL_P(parser->delayed)) {
12019  parser->delayed = rb_str_buf_new(1024);
12020  rb_enc_associate(parser->delayed, current_enc);
12021  rb_str_buf_cat(parser->delayed,
12022  parser->tokp, lex_pend - parser->tokp);
12023  parser->delayed_line = ruby_sourceline;
12024  parser->delayed_col = (int)(parser->tokp - lex_pbeg);
12025  }
12026  else {
12027  rb_str_buf_cat(parser->delayed,
12028  parser->tokp, lex_pend - parser->tokp);
12029  }
12030  }
12031 #endif
12032  if (heredoc_end > 0) {
12034  heredoc_end = 0;
12035  }
12036  ruby_sourceline++;
12037  parser->line_count++;
12038  lex_pbeg = lex_p = RSTRING_PTR(v);
12039  lex_pend = lex_p + RSTRING_LEN(v);
12040  ripper_flush(parser);
12041  lex_lastline = v;
12042  }
12043  }
12044  c = (unsigned char)*lex_p++;
12045  if (c == '\r' && peek('\n')) {
12046  lex_p++;
12047  c = '\n';
12048  }
12049 
12050  return c;
12051 }
12052 
12053 static void
12054 parser_pushback(struct parser_params *parser, int c)
12055 {
12056  if (c == -1) return;
12057  lex_p--;
12058  if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
12059  lex_p--;
12060  }
12061 }
12062 
12063 #define was_bol() (lex_p == lex_pbeg + 1)
12064 
12065 #define tokfix() (tokenbuf[tokidx]='\0')
12066 #define tok() tokenbuf
12067 #define toklen() tokidx
12068 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
12069 
12070 static char*
12072 {
12073  tokidx = 0;
12075  if (!tokenbuf) {
12076  toksiz = 60;
12077  tokenbuf = ALLOC_N(char, 60);
12078  }
12079  if (toksiz > 4096) {
12080  toksiz = 60;
12081  REALLOC_N(tokenbuf, char, 60);
12082  }
12083  return tokenbuf;
12084 }
12085 
12086 static char *
12087 parser_tokspace(struct parser_params *parser, int n)
12088 {
12089  tokidx += n;
12090 
12091  if (tokidx >= toksiz) {
12092  do {toksiz *= 2;} while (toksiz < tokidx);
12093  REALLOC_N(tokenbuf, char, toksiz);
12094  }
12095  return &tokenbuf[tokidx-n];
12096 }
12097 
12098 static void
12099 parser_tokadd(struct parser_params *parser, int c)
12100 {
12101  tokenbuf[tokidx++] = (char)c;
12102  if (tokidx >= toksiz) {
12103  toksiz *= 2;
12104  REALLOC_N(tokenbuf, char, toksiz);
12105  }
12106 }
12107 
12108 static int
12109 parser_tok_hex(struct parser_params *parser, size_t *numlen)
12110 {
12111  int c;
12112 
12113  c = scan_hex(lex_p, 2, numlen);
12114  if (!*numlen) {
12115  yyerror("invalid hex escape");
12116  return 0;
12117  }
12118  lex_p += *numlen;
12119  return c;
12120 }
12121 
12122 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
12123 
12124 /* return value is for ?\u3042 */
12125 static int
12127  int string_literal, int symbol_literal, int regexp_literal)
12128 {
12129  /*
12130  * If string_literal is true, then we allow multiple codepoints
12131  * in \u{}, and add the codepoints to the current token.
12132  * Otherwise we're parsing a character literal and return a single
12133  * codepoint without adding it
12134  */
12135 
12136  int codepoint;
12137  size_t numlen;
12138 
12139  if (regexp_literal) { tokadd('\\'); tokadd('u'); }
12140 
12141  if (peek('{')) { /* handle \u{...} form */
12142  do {
12143  if (regexp_literal) { tokadd(*lex_p); }
12144  nextc();
12145  codepoint = scan_hex(lex_p, 6, &numlen);
12146  if (numlen == 0) {
12147  yyerror("invalid Unicode escape");
12148  return 0;
12149  }
12150  if (codepoint > 0x10ffff) {
12151  yyerror("invalid Unicode codepoint (too large)");
12152  return 0;
12153  }
12154  lex_p += numlen;
12155  if (regexp_literal) {
12156  tokcopy((int)numlen);
12157  }
12158  else if (codepoint >= 0x80) {
12159  *encp = rb_utf8_encoding();
12160  if (string_literal) tokaddmbc(codepoint, *encp);
12161  }
12162  else if (string_literal) {
12163  tokadd(codepoint);
12164  }
12165  } while (string_literal && (peek(' ') || peek('\t')));
12166 
12167  if (!peek('}')) {
12168  yyerror("unterminated Unicode escape");
12169  return 0;
12170  }
12171 
12172  if (regexp_literal) { tokadd('}'); }
12173  nextc();
12174  }
12175  else { /* handle \uxxxx form */
12176  codepoint = scan_hex(lex_p, 4, &numlen);
12177  if (numlen < 4) {
12178  yyerror("invalid Unicode escape");
12179  return 0;
12180  }
12181  lex_p += 4;
12182  if (regexp_literal) {
12183  tokcopy(4);
12184  }
12185  else if (codepoint >= 0x80) {
12186  *encp = rb_utf8_encoding();
12187  if (string_literal) tokaddmbc(codepoint, *encp);
12188  }
12189  else if (string_literal) {
12190  tokadd(codepoint);
12191  }
12192  }
12193 
12194  return codepoint;
12195 }
12196 
12197 #define ESCAPE_CONTROL 1
12198 #define ESCAPE_META 2
12199 
12200 static int
12201 parser_read_escape(struct parser_params *parser, int flags,
12202  rb_encoding **encp)
12203 {
12204  int c;
12205  size_t numlen;
12206 
12207  switch (c = nextc()) {
12208  case '\\': /* Backslash */
12209  return c;
12210 
12211  case 'n': /* newline */
12212  return '\n';
12213 
12214  case 't': /* horizontal tab */
12215  return '\t';
12216 
12217  case 'r': /* carriage-return */
12218  return '\r';
12219 
12220  case 'f': /* form-feed */
12221  return '\f';
12222 
12223  case 'v': /* vertical tab */
12224  return '\13';
12225 
12226  case 'a': /* alarm(bell) */
12227  return '\007';
12228 
12229  case 'e': /* escape */
12230  return 033;
12231 
12232  case '0': case '1': case '2': case '3': /* octal constant */
12233  case '4': case '5': case '6': case '7':
12234  pushback(c);
12235  c = scan_oct(lex_p, 3, &numlen);
12236  lex_p += numlen;
12237  return c;
12238 
12239  case 'x': /* hex constant */
12240  c = tok_hex(&numlen);
12241  if (numlen == 0) return 0;
12242  return c;
12243 
12244  case 'b': /* backspace */
12245  return '\010';
12246 
12247  case 's': /* space */
12248  return ' ';
12249 
12250  case 'M':
12251  if (flags & ESCAPE_META) goto eof;
12252  if ((c = nextc()) != '-') {
12253  pushback(c);
12254  goto eof;
12255  }
12256  if ((c = nextc()) == '\\') {
12257  if (peek('u')) goto eof;
12258  return read_escape(flags|ESCAPE_META, encp) | 0x80;
12259  }
12260  else if (c == -1 || !ISASCII(c)) goto eof;
12261  else {
12262  return ((c & 0xff) | 0x80);
12263  }
12264 
12265  case 'C':
12266  if ((c = nextc()) != '-') {
12267  pushback(c);
12268  goto eof;
12269  }
12270  case 'c':
12271  if (flags & ESCAPE_CONTROL) goto eof;
12272  if ((c = nextc())== '\\') {
12273  if (peek('u')) goto eof;
12274  c = read_escape(flags|ESCAPE_CONTROL, encp);
12275  }
12276  else if (c == '?')
12277  return 0177;
12278  else if (c == -1 || !ISASCII(c)) goto eof;
12279  return c & 0x9f;
12280 
12281  eof:
12282  case -1:
12283  yyerror("Invalid escape character syntax");
12284  return '\0';
12285 
12286  default:
12287  return c;
12288  }
12289 }
12290 
12291 static void
12293 {
12294  int len = rb_enc_codelen(c, enc);
12295  rb_enc_mbcput(c, tokspace(len), enc);
12296 }
12297 
12298 static int
12300 {
12301  int c;
12302  int flags = 0;
12303  size_t numlen;
12304 
12305  first:
12306  switch (c = nextc()) {
12307  case '\n':
12308  return 0; /* just ignore */
12309 
12310  case '0': case '1': case '2': case '3': /* octal constant */
12311  case '4': case '5': case '6': case '7':
12312  {
12313  ruby_scan_oct(--lex_p, 3, &numlen);
12314  if (numlen == 0) goto eof;
12315  lex_p += numlen;
12316  tokcopy((int)numlen + 1);
12317  }
12318  return 0;
12319 
12320  case 'x': /* hex constant */
12321  {
12322  tok_hex(&numlen);
12323  if (numlen == 0) return -1;
12324  tokcopy((int)numlen + 2);
12325  }
12326  return 0;
12327 
12328  case 'M':
12329  if (flags & ESCAPE_META) goto eof;
12330  if ((c = nextc()) != '-') {
12331  pushback(c);
12332  goto eof;
12333  }
12334  tokcopy(3);
12335  flags |= ESCAPE_META;
12336  goto escaped;
12337 
12338  case 'C':
12339  if (flags & ESCAPE_CONTROL) goto eof;
12340  if ((c = nextc()) != '-') {
12341  pushback(c);
12342  goto eof;
12343  }
12344  tokcopy(3);
12345  goto escaped;
12346 
12347  case 'c':
12348  if (flags & ESCAPE_CONTROL) goto eof;
12349  tokcopy(2);
12350  flags |= ESCAPE_CONTROL;
12351  escaped:
12352  if ((c = nextc()) == '\\') {
12353  goto first;
12354  }
12355  else if (c == -1) goto eof;
12356  tokadd(c);
12357  return 0;
12358 
12359  eof:
12360  case -1:
12361  yyerror("Invalid escape character syntax");
12362  return -1;
12363 
12364  default:
12365  tokadd('\\');
12366  tokadd(c);
12367  }
12368  return 0;
12369 }
12370 
12371 static int
12373 {
12374  int kcode = 0;
12375  int kopt = 0;
12376  int options = 0;
12377  int c, opt, kc;
12378 
12379  newtok();
12380  while (c = nextc(), ISALPHA(c)) {
12381  if (c == 'o') {
12382  options |= RE_OPTION_ONCE;
12383  }
12384  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12385  if (kc >= 0) {
12386  if (kc != rb_ascii8bit_encindex()) kcode = c;
12387  kopt = opt;
12388  }
12389  else {
12390  options |= opt;
12391  }
12392  }
12393  else {
12394  tokadd(c);
12395  }
12396  }
12397  options |= kopt;
12398  pushback(c);
12399  if (toklen()) {
12400  tokfix();
12401  compile_error(PARSER_ARG "unknown regexp option%s - %s",
12402  toklen() > 1 ? "s" : "", tok());
12403  }
12404  return options | RE_OPTION_ENCODING(kcode);
12405 }
12406 
12407 static void
12409 {
12410  rb_str_free(str);
12411  rb_gc_force_recycle(str);
12412 }
12413 
12414 static int
12415 parser_tokadd_mbchar(struct parser_params *parser, int c)
12416 {
12417  int len = parser_precise_mbclen();
12418  if (!MBCLEN_CHARFOUND_P(len)) {
12419  compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12420  return -1;
12421  }
12422  tokadd(c);
12423  lex_p += --len;
12424  if (len > 0) tokcopy(len);
12425  return c;
12426 }
12427 
12428 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12429 
12430 static inline int
12432 {
12433  switch (c) {
12434  case '$': case '*': case '+': case '.':
12435  case '?': case '^': case '|':
12436  case ')': case ']': case '}': case '>':
12437  return TRUE;
12438  default:
12439  return FALSE;
12440  }
12441 }
12442 
12443 static int
12445  int func, int term, int paren, long *nest,
12446  rb_encoding **encp)
12447 {
12448  int c;
12449  int has_nonascii = 0;
12450  rb_encoding *enc = *encp;
12451  char *errbuf = 0;
12452  static const char mixed_msg[] = "%s mixed within %s source";
12453 
12454 #define mixed_error(enc1, enc2) if (!errbuf) { \
12455  size_t len = sizeof(mixed_msg) - 4; \
12456  len += strlen(rb_enc_name(enc1)); \
12457  len += strlen(rb_enc_name(enc2)); \
12458  errbuf = ALLOCA_N(char, len); \
12459  snprintf(errbuf, len, mixed_msg, \
12460  rb_enc_name(enc1), \
12461  rb_enc_name(enc2)); \
12462  yyerror(errbuf); \
12463  }
12464 #define mixed_escape(beg, enc1, enc2) do { \
12465  const char *pos = lex_p; \
12466  lex_p = (beg); \
12467  mixed_error((enc1), (enc2)); \
12468  lex_p = pos; \
12469  } while (0)
12470 
12471  while ((c = nextc()) != -1) {
12472  if (paren && c == paren) {
12473  ++*nest;
12474  }
12475  else if (c == term) {
12476  if (!nest || !*nest) {
12477  pushback(c);
12478  break;
12479  }
12480  --*nest;
12481  }
12482  else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12483  int c2 = *lex_p;
12484  if (c2 == '$' || c2 == '@' || c2 == '{') {
12485  pushback(c);
12486  break;
12487  }
12488  }
12489  else if (c == '\\') {
12490  const char *beg = lex_p - 1;
12491  c = nextc();
12492  switch (c) {
12493  case '\n':
12494  if (func & STR_FUNC_QWORDS) break;
12495  if (func & STR_FUNC_EXPAND) continue;
12496  tokadd('\\');
12497  break;
12498 
12499  case '\\':
12500  if (func & STR_FUNC_ESCAPE) tokadd(c);
12501  break;
12502 
12503  case 'u':
12504  if ((func & STR_FUNC_EXPAND) == 0) {
12505  tokadd('\\');
12506  break;
12507  }
12508  parser_tokadd_utf8(parser, &enc, 1,
12509  func & STR_FUNC_SYMBOL,
12510  func & STR_FUNC_REGEXP);
12511  if (has_nonascii && enc != *encp) {
12512  mixed_escape(beg, enc, *encp);
12513  }
12514  continue;
12515 
12516  default:
12517  if (c == -1) return -1;
12518  if (!ISASCII(c)) {
12519  if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12520  goto non_ascii;
12521  }
12522  if (func & STR_FUNC_REGEXP) {
12523  if (c == term && !simple_re_meta(c)) {
12524  tokadd(c);
12525  continue;
12526  }
12527  pushback(c);
12528  if ((c = tokadd_escape(&enc)) < 0)
12529  return -1;
12530  if (has_nonascii && enc != *encp) {
12531  mixed_escape(beg, enc, *encp);
12532  }
12533  continue;
12534  }
12535  else if (func & STR_FUNC_EXPAND) {
12536  pushback(c);
12537  if (func & STR_FUNC_ESCAPE) tokadd('\\');
12538  c = read_escape(0, &enc);
12539  }
12540  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12541  /* ignore backslashed spaces in %w */
12542  }
12543  else if (c != term && !(paren && c == paren)) {
12544  tokadd('\\');
12545  pushback(c);
12546  continue;
12547  }
12548  }
12549  }
12550  else if (!parser_isascii()) {
12551  non_ascii:
12552  has_nonascii = 1;
12553  if (enc != *encp) {
12554  mixed_error(enc, *encp);
12555  continue;
12556  }
12557  if (tokadd_mbchar(c) == -1) return -1;
12558  continue;
12559  }
12560  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12561  pushback(c);
12562  break;
12563  }
12564  if (c & 0x80) {
12565  has_nonascii = 1;
12566  if (enc != *encp) {
12567  mixed_error(enc, *encp);
12568  continue;
12569  }
12570  }
12571  tokadd(c);
12572  }
12573  *encp = enc;
12574  return c;
12575 }
12576 
12577 #define NEW_STRTERM(func, term, paren) \
12578  rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12579 
12580 #ifdef RIPPER
12581 static void
12582 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12583 {
12584  if (!NIL_P(parser->delayed)) {
12585  ptrdiff_t len = lex_p - parser->tokp;
12586  if (len > 0) {
12587  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12588  }
12589  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12590  parser->tokp = lex_p;
12591  }
12592 }
12593 
12594 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12595 #else
12596 #define flush_string_content(enc) ((void)(enc))
12597 #endif
12598 
12599 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12600 /* this can be shared with ripper, since it's independent from struct
12601  * parser_params. */
12602 #ifndef RIPPER
12603 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12604 #define SPECIAL_PUNCT(idx) ( \
12605  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12606  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12607  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12608  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12609  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12610  BIT('0', idx))
12611 const unsigned int ruby_global_name_punct_bits[] = {
12612  SPECIAL_PUNCT(0),
12613  SPECIAL_PUNCT(1),
12614  SPECIAL_PUNCT(2),
12615 };
12616 #undef BIT
12617 #undef SPECIAL_PUNCT
12618 #endif
12619 
12620 static inline int
12622 {
12623  if (c <= 0x20 || 0x7e < c) return 0;
12624  return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12625 }
12626 
12627 static int
12629 {
12630  int c;
12631  const char *p = lex_p;
12632 
12633  if (p + 1 >= lex_pend) return 0;
12634  c = *p++;
12635  switch (c) {
12636  case '$':
12637  if ((c = *p) == '-') {
12638  if (++p >= lex_pend) return 0;
12639  c = *p;
12640  }
12641  else if (is_global_name_punct(c) || ISDIGIT(c)) {
12642  return tSTRING_DVAR;
12643  }
12644  break;
12645  case '@':
12646  if ((c = *p) == '@') {
12647  if (++p >= lex_pend) return 0;
12648  c = *p;
12649  }
12650  break;
12651  case '{':
12652  lex_p = p;
12653  command_start = TRUE;
12654  return tSTRING_DBEG;
12655  default:
12656  return 0;
12657  }
12658  if (!ISASCII(c) || c == '_' || ISALPHA(c))
12659  return tSTRING_DVAR;
12660  return 0;
12661 }
12662 
12663 static int
12664 parser_parse_string(struct parser_params *parser, NODE *quote)
12665 {
12666  int func = (int)quote->nd_func;
12667  int term = nd_term(quote);
12668  int paren = nd_paren(quote);
12669  int c, space = 0;
12671 
12672  if (func == -1) return tSTRING_END;
12673  c = nextc();
12674  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12675  do {c = nextc();} while (ISSPACE(c));
12676  space = 1;
12677  }
12678  if (c == term && !quote->nd_nest) {
12679  if (func & STR_FUNC_QWORDS) {
12680  quote->nd_func = -1;
12681  return ' ';
12682  }
12683  if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12685  return tREGEXP_END;
12686  }
12687  if (space) {
12688  pushback(c);
12689  return ' ';
12690  }
12691  newtok();
12692  if ((func & STR_FUNC_EXPAND) && c == '#') {
12693  int t = parser_peek_variable_name(parser);
12694  if (t) return t;
12695  tokadd('#');
12696  c = nextc();
12697  }
12698  pushback(c);
12699  if (tokadd_string(func, term, paren, &quote->nd_nest,
12700  &enc) == -1) {
12701  ruby_sourceline = nd_line(quote);
12702  if (func & STR_FUNC_REGEXP) {
12703  if (parser->eofp)
12704  compile_error(PARSER_ARG "unterminated regexp meets end of file");
12705  return tREGEXP_END;
12706  }
12707  else {
12708  if (parser->eofp)
12709  compile_error(PARSER_ARG "unterminated string meets end of file");
12710  return tSTRING_END;
12711  }
12712  }
12713 
12714  tokfix();
12715  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12716  flush_string_content(enc);
12717 
12718  return tSTRING_CONTENT;
12719 }
12720 
12721 static int
12723 {
12724  int c = nextc(), term, func = 0;
12725  long len;
12726 
12727  if (c == '-') {
12728  c = nextc();
12729  func = STR_FUNC_INDENT;
12730  }
12731  switch (c) {
12732  case '\'':
12733  func |= str_squote; goto quoted;
12734  case '"':
12735  func |= str_dquote; goto quoted;
12736  case '`':
12737  func |= str_xquote;
12738  quoted:
12739  newtok();
12740  tokadd(func);
12741  term = c;
12742  while ((c = nextc()) != -1 && c != term) {
12743  if (tokadd_mbchar(c) == -1) return 0;
12744  }
12745  if (c == -1) {
12746  compile_error(PARSER_ARG "unterminated here document identifier");
12747  return 0;
12748  }
12749  break;
12750 
12751  default:
12752  if (!parser_is_identchar()) {
12753  pushback(c);
12754  if (func & STR_FUNC_INDENT) {
12755  pushback('-');
12756  }
12757  return 0;
12758  }
12759  newtok();
12760  term = '"';
12761  tokadd(func |= str_dquote);
12762  do {
12763  if (tokadd_mbchar(c) == -1) return 0;
12764  } while ((c = nextc()) != -1 && parser_is_identchar());
12765  pushback(c);
12766  break;
12767  }
12768 
12769  tokfix();
12770 #ifdef RIPPER
12771  ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12772 #endif
12773  len = lex_p - lex_pbeg;
12774  lex_goto_eol(parser);
12776  STR_NEW(tok(), toklen()), /* nd_lit */
12777  len, /* nd_nth */
12778  lex_lastline); /* nd_orig */
12780  ripper_flush(parser);
12781  return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12782 }
12783 
12784 static void
12786 {
12787  VALUE line;
12788 
12789  line = here->nd_orig;
12790  lex_lastline = line;
12791  lex_pbeg = RSTRING_PTR(line);
12792  lex_pend = lex_pbeg + RSTRING_LEN(line);
12793  lex_p = lex_pbeg + here->nd_nth;
12795  ruby_sourceline = nd_line(here);
12796  dispose_string(here->nd_lit);
12797  rb_gc_force_recycle((VALUE)here);
12798  ripper_flush(parser);
12799 }
12800 
12801 static int
12803  const char *eos, long len, int indent)
12804 {
12805  const char *p = lex_pbeg;
12806  long n;
12807 
12808  if (indent) {
12809  while (*p && ISSPACE(*p)) p++;
12810  }
12811  n = lex_pend - (p + len);
12812  if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12813  return strncmp(eos, p, len) == 0;
12814 }
12815 
12816 #ifdef RIPPER
12817 static void
12818 ripper_dispatch_heredoc_end(struct parser_params *parser)
12819 {
12820  if (!NIL_P(parser->delayed))
12821  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12822  lex_goto_eol(parser);
12823  ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12824 }
12825 
12826 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12827 #else
12828 #define dispatch_heredoc_end() ((void)0)
12829 #endif
12830 
12831 static int
12833 {
12834  int c, func, indent = 0;
12835  const char *eos, *p, *pend;
12836  long len;
12837  VALUE str = 0;
12839 
12840  eos = RSTRING_PTR(here->nd_lit);
12841  len = RSTRING_LEN(here->nd_lit) - 1;
12842  indent = (func = *eos++) & STR_FUNC_INDENT;
12843 
12844  if ((c = nextc()) == -1) {
12845  error:
12846  compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12847 #ifdef RIPPER
12848  if (NIL_P(parser->delayed)) {
12849  ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12850  }
12851  else {
12852  if (str ||
12853  ((len = lex_p - parser->tokp) > 0 &&
12854  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12855  rb_str_append(parser->delayed, str);
12856  }
12857  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12858  }
12859  lex_goto_eol(parser);
12860 #endif
12861  restore:
12863  lex_strterm = 0;
12864  return 0;
12865  }
12866  if (was_bol() && whole_match_p(eos, len, indent)) {
12869  return tSTRING_END;
12870  }
12871 
12872  if (!(func & STR_FUNC_EXPAND)) {
12873  do {
12875  pend = lex_pend;
12876  if (pend > p) {
12877  switch (pend[-1]) {
12878  case '\n':
12879  if (--pend == p || pend[-1] != '\r') {
12880  pend++;
12881  break;
12882  }
12883  case '\r':
12884  --pend;
12885  }
12886  }
12887  if (str)
12888  rb_str_cat(str, p, pend - p);
12889  else
12890  str = STR_NEW(p, pend - p);
12891  if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12892  lex_goto_eol(parser);
12893  if (nextc() == -1) {
12894  if (str) {
12895  dispose_string(str);
12896  str = 0;
12897  }
12898  goto error;
12899  }
12900  } while (!whole_match_p(eos, len, indent));
12901  }
12902  else {
12903  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12904  newtok();
12905  if (c == '#') {
12906  int t = parser_peek_variable_name(parser);
12907  if (t) return t;
12908  tokadd('#');
12909  c = nextc();
12910  }
12911  do {
12912  pushback(c);
12913  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
12914  if (parser->eofp) goto error;
12915  goto restore;
12916  }
12917  if (c != '\n') {
12918  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12919  flush_string_content(enc);
12920  return tSTRING_CONTENT;
12921  }
12922  tokadd(nextc());
12923  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
12924  if ((c = nextc()) == -1) goto error;
12925  } while (!whole_match_p(eos, len, indent));
12926  str = STR_NEW3(tok(), toklen(), enc, func);
12927  }
12930  lex_strterm = NEW_STRTERM(-1, 0, 0);
12931  set_yylval_str(str);
12932  return tSTRING_CONTENT;
12933 }
12934 
12935 #include "lex.c"
12936 
12937 static void
12939 {
12940 #ifndef RIPPER
12941  rb_warning0("ambiguous first argument; put parentheses or even spaces");
12942 #else
12943  dispatch0(arg_ambiguous);
12944 #endif
12945 }
12946 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
12947 
12948 static ID
12950 {
12951 #ifndef RIPPER
12952  if (!is_local_id(lhs))
12953  yyerror("formal argument must be local variable");
12954 #endif
12955  shadowing_lvar(lhs);
12956  return lhs;
12957 }
12958 
12959 static int
12960 lvar_defined_gen(struct parser_params *parser, ID id)
12961 {
12962  return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
12963 }
12964 
12965 /* emacsen -*- hack */
12966 static long
12967 parser_encode_length(struct parser_params *parser, const char *name, long len)
12968 {
12969  long nlen;
12970 
12971  if (len > 5 && name[nlen = len - 5] == '-') {
12972  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
12973  return nlen;
12974  }
12975  if (len > 4 && name[nlen = len - 4] == '-') {
12976  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
12977  return nlen;
12978  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
12979  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
12980  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
12981  return nlen;
12982  }
12983  return len;
12984 }
12985 
12986 static void
12987 parser_set_encode(struct parser_params *parser, const char *name)
12988 {
12989  int idx = rb_enc_find_index(name);
12990  rb_encoding *enc;
12991  VALUE excargs[3];
12992 
12993  if (idx < 0) {
12994  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
12995  error:
12996  excargs[0] = rb_eArgError;
12997  excargs[2] = rb_make_backtrace();
12998  rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
12999  rb_exc_raise(rb_make_exception(3, excargs));
13000  }
13001  enc = rb_enc_from_index(idx);
13002  if (!rb_enc_asciicompat(enc)) {
13003  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13004  goto error;
13005  }
13006  parser->enc = enc;
13007 #ifndef RIPPER
13008  if (ruby_debug_lines) {
13009  long i, n = RARRAY_LEN(ruby_debug_lines);
13010  const VALUE *p = RARRAY_PTR(ruby_debug_lines);
13011  for (i = 0; i < n; ++i) {
13012  rb_enc_associate_index(*p, idx);
13013  }
13014  }
13015 #endif
13016 }
13017 
13018 static int
13020 {
13021  const char *p = lex_pbeg, *pend = lex_p - 1;
13022  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13023  while (p < pend) {
13024  if (!ISSPACE(*p)) return 0;
13025  p++;
13026  }
13027  return 1;
13028 }
13029 
13030 #ifndef RIPPER
13031 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13032 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13033 
13034 static void
13035 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13036 {
13037  if (!comment_at_top(parser)) {
13038  return;
13039  }
13040  parser_set_encode(parser, val);
13041 }
13042 
13043 static void
13044 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13045 {
13046  int *p = &parser->parser_token_info_enabled;
13047 
13048  switch (*val) {
13049  case 't': case 'T':
13050  if (strcasecmp(val, "true") == 0) {
13051  *p = TRUE;
13052  return;
13053  }
13054  break;
13055  case 'f': case 'F':
13056  if (strcasecmp(val, "false") == 0) {
13057  *p = FALSE;
13058  return;
13059  }
13060  break;
13061  }
13062  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13063 }
13064 
13065 struct magic_comment {
13066  const char *name;
13069 };
13070 
13071 static const struct magic_comment magic_comments[] = {
13074  {"warn_indent", parser_set_token_info},
13075 };
13076 #endif
13077 
13078 static const char *
13079 magic_comment_marker(const char *str, long len)
13080 {
13081  long i = 2;
13082 
13083  while (i < len) {
13084  switch (str[i]) {
13085  case '-':
13086  if (str[i-1] == '*' && str[i-2] == '-') {
13087  return str + i + 1;
13088  }
13089  i += 2;
13090  break;
13091  case '*':
13092  if (i + 1 >= len) return 0;
13093  if (str[i+1] != '-') {
13094  i += 4;
13095  }
13096  else if (str[i-1] != '-') {
13097  i += 2;
13098  }
13099  else {
13100  return str + i + 2;
13101  }
13102  break;
13103  default:
13104  i += 3;
13105  break;
13106  }
13107  }
13108  return 0;
13109 }
13110 
13111 static int
13112 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13113 {
13114  VALUE name = 0, val = 0;
13115  const char *beg, *end, *vbeg, *vend;
13116 #define str_copy(_s, _p, _n) ((_s) \
13117  ? (void)(rb_str_resize((_s), (_n)), \
13118  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13119  : (void)((_s) = STR_NEW((_p), (_n))))
13120 
13121  if (len <= 7) return FALSE;
13122  if (!(beg = magic_comment_marker(str, len))) return FALSE;
13123  if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13124  str = beg;
13125  len = end - beg - 3;
13126 
13127  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13128  while (len > 0) {
13129 #ifndef RIPPER
13130  const struct magic_comment *p = magic_comments;
13131 #endif
13132  char *s;
13133  int i;
13134  long n = 0;
13135 
13136  for (; len > 0 && *str; str++, --len) {
13137  switch (*str) {
13138  case '\'': case '"': case ':': case ';':
13139  continue;
13140  }
13141  if (!ISSPACE(*str)) break;
13142  }
13143  for (beg = str; len > 0; str++, --len) {
13144  switch (*str) {
13145  case '\'': case '"': case ':': case ';':
13146  break;
13147  default:
13148  if (ISSPACE(*str)) break;
13149  continue;
13150  }
13151  break;
13152  }
13153  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13154  if (!len) break;
13155  if (*str != ':') continue;
13156 
13157  do str++; while (--len > 0 && ISSPACE(*str));
13158  if (!len) break;
13159  if (*str == '"') {
13160  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13161  if (*str == '\\') {
13162  --len;
13163  ++str;
13164  }
13165  }
13166  vend = str;
13167  if (len) {
13168  --len;
13169  ++str;
13170  }
13171  }
13172  else {
13173  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13174  vend = str;
13175  }
13176  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13177 
13178  n = end - beg;
13179  str_copy(name, beg, n);
13180  s = RSTRING_PTR(name);
13181  for (i = 0; i < n; ++i) {
13182  if (s[i] == '-') s[i] = '_';
13183  }
13184 #ifndef RIPPER
13185  do {
13186  if (STRNCASECMP(p->name, s, n) == 0) {
13187  n = vend - vbeg;
13188  if (p->length) {
13189  n = (*p->length)(parser, vbeg, n);
13190  }
13191  str_copy(val, vbeg, n);
13192  (*p->func)(parser, s, RSTRING_PTR(val));
13193  break;
13194  }
13195  } while (++p < magic_comments + numberof(magic_comments));
13196 #else
13197  str_copy(val, vbeg, vend - vbeg);
13198  dispatch2(magic_comment, name, val);
13199 #endif
13200  }
13201 
13202  return TRUE;
13203 }
13204 
13205 static void
13206 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13207 {
13208  int sep = 0;
13209  const char *beg = str;
13210  VALUE s;
13211 
13212  for (;;) {
13213  if (send - str <= 6) return;
13214  switch (str[6]) {
13215  case 'C': case 'c': str += 6; continue;
13216  case 'O': case 'o': str += 5; continue;
13217  case 'D': case 'd': str += 4; continue;
13218  case 'I': case 'i': str += 3; continue;
13219  case 'N': case 'n': str += 2; continue;
13220  case 'G': case 'g': str += 1; continue;
13221  case '=': case ':':
13222  sep = 1;
13223  str += 6;
13224  break;
13225  default:
13226  str += 6;
13227  if (ISSPACE(*str)) break;
13228  continue;
13229  }
13230  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13231  }
13232  for (;;) {
13233  do {
13234  if (++str >= send) return;
13235  } while (ISSPACE(*str));
13236  if (sep) break;
13237  if (*str != '=' && *str != ':') return;
13238  sep = 1;
13239  str++;
13240  }
13241  beg = str;
13242  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13243  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13244  parser_set_encode(parser, RSTRING_PTR(s));
13245  rb_str_resize(s, 0);
13246 }
13247 
13248 static void
13250 {
13251  int c = nextc();
13252  switch (c) {
13253  case '#':
13254  if (peek('!')) parser->has_shebang = 1;
13255  break;
13256  case 0xef: /* UTF-8 BOM marker */
13257  if (lex_pend - lex_p >= 2 &&
13258  (unsigned char)lex_p[0] == 0xbb &&
13259  (unsigned char)lex_p[1] == 0xbf) {
13260  parser->enc = rb_utf8_encoding();
13261  lex_p += 2;
13262  lex_pbeg = lex_p;
13263  return;
13264  }
13265  break;
13266  case EOF:
13267  return;
13268  }
13269  pushback(c);
13270  parser->enc = rb_enc_get(lex_lastline);
13271 }
13272 
13273 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13274 #define IS_END() IS_lex_state(EXPR_END_ANY)
13275 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13276 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13277 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13278 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13279 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13280 
13281 #ifndef RIPPER
13282 #define ambiguous_operator(op, syn) ( \
13283  rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
13284  rb_warning0("even though it seems like "syn""))
13285 #else
13286 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13287 #endif
13288 #define warn_balanced(op, syn) ((void) \
13289  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13290  space_seen && !ISSPACE(c) && \
13291  (ambiguous_operator(op, syn), 0)))
13292 
13293 static int
13295 {
13296  register int c;
13297  int space_seen = 0;
13298  int cmd_state;
13299  enum lex_state_e last_state;
13300  rb_encoding *enc;
13301  int mb;
13302 #ifdef RIPPER
13303  int fallthru = FALSE;
13304 #endif
13305 
13306  if (lex_strterm) {
13307  int token;
13308  if (nd_type(lex_strterm) == NODE_HEREDOC) {
13309  token = here_document(lex_strterm);
13310  if (token == tSTRING_END) {
13311  lex_strterm = 0;
13312  lex_state = EXPR_END;
13313  }
13314  }
13315  else {
13316  token = parse_string(lex_strterm);
13317  if (token == tSTRING_END || token == tREGEXP_END) {
13319  lex_strterm = 0;
13320  lex_state = EXPR_END;
13321  }
13322  }
13323  return token;
13324  }
13325  cmd_state = command_start;
13326  command_start = FALSE;
13327  retry:
13328  last_state = lex_state;
13329  switch (c = nextc()) {
13330  case '\0': /* NUL */
13331  case '\004': /* ^D */
13332  case '\032': /* ^Z */
13333  case -1: /* end of script. */
13334  return 0;
13335 
13336  /* white spaces */
13337  case ' ': case '\t': case '\f': case '\r':
13338  case '\13': /* '\v' */
13339  space_seen = 1;
13340 #ifdef RIPPER
13341  while ((c = nextc())) {
13342  switch (c) {
13343  case ' ': case '\t': case '\f': case '\r':
13344  case '\13': /* '\v' */
13345  break;
13346  default:
13347  goto outofloop;
13348  }
13349  }
13350  outofloop:
13351  pushback(c);
13352  ripper_dispatch_scan_event(parser, tSP);
13353 #endif
13354  goto retry;
13355 
13356  case '#': /* it's a comment */
13357  /* no magic_comment in shebang line */
13358  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13359  if (comment_at_top(parser)) {
13360  set_file_encoding(parser, lex_p, lex_pend);
13361  }
13362  }
13363  lex_p = lex_pend;
13364 #ifdef RIPPER
13365  ripper_dispatch_scan_event(parser, tCOMMENT);
13366  fallthru = TRUE;
13367 #endif
13368  /* fall through */
13369  case '\n':
13370  if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT)) {
13371 #ifdef RIPPER
13372  if (!fallthru) {
13373  ripper_dispatch_scan_event(parser, tIGNORED_NL);
13374  }
13375  fallthru = FALSE;
13376 #endif
13377  goto retry;
13378  }
13379  while ((c = nextc())) {
13380  switch (c) {
13381  case ' ': case '\t': case '\f': case '\r':
13382  case '\13': /* '\v' */
13383  space_seen = 1;
13384  break;
13385  case '.': {
13386  if ((c = nextc()) != '.') {
13387  pushback(c);
13388  pushback('.');
13389  goto retry;
13390  }
13391  }
13392  default:
13393  --ruby_sourceline;
13395  case -1: /* EOF no decrement*/
13396  lex_goto_eol(parser);
13397 #ifdef RIPPER
13398  if (c != -1) {
13399  parser->tokp = lex_p;
13400  }
13401 #endif
13402  goto normal_newline;
13403  }
13404  }
13405  normal_newline:
13406  command_start = TRUE;
13407  lex_state = EXPR_BEG;
13408  return '\n';
13409 
13410  case '*':
13411  if ((c = nextc()) == '*') {
13412  if ((c = nextc()) == '=') {
13414  lex_state = EXPR_BEG;
13415  return tOP_ASGN;
13416  }
13417  pushback(c);
13418  if (IS_SPCARG(c)) {
13419  rb_warning0("`**' interpreted as argument prefix");
13420  c = tDSTAR;
13421  }
13422  else if (IS_BEG()) {
13423  c = tDSTAR;
13424  }
13425  else {
13426  warn_balanced("**", "argument prefix");
13427  c = tPOW;
13428  }
13429  }
13430  else {
13431  if (c == '=') {
13432  set_yylval_id('*');
13433  lex_state = EXPR_BEG;
13434  return tOP_ASGN;
13435  }
13436  pushback(c);
13437  if (IS_SPCARG(c)) {
13438  rb_warning0("`*' interpreted as argument prefix");
13439  c = tSTAR;
13440  }
13441  else if (IS_BEG()) {
13442  c = tSTAR;
13443  }
13444  else {
13445  warn_balanced("*", "argument prefix");
13446  c = '*';
13447  }
13448  }
13449  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13450  return c;
13451 
13452  case '!':
13453  c = nextc();
13454  if (IS_AFTER_OPERATOR()) {
13455  lex_state = EXPR_ARG;
13456  if (c == '@') {
13457  return '!';
13458  }
13459  }
13460  else {
13461  lex_state = EXPR_BEG;
13462  }
13463  if (c == '=') {
13464  return tNEQ;
13465  }
13466  if (c == '~') {
13467  return tNMATCH;
13468  }
13469  pushback(c);
13470  return '!';
13471 
13472  case '=':
13473  if (was_bol()) {
13474  /* skip embedded rd document */
13475  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13476 #ifdef RIPPER
13477  int first_p = TRUE;
13478 
13479  lex_goto_eol(parser);
13480  ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13481 #endif
13482  for (;;) {
13483  lex_goto_eol(parser);
13484 #ifdef RIPPER
13485  if (!first_p) {
13486  ripper_dispatch_scan_event(parser, tEMBDOC);
13487  }
13488  first_p = FALSE;
13489 #endif
13490  c = nextc();
13491  if (c == -1) {
13492  compile_error(PARSER_ARG "embedded document meets end of file");
13493  return 0;
13494  }
13495  if (c != '=') continue;
13496  if (strncmp(lex_p, "end", 3) == 0 &&
13497  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13498  break;
13499  }
13500  }
13501  lex_goto_eol(parser);
13502 #ifdef RIPPER
13503  ripper_dispatch_scan_event(parser, tEMBDOC_END);
13504 #endif
13505  goto retry;
13506  }
13507  }
13508 
13509  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13510  if ((c = nextc()) == '=') {
13511  if ((c = nextc()) == '=') {
13512  return tEQQ;
13513  }
13514  pushback(c);
13515  return tEQ;
13516  }
13517  if (c == '~') {
13518  return tMATCH;
13519  }
13520  else if (c == '>') {
13521  return tASSOC;
13522  }
13523  pushback(c);
13524  return '=';
13525 
13526  case '<':
13527  last_state = lex_state;
13528  c = nextc();
13529  if (c == '<' &&
13530  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13531  !IS_END() &&
13532  (!IS_ARG() || space_seen)) {
13533  int token = heredoc_identifier();
13534  if (token) return token;
13535  }
13536  if (IS_AFTER_OPERATOR()) {
13537  lex_state = EXPR_ARG;
13538  }
13539  else {
13540  if (IS_lex_state(EXPR_CLASS))
13541  command_start = TRUE;
13542  lex_state = EXPR_BEG;
13543  }
13544  if (c == '=') {
13545  if ((c = nextc()) == '>') {
13546  return tCMP;
13547  }
13548  pushback(c);
13549  return tLEQ;
13550  }
13551  if (c == '<') {
13552  if ((c = nextc()) == '=') {
13554  lex_state = EXPR_BEG;
13555  return tOP_ASGN;
13556  }
13557  pushback(c);
13558  warn_balanced("<<", "here document");
13559  return tLSHFT;
13560  }
13561  pushback(c);
13562  return '<';
13563 
13564  case '>':
13565  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13566  if ((c = nextc()) == '=') {
13567  return tGEQ;
13568  }
13569  if (c == '>') {
13570  if ((c = nextc()) == '=') {
13572  lex_state = EXPR_BEG;
13573  return tOP_ASGN;
13574  }
13575  pushback(c);
13576  return tRSHFT;
13577  }
13578  pushback(c);
13579  return '>';
13580 
13581  case '"':
13582  lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13583  return tSTRING_BEG;
13584 
13585  case '`':
13586  if (IS_lex_state(EXPR_FNAME)) {
13587  lex_state = EXPR_ENDFN;
13588  return c;
13589  }
13590  if (IS_lex_state(EXPR_DOT)) {
13591  if (cmd_state)
13592  lex_state = EXPR_CMDARG;
13593  else
13594  lex_state = EXPR_ARG;
13595  return c;
13596  }
13597  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13598  return tXSTRING_BEG;
13599 
13600  case '\'':
13601  lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13602  return tSTRING_BEG;
13603 
13604  case '?':
13605  if (IS_END()) {
13606  lex_state = EXPR_VALUE;
13607  return '?';
13608  }
13609  c = nextc();
13610  if (c == -1) {
13611  compile_error(PARSER_ARG "incomplete character syntax");
13612  return 0;
13613  }
13614  if (rb_enc_isspace(c, current_enc)) {
13615  if (!IS_ARG()) {
13616  int c2 = 0;
13617  switch (c) {
13618  case ' ':
13619  c2 = 's';
13620  break;
13621  case '\n':
13622  c2 = 'n';
13623  break;
13624  case '\t':
13625  c2 = 't';
13626  break;
13627  case '\v':
13628  c2 = 'v';
13629  break;
13630  case '\r':
13631  c2 = 'r';
13632  break;
13633  case '\f':
13634  c2 = 'f';
13635  break;
13636  }
13637  if (c2) {
13638  rb_warnI("invalid character syntax; use ?\\%c", c2);
13639  }
13640  }
13641  ternary:
13642  pushback(c);
13643  lex_state = EXPR_VALUE;
13644  return '?';
13645  }
13646  newtok();
13647  enc = current_enc;
13648  if (!parser_isascii()) {
13649  if (tokadd_mbchar(c) == -1) return 0;
13650  }
13651  else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13653  goto ternary;
13654  }
13655  else if (c == '\\') {
13656  if (peek('u')) {
13657  nextc();
13658  c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13659  if (0x80 <= c) {
13660  tokaddmbc(c, enc);
13661  }
13662  else {
13663  tokadd(c);
13664  }
13665  }
13666  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13667  nextc();
13668  if (tokadd_mbchar(c) == -1) return 0;
13669  }
13670  else {
13671  c = read_escape(0, &enc);
13672  tokadd(c);
13673  }
13674  }
13675  else {
13676  tokadd(c);
13677  }
13678  tokfix();
13679  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13680  lex_state = EXPR_END;
13681  return tCHAR;
13682 
13683  case '&':
13684  if ((c = nextc()) == '&') {
13685  lex_state = EXPR_BEG;
13686  if ((c = nextc()) == '=') {
13688  lex_state = EXPR_BEG;
13689  return tOP_ASGN;
13690  }
13691  pushback(c);
13692  return tANDOP;
13693  }
13694  else if (c == '=') {
13695  set_yylval_id('&');
13696  lex_state = EXPR_BEG;
13697  return tOP_ASGN;
13698  }
13699  pushback(c);
13700  if (IS_SPCARG(c)) {
13701  rb_warning0("`&' interpreted as argument prefix");
13702  c = tAMPER;
13703  }
13704  else if (IS_BEG()) {
13705  c = tAMPER;
13706  }
13707  else {
13708  warn_balanced("&", "argument prefix");
13709  c = '&';
13710  }
13711  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13712  return c;
13713 
13714  case '|':
13715  if ((c = nextc()) == '|') {
13716  lex_state = EXPR_BEG;
13717  if ((c = nextc()) == '=') {
13719  lex_state = EXPR_BEG;
13720  return tOP_ASGN;
13721  }
13722  pushback(c);
13723  return tOROP;
13724  }
13725  if (c == '=') {
13726  set_yylval_id('|');
13727  lex_state = EXPR_BEG;
13728  return tOP_ASGN;
13729  }
13730  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13731  pushback(c);
13732  return '|';
13733 
13734  case '+':
13735  c = nextc();
13736  if (IS_AFTER_OPERATOR()) {
13737  lex_state = EXPR_ARG;
13738  if (c == '@') {
13739  return tUPLUS;
13740  }
13741  pushback(c);
13742  return '+';
13743  }
13744  if (c == '=') {
13745  set_yylval_id('+');
13746  lex_state = EXPR_BEG;
13747  return tOP_ASGN;
13748  }
13749  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13750  lex_state = EXPR_BEG;
13751  pushback(c);
13752  if (c != -1 && ISDIGIT(c)) {
13753  c = '+';
13754  goto start_num;
13755  }
13756  return tUPLUS;
13757  }
13758  lex_state = EXPR_BEG;
13759  pushback(c);
13760  warn_balanced("+", "unary operator");
13761  return '+';
13762 
13763  case '-':
13764  c = nextc();
13765  if (IS_AFTER_OPERATOR()) {
13766  lex_state = EXPR_ARG;
13767  if (c == '@') {
13768  return tUMINUS;
13769  }
13770  pushback(c);
13771  return '-';
13772  }
13773  if (c == '=') {
13774  set_yylval_id('-');
13775  lex_state = EXPR_BEG;
13776  return tOP_ASGN;
13777  }
13778  if (c == '>') {
13779  lex_state = EXPR_ENDFN;
13780  return tLAMBDA;
13781  }
13782  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13783  lex_state = EXPR_BEG;
13784  pushback(c);
13785  if (c != -1 && ISDIGIT(c)) {
13786  return tUMINUS_NUM;
13787  }
13788  return tUMINUS;
13789  }
13790  lex_state = EXPR_BEG;
13791  pushback(c);
13792  warn_balanced("-", "unary operator");
13793  return '-';
13794 
13795  case '.':
13796  lex_state = EXPR_BEG;
13797  if ((c = nextc()) == '.') {
13798  if ((c = nextc()) == '.') {
13799  return tDOT3;
13800  }
13801  pushback(c);
13802  return tDOT2;
13803  }
13804  pushback(c);
13805  if (c != -1 && ISDIGIT(c)) {
13806  yyerror("no .<digit> floating literal anymore; put 0 before dot");
13807  }
13808  lex_state = EXPR_DOT;
13809  return '.';
13810 
13811  start_num:
13812  case '0': case '1': case '2': case '3': case '4':
13813  case '5': case '6': case '7': case '8': case '9':
13814  {
13815  int is_float, seen_point, seen_e, nondigit;
13816 
13817  is_float = seen_point = seen_e = nondigit = 0;
13818  lex_state = EXPR_END;
13819  newtok();
13820  if (c == '-' || c == '+') {
13821  tokadd(c);
13822  c = nextc();
13823  }
13824  if (c == '0') {
13825 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13826  int start = toklen();
13827  c = nextc();
13828  if (c == 'x' || c == 'X') {
13829  /* hexadecimal */
13830  c = nextc();
13831  if (c != -1 && ISXDIGIT(c)) {
13832  do {
13833  if (c == '_') {
13834  if (nondigit) break;
13835  nondigit = c;
13836  continue;
13837  }
13838  if (!ISXDIGIT(c)) break;
13839  nondigit = 0;
13840  tokadd(c);
13841  } while ((c = nextc()) != -1);
13842  }
13843  pushback(c);
13844  tokfix();
13845  if (toklen() == start) {
13846  no_digits();
13847  }
13848  else if (nondigit) goto trailing_uc;
13850  return tINTEGER;
13851  }
13852  if (c == 'b' || c == 'B') {
13853  /* binary */
13854  c = nextc();
13855  if (c == '0' || c == '1') {
13856  do {
13857  if (c == '_') {
13858  if (nondigit) break;
13859  nondigit = c;
13860  continue;
13861  }
13862  if (c != '0' && c != '1') break;
13863  nondigit = 0;
13864  tokadd(c);
13865  } while ((c = nextc()) != -1);
13866  }
13867  pushback(c);
13868  tokfix();
13869  if (toklen() == start) {
13870  no_digits();
13871  }
13872  else if (nondigit) goto trailing_uc;
13874  return tINTEGER;
13875  }
13876  if (c == 'd' || c == 'D') {
13877  /* decimal */
13878  c = nextc();
13879  if (c != -1 && ISDIGIT(c)) {
13880  do {
13881  if (c == '_') {
13882  if (nondigit) break;
13883  nondigit = c;
13884  continue;
13885  }
13886  if (!ISDIGIT(c)) break;
13887  nondigit = 0;
13888  tokadd(c);
13889  } while ((c = nextc()) != -1);
13890  }
13891  pushback(c);
13892  tokfix();
13893  if (toklen() == start) {
13894  no_digits();
13895  }
13896  else if (nondigit) goto trailing_uc;
13898  return tINTEGER;
13899  }
13900  if (c == '_') {
13901  /* 0_0 */
13902  goto octal_number;
13903  }
13904  if (c == 'o' || c == 'O') {
13905  /* prefixed octal */
13906  c = nextc();
13907  if (c == -1 || c == '_' || !ISDIGIT(c)) {
13908  no_digits();
13909  }
13910  }
13911  if (c >= '0' && c <= '7') {
13912  /* octal */
13913  octal_number:
13914  do {
13915  if (c == '_') {
13916  if (nondigit) break;
13917  nondigit = c;
13918  continue;
13919  }
13920  if (c < '0' || c > '9') break;
13921  if (c > '7') goto invalid_octal;
13922  nondigit = 0;
13923  tokadd(c);
13924  } while ((c = nextc()) != -1);
13925  if (toklen() > start) {
13926  pushback(c);
13927  tokfix();
13928  if (nondigit) goto trailing_uc;
13930  return tINTEGER;
13931  }
13932  if (nondigit) {
13933  pushback(c);
13934  goto trailing_uc;
13935  }
13936  }
13937  if (c > '7' && c <= '9') {
13938  invalid_octal:
13939  yyerror("Invalid octal digit");
13940  }
13941  else if (c == '.' || c == 'e' || c == 'E') {
13942  tokadd('0');
13943  }
13944  else {
13945  pushback(c);
13947  return tINTEGER;
13948  }
13949  }
13950 
13951  for (;;) {
13952  switch (c) {
13953  case '0': case '1': case '2': case '3': case '4':
13954  case '5': case '6': case '7': case '8': case '9':
13955  nondigit = 0;
13956  tokadd(c);
13957  break;
13958 
13959  case '.':
13960  if (nondigit) goto trailing_uc;
13961  if (seen_point || seen_e) {
13962  goto decode_num;
13963  }
13964  else {
13965  int c0 = nextc();
13966  if (c0 == -1 || !ISDIGIT(c0)) {
13967  pushback(c0);
13968  goto decode_num;
13969  }
13970  c = c0;
13971  }
13972  tokadd('.');
13973  tokadd(c);
13974  is_float++;
13975  seen_point++;
13976  nondigit = 0;
13977  break;
13978 
13979  case 'e':
13980  case 'E':
13981  if (nondigit) {
13982  pushback(c);
13983  c = nondigit;
13984  goto decode_num;
13985  }
13986  if (seen_e) {
13987  goto decode_num;
13988  }
13989  tokadd(c);
13990  seen_e++;
13991  is_float++;
13992  nondigit = c;
13993  c = nextc();
13994  if (c != '-' && c != '+') continue;
13995  tokadd(c);
13996  nondigit = c;
13997  break;
13998 
13999  case '_': /* `_' in number just ignored */
14000  if (nondigit) goto decode_num;
14001  nondigit = c;
14002  break;
14003 
14004  default:
14005  goto decode_num;
14006  }
14007  c = nextc();
14008  }
14009 
14010  decode_num:
14011  pushback(c);
14012  if (nondigit) {
14013  char tmp[30];
14014  trailing_uc:
14015  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14016  yyerror(tmp);
14017  }
14018  tokfix();
14019  if (is_float) {
14020  double d = strtod(tok(), 0);
14021  if (errno == ERANGE) {
14022  rb_warningS("Float %s out of range", tok());
14023  errno = 0;
14024  }
14026  return tFLOAT;
14027  }
14029  return tINTEGER;
14030  }
14031 
14032  case ')':
14033  case ']':
14034  paren_nest--;
14035  case '}':
14036  COND_LEXPOP();
14037  CMDARG_LEXPOP();
14038  if (c == ')')
14039  lex_state = EXPR_ENDFN;
14040  else
14041  lex_state = EXPR_ENDARG;
14042  if (c == '}') {
14043  if (!brace_nest--) c = tSTRING_DEND;
14044  }
14045  return c;
14046 
14047  case ':':
14048  c = nextc();
14049  if (c == ':') {
14050  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14051  lex_state = EXPR_BEG;
14052  return tCOLON3;
14053  }
14054  lex_state = EXPR_DOT;
14055  return tCOLON2;
14056  }
14057  if (IS_END() || ISSPACE(c)) {
14058  pushback(c);
14059  warn_balanced(":", "symbol literal");
14060  lex_state = EXPR_BEG;
14061  return ':';
14062  }
14063  switch (c) {
14064  case '\'':
14065  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14066  break;
14067  case '"':
14068  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14069  break;
14070  default:
14071  pushback(c);
14072  break;
14073  }
14074  lex_state = EXPR_FNAME;
14075  return tSYMBEG;
14076 
14077  case '/':
14078  if (IS_lex_state(EXPR_BEG_ANY)) {
14079  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14080  return tREGEXP_BEG;
14081  }
14082  if ((c = nextc()) == '=') {
14083  set_yylval_id('/');
14084  lex_state = EXPR_BEG;
14085  return tOP_ASGN;
14086  }
14087  pushback(c);
14088  if (IS_SPCARG(c)) {
14089  (void)arg_ambiguous();
14090  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14091  return tREGEXP_BEG;
14092  }
14093  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14094  warn_balanced("/", "regexp literal");
14095  return '/';
14096 
14097  case '^':
14098  if ((c = nextc()) == '=') {
14099  set_yylval_id('^');
14100  lex_state = EXPR_BEG;
14101  return tOP_ASGN;
14102  }
14103  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14104  pushback(c);
14105  return '^';
14106 
14107  case ';':
14108  lex_state = EXPR_BEG;
14109  command_start = TRUE;
14110  return ';';
14111 
14112  case ',':
14113  lex_state = EXPR_BEG;
14114  return ',';
14115 
14116  case '~':
14117  if (IS_AFTER_OPERATOR()) {
14118  if ((c = nextc()) != '@') {
14119  pushback(c);
14120  }
14121  lex_state = EXPR_ARG;
14122  }
14123  else {
14124  lex_state = EXPR_BEG;
14125  }
14126  return '~';
14127 
14128  case '(':
14129  if (IS_BEG()) {
14130  c = tLPAREN;
14131  }
14132  else if (IS_SPCARG(-1)) {
14133  c = tLPAREN_ARG;
14134  }
14135  paren_nest++;
14136  COND_PUSH(0);
14137  CMDARG_PUSH(0);
14138  lex_state = EXPR_BEG;
14139  return c;
14140 
14141  case '[':
14142  paren_nest++;
14143  if (IS_AFTER_OPERATOR()) {
14144  lex_state = EXPR_ARG;
14145  if ((c = nextc()) == ']') {
14146  if ((c = nextc()) == '=') {
14147  return tASET;
14148  }
14149  pushback(c);
14150  return tAREF;
14151  }
14152  pushback(c);
14153  return '[';
14154  }
14155  else if (IS_BEG()) {
14156  c = tLBRACK;
14157  }
14158  else if (IS_ARG() && space_seen) {
14159  c = tLBRACK;
14160  }
14161  lex_state = EXPR_BEG;
14162  COND_PUSH(0);
14163  CMDARG_PUSH(0);
14164  return c;
14165 
14166  case '{':
14167  ++brace_nest;
14168  if (lpar_beg && lpar_beg == paren_nest) {
14169  lex_state = EXPR_BEG;
14170  lpar_beg = 0;
14171  --paren_nest;
14172  COND_PUSH(0);
14173  CMDARG_PUSH(0);
14174  return tLAMBEG;
14175  }
14176  if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14177  c = '{'; /* block (primary) */
14178  else if (IS_lex_state(EXPR_ENDARG))
14179  c = tLBRACE_ARG; /* block (expr) */
14180  else
14181  c = tLBRACE; /* hash */
14182  COND_PUSH(0);
14183  CMDARG_PUSH(0);
14184  lex_state = EXPR_BEG;
14185  if (c != tLBRACE) command_start = TRUE;
14186  return c;
14187 
14188  case '\\':
14189  c = nextc();
14190  if (c == '\n') {
14191  space_seen = 1;
14192 #ifdef RIPPER
14193  ripper_dispatch_scan_event(parser, tSP);
14194 #endif
14195  goto retry; /* skip \\n */
14196  }
14197  pushback(c);
14198  return '\\';
14199 
14200  case '%':
14201  if (IS_lex_state(EXPR_BEG_ANY)) {
14202  int term;
14203  int paren;
14204 
14205  c = nextc();
14206  quotation:
14207  if (c == -1 || !ISALNUM(c)) {
14208  term = c;
14209  c = 'Q';
14210  }
14211  else {
14212  term = nextc();
14213  if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14214  yyerror("unknown type of %string");
14215  return 0;
14216  }
14217  }
14218  if (c == -1 || term == -1) {
14219  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14220  return 0;
14221  }
14222  paren = term;
14223  if (term == '(') term = ')';
14224  else if (term == '[') term = ']';
14225  else if (term == '{') term = '}';
14226  else if (term == '<') term = '>';
14227  else paren = 0;
14228 
14229  switch (c) {
14230  case 'Q':
14231  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14232  return tSTRING_BEG;
14233 
14234  case 'q':
14235  lex_strterm = NEW_STRTERM(str_squote, term, paren);
14236  return tSTRING_BEG;
14237 
14238  case 'W':
14239  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14240  do {c = nextc();} while (ISSPACE(c));
14241  pushback(c);
14242  return tWORDS_BEG;
14243 
14244  case 'w':
14245  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14246  do {c = nextc();} while (ISSPACE(c));
14247  pushback(c);
14248  return tQWORDS_BEG;
14249 
14250  case 'I':
14251  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14252  do {c = nextc();} while (ISSPACE(c));
14253  pushback(c);
14254  return tSYMBOLS_BEG;
14255 
14256  case 'i':
14257  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14258  do {c = nextc();} while (ISSPACE(c));
14259  pushback(c);
14260  return tQSYMBOLS_BEG;
14261 
14262  case 'x':
14263  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14264  return tXSTRING_BEG;
14265 
14266  case 'r':
14267  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14268  return tREGEXP_BEG;
14269 
14270  case 's':
14271  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14272  lex_state = EXPR_FNAME;
14273  return tSYMBEG;
14274 
14275  default:
14276  yyerror("unknown type of %string");
14277  return 0;
14278  }
14279  }
14280  if ((c = nextc()) == '=') {
14281  set_yylval_id('%');
14282  lex_state = EXPR_BEG;
14283  return tOP_ASGN;
14284  }
14285  if (IS_SPCARG(c)) {
14286  goto quotation;
14287  }
14288  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14289  pushback(c);
14290  warn_balanced("%%", "string literal");
14291  return '%';
14292 
14293  case '$':
14294  lex_state = EXPR_END;
14295  newtok();
14296  c = nextc();
14297  switch (c) {
14298  case '_': /* $_: last read line string */
14299  c = nextc();
14300  if (parser_is_identchar()) {
14301  tokadd('$');
14302  tokadd('_');
14303  break;
14304  }
14305  pushback(c);
14306  c = '_';
14307  /* fall through */
14308  case '~': /* $~: match-data */
14309  case '*': /* $*: argv */
14310  case '$': /* $$: pid */
14311  case '?': /* $?: last status */
14312  case '!': /* $!: error string */
14313  case '@': /* $@: error position */
14314  case '/': /* $/: input record separator */
14315  case '\\': /* $\: output record separator */
14316  case ';': /* $;: field separator */
14317  case ',': /* $,: output field separator */
14318  case '.': /* $.: last read line number */
14319  case '=': /* $=: ignorecase */
14320  case ':': /* $:: load path */
14321  case '<': /* $<: reading filename */
14322  case '>': /* $>: default output handle */
14323  case '\"': /* $": already loaded files */
14324  tokadd('$');
14325  tokadd(c);
14326  tokfix();
14328  return tGVAR;
14329 
14330  case '-':
14331  tokadd('$');
14332  tokadd(c);
14333  c = nextc();
14334  if (parser_is_identchar()) {
14335  if (tokadd_mbchar(c) == -1) return 0;
14336  }
14337  else {
14338  pushback(c);
14339  }
14340  gvar:
14341  tokfix();
14343  return tGVAR;
14344 
14345  case '&': /* $&: last match */
14346  case '`': /* $`: string before last match */
14347  case '\'': /* $': string after last match */
14348  case '+': /* $+: string matches last paren. */
14349  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14350  tokadd('$');
14351  tokadd(c);
14352  goto gvar;
14353  }
14355  return tBACK_REF;
14356 
14357  case '1': case '2': case '3':
14358  case '4': case '5': case '6':
14359  case '7': case '8': case '9':
14360  tokadd('$');
14361  do {
14362  tokadd(c);
14363  c = nextc();
14364  } while (c != -1 && ISDIGIT(c));
14365  pushback(c);
14366  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14367  tokfix();
14368  set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
14369  return tNTH_REF;
14370 
14371  default:
14372  if (!parser_is_identchar()) {
14373  pushback(c);
14374  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14375  return 0;
14376  }
14377  case '0':
14378  tokadd('$');
14379  }
14380  break;
14381 
14382  case '@':
14383  c = nextc();
14384  newtok();
14385  tokadd('@');
14386  if (c == '@') {
14387  tokadd('@');
14388  c = nextc();
14389  }
14390  if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14391  pushback(c);
14392  if (tokidx == 1) {
14393  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14394  }
14395  else {
14396  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14397  }
14398  return 0;
14399  }
14400  break;
14401 
14402  case '_':
14403  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14404  ruby__end__seen = 1;
14405  parser->eofp = Qtrue;
14406 #ifndef RIPPER
14407  return -1;
14408 #else
14409  lex_goto_eol(parser);
14410  ripper_dispatch_scan_event(parser, k__END__);
14411  return 0;
14412 #endif
14413  }
14414  newtok();
14415  break;
14416 
14417  default:
14418  if (!parser_is_identchar()) {
14419  compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14420  goto retry;
14421  }
14422 
14423  newtok();
14424  break;
14425  }
14426 
14427  mb = ENC_CODERANGE_7BIT;
14428  do {
14429  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14430  if (tokadd_mbchar(c) == -1) return 0;
14431  c = nextc();
14432  } while (parser_is_identchar());
14433  switch (tok()[0]) {
14434  case '@': case '$':
14435  pushback(c);
14436  break;
14437  default:
14438  if ((c == '!' || c == '?') && !peek('=')) {
14439  tokadd(c);
14440  }
14441  else {
14442  pushback(c);
14443  }
14444  }
14445  tokfix();
14446 
14447  {
14448  int result = 0;
14449 
14450  last_state = lex_state;
14451  switch (tok()[0]) {
14452  case '$':
14453  lex_state = EXPR_END;
14454  result = tGVAR;
14455  break;
14456  case '@':
14457  lex_state = EXPR_END;
14458  if (tok()[1] == '@')
14459  result = tCVAR;
14460  else
14461  result = tIVAR;
14462  break;
14463 
14464  default:
14465  if (toklast() == '!' || toklast() == '?') {
14466  result = tFID;
14467  }
14468  else {
14469  if (IS_lex_state(EXPR_FNAME)) {
14470  if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14471  (!peek('=') || (peek_n('>', 1)))) {
14472  result = tIDENTIFIER;
14473  tokadd(c);
14474  tokfix();
14475  }
14476  else {
14477  pushback(c);
14478  }
14479  }
14480  if (result == 0 && ISUPPER(tok()[0])) {
14481  result = tCONSTANT;
14482  }
14483  else {
14484  result = tIDENTIFIER;
14485  }
14486  }
14487 
14488  if (IS_LABEL_POSSIBLE()) {
14489  if (IS_LABEL_SUFFIX(0)) {
14490  lex_state = EXPR_BEG;
14491  nextc();
14493  return tLABEL;
14494  }
14495  }
14496  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14497  const struct kwtable *kw;
14498 
14499  /* See if it is a reserved word. */
14500  kw = rb_reserved_word(tok(), toklen());
14501  if (kw) {
14502  enum lex_state_e state = lex_state;
14503  lex_state = kw->state;
14504  if (state == EXPR_FNAME) {
14506  return kw->id[0];
14507  }
14508  if (lex_state == EXPR_BEG) {
14509  command_start = TRUE;
14510  }
14511  if (kw->id[0] == keyword_do) {
14512  if (lpar_beg && lpar_beg == paren_nest) {
14513  lpar_beg = 0;
14514  --paren_nest;
14515  return keyword_do_LAMBDA;
14516  }
14517  if (COND_P()) return keyword_do_cond;
14518  if (CMDARG_P() && state != EXPR_CMDARG)
14519  return keyword_do_block;
14520  if (state & (EXPR_BEG | EXPR_ENDARG))
14521  return keyword_do_block;
14522  return keyword_do;
14523  }
14524  if (state & (EXPR_BEG | EXPR_VALUE))
14525  return kw->id[0];
14526  else {
14527  if (kw->id[0] != kw->id[1])
14528  lex_state = EXPR_BEG;
14529  return kw->id[1];
14530  }
14531  }
14532  }
14533 
14534  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14535  if (cmd_state) {
14536  lex_state = EXPR_CMDARG;
14537  }
14538  else {
14539  lex_state = EXPR_ARG;
14540  }
14541  }
14542  else if (lex_state == EXPR_FNAME) {
14543  lex_state = EXPR_ENDFN;
14544  }
14545  else {
14546  lex_state = EXPR_END;
14547  }
14548  }
14549  {
14550  ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14551 
14552  set_yylval_name(ident);
14553  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14554  is_local_id(ident) && lvar_defined(ident)) {
14555  lex_state = EXPR_END;
14556  }
14557  }
14558  return result;
14559  }
14560 }
14561 
14562 #if YYPURE
14563 static int
14564 yylex(void *lval, void *p)
14565 #else
14566 yylex(void *p)
14567 #endif
14568 {
14569  struct parser_params *parser = (struct parser_params*)p;
14570  int t;
14571 
14572 #if YYPURE
14573  parser->parser_yylval = lval;
14574  parser->parser_yylval->val = Qundef;
14575 #endif
14576  t = parser_yylex(parser);
14577 #ifdef RIPPER
14578  if (!NIL_P(parser->delayed)) {
14579  ripper_dispatch_delayed_token(parser, t);
14580  return t;
14581  }
14582  if (t != 0)
14583  ripper_dispatch_scan_event(parser, t);
14584 #endif
14585 
14586  return t;
14587 }
14588 
14589 #ifndef RIPPER
14590 static NODE*
14591 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14592 {
14593  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14595  return n;
14596 }
14597 
14598 static enum node_type
14599 nodetype(NODE *node) /* for debug */
14600 {
14601  return (enum node_type)nd_type(node);
14602 }
14603 
14604 static int
14606 {
14607  return nd_line(node);
14608 }
14609 
14610 static NODE*
14612 {
14613  if (node) {
14614  node = remove_begin(node);
14615  node->flags |= NODE_FL_NEWLINE;
14616  }
14617  return node;
14618 }
14619 
14620 static void
14621 fixpos(NODE *node, NODE *orig)
14622 {
14623  if (!node) return;
14624  if (!orig) return;
14625  if (orig == (NODE*)1) return;
14626  nd_set_line(node, nd_line(orig));
14627 }
14628 
14629 static void
14630 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14631 {
14632  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14633 }
14634 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14635 
14636 static void
14637 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14638 {
14639  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14640 }
14641 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14642 
14643 static NODE*
14644 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14645 {
14646  NODE *end, *h = head, *nd;
14647 
14648  if (tail == 0) return head;
14649 
14650  if (h == 0) return tail;
14651  switch (nd_type(h)) {
14652  case NODE_LIT:
14653  case NODE_STR:
14654  case NODE_SELF:
14655  case NODE_TRUE:
14656  case NODE_FALSE:
14657  case NODE_NIL:
14658  parser_warning(h, "unused literal ignored");
14659  return tail;
14660  default:
14661  h = end = NEW_BLOCK(head);
14662  end->nd_end = end;
14663  fixpos(end, head);
14664  head = end;
14665  break;
14666  case NODE_BLOCK:
14667  end = h->nd_end;
14668  break;
14669  }
14670 
14671  nd = end->nd_head;
14672  switch (nd_type(nd)) {
14673  case NODE_RETURN:
14674  case NODE_BREAK:
14675  case NODE_NEXT:
14676  case NODE_REDO:
14677  case NODE_RETRY:
14678  if (RTEST(ruby_verbose)) {
14679  parser_warning(tail, "statement not reached");
14680  }
14681  break;
14682 
14683  default:
14684  break;
14685  }
14686 
14687  if (nd_type(tail) != NODE_BLOCK) {
14688  tail = NEW_BLOCK(tail);
14689  tail->nd_end = tail;
14690  }
14691  end->nd_next = tail;
14692  h->nd_end = tail->nd_end;
14693  return head;
14694 }
14695 
14696 /* append item to the list */
14697 static NODE*
14698 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14699 {
14700  NODE *last;
14701 
14702  if (list == 0) return NEW_LIST(item);
14703  if (list->nd_next) {
14704  last = list->nd_next->nd_end;
14705  }
14706  else {
14707  last = list;
14708  }
14709 
14710  list->nd_alen += 1;
14711  last->nd_next = NEW_LIST(item);
14712  list->nd_next->nd_end = last->nd_next;
14713  return list;
14714 }
14715 
14716 /* concat two lists */
14717 static NODE*
14718 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14719 {
14720  NODE *last;
14721 
14722  if (head->nd_next) {
14723  last = head->nd_next->nd_end;
14724  }
14725  else {
14726  last = head;
14727  }
14728 
14729  head->nd_alen += tail->nd_alen;
14730  last->nd_next = tail;
14731  if (tail->nd_next) {
14732  head->nd_next->nd_end = tail->nd_next->nd_end;
14733  }
14734  else {
14735  head->nd_next->nd_end = tail;
14736  }
14737 
14738  return head;
14739 }
14740 
14741 static int
14743 {
14744  if (NIL_P(tail)) return 1;
14745  if (!rb_enc_compatible(head, tail)) {
14746  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14747  rb_enc_name(rb_enc_get(head)),
14748  rb_enc_name(rb_enc_get(tail)));
14749  rb_str_resize(head, 0);
14750  rb_str_resize(tail, 0);
14751  return 0;
14752  }
14753  rb_str_buf_append(head, tail);
14754  return 1;
14755 }
14756 
14757 /* concat two string literals */
14758 static NODE *
14760 {
14761  enum node_type htype;
14762  NODE *headlast;
14763  VALUE lit;
14764 
14765  if (!head) return tail;
14766  if (!tail) return head;
14767 
14768  htype = nd_type(head);
14769  if (htype == NODE_EVSTR) {
14770  NODE *node = NEW_DSTR(Qnil);
14771  head = list_append(node, head);
14772  htype = NODE_DSTR;
14773  }
14774  switch (nd_type(tail)) {
14775  case NODE_STR:
14776  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14777  nd_type(headlast) == NODE_STR) {
14778  htype = NODE_STR;
14779  lit = headlast->nd_lit;
14780  }
14781  else {
14782  lit = head->nd_lit;
14783  }
14784  if (htype == NODE_STR) {
14785  if (!literal_concat0(parser, lit, tail->nd_lit)) {
14786  error:
14787  rb_gc_force_recycle((VALUE)head);
14788  rb_gc_force_recycle((VALUE)tail);
14789  return 0;
14790  }
14791  rb_gc_force_recycle((VALUE)tail);
14792  }
14793  else {
14794  list_append(head, tail);
14795  }
14796  break;
14797 
14798  case NODE_DSTR:
14799  if (htype == NODE_STR) {
14800  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14801  goto error;
14802  tail->nd_lit = head->nd_lit;
14803  rb_gc_force_recycle((VALUE)head);
14804  head = tail;
14805  }
14806  else if (NIL_P(tail->nd_lit)) {
14807  append:
14808  head->nd_alen += tail->nd_alen - 1;
14809  head->nd_next->nd_end->nd_next = tail->nd_next;
14810  head->nd_next->nd_end = tail->nd_next->nd_end;
14811  rb_gc_force_recycle((VALUE)tail);
14812  }
14813  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14814  nd_type(headlast) == NODE_STR) {
14815  lit = headlast->nd_lit;
14816  if (!literal_concat0(parser, lit, tail->nd_lit))
14817  goto error;
14818  tail->nd_lit = Qnil;
14819  goto append;
14820  }
14821  else {
14822  nd_set_type(tail, NODE_ARRAY);
14823  tail->nd_head = NEW_STR(tail->nd_lit);
14824  list_concat(head, tail);
14825  }
14826  break;
14827 
14828  case NODE_EVSTR:
14829  if (htype == NODE_STR) {
14830  nd_set_type(head, NODE_DSTR);
14831  head->nd_alen = 1;
14832  }
14833  list_append(head, tail);
14834  break;
14835  }
14836  return head;
14837 }
14838 
14839 static NODE *
14840 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14841 {
14842  if (nd_type(node) == NODE_EVSTR) {
14843  node = list_append(NEW_DSTR(Qnil), node);
14844  }
14845  return node;
14846 }
14847 
14848 static NODE *
14849 new_evstr_gen(struct parser_params *parser, NODE *node)
14850 {
14851  NODE *head = node;
14852 
14853  if (node) {
14854  switch (nd_type(node)) {
14855  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14856  return node;
14857  }
14858  }
14859  return NEW_EVSTR(head);
14860 }
14861 
14862 static NODE *
14863 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14864 {
14865  value_expr(recv);
14866  value_expr(arg1);
14867  return NEW_CALL(recv, id, NEW_LIST(arg1));
14868 }
14869 
14870 static NODE *
14871 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
14872 {
14873  value_expr(recv);
14874  return NEW_CALL(recv, id, 0);
14875 }
14876 
14877 static NODE*
14878 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14879 {
14880  value_expr(node1);
14881  value_expr(node2);
14882  if (node1) {
14883  switch (nd_type(node1)) {
14884  case NODE_DREGX:
14885  case NODE_DREGX_ONCE:
14886  return NEW_MATCH2(node1, node2);
14887 
14888  case NODE_LIT:
14889  if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
14890  return NEW_MATCH2(node1, node2);
14891  }
14892  }
14893  }
14894 
14895  if (node2) {
14896  switch (nd_type(node2)) {
14897  case NODE_DREGX:
14898  case NODE_DREGX_ONCE:
14899  return NEW_MATCH3(node2, node1);
14900 
14901  case NODE_LIT:
14902  if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
14903  return NEW_MATCH3(node2, node1);
14904  }
14905  }
14906  }
14907 
14908  return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
14909 }
14910 
14911 static NODE*
14912 gettable_gen(struct parser_params *parser, ID id)
14913 {
14914  switch (id) {
14915  case keyword_self:
14916  return NEW_SELF();
14917  case keyword_nil:
14918  return NEW_NIL();
14919  case keyword_true:
14920  return NEW_TRUE();
14921  case keyword_false:
14922  return NEW_FALSE();
14923  case keyword__FILE__:
14925  case keyword__LINE__:
14926  return NEW_LIT(INT2FIX(tokline));
14927  case keyword__ENCODING__:
14929  }
14930  switch (id_type(id)) {
14931  case ID_LOCAL:
14932  if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
14933  if (local_id(id)) return NEW_LVAR(id);
14934  /* method call without arguments */
14935  return NEW_VCALL(id);
14936  case ID_GLOBAL:
14937  return NEW_GVAR(id);
14938  case ID_INSTANCE:
14939  return NEW_IVAR(id);
14940  case ID_CONST:
14941  return NEW_CONST(id);
14942  case ID_CLASS:
14943  return NEW_CVAR(id);
14944  }
14945  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14946  return 0;
14947 }
14948 #else /* !RIPPER */
14949 static int
14950 id_is_var_gen(struct parser_params *parser, ID id)
14951 {
14952  if (is_notop_id(id)) {
14953  switch (id & ID_SCOPE_MASK) {
14954  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
14955  return 1;
14956  case ID_LOCAL:
14957  if (dyna_in_block() && dvar_defined(id)) return 1;
14958  if (local_id(id)) return 1;
14959  /* method call without arguments */
14960  return 0;
14961  }
14962  }
14963  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14964  return 0;
14965 }
14966 #endif /* !RIPPER */
14967 
14968 #if PARSER_DEBUG
14969 static const char *
14970 lex_state_name(enum lex_state_e state)
14971 {
14972  static const char names[][12] = {
14973  "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG",
14974  "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS",
14975  "EXPR_VALUE",
14976  };
14977 
14978  if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
14979  return names[ffs(state)];
14980  return NULL;
14981 }
14982 #endif
14983 
14984 #ifdef RIPPER
14985 static VALUE
14986 assignable_gen(struct parser_params *parser, VALUE lhs)
14987 #else
14988 static NODE*
14989 assignable_gen(struct parser_params *parser, ID id, NODE *val)
14990 #endif
14991 {
14992 #ifdef RIPPER
14993  ID id = get_id(lhs);
14994 # define assignable_result(x) get_value(lhs)
14995 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
14996 #else
14997 # define assignable_result(x) (x)
14998 #endif
14999  if (!id) return assignable_result(0);
15000  switch (id) {
15001  case keyword_self:
15002  yyerror("Can't change the value of self");
15003  goto error;
15004  case keyword_nil:
15005  yyerror("Can't assign to nil");
15006  goto error;
15007  case keyword_true:
15008  yyerror("Can't assign to true");
15009  goto error;
15010  case keyword_false:
15011  yyerror("Can't assign to false");
15012  goto error;
15013  case keyword__FILE__:
15014  yyerror("Can't assign to __FILE__");
15015  goto error;
15016  case keyword__LINE__:
15017  yyerror("Can't assign to __LINE__");
15018  goto error;
15019  case keyword__ENCODING__:
15020  yyerror("Can't assign to __ENCODING__");
15021  goto error;
15022  }
15023  switch (id_type(id)) {
15024  case ID_LOCAL:
15025  if (dyna_in_block()) {
15026  if (dvar_curr(id)) {
15027  return assignable_result(NEW_DASGN_CURR(id, val));
15028  }
15029  else if (dvar_defined(id)) {
15030  return assignable_result(NEW_DASGN(id, val));
15031  }
15032  else if (local_id(id)) {
15033  return assignable_result(NEW_LASGN(id, val));
15034  }
15035  else {
15036  dyna_var(id);
15037  return assignable_result(NEW_DASGN_CURR(id, val));
15038  }
15039  }
15040  else {
15041  if (!local_id(id)) {
15042  local_var(id);
15043  }
15044  return assignable_result(NEW_LASGN(id, val));
15045  }
15046  break;
15047  case ID_GLOBAL:
15048  return assignable_result(NEW_GASGN(id, val));
15049  case ID_INSTANCE:
15050  return assignable_result(NEW_IASGN(id, val));
15051  case ID_CONST:
15052  if (!in_def && !in_single)
15053  return assignable_result(NEW_CDECL(id, val, 0));
15054  yyerror("dynamic constant assignment");
15055  break;
15056  case ID_CLASS:
15057  return assignable_result(NEW_CVASGN(id, val));
15058  default:
15059  compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15060  }
15061  error:
15062  return assignable_result(0);
15063 #undef assignable_result
15064 #undef parser_yyerror
15065 }
15066 
15067 static int
15069 {
15070  VALUE s;
15071  if (name == idUScore) return 1;
15072  if (!is_local_id(name)) return 0;
15073  s = rb_id2str(name);
15074  if (!s) return 0;
15075  return RSTRING_PTR(s)[0] == '_';
15076 }
15077 
15078 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15079 
15080 static ID
15081 shadowing_lvar_gen(struct parser_params *parser, ID name)
15082 {
15083  if (is_private_local_id(name)) return name;
15084  if (dyna_in_block()) {
15085  if (dvar_curr(name)) {
15086  yyerror("duplicated argument name");
15087  }
15088  else if (dvar_defined_get(name) || local_id(name)) {
15089  rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15090  vtable_add(lvtbl->vars, name);
15091  if (lvtbl->used) {
15093  }
15094  }
15095  }
15096  else {
15097  if (local_id(name)) {
15098  yyerror("duplicated argument name");
15099  }
15100  }
15101  return name;
15102 }
15103 
15104 static void
15105 new_bv_gen(struct parser_params *parser, ID name)
15106 {
15107  if (!name) return;
15108  if (!is_local_id(name)) {
15109  compile_error(PARSER_ARG "invalid local variable - %s",
15110  rb_id2name(name));
15111  return;
15112  }
15113  shadowing_lvar(name);
15114  dyna_var(name);
15115 }
15116 
15117 #ifndef RIPPER
15118 static NODE *
15119 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15120 {
15121  if (recv && nd_type(recv) == NODE_SELF)
15122  recv = (NODE *)1;
15123  return NEW_ATTRASGN(recv, tASET, idx);
15124 }
15125 
15126 static void
15127 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15128 {
15129  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15130  compile_error(PARSER_ARG "both block arg and actual block given");
15131  }
15132 }
15133 
15134 static const char id_type_names[][9] = {
15135  "LOCAL",
15136  "INSTANCE",
15137  "", /* INSTANCE2 */
15138  "GLOBAL",
15139  "ATTRSET",
15140  "CONST",
15141  "CLASS",
15142  "JUNK",
15143 };
15144 
15145 ID
15147 {
15148  if (!is_notop_id(id)) {
15149  switch (id) {
15150  case tAREF: case tASET:
15151  return tASET; /* only exception */
15152  }
15153  rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
15154  }
15155  else {
15156  int scope = (int)(id & ID_SCOPE_MASK);
15157  switch (scope) {
15158  case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
15159  case ID_CONST: case ID_CLASS: case ID_JUNK:
15160  break;
15161  case ID_ATTRSET:
15162  return id;
15163  default:
15164  rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset",
15165  id_type_names[scope], ID2SYM(id));
15166 
15167  }
15168  }
15169  id &= ~ID_SCOPE_MASK;
15170  id |= ID_ATTRSET;
15171  return id;
15172 }
15173 
15174 static NODE *
15175 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15176 {
15177  if (recv && nd_type(recv) == NODE_SELF)
15178  recv = (NODE *)1;
15179  return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15180 }
15181 
15182 static void
15184 {
15185  switch (nd_type(node)) {
15186  case NODE_NTH_REF:
15187  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15188  break;
15189  case NODE_BACK_REF:
15190  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15191  break;
15192  }
15193 }
15194 
15195 static NODE *
15196 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15197 {
15198  if (!node2) return node1;
15199  switch (nd_type(node1)) {
15200  case NODE_BLOCK_PASS:
15201  if (node1->nd_head)
15202  node1->nd_head = arg_concat(node1->nd_head, node2);
15203  else
15204  node1->nd_head = NEW_LIST(node2);
15205  return node1;
15206  case NODE_ARGSPUSH:
15207  if (nd_type(node2) != NODE_ARRAY) break;
15208  node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15209  nd_set_type(node1, NODE_ARGSCAT);
15210  return node1;
15211  case NODE_ARGSCAT:
15212  if (nd_type(node2) != NODE_ARRAY ||
15213  nd_type(node1->nd_body) != NODE_ARRAY) break;
15214  node1->nd_body = list_concat(node1->nd_body, node2);
15215  return node1;
15216  }
15217  return NEW_ARGSCAT(node1, node2);
15218 }
15219 
15220 static NODE *
15221 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15222 {
15223  if (!node1) return NEW_LIST(node2);
15224  switch (nd_type(node1)) {
15225  case NODE_ARRAY:
15226  return list_append(node1, node2);
15227  case NODE_BLOCK_PASS:
15228  node1->nd_head = arg_append(node1->nd_head, node2);
15229  return node1;
15230  case NODE_ARGSPUSH:
15231  node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15232  nd_set_type(node1, NODE_ARGSCAT);
15233  return node1;
15234  }
15235  return NEW_ARGSPUSH(node1, node2);
15236 }
15237 
15238 static NODE *
15240 {
15241  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15242  if (nd_type(node) == NODE_ARRAY) return node;
15243  return 0;
15244 }
15245 
15246 static NODE *
15247 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15248 {
15249  if (!lhs) return 0;
15250 
15251  switch (nd_type(lhs)) {
15252  case NODE_GASGN:
15253  case NODE_IASGN:
15254  case NODE_IASGN2:
15255  case NODE_LASGN:
15256  case NODE_DASGN:
15257  case NODE_DASGN_CURR:
15258  case NODE_MASGN:
15259  case NODE_CDECL:
15260  case NODE_CVASGN:
15261  lhs->nd_value = rhs;
15262  break;
15263 
15264  case NODE_ATTRASGN:
15265  case NODE_CALL:
15266  lhs->nd_args = arg_append(lhs->nd_args, rhs);
15267  break;
15268 
15269  default:
15270  /* should not happen */
15271  break;
15272  }
15273 
15274  return lhs;
15275 }
15276 
15277 static int
15278 value_expr_gen(struct parser_params *parser, NODE *node)
15279 {
15280  int cond = 0;
15281 
15282  if (!node) {
15283  rb_warning0("empty expression");
15284  }
15285  while (node) {
15286  switch (nd_type(node)) {
15287  case NODE_DEFN:
15288  case NODE_DEFS:
15289  parser_warning(node, "void value expression");
15290  return FALSE;
15291 
15292  case NODE_RETURN:
15293  case NODE_BREAK:
15294  case NODE_NEXT:
15295  case NODE_REDO:
15296  case NODE_RETRY:
15297  if (!cond) yyerror("void value expression");
15298  /* or "control never reach"? */
15299  return FALSE;
15300 
15301  case NODE_BLOCK:
15302  while (node->nd_next) {
15303  node = node->nd_next;
15304  }
15305  node = node->nd_head;
15306  break;
15307 
15308  case NODE_BEGIN:
15309  node = node->nd_body;
15310  break;
15311 
15312  case NODE_IF:
15313  if (!node->nd_body) {
15314  node = node->nd_else;
15315  break;
15316  }
15317  else if (!node->nd_else) {
15318  node = node->nd_body;
15319  break;
15320  }
15321  if (!value_expr(node->nd_body)) return FALSE;
15322  node = node->nd_else;
15323  break;
15324 
15325  case NODE_AND:
15326  case NODE_OR:
15327  cond = 1;
15328  node = node->nd_2nd;
15329  break;
15330 
15331  default:
15332  return TRUE;
15333  }
15334  }
15335 
15336  return TRUE;
15337 }
15338 
15339 static void
15340 void_expr_gen(struct parser_params *parser, NODE *node)
15341 {
15342  const char *useless = 0;
15343 
15344  if (!RTEST(ruby_verbose)) return;
15345 
15346  if (!node) return;
15347  switch (nd_type(node)) {
15348  case NODE_CALL:
15349  switch (node->nd_mid) {
15350  case '+':
15351  case '-':
15352  case '*':
15353  case '/':
15354  case '%':
15355  case tPOW:
15356  case tUPLUS:
15357  case tUMINUS:
15358  case '|':
15359  case '^':
15360  case '&':
15361  case tCMP:
15362  case '>':
15363  case tGEQ:
15364  case '<':
15365  case tLEQ:
15366  case tEQ:
15367  case tNEQ:
15368  useless = rb_id2name(node->nd_mid);
15369  break;
15370  }
15371  break;
15372 
15373  case NODE_LVAR:
15374  case NODE_DVAR:
15375  case NODE_GVAR:
15376  case NODE_IVAR:
15377  case NODE_CVAR:
15378  case NODE_NTH_REF:
15379  case NODE_BACK_REF:
15380  useless = "a variable";
15381  break;
15382  case NODE_CONST:
15383  useless = "a constant";
15384  break;
15385  case NODE_LIT:
15386  case NODE_STR:
15387  case NODE_DSTR:
15388  case NODE_DREGX:
15389  case NODE_DREGX_ONCE:
15390  useless = "a literal";
15391  break;
15392  case NODE_COLON2:
15393  case NODE_COLON3:
15394  useless = "::";
15395  break;
15396  case NODE_DOT2:
15397  useless = "..";
15398  break;
15399  case NODE_DOT3:
15400  useless = "...";
15401  break;
15402  case NODE_SELF:
15403  useless = "self";
15404  break;
15405  case NODE_NIL:
15406  useless = "nil";
15407  break;
15408  case NODE_TRUE:
15409  useless = "true";
15410  break;
15411  case NODE_FALSE:
15412  useless = "false";
15413  break;
15414  case NODE_DEFINED:
15415  useless = "defined?";
15416  break;
15417  }
15418 
15419  if (useless) {
15420  int line = ruby_sourceline;
15421 
15422  ruby_sourceline = nd_line(node);
15423  rb_warnS("possibly useless use of %s in void context", useless);
15424  ruby_sourceline = line;
15425  }
15426 }
15427 
15428 static void
15429 void_stmts_gen(struct parser_params *parser, NODE *node)
15430 {
15431  if (!RTEST(ruby_verbose)) return;
15432  if (!node) return;
15433  if (nd_type(node) != NODE_BLOCK) return;
15434 
15435  for (;;) {
15436  if (!node->nd_next) return;
15437  void_expr0(node->nd_head);
15438  node = node->nd_next;
15439  }
15440 }
15441 
15442 static NODE *
15444 {
15445  NODE **n = &node, *n1 = node;
15446  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15447  *n = n1 = n1->nd_body;
15448  }
15449  return node;
15450 }
15451 
15452 static void
15453 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15454 {
15455  NODE *node = *body;
15456 
15457  if (!node) {
15458  *body = NEW_NIL();
15459  return;
15460  }
15461 #define subnodes(n1, n2) \
15462  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15463  (!node->n2) ? (body = &node->n1, 1) : \
15464  (reduce_nodes(&node->n1), body = &node->n2, 1))
15465 
15466  while (node) {
15467  int newline = (int)(node->flags & NODE_FL_NEWLINE);
15468  switch (nd_type(node)) {
15469  end:
15470  case NODE_NIL:
15471  *body = 0;
15472  return;
15473  case NODE_RETURN:
15474  *body = node = node->nd_stts;
15475  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15476  continue;
15477  case NODE_BEGIN:
15478  *body = node = node->nd_body;
15479  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15480  continue;
15481  case NODE_BLOCK:
15482  body = &node->nd_end->nd_head;
15483  break;
15484  case NODE_IF:
15485  if (subnodes(nd_body, nd_else)) break;
15486  return;
15487  case NODE_CASE:
15488  body = &node->nd_body;
15489  break;
15490  case NODE_WHEN:
15491  if (!subnodes(nd_body, nd_next)) goto end;
15492  break;
15493  case NODE_ENSURE:
15494  if (!subnodes(nd_head, nd_resq)) goto end;
15495  break;
15496  case NODE_RESCUE:
15497  if (node->nd_else) {
15498  body = &node->nd_resq;
15499  break;
15500  }
15501  if (!subnodes(nd_head, nd_resq)) goto end;
15502  break;
15503  default:
15504  return;
15505  }
15506  node = *body;
15507  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15508  }
15509 
15510 #undef subnodes
15511 }
15512 
15513 static int
15515 {
15516  if (!node) return 1;
15517  switch (nd_type(node)) {
15518  case NODE_HASH:
15519  if (!(node = node->nd_head)) break;
15520  case NODE_ARRAY:
15521  do {
15522  if (!is_static_content(node->nd_head)) return 0;
15523  } while ((node = node->nd_next) != 0);
15524  case NODE_LIT:
15525  case NODE_STR:
15526  case NODE_NIL:
15527  case NODE_TRUE:
15528  case NODE_FALSE:
15529  case NODE_ZARRAY:
15530  break;
15531  default:
15532  return 0;
15533  }
15534  return 1;
15535 }
15536 
15537 static int
15538 assign_in_cond(struct parser_params *parser, NODE *node)
15539 {
15540  switch (nd_type(node)) {
15541  case NODE_MASGN:
15542  yyerror("multiple assignment in conditional");
15543  return 1;
15544 
15545  case NODE_LASGN:
15546  case NODE_DASGN:
15547  case NODE_DASGN_CURR:
15548  case NODE_GASGN:
15549  case NODE_IASGN:
15550  break;
15551 
15552  default:
15553  return 0;
15554  }
15555 
15556  if (!node->nd_value) return 1;
15557  if (is_static_content(node->nd_value)) {
15558  /* reports always */
15559  parser_warn(node->nd_value, "found = in conditional, should be ==");
15560  }
15561  return 1;
15562 }
15563 
15564 static void
15565 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15566 {
15567  if (!e_option_supplied(parser)) parser_warn(node, str);
15568 }
15569 
15570 static void
15571 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15572 {
15573  if (!e_option_supplied(parser)) parser_warning(node, str);
15574 }
15575 
15576 static void
15577 fixup_nodes(NODE **rootnode)
15578 {
15579  NODE *node, *next, *head;
15580 
15581  for (node = *rootnode; node; node = next) {
15582  enum node_type type;
15583  VALUE val;
15584 
15585  next = node->nd_next;
15586  head = node->nd_head;
15587  rb_gc_force_recycle((VALUE)node);
15588  *rootnode = next;
15589  switch (type = nd_type(head)) {
15590  case NODE_DOT2:
15591  case NODE_DOT3:
15592  val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15593  type == NODE_DOT3);
15594  rb_gc_force_recycle((VALUE)head->nd_beg);
15595  rb_gc_force_recycle((VALUE)head->nd_end);
15596  nd_set_type(head, NODE_LIT);
15597  head->nd_lit = val;
15598  break;
15599  default:
15600  break;
15601  }
15602  }
15603 }
15604 
15605 static NODE *cond0(struct parser_params*,NODE*);
15606 
15607 static NODE*
15608 range_op(struct parser_params *parser, NODE *node)
15609 {
15610  enum node_type type;
15611 
15612  if (node == 0) return 0;
15613 
15614  type = nd_type(node);
15615  value_expr(node);
15616  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15617  warn_unless_e_option(parser, node, "integer literal in conditional range");
15618  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15619  }
15620  return cond0(parser, node);
15621 }
15622 
15623 static int
15625 {
15626  if (!node) return 1; /* same as NODE_NIL */
15627  switch (nd_type(node)) {
15628  case NODE_LIT:
15629  case NODE_STR:
15630  case NODE_DSTR:
15631  case NODE_EVSTR:
15632  case NODE_DREGX:
15633  case NODE_DREGX_ONCE:
15634  case NODE_DSYM:
15635  return 2;
15636  case NODE_TRUE:
15637  case NODE_FALSE:
15638  case NODE_NIL:
15639  return 1;
15640  }
15641  return 0;
15642 }
15643 
15644 static NODE*
15645 cond0(struct parser_params *parser, NODE *node)
15646 {
15647  if (node == 0) return 0;
15648  assign_in_cond(parser, node);
15649 
15650  switch (nd_type(node)) {
15651  case NODE_DSTR:
15652  case NODE_EVSTR:
15653  case NODE_STR:
15654  rb_warn0("string literal in condition");
15655  break;
15656 
15657  case NODE_DREGX:
15658  case NODE_DREGX_ONCE:
15659  warning_unless_e_option(parser, node, "regex literal in condition");
15660  return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15661 
15662  case NODE_AND:
15663  case NODE_OR:
15664  node->nd_1st = cond0(parser, node->nd_1st);
15665  node->nd_2nd = cond0(parser, node->nd_2nd);
15666  break;
15667 
15668  case NODE_DOT2:
15669  case NODE_DOT3:
15670  node->nd_beg = range_op(parser, node->nd_beg);
15671  node->nd_end = range_op(parser, node->nd_end);
15672  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15673  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15674  if (!e_option_supplied(parser)) {
15675  int b = literal_node(node->nd_beg);
15676  int e = literal_node(node->nd_end);
15677  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15678  parser_warn(node, "range literal in condition");
15679  }
15680  }
15681  break;
15682 
15683  case NODE_DSYM:
15684  parser_warning(node, "literal in condition");
15685  break;
15686 
15687  case NODE_LIT:
15688  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
15689  warn_unless_e_option(parser, node, "regex literal in condition");
15690  nd_set_type(node, NODE_MATCH);
15691  }
15692  else {
15693  parser_warning(node, "literal in condition");
15694  }
15695  default:
15696  break;
15697  }
15698  return node;
15699 }
15700 
15701 static NODE*
15702 cond_gen(struct parser_params *parser, NODE *node)
15703 {
15704  if (node == 0) return 0;
15705  return cond0(parser, node);
15706 }
15707 
15708 static NODE*
15709 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15710 {
15711  value_expr(left);
15712  if (left && (enum node_type)nd_type(left) == type) {
15713  NODE *node = left, *second;
15714  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15715  node = second;
15716  }
15717  node->nd_2nd = NEW_NODE(type, second, right, 0);
15718  return left;
15719  }
15720  return NEW_NODE(type, left, right, 0);
15721 }
15722 
15723 static void
15724 no_blockarg(struct parser_params *parser, NODE *node)
15725 {
15726  if (node && nd_type(node) == NODE_BLOCK_PASS) {
15727  compile_error(PARSER_ARG "block argument should not be given");
15728  }
15729 }
15730 
15731 static NODE *
15732 ret_args_gen(struct parser_params *parser, NODE *node)
15733 {
15734  if (node) {
15735  no_blockarg(parser, node);
15736  if (nd_type(node) == NODE_ARRAY) {
15737  if (node->nd_next == 0) {
15738  node = node->nd_head;
15739  }
15740  else {
15741  nd_set_type(node, NODE_VALUES);
15742  }
15743  }
15744  }
15745  return node;
15746 }
15747 
15748 static NODE *
15749 new_yield_gen(struct parser_params *parser, NODE *node)
15750 {
15751  if (node) no_blockarg(parser, node);
15752 
15753  return NEW_YIELD(node);
15754 }
15755 
15756 static NODE*
15758 {
15759  switch (TYPE(node->nd_lit)) {
15760  case T_FIXNUM:
15761  node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15762  break;
15763  case T_BIGNUM:
15764  node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15765  break;
15766  case T_FLOAT:
15767 #if USE_FLONUM
15768  if (FLONUM_P(node->nd_lit)) {
15769  node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
15770  }
15771  else {
15772  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15773  }
15774 #else
15775  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15776 #endif
15777  break;
15778  default:
15779  break;
15780  }
15781  return node;
15782 }
15783 
15784 static NODE *
15785 arg_blk_pass(NODE *node1, NODE *node2)
15786 {
15787  if (node2) {
15788  node2->nd_head = node1;
15789  return node2;
15790  }
15791  return node1;
15792 }
15793 
15794 
15795 static NODE*
15796 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
15797 {
15798  int saved_line = ruby_sourceline;
15799  struct rb_args_info *args = tail->nd_ainfo;
15800 
15801  args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0;
15802  args->pre_init = m ? m->nd_next : 0;
15803 
15804  args->post_args_num = p ? rb_long2int(p->nd_plen) : 0;
15805  args->post_init = p ? p->nd_next : 0;
15806  args->first_post_arg = p ? p->nd_pid : 0;
15807 
15808  args->rest_arg = r;
15809 
15810  args->opt_args = o;
15811 
15812  ruby_sourceline = saved_line;
15813 
15814  return tail;
15815 }
15816 
15817 static NODE*
15818 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
15819 {
15820  int saved_line = ruby_sourceline;
15821  struct rb_args_info *args;
15822  NODE *kw_rest_arg = 0;
15823  NODE *node;
15824 
15825  args = ALLOC(struct rb_args_info);
15826  MEMZERO(args, struct rb_args_info, 1);
15827  node = NEW_NODE(NODE_ARGS, 0, 0, args);
15828 
15829  args->block_arg = b;
15830  args->kw_args = k;
15831  if (k && !kr) kr = internal_id();
15832  if (kr) {
15833  arg_var(kr);
15834  kw_rest_arg = NEW_DVAR(kr);
15835  }
15836  args->kw_rest_arg = kw_rest_arg;
15837 
15838  ruby_sourceline = saved_line;
15839  return node;
15840 }
15841 
15842 static NODE*
15843 dsym_node_gen(struct parser_params *parser, NODE *node)
15844 {
15845  VALUE lit;
15846 
15847  if (!node) {
15848  return NEW_LIT(ID2SYM(idNULL));
15849  }
15850 
15851  switch (nd_type(node)) {
15852  case NODE_DSTR:
15853  nd_set_type(node, NODE_DSYM);
15854  break;
15855  case NODE_STR:
15856  lit = node->nd_lit;
15857  node->nd_lit = ID2SYM(rb_intern_str(lit));
15858  nd_set_type(node, NODE_LIT);
15859  break;
15860  default:
15861  node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
15862  break;
15863  }
15864  return node;
15865 }
15866 #endif /* !RIPPER */
15867 
15868 #ifndef RIPPER
15869 static NODE *
15870 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
15871 {
15872  NODE *asgn;
15873 
15874  if (lhs) {
15875  ID vid = lhs->nd_vid;
15876  if (op == tOROP) {
15877  lhs->nd_value = rhs;
15878  asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
15879  if (is_asgn_or_id(vid)) {
15880  asgn->nd_aid = vid;
15881  }
15882  }
15883  else if (op == tANDOP) {
15884  lhs->nd_value = rhs;
15885  asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
15886  }
15887  else {
15888  asgn = lhs;
15889  asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
15890  }
15891  }
15892  else {
15893  asgn = NEW_BEGIN(0);
15894  }
15895  return asgn;
15896 }
15897 
15898 static NODE *
15899 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
15900 {
15901  NODE *asgn;
15902 
15903  if (op == tOROP) {
15904  op = 0;
15905  }
15906  else if (op == tANDOP) {
15907  op = 1;
15908  }
15909  asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
15910  fixpos(asgn, lhs);
15911  return asgn;
15912 }
15913 
15914 static NODE *
15915 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
15916 {
15917  NODE *asgn;
15918 
15919  if (op == tOROP) {
15920  op = 0;
15921  }
15922  else if (op == tANDOP) {
15923  op = 1;
15924  }
15925  if (lhs) {
15926  asgn = NEW_OP_CDECL(lhs, op, rhs);
15927  }
15928  else {
15929  asgn = NEW_BEGIN(0);
15930  }
15931  fixpos(asgn, lhs);
15932  return asgn;
15933 }
15934 #else
15935 static VALUE
15936 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
15937 {
15938  return dispatch3(opassign, lhs, op, rhs);
15939 }
15940 
15941 static VALUE
15942 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
15943 {
15944  VALUE recv = dispatch3(field, lhs, type, attr);
15945  return dispatch3(opassign, recv, op, rhs);
15946 }
15947 #endif
15948 
15949 static void
15950 warn_unused_var(struct parser_params *parser, struct local_vars *local)
15951 {
15952  int i, cnt;
15953  ID *v, *u;
15954 
15955  if (!local->used) return;
15956  v = local->vars->tbl;
15957  u = local->used->tbl;
15958  cnt = local->used->pos;
15959  if (cnt != local->vars->pos) {
15960  rb_bug("local->used->pos != local->vars->pos");
15961  }
15962  for (i = 0; i < cnt; ++i) {
15963  if (!v[i] || (u[i] & LVAR_USED)) continue;
15964  if (is_private_local_id(v[i])) continue;
15965  rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
15966  }
15967 }
15968 
15969 static void
15970 local_push_gen(struct parser_params *parser, int inherit_dvars)
15971 {
15972  struct local_vars *local;
15973 
15974  local = ALLOC(struct local_vars);
15975  local->prev = lvtbl;
15976  local->args = vtable_alloc(0);
15977  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
15978  local->used = !(inherit_dvars &&
15980  RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
15981  local->cmdargs = cmdarg_stack;
15982  cmdarg_stack = 0;
15983  lvtbl = local;
15984 }
15985 
15986 static void
15988 {
15989  struct local_vars *local = lvtbl->prev;
15990  if (lvtbl->used) {
15991  warn_unused_var(parser, lvtbl);
15992  vtable_free(lvtbl->used);
15993  }
15994  vtable_free(lvtbl->args);
15995  vtable_free(lvtbl->vars);
15996  cmdarg_stack = lvtbl->cmdargs;
15997  xfree(lvtbl);
15998  lvtbl = local;
15999 }
16000 
16001 #ifndef RIPPER
16002 static ID*
16004 {
16005  int cnt_args = vtable_size(lvtbl->args);
16006  int cnt_vars = vtable_size(lvtbl->vars);
16007  int cnt = cnt_args + cnt_vars;
16008  int i, j;
16009  ID *buf;
16010 
16011  if (cnt <= 0) return 0;
16012  buf = ALLOC_N(ID, cnt + 1);
16013  MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args);
16014  /* remove IDs duplicated to warn shadowing */
16015  for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
16016  ID id = lvtbl->vars->tbl[i];
16017  if (!vtable_included(lvtbl->args, id)) {
16018  buf[j++] = id;
16019  }
16020  }
16021  if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1);
16022  buf[0] = cnt;
16023  return buf;
16024 }
16025 #endif
16026 
16027 static int
16028 arg_var_gen(struct parser_params *parser, ID id)
16029 {
16030  vtable_add(lvtbl->args, id);
16031  return vtable_size(lvtbl->args) - 1;
16032 }
16033 
16034 static int
16035 local_var_gen(struct parser_params *parser, ID id)
16036 {
16037  vtable_add(lvtbl->vars, id);
16038  if (lvtbl->used) {
16040  }
16041  return vtable_size(lvtbl->vars) - 1;
16042 }
16043 
16044 static int
16045 local_id_gen(struct parser_params *parser, ID id)
16046 {
16047  struct vtable *vars, *args, *used;
16048 
16049  vars = lvtbl->vars;
16050  args = lvtbl->args;
16051  used = lvtbl->used;
16052 
16053  while (vars && POINTER_P(vars->prev)) {
16054  vars = vars->prev;
16055  args = args->prev;
16056  if (used) used = used->prev;
16057  }
16058 
16059  if (vars && vars->prev == DVARS_INHERIT) {
16060  return rb_local_defined(id);
16061  }
16062  else if (vtable_included(args, id)) {
16063  return 1;
16064  }
16065  else {
16066  int i = vtable_included(vars, id);
16067  if (i && used) used->tbl[i-1] |= LVAR_USED;
16068  return i != 0;
16069  }
16070 }
16071 
16072 static const struct vtable *
16074 {
16075  lvtbl->args = vtable_alloc(lvtbl->args);
16076  lvtbl->vars = vtable_alloc(lvtbl->vars);
16077  if (lvtbl->used) {
16078  lvtbl->used = vtable_alloc(lvtbl->used);
16079  }
16080  return lvtbl->args;
16081 }
16082 
16083 static void
16084 dyna_pop_1(struct parser_params *parser)
16085 {
16086  struct vtable *tmp;
16087 
16088  if ((tmp = lvtbl->used) != 0) {
16089  warn_unused_var(parser, lvtbl);
16090  lvtbl->used = lvtbl->used->prev;
16091  vtable_free(tmp);
16092  }
16093  tmp = lvtbl->args;
16094  lvtbl->args = lvtbl->args->prev;
16095  vtable_free(tmp);
16096  tmp = lvtbl->vars;
16097  lvtbl->vars = lvtbl->vars->prev;
16098  vtable_free(tmp);
16099 }
16100 
16101 static void
16102 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16103 {
16104  while (lvtbl->args != lvargs) {
16105  dyna_pop_1(parser);
16106  if (!lvtbl->args) {
16107  struct local_vars *local = lvtbl->prev;
16108  xfree(lvtbl);
16109  lvtbl = local;
16110  }
16111  }
16112  dyna_pop_1(parser);
16113 }
16114 
16115 static int
16117 {
16118  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16119 }
16120 
16121 static int
16122 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16123 {
16124  struct vtable *vars, *args, *used;
16125  int i;
16126 
16127  args = lvtbl->args;
16128  vars = lvtbl->vars;
16129  used = lvtbl->used;
16130 
16131  while (POINTER_P(vars)) {
16132  if (vtable_included(args, id)) {
16133  return 1;
16134  }
16135  if ((i = vtable_included(vars, id)) != 0) {
16136  if (used) used->tbl[i-1] |= LVAR_USED;
16137  return 1;
16138  }
16139  args = args->prev;
16140  vars = vars->prev;
16141  if (get) used = 0;
16142  if (used) used = used->prev;
16143  }
16144 
16145  if (vars == DVARS_INHERIT) {
16146  return rb_dvar_defined(id);
16147  }
16148 
16149  return 0;
16150 }
16151 
16152 static int
16153 dvar_curr_gen(struct parser_params *parser, ID id)
16154 {
16155  return (vtable_included(lvtbl->args, id) ||
16156  vtable_included(lvtbl->vars, id));
16157 }
16158 
16159 #ifndef RIPPER
16160 static void
16162 {
16163  int c = RE_OPTION_ENCODING_IDX(options);
16164 
16165  if (c) {
16166  int opt, idx;
16167  rb_char_to_option_kcode(c, &opt, &idx);
16168  if (idx != ENCODING_GET(str) &&
16170  goto error;
16171  }
16172  ENCODING_SET(str, idx);
16173  }
16174  else if (RE_OPTION_ENCODING_NONE(options)) {
16175  if (!ENCODING_IS_ASCII8BIT(str) &&
16177  c = 'n';
16178  goto error;
16179  }
16181  }
16182  else if (current_enc == rb_usascii_encoding()) {
16184  /* raise in re.c */
16186  }
16187  else {
16189  }
16190  }
16191  return;
16192 
16193  error:
16195  "regexp encoding option '%c' differs from source encoding '%s'",
16196  c, rb_enc_name(rb_enc_get(str)));
16197 }
16198 
16199 static int
16201 {
16202  VALUE err;
16203  reg_fragment_setenc(str, options);
16204  err = rb_reg_check_preprocess(str);
16205  if (err != Qnil) {
16206  err = rb_obj_as_string(err);
16207  compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
16208  RB_GC_GUARD(err);
16209  return 0;
16210  }
16211  return 1;
16212 }
16213 
16214 typedef struct {
16215  struct parser_params* parser;
16216  rb_encoding *enc;
16217  NODE *succ_block;
16218  NODE *fail_block;
16219  int num;
16221 
16222 static int
16224  int back_num, int *back_refs, OnigRegex regex, void *arg0)
16225 {
16227  struct parser_params* parser = arg->parser;
16228  rb_encoding *enc = arg->enc;
16229  long len = name_end - name;
16230  const char *s = (const char *)name;
16231  ID var;
16232 
16233  arg->num++;
16234 
16235  if (arg->succ_block == 0) {
16236  arg->succ_block = NEW_BEGIN(0);
16237  arg->fail_block = NEW_BEGIN(0);
16238  }
16239 
16240  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16241  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16242  !rb_enc_symname2_p(s, len, enc)) {
16243  return ST_CONTINUE;
16244  }
16245  var = rb_intern3(s, len, enc);
16246  if (dvar_defined(var) || local_id(var)) {
16247  rb_warningS("named capture conflicts a local variable - %s",
16248  rb_id2name(var));
16249  }
16250  arg->succ_block = block_append(arg->succ_block,
16252  NEW_CALL(
16253  gettable(rb_intern("$~")),
16254  idAREF,
16255  NEW_LIST(NEW_LIT(ID2SYM(var))))
16256  )));
16257  arg->fail_block = block_append(arg->fail_block,
16259  return ST_CONTINUE;
16260 }
16261 
16262 static NODE *
16264 {
16266 
16267  arg.parser = parser;
16268  arg.enc = rb_enc_get(regexp);
16269  arg.succ_block = 0;
16270  arg.fail_block = 0;
16271  arg.num = 0;
16272  onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
16273 
16274  if (arg.num == 0)
16275  return match;
16276 
16277  return
16278  block_append(
16279  newline_node(match),
16280  NEW_IF(gettable(rb_intern("$~")),
16281  block_append(
16282  newline_node(arg.succ_block),
16283  newline_node(
16284  NEW_CALL(
16285  gettable(rb_intern("$~")),
16286  rb_intern("begin"),
16287  NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16288  block_append(
16289  newline_node(arg.fail_block),
16290  newline_node(
16291  NEW_LIT(Qnil)))));
16292 }
16293 
16294 static VALUE
16295 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16296 {
16297  VALUE re;
16298  VALUE err;
16299 
16300  reg_fragment_setenc(str, options);
16301  err = rb_errinfo();
16303  if (NIL_P(re)) {
16304  ID mesg = rb_intern("mesg");
16305  VALUE m = rb_attr_get(rb_errinfo(), mesg);
16306  rb_set_errinfo(err);
16307  if (!NIL_P(err)) {
16308  rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16309  }
16310  else {
16312  }
16313  return Qnil;
16314  }
16315  return re;
16316 }
16317 
16318 void
16320 {
16321 }
16322 
16323 NODE*
16325 {
16326  NODE *prelude = 0;
16327  NODE *scope = node;
16328  struct parser_params *parser;
16329 
16330  if (!node) return node;
16331 
16332  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16333 
16334  node = node->nd_body;
16335 
16336  if (nd_type(node) == NODE_PRELUDE) {
16337  prelude = node;
16338  node = node->nd_body;
16339  }
16340 
16341  node = block_append(node,
16342  NEW_FCALL(rb_intern("print"),
16343  NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16344  if (prelude) {
16345  prelude->nd_body = node;
16346  scope->nd_body = prelude;
16347  }
16348  else {
16349  scope->nd_body = node;
16350  }
16351 
16352  return scope;
16353 }
16354 
16355 NODE *
16356 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16357 {
16358  NODE *prelude = 0;
16359  NODE *scope = node;
16360  struct parser_params *parser;
16361 
16362  if (!node) return node;
16363 
16364  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16365 
16366  node = node->nd_body;
16367 
16368  if (nd_type(node) == NODE_PRELUDE) {
16369  prelude = node;
16370  node = node->nd_body;
16371  }
16372  if (split) {
16373  node = block_append(NEW_GASGN(rb_intern("$F"),
16374  NEW_CALL(NEW_GVAR(rb_intern("$_")),
16375  rb_intern("split"), 0)),
16376  node);
16377  }
16378  if (chop) {
16379  node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16380  rb_intern("chop!"), 0), node);
16381  }
16382 
16383  node = NEW_OPT_N(node);
16384 
16385  if (prelude) {
16386  prelude->nd_body = node;
16387  scope->nd_body = prelude;
16388  }
16389  else {
16390  scope->nd_body = node;
16391  }
16392 
16393  return scope;
16394 }
16395 
16396 static const struct {
16398  const char *name;
16399 } op_tbl[] = {
16400  {tDOT2, ".."},
16401  {tDOT3, "..."},
16402  {tPOW, "**"},
16403  {tDSTAR, "**"},
16404  {tUPLUS, "+@"},
16405  {tUMINUS, "-@"},
16406  {tCMP, "<=>"},
16407  {tGEQ, ">="},
16408  {tLEQ, "<="},
16409  {tEQ, "=="},
16410  {tEQQ, "==="},
16411  {tNEQ, "!="},
16412  {tMATCH, "=~"},
16413  {tNMATCH, "!~"},
16414  {tAREF, "[]"},
16415  {tASET, "[]="},
16416  {tLSHFT, "<<"},
16417  {tRSHFT, ">>"},
16418  {tCOLON2, "::"},
16419 };
16420 
16421 #define op_tbl_count numberof(op_tbl)
16422 
16423 #ifndef ENABLE_SELECTOR_NAMESPACE
16424 #define ENABLE_SELECTOR_NAMESPACE 0
16425 #endif
16426 
16427 static struct symbols {
16428  ID last_id;
16429  st_table *sym_id;
16430  st_table *id_str;
16431 #if ENABLE_SELECTOR_NAMESPACE
16432  st_table *ivar2_id;
16433  st_table *id_ivar2;
16434 #endif
16437 
16438 static const struct st_hash_type symhash = {
16440  rb_str_hash,
16441 };
16442 
16443 #if ENABLE_SELECTOR_NAMESPACE
16444 struct ivar2_key {
16445  ID id;
16446  VALUE klass;
16447 };
16448 
16449 static int
16450 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16451 {
16452  if (key1->id == key2->id && key1->klass == key2->klass) {
16453  return 0;
16454  }
16455  return 1;
16456 }
16457 
16458 static int
16459 ivar2_hash(struct ivar2_key *key)
16460 {
16461  return (key->id << 8) ^ (key->klass >> 2);
16462 }
16463 
16464 static const struct st_hash_type ivar2_hash_type = {
16465  ivar2_cmp,
16466  ivar2_hash,
16467 };
16468 #endif
16469 
16470 void
16472 {
16473  global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
16475 #if ENABLE_SELECTOR_NAMESPACE
16476  global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16477  global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16478 #endif
16479 
16480  (void)nodetype;
16481  (void)nodeline;
16482 #if PARSER_DEBUG
16483  (void)lex_state_name(-1);
16484 #endif
16485 
16486  Init_id();
16487 }
16488 
16489 void
16491 {
16495 }
16496 #endif /* !RIPPER */
16497 
16498 static ID
16500 {
16501  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16502  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16503  return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16504 }
16505 
16506 #ifndef RIPPER
16507 static int
16508 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16509 {
16510  int mb = 0;
16511 
16512  if (m >= e) return 0;
16513  if (is_global_name_punct(*m)) {
16514  ++m;
16515  }
16516  else if (*m == '-') {
16517  ++m;
16518  if (m < e && is_identchar(m, e, enc)) {
16519  if (!ISASCII(*m)) mb = 1;
16520  m += rb_enc_mbclen(m, e, enc);
16521  }
16522  }
16523  else {
16524  if (!rb_enc_isdigit(*m, enc)) return 0;
16525  do {
16526  if (!ISASCII(*m)) mb = 1;
16527  ++m;
16528  } while (m < e && rb_enc_isdigit(*m, enc));
16529  }
16530  return m == e ? mb + 1 : 0;
16531 }
16532 
16533 int
16534 rb_symname_p(const char *name)
16535 {
16536  return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16537 }
16538 
16539 int
16540 rb_enc_symname_p(const char *name, rb_encoding *enc)
16541 {
16542  return rb_enc_symname2_p(name, strlen(name), enc);
16543 }
16544 
16545 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
16546 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<(1<<ID_SCOPE_SHIFT)) & ~(1U<<ID_ATTRSET))
16547 
16548 static int
16549 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_atttset)
16550 {
16551  const char *m = name;
16552  const char *e = m + len;
16553  int type = ID_JUNK;
16554 
16555  if (!m || len <= 0) return -1;
16556  switch (*m) {
16557  case '\0':
16558  return -1;
16559 
16560  case '$':
16561  type = ID_GLOBAL;
16562  if (is_special_global_name(++m, e, enc)) return type;
16563  goto id;
16564 
16565  case '@':
16566  type = ID_INSTANCE;
16567  if (*++m == '@') {
16568  ++m;
16569  type = ID_CLASS;
16570  }
16571  goto id;
16572 
16573  case '<':
16574  switch (*++m) {
16575  case '<': ++m; break;
16576  case '=': if (*++m == '>') ++m; break;
16577  default: break;
16578  }
16579  break;
16580 
16581  case '>':
16582  switch (*++m) {
16583  case '>': case '=': ++m; break;
16584  }
16585  break;
16586 
16587  case '=':
16588  switch (*++m) {
16589  case '~': ++m; break;
16590  case '=': if (*++m == '=') ++m; break;
16591  default: return -1;
16592  }
16593  break;
16594 
16595  case '*':
16596  if (*++m == '*') ++m;
16597  break;
16598 
16599  case '+': case '-':
16600  if (*++m == '@') ++m;
16601  break;
16602 
16603  case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16604  ++m;
16605  break;
16606 
16607  case '[':
16608  if (*++m != ']') return -1;
16609  if (*++m == '=') ++m;
16610  break;
16611 
16612  case '!':
16613  if (len == 1) return ID_JUNK;
16614  switch (*++m) {
16615  case '=': case '~': ++m; break;
16616  default: return -1;
16617  }
16618  break;
16619 
16620  default:
16621  type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16622  id:
16623  if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16624  return -1;
16625  while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16626  if (m >= e) break;
16627  switch (*m) {
16628  case '!': case '?':
16629  if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16630  type = ID_JUNK;
16631  ++m;
16632  if (m + 1 < e || *m != '=') break;
16633  /* fall through */
16634  case '=':
16635  if (!(allowed_atttset & (1U << type))) return -1;
16636  type = ID_ATTRSET;
16637  ++m;
16638  break;
16639  }
16640  break;
16641  }
16642  return m == e ? type : -1;
16643 }
16644 
16645 int
16646 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16647 {
16648  return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
16649 }
16650 
16651 static int
16652 rb_str_symname_type(VALUE name, unsigned int allowed_atttset)
16653 {
16654  const char *ptr = StringValuePtr(name);
16655  long len = RSTRING_LEN(name);
16656  int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_atttset);
16657  RB_GC_GUARD(name);
16658  return type;
16659 }
16660 
16661 static ID
16662 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16663 {
16664  VALUE str = rb_enc_str_new(name, len, enc);
16665  return register_symid_str(id, str);
16666 }
16667 
16668 static ID
16670 {
16671  OBJ_FREEZE(str);
16674  return id;
16675 }
16676 
16677 static int
16679 {
16680  if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
16681  switch (rb_enc_str_coderange(str)) {
16682  case ENC_CODERANGE_BROKEN:
16683  rb_raise(rb_eEncodingError, "invalid encoding symbol");
16684  case ENC_CODERANGE_7BIT:
16685  return TRUE;
16686  }
16687  return FALSE;
16688 }
16689 
16690 /*
16691  * _str_ itself will be registered at the global symbol table. _str_
16692  * can be modified before the registration, since the encoding will be
16693  * set to ASCII-8BIT if it is a special global name.
16694  */
16695 static ID intern_str(VALUE str);
16696 
16697 ID
16698 rb_intern3(const char *name, long len, rb_encoding *enc)
16699 {
16700  VALUE str;
16701  st_data_t data;
16702  struct RString fake_str;
16703  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
16704  fake_str.basic.klass = rb_cString;
16705  fake_str.as.heap.len = len;
16706  fake_str.as.heap.ptr = (char *)name;
16707  fake_str.as.heap.aux.capa = len;
16708  str = (VALUE)&fake_str;
16709  rb_enc_associate(str, enc);
16710  OBJ_FREEZE(str);
16711 
16712  if (st_lookup(global_symbols.sym_id, str, &data))
16713  return (ID)data;
16714 
16715  str = rb_enc_str_new(name, len, enc); /* make true string */
16716  return intern_str(str);
16717 }
16718 
16719 static ID
16721 {
16722  const char *name, *m, *e;
16723  long len, last;
16724  rb_encoding *enc, *symenc;
16725  unsigned char c;
16726  ID id;
16727  int mb;
16728 
16729  RSTRING_GETMEM(str, name, len);
16730  m = name;
16731  e = m + len;
16732  enc = rb_enc_get(str);
16733  symenc = enc;
16734 
16735  if (!len || (rb_cString && !rb_enc_asciicompat(enc))) {
16736  junk:
16737  id = ID_JUNK;
16738  goto new_id;
16739  }
16740  last = len-1;
16741  id = 0;
16742  switch (*m) {
16743  case '$':
16744  if (len < 2) goto junk;
16745  id |= ID_GLOBAL;
16746  if ((mb = is_special_global_name(++m, e, enc)) != 0) {
16747  if (!--mb) symenc = rb_usascii_encoding();
16748  goto new_id;
16749  }
16750  break;
16751  case '@':
16752  if (m[1] == '@') {
16753  if (len < 3) goto junk;
16754  m++;
16755  id |= ID_CLASS;
16756  }
16757  else {
16758  if (len < 2) goto junk;
16759  id |= ID_INSTANCE;
16760  }
16761  m++;
16762  break;
16763  default:
16764  c = m[0];
16765  if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
16766  /* operators */
16767  int i;
16768 
16769  if (len == 1) {
16770  id = c;
16771  goto id_register;
16772  }
16773  for (i = 0; i < op_tbl_count; i++) {
16774  if (*op_tbl[i].name == *m &&
16775  strcmp(op_tbl[i].name, m) == 0) {
16776  id = op_tbl[i].token;
16777  goto id_register;
16778  }
16779  }
16780  }
16781  break;
16782  }
16783  if (name[last] == '=') {
16784  /* attribute assignment */
16785  if (last > 1 && name[last-1] == '=')
16786  goto junk;
16787  id = rb_intern3(name, last, enc);
16788  if (id > tLAST_OP_ID && !is_attrset_id(id)) {
16789  enc = rb_enc_get(rb_id2str(id));
16790  id = rb_id_attrset(id);
16791  goto id_register;
16792  }
16793  id = ID_ATTRSET;
16794  }
16795  else if (id == 0) {
16796  if (rb_enc_isupper(m[0], enc)) {
16797  id = ID_CONST;
16798  }
16799  else {
16800  id = ID_LOCAL;
16801  }
16802  }
16803  if (!rb_enc_isdigit(*m, enc)) {
16804  while (m <= name + last && is_identchar(m, e, enc)) {
16805  if (ISASCII(*m)) {
16806  m++;
16807  }
16808  else {
16809  m += rb_enc_mbclen(m, e, enc);
16810  }
16811  }
16812  }
16813  if (id != ID_ATTRSET && m - name < len) id = ID_JUNK;
16814  if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
16815  new_id:
16816  if (symenc != enc) rb_enc_associate(str, symenc);
16818  if (len > 20) {
16819  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
16820  name);
16821  }
16822  else {
16823  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
16824  (int)len, name);
16825  }
16826  }
16828  id_register:
16829  return register_symid_str(id, str);
16830 }
16831 
16832 ID
16833 rb_intern2(const char *name, long len)
16834 {
16835  return rb_intern3(name, len, rb_usascii_encoding());
16836 }
16837 
16838 #undef rb_intern
16839 ID
16840 rb_intern(const char *name)
16841 {
16842  return rb_intern2(name, strlen(name));
16843 }
16844 
16845 ID
16847 {
16848  st_data_t id;
16849 
16850  if (st_lookup(global_symbols.sym_id, str, &id))
16851  return (ID)id;
16852  return intern_str(rb_str_dup(str));
16853 }
16854 
16855 VALUE
16857 {
16858  st_data_t data;
16859 
16860  if (id < tLAST_TOKEN) {
16861  int i = 0;
16862 
16863  if (id < INT_MAX && rb_ispunct((int)id)) {
16864  VALUE str = global_symbols.op_sym[i = (int)id];
16865  if (!str) {
16866  char name[2];
16867  name[0] = (char)id;
16868  name[1] = 0;
16869  str = rb_usascii_str_new(name, 1);
16870  OBJ_FREEZE(str);
16871  global_symbols.op_sym[i] = str;
16872  }
16873  return str;
16874  }
16875  for (i = 0; i < op_tbl_count; i++) {
16876  if (op_tbl[i].token == id) {
16877  VALUE str = global_symbols.op_sym[i];
16878  if (!str) {
16879  str = rb_usascii_str_new2(op_tbl[i].name);
16880  OBJ_FREEZE(str);
16881  global_symbols.op_sym[i] = str;
16882  }
16883  return str;
16884  }
16885  }
16886  }
16887 
16888  if (st_lookup(global_symbols.id_str, id, &data)) {
16889  VALUE str = (VALUE)data;
16890  if (RBASIC(str)->klass == 0)
16891  RBASIC(str)->klass = rb_cString;
16892  return str;
16893  }
16894 
16895  if (is_attrset_id(id)) {
16896  ID id_stem = (id & ~ID_SCOPE_MASK);
16897  VALUE str;
16898 
16899  do {
16900  if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break;
16901  if (!!(str = rb_id2str(id_stem | ID_CONST))) break;
16902  if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break;
16903  if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break;
16904  if (!!(str = rb_id2str(id_stem | ID_CLASS))) break;
16905  if (!!(str = rb_id2str(id_stem | ID_JUNK))) break;
16906  return 0;
16907  } while (0);
16908  str = rb_str_dup(str);
16909  rb_str_cat(str, "=", 1);
16910  register_symid_str(id, str);
16911  if (st_lookup(global_symbols.id_str, id, &data)) {
16912  VALUE str = (VALUE)data;
16913  if (RBASIC(str)->klass == 0)
16914  RBASIC(str)->klass = rb_cString;
16915  return str;
16916  }
16917  }
16918  return 0;
16919 }
16920 
16921 const char *
16923 {
16924  VALUE str = rb_id2str(id);
16925 
16926  if (!str) return 0;
16927  return RSTRING_PTR(str);
16928 }
16929 
16930 static int
16932 {
16933  rb_ary_push(ary, ID2SYM(value));
16934  return ST_CONTINUE;
16935 }
16936 
16937 /*
16938  * call-seq:
16939  * Symbol.all_symbols => array
16940  *
16941  * Returns an array of all the symbols currently in Ruby's symbol
16942  * table.
16943  *
16944  * Symbol.all_symbols.size #=> 903
16945  * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
16946  * :chown, :EOFError, :$;, :String,
16947  * :LOCK_SH, :"setuid?", :$<,
16948  * :default_proc, :compact, :extend,
16949  * :Tms, :getwd, :$=, :ThreadGroup,
16950  * :wait2, :$>]
16951  */
16952 
16953 VALUE
16955 {
16957 
16959  return ary;
16960 }
16961 
16962 int
16964 {
16965  return is_const_id(id);
16966 }
16967 
16968 int
16970 {
16971  return is_class_id(id);
16972 }
16973 
16974 int
16976 {
16977  return is_global_id(id);
16978 }
16979 
16980 int
16982 {
16983  return is_instance_id(id);
16984 }
16985 
16986 int
16988 {
16989  return is_attrset_id(id);
16990 }
16991 
16992 int
16994 {
16995  return is_local_id(id);
16996 }
16997 
16998 int
17000 {
17001  return is_junk_id(id);
17002 }
17003 
17015 ID
17016 rb_check_id(volatile VALUE *namep)
17017 {
17018  st_data_t id;
17019  VALUE tmp;
17020  VALUE name = *namep;
17021 
17022  if (SYMBOL_P(name)) {
17023  return SYM2ID(name);
17024  }
17025  else if (!RB_TYPE_P(name, T_STRING)) {
17026  tmp = rb_check_string_type(name);
17027  if (NIL_P(tmp)) {
17028  tmp = rb_inspect(name);
17029  rb_raise(rb_eTypeError, "%s is not a symbol",
17030  RSTRING_PTR(tmp));
17031  }
17032  name = tmp;
17033  *namep = name;
17034  }
17035 
17036  sym_check_asciionly(name);
17037 
17038  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17039  return (ID)id;
17040 
17041  if (rb_is_attrset_name(name)) {
17042  struct RString fake_str;
17043  const VALUE localname = (VALUE)&fake_str;
17044  /* make local name by chopping '=' */
17045  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17046  fake_str.basic.klass = rb_cString;
17047  fake_str.as.heap.len = RSTRING_LEN(name) - 1;
17048  fake_str.as.heap.ptr = RSTRING_PTR(name);
17049  fake_str.as.heap.aux.capa = fake_str.as.heap.len;
17050  rb_enc_copy(localname, name);
17051  OBJ_FREEZE(localname);
17052 
17053  if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17054  return rb_id_attrset((ID)id);
17055  }
17056  RB_GC_GUARD(name);
17057  }
17058 
17059  return (ID)0;
17060 }
17061 
17062 ID
17063 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
17064 {
17065  st_data_t id;
17066  struct RString fake_str;
17067  const VALUE name = (VALUE)&fake_str;
17068  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17069  fake_str.basic.klass = rb_cString;
17070  fake_str.as.heap.len = len;
17071  fake_str.as.heap.ptr = (char *)ptr;
17072  fake_str.as.heap.aux.capa = len;
17073  rb_enc_associate(name, enc);
17074 
17075  sym_check_asciionly(name);
17076 
17077  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17078  return (ID)id;
17079 
17080  if (rb_is_attrset_name(name)) {
17081  fake_str.as.heap.len = len - 1;
17082  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
17083  return rb_id_attrset((ID)id);
17084  }
17085  }
17086 
17087  return (ID)0;
17088 }
17089 
17090 int
17092 {
17093  return rb_str_symname_type(name, 0) == ID_CONST;
17094 }
17095 
17096 int
17098 {
17099  return rb_str_symname_type(name, 0) == ID_CLASS;
17100 }
17101 
17102 int
17104 {
17105  return rb_str_symname_type(name, 0) == ID_GLOBAL;
17106 }
17107 
17108 int
17110 {
17111  return rb_str_symname_type(name, 0) == ID_INSTANCE;
17112 }
17113 
17114 int
17116 {
17118 }
17119 
17120 int
17122 {
17123  return rb_str_symname_type(name, 0) == ID_LOCAL;
17124 }
17125 
17126 int
17128 {
17129  switch (rb_str_symname_type(name, 0)) {
17130  case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17131  return TRUE;
17132  }
17133  return FALSE;
17134 }
17135 
17136 int
17138 {
17139  return rb_str_symname_type(name, IDSET_ATTRSET_FOR_SYNTAX) == -1;
17140 }
17141 
17142 #endif /* !RIPPER */
17143 
17144 static void
17146 {
17147  parser->eofp = Qfalse;
17148 
17149  parser->parser_lex_strterm = 0;
17150  parser->parser_cond_stack = 0;
17151  parser->parser_cmdarg_stack = 0;
17152  parser->parser_class_nest = 0;
17153  parser->parser_paren_nest = 0;
17154  parser->parser_lpar_beg = 0;
17155  parser->parser_brace_nest = 0;
17156  parser->parser_in_single = 0;
17157  parser->parser_in_def = 0;
17158  parser->parser_in_defined = 0;
17159  parser->parser_compile_for_eval = 0;
17160  parser->parser_cur_mid = 0;
17161  parser->parser_tokenbuf = NULL;
17162  parser->parser_tokidx = 0;
17163  parser->parser_toksiz = 0;
17164  parser->parser_heredoc_end = 0;
17165  parser->parser_command_start = TRUE;
17166  parser->parser_deferred_nodes = 0;
17167  parser->parser_lex_pbeg = 0;
17168  parser->parser_lex_p = 0;
17169  parser->parser_lex_pend = 0;
17170  parser->parser_lvtbl = 0;
17171  parser->parser_ruby__end__seen = 0;
17172  parser->parser_ruby_sourcefile = 0;
17174 #ifndef RIPPER
17175  parser->is_ripper = 0;
17176  parser->parser_eval_tree_begin = 0;
17177  parser->parser_eval_tree = 0;
17178 #else
17179  parser->is_ripper = 1;
17180  parser->delayed = Qnil;
17181 
17182  parser->result = Qnil;
17183  parser->parsing_thread = Qnil;
17184  parser->toplevel_p = TRUE;
17185 #endif
17186 #ifdef YYMALLOC
17187  parser->heap = NULL;
17188 #endif
17189  parser->enc = rb_utf8_encoding();
17190 }
17191 
17192 #ifdef RIPPER
17193 #define parser_mark ripper_parser_mark
17194 #define parser_free ripper_parser_free
17195 #endif
17196 
17197 static void
17199 {
17200  struct parser_params *p = (struct parser_params*)ptr;
17201 
17208 #ifndef RIPPER
17211  rb_gc_mark(p->debug_lines);
17212 #else
17213  rb_gc_mark(p->delayed);
17214  rb_gc_mark(p->value);
17215  rb_gc_mark(p->result);
17216  rb_gc_mark(p->parsing_thread);
17217 #endif
17218 #ifdef YYMALLOC
17219  rb_gc_mark((VALUE)p->heap);
17220 #endif
17221 }
17222 
17223 static void
17224 parser_free(void *ptr)
17225 {
17226  struct parser_params *p = (struct parser_params*)ptr;
17227  struct local_vars *local, *prev;
17228 
17229  if (p->parser_tokenbuf) {
17230  xfree(p->parser_tokenbuf);
17231  }
17232  for (local = p->parser_lvtbl; local; local = prev) {
17233  if (local->vars) xfree(local->vars);
17234  prev = local->prev;
17235  xfree(local);
17236  }
17237  xfree(p);
17238 }
17239 
17240 static size_t
17241 parser_memsize(const void *ptr)
17242 {
17243  struct parser_params *p = (struct parser_params*)ptr;
17244  struct local_vars *local;
17245  size_t size = sizeof(*p);
17246 
17247  if (!ptr) return 0;
17248  size += p->parser_toksiz;
17249  for (local = p->parser_lvtbl; local; local = local->prev) {
17250  size += sizeof(*local);
17251  if (local->vars) size += local->vars->capa * sizeof(ID);
17252  }
17253  return size;
17254 }
17255 
17256 static
17257 #ifndef RIPPER
17258 const
17259 #endif
17260 rb_data_type_t parser_data_type = {
17261  "parser",
17262  {
17263  parser_mark,
17264  parser_free,
17266  },
17267 };
17268 
17269 #ifndef RIPPER
17270 #undef rb_reserved_word
17271 
17272 const struct kwtable *
17273 rb_reserved_word(const char *str, unsigned int len)
17274 {
17275  return reserved_word(str, len);
17276 }
17277 
17278 static struct parser_params *
17280 {
17281  struct parser_params *p;
17282 
17283  p = ALLOC_N(struct parser_params, 1);
17284  MEMZERO(p, struct parser_params, 1);
17285  parser_initialize(p);
17286  return p;
17287 }
17288 
17289 VALUE
17291 {
17292  struct parser_params *p = parser_new();
17293 
17294  return TypedData_Wrap_Struct(0, &parser_data_type, p);
17295 }
17296 
17297 /*
17298  * call-seq:
17299  * ripper#end_seen? -> Boolean
17300  *
17301  * Return true if parsed source ended by +\_\_END\_\_+.
17302  */
17303 VALUE
17305 {
17306  struct parser_params *parser;
17307 
17308  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17309  return ruby__end__seen ? Qtrue : Qfalse;
17310 }
17311 
17312 /*
17313  * call-seq:
17314  * ripper#encoding -> encoding
17315  *
17316  * Return encoding of the source.
17317  */
17318 VALUE
17320 {
17321  struct parser_params *parser;
17322 
17323  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17325 }
17326 
17327 /*
17328  * call-seq:
17329  * ripper.yydebug -> true or false
17330  *
17331  * Get yydebug.
17332  */
17333 VALUE
17335 {
17336  struct parser_params *parser;
17337 
17338  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17339  return yydebug ? Qtrue : Qfalse;
17340 }
17341 
17342 /*
17343  * call-seq:
17344  * ripper.yydebug = flag
17345  *
17346  * Set yydebug.
17347  */
17348 VALUE
17350 {
17351  struct parser_params *parser;
17352 
17353  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17354  yydebug = RTEST(flag);
17355  return flag;
17356 }
17357 
17358 #ifdef YYMALLOC
17359 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17360 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17361 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17362  (n)->u3.cnt = (c), (p))
17363 
17364 void *
17365 rb_parser_malloc(struct parser_params *parser, size_t size)
17366 {
17367  size_t cnt = HEAPCNT(1, size);
17368  NODE *n = NEWHEAP();
17369  void *ptr = xmalloc(size);
17370 
17371  return ADD2HEAP(n, cnt, ptr);
17372 }
17373 
17374 void *
17375 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17376 {
17377  size_t cnt = HEAPCNT(nelem, size);
17378  NODE *n = NEWHEAP();
17379  void *ptr = xcalloc(nelem, size);
17380 
17381  return ADD2HEAP(n, cnt, ptr);
17382 }
17383 
17384 void *
17385 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17386 {
17387  NODE *n;
17388  size_t cnt = HEAPCNT(1, size);
17389 
17390  if (ptr && (n = parser->heap) != NULL) {
17391  do {
17392  if (n->u1.node == ptr) {
17393  n->u1.node = ptr = xrealloc(ptr, size);
17394  if (n->u3.cnt) n->u3.cnt = cnt;
17395  return ptr;
17396  }
17397  } while ((n = n->u2.node) != NULL);
17398  }
17399  n = NEWHEAP();
17400  ptr = xrealloc(ptr, size);
17401  return ADD2HEAP(n, cnt, ptr);
17402 }
17403 
17404 void
17405 rb_parser_free(struct parser_params *parser, void *ptr)
17406 {
17407  NODE **prev = &parser->heap, *n;
17408 
17409  while ((n = *prev) != NULL) {
17410  if (n->u1.node == ptr) {
17411  *prev = n->u2.node;
17413  break;
17414  }
17415  prev = &n->u2.node;
17416  }
17417  xfree(ptr);
17418 }
17419 #endif
17420 #endif
17421 
17422 #ifdef RIPPER
17423 #ifdef RIPPER_DEBUG
17424 extern int rb_is_pointer_to_heap(VALUE);
17425 
17426 /* :nodoc: */
17427 static VALUE
17428 ripper_validate_object(VALUE self, VALUE x)
17429 {
17430  if (x == Qfalse) return x;
17431  if (x == Qtrue) return x;
17432  if (x == Qnil) return x;
17433  if (x == Qundef)
17434  rb_raise(rb_eArgError, "Qundef given");
17435  if (FIXNUM_P(x)) return x;
17436  if (SYMBOL_P(x)) return x;
17437  if (!rb_is_pointer_to_heap(x))
17438  rb_raise(rb_eArgError, "invalid pointer: %p", x);
17439  switch (TYPE(x)) {
17440  case T_STRING:
17441  case T_OBJECT:
17442  case T_ARRAY:
17443  case T_BIGNUM:
17444  case T_FLOAT:
17445  return x;
17446  case T_NODE:
17447  if (nd_type(x) != NODE_LASGN) {
17448  rb_raise(rb_eArgError, "NODE given: %p", x);
17449  }
17450  return ((NODE *)x)->nd_rval;
17451  default:
17452  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17453  x, rb_obj_classname(x));
17454  }
17455  return x;
17456 }
17457 #endif
17458 
17459 #define validate(x) ((x) = get_value(x))
17460 
17461 static VALUE
17462 ripper_dispatch0(struct parser_params *parser, ID mid)
17463 {
17464  return rb_funcall(parser->value, mid, 0);
17465 }
17466 
17467 static VALUE
17468 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17469 {
17470  validate(a);
17471  return rb_funcall(parser->value, mid, 1, a);
17472 }
17473 
17474 static VALUE
17475 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17476 {
17477  validate(a);
17478  validate(b);
17479  return rb_funcall(parser->value, mid, 2, a, b);
17480 }
17481 
17482 static VALUE
17483 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17484 {
17485  validate(a);
17486  validate(b);
17487  validate(c);
17488  return rb_funcall(parser->value, mid, 3, a, b, c);
17489 }
17490 
17491 static VALUE
17492 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17493 {
17494  validate(a);
17495  validate(b);
17496  validate(c);
17497  validate(d);
17498  return rb_funcall(parser->value, mid, 4, a, b, c, d);
17499 }
17500 
17501 static VALUE
17502 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17503 {
17504  validate(a);
17505  validate(b);
17506  validate(c);
17507  validate(d);
17508  validate(e);
17509  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17510 }
17511 
17512 static VALUE
17513 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17514 {
17515  validate(a);
17516  validate(b);
17517  validate(c);
17518  validate(d);
17519  validate(e);
17520  validate(f);
17521  validate(g);
17522  return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17523 }
17524 
17525 static const struct kw_assoc {
17526  ID id;
17527  const char *name;
17528 } keyword_to_name[] = {
17529  {keyword_class, "class"},
17530  {keyword_module, "module"},
17531  {keyword_def, "def"},
17532  {keyword_undef, "undef"},
17533  {keyword_begin, "begin"},
17534  {keyword_rescue, "rescue"},
17535  {keyword_ensure, "ensure"},
17536  {keyword_end, "end"},
17537  {keyword_if, "if"},
17538  {keyword_unless, "unless"},
17539  {keyword_then, "then"},
17540  {keyword_elsif, "elsif"},
17541  {keyword_else, "else"},
17542  {keyword_case, "case"},
17543  {keyword_when, "when"},
17544  {keyword_while, "while"},
17545  {keyword_until, "until"},
17546  {keyword_for, "for"},
17547  {keyword_break, "break"},
17548  {keyword_next, "next"},
17549  {keyword_redo, "redo"},
17550  {keyword_retry, "retry"},
17551  {keyword_in, "in"},
17552  {keyword_do, "do"},
17553  {keyword_do_cond, "do"},
17554  {keyword_do_block, "do"},
17555  {keyword_return, "return"},
17556  {keyword_yield, "yield"},
17557  {keyword_super, "super"},
17558  {keyword_self, "self"},
17559  {keyword_nil, "nil"},
17560  {keyword_true, "true"},
17561  {keyword_false, "false"},
17562  {keyword_and, "and"},
17563  {keyword_or, "or"},
17564  {keyword_not, "not"},
17565  {modifier_if, "if"},
17566  {modifier_unless, "unless"},
17567  {modifier_while, "while"},
17568  {modifier_until, "until"},
17569  {modifier_rescue, "rescue"},
17570  {keyword_alias, "alias"},
17571  {keyword_defined, "defined?"},
17572  {keyword_BEGIN, "BEGIN"},
17573  {keyword_END, "END"},
17574  {keyword__LINE__, "__LINE__"},
17575  {keyword__FILE__, "__FILE__"},
17576  {keyword__ENCODING__, "__ENCODING__"},
17577  {0, NULL}
17578 };
17579 
17580 static const char*
17581 keyword_id_to_str(ID id)
17582 {
17583  const struct kw_assoc *a;
17584 
17585  for (a = keyword_to_name; a->id; a++) {
17586  if (a->id == id)
17587  return a->name;
17588  }
17589  return NULL;
17590 }
17591 
17592 #undef ripper_id2sym
17593 static VALUE
17594 ripper_id2sym(ID id)
17595 {
17596  const char *name;
17597  char buf[8];
17598 
17599  if (id <= 256) {
17600  buf[0] = (char)id;
17601  buf[1] = '\0';
17602  return ID2SYM(rb_intern2(buf, 1));
17603  }
17604  if ((name = keyword_id_to_str(id))) {
17605  return ID2SYM(rb_intern(name));
17606  }
17607  switch (id) {
17608  case tOROP:
17609  name = "||";
17610  break;
17611  case tANDOP:
17612  name = "&&";
17613  break;
17614  default:
17615  name = rb_id2name(id);
17616  if (!name) {
17617  rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17618  }
17619  return ID2SYM(id);
17620  }
17621  return ID2SYM(rb_intern(name));
17622 }
17623 
17624 static ID
17625 ripper_get_id(VALUE v)
17626 {
17627  NODE *nd;
17628  if (!RB_TYPE_P(v, T_NODE)) return 0;
17629  nd = (NODE *)v;
17630  if (nd_type(nd) != NODE_LASGN) return 0;
17631  return nd->nd_vid;
17632 }
17633 
17634 static VALUE
17635 ripper_get_value(VALUE v)
17636 {
17637  NODE *nd;
17638  if (v == Qundef) return Qnil;
17639  if (!RB_TYPE_P(v, T_NODE)) return v;
17640  nd = (NODE *)v;
17641  if (nd_type(nd) != NODE_LASGN) return Qnil;
17642  return nd->nd_rval;
17643 }
17644 
17645 static void
17646 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17647 {
17648  VALUE str;
17649  va_list args;
17650 
17651  va_start(args, fmt);
17652  str = rb_vsprintf(fmt, args);
17653  va_end(args);
17654  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17655 }
17656 
17657 static void
17658 ripper_warn0(struct parser_params *parser, const char *fmt)
17659 {
17660  rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
17661 }
17662 
17663 static void
17664 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
17665 {
17666  rb_funcall(parser->value, rb_intern("warn"), 2,
17667  STR_NEW2(fmt), INT2NUM(a));
17668 }
17669 
17670 static void
17671 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
17672 {
17673  rb_funcall(parser->value, rb_intern("warn"), 2,
17674  STR_NEW2(fmt), STR_NEW2(str));
17675 }
17676 
17677 static void
17678 ripper_warning0(struct parser_params *parser, const char *fmt)
17679 {
17680  rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
17681 }
17682 
17683 static void
17684 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
17685 {
17686  rb_funcall(parser->value, rb_intern("warning"), 2,
17687  STR_NEW2(fmt), STR_NEW2(str));
17688 }
17689 
17690 static VALUE
17691 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
17692 {
17693  return rb_io_gets(src);
17694 }
17695 
17696 static VALUE
17697 ripper_s_allocate(VALUE klass)
17698 {
17699  struct parser_params *p;
17700  VALUE self;
17701 
17702  p = ALLOC_N(struct parser_params, 1);
17703  MEMZERO(p, struct parser_params, 1);
17704  self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
17705  p->value = self;
17706  return self;
17707 }
17708 
17709 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
17710 
17711 /*
17712  * call-seq:
17713  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
17714  *
17715  * Create a new Ripper object.
17716  * _src_ must be a String, an IO, or an Object which has #gets method.
17717  *
17718  * This method does not starts parsing.
17719  * See also Ripper#parse and Ripper.parse.
17720  */
17721 static VALUE
17722 ripper_initialize(int argc, VALUE *argv, VALUE self)
17723 {
17724  struct parser_params *parser;
17725  VALUE src, fname, lineno;
17726 
17727  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17728  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
17729  if (RB_TYPE_P(src, T_FILE)) {
17730  parser->parser_lex_gets = ripper_lex_get_generic;
17731  }
17732  else {
17733  StringValue(src);
17734  parser->parser_lex_gets = lex_get_str;
17735  }
17736  parser->parser_lex_input = src;
17737  parser->eofp = Qfalse;
17738  if (NIL_P(fname)) {
17739  fname = STR_NEW2("(ripper)");
17740  }
17741  else {
17742  StringValue(fname);
17743  }
17744  parser_initialize(parser);
17745 
17746  parser->parser_ruby_sourcefile_string = fname;
17747  parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
17748  parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
17749 
17750  return Qnil;
17751 }
17752 
17753 struct ripper_args {
17754  struct parser_params *parser;
17755  int argc;
17756  VALUE *argv;
17757 };
17758 
17759 static VALUE
17760 ripper_parse0(VALUE parser_v)
17761 {
17762  struct parser_params *parser;
17763 
17764  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17765  parser_prepare(parser);
17766  ripper_yyparse((void*)parser);
17767  return parser->result;
17768 }
17769 
17770 static VALUE
17771 ripper_ensure(VALUE parser_v)
17772 {
17773  struct parser_params *parser;
17774 
17775  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17776  parser->parsing_thread = Qnil;
17777  return Qnil;
17778 }
17779 
17780 /*
17781  * call-seq:
17782  * ripper#parse
17783  *
17784  * Start parsing and returns the value of the root action.
17785  */
17786 static VALUE
17787 ripper_parse(VALUE self)
17788 {
17789  struct parser_params *parser;
17790 
17791  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17792  if (!ripper_initialized_p(parser)) {
17793  rb_raise(rb_eArgError, "method called for uninitialized object");
17794  }
17795  if (!NIL_P(parser->parsing_thread)) {
17796  if (parser->parsing_thread == rb_thread_current())
17797  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
17798  else
17799  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
17800  }
17801  parser->parsing_thread = rb_thread_current();
17802  rb_ensure(ripper_parse0, self, ripper_ensure, self);
17803 
17804  return parser->result;
17805 }
17806 
17807 /*
17808  * call-seq:
17809  * ripper#column -> Integer
17810  *
17811  * Return column number of current parsing line.
17812  * This number starts from 0.
17813  */
17814 static VALUE
17815 ripper_column(VALUE self)
17816 {
17817  struct parser_params *parser;
17818  long col;
17819 
17820  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17821  if (!ripper_initialized_p(parser)) {
17822  rb_raise(rb_eArgError, "method called for uninitialized object");
17823  }
17824  if (NIL_P(parser->parsing_thread)) return Qnil;
17825  col = parser->tokp - parser->parser_lex_pbeg;
17826  return LONG2NUM(col);
17827 }
17828 
17829 /*
17830  * call-seq:
17831  * ripper#filename -> String
17832  *
17833  * Return current parsing filename.
17834  */
17835 static VALUE
17836 ripper_filename(VALUE self)
17837 {
17838  struct parser_params *parser;
17839 
17840  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17841  if (!ripper_initialized_p(parser)) {
17842  rb_raise(rb_eArgError, "method called for uninitialized object");
17843  }
17844  return parser->parser_ruby_sourcefile_string;
17845 }
17846 
17847 /*
17848  * call-seq:
17849  * ripper#lineno -> Integer
17850  *
17851  * Return line number of current parsing line.
17852  * This number starts from 1.
17853  */
17854 static VALUE
17855 ripper_lineno(VALUE self)
17856 {
17857  struct parser_params *parser;
17858 
17859  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17860  if (!ripper_initialized_p(parser)) {
17861  rb_raise(rb_eArgError, "method called for uninitialized object");
17862  }
17863  if (NIL_P(parser->parsing_thread)) return Qnil;
17864  return INT2NUM(parser->parser_ruby_sourceline);
17865 }
17866 
17867 #ifdef RIPPER_DEBUG
17868 /* :nodoc: */
17869 static VALUE
17870 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
17871 {
17872  StringValue(msg);
17873  if (obj == Qundef) {
17874  rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
17875  }
17876  return Qnil;
17877 }
17878 
17879 /* :nodoc: */
17880 static VALUE
17881 ripper_value(VALUE self, VALUE obj)
17882 {
17883  return ULONG2NUM(obj);
17884 }
17885 #endif
17886 
17887 
17888 void
17889 Init_ripper(void)
17890 {
17891  parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
17892 
17895  /* ensure existing in symbol table */
17896  (void)rb_intern("||");
17897  (void)rb_intern("&&");
17898 
17899  InitVM(ripper);
17900 }
17901 
17902 void
17903 InitVM_ripper(void)
17904 {
17905  VALUE Ripper;
17906 
17907  Ripper = rb_define_class("Ripper", rb_cObject);
17908  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
17909  rb_define_alloc_func(Ripper, ripper_s_allocate);
17910  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
17911  rb_define_method(Ripper, "parse", ripper_parse, 0);
17912  rb_define_method(Ripper, "column", ripper_column, 0);
17913  rb_define_method(Ripper, "filename", ripper_filename, 0);
17914  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
17915  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
17916  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
17917  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
17918  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
17919 #ifdef RIPPER_DEBUG
17920  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
17921  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
17922  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
17923 #endif
17924 
17927 
17928 # if 0
17929  /* Hack to let RDoc document SCRIPT_LINES__ */
17930 
17931  /*
17932  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
17933  * after the assignment will be added as an Array of lines with the file
17934  * name as the key.
17935  */
17936  rb_define_global_const("SCRIPT_LINES__", Qnil);
17937 #endif
17938 
17939 }
17940 #endif /* RIPPER */
17941 
#define STRNCASECMP(s1, s2, n)
Definition: ruby.h:1646
#define toklast()
Definition: parse.c:12068
RUBY_EXTERN VALUE rb_cString
Definition: ruby.h:1456
#define tokadd_mbchar(c)
Definition: parse.c:12428
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:2218
#define command_start
Definition: parse.c:392
char * parser_ruby_sourcefile
Definition: ripper.c:327
VALUE val
Definition: parse.h:164
#define YYFPRINTF
Definition: parse.c:4401
#define YYLAST
Definition: parse.c:1138
#define evstr2dstr(n)
Definition: parse.c:460
static const char id_type_names[][9]
Definition: parse.c:15134
#define T_OBJECT
Definition: ruby.h:485
Definition: node.h:93
Definition: node.h:29
static NODE * call_bin_op_gen(struct parser_params *, NODE *, ID, NODE *)
Definition: parse.c:14863
stack_type cmdargs
Definition: ripper.c:193
#define NEW_RETURN(s)
Definition: node.h:383
enum lex_state_e state
Definition: lex.c:33
struct local_vars * parser_lvtbl
Definition: ripper.c:323
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: parse.c:4645
VALUE rb_ary_unshift(VALUE ary, VALUE item)
Definition: array.c:1071
static ID ripper_token2eventid(int tok)
Definition: eventids2.c:273
static ID internal_id_gen(struct parser_params *)
Definition: parse.c:16499
Definition: lex.c:33
#define tokenbuf
Definition: parse.c:381
int rb_enc_codelen(int c, rb_encoding *enc)
Definition: encoding.c:954
#define NEW_OP_ASGN_AND(i, val)
Definition: node.h:403
static double zero(void)
Definition: isinf.c:51
#define YY_REDUCE_PRINT(Rule)
Definition: parse.c:4547
#define shadowing_lvar(name)
Definition: parse.c:549
#define MBCLEN_CHARFOUND_P(ret)
Definition: encoding.h:138
static void arg_ambiguous_gen(struct parser_params *parser)
Definition: parse.c:12938
#define nextc()
Definition: parse.c:11449
static long parser_encode_length(struct parser_params *parser, const char *name, long len)
Definition: parse.c:12967
#define RE_OPTION_ENCODING_IDX(o)
Definition: parse.c:585
Definition: parse.c:862
#define NEW_OP_ASGN1(p, id, a)
Definition: node.h:399
int onig_foreach_name(regex_t *reg, int(*func)(const UChar *, const UChar *, int, int *, regex_t *, void *), void *arg)
Definition: regparse.c:537
union YYSTYPE YYSTYPE
void * rb_parser_malloc(struct parser_params *parser, size_t size)
Definition: parse.c:17365
#define NEW_SCLASS(r, b)
Definition: node.h:442
#define lex_strterm
Definition: parse.c:368
static void Init_id(void)
Definition: id.c:14
#define RARRAY_LEN(a)
Definition: ruby.h:899
Definition: parse.c:870
void rb_bug(const char *fmt,...)
Definition: error.c:295
int num
Definition: parse.h:167
#define mixed_escape(beg, enc1, enc2)
static const yytype_uint8 yyr2[]
Definition: parse.c:1692
struct token_info * next
Definition: ripper.c:275
int rb_is_local_name(VALUE name)
Definition: parse.c:17121
static NODE * attrset_gen(struct parser_params *, NODE *, ID)
Definition: parse.c:15175
void rb_enc_copy(VALUE obj1, VALUE obj2)
Definition: encoding.c:856
#define FALSE
Definition: nkf.h:174
static const struct kwtable * reserved_word(const char *, unsigned int)
#define CMDARG_P()
Definition: parse.c:179
#define tail
Definition: st.c:108
#define heredoc_end
Definition: parse.c:391
#define NEW_LIST(a)
Definition: node.h:385
int rb_is_class_name(VALUE name)
Definition: parse.c:17097
#define NEW_DEFINED(e)
Definition: node.h:454
struct vtable * used
Definition: ripper.c:191
#define tHEREDOC_BEG
Definition: eventids2.c:7
#define pushback(c)
Definition: parse.c:11450
#define rb_gc_mark_locations(start, end)
Definition: gc.c:2348
size_t strlen(const char *)
#define INT2NUM(x)
Definition: ruby.h:1178
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2525
int rb_is_attrset_name(VALUE name)
Definition: parse.c:17115
int i
Definition: win32ole.c:784
VALUE parser_lex_nextline
Definition: ripper.c:314
VALUE rb_make_exception(int argc, VALUE *argv)
Definition: eval.c:642
#define is_const_id(id)
Definition: parse.c:115
#define scan_oct(s, l, e)
Definition: util.h:52
#define nd_plen
Definition: node.h:327
#define compile_error
Definition: parse.c:721
#define T_FIXNUM
Definition: ruby.h:497
Definition: st.h:77
static NODE * negate_lit(NODE *)
Definition: parse.c:15757
#define toklen()
Definition: parse.c:12067
#define new_yield(node)
Definition: parse.c:478
#define dispatch_heredoc_end()
Definition: parse.c:12828
static NODE * node_assign_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15247
Definition: node.h:47
#define NEW_XSTR(s)
Definition: node.h:419
int parser_ruby__end__seen
Definition: ripper.c:324
static void local_push_gen(struct parser_params *, int)
Definition: parse.c:15970
static int vtable_size(const struct vtable *tbl)
Definition: parse.c:202
#define formal_argument(id)
Definition: parse.c:547
int parser_command_start
Definition: ripper.c:319
const struct kwtable * rb_reserved_word(const char *str, unsigned int len)
Definition: parse.c:17273
VALUE rb_range_new(VALUE, VALUE, int)
Definition: range.c:67
#define YY_STACK_PRINT(Bottom, Top)
Definition: parse.c:4508
static NODE * arg_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15196
#define NUM2INT(x)
Definition: ruby.h:622
#define is_notop_id(id)
Definition: parse.c:110
ID rb_check_id(volatile VALUE *namep)
Returns ID for the given name if it is interned already, or 0.
Definition: parse.c:17016
#define NEW_DOT2(b, e)
Definition: node.h:447
#define tokfix()
Definition: parse.c:12065
static NODE * evstr2dstr_gen(struct parser_params *, NODE *)
Definition: parse.c:14840
#define local_pop()
Definition: parse.c:556
static void yy_reduce_print(YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
Definition: parse.c:4525
static int nodeline(NODE *node)
Definition: parse.c:14605
static int token_info_has_nonspaces(struct parser_params *parser, const char *token)
Definition: parse.c:11581
#define malloc
Definition: parse.c:98
#define local_var(id)
Definition: parse.c:558
static NODE * arg_blk_pass(NODE *, NODE *)
Definition: parse.c:15785
#define IS_LABEL_POSSIBLE()
Definition: parse.c:13277
#define is_asgn_or_id(id)
Definition: parse.c:120
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:16161
#define POINTER_P(val)
Definition: parse.c:199
int parser_compile_for_eval
Definition: ripper.c:305
int parser_token_info_enabled
Definition: ripper.c:342
#define parser_precise_mbclen()
Definition: parse.c:11559
static ID formal_argument_gen(struct parser_params *, ID)
Definition: parse.c:12949
static int parser_read_escape(struct parser_params *parser, int flags, rb_encoding **encp)
Definition: parse.c:12201
#define internal_id()
Definition: parse.c:564
int parser_brace_nest
Definition: ripper.c:304
static VALUE reg_compile_gen(struct parser_params *, VALUE, int)
Definition: parse.c:16295
#define InitVM(ext)
Definition: ruby.h:1651
static ID register_symid(ID, const char *, long, rb_encoding *)
Definition: parse.c:16662
unsigned short int yytype_uint16
Definition: parse.c:943
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:1967
#define lex_nextline
Definition: parse.c:387
ID rb_intern_str(VALUE str)
Definition: parse.c:16846
Definition: id.h:81
#define nd_line(n)
Definition: node.h:282
#define Qtrue
Definition: ruby.h:434
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2299
#define RE_OPTION_ENCODING(e)
Definition: parse.c:584
NODE * rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
Definition: parse.c:16356
Definition: id.h:78
#define yyparse
Definition: parse.c:418
#define DVARS_TOPSCOPE
Definition: parse.c:197
#define set_yylval_str(x)
Definition: parse.c:11467
static const yytype_uint16 yyr1[]
Definition: parse.c:1624
#define gettable(id)
Definition: parse.c:483
#define set_yylval_literal(x)
Definition: parse.c:11471
#define TypedData_Wrap_Struct(klass, data_type, sval)
Definition: ruby.h:1016
#define yytable_value_is_error(yytable_value)
Definition: parse.c:3117
#define IDSET_ATTRSET_FOR_SYNTAX
Definition: parse.c:16545
#define YYPOPSTACK(N)
Definition: parse.c:854
#define ADD2HEAP(n, c, p)
Definition: parse.c:17361
VALUE rb_parser_encoding(VALUE vparser)
Definition: parse.c:17319
#define TypedData_Get_Struct(obj, type, data_type, sval)
Definition: ruby.h:1030
#define literal_concat(h, t)
Definition: parse.c:455
const int id
Definition: nkf.c:209
static void block_dup_check_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15127
int line_count
Definition: ripper.c:325
stack_type parser_cmdarg_stack
Definition: ripper.c:298
node_type
Definition: node.h:22
#define strcasecmp
Definition: win32.h:200
#define STR_NEW2(p)
Definition: parse.c:360
Definition: parse.c:839
static int lvar_defined_gen(struct parser_params *, ID)
Definition: parse.c:12960
Definition: parse.c:867
#define ID_CONST
Definition: id.h:22
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:345
#define tokspace(n)
Definition: parse.c:11452
VALUE rb_enc_from_encoding(rb_encoding *encoding)
Definition: encoding.c:103
int rb_is_method_name(VALUE name)
Definition: parse.c:17127
static ID * local_tbl_gen(struct parser_params *)
Definition: parse.c:16003
VALUE rb_eTypeError
Definition: error.c:516
#define rb_warnI(fmt, a)
Definition: parse.c:695
NODE * node
Definition: parse.h:165
#define PARSER_ARG
Definition: parse.c:722
st_table * names
Definition: encoding.c:53
#define ID_JUNK
Definition: id.h:24
#define ULONG2NUM(x)
Definition: ruby.h:1209
#define lvar_defined(id)
Definition: parse.c:580
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:822
#define rb_long2int(n)
Definition: ruby.h:325
ID rb_intern3(const char *name, long len, rb_encoding *enc)
Definition: parse.c:16698
#define NEW_CLASS(n, b, s)
Definition: node.h:441
#define current_enc
Definition: parse.c:401
#define lex_pbeg
Definition: parse.c:388
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:108
#define MAX_WORD_LENGTH
Definition: lex.c:43
VALUE rb_eEncodingError
Definition: error.c:522
NODE * rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
Definition: parse.c:11933
union RNode::@93 u1
#define SYM2ID(x)
Definition: ruby.h:364
#define subnodes(n1, n2)
#define yydebug
Definition: parse.c:402
struct RBasic basic
Definition: ruby.h:843
#define YYSTACK_BYTES(N)
Definition: parse.c:1091
#define nd_term(node)
Definition: parse.c:597
static int parser_yylex(struct parser_params *parser)
Definition: parse.c:13294
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:789
#define new_args_tail(k, kr, b)
Definition: parse.c:471
Definition: parse.c:860
#define NEW_OPT_N(b)
Definition: node.h:369
#define CMDARG_LEXPOP()
Definition: parse.c:178
static NODE * new_evstr_gen(struct parser_params *, NODE *)
Definition: parse.c:14849
VALUE op_sym[tLAST_OP_ID]
Definition: ripper.c:16525
int rb_is_junk_name(VALUE name)
Definition: parse.c:17137
VALUE debug_lines
Definition: ripper.c:338
static int parser_regx_options(struct parser_params *)
Definition: parse.c:12372
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
Definition: vm_eval.c:773
struct RString::@73::@74 heap
ID id
Definition: parse.h:166
static VALUE coverage(VALUE fname, int n)
Definition: parse.c:11721
static void set_file_encoding(struct parser_params *parser, const char *str, const char *send)
Definition: parse.c:13206
static NODE * newline_node(NODE *)
Definition: parse.c:14611
int rb_enc_str_coderange(VALUE)
Definition: string.c:327
static void ripper_init_eventids1_table(VALUE self)
Definition: eventids1.c:270
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1788
Definition: parse.c:840
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: parse.c:4410
#define RE_OPTION_ONCE
Definition: parse.c:582
#define NEW_NIL()
Definition: node.h:450
static const yytype_uint16 yyprhs[]
Definition: parse.c:1200
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Definition: ruby.h:875
#define block_dup_check(n1, n2)
Definition: parse.c:442
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
Definition: encoding.c:766
static void warn_unused_var(struct parser_params *parser, struct local_vars *local)
Definition: parse.c:15950
ID * tbl
Definition: ripper.c:182
const rb_data_type_t * parent
Definition: ruby.h:969
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:177
#define attrset(node, id)
Definition: parse.c:490
int pre_args_num
Definition: node.h:510
#define RB_GC_GUARD(v)
Definition: ruby.h:530
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
#define T_HASH
Definition: ruby.h:493
#define new_const_op_assign(lhs, op, rhs)
Definition: parse.c:501
int parser_toksiz
Definition: ripper.c:310
static NODE * assignable_gen(struct parser_params *, ID, NODE *)
Definition: parse.c:14989
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
Definition: encoding.c:886
#define ID_LOCAL
Definition: id.h:18
st_index_t rb_str_hash(VALUE)
Definition: string.c:2248
#define nd_args
Definition: node.h:331
Definition: parse.c:882
#define nd_set_type(n, t)
Definition: node.h:277
ID last_id
Definition: ripper.c:16518
static size_t parser_memsize(const void *ptr)
Definition: parse.c:17241
static NODE * new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: parse.c:15870
static void fixpos(NODE *, NODE *)
Definition: parse.c:14621
void rb_gc_mark(VALUE ptr)
Definition: gc.c:2600
#define lex_pend
Definition: parse.c:390
static NODE * gettable_gen(struct parser_params *, ID)
Definition: parse.c:14912
#define T_ARRAY
Definition: ruby.h:492
#define NEW_DOT3(b, e)
Definition: node.h:448
#define nd_paren(node)
Definition: parse.c:599
#define cmdarg_stack
Definition: parse.c:371
#define rb_enc_islower(c, enc)
Definition: encoding.h:176
static struct symbols global_symbols
#define is_class_id(id)
Definition: parse.c:116
static NODE * cond0(struct parser_params *, NODE *)
Definition: parse.c:15645
#define NEW_ITER(a, b)
Definition: node.h:373
#define STR_NEW0()
Definition: parse.c:359
void rb_gc_mark_parser(void)
Definition: parse.c:16319
#define numberof(array)
Definition: parse.c:92
#define reg_compile(str, options)
Definition: parse.c:512
NODE * pre_init
Definition: node.h:507
#define ISDIGIT(c)
static int local_var_gen(struct parser_params *, ID)
Definition: parse.c:16035
#define str_copy(_s, _p, _n)
#define NEW_IVAR(v)
Definition: node.h:408
unsigned int last
Definition: nkf.c:4310
static NODE * match_op_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14878
ID block_arg
Definition: node.h:516
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
Definition: parse.c:4494
struct RNode * node
Definition: node.h:243
#define NEW_IASGN(v, val)
Definition: node.h:394
#define FIXNUM_P(f)
Definition: ruby.h:355
rb_encoding * rb_utf8_encoding(void)
Definition: encoding.c:1166
VALUE parser_lex_input
Definition: ripper.c:312
static int dvar_defined_gen(struct parser_params *, ID, int)
Definition: parse.c:16122
#define nd_type(n)
Definition: node.h:276
static NODE * new_yield_gen(struct parser_params *, NODE *)
Definition: parse.c:15749
#define RE_OPTION_ENCODING_NONE(o)
Definition: parse.c:586
#define YYNTOKENS
Definition: parse.c:1141
static char * parser_tokspace(struct parser_params *parser, int n)
Definition: parse.c:12087
Definition: parse.c:859
VALUE klass
Definition: ruby.h:701
int rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
Definition: parse.c:16646
#define tokadd_string(f, t, p, n, e)
Definition: parse.c:11458
#define paren_nest
Definition: parse.c:373
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2109
#define is_identchar(p, e, enc)
Definition: parse.c:11560
#define RUBY_DTRACE_PARSE_BEGIN(arg0, arg1)
Definition: probes.h:68
int pos
Definition: ripper.c:183
VALUE parser_ruby_sourcefile_string
Definition: ripper.c:329
Definition: parse.c:825
Definition: parse.c:883
static void parser_heredoc_restore(struct parser_params *parser, NODE *here)
Definition: parse.c:12785
static NODE * remove_begin(NODE *)
Definition: parse.c:15443
static int is_global_name_punct(const char c)
Definition: parse.c:12621
NODE * rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: parse.c:11892
#define ENC_CODERANGE_7BIT
Definition: encoding.h:58
const char * rb_obj_classname(VALUE)
Definition: variable.c:396
void rb_gc_force_recycle(VALUE p)
Definition: gc.c:2963
#define lex_lastline
Definition: parse.c:386
#define NEW_SCOPE(a, b)
Definition: node.h:363
#define head
Definition: st.c:107
#define tok_hex(numlen)
Definition: parse.c:11454
unsigned char OnigUChar
Definition: oniguruma.h:113
int parser_yydebug
Definition: ripper.c:332
Definition: node.h:27
st_table * id_str
Definition: ripper.c:16520
static const yytype_int16 yytable[]
Definition: parse.c:2039
NODE * parser_eval_tree
Definition: ripper.c:337
NODE * parser_deferred_nodes
Definition: ripper.c:320
#define sym(x)
Definition: date_core.c:3715
VALUE rb_str_buf_cat(VALUE, const char *, long)
Definition: string.c:1951
void rb_name_error(ID id, const char *fmt,...)
Definition: error.c:904
static int dyna_in_block_gen(struct parser_params *)
Definition: parse.c:16116
static const rb_data_type_t parser_data_type
Definition: parse.c:11863
Definition: node.h:239
#define YYSYNTAX_ERROR
#define YYABORT
Definition: parse.c:4313
Definition: parse.h:159
int has_shebang
Definition: ripper.c:326
Win32OLEIDispatch * p
Definition: win32ole.c:786
#define logop(type, node1, node2)
Definition: parse.c:426
static rb_encoding * must_be_ascii_compatible(VALUE s)
Definition: parse.c:11813
#define ISALPHA(c)
Definition: ruby.h:1636
static void dyna_pop_1(struct parser_params *parser)
Definition: parse.c:16084
void rb_exc_raise(VALUE mesg)
Definition: eval.c:527
#define in_single
Definition: parse.c:376
#define NEW_VCALL(m)
Definition: node.h:425
int args
Definition: win32ole.c:785
static NODE * new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: parse.c:15915
#define strtod(s, e)
Definition: util.h:76
#define parser_warn(node, mesg)
Definition: parse.c:14641
struct vtable * prev
Definition: ripper.c:185
#define NEW_VALIAS(n, o)
Definition: node.h:439
#define RUBY_DTRACE_PARSE_END(arg0, arg1)
Definition: probes.h:72
#define RB_TYPE_P(obj, type)
Definition: ruby.h:1537
#define NEW_LVAR(v)
Definition: node.h:406
static void warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: parse.c:15565
int st_lookup(st_table *, st_data_t, st_data_t *)
#define NEW_ATTRASGN(r, m, a)
Definition: node.h:458
#define MEMZERO(p, type, n)
Definition: ruby.h:1241
#define toksiz
Definition: parse.c:383
Definition: ruby.h:842
int rb_is_instance_name(VALUE name)
Definition: parse.c:17109
#define ID_SCOPE_MASK
Definition: id.h:17
rb_encoding * enc
Definition: ripper.c:330
static void parser_free(void *ptr)
Definition: parse.c:17224
#define free
Definition: parse.c:101
enum lex_state_e parser_lex_state
Definition: ripper.c:296
int rb_is_local_id(ID id)
Definition: parse.c:16993
#define lex_gets
Definition: parse.c:395
#define NEW_POSTEXE(b)
Definition: node.h:456
int capa
Definition: ripper.c:184
VALUE parser_lex_lastline
Definition: ripper.c:313
void * rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
Definition: parse.c:17385
#define void_expr(node)
Definition: parse.c:436
static void parser_initialize(struct parser_params *parser)
Definition: parse.c:17145
#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:12987
#define NEW_IF(c, t, e)
Definition: node.h:365
#define local_id(id)
Definition: parse.c:562
#define here_document(n)
Definition: parse.c:11461
#define lex_goto_eol(parser)
Definition: parse.c:11992
#define RARRAY(obj)
Definition: ruby.h:1101
#define ruby_sourcefile
Definition: parse.c:399
#define ALLOC_N(type, n)
Definition: ruby.h:1223
void rb_compile_error_append(const char *fmt,...)
Definition: error.c:155
void rb_compile_error_with_enc(const char *file, int line, void *enc, const char *fmt,...)
Definition: error.c:131
VALUE rb_parser_get_yydebug(VALUE self)
Definition: parse.c:17334
#define YYTRANSLATE(YYX)
Definition: parse.c:1153
#define NEW_PRELUDE(p, b)
Definition: node.h:459
#define val
int rb_ispunct(int c)
Definition: encoding.c:1890
Definition: parse.c:833
#define NEW_ARRAY(a)
Definition: node.h:386
#define tokidx
Definition: parse.c:382
RUBY_EXTERN VALUE rb_cObject
Definition: ruby.h:1426
VALUE rb_eRuntimeError
Definition: error.c:515
#define match_op(node1, node2)
Definition: parse.c:504
static enum node_type nodetype(NODE *node)
Definition: parse.c:14599
#define NEW_STRTERM(func, term, paren)
Definition: parse.c:12577
#define ID_INSTANCE
Definition: id.h:19
static const struct magic_comment magic_comments[]
Definition: parse.c:13071
#define rb_enc_isascii(c, enc)
Definition: encoding.h:174
#define CMDARG_PUSH(n)
Definition: parse.c:176
#define reg_named_capture_assign(regexp, match)
Definition: parse.c:518
#define arg_concat(h, t)
Definition: parse.c:453
void rb_str_free(VALUE)
Definition: string.c:830
struct parser_params * parser
Definition: ripper.c:16305
static void magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
Definition: parse.c:13035
#define RE_OPTION_MASK
Definition: parse.c:587
void * rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
Definition: parse.c:17375
#define NEW_HASH(a)
Definition: node.h:388
#define DEF_EXPR(n)
Definition: parse.c:141
VALUE rb_get_coverages(void)
Definition: thread.c:5191
static int e_option_supplied(struct parser_params *parser)
Definition: parse.c:11737
#define NEW_ZARRAY()
Definition: node.h:387
static struct vtable * vtable_alloc(struct vtable *prev)
Definition: parse.c:215
#define NEW_FALSE()
Definition: node.h:452
#define token_info_push(token)
Definition: parse.c:737
static int rb_str_symname_type(VALUE name, unsigned int allowed_atttset)
Definition: parse.c:16652
VALUE rb_obj_as_string(VALUE)
Definition: string.c:895
int parser_paren_nest
Definition: ripper.c:300
VALUE rb_ary_new(void)
Definition: array.c:424
#define YY_(msgid)
Definition: parse.c:976
#define NODE_HEREDOC
Definition: parse.c:591
int rb_ascii8bit_encindex(void)
Definition: encoding.c:1160
#define NEW_ARGSPUSH(a, b)
Definition: node.h:433
#define VTBL_DEBUG
Definition: parse.c:212
#define cond_stack
Definition: parse.c:370
static int is_special_global_name(const char *m, const char *e, rb_encoding *enc)
Definition: parse.c:16508
static const yytype_uint16 yyrline[]
Definition: parse.c:1463
#define NEW_REDO()
Definition: node.h:377
#define NEW_NTH_REF(n)
Definition: node.h:411
#define NEW_UNLESS(c, t, e)
Definition: node.h:366
RUBY_EXTERN VALUE rb_mKernel
Definition: ruby.h:1414
#define snprintf
Definition: subst.h:6
VALUE rb_thread_current(void)
Definition: thread.c:2358
#define IS_SPCARG(c)
Definition: parse.c:13276
#define set_yylval_id(x)
Definition: parse.c:11469
NODE * rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
Definition: parse.c:11939
#define NIL_P(v)
Definition: ruby.h:446
#define ISASCII(c)
Definition: ruby.h:1629
void st_add_direct(st_table *, st_data_t, st_data_t)
Definition: st.c:629
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:488
static char msg[50]
Definition: strerror.c:8
#define NEW_GVAR(v)
Definition: node.h:405
NODE * opt_args
Definition: node.h:521
int rb_is_attrset_id(ID id)
Definition: parse.c:16987
static int reg_fragment_check_gen(struct parser_params *, VALUE, int)
Definition: parse.c:16200
#define NEW_YIELD(a)
Definition: node.h:384
#define YYSTACK_ALLOC
Definition: parse.c:1044
static NODE * dsym_node_gen(struct parser_params *, NODE *)
Definition: parse.c:15843
#define STR_FUNC_REGEXP
Definition: parse.c:11959
NODE * rb_compile_string(const char *f, VALUE s, int line)
Definition: parse.c:11885
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:2204
VALUE value
Definition: node.h:245
#define ID_SCOPE_SHIFT
Definition: id.h:16
static NODE * new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
Definition: parse.c:15899
#define k__END__
Definition: eventids2.c:9
#define ISALNUM(c)
Definition: ruby.h:1635
#define NEW_CASE(h, b)
Definition: node.h:367
rb_atomic_t cnt[RUBY_NSIG]
Definition: signal.c:432
#define RFLOAT(obj)
Definition: ruby.h:1098
static void no_blockarg(struct parser_params *parser, NODE *node)
Definition: parse.c:15724
Definition: parse.c:831
static double one(void)
Definition: isinf.c:52
Definition: parse.c:829
static NODE * splat_array(NODE *)
Definition: parse.c:15239
Definition: parse.c:864
#define FLONUM_P(x)
Definition: ruby.h:375
static void parser_mark(void *ptr)
Definition: parse.c:17198
#define T_FLOAT
Definition: ruby.h:489
static void parser_tokadd(struct parser_params *parser, int c)
Definition: parse.c:12099
#define is_local_id(id)
Definition: parse.c:111
static YYSIZE_T yystrlen(char *yystr) const
Definition: parse.c:4596
#define LVAR_USED
Definition: parse.c:15078
#define TYPE(x)
Definition: ruby.h:513
static void ripper_init_eventids1(void)
Definition: eventids1.c:134
int argc
Definition: ruby.c:130
Definition: node.h:59
static int sym_check_asciionly(VALUE str)
Definition: parse.c:16678
yytype_int16 yyss_alloc
Definition: ripper.c:1082
static ID intern_str(VALUE str)
Definition: parse.c:16720
Definition: parse.c:852
#define STR_FUNC_INDENT
Definition: parse.c:11962
char ary[RSTRING_EMBED_LEN_MAX+1]
Definition: ruby.h:853
#define Qfalse
Definition: ruby.h:433
#define NEW_EVSTR(n)
Definition: node.h:422
#define arg_append(h, t)
Definition: parse.c:451
static VALUE lex_get_str(struct parser_params *parser, VALUE s)
Definition: parse.c:11823
#define ALLOCA_N(type, n)
Definition: ruby.h:1227
static int assign_in_cond(struct parser_params *parser, NODE *node)
Definition: parse.c:15538
#define op_tbl_count
Definition: parse.c:16421
#define warn_balanced(op, syn)
Definition: parse.c:13288
#define tokadd(c)
Definition: parse.c:11453
#define NEW_OP_CDECL(v, op, val)
Definition: node.h:404
#define no_digits()
#define peek_n(c, n)
Definition: parse.c:11995
#define T_BIGNUM
Definition: ruby.h:495
#define ENC_CODERANGE_UNKNOWN
Definition: encoding.h:57
#define YYFINAL
Definition: parse.c:1136
#define ISUPPER(c)
Definition: ruby.h:1633
static void void_expr_gen(struct parser_params *, NODE *)
Definition: parse.c:15340
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:16223
#define RUBY_FUNC_EXPORTED
Definition: defines.h:184
#define MEMCPY(p1, p2, type, n)
Definition: ruby.h:1242
#define T_NODE
Definition: ruby.h:506
#define ENC_CODERANGE_BROKEN
Definition: encoding.h:60
Definition: parse.c:869
#define rb_enc_isupper(c, enc)
Definition: encoding.h:177
VALUE rb_enc_associate_index(VALUE obj, int idx)
Definition: encoding.c:748
int rb_parse_in_main(void)
Definition: compile.c:5943
static VALUE debug_lines(VALUE fname)
Definition: parse.c:11705
#define YYCASE_(N, S)
int err
Definition: win32.c:87
#define IS_AFTER_OPERATOR()
Definition: parse.c:13279
Definition: parse.c:845
#define OBJ_FREEZE(x)
Definition: ruby.h:1164
const char * parser_lex_pend
Definition: ripper.c:317
static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
Definition: parse.c:12292
#define nd_else
Definition: node.h:294
#define IDSET_ATTRSET_FOR_INTERN
Definition: parse.c:16546
#define set_yylval_num(x)
Definition: parse.c:11468
long cnt
Definition: node.h:261
Definition: util.c:791
#define parser_encoding_name()
Definition: parse.c:11557
token_info * parser_token_info
Definition: ripper.c:343
#define new_op_assign(lhs, op, rhs)
Definition: parse.c:544
int column
Definition: ripper.c:273
#define YYSIZE_T
Definition: parse.c:962
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:772
#define ALLOC(type)
Definition: ruby.h:1224
#define END(no)
Definition: re.c:26
#define NEW_FOR(v, i, b)
Definition: node.h:372
#define brace_nest
Definition: parse.c:375
#define EOF
Definition: vsnprintf.c:207
static NODE * list_append_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14698
#define NEW_WHEN(c, t, e)
Definition: node.h:368
static const yytype_int16 yycheck[]
Definition: parse.c:3120
VALUE rb_str_resize(VALUE, long)
Definition: string.c:1854
static int literal_node(NODE *node)
Definition: parse.c:15624
static int dvar_curr_gen(struct parser_params *, ID)
Definition: parse.c:16153
#define tHEREDOC_END
Definition: eventids2.c:8
#define NEW_DASGN(v, val)
Definition: node.h:392
YYSTYPE yyvs_alloc
Definition: ripper.c:1083
#define flush_string_content(enc)
Definition: parse.c:12596
int rb_str_hash_cmp(VALUE, VALUE)
Definition: string.c:2258
#define NEW_ERRINFO()
Definition: node.h:453
#define NEW_BLOCK_PASS(b)
Definition: node.h:437
Definition: parse.c:846
string_type
Definition: ripper.c:12054
int rb_dvar_defined(ID id)
Definition: compile.c:5893
union RString::@73 as
union RNode::@94 u2
#define RSTRING_LEN(str)
Definition: ruby.h:862
int parser_in_single
Definition: ripper.c:302
lex_state_bits
Definition: ripper.c:125
#define ret_args(node)
Definition: parse.c:475
static int parser_yyerror(struct parser_params *, const char *)
Definition: parse.c:11640
#define RUBY_DTRACE_PARSE_END_ENABLED()
Definition: probes.h:71
#define COND_LEXPOP()
Definition: parse.c:173
ID rest_arg
Definition: node.h:515
#define REALLOC_N(var, type, n)
Definition: ruby.h:1225
static const yytype_int16 yypgoto[]
Definition: parse.c:2011
int errno
#define TRUE
Definition: nkf.h:175
static int parser_tokadd_mbchar(struct parser_params *parser, int c)
Definition: parse.c:12415
#define nd_next
Definition: node.h:290
void rb_gc_mark_symbols(void)
Definition: parse.c:16490
#define NEW_CONST(v)
Definition: node.h:409
int rb_symname_p(const char *name)
Definition: parse.c:16534
#define COND_POP()
Definition: parse.c:172
#define TOK_INTERN(mb)
Definition: parse.c:363
#define NEW_LIT(l)
Definition: node.h:416
VALUE rb_io_gets(VALUE)
Definition: io.c:3122
int rb_is_junk_id(ID id)
Definition: parse.c:16999
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1275
#define COND_P()
Definition: parse.c:174
#define ruby_coverage
Definition: parse.c:408
#define NEW_OP_ASGN_OR(i, val)
Definition: node.h:402
static void yydestruct(char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser) const
Definition: parse.c:4832
#define rb_enc_isspace(c, enc)
Definition: encoding.h:181
#define ruby_sourcefile_string
Definition: parse.c:400
#define NEW_NEXT(s)
Definition: node.h:376
#define rb_warnS(fmt, a)
Definition: parse.c:696
#define parser_warning(node, mesg)
Definition: parse.c:14634
#define mixed_error(enc1, enc2)
#define const
Definition: strftime.c:102
#define rb_enc_name(enc)
Definition: encoding.h:124
union RNode::@95 u3
RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e-0x20+31)/32]
Definition: parse.c:12599
#define value_expr(node)
Definition: parse.c:434
#define rb_warning0(fmt)
Definition: parse.c:698
#define reg_fragment_setenc(str, options)
Definition: parse.c:514
static int value_expr_gen(struct parser_params *, NODE *)
Definition: parse.c:15278
static const yytype_int16 yyrhs[]
Definition: parse.c:1268
const char * rb_id2name(ID id)
Definition: parse.c:16922
static int parser_whole_match_p(struct parser_params *parser, const char *eos, long len, int indent)
Definition: parse.c:12802
#define NEW_RESCUE(b, res, e)
Definition: node.h:380
#define YYDPRINTF(Args)
Definition: parse.c:4404
static const char * magic_comment_marker(const char *str, long len)
Definition: parse.c:13079
#define rb_warn0(fmt)
Definition: parse.c:694
rb_magic_comment_length_t length
Definition: ripper.c:13158
int parser_in_def
Definition: ripper.c:303
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1570
static const yytype_uint8 yytranslate[]
Definition: parse.c:1157
#define new_bv(id)
Definition: parse.c:551
#define YYEMPTY
Definition: parse.c:4309
#define YYSTACK_FREE
Definition: parse.c:1045
#define YYID(n)
Definition: parse.c:989
VALUE parser_cur_mid
Definition: ripper.c:306
VALUE stack_type
Definition: parse.c:164
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4308
Definition: parse.c:826
Definition: parse.c:866
#define PRIsVALUE
Definition: ruby.h:147
static char * parser_newtok(struct parser_params *parser)
Definition: parse.c:12071
long parser_lex_gets_ptr
Definition: ripper.c:321
unsigned long ID
Definition: ruby.h:105
static void fixup_nodes(NODE **)
Definition: parse.c:15577
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1181
#define rb_enc_isalnum(c, enc)
Definition: encoding.h:179
#define dyna_pop(node)
Definition: parse.c:569
#define rb_enc_isdigit(c, enc)
Definition: encoding.h:182
#define nd_resq
Definition: node.h:298
#define list_concat(h, t)
Definition: parse.c:449
#define dyna_in_block()
Definition: parse.c:571
#define Qnil
Definition: ruby.h:435
#define dyna_var(id)
Definition: parse.c:572
#define NEW_BACK_REF(n)
Definition: node.h:412
Definition: parse.c:857
#define STR_FUNC_ESCAPE
Definition: parse.c:11957
int type
Definition: tcltklib.c:111
int id[2]
Definition: lex.c:33
#define NODE_FL_NEWLINE
Definition: node.h:269
static int options(unsigned char *cp)
Definition: nkf.c:6355
#define NEW_MASGN(l, r)
Definition: node.h:389
#define heredoc_restore(n)
Definition: parse.c:11463
#define NEW_COLON2(c, i)
Definition: node.h:444
unsigned long VALUE
Definition: ruby.h:104
#define yyerror(msg)
Definition: parse.c:366
#define peek(c)
Definition: parse.c:11994
stack_type parser_cond_stack
Definition: ripper.c:297
#define IS_lex_state_for(x, ls)
Definition: parse.c:157
static VALUE result
Definition: nkf.c:40
NODE * post_init
Definition: node.h:508
static NODE * arg_append_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15221
static void ripper_init_eventids2(void)
Definition: eventids2.c:64
#define RBASIC(obj)
Definition: ruby.h:1094
#define heredoc_identifier()
Definition: parse.c:11462
int parser_heredoc_end
Definition: ripper.c:318
#define rb_enc_ispunct(c, enc)
Definition: encoding.h:178
#define NEW_KW_ARG(i, v)
Definition: node.h:430
static VALUE parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
Definition: parse.c:11976
#define ripper_flush(p)
Definition: parse.c:11490
void rb_mark_tbl(st_table *tbl)
Definition: gc.c:2543
#define dsym_node(node)
Definition: parse.c:480
#define regx_options()
Definition: parse.c:11457
int post_args_num
Definition: node.h:511
static int parser_magic_comment(struct parser_params *parser, const char *str, long len)
Definition: parse.c:13112
#define NEW_ENSURE(b, en)
Definition: node.h:382
yytokentype
Definition: parse.c:772
#define token_info_pop(token)
Definition: parse.c:738
static int arg_var_gen(struct parser_params *, ID)
Definition: parse.c:16028
#define call_bin_op(recv, id, arg1)
Definition: parse.c:464
#define rb_warn4S(file, line, fmt, a)
Definition: parse.c:697
#define NEW_ZSUPER()
Definition: node.h:427
#define rb_enc_asciicompat(enc)
Definition: encoding.h:184
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
Definition: eval.c:804
VALUE flags
Definition: ruby.h:700
static VALUE yycompile0(VALUE arg)
Definition: parse.c:11743
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Definition: re.c:301
#define NEW_COLON3(i)
Definition: node.h:445
#define NEW_BLOCK(a)
Definition: node.h:364
#define Qnone
Definition: parse.c:686
#define assignable_result(x)
static int parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
Definition: parse.c:12299
static int parser_tokadd_string(struct parser_params *, int, int, int, long *, rb_encoding **)
Definition: parse.c:12444
#define nd_body
Definition: node.h:293
VALUE flags
Definition: node.h:240
const char * token
Definition: ripper.c:271
#define ENCODING_IS_ASCII8BIT(obj)
Definition: encoding.h:52
VALUE rb_str_dup(VALUE)
Definition: string.c:946
#define dvar_defined_get(id)
Definition: parse.c:575
#define RUBY_DTRACE_PARSE_BEGIN_ENABLED()
Definition: probes.h:67
#define rb_enc_isalpha(c, enc)
Definition: encoding.h:175
static NODE * new_args_gen(struct parser_params *, NODE *, NODE *, ID, NODE *, NODE *)
Definition: parse.c:15796
#define ruby_sourceline
Definition: parse.c:398
#define is_global_id(id)
Definition: parse.c:112
#define lex_input
Definition: parse.c:385
Definition: parse.c:847
void xfree(void *)
#define STR_FUNC_QWORDS
Definition: parse.c:11960
static int vtable_included(const struct vtable *tbl, ID id)
Definition: parse.c:254
ID rb_intern(const char *name)
Definition: parse.c:16840
int parser_in_defined
Definition: ripper.c:307
#define ruby_eval_tree
Definition: parse.c:405
#define LONG2NUM(x)
Definition: ruby.h:1199
int parser_class_nest
Definition: ripper.c:299
ID token
Definition: parse.c:16397
static VALUE lex_io_gets(struct parser_params *parser, VALUE io)
Definition: parse.c:11919
NODE * rb_compile_cstr(const char *f, const char *s, int len, int line)
Definition: parse.c:11905
#define parser_is_identchar()
Definition: parse.c:11561
#define NEW_BEGIN(b)
Definition: node.h:379
#define ruby__end__seen
Definition: parse.c:397
#define dvar_curr(id)
Definition: parse.c:577
#define set_yylval_node(x)
Definition: parse.c:11472
static void yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: parse.c:4433
static void vtable_free(struct vtable *tbl)
Definition: parse.c:227
#define RSTRING_PTR(str)
Definition: ruby.h:866
#define NEW_SPLAT(a)
Definition: node.h:434
static int rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_atttset)
Definition: parse.c:16549
#define reg_fragment_check(str, options)
Definition: parse.c:516
VALUE rb_usascii_str_new2(const char *)
const struct vtable * vars
Definition: parse.h:168
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:2109
st_table * st_init_table_with_size(const struct st_hash_type *, st_index_t)
Definition: st.c:229
#define ENCODING_GET(obj)
Definition: encoding.h:47
#define lex_state
Definition: parse.c:369
#define arg_ambiguous()
Definition: parse.c:12946
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:772
RUBY_EXTERN int ffs(int)
Definition: ffs.c:6
static void reduce_nodes_gen(struct parser_params *, NODE **)
Definition: parse.c:15453
#define RFLOAT_VALUE(v)
Definition: ruby.h:836
int nonspc
Definition: ripper.c:274
int size
Definition: encoding.c:52
#define YYSTACK_ALLOC_MAXIMUM
Definition: parse.c:1047
#define NEW_DSTR(s)
Definition: node.h:418
#define newtok()
Definition: parse.c:11451
#define f
#define yylval
Definition: parse.c:11440
#define INT2FIX(i)
Definition: ruby.h:241
#define set_yylval_name(x)
Definition: parse.c:11470
#define NEW_GASGN(v, val)
Definition: node.h:390
static const struct @96 op_tbl[]
#define NEW_BREAK(s)
Definition: node.h:375
Definition: parse.c:842
static NODE * reg_named_capture_assign_gen(struct parser_params *parser, VALUE regexp, NODE *match)
Definition: parse.c:16263
static void parser_pushback(struct parser_params *parser, int c)
Definition: parse.c:12054
int rb_enc_symname_p(const char *name, rb_encoding *enc)
Definition: parse.c:16540
int parser_tokidx
Definition: ripper.c:309
static const yytype_uint16 yydefact[]
Definition: parse.c:1762
Definition: node.h:45
#define lpar_beg
Definition: parse.c:374
static int parser_here_document(struct parser_params *, NODE *)
Definition: parse.c:12832
#define YYUSE(e)
Definition: parse.c:982
#define COND_PUSH(n)
Definition: parse.c:171
#define xmalloc
Definition: defines.h:64
int rb_is_const_name(VALUE name)
Definition: parse.c:17091
static NODE * ret_args_gen(struct parser_params *, NODE *)
Definition: parse.c:15732
#define YYACCEPT
Definition: parse.c:4312
VALUE coverage
Definition: ripper.c:339
void rb_set_errinfo(VALUE err)
Definition: eval.c:1442
#define lex_gets_ptr
Definition: parse.c:394
#define NEW_TRUE()
Definition: node.h:451
static void dyna_pop_gen(struct parser_params *, const struct vtable *)
Definition: parse.c:16102
NODE * parser_lex_strterm
Definition: ripper.c:295
int rb_is_global_id(ID id)
Definition: parse.c:16975
const char * name
Definition: parse.c:16398
const char * name
Definition: ripper.c:13156
static void local_pop_gen(struct parser_params *)
Definition: parse.c:15987
#define tSP
Definition: eventids2.c:6
#define NEW_LAMBDA(a, b)
Definition: node.h:374
#define IS_lex_state(ls)
Definition: parse.c:158
static int simple_re_meta(int c)
Definition: parse.c:12431
Definition: node.h:207
#define NEW_UNTIL(c, b, n)
Definition: node.h:371
#define lvtbl
Definition: parse.c:396
#define new_attr_op_assign(lhs, type, attr, op, rhs)
Definition: parse.c:499
#define RARRAY_PTR(a)
Definition: ruby.h:904
#define aryset(node1, node2)
Definition: parse.c:488
#define NEW_MODULE(n, b)
Definition: node.h:443
static const struct st_hash_type symhash
Definition: parse.c:16438
#define list_append(l, i)
Definition: parse.c:447
#define tokaddmbc(c, enc)
Definition: parse.c:11460
short int yytype_int16
Definition: parse.c:949
#define cur_mid
Definition: parse.c:379
#define STR_NEW3(p, n, e, func)
Definition: parse.c:361
#define IS_BEG()
Definition: parse.c:13275
rb_magic_comment_setter_t func
Definition: ripper.c:13157
static const yytype_int16 yypact[]
Definition: parse.c:1900
#define dvar_defined(id)
Definition: parse.c:574
int parser_lpar_beg
Definition: ripper.c:301
#define ESCAPE_CONTROL
Definition: parse.c:12197
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:190
VALUE rb_check_string_type(VALUE)
Definition: string.c:1509
st_table * sym_id
Definition: ripper.c:16519
static void warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: parse.c:15571
#define yypact_value_is_default(yystate)
Definition: parse.c:3114
Definition: parse.c:850
uint8_t key[16]
Definition: random.c:1370
static int symbols_i(VALUE sym, ID value, VALUE ary)
Definition: parse.c:16931
#define nd_head
Definition: node.h:288
struct local_vars * prev
Definition: ripper.c:192
#define IS_END()
Definition: parse.c:13274
static void parser_prepare(struct parser_params *parser)
Definition: parse.c:13249
#define LONG2FIX(i)
Definition: ruby.h:242
ID rb_id_attrset(ID id)
Definition: parse.c:15146
static struct parser_params * parser_new(void)
Definition: parse.c:17279
#define NEW_WHILE(c, b, n)
Definition: node.h:370
struct vtable * vars
Definition: ripper.c:190
#define RTEST(v)
Definition: ruby.h:445
static void yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: parse.c:4467
Definition: node.h:139
#define new_args(f, o, r, p, t)
Definition: parse.c:469
#define T_STRING
Definition: ruby.h:490
static void rb_backref_error_gen(struct parser_params *, NODE *)
Definition: parse.c:15183
VALUE rb_id2str(ID id)
Definition: parse.c:16856
#define NEW_POSTARG(i, v)
Definition: node.h:431
#define YYINITDEPTH
Definition: parse.c:4568
#define RREGEXP(obj)
Definition: ruby.h:1100
static NODE * logop_gen(struct parser_params *, enum node_type, NODE *, NODE *)
Definition: parse.c:15709
VALUE rb_parser_new(void)
Definition: parse.c:17290
static void void_stmts_gen(struct parser_params *, NODE *)
Definition: parse.c:15429
#define ENC_SINGLE(cr)
Definition: parse.c:362
#define NEW_UNDEF(i)
Definition: node.h:440
struct rb_encoding_entry * list
Definition: encoding.c:50
static const yytype_int16 yydefgoto[]
Definition: parse.c:1873
static NODE * parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
Definition: parse.c:11866
v
Definition: win32ole.c:798
#define parse_string(n)
Definition: parse.c:11459
#define ID_ATTRSET
Definition: id.h:21
#define T_FILE
Definition: ruby.h:496
#define NEWHEAP()
Definition: parse.c:17360
#define NEW_CVASGN(v, val)
Definition: node.h:397
static int yylex(void *, void *)
Definition: parse.c:14564
#define NEW_FCALL(m, a)
Definition: node.h:424
Definition: parse.c:844
int linenum
Definition: ripper.c:272
#define YYEOF
Definition: parse.c:4310
#define tEMBDOC
Definition: eventids2.c:4
int rb_is_global_name(VALUE name)
Definition: parse.c:17103
#define NEW_OP_ASGN2(r, i, o, val)
Definition: node.h:400
#define NEW_MATCH3(r, n2)
Definition: node.h:415
#define deferred_nodes
Definition: parse.c:393
Definition: parse.c:863
long(* rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len)
Definition: parse.c:13031
char * parser_tokenbuf
Definition: ripper.c:308
#define node_assign(node1, node2)
Definition: parse.c:495
#define get_id(id)
Definition: parse.c:520
VALUE rb_cArray
Definition: array.c:29
#define NEW_OPT_ARG(i, v)
Definition: node.h:429
#define BEG(no)
Definition: re.c:25
short int yytype_int8
Definition: parse.c:937
static unsigned int hash(const char *str, unsigned int len)
Definition: lex.c:56
#define id_type(id)
Definition: parse.c:118
int parser_tokline
Definition: ripper.c:311
#define YYTERROR
Definition: parse.c:4351
static int parser_parse_string(struct parser_params *, NODE *)
Definition: parse.c:12664
#define tok()
Definition: parse.c:12066
#define cond(node)
Definition: parse.c:424
VALUE rb_ary_new2(long capa)
Definition: array.c:417
VALUE rb_filesystem_str_new_cstr(const char *)
Definition: string.c:614
#define ruby_eval_tree_begin
Definition: parse.c:406
#define is_instance_id(id)
Definition: parse.c:113
NODE * rb_parser_append_print(VALUE vparser, NODE *node)
Definition: parse.c:16324
ID rb_intern2(const char *name, long len)
Definition: parse.c:16833
const char * parser_lex_pbeg
Definition: ripper.c:315
static NODE * cond_gen(struct parser_params *, NODE *)
Definition: parse.c:15702
NODE * rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
Definition: parse.c:11912
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
Definition: string.c:439
#define rb_safe_level()
Definition: tcltklib.c:94
static NODE * list_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14718
Definition: ripper.c:181
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:1882
static int is_private_local_id(ID name)
Definition: parse.c:15068
#define lex_p
Definition: parse.c:389
static int comment_at_top(struct parser_params *parser)
Definition: parse.c:13019
const char * parser_lex_p
Definition: ripper.c:316
static void dispose_string(VALUE str)
Definition: parse.c:12408
Definition: parse.c:841
#define xrealloc
Definition: defines.h:67
static int parser_nextc(struct parser_params *parser)
Definition: parse.c:11998
lex_state_e
Definition: ripper.c:140
#define read_escape(flags, e)
Definition: parse.c:11455
#define parser_isascii()
Definition: parse.c:11563
#define ID2SYM(x)
Definition: ruby.h:363
static const char *const yytname[]
Definition: parse.c:1534
Definition: node.h:61
static char * yystpcpy(char *yydest, const char *yysrc)
Definition: parse.c:4620
int parser_ruby_sourceline
Definition: ripper.c:328
#define NEW_RETRY()
Definition: node.h:378
#define call_uni_op(recv, id)
Definition: parse.c:466
#define rb_errinfo()
Definition: tcltklib.c:89
unsigned long st_data_t
Definition: st.h:35
static ID register_symid_str(ID, VALUE)
Definition: parse.c:16669
#define StringValuePtr(v)
Definition: ruby.h:547
#define STR_FUNC_SYMBOL
Definition: parse.c:11961
#define nd_value
Definition: node.h:318
#define DVARS_INHERIT
Definition: parse.c:196
#define ID_INTERNAL
Definition: id.h:25
Definition: parse.c:851
static ID shadowing_lvar_gen(struct parser_params *, ID)
Definition: parse.c:15081
YYSTYPE * parser_yylval
Definition: ripper.c:292
VALUE rb_str_new_frozen(VALUE)
Definition: string.c:713
static int token_info_get_column(struct parser_params *parser, const char *token)
Definition: parse.c:11567
unsigned char yytype_uint8
Definition: parse.c:928
void(* rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val)
Definition: parse.c:13032
static NODE * yycompile(struct parser_params *parser, VALUE fname, int line)
Definition: parse.c:11803
#define NEW_RESBODY(a, ex, n)
Definition: node.h:381
Definition: parse.c:853
#define NEW_ARGSCAT(a, b)
Definition: node.h:432
#define arg_var(id)
Definition: parse.c:560
#define NEW_DASGN_CURR(v, val)
Definition: node.h:393
VALUE rb_inspect(VALUE)
Definition: object.c:411
#define is_junk_id(id)
Definition: parse.c:117
static void vtable_add(struct vtable *tbl, ID id)
Definition: parse.c:239
int rb_is_class_id(ID id)
Definition: parse.c:16969
#define NEW_SUPER(a)
Definition: node.h:426
#define NEW_CALL(r, m, a)
Definition: node.h:423
static const yytype_uint16 yystos[]
Definition: parse.c:4197
static int is_static_content(NODE *node)
Definition: parse.c:15514
int is_ripper
Definition: ripper.c:289
#define in_defined
Definition: parse.c:380
rb_encoding * rb_ascii8bit_encoding(void)
Definition: encoding.c:1151
int rb_enc_find_index(const char *name)
Definition: encoding.c:635
VALUE eofp
Definition: ripper.c:293
static NODE * aryset_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15119
VALUE rb_parser_end_seen_p(VALUE vparser)
Definition: parse.c:17304
static int parser_heredoc_identifier(struct parser_params *parser)
Definition: parse.c:12722
Definition: node.h:31
int rb_is_const_id(ID id)
Definition: parse.c:16963
static int parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp, int string_literal, int symbol_literal, int regexp_literal)
Definition: parse.c:12126
long len
Definition: ruby.h:846
static const struct vtable * dyna_push_gen(struct parser_params *)
Definition: parse.c:16073
#define CONST_ID(var, str)
Definition: ruby.h:1318
NODE * heap
Definition: ripper.c:290
static NODE * block_append_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14644
VALUE rb_str_intern(VALUE)
Definition: string.c:7229
#define NEW_CVAR(v)
Definition: node.h:410
#define tokline
Definition: parse.c:384
#define ESCAPE_META
Definition: parse.c:12198
#define local_push(top)
Definition: parse.c:554
Definition: parse.c:868
#define NEW_MATCH2(n1, n2)
Definition: node.h:414
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: parse.c:17349
static void new_bv_gen(struct parser_params *, ID)
Definition: parse.c:15105
#define assignable(id, node)
Definition: parse.c:485
ID first_post_arg
Definition: node.h:513
st_table * st_init_numtable_with_size(st_index_t)
Definition: st.c:278
Definition: parse.c:856
VALUE rb_cstr_to_inum(const char *str, int base, int badcheck)
Definition: bignum.c:579
static NODE * range_op(struct parser_params *parser, NODE *node)
Definition: parse.c:15608
#define ruby_debug_lines
Definition: parse.c:407
Definition: id.h:71
#define rb_enc_mbcput(c, buf, enc)
Definition: encoding.h:161
#define IS_ARG()
Definition: parse.c:13273
#define NEW_DVAR(v)
Definition: node.h:407
#define NEW_DEFN(i, a, d, p)
Definition: node.h:360
static int parser_tok_hex(struct parser_params *parser, size_t *numlen)
Definition: parse.c:12109
#define new_evstr(n)
Definition: parse.c:458
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
Definition: parse.c:17063
int rb_parse_in_eval(void)
Definition: compile.c:5937
NODE * rb_compile_file(const char *f, VALUE file, int start)
Definition: parse.c:11925
VALUE rb_str_buf_new(long)
Definition: string.c:777
VALUE rb_usascii_str_new(const char *, long)
Definition: string.c:431
#define lex_eol_p()
Definition: parse.c:11993
#define rb_node_newnode(type, a1, a2, a3)
Definition: parse.c:421
#define SYMBOL_P(x)
Definition: ruby.h:362
#define tCOMMENT
Definition: eventids2.c:2
NODE * kw_args
Definition: node.h:518
#define nd_iter
Definition: node.h:316
#define nd_set_line(n, l)
Definition: node.h:283
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1269
Definition: parse.c:838
#define void_stmts(node)
Definition: parse.c:438
#define block_append(h, t)
Definition: parse.c:445
VALUE(* parser_lex_gets)(struct parser_params *, VALUE)
Definition: ripper.c:322
#define NULL
Definition: _sdbm.c:102
#define compile_for_eval
Definition: parse.c:378
#define RTYPEDDATA_TYPE(v)
Definition: ruby.h:988
#define NEW_LASGN(v, val)
Definition: node.h:391
struct token_info token_info
#define FIX2LONG(x)
Definition: ruby.h:353
#define Qundef
Definition: ruby.h:436
static NODE * literal_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14759
VALUE rb_hash_aset(VALUE, VALUE, VALUE)
#define tIGNORED_NL
Definition: eventids2.c:1
#define yyerrok
Definition: parse.c:4307
#define NEW_STR(s)
Definition: node.h:417
static NODE * call_uni_op_gen(struct parser_params *, NODE *, ID)
Definition: parse.c:14871
#define YYMAXDEPTH
Definition: parse.c:4579
static int literal_concat0(struct parser_params *, VALUE, VALUE)
Definition: parse.c:14742
int rb_is_instance_id(ID id)
Definition: parse.c:16981
void rb_parser_free(struct parser_params *parser, void *ptr)
Definition: parse.c:17405
Definition: parse.c:837
NODE * kw_rest_arg
Definition: node.h:519
#define ID_GLOBAL
Definition: id.h:20
#define in_def
Definition: parse.c:377
#define ISXDIGIT(c)
Definition: ruby.h:1638
#define ENCODING_SET(obj, i)
Definition: encoding.h:37
int rb_local_defined(ID id)
Definition: compile.c:5918
st_index_t num_entries
Definition: st.h:93
Definition: parse.c:848
#define IS_LABEL_SUFFIX(n)
Definition: parse.c:13278
#define NEW_SELF()
Definition: node.h:449
Definition: parse.c:824
NODE * parser_eval_tree_begin
Definition: ripper.c:336
static int match(VALUE str, VALUE pat, VALUE hash, int(*cb)(VALUE, VALUE))
Definition: date_parse.c:273
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1344
Definition: parse.c:855
#define ruby_verbose
Definition: ruby.h:1363
VALUE rb_str_append(VALUE, VALUE)
Definition: string.c:2125
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
Definition: st.c:1006
static void parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
Definition: parse.c:13044
#define NEW_NODE(t, a0, a1, a2)
Definition: node.h:358
#define NEW_ARGS_AUX(r, b)
Definition: node.h:428
#define RSTRING_NOEMBED
Definition: ruby.h:856
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:80
#define NEW_ALIAS(n, o)
Definition: node.h:438
NODE * rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
Definition: parse.c:11898
#define ifndef_ripper(x)
Definition: parse.c:687
#define YYLEX
Definition: parse.c:4393
static VALUE lex_getline(struct parser_params *parser)
Definition: parse.c:11843
VALUE rb_sym_all_symbols(void)
Definition: parse.c:16954
VALUE rb_eArgError
Definition: error.c:517
#define nd_lit
Definition: node.h:321
#define rb_enc_prev_char(s, p, e, enc)
Definition: encoding.h:164
#define T_REGEXP
Definition: ruby.h:491
#define tokadd_escape(e)
Definition: parse.c:11456
static NODE * node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE)
Definition: parse.c:14591
Definition: node.h:137
#define dyna_push()
Definition: parse.c:567
#define whole_match_p(e, l, i)
Definition: parse.c:11464
#define was_bol()
Definition: parse.c:12063
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:4693
#define HEAPCNT(n, size)
Definition: parse.c:17359
#define STR_FUNC_EXPAND
Definition: parse.c:11958
static int parser_peek_variable_name(struct parser_params *parser)
Definition: parse.c:12628
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1122
#define is_attrset_id(id)
Definition: parse.c:114
struct vtable * args
Definition: ripper.c:189
static int local_id_gen(struct parser_params *, ID)
Definition: parse.c:16045
#define SPECIAL_PUNCT(idx)
Definition: parse.c:12604
#define NEW_CDECL(v, val, path)
Definition: node.h:396
#define rb_backref_error(n)
Definition: parse.c:493
#define NEW_DEFS(r, i, a, d)
Definition: node.h:361
char ** argv
Definition: ruby.c:131
#define tEMBDOC_END
Definition: eventids2.c:5
char * ptr
Definition: ruby.h:847
#define DBL2NUM(dbl)
Definition: ruby.h:837
static void ripper_init_eventids2_table(VALUE self)
Definition: eventids2table.c:2
Definition: parse.c:849
#define ISSPACE(c)
Definition: ruby.h:1632
#define StringValue(v)
Definition: ruby.h:546
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:2078
#define STR_NEW(p, n)
Definition: parse.c:358
static NODE * new_args_tail_gen(struct parser_params *, NODE *, ID, ID)
Definition: parse.c:15818
#define rb_warningS(fmt, a)
Definition: parse.c:699
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: parse.c:1102
#define reduce_nodes(n)
Definition: parse.c:440
#define void_expr0(node)
Definition: parse.c:435
rb_encoding * rb_enc_from_index(int index)
Definition: encoding.c:548
#define tokcopy(n)
Definition: parse.c:12122
void Init_sym(void)
Definition: parse.c:16471
VALUE rb_str_new(const char *, long)
Definition: string.c:425
Definition: parse.c:828
#define xcalloc
Definition: defines.h:66
#define ID_CLASS
Definition: id.h:23
Definition: parse.c:843