Ruby  2.0.0p353(2013-11-22revision43784)
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 };
194 
195 #define DVARS_INHERIT ((void*)1)
196 #define DVARS_TOPSCOPE NULL
197 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
198 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
199 
200 static int
201 vtable_size(const struct vtable *tbl)
202 {
203  if (POINTER_P(tbl)) {
204  return tbl->pos;
205  }
206  else {
207  return 0;
208  }
209 }
210 
211 #define VTBL_DEBUG 0
212 
213 static struct vtable *
215 {
216  struct vtable *tbl = ALLOC(struct vtable);
217  tbl->pos = 0;
218  tbl->capa = 8;
219  tbl->tbl = ALLOC_N(ID, tbl->capa);
220  tbl->prev = prev;
221  if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
222  return tbl;
223 }
224 
225 static void
227 {
228  if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
229  if (POINTER_P(tbl)) {
230  if (tbl->tbl) {
231  xfree(tbl->tbl);
232  }
233  xfree(tbl);
234  }
235 }
236 
237 static void
238 vtable_add(struct vtable *tbl, ID id)
239 {
240  if (!POINTER_P(tbl)) {
241  rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
242  }
243  if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
244 
245  if (tbl->pos == tbl->capa) {
246  tbl->capa = tbl->capa * 2;
247  REALLOC_N(tbl->tbl, ID, tbl->capa);
248  }
249  tbl->tbl[tbl->pos++] = id;
250 }
251 
252 static int
253 vtable_included(const struct vtable * tbl, ID id)
254 {
255  int i;
256 
257  if (POINTER_P(tbl)) {
258  for (i = 0; i < tbl->pos; i++) {
259  if (tbl->tbl[i] == id) {
260  return i+1;
261  }
262  }
263  }
264  return 0;
265 }
266 
267 
268 #ifndef RIPPER
269 typedef struct token_info {
270  const char *token;
271  int linenum;
272  int column;
273  int nonspc;
274  struct token_info *next;
275 } token_info;
276 #endif
277 
278 /*
279  Structure of Lexer Buffer:
280 
281  lex_pbeg tokp lex_p lex_pend
282  | | | |
283  |-----------+--------------+------------|
284  |<------------>|
285  token
286 */
287 struct parser_params {
288  int is_ripper;
289  NODE *heap;
290 
292  VALUE eofp;
293 
296  stack_type parser_cond_stack;
297  stack_type parser_cmdarg_stack;
298  int parser_class_nest;
299  int parser_paren_nest;
300  int parser_lpar_beg;
301  int parser_in_single;
302  int parser_in_def;
303  int parser_brace_nest;
306  int parser_in_defined;
307  char *parser_tokenbuf;
308  int parser_tokidx;
309  int parser_toksiz;
310  int parser_tokline;
314  const char *parser_lex_pbeg;
315  const char *parser_lex_p;
316  const char *parser_lex_pend;
317  int parser_heredoc_end;
320  long parser_lex_gets_ptr;
322  struct local_vars *parser_lvtbl;
324  int line_count;
325  int has_shebang;
326  char *parser_ruby_sourcefile; /* current source file */
327  int parser_ruby_sourceline; /* current line no. */
328  rb_encoding *enc;
329 
330  int parser_yydebug;
331 
332 #ifndef RIPPER
333  /* Ruby core only */
337  VALUE coverage;
338  int nerr;
339 
342 #else
343  /* Ripper only */
344  VALUE parser_ruby_sourcefile_string;
345  const char *tokp;
346  VALUE delayed;
347  int delayed_line;
348  int delayed_col;
349 
350  VALUE value;
351  VALUE result;
352  VALUE parsing_thread;
353  int toplevel_p;
354 #endif
355 };
356 
357 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)
358 #define STR_NEW0() rb_enc_str_new(0,0,current_enc)
359 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)
360 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)
361 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
362 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc)
363 
364 static int parser_yyerror(struct parser_params*, const char*);
365 #define yyerror(msg) parser_yyerror(parser, (msg))
366 
367 #define lex_strterm (parser->parser_lex_strterm)
368 #define lex_state (parser->parser_lex_state)
369 #define cond_stack (parser->parser_cond_stack)
370 #define cmdarg_stack (parser->parser_cmdarg_stack)
371 #define class_nest (parser->parser_class_nest)
372 #define paren_nest (parser->parser_paren_nest)
373 #define lpar_beg (parser->parser_lpar_beg)
374 #define brace_nest (parser->parser_brace_nest)
375 #define in_single (parser->parser_in_single)
376 #define in_def (parser->parser_in_def)
377 #define compile_for_eval (parser->parser_compile_for_eval)
378 #define cur_mid (parser->parser_cur_mid)
379 #define in_defined (parser->parser_in_defined)
380 #define tokenbuf (parser->parser_tokenbuf)
381 #define tokidx (parser->parser_tokidx)
382 #define toksiz (parser->parser_toksiz)
383 #define tokline (parser->parser_tokline)
384 #define lex_input (parser->parser_lex_input)
385 #define lex_lastline (parser->parser_lex_lastline)
386 #define lex_nextline (parser->parser_lex_nextline)
387 #define lex_pbeg (parser->parser_lex_pbeg)
388 #define lex_p (parser->parser_lex_p)
389 #define lex_pend (parser->parser_lex_pend)
390 #define heredoc_end (parser->parser_heredoc_end)
391 #define command_start (parser->parser_command_start)
392 #define deferred_nodes (parser->parser_deferred_nodes)
393 #define lex_gets_ptr (parser->parser_lex_gets_ptr)
394 #define lex_gets (parser->parser_lex_gets)
395 #define lvtbl (parser->parser_lvtbl)
396 #define ruby__end__seen (parser->parser_ruby__end__seen)
397 #define ruby_sourceline (parser->parser_ruby_sourceline)
398 #define ruby_sourcefile (parser->parser_ruby_sourcefile)
399 #define current_enc (parser->enc)
400 #define yydebug (parser->parser_yydebug)
401 #ifdef RIPPER
402 #else
403 #define ruby_eval_tree (parser->parser_eval_tree)
404 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin)
405 #define ruby_debug_lines (parser->debug_lines)
406 #define ruby_coverage (parser->coverage)
407 #endif
408 
409 #if YYPURE
410 static int yylex(void*, void*);
411 #else
412 static int yylex(void*);
413 #endif
414 
415 #ifndef RIPPER
416 #define yyparse ruby_yyparse
417 
418 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
419 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
420 
421 static NODE *cond_gen(struct parser_params*,NODE*);
422 #define cond(node) cond_gen(parser, (node))
423 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
424 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
425 
426 static NODE *newline_node(NODE*);
427 static void fixpos(NODE*,NODE*);
428 
429 static int value_expr_gen(struct parser_params*,NODE*);
430 static void void_expr_gen(struct parser_params*,NODE*);
431 static NODE *remove_begin(NODE*);
432 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
433 #define void_expr0(node) void_expr_gen(parser, (node))
434 #define void_expr(node) void_expr0((node) = remove_begin(node))
435 static void void_stmts_gen(struct parser_params*,NODE*);
436 #define void_stmts(node) void_stmts_gen(parser, (node))
437 static void reduce_nodes_gen(struct parser_params*,NODE**);
438 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
439 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
440 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
441 
442 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
443 #define block_append(h,t) block_append_gen(parser,(h),(t))
444 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
445 #define list_append(l,i) list_append_gen(parser,(l),(i))
446 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
447 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
448 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
449 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
450 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
451 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
452 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
453 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
454 static int literal_concat0(struct parser_params *, VALUE, VALUE);
455 static NODE *new_evstr_gen(struct parser_params*,NODE*);
456 #define new_evstr(n) new_evstr_gen(parser,(n))
457 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
458 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
459 static NODE *splat_array(NODE*);
460 
461 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
462 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
463 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
464 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
465 
466 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
467 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
468 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);
469 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
470 
471 static NODE *negate_lit(NODE*);
472 static NODE *ret_args_gen(struct parser_params*,NODE*);
473 #define ret_args(node) ret_args_gen(parser, (node))
474 static NODE *arg_blk_pass(NODE*,NODE*);
475 static NODE *new_yield_gen(struct parser_params*,NODE*);
476 #define new_yield(node) new_yield_gen(parser, (node))
477 static NODE *dsym_node_gen(struct parser_params*,NODE*);
478 #define dsym_node(node) dsym_node_gen(parser, (node))
479 
480 static NODE *gettable_gen(struct parser_params*,ID);
481 #define gettable(id) gettable_gen(parser,(id))
482 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
483 #define assignable(id,node) assignable_gen(parser, (id), (node))
484 
485 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
486 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
487 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
488 #define attrset(node,id) attrset_gen(parser, (node), (id))
489 
490 static void rb_backref_error_gen(struct parser_params*,NODE*);
491 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
492 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
493 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
494 
495 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
496 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
497 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
498 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
499 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
500 
501 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
502 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
503 
504 static ID *local_tbl_gen(struct parser_params*);
505 #define local_tbl() local_tbl_gen(parser)
506 
507 static void fixup_nodes(NODE **);
508 
509 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
510 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
511 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
512 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
513 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
514 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
515 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
516 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
517 
518 #define get_id(id) (id)
519 #define get_value(val) (val)
520 #else
521 #define value_expr(node) ((void)(node))
522 #define remove_begin(node) (node)
523 #define rb_dvar_defined(id) 0
524 #define rb_local_defined(id) 0
525 static ID ripper_get_id(VALUE);
526 #define get_id(id) ripper_get_id(id)
527 static VALUE ripper_get_value(VALUE);
528 #define get_value(val) ripper_get_value(val)
529 static VALUE assignable_gen(struct parser_params*,VALUE);
530 #define assignable(lhs,node) assignable_gen(parser, (lhs))
531 static int id_is_var_gen(struct parser_params *parser, ID id);
532 #define id_is_var(id) id_is_var_gen(parser, (id))
533 
534 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2))
535 
536 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
537 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);
538 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
539 
540 #endif /* !RIPPER */
541 
542 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
543 
544 static ID formal_argument_gen(struct parser_params*, ID);
545 #define formal_argument(id) formal_argument_gen(parser, (id))
546 static ID shadowing_lvar_gen(struct parser_params*,ID);
547 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
548 static void new_bv_gen(struct parser_params*,ID);
549 #define new_bv(id) new_bv_gen(parser, (id))
550 
551 static void local_push_gen(struct parser_params*,int);
552 #define local_push(top) local_push_gen(parser,(top))
553 static void local_pop_gen(struct parser_params*);
554 #define local_pop() local_pop_gen(parser)
555 static int local_var_gen(struct parser_params*, ID);
556 #define local_var(id) local_var_gen(parser, (id))
557 static int arg_var_gen(struct parser_params*, ID);
558 #define arg_var(id) arg_var_gen(parser, (id))
559 static int local_id_gen(struct parser_params*, ID);
560 #define local_id(id) local_id_gen(parser, (id))
561 static ID internal_id_gen(struct parser_params*);
562 #define internal_id() internal_id_gen(parser)
563 
564 static const struct vtable *dyna_push_gen(struct parser_params *);
565 #define dyna_push() dyna_push_gen(parser)
566 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
567 #define dyna_pop(node) dyna_pop_gen(parser, (node))
568 static int dyna_in_block_gen(struct parser_params*);
569 #define dyna_in_block() dyna_in_block_gen(parser)
570 #define dyna_var(id) local_var(id)
571 static int dvar_defined_gen(struct parser_params*,ID,int);
572 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
573 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
574 static int dvar_curr_gen(struct parser_params*,ID);
575 #define dvar_curr(id) dvar_curr_gen(parser, (id))
576 
577 static int lvar_defined_gen(struct parser_params*, ID);
578 #define lvar_defined(id) lvar_defined_gen(parser, (id))
579 
580 #define RE_OPTION_ONCE (1<<16)
581 #define RE_OPTION_ENCODING_SHIFT 8
582 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
583 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
584 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
585 #define RE_OPTION_MASK 0xff
586 #define RE_OPTION_ARG_ENCODING_NONE 32
587 
588 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
589 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
590 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
591 #define nd_func u1.id
592 #if SIZEOF_SHORT == 2
593 #define nd_term(node) ((signed short)(node)->u2.id)
594 #else
595 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
596 #endif
597 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
598 #define nd_nest u3.cnt
599 
600 /****** Ripper *******/
601 
602 #ifdef RIPPER
603 #define RIPPER_VERSION "0.1.0"
604 
605 #include "eventids1.c"
606 #include "eventids2.c"
607 
608 static VALUE ripper_dispatch0(struct parser_params*,ID);
609 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
610 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
611 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
612 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
613 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
614 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
615 
616 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
617 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
618 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
619 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
620 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
621 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
622 #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))
623 
624 #define yyparse ripper_yyparse
625 
626 #define ripper_intern(s) ID2SYM(rb_intern(s))
627 static VALUE ripper_id2sym(ID);
628 #ifdef __GNUC__
629 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
630  ID2SYM(id) : ripper_id2sym(id))
631 #endif
632 
633 #define arg_new() dispatch0(args_new)
634 #define arg_add(l,a) dispatch2(args_add, (l), (a))
635 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
636 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
637 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
638 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
639 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
640 
641 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
642 #define mrhs_new() dispatch0(mrhs_new)
643 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
644 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
645 
646 #define mlhs_new() dispatch0(mlhs_new)
647 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
648 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
649 
650 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
651  dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
652 
653 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
654 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
655 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
656 
657 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
658 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
659 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
660 
661 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
662 
663 static inline VALUE
664 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
665 {
666  NODE *t = (NODE *)tail;
667  VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
668  return params_new(f, o, r, p, k, kr, escape_Qundef(b));
669 }
670 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
671 
672 static inline VALUE
673 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
674 {
675  return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);
676 }
677 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
678 
679 #define FIXME 0
680 
681 #endif /* RIPPER */
682 
683 #ifndef RIPPER
684 # define Qnone 0
685 # define ifndef_ripper(x) (x)
686 #else
687 # define Qnone Qnil
688 # define ifndef_ripper(x)
689 #endif
690 
691 #ifndef RIPPER
692 # define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
693 # define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
694 # define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
695 # define rb_warn4S(file,line,fmt,a) rb_compile_warn((file), (line), (fmt), (a))
696 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
697 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
698 #else
699 # define rb_warn0(fmt) ripper_warn0(parser, (fmt))
700 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))
701 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))
702 # define rb_warn4S(file,line,fmt,a) ripper_warnS(parser, (fmt), (a))
703 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
704 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
705 static void ripper_warn0(struct parser_params*, const char*);
706 static void ripper_warnI(struct parser_params*, const char*, int);
707 static void ripper_warnS(struct parser_params*, const char*, const char*);
708 static void ripper_warning0(struct parser_params*, const char*);
709 static void ripper_warningS(struct parser_params*, const char*, const char*);
710 #endif
711 
712 #ifdef RIPPER
713 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
714 # define rb_compile_error ripper_compile_error
715 # define compile_error ripper_compile_error
716 # define PARSER_ARG parser,
717 #else
718 # define rb_compile_error rb_compile_error_with_enc
719 # define compile_error parser->nerr++,rb_compile_error_with_enc
720 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
721 #endif
722 
723 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
724  for instance). This is too low for Ruby to parse some files, such as
725  date/format.rb, therefore bump the value up to at least Bison's default. */
726 #ifdef OLD_YACC
727 #ifndef YYMAXDEPTH
728 #define YYMAXDEPTH 10000
729 #endif
730 #endif
731 
732 #ifndef RIPPER
733 static void token_info_push(struct parser_params*, const char *token);
734 static void token_info_pop(struct parser_params*, const char *token);
735 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
736 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
737 #else
738 #define token_info_push(token) /* nothing */
739 #define token_info_pop(token) /* nothing */
740 #endif
741 
742 
743 /* Line 268 of yacc.c */
744 #line 745 "parse.c"
745 
746 /* Enabling traces. */
747 #ifndef YYDEBUG
748 # define YYDEBUG 0
749 #endif
750 
751 /* Enabling verbose error messages. */
752 #ifdef YYERROR_VERBOSE
753 # undef YYERROR_VERBOSE
754 # define YYERROR_VERBOSE 1
755 #else
756 # define YYERROR_VERBOSE 0
757 #endif
758 
759 /* Enabling the token table. */
760 #ifndef YYTOKEN_TABLE
761 # define YYTOKEN_TABLE 0
762 #endif
763 
764 
765 /* Tokens. */
766 #ifndef YYTOKENTYPE
767 # define YYTOKENTYPE
768  /* Put the tokens into the symbol table, so that GDB and other debuggers
769  know about them. */
770  enum yytokentype {
774  keyword_def = 260,
779  keyword_end = 265,
780  keyword_if = 266,
789  keyword_for = 275,
794  keyword_in = 280,
795  keyword_do = 281,
803  keyword_nil = 289,
806  keyword_and = 292,
807  keyword_or = 293,
808  keyword_not = 294,
809  modifier_if = 295,
817  keyword_END = 303,
821  tIDENTIFIER = 307,
822  tFID = 308,
823  tGVAR = 309,
824  tIVAR = 310,
825  tCONSTANT = 311,
826  tCVAR = 312,
827  tLABEL = 313,
828  tINTEGER = 314,
829  tFLOAT = 315,
831  tCHAR = 317,
832  tNTH_REF = 318,
833  tBACK_REF = 319,
834  tREGEXP_END = 320,
835  tUPLUS = 130,
836  tUMINUS = 131,
837  tPOW = 132,
838  tCMP = 134,
839  tEQ = 139,
840  tEQQ = 140,
841  tNEQ = 141,
842  tGEQ = 138,
843  tLEQ = 137,
844  tANDOP = 321,
845  tOROP = 322,
846  tMATCH = 142,
847  tNMATCH = 143,
848  tDOT2 = 128,
849  tDOT3 = 129,
850  tAREF = 144,
851  tASET = 145,
852  tLSHFT = 135,
853  tRSHFT = 136,
854  tCOLON2 = 323,
855  tCOLON3 = 324,
856  tOP_ASGN = 325,
857  tASSOC = 326,
858  tLPAREN = 327,
859  tLPAREN_ARG = 328,
860  tRPAREN = 329,
861  tLBRACK = 330,
862  tLBRACE = 331,
863  tLBRACE_ARG = 332,
864  tSTAR = 333,
865  tDSTAR = 334,
866  tAMPER = 335,
867  tLAMBDA = 336,
868  tSYMBEG = 337,
869  tSTRING_BEG = 338,
871  tREGEXP_BEG = 340,
872  tWORDS_BEG = 341,
873  tQWORDS_BEG = 342,
879  tSTRING_END = 348,
880  tLAMBEG = 349,
881  tLOWEST = 350,
882  tUMINUS_NUM = 351,
884  };
885 #endif
886 
887 
888 
889 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
890 typedef union YYSTYPE
891 {
892 
893 /* Line 293 of yacc.c */
894 #line 689 "parse.y"
895 
896  VALUE val;
897  NODE *node;
898  ID id;
899  int num;
900  const struct vtable *vars;
901 
902 
903 
904 /* Line 293 of yacc.c */
905 #line 906 "parse.c"
906 } YYSTYPE;
907 # define YYSTYPE_IS_TRIVIAL 1
908 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
909 # define YYSTYPE_IS_DECLARED 1
910 #endif
911 
912 
913 /* Copy the second part of user declarations. */
914 
915 
916 /* Line 343 of yacc.c */
917 #line 918 "parse.c"
918 
919 #ifdef short
920 # undef short
921 #endif
922 
923 #ifdef YYTYPE_UINT8
924 typedef YYTYPE_UINT8 yytype_uint8;
925 #else
926 typedef unsigned char yytype_uint8;
927 #endif
928 
929 #ifdef YYTYPE_INT8
930 typedef YYTYPE_INT8 yytype_int8;
931 #elif (defined __STDC__ || defined __C99__FUNC__ \
932  || defined __cplusplus || defined _MSC_VER)
933 typedef signed char yytype_int8;
934 #else
935 typedef short int yytype_int8;
936 #endif
937 
938 #ifdef YYTYPE_UINT16
939 typedef YYTYPE_UINT16 yytype_uint16;
940 #else
941 typedef unsigned short int yytype_uint16;
942 #endif
943 
944 #ifdef YYTYPE_INT16
945 typedef YYTYPE_INT16 yytype_int16;
946 #else
947 typedef short int yytype_int16;
948 #endif
949 
950 #ifndef YYSIZE_T
951 # ifdef __SIZE_TYPE__
952 # define YYSIZE_T __SIZE_TYPE__
953 # elif defined size_t
954 # define YYSIZE_T size_t
955 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
956  || defined __cplusplus || defined _MSC_VER)
957 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
958 # define YYSIZE_T size_t
959 # else
960 # define YYSIZE_T unsigned int
961 # endif
962 #endif
963 
964 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
965 
966 #ifndef YY_
967 # if defined YYENABLE_NLS && YYENABLE_NLS
968 # if ENABLE_NLS
969 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
970 # define YY_(msgid) dgettext ("bison-runtime", msgid)
971 # endif
972 # endif
973 # ifndef YY_
974 # define YY_(msgid) msgid
975 # endif
976 #endif
977 
978 /* Suppress unused-variable warnings by "using" E. */
979 #if ! defined lint || defined __GNUC__
980 # define YYUSE(e) ((void) (e))
981 #else
982 # define YYUSE(e) /* empty */
983 #endif
984 
985 /* Identity function, used to suppress warnings about constant conditions. */
986 #ifndef lint
987 # define YYID(n) (n)
988 #else
989 #if (defined __STDC__ || defined __C99__FUNC__ \
990  || defined __cplusplus || defined _MSC_VER)
991 static int
992 YYID (int yyi)
993 #else
994 static int
995 YYID (yyi)
996  int yyi;
997 #endif
998 {
999  return yyi;
1000 }
1001 #endif
1002 
1003 #if ! defined yyoverflow || YYERROR_VERBOSE
1004 
1005 /* The parser invokes alloca or malloc; define the necessary symbols. */
1006 
1007 # ifdef YYSTACK_USE_ALLOCA
1008 # if YYSTACK_USE_ALLOCA
1009 # ifdef __GNUC__
1010 # define YYSTACK_ALLOC __builtin_alloca
1011 # elif defined __BUILTIN_VA_ARG_INCR
1012 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1013 # elif defined _AIX
1014 # define YYSTACK_ALLOC __alloca
1015 # elif defined _MSC_VER
1016 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1017 # define alloca _alloca
1018 # else
1019 # define YYSTACK_ALLOC alloca
1020 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1021  || defined __cplusplus || defined _MSC_VER)
1022 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1023 # ifndef EXIT_SUCCESS
1024 # define EXIT_SUCCESS 0
1025 # endif
1026 # endif
1027 # endif
1028 # endif
1029 # endif
1030 
1031 # ifdef YYSTACK_ALLOC
1032  /* Pacify GCC's `empty if-body' warning. */
1033 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1034 # ifndef YYSTACK_ALLOC_MAXIMUM
1035  /* The OS might guarantee only one guard page at the bottom of the stack,
1036  and a page size can be as small as 4096 bytes. So we cannot safely
1037  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1038  to allow for a few compiler-allocated temporary stack slots. */
1039 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1040 # endif
1041 # else
1042 # define YYSTACK_ALLOC YYMALLOC
1043 # define YYSTACK_FREE YYFREE
1044 # ifndef YYSTACK_ALLOC_MAXIMUM
1045 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1046 # endif
1047 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
1048  && ! ((defined YYMALLOC || defined malloc) \
1049  && (defined YYFREE || defined free)))
1050 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1051 # ifndef EXIT_SUCCESS
1052 # define EXIT_SUCCESS 0
1053 # endif
1054 # endif
1055 # ifndef YYMALLOC
1056 # define YYMALLOC malloc
1057 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1058  || defined __cplusplus || defined _MSC_VER)
1059 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1060 # endif
1061 # endif
1062 # ifndef YYFREE
1063 # define YYFREE free
1064 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1065  || defined __cplusplus || defined _MSC_VER)
1066 void free (void *); /* INFRINGES ON USER NAME SPACE */
1067 # endif
1068 # endif
1069 # endif
1070 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1071 
1072 
1073 #if (! defined yyoverflow \
1074  && (! defined __cplusplus \
1075  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1076 
1077 /* A type that is properly aligned for any stack member. */
1078 union yyalloc
1079 {
1080  yytype_int16 yyss_alloc;
1082 };
1083 
1084 /* The size of the maximum gap between one aligned stack and the next. */
1085 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1086 
1087 /* The size of an array large to enough to hold all stacks, each with
1088  N elements. */
1089 # define YYSTACK_BYTES(N) \
1090  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1091  + YYSTACK_GAP_MAXIMUM)
1092 
1093 # define YYCOPY_NEEDED 1
1094 
1095 /* Relocate STACK from its old location to the new one. The
1096  local variables YYSIZE and YYSTACKSIZE give the old and new number of
1097  elements in the stack, and YYPTR gives the new location of the
1098  stack. Advance YYPTR to a properly aligned location for the next
1099  stack. */
1100 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1101  do \
1102  { \
1103  YYSIZE_T yynewbytes; \
1104  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1105  Stack = &yyptr->Stack_alloc; \
1106  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1107  yyptr += yynewbytes / sizeof (*yyptr); \
1108  } \
1109  while (YYID (0))
1110 
1111 #endif
1112 
1113 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1114 /* Copy COUNT objects from FROM to TO. The source and destination do
1115  not overlap. */
1116 # ifndef YYCOPY
1117 # if defined __GNUC__ && 1 < __GNUC__
1118 # define YYCOPY(To, From, Count) \
1119  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1120 # else
1121 # define YYCOPY(To, From, Count) \
1122  do \
1123  { \
1124  YYSIZE_T yyi; \
1125  for (yyi = 0; yyi < (Count); yyi++) \
1126  (To)[yyi] = (From)[yyi]; \
1127  } \
1128  while (YYID (0))
1129 # endif
1130 # endif
1131 #endif /* !YYCOPY_NEEDED */
1132 
1133 /* YYFINAL -- State number of the termination state. */
1134 #define YYFINAL 3
1135 /* YYLAST -- Last index in YYTABLE. */
1136 #define YYLAST 11084
1137 
1138 /* YYNTOKENS -- Number of terminals. */
1139 #define YYNTOKENS 142
1140 /* YYNNTS -- Number of nonterminals. */
1141 #define YYNNTS 198
1142 /* YYNRULES -- Number of rules. */
1143 #define YYNRULES 619
1144 /* YYNRULES -- Number of states. */
1145 #define YYNSTATES 1056
1146 
1147 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1148 #define YYUNDEFTOK 2
1149 #define YYMAXUTOK 352
1150 
1151 #define YYTRANSLATE(YYX) \
1152  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1153 
1154 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1155 static const yytype_uint8 yytranslate[] =
1156 {
1157  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1158  141, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1159  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1160  2, 2, 140, 127, 2, 2, 2, 125, 120, 2,
1161  136, 137, 123, 121, 134, 122, 133, 124, 2, 2,
1162  2, 2, 2, 2, 2, 2, 2, 2, 115, 139,
1163  117, 113, 116, 114, 2, 2, 2, 2, 2, 2,
1164  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1165  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1166  2, 132, 2, 138, 119, 2, 135, 2, 2, 2,
1167  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1168  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1169  2, 2, 2, 130, 118, 131, 128, 2, 79, 80,
1170  66, 67, 68, 2, 69, 83, 84, 74, 73, 70,
1171  71, 72, 77, 78, 81, 82, 2, 2, 2, 2,
1172  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1173  2, 2, 2, 2, 2, 2, 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, 1, 2, 3, 4,
1183  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1184  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1185  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1186  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1187  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1188  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1189  65, 75, 76, 85, 86, 87, 88, 89, 90, 91,
1190  92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
1191  102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
1192  112, 126, 129
1193 };
1194 
1195 #if YYDEBUG
1196 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1197  YYRHS. */
1198 static const yytype_uint16 yyprhs[] =
1199 {
1200  0, 0, 3, 4, 7, 10, 12, 14, 18, 21,
1201  23, 24, 30, 35, 38, 40, 42, 46, 49, 51,
1202  52, 58, 59, 64, 68, 72, 76, 79, 83, 87,
1203  91, 95, 99, 104, 106, 110, 114, 121, 127, 133,
1204  139, 145, 149, 153, 157, 161, 163, 167, 171, 173,
1205  177, 181, 185, 188, 190, 192, 194, 196, 198, 203,
1206  204, 210, 212, 215, 219, 224, 230, 235, 241, 244,
1207  247, 250, 253, 256, 258, 262, 264, 268, 270, 273,
1208  277, 283, 286, 291, 294, 299, 301, 305, 307, 311,
1209  314, 318, 320, 324, 326, 328, 333, 337, 341, 345,
1210  349, 352, 354, 356, 358, 363, 367, 371, 375, 379,
1211  382, 384, 386, 388, 391, 393, 397, 399, 401, 403,
1212  405, 407, 409, 411, 413, 415, 417, 418, 423, 425,
1213  427, 429, 431, 433, 435, 437, 439, 441, 443, 445,
1214  447, 449, 451, 453, 455, 457, 459, 461, 463, 465,
1215  467, 469, 471, 473, 475, 477, 479, 481, 483, 485,
1216  487, 489, 491, 493, 495, 497, 499, 501, 503, 505,
1217  507, 509, 511, 513, 515, 517, 519, 521, 523, 525,
1218  527, 529, 531, 533, 535, 537, 539, 541, 543, 545,
1219  547, 549, 551, 553, 555, 557, 559, 561, 563, 565,
1220  569, 575, 579, 585, 592, 598, 604, 610, 616, 621,
1221  625, 629, 633, 637, 641, 645, 649, 653, 657, 662,
1222  667, 670, 673, 677, 681, 685, 689, 693, 697, 701,
1223  705, 709, 713, 717, 721, 725, 728, 731, 735, 739,
1224  743, 747, 748, 753, 760, 762, 764, 766, 769, 774,
1225  777, 781, 783, 785, 787, 789, 792, 797, 800, 802,
1226  805, 808, 813, 815, 816, 819, 822, 825, 827, 829,
1227  832, 836, 841, 845, 850, 853, 855, 857, 859, 861,
1228  863, 865, 867, 869, 871, 873, 875, 876, 881, 882,
1229  886, 887, 892, 896, 900, 903, 907, 911, 913, 918,
1230  922, 924, 925, 932, 937, 941, 944, 946, 949, 952,
1231  959, 966, 967, 968, 976, 977, 978, 986, 992, 997,
1232  998, 999, 1009, 1010, 1017, 1018, 1019, 1028, 1029, 1035,
1233  1036, 1043, 1044, 1045, 1055, 1057, 1059, 1061, 1063, 1065,
1234  1067, 1069, 1071, 1073, 1075, 1077, 1079, 1081, 1083, 1085,
1235  1087, 1089, 1091, 1094, 1096, 1098, 1100, 1106, 1108, 1111,
1236  1113, 1115, 1117, 1121, 1123, 1127, 1129, 1134, 1141, 1145,
1237  1151, 1154, 1159, 1161, 1165, 1170, 1173, 1176, 1178, 1181,
1238  1182, 1189, 1198, 1203, 1210, 1215, 1218, 1225, 1228, 1233,
1239  1240, 1243, 1248, 1251, 1256, 1258, 1260, 1262, 1266, 1268,
1240  1273, 1275, 1280, 1282, 1286, 1288, 1290, 1291, 1292, 1293,
1241  1299, 1304, 1306, 1310, 1314, 1315, 1321, 1324, 1329, 1335,
1242  1341, 1344, 1345, 1351, 1352, 1358, 1362, 1363, 1368, 1369,
1243  1374, 1377, 1379, 1384, 1385, 1391, 1392, 1398, 1404, 1406,
1244  1408, 1415, 1417, 1419, 1421, 1423, 1426, 1428, 1431, 1433,
1245  1435, 1437, 1439, 1441, 1443, 1445, 1448, 1452, 1456, 1460,
1246  1464, 1468, 1469, 1473, 1475, 1478, 1482, 1486, 1487, 1491,
1247  1495, 1499, 1503, 1507, 1508, 1512, 1513, 1517, 1518, 1521,
1248  1522, 1525, 1526, 1529, 1531, 1532, 1536, 1537, 1538, 1539,
1249  1546, 1548, 1550, 1552, 1554, 1557, 1559, 1561, 1563, 1565,
1250  1569, 1571, 1573, 1576, 1579, 1581, 1583, 1585, 1587, 1589,
1251  1591, 1593, 1595, 1597, 1599, 1601, 1603, 1605, 1607, 1609,
1252  1611, 1613, 1615, 1617, 1618, 1623, 1626, 1630, 1633, 1638,
1253  1641, 1644, 1646, 1649, 1650, 1657, 1666, 1671, 1678, 1683,
1254  1690, 1693, 1698, 1705, 1708, 1713, 1716, 1721, 1723, 1724,
1255  1726, 1728, 1730, 1732, 1734, 1736, 1738, 1742, 1744, 1748,
1256  1751, 1754, 1756, 1760, 1762, 1766, 1768, 1770, 1773, 1775,
1257  1779, 1783, 1785, 1789, 1791, 1795, 1797, 1799, 1802, 1804,
1258  1806, 1808, 1811, 1814, 1816, 1818, 1819, 1824, 1826, 1829,
1259  1831, 1835, 1839, 1842, 1845, 1847, 1849, 1851, 1853, 1855,
1260  1857, 1859, 1861, 1863, 1865, 1867, 1869, 1870, 1872, 1873,
1261  1875, 1878, 1881, 1882, 1884, 1886, 1888, 1890, 1892, 1895
1262 };
1263 
1264 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1265 static const yytype_int16 yyrhs[] =
1266 {
1267  143, 0, -1, -1, 144, 145, -1, 146, 332, -1,
1268  339, -1, 147, -1, 146, 338, 147, -1, 1, 147,
1269  -1, 154, -1, -1, 47, 148, 130, 145, 131, -1,
1270  150, 261, 229, 264, -1, 151, 332, -1, 339, -1,
1271  152, -1, 151, 338, 152, -1, 1, 154, -1, 154,
1272  -1, -1, 47, 153, 130, 145, 131, -1, -1, 45,
1273  177, 155, 177, -1, 45, 54, 54, -1, 45, 54,
1274  64, -1, 45, 54, 63, -1, 6, 178, -1, 154,
1275  40, 158, -1, 154, 41, 158, -1, 154, 42, 158,
1276  -1, 154, 43, 158, -1, 154, 44, 154, -1, 48,
1277  130, 150, 131, -1, 156, -1, 165, 113, 159, -1,
1278  296, 87, 159, -1, 214, 132, 188, 335, 87, 159,
1279  -1, 214, 133, 52, 87, 159, -1, 214, 133, 56,
1280  87, 159, -1, 214, 85, 56, 87, 159, -1, 214,
1281  85, 52, 87, 159, -1, 297, 87, 159, -1, 172,
1282  113, 195, -1, 165, 113, 184, -1, 165, 113, 195,
1283  -1, 157, -1, 172, 113, 159, -1, 172, 113, 156,
1284  -1, 159, -1, 157, 37, 157, -1, 157, 38, 157,
1285  -1, 39, 333, 157, -1, 127, 159, -1, 182, -1,
1286  157, -1, 164, -1, 160, -1, 250, -1, 250, 331,
1287  329, 190, -1, -1, 94, 162, 237, 150, 131, -1,
1288  328, -1, 163, 190, -1, 163, 190, 161, -1, 214,
1289  133, 329, 190, -1, 214, 133, 329, 190, 161, -1,
1290  214, 85, 329, 190, -1, 214, 85, 329, 190, 161,
1291  -1, 32, 190, -1, 31, 190, -1, 30, 189, -1,
1292  21, 189, -1, 22, 189, -1, 167, -1, 89, 166,
1293  334, -1, 167, -1, 89, 166, 334, -1, 169, -1,
1294  169, 168, -1, 169, 95, 171, -1, 169, 95, 171,
1295  134, 170, -1, 169, 95, -1, 169, 95, 134, 170,
1296  -1, 95, 171, -1, 95, 171, 134, 170, -1, 95,
1297  -1, 95, 134, 170, -1, 171, -1, 89, 166, 334,
1298  -1, 168, 134, -1, 169, 168, 134, -1, 168, -1,
1299  170, 134, 168, -1, 293, -1, 294, -1, 214, 132,
1300  188, 335, -1, 214, 133, 52, -1, 214, 85, 52,
1301  -1, 214, 133, 56, -1, 214, 85, 56, -1, 86,
1302  56, -1, 297, -1, 293, -1, 294, -1, 214, 132,
1303  188, 335, -1, 214, 133, 52, -1, 214, 85, 52,
1304  -1, 214, 133, 56, -1, 214, 85, 56, -1, 86,
1305  56, -1, 297, -1, 52, -1, 56, -1, 86, 173,
1306  -1, 173, -1, 214, 85, 173, -1, 52, -1, 56,
1307  -1, 53, -1, 180, -1, 181, -1, 175, -1, 289,
1308  -1, 176, -1, 291, -1, 177, -1, -1, 178, 134,
1309  179, 177, -1, 118, -1, 119, -1, 120, -1, 69,
1310  -1, 70, -1, 71, -1, 77, -1, 78, -1, 116,
1311  -1, 73, -1, 117, -1, 74, -1, 72, -1, 83,
1312  -1, 84, -1, 121, -1, 122, -1, 123, -1, 95,
1313  -1, 124, -1, 125, -1, 68, -1, 96, -1, 127,
1314  -1, 128, -1, 66, -1, 67, -1, 81, -1, 82,
1315  -1, 135, -1, 49, -1, 50, -1, 51, -1, 47,
1316  -1, 48, -1, 45, -1, 37, -1, 7, -1, 21,
1317  -1, 16, -1, 3, -1, 5, -1, 46, -1, 26,
1318  -1, 15, -1, 14, -1, 10, -1, 9, -1, 36,
1319  -1, 20, -1, 25, -1, 4, -1, 22, -1, 34,
1320  -1, 39, -1, 38, -1, 23, -1, 8, -1, 24,
1321  -1, 30, -1, 33, -1, 32, -1, 13, -1, 35,
1322  -1, 6, -1, 17, -1, 31, -1, 11, -1, 12,
1323  -1, 18, -1, 19, -1, 172, 113, 182, -1, 172,
1324  113, 182, 44, 182, -1, 296, 87, 182, -1, 296,
1325  87, 182, 44, 182, -1, 214, 132, 188, 335, 87,
1326  182, -1, 214, 133, 52, 87, 182, -1, 214, 133,
1327  56, 87, 182, -1, 214, 85, 52, 87, 182, -1,
1328  214, 85, 56, 87, 182, -1, 86, 56, 87, 182,
1329  -1, 297, 87, 182, -1, 182, 79, 182, -1, 182,
1330  80, 182, -1, 182, 121, 182, -1, 182, 122, 182,
1331  -1, 182, 123, 182, -1, 182, 124, 182, -1, 182,
1332  125, 182, -1, 182, 68, 182, -1, 126, 59, 68,
1333  182, -1, 126, 60, 68, 182, -1, 66, 182, -1,
1334  67, 182, -1, 182, 118, 182, -1, 182, 119, 182,
1335  -1, 182, 120, 182, -1, 182, 69, 182, -1, 182,
1336  116, 182, -1, 182, 73, 182, -1, 182, 117, 182,
1337  -1, 182, 74, 182, -1, 182, 70, 182, -1, 182,
1338  71, 182, -1, 182, 72, 182, -1, 182, 77, 182,
1339  -1, 182, 78, 182, -1, 127, 182, -1, 128, 182,
1340  -1, 182, 83, 182, -1, 182, 84, 182, -1, 182,
1341  75, 182, -1, 182, 76, 182, -1, -1, 46, 333,
1342  183, 182, -1, 182, 114, 182, 333, 115, 182, -1,
1343  196, -1, 182, -1, 339, -1, 194, 336, -1, 194,
1344  134, 326, 336, -1, 326, 336, -1, 136, 188, 334,
1345  -1, 339, -1, 186, -1, 339, -1, 189, -1, 194,
1346  134, -1, 194, 134, 326, 134, -1, 326, 134, -1,
1347  164, -1, 194, 193, -1, 326, 193, -1, 194, 134,
1348  326, 193, -1, 192, -1, -1, 191, 189, -1, 97,
1349  184, -1, 134, 192, -1, 339, -1, 184, -1, 95,
1350  184, -1, 194, 134, 184, -1, 194, 134, 95, 184,
1351  -1, 194, 134, 184, -1, 194, 134, 95, 184, -1,
1352  95, 184, -1, 265, -1, 266, -1, 269, -1, 270,
1353  -1, 271, -1, 276, -1, 274, -1, 277, -1, 295,
1354  -1, 297, -1, 53, -1, -1, 215, 197, 149, 225,
1355  -1, -1, 90, 198, 334, -1, -1, 90, 157, 199,
1356  334, -1, 89, 150, 137, -1, 214, 85, 56, -1,
1357  86, 56, -1, 92, 185, 138, -1, 93, 325, 131,
1358  -1, 30, -1, 31, 136, 189, 334, -1, 31, 136,
1359  334, -1, 31, -1, -1, 46, 333, 136, 200, 157,
1360  334, -1, 39, 136, 157, 334, -1, 39, 136, 334,
1361  -1, 163, 256, -1, 251, -1, 251, 256, -1, 98,
1362  242, -1, 216, 158, 226, 150, 228, 225, -1, 217,
1363  158, 226, 150, 229, 225, -1, -1, -1, 218, 201,
1364  158, 227, 202, 150, 225, -1, -1, -1, 219, 203,
1365  158, 227, 204, 150, 225, -1, 220, 158, 332, 259,
1366  225, -1, 220, 332, 259, 225, -1, -1, -1, 221,
1367  230, 25, 205, 158, 227, 206, 150, 225, -1, -1,
1368  222, 174, 298, 207, 149, 225, -1, -1, -1, 222,
1369  83, 157, 208, 337, 209, 149, 225, -1, -1, 223,
1370  174, 210, 149, 225, -1, -1, 224, 175, 211, 300,
1371  149, 225, -1, -1, -1, 224, 323, 331, 212, 175,
1372  213, 300, 149, 225, -1, 21, -1, 22, -1, 23,
1373  -1, 24, -1, 196, -1, 7, -1, 11, -1, 12,
1374  -1, 18, -1, 19, -1, 16, -1, 20, -1, 3,
1375  -1, 4, -1, 5, -1, 10, -1, 337, -1, 13,
1376  -1, 337, 13, -1, 337, -1, 27, -1, 229, -1,
1377  14, 158, 226, 150, 228, -1, 339, -1, 15, 150,
1378  -1, 172, -1, 165, -1, 305, -1, 89, 233, 334,
1379  -1, 231, -1, 232, 134, 231, -1, 232, -1, 232,
1380  134, 95, 305, -1, 232, 134, 95, 305, 134, 232,
1381  -1, 232, 134, 95, -1, 232, 134, 95, 134, 232,
1382  -1, 95, 305, -1, 95, 305, 134, 232, -1, 95,
1383  -1, 95, 134, 232, -1, 310, 134, 313, 322, -1,
1384  310, 322, -1, 313, 322, -1, 321, -1, 134, 234,
1385  -1, -1, 307, 134, 316, 134, 319, 235, -1, 307,
1386  134, 316, 134, 319, 134, 307, 235, -1, 307, 134,
1387  316, 235, -1, 307, 134, 316, 134, 307, 235, -1,
1388  307, 134, 319, 235, -1, 307, 134, -1, 307, 134,
1389  319, 134, 307, 235, -1, 307, 235, -1, 316, 134,
1390  319, 235, -1, 316, 134, 319, 134, 307, 235, -1,
1391  316, 235, -1, 316, 134, 307, 235, -1, 319, 235,
1392  -1, 319, 134, 307, 235, -1, 234, -1, 339, -1,
1393  238, -1, 118, 239, 118, -1, 76, -1, 118, 236,
1394  239, 118, -1, 333, -1, 333, 139, 240, 333, -1,
1395  241, -1, 240, 134, 241, -1, 52, -1, 304, -1,
1396  -1, -1, -1, 243, 244, 246, 245, 247, -1, 136,
1397  303, 239, 137, -1, 303, -1, 111, 150, 131, -1,
1398  29, 150, 10, -1, -1, 28, 249, 237, 150, 10,
1399  -1, 164, 248, -1, 250, 331, 329, 187, -1, 250,
1400  331, 329, 187, 256, -1, 250, 331, 329, 190, 248,
1401  -1, 163, 186, -1, -1, 214, 133, 329, 252, 187,
1402  -1, -1, 214, 85, 329, 253, 186, -1, 214, 85,
1403  330, -1, -1, 214, 133, 254, 186, -1, -1, 214,
1404  85, 255, 186, -1, 32, 186, -1, 32, -1, 214,
1405  132, 188, 335, -1, -1, 130, 257, 237, 150, 131,
1406  -1, -1, 26, 258, 237, 150, 10, -1, 17, 194,
1407  226, 150, 260, -1, 229, -1, 259, -1, 8, 262,
1408  263, 226, 150, 261, -1, 339, -1, 184, -1, 195,
1409  -1, 339, -1, 88, 172, -1, 339, -1, 9, 150,
1410  -1, 339, -1, 292, -1, 289, -1, 291, -1, 267,
1411  -1, 62, -1, 268, -1, 267, 268, -1, 100, 280,
1412  110, -1, 101, 281, 110, -1, 102, 282, 65, -1,
1413  103, 140, 110, -1, 103, 272, 110, -1, -1, 272,
1414  273, 140, -1, 283, -1, 273, 283, -1, 105, 140,
1415  110, -1, 105, 275, 110, -1, -1, 275, 273, 140,
1416  -1, 104, 140, 110, -1, 104, 278, 110, -1, 106,
1417  140, 110, -1, 106, 279, 110, -1, -1, 278, 61,
1418  140, -1, -1, 279, 61, 140, -1, -1, 280, 283,
1419  -1, -1, 281, 283, -1, -1, 282, 283, -1, 61,
1420  -1, -1, 109, 284, 288, -1, -1, -1, -1, 107,
1421  285, 286, 287, 150, 108, -1, 54, -1, 55, -1,
1422  57, -1, 297, -1, 99, 290, -1, 175, -1, 55,
1423  -1, 54, -1, 57, -1, 99, 281, 110, -1, 59,
1424  -1, 60, -1, 126, 59, -1, 126, 60, -1, 52,
1425  -1, 55, -1, 54, -1, 56, -1, 57, -1, 34,
1426  -1, 33, -1, 35, -1, 36, -1, 50, -1, 49,
1427  -1, 51, -1, 293, -1, 294, -1, 293, -1, 294,
1428  -1, 63, -1, 64, -1, 337, -1, -1, 117, 299,
1429  158, 337, -1, 1, 337, -1, 136, 303, 334, -1,
1430  303, 337, -1, 311, 134, 313, 322, -1, 311, 322,
1431  -1, 313, 322, -1, 321, -1, 134, 301, -1, -1,
1432  307, 134, 317, 134, 319, 302, -1, 307, 134, 317,
1433  134, 319, 134, 307, 302, -1, 307, 134, 317, 302,
1434  -1, 307, 134, 317, 134, 307, 302, -1, 307, 134,
1435  319, 302, -1, 307, 134, 319, 134, 307, 302, -1,
1436  307, 302, -1, 317, 134, 319, 302, -1, 317, 134,
1437  319, 134, 307, 302, -1, 317, 302, -1, 317, 134,
1438  307, 302, -1, 319, 302, -1, 319, 134, 307, 302,
1439  -1, 301, -1, -1, 56, -1, 55, -1, 54, -1,
1440  57, -1, 304, -1, 52, -1, 305, -1, 89, 233,
1441  334, -1, 306, -1, 307, 134, 306, -1, 58, 184,
1442  -1, 58, 214, -1, 309, -1, 310, 134, 309, -1,
1443  308, -1, 311, 134, 308, -1, 68, -1, 96, -1,
1444  312, 52, -1, 312, -1, 52, 113, 184, -1, 52,
1445  113, 214, -1, 315, -1, 316, 134, 315, -1, 314,
1446  -1, 317, 134, 314, -1, 123, -1, 95, -1, 318,
1447  52, -1, 318, -1, 120, -1, 97, -1, 320, 52,
1448  -1, 134, 321, -1, 339, -1, 295, -1, -1, 136,
1449  324, 157, 334, -1, 339, -1, 326, 336, -1, 327,
1450  -1, 326, 134, 327, -1, 184, 88, 184, -1, 58,
1451  184, -1, 96, 184, -1, 52, -1, 56, -1, 53,
1452  -1, 52, -1, 56, -1, 53, -1, 180, -1, 52,
1453  -1, 53, -1, 180, -1, 133, -1, 85, -1, -1,
1454  338, -1, -1, 141, -1, 333, 137, -1, 333, 138,
1455  -1, -1, 141, -1, 134, -1, 139, -1, 141, -1,
1456  337, -1, 338, 139, -1, -1
1457 };
1458 
1459 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1460 static const yytype_uint16 yyrline[] =
1461 {
1462  0, 853, 853, 853, 884, 895, 904, 912, 920, 926,
1463  928, 927, 948, 981, 992, 1001, 1009, 1017, 1023, 1028,
1464  1027, 1048, 1048, 1056, 1064, 1075, 1085, 1093, 1102, 1111,
1465  1124, 1137, 1146, 1158, 1159, 1169, 1174, 1195, 1200, 1205,
1466  1215, 1220, 1230, 1239, 1248, 1257, 1260, 1269, 1281, 1282,
1467  1290, 1298, 1306, 1314, 1317, 1329, 1330, 1333, 1334, 1346,
1468  1345, 1367, 1377, 1386, 1399, 1408, 1420, 1429, 1441, 1450,
1469  1459, 1467, 1475, 1485, 1486, 1496, 1497, 1507, 1515, 1523,
1470  1531, 1540, 1548, 1557, 1565, 1574, 1582, 1593, 1594, 1604,
1471  1612, 1622, 1630, 1640, 1644, 1648, 1656, 1664, 1672, 1680,
1472  1692, 1702, 1714, 1723, 1732, 1740, 1748, 1756, 1764, 1777,
1473  1790, 1801, 1809, 1812, 1820, 1828, 1838, 1839, 1840, 1841,
1474  1846, 1857, 1858, 1861, 1869, 1872, 1880, 1880, 1890, 1891,
1475  1892, 1893, 1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901,
1476  1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911,
1477  1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, 1922, 1922,
1478  1922, 1923, 1923, 1924, 1924, 1924, 1925, 1925, 1925, 1925,
1479  1926, 1926, 1926, 1926, 1927, 1927, 1927, 1928, 1928, 1928,
1480  1928, 1929, 1929, 1929, 1929, 1930, 1930, 1930, 1930, 1931,
1481  1931, 1931, 1931, 1932, 1932, 1932, 1932, 1933, 1933, 1936,
1482  1945, 1955, 1960, 1970, 1996, 2001, 2006, 2011, 2021, 2031,
1483  2042, 2056, 2070, 2078, 2086, 2094, 2102, 2110, 2118, 2127,
1484  2136, 2144, 2152, 2160, 2168, 2176, 2184, 2192, 2200, 2208,
1485  2216, 2224, 2232, 2240, 2251, 2259, 2267, 2275, 2283, 2291,
1486  2299, 2307, 2307, 2317, 2327, 2333, 2345, 2346, 2350, 2358,
1487  2368, 2378, 2379, 2382, 2383, 2384, 2388, 2396, 2406, 2415,
1488  2423, 2433, 2442, 2451, 2451, 2463, 2473, 2477, 2483, 2491,
1489  2499, 2513, 2529, 2543, 2558, 2568, 2569, 2570, 2571, 2572,
1490  2573, 2574, 2575, 2576, 2577, 2578, 2587, 2586, 2614, 2614,
1491  2622, 2622, 2630, 2638, 2646, 2654, 2667, 2675, 2683, 2691,
1492  2699, 2707, 2707, 2717, 2725, 2733, 2743, 2744, 2754, 2758,
1493  2770, 2782, 2782, 2782, 2793, 2793, 2793, 2804, 2815, 2824,
1494  2826, 2823, 2890, 2889, 2911, 2916, 2910, 2935, 2934, 2956,
1495  2955, 2978, 2979, 2978, 2999, 3007, 3015, 3023, 3033, 3045,
1496  3051, 3057, 3063, 3069, 3075, 3081, 3087, 3093, 3099, 3109,
1497  3115, 3120, 3121, 3128, 3133, 3136, 3137, 3150, 3151, 3161,
1498  3162, 3165, 3173, 3183, 3191, 3201, 3209, 3218, 3227, 3235,
1499  3243, 3252, 3264, 3272, 3283, 3287, 3291, 3295, 3301, 3306,
1500  3311, 3315, 3319, 3323, 3327, 3331, 3339, 3343, 3347, 3351,
1501  3355, 3359, 3363, 3367, 3371, 3377, 3378, 3384, 3393, 3402,
1502  3413, 3417, 3427, 3434, 3443, 3451, 3457, 3460, 3465, 3457,
1503  3481, 3489, 3499, 3503, 3510, 3509, 3530, 3546, 3555, 3567,
1504  3581, 3591, 3590, 3607, 3606, 3622, 3631, 3630, 3648, 3647,
1505  3664, 3672, 3680, 3695, 3694, 3714, 3713, 3734, 3746, 3747,
1506  3750, 3769, 3772, 3780, 3788, 3791, 3795, 3798, 3806, 3809,
1507  3810, 3818, 3821, 3838, 3839, 3840, 3850, 3860, 3887, 3952,
1508  3961, 3972, 3979, 3989, 3997, 4007, 4016, 4027, 4034, 4046,
1509  4055, 4065, 4074, 4085, 4092, 4103, 4110, 4125, 4132, 4143,
1510  4150, 4161, 4168, 4197, 4199, 4198, 4215, 4221, 4226, 4214,
1511  4245, 4253, 4261, 4269, 4272, 4283, 4284, 4285, 4286, 4289,
1512  4300, 4301, 4302, 4310, 4320, 4321, 4322, 4323, 4324, 4327,
1513  4328, 4329, 4330, 4331, 4332, 4333, 4336, 4349, 4359, 4367,
1514  4377, 4378, 4381, 4390, 4389, 4398, 4410, 4420, 4428, 4432,
1515  4436, 4440, 4446, 4451, 4456, 4460, 4464, 4468, 4472, 4476,
1516  4480, 4484, 4488, 4492, 4496, 4500, 4504, 4508, 4513, 4519,
1517  4528, 4537, 4546, 4557, 4558, 4565, 4574, 4593, 4600, 4613,
1518  4625, 4637, 4645, 4662, 4670, 4686, 4687, 4690, 4695, 4701,
1519  4713, 4725, 4733, 4749, 4757, 4773, 4774, 4777, 4790, 4801,
1520  4802, 4805, 4822, 4826, 4836, 4846, 4846, 4875, 4876, 4886,
1521  4893, 4903, 4911, 4919, 4931, 4932, 4933, 4936, 4937, 4938,
1522  4939, 4942, 4943, 4944, 4947, 4952, 4959, 4960, 4963, 4964,
1523  4967, 4970, 4973, 4974, 4975, 4978, 4979, 4982, 4983, 4987
1524 };
1525 #endif
1526 
1527 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1528 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1529  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1530 static const char *const yytname[] =
1531 {
1532  "\"end-of-input\"", "error", "$undefined", "keyword_class",
1533  "keyword_module", "keyword_def", "keyword_undef", "keyword_begin",
1534  "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if",
1535  "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else",
1536  "keyword_case", "keyword_when", "keyword_while", "keyword_until",
1537  "keyword_for", "keyword_break", "keyword_next", "keyword_redo",
1538  "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond",
1539  "keyword_do_block", "keyword_do_LAMBDA", "keyword_return",
1540  "keyword_yield", "keyword_super", "keyword_self", "keyword_nil",
1541  "keyword_true", "keyword_false", "keyword_and", "keyword_or",
1542  "keyword_not", "modifier_if", "modifier_unless", "modifier_while",
1543  "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined",
1544  "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__",
1545  "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR",
1546  "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tSTRING_CONTENT",
1547  "tCHAR", "tNTH_REF", "tBACK_REF", "tREGEXP_END", "\"unary+\"",
1548  "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"", "\"===\"", "\"!=\"",
1549  "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"", "\"!~\"", "\"..\"",
1550  "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"", "\"::\"",
1551  "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"", "\"( arg\"",
1552  "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"", "\"**arg\"", "\"&\"",
1553  "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG", "tREGEXP_BEG",
1554  "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG", "tQSYMBOLS_BEG",
1555  "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR", "tSTRING_END", "tLAMBEG",
1556  "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'", "'^'", "'&'", "'+'",
1557  "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'", "'~'", "tLAST_TOKEN",
1558  "'{'", "'}'", "'['", "'.'", "','", "'`'", "'('", "')'", "']'", "';'",
1559  "' '", "'\\n'", "$accept", "program", "$@1", "top_compstmt", "top_stmts",
1560  "top_stmt", "$@2", "bodystmt", "compstmt", "stmts", "stmt_or_begin",
1561  "$@3", "stmt", "$@4", "command_asgn", "expr", "expr_value",
1562  "command_call", "block_command", "cmd_brace_block", "@5", "fcall",
1563  "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head",
1564  "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
1565  "fitem", "undef_list", "$@6", "op", "reswords", "arg", "$@7",
1566  "arg_value", "aref_args", "paren_args", "opt_paren_args",
1567  "opt_call_args", "call_args", "command_args", "@8", "block_arg",
1568  "opt_block_arg", "args", "mrhs", "primary", "@9", "$@10", "$@11", "$@12",
1569  "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "@19", "@20", "@21",
1570  "@22", "@23", "$@24", "$@25", "primary_value", "k_begin", "k_if",
1571  "k_unless", "k_while", "k_until", "k_case", "k_for", "k_class",
1572  "k_module", "k_def", "k_end", "then", "do", "if_tail", "opt_else",
1573  "for_var", "f_marg", "f_marg_list", "f_margs", "block_args_tail",
1574  "opt_block_args_tail", "block_param", "opt_block_param",
1575  "block_param_def", "opt_bv_decl", "bv_decls", "bvar", "lambda", "@26",
1576  "@27", "@28", "f_larglist", "lambda_body", "do_block", "@29",
1577  "block_call", "method_call", "@30", "@31", "@32", "@33", "brace_block",
1578  "@34", "@35", "case_body", "cases", "opt_rescue", "exc_list", "exc_var",
1579  "opt_ensure", "literal", "strings", "string", "string1", "xstring",
1580  "regexp", "words", "word_list", "word", "symbols", "symbol_list",
1581  "qwords", "qsymbols", "qword_list", "qsym_list", "string_contents",
1582  "xstring_contents", "regexp_contents", "string_content", "@36", "@37",
1583  "@38", "@39", "string_dvar", "symbol", "sym", "dsym", "numeric",
1584  "user_variable", "keyword_variable", "var_ref", "var_lhs", "backref",
1585  "superclass", "$@40", "f_arglist", "args_tail", "opt_args_tail",
1586  "f_args", "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_kw",
1587  "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest",
1588  "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
1589  "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
1590  "singleton", "$@41", "assoc_list", "assocs", "assoc", "operation",
1591  "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
1592  "rparen", "rbracket", "trailer", "term", "terms", "none", 0
1593 };
1594 #endif
1595 
1596 # ifdef YYPRINT
1597 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1598  token YYLEX-NUM. */
1599 static const yytype_uint16 yytoknum[] =
1600 {
1601  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1602  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1603  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1604  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1605  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1606  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1607  315, 316, 317, 318, 319, 320, 130, 131, 132, 134,
1608  139, 140, 141, 138, 137, 321, 322, 142, 143, 128,
1609  129, 144, 145, 135, 136, 323, 324, 325, 326, 327,
1610  328, 329, 330, 331, 332, 333, 334, 335, 336, 337,
1611  338, 339, 340, 341, 342, 343, 344, 345, 346, 347,
1612  348, 349, 350, 61, 63, 58, 62, 60, 124, 94,
1613  38, 43, 45, 42, 47, 37, 351, 33, 126, 352,
1614  123, 125, 91, 46, 44, 96, 40, 41, 93, 59,
1615  32, 10
1616 };
1617 # endif
1618 
1619 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1620 static const yytype_uint16 yyr1[] =
1621 {
1622  0, 142, 144, 143, 145, 146, 146, 146, 146, 147,
1623  148, 147, 149, 150, 151, 151, 151, 151, 152, 153,
1624  152, 155, 154, 154, 154, 154, 154, 154, 154, 154,
1625  154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1626  154, 154, 154, 154, 154, 154, 156, 156, 157, 157,
1627  157, 157, 157, 157, 158, 159, 159, 160, 160, 162,
1628  161, 163, 164, 164, 164, 164, 164, 164, 164, 164,
1629  164, 164, 164, 165, 165, 166, 166, 167, 167, 167,
1630  167, 167, 167, 167, 167, 167, 167, 168, 168, 169,
1631  169, 170, 170, 171, 171, 171, 171, 171, 171, 171,
1632  171, 171, 172, 172, 172, 172, 172, 172, 172, 172,
1633  172, 173, 173, 174, 174, 174, 175, 175, 175, 175,
1634  175, 176, 176, 177, 177, 178, 179, 178, 180, 180,
1635  180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
1636  180, 180, 180, 180, 180, 180, 180, 180, 180, 180,
1637  180, 180, 180, 180, 180, 180, 180, 180, 181, 181,
1638  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1639  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1640  181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
1641  181, 181, 181, 181, 181, 181, 181, 181, 181, 182,
1642  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1643  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1644  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1645  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1646  182, 183, 182, 182, 182, 184, 185, 185, 185, 185,
1647  186, 187, 187, 188, 188, 188, 188, 188, 189, 189,
1648  189, 189, 189, 191, 190, 192, 193, 193, 194, 194,
1649  194, 194, 195, 195, 195, 196, 196, 196, 196, 196,
1650  196, 196, 196, 196, 196, 196, 197, 196, 198, 196,
1651  199, 196, 196, 196, 196, 196, 196, 196, 196, 196,
1652  196, 200, 196, 196, 196, 196, 196, 196, 196, 196,
1653  196, 201, 202, 196, 203, 204, 196, 196, 196, 205,
1654  206, 196, 207, 196, 208, 209, 196, 210, 196, 211,
1655  196, 212, 213, 196, 196, 196, 196, 196, 214, 215,
1656  216, 217, 218, 219, 220, 221, 222, 223, 224, 225,
1657  226, 226, 226, 227, 227, 228, 228, 229, 229, 230,
1658  230, 231, 231, 232, 232, 233, 233, 233, 233, 233,
1659  233, 233, 233, 233, 234, 234, 234, 234, 235, 235,
1660  236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
1661  236, 236, 236, 236, 236, 237, 237, 238, 238, 238,
1662  239, 239, 240, 240, 241, 241, 243, 244, 245, 242,
1663  246, 246, 247, 247, 249, 248, 250, 250, 250, 250,
1664  251, 252, 251, 253, 251, 251, 254, 251, 255, 251,
1665  251, 251, 251, 257, 256, 258, 256, 259, 260, 260,
1666  261, 261, 262, 262, 262, 263, 263, 264, 264, 265,
1667  265, 265, 266, 267, 267, 267, 268, 269, 270, 271,
1668  271, 272, 272, 273, 273, 274, 274, 275, 275, 276,
1669  276, 277, 277, 278, 278, 279, 279, 280, 280, 281,
1670  281, 282, 282, 283, 284, 283, 285, 286, 287, 283,
1671  288, 288, 288, 288, 289, 290, 290, 290, 290, 291,
1672  292, 292, 292, 292, 293, 293, 293, 293, 293, 294,
1673  294, 294, 294, 294, 294, 294, 295, 295, 296, 296,
1674  297, 297, 298, 299, 298, 298, 300, 300, 301, 301,
1675  301, 301, 302, 302, 303, 303, 303, 303, 303, 303,
1676  303, 303, 303, 303, 303, 303, 303, 303, 303, 304,
1677  304, 304, 304, 305, 305, 306, 306, 307, 307, 308,
1678  309, 310, 310, 311, 311, 312, 312, 313, 313, 314,
1679  315, 316, 316, 317, 317, 318, 318, 319, 319, 320,
1680  320, 321, 322, 322, 323, 324, 323, 325, 325, 326,
1681  326, 327, 327, 327, 328, 328, 328, 329, 329, 329,
1682  329, 330, 330, 330, 331, 331, 332, 332, 333, 333,
1683  334, 335, 336, 336, 336, 337, 337, 338, 338, 339
1684 };
1685 
1686 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1687 static const yytype_uint8 yyr2[] =
1688 {
1689  0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
1690  0, 5, 4, 2, 1, 1, 3, 2, 1, 0,
1691  5, 0, 4, 3, 3, 3, 2, 3, 3, 3,
1692  3, 3, 4, 1, 3, 3, 6, 5, 5, 5,
1693  5, 3, 3, 3, 3, 1, 3, 3, 1, 3,
1694  3, 3, 2, 1, 1, 1, 1, 1, 4, 0,
1695  5, 1, 2, 3, 4, 5, 4, 5, 2, 2,
1696  2, 2, 2, 1, 3, 1, 3, 1, 2, 3,
1697  5, 2, 4, 2, 4, 1, 3, 1, 3, 2,
1698  3, 1, 3, 1, 1, 4, 3, 3, 3, 3,
1699  2, 1, 1, 1, 4, 3, 3, 3, 3, 2,
1700  1, 1, 1, 2, 1, 3, 1, 1, 1, 1,
1701  1, 1, 1, 1, 1, 1, 0, 4, 1, 1,
1702  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1703  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1704  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1705  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1706  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1707  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1708  1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
1709  5, 3, 5, 6, 5, 5, 5, 5, 4, 3,
1710  3, 3, 3, 3, 3, 3, 3, 3, 4, 4,
1711  2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
1712  3, 3, 3, 3, 3, 2, 2, 3, 3, 3,
1713  3, 0, 4, 6, 1, 1, 1, 2, 4, 2,
1714  3, 1, 1, 1, 1, 2, 4, 2, 1, 2,
1715  2, 4, 1, 0, 2, 2, 2, 1, 1, 2,
1716  3, 4, 3, 4, 2, 1, 1, 1, 1, 1,
1717  1, 1, 1, 1, 1, 1, 0, 4, 0, 3,
1718  0, 4, 3, 3, 2, 3, 3, 1, 4, 3,
1719  1, 0, 6, 4, 3, 2, 1, 2, 2, 6,
1720  6, 0, 0, 7, 0, 0, 7, 5, 4, 0,
1721  0, 9, 0, 6, 0, 0, 8, 0, 5, 0,
1722  6, 0, 0, 9, 1, 1, 1, 1, 1, 1,
1723  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1724  1, 1, 2, 1, 1, 1, 5, 1, 2, 1,
1725  1, 1, 3, 1, 3, 1, 4, 6, 3, 5,
1726  2, 4, 1, 3, 4, 2, 2, 1, 2, 0,
1727  6, 8, 4, 6, 4, 2, 6, 2, 4, 6,
1728  2, 4, 2, 4, 1, 1, 1, 3, 1, 4,
1729  1, 4, 1, 3, 1, 1, 0, 0, 0, 5,
1730  4, 1, 3, 3, 0, 5, 2, 4, 5, 5,
1731  2, 0, 5, 0, 5, 3, 0, 4, 0, 4,
1732  2, 1, 4, 0, 5, 0, 5, 5, 1, 1,
1733  6, 1, 1, 1, 1, 2, 1, 2, 1, 1,
1734  1, 1, 1, 1, 1, 2, 3, 3, 3, 3,
1735  3, 0, 3, 1, 2, 3, 3, 0, 3, 3,
1736  3, 3, 3, 0, 3, 0, 3, 0, 2, 0,
1737  2, 0, 2, 1, 0, 3, 0, 0, 0, 6,
1738  1, 1, 1, 1, 2, 1, 1, 1, 1, 3,
1739  1, 1, 2, 2, 1, 1, 1, 1, 1, 1,
1740  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1741  1, 1, 1, 0, 4, 2, 3, 2, 4, 2,
1742  2, 1, 2, 0, 6, 8, 4, 6, 4, 6,
1743  2, 4, 6, 2, 4, 2, 4, 1, 0, 1,
1744  1, 1, 1, 1, 1, 1, 3, 1, 3, 2,
1745  2, 1, 3, 1, 3, 1, 1, 2, 1, 3,
1746  3, 1, 3, 1, 3, 1, 1, 2, 1, 1,
1747  1, 2, 2, 1, 1, 0, 4, 1, 2, 1,
1748  3, 3, 2, 2, 1, 1, 1, 1, 1, 1,
1749  1, 1, 1, 1, 1, 1, 0, 1, 0, 1,
1750  2, 2, 0, 1, 1, 1, 1, 1, 2, 0
1751 };
1752 
1753 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1754  Performed when YYTABLE doesn't specify something else to do. Zero
1755  means the default is an error. */
1756 static const yytype_uint16 yydefact[] =
1757 {
1758  2, 0, 0, 1, 0, 346, 347, 348, 0, 339,
1759  340, 341, 344, 342, 343, 345, 334, 335, 336, 337,
1760  297, 263, 263, 510, 509, 511, 512, 608, 0, 608,
1761  10, 0, 514, 513, 515, 594, 596, 506, 505, 595,
1762  508, 500, 501, 453, 520, 521, 0, 0, 0, 0,
1763  288, 619, 619, 85, 406, 479, 477, 479, 481, 461,
1764  473, 467, 475, 0, 0, 0, 3, 606, 6, 9,
1765  33, 45, 48, 56, 263, 55, 0, 73, 0, 77,
1766  87, 0, 53, 244, 0, 286, 0, 0, 311, 314,
1767  606, 0, 0, 0, 0, 57, 306, 275, 276, 452,
1768  454, 277, 278, 279, 281, 280, 282, 450, 451, 449,
1769  516, 517, 283, 0, 284, 61, 5, 8, 168, 179,
1770  169, 192, 165, 185, 175, 174, 195, 196, 190, 173,
1771  172, 167, 193, 197, 198, 177, 166, 180, 184, 186,
1772  178, 171, 187, 194, 189, 188, 181, 191, 176, 164,
1773  183, 182, 163, 170, 161, 162, 158, 159, 160, 116,
1774  118, 117, 153, 154, 149, 131, 132, 133, 140, 137,
1775  139, 134, 135, 155, 156, 141, 142, 146, 150, 136,
1776  138, 128, 129, 130, 143, 144, 145, 147, 148, 151,
1777  152, 157, 121, 123, 125, 26, 119, 120, 122, 124,
1778  0, 0, 0, 0, 0, 0, 0, 0, 258, 0,
1779  245, 268, 71, 262, 619, 0, 516, 517, 0, 284,
1780  619, 589, 72, 70, 608, 69, 0, 619, 430, 68,
1781  608, 609, 0, 0, 21, 241, 0, 0, 334, 335,
1782  297, 300, 431, 0, 220, 0, 221, 294, 0, 19,
1783  0, 0, 606, 15, 18, 608, 75, 14, 290, 608,
1784  0, 612, 612, 246, 0, 0, 612, 587, 608, 0,
1785  0, 0, 83, 338, 0, 93, 94, 101, 308, 407,
1786  497, 496, 498, 495, 0, 494, 0, 0, 0, 0,
1787  0, 0, 0, 0, 0, 0, 0, 502, 503, 52,
1788  235, 236, 615, 616, 4, 617, 607, 0, 0, 0,
1789  0, 0, 0, 0, 435, 433, 420, 62, 305, 414,
1790  416, 0, 89, 0, 81, 78, 0, 0, 0, 0,
1791  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1792  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1793  0, 0, 0, 428, 619, 426, 0, 54, 0, 0,
1794  0, 0, 606, 0, 607, 0, 360, 359, 0, 0,
1795  516, 517, 284, 111, 112, 0, 0, 114, 0, 0,
1796  516, 517, 284, 327, 188, 181, 191, 176, 158, 159,
1797  160, 116, 117, 585, 329, 584, 0, 605, 604, 0,
1798  307, 455, 0, 0, 126, 592, 294, 269, 593, 265,
1799  0, 0, 0, 259, 267, 428, 619, 426, 0, 0,
1800  0, 260, 608, 0, 299, 264, 608, 254, 619, 619,
1801  253, 608, 304, 51, 23, 25, 24, 0, 301, 0,
1802  0, 0, 428, 426, 0, 17, 0, 608, 292, 13,
1803  607, 74, 608, 289, 295, 614, 613, 247, 614, 249,
1804  296, 588, 0, 100, 502, 503, 91, 86, 0, 428,
1805  619, 426, 548, 483, 486, 484, 499, 480, 456, 478,
1806  457, 458, 482, 459, 460, 0, 463, 469, 0, 470,
1807  465, 466, 0, 471, 0, 472, 0, 0, 618, 7,
1808  27, 28, 29, 30, 31, 49, 50, 619, 619, 59,
1809  63, 619, 0, 34, 43, 0, 44, 608, 0, 79,
1810  90, 47, 46, 0, 199, 268, 42, 217, 225, 230,
1811  231, 232, 227, 229, 239, 240, 233, 234, 210, 211,
1812  237, 238, 608, 226, 228, 222, 223, 224, 212, 213,
1813  214, 215, 216, 597, 599, 598, 600, 0, 263, 425,
1814  608, 597, 599, 598, 600, 0, 263, 0, 619, 351,
1815  0, 350, 0, 0, 0, 0, 0, 0, 294, 428,
1816  619, 426, 319, 324, 111, 112, 113, 0, 523, 322,
1817  522, 428, 619, 426, 0, 0, 548, 331, 597, 598,
1818  263, 35, 201, 41, 209, 0, 199, 591, 0, 270,
1819  266, 619, 597, 598, 608, 597, 598, 590, 298, 610,
1820  250, 255, 257, 303, 22, 0, 242, 0, 32, 423,
1821  421, 208, 0, 76, 16, 291, 612, 0, 84, 97,
1822  99, 608, 597, 598, 554, 551, 550, 549, 552, 0,
1823  565, 0, 576, 566, 580, 579, 575, 548, 408, 547,
1824  411, 553, 555, 557, 533, 563, 619, 568, 619, 573,
1825  533, 578, 533, 0, 531, 487, 0, 462, 464, 474,
1826  468, 476, 218, 219, 398, 608, 0, 396, 395, 0,
1827  619, 0, 274, 0, 88, 82, 0, 0, 0, 0,
1828  0, 0, 429, 66, 0, 0, 432, 0, 0, 427,
1829  64, 619, 349, 287, 619, 619, 441, 619, 352, 619,
1830  354, 312, 353, 315, 0, 0, 318, 601, 293, 608,
1831  597, 598, 0, 0, 525, 0, 0, 111, 112, 115,
1832  608, 0, 608, 548, 0, 0, 0, 252, 417, 58,
1833  251, 0, 127, 271, 261, 0, 0, 432, 0, 0,
1834  619, 608, 11, 0, 248, 92, 95, 0, 559, 554,
1835  0, 372, 363, 365, 608, 361, 608, 0, 0, 540,
1836  0, 529, 583, 567, 0, 530, 0, 543, 577, 0,
1837  545, 581, 488, 490, 491, 492, 485, 493, 554, 0,
1838  394, 608, 0, 379, 561, 619, 619, 571, 379, 379,
1839  377, 400, 0, 0, 0, 0, 0, 272, 80, 200,
1840  0, 40, 206, 39, 207, 67, 424, 611, 0, 37,
1841  204, 38, 205, 65, 422, 442, 443, 619, 444, 0,
1842  619, 357, 0, 0, 355, 0, 0, 0, 317, 0,
1843  0, 432, 0, 325, 0, 0, 432, 328, 586, 608,
1844  0, 527, 332, 418, 419, 202, 0, 256, 302, 20,
1845  569, 608, 0, 370, 0, 556, 0, 0, 0, 409,
1846  532, 558, 533, 533, 564, 619, 582, 533, 574, 533,
1847  533, 0, 0, 0, 560, 0, 397, 385, 387, 0,
1848  375, 376, 0, 390, 0, 392, 0, 436, 434, 0,
1849  415, 273, 243, 36, 203, 0, 0, 446, 358, 0,
1850  12, 448, 0, 309, 310, 0, 0, 270, 619, 320,
1851  0, 524, 323, 526, 330, 548, 362, 373, 0, 368,
1852  364, 410, 0, 0, 0, 536, 0, 538, 528, 0,
1853  544, 0, 541, 546, 0, 570, 294, 428, 399, 378,
1854  379, 379, 562, 619, 379, 572, 379, 379, 404, 608,
1855  402, 405, 60, 0, 445, 0, 102, 103, 110, 0,
1856  447, 0, 313, 316, 438, 439, 437, 0, 0, 0,
1857  0, 371, 0, 366, 413, 412, 533, 533, 533, 533,
1858  489, 601, 293, 0, 382, 0, 384, 374, 0, 391,
1859  0, 388, 393, 0, 401, 109, 428, 619, 426, 619,
1860  619, 0, 326, 0, 369, 0, 537, 0, 534, 539,
1861  542, 379, 379, 379, 379, 403, 601, 108, 608, 597,
1862  598, 440, 356, 321, 333, 367, 533, 383, 0, 380,
1863  386, 389, 432, 535, 379, 381
1864 };
1865 
1866 /* YYDEFGOTO[NTERM-NUM]. */
1867 static const yytype_int16 yydefgoto[] =
1868 {
1869  -1, 1, 2, 66, 67, 68, 236, 567, 568, 252,
1870  253, 446, 254, 437, 70, 71, 358, 72, 73, 510,
1871  690, 243, 75, 76, 255, 77, 78, 79, 467, 80,
1872  209, 377, 378, 192, 193, 194, 195, 605, 556, 197,
1873  82, 439, 211, 260, 228, 748, 426, 427, 225, 226,
1874  213, 413, 428, 516, 83, 356, 259, 452, 625, 360,
1875  846, 361, 847, 732, 987, 736, 733, 930, 594, 596,
1876  746, 935, 245, 85, 86, 87, 88, 89, 90, 91,
1877  92, 93, 94, 713, 570, 721, 843, 844, 369, 772,
1878  773, 774, 959, 898, 801, 686, 687, 802, 969, 970,
1879  278, 279, 472, 777, 658, 879, 320, 511, 95, 96,
1880  711, 704, 565, 557, 318, 508, 507, 577, 986, 715,
1881  837, 916, 920, 97, 98, 99, 100, 101, 102, 103,
1882  290, 485, 104, 294, 105, 106, 292, 296, 286, 284,
1883  288, 477, 676, 675, 792, 891, 796, 107, 285, 108,
1884  109, 216, 217, 112, 218, 219, 589, 735, 744, 880,
1885  779, 745, 661, 662, 663, 664, 665, 804, 805, 666,
1886  667, 668, 669, 807, 808, 670, 671, 672, 673, 674,
1887  781, 396, 595, 265, 429, 221, 115, 629, 559, 399,
1888  304, 423, 424, 706, 457, 571, 364, 257
1889 };
1890 
1891 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1892  STATE-NUM. */
1893 #define YYPACT_NINF -810
1894 static const yytype_int16 yypact[] =
1895 {
1896  -810, 102, 2888, -810, 7502, -810, -810, -810, 7025, -810,
1897  -810, -810, -810, -810, -810, -810, 7615, 7615, -810, -810,
1898  7615, 4210, 3805, -810, -810, -810, -810, 190, 6892, -21,
1899  -810, 10, -810, -810, -810, 3130, 3940, -810, -810, 3265,
1900  -810, -810, -810, -810, -810, -810, 8971, 8971, 130, 5262,
1901  9084, 7954, 8293, 7284, -810, 6759, -810, -810, -810, 54,
1902  70, 225, 228, 515, 9197, 8971, -810, 245, -810, 1021,
1903  -810, 269, -810, -810, 73, 120, 87, -810, 98, 9310,
1904  -810, 148, 3109, 44, 359, -810, 9084, 9084, -810, -810,
1905  6149, 9419, 9528, 9637, 6625, 30, 86, -810, -810, 230,
1906  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1907  3, 385, -810, 348, 490, -810, -810, -810, -810, -810,
1908  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1909  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1910  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1911  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1912  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1913  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1914  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
1915  -810, -810, -810, -810, -810, 285, -810, -810, -810, -810,
1916  253, 8971, 374, 5401, 8971, 8971, 8971, 8971, -810, 328,
1917  3109, 364, -810, -810, 313, 369, 208, 224, 395, 247,
1918  354, -810, -810, -810, 6036, -810, 7615, 7615, -810, -810,
1919  6262, -810, 9084, 844, -810, 360, 388, 5540, -810, -810,
1920  -810, 379, 400, 73, -810, 464, 463, 501, 7728, -810,
1921  5262, 402, 245, -810, 1021, -21, 437, -810, 269, -21,
1922  415, 8, 317, -810, 364, 440, 317, -810, -21, 525,
1923  615, 9746, 470, -810, 488, 508, 575, 612, -810, -810,
1924  -810, -810, -810, -810, 438, -810, 447, 451, 284, 475,
1925  540, 496, 60, 502, 576, 516, 61, 550, 565, -810,
1926  -810, -810, -810, -810, -810, -810, 6375, 9084, 9084, 9084,
1927  9084, 7728, 9084, 9084, -810, -810, -810, 549, -810, -810,
1928  -810, 8406, -810, 5262, 7393, 527, 8406, 8971, 8971, 8971,
1929  8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971,
1930  8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971, 8971,
1931  8971, 8971, 8971, 10025, 7615, 10102, 4619, 269, 110, 110,
1932  9084, 9084, 245, 654, 538, 631, -810, -810, 645, 668,
1933  85, 93, 108, 405, 410, 9084, 377, -810, 123, 661,
1934  -810, -810, -810, -810, 40, 42, 56, 167, 180, 279,
1935  332, 336, 343, -810, -810, -810, 30, -810, -810, 10179,
1936  -810, -810, 9197, 9197, -810, -810, 394, -810, -810, -810,
1937  8971, 8971, 7841, -810, -810, 10256, 7615, 10333, 8971, 8971,
1938  8067, -810, -21, 558, -810, -810, -21, -810, 564, 566,
1939  -810, 66, -810, -810, -810, -810, -810, 7025, -810, 8971,
1940  5671, 574, 10256, 10333, 8971, 1021, 581, -21, -810, -810,
1941  6488, 572, -21, -810, -810, 8180, -810, -810, 8293, -810,
1942  -810, -810, 360, 678, -810, -810, -810, 588, 9746, 10410,
1943  7615, 10487, 1081, -810, -810, -810, -810, -810, -810, -810,
1944  -810, -810, -810, -810, -810, 302, -810, -810, 594, -810,
1945  -810, -810, 306, -810, 597, -810, 8971, 8971, -810, -810,
1946  -810, -810, -810, -810, -810, -810, -810, 63, 63, -810,
1947  -810, 63, 8971, -810, 605, 607, -810, -21, 9746, 617,
1948  -810, -810, -810, 636, 1231, -810, -810, 463, 2567, 2567,
1949  2567, 2567, 976, 976, 2722, 2633, 2567, 2567, 3244, 3244,
1950  339, 339, 1305, 976, 976, 986, 986, 1119, 255, 255,
1951  463, 463, 463, 4345, 3400, 4480, 3535, 400, 620, -810,
1952  -21, 591, -810, 742, -810, 400, 4075, 747, 754, -810,
1953  4758, 756, 5036, 52, 52, 654, 8519, 747, 121, 10564,
1954  7615, 10641, -810, 269, -810, 678, -810, 245, -810, -810,
1955  -810, 10718, 7615, 10179, 4619, 9084, 1274, -810, -810, -810,
1956  1148, -810, 2322, -810, 3109, 7025, 2974, -810, 8971, 364,
1957  -810, 354, 2995, 3670, -21, 398, 497, -810, -810, -810,
1958  -810, 7841, 8067, -810, -810, 9084, 3109, 644, -810, -810,
1959  -810, 3109, 5671, 212, -810, -810, 317, 9746, 588, 495,
1960  323, -21, 337, 376, 676, -810, -810, -810, -810, 8971,
1961  -810, 896, -810, -810, -810, -810, -810, 1142, -810, -810,
1962  -810, -810, -810, -810, 656, -810, 657, 743, 663, -810,
1963  667, 750, 671, 760, -810, -810, 763, -810, -810, -810,
1964  -810, -810, 463, 463, -810, 793, 5810, -810, -810, 5540,
1965  63, 5810, 679, 8632, -810, 588, 9746, 9197, 8971, 699,
1966  9197, 9197, -810, 549, 400, 681, 759, 9197, 9197, -810,
1967  549, 400, -810, -810, 8745, 810, -810, 718, -810, 810,
1968  -810, -810, -810, -810, 747, 92, -810, 81, 149, -21,
1969  144, 155, 9084, 245, -810, 9084, 4619, 495, 323, -810,
1970  -21, 747, 66, 1142, 4619, 245, 7158, -810, 86, 120,
1971  -810, 8971, -810, -810, -810, 8971, 8971, 504, 8971, 8971,
1972  694, 66, -810, 700, -810, -810, 390, 8971, -810, -810,
1973  896, 473, -810, 702, -21, -810, -21, 124, 1142, -810,
1974  571, -810, -810, -810, 38, -810, 1142, -810, -810, 881,
1975  -810, -810, -810, -810, -810, -810, -810, -810, 720, 9855,
1976  -810, -21, 716, 703, -810, 707, 663, -810, 723, 724,
1977  -810, 725, 856, 737, 5540, 859, 8971, 740, 588, 3109,
1978  8971, -810, 3109, -810, 3109, -810, -810, -810, 9197, -810,
1979  3109, -810, 3109, -810, -810, 605, -810, 797, -810, 5149,
1980  872, -810, 9084, 747, -810, 747, 5810, 5810, -810, 8858,
1981  4897, 159, 52, -810, 245, 747, -810, -810, -810, -21,
1982  747, -810, -810, -810, -810, 3109, 8971, 8067, -810, -810,
1983  -810, -21, 875, 752, 953, -810, 762, 5810, 5540, -810,
1984  -810, -810, 753, 757, -810, 663, -810, 767, -810, 768,
1985  767, 5923, 9855, 848, 689, 787, -810, 1386, -810, 622,
1986  -810, -810, 1386, -810, 1533, -810, 1028, -810, -810, 778,
1987  -810, 784, 3109, -810, 3109, 9964, 110, -810, -810, 5810,
1988  -810, -810, 110, -810, -810, 747, 747, -810, 383, -810,
1989  4619, -810, -810, -810, -810, 1274, -810, 785, 875, 672,
1990  -810, -810, 911, 792, 1142, -810, 881, -810, -810, 881,
1991  -810, 881, -810, -810, 820, 689, -810, 10795, -810, -810,
1992  806, 809, -810, 663, 811, -810, 812, 811, -810, 352,
1993  -810, -810, -810, 891, -810, 691, 508, 575, 612, 4619,
1994  -810, 4758, -810, -810, -810, -810, -810, 5810, 747, 4619,
1995  875, 785, 875, 823, -810, -810, 767, 824, 767, 767,
1996  -810, 818, 826, 1386, -810, 1533, -810, -810, 1533, -810,
1997  1533, -810, -810, 1028, -810, 678, 10872, 7615, 10949, 754,
1998  718, 747, -810, 747, 785, 875, -810, 881, -810, -810,
1999  -810, 811, 825, 811, 811, -810, 49, 323, -21, 179,
2000  215, -810, -810, -810, -810, 785, 767, -810, 1533, -810,
2001  -810, -810, 216, -810, 811, -810
2002 };
2003 
2004 /* YYPGOTO[NTERM-NUM]. */
2005 static const yytype_int16 yypgoto[] =
2006 {
2007  -810, -810, -810, -382, -810, 26, -810, -549, -7, -810,
2008  513, -810, 33, -810, -315, -33, -63, -55, -810, -216,
2009  -810, 766, -13, 874, -164, 20, -73, -810, -409, 29,
2010  1882, -309, 882, -54, -810, -5, -810, -810, 6, -810,
2011  1208, -810, 1366, -810, -41, 256, -344, 78, -14, -810,
2012  -384, -205, -4, -304, -15, -810, -810, -810, -810, -810,
2013  -810, -810, -810, -810, -810, -810, -810, -810, -810, -810,
2014  -810, -810, 64, -810, -810, -810, -810, -810, -810, -810,
2015  -810, -810, -810, -1, -333, -519, -44, -623, -810, -789,
2016  -771, 211, 297, 71, -810, -437, -810, -693, -810, -29,
2017  -810, -810, -810, -810, -810, -810, 237, -810, -810, -810,
2018  -810, -810, -810, -810, -94, -810, -810, -531, -810, -31,
2019  -810, -810, -810, -810, -810, -810, 890, -810, -810, -810,
2020  -810, 701, -810, -810, -810, -810, -810, -810, -810, 940,
2021  -810, -126, -810, -810, -810, -810, -810, -3, -810, 11,
2022  -810, 1400, 1673, 905, 1898, 1689, -810, -810, 65, -451,
2023  -102, -385, -809, -588, -689, -289, 222, 107, -810, -810,
2024  -810, 18, -721, -764, 115, 235, -810, -634, -810, -37,
2025  -627, -810, -810, -810, 114, -388, -810, -324, -810, 623,
2026  -47, -9, -123, -568, -214, 21, -11, -2
2027 };
2028 
2029 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2030  positive, shift that token. If negative, reduce the rule which
2031  number is the opposite. If YYTABLE_NINF, syntax error. */
2032 #define YYTABLE_NINF -620
2033 static const yytype_int16 yytable[] =
2034 {
2035  116, 283, 400, 208, 208, 198, 325, 208, 229, 299,
2036  560, 521, 214, 214, 196, 421, 214, 258, 232, 199,
2037  235, 659, 526, 234, 359, 198, 572, 362, 610, 558,
2038  117, 566, 617, 316, 196, 69, 610, 69, 273, 199,
2039  394, 785, 251, 363, 724, 741, 757, 261, 459, 263,
2040  267, 809, 461, 357, 357, 723, 306, 357, 627, 638,
2041  317, 196, -106, 775, 273, 888, 84, 586, 84, 256,
2042  617, 689, 614, 766, 691, 600, 273, 273, 273, 720,
2043  215, 215, 272, 876, 215, 940, 447, 660, 305, 881,
2044  -518, 558, 840, 566, 212, 222, 845, 971, 223, 314,
2045  196, 937, 3, 312, 313, 569, -106, 432, 895, 695,
2046  -102, 305, 314, 84, 215, 397, -102, 274, -103, 630,
2047  231, 488, 494, 569, 587, -510, 641, -509, 215, -338,
2048  220, 220, 451, -110, 220, 654, 453, -93, 965, 684,
2049  237, -511, 455, 274, 883, 659, -109, 630, 319, 456,
2050  215, 215, 889, 877, 215, 368, 379, 379, 655, 517,
2051  479, 851, 482, 398, 486, 262, 266, 991, 486, -105,
2052  489, 495, 856, -510, -108, -509, -338, -338, 900, 901,
2053  -107, 685, 775, 873, -104, -597, 247, 855, -106, -511,
2054  -106, 302, -105, 303, 289, 860, 251, 431, 466, 433,
2055  321, 940, 316, 315, 971, 449, 659, 231, 881, 227,
2056  291, 208, 414, 208, 208, -97, 315, -597, 414, -93,
2057  214, 1024, 214, 888, 421, 430, 849, -94, -107, -104,
2058  441, 302, 322, 303, 617, 878, 729, 610, 610, 965,
2059  588, 450, -101, 251, 500, 501, 502, 503, 740, 302,
2060  763, 303, -512, 814, 1045, -100, 273, 630, 948, 462,
2061  881, 326, 302, 961, 303, -514, 513, 84, 966, 630,
2062  256, 522, 776, 305, 357, 357, 357, 357, -96, 505,
2063  506, 445, 739, -99, 775, -598, 775, 818, 215, -98,
2064  215, 215, 659, -95, 215, -518, 215, 573, 574, 618,
2065  -512, 84, 422, 620, 425, 984, 312, 313, 623, 273,
2066  997, -519, 84, -514, 84, 575, 251, 515, -105, 881,
2067  -105, -102, 515, 327, 633, -74, 230, 357, 357, 635,
2068  56, 231, 499, 929, 419, 274, 1007, -103, 220, 69,
2069  220, 208, 583, 256, 504, 473, -88, 601, 603, 481,
2070  775, 993, 430, 519, -107, -104, -107, -104, 859, 678,
2071  -110, 564, -96, 473, -513, 293, 678, 473, 295, 1032,
2072  84, 215, 215, 215, 215, 84, 215, 215, 350, 351,
2073  352, 988, 521, 305, 302, 215, 303, 84, 274, 230,
2074  215, 474, 850, 475, 694, 466, 803, 985, 839, 590,
2075  576, -98, 775, 208, 775, 564, 754, 327, -293, 474,
2076  836, 475, -513, 474, 430, 475, -432, -515, 215, 404,
2077  84, -504, 764, 564, 215, 215, 414, 414, -507, 584,
2078  406, -594, 624, 585, 198, 402, -595, 775, 116, 215,
2079  1023, 410, 677, 196, 353, 466, 680, 412, 199, 564,
2080  -96, 458, 411, 273, 415, -293, -293, 208, 456, -598,
2081  348, 349, 350, 351, 352, -515, 215, 215, 430, -504,
2082  1052, -96, -519, 69, -96, -432, -507, 564, -96, 617,
2083  215, 444, 418, 610, 659, 758, 1013, 825, 420, -98,
2084  -504, 354, 355, 231, 833, -507, 438, 887, -103, 473,
2085  890, 416, 417, 273, 84, 688, 688, -109, 473, 688,
2086  -98, -105, 473, -98, 84, 224, 702, -98, 440, -94,
2087  -432, -601, -432, -432, 709, 769, 611, 645, 646, 647,
2088  648, 327, 274, 699, 215, -594, 227, -504, -504, 448,
2089  -595, -594, -507, -507, 703, 474, -595, 475, 476, 442,
2090  -73, 705, 710, 454, 474, 754, 475, 478, 474, 747,
2091  475, 480, 742, 717, 765, 719, 716, 208, 787, 636,
2092  790, 460, 725, 469, 297, 298, 726, 403, 430, 208,
2093  -601, 463, 274, 979, 759, 483, 749, 564, 444, 981,
2094  430, 866, 761, -516, 722, 722, 416, 443, 750, 564,
2095  752, 473, 198, -110, 468, 705, 487, 872, 734, 414,
2096  -107, 196, 490, 964, -109, 967, 199, -104, 496, 858,
2097  470, 471, 273, 466, -101, -601, 493, -601, -601, 649,
2098  116, -597, 705, 497, 84, -100, 84, 473, 868, 650,
2099  -516, -516, 522, 509, 215, 821, 823, 474, 810, 475,
2100  484, 875, 829, 831, 863, 996, 215, 998, 84, 215,
2101  -517, 520, 999, 826, 782, 69, 782, 653, 654, 852,
2102  747, 576, 854, 1038, 464, 465, 811, 498, 707, 812,
2103  799, 273, 813, 474, 815, 475, 491, 578, 688, 215,
2104  650, 655, 862, 582, 630, 619, 84, -284, 621, 357,
2105  622, 274, 357, 806, -105, 628, -88, -517, -517, 750,
2106  515, 632, 838, 841, 1031, 841, 1033, 841, 653, 654,
2107  705, 1034, 637, 848, 769, -96, 645, 646, 647, 648,
2108  579, 705, 842, 839, 679, 760, 933, 681, 1046, -268,
2109  857, 693, 655, 886, -284, -284, 591, 886, 936, 697,
2110  84, 696, 196, 84, 853, 84, -423, 712, 414, 1054,
2111  274, 215, 714, -294, 215, 215, 861, 811, 74, 718,
2112  74, 215, 215, 913, 957, 762, 1016, 580, 581, 922,
2113  945, 947, 74, 74, 273, 950, 74, 952, 953, 767,
2114  778, 780, 811, 592, 593, 783, 215, 784, 885, 215,
2115  84, 786, 788, 782, 782, 789, 992, 909, 84, 357,
2116  -294, -294, 791, -269, 820, 74, 74, 793, 794, 827,
2117  795, 592, 593, 1017, 1018, 839, 44, 45, 867, 708,
2118  74, 869, 918, 892, 896, 917, 874, 897, 921, 925,
2119  926, 899, 923, 928, 924, 798, 828, 645, 646, 647,
2120  648, 799, 74, 74, 932, -107, 74, 902, 904, 934,
2121  810, 650, 886, 894, 906, 810, 907, 810, 908, 910,
2122  942, 943, -104, 722, -270, 931, -98, 273, 84, 903,
2123  905, 919, 651, 782, 954, 915, 938, 944, 652, 653,
2124  654, 946, 215, -95, 1026, 1028, 1029, 1030, 434, 941,
2125  273, 949, 951, 84, 956, 958, 215, 435, 436, 972,
2126  84, 84, 980, 655, 84, 806, 656, 963, -271, 990,
2127  806, 994, 806, 995, 982, 983, 841, 769, 1000, 645,
2128  646, 647, 648, 769, 231, 645, 646, 647, 648, 649,
2129  1003, 84, 84, 1005, 1053, 1008, 1010, 1015, 769, 650,
2130  645, 646, 647, 648, -597, 84, 955, 1025, 1027, 1048,
2131  1014, 782, -598, 634, 770, 366, 810, 834, 810, 74,
2132  651, 810, 1019, 810, 1020, 383, 1042, 653, 654, 975,
2133  1021, 871, 800, 84, 1035, 770, 864, 1022, 1041, 401,
2134  74, 771, 74, 74, 84, 492, 74, 287, 74, 395,
2135  989, 655, 884, 74, 208, 769, 962, 645, 646, 647,
2136  648, 810, 960, 882, 74, 430, 74, 716, 841, 597,
2137  1043, 806, 1044, 806, 564, 0, 806, 0, 806, 705,
2138  0, 1004, 1006, 0, 0, 1009, 0, 1011, 1012, 0,
2139  0, 0, 770, 84, 327, 84, 0, 0, 939, 0,
2140  0, 84, 0, 84, 327, 0, 0, 0, 0, 340,
2141  341, 307, 308, 309, 310, 311, 806, 0, 0, 340,
2142  341, 0, 74, 74, 74, 74, 74, 74, 74, 74,
2143  968, 215, 645, 646, 647, 648, 0, 74, 0, 74,
2144  0, 0, 74, 0, 345, 346, 347, 348, 349, 350,
2145  351, 352, 1047, 1049, 1050, 1051, 347, 348, 349, 350,
2146  351, 352, 0, 0, 0, 0, 0, 0, 0, 0,
2147  74, 0, 74, 0, 0, 1055, 74, 74, 0, 0,
2148  0, 0, 0, 644, 0, 645, 646, 647, 648, 649,
2149  0, 74, 0, 0, 0, 0, 0, 0, -619, 650,
2150  0, 0, 0, 0, 0, 0, -619, -619, -619, 0,
2151  0, -619, -619, -619, 0, -619, 0, 0, 74, 74,
2152  651, 0, 0, 0, -619, -619, 652, 653, 654, 0,
2153  0, 0, 74, 0, 0, -619, -619, 327, -619, -619,
2154  -619, -619, -619, 0, 644, 0, 645, 646, 647, 648,
2155  649, 655, 340, 341, 656, 0, 74, 0, 0, 0,
2156  650, 0, 0, 0, 0, 0, 74, 657, 0, 0,
2157  0, 0, 0, 0, 210, 210, 0, 0, 210, 0,
2158  0, 651, 0, -619, 0, 0, 74, 652, 653, 654,
2159  348, 349, 350, 351, 352, 0, 0, 0, 0, 0,
2160  0, 0, 0, 0, 244, 246, -619, 0, 0, 210,
2161  210, 0, 655, 0, 0, 656, 0, 0, 0, 0,
2162  0, 0, 300, 301, 0, 698, 0, 0, -619, -619,
2163  0, -619, 0, 0, 227, -619, 0, -619, 0, -619,
2164  0, 0, 0, 0, 0, 0, 0, 0, 0, 327,
2165  328, 329, 330, 331, 332, 333, 334, 335, 336, 337,
2166  338, 339, 0, 0, 340, 341, 0, 0, 0, 0,
2167  0, 0, 0, 0, 0, 0, 644, 0, 645, 646,
2168  647, 648, 649, 0, 0, 0, 74, 0, 74, 0,
2169  0, 0, 650, 0, 0, 342, 74, 343, 344, 345,
2170  346, 347, 348, 349, 350, 351, 352, 0, 74, 0,
2171  74, 74, 0, 651, 0, -245, 0, 0, 0, 652,
2172  653, 654, 0, 327, 328, 329, 330, 331, 332, 333,
2173  334, 335, 336, 337, 338, 339, 0, 0, 340, 341,
2174  0, 74, 0, 0, 655, 0, 0, 656, 74, 0,
2175  0, 0, 110, 0, 110, 0, 0, 0, 0, 210,
2176  743, 0, 210, 210, 210, 300, 0, 0, 264, 342,
2177  0, 343, 344, 345, 346, 347, 348, 349, 350, 351,
2178  352, 0, 210, 0, 210, 210, 0, 0, 798, 0,
2179  645, 646, 647, 648, 799, 0, 231, 0, 0, 110,
2180  0, 0, 74, 275, 650, 74, 0, 74, 0, 0,
2181  0, 0, 0, 74, 0, 0, 74, 74, 0, 0,
2182  0, 0, 0, 74, 74, 651, 0, 0, 0, 275,
2183  0, 652, 653, 654, 0, 0, 0, 0, 0, 0,
2184  0, 370, 380, 380, 380, 0, 0, 0, 74, 0,
2185  0, 74, 74, 0, 0, 0, 655, 0, 0, 656,
2186  74, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2187  0, 0, 0, 0, 0, 0, 0, 0, 0, 210,
2188  0, 0, 0, 0, 524, 527, 528, 529, 530, 531,
2189  532, 533, 534, 535, 536, 537, 538, 539, 540, 541,
2190  542, 543, 544, 545, 546, 547, 548, 549, 550, 551,
2191  552, 0, 210, 0, 0, 0, 0, 405, 0, 0,
2192  407, 408, 409, 0, 0, 0, 0, 0, 0, 0,
2193  74, 0, 0, 0, 0, 769, 0, 645, 646, 647,
2194  648, 799, 0, 0, 74, 0, 0, 0, 0, 0,
2195  0, 650, 0, 110, 0, 74, 0, 0, 74, 0,
2196  602, 604, 74, 74, 0, 0, 74, 0, 606, 210,
2197  210, 0, 651, 0, 210, 0, 602, 604, 210, 653,
2198  654, 0, 0, 0, 0, 0, 0, 110, 0, 0,
2199  0, 0, 0, 74, 74, 0, 0, 626, 110, 0,
2200  110, 0, 631, 655, 0, 0, 0, 74, 0, 0,
2201  0, 0, 0, 210, 0, 0, 210, 0, 0, 0,
2202  0, 275, 0, 0, 0, 111, 0, 111, 210, 0,
2203  0, 0, 0, 0, 0, 74, 0, 514, 0, 0,
2204  0, 114, 525, 114, 0, 0, 74, 0, 0, 0,
2205  0, 0, 0, 0, 682, 683, 110, 0, 0, 0,
2206  0, 110, 0, 0, 0, 0, 0, 0, 0, 0,
2207  210, 0, 111, 110, 275, 0, 276, 0, 0, 0,
2208  0, 0, 0, 0, 0, 0, 0, 0, 114, 0,
2209  0, 0, 277, 0, 0, 74, 0, 74, 0, 0,
2210  0, 0, 276, 74, 0, 74, 110, 0, 0, 0,
2211  0, 0, 0, 0, 371, 381, 381, 381, 277, 0,
2212  0, 0, 0, 0, 0, 0, 0, 607, 609, 0,
2213  372, 382, 382, 74, 210, 0, 264, 0, 210, 0,
2214  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2215  210, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2216  0, 0, 0, 0, 0, 0, 210, 0, 0, 0,
2217  0, 609, 0, 0, 264, 0, 0, 0, 0, 210,
2218  210, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2219  110, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2220  110, 0, 0, 0, 0, 0, 0, 210, 0, 0,
2221  0, 0, 0, 0, 0, 0, 0, 0, 275, 0,
2222  0, 0, 0, 0, 0, 0, 111, 0, 692, 0,
2223  0, 0, 0, 0, 81, 0, 81, 0, 0, 0,
2224  0, 0, 114, 0, 0, 0, 0, 0, 0, 0,
2225  113, 210, 113, 0, 0, 606, 819, 0, 822, 824,
2226  111, 0, 0, 0, 0, 830, 832, 0, 275, 0,
2227  0, 111, 210, 111, 0, 0, 114, 0, 0, 0,
2228  0, 81, 0, 0, 0, 0, 0, 114, 0, 114,
2229  0, 0, 525, 0, 276, 0, 0, 113, 0, 0,
2230  0, 0, 0, 0, 0, 0, 0, 0, 0, 865,
2231  277, 0, 0, 822, 824, 0, 830, 832, 0, 0,
2232  110, 0, 110, 367, 753, 210, 0, 0, 0, 111,
2233  0, 0, 0, 0, 111, 0, 0, 609, 264, 0,
2234  0, 0, 0, 0, 110, 114, 111, 276, 0, 0,
2235  114, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2236  0, 0, 114, 277, 0, 768, 0, 0, 0, 0,
2237  0, 0, 0, 0, 210, 0, 0, 0, 912, 111,
2238  0, 0, 110, 0, 0, 0, 914, 275, 0, 0,
2239  0, 0, 0, 0, 0, 114, 0, 0, 0, 0,
2240  0, 0, 0, 0, 0, 0, 0, 210, 0, 817,
2241  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2242  0, 0, 0, 0, 914, 210, 0, 0, 0, 0,
2243  835, 0, 0, 0, 0, 81, 110, 0, 0, 110,
2244  0, 110, 0, 0, 0, 0, 275, 0, 0, 0,
2245  0, 113, 0, 0, 0, 0, 0, 0, 0, 0,
2246  0, 0, 0, 111, 0, 0, 0, 0, 0, 81,
2247  0, 0, 0, 111, 0, 0, 0, 0, 0, 114,
2248  81, 0, 81, 870, 0, 113, 110, 0, 0, 114,
2249  0, 276, 0, 0, 110, 0, 113, 0, 113, 0,
2250  0, 0, 0, 0, 0, 0, 0, 277, 0, 0,
2251  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2252  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2253  0, 0, 911, 0, 0, 0, 0, 0, 81, 0,
2254  0, 276, 0, 81, 0, 0, 0, 0, 0, 380,
2255  0, 0, 0, 0, 113, 81, 0, 277, 523, 113,
2256  0, 0, 0, 0, 110, 927, 0, 0, 0, 0,
2257  0, 113, 0, 0, 0, 210, 0, 0, 0, 0,
2258  0, 0, 0, 264, 0, 0, 0, 0, 81, 110,
2259  0, 0, 0, 111, 0, 111, 110, 110, 0, 0,
2260  110, 0, 0, 0, 113, 0, 0, 0, 0, 114,
2261  0, 114, 0, 0, 0, 0, 0, 111, 0, 0,
2262  0, 0, 0, 0, 0, 0, 0, 110, 110, 0,
2263  0, 0, 0, 114, 0, 0, 0, 0, 0, 0,
2264  0, 110, 380, 0, 0, 0, 0, 0, 0, 0,
2265  0, 0, 0, 0, 0, 111, 0, 0, 0, 0,
2266  276, 0, 0, 0, 0, 976, 0, 0, 0, 110,
2267  0, 114, 81, 0, 0, 0, 277, 0, 0, 0,
2268  110, 0, 81, 0, 0, 0, 0, 0, 113, 0,
2269  0, 0, 0, 0, 0, 0, 0, 0, 113, 0,
2270  0, 0, 0, 0, 0, 0, 0, 0, 0, 111,
2271  0, 0, 111, 0, 111, 797, 751, 0, 0, 276,
2272  0, 0, 0, 0, 0, 114, 0, 0, 114, 110,
2273  114, 110, 0, 0, 0, 277, 0, 110, 0, 110,
2274  327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
2275  337, 338, 339, 0, 0, 340, 341, 0, 0, 111,
2276  0, 0, 0, 0, 0, 0, 0, 111, 0, 0,
2277  0, 0, 0, 0, 0, 114, 0, 0, 0, 0,
2278  0, 0, 0, 114, 0, 0, 342, 0, 343, 344,
2279  345, 346, 347, 348, 349, 350, 351, 352, 0, 0,
2280  0, 0, 81, 0, 81, 0, 0, 0, 0, 0,
2281  0, 0, 0, 0, 0, 0, 0, 0, 113, 0,
2282  113, 0, 381, 0, 0, 0, 81, 0, 0, 0,
2283  0, 0, 0, 0, 0, 0, 0, 111, 382, 0,
2284  0, 0, 113, 0, 0, 0, 0, 0, 0, 0,
2285  0, 0, 0, 114, 0, 0, 0, 0, 0, 0,
2286  0, 0, 111, 0, 81, 0, 0, 0, 0, 111,
2287  111, 0, 0, 111, 0, 0, 0, 0, 114, 0,
2288  113, 0, 0, 0, 0, 114, 114, 0, 0, 114,
2289  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2290  111, 111, 0, 0, 0, 0, 0, 0, 0, 0,
2291  0, 0, 0, 0, 111, 381, 114, 114, 81, 0,
2292  0, 81, 0, 81, 0, 0, 0, 0, 0, 523,
2293  114, 382, 0, 0, 113, 0, 0, 113, 977, 113,
2294  0, 0, 111, 0, 0, 0, 0, 0, 0, 0,
2295  0, 0, 0, 111, 978, 0, 0, 0, 114, 0,
2296  0, 0, 0, 0, 0, 0, 0, 0, 81, 114,
2297  0, 0, 0, 0, 0, 0, 81, 0, 0, 0,
2298  0, 0, 0, 0, 113, 327, -620, -620, -620, -620,
2299  332, 333, 113, 0, -620, -620, 0, 0, 0, 0,
2300  340, 341, 111, 0, 111, 0, 0, 0, 0, 0,
2301  111, 0, 111, 0, 0, 0, 0, 0, 114, 0,
2302  114, 0, 0, 0, 0, 0, 114, 0, 114, 0,
2303  0, 0, 0, 343, 344, 345, 346, 347, 348, 349,
2304  350, 351, 352, 0, 0, 0, 81, 0, 0, 0,
2305  0, 327, 328, 329, 330, 331, 332, 333, 334, 0,
2306  336, 337, 113, 0, 0, 0, 340, 341, 0, 0,
2307  0, 81, 0, 0, 0, 0, 0, 0, 81, 81,
2308  0, 0, 81, 0, 0, 0, 0, 113, 0, 0,
2309  0, 0, 0, 0, 113, 113, 0, 0, 113, 343,
2310  344, 345, 346, 347, 348, 349, 350, 351, 352, 81,
2311  81, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2312  0, 0, 0, 81, 0, 113, 113, 0, 0, 0,
2313  0, 0, 0, 0, 0, 0, 0, 0, 0, 113,
2314  327, 328, 329, 330, 331, 332, 333, 974, 0, 336,
2315  337, 81, 0, 0, 0, 340, 341, 0, 0, 0,
2316  0, 0, 81, 0, 0, 0, 0, 113, 0, 0,
2317  0, 0, 0, 0, 0, 0, 0, 0, 113, 0,
2318  0, 0, 0, 0, 0, 0, 0, 0, 343, 344,
2319  345, 346, 347, 348, 349, 350, 351, 352, 0, 0,
2320  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2321  0, 81, 0, 81, 0, 0, 0, 0, 0, 81,
2322  0, 81, 0, 0, 0, 0, 0, 113, 0, 113,
2323  0, 0, 0, 0, 0, 113, 0, 113, -619, 4,
2324  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2325  11, 0, 0, 0, 12, 0, 13, 14, 15, 16,
2326  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2327  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2328  0, 0, 0, 28, 29, 30, 31, 32, 33, 34,
2329  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2330  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2331  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2332  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2333  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2334  58, 59, 60, 61, 62, -601, 0, 0, 0, 0,
2335  0, 0, 0, -601, -601, -601, 0, 0, -601, -601,
2336  -601, 0, -601, 0, 63, 64, 65, 0, 698, 0,
2337  0, -601, -601, -601, -601, 0, 0, -619, 0, -619,
2338  0, 0, -601, -601, 0, -601, -601, -601, -601, -601,
2339  0, 0, 327, 328, 329, 330, 331, 332, 333, 334,
2340  335, 336, 337, 338, 339, 0, 0, 340, 341, 0,
2341  0, 0, 0, -601, -601, -601, -601, -601, -601, -601,
2342  -601, -601, -601, -601, -601, -601, 0, 0, -601, -601,
2343  -601, 0, 755, -601, 0, 0, 0, 0, 342, -601,
2344  343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
2345  0, 0, 0, -601, 0, 0, -601, 0, -106, -601,
2346  -601, -601, -601, -601, -601, -601, -601, -601, -601, -601,
2347  -601, 0, 0, 0, 0, -601, -601, -601, -601, -601,
2348  -504, 0, -601, -601, -601, 0, -601, 0, -504, -504,
2349  -504, 0, 0, -504, -504, -504, 0, -504, 0, 0,
2350  0, 0, 0, 0, 0, -504, 0, -504, -504, -504,
2351  0, 0, 0, 0, 0, 0, 0, -504, -504, 0,
2352  -504, -504, -504, -504, -504, 0, 0, 327, 328, 329,
2353  330, 331, 332, 333, 334, 335, 336, 337, 338, 339,
2354  0, 0, 340, 341, 0, 0, 0, 0, -504, -504,
2355  -504, -504, -504, -504, -504, -504, -504, -504, -504, -504,
2356  -504, 0, 0, -504, -504, -504, 0, -504, -504, 0,
2357  0, 0, 0, 342, -504, 343, 344, 345, 346, 347,
2358  348, 349, 350, 351, 352, 0, 0, 0, -504, 0,
2359  0, -504, 0, -504, -504, -504, -504, -504, -504, -504,
2360  -504, -504, -504, -504, -504, -504, 0, 0, 0, 0,
2361  0, -504, -504, -504, -504, -507, 0, -504, -504, -504,
2362  0, -504, 0, -507, -507, -507, 0, 0, -507, -507,
2363  -507, 0, -507, 0, 0, 0, 0, 0, 0, 0,
2364  -507, 0, -507, -507, -507, 0, 0, 0, 0, 0,
2365  0, 0, -507, -507, 0, -507, -507, -507, -507, -507,
2366  0, 0, 327, 328, 329, 330, 331, 332, 333, 334,
2367  335, 336, 337, -620, -620, 0, 0, 340, 341, 0,
2368  0, 0, 0, -507, -507, -507, -507, -507, -507, -507,
2369  -507, -507, -507, -507, -507, -507, 0, 0, -507, -507,
2370  -507, 0, -507, -507, 0, 0, 0, 0, 0, -507,
2371  343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
2372  0, 0, 0, -507, 0, 0, -507, 0, -507, -507,
2373  -507, -507, -507, -507, -507, -507, -507, -507, -507, -507,
2374  -507, 0, 0, 0, 0, 0, -507, -507, -507, -507,
2375  -602, 0, -507, -507, -507, 0, -507, 0, -602, -602,
2376  -602, 0, 0, -602, -602, -602, 0, -602, 0, 0,
2377  0, 0, 0, 0, 0, 0, -602, -602, -602, -602,
2378  0, 0, 0, 0, 0, 0, 0, -602, -602, 0,
2379  -602, -602, -602, -602, -602, 0, 0, 0, 0, 0,
2380  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2381  0, 0, 0, 0, 0, 0, 0, 0, -602, -602,
2382  -602, -602, -602, -602, -602, -602, -602, -602, -602, -602,
2383  -602, 0, 0, -602, -602, -602, 0, 0, -602, 0,
2384  0, 0, 0, 0, -602, 0, 0, 0, 0, 0,
2385  0, 0, 0, 0, 0, 0, 0, 0, -602, 0,
2386  0, -602, 0, 0, -602, -602, -602, -602, -602, -602,
2387  -602, -602, -602, -602, -602, -602, 0, 0, 0, 0,
2388  -602, -602, -602, -602, -602, -603, 0, -602, -602, -602,
2389  0, -602, 0, -603, -603, -603, 0, 0, -603, -603,
2390  -603, 0, -603, 0, 0, 0, 0, 0, 0, 0,
2391  0, -603, -603, -603, -603, 0, 0, 0, 0, 0,
2392  0, 0, -603, -603, 0, -603, -603, -603, -603, -603,
2393  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2394  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2395  0, 0, 0, -603, -603, -603, -603, -603, -603, -603,
2396  -603, -603, -603, -603, -603, -603, 0, 0, -603, -603,
2397  -603, 0, 0, -603, 0, 0, 0, 0, 0, -603,
2398  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2399  0, 0, 0, -603, 0, 0, -603, 0, 0, -603,
2400  -603, -603, -603, -603, -603, -603, -603, -603, -603, -603,
2401  -603, 0, 0, 0, 0, -603, -603, -603, -603, -603,
2402  -293, 0, -603, -603, -603, 0, -603, 0, -293, -293,
2403  -293, 0, 0, -293, -293, -293, 0, -293, 0, 0,
2404  0, 0, 0, 0, 0, 0, 0, -293, -293, -293,
2405  0, 0, 0, 0, 0, 0, 0, -293, -293, 0,
2406  -293, -293, -293, -293, -293, 0, 0, 0, 0, 0,
2407  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2408  0, 0, 0, 0, 0, 0, 0, 0, -293, -293,
2409  -293, -293, -293, -293, -293, -293, -293, -293, -293, -293,
2410  -293, 0, 0, -293, -293, -293, 0, 756, -293, 0,
2411  0, 0, 0, 0, -293, 0, 0, 0, 0, 0,
2412  0, 0, 0, 0, 0, 0, 0, 0, -293, 0,
2413  0, -293, 0, -108, -293, -293, -293, -293, -293, -293,
2414  -293, -293, -293, -293, -293, -293, 0, 0, 0, 0,
2415  0, -293, -293, -293, -293, -431, 0, -293, -293, -293,
2416  0, -293, 0, -431, -431, -431, 0, 0, -431, -431,
2417  -431, 0, -431, 0, 0, 0, 0, 0, 0, 0,
2418  0, -431, -431, -431, 0, 0, 0, 0, 0, 0,
2419  0, 0, -431, -431, 0, -431, -431, -431, -431, -431,
2420  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2421  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2422  0, 0, 0, -431, -431, -431, -431, -431, -431, -431,
2423  -431, -431, -431, -431, -431, -431, 0, 0, -431, -431,
2424  -431, 0, 0, -431, 0, 0, 0, 0, 0, -431,
2425  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2426  0, 0, 0, -431, 0, 0, 0, 0, 0, -431,
2427  0, -431, -431, -431, -431, -431, -431, -431, -431, -431,
2428  -431, 0, 0, 0, 0, -431, -431, -431, -431, -431,
2429  -285, 227, -431, -431, -431, 0, -431, 0, -285, -285,
2430  -285, 0, 0, -285, -285, -285, 0, -285, 0, 0,
2431  0, 0, 0, 0, 0, 0, 0, -285, -285, -285,
2432  0, 0, 0, 0, 0, 0, 0, -285, -285, 0,
2433  -285, -285, -285, -285, -285, 0, 0, 0, 0, 0,
2434  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2435  0, 0, 0, 0, 0, 0, 0, 0, -285, -285,
2436  -285, -285, -285, -285, -285, -285, -285, -285, -285, -285,
2437  -285, 0, 0, -285, -285, -285, 0, 0, -285, 0,
2438  0, 0, 0, 0, -285, 0, 0, 0, 0, 0,
2439  0, 0, 0, 0, 0, 0, 0, 0, -285, 0,
2440  0, -285, 0, 0, -285, -285, -285, -285, -285, -285,
2441  -285, -285, -285, -285, -285, -285, 0, 0, 0, 0,
2442  0, -285, -285, -285, -285, -421, 0, -285, -285, -285,
2443  0, -285, 0, -421, -421, -421, 0, 0, -421, -421,
2444  -421, 0, -421, 0, 0, 0, 0, 0, 0, 0,
2445  0, -421, -421, -421, 0, 0, 0, 0, 0, 0,
2446  0, 0, -421, -421, 0, -421, -421, -421, -421, -421,
2447  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2448  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2449  0, 0, 0, -421, -421, -421, -421, -421, -421, -421,
2450  -421, -421, -421, -421, -421, -421, 0, 0, -421, -421,
2451  -421, 0, 0, -421, 0, 0, 0, 0, 0, -421,
2452  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2453  0, 0, 0, -421, 0, 0, 0, 0, 0, -421,
2454  0, -421, -421, -421, -421, -421, -421, -421, -421, -421,
2455  -421, 0, 0, 0, 0, -421, -421, -421, -421, -421,
2456  -300, -421, -421, -421, -421, 0, -421, 0, -300, -300,
2457  -300, 0, 0, -300, -300, -300, 0, -300, 0, 0,
2458  0, 0, 0, 0, 0, 0, 0, -300, -300, 0,
2459  0, 0, 0, 0, 0, 0, 0, -300, -300, 0,
2460  -300, -300, -300, -300, -300, 0, 0, 0, 0, 0,
2461  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2462  0, 0, 0, 0, 0, 0, 0, 0, -300, -300,
2463  -300, -300, -300, -300, -300, -300, -300, -300, -300, -300,
2464  -300, 0, 0, -300, -300, -300, 0, 0, -300, 0,
2465  0, 0, 0, 0, -300, 0, 0, 0, 0, 0,
2466  0, 0, 0, 0, 0, 0, 0, 0, -300, 0,
2467  0, 0, 0, 0, -300, 0, -300, -300, -300, -300,
2468  -300, -300, -300, -300, -300, -300, 0, 0, 0, 0,
2469  0, -300, -300, -300, -300, -601, 224, -300, -300, -300,
2470  0, -300, 0, -601, -601, -601, 0, 0, 0, -601,
2471  -601, 0, -601, 0, 0, 0, 0, 0, 0, 0,
2472  0, -601, 0, 0, 0, 0, 0, 0, 0, 0,
2473  0, 0, -601, -601, 0, -601, -601, -601, -601, -601,
2474  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2475  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2476  0, 0, 0, -601, -601, -601, -601, -601, -601, -601,
2477  -601, -601, -601, -601, -601, -601, 0, 0, -601, -601,
2478  -601, 0, 700, 0, 0, 0, 0, 0, 0, 0,
2479  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2480  0, 0, 0, -601, 0, 0, 0, 0, -106, -601,
2481  0, -601, -601, -601, -601, -601, -601, -601, -601, -601,
2482  -601, 0, 0, 0, 0, -601, -601, -601, -601, -97,
2483  -293, 0, -601, 0, -601, 0, -601, 0, -293, -293,
2484  -293, 0, 0, 0, -293, -293, 0, -293, 0, 0,
2485  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2486  0, 0, 0, 0, 0, 0, 0, -293, -293, 0,
2487  -293, -293, -293, -293, -293, 0, 0, 0, 0, 0,
2488  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2489  0, 0, 0, 0, 0, 0, 0, 0, -293, -293,
2490  -293, -293, -293, -293, -293, -293, -293, -293, -293, -293,
2491  -293, 0, 0, -293, -293, -293, 0, 701, 0, 0,
2492  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2493  0, 0, 0, 0, 0, 0, 0, 0, -293, 0,
2494  0, 0, 0, -108, -293, 0, -293, -293, -293, -293,
2495  -293, -293, -293, -293, -293, -293, 0, 0, 0, 0,
2496  0, -293, -293, -293, -99, 0, 0, -293, 0, -293,
2497  248, -293, 5, 6, 7, 8, 9, -619, -619, -619,
2498  10, 11, 0, 0, -619, 12, 0, 13, 14, 15,
2499  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2500  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2501  0, 0, 0, 0, 28, 29, 249, 31, 32, 33,
2502  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2503  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2504  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2505  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2506  0, 51, 52, 0, 53, 0, 0, 54, 55, 56,
2507  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2508  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2509  0, 0, 0, 0, 0, 63, 64, 65, 0, 0,
2510  0, 0, 0, 0, 0, 0, 0, 0, -619, 248,
2511  -619, 5, 6, 7, 8, 9, 0, 0, -619, 10,
2512  11, 0, -619, -619, 12, 0, 13, 14, 15, 16,
2513  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2514  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2515  0, 0, 0, 28, 29, 249, 31, 32, 33, 34,
2516  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2517  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2518  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2519  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2520  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2521  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2522  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2523  0, 0, 0, 0, 63, 64, 65, 0, 0, 0,
2524  0, 0, 0, 0, 0, 0, 0, -619, 248, -619,
2525  5, 6, 7, 8, 9, 0, 0, -619, 10, 11,
2526  0, 0, -619, 12, -619, 13, 14, 15, 16, 17,
2527  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2528  23, 24, 25, 26, 0, 0, 27, 0, 0, 0,
2529  0, 0, 28, 29, 249, 31, 32, 33, 34, 35,
2530  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2531  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2532  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2533  0, 0, 0, 48, 0, 0, 49, 50, 0, 51,
2534  52, 0, 53, 0, 0, 54, 55, 56, 57, 58,
2535  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
2536  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2537  0, 0, 0, 63, 64, 65, 0, 0, 0, 0,
2538  0, 0, 0, 0, 0, 0, -619, 248, -619, 5,
2539  6, 7, 8, 9, 0, 0, -619, 10, 11, 0,
2540  0, -619, 12, 0, 13, 14, 15, 16, 17, 18,
2541  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2542  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2543  0, 28, 29, 249, 31, 32, 33, 34, 35, 36,
2544  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2545  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2546  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2547  0, 0, 48, 0, 0, 49, 50, 0, 51, 52,
2548  0, 53, 0, 0, 54, 55, 56, 57, 58, 59,
2549  60, 61, 62, 0, 0, 0, 0, 0, 0, 0,
2550  248, 0, 5, 6, 7, 8, 9, 0, -619, -619,
2551  10, 11, 63, 64, 65, 12, 0, 13, 14, 15,
2552  16, 17, 18, 19, 0, -619, 0, -619, 0, 20,
2553  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2554  0, 0, 0, 0, 28, 29, 249, 31, 32, 33,
2555  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2556  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2557  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2558  0, 0, 0, 0, 0, 48, 0, 0, 49, 50,
2559  0, 51, 52, 0, 53, 0, 0, 54, 55, 56,
2560  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2561  0, 0, 0, 248, 0, 5, 6, 7, 8, 9,
2562  0, 0, 0, 10, 11, 63, 64, 65, 12, 0,
2563  13, 14, 15, 16, 17, 18, 19, 0, -619, 0,
2564  -619, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2565  0, 27, 0, 0, 0, 0, 0, 28, 29, 249,
2566  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2567  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2568  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2569  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2570  0, 250, 50, 0, 51, 52, 0, 53, 0, 0,
2571  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2572  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2573  0, 0, 0, 0, 0, 0, 0, 0, 63, 64,
2574  65, 0, 0, 0, 0, 0, 0, 0, 0, -619,
2575  0, -619, 248, -619, 5, 6, 7, 8, 9, 0,
2576  0, 0, 10, 11, 0, 0, 0, 12, 0, 13,
2577  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2578  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2579  27, 0, 0, 0, 0, 0, 28, 29, 249, 31,
2580  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2581  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2582  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2583  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2584  49, 50, 0, 51, 52, 0, 53, 0, 0, 54,
2585  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2586  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2587  0, 0, 0, 0, 0, 0, 0, 63, 64, 65,
2588  0, 0, 0, 0, 0, 0, 0, 0, -619, 0,
2589  -619, 248, -619, 5, 6, 7, 8, 9, 0, 0,
2590  0, 10, 11, 0, 0, 0, 12, 0, 13, 14,
2591  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2592  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2593  0, 0, 0, 0, 0, 28, 29, 249, 31, 32,
2594  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2595  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2596  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2597  0, 0, 0, 0, 0, 0, 48, 0, 0, 49,
2598  50, 0, 51, 52, 0, 53, 0, 0, 54, 55,
2599  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2600  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2601  0, 0, 0, 0, 0, 0, 63, 64, 65, 0,
2602  0, -619, 4, 0, 5, 6, 7, 8, 9, -619,
2603  0, -619, 10, 11, 0, 0, 0, 12, 0, 13,
2604  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2605  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2606  27, 0, 0, 0, 0, 0, 28, 29, 30, 31,
2607  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2608  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2609  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2610  0, 0, 0, 0, 0, 0, 0, 48, 0, 0,
2611  49, 50, 0, 51, 52, 0, 53, 0, 0, 54,
2612  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2613  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2614  0, 0, 0, 0, 0, 0, 0, 63, 64, 65,
2615  0, 0, -619, 0, 0, 0, 0, 0, 0, 0,
2616  -619, 248, -619, 5, 6, 7, 8, 9, 0, 0,
2617  -619, 10, 11, 0, 0, 0, 12, 0, 13, 14,
2618  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2619  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2620  0, 0, 0, 0, 0, 28, 29, 249, 31, 32,
2621  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2622  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2623  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2624  0, 0, 0, 0, 0, 0, 48, 0, 0, 49,
2625  50, 0, 51, 52, 0, 53, 0, 0, 54, 55,
2626  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2627  0, 0, 0, 0, 248, 0, 5, 6, 7, 8,
2628  9, 0, 0, 0, 10, 11, 63, 64, 65, 12,
2629  0, 13, 14, 15, 16, 17, 18, 19, 0, -619,
2630  0, -619, 0, 20, 21, 22, 23, 24, 25, 26,
2631  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2632  249, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2633  40, 0, 41, 42, 0, 43, 44, 45, 0, 46,
2634  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2635  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
2636  0, 0, 49, 50, 0, 51, 52, 0, 53, 0,
2637  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2638  0, -619, 0, 0, 0, 0, 0, 0, 0, 5,
2639  6, 7, 0, 9, 0, 0, 0, 10, 11, 63,
2640  64, 65, 12, 0, 13, 14, 15, 16, 17, 18,
2641  19, 0, -619, 0, -619, 0, 20, 21, 22, 23,
2642  24, 25, 26, 0, 0, 200, 0, 0, 0, 0,
2643  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2644  37, 38, 39, 40, 201, 41, 42, 0, 43, 44,
2645  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2646  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2647  0, 0, 202, 0, 0, 203, 50, 0, 51, 52,
2648  0, 204, 205, 206, 54, 55, 56, 57, 58, 59,
2649  60, 61, 62, 0, 0, 0, 0, 0, 0, 0,
2650  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2651  10, 11, 63, 207, 65, 12, 0, 13, 14, 15,
2652  16, 17, 18, 19, 0, 0, 0, 231, 0, 20,
2653  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2654  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2655  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2656  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2657  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2658  0, 0, 0, 0, 0, 202, 0, 0, 203, 50,
2659  0, 51, 52, 0, 0, 0, 0, 54, 55, 56,
2660  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2661  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2662  0, 0, 0, 10, 11, 63, 64, 65, 12, 0,
2663  13, 14, 15, 16, 17, 18, 19, 0, 302, 0,
2664  303, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2665  0, 27, 0, 0, 0, 0, 0, 0, 29, 0,
2666  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2667  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2668  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2669  0, 0, 0, 0, 0, 0, 0, 0, 202, 0,
2670  0, 203, 50, 0, 51, 52, 0, 0, 0, 0,
2671  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2672  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2673  7, 8, 9, 0, 0, 0, 10, 11, 63, 64,
2674  65, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2675  0, 0, 0, 231, 0, 20, 21, 22, 23, 24,
2676  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2677  28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
2678  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2679  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2680  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2681  0, 48, 0, 0, 49, 50, 0, 51, 52, 0,
2682  53, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2683  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2684  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2685  11, 63, 64, 65, 12, 0, 13, 14, 15, 16,
2686  17, 18, 19, 0, 498, 0, 0, 0, 20, 21,
2687  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2688  0, 0, 0, 28, 29, 249, 31, 32, 33, 34,
2689  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2690  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2691  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2692  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2693  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2694  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2695  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2696  0, 0, 0, 0, 63, 64, 65, 0, 0, 0,
2697  0, 0, 0, 0, 0, 0, 0, 498, 118, 119,
2698  120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
2699  130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2700  140, 141, 0, 0, 0, 142, 143, 144, 384, 385,
2701  386, 387, 149, 150, 151, 0, 0, 0, 0, 0,
2702  152, 153, 154, 155, 388, 389, 390, 391, 160, 37,
2703  38, 392, 40, 0, 0, 0, 0, 0, 0, 0,
2704  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
2705  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
2706  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2707  177, 178, 0, 0, 0, 0, 0, 0, 0, 0,
2708  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2709  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
2710  188, 0, 189, 190, 0, 0, 0, 0, 0, 0,
2711  191, 393, 118, 119, 120, 121, 122, 123, 124, 125,
2712  126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
2713  136, 137, 138, 139, 140, 141, 0, 0, 0, 142,
2714  143, 144, 145, 146, 147, 148, 149, 150, 151, 0,
2715  0, 0, 0, 0, 152, 153, 154, 155, 156, 157,
2716  158, 159, 160, 280, 281, 161, 282, 0, 0, 0,
2717  0, 0, 0, 0, 0, 162, 163, 164, 165, 166,
2718  167, 168, 169, 170, 0, 0, 171, 172, 0, 0,
2719  173, 174, 175, 176, 0, 0, 0, 0, 0, 0,
2720  0, 0, 0, 0, 177, 178, 0, 0, 0, 0,
2721  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2722  0, 0, 0, 0, 0, 179, 180, 181, 182, 183,
2723  184, 185, 186, 187, 188, 0, 189, 190, 0, 0,
2724  0, 0, 0, 0, 191, 118, 119, 120, 121, 122,
2725  123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
2726  133, 134, 135, 136, 137, 138, 139, 140, 141, 0,
2727  0, 0, 142, 143, 144, 145, 146, 147, 148, 149,
2728  150, 151, 0, 0, 0, 0, 0, 152, 153, 154,
2729  155, 156, 157, 158, 159, 160, 233, 0, 161, 0,
2730  0, 0, 0, 0, 0, 0, 0, 0, 162, 163,
2731  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
2732  172, 0, 0, 173, 174, 175, 176, 0, 0, 0,
2733  0, 0, 0, 0, 0, 0, 0, 177, 178, 0,
2734  0, 55, 0, 0, 0, 0, 0, 0, 0, 0,
2735  0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
2736  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
2737  190, 0, 0, 0, 0, 0, 0, 191, 118, 119,
2738  120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
2739  130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
2740  140, 141, 0, 0, 0, 142, 143, 144, 145, 146,
2741  147, 148, 149, 150, 151, 0, 0, 0, 0, 0,
2742  152, 153, 154, 155, 156, 157, 158, 159, 160, 0,
2743  0, 161, 0, 0, 0, 0, 0, 0, 0, 0,
2744  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
2745  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
2746  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2747  177, 178, 0, 0, 55, 0, 0, 0, 0, 0,
2748  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2749  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
2750  188, 0, 189, 190, 0, 0, 0, 0, 0, 0,
2751  191, 118, 119, 120, 121, 122, 123, 124, 125, 126,
2752  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
2753  137, 138, 139, 140, 141, 0, 0, 0, 142, 143,
2754  144, 145, 146, 147, 148, 149, 150, 151, 0, 0,
2755  0, 0, 0, 152, 153, 154, 155, 156, 157, 158,
2756  159, 160, 0, 0, 161, 0, 0, 0, 0, 0,
2757  0, 0, 0, 0, 162, 163, 164, 165, 166, 167,
2758  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
2759  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
2760  0, 0, 0, 177, 178, 0, 0, 0, 0, 0,
2761  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2762  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
2763  185, 186, 187, 188, 0, 189, 190, 5, 6, 7,
2764  0, 9, 0, 191, 0, 10, 11, 0, 0, 0,
2765  12, 0, 13, 14, 15, 238, 239, 18, 19, 0,
2766  0, 0, 0, 0, 240, 241, 242, 23, 24, 25,
2767  26, 0, 0, 200, 0, 0, 0, 0, 0, 0,
2768  268, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2769  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2770  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2771  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2772  269, 0, 0, 203, 50, 0, 51, 52, 0, 0,
2773  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2774  62, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2775  9, 0, 0, 0, 10, 11, 0, 0, 0, 12,
2776  270, 13, 14, 15, 238, 239, 18, 19, 271, 0,
2777  0, 0, 0, 240, 241, 242, 23, 24, 25, 26,
2778  0, 0, 200, 0, 0, 0, 0, 0, 0, 268,
2779  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2780  40, 0, 41, 42, 0, 43, 44, 45, 0, 0,
2781  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2782  0, 0, 0, 0, 0, 0, 0, 0, 0, 269,
2783  0, 0, 203, 50, 0, 51, 52, 0, 0, 0,
2784  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2785  0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
2786  0, 0, 0, 10, 11, 0, 0, 0, 12, 270,
2787  13, 14, 15, 16, 17, 18, 19, 518, 0, 0,
2788  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2789  0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
2790  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2791  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2792  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2793  0, 0, 0, 0, 0, 0, 0, 0, 48, 0,
2794  0, 49, 50, 0, 51, 52, 0, 53, 0, 0,
2795  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2796  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2797  7, 0, 9, 0, 0, 0, 10, 11, 63, 64,
2798  65, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2799  0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2800  25, 26, 0, 0, 200, 0, 0, 0, 0, 0,
2801  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2802  38, 39, 40, 201, 41, 42, 0, 43, 44, 45,
2803  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2804  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2805  0, 202, 0, 0, 203, 50, 0, 51, 52, 0,
2806  204, 205, 206, 54, 55, 56, 57, 58, 59, 60,
2807  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2808  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2809  11, 63, 207, 65, 12, 0, 13, 14, 15, 16,
2810  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2811  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2812  0, 0, 0, 28, 29, 0, 31, 32, 33, 34,
2813  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2814  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2815  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2816  0, 0, 0, 0, 48, 0, 0, 49, 50, 0,
2817  51, 52, 0, 53, 0, 0, 54, 55, 56, 57,
2818  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2819  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2820  0, 0, 10, 11, 63, 64, 65, 12, 0, 13,
2821  14, 15, 238, 239, 18, 19, 0, 0, 0, 0,
2822  0, 240, 241, 242, 23, 24, 25, 26, 0, 0,
2823  200, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2824  32, 33, 34, 35, 36, 37, 38, 39, 40, 201,
2825  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2826  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2827  0, 0, 0, 0, 0, 0, 0, 202, 0, 0,
2828  203, 50, 0, 51, 52, 0, 608, 205, 206, 54,
2829  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2830  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2831  0, 9, 0, 0, 0, 10, 11, 63, 207, 65,
2832  12, 0, 13, 14, 15, 238, 239, 18, 19, 0,
2833  0, 0, 0, 0, 240, 241, 242, 23, 24, 25,
2834  26, 0, 0, 200, 0, 0, 0, 0, 0, 0,
2835  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2836  39, 40, 201, 41, 42, 0, 43, 44, 45, 0,
2837  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2838  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2839  202, 0, 0, 203, 50, 0, 51, 52, 0, 204,
2840  205, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2841  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2842  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2843  63, 207, 65, 12, 0, 13, 14, 15, 238, 239,
2844  18, 19, 0, 0, 0, 0, 0, 240, 241, 242,
2845  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
2846  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2847  36, 37, 38, 39, 40, 201, 41, 42, 0, 43,
2848  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2849  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2850  0, 0, 0, 202, 0, 0, 203, 50, 0, 51,
2851  52, 0, 0, 205, 206, 54, 55, 56, 57, 58,
2852  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
2853  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2854  0, 10, 11, 63, 207, 65, 12, 0, 13, 14,
2855  15, 238, 239, 18, 19, 0, 0, 0, 0, 0,
2856  240, 241, 242, 23, 24, 25, 26, 0, 0, 200,
2857  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
2858  33, 34, 35, 36, 37, 38, 39, 40, 201, 41,
2859  42, 0, 43, 44, 45, 0, 46, 47, 0, 0,
2860  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2861  0, 0, 0, 0, 0, 0, 202, 0, 0, 203,
2862  50, 0, 51, 52, 0, 608, 205, 0, 54, 55,
2863  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2864  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2865  9, 0, 0, 0, 10, 11, 63, 207, 65, 12,
2866  0, 13, 14, 15, 238, 239, 18, 19, 0, 0,
2867  0, 0, 0, 240, 241, 242, 23, 24, 25, 26,
2868  0, 0, 200, 0, 0, 0, 0, 0, 0, 29,
2869  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2870  40, 201, 41, 42, 0, 43, 44, 45, 0, 46,
2871  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2872  0, 0, 0, 0, 0, 0, 0, 0, 0, 202,
2873  0, 0, 203, 50, 0, 51, 52, 0, 0, 205,
2874  0, 54, 55, 56, 57, 58, 59, 60, 61, 62,
2875  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2876  6, 7, 0, 9, 0, 0, 0, 10, 11, 63,
2877  207, 65, 12, 0, 13, 14, 15, 16, 17, 18,
2878  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2879  24, 25, 26, 0, 0, 200, 0, 0, 0, 0,
2880  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2881  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
2882  45, 0, 46, 47, 0, 0, 0, 0, 0, 0,
2883  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2884  0, 0, 202, 0, 0, 203, 50, 0, 51, 52,
2885  0, 512, 0, 0, 54, 55, 56, 57, 58, 59,
2886  60, 61, 62, 0, 0, 0, 0, 0, 0, 0,
2887  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2888  10, 11, 63, 207, 65, 12, 0, 13, 14, 15,
2889  238, 239, 18, 19, 0, 0, 0, 0, 0, 240,
2890  241, 242, 23, 24, 25, 26, 0, 0, 200, 0,
2891  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2892  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2893  0, 43, 44, 45, 0, 46, 47, 0, 0, 0,
2894  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2895  0, 0, 0, 0, 0, 202, 0, 0, 203, 50,
2896  0, 51, 52, 0, 204, 0, 0, 54, 55, 56,
2897  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2898  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2899  0, 0, 0, 10, 11, 63, 207, 65, 12, 0,
2900  13, 14, 15, 238, 239, 18, 19, 0, 0, 0,
2901  0, 0, 240, 241, 242, 23, 24, 25, 26, 0,
2902  0, 200, 0, 0, 0, 0, 0, 0, 29, 0,
2903  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2904  0, 41, 42, 0, 43, 44, 45, 0, 46, 47,
2905  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2906  0, 0, 0, 0, 0, 0, 0, 0, 202, 0,
2907  0, 203, 50, 0, 51, 52, 0, 816, 0, 0,
2908  54, 55, 56, 57, 58, 59, 60, 61, 62, 0,
2909  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2910  7, 0, 9, 0, 0, 0, 10, 11, 63, 207,
2911  65, 12, 0, 13, 14, 15, 238, 239, 18, 19,
2912  0, 0, 0, 0, 0, 240, 241, 242, 23, 24,
2913  25, 26, 0, 0, 200, 0, 0, 0, 0, 0,
2914  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2915  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
2916  0, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2917  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2918  0, 202, 0, 0, 203, 50, 0, 51, 52, 0,
2919  512, 0, 0, 54, 55, 56, 57, 58, 59, 60,
2920  61, 62, 0, 0, 0, 0, 0, 0, 0, 0,
2921  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2922  11, 63, 207, 65, 12, 0, 13, 14, 15, 238,
2923  239, 18, 19, 0, 0, 0, 0, 0, 240, 241,
2924  242, 23, 24, 25, 26, 0, 0, 200, 0, 0,
2925  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
2926  35, 36, 37, 38, 39, 40, 0, 41, 42, 0,
2927  43, 44, 45, 0, 46, 47, 0, 0, 0, 0,
2928  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2929  0, 0, 0, 0, 202, 0, 0, 203, 50, 0,
2930  51, 52, 0, 608, 0, 0, 54, 55, 56, 57,
2931  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2932  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2933  0, 0, 10, 11, 63, 207, 65, 12, 0, 13,
2934  14, 15, 238, 239, 18, 19, 0, 0, 0, 0,
2935  0, 240, 241, 242, 23, 24, 25, 26, 0, 0,
2936  200, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2937  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2938  41, 42, 0, 43, 44, 45, 0, 46, 47, 0,
2939  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2940  0, 0, 0, 0, 0, 0, 0, 202, 0, 0,
2941  203, 50, 0, 51, 52, 0, 0, 0, 0, 54,
2942  55, 56, 57, 58, 59, 60, 61, 62, 0, 0,
2943  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2944  0, 9, 0, 0, 0, 10, 11, 63, 207, 65,
2945  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2946  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2947  26, 0, 0, 27, 0, 0, 0, 0, 0, 0,
2948  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2949  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
2950  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2951  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2952  202, 0, 0, 203, 50, 0, 51, 52, 0, 0,
2953  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
2954  62, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2955  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2956  63, 64, 65, 12, 0, 13, 14, 15, 16, 17,
2957  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2958  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
2959  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2960  36, 37, 38, 39, 40, 0, 41, 42, 0, 43,
2961  44, 45, 0, 46, 47, 0, 0, 0, 0, 0,
2962  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2963  0, 0, 0, 202, 0, 0, 203, 50, 0, 51,
2964  52, 0, 0, 0, 0, 54, 55, 56, 57, 58,
2965  59, 60, 61, 62, 0, 0, 0, 0, 0, 0,
2966  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
2967  0, 10, 11, 63, 207, 65, 12, 0, 13, 14,
2968  15, 238, 239, 18, 19, 0, 0, 0, 0, 0,
2969  240, 241, 242, 23, 24, 25, 26, 0, 0, 200,
2970  0, 0, 0, 0, 0, 0, 268, 0, 0, 32,
2971  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2972  42, 0, 43, 44, 45, 0, 0, 0, 0, 0,
2973  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2974  0, 0, 0, 0, 0, 0, 269, 0, 0, 323,
2975  50, 0, 51, 52, 0, 324, 0, 0, 54, 55,
2976  56, 57, 58, 59, 60, 61, 62, 0, 0, 0,
2977  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2978  10, 11, 0, 0, 0, 12, 270, 13, 14, 15,
2979  238, 239, 18, 19, 0, 0, 0, 0, 0, 240,
2980  241, 242, 23, 24, 25, 26, 0, 0, 200, 0,
2981  0, 0, 0, 0, 0, 268, 0, 0, 32, 33,
2982  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2983  0, 43, 44, 45, 0, 0, 0, 0, 0, 0,
2984  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2985  0, 0, 0, 0, 0, 365, 0, 0, 49, 50,
2986  0, 51, 52, 0, 53, 0, 0, 54, 55, 56,
2987  57, 58, 59, 60, 61, 62, 0, 0, 0, 0,
2988  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2989  11, 0, 0, 0, 12, 270, 13, 14, 15, 238,
2990  239, 18, 19, 0, 0, 0, 0, 0, 240, 241,
2991  242, 23, 24, 25, 26, 0, 0, 200, 0, 0,
2992  0, 0, 0, 0, 268, 0, 0, 32, 33, 34,
2993  373, 36, 37, 38, 374, 40, 0, 41, 42, 0,
2994  43, 44, 45, 0, 0, 0, 0, 0, 0, 0,
2995  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2996  0, 375, 0, 0, 376, 0, 0, 203, 50, 0,
2997  51, 52, 0, 0, 0, 0, 54, 55, 56, 57,
2998  58, 59, 60, 61, 62, 0, 0, 0, 0, 0,
2999  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
3000  0, 0, 0, 12, 270, 13, 14, 15, 238, 239,
3001  18, 19, 0, 0, 0, 0, 0, 240, 241, 242,
3002  23, 24, 25, 26, 0, 0, 200, 0, 0, 0,
3003  0, 0, 0, 268, 0, 0, 32, 33, 34, 373,
3004  36, 37, 38, 374, 40, 0, 41, 42, 0, 43,
3005  44, 45, 0, 0, 0, 0, 0, 0, 0, 0,
3006  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3007  0, 0, 0, 376, 0, 0, 203, 50, 0, 51,
3008  52, 0, 0, 0, 0, 54, 55, 56, 57, 58,
3009  59, 60, 61, 62, 0, 0, 0, 0, 0, 5,
3010  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
3011  0, 0, 12, 270, 13, 14, 15, 238, 239, 18,
3012  19, 0, 0, 0, 0, 0, 240, 241, 242, 23,
3013  24, 25, 26, 0, 0, 200, 0, 0, 0, 0,
3014  0, 0, 268, 0, 0, 32, 33, 34, 35, 36,
3015  37, 38, 39, 40, 0, 41, 42, 0, 43, 44,
3016  45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3017  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3018  0, 0, 269, 0, 0, 323, 50, 0, 51, 52,
3019  0, 0, 0, 0, 54, 55, 56, 57, 58, 59,
3020  60, 61, 62, 0, 0, 0, 0, 0, 5, 6,
3021  7, 0, 9, 0, 0, 0, 10, 11, 0, 0,
3022  0, 12, 270, 13, 14, 15, 238, 239, 18, 19,
3023  0, 0, 0, 0, 0, 240, 241, 242, 23, 24,
3024  25, 26, 0, 0, 200, 0, 0, 0, 0, 0,
3025  0, 268, 0, 0, 32, 33, 34, 35, 36, 37,
3026  38, 39, 40, 0, 41, 42, 0, 43, 44, 45,
3027  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3028  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3029  0, 893, 0, 0, 203, 50, 0, 51, 52, 0,
3030  0, 0, 0, 54, 55, 56, 57, 58, 59, 60,
3031  61, 62, 0, 0, 0, 0, 0, 5, 6, 7,
3032  0, 9, 0, 0, 0, 10, 11, 0, 0, 0,
3033  12, 270, 13, 14, 15, 238, 239, 18, 19, 0,
3034  0, 0, 0, 0, 240, 241, 242, 23, 24, 25,
3035  26, 0, 0, 200, 0, 0, 0, 0, 0, 0,
3036  268, 0, 0, 32, 33, 34, 35, 36, 37, 38,
3037  39, 40, 0, 41, 42, 0, 43, 44, 45, 0,
3038  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3039  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3040  973, 0, 0, 203, 50, 0, 51, 52, 0, 0,
3041  0, 0, 54, 55, 56, 57, 58, 59, 60, 61,
3042  62, 0, 0, 0, 0, 0, 0, 553, 554, 0,
3043  0, 555, 0, 0, 0, 0, 0, 0, 0, 0,
3044  270, 162, 163, 164, 165, 166, 167, 168, 169, 170,
3045  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
3046  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3047  177, 178, 0, 0, 0, 0, 0, 0, 0, 0,
3048  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3049  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
3050  188, 0, 189, 190, 561, 562, 0, 0, 563, 0,
3051  191, 0, 0, 0, 0, 0, 0, 0, 162, 163,
3052  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
3053  172, 0, 0, 173, 174, 175, 176, 0, 0, 0,
3054  0, 0, 0, 0, 0, 0, 0, 177, 178, 0,
3055  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3056  0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
3057  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
3058  190, 598, 562, 0, 0, 599, 0, 191, 0, 0,
3059  0, 0, 0, 0, 0, 162, 163, 164, 165, 166,
3060  167, 168, 169, 170, 0, 0, 171, 172, 0, 0,
3061  173, 174, 175, 176, 0, 0, 0, 0, 0, 0,
3062  0, 0, 0, 0, 177, 178, 0, 0, 0, 0,
3063  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3064  0, 0, 0, 0, 0, 179, 180, 181, 182, 183,
3065  184, 185, 186, 187, 188, 0, 189, 190, 612, 554,
3066  0, 0, 613, 0, 191, 0, 0, 0, 0, 0,
3067  0, 0, 162, 163, 164, 165, 166, 167, 168, 169,
3068  170, 0, 0, 171, 172, 0, 0, 173, 174, 175,
3069  176, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3070  0, 177, 178, 0, 0, 0, 0, 0, 0, 0,
3071  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3072  0, 0, 179, 180, 181, 182, 183, 184, 185, 186,
3073  187, 188, 0, 189, 190, 615, 562, 0, 0, 616,
3074  0, 191, 0, 0, 0, 0, 0, 0, 0, 162,
3075  163, 164, 165, 166, 167, 168, 169, 170, 0, 0,
3076  171, 172, 0, 0, 173, 174, 175, 176, 0, 0,
3077  0, 0, 0, 0, 0, 0, 0, 0, 177, 178,
3078  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3079  0, 0, 0, 0, 0, 0, 0, 0, 0, 179,
3080  180, 181, 182, 183, 184, 185, 186, 187, 188, 0,
3081  189, 190, 639, 554, 0, 0, 640, 0, 191, 0,
3082  0, 0, 0, 0, 0, 0, 162, 163, 164, 165,
3083  166, 167, 168, 169, 170, 0, 0, 171, 172, 0,
3084  0, 173, 174, 175, 176, 0, 0, 0, 0, 0,
3085  0, 0, 0, 0, 0, 177, 178, 0, 0, 0,
3086  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3087  0, 0, 0, 0, 0, 0, 179, 180, 181, 182,
3088  183, 184, 185, 186, 187, 188, 0, 189, 190, 642,
3089  562, 0, 0, 643, 0, 191, 0, 0, 0, 0,
3090  0, 0, 0, 162, 163, 164, 165, 166, 167, 168,
3091  169, 170, 0, 0, 171, 172, 0, 0, 173, 174,
3092  175, 176, 0, 0, 0, 0, 0, 0, 0, 0,
3093  0, 0, 177, 178, 0, 0, 0, 0, 0, 0,
3094  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3095  0, 0, 0, 179, 180, 181, 182, 183, 184, 185,
3096  186, 187, 188, 0, 189, 190, 727, 554, 0, 0,
3097  728, 0, 191, 0, 0, 0, 0, 0, 0, 0,
3098  162, 163, 164, 165, 166, 167, 168, 169, 170, 0,
3099  0, 171, 172, 0, 0, 173, 174, 175, 176, 0,
3100  0, 0, 0, 0, 0, 0, 0, 0, 0, 177,
3101  178, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3102  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3103  179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
3104  0, 189, 190, 730, 562, 0, 0, 731, 0, 191,
3105  0, 0, 0, 0, 0, 0, 0, 162, 163, 164,
3106  165, 166, 167, 168, 169, 170, 0, 0, 171, 172,
3107  0, 0, 173, 174, 175, 176, 0, 0, 0, 0,
3108  0, 0, 0, 0, 0, 0, 177, 178, 0, 0,
3109  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3110  0, 0, 0, 0, 0, 0, 0, 179, 180, 181,
3111  182, 183, 184, 185, 186, 187, 188, 0, 189, 190,
3112  737, 554, 0, 0, 738, 0, 191, 0, 0, 0,
3113  0, 0, 0, 0, 162, 163, 164, 165, 166, 167,
3114  168, 169, 170, 0, 0, 171, 172, 0, 0, 173,
3115  174, 175, 176, 0, 0, 0, 0, 0, 0, 0,
3116  0, 0, 0, 177, 178, 0, 0, 0, 0, 0,
3117  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3118  0, 0, 0, 0, 179, 180, 181, 182, 183, 184,
3119  185, 186, 187, 188, 0, 189, 190, 1001, 554, 0,
3120  0, 1002, 0, 191, 0, 0, 0, 0, 0, 0,
3121  0, 162, 163, 164, 165, 166, 167, 168, 169, 170,
3122  0, 0, 171, 172, 0, 0, 173, 174, 175, 176,
3123  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3124  177, 178, 0, 0, 0, 0, 0, 0, 0, 0,
3125  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3126  0, 179, 180, 181, 182, 183, 184, 185, 186, 187,
3127  188, 0, 189, 190, 1036, 554, 0, 0, 1037, 0,
3128  191, 0, 0, 0, 0, 0, 0, 0, 162, 163,
3129  164, 165, 166, 167, 168, 169, 170, 0, 0, 171,
3130  172, 0, 0, 173, 174, 175, 176, 0, 0, 0,
3131  0, 0, 0, 0, 0, 0, 0, 177, 178, 0,
3132  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3133  0, 0, 0, 0, 0, 0, 0, 0, 179, 180,
3134  181, 182, 183, 184, 185, 186, 187, 188, 0, 189,
3135  190, 1039, 562, 0, 0, 1040, 0, 191, 0, 0,
3136  0, 0, 0, 0, 0, 162, 163, 164, 165, 166,
3137  167, 168, 169, 170, 0, 0, 171, 172, 0, 0,
3138  173, 174, 175, 176, 0, 0, 0, 0, 0, 0,
3139  0, 0, 0, 0, 177, 178, 0, 0, 0, 0,
3140  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3141  0, 0, 0, 0, 0, 179, 180, 181, 182, 183,
3142  184, 185, 186, 187, 188, 0, 189, 190, 0, 0,
3143  0, 0, 0, 0, 191
3144 };
3145 
3146 #define yypact_value_is_default(yystate) \
3147  ((yystate) == (-810))
3148 
3149 #define yytable_value_is_error(yytable_value) \
3150  ((yytable_value) == (-620))
3151 
3152 static const yytype_int16 yycheck[] =
3153 {
3154  2, 55, 96, 16, 17, 8, 79, 20, 22, 64,
3155  354, 326, 16, 17, 8, 220, 20, 50, 27, 8,
3156  29, 472, 326, 28, 87, 28, 359, 90, 412, 353,
3157  4, 355, 420, 74, 28, 2, 420, 4, 53, 28,
3158  94, 668, 49, 90, 575, 594, 614, 51, 262, 51,
3159  52, 685, 266, 86, 87, 574, 67, 90, 440, 468,
3160  74, 55, 13, 651, 79, 786, 2, 376, 4, 49,
3161  458, 508, 416, 641, 511, 399, 91, 92, 93, 27,
3162  16, 17, 53, 776, 20, 874, 250, 472, 67, 778,
3163  87, 415, 715, 417, 16, 17, 719, 906, 20, 26,
3164  94, 872, 0, 37, 38, 13, 25, 230, 801, 518,
3165  25, 90, 26, 49, 50, 85, 113, 53, 25, 443,
3166  141, 61, 61, 13, 1, 85, 470, 85, 64, 85,
3167  16, 17, 255, 25, 20, 97, 259, 134, 902, 76,
3168  130, 85, 134, 79, 778, 596, 25, 471, 28, 141,
3169  86, 87, 786, 29, 90, 91, 92, 93, 120, 323,
3170  286, 729, 288, 133, 290, 51, 52, 938, 294, 25,
3171  110, 110, 740, 133, 25, 133, 132, 133, 805, 806,
3172  25, 118, 770, 771, 25, 136, 56, 736, 139, 133,
3173  141, 139, 13, 141, 140, 744, 203, 230, 271, 232,
3174  113, 990, 243, 130, 1013, 252, 657, 141, 897, 136,
3175  140, 224, 214, 226, 227, 134, 130, 136, 220, 134,
3176  224, 992, 226, 944, 429, 227, 134, 134, 13, 13,
3177  237, 139, 134, 141, 622, 111, 580, 621, 622, 1003,
3178  117, 252, 134, 250, 307, 308, 309, 310, 592, 139,
3179  632, 141, 85, 690, 1025, 134, 271, 581, 885, 268,
3180  949, 113, 139, 897, 141, 85, 321, 203, 902, 593,
3181  250, 326, 657, 252, 307, 308, 309, 310, 134, 312,
3182  313, 248, 591, 134, 872, 136, 874, 696, 224, 134,
3183  226, 227, 743, 134, 230, 87, 232, 360, 361, 422,
3184  133, 237, 224, 426, 226, 928, 37, 38, 431, 324,
3185  944, 87, 248, 133, 250, 362, 323, 321, 139, 1008,
3186  141, 113, 326, 68, 447, 113, 136, 360, 361, 452,
3187  100, 141, 306, 852, 87, 271, 963, 113, 224, 306,
3188  226, 354, 375, 323, 311, 61, 134, 402, 403, 65,
3189  938, 939, 354, 324, 139, 139, 141, 141, 743, 485,
3190  113, 355, 25, 61, 85, 140, 492, 61, 140, 1003,
3191  306, 307, 308, 309, 310, 311, 312, 313, 123, 124,
3192  125, 930, 697, 362, 139, 321, 141, 323, 324, 136,
3193  326, 107, 725, 109, 517, 468, 685, 928, 15, 378,
3194  17, 25, 990, 416, 992, 399, 611, 68, 85, 107,
3195  714, 109, 133, 107, 416, 109, 26, 85, 354, 134,
3196  356, 85, 636, 417, 360, 361, 428, 429, 85, 52,
3197  56, 26, 437, 56, 437, 87, 26, 1025, 440, 375,
3198  989, 113, 140, 437, 85, 518, 140, 134, 437, 443,
3199  113, 134, 88, 468, 85, 132, 133, 470, 141, 136,
3200  121, 122, 123, 124, 125, 133, 402, 403, 470, 133,
3201  1038, 134, 87, 440, 137, 85, 133, 471, 141, 867,
3202  416, 87, 87, 867, 935, 87, 134, 703, 134, 113,
3203  85, 132, 133, 141, 710, 85, 136, 786, 113, 61,
3204  789, 132, 133, 518, 440, 507, 508, 113, 61, 511,
3205  134, 113, 61, 137, 450, 136, 557, 141, 130, 134,
3206  130, 26, 132, 133, 565, 52, 412, 54, 55, 56,
3207  57, 68, 468, 542, 470, 130, 136, 132, 133, 137,
3208  130, 136, 132, 133, 558, 107, 136, 109, 110, 85,
3209  113, 560, 566, 138, 107, 760, 109, 110, 107, 600,
3210  109, 110, 595, 570, 637, 572, 568, 580, 670, 455,
3211  672, 131, 576, 85, 59, 60, 577, 87, 580, 592,
3212  85, 56, 518, 916, 87, 110, 600, 581, 87, 922,
3213  592, 87, 625, 85, 573, 574, 132, 133, 600, 593,
3214  605, 61, 605, 113, 134, 614, 110, 134, 587, 611,
3215  113, 605, 110, 902, 113, 904, 605, 113, 68, 742,
3216  132, 133, 637, 696, 134, 130, 110, 132, 133, 58,
3217  632, 136, 641, 68, 570, 134, 572, 61, 761, 68,
3218  132, 133, 697, 94, 580, 700, 701, 107, 685, 109,
3219  110, 774, 707, 708, 748, 944, 592, 946, 594, 595,
3220  85, 134, 951, 704, 666, 632, 668, 96, 97, 732,
3221  711, 17, 735, 1017, 59, 60, 685, 139, 87, 686,
3222  58, 696, 689, 107, 691, 109, 110, 56, 690, 625,
3223  68, 120, 746, 25, 1018, 137, 632, 85, 134, 732,
3224  134, 637, 735, 685, 113, 131, 134, 132, 133, 711,
3225  714, 130, 714, 715, 1003, 717, 1005, 719, 96, 97,
3226  729, 1010, 134, 724, 52, 134, 54, 55, 56, 57,
3227  85, 740, 14, 15, 140, 621, 859, 140, 1027, 134,
3228  741, 134, 120, 780, 132, 133, 85, 784, 871, 113,
3229  686, 134, 746, 689, 733, 691, 136, 10, 760, 1048,
3230  696, 697, 8, 85, 700, 701, 745, 776, 2, 13,
3231  4, 707, 708, 828, 85, 131, 85, 132, 133, 842,
3232  882, 883, 16, 17, 799, 887, 20, 889, 890, 113,
3233  134, 134, 801, 132, 133, 52, 732, 134, 780, 735,
3234  736, 134, 52, 805, 806, 134, 134, 814, 744, 842,
3235  132, 133, 52, 134, 115, 49, 50, 54, 55, 138,
3236  57, 132, 133, 132, 133, 15, 63, 64, 134, 87,
3237  64, 131, 839, 113, 118, 837, 134, 134, 840, 846,
3238  847, 134, 843, 850, 845, 52, 87, 54, 55, 56,
3239  57, 58, 86, 87, 855, 113, 90, 134, 134, 860,
3240  897, 68, 899, 799, 139, 902, 10, 904, 131, 10,
3241  877, 878, 113, 852, 134, 854, 134, 892, 814, 808,
3242  809, 9, 89, 885, 891, 88, 134, 134, 95, 96,
3243  97, 134, 828, 134, 996, 997, 998, 999, 54, 137,
3244  915, 134, 134, 839, 56, 118, 842, 63, 64, 131,
3245  846, 847, 919, 120, 850, 897, 123, 899, 134, 134,
3246  902, 10, 904, 131, 925, 926, 928, 52, 108, 54,
3247  55, 56, 57, 52, 141, 54, 55, 56, 57, 58,
3248  134, 877, 878, 134, 1046, 134, 134, 56, 52, 68,
3249  54, 55, 56, 57, 136, 891, 892, 134, 134, 134,
3250  969, 963, 136, 450, 89, 91, 1003, 711, 1005, 203,
3251  89, 1008, 979, 1010, 981, 93, 1020, 96, 97, 915,
3252  987, 770, 685, 919, 1013, 89, 749, 988, 1019, 99,
3253  224, 95, 226, 227, 930, 294, 230, 57, 232, 94,
3254  935, 120, 780, 237, 1017, 52, 899, 54, 55, 56,
3255  57, 1048, 897, 778, 248, 1017, 250, 1019, 1020, 396,
3256  1021, 1003, 1023, 1005, 1018, -1, 1008, -1, 1010, 1038,
3257  -1, 960, 961, -1, -1, 964, -1, 966, 967, -1,
3258  -1, -1, 89, 979, 68, 981, -1, -1, 95, -1,
3259  -1, 987, -1, 989, 68, -1, -1, -1, -1, 83,
3260  84, 40, 41, 42, 43, 44, 1048, -1, -1, 83,
3261  84, -1, 306, 307, 308, 309, 310, 311, 312, 313,
3262  52, 1017, 54, 55, 56, 57, -1, 321, -1, 323,
3263  -1, -1, 326, -1, 118, 119, 120, 121, 122, 123,
3264  124, 125, 1031, 1032, 1033, 1034, 120, 121, 122, 123,
3265  124, 125, -1, -1, -1, -1, -1, -1, -1, -1,
3266  354, -1, 356, -1, -1, 1054, 360, 361, -1, -1,
3267  -1, -1, -1, 52, -1, 54, 55, 56, 57, 58,
3268  -1, 375, -1, -1, -1, -1, -1, -1, 0, 68,
3269  -1, -1, -1, -1, -1, -1, 8, 9, 10, -1,
3270  -1, 13, 14, 15, -1, 17, -1, -1, 402, 403,
3271  89, -1, -1, -1, 26, 27, 95, 96, 97, -1,
3272  -1, -1, 416, -1, -1, 37, 38, 68, 40, 41,
3273  42, 43, 44, -1, 52, -1, 54, 55, 56, 57,
3274  58, 120, 83, 84, 123, -1, 440, -1, -1, -1,
3275  68, -1, -1, -1, -1, -1, 450, 136, -1, -1,
3276  -1, -1, -1, -1, 16, 17, -1, -1, 20, -1,
3277  -1, 89, -1, 85, -1, -1, 470, 95, 96, 97,
3278  121, 122, 123, 124, 125, -1, -1, -1, -1, -1,
3279  -1, -1, -1, -1, 46, 47, 108, -1, -1, 51,
3280  52, -1, 120, -1, -1, 123, -1, -1, -1, -1,
3281  -1, -1, 64, 65, -1, 44, -1, -1, 130, 131,
3282  -1, 133, -1, -1, 136, 137, -1, 139, -1, 141,
3283  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
3284  69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
3285  79, 80, -1, -1, 83, 84, -1, -1, -1, -1,
3286  -1, -1, -1, -1, -1, -1, 52, -1, 54, 55,
3287  56, 57, 58, -1, -1, -1, 570, -1, 572, -1,
3288  -1, -1, 68, -1, -1, 114, 580, 116, 117, 118,
3289  119, 120, 121, 122, 123, 124, 125, -1, 592, -1,
3290  594, 595, -1, 89, -1, 134, -1, -1, -1, 95,
3291  96, 97, -1, 68, 69, 70, 71, 72, 73, 74,
3292  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3293  -1, 625, -1, -1, 120, -1, -1, 123, 632, -1,
3294  -1, -1, 2, -1, 4, -1, -1, -1, -1, 201,
3295  136, -1, 204, 205, 206, 207, -1, -1, 52, 114,
3296  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3297  125, -1, 224, -1, 226, 227, -1, -1, 52, -1,
3298  54, 55, 56, 57, 58, -1, 141, -1, -1, 49,
3299  -1, -1, 686, 53, 68, 689, -1, 691, -1, -1,
3300  -1, -1, -1, 697, -1, -1, 700, 701, -1, -1,
3301  -1, -1, -1, 707, 708, 89, -1, -1, -1, 79,
3302  -1, 95, 96, 97, -1, -1, -1, -1, -1, -1,
3303  -1, 91, 92, 93, 94, -1, -1, -1, 732, -1,
3304  -1, 735, 736, -1, -1, -1, 120, -1, -1, 123,
3305  744, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3306  -1, -1, -1, -1, -1, -1, -1, -1, -1, 321,
3307  -1, -1, -1, -1, 326, 327, 328, 329, 330, 331,
3308  332, 333, 334, 335, 336, 337, 338, 339, 340, 341,
3309  342, 343, 344, 345, 346, 347, 348, 349, 350, 351,
3310  352, -1, 354, -1, -1, -1, -1, 201, -1, -1,
3311  204, 205, 206, -1, -1, -1, -1, -1, -1, -1,
3312  814, -1, -1, -1, -1, 52, -1, 54, 55, 56,
3313  57, 58, -1, -1, 828, -1, -1, -1, -1, -1,
3314  -1, 68, -1, 203, -1, 839, -1, -1, 842, -1,
3315  402, 403, 846, 847, -1, -1, 850, -1, 410, 411,
3316  412, -1, 89, -1, 416, -1, 418, 419, 420, 96,
3317  97, -1, -1, -1, -1, -1, -1, 237, -1, -1,
3318  -1, -1, -1, 877, 878, -1, -1, 439, 248, -1,
3319  250, -1, 444, 120, -1, -1, -1, 891, -1, -1,
3320  -1, -1, -1, 455, -1, -1, 458, -1, -1, -1,
3321  -1, 271, -1, -1, -1, 2, -1, 4, 470, -1,
3322  -1, -1, -1, -1, -1, 919, -1, 321, -1, -1,
3323  -1, 2, 326, 4, -1, -1, 930, -1, -1, -1,
3324  -1, -1, -1, -1, 496, 497, 306, -1, -1, -1,
3325  -1, 311, -1, -1, -1, -1, -1, -1, -1, -1,
3326  512, -1, 49, 323, 324, -1, 53, -1, -1, -1,
3327  -1, -1, -1, -1, -1, -1, -1, -1, 49, -1,
3328  -1, -1, 53, -1, -1, 979, -1, 981, -1, -1,
3329  -1, -1, 79, 987, -1, 989, 356, -1, -1, -1,
3330  -1, -1, -1, -1, 91, 92, 93, 94, 79, -1,
3331  -1, -1, -1, -1, -1, -1, -1, 411, 412, -1,
3332  91, 92, 93, 1017, 576, -1, 420, -1, 580, -1,
3333  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3334  592, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3335  -1, -1, -1, -1, -1, -1, 608, -1, -1, -1,
3336  -1, 455, -1, -1, 458, -1, -1, -1, -1, 621,
3337  622, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3338  440, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3339  450, -1, -1, -1, -1, -1, -1, 649, -1, -1,
3340  -1, -1, -1, -1, -1, -1, -1, -1, 468, -1,
3341  -1, -1, -1, -1, -1, -1, 203, -1, 512, -1,
3342  -1, -1, -1, -1, 2, -1, 4, -1, -1, -1,
3343  -1, -1, 203, -1, -1, -1, -1, -1, -1, -1,
3344  2, 693, 4, -1, -1, 697, 698, -1, 700, 701,
3345  237, -1, -1, -1, -1, 707, 708, -1, 518, -1,
3346  -1, 248, 714, 250, -1, -1, 237, -1, -1, -1,
3347  -1, 49, -1, -1, -1, -1, -1, 248, -1, 250,
3348  -1, -1, 576, -1, 271, -1, -1, 49, -1, -1,
3349  -1, -1, -1, -1, -1, -1, -1, -1, -1, 751,
3350  271, -1, -1, 755, 756, -1, 758, 759, -1, -1,
3351  570, -1, 572, 91, 608, 767, -1, -1, -1, 306,
3352  -1, -1, -1, -1, 311, -1, -1, 621, 622, -1,
3353  -1, -1, -1, -1, 594, 306, 323, 324, -1, -1,
3354  311, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3355  -1, -1, 323, 324, -1, 649, -1, -1, -1, -1,
3356  -1, -1, -1, -1, 816, -1, -1, -1, 820, 356,
3357  -1, -1, 632, -1, -1, -1, 828, 637, -1, -1,
3358  -1, -1, -1, -1, -1, 356, -1, -1, -1, -1,
3359  -1, -1, -1, -1, -1, -1, -1, 849, -1, 693,
3360  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3361  -1, -1, -1, -1, 866, 867, -1, -1, -1, -1,
3362  714, -1, -1, -1, -1, 203, 686, -1, -1, 689,
3363  -1, 691, -1, -1, -1, -1, 696, -1, -1, -1,
3364  -1, 203, -1, -1, -1, -1, -1, -1, -1, -1,
3365  -1, -1, -1, 440, -1, -1, -1, -1, -1, 237,
3366  -1, -1, -1, 450, -1, -1, -1, -1, -1, 440,
3367  248, -1, 250, 767, -1, 237, 736, -1, -1, 450,
3368  -1, 468, -1, -1, 744, -1, 248, -1, 250, -1,
3369  -1, -1, -1, -1, -1, -1, -1, 468, -1, -1,
3370  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3371  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3372  -1, -1, 816, -1, -1, -1, -1, -1, 306, -1,
3373  -1, 518, -1, 311, -1, -1, -1, -1, -1, 799,
3374  -1, -1, -1, -1, 306, 323, -1, 518, 326, 311,
3375  -1, -1, -1, -1, 814, 849, -1, -1, -1, -1,
3376  -1, 323, -1, -1, -1, 1017, -1, -1, -1, -1,
3377  -1, -1, -1, 867, -1, -1, -1, -1, 356, 839,
3378  -1, -1, -1, 570, -1, 572, 846, 847, -1, -1,
3379  850, -1, -1, -1, 356, -1, -1, -1, -1, 570,
3380  -1, 572, -1, -1, -1, -1, -1, 594, -1, -1,
3381  -1, -1, -1, -1, -1, -1, -1, 877, 878, -1,
3382  -1, -1, -1, 594, -1, -1, -1, -1, -1, -1,
3383  -1, 891, 892, -1, -1, -1, -1, -1, -1, -1,
3384  -1, -1, -1, -1, -1, 632, -1, -1, -1, -1,
3385  637, -1, -1, -1, -1, 915, -1, -1, -1, 919,
3386  -1, 632, 440, -1, -1, -1, 637, -1, -1, -1,
3387  930, -1, 450, -1, -1, -1, -1, -1, 440, -1,
3388  -1, -1, -1, -1, -1, -1, -1, -1, 450, -1,
3389  -1, -1, -1, -1, -1, -1, -1, -1, -1, 686,
3390  -1, -1, 689, -1, 691, 676, 44, -1, -1, 696,
3391  -1, -1, -1, -1, -1, 686, -1, -1, 689, 979,
3392  691, 981, -1, -1, -1, 696, -1, 987, -1, 989,
3393  68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
3394  78, 79, 80, -1, -1, 83, 84, -1, -1, 736,
3395  -1, -1, -1, -1, -1, -1, -1, 744, -1, -1,
3396  -1, -1, -1, -1, -1, 736, -1, -1, -1, -1,
3397  -1, -1, -1, 744, -1, -1, 114, -1, 116, 117,
3398  118, 119, 120, 121, 122, 123, 124, 125, -1, -1,
3399  -1, -1, 570, -1, 572, -1, -1, -1, -1, -1,
3400  -1, -1, -1, -1, -1, -1, -1, -1, 570, -1,
3401  572, -1, 799, -1, -1, -1, 594, -1, -1, -1,
3402  -1, -1, -1, -1, -1, -1, -1, 814, 799, -1,
3403  -1, -1, 594, -1, -1, -1, -1, -1, -1, -1,
3404  -1, -1, -1, 814, -1, -1, -1, -1, -1, -1,
3405  -1, -1, 839, -1, 632, -1, -1, -1, -1, 846,
3406  847, -1, -1, 850, -1, -1, -1, -1, 839, -1,
3407  632, -1, -1, -1, -1, 846, 847, -1, -1, 850,
3408  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3409  877, 878, -1, -1, -1, -1, -1, -1, -1, -1,
3410  -1, -1, -1, -1, 891, 892, 877, 878, 686, -1,
3411  -1, 689, -1, 691, -1, -1, -1, -1, -1, 697,
3412  891, 892, -1, -1, 686, -1, -1, 689, 915, 691,
3413  -1, -1, 919, -1, -1, -1, -1, -1, -1, -1,
3414  -1, -1, -1, 930, 915, -1, -1, -1, 919, -1,
3415  -1, -1, -1, -1, -1, -1, -1, -1, 736, 930,
3416  -1, -1, -1, -1, -1, -1, 744, -1, -1, -1,
3417  -1, -1, -1, -1, 736, 68, 69, 70, 71, 72,
3418  73, 74, 744, -1, 77, 78, -1, -1, -1, -1,
3419  83, 84, 979, -1, 981, -1, -1, -1, -1, -1,
3420  987, -1, 989, -1, -1, -1, -1, -1, 979, -1,
3421  981, -1, -1, -1, -1, -1, 987, -1, 989, -1,
3422  -1, -1, -1, 116, 117, 118, 119, 120, 121, 122,
3423  123, 124, 125, -1, -1, -1, 814, -1, -1, -1,
3424  -1, 68, 69, 70, 71, 72, 73, 74, 75, -1,
3425  77, 78, 814, -1, -1, -1, 83, 84, -1, -1,
3426  -1, 839, -1, -1, -1, -1, -1, -1, 846, 847,
3427  -1, -1, 850, -1, -1, -1, -1, 839, -1, -1,
3428  -1, -1, -1, -1, 846, 847, -1, -1, 850, 116,
3429  117, 118, 119, 120, 121, 122, 123, 124, 125, 877,
3430  878, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3431  -1, -1, -1, 891, -1, 877, 878, -1, -1, -1,
3432  -1, -1, -1, -1, -1, -1, -1, -1, -1, 891,
3433  68, 69, 70, 71, 72, 73, 74, 915, -1, 77,
3434  78, 919, -1, -1, -1, 83, 84, -1, -1, -1,
3435  -1, -1, 930, -1, -1, -1, -1, 919, -1, -1,
3436  -1, -1, -1, -1, -1, -1, -1, -1, 930, -1,
3437  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
3438  118, 119, 120, 121, 122, 123, 124, 125, -1, -1,
3439  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3440  -1, 979, -1, 981, -1, -1, -1, -1, -1, 987,
3441  -1, 989, -1, -1, -1, -1, -1, 979, -1, 981,
3442  -1, -1, -1, -1, -1, 987, -1, 989, 0, 1,
3443  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
3444  12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
3445  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3446  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3447  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3448  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3449  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3450  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3451  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3452  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3453  102, 103, 104, 105, 106, 0, -1, -1, -1, -1,
3454  -1, -1, -1, 8, 9, 10, -1, -1, 13, 14,
3455  15, -1, 17, -1, 126, 127, 128, -1, 44, -1,
3456  -1, 26, 27, 28, 29, -1, -1, 139, -1, 141,
3457  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3458  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3459  76, 77, 78, 79, 80, -1, -1, 83, 84, -1,
3460  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3461  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3462  85, -1, 87, 88, -1, -1, -1, -1, 114, 94,
3463  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3464  -1, -1, -1, 108, -1, -1, 111, -1, 113, 114,
3465  115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3466  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3467  0, -1, 137, 138, 139, -1, 141, -1, 8, 9,
3468  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3469  -1, -1, -1, -1, -1, 25, -1, 27, 28, 29,
3470  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3471  40, 41, 42, 43, 44, -1, -1, 68, 69, 70,
3472  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3473  -1, -1, 83, 84, -1, -1, -1, -1, 68, 69,
3474  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3475  80, -1, -1, 83, 84, 85, -1, 87, 88, -1,
3476  -1, -1, -1, 114, 94, 116, 117, 118, 119, 120,
3477  121, 122, 123, 124, 125, -1, -1, -1, 108, -1,
3478  -1, 111, -1, 113, 114, 115, 116, 117, 118, 119,
3479  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3480  -1, 131, 132, 133, 134, 0, -1, 137, 138, 139,
3481  -1, 141, -1, 8, 9, 10, -1, -1, 13, 14,
3482  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3483  25, -1, 27, 28, 29, -1, -1, -1, -1, -1,
3484  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3485  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3486  76, 77, 78, 79, 80, -1, -1, 83, 84, -1,
3487  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3488  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3489  85, -1, 87, 88, -1, -1, -1, -1, -1, 94,
3490  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3491  -1, -1, -1, 108, -1, -1, 111, -1, 113, 114,
3492  115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3493  125, -1, -1, -1, -1, -1, 131, 132, 133, 134,
3494  0, -1, 137, 138, 139, -1, 141, -1, 8, 9,
3495  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3496  -1, -1, -1, -1, -1, -1, 26, 27, 28, 29,
3497  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3498  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3499  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3500  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3501  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3502  80, -1, -1, 83, 84, 85, -1, -1, 88, -1,
3503  -1, -1, -1, -1, 94, -1, -1, -1, -1, -1,
3504  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3505  -1, 111, -1, -1, 114, 115, 116, 117, 118, 119,
3506  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3507  130, 131, 132, 133, 134, 0, -1, 137, 138, 139,
3508  -1, 141, -1, 8, 9, 10, -1, -1, 13, 14,
3509  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3510  -1, 26, 27, 28, 29, -1, -1, -1, -1, -1,
3511  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3512  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3513  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3514  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3515  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3516  85, -1, -1, 88, -1, -1, -1, -1, -1, 94,
3517  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3518  -1, -1, -1, 108, -1, -1, 111, -1, -1, 114,
3519  115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3520  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3521  0, -1, 137, 138, 139, -1, 141, -1, 8, 9,
3522  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3523  -1, -1, -1, -1, -1, -1, -1, 27, 28, 29,
3524  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3525  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3526  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3527  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3528  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3529  80, -1, -1, 83, 84, 85, -1, 87, 88, -1,
3530  -1, -1, -1, -1, 94, -1, -1, -1, -1, -1,
3531  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3532  -1, 111, -1, 113, 114, 115, 116, 117, 118, 119,
3533  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3534  -1, 131, 132, 133, 134, 0, -1, 137, 138, 139,
3535  -1, 141, -1, 8, 9, 10, -1, -1, 13, 14,
3536  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3537  -1, 26, 27, 28, -1, -1, -1, -1, -1, -1,
3538  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3539  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3540  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3541  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3542  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3543  85, -1, -1, 88, -1, -1, -1, -1, -1, 94,
3544  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3545  -1, -1, -1, 108, -1, -1, -1, -1, -1, 114,
3546  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3547  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3548  0, 136, 137, 138, 139, -1, 141, -1, 8, 9,
3549  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3550  -1, -1, -1, -1, -1, -1, -1, 27, 28, 29,
3551  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3552  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3553  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3554  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3555  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3556  80, -1, -1, 83, 84, 85, -1, -1, 88, -1,
3557  -1, -1, -1, -1, 94, -1, -1, -1, -1, -1,
3558  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3559  -1, 111, -1, -1, 114, 115, 116, 117, 118, 119,
3560  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3561  -1, 131, 132, 133, 134, 0, -1, 137, 138, 139,
3562  -1, 141, -1, 8, 9, 10, -1, -1, 13, 14,
3563  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3564  -1, 26, 27, 28, -1, -1, -1, -1, -1, -1,
3565  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3566  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3567  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3568  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3569  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3570  85, -1, -1, 88, -1, -1, -1, -1, -1, 94,
3571  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3572  -1, -1, -1, 108, -1, -1, -1, -1, -1, 114,
3573  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3574  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3575  0, 136, 137, 138, 139, -1, 141, -1, 8, 9,
3576  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3577  -1, -1, -1, -1, -1, -1, -1, 27, 28, -1,
3578  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3579  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3580  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3581  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3582  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3583  80, -1, -1, 83, 84, 85, -1, -1, 88, -1,
3584  -1, -1, -1, -1, 94, -1, -1, -1, -1, -1,
3585  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3586  -1, -1, -1, -1, 114, -1, 116, 117, 118, 119,
3587  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3588  -1, 131, 132, 133, 134, 0, 136, 137, 138, 139,
3589  -1, 141, -1, 8, 9, 10, -1, -1, -1, 14,
3590  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3591  -1, 26, -1, -1, -1, -1, -1, -1, -1, -1,
3592  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3593  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3594  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3595  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3596  75, 76, 77, 78, 79, 80, -1, -1, 83, 84,
3597  85, -1, 87, -1, -1, -1, -1, -1, -1, -1,
3598  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3599  -1, -1, -1, 108, -1, -1, -1, -1, 113, 114,
3600  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3601  125, -1, -1, -1, -1, 130, 131, 132, 133, 134,
3602  0, -1, 137, -1, 139, -1, 141, -1, 8, 9,
3603  10, -1, -1, -1, 14, 15, -1, 17, -1, -1,
3604  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3605  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3606  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3607  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3608  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
3609  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3610  80, -1, -1, 83, 84, 85, -1, 87, -1, -1,
3611  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3612  -1, -1, -1, -1, -1, -1, -1, -1, 108, -1,
3613  -1, -1, -1, 113, 114, -1, 116, 117, 118, 119,
3614  120, 121, 122, 123, 124, 125, -1, -1, -1, -1,
3615  -1, 131, 132, 133, 134, -1, -1, 137, -1, 139,
3616  1, 141, 3, 4, 5, 6, 7, 8, 9, 10,
3617  11, 12, -1, -1, 15, 16, -1, 18, 19, 20,
3618  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3619  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3620  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3621  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3622  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3623  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3624  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3625  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
3626  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3627  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3628  -1, -1, -1, -1, -1, 126, 127, 128, -1, -1,
3629  -1, -1, -1, -1, -1, -1, -1, -1, 139, 1,
3630  141, 3, 4, 5, 6, 7, -1, -1, 10, 11,
3631  12, -1, 14, 15, 16, -1, 18, 19, 20, 21,
3632  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3633  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3634  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3635  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3636  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3637  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3638  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3639  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3640  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3641  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3642  -1, -1, -1, -1, 126, 127, 128, -1, -1, -1,
3643  -1, -1, -1, -1, -1, -1, -1, 139, 1, 141,
3644  3, 4, 5, 6, 7, -1, -1, 10, 11, 12,
3645  -1, -1, 15, 16, 17, 18, 19, 20, 21, 22,
3646  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3647  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3648  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3649  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
3650  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3651  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3652  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3653  93, -1, 95, -1, -1, 98, 99, 100, 101, 102,
3654  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
3655  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3656  -1, -1, -1, 126, 127, 128, -1, -1, -1, -1,
3657  -1, -1, -1, -1, -1, -1, 139, 1, 141, 3,
3658  4, 5, 6, 7, -1, -1, 10, 11, 12, -1,
3659  -1, 15, 16, -1, 18, 19, 20, 21, 22, 23,
3660  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3661  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3662  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3663  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
3664  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
3665  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3666  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3667  -1, 95, -1, -1, 98, 99, 100, 101, 102, 103,
3668  104, 105, 106, -1, -1, -1, -1, -1, -1, -1,
3669  1, -1, 3, 4, 5, 6, 7, -1, 9, 10,
3670  11, 12, 126, 127, 128, 16, -1, 18, 19, 20,
3671  21, 22, 23, 24, -1, 139, -1, 141, -1, 30,
3672  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3673  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3674  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3675  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3676  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3677  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3678  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
3679  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3680  -1, -1, -1, 1, -1, 3, 4, 5, 6, 7,
3681  -1, -1, -1, 11, 12, 126, 127, 128, 16, -1,
3682  18, 19, 20, 21, 22, 23, 24, -1, 139, -1,
3683  141, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3684  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3685  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3686  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3687  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3688  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3689  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3690  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3691  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3692  -1, -1, -1, -1, -1, -1, -1, -1, 126, 127,
3693  128, -1, -1, -1, -1, -1, -1, -1, -1, 137,
3694  -1, 139, 1, 141, 3, 4, 5, 6, 7, -1,
3695  -1, -1, 11, 12, -1, -1, -1, 16, -1, 18,
3696  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3697  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3698  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3699  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3700  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3701  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3702  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3703  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3704  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3705  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3706  -1, -1, -1, -1, -1, -1, -1, 126, 127, 128,
3707  -1, -1, -1, -1, -1, -1, -1, -1, 137, -1,
3708  139, 1, 141, 3, 4, 5, 6, 7, -1, -1,
3709  -1, 11, 12, -1, -1, -1, 16, -1, 18, 19,
3710  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3711  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3712  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
3713  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3714  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3715  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3716  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3717  90, -1, 92, 93, -1, 95, -1, -1, 98, 99,
3718  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
3719  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3720  -1, -1, -1, -1, -1, -1, 126, 127, 128, -1,
3721  -1, 131, 1, -1, 3, 4, 5, 6, 7, 139,
3722  -1, 141, 11, 12, -1, -1, -1, 16, -1, 18,
3723  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3724  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3725  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3726  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3727  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3728  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3729  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3730  89, 90, -1, 92, 93, -1, 95, -1, -1, 98,
3731  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3732  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3733  -1, -1, -1, -1, -1, -1, -1, 126, 127, 128,
3734  -1, -1, 131, -1, -1, -1, -1, -1, -1, -1,
3735  139, 1, 141, 3, 4, 5, 6, 7, -1, -1,
3736  10, 11, 12, -1, -1, -1, 16, -1, 18, 19,
3737  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3738  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3739  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
3740  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3741  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3742  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3743  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3744  90, -1, 92, 93, -1, 95, -1, -1, 98, 99,
3745  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
3746  -1, -1, -1, -1, 1, -1, 3, 4, 5, 6,
3747  7, -1, -1, -1, 11, 12, 126, 127, 128, 16,
3748  -1, 18, 19, 20, 21, 22, 23, 24, -1, 139,
3749  -1, 141, -1, 30, 31, 32, 33, 34, 35, 36,
3750  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
3751  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
3752  57, -1, 59, 60, -1, 62, 63, 64, -1, 66,
3753  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3754  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3755  -1, -1, 89, 90, -1, 92, 93, -1, 95, -1,
3756  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3757  -1, 108, -1, -1, -1, -1, -1, -1, -1, 3,
3758  4, 5, -1, 7, -1, -1, -1, 11, 12, 126,
3759  127, 128, 16, -1, 18, 19, 20, 21, 22, 23,
3760  24, -1, 139, -1, 141, -1, 30, 31, 32, 33,
3761  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3762  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3763  54, 55, 56, 57, 58, 59, 60, -1, 62, 63,
3764  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
3765  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3766  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
3767  -1, 95, 96, 97, 98, 99, 100, 101, 102, 103,
3768  104, 105, 106, -1, -1, -1, -1, -1, -1, -1,
3769  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3770  11, 12, 126, 127, 128, 16, -1, 18, 19, 20,
3771  21, 22, 23, 24, -1, -1, -1, 141, -1, 30,
3772  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3773  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3774  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3775  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
3776  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3777  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
3778  -1, 92, 93, -1, -1, -1, -1, 98, 99, 100,
3779  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
3780  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
3781  -1, -1, -1, 11, 12, 126, 127, 128, 16, -1,
3782  18, 19, 20, 21, 22, 23, 24, -1, 139, -1,
3783  141, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3784  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3785  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3786  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3787  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3788  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3789  -1, 89, 90, -1, 92, 93, -1, -1, -1, -1,
3790  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3791  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
3792  5, 6, 7, -1, -1, -1, 11, 12, 126, 127,
3793  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3794  -1, -1, -1, 141, -1, 30, 31, 32, 33, 34,
3795  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3796  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3797  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
3798  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3799  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3800  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3801  95, -1, -1, 98, 99, 100, 101, 102, 103, 104,
3802  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3803  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
3804  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
3805  22, 23, 24, -1, 139, -1, -1, -1, 30, 31,
3806  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3807  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3808  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3809  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3810  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3811  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3812  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3813  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3814  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3815  -1, -1, -1, -1, 126, 127, 128, -1, -1, -1,
3816  -1, -1, -1, -1, -1, -1, -1, 139, 3, 4,
3817  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3818  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3819  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3820  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
3821  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3822  55, 56, 57, -1, -1, -1, -1, -1, -1, -1,
3823  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3824  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3825  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3826  95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
3827  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3828  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3829  125, -1, 127, 128, -1, -1, -1, -1, -1, -1,
3830  135, 136, 3, 4, 5, 6, 7, 8, 9, 10,
3831  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
3832  21, 22, 23, 24, 25, 26, -1, -1, -1, 30,
3833  31, 32, 33, 34, 35, 36, 37, 38, 39, -1,
3834  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3835  51, 52, 53, 54, 55, 56, 57, -1, -1, -1,
3836  -1, -1, -1, -1, -1, 66, 67, 68, 69, 70,
3837  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
3838  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
3839  -1, -1, -1, -1, 95, 96, -1, -1, -1, -1,
3840  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3841  -1, -1, -1, -1, -1, 116, 117, 118, 119, 120,
3842  121, 122, 123, 124, 125, -1, 127, 128, -1, -1,
3843  -1, -1, -1, -1, 135, 3, 4, 5, 6, 7,
3844  8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
3845  18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
3846  -1, -1, 30, 31, 32, 33, 34, 35, 36, 37,
3847  38, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3848  48, 49, 50, 51, 52, 53, 54, -1, 56, -1,
3849  -1, -1, -1, -1, -1, -1, -1, -1, 66, 67,
3850  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
3851  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
3852  -1, -1, -1, -1, -1, -1, -1, 95, 96, -1,
3853  -1, 99, -1, -1, -1, -1, -1, -1, -1, -1,
3854  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
3855  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
3856  128, -1, -1, -1, -1, -1, -1, 135, 3, 4,
3857  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3858  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3859  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3860  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
3861  45, 46, 47, 48, 49, 50, 51, 52, 53, -1,
3862  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
3863  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
3864  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
3865  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3866  95, 96, -1, -1, 99, -1, -1, -1, -1, -1,
3867  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3868  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3869  125, -1, 127, 128, -1, -1, -1, -1, -1, -1,
3870  135, 3, 4, 5, 6, 7, 8, 9, 10, 11,
3871  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
3872  22, 23, 24, 25, 26, -1, -1, -1, 30, 31,
3873  32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
3874  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3875  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
3876  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
3877  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
3878  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
3879  -1, -1, -1, 95, 96, -1, -1, -1, -1, -1,
3880  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3881  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
3882  122, 123, 124, 125, -1, 127, 128, 3, 4, 5,
3883  -1, 7, -1, 135, -1, 11, 12, -1, -1, -1,
3884  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3885  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3886  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3887  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3888  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
3889  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3890  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3891  86, -1, -1, 89, 90, -1, 92, 93, -1, -1,
3892  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
3893  106, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3894  7, -1, -1, -1, 11, 12, -1, -1, -1, 16,
3895  126, 18, 19, 20, 21, 22, 23, 24, 134, -1,
3896  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3897  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3898  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3899  57, -1, 59, 60, -1, 62, 63, 64, -1, -1,
3900  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3901  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3902  -1, -1, 89, 90, -1, 92, 93, -1, -1, -1,
3903  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3904  -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
3905  -1, -1, -1, 11, 12, -1, -1, -1, 16, 126,
3906  18, 19, 20, 21, 22, 23, 24, 134, -1, -1,
3907  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3908  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3909  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3910  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
3911  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3912  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
3913  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
3914  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
3915  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
3916  5, -1, 7, -1, -1, -1, 11, 12, 126, 127,
3917  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3918  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3919  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3920  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3921  55, 56, 57, 58, 59, 60, -1, 62, 63, 64,
3922  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
3923  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3924  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
3925  95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
3926  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
3927  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
3928  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
3929  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3930  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3931  -1, -1, -1, 45, 46, -1, 48, 49, 50, 51,
3932  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
3933  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
3934  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3935  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
3936  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
3937  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
3938  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3939  -1, -1, 11, 12, 126, 127, 128, 16, -1, 18,
3940  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3941  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3942  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3943  49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
3944  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
3945  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3946  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
3947  89, 90, -1, 92, 93, -1, 95, 96, 97, 98,
3948  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
3949  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3950  -1, 7, -1, -1, -1, 11, 12, 126, 127, 128,
3951  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3952  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3953  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3954  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3955  56, 57, 58, 59, 60, -1, 62, 63, 64, -1,
3956  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
3957  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3958  86, -1, -1, 89, 90, -1, 92, 93, -1, 95,
3959  96, -1, 98, 99, 100, 101, 102, 103, 104, 105,
3960  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3961  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
3962  126, 127, 128, 16, -1, 18, 19, 20, 21, 22,
3963  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3964  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3965  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
3966  53, 54, 55, 56, 57, 58, 59, 60, -1, 62,
3967  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
3968  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3969  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
3970  93, -1, -1, 96, 97, 98, 99, 100, 101, 102,
3971  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
3972  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
3973  -1, 11, 12, 126, 127, 128, 16, -1, 18, 19,
3974  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3975  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3976  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
3977  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
3978  60, -1, 62, 63, 64, -1, 66, 67, -1, -1,
3979  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3980  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
3981  90, -1, 92, 93, -1, 95, 96, -1, 98, 99,
3982  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
3983  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3984  7, -1, -1, -1, 11, 12, 126, 127, 128, 16,
3985  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3986  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3987  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3988  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3989  57, 58, 59, 60, -1, 62, 63, 64, -1, 66,
3990  67, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3991  -1, -1, -1, -1, -1, -1, -1, -1, -1, 86,
3992  -1, -1, 89, 90, -1, 92, 93, -1, -1, 96,
3993  -1, 98, 99, 100, 101, 102, 103, 104, 105, 106,
3994  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3995  4, 5, -1, 7, -1, -1, -1, 11, 12, 126,
3996  127, 128, 16, -1, 18, 19, 20, 21, 22, 23,
3997  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3998  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3999  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4000  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
4001  64, -1, 66, 67, -1, -1, -1, -1, -1, -1,
4002  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4003  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
4004  -1, 95, -1, -1, 98, 99, 100, 101, 102, 103,
4005  104, 105, 106, -1, -1, -1, -1, -1, -1, -1,
4006  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4007  11, 12, 126, 127, 128, 16, -1, 18, 19, 20,
4008  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4009  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4010  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4011  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4012  -1, 62, 63, 64, -1, 66, 67, -1, -1, -1,
4013  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4014  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
4015  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
4016  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
4017  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4018  -1, -1, -1, 11, 12, 126, 127, 128, 16, -1,
4019  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4020  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4021  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4022  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4023  -1, 59, 60, -1, 62, 63, 64, -1, 66, 67,
4024  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4025  -1, -1, -1, -1, -1, -1, -1, -1, 86, -1,
4026  -1, 89, 90, -1, 92, 93, -1, 95, -1, -1,
4027  98, 99, 100, 101, 102, 103, 104, 105, 106, -1,
4028  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
4029  5, -1, 7, -1, -1, -1, 11, 12, 126, 127,
4030  128, 16, -1, 18, 19, 20, 21, 22, 23, 24,
4031  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4032  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4033  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
4034  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
4035  -1, 66, 67, -1, -1, -1, -1, -1, -1, -1,
4036  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4037  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
4038  95, -1, -1, 98, 99, 100, 101, 102, 103, 104,
4039  105, 106, -1, -1, -1, -1, -1, -1, -1, -1,
4040  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4041  12, 126, 127, 128, 16, -1, 18, 19, 20, 21,
4042  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4043  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4044  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4045  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
4046  62, 63, 64, -1, 66, 67, -1, -1, -1, -1,
4047  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4048  -1, -1, -1, -1, 86, -1, -1, 89, 90, -1,
4049  92, 93, -1, 95, -1, -1, 98, 99, 100, 101,
4050  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
4051  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4052  -1, -1, 11, 12, 126, 127, 128, 16, -1, 18,
4053  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4054  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4055  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4056  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4057  59, 60, -1, 62, 63, 64, -1, 66, 67, -1,
4058  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4059  -1, -1, -1, -1, -1, -1, -1, 86, -1, -1,
4060  89, 90, -1, 92, 93, -1, -1, -1, -1, 98,
4061  99, 100, 101, 102, 103, 104, 105, 106, -1, -1,
4062  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4063  -1, 7, -1, -1, -1, 11, 12, 126, 127, 128,
4064  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4065  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4066  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4067  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4068  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
4069  66, 67, -1, -1, -1, -1, -1, -1, -1, -1,
4070  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4071  86, -1, -1, 89, 90, -1, 92, 93, -1, -1,
4072  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
4073  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4074  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4075  126, 127, 128, 16, -1, 18, 19, 20, 21, 22,
4076  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4077  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4078  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4079  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
4080  63, 64, -1, 66, 67, -1, -1, -1, -1, -1,
4081  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4082  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
4083  93, -1, -1, -1, -1, 98, 99, 100, 101, 102,
4084  103, 104, 105, 106, -1, -1, -1, -1, -1, -1,
4085  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4086  -1, 11, 12, 126, 127, 128, 16, -1, 18, 19,
4087  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4088  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4089  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4090  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4091  60, -1, 62, 63, 64, -1, -1, -1, -1, -1,
4092  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4093  -1, -1, -1, -1, -1, -1, 86, -1, -1, 89,
4094  90, -1, 92, 93, -1, 95, -1, -1, 98, 99,
4095  100, 101, 102, 103, 104, 105, 106, -1, -1, -1,
4096  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4097  11, 12, -1, -1, -1, 16, 126, 18, 19, 20,
4098  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4099  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4100  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4101  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4102  -1, 62, 63, 64, -1, -1, -1, -1, -1, -1,
4103  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4104  -1, -1, -1, -1, -1, 86, -1, -1, 89, 90,
4105  -1, 92, 93, -1, 95, -1, -1, 98, 99, 100,
4106  101, 102, 103, 104, 105, 106, -1, -1, -1, -1,
4107  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4108  12, -1, -1, -1, 16, 126, 18, 19, 20, 21,
4109  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4110  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4111  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4112  52, 53, 54, 55, 56, 57, -1, 59, 60, -1,
4113  62, 63, 64, -1, -1, -1, -1, -1, -1, -1,
4114  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4115  -1, 83, -1, -1, 86, -1, -1, 89, 90, -1,
4116  92, 93, -1, -1, -1, -1, 98, 99, 100, 101,
4117  102, 103, 104, 105, 106, -1, -1, -1, -1, -1,
4118  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4119  -1, -1, -1, 16, 126, 18, 19, 20, 21, 22,
4120  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4121  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4122  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4123  53, 54, 55, 56, 57, -1, 59, 60, -1, 62,
4124  63, 64, -1, -1, -1, -1, -1, -1, -1, -1,
4125  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4126  -1, -1, -1, 86, -1, -1, 89, 90, -1, 92,
4127  93, -1, -1, -1, -1, 98, 99, 100, 101, 102,
4128  103, 104, 105, 106, -1, -1, -1, -1, -1, 3,
4129  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
4130  -1, -1, 16, 126, 18, 19, 20, 21, 22, 23,
4131  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4132  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4133  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4134  54, 55, 56, 57, -1, 59, 60, -1, 62, 63,
4135  64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4136  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4137  -1, -1, 86, -1, -1, 89, 90, -1, 92, 93,
4138  -1, -1, -1, -1, 98, 99, 100, 101, 102, 103,
4139  104, 105, 106, -1, -1, -1, -1, -1, 3, 4,
4140  5, -1, 7, -1, -1, -1, 11, 12, -1, -1,
4141  -1, 16, 126, 18, 19, 20, 21, 22, 23, 24,
4142  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4143  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4144  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
4145  55, 56, 57, -1, 59, 60, -1, 62, 63, 64,
4146  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4147  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4148  -1, 86, -1, -1, 89, 90, -1, 92, 93, -1,
4149  -1, -1, -1, 98, 99, 100, 101, 102, 103, 104,
4150  105, 106, -1, -1, -1, -1, -1, 3, 4, 5,
4151  -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
4152  16, 126, 18, 19, 20, 21, 22, 23, 24, -1,
4153  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4154  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4155  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4156  56, 57, -1, 59, 60, -1, 62, 63, 64, -1,
4157  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4158  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4159  86, -1, -1, 89, 90, -1, 92, 93, -1, -1,
4160  -1, -1, 98, 99, 100, 101, 102, 103, 104, 105,
4161  106, -1, -1, -1, -1, -1, -1, 52, 53, -1,
4162  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
4163  126, 66, 67, 68, 69, 70, 71, 72, 73, 74,
4164  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
4165  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4166  95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
4167  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4168  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
4169  125, -1, 127, 128, 52, 53, -1, -1, 56, -1,
4170  135, -1, -1, -1, -1, -1, -1, -1, 66, 67,
4171  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
4172  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
4173  -1, -1, -1, -1, -1, -1, -1, 95, 96, -1,
4174  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4175  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
4176  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
4177  128, 52, 53, -1, -1, 56, -1, 135, -1, -1,
4178  -1, -1, -1, -1, -1, 66, 67, 68, 69, 70,
4179  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
4180  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
4181  -1, -1, -1, -1, 95, 96, -1, -1, -1, -1,
4182  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4183  -1, -1, -1, -1, -1, 116, 117, 118, 119, 120,
4184  121, 122, 123, 124, 125, -1, 127, 128, 52, 53,
4185  -1, -1, 56, -1, 135, -1, -1, -1, -1, -1,
4186  -1, -1, 66, 67, 68, 69, 70, 71, 72, 73,
4187  74, -1, -1, 77, 78, -1, -1, 81, 82, 83,
4188  84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4189  -1, 95, 96, -1, -1, -1, -1, -1, -1, -1,
4190  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4191  -1, -1, 116, 117, 118, 119, 120, 121, 122, 123,
4192  124, 125, -1, 127, 128, 52, 53, -1, -1, 56,
4193  -1, 135, -1, -1, -1, -1, -1, -1, -1, 66,
4194  67, 68, 69, 70, 71, 72, 73, 74, -1, -1,
4195  77, 78, -1, -1, 81, 82, 83, 84, -1, -1,
4196  -1, -1, -1, -1, -1, -1, -1, -1, 95, 96,
4197  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4198  -1, -1, -1, -1, -1, -1, -1, -1, -1, 116,
4199  117, 118, 119, 120, 121, 122, 123, 124, 125, -1,
4200  127, 128, 52, 53, -1, -1, 56, -1, 135, -1,
4201  -1, -1, -1, -1, -1, -1, 66, 67, 68, 69,
4202  70, 71, 72, 73, 74, -1, -1, 77, 78, -1,
4203  -1, 81, 82, 83, 84, -1, -1, -1, -1, -1,
4204  -1, -1, -1, -1, -1, 95, 96, -1, -1, -1,
4205  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4206  -1, -1, -1, -1, -1, -1, 116, 117, 118, 119,
4207  120, 121, 122, 123, 124, 125, -1, 127, 128, 52,
4208  53, -1, -1, 56, -1, 135, -1, -1, -1, -1,
4209  -1, -1, -1, 66, 67, 68, 69, 70, 71, 72,
4210  73, 74, -1, -1, 77, 78, -1, -1, 81, 82,
4211  83, 84, -1, -1, -1, -1, -1, -1, -1, -1,
4212  -1, -1, 95, 96, -1, -1, -1, -1, -1, -1,
4213  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4214  -1, -1, -1, 116, 117, 118, 119, 120, 121, 122,
4215  123, 124, 125, -1, 127, 128, 52, 53, -1, -1,
4216  56, -1, 135, -1, -1, -1, -1, -1, -1, -1,
4217  66, 67, 68, 69, 70, 71, 72, 73, 74, -1,
4218  -1, 77, 78, -1, -1, 81, 82, 83, 84, -1,
4219  -1, -1, -1, -1, -1, -1, -1, -1, -1, 95,
4220  96, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4221  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4222  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
4223  -1, 127, 128, 52, 53, -1, -1, 56, -1, 135,
4224  -1, -1, -1, -1, -1, -1, -1, 66, 67, 68,
4225  69, 70, 71, 72, 73, 74, -1, -1, 77, 78,
4226  -1, -1, 81, 82, 83, 84, -1, -1, -1, -1,
4227  -1, -1, -1, -1, -1, -1, 95, 96, -1, -1,
4228  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4229  -1, -1, -1, -1, -1, -1, -1, 116, 117, 118,
4230  119, 120, 121, 122, 123, 124, 125, -1, 127, 128,
4231  52, 53, -1, -1, 56, -1, 135, -1, -1, -1,
4232  -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
4233  72, 73, 74, -1, -1, 77, 78, -1, -1, 81,
4234  82, 83, 84, -1, -1, -1, -1, -1, -1, -1,
4235  -1, -1, -1, 95, 96, -1, -1, -1, -1, -1,
4236  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4237  -1, -1, -1, -1, 116, 117, 118, 119, 120, 121,
4238  122, 123, 124, 125, -1, 127, 128, 52, 53, -1,
4239  -1, 56, -1, 135, -1, -1, -1, -1, -1, -1,
4240  -1, 66, 67, 68, 69, 70, 71, 72, 73, 74,
4241  -1, -1, 77, 78, -1, -1, 81, 82, 83, 84,
4242  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4243  95, 96, -1, -1, -1, -1, -1, -1, -1, -1,
4244  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4245  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
4246  125, -1, 127, 128, 52, 53, -1, -1, 56, -1,
4247  135, -1, -1, -1, -1, -1, -1, -1, 66, 67,
4248  68, 69, 70, 71, 72, 73, 74, -1, -1, 77,
4249  78, -1, -1, 81, 82, 83, 84, -1, -1, -1,
4250  -1, -1, -1, -1, -1, -1, -1, 95, 96, -1,
4251  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4252  -1, -1, -1, -1, -1, -1, -1, -1, 116, 117,
4253  118, 119, 120, 121, 122, 123, 124, 125, -1, 127,
4254  128, 52, 53, -1, -1, 56, -1, 135, -1, -1,
4255  -1, -1, -1, -1, -1, 66, 67, 68, 69, 70,
4256  71, 72, 73, 74, -1, -1, 77, 78, -1, -1,
4257  81, 82, 83, 84, -1, -1, -1, -1, -1, -1,
4258  -1, -1, -1, -1, 95, 96, -1, -1, -1, -1,
4259  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4260  -1, -1, -1, -1, -1, 116, 117, 118, 119, 120,
4261  121, 122, 123, 124, 125, -1, 127, 128, -1, -1,
4262  -1, -1, -1, -1, 135
4263 };
4264 
4265 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4266  symbol of state STATE-NUM. */
4267 static const yytype_uint16 yystos[] =
4268 {
4269  0, 143, 144, 0, 1, 3, 4, 5, 6, 7,
4270  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4271  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4272  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4273  57, 59, 60, 62, 63, 64, 66, 67, 86, 89,
4274  90, 92, 93, 95, 98, 99, 100, 101, 102, 103,
4275  104, 105, 106, 126, 127, 128, 145, 146, 147, 154,
4276  156, 157, 159, 160, 163, 164, 165, 167, 168, 169,
4277  171, 172, 182, 196, 214, 215, 216, 217, 218, 219,
4278  220, 221, 222, 223, 224, 250, 251, 265, 266, 267,
4279  268, 269, 270, 271, 274, 276, 277, 289, 291, 292,
4280  293, 294, 295, 296, 297, 328, 339, 147, 3, 4,
4281  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
4282  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
4283  25, 26, 30, 31, 32, 33, 34, 35, 36, 37,
4284  38, 39, 45, 46, 47, 48, 49, 50, 51, 52,
4285  53, 56, 66, 67, 68, 69, 70, 71, 72, 73,
4286  74, 77, 78, 81, 82, 83, 84, 95, 96, 116,
4287  117, 118, 119, 120, 121, 122, 123, 124, 125, 127,
4288  128, 135, 175, 176, 177, 178, 180, 181, 289, 291,
4289  39, 58, 86, 89, 95, 96, 97, 127, 164, 172,
4290  182, 184, 189, 192, 194, 214, 293, 294, 296, 297,
4291  326, 327, 189, 189, 136, 190, 191, 136, 186, 190,
4292  136, 141, 333, 54, 177, 333, 148, 130, 21, 22,
4293  30, 31, 32, 163, 182, 214, 182, 56, 1, 47,
4294  89, 150, 151, 152, 154, 166, 167, 339, 157, 198,
4295  185, 194, 326, 339, 184, 325, 326, 339, 46, 86,
4296  126, 134, 171, 196, 214, 293, 294, 297, 242, 243,
4297  54, 55, 57, 175, 281, 290, 280, 281, 282, 140,
4298  272, 140, 278, 140, 275, 140, 279, 59, 60, 159,
4299  182, 182, 139, 141, 332, 337, 338, 40, 41, 42,
4300  43, 44, 37, 38, 26, 130, 186, 190, 256, 28,
4301  248, 113, 134, 89, 95, 168, 113, 68, 69, 70,
4302  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
4303  83, 84, 114, 116, 117, 118, 119, 120, 121, 122,
4304  123, 124, 125, 85, 132, 133, 197, 157, 158, 158,
4305  201, 203, 158, 332, 338, 86, 165, 172, 214, 230,
4306  293, 294, 297, 52, 56, 83, 86, 173, 174, 214,
4307  293, 294, 297, 174, 33, 34, 35, 36, 49, 50,
4308  51, 52, 56, 136, 175, 295, 323, 85, 133, 331,
4309  256, 268, 87, 87, 134, 184, 56, 184, 184, 184,
4310  113, 88, 134, 193, 339, 85, 132, 133, 87, 87,
4311  134, 193, 189, 333, 334, 189, 188, 189, 194, 326,
4312  339, 157, 334, 157, 54, 63, 64, 155, 136, 183,
4313  130, 150, 85, 133, 87, 154, 153, 166, 137, 332,
4314  338, 334, 199, 334, 138, 134, 141, 336, 134, 336,
4315  131, 336, 333, 56, 59, 60, 168, 170, 134, 85,
4316  132, 133, 244, 61, 107, 109, 110, 283, 110, 283,
4317  110, 65, 283, 110, 110, 273, 283, 110, 61, 110,
4318  110, 110, 273, 110, 61, 110, 68, 68, 139, 147,
4319  158, 158, 158, 158, 154, 157, 157, 258, 257, 94,
4320  161, 249, 95, 159, 184, 194, 195, 166, 134, 171,
4321  134, 156, 159, 172, 182, 184, 195, 182, 182, 182,
4322  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
4323  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
4324  182, 182, 182, 52, 53, 56, 180, 255, 329, 330,
4325  188, 52, 53, 56, 180, 254, 329, 149, 150, 13,
4326  226, 337, 226, 158, 158, 332, 17, 259, 56, 85,
4327  132, 133, 25, 157, 52, 56, 173, 1, 117, 298,
4328  337, 85, 132, 133, 210, 324, 211, 331, 52, 56,
4329  329, 159, 182, 159, 182, 179, 182, 184, 95, 184,
4330  192, 326, 52, 56, 188, 52, 56, 327, 334, 137,
4331  334, 134, 134, 334, 177, 200, 182, 145, 131, 329,
4332  329, 182, 130, 334, 152, 334, 326, 134, 170, 52,
4333  56, 188, 52, 56, 52, 54, 55, 56, 57, 58,
4334  68, 89, 95, 96, 97, 120, 123, 136, 246, 301,
4335  303, 304, 305, 306, 307, 308, 311, 312, 313, 314,
4336  317, 318, 319, 320, 321, 285, 284, 140, 283, 140,
4337  140, 140, 182, 182, 76, 118, 237, 238, 339, 237,
4338  162, 237, 184, 134, 334, 170, 134, 113, 44, 333,
4339  87, 87, 186, 190, 253, 333, 335, 87, 87, 186,
4340  190, 252, 10, 225, 8, 261, 339, 150, 13, 150,
4341  27, 227, 337, 227, 259, 194, 225, 52, 56, 188,
4342  52, 56, 205, 208, 337, 299, 207, 52, 56, 173,
4343  188, 149, 157, 136, 300, 303, 212, 186, 187, 190,
4344  339, 44, 177, 184, 193, 87, 87, 335, 87, 87,
4345  326, 157, 131, 145, 336, 168, 335, 113, 184, 52,
4346  89, 95, 231, 232, 233, 305, 303, 245, 134, 302,
4347  134, 322, 339, 52, 134, 322, 134, 302, 52, 134,
4348  302, 52, 286, 54, 55, 57, 288, 297, 52, 58,
4349  234, 236, 239, 307, 309, 310, 313, 315, 316, 319,
4350  321, 333, 150, 150, 237, 150, 95, 184, 170, 182,
4351  115, 159, 182, 159, 182, 161, 186, 138, 87, 159,
4352  182, 159, 182, 161, 187, 184, 195, 262, 339, 15,
4353  229, 339, 14, 228, 229, 229, 202, 204, 225, 134,
4354  226, 335, 158, 337, 158, 149, 335, 225, 334, 303,
4355  149, 337, 175, 256, 248, 182, 87, 134, 334, 131,
4356  184, 233, 134, 305, 134, 334, 239, 29, 111, 247,
4357  301, 306, 317, 319, 308, 313, 321, 307, 314, 319,
4358  307, 287, 113, 86, 214, 239, 118, 134, 235, 134,
4359  322, 322, 134, 235, 134, 235, 139, 10, 131, 150,
4360  10, 184, 182, 159, 182, 88, 263, 339, 150, 9,
4361  264, 339, 158, 225, 225, 150, 150, 184, 150, 227,
4362  209, 337, 225, 334, 225, 213, 334, 232, 134, 95,
4363  231, 137, 150, 150, 134, 302, 134, 302, 322, 134,
4364  302, 134, 302, 302, 150, 214, 56, 85, 118, 234,
4365  316, 319, 309, 313, 307, 315, 319, 307, 52, 240,
4366  241, 304, 131, 86, 172, 214, 293, 294, 297, 226,
4367  150, 226, 225, 225, 229, 259, 260, 206, 149, 300,
4368  134, 232, 134, 305, 10, 131, 307, 319, 307, 307,
4369  108, 52, 56, 134, 235, 134, 235, 322, 134, 235,
4370  134, 235, 235, 134, 333, 56, 85, 132, 133, 150,
4371  150, 150, 225, 149, 232, 134, 302, 134, 302, 302,
4372  302, 307, 319, 307, 307, 241, 52, 56, 188, 52,
4373  56, 261, 228, 225, 225, 232, 307, 235, 134, 235,
4374  235, 235, 335, 302, 307, 235
4375 };
4376 
4377 #define yyerrok (yyerrstatus = 0)
4378 #define yyclearin (yychar = YYEMPTY)
4379 #define YYEMPTY (-2)
4380 #define YYEOF 0
4381 
4382 #define YYACCEPT goto yyacceptlab
4383 #define YYABORT goto yyabortlab
4384 #define YYERROR goto yyerrorlab
4385 
4386 
4387 /* Like YYERROR except do call yyerror. This remains here temporarily
4388  to ease the transition to the new meaning of YYERROR, for GCC.
4389  Once GCC version 2 has supplanted version 1, this can go. However,
4390  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
4391  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
4392  discussed. */
4393 
4394 #define YYFAIL goto yyerrlab
4395 #if defined YYFAIL
4396  /* This is here to suppress warnings from the GCC cpp's
4397  -Wunused-macros. Normally we don't worry about that warning, but
4398  some users do, and we want to make it easy for users to remove
4399  YYFAIL uses, which will produce warnings from Bison 2.5. */
4400 #endif
4401 
4402 #define YYRECOVERING() (!!yyerrstatus)
4403 
4404 #define YYBACKUP(Token, Value) \
4405 do \
4406  if (yychar == YYEMPTY && yylen == 1) \
4407  { \
4408  yychar = (Token); \
4409  yylval = (Value); \
4410  YYPOPSTACK (1); \
4411  goto yybackup; \
4412  } \
4413  else \
4414  { \
4415  parser_yyerror (parser, YY_("syntax error: cannot back up")); \
4416  YYERROR; \
4417  } \
4418 while (YYID (0))
4419 
4420 
4421 #define YYTERROR 1
4422 #define YYERRCODE 256
4423 
4424 
4425 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
4426  If N is 0, then set CURRENT to the empty location which ends
4427  the previous symbol: RHS[0] (always defined). */
4428 
4429 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
4430 #ifndef YYLLOC_DEFAULT
4431 # define YYLLOC_DEFAULT(Current, Rhs, N) \
4432  do \
4433  if (YYID (N)) \
4434  { \
4435  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
4436  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
4437  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
4438  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
4439  } \
4440  else \
4441  { \
4442  (Current).first_line = (Current).last_line = \
4443  YYRHSLOC (Rhs, 0).last_line; \
4444  (Current).first_column = (Current).last_column = \
4445  YYRHSLOC (Rhs, 0).last_column; \
4446  } \
4447  while (YYID (0))
4448 #endif
4449 
4450 
4451 /* This macro is provided for backward compatibility. */
4452 
4453 #ifndef YY_LOCATION_PRINT
4454 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
4455 #endif
4456 
4457 
4458 /* YYLEX -- calling `yylex' with the right arguments. */
4459 
4460 #ifdef YYLEX_PARAM
4461 # define YYLEX yylex (&yylval, YYLEX_PARAM)
4462 #else
4463 # define YYLEX yylex (&yylval, parser)
4464 #endif
4465 
4466 /* Enable debugging if requested. */
4467 #if YYDEBUG
4468 
4469 # ifndef YYFPRINTF
4470 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
4471 # define YYFPRINTF fprintf
4472 # endif
4473 
4474 # define YYDPRINTF(Args) \
4475 do { \
4476  if (yydebug) \
4477  YYFPRINTF Args; \
4478 } while (YYID (0))
4479 
4480 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
4481 do { \
4482  if (yydebug) \
4483  { \
4484  YYFPRINTF (stderr, "%s ", Title); \
4485  yy_symbol_print (stderr, \
4486  Type, Value, parser); \
4487  YYFPRINTF (stderr, "\n"); \
4488  } \
4489 } while (YYID (0))
4490 
4491 
4492 /*--------------------------------.
4493 | Print this symbol on YYOUTPUT. |
4494 `--------------------------------*/
4495 
4496 /*ARGSUSED*/
4497 #if (defined __STDC__ || defined __C99__FUNC__ \
4498  || defined __cplusplus || defined _MSC_VER)
4499 static void
4500 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4501 #else
4502 static void
4503 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
4504  FILE *yyoutput;
4505  int yytype;
4506  YYSTYPE const * const yyvaluep;
4507  struct parser_params *parser;
4508 #endif
4509 {
4510  if (!yyvaluep)
4511  return;
4512  YYUSE (parser);
4513 # ifdef YYPRINT
4514  if (yytype < YYNTOKENS)
4515  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4516 # else
4517  YYUSE (yyoutput);
4518 # endif
4519  switch (yytype)
4520  {
4521  default:
4522  break;
4523  }
4524 }
4525 
4526 
4527 /*--------------------------------.
4528 | Print this symbol on YYOUTPUT. |
4529 `--------------------------------*/
4530 
4531 #if (defined __STDC__ || defined __C99__FUNC__ \
4532  || defined __cplusplus || defined _MSC_VER)
4533 static void
4534 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4535 #else
4536 static void
4537 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
4538  FILE *yyoutput;
4539  int yytype;
4540  YYSTYPE const * const yyvaluep;
4541  struct parser_params *parser;
4542 #endif
4543 {
4544  if (yytype < YYNTOKENS)
4545  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4546  else
4547  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4548 
4549  yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
4550  YYFPRINTF (yyoutput, ")");
4551 }
4552 
4553 /*------------------------------------------------------------------.
4554 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4555 | TOP (included). |
4556 `------------------------------------------------------------------*/
4557 
4558 #if (defined __STDC__ || defined __C99__FUNC__ \
4559  || defined __cplusplus || defined _MSC_VER)
4560 static void
4561 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4562 #else
4563 static void
4564 yy_stack_print (yybottom, yytop)
4565  yytype_int16 *yybottom;
4566  yytype_int16 *yytop;
4567 #endif
4568 {
4569  YYFPRINTF (stderr, "Stack now");
4570  for (; yybottom <= yytop; yybottom++)
4571  {
4572  int yybot = *yybottom;
4573  YYFPRINTF (stderr, " %d", yybot);
4574  }
4575  YYFPRINTF (stderr, "\n");
4576 }
4577 
4578 # define YY_STACK_PRINT(Bottom, Top) \
4579 do { \
4580  if (yydebug) \
4581  yy_stack_print ((Bottom), (Top)); \
4582 } while (YYID (0))
4583 
4584 
4585 /*------------------------------------------------.
4586 | Report that the YYRULE is going to be reduced. |
4587 `------------------------------------------------*/
4588 
4589 #if (defined __STDC__ || defined __C99__FUNC__ \
4590  || defined __cplusplus || defined _MSC_VER)
4591 static void
4592 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
4593 #else
4594 static void
4595 yy_reduce_print (yyvsp, yyrule, parser)
4596  YYSTYPE *yyvsp;
4597  int yyrule;
4598  struct parser_params *parser;
4599 #endif
4600 {
4601  int yynrhs = yyr2[yyrule];
4602  int yyi;
4603  unsigned long int yylno = yyrline[yyrule];
4604  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4605  yyrule - 1, yylno);
4606  /* The symbols being reduced. */
4607  for (yyi = 0; yyi < yynrhs; yyi++)
4608  {
4609  YYFPRINTF (stderr, " $%d = ", yyi + 1);
4610  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4611  &(yyvsp[(yyi + 1) - (yynrhs)])
4612  , parser);
4613  YYFPRINTF (stderr, "\n");
4614  }
4615 }
4616 
4617 # define YY_REDUCE_PRINT(Rule) \
4618 do { \
4619  if (yydebug) \
4620  yy_reduce_print (yyvsp, Rule, parser); \
4621 } while (YYID (0))
4622 
4623 /* Nonzero means print parse trace. It is left uninitialized so that
4624  multiple parsers can coexist. */
4625 #ifndef yydebug
4626 int yydebug;
4627 #endif
4628 #else /* !YYDEBUG */
4629 # define YYDPRINTF(Args)
4630 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4631 # define YY_STACK_PRINT(Bottom, Top)
4632 # define YY_REDUCE_PRINT(Rule)
4633 #endif /* !YYDEBUG */
4634 
4635 
4636 /* YYINITDEPTH -- initial size of the parser's stacks. */
4637 #ifndef YYINITDEPTH
4638 # define YYINITDEPTH 200
4639 #endif
4640 
4641 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4642  if the built-in stack extension method is used).
4643 
4644  Do not make this value too large; the results are undefined if
4645  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4646  evaluated with infinite-precision integer arithmetic. */
4647 
4648 #ifndef YYMAXDEPTH
4649 # define YYMAXDEPTH 10000
4650 #endif
4651 
4652 
4653 #if YYERROR_VERBOSE
4654 
4655 # ifndef yystrlen
4656 # if defined __GLIBC__ && defined _STRING_H
4657 # define yystrlen strlen
4658 # else
4659 /* Return the length of YYSTR. */
4660 #if (defined __STDC__ || defined __C99__FUNC__ \
4661  || defined __cplusplus || defined _MSC_VER)
4662 static YYSIZE_T
4663 yystrlen (const char *yystr)
4664 #else
4665 static YYSIZE_T
4666 yystrlen (yystr)
4667  const char *yystr;
4668 #endif
4669 {
4670  YYSIZE_T yylen;
4671  for (yylen = 0; yystr[yylen]; yylen++)
4672  continue;
4673  return yylen;
4674 }
4675 # endif
4676 # endif
4677 
4678 # ifndef yystpcpy
4679 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4680 # define yystpcpy stpcpy
4681 # else
4682 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4683  YYDEST. */
4684 #if (defined __STDC__ || defined __C99__FUNC__ \
4685  || defined __cplusplus || defined _MSC_VER)
4686 static char *
4687 yystpcpy (char *yydest, const char *yysrc)
4688 #else
4689 static char *
4690 yystpcpy (yydest, yysrc)
4691  char *yydest;
4692  const char *yysrc;
4693 #endif
4694 {
4695  char *yyd = yydest;
4696  const char *yys = yysrc;
4697 
4698  while ((*yyd++ = *yys++) != '\0')
4699  continue;
4700 
4701  return yyd - 1;
4702 }
4703 # endif
4704 # endif
4705 
4706 # ifndef yytnamerr
4707 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4708  quotes and backslashes, so that it's suitable for yyerror. The
4709  heuristic is that double-quoting is unnecessary unless the string
4710  contains an apostrophe, a comma, or backslash (other than
4711  backslash-backslash). YYSTR is taken from yytname. If YYRES is
4712  null, do not copy; instead, return the length of what the result
4713  would have been. */
4714 static YYSIZE_T
4715 yytnamerr (char *yyres, const char *yystr)
4716 {
4717  if (*yystr == '"')
4718  {
4719  YYSIZE_T yyn = 0;
4720  char const *yyp = yystr;
4721 
4722  for (;;)
4723  switch (*++yyp)
4724  {
4725  case '\'':
4726  case ',':
4727  goto do_not_strip_quotes;
4728 
4729  case '\\':
4730  if (*++yyp != '\\')
4731  goto do_not_strip_quotes;
4732  /* Fall through. */
4733  default:
4734  if (yyres)
4735  yyres[yyn] = *yyp;
4736  yyn++;
4737  break;
4738 
4739  case '"':
4740  if (yyres)
4741  yyres[yyn] = '\0';
4742  return yyn;
4743  }
4744  do_not_strip_quotes: ;
4745  }
4746 
4747  if (! yyres)
4748  return yystrlen (yystr);
4749 
4750  return yystpcpy (yyres, yystr) - yyres;
4751 }
4752 # endif
4753 
4754 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
4755  about the unexpected token YYTOKEN for the state stack whose top is
4756  YYSSP.
4757 
4758  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
4759  not large enough to hold the message. In that case, also set
4760  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
4761  required number of bytes is too large to store. */
4762 static int
4763 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
4764  yytype_int16 *yyssp, int yytoken)
4765 {
4766  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
4767  YYSIZE_T yysize = yysize0;
4768  YYSIZE_T yysize1;
4769  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4770  /* Internationalized format string. */
4771  const char *yyformat = 0;
4772  /* Arguments of yyformat. */
4773  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4774  /* Number of reported tokens (one for the "unexpected", one per
4775  "expected"). */
4776  int yycount = 0;
4777 
4778  /* There are many possibilities here to consider:
4779  - Assume YYFAIL is not used. It's too flawed to consider. See
4780  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
4781  for details. YYERROR is fine as it does not invoke this
4782  function.
4783  - If this state is a consistent state with a default action, then
4784  the only way this function was invoked is if the default action
4785  is an error action. In that case, don't check for expected
4786  tokens because there are none.
4787  - The only way there can be no lookahead present (in yychar) is if
4788  this state is a consistent state with a default action. Thus,
4789  detecting the absence of a lookahead is sufficient to determine
4790  that there is no unexpected or expected token to report. In that
4791  case, just report a simple "syntax error".
4792  - Don't assume there isn't a lookahead just because this state is a
4793  consistent state with a default action. There might have been a
4794  previous inconsistent state, consistent state with a non-default
4795  action, or user semantic action that manipulated yychar.
4796  - Of course, the expected token list depends on states to have
4797  correct lookahead information, and it depends on the parser not
4798  to perform extra reductions after fetching a lookahead from the
4799  scanner and before detecting a syntax error. Thus, state merging
4800  (from LALR or IELR) and default reductions corrupt the expected
4801  token list. However, the list is correct for canonical LR with
4802  one exception: it will still contain any token that will not be
4803  accepted due to an error action in a later state.
4804  */
4805  if (yytoken != YYEMPTY)
4806  {
4807  int yyn = yypact[*yyssp];
4808  yyarg[yycount++] = yytname[yytoken];
4809  if (!yypact_value_is_default (yyn))
4810  {
4811  /* Start YYX at -YYN if negative to avoid negative indexes in
4812  YYCHECK. In other words, skip the first -YYN actions for
4813  this state because they are default actions. */
4814  int yyxbegin = yyn < 0 ? -yyn : 0;
4815  /* Stay within bounds of both yycheck and yytname. */
4816  int yychecklim = YYLAST - yyn + 1;
4817  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4818  int yyx;
4819 
4820  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4821  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
4822  && !yytable_value_is_error (yytable[yyx + yyn]))
4823  {
4824  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4825  {
4826  yycount = 1;
4827  yysize = yysize0;
4828  break;
4829  }
4830  yyarg[yycount++] = yytname[yyx];
4831  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4832  if (! (yysize <= yysize1
4833  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4834  return 2;
4835  yysize = yysize1;
4836  }
4837  }
4838  }
4839 
4840  switch (yycount)
4841  {
4842 # define YYCASE_(N, S) \
4843  case N: \
4844  yyformat = S; \
4845  break
4846  YYCASE_(0, YY_("syntax error"));
4847  YYCASE_(1, YY_("syntax error, unexpected %s"));
4848  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
4849  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
4850  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
4851  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
4852 # undef YYCASE_
4853  }
4854 
4855  yysize1 = yysize + yystrlen (yyformat);
4856  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4857  return 2;
4858  yysize = yysize1;
4859 
4860  if (*yymsg_alloc < yysize)
4861  {
4862  *yymsg_alloc = 2 * yysize;
4863  if (! (yysize <= *yymsg_alloc
4864  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
4865  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
4866  return 1;
4867  }
4868 
4869  /* Avoid sprintf, as that infringes on the user's name space.
4870  Don't have undefined behavior even if the translation
4871  produced a string with the wrong number of "%s"s. */
4872  {
4873  char *yyp = *yymsg;
4874  int yyi = 0;
4875  while ((*yyp = *yyformat) != '\0')
4876  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
4877  {
4878  yyp += yytnamerr (yyp, yyarg[yyi++]);
4879  yyformat += 2;
4880  }
4881  else
4882  {
4883  yyp++;
4884  yyformat++;
4885  }
4886  }
4887  return 0;
4888 }
4889 #endif /* YYERROR_VERBOSE */
4890 
4891 /*-----------------------------------------------.
4892 | Release the memory associated to this symbol. |
4893 `-----------------------------------------------*/
4894 
4895 /*ARGSUSED*/
4896 #if (defined __STDC__ || defined __C99__FUNC__ \
4897  || defined __cplusplus || defined _MSC_VER)
4898 static void
4899 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
4900 #else
4901 static void
4902 yydestruct (yymsg, yytype, yyvaluep, parser)
4903  const char *yymsg;
4904  int yytype;
4905  YYSTYPE *yyvaluep;
4906  struct parser_params *parser;
4907 #endif
4908 {
4909  YYUSE (yyvaluep);
4910  YYUSE (parser);
4911 
4912  if (!yymsg)
4913  yymsg = "Deleting";
4914  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4915 
4916  switch (yytype)
4917  {
4918 
4919  default:
4920  break;
4921  }
4922 }
4923 
4924 
4925 /* Prevent warnings from -Wmissing-prototypes. */
4926 #ifdef YYPARSE_PARAM
4927 #if defined __STDC__ || defined __cplusplus
4928 int yyparse (void *YYPARSE_PARAM);
4929 #else
4930 int yyparse ();
4931 #endif
4932 #else /* ! YYPARSE_PARAM */
4933 #if defined __STDC__ || defined __cplusplus
4934 int yyparse (struct parser_params *parser);
4935 #else
4936 int yyparse ();
4937 #endif
4938 #endif /* ! YYPARSE_PARAM */
4939 
4940 
4941 /*----------.
4942 | yyparse. |
4943 `----------*/
4944 
4945 #ifdef YYPARSE_PARAM
4946 #if (defined __STDC__ || defined __C99__FUNC__ \
4947  || defined __cplusplus || defined _MSC_VER)
4948 int
4949 yyparse (void *YYPARSE_PARAM)
4950 #else
4951 int
4952 yyparse (YYPARSE_PARAM)
4953  void *YYPARSE_PARAM;
4954 #endif
4955 #else /* ! YYPARSE_PARAM */
4956 #if (defined __STDC__ || defined __C99__FUNC__ \
4957  || defined __cplusplus || defined _MSC_VER)
4958 int
4959 yyparse (struct parser_params *parser)
4960 #else
4961 int
4962 yyparse (parser)
4963  struct parser_params *parser;
4964 #endif
4965 #endif
4966 {
4967 /* The lookahead symbol. */
4968 int yychar;
4969 
4970 /* The semantic value of the lookahead symbol. */
4971 YYSTYPE yylval;
4972 
4973  /* Number of syntax errors so far. */
4974  int yynerrs;
4975 
4976  int yystate;
4977  /* Number of tokens to shift before error messages enabled. */
4978  int yyerrstatus;
4979 
4980  /* The stacks and their tools:
4981  `yyss': related to states.
4982  `yyvs': related to semantic values.
4983 
4984  Refer to the stacks thru separate pointers, to allow yyoverflow
4985  to reallocate them elsewhere. */
4986 
4987  /* The state stack. */
4988  yytype_int16 yyssa[YYINITDEPTH];
4989  yytype_int16 *yyss;
4990  yytype_int16 *yyssp;
4991 
4992  /* The semantic value stack. */
4993  YYSTYPE yyvsa[YYINITDEPTH];
4994  YYSTYPE *yyvs;
4995  YYSTYPE *yyvsp;
4996 
4997  YYSIZE_T yystacksize;
4998 
4999  int yyn;
5000  int yyresult;
5001  /* Lookahead token as an internal (translated) token number. */
5002  int yytoken;
5003  /* The variables used to return semantic value and location from the
5004  action routines. */
5005  YYSTYPE yyval;
5006 
5007 #if YYERROR_VERBOSE
5008  /* Buffer for error messages, and its allocated size. */
5009  char yymsgbuf[128];
5010  char *yymsg = yymsgbuf;
5011  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
5012 #endif
5013 
5014 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
5015 
5016  /* The number of symbols on the RHS of the reduced rule.
5017  Keep to zero when no symbol should be popped. */
5018  int yylen = 0;
5019 
5020  yytoken = 0;
5021  yyss = yyssa;
5022  yyvs = yyvsa;
5023  yystacksize = YYINITDEPTH;
5024 
5025  YYDPRINTF ((stderr, "Starting parse\n"));
5026 
5027  yystate = 0;
5028  yyerrstatus = 0;
5029  yynerrs = 0;
5030  yychar = YYEMPTY; /* Cause a token to be read. */
5031 
5032  /* Initialize stack pointers.
5033  Waste one element of value and location stack
5034  so that they stay on the same level as the state stack.
5035  The wasted elements are never initialized. */
5036  yyssp = yyss;
5037  yyvsp = yyvs;
5038 
5039  goto yysetstate;
5040 
5041 /*------------------------------------------------------------.
5042 | yynewstate -- Push a new state, which is found in yystate. |
5043 `------------------------------------------------------------*/
5044  yynewstate:
5045  /* In all cases, when you get here, the value and location stacks
5046  have just been pushed. So pushing a state here evens the stacks. */
5047  yyssp++;
5048 
5049  yysetstate:
5050  *yyssp = yystate;
5051 
5052  if (yyss + yystacksize - 1 <= yyssp)
5053  {
5054  /* Get the current used size of the three stacks, in elements. */
5055  YYSIZE_T yysize = yyssp - yyss + 1;
5056 
5057 #ifdef yyoverflow
5058  {
5059  /* Give user a chance to reallocate the stack. Use copies of
5060  these so that the &'s don't force the real ones into
5061  memory. */
5062  YYSTYPE *yyvs1 = yyvs;
5063  yytype_int16 *yyss1 = yyss;
5064 
5065  /* Each stack pointer address is followed by the size of the
5066  data in use in that stack, in bytes. This used to be a
5067  conditional around just the two extra args, but that might
5068  be undefined if yyoverflow is a macro. */
5069  yyoverflow (YY_("memory exhausted"),
5070  &yyss1, yysize * sizeof (*yyssp),
5071  &yyvs1, yysize * sizeof (*yyvsp),
5072  &yystacksize);
5073 
5074  yyss = yyss1;
5075  yyvs = yyvs1;
5076  }
5077 #else /* no yyoverflow */
5078 # ifndef YYSTACK_RELOCATE
5079  goto yyexhaustedlab;
5080 # else
5081  /* Extend the stack our own way. */
5082  if (YYMAXDEPTH <= yystacksize)
5083  goto yyexhaustedlab;
5084  yystacksize *= 2;
5085  if (YYMAXDEPTH < yystacksize)
5086  yystacksize = YYMAXDEPTH;
5087 
5088  {
5089  yytype_int16 *yyss1 = yyss;
5090  union yyalloc *yyptr =
5091  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
5092  if (! yyptr)
5093  goto yyexhaustedlab;
5094  YYSTACK_RELOCATE (yyss_alloc, yyss);
5095  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
5096 # undef YYSTACK_RELOCATE
5097  if (yyss1 != yyssa)
5098  YYSTACK_FREE (yyss1);
5099  }
5100 # endif
5101 #endif /* no yyoverflow */
5102 
5103  yyssp = yyss + yysize - 1;
5104  yyvsp = yyvs + yysize - 1;
5105 
5106  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
5107  (unsigned long int) yystacksize));
5108 
5109  if (yyss + yystacksize - 1 <= yyssp)
5110  YYABORT;
5111  }
5112 
5113  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
5114 
5115  if (yystate == YYFINAL)
5116  YYACCEPT;
5117 
5118  goto yybackup;
5119 
5120 /*-----------.
5121 | yybackup. |
5122 `-----------*/
5123 yybackup:
5124 
5125  /* Do appropriate processing given the current state. Read a
5126  lookahead token if we need one and don't already have one. */
5127 
5128  /* First try to decide what to do without reference to lookahead token. */
5129  yyn = yypact[yystate];
5130  if (yypact_value_is_default (yyn))
5131  goto yydefault;
5132 
5133  /* Not known => get a lookahead token if don't already have one. */
5134 
5135  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5136  if (yychar == YYEMPTY)
5137  {
5138  YYDPRINTF ((stderr, "Reading a token: "));
5139  yychar = YYLEX;
5140  }
5141 
5142  if (yychar <= YYEOF)
5143  {
5144  yychar = yytoken = YYEOF;
5145  YYDPRINTF ((stderr, "Now at end of input.\n"));
5146  }
5147  else
5148  {
5149  yytoken = YYTRANSLATE (yychar);
5150  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
5151  }
5152 
5153  /* If the proper action on seeing token YYTOKEN is to reduce or to
5154  detect an error, take that action. */
5155  yyn += yytoken;
5156  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
5157  goto yydefault;
5158  yyn = yytable[yyn];
5159  if (yyn <= 0)
5160  {
5161  if (yytable_value_is_error (yyn))
5162  goto yyerrlab;
5163  yyn = -yyn;
5164  goto yyreduce;
5165  }
5166 
5167  /* Count tokens shifted since error; after three, turn off error
5168  status. */
5169  if (yyerrstatus)
5170  yyerrstatus--;
5171 
5172  /* Shift the lookahead token. */
5173  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
5174 
5175  /* Discard the shifted token. */
5176  yychar = YYEMPTY;
5177 
5178  yystate = yyn;
5179  *++yyvsp = yylval;
5180 
5181  goto yynewstate;
5182 
5183 
5184 /*-----------------------------------------------------------.
5185 | yydefault -- do the default action for the current state. |
5186 `-----------------------------------------------------------*/
5187 yydefault:
5188  yyn = yydefact[yystate];
5189  if (yyn == 0)
5190  goto yyerrlab;
5191  goto yyreduce;
5192 
5193 
5194 /*-----------------------------.
5195 | yyreduce -- Do a reduction. |
5196 `-----------------------------*/
5197 yyreduce:
5198  /* yyn is the number of a rule to reduce with. */
5199  yylen = yyr2[yyn];
5200 
5201  /* If YYLEN is nonzero, implement the default value of the action:
5202  `$$ = $1'.
5203 
5204  Otherwise, the following line sets YYVAL to garbage.
5205  This behavior is undocumented and Bison
5206  users should not rely upon it. Assigning to YYVAL
5207  unconditionally makes the parser a bit smaller, and it avoids a
5208  GCC warning that YYVAL may be used uninitialized. */
5209  yyval = yyvsp[1-yylen];
5210 
5211 
5212  YY_REDUCE_PRINT (yyn);
5213  switch (yyn)
5214  {
5215  case 2:
5216 
5217 /* Line 1806 of yacc.c */
5218 #line 853 "parse.y"
5219  {
5220  lex_state = EXPR_BEG;
5221  /*%%%*/
5223  /*%
5224  local_push(0);
5225  %*/
5226  }
5227  break;
5228 
5229  case 3:
5230 
5231 /* Line 1806 of yacc.c */
5232 #line 862 "parse.y"
5233  {
5234  /*%%%*/
5235  if ((yyvsp[(2) - (2)].node) && !compile_for_eval) {
5236  /* last expression should not be void */
5237  if (nd_type((yyvsp[(2) - (2)].node)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].node));
5238  else {
5239  NODE *node = (yyvsp[(2) - (2)].node);
5240  while (node->nd_next) {
5241  node = node->nd_next;
5242  }
5243  void_expr(node->nd_head);
5244  }
5245  }
5246  ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].node)));
5247  /*%
5248  $$ = $2;
5249  parser->result = dispatch1(program, $$);
5250  %*/
5251  local_pop();
5252  }
5253  break;
5254 
5255  case 4:
5256 
5257 /* Line 1806 of yacc.c */
5258 #line 885 "parse.y"
5259  {
5260  /*%%%*/
5261  void_stmts((yyvsp[(1) - (2)].node));
5263  /*%
5264  %*/
5265  (yyval.node) = (yyvsp[(1) - (2)].node);
5266  }
5267  break;
5268 
5269  case 5:
5270 
5271 /* Line 1806 of yacc.c */
5272 #line 896 "parse.y"
5273  {
5274  /*%%%*/
5275  (yyval.node) = NEW_BEGIN(0);
5276  /*%
5277  $$ = dispatch2(stmts_add, dispatch0(stmts_new),
5278  dispatch0(void_stmt));
5279  %*/
5280  }
5281  break;
5282 
5283  case 6:
5284 
5285 /* Line 1806 of yacc.c */
5286 #line 905 "parse.y"
5287  {
5288  /*%%%*/
5289  (yyval.node) = newline_node((yyvsp[(1) - (1)].node));
5290  /*%
5291  $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
5292  %*/
5293  }
5294  break;
5295 
5296  case 7:
5297 
5298 /* Line 1806 of yacc.c */
5299 #line 913 "parse.y"
5300  {
5301  /*%%%*/
5302  (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node)));
5303  /*%
5304  $$ = dispatch2(stmts_add, $1, $3);
5305  %*/
5306  }
5307  break;
5308 
5309  case 8:
5310 
5311 /* Line 1806 of yacc.c */
5312 #line 921 "parse.y"
5313  {
5314  (yyval.node) = remove_begin((yyvsp[(2) - (2)].node));
5315  }
5316  break;
5317 
5318  case 10:
5319 
5320 /* Line 1806 of yacc.c */
5321 #line 928 "parse.y"
5322  {
5323  /*%%%*/
5324  /* local_push(0); */
5325  /*%
5326  %*/
5327  }
5328  break;
5329 
5330  case 11:
5331 
5332 /* Line 1806 of yacc.c */
5333 #line 935 "parse.y"
5334  {
5335  /*%%%*/
5337  (yyvsp[(4) - (5)].node));
5338  /* NEW_PREEXE($4)); */
5339  /* local_pop(); */
5340  (yyval.node) = NEW_BEGIN(0);
5341  /*%
5342  $$ = dispatch1(BEGIN, $4);
5343  %*/
5344  }
5345  break;
5346 
5347  case 12:
5348 
5349 /* Line 1806 of yacc.c */
5350 #line 952 "parse.y"
5351  {
5352  /*%%%*/
5353  (yyval.node) = (yyvsp[(1) - (4)].node);
5354  if ((yyvsp[(2) - (4)].node)) {
5355  (yyval.node) = NEW_RESCUE((yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].node), (yyvsp[(3) - (4)].node));
5356  }
5357  else if ((yyvsp[(3) - (4)].node)) {
5358  rb_warn0("else without rescue is useless");
5359  (yyval.node) = block_append((yyval.node), (yyvsp[(3) - (4)].node));
5360  }
5361  if ((yyvsp[(4) - (4)].node)) {
5362  if ((yyval.node)) {
5363  (yyval.node) = NEW_ENSURE((yyval.node), (yyvsp[(4) - (4)].node));
5364  }
5365  else {
5366  (yyval.node) = block_append((yyvsp[(4) - (4)].node), NEW_NIL());
5367  }
5368  }
5369  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
5370  /*%
5371  $$ = dispatch4(bodystmt,
5372  escape_Qundef($1),
5373  escape_Qundef($2),
5374  escape_Qundef($3),
5375  escape_Qundef($4));
5376  %*/
5377  }
5378  break;
5379 
5380  case 13:
5381 
5382 /* Line 1806 of yacc.c */
5383 #line 982 "parse.y"
5384  {
5385  /*%%%*/
5386  void_stmts((yyvsp[(1) - (2)].node));
5388  /*%
5389  %*/
5390  (yyval.node) = (yyvsp[(1) - (2)].node);
5391  }
5392  break;
5393 
5394  case 14:
5395 
5396 /* Line 1806 of yacc.c */
5397 #line 993 "parse.y"
5398  {
5399  /*%%%*/
5400  (yyval.node) = NEW_BEGIN(0);
5401  /*%
5402  $$ = dispatch2(stmts_add, dispatch0(stmts_new),
5403  dispatch0(void_stmt));
5404  %*/
5405  }
5406  break;
5407 
5408  case 15:
5409 
5410 /* Line 1806 of yacc.c */
5411 #line 1002 "parse.y"
5412  {
5413  /*%%%*/
5414  (yyval.node) = newline_node((yyvsp[(1) - (1)].node));
5415  /*%
5416  $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
5417  %*/
5418  }
5419  break;
5420 
5421  case 16:
5422 
5423 /* Line 1806 of yacc.c */
5424 #line 1010 "parse.y"
5425  {
5426  /*%%%*/
5427  (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node)));
5428  /*%
5429  $$ = dispatch2(stmts_add, $1, $3);
5430  %*/
5431  }
5432  break;
5433 
5434  case 17:
5435 
5436 /* Line 1806 of yacc.c */
5437 #line 1018 "parse.y"
5438  {
5439  (yyval.node) = remove_begin((yyvsp[(2) - (2)].node));
5440  }
5441  break;
5442 
5443  case 18:
5444 
5445 /* Line 1806 of yacc.c */
5446 #line 1024 "parse.y"
5447  {
5448  (yyval.node) = (yyvsp[(1) - (1)].node);
5449  }
5450  break;
5451 
5452  case 19:
5453 
5454 /* Line 1806 of yacc.c */
5455 #line 1028 "parse.y"
5456  {
5457  yyerror("BEGIN is permitted only at toplevel");
5458  /*%%%*/
5459  /* local_push(0); */
5460  /*%
5461  %*/
5462  }
5463  break;
5464 
5465  case 20:
5466 
5467 /* Line 1806 of yacc.c */
5468 #line 1036 "parse.y"
5469  {
5470  /*%%%*/
5472  (yyvsp[(4) - (5)].node));
5473  /* NEW_PREEXE($4)); */
5474  /* local_pop(); */
5475  (yyval.node) = NEW_BEGIN(0);
5476  /*%
5477  $$ = dispatch1(BEGIN, $4);
5478  %*/
5479  }
5480  break;
5481 
5482  case 21:
5483 
5484 /* Line 1806 of yacc.c */
5485 #line 1048 "parse.y"
5486  {lex_state = EXPR_FNAME;}
5487  break;
5488 
5489  case 22:
5490 
5491 /* Line 1806 of yacc.c */
5492 #line 1049 "parse.y"
5493  {
5494  /*%%%*/
5495  (yyval.node) = NEW_ALIAS((yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].node));
5496  /*%
5497  $$ = dispatch2(alias, $2, $4);
5498  %*/
5499  }
5500  break;
5501 
5502  case 23:
5503 
5504 /* Line 1806 of yacc.c */
5505 #line 1057 "parse.y"
5506  {
5507  /*%%%*/
5508  (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].id));
5509  /*%
5510  $$ = dispatch2(var_alias, $2, $3);
5511  %*/
5512  }
5513  break;
5514 
5515  case 24:
5516 
5517 /* Line 1806 of yacc.c */
5518 #line 1065 "parse.y"
5519  {
5520  /*%%%*/
5521  char buf[2];
5522  buf[0] = '$';
5523  buf[1] = (char)(yyvsp[(3) - (3)].node)->nd_nth;
5524  (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), rb_intern2(buf, 2));
5525  /*%
5526  $$ = dispatch2(var_alias, $2, $3);
5527  %*/
5528  }
5529  break;
5530 
5531  case 25:
5532 
5533 /* Line 1806 of yacc.c */
5534 #line 1076 "parse.y"
5535  {
5536  /*%%%*/
5537  yyerror("can't make alias for the number variables");
5538  (yyval.node) = NEW_BEGIN(0);
5539  /*%
5540  $$ = dispatch2(var_alias, $2, $3);
5541  $$ = dispatch1(alias_error, $$);
5542  %*/
5543  }
5544  break;
5545 
5546  case 26:
5547 
5548 /* Line 1806 of yacc.c */
5549 #line 1086 "parse.y"
5550  {
5551  /*%%%*/
5552  (yyval.node) = (yyvsp[(2) - (2)].node);
5553  /*%
5554  $$ = dispatch1(undef, $2);
5555  %*/
5556  }
5557  break;
5558 
5559  case 27:
5560 
5561 /* Line 1806 of yacc.c */
5562 #line 1094 "parse.y"
5563  {
5564  /*%%%*/
5565  (yyval.node) = NEW_IF(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0);
5566  fixpos((yyval.node), (yyvsp[(3) - (3)].node));
5567  /*%
5568  $$ = dispatch2(if_mod, $3, $1);
5569  %*/
5570  }
5571  break;
5572 
5573  case 28:
5574 
5575 /* Line 1806 of yacc.c */
5576 #line 1103 "parse.y"
5577  {
5578  /*%%%*/
5579  (yyval.node) = NEW_UNLESS(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0);
5580  fixpos((yyval.node), (yyvsp[(3) - (3)].node));
5581  /*%
5582  $$ = dispatch2(unless_mod, $3, $1);
5583  %*/
5584  }
5585  break;
5586 
5587  case 29:
5588 
5589 /* Line 1806 of yacc.c */
5590 #line 1112 "parse.y"
5591  {
5592  /*%%%*/
5593  if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) {
5594  (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0);
5595  }
5596  else {
5597  (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1);
5598  }
5599  /*%
5600  $$ = dispatch2(while_mod, $3, $1);
5601  %*/
5602  }
5603  break;
5604 
5605  case 30:
5606 
5607 /* Line 1806 of yacc.c */
5608 #line 1125 "parse.y"
5609  {
5610  /*%%%*/
5611  if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) {
5612  (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0);
5613  }
5614  else {
5615  (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1);
5616  }
5617  /*%
5618  $$ = dispatch2(until_mod, $3, $1);
5619  %*/
5620  }
5621  break;
5622 
5623  case 31:
5624 
5625 /* Line 1806 of yacc.c */
5626 #line 1138 "parse.y"
5627  {
5628  /*%%%*/
5629  NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].node)), 0);
5630  (yyval.node) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].node)), resq, 0);
5631  /*%
5632  $$ = dispatch2(rescue_mod, $1, $3);
5633  %*/
5634  }
5635  break;
5636 
5637  case 32:
5638 
5639 /* Line 1806 of yacc.c */
5640 #line 1147 "parse.y"
5641  {
5642  if (in_def || in_single) {
5643  rb_warn0("END in method; use at_exit");
5644  }
5645  /*%%%*/
5646  (yyval.node) = NEW_POSTEXE(NEW_NODE(
5647  NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].node) /* body */, 0 /* args */));
5648  /*%
5649  $$ = dispatch1(END, $3);
5650  %*/
5651  }
5652  break;
5653 
5654  case 34:
5655 
5656 /* Line 1806 of yacc.c */
5657 #line 1160 "parse.y"
5658  {
5659  /*%%%*/
5660  value_expr((yyvsp[(3) - (3)].node));
5661  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
5662  (yyval.node) = (yyvsp[(1) - (3)].node);
5663  /*%
5664  $$ = dispatch2(massign, $1, $3);
5665  %*/
5666  }
5667  break;
5668 
5669  case 35:
5670 
5671 /* Line 1806 of yacc.c */
5672 #line 1170 "parse.y"
5673  {
5674  value_expr((yyvsp[(3) - (3)].node));
5675  (yyval.node) = new_op_assign((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].node));
5676  }
5677  break;
5678 
5679  case 36:
5680 
5681 /* Line 1806 of yacc.c */
5682 #line 1175 "parse.y"
5683  {
5684  /*%%%*/
5685  NODE *args;
5686 
5687  value_expr((yyvsp[(6) - (6)].node));
5688  if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY();
5689  args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
5690  if ((yyvsp[(5) - (6)].id) == tOROP) {
5691  (yyvsp[(5) - (6)].id) = 0;
5692  }
5693  else if ((yyvsp[(5) - (6)].id) == tANDOP) {
5694  (yyvsp[(5) - (6)].id) = 1;
5695  }
5696  (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args);
5697  fixpos((yyval.node), (yyvsp[(1) - (6)].node));
5698  /*%
5699  $$ = dispatch2(aref_field, $1, escape_Qundef($3));
5700  $$ = dispatch3(opassign, $$, $5, $6);
5701  %*/
5702  }
5703  break;
5704 
5705  case 37:
5706 
5707 /* Line 1806 of yacc.c */
5708 #line 1196 "parse.y"
5709  {
5710  value_expr((yyvsp[(5) - (5)].node));
5711  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5712  }
5713  break;
5714 
5715  case 38:
5716 
5717 /* Line 1806 of yacc.c */
5718 #line 1201 "parse.y"
5719  {
5720  value_expr((yyvsp[(5) - (5)].node));
5721  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5722  }
5723  break;
5724 
5725  case 39:
5726 
5727 /* Line 1806 of yacc.c */
5728 #line 1206 "parse.y"
5729  {
5730  /*%%%*/
5731  (yyval.node) = NEW_COLON2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id));
5732  (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5733  /*%
5734  $$ = dispatch2(const_path_field, $1, $3);
5735  $$ = dispatch3(opassign, $$, $4, $5);
5736  %*/
5737  }
5738  break;
5739 
5740  case 40:
5741 
5742 /* Line 1806 of yacc.c */
5743 #line 1216 "parse.y"
5744  {
5745  value_expr((yyvsp[(5) - (5)].node));
5746  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_intern("::"), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5747  }
5748  break;
5749 
5750  case 41:
5751 
5752 /* Line 1806 of yacc.c */
5753 #line 1221 "parse.y"
5754  {
5755  /*%%%*/
5756  rb_backref_error((yyvsp[(1) - (3)].node));
5757  (yyval.node) = NEW_BEGIN(0);
5758  /*%
5759  $$ = dispatch2(assign, dispatch1(var_field, $1), $3);
5760  $$ = dispatch1(assign_error, $$);
5761  %*/
5762  }
5763  break;
5764 
5765  case 42:
5766 
5767 /* Line 1806 of yacc.c */
5768 #line 1231 "parse.y"
5769  {
5770  /*%%%*/
5771  value_expr((yyvsp[(3) - (3)].node));
5772  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5773  /*%
5774  $$ = dispatch2(assign, $1, $3);
5775  %*/
5776  }
5777  break;
5778 
5779  case 43:
5780 
5781 /* Line 1806 of yacc.c */
5782 #line 1240 "parse.y"
5783  {
5784  /*%%%*/
5785  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
5786  (yyval.node) = (yyvsp[(1) - (3)].node);
5787  /*%
5788  $$ = dispatch2(massign, $1, $3);
5789  %*/
5790  }
5791  break;
5792 
5793  case 44:
5794 
5795 /* Line 1806 of yacc.c */
5796 #line 1249 "parse.y"
5797  {
5798  /*%%%*/
5799  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
5800  (yyval.node) = (yyvsp[(1) - (3)].node);
5801  /*%
5802  $$ = dispatch2(massign, $1, $3);
5803  %*/
5804  }
5805  break;
5806 
5807  case 46:
5808 
5809 /* Line 1806 of yacc.c */
5810 #line 1261 "parse.y"
5811  {
5812  /*%%%*/
5813  value_expr((yyvsp[(3) - (3)].node));
5814  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5815  /*%
5816  $$ = dispatch2(assign, $1, $3);
5817  %*/
5818  }
5819  break;
5820 
5821  case 47:
5822 
5823 /* Line 1806 of yacc.c */
5824 #line 1270 "parse.y"
5825  {
5826  /*%%%*/
5827  value_expr((yyvsp[(3) - (3)].node));
5828  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5829  /*%
5830  $$ = dispatch2(assign, $1, $3);
5831  %*/
5832  }
5833  break;
5834 
5835  case 49:
5836 
5837 /* Line 1806 of yacc.c */
5838 #line 1283 "parse.y"
5839  {
5840  /*%%%*/
5841  (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5842  /*%
5843  $$ = dispatch3(binary, $1, ripper_intern("and"), $3);
5844  %*/
5845  }
5846  break;
5847 
5848  case 50:
5849 
5850 /* Line 1806 of yacc.c */
5851 #line 1291 "parse.y"
5852  {
5853  /*%%%*/
5854  (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5855  /*%
5856  $$ = dispatch3(binary, $1, ripper_intern("or"), $3);
5857  %*/
5858  }
5859  break;
5860 
5861  case 51:
5862 
5863 /* Line 1806 of yacc.c */
5864 #line 1299 "parse.y"
5865  {
5866  /*%%%*/
5867  (yyval.node) = call_uni_op(cond((yyvsp[(3) - (3)].node)), '!');
5868  /*%
5869  $$ = dispatch2(unary, ripper_intern("not"), $3);
5870  %*/
5871  }
5872  break;
5873 
5874  case 52:
5875 
5876 /* Line 1806 of yacc.c */
5877 #line 1307 "parse.y"
5878  {
5879  /*%%%*/
5880  (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!');
5881  /*%
5882  $$ = dispatch2(unary, ripper_id2sym('!'), $2);
5883  %*/
5884  }
5885  break;
5886 
5887  case 54:
5888 
5889 /* Line 1806 of yacc.c */
5890 #line 1318 "parse.y"
5891  {
5892  /*%%%*/
5893  value_expr((yyvsp[(1) - (1)].node));
5894  (yyval.node) = (yyvsp[(1) - (1)].node);
5895  if (!(yyval.node)) (yyval.node) = NEW_NIL();
5896  /*%
5897  $$ = $1;
5898  %*/
5899  }
5900  break;
5901 
5902  case 58:
5903 
5904 /* Line 1806 of yacc.c */
5905 #line 1335 "parse.y"
5906  {
5907  /*%%%*/
5908  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
5909  /*%
5910  $$ = dispatch3(call, $1, $2, $3);
5911  $$ = method_arg($$, $4);
5912  %*/
5913  }
5914  break;
5915 
5916  case 59:
5917 
5918 /* Line 1806 of yacc.c */
5919 #line 1346 "parse.y"
5920  {
5921  (yyvsp[(1) - (1)].vars) = dyna_push();
5922  /*%%%*/
5923  (yyval.num) = ruby_sourceline;
5924  /*%
5925  %*/
5926  }
5927  break;
5928 
5929  case 60:
5930 
5931 /* Line 1806 of yacc.c */
5932 #line 1356 "parse.y"
5933  {
5934  /*%%%*/
5935  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
5936  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
5937  /*%
5938  $$ = dispatch2(brace_block, escape_Qundef($3), $4);
5939  %*/
5940  dyna_pop((yyvsp[(1) - (5)].vars));
5941  }
5942  break;
5943 
5944  case 61:
5945 
5946 /* Line 1806 of yacc.c */
5947 #line 1368 "parse.y"
5948  {
5949  /*%%%*/
5950  (yyval.node) = NEW_FCALL((yyvsp[(1) - (1)].id), 0);
5951  nd_set_line((yyval.node), tokline);
5952  /*%
5953  %*/
5954  }
5955  break;
5956 
5957  case 62:
5958 
5959 /* Line 1806 of yacc.c */
5960 #line 1378 "parse.y"
5961  {
5962  /*%%%*/
5963  (yyval.node) = (yyvsp[(1) - (2)].node);
5964  (yyval.node)->nd_args = (yyvsp[(2) - (2)].node);
5965  /*%
5966  $$ = dispatch2(command, $1, $2);
5967  %*/
5968  }
5969  break;
5970 
5971  case 63:
5972 
5973 /* Line 1806 of yacc.c */
5974 #line 1387 "parse.y"
5975  {
5976  /*%%%*/
5977  block_dup_check((yyvsp[(2) - (3)].node),(yyvsp[(3) - (3)].node));
5978  (yyvsp[(1) - (3)].node)->nd_args = (yyvsp[(2) - (3)].node);
5979  (yyvsp[(3) - (3)].node)->nd_iter = (yyvsp[(1) - (3)].node);
5980  (yyval.node) = (yyvsp[(3) - (3)].node);
5981  fixpos((yyval.node), (yyvsp[(1) - (3)].node));
5982  /*%
5983  $$ = dispatch2(command, $1, $2);
5984  $$ = method_add_block($$, $3);
5985  %*/
5986  }
5987  break;
5988 
5989  case 64:
5990 
5991 /* Line 1806 of yacc.c */
5992 #line 1400 "parse.y"
5993  {
5994  /*%%%*/
5995  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
5996  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
5997  /*%
5998  $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
5999  %*/
6000  }
6001  break;
6002 
6003  case 65:
6004 
6005 /* Line 1806 of yacc.c */
6006 #line 1409 "parse.y"
6007  {
6008  /*%%%*/
6009  block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node));
6010  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
6011  (yyval.node) = (yyvsp[(5) - (5)].node);
6012  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
6013  /*%
6014  $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
6015  $$ = method_add_block($$, $5);
6016  %*/
6017  }
6018  break;
6019 
6020  case 66:
6021 
6022 /* Line 1806 of yacc.c */
6023 #line 1421 "parse.y"
6024  {
6025  /*%%%*/
6026  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
6027  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
6028  /*%
6029  $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
6030  %*/
6031  }
6032  break;
6033 
6034  case 67:
6035 
6036 /* Line 1806 of yacc.c */
6037 #line 1430 "parse.y"
6038  {
6039  /*%%%*/
6040  block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node));
6041  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
6042  (yyval.node) = (yyvsp[(5) - (5)].node);
6043  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
6044  /*%
6045  $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
6046  $$ = method_add_block($$, $5);
6047  %*/
6048  }
6049  break;
6050 
6051  case 68:
6052 
6053 /* Line 1806 of yacc.c */
6054 #line 1442 "parse.y"
6055  {
6056  /*%%%*/
6057  (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node));
6058  fixpos((yyval.node), (yyvsp[(2) - (2)].node));
6059  /*%
6060  $$ = dispatch1(super, $2);
6061  %*/
6062  }
6063  break;
6064 
6065  case 69:
6066 
6067 /* Line 1806 of yacc.c */
6068 #line 1451 "parse.y"
6069  {
6070  /*%%%*/
6071  (yyval.node) = new_yield((yyvsp[(2) - (2)].node));
6072  fixpos((yyval.node), (yyvsp[(2) - (2)].node));
6073  /*%
6074  $$ = dispatch1(yield, $2);
6075  %*/
6076  }
6077  break;
6078 
6079  case 70:
6080 
6081 /* Line 1806 of yacc.c */
6082 #line 1460 "parse.y"
6083  {
6084  /*%%%*/
6085  (yyval.node) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].node)));
6086  /*%
6087  $$ = dispatch1(return, $2);
6088  %*/
6089  }
6090  break;
6091 
6092  case 71:
6093 
6094 /* Line 1806 of yacc.c */
6095 #line 1468 "parse.y"
6096  {
6097  /*%%%*/
6098  (yyval.node) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].node)));
6099  /*%
6100  $$ = dispatch1(break, $2);
6101  %*/
6102  }
6103  break;
6104 
6105  case 72:
6106 
6107 /* Line 1806 of yacc.c */
6108 #line 1476 "parse.y"
6109  {
6110  /*%%%*/
6111  (yyval.node) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].node)));
6112  /*%
6113  $$ = dispatch1(next, $2);
6114  %*/
6115  }
6116  break;
6117 
6118  case 74:
6119 
6120 /* Line 1806 of yacc.c */
6121 #line 1487 "parse.y"
6122  {
6123  /*%%%*/
6124  (yyval.node) = (yyvsp[(2) - (3)].node);
6125  /*%
6126  $$ = dispatch1(mlhs_paren, $2);
6127  %*/
6128  }
6129  break;
6130 
6131  case 76:
6132 
6133 /* Line 1806 of yacc.c */
6134 #line 1498 "parse.y"
6135  {
6136  /*%%%*/
6137  (yyval.node) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].node)), 0);
6138  /*%
6139  $$ = dispatch1(mlhs_paren, $2);
6140  %*/
6141  }
6142  break;
6143 
6144  case 77:
6145 
6146 /* Line 1806 of yacc.c */
6147 #line 1508 "parse.y"
6148  {
6149  /*%%%*/
6150  (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0);
6151  /*%
6152  $$ = $1;
6153  %*/
6154  }
6155  break;
6156 
6157  case 78:
6158 
6159 /* Line 1806 of yacc.c */
6160 #line 1516 "parse.y"
6161  {
6162  /*%%%*/
6163  (yyval.node) = NEW_MASGN(list_append((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node)), 0);
6164  /*%
6165  $$ = mlhs_add($1, $2);
6166  %*/
6167  }
6168  break;
6169 
6170  case 79:
6171 
6172 /* Line 1806 of yacc.c */
6173 #line 1524 "parse.y"
6174  {
6175  /*%%%*/
6176  (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
6177  /*%
6178  $$ = mlhs_add_star($1, $3);
6179  %*/
6180  }
6181  break;
6182 
6183  case 80:
6184 
6185 /* Line 1806 of yacc.c */
6186 #line 1532 "parse.y"
6187  {
6188  /*%%%*/
6189  (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG((yyvsp[(3) - (5)].node),(yyvsp[(5) - (5)].node)));
6190  /*%
6191  $1 = mlhs_add_star($1, $3);
6192  $$ = mlhs_add($1, $5);
6193  %*/
6194  }
6195  break;
6196 
6197  case 81:
6198 
6199 /* Line 1806 of yacc.c */
6200 #line 1541 "parse.y"
6201  {
6202  /*%%%*/
6203  (yyval.node) = NEW_MASGN((yyvsp[(1) - (2)].node), -1);
6204  /*%
6205  $$ = mlhs_add_star($1, Qnil);
6206  %*/
6207  }
6208  break;
6209 
6210  case 82:
6211 
6212 /* Line 1806 of yacc.c */
6213 #line 1549 "parse.y"
6214  {
6215  /*%%%*/
6216  (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), NEW_POSTARG(-1, (yyvsp[(4) - (4)].node)));
6217  /*%
6218  $1 = mlhs_add_star($1, Qnil);
6219  $$ = mlhs_add($1, $4);
6220  %*/
6221  }
6222  break;
6223 
6224  case 83:
6225 
6226 /* Line 1806 of yacc.c */
6227 #line 1558 "parse.y"
6228  {
6229  /*%%%*/
6230  (yyval.node) = NEW_MASGN(0, (yyvsp[(2) - (2)].node));
6231  /*%
6232  $$ = mlhs_add_star(mlhs_new(), $2);
6233  %*/
6234  }
6235  break;
6236 
6237  case 84:
6238 
6239 /* Line 1806 of yacc.c */
6240 #line 1566 "parse.y"
6241  {
6242  /*%%%*/
6243  (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].node),(yyvsp[(4) - (4)].node)));
6244  /*%
6245  $2 = mlhs_add_star(mlhs_new(), $2);
6246  $$ = mlhs_add($2, $4);
6247  %*/
6248  }
6249  break;
6250 
6251  case 85:
6252 
6253 /* Line 1806 of yacc.c */
6254 #line 1575 "parse.y"
6255  {
6256  /*%%%*/
6257  (yyval.node) = NEW_MASGN(0, -1);
6258  /*%
6259  $$ = mlhs_add_star(mlhs_new(), Qnil);
6260  %*/
6261  }
6262  break;
6263 
6264  case 86:
6265 
6266 /* Line 1806 of yacc.c */
6267 #line 1583 "parse.y"
6268  {
6269  /*%%%*/
6270  (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node)));
6271  /*%
6272  $$ = mlhs_add_star(mlhs_new(), Qnil);
6273  $$ = mlhs_add($$, $3);
6274  %*/
6275  }
6276  break;
6277 
6278  case 88:
6279 
6280 /* Line 1806 of yacc.c */
6281 #line 1595 "parse.y"
6282  {
6283  /*%%%*/
6284  (yyval.node) = (yyvsp[(2) - (3)].node);
6285  /*%
6286  $$ = dispatch1(mlhs_paren, $2);
6287  %*/
6288  }
6289  break;
6290 
6291  case 89:
6292 
6293 /* Line 1806 of yacc.c */
6294 #line 1605 "parse.y"
6295  {
6296  /*%%%*/
6297  (yyval.node) = NEW_LIST((yyvsp[(1) - (2)].node));
6298  /*%
6299  $$ = mlhs_add(mlhs_new(), $1);
6300  %*/
6301  }
6302  break;
6303 
6304  case 90:
6305 
6306 /* Line 1806 of yacc.c */
6307 #line 1613 "parse.y"
6308  {
6309  /*%%%*/
6310  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
6311  /*%
6312  $$ = mlhs_add($1, $2);
6313  %*/
6314  }
6315  break;
6316 
6317  case 91:
6318 
6319 /* Line 1806 of yacc.c */
6320 #line 1623 "parse.y"
6321  {
6322  /*%%%*/
6323  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
6324  /*%
6325  $$ = mlhs_add(mlhs_new(), $1);
6326  %*/
6327  }
6328  break;
6329 
6330  case 92:
6331 
6332 /* Line 1806 of yacc.c */
6333 #line 1631 "parse.y"
6334  {
6335  /*%%%*/
6336  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
6337  /*%
6338  $$ = mlhs_add($1, $3);
6339  %*/
6340  }
6341  break;
6342 
6343  case 93:
6344 
6345 /* Line 1806 of yacc.c */
6346 #line 1641 "parse.y"
6347  {
6348  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6349  }
6350  break;
6351 
6352  case 94:
6353 
6354 /* Line 1806 of yacc.c */
6355 #line 1645 "parse.y"
6356  {
6357  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6358  }
6359  break;
6360 
6361  case 95:
6362 
6363 /* Line 1806 of yacc.c */
6364 #line 1649 "parse.y"
6365  {
6366  /*%%%*/
6367  (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
6368  /*%
6369  $$ = dispatch2(aref_field, $1, escape_Qundef($3));
6370  %*/
6371  }
6372  break;
6373 
6374  case 96:
6375 
6376 /* Line 1806 of yacc.c */
6377 #line 1657 "parse.y"
6378  {
6379  /*%%%*/
6380  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6381  /*%
6382  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6383  %*/
6384  }
6385  break;
6386 
6387  case 97:
6388 
6389 /* Line 1806 of yacc.c */
6390 #line 1665 "parse.y"
6391  {
6392  /*%%%*/
6393  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6394  /*%
6395  $$ = dispatch2(const_path_field, $1, $3);
6396  %*/
6397  }
6398  break;
6399 
6400  case 98:
6401 
6402 /* Line 1806 of yacc.c */
6403 #line 1673 "parse.y"
6404  {
6405  /*%%%*/
6406  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6407  /*%
6408  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6409  %*/
6410  }
6411  break;
6412 
6413  case 99:
6414 
6415 /* Line 1806 of yacc.c */
6416 #line 1681 "parse.y"
6417  {
6418  /*%%%*/
6419  if (in_def || in_single)
6420  yyerror("dynamic constant assignment");
6421  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)));
6422  /*%
6423  if (in_def || in_single)
6424  yyerror("dynamic constant assignment");
6425  $$ = dispatch2(const_path_field, $1, $3);
6426  %*/
6427  }
6428  break;
6429 
6430  case 100:
6431 
6432 /* Line 1806 of yacc.c */
6433 #line 1693 "parse.y"
6434  {
6435  /*%%%*/
6436  if (in_def || in_single)
6437  yyerror("dynamic constant assignment");
6438  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id)));
6439  /*%
6440  $$ = dispatch1(top_const_field, $2);
6441  %*/
6442  }
6443  break;
6444 
6445  case 101:
6446 
6447 /* Line 1806 of yacc.c */
6448 #line 1703 "parse.y"
6449  {
6450  /*%%%*/
6451  rb_backref_error((yyvsp[(1) - (1)].node));
6452  (yyval.node) = NEW_BEGIN(0);
6453  /*%
6454  $$ = dispatch1(var_field, $1);
6455  $$ = dispatch1(assign_error, $$);
6456  %*/
6457  }
6458  break;
6459 
6460  case 102:
6461 
6462 /* Line 1806 of yacc.c */
6463 #line 1715 "parse.y"
6464  {
6465  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6466  /*%%%*/
6467  if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0);
6468  /*%
6469  $$ = dispatch1(var_field, $$);
6470  %*/
6471  }
6472  break;
6473 
6474  case 103:
6475 
6476 /* Line 1806 of yacc.c */
6477 #line 1724 "parse.y"
6478  {
6479  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6480  /*%%%*/
6481  if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0);
6482  /*%
6483  $$ = dispatch1(var_field, $$);
6484  %*/
6485  }
6486  break;
6487 
6488  case 104:
6489 
6490 /* Line 1806 of yacc.c */
6491 #line 1733 "parse.y"
6492  {
6493  /*%%%*/
6494  (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
6495  /*%
6496  $$ = dispatch2(aref_field, $1, escape_Qundef($3));
6497  %*/
6498  }
6499  break;
6500 
6501  case 105:
6502 
6503 /* Line 1806 of yacc.c */
6504 #line 1741 "parse.y"
6505  {
6506  /*%%%*/
6507  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6508  /*%
6509  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6510  %*/
6511  }
6512  break;
6513 
6514  case 106:
6515 
6516 /* Line 1806 of yacc.c */
6517 #line 1749 "parse.y"
6518  {
6519  /*%%%*/
6520  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6521  /*%
6522  $$ = dispatch3(field, $1, ripper_intern("::"), $3);
6523  %*/
6524  }
6525  break;
6526 
6527  case 107:
6528 
6529 /* Line 1806 of yacc.c */
6530 #line 1757 "parse.y"
6531  {
6532  /*%%%*/
6533  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6534  /*%
6535  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6536  %*/
6537  }
6538  break;
6539 
6540  case 108:
6541 
6542 /* Line 1806 of yacc.c */
6543 #line 1765 "parse.y"
6544  {
6545  /*%%%*/
6546  if (in_def || in_single)
6547  yyerror("dynamic constant assignment");
6548  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)));
6549  /*%
6550  $$ = dispatch2(const_path_field, $1, $3);
6551  if (in_def || in_single) {
6552  $$ = dispatch1(assign_error, $$);
6553  }
6554  %*/
6555  }
6556  break;
6557 
6558  case 109:
6559 
6560 /* Line 1806 of yacc.c */
6561 #line 1778 "parse.y"
6562  {
6563  /*%%%*/
6564  if (in_def || in_single)
6565  yyerror("dynamic constant assignment");
6566  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id)));
6567  /*%
6568  $$ = dispatch1(top_const_field, $2);
6569  if (in_def || in_single) {
6570  $$ = dispatch1(assign_error, $$);
6571  }
6572  %*/
6573  }
6574  break;
6575 
6576  case 110:
6577 
6578 /* Line 1806 of yacc.c */
6579 #line 1791 "parse.y"
6580  {
6581  /*%%%*/
6582  rb_backref_error((yyvsp[(1) - (1)].node));
6583  (yyval.node) = NEW_BEGIN(0);
6584  /*%
6585  $$ = dispatch1(assign_error, $1);
6586  %*/
6587  }
6588  break;
6589 
6590  case 111:
6591 
6592 /* Line 1806 of yacc.c */
6593 #line 1802 "parse.y"
6594  {
6595  /*%%%*/
6596  yyerror("class/module name must be CONSTANT");
6597  /*%
6598  $$ = dispatch1(class_name_error, $1);
6599  %*/
6600  }
6601  break;
6602 
6603  case 113:
6604 
6605 /* Line 1806 of yacc.c */
6606 #line 1813 "parse.y"
6607  {
6608  /*%%%*/
6609  (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id));
6610  /*%
6611  $$ = dispatch1(top_const_ref, $2);
6612  %*/
6613  }
6614  break;
6615 
6616  case 114:
6617 
6618 /* Line 1806 of yacc.c */
6619 #line 1821 "parse.y"
6620  {
6621  /*%%%*/
6622  (yyval.node) = NEW_COLON2(0, (yyval.node));
6623  /*%
6624  $$ = dispatch1(const_ref, $1);
6625  %*/
6626  }
6627  break;
6628 
6629  case 115:
6630 
6631 /* Line 1806 of yacc.c */
6632 #line 1829 "parse.y"
6633  {
6634  /*%%%*/
6635  (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6636  /*%
6637  $$ = dispatch2(const_path_ref, $1, $3);
6638  %*/
6639  }
6640  break;
6641 
6642  case 119:
6643 
6644 /* Line 1806 of yacc.c */
6645 #line 1842 "parse.y"
6646  {
6647  lex_state = EXPR_ENDFN;
6648  (yyval.id) = (yyvsp[(1) - (1)].id);
6649  }
6650  break;
6651 
6652  case 120:
6653 
6654 /* Line 1806 of yacc.c */
6655 #line 1847 "parse.y"
6656  {
6657  lex_state = EXPR_ENDFN;
6658  /*%%%*/
6659  (yyval.id) = (yyvsp[(1) - (1)].id);
6660  /*%
6661  $$ = $1;
6662  %*/
6663  }
6664  break;
6665 
6666  case 123:
6667 
6668 /* Line 1806 of yacc.c */
6669 #line 1862 "parse.y"
6670  {
6671  /*%%%*/
6672  (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id)));
6673  /*%
6674  $$ = dispatch1(symbol_literal, $1);
6675  %*/
6676  }
6677  break;
6678 
6679  case 125:
6680 
6681 /* Line 1806 of yacc.c */
6682 #line 1873 "parse.y"
6683  {
6684  /*%%%*/
6685  (yyval.node) = NEW_UNDEF((yyvsp[(1) - (1)].node));
6686  /*%
6687  $$ = rb_ary_new3(1, $1);
6688  %*/
6689  }
6690  break;
6691 
6692  case 126:
6693 
6694 /* Line 1806 of yacc.c */
6695 #line 1880 "parse.y"
6696  {lex_state = EXPR_FNAME;}
6697  break;
6698 
6699  case 127:
6700 
6701 /* Line 1806 of yacc.c */
6702 #line 1881 "parse.y"
6703  {
6704  /*%%%*/
6705  (yyval.node) = block_append((yyvsp[(1) - (4)].node), NEW_UNDEF((yyvsp[(4) - (4)].node)));
6706  /*%
6707  rb_ary_push($1, $4);
6708  %*/
6709  }
6710  break;
6711 
6712  case 128:
6713 
6714 /* Line 1806 of yacc.c */
6715 #line 1890 "parse.y"
6716  { ifndef_ripper((yyval.id) = '|'); }
6717  break;
6718 
6719  case 129:
6720 
6721 /* Line 1806 of yacc.c */
6722 #line 1891 "parse.y"
6723  { ifndef_ripper((yyval.id) = '^'); }
6724  break;
6725 
6726  case 130:
6727 
6728 /* Line 1806 of yacc.c */
6729 #line 1892 "parse.y"
6730  { ifndef_ripper((yyval.id) = '&'); }
6731  break;
6732 
6733  case 131:
6734 
6735 /* Line 1806 of yacc.c */
6736 #line 1893 "parse.y"
6737  { ifndef_ripper((yyval.id) = tCMP); }
6738  break;
6739 
6740  case 132:
6741 
6742 /* Line 1806 of yacc.c */
6743 #line 1894 "parse.y"
6744  { ifndef_ripper((yyval.id) = tEQ); }
6745  break;
6746 
6747  case 133:
6748 
6749 /* Line 1806 of yacc.c */
6750 #line 1895 "parse.y"
6751  { ifndef_ripper((yyval.id) = tEQQ); }
6752  break;
6753 
6754  case 134:
6755 
6756 /* Line 1806 of yacc.c */
6757 #line 1896 "parse.y"
6758  { ifndef_ripper((yyval.id) = tMATCH); }
6759  break;
6760 
6761  case 135:
6762 
6763 /* Line 1806 of yacc.c */
6764 #line 1897 "parse.y"
6765  { ifndef_ripper((yyval.id) = tNMATCH); }
6766  break;
6767 
6768  case 136:
6769 
6770 /* Line 1806 of yacc.c */
6771 #line 1898 "parse.y"
6772  { ifndef_ripper((yyval.id) = '>'); }
6773  break;
6774 
6775  case 137:
6776 
6777 /* Line 1806 of yacc.c */
6778 #line 1899 "parse.y"
6779  { ifndef_ripper((yyval.id) = tGEQ); }
6780  break;
6781 
6782  case 138:
6783 
6784 /* Line 1806 of yacc.c */
6785 #line 1900 "parse.y"
6786  { ifndef_ripper((yyval.id) = '<'); }
6787  break;
6788 
6789  case 139:
6790 
6791 /* Line 1806 of yacc.c */
6792 #line 1901 "parse.y"
6793  { ifndef_ripper((yyval.id) = tLEQ); }
6794  break;
6795 
6796  case 140:
6797 
6798 /* Line 1806 of yacc.c */
6799 #line 1902 "parse.y"
6800  { ifndef_ripper((yyval.id) = tNEQ); }
6801  break;
6802 
6803  case 141:
6804 
6805 /* Line 1806 of yacc.c */
6806 #line 1903 "parse.y"
6807  { ifndef_ripper((yyval.id) = tLSHFT); }
6808  break;
6809 
6810  case 142:
6811 
6812 /* Line 1806 of yacc.c */
6813 #line 1904 "parse.y"
6814  { ifndef_ripper((yyval.id) = tRSHFT); }
6815  break;
6816 
6817  case 143:
6818 
6819 /* Line 1806 of yacc.c */
6820 #line 1905 "parse.y"
6821  { ifndef_ripper((yyval.id) = '+'); }
6822  break;
6823 
6824  case 144:
6825 
6826 /* Line 1806 of yacc.c */
6827 #line 1906 "parse.y"
6828  { ifndef_ripper((yyval.id) = '-'); }
6829  break;
6830 
6831  case 145:
6832 
6833 /* Line 1806 of yacc.c */
6834 #line 1907 "parse.y"
6835  { ifndef_ripper((yyval.id) = '*'); }
6836  break;
6837 
6838  case 146:
6839 
6840 /* Line 1806 of yacc.c */
6841 #line 1908 "parse.y"
6842  { ifndef_ripper((yyval.id) = '*'); }
6843  break;
6844 
6845  case 147:
6846 
6847 /* Line 1806 of yacc.c */
6848 #line 1909 "parse.y"
6849  { ifndef_ripper((yyval.id) = '/'); }
6850  break;
6851 
6852  case 148:
6853 
6854 /* Line 1806 of yacc.c */
6855 #line 1910 "parse.y"
6856  { ifndef_ripper((yyval.id) = '%'); }
6857  break;
6858 
6859  case 149:
6860 
6861 /* Line 1806 of yacc.c */
6862 #line 1911 "parse.y"
6863  { ifndef_ripper((yyval.id) = tPOW); }
6864  break;
6865 
6866  case 150:
6867 
6868 /* Line 1806 of yacc.c */
6869 #line 1912 "parse.y"
6870  { ifndef_ripper((yyval.id) = tDSTAR); }
6871  break;
6872 
6873  case 151:
6874 
6875 /* Line 1806 of yacc.c */
6876 #line 1913 "parse.y"
6877  { ifndef_ripper((yyval.id) = '!'); }
6878  break;
6879 
6880  case 152:
6881 
6882 /* Line 1806 of yacc.c */
6883 #line 1914 "parse.y"
6884  { ifndef_ripper((yyval.id) = '~'); }
6885  break;
6886 
6887  case 153:
6888 
6889 /* Line 1806 of yacc.c */
6890 #line 1915 "parse.y"
6891  { ifndef_ripper((yyval.id) = tUPLUS); }
6892  break;
6893 
6894  case 154:
6895 
6896 /* Line 1806 of yacc.c */
6897 #line 1916 "parse.y"
6898  { ifndef_ripper((yyval.id) = tUMINUS); }
6899  break;
6900 
6901  case 155:
6902 
6903 /* Line 1806 of yacc.c */
6904 #line 1917 "parse.y"
6905  { ifndef_ripper((yyval.id) = tAREF); }
6906  break;
6907 
6908  case 156:
6909 
6910 /* Line 1806 of yacc.c */
6911 #line 1918 "parse.y"
6912  { ifndef_ripper((yyval.id) = tASET); }
6913  break;
6914 
6915  case 157:
6916 
6917 /* Line 1806 of yacc.c */
6918 #line 1919 "parse.y"
6919  { ifndef_ripper((yyval.id) = '`'); }
6920  break;
6921 
6922  case 199:
6923 
6924 /* Line 1806 of yacc.c */
6925 #line 1937 "parse.y"
6926  {
6927  /*%%%*/
6928  value_expr((yyvsp[(3) - (3)].node));
6929  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
6930  /*%
6931  $$ = dispatch2(assign, $1, $3);
6932  %*/
6933  }
6934  break;
6935 
6936  case 200:
6937 
6938 /* Line 1806 of yacc.c */
6939 #line 1946 "parse.y"
6940  {
6941  /*%%%*/
6942  value_expr((yyvsp[(3) - (5)].node));
6943  (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0);
6944  (yyval.node) = node_assign((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node));
6945  /*%
6946  $$ = dispatch2(assign, $1, dispatch2(rescue_mod, $3, $5));
6947  %*/
6948  }
6949  break;
6950 
6951  case 201:
6952 
6953 /* Line 1806 of yacc.c */
6954 #line 1956 "parse.y"
6955  {
6956  value_expr((yyvsp[(3) - (3)].node));
6957  (yyval.node) = new_op_assign((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].node));
6958  }
6959  break;
6960 
6961  case 202:
6962 
6963 /* Line 1806 of yacc.c */
6964 #line 1961 "parse.y"
6965  {
6966  /*%%%*/
6967  value_expr((yyvsp[(3) - (5)].node));
6968  (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0);
6969  /*%
6970  $3 = dispatch2(rescue_mod, $3, $5);
6971  %*/
6972  (yyval.node) = new_op_assign((yyvsp[(1) - (5)].node), (yyvsp[(2) - (5)].id), (yyvsp[(3) - (5)].node));
6973  }
6974  break;
6975 
6976  case 203:
6977 
6978 /* Line 1806 of yacc.c */
6979 #line 1971 "parse.y"
6980  {
6981  /*%%%*/
6982  NODE *args;
6983 
6984  value_expr((yyvsp[(6) - (6)].node));
6985  if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY();
6986  if (nd_type((yyvsp[(3) - (6)].node)) == NODE_BLOCK_PASS) {
6987  args = NEW_ARGSCAT((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
6988  }
6989  else {
6990  args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
6991  }
6992  if ((yyvsp[(5) - (6)].id) == tOROP) {
6993  (yyvsp[(5) - (6)].id) = 0;
6994  }
6995  else if ((yyvsp[(5) - (6)].id) == tANDOP) {
6996  (yyvsp[(5) - (6)].id) = 1;
6997  }
6998  (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args);
6999  fixpos((yyval.node), (yyvsp[(1) - (6)].node));
7000  /*%
7001  $1 = dispatch2(aref_field, $1, escape_Qundef($3));
7002  $$ = dispatch3(opassign, $1, $5, $6);
7003  %*/
7004  }
7005  break;
7006 
7007  case 204:
7008 
7009 /* Line 1806 of yacc.c */
7010 #line 1997 "parse.y"
7011  {
7012  value_expr((yyvsp[(5) - (5)].node));
7013  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
7014  }
7015  break;
7016 
7017  case 205:
7018 
7019 /* Line 1806 of yacc.c */
7020 #line 2002 "parse.y"
7021  {
7022  value_expr((yyvsp[(5) - (5)].node));
7023  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
7024  }
7025  break;
7026 
7027  case 206:
7028 
7029 /* Line 1806 of yacc.c */
7030 #line 2007 "parse.y"
7031  {
7032  value_expr((yyvsp[(5) - (5)].node));
7033  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_intern("::"), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
7034  }
7035  break;
7036 
7037  case 207:
7038 
7039 /* Line 1806 of yacc.c */
7040 #line 2012 "parse.y"
7041  {
7042  /*%%%*/
7043  (yyval.node) = NEW_COLON2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id));
7044  (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
7045  /*%
7046  $$ = dispatch2(const_path_field, $1, $3);
7047  $$ = dispatch3(opassign, $$, $4, $5);
7048  %*/
7049  }
7050  break;
7051 
7052  case 208:
7053 
7054 /* Line 1806 of yacc.c */
7055 #line 2022 "parse.y"
7056  {
7057  /*%%%*/
7058  (yyval.node) = NEW_COLON3((yyvsp[(2) - (4)].id));
7059  (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
7060  /*%
7061  $$ = dispatch1(top_const_field, $2);
7062  $$ = dispatch3(opassign, $$, $3, $4);
7063  %*/
7064  }
7065  break;
7066 
7067  case 209:
7068 
7069 /* Line 1806 of yacc.c */
7070 #line 2032 "parse.y"
7071  {
7072  /*%%%*/
7073  rb_backref_error((yyvsp[(1) - (3)].node));
7074  (yyval.node) = NEW_BEGIN(0);
7075  /*%
7076  $$ = dispatch1(var_field, $1);
7077  $$ = dispatch3(opassign, $$, $2, $3);
7078  $$ = dispatch1(assign_error, $$);
7079  %*/
7080  }
7081  break;
7082 
7083  case 210:
7084 
7085 /* Line 1806 of yacc.c */
7086 #line 2043 "parse.y"
7087  {
7088  /*%%%*/
7089  value_expr((yyvsp[(1) - (3)].node));
7090  value_expr((yyvsp[(3) - (3)].node));
7091  (yyval.node) = NEW_DOT2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7092  if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) &&
7093  nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) {
7095  }
7096  /*%
7097  $$ = dispatch2(dot2, $1, $3);
7098  %*/
7099  }
7100  break;
7101 
7102  case 211:
7103 
7104 /* Line 1806 of yacc.c */
7105 #line 2057 "parse.y"
7106  {
7107  /*%%%*/
7108  value_expr((yyvsp[(1) - (3)].node));
7109  value_expr((yyvsp[(3) - (3)].node));
7110  (yyval.node) = NEW_DOT3((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7111  if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) &&
7112  nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) {
7114  }
7115  /*%
7116  $$ = dispatch2(dot3, $1, $3);
7117  %*/
7118  }
7119  break;
7120 
7121  case 212:
7122 
7123 /* Line 1806 of yacc.c */
7124 #line 2071 "parse.y"
7125  {
7126  /*%%%*/
7127  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '+', (yyvsp[(3) - (3)].node));
7128  /*%
7129  $$ = dispatch3(binary, $1, ID2SYM('+'), $3);
7130  %*/
7131  }
7132  break;
7133 
7134  case 213:
7135 
7136 /* Line 1806 of yacc.c */
7137 #line 2079 "parse.y"
7138  {
7139  /*%%%*/
7140  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '-', (yyvsp[(3) - (3)].node));
7141  /*%
7142  $$ = dispatch3(binary, $1, ID2SYM('-'), $3);
7143  %*/
7144  }
7145  break;
7146 
7147  case 214:
7148 
7149 /* Line 1806 of yacc.c */
7150 #line 2087 "parse.y"
7151  {
7152  /*%%%*/
7153  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '*', (yyvsp[(3) - (3)].node));
7154  /*%
7155  $$ = dispatch3(binary, $1, ID2SYM('*'), $3);
7156  %*/
7157  }
7158  break;
7159 
7160  case 215:
7161 
7162 /* Line 1806 of yacc.c */
7163 #line 2095 "parse.y"
7164  {
7165  /*%%%*/
7166  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '/', (yyvsp[(3) - (3)].node));
7167  /*%
7168  $$ = dispatch3(binary, $1, ID2SYM('/'), $3);
7169  %*/
7170  }
7171  break;
7172 
7173  case 216:
7174 
7175 /* Line 1806 of yacc.c */
7176 #line 2103 "parse.y"
7177  {
7178  /*%%%*/
7179  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '%', (yyvsp[(3) - (3)].node));
7180  /*%
7181  $$ = dispatch3(binary, $1, ID2SYM('%'), $3);
7182  %*/
7183  }
7184  break;
7185 
7186  case 217:
7187 
7188 /* Line 1806 of yacc.c */
7189 #line 2111 "parse.y"
7190  {
7191  /*%%%*/
7192  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tPOW, (yyvsp[(3) - (3)].node));
7193  /*%
7194  $$ = dispatch3(binary, $1, ripper_intern("**"), $3);
7195  %*/
7196  }
7197  break;
7198 
7199  case 218:
7200 
7201 /* Line 1806 of yacc.c */
7202 #line 2119 "parse.y"
7203  {
7204  /*%%%*/
7205  (yyval.node) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].node), tPOW, (yyvsp[(4) - (4)].node)), tUMINUS, 0);
7206  /*%
7207  $$ = dispatch3(binary, $2, ripper_intern("**"), $4);
7208  $$ = dispatch2(unary, ripper_intern("-@"), $$);
7209  %*/
7210  }
7211  break;
7212 
7213  case 219:
7214 
7215 /* Line 1806 of yacc.c */
7216 #line 2128 "parse.y"
7217  {
7218  /*%%%*/
7219  (yyval.node) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].node), tPOW, (yyvsp[(4) - (4)].node)), tUMINUS, 0);
7220  /*%
7221  $$ = dispatch3(binary, $2, ripper_intern("**"), $4);
7222  $$ = dispatch2(unary, ripper_intern("-@"), $$);
7223  %*/
7224  }
7225  break;
7226 
7227  case 220:
7228 
7229 /* Line 1806 of yacc.c */
7230 #line 2137 "parse.y"
7231  {
7232  /*%%%*/
7233  (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUPLUS);
7234  /*%
7235  $$ = dispatch2(unary, ripper_intern("+@"), $2);
7236  %*/
7237  }
7238  break;
7239 
7240  case 221:
7241 
7242 /* Line 1806 of yacc.c */
7243 #line 2145 "parse.y"
7244  {
7245  /*%%%*/
7246  (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUMINUS);
7247  /*%
7248  $$ = dispatch2(unary, ripper_intern("-@"), $2);
7249  %*/
7250  }
7251  break;
7252 
7253  case 222:
7254 
7255 /* Line 1806 of yacc.c */
7256 #line 2153 "parse.y"
7257  {
7258  /*%%%*/
7259  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '|', (yyvsp[(3) - (3)].node));
7260  /*%
7261  $$ = dispatch3(binary, $1, ID2SYM('|'), $3);
7262  %*/
7263  }
7264  break;
7265 
7266  case 223:
7267 
7268 /* Line 1806 of yacc.c */
7269 #line 2161 "parse.y"
7270  {
7271  /*%%%*/
7272  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '^', (yyvsp[(3) - (3)].node));
7273  /*%
7274  $$ = dispatch3(binary, $1, ID2SYM('^'), $3);
7275  %*/
7276  }
7277  break;
7278 
7279  case 224:
7280 
7281 /* Line 1806 of yacc.c */
7282 #line 2169 "parse.y"
7283  {
7284  /*%%%*/
7285  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '&', (yyvsp[(3) - (3)].node));
7286  /*%
7287  $$ = dispatch3(binary, $1, ID2SYM('&'), $3);
7288  %*/
7289  }
7290  break;
7291 
7292  case 225:
7293 
7294 /* Line 1806 of yacc.c */
7295 #line 2177 "parse.y"
7296  {
7297  /*%%%*/
7298  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tCMP, (yyvsp[(3) - (3)].node));
7299  /*%
7300  $$ = dispatch3(binary, $1, ripper_intern("<=>"), $3);
7301  %*/
7302  }
7303  break;
7304 
7305  case 226:
7306 
7307 /* Line 1806 of yacc.c */
7308 #line 2185 "parse.y"
7309  {
7310  /*%%%*/
7311  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '>', (yyvsp[(3) - (3)].node));
7312  /*%
7313  $$ = dispatch3(binary, $1, ID2SYM('>'), $3);
7314  %*/
7315  }
7316  break;
7317 
7318  case 227:
7319 
7320 /* Line 1806 of yacc.c */
7321 #line 2193 "parse.y"
7322  {
7323  /*%%%*/
7324  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tGEQ, (yyvsp[(3) - (3)].node));
7325  /*%
7326  $$ = dispatch3(binary, $1, ripper_intern(">="), $3);
7327  %*/
7328  }
7329  break;
7330 
7331  case 228:
7332 
7333 /* Line 1806 of yacc.c */
7334 #line 2201 "parse.y"
7335  {
7336  /*%%%*/
7337  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '<', (yyvsp[(3) - (3)].node));
7338  /*%
7339  $$ = dispatch3(binary, $1, ID2SYM('<'), $3);
7340  %*/
7341  }
7342  break;
7343 
7344  case 229:
7345 
7346 /* Line 1806 of yacc.c */
7347 #line 2209 "parse.y"
7348  {
7349  /*%%%*/
7350  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLEQ, (yyvsp[(3) - (3)].node));
7351  /*%
7352  $$ = dispatch3(binary, $1, ripper_intern("<="), $3);
7353  %*/
7354  }
7355  break;
7356 
7357  case 230:
7358 
7359 /* Line 1806 of yacc.c */
7360 #line 2217 "parse.y"
7361  {
7362  /*%%%*/
7363  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQ, (yyvsp[(3) - (3)].node));
7364  /*%
7365  $$ = dispatch3(binary, $1, ripper_intern("=="), $3);
7366  %*/
7367  }
7368  break;
7369 
7370  case 231:
7371 
7372 /* Line 1806 of yacc.c */
7373 #line 2225 "parse.y"
7374  {
7375  /*%%%*/
7376  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQQ, (yyvsp[(3) - (3)].node));
7377  /*%
7378  $$ = dispatch3(binary, $1, ripper_intern("==="), $3);
7379  %*/
7380  }
7381  break;
7382 
7383  case 232:
7384 
7385 /* Line 1806 of yacc.c */
7386 #line 2233 "parse.y"
7387  {
7388  /*%%%*/
7389  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNEQ, (yyvsp[(3) - (3)].node));
7390  /*%
7391  $$ = dispatch3(binary, $1, ripper_intern("!="), $3);
7392  %*/
7393  }
7394  break;
7395 
7396  case 233:
7397 
7398 /* Line 1806 of yacc.c */
7399 #line 2241 "parse.y"
7400  {
7401  /*%%%*/
7402  (yyval.node) = match_op((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7403  if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].node)->nd_lit, T_REGEXP)) {
7404  (yyval.node) = reg_named_capture_assign((yyvsp[(1) - (3)].node)->nd_lit, (yyval.node));
7405  }
7406  /*%
7407  $$ = dispatch3(binary, $1, ripper_intern("=~"), $3);
7408  %*/
7409  }
7410  break;
7411 
7412  case 234:
7413 
7414 /* Line 1806 of yacc.c */
7415 #line 2252 "parse.y"
7416  {
7417  /*%%%*/
7418  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNMATCH, (yyvsp[(3) - (3)].node));
7419  /*%
7420  $$ = dispatch3(binary, $1, ripper_intern("!~"), $3);
7421  %*/
7422  }
7423  break;
7424 
7425  case 235:
7426 
7427 /* Line 1806 of yacc.c */
7428 #line 2260 "parse.y"
7429  {
7430  /*%%%*/
7431  (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!');
7432  /*%
7433  $$ = dispatch2(unary, ID2SYM('!'), $2);
7434  %*/
7435  }
7436  break;
7437 
7438  case 236:
7439 
7440 /* Line 1806 of yacc.c */
7441 #line 2268 "parse.y"
7442  {
7443  /*%%%*/
7444  (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), '~');
7445  /*%
7446  $$ = dispatch2(unary, ID2SYM('~'), $2);
7447  %*/
7448  }
7449  break;
7450 
7451  case 237:
7452 
7453 /* Line 1806 of yacc.c */
7454 #line 2276 "parse.y"
7455  {
7456  /*%%%*/
7457  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLSHFT, (yyvsp[(3) - (3)].node));
7458  /*%
7459  $$ = dispatch3(binary, $1, ripper_intern("<<"), $3);
7460  %*/
7461  }
7462  break;
7463 
7464  case 238:
7465 
7466 /* Line 1806 of yacc.c */
7467 #line 2284 "parse.y"
7468  {
7469  /*%%%*/
7470  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tRSHFT, (yyvsp[(3) - (3)].node));
7471  /*%
7472  $$ = dispatch3(binary, $1, ripper_intern(">>"), $3);
7473  %*/
7474  }
7475  break;
7476 
7477  case 239:
7478 
7479 /* Line 1806 of yacc.c */
7480 #line 2292 "parse.y"
7481  {
7482  /*%%%*/
7483  (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7484  /*%
7485  $$ = dispatch3(binary, $1, ripper_intern("&&"), $3);
7486  %*/
7487  }
7488  break;
7489 
7490  case 240:
7491 
7492 /* Line 1806 of yacc.c */
7493 #line 2300 "parse.y"
7494  {
7495  /*%%%*/
7496  (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7497  /*%
7498  $$ = dispatch3(binary, $1, ripper_intern("||"), $3);
7499  %*/
7500  }
7501  break;
7502 
7503  case 241:
7504 
7505 /* Line 1806 of yacc.c */
7506 #line 2307 "parse.y"
7507  {in_defined = 1;}
7508  break;
7509 
7510  case 242:
7511 
7512 /* Line 1806 of yacc.c */
7513 #line 2308 "parse.y"
7514  {
7515  /*%%%*/
7516  in_defined = 0;
7517  (yyval.node) = NEW_DEFINED((yyvsp[(4) - (4)].node));
7518  /*%
7519  in_defined = 0;
7520  $$ = dispatch1(defined, $4);
7521  %*/
7522  }
7523  break;
7524 
7525  case 243:
7526 
7527 /* Line 1806 of yacc.c */
7528 #line 2318 "parse.y"
7529  {
7530  /*%%%*/
7531  value_expr((yyvsp[(1) - (6)].node));
7532  (yyval.node) = NEW_IF(cond((yyvsp[(1) - (6)].node)), (yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
7533  fixpos((yyval.node), (yyvsp[(1) - (6)].node));
7534  /*%
7535  $$ = dispatch3(ifop, $1, $3, $6);
7536  %*/
7537  }
7538  break;
7539 
7540  case 244:
7541 
7542 /* Line 1806 of yacc.c */
7543 #line 2328 "parse.y"
7544  {
7545  (yyval.node) = (yyvsp[(1) - (1)].node);
7546  }
7547  break;
7548 
7549  case 245:
7550 
7551 /* Line 1806 of yacc.c */
7552 #line 2334 "parse.y"
7553  {
7554  /*%%%*/
7555  value_expr((yyvsp[(1) - (1)].node));
7556  (yyval.node) = (yyvsp[(1) - (1)].node);
7557  if (!(yyval.node)) (yyval.node) = NEW_NIL();
7558  /*%
7559  $$ = $1;
7560  %*/
7561  }
7562  break;
7563 
7564  case 247:
7565 
7566 /* Line 1806 of yacc.c */
7567 #line 2347 "parse.y"
7568  {
7569  (yyval.node) = (yyvsp[(1) - (2)].node);
7570  }
7571  break;
7572 
7573  case 248:
7574 
7575 /* Line 1806 of yacc.c */
7576 #line 2351 "parse.y"
7577  {
7578  /*%%%*/
7579  (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
7580  /*%
7581  $$ = arg_add_assocs($1, $3);
7582  %*/
7583  }
7584  break;
7585 
7586  case 249:
7587 
7588 /* Line 1806 of yacc.c */
7589 #line 2359 "parse.y"
7590  {
7591  /*%%%*/
7592  (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
7593  /*%
7594  $$ = arg_add_assocs(arg_new(), $1);
7595  %*/
7596  }
7597  break;
7598 
7599  case 250:
7600 
7601 /* Line 1806 of yacc.c */
7602 #line 2369 "parse.y"
7603  {
7604  /*%%%*/
7605  (yyval.node) = (yyvsp[(2) - (3)].node);
7606  /*%
7607  $$ = dispatch1(arg_paren, escape_Qundef($2));
7608  %*/
7609  }
7610  break;
7611 
7612  case 255:
7613 
7614 /* Line 1806 of yacc.c */
7615 #line 2385 "parse.y"
7616  {
7617  (yyval.node) = (yyvsp[(1) - (2)].node);
7618  }
7619  break;
7620 
7621  case 256:
7622 
7623 /* Line 1806 of yacc.c */
7624 #line 2389 "parse.y"
7625  {
7626  /*%%%*/
7627  (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
7628  /*%
7629  $$ = arg_add_assocs($1, $3);
7630  %*/
7631  }
7632  break;
7633 
7634  case 257:
7635 
7636 /* Line 1806 of yacc.c */
7637 #line 2397 "parse.y"
7638  {
7639  /*%%%*/
7640  (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
7641  /*%
7642  $$ = arg_add_assocs(arg_new(), $1);
7643  %*/
7644  }
7645  break;
7646 
7647  case 258:
7648 
7649 /* Line 1806 of yacc.c */
7650 #line 2407 "parse.y"
7651  {
7652  /*%%%*/
7653  value_expr((yyvsp[(1) - (1)].node));
7654  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
7655  /*%
7656  $$ = arg_add(arg_new(), $1);
7657  %*/
7658  }
7659  break;
7660 
7661  case 259:
7662 
7663 /* Line 1806 of yacc.c */
7664 #line 2416 "parse.y"
7665  {
7666  /*%%%*/
7667  (yyval.node) = arg_blk_pass((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
7668  /*%
7669  $$ = arg_add_optblock($1, $2);
7670  %*/
7671  }
7672  break;
7673 
7674  case 260:
7675 
7676 /* Line 1806 of yacc.c */
7677 #line 2424 "parse.y"
7678  {
7679  /*%%%*/
7680  (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
7681  (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(2) - (2)].node));
7682  /*%
7683  $$ = arg_add_assocs(arg_new(), $1);
7684  $$ = arg_add_optblock($$, $2);
7685  %*/
7686  }
7687  break;
7688 
7689  case 261:
7690 
7691 /* Line 1806 of yacc.c */
7692 #line 2434 "parse.y"
7693  {
7694  /*%%%*/
7695  (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
7696  (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(4) - (4)].node));
7697  /*%
7698  $$ = arg_add_optblock(arg_add_assocs($1, $3), $4);
7699  %*/
7700  }
7701  break;
7702 
7703  case 263:
7704 
7705 /* Line 1806 of yacc.c */
7706 #line 2451 "parse.y"
7707  {
7708  (yyval.val) = cmdarg_stack;
7709  CMDARG_PUSH(1);
7710  }
7711  break;
7712 
7713  case 264:
7714 
7715 /* Line 1806 of yacc.c */
7716 #line 2456 "parse.y"
7717  {
7718  /* CMDARG_POP() */
7719  cmdarg_stack = (yyvsp[(1) - (2)].val);
7720  (yyval.node) = (yyvsp[(2) - (2)].node);
7721  }
7722  break;
7723 
7724  case 265:
7725 
7726 /* Line 1806 of yacc.c */
7727 #line 2464 "parse.y"
7728  {
7729  /*%%%*/
7730  (yyval.node) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].node));
7731  /*%
7732  $$ = $2;
7733  %*/
7734  }
7735  break;
7736 
7737  case 266:
7738 
7739 /* Line 1806 of yacc.c */
7740 #line 2474 "parse.y"
7741  {
7742  (yyval.node) = (yyvsp[(2) - (2)].node);
7743  }
7744  break;
7745 
7746  case 267:
7747 
7748 /* Line 1806 of yacc.c */
7749 #line 2478 "parse.y"
7750  {
7751  (yyval.node) = 0;
7752  }
7753  break;
7754 
7755  case 268:
7756 
7757 /* Line 1806 of yacc.c */
7758 #line 2484 "parse.y"
7759  {
7760  /*%%%*/
7761  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
7762  /*%
7763  $$ = arg_add(arg_new(), $1);
7764  %*/
7765  }
7766  break;
7767 
7768  case 269:
7769 
7770 /* Line 1806 of yacc.c */
7771 #line 2492 "parse.y"
7772  {
7773  /*%%%*/
7774  (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node));
7775  /*%
7776  $$ = arg_add_star(arg_new(), $2);
7777  %*/
7778  }
7779  break;
7780 
7781  case 270:
7782 
7783 /* Line 1806 of yacc.c */
7784 #line 2500 "parse.y"
7785  {
7786  /*%%%*/
7787  NODE *n1;
7788  if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) {
7789  (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node));
7790  }
7791  else {
7792  (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7793  }
7794  /*%
7795  $$ = arg_add($1, $3);
7796  %*/
7797  }
7798  break;
7799 
7800  case 271:
7801 
7802 /* Line 1806 of yacc.c */
7803 #line 2514 "parse.y"
7804  {
7805  /*%%%*/
7806  NODE *n1;
7807  if ((nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) {
7808  (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node));
7809  }
7810  else {
7811  (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
7812  }
7813  /*%
7814  $$ = arg_add_star($1, $4);
7815  %*/
7816  }
7817  break;
7818 
7819  case 272:
7820 
7821 /* Line 1806 of yacc.c */
7822 #line 2530 "parse.y"
7823  {
7824  /*%%%*/
7825  NODE *n1;
7826  if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) {
7827  (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node));
7828  }
7829  else {
7830  (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7831  }
7832  /*%
7833  $$ = mrhs_add(args2mrhs($1), $3);
7834  %*/
7835  }
7836  break;
7837 
7838  case 273:
7839 
7840 /* Line 1806 of yacc.c */
7841 #line 2544 "parse.y"
7842  {
7843  /*%%%*/
7844  NODE *n1;
7845  if (nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY &&
7846  (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) {
7847  (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node));
7848  }
7849  else {
7850  (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
7851  }
7852  /*%
7853  $$ = mrhs_add_star(args2mrhs($1), $4);
7854  %*/
7855  }
7856  break;
7857 
7858  case 274:
7859 
7860 /* Line 1806 of yacc.c */
7861 #line 2559 "parse.y"
7862  {
7863  /*%%%*/
7864  (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node));
7865  /*%
7866  $$ = mrhs_add_star(mrhs_new(), $2);
7867  %*/
7868  }
7869  break;
7870 
7871  case 285:
7872 
7873 /* Line 1806 of yacc.c */
7874 #line 2579 "parse.y"
7875  {
7876  /*%%%*/
7877  (yyval.node) = NEW_FCALL((yyvsp[(1) - (1)].id), 0);
7878  /*%
7879  $$ = method_arg(dispatch1(fcall, $1), arg_new());
7880  %*/
7881  }
7882  break;
7883 
7884  case 286:
7885 
7886 /* Line 1806 of yacc.c */
7887 #line 2587 "parse.y"
7888  {
7889  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7890  cmdarg_stack = 0;
7891  /*%%%*/
7892  (yyval.num) = ruby_sourceline;
7893  /*%
7894  %*/
7895  }
7896  break;
7897 
7898  case 287:
7899 
7900 /* Line 1806 of yacc.c */
7901 #line 2597 "parse.y"
7902  {
7903  cmdarg_stack = (yyvsp[(1) - (4)].val);
7904  /*%%%*/
7905  if ((yyvsp[(3) - (4)].node) == NULL) {
7906  (yyval.node) = NEW_NIL();
7907  }
7908  else {
7909  if (nd_type((yyvsp[(3) - (4)].node)) == NODE_RESCUE ||
7910  nd_type((yyvsp[(3) - (4)].node)) == NODE_ENSURE)
7911  nd_set_line((yyvsp[(3) - (4)].node), (yyvsp[(2) - (4)].num));
7912  (yyval.node) = NEW_BEGIN((yyvsp[(3) - (4)].node));
7913  }
7914  nd_set_line((yyval.node), (yyvsp[(2) - (4)].num));
7915  /*%
7916  $$ = dispatch1(begin, $3);
7917  %*/
7918  }
7919  break;
7920 
7921  case 288:
7922 
7923 /* Line 1806 of yacc.c */
7924 #line 2614 "parse.y"
7925  {lex_state = EXPR_ENDARG;}
7926  break;
7927 
7928  case 289:
7929 
7930 /* Line 1806 of yacc.c */
7931 #line 2615 "parse.y"
7932  {
7933  /*%%%*/
7934  (yyval.node) = 0;
7935  /*%
7936  $$ = dispatch1(paren, 0);
7937  %*/
7938  }
7939  break;
7940 
7941  case 290:
7942 
7943 /* Line 1806 of yacc.c */
7944 #line 2622 "parse.y"
7945  {lex_state = EXPR_ENDARG;}
7946  break;
7947 
7948  case 291:
7949 
7950 /* Line 1806 of yacc.c */
7951 #line 2623 "parse.y"
7952  {
7953  /*%%%*/
7954  (yyval.node) = (yyvsp[(2) - (4)].node);
7955  /*%
7956  $$ = dispatch1(paren, $2);
7957  %*/
7958  }
7959  break;
7960 
7961  case 292:
7962 
7963 /* Line 1806 of yacc.c */
7964 #line 2631 "parse.y"
7965  {
7966  /*%%%*/
7967  (yyval.node) = (yyvsp[(2) - (3)].node);
7968  /*%
7969  $$ = dispatch1(paren, $2);
7970  %*/
7971  }
7972  break;
7973 
7974  case 293:
7975 
7976 /* Line 1806 of yacc.c */
7977 #line 2639 "parse.y"
7978  {
7979  /*%%%*/
7980  (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
7981  /*%
7982  $$ = dispatch2(const_path_ref, $1, $3);
7983  %*/
7984  }
7985  break;
7986 
7987  case 294:
7988 
7989 /* Line 1806 of yacc.c */
7990 #line 2647 "parse.y"
7991  {
7992  /*%%%*/
7993  (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id));
7994  /*%
7995  $$ = dispatch1(top_const_ref, $2);
7996  %*/
7997  }
7998  break;
7999 
8000  case 295:
8001 
8002 /* Line 1806 of yacc.c */
8003 #line 2655 "parse.y"
8004  {
8005  /*%%%*/
8006  if ((yyvsp[(2) - (3)].node) == 0) {
8007  (yyval.node) = NEW_ZARRAY(); /* zero length array*/
8008  }
8009  else {
8010  (yyval.node) = (yyvsp[(2) - (3)].node);
8011  }
8012  /*%
8013  $$ = dispatch1(array, escape_Qundef($2));
8014  %*/
8015  }
8016  break;
8017 
8018  case 296:
8019 
8020 /* Line 1806 of yacc.c */
8021 #line 2668 "parse.y"
8022  {
8023  /*%%%*/
8024  (yyval.node) = NEW_HASH((yyvsp[(2) - (3)].node));
8025  /*%
8026  $$ = dispatch1(hash, escape_Qundef($2));
8027  %*/
8028  }
8029  break;
8030 
8031  case 297:
8032 
8033 /* Line 1806 of yacc.c */
8034 #line 2676 "parse.y"
8035  {
8036  /*%%%*/
8037  (yyval.node) = NEW_RETURN(0);
8038  /*%
8039  $$ = dispatch0(return0);
8040  %*/
8041  }
8042  break;
8043 
8044  case 298:
8045 
8046 /* Line 1806 of yacc.c */
8047 #line 2684 "parse.y"
8048  {
8049  /*%%%*/
8050  (yyval.node) = new_yield((yyvsp[(3) - (4)].node));
8051  /*%
8052  $$ = dispatch1(yield, dispatch1(paren, $3));
8053  %*/
8054  }
8055  break;
8056 
8057  case 299:
8058 
8059 /* Line 1806 of yacc.c */
8060 #line 2692 "parse.y"
8061  {
8062  /*%%%*/
8063  (yyval.node) = NEW_YIELD(0);
8064  /*%
8065  $$ = dispatch1(yield, dispatch1(paren, arg_new()));
8066  %*/
8067  }
8068  break;
8069 
8070  case 300:
8071 
8072 /* Line 1806 of yacc.c */
8073 #line 2700 "parse.y"
8074  {
8075  /*%%%*/
8076  (yyval.node) = NEW_YIELD(0);
8077  /*%
8078  $$ = dispatch0(yield0);
8079  %*/
8080  }
8081  break;
8082 
8083  case 301:
8084 
8085 /* Line 1806 of yacc.c */
8086 #line 2707 "parse.y"
8087  {in_defined = 1;}
8088  break;
8089 
8090  case 302:
8091 
8092 /* Line 1806 of yacc.c */
8093 #line 2708 "parse.y"
8094  {
8095  /*%%%*/
8096  in_defined = 0;
8097  (yyval.node) = NEW_DEFINED((yyvsp[(5) - (6)].node));
8098  /*%
8099  in_defined = 0;
8100  $$ = dispatch1(defined, $5);
8101  %*/
8102  }
8103  break;
8104 
8105  case 303:
8106 
8107 /* Line 1806 of yacc.c */
8108 #line 2718 "parse.y"
8109  {
8110  /*%%%*/
8111  (yyval.node) = call_uni_op(cond((yyvsp[(3) - (4)].node)), '!');
8112  /*%
8113  $$ = dispatch2(unary, ripper_intern("not"), $3);
8114  %*/
8115  }
8116  break;
8117 
8118  case 304:
8119 
8120 /* Line 1806 of yacc.c */
8121 #line 2726 "parse.y"
8122  {
8123  /*%%%*/
8124  (yyval.node) = call_uni_op(cond(NEW_NIL()), '!');
8125  /*%
8126  $$ = dispatch2(unary, ripper_intern("not"), Qnil);
8127  %*/
8128  }
8129  break;
8130 
8131  case 305:
8132 
8133 /* Line 1806 of yacc.c */
8134 #line 2734 "parse.y"
8135  {
8136  /*%%%*/
8137  (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
8138  (yyval.node) = (yyvsp[(2) - (2)].node);
8139  /*%
8140  $$ = method_arg(dispatch1(fcall, $1), arg_new());
8141  $$ = method_add_block($$, $2);
8142  %*/
8143  }
8144  break;
8145 
8146  case 307:
8147 
8148 /* Line 1806 of yacc.c */
8149 #line 2745 "parse.y"
8150  {
8151  /*%%%*/
8152  block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node));
8153  (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
8154  (yyval.node) = (yyvsp[(2) - (2)].node);
8155  /*%
8156  $$ = method_add_block($1, $2);
8157  %*/
8158  }
8159  break;
8160 
8161  case 308:
8162 
8163 /* Line 1806 of yacc.c */
8164 #line 2755 "parse.y"
8165  {
8166  (yyval.node) = (yyvsp[(2) - (2)].node);
8167  }
8168  break;
8169 
8170  case 309:
8171 
8172 /* Line 1806 of yacc.c */
8173 #line 2762 "parse.y"
8174  {
8175  /*%%%*/
8176  (yyval.node) = NEW_IF(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node));
8177  fixpos((yyval.node), (yyvsp[(2) - (6)].node));
8178  /*%
8179  $$ = dispatch3(if, $2, $4, escape_Qundef($5));
8180  %*/
8181  }
8182  break;
8183 
8184  case 310:
8185 
8186 /* Line 1806 of yacc.c */
8187 #line 2774 "parse.y"
8188  {
8189  /*%%%*/
8190  (yyval.node) = NEW_UNLESS(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node));
8191  fixpos((yyval.node), (yyvsp[(2) - (6)].node));
8192  /*%
8193  $$ = dispatch3(unless, $2, $4, escape_Qundef($5));
8194  %*/
8195  }
8196  break;
8197 
8198  case 311:
8199 
8200 /* Line 1806 of yacc.c */
8201 #line 2782 "parse.y"
8202  {COND_PUSH(1);}
8203  break;
8204 
8205  case 312:
8206 
8207 /* Line 1806 of yacc.c */
8208 #line 2782 "parse.y"
8209  {COND_POP();}
8210  break;
8211 
8212  case 313:
8213 
8214 /* Line 1806 of yacc.c */
8215 #line 2785 "parse.y"
8216  {
8217  /*%%%*/
8218  (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1);
8219  fixpos((yyval.node), (yyvsp[(3) - (7)].node));
8220  /*%
8221  $$ = dispatch2(while, $3, $6);
8222  %*/
8223  }
8224  break;
8225 
8226  case 314:
8227 
8228 /* Line 1806 of yacc.c */
8229 #line 2793 "parse.y"
8230  {COND_PUSH(1);}
8231  break;
8232 
8233  case 315:
8234 
8235 /* Line 1806 of yacc.c */
8236 #line 2793 "parse.y"
8237  {COND_POP();}
8238  break;
8239 
8240  case 316:
8241 
8242 /* Line 1806 of yacc.c */
8243 #line 2796 "parse.y"
8244  {
8245  /*%%%*/
8246  (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1);
8247  fixpos((yyval.node), (yyvsp[(3) - (7)].node));
8248  /*%
8249  $$ = dispatch2(until, $3, $6);
8250  %*/
8251  }
8252  break;
8253 
8254  case 317:
8255 
8256 /* Line 1806 of yacc.c */
8257 #line 2807 "parse.y"
8258  {
8259  /*%%%*/
8260  (yyval.node) = NEW_CASE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node));
8261  fixpos((yyval.node), (yyvsp[(2) - (5)].node));
8262  /*%
8263  $$ = dispatch2(case, $2, $4);
8264  %*/
8265  }
8266  break;
8267 
8268  case 318:
8269 
8270 /* Line 1806 of yacc.c */
8271 #line 2816 "parse.y"
8272  {
8273  /*%%%*/
8274  (yyval.node) = NEW_CASE(0, (yyvsp[(3) - (4)].node));
8275  /*%
8276  $$ = dispatch2(case, Qnil, $3);
8277  %*/
8278  }
8279  break;
8280 
8281  case 319:
8282 
8283 /* Line 1806 of yacc.c */
8284 #line 2824 "parse.y"
8285  {COND_PUSH(1);}
8286  break;
8287 
8288  case 320:
8289 
8290 /* Line 1806 of yacc.c */
8291 #line 2826 "parse.y"
8292  {COND_POP();}
8293  break;
8294 
8295  case 321:
8296 
8297 /* Line 1806 of yacc.c */
8298 #line 2829 "parse.y"
8299  {
8300  /*%%%*/
8301  /*
8302  * for a, b, c in e
8303  * #=>
8304  * e.each{|*x| a, b, c = x
8305  *
8306  * for a in e
8307  * #=>
8308  * e.each{|x| a, = x}
8309  */
8310  ID id = internal_id();
8311  ID *tbl = ALLOC_N(ID, 2);
8312  NODE *m = NEW_ARGS_AUX(0, 0);
8313  NODE *args, *scope;
8314 
8315  if (nd_type((yyvsp[(2) - (9)].node)) == NODE_MASGN) {
8316  /* if args.length == 1 && args[0].kind_of?(Array)
8317  * args = args[0]
8318  * end
8319  */
8320  NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
8321  NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
8322  m->nd_next = block_append(
8323  NEW_IF(
8325  NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
8326  idEq, one),
8327  NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero),
8328  rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
8329  0),
8330  NEW_DASGN_CURR(id,
8331  NEW_CALL(NEW_DVAR(id), idAREF, zero)),
8332  0),
8333  node_assign((yyvsp[(2) - (9)].node), NEW_DVAR(id)));
8334 
8335  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8336  }
8337  else {
8338  if (nd_type((yyvsp[(2) - (9)].node)) == NODE_LASGN ||
8339  nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN ||
8340  nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN_CURR) {
8341  (yyvsp[(2) - (9)].node)->nd_value = NEW_DVAR(id);
8342  m->nd_plen = 1;
8343  m->nd_next = (yyvsp[(2) - (9)].node);
8344  args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
8345  }
8346  else {
8347  m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].node)), 0), NEW_DVAR(id));
8348  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8349  }
8350  }
8351  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].node), args);
8352  tbl[0] = 1; tbl[1] = id;
8353  (yyval.node) = NEW_FOR(0, (yyvsp[(5) - (9)].node), scope);
8354  fixpos((yyval.node), (yyvsp[(2) - (9)].node));
8355  /*%
8356  $$ = dispatch3(for, $2, $5, $8);
8357  %*/
8358  }
8359  break;
8360 
8361  case 322:
8362 
8363 /* Line 1806 of yacc.c */
8364 #line 2890 "parse.y"
8365  {
8366  if (in_def || in_single)
8367  yyerror("class definition in method body");
8368  local_push(0);
8369  /*%%%*/
8370  (yyval.num) = ruby_sourceline;
8371  /*%
8372  %*/
8373  }
8374  break;
8375 
8376  case 323:
8377 
8378 /* Line 1806 of yacc.c */
8379 #line 2901 "parse.y"
8380  {
8381  /*%%%*/
8382  (yyval.node) = NEW_CLASS((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(3) - (6)].node));
8383  nd_set_line((yyval.node), (yyvsp[(4) - (6)].num));
8384  /*%
8385  $$ = dispatch3(class, $2, $3, $5);
8386  %*/
8387  local_pop();
8388  }
8389  break;
8390 
8391  case 324:
8392 
8393 /* Line 1806 of yacc.c */
8394 #line 2911 "parse.y"
8395  {
8396  (yyval.num) = in_def;
8397  in_def = 0;
8398  }
8399  break;
8400 
8401  case 325:
8402 
8403 /* Line 1806 of yacc.c */
8404 #line 2916 "parse.y"
8405  {
8406  (yyval.num) = in_single;
8407  in_single = 0;
8408  local_push(0);
8409  }
8410  break;
8411 
8412  case 326:
8413 
8414 /* Line 1806 of yacc.c */
8415 #line 2923 "parse.y"
8416  {
8417  /*%%%*/
8418  (yyval.node) = NEW_SCLASS((yyvsp[(3) - (8)].node), (yyvsp[(7) - (8)].node));
8419  fixpos((yyval.node), (yyvsp[(3) - (8)].node));
8420  /*%
8421  $$ = dispatch2(sclass, $3, $7);
8422  %*/
8423  local_pop();
8424  in_def = (yyvsp[(4) - (8)].num);
8425  in_single = (yyvsp[(6) - (8)].num);
8426  }
8427  break;
8428 
8429  case 327:
8430 
8431 /* Line 1806 of yacc.c */
8432 #line 2935 "parse.y"
8433  {
8434  if (in_def || in_single)
8435  yyerror("module definition in method body");
8436  local_push(0);
8437  /*%%%*/
8438  (yyval.num) = ruby_sourceline;
8439  /*%
8440  %*/
8441  }
8442  break;
8443 
8444  case 328:
8445 
8446 /* Line 1806 of yacc.c */
8447 #line 2946 "parse.y"
8448  {
8449  /*%%%*/
8450  (yyval.node) = NEW_MODULE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node));
8451  nd_set_line((yyval.node), (yyvsp[(3) - (5)].num));
8452  /*%
8453  $$ = dispatch2(module, $2, $4);
8454  %*/
8455  local_pop();
8456  }
8457  break;
8458 
8459  case 329:
8460 
8461 /* Line 1806 of yacc.c */
8462 #line 2956 "parse.y"
8463  {
8464  (yyval.id) = cur_mid;
8465  cur_mid = (yyvsp[(2) - (2)].id);
8466  in_def++;
8467  local_push(0);
8468  }
8469  break;
8470 
8471  case 330:
8472 
8473 /* Line 1806 of yacc.c */
8474 #line 2965 "parse.y"
8475  {
8476  /*%%%*/
8477  NODE *body = remove_begin((yyvsp[(5) - (6)].node));
8478  reduce_nodes(&body);
8479  (yyval.node) = NEW_DEFN((yyvsp[(2) - (6)].id), (yyvsp[(4) - (6)].node), body, NOEX_PRIVATE);
8480  nd_set_line((yyval.node), (yyvsp[(1) - (6)].num));
8481  /*%
8482  $$ = dispatch3(def, $2, $4, $5);
8483  %*/
8484  local_pop();
8485  in_def--;
8486  cur_mid = (yyvsp[(3) - (6)].id);
8487  }
8488  break;
8489 
8490  case 331:
8491 
8492 /* Line 1806 of yacc.c */
8493 #line 2978 "parse.y"
8494  {lex_state = EXPR_FNAME;}
8495  break;
8496 
8497  case 332:
8498 
8499 /* Line 1806 of yacc.c */
8500 #line 2979 "parse.y"
8501  {
8502  in_single++;
8503  lex_state = EXPR_ENDFN; /* force for args */
8504  local_push(0);
8505  }
8506  break;
8507 
8508  case 333:
8509 
8510 /* Line 1806 of yacc.c */
8511 #line 2987 "parse.y"
8512  {
8513  /*%%%*/
8514  NODE *body = remove_begin((yyvsp[(8) - (9)].node));
8515  reduce_nodes(&body);
8516  (yyval.node) = NEW_DEFS((yyvsp[(2) - (9)].node), (yyvsp[(5) - (9)].id), (yyvsp[(7) - (9)].node), body);
8517  nd_set_line((yyval.node), (yyvsp[(1) - (9)].num));
8518  /*%
8519  $$ = dispatch5(defs, $2, $3, $5, $7, $8);
8520  %*/
8521  local_pop();
8522  in_single--;
8523  }
8524  break;
8525 
8526  case 334:
8527 
8528 /* Line 1806 of yacc.c */
8529 #line 3000 "parse.y"
8530  {
8531  /*%%%*/
8532  (yyval.node) = NEW_BREAK(0);
8533  /*%
8534  $$ = dispatch1(break, arg_new());
8535  %*/
8536  }
8537  break;
8538 
8539  case 335:
8540 
8541 /* Line 1806 of yacc.c */
8542 #line 3008 "parse.y"
8543  {
8544  /*%%%*/
8545  (yyval.node) = NEW_NEXT(0);
8546  /*%
8547  $$ = dispatch1(next, arg_new());
8548  %*/
8549  }
8550  break;
8551 
8552  case 336:
8553 
8554 /* Line 1806 of yacc.c */
8555 #line 3016 "parse.y"
8556  {
8557  /*%%%*/
8558  (yyval.node) = NEW_REDO();
8559  /*%
8560  $$ = dispatch0(redo);
8561  %*/
8562  }
8563  break;
8564 
8565  case 337:
8566 
8567 /* Line 1806 of yacc.c */
8568 #line 3024 "parse.y"
8569  {
8570  /*%%%*/
8571  (yyval.node) = NEW_RETRY();
8572  /*%
8573  $$ = dispatch0(retry);
8574  %*/
8575  }
8576  break;
8577 
8578  case 338:
8579 
8580 /* Line 1806 of yacc.c */
8581 #line 3034 "parse.y"
8582  {
8583  /*%%%*/
8584  value_expr((yyvsp[(1) - (1)].node));
8585  (yyval.node) = (yyvsp[(1) - (1)].node);
8586  if (!(yyval.node)) (yyval.node) = NEW_NIL();
8587  /*%
8588  $$ = $1;
8589  %*/
8590  }
8591  break;
8592 
8593  case 339:
8594 
8595 /* Line 1806 of yacc.c */
8596 #line 3046 "parse.y"
8597  {
8598  token_info_push("begin");
8599  }
8600  break;
8601 
8602  case 340:
8603 
8604 /* Line 1806 of yacc.c */
8605 #line 3052 "parse.y"
8606  {
8607  token_info_push("if");
8608  }
8609  break;
8610 
8611  case 341:
8612 
8613 /* Line 1806 of yacc.c */
8614 #line 3058 "parse.y"
8615  {
8616  token_info_push("unless");
8617  }
8618  break;
8619 
8620  case 342:
8621 
8622 /* Line 1806 of yacc.c */
8623 #line 3064 "parse.y"
8624  {
8625  token_info_push("while");
8626  }
8627  break;
8628 
8629  case 343:
8630 
8631 /* Line 1806 of yacc.c */
8632 #line 3070 "parse.y"
8633  {
8634  token_info_push("until");
8635  }
8636  break;
8637 
8638  case 344:
8639 
8640 /* Line 1806 of yacc.c */
8641 #line 3076 "parse.y"
8642  {
8643  token_info_push("case");
8644  }
8645  break;
8646 
8647  case 345:
8648 
8649 /* Line 1806 of yacc.c */
8650 #line 3082 "parse.y"
8651  {
8652  token_info_push("for");
8653  }
8654  break;
8655 
8656  case 346:
8657 
8658 /* Line 1806 of yacc.c */
8659 #line 3088 "parse.y"
8660  {
8661  token_info_push("class");
8662  }
8663  break;
8664 
8665  case 347:
8666 
8667 /* Line 1806 of yacc.c */
8668 #line 3094 "parse.y"
8669  {
8670  token_info_push("module");
8671  }
8672  break;
8673 
8674  case 348:
8675 
8676 /* Line 1806 of yacc.c */
8677 #line 3100 "parse.y"
8678  {
8679  token_info_push("def");
8680  /*%%%*/
8681  (yyval.num) = ruby_sourceline;
8682  /*%
8683  %*/
8684  }
8685  break;
8686 
8687  case 349:
8688 
8689 /* Line 1806 of yacc.c */
8690 #line 3110 "parse.y"
8691  {
8692  token_info_pop("end");
8693  }
8694  break;
8695 
8696  case 356:
8697 
8698 /* Line 1806 of yacc.c */
8699 #line 3140 "parse.y"
8700  {
8701  /*%%%*/
8702  (yyval.node) = NEW_IF(cond((yyvsp[(2) - (5)].node)), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
8703  fixpos((yyval.node), (yyvsp[(2) - (5)].node));
8704  /*%
8705  $$ = dispatch3(elsif, $2, $4, escape_Qundef($5));
8706  %*/
8707  }
8708  break;
8709 
8710  case 358:
8711 
8712 /* Line 1806 of yacc.c */
8713 #line 3152 "parse.y"
8714  {
8715  /*%%%*/
8716  (yyval.node) = (yyvsp[(2) - (2)].node);
8717  /*%
8718  $$ = dispatch1(else, $2);
8719  %*/
8720  }
8721  break;
8722 
8723  case 361:
8724 
8725 /* Line 1806 of yacc.c */
8726 #line 3166 "parse.y"
8727  {
8728  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
8729  /*%%%*/
8730  /*%
8731  $$ = dispatch1(mlhs_paren, $$);
8732  %*/
8733  }
8734  break;
8735 
8736  case 362:
8737 
8738 /* Line 1806 of yacc.c */
8739 #line 3174 "parse.y"
8740  {
8741  /*%%%*/
8742  (yyval.node) = (yyvsp[(2) - (3)].node);
8743  /*%
8744  $$ = dispatch1(mlhs_paren, $2);
8745  %*/
8746  }
8747  break;
8748 
8749  case 363:
8750 
8751 /* Line 1806 of yacc.c */
8752 #line 3184 "parse.y"
8753  {
8754  /*%%%*/
8755  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
8756  /*%
8757  $$ = mlhs_add(mlhs_new(), $1);
8758  %*/
8759  }
8760  break;
8761 
8762  case 364:
8763 
8764 /* Line 1806 of yacc.c */
8765 #line 3192 "parse.y"
8766  {
8767  /*%%%*/
8768  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
8769  /*%
8770  $$ = mlhs_add($1, $3);
8771  %*/
8772  }
8773  break;
8774 
8775  case 365:
8776 
8777 /* Line 1806 of yacc.c */
8778 #line 3202 "parse.y"
8779  {
8780  /*%%%*/
8781  (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0);
8782  /*%
8783  $$ = $1;
8784  %*/
8785  }
8786  break;
8787 
8788  case 366:
8789 
8790 /* Line 1806 of yacc.c */
8791 #line 3210 "parse.y"
8792  {
8793  (yyval.node) = assignable((yyvsp[(4) - (4)].id), 0);
8794  /*%%%*/
8795  (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), (yyval.node));
8796  /*%
8797  $$ = mlhs_add_star($1, $$);
8798  %*/
8799  }
8800  break;
8801 
8802  case 367:
8803 
8804 /* Line 1806 of yacc.c */
8805 #line 3219 "parse.y"
8806  {
8807  (yyval.node) = assignable((yyvsp[(4) - (6)].id), 0);
8808  /*%%%*/
8809  (yyval.node) = NEW_MASGN((yyvsp[(1) - (6)].node), NEW_POSTARG((yyval.node), (yyvsp[(6) - (6)].node)));
8810  /*%
8811  $$ = mlhs_add_star($1, $$);
8812  %*/
8813  }
8814  break;
8815 
8816  case 368:
8817 
8818 /* Line 1806 of yacc.c */
8819 #line 3228 "parse.y"
8820  {
8821  /*%%%*/
8822  (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), -1);
8823  /*%
8824  $$ = mlhs_add_star($1, Qnil);
8825  %*/
8826  }
8827  break;
8828 
8829  case 369:
8830 
8831 /* Line 1806 of yacc.c */
8832 #line 3236 "parse.y"
8833  {
8834  /*%%%*/
8835  (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG(-1, (yyvsp[(5) - (5)].node)));
8836  /*%
8837  $$ = mlhs_add_star($1, $5);
8838  %*/
8839  }
8840  break;
8841 
8842  case 370:
8843 
8844 /* Line 1806 of yacc.c */
8845 #line 3244 "parse.y"
8846  {
8847  (yyval.node) = assignable((yyvsp[(2) - (2)].id), 0);
8848  /*%%%*/
8849  (yyval.node) = NEW_MASGN(0, (yyval.node));
8850  /*%
8851  $$ = mlhs_add_star(mlhs_new(), $$);
8852  %*/
8853  }
8854  break;
8855 
8856  case 371:
8857 
8858 /* Line 1806 of yacc.c */
8859 #line 3253 "parse.y"
8860  {
8861  (yyval.node) = assignable((yyvsp[(2) - (4)].id), 0);
8862  /*%%%*/
8863  (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyval.node), (yyvsp[(4) - (4)].node)));
8864  /*%
8865  #if 0
8866  TODO: Check me
8867  #endif
8868  $$ = mlhs_add_star($$, $4);
8869  %*/
8870  }
8871  break;
8872 
8873  case 372:
8874 
8875 /* Line 1806 of yacc.c */
8876 #line 3265 "parse.y"
8877  {
8878  /*%%%*/
8879  (yyval.node) = NEW_MASGN(0, -1);
8880  /*%
8881  $$ = mlhs_add_star(mlhs_new(), Qnil);
8882  %*/
8883  }
8884  break;
8885 
8886  case 373:
8887 
8888 /* Line 1806 of yacc.c */
8889 #line 3273 "parse.y"
8890  {
8891  /*%%%*/
8892  (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node)));
8893  /*%
8894  $$ = mlhs_add_star(mlhs_new(), Qnil);
8895  %*/
8896  }
8897  break;
8898 
8899  case 374:
8900 
8901 /* Line 1806 of yacc.c */
8902 #line 3284 "parse.y"
8903  {
8904  (yyval.node) = new_args_tail((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id));
8905  }
8906  break;
8907 
8908  case 375:
8909 
8910 /* Line 1806 of yacc.c */
8911 #line 3288 "parse.y"
8912  {
8913  (yyval.node) = new_args_tail((yyvsp[(1) - (2)].node), Qnone, (yyvsp[(2) - (2)].id));
8914  }
8915  break;
8916 
8917  case 376:
8918 
8919 /* Line 1806 of yacc.c */
8920 #line 3292 "parse.y"
8921  {
8922  (yyval.node) = new_args_tail(Qnone, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id));
8923  }
8924  break;
8925 
8926  case 377:
8927 
8928 /* Line 1806 of yacc.c */
8929 #line 3296 "parse.y"
8930  {
8931  (yyval.node) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].id));
8932  }
8933  break;
8934 
8935  case 378:
8936 
8937 /* Line 1806 of yacc.c */
8938 #line 3302 "parse.y"
8939  {
8940  (yyval.node) = (yyvsp[(2) - (2)].node);
8941  }
8942  break;
8943 
8944  case 379:
8945 
8946 /* Line 1806 of yacc.c */
8947 #line 3306 "parse.y"
8948  {
8949  (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
8950  }
8951  break;
8952 
8953  case 380:
8954 
8955 /* Line 1806 of yacc.c */
8956 #line 3312 "parse.y"
8957  {
8958  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), Qnone, (yyvsp[(6) - (6)].node));
8959  }
8960  break;
8961 
8962  case 381:
8963 
8964 /* Line 1806 of yacc.c */
8965 #line 3316 "parse.y"
8966  {
8967  (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].node));
8968  }
8969  break;
8970 
8971  case 382:
8972 
8973 /* Line 1806 of yacc.c */
8974 #line 3320 "parse.y"
8975  {
8976  (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), Qnone, Qnone, (yyvsp[(4) - (4)].node));
8977  }
8978  break;
8979 
8980  case 383:
8981 
8982 /* Line 1806 of yacc.c */
8983 #line 3324 "parse.y"
8984  {
8985  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), Qnone, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
8986  }
8987  break;
8988 
8989  case 384:
8990 
8991 /* Line 1806 of yacc.c */
8992 #line 3328 "parse.y"
8993  {
8994  (yyval.node) = new_args((yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
8995  }
8996  break;
8997 
8998  case 385:
8999 
9000 /* Line 1806 of yacc.c */
9001 #line 3332 "parse.y"
9002  {
9003  (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
9004  /*%%%*/
9005  /*%
9006  dispatch1(excessed_comma, $$);
9007  %*/
9008  }
9009  break;
9010 
9011  case 386:
9012 
9013 /* Line 1806 of yacc.c */
9014 #line 3340 "parse.y"
9015  {
9016  (yyval.node) = new_args((yyvsp[(1) - (6)].node), Qnone, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
9017  }
9018  break;
9019 
9020  case 387:
9021 
9022 /* Line 1806 of yacc.c */
9023 #line 3344 "parse.y"
9024  {
9025  (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].node));
9026  }
9027  break;
9028 
9029  case 388:
9030 
9031 /* Line 1806 of yacc.c */
9032 #line 3348 "parse.y"
9033  {
9034  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
9035  }
9036  break;
9037 
9038  case 389:
9039 
9040 /* Line 1806 of yacc.c */
9041 #line 3352 "parse.y"
9042  {
9043  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
9044  }
9045  break;
9046 
9047  case 390:
9048 
9049 /* Line 1806 of yacc.c */
9050 #line 3356 "parse.y"
9051  {
9052  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (2)].node), Qnone, Qnone, (yyvsp[(2) - (2)].node));
9053  }
9054  break;
9055 
9056  case 391:
9057 
9058 /* Line 1806 of yacc.c */
9059 #line 3360 "parse.y"
9060  {
9061  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
9062  }
9063  break;
9064 
9065  case 392:
9066 
9067 /* Line 1806 of yacc.c */
9068 #line 3364 "parse.y"
9069  {
9070  (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].id), Qnone, (yyvsp[(2) - (2)].node));
9071  }
9072  break;
9073 
9074  case 393:
9075 
9076 /* Line 1806 of yacc.c */
9077 #line 3368 "parse.y"
9078  {
9079  (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
9080  }
9081  break;
9082 
9083  case 394:
9084 
9085 /* Line 1806 of yacc.c */
9086 #line 3372 "parse.y"
9087  {
9088  (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].node));
9089  }
9090  break;
9091 
9092  case 396:
9093 
9094 /* Line 1806 of yacc.c */
9095 #line 3379 "parse.y"
9096  {
9097  command_start = TRUE;
9098  }
9099  break;
9100 
9101  case 397:
9102 
9103 /* Line 1806 of yacc.c */
9104 #line 3385 "parse.y"
9105  {
9106  /*%%%*/
9107  (yyval.node) = 0;
9108  /*%
9109  $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9110  escape_Qundef($2));
9111  %*/
9112  }
9113  break;
9114 
9115  case 398:
9116 
9117 /* Line 1806 of yacc.c */
9118 #line 3394 "parse.y"
9119  {
9120  /*%%%*/
9121  (yyval.node) = 0;
9122  /*%
9123  $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9124  Qnil);
9125  %*/
9126  }
9127  break;
9128 
9129  case 399:
9130 
9131 /* Line 1806 of yacc.c */
9132 #line 3403 "parse.y"
9133  {
9134  /*%%%*/
9135  (yyval.node) = (yyvsp[(2) - (4)].node);
9136  /*%
9137  $$ = blockvar_new(escape_Qundef($2), escape_Qundef($3));
9138  %*/
9139  }
9140  break;
9141 
9142  case 400:
9143 
9144 /* Line 1806 of yacc.c */
9145 #line 3414 "parse.y"
9146  {
9147  (yyval.node) = 0;
9148  }
9149  break;
9150 
9151  case 401:
9152 
9153 /* Line 1806 of yacc.c */
9154 #line 3418 "parse.y"
9155  {
9156  /*%%%*/
9157  (yyval.node) = 0;
9158  /*%
9159  $$ = $3;
9160  %*/
9161  }
9162  break;
9163 
9164  case 404:
9165 
9166 /* Line 1806 of yacc.c */
9167 #line 3444 "parse.y"
9168  {
9169  new_bv(get_id((yyvsp[(1) - (1)].id)));
9170  /*%%%*/
9171  /*%
9172  $$ = get_value($1);
9173  %*/
9174  }
9175  break;
9176 
9177  case 405:
9178 
9179 /* Line 1806 of yacc.c */
9180 #line 3452 "parse.y"
9181  {
9182  (yyval.node) = 0;
9183  }
9184  break;
9185 
9186  case 406:
9187 
9188 /* Line 1806 of yacc.c */
9189 #line 3457 "parse.y"
9190  {
9191  (yyval.vars) = dyna_push();
9192  }
9193  break;
9194 
9195  case 407:
9196 
9197 /* Line 1806 of yacc.c */
9198 #line 3460 "parse.y"
9199  {
9200  (yyval.num) = lpar_beg;
9201  lpar_beg = ++paren_nest;
9202  }
9203  break;
9204 
9205  case 408:
9206 
9207 /* Line 1806 of yacc.c */
9208 #line 3465 "parse.y"
9209  {
9210  (yyval.num) = ruby_sourceline;
9211  }
9212  break;
9213 
9214  case 409:
9215 
9216 /* Line 1806 of yacc.c */
9217 #line 3469 "parse.y"
9218  {
9219  lpar_beg = (yyvsp[(2) - (5)].num);
9220  /*%%%*/
9221  (yyval.node) = NEW_LAMBDA((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));
9222  nd_set_line((yyval.node), (yyvsp[(4) - (5)].num));
9223  /*%
9224  $$ = dispatch2(lambda, $3, $5);
9225  %*/
9226  dyna_pop((yyvsp[(1) - (5)].vars));
9227  }
9228  break;
9229 
9230  case 410:
9231 
9232 /* Line 1806 of yacc.c */
9233 #line 3482 "parse.y"
9234  {
9235  /*%%%*/
9236  (yyval.node) = (yyvsp[(2) - (4)].node);
9237  /*%
9238  $$ = dispatch1(paren, $2);
9239  %*/
9240  }
9241  break;
9242 
9243  case 411:
9244 
9245 /* Line 1806 of yacc.c */
9246 #line 3490 "parse.y"
9247  {
9248  /*%%%*/
9249  (yyval.node) = (yyvsp[(1) - (1)].node);
9250  /*%
9251  $$ = $1;
9252  %*/
9253  }
9254  break;
9255 
9256  case 412:
9257 
9258 /* Line 1806 of yacc.c */
9259 #line 3500 "parse.y"
9260  {
9261  (yyval.node) = (yyvsp[(2) - (3)].node);
9262  }
9263  break;
9264 
9265  case 413:
9266 
9267 /* Line 1806 of yacc.c */
9268 #line 3504 "parse.y"
9269  {
9270  (yyval.node) = (yyvsp[(2) - (3)].node);
9271  }
9272  break;
9273 
9274  case 414:
9275 
9276 /* Line 1806 of yacc.c */
9277 #line 3510 "parse.y"
9278  {
9279  (yyvsp[(1) - (1)].vars) = dyna_push();
9280  /*%%%*/
9281  (yyval.num) = ruby_sourceline;
9282  /*% %*/
9283  }
9284  break;
9285 
9286  case 415:
9287 
9288 /* Line 1806 of yacc.c */
9289 #line 3519 "parse.y"
9290  {
9291  /*%%%*/
9292  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
9293  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
9294  /*%
9295  $$ = dispatch2(do_block, escape_Qundef($3), $4);
9296  %*/
9297  dyna_pop((yyvsp[(1) - (5)].vars));
9298  }
9299  break;
9300 
9301  case 416:
9302 
9303 /* Line 1806 of yacc.c */
9304 #line 3531 "parse.y"
9305  {
9306  /*%%%*/
9307  if (nd_type((yyvsp[(1) - (2)].node)) == NODE_YIELD) {
9308  compile_error(PARSER_ARG "block given to yield");
9309  }
9310  else {
9311  block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node));
9312  }
9313  (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
9314  (yyval.node) = (yyvsp[(2) - (2)].node);
9315  fixpos((yyval.node), (yyvsp[(1) - (2)].node));
9316  /*%
9317  $$ = method_add_block($1, $2);
9318  %*/
9319  }
9320  break;
9321 
9322  case 417:
9323 
9324 /* Line 1806 of yacc.c */
9325 #line 3547 "parse.y"
9326  {
9327  /*%%%*/
9328  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
9329  /*%
9330  $$ = dispatch3(call, $1, $2, $3);
9331  $$ = method_optarg($$, $4);
9332  %*/
9333  }
9334  break;
9335 
9336  case 418:
9337 
9338 /* Line 1806 of yacc.c */
9339 #line 3556 "parse.y"
9340  {
9341  /*%%%*/
9342  block_dup_check((yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
9343  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
9344  (yyval.node) = (yyvsp[(5) - (5)].node);
9345  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
9346  /*%
9347  $$ = dispatch4(command_call, $1, $2, $3, $4);
9348  $$ = method_add_block($$, $5);
9349  %*/
9350  }
9351  break;
9352 
9353  case 419:
9354 
9355 /* Line 1806 of yacc.c */
9356 #line 3568 "parse.y"
9357  {
9358  /*%%%*/
9359  block_dup_check((yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
9360  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
9361  (yyval.node) = (yyvsp[(5) - (5)].node);
9362  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
9363  /*%
9364  $$ = dispatch4(command_call, $1, $2, $3, $4);
9365  $$ = method_add_block($$, $5);
9366  %*/
9367  }
9368  break;
9369 
9370  case 420:
9371 
9372 /* Line 1806 of yacc.c */
9373 #line 3582 "parse.y"
9374  {
9375  /*%%%*/
9376  (yyval.node) = (yyvsp[(1) - (2)].node);
9377  (yyval.node)->nd_args = (yyvsp[(2) - (2)].node);
9378  /*%
9379  $$ = method_arg(dispatch1(fcall, $1), $2);
9380  %*/
9381  }
9382  break;
9383 
9384  case 421:
9385 
9386 /* Line 1806 of yacc.c */
9387 #line 3591 "parse.y"
9388  {
9389  /*%%%*/
9390  (yyval.num) = ruby_sourceline;
9391  /*% %*/
9392  }
9393  break;
9394 
9395  case 422:
9396 
9397 /* Line 1806 of yacc.c */
9398 #line 3597 "parse.y"
9399  {
9400  /*%%%*/
9401  (yyval.node) = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].node));
9402  nd_set_line((yyval.node), (yyvsp[(4) - (5)].num));
9403  /*%
9404  $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
9405  $$ = method_optarg($$, $5);
9406  %*/
9407  }
9408  break;
9409 
9410  case 423:
9411 
9412 /* Line 1806 of yacc.c */
9413 #line 3607 "parse.y"
9414  {
9415  /*%%%*/
9416  (yyval.num) = ruby_sourceline;
9417  /*% %*/
9418  }
9419  break;
9420 
9421  case 424:
9422 
9423 /* Line 1806 of yacc.c */
9424 #line 3613 "parse.y"
9425  {
9426  /*%%%*/
9427  (yyval.node) = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].node));
9428  nd_set_line((yyval.node), (yyvsp[(4) - (5)].num));
9429  /*%
9430  $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
9431  $$ = method_optarg($$, $5);
9432  %*/
9433  }
9434  break;
9435 
9436  case 425:
9437 
9438 /* Line 1806 of yacc.c */
9439 #line 3623 "parse.y"
9440  {
9441  /*%%%*/
9442  (yyval.node) = NEW_CALL((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id), 0);
9443  /*%
9444  $$ = dispatch3(call, $1, ripper_intern("::"), $3);
9445  %*/
9446  }
9447  break;
9448 
9449  case 426:
9450 
9451 /* Line 1806 of yacc.c */
9452 #line 3631 "parse.y"
9453  {
9454  /*%%%*/
9455  (yyval.num) = ruby_sourceline;
9456  /*% %*/
9457  }
9458  break;
9459 
9460  case 427:
9461 
9462 /* Line 1806 of yacc.c */
9463 #line 3637 "parse.y"
9464  {
9465  /*%%%*/
9466  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), rb_intern("call"), (yyvsp[(4) - (4)].node));
9467  nd_set_line((yyval.node), (yyvsp[(3) - (4)].num));
9468  /*%
9469  $$ = dispatch3(call, $1, ripper_id2sym('.'),
9470  ripper_intern("call"));
9471  $$ = method_optarg($$, $4);
9472  %*/
9473  }
9474  break;
9475 
9476  case 428:
9477 
9478 /* Line 1806 of yacc.c */
9479 #line 3648 "parse.y"
9480  {
9481  /*%%%*/
9482  (yyval.num) = ruby_sourceline;
9483  /*% %*/
9484  }
9485  break;
9486 
9487  case 429:
9488 
9489 /* Line 1806 of yacc.c */
9490 #line 3654 "parse.y"
9491  {
9492  /*%%%*/
9493  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), rb_intern("call"), (yyvsp[(4) - (4)].node));
9494  nd_set_line((yyval.node), (yyvsp[(3) - (4)].num));
9495  /*%
9496  $$ = dispatch3(call, $1, ripper_intern("::"),
9497  ripper_intern("call"));
9498  $$ = method_optarg($$, $4);
9499  %*/
9500  }
9501  break;
9502 
9503  case 430:
9504 
9505 /* Line 1806 of yacc.c */
9506 #line 3665 "parse.y"
9507  {
9508  /*%%%*/
9509  (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node));
9510  /*%
9511  $$ = dispatch1(super, $2);
9512  %*/
9513  }
9514  break;
9515 
9516  case 431:
9517 
9518 /* Line 1806 of yacc.c */
9519 #line 3673 "parse.y"
9520  {
9521  /*%%%*/
9522  (yyval.node) = NEW_ZSUPER();
9523  /*%
9524  $$ = dispatch0(zsuper);
9525  %*/
9526  }
9527  break;
9528 
9529  case 432:
9530 
9531 /* Line 1806 of yacc.c */
9532 #line 3681 "parse.y"
9533  {
9534  /*%%%*/
9535  if ((yyvsp[(1) - (4)].node) && nd_type((yyvsp[(1) - (4)].node)) == NODE_SELF)
9536  (yyval.node) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].node));
9537  else
9538  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), tAREF, (yyvsp[(3) - (4)].node));
9539  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
9540  /*%
9541  $$ = dispatch2(aref, $1, escape_Qundef($3));
9542  %*/
9543  }
9544  break;
9545 
9546  case 433:
9547 
9548 /* Line 1806 of yacc.c */
9549 #line 3695 "parse.y"
9550  {
9551  (yyvsp[(1) - (1)].vars) = dyna_push();
9552  /*%%%*/
9553  (yyval.num) = ruby_sourceline;
9554  /*%
9555  %*/
9556  }
9557  break;
9558 
9559  case 434:
9560 
9561 /* Line 1806 of yacc.c */
9562 #line 3704 "parse.y"
9563  {
9564  /*%%%*/
9565  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
9566  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
9567  /*%
9568  $$ = dispatch2(brace_block, escape_Qundef($3), $4);
9569  %*/
9570  dyna_pop((yyvsp[(1) - (5)].vars));
9571  }
9572  break;
9573 
9574  case 435:
9575 
9576 /* Line 1806 of yacc.c */
9577 #line 3714 "parse.y"
9578  {
9579  (yyvsp[(1) - (1)].vars) = dyna_push();
9580  /*%%%*/
9581  (yyval.num) = ruby_sourceline;
9582  /*%
9583  %*/
9584  }
9585  break;
9586 
9587  case 436:
9588 
9589 /* Line 1806 of yacc.c */
9590 #line 3723 "parse.y"
9591  {
9592  /*%%%*/
9593  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
9594  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
9595  /*%
9596  $$ = dispatch2(do_block, escape_Qundef($3), $4);
9597  %*/
9598  dyna_pop((yyvsp[(1) - (5)].vars));
9599  }
9600  break;
9601 
9602  case 437:
9603 
9604 /* Line 1806 of yacc.c */
9605 #line 3737 "parse.y"
9606  {
9607  /*%%%*/
9608  (yyval.node) = NEW_WHEN((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
9609  /*%
9610  $$ = dispatch3(when, $2, $4, escape_Qundef($5));
9611  %*/
9612  }
9613  break;
9614 
9615  case 440:
9616 
9617 /* Line 1806 of yacc.c */
9618 #line 3753 "parse.y"
9619  {
9620  /*%%%*/
9621  if ((yyvsp[(3) - (6)].node)) {
9622  (yyvsp[(3) - (6)].node) = node_assign((yyvsp[(3) - (6)].node), NEW_ERRINFO());
9623  (yyvsp[(5) - (6)].node) = block_append((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node));
9624  }
9625  (yyval.node) = NEW_RESBODY((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
9626  fixpos((yyval.node), (yyvsp[(2) - (6)].node)?(yyvsp[(2) - (6)].node):(yyvsp[(5) - (6)].node));
9627  /*%
9628  $$ = dispatch4(rescue,
9629  escape_Qundef($2),
9630  escape_Qundef($3),
9631  escape_Qundef($5),
9632  escape_Qundef($6));
9633  %*/
9634  }
9635  break;
9636 
9637  case 442:
9638 
9639 /* Line 1806 of yacc.c */
9640 #line 3773 "parse.y"
9641  {
9642  /*%%%*/
9643  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
9644  /*%
9645  $$ = rb_ary_new3(1, $1);
9646  %*/
9647  }
9648  break;
9649 
9650  case 443:
9651 
9652 /* Line 1806 of yacc.c */
9653 #line 3781 "parse.y"
9654  {
9655  /*%%%*/
9656  if (!((yyval.node) = splat_array((yyvsp[(1) - (1)].node)))) (yyval.node) = (yyvsp[(1) - (1)].node);
9657  /*%
9658  $$ = $1;
9659  %*/
9660  }
9661  break;
9662 
9663  case 445:
9664 
9665 /* Line 1806 of yacc.c */
9666 #line 3792 "parse.y"
9667  {
9668  (yyval.node) = (yyvsp[(2) - (2)].node);
9669  }
9670  break;
9671 
9672  case 447:
9673 
9674 /* Line 1806 of yacc.c */
9675 #line 3799 "parse.y"
9676  {
9677  /*%%%*/
9678  (yyval.node) = (yyvsp[(2) - (2)].node);
9679  /*%
9680  $$ = dispatch1(ensure, $2);
9681  %*/
9682  }
9683  break;
9684 
9685  case 450:
9686 
9687 /* Line 1806 of yacc.c */
9688 #line 3811 "parse.y"
9689  {
9690  /*%%%*/
9691  (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id)));
9692  /*%
9693  $$ = dispatch1(symbol_literal, $1);
9694  %*/
9695  }
9696  break;
9697 
9698  case 452:
9699 
9700 /* Line 1806 of yacc.c */
9701 #line 3822 "parse.y"
9702  {
9703  /*%%%*/
9704  NODE *node = (yyvsp[(1) - (1)].node);
9705  if (!node) {
9706  node = NEW_STR(STR_NEW0());
9707  }
9708  else {
9709  node = evstr2dstr(node);
9710  }
9711  (yyval.node) = node;
9712  /*%
9713  $$ = $1;
9714  %*/
9715  }
9716  break;
9717 
9718  case 455:
9719 
9720 /* Line 1806 of yacc.c */
9721 #line 3841 "parse.y"
9722  {
9723  /*%%%*/
9724  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
9725  /*%
9726  $$ = dispatch2(string_concat, $1, $2);
9727  %*/
9728  }
9729  break;
9730 
9731  case 456:
9732 
9733 /* Line 1806 of yacc.c */
9734 #line 3851 "parse.y"
9735  {
9736  /*%%%*/
9737  (yyval.node) = (yyvsp[(2) - (3)].node);
9738  /*%
9739  $$ = dispatch1(string_literal, $2);
9740  %*/
9741  }
9742  break;
9743 
9744  case 457:
9745 
9746 /* Line 1806 of yacc.c */
9747 #line 3861 "parse.y"
9748  {
9749  /*%%%*/
9750  NODE *node = (yyvsp[(2) - (3)].node);
9751  if (!node) {
9752  node = NEW_XSTR(STR_NEW0());
9753  }
9754  else {
9755  switch (nd_type(node)) {
9756  case NODE_STR:
9757  nd_set_type(node, NODE_XSTR);
9758  break;
9759  case NODE_DSTR:
9760  nd_set_type(node, NODE_DXSTR);
9761  break;
9762  default:
9763  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
9764  break;
9765  }
9766  }
9767  (yyval.node) = node;
9768  /*%
9769  $$ = dispatch1(xstring_literal, $2);
9770  %*/
9771  }
9772  break;
9773 
9774  case 458:
9775 
9776 /* Line 1806 of yacc.c */
9777 #line 3888 "parse.y"
9778  {
9779  /*%%%*/
9780  int options = (yyvsp[(3) - (3)].num);
9781  NODE *node = (yyvsp[(2) - (3)].node);
9782  NODE *list, *prev;
9783  if (!node) {
9784  node = NEW_LIT(reg_compile(STR_NEW0(), options));
9785  }
9786  else switch (nd_type(node)) {
9787  case NODE_STR:
9788  {
9789  VALUE src = node->nd_lit;
9790  nd_set_type(node, NODE_LIT);
9791  node->nd_lit = reg_compile(src, options);
9792  }
9793  break;
9794  default:
9795  node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
9796  case NODE_DSTR:
9797  if (options & RE_OPTION_ONCE) {
9799  }
9800  else {
9801  nd_set_type(node, NODE_DREGX);
9802  }
9803  node->nd_cflag = options & RE_OPTION_MASK;
9804  if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
9805  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
9806  if (nd_type(list->nd_head) == NODE_STR) {
9807  VALUE tail = list->nd_head->nd_lit;
9808  if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
9809  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
9810  if (!literal_concat0(parser, lit, tail)) {
9811  node = 0;
9812  break;
9813  }
9814  rb_str_resize(tail, 0);
9815  prev->nd_next = list->nd_next;
9816  rb_gc_force_recycle((VALUE)list->nd_head);
9817  rb_gc_force_recycle((VALUE)list);
9818  list = prev;
9819  }
9820  else {
9821  prev = list;
9822  }
9823  }
9824  else {
9825  prev = 0;
9826  }
9827  }
9828  if (!node->nd_next) {
9829  VALUE src = node->nd_lit;
9830  nd_set_type(node, NODE_LIT);
9831  node->nd_lit = reg_compile(src, options);
9832  }
9833  break;
9834  }
9835  (yyval.node) = node;
9836  /*%
9837  $$ = dispatch2(regexp_literal, $2, $3);
9838  %*/
9839  }
9840  break;
9841 
9842  case 459:
9843 
9844 /* Line 1806 of yacc.c */
9845 #line 3953 "parse.y"
9846  {
9847  /*%%%*/
9848  (yyval.node) = NEW_ZARRAY();
9849  /*%
9850  $$ = dispatch0(words_new);
9851  $$ = dispatch1(array, $$);
9852  %*/
9853  }
9854  break;
9855 
9856  case 460:
9857 
9858 /* Line 1806 of yacc.c */
9859 #line 3962 "parse.y"
9860  {
9861  /*%%%*/
9862  (yyval.node) = (yyvsp[(2) - (3)].node);
9863  /*%
9864  $$ = dispatch1(array, $2);
9865  %*/
9866  }
9867  break;
9868 
9869  case 461:
9870 
9871 /* Line 1806 of yacc.c */
9872 #line 3972 "parse.y"
9873  {
9874  /*%%%*/
9875  (yyval.node) = 0;
9876  /*%
9877  $$ = dispatch0(words_new);
9878  %*/
9879  }
9880  break;
9881 
9882  case 462:
9883 
9884 /* Line 1806 of yacc.c */
9885 #line 3980 "parse.y"
9886  {
9887  /*%%%*/
9888  (yyval.node) = list_append((yyvsp[(1) - (3)].node), evstr2dstr((yyvsp[(2) - (3)].node)));
9889  /*%
9890  $$ = dispatch2(words_add, $1, $2);
9891  %*/
9892  }
9893  break;
9894 
9895  case 464:
9896 
9897 /* Line 1806 of yacc.c */
9898 #line 3998 "parse.y"
9899  {
9900  /*%%%*/
9901  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
9902  /*%
9903  $$ = dispatch2(word_add, $1, $2);
9904  %*/
9905  }
9906  break;
9907 
9908  case 465:
9909 
9910 /* Line 1806 of yacc.c */
9911 #line 4008 "parse.y"
9912  {
9913  /*%%%*/
9914  (yyval.node) = NEW_ZARRAY();
9915  /*%
9916  $$ = dispatch0(symbols_new);
9917  $$ = dispatch1(array, $$);
9918  %*/
9919  }
9920  break;
9921 
9922  case 466:
9923 
9924 /* Line 1806 of yacc.c */
9925 #line 4017 "parse.y"
9926  {
9927  /*%%%*/
9928  (yyval.node) = (yyvsp[(2) - (3)].node);
9929  /*%
9930  $$ = dispatch1(array, $2);
9931  %*/
9932  }
9933  break;
9934 
9935  case 467:
9936 
9937 /* Line 1806 of yacc.c */
9938 #line 4027 "parse.y"
9939  {
9940  /*%%%*/
9941  (yyval.node) = 0;
9942  /*%
9943  $$ = dispatch0(symbols_new);
9944  %*/
9945  }
9946  break;
9947 
9948  case 468:
9949 
9950 /* Line 1806 of yacc.c */
9951 #line 4035 "parse.y"
9952  {
9953  /*%%%*/
9954  (yyvsp[(2) - (3)].node) = evstr2dstr((yyvsp[(2) - (3)].node));
9955  nd_set_type((yyvsp[(2) - (3)].node), NODE_DSYM);
9956  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
9957  /*%
9958  $$ = dispatch2(symbols_add, $1, $2);
9959  %*/
9960  }
9961  break;
9962 
9963  case 469:
9964 
9965 /* Line 1806 of yacc.c */
9966 #line 4047 "parse.y"
9967  {
9968  /*%%%*/
9969  (yyval.node) = NEW_ZARRAY();
9970  /*%
9971  $$ = dispatch0(qwords_new);
9972  $$ = dispatch1(array, $$);
9973  %*/
9974  }
9975  break;
9976 
9977  case 470:
9978 
9979 /* Line 1806 of yacc.c */
9980 #line 4056 "parse.y"
9981  {
9982  /*%%%*/
9983  (yyval.node) = (yyvsp[(2) - (3)].node);
9984  /*%
9985  $$ = dispatch1(array, $2);
9986  %*/
9987  }
9988  break;
9989 
9990  case 471:
9991 
9992 /* Line 1806 of yacc.c */
9993 #line 4066 "parse.y"
9994  {
9995  /*%%%*/
9996  (yyval.node) = NEW_ZARRAY();
9997  /*%
9998  $$ = dispatch0(qsymbols_new);
9999  $$ = dispatch1(array, $$);
10000  %*/
10001  }
10002  break;
10003 
10004  case 472:
10005 
10006 /* Line 1806 of yacc.c */
10007 #line 4075 "parse.y"
10008  {
10009  /*%%%*/
10010  (yyval.node) = (yyvsp[(2) - (3)].node);
10011  /*%
10012  $$ = dispatch1(array, $2);
10013  %*/
10014  }
10015  break;
10016 
10017  case 473:
10018 
10019 /* Line 1806 of yacc.c */
10020 #line 4085 "parse.y"
10021  {
10022  /*%%%*/
10023  (yyval.node) = 0;
10024  /*%
10025  $$ = dispatch0(qwords_new);
10026  %*/
10027  }
10028  break;
10029 
10030  case 474:
10031 
10032 /* Line 1806 of yacc.c */
10033 #line 4093 "parse.y"
10034  {
10035  /*%%%*/
10036  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
10037  /*%
10038  $$ = dispatch2(qwords_add, $1, $2);
10039  %*/
10040  }
10041  break;
10042 
10043  case 475:
10044 
10045 /* Line 1806 of yacc.c */
10046 #line 4103 "parse.y"
10047  {
10048  /*%%%*/
10049  (yyval.node) = 0;
10050  /*%
10051  $$ = dispatch0(qsymbols_new);
10052  %*/
10053  }
10054  break;
10055 
10056  case 476:
10057 
10058 /* Line 1806 of yacc.c */
10059 #line 4111 "parse.y"
10060  {
10061  /*%%%*/
10062  VALUE lit;
10063  lit = (yyvsp[(2) - (3)].node)->nd_lit;
10064  (yyvsp[(2) - (3)].node)->nd_lit = ID2SYM(rb_intern_str(lit));
10065  nd_set_type((yyvsp[(2) - (3)].node), NODE_LIT);
10066  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
10067  /*%
10068  $$ = dispatch2(qsymbols_add, $1, $2);
10069  %*/
10070  }
10071  break;
10072 
10073  case 477:
10074 
10075 /* Line 1806 of yacc.c */
10076 #line 4125 "parse.y"
10077  {
10078  /*%%%*/
10079  (yyval.node) = 0;
10080  /*%
10081  $$ = dispatch0(string_content);
10082  %*/
10083  }
10084  break;
10085 
10086  case 478:
10087 
10088 /* Line 1806 of yacc.c */
10089 #line 4133 "parse.y"
10090  {
10091  /*%%%*/
10092  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
10093  /*%
10094  $$ = dispatch2(string_add, $1, $2);
10095  %*/
10096  }
10097  break;
10098 
10099  case 479:
10100 
10101 /* Line 1806 of yacc.c */
10102 #line 4143 "parse.y"
10103  {
10104  /*%%%*/
10105  (yyval.node) = 0;
10106  /*%
10107  $$ = dispatch0(xstring_new);
10108  %*/
10109  }
10110  break;
10111 
10112  case 480:
10113 
10114 /* Line 1806 of yacc.c */
10115 #line 4151 "parse.y"
10116  {
10117  /*%%%*/
10118  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
10119  /*%
10120  $$ = dispatch2(xstring_add, $1, $2);
10121  %*/
10122  }
10123  break;
10124 
10125  case 481:
10126 
10127 /* Line 1806 of yacc.c */
10128 #line 4161 "parse.y"
10129  {
10130  /*%%%*/
10131  (yyval.node) = 0;
10132  /*%
10133  $$ = dispatch0(regexp_new);
10134  %*/
10135  }
10136  break;
10137 
10138  case 482:
10139 
10140 /* Line 1806 of yacc.c */
10141 #line 4169 "parse.y"
10142  {
10143  /*%%%*/
10144  NODE *head = (yyvsp[(1) - (2)].node), *tail = (yyvsp[(2) - (2)].node);
10145  if (!head) {
10146  (yyval.node) = tail;
10147  }
10148  else if (!tail) {
10149  (yyval.node) = head;
10150  }
10151  else {
10152  switch (nd_type(head)) {
10153  case NODE_STR:
10154  nd_set_type(head, NODE_DSTR);
10155  break;
10156  case NODE_DSTR:
10157  break;
10158  default:
10159  head = list_append(NEW_DSTR(Qnil), head);
10160  break;
10161  }
10162  (yyval.node) = list_append(head, tail);
10163  }
10164  /*%
10165  $$ = dispatch2(regexp_add, $1, $2);
10166  %*/
10167  }
10168  break;
10169 
10170  case 484:
10171 
10172 /* Line 1806 of yacc.c */
10173 #line 4199 "parse.y"
10174  {
10175  (yyval.node) = lex_strterm;
10176  lex_strterm = 0;
10177  lex_state = EXPR_BEG;
10178  }
10179  break;
10180 
10181  case 485:
10182 
10183 /* Line 1806 of yacc.c */
10184 #line 4205 "parse.y"
10185  {
10186  /*%%%*/
10187  lex_strterm = (yyvsp[(2) - (3)].node);
10188  (yyval.node) = NEW_EVSTR((yyvsp[(3) - (3)].node));
10189  /*%
10190  lex_strterm = $<node>2;
10191  $$ = dispatch1(string_dvar, $3);
10192  %*/
10193  }
10194  break;
10195 
10196  case 486:
10197 
10198 /* Line 1806 of yacc.c */
10199 #line 4215 "parse.y"
10200  {
10201  (yyvsp[(1) - (1)].val) = cond_stack;
10202  (yyval.val) = cmdarg_stack;
10203  cond_stack = 0;
10204  cmdarg_stack = 0;
10205  }
10206  break;
10207 
10208  case 487:
10209 
10210 /* Line 1806 of yacc.c */
10211 #line 4221 "parse.y"
10212  {
10213  (yyval.node) = lex_strterm;
10214  lex_strterm = 0;
10215  lex_state = EXPR_BEG;
10216  }
10217  break;
10218 
10219  case 488:
10220 
10221 /* Line 1806 of yacc.c */
10222 #line 4226 "parse.y"
10223  {
10224  (yyval.num) = brace_nest;
10225  brace_nest = 0;
10226  }
10227  break;
10228 
10229  case 489:
10230 
10231 /* Line 1806 of yacc.c */
10232 #line 4231 "parse.y"
10233  {
10234  cond_stack = (yyvsp[(1) - (6)].val);
10235  cmdarg_stack = (yyvsp[(2) - (6)].val);
10236  lex_strterm = (yyvsp[(3) - (6)].node);
10237  brace_nest = (yyvsp[(4) - (6)].num);
10238  /*%%%*/
10239  if ((yyvsp[(5) - (6)].node)) (yyvsp[(5) - (6)].node)->flags &= ~NODE_FL_NEWLINE;
10240  (yyval.node) = new_evstr((yyvsp[(5) - (6)].node));
10241  /*%
10242  $$ = dispatch1(string_embexpr, $5);
10243  %*/
10244  }
10245  break;
10246 
10247  case 490:
10248 
10249 /* Line 1806 of yacc.c */
10250 #line 4246 "parse.y"
10251  {
10252  /*%%%*/
10253  (yyval.node) = NEW_GVAR((yyvsp[(1) - (1)].id));
10254  /*%
10255  $$ = dispatch1(var_ref, $1);
10256  %*/
10257  }
10258  break;
10259 
10260  case 491:
10261 
10262 /* Line 1806 of yacc.c */
10263 #line 4254 "parse.y"
10264  {
10265  /*%%%*/
10266  (yyval.node) = NEW_IVAR((yyvsp[(1) - (1)].id));
10267  /*%
10268  $$ = dispatch1(var_ref, $1);
10269  %*/
10270  }
10271  break;
10272 
10273  case 492:
10274 
10275 /* Line 1806 of yacc.c */
10276 #line 4262 "parse.y"
10277  {
10278  /*%%%*/
10279  (yyval.node) = NEW_CVAR((yyvsp[(1) - (1)].id));
10280  /*%
10281  $$ = dispatch1(var_ref, $1);
10282  %*/
10283  }
10284  break;
10285 
10286  case 494:
10287 
10288 /* Line 1806 of yacc.c */
10289 #line 4273 "parse.y"
10290  {
10291  lex_state = EXPR_END;
10292  /*%%%*/
10293  (yyval.id) = (yyvsp[(2) - (2)].id);
10294  /*%
10295  $$ = dispatch1(symbol, $2);
10296  %*/
10297  }
10298  break;
10299 
10300  case 499:
10301 
10302 /* Line 1806 of yacc.c */
10303 #line 4290 "parse.y"
10304  {
10305  lex_state = EXPR_END;
10306  /*%%%*/
10307  (yyval.node) = dsym_node((yyvsp[(2) - (3)].node));
10308  /*%
10309  $$ = dispatch1(dyna_symbol, $2);
10310  %*/
10311  }
10312  break;
10313 
10314  case 502:
10315 
10316 /* Line 1806 of yacc.c */
10317 #line 4303 "parse.y"
10318  {
10319  /*%%%*/
10320  (yyval.node) = negate_lit((yyvsp[(2) - (2)].node));
10321  /*%
10322  $$ = dispatch2(unary, ripper_intern("-@"), $2);
10323  %*/
10324  }
10325  break;
10326 
10327  case 503:
10328 
10329 /* Line 1806 of yacc.c */
10330 #line 4311 "parse.y"
10331  {
10332  /*%%%*/
10333  (yyval.node) = negate_lit((yyvsp[(2) - (2)].node));
10334  /*%
10335  $$ = dispatch2(unary, ripper_intern("-@"), $2);
10336  %*/
10337  }
10338  break;
10339 
10340  case 509:
10341 
10342 /* Line 1806 of yacc.c */
10343 #line 4327 "parse.y"
10344  {ifndef_ripper((yyval.id) = keyword_nil);}
10345  break;
10346 
10347  case 510:
10348 
10349 /* Line 1806 of yacc.c */
10350 #line 4328 "parse.y"
10351  {ifndef_ripper((yyval.id) = keyword_self);}
10352  break;
10353 
10354  case 511:
10355 
10356 /* Line 1806 of yacc.c */
10357 #line 4329 "parse.y"
10358  {ifndef_ripper((yyval.id) = keyword_true);}
10359  break;
10360 
10361  case 512:
10362 
10363 /* Line 1806 of yacc.c */
10364 #line 4330 "parse.y"
10365  {ifndef_ripper((yyval.id) = keyword_false);}
10366  break;
10367 
10368  case 513:
10369 
10370 /* Line 1806 of yacc.c */
10371 #line 4331 "parse.y"
10372  {ifndef_ripper((yyval.id) = keyword__FILE__);}
10373  break;
10374 
10375  case 514:
10376 
10377 /* Line 1806 of yacc.c */
10378 #line 4332 "parse.y"
10379  {ifndef_ripper((yyval.id) = keyword__LINE__);}
10380  break;
10381 
10382  case 515:
10383 
10384 /* Line 1806 of yacc.c */
10385 #line 4333 "parse.y"
10386  {ifndef_ripper((yyval.id) = keyword__ENCODING__);}
10387  break;
10388 
10389  case 516:
10390 
10391 /* Line 1806 of yacc.c */
10392 #line 4337 "parse.y"
10393  {
10394  /*%%%*/
10395  if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0);
10396  /*%
10397  if (id_is_var(get_id($1))) {
10398  $$ = dispatch1(var_ref, $1);
10399  }
10400  else {
10401  $$ = dispatch1(vcall, $1);
10402  }
10403  %*/
10404  }
10405  break;
10406 
10407  case 517:
10408 
10409 /* Line 1806 of yacc.c */
10410 #line 4350 "parse.y"
10411  {
10412  /*%%%*/
10413  if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0);
10414  /*%
10415  $$ = dispatch1(var_ref, $1);
10416  %*/
10417  }
10418  break;
10419 
10420  case 518:
10421 
10422 /* Line 1806 of yacc.c */
10423 #line 4360 "parse.y"
10424  {
10425  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
10426  /*%%%*/
10427  /*%
10428  $$ = dispatch1(var_field, $$);
10429  %*/
10430  }
10431  break;
10432 
10433  case 519:
10434 
10435 /* Line 1806 of yacc.c */
10436 #line 4368 "parse.y"
10437  {
10438  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
10439  /*%%%*/
10440  /*%
10441  $$ = dispatch1(var_field, $$);
10442  %*/
10443  }
10444  break;
10445 
10446  case 522:
10447 
10448 /* Line 1806 of yacc.c */
10449 #line 4382 "parse.y"
10450  {
10451  /*%%%*/
10452  (yyval.node) = 0;
10453  /*%
10454  $$ = Qnil;
10455  %*/
10456  }
10457  break;
10458 
10459  case 523:
10460 
10461 /* Line 1806 of yacc.c */
10462 #line 4390 "parse.y"
10463  {
10464  lex_state = EXPR_BEG;
10465  command_start = TRUE;
10466  }
10467  break;
10468 
10469  case 524:
10470 
10471 /* Line 1806 of yacc.c */
10472 #line 4395 "parse.y"
10473  {
10474  (yyval.node) = (yyvsp[(3) - (4)].node);
10475  }
10476  break;
10477 
10478  case 525:
10479 
10480 /* Line 1806 of yacc.c */
10481 #line 4399 "parse.y"
10482  {
10483  /*%%%*/
10484  yyerrok;
10485  (yyval.node) = 0;
10486  /*%
10487  yyerrok;
10488  $$ = Qnil;
10489  %*/
10490  }
10491  break;
10492 
10493  case 526:
10494 
10495 /* Line 1806 of yacc.c */
10496 #line 4411 "parse.y"
10497  {
10498  /*%%%*/
10499  (yyval.node) = (yyvsp[(2) - (3)].node);
10500  /*%
10501  $$ = dispatch1(paren, $2);
10502  %*/
10503  lex_state = EXPR_BEG;
10504  command_start = TRUE;
10505  }
10506  break;
10507 
10508  case 527:
10509 
10510 /* Line 1806 of yacc.c */
10511 #line 4421 "parse.y"
10512  {
10513  (yyval.node) = (yyvsp[(1) - (2)].node);
10514  lex_state = EXPR_BEG;
10515  command_start = TRUE;
10516  }
10517  break;
10518 
10519  case 528:
10520 
10521 /* Line 1806 of yacc.c */
10522 #line 4429 "parse.y"
10523  {
10524  (yyval.node) = new_args_tail((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id));
10525  }
10526  break;
10527 
10528  case 529:
10529 
10530 /* Line 1806 of yacc.c */
10531 #line 4433 "parse.y"
10532  {
10533  (yyval.node) = new_args_tail((yyvsp[(1) - (2)].node), Qnone, (yyvsp[(2) - (2)].id));
10534  }
10535  break;
10536 
10537  case 530:
10538 
10539 /* Line 1806 of yacc.c */
10540 #line 4437 "parse.y"
10541  {
10542  (yyval.node) = new_args_tail(Qnone, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id));
10543  }
10544  break;
10545 
10546  case 531:
10547 
10548 /* Line 1806 of yacc.c */
10549 #line 4441 "parse.y"
10550  {
10551  (yyval.node) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].id));
10552  }
10553  break;
10554 
10555  case 532:
10556 
10557 /* Line 1806 of yacc.c */
10558 #line 4447 "parse.y"
10559  {
10560  (yyval.node) = (yyvsp[(2) - (2)].node);
10561  }
10562  break;
10563 
10564  case 533:
10565 
10566 /* Line 1806 of yacc.c */
10567 #line 4451 "parse.y"
10568  {
10569  (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
10570  }
10571  break;
10572 
10573  case 534:
10574 
10575 /* Line 1806 of yacc.c */
10576 #line 4457 "parse.y"
10577  {
10578  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), Qnone, (yyvsp[(6) - (6)].node));
10579  }
10580  break;
10581 
10582  case 535:
10583 
10584 /* Line 1806 of yacc.c */
10585 #line 4461 "parse.y"
10586  {
10587  (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].node));
10588  }
10589  break;
10590 
10591  case 536:
10592 
10593 /* Line 1806 of yacc.c */
10594 #line 4465 "parse.y"
10595  {
10596  (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), Qnone, Qnone, (yyvsp[(4) - (4)].node));
10597  }
10598  break;
10599 
10600  case 537:
10601 
10602 /* Line 1806 of yacc.c */
10603 #line 4469 "parse.y"
10604  {
10605  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), Qnone, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10606  }
10607  break;
10608 
10609  case 538:
10610 
10611 /* Line 1806 of yacc.c */
10612 #line 4473 "parse.y"
10613  {
10614  (yyval.node) = new_args((yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
10615  }
10616  break;
10617 
10618  case 539:
10619 
10620 /* Line 1806 of yacc.c */
10621 #line 4477 "parse.y"
10622  {
10623  (yyval.node) = new_args((yyvsp[(1) - (6)].node), Qnone, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10624  }
10625  break;
10626 
10627  case 540:
10628 
10629 /* Line 1806 of yacc.c */
10630 #line 4481 "parse.y"
10631  {
10632  (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].node));
10633  }
10634  break;
10635 
10636  case 541:
10637 
10638 /* Line 1806 of yacc.c */
10639 #line 4485 "parse.y"
10640  {
10641  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
10642  }
10643  break;
10644 
10645  case 542:
10646 
10647 /* Line 1806 of yacc.c */
10648 #line 4489 "parse.y"
10649  {
10650  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10651  }
10652  break;
10653 
10654  case 543:
10655 
10656 /* Line 1806 of yacc.c */
10657 #line 4493 "parse.y"
10658  {
10659  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (2)].node), Qnone, Qnone, (yyvsp[(2) - (2)].node));
10660  }
10661  break;
10662 
10663  case 544:
10664 
10665 /* Line 1806 of yacc.c */
10666 #line 4497 "parse.y"
10667  {
10668  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
10669  }
10670  break;
10671 
10672  case 545:
10673 
10674 /* Line 1806 of yacc.c */
10675 #line 4501 "parse.y"
10676  {
10677  (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].id), Qnone, (yyvsp[(2) - (2)].node));
10678  }
10679  break;
10680 
10681  case 546:
10682 
10683 /* Line 1806 of yacc.c */
10684 #line 4505 "parse.y"
10685  {
10686  (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
10687  }
10688  break;
10689 
10690  case 547:
10691 
10692 /* Line 1806 of yacc.c */
10693 #line 4509 "parse.y"
10694  {
10695  (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].node));
10696  }
10697  break;
10698 
10699  case 548:
10700 
10701 /* Line 1806 of yacc.c */
10702 #line 4513 "parse.y"
10703  {
10704  (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
10705  (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.node));
10706  }
10707  break;
10708 
10709  case 549:
10710 
10711 /* Line 1806 of yacc.c */
10712 #line 4520 "parse.y"
10713  {
10714  /*%%%*/
10715  yyerror("formal argument cannot be a constant");
10716  (yyval.id) = 0;
10717  /*%
10718  $$ = dispatch1(param_error, $1);
10719  %*/
10720  }
10721  break;
10722 
10723  case 550:
10724 
10725 /* Line 1806 of yacc.c */
10726 #line 4529 "parse.y"
10727  {
10728  /*%%%*/
10729  yyerror("formal argument cannot be an instance variable");
10730  (yyval.id) = 0;
10731  /*%
10732  $$ = dispatch1(param_error, $1);
10733  %*/
10734  }
10735  break;
10736 
10737  case 551:
10738 
10739 /* Line 1806 of yacc.c */
10740 #line 4538 "parse.y"
10741  {
10742  /*%%%*/
10743  yyerror("formal argument cannot be a global variable");
10744  (yyval.id) = 0;
10745  /*%
10746  $$ = dispatch1(param_error, $1);
10747  %*/
10748  }
10749  break;
10750 
10751  case 552:
10752 
10753 /* Line 1806 of yacc.c */
10754 #line 4547 "parse.y"
10755  {
10756  /*%%%*/
10757  yyerror("formal argument cannot be a class variable");
10758  (yyval.id) = 0;
10759  /*%
10760  $$ = dispatch1(param_error, $1);
10761  %*/
10762  }
10763  break;
10764 
10765  case 554:
10766 
10767 /* Line 1806 of yacc.c */
10768 #line 4559 "parse.y"
10769  {
10770  formal_argument(get_id((yyvsp[(1) - (1)].id)));
10771  (yyval.id) = (yyvsp[(1) - (1)].id);
10772  }
10773  break;
10774 
10775  case 555:
10776 
10777 /* Line 1806 of yacc.c */
10778 #line 4566 "parse.y"
10779  {
10780  arg_var(get_id((yyvsp[(1) - (1)].id)));
10781  /*%%%*/
10782  (yyval.node) = NEW_ARGS_AUX((yyvsp[(1) - (1)].id), 1);
10783  /*%
10784  $$ = get_value($1);
10785  %*/
10786  }
10787  break;
10788 
10789  case 556:
10790 
10791 /* Line 1806 of yacc.c */
10792 #line 4575 "parse.y"
10793  {
10794  ID tid = internal_id();
10795  arg_var(tid);
10796  /*%%%*/
10797  if (dyna_in_block()) {
10798  (yyvsp[(2) - (3)].node)->nd_value = NEW_DVAR(tid);
10799  }
10800  else {
10801  (yyvsp[(2) - (3)].node)->nd_value = NEW_LVAR(tid);
10802  }
10803  (yyval.node) = NEW_ARGS_AUX(tid, 1);
10804  (yyval.node)->nd_next = (yyvsp[(2) - (3)].node);
10805  /*%
10806  $$ = dispatch1(mlhs_paren, $2);
10807  %*/
10808  }
10809  break;
10810 
10811  case 558:
10812 
10813 /* Line 1806 of yacc.c */
10814 #line 4601 "parse.y"
10815  {
10816  /*%%%*/
10817  (yyval.node) = (yyvsp[(1) - (3)].node);
10818  (yyval.node)->nd_plen++;
10819  (yyval.node)->nd_next = block_append((yyval.node)->nd_next, (yyvsp[(3) - (3)].node)->nd_next);
10820  rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].node));
10821  /*%
10822  $$ = rb_ary_push($1, $3);
10823  %*/
10824  }
10825  break;
10826 
10827  case 559:
10828 
10829 /* Line 1806 of yacc.c */
10830 #line 4614 "parse.y"
10831  {
10832  arg_var(formal_argument(get_id((yyvsp[(1) - (2)].id))));
10833  (yyval.node) = assignable((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node));
10834  /*%%%*/
10835  (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10836  /*%
10837  $$ = rb_assoc_new($$, $2);
10838  %*/
10839  }
10840  break;
10841 
10842  case 560:
10843 
10844 /* Line 1806 of yacc.c */
10845 #line 4626 "parse.y"
10846  {
10847  arg_var(formal_argument(get_id((yyvsp[(1) - (2)].id))));
10848  (yyval.node) = assignable((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node));
10849  /*%%%*/
10850  (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10851  /*%
10852  $$ = rb_assoc_new($$, $2);
10853  %*/
10854  }
10855  break;
10856 
10857  case 561:
10858 
10859 /* Line 1806 of yacc.c */
10860 #line 4638 "parse.y"
10861  {
10862  /*%%%*/
10863  (yyval.node) = (yyvsp[(1) - (1)].node);
10864  /*%
10865  $$ = rb_ary_new3(1, $1);
10866  %*/
10867  }
10868  break;
10869 
10870  case 562:
10871 
10872 /* Line 1806 of yacc.c */
10873 #line 4646 "parse.y"
10874  {
10875  /*%%%*/
10876  NODE *kws = (yyvsp[(1) - (3)].node);
10877 
10878  while (kws->nd_next) {
10879  kws = kws->nd_next;
10880  }
10881  kws->nd_next = (yyvsp[(3) - (3)].node);
10882  (yyval.node) = (yyvsp[(1) - (3)].node);
10883  /*%
10884  $$ = rb_ary_push($1, $3);
10885  %*/
10886  }
10887  break;
10888 
10889  case 563:
10890 
10891 /* Line 1806 of yacc.c */
10892 #line 4663 "parse.y"
10893  {
10894  /*%%%*/
10895  (yyval.node) = (yyvsp[(1) - (1)].node);
10896  /*%
10897  $$ = rb_ary_new3(1, $1);
10898  %*/
10899  }
10900  break;
10901 
10902  case 564:
10903 
10904 /* Line 1806 of yacc.c */
10905 #line 4671 "parse.y"
10906  {
10907  /*%%%*/
10908  NODE *kws = (yyvsp[(1) - (3)].node);
10909 
10910  while (kws->nd_next) {
10911  kws = kws->nd_next;
10912  }
10913  kws->nd_next = (yyvsp[(3) - (3)].node);
10914  (yyval.node) = (yyvsp[(1) - (3)].node);
10915  /*%
10916  $$ = rb_ary_push($1, $3);
10917  %*/
10918  }
10919  break;
10920 
10921  case 567:
10922 
10923 /* Line 1806 of yacc.c */
10924 #line 4691 "parse.y"
10925  {
10926  shadowing_lvar(get_id((yyvsp[(2) - (2)].id)));
10927  (yyval.id) = (yyvsp[(2) - (2)].id);
10928  }
10929  break;
10930 
10931  case 568:
10932 
10933 /* Line 1806 of yacc.c */
10934 #line 4696 "parse.y"
10935  {
10936  (yyval.id) = internal_id();
10937  }
10938  break;
10939 
10940  case 569:
10941 
10942 /* Line 1806 of yacc.c */
10943 #line 4702 "parse.y"
10944  {
10945  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].id))));
10946  (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node));
10947  /*%%%*/
10948  (yyval.node) = NEW_OPT_ARG(0, (yyval.node));
10949  /*%
10950  $$ = rb_assoc_new($$, $3);
10951  %*/
10952  }
10953  break;
10954 
10955  case 570:
10956 
10957 /* Line 1806 of yacc.c */
10958 #line 4714 "parse.y"
10959  {
10960  arg_var(formal_argument(get_id((yyvsp[(1) - (3)].id))));
10961  (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node));
10962  /*%%%*/
10963  (yyval.node) = NEW_OPT_ARG(0, (yyval.node));
10964  /*%
10965  $$ = rb_assoc_new($$, $3);
10966  %*/
10967  }
10968  break;
10969 
10970  case 571:
10971 
10972 /* Line 1806 of yacc.c */
10973 #line 4726 "parse.y"
10974  {
10975  /*%%%*/
10976  (yyval.node) = (yyvsp[(1) - (1)].node);
10977  /*%
10978  $$ = rb_ary_new3(1, $1);
10979  %*/
10980  }
10981  break;
10982 
10983  case 572:
10984 
10985 /* Line 1806 of yacc.c */
10986 #line 4734 "parse.y"
10987  {
10988  /*%%%*/
10989  NODE *opts = (yyvsp[(1) - (3)].node);
10990 
10991  while (opts->nd_next) {
10992  opts = opts->nd_next;
10993  }
10994  opts->nd_next = (yyvsp[(3) - (3)].node);
10995  (yyval.node) = (yyvsp[(1) - (3)].node);
10996  /*%
10997  $$ = rb_ary_push($1, $3);
10998  %*/
10999  }
11000  break;
11001 
11002  case 573:
11003 
11004 /* Line 1806 of yacc.c */
11005 #line 4750 "parse.y"
11006  {
11007  /*%%%*/
11008  (yyval.node) = (yyvsp[(1) - (1)].node);
11009  /*%
11010  $$ = rb_ary_new3(1, $1);
11011  %*/
11012  }
11013  break;
11014 
11015  case 574:
11016 
11017 /* Line 1806 of yacc.c */
11018 #line 4758 "parse.y"
11019  {
11020  /*%%%*/
11021  NODE *opts = (yyvsp[(1) - (3)].node);
11022 
11023  while (opts->nd_next) {
11024  opts = opts->nd_next;
11025  }
11026  opts->nd_next = (yyvsp[(3) - (3)].node);
11027  (yyval.node) = (yyvsp[(1) - (3)].node);
11028  /*%
11029  $$ = rb_ary_push($1, $3);
11030  %*/
11031  }
11032  break;
11033 
11034  case 577:
11035 
11036 /* Line 1806 of yacc.c */
11037 #line 4778 "parse.y"
11038  {
11039  /*%%%*/
11040  if (!is_local_id((yyvsp[(2) - (2)].id)))
11041  yyerror("rest argument must be local variable");
11042  /*% %*/
11043  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id))));
11044  /*%%%*/
11045  (yyval.id) = (yyvsp[(2) - (2)].id);
11046  /*%
11047  $$ = dispatch1(rest_param, $2);
11048  %*/
11049  }
11050  break;
11051 
11052  case 578:
11053 
11054 /* Line 1806 of yacc.c */
11055 #line 4791 "parse.y"
11056  {
11057  /*%%%*/
11058  (yyval.id) = internal_id();
11059  arg_var((yyval.id));
11060  /*%
11061  $$ = dispatch1(rest_param, Qnil);
11062  %*/
11063  }
11064  break;
11065 
11066  case 581:
11067 
11068 /* Line 1806 of yacc.c */
11069 #line 4806 "parse.y"
11070  {
11071  /*%%%*/
11072  if (!is_local_id((yyvsp[(2) - (2)].id)))
11073  yyerror("block argument must be local variable");
11074  else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].id)))
11075  yyerror("duplicated block argument name");
11076  /*% %*/
11077  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id))));
11078  /*%%%*/
11079  (yyval.id) = (yyvsp[(2) - (2)].id);
11080  /*%
11081  $$ = dispatch1(blockarg, $2);
11082  %*/
11083  }
11084  break;
11085 
11086  case 582:
11087 
11088 /* Line 1806 of yacc.c */
11089 #line 4823 "parse.y"
11090  {
11091  (yyval.id) = (yyvsp[(2) - (2)].id);
11092  }
11093  break;
11094 
11095  case 583:
11096 
11097 /* Line 1806 of yacc.c */
11098 #line 4827 "parse.y"
11099  {
11100  /*%%%*/
11101  (yyval.id) = 0;
11102  /*%
11103  $$ = Qundef;
11104  %*/
11105  }
11106  break;
11107 
11108  case 584:
11109 
11110 /* Line 1806 of yacc.c */
11111 #line 4837 "parse.y"
11112  {
11113  /*%%%*/
11114  value_expr((yyvsp[(1) - (1)].node));
11115  (yyval.node) = (yyvsp[(1) - (1)].node);
11116  if (!(yyval.node)) (yyval.node) = NEW_NIL();
11117  /*%
11118  $$ = $1;
11119  %*/
11120  }
11121  break;
11122 
11123  case 585:
11124 
11125 /* Line 1806 of yacc.c */
11126 #line 4846 "parse.y"
11127  {lex_state = EXPR_BEG;}
11128  break;
11129 
11130  case 586:
11131 
11132 /* Line 1806 of yacc.c */
11133 #line 4847 "parse.y"
11134  {
11135  /*%%%*/
11136  if ((yyvsp[(3) - (4)].node) == 0) {
11137  yyerror("can't define singleton method for ().");
11138  }
11139  else {
11140  switch (nd_type((yyvsp[(3) - (4)].node))) {
11141  case NODE_STR:
11142  case NODE_DSTR:
11143  case NODE_XSTR:
11144  case NODE_DXSTR:
11145  case NODE_DREGX:
11146  case NODE_LIT:
11147  case NODE_ARRAY:
11148  case NODE_ZARRAY:
11149  yyerror("can't define singleton method for literals");
11150  default:
11151  value_expr((yyvsp[(3) - (4)].node));
11152  break;
11153  }
11154  }
11155  (yyval.node) = (yyvsp[(3) - (4)].node);
11156  /*%
11157  $$ = dispatch1(paren, $3);
11158  %*/
11159  }
11160  break;
11161 
11162  case 588:
11163 
11164 /* Line 1806 of yacc.c */
11165 #line 4877 "parse.y"
11166  {
11167  /*%%%*/
11168  (yyval.node) = (yyvsp[(1) - (2)].node);
11169  /*%
11170  $$ = dispatch1(assoclist_from_args, $1);
11171  %*/
11172  }
11173  break;
11174 
11175  case 590:
11176 
11177 /* Line 1806 of yacc.c */
11178 #line 4894 "parse.y"
11179  {
11180  /*%%%*/
11181  (yyval.node) = list_concat((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
11182  /*%
11183  $$ = rb_ary_push($1, $3);
11184  %*/
11185  }
11186  break;
11187 
11188  case 591:
11189 
11190 /* Line 1806 of yacc.c */
11191 #line 4904 "parse.y"
11192  {
11193  /*%%%*/
11194  (yyval.node) = list_append(NEW_LIST((yyvsp[(1) - (3)].node)), (yyvsp[(3) - (3)].node));
11195  /*%
11196  $$ = dispatch2(assoc_new, $1, $3);
11197  %*/
11198  }
11199  break;
11200 
11201  case 592:
11202 
11203 /* Line 1806 of yacc.c */
11204 #line 4912 "parse.y"
11205  {
11206  /*%%%*/
11207  (yyval.node) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].id)))), (yyvsp[(2) - (2)].node));
11208  /*%
11209  $$ = dispatch2(assoc_new, $1, $2);
11210  %*/
11211  }
11212  break;
11213 
11214  case 593:
11215 
11216 /* Line 1806 of yacc.c */
11217 #line 4920 "parse.y"
11218  {
11219  /*%%%*/
11220  (yyval.node) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].node));
11221  /*%
11222  $$ = dispatch1(assoc_splat, $2);
11223  %*/
11224  }
11225  break;
11226 
11227  case 615:
11228 
11229 /* Line 1806 of yacc.c */
11230 #line 4978 "parse.y"
11231  {yyerrok;}
11232  break;
11233 
11234  case 618:
11235 
11236 /* Line 1806 of yacc.c */
11237 #line 4983 "parse.y"
11238  {yyerrok;}
11239  break;
11240 
11241  case 619:
11242 
11243 /* Line 1806 of yacc.c */
11244 #line 4987 "parse.y"
11245  {
11246  /*%%%*/
11247  (yyval.node) = 0;
11248  /*%
11249  $$ = Qundef;
11250  %*/
11251  }
11252  break;
11253 
11254 
11255 
11256 /* Line 1806 of yacc.c */
11257 #line 11256 "parse.c"
11258  default: break;
11259  }
11260  /* User semantic actions sometimes alter yychar, and that requires
11261  that yytoken be updated with the new translation. We take the
11262  approach of translating immediately before every use of yytoken.
11263  One alternative is translating here after every semantic action,
11264  but that translation would be missed if the semantic action invokes
11265  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11266  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
11267  incorrect destructor might then be invoked immediately. In the
11268  case of YYERROR or YYBACKUP, subsequent parser actions might lead
11269  to an incorrect destructor call or verbose syntax error message
11270  before the lookahead is translated. */
11271  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11272 
11273  YYPOPSTACK (yylen);
11274  yylen = 0;
11275  YY_STACK_PRINT (yyss, yyssp);
11276 
11277  *++yyvsp = yyval;
11278 
11279  /* Now `shift' the result of the reduction. Determine what state
11280  that goes to, based on the state we popped back to and the rule
11281  number reduced by. */
11282 
11283  yyn = yyr1[yyn];
11284 
11285  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
11286  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
11287  yystate = yytable[yystate];
11288  else
11289  yystate = yydefgoto[yyn - YYNTOKENS];
11290 
11291  goto yynewstate;
11292 
11293 
11294 /*------------------------------------.
11295 | yyerrlab -- here on detecting error |
11296 `------------------------------------*/
11297 yyerrlab:
11298  /* Make sure we have latest lookahead translation. See comments at
11299  user semantic actions for why this is necessary. */
11300  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
11301 
11302  /* If not already recovering from an error, report this error. */
11303  if (!yyerrstatus)
11304  {
11305  ++yynerrs;
11306 #if ! YYERROR_VERBOSE
11307  parser_yyerror (parser, YY_("syntax error"));
11308 #else
11309 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
11310  yyssp, yytoken)
11311  {
11312  char const *yymsgp = YY_("syntax error");
11313  int yysyntax_error_status;
11314  yysyntax_error_status = YYSYNTAX_ERROR;
11315  if (yysyntax_error_status == 0)
11316  yymsgp = yymsg;
11317  else if (yysyntax_error_status == 1)
11318  {
11319  if (yymsg != yymsgbuf)
11320  YYSTACK_FREE (yymsg);
11321  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11322  if (!yymsg)
11323  {
11324  yymsg = yymsgbuf;
11325  yymsg_alloc = sizeof yymsgbuf;
11326  yysyntax_error_status = 2;
11327  }
11328  else
11329  {
11330  yysyntax_error_status = YYSYNTAX_ERROR;
11331  yymsgp = yymsg;
11332  }
11333  }
11334  parser_yyerror (parser, yymsgp);
11335  if (yysyntax_error_status == 2)
11336  goto yyexhaustedlab;
11337  }
11338 # undef YYSYNTAX_ERROR
11339 #endif
11340  }
11341 
11342 
11343 
11344  if (yyerrstatus == 3)
11345  {
11346  /* If just tried and failed to reuse lookahead token after an
11347  error, discard it. */
11348 
11349  if (yychar <= YYEOF)
11350  {
11351  /* Return failure if at end of input. */
11352  if (yychar == YYEOF)
11353  YYABORT;
11354  }
11355  else
11356  {
11357  yydestruct ("Error: discarding",
11358  yytoken, &yylval, parser);
11359  yychar = YYEMPTY;
11360  }
11361  }
11362 
11363  /* Else will try to reuse lookahead token after shifting the error
11364  token. */
11365  goto yyerrlab1;
11366 
11367 
11368 /*---------------------------------------------------.
11369 | yyerrorlab -- error raised explicitly by YYERROR. |
11370 `---------------------------------------------------*/
11371 yyerrorlab:
11372 
11373  /* Pacify compilers like GCC when the user code never invokes
11374  YYERROR and the label yyerrorlab therefore never appears in user
11375  code. */
11376  if (/*CONSTCOND*/ 0)
11377  goto yyerrorlab;
11378 
11379  /* Do not reclaim the symbols of the rule which action triggered
11380  this YYERROR. */
11381  YYPOPSTACK (yylen);
11382  yylen = 0;
11383  YY_STACK_PRINT (yyss, yyssp);
11384  yystate = *yyssp;
11385  goto yyerrlab1;
11386 
11387 
11388 /*-------------------------------------------------------------.
11389 | yyerrlab1 -- common code for both syntax error and YYERROR. |
11390 `-------------------------------------------------------------*/
11391 yyerrlab1:
11392  yyerrstatus = 3; /* Each real token shifted decrements this. */
11393 
11394  for (;;)
11395  {
11396  yyn = yypact[yystate];
11397  if (!yypact_value_is_default (yyn))
11398  {
11399  yyn += YYTERROR;
11400  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11401  {
11402  yyn = yytable[yyn];
11403  if (0 < yyn)
11404  break;
11405  }
11406  }
11407 
11408  /* Pop the current state because it cannot handle the error token. */
11409  if (yyssp == yyss)
11410  YYABORT;
11411 
11412 
11413  yydestruct ("Error: popping",
11414  yystos[yystate], yyvsp, parser);
11415  YYPOPSTACK (1);
11416  yystate = *yyssp;
11417  YY_STACK_PRINT (yyss, yyssp);
11418  }
11419 
11420  *++yyvsp = yylval;
11421 
11422 
11423  /* Shift the error token. */
11424  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11425 
11426  yystate = yyn;
11427  goto yynewstate;
11428 
11429 
11430 /*-------------------------------------.
11431 | yyacceptlab -- YYACCEPT comes here. |
11432 `-------------------------------------*/
11433 yyacceptlab:
11434  yyresult = 0;
11435  goto yyreturn;
11436 
11437 /*-----------------------------------.
11438 | yyabortlab -- YYABORT comes here. |
11439 `-----------------------------------*/
11440 yyabortlab:
11441  yyresult = 1;
11442  goto yyreturn;
11443 
11444 #if !defined(yyoverflow) || YYERROR_VERBOSE
11445 /*-------------------------------------------------.
11446 | yyexhaustedlab -- memory exhaustion comes here. |
11447 `-------------------------------------------------*/
11448 yyexhaustedlab:
11449  parser_yyerror (parser, YY_("memory exhausted"));
11450  yyresult = 2;
11451  /* Fall through. */
11452 #endif
11453 
11454 yyreturn:
11455  if (yychar != YYEMPTY)
11456  {
11457  /* Make sure we have latest lookahead translation. See comments at
11458  user semantic actions for why this is necessary. */
11459  yytoken = YYTRANSLATE (yychar);
11460  yydestruct ("Cleanup: discarding lookahead",
11461  yytoken, &yylval, parser);
11462  }
11463  /* Do not reclaim the symbols of the rule which action triggered
11464  this YYABORT or YYACCEPT. */
11465  YYPOPSTACK (yylen);
11466  YY_STACK_PRINT (yyss, yyssp);
11467  while (yyssp != yyss)
11468  {
11469  yydestruct ("Cleanup: popping",
11470  yystos[*yyssp], yyvsp, parser);
11471  YYPOPSTACK (1);
11472  }
11473 #ifndef yyoverflow
11474  if (yyss != yyssa)
11475  YYSTACK_FREE (yyss);
11476 #endif
11477 #if YYERROR_VERBOSE
11478  if (yymsg != yymsgbuf)
11479  YYSTACK_FREE (yymsg);
11480 #endif
11481  /* Make sure YYID is used. */
11482  return YYID (yyresult);
11483 }
11484 
11485 
11486 
11487 /* Line 2067 of yacc.c */
11488 #line 4995 "parse.y"
11489 
11490 # undef parser
11491 # undef yylex
11492 # undef yylval
11493 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
11494 
11495 static int parser_regx_options(struct parser_params*);
11496 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11497 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11498 static int parser_parse_string(struct parser_params*,NODE*);
11499 static int parser_here_document(struct parser_params*,NODE*);
11500 
11501 
11502 # define nextc() parser_nextc(parser)
11503 # define pushback(c) parser_pushback(parser, (c))
11504 # define newtok() parser_newtok(parser)
11505 # define tokspace(n) parser_tokspace(parser, (n))
11506 # define tokadd(c) parser_tokadd(parser, (c))
11507 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
11508 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
11509 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
11510 # define regx_options() parser_regx_options(parser)
11511 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11512 # define parse_string(n) parser_parse_string(parser,(n))
11513 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
11514 # define here_document(n) parser_here_document(parser,(n))
11515 # define heredoc_identifier() parser_heredoc_identifier(parser)
11516 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
11517 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
11518 
11519 #ifndef RIPPER
11520 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11521 # define set_yylval_num(x) (yylval.num = (x))
11522 # define set_yylval_id(x) (yylval.id = (x))
11523 # define set_yylval_name(x) (yylval.id = (x))
11524 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11525 # define set_yylval_node(x) (yylval.node = (x))
11526 # define yylval_id() (yylval.id)
11527 #else
11528 static inline VALUE
11529 ripper_yylval_id(ID x)
11530 {
11531  return (VALUE)NEW_LASGN(x, ID2SYM(x));
11532 }
11533 # define set_yylval_str(x) (void)(x)
11534 # define set_yylval_num(x) (void)(x)
11535 # define set_yylval_id(x) (void)(x)
11536 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11537 # define set_yylval_literal(x) (void)(x)
11538 # define set_yylval_node(x) (void)(x)
11539 # define yylval_id() yylval.id
11540 #endif
11541 
11542 #ifndef RIPPER
11543 #define ripper_flush(p) (void)(p)
11544 #else
11545 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11546 
11547 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11548 
11549 static int
11550 ripper_has_scan_event(struct parser_params *parser)
11551 {
11552 
11553  if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11554  return lex_p > parser->tokp;
11555 }
11556 
11557 static VALUE
11558 ripper_scan_event_val(struct parser_params *parser, int t)
11559 {
11560  VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11561  VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11562  ripper_flush(parser);
11563  return rval;
11564 }
11565 
11566 static void
11567 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11568 {
11569  if (!ripper_has_scan_event(parser)) return;
11570  yylval_rval = ripper_scan_event_val(parser, t);
11571 }
11572 
11573 static void
11574 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11575 {
11576  if (!ripper_has_scan_event(parser)) return;
11577  (void)ripper_scan_event_val(parser, t);
11578 }
11579 
11580 static void
11581 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11582 {
11583  int saved_line = ruby_sourceline;
11584  const char *saved_tokp = parser->tokp;
11585 
11586  ruby_sourceline = parser->delayed_line;
11587  parser->tokp = lex_pbeg + parser->delayed_col;
11588  yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11589  parser->delayed = Qnil;
11590  ruby_sourceline = saved_line;
11591  parser->tokp = saved_tokp;
11592 }
11593 #endif /* RIPPER */
11594 
11595 #include "ruby/regex.h"
11596 #include "ruby/util.h"
11597 
11598 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11599  since ours (we hope) works properly with all combinations of
11600  machines, compilers, `char' and `unsigned char' argument types.
11601  (Per Bothner suggested the basic approach.) */
11602 #undef SIGN_EXTEND_CHAR
11603 #if __STDC__
11604 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11605 #else /* not __STDC__ */
11606 /* As in Harbison and Steele. */
11607 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11608 #endif
11609 
11610 #define parser_encoding_name() (current_enc->name)
11611 #define parser_mbclen() mbclen((lex_p-1),lex_pend,current_enc)
11612 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
11613 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11614 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11615 
11616 #define parser_isascii() ISASCII(*(lex_p-1))
11617 
11618 #ifndef RIPPER
11619 static int
11620 token_info_get_column(struct parser_params *parser, const char *token)
11621 {
11622  int column = 1;
11623  const char *p, *pend = lex_p - strlen(token);
11624  for (p = lex_pbeg; p < pend; p++) {
11625  if (*p == '\t') {
11626  column = (((column - 1) / 8) + 1) * 8;
11627  }
11628  column++;
11629  }
11630  return column;
11631 }
11632 
11633 static int
11634 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11635 {
11636  const char *p, *pend = lex_p - strlen(token);
11637  for (p = lex_pbeg; p < pend; p++) {
11638  if (*p != ' ' && *p != '\t') {
11639  return 1;
11640  }
11641  }
11642  return 0;
11643 }
11644 
11645 #undef token_info_push
11646 static void
11647 token_info_push(struct parser_params *parser, const char *token)
11648 {
11649  token_info *ptinfo;
11650 
11651  if (!parser->parser_token_info_enabled) return;
11652  ptinfo = ALLOC(token_info);
11653  ptinfo->token = token;
11654  ptinfo->linenum = ruby_sourceline;
11655  ptinfo->column = token_info_get_column(parser, token);
11656  ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11657  ptinfo->next = parser->parser_token_info;
11658 
11659  parser->parser_token_info = ptinfo;
11660 }
11661 
11662 #undef token_info_pop
11663 static void
11664 token_info_pop(struct parser_params *parser, const char *token)
11665 {
11666  int linenum;
11667  token_info *ptinfo = parser->parser_token_info;
11668 
11669  if (!ptinfo) return;
11670  parser->parser_token_info = ptinfo->next;
11671  if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11672  goto finish;
11673  }
11674  linenum = ruby_sourceline;
11675  if (linenum == ptinfo->linenum) { /* SKIP */
11676  goto finish;
11677  }
11678  if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11679  goto finish;
11680  }
11681  if (parser->parser_token_info_enabled) {
11683  "mismatched indentations at '%s' with '%s' at %d",
11684  token, ptinfo->token, ptinfo->linenum);
11685  }
11686 
11687  finish:
11688  xfree(ptinfo);
11689 }
11690 #endif /* RIPPER */
11691 
11692 static int
11693 parser_yyerror(struct parser_params *parser, const char *msg)
11694 {
11695 #ifndef RIPPER
11696  const int max_line_margin = 30;
11697  const char *p, *pe;
11698  char *buf;
11699  long len;
11700  int i;
11701 
11702  compile_error(PARSER_ARG "%s", msg);
11703  p = lex_p;
11704  while (lex_pbeg <= p) {
11705  if (*p == '\n') break;
11706  p--;
11707  }
11708  p++;
11709 
11710  pe = lex_p;
11711  while (pe < lex_pend) {
11712  if (*pe == '\n') break;
11713  pe++;
11714  }
11715 
11716  len = pe - p;
11717  if (len > 4) {
11718  char *p2;
11719  const char *pre = "", *post = "";
11720 
11721  if (len > max_line_margin * 2 + 10) {
11722  if (lex_p - p > max_line_margin) {
11723  p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11724  pre = "...";
11725  }
11726  if (pe - lex_p > max_line_margin) {
11727  pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11728  post = "...";
11729  }
11730  len = pe - p;
11731  }
11732  buf = ALLOCA_N(char, len+2);
11733  MEMCPY(buf, p, char, len);
11734  buf[len] = '\0';
11735  rb_compile_error_append("%s%s%s", pre, buf, post);
11736 
11737  i = (int)(lex_p - p);
11738  p2 = buf; pe = buf + len;
11739 
11740  while (p2 < pe) {
11741  if (*p2 != '\t') *p2 = ' ';
11742  p2++;
11743  }
11744  buf[i] = '^';
11745  buf[i+1] = '\0';
11746  rb_compile_error_append("%s%s", pre, buf);
11747  }
11748 #else
11749  dispatch1(parse_error, STR_NEW2(msg));
11750 #endif /* !RIPPER */
11751  return 0;
11752 }
11753 
11754 static void parser_prepare(struct parser_params *parser);
11755 
11756 #ifndef RIPPER
11757 static VALUE
11758 debug_lines(const char *f)
11759 {
11760  ID script_lines;
11761  CONST_ID(script_lines, "SCRIPT_LINES__");
11762  if (rb_const_defined_at(rb_cObject, script_lines)) {
11763  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11764  if (RB_TYPE_P(hash, T_HASH)) {
11766  VALUE lines = rb_ary_new();
11767  rb_hash_aset(hash, fname, lines);
11768  return lines;
11769  }
11770  }
11771  return 0;
11772 }
11773 
11774 static VALUE
11775 coverage(const char *f, int n)
11776 {
11777  VALUE coverages = rb_get_coverages();
11778  if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11780  VALUE lines = rb_ary_new2(n);
11781  int i;
11782  RBASIC(lines)->klass = 0;
11783  for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
11784  RARRAY(lines)->as.heap.len = n;
11785  rb_hash_aset(coverages, fname, lines);
11786  return lines;
11787  }
11788  return 0;
11789 }
11790 
11791 static int
11793 {
11794  return strcmp(ruby_sourcefile, "-e") == 0;
11795 }
11796 
11797 static VALUE
11799 {
11800  int n;
11801  NODE *tree;
11802  struct parser_params *parser = (struct parser_params *)arg;
11803 
11804  if (!compile_for_eval && rb_safe_level() == 0) {
11806  if (ruby_debug_lines && ruby_sourceline > 0) {
11807  VALUE str = STR_NEW0();
11808  n = ruby_sourceline;
11809  do {
11811  } while (--n);
11812  }
11813 
11814  if (!e_option_supplied(parser)) {
11816  }
11817  }
11818 
11819  parser_prepare(parser);
11820  deferred_nodes = 0;
11821 #ifndef RIPPER
11823 #endif
11824 #ifndef RIPPER
11827  parser->parser_ruby_sourceline);
11828  }
11829 #endif
11830  n = yyparse((void*)parser);
11831 #ifndef RIPPER
11834  parser->parser_ruby_sourceline);
11835  }
11836 #endif
11837  ruby_debug_lines = 0;
11838  ruby_coverage = 0;
11839  compile_for_eval = 0;
11840 
11841  lex_strterm = 0;
11842  lex_p = lex_pbeg = lex_pend = 0;
11843  lex_lastline = lex_nextline = 0;
11844  if (parser->nerr) {
11845  return 0;
11846  }
11847  tree = ruby_eval_tree;
11848  if (!tree) {
11849  tree = NEW_NIL();
11850  }
11851  else if (ruby_eval_tree_begin) {
11852  tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11853  }
11854  return (VALUE)tree;
11855 }
11856 
11857 static NODE*
11858 yycompile(struct parser_params *parser, const char *f, int line)
11859 {
11861  ruby_sourceline = line - 1;
11862  return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
11863 }
11864 #endif /* !RIPPER */
11865 
11866 static rb_encoding *
11868 {
11869  rb_encoding *enc = rb_enc_get(s);
11870  if (!rb_enc_asciicompat(enc)) {
11871  rb_raise(rb_eArgError, "invalid source encoding");
11872  }
11873  return enc;
11874 }
11875 
11876 static VALUE
11877 lex_get_str(struct parser_params *parser, VALUE s)
11878 {
11879  char *beg, *end, *pend;
11881 
11882  beg = RSTRING_PTR(s);
11883  if (lex_gets_ptr) {
11884  if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11885  beg += lex_gets_ptr;
11886  }
11887  pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11888  end = beg;
11889  while (end < pend) {
11890  if (*end++ == '\n') break;
11891  }
11892  lex_gets_ptr = end - RSTRING_PTR(s);
11893  return rb_enc_str_new(beg, end - beg, enc);
11894 }
11895 
11896 static VALUE
11898 {
11899  VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11900  if (NIL_P(line)) return line;
11902 #ifndef RIPPER
11903  if (ruby_debug_lines) {
11906  }
11907  if (ruby_coverage) {
11909  }
11910 #endif
11911  return line;
11912 }
11913 
11914 #ifdef RIPPER
11916 #else
11918 
11919 static NODE*
11920 parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11921 {
11922  struct parser_params *parser;
11923  NODE *node;
11924 
11925  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11927  lex_gets_ptr = 0;
11928  lex_input = s;
11929  lex_pbeg = lex_p = lex_pend = 0;
11931 
11932  node = yycompile(parser, f, line);
11933  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11934 
11935  return node;
11936 }
11937 
11938 NODE*
11939 rb_compile_string(const char *f, VALUE s, int line)
11940 {
11942  return parser_compile_string(rb_parser_new(), f, s, line);
11943 }
11944 
11945 NODE*
11946 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
11947 {
11949  return parser_compile_string(vparser, f, s, line);
11950 }
11951 
11952 NODE*
11953 rb_compile_cstr(const char *f, const char *s, int len, int line)
11954 {
11955  VALUE str = rb_str_new(s, len);
11956  return parser_compile_string(rb_parser_new(), f, str, line);
11957 }
11958 
11959 NODE*
11960 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
11961 {
11962  VALUE str = rb_str_new(s, len);
11963  return parser_compile_string(vparser, f, str, line);
11964 }
11965 
11966 static VALUE
11967 lex_io_gets(struct parser_params *parser, VALUE io)
11968 {
11969  return rb_io_gets(io);
11970 }
11971 
11972 NODE*
11973 rb_compile_file(const char *f, VALUE file, int start)
11974 {
11975  VALUE volatile vparser = rb_parser_new();
11976 
11977  return rb_parser_compile_file(vparser, f, file, start);
11978 }
11979 
11980 NODE*
11981 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
11982 {
11983  struct parser_params *parser;
11984  NODE *node;
11985 
11986  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11988  lex_input = file;
11989  lex_pbeg = lex_p = lex_pend = 0;
11991 
11992  node = yycompile(parser, f, start);
11993  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11994 
11995  return node;
11996 }
11997 #endif /* !RIPPER */
11998 
11999 #define STR_FUNC_ESCAPE 0x01
12000 #define STR_FUNC_EXPAND 0x02
12001 #define STR_FUNC_REGEXP 0x04
12002 #define STR_FUNC_QWORDS 0x08
12003 #define STR_FUNC_SYMBOL 0x10
12004 #define STR_FUNC_INDENT 0x20
12005 
12007  str_squote = (0),
12015 };
12016 
12017 static VALUE
12018 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
12019 {
12020  VALUE str;
12021 
12022  str = rb_enc_str_new(p, n, enc);
12023  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12025  }
12026  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12028  }
12029  }
12030 
12031  return str;
12032 }
12033 
12034 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
12035 #define lex_eol_p() (lex_p >= lex_pend)
12036 #define peek(c) peek_n((c), 0)
12037 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
12038 
12039 static inline int
12041 {
12042  int c;
12043 
12044  if (lex_p == lex_pend) {
12045  VALUE v = lex_nextline;
12046  lex_nextline = 0;
12047  if (!v) {
12048  if (parser->eofp)
12049  return -1;
12050 
12051  if (!lex_input || NIL_P(v = lex_getline(parser))) {
12052  parser->eofp = Qtrue;
12053  lex_goto_eol(parser);
12054  return -1;
12055  }
12056  }
12057  {
12058 #ifdef RIPPER
12059  if (parser->tokp < lex_pend) {
12060  if (NIL_P(parser->delayed)) {
12061  parser->delayed = rb_str_buf_new(1024);
12062  rb_enc_associate(parser->delayed, current_enc);
12063  rb_str_buf_cat(parser->delayed,
12064  parser->tokp, lex_pend - parser->tokp);
12065  parser->delayed_line = ruby_sourceline;
12066  parser->delayed_col = (int)(parser->tokp - lex_pbeg);
12067  }
12068  else {
12069  rb_str_buf_cat(parser->delayed,
12070  parser->tokp, lex_pend - parser->tokp);
12071  }
12072  }
12073 #endif
12074  if (heredoc_end > 0) {
12076  heredoc_end = 0;
12077  }
12078  ruby_sourceline++;
12079  parser->line_count++;
12080  lex_pbeg = lex_p = RSTRING_PTR(v);
12081  lex_pend = lex_p + RSTRING_LEN(v);
12082  ripper_flush(parser);
12083  lex_lastline = v;
12084  }
12085  }
12086  c = (unsigned char)*lex_p++;
12087  if (c == '\r' && peek('\n')) {
12088  lex_p++;
12089  c = '\n';
12090  }
12091 
12092  return c;
12093 }
12094 
12095 static void
12096 parser_pushback(struct parser_params *parser, int c)
12097 {
12098  if (c == -1) return;
12099  lex_p--;
12100  if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
12101  lex_p--;
12102  }
12103 }
12104 
12105 #define was_bol() (lex_p == lex_pbeg + 1)
12106 
12107 #define tokfix() (tokenbuf[tokidx]='\0')
12108 #define tok() tokenbuf
12109 #define toklen() tokidx
12110 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
12111 
12112 static char*
12114 {
12115  tokidx = 0;
12117  if (!tokenbuf) {
12118  toksiz = 60;
12119  tokenbuf = ALLOC_N(char, 60);
12120  }
12121  if (toksiz > 4096) {
12122  toksiz = 60;
12123  REALLOC_N(tokenbuf, char, 60);
12124  }
12125  return tokenbuf;
12126 }
12127 
12128 static char *
12129 parser_tokspace(struct parser_params *parser, int n)
12130 {
12131  tokidx += n;
12132 
12133  if (tokidx >= toksiz) {
12134  do {toksiz *= 2;} while (toksiz < tokidx);
12135  REALLOC_N(tokenbuf, char, toksiz);
12136  }
12137  return &tokenbuf[tokidx-n];
12138 }
12139 
12140 static void
12141 parser_tokadd(struct parser_params *parser, int c)
12142 {
12143  tokenbuf[tokidx++] = (char)c;
12144  if (tokidx >= toksiz) {
12145  toksiz *= 2;
12146  REALLOC_N(tokenbuf, char, toksiz);
12147  }
12148 }
12149 
12150 static int
12151 parser_tok_hex(struct parser_params *parser, size_t *numlen)
12152 {
12153  int c;
12154 
12155  c = scan_hex(lex_p, 2, numlen);
12156  if (!*numlen) {
12157  yyerror("invalid hex escape");
12158  return 0;
12159  }
12160  lex_p += *numlen;
12161  return c;
12162 }
12163 
12164 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
12165 
12166 /* return value is for ?\u3042 */
12167 static int
12169  int string_literal, int symbol_literal, int regexp_literal)
12170 {
12171  /*
12172  * If string_literal is true, then we allow multiple codepoints
12173  * in \u{}, and add the codepoints to the current token.
12174  * Otherwise we're parsing a character literal and return a single
12175  * codepoint without adding it
12176  */
12177 
12178  int codepoint;
12179  size_t numlen;
12180 
12181  if (regexp_literal) { tokadd('\\'); tokadd('u'); }
12182 
12183  if (peek('{')) { /* handle \u{...} form */
12184  do {
12185  if (regexp_literal) { tokadd(*lex_p); }
12186  nextc();
12187  codepoint = scan_hex(lex_p, 6, &numlen);
12188  if (numlen == 0) {
12189  yyerror("invalid Unicode escape");
12190  return 0;
12191  }
12192  if (codepoint > 0x10ffff) {
12193  yyerror("invalid Unicode codepoint (too large)");
12194  return 0;
12195  }
12196  lex_p += numlen;
12197  if (regexp_literal) {
12198  tokcopy((int)numlen);
12199  }
12200  else if (codepoint >= 0x80) {
12201  *encp = rb_utf8_encoding();
12202  if (string_literal) tokaddmbc(codepoint, *encp);
12203  }
12204  else if (string_literal) {
12205  tokadd(codepoint);
12206  }
12207  } while (string_literal && (peek(' ') || peek('\t')));
12208 
12209  if (!peek('}')) {
12210  yyerror("unterminated Unicode escape");
12211  return 0;
12212  }
12213 
12214  if (regexp_literal) { tokadd('}'); }
12215  nextc();
12216  }
12217  else { /* handle \uxxxx form */
12218  codepoint = scan_hex(lex_p, 4, &numlen);
12219  if (numlen < 4) {
12220  yyerror("invalid Unicode escape");
12221  return 0;
12222  }
12223  lex_p += 4;
12224  if (regexp_literal) {
12225  tokcopy(4);
12226  }
12227  else if (codepoint >= 0x80) {
12228  *encp = rb_utf8_encoding();
12229  if (string_literal) tokaddmbc(codepoint, *encp);
12230  }
12231  else if (string_literal) {
12232  tokadd(codepoint);
12233  }
12234  }
12235 
12236  return codepoint;
12237 }
12238 
12239 #define ESCAPE_CONTROL 1
12240 #define ESCAPE_META 2
12241 
12242 static int
12243 parser_read_escape(struct parser_params *parser, int flags,
12244  rb_encoding **encp)
12245 {
12246  int c;
12247  size_t numlen;
12248 
12249  switch (c = nextc()) {
12250  case '\\': /* Backslash */
12251  return c;
12252 
12253  case 'n': /* newline */
12254  return '\n';
12255 
12256  case 't': /* horizontal tab */
12257  return '\t';
12258 
12259  case 'r': /* carriage-return */
12260  return '\r';
12261 
12262  case 'f': /* form-feed */
12263  return '\f';
12264 
12265  case 'v': /* vertical tab */
12266  return '\13';
12267 
12268  case 'a': /* alarm(bell) */
12269  return '\007';
12270 
12271  case 'e': /* escape */
12272  return 033;
12273 
12274  case '0': case '1': case '2': case '3': /* octal constant */
12275  case '4': case '5': case '6': case '7':
12276  pushback(c);
12277  c = scan_oct(lex_p, 3, &numlen);
12278  lex_p += numlen;
12279  return c;
12280 
12281  case 'x': /* hex constant */
12282  c = tok_hex(&numlen);
12283  if (numlen == 0) return 0;
12284  return c;
12285 
12286  case 'b': /* backspace */
12287  return '\010';
12288 
12289  case 's': /* space */
12290  return ' ';
12291 
12292  case 'M':
12293  if (flags & ESCAPE_META) goto eof;
12294  if ((c = nextc()) != '-') {
12295  pushback(c);
12296  goto eof;
12297  }
12298  if ((c = nextc()) == '\\') {
12299  if (peek('u')) goto eof;
12300  return read_escape(flags|ESCAPE_META, encp) | 0x80;
12301  }
12302  else if (c == -1 || !ISASCII(c)) goto eof;
12303  else {
12304  return ((c & 0xff) | 0x80);
12305  }
12306 
12307  case 'C':
12308  if ((c = nextc()) != '-') {
12309  pushback(c);
12310  goto eof;
12311  }
12312  case 'c':
12313  if (flags & ESCAPE_CONTROL) goto eof;
12314  if ((c = nextc())== '\\') {
12315  if (peek('u')) goto eof;
12316  c = read_escape(flags|ESCAPE_CONTROL, encp);
12317  }
12318  else if (c == '?')
12319  return 0177;
12320  else if (c == -1 || !ISASCII(c)) goto eof;
12321  return c & 0x9f;
12322 
12323  eof:
12324  case -1:
12325  yyerror("Invalid escape character syntax");
12326  return '\0';
12327 
12328  default:
12329  return c;
12330  }
12331 }
12332 
12333 static void
12335 {
12336  int len = rb_enc_codelen(c, enc);
12337  rb_enc_mbcput(c, tokspace(len), enc);
12338 }
12339 
12340 static int
12342 {
12343  int c;
12344  int flags = 0;
12345  size_t numlen;
12346 
12347  first:
12348  switch (c = nextc()) {
12349  case '\n':
12350  return 0; /* just ignore */
12351 
12352  case '0': case '1': case '2': case '3': /* octal constant */
12353  case '4': case '5': case '6': case '7':
12354  {
12355  ruby_scan_oct(--lex_p, 3, &numlen);
12356  if (numlen == 0) goto eof;
12357  lex_p += numlen;
12358  tokcopy((int)numlen + 1);
12359  }
12360  return 0;
12361 
12362  case 'x': /* hex constant */
12363  {
12364  tok_hex(&numlen);
12365  if (numlen == 0) return -1;
12366  tokcopy((int)numlen + 2);
12367  }
12368  return 0;
12369 
12370  case 'M':
12371  if (flags & ESCAPE_META) goto eof;
12372  if ((c = nextc()) != '-') {
12373  pushback(c);
12374  goto eof;
12375  }
12376  tokcopy(3);
12377  flags |= ESCAPE_META;
12378  goto escaped;
12379 
12380  case 'C':
12381  if (flags & ESCAPE_CONTROL) goto eof;
12382  if ((c = nextc()) != '-') {
12383  pushback(c);
12384  goto eof;
12385  }
12386  tokcopy(3);
12387  goto escaped;
12388 
12389  case 'c':
12390  if (flags & ESCAPE_CONTROL) goto eof;
12391  tokcopy(2);
12392  flags |= ESCAPE_CONTROL;
12393  escaped:
12394  if ((c = nextc()) == '\\') {
12395  goto first;
12396  }
12397  else if (c == -1) goto eof;
12398  tokadd(c);
12399  return 0;
12400 
12401  eof:
12402  case -1:
12403  yyerror("Invalid escape character syntax");
12404  return -1;
12405 
12406  default:
12407  tokadd('\\');
12408  tokadd(c);
12409  }
12410  return 0;
12411 }
12412 
12413 static int
12415 {
12416  int kcode = 0;
12417  int kopt = 0;
12418  int options = 0;
12419  int c, opt, kc;
12420 
12421  newtok();
12422  while (c = nextc(), ISALPHA(c)) {
12423  if (c == 'o') {
12424  options |= RE_OPTION_ONCE;
12425  }
12426  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12427  if (kc >= 0) {
12428  if (kc != rb_ascii8bit_encindex()) kcode = c;
12429  kopt = opt;
12430  }
12431  else {
12432  options |= opt;
12433  }
12434  }
12435  else {
12436  tokadd(c);
12437  }
12438  }
12439  options |= kopt;
12440  pushback(c);
12441  if (toklen()) {
12442  tokfix();
12443  compile_error(PARSER_ARG "unknown regexp option%s - %s",
12444  toklen() > 1 ? "s" : "", tok());
12445  }
12446  return options | RE_OPTION_ENCODING(kcode);
12447 }
12448 
12449 static void
12451 {
12452  rb_str_free(str);
12453  rb_gc_force_recycle(str);
12454 }
12455 
12456 static int
12457 parser_tokadd_mbchar(struct parser_params *parser, int c)
12458 {
12459  int len = parser_precise_mbclen();
12460  if (!MBCLEN_CHARFOUND_P(len)) {
12461  compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12462  return -1;
12463  }
12464  tokadd(c);
12465  lex_p += --len;
12466  if (len > 0) tokcopy(len);
12467  return c;
12468 }
12469 
12470 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12471 
12472 static inline int
12474 {
12475  switch (c) {
12476  case '$': case '*': case '+': case '.':
12477  case '?': case '^': case '|':
12478  case ')': case ']': case '}': case '>':
12479  return TRUE;
12480  default:
12481  return FALSE;
12482  }
12483 }
12484 
12485 static int
12487  int func, int term, int paren, long *nest,
12488  rb_encoding **encp)
12489 {
12490  int c;
12491  int has_nonascii = 0;
12492  rb_encoding *enc = *encp;
12493  char *errbuf = 0;
12494  static const char mixed_msg[] = "%s mixed within %s source";
12495 
12496 #define mixed_error(enc1, enc2) if (!errbuf) { \
12497  size_t len = sizeof(mixed_msg) - 4; \
12498  len += strlen(rb_enc_name(enc1)); \
12499  len += strlen(rb_enc_name(enc2)); \
12500  errbuf = ALLOCA_N(char, len); \
12501  snprintf(errbuf, len, mixed_msg, \
12502  rb_enc_name(enc1), \
12503  rb_enc_name(enc2)); \
12504  yyerror(errbuf); \
12505  }
12506 #define mixed_escape(beg, enc1, enc2) do { \
12507  const char *pos = lex_p; \
12508  lex_p = (beg); \
12509  mixed_error((enc1), (enc2)); \
12510  lex_p = pos; \
12511  } while (0)
12512 
12513  while ((c = nextc()) != -1) {
12514  if (paren && c == paren) {
12515  ++*nest;
12516  }
12517  else if (c == term) {
12518  if (!nest || !*nest) {
12519  pushback(c);
12520  break;
12521  }
12522  --*nest;
12523  }
12524  else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12525  int c2 = *lex_p;
12526  if (c2 == '$' || c2 == '@' || c2 == '{') {
12527  pushback(c);
12528  break;
12529  }
12530  }
12531  else if (c == '\\') {
12532  const char *beg = lex_p - 1;
12533  c = nextc();
12534  switch (c) {
12535  case '\n':
12536  if (func & STR_FUNC_QWORDS) break;
12537  if (func & STR_FUNC_EXPAND) continue;
12538  tokadd('\\');
12539  break;
12540 
12541  case '\\':
12542  if (func & STR_FUNC_ESCAPE) tokadd(c);
12543  break;
12544 
12545  case 'u':
12546  if ((func & STR_FUNC_EXPAND) == 0) {
12547  tokadd('\\');
12548  break;
12549  }
12550  parser_tokadd_utf8(parser, &enc, 1,
12551  func & STR_FUNC_SYMBOL,
12552  func & STR_FUNC_REGEXP);
12553  if (has_nonascii && enc != *encp) {
12554  mixed_escape(beg, enc, *encp);
12555  }
12556  continue;
12557 
12558  default:
12559  if (c == -1) return -1;
12560  if (!ISASCII(c)) {
12561  if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12562  goto non_ascii;
12563  }
12564  if (func & STR_FUNC_REGEXP) {
12565  if (c == term && !simple_re_meta(c)) {
12566  tokadd(c);
12567  continue;
12568  }
12569  pushback(c);
12570  if ((c = tokadd_escape(&enc)) < 0)
12571  return -1;
12572  if (has_nonascii && enc != *encp) {
12573  mixed_escape(beg, enc, *encp);
12574  }
12575  continue;
12576  }
12577  else if (func & STR_FUNC_EXPAND) {
12578  pushback(c);
12579  if (func & STR_FUNC_ESCAPE) tokadd('\\');
12580  c = read_escape(0, &enc);
12581  }
12582  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12583  /* ignore backslashed spaces in %w */
12584  }
12585  else if (c != term && !(paren && c == paren)) {
12586  tokadd('\\');
12587  pushback(c);
12588  continue;
12589  }
12590  }
12591  }
12592  else if (!parser_isascii()) {
12593  non_ascii:
12594  has_nonascii = 1;
12595  if (enc != *encp) {
12596  mixed_error(enc, *encp);
12597  continue;
12598  }
12599  if (tokadd_mbchar(c) == -1) return -1;
12600  continue;
12601  }
12602  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12603  pushback(c);
12604  break;
12605  }
12606  if (c & 0x80) {
12607  has_nonascii = 1;
12608  if (enc != *encp) {
12609  mixed_error(enc, *encp);
12610  continue;
12611  }
12612  }
12613  tokadd(c);
12614  }
12615  *encp = enc;
12616  return c;
12617 }
12618 
12619 #define NEW_STRTERM(func, term, paren) \
12620  rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12621 
12622 #ifdef RIPPER
12623 static void
12624 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12625 {
12626  if (!NIL_P(parser->delayed)) {
12627  ptrdiff_t len = lex_p - parser->tokp;
12628  if (len > 0) {
12629  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12630  }
12631  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12632  parser->tokp = lex_p;
12633  }
12634 }
12635 
12636 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12637 #else
12638 #define flush_string_content(enc) ((void)(enc))
12639 #endif
12640 
12641 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12642 /* this can be shared with ripper, since it's independent from struct
12643  * parser_params. */
12644 #ifndef RIPPER
12645 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12646 #define SPECIAL_PUNCT(idx) ( \
12647  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12648  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12649  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12650  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12651  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12652  BIT('0', idx))
12653 const unsigned int ruby_global_name_punct_bits[] = {
12654  SPECIAL_PUNCT(0),
12655  SPECIAL_PUNCT(1),
12656  SPECIAL_PUNCT(2),
12657 };
12658 #undef BIT
12659 #undef SPECIAL_PUNCT
12660 #endif
12661 
12662 static inline int
12664 {
12665  if (c <= 0x20 || 0x7e < c) return 0;
12666  return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12667 }
12668 
12669 static int
12671 {
12672  int c;
12673  const char *p = lex_p;
12674 
12675  if (p + 1 >= lex_pend) return 0;
12676  c = *p++;
12677  switch (c) {
12678  case '$':
12679  if ((c = *p) == '-') {
12680  if (++p >= lex_pend) return 0;
12681  c = *p;
12682  }
12683  else if (is_global_name_punct(c) || ISDIGIT(c)) {
12684  return tSTRING_DVAR;
12685  }
12686  break;
12687  case '@':
12688  if ((c = *p) == '@') {
12689  if (++p >= lex_pend) return 0;
12690  c = *p;
12691  }
12692  break;
12693  case '{':
12694  lex_p = p;
12695  command_start = TRUE;
12696  return tSTRING_DBEG;
12697  default:
12698  return 0;
12699  }
12700  if (!ISASCII(c) || c == '_' || ISALPHA(c))
12701  return tSTRING_DVAR;
12702  return 0;
12703 }
12704 
12705 static int
12706 parser_parse_string(struct parser_params *parser, NODE *quote)
12707 {
12708  int func = (int)quote->nd_func;
12709  int term = nd_term(quote);
12710  int paren = nd_paren(quote);
12711  int c, space = 0;
12713 
12714  if (func == -1) return tSTRING_END;
12715  c = nextc();
12716  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12717  do {c = nextc();} while (ISSPACE(c));
12718  space = 1;
12719  }
12720  if (c == term && !quote->nd_nest) {
12721  if (func & STR_FUNC_QWORDS) {
12722  quote->nd_func = -1;
12723  return ' ';
12724  }
12725  if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12727  return tREGEXP_END;
12728  }
12729  if (space) {
12730  pushback(c);
12731  return ' ';
12732  }
12733  newtok();
12734  if ((func & STR_FUNC_EXPAND) && c == '#') {
12735  int t = parser_peek_variable_name(parser);
12736  if (t) return t;
12737  tokadd('#');
12738  c = nextc();
12739  }
12740  pushback(c);
12741  if (tokadd_string(func, term, paren, &quote->nd_nest,
12742  &enc) == -1) {
12743  ruby_sourceline = nd_line(quote);
12744  if (func & STR_FUNC_REGEXP) {
12745  if (parser->eofp)
12746  compile_error(PARSER_ARG "unterminated regexp meets end of file");
12747  return tREGEXP_END;
12748  }
12749  else {
12750  if (parser->eofp)
12751  compile_error(PARSER_ARG "unterminated string meets end of file");
12752  return tSTRING_END;
12753  }
12754  }
12755 
12756  tokfix();
12757  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12758  flush_string_content(enc);
12759 
12760  return tSTRING_CONTENT;
12761 }
12762 
12763 static int
12765 {
12766  int c = nextc(), term, func = 0;
12767  long len;
12768 
12769  if (c == '-') {
12770  c = nextc();
12771  func = STR_FUNC_INDENT;
12772  }
12773  switch (c) {
12774  case '\'':
12775  func |= str_squote; goto quoted;
12776  case '"':
12777  func |= str_dquote; goto quoted;
12778  case '`':
12779  func |= str_xquote;
12780  quoted:
12781  newtok();
12782  tokadd(func);
12783  term = c;
12784  while ((c = nextc()) != -1 && c != term) {
12785  if (tokadd_mbchar(c) == -1) return 0;
12786  }
12787  if (c == -1) {
12788  compile_error(PARSER_ARG "unterminated here document identifier");
12789  return 0;
12790  }
12791  break;
12792 
12793  default:
12794  if (!parser_is_identchar()) {
12795  pushback(c);
12796  if (func & STR_FUNC_INDENT) {
12797  pushback('-');
12798  }
12799  return 0;
12800  }
12801  newtok();
12802  term = '"';
12803  tokadd(func |= str_dquote);
12804  do {
12805  if (tokadd_mbchar(c) == -1) return 0;
12806  } while ((c = nextc()) != -1 && parser_is_identchar());
12807  pushback(c);
12808  break;
12809  }
12810 
12811  tokfix();
12812 #ifdef RIPPER
12813  ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12814 #endif
12815  len = lex_p - lex_pbeg;
12816  lex_goto_eol(parser);
12818  STR_NEW(tok(), toklen()), /* nd_lit */
12819  len, /* nd_nth */
12820  lex_lastline); /* nd_orig */
12822  ripper_flush(parser);
12823  return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12824 }
12825 
12826 static void
12828 {
12829  VALUE line;
12830 
12831  line = here->nd_orig;
12832  lex_lastline = line;
12833  lex_pbeg = RSTRING_PTR(line);
12834  lex_pend = lex_pbeg + RSTRING_LEN(line);
12835  lex_p = lex_pbeg + here->nd_nth;
12837  ruby_sourceline = nd_line(here);
12838  dispose_string(here->nd_lit);
12839  rb_gc_force_recycle((VALUE)here);
12840  ripper_flush(parser);
12841 }
12842 
12843 static int
12845  const char *eos, long len, int indent)
12846 {
12847  const char *p = lex_pbeg;
12848  long n;
12849 
12850  if (indent) {
12851  while (*p && ISSPACE(*p)) p++;
12852  }
12853  n = lex_pend - (p + len);
12854  if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
12855  return strncmp(eos, p, len) == 0;
12856 }
12857 
12858 #ifdef RIPPER
12859 static void
12860 ripper_dispatch_heredoc_end(struct parser_params *parser)
12861 {
12862  if (!NIL_P(parser->delayed))
12863  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12864  lex_goto_eol(parser);
12865  ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
12866 }
12867 
12868 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12869 #else
12870 #define dispatch_heredoc_end() ((void)0)
12871 #endif
12872 
12873 static int
12875 {
12876  int c, func, indent = 0;
12877  const char *eos, *p, *pend;
12878  long len;
12879  VALUE str = 0;
12881 
12882  eos = RSTRING_PTR(here->nd_lit);
12883  len = RSTRING_LEN(here->nd_lit) - 1;
12884  indent = (func = *eos++) & STR_FUNC_INDENT;
12885 
12886  if ((c = nextc()) == -1) {
12887  error:
12888  compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12889 #ifdef RIPPER
12890  if (NIL_P(parser->delayed)) {
12891  ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
12892  }
12893  else {
12894  if (str ||
12895  ((len = lex_p - parser->tokp) > 0 &&
12896  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
12897  rb_str_append(parser->delayed, str);
12898  }
12899  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12900  }
12901  lex_goto_eol(parser);
12902 #endif
12903  restore:
12905  lex_strterm = 0;
12906  return 0;
12907  }
12908  if (was_bol() && whole_match_p(eos, len, indent)) {
12911  return tSTRING_END;
12912  }
12913 
12914  if (!(func & STR_FUNC_EXPAND)) {
12915  do {
12917  pend = lex_pend;
12918  if (pend > p) {
12919  switch (pend[-1]) {
12920  case '\n':
12921  if (--pend == p || pend[-1] != '\r') {
12922  pend++;
12923  break;
12924  }
12925  case '\r':
12926  --pend;
12927  }
12928  }
12929  if (str)
12930  rb_str_cat(str, p, pend - p);
12931  else
12932  str = STR_NEW(p, pend - p);
12933  if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12934  lex_goto_eol(parser);
12935  if (nextc() == -1) {
12936  if (str) dispose_string(str);
12937  goto error;
12938  }
12939  } while (!whole_match_p(eos, len, indent));
12940  }
12941  else {
12942  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12943  newtok();
12944  if (c == '#') {
12945  int t = parser_peek_variable_name(parser);
12946  if (t) return t;
12947  tokadd('#');
12948  c = nextc();
12949  }
12950  do {
12951  pushback(c);
12952  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
12953  if (parser->eofp) goto error;
12954  goto restore;
12955  }
12956  if (c != '\n') {
12957  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12958  flush_string_content(enc);
12959  return tSTRING_CONTENT;
12960  }
12961  tokadd(nextc());
12962  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
12963  if ((c = nextc()) == -1) goto error;
12964  } while (!whole_match_p(eos, len, indent));
12965  str = STR_NEW3(tok(), toklen(), enc, func);
12966  }
12969  lex_strterm = NEW_STRTERM(-1, 0, 0);
12970  set_yylval_str(str);
12971  return tSTRING_CONTENT;
12972 }
12973 
12974 #include "lex.c"
12975 
12976 static void
12978 {
12979 #ifndef RIPPER
12980  rb_warning0("ambiguous first argument; put parentheses or even spaces");
12981 #else
12982  dispatch0(arg_ambiguous);
12983 #endif
12984 }
12985 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
12986 
12987 static ID
12989 {
12990 #ifndef RIPPER
12991  if (!is_local_id(lhs))
12992  yyerror("formal argument must be local variable");
12993 #endif
12994  shadowing_lvar(lhs);
12995  return lhs;
12996 }
12997 
12998 static int
12999 lvar_defined_gen(struct parser_params *parser, ID id)
13000 {
13001  return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
13002 }
13003 
13004 /* emacsen -*- hack */
13005 static long
13006 parser_encode_length(struct parser_params *parser, const char *name, long len)
13007 {
13008  long nlen;
13009 
13010  if (len > 5 && name[nlen = len - 5] == '-') {
13011  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
13012  return nlen;
13013  }
13014  if (len > 4 && name[nlen = len - 4] == '-') {
13015  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
13016  return nlen;
13017  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
13018  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
13019  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
13020  return nlen;
13021  }
13022  return len;
13023 }
13024 
13025 static void
13026 parser_set_encode(struct parser_params *parser, const char *name)
13027 {
13028  int idx = rb_enc_find_index(name);
13029  rb_encoding *enc;
13030  VALUE excargs[3];
13031 
13032  if (idx < 0) {
13033  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
13034  error:
13035  excargs[0] = rb_eArgError;
13036  excargs[2] = rb_make_backtrace();
13037  rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
13038  rb_exc_raise(rb_make_exception(3, excargs));
13039  }
13040  enc = rb_enc_from_index(idx);
13041  if (!rb_enc_asciicompat(enc)) {
13042  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13043  goto error;
13044  }
13045  parser->enc = enc;
13046 #ifndef RIPPER
13047  if (ruby_debug_lines) {
13048  long i, n = RARRAY_LEN(ruby_debug_lines);
13049  const VALUE *p = RARRAY_PTR(ruby_debug_lines);
13050  for (i = 0; i < n; ++i) {
13051  rb_enc_associate_index(*p, idx);
13052  }
13053  }
13054 #endif
13055 }
13056 
13057 static int
13059 {
13060  const char *p = lex_pbeg, *pend = lex_p - 1;
13061  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13062  while (p < pend) {
13063  if (!ISSPACE(*p)) return 0;
13064  p++;
13065  }
13066  return 1;
13067 }
13068 
13069 #ifndef RIPPER
13070 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13071 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13072 
13073 static void
13074 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13075 {
13076  if (!comment_at_top(parser)) {
13077  return;
13078  }
13079  parser_set_encode(parser, val);
13080 }
13081 
13082 static void
13083 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13084 {
13085  int *p = &parser->parser_token_info_enabled;
13086 
13087  switch (*val) {
13088  case 't': case 'T':
13089  if (strcasecmp(val, "true") == 0) {
13090  *p = TRUE;
13091  return;
13092  }
13093  break;
13094  case 'f': case 'F':
13095  if (strcasecmp(val, "false") == 0) {
13096  *p = FALSE;
13097  return;
13098  }
13099  break;
13100  }
13101  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13102 }
13103 
13104 struct magic_comment {
13105  const char *name;
13108 };
13109 
13110 static const struct magic_comment magic_comments[] = {
13113  {"warn_indent", parser_set_token_info},
13114 };
13115 #endif
13116 
13117 static const char *
13118 magic_comment_marker(const char *str, long len)
13119 {
13120  long i = 2;
13121 
13122  while (i < len) {
13123  switch (str[i]) {
13124  case '-':
13125  if (str[i-1] == '*' && str[i-2] == '-') {
13126  return str + i + 1;
13127  }
13128  i += 2;
13129  break;
13130  case '*':
13131  if (i + 1 >= len) return 0;
13132  if (str[i+1] != '-') {
13133  i += 4;
13134  }
13135  else if (str[i-1] != '-') {
13136  i += 2;
13137  }
13138  else {
13139  return str + i + 2;
13140  }
13141  break;
13142  default:
13143  i += 3;
13144  break;
13145  }
13146  }
13147  return 0;
13148 }
13149 
13150 static int
13151 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13152 {
13153  VALUE name = 0, val = 0;
13154  const char *beg, *end, *vbeg, *vend;
13155 #define str_copy(_s, _p, _n) ((_s) \
13156  ? (void)(rb_str_resize((_s), (_n)), \
13157  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13158  : (void)((_s) = STR_NEW((_p), (_n))))
13159 
13160  if (len <= 7) return FALSE;
13161  if (!(beg = magic_comment_marker(str, len))) return FALSE;
13162  if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13163  str = beg;
13164  len = end - beg - 3;
13165 
13166  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13167  while (len > 0) {
13168 #ifndef RIPPER
13169  const struct magic_comment *p = magic_comments;
13170 #endif
13171  char *s;
13172  int i;
13173  long n = 0;
13174 
13175  for (; len > 0 && *str; str++, --len) {
13176  switch (*str) {
13177  case '\'': case '"': case ':': case ';':
13178  continue;
13179  }
13180  if (!ISSPACE(*str)) break;
13181  }
13182  for (beg = str; len > 0; str++, --len) {
13183  switch (*str) {
13184  case '\'': case '"': case ':': case ';':
13185  break;
13186  default:
13187  if (ISSPACE(*str)) break;
13188  continue;
13189  }
13190  break;
13191  }
13192  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13193  if (!len) break;
13194  if (*str != ':') continue;
13195 
13196  do str++; while (--len > 0 && ISSPACE(*str));
13197  if (!len) break;
13198  if (*str == '"') {
13199  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13200  if (*str == '\\') {
13201  --len;
13202  ++str;
13203  }
13204  }
13205  vend = str;
13206  if (len) {
13207  --len;
13208  ++str;
13209  }
13210  }
13211  else {
13212  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13213  vend = str;
13214  }
13215  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13216 
13217  n = end - beg;
13218  str_copy(name, beg, n);
13219  s = RSTRING_PTR(name);
13220  for (i = 0; i < n; ++i) {
13221  if (s[i] == '-') s[i] = '_';
13222  }
13223 #ifndef RIPPER
13224  do {
13225  if (STRNCASECMP(p->name, s, n) == 0) {
13226  n = vend - vbeg;
13227  if (p->length) {
13228  n = (*p->length)(parser, vbeg, n);
13229  }
13230  str_copy(val, vbeg, n);
13231  (*p->func)(parser, s, RSTRING_PTR(val));
13232  break;
13233  }
13234  } while (++p < magic_comments + numberof(magic_comments));
13235 #else
13236  str_copy(val, vbeg, vend - vbeg);
13237  dispatch2(magic_comment, name, val);
13238 #endif
13239  }
13240 
13241  return TRUE;
13242 }
13243 
13244 static void
13245 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13246 {
13247  int sep = 0;
13248  const char *beg = str;
13249  VALUE s;
13250 
13251  for (;;) {
13252  if (send - str <= 6) return;
13253  switch (str[6]) {
13254  case 'C': case 'c': str += 6; continue;
13255  case 'O': case 'o': str += 5; continue;
13256  case 'D': case 'd': str += 4; continue;
13257  case 'I': case 'i': str += 3; continue;
13258  case 'N': case 'n': str += 2; continue;
13259  case 'G': case 'g': str += 1; continue;
13260  case '=': case ':':
13261  sep = 1;
13262  str += 6;
13263  break;
13264  default:
13265  str += 6;
13266  if (ISSPACE(*str)) break;
13267  continue;
13268  }
13269  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13270  }
13271  for (;;) {
13272  do {
13273  if (++str >= send) return;
13274  } while (ISSPACE(*str));
13275  if (sep) break;
13276  if (*str != '=' && *str != ':') return;
13277  sep = 1;
13278  str++;
13279  }
13280  beg = str;
13281  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13282  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13283  parser_set_encode(parser, RSTRING_PTR(s));
13284  rb_str_resize(s, 0);
13285 }
13286 
13287 static void
13289 {
13290  int c = nextc();
13291  switch (c) {
13292  case '#':
13293  if (peek('!')) parser->has_shebang = 1;
13294  break;
13295  case 0xef: /* UTF-8 BOM marker */
13296  if (lex_pend - lex_p >= 2 &&
13297  (unsigned char)lex_p[0] == 0xbb &&
13298  (unsigned char)lex_p[1] == 0xbf) {
13299  parser->enc = rb_utf8_encoding();
13300  lex_p += 2;
13301  lex_pbeg = lex_p;
13302  return;
13303  }
13304  break;
13305  case EOF:
13306  return;
13307  }
13308  pushback(c);
13309  parser->enc = rb_enc_get(lex_lastline);
13310 }
13311 
13312 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13313 #define IS_END() IS_lex_state(EXPR_END_ANY)
13314 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13315 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13316 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13317 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13318 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13319 
13320 #ifndef RIPPER
13321 #define ambiguous_operator(op, syn) ( \
13322  rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
13323  rb_warning0("even though it seems like "syn""))
13324 #else
13325 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13326 #endif
13327 #define warn_balanced(op, syn) ((void) \
13328  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13329  space_seen && !ISSPACE(c) && \
13330  (ambiguous_operator(op, syn), 0)))
13331 
13332 static int
13334 {
13335  register int c;
13336  int space_seen = 0;
13337  int cmd_state;
13338  enum lex_state_e last_state;
13339  rb_encoding *enc;
13340  int mb;
13341 #ifdef RIPPER
13342  int fallthru = FALSE;
13343 #endif
13344 
13345  if (lex_strterm) {
13346  int token;
13347  if (nd_type(lex_strterm) == NODE_HEREDOC) {
13348  token = here_document(lex_strterm);
13349  if (token == tSTRING_END) {
13350  lex_strterm = 0;
13351  lex_state = EXPR_END;
13352  }
13353  }
13354  else {
13355  token = parse_string(lex_strterm);
13356  if (token == tSTRING_END || token == tREGEXP_END) {
13358  lex_strterm = 0;
13359  lex_state = EXPR_END;
13360  }
13361  }
13362  return token;
13363  }
13364  cmd_state = command_start;
13365  command_start = FALSE;
13366  retry:
13367  last_state = lex_state;
13368  switch (c = nextc()) {
13369  case '\0': /* NUL */
13370  case '\004': /* ^D */
13371  case '\032': /* ^Z */
13372  case -1: /* end of script. */
13373  return 0;
13374 
13375  /* white spaces */
13376  case ' ': case '\t': case '\f': case '\r':
13377  case '\13': /* '\v' */
13378  space_seen = 1;
13379 #ifdef RIPPER
13380  while ((c = nextc())) {
13381  switch (c) {
13382  case ' ': case '\t': case '\f': case '\r':
13383  case '\13': /* '\v' */
13384  break;
13385  default:
13386  goto outofloop;
13387  }
13388  }
13389  outofloop:
13390  pushback(c);
13391  ripper_dispatch_scan_event(parser, tSP);
13392 #endif
13393  goto retry;
13394 
13395  case '#': /* it's a comment */
13396  /* no magic_comment in shebang line */
13397  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13398  if (comment_at_top(parser)) {
13399  set_file_encoding(parser, lex_p, lex_pend);
13400  }
13401  }
13402  lex_p = lex_pend;
13403 #ifdef RIPPER
13404  ripper_dispatch_scan_event(parser, tCOMMENT);
13405  fallthru = TRUE;
13406 #endif
13407  /* fall through */
13408  case '\n':
13409  if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT)) {
13410 #ifdef RIPPER
13411  if (!fallthru) {
13412  ripper_dispatch_scan_event(parser, tIGNORED_NL);
13413  }
13414  fallthru = FALSE;
13415 #endif
13416  goto retry;
13417  }
13418  while ((c = nextc())) {
13419  switch (c) {
13420  case ' ': case '\t': case '\f': case '\r':
13421  case '\13': /* '\v' */
13422  space_seen = 1;
13423  break;
13424  case '.': {
13425  if ((c = nextc()) != '.') {
13426  pushback(c);
13427  pushback('.');
13428  goto retry;
13429  }
13430  }
13431  default:
13432  --ruby_sourceline;
13434  case -1: /* EOF no decrement*/
13435  lex_goto_eol(parser);
13436 #ifdef RIPPER
13437  if (c != -1) {
13438  parser->tokp = lex_p;
13439  }
13440 #endif
13441  goto normal_newline;
13442  }
13443  }
13444  normal_newline:
13445  command_start = TRUE;
13446  lex_state = EXPR_BEG;
13447  return '\n';
13448 
13449  case '*':
13450  if ((c = nextc()) == '*') {
13451  if ((c = nextc()) == '=') {
13453  lex_state = EXPR_BEG;
13454  return tOP_ASGN;
13455  }
13456  pushback(c);
13457  if (IS_SPCARG(c)) {
13458  rb_warning0("`**' interpreted as argument prefix");
13459  c = tDSTAR;
13460  }
13461  else if (IS_BEG()) {
13462  c = tDSTAR;
13463  }
13464  else {
13465  warn_balanced("**", "argument prefix");
13466  c = tPOW;
13467  }
13468  }
13469  else {
13470  if (c == '=') {
13471  set_yylval_id('*');
13472  lex_state = EXPR_BEG;
13473  return tOP_ASGN;
13474  }
13475  pushback(c);
13476  if (IS_SPCARG(c)) {
13477  rb_warning0("`*' interpreted as argument prefix");
13478  c = tSTAR;
13479  }
13480  else if (IS_BEG()) {
13481  c = tSTAR;
13482  }
13483  else {
13484  warn_balanced("*", "argument prefix");
13485  c = '*';
13486  }
13487  }
13488  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13489  return c;
13490 
13491  case '!':
13492  c = nextc();
13493  if (IS_AFTER_OPERATOR()) {
13494  lex_state = EXPR_ARG;
13495  if (c == '@') {
13496  return '!';
13497  }
13498  }
13499  else {
13500  lex_state = EXPR_BEG;
13501  }
13502  if (c == '=') {
13503  return tNEQ;
13504  }
13505  if (c == '~') {
13506  return tNMATCH;
13507  }
13508  pushback(c);
13509  return '!';
13510 
13511  case '=':
13512  if (was_bol()) {
13513  /* skip embedded rd document */
13514  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13515 #ifdef RIPPER
13516  int first_p = TRUE;
13517 
13518  lex_goto_eol(parser);
13519  ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13520 #endif
13521  for (;;) {
13522  lex_goto_eol(parser);
13523 #ifdef RIPPER
13524  if (!first_p) {
13525  ripper_dispatch_scan_event(parser, tEMBDOC);
13526  }
13527  first_p = FALSE;
13528 #endif
13529  c = nextc();
13530  if (c == -1) {
13531  compile_error(PARSER_ARG "embedded document meets end of file");
13532  return 0;
13533  }
13534  if (c != '=') continue;
13535  if (strncmp(lex_p, "end", 3) == 0 &&
13536  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13537  break;
13538  }
13539  }
13540  lex_goto_eol(parser);
13541 #ifdef RIPPER
13542  ripper_dispatch_scan_event(parser, tEMBDOC_END);
13543 #endif
13544  goto retry;
13545  }
13546  }
13547 
13548  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13549  if ((c = nextc()) == '=') {
13550  if ((c = nextc()) == '=') {
13551  return tEQQ;
13552  }
13553  pushback(c);
13554  return tEQ;
13555  }
13556  if (c == '~') {
13557  return tMATCH;
13558  }
13559  else if (c == '>') {
13560  return tASSOC;
13561  }
13562  pushback(c);
13563  return '=';
13564 
13565  case '<':
13566  last_state = lex_state;
13567  c = nextc();
13568  if (c == '<' &&
13569  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13570  !IS_END() &&
13571  (!IS_ARG() || space_seen)) {
13572  int token = heredoc_identifier();
13573  if (token) return token;
13574  }
13575  if (IS_AFTER_OPERATOR()) {
13576  lex_state = EXPR_ARG;
13577  }
13578  else {
13579  if (IS_lex_state(EXPR_CLASS))
13580  command_start = TRUE;
13581  lex_state = EXPR_BEG;
13582  }
13583  if (c == '=') {
13584  if ((c = nextc()) == '>') {
13585  return tCMP;
13586  }
13587  pushback(c);
13588  return tLEQ;
13589  }
13590  if (c == '<') {
13591  if ((c = nextc()) == '=') {
13593  lex_state = EXPR_BEG;
13594  return tOP_ASGN;
13595  }
13596  pushback(c);
13597  warn_balanced("<<", "here document");
13598  return tLSHFT;
13599  }
13600  pushback(c);
13601  return '<';
13602 
13603  case '>':
13604  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13605  if ((c = nextc()) == '=') {
13606  return tGEQ;
13607  }
13608  if (c == '>') {
13609  if ((c = nextc()) == '=') {
13611  lex_state = EXPR_BEG;
13612  return tOP_ASGN;
13613  }
13614  pushback(c);
13615  return tRSHFT;
13616  }
13617  pushback(c);
13618  return '>';
13619 
13620  case '"':
13621  lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13622  return tSTRING_BEG;
13623 
13624  case '`':
13625  if (IS_lex_state(EXPR_FNAME)) {
13626  lex_state = EXPR_ENDFN;
13627  return c;
13628  }
13629  if (IS_lex_state(EXPR_DOT)) {
13630  if (cmd_state)
13631  lex_state = EXPR_CMDARG;
13632  else
13633  lex_state = EXPR_ARG;
13634  return c;
13635  }
13636  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13637  return tXSTRING_BEG;
13638 
13639  case '\'':
13640  lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13641  return tSTRING_BEG;
13642 
13643  case '?':
13644  if (IS_END()) {
13645  lex_state = EXPR_VALUE;
13646  return '?';
13647  }
13648  c = nextc();
13649  if (c == -1) {
13650  compile_error(PARSER_ARG "incomplete character syntax");
13651  return 0;
13652  }
13653  if (rb_enc_isspace(c, current_enc)) {
13654  if (!IS_ARG()) {
13655  int c2 = 0;
13656  switch (c) {
13657  case ' ':
13658  c2 = 's';
13659  break;
13660  case '\n':
13661  c2 = 'n';
13662  break;
13663  case '\t':
13664  c2 = 't';
13665  break;
13666  case '\v':
13667  c2 = 'v';
13668  break;
13669  case '\r':
13670  c2 = 'r';
13671  break;
13672  case '\f':
13673  c2 = 'f';
13674  break;
13675  }
13676  if (c2) {
13677  rb_warnI("invalid character syntax; use ?\\%c", c2);
13678  }
13679  }
13680  ternary:
13681  pushback(c);
13682  lex_state = EXPR_VALUE;
13683  return '?';
13684  }
13685  newtok();
13686  enc = current_enc;
13687  if (!parser_isascii()) {
13688  if (tokadd_mbchar(c) == -1) return 0;
13689  }
13690  else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13692  goto ternary;
13693  }
13694  else if (c == '\\') {
13695  if (peek('u')) {
13696  nextc();
13697  c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13698  if (0x80 <= c) {
13699  tokaddmbc(c, enc);
13700  }
13701  else {
13702  tokadd(c);
13703  }
13704  }
13705  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13706  nextc();
13707  if (tokadd_mbchar(c) == -1) return 0;
13708  }
13709  else {
13710  c = read_escape(0, &enc);
13711  tokadd(c);
13712  }
13713  }
13714  else {
13715  tokadd(c);
13716  }
13717  tokfix();
13718  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13719  lex_state = EXPR_END;
13720  return tCHAR;
13721 
13722  case '&':
13723  if ((c = nextc()) == '&') {
13724  lex_state = EXPR_BEG;
13725  if ((c = nextc()) == '=') {
13727  lex_state = EXPR_BEG;
13728  return tOP_ASGN;
13729  }
13730  pushback(c);
13731  return tANDOP;
13732  }
13733  else if (c == '=') {
13734  set_yylval_id('&');
13735  lex_state = EXPR_BEG;
13736  return tOP_ASGN;
13737  }
13738  pushback(c);
13739  if (IS_SPCARG(c)) {
13740  rb_warning0("`&' interpreted as argument prefix");
13741  c = tAMPER;
13742  }
13743  else if (IS_BEG()) {
13744  c = tAMPER;
13745  }
13746  else {
13747  warn_balanced("&", "argument prefix");
13748  c = '&';
13749  }
13750  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13751  return c;
13752 
13753  case '|':
13754  if ((c = nextc()) == '|') {
13755  lex_state = EXPR_BEG;
13756  if ((c = nextc()) == '=') {
13758  lex_state = EXPR_BEG;
13759  return tOP_ASGN;
13760  }
13761  pushback(c);
13762  return tOROP;
13763  }
13764  if (c == '=') {
13765  set_yylval_id('|');
13766  lex_state = EXPR_BEG;
13767  return tOP_ASGN;
13768  }
13769  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13770  pushback(c);
13771  return '|';
13772 
13773  case '+':
13774  c = nextc();
13775  if (IS_AFTER_OPERATOR()) {
13776  lex_state = EXPR_ARG;
13777  if (c == '@') {
13778  return tUPLUS;
13779  }
13780  pushback(c);
13781  return '+';
13782  }
13783  if (c == '=') {
13784  set_yylval_id('+');
13785  lex_state = EXPR_BEG;
13786  return tOP_ASGN;
13787  }
13788  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13789  lex_state = EXPR_BEG;
13790  pushback(c);
13791  if (c != -1 && ISDIGIT(c)) {
13792  c = '+';
13793  goto start_num;
13794  }
13795  return tUPLUS;
13796  }
13797  lex_state = EXPR_BEG;
13798  pushback(c);
13799  warn_balanced("+", "unary operator");
13800  return '+';
13801 
13802  case '-':
13803  c = nextc();
13804  if (IS_AFTER_OPERATOR()) {
13805  lex_state = EXPR_ARG;
13806  if (c == '@') {
13807  return tUMINUS;
13808  }
13809  pushback(c);
13810  return '-';
13811  }
13812  if (c == '=') {
13813  set_yylval_id('-');
13814  lex_state = EXPR_BEG;
13815  return tOP_ASGN;
13816  }
13817  if (c == '>') {
13818  lex_state = EXPR_ENDFN;
13819  return tLAMBDA;
13820  }
13821  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13822  lex_state = EXPR_BEG;
13823  pushback(c);
13824  if (c != -1 && ISDIGIT(c)) {
13825  return tUMINUS_NUM;
13826  }
13827  return tUMINUS;
13828  }
13829  lex_state = EXPR_BEG;
13830  pushback(c);
13831  warn_balanced("-", "unary operator");
13832  return '-';
13833 
13834  case '.':
13835  lex_state = EXPR_BEG;
13836  if ((c = nextc()) == '.') {
13837  if ((c = nextc()) == '.') {
13838  return tDOT3;
13839  }
13840  pushback(c);
13841  return tDOT2;
13842  }
13843  pushback(c);
13844  if (c != -1 && ISDIGIT(c)) {
13845  yyerror("no .<digit> floating literal anymore; put 0 before dot");
13846  }
13847  lex_state = EXPR_DOT;
13848  return '.';
13849 
13850  start_num:
13851  case '0': case '1': case '2': case '3': case '4':
13852  case '5': case '6': case '7': case '8': case '9':
13853  {
13854  int is_float, seen_point, seen_e, nondigit;
13855 
13856  is_float = seen_point = seen_e = nondigit = 0;
13857  lex_state = EXPR_END;
13858  newtok();
13859  if (c == '-' || c == '+') {
13860  tokadd(c);
13861  c = nextc();
13862  }
13863  if (c == '0') {
13864 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
13865  int start = toklen();
13866  c = nextc();
13867  if (c == 'x' || c == 'X') {
13868  /* hexadecimal */
13869  c = nextc();
13870  if (c != -1 && ISXDIGIT(c)) {
13871  do {
13872  if (c == '_') {
13873  if (nondigit) break;
13874  nondigit = c;
13875  continue;
13876  }
13877  if (!ISXDIGIT(c)) break;
13878  nondigit = 0;
13879  tokadd(c);
13880  } while ((c = nextc()) != -1);
13881  }
13882  pushback(c);
13883  tokfix();
13884  if (toklen() == start) {
13885  no_digits();
13886  }
13887  else if (nondigit) goto trailing_uc;
13889  return tINTEGER;
13890  }
13891  if (c == 'b' || c == 'B') {
13892  /* binary */
13893  c = nextc();
13894  if (c == '0' || c == '1') {
13895  do {
13896  if (c == '_') {
13897  if (nondigit) break;
13898  nondigit = c;
13899  continue;
13900  }
13901  if (c != '0' && c != '1') break;
13902  nondigit = 0;
13903  tokadd(c);
13904  } while ((c = nextc()) != -1);
13905  }
13906  pushback(c);
13907  tokfix();
13908  if (toklen() == start) {
13909  no_digits();
13910  }
13911  else if (nondigit) goto trailing_uc;
13913  return tINTEGER;
13914  }
13915  if (c == 'd' || c == 'D') {
13916  /* decimal */
13917  c = nextc();
13918  if (c != -1 && ISDIGIT(c)) {
13919  do {
13920  if (c == '_') {
13921  if (nondigit) break;
13922  nondigit = c;
13923  continue;
13924  }
13925  if (!ISDIGIT(c)) break;
13926  nondigit = 0;
13927  tokadd(c);
13928  } while ((c = nextc()) != -1);
13929  }
13930  pushback(c);
13931  tokfix();
13932  if (toklen() == start) {
13933  no_digits();
13934  }
13935  else if (nondigit) goto trailing_uc;
13937  return tINTEGER;
13938  }
13939  if (c == '_') {
13940  /* 0_0 */
13941  goto octal_number;
13942  }
13943  if (c == 'o' || c == 'O') {
13944  /* prefixed octal */
13945  c = nextc();
13946  if (c == -1 || c == '_' || !ISDIGIT(c)) {
13947  no_digits();
13948  }
13949  }
13950  if (c >= '0' && c <= '7') {
13951  /* octal */
13952  octal_number:
13953  do {
13954  if (c == '_') {
13955  if (nondigit) break;
13956  nondigit = c;
13957  continue;
13958  }
13959  if (c < '0' || c > '9') break;
13960  if (c > '7') goto invalid_octal;
13961  nondigit = 0;
13962  tokadd(c);
13963  } while ((c = nextc()) != -1);
13964  if (toklen() > start) {
13965  pushback(c);
13966  tokfix();
13967  if (nondigit) goto trailing_uc;
13969  return tINTEGER;
13970  }
13971  if (nondigit) {
13972  pushback(c);
13973  goto trailing_uc;
13974  }
13975  }
13976  if (c > '7' && c <= '9') {
13977  invalid_octal:
13978  yyerror("Invalid octal digit");
13979  }
13980  else if (c == '.' || c == 'e' || c == 'E') {
13981  tokadd('0');
13982  }
13983  else {
13984  pushback(c);
13986  return tINTEGER;
13987  }
13988  }
13989 
13990  for (;;) {
13991  switch (c) {
13992  case '0': case '1': case '2': case '3': case '4':
13993  case '5': case '6': case '7': case '8': case '9':
13994  nondigit = 0;
13995  tokadd(c);
13996  break;
13997 
13998  case '.':
13999  if (nondigit) goto trailing_uc;
14000  if (seen_point || seen_e) {
14001  goto decode_num;
14002  }
14003  else {
14004  int c0 = nextc();
14005  if (c0 == -1 || !ISDIGIT(c0)) {
14006  pushback(c0);
14007  goto decode_num;
14008  }
14009  c = c0;
14010  }
14011  tokadd('.');
14012  tokadd(c);
14013  is_float++;
14014  seen_point++;
14015  nondigit = 0;
14016  break;
14017 
14018  case 'e':
14019  case 'E':
14020  if (nondigit) {
14021  pushback(c);
14022  c = nondigit;
14023  goto decode_num;
14024  }
14025  if (seen_e) {
14026  goto decode_num;
14027  }
14028  tokadd(c);
14029  seen_e++;
14030  is_float++;
14031  nondigit = c;
14032  c = nextc();
14033  if (c != '-' && c != '+') continue;
14034  tokadd(c);
14035  nondigit = c;
14036  break;
14037 
14038  case '_': /* `_' in number just ignored */
14039  if (nondigit) goto decode_num;
14040  nondigit = c;
14041  break;
14042 
14043  default:
14044  goto decode_num;
14045  }
14046  c = nextc();
14047  }
14048 
14049  decode_num:
14050  pushback(c);
14051  if (nondigit) {
14052  char tmp[30];
14053  trailing_uc:
14054  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14055  yyerror(tmp);
14056  }
14057  tokfix();
14058  if (is_float) {
14059  double d = strtod(tok(), 0);
14060  if (errno == ERANGE) {
14061  rb_warningS("Float %s out of range", tok());
14062  errno = 0;
14063  }
14065  return tFLOAT;
14066  }
14068  return tINTEGER;
14069  }
14070 
14071  case ')':
14072  case ']':
14073  paren_nest--;
14074  case '}':
14075  COND_LEXPOP();
14076  CMDARG_LEXPOP();
14077  if (c == ')')
14078  lex_state = EXPR_ENDFN;
14079  else
14080  lex_state = EXPR_ENDARG;
14081  if (c == '}') {
14082  if (!brace_nest--) c = tSTRING_DEND;
14083  }
14084  return c;
14085 
14086  case ':':
14087  c = nextc();
14088  if (c == ':') {
14089  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14090  lex_state = EXPR_BEG;
14091  return tCOLON3;
14092  }
14093  lex_state = EXPR_DOT;
14094  return tCOLON2;
14095  }
14096  if (IS_END() || ISSPACE(c)) {
14097  pushback(c);
14098  warn_balanced(":", "symbol literal");
14099  lex_state = EXPR_BEG;
14100  return ':';
14101  }
14102  switch (c) {
14103  case '\'':
14104  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14105  break;
14106  case '"':
14107  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14108  break;
14109  default:
14110  pushback(c);
14111  break;
14112  }
14113  lex_state = EXPR_FNAME;
14114  return tSYMBEG;
14115 
14116  case '/':
14117  if (IS_lex_state(EXPR_BEG_ANY)) {
14118  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14119  return tREGEXP_BEG;
14120  }
14121  if ((c = nextc()) == '=') {
14122  set_yylval_id('/');
14123  lex_state = EXPR_BEG;
14124  return tOP_ASGN;
14125  }
14126  pushback(c);
14127  if (IS_SPCARG(c)) {
14128  (void)arg_ambiguous();
14129  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14130  return tREGEXP_BEG;
14131  }
14132  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14133  warn_balanced("/", "regexp literal");
14134  return '/';
14135 
14136  case '^':
14137  if ((c = nextc()) == '=') {
14138  set_yylval_id('^');
14139  lex_state = EXPR_BEG;
14140  return tOP_ASGN;
14141  }
14142  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14143  pushback(c);
14144  return '^';
14145 
14146  case ';':
14147  lex_state = EXPR_BEG;
14148  command_start = TRUE;
14149  return ';';
14150 
14151  case ',':
14152  lex_state = EXPR_BEG;
14153  return ',';
14154 
14155  case '~':
14156  if (IS_AFTER_OPERATOR()) {
14157  if ((c = nextc()) != '@') {
14158  pushback(c);
14159  }
14160  lex_state = EXPR_ARG;
14161  }
14162  else {
14163  lex_state = EXPR_BEG;
14164  }
14165  return '~';
14166 
14167  case '(':
14168  if (IS_BEG()) {
14169  c = tLPAREN;
14170  }
14171  else if (IS_SPCARG(-1)) {
14172  c = tLPAREN_ARG;
14173  }
14174  paren_nest++;
14175  COND_PUSH(0);
14176  CMDARG_PUSH(0);
14177  lex_state = EXPR_BEG;
14178  return c;
14179 
14180  case '[':
14181  paren_nest++;
14182  if (IS_AFTER_OPERATOR()) {
14183  lex_state = EXPR_ARG;
14184  if ((c = nextc()) == ']') {
14185  if ((c = nextc()) == '=') {
14186  return tASET;
14187  }
14188  pushback(c);
14189  return tAREF;
14190  }
14191  pushback(c);
14192  return '[';
14193  }
14194  else if (IS_BEG()) {
14195  c = tLBRACK;
14196  }
14197  else if (IS_ARG() && space_seen) {
14198  c = tLBRACK;
14199  }
14200  lex_state = EXPR_BEG;
14201  COND_PUSH(0);
14202  CMDARG_PUSH(0);
14203  return c;
14204 
14205  case '{':
14206  ++brace_nest;
14207  if (lpar_beg && lpar_beg == paren_nest) {
14208  lex_state = EXPR_BEG;
14209  lpar_beg = 0;
14210  --paren_nest;
14211  COND_PUSH(0);
14212  CMDARG_PUSH(0);
14213  return tLAMBEG;
14214  }
14215  if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14216  c = '{'; /* block (primary) */
14217  else if (IS_lex_state(EXPR_ENDARG))
14218  c = tLBRACE_ARG; /* block (expr) */
14219  else
14220  c = tLBRACE; /* hash */
14221  COND_PUSH(0);
14222  CMDARG_PUSH(0);
14223  lex_state = EXPR_BEG;
14224  if (c != tLBRACE) command_start = TRUE;
14225  return c;
14226 
14227  case '\\':
14228  c = nextc();
14229  if (c == '\n') {
14230  space_seen = 1;
14231 #ifdef RIPPER
14232  ripper_dispatch_scan_event(parser, tSP);
14233 #endif
14234  goto retry; /* skip \\n */
14235  }
14236  pushback(c);
14237  return '\\';
14238 
14239  case '%':
14240  if (IS_lex_state(EXPR_BEG_ANY)) {
14241  int term;
14242  int paren;
14243 
14244  c = nextc();
14245  quotation:
14246  if (c == -1 || !ISALNUM(c)) {
14247  term = c;
14248  c = 'Q';
14249  }
14250  else {
14251  term = nextc();
14252  if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14253  yyerror("unknown type of %string");
14254  return 0;
14255  }
14256  }
14257  if (c == -1 || term == -1) {
14258  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14259  return 0;
14260  }
14261  paren = term;
14262  if (term == '(') term = ')';
14263  else if (term == '[') term = ']';
14264  else if (term == '{') term = '}';
14265  else if (term == '<') term = '>';
14266  else paren = 0;
14267 
14268  switch (c) {
14269  case 'Q':
14270  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14271  return tSTRING_BEG;
14272 
14273  case 'q':
14274  lex_strterm = NEW_STRTERM(str_squote, term, paren);
14275  return tSTRING_BEG;
14276 
14277  case 'W':
14278  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14279  do {c = nextc();} while (ISSPACE(c));
14280  pushback(c);
14281  return tWORDS_BEG;
14282 
14283  case 'w':
14284  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14285  do {c = nextc();} while (ISSPACE(c));
14286  pushback(c);
14287  return tQWORDS_BEG;
14288 
14289  case 'I':
14290  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14291  do {c = nextc();} while (ISSPACE(c));
14292  pushback(c);
14293  return tSYMBOLS_BEG;
14294 
14295  case 'i':
14296  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14297  do {c = nextc();} while (ISSPACE(c));
14298  pushback(c);
14299  return tQSYMBOLS_BEG;
14300 
14301  case 'x':
14302  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14303  return tXSTRING_BEG;
14304 
14305  case 'r':
14306  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14307  return tREGEXP_BEG;
14308 
14309  case 's':
14310  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14311  lex_state = EXPR_FNAME;
14312  return tSYMBEG;
14313 
14314  default:
14315  yyerror("unknown type of %string");
14316  return 0;
14317  }
14318  }
14319  if ((c = nextc()) == '=') {
14320  set_yylval_id('%');
14321  lex_state = EXPR_BEG;
14322  return tOP_ASGN;
14323  }
14324  if (IS_SPCARG(c)) {
14325  goto quotation;
14326  }
14327  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14328  pushback(c);
14329  warn_balanced("%%", "string literal");
14330  return '%';
14331 
14332  case '$':
14333  lex_state = EXPR_END;
14334  newtok();
14335  c = nextc();
14336  switch (c) {
14337  case '_': /* $_: last read line string */
14338  c = nextc();
14339  if (parser_is_identchar()) {
14340  tokadd('$');
14341  tokadd('_');
14342  break;
14343  }
14344  pushback(c);
14345  c = '_';
14346  /* fall through */
14347  case '~': /* $~: match-data */
14348  case '*': /* $*: argv */
14349  case '$': /* $$: pid */
14350  case '?': /* $?: last status */
14351  case '!': /* $!: error string */
14352  case '@': /* $@: error position */
14353  case '/': /* $/: input record separator */
14354  case '\\': /* $\: output record separator */
14355  case ';': /* $;: field separator */
14356  case ',': /* $,: output field separator */
14357  case '.': /* $.: last read line number */
14358  case '=': /* $=: ignorecase */
14359  case ':': /* $:: load path */
14360  case '<': /* $<: reading filename */
14361  case '>': /* $>: default output handle */
14362  case '\"': /* $": already loaded files */
14363  tokadd('$');
14364  tokadd(c);
14365  tokfix();
14367  return tGVAR;
14368 
14369  case '-':
14370  tokadd('$');
14371  tokadd(c);
14372  c = nextc();
14373  if (parser_is_identchar()) {
14374  if (tokadd_mbchar(c) == -1) return 0;
14375  }
14376  else {
14377  pushback(c);
14378  }
14379  gvar:
14380  tokfix();
14382  return tGVAR;
14383 
14384  case '&': /* $&: last match */
14385  case '`': /* $`: string before last match */
14386  case '\'': /* $': string after last match */
14387  case '+': /* $+: string matches last paren. */
14388  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14389  tokadd('$');
14390  tokadd(c);
14391  goto gvar;
14392  }
14394  return tBACK_REF;
14395 
14396  case '1': case '2': case '3':
14397  case '4': case '5': case '6':
14398  case '7': case '8': case '9':
14399  tokadd('$');
14400  do {
14401  tokadd(c);
14402  c = nextc();
14403  } while (c != -1 && ISDIGIT(c));
14404  pushback(c);
14405  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14406  tokfix();
14407  set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
14408  return tNTH_REF;
14409 
14410  default:
14411  if (!parser_is_identchar()) {
14412  pushback(c);
14413  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14414  return 0;
14415  }
14416  case '0':
14417  tokadd('$');
14418  }
14419  break;
14420 
14421  case '@':
14422  c = nextc();
14423  newtok();
14424  tokadd('@');
14425  if (c == '@') {
14426  tokadd('@');
14427  c = nextc();
14428  }
14429  if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14430  pushback(c);
14431  if (tokidx == 1) {
14432  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14433  }
14434  else {
14435  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14436  }
14437  return 0;
14438  }
14439  break;
14440 
14441  case '_':
14442  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14443  ruby__end__seen = 1;
14444  parser->eofp = Qtrue;
14445 #ifndef RIPPER
14446  return -1;
14447 #else
14448  lex_goto_eol(parser);
14449  ripper_dispatch_scan_event(parser, k__END__);
14450  return 0;
14451 #endif
14452  }
14453  newtok();
14454  break;
14455 
14456  default:
14457  if (!parser_is_identchar()) {
14458  rb_compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14459  goto retry;
14460  }
14461 
14462  newtok();
14463  break;
14464  }
14465 
14466  mb = ENC_CODERANGE_7BIT;
14467  do {
14468  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14469  if (tokadd_mbchar(c) == -1) return 0;
14470  c = nextc();
14471  } while (parser_is_identchar());
14472  switch (tok()[0]) {
14473  case '@': case '$':
14474  pushback(c);
14475  break;
14476  default:
14477  if ((c == '!' || c == '?') && !peek('=')) {
14478  tokadd(c);
14479  }
14480  else {
14481  pushback(c);
14482  }
14483  }
14484  tokfix();
14485 
14486  {
14487  int result = 0;
14488 
14489  last_state = lex_state;
14490  switch (tok()[0]) {
14491  case '$':
14492  lex_state = EXPR_END;
14493  result = tGVAR;
14494  break;
14495  case '@':
14496  lex_state = EXPR_END;
14497  if (tok()[1] == '@')
14498  result = tCVAR;
14499  else
14500  result = tIVAR;
14501  break;
14502 
14503  default:
14504  if (toklast() == '!' || toklast() == '?') {
14505  result = tFID;
14506  }
14507  else {
14508  if (IS_lex_state(EXPR_FNAME)) {
14509  if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14510  (!peek('=') || (peek_n('>', 1)))) {
14511  result = tIDENTIFIER;
14512  tokadd(c);
14513  tokfix();
14514  }
14515  else {
14516  pushback(c);
14517  }
14518  }
14519  if (result == 0 && ISUPPER(tok()[0])) {
14520  result = tCONSTANT;
14521  }
14522  else {
14523  result = tIDENTIFIER;
14524  }
14525  }
14526 
14527  if (IS_LABEL_POSSIBLE()) {
14528  if (IS_LABEL_SUFFIX(0)) {
14529  lex_state = EXPR_BEG;
14530  nextc();
14532  return tLABEL;
14533  }
14534  }
14535  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14536  const struct kwtable *kw;
14537 
14538  /* See if it is a reserved word. */
14539  kw = rb_reserved_word(tok(), toklen());
14540  if (kw) {
14541  enum lex_state_e state = lex_state;
14542  lex_state = kw->state;
14543  if (state == EXPR_FNAME) {
14545  return kw->id[0];
14546  }
14547  if (lex_state == EXPR_BEG) {
14548  command_start = TRUE;
14549  }
14550  if (kw->id[0] == keyword_do) {
14551  if (lpar_beg && lpar_beg == paren_nest) {
14552  lpar_beg = 0;
14553  --paren_nest;
14554  return keyword_do_LAMBDA;
14555  }
14556  if (COND_P()) return keyword_do_cond;
14557  if (CMDARG_P() && state != EXPR_CMDARG)
14558  return keyword_do_block;
14559  if (state & (EXPR_BEG | EXPR_ENDARG))
14560  return keyword_do_block;
14561  return keyword_do;
14562  }
14563  if (state & (EXPR_BEG | EXPR_VALUE))
14564  return kw->id[0];
14565  else {
14566  if (kw->id[0] != kw->id[1])
14567  lex_state = EXPR_BEG;
14568  return kw->id[1];
14569  }
14570  }
14571  }
14572 
14573  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14574  if (cmd_state) {
14575  lex_state = EXPR_CMDARG;
14576  }
14577  else {
14578  lex_state = EXPR_ARG;
14579  }
14580  }
14581  else if (lex_state == EXPR_FNAME) {
14582  lex_state = EXPR_ENDFN;
14583  }
14584  else {
14585  lex_state = EXPR_END;
14586  }
14587  }
14588  {
14589  ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14590 
14591  set_yylval_name(ident);
14592  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14593  is_local_id(ident) && lvar_defined(ident)) {
14594  lex_state = EXPR_END;
14595  }
14596  }
14597  return result;
14598  }
14599 }
14600 
14601 #if YYPURE
14602 static int
14603 yylex(void *lval, void *p)
14604 #else
14605 yylex(void *p)
14606 #endif
14607 {
14608  struct parser_params *parser = (struct parser_params*)p;
14609  int t;
14610 
14611 #if YYPURE
14612  parser->parser_yylval = lval;
14613  parser->parser_yylval->val = Qundef;
14614 #endif
14615  t = parser_yylex(parser);
14616 #ifdef RIPPER
14617  if (!NIL_P(parser->delayed)) {
14618  ripper_dispatch_delayed_token(parser, t);
14619  return t;
14620  }
14621  if (t != 0)
14622  ripper_dispatch_scan_event(parser, t);
14623 #endif
14624 
14625  return t;
14626 }
14627 
14628 #ifndef RIPPER
14629 static NODE*
14630 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14631 {
14632  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14634  return n;
14635 }
14636 
14637 static enum node_type
14638 nodetype(NODE *node) /* for debug */
14639 {
14640  return (enum node_type)nd_type(node);
14641 }
14642 
14643 static int
14645 {
14646  return nd_line(node);
14647 }
14648 
14649 static NODE*
14651 {
14652  if (node) {
14653  node = remove_begin(node);
14654  node->flags |= NODE_FL_NEWLINE;
14655  }
14656  return node;
14657 }
14658 
14659 static void
14660 fixpos(NODE *node, NODE *orig)
14661 {
14662  if (!node) return;
14663  if (!orig) return;
14664  if (orig == (NODE*)1) return;
14665  nd_set_line(node, nd_line(orig));
14666 }
14667 
14668 static void
14669 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14670 {
14671  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14672 }
14673 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14674 
14675 static void
14676 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14677 {
14678  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14679 }
14680 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14681 
14682 static NODE*
14683 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14684 {
14685  NODE *end, *h = head, *nd;
14686 
14687  if (tail == 0) return head;
14688 
14689  if (h == 0) return tail;
14690  switch (nd_type(h)) {
14691  case NODE_LIT:
14692  case NODE_STR:
14693  case NODE_SELF:
14694  case NODE_TRUE:
14695  case NODE_FALSE:
14696  case NODE_NIL:
14697  parser_warning(h, "unused literal ignored");
14698  return tail;
14699  default:
14700  h = end = NEW_BLOCK(head);
14701  end->nd_end = end;
14702  fixpos(end, head);
14703  head = end;
14704  break;
14705  case NODE_BLOCK:
14706  end = h->nd_end;
14707  break;
14708  }
14709 
14710  nd = end->nd_head;
14711  switch (nd_type(nd)) {
14712  case NODE_RETURN:
14713  case NODE_BREAK:
14714  case NODE_NEXT:
14715  case NODE_REDO:
14716  case NODE_RETRY:
14717  if (RTEST(ruby_verbose)) {
14718  parser_warning(tail, "statement not reached");
14719  }
14720  break;
14721 
14722  default:
14723  break;
14724  }
14725 
14726  if (nd_type(tail) != NODE_BLOCK) {
14727  tail = NEW_BLOCK(tail);
14728  tail->nd_end = tail;
14729  }
14730  end->nd_next = tail;
14731  h->nd_end = tail->nd_end;
14732  return head;
14733 }
14734 
14735 /* append item to the list */
14736 static NODE*
14737 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14738 {
14739  NODE *last;
14740 
14741  if (list == 0) return NEW_LIST(item);
14742  if (list->nd_next) {
14743  last = list->nd_next->nd_end;
14744  }
14745  else {
14746  last = list;
14747  }
14748 
14749  list->nd_alen += 1;
14750  last->nd_next = NEW_LIST(item);
14751  list->nd_next->nd_end = last->nd_next;
14752  return list;
14753 }
14754 
14755 /* concat two lists */
14756 static NODE*
14757 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14758 {
14759  NODE *last;
14760 
14761  if (head->nd_next) {
14762  last = head->nd_next->nd_end;
14763  }
14764  else {
14765  last = head;
14766  }
14767 
14768  head->nd_alen += tail->nd_alen;
14769  last->nd_next = tail;
14770  if (tail->nd_next) {
14771  head->nd_next->nd_end = tail->nd_next->nd_end;
14772  }
14773  else {
14774  head->nd_next->nd_end = tail;
14775  }
14776 
14777  return head;
14778 }
14779 
14780 static int
14782 {
14783  if (NIL_P(tail)) return 1;
14784  if (!rb_enc_compatible(head, tail)) {
14785  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14786  rb_enc_name(rb_enc_get(head)),
14787  rb_enc_name(rb_enc_get(tail)));
14788  rb_str_resize(head, 0);
14789  rb_str_resize(tail, 0);
14790  return 0;
14791  }
14792  rb_str_buf_append(head, tail);
14793  return 1;
14794 }
14795 
14796 /* concat two string literals */
14797 static NODE *
14799 {
14800  enum node_type htype;
14801  NODE *headlast;
14802  VALUE lit;
14803 
14804  if (!head) return tail;
14805  if (!tail) return head;
14806 
14807  htype = nd_type(head);
14808  if (htype == NODE_EVSTR) {
14809  NODE *node = NEW_DSTR(Qnil);
14810  head = list_append(node, head);
14811  htype = NODE_DSTR;
14812  }
14813  switch (nd_type(tail)) {
14814  case NODE_STR:
14815  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14816  nd_type(headlast) == NODE_STR) {
14817  htype = NODE_STR;
14818  lit = headlast->nd_lit;
14819  }
14820  else {
14821  lit = head->nd_lit;
14822  }
14823  if (htype == NODE_STR) {
14824  if (!literal_concat0(parser, lit, tail->nd_lit)) {
14825  error:
14826  rb_gc_force_recycle((VALUE)head);
14827  rb_gc_force_recycle((VALUE)tail);
14828  return 0;
14829  }
14830  rb_gc_force_recycle((VALUE)tail);
14831  }
14832  else {
14833  list_append(head, tail);
14834  }
14835  break;
14836 
14837  case NODE_DSTR:
14838  if (htype == NODE_STR) {
14839  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14840  goto error;
14841  tail->nd_lit = head->nd_lit;
14842  rb_gc_force_recycle((VALUE)head);
14843  head = tail;
14844  }
14845  else if (NIL_P(tail->nd_lit)) {
14846  append:
14847  head->nd_alen += tail->nd_alen - 1;
14848  head->nd_next->nd_end->nd_next = tail->nd_next;
14849  head->nd_next->nd_end = tail->nd_next->nd_end;
14850  rb_gc_force_recycle((VALUE)tail);
14851  }
14852  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14853  nd_type(headlast) == NODE_STR) {
14854  lit = headlast->nd_lit;
14855  if (!literal_concat0(parser, lit, tail->nd_lit))
14856  goto error;
14857  tail->nd_lit = Qnil;
14858  goto append;
14859  }
14860  else {
14861  nd_set_type(tail, NODE_ARRAY);
14862  tail->nd_head = NEW_STR(tail->nd_lit);
14863  list_concat(head, tail);
14864  }
14865  break;
14866 
14867  case NODE_EVSTR:
14868  if (htype == NODE_STR) {
14869  nd_set_type(head, NODE_DSTR);
14870  head->nd_alen = 1;
14871  }
14872  list_append(head, tail);
14873  break;
14874  }
14875  return head;
14876 }
14877 
14878 static NODE *
14879 evstr2dstr_gen(struct parser_params *parser, NODE *node)
14880 {
14881  if (nd_type(node) == NODE_EVSTR) {
14882  node = list_append(NEW_DSTR(Qnil), node);
14883  }
14884  return node;
14885 }
14886 
14887 static NODE *
14888 new_evstr_gen(struct parser_params *parser, NODE *node)
14889 {
14890  NODE *head = node;
14891 
14892  if (node) {
14893  switch (nd_type(node)) {
14894  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
14895  return node;
14896  }
14897  }
14898  return NEW_EVSTR(head);
14899 }
14900 
14901 static NODE *
14902 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
14903 {
14904  value_expr(recv);
14905  value_expr(arg1);
14906  return NEW_CALL(recv, id, NEW_LIST(arg1));
14907 }
14908 
14909 static NODE *
14910 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
14911 {
14912  value_expr(recv);
14913  return NEW_CALL(recv, id, 0);
14914 }
14915 
14916 static NODE*
14917 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
14918 {
14919  value_expr(node1);
14920  value_expr(node2);
14921  if (node1) {
14922  switch (nd_type(node1)) {
14923  case NODE_DREGX:
14924  case NODE_DREGX_ONCE:
14925  return NEW_MATCH2(node1, node2);
14926 
14927  case NODE_LIT:
14928  if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
14929  return NEW_MATCH2(node1, node2);
14930  }
14931  }
14932  }
14933 
14934  if (node2) {
14935  switch (nd_type(node2)) {
14936  case NODE_DREGX:
14937  case NODE_DREGX_ONCE:
14938  return NEW_MATCH3(node2, node1);
14939 
14940  case NODE_LIT:
14941  if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
14942  return NEW_MATCH3(node2, node1);
14943  }
14944  }
14945  }
14946 
14947  return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
14948 }
14949 
14950 static NODE*
14951 gettable_gen(struct parser_params *parser, ID id)
14952 {
14953  switch (id) {
14954  case keyword_self:
14955  return NEW_SELF();
14956  case keyword_nil:
14957  return NEW_NIL();
14958  case keyword_true:
14959  return NEW_TRUE();
14960  case keyword_false:
14961  return NEW_FALSE();
14962  case keyword__FILE__:
14965  case keyword__LINE__:
14966  return NEW_LIT(INT2FIX(tokline));
14967  case keyword__ENCODING__:
14969  }
14970  switch (id_type(id)) {
14971  case ID_LOCAL:
14972  if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
14973  if (local_id(id)) return NEW_LVAR(id);
14974  /* method call without arguments */
14975  return NEW_VCALL(id);
14976  case ID_GLOBAL:
14977  return NEW_GVAR(id);
14978  case ID_INSTANCE:
14979  return NEW_IVAR(id);
14980  case ID_CONST:
14981  return NEW_CONST(id);
14982  case ID_CLASS:
14983  return NEW_CVAR(id);
14984  }
14985  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
14986  return 0;
14987 }
14988 #else /* !RIPPER */
14989 static int
14990 id_is_var_gen(struct parser_params *parser, ID id)
14991 {
14992  if (is_notop_id(id)) {
14993  switch (id & ID_SCOPE_MASK) {
14994  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
14995  return 1;
14996  case ID_LOCAL:
14997  if (dyna_in_block() && dvar_defined(id)) return 1;
14998  if (local_id(id)) return 1;
14999  /* method call without arguments */
15000  return 0;
15001  }
15002  }
15003  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15004  return 0;
15005 }
15006 #endif /* !RIPPER */
15007 
15008 #if PARSER_DEBUG
15009 static const char *
15010 lex_state_name(enum lex_state_e state)
15011 {
15012  static const char names[][12] = {
15013  "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG",
15014  "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS",
15015  "EXPR_VALUE",
15016  };
15017 
15018  if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
15019  return names[ffs(state)];
15020  return NULL;
15021 }
15022 #endif
15023 
15024 #ifdef RIPPER
15025 static VALUE
15026 assignable_gen(struct parser_params *parser, VALUE lhs)
15027 #else
15028 static NODE*
15029 assignable_gen(struct parser_params *parser, ID id, NODE *val)
15030 #endif
15031 {
15032 #ifdef RIPPER
15033  ID id = get_id(lhs);
15034 # define assignable_result(x) get_value(lhs)
15035 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
15036 #else
15037 # define assignable_result(x) (x)
15038 #endif
15039  if (!id) return assignable_result(0);
15040  switch (id) {
15041  case keyword_self:
15042  yyerror("Can't change the value of self");
15043  goto error;
15044  case keyword_nil:
15045  yyerror("Can't assign to nil");
15046  goto error;
15047  case keyword_true:
15048  yyerror("Can't assign to true");
15049  goto error;
15050  case keyword_false:
15051  yyerror("Can't assign to false");
15052  goto error;
15053  case keyword__FILE__:
15054  yyerror("Can't assign to __FILE__");
15055  goto error;
15056  case keyword__LINE__:
15057  yyerror("Can't assign to __LINE__");
15058  goto error;
15059  case keyword__ENCODING__:
15060  yyerror("Can't assign to __ENCODING__");
15061  goto error;
15062  }
15063  switch (id_type(id)) {
15064  case ID_LOCAL:
15065  if (dyna_in_block()) {
15066  if (dvar_curr(id)) {
15067  return assignable_result(NEW_DASGN_CURR(id, val));
15068  }
15069  else if (dvar_defined(id)) {
15070  return assignable_result(NEW_DASGN(id, val));
15071  }
15072  else if (local_id(id)) {
15073  return assignable_result(NEW_LASGN(id, val));
15074  }
15075  else {
15076  dyna_var(id);
15077  return assignable_result(NEW_DASGN_CURR(id, val));
15078  }
15079  }
15080  else {
15081  if (!local_id(id)) {
15082  local_var(id);
15083  }
15084  return assignable_result(NEW_LASGN(id, val));
15085  }
15086  break;
15087  case ID_GLOBAL:
15088  return assignable_result(NEW_GASGN(id, val));
15089  case ID_INSTANCE:
15090  return assignable_result(NEW_IASGN(id, val));
15091  case ID_CONST:
15092  if (!in_def && !in_single)
15093  return assignable_result(NEW_CDECL(id, val, 0));
15094  yyerror("dynamic constant assignment");
15095  break;
15096  case ID_CLASS:
15097  return assignable_result(NEW_CVASGN(id, val));
15098  default:
15099  compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15100  }
15101  error:
15102  return assignable_result(0);
15103 #undef assignable_result
15104 #undef parser_yyerror
15105 }
15106 
15107 static int
15109 {
15110  VALUE s;
15111  if (name == idUScore) return 1;
15112  if (!is_local_id(name)) return 0;
15113  s = rb_id2str(name);
15114  if (!s) return 0;
15115  return RSTRING_PTR(s)[0] == '_';
15116 }
15117 
15118 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15119 
15120 static ID
15121 shadowing_lvar_gen(struct parser_params *parser, ID name)
15122 {
15123  if (is_private_local_id(name)) return name;
15124  if (dyna_in_block()) {
15125  if (dvar_curr(name)) {
15126  yyerror("duplicated argument name");
15127  }
15128  else if (dvar_defined_get(name) || local_id(name)) {
15129  rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15130  vtable_add(lvtbl->vars, name);
15131  if (lvtbl->used) {
15133  }
15134  }
15135  }
15136  else {
15137  if (local_id(name)) {
15138  yyerror("duplicated argument name");
15139  }
15140  }
15141  return name;
15142 }
15143 
15144 static void
15145 new_bv_gen(struct parser_params *parser, ID name)
15146 {
15147  if (!name) return;
15148  if (!is_local_id(name)) {
15149  compile_error(PARSER_ARG "invalid local variable - %s",
15150  rb_id2name(name));
15151  return;
15152  }
15153  shadowing_lvar(name);
15154  dyna_var(name);
15155 }
15156 
15157 #ifndef RIPPER
15158 static NODE *
15159 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15160 {
15161  if (recv && nd_type(recv) == NODE_SELF)
15162  recv = (NODE *)1;
15163  return NEW_ATTRASGN(recv, tASET, idx);
15164 }
15165 
15166 static void
15167 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15168 {
15169  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15170  compile_error(PARSER_ARG "both block arg and actual block given");
15171  }
15172 }
15173 
15174 ID
15176 {
15177  id &= ~ID_SCOPE_MASK;
15178  id |= ID_ATTRSET;
15179  return id;
15180 }
15181 
15182 static NODE *
15183 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15184 {
15185  if (recv && nd_type(recv) == NODE_SELF)
15186  recv = (NODE *)1;
15187  return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15188 }
15189 
15190 static void
15192 {
15193  switch (nd_type(node)) {
15194  case NODE_NTH_REF:
15195  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15196  break;
15197  case NODE_BACK_REF:
15198  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15199  break;
15200  }
15201 }
15202 
15203 static NODE *
15204 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15205 {
15206  if (!node2) return node1;
15207  switch (nd_type(node1)) {
15208  case NODE_BLOCK_PASS:
15209  if (node1->nd_head)
15210  node1->nd_head = arg_concat(node1->nd_head, node2);
15211  else
15212  node1->nd_head = NEW_LIST(node2);
15213  return node1;
15214  case NODE_ARGSPUSH:
15215  if (nd_type(node2) != NODE_ARRAY) break;
15216  node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15217  nd_set_type(node1, NODE_ARGSCAT);
15218  return node1;
15219  case NODE_ARGSCAT:
15220  if (nd_type(node2) != NODE_ARRAY ||
15221  nd_type(node1->nd_body) != NODE_ARRAY) break;
15222  node1->nd_body = list_concat(node1->nd_body, node2);
15223  return node1;
15224  }
15225  return NEW_ARGSCAT(node1, node2);
15226 }
15227 
15228 static NODE *
15229 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15230 {
15231  if (!node1) return NEW_LIST(node2);
15232  switch (nd_type(node1)) {
15233  case NODE_ARRAY:
15234  return list_append(node1, node2);
15235  case NODE_BLOCK_PASS:
15236  node1->nd_head = arg_append(node1->nd_head, node2);
15237  return node1;
15238  case NODE_ARGSPUSH:
15239  node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15240  nd_set_type(node1, NODE_ARGSCAT);
15241  return node1;
15242  }
15243  return NEW_ARGSPUSH(node1, node2);
15244 }
15245 
15246 static NODE *
15248 {
15249  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15250  if (nd_type(node) == NODE_ARRAY) return node;
15251  return 0;
15252 }
15253 
15254 static NODE *
15255 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15256 {
15257  if (!lhs) return 0;
15258 
15259  switch (nd_type(lhs)) {
15260  case NODE_GASGN:
15261  case NODE_IASGN:
15262  case NODE_IASGN2:
15263  case NODE_LASGN:
15264  case NODE_DASGN:
15265  case NODE_DASGN_CURR:
15266  case NODE_MASGN:
15267  case NODE_CDECL:
15268  case NODE_CVASGN:
15269  lhs->nd_value = rhs;
15270  break;
15271 
15272  case NODE_ATTRASGN:
15273  case NODE_CALL:
15274  lhs->nd_args = arg_append(lhs->nd_args, rhs);
15275  break;
15276 
15277  default:
15278  /* should not happen */
15279  break;
15280  }
15281 
15282  return lhs;
15283 }
15284 
15285 static int
15286 value_expr_gen(struct parser_params *parser, NODE *node)
15287 {
15288  int cond = 0;
15289 
15290  if (!node) {
15291  rb_warning0("empty expression");
15292  }
15293  while (node) {
15294  switch (nd_type(node)) {
15295  case NODE_DEFN:
15296  case NODE_DEFS:
15297  parser_warning(node, "void value expression");
15298  return FALSE;
15299 
15300  case NODE_RETURN:
15301  case NODE_BREAK:
15302  case NODE_NEXT:
15303  case NODE_REDO:
15304  case NODE_RETRY:
15305  if (!cond) yyerror("void value expression");
15306  /* or "control never reach"? */
15307  return FALSE;
15308 
15309  case NODE_BLOCK:
15310  while (node->nd_next) {
15311  node = node->nd_next;
15312  }
15313  node = node->nd_head;
15314  break;
15315 
15316  case NODE_BEGIN:
15317  node = node->nd_body;
15318  break;
15319 
15320  case NODE_IF:
15321  if (!node->nd_body) {
15322  node = node->nd_else;
15323  break;
15324  }
15325  else if (!node->nd_else) {
15326  node = node->nd_body;
15327  break;
15328  }
15329  if (!value_expr(node->nd_body)) return FALSE;
15330  node = node->nd_else;
15331  break;
15332 
15333  case NODE_AND:
15334  case NODE_OR:
15335  cond = 1;
15336  node = node->nd_2nd;
15337  break;
15338 
15339  default:
15340  return TRUE;
15341  }
15342  }
15343 
15344  return TRUE;
15345 }
15346 
15347 static void
15348 void_expr_gen(struct parser_params *parser, NODE *node)
15349 {
15350  const char *useless = 0;
15351 
15352  if (!RTEST(ruby_verbose)) return;
15353 
15354  if (!node) return;
15355  switch (nd_type(node)) {
15356  case NODE_CALL:
15357  switch (node->nd_mid) {
15358  case '+':
15359  case '-':
15360  case '*':
15361  case '/':
15362  case '%':
15363  case tPOW:
15364  case tUPLUS:
15365  case tUMINUS:
15366  case '|':
15367  case '^':
15368  case '&':
15369  case tCMP:
15370  case '>':
15371  case tGEQ:
15372  case '<':
15373  case tLEQ:
15374  case tEQ:
15375  case tNEQ:
15376  useless = rb_id2name(node->nd_mid);
15377  break;
15378  }
15379  break;
15380 
15381  case NODE_LVAR:
15382  case NODE_DVAR:
15383  case NODE_GVAR:
15384  case NODE_IVAR:
15385  case NODE_CVAR:
15386  case NODE_NTH_REF:
15387  case NODE_BACK_REF:
15388  useless = "a variable";
15389  break;
15390  case NODE_CONST:
15391  useless = "a constant";
15392  break;
15393  case NODE_LIT:
15394  case NODE_STR:
15395  case NODE_DSTR:
15396  case NODE_DREGX:
15397  case NODE_DREGX_ONCE:
15398  useless = "a literal";
15399  break;
15400  case NODE_COLON2:
15401  case NODE_COLON3:
15402  useless = "::";
15403  break;
15404  case NODE_DOT2:
15405  useless = "..";
15406  break;
15407  case NODE_DOT3:
15408  useless = "...";
15409  break;
15410  case NODE_SELF:
15411  useless = "self";
15412  break;
15413  case NODE_NIL:
15414  useless = "nil";
15415  break;
15416  case NODE_TRUE:
15417  useless = "true";
15418  break;
15419  case NODE_FALSE:
15420  useless = "false";
15421  break;
15422  case NODE_DEFINED:
15423  useless = "defined?";
15424  break;
15425  }
15426 
15427  if (useless) {
15428  int line = ruby_sourceline;
15429 
15430  ruby_sourceline = nd_line(node);
15431  rb_warnS("possibly useless use of %s in void context", useless);
15432  ruby_sourceline = line;
15433  }
15434 }
15435 
15436 static void
15437 void_stmts_gen(struct parser_params *parser, NODE *node)
15438 {
15439  if (!RTEST(ruby_verbose)) return;
15440  if (!node) return;
15441  if (nd_type(node) != NODE_BLOCK) return;
15442 
15443  for (;;) {
15444  if (!node->nd_next) return;
15445  void_expr0(node->nd_head);
15446  node = node->nd_next;
15447  }
15448 }
15449 
15450 static NODE *
15452 {
15453  NODE **n = &node, *n1 = node;
15454  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15455  *n = n1 = n1->nd_body;
15456  }
15457  return node;
15458 }
15459 
15460 static void
15461 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15462 {
15463  NODE *node = *body;
15464 
15465  if (!node) {
15466  *body = NEW_NIL();
15467  return;
15468  }
15469 #define subnodes(n1, n2) \
15470  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15471  (!node->n2) ? (body = &node->n1, 1) : \
15472  (reduce_nodes(&node->n1), body = &node->n2, 1))
15473 
15474  while (node) {
15475  int newline = (int)(node->flags & NODE_FL_NEWLINE);
15476  switch (nd_type(node)) {
15477  end:
15478  case NODE_NIL:
15479  *body = 0;
15480  return;
15481  case NODE_RETURN:
15482  *body = node = node->nd_stts;
15483  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15484  continue;
15485  case NODE_BEGIN:
15486  *body = node = node->nd_body;
15487  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15488  continue;
15489  case NODE_BLOCK:
15490  body = &node->nd_end->nd_head;
15491  break;
15492  case NODE_IF:
15493  if (subnodes(nd_body, nd_else)) break;
15494  return;
15495  case NODE_CASE:
15496  body = &node->nd_body;
15497  break;
15498  case NODE_WHEN:
15499  if (!subnodes(nd_body, nd_next)) goto end;
15500  break;
15501  case NODE_ENSURE:
15502  if (!subnodes(nd_head, nd_resq)) goto end;
15503  break;
15504  case NODE_RESCUE:
15505  if (node->nd_else) {
15506  body = &node->nd_resq;
15507  break;
15508  }
15509  if (!subnodes(nd_head, nd_resq)) goto end;
15510  break;
15511  default:
15512  return;
15513  }
15514  node = *body;
15515  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15516  }
15517 
15518 #undef subnodes
15519 }
15520 
15521 static int
15523 {
15524  if (!node) return 1;
15525  switch (nd_type(node)) {
15526  case NODE_HASH:
15527  if (!(node = node->nd_head)) break;
15528  case NODE_ARRAY:
15529  do {
15530  if (!is_static_content(node->nd_head)) return 0;
15531  } while ((node = node->nd_next) != 0);
15532  case NODE_LIT:
15533  case NODE_STR:
15534  case NODE_NIL:
15535  case NODE_TRUE:
15536  case NODE_FALSE:
15537  case NODE_ZARRAY:
15538  break;
15539  default:
15540  return 0;
15541  }
15542  return 1;
15543 }
15544 
15545 static int
15546 assign_in_cond(struct parser_params *parser, NODE *node)
15547 {
15548  switch (nd_type(node)) {
15549  case NODE_MASGN:
15550  yyerror("multiple assignment in conditional");
15551  return 1;
15552 
15553  case NODE_LASGN:
15554  case NODE_DASGN:
15555  case NODE_DASGN_CURR:
15556  case NODE_GASGN:
15557  case NODE_IASGN:
15558  break;
15559 
15560  default:
15561  return 0;
15562  }
15563 
15564  if (!node->nd_value) return 1;
15565  if (is_static_content(node->nd_value)) {
15566  /* reports always */
15567  parser_warn(node->nd_value, "found = in conditional, should be ==");
15568  }
15569  return 1;
15570 }
15571 
15572 static void
15573 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15574 {
15575  if (!e_option_supplied(parser)) parser_warn(node, str);
15576 }
15577 
15578 static void
15579 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15580 {
15581  if (!e_option_supplied(parser)) parser_warning(node, str);
15582 }
15583 
15584 static void
15585 fixup_nodes(NODE **rootnode)
15586 {
15587  NODE *node, *next, *head;
15588 
15589  for (node = *rootnode; node; node = next) {
15590  enum node_type type;
15591  VALUE val;
15592 
15593  next = node->nd_next;
15594  head = node->nd_head;
15595  rb_gc_force_recycle((VALUE)node);
15596  *rootnode = next;
15597  switch (type = nd_type(head)) {
15598  case NODE_DOT2:
15599  case NODE_DOT3:
15600  val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15601  type == NODE_DOT3);
15602  rb_gc_force_recycle((VALUE)head->nd_beg);
15603  rb_gc_force_recycle((VALUE)head->nd_end);
15604  nd_set_type(head, NODE_LIT);
15605  head->nd_lit = val;
15606  break;
15607  default:
15608  break;
15609  }
15610  }
15611 }
15612 
15613 static NODE *cond0(struct parser_params*,NODE*);
15614 
15615 static NODE*
15616 range_op(struct parser_params *parser, NODE *node)
15617 {
15618  enum node_type type;
15619 
15620  if (node == 0) return 0;
15621 
15622  type = nd_type(node);
15623  value_expr(node);
15624  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15625  warn_unless_e_option(parser, node, "integer literal in conditional range");
15626  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15627  }
15628  return cond0(parser, node);
15629 }
15630 
15631 static int
15633 {
15634  if (!node) return 1; /* same as NODE_NIL */
15635  switch (nd_type(node)) {
15636  case NODE_LIT:
15637  case NODE_STR:
15638  case NODE_DSTR:
15639  case NODE_EVSTR:
15640  case NODE_DREGX:
15641  case NODE_DREGX_ONCE:
15642  case NODE_DSYM:
15643  return 2;
15644  case NODE_TRUE:
15645  case NODE_FALSE:
15646  case NODE_NIL:
15647  return 1;
15648  }
15649  return 0;
15650 }
15651 
15652 static NODE*
15653 cond0(struct parser_params *parser, NODE *node)
15654 {
15655  if (node == 0) return 0;
15656  assign_in_cond(parser, node);
15657 
15658  switch (nd_type(node)) {
15659  case NODE_DSTR:
15660  case NODE_EVSTR:
15661  case NODE_STR:
15662  rb_warn0("string literal in condition");
15663  break;
15664 
15665  case NODE_DREGX:
15666  case NODE_DREGX_ONCE:
15667  warning_unless_e_option(parser, node, "regex literal in condition");
15668  return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15669 
15670  case NODE_AND:
15671  case NODE_OR:
15672  node->nd_1st = cond0(parser, node->nd_1st);
15673  node->nd_2nd = cond0(parser, node->nd_2nd);
15674  break;
15675 
15676  case NODE_DOT2:
15677  case NODE_DOT3:
15678  node->nd_beg = range_op(parser, node->nd_beg);
15679  node->nd_end = range_op(parser, node->nd_end);
15680  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15681  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15682  if (!e_option_supplied(parser)) {
15683  int b = literal_node(node->nd_beg);
15684  int e = literal_node(node->nd_end);
15685  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15686  parser_warn(node, "range literal in condition");
15687  }
15688  }
15689  break;
15690 
15691  case NODE_DSYM:
15692  parser_warning(node, "literal in condition");
15693  break;
15694 
15695  case NODE_LIT:
15696  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
15697  warn_unless_e_option(parser, node, "regex literal in condition");
15698  nd_set_type(node, NODE_MATCH);
15699  }
15700  else {
15701  parser_warning(node, "literal in condition");
15702  }
15703  default:
15704  break;
15705  }
15706  return node;
15707 }
15708 
15709 static NODE*
15710 cond_gen(struct parser_params *parser, NODE *node)
15711 {
15712  if (node == 0) return 0;
15713  return cond0(parser, node);
15714 }
15715 
15716 static NODE*
15717 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15718 {
15719  value_expr(left);
15720  if (left && (enum node_type)nd_type(left) == type) {
15721  NODE *node = left, *second;
15722  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15723  node = second;
15724  }
15725  node->nd_2nd = NEW_NODE(type, second, right, 0);
15726  return left;
15727  }
15728  return NEW_NODE(type, left, right, 0);
15729 }
15730 
15731 static void
15732 no_blockarg(struct parser_params *parser, NODE *node)
15733 {
15734  if (node && nd_type(node) == NODE_BLOCK_PASS) {
15735  compile_error(PARSER_ARG "block argument should not be given");
15736  }
15737 }
15738 
15739 static NODE *
15740 ret_args_gen(struct parser_params *parser, NODE *node)
15741 {
15742  if (node) {
15743  no_blockarg(parser, node);
15744  if (nd_type(node) == NODE_ARRAY) {
15745  if (node->nd_next == 0) {
15746  node = node->nd_head;
15747  }
15748  else {
15749  nd_set_type(node, NODE_VALUES);
15750  }
15751  }
15752  }
15753  return node;
15754 }
15755 
15756 static NODE *
15757 new_yield_gen(struct parser_params *parser, NODE *node)
15758 {
15759  if (node) no_blockarg(parser, node);
15760 
15761  return NEW_YIELD(node);
15762 }
15763 
15764 static NODE*
15766 {
15767  switch (TYPE(node->nd_lit)) {
15768  case T_FIXNUM:
15769  node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15770  break;
15771  case T_BIGNUM:
15772  node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15773  break;
15774  case T_FLOAT:
15775 #if USE_FLONUM
15776  if (FLONUM_P(node->nd_lit)) {
15777  node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
15778  }
15779  else {
15780  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15781  }
15782 #else
15783  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
15784 #endif
15785  break;
15786  default:
15787  break;
15788  }
15789  return node;
15790 }
15791 
15792 static NODE *
15793 arg_blk_pass(NODE *node1, NODE *node2)
15794 {
15795  if (node2) {
15796  node2->nd_head = node1;
15797  return node2;
15798  }
15799  return node1;
15800 }
15801 
15802 
15803 static NODE*
15804 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
15805 {
15806  int saved_line = ruby_sourceline;
15807  struct rb_args_info *args = tail->nd_ainfo;
15808 
15809  args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0;
15810  args->pre_init = m ? m->nd_next : 0;
15811 
15812  args->post_args_num = p ? rb_long2int(p->nd_plen) : 0;
15813  args->post_init = p ? p->nd_next : 0;
15814  args->first_post_arg = p ? p->nd_pid : 0;
15815 
15816  args->rest_arg = r;
15817 
15818  args->opt_args = o;
15819 
15820  ruby_sourceline = saved_line;
15821 
15822  return tail;
15823 }
15824 
15825 static NODE*
15826 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
15827 {
15828  int saved_line = ruby_sourceline;
15829  struct rb_args_info *args;
15830  NODE *kw_rest_arg = 0;
15831  NODE *node;
15832 
15833  args = ALLOC(struct rb_args_info);
15834  MEMZERO(args, struct rb_args_info, 1);
15835  node = NEW_NODE(NODE_ARGS, 0, 0, args);
15836 
15837  args->block_arg = b;
15838  args->kw_args = k;
15839  if (k && !kr) kr = internal_id();
15840  if (kr) {
15841  arg_var(kr);
15842  kw_rest_arg = NEW_DVAR(kr);
15843  }
15844  args->kw_rest_arg = kw_rest_arg;
15845 
15846  ruby_sourceline = saved_line;
15847  return node;
15848 }
15849 
15850 static NODE*
15851 dsym_node_gen(struct parser_params *parser, NODE *node)
15852 {
15853  VALUE lit;
15854 
15855  if (!node) {
15856  return NEW_LIT(ID2SYM(idNULL));
15857  }
15858 
15859  switch (nd_type(node)) {
15860  case NODE_DSTR:
15861  nd_set_type(node, NODE_DSYM);
15862  break;
15863  case NODE_STR:
15864  lit = node->nd_lit;
15865  node->nd_lit = ID2SYM(rb_intern_str(lit));
15866  nd_set_type(node, NODE_LIT);
15867  break;
15868  default:
15869  node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
15870  break;
15871  }
15872  return node;
15873 }
15874 #endif /* !RIPPER */
15875 
15876 #ifndef RIPPER
15877 static NODE *
15878 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
15879 {
15880  NODE *asgn;
15881 
15882  if (lhs) {
15883  ID vid = lhs->nd_vid;
15884  if (op == tOROP) {
15885  lhs->nd_value = rhs;
15886  asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
15887  if (is_asgn_or_id(vid)) {
15888  asgn->nd_aid = vid;
15889  }
15890  }
15891  else if (op == tANDOP) {
15892  lhs->nd_value = rhs;
15893  asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
15894  }
15895  else {
15896  asgn = lhs;
15897  asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
15898  }
15899  }
15900  else {
15901  asgn = NEW_BEGIN(0);
15902  }
15903  return asgn;
15904 }
15905 
15906 static NODE *
15907 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
15908 {
15909  NODE *asgn;
15910 
15911  if (op == tOROP) {
15912  op = 0;
15913  }
15914  else if (op == tANDOP) {
15915  op = 1;
15916  }
15917  asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
15918  fixpos(asgn, lhs);
15919  return asgn;
15920 }
15921 
15922 static NODE *
15923 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
15924 {
15925  NODE *asgn;
15926 
15927  if (op == tOROP) {
15928  op = 0;
15929  }
15930  else if (op == tANDOP) {
15931  op = 1;
15932  }
15933  if (lhs) {
15934  asgn = NEW_OP_CDECL(lhs, op, rhs);
15935  }
15936  else {
15937  asgn = NEW_BEGIN(0);
15938  }
15939  fixpos(asgn, lhs);
15940  return asgn;
15941 }
15942 #else
15943 static VALUE
15944 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
15945 {
15946  return dispatch3(opassign, lhs, op, rhs);
15947 }
15948 
15949 static VALUE
15950 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
15951 {
15952  VALUE recv = dispatch3(field, lhs, type, attr);
15953  return dispatch3(opassign, recv, op, rhs);
15954 }
15955 #endif
15956 
15957 static void
15958 warn_unused_var(struct parser_params *parser, struct local_vars *local)
15959 {
15960  int i, cnt;
15961  ID *v, *u;
15962 
15963  if (!local->used) return;
15964  v = local->vars->tbl;
15965  u = local->used->tbl;
15966  cnt = local->used->pos;
15967  if (cnt != local->vars->pos) {
15968  rb_bug("local->used->pos != local->vars->pos");
15969  }
15970  for (i = 0; i < cnt; ++i) {
15971  if (!v[i] || (u[i] & LVAR_USED)) continue;
15972  if (is_private_local_id(v[i])) continue;
15973  rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
15974  }
15975 }
15976 
15977 static void
15978 local_push_gen(struct parser_params *parser, int inherit_dvars)
15979 {
15980  struct local_vars *local;
15981 
15982  local = ALLOC(struct local_vars);
15983  local->prev = lvtbl;
15984  local->args = vtable_alloc(0);
15985  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
15986  local->used = !(inherit_dvars &&
15988  RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
15989  lvtbl = local;
15990 }
15991 
15992 static void
15994 {
15995  struct local_vars *local = lvtbl->prev;
15996  if (lvtbl->used) {
15997  warn_unused_var(parser, lvtbl);
15998  vtable_free(lvtbl->used);
15999  }
16000  vtable_free(lvtbl->args);
16001  vtable_free(lvtbl->vars);
16002  xfree(lvtbl);
16003  lvtbl = local;
16004 }
16005 
16006 #ifndef RIPPER
16007 static ID*
16008 vtable_tblcpy(ID *buf, const struct vtable *src)
16009 {
16010  int i, cnt = vtable_size(src);
16011 
16012  if (cnt > 0) {
16013  buf[0] = cnt;
16014  for (i = 0; i < cnt; i++) {
16015  buf[i] = src->tbl[i];
16016  }
16017  return buf;
16018  }
16019  return 0;
16020 }
16021 
16022 static ID*
16024 {
16025  int cnt = vtable_size(lvtbl->args) + vtable_size(lvtbl->vars);
16026  ID *buf;
16027 
16028  if (cnt <= 0) return 0;
16029  buf = ALLOC_N(ID, cnt + 1);
16030  vtable_tblcpy(buf+1, lvtbl->args);
16031  vtable_tblcpy(buf+vtable_size(lvtbl->args)+1, lvtbl->vars);
16032  buf[0] = cnt;
16033  return buf;
16034 }
16035 #endif
16036 
16037 static int
16038 arg_var_gen(struct parser_params *parser, ID id)
16039 {
16040  vtable_add(lvtbl->args, id);
16041  return vtable_size(lvtbl->args) - 1;
16042 }
16043 
16044 static int
16045 local_var_gen(struct parser_params *parser, ID id)
16046 {
16047  vtable_add(lvtbl->vars, id);
16048  if (lvtbl->used) {
16050  }
16051  return vtable_size(lvtbl->vars) - 1;
16052 }
16053 
16054 static int
16055 local_id_gen(struct parser_params *parser, ID id)
16056 {
16057  struct vtable *vars, *args, *used;
16058 
16059  vars = lvtbl->vars;
16060  args = lvtbl->args;
16061  used = lvtbl->used;
16062 
16063  while (vars && POINTER_P(vars->prev)) {
16064  vars = vars->prev;
16065  args = args->prev;
16066  if (used) used = used->prev;
16067  }
16068 
16069  if (vars && vars->prev == DVARS_INHERIT) {
16070  return rb_local_defined(id);
16071  }
16072  else if (vtable_included(args, id)) {
16073  return 1;
16074  }
16075  else {
16076  int i = vtable_included(vars, id);
16077  if (i && used) used->tbl[i-1] |= LVAR_USED;
16078  return i != 0;
16079  }
16080 }
16081 
16082 static const struct vtable *
16084 {
16085  lvtbl->args = vtable_alloc(lvtbl->args);
16086  lvtbl->vars = vtable_alloc(lvtbl->vars);
16087  if (lvtbl->used) {
16088  lvtbl->used = vtable_alloc(lvtbl->used);
16089  }
16090  return lvtbl->args;
16091 }
16092 
16093 static void
16094 dyna_pop_1(struct parser_params *parser)
16095 {
16096  struct vtable *tmp;
16097 
16098  if ((tmp = lvtbl->used) != 0) {
16099  warn_unused_var(parser, lvtbl);
16100  lvtbl->used = lvtbl->used->prev;
16101  vtable_free(tmp);
16102  }
16103  tmp = lvtbl->args;
16104  lvtbl->args = lvtbl->args->prev;
16105  vtable_free(tmp);
16106  tmp = lvtbl->vars;
16107  lvtbl->vars = lvtbl->vars->prev;
16108  vtable_free(tmp);
16109 }
16110 
16111 static void
16112 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16113 {
16114  while (lvtbl->args != lvargs) {
16115  dyna_pop_1(parser);
16116  if (!lvtbl->args) {
16117  struct local_vars *local = lvtbl->prev;
16118  xfree(lvtbl);
16119  lvtbl = local;
16120  }
16121  }
16122  dyna_pop_1(parser);
16123 }
16124 
16125 static int
16127 {
16128  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16129 }
16130 
16131 static int
16132 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16133 {
16134  struct vtable *vars, *args, *used;
16135  int i;
16136 
16137  args = lvtbl->args;
16138  vars = lvtbl->vars;
16139  used = lvtbl->used;
16140 
16141  while (POINTER_P(vars)) {
16142  if (vtable_included(args, id)) {
16143  return 1;
16144  }
16145  if ((i = vtable_included(vars, id)) != 0) {
16146  if (used) used->tbl[i-1] |= LVAR_USED;
16147  return 1;
16148  }
16149  args = args->prev;
16150  vars = vars->prev;
16151  if (get) used = 0;
16152  if (used) used = used->prev;
16153  }
16154 
16155  if (vars == DVARS_INHERIT) {
16156  return rb_dvar_defined(id);
16157  }
16158 
16159  return 0;
16160 }
16161 
16162 static int
16163 dvar_curr_gen(struct parser_params *parser, ID id)
16164 {
16165  return (vtable_included(lvtbl->args, id) ||
16166  vtable_included(lvtbl->vars, id));
16167 }
16168 
16169 #ifndef RIPPER
16170 static void
16172 {
16173  int c = RE_OPTION_ENCODING_IDX(options);
16174 
16175  if (c) {
16176  int opt, idx;
16177  rb_char_to_option_kcode(c, &opt, &idx);
16178  if (idx != ENCODING_GET(str) &&
16180  goto error;
16181  }
16182  ENCODING_SET(str, idx);
16183  }
16184  else if (RE_OPTION_ENCODING_NONE(options)) {
16185  if (!ENCODING_IS_ASCII8BIT(str) &&
16187  c = 'n';
16188  goto error;
16189  }
16191  }
16192  else if (current_enc == rb_usascii_encoding()) {
16194  /* raise in re.c */
16196  }
16197  else {
16199  }
16200  }
16201  return;
16202 
16203  error:
16205  "regexp encoding option '%c' differs from source encoding '%s'",
16206  c, rb_enc_name(rb_enc_get(str)));
16207 }
16208 
16209 static int
16211 {
16212  VALUE err;
16213  reg_fragment_setenc(str, options);
16214  err = rb_reg_check_preprocess(str);
16215  if (err != Qnil) {
16216  err = rb_obj_as_string(err);
16217  compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
16218  RB_GC_GUARD(err);
16219  return 0;
16220  }
16221  return 1;
16222 }
16223 
16224 typedef struct {
16225  struct parser_params* parser;
16226  rb_encoding *enc;
16227  NODE *succ_block;
16228  NODE *fail_block;
16229  int num;
16231 
16232 static int
16234  int back_num, int *back_refs, OnigRegex regex, void *arg0)
16235 {
16237  struct parser_params* parser = arg->parser;
16238  rb_encoding *enc = arg->enc;
16239  long len = name_end - name;
16240  const char *s = (const char *)name;
16241  ID var;
16242 
16243  arg->num++;
16244 
16245  if (arg->succ_block == 0) {
16246  arg->succ_block = NEW_BEGIN(0);
16247  arg->fail_block = NEW_BEGIN(0);
16248  }
16249 
16250  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16251  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16252  !rb_enc_symname2_p(s, len, enc)) {
16253  return ST_CONTINUE;
16254  }
16255  var = rb_intern3(s, len, enc);
16256  if (dvar_defined(var) || local_id(var)) {
16257  rb_warningS("named capture conflicts a local variable - %s",
16258  rb_id2name(var));
16259  }
16260  arg->succ_block = block_append(arg->succ_block,
16262  NEW_CALL(
16263  gettable(rb_intern("$~")),
16264  idAREF,
16265  NEW_LIST(NEW_LIT(ID2SYM(var))))
16266  )));
16267  arg->fail_block = block_append(arg->fail_block,
16269  return ST_CONTINUE;
16270 }
16271 
16272 static NODE *
16274 {
16276 
16277  arg.parser = parser;
16278  arg.enc = rb_enc_get(regexp);
16279  arg.succ_block = 0;
16280  arg.fail_block = 0;
16281  arg.num = 0;
16282  onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
16283 
16284  if (arg.num == 0)
16285  return match;
16286 
16287  return
16288  block_append(
16289  newline_node(match),
16290  NEW_IF(gettable(rb_intern("$~")),
16291  block_append(
16292  newline_node(arg.succ_block),
16293  newline_node(
16294  NEW_CALL(
16295  gettable(rb_intern("$~")),
16296  rb_intern("begin"),
16297  NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16298  block_append(
16299  newline_node(arg.fail_block),
16300  newline_node(
16301  NEW_LIT(Qnil)))));
16302 }
16303 
16304 static VALUE
16305 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16306 {
16307  VALUE re;
16308  VALUE err;
16309 
16310  reg_fragment_setenc(str, options);
16311  err = rb_errinfo();
16313  if (NIL_P(re)) {
16314  ID mesg = rb_intern("mesg");
16315  VALUE m = rb_attr_get(rb_errinfo(), mesg);
16316  rb_set_errinfo(err);
16317  if (!NIL_P(err)) {
16318  rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16319  }
16320  else {
16322  }
16323  return Qnil;
16324  }
16325  return re;
16326 }
16327 
16328 void
16330 {
16331 }
16332 
16333 NODE*
16335 {
16336  NODE *prelude = 0;
16337  NODE *scope = node;
16338  struct parser_params *parser;
16339 
16340  if (!node) return node;
16341 
16342  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16343 
16344  node = node->nd_body;
16345 
16346  if (nd_type(node) == NODE_PRELUDE) {
16347  prelude = node;
16348  node = node->nd_body;
16349  }
16350 
16351  node = block_append(node,
16352  NEW_FCALL(rb_intern("print"),
16353  NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16354  if (prelude) {
16355  prelude->nd_body = node;
16356  scope->nd_body = prelude;
16357  }
16358  else {
16359  scope->nd_body = node;
16360  }
16361 
16362  return scope;
16363 }
16364 
16365 NODE *
16366 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16367 {
16368  NODE *prelude = 0;
16369  NODE *scope = node;
16370  struct parser_params *parser;
16371 
16372  if (!node) return node;
16373 
16374  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16375 
16376  node = node->nd_body;
16377 
16378  if (nd_type(node) == NODE_PRELUDE) {
16379  prelude = node;
16380  node = node->nd_body;
16381  }
16382  if (split) {
16383  node = block_append(NEW_GASGN(rb_intern("$F"),
16384  NEW_CALL(NEW_GVAR(rb_intern("$_")),
16385  rb_intern("split"), 0)),
16386  node);
16387  }
16388  if (chop) {
16389  node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16390  rb_intern("chop!"), 0), node);
16391  }
16392 
16393  node = NEW_OPT_N(node);
16394 
16395  if (prelude) {
16396  prelude->nd_body = node;
16397  scope->nd_body = prelude;
16398  }
16399  else {
16400  scope->nd_body = node;
16401  }
16402 
16403  return scope;
16404 }
16405 
16406 static const struct {
16408  const char *name;
16409 } op_tbl[] = {
16410  {tDOT2, ".."},
16411  {tDOT3, "..."},
16412  {tPOW, "**"},
16413  {tDSTAR, "**"},
16414  {tUPLUS, "+@"},
16415  {tUMINUS, "-@"},
16416  {tCMP, "<=>"},
16417  {tGEQ, ">="},
16418  {tLEQ, "<="},
16419  {tEQ, "=="},
16420  {tEQQ, "==="},
16421  {tNEQ, "!="},
16422  {tMATCH, "=~"},
16423  {tNMATCH, "!~"},
16424  {tAREF, "[]"},
16425  {tASET, "[]="},
16426  {tLSHFT, "<<"},
16427  {tRSHFT, ">>"},
16428  {tCOLON2, "::"},
16429 };
16430 
16431 #define op_tbl_count numberof(op_tbl)
16432 
16433 #ifndef ENABLE_SELECTOR_NAMESPACE
16434 #define ENABLE_SELECTOR_NAMESPACE 0
16435 #endif
16436 
16437 static struct symbols {
16438  ID last_id;
16439  st_table *sym_id;
16440  st_table *id_str;
16441 #if ENABLE_SELECTOR_NAMESPACE
16442  st_table *ivar2_id;
16443  st_table *id_ivar2;
16444 #endif
16447 
16448 static const struct st_hash_type symhash = {
16450  rb_str_hash,
16451 };
16452 
16453 #if ENABLE_SELECTOR_NAMESPACE
16454 struct ivar2_key {
16455  ID id;
16456  VALUE klass;
16457 };
16458 
16459 static int
16460 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16461 {
16462  if (key1->id == key2->id && key1->klass == key2->klass) {
16463  return 0;
16464  }
16465  return 1;
16466 }
16467 
16468 static int
16469 ivar2_hash(struct ivar2_key *key)
16470 {
16471  return (key->id << 8) ^ (key->klass >> 2);
16472 }
16473 
16474 static const struct st_hash_type ivar2_hash_type = {
16475  ivar2_cmp,
16476  ivar2_hash,
16477 };
16478 #endif
16479 
16480 void
16482 {
16483  global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
16485 #if ENABLE_SELECTOR_NAMESPACE
16486  global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16487  global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16488 #endif
16489 
16490  (void)nodetype;
16491  (void)nodeline;
16492 #if PARSER_DEBUG
16493  (void)lex_state_name(-1);
16494 #endif
16495 
16496  Init_id();
16497 }
16498 
16499 void
16501 {
16505 }
16506 #endif /* !RIPPER */
16507 
16508 static ID
16510 {
16511  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16512  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16513  return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16514 }
16515 
16516 #ifndef RIPPER
16517 static int
16518 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16519 {
16520  int mb = 0;
16521 
16522  if (m >= e) return 0;
16523  if (is_global_name_punct(*m)) {
16524  ++m;
16525  }
16526  else if (*m == '-') {
16527  ++m;
16528  if (m < e && is_identchar(m, e, enc)) {
16529  if (!ISASCII(*m)) mb = 1;
16530  m += rb_enc_mbclen(m, e, enc);
16531  }
16532  }
16533  else {
16534  if (!rb_enc_isdigit(*m, enc)) return 0;
16535  do {
16536  if (!ISASCII(*m)) mb = 1;
16537  ++m;
16538  } while (m < e && rb_enc_isdigit(*m, enc));
16539  }
16540  return m == e ? mb + 1 : 0;
16541 }
16542 
16543 int
16544 rb_symname_p(const char *name)
16545 {
16546  return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16547 }
16548 
16549 int
16550 rb_enc_symname_p(const char *name, rb_encoding *enc)
16551 {
16552  return rb_enc_symname2_p(name, strlen(name), enc);
16553 }
16554 
16555 static int
16556 rb_enc_symname_type(const char *name, long len, rb_encoding *enc)
16557 {
16558  const char *m = name;
16559  const char *e = m + len;
16560  int type = ID_JUNK;
16561 
16562  if (!m || len <= 0) return -1;
16563  switch (*m) {
16564  case '\0':
16565  return -1;
16566 
16567  case '$':
16568  type = ID_GLOBAL;
16569  if (is_special_global_name(++m, e, enc)) return type;
16570  goto id;
16571 
16572  case '@':
16573  type = ID_INSTANCE;
16574  if (*++m == '@') {
16575  ++m;
16576  type = ID_CLASS;
16577  }
16578  goto id;
16579 
16580  case '<':
16581  switch (*++m) {
16582  case '<': ++m; break;
16583  case '=': if (*++m == '>') ++m; break;
16584  default: break;
16585  }
16586  break;
16587 
16588  case '>':
16589  switch (*++m) {
16590  case '>': case '=': ++m; break;
16591  }
16592  break;
16593 
16594  case '=':
16595  switch (*++m) {
16596  case '~': ++m; break;
16597  case '=': if (*++m == '=') ++m; break;
16598  default: return -1;
16599  }
16600  break;
16601 
16602  case '*':
16603  if (*++m == '*') ++m;
16604  break;
16605 
16606  case '+': case '-':
16607  if (*++m == '@') ++m;
16608  break;
16609 
16610  case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16611  ++m;
16612  break;
16613 
16614  case '[':
16615  if (*++m != ']') return -1;
16616  if (*++m == '=') ++m;
16617  break;
16618 
16619  case '!':
16620  if (len == 1) return ID_JUNK;
16621  switch (*++m) {
16622  case '=': case '~': ++m; break;
16623  default: return -1;
16624  }
16625  break;
16626 
16627  default:
16628  type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16629  id:
16630  if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16631  return -1;
16632  while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16633  switch (*m) {
16634  case '!': case '?':
16635  if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16636  type = ID_JUNK;
16637  ++m;
16638  break;
16639  case '=':
16640  if (type != ID_CONST && type != ID_LOCAL) return -1;
16641  type = ID_ATTRSET;
16642  ++m;
16643  break;
16644  }
16645  break;
16646  }
16647  return m == e ? type : -1;
16648 }
16649 
16650 int
16651 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16652 {
16653  return rb_enc_symname_type(name, len, enc) != -1;
16654 }
16655 
16656 static int
16658 {
16659  const char *ptr = StringValuePtr(name);
16660  long len = RSTRING_LEN(name);
16661  int type = rb_enc_symname_type(ptr, len, rb_enc_get(name));
16662  RB_GC_GUARD(name);
16663  return type;
16664 }
16665 
16666 static ID
16667 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16668 {
16669  VALUE str = rb_enc_str_new(name, len, enc);
16670  return register_symid_str(id, str);
16671 }
16672 
16673 static ID
16675 {
16676  OBJ_FREEZE(str);
16679  return id;
16680 }
16681 
16682 static int
16684 {
16685  if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
16686  switch (rb_enc_str_coderange(str)) {
16687  case ENC_CODERANGE_BROKEN:
16688  rb_raise(rb_eEncodingError, "invalid encoding symbol");
16689  case ENC_CODERANGE_7BIT:
16690  return TRUE;
16691  }
16692  return FALSE;
16693 }
16694 
16695 /*
16696  * _str_ itself will be registered at the global symbol table. _str_
16697  * can be modified before the registration, since the encoding will be
16698  * set to ASCII-8BIT if it is a special global name.
16699  */
16700 static ID intern_str(VALUE str);
16701 
16702 ID
16703 rb_intern3(const char *name, long len, rb_encoding *enc)
16704 {
16705  VALUE str;
16706  st_data_t data;
16707  struct RString fake_str;
16708  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
16709  fake_str.basic.klass = rb_cString;
16710  fake_str.as.heap.len = len;
16711  fake_str.as.heap.ptr = (char *)name;
16712  fake_str.as.heap.aux.capa = len;
16713  str = (VALUE)&fake_str;
16714  rb_enc_associate(str, enc);
16715  OBJ_FREEZE(str);
16716 
16717  if (st_lookup(global_symbols.sym_id, str, &data))
16718  return (ID)data;
16719 
16720  str = rb_enc_str_new(name, len, enc); /* make true string */
16721  return intern_str(str);
16722 }
16723 
16724 static ID
16726 {
16727  const char *name, *m, *e;
16728  long len, last;
16729  rb_encoding *enc, *symenc;
16730  unsigned char c;
16731  ID id;
16732  int mb;
16733 
16734  RSTRING_GETMEM(str, name, len);
16735  m = name;
16736  e = m + len;
16737  enc = rb_enc_get(str);
16738  symenc = enc;
16739 
16740  if (rb_cString && !rb_enc_asciicompat(enc)) {
16741  id = ID_JUNK;
16742  goto new_id;
16743  }
16744  last = len-1;
16745  id = 0;
16746  switch (*m) {
16747  case '$':
16748  id |= ID_GLOBAL;
16749  if ((mb = is_special_global_name(++m, e, enc)) != 0) {
16750  if (!--mb) symenc = rb_usascii_encoding();
16751  goto new_id;
16752  }
16753  break;
16754  case '@':
16755  if (m[1] == '@') {
16756  m++;
16757  id |= ID_CLASS;
16758  }
16759  else {
16760  id |= ID_INSTANCE;
16761  }
16762  m++;
16763  break;
16764  default:
16765  c = m[0];
16766  if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
16767  /* operators */
16768  int i;
16769 
16770  if (len == 1) {
16771  id = c;
16772  goto id_register;
16773  }
16774  for (i = 0; i < op_tbl_count; i++) {
16775  if (*op_tbl[i].name == *m &&
16776  strcmp(op_tbl[i].name, m) == 0) {
16777  id = op_tbl[i].token;
16778  goto id_register;
16779  }
16780  }
16781  }
16782 
16783  if (m[last] == '=') {
16784  /* attribute assignment */
16785  id = rb_intern3(name, last, enc);
16786  if (id > tLAST_OP_ID && !is_attrset_id(id)) {
16787  enc = rb_enc_get(rb_id2str(id));
16788  id = rb_id_attrset(id);
16789  goto id_register;
16790  }
16791  id = ID_ATTRSET;
16792  }
16793  else if (rb_enc_isupper(m[0], enc)) {
16794  id = ID_CONST;
16795  }
16796  else {
16797  id = ID_LOCAL;
16798  }
16799  break;
16800  }
16801  if (!rb_enc_isdigit(*m, enc)) {
16802  while (m <= name + last && is_identchar(m, e, enc)) {
16803  if (ISASCII(*m)) {
16804  m++;
16805  }
16806  else {
16807  m += rb_enc_mbclen(m, e, enc);
16808  }
16809  }
16810  }
16811  if (m - name < len) id = ID_JUNK;
16812  if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
16813  new_id:
16814  if (symenc != enc) rb_enc_associate(str, symenc);
16816  if (len > 20) {
16817  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
16818  name);
16819  }
16820  else {
16821  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
16822  (int)len, name);
16823  }
16824  }
16826  id_register:
16827  return register_symid_str(id, str);
16828 }
16829 
16830 ID
16831 rb_intern2(const char *name, long len)
16832 {
16833  return rb_intern3(name, len, rb_usascii_encoding());
16834 }
16835 
16836 #undef rb_intern
16837 ID
16838 rb_intern(const char *name)
16839 {
16840  return rb_intern2(name, strlen(name));
16841 }
16842 
16843 ID
16845 {
16846  st_data_t id;
16847 
16848  if (st_lookup(global_symbols.sym_id, str, &id))
16849  return (ID)id;
16850  return intern_str(rb_str_dup(str));
16851 }
16852 
16853 VALUE
16855 {
16856  st_data_t data;
16857 
16858  if (id < tLAST_TOKEN) {
16859  int i = 0;
16860 
16861  if (id < INT_MAX && rb_ispunct((int)id)) {
16862  VALUE str = global_symbols.op_sym[i = (int)id];
16863  if (!str) {
16864  char name[2];
16865  name[0] = (char)id;
16866  name[1] = 0;
16867  str = rb_usascii_str_new(name, 1);
16868  OBJ_FREEZE(str);
16869  global_symbols.op_sym[i] = str;
16870  }
16871  return str;
16872  }
16873  for (i = 0; i < op_tbl_count; i++) {
16874  if (op_tbl[i].token == id) {
16875  VALUE str = global_symbols.op_sym[i];
16876  if (!str) {
16877  str = rb_usascii_str_new2(op_tbl[i].name);
16878  OBJ_FREEZE(str);
16879  global_symbols.op_sym[i] = str;
16880  }
16881  return str;
16882  }
16883  }
16884  }
16885 
16886  if (st_lookup(global_symbols.id_str, id, &data)) {
16887  VALUE str = (VALUE)data;
16888  if (RBASIC(str)->klass == 0)
16889  RBASIC(str)->klass = rb_cString;
16890  return str;
16891  }
16892 
16893  if (is_attrset_id(id)) {
16894  ID id2 = (id & ~ID_SCOPE_MASK) | ID_LOCAL;
16895  VALUE str;
16896 
16897  while (!(str = rb_id2str(id2))) {
16898  if (!is_local_id(id2)) return 0;
16899  id2 = (id & ~ID_SCOPE_MASK) | ID_CONST;
16900  }
16901  str = rb_str_dup(str);
16902  rb_str_cat(str, "=", 1);
16903  rb_intern_str(str);
16904  if (st_lookup(global_symbols.id_str, id, &data)) {
16905  VALUE str = (VALUE)data;
16906  if (RBASIC(str)->klass == 0)
16907  RBASIC(str)->klass = rb_cString;
16908  return str;
16909  }
16910  }
16911  return 0;
16912 }
16913 
16914 const char *
16916 {
16917  VALUE str = rb_id2str(id);
16918 
16919  if (!str) return 0;
16920  return RSTRING_PTR(str);
16921 }
16922 
16923 static int
16925 {
16926  rb_ary_push(ary, ID2SYM(value));
16927  return ST_CONTINUE;
16928 }
16929 
16930 /*
16931  * call-seq:
16932  * Symbol.all_symbols => array
16933  *
16934  * Returns an array of all the symbols currently in Ruby's symbol
16935  * table.
16936  *
16937  * Symbol.all_symbols.size #=> 903
16938  * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
16939  * :chown, :EOFError, :$;, :String,
16940  * :LOCK_SH, :"setuid?", :$<,
16941  * :default_proc, :compact, :extend,
16942  * :Tms, :getwd, :$=, :ThreadGroup,
16943  * :wait2, :$>]
16944  */
16945 
16946 VALUE
16948 {
16950 
16952  return ary;
16953 }
16954 
16955 int
16957 {
16958  return is_const_id(id);
16959 }
16960 
16961 int
16963 {
16964  return is_class_id(id);
16965 }
16966 
16967 int
16969 {
16970  return is_global_id(id);
16971 }
16972 
16973 int
16975 {
16976  return is_instance_id(id);
16977 }
16978 
16979 int
16981 {
16982  return is_attrset_id(id);
16983 }
16984 
16985 int
16987 {
16988  return is_local_id(id);
16989 }
16990 
16991 int
16993 {
16994  return is_junk_id(id);
16995 }
16996 
17008 ID
17009 rb_check_id(volatile VALUE *namep)
17010 {
17011  st_data_t id;
17012  VALUE tmp;
17013  VALUE name = *namep;
17014 
17015  if (SYMBOL_P(name)) {
17016  return SYM2ID(name);
17017  }
17018  else if (!RB_TYPE_P(name, T_STRING)) {
17019  tmp = rb_check_string_type(name);
17020  if (NIL_P(tmp)) {
17021  tmp = rb_inspect(name);
17022  rb_raise(rb_eTypeError, "%s is not a symbol",
17023  RSTRING_PTR(tmp));
17024  }
17025  name = tmp;
17026  *namep = name;
17027  }
17028 
17029  sym_check_asciionly(name);
17030 
17031  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17032  return (ID)id;
17033 
17034  if (rb_is_attrset_name(name)) {
17035  struct RString fake_str;
17036  const VALUE localname = (VALUE)&fake_str;
17037  /* make local name by chopping '=' */
17038  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17039  fake_str.basic.klass = rb_cString;
17040  fake_str.as.heap.len = RSTRING_LEN(name) - 1;
17041  fake_str.as.heap.ptr = RSTRING_PTR(name);
17042  fake_str.as.heap.aux.capa = fake_str.as.heap.len;
17043  rb_enc_copy(localname, name);
17044  OBJ_FREEZE(localname);
17045 
17046  if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17047  return rb_id_attrset((ID)id);
17048  }
17049  RB_GC_GUARD(name);
17050  }
17051 
17052  return (ID)0;
17053 }
17054 
17055 ID
17056 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
17057 {
17058  st_data_t id;
17059  struct RString fake_str;
17060  const VALUE name = (VALUE)&fake_str;
17061  fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
17062  fake_str.basic.klass = rb_cString;
17063  fake_str.as.heap.len = len;
17064  fake_str.as.heap.ptr = (char *)ptr;
17065  fake_str.as.heap.aux.capa = len;
17066  rb_enc_associate(name, enc);
17067 
17068  sym_check_asciionly(name);
17069 
17070  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17071  return (ID)id;
17072 
17073  if (rb_is_attrset_name(name)) {
17074  fake_str.as.heap.len = len - 1;
17075  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
17076  return rb_id_attrset((ID)id);
17077  }
17078  }
17079 
17080  return (ID)0;
17081 }
17082 
17083 int
17085 {
17086  return rb_str_symname_type(name) == ID_CONST;
17087 }
17088 
17089 int
17091 {
17092  return rb_str_symname_type(name) == ID_CLASS;
17093 }
17094 
17095 int
17097 {
17098  return rb_str_symname_type(name) == ID_GLOBAL;
17099 }
17100 
17101 int
17103 {
17104  return rb_str_symname_type(name) == ID_INSTANCE;
17105 }
17106 
17107 int
17109 {
17110  return rb_str_symname_type(name) == ID_ATTRSET;
17111 }
17112 
17113 int
17115 {
17116  return rb_str_symname_type(name) == ID_LOCAL;
17117 }
17118 
17119 int
17121 {
17122  switch (rb_str_symname_type(name)) {
17123  case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17124  return TRUE;
17125  }
17126  return FALSE;
17127 }
17128 
17129 int
17131 {
17132  return rb_str_symname_type(name) == -1;
17133 }
17134 
17135 #endif /* !RIPPER */
17136 
17137 static void
17139 {
17140  parser->eofp = Qfalse;
17141 
17142  parser->parser_lex_strterm = 0;
17143  parser->parser_cond_stack = 0;
17144  parser->parser_cmdarg_stack = 0;
17145  parser->parser_class_nest = 0;
17146  parser->parser_paren_nest = 0;
17147  parser->parser_lpar_beg = 0;
17148  parser->parser_brace_nest = 0;
17149  parser->parser_in_single = 0;
17150  parser->parser_in_def = 0;
17151  parser->parser_in_defined = 0;
17152  parser->parser_compile_for_eval = 0;
17153  parser->parser_cur_mid = 0;
17154  parser->parser_tokenbuf = NULL;
17155  parser->parser_tokidx = 0;
17156  parser->parser_toksiz = 0;
17157  parser->parser_heredoc_end = 0;
17158  parser->parser_command_start = TRUE;
17159  parser->parser_deferred_nodes = 0;
17160  parser->parser_lex_pbeg = 0;
17161  parser->parser_lex_p = 0;
17162  parser->parser_lex_pend = 0;
17163  parser->parser_lvtbl = 0;
17164  parser->parser_ruby__end__seen = 0;
17165  parser->parser_ruby_sourcefile = 0;
17166 #ifndef RIPPER
17167  parser->is_ripper = 0;
17168  parser->parser_eval_tree_begin = 0;
17169  parser->parser_eval_tree = 0;
17170 #else
17171  parser->is_ripper = 1;
17172  parser->parser_ruby_sourcefile_string = Qnil;
17173  parser->delayed = Qnil;
17174 
17175  parser->result = Qnil;
17176  parser->parsing_thread = Qnil;
17177  parser->toplevel_p = TRUE;
17178 #endif
17179 #ifdef YYMALLOC
17180  parser->heap = NULL;
17181 #endif
17182  parser->enc = rb_utf8_encoding();
17183 }
17184 
17185 #ifdef RIPPER
17186 #define parser_mark ripper_parser_mark
17187 #define parser_free ripper_parser_free
17188 #endif
17189 
17190 static void
17192 {
17193  struct parser_params *p = (struct parser_params*)ptr;
17194 
17200 #ifndef RIPPER
17203  rb_gc_mark(p->debug_lines);
17204 #else
17205  rb_gc_mark(p->parser_ruby_sourcefile_string);
17206  rb_gc_mark(p->delayed);
17207  rb_gc_mark(p->value);
17208  rb_gc_mark(p->result);
17209  rb_gc_mark(p->parsing_thread);
17210 #endif
17211 #ifdef YYMALLOC
17212  rb_gc_mark((VALUE)p->heap);
17213 #endif
17214 }
17215 
17216 static void
17217 parser_free(void *ptr)
17218 {
17219  struct parser_params *p = (struct parser_params*)ptr;
17220  struct local_vars *local, *prev;
17221 
17222  if (p->parser_tokenbuf) {
17223  xfree(p->parser_tokenbuf);
17224  }
17225  for (local = p->parser_lvtbl; local; local = prev) {
17226  if (local->vars) xfree(local->vars);
17227  prev = local->prev;
17228  xfree(local);
17229  }
17230 #ifndef RIPPER
17232 #endif
17233  xfree(p);
17234 }
17235 
17236 static size_t
17237 parser_memsize(const void *ptr)
17238 {
17239  struct parser_params *p = (struct parser_params*)ptr;
17240  struct local_vars *local;
17241  size_t size = sizeof(*p);
17242 
17243  if (!ptr) return 0;
17244  size += p->parser_toksiz;
17245  for (local = p->parser_lvtbl; local; local = local->prev) {
17246  size += sizeof(*local);
17247  if (local->vars) size += local->vars->capa * sizeof(ID);
17248  }
17249 #ifndef RIPPER
17250  if (p->parser_ruby_sourcefile) {
17251  size += strlen(p->parser_ruby_sourcefile) + 1;
17252  }
17253 #endif
17254  return size;
17255 }
17256 
17257 static
17258 #ifndef RIPPER
17259 const
17260 #endif
17261 rb_data_type_t parser_data_type = {
17262  "parser",
17263  {
17264  parser_mark,
17265  parser_free,
17267  },
17268 };
17269 
17270 #ifndef RIPPER
17271 #undef rb_reserved_word
17272 
17273 const struct kwtable *
17274 rb_reserved_word(const char *str, unsigned int len)
17275 {
17276  return reserved_word(str, len);
17277 }
17278 
17279 static struct parser_params *
17281 {
17282  struct parser_params *p;
17283 
17284  p = ALLOC_N(struct parser_params, 1);
17285  MEMZERO(p, struct parser_params, 1);
17286  parser_initialize(p);
17287  return p;
17288 }
17289 
17290 VALUE
17292 {
17293  struct parser_params *p = parser_new();
17294 
17295  return TypedData_Wrap_Struct(0, &parser_data_type, p);
17296 }
17297 
17298 /*
17299  * call-seq:
17300  * ripper#end_seen? -> Boolean
17301  *
17302  * Return true if parsed source ended by +\_\_END\_\_+.
17303  */
17304 VALUE
17306 {
17307  struct parser_params *parser;
17308 
17309  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17310  return ruby__end__seen ? Qtrue : Qfalse;
17311 }
17312 
17313 /*
17314  * call-seq:
17315  * ripper#encoding -> encoding
17316  *
17317  * Return encoding of the source.
17318  */
17319 VALUE
17321 {
17322  struct parser_params *parser;
17323 
17324  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17326 }
17327 
17328 /*
17329  * call-seq:
17330  * ripper.yydebug -> true or false
17331  *
17332  * Get yydebug.
17333  */
17334 VALUE
17336 {
17337  struct parser_params *parser;
17338 
17339  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17340  return yydebug ? Qtrue : Qfalse;
17341 }
17342 
17343 /*
17344  * call-seq:
17345  * ripper.yydebug = flag
17346  *
17347  * Set yydebug.
17348  */
17349 VALUE
17351 {
17352  struct parser_params *parser;
17353 
17354  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17355  yydebug = RTEST(flag);
17356  return flag;
17357 }
17358 
17359 #ifdef YYMALLOC
17360 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17361 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17362 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17363  (n)->u3.cnt = (c), (p))
17364 
17365 void *
17366 rb_parser_malloc(struct parser_params *parser, size_t size)
17367 {
17368  size_t cnt = HEAPCNT(1, size);
17369  NODE *n = NEWHEAP();
17370  void *ptr = xmalloc(size);
17371 
17372  return ADD2HEAP(n, cnt, ptr);
17373 }
17374 
17375 void *
17376 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17377 {
17378  size_t cnt = HEAPCNT(nelem, size);
17379  NODE *n = NEWHEAP();
17380  void *ptr = xcalloc(nelem, size);
17381 
17382  return ADD2HEAP(n, cnt, ptr);
17383 }
17384 
17385 void *
17386 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17387 {
17388  NODE *n;
17389  size_t cnt = HEAPCNT(1, size);
17390 
17391  if (ptr && (n = parser->heap) != NULL) {
17392  do {
17393  if (n->u1.node == ptr) {
17394  n->u1.node = ptr = xrealloc(ptr, size);
17395  if (n->u3.cnt) n->u3.cnt = cnt;
17396  return ptr;
17397  }
17398  } while ((n = n->u2.node) != NULL);
17399  }
17400  n = NEWHEAP();
17401  ptr = xrealloc(ptr, size);
17402  return ADD2HEAP(n, cnt, ptr);
17403 }
17404 
17405 void
17406 rb_parser_free(struct parser_params *parser, void *ptr)
17407 {
17408  NODE **prev = &parser->heap, *n;
17409 
17410  while ((n = *prev) != NULL) {
17411  if (n->u1.node == ptr) {
17412  *prev = n->u2.node;
17414  break;
17415  }
17416  prev = &n->u2.node;
17417  }
17418  xfree(ptr);
17419 }
17420 #endif
17421 #endif
17422 
17423 #ifdef RIPPER
17424 #ifdef RIPPER_DEBUG
17425 extern int rb_is_pointer_to_heap(VALUE);
17426 
17427 /* :nodoc: */
17428 static VALUE
17429 ripper_validate_object(VALUE self, VALUE x)
17430 {
17431  if (x == Qfalse) return x;
17432  if (x == Qtrue) return x;
17433  if (x == Qnil) return x;
17434  if (x == Qundef)
17435  rb_raise(rb_eArgError, "Qundef given");
17436  if (FIXNUM_P(x)) return x;
17437  if (SYMBOL_P(x)) return x;
17438  if (!rb_is_pointer_to_heap(x))
17439  rb_raise(rb_eArgError, "invalid pointer: %p", x);
17440  switch (TYPE(x)) {
17441  case T_STRING:
17442  case T_OBJECT:
17443  case T_ARRAY:
17444  case T_BIGNUM:
17445  case T_FLOAT:
17446  return x;
17447  case T_NODE:
17448  if (nd_type(x) != NODE_LASGN) {
17449  rb_raise(rb_eArgError, "NODE given: %p", x);
17450  }
17451  return ((NODE *)x)->nd_rval;
17452  default:
17453  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17454  x, rb_obj_classname(x));
17455  }
17456  return x;
17457 }
17458 #endif
17459 
17460 #define validate(x) ((x) = get_value(x))
17461 
17462 static VALUE
17463 ripper_dispatch0(struct parser_params *parser, ID mid)
17464 {
17465  return rb_funcall(parser->value, mid, 0);
17466 }
17467 
17468 static VALUE
17469 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17470 {
17471  validate(a);
17472  return rb_funcall(parser->value, mid, 1, a);
17473 }
17474 
17475 static VALUE
17476 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17477 {
17478  validate(a);
17479  validate(b);
17480  return rb_funcall(parser->value, mid, 2, a, b);
17481 }
17482 
17483 static VALUE
17484 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17485 {
17486  validate(a);
17487  validate(b);
17488  validate(c);
17489  return rb_funcall(parser->value, mid, 3, a, b, c);
17490 }
17491 
17492 static VALUE
17493 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17494 {
17495  validate(a);
17496  validate(b);
17497  validate(c);
17498  validate(d);
17499  return rb_funcall(parser->value, mid, 4, a, b, c, d);
17500 }
17501 
17502 static VALUE
17503 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17504 {
17505  validate(a);
17506  validate(b);
17507  validate(c);
17508  validate(d);
17509  validate(e);
17510  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17511 }
17512 
17513 static VALUE
17514 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17515 {
17516  validate(a);
17517  validate(b);
17518  validate(c);
17519  validate(d);
17520  validate(e);
17521  validate(f);
17522  validate(g);
17523  return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17524 }
17525 
17526 static const struct kw_assoc {
17527  ID id;
17528  const char *name;
17529 } keyword_to_name[] = {
17530  {keyword_class, "class"},
17531  {keyword_module, "module"},
17532  {keyword_def, "def"},
17533  {keyword_undef, "undef"},
17534  {keyword_begin, "begin"},
17535  {keyword_rescue, "rescue"},
17536  {keyword_ensure, "ensure"},
17537  {keyword_end, "end"},
17538  {keyword_if, "if"},
17539  {keyword_unless, "unless"},
17540  {keyword_then, "then"},
17541  {keyword_elsif, "elsif"},
17542  {keyword_else, "else"},
17543  {keyword_case, "case"},
17544  {keyword_when, "when"},
17545  {keyword_while, "while"},
17546  {keyword_until, "until"},
17547  {keyword_for, "for"},
17548  {keyword_break, "break"},
17549  {keyword_next, "next"},
17550  {keyword_redo, "redo"},
17551  {keyword_retry, "retry"},
17552  {keyword_in, "in"},
17553  {keyword_do, "do"},
17554  {keyword_do_cond, "do"},
17555  {keyword_do_block, "do"},
17556  {keyword_return, "return"},
17557  {keyword_yield, "yield"},
17558  {keyword_super, "super"},
17559  {keyword_self, "self"},
17560  {keyword_nil, "nil"},
17561  {keyword_true, "true"},
17562  {keyword_false, "false"},
17563  {keyword_and, "and"},
17564  {keyword_or, "or"},
17565  {keyword_not, "not"},
17566  {modifier_if, "if"},
17567  {modifier_unless, "unless"},
17568  {modifier_while, "while"},
17569  {modifier_until, "until"},
17570  {modifier_rescue, "rescue"},
17571  {keyword_alias, "alias"},
17572  {keyword_defined, "defined?"},
17573  {keyword_BEGIN, "BEGIN"},
17574  {keyword_END, "END"},
17575  {keyword__LINE__, "__LINE__"},
17576  {keyword__FILE__, "__FILE__"},
17577  {keyword__ENCODING__, "__ENCODING__"},
17578  {0, NULL}
17579 };
17580 
17581 static const char*
17582 keyword_id_to_str(ID id)
17583 {
17584  const struct kw_assoc *a;
17585 
17586  for (a = keyword_to_name; a->id; a++) {
17587  if (a->id == id)
17588  return a->name;
17589  }
17590  return NULL;
17591 }
17592 
17593 #undef ripper_id2sym
17594 static VALUE
17595 ripper_id2sym(ID id)
17596 {
17597  const char *name;
17598  char buf[8];
17599 
17600  if (id <= 256) {
17601  buf[0] = (char)id;
17602  buf[1] = '\0';
17603  return ID2SYM(rb_intern2(buf, 1));
17604  }
17605  if ((name = keyword_id_to_str(id))) {
17606  return ID2SYM(rb_intern(name));
17607  }
17608  switch (id) {
17609  case tOROP:
17610  name = "||";
17611  break;
17612  case tANDOP:
17613  name = "&&";
17614  break;
17615  default:
17616  name = rb_id2name(id);
17617  if (!name) {
17618  rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17619  }
17620  return ID2SYM(id);
17621  }
17622  return ID2SYM(rb_intern(name));
17623 }
17624 
17625 static ID
17626 ripper_get_id(VALUE v)
17627 {
17628  NODE *nd;
17629  if (!RB_TYPE_P(v, T_NODE)) return 0;
17630  nd = (NODE *)v;
17631  if (nd_type(nd) != NODE_LASGN) return 0;
17632  return nd->nd_vid;
17633 }
17634 
17635 static VALUE
17636 ripper_get_value(VALUE v)
17637 {
17638  NODE *nd;
17639  if (v == Qundef) return Qnil;
17640  if (!RB_TYPE_P(v, T_NODE)) return v;
17641  nd = (NODE *)v;
17642  if (nd_type(nd) != NODE_LASGN) return Qnil;
17643  return nd->nd_rval;
17644 }
17645 
17646 static void
17647 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17648 {
17649  VALUE str;
17650  va_list args;
17651 
17652  va_start(args, fmt);
17653  str = rb_vsprintf(fmt, args);
17654  va_end(args);
17655  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17656 }
17657 
17658 static void
17659 ripper_warn0(struct parser_params *parser, const char *fmt)
17660 {
17661  rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
17662 }
17663 
17664 static void
17665 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
17666 {
17667  rb_funcall(parser->value, rb_intern("warn"), 2,
17668  STR_NEW2(fmt), INT2NUM(a));
17669 }
17670 
17671 static void
17672 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
17673 {
17674  rb_funcall(parser->value, rb_intern("warn"), 2,
17675  STR_NEW2(fmt), STR_NEW2(str));
17676 }
17677 
17678 static void
17679 ripper_warning0(struct parser_params *parser, const char *fmt)
17680 {
17681  rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
17682 }
17683 
17684 static void
17685 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
17686 {
17687  rb_funcall(parser->value, rb_intern("warning"), 2,
17688  STR_NEW2(fmt), STR_NEW2(str));
17689 }
17690 
17691 static VALUE
17692 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
17693 {
17694  return rb_io_gets(src);
17695 }
17696 
17697 static VALUE
17698 ripper_s_allocate(VALUE klass)
17699 {
17700  struct parser_params *p;
17701  VALUE self;
17702 
17703  p = ALLOC_N(struct parser_params, 1);
17704  MEMZERO(p, struct parser_params, 1);
17705  self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
17706  p->value = self;
17707  return self;
17708 }
17709 
17710 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
17711 
17712 /*
17713  * call-seq:
17714  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
17715  *
17716  * Create a new Ripper object.
17717  * _src_ must be a String, an IO, or an Object which has #gets method.
17718  *
17719  * This method does not starts parsing.
17720  * See also Ripper#parse and Ripper.parse.
17721  */
17722 static VALUE
17723 ripper_initialize(int argc, VALUE *argv, VALUE self)
17724 {
17725  struct parser_params *parser;
17726  VALUE src, fname, lineno;
17727 
17728  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17729  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
17730  if (RB_TYPE_P(src, T_FILE)) {
17731  parser->parser_lex_gets = ripper_lex_get_generic;
17732  }
17733  else {
17734  StringValue(src);
17735  parser->parser_lex_gets = lex_get_str;
17736  }
17737  parser->parser_lex_input = src;
17738  parser->eofp = Qfalse;
17739  if (NIL_P(fname)) {
17740  fname = STR_NEW2("(ripper)");
17741  }
17742  else {
17743  StringValue(fname);
17744  }
17745  parser_initialize(parser);
17746 
17747  parser->parser_ruby_sourcefile_string = fname;
17748  parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
17749  parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
17750 
17751  return Qnil;
17752 }
17753 
17754 struct ripper_args {
17755  struct parser_params *parser;
17756  int argc;
17757  VALUE *argv;
17758 };
17759 
17760 static VALUE
17761 ripper_parse0(VALUE parser_v)
17762 {
17763  struct parser_params *parser;
17764 
17765  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17766  parser_prepare(parser);
17767  ripper_yyparse((void*)parser);
17768  return parser->result;
17769 }
17770 
17771 static VALUE
17772 ripper_ensure(VALUE parser_v)
17773 {
17774  struct parser_params *parser;
17775 
17776  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17777  parser->parsing_thread = Qnil;
17778  return Qnil;
17779 }
17780 
17781 /*
17782  * call-seq:
17783  * ripper#parse
17784  *
17785  * Start parsing and returns the value of the root action.
17786  */
17787 static VALUE
17788 ripper_parse(VALUE self)
17789 {
17790  struct parser_params *parser;
17791 
17792  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17793  if (!ripper_initialized_p(parser)) {
17794  rb_raise(rb_eArgError, "method called for uninitialized object");
17795  }
17796  if (!NIL_P(parser->parsing_thread)) {
17797  if (parser->parsing_thread == rb_thread_current())
17798  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
17799  else
17800  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
17801  }
17802  parser->parsing_thread = rb_thread_current();
17803  rb_ensure(ripper_parse0, self, ripper_ensure, self);
17804 
17805  return parser->result;
17806 }
17807 
17808 /*
17809  * call-seq:
17810  * ripper#column -> Integer
17811  *
17812  * Return column number of current parsing line.
17813  * This number starts from 0.
17814  */
17815 static VALUE
17816 ripper_column(VALUE self)
17817 {
17818  struct parser_params *parser;
17819  long col;
17820 
17821  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17822  if (!ripper_initialized_p(parser)) {
17823  rb_raise(rb_eArgError, "method called for uninitialized object");
17824  }
17825  if (NIL_P(parser->parsing_thread)) return Qnil;
17826  col = parser->tokp - parser->parser_lex_pbeg;
17827  return LONG2NUM(col);
17828 }
17829 
17830 /*
17831  * call-seq:
17832  * ripper#filename -> String
17833  *
17834  * Return current parsing filename.
17835  */
17836 static VALUE
17837 ripper_filename(VALUE self)
17838 {
17839  struct parser_params *parser;
17840 
17841  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17842  if (!ripper_initialized_p(parser)) {
17843  rb_raise(rb_eArgError, "method called for uninitialized object");
17844  }
17845  return parser->parser_ruby_sourcefile_string;
17846 }
17847 
17848 /*
17849  * call-seq:
17850  * ripper#lineno -> Integer
17851  *
17852  * Return line number of current parsing line.
17853  * This number starts from 1.
17854  */
17855 static VALUE
17856 ripper_lineno(VALUE self)
17857 {
17858  struct parser_params *parser;
17859 
17860  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17861  if (!ripper_initialized_p(parser)) {
17862  rb_raise(rb_eArgError, "method called for uninitialized object");
17863  }
17864  if (NIL_P(parser->parsing_thread)) return Qnil;
17865  return INT2NUM(parser->parser_ruby_sourceline);
17866 }
17867 
17868 #ifdef RIPPER_DEBUG
17869 /* :nodoc: */
17870 static VALUE
17871 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
17872 {
17873  StringValue(msg);
17874  if (obj == Qundef) {
17875  rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
17876  }
17877  return Qnil;
17878 }
17879 
17880 /* :nodoc: */
17881 static VALUE
17882 ripper_value(VALUE self, VALUE obj)
17883 {
17884  return ULONG2NUM(obj);
17885 }
17886 #endif
17887 
17888 
17889 void
17890 Init_ripper(void)
17891 {
17892  parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
17893 
17896  /* ensure existing in symbol table */
17897  (void)rb_intern("||");
17898  (void)rb_intern("&&");
17899 
17900  InitVM(ripper);
17901 }
17902 
17903 void
17904 InitVM_ripper(void)
17905 {
17906  VALUE Ripper;
17907 
17908  Ripper = rb_define_class("Ripper", rb_cObject);
17909  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
17910  rb_define_alloc_func(Ripper, ripper_s_allocate);
17911  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
17912  rb_define_method(Ripper, "parse", ripper_parse, 0);
17913  rb_define_method(Ripper, "column", ripper_column, 0);
17914  rb_define_method(Ripper, "filename", ripper_filename, 0);
17915  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
17916  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
17917  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
17918  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
17919  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
17920 #ifdef RIPPER_DEBUG
17921  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
17922  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
17923  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
17924 #endif
17925 
17928 
17929 # if 0
17930  /* Hack to let RDoc document SCRIPT_LINES__ */
17931 
17932  /*
17933  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
17934  * after the assignment will be added as an Array of lines with the file
17935  * name as the key.
17936  */
17937  rb_define_global_const("SCRIPT_LINES__", Qnil);
17938 #endif
17939 
17940 }
17941 #endif /* RIPPER */
17942 
#define STRNCASECMP(s1, s2, n)
Definition: ruby.h:1646
#define toklast()
Definition: parse.c:12110
RUBY_EXTERN VALUE rb_cString
Definition: ruby.h:1456
#define tokadd_mbchar(c)
Definition: parse.c:12470
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:2216
#define command_start
Definition: parse.c:391
char * parser_ruby_sourcefile
Definition: ripper.c:326
VALUE val
Definition: parse.h:164
#define YYFPRINTF
Definition: parse.c:4471
#define YYLAST
Definition: parse.c:1136
#define evstr2dstr(n)
Definition: parse.c:458
#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:14902
#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:322
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: parse.c:4715
VALUE rb_ary_unshift(VALUE ary, VALUE item)
Definition: array.c:1084
static ID ripper_token2eventid(int tok)
Definition: eventids2.c:273
static ID internal_id_gen(struct parser_params *)
Definition: parse.c:16509
Definition: lex.c:33
#define tokenbuf
Definition: parse.c:380
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:4617
#define shadowing_lvar(name)
Definition: parse.c:547
#define MBCLEN_CHARFOUND_P(ret)
Definition: encoding.h:138
static void arg_ambiguous_gen(struct parser_params *parser)
Definition: parse.c:12977
#define nextc()
Definition: parse.c:11502
static long parser_encode_length(struct parser_params *parser, const char *name, long len)
Definition: parse.c:13006
#define RE_OPTION_ENCODING_IDX(o)
Definition: parse.c:583
Definition: parse.c:860
#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:17366
#define NEW_SCLASS(r, b)
Definition: node.h:442
#define lex_strterm
Definition: parse.c:367
static void Init_id(void)
Definition: id.c:14
#define RARRAY_LEN(a)
Definition: ruby.h:899
Definition: parse.c:868
void rb_bug(const char *fmt,...)
Definition: error.c:290
int num
Definition: parse.h:167
#define mixed_escape(beg, enc1, enc2)
static const yytype_uint8 yyr2[]
Definition: parse.c:1687
struct token_info * next
Definition: ripper.c:274
int rb_is_local_name(VALUE name)
Definition: parse.c:17114
static NODE * attrset_gen(struct parser_params *, NODE *, ID)
Definition: parse.c:15183
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:390
#define NEW_LIST(a)
Definition: node.h:385
int rb_is_class_name(VALUE name)
Definition: parse.c:17090
#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:11503
#define rb_gc_mark_locations(start, end)
Definition: gc.c:2346
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:2530
int rb_is_attrset_name(VALUE name)
Definition: parse.c:17108
int i
Definition: win32ole.c:784
VALUE parser_lex_nextline
Definition: ripper.c:313
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:719
#define T_FIXNUM
Definition: ruby.h:497
Definition: st.h:77
static NODE * negate_lit(NODE *)
Definition: parse.c:15765
#define toklen()
Definition: parse.c:12109
#define new_yield(node)
Definition: parse.c:476
#define dispatch_heredoc_end()
Definition: parse.c:12870
static NODE * node_assign_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15255
Definition: node.h:47
#define NEW_XSTR(s)
Definition: node.h:419
int parser_ruby__end__seen
Definition: ripper.c:323
static void local_push_gen(struct parser_params *, int)
Definition: parse.c:15978
static int vtable_size(const struct vtable *tbl)
Definition: parse.c:201
#define formal_argument(id)
Definition: parse.c:545
int parser_command_start
Definition: ripper.c:318
const struct kwtable * rb_reserved_word(const char *str, unsigned int len)
Definition: parse.c:17274
VALUE rb_range_new(VALUE, VALUE, int)
Definition: range.c:67
#define YY_STACK_PRINT(Bottom, Top)
Definition: parse.c:4578
static NODE * arg_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15204
#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:17009
#define NEW_DOT2(b, e)
Definition: node.h:447
#define tokfix()
Definition: parse.c:12107
static NODE * evstr2dstr_gen(struct parser_params *, NODE *)
Definition: parse.c:14879
#define local_pop()
Definition: parse.c:554
static void yy_reduce_print(YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
Definition: parse.c:4595
static int nodeline(NODE *node)
Definition: parse.c:14644
static int token_info_has_nonspaces(struct parser_params *parser, const char *token)
Definition: parse.c:11634
#define malloc
Definition: parse.c:98
#define local_var(id)
Definition: parse.c:556
static NODE * arg_blk_pass(NODE *, NODE *)
Definition: parse.c:15793
#define IS_LABEL_POSSIBLE()
Definition: parse.c:13316
#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:16171
#define POINTER_P(val)
Definition: parse.c:198
int parser_compile_for_eval
Definition: ripper.c:304
int parser_token_info_enabled
Definition: ripper.c:340
#define parser_precise_mbclen()
Definition: parse.c:11612
static ID formal_argument_gen(struct parser_params *, ID)
Definition: parse.c:12988
static int parser_read_escape(struct parser_params *parser, int flags, rb_encoding **encp)
Definition: parse.c:12243
#define internal_id()
Definition: parse.c:562
int parser_brace_nest
Definition: ripper.c:303
static VALUE reg_compile_gen(struct parser_params *, VALUE, int)
Definition: parse.c:16305
#define InitVM(ext)
Definition: ruby.h:1651
static ID register_symid(ID, const char *, long, rb_encoding *)
Definition: parse.c:16667
unsigned short int yytype_uint16
Definition: parse.c:941
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:1963
#define lex_nextline
Definition: parse.c:386
ID rb_intern_str(VALUE str)
Definition: parse.c:16844
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:2304
#define RE_OPTION_ENCODING(e)
Definition: parse.c:582
NODE * rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
Definition: parse.c:16366
static ID * vtable_tblcpy(ID *buf, const struct vtable *src)
Definition: parse.c:16008
Definition: id.h:78
#define yyparse
Definition: parse.c:416
#define DVARS_TOPSCOPE
Definition: parse.c:196
#define set_yylval_str(x)
Definition: parse.c:11520
static const yytype_uint16 yyr1[]
Definition: parse.c:1620
#define gettable(id)
Definition: parse.c:481
#define set_yylval_literal(x)
Definition: parse.c:11524
#define TypedData_Wrap_Struct(klass, data_type, sval)
Definition: ruby.h:1016
#define yytable_value_is_error(yytable_value)
Definition: parse.c:3149
#define YYPOPSTACK(N)
Definition: parse.c:852
#define ADD2HEAP(n, c, p)
Definition: parse.c:17362
VALUE rb_parser_encoding(VALUE vparser)
Definition: parse.c:17320
#define TypedData_Get_Struct(obj, type, data_type, sval)
Definition: ruby.h:1030
#define literal_concat(h, t)
Definition: parse.c:453
const int id
Definition: nkf.c:209
static void block_dup_check_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15167
int line_count
Definition: ripper.c:324
stack_type parser_cmdarg_stack
Definition: ripper.c:297
node_type
Definition: node.h:22
VALUE rb_external_str_new_with_enc(const char *ptr, long len, rb_encoding *)
Definition: string.c:569
#define strcasecmp
Definition: win32.h:200
#define STR_NEW2(p)
Definition: parse.c:359
Definition: parse.c:837
static int lvar_defined_gen(struct parser_params *, ID)
Definition: parse.c:12999
Definition: parse.c:865
#define ID_CONST
Definition: id.h:22
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:344
#define tokspace(n)
Definition: parse.c:11505
VALUE rb_enc_from_encoding(rb_encoding *encoding)
Definition: encoding.c:103
int rb_is_method_name(VALUE name)
Definition: parse.c:17120
static ID * local_tbl_gen(struct parser_params *)
Definition: parse.c:16023
VALUE rb_eTypeError
Definition: error.c:511
#define rb_warnI(fmt, a)
Definition: parse.c:693
NODE * node
Definition: parse.h:165
#define PARSER_ARG
Definition: parse.c:720
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:578
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:16703
#define NEW_CLASS(n, b, s)
Definition: node.h:441
#define current_enc
Definition: parse.c:399
#define lex_pbeg
Definition: parse.c:387
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:108
#define MAX_WORD_LENGTH
Definition: lex.c:43
VALUE rb_eEncodingError
Definition: error.c:517
NODE * rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
Definition: parse.c:11981
union RNode::@93 u1
#define SYM2ID(x)
Definition: ruby.h:364
#define subnodes(n1, n2)
#define yydebug
Definition: parse.c:400
struct RBasic basic
Definition: ruby.h:843
#define YYSTACK_BYTES(N)
Definition: parse.c:1089
#define nd_term(node)
Definition: parse.c:595
static int parser_yylex(struct parser_params *parser)
Definition: parse.c:13333
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:789
#define new_args_tail(k, kr, b)
Definition: parse.c:469
Definition: parse.c:858
#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:14888
VALUE op_sym[tLAST_OP_ID]
Definition: ripper.c:16535
int rb_is_junk_name(VALUE name)
Definition: parse.c:17130
VALUE debug_lines
Definition: ripper.c:336
static int parser_regx_options(struct parser_params *)
Definition: parse.c:12414
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
Definition: vm_eval.c:774
struct RString::@73::@74 heap
ID id
Definition: parse.h:166
static void set_file_encoding(struct parser_params *parser, const char *str, const char *send)
Definition: parse.c:13245
static NODE * newline_node(NODE *)
Definition: parse.c:14650
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:1780
Definition: parse.c:838
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: parse.c:4480
#define RE_OPTION_ONCE
Definition: parse.c:580
#define NEW_NIL()
Definition: node.h:450
static const yytype_uint16 yyprhs[]
Definition: parse.c:1198
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Definition: ruby.h:875
#define block_dup_check(n1, n2)
Definition: parse.c:440
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:15958
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:172
#define attrset(node, id)
Definition: parse.c:488
int pre_args_num
Definition: node.h:508
#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:499
int parser_toksiz
Definition: ripper.c:309
static NODE * assignable_gen(struct parser_params *, ID, NODE *)
Definition: parse.c:15029
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:2244
#define nd_args
Definition: node.h:331
Definition: parse.c:880
#define nd_set_type(n, t)
Definition: node.h:277
ID last_id
Definition: ripper.c:16528
static size_t parser_memsize(const void *ptr)
Definition: parse.c:17237
static NODE * new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: parse.c:15878
static void fixpos(NODE *, NODE *)
Definition: parse.c:14660
void rb_gc_mark(VALUE ptr)
Definition: gc.c:2598
#define lex_pend
Definition: parse.c:389
static NODE * gettable_gen(struct parser_params *, ID)
Definition: parse.c:14951
#define T_ARRAY
Definition: ruby.h:492
#define NEW_DOT3(b, e)
Definition: node.h:448
#define nd_paren(node)
Definition: parse.c:597
#define cmdarg_stack
Definition: parse.c:370
#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:15653
#define NEW_ITER(a, b)
Definition: node.h:373
#define STR_NEW0()
Definition: parse.c:358
void rb_gc_mark_parser(void)
Definition: parse.c:16329
#define numberof(array)
Definition: parse.c:92
#define reg_compile(str, options)
Definition: parse.c:510
NODE * pre_init
Definition: node.h:505
#define ISDIGIT(c)
static int local_var_gen(struct parser_params *, ID)
Definition: parse.c:16045
#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:14917
ID block_arg
Definition: node.h:514
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
Definition: parse.c:4564
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:1168
VALUE parser_lex_input
Definition: ripper.c:311
static int dvar_defined_gen(struct parser_params *, ID, int)
Definition: parse.c:16132
#define nd_type(n)
Definition: node.h:276
static NODE * new_yield_gen(struct parser_params *, NODE *)
Definition: parse.c:15757
#define RE_OPTION_ENCODING_NONE(o)
Definition: parse.c:584
#define YYNTOKENS
Definition: parse.c:1139
static char * parser_tokspace(struct parser_params *parser, int n)
Definition: parse.c:12129
Definition: parse.c:857
VALUE klass
Definition: ruby.h:701
int rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
Definition: parse.c:16651
#define tokadd_string(f, t, p, n, e)
Definition: parse.c:11511
#define paren_nest
Definition: parse.c:372
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2105
#define is_identchar(p, e, enc)
Definition: parse.c:11613
#define RUBY_DTRACE_PARSE_BEGIN(arg0, arg1)
Definition: probes.h:68
int pos
Definition: ripper.c:183
Definition: parse.c:823
Definition: parse.c:881
static void parser_heredoc_restore(struct parser_params *parser, NODE *here)
Definition: parse.c:12827
static NODE * remove_begin(NODE *)
Definition: parse.c:15451
static int is_global_name_punct(const char c)
Definition: parse.c:12663
NODE * rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: parse.c:11946
#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:2961
#define lex_lastline
Definition: parse.c:385
#define NEW_SCOPE(a, b)
Definition: node.h:363
#define head
Definition: st.c:107
#define tok_hex(numlen)
Definition: parse.c:11507
unsigned char OnigUChar
Definition: oniguruma.h:113
int parser_yydebug
Definition: ripper.c:330
Definition: node.h:27
st_table * id_str
Definition: ripper.c:16530
static const yytype_int16 yytable[]
Definition: parse.c:2033
NODE * parser_eval_tree
Definition: ripper.c:335
NODE * parser_deferred_nodes
Definition: ripper.c:319
#define sym(x)
Definition: date_core.c:3715
VALUE rb_str_buf_cat(VALUE, const char *, long)
Definition: string.c:1947
static int dyna_in_block_gen(struct parser_params *)
Definition: parse.c:16126
static const rb_data_type_t parser_data_type
Definition: parse.c:11917
Definition: node.h:239
#define YYSYNTAX_ERROR
#define YYABORT
Definition: parse.c:4383
Definition: parse.h:159
int has_shebang
Definition: ripper.c:325
Win32OLEIDispatch * p
Definition: win32ole.c:786
#define logop(type, node1, node2)
Definition: parse.c:424
static rb_encoding * must_be_ascii_compatible(VALUE s)
Definition: parse.c:11867
#define ISALPHA(c)
Definition: ruby.h:1636
static void dyna_pop_1(struct parser_params *parser)
Definition: parse.c:16094
void rb_exc_raise(VALUE mesg)
Definition: eval.c:527
#define in_single
Definition: parse.c:375
#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:15923
#define strtod(s, e)
Definition: util.h:76
#define parser_warn(node, mesg)
Definition: parse.c:14680
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:15573
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:382
Definition: ruby.h:842
int rb_is_instance_name(VALUE name)
Definition: parse.c:17102
#define ID_SCOPE_MASK
Definition: id.h:17
static VALUE coverage(const char *f, int n)
Definition: parse.c:11775
rb_encoding * enc
Definition: ripper.c:328
static void parser_free(void *ptr)
Definition: parse.c:17217
#define free
Definition: parse.c:101
enum lex_state_e parser_lex_state
Definition: ripper.c:295
int rb_is_local_id(ID id)
Definition: parse.c:16986
#define lex_gets
Definition: parse.c:394
#define NEW_POSTEXE(b)
Definition: node.h:456
int capa
Definition: ripper.c:184
VALUE parser_lex_lastline
Definition: ripper.c:312
void * rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
Definition: parse.c:17386
#define void_expr(node)
Definition: parse.c:434
static void parser_initialize(struct parser_params *parser)
Definition: parse.c:17138
#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:13026
#define NEW_IF(c, t, e)
Definition: node.h:365
#define local_id(id)
Definition: parse.c:560
#define here_document(n)
Definition: parse.c:11514
#define lex_goto_eol(parser)
Definition: parse.c:12034
#define RARRAY(obj)
Definition: ruby.h:1101
#define ruby_sourcefile
Definition: parse.c:398
#define ALLOC_N(type, n)
Definition: ruby.h:1223
void rb_compile_error_append(const char *fmt,...)
Definition: error.c:150
VALUE rb_parser_get_yydebug(VALUE self)
Definition: parse.c:17335
#define YYTRANSLATE(YYX)
Definition: parse.c:1151
#define NEW_PRELUDE(p, b)
Definition: node.h:459
#define val
int rb_ispunct(int c)
Definition: encoding.c:1892
Definition: parse.c:831
#define NEW_ARRAY(a)
Definition: node.h:386
#define tokidx
Definition: parse.c:381
RUBY_EXTERN VALUE rb_cObject
Definition: ruby.h:1426
VALUE rb_eRuntimeError
Definition: error.c:510
#define match_op(node1, node2)
Definition: parse.c:502
static enum node_type nodetype(NODE *node)
Definition: parse.c:14638
#define NEW_STRTERM(func, term, paren)
Definition: parse.c:12619
#define ID_INSTANCE
Definition: id.h:19
static const struct magic_comment magic_comments[]
Definition: parse.c:13110
#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:516
#define arg_concat(h, t)
Definition: parse.c:451
void rb_str_free(VALUE)
Definition: string.c:830
struct parser_params * parser
Definition: ripper.c:16315
static void magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
Definition: parse.c:13074
#define RE_OPTION_MASK
Definition: parse.c:585
void * rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
Definition: parse.c:17376
char * ruby_strdup(const char *)
Definition: util.c:454
#define NEW_HASH(a)
Definition: node.h:388
#define DEF_EXPR(n)
Definition: parse.c:141
VALUE rb_get_coverages(void)
Definition: thread.c:5162
static int e_option_supplied(struct parser_params *parser)
Definition: parse.c:11792
#define NEW_ZARRAY()
Definition: node.h:387
static struct vtable * vtable_alloc(struct vtable *prev)
Definition: parse.c:214
#define NEW_FALSE()
Definition: node.h:452
#define token_info_push(token)
Definition: parse.c:735
VALUE rb_obj_as_string(VALUE)
Definition: string.c:895
int parser_paren_nest
Definition: ripper.c:299
VALUE rb_ary_new(void)
Definition: array.c:424
#define YY_(msgid)
Definition: parse.c:974
#define NODE_HEREDOC
Definition: parse.c:589
int rb_ascii8bit_encindex(void)
Definition: encoding.c:1162
#define NEW_ARGSPUSH(a, b)
Definition: node.h:433
#define VTBL_DEBUG
Definition: parse.c:211
#define cond_stack
Definition: parse.c:369
static int is_special_global_name(const char *m, const char *e, rb_encoding *enc)
Definition: parse.c:16518
static const yytype_uint16 yyrline[]
Definition: parse.c:1460
#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:2350
#define IS_SPCARG(c)
Definition: parse.c:13315
#define set_yylval_id(x)
Definition: parse.c:11522
#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:624
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:499
static char msg[50]
Definition: strerror.c:8
#define NEW_GVAR(v)
Definition: node.h:405
NODE * opt_args
Definition: node.h:519
int rb_is_attrset_id(ID id)
Definition: parse.c:16980
static int reg_fragment_check_gen(struct parser_params *, VALUE, int)
Definition: parse.c:16210
#define NEW_YIELD(a)
Definition: node.h:384
#define YYSTACK_ALLOC
Definition: parse.c:1042
static NODE * dsym_node_gen(struct parser_params *, NODE *)
Definition: parse.c:15851
#define STR_FUNC_REGEXP
Definition: parse.c:12001
NODE * rb_compile_string(const char *f, VALUE s, int line)
Definition: parse.c:11939
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:2202
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:15907
#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:15732
Definition: parse.c:829
static double one(void)
Definition: isinf.c:52
Definition: parse.c:827
static NODE * splat_array(NODE *)
Definition: parse.c:15247
Definition: parse.c:862
#define FLONUM_P(x)
Definition: ruby.h:375
static void parser_mark(void *ptr)
Definition: parse.c:17191
#define T_FLOAT
Definition: ruby.h:489
static void parser_tokadd(struct parser_params *parser, int c)
Definition: parse.c:12141
#define is_local_id(id)
Definition: parse.c:111
static YYSIZE_T yystrlen(char *yystr) const
Definition: parse.c:4666
#define LVAR_USED
Definition: parse.c:15118
#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:16683
yytype_int16 yyss_alloc
Definition: ripper.c:1080
static ID intern_str(VALUE str)
Definition: parse.c:16725
Definition: parse.c:850
#define STR_FUNC_INDENT
Definition: parse.c:12004
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:449
static VALUE lex_get_str(struct parser_params *parser, VALUE s)
Definition: parse.c:11877
#define ALLOCA_N(type, n)
Definition: ruby.h:1227
static int assign_in_cond(struct parser_params *parser, NODE *node)
Definition: parse.c:15546
#define op_tbl_count
Definition: parse.c:16431
#define warn_balanced(op, syn)
Definition: parse.c:13327
#define tokadd(c)
Definition: parse.c:11506
#define NEW_OP_CDECL(v, op, val)
Definition: node.h:404
#define no_digits()
#define peek_n(c, n)
Definition: parse.c:12037
#define T_BIGNUM
Definition: ruby.h:495
#define ENC_CODERANGE_UNKNOWN
Definition: encoding.h:57
#define YYFINAL
Definition: parse.c:1134
#define ISUPPER(c)
Definition: ruby.h:1633
static void void_expr_gen(struct parser_params *, NODE *)
Definition: parse.c:15348
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:16233
#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:867
#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:5882
#define YYCASE_(N, S)
int err
Definition: win32.c:87
#define IS_AFTER_OPERATOR()
Definition: parse.c:13318
Definition: parse.c:843
#define OBJ_FREEZE(x)
Definition: ruby.h:1164
const char * parser_lex_pend
Definition: ripper.c:316
static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
Definition: parse.c:12334
#define nd_else
Definition: node.h:294
#define set_yylval_num(x)
Definition: parse.c:11521
long cnt
Definition: node.h:261
#define parser_encoding_name()
Definition: parse.c:11610
token_info * parser_token_info
Definition: ripper.c:341
#define new_op_assign(lhs, op, rhs)
Definition: parse.c:542
int column
Definition: ripper.c:272
#define YYSIZE_T
Definition: parse.c:960
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:374
#define EOF
Definition: vsnprintf.c:207
static NODE * list_append_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14737
#define NEW_WHEN(c, t, e)
Definition: node.h:368
static const yytype_int16 yycheck[]
Definition: parse.c:3152
VALUE rb_str_resize(VALUE, long)
Definition: string.c:1853
static int literal_node(NODE *node)
Definition: parse.c:15632
static int dvar_curr_gen(struct parser_params *, ID)
Definition: parse.c:16163
#define tHEREDOC_END
Definition: eventids2.c:8
static int rb_str_symname_type(VALUE name)
Definition: parse.c:16657
static int rb_enc_symname_type(const char *name, long len, rb_encoding *enc)
Definition: parse.c:16556
#define NEW_DASGN(v, val)
Definition: node.h:392
YYSTYPE yyvs_alloc
Definition: ripper.c:1081
#define flush_string_content(enc)
Definition: parse.c:12638
int rb_str_hash_cmp(VALUE, VALUE)
Definition: string.c:2254
#define NEW_ERRINFO()
Definition: node.h:453
#define NEW_BLOCK_PASS(b)
Definition: node.h:437
Definition: parse.c:844
string_type
Definition: ripper.c:12096
int rb_dvar_defined(ID id)
Definition: compile.c:5832
union RString::@73 as
union RNode::@94 u2
#define RSTRING_LEN(str)
Definition: ruby.h:862
int parser_in_single
Definition: ripper.c:301
lex_state_bits
Definition: ripper.c:125
#define ret_args(node)
Definition: parse.c:473
static int parser_yyerror(struct parser_params *, const char *)
Definition: parse.c:11693
#define RUBY_DTRACE_PARSE_END_ENABLED()
Definition: probes.h:71
#define COND_LEXPOP()
Definition: parse.c:173
ID rest_arg
Definition: node.h:513
#define REALLOC_N(var, type, n)
Definition: ruby.h:1225
static const yytype_int16 yypgoto[]
Definition: parse.c:2005
int errno
#define TRUE
Definition: nkf.h:175
static int parser_tokadd_mbchar(struct parser_params *parser, int c)
Definition: parse.c:12457
#define nd_next
Definition: node.h:290
void rb_gc_mark_symbols(void)
Definition: parse.c:16500
#define NEW_CONST(v)
Definition: node.h:409
int rb_symname_p(const char *name)
Definition: parse.c:16544
#define COND_POP()
Definition: parse.c:172
#define TOK_INTERN(mb)
Definition: parse.c:362
#define NEW_LIT(l)
Definition: node.h:416
VALUE rb_io_gets(VALUE)
Definition: io.c:3110
int rb_is_junk_id(ID id)
Definition: parse.c:16992
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1270
#define COND_P()
Definition: parse.c:174
#define ruby_coverage
Definition: parse.c:406
static VALUE debug_lines(const char *f)
Definition: parse.c:11758
#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:4902
#define rb_enc_isspace(c, enc)
Definition: encoding.h:181
#define NEW_NEXT(s)
Definition: node.h:376
#define rb_warnS(fmt, a)
Definition: parse.c:694
#define parser_warning(node, mesg)
Definition: parse.c:14673
#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:12641
#define value_expr(node)
Definition: parse.c:432
#define rb_warning0(fmt)
Definition: parse.c:696
#define reg_fragment_setenc(str, options)
Definition: parse.c:512
static int value_expr_gen(struct parser_params *, NODE *)
Definition: parse.c:15286
static const yytype_int16 yyrhs[]
Definition: parse.c:1265
const char * rb_id2name(ID id)
Definition: parse.c:16915
static int parser_whole_match_p(struct parser_params *parser, const char *eos, long len, int indent)
Definition: parse.c:12844
#define NEW_RESCUE(b, res, e)
Definition: node.h:380
#define YYDPRINTF(Args)
Definition: parse.c:4474
static const char * magic_comment_marker(const char *str, long len)
Definition: parse.c:13118
#define rb_warn0(fmt)
Definition: parse.c:692
rb_magic_comment_length_t length
Definition: ripper.c:13197
int parser_in_def
Definition: ripper.c:302
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1570
static const yytype_uint8 yytranslate[]
Definition: parse.c:1155
#define new_bv(id)
Definition: parse.c:549
#define YYEMPTY
Definition: parse.c:4379
#define YYSTACK_FREE
Definition: parse.c:1043
#define YYID(n)
Definition: parse.c:987
VALUE parser_cur_mid
Definition: ripper.c:305
VALUE stack_type
Definition: parse.c:164
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4308
Definition: parse.c:824
Definition: parse.c:864
static char * parser_newtok(struct parser_params *parser)
Definition: parse.c:12113
long parser_lex_gets_ptr
Definition: ripper.c:320
unsigned long ID
Definition: ruby.h:105
static void fixup_nodes(NODE **)
Definition: parse.c:15585
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1183
#define rb_enc_isalnum(c, enc)
Definition: encoding.h:179
#define dyna_pop(node)
Definition: parse.c:567
#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:447
#define dyna_in_block()
Definition: parse.c:569
#define Qnil
Definition: ruby.h:435
#define dyna_var(id)
Definition: parse.c:570
#define NEW_BACK_REF(n)
Definition: node.h:412
Definition: parse.c:855
#define STR_FUNC_ESCAPE
Definition: parse.c:11999
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:11516
#define NEW_COLON2(c, i)
Definition: node.h:444
unsigned long VALUE
Definition: ruby.h:104
#define yyerror(msg)
Definition: parse.c:365
#define peek(c)
Definition: parse.c:12036
stack_type parser_cond_stack
Definition: ripper.c:296
#define IS_lex_state_for(x, ls)
Definition: parse.c:157
static VALUE result
Definition: nkf.c:40
NODE * post_init
Definition: node.h:506
static NODE * arg_append_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15229
static void ripper_init_eventids2(void)
Definition: eventids2.c:64
#define RBASIC(obj)
Definition: ruby.h:1094
#define heredoc_identifier()
Definition: parse.c:11515
int parser_heredoc_end
Definition: ripper.c:317
#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:12018
#define ripper_flush(p)
Definition: parse.c:11543
void rb_mark_tbl(st_table *tbl)
Definition: gc.c:2541
#define dsym_node(node)
Definition: parse.c:478
#define regx_options()
Definition: parse.c:11510
int post_args_num
Definition: node.h:509
static int parser_magic_comment(struct parser_params *parser, const char *str, long len)
Definition: parse.c:13151
#define NEW_ENSURE(b, en)
Definition: node.h:382
yytokentype
Definition: parse.c:770
#define token_info_pop(token)
Definition: parse.c:736
static int arg_var_gen(struct parser_params *, ID)
Definition: parse.c:16038
#define call_bin_op(recv, id, arg1)
Definition: parse.c:462
#define rb_warn4S(file, line, fmt, a)
Definition: parse.c:695
#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:11798
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:684
#define assignable_result(x)
static int parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
Definition: parse.c:12341
static int parser_tokadd_string(struct parser_params *, int, int, int, long *, rb_encoding **)
Definition: parse.c:12486
#define nd_body
Definition: node.h:293
VALUE flags
Definition: node.h:240
const char * token
Definition: ripper.c:270
#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:573
#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:15804
#define ruby_sourceline
Definition: parse.c:397
#define is_global_id(id)
Definition: parse.c:112
#define lex_input
Definition: parse.c:384
Definition: parse.c:845
void xfree(void *)
#define STR_FUNC_QWORDS
Definition: parse.c:12002
static int vtable_included(const struct vtable *tbl, ID id)
Definition: parse.c:253
ID rb_intern(const char *name)
Definition: parse.c:16838
int parser_in_defined
Definition: ripper.c:306
#define ruby_eval_tree
Definition: parse.c:403
#define LONG2NUM(x)
Definition: ruby.h:1199
int parser_class_nest
Definition: ripper.c:298
ID token
Definition: parse.c:16407
static VALUE lex_io_gets(struct parser_params *parser, VALUE io)
Definition: parse.c:11967
NODE * rb_compile_cstr(const char *f, const char *s, int len, int line)
Definition: parse.c:11953
#define parser_is_identchar()
Definition: parse.c:11614
#define NEW_BEGIN(b)
Definition: node.h:379
#define ruby__end__seen
Definition: parse.c:396
#define dvar_curr(id)
Definition: parse.c:575
#define set_yylval_node(x)
Definition: parse.c:11525
static void yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: parse.c:4503
static void vtable_free(struct vtable *tbl)
Definition: parse.c:226
#define RSTRING_PTR(str)
Definition: ruby.h:866
#define rb_compile_error
Definition: parse.c:718
#define NEW_SPLAT(a)
Definition: node.h:434
#define reg_fragment_check(str, options)
Definition: parse.c:514
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:368
#define arg_ambiguous()
Definition: parse.c:12985
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:15461
#define RFLOAT_VALUE(v)
Definition: ruby.h:836
int nonspc
Definition: ripper.c:273
int size
Definition: encoding.c:52
#define YYSTACK_ALLOC_MAXIMUM
Definition: parse.c:1045
#define NEW_DSTR(s)
Definition: node.h:418
#define newtok()
Definition: parse.c:11504
#define f
#define yylval
Definition: parse.c:11493
#define INT2FIX(i)
Definition: ruby.h:241
#define set_yylval_name(x)
Definition: parse.c:11523
#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:840
static NODE * reg_named_capture_assign_gen(struct parser_params *parser, VALUE regexp, NODE *match)
Definition: parse.c:16273
static void parser_pushback(struct parser_params *parser, int c)
Definition: parse.c:12096
int rb_enc_symname_p(const char *name, rb_encoding *enc)
Definition: parse.c:16550
int parser_tokidx
Definition: ripper.c:308
static const yytype_uint16 yydefact[]
Definition: parse.c:1756
Definition: node.h:45
#define lpar_beg
Definition: parse.c:373
static int parser_here_document(struct parser_params *, NODE *)
Definition: parse.c:12874
#define YYUSE(e)
Definition: parse.c:980
#define COND_PUSH(n)
Definition: parse.c:171
#define xmalloc
Definition: defines.h:64
int rb_is_const_name(VALUE name)
Definition: parse.c:17084
static NODE * ret_args_gen(struct parser_params *, NODE *)
Definition: parse.c:15740
#define YYACCEPT
Definition: parse.c:4382
VALUE coverage
Definition: ripper.c:337
void rb_set_errinfo(VALUE err)
Definition: eval.c:1436
#define lex_gets_ptr
Definition: parse.c:393
#define NEW_TRUE()
Definition: node.h:451
static void dyna_pop_gen(struct parser_params *, const struct vtable *)
Definition: parse.c:16112
NODE * parser_lex_strterm
Definition: ripper.c:294
int rb_is_global_id(ID id)
Definition: parse.c:16968
const char * name
Definition: parse.c:16408
const char * name
Definition: ripper.c:13195
static void local_pop_gen(struct parser_params *)
Definition: parse.c:15993
#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:12473
Definition: node.h:207
#define NEW_UNTIL(c, b, n)
Definition: node.h:371
#define lvtbl
Definition: parse.c:395
#define new_attr_op_assign(lhs, type, attr, op, rhs)
Definition: parse.c:497
#define RARRAY_PTR(a)
Definition: ruby.h:904
#define aryset(node1, node2)
Definition: parse.c:486
#define NEW_MODULE(n, b)
Definition: node.h:443
static const struct st_hash_type symhash
Definition: parse.c:16448
#define list_append(l, i)
Definition: parse.c:445
#define tokaddmbc(c, enc)
Definition: parse.c:11513
short int yytype_int16
Definition: parse.c:947
#define cur_mid
Definition: parse.c:378
#define STR_NEW3(p, n, e, func)
Definition: parse.c:360
#define IS_BEG()
Definition: parse.c:13314
rb_magic_comment_setter_t func
Definition: ripper.c:13196
static const yytype_int16 yypact[]
Definition: parse.c:1894
#define dvar_defined(id)
Definition: parse.c:572
int parser_lpar_beg
Definition: ripper.c:300
#define ESCAPE_CONTROL
Definition: parse.c:12239
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:185
VALUE rb_check_string_type(VALUE)
Definition: string.c:1508
st_table * sym_id
Definition: ripper.c:16529
static void warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: parse.c:15579
#define yypact_value_is_default(yystate)
Definition: parse.c:3146
Definition: parse.c:848
uint8_t key[16]
Definition: random.c:1370
static int symbols_i(VALUE sym, ID value, VALUE ary)
Definition: parse.c:16924
#define nd_head
Definition: node.h:288
struct local_vars * prev
Definition: ripper.c:192
#define IS_END()
Definition: parse.c:13313
static void parser_prepare(struct parser_params *parser)
Definition: parse.c:13288
#define LONG2FIX(i)
Definition: ruby.h:242
ID rb_id_attrset(ID id)
Definition: parse.c:15175
static struct parser_params * parser_new(void)
Definition: parse.c:17280
#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:4537
Definition: node.h:139
#define new_args(f, o, r, p, t)
Definition: parse.c:467
#define T_STRING
Definition: ruby.h:490
static void rb_backref_error_gen(struct parser_params *, NODE *)
Definition: parse.c:15191
VALUE rb_id2str(ID id)
Definition: parse.c:16854
#define NEW_POSTARG(i, v)
Definition: node.h:431
#define YYINITDEPTH
Definition: parse.c:4638
#define RREGEXP(obj)
Definition: ruby.h:1100
static NODE * logop_gen(struct parser_params *, enum node_type, NODE *, NODE *)
Definition: parse.c:15717
VALUE rb_parser_new(void)
Definition: parse.c:17291
static void void_stmts_gen(struct parser_params *, NODE *)
Definition: parse.c:15437
#define ENC_SINGLE(cr)
Definition: parse.c:361
#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:1867
rb_encoding * rb_filesystem_encoding(void)
Definition: encoding.c:1248
v
Definition: win32ole.c:798
#define parse_string(n)
Definition: parse.c:11512
#define ID_ATTRSET
Definition: id.h:21
#define T_FILE
Definition: ruby.h:496
#define NEWHEAP()
Definition: parse.c:17361
#define NEW_CVASGN(v, val)
Definition: node.h:397
static int yylex(void *, void *)
Definition: parse.c:14603
#define NEW_FCALL(m, a)
Definition: node.h:424
Definition: parse.c:842
int linenum
Definition: ripper.c:271
#define YYEOF
Definition: parse.c:4380
#define tEMBDOC
Definition: eventids2.c:4
int rb_is_global_name(VALUE name)
Definition: parse.c:17096
#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:392
Definition: parse.c:861
long(* rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len)
Definition: parse.c:13070
char * parser_tokenbuf
Definition: ripper.c:307
#define node_assign(node1, node2)
Definition: parse.c:493
#define get_id(id)
Definition: parse.c:518
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:935
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:310
#define YYTERROR
Definition: parse.c:4421
static int parser_parse_string(struct parser_params *, NODE *)
Definition: parse.c:12706
#define tok()
Definition: parse.c:12108
#define cond(node)
Definition: parse.c:422
VALUE rb_ary_new2(long capa)
Definition: array.c:417
#define ruby_eval_tree_begin
Definition: parse.c:404
#define is_instance_id(id)
Definition: parse.c:113
NODE * rb_parser_append_print(VALUE vparser, NODE *node)
Definition: parse.c:16334
ID rb_intern2(const char *name, long len)
Definition: parse.c:16831
const char * parser_lex_pbeg
Definition: ripper.c:314
static NODE * cond_gen(struct parser_params *, NODE *)
Definition: parse.c:15710
NODE * rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
Definition: parse.c:11960
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:14757
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:15108
#define lex_p
Definition: parse.c:388
static int comment_at_top(struct parser_params *parser)
Definition: parse.c:13058
const char * parser_lex_p
Definition: ripper.c:315
static void dispose_string(VALUE str)
Definition: parse.c:12450
Definition: parse.c:839
#define xrealloc
Definition: defines.h:67
static int parser_nextc(struct parser_params *parser)
Definition: parse.c:12040
lex_state_e
Definition: ripper.c:140
#define read_escape(flags, e)
Definition: parse.c:11508
#define parser_isascii()
Definition: parse.c:11616
#define ID2SYM(x)
Definition: ruby.h:363
static const char *const yytname[]
Definition: parse.c:1530
Definition: node.h:61
static char * yystpcpy(char *yydest, const char *yysrc)
Definition: parse.c:4690
int parser_ruby_sourceline
Definition: ripper.c:327
#define NEW_RETRY()
Definition: node.h:378
#define call_uni_op(recv, id)
Definition: parse.c:464
#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:16674
#define StringValuePtr(v)
Definition: ruby.h:547
#define STR_FUNC_SYMBOL
Definition: parse.c:12003
#define nd_value
Definition: node.h:318
#define DVARS_INHERIT
Definition: parse.c:195
#define ID_INTERNAL
Definition: id.h:25
Definition: parse.c:849
static ID shadowing_lvar_gen(struct parser_params *, ID)
Definition: parse.c:15121
YYSTYPE * parser_yylval
Definition: ripper.c:291
static int token_info_get_column(struct parser_params *parser, const char *token)
Definition: parse.c:11620
unsigned char yytype_uint8
Definition: parse.c:926
void(* rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val)
Definition: parse.c:13071
#define NEW_RESBODY(a, ex, n)
Definition: node.h:381
Definition: parse.c:851
#define NEW_ARGSCAT(a, b)
Definition: node.h:432
#define arg_var(id)
Definition: parse.c:558
#define NEW_DASGN_CURR(v, val)
Definition: node.h:393
VALUE rb_inspect(VALUE)
Definition: object.c:402
#define is_junk_id(id)
Definition: parse.c:117
static NODE * yycompile(struct parser_params *parser, const char *f, int line)
Definition: parse.c:11858
static void vtable_add(struct vtable *tbl, ID id)
Definition: parse.c:238
int rb_is_class_id(ID id)
Definition: parse.c:16962
#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:4267
static int is_static_content(NODE *node)
Definition: parse.c:15522
int is_ripper
Definition: ripper.c:288
#define in_defined
Definition: parse.c:379
rb_encoding * rb_ascii8bit_encoding(void)
Definition: encoding.c:1153
int rb_enc_find_index(const char *name)
Definition: encoding.c:635
VALUE eofp
Definition: ripper.c:292
static NODE * aryset_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15159
VALUE rb_parser_end_seen_p(VALUE vparser)
Definition: parse.c:17305
static int parser_heredoc_identifier(struct parser_params *parser)
Definition: parse.c:12764
Definition: node.h:31
int rb_is_const_id(ID id)
Definition: parse.c:16956
static int parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp, int string_literal, int symbol_literal, int regexp_literal)
Definition: parse.c:12168
long len
Definition: ruby.h:846
static const struct vtable * dyna_push_gen(struct parser_params *)
Definition: parse.c:16083
#define CONST_ID(var, str)
Definition: ruby.h:1318
NODE * heap
Definition: ripper.c:289
static NODE * block_append_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14683
#define NEW_CVAR(v)
Definition: node.h:410
#define tokline
Definition: parse.c:383
#define ESCAPE_META
Definition: parse.c:12240
#define local_push(top)
Definition: parse.c:552
Definition: parse.c:866
#define NEW_MATCH2(n1, n2)
Definition: node.h:414
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: parse.c:17350
static void new_bv_gen(struct parser_params *, ID)
Definition: parse.c:15145
#define assignable(id, node)
Definition: parse.c:483
ID first_post_arg
Definition: node.h:511
st_table * st_init_numtable_with_size(st_index_t)
Definition: st.c:278
Definition: parse.c:854
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:15616
#define ruby_debug_lines
Definition: parse.c:405
Definition: id.h:71
#define rb_enc_mbcput(c, buf, enc)
Definition: encoding.h:161
#define IS_ARG()
Definition: parse.c:13312
#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:12151
#define new_evstr(n)
Definition: parse.c:456
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
Definition: parse.c:17056
int rb_parse_in_eval(void)
Definition: compile.c:5876
NODE * rb_compile_file(const char *f, VALUE file, int start)
Definition: parse.c:11973
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:12035
#define rb_node_newnode(type, a1, a2, a3)
Definition: parse.c:419
#define SYMBOL_P(x)
Definition: ruby.h:362
#define tCOMMENT
Definition: eventids2.c:2
NODE * kw_args
Definition: node.h:516
#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:1264
Definition: parse.c:836
#define void_stmts(node)
Definition: parse.c:436
#define block_append(h, t)
Definition: parse.c:443
VALUE(* parser_lex_gets)(struct parser_params *, VALUE)
Definition: ripper.c:321
#define NULL
Definition: _sdbm.c:103
#define compile_for_eval
Definition: parse.c:377
#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:14798
VALUE rb_hash_aset(VALUE, VALUE, VALUE)
#define tIGNORED_NL
Definition: eventids2.c:1
#define yyerrok
Definition: parse.c:4377
#define NEW_STR(s)
Definition: node.h:417
static NODE * call_uni_op_gen(struct parser_params *, NODE *, ID)
Definition: parse.c:14910
#define YYMAXDEPTH
Definition: parse.c:4649
static int literal_concat0(struct parser_params *, VALUE, VALUE)
Definition: parse.c:14781
int rb_is_instance_id(ID id)
Definition: parse.c:16974
void rb_parser_free(struct parser_params *parser, void *ptr)
Definition: parse.c:17406
Definition: parse.c:835
NODE * kw_rest_arg
Definition: node.h:517
#define ID_GLOBAL
Definition: id.h:20
#define in_def
Definition: parse.c:376
#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:5857
st_index_t num_entries
Definition: st.h:93
Definition: parse.c:846
#define IS_LABEL_SUFFIX(n)
Definition: parse.c:13317
#define NEW_SELF()
Definition: node.h:449
Definition: parse.c:822
NODE * parser_eval_tree_begin
Definition: ripper.c:334
static int match(VALUE str, VALUE pat, VALUE hash, int(*cb)(VALUE, VALUE))
Definition: date_parse.c:273
static NODE * parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: parse.c:11920
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1344
Definition: parse.c:853
#define ruby_verbose
Definition: ruby.h:1363
VALUE rb_str_append(VALUE, VALUE)
Definition: string.c:2121
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
Definition: st.c:1000
static void parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
Definition: parse.c:13083
#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
#define ifndef_ripper(x)
Definition: parse.c:685
#define YYLEX
Definition: parse.c:4463
static VALUE lex_getline(struct parser_params *parser)
Definition: parse.c:11897
VALUE rb_sym_all_symbols(void)
Definition: parse.c:16947
VALUE rb_eArgError
Definition: error.c:512
#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:11509
static NODE * node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE)
Definition: parse.c:14630
Definition: node.h:137
#define dyna_push()
Definition: parse.c:565
#define whole_match_p(e, l, i)
Definition: parse.c:11517
#define was_bol()
Definition: parse.c:12105
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:4763
#define HEAPCNT(n, size)
Definition: parse.c:17360
#define STR_FUNC_EXPAND
Definition: parse.c:12000
static int parser_peek_variable_name(struct parser_params *parser)
Definition: parse.c:12670
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:16055
#define SPECIAL_PUNCT(idx)
Definition: parse.c:12646
#define NEW_CDECL(v, val, path)
Definition: node.h:396
#define rb_backref_error(n)
Definition: parse.c:491
#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:847
#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:2074
#define STR_NEW(p, n)
Definition: parse.c:357
static NODE * new_args_tail_gen(struct parser_params *, NODE *, ID, ID)
Definition: parse.c:15826
#define rb_warningS(fmt, a)
Definition: parse.c:697
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: parse.c:1100
#define reduce_nodes(n)
Definition: parse.c:438
#define void_expr0(node)
Definition: parse.c:433
rb_encoding * rb_enc_from_index(int index)
Definition: encoding.c:548
#define tokcopy(n)
Definition: parse.c:12164
void Init_sym(void)
Definition: parse.c:16481
VALUE rb_str_new(const char *, long)
Definition: string.c:425
Definition: parse.c:826
#define xcalloc
Definition: defines.h:66
#define ID_CLASS
Definition: id.h:23
Definition: parse.c:841