Ruby  2.1.10p492(2016-04-01revision54464)
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 YYMALLOC(size) rb_parser_malloc(parser, (size))
93 #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
94 #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
95 #define YYFREE(ptr) rb_parser_free(parser, (ptr))
96 #define malloc YYMALLOC
97 #define realloc YYREALLOC
98 #define calloc YYCALLOC
99 #define free YYFREE
100 
101 #ifndef RIPPER
102 static ID register_symid(ID, const char *, long, rb_encoding *);
103 static ID register_symid_str(ID, VALUE);
104 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
105 #include "id.c"
106 #endif
107 
108 #define is_notop_id(id) ((id)>tLAST_OP_ID)
109 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
110 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
111 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
112 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
113 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
114 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
115 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
116 #define id_type(id) (is_notop_id(id) ? (int)((id)&ID_SCOPE_MASK) : -1)
117 
118 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
119  (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
120  ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
121  ((id)&ID_SCOPE_MASK) == ID_CLASS))
122 
124  EXPR_BEG_bit, /* ignore newline, +/- is a sign. */
125  EXPR_END_bit, /* newline significant, +/- is an operator. */
126  EXPR_ENDARG_bit, /* ditto, and unbound braces. */
127  EXPR_ENDFN_bit, /* ditto, and unbound braces. */
128  EXPR_ARG_bit, /* newline significant, +/- is an operator. */
129  EXPR_CMDARG_bit, /* newline significant, +/- is an operator. */
130  EXPR_MID_bit, /* newline significant, +/- is an operator. */
131  EXPR_FNAME_bit, /* ignore newline, no reserved words. */
132  EXPR_DOT_bit, /* right after `.' or `::', no reserved words. */
133  EXPR_CLASS_bit, /* immediate after `class', no here document. */
134  EXPR_VALUE_bit, /* alike EXPR_BEG but label is disallowed. */
135  EXPR_LABELARG_bit, /* ignore significant, +/- is a sign. */
137 };
138 /* examine combinations */
140 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
142  DEF_EXPR(END),
143  DEF_EXPR(ENDARG),
144  DEF_EXPR(ENDFN),
145  DEF_EXPR(ARG),
146  DEF_EXPR(CMDARG),
147  DEF_EXPR(MID),
148  DEF_EXPR(FNAME),
149  DEF_EXPR(DOT),
150  DEF_EXPR(CLASS),
151  DEF_EXPR(VALUE),
152  DEF_EXPR(LABELARG),
153  EXPR_BEG_ANY = (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS | EXPR_LABELARG),
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;
194 };
195 
196 #define DVARS_INHERIT ((void*)1)
197 #define DVARS_TOPSCOPE NULL
198 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
199 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
200 
201 static int
202 vtable_size(const struct vtable *tbl)
203 {
204  if (POINTER_P(tbl)) {
205  return tbl->pos;
206  }
207  else {
208  return 0;
209  }
210 }
211 
212 #define VTBL_DEBUG 0
213 
214 static struct vtable *
216 {
217  struct vtable *tbl = ALLOC(struct vtable);
218  tbl->pos = 0;
219  tbl->capa = 8;
220  tbl->tbl = ALLOC_N(ID, tbl->capa);
221  tbl->prev = prev;
222  if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
223  return tbl;
224 }
225 
226 static void
228 {
229  if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
230  if (POINTER_P(tbl)) {
231  if (tbl->tbl) {
232  xfree(tbl->tbl);
233  }
234  xfree(tbl);
235  }
236 }
237 
238 static void
239 vtable_add(struct vtable *tbl, ID id)
240 {
241  if (!POINTER_P(tbl)) {
242  rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
243  }
244  if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
245 
246  if (tbl->pos == tbl->capa) {
247  tbl->capa = tbl->capa * 2;
248  REALLOC_N(tbl->tbl, ID, tbl->capa);
249  }
250  tbl->tbl[tbl->pos++] = id;
251 }
252 
253 static int
254 vtable_included(const struct vtable * tbl, ID id)
255 {
256  int i;
257 
258  if (POINTER_P(tbl)) {
259  for (i = 0; i < tbl->pos; i++) {
260  if (tbl->tbl[i] == id) {
261  return i+1;
262  }
263  }
264  }
265  return 0;
266 }
267 
268 
269 #ifndef RIPPER
270 typedef struct token_info {
271  const char *token;
272  int linenum;
273  int column;
274  int nonspc;
275  struct token_info *next;
276 } token_info;
277 #endif
278 
279 /*
280  Structure of Lexer Buffer:
281 
282  lex_pbeg tokp lex_p lex_pend
283  | | | |
284  |-----------+--------------+------------|
285  |<------------>|
286  token
287 */
288 struct parser_params {
289  int is_ripper;
290  NODE *heap;
291 
293  VALUE eofp;
294 
299  int parser_class_nest;
300  int parser_paren_nest;
301  int parser_lpar_beg;
302  int parser_in_single;
303  int parser_in_def;
304  int parser_brace_nest;
307  int parser_in_kwarg;
308  int parser_in_defined;
309  char *parser_tokenbuf;
310  int parser_tokidx;
311  int parser_toksiz;
312  int parser_tokline;
316  const char *parser_lex_pbeg;
317  const char *parser_lex_p;
318  const char *parser_lex_pend;
319  int parser_heredoc_end;
322  long parser_lex_gets_ptr;
324  struct local_vars *parser_lvtbl;
326  int line_count;
327  int has_shebang;
328  char *parser_ruby_sourcefile; /* current source file */
329  int parser_ruby_sourceline; /* current line no. */
331  rb_encoding *enc;
332 
333  int parser_yydebug;
334 
335  int last_cr_line;
336 
337 #ifndef RIPPER
338  /* Ruby core only */
342  VALUE coverage;
343  int nerr;
344 
347 #else
348  /* Ripper only */
349  const char *tokp;
350  VALUE delayed;
351  int delayed_line;
352  int delayed_col;
353 
354  VALUE value;
355  VALUE result;
356  VALUE parsing_thread;
357  int toplevel_p;
358 #endif
359 };
360 
361 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)
362 #define STR_NEW0() rb_enc_str_new(0,0,current_enc)
363 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)
364 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)
365 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
366 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc)
367 
368 static int parser_yyerror(struct parser_params*, const char*);
369 #define yyerror(msg) parser_yyerror(parser, (msg))
370 
371 #define lex_strterm (parser->parser_lex_strterm)
372 #define lex_state (parser->parser_lex_state)
373 #define cond_stack (parser->parser_cond_stack)
374 #define cmdarg_stack (parser->parser_cmdarg_stack)
375 #define class_nest (parser->parser_class_nest)
376 #define paren_nest (parser->parser_paren_nest)
377 #define lpar_beg (parser->parser_lpar_beg)
378 #define brace_nest (parser->parser_brace_nest)
379 #define in_single (parser->parser_in_single)
380 #define in_def (parser->parser_in_def)
381 #define compile_for_eval (parser->parser_compile_for_eval)
382 #define cur_mid (parser->parser_cur_mid)
383 #define in_defined (parser->parser_in_defined)
384 #define tokenbuf (parser->parser_tokenbuf)
385 #define tokidx (parser->parser_tokidx)
386 #define toksiz (parser->parser_toksiz)
387 #define tokline (parser->parser_tokline)
388 #define lex_input (parser->parser_lex_input)
389 #define lex_lastline (parser->parser_lex_lastline)
390 #define lex_nextline (parser->parser_lex_nextline)
391 #define lex_pbeg (parser->parser_lex_pbeg)
392 #define lex_p (parser->parser_lex_p)
393 #define lex_pend (parser->parser_lex_pend)
394 #define heredoc_end (parser->parser_heredoc_end)
395 #define command_start (parser->parser_command_start)
396 #define deferred_nodes (parser->parser_deferred_nodes)
397 #define lex_gets_ptr (parser->parser_lex_gets_ptr)
398 #define lex_gets (parser->parser_lex_gets)
399 #define lvtbl (parser->parser_lvtbl)
400 #define ruby__end__seen (parser->parser_ruby__end__seen)
401 #define ruby_sourceline (parser->parser_ruby_sourceline)
402 #define ruby_sourcefile (parser->parser_ruby_sourcefile)
403 #define ruby_sourcefile_string (parser->parser_ruby_sourcefile_string)
404 #define current_enc (parser->enc)
405 #define yydebug (parser->parser_yydebug)
406 #ifdef RIPPER
407 #else
408 #define ruby_eval_tree (parser->parser_eval_tree)
409 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin)
410 #define ruby_debug_lines (parser->debug_lines)
411 #define ruby_coverage (parser->coverage)
412 #endif
413 
414 #if YYPURE
415 static int yylex(void*, void*);
416 #else
417 static int yylex(void*);
418 #endif
419 
420 #ifndef RIPPER
421 #define yyparse ruby_yyparse
422 
423 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
424 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
425 
426 static NODE *cond_gen(struct parser_params*,NODE*);
427 #define cond(node) cond_gen(parser, (node))
428 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
429 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
430 
431 static NODE *newline_node(NODE*);
432 static void fixpos(NODE*,NODE*);
433 
434 static int value_expr_gen(struct parser_params*,NODE*);
435 static void void_expr_gen(struct parser_params*,NODE*);
436 static NODE *remove_begin(NODE*);
437 static NODE *remove_begin_all(NODE*);
438 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
439 #define void_expr0(node) void_expr_gen(parser, (node))
440 #define void_expr(node) void_expr0((node) = remove_begin(node))
441 static void void_stmts_gen(struct parser_params*,NODE*);
442 #define void_stmts(node) void_stmts_gen(parser, (node))
443 static void reduce_nodes_gen(struct parser_params*,NODE**);
444 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
445 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
446 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
447 
448 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
449 #define block_append(h,t) block_append_gen(parser,(h),(t))
450 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
451 #define list_append(l,i) list_append_gen(parser,(l),(i))
452 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
453 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
454 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
455 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
456 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
457 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
458 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
459 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
460 static int literal_concat0(struct parser_params *, VALUE, VALUE);
461 static NODE *new_evstr_gen(struct parser_params*,NODE*);
462 #define new_evstr(n) new_evstr_gen(parser,(n))
463 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
464 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
465 static NODE *splat_array(NODE*);
466 
467 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
468 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
469 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
470 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
471 
472 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
473 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
474 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);
475 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
476 
477 static NODE *negate_lit(NODE*);
478 static NODE *ret_args_gen(struct parser_params*,NODE*);
479 #define ret_args(node) ret_args_gen(parser, (node))
480 static NODE *arg_blk_pass(NODE*,NODE*);
481 static NODE *new_yield_gen(struct parser_params*,NODE*);
482 #define new_yield(node) new_yield_gen(parser, (node))
483 static NODE *dsym_node_gen(struct parser_params*,NODE*);
484 #define dsym_node(node) dsym_node_gen(parser, (node))
485 
486 static NODE *gettable_gen(struct parser_params*,ID);
487 #define gettable(id) gettable_gen(parser,(id))
488 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
489 #define assignable(id,node) assignable_gen(parser, (id), (node))
490 
491 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
492 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
493 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
494 #define attrset(node,id) attrset_gen(parser, (node), (id))
495 
496 static void rb_backref_error_gen(struct parser_params*,NODE*);
497 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
498 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
499 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
500 
501 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
502 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
503 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
504 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
505 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
506 
507 #define new_defined(expr) NEW_DEFINED(remove_begin_all(expr))
508 
509 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
510 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
511 
512 static ID *local_tbl_gen(struct parser_params*);
513 #define local_tbl() local_tbl_gen(parser)
514 
515 static void fixup_nodes(NODE **);
516 
517 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
518 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
519 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
520 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
521 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
522 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
523 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
524 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
525 
526 #define get_id(id) (id)
527 #define get_value(val) (val)
528 #else
529 #define value_expr(node) ((void)(node))
530 #define remove_begin(node) (node)
531 #define rb_dvar_defined(id) 0
532 #define rb_local_defined(id) 0
533 static ID ripper_get_id(VALUE);
534 #define get_id(id) ripper_get_id(id)
535 static VALUE ripper_get_value(VALUE);
536 #define get_value(val) ripper_get_value(val)
537 static VALUE assignable_gen(struct parser_params*,VALUE);
538 #define assignable(lhs,node) assignable_gen(parser, (lhs))
539 static int id_is_var_gen(struct parser_params *parser, ID id);
540 #define id_is_var(id) id_is_var_gen(parser, (id))
541 
542 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2))
543 
544 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
545 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);
546 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
547 
548 #endif /* !RIPPER */
549 
550 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
551 
552 static ID formal_argument_gen(struct parser_params*, ID);
553 #define formal_argument(id) formal_argument_gen(parser, (id))
554 static ID shadowing_lvar_gen(struct parser_params*,ID);
555 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
556 static void new_bv_gen(struct parser_params*,ID);
557 #define new_bv(id) new_bv_gen(parser, (id))
558 
559 static void local_push_gen(struct parser_params*,int);
560 #define local_push(top) local_push_gen(parser,(top))
561 static void local_pop_gen(struct parser_params*);
562 #define local_pop() local_pop_gen(parser)
563 static int local_var_gen(struct parser_params*, ID);
564 #define local_var(id) local_var_gen(parser, (id))
565 static int arg_var_gen(struct parser_params*, ID);
566 #define arg_var(id) arg_var_gen(parser, (id))
567 static int local_id_gen(struct parser_params*, ID);
568 #define local_id(id) local_id_gen(parser, (id))
569 static ID internal_id_gen(struct parser_params*);
570 #define internal_id() internal_id_gen(parser)
571 
572 static const struct vtable *dyna_push_gen(struct parser_params *);
573 #define dyna_push() dyna_push_gen(parser)
574 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
575 #define dyna_pop(node) dyna_pop_gen(parser, (node))
576 static int dyna_in_block_gen(struct parser_params*);
577 #define dyna_in_block() dyna_in_block_gen(parser)
578 #define dyna_var(id) local_var(id)
579 static int dvar_defined_gen(struct parser_params*,ID,int);
580 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
581 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
582 static int dvar_curr_gen(struct parser_params*,ID);
583 #define dvar_curr(id) dvar_curr_gen(parser, (id))
584 
585 static int lvar_defined_gen(struct parser_params*, ID);
586 #define lvar_defined(id) lvar_defined_gen(parser, (id))
587 
588 #define RE_OPTION_ONCE (1<<16)
589 #define RE_OPTION_ENCODING_SHIFT 8
590 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
591 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
592 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
593 #define RE_OPTION_MASK 0xff
594 #define RE_OPTION_ARG_ENCODING_NONE 32
595 
596 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
597 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
598 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
599 #define nd_func u1.id
600 #if SIZEOF_SHORT == 2
601 #define nd_term(node) ((signed short)(node)->u2.id)
602 #else
603 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
604 #endif
605 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
606 #define nd_nest u3.cnt
607 
608 /****** Ripper *******/
609 
610 #ifdef RIPPER
611 #define RIPPER_VERSION "0.1.0"
612 
613 #include "eventids1.c"
614 #include "eventids2.c"
615 
616 static VALUE ripper_dispatch0(struct parser_params*,ID);
617 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
618 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
619 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
620 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
621 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
622 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
623 
624 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
625 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
626 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
627 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
628 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
629 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
630 #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))
631 
632 #define yyparse ripper_yyparse
633 
634 #define ripper_intern(s) ID2SYM(rb_intern(s))
635 static VALUE ripper_id2sym(ID);
636 #ifdef __GNUC__
637 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
638  ID2SYM(id) : ripper_id2sym(id))
639 #endif
640 
641 #define arg_new() dispatch0(args_new)
642 #define arg_add(l,a) dispatch2(args_add, (l), (a))
643 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
644 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
645 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
646 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
647 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
648 
649 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
650 #define mrhs_new() dispatch0(mrhs_new)
651 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
652 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
653 
654 #define mlhs_new() dispatch0(mlhs_new)
655 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
656 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
657 
658 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
659  dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
660 
661 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
662 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
663 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
664 
665 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
666 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
667 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
668 
669 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
670 
671 static inline VALUE
672 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
673 {
674  NODE *t = (NODE *)tail;
675  VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
676  return params_new(f, o, r, p, k, kr, escape_Qundef(b));
677 }
678 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
679 
680 static inline VALUE
681 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
682 {
683  return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);
684 }
685 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
686 
687 #define new_defined(expr) dispatch1(defined, (expr))
688 
689 #define FIXME 0
690 
691 #endif /* RIPPER */
692 
693 #ifndef RIPPER
694 # define Qnone 0
695 # define ifndef_ripper(x) (x)
696 #else
697 # define Qnone Qnil
698 # define ifndef_ripper(x)
699 #endif
700 
701 #ifndef RIPPER
702 # define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
703 # define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
704 # define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
705 # define rb_warn4S(file,line,fmt,a) rb_compile_warn((file), (line), (fmt), (a))
706 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
707 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
708 #else
709 # define rb_warn0(fmt) ripper_warn0(parser, (fmt))
710 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))
711 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))
712 # define rb_warn4S(file,line,fmt,a) ripper_warnS(parser, (fmt), (a))
713 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
714 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
715 static void ripper_warn0(struct parser_params*, const char*);
716 static void ripper_warnI(struct parser_params*, const char*, int);
717 static void ripper_warnS(struct parser_params*, const char*, const char*);
718 static void ripper_warning0(struct parser_params*, const char*);
719 static void ripper_warningS(struct parser_params*, const char*, const char*);
720 #endif
721 
722 #ifdef RIPPER
723 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
724 # define rb_compile_error ripper_compile_error
725 # define compile_error ripper_compile_error
726 # define PARSER_ARG parser,
727 #else
728 # define rb_compile_error rb_compile_error_with_enc
729 # define compile_error parser->nerr++,rb_compile_error_with_enc
730 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
731 #endif
732 
733 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
734  for instance). This is too low for Ruby to parse some files, such as
735  date/format.rb, therefore bump the value up to at least Bison's default. */
736 #ifdef OLD_YACC
737 #ifndef YYMAXDEPTH
738 #define YYMAXDEPTH 10000
739 #endif
740 #endif
741 
742 #ifndef RIPPER
743 static void token_info_push(struct parser_params*, const char *token);
744 static void token_info_pop(struct parser_params*, const char *token);
745 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
746 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
747 #else
748 #define token_info_push(token) /* nothing */
749 #define token_info_pop(token) /* nothing */
750 #endif
751 
752 
753 /* Line 268 of yacc.c */
754 #line 755 "parse.c"
755 
756 /* Enabling traces. */
757 #ifndef YYDEBUG
758 # define YYDEBUG 0
759 #endif
760 
761 /* Enabling verbose error messages. */
762 #ifdef YYERROR_VERBOSE
763 # undef YYERROR_VERBOSE
764 # define YYERROR_VERBOSE 1
765 #else
766 # define YYERROR_VERBOSE 0
767 #endif
768 
769 /* Enabling the token table. */
770 #ifndef YYTOKEN_TABLE
771 # define YYTOKEN_TABLE 0
772 #endif
773 
774 
775 /* Tokens. */
776 #ifndef YYTOKENTYPE
777 # define YYTOKENTYPE
778  /* Put the tokens into the symbol table, so that GDB and other debuggers
779  know about them. */
780  enum yytokentype {
784  keyword_def = 260,
789  keyword_end = 265,
790  keyword_if = 266,
799  keyword_for = 275,
804  keyword_in = 280,
805  keyword_do = 281,
813  keyword_nil = 289,
816  keyword_and = 292,
817  keyword_or = 293,
818  keyword_not = 294,
819  modifier_if = 295,
827  keyword_END = 303,
831  tIDENTIFIER = 307,
832  tFID = 308,
833  tGVAR = 309,
834  tIVAR = 310,
835  tCONSTANT = 311,
836  tCVAR = 312,
837  tLABEL = 313,
838  tINTEGER = 314,
839  tFLOAT = 315,
840  tRATIONAL = 316,
841  tIMAGINARY = 317,
843  tCHAR = 319,
844  tNTH_REF = 320,
845  tBACK_REF = 321,
846  tREGEXP_END = 322,
847  tUPLUS = 130,
848  tUMINUS = 131,
849  tPOW = 132,
850  tCMP = 134,
851  tEQ = 139,
852  tEQQ = 140,
853  tNEQ = 141,
854  tGEQ = 138,
855  tLEQ = 137,
856  tANDOP = 323,
857  tOROP = 324,
858  tMATCH = 142,
859  tNMATCH = 143,
860  tDOT2 = 128,
861  tDOT3 = 129,
862  tAREF = 144,
863  tASET = 145,
864  tLSHFT = 135,
865  tRSHFT = 136,
866  tCOLON2 = 325,
867  tCOLON3 = 326,
868  tOP_ASGN = 327,
869  tASSOC = 328,
870  tLPAREN = 329,
871  tLPAREN_ARG = 330,
872  tRPAREN = 331,
873  tLBRACK = 332,
874  tLBRACE = 333,
875  tLBRACE_ARG = 334,
876  tSTAR = 335,
877  tDSTAR = 336,
878  tAMPER = 337,
879  tLAMBDA = 338,
880  tSYMBEG = 339,
881  tSTRING_BEG = 340,
883  tREGEXP_BEG = 342,
884  tWORDS_BEG = 343,
885  tQWORDS_BEG = 344,
891  tSTRING_END = 350,
892  tLAMBEG = 351,
893  tLOWEST = 352,
894  tUMINUS_NUM = 353,
896  };
897 #endif
898 
899 
900 
901 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
902 typedef union YYSTYPE
903 {
904 
905 /* Line 293 of yacc.c */
906 #line 699 "parse.y"
907 
908  VALUE val;
909  NODE *node;
910  ID id;
911  int num;
912  const struct vtable *vars;
913 
914 
915 
916 /* Line 293 of yacc.c */
917 #line 918 "parse.c"
918 } YYSTYPE;
919 # define YYSTYPE_IS_TRIVIAL 1
920 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
921 # define YYSTYPE_IS_DECLARED 1
922 #endif
923 
924 
925 /* Copy the second part of user declarations. */
926 
927 
928 /* Line 343 of yacc.c */
929 #line 930 "parse.c"
930 
931 #ifdef short
932 # undef short
933 #endif
934 
935 #ifdef YYTYPE_UINT8
936 typedef YYTYPE_UINT8 yytype_uint8;
937 #else
938 typedef unsigned char yytype_uint8;
939 #endif
940 
941 #ifdef YYTYPE_INT8
942 typedef YYTYPE_INT8 yytype_int8;
943 #elif (defined __STDC__ || defined __C99__FUNC__ \
944  || defined __cplusplus || defined _MSC_VER)
945 typedef signed char yytype_int8;
946 #else
947 typedef short int yytype_int8;
948 #endif
949 
950 #ifdef YYTYPE_UINT16
951 typedef YYTYPE_UINT16 yytype_uint16;
952 #else
953 typedef unsigned short int yytype_uint16;
954 #endif
955 
956 #ifdef YYTYPE_INT16
957 typedef YYTYPE_INT16 yytype_int16;
958 #else
959 typedef short int yytype_int16;
960 #endif
961 
962 #ifndef YYSIZE_T
963 # ifdef __SIZE_TYPE__
964 # define YYSIZE_T __SIZE_TYPE__
965 # elif defined size_t
966 # define YYSIZE_T size_t
967 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
968  || defined __cplusplus || defined _MSC_VER)
969 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
970 # define YYSIZE_T size_t
971 # else
972 # define YYSIZE_T unsigned int
973 # endif
974 #endif
975 
976 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
977 
978 #ifndef YY_
979 # if defined YYENABLE_NLS && YYENABLE_NLS
980 # if ENABLE_NLS
981 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
982 # define YY_(msgid) dgettext ("bison-runtime", msgid)
983 # endif
984 # endif
985 # ifndef YY_
986 # define YY_(msgid) msgid
987 # endif
988 #endif
989 
990 /* Suppress unused-variable warnings by "using" E. */
991 #if ! defined lint || defined __GNUC__
992 # define YYUSE(e) ((void) (e))
993 #else
994 # define YYUSE(e) /* empty */
995 #endif
996 
997 /* Identity function, used to suppress warnings about constant conditions. */
998 #ifndef lint
999 # define YYID(n) (n)
1000 #else
1001 #if (defined __STDC__ || defined __C99__FUNC__ \
1002  || defined __cplusplus || defined _MSC_VER)
1003 static int
1004 YYID (int yyi)
1005 #else
1006 static int
1007 YYID (yyi)
1008  int yyi;
1009 #endif
1010 {
1011  return yyi;
1012 }
1013 #endif
1014 
1015 #if ! defined yyoverflow || YYERROR_VERBOSE
1016 
1017 /* The parser invokes alloca or malloc; define the necessary symbols. */
1018 
1019 # ifdef YYSTACK_USE_ALLOCA
1020 # if YYSTACK_USE_ALLOCA
1021 # ifdef __GNUC__
1022 # define YYSTACK_ALLOC __builtin_alloca
1023 # elif defined __BUILTIN_VA_ARG_INCR
1024 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1025 # elif defined _AIX
1026 # define YYSTACK_ALLOC __alloca
1027 # elif defined _MSC_VER
1028 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1029 # define alloca _alloca
1030 # else
1031 # define YYSTACK_ALLOC alloca
1032 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1033  || defined __cplusplus || defined _MSC_VER)
1034 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1035 # ifndef EXIT_SUCCESS
1036 # define EXIT_SUCCESS 0
1037 # endif
1038 # endif
1039 # endif
1040 # endif
1041 # endif
1042 
1043 # ifdef YYSTACK_ALLOC
1044  /* Pacify GCC's `empty if-body' warning. */
1045 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1046 # ifndef YYSTACK_ALLOC_MAXIMUM
1047  /* The OS might guarantee only one guard page at the bottom of the stack,
1048  and a page size can be as small as 4096 bytes. So we cannot safely
1049  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1050  to allow for a few compiler-allocated temporary stack slots. */
1051 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1052 # endif
1053 # else
1054 # define YYSTACK_ALLOC YYMALLOC
1055 # define YYSTACK_FREE YYFREE
1056 # ifndef YYSTACK_ALLOC_MAXIMUM
1057 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1058 # endif
1059 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
1060  && ! ((defined YYMALLOC || defined malloc) \
1061  && (defined YYFREE || defined free)))
1062 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1063 # ifndef EXIT_SUCCESS
1064 # define EXIT_SUCCESS 0
1065 # endif
1066 # endif
1067 # ifndef YYMALLOC
1068 # define YYMALLOC malloc
1069 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1070  || defined __cplusplus || defined _MSC_VER)
1071 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1072 # endif
1073 # endif
1074 # ifndef YYFREE
1075 # define YYFREE free
1076 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
1077  || defined __cplusplus || defined _MSC_VER)
1078 void free (void *); /* INFRINGES ON USER NAME SPACE */
1079 # endif
1080 # endif
1081 # endif
1082 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1083 
1084 
1085 #if (! defined yyoverflow \
1086  && (! defined __cplusplus \
1087  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1088 
1089 /* A type that is properly aligned for any stack member. */
1090 union yyalloc
1091 {
1094 };
1095 
1096 /* The size of the maximum gap between one aligned stack and the next. */
1097 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1098 
1099 /* The size of an array large to enough to hold all stacks, each with
1100  N elements. */
1101 # define YYSTACK_BYTES(N) \
1102  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1103  + YYSTACK_GAP_MAXIMUM)
1104 
1105 # define YYCOPY_NEEDED 1
1106 
1107 /* Relocate STACK from its old location to the new one. The
1108  local variables YYSIZE and YYSTACKSIZE give the old and new number of
1109  elements in the stack, and YYPTR gives the new location of the
1110  stack. Advance YYPTR to a properly aligned location for the next
1111  stack. */
1112 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1113  do \
1114  { \
1115  YYSIZE_T yynewbytes; \
1116  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1117  Stack = &yyptr->Stack_alloc; \
1118  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1119  yyptr += yynewbytes / sizeof (*yyptr); \
1120  } \
1121  while (YYID (0))
1122 
1123 #endif
1124 
1125 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1126 /* Copy COUNT objects from FROM to TO. The source and destination do
1127  not overlap. */
1128 # ifndef YYCOPY
1129 # if defined __GNUC__ && 1 < __GNUC__
1130 # define YYCOPY(To, From, Count) \
1131  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1132 # else
1133 # define YYCOPY(To, From, Count) \
1134  do \
1135  { \
1136  YYSIZE_T yyi; \
1137  for (yyi = 0; yyi < (Count); yyi++) \
1138  (To)[yyi] = (From)[yyi]; \
1139  } \
1140  while (YYID (0))
1141 # endif
1142 # endif
1143 #endif /* !YYCOPY_NEEDED */
1144 
1145 /* YYFINAL -- State number of the termination state. */
1146 #define YYFINAL 3
1147 /* YYLAST -- Last index in YYTABLE. */
1148 #define YYLAST 11083
1149 
1150 /* YYNTOKENS -- Number of terminals. */
1151 #define YYNTOKENS 144
1152 /* YYNNTS -- Number of nonterminals. */
1153 #define YYNNTS 204
1154 /* YYNRULES -- Number of rules. */
1155 #define YYNRULES 627
1156 /* YYNRULES -- Number of states. */
1157 #define YYNSTATES 1060
1158 
1159 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1160 #define YYUNDEFTOK 2
1161 #define YYMAXUTOK 354
1162 
1163 #define YYTRANSLATE(YYX) \
1164  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1165 
1166 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1167 static const yytype_uint8 yytranslate[] =
1168 {
1169  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1170  143, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1171  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1172  2, 2, 142, 129, 2, 2, 2, 127, 122, 2,
1173  138, 139, 125, 123, 136, 124, 135, 126, 2, 2,
1174  2, 2, 2, 2, 2, 2, 2, 2, 117, 141,
1175  119, 115, 118, 116, 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, 134, 2, 140, 121, 2, 137, 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, 132, 120, 133, 130, 2, 81, 82,
1182  68, 69, 70, 2, 71, 85, 86, 76, 75, 72,
1183  73, 74, 79, 80, 83, 84, 2, 2, 2, 2,
1184  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1185  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1186  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1187  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1188  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1189  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1190  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1191  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1192  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1193  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1194  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1195  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1196  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1197  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1198  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1199  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1200  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1201  65, 66, 67, 77, 78, 87, 88, 89, 90, 91,
1202  92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
1203  102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
1204  112, 113, 114, 128, 131
1205 };
1206 
1207 #if YYDEBUG
1208 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1209  YYRHS. */
1210 static const yytype_uint16 yyprhs[] =
1211 {
1212  0, 0, 3, 4, 7, 10, 12, 14, 18, 21,
1213  23, 24, 30, 35, 38, 40, 42, 46, 49, 51,
1214  52, 58, 59, 64, 68, 72, 76, 79, 83, 87,
1215  91, 95, 99, 104, 106, 110, 114, 121, 127, 133,
1216  139, 145, 149, 153, 157, 159, 163, 167, 169, 173,
1217  177, 181, 184, 186, 188, 190, 192, 194, 199, 200,
1218  206, 208, 211, 215, 220, 226, 231, 237, 240, 243,
1219  246, 249, 252, 254, 258, 260, 264, 266, 269, 273,
1220  279, 282, 287, 290, 295, 297, 301, 303, 307, 310,
1221  314, 316, 320, 322, 324, 329, 333, 337, 341, 345,
1222  348, 350, 352, 354, 359, 363, 367, 371, 375, 378,
1223  380, 382, 384, 387, 389, 393, 395, 397, 399, 401,
1224  403, 405, 407, 409, 411, 413, 414, 419, 421, 423,
1225  425, 427, 429, 431, 433, 435, 437, 439, 441, 443,
1226  445, 447, 449, 451, 453, 455, 457, 459, 461, 463,
1227  465, 467, 469, 471, 473, 475, 477, 479, 481, 483,
1228  485, 487, 489, 491, 493, 495, 497, 499, 501, 503,
1229  505, 507, 509, 511, 513, 515, 517, 519, 521, 523,
1230  525, 527, 529, 531, 533, 535, 537, 539, 541, 543,
1231  545, 547, 549, 551, 553, 555, 557, 559, 561, 565,
1232  571, 575, 581, 588, 594, 600, 606, 612, 617, 621,
1233  625, 629, 633, 637, 641, 645, 649, 653, 658, 661,
1234  664, 668, 672, 676, 680, 684, 688, 692, 696, 700,
1235  704, 708, 712, 716, 719, 722, 726, 730, 734, 738,
1236  739, 744, 751, 753, 755, 757, 760, 765, 768, 772,
1237  774, 776, 778, 780, 783, 788, 791, 793, 796, 799,
1238  804, 806, 807, 810, 813, 816, 818, 820, 823, 827,
1239  832, 834, 836, 840, 845, 848, 850, 852, 854, 856,
1240  858, 860, 862, 864, 866, 868, 870, 871, 876, 877,
1241  881, 882, 883, 889, 893, 897, 900, 904, 908, 910,
1242  915, 919, 921, 922, 929, 934, 938, 941, 943, 946,
1243  949, 956, 963, 964, 965, 973, 974, 975, 983, 989,
1244  994, 995, 996, 1006, 1007, 1014, 1015, 1016, 1025, 1026,
1245  1032, 1033, 1040, 1041, 1042, 1052, 1054, 1056, 1058, 1060,
1246  1062, 1064, 1066, 1068, 1070, 1072, 1074, 1076, 1078, 1080,
1247  1082, 1084, 1086, 1088, 1091, 1093, 1095, 1097, 1103, 1105,
1248  1108, 1110, 1112, 1114, 1118, 1120, 1124, 1126, 1131, 1138,
1249  1142, 1148, 1151, 1156, 1158, 1162, 1167, 1170, 1173, 1175,
1250  1178, 1179, 1186, 1195, 1200, 1207, 1212, 1215, 1222, 1225,
1251  1230, 1237, 1240, 1245, 1248, 1253, 1255, 1257, 1259, 1263,
1252  1265, 1270, 1272, 1277, 1279, 1283, 1285, 1287, 1288, 1289,
1253  1290, 1291, 1298, 1303, 1305, 1309, 1313, 1314, 1320, 1323,
1254  1328, 1334, 1340, 1343, 1344, 1350, 1351, 1357, 1361, 1362,
1255  1367, 1368, 1373, 1376, 1378, 1383, 1384, 1390, 1391, 1397,
1256  1403, 1405, 1407, 1414, 1416, 1418, 1420, 1422, 1425, 1427,
1257  1430, 1432, 1434, 1436, 1438, 1440, 1442, 1444, 1447, 1451,
1258  1455, 1459, 1463, 1467, 1468, 1472, 1474, 1477, 1481, 1485,
1259  1486, 1490, 1494, 1498, 1502, 1506, 1507, 1511, 1512, 1516,
1260  1517, 1520, 1521, 1524, 1525, 1528, 1530, 1531, 1535, 1536,
1261  1537, 1538, 1545, 1547, 1549, 1551, 1553, 1556, 1558, 1560,
1262  1562, 1564, 1568, 1570, 1573, 1575, 1577, 1579, 1581, 1583,
1263  1585, 1587, 1589, 1591, 1593, 1595, 1597, 1599, 1601, 1603,
1264  1605, 1607, 1609, 1611, 1613, 1615, 1617, 1619, 1620, 1625,
1265  1628, 1632, 1633, 1637, 1642, 1645, 1648, 1650, 1653, 1654,
1266  1661, 1670, 1675, 1682, 1687, 1694, 1697, 1702, 1709, 1712,
1267  1717, 1720, 1725, 1727, 1728, 1730, 1732, 1734, 1736, 1738,
1268  1740, 1742, 1746, 1748, 1752, 1754, 1757, 1759, 1762, 1764,
1269  1766, 1770, 1772, 1776, 1778, 1780, 1783, 1785, 1789, 1793,
1270  1795, 1799, 1801, 1805, 1807, 1809, 1812, 1814, 1816, 1818,
1271  1821, 1824, 1826, 1828, 1829, 1834, 1836, 1839, 1841, 1845,
1272  1849, 1852, 1855, 1857, 1859, 1861, 1863, 1865, 1867, 1869,
1273  1871, 1873, 1875, 1877, 1879, 1880, 1882, 1883, 1885, 1888,
1274  1891, 1892, 1894, 1896, 1898, 1900, 1902, 1905
1275 };
1276 
1277 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1278 static const yytype_int16 yyrhs[] =
1279 {
1280  145, 0, -1, -1, 146, 147, -1, 148, 340, -1,
1281  347, -1, 149, -1, 148, 346, 149, -1, 1, 149,
1282  -1, 156, -1, -1, 47, 150, 132, 147, 133, -1,
1283  152, 266, 233, 269, -1, 153, 340, -1, 347, -1,
1284  154, -1, 153, 346, 154, -1, 1, 156, -1, 156,
1285  -1, -1, 47, 155, 132, 147, 133, -1, -1, 45,
1286  179, 157, 179, -1, 45, 54, 54, -1, 45, 54,
1287  66, -1, 45, 54, 65, -1, 6, 180, -1, 156,
1288  40, 160, -1, 156, 41, 160, -1, 156, 42, 160,
1289  -1, 156, 43, 160, -1, 156, 44, 156, -1, 48,
1290  132, 152, 133, -1, 158, -1, 167, 115, 161, -1,
1291  302, 89, 161, -1, 218, 134, 190, 343, 89, 161,
1292  -1, 218, 135, 52, 89, 161, -1, 218, 135, 56,
1293  89, 161, -1, 218, 87, 56, 89, 161, -1, 218,
1294  87, 52, 89, 161, -1, 303, 89, 161, -1, 174,
1295  115, 198, -1, 167, 115, 197, -1, 159, -1, 174,
1296  115, 161, -1, 174, 115, 158, -1, 161, -1, 159,
1297  37, 159, -1, 159, 38, 159, -1, 39, 341, 159,
1298  -1, 129, 161, -1, 184, -1, 159, -1, 166, -1,
1299  162, -1, 255, -1, 255, 339, 337, 192, -1, -1,
1300  96, 164, 241, 152, 133, -1, 336, -1, 165, 192,
1301  -1, 165, 192, 163, -1, 218, 135, 337, 192, -1,
1302  218, 135, 337, 192, 163, -1, 218, 87, 337, 192,
1303  -1, 218, 87, 337, 192, 163, -1, 32, 192, -1,
1304  31, 192, -1, 30, 191, -1, 21, 191, -1, 22,
1305  191, -1, 169, -1, 91, 168, 342, -1, 169, -1,
1306  91, 168, 342, -1, 171, -1, 171, 170, -1, 171,
1307  97, 173, -1, 171, 97, 173, 136, 172, -1, 171,
1308  97, -1, 171, 97, 136, 172, -1, 97, 173, -1,
1309  97, 173, 136, 172, -1, 97, -1, 97, 136, 172,
1310  -1, 173, -1, 91, 168, 342, -1, 170, 136, -1,
1311  171, 170, 136, -1, 170, -1, 172, 136, 170, -1,
1312  299, -1, 300, -1, 218, 134, 190, 343, -1, 218,
1313  135, 52, -1, 218, 87, 52, -1, 218, 135, 56,
1314  -1, 218, 87, 56, -1, 88, 56, -1, 303, -1,
1315  299, -1, 300, -1, 218, 134, 190, 343, -1, 218,
1316  135, 52, -1, 218, 87, 52, -1, 218, 135, 56,
1317  -1, 218, 87, 56, -1, 88, 56, -1, 303, -1,
1318  52, -1, 56, -1, 88, 175, -1, 175, -1, 218,
1319  87, 175, -1, 52, -1, 56, -1, 53, -1, 182,
1320  -1, 183, -1, 177, -1, 294, -1, 178, -1, 296,
1321  -1, 179, -1, -1, 180, 136, 181, 179, -1, 120,
1322  -1, 121, -1, 122, -1, 71, -1, 72, -1, 73,
1323  -1, 79, -1, 80, -1, 118, -1, 75, -1, 119,
1324  -1, 76, -1, 74, -1, 85, -1, 86, -1, 123,
1325  -1, 124, -1, 125, -1, 97, -1, 126, -1, 127,
1326  -1, 70, -1, 98, -1, 129, -1, 130, -1, 68,
1327  -1, 69, -1, 83, -1, 84, -1, 137, -1, 49,
1328  -1, 50, -1, 51, -1, 47, -1, 48, -1, 45,
1329  -1, 37, -1, 7, -1, 21, -1, 16, -1, 3,
1330  -1, 5, -1, 46, -1, 26, -1, 15, -1, 14,
1331  -1, 10, -1, 9, -1, 36, -1, 20, -1, 25,
1332  -1, 4, -1, 22, -1, 34, -1, 39, -1, 38,
1333  -1, 23, -1, 8, -1, 24, -1, 30, -1, 33,
1334  -1, 32, -1, 13, -1, 35, -1, 6, -1, 17,
1335  -1, 31, -1, 11, -1, 12, -1, 18, -1, 19,
1336  -1, 174, 115, 184, -1, 174, 115, 184, 44, 184,
1337  -1, 302, 89, 184, -1, 302, 89, 184, 44, 184,
1338  -1, 218, 134, 190, 343, 89, 184, -1, 218, 135,
1339  52, 89, 184, -1, 218, 135, 56, 89, 184, -1,
1340  218, 87, 52, 89, 184, -1, 218, 87, 56, 89,
1341  184, -1, 88, 56, 89, 184, -1, 303, 89, 184,
1342  -1, 184, 81, 184, -1, 184, 82, 184, -1, 184,
1343  123, 184, -1, 184, 124, 184, -1, 184, 125, 184,
1344  -1, 184, 126, 184, -1, 184, 127, 184, -1, 184,
1345  70, 184, -1, 128, 298, 70, 184, -1, 68, 184,
1346  -1, 69, 184, -1, 184, 120, 184, -1, 184, 121,
1347  184, -1, 184, 122, 184, -1, 184, 71, 184, -1,
1348  184, 118, 184, -1, 184, 75, 184, -1, 184, 119,
1349  184, -1, 184, 76, 184, -1, 184, 72, 184, -1,
1350  184, 73, 184, -1, 184, 74, 184, -1, 184, 79,
1351  184, -1, 184, 80, 184, -1, 129, 184, -1, 130,
1352  184, -1, 184, 85, 184, -1, 184, 86, 184, -1,
1353  184, 77, 184, -1, 184, 78, 184, -1, -1, 46,
1354  341, 185, 184, -1, 184, 116, 184, 341, 117, 184,
1355  -1, 199, -1, 184, -1, 347, -1, 196, 344, -1,
1356  196, 136, 334, 344, -1, 334, 344, -1, 138, 190,
1357  342, -1, 347, -1, 188, -1, 347, -1, 191, -1,
1358  196, 136, -1, 196, 136, 334, 136, -1, 334, 136,
1359  -1, 166, -1, 196, 195, -1, 334, 195, -1, 196,
1360  136, 334, 195, -1, 194, -1, -1, 193, 191, -1,
1361  99, 186, -1, 136, 194, -1, 347, -1, 186, -1,
1362  97, 186, -1, 196, 136, 186, -1, 196, 136, 97,
1363  186, -1, 198, -1, 186, -1, 196, 136, 186, -1,
1364  196, 136, 97, 186, -1, 97, 186, -1, 270, -1,
1365  271, -1, 274, -1, 275, -1, 276, -1, 281, -1,
1366  279, -1, 282, -1, 301, -1, 303, -1, 53, -1,
1367  -1, 219, 200, 151, 229, -1, -1, 92, 201, 342,
1368  -1, -1, -1, 92, 202, 159, 203, 342, -1, 91,
1369  152, 139, -1, 218, 87, 56, -1, 88, 56, -1,
1370  94, 187, 140, -1, 95, 333, 133, -1, 30, -1,
1371  31, 138, 191, 342, -1, 31, 138, 342, -1, 31,
1372  -1, -1, 46, 341, 138, 204, 159, 342, -1, 39,
1373  138, 159, 342, -1, 39, 138, 342, -1, 165, 261,
1374  -1, 256, -1, 256, 261, -1, 100, 246, -1, 220,
1375  160, 230, 152, 232, 229, -1, 221, 160, 230, 152,
1376  233, 229, -1, -1, -1, 222, 205, 160, 231, 206,
1377  152, 229, -1, -1, -1, 223, 207, 160, 231, 208,
1378  152, 229, -1, 224, 160, 340, 264, 229, -1, 224,
1379  340, 264, 229, -1, -1, -1, 225, 234, 25, 209,
1380  160, 231, 210, 152, 229, -1, -1, 226, 176, 304,
1381  211, 151, 229, -1, -1, -1, 226, 85, 159, 212,
1382  345, 213, 151, 229, -1, -1, 227, 176, 214, 151,
1383  229, -1, -1, 228, 177, 215, 306, 151, 229, -1,
1384  -1, -1, 228, 331, 339, 216, 177, 217, 306, 151,
1385  229, -1, 21, -1, 22, -1, 23, -1, 24, -1,
1386  199, -1, 7, -1, 11, -1, 12, -1, 18, -1,
1387  19, -1, 16, -1, 20, -1, 3, -1, 4, -1,
1388  5, -1, 10, -1, 345, -1, 13, -1, 345, 13,
1389  -1, 345, -1, 27, -1, 233, -1, 14, 160, 230,
1390  152, 232, -1, 347, -1, 15, 152, -1, 174, -1,
1391  167, -1, 312, -1, 91, 237, 342, -1, 235, -1,
1392  236, 136, 235, -1, 236, -1, 236, 136, 97, 312,
1393  -1, 236, 136, 97, 312, 136, 236, -1, 236, 136,
1394  97, -1, 236, 136, 97, 136, 236, -1, 97, 312,
1395  -1, 97, 312, 136, 236, -1, 97, -1, 97, 136,
1396  236, -1, 318, 136, 321, 330, -1, 318, 330, -1,
1397  321, 330, -1, 329, -1, 136, 238, -1, -1, 314,
1398  136, 324, 136, 327, 239, -1, 314, 136, 324, 136,
1399  327, 136, 314, 239, -1, 314, 136, 324, 239, -1,
1400  314, 136, 324, 136, 314, 239, -1, 314, 136, 327,
1401  239, -1, 314, 136, -1, 314, 136, 327, 136, 314,
1402  239, -1, 314, 239, -1, 324, 136, 327, 239, -1,
1403  324, 136, 327, 136, 314, 239, -1, 324, 239, -1,
1404  324, 136, 314, 239, -1, 327, 239, -1, 327, 136,
1405  314, 239, -1, 238, -1, 347, -1, 242, -1, 120,
1406  243, 120, -1, 78, -1, 120, 240, 243, 120, -1,
1407  341, -1, 341, 141, 244, 341, -1, 245, -1, 244,
1408  136, 245, -1, 52, -1, 311, -1, -1, -1, -1,
1409  -1, 247, 248, 251, 249, 250, 252, -1, 138, 310,
1410  243, 139, -1, 310, -1, 113, 152, 133, -1, 29,
1411  152, 10, -1, -1, 28, 254, 241, 152, 10, -1,
1412  166, 253, -1, 255, 339, 337, 189, -1, 255, 339,
1413  337, 189, 261, -1, 255, 339, 337, 192, 253, -1,
1414  165, 188, -1, -1, 218, 135, 337, 257, 189, -1,
1415  -1, 218, 87, 337, 258, 188, -1, 218, 87, 338,
1416  -1, -1, 218, 135, 259, 188, -1, -1, 218, 87,
1417  260, 188, -1, 32, 188, -1, 32, -1, 218, 134,
1418  190, 343, -1, -1, 132, 262, 241, 152, 133, -1,
1419  -1, 26, 263, 241, 152, 10, -1, 17, 196, 230,
1420  152, 265, -1, 233, -1, 264, -1, 8, 267, 268,
1421  230, 152, 266, -1, 347, -1, 186, -1, 198, -1,
1422  347, -1, 90, 174, -1, 347, -1, 9, 152, -1,
1423  347, -1, 297, -1, 294, -1, 296, -1, 272, -1,
1424  64, -1, 273, -1, 272, 273, -1, 102, 285, 112,
1425  -1, 103, 286, 112, -1, 104, 287, 67, -1, 105,
1426  142, 112, -1, 105, 277, 112, -1, -1, 277, 278,
1427  142, -1, 288, -1, 278, 288, -1, 107, 142, 112,
1428  -1, 107, 280, 112, -1, -1, 280, 278, 142, -1,
1429  106, 142, 112, -1, 106, 283, 112, -1, 108, 142,
1430  112, -1, 108, 284, 112, -1, -1, 283, 63, 142,
1431  -1, -1, 284, 63, 142, -1, -1, 285, 288, -1,
1432  -1, 286, 288, -1, -1, 287, 288, -1, 63, -1,
1433  -1, 111, 289, 293, -1, -1, -1, -1, 109, 290,
1434  291, 292, 152, 110, -1, 54, -1, 55, -1, 57,
1435  -1, 303, -1, 101, 295, -1, 177, -1, 55, -1,
1436  54, -1, 57, -1, 101, 286, 112, -1, 298, -1,
1437  128, 298, -1, 59, -1, 60, -1, 61, -1, 62,
1438  -1, 52, -1, 55, -1, 54, -1, 56, -1, 57,
1439  -1, 34, -1, 33, -1, 35, -1, 36, -1, 50,
1440  -1, 49, -1, 51, -1, 299, -1, 300, -1, 299,
1441  -1, 300, -1, 65, -1, 66, -1, 345, -1, -1,
1442  119, 305, 160, 345, -1, 1, 345, -1, 138, 310,
1443  342, -1, -1, 307, 310, 345, -1, 319, 136, 321,
1444  330, -1, 319, 330, -1, 321, 330, -1, 329, -1,
1445  136, 308, -1, -1, 314, 136, 325, 136, 327, 309,
1446  -1, 314, 136, 325, 136, 327, 136, 314, 309, -1,
1447  314, 136, 325, 309, -1, 314, 136, 325, 136, 314,
1448  309, -1, 314, 136, 327, 309, -1, 314, 136, 327,
1449  136, 314, 309, -1, 314, 309, -1, 325, 136, 327,
1450  309, -1, 325, 136, 327, 136, 314, 309, -1, 325,
1451  309, -1, 325, 136, 314, 309, -1, 327, 309, -1,
1452  327, 136, 314, 309, -1, 308, -1, -1, 56, -1,
1453  55, -1, 54, -1, 57, -1, 311, -1, 52, -1,
1454  312, -1, 91, 237, 342, -1, 313, -1, 314, 136,
1455  313, -1, 58, -1, 315, 186, -1, 315, -1, 315,
1456  218, -1, 315, -1, 317, -1, 318, 136, 317, -1,
1457  316, -1, 319, 136, 316, -1, 70, -1, 98, -1,
1458  320, 52, -1, 320, -1, 312, 115, 186, -1, 312,
1459  115, 218, -1, 323, -1, 324, 136, 323, -1, 322,
1460  -1, 325, 136, 322, -1, 125, -1, 97, -1, 326,
1461  52, -1, 326, -1, 122, -1, 99, -1, 328, 52,
1462  -1, 136, 329, -1, 347, -1, 301, -1, -1, 138,
1463  332, 159, 342, -1, 347, -1, 334, 344, -1, 335,
1464  -1, 334, 136, 335, -1, 186, 90, 186, -1, 58,
1465  186, -1, 98, 186, -1, 52, -1, 56, -1, 53,
1466  -1, 52, -1, 56, -1, 53, -1, 182, -1, 52,
1467  -1, 53, -1, 182, -1, 135, -1, 87, -1, -1,
1468  346, -1, -1, 143, -1, 341, 139, -1, 341, 140,
1469  -1, -1, 143, -1, 136, -1, 141, -1, 143, -1,
1470  345, -1, 346, 141, -1, -1
1471 };
1472 
1473 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1474 static const yytype_uint16 yyrline[] =
1475 {
1476  0, 863, 863, 863, 894, 905, 914, 922, 930, 936,
1477  938, 937, 958, 991, 1002, 1011, 1019, 1027, 1033, 1038,
1478  1037, 1058, 1058, 1066, 1074, 1085, 1095, 1103, 1112, 1121,
1479  1134, 1147, 1156, 1168, 1169, 1179, 1184, 1205, 1210, 1215,
1480  1225, 1230, 1240, 1249, 1258, 1261, 1270, 1282, 1283, 1291,
1481  1299, 1307, 1315, 1318, 1330, 1331, 1334, 1335, 1347, 1346,
1482  1368, 1378, 1387, 1400, 1409, 1421, 1430, 1442, 1451, 1460,
1483  1468, 1476, 1486, 1487, 1497, 1498, 1508, 1516, 1524, 1532,
1484  1541, 1549, 1558, 1566, 1575, 1583, 1594, 1595, 1605, 1613,
1485  1623, 1631, 1641, 1645, 1649, 1657, 1665, 1673, 1681, 1693,
1486  1703, 1715, 1724, 1733, 1741, 1749, 1757, 1765, 1778, 1791,
1487  1802, 1810, 1813, 1821, 1829, 1839, 1840, 1841, 1842, 1847,
1488  1858, 1859, 1862, 1870, 1873, 1881, 1881, 1891, 1892, 1893,
1489  1894, 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1902, 1903,
1490  1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913,
1491  1914, 1915, 1916, 1917, 1918, 1919, 1920, 1923, 1923, 1923,
1492  1924, 1924, 1925, 1925, 1925, 1926, 1926, 1926, 1926, 1927,
1493  1927, 1927, 1927, 1928, 1928, 1928, 1929, 1929, 1929, 1929,
1494  1930, 1930, 1930, 1930, 1931, 1931, 1931, 1931, 1932, 1932,
1495  1932, 1932, 1933, 1933, 1933, 1933, 1934, 1934, 1937, 1946,
1496  1956, 1961, 1971, 1997, 2002, 2007, 2012, 2022, 2032, 2043,
1497  2057, 2071, 2079, 2087, 2095, 2103, 2111, 2119, 2128, 2136,
1498  2144, 2152, 2160, 2168, 2176, 2184, 2192, 2200, 2208, 2216,
1499  2224, 2232, 2243, 2251, 2259, 2267, 2275, 2283, 2291, 2299,
1500  2299, 2309, 2319, 2325, 2337, 2338, 2342, 2350, 2360, 2370,
1501  2371, 2374, 2375, 2376, 2380, 2388, 2398, 2407, 2415, 2425,
1502  2434, 2443, 2443, 2455, 2465, 2469, 2475, 2483, 2491, 2505,
1503  2521, 2522, 2525, 2539, 2554, 2564, 2565, 2566, 2567, 2568,
1504  2569, 2570, 2571, 2572, 2573, 2574, 2583, 2582, 2610, 2610,
1505  2619, 2623, 2618, 2632, 2640, 2648, 2656, 2669, 2677, 2685,
1506  2693, 2701, 2709, 2709, 2719, 2727, 2735, 2745, 2746, 2756,
1507  2760, 2772, 2784, 2784, 2784, 2795, 2795, 2795, 2806, 2817,
1508  2826, 2828, 2825, 2892, 2891, 2913, 2918, 2912, 2937, 2936,
1509  2958, 2957, 2980, 2981, 2980, 3001, 3009, 3017, 3025, 3035,
1510  3047, 3053, 3059, 3065, 3071, 3077, 3083, 3089, 3095, 3101,
1511  3111, 3117, 3122, 3123, 3130, 3135, 3138, 3139, 3152, 3153,
1512  3163, 3164, 3167, 3175, 3185, 3193, 3203, 3211, 3220, 3229,
1513  3237, 3245, 3254, 3266, 3274, 3285, 3289, 3293, 3297, 3303,
1514  3308, 3313, 3317, 3321, 3325, 3329, 3333, 3341, 3345, 3349,
1515  3353, 3357, 3361, 3365, 3369, 3373, 3379, 3380, 3386, 3395,
1516  3404, 3415, 3419, 3429, 3436, 3445, 3453, 3459, 3462, 3467,
1517  3470, 3459, 3489, 3497, 3503, 3507, 3514, 3513, 3534, 3550,
1518  3559, 3571, 3585, 3595, 3594, 3611, 3610, 3626, 3635, 3634,
1519  3652, 3651, 3668, 3676, 3684, 3699, 3698, 3718, 3717, 3738,
1520  3750, 3751, 3754, 3773, 3776, 3784, 3792, 3795, 3799, 3802,
1521  3810, 3813, 3814, 3822, 3825, 3842, 3843, 3844, 3854, 3864,
1522  3891, 3956, 3965, 3976, 3983, 3993, 4001, 4011, 4020, 4031,
1523  4038, 4056, 4065, 4075, 4084, 4095, 4102, 4113, 4120, 4135,
1524  4142, 4153, 4160, 4171, 4178, 4207, 4209, 4208, 4225, 4231,
1525  4236, 4224, 4255, 4263, 4271, 4279, 4282, 4293, 4294, 4295,
1526  4296, 4299, 4310, 4311, 4321, 4322, 4323, 4324, 4327, 4328,
1527  4329, 4330, 4331, 4334, 4335, 4336, 4337, 4338, 4339, 4340,
1528  4343, 4356, 4366, 4374, 4384, 4385, 4388, 4397, 4396, 4405,
1529  4417, 4427, 4427, 4440, 4444, 4448, 4452, 4458, 4463, 4468,
1530  4472, 4476, 4480, 4484, 4488, 4492, 4496, 4500, 4504, 4508,
1531  4512, 4516, 4520, 4525, 4531, 4540, 4549, 4558, 4569, 4570,
1532  4577, 4586, 4605, 4612, 4626, 4633, 4642, 4653, 4662, 4673,
1533  4681, 4698, 4706, 4722, 4723, 4726, 4731, 4737, 4749, 4761,
1534  4769, 4785, 4793, 4809, 4810, 4813, 4826, 4837, 4838, 4841,
1535  4858, 4862, 4872, 4882, 4882, 4911, 4912, 4922, 4929, 4939,
1536  4951, 4959, 4971, 4972, 4973, 4976, 4977, 4978, 4979, 4982,
1537  4983, 4984, 4987, 4992, 4999, 5000, 5003, 5004, 5007, 5010,
1538  5013, 5014, 5015, 5018, 5019, 5022, 5023, 5027
1539 };
1540 #endif
1541 
1542 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1543 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1544  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1545 static const char *const yytname[] =
1546 {
1547  "\"end-of-input\"", "error", "$undefined", "keyword_class",
1548  "keyword_module", "keyword_def", "keyword_undef", "keyword_begin",
1549  "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if",
1550  "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else",
1551  "keyword_case", "keyword_when", "keyword_while", "keyword_until",
1552  "keyword_for", "keyword_break", "keyword_next", "keyword_redo",
1553  "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond",
1554  "keyword_do_block", "keyword_do_LAMBDA", "keyword_return",
1555  "keyword_yield", "keyword_super", "keyword_self", "keyword_nil",
1556  "keyword_true", "keyword_false", "keyword_and", "keyword_or",
1557  "keyword_not", "modifier_if", "modifier_unless", "modifier_while",
1558  "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined",
1559  "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__",
1560  "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR",
1561  "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tRATIONAL",
1562  "tIMAGINARY", "tSTRING_CONTENT", "tCHAR", "tNTH_REF", "tBACK_REF",
1563  "tREGEXP_END", "\"unary+\"", "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"",
1564  "\"===\"", "\"!=\"", "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"",
1565  "\"!~\"", "\"..\"", "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"",
1566  "\"::\"", "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"",
1567  "\"( arg\"", "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"",
1568  "\"**arg\"", "\"&\"", "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG",
1569  "tREGEXP_BEG", "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG",
1570  "tQSYMBOLS_BEG", "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR",
1571  "tSTRING_END", "tLAMBEG", "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'",
1572  "'|'", "'^'", "'&'", "'+'", "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM",
1573  "'!'", "'~'", "tLAST_TOKEN", "'{'", "'}'", "'['", "'.'", "','", "'`'",
1574  "'('", "')'", "']'", "';'", "' '", "'\\n'", "$accept", "program", "$@1",
1575  "top_compstmt", "top_stmts", "top_stmt", "$@2", "bodystmt", "compstmt",
1576  "stmts", "stmt_or_begin", "$@3", "stmt", "$@4", "command_asgn", "expr",
1577  "expr_value", "command_call", "block_command", "cmd_brace_block", "@5",
1578  "fcall", "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item",
1579  "mlhs_head", "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname",
1580  "fsym", "fitem", "undef_list", "$@6", "op", "reswords", "arg", "$@7",
1581  "arg_value", "aref_args", "paren_args", "opt_paren_args",
1582  "opt_call_args", "call_args", "command_args", "@8", "block_arg",
1583  "opt_block_arg", "args", "mrhs_arg", "mrhs", "primary", "@9", "$@10",
1584  "$@11", "$@12", "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "$@19",
1585  "@20", "@21", "@22", "@23", "@24", "$@25", "$@26", "primary_value",
1586  "k_begin", "k_if", "k_unless", "k_while", "k_until", "k_case", "k_for",
1587  "k_class", "k_module", "k_def", "k_end", "then", "do", "if_tail",
1588  "opt_else", "for_var", "f_marg", "f_marg_list", "f_margs",
1589  "block_args_tail", "opt_block_args_tail", "block_param",
1590  "opt_block_param", "block_param_def", "opt_bv_decl", "bv_decls", "bvar",
1591  "lambda", "@27", "@28", "@29", "@30", "f_larglist", "lambda_body",
1592  "do_block", "@31", "block_call", "method_call", "@32", "@33", "@34",
1593  "@35", "brace_block", "@36", "@37", "case_body", "cases", "opt_rescue",
1594  "exc_list", "exc_var", "opt_ensure", "literal", "strings", "string",
1595  "string1", "xstring", "regexp", "words", "word_list", "word", "symbols",
1596  "symbol_list", "qwords", "qsymbols", "qword_list", "qsym_list",
1597  "string_contents", "xstring_contents", "regexp_contents",
1598  "string_content", "@38", "@39", "@40", "@41", "string_dvar", "symbol",
1599  "sym", "dsym", "numeric", "simple_numeric", "user_variable",
1600  "keyword_variable", "var_ref", "var_lhs", "backref", "superclass",
1601  "$@42", "f_arglist", "@43", "args_tail", "opt_args_tail", "f_args",
1602  "f_bad_arg", "f_norm_arg", "f_arg_item", "f_arg", "f_label", "f_kw",
1603  "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest",
1604  "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
1605  "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
1606  "singleton", "$@44", "assoc_list", "assocs", "assoc", "operation",
1607  "operation2", "operation3", "dot_or_colon", "opt_terms", "opt_nl",
1608  "rparen", "rbracket", "trailer", "term", "terms", "none", 0
1609 };
1610 #endif
1611 
1612 # ifdef YYPRINT
1613 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1614  token YYLEX-NUM. */
1615 static const yytype_uint16 yytoknum[] =
1616 {
1617  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1618  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1619  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1620  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1621  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1622  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1623  315, 316, 317, 318, 319, 320, 321, 322, 130, 131,
1624  132, 134, 139, 140, 141, 138, 137, 323, 324, 142,
1625  143, 128, 129, 144, 145, 135, 136, 325, 326, 327,
1626  328, 329, 330, 331, 332, 333, 334, 335, 336, 337,
1627  338, 339, 340, 341, 342, 343, 344, 345, 346, 347,
1628  348, 349, 350, 351, 352, 61, 63, 58, 62, 60,
1629  124, 94, 38, 43, 45, 42, 47, 37, 353, 33,
1630  126, 354, 123, 125, 91, 46, 44, 96, 40, 41,
1631  93, 59, 32, 10
1632 };
1633 # endif
1634 
1635 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1636 static const yytype_uint16 yyr1[] =
1637 {
1638  0, 144, 146, 145, 147, 148, 148, 148, 148, 149,
1639  150, 149, 151, 152, 153, 153, 153, 153, 154, 155,
1640  154, 157, 156, 156, 156, 156, 156, 156, 156, 156,
1641  156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
1642  156, 156, 156, 156, 156, 158, 158, 159, 159, 159,
1643  159, 159, 159, 160, 161, 161, 162, 162, 164, 163,
1644  165, 166, 166, 166, 166, 166, 166, 166, 166, 166,
1645  166, 166, 167, 167, 168, 168, 169, 169, 169, 169,
1646  169, 169, 169, 169, 169, 169, 170, 170, 171, 171,
1647  172, 172, 173, 173, 173, 173, 173, 173, 173, 173,
1648  173, 174, 174, 174, 174, 174, 174, 174, 174, 174,
1649  175, 175, 176, 176, 176, 177, 177, 177, 177, 177,
1650  178, 178, 179, 179, 180, 181, 180, 182, 182, 182,
1651  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1652  182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1653  182, 182, 182, 182, 182, 182, 182, 183, 183, 183,
1654  183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
1655  183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
1656  183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
1657  183, 183, 183, 183, 183, 183, 183, 183, 184, 184,
1658  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1659  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1660  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
1661  184, 184, 184, 184, 184, 184, 184, 184, 184, 185,
1662  184, 184, 184, 186, 187, 187, 187, 187, 188, 189,
1663  189, 190, 190, 190, 190, 190, 191, 191, 191, 191,
1664  191, 193, 192, 194, 195, 195, 196, 196, 196, 196,
1665  197, 197, 198, 198, 198, 199, 199, 199, 199, 199,
1666  199, 199, 199, 199, 199, 199, 200, 199, 201, 199,
1667  202, 203, 199, 199, 199, 199, 199, 199, 199, 199,
1668  199, 199, 204, 199, 199, 199, 199, 199, 199, 199,
1669  199, 199, 205, 206, 199, 207, 208, 199, 199, 199,
1670  209, 210, 199, 211, 199, 212, 213, 199, 214, 199,
1671  215, 199, 216, 217, 199, 199, 199, 199, 199, 218,
1672  219, 220, 221, 222, 223, 224, 225, 226, 227, 228,
1673  229, 230, 230, 230, 231, 231, 232, 232, 233, 233,
1674  234, 234, 235, 235, 236, 236, 237, 237, 237, 237,
1675  237, 237, 237, 237, 237, 238, 238, 238, 238, 239,
1676  239, 240, 240, 240, 240, 240, 240, 240, 240, 240,
1677  240, 240, 240, 240, 240, 240, 241, 241, 242, 242,
1678  242, 243, 243, 244, 244, 245, 245, 247, 248, 249,
1679  250, 246, 251, 251, 252, 252, 254, 253, 255, 255,
1680  255, 255, 256, 257, 256, 258, 256, 256, 259, 256,
1681  260, 256, 256, 256, 256, 262, 261, 263, 261, 264,
1682  265, 265, 266, 266, 267, 267, 267, 268, 268, 269,
1683  269, 270, 270, 270, 271, 272, 272, 272, 273, 274,
1684  275, 276, 276, 277, 277, 278, 278, 279, 279, 280,
1685  280, 281, 281, 282, 282, 283, 283, 284, 284, 285,
1686  285, 286, 286, 287, 287, 288, 289, 288, 290, 291,
1687  292, 288, 293, 293, 293, 293, 294, 295, 295, 295,
1688  295, 296, 297, 297, 298, 298, 298, 298, 299, 299,
1689  299, 299, 299, 300, 300, 300, 300, 300, 300, 300,
1690  301, 301, 302, 302, 303, 303, 304, 305, 304, 304,
1691  306, 307, 306, 308, 308, 308, 308, 309, 309, 310,
1692  310, 310, 310, 310, 310, 310, 310, 310, 310, 310,
1693  310, 310, 310, 310, 311, 311, 311, 311, 312, 312,
1694  313, 313, 314, 314, 315, 316, 316, 317, 317, 318,
1695  318, 319, 319, 320, 320, 321, 321, 322, 323, 324,
1696  324, 325, 325, 326, 326, 327, 327, 328, 328, 329,
1697  330, 330, 331, 332, 331, 333, 333, 334, 334, 335,
1698  335, 335, 336, 336, 336, 337, 337, 337, 337, 338,
1699  338, 338, 339, 339, 340, 340, 341, 341, 342, 343,
1700  344, 344, 344, 345, 345, 346, 346, 347
1701 };
1702 
1703 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1704 static const yytype_uint8 yyr2[] =
1705 {
1706  0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
1707  0, 5, 4, 2, 1, 1, 3, 2, 1, 0,
1708  5, 0, 4, 3, 3, 3, 2, 3, 3, 3,
1709  3, 3, 4, 1, 3, 3, 6, 5, 5, 5,
1710  5, 3, 3, 3, 1, 3, 3, 1, 3, 3,
1711  3, 2, 1, 1, 1, 1, 1, 4, 0, 5,
1712  1, 2, 3, 4, 5, 4, 5, 2, 2, 2,
1713  2, 2, 1, 3, 1, 3, 1, 2, 3, 5,
1714  2, 4, 2, 4, 1, 3, 1, 3, 2, 3,
1715  1, 3, 1, 1, 4, 3, 3, 3, 3, 2,
1716  1, 1, 1, 4, 3, 3, 3, 3, 2, 1,
1717  1, 1, 2, 1, 3, 1, 1, 1, 1, 1,
1718  1, 1, 1, 1, 1, 0, 4, 1, 1, 1,
1719  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1720  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1721  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1722  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1723  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1724  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1725  1, 1, 1, 1, 1, 1, 1, 1, 3, 5,
1726  3, 5, 6, 5, 5, 5, 5, 4, 3, 3,
1727  3, 3, 3, 3, 3, 3, 3, 4, 2, 2,
1728  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1729  3, 3, 3, 2, 2, 3, 3, 3, 3, 0,
1730  4, 6, 1, 1, 1, 2, 4, 2, 3, 1,
1731  1, 1, 1, 2, 4, 2, 1, 2, 2, 4,
1732  1, 0, 2, 2, 2, 1, 1, 2, 3, 4,
1733  1, 1, 3, 4, 2, 1, 1, 1, 1, 1,
1734  1, 1, 1, 1, 1, 1, 0, 4, 0, 3,
1735  0, 0, 5, 3, 3, 2, 3, 3, 1, 4,
1736  3, 1, 0, 6, 4, 3, 2, 1, 2, 2,
1737  6, 6, 0, 0, 7, 0, 0, 7, 5, 4,
1738  0, 0, 9, 0, 6, 0, 0, 8, 0, 5,
1739  0, 6, 0, 0, 9, 1, 1, 1, 1, 1,
1740  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1741  1, 1, 1, 2, 1, 1, 1, 5, 1, 2,
1742  1, 1, 1, 3, 1, 3, 1, 4, 6, 3,
1743  5, 2, 4, 1, 3, 4, 2, 2, 1, 2,
1744  0, 6, 8, 4, 6, 4, 2, 6, 2, 4,
1745  6, 2, 4, 2, 4, 1, 1, 1, 3, 1,
1746  4, 1, 4, 1, 3, 1, 1, 0, 0, 0,
1747  0, 6, 4, 1, 3, 3, 0, 5, 2, 4,
1748  5, 5, 2, 0, 5, 0, 5, 3, 0, 4,
1749  0, 4, 2, 1, 4, 0, 5, 0, 5, 5,
1750  1, 1, 6, 1, 1, 1, 1, 2, 1, 2,
1751  1, 1, 1, 1, 1, 1, 1, 2, 3, 3,
1752  3, 3, 3, 0, 3, 1, 2, 3, 3, 0,
1753  3, 3, 3, 3, 3, 0, 3, 0, 3, 0,
1754  2, 0, 2, 0, 2, 1, 0, 3, 0, 0,
1755  0, 6, 1, 1, 1, 1, 2, 1, 1, 1,
1756  1, 3, 1, 2, 1, 1, 1, 1, 1, 1,
1757  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1758  1, 1, 1, 1, 1, 1, 1, 0, 4, 2,
1759  3, 0, 3, 4, 2, 2, 1, 2, 0, 6,
1760  8, 4, 6, 4, 6, 2, 4, 6, 2, 4,
1761  2, 4, 1, 0, 1, 1, 1, 1, 1, 1,
1762  1, 3, 1, 3, 1, 2, 1, 2, 1, 1,
1763  3, 1, 3, 1, 1, 2, 1, 3, 3, 1,
1764  3, 1, 3, 1, 1, 2, 1, 1, 1, 2,
1765  2, 1, 1, 0, 4, 1, 2, 1, 3, 3,
1766  2, 2, 1, 1, 1, 1, 1, 1, 1, 1,
1767  1, 1, 1, 1, 0, 1, 0, 1, 2, 2,
1768  0, 1, 1, 1, 1, 1, 2, 0
1769 };
1770 
1771 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
1772  Performed when YYTABLE doesn't specify something else to do. Zero
1773  means the default is an error. */
1774 static const yytype_uint16 yydefact[] =
1775 {
1776  2, 0, 0, 1, 0, 347, 348, 349, 0, 340,
1777  341, 342, 345, 343, 344, 346, 335, 336, 337, 338,
1778  298, 261, 261, 514, 513, 515, 516, 616, 0, 616,
1779  10, 0, 518, 517, 519, 602, 604, 510, 509, 603,
1780  512, 504, 505, 506, 507, 455, 524, 525, 0, 0,
1781  0, 0, 290, 627, 627, 84, 407, 481, 479, 481,
1782  483, 463, 475, 469, 477, 0, 0, 0, 3, 614,
1783  6, 9, 33, 44, 47, 55, 261, 54, 0, 72,
1784  0, 76, 86, 0, 52, 242, 0, 286, 0, 0,
1785  312, 315, 614, 0, 0, 0, 0, 56, 307, 275,
1786  276, 454, 456, 277, 278, 279, 281, 280, 282, 452,
1787  453, 451, 502, 520, 521, 283, 0, 284, 60, 5,
1788  8, 167, 178, 168, 191, 164, 184, 174, 173, 194,
1789  195, 189, 172, 171, 166, 192, 196, 197, 176, 165,
1790  179, 183, 185, 177, 170, 186, 193, 188, 187, 180,
1791  190, 175, 163, 182, 181, 162, 169, 160, 161, 157,
1792  158, 159, 115, 117, 116, 152, 153, 148, 130, 131,
1793  132, 139, 136, 138, 133, 134, 154, 155, 140, 141,
1794  145, 149, 135, 137, 127, 128, 129, 142, 143, 144,
1795  146, 147, 150, 151, 156, 120, 122, 124, 26, 118,
1796  119, 121, 123, 0, 0, 0, 0, 0, 0, 0,
1797  0, 256, 0, 243, 266, 70, 260, 627, 0, 520,
1798  521, 0, 284, 627, 597, 71, 69, 616, 68, 0,
1799  627, 432, 67, 616, 617, 0, 0, 21, 239, 0,
1800  0, 335, 336, 298, 301, 433, 0, 218, 0, 219,
1801  295, 0, 19, 0, 0, 614, 15, 18, 616, 74,
1802  14, 616, 0, 0, 620, 620, 244, 0, 0, 620,
1803  595, 616, 0, 0, 0, 82, 339, 0, 92, 93,
1804  100, 309, 408, 499, 498, 500, 497, 0, 496, 0,
1805  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1806  503, 51, 233, 234, 623, 624, 4, 625, 615, 0,
1807  0, 0, 0, 0, 0, 0, 437, 435, 422, 61,
1808  306, 416, 418, 0, 88, 0, 80, 77, 0, 0,
1809  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1810  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1811  0, 0, 0, 0, 0, 430, 627, 428, 0, 53,
1812  0, 0, 0, 0, 614, 0, 615, 0, 361, 360,
1813  0, 0, 520, 521, 284, 110, 111, 0, 0, 113,
1814  0, 0, 520, 521, 284, 328, 187, 180, 190, 175,
1815  157, 158, 159, 115, 116, 593, 330, 592, 0, 613,
1816  612, 0, 308, 457, 0, 0, 125, 600, 295, 267,
1817  601, 263, 0, 0, 0, 257, 265, 430, 627, 428,
1818  0, 0, 0, 258, 616, 0, 300, 262, 616, 252,
1819  627, 627, 251, 616, 305, 50, 23, 25, 24, 0,
1820  302, 0, 0, 0, 430, 428, 0, 17, 0, 616,
1821  293, 13, 615, 73, 289, 291, 296, 622, 621, 245,
1822  622, 247, 297, 596, 0, 99, 503, 90, 85, 0,
1823  430, 627, 428, 553, 485, 488, 486, 501, 482, 458,
1824  480, 459, 460, 484, 461, 462, 0, 465, 471, 0,
1825  472, 467, 468, 0, 473, 0, 474, 0, 626, 7,
1826  27, 28, 29, 30, 31, 48, 49, 627, 627, 58,
1827  62, 627, 0, 34, 271, 0, 43, 270, 616, 0,
1828  78, 89, 46, 45, 0, 198, 266, 42, 216, 223,
1829  228, 229, 230, 225, 227, 237, 238, 231, 232, 209,
1830  210, 235, 236, 616, 224, 226, 220, 221, 222, 211,
1831  212, 213, 214, 215, 605, 607, 606, 608, 0, 261,
1832  427, 616, 605, 607, 606, 608, 0, 261, 0, 627,
1833  352, 0, 351, 0, 0, 0, 0, 0, 0, 295,
1834  430, 627, 428, 320, 325, 110, 111, 112, 0, 527,
1835  323, 526, 430, 627, 428, 0, 0, 531, 332, 605,
1836  606, 261, 35, 200, 41, 208, 0, 198, 599, 0,
1837  268, 264, 627, 605, 606, 616, 605, 606, 598, 299,
1838  618, 248, 253, 255, 304, 22, 0, 240, 0, 32,
1839  425, 423, 207, 0, 75, 16, 616, 620, 0, 83,
1840  96, 98, 616, 605, 606, 559, 556, 555, 554, 557,
1841  564, 573, 0, 584, 574, 588, 587, 583, 553, 409,
1842  552, 413, 558, 560, 562, 538, 566, 571, 627, 576,
1843  627, 581, 538, 586, 538, 0, 536, 489, 0, 464,
1844  466, 476, 470, 478, 217, 399, 616, 0, 397, 396,
1845  0, 627, 0, 274, 0, 87, 81, 0, 0, 0,
1846  0, 0, 0, 431, 65, 0, 0, 434, 0, 0,
1847  429, 63, 627, 350, 287, 627, 627, 443, 627, 353,
1848  627, 355, 313, 354, 316, 0, 0, 319, 609, 294,
1849  616, 605, 606, 0, 0, 529, 0, 0, 110, 111,
1850  114, 616, 0, 616, 553, 0, 553, 0, 250, 419,
1851  57, 249, 0, 126, 269, 259, 0, 0, 434, 0,
1852  0, 627, 616, 11, 0, 292, 246, 91, 94, 0,
1853  373, 364, 366, 616, 362, 616, 410, 0, 0, 545,
1854  565, 0, 534, 591, 575, 0, 535, 0, 548, 585,
1855  0, 550, 589, 490, 492, 493, 494, 487, 495, 395,
1856  616, 0, 560, 380, 568, 569, 627, 627, 579, 380,
1857  380, 378, 401, 0, 0, 0, 0, 0, 272, 79,
1858  199, 0, 40, 205, 39, 206, 66, 426, 619, 0,
1859  37, 203, 38, 204, 64, 424, 444, 445, 627, 446,
1860  0, 627, 358, 0, 0, 356, 0, 0, 0, 318,
1861  0, 0, 434, 0, 326, 0, 0, 434, 329, 594,
1862  616, 0, 0, 333, 420, 421, 201, 0, 254, 303,
1863  20, 616, 0, 371, 0, 561, 0, 0, 577, 537,
1864  563, 538, 538, 572, 627, 590, 538, 582, 538, 560,
1865  538, 0, 0, 398, 0, 386, 388, 0, 567, 0,
1866  376, 377, 0, 391, 0, 393, 0, 438, 436, 0,
1867  417, 273, 241, 36, 202, 0, 0, 448, 359, 0,
1868  12, 450, 0, 310, 311, 0, 0, 268, 627, 321,
1869  0, 528, 324, 530, 331, 532, 531, 363, 374, 0,
1870  369, 365, 412, 0, 0, 411, 0, 541, 0, 543,
1871  533, 0, 549, 0, 546, 551, 0, 400, 578, 379,
1872  380, 380, 295, 430, 570, 627, 380, 580, 380, 380,
1873  405, 616, 403, 406, 59, 0, 447, 0, 101, 102,
1874  109, 0, 449, 0, 314, 317, 440, 441, 439, 0,
1875  0, 0, 0, 372, 0, 367, 0, 0, 538, 538,
1876  538, 538, 491, 0, 383, 0, 385, 609, 294, 375,
1877  0, 392, 0, 389, 394, 0, 402, 108, 430, 627,
1878  428, 627, 627, 0, 327, 0, 370, 0, 415, 414,
1879  542, 0, 539, 544, 547, 380, 380, 380, 380, 404,
1880  609, 107, 616, 605, 606, 442, 357, 322, 334, 368,
1881  538, 384, 0, 381, 387, 390, 434, 540, 380, 382
1882 };
1883 
1884 /* YYDEFGOTO[NTERM-NUM]. */
1885 static const yytype_int16 yydefgoto[] =
1886 {
1887  -1, 1, 2, 68, 69, 70, 239, 568, 569, 255,
1888  256, 448, 257, 439, 72, 73, 360, 74, 75, 510,
1889  691, 246, 77, 78, 258, 79, 80, 81, 468, 82,
1890  212, 379, 380, 195, 196, 197, 198, 606, 557, 200,
1891  84, 441, 214, 263, 231, 749, 428, 429, 228, 229,
1892  216, 415, 430, 516, 517, 85, 358, 261, 262, 636,
1893  626, 362, 847, 363, 848, 733, 989, 737, 734, 930,
1894  595, 597, 747, 936, 248, 87, 88, 89, 90, 91,
1895  92, 93, 94, 95, 96, 714, 571, 722, 844, 845,
1896  371, 771, 772, 773, 959, 896, 800, 687, 688, 801,
1897  971, 972, 281, 282, 473, 776, 877, 659, 945, 322,
1898  511, 97, 98, 712, 705, 566, 558, 320, 508, 507,
1899  578, 988, 716, 838, 916, 920, 99, 100, 101, 102,
1900  103, 104, 105, 293, 486, 106, 297, 107, 108, 295,
1901  299, 289, 287, 291, 478, 678, 677, 793, 891, 797,
1902  109, 288, 110, 111, 112, 219, 220, 115, 221, 222,
1903  590, 736, 745, 746, 879, 779, 661, 662, 889, 664,
1904  665, 666, 667, 805, 806, 668, 669, 670, 671, 808,
1905  809, 672, 673, 674, 675, 676, 782, 398, 596, 268,
1906  431, 224, 118, 630, 560, 401, 306, 425, 426, 707,
1907  459, 572, 366, 260
1908 };
1909 
1910 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1911  STATE-NUM. */
1912 #define YYPACT_NINF -813
1913 static const yytype_int16 yypact[] =
1914 {
1915  -813, 111, 2847, -813, 7396, -813, -813, -813, 6911, -813,
1916  -813, -813, -813, -813, -813, -813, 7511, 7511, -813, -813,
1917  7511, 4052, 3641, -813, -813, -813, -813, -21, 6776, -35,
1918  -813, -12, -813, -813, -813, 2956, 3778, -813, -813, 3093,
1919  -813, -813, -813, -813, -813, -813, -813, -813, 8891, 8891,
1920  72, 5120, 30, 7856, 8201, 7174, -813, 6641, -813, -813,
1921  -813, 41, 84, 95, 136, 1005, 9006, 8891, -813, 230,
1922  -813, 1060, -813, 324, -813, -813, 142, 104, 168, -813,
1923  192, 9236, -813, 201, 3209, 40, 271, -813, 9121, 9121,
1924  -813, -813, 6021, 9347, 9458, 9569, 6505, 22, 97, -813,
1925  -813, 56, -813, -813, -813, -813, -813, -813, -813, -813,
1926  -813, -813, -813, 27, 472, -813, 243, 651, -813, -813,
1927  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1928  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1929  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1930  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1931  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1932  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1933  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1934  -813, -813, -813, -813, -813, -813, -813, -813, 207, -813,
1935  -813, -813, -813, 219, 8891, 330, 5261, 8891, 8891, 8891,
1936  8891, -813, 285, 3209, 343, -813, -813, 278, 301, 14,
1937  233, 348, 244, 284, -813, -813, -813, 5906, -813, 7511,
1938  7511, -813, -813, 6136, -813, 9121, 775, -813, 314, 354,
1939  5402, -813, -813, -813, 342, 364, 142, -813, 435, 422,
1940  687, 7626, -813, 5120, 369, 230, -813, 1060, -35, 408,
1941  -813, -35, 9121, 403, 329, 331, -813, 343, 420, 331,
1942  -813, -35, 510, 1005, 9680, 432, -813, 520, 565, 590,
1943  604, -813, -813, -813, -813, -813, -813, 502, -813, 513,
1944  523, 416, 465, 658, 469, 33, 476, 685, 488, 44,
1945  514, -813, -813, -813, -813, -813, -813, -813, 6251, 9121,
1946  9121, 9121, 9121, 7626, 9121, 9121, -813, -813, -813, 522,
1947  -813, -813, -813, 8316, -813, 5120, 7285, 528, 8316, 8891,
1948  8891, 8891, 8891, 8891, 8891, 8891, 8891, 8891, 8891, 8891,
1949  8891, 8891, 8891, 8891, 8891, 8891, 8891, 8891, 8891, 8891,
1950  8891, 8891, 8891, 8891, 8891, 9963, 7511, 10042, 4467, 324,
1951  112, 112, 9121, 9121, 230, 642, 530, 618, -813, -813,
1952  620, 655, 94, 108, 121, 312, 495, 9121, 139, -813,
1953  212, 644, -813, -813, -813, -813, 26, 292, 384, 458,
1954  467, 532, 562, 570, 582, -813, -813, -813, 22, -813,
1955  -813, 10121, -813, -813, 9006, 9006, -813, -813, 286, -813,
1956  -813, -813, 8891, 8891, 7741, -813, -813, 10200, 7511, 10279,
1957  8891, 8891, 7971, -813, -35, 544, -813, -813, -35, -813,
1958  550, 551, -813, 93, -813, -813, -813, -813, -813, 6911,
1959  -813, 8891, 5535, 576, 10200, 10279, 8891, 1060, 558, -35,
1960  -813, -813, 6366, 559, -813, 324, -813, 8086, -813, -813,
1961  8201, -813, -813, -813, 314, 648, -813, -813, 597, 9680,
1962  10358, 7511, 10437, 1164, -813, -813, -813, -813, -813, -813,
1963  -813, -813, -813, -813, -813, -813, 346, -813, -813, 556,
1964  -813, -813, -813, 347, -813, 584, -813, 8891, -813, -813,
1965  -813, -813, -813, -813, -813, -813, -813, 19, 19, -813,
1966  -813, 19, 8891, -813, 607, 608, -813, -813, -35, 9680,
1967  610, -813, -813, -813, 636, 2008, -813, -813, 422, 2309,
1968  2309, 2309, 2309, 1315, 1315, 2621, 1681, 2309, 2309, 3346,
1969  3346, 425, 425, 10940, 1315, 1315, 795, 795, 887, 337,
1970  337, 422, 422, 422, 4189, 3230, 4326, 3367, 364, 623,
1971  -813, -35, 688, -813, 706, -813, 364, 3915, 755, 763,
1972  -813, 4608, 771, 4890, 65, 65, 642, 8431, 755, 135,
1973  10516, 7511, 10595, -813, 324, -813, 648, -813, 230, -813,
1974  -813, -813, 10674, 7511, 10121, 4467, 9121, 647, -813, -813,
1975  -813, 1256, -813, 2935, -813, 3209, 6911, 3072, -813, 8891,
1976  343, -813, 284, 2529, 3504, -35, 381, 526, -813, -813,
1977  -813, -813, 7741, 7971, -813, -813, 9121, 3209, 657, -813,
1978  -813, -813, 3209, 5535, 262, -813, -35, 331, 9680, 597,
1979  505, 394, -35, 276, 351, -813, -813, -813, -813, -813,
1980  -813, -813, 950, -813, -813, -813, -813, -813, 1220, -813,
1981  -813, -813, -813, 678, -813, 674, 8891, -813, 676, 768,
1982  692, -813, 701, 786, 707, 800, -813, -813, 885, -813,
1983  -813, -813, -813, -813, 422, -813, 1115, 5676, -813, -813,
1984  5402, 19, 5676, 718, 8546, -813, 597, 9680, 9006, 8891,
1985  739, 9006, 9006, -813, 522, 364, 721, 717, 9006, 9006,
1986  -813, 522, 364, -813, -813, 8661, 842, -813, 664, -813,
1987  842, -813, -813, -813, -813, 755, 71, -813, 66, 80,
1988  -35, 141, 162, 9121, 230, -813, 9121, 4467, 505, 394,
1989  -813, -35, 755, 93, 1220, 4467, 1220, 7046, -813, 97,
1990  104, -813, 8891, -813, -813, -813, 8891, 8891, 557, 8891,
1991  8891, 728, 93, -813, 733, -813, -813, -813, 366, 950,
1992  459, -813, 732, -35, -813, -35, -813, 8891, 1220, -813,
1993  -813, 586, -813, -813, -813, 42, -813, 1220, -813, -813,
1994  1307, -813, -813, -813, -813, -813, -813, -813, -813, -813,
1995  -35, 751, 757, 737, 9791, -813, 740, 692, -813, 742,
1996  747, -813, 734, 877, 758, 5402, 878, 8891, 761, 597,
1997  3209, 8891, -813, 3209, -813, 3209, -813, -813, -813, 9006,
1998  -813, 3209, -813, 3209, -813, -813, 607, -813, 804, -813,
1999  5005, 890, -813, 9121, 755, -813, 755, 5676, 5676, -813,
2000  8776, 4749, 288, 65, -813, 230, 755, -813, -813, -813,
2001  -35, 755, 230, -813, -813, -813, 3209, 8891, 7971, -813,
2002  -813, -35, 873, 769, 1000, -813, 765, 73, -813, -813,
2003  -813, 772, 773, -813, 692, -813, 776, -813, 777, -813,
2004  776, 5791, 787, -813, 9791, 1220, -813, 855, 673, 586,
2005  -813, -813, 1220, -813, 1307, -813, 1016, -813, -813, 783,
2006  -813, 788, 3209, -813, 3209, 9902, 112, -813, -813, 5676,
2007  -813, -813, 112, -813, -813, 755, 755, -813, 542, -813,
2008  4467, -813, -813, -813, -813, -813, 647, -813, 796, 873,
2009  484, -813, -813, 5676, 5402, -813, 1220, -813, 1307, -813,
2010  -813, 1307, -813, 1307, -813, -813, 813, -813, 673, -813,
2011  799, 801, -813, 10753, -813, 692, 802, -813, 808, 802,
2012  -813, 367, -813, -813, -813, 875, -813, 681, 565, 590,
2013  604, 4467, -813, 4608, -813, -813, -813, -813, -813, 5676,
2014  755, 4467, 873, 796, 873, 811, 923, 815, 776, 817,
2015  776, 776, -813, 1220, -813, 1307, -813, 818, 820, -813,
2016  1307, -813, 1307, -813, -813, 1016, -813, 648, 10832, 7511,
2017  10911, 763, 664, 755, -813, 755, 796, 873, -813, -813,
2018  -813, 1307, -813, -813, -813, 802, 819, 802, 802, -813,
2019  169, 394, -35, 127, 146, -813, -813, -813, -813, 796,
2020  776, -813, 1307, -813, -813, -813, 180, -813, 802, -813
2021 };
2022 
2023 /* YYPGOTO[NTERM-NUM]. */
2024 static const yytype_int16 yypgoto[] =
2025 {
2026  -813, -813, -813, -361, -813, 29, -813, -540, -29, -813,
2027  515, -813, 43, -813, -301, -63, -71, 21, -813, -174,
2028  -813, 797, -10, 869, -158, 16, -76, -813, -395, 8,
2029  1783, -325, 870, -53, -813, -5, -813, -813, 3, -813,
2030  1127, -813, -19, -813, -67, 257, -317, 118, -3, -813,
2031  -390, -181, -4, -813, -313, -15, -813, -813, -813, -813,
2032  -813, -813, -813, -813, -813, -813, -813, -813, -813, -813,
2033  -813, -813, -813, -813, 55, -813, -813, -813, -813, -813,
2034  -813, -813, -813, -813, -813, -541, -344, -527, -45, -631,
2035  -813, -770, -784, 210, 290, 172, -813, -425, -813, -663,
2036  -813, -31, -813, -813, -813, -813, -813, -813, -813, 236,
2037  -813, -813, -813, -813, -813, -813, -813, -96, -813, -813,
2038  -556, -813, -34, -813, -813, -813, -813, -813, -813, 889,
2039  -813, -813, -813, -813, 691, -813, -813, -813, -813, -813,
2040  -813, -813, 933, -813, -97, -813, -813, -813, -813, -813,
2041  0, -813, 6, -813, -11, 1321, 1524, 897, 1945, 1604,
2042  -813, -813, 58, -813, -404, -154, -323, -812, 123, -717,
2043  87, 76, 215, 101, -813, -813, -813, -69, -711, -629,
2044  106, 237, -813, -616, -813, -44, -626, -813, -813, -813,
2045  98, -392, -813, -319, -813, 624, -46, -26, -168, -565,
2046  -207, -28, -13, -2
2047 };
2048 
2049 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2050  positive, shift that token. If negative, reduce the rule which
2051  number is the opposite. If YYTABLE_NINF, syntax error. */
2052 #define YYTABLE_NINF -628
2053 static const yytype_int16 yytable[] =
2054 {
2055  119, 235, 402, 238, 286, 327, 211, 211, 201, 318,
2056  211, 199, 217, 217, 202, 527, 217, 573, 361, 232,
2057  725, 364, 254, 237, 611, 359, 359, 522, 201, 359,
2058  618, 199, 611, 120, 202, 267, 559, 727, 567, 561,
2059  276, 307, 423, 396, 786, 71, 365, 71, 724, 264,
2060  758, 266, 270, 587, 300, 742, 308, 86, 461, 86,
2061  199, 880, 463, 275, 307, 434, 276, 259, 618, 660,
2062  810, 218, 218, 319, 639, 218, 887, 768, 276, 276,
2063  276, 628, 601, 690, 570, 841, 692, 301, 938, 846,
2064  453, -105, 721, 454, 973, 449, 489, 685, 559, 199,
2065  567, 615, 943, -522, 941, -107, 86, 495, 234, 399,
2066  277, 3, 876, -514, 223, 223, -522, 233, 223, -101,
2067  240, 218, 234, 316, 696, 570, 631, -339, 250, -101,
2068  314, 315, 321, -102, 215, 225, 277, 892, 226, 686,
2069  -104, 655, -101, 218, 218, 490, -109, 218, 370, 381,
2070  381, 265, 269, 631, 642, 993, 496, 400, 58, -106,
2071  -108, -514, 882, -92, 656, 852, -104, 518, 316, -288,
2072  433, 888, 435, -288, -339, -339, 857, 254, 880, 318,
2073  900, 901, -105, 292, 849, 407, 944, -106, 409, 410,
2074  411, 585, 480, -103, 483, 586, 487, 856, 467, 455,
2075  487, 858, -96, 973, -605, 861, 304, 850, 305, 451,
2076  1026, 443, 304, 588, 305, 416, -98, 211, -606, 211,
2077  211, 416, 941, 217, 254, 217, 294, 307, 432, 317,
2078  -92, 618, 611, 611, 880, 887, 234, 296, 500, 501,
2079  502, 503, 452, 1049, -93, 464, 359, 359, 359, 359,
2080  423, 505, 506, 304, 660, 305, 619, -100, 950, 276,
2081  621, 86, 466, 631, 730, 624, 815, 740, -104, 259,
2082  -104, -99, 764, 967, 317, 631, 741, -95, 298, 961,
2083  230, 634, 218, 323, 218, 218, 968, -106, 218, -106,
2084  218, 574, 575, 880, 447, 86, 254, 986, -97, 359,
2085  359, -95, 819, 923, 514, 924, 86, -605, 86, 526,
2086  -105, 276, -105, -103, 584, 932, 328, 218, 576, 515,
2087  934, -103, -523, -103, 515, 223, 929, 223, 324, 277,
2088  999, 589, 404, 421, 520, 775, 307, 499, -602, 1009,
2089  660, 259, 660, 406, 513, 424, 211, 427, -102, 523,
2090  695, 71, 591, 304, 432, 305, 504, 233, 355, -109,
2091  565, 314, 315, 86, 218, 218, 218, 218, 86, 218,
2092  218, 304, 987, 305, 967, 446, -97, -73, 218, -513,
2093  86, 277, 851, 218, 984, 985, 408, 1036, 417, 680,
2094  990, -95, -434, 467, 608, 610, 680, 522, -87, -508,
2095  412, -108, 837, 267, 565, 356, 357, 329, 211, 474,
2096  474, 218, -95, 86, 414, -95, 432, 218, 218, -95,
2097  422, 860, 565, 862, -94, 602, 604, -513, 416, 416,
2098  766, 755, 218, 413, 625, 418, 419, 420, 610, 201,
2099  119, 267, 199, 467, -602, 202, -508, -508, 565, 1024,
2100  -602, 1025, 440, -434, 276, 475, 475, 476, 476, 218,
2101  218, 211, 352, 353, 354, 457, -97, 460, 765, 432,
2102  759, -515, 458, 218, 458, 565, 618, 1056, 611, 474,
2103  227, -294, 1047, 482, 1048, 71, 442, -97, 679, 682,
2104  -97, 703, 329, 693, -97, 329, -104, 86, -434, 710,
2105  -434, -434, 230, 1015, 276, 689, 689, 86, 450, 689,
2106  234, 645, 612, 646, 647, 648, 649, 700, 788, -515,
2107  791, -603, 444, -72, 277, 475, 218, 476, -294, -294,
2108  826, -609, -606, 743, 748, 706, 645, 834, 646, 647,
2109  648, 649, 718, 456, 720, -516, 723, 723, 350, 351,
2110  352, 353, 354, 462, -518, 637, 704, 840, 526, 577,
2111  735, -523, 767, 762, 711, 474, 465, 717, 469, 418,
2112  445, 211, 981, 726, 277, 859, 474, 484, 983, 432,
2113  755, 488, -511, 211, 497, 565, 474, -102, 491, 706,
2114  754, 432, -609, -516, 869, 872, 663, 565, 750, 751,
2115  494, 753, -518, 610, 267, 875, 201, 470, -93, 199,
2116  416, 475, 202, 476, 477, 760, 706, 807, 509, -517,
2117  994, 467, 475, 276, 476, 479, 86, -603, 86, -511,
2118  -511, 119, 475, -603, 476, 481, 218, -609, 827, -609,
2119  -609, -106, 811, -605, 650, 748, 867, 780, 218, -519,
2120  86, 218, -520, 864, 471, 472, 651, -508, 813, 577,
2121  812, 814, 853, 816, 521, 855, 783, -517, 783, -511,
2122  359, 498, -103, 359, 579, 818, 71, -521, 843, 840,
2123  583, 218, 276, 620, 654, 655, 622, 623, 86, 689,
2124  633, -284, 933, 277, 863, -87, 836, -519, 681, -520,
2125  -520, 631, 1042, 937, 706, -508, 854, 580, 656, 629,
2126  751, 515, 884, 839, 842, 706, 842, -511, 842, 523,
2127  761, 474, 822, 824, -521, -521, 683, 947, 949, 830,
2128  832, 592, 952, 638, 954, -295, 955, 885, -284, -284,
2129  405, 885, 86, -266, 694, 86, 697, 86, 474, 812,
2130  199, 698, 277, 218, 581, 582, 218, 218, 878, 416,
2131  963, -425, 804, 218, 218, 713, -109, 475, 1018, 476,
2132  485, 715, 922, 803, 812, 774, 446, 708, 593, 594,
2133  359, 663, -295, -295, 719, 744, 909, -100, 218, 276,
2134  763, 218, 86, 777, 475, 709, 476, 492, 911, 76,
2135  86, 76, -108, -104, 783, 783, 829, 593, 594, 802,
2136  778, 918, 781, 76, 76, 1019, 1020, 76, 925, 926,
2137  784, -106, 928, -99, -95, 723, 807, 931, 785, 436,
2138  965, 927, -103, 807, 935, 807, 917, 787, 789, 921,
2139  437, 438, -97, 790, 1030, 1032, 1033, 1034, 76, 267,
2140  913, 811, 792, -94, -267, 885, 821, 840, 811, 898,
2141  811, 828, 956, 76, 868, 329, 870, 663, 874, 663,
2142  86, 893, 894, 895, 886, 906, 899, 890, 902, 276,
2143  342, 343, 783, 904, 218, 76, 76, 907, 910, 76,
2144  982, 908, 774, 873, 915, 86, 1057, -268, 218, 919,
2145  276, 663, 86, 86, 942, 939, 86, 957, 946, 948,
2146  663, 962, 951, 953, 996, 997, 974, 349, 350, 351,
2147  352, 353, 354, 1002, -269, 645, 842, 646, 647, 648,
2148  649, 1017, 992, 1028, 807, 1003, 807, 1005, 1010, 794,
2149  795, 807, 796, 807, 1012, 1016, 86, 1027, 1029, 958,
2150  46, 47, 1021, 1031, 1022, 1052, -605, 329, -606, 811,
2151  1023, 811, 368, 783, 769, 385, 811, 635, 811, 835,
2152  977, 804, 342, 343, 86, 804, 799, 1046, 804, 871,
2153  804, 903, 905, 807, 1039, 86, 865, 1045, 493, 966,
2154  403, 969, 290, 397, 991, 774, 883, 774, 86, 86,
2155  964, 960, 645, 76, 646, 647, 648, 649, 811, 211,
2156  350, 351, 352, 353, 354, 881, 706, 432, 802, 717,
2157  842, 0, 598, 565, 76, 802, 76, 76, 0, 0,
2158  76, 0, 76, 998, 0, 1000, 86, 76, 86, 0,
2159  1001, 769, 0, 0, 86, 0, 86, 770, 76, 0,
2160  76, 0, 645, 0, 646, 647, 648, 649, 0, 76,
2161  0, 0, 774, 995, 41, 42, 43, 44, 970, 663,
2162  646, 647, 648, 649, 218, 0, 0, 0, 0, 804,
2163  0, 804, 0, 0, 0, 0, 804, 0, 804, 0,
2164  1035, 769, 1037, 0, 0, 0, 0, 940, 0, 1038,
2165  309, 310, 311, 312, 313, 76, 76, 76, 76, 76,
2166  76, 76, 76, 0, 0, 774, 0, 774, 1050, 0,
2167  76, 0, 76, 0, 0, 76, 802, 0, 804, 0,
2168  0, 0, 1004, 1006, 0, 0, 0, 0, 1011, 1058,
2169  1013, 1014, 0, 213, 213, 0, 0, 213, 0, 0,
2170  774, 0, 0, 76, 0, 76, 0, 0, 0, 76,
2171  76, 0, 0, 0, 0, 0, 0, 645, 0, 646,
2172  647, 648, 649, 650, 76, 247, 249, 0, 0, 0,
2173  213, 213, 0, 0, 0, 651, 0, 0, 0, 0,
2174  0, 0, 0, 302, 303, 0, 0, 0, 0, 0,
2175  0, 76, 76, 0, 0, 0, 652, 1051, 1053, 1054,
2176  1055, 0, 653, 654, 655, 76, 645, 0, 646, 647,
2177  648, 649, 650, 0, 0, 0, 0, 0, 0, 0,
2178  1059, 0, 0, 0, 651, 0, 0, 656, 0, 76,
2179  657, 0, 0, 0, 0, 0, 0, 0, 0, 76,
2180  0, 0, 0, 0, 0, 652, -627, 0, 234, 0,
2181  0, 653, 654, 655, -627, -627, -627, 0, 76, -627,
2182  -627, -627, 645, -627, 646, 647, 648, 649, 650, 0,
2183  0, 0, -627, -627, 0, 0, 656, 0, 0, 657,
2184  651, 0, 0, -627, -627, 0, -627, -627, -627, -627,
2185  -627, 0, 658, 0, 0, 0, 0, 0, 0, 0,
2186  0, 652, 0, 0, 0, 0, 0, 653, 654, 655,
2187  0, 0, 0, 113, 0, 113, 0, 0, 0, 0,
2188  0, 213, 0, 0, 213, 213, 213, 302, 0, 0,
2189  0, 0, 656, -627, 0, 657, 0, 0, 0, 0,
2190  0, 0, 0, 0, 213, 0, 213, 213, 0, 645,
2191  0, 646, 647, 648, 649, 650, -627, 0, 76, 0,
2192  76, 0, 113, 0, 0, 0, 278, 651, 76, 0,
2193  0, 0, 0, 0, 0, 329, 0, 0, -627, -627,
2194  76, -627, 76, 76, 230, -627, 0, -627, 652, -627,
2195  342, 343, 278, 0, 0, 654, 655, 0, 0, 0,
2196  0, 0, 0, 0, 372, 382, 382, 382, 0, 0,
2197  0, 0, 0, 76, 0, 0, 0, 0, 0, 656,
2198  76, 0, 0, 0, 0, 347, 348, 349, 350, 351,
2199  352, 353, 354, 0, 0, 0, 0, 0, 0, 0,
2200  213, 0, 0, 0, 0, 525, 528, 529, 530, 531,
2201  532, 533, 534, 535, 536, 537, 538, 539, 540, 541,
2202  542, 543, 544, 545, 546, 547, 548, 549, 550, 551,
2203  552, 553, 0, 213, 76, 0, 0, 76, 0, 76,
2204  0, 0, 0, 0, 0, 76, 0, 0, 76, 76,
2205  0, 0, 0, 0, 0, 76, 76, 0, 0, 0,
2206  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2207  0, 0, 0, 0, 0, 0, 114, 113, 114, 0,
2208  76, 603, 605, 76, 76, 0, 0, 0, 0, 607,
2209  213, 213, 76, 0, 0, 213, 0, 603, 605, 213,
2210  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2211  0, 113, 0, 0, 0, 0, 0, 0, 627, 0,
2212  0, 0, 113, 632, 113, 114, 0, 0, 0, 279,
2213  0, 0, 0, 0, 213, 0, 0, 213, 0, 0,
2214  0, 0, 0, 0, 0, 278, 0, 0, 213, 0,
2215  0, 0, 0, 0, 0, 279, 117, 0, 117, 0,
2216  0, 0, 76, 0, 0, 0, 0, 373, 383, 383,
2217  383, 0, 0, 0, 684, 0, 76, 0, 0, 113,
2218  0, 0, 0, 0, 113, 0, 0, 76, 0, 213,
2219  76, 0, 0, 0, 76, 76, 113, 278, 76, 0,
2220  0, 0, 0, 0, 0, 117, 0, 0, 0, 280,
2221  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2222  0, 0, 0, 0, 0, 0, 0, 0, 0, 113,
2223  0, 0, 0, 0, 0, 280, 0, 0, 76, 0,
2224  0, 0, 0, 0, 0, 0, 0, 374, 384, 384,
2225  0, 0, 0, 0, 213, 0, 0, 0, 213, 0,
2226  0, 0, 0, 0, 0, 0, 76, 0, 0, 0,
2227  213, 0, 0, 0, 0, 0, 0, 76, 0, 0,
2228  114, 0, 0, 0, 0, 0, 213, 0, 0, 0,
2229  76, 76, 0, 0, 0, 0, 0, 0, 0, 213,
2230  213, 329, 330, 331, 332, 333, 334, 335, 336, 0,
2231  338, 339, 0, 113, 114, 0, 342, 343, 0, 0,
2232  0, 0, 0, 113, 0, 114, 0, 114, 76, 0,
2233  76, 0, 0, 0, 0, 83, 76, 83, 76, 0,
2234  278, 0, 0, 213, 0, 0, 0, 0, 279, 345,
2235  346, 347, 348, 349, 350, 351, 352, 353, 354, 0,
2236  117, 0, 0, 0, 0, 0, 76, 0, 0, 0,
2237  0, 213, 0, 0, 0, 607, 820, 0, 823, 825,
2238  0, 0, 114, 0, 83, 831, 833, 114, 0, 0,
2239  278, 0, 213, 0, 117, 0, 0, 0, 0, 114,
2240  279, 0, 0, 0, 0, 117, 0, 117, 0, 0,
2241  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2242  0, 0, 0, 0, 0, 0, 369, 0, 280, 866,
2243  0, 0, 114, 823, 825, 0, 831, 833, 0, 0,
2244  0, 0, 113, 0, 113, 0, 0, 0, 0, 0,
2245  0, 0, 0, 0, 213, 0, 0, 0, 0, 0,
2246  0, 0, 117, 0, 0, 0, 113, 117, 0, 0,
2247  0, 0, 0, 0, 0, 0, 0, 0, 0, 117,
2248  280, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2249  0, 0, 0, 0, 213, 0, 0, 116, 912, 116,
2250  0, 0, 0, 0, 113, 0, 914, 0, 0, 278,
2251  0, 0, 117, 0, 0, 0, 114, 0, 0, 0,
2252  0, 0, 0, 0, 0, 0, 114, 213, 0, 0,
2253  0, 0, 0, 0, 0, 0, 0, 0, 0, 83,
2254  0, 0, 0, 279, 914, 213, 116, 0, 0, 0,
2255  0, 0, 0, 0, 0, 0, 0, 0, 113, 0,
2256  0, 113, 0, 113, 0, 0, 0, 0, 278, 0,
2257  0, 0, 0, 83, 0, 0, 0, 0, 0, 0,
2258  0, 0, 0, 0, 83, 0, 83, 0, 0, 0,
2259  0, 0, 0, 279, 0, 0, 117, 0, 0, 0,
2260  0, 0, 699, 0, 0, 0, 117, 0, 113, 0,
2261  0, 0, 0, 0, 0, 0, 113, 0, 0, 0,
2262  0, 0, 0, 280, 0, 0, 0, 0, 329, 330,
2263  331, 332, 333, 334, 335, 336, 337, 338, 339, 340,
2264  341, 83, 0, 342, 343, 114, 83, 114, 0, 0,
2265  0, 0, 0, 0, 0, 0, 0, 0, 83, 0,
2266  0, 524, 0, 0, 0, 0, 0, 0, 0, 114,
2267  0, 0, 0, 280, 344, 382, 345, 346, 347, 348,
2268  349, 350, 351, 352, 353, 354, 113, 0, 0, 0,
2269  0, 83, 0, 0, -243, 0, 213, 0, 0, 0,
2270  0, 116, 0, 0, 0, 0, 0, 114, 0, 0,
2271  0, 113, 279, 0, 0, 0, 0, 0, 113, 113,
2272  0, 0, 113, 0, 0, 117, 0, 117, 0, 0,
2273  0, 0, 0, 0, 0, 116, 0, 0, 0, 0,
2274  0, 0, 0, 0, 0, 0, 116, 0, 116, 117,
2275  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2276  0, 114, 113, 0, 114, 382, 114, 0, 0, 0,
2277  0, 279, 0, 0, 0, 83, 0, 0, 0, 0,
2278  0, 0, 0, 0, 0, 83, 978, 117, 0, 0,
2279  113, 0, 280, 0, 0, 0, 0, 0, 0, 0,
2280  0, 113, 0, 116, 0, 0, 0, 0, 116, 0,
2281  0, 114, 0, 0, 113, 113, 0, 0, 0, 114,
2282  116, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2283  0, 0, 798, 0, 0, 0, 0, 0, 0, 0,
2284  0, 117, 0, 0, 117, 0, 117, 0, 0, 0,
2285  0, 280, 113, 116, 113, 0, 0, 0, 0, 0,
2286  113, 0, 113, 0, 0, 0, 0, 0, 0, 0,
2287  0, 0, 0, 0, 0, 0, 0, 0, 383, 0,
2288  0, 0, 0, 0, 0, 0, 0, 0, 0, 114,
2289  0, 117, 0, 0, 0, 0, 0, 0, 0, 117,
2290  0, 0, 0, 0, 83, 0, 83, 0, 0, 0,
2291  0, 0, 0, 0, 114, 0, 0, 0, 0, 0,
2292  0, 114, 114, 0, 0, 114, 0, 0, 83, 329,
2293  -628, -628, -628, -628, 334, 335, 0, 116, -628, -628,
2294  0, 0, 0, 0, 342, 343, 0, 116, 0, 0,
2295  0, 0, 0, 0, 0, 0, 0, 0, 384, 0,
2296  0, 0, 0, 0, 0, 114, 83, 0, 383, 117,
2297  0, 0, 0, 0, 0, 0, 0, 345, 346, 347,
2298  348, 349, 350, 351, 352, 353, 354, 0, 0, 979,
2299  0, 0, 0, 114, 117, 0, 0, 0, 0, 0,
2300  0, 117, 117, 0, 114, 117, 0, 0, 0, 0,
2301  0, 0, 0, 0, 0, 0, 0, 114, 114, 0,
2302  83, 0, 0, 83, 0, 83, 0, 0, 0, 0,
2303  0, 524, 0, 0, 0, 0, 0, 0, 0, 0,
2304  0, 0, 0, 0, 0, 117, 0, 0, 384, 0,
2305  0, 0, 0, 0, 0, 114, 0, 114, 0, 0,
2306  0, 0, 0, 114, 0, 114, 116, 0, 116, 980,
2307  83, 0, 0, 117, 0, 0, 0, 0, 83, -609,
2308  0, 0, 0, 0, 117, 0, 0, -609, -609, -609,
2309  116, 0, -609, -609, -609, 0, -609, 117, 117, 0,
2310  0, 0, 0, 0, 0, -609, -609, -609, -609, 0,
2311  0, 0, 0, 0, 0, 0, -609, -609, 0, -609,
2312  -609, -609, -609, -609, 0, 0, 0, 0, 116, 0,
2313  0, 0, 0, 0, 0, 117, 0, 117, 0, 0,
2314  0, 0, 0, 117, 0, 117, 0, 0, 83, -609,
2315  -609, -609, -609, -609, -609, -609, -609, -609, -609, -609,
2316  -609, -609, 0, 0, -609, -609, -609, 0, 756, -609,
2317  0, 0, 0, 83, 0, -609, 0, 0, 0, 0,
2318  83, 83, 116, 0, 83, 116, 0, 116, 0, -609,
2319  0, 0, -609, 0, -105, -609, -609, -609, -609, -609,
2320  -609, -609, -609, -609, -609, -609, -609, 0, 0, 0,
2321  0, -609, -609, -609, -609, -609, 0, 0, -609, -609,
2322  -609, 0, -609, 0, 83, 0, 0, 0, 0, 0,
2323  0, 0, 116, 0, 0, 0, 0, 0, 0, 0,
2324  116, 329, 330, 331, 332, 333, 334, 335, 976, 0,
2325  338, 339, 83, 0, 0, 0, 342, 343, 0, 0,
2326  0, 0, 0, 83, 0, 0, 0, 0, 0, 0,
2327  0, 0, 0, 0, 0, 0, 83, 83, 0, 0,
2328  0, 0, 0, 0, 0, 0, 0, 0, 0, 345,
2329  346, 347, 348, 349, 350, 351, 352, 353, 354, 0,
2330  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2331  116, 0, 0, 0, 83, 0, 83, 0, 0, 0,
2332  0, 0, 83, 0, 83, 0, 0, 0, 0, 0,
2333  0, 0, 0, 0, 0, 116, 0, 0, 0, 0,
2334  0, 0, 116, 116, 0, 0, 116, 0, 0, 0,
2335  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2336  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2337  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2338  0, 0, 0, 0, 0, 0, 116, 0, 0, 0,
2339  0, 0, 0, 0, 0, 0, 0, -627, 4, 0,
2340  5, 6, 7, 8, 9, 0, 0, 0, 10, 11,
2341  0, 0, 0, 12, 116, 13, 14, 15, 16, 17,
2342  18, 19, 0, 0, 0, 116, 0, 20, 21, 22,
2343  23, 24, 25, 26, 0, 0, 27, 0, 116, 116,
2344  0, 0, 28, 29, 30, 31, 32, 33, 34, 35,
2345  36, 37, 38, 39, 40, 0, 41, 42, 43, 44,
2346  0, 45, 46, 47, 0, 48, 49, 0, 0, 0,
2347  0, 0, 0, 0, 0, 0, 116, 0, 116, 0,
2348  0, 0, 0, 0, 116, 50, 116, 0, 51, 52,
2349  0, 53, 54, 0, 55, 0, 0, 56, 57, 58,
2350  59, 60, 61, 62, 63, 64, -508, 0, 0, 0,
2351  0, 0, 0, 0, -508, -508, -508, 0, 0, -508,
2352  -508, -508, 0, -508, 0, 65, 66, 67, 0, 752,
2353  0, -508, 0, -508, -508, -508, 0, 0, -627, 0,
2354  -627, 0, 0, -508, -508, 0, -508, -508, -508, -508,
2355  -508, 0, 0, 0, 0, 329, 330, 331, 332, 333,
2356  334, 335, 336, 337, 338, 339, 340, 341, 0, 0,
2357  342, 343, 0, 0, 0, 0, -508, -508, -508, -508,
2358  -508, -508, -508, -508, -508, -508, -508, -508, -508, 0,
2359  0, -508, -508, -508, 0, -508, -508, 0, 0, 0,
2360  0, 344, -508, 345, 346, 347, 348, 349, 350, 351,
2361  352, 353, 354, 0, 0, 0, -508, 0, 0, -508,
2362  0, -508, -508, -508, -508, -508, -508, -508, -508, -508,
2363  -508, -508, -508, -508, 0, 0, 0, 0, 0, -508,
2364  -508, -508, -508, -511, 0, -508, -508, -508, 0, -508,
2365  0, -511, -511, -511, 0, 0, -511, -511, -511, 0,
2366  -511, 0, 0, 0, 0, 0, 699, 0, -511, 0,
2367  -511, -511, -511, 0, 0, 0, 0, 0, 0, 0,
2368  -511, -511, 0, -511, -511, -511, -511, -511, 0, 0,
2369  0, 0, 329, 330, 331, 332, 333, 334, 335, 336,
2370  337, 338, 339, 340, 341, 0, 0, 342, 343, 0,
2371  0, 0, 0, -511, -511, -511, -511, -511, -511, -511,
2372  -511, -511, -511, -511, -511, -511, 0, 0, -511, -511,
2373  -511, 0, -511, -511, 0, 0, 0, 0, 344, -511,
2374  345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
2375  0, 0, 0, -511, 0, 0, -511, 0, -511, -511,
2376  -511, -511, -511, -511, -511, -511, -511, -511, -511, -511,
2377  -511, 0, 0, 0, 0, 0, -511, -511, -511, -511,
2378  -610, 0, -511, -511, -511, 0, -511, 0, -610, -610,
2379  -610, 0, 0, -610, -610, -610, 0, -610, 0, 0,
2380  0, 0, 0, 0, 0, 0, -610, -610, -610, -610,
2381  0, 0, 0, 0, 0, 0, 0, -610, -610, 0,
2382  -610, -610, -610, -610, -610, 0, 0, 0, 0, 329,
2383  330, 331, 332, 333, 334, 335, 336, 337, 338, 339,
2384  340, 341, 0, 0, 342, 343, 0, 0, 0, 0,
2385  -610, -610, -610, -610, -610, -610, -610, -610, -610, -610,
2386  -610, -610, -610, 0, 0, -610, -610, -610, 0, 0,
2387  -610, 0, 0, 0, 0, 344, -610, 345, 346, 347,
2388  348, 349, 350, 351, 352, 353, 354, 0, 0, 0,
2389  -610, 0, 0, -610, 0, 0, -610, -610, -610, -610,
2390  -610, -610, -610, -610, -610, -610, -610, -610, 0, 0,
2391  0, 0, -610, -610, -610, -610, -610, -611, 0, -610,
2392  -610, -610, 0, -610, 0, -611, -611, -611, 0, 0,
2393  -611, -611, -611, 0, -611, 0, 0, 0, 0, 0,
2394  0, 0, 0, -611, -611, -611, -611, 0, 0, 0,
2395  0, 0, 0, 0, -611, -611, 0, -611, -611, -611,
2396  -611, -611, 0, 0, 0, 0, 329, 330, 331, 332,
2397  333, 334, 335, 336, 337, 338, 339, -628, -628, 0,
2398  0, 342, 343, 0, 0, 0, 0, -611, -611, -611,
2399  -611, -611, -611, -611, -611, -611, -611, -611, -611, -611,
2400  0, 0, -611, -611, -611, 0, 0, -611, 0, 0,
2401  0, 0, 0, -611, 345, 346, 347, 348, 349, 350,
2402  351, 352, 353, 354, 0, 0, 0, -611, 0, 0,
2403  -611, 0, 0, -611, -611, -611, -611, -611, -611, -611,
2404  -611, -611, -611, -611, -611, 0, 0, 0, 0, -611,
2405  -611, -611, -611, -611, -294, 0, -611, -611, -611, 0,
2406  -611, 0, -294, -294, -294, 0, 0, -294, -294, -294,
2407  0, -294, 0, 0, 0, 0, 0, 0, 0, 0,
2408  0, -294, -294, -294, 0, 0, 0, 0, 0, 0,
2409  0, -294, -294, 0, -294, -294, -294, -294, -294, 0,
2410  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2411  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2412  0, 0, 0, 0, -294, -294, -294, -294, -294, -294,
2413  -294, -294, -294, -294, -294, -294, -294, 0, 0, -294,
2414  -294, -294, 0, 757, -294, 0, 0, 0, 0, 0,
2415  -294, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2416  0, 0, 0, 0, -294, 0, 0, -294, 0, -107,
2417  -294, -294, -294, -294, -294, -294, -294, -294, -294, -294,
2418  -294, -294, 0, 0, 0, 0, 0, -294, -294, -294,
2419  -294, -433, 0, -294, -294, -294, 0, -294, 0, -433,
2420  -433, -433, 0, 0, -433, -433, -433, 0, -433, 0,
2421  0, 0, 0, 0, 0, 0, 0, -433, -433, -433,
2422  0, 0, 0, 0, 0, 0, 0, 0, -433, -433,
2423  0, -433, -433, -433, -433, -433, 0, 0, 0, 0,
2424  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2425  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2426  0, -433, -433, -433, -433, -433, -433, -433, -433, -433,
2427  -433, -433, -433, -433, 0, 0, -433, -433, -433, 0,
2428  0, -433, 0, 0, 0, 0, 0, -433, 0, 0,
2429  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2430  0, -433, 0, 0, 0, 0, 0, -433, 0, -433,
2431  -433, -433, -433, -433, -433, -433, -433, -433, -433, 0,
2432  0, 0, 0, -433, -433, -433, -433, -433, -285, 230,
2433  -433, -433, -433, 0, -433, 0, -285, -285, -285, 0,
2434  0, -285, -285, -285, 0, -285, 0, 0, 0, 0,
2435  0, 0, 0, 0, 0, -285, -285, -285, 0, 0,
2436  0, 0, 0, 0, 0, -285, -285, 0, -285, -285,
2437  -285, -285, -285, 0, 0, 0, 0, 0, 0, 0,
2438  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2439  0, 0, 0, 0, 0, 0, 0, 0, -285, -285,
2440  -285, -285, -285, -285, -285, -285, -285, -285, -285, -285,
2441  -285, 0, 0, -285, -285, -285, 0, 0, -285, 0,
2442  0, 0, 0, 0, -285, 0, 0, 0, 0, 0,
2443  0, 0, 0, 0, 0, 0, 0, 0, -285, 0,
2444  0, -285, 0, 0, -285, -285, -285, -285, -285, -285,
2445  -285, -285, -285, -285, -285, -285, 0, 0, 0, 0,
2446  0, -285, -285, -285, -285, -423, 0, -285, -285, -285,
2447  0, -285, 0, -423, -423, -423, 0, 0, -423, -423,
2448  -423, 0, -423, 0, 0, 0, 0, 0, 0, 0,
2449  0, -423, -423, -423, 0, 0, 0, 0, 0, 0,
2450  0, 0, -423, -423, 0, -423, -423, -423, -423, -423,
2451  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2452  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2453  0, 0, 0, 0, 0, -423, -423, -423, -423, -423,
2454  -423, -423, -423, -423, -423, -423, -423, -423, 0, 0,
2455  -423, -423, -423, 0, 0, -423, 0, 0, 0, 0,
2456  0, -423, 0, 0, 0, 0, 0, 0, 0, 0,
2457  0, 0, 0, 0, 0, -423, 0, 0, 0, 0,
2458  0, -423, 0, -423, -423, -423, -423, -423, -423, -423,
2459  -423, -423, -423, 0, 0, 0, 0, -423, -423, -423,
2460  -423, -423, -301, -423, -423, -423, -423, 0, -423, 0,
2461  -301, -301, -301, 0, 0, -301, -301, -301, 0, -301,
2462  0, 0, 0, 0, 0, 0, 0, 0, 0, -301,
2463  -301, 0, 0, 0, 0, 0, 0, 0, 0, -301,
2464  -301, 0, -301, -301, -301, -301, -301, 0, 0, 0,
2465  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2466  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2467  0, 0, -301, -301, -301, -301, -301, -301, -301, -301,
2468  -301, -301, -301, -301, -301, 0, 0, -301, -301, -301,
2469  0, 0, -301, 0, 0, 0, 0, 0, -301, 0,
2470  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2471  0, 0, -301, 0, 0, 0, 0, 0, -301, 0,
2472  -301, -301, -301, -301, -301, -301, -301, -301, -301, -301,
2473  0, 0, 0, 0, 0, -301, -301, -301, -301, -609,
2474  227, -301, -301, -301, 0, -301, 0, -609, -609, -609,
2475  0, 0, 0, -609, -609, 0, -609, 0, 0, 0,
2476  0, 0, 0, 0, 0, -609, 0, 0, 0, 0,
2477  0, 0, 0, 0, 0, 0, -609, -609, 0, -609,
2478  -609, -609, -609, -609, 0, 0, 0, 0, 0, 0,
2479  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2480  0, 0, 0, 0, 0, 0, 0, 0, 0, -609,
2481  -609, -609, -609, -609, -609, -609, -609, -609, -609, -609,
2482  -609, -609, 0, 0, -609, -609, -609, 0, 701, 0,
2483  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2484  0, 0, 0, 0, 0, 0, 0, 0, 0, -609,
2485  0, 0, 0, 0, -105, -609, 0, -609, -609, -609,
2486  -609, -609, -609, -609, -609, -609, -609, 0, 0, 0,
2487  0, -609, -609, -609, -609, -96, -294, 0, -609, 0,
2488  -609, 0, -609, 0, -294, -294, -294, 0, 0, 0,
2489  -294, -294, 0, -294, 0, 0, 0, 0, 0, 0,
2490  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2491  0, 0, 0, -294, -294, 0, -294, -294, -294, -294,
2492  -294, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2493  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2494  0, 0, 0, 0, 0, 0, -294, -294, -294, -294,
2495  -294, -294, -294, -294, -294, -294, -294, -294, -294, 0,
2496  0, -294, -294, -294, 0, 702, 0, 0, 0, 0,
2497  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2498  0, 0, 0, 0, 0, 0, -294, 0, 0, 0,
2499  0, -107, -294, 0, -294, -294, -294, -294, -294, -294,
2500  -294, -294, -294, -294, 0, 0, 0, 0, 0, -294,
2501  -294, -294, -98, 0, 0, -294, 0, -294, 251, -294,
2502  5, 6, 7, 8, 9, -627, -627, -627, 10, 11,
2503  0, 0, -627, 12, 0, 13, 14, 15, 16, 17,
2504  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2505  23, 24, 25, 26, 0, 0, 27, 0, 0, 0,
2506  0, 0, 28, 29, 252, 31, 32, 33, 34, 35,
2507  36, 37, 38, 39, 40, 0, 41, 42, 43, 44,
2508  0, 45, 46, 47, 0, 48, 49, 0, 0, 0,
2509  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2510  0, 0, 0, 0, 0, 50, 0, 0, 51, 52,
2511  0, 53, 54, 0, 55, 0, 0, 56, 57, 58,
2512  59, 60, 61, 62, 63, 64, 0, 0, 0, 0,
2513  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2514  0, 0, 0, 0, 0, 65, 66, 67, 0, 0,
2515  0, 0, 0, 0, 0, 0, 0, 0, -627, 251,
2516  -627, 5, 6, 7, 8, 9, 0, 0, -627, 10,
2517  11, 0, -627, -627, 12, 0, 13, 14, 15, 16,
2518  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2519  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2520  0, 0, 0, 28, 29, 252, 31, 32, 33, 34,
2521  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
2522  44, 0, 45, 46, 47, 0, 48, 49, 0, 0,
2523  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2524  0, 0, 0, 0, 0, 0, 50, 0, 0, 51,
2525  52, 0, 53, 54, 0, 55, 0, 0, 56, 57,
2526  58, 59, 60, 61, 62, 63, 64, 0, 0, 0,
2527  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2528  0, 0, 0, 0, 0, 0, 65, 66, 67, 0,
2529  0, 0, 0, 0, 0, 0, 0, 0, 0, -627,
2530  251, -627, 5, 6, 7, 8, 9, 0, 0, -627,
2531  10, 11, 0, 0, -627, 12, -627, 13, 14, 15,
2532  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2533  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2534  0, 0, 0, 0, 28, 29, 252, 31, 32, 33,
2535  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2536  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2537  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2538  0, 0, 0, 0, 0, 0, 0, 50, 0, 0,
2539  51, 52, 0, 53, 54, 0, 55, 0, 0, 56,
2540  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2541  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2542  0, 0, 0, 0, 0, 0, 0, 65, 66, 67,
2543  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2544  -627, 251, -627, 5, 6, 7, 8, 9, 0, 0,
2545  -627, 10, 11, 0, 0, -627, 12, 0, 13, 14,
2546  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2547  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2548  0, 0, 0, 0, 0, 28, 29, 252, 31, 32,
2549  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2550  42, 43, 44, 0, 45, 46, 47, 0, 48, 49,
2551  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2552  0, 0, 0, 0, 0, 0, 0, 0, 50, 0,
2553  0, 51, 52, 0, 53, 54, 0, 55, 0, 0,
2554  56, 57, 58, 59, 60, 61, 62, 63, 64, 0,
2555  0, 0, 0, 0, 0, 0, 251, 0, 5, 6,
2556  7, 8, 9, 0, -627, -627, 10, 11, 65, 66,
2557  67, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2558  0, -627, 0, -627, 0, 20, 21, 22, 23, 24,
2559  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2560  28, 29, 252, 31, 32, 33, 34, 35, 36, 37,
2561  38, 39, 40, 0, 41, 42, 43, 44, 0, 45,
2562  46, 47, 0, 48, 49, 0, 0, 0, 0, 0,
2563  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2564  0, 0, 0, 50, 0, 0, 51, 52, 0, 53,
2565  54, 0, 55, 0, 0, 56, 57, 58, 59, 60,
2566  61, 62, 63, 64, 0, 0, 0, 0, 0, 0,
2567  0, 251, 0, 5, 6, 7, 8, 9, 0, 0,
2568  0, 10, 11, 65, 66, 67, 12, 0, 13, 14,
2569  15, 16, 17, 18, 19, 0, -627, 0, -627, 0,
2570  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2571  0, 0, 0, 0, 0, 28, 29, 252, 31, 32,
2572  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2573  42, 43, 44, 0, 45, 46, 47, 0, 48, 49,
2574  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2575  0, 0, 0, 0, 0, 0, 0, 0, 50, 0,
2576  0, 253, 52, 0, 53, 54, 0, 55, 0, 0,
2577  56, 57, 58, 59, 60, 61, 62, 63, 64, 0,
2578  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2579  0, 0, 0, 0, 0, 0, 0, 0, 65, 66,
2580  67, 0, 0, 0, 0, 0, 0, 0, 0, -627,
2581  0, -627, 251, -627, 5, 6, 7, 8, 9, 0,
2582  0, 0, 10, 11, 0, 0, 0, 12, 0, 13,
2583  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2584  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2585  27, 0, 0, 0, 0, 0, 28, 29, 252, 31,
2586  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2587  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2588  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2589  0, 0, 0, 0, 0, 0, 0, 0, 0, 50,
2590  0, 0, 51, 52, 0, 53, 54, 0, 55, 0,
2591  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2592  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2593  0, 0, 0, 0, 0, 0, 0, 0, 0, 65,
2594  66, 67, 0, 0, 0, 0, 0, 0, 0, 0,
2595  -627, 0, -627, 251, -627, 5, 6, 7, 8, 9,
2596  0, 0, 0, 10, 11, 0, 0, 0, 12, 0,
2597  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2598  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2599  0, 27, 0, 0, 0, 0, 0, 28, 29, 252,
2600  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2601  0, 41, 42, 43, 44, 0, 45, 46, 47, 0,
2602  48, 49, 0, 0, 0, 0, 0, 0, 0, 0,
2603  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2604  50, 0, 0, 51, 52, 0, 53, 54, 0, 55,
2605  0, 0, 56, 57, 58, 59, 60, 61, 62, 63,
2606  64, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2607  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2608  65, 66, 67, 0, 0, -627, 4, 0, 5, 6,
2609  7, 8, 9, -627, 0, -627, 10, 11, 0, 0,
2610  0, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2611  0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2612  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2613  28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
2614  38, 39, 40, 0, 41, 42, 43, 44, 0, 45,
2615  46, 47, 0, 48, 49, 0, 0, 0, 0, 0,
2616  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2617  0, 0, 0, 50, 0, 0, 51, 52, 0, 53,
2618  54, 0, 55, 0, 0, 56, 57, 58, 59, 60,
2619  61, 62, 63, 64, 0, 0, 0, 0, 0, 0,
2620  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2621  0, 0, 0, 65, 66, 67, 0, 0, -627, 0,
2622  0, 0, 0, 0, 0, 0, -627, 251, -627, 5,
2623  6, 7, 8, 9, 0, 0, -627, 10, 11, 0,
2624  0, 0, 12, 0, 13, 14, 15, 16, 17, 18,
2625  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2626  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2627  0, 28, 29, 252, 31, 32, 33, 34, 35, 36,
2628  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2629  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2630  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2631  0, 0, 0, 0, 50, 0, 0, 51, 52, 0,
2632  53, 54, 0, 55, 0, 0, 56, 57, 58, 59,
2633  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2634  0, 0, 251, 0, 5, 6, 7, 8, 9, 0,
2635  0, 0, 10, 11, 65, 66, 67, 12, 0, 13,
2636  14, 15, 16, 17, 18, 19, 0, -627, 0, -627,
2637  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2638  27, 0, 0, 0, 0, 0, 28, 29, 252, 31,
2639  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2640  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2641  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2642  0, 0, 0, 0, 0, 0, 0, 0, 0, 50,
2643  0, 0, 51, 52, 0, 53, 54, 0, 55, 0,
2644  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2645  0, -627, 0, 0, 0, 0, 0, 0, 0, 5,
2646  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2647  66, 67, 12, 0, 13, 14, 15, 16, 17, 18,
2648  19, 0, -627, 0, -627, 0, 20, 21, 22, 23,
2649  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2650  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2651  37, 38, 39, 40, 204, 41, 42, 43, 44, 0,
2652  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2653  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2654  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2655  53, 54, 0, 207, 208, 209, 56, 57, 58, 59,
2656  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2657  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2658  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2659  14, 15, 16, 17, 18, 19, 0, 0, 0, 234,
2660  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2661  27, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2662  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2663  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2664  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2665  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2666  0, 0, 206, 52, 0, 53, 54, 0, 0, 0,
2667  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2668  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2669  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2670  66, 67, 12, 0, 13, 14, 15, 16, 17, 18,
2671  19, 0, 304, 0, 305, 0, 20, 21, 22, 23,
2672  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2673  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2674  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2675  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2676  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2677  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2678  53, 54, 0, 0, 0, 0, 56, 57, 58, 59,
2679  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2680  0, 0, 0, 0, 5, 6, 7, 8, 9, 0,
2681  0, 0, 10, 11, 65, 66, 67, 12, 0, 13,
2682  14, 15, 16, 17, 18, 19, 0, 0, 0, 234,
2683  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2684  27, 0, 0, 0, 0, 0, 28, 29, 30, 31,
2685  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2686  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2687  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2688  0, 0, 0, 0, 0, 0, 0, 0, 0, 50,
2689  0, 0, 51, 52, 0, 53, 54, 0, 55, 0,
2690  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2691  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2692  6, 7, 8, 9, 0, 0, 0, 10, 11, 65,
2693  66, 67, 12, 0, 13, 14, 15, 16, 17, 18,
2694  19, 0, 498, 0, 0, 0, 20, 21, 22, 23,
2695  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2696  0, 28, 29, 252, 31, 32, 33, 34, 35, 36,
2697  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2698  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2699  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2700  0, 0, 0, 0, 50, 0, 0, 51, 52, 0,
2701  53, 54, 0, 55, 0, 0, 56, 57, 58, 59,
2702  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2703  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2704  0, 0, 0, 0, 65, 66, 67, 0, 0, 0,
2705  0, 0, 0, 0, 0, 0, 0, 498, 121, 122,
2706  123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
2707  133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
2708  143, 144, 0, 0, 0, 145, 146, 147, 386, 387,
2709  388, 389, 152, 153, 154, 0, 0, 0, 0, 0,
2710  155, 156, 157, 158, 390, 391, 392, 393, 163, 37,
2711  38, 394, 40, 0, 0, 0, 0, 0, 0, 0,
2712  0, 0, 0, 165, 166, 167, 168, 169, 170, 171,
2713  172, 173, 0, 0, 174, 175, 0, 0, 176, 177,
2714  178, 179, 0, 0, 0, 0, 0, 0, 0, 0,
2715  0, 0, 180, 181, 0, 0, 0, 0, 0, 0,
2716  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2717  0, 0, 0, 182, 183, 184, 185, 186, 187, 188,
2718  189, 190, 191, 0, 192, 193, 0, 0, 0, 0,
2719  0, 0, 194, 395, 121, 122, 123, 124, 125, 126,
2720  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
2721  137, 138, 139, 140, 141, 142, 143, 144, 0, 0,
2722  0, 145, 146, 147, 148, 149, 150, 151, 152, 153,
2723  154, 0, 0, 0, 0, 0, 155, 156, 157, 158,
2724  159, 160, 161, 162, 163, 283, 284, 164, 285, 0,
2725  0, 0, 0, 0, 0, 0, 0, 0, 0, 165,
2726  166, 167, 168, 169, 170, 171, 172, 173, 0, 0,
2727  174, 175, 0, 0, 176, 177, 178, 179, 0, 0,
2728  0, 0, 0, 0, 0, 0, 0, 0, 180, 181,
2729  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2730  0, 0, 0, 0, 0, 0, 0, 0, 0, 182,
2731  183, 184, 185, 186, 187, 188, 189, 190, 191, 0,
2732  192, 193, 0, 0, 0, 0, 0, 0, 194, 121,
2733  122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
2734  132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
2735  142, 143, 144, 0, 0, 0, 145, 146, 147, 148,
2736  149, 150, 151, 152, 153, 154, 0, 0, 0, 0,
2737  0, 155, 156, 157, 158, 159, 160, 161, 162, 163,
2738  236, 0, 164, 0, 0, 0, 0, 0, 0, 0,
2739  0, 0, 0, 0, 165, 166, 167, 168, 169, 170,
2740  171, 172, 173, 0, 0, 174, 175, 0, 0, 176,
2741  177, 178, 179, 0, 0, 0, 0, 0, 0, 0,
2742  0, 0, 0, 180, 181, 0, 0, 57, 0, 0,
2743  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2744  0, 0, 0, 0, 182, 183, 184, 185, 186, 187,
2745  188, 189, 190, 191, 0, 192, 193, 0, 0, 0,
2746  0, 0, 0, 194, 121, 122, 123, 124, 125, 126,
2747  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
2748  137, 138, 139, 140, 141, 142, 143, 144, 0, 0,
2749  0, 145, 146, 147, 148, 149, 150, 151, 152, 153,
2750  154, 0, 0, 0, 0, 0, 155, 156, 157, 158,
2751  159, 160, 161, 162, 163, 0, 0, 164, 0, 0,
2752  0, 0, 0, 0, 0, 0, 0, 0, 0, 165,
2753  166, 167, 168, 169, 170, 171, 172, 173, 0, 0,
2754  174, 175, 0, 0, 176, 177, 178, 179, 0, 0,
2755  0, 0, 0, 0, 0, 0, 0, 0, 180, 181,
2756  0, 0, 57, 0, 0, 0, 0, 0, 0, 0,
2757  0, 0, 0, 0, 0, 0, 0, 0, 0, 182,
2758  183, 184, 185, 186, 187, 188, 189, 190, 191, 0,
2759  192, 193, 0, 0, 0, 0, 0, 0, 194, 121,
2760  122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
2761  132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
2762  142, 143, 144, 0, 0, 0, 145, 146, 147, 148,
2763  149, 150, 151, 152, 153, 154, 0, 0, 0, 0,
2764  0, 155, 156, 157, 158, 159, 160, 161, 162, 163,
2765  0, 0, 164, 0, 0, 0, 0, 0, 0, 0,
2766  0, 0, 0, 0, 165, 166, 167, 168, 169, 170,
2767  171, 172, 173, 0, 0, 174, 175, 0, 0, 176,
2768  177, 178, 179, 0, 0, 0, 0, 0, 0, 0,
2769  0, 0, 0, 180, 181, 0, 0, 0, 0, 0,
2770  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2771  0, 0, 0, 0, 182, 183, 184, 185, 186, 187,
2772  188, 189, 190, 191, 0, 192, 193, 5, 6, 7,
2773  0, 9, 0, 194, 0, 10, 11, 0, 0, 0,
2774  12, 0, 13, 14, 15, 241, 242, 18, 19, 0,
2775  0, 0, 0, 0, 243, 244, 245, 23, 24, 25,
2776  26, 0, 0, 203, 0, 0, 0, 0, 0, 0,
2777  271, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2778  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2779  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2780  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2781  0, 0, 272, 0, 0, 206, 52, 0, 53, 54,
2782  0, 0, 0, 0, 56, 57, 58, 59, 60, 61,
2783  62, 63, 64, 0, 0, 0, 0, 0, 5, 6,
2784  7, 0, 9, 0, 0, 0, 10, 11, 0, 0,
2785  0, 12, 273, 13, 14, 15, 241, 242, 18, 19,
2786  274, 0, 0, 0, 0, 243, 244, 245, 23, 24,
2787  25, 26, 0, 0, 203, 0, 0, 0, 0, 0,
2788  0, 271, 0, 0, 32, 33, 34, 35, 36, 37,
2789  38, 39, 40, 0, 41, 42, 43, 44, 0, 45,
2790  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2791  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2792  0, 0, 0, 272, 0, 0, 206, 52, 0, 53,
2793  54, 0, 0, 0, 0, 56, 57, 58, 59, 60,
2794  61, 62, 63, 64, 0, 0, 0, 0, 0, 5,
2795  6, 7, 8, 9, 0, 0, 0, 10, 11, 0,
2796  0, 0, 12, 273, 13, 14, 15, 16, 17, 18,
2797  19, 519, 0, 0, 0, 0, 20, 21, 22, 23,
2798  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2799  0, 28, 29, 30, 31, 32, 33, 34, 35, 36,
2800  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2801  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2802  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2803  0, 0, 0, 0, 50, 0, 0, 51, 52, 0,
2804  53, 54, 0, 55, 0, 0, 56, 57, 58, 59,
2805  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2806  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2807  0, 0, 10, 11, 65, 66, 67, 12, 0, 13,
2808  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2809  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2810  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2811  32, 33, 34, 35, 36, 37, 38, 39, 40, 204,
2812  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2813  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2814  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2815  0, 0, 206, 52, 0, 53, 54, 0, 207, 208,
2816  209, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2817  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2818  6, 7, 8, 9, 0, 0, 0, 10, 11, 65,
2819  210, 67, 12, 0, 13, 14, 15, 16, 17, 18,
2820  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2821  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2822  0, 28, 29, 0, 31, 32, 33, 34, 35, 36,
2823  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2824  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2825  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2826  0, 0, 0, 0, 50, 0, 0, 51, 52, 0,
2827  53, 54, 0, 55, 0, 0, 56, 57, 58, 59,
2828  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2829  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2830  0, 0, 10, 11, 65, 66, 67, 12, 0, 13,
2831  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
2832  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
2833  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2834  32, 33, 34, 35, 36, 37, 38, 39, 40, 204,
2835  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2836  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2837  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2838  0, 0, 206, 52, 0, 53, 54, 0, 609, 208,
2839  209, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2840  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2841  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2842  210, 67, 12, 0, 13, 14, 15, 241, 242, 18,
2843  19, 0, 0, 0, 0, 0, 243, 244, 245, 23,
2844  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2845  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2846  37, 38, 39, 40, 204, 41, 42, 43, 44, 0,
2847  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2848  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2849  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2850  53, 54, 0, 207, 208, 0, 56, 57, 58, 59,
2851  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2852  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2853  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2854  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
2855  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
2856  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2857  32, 33, 34, 35, 36, 37, 38, 39, 40, 204,
2858  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2859  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2860  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2861  0, 0, 206, 52, 0, 53, 54, 0, 0, 208,
2862  209, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2863  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2864  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2865  210, 67, 12, 0, 13, 14, 15, 241, 242, 18,
2866  19, 0, 0, 0, 0, 0, 243, 244, 245, 23,
2867  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2868  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2869  37, 38, 39, 40, 204, 41, 42, 43, 44, 0,
2870  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2871  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2872  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2873  53, 54, 0, 609, 208, 0, 56, 57, 58, 59,
2874  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2875  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2876  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2877  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
2878  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
2879  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2880  32, 33, 34, 35, 36, 37, 38, 39, 40, 204,
2881  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2882  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2883  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2884  0, 0, 206, 52, 0, 53, 54, 0, 0, 208,
2885  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2886  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2887  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2888  210, 67, 12, 0, 13, 14, 15, 16, 17, 18,
2889  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2890  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2891  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2892  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2893  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2894  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2895  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2896  53, 54, 0, 512, 0, 0, 56, 57, 58, 59,
2897  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2898  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2899  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2900  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
2901  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
2902  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2903  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2904  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2905  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2906  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2907  0, 0, 206, 52, 0, 53, 54, 0, 207, 0,
2908  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2909  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2910  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2911  210, 67, 12, 0, 13, 14, 15, 241, 242, 18,
2912  19, 0, 0, 0, 0, 0, 243, 244, 245, 23,
2913  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2914  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2915  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2916  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2917  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2918  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2919  53, 54, 0, 817, 0, 0, 56, 57, 58, 59,
2920  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2921  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2922  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2923  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
2924  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
2925  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2926  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2927  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2928  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2929  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2930  0, 0, 206, 52, 0, 53, 54, 0, 512, 0,
2931  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2932  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2933  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2934  210, 67, 12, 0, 13, 14, 15, 241, 242, 18,
2935  19, 0, 0, 0, 0, 0, 243, 244, 245, 23,
2936  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2937  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2938  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2939  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2940  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2941  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2942  53, 54, 0, 609, 0, 0, 56, 57, 58, 59,
2943  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2944  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2945  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2946  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
2947  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
2948  203, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2949  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2950  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2951  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2952  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2953  0, 0, 206, 52, 0, 53, 54, 0, 0, 0,
2954  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2955  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2956  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2957  210, 67, 12, 0, 13, 14, 15, 16, 17, 18,
2958  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2959  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2960  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
2961  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2962  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2963  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2964  0, 0, 0, 0, 205, 0, 0, 206, 52, 0,
2965  53, 54, 0, 0, 0, 0, 56, 57, 58, 59,
2966  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2967  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2968  0, 0, 10, 11, 65, 210, 67, 12, 0, 13,
2969  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2970  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2971  27, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2972  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2973  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2974  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2975  0, 0, 0, 0, 0, 0, 0, 0, 0, 205,
2976  0, 0, 206, 52, 0, 53, 54, 0, 0, 0,
2977  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
2978  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2979  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
2980  66, 67, 12, 0, 13, 14, 15, 241, 242, 18,
2981  19, 0, 0, 0, 0, 0, 243, 244, 245, 23,
2982  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
2983  0, 0, 271, 0, 0, 32, 33, 34, 35, 36,
2984  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2985  45, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2986  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2987  0, 0, 0, 0, 272, 0, 0, 325, 52, 0,
2988  53, 54, 0, 326, 0, 0, 56, 57, 58, 59,
2989  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2990  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2991  0, 0, 0, 12, 273, 13, 14, 15, 241, 242,
2992  18, 19, 0, 0, 0, 0, 0, 243, 244, 245,
2993  23, 24, 25, 26, 0, 0, 203, 0, 0, 0,
2994  0, 0, 0, 271, 0, 0, 32, 33, 34, 35,
2995  36, 37, 38, 39, 40, 0, 41, 42, 43, 44,
2996  0, 45, 46, 47, 0, 0, 0, 0, 0, 0,
2997  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2998  0, 0, 0, 0, 0, 367, 0, 0, 51, 52,
2999  0, 53, 54, 0, 55, 0, 0, 56, 57, 58,
3000  59, 60, 61, 62, 63, 64, 0, 0, 0, 0,
3001  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
3002  11, 0, 0, 0, 12, 273, 13, 14, 15, 241,
3003  242, 18, 19, 0, 0, 0, 0, 0, 243, 244,
3004  245, 23, 24, 25, 26, 0, 0, 203, 0, 0,
3005  0, 0, 0, 0, 271, 0, 0, 32, 33, 34,
3006  375, 36, 37, 38, 376, 40, 0, 41, 42, 43,
3007  44, 0, 45, 46, 47, 0, 0, 0, 0, 0,
3008  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3009  0, 0, 0, 377, 0, 0, 378, 0, 0, 206,
3010  52, 0, 53, 54, 0, 0, 0, 0, 56, 57,
3011  58, 59, 60, 61, 62, 63, 64, 0, 0, 0,
3012  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
3013  10, 11, 0, 0, 0, 12, 273, 13, 14, 15,
3014  241, 242, 18, 19, 0, 0, 0, 0, 0, 243,
3015  244, 245, 23, 24, 25, 26, 0, 0, 203, 0,
3016  0, 0, 0, 0, 0, 271, 0, 0, 32, 33,
3017  34, 375, 36, 37, 38, 376, 40, 0, 41, 42,
3018  43, 44, 0, 45, 46, 47, 0, 0, 0, 0,
3019  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3020  0, 0, 0, 0, 0, 0, 0, 378, 0, 0,
3021  206, 52, 0, 53, 54, 0, 0, 0, 0, 56,
3022  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
3023  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3024  0, 10, 11, 0, 0, 0, 12, 273, 13, 14,
3025  15, 241, 242, 18, 19, 0, 0, 0, 0, 0,
3026  243, 244, 245, 23, 24, 25, 26, 0, 0, 203,
3027  0, 0, 0, 0, 0, 0, 271, 0, 0, 32,
3028  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
3029  42, 43, 44, 0, 45, 46, 47, 0, 0, 0,
3030  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3031  0, 0, 0, 0, 0, 0, 0, 0, 272, 0,
3032  0, 325, 52, 0, 53, 54, 0, 0, 0, 0,
3033  56, 57, 58, 59, 60, 61, 62, 63, 64, 0,
3034  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
3035  0, 0, 10, 11, 0, 0, 0, 12, 273, 13,
3036  14, 15, 241, 242, 18, 19, 0, 0, 0, 0,
3037  0, 243, 244, 245, 23, 24, 25, 26, 0, 0,
3038  203, 0, 0, 0, 0, 0, 0, 271, 0, 0,
3039  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
3040  41, 42, 43, 44, 0, 45, 46, 47, 0, 0,
3041  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3042  0, 0, 0, 0, 0, 0, 0, 0, 0, 897,
3043  0, 0, 206, 52, 0, 53, 54, 0, 0, 0,
3044  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
3045  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
3046  0, 0, 0, 10, 11, 0, 0, 0, 12, 273,
3047  13, 14, 15, 241, 242, 18, 19, 0, 0, 0,
3048  0, 0, 243, 244, 245, 23, 24, 25, 26, 0,
3049  0, 203, 0, 0, 0, 0, 0, 0, 271, 0,
3050  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3051  0, 41, 42, 43, 44, 0, 45, 46, 47, 0,
3052  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3053  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3054  975, 0, 0, 206, 52, 0, 53, 54, 0, 0,
3055  0, 0, 56, 57, 58, 59, 60, 61, 62, 63,
3056  64, 0, 0, 0, 0, 554, 555, 0, 0, 556,
3057  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3058  273, 165, 166, 167, 168, 169, 170, 171, 172, 173,
3059  0, 0, 174, 175, 0, 0, 176, 177, 178, 179,
3060  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3061  180, 181, 0, 0, 0, 0, 0, 0, 0, 0,
3062  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3063  0, 182, 183, 184, 185, 186, 187, 188, 189, 190,
3064  191, 0, 192, 193, 562, 563, 0, 0, 564, 0,
3065  194, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3066  165, 166, 167, 168, 169, 170, 171, 172, 173, 0,
3067  0, 174, 175, 0, 0, 176, 177, 178, 179, 0,
3068  0, 0, 0, 0, 0, 0, 0, 0, 0, 180,
3069  181, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3070  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3071  182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
3072  0, 192, 193, 599, 563, 0, 0, 600, 0, 194,
3073  0, 0, 0, 0, 0, 0, 0, 0, 0, 165,
3074  166, 167, 168, 169, 170, 171, 172, 173, 0, 0,
3075  174, 175, 0, 0, 176, 177, 178, 179, 0, 0,
3076  0, 0, 0, 0, 0, 0, 0, 0, 180, 181,
3077  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3078  0, 0, 0, 0, 0, 0, 0, 0, 0, 182,
3079  183, 184, 185, 186, 187, 188, 189, 190, 191, 0,
3080  192, 193, 613, 555, 0, 0, 614, 0, 194, 0,
3081  0, 0, 0, 0, 0, 0, 0, 0, 165, 166,
3082  167, 168, 169, 170, 171, 172, 173, 0, 0, 174,
3083  175, 0, 0, 176, 177, 178, 179, 0, 0, 0,
3084  0, 0, 0, 0, 0, 0, 0, 180, 181, 0,
3085  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3086  0, 0, 0, 0, 0, 0, 0, 0, 182, 183,
3087  184, 185, 186, 187, 188, 189, 190, 191, 0, 192,
3088  193, 616, 563, 0, 0, 617, 0, 194, 0, 0,
3089  0, 0, 0, 0, 0, 0, 0, 165, 166, 167,
3090  168, 169, 170, 171, 172, 173, 0, 0, 174, 175,
3091  0, 0, 176, 177, 178, 179, 0, 0, 0, 0,
3092  0, 0, 0, 0, 0, 0, 180, 181, 0, 0,
3093  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3094  0, 0, 0, 0, 0, 0, 0, 182, 183, 184,
3095  185, 186, 187, 188, 189, 190, 191, 0, 192, 193,
3096  640, 555, 0, 0, 641, 0, 194, 0, 0, 0,
3097  0, 0, 0, 0, 0, 0, 165, 166, 167, 168,
3098  169, 170, 171, 172, 173, 0, 0, 174, 175, 0,
3099  0, 176, 177, 178, 179, 0, 0, 0, 0, 0,
3100  0, 0, 0, 0, 0, 180, 181, 0, 0, 0,
3101  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3102  0, 0, 0, 0, 0, 0, 182, 183, 184, 185,
3103  186, 187, 188, 189, 190, 191, 0, 192, 193, 643,
3104  563, 0, 0, 644, 0, 194, 0, 0, 0, 0,
3105  0, 0, 0, 0, 0, 165, 166, 167, 168, 169,
3106  170, 171, 172, 173, 0, 0, 174, 175, 0, 0,
3107  176, 177, 178, 179, 0, 0, 0, 0, 0, 0,
3108  0, 0, 0, 0, 180, 181, 0, 0, 0, 0,
3109  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3110  0, 0, 0, 0, 0, 182, 183, 184, 185, 186,
3111  187, 188, 189, 190, 191, 0, 192, 193, 728, 555,
3112  0, 0, 729, 0, 194, 0, 0, 0, 0, 0,
3113  0, 0, 0, 0, 165, 166, 167, 168, 169, 170,
3114  171, 172, 173, 0, 0, 174, 175, 0, 0, 176,
3115  177, 178, 179, 0, 0, 0, 0, 0, 0, 0,
3116  0, 0, 0, 180, 181, 0, 0, 0, 0, 0,
3117  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3118  0, 0, 0, 0, 182, 183, 184, 185, 186, 187,
3119  188, 189, 190, 191, 0, 192, 193, 731, 563, 0,
3120  0, 732, 0, 194, 0, 0, 0, 0, 0, 0,
3121  0, 0, 0, 165, 166, 167, 168, 169, 170, 171,
3122  172, 173, 0, 0, 174, 175, 0, 0, 176, 177,
3123  178, 179, 0, 0, 0, 0, 0, 0, 0, 0,
3124  0, 0, 180, 181, 0, 0, 0, 0, 0, 0,
3125  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3126  0, 0, 0, 182, 183, 184, 185, 186, 187, 188,
3127  189, 190, 191, 0, 192, 193, 738, 555, 0, 0,
3128  739, 0, 194, 0, 0, 0, 0, 0, 0, 0,
3129  0, 0, 165, 166, 167, 168, 169, 170, 171, 172,
3130  173, 0, 0, 174, 175, 0, 0, 176, 177, 178,
3131  179, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3132  0, 180, 181, 0, 0, 0, 0, 0, 0, 0,
3133  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3134  0, 0, 182, 183, 184, 185, 186, 187, 188, 189,
3135  190, 191, 0, 192, 193, 1007, 555, 0, 0, 1008,
3136  0, 194, 0, 0, 0, 0, 0, 0, 0, 0,
3137  0, 165, 166, 167, 168, 169, 170, 171, 172, 173,
3138  0, 0, 174, 175, 0, 0, 176, 177, 178, 179,
3139  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3140  180, 181, 0, 0, 0, 0, 0, 0, 0, 0,
3141  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3142  0, 182, 183, 184, 185, 186, 187, 188, 189, 190,
3143  191, 0, 192, 193, 1040, 555, 0, 0, 1041, 0,
3144  194, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3145  165, 166, 167, 168, 169, 170, 171, 172, 173, 0,
3146  0, 174, 175, 0, 0, 176, 177, 178, 179, 0,
3147  0, 0, 0, 0, 0, 0, 0, 0, 0, 180,
3148  181, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3149  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3150  182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
3151  0, 192, 193, 1043, 563, 0, 0, 1044, 0, 194,
3152  0, 0, 0, 0, 0, 0, 0, 0, 0, 165,
3153  166, 167, 168, 169, 170, 171, 172, 173, 0, 0,
3154  174, 175, 0, 0, 176, 177, 178, 179, 0, 0,
3155  0, 0, 0, 0, 0, 0, 0, 0, 180, 181,
3156  329, 330, 331, 332, 333, 334, 335, 336, 337, 338,
3157  339, 340, 341, 0, 0, 342, 343, 0, 0, 182,
3158  183, 184, 185, 186, 187, 188, 189, 190, 191, 0,
3159  192, 193, 0, 0, 0, 0, 0, 0, 194, 0,
3160  0, 0, 0, 0, 0, 0, 344, 0, 345, 346,
3161  347, 348, 349, 350, 351, 352, 353, 354, 0, 0,
3162  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3163  0, 0, 0, 234
3164 };
3165 
3166 #define yypact_value_is_default(yystate) \
3167  ((yystate) == (-813))
3168 
3169 #define yytable_value_is_error(yytable_value) \
3170  ((yytable_value) == (-628))
3171 
3172 static const yytype_int16 yycheck[] =
3173 {
3174  2, 27, 98, 29, 57, 81, 16, 17, 8, 76,
3175  20, 8, 16, 17, 8, 328, 20, 361, 89, 22,
3176  576, 92, 51, 28, 414, 88, 89, 328, 28, 92,
3177  422, 28, 422, 4, 28, 54, 355, 578, 357, 356,
3178  55, 69, 223, 96, 670, 2, 92, 4, 575, 53,
3179  615, 53, 54, 378, 65, 595, 69, 2, 265, 4,
3180  57, 778, 269, 55, 92, 233, 81, 51, 460, 473,
3181  686, 16, 17, 76, 469, 20, 787, 642, 93, 94,
3182  95, 442, 401, 508, 13, 716, 511, 66, 872, 720,
3183  258, 25, 27, 261, 906, 253, 63, 78, 417, 96,
3184  419, 418, 29, 89, 874, 25, 51, 63, 143, 87,
3185  55, 0, 775, 87, 16, 17, 89, 138, 20, 25,
3186  132, 66, 143, 26, 519, 13, 445, 87, 56, 115,
3187  37, 38, 28, 25, 16, 17, 81, 800, 20, 120,
3188  13, 99, 115, 88, 89, 112, 25, 92, 93, 94,
3189  95, 53, 54, 472, 471, 939, 112, 135, 102, 13,
3190  25, 135, 778, 136, 122, 730, 25, 325, 26, 139,
3191  233, 787, 235, 143, 134, 135, 741, 206, 895, 246,
3192  806, 807, 13, 142, 725, 204, 113, 25, 207, 208,
3193  209, 52, 289, 13, 291, 56, 293, 737, 274, 262,
3194  297, 742, 136, 1015, 138, 745, 141, 136, 143, 255,
3195  994, 240, 141, 1, 143, 217, 136, 227, 138, 229,
3196  230, 223, 992, 227, 253, 229, 142, 255, 230, 132,
3197  136, 623, 622, 623, 951, 946, 143, 142, 309, 310,
3198  311, 312, 255, 1027, 136, 271, 309, 310, 311, 312,
3199  431, 314, 315, 141, 658, 143, 424, 136, 884, 274,
3200  428, 206, 273, 582, 581, 433, 691, 592, 141, 253,
3201  143, 136, 633, 902, 132, 594, 593, 136, 142, 895,
3202  138, 449, 227, 115, 229, 230, 902, 141, 233, 143,
3203  235, 362, 363, 1010, 251, 240, 325, 928, 136, 362,
3204  363, 25, 697, 844, 323, 846, 251, 138, 253, 328,
3205  141, 326, 143, 25, 377, 856, 115, 262, 364, 323,
3206  861, 141, 89, 143, 328, 227, 853, 229, 136, 274,
3207  946, 119, 89, 89, 326, 658, 364, 308, 26, 965,
3208  744, 325, 746, 136, 323, 227, 356, 229, 115, 328,
3209  518, 308, 380, 141, 356, 143, 313, 138, 87, 115,
3210  357, 37, 38, 308, 309, 310, 311, 312, 313, 314,
3211  315, 141, 928, 143, 1003, 89, 25, 115, 323, 87,
3212  325, 326, 726, 328, 925, 926, 56, 1003, 87, 486,
3213  930, 115, 26, 469, 413, 414, 493, 698, 136, 87,
3214  115, 115, 715, 422, 401, 134, 135, 70, 418, 63,
3215  63, 356, 136, 358, 136, 139, 418, 362, 363, 143,
3216  136, 744, 419, 746, 136, 404, 405, 135, 430, 431,
3217  637, 612, 377, 90, 439, 134, 135, 89, 457, 439,
3218  442, 460, 439, 519, 132, 439, 134, 135, 445, 990,
3219  138, 991, 138, 87, 469, 109, 109, 111, 111, 404,
3220  405, 471, 125, 126, 127, 136, 115, 136, 636, 471,
3221  89, 87, 143, 418, 143, 472, 868, 1042, 868, 63,
3222  138, 87, 1023, 67, 1025, 442, 132, 136, 142, 142,
3223  139, 558, 70, 512, 143, 70, 115, 442, 132, 566,
3224  134, 135, 138, 136, 519, 507, 508, 452, 139, 511,
3225  143, 52, 414, 54, 55, 56, 57, 543, 672, 135,
3226  674, 26, 87, 115, 469, 109, 471, 111, 134, 135,
3227  704, 26, 138, 596, 601, 561, 52, 711, 54, 55,
3228  56, 57, 571, 140, 573, 87, 574, 575, 123, 124,
3229  125, 126, 127, 133, 87, 457, 559, 15, 577, 17,
3230  588, 89, 638, 626, 567, 63, 56, 569, 136, 134,
3231  135, 581, 916, 577, 519, 743, 63, 112, 922, 581,
3232  761, 112, 87, 593, 70, 582, 63, 115, 112, 615,
3233  609, 593, 87, 135, 762, 136, 473, 594, 601, 601,
3234  112, 606, 135, 622, 623, 773, 606, 87, 136, 606,
3235  612, 109, 606, 111, 112, 89, 642, 686, 96, 87,
3236  136, 697, 109, 638, 111, 112, 571, 132, 573, 134,
3237  135, 633, 109, 138, 111, 112, 581, 132, 705, 134,
3238  135, 115, 686, 138, 58, 712, 89, 666, 593, 87,
3239  595, 596, 87, 749, 134, 135, 70, 87, 687, 17,
3240  686, 690, 733, 692, 136, 736, 668, 135, 670, 87,
3241  733, 141, 115, 736, 56, 694, 633, 87, 14, 15,
3242  25, 626, 697, 139, 98, 99, 136, 136, 633, 691,
3243  132, 87, 860, 638, 747, 136, 715, 135, 142, 134,
3244  135, 1020, 1019, 871, 730, 135, 734, 87, 122, 133,
3245  712, 715, 781, 715, 716, 741, 718, 135, 720, 698,
3246  622, 63, 701, 702, 134, 135, 142, 881, 882, 708,
3247  709, 87, 886, 136, 888, 87, 890, 781, 134, 135,
3248  89, 785, 687, 136, 136, 690, 136, 692, 63, 775,
3249  747, 115, 697, 698, 134, 135, 701, 702, 777, 761,
3250  87, 138, 686, 708, 709, 10, 115, 109, 87, 111,
3251  112, 8, 843, 686, 800, 652, 89, 89, 134, 135,
3252  843, 658, 134, 135, 13, 138, 815, 136, 733, 804,
3253  133, 736, 737, 115, 109, 89, 111, 112, 817, 2,
3254  745, 4, 115, 115, 806, 807, 89, 134, 135, 686,
3255  136, 840, 136, 16, 17, 134, 135, 20, 847, 848,
3256  52, 115, 851, 136, 136, 853, 895, 855, 136, 54,
3257  899, 850, 115, 902, 862, 904, 838, 136, 52, 841,
3258  65, 66, 136, 136, 998, 999, 1000, 1001, 51, 868,
3259  829, 895, 52, 136, 136, 899, 117, 15, 902, 804,
3260  904, 140, 891, 66, 136, 70, 133, 744, 136, 746,
3261  815, 120, 115, 136, 787, 141, 136, 790, 136, 894,
3262  85, 86, 884, 136, 829, 88, 89, 10, 10, 92,
3263  919, 133, 769, 770, 90, 840, 1050, 136, 843, 9,
3264  915, 778, 847, 848, 139, 136, 851, 120, 136, 136,
3265  787, 56, 136, 136, 943, 944, 133, 122, 123, 124,
3266  125, 126, 127, 110, 136, 52, 928, 54, 55, 56,
3267  57, 56, 136, 10, 1003, 136, 1005, 136, 136, 54,
3268  55, 1010, 57, 1012, 136, 971, 891, 136, 133, 894,
3269  65, 66, 981, 136, 983, 136, 138, 70, 138, 1003,
3270  989, 1005, 93, 965, 91, 95, 1010, 452, 1012, 712,
3271  915, 895, 85, 86, 919, 899, 686, 1022, 902, 769,
3272  904, 809, 810, 1052, 1015, 930, 750, 1021, 297, 902,
3273  101, 904, 59, 96, 936, 872, 781, 874, 943, 944,
3274  899, 895, 52, 206, 54, 55, 56, 57, 1052, 1019,
3275  123, 124, 125, 126, 127, 778, 1042, 1019, 895, 1021,
3276  1022, -1, 398, 1020, 227, 902, 229, 230, -1, -1,
3277  233, -1, 235, 946, -1, 948, 981, 240, 983, -1,
3278  953, 91, -1, -1, 989, -1, 991, 97, 251, -1,
3279  253, -1, 52, -1, 54, 55, 56, 57, -1, 262,
3280  -1, -1, 939, 940, 59, 60, 61, 62, 52, 946,
3281  54, 55, 56, 57, 1019, -1, -1, -1, -1, 1003,
3282  -1, 1005, -1, -1, -1, -1, 1010, -1, 1012, -1,
3283  1003, 91, 1005, -1, -1, -1, -1, 97, -1, 1012,
3284  40, 41, 42, 43, 44, 308, 309, 310, 311, 312,
3285  313, 314, 315, -1, -1, 992, -1, 994, 1031, -1,
3286  323, -1, 325, -1, -1, 328, 1003, -1, 1052, -1,
3287  -1, -1, 960, 961, -1, -1, -1, -1, 966, 1052,
3288  968, 969, -1, 16, 17, -1, -1, 20, -1, -1,
3289  1027, -1, -1, 356, -1, 358, -1, -1, -1, 362,
3290  363, -1, -1, -1, -1, -1, -1, 52, -1, 54,
3291  55, 56, 57, 58, 377, 48, 49, -1, -1, -1,
3292  53, 54, -1, -1, -1, 70, -1, -1, -1, -1,
3293  -1, -1, -1, 66, 67, -1, -1, -1, -1, -1,
3294  -1, 404, 405, -1, -1, -1, 91, 1035, 1036, 1037,
3295  1038, -1, 97, 98, 99, 418, 52, -1, 54, 55,
3296  56, 57, 58, -1, -1, -1, -1, -1, -1, -1,
3297  1058, -1, -1, -1, 70, -1, -1, 122, -1, 442,
3298  125, -1, -1, -1, -1, -1, -1, -1, -1, 452,
3299  -1, -1, -1, -1, -1, 91, 0, -1, 143, -1,
3300  -1, 97, 98, 99, 8, 9, 10, -1, 471, 13,
3301  14, 15, 52, 17, 54, 55, 56, 57, 58, -1,
3302  -1, -1, 26, 27, -1, -1, 122, -1, -1, 125,
3303  70, -1, -1, 37, 38, -1, 40, 41, 42, 43,
3304  44, -1, 138, -1, -1, -1, -1, -1, -1, -1,
3305  -1, 91, -1, -1, -1, -1, -1, 97, 98, 99,
3306  -1, -1, -1, 2, -1, 4, -1, -1, -1, -1,
3307  -1, 204, -1, -1, 207, 208, 209, 210, -1, -1,
3308  -1, -1, 122, 87, -1, 125, -1, -1, -1, -1,
3309  -1, -1, -1, -1, 227, -1, 229, 230, -1, 52,
3310  -1, 54, 55, 56, 57, 58, 110, -1, 571, -1,
3311  573, -1, 51, -1, -1, -1, 55, 70, 581, -1,
3312  -1, -1, -1, -1, -1, 70, -1, -1, 132, 133,
3313  593, 135, 595, 596, 138, 139, -1, 141, 91, 143,
3314  85, 86, 81, -1, -1, 98, 99, -1, -1, -1,
3315  -1, -1, -1, -1, 93, 94, 95, 96, -1, -1,
3316  -1, -1, -1, 626, -1, -1, -1, -1, -1, 122,
3317  633, -1, -1, -1, -1, 120, 121, 122, 123, 124,
3318  125, 126, 127, -1, -1, -1, -1, -1, -1, -1,
3319  323, -1, -1, -1, -1, 328, 329, 330, 331, 332,
3320  333, 334, 335, 336, 337, 338, 339, 340, 341, 342,
3321  343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
3322  353, 354, -1, 356, 687, -1, -1, 690, -1, 692,
3323  -1, -1, -1, -1, -1, 698, -1, -1, 701, 702,
3324  -1, -1, -1, -1, -1, 708, 709, -1, -1, -1,
3325  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3326  -1, -1, -1, -1, -1, -1, 2, 206, 4, -1,
3327  733, 404, 405, 736, 737, -1, -1, -1, -1, 412,
3328  413, 414, 745, -1, -1, 418, -1, 420, 421, 422,
3329  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3330  -1, 240, -1, -1, -1, -1, -1, -1, 441, -1,
3331  -1, -1, 251, 446, 253, 51, -1, -1, -1, 55,
3332  -1, -1, -1, -1, 457, -1, -1, 460, -1, -1,
3333  -1, -1, -1, -1, -1, 274, -1, -1, 471, -1,
3334  -1, -1, -1, -1, -1, 81, 2, -1, 4, -1,
3335  -1, -1, 815, -1, -1, -1, -1, 93, 94, 95,
3336  96, -1, -1, -1, 497, -1, 829, -1, -1, 308,
3337  -1, -1, -1, -1, 313, -1, -1, 840, -1, 512,
3338  843, -1, -1, -1, 847, 848, 325, 326, 851, -1,
3339  -1, -1, -1, -1, -1, 51, -1, -1, -1, 55,
3340  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3341  -1, -1, -1, -1, -1, -1, -1, -1, -1, 358,
3342  -1, -1, -1, -1, -1, 81, -1, -1, 891, -1,
3343  -1, -1, -1, -1, -1, -1, -1, 93, 94, 95,
3344  -1, -1, -1, -1, 577, -1, -1, -1, 581, -1,
3345  -1, -1, -1, -1, -1, -1, 919, -1, -1, -1,
3346  593, -1, -1, -1, -1, -1, -1, 930, -1, -1,
3347  206, -1, -1, -1, -1, -1, 609, -1, -1, -1,
3348  943, 944, -1, -1, -1, -1, -1, -1, -1, 622,
3349  623, 70, 71, 72, 73, 74, 75, 76, 77, -1,
3350  79, 80, -1, 442, 240, -1, 85, 86, -1, -1,
3351  -1, -1, -1, 452, -1, 251, -1, 253, 981, -1,
3352  983, -1, -1, -1, -1, 2, 989, 4, 991, -1,
3353  469, -1, -1, 666, -1, -1, -1, -1, 274, 118,
3354  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
3355  206, -1, -1, -1, -1, -1, 1019, -1, -1, -1,
3356  -1, 694, -1, -1, -1, 698, 699, -1, 701, 702,
3357  -1, -1, 308, -1, 51, 708, 709, 313, -1, -1,
3358  519, -1, 715, -1, 240, -1, -1, -1, -1, 325,
3359  326, -1, -1, -1, -1, 251, -1, 253, -1, -1,
3360  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3361  -1, -1, -1, -1, -1, -1, 93, -1, 274, 752,
3362  -1, -1, 358, 756, 757, -1, 759, 760, -1, -1,
3363  -1, -1, 571, -1, 573, -1, -1, -1, -1, -1,
3364  -1, -1, -1, -1, 777, -1, -1, -1, -1, -1,
3365  -1, -1, 308, -1, -1, -1, 595, 313, -1, -1,
3366  -1, -1, -1, -1, -1, -1, -1, -1, -1, 325,
3367  326, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3368  -1, -1, -1, -1, 817, -1, -1, 2, 821, 4,
3369  -1, -1, -1, -1, 633, -1, 829, -1, -1, 638,
3370  -1, -1, 358, -1, -1, -1, 442, -1, -1, -1,
3371  -1, -1, -1, -1, -1, -1, 452, 850, -1, -1,
3372  -1, -1, -1, -1, -1, -1, -1, -1, -1, 206,
3373  -1, -1, -1, 469, 867, 868, 51, -1, -1, -1,
3374  -1, -1, -1, -1, -1, -1, -1, -1, 687, -1,
3375  -1, 690, -1, 692, -1, -1, -1, -1, 697, -1,
3376  -1, -1, -1, 240, -1, -1, -1, -1, -1, -1,
3377  -1, -1, -1, -1, 251, -1, 253, -1, -1, -1,
3378  -1, -1, -1, 519, -1, -1, 442, -1, -1, -1,
3379  -1, -1, 44, -1, -1, -1, 452, -1, 737, -1,
3380  -1, -1, -1, -1, -1, -1, 745, -1, -1, -1,
3381  -1, -1, -1, 469, -1, -1, -1, -1, 70, 71,
3382  72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
3383  82, 308, -1, 85, 86, 571, 313, 573, -1, -1,
3384  -1, -1, -1, -1, -1, -1, -1, -1, 325, -1,
3385  -1, 328, -1, -1, -1, -1, -1, -1, -1, 595,
3386  -1, -1, -1, 519, 116, 804, 118, 119, 120, 121,
3387  122, 123, 124, 125, 126, 127, 815, -1, -1, -1,
3388  -1, 358, -1, -1, 136, -1, 1019, -1, -1, -1,
3389  -1, 206, -1, -1, -1, -1, -1, 633, -1, -1,
3390  -1, 840, 638, -1, -1, -1, -1, -1, 847, 848,
3391  -1, -1, 851, -1, -1, 571, -1, 573, -1, -1,
3392  -1, -1, -1, -1, -1, 240, -1, -1, -1, -1,
3393  -1, -1, -1, -1, -1, -1, 251, -1, 253, 595,
3394  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3395  -1, 687, 891, -1, 690, 894, 692, -1, -1, -1,
3396  -1, 697, -1, -1, -1, 442, -1, -1, -1, -1,
3397  -1, -1, -1, -1, -1, 452, 915, 633, -1, -1,
3398  919, -1, 638, -1, -1, -1, -1, -1, -1, -1,
3399  -1, 930, -1, 308, -1, -1, -1, -1, 313, -1,
3400  -1, 737, -1, -1, 943, 944, -1, -1, -1, 745,
3401  325, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3402  -1, -1, 678, -1, -1, -1, -1, -1, -1, -1,
3403  -1, 687, -1, -1, 690, -1, 692, -1, -1, -1,
3404  -1, 697, 981, 358, 983, -1, -1, -1, -1, -1,
3405  989, -1, 991, -1, -1, -1, -1, -1, -1, -1,
3406  -1, -1, -1, -1, -1, -1, -1, -1, 804, -1,
3407  -1, -1, -1, -1, -1, -1, -1, -1, -1, 815,
3408  -1, 737, -1, -1, -1, -1, -1, -1, -1, 745,
3409  -1, -1, -1, -1, 571, -1, 573, -1, -1, -1,
3410  -1, -1, -1, -1, 840, -1, -1, -1, -1, -1,
3411  -1, 847, 848, -1, -1, 851, -1, -1, 595, 70,
3412  71, 72, 73, 74, 75, 76, -1, 442, 79, 80,
3413  -1, -1, -1, -1, 85, 86, -1, 452, -1, -1,
3414  -1, -1, -1, -1, -1, -1, -1, -1, 804, -1,
3415  -1, -1, -1, -1, -1, 891, 633, -1, 894, 815,
3416  -1, -1, -1, -1, -1, -1, -1, 118, 119, 120,
3417  121, 122, 123, 124, 125, 126, 127, -1, -1, 915,
3418  -1, -1, -1, 919, 840, -1, -1, -1, -1, -1,
3419  -1, 847, 848, -1, 930, 851, -1, -1, -1, -1,
3420  -1, -1, -1, -1, -1, -1, -1, 943, 944, -1,
3421  687, -1, -1, 690, -1, 692, -1, -1, -1, -1,
3422  -1, 698, -1, -1, -1, -1, -1, -1, -1, -1,
3423  -1, -1, -1, -1, -1, 891, -1, -1, 894, -1,
3424  -1, -1, -1, -1, -1, 981, -1, 983, -1, -1,
3425  -1, -1, -1, 989, -1, 991, 571, -1, 573, 915,
3426  737, -1, -1, 919, -1, -1, -1, -1, 745, 0,
3427  -1, -1, -1, -1, 930, -1, -1, 8, 9, 10,
3428  595, -1, 13, 14, 15, -1, 17, 943, 944, -1,
3429  -1, -1, -1, -1, -1, 26, 27, 28, 29, -1,
3430  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3431  41, 42, 43, 44, -1, -1, -1, -1, 633, -1,
3432  -1, -1, -1, -1, -1, 981, -1, 983, -1, -1,
3433  -1, -1, -1, 989, -1, 991, -1, -1, 815, 70,
3434  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3435  81, 82, -1, -1, 85, 86, 87, -1, 89, 90,
3436  -1, -1, -1, 840, -1, 96, -1, -1, -1, -1,
3437  847, 848, 687, -1, 851, 690, -1, 692, -1, 110,
3438  -1, -1, 113, -1, 115, 116, 117, 118, 119, 120,
3439  121, 122, 123, 124, 125, 126, 127, -1, -1, -1,
3440  -1, 132, 133, 134, 135, 136, -1, -1, 139, 140,
3441  141, -1, 143, -1, 891, -1, -1, -1, -1, -1,
3442  -1, -1, 737, -1, -1, -1, -1, -1, -1, -1,
3443  745, 70, 71, 72, 73, 74, 75, 76, 915, -1,
3444  79, 80, 919, -1, -1, -1, 85, 86, -1, -1,
3445  -1, -1, -1, 930, -1, -1, -1, -1, -1, -1,
3446  -1, -1, -1, -1, -1, -1, 943, 944, -1, -1,
3447  -1, -1, -1, -1, -1, -1, -1, -1, -1, 118,
3448  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
3449  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3450  815, -1, -1, -1, 981, -1, 983, -1, -1, -1,
3451  -1, -1, 989, -1, 991, -1, -1, -1, -1, -1,
3452  -1, -1, -1, -1, -1, 840, -1, -1, -1, -1,
3453  -1, -1, 847, 848, -1, -1, 851, -1, -1, -1,
3454  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3455  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3456  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3457  -1, -1, -1, -1, -1, -1, 891, -1, -1, -1,
3458  -1, -1, -1, -1, -1, -1, -1, 0, 1, -1,
3459  3, 4, 5, 6, 7, -1, -1, -1, 11, 12,
3460  -1, -1, -1, 16, 919, 18, 19, 20, 21, 22,
3461  23, 24, -1, -1, -1, 930, -1, 30, 31, 32,
3462  33, 34, 35, 36, -1, -1, 39, -1, 943, 944,
3463  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3464  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
3465  -1, 64, 65, 66, -1, 68, 69, -1, -1, -1,
3466  -1, -1, -1, -1, -1, -1, 981, -1, 983, -1,
3467  -1, -1, -1, -1, 989, 88, 991, -1, 91, 92,
3468  -1, 94, 95, -1, 97, -1, -1, 100, 101, 102,
3469  103, 104, 105, 106, 107, 108, 0, -1, -1, -1,
3470  -1, -1, -1, -1, 8, 9, 10, -1, -1, 13,
3471  14, 15, -1, 17, -1, 128, 129, 130, -1, 44,
3472  -1, 25, -1, 27, 28, 29, -1, -1, 141, -1,
3473  143, -1, -1, 37, 38, -1, 40, 41, 42, 43,
3474  44, -1, -1, -1, -1, 70, 71, 72, 73, 74,
3475  75, 76, 77, 78, 79, 80, 81, 82, -1, -1,
3476  85, 86, -1, -1, -1, -1, 70, 71, 72, 73,
3477  74, 75, 76, 77, 78, 79, 80, 81, 82, -1,
3478  -1, 85, 86, 87, -1, 89, 90, -1, -1, -1,
3479  -1, 116, 96, 118, 119, 120, 121, 122, 123, 124,
3480  125, 126, 127, -1, -1, -1, 110, -1, -1, 113,
3481  -1, 115, 116, 117, 118, 119, 120, 121, 122, 123,
3482  124, 125, 126, 127, -1, -1, -1, -1, -1, 133,
3483  134, 135, 136, 0, -1, 139, 140, 141, -1, 143,
3484  -1, 8, 9, 10, -1, -1, 13, 14, 15, -1,
3485  17, -1, -1, -1, -1, -1, 44, -1, 25, -1,
3486  27, 28, 29, -1, -1, -1, -1, -1, -1, -1,
3487  37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
3488  -1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
3489  78, 79, 80, 81, 82, -1, -1, 85, 86, -1,
3490  -1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
3491  77, 78, 79, 80, 81, 82, -1, -1, 85, 86,
3492  87, -1, 89, 90, -1, -1, -1, -1, 116, 96,
3493  118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
3494  -1, -1, -1, 110, -1, -1, 113, -1, 115, 116,
3495  117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
3496  127, -1, -1, -1, -1, -1, 133, 134, 135, 136,
3497  0, -1, 139, 140, 141, -1, 143, -1, 8, 9,
3498  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3499  -1, -1, -1, -1, -1, -1, 26, 27, 28, 29,
3500  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3501  40, 41, 42, 43, 44, -1, -1, -1, -1, 70,
3502  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3503  81, 82, -1, -1, 85, 86, -1, -1, -1, -1,
3504  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3505  80, 81, 82, -1, -1, 85, 86, 87, -1, -1,
3506  90, -1, -1, -1, -1, 116, 96, 118, 119, 120,
3507  121, 122, 123, 124, 125, 126, 127, -1, -1, -1,
3508  110, -1, -1, 113, -1, -1, 116, 117, 118, 119,
3509  120, 121, 122, 123, 124, 125, 126, 127, -1, -1,
3510  -1, -1, 132, 133, 134, 135, 136, 0, -1, 139,
3511  140, 141, -1, 143, -1, 8, 9, 10, -1, -1,
3512  13, 14, 15, -1, 17, -1, -1, -1, -1, -1,
3513  -1, -1, -1, 26, 27, 28, 29, -1, -1, -1,
3514  -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
3515  43, 44, -1, -1, -1, -1, 70, 71, 72, 73,
3516  74, 75, 76, 77, 78, 79, 80, 81, 82, -1,
3517  -1, 85, 86, -1, -1, -1, -1, 70, 71, 72,
3518  73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
3519  -1, -1, 85, 86, 87, -1, -1, 90, -1, -1,
3520  -1, -1, -1, 96, 118, 119, 120, 121, 122, 123,
3521  124, 125, 126, 127, -1, -1, -1, 110, -1, -1,
3522  113, -1, -1, 116, 117, 118, 119, 120, 121, 122,
3523  123, 124, 125, 126, 127, -1, -1, -1, -1, 132,
3524  133, 134, 135, 136, 0, -1, 139, 140, 141, -1,
3525  143, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3526  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3527  -1, 27, 28, 29, -1, -1, -1, -1, -1, -1,
3528  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3529  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3530  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3531  -1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
3532  76, 77, 78, 79, 80, 81, 82, -1, -1, 85,
3533  86, 87, -1, 89, 90, -1, -1, -1, -1, -1,
3534  96, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3535  -1, -1, -1, -1, 110, -1, -1, 113, -1, 115,
3536  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3537  126, 127, -1, -1, -1, -1, -1, 133, 134, 135,
3538  136, 0, -1, 139, 140, 141, -1, 143, -1, 8,
3539  9, 10, -1, -1, 13, 14, 15, -1, 17, -1,
3540  -1, -1, -1, -1, -1, -1, -1, 26, 27, 28,
3541  -1, -1, -1, -1, -1, -1, -1, -1, 37, 38,
3542  -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
3543  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3544  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3545  -1, 70, 71, 72, 73, 74, 75, 76, 77, 78,
3546  79, 80, 81, 82, -1, -1, 85, 86, 87, -1,
3547  -1, 90, -1, -1, -1, -1, -1, 96, -1, -1,
3548  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3549  -1, 110, -1, -1, -1, -1, -1, 116, -1, 118,
3550  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
3551  -1, -1, -1, 132, 133, 134, 135, 136, 0, 138,
3552  139, 140, 141, -1, 143, -1, 8, 9, 10, -1,
3553  -1, 13, 14, 15, -1, 17, -1, -1, -1, -1,
3554  -1, -1, -1, -1, -1, 27, 28, 29, -1, -1,
3555  -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
3556  42, 43, 44, -1, -1, -1, -1, -1, -1, -1,
3557  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3558  -1, -1, -1, -1, -1, -1, -1, -1, 70, 71,
3559  72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
3560  82, -1, -1, 85, 86, 87, -1, -1, 90, -1,
3561  -1, -1, -1, -1, 96, -1, -1, -1, -1, -1,
3562  -1, -1, -1, -1, -1, -1, -1, -1, 110, -1,
3563  -1, 113, -1, -1, 116, 117, 118, 119, 120, 121,
3564  122, 123, 124, 125, 126, 127, -1, -1, -1, -1,
3565  -1, 133, 134, 135, 136, 0, -1, 139, 140, 141,
3566  -1, 143, -1, 8, 9, 10, -1, -1, 13, 14,
3567  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3568  -1, 26, 27, 28, -1, -1, -1, -1, -1, -1,
3569  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3570  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3571  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3572  -1, -1, -1, -1, -1, 70, 71, 72, 73, 74,
3573  75, 76, 77, 78, 79, 80, 81, 82, -1, -1,
3574  85, 86, 87, -1, -1, 90, -1, -1, -1, -1,
3575  -1, 96, -1, -1, -1, -1, -1, -1, -1, -1,
3576  -1, -1, -1, -1, -1, 110, -1, -1, -1, -1,
3577  -1, 116, -1, 118, 119, 120, 121, 122, 123, 124,
3578  125, 126, 127, -1, -1, -1, -1, 132, 133, 134,
3579  135, 136, 0, 138, 139, 140, 141, -1, 143, -1,
3580  8, 9, 10, -1, -1, 13, 14, 15, -1, 17,
3581  -1, -1, -1, -1, -1, -1, -1, -1, -1, 27,
3582  28, -1, -1, -1, -1, -1, -1, -1, -1, 37,
3583  38, -1, 40, 41, 42, 43, 44, -1, -1, -1,
3584  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3585  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3586  -1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
3587  78, 79, 80, 81, 82, -1, -1, 85, 86, 87,
3588  -1, -1, 90, -1, -1, -1, -1, -1, 96, -1,
3589  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3590  -1, -1, 110, -1, -1, -1, -1, -1, 116, -1,
3591  118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
3592  -1, -1, -1, -1, -1, 133, 134, 135, 136, 0,
3593  138, 139, 140, 141, -1, 143, -1, 8, 9, 10,
3594  -1, -1, -1, 14, 15, -1, 17, -1, -1, -1,
3595  -1, -1, -1, -1, -1, 26, -1, -1, -1, -1,
3596  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3597  41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
3598  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3599  -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
3600  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3601  81, 82, -1, -1, 85, 86, 87, -1, 89, -1,
3602  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3603  -1, -1, -1, -1, -1, -1, -1, -1, -1, 110,
3604  -1, -1, -1, -1, 115, 116, -1, 118, 119, 120,
3605  121, 122, 123, 124, 125, 126, 127, -1, -1, -1,
3606  -1, 132, 133, 134, 135, 136, 0, -1, 139, -1,
3607  141, -1, 143, -1, 8, 9, 10, -1, -1, -1,
3608  14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
3609  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3610  -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
3611  44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3612  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3613  -1, -1, -1, -1, -1, -1, 70, 71, 72, 73,
3614  74, 75, 76, 77, 78, 79, 80, 81, 82, -1,
3615  -1, 85, 86, 87, -1, 89, -1, -1, -1, -1,
3616  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3617  -1, -1, -1, -1, -1, -1, 110, -1, -1, -1,
3618  -1, 115, 116, -1, 118, 119, 120, 121, 122, 123,
3619  124, 125, 126, 127, -1, -1, -1, -1, -1, 133,
3620  134, 135, 136, -1, -1, 139, -1, 141, 1, 143,
3621  3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
3622  -1, -1, 15, 16, -1, 18, 19, 20, 21, 22,
3623  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3624  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3625  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3626  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
3627  -1, 64, 65, 66, -1, 68, 69, -1, -1, -1,
3628  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3629  -1, -1, -1, -1, -1, 88, -1, -1, 91, 92,
3630  -1, 94, 95, -1, 97, -1, -1, 100, 101, 102,
3631  103, 104, 105, 106, 107, 108, -1, -1, -1, -1,
3632  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3633  -1, -1, -1, -1, -1, 128, 129, 130, -1, -1,
3634  -1, -1, -1, -1, -1, -1, -1, -1, 141, 1,
3635  143, 3, 4, 5, 6, 7, -1, -1, 10, 11,
3636  12, -1, 14, 15, 16, -1, 18, 19, 20, 21,
3637  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3638  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3639  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3640  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
3641  62, -1, 64, 65, 66, -1, 68, 69, -1, -1,
3642  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3643  -1, -1, -1, -1, -1, -1, 88, -1, -1, 91,
3644  92, -1, 94, 95, -1, 97, -1, -1, 100, 101,
3645  102, 103, 104, 105, 106, 107, 108, -1, -1, -1,
3646  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3647  -1, -1, -1, -1, -1, -1, 128, 129, 130, -1,
3648  -1, -1, -1, -1, -1, -1, -1, -1, -1, 141,
3649  1, 143, 3, 4, 5, 6, 7, -1, -1, 10,
3650  11, 12, -1, -1, 15, 16, 17, 18, 19, 20,
3651  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3652  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3653  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3654  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3655  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
3656  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3657  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
3658  91, 92, -1, 94, 95, -1, 97, -1, -1, 100,
3659  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
3660  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3661  -1, -1, -1, -1, -1, -1, -1, 128, 129, 130,
3662  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3663  141, 1, 143, 3, 4, 5, 6, 7, -1, -1,
3664  10, 11, 12, -1, -1, 15, 16, -1, 18, 19,
3665  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3666  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3667  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
3668  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3669  60, 61, 62, -1, 64, 65, 66, -1, 68, 69,
3670  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3671  -1, -1, -1, -1, -1, -1, -1, -1, 88, -1,
3672  -1, 91, 92, -1, 94, 95, -1, 97, -1, -1,
3673  100, 101, 102, 103, 104, 105, 106, 107, 108, -1,
3674  -1, -1, -1, -1, -1, -1, 1, -1, 3, 4,
3675  5, 6, 7, -1, 9, 10, 11, 12, 128, 129,
3676  130, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3677  -1, 141, -1, 143, -1, 30, 31, 32, 33, 34,
3678  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3679  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3680  55, 56, 57, -1, 59, 60, 61, 62, -1, 64,
3681  65, 66, -1, 68, 69, -1, -1, -1, -1, -1,
3682  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3683  -1, -1, -1, 88, -1, -1, 91, 92, -1, 94,
3684  95, -1, 97, -1, -1, 100, 101, 102, 103, 104,
3685  105, 106, 107, 108, -1, -1, -1, -1, -1, -1,
3686  -1, 1, -1, 3, 4, 5, 6, 7, -1, -1,
3687  -1, 11, 12, 128, 129, 130, 16, -1, 18, 19,
3688  20, 21, 22, 23, 24, -1, 141, -1, 143, -1,
3689  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3690  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
3691  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3692  60, 61, 62, -1, 64, 65, 66, -1, 68, 69,
3693  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3694  -1, -1, -1, -1, -1, -1, -1, -1, 88, -1,
3695  -1, 91, 92, -1, 94, 95, -1, 97, -1, -1,
3696  100, 101, 102, 103, 104, 105, 106, 107, 108, -1,
3697  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3698  -1, -1, -1, -1, -1, -1, -1, -1, 128, 129,
3699  130, -1, -1, -1, -1, -1, -1, -1, -1, 139,
3700  -1, 141, 1, 143, 3, 4, 5, 6, 7, -1,
3701  -1, -1, 11, 12, -1, -1, -1, 16, -1, 18,
3702  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3703  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3704  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3705  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3706  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3707  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3708  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3709  -1, -1, 91, 92, -1, 94, 95, -1, 97, -1,
3710  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3711  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3712  -1, -1, -1, -1, -1, -1, -1, -1, -1, 128,
3713  129, 130, -1, -1, -1, -1, -1, -1, -1, -1,
3714  139, -1, 141, 1, 143, 3, 4, 5, 6, 7,
3715  -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
3716  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3717  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3718  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
3719  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3720  -1, 59, 60, 61, 62, -1, 64, 65, 66, -1,
3721  68, 69, -1, -1, -1, -1, -1, -1, -1, -1,
3722  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3723  88, -1, -1, 91, 92, -1, 94, 95, -1, 97,
3724  -1, -1, 100, 101, 102, 103, 104, 105, 106, 107,
3725  108, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3726  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3727  128, 129, 130, -1, -1, 133, 1, -1, 3, 4,
3728  5, 6, 7, 141, -1, 143, 11, 12, -1, -1,
3729  -1, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3730  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3731  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3732  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3733  55, 56, 57, -1, 59, 60, 61, 62, -1, 64,
3734  65, 66, -1, 68, 69, -1, -1, -1, -1, -1,
3735  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3736  -1, -1, -1, 88, -1, -1, 91, 92, -1, 94,
3737  95, -1, 97, -1, -1, 100, 101, 102, 103, 104,
3738  105, 106, 107, 108, -1, -1, -1, -1, -1, -1,
3739  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3740  -1, -1, -1, 128, 129, 130, -1, -1, 133, -1,
3741  -1, -1, -1, -1, -1, -1, 141, 1, 143, 3,
3742  4, 5, 6, 7, -1, -1, 10, 11, 12, -1,
3743  -1, -1, 16, -1, 18, 19, 20, 21, 22, 23,
3744  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3745  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3746  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3747  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
3748  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3749  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3750  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3751  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
3752  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3753  -1, -1, 1, -1, 3, 4, 5, 6, 7, -1,
3754  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3755  19, 20, 21, 22, 23, 24, -1, 141, -1, 143,
3756  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3757  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3758  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3759  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3760  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3761  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3762  -1, -1, 91, 92, -1, 94, 95, -1, 97, -1,
3763  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3764  -1, 110, -1, -1, -1, -1, -1, -1, -1, 3,
3765  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
3766  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
3767  24, -1, 141, -1, 143, -1, 30, 31, 32, 33,
3768  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3769  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3770  54, 55, 56, 57, 58, 59, 60, 61, 62, -1,
3771  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3772  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3773  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3774  94, 95, -1, 97, 98, 99, 100, 101, 102, 103,
3775  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3776  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3777  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3778  19, 20, 21, 22, 23, 24, -1, -1, -1, 143,
3779  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3780  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3781  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3782  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3783  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3784  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3785  -1, -1, 91, 92, -1, 94, 95, -1, -1, -1,
3786  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3787  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3788  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
3789  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
3790  24, -1, 141, -1, 143, -1, 30, 31, 32, 33,
3791  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3792  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3793  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
3794  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3795  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3796  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3797  94, 95, -1, -1, -1, -1, 100, 101, 102, 103,
3798  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3799  -1, -1, -1, -1, 3, 4, 5, 6, 7, -1,
3800  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3801  19, 20, 21, 22, 23, 24, -1, -1, -1, 143,
3802  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3803  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3804  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3805  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3806  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3807  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3808  -1, -1, 91, 92, -1, 94, 95, -1, 97, -1,
3809  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3810  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3811  4, 5, 6, 7, -1, -1, -1, 11, 12, 128,
3812  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
3813  24, -1, 141, -1, -1, -1, 30, 31, 32, 33,
3814  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3815  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3816  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
3817  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3818  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3819  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3820  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
3821  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3822  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3823  -1, -1, -1, -1, 128, 129, 130, -1, -1, -1,
3824  -1, -1, -1, -1, -1, -1, -1, 141, 3, 4,
3825  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
3826  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
3827  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
3828  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
3829  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3830  55, 56, 57, -1, -1, -1, -1, -1, -1, -1,
3831  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
3832  75, 76, -1, -1, 79, 80, -1, -1, 83, 84,
3833  85, 86, -1, -1, -1, -1, -1, -1, -1, -1,
3834  -1, -1, 97, 98, -1, -1, -1, -1, -1, -1,
3835  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3836  -1, -1, -1, 118, 119, 120, 121, 122, 123, 124,
3837  125, 126, 127, -1, 129, 130, -1, -1, -1, -1,
3838  -1, -1, 137, 138, 3, 4, 5, 6, 7, 8,
3839  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
3840  19, 20, 21, 22, 23, 24, 25, 26, -1, -1,
3841  -1, 30, 31, 32, 33, 34, 35, 36, 37, 38,
3842  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3843  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
3844  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
3845  69, 70, 71, 72, 73, 74, 75, 76, -1, -1,
3846  79, 80, -1, -1, 83, 84, 85, 86, -1, -1,
3847  -1, -1, -1, -1, -1, -1, -1, -1, 97, 98,
3848  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3849  -1, -1, -1, -1, -1, -1, -1, -1, -1, 118,
3850  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
3851  129, 130, -1, -1, -1, -1, -1, -1, 137, 3,
3852  4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3853  14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
3854  24, 25, 26, -1, -1, -1, 30, 31, 32, 33,
3855  34, 35, 36, 37, 38, 39, -1, -1, -1, -1,
3856  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3857  54, -1, 56, -1, -1, -1, -1, -1, -1, -1,
3858  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
3859  74, 75, 76, -1, -1, 79, 80, -1, -1, 83,
3860  84, 85, 86, -1, -1, -1, -1, -1, -1, -1,
3861  -1, -1, -1, 97, 98, -1, -1, 101, -1, -1,
3862  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3863  -1, -1, -1, -1, 118, 119, 120, 121, 122, 123,
3864  124, 125, 126, 127, -1, 129, 130, -1, -1, -1,
3865  -1, -1, -1, 137, 3, 4, 5, 6, 7, 8,
3866  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
3867  19, 20, 21, 22, 23, 24, 25, 26, -1, -1,
3868  -1, 30, 31, 32, 33, 34, 35, 36, 37, 38,
3869  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3870  49, 50, 51, 52, 53, -1, -1, 56, -1, -1,
3871  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
3872  69, 70, 71, 72, 73, 74, 75, 76, -1, -1,
3873  79, 80, -1, -1, 83, 84, 85, 86, -1, -1,
3874  -1, -1, -1, -1, -1, -1, -1, -1, 97, 98,
3875  -1, -1, 101, -1, -1, -1, -1, -1, -1, -1,
3876  -1, -1, -1, -1, -1, -1, -1, -1, -1, 118,
3877  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
3878  129, 130, -1, -1, -1, -1, -1, -1, 137, 3,
3879  4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3880  14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
3881  24, 25, 26, -1, -1, -1, 30, 31, 32, 33,
3882  34, 35, 36, 37, 38, 39, -1, -1, -1, -1,
3883  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3884  -1, -1, 56, -1, -1, -1, -1, -1, -1, -1,
3885  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
3886  74, 75, 76, -1, -1, 79, 80, -1, -1, 83,
3887  84, 85, 86, -1, -1, -1, -1, -1, -1, -1,
3888  -1, -1, -1, 97, 98, -1, -1, -1, -1, -1,
3889  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3890  -1, -1, -1, -1, 118, 119, 120, 121, 122, 123,
3891  124, 125, 126, 127, -1, 129, 130, 3, 4, 5,
3892  -1, 7, -1, 137, -1, 11, 12, -1, -1, -1,
3893  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3894  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3895  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3896  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3897  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
3898  66, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3899  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3900  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
3901  -1, -1, -1, -1, 100, 101, 102, 103, 104, 105,
3902  106, 107, 108, -1, -1, -1, -1, -1, 3, 4,
3903  5, -1, 7, -1, -1, -1, 11, 12, -1, -1,
3904  -1, 16, 128, 18, 19, 20, 21, 22, 23, 24,
3905  136, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3906  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3907  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
3908  55, 56, 57, -1, 59, 60, 61, 62, -1, 64,
3909  65, 66, -1, -1, -1, -1, -1, -1, -1, -1,
3910  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3911  -1, -1, -1, 88, -1, -1, 91, 92, -1, 94,
3912  95, -1, -1, -1, -1, 100, 101, 102, 103, 104,
3913  105, 106, 107, 108, -1, -1, -1, -1, -1, 3,
3914  4, 5, 6, 7, -1, -1, -1, 11, 12, -1,
3915  -1, -1, 16, 128, 18, 19, 20, 21, 22, 23,
3916  24, 136, -1, -1, -1, -1, 30, 31, 32, 33,
3917  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3918  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3919  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
3920  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3921  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3922  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3923  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
3924  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3925  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3926  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3927  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3928  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3929  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3930  49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
3931  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3932  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3933  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3934  -1, -1, 91, 92, -1, 94, 95, -1, 97, 98,
3935  99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3936  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3937  4, 5, 6, 7, -1, -1, -1, 11, 12, 128,
3938  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
3939  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3940  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3941  -1, 45, 46, -1, 48, 49, 50, 51, 52, 53,
3942  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
3943  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3944  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3945  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3946  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
3947  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3948  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3949  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3950  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3951  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3952  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3953  49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
3954  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3955  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3956  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3957  -1, -1, 91, 92, -1, 94, 95, -1, 97, 98,
3958  99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3959  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3960  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
3961  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
3962  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3963  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3964  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3965  54, 55, 56, 57, 58, 59, 60, 61, 62, -1,
3966  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3967  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3968  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3969  94, 95, -1, 97, 98, -1, 100, 101, 102, 103,
3970  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3971  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3972  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3973  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3974  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3975  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3976  49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
3977  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
3978  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3979  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
3980  -1, -1, 91, 92, -1, 94, 95, -1, -1, 98,
3981  99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
3982  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
3983  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
3984  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
3985  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3986  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3987  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
3988  54, 55, 56, 57, 58, 59, 60, 61, 62, -1,
3989  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3990  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3991  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3992  94, 95, -1, 97, 98, -1, 100, 101, 102, 103,
3993  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3994  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
3995  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
3996  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
3997  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3998  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
3999  49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
4000  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4001  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4002  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
4003  -1, -1, 91, 92, -1, 94, 95, -1, -1, 98,
4004  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
4005  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4006  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
4007  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
4008  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4009  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4010  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4011  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4012  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
4013  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4014  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
4015  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
4016  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
4017  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4018  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
4019  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4020  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4021  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4022  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4023  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4024  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4025  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
4026  -1, -1, 91, 92, -1, 94, 95, -1, 97, -1,
4027  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
4028  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4029  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
4030  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
4031  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4032  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4033  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4034  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4035  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
4036  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4037  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
4038  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
4039  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
4040  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4041  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
4042  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4043  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4044  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4045  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4046  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4047  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4048  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
4049  -1, -1, 91, 92, -1, 94, 95, -1, 97, -1,
4050  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
4051  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4052  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
4053  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
4054  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4055  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4056  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4057  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4058  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
4059  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4060  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
4061  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
4062  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
4063  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4064  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
4065  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4066  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4067  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4068  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4069  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4070  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4071  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
4072  -1, -1, 91, 92, -1, 94, 95, -1, -1, -1,
4073  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
4074  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4075  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
4076  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
4077  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4078  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4079  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4080  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4081  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
4082  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4083  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
4084  94, 95, -1, -1, -1, -1, 100, 101, 102, 103,
4085  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
4086  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4087  -1, -1, 11, 12, 128, 129, 130, 16, -1, 18,
4088  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4089  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4090  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4091  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4092  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4093  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4094  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
4095  -1, -1, 91, 92, -1, 94, 95, -1, -1, -1,
4096  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
4097  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4098  4, 5, -1, 7, -1, -1, -1, 11, 12, 128,
4099  129, 130, 16, -1, 18, 19, 20, 21, 22, 23,
4100  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4101  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4102  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4103  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4104  64, 65, 66, -1, -1, -1, -1, -1, -1, -1,
4105  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4106  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
4107  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
4108  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
4109  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4110  -1, -1, -1, 16, 128, 18, 19, 20, 21, 22,
4111  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4112  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4113  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4114  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
4115  -1, 64, 65, 66, -1, -1, -1, -1, -1, -1,
4116  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4117  -1, -1, -1, -1, -1, 88, -1, -1, 91, 92,
4118  -1, 94, 95, -1, 97, -1, -1, 100, 101, 102,
4119  103, 104, 105, 106, 107, 108, -1, -1, -1, -1,
4120  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4121  12, -1, -1, -1, 16, 128, 18, 19, 20, 21,
4122  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4123  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4124  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4125  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4126  62, -1, 64, 65, 66, -1, -1, -1, -1, -1,
4127  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4128  -1, -1, -1, 85, -1, -1, 88, -1, -1, 91,
4129  92, -1, 94, 95, -1, -1, -1, -1, 100, 101,
4130  102, 103, 104, 105, 106, 107, 108, -1, -1, -1,
4131  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4132  11, 12, -1, -1, -1, 16, 128, 18, 19, 20,
4133  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4134  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4135  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4136  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4137  61, 62, -1, 64, 65, 66, -1, -1, -1, -1,
4138  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4139  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
4140  91, 92, -1, 94, 95, -1, -1, -1, -1, 100,
4141  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
4142  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4143  -1, 11, 12, -1, -1, -1, 16, 128, 18, 19,
4144  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4145  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4146  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4147  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4148  60, 61, 62, -1, 64, 65, 66, -1, -1, -1,
4149  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4150  -1, -1, -1, -1, -1, -1, -1, -1, 88, -1,
4151  -1, 91, 92, -1, 94, 95, -1, -1, -1, -1,
4152  100, 101, 102, 103, 104, 105, 106, 107, 108, -1,
4153  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4154  -1, -1, 11, 12, -1, -1, -1, 16, 128, 18,
4155  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4156  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4157  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4158  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4159  59, 60, 61, 62, -1, 64, 65, 66, -1, -1,
4160  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4161  -1, -1, -1, -1, -1, -1, -1, -1, -1, 88,
4162  -1, -1, 91, 92, -1, 94, 95, -1, -1, -1,
4163  -1, 100, 101, 102, 103, 104, 105, 106, 107, 108,
4164  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4165  -1, -1, -1, 11, 12, -1, -1, -1, 16, 128,
4166  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4167  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4168  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4169  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4170  -1, 59, 60, 61, 62, -1, 64, 65, 66, -1,
4171  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4172  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4173  88, -1, -1, 91, 92, -1, 94, 95, -1, -1,
4174  -1, -1, 100, 101, 102, 103, 104, 105, 106, 107,
4175  108, -1, -1, -1, -1, 52, 53, -1, -1, 56,
4176  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4177  128, 68, 69, 70, 71, 72, 73, 74, 75, 76,
4178  -1, -1, 79, 80, -1, -1, 83, 84, 85, 86,
4179  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4180  97, 98, -1, -1, -1, -1, -1, -1, -1, -1,
4181  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4182  -1, 118, 119, 120, 121, 122, 123, 124, 125, 126,
4183  127, -1, 129, 130, 52, 53, -1, -1, 56, -1,
4184  137, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4185  68, 69, 70, 71, 72, 73, 74, 75, 76, -1,
4186  -1, 79, 80, -1, -1, 83, 84, 85, 86, -1,
4187  -1, -1, -1, -1, -1, -1, -1, -1, -1, 97,
4188  98, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4189  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4190  118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
4191  -1, 129, 130, 52, 53, -1, -1, 56, -1, 137,
4192  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
4193  69, 70, 71, 72, 73, 74, 75, 76, -1, -1,
4194  79, 80, -1, -1, 83, 84, 85, 86, -1, -1,
4195  -1, -1, -1, -1, -1, -1, -1, -1, 97, 98,
4196  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4197  -1, -1, -1, -1, -1, -1, -1, -1, -1, 118,
4198  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
4199  129, 130, 52, 53, -1, -1, 56, -1, 137, -1,
4200  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
4201  70, 71, 72, 73, 74, 75, 76, -1, -1, 79,
4202  80, -1, -1, 83, 84, 85, 86, -1, -1, -1,
4203  -1, -1, -1, -1, -1, -1, -1, 97, 98, -1,
4204  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4205  -1, -1, -1, -1, -1, -1, -1, -1, 118, 119,
4206  120, 121, 122, 123, 124, 125, 126, 127, -1, 129,
4207  130, 52, 53, -1, -1, 56, -1, 137, -1, -1,
4208  -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
4209  71, 72, 73, 74, 75, 76, -1, -1, 79, 80,
4210  -1, -1, 83, 84, 85, 86, -1, -1, -1, -1,
4211  -1, -1, -1, -1, -1, -1, 97, 98, -1, -1,
4212  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4213  -1, -1, -1, -1, -1, -1, -1, 118, 119, 120,
4214  121, 122, 123, 124, 125, 126, 127, -1, 129, 130,
4215  52, 53, -1, -1, 56, -1, 137, -1, -1, -1,
4216  -1, -1, -1, -1, -1, -1, 68, 69, 70, 71,
4217  72, 73, 74, 75, 76, -1, -1, 79, 80, -1,
4218  -1, 83, 84, 85, 86, -1, -1, -1, -1, -1,
4219  -1, -1, -1, -1, -1, 97, 98, -1, -1, -1,
4220  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4221  -1, -1, -1, -1, -1, -1, 118, 119, 120, 121,
4222  122, 123, 124, 125, 126, 127, -1, 129, 130, 52,
4223  53, -1, -1, 56, -1, 137, -1, -1, -1, -1,
4224  -1, -1, -1, -1, -1, 68, 69, 70, 71, 72,
4225  73, 74, 75, 76, -1, -1, 79, 80, -1, -1,
4226  83, 84, 85, 86, -1, -1, -1, -1, -1, -1,
4227  -1, -1, -1, -1, 97, 98, -1, -1, -1, -1,
4228  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4229  -1, -1, -1, -1, -1, 118, 119, 120, 121, 122,
4230  123, 124, 125, 126, 127, -1, 129, 130, 52, 53,
4231  -1, -1, 56, -1, 137, -1, -1, -1, -1, -1,
4232  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
4233  74, 75, 76, -1, -1, 79, 80, -1, -1, 83,
4234  84, 85, 86, -1, -1, -1, -1, -1, -1, -1,
4235  -1, -1, -1, 97, 98, -1, -1, -1, -1, -1,
4236  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4237  -1, -1, -1, -1, 118, 119, 120, 121, 122, 123,
4238  124, 125, 126, 127, -1, 129, 130, 52, 53, -1,
4239  -1, 56, -1, 137, -1, -1, -1, -1, -1, -1,
4240  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
4241  75, 76, -1, -1, 79, 80, -1, -1, 83, 84,
4242  85, 86, -1, -1, -1, -1, -1, -1, -1, -1,
4243  -1, -1, 97, 98, -1, -1, -1, -1, -1, -1,
4244  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4245  -1, -1, -1, 118, 119, 120, 121, 122, 123, 124,
4246  125, 126, 127, -1, 129, 130, 52, 53, -1, -1,
4247  56, -1, 137, -1, -1, -1, -1, -1, -1, -1,
4248  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
4249  76, -1, -1, 79, 80, -1, -1, 83, 84, 85,
4250  86, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4251  -1, 97, 98, -1, -1, -1, -1, -1, -1, -1,
4252  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4253  -1, -1, 118, 119, 120, 121, 122, 123, 124, 125,
4254  126, 127, -1, 129, 130, 52, 53, -1, -1, 56,
4255  -1, 137, -1, -1, -1, -1, -1, -1, -1, -1,
4256  -1, 68, 69, 70, 71, 72, 73, 74, 75, 76,
4257  -1, -1, 79, 80, -1, -1, 83, 84, 85, 86,
4258  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4259  97, 98, -1, -1, -1, -1, -1, -1, -1, -1,
4260  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4261  -1, 118, 119, 120, 121, 122, 123, 124, 125, 126,
4262  127, -1, 129, 130, 52, 53, -1, -1, 56, -1,
4263  137, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4264  68, 69, 70, 71, 72, 73, 74, 75, 76, -1,
4265  -1, 79, 80, -1, -1, 83, 84, 85, 86, -1,
4266  -1, -1, -1, -1, -1, -1, -1, -1, -1, 97,
4267  98, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4268  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4269  118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
4270  -1, 129, 130, 52, 53, -1, -1, 56, -1, 137,
4271  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
4272  69, 70, 71, 72, 73, 74, 75, 76, -1, -1,
4273  79, 80, -1, -1, 83, 84, 85, 86, -1, -1,
4274  -1, -1, -1, -1, -1, -1, -1, -1, 97, 98,
4275  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
4276  80, 81, 82, -1, -1, 85, 86, -1, -1, 118,
4277  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
4278  129, 130, -1, -1, -1, -1, -1, -1, 137, -1,
4279  -1, -1, -1, -1, -1, -1, 116, -1, 118, 119,
4280  120, 121, 122, 123, 124, 125, 126, 127, -1, -1,
4281  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4282  -1, -1, -1, 143
4283 };
4284 
4285 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4286  symbol of state STATE-NUM. */
4287 static const yytype_uint16 yystos[] =
4288 {
4289  0, 145, 146, 0, 1, 3, 4, 5, 6, 7,
4290  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4291  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4292  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4293  57, 59, 60, 61, 62, 64, 65, 66, 68, 69,
4294  88, 91, 92, 94, 95, 97, 100, 101, 102, 103,
4295  104, 105, 106, 107, 108, 128, 129, 130, 147, 148,
4296  149, 156, 158, 159, 161, 162, 165, 166, 167, 169,
4297  170, 171, 173, 174, 184, 199, 218, 219, 220, 221,
4298  222, 223, 224, 225, 226, 227, 228, 255, 256, 270,
4299  271, 272, 273, 274, 275, 276, 279, 281, 282, 294,
4300  296, 297, 298, 299, 300, 301, 302, 303, 336, 347,
4301  149, 3, 4, 5, 6, 7, 8, 9, 10, 11,
4302  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
4303  22, 23, 24, 25, 26, 30, 31, 32, 33, 34,
4304  35, 36, 37, 38, 39, 45, 46, 47, 48, 49,
4305  50, 51, 52, 53, 56, 68, 69, 70, 71, 72,
4306  73, 74, 75, 76, 79, 80, 83, 84, 85, 86,
4307  97, 98, 118, 119, 120, 121, 122, 123, 124, 125,
4308  126, 127, 129, 130, 137, 177, 178, 179, 180, 182,
4309  183, 294, 296, 39, 58, 88, 91, 97, 98, 99,
4310  129, 166, 174, 184, 186, 191, 194, 196, 218, 299,
4311  300, 302, 303, 334, 335, 191, 191, 138, 192, 193,
4312  138, 188, 192, 138, 143, 341, 54, 179, 341, 150,
4313  132, 21, 22, 30, 31, 32, 165, 184, 218, 184,
4314  56, 1, 47, 91, 152, 153, 154, 156, 168, 169,
4315  347, 201, 202, 187, 196, 334, 347, 186, 333, 334,
4316  347, 46, 88, 128, 136, 173, 199, 218, 299, 300,
4317  303, 246, 247, 54, 55, 57, 177, 286, 295, 285,
4318  286, 287, 142, 277, 142, 283, 142, 280, 142, 284,
4319  298, 161, 184, 184, 141, 143, 340, 345, 346, 40,
4320  41, 42, 43, 44, 37, 38, 26, 132, 188, 192,
4321  261, 28, 253, 115, 136, 91, 97, 170, 115, 70,
4322  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
4323  81, 82, 85, 86, 116, 118, 119, 120, 121, 122,
4324  123, 124, 125, 126, 127, 87, 134, 135, 200, 159,
4325  160, 160, 205, 207, 160, 340, 346, 88, 167, 174,
4326  218, 234, 299, 300, 303, 52, 56, 85, 88, 175,
4327  176, 218, 299, 300, 303, 176, 33, 34, 35, 36,
4328  49, 50, 51, 52, 56, 138, 177, 301, 331, 87,
4329  135, 339, 261, 273, 89, 89, 136, 186, 56, 186,
4330  186, 186, 115, 90, 136, 195, 347, 87, 134, 135,
4331  89, 89, 136, 195, 191, 341, 342, 191, 190, 191,
4332  196, 334, 347, 159, 342, 159, 54, 65, 66, 157,
4333  138, 185, 132, 152, 87, 135, 89, 156, 155, 168,
4334  139, 340, 346, 342, 342, 159, 140, 136, 143, 344,
4335  136, 344, 133, 344, 341, 56, 298, 170, 172, 136,
4336  87, 134, 135, 248, 63, 109, 111, 112, 288, 112,
4337  288, 112, 67, 288, 112, 112, 278, 288, 112, 63,
4338  112, 112, 112, 278, 112, 63, 112, 70, 141, 149,
4339  160, 160, 160, 160, 156, 159, 159, 263, 262, 96,
4340  163, 254, 97, 161, 186, 196, 197, 198, 168, 136,
4341  173, 136, 158, 161, 174, 184, 186, 198, 184, 184,
4342  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
4343  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
4344  184, 184, 184, 184, 52, 53, 56, 182, 260, 337,
4345  338, 190, 52, 53, 56, 182, 259, 337, 151, 152,
4346  13, 230, 345, 230, 160, 160, 340, 17, 264, 56,
4347  87, 134, 135, 25, 159, 52, 56, 175, 1, 119,
4348  304, 345, 87, 134, 135, 214, 332, 215, 339, 52,
4349  56, 337, 161, 184, 161, 184, 181, 184, 186, 97,
4350  186, 194, 334, 52, 56, 190, 52, 56, 335, 342,
4351  139, 342, 136, 136, 342, 179, 204, 184, 147, 133,
4352  337, 337, 184, 132, 342, 154, 203, 334, 136, 172,
4353  52, 56, 190, 52, 56, 52, 54, 55, 56, 57,
4354  58, 70, 91, 97, 98, 99, 122, 125, 138, 251,
4355  308, 310, 311, 312, 313, 314, 315, 316, 319, 320,
4356  321, 322, 325, 326, 327, 328, 329, 290, 289, 142,
4357  288, 142, 142, 142, 184, 78, 120, 241, 242, 347,
4358  241, 164, 241, 186, 136, 342, 172, 136, 115, 44,
4359  341, 89, 89, 188, 192, 258, 341, 343, 89, 89,
4360  188, 192, 257, 10, 229, 8, 266, 347, 152, 13,
4361  152, 27, 231, 345, 231, 264, 196, 229, 52, 56,
4362  190, 52, 56, 209, 212, 345, 305, 211, 52, 56,
4363  175, 190, 151, 159, 138, 306, 307, 216, 188, 189,
4364  192, 347, 44, 179, 186, 195, 89, 89, 343, 89,
4365  89, 334, 159, 133, 147, 342, 344, 170, 343, 91,
4366  97, 235, 236, 237, 312, 310, 249, 115, 136, 309,
4367  186, 136, 330, 347, 52, 136, 330, 136, 309, 52,
4368  136, 309, 52, 291, 54, 55, 57, 293, 303, 238,
4369  240, 243, 312, 314, 315, 317, 318, 321, 323, 324,
4370  327, 329, 341, 152, 152, 241, 152, 97, 186, 172,
4371  184, 117, 161, 184, 161, 184, 163, 188, 140, 89,
4372  161, 184, 161, 184, 163, 189, 186, 198, 267, 347,
4373  15, 233, 347, 14, 232, 233, 233, 206, 208, 229,
4374  136, 230, 343, 160, 345, 160, 151, 343, 229, 342,
4375  310, 151, 310, 177, 261, 253, 184, 89, 136, 342,
4376  133, 237, 136, 312, 136, 342, 243, 250, 186, 308,
4377  313, 325, 327, 316, 321, 329, 314, 322, 327, 312,
4378  314, 292, 243, 120, 115, 136, 239, 88, 218, 136,
4379  330, 330, 136, 239, 136, 239, 141, 10, 133, 152,
4380  10, 186, 184, 161, 184, 90, 268, 347, 152, 9,
4381  269, 347, 160, 229, 229, 152, 152, 186, 152, 231,
4382  213, 345, 229, 342, 229, 345, 217, 342, 236, 136,
4383  97, 235, 139, 29, 113, 252, 136, 309, 136, 309,
4384  330, 136, 309, 136, 309, 309, 152, 120, 218, 238,
4385  324, 327, 56, 87, 317, 321, 314, 323, 327, 314,
4386  52, 244, 245, 311, 133, 88, 174, 218, 299, 300,
4387  303, 230, 152, 230, 229, 229, 233, 264, 265, 210,
4388  151, 306, 136, 236, 136, 312, 152, 152, 314, 327,
4389  314, 314, 110, 136, 239, 136, 239, 52, 56, 330,
4390  136, 239, 136, 239, 239, 136, 341, 56, 87, 134,
4391  135, 152, 152, 152, 229, 151, 236, 136, 10, 133,
4392  309, 136, 309, 309, 309, 314, 327, 314, 314, 245,
4393  52, 56, 190, 52, 56, 266, 232, 229, 229, 236,
4394  314, 239, 136, 239, 239, 239, 343, 309, 314, 239
4395 };
4396 
4397 #define yyerrok (yyerrstatus = 0)
4398 #define yyclearin (yychar = YYEMPTY)
4399 #define YYEMPTY (-2)
4400 #define YYEOF 0
4401 
4402 #define YYACCEPT goto yyacceptlab
4403 #define YYABORT goto yyabortlab
4404 #define YYERROR goto yyerrorlab
4405 
4406 
4407 /* Like YYERROR except do call yyerror. This remains here temporarily
4408  to ease the transition to the new meaning of YYERROR, for GCC.
4409  Once GCC version 2 has supplanted version 1, this can go. However,
4410  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
4411  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
4412  discussed. */
4413 
4414 #define YYFAIL goto yyerrlab
4415 #if defined YYFAIL
4416  /* This is here to suppress warnings from the GCC cpp's
4417  -Wunused-macros. Normally we don't worry about that warning, but
4418  some users do, and we want to make it easy for users to remove
4419  YYFAIL uses, which will produce warnings from Bison 2.5. */
4420 #endif
4421 
4422 #define YYRECOVERING() (!!yyerrstatus)
4423 
4424 #define YYBACKUP(Token, Value) \
4425 do \
4426  if (yychar == YYEMPTY && yylen == 1) \
4427  { \
4428  yychar = (Token); \
4429  yylval = (Value); \
4430  YYPOPSTACK (1); \
4431  goto yybackup; \
4432  } \
4433  else \
4434  { \
4435  parser_yyerror (parser, YY_("syntax error: cannot back up")); \
4436  YYERROR; \
4437  } \
4438 while (YYID (0))
4439 
4440 
4441 #define YYTERROR 1
4442 #define YYERRCODE 256
4443 
4444 
4445 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
4446  If N is 0, then set CURRENT to the empty location which ends
4447  the previous symbol: RHS[0] (always defined). */
4448 
4449 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
4450 #ifndef YYLLOC_DEFAULT
4451 # define YYLLOC_DEFAULT(Current, Rhs, N) \
4452  do \
4453  if (YYID (N)) \
4454  { \
4455  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
4456  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
4457  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
4458  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
4459  } \
4460  else \
4461  { \
4462  (Current).first_line = (Current).last_line = \
4463  YYRHSLOC (Rhs, 0).last_line; \
4464  (Current).first_column = (Current).last_column = \
4465  YYRHSLOC (Rhs, 0).last_column; \
4466  } \
4467  while (YYID (0))
4468 #endif
4469 
4470 
4471 /* This macro is provided for backward compatibility. */
4472 
4473 #ifndef YY_LOCATION_PRINT
4474 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
4475 #endif
4476 
4477 
4478 /* YYLEX -- calling `yylex' with the right arguments. */
4479 
4480 #ifdef YYLEX_PARAM
4481 # define YYLEX yylex (&yylval, YYLEX_PARAM)
4482 #else
4483 # define YYLEX yylex (&yylval, parser)
4484 #endif
4485 
4486 /* Enable debugging if requested. */
4487 #if YYDEBUG
4488 
4489 # ifndef YYFPRINTF
4490 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
4491 # define YYFPRINTF fprintf
4492 # endif
4493 
4494 # define YYDPRINTF(Args) \
4495 do { \
4496  if (yydebug) \
4497  YYFPRINTF Args; \
4498 } while (YYID (0))
4499 
4500 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
4501 do { \
4502  if (yydebug) \
4503  { \
4504  YYFPRINTF (stderr, "%s ", Title); \
4505  yy_symbol_print (stderr, \
4506  Type, Value, parser); \
4507  YYFPRINTF (stderr, "\n"); \
4508  } \
4509 } while (YYID (0))
4510 
4511 
4512 /*--------------------------------.
4513 | Print this symbol on YYOUTPUT. |
4514 `--------------------------------*/
4515 
4516 /*ARGSUSED*/
4517 #if (defined __STDC__ || defined __C99__FUNC__ \
4518  || defined __cplusplus || defined _MSC_VER)
4519 static void
4520 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4521 #else
4522 static void
4523 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
4524  FILE *yyoutput;
4525  int yytype;
4526  YYSTYPE const * const yyvaluep;
4527  struct parser_params *parser;
4528 #endif
4529 {
4530  if (!yyvaluep)
4531  return;
4532  YYUSE (parser);
4533 # ifdef YYPRINT
4534  if (yytype < YYNTOKENS)
4535  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4536 # else
4537  YYUSE (yyoutput);
4538 # endif
4539  switch (yytype)
4540  {
4541  default:
4542  break;
4543  }
4544 }
4545 
4546 
4547 /*--------------------------------.
4548 | Print this symbol on YYOUTPUT. |
4549 `--------------------------------*/
4550 
4551 #if (defined __STDC__ || defined __C99__FUNC__ \
4552  || defined __cplusplus || defined _MSC_VER)
4553 static void
4554 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4555 #else
4556 static void
4557 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
4558  FILE *yyoutput;
4559  int yytype;
4560  YYSTYPE const * const yyvaluep;
4561  struct parser_params *parser;
4562 #endif
4563 {
4564  if (yytype < YYNTOKENS)
4565  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4566  else
4567  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4568 
4569  yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
4570  YYFPRINTF (yyoutput, ")");
4571 }
4572 
4573 /*------------------------------------------------------------------.
4574 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4575 | TOP (included). |
4576 `------------------------------------------------------------------*/
4577 
4578 #if (defined __STDC__ || defined __C99__FUNC__ \
4579  || defined __cplusplus || defined _MSC_VER)
4580 static void
4581 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4582 #else
4583 static void
4584 yy_stack_print (yybottom, yytop)
4585  yytype_int16 *yybottom;
4586  yytype_int16 *yytop;
4587 #endif
4588 {
4589  YYFPRINTF (stderr, "Stack now");
4590  for (; yybottom <= yytop; yybottom++)
4591  {
4592  int yybot = *yybottom;
4593  YYFPRINTF (stderr, " %d", yybot);
4594  }
4595  YYFPRINTF (stderr, "\n");
4596 }
4597 
4598 # define YY_STACK_PRINT(Bottom, Top) \
4599 do { \
4600  if (yydebug) \
4601  yy_stack_print ((Bottom), (Top)); \
4602 } while (YYID (0))
4603 
4604 
4605 /*------------------------------------------------.
4606 | Report that the YYRULE is going to be reduced. |
4607 `------------------------------------------------*/
4608 
4609 #if (defined __STDC__ || defined __C99__FUNC__ \
4610  || defined __cplusplus || defined _MSC_VER)
4611 static void
4612 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
4613 #else
4614 static void
4615 yy_reduce_print (yyvsp, yyrule, parser)
4616  YYSTYPE *yyvsp;
4617  int yyrule;
4618  struct parser_params *parser;
4619 #endif
4620 {
4621  int yynrhs = yyr2[yyrule];
4622  int yyi;
4623  unsigned long int yylno = yyrline[yyrule];
4624  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4625  yyrule - 1, yylno);
4626  /* The symbols being reduced. */
4627  for (yyi = 0; yyi < yynrhs; yyi++)
4628  {
4629  YYFPRINTF (stderr, " $%d = ", yyi + 1);
4630  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4631  &(yyvsp[(yyi + 1) - (yynrhs)])
4632  , parser);
4633  YYFPRINTF (stderr, "\n");
4634  }
4635 }
4636 
4637 # define YY_REDUCE_PRINT(Rule) \
4638 do { \
4639  if (yydebug) \
4640  yy_reduce_print (yyvsp, Rule, parser); \
4641 } while (YYID (0))
4642 
4643 /* Nonzero means print parse trace. It is left uninitialized so that
4644  multiple parsers can coexist. */
4645 #ifndef yydebug
4646 int yydebug;
4647 #endif
4648 #else /* !YYDEBUG */
4649 # define YYDPRINTF(Args)
4650 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4651 # define YY_STACK_PRINT(Bottom, Top)
4652 # define YY_REDUCE_PRINT(Rule)
4653 #endif /* !YYDEBUG */
4654 
4655 
4656 /* YYINITDEPTH -- initial size of the parser's stacks. */
4657 #ifndef YYINITDEPTH
4658 # define YYINITDEPTH 200
4659 #endif
4660 
4661 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4662  if the built-in stack extension method is used).
4663 
4664  Do not make this value too large; the results are undefined if
4665  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4666  evaluated with infinite-precision integer arithmetic. */
4667 
4668 #ifndef YYMAXDEPTH
4669 # define YYMAXDEPTH 10000
4670 #endif
4671 
4672 
4673 #if YYERROR_VERBOSE
4674 
4675 # ifndef yystrlen
4676 # if defined __GLIBC__ && defined _STRING_H
4677 # define yystrlen strlen
4678 # else
4679 /* Return the length of YYSTR. */
4680 #if (defined __STDC__ || defined __C99__FUNC__ \
4681  || defined __cplusplus || defined _MSC_VER)
4682 static YYSIZE_T
4683 yystrlen (const char *yystr)
4684 #else
4685 static YYSIZE_T
4686 yystrlen (yystr)
4687  const char *yystr;
4688 #endif
4689 {
4690  YYSIZE_T yylen;
4691  for (yylen = 0; yystr[yylen]; yylen++)
4692  continue;
4693  return yylen;
4694 }
4695 # endif
4696 # endif
4697 
4698 # ifndef yystpcpy
4699 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4700 # define yystpcpy stpcpy
4701 # else
4702 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4703  YYDEST. */
4704 #if (defined __STDC__ || defined __C99__FUNC__ \
4705  || defined __cplusplus || defined _MSC_VER)
4706 static char *
4707 yystpcpy (char *yydest, const char *yysrc)
4708 #else
4709 static char *
4710 yystpcpy (yydest, yysrc)
4711  char *yydest;
4712  const char *yysrc;
4713 #endif
4714 {
4715  char *yyd = yydest;
4716  const char *yys = yysrc;
4717 
4718  while ((*yyd++ = *yys++) != '\0')
4719  continue;
4720 
4721  return yyd - 1;
4722 }
4723 # endif
4724 # endif
4725 
4726 # ifndef yytnamerr
4727 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4728  quotes and backslashes, so that it's suitable for yyerror. The
4729  heuristic is that double-quoting is unnecessary unless the string
4730  contains an apostrophe, a comma, or backslash (other than
4731  backslash-backslash). YYSTR is taken from yytname. If YYRES is
4732  null, do not copy; instead, return the length of what the result
4733  would have been. */
4734 static YYSIZE_T
4735 yytnamerr (char *yyres, const char *yystr)
4736 {
4737  if (*yystr == '"')
4738  {
4739  YYSIZE_T yyn = 0;
4740  char const *yyp = yystr;
4741 
4742  for (;;)
4743  switch (*++yyp)
4744  {
4745  case '\'':
4746  case ',':
4747  goto do_not_strip_quotes;
4748 
4749  case '\\':
4750  if (*++yyp != '\\')
4751  goto do_not_strip_quotes;
4752  /* Fall through. */
4753  default:
4754  if (yyres)
4755  yyres[yyn] = *yyp;
4756  yyn++;
4757  break;
4758 
4759  case '"':
4760  if (yyres)
4761  yyres[yyn] = '\0';
4762  return yyn;
4763  }
4764  do_not_strip_quotes: ;
4765  }
4766 
4767  if (! yyres)
4768  return yystrlen (yystr);
4769 
4770  return yystpcpy (yyres, yystr) - yyres;
4771 }
4772 # endif
4773 
4774 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
4775  about the unexpected token YYTOKEN for the state stack whose top is
4776  YYSSP.
4777 
4778  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
4779  not large enough to hold the message. In that case, also set
4780  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
4781  required number of bytes is too large to store. */
4782 static int
4783 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
4784  yytype_int16 *yyssp, int yytoken)
4785 {
4786  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
4787  YYSIZE_T yysize = yysize0;
4788  YYSIZE_T yysize1;
4789  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4790  /* Internationalized format string. */
4791  const char *yyformat = 0;
4792  /* Arguments of yyformat. */
4793  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4794  /* Number of reported tokens (one for the "unexpected", one per
4795  "expected"). */
4796  int yycount = 0;
4797 
4798  /* There are many possibilities here to consider:
4799  - Assume YYFAIL is not used. It's too flawed to consider. See
4800  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
4801  for details. YYERROR is fine as it does not invoke this
4802  function.
4803  - If this state is a consistent state with a default action, then
4804  the only way this function was invoked is if the default action
4805  is an error action. In that case, don't check for expected
4806  tokens because there are none.
4807  - The only way there can be no lookahead present (in yychar) is if
4808  this state is a consistent state with a default action. Thus,
4809  detecting the absence of a lookahead is sufficient to determine
4810  that there is no unexpected or expected token to report. In that
4811  case, just report a simple "syntax error".
4812  - Don't assume there isn't a lookahead just because this state is a
4813  consistent state with a default action. There might have been a
4814  previous inconsistent state, consistent state with a non-default
4815  action, or user semantic action that manipulated yychar.
4816  - Of course, the expected token list depends on states to have
4817  correct lookahead information, and it depends on the parser not
4818  to perform extra reductions after fetching a lookahead from the
4819  scanner and before detecting a syntax error. Thus, state merging
4820  (from LALR or IELR) and default reductions corrupt the expected
4821  token list. However, the list is correct for canonical LR with
4822  one exception: it will still contain any token that will not be
4823  accepted due to an error action in a later state.
4824  */
4825  if (yytoken != YYEMPTY)
4826  {
4827  int yyn = yypact[*yyssp];
4828  yyarg[yycount++] = yytname[yytoken];
4829  if (!yypact_value_is_default (yyn))
4830  {
4831  /* Start YYX at -YYN if negative to avoid negative indexes in
4832  YYCHECK. In other words, skip the first -YYN actions for
4833  this state because they are default actions. */
4834  int yyxbegin = yyn < 0 ? -yyn : 0;
4835  /* Stay within bounds of both yycheck and yytname. */
4836  int yychecklim = YYLAST - yyn + 1;
4837  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4838  int yyx;
4839 
4840  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4841  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
4842  && !yytable_value_is_error (yytable[yyx + yyn]))
4843  {
4844  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4845  {
4846  yycount = 1;
4847  yysize = yysize0;
4848  break;
4849  }
4850  yyarg[yycount++] = yytname[yyx];
4851  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4852  if (! (yysize <= yysize1
4853  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4854  return 2;
4855  yysize = yysize1;
4856  }
4857  }
4858  }
4859 
4860  switch (yycount)
4861  {
4862 # define YYCASE_(N, S) \
4863  case N: \
4864  yyformat = S; \
4865  break
4866  YYCASE_(0, YY_("syntax error"));
4867  YYCASE_(1, YY_("syntax error, unexpected %s"));
4868  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
4869  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
4870  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
4871  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
4872 # undef YYCASE_
4873  }
4874 
4875  yysize1 = yysize + yystrlen (yyformat);
4876  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4877  return 2;
4878  yysize = yysize1;
4879 
4880  if (*yymsg_alloc < yysize)
4881  {
4882  *yymsg_alloc = 2 * yysize;
4883  if (! (yysize <= *yymsg_alloc
4884  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
4885  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
4886  return 1;
4887  }
4888 
4889  /* Avoid sprintf, as that infringes on the user's name space.
4890  Don't have undefined behavior even if the translation
4891  produced a string with the wrong number of "%s"s. */
4892  {
4893  char *yyp = *yymsg;
4894  int yyi = 0;
4895  while ((*yyp = *yyformat) != '\0')
4896  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
4897  {
4898  yyp += yytnamerr (yyp, yyarg[yyi++]);
4899  yyformat += 2;
4900  }
4901  else
4902  {
4903  yyp++;
4904  yyformat++;
4905  }
4906  }
4907  return 0;
4908 }
4909 #endif /* YYERROR_VERBOSE */
4910 
4911 /*-----------------------------------------------.
4912 | Release the memory associated to this symbol. |
4913 `-----------------------------------------------*/
4914 
4915 /*ARGSUSED*/
4916 #if (defined __STDC__ || defined __C99__FUNC__ \
4917  || defined __cplusplus || defined _MSC_VER)
4918 static void
4919 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
4920 #else
4921 static void
4922 yydestruct (yymsg, yytype, yyvaluep, parser)
4923  const char *yymsg;
4924  int yytype;
4925  YYSTYPE *yyvaluep;
4926  struct parser_params *parser;
4927 #endif
4928 {
4929  YYUSE (yyvaluep);
4930  YYUSE (parser);
4931 
4932  if (!yymsg)
4933  yymsg = "Deleting";
4934  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4935 
4936  switch (yytype)
4937  {
4938 
4939  default:
4940  break;
4941  }
4942 }
4943 
4944 
4945 /* Prevent warnings from -Wmissing-prototypes. */
4946 #ifdef YYPARSE_PARAM
4947 #if defined __STDC__ || defined __cplusplus
4948 int yyparse (void *YYPARSE_PARAM);
4949 #else
4950 int yyparse ();
4951 #endif
4952 #else /* ! YYPARSE_PARAM */
4953 #if defined __STDC__ || defined __cplusplus
4954 int yyparse (struct parser_params *parser);
4955 #else
4956 int yyparse ();
4957 #endif
4958 #endif /* ! YYPARSE_PARAM */
4959 
4960 
4961 /*----------.
4962 | yyparse. |
4963 `----------*/
4964 
4965 #ifdef YYPARSE_PARAM
4966 #if (defined __STDC__ || defined __C99__FUNC__ \
4967  || defined __cplusplus || defined _MSC_VER)
4968 int
4969 yyparse (void *YYPARSE_PARAM)
4970 #else
4971 int
4972 yyparse (YYPARSE_PARAM)
4973  void *YYPARSE_PARAM;
4974 #endif
4975 #else /* ! YYPARSE_PARAM */
4976 #if (defined __STDC__ || defined __C99__FUNC__ \
4977  || defined __cplusplus || defined _MSC_VER)
4978 int
4979 yyparse (struct parser_params *parser)
4980 #else
4981 int
4982 yyparse (parser)
4983  struct parser_params *parser;
4984 #endif
4985 #endif
4986 {
4987 /* The lookahead symbol. */
4988 int yychar;
4989 
4990 /* The semantic value of the lookahead symbol. */
4991 YYSTYPE yylval;
4992 
4993  /* Number of syntax errors so far. */
4994  int yynerrs;
4995 
4996  int yystate;
4997  /* Number of tokens to shift before error messages enabled. */
4998  int yyerrstatus;
4999 
5000  /* The stacks and their tools:
5001  `yyss': related to states.
5002  `yyvs': related to semantic values.
5003 
5004  Refer to the stacks thru separate pointers, to allow yyoverflow
5005  to reallocate them elsewhere. */
5006 
5007  /* The state stack. */
5008  yytype_int16 yyssa[YYINITDEPTH];
5009  yytype_int16 *yyss;
5010  yytype_int16 *yyssp;
5011 
5012  /* The semantic value stack. */
5013  YYSTYPE yyvsa[YYINITDEPTH];
5014  YYSTYPE *yyvs;
5015  YYSTYPE *yyvsp;
5016 
5017  YYSIZE_T yystacksize;
5018 
5019  int yyn;
5020  int yyresult;
5021  /* Lookahead token as an internal (translated) token number. */
5022  int yytoken;
5023  /* The variables used to return semantic value and location from the
5024  action routines. */
5025  YYSTYPE yyval;
5026 
5027 #if YYERROR_VERBOSE
5028  /* Buffer for error messages, and its allocated size. */
5029  char yymsgbuf[128];
5030  char *yymsg = yymsgbuf;
5031  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
5032 #endif
5033 
5034 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
5035 
5036  /* The number of symbols on the RHS of the reduced rule.
5037  Keep to zero when no symbol should be popped. */
5038  int yylen = 0;
5039 
5040  yytoken = 0;
5041  yyss = yyssa;
5042  yyvs = yyvsa;
5043  yystacksize = YYINITDEPTH;
5044 
5045  YYDPRINTF ((stderr, "Starting parse\n"));
5046 
5047  yystate = 0;
5048  yyerrstatus = 0;
5049  yynerrs = 0;
5050  yychar = YYEMPTY; /* Cause a token to be read. */
5051 
5052  /* Initialize stack pointers.
5053  Waste one element of value and location stack
5054  so that they stay on the same level as the state stack.
5055  The wasted elements are never initialized. */
5056  yyssp = yyss;
5057  yyvsp = yyvs;
5058 
5059  goto yysetstate;
5060 
5061 /*------------------------------------------------------------.
5062 | yynewstate -- Push a new state, which is found in yystate. |
5063 `------------------------------------------------------------*/
5064  yynewstate:
5065  /* In all cases, when you get here, the value and location stacks
5066  have just been pushed. So pushing a state here evens the stacks. */
5067  yyssp++;
5068 
5069  yysetstate:
5070  *yyssp = yystate;
5071 
5072  if (yyss + yystacksize - 1 <= yyssp)
5073  {
5074  /* Get the current used size of the three stacks, in elements. */
5075  YYSIZE_T yysize = yyssp - yyss + 1;
5076 
5077 #ifdef yyoverflow
5078  {
5079  /* Give user a chance to reallocate the stack. Use copies of
5080  these so that the &'s don't force the real ones into
5081  memory. */
5082  YYSTYPE *yyvs1 = yyvs;
5083  yytype_int16 *yyss1 = yyss;
5084 
5085  /* Each stack pointer address is followed by the size of the
5086  data in use in that stack, in bytes. This used to be a
5087  conditional around just the two extra args, but that might
5088  be undefined if yyoverflow is a macro. */
5089  yyoverflow (YY_("memory exhausted"),
5090  &yyss1, yysize * sizeof (*yyssp),
5091  &yyvs1, yysize * sizeof (*yyvsp),
5092  &yystacksize);
5093 
5094  yyss = yyss1;
5095  yyvs = yyvs1;
5096  }
5097 #else /* no yyoverflow */
5098 # ifndef YYSTACK_RELOCATE
5099  goto yyexhaustedlab;
5100 # else
5101  /* Extend the stack our own way. */
5102  if (YYMAXDEPTH <= yystacksize)
5103  goto yyexhaustedlab;
5104  yystacksize *= 2;
5105  if (YYMAXDEPTH < yystacksize)
5106  yystacksize = YYMAXDEPTH;
5107 
5108  {
5109  yytype_int16 *yyss1 = yyss;
5110  union yyalloc *yyptr =
5111  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
5112  if (! yyptr)
5113  goto yyexhaustedlab;
5114  YYSTACK_RELOCATE (yyss_alloc, yyss);
5115  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
5116 # undef YYSTACK_RELOCATE
5117  if (yyss1 != yyssa)
5118  YYSTACK_FREE (yyss1);
5119  }
5120 # endif
5121 #endif /* no yyoverflow */
5122 
5123  yyssp = yyss + yysize - 1;
5124  yyvsp = yyvs + yysize - 1;
5125 
5126  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
5127  (unsigned long int) yystacksize));
5128 
5129  if (yyss + yystacksize - 1 <= yyssp)
5130  YYABORT;
5131  }
5132 
5133  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
5134 
5135  if (yystate == YYFINAL)
5136  YYACCEPT;
5137 
5138  goto yybackup;
5139 
5140 /*-----------.
5141 | yybackup. |
5142 `-----------*/
5143 yybackup:
5144 
5145  /* Do appropriate processing given the current state. Read a
5146  lookahead token if we need one and don't already have one. */
5147 
5148  /* First try to decide what to do without reference to lookahead token. */
5149  yyn = yypact[yystate];
5150  if (yypact_value_is_default (yyn))
5151  goto yydefault;
5152 
5153  /* Not known => get a lookahead token if don't already have one. */
5154 
5155  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5156  if (yychar == YYEMPTY)
5157  {
5158  YYDPRINTF ((stderr, "Reading a token: "));
5159  yychar = YYLEX;
5160  }
5161 
5162  if (yychar <= YYEOF)
5163  {
5164  yychar = yytoken = YYEOF;
5165  YYDPRINTF ((stderr, "Now at end of input.\n"));
5166  }
5167  else
5168  {
5169  yytoken = YYTRANSLATE (yychar);
5170  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
5171  }
5172 
5173  /* If the proper action on seeing token YYTOKEN is to reduce or to
5174  detect an error, take that action. */
5175  yyn += yytoken;
5176  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
5177  goto yydefault;
5178  yyn = yytable[yyn];
5179  if (yyn <= 0)
5180  {
5181  if (yytable_value_is_error (yyn))
5182  goto yyerrlab;
5183  yyn = -yyn;
5184  goto yyreduce;
5185  }
5186 
5187  /* Count tokens shifted since error; after three, turn off error
5188  status. */
5189  if (yyerrstatus)
5190  yyerrstatus--;
5191 
5192  /* Shift the lookahead token. */
5193  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
5194 
5195  /* Discard the shifted token. */
5196  yychar = YYEMPTY;
5197 
5198  yystate = yyn;
5199  *++yyvsp = yylval;
5200 
5201  goto yynewstate;
5202 
5203 
5204 /*-----------------------------------------------------------.
5205 | yydefault -- do the default action for the current state. |
5206 `-----------------------------------------------------------*/
5207 yydefault:
5208  yyn = yydefact[yystate];
5209  if (yyn == 0)
5210  goto yyerrlab;
5211  goto yyreduce;
5212 
5213 
5214 /*-----------------------------.
5215 | yyreduce -- Do a reduction. |
5216 `-----------------------------*/
5217 yyreduce:
5218  /* yyn is the number of a rule to reduce with. */
5219  yylen = yyr2[yyn];
5220 
5221  /* If YYLEN is nonzero, implement the default value of the action:
5222  `$$ = $1'.
5223 
5224  Otherwise, the following line sets YYVAL to garbage.
5225  This behavior is undocumented and Bison
5226  users should not rely upon it. Assigning to YYVAL
5227  unconditionally makes the parser a bit smaller, and it avoids a
5228  GCC warning that YYVAL may be used uninitialized. */
5229  yyval = yyvsp[1-yylen];
5230 
5231 
5232  YY_REDUCE_PRINT (yyn);
5233  switch (yyn)
5234  {
5235  case 2:
5236 
5237 /* Line 1806 of yacc.c */
5238 #line 863 "parse.y"
5239  {
5240  lex_state = EXPR_BEG;
5241  /*%%%*/
5243  /*%
5244  local_push(0);
5245  %*/
5246  }
5247  break;
5248 
5249  case 3:
5250 
5251 /* Line 1806 of yacc.c */
5252 #line 872 "parse.y"
5253  {
5254  /*%%%*/
5255  if ((yyvsp[(2) - (2)].node) && !compile_for_eval) {
5256  /* last expression should not be void */
5257  if (nd_type((yyvsp[(2) - (2)].node)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].node));
5258  else {
5259  NODE *node = (yyvsp[(2) - (2)].node);
5260  while (node->nd_next) {
5261  node = node->nd_next;
5262  }
5263  void_expr(node->nd_head);
5264  }
5265  }
5266  ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].node)));
5267  /*%
5268  $$ = $2;
5269  parser->result = dispatch1(program, $$);
5270  %*/
5271  local_pop();
5272  }
5273  break;
5274 
5275  case 4:
5276 
5277 /* Line 1806 of yacc.c */
5278 #line 895 "parse.y"
5279  {
5280  /*%%%*/
5281  void_stmts((yyvsp[(1) - (2)].node));
5283  /*%
5284  %*/
5285  (yyval.node) = (yyvsp[(1) - (2)].node);
5286  }
5287  break;
5288 
5289  case 5:
5290 
5291 /* Line 1806 of yacc.c */
5292 #line 906 "parse.y"
5293  {
5294  /*%%%*/
5295  (yyval.node) = NEW_BEGIN(0);
5296  /*%
5297  $$ = dispatch2(stmts_add, dispatch0(stmts_new),
5298  dispatch0(void_stmt));
5299  %*/
5300  }
5301  break;
5302 
5303  case 6:
5304 
5305 /* Line 1806 of yacc.c */
5306 #line 915 "parse.y"
5307  {
5308  /*%%%*/
5309  (yyval.node) = newline_node((yyvsp[(1) - (1)].node));
5310  /*%
5311  $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
5312  %*/
5313  }
5314  break;
5315 
5316  case 7:
5317 
5318 /* Line 1806 of yacc.c */
5319 #line 923 "parse.y"
5320  {
5321  /*%%%*/
5322  (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node)));
5323  /*%
5324  $$ = dispatch2(stmts_add, $1, $3);
5325  %*/
5326  }
5327  break;
5328 
5329  case 8:
5330 
5331 /* Line 1806 of yacc.c */
5332 #line 931 "parse.y"
5333  {
5334  (yyval.node) = remove_begin((yyvsp[(2) - (2)].node));
5335  }
5336  break;
5337 
5338  case 10:
5339 
5340 /* Line 1806 of yacc.c */
5341 #line 938 "parse.y"
5342  {
5343  /*%%%*/
5344  /* local_push(0); */
5345  /*%
5346  %*/
5347  }
5348  break;
5349 
5350  case 11:
5351 
5352 /* Line 1806 of yacc.c */
5353 #line 945 "parse.y"
5354  {
5355  /*%%%*/
5357  (yyvsp[(4) - (5)].node));
5358  /* NEW_PREEXE($4)); */
5359  /* local_pop(); */
5360  (yyval.node) = NEW_BEGIN(0);
5361  /*%
5362  $$ = dispatch1(BEGIN, $4);
5363  %*/
5364  }
5365  break;
5366 
5367  case 12:
5368 
5369 /* Line 1806 of yacc.c */
5370 #line 962 "parse.y"
5371  {
5372  /*%%%*/
5373  (yyval.node) = (yyvsp[(1) - (4)].node);
5374  if ((yyvsp[(2) - (4)].node)) {
5375  (yyval.node) = NEW_RESCUE((yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].node), (yyvsp[(3) - (4)].node));
5376  }
5377  else if ((yyvsp[(3) - (4)].node)) {
5378  rb_warn0("else without rescue is useless");
5379  (yyval.node) = block_append((yyval.node), (yyvsp[(3) - (4)].node));
5380  }
5381  if ((yyvsp[(4) - (4)].node)) {
5382  if ((yyval.node)) {
5383  (yyval.node) = NEW_ENSURE((yyval.node), (yyvsp[(4) - (4)].node));
5384  }
5385  else {
5386  (yyval.node) = block_append((yyvsp[(4) - (4)].node), NEW_NIL());
5387  }
5388  }
5389  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
5390  /*%
5391  $$ = dispatch4(bodystmt,
5392  escape_Qundef($1),
5393  escape_Qundef($2),
5394  escape_Qundef($3),
5395  escape_Qundef($4));
5396  %*/
5397  }
5398  break;
5399 
5400  case 13:
5401 
5402 /* Line 1806 of yacc.c */
5403 #line 992 "parse.y"
5404  {
5405  /*%%%*/
5406  void_stmts((yyvsp[(1) - (2)].node));
5408  /*%
5409  %*/
5410  (yyval.node) = (yyvsp[(1) - (2)].node);
5411  }
5412  break;
5413 
5414  case 14:
5415 
5416 /* Line 1806 of yacc.c */
5417 #line 1003 "parse.y"
5418  {
5419  /*%%%*/
5420  (yyval.node) = NEW_BEGIN(0);
5421  /*%
5422  $$ = dispatch2(stmts_add, dispatch0(stmts_new),
5423  dispatch0(void_stmt));
5424  %*/
5425  }
5426  break;
5427 
5428  case 15:
5429 
5430 /* Line 1806 of yacc.c */
5431 #line 1012 "parse.y"
5432  {
5433  /*%%%*/
5434  (yyval.node) = newline_node((yyvsp[(1) - (1)].node));
5435  /*%
5436  $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
5437  %*/
5438  }
5439  break;
5440 
5441  case 16:
5442 
5443 /* Line 1806 of yacc.c */
5444 #line 1020 "parse.y"
5445  {
5446  /*%%%*/
5447  (yyval.node) = block_append((yyvsp[(1) - (3)].node), newline_node((yyvsp[(3) - (3)].node)));
5448  /*%
5449  $$ = dispatch2(stmts_add, $1, $3);
5450  %*/
5451  }
5452  break;
5453 
5454  case 17:
5455 
5456 /* Line 1806 of yacc.c */
5457 #line 1028 "parse.y"
5458  {
5459  (yyval.node) = remove_begin((yyvsp[(2) - (2)].node));
5460  }
5461  break;
5462 
5463  case 18:
5464 
5465 /* Line 1806 of yacc.c */
5466 #line 1034 "parse.y"
5467  {
5468  (yyval.node) = (yyvsp[(1) - (1)].node);
5469  }
5470  break;
5471 
5472  case 19:
5473 
5474 /* Line 1806 of yacc.c */
5475 #line 1038 "parse.y"
5476  {
5477  yyerror("BEGIN is permitted only at toplevel");
5478  /*%%%*/
5479  /* local_push(0); */
5480  /*%
5481  %*/
5482  }
5483  break;
5484 
5485  case 20:
5486 
5487 /* Line 1806 of yacc.c */
5488 #line 1046 "parse.y"
5489  {
5490  /*%%%*/
5492  (yyvsp[(4) - (5)].node));
5493  /* NEW_PREEXE($4)); */
5494  /* local_pop(); */
5495  (yyval.node) = NEW_BEGIN(0);
5496  /*%
5497  $$ = dispatch1(BEGIN, $4);
5498  %*/
5499  }
5500  break;
5501 
5502  case 21:
5503 
5504 /* Line 1806 of yacc.c */
5505 #line 1058 "parse.y"
5506  {lex_state = EXPR_FNAME;}
5507  break;
5508 
5509  case 22:
5510 
5511 /* Line 1806 of yacc.c */
5512 #line 1059 "parse.y"
5513  {
5514  /*%%%*/
5515  (yyval.node) = NEW_ALIAS((yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].node));
5516  /*%
5517  $$ = dispatch2(alias, $2, $4);
5518  %*/
5519  }
5520  break;
5521 
5522  case 23:
5523 
5524 /* Line 1806 of yacc.c */
5525 #line 1067 "parse.y"
5526  {
5527  /*%%%*/
5528  (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].id));
5529  /*%
5530  $$ = dispatch2(var_alias, $2, $3);
5531  %*/
5532  }
5533  break;
5534 
5535  case 24:
5536 
5537 /* Line 1806 of yacc.c */
5538 #line 1075 "parse.y"
5539  {
5540  /*%%%*/
5541  char buf[2];
5542  buf[0] = '$';
5543  buf[1] = (char)(yyvsp[(3) - (3)].node)->nd_nth;
5544  (yyval.node) = NEW_VALIAS((yyvsp[(2) - (3)].id), rb_intern2(buf, 2));
5545  /*%
5546  $$ = dispatch2(var_alias, $2, $3);
5547  %*/
5548  }
5549  break;
5550 
5551  case 25:
5552 
5553 /* Line 1806 of yacc.c */
5554 #line 1086 "parse.y"
5555  {
5556  /*%%%*/
5557  yyerror("can't make alias for the number variables");
5558  (yyval.node) = NEW_BEGIN(0);
5559  /*%
5560  $$ = dispatch2(var_alias, $2, $3);
5561  $$ = dispatch1(alias_error, $$);
5562  %*/
5563  }
5564  break;
5565 
5566  case 26:
5567 
5568 /* Line 1806 of yacc.c */
5569 #line 1096 "parse.y"
5570  {
5571  /*%%%*/
5572  (yyval.node) = (yyvsp[(2) - (2)].node);
5573  /*%
5574  $$ = dispatch1(undef, $2);
5575  %*/
5576  }
5577  break;
5578 
5579  case 27:
5580 
5581 /* Line 1806 of yacc.c */
5582 #line 1104 "parse.y"
5583  {
5584  /*%%%*/
5585  (yyval.node) = NEW_IF(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0);
5586  fixpos((yyval.node), (yyvsp[(3) - (3)].node));
5587  /*%
5588  $$ = dispatch2(if_mod, $3, $1);
5589  %*/
5590  }
5591  break;
5592 
5593  case 28:
5594 
5595 /* Line 1806 of yacc.c */
5596 #line 1113 "parse.y"
5597  {
5598  /*%%%*/
5599  (yyval.node) = NEW_UNLESS(cond((yyvsp[(3) - (3)].node)), remove_begin((yyvsp[(1) - (3)].node)), 0);
5600  fixpos((yyval.node), (yyvsp[(3) - (3)].node));
5601  /*%
5602  $$ = dispatch2(unless_mod, $3, $1);
5603  %*/
5604  }
5605  break;
5606 
5607  case 29:
5608 
5609 /* Line 1806 of yacc.c */
5610 #line 1122 "parse.y"
5611  {
5612  /*%%%*/
5613  if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) {
5614  (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0);
5615  }
5616  else {
5617  (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1);
5618  }
5619  /*%
5620  $$ = dispatch2(while_mod, $3, $1);
5621  %*/
5622  }
5623  break;
5624 
5625  case 30:
5626 
5627 /* Line 1806 of yacc.c */
5628 #line 1135 "parse.y"
5629  {
5630  /*%%%*/
5631  if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_BEGIN) {
5632  (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node)->nd_body, 0);
5633  }
5634  else {
5635  (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (3)].node)), (yyvsp[(1) - (3)].node), 1);
5636  }
5637  /*%
5638  $$ = dispatch2(until_mod, $3, $1);
5639  %*/
5640  }
5641  break;
5642 
5643  case 31:
5644 
5645 /* Line 1806 of yacc.c */
5646 #line 1148 "parse.y"
5647  {
5648  /*%%%*/
5649  NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].node)), 0);
5650  (yyval.node) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].node)), resq, 0);
5651  /*%
5652  $$ = dispatch2(rescue_mod, $1, $3);
5653  %*/
5654  }
5655  break;
5656 
5657  case 32:
5658 
5659 /* Line 1806 of yacc.c */
5660 #line 1157 "parse.y"
5661  {
5662  if (in_def || in_single) {
5663  rb_warn0("END in method; use at_exit");
5664  }
5665  /*%%%*/
5666  (yyval.node) = NEW_POSTEXE(NEW_NODE(
5667  NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].node) /* body */, 0 /* args */));
5668  /*%
5669  $$ = dispatch1(END, $3);
5670  %*/
5671  }
5672  break;
5673 
5674  case 34:
5675 
5676 /* Line 1806 of yacc.c */
5677 #line 1170 "parse.y"
5678  {
5679  /*%%%*/
5680  value_expr((yyvsp[(3) - (3)].node));
5681  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
5682  (yyval.node) = (yyvsp[(1) - (3)].node);
5683  /*%
5684  $$ = dispatch2(massign, $1, $3);
5685  %*/
5686  }
5687  break;
5688 
5689  case 35:
5690 
5691 /* Line 1806 of yacc.c */
5692 #line 1180 "parse.y"
5693  {
5694  value_expr((yyvsp[(3) - (3)].node));
5695  (yyval.node) = new_op_assign((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].node));
5696  }
5697  break;
5698 
5699  case 36:
5700 
5701 /* Line 1806 of yacc.c */
5702 #line 1185 "parse.y"
5703  {
5704  /*%%%*/
5705  NODE *args;
5706 
5707  value_expr((yyvsp[(6) - (6)].node));
5708  if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY();
5709  args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
5710  if ((yyvsp[(5) - (6)].id) == tOROP) {
5711  (yyvsp[(5) - (6)].id) = 0;
5712  }
5713  else if ((yyvsp[(5) - (6)].id) == tANDOP) {
5714  (yyvsp[(5) - (6)].id) = 1;
5715  }
5716  (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args);
5717  fixpos((yyval.node), (yyvsp[(1) - (6)].node));
5718  /*%
5719  $$ = dispatch2(aref_field, $1, escape_Qundef($3));
5720  $$ = dispatch3(opassign, $$, $5, $6);
5721  %*/
5722  }
5723  break;
5724 
5725  case 37:
5726 
5727 /* Line 1806 of yacc.c */
5728 #line 1206 "parse.y"
5729  {
5730  value_expr((yyvsp[(5) - (5)].node));
5731  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5732  }
5733  break;
5734 
5735  case 38:
5736 
5737 /* Line 1806 of yacc.c */
5738 #line 1211 "parse.y"
5739  {
5740  value_expr((yyvsp[(5) - (5)].node));
5741  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5742  }
5743  break;
5744 
5745  case 39:
5746 
5747 /* Line 1806 of yacc.c */
5748 #line 1216 "parse.y"
5749  {
5750  /*%%%*/
5751  (yyval.node) = NEW_COLON2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id));
5752  (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5753  /*%
5754  $$ = dispatch2(const_path_field, $1, $3);
5755  $$ = dispatch3(opassign, $$, $4, $5);
5756  %*/
5757  }
5758  break;
5759 
5760  case 40:
5761 
5762 /* Line 1806 of yacc.c */
5763 #line 1226 "parse.y"
5764  {
5765  value_expr((yyvsp[(5) - (5)].node));
5766  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_intern("::"), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
5767  }
5768  break;
5769 
5770  case 41:
5771 
5772 /* Line 1806 of yacc.c */
5773 #line 1231 "parse.y"
5774  {
5775  /*%%%*/
5776  rb_backref_error((yyvsp[(1) - (3)].node));
5777  (yyval.node) = NEW_BEGIN(0);
5778  /*%
5779  $$ = dispatch2(assign, dispatch1(var_field, $1), $3);
5780  $$ = dispatch1(assign_error, $$);
5781  %*/
5782  }
5783  break;
5784 
5785  case 42:
5786 
5787 /* Line 1806 of yacc.c */
5788 #line 1241 "parse.y"
5789  {
5790  /*%%%*/
5791  value_expr((yyvsp[(3) - (3)].node));
5792  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5793  /*%
5794  $$ = dispatch2(assign, $1, $3);
5795  %*/
5796  }
5797  break;
5798 
5799  case 43:
5800 
5801 /* Line 1806 of yacc.c */
5802 #line 1250 "parse.y"
5803  {
5804  /*%%%*/
5805  (yyvsp[(1) - (3)].node)->nd_value = (yyvsp[(3) - (3)].node);
5806  (yyval.node) = (yyvsp[(1) - (3)].node);
5807  /*%
5808  $$ = dispatch2(massign, $1, $3);
5809  %*/
5810  }
5811  break;
5812 
5813  case 45:
5814 
5815 /* Line 1806 of yacc.c */
5816 #line 1262 "parse.y"
5817  {
5818  /*%%%*/
5819  value_expr((yyvsp[(3) - (3)].node));
5820  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5821  /*%
5822  $$ = dispatch2(assign, $1, $3);
5823  %*/
5824  }
5825  break;
5826 
5827  case 46:
5828 
5829 /* Line 1806 of yacc.c */
5830 #line 1271 "parse.y"
5831  {
5832  /*%%%*/
5833  value_expr((yyvsp[(3) - (3)].node));
5834  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5835  /*%
5836  $$ = dispatch2(assign, $1, $3);
5837  %*/
5838  }
5839  break;
5840 
5841  case 48:
5842 
5843 /* Line 1806 of yacc.c */
5844 #line 1284 "parse.y"
5845  {
5846  /*%%%*/
5847  (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5848  /*%
5849  $$ = dispatch3(binary, $1, ripper_intern("and"), $3);
5850  %*/
5851  }
5852  break;
5853 
5854  case 49:
5855 
5856 /* Line 1806 of yacc.c */
5857 #line 1292 "parse.y"
5858  {
5859  /*%%%*/
5860  (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
5861  /*%
5862  $$ = dispatch3(binary, $1, ripper_intern("or"), $3);
5863  %*/
5864  }
5865  break;
5866 
5867  case 50:
5868 
5869 /* Line 1806 of yacc.c */
5870 #line 1300 "parse.y"
5871  {
5872  /*%%%*/
5873  (yyval.node) = call_uni_op(cond((yyvsp[(3) - (3)].node)), '!');
5874  /*%
5875  $$ = dispatch2(unary, ripper_intern("not"), $3);
5876  %*/
5877  }
5878  break;
5879 
5880  case 51:
5881 
5882 /* Line 1806 of yacc.c */
5883 #line 1308 "parse.y"
5884  {
5885  /*%%%*/
5886  (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!');
5887  /*%
5888  $$ = dispatch2(unary, ripper_id2sym('!'), $2);
5889  %*/
5890  }
5891  break;
5892 
5893  case 53:
5894 
5895 /* Line 1806 of yacc.c */
5896 #line 1319 "parse.y"
5897  {
5898  /*%%%*/
5899  value_expr((yyvsp[(1) - (1)].node));
5900  (yyval.node) = (yyvsp[(1) - (1)].node);
5901  if (!(yyval.node)) (yyval.node) = NEW_NIL();
5902  /*%
5903  $$ = $1;
5904  %*/
5905  }
5906  break;
5907 
5908  case 57:
5909 
5910 /* Line 1806 of yacc.c */
5911 #line 1336 "parse.y"
5912  {
5913  /*%%%*/
5914  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
5915  /*%
5916  $$ = dispatch3(call, $1, $2, $3);
5917  $$ = method_arg($$, $4);
5918  %*/
5919  }
5920  break;
5921 
5922  case 58:
5923 
5924 /* Line 1806 of yacc.c */
5925 #line 1347 "parse.y"
5926  {
5927  (yyvsp[(1) - (1)].vars) = dyna_push();
5928  /*%%%*/
5929  (yyval.num) = ruby_sourceline;
5930  /*%
5931  %*/
5932  }
5933  break;
5934 
5935  case 59:
5936 
5937 /* Line 1806 of yacc.c */
5938 #line 1357 "parse.y"
5939  {
5940  /*%%%*/
5941  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
5942  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
5943  /*%
5944  $$ = dispatch2(brace_block, escape_Qundef($3), $4);
5945  %*/
5946  dyna_pop((yyvsp[(1) - (5)].vars));
5947  }
5948  break;
5949 
5950  case 60:
5951 
5952 /* Line 1806 of yacc.c */
5953 #line 1369 "parse.y"
5954  {
5955  /*%%%*/
5956  (yyval.node) = NEW_FCALL((yyvsp[(1) - (1)].id), 0);
5957  nd_set_line((yyval.node), tokline);
5958  /*%
5959  %*/
5960  }
5961  break;
5962 
5963  case 61:
5964 
5965 /* Line 1806 of yacc.c */
5966 #line 1379 "parse.y"
5967  {
5968  /*%%%*/
5969  (yyval.node) = (yyvsp[(1) - (2)].node);
5970  (yyval.node)->nd_args = (yyvsp[(2) - (2)].node);
5971  /*%
5972  $$ = dispatch2(command, $1, $2);
5973  %*/
5974  }
5975  break;
5976 
5977  case 62:
5978 
5979 /* Line 1806 of yacc.c */
5980 #line 1388 "parse.y"
5981  {
5982  /*%%%*/
5983  block_dup_check((yyvsp[(2) - (3)].node),(yyvsp[(3) - (3)].node));
5984  (yyvsp[(1) - (3)].node)->nd_args = (yyvsp[(2) - (3)].node);
5985  (yyvsp[(3) - (3)].node)->nd_iter = (yyvsp[(1) - (3)].node);
5986  (yyval.node) = (yyvsp[(3) - (3)].node);
5987  fixpos((yyval.node), (yyvsp[(1) - (3)].node));
5988  /*%
5989  $$ = dispatch2(command, $1, $2);
5990  $$ = method_add_block($$, $3);
5991  %*/
5992  }
5993  break;
5994 
5995  case 63:
5996 
5997 /* Line 1806 of yacc.c */
5998 #line 1401 "parse.y"
5999  {
6000  /*%%%*/
6001  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
6002  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
6003  /*%
6004  $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
6005  %*/
6006  }
6007  break;
6008 
6009  case 64:
6010 
6011 /* Line 1806 of yacc.c */
6012 #line 1410 "parse.y"
6013  {
6014  /*%%%*/
6015  block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node));
6016  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
6017  (yyval.node) = (yyvsp[(5) - (5)].node);
6018  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
6019  /*%
6020  $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
6021  $$ = method_add_block($$, $5);
6022  %*/
6023  }
6024  break;
6025 
6026  case 65:
6027 
6028 /* Line 1806 of yacc.c */
6029 #line 1422 "parse.y"
6030  {
6031  /*%%%*/
6032  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
6033  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
6034  /*%
6035  $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
6036  %*/
6037  }
6038  break;
6039 
6040  case 66:
6041 
6042 /* Line 1806 of yacc.c */
6043 #line 1431 "parse.y"
6044  {
6045  /*%%%*/
6046  block_dup_check((yyvsp[(4) - (5)].node),(yyvsp[(5) - (5)].node));
6047  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
6048  (yyval.node) = (yyvsp[(5) - (5)].node);
6049  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
6050  /*%
6051  $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
6052  $$ = method_add_block($$, $5);
6053  %*/
6054  }
6055  break;
6056 
6057  case 67:
6058 
6059 /* Line 1806 of yacc.c */
6060 #line 1443 "parse.y"
6061  {
6062  /*%%%*/
6063  (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node));
6064  fixpos((yyval.node), (yyvsp[(2) - (2)].node));
6065  /*%
6066  $$ = dispatch1(super, $2);
6067  %*/
6068  }
6069  break;
6070 
6071  case 68:
6072 
6073 /* Line 1806 of yacc.c */
6074 #line 1452 "parse.y"
6075  {
6076  /*%%%*/
6077  (yyval.node) = new_yield((yyvsp[(2) - (2)].node));
6078  fixpos((yyval.node), (yyvsp[(2) - (2)].node));
6079  /*%
6080  $$ = dispatch1(yield, $2);
6081  %*/
6082  }
6083  break;
6084 
6085  case 69:
6086 
6087 /* Line 1806 of yacc.c */
6088 #line 1461 "parse.y"
6089  {
6090  /*%%%*/
6091  (yyval.node) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].node)));
6092  /*%
6093  $$ = dispatch1(return, $2);
6094  %*/
6095  }
6096  break;
6097 
6098  case 70:
6099 
6100 /* Line 1806 of yacc.c */
6101 #line 1469 "parse.y"
6102  {
6103  /*%%%*/
6104  (yyval.node) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].node)));
6105  /*%
6106  $$ = dispatch1(break, $2);
6107  %*/
6108  }
6109  break;
6110 
6111  case 71:
6112 
6113 /* Line 1806 of yacc.c */
6114 #line 1477 "parse.y"
6115  {
6116  /*%%%*/
6117  (yyval.node) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].node)));
6118  /*%
6119  $$ = dispatch1(next, $2);
6120  %*/
6121  }
6122  break;
6123 
6124  case 73:
6125 
6126 /* Line 1806 of yacc.c */
6127 #line 1488 "parse.y"
6128  {
6129  /*%%%*/
6130  (yyval.node) = (yyvsp[(2) - (3)].node);
6131  /*%
6132  $$ = dispatch1(mlhs_paren, $2);
6133  %*/
6134  }
6135  break;
6136 
6137  case 75:
6138 
6139 /* Line 1806 of yacc.c */
6140 #line 1499 "parse.y"
6141  {
6142  /*%%%*/
6143  (yyval.node) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].node)), 0);
6144  /*%
6145  $$ = dispatch1(mlhs_paren, $2);
6146  %*/
6147  }
6148  break;
6149 
6150  case 76:
6151 
6152 /* Line 1806 of yacc.c */
6153 #line 1509 "parse.y"
6154  {
6155  /*%%%*/
6156  (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0);
6157  /*%
6158  $$ = $1;
6159  %*/
6160  }
6161  break;
6162 
6163  case 77:
6164 
6165 /* Line 1806 of yacc.c */
6166 #line 1517 "parse.y"
6167  {
6168  /*%%%*/
6169  (yyval.node) = NEW_MASGN(list_append((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node)), 0);
6170  /*%
6171  $$ = mlhs_add($1, $2);
6172  %*/
6173  }
6174  break;
6175 
6176  case 78:
6177 
6178 /* Line 1806 of yacc.c */
6179 #line 1525 "parse.y"
6180  {
6181  /*%%%*/
6182  (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
6183  /*%
6184  $$ = mlhs_add_star($1, $3);
6185  %*/
6186  }
6187  break;
6188 
6189  case 79:
6190 
6191 /* Line 1806 of yacc.c */
6192 #line 1533 "parse.y"
6193  {
6194  /*%%%*/
6195  (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG((yyvsp[(3) - (5)].node),(yyvsp[(5) - (5)].node)));
6196  /*%
6197  $1 = mlhs_add_star($1, $3);
6198  $$ = mlhs_add($1, $5);
6199  %*/
6200  }
6201  break;
6202 
6203  case 80:
6204 
6205 /* Line 1806 of yacc.c */
6206 #line 1542 "parse.y"
6207  {
6208  /*%%%*/
6209  (yyval.node) = NEW_MASGN((yyvsp[(1) - (2)].node), -1);
6210  /*%
6211  $$ = mlhs_add_star($1, Qnil);
6212  %*/
6213  }
6214  break;
6215 
6216  case 81:
6217 
6218 /* Line 1806 of yacc.c */
6219 #line 1550 "parse.y"
6220  {
6221  /*%%%*/
6222  (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), NEW_POSTARG(-1, (yyvsp[(4) - (4)].node)));
6223  /*%
6224  $1 = mlhs_add_star($1, Qnil);
6225  $$ = mlhs_add($1, $4);
6226  %*/
6227  }
6228  break;
6229 
6230  case 82:
6231 
6232 /* Line 1806 of yacc.c */
6233 #line 1559 "parse.y"
6234  {
6235  /*%%%*/
6236  (yyval.node) = NEW_MASGN(0, (yyvsp[(2) - (2)].node));
6237  /*%
6238  $$ = mlhs_add_star(mlhs_new(), $2);
6239  %*/
6240  }
6241  break;
6242 
6243  case 83:
6244 
6245 /* Line 1806 of yacc.c */
6246 #line 1567 "parse.y"
6247  {
6248  /*%%%*/
6249  (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].node),(yyvsp[(4) - (4)].node)));
6250  /*%
6251  $2 = mlhs_add_star(mlhs_new(), $2);
6252  $$ = mlhs_add($2, $4);
6253  %*/
6254  }
6255  break;
6256 
6257  case 84:
6258 
6259 /* Line 1806 of yacc.c */
6260 #line 1576 "parse.y"
6261  {
6262  /*%%%*/
6263  (yyval.node) = NEW_MASGN(0, -1);
6264  /*%
6265  $$ = mlhs_add_star(mlhs_new(), Qnil);
6266  %*/
6267  }
6268  break;
6269 
6270  case 85:
6271 
6272 /* Line 1806 of yacc.c */
6273 #line 1584 "parse.y"
6274  {
6275  /*%%%*/
6276  (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node)));
6277  /*%
6278  $$ = mlhs_add_star(mlhs_new(), Qnil);
6279  $$ = mlhs_add($$, $3);
6280  %*/
6281  }
6282  break;
6283 
6284  case 87:
6285 
6286 /* Line 1806 of yacc.c */
6287 #line 1596 "parse.y"
6288  {
6289  /*%%%*/
6290  (yyval.node) = (yyvsp[(2) - (3)].node);
6291  /*%
6292  $$ = dispatch1(mlhs_paren, $2);
6293  %*/
6294  }
6295  break;
6296 
6297  case 88:
6298 
6299 /* Line 1806 of yacc.c */
6300 #line 1606 "parse.y"
6301  {
6302  /*%%%*/
6303  (yyval.node) = NEW_LIST((yyvsp[(1) - (2)].node));
6304  /*%
6305  $$ = mlhs_add(mlhs_new(), $1);
6306  %*/
6307  }
6308  break;
6309 
6310  case 89:
6311 
6312 /* Line 1806 of yacc.c */
6313 #line 1614 "parse.y"
6314  {
6315  /*%%%*/
6316  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
6317  /*%
6318  $$ = mlhs_add($1, $2);
6319  %*/
6320  }
6321  break;
6322 
6323  case 90:
6324 
6325 /* Line 1806 of yacc.c */
6326 #line 1624 "parse.y"
6327  {
6328  /*%%%*/
6329  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
6330  /*%
6331  $$ = mlhs_add(mlhs_new(), $1);
6332  %*/
6333  }
6334  break;
6335 
6336  case 91:
6337 
6338 /* Line 1806 of yacc.c */
6339 #line 1632 "parse.y"
6340  {
6341  /*%%%*/
6342  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
6343  /*%
6344  $$ = mlhs_add($1, $3);
6345  %*/
6346  }
6347  break;
6348 
6349  case 92:
6350 
6351 /* Line 1806 of yacc.c */
6352 #line 1642 "parse.y"
6353  {
6354  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6355  }
6356  break;
6357 
6358  case 93:
6359 
6360 /* Line 1806 of yacc.c */
6361 #line 1646 "parse.y"
6362  {
6363  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6364  }
6365  break;
6366 
6367  case 94:
6368 
6369 /* Line 1806 of yacc.c */
6370 #line 1650 "parse.y"
6371  {
6372  /*%%%*/
6373  (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
6374  /*%
6375  $$ = dispatch2(aref_field, $1, escape_Qundef($3));
6376  %*/
6377  }
6378  break;
6379 
6380  case 95:
6381 
6382 /* Line 1806 of yacc.c */
6383 #line 1658 "parse.y"
6384  {
6385  /*%%%*/
6386  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6387  /*%
6388  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6389  %*/
6390  }
6391  break;
6392 
6393  case 96:
6394 
6395 /* Line 1806 of yacc.c */
6396 #line 1666 "parse.y"
6397  {
6398  /*%%%*/
6399  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6400  /*%
6401  $$ = dispatch2(const_path_field, $1, $3);
6402  %*/
6403  }
6404  break;
6405 
6406  case 97:
6407 
6408 /* Line 1806 of yacc.c */
6409 #line 1674 "parse.y"
6410  {
6411  /*%%%*/
6412  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6413  /*%
6414  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6415  %*/
6416  }
6417  break;
6418 
6419  case 98:
6420 
6421 /* Line 1806 of yacc.c */
6422 #line 1682 "parse.y"
6423  {
6424  /*%%%*/
6425  if (in_def || in_single)
6426  yyerror("dynamic constant assignment");
6427  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)));
6428  /*%
6429  if (in_def || in_single)
6430  yyerror("dynamic constant assignment");
6431  $$ = dispatch2(const_path_field, $1, $3);
6432  %*/
6433  }
6434  break;
6435 
6436  case 99:
6437 
6438 /* Line 1806 of yacc.c */
6439 #line 1694 "parse.y"
6440  {
6441  /*%%%*/
6442  if (in_def || in_single)
6443  yyerror("dynamic constant assignment");
6444  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id)));
6445  /*%
6446  $$ = dispatch1(top_const_field, $2);
6447  %*/
6448  }
6449  break;
6450 
6451  case 100:
6452 
6453 /* Line 1806 of yacc.c */
6454 #line 1704 "parse.y"
6455  {
6456  /*%%%*/
6457  rb_backref_error((yyvsp[(1) - (1)].node));
6458  (yyval.node) = NEW_BEGIN(0);
6459  /*%
6460  $$ = dispatch1(var_field, $1);
6461  $$ = dispatch1(assign_error, $$);
6462  %*/
6463  }
6464  break;
6465 
6466  case 101:
6467 
6468 /* Line 1806 of yacc.c */
6469 #line 1716 "parse.y"
6470  {
6471  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6472  /*%%%*/
6473  if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0);
6474  /*%
6475  $$ = dispatch1(var_field, $$);
6476  %*/
6477  }
6478  break;
6479 
6480  case 102:
6481 
6482 /* Line 1806 of yacc.c */
6483 #line 1725 "parse.y"
6484  {
6485  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
6486  /*%%%*/
6487  if (!(yyval.node)) (yyval.node) = NEW_BEGIN(0);
6488  /*%
6489  $$ = dispatch1(var_field, $$);
6490  %*/
6491  }
6492  break;
6493 
6494  case 103:
6495 
6496 /* Line 1806 of yacc.c */
6497 #line 1734 "parse.y"
6498  {
6499  /*%%%*/
6500  (yyval.node) = aryset((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
6501  /*%
6502  $$ = dispatch2(aref_field, $1, escape_Qundef($3));
6503  %*/
6504  }
6505  break;
6506 
6507  case 104:
6508 
6509 /* Line 1806 of yacc.c */
6510 #line 1742 "parse.y"
6511  {
6512  /*%%%*/
6513  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6514  /*%
6515  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6516  %*/
6517  }
6518  break;
6519 
6520  case 105:
6521 
6522 /* Line 1806 of yacc.c */
6523 #line 1750 "parse.y"
6524  {
6525  /*%%%*/
6526  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6527  /*%
6528  $$ = dispatch3(field, $1, ripper_intern("::"), $3);
6529  %*/
6530  }
6531  break;
6532 
6533  case 106:
6534 
6535 /* Line 1806 of yacc.c */
6536 #line 1758 "parse.y"
6537  {
6538  /*%%%*/
6539  (yyval.node) = attrset((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6540  /*%
6541  $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
6542  %*/
6543  }
6544  break;
6545 
6546  case 107:
6547 
6548 /* Line 1806 of yacc.c */
6549 #line 1766 "parse.y"
6550  {
6551  /*%%%*/
6552  if (in_def || in_single)
6553  yyerror("dynamic constant assignment");
6554  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id)));
6555  /*%
6556  $$ = dispatch2(const_path_field, $1, $3);
6557  if (in_def || in_single) {
6558  $$ = dispatch1(assign_error, $$);
6559  }
6560  %*/
6561  }
6562  break;
6563 
6564  case 108:
6565 
6566 /* Line 1806 of yacc.c */
6567 #line 1779 "parse.y"
6568  {
6569  /*%%%*/
6570  if (in_def || in_single)
6571  yyerror("dynamic constant assignment");
6572  (yyval.node) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].id)));
6573  /*%
6574  $$ = dispatch1(top_const_field, $2);
6575  if (in_def || in_single) {
6576  $$ = dispatch1(assign_error, $$);
6577  }
6578  %*/
6579  }
6580  break;
6581 
6582  case 109:
6583 
6584 /* Line 1806 of yacc.c */
6585 #line 1792 "parse.y"
6586  {
6587  /*%%%*/
6588  rb_backref_error((yyvsp[(1) - (1)].node));
6589  (yyval.node) = NEW_BEGIN(0);
6590  /*%
6591  $$ = dispatch1(assign_error, $1);
6592  %*/
6593  }
6594  break;
6595 
6596  case 110:
6597 
6598 /* Line 1806 of yacc.c */
6599 #line 1803 "parse.y"
6600  {
6601  /*%%%*/
6602  yyerror("class/module name must be CONSTANT");
6603  /*%
6604  $$ = dispatch1(class_name_error, $1);
6605  %*/
6606  }
6607  break;
6608 
6609  case 112:
6610 
6611 /* Line 1806 of yacc.c */
6612 #line 1814 "parse.y"
6613  {
6614  /*%%%*/
6615  (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id));
6616  /*%
6617  $$ = dispatch1(top_const_ref, $2);
6618  %*/
6619  }
6620  break;
6621 
6622  case 113:
6623 
6624 /* Line 1806 of yacc.c */
6625 #line 1822 "parse.y"
6626  {
6627  /*%%%*/
6628  (yyval.node) = NEW_COLON2(0, (yyval.node));
6629  /*%
6630  $$ = dispatch1(const_ref, $1);
6631  %*/
6632  }
6633  break;
6634 
6635  case 114:
6636 
6637 /* Line 1806 of yacc.c */
6638 #line 1830 "parse.y"
6639  {
6640  /*%%%*/
6641  (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
6642  /*%
6643  $$ = dispatch2(const_path_ref, $1, $3);
6644  %*/
6645  }
6646  break;
6647 
6648  case 118:
6649 
6650 /* Line 1806 of yacc.c */
6651 #line 1843 "parse.y"
6652  {
6653  lex_state = EXPR_ENDFN;
6654  (yyval.id) = (yyvsp[(1) - (1)].id);
6655  }
6656  break;
6657 
6658  case 119:
6659 
6660 /* Line 1806 of yacc.c */
6661 #line 1848 "parse.y"
6662  {
6663  lex_state = EXPR_ENDFN;
6664  /*%%%*/
6665  (yyval.id) = (yyvsp[(1) - (1)].id);
6666  /*%
6667  $$ = $1;
6668  %*/
6669  }
6670  break;
6671 
6672  case 122:
6673 
6674 /* Line 1806 of yacc.c */
6675 #line 1863 "parse.y"
6676  {
6677  /*%%%*/
6678  (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id)));
6679  /*%
6680  $$ = dispatch1(symbol_literal, $1);
6681  %*/
6682  }
6683  break;
6684 
6685  case 124:
6686 
6687 /* Line 1806 of yacc.c */
6688 #line 1874 "parse.y"
6689  {
6690  /*%%%*/
6691  (yyval.node) = NEW_UNDEF((yyvsp[(1) - (1)].node));
6692  /*%
6693  $$ = rb_ary_new3(1, $1);
6694  %*/
6695  }
6696  break;
6697 
6698  case 125:
6699 
6700 /* Line 1806 of yacc.c */
6701 #line 1881 "parse.y"
6702  {lex_state = EXPR_FNAME;}
6703  break;
6704 
6705  case 126:
6706 
6707 /* Line 1806 of yacc.c */
6708 #line 1882 "parse.y"
6709  {
6710  /*%%%*/
6711  (yyval.node) = block_append((yyvsp[(1) - (4)].node), NEW_UNDEF((yyvsp[(4) - (4)].node)));
6712  /*%
6713  rb_ary_push($1, $4);
6714  %*/
6715  }
6716  break;
6717 
6718  case 127:
6719 
6720 /* Line 1806 of yacc.c */
6721 #line 1891 "parse.y"
6722  { ifndef_ripper((yyval.id) = '|'); }
6723  break;
6724 
6725  case 128:
6726 
6727 /* Line 1806 of yacc.c */
6728 #line 1892 "parse.y"
6729  { ifndef_ripper((yyval.id) = '^'); }
6730  break;
6731 
6732  case 129:
6733 
6734 /* Line 1806 of yacc.c */
6735 #line 1893 "parse.y"
6736  { ifndef_ripper((yyval.id) = '&'); }
6737  break;
6738 
6739  case 130:
6740 
6741 /* Line 1806 of yacc.c */
6742 #line 1894 "parse.y"
6743  { ifndef_ripper((yyval.id) = tCMP); }
6744  break;
6745 
6746  case 131:
6747 
6748 /* Line 1806 of yacc.c */
6749 #line 1895 "parse.y"
6750  { ifndef_ripper((yyval.id) = tEQ); }
6751  break;
6752 
6753  case 132:
6754 
6755 /* Line 1806 of yacc.c */
6756 #line 1896 "parse.y"
6757  { ifndef_ripper((yyval.id) = tEQQ); }
6758  break;
6759 
6760  case 133:
6761 
6762 /* Line 1806 of yacc.c */
6763 #line 1897 "parse.y"
6764  { ifndef_ripper((yyval.id) = tMATCH); }
6765  break;
6766 
6767  case 134:
6768 
6769 /* Line 1806 of yacc.c */
6770 #line 1898 "parse.y"
6771  { ifndef_ripper((yyval.id) = tNMATCH); }
6772  break;
6773 
6774  case 135:
6775 
6776 /* Line 1806 of yacc.c */
6777 #line 1899 "parse.y"
6778  { ifndef_ripper((yyval.id) = '>'); }
6779  break;
6780 
6781  case 136:
6782 
6783 /* Line 1806 of yacc.c */
6784 #line 1900 "parse.y"
6785  { ifndef_ripper((yyval.id) = tGEQ); }
6786  break;
6787 
6788  case 137:
6789 
6790 /* Line 1806 of yacc.c */
6791 #line 1901 "parse.y"
6792  { ifndef_ripper((yyval.id) = '<'); }
6793  break;
6794 
6795  case 138:
6796 
6797 /* Line 1806 of yacc.c */
6798 #line 1902 "parse.y"
6799  { ifndef_ripper((yyval.id) = tLEQ); }
6800  break;
6801 
6802  case 139:
6803 
6804 /* Line 1806 of yacc.c */
6805 #line 1903 "parse.y"
6806  { ifndef_ripper((yyval.id) = tNEQ); }
6807  break;
6808 
6809  case 140:
6810 
6811 /* Line 1806 of yacc.c */
6812 #line 1904 "parse.y"
6813  { ifndef_ripper((yyval.id) = tLSHFT); }
6814  break;
6815 
6816  case 141:
6817 
6818 /* Line 1806 of yacc.c */
6819 #line 1905 "parse.y"
6820  { ifndef_ripper((yyval.id) = tRSHFT); }
6821  break;
6822 
6823  case 142:
6824 
6825 /* Line 1806 of yacc.c */
6826 #line 1906 "parse.y"
6827  { ifndef_ripper((yyval.id) = '+'); }
6828  break;
6829 
6830  case 143:
6831 
6832 /* Line 1806 of yacc.c */
6833 #line 1907 "parse.y"
6834  { ifndef_ripper((yyval.id) = '-'); }
6835  break;
6836 
6837  case 144:
6838 
6839 /* Line 1806 of yacc.c */
6840 #line 1908 "parse.y"
6841  { ifndef_ripper((yyval.id) = '*'); }
6842  break;
6843 
6844  case 145:
6845 
6846 /* Line 1806 of yacc.c */
6847 #line 1909 "parse.y"
6848  { ifndef_ripper((yyval.id) = '*'); }
6849  break;
6850 
6851  case 146:
6852 
6853 /* Line 1806 of yacc.c */
6854 #line 1910 "parse.y"
6855  { ifndef_ripper((yyval.id) = '/'); }
6856  break;
6857 
6858  case 147:
6859 
6860 /* Line 1806 of yacc.c */
6861 #line 1911 "parse.y"
6862  { ifndef_ripper((yyval.id) = '%'); }
6863  break;
6864 
6865  case 148:
6866 
6867 /* Line 1806 of yacc.c */
6868 #line 1912 "parse.y"
6869  { ifndef_ripper((yyval.id) = tPOW); }
6870  break;
6871 
6872  case 149:
6873 
6874 /* Line 1806 of yacc.c */
6875 #line 1913 "parse.y"
6876  { ifndef_ripper((yyval.id) = tDSTAR); }
6877  break;
6878 
6879  case 150:
6880 
6881 /* Line 1806 of yacc.c */
6882 #line 1914 "parse.y"
6883  { ifndef_ripper((yyval.id) = '!'); }
6884  break;
6885 
6886  case 151:
6887 
6888 /* Line 1806 of yacc.c */
6889 #line 1915 "parse.y"
6890  { ifndef_ripper((yyval.id) = '~'); }
6891  break;
6892 
6893  case 152:
6894 
6895 /* Line 1806 of yacc.c */
6896 #line 1916 "parse.y"
6897  { ifndef_ripper((yyval.id) = tUPLUS); }
6898  break;
6899 
6900  case 153:
6901 
6902 /* Line 1806 of yacc.c */
6903 #line 1917 "parse.y"
6904  { ifndef_ripper((yyval.id) = tUMINUS); }
6905  break;
6906 
6907  case 154:
6908 
6909 /* Line 1806 of yacc.c */
6910 #line 1918 "parse.y"
6911  { ifndef_ripper((yyval.id) = tAREF); }
6912  break;
6913 
6914  case 155:
6915 
6916 /* Line 1806 of yacc.c */
6917 #line 1919 "parse.y"
6918  { ifndef_ripper((yyval.id) = tASET); }
6919  break;
6920 
6921  case 156:
6922 
6923 /* Line 1806 of yacc.c */
6924 #line 1920 "parse.y"
6925  { ifndef_ripper((yyval.id) = '`'); }
6926  break;
6927 
6928  case 198:
6929 
6930 /* Line 1806 of yacc.c */
6931 #line 1938 "parse.y"
6932  {
6933  /*%%%*/
6934  value_expr((yyvsp[(3) - (3)].node));
6935  (yyval.node) = node_assign((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
6936  /*%
6937  $$ = dispatch2(assign, $1, $3);
6938  %*/
6939  }
6940  break;
6941 
6942  case 199:
6943 
6944 /* Line 1806 of yacc.c */
6945 #line 1947 "parse.y"
6946  {
6947  /*%%%*/
6948  value_expr((yyvsp[(3) - (5)].node));
6949  (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0);
6950  (yyval.node) = node_assign((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node));
6951  /*%
6952  $$ = dispatch2(assign, $1, dispatch2(rescue_mod, $3, $5));
6953  %*/
6954  }
6955  break;
6956 
6957  case 200:
6958 
6959 /* Line 1806 of yacc.c */
6960 #line 1957 "parse.y"
6961  {
6962  value_expr((yyvsp[(3) - (3)].node));
6963  (yyval.node) = new_op_assign((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].node));
6964  }
6965  break;
6966 
6967  case 201:
6968 
6969 /* Line 1806 of yacc.c */
6970 #line 1962 "parse.y"
6971  {
6972  /*%%%*/
6973  value_expr((yyvsp[(3) - (5)].node));
6974  (yyvsp[(3) - (5)].node) = NEW_RESCUE((yyvsp[(3) - (5)].node), NEW_RESBODY(0,(yyvsp[(5) - (5)].node),0), 0);
6975  /*%
6976  $3 = dispatch2(rescue_mod, $3, $5);
6977  %*/
6978  (yyval.node) = new_op_assign((yyvsp[(1) - (5)].node), (yyvsp[(2) - (5)].id), (yyvsp[(3) - (5)].node));
6979  }
6980  break;
6981 
6982  case 202:
6983 
6984 /* Line 1806 of yacc.c */
6985 #line 1972 "parse.y"
6986  {
6987  /*%%%*/
6988  NODE *args;
6989 
6990  value_expr((yyvsp[(6) - (6)].node));
6991  if (!(yyvsp[(3) - (6)].node)) (yyvsp[(3) - (6)].node) = NEW_ZARRAY();
6992  if (nd_type((yyvsp[(3) - (6)].node)) == NODE_BLOCK_PASS) {
6993  args = NEW_ARGSCAT((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
6994  }
6995  else {
6996  args = arg_concat((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
6997  }
6998  if ((yyvsp[(5) - (6)].id) == tOROP) {
6999  (yyvsp[(5) - (6)].id) = 0;
7000  }
7001  else if ((yyvsp[(5) - (6)].id) == tANDOP) {
7002  (yyvsp[(5) - (6)].id) = 1;
7003  }
7004  (yyval.node) = NEW_OP_ASGN1((yyvsp[(1) - (6)].node), (yyvsp[(5) - (6)].id), args);
7005  fixpos((yyval.node), (yyvsp[(1) - (6)].node));
7006  /*%
7007  $1 = dispatch2(aref_field, $1, escape_Qundef($3));
7008  $$ = dispatch3(opassign, $1, $5, $6);
7009  %*/
7010  }
7011  break;
7012 
7013  case 203:
7014 
7015 /* Line 1806 of yacc.c */
7016 #line 1998 "parse.y"
7017  {
7018  value_expr((yyvsp[(5) - (5)].node));
7019  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
7020  }
7021  break;
7022 
7023  case 204:
7024 
7025 /* Line 1806 of yacc.c */
7026 #line 2003 "parse.y"
7027  {
7028  value_expr((yyvsp[(5) - (5)].node));
7029  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_id2sym('.'), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
7030  }
7031  break;
7032 
7033  case 205:
7034 
7035 /* Line 1806 of yacc.c */
7036 #line 2008 "parse.y"
7037  {
7038  value_expr((yyvsp[(5) - (5)].node));
7039  (yyval.node) = new_attr_op_assign((yyvsp[(1) - (5)].node), ripper_intern("::"), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
7040  }
7041  break;
7042 
7043  case 206:
7044 
7045 /* Line 1806 of yacc.c */
7046 #line 2013 "parse.y"
7047  {
7048  /*%%%*/
7049  (yyval.node) = NEW_COLON2((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id));
7050  (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(4) - (5)].id), (yyvsp[(5) - (5)].node));
7051  /*%
7052  $$ = dispatch2(const_path_field, $1, $3);
7053  $$ = dispatch3(opassign, $$, $4, $5);
7054  %*/
7055  }
7056  break;
7057 
7058  case 207:
7059 
7060 /* Line 1806 of yacc.c */
7061 #line 2023 "parse.y"
7062  {
7063  /*%%%*/
7064  (yyval.node) = NEW_COLON3((yyvsp[(2) - (4)].id));
7065  (yyval.node) = new_const_op_assign((yyval.node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
7066  /*%
7067  $$ = dispatch1(top_const_field, $2);
7068  $$ = dispatch3(opassign, $$, $3, $4);
7069  %*/
7070  }
7071  break;
7072 
7073  case 208:
7074 
7075 /* Line 1806 of yacc.c */
7076 #line 2033 "parse.y"
7077  {
7078  /*%%%*/
7079  rb_backref_error((yyvsp[(1) - (3)].node));
7080  (yyval.node) = NEW_BEGIN(0);
7081  /*%
7082  $$ = dispatch1(var_field, $1);
7083  $$ = dispatch3(opassign, $$, $2, $3);
7084  $$ = dispatch1(assign_error, $$);
7085  %*/
7086  }
7087  break;
7088 
7089  case 209:
7090 
7091 /* Line 1806 of yacc.c */
7092 #line 2044 "parse.y"
7093  {
7094  /*%%%*/
7095  value_expr((yyvsp[(1) - (3)].node));
7096  value_expr((yyvsp[(3) - (3)].node));
7097  (yyval.node) = NEW_DOT2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7098  if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) &&
7099  (yyvsp[(3) - (3)].node) && nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) {
7101  }
7102  /*%
7103  $$ = dispatch2(dot2, $1, $3);
7104  %*/
7105  }
7106  break;
7107 
7108  case 210:
7109 
7110 /* Line 1806 of yacc.c */
7111 #line 2058 "parse.y"
7112  {
7113  /*%%%*/
7114  value_expr((yyvsp[(1) - (3)].node));
7115  value_expr((yyvsp[(3) - (3)].node));
7116  (yyval.node) = NEW_DOT3((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7117  if ((yyvsp[(1) - (3)].node) && nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].node)->nd_lit) &&
7118  (yyvsp[(3) - (3)].node) && nd_type((yyvsp[(3) - (3)].node)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].node)->nd_lit)) {
7120  }
7121  /*%
7122  $$ = dispatch2(dot3, $1, $3);
7123  %*/
7124  }
7125  break;
7126 
7127  case 211:
7128 
7129 /* Line 1806 of yacc.c */
7130 #line 2072 "parse.y"
7131  {
7132  /*%%%*/
7133  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '+', (yyvsp[(3) - (3)].node));
7134  /*%
7135  $$ = dispatch3(binary, $1, ID2SYM('+'), $3);
7136  %*/
7137  }
7138  break;
7139 
7140  case 212:
7141 
7142 /* Line 1806 of yacc.c */
7143 #line 2080 "parse.y"
7144  {
7145  /*%%%*/
7146  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '-', (yyvsp[(3) - (3)].node));
7147  /*%
7148  $$ = dispatch3(binary, $1, ID2SYM('-'), $3);
7149  %*/
7150  }
7151  break;
7152 
7153  case 213:
7154 
7155 /* Line 1806 of yacc.c */
7156 #line 2088 "parse.y"
7157  {
7158  /*%%%*/
7159  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '*', (yyvsp[(3) - (3)].node));
7160  /*%
7161  $$ = dispatch3(binary, $1, ID2SYM('*'), $3);
7162  %*/
7163  }
7164  break;
7165 
7166  case 214:
7167 
7168 /* Line 1806 of yacc.c */
7169 #line 2096 "parse.y"
7170  {
7171  /*%%%*/
7172  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '/', (yyvsp[(3) - (3)].node));
7173  /*%
7174  $$ = dispatch3(binary, $1, ID2SYM('/'), $3);
7175  %*/
7176  }
7177  break;
7178 
7179  case 215:
7180 
7181 /* Line 1806 of yacc.c */
7182 #line 2104 "parse.y"
7183  {
7184  /*%%%*/
7185  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '%', (yyvsp[(3) - (3)].node));
7186  /*%
7187  $$ = dispatch3(binary, $1, ID2SYM('%'), $3);
7188  %*/
7189  }
7190  break;
7191 
7192  case 216:
7193 
7194 /* Line 1806 of yacc.c */
7195 #line 2112 "parse.y"
7196  {
7197  /*%%%*/
7198  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tPOW, (yyvsp[(3) - (3)].node));
7199  /*%
7200  $$ = dispatch3(binary, $1, ripper_intern("**"), $3);
7201  %*/
7202  }
7203  break;
7204 
7205  case 217:
7206 
7207 /* Line 1806 of yacc.c */
7208 #line 2120 "parse.y"
7209  {
7210  /*%%%*/
7211  (yyval.node) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].node), tPOW, (yyvsp[(4) - (4)].node)), tUMINUS, 0);
7212  /*%
7213  $$ = dispatch3(binary, $2, ripper_intern("**"), $4);
7214  $$ = dispatch2(unary, ripper_intern("-@"), $$);
7215  %*/
7216  }
7217  break;
7218 
7219  case 218:
7220 
7221 /* Line 1806 of yacc.c */
7222 #line 2129 "parse.y"
7223  {
7224  /*%%%*/
7225  (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUPLUS);
7226  /*%
7227  $$ = dispatch2(unary, ripper_intern("+@"), $2);
7228  %*/
7229  }
7230  break;
7231 
7232  case 219:
7233 
7234 /* Line 1806 of yacc.c */
7235 #line 2137 "parse.y"
7236  {
7237  /*%%%*/
7238  (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), tUMINUS);
7239  /*%
7240  $$ = dispatch2(unary, ripper_intern("-@"), $2);
7241  %*/
7242  }
7243  break;
7244 
7245  case 220:
7246 
7247 /* Line 1806 of yacc.c */
7248 #line 2145 "parse.y"
7249  {
7250  /*%%%*/
7251  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '|', (yyvsp[(3) - (3)].node));
7252  /*%
7253  $$ = dispatch3(binary, $1, ID2SYM('|'), $3);
7254  %*/
7255  }
7256  break;
7257 
7258  case 221:
7259 
7260 /* Line 1806 of yacc.c */
7261 #line 2153 "parse.y"
7262  {
7263  /*%%%*/
7264  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '^', (yyvsp[(3) - (3)].node));
7265  /*%
7266  $$ = dispatch3(binary, $1, ID2SYM('^'), $3);
7267  %*/
7268  }
7269  break;
7270 
7271  case 222:
7272 
7273 /* Line 1806 of yacc.c */
7274 #line 2161 "parse.y"
7275  {
7276  /*%%%*/
7277  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '&', (yyvsp[(3) - (3)].node));
7278  /*%
7279  $$ = dispatch3(binary, $1, ID2SYM('&'), $3);
7280  %*/
7281  }
7282  break;
7283 
7284  case 223:
7285 
7286 /* Line 1806 of yacc.c */
7287 #line 2169 "parse.y"
7288  {
7289  /*%%%*/
7290  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tCMP, (yyvsp[(3) - (3)].node));
7291  /*%
7292  $$ = dispatch3(binary, $1, ripper_intern("<=>"), $3);
7293  %*/
7294  }
7295  break;
7296 
7297  case 224:
7298 
7299 /* Line 1806 of yacc.c */
7300 #line 2177 "parse.y"
7301  {
7302  /*%%%*/
7303  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '>', (yyvsp[(3) - (3)].node));
7304  /*%
7305  $$ = dispatch3(binary, $1, ID2SYM('>'), $3);
7306  %*/
7307  }
7308  break;
7309 
7310  case 225:
7311 
7312 /* Line 1806 of yacc.c */
7313 #line 2185 "parse.y"
7314  {
7315  /*%%%*/
7316  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tGEQ, (yyvsp[(3) - (3)].node));
7317  /*%
7318  $$ = dispatch3(binary, $1, ripper_intern(">="), $3);
7319  %*/
7320  }
7321  break;
7322 
7323  case 226:
7324 
7325 /* Line 1806 of yacc.c */
7326 #line 2193 "parse.y"
7327  {
7328  /*%%%*/
7329  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), '<', (yyvsp[(3) - (3)].node));
7330  /*%
7331  $$ = dispatch3(binary, $1, ID2SYM('<'), $3);
7332  %*/
7333  }
7334  break;
7335 
7336  case 227:
7337 
7338 /* Line 1806 of yacc.c */
7339 #line 2201 "parse.y"
7340  {
7341  /*%%%*/
7342  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLEQ, (yyvsp[(3) - (3)].node));
7343  /*%
7344  $$ = dispatch3(binary, $1, ripper_intern("<="), $3);
7345  %*/
7346  }
7347  break;
7348 
7349  case 228:
7350 
7351 /* Line 1806 of yacc.c */
7352 #line 2209 "parse.y"
7353  {
7354  /*%%%*/
7355  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQ, (yyvsp[(3) - (3)].node));
7356  /*%
7357  $$ = dispatch3(binary, $1, ripper_intern("=="), $3);
7358  %*/
7359  }
7360  break;
7361 
7362  case 229:
7363 
7364 /* Line 1806 of yacc.c */
7365 #line 2217 "parse.y"
7366  {
7367  /*%%%*/
7368  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tEQQ, (yyvsp[(3) - (3)].node));
7369  /*%
7370  $$ = dispatch3(binary, $1, ripper_intern("==="), $3);
7371  %*/
7372  }
7373  break;
7374 
7375  case 230:
7376 
7377 /* Line 1806 of yacc.c */
7378 #line 2225 "parse.y"
7379  {
7380  /*%%%*/
7381  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNEQ, (yyvsp[(3) - (3)].node));
7382  /*%
7383  $$ = dispatch3(binary, $1, ripper_intern("!="), $3);
7384  %*/
7385  }
7386  break;
7387 
7388  case 231:
7389 
7390 /* Line 1806 of yacc.c */
7391 #line 2233 "parse.y"
7392  {
7393  /*%%%*/
7394  (yyval.node) = match_op((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7395  if (nd_type((yyvsp[(1) - (3)].node)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].node)->nd_lit, T_REGEXP)) {
7396  (yyval.node) = reg_named_capture_assign((yyvsp[(1) - (3)].node)->nd_lit, (yyval.node));
7397  }
7398  /*%
7399  $$ = dispatch3(binary, $1, ripper_intern("=~"), $3);
7400  %*/
7401  }
7402  break;
7403 
7404  case 232:
7405 
7406 /* Line 1806 of yacc.c */
7407 #line 2244 "parse.y"
7408  {
7409  /*%%%*/
7410  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tNMATCH, (yyvsp[(3) - (3)].node));
7411  /*%
7412  $$ = dispatch3(binary, $1, ripper_intern("!~"), $3);
7413  %*/
7414  }
7415  break;
7416 
7417  case 233:
7418 
7419 /* Line 1806 of yacc.c */
7420 #line 2252 "parse.y"
7421  {
7422  /*%%%*/
7423  (yyval.node) = call_uni_op(cond((yyvsp[(2) - (2)].node)), '!');
7424  /*%
7425  $$ = dispatch2(unary, ID2SYM('!'), $2);
7426  %*/
7427  }
7428  break;
7429 
7430  case 234:
7431 
7432 /* Line 1806 of yacc.c */
7433 #line 2260 "parse.y"
7434  {
7435  /*%%%*/
7436  (yyval.node) = call_uni_op((yyvsp[(2) - (2)].node), '~');
7437  /*%
7438  $$ = dispatch2(unary, ID2SYM('~'), $2);
7439  %*/
7440  }
7441  break;
7442 
7443  case 235:
7444 
7445 /* Line 1806 of yacc.c */
7446 #line 2268 "parse.y"
7447  {
7448  /*%%%*/
7449  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tLSHFT, (yyvsp[(3) - (3)].node));
7450  /*%
7451  $$ = dispatch3(binary, $1, ripper_intern("<<"), $3);
7452  %*/
7453  }
7454  break;
7455 
7456  case 236:
7457 
7458 /* Line 1806 of yacc.c */
7459 #line 2276 "parse.y"
7460  {
7461  /*%%%*/
7462  (yyval.node) = call_bin_op((yyvsp[(1) - (3)].node), tRSHFT, (yyvsp[(3) - (3)].node));
7463  /*%
7464  $$ = dispatch3(binary, $1, ripper_intern(">>"), $3);
7465  %*/
7466  }
7467  break;
7468 
7469  case 237:
7470 
7471 /* Line 1806 of yacc.c */
7472 #line 2284 "parse.y"
7473  {
7474  /*%%%*/
7475  (yyval.node) = logop(NODE_AND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7476  /*%
7477  $$ = dispatch3(binary, $1, ripper_intern("&&"), $3);
7478  %*/
7479  }
7480  break;
7481 
7482  case 238:
7483 
7484 /* Line 1806 of yacc.c */
7485 #line 2292 "parse.y"
7486  {
7487  /*%%%*/
7488  (yyval.node) = logop(NODE_OR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7489  /*%
7490  $$ = dispatch3(binary, $1, ripper_intern("||"), $3);
7491  %*/
7492  }
7493  break;
7494 
7495  case 239:
7496 
7497 /* Line 1806 of yacc.c */
7498 #line 2299 "parse.y"
7499  {in_defined = 1;}
7500  break;
7501 
7502  case 240:
7503 
7504 /* Line 1806 of yacc.c */
7505 #line 2300 "parse.y"
7506  {
7507  /*%%%*/
7508  in_defined = 0;
7509  (yyval.node) = new_defined((yyvsp[(4) - (4)].node));
7510  /*%
7511  in_defined = 0;
7512  $$ = dispatch1(defined, $4);
7513  %*/
7514  }
7515  break;
7516 
7517  case 241:
7518 
7519 /* Line 1806 of yacc.c */
7520 #line 2310 "parse.y"
7521  {
7522  /*%%%*/
7523  value_expr((yyvsp[(1) - (6)].node));
7524  (yyval.node) = NEW_IF(cond((yyvsp[(1) - (6)].node)), (yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
7525  fixpos((yyval.node), (yyvsp[(1) - (6)].node));
7526  /*%
7527  $$ = dispatch3(ifop, $1, $3, $6);
7528  %*/
7529  }
7530  break;
7531 
7532  case 242:
7533 
7534 /* Line 1806 of yacc.c */
7535 #line 2320 "parse.y"
7536  {
7537  (yyval.node) = (yyvsp[(1) - (1)].node);
7538  }
7539  break;
7540 
7541  case 243:
7542 
7543 /* Line 1806 of yacc.c */
7544 #line 2326 "parse.y"
7545  {
7546  /*%%%*/
7547  value_expr((yyvsp[(1) - (1)].node));
7548  (yyval.node) = (yyvsp[(1) - (1)].node);
7549  if (!(yyval.node)) (yyval.node) = NEW_NIL();
7550  /*%
7551  $$ = $1;
7552  %*/
7553  }
7554  break;
7555 
7556  case 245:
7557 
7558 /* Line 1806 of yacc.c */
7559 #line 2339 "parse.y"
7560  {
7561  (yyval.node) = (yyvsp[(1) - (2)].node);
7562  }
7563  break;
7564 
7565  case 246:
7566 
7567 /* Line 1806 of yacc.c */
7568 #line 2343 "parse.y"
7569  {
7570  /*%%%*/
7571  (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
7572  /*%
7573  $$ = arg_add_assocs($1, $3);
7574  %*/
7575  }
7576  break;
7577 
7578  case 247:
7579 
7580 /* Line 1806 of yacc.c */
7581 #line 2351 "parse.y"
7582  {
7583  /*%%%*/
7584  (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
7585  /*%
7586  $$ = arg_add_assocs(arg_new(), $1);
7587  %*/
7588  }
7589  break;
7590 
7591  case 248:
7592 
7593 /* Line 1806 of yacc.c */
7594 #line 2361 "parse.y"
7595  {
7596  /*%%%*/
7597  (yyval.node) = (yyvsp[(2) - (3)].node);
7598  /*%
7599  $$ = dispatch1(arg_paren, escape_Qundef($2));
7600  %*/
7601  }
7602  break;
7603 
7604  case 253:
7605 
7606 /* Line 1806 of yacc.c */
7607 #line 2377 "parse.y"
7608  {
7609  (yyval.node) = (yyvsp[(1) - (2)].node);
7610  }
7611  break;
7612 
7613  case 254:
7614 
7615 /* Line 1806 of yacc.c */
7616 #line 2381 "parse.y"
7617  {
7618  /*%%%*/
7619  (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
7620  /*%
7621  $$ = arg_add_assocs($1, $3);
7622  %*/
7623  }
7624  break;
7625 
7626  case 255:
7627 
7628 /* Line 1806 of yacc.c */
7629 #line 2389 "parse.y"
7630  {
7631  /*%%%*/
7632  (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
7633  /*%
7634  $$ = arg_add_assocs(arg_new(), $1);
7635  %*/
7636  }
7637  break;
7638 
7639  case 256:
7640 
7641 /* Line 1806 of yacc.c */
7642 #line 2399 "parse.y"
7643  {
7644  /*%%%*/
7645  value_expr((yyvsp[(1) - (1)].node));
7646  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
7647  /*%
7648  $$ = arg_add(arg_new(), $1);
7649  %*/
7650  }
7651  break;
7652 
7653  case 257:
7654 
7655 /* Line 1806 of yacc.c */
7656 #line 2408 "parse.y"
7657  {
7658  /*%%%*/
7659  (yyval.node) = arg_blk_pass((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
7660  /*%
7661  $$ = arg_add_optblock($1, $2);
7662  %*/
7663  }
7664  break;
7665 
7666  case 258:
7667 
7668 /* Line 1806 of yacc.c */
7669 #line 2416 "parse.y"
7670  {
7671  /*%%%*/
7672  (yyval.node) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].node)));
7673  (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(2) - (2)].node));
7674  /*%
7675  $$ = arg_add_assocs(arg_new(), $1);
7676  $$ = arg_add_optblock($$, $2);
7677  %*/
7678  }
7679  break;
7680 
7681  case 259:
7682 
7683 /* Line 1806 of yacc.c */
7684 #line 2426 "parse.y"
7685  {
7686  /*%%%*/
7687  (yyval.node) = arg_append((yyvsp[(1) - (4)].node), NEW_HASH((yyvsp[(3) - (4)].node)));
7688  (yyval.node) = arg_blk_pass((yyval.node), (yyvsp[(4) - (4)].node));
7689  /*%
7690  $$ = arg_add_optblock(arg_add_assocs($1, $3), $4);
7691  %*/
7692  }
7693  break;
7694 
7695  case 261:
7696 
7697 /* Line 1806 of yacc.c */
7698 #line 2443 "parse.y"
7699  {
7700  (yyval.val) = cmdarg_stack;
7701  CMDARG_PUSH(1);
7702  }
7703  break;
7704 
7705  case 262:
7706 
7707 /* Line 1806 of yacc.c */
7708 #line 2448 "parse.y"
7709  {
7710  /* CMDARG_POP() */
7711  cmdarg_stack = (yyvsp[(1) - (2)].val);
7712  (yyval.node) = (yyvsp[(2) - (2)].node);
7713  }
7714  break;
7715 
7716  case 263:
7717 
7718 /* Line 1806 of yacc.c */
7719 #line 2456 "parse.y"
7720  {
7721  /*%%%*/
7722  (yyval.node) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].node));
7723  /*%
7724  $$ = $2;
7725  %*/
7726  }
7727  break;
7728 
7729  case 264:
7730 
7731 /* Line 1806 of yacc.c */
7732 #line 2466 "parse.y"
7733  {
7734  (yyval.node) = (yyvsp[(2) - (2)].node);
7735  }
7736  break;
7737 
7738  case 265:
7739 
7740 /* Line 1806 of yacc.c */
7741 #line 2470 "parse.y"
7742  {
7743  (yyval.node) = 0;
7744  }
7745  break;
7746 
7747  case 266:
7748 
7749 /* Line 1806 of yacc.c */
7750 #line 2476 "parse.y"
7751  {
7752  /*%%%*/
7753  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
7754  /*%
7755  $$ = arg_add(arg_new(), $1);
7756  %*/
7757  }
7758  break;
7759 
7760  case 267:
7761 
7762 /* Line 1806 of yacc.c */
7763 #line 2484 "parse.y"
7764  {
7765  /*%%%*/
7766  (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node));
7767  /*%
7768  $$ = arg_add_star(arg_new(), $2);
7769  %*/
7770  }
7771  break;
7772 
7773  case 268:
7774 
7775 /* Line 1806 of yacc.c */
7776 #line 2492 "parse.y"
7777  {
7778  /*%%%*/
7779  NODE *n1;
7780  if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) {
7781  (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node));
7782  }
7783  else {
7784  (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7785  }
7786  /*%
7787  $$ = arg_add($1, $3);
7788  %*/
7789  }
7790  break;
7791 
7792  case 269:
7793 
7794 /* Line 1806 of yacc.c */
7795 #line 2506 "parse.y"
7796  {
7797  /*%%%*/
7798  NODE *n1;
7799  if ((nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) {
7800  (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node));
7801  }
7802  else {
7803  (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
7804  }
7805  /*%
7806  $$ = arg_add_star($1, $4);
7807  %*/
7808  }
7809  break;
7810 
7811  case 272:
7812 
7813 /* Line 1806 of yacc.c */
7814 #line 2526 "parse.y"
7815  {
7816  /*%%%*/
7817  NODE *n1;
7818  if ((n1 = splat_array((yyvsp[(1) - (3)].node))) != 0) {
7819  (yyval.node) = list_append(n1, (yyvsp[(3) - (3)].node));
7820  }
7821  else {
7822  (yyval.node) = arg_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
7823  }
7824  /*%
7825  $$ = mrhs_add(args2mrhs($1), $3);
7826  %*/
7827  }
7828  break;
7829 
7830  case 273:
7831 
7832 /* Line 1806 of yacc.c */
7833 #line 2540 "parse.y"
7834  {
7835  /*%%%*/
7836  NODE *n1;
7837  if (nd_type((yyvsp[(4) - (4)].node)) == NODE_ARRAY &&
7838  (n1 = splat_array((yyvsp[(1) - (4)].node))) != 0) {
7839  (yyval.node) = list_concat(n1, (yyvsp[(4) - (4)].node));
7840  }
7841  else {
7842  (yyval.node) = arg_concat((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node));
7843  }
7844  /*%
7845  $$ = mrhs_add_star(args2mrhs($1), $4);
7846  %*/
7847  }
7848  break;
7849 
7850  case 274:
7851 
7852 /* Line 1806 of yacc.c */
7853 #line 2555 "parse.y"
7854  {
7855  /*%%%*/
7856  (yyval.node) = NEW_SPLAT((yyvsp[(2) - (2)].node));
7857  /*%
7858  $$ = mrhs_add_star(mrhs_new(), $2);
7859  %*/
7860  }
7861  break;
7862 
7863  case 285:
7864 
7865 /* Line 1806 of yacc.c */
7866 #line 2575 "parse.y"
7867  {
7868  /*%%%*/
7869  (yyval.node) = NEW_FCALL((yyvsp[(1) - (1)].id), 0);
7870  /*%
7871  $$ = method_arg(dispatch1(fcall, $1), arg_new());
7872  %*/
7873  }
7874  break;
7875 
7876  case 286:
7877 
7878 /* Line 1806 of yacc.c */
7879 #line 2583 "parse.y"
7880  {
7881  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7882  cmdarg_stack = 0;
7883  /*%%%*/
7884  (yyval.num) = ruby_sourceline;
7885  /*%
7886  %*/
7887  }
7888  break;
7889 
7890  case 287:
7891 
7892 /* Line 1806 of yacc.c */
7893 #line 2593 "parse.y"
7894  {
7895  cmdarg_stack = (yyvsp[(1) - (4)].val);
7896  /*%%%*/
7897  if ((yyvsp[(3) - (4)].node) == NULL) {
7898  (yyval.node) = NEW_NIL();
7899  }
7900  else {
7901  if (nd_type((yyvsp[(3) - (4)].node)) == NODE_RESCUE ||
7902  nd_type((yyvsp[(3) - (4)].node)) == NODE_ENSURE)
7903  nd_set_line((yyvsp[(3) - (4)].node), (yyvsp[(2) - (4)].num));
7904  (yyval.node) = NEW_BEGIN((yyvsp[(3) - (4)].node));
7905  }
7906  nd_set_line((yyval.node), (yyvsp[(2) - (4)].num));
7907  /*%
7908  $$ = dispatch1(begin, $3);
7909  %*/
7910  }
7911  break;
7912 
7913  case 288:
7914 
7915 /* Line 1806 of yacc.c */
7916 #line 2610 "parse.y"
7917  {lex_state = EXPR_ENDARG;}
7918  break;
7919 
7920  case 289:
7921 
7922 /* Line 1806 of yacc.c */
7923 #line 2611 "parse.y"
7924  {
7925  /*%%%*/
7926  (yyval.node) = 0;
7927  /*%
7928  $$ = dispatch1(paren, 0);
7929  %*/
7930  }
7931  break;
7932 
7933  case 290:
7934 
7935 /* Line 1806 of yacc.c */
7936 #line 2619 "parse.y"
7937  {
7938  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7939  cmdarg_stack = 0;
7940  }
7941  break;
7942 
7943  case 291:
7944 
7945 /* Line 1806 of yacc.c */
7946 #line 2623 "parse.y"
7947  {lex_state = EXPR_ENDARG;}
7948  break;
7949 
7950  case 292:
7951 
7952 /* Line 1806 of yacc.c */
7953 #line 2624 "parse.y"
7954  {
7955  cmdarg_stack = (yyvsp[(1) - (5)].val);
7956  /*%%%*/
7957  (yyval.node) = (yyvsp[(3) - (5)].node);
7958  /*%
7959  $$ = dispatch1(paren, $3);
7960  %*/
7961  }
7962  break;
7963 
7964  case 293:
7965 
7966 /* Line 1806 of yacc.c */
7967 #line 2633 "parse.y"
7968  {
7969  /*%%%*/
7970  (yyval.node) = (yyvsp[(2) - (3)].node);
7971  /*%
7972  $$ = dispatch1(paren, $2);
7973  %*/
7974  }
7975  break;
7976 
7977  case 294:
7978 
7979 /* Line 1806 of yacc.c */
7980 #line 2641 "parse.y"
7981  {
7982  /*%%%*/
7983  (yyval.node) = NEW_COLON2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id));
7984  /*%
7985  $$ = dispatch2(const_path_ref, $1, $3);
7986  %*/
7987  }
7988  break;
7989 
7990  case 295:
7991 
7992 /* Line 1806 of yacc.c */
7993 #line 2649 "parse.y"
7994  {
7995  /*%%%*/
7996  (yyval.node) = NEW_COLON3((yyvsp[(2) - (2)].id));
7997  /*%
7998  $$ = dispatch1(top_const_ref, $2);
7999  %*/
8000  }
8001  break;
8002 
8003  case 296:
8004 
8005 /* Line 1806 of yacc.c */
8006 #line 2657 "parse.y"
8007  {
8008  /*%%%*/
8009  if ((yyvsp[(2) - (3)].node) == 0) {
8010  (yyval.node) = NEW_ZARRAY(); /* zero length array*/
8011  }
8012  else {
8013  (yyval.node) = (yyvsp[(2) - (3)].node);
8014  }
8015  /*%
8016  $$ = dispatch1(array, escape_Qundef($2));
8017  %*/
8018  }
8019  break;
8020 
8021  case 297:
8022 
8023 /* Line 1806 of yacc.c */
8024 #line 2670 "parse.y"
8025  {
8026  /*%%%*/
8027  (yyval.node) = NEW_HASH((yyvsp[(2) - (3)].node));
8028  /*%
8029  $$ = dispatch1(hash, escape_Qundef($2));
8030  %*/
8031  }
8032  break;
8033 
8034  case 298:
8035 
8036 /* Line 1806 of yacc.c */
8037 #line 2678 "parse.y"
8038  {
8039  /*%%%*/
8040  (yyval.node) = NEW_RETURN(0);
8041  /*%
8042  $$ = dispatch0(return0);
8043  %*/
8044  }
8045  break;
8046 
8047  case 299:
8048 
8049 /* Line 1806 of yacc.c */
8050 #line 2686 "parse.y"
8051  {
8052  /*%%%*/
8053  (yyval.node) = new_yield((yyvsp[(3) - (4)].node));
8054  /*%
8055  $$ = dispatch1(yield, dispatch1(paren, $3));
8056  %*/
8057  }
8058  break;
8059 
8060  case 300:
8061 
8062 /* Line 1806 of yacc.c */
8063 #line 2694 "parse.y"
8064  {
8065  /*%%%*/
8066  (yyval.node) = NEW_YIELD(0);
8067  /*%
8068  $$ = dispatch1(yield, dispatch1(paren, arg_new()));
8069  %*/
8070  }
8071  break;
8072 
8073  case 301:
8074 
8075 /* Line 1806 of yacc.c */
8076 #line 2702 "parse.y"
8077  {
8078  /*%%%*/
8079  (yyval.node) = NEW_YIELD(0);
8080  /*%
8081  $$ = dispatch0(yield0);
8082  %*/
8083  }
8084  break;
8085 
8086  case 302:
8087 
8088 /* Line 1806 of yacc.c */
8089 #line 2709 "parse.y"
8090  {in_defined = 1;}
8091  break;
8092 
8093  case 303:
8094 
8095 /* Line 1806 of yacc.c */
8096 #line 2710 "parse.y"
8097  {
8098  /*%%%*/
8099  in_defined = 0;
8100  (yyval.node) = new_defined((yyvsp[(5) - (6)].node));
8101  /*%
8102  in_defined = 0;
8103  $$ = dispatch1(defined, $5);
8104  %*/
8105  }
8106  break;
8107 
8108  case 304:
8109 
8110 /* Line 1806 of yacc.c */
8111 #line 2720 "parse.y"
8112  {
8113  /*%%%*/
8114  (yyval.node) = call_uni_op(cond((yyvsp[(3) - (4)].node)), '!');
8115  /*%
8116  $$ = dispatch2(unary, ripper_intern("not"), $3);
8117  %*/
8118  }
8119  break;
8120 
8121  case 305:
8122 
8123 /* Line 1806 of yacc.c */
8124 #line 2728 "parse.y"
8125  {
8126  /*%%%*/
8127  (yyval.node) = call_uni_op(cond(NEW_NIL()), '!');
8128  /*%
8129  $$ = dispatch2(unary, ripper_intern("not"), Qnil);
8130  %*/
8131  }
8132  break;
8133 
8134  case 306:
8135 
8136 /* Line 1806 of yacc.c */
8137 #line 2736 "parse.y"
8138  {
8139  /*%%%*/
8140  (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
8141  (yyval.node) = (yyvsp[(2) - (2)].node);
8142  /*%
8143  $$ = method_arg(dispatch1(fcall, $1), arg_new());
8144  $$ = method_add_block($$, $2);
8145  %*/
8146  }
8147  break;
8148 
8149  case 308:
8150 
8151 /* Line 1806 of yacc.c */
8152 #line 2747 "parse.y"
8153  {
8154  /*%%%*/
8155  block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node));
8156  (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
8157  (yyval.node) = (yyvsp[(2) - (2)].node);
8158  /*%
8159  $$ = method_add_block($1, $2);
8160  %*/
8161  }
8162  break;
8163 
8164  case 309:
8165 
8166 /* Line 1806 of yacc.c */
8167 #line 2757 "parse.y"
8168  {
8169  (yyval.node) = (yyvsp[(2) - (2)].node);
8170  }
8171  break;
8172 
8173  case 310:
8174 
8175 /* Line 1806 of yacc.c */
8176 #line 2764 "parse.y"
8177  {
8178  /*%%%*/
8179  (yyval.node) = NEW_IF(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node));
8180  fixpos((yyval.node), (yyvsp[(2) - (6)].node));
8181  /*%
8182  $$ = dispatch3(if, $2, $4, escape_Qundef($5));
8183  %*/
8184  }
8185  break;
8186 
8187  case 311:
8188 
8189 /* Line 1806 of yacc.c */
8190 #line 2776 "parse.y"
8191  {
8192  /*%%%*/
8193  (yyval.node) = NEW_UNLESS(cond((yyvsp[(2) - (6)].node)), (yyvsp[(4) - (6)].node), (yyvsp[(5) - (6)].node));
8194  fixpos((yyval.node), (yyvsp[(2) - (6)].node));
8195  /*%
8196  $$ = dispatch3(unless, $2, $4, escape_Qundef($5));
8197  %*/
8198  }
8199  break;
8200 
8201  case 312:
8202 
8203 /* Line 1806 of yacc.c */
8204 #line 2784 "parse.y"
8205  {COND_PUSH(1);}
8206  break;
8207 
8208  case 313:
8209 
8210 /* Line 1806 of yacc.c */
8211 #line 2784 "parse.y"
8212  {COND_POP();}
8213  break;
8214 
8215  case 314:
8216 
8217 /* Line 1806 of yacc.c */
8218 #line 2787 "parse.y"
8219  {
8220  /*%%%*/
8221  (yyval.node) = NEW_WHILE(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1);
8222  fixpos((yyval.node), (yyvsp[(3) - (7)].node));
8223  /*%
8224  $$ = dispatch2(while, $3, $6);
8225  %*/
8226  }
8227  break;
8228 
8229  case 315:
8230 
8231 /* Line 1806 of yacc.c */
8232 #line 2795 "parse.y"
8233  {COND_PUSH(1);}
8234  break;
8235 
8236  case 316:
8237 
8238 /* Line 1806 of yacc.c */
8239 #line 2795 "parse.y"
8240  {COND_POP();}
8241  break;
8242 
8243  case 317:
8244 
8245 /* Line 1806 of yacc.c */
8246 #line 2798 "parse.y"
8247  {
8248  /*%%%*/
8249  (yyval.node) = NEW_UNTIL(cond((yyvsp[(3) - (7)].node)), (yyvsp[(6) - (7)].node), 1);
8250  fixpos((yyval.node), (yyvsp[(3) - (7)].node));
8251  /*%
8252  $$ = dispatch2(until, $3, $6);
8253  %*/
8254  }
8255  break;
8256 
8257  case 318:
8258 
8259 /* Line 1806 of yacc.c */
8260 #line 2809 "parse.y"
8261  {
8262  /*%%%*/
8263  (yyval.node) = NEW_CASE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node));
8264  fixpos((yyval.node), (yyvsp[(2) - (5)].node));
8265  /*%
8266  $$ = dispatch2(case, $2, $4);
8267  %*/
8268  }
8269  break;
8270 
8271  case 319:
8272 
8273 /* Line 1806 of yacc.c */
8274 #line 2818 "parse.y"
8275  {
8276  /*%%%*/
8277  (yyval.node) = NEW_CASE(0, (yyvsp[(3) - (4)].node));
8278  /*%
8279  $$ = dispatch2(case, Qnil, $3);
8280  %*/
8281  }
8282  break;
8283 
8284  case 320:
8285 
8286 /* Line 1806 of yacc.c */
8287 #line 2826 "parse.y"
8288  {COND_PUSH(1);}
8289  break;
8290 
8291  case 321:
8292 
8293 /* Line 1806 of yacc.c */
8294 #line 2828 "parse.y"
8295  {COND_POP();}
8296  break;
8297 
8298  case 322:
8299 
8300 /* Line 1806 of yacc.c */
8301 #line 2831 "parse.y"
8302  {
8303  /*%%%*/
8304  /*
8305  * for a, b, c in e
8306  * #=>
8307  * e.each{|*x| a, b, c = x
8308  *
8309  * for a in e
8310  * #=>
8311  * e.each{|x| a, = x}
8312  */
8313  ID id = internal_id();
8314  ID *tbl = ALLOC_N(ID, 2);
8315  NODE *m = NEW_ARGS_AUX(0, 0);
8316  NODE *args, *scope;
8317 
8318  if (nd_type((yyvsp[(2) - (9)].node)) == NODE_MASGN) {
8319  /* if args.length == 1 && args[0].kind_of?(Array)
8320  * args = args[0]
8321  * end
8322  */
8323  NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
8324  NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
8325  m->nd_next = block_append(
8326  NEW_IF(
8328  NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
8329  idEq, one),
8331  rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
8332  0),
8333  NEW_DASGN_CURR(id,
8334  NEW_CALL(NEW_DVAR(id), idAREF, zero)),
8335  0),
8336  node_assign((yyvsp[(2) - (9)].node), NEW_DVAR(id)));
8337 
8338  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8339  }
8340  else {
8341  if (nd_type((yyvsp[(2) - (9)].node)) == NODE_LASGN ||
8342  nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN ||
8343  nd_type((yyvsp[(2) - (9)].node)) == NODE_DASGN_CURR) {
8344  (yyvsp[(2) - (9)].node)->nd_value = NEW_DVAR(id);
8345  m->nd_plen = 1;
8346  m->nd_next = (yyvsp[(2) - (9)].node);
8347  args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
8348  }
8349  else {
8350  m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].node)), 0), NEW_DVAR(id));
8351  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8352  }
8353  }
8354  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].node), args);
8355  tbl[0] = 1; tbl[1] = id;
8356  (yyval.node) = NEW_FOR(0, (yyvsp[(5) - (9)].node), scope);
8357  fixpos((yyval.node), (yyvsp[(2) - (9)].node));
8358  /*%
8359  $$ = dispatch3(for, $2, $5, $8);
8360  %*/
8361  }
8362  break;
8363 
8364  case 323:
8365 
8366 /* Line 1806 of yacc.c */
8367 #line 2892 "parse.y"
8368  {
8369  if (in_def || in_single)
8370  yyerror("class definition in method body");
8371  local_push(0);
8372  /*%%%*/
8373  (yyval.num) = ruby_sourceline;
8374  /*%
8375  %*/
8376  }
8377  break;
8378 
8379  case 324:
8380 
8381 /* Line 1806 of yacc.c */
8382 #line 2903 "parse.y"
8383  {
8384  /*%%%*/
8385  (yyval.node) = NEW_CLASS((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(3) - (6)].node));
8386  nd_set_line((yyval.node), (yyvsp[(4) - (6)].num));
8387  /*%
8388  $$ = dispatch3(class, $2, $3, $5);
8389  %*/
8390  local_pop();
8391  }
8392  break;
8393 
8394  case 325:
8395 
8396 /* Line 1806 of yacc.c */
8397 #line 2913 "parse.y"
8398  {
8399  (yyval.num) = in_def;
8400  in_def = 0;
8401  }
8402  break;
8403 
8404  case 326:
8405 
8406 /* Line 1806 of yacc.c */
8407 #line 2918 "parse.y"
8408  {
8409  (yyval.num) = in_single;
8410  in_single = 0;
8411  local_push(0);
8412  }
8413  break;
8414 
8415  case 327:
8416 
8417 /* Line 1806 of yacc.c */
8418 #line 2925 "parse.y"
8419  {
8420  /*%%%*/
8421  (yyval.node) = NEW_SCLASS((yyvsp[(3) - (8)].node), (yyvsp[(7) - (8)].node));
8422  fixpos((yyval.node), (yyvsp[(3) - (8)].node));
8423  /*%
8424  $$ = dispatch2(sclass, $3, $7);
8425  %*/
8426  local_pop();
8427  in_def = (yyvsp[(4) - (8)].num);
8428  in_single = (yyvsp[(6) - (8)].num);
8429  }
8430  break;
8431 
8432  case 328:
8433 
8434 /* Line 1806 of yacc.c */
8435 #line 2937 "parse.y"
8436  {
8437  if (in_def || in_single)
8438  yyerror("module definition in method body");
8439  local_push(0);
8440  /*%%%*/
8441  (yyval.num) = ruby_sourceline;
8442  /*%
8443  %*/
8444  }
8445  break;
8446 
8447  case 329:
8448 
8449 /* Line 1806 of yacc.c */
8450 #line 2948 "parse.y"
8451  {
8452  /*%%%*/
8453  (yyval.node) = NEW_MODULE((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node));
8454  nd_set_line((yyval.node), (yyvsp[(3) - (5)].num));
8455  /*%
8456  $$ = dispatch2(module, $2, $4);
8457  %*/
8458  local_pop();
8459  }
8460  break;
8461 
8462  case 330:
8463 
8464 /* Line 1806 of yacc.c */
8465 #line 2958 "parse.y"
8466  {
8467  (yyval.id) = cur_mid;
8468  cur_mid = (yyvsp[(2) - (2)].id);
8469  in_def++;
8470  local_push(0);
8471  }
8472  break;
8473 
8474  case 331:
8475 
8476 /* Line 1806 of yacc.c */
8477 #line 2967 "parse.y"
8478  {
8479  /*%%%*/
8480  NODE *body = remove_begin((yyvsp[(5) - (6)].node));
8481  reduce_nodes(&body);
8482  (yyval.node) = NEW_DEFN((yyvsp[(2) - (6)].id), (yyvsp[(4) - (6)].node), body, NOEX_PRIVATE);
8483  nd_set_line((yyval.node), (yyvsp[(1) - (6)].num));
8484  /*%
8485  $$ = dispatch3(def, $2, $4, $5);
8486  %*/
8487  local_pop();
8488  in_def--;
8489  cur_mid = (yyvsp[(3) - (6)].id);
8490  }
8491  break;
8492 
8493  case 332:
8494 
8495 /* Line 1806 of yacc.c */
8496 #line 2980 "parse.y"
8497  {lex_state = EXPR_FNAME;}
8498  break;
8499 
8500  case 333:
8501 
8502 /* Line 1806 of yacc.c */
8503 #line 2981 "parse.y"
8504  {
8505  in_single++;
8506  lex_state = EXPR_ENDFN; /* force for args */
8507  local_push(0);
8508  }
8509  break;
8510 
8511  case 334:
8512 
8513 /* Line 1806 of yacc.c */
8514 #line 2989 "parse.y"
8515  {
8516  /*%%%*/
8517  NODE *body = remove_begin((yyvsp[(8) - (9)].node));
8518  reduce_nodes(&body);
8519  (yyval.node) = NEW_DEFS((yyvsp[(2) - (9)].node), (yyvsp[(5) - (9)].id), (yyvsp[(7) - (9)].node), body);
8520  nd_set_line((yyval.node), (yyvsp[(1) - (9)].num));
8521  /*%
8522  $$ = dispatch5(defs, $2, $3, $5, $7, $8);
8523  %*/
8524  local_pop();
8525  in_single--;
8526  }
8527  break;
8528 
8529  case 335:
8530 
8531 /* Line 1806 of yacc.c */
8532 #line 3002 "parse.y"
8533  {
8534  /*%%%*/
8535  (yyval.node) = NEW_BREAK(0);
8536  /*%
8537  $$ = dispatch1(break, arg_new());
8538  %*/
8539  }
8540  break;
8541 
8542  case 336:
8543 
8544 /* Line 1806 of yacc.c */
8545 #line 3010 "parse.y"
8546  {
8547  /*%%%*/
8548  (yyval.node) = NEW_NEXT(0);
8549  /*%
8550  $$ = dispatch1(next, arg_new());
8551  %*/
8552  }
8553  break;
8554 
8555  case 337:
8556 
8557 /* Line 1806 of yacc.c */
8558 #line 3018 "parse.y"
8559  {
8560  /*%%%*/
8561  (yyval.node) = NEW_REDO();
8562  /*%
8563  $$ = dispatch0(redo);
8564  %*/
8565  }
8566  break;
8567 
8568  case 338:
8569 
8570 /* Line 1806 of yacc.c */
8571 #line 3026 "parse.y"
8572  {
8573  /*%%%*/
8574  (yyval.node) = NEW_RETRY();
8575  /*%
8576  $$ = dispatch0(retry);
8577  %*/
8578  }
8579  break;
8580 
8581  case 339:
8582 
8583 /* Line 1806 of yacc.c */
8584 #line 3036 "parse.y"
8585  {
8586  /*%%%*/
8587  value_expr((yyvsp[(1) - (1)].node));
8588  (yyval.node) = (yyvsp[(1) - (1)].node);
8589  if (!(yyval.node)) (yyval.node) = NEW_NIL();
8590  /*%
8591  $$ = $1;
8592  %*/
8593  }
8594  break;
8595 
8596  case 340:
8597 
8598 /* Line 1806 of yacc.c */
8599 #line 3048 "parse.y"
8600  {
8601  token_info_push("begin");
8602  }
8603  break;
8604 
8605  case 341:
8606 
8607 /* Line 1806 of yacc.c */
8608 #line 3054 "parse.y"
8609  {
8610  token_info_push("if");
8611  }
8612  break;
8613 
8614  case 342:
8615 
8616 /* Line 1806 of yacc.c */
8617 #line 3060 "parse.y"
8618  {
8619  token_info_push("unless");
8620  }
8621  break;
8622 
8623  case 343:
8624 
8625 /* Line 1806 of yacc.c */
8626 #line 3066 "parse.y"
8627  {
8628  token_info_push("while");
8629  }
8630  break;
8631 
8632  case 344:
8633 
8634 /* Line 1806 of yacc.c */
8635 #line 3072 "parse.y"
8636  {
8637  token_info_push("until");
8638  }
8639  break;
8640 
8641  case 345:
8642 
8643 /* Line 1806 of yacc.c */
8644 #line 3078 "parse.y"
8645  {
8646  token_info_push("case");
8647  }
8648  break;
8649 
8650  case 346:
8651 
8652 /* Line 1806 of yacc.c */
8653 #line 3084 "parse.y"
8654  {
8655  token_info_push("for");
8656  }
8657  break;
8658 
8659  case 347:
8660 
8661 /* Line 1806 of yacc.c */
8662 #line 3090 "parse.y"
8663  {
8664  token_info_push("class");
8665  }
8666  break;
8667 
8668  case 348:
8669 
8670 /* Line 1806 of yacc.c */
8671 #line 3096 "parse.y"
8672  {
8673  token_info_push("module");
8674  }
8675  break;
8676 
8677  case 349:
8678 
8679 /* Line 1806 of yacc.c */
8680 #line 3102 "parse.y"
8681  {
8682  token_info_push("def");
8683  /*%%%*/
8684  (yyval.num) = ruby_sourceline;
8685  /*%
8686  %*/
8687  }
8688  break;
8689 
8690  case 350:
8691 
8692 /* Line 1806 of yacc.c */
8693 #line 3112 "parse.y"
8694  {
8695  token_info_pop("end");
8696  }
8697  break;
8698 
8699  case 357:
8700 
8701 /* Line 1806 of yacc.c */
8702 #line 3142 "parse.y"
8703  {
8704  /*%%%*/
8705  (yyval.node) = NEW_IF(cond((yyvsp[(2) - (5)].node)), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
8706  fixpos((yyval.node), (yyvsp[(2) - (5)].node));
8707  /*%
8708  $$ = dispatch3(elsif, $2, $4, escape_Qundef($5));
8709  %*/
8710  }
8711  break;
8712 
8713  case 359:
8714 
8715 /* Line 1806 of yacc.c */
8716 #line 3154 "parse.y"
8717  {
8718  /*%%%*/
8719  (yyval.node) = (yyvsp[(2) - (2)].node);
8720  /*%
8721  $$ = dispatch1(else, $2);
8722  %*/
8723  }
8724  break;
8725 
8726  case 362:
8727 
8728 /* Line 1806 of yacc.c */
8729 #line 3168 "parse.y"
8730  {
8731  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
8732  /*%%%*/
8733  /*%
8734  $$ = dispatch1(mlhs_paren, $$);
8735  %*/
8736  }
8737  break;
8738 
8739  case 363:
8740 
8741 /* Line 1806 of yacc.c */
8742 #line 3176 "parse.y"
8743  {
8744  /*%%%*/
8745  (yyval.node) = (yyvsp[(2) - (3)].node);
8746  /*%
8747  $$ = dispatch1(mlhs_paren, $2);
8748  %*/
8749  }
8750  break;
8751 
8752  case 364:
8753 
8754 /* Line 1806 of yacc.c */
8755 #line 3186 "parse.y"
8756  {
8757  /*%%%*/
8758  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
8759  /*%
8760  $$ = mlhs_add(mlhs_new(), $1);
8761  %*/
8762  }
8763  break;
8764 
8765  case 365:
8766 
8767 /* Line 1806 of yacc.c */
8768 #line 3194 "parse.y"
8769  {
8770  /*%%%*/
8771  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
8772  /*%
8773  $$ = mlhs_add($1, $3);
8774  %*/
8775  }
8776  break;
8777 
8778  case 366:
8779 
8780 /* Line 1806 of yacc.c */
8781 #line 3204 "parse.y"
8782  {
8783  /*%%%*/
8784  (yyval.node) = NEW_MASGN((yyvsp[(1) - (1)].node), 0);
8785  /*%
8786  $$ = $1;
8787  %*/
8788  }
8789  break;
8790 
8791  case 367:
8792 
8793 /* Line 1806 of yacc.c */
8794 #line 3212 "parse.y"
8795  {
8796  (yyval.node) = assignable((yyvsp[(4) - (4)].id), 0);
8797  /*%%%*/
8798  (yyval.node) = NEW_MASGN((yyvsp[(1) - (4)].node), (yyval.node));
8799  /*%
8800  $$ = mlhs_add_star($1, $$);
8801  %*/
8802  }
8803  break;
8804 
8805  case 368:
8806 
8807 /* Line 1806 of yacc.c */
8808 #line 3221 "parse.y"
8809  {
8810  (yyval.node) = assignable((yyvsp[(4) - (6)].id), 0);
8811  /*%%%*/
8812  (yyval.node) = NEW_MASGN((yyvsp[(1) - (6)].node), NEW_POSTARG((yyval.node), (yyvsp[(6) - (6)].node)));
8813  /*%
8814  $$ = mlhs_add_star($1, $$);
8815  %*/
8816  }
8817  break;
8818 
8819  case 369:
8820 
8821 /* Line 1806 of yacc.c */
8822 #line 3230 "parse.y"
8823  {
8824  /*%%%*/
8825  (yyval.node) = NEW_MASGN((yyvsp[(1) - (3)].node), -1);
8826  /*%
8827  $$ = mlhs_add_star($1, Qnil);
8828  %*/
8829  }
8830  break;
8831 
8832  case 370:
8833 
8834 /* Line 1806 of yacc.c */
8835 #line 3238 "parse.y"
8836  {
8837  /*%%%*/
8838  (yyval.node) = NEW_MASGN((yyvsp[(1) - (5)].node), NEW_POSTARG(-1, (yyvsp[(5) - (5)].node)));
8839  /*%
8840  $$ = mlhs_add_star($1, $5);
8841  %*/
8842  }
8843  break;
8844 
8845  case 371:
8846 
8847 /* Line 1806 of yacc.c */
8848 #line 3246 "parse.y"
8849  {
8850  (yyval.node) = assignable((yyvsp[(2) - (2)].id), 0);
8851  /*%%%*/
8852  (yyval.node) = NEW_MASGN(0, (yyval.node));
8853  /*%
8854  $$ = mlhs_add_star(mlhs_new(), $$);
8855  %*/
8856  }
8857  break;
8858 
8859  case 372:
8860 
8861 /* Line 1806 of yacc.c */
8862 #line 3255 "parse.y"
8863  {
8864  (yyval.node) = assignable((yyvsp[(2) - (4)].id), 0);
8865  /*%%%*/
8866  (yyval.node) = NEW_MASGN(0, NEW_POSTARG((yyval.node), (yyvsp[(4) - (4)].node)));
8867  /*%
8868  #if 0
8869  TODO: Check me
8870  #endif
8871  $$ = mlhs_add_star($$, $4);
8872  %*/
8873  }
8874  break;
8875 
8876  case 373:
8877 
8878 /* Line 1806 of yacc.c */
8879 #line 3267 "parse.y"
8880  {
8881  /*%%%*/
8882  (yyval.node) = NEW_MASGN(0, -1);
8883  /*%
8884  $$ = mlhs_add_star(mlhs_new(), Qnil);
8885  %*/
8886  }
8887  break;
8888 
8889  case 374:
8890 
8891 /* Line 1806 of yacc.c */
8892 #line 3275 "parse.y"
8893  {
8894  /*%%%*/
8895  (yyval.node) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].node)));
8896  /*%
8897  $$ = mlhs_add_star(mlhs_new(), Qnil);
8898  %*/
8899  }
8900  break;
8901 
8902  case 375:
8903 
8904 /* Line 1806 of yacc.c */
8905 #line 3286 "parse.y"
8906  {
8907  (yyval.node) = new_args_tail((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id));
8908  }
8909  break;
8910 
8911  case 376:
8912 
8913 /* Line 1806 of yacc.c */
8914 #line 3290 "parse.y"
8915  {
8916  (yyval.node) = new_args_tail((yyvsp[(1) - (2)].node), Qnone, (yyvsp[(2) - (2)].id));
8917  }
8918  break;
8919 
8920  case 377:
8921 
8922 /* Line 1806 of yacc.c */
8923 #line 3294 "parse.y"
8924  {
8925  (yyval.node) = new_args_tail(Qnone, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id));
8926  }
8927  break;
8928 
8929  case 378:
8930 
8931 /* Line 1806 of yacc.c */
8932 #line 3298 "parse.y"
8933  {
8934  (yyval.node) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].id));
8935  }
8936  break;
8937 
8938  case 379:
8939 
8940 /* Line 1806 of yacc.c */
8941 #line 3304 "parse.y"
8942  {
8943  (yyval.node) = (yyvsp[(2) - (2)].node);
8944  }
8945  break;
8946 
8947  case 380:
8948 
8949 /* Line 1806 of yacc.c */
8950 #line 3308 "parse.y"
8951  {
8952  (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
8953  }
8954  break;
8955 
8956  case 381:
8957 
8958 /* Line 1806 of yacc.c */
8959 #line 3314 "parse.y"
8960  {
8961  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), Qnone, (yyvsp[(6) - (6)].node));
8962  }
8963  break;
8964 
8965  case 382:
8966 
8967 /* Line 1806 of yacc.c */
8968 #line 3318 "parse.y"
8969  {
8970  (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].node));
8971  }
8972  break;
8973 
8974  case 383:
8975 
8976 /* Line 1806 of yacc.c */
8977 #line 3322 "parse.y"
8978  {
8979  (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), Qnone, Qnone, (yyvsp[(4) - (4)].node));
8980  }
8981  break;
8982 
8983  case 384:
8984 
8985 /* Line 1806 of yacc.c */
8986 #line 3326 "parse.y"
8987  {
8988  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), Qnone, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
8989  }
8990  break;
8991 
8992  case 385:
8993 
8994 /* Line 1806 of yacc.c */
8995 #line 3330 "parse.y"
8996  {
8997  (yyval.node) = new_args((yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
8998  }
8999  break;
9000 
9001  case 386:
9002 
9003 /* Line 1806 of yacc.c */
9004 #line 3334 "parse.y"
9005  {
9006  (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
9007  /*%%%*/
9008  /*%
9009  dispatch1(excessed_comma, $$);
9010  %*/
9011  }
9012  break;
9013 
9014  case 387:
9015 
9016 /* Line 1806 of yacc.c */
9017 #line 3342 "parse.y"
9018  {
9019  (yyval.node) = new_args((yyvsp[(1) - (6)].node), Qnone, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
9020  }
9021  break;
9022 
9023  case 388:
9024 
9025 /* Line 1806 of yacc.c */
9026 #line 3346 "parse.y"
9027  {
9028  (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].node));
9029  }
9030  break;
9031 
9032  case 389:
9033 
9034 /* Line 1806 of yacc.c */
9035 #line 3350 "parse.y"
9036  {
9037  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
9038  }
9039  break;
9040 
9041  case 390:
9042 
9043 /* Line 1806 of yacc.c */
9044 #line 3354 "parse.y"
9045  {
9046  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
9047  }
9048  break;
9049 
9050  case 391:
9051 
9052 /* Line 1806 of yacc.c */
9053 #line 3358 "parse.y"
9054  {
9055  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (2)].node), Qnone, Qnone, (yyvsp[(2) - (2)].node));
9056  }
9057  break;
9058 
9059  case 392:
9060 
9061 /* Line 1806 of yacc.c */
9062 #line 3362 "parse.y"
9063  {
9064  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
9065  }
9066  break;
9067 
9068  case 393:
9069 
9070 /* Line 1806 of yacc.c */
9071 #line 3366 "parse.y"
9072  {
9073  (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].id), Qnone, (yyvsp[(2) - (2)].node));
9074  }
9075  break;
9076 
9077  case 394:
9078 
9079 /* Line 1806 of yacc.c */
9080 #line 3370 "parse.y"
9081  {
9082  (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
9083  }
9084  break;
9085 
9086  case 395:
9087 
9088 /* Line 1806 of yacc.c */
9089 #line 3374 "parse.y"
9090  {
9091  (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].node));
9092  }
9093  break;
9094 
9095  case 397:
9096 
9097 /* Line 1806 of yacc.c */
9098 #line 3381 "parse.y"
9099  {
9100  command_start = TRUE;
9101  }
9102  break;
9103 
9104  case 398:
9105 
9106 /* Line 1806 of yacc.c */
9107 #line 3387 "parse.y"
9108  {
9109  /*%%%*/
9110  (yyval.node) = 0;
9111  /*%
9112  $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9113  escape_Qundef($2));
9114  %*/
9115  }
9116  break;
9117 
9118  case 399:
9119 
9120 /* Line 1806 of yacc.c */
9121 #line 3396 "parse.y"
9122  {
9123  /*%%%*/
9124  (yyval.node) = 0;
9125  /*%
9126  $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9127  Qnil);
9128  %*/
9129  }
9130  break;
9131 
9132  case 400:
9133 
9134 /* Line 1806 of yacc.c */
9135 #line 3405 "parse.y"
9136  {
9137  /*%%%*/
9138  (yyval.node) = (yyvsp[(2) - (4)].node);
9139  /*%
9140  $$ = blockvar_new(escape_Qundef($2), escape_Qundef($3));
9141  %*/
9142  }
9143  break;
9144 
9145  case 401:
9146 
9147 /* Line 1806 of yacc.c */
9148 #line 3416 "parse.y"
9149  {
9150  (yyval.node) = 0;
9151  }
9152  break;
9153 
9154  case 402:
9155 
9156 /* Line 1806 of yacc.c */
9157 #line 3420 "parse.y"
9158  {
9159  /*%%%*/
9160  (yyval.node) = 0;
9161  /*%
9162  $$ = $3;
9163  %*/
9164  }
9165  break;
9166 
9167  case 405:
9168 
9169 /* Line 1806 of yacc.c */
9170 #line 3446 "parse.y"
9171  {
9172  new_bv(get_id((yyvsp[(1) - (1)].id)));
9173  /*%%%*/
9174  /*%
9175  $$ = get_value($1);
9176  %*/
9177  }
9178  break;
9179 
9180  case 406:
9181 
9182 /* Line 1806 of yacc.c */
9183 #line 3454 "parse.y"
9184  {
9185  (yyval.node) = 0;
9186  }
9187  break;
9188 
9189  case 407:
9190 
9191 /* Line 1806 of yacc.c */
9192 #line 3459 "parse.y"
9193  {
9194  (yyval.vars) = dyna_push();
9195  }
9196  break;
9197 
9198  case 408:
9199 
9200 /* Line 1806 of yacc.c */
9201 #line 3462 "parse.y"
9202  {
9203  (yyval.num) = lpar_beg;
9204  lpar_beg = ++paren_nest;
9205  }
9206  break;
9207 
9208  case 409:
9209 
9210 /* Line 1806 of yacc.c */
9211 #line 3467 "parse.y"
9212  {
9213  (yyval.num) = ruby_sourceline;
9214  }
9215  break;
9216 
9217  case 410:
9218 
9219 /* Line 1806 of yacc.c */
9220 #line 3470 "parse.y"
9221  {
9222  (yyval.val) = cmdarg_stack;
9223  cmdarg_stack = 0;
9224  }
9225  break;
9226 
9227  case 411:
9228 
9229 /* Line 1806 of yacc.c */
9230 #line 3475 "parse.y"
9231  {
9232  lpar_beg = (yyvsp[(2) - (6)].num);
9233  cmdarg_stack = (yyvsp[(5) - (6)].val);
9234  CMDARG_LEXPOP();
9235  /*%%%*/
9236  (yyval.node) = NEW_LAMBDA((yyvsp[(3) - (6)].node), (yyvsp[(6) - (6)].node));
9237  nd_set_line((yyval.node), (yyvsp[(4) - (6)].num));
9238  /*%
9239  $$ = dispatch2(lambda, $3, $6);
9240  %*/
9241  dyna_pop((yyvsp[(1) - (6)].vars));
9242  }
9243  break;
9244 
9245  case 412:
9246 
9247 /* Line 1806 of yacc.c */
9248 #line 3490 "parse.y"
9249  {
9250  /*%%%*/
9251  (yyval.node) = (yyvsp[(2) - (4)].node);
9252  /*%
9253  $$ = dispatch1(paren, $2);
9254  %*/
9255  }
9256  break;
9257 
9258  case 413:
9259 
9260 /* Line 1806 of yacc.c */
9261 #line 3498 "parse.y"
9262  {
9263  (yyval.node) = (yyvsp[(1) - (1)].node);
9264  }
9265  break;
9266 
9267  case 414:
9268 
9269 /* Line 1806 of yacc.c */
9270 #line 3504 "parse.y"
9271  {
9272  (yyval.node) = (yyvsp[(2) - (3)].node);
9273  }
9274  break;
9275 
9276  case 415:
9277 
9278 /* Line 1806 of yacc.c */
9279 #line 3508 "parse.y"
9280  {
9281  (yyval.node) = (yyvsp[(2) - (3)].node);
9282  }
9283  break;
9284 
9285  case 416:
9286 
9287 /* Line 1806 of yacc.c */
9288 #line 3514 "parse.y"
9289  {
9290  (yyvsp[(1) - (1)].vars) = dyna_push();
9291  /*%%%*/
9292  (yyval.num) = ruby_sourceline;
9293  /*% %*/
9294  }
9295  break;
9296 
9297  case 417:
9298 
9299 /* Line 1806 of yacc.c */
9300 #line 3523 "parse.y"
9301  {
9302  /*%%%*/
9303  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
9304  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
9305  /*%
9306  $$ = dispatch2(do_block, escape_Qundef($3), $4);
9307  %*/
9308  dyna_pop((yyvsp[(1) - (5)].vars));
9309  }
9310  break;
9311 
9312  case 418:
9313 
9314 /* Line 1806 of yacc.c */
9315 #line 3535 "parse.y"
9316  {
9317  /*%%%*/
9318  if (nd_type((yyvsp[(1) - (2)].node)) == NODE_YIELD) {
9319  compile_error(PARSER_ARG "block given to yield");
9320  }
9321  else {
9322  block_dup_check((yyvsp[(1) - (2)].node)->nd_args, (yyvsp[(2) - (2)].node));
9323  }
9324  (yyvsp[(2) - (2)].node)->nd_iter = (yyvsp[(1) - (2)].node);
9325  (yyval.node) = (yyvsp[(2) - (2)].node);
9326  fixpos((yyval.node), (yyvsp[(1) - (2)].node));
9327  /*%
9328  $$ = method_add_block($1, $2);
9329  %*/
9330  }
9331  break;
9332 
9333  case 419:
9334 
9335 /* Line 1806 of yacc.c */
9336 #line 3551 "parse.y"
9337  {
9338  /*%%%*/
9339  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].node));
9340  /*%
9341  $$ = dispatch3(call, $1, $2, $3);
9342  $$ = method_optarg($$, $4);
9343  %*/
9344  }
9345  break;
9346 
9347  case 420:
9348 
9349 /* Line 1806 of yacc.c */
9350 #line 3560 "parse.y"
9351  {
9352  /*%%%*/
9353  block_dup_check((yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
9354  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
9355  (yyval.node) = (yyvsp[(5) - (5)].node);
9356  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
9357  /*%
9358  $$ = dispatch4(command_call, $1, $2, $3, $4);
9359  $$ = method_add_block($$, $5);
9360  %*/
9361  }
9362  break;
9363 
9364  case 421:
9365 
9366 /* Line 1806 of yacc.c */
9367 #line 3572 "parse.y"
9368  {
9369  /*%%%*/
9370  block_dup_check((yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
9371  (yyvsp[(5) - (5)].node)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].node));
9372  (yyval.node) = (yyvsp[(5) - (5)].node);
9373  fixpos((yyval.node), (yyvsp[(1) - (5)].node));
9374  /*%
9375  $$ = dispatch4(command_call, $1, $2, $3, $4);
9376  $$ = method_add_block($$, $5);
9377  %*/
9378  }
9379  break;
9380 
9381  case 422:
9382 
9383 /* Line 1806 of yacc.c */
9384 #line 3586 "parse.y"
9385  {
9386  /*%%%*/
9387  (yyval.node) = (yyvsp[(1) - (2)].node);
9388  (yyval.node)->nd_args = (yyvsp[(2) - (2)].node);
9389  /*%
9390  $$ = method_arg(dispatch1(fcall, $1), $2);
9391  %*/
9392  }
9393  break;
9394 
9395  case 423:
9396 
9397 /* Line 1806 of yacc.c */
9398 #line 3595 "parse.y"
9399  {
9400  /*%%%*/
9401  (yyval.num) = ruby_sourceline;
9402  /*% %*/
9403  }
9404  break;
9405 
9406  case 424:
9407 
9408 /* Line 1806 of yacc.c */
9409 #line 3601 "parse.y"
9410  {
9411  /*%%%*/
9412  (yyval.node) = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].node));
9413  nd_set_line((yyval.node), (yyvsp[(4) - (5)].num));
9414  /*%
9415  $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
9416  $$ = method_optarg($$, $5);
9417  %*/
9418  }
9419  break;
9420 
9421  case 425:
9422 
9423 /* Line 1806 of yacc.c */
9424 #line 3611 "parse.y"
9425  {
9426  /*%%%*/
9427  (yyval.num) = ruby_sourceline;
9428  /*% %*/
9429  }
9430  break;
9431 
9432  case 426:
9433 
9434 /* Line 1806 of yacc.c */
9435 #line 3617 "parse.y"
9436  {
9437  /*%%%*/
9438  (yyval.node) = NEW_CALL((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].id), (yyvsp[(5) - (5)].node));
9439  nd_set_line((yyval.node), (yyvsp[(4) - (5)].num));
9440  /*%
9441  $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
9442  $$ = method_optarg($$, $5);
9443  %*/
9444  }
9445  break;
9446 
9447  case 427:
9448 
9449 /* Line 1806 of yacc.c */
9450 #line 3627 "parse.y"
9451  {
9452  /*%%%*/
9453  (yyval.node) = NEW_CALL((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].id), 0);
9454  /*%
9455  $$ = dispatch3(call, $1, ripper_intern("::"), $3);
9456  %*/
9457  }
9458  break;
9459 
9460  case 428:
9461 
9462 /* Line 1806 of yacc.c */
9463 #line 3635 "parse.y"
9464  {
9465  /*%%%*/
9466  (yyval.num) = ruby_sourceline;
9467  /*% %*/
9468  }
9469  break;
9470 
9471  case 429:
9472 
9473 /* Line 1806 of yacc.c */
9474 #line 3641 "parse.y"
9475  {
9476  /*%%%*/
9477  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), rb_intern("call"), (yyvsp[(4) - (4)].node));
9478  nd_set_line((yyval.node), (yyvsp[(3) - (4)].num));
9479  /*%
9480  $$ = dispatch3(call, $1, ripper_id2sym('.'),
9481  ripper_intern("call"));
9482  $$ = method_optarg($$, $4);
9483  %*/
9484  }
9485  break;
9486 
9487  case 430:
9488 
9489 /* Line 1806 of yacc.c */
9490 #line 3652 "parse.y"
9491  {
9492  /*%%%*/
9493  (yyval.num) = ruby_sourceline;
9494  /*% %*/
9495  }
9496  break;
9497 
9498  case 431:
9499 
9500 /* Line 1806 of yacc.c */
9501 #line 3658 "parse.y"
9502  {
9503  /*%%%*/
9504  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), rb_intern("call"), (yyvsp[(4) - (4)].node));
9505  nd_set_line((yyval.node), (yyvsp[(3) - (4)].num));
9506  /*%
9507  $$ = dispatch3(call, $1, ripper_intern("::"),
9508  ripper_intern("call"));
9509  $$ = method_optarg($$, $4);
9510  %*/
9511  }
9512  break;
9513 
9514  case 432:
9515 
9516 /* Line 1806 of yacc.c */
9517 #line 3669 "parse.y"
9518  {
9519  /*%%%*/
9520  (yyval.node) = NEW_SUPER((yyvsp[(2) - (2)].node));
9521  /*%
9522  $$ = dispatch1(super, $2);
9523  %*/
9524  }
9525  break;
9526 
9527  case 433:
9528 
9529 /* Line 1806 of yacc.c */
9530 #line 3677 "parse.y"
9531  {
9532  /*%%%*/
9533  (yyval.node) = NEW_ZSUPER();
9534  /*%
9535  $$ = dispatch0(zsuper);
9536  %*/
9537  }
9538  break;
9539 
9540  case 434:
9541 
9542 /* Line 1806 of yacc.c */
9543 #line 3685 "parse.y"
9544  {
9545  /*%%%*/
9546  if ((yyvsp[(1) - (4)].node) && nd_type((yyvsp[(1) - (4)].node)) == NODE_SELF)
9547  (yyval.node) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].node));
9548  else
9549  (yyval.node) = NEW_CALL((yyvsp[(1) - (4)].node), tAREF, (yyvsp[(3) - (4)].node));
9550  fixpos((yyval.node), (yyvsp[(1) - (4)].node));
9551  /*%
9552  $$ = dispatch2(aref, $1, escape_Qundef($3));
9553  %*/
9554  }
9555  break;
9556 
9557  case 435:
9558 
9559 /* Line 1806 of yacc.c */
9560 #line 3699 "parse.y"
9561  {
9562  (yyvsp[(1) - (1)].vars) = dyna_push();
9563  /*%%%*/
9564  (yyval.num) = ruby_sourceline;
9565  /*%
9566  %*/
9567  }
9568  break;
9569 
9570  case 436:
9571 
9572 /* Line 1806 of yacc.c */
9573 #line 3708 "parse.y"
9574  {
9575  /*%%%*/
9576  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
9577  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
9578  /*%
9579  $$ = dispatch2(brace_block, escape_Qundef($3), $4);
9580  %*/
9581  dyna_pop((yyvsp[(1) - (5)].vars));
9582  }
9583  break;
9584 
9585  case 437:
9586 
9587 /* Line 1806 of yacc.c */
9588 #line 3718 "parse.y"
9589  {
9590  (yyvsp[(1) - (1)].vars) = dyna_push();
9591  /*%%%*/
9592  (yyval.num) = ruby_sourceline;
9593  /*%
9594  %*/
9595  }
9596  break;
9597 
9598  case 438:
9599 
9600 /* Line 1806 of yacc.c */
9601 #line 3727 "parse.y"
9602  {
9603  /*%%%*/
9604  (yyval.node) = NEW_ITER((yyvsp[(3) - (5)].node),(yyvsp[(4) - (5)].node));
9605  nd_set_line((yyval.node), (yyvsp[(2) - (5)].num));
9606  /*%
9607  $$ = dispatch2(do_block, escape_Qundef($3), $4);
9608  %*/
9609  dyna_pop((yyvsp[(1) - (5)].vars));
9610  }
9611  break;
9612 
9613  case 439:
9614 
9615 /* Line 1806 of yacc.c */
9616 #line 3741 "parse.y"
9617  {
9618  /*%%%*/
9619  (yyval.node) = NEW_WHEN((yyvsp[(2) - (5)].node), (yyvsp[(4) - (5)].node), (yyvsp[(5) - (5)].node));
9620  /*%
9621  $$ = dispatch3(when, $2, $4, escape_Qundef($5));
9622  %*/
9623  }
9624  break;
9625 
9626  case 442:
9627 
9628 /* Line 1806 of yacc.c */
9629 #line 3757 "parse.y"
9630  {
9631  /*%%%*/
9632  if ((yyvsp[(3) - (6)].node)) {
9633  (yyvsp[(3) - (6)].node) = node_assign((yyvsp[(3) - (6)].node), NEW_ERRINFO());
9634  (yyvsp[(5) - (6)].node) = block_append((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node));
9635  }
9636  (yyval.node) = NEW_RESBODY((yyvsp[(2) - (6)].node), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
9637  fixpos((yyval.node), (yyvsp[(2) - (6)].node)?(yyvsp[(2) - (6)].node):(yyvsp[(5) - (6)].node));
9638  /*%
9639  $$ = dispatch4(rescue,
9640  escape_Qundef($2),
9641  escape_Qundef($3),
9642  escape_Qundef($5),
9643  escape_Qundef($6));
9644  %*/
9645  }
9646  break;
9647 
9648  case 444:
9649 
9650 /* Line 1806 of yacc.c */
9651 #line 3777 "parse.y"
9652  {
9653  /*%%%*/
9654  (yyval.node) = NEW_LIST((yyvsp[(1) - (1)].node));
9655  /*%
9656  $$ = rb_ary_new3(1, $1);
9657  %*/
9658  }
9659  break;
9660 
9661  case 445:
9662 
9663 /* Line 1806 of yacc.c */
9664 #line 3785 "parse.y"
9665  {
9666  /*%%%*/
9667  if (!((yyval.node) = splat_array((yyvsp[(1) - (1)].node)))) (yyval.node) = (yyvsp[(1) - (1)].node);
9668  /*%
9669  $$ = $1;
9670  %*/
9671  }
9672  break;
9673 
9674  case 447:
9675 
9676 /* Line 1806 of yacc.c */
9677 #line 3796 "parse.y"
9678  {
9679  (yyval.node) = (yyvsp[(2) - (2)].node);
9680  }
9681  break;
9682 
9683  case 449:
9684 
9685 /* Line 1806 of yacc.c */
9686 #line 3803 "parse.y"
9687  {
9688  /*%%%*/
9689  (yyval.node) = (yyvsp[(2) - (2)].node);
9690  /*%
9691  $$ = dispatch1(ensure, $2);
9692  %*/
9693  }
9694  break;
9695 
9696  case 452:
9697 
9698 /* Line 1806 of yacc.c */
9699 #line 3815 "parse.y"
9700  {
9701  /*%%%*/
9702  (yyval.node) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].id)));
9703  /*%
9704  $$ = dispatch1(symbol_literal, $1);
9705  %*/
9706  }
9707  break;
9708 
9709  case 454:
9710 
9711 /* Line 1806 of yacc.c */
9712 #line 3826 "parse.y"
9713  {
9714  /*%%%*/
9715  NODE *node = (yyvsp[(1) - (1)].node);
9716  if (!node) {
9717  node = NEW_STR(STR_NEW0());
9718  }
9719  else {
9720  node = evstr2dstr(node);
9721  }
9722  (yyval.node) = node;
9723  /*%
9724  $$ = $1;
9725  %*/
9726  }
9727  break;
9728 
9729  case 457:
9730 
9731 /* Line 1806 of yacc.c */
9732 #line 3845 "parse.y"
9733  {
9734  /*%%%*/
9735  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
9736  /*%
9737  $$ = dispatch2(string_concat, $1, $2);
9738  %*/
9739  }
9740  break;
9741 
9742  case 458:
9743 
9744 /* Line 1806 of yacc.c */
9745 #line 3855 "parse.y"
9746  {
9747  /*%%%*/
9748  (yyval.node) = (yyvsp[(2) - (3)].node);
9749  /*%
9750  $$ = dispatch1(string_literal, $2);
9751  %*/
9752  }
9753  break;
9754 
9755  case 459:
9756 
9757 /* Line 1806 of yacc.c */
9758 #line 3865 "parse.y"
9759  {
9760  /*%%%*/
9761  NODE *node = (yyvsp[(2) - (3)].node);
9762  if (!node) {
9763  node = NEW_XSTR(STR_NEW0());
9764  }
9765  else {
9766  switch (nd_type(node)) {
9767  case NODE_STR:
9768  nd_set_type(node, NODE_XSTR);
9769  break;
9770  case NODE_DSTR:
9771  nd_set_type(node, NODE_DXSTR);
9772  break;
9773  default:
9774  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
9775  break;
9776  }
9777  }
9778  (yyval.node) = node;
9779  /*%
9780  $$ = dispatch1(xstring_literal, $2);
9781  %*/
9782  }
9783  break;
9784 
9785  case 460:
9786 
9787 /* Line 1806 of yacc.c */
9788 #line 3892 "parse.y"
9789  {
9790  /*%%%*/
9791  int options = (yyvsp[(3) - (3)].num);
9792  NODE *node = (yyvsp[(2) - (3)].node);
9793  NODE *list, *prev;
9794  if (!node) {
9795  node = NEW_LIT(reg_compile(STR_NEW0(), options));
9796  }
9797  else switch (nd_type(node)) {
9798  case NODE_STR:
9799  {
9800  VALUE src = node->nd_lit;
9801  nd_set_type(node, NODE_LIT);
9802  node->nd_lit = reg_compile(src, options);
9803  }
9804  break;
9805  default:
9806  node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
9807  case NODE_DSTR:
9808  if (options & RE_OPTION_ONCE) {
9810  }
9811  else {
9812  nd_set_type(node, NODE_DREGX);
9813  }
9814  node->nd_cflag = options & RE_OPTION_MASK;
9815  if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
9816  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
9817  if (nd_type(list->nd_head) == NODE_STR) {
9818  VALUE tail = list->nd_head->nd_lit;
9819  if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
9820  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
9821  if (!literal_concat0(parser, lit, tail)) {
9822  node = 0;
9823  break;
9824  }
9825  rb_str_resize(tail, 0);
9826  prev->nd_next = list->nd_next;
9827  rb_gc_force_recycle((VALUE)list->nd_head);
9829  list = prev;
9830  }
9831  else {
9832  prev = list;
9833  }
9834  }
9835  else {
9836  prev = 0;
9837  }
9838  }
9839  if (!node->nd_next) {
9840  VALUE src = node->nd_lit;
9841  nd_set_type(node, NODE_LIT);
9842  node->nd_lit = reg_compile(src, options);
9843  }
9844  break;
9845  }
9846  (yyval.node) = node;
9847  /*%
9848  $$ = dispatch2(regexp_literal, $2, $3);
9849  %*/
9850  }
9851  break;
9852 
9853  case 461:
9854 
9855 /* Line 1806 of yacc.c */
9856 #line 3957 "parse.y"
9857  {
9858  /*%%%*/
9859  (yyval.node) = NEW_ZARRAY();
9860  /*%
9861  $$ = dispatch0(words_new);
9862  $$ = dispatch1(array, $$);
9863  %*/
9864  }
9865  break;
9866 
9867  case 462:
9868 
9869 /* Line 1806 of yacc.c */
9870 #line 3966 "parse.y"
9871  {
9872  /*%%%*/
9873  (yyval.node) = (yyvsp[(2) - (3)].node);
9874  /*%
9875  $$ = dispatch1(array, $2);
9876  %*/
9877  }
9878  break;
9879 
9880  case 463:
9881 
9882 /* Line 1806 of yacc.c */
9883 #line 3976 "parse.y"
9884  {
9885  /*%%%*/
9886  (yyval.node) = 0;
9887  /*%
9888  $$ = dispatch0(words_new);
9889  %*/
9890  }
9891  break;
9892 
9893  case 464:
9894 
9895 /* Line 1806 of yacc.c */
9896 #line 3984 "parse.y"
9897  {
9898  /*%%%*/
9899  (yyval.node) = list_append((yyvsp[(1) - (3)].node), evstr2dstr((yyvsp[(2) - (3)].node)));
9900  /*%
9901  $$ = dispatch2(words_add, $1, $2);
9902  %*/
9903  }
9904  break;
9905 
9906  case 466:
9907 
9908 /* Line 1806 of yacc.c */
9909 #line 4002 "parse.y"
9910  {
9911  /*%%%*/
9912  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
9913  /*%
9914  $$ = dispatch2(word_add, $1, $2);
9915  %*/
9916  }
9917  break;
9918 
9919  case 467:
9920 
9921 /* Line 1806 of yacc.c */
9922 #line 4012 "parse.y"
9923  {
9924  /*%%%*/
9925  (yyval.node) = NEW_ZARRAY();
9926  /*%
9927  $$ = dispatch0(symbols_new);
9928  $$ = dispatch1(array, $$);
9929  %*/
9930  }
9931  break;
9932 
9933  case 468:
9934 
9935 /* Line 1806 of yacc.c */
9936 #line 4021 "parse.y"
9937  {
9938  /*%%%*/
9939  (yyval.node) = (yyvsp[(2) - (3)].node);
9940  /*%
9941  $$ = dispatch1(array, $2);
9942  %*/
9943  }
9944  break;
9945 
9946  case 469:
9947 
9948 /* Line 1806 of yacc.c */
9949 #line 4031 "parse.y"
9950  {
9951  /*%%%*/
9952  (yyval.node) = 0;
9953  /*%
9954  $$ = dispatch0(symbols_new);
9955  %*/
9956  }
9957  break;
9958 
9959  case 470:
9960 
9961 /* Line 1806 of yacc.c */
9962 #line 4039 "parse.y"
9963  {
9964  /*%%%*/
9965  (yyvsp[(2) - (3)].node) = evstr2dstr((yyvsp[(2) - (3)].node));
9966  if (nd_type((yyvsp[(2) - (3)].node)) == NODE_DSTR) {
9967  nd_set_type((yyvsp[(2) - (3)].node), NODE_DSYM);
9968  }
9969  else {
9970  nd_set_type((yyvsp[(2) - (3)].node), NODE_LIT);
9971  (yyvsp[(2) - (3)].node)->nd_lit = rb_str_intern((yyvsp[(2) - (3)].node)->nd_lit);
9972  }
9973  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
9974  /*%
9975  $$ = dispatch2(symbols_add, $1, $2);
9976  %*/
9977  }
9978  break;
9979 
9980  case 471:
9981 
9982 /* Line 1806 of yacc.c */
9983 #line 4057 "parse.y"
9984  {
9985  /*%%%*/
9986  (yyval.node) = NEW_ZARRAY();
9987  /*%
9988  $$ = dispatch0(qwords_new);
9989  $$ = dispatch1(array, $$);
9990  %*/
9991  }
9992  break;
9993 
9994  case 472:
9995 
9996 /* Line 1806 of yacc.c */
9997 #line 4066 "parse.y"
9998  {
9999  /*%%%*/
10000  (yyval.node) = (yyvsp[(2) - (3)].node);
10001  /*%
10002  $$ = dispatch1(array, $2);
10003  %*/
10004  }
10005  break;
10006 
10007  case 473:
10008 
10009 /* Line 1806 of yacc.c */
10010 #line 4076 "parse.y"
10011  {
10012  /*%%%*/
10013  (yyval.node) = NEW_ZARRAY();
10014  /*%
10015  $$ = dispatch0(qsymbols_new);
10016  $$ = dispatch1(array, $$);
10017  %*/
10018  }
10019  break;
10020 
10021  case 474:
10022 
10023 /* Line 1806 of yacc.c */
10024 #line 4085 "parse.y"
10025  {
10026  /*%%%*/
10027  (yyval.node) = (yyvsp[(2) - (3)].node);
10028  /*%
10029  $$ = dispatch1(array, $2);
10030  %*/
10031  }
10032  break;
10033 
10034  case 475:
10035 
10036 /* Line 1806 of yacc.c */
10037 #line 4095 "parse.y"
10038  {
10039  /*%%%*/
10040  (yyval.node) = 0;
10041  /*%
10042  $$ = dispatch0(qwords_new);
10043  %*/
10044  }
10045  break;
10046 
10047  case 476:
10048 
10049 /* Line 1806 of yacc.c */
10050 #line 4103 "parse.y"
10051  {
10052  /*%%%*/
10053  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
10054  /*%
10055  $$ = dispatch2(qwords_add, $1, $2);
10056  %*/
10057  }
10058  break;
10059 
10060  case 477:
10061 
10062 /* Line 1806 of yacc.c */
10063 #line 4113 "parse.y"
10064  {
10065  /*%%%*/
10066  (yyval.node) = 0;
10067  /*%
10068  $$ = dispatch0(qsymbols_new);
10069  %*/
10070  }
10071  break;
10072 
10073  case 478:
10074 
10075 /* Line 1806 of yacc.c */
10076 #line 4121 "parse.y"
10077  {
10078  /*%%%*/
10079  VALUE lit;
10080  lit = (yyvsp[(2) - (3)].node)->nd_lit;
10081  (yyvsp[(2) - (3)].node)->nd_lit = ID2SYM(rb_intern_str(lit));
10082  nd_set_type((yyvsp[(2) - (3)].node), NODE_LIT);
10083  (yyval.node) = list_append((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
10084  /*%
10085  $$ = dispatch2(qsymbols_add, $1, $2);
10086  %*/
10087  }
10088  break;
10089 
10090  case 479:
10091 
10092 /* Line 1806 of yacc.c */
10093 #line 4135 "parse.y"
10094  {
10095  /*%%%*/
10096  (yyval.node) = 0;
10097  /*%
10098  $$ = dispatch0(string_content);
10099  %*/
10100  }
10101  break;
10102 
10103  case 480:
10104 
10105 /* Line 1806 of yacc.c */
10106 #line 4143 "parse.y"
10107  {
10108  /*%%%*/
10109  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
10110  /*%
10111  $$ = dispatch2(string_add, $1, $2);
10112  %*/
10113  }
10114  break;
10115 
10116  case 481:
10117 
10118 /* Line 1806 of yacc.c */
10119 #line 4153 "parse.y"
10120  {
10121  /*%%%*/
10122  (yyval.node) = 0;
10123  /*%
10124  $$ = dispatch0(xstring_new);
10125  %*/
10126  }
10127  break;
10128 
10129  case 482:
10130 
10131 /* Line 1806 of yacc.c */
10132 #line 4161 "parse.y"
10133  {
10134  /*%%%*/
10135  (yyval.node) = literal_concat((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
10136  /*%
10137  $$ = dispatch2(xstring_add, $1, $2);
10138  %*/
10139  }
10140  break;
10141 
10142  case 483:
10143 
10144 /* Line 1806 of yacc.c */
10145 #line 4171 "parse.y"
10146  {
10147  /*%%%*/
10148  (yyval.node) = 0;
10149  /*%
10150  $$ = dispatch0(regexp_new);
10151  %*/
10152  }
10153  break;
10154 
10155  case 484:
10156 
10157 /* Line 1806 of yacc.c */
10158 #line 4179 "parse.y"
10159  {
10160  /*%%%*/
10161  NODE *head = (yyvsp[(1) - (2)].node), *tail = (yyvsp[(2) - (2)].node);
10162  if (!head) {
10163  (yyval.node) = tail;
10164  }
10165  else if (!tail) {
10166  (yyval.node) = head;
10167  }
10168  else {
10169  switch (nd_type(head)) {
10170  case NODE_STR:
10172  break;
10173  case NODE_DSTR:
10174  break;
10175  default:
10177  break;
10178  }
10179  (yyval.node) = list_append(head, tail);
10180  }
10181  /*%
10182  $$ = dispatch2(regexp_add, $1, $2);
10183  %*/
10184  }
10185  break;
10186 
10187  case 486:
10188 
10189 /* Line 1806 of yacc.c */
10190 #line 4209 "parse.y"
10191  {
10192  (yyval.node) = lex_strterm;
10193  lex_strterm = 0;
10194  lex_state = EXPR_BEG;
10195  }
10196  break;
10197 
10198  case 487:
10199 
10200 /* Line 1806 of yacc.c */
10201 #line 4215 "parse.y"
10202  {
10203  /*%%%*/
10204  lex_strterm = (yyvsp[(2) - (3)].node);
10205  (yyval.node) = NEW_EVSTR((yyvsp[(3) - (3)].node));
10206  /*%
10207  lex_strterm = $<node>2;
10208  $$ = dispatch1(string_dvar, $3);
10209  %*/
10210  }
10211  break;
10212 
10213  case 488:
10214 
10215 /* Line 1806 of yacc.c */
10216 #line 4225 "parse.y"
10217  {
10218  (yyvsp[(1) - (1)].val) = cond_stack;
10219  (yyval.val) = cmdarg_stack;
10220  cond_stack = 0;
10221  cmdarg_stack = 0;
10222  }
10223  break;
10224 
10225  case 489:
10226 
10227 /* Line 1806 of yacc.c */
10228 #line 4231 "parse.y"
10229  {
10230  (yyval.node) = lex_strterm;
10231  lex_strterm = 0;
10232  lex_state = EXPR_BEG;
10233  }
10234  break;
10235 
10236  case 490:
10237 
10238 /* Line 1806 of yacc.c */
10239 #line 4236 "parse.y"
10240  {
10241  (yyval.num) = brace_nest;
10242  brace_nest = 0;
10243  }
10244  break;
10245 
10246  case 491:
10247 
10248 /* Line 1806 of yacc.c */
10249 #line 4241 "parse.y"
10250  {
10251  cond_stack = (yyvsp[(1) - (6)].val);
10252  cmdarg_stack = (yyvsp[(2) - (6)].val);
10253  lex_strterm = (yyvsp[(3) - (6)].node);
10254  brace_nest = (yyvsp[(4) - (6)].num);
10255  /*%%%*/
10256  if ((yyvsp[(5) - (6)].node)) (yyvsp[(5) - (6)].node)->flags &= ~NODE_FL_NEWLINE;
10257  (yyval.node) = new_evstr((yyvsp[(5) - (6)].node));
10258  /*%
10259  $$ = dispatch1(string_embexpr, $5);
10260  %*/
10261  }
10262  break;
10263 
10264  case 492:
10265 
10266 /* Line 1806 of yacc.c */
10267 #line 4256 "parse.y"
10268  {
10269  /*%%%*/
10270  (yyval.node) = NEW_GVAR((yyvsp[(1) - (1)].id));
10271  /*%
10272  $$ = dispatch1(var_ref, $1);
10273  %*/
10274  }
10275  break;
10276 
10277  case 493:
10278 
10279 /* Line 1806 of yacc.c */
10280 #line 4264 "parse.y"
10281  {
10282  /*%%%*/
10283  (yyval.node) = NEW_IVAR((yyvsp[(1) - (1)].id));
10284  /*%
10285  $$ = dispatch1(var_ref, $1);
10286  %*/
10287  }
10288  break;
10289 
10290  case 494:
10291 
10292 /* Line 1806 of yacc.c */
10293 #line 4272 "parse.y"
10294  {
10295  /*%%%*/
10296  (yyval.node) = NEW_CVAR((yyvsp[(1) - (1)].id));
10297  /*%
10298  $$ = dispatch1(var_ref, $1);
10299  %*/
10300  }
10301  break;
10302 
10303  case 496:
10304 
10305 /* Line 1806 of yacc.c */
10306 #line 4283 "parse.y"
10307  {
10308  lex_state = EXPR_END;
10309  /*%%%*/
10310  (yyval.id) = (yyvsp[(2) - (2)].id);
10311  /*%
10312  $$ = dispatch1(symbol, $2);
10313  %*/
10314  }
10315  break;
10316 
10317  case 501:
10318 
10319 /* Line 1806 of yacc.c */
10320 #line 4300 "parse.y"
10321  {
10322  lex_state = EXPR_END;
10323  /*%%%*/
10324  (yyval.node) = dsym_node((yyvsp[(2) - (3)].node));
10325  /*%
10326  $$ = dispatch1(dyna_symbol, $2);
10327  %*/
10328  }
10329  break;
10330 
10331  case 503:
10332 
10333 /* Line 1806 of yacc.c */
10334 #line 4312 "parse.y"
10335  {
10336  /*%%%*/
10337  (yyval.node) = negate_lit((yyvsp[(2) - (2)].node));
10338  /*%
10339  $$ = dispatch2(unary, ripper_intern("-@"), $2);
10340  %*/
10341  }
10342  break;
10343 
10344  case 513:
10345 
10346 /* Line 1806 of yacc.c */
10347 #line 4334 "parse.y"
10348  {ifndef_ripper((yyval.id) = keyword_nil);}
10349  break;
10350 
10351  case 514:
10352 
10353 /* Line 1806 of yacc.c */
10354 #line 4335 "parse.y"
10355  {ifndef_ripper((yyval.id) = keyword_self);}
10356  break;
10357 
10358  case 515:
10359 
10360 /* Line 1806 of yacc.c */
10361 #line 4336 "parse.y"
10362  {ifndef_ripper((yyval.id) = keyword_true);}
10363  break;
10364 
10365  case 516:
10366 
10367 /* Line 1806 of yacc.c */
10368 #line 4337 "parse.y"
10369  {ifndef_ripper((yyval.id) = keyword_false);}
10370  break;
10371 
10372  case 517:
10373 
10374 /* Line 1806 of yacc.c */
10375 #line 4338 "parse.y"
10376  {ifndef_ripper((yyval.id) = keyword__FILE__);}
10377  break;
10378 
10379  case 518:
10380 
10381 /* Line 1806 of yacc.c */
10382 #line 4339 "parse.y"
10383  {ifndef_ripper((yyval.id) = keyword__LINE__);}
10384  break;
10385 
10386  case 519:
10387 
10388 /* Line 1806 of yacc.c */
10389 #line 4340 "parse.y"
10390  {ifndef_ripper((yyval.id) = keyword__ENCODING__);}
10391  break;
10392 
10393  case 520:
10394 
10395 /* Line 1806 of yacc.c */
10396 #line 4344 "parse.y"
10397  {
10398  /*%%%*/
10399  if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0);
10400  /*%
10401  if (id_is_var(get_id($1))) {
10402  $$ = dispatch1(var_ref, $1);
10403  }
10404  else {
10405  $$ = dispatch1(vcall, $1);
10406  }
10407  %*/
10408  }
10409  break;
10410 
10411  case 521:
10412 
10413 /* Line 1806 of yacc.c */
10414 #line 4357 "parse.y"
10415  {
10416  /*%%%*/
10417  if (!((yyval.node) = gettable((yyvsp[(1) - (1)].id)))) (yyval.node) = NEW_BEGIN(0);
10418  /*%
10419  $$ = dispatch1(var_ref, $1);
10420  %*/
10421  }
10422  break;
10423 
10424  case 522:
10425 
10426 /* Line 1806 of yacc.c */
10427 #line 4367 "parse.y"
10428  {
10429  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
10430  /*%%%*/
10431  /*%
10432  $$ = dispatch1(var_field, $$);
10433  %*/
10434  }
10435  break;
10436 
10437  case 523:
10438 
10439 /* Line 1806 of yacc.c */
10440 #line 4375 "parse.y"
10441  {
10442  (yyval.node) = assignable((yyvsp[(1) - (1)].id), 0);
10443  /*%%%*/
10444  /*%
10445  $$ = dispatch1(var_field, $$);
10446  %*/
10447  }
10448  break;
10449 
10450  case 526:
10451 
10452 /* Line 1806 of yacc.c */
10453 #line 4389 "parse.y"
10454  {
10455  /*%%%*/
10456  (yyval.node) = 0;
10457  /*%
10458  $$ = Qnil;
10459  %*/
10460  }
10461  break;
10462 
10463  case 527:
10464 
10465 /* Line 1806 of yacc.c */
10466 #line 4397 "parse.y"
10467  {
10468  lex_state = EXPR_BEG;
10469  command_start = TRUE;
10470  }
10471  break;
10472 
10473  case 528:
10474 
10475 /* Line 1806 of yacc.c */
10476 #line 4402 "parse.y"
10477  {
10478  (yyval.node) = (yyvsp[(3) - (4)].node);
10479  }
10480  break;
10481 
10482  case 529:
10483 
10484 /* Line 1806 of yacc.c */
10485 #line 4406 "parse.y"
10486  {
10487  /*%%%*/
10488  yyerrok;
10489  (yyval.node) = 0;
10490  /*%
10491  yyerrok;
10492  $$ = Qnil;
10493  %*/
10494  }
10495  break;
10496 
10497  case 530:
10498 
10499 /* Line 1806 of yacc.c */
10500 #line 4418 "parse.y"
10501  {
10502  /*%%%*/
10503  (yyval.node) = (yyvsp[(2) - (3)].node);
10504  /*%
10505  $$ = dispatch1(paren, $2);
10506  %*/
10507  lex_state = EXPR_BEG;
10508  command_start = TRUE;
10509  }
10510  break;
10511 
10512  case 531:
10513 
10514 /* Line 1806 of yacc.c */
10515 #line 4427 "parse.y"
10516  {
10517  (yyval.num) = parser->parser_in_kwarg;
10518  parser->parser_in_kwarg = 1;
10519  }
10520  break;
10521 
10522  case 532:
10523 
10524 /* Line 1806 of yacc.c */
10525 #line 4432 "parse.y"
10526  {
10527  parser->parser_in_kwarg = (yyvsp[(1) - (3)].num);
10528  (yyval.node) = (yyvsp[(2) - (3)].node);
10529  lex_state = EXPR_BEG;
10530  command_start = TRUE;
10531  }
10532  break;
10533 
10534  case 533:
10535 
10536 /* Line 1806 of yacc.c */
10537 #line 4441 "parse.y"
10538  {
10539  (yyval.node) = new_args_tail((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), (yyvsp[(4) - (4)].id));
10540  }
10541  break;
10542 
10543  case 534:
10544 
10545 /* Line 1806 of yacc.c */
10546 #line 4445 "parse.y"
10547  {
10548  (yyval.node) = new_args_tail((yyvsp[(1) - (2)].node), Qnone, (yyvsp[(2) - (2)].id));
10549  }
10550  break;
10551 
10552  case 535:
10553 
10554 /* Line 1806 of yacc.c */
10555 #line 4449 "parse.y"
10556  {
10557  (yyval.node) = new_args_tail(Qnone, (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id));
10558  }
10559  break;
10560 
10561  case 536:
10562 
10563 /* Line 1806 of yacc.c */
10564 #line 4453 "parse.y"
10565  {
10566  (yyval.node) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].id));
10567  }
10568  break;
10569 
10570  case 537:
10571 
10572 /* Line 1806 of yacc.c */
10573 #line 4459 "parse.y"
10574  {
10575  (yyval.node) = (yyvsp[(2) - (2)].node);
10576  }
10577  break;
10578 
10579  case 538:
10580 
10581 /* Line 1806 of yacc.c */
10582 #line 4463 "parse.y"
10583  {
10584  (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
10585  }
10586  break;
10587 
10588  case 539:
10589 
10590 /* Line 1806 of yacc.c */
10591 #line 4469 "parse.y"
10592  {
10593  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].id), Qnone, (yyvsp[(6) - (6)].node));
10594  }
10595  break;
10596 
10597  case 540:
10598 
10599 /* Line 1806 of yacc.c */
10600 #line 4473 "parse.y"
10601  {
10602  (yyval.node) = new_args((yyvsp[(1) - (8)].node), (yyvsp[(3) - (8)].node), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].node), (yyvsp[(8) - (8)].node));
10603  }
10604  break;
10605 
10606  case 541:
10607 
10608 /* Line 1806 of yacc.c */
10609 #line 4477 "parse.y"
10610  {
10611  (yyval.node) = new_args((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node), Qnone, Qnone, (yyvsp[(4) - (4)].node));
10612  }
10613  break;
10614 
10615  case 542:
10616 
10617 /* Line 1806 of yacc.c */
10618 #line 4481 "parse.y"
10619  {
10620  (yyval.node) = new_args((yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].node), Qnone, (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10621  }
10622  break;
10623 
10624  case 543:
10625 
10626 /* Line 1806 of yacc.c */
10627 #line 4485 "parse.y"
10628  {
10629  (yyval.node) = new_args((yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
10630  }
10631  break;
10632 
10633  case 544:
10634 
10635 /* Line 1806 of yacc.c */
10636 #line 4489 "parse.y"
10637  {
10638  (yyval.node) = new_args((yyvsp[(1) - (6)].node), Qnone, (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10639  }
10640  break;
10641 
10642  case 545:
10643 
10644 /* Line 1806 of yacc.c */
10645 #line 4493 "parse.y"
10646  {
10647  (yyval.node) = new_args((yyvsp[(1) - (2)].node), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].node));
10648  }
10649  break;
10650 
10651  case 546:
10652 
10653 /* Line 1806 of yacc.c */
10654 #line 4497 "parse.y"
10655  {
10656  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].id), Qnone, (yyvsp[(4) - (4)].node));
10657  }
10658  break;
10659 
10660  case 547:
10661 
10662 /* Line 1806 of yacc.c */
10663 #line 4501 "parse.y"
10664  {
10665  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (6)].node), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].node), (yyvsp[(6) - (6)].node));
10666  }
10667  break;
10668 
10669  case 548:
10670 
10671 /* Line 1806 of yacc.c */
10672 #line 4505 "parse.y"
10673  {
10674  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (2)].node), Qnone, Qnone, (yyvsp[(2) - (2)].node));
10675  }
10676  break;
10677 
10678  case 549:
10679 
10680 /* Line 1806 of yacc.c */
10681 #line 4509 "parse.y"
10682  {
10683  (yyval.node) = new_args(Qnone, (yyvsp[(1) - (4)].node), Qnone, (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
10684  }
10685  break;
10686 
10687  case 550:
10688 
10689 /* Line 1806 of yacc.c */
10690 #line 4513 "parse.y"
10691  {
10692  (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].id), Qnone, (yyvsp[(2) - (2)].node));
10693  }
10694  break;
10695 
10696  case 551:
10697 
10698 /* Line 1806 of yacc.c */
10699 #line 4517 "parse.y"
10700  {
10701  (yyval.node) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node));
10702  }
10703  break;
10704 
10705  case 552:
10706 
10707 /* Line 1806 of yacc.c */
10708 #line 4521 "parse.y"
10709  {
10710  (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].node));
10711  }
10712  break;
10713 
10714  case 553:
10715 
10716 /* Line 1806 of yacc.c */
10717 #line 4525 "parse.y"
10718  {
10719  (yyval.node) = new_args_tail(Qnone, Qnone, Qnone);
10720  (yyval.node) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.node));
10721  }
10722  break;
10723 
10724  case 554:
10725 
10726 /* Line 1806 of yacc.c */
10727 #line 4532 "parse.y"
10728  {
10729  /*%%%*/
10730  yyerror("formal argument cannot be a constant");
10731  (yyval.id) = 0;
10732  /*%
10733  $$ = dispatch1(param_error, $1);
10734  %*/
10735  }
10736  break;
10737 
10738  case 555:
10739 
10740 /* Line 1806 of yacc.c */
10741 #line 4541 "parse.y"
10742  {
10743  /*%%%*/
10744  yyerror("formal argument cannot be an instance variable");
10745  (yyval.id) = 0;
10746  /*%
10747  $$ = dispatch1(param_error, $1);
10748  %*/
10749  }
10750  break;
10751 
10752  case 556:
10753 
10754 /* Line 1806 of yacc.c */
10755 #line 4550 "parse.y"
10756  {
10757  /*%%%*/
10758  yyerror("formal argument cannot be a global variable");
10759  (yyval.id) = 0;
10760  /*%
10761  $$ = dispatch1(param_error, $1);
10762  %*/
10763  }
10764  break;
10765 
10766  case 557:
10767 
10768 /* Line 1806 of yacc.c */
10769 #line 4559 "parse.y"
10770  {
10771  /*%%%*/
10772  yyerror("formal argument cannot be a class variable");
10773  (yyval.id) = 0;
10774  /*%
10775  $$ = dispatch1(param_error, $1);
10776  %*/
10777  }
10778  break;
10779 
10780  case 559:
10781 
10782 /* Line 1806 of yacc.c */
10783 #line 4571 "parse.y"
10784  {
10785  formal_argument(get_id((yyvsp[(1) - (1)].id)));
10786  (yyval.id) = (yyvsp[(1) - (1)].id);
10787  }
10788  break;
10789 
10790  case 560:
10791 
10792 /* Line 1806 of yacc.c */
10793 #line 4578 "parse.y"
10794  {
10795  arg_var(get_id((yyvsp[(1) - (1)].id)));
10796  /*%%%*/
10797  (yyval.node) = NEW_ARGS_AUX((yyvsp[(1) - (1)].id), 1);
10798  /*%
10799  $$ = get_value($1);
10800  %*/
10801  }
10802  break;
10803 
10804  case 561:
10805 
10806 /* Line 1806 of yacc.c */
10807 #line 4587 "parse.y"
10808  {
10809  ID tid = internal_id();
10810  arg_var(tid);
10811  /*%%%*/
10812  if (dyna_in_block()) {
10813  (yyvsp[(2) - (3)].node)->nd_value = NEW_DVAR(tid);
10814  }
10815  else {
10816  (yyvsp[(2) - (3)].node)->nd_value = NEW_LVAR(tid);
10817  }
10818  (yyval.node) = NEW_ARGS_AUX(tid, 1);
10819  (yyval.node)->nd_next = (yyvsp[(2) - (3)].node);
10820  /*%
10821  $$ = dispatch1(mlhs_paren, $2);
10822  %*/
10823  }
10824  break;
10825 
10826  case 563:
10827 
10828 /* Line 1806 of yacc.c */
10829 #line 4613 "parse.y"
10830  {
10831  /*%%%*/
10832  (yyval.node) = (yyvsp[(1) - (3)].node);
10833  (yyval.node)->nd_plen++;
10834  (yyval.node)->nd_next = block_append((yyval.node)->nd_next, (yyvsp[(3) - (3)].node)->nd_next);
10835  rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].node));
10836  /*%
10837  $$ = rb_ary_push($1, $3);
10838  %*/
10839  }
10840  break;
10841 
10842  case 564:
10843 
10844 /* Line 1806 of yacc.c */
10845 #line 4627 "parse.y"
10846  {
10847  arg_var(formal_argument(get_id((yyvsp[(1) - (1)].id))));
10848  (yyval.id) = (yyvsp[(1) - (1)].id);
10849  }
10850  break;
10851 
10852  case 565:
10853 
10854 /* Line 1806 of yacc.c */
10855 #line 4634 "parse.y"
10856  {
10857  (yyval.node) = assignable((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node));
10858  /*%%%*/
10859  (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10860  /*%
10861  $$ = rb_assoc_new($$, $2);
10862  %*/
10863  }
10864  break;
10865 
10866  case 566:
10867 
10868 /* Line 1806 of yacc.c */
10869 #line 4643 "parse.y"
10870  {
10871  (yyval.node) = assignable((yyvsp[(1) - (1)].id), (NODE *)-1);
10872  /*%%%*/
10873  (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10874  /*%
10875  $$ = rb_assoc_new($$, 0);
10876  %*/
10877  }
10878  break;
10879 
10880  case 567:
10881 
10882 /* Line 1806 of yacc.c */
10883 #line 4654 "parse.y"
10884  {
10885  (yyval.node) = assignable((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].node));
10886  /*%%%*/
10887  (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10888  /*%
10889  $$ = rb_assoc_new($$, $2);
10890  %*/
10891  }
10892  break;
10893 
10894  case 568:
10895 
10896 /* Line 1806 of yacc.c */
10897 #line 4663 "parse.y"
10898  {
10899  (yyval.node) = assignable((yyvsp[(1) - (1)].id), (NODE *)-1);
10900  /*%%%*/
10901  (yyval.node) = NEW_KW_ARG(0, (yyval.node));
10902  /*%
10903  $$ = rb_assoc_new($$, 0);
10904  %*/
10905  }
10906  break;
10907 
10908  case 569:
10909 
10910 /* Line 1806 of yacc.c */
10911 #line 4674 "parse.y"
10912  {
10913  /*%%%*/
10914  (yyval.node) = (yyvsp[(1) - (1)].node);
10915  /*%
10916  $$ = rb_ary_new3(1, $1);
10917  %*/
10918  }
10919  break;
10920 
10921  case 570:
10922 
10923 /* Line 1806 of yacc.c */
10924 #line 4682 "parse.y"
10925  {
10926  /*%%%*/
10927  NODE *kws = (yyvsp[(1) - (3)].node);
10928 
10929  while (kws->nd_next) {
10930  kws = kws->nd_next;
10931  }
10932  kws->nd_next = (yyvsp[(3) - (3)].node);
10933  (yyval.node) = (yyvsp[(1) - (3)].node);
10934  /*%
10935  $$ = rb_ary_push($1, $3);
10936  %*/
10937  }
10938  break;
10939 
10940  case 571:
10941 
10942 /* Line 1806 of yacc.c */
10943 #line 4699 "parse.y"
10944  {
10945  /*%%%*/
10946  (yyval.node) = (yyvsp[(1) - (1)].node);
10947  /*%
10948  $$ = rb_ary_new3(1, $1);
10949  %*/
10950  }
10951  break;
10952 
10953  case 572:
10954 
10955 /* Line 1806 of yacc.c */
10956 #line 4707 "parse.y"
10957  {
10958  /*%%%*/
10959  NODE *kws = (yyvsp[(1) - (3)].node);
10960 
10961  while (kws->nd_next) {
10962  kws = kws->nd_next;
10963  }
10964  kws->nd_next = (yyvsp[(3) - (3)].node);
10965  (yyval.node) = (yyvsp[(1) - (3)].node);
10966  /*%
10967  $$ = rb_ary_push($1, $3);
10968  %*/
10969  }
10970  break;
10971 
10972  case 575:
10973 
10974 /* Line 1806 of yacc.c */
10975 #line 4727 "parse.y"
10976  {
10977  shadowing_lvar(get_id((yyvsp[(2) - (2)].id)));
10978  (yyval.id) = (yyvsp[(2) - (2)].id);
10979  }
10980  break;
10981 
10982  case 576:
10983 
10984 /* Line 1806 of yacc.c */
10985 #line 4732 "parse.y"
10986  {
10987  (yyval.id) = internal_id();
10988  }
10989  break;
10990 
10991  case 577:
10992 
10993 /* Line 1806 of yacc.c */
10994 #line 4738 "parse.y"
10995  {
10996  arg_var(get_id((yyvsp[(1) - (3)].id)));
10997  (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node));
10998  /*%%%*/
10999  (yyval.node) = NEW_OPT_ARG(0, (yyval.node));
11000  /*%
11001  $$ = rb_assoc_new($$, $3);
11002  %*/
11003  }
11004  break;
11005 
11006  case 578:
11007 
11008 /* Line 1806 of yacc.c */
11009 #line 4750 "parse.y"
11010  {
11011  arg_var(get_id((yyvsp[(1) - (3)].id)));
11012  (yyval.node) = assignable((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].node));
11013  /*%%%*/
11014  (yyval.node) = NEW_OPT_ARG(0, (yyval.node));
11015  /*%
11016  $$ = rb_assoc_new($$, $3);
11017  %*/
11018  }
11019  break;
11020 
11021  case 579:
11022 
11023 /* Line 1806 of yacc.c */
11024 #line 4762 "parse.y"
11025  {
11026  /*%%%*/
11027  (yyval.node) = (yyvsp[(1) - (1)].node);
11028  /*%
11029  $$ = rb_ary_new3(1, $1);
11030  %*/
11031  }
11032  break;
11033 
11034  case 580:
11035 
11036 /* Line 1806 of yacc.c */
11037 #line 4770 "parse.y"
11038  {
11039  /*%%%*/
11040  NODE *opts = (yyvsp[(1) - (3)].node);
11041 
11042  while (opts->nd_next) {
11043  opts = opts->nd_next;
11044  }
11045  opts->nd_next = (yyvsp[(3) - (3)].node);
11046  (yyval.node) = (yyvsp[(1) - (3)].node);
11047  /*%
11048  $$ = rb_ary_push($1, $3);
11049  %*/
11050  }
11051  break;
11052 
11053  case 581:
11054 
11055 /* Line 1806 of yacc.c */
11056 #line 4786 "parse.y"
11057  {
11058  /*%%%*/
11059  (yyval.node) = (yyvsp[(1) - (1)].node);
11060  /*%
11061  $$ = rb_ary_new3(1, $1);
11062  %*/
11063  }
11064  break;
11065 
11066  case 582:
11067 
11068 /* Line 1806 of yacc.c */
11069 #line 4794 "parse.y"
11070  {
11071  /*%%%*/
11072  NODE *opts = (yyvsp[(1) - (3)].node);
11073 
11074  while (opts->nd_next) {
11075  opts = opts->nd_next;
11076  }
11077  opts->nd_next = (yyvsp[(3) - (3)].node);
11078  (yyval.node) = (yyvsp[(1) - (3)].node);
11079  /*%
11080  $$ = rb_ary_push($1, $3);
11081  %*/
11082  }
11083  break;
11084 
11085  case 585:
11086 
11087 /* Line 1806 of yacc.c */
11088 #line 4814 "parse.y"
11089  {
11090  /*%%%*/
11091  if (!is_local_id((yyvsp[(2) - (2)].id)))
11092  yyerror("rest argument must be local variable");
11093  /*% %*/
11094  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id))));
11095  /*%%%*/
11096  (yyval.id) = (yyvsp[(2) - (2)].id);
11097  /*%
11098  $$ = dispatch1(rest_param, $2);
11099  %*/
11100  }
11101  break;
11102 
11103  case 586:
11104 
11105 /* Line 1806 of yacc.c */
11106 #line 4827 "parse.y"
11107  {
11108  /*%%%*/
11109  (yyval.id) = internal_id();
11110  arg_var((yyval.id));
11111  /*%
11112  $$ = dispatch1(rest_param, Qnil);
11113  %*/
11114  }
11115  break;
11116 
11117  case 589:
11118 
11119 /* Line 1806 of yacc.c */
11120 #line 4842 "parse.y"
11121  {
11122  /*%%%*/
11123  if (!is_local_id((yyvsp[(2) - (2)].id)))
11124  yyerror("block argument must be local variable");
11125  else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].id)))
11126  yyerror("duplicated block argument name");
11127  /*% %*/
11128  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].id))));
11129  /*%%%*/
11130  (yyval.id) = (yyvsp[(2) - (2)].id);
11131  /*%
11132  $$ = dispatch1(blockarg, $2);
11133  %*/
11134  }
11135  break;
11136 
11137  case 590:
11138 
11139 /* Line 1806 of yacc.c */
11140 #line 4859 "parse.y"
11141  {
11142  (yyval.id) = (yyvsp[(2) - (2)].id);
11143  }
11144  break;
11145 
11146  case 591:
11147 
11148 /* Line 1806 of yacc.c */
11149 #line 4863 "parse.y"
11150  {
11151  /*%%%*/
11152  (yyval.id) = 0;
11153  /*%
11154  $$ = Qundef;
11155  %*/
11156  }
11157  break;
11158 
11159  case 592:
11160 
11161 /* Line 1806 of yacc.c */
11162 #line 4873 "parse.y"
11163  {
11164  /*%%%*/
11165  value_expr((yyvsp[(1) - (1)].node));
11166  (yyval.node) = (yyvsp[(1) - (1)].node);
11167  if (!(yyval.node)) (yyval.node) = NEW_NIL();
11168  /*%
11169  $$ = $1;
11170  %*/
11171  }
11172  break;
11173 
11174  case 593:
11175 
11176 /* Line 1806 of yacc.c */
11177 #line 4882 "parse.y"
11178  {lex_state = EXPR_BEG;}
11179  break;
11180 
11181  case 594:
11182 
11183 /* Line 1806 of yacc.c */
11184 #line 4883 "parse.y"
11185  {
11186  /*%%%*/
11187  if ((yyvsp[(3) - (4)].node) == 0) {
11188  yyerror("can't define singleton method for ().");
11189  }
11190  else {
11191  switch (nd_type((yyvsp[(3) - (4)].node))) {
11192  case NODE_STR:
11193  case NODE_DSTR:
11194  case NODE_XSTR:
11195  case NODE_DXSTR:
11196  case NODE_DREGX:
11197  case NODE_LIT:
11198  case NODE_ARRAY:
11199  case NODE_ZARRAY:
11200  yyerror("can't define singleton method for literals");
11201  default:
11202  value_expr((yyvsp[(3) - (4)].node));
11203  break;
11204  }
11205  }
11206  (yyval.node) = (yyvsp[(3) - (4)].node);
11207  /*%
11208  $$ = dispatch1(paren, $3);
11209  %*/
11210  }
11211  break;
11212 
11213  case 596:
11214 
11215 /* Line 1806 of yacc.c */
11216 #line 4913 "parse.y"
11217  {
11218  /*%%%*/
11219  (yyval.node) = (yyvsp[(1) - (2)].node);
11220  /*%
11221  $$ = dispatch1(assoclist_from_args, $1);
11222  %*/
11223  }
11224  break;
11225 
11226  case 598:
11227 
11228 /* Line 1806 of yacc.c */
11229 #line 4930 "parse.y"
11230  {
11231  /*%%%*/
11232  (yyval.node) = list_concat((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
11233  /*%
11234  $$ = rb_ary_push($1, $3);
11235  %*/
11236  }
11237  break;
11238 
11239  case 599:
11240 
11241 /* Line 1806 of yacc.c */
11242 #line 4940 "parse.y"
11243  {
11244  /*%%%*/
11245  if (nd_type((yyvsp[(1) - (3)].node)) == NODE_STR) {
11246  nd_set_type((yyvsp[(1) - (3)].node), NODE_LIT);
11247  (yyvsp[(1) - (3)].node)->nd_lit = rb_fstring((yyvsp[(1) - (3)].node)->nd_lit);
11248  }
11249  (yyval.node) = list_append(NEW_LIST((yyvsp[(1) - (3)].node)), (yyvsp[(3) - (3)].node));
11250  /*%
11251  $$ = dispatch2(assoc_new, $1, $3);
11252  %*/
11253  }
11254  break;
11255 
11256  case 600:
11257 
11258 /* Line 1806 of yacc.c */
11259 #line 4952 "parse.y"
11260  {
11261  /*%%%*/
11262  (yyval.node) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].id)))), (yyvsp[(2) - (2)].node));
11263  /*%
11264  $$ = dispatch2(assoc_new, $1, $2);
11265  %*/
11266  }
11267  break;
11268 
11269  case 601:
11270 
11271 /* Line 1806 of yacc.c */
11272 #line 4960 "parse.y"
11273  {
11274  /*%%%*/
11275  (yyval.node) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].node));
11276  /*%
11277  $$ = dispatch1(assoc_splat, $2);
11278  %*/
11279  }
11280  break;
11281 
11282  case 623:
11283 
11284 /* Line 1806 of yacc.c */
11285 #line 5018 "parse.y"
11286  {yyerrok;}
11287  break;
11288 
11289  case 626:
11290 
11291 /* Line 1806 of yacc.c */
11292 #line 5023 "parse.y"
11293  {yyerrok;}
11294  break;
11295 
11296  case 627:
11297 
11298 /* Line 1806 of yacc.c */
11299 #line 5027 "parse.y"
11300  {
11301  /*%%%*/
11302  (yyval.node) = 0;
11303  /*%
11304  $$ = Qundef;
11305  %*/
11306  }
11307  break;
11308 
11309 
11310 
11311 /* Line 1806 of yacc.c */
11312 #line 11311 "parse.c"
11313  default: break;
11314  }
11315  /* User semantic actions sometimes alter yychar, and that requires
11316  that yytoken be updated with the new translation. We take the
11317  approach of translating immediately before every use of yytoken.
11318  One alternative is translating here after every semantic action,
11319  but that translation would be missed if the semantic action invokes
11320  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11321  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
11322  incorrect destructor might then be invoked immediately. In the
11323  case of YYERROR or YYBACKUP, subsequent parser actions might lead
11324  to an incorrect destructor call or verbose syntax error message
11325  before the lookahead is translated. */
11326  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11327 
11328  YYPOPSTACK (yylen);
11329  yylen = 0;
11330  YY_STACK_PRINT (yyss, yyssp);
11331 
11332  *++yyvsp = yyval;
11333 
11334  /* Now `shift' the result of the reduction. Determine what state
11335  that goes to, based on the state we popped back to and the rule
11336  number reduced by. */
11337 
11338  yyn = yyr1[yyn];
11339 
11340  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
11341  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
11342  yystate = yytable[yystate];
11343  else
11344  yystate = yydefgoto[yyn - YYNTOKENS];
11345 
11346  goto yynewstate;
11347 
11348 
11349 /*------------------------------------.
11350 | yyerrlab -- here on detecting error |
11351 `------------------------------------*/
11352 yyerrlab:
11353  /* Make sure we have latest lookahead translation. See comments at
11354  user semantic actions for why this is necessary. */
11355  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
11356 
11357  /* If not already recovering from an error, report this error. */
11358  if (!yyerrstatus)
11359  {
11360  ++yynerrs;
11361 #if ! YYERROR_VERBOSE
11362  parser_yyerror (parser, YY_("syntax error"));
11363 #else
11364 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
11365  yyssp, yytoken)
11366  {
11367  char const *yymsgp = YY_("syntax error");
11368  int yysyntax_error_status;
11369  yysyntax_error_status = YYSYNTAX_ERROR;
11370  if (yysyntax_error_status == 0)
11371  yymsgp = yymsg;
11372  else if (yysyntax_error_status == 1)
11373  {
11374  if (yymsg != yymsgbuf)
11375  YYSTACK_FREE (yymsg);
11376  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11377  if (!yymsg)
11378  {
11379  yymsg = yymsgbuf;
11380  yymsg_alloc = sizeof yymsgbuf;
11381  yysyntax_error_status = 2;
11382  }
11383  else
11384  {
11385  yysyntax_error_status = YYSYNTAX_ERROR;
11386  yymsgp = yymsg;
11387  }
11388  }
11389  parser_yyerror (parser, yymsgp);
11390  if (yysyntax_error_status == 2)
11391  goto yyexhaustedlab;
11392  }
11393 # undef YYSYNTAX_ERROR
11394 #endif
11395  }
11396 
11397 
11398 
11399  if (yyerrstatus == 3)
11400  {
11401  /* If just tried and failed to reuse lookahead token after an
11402  error, discard it. */
11403 
11404  if (yychar <= YYEOF)
11405  {
11406  /* Return failure if at end of input. */
11407  if (yychar == YYEOF)
11408  YYABORT;
11409  }
11410  else
11411  {
11412  yydestruct ("Error: discarding",
11413  yytoken, &yylval, parser);
11414  yychar = YYEMPTY;
11415  }
11416  }
11417 
11418  /* Else will try to reuse lookahead token after shifting the error
11419  token. */
11420  goto yyerrlab1;
11421 
11422 
11423 /*---------------------------------------------------.
11424 | yyerrorlab -- error raised explicitly by YYERROR. |
11425 `---------------------------------------------------*/
11426 yyerrorlab:
11427 
11428  /* Pacify compilers like GCC when the user code never invokes
11429  YYERROR and the label yyerrorlab therefore never appears in user
11430  code. */
11431  if (/*CONSTCOND*/ 0)
11432  goto yyerrorlab;
11433 
11434  /* Do not reclaim the symbols of the rule which action triggered
11435  this YYERROR. */
11436  YYPOPSTACK (yylen);
11437  yylen = 0;
11438  YY_STACK_PRINT (yyss, yyssp);
11439  yystate = *yyssp;
11440  goto yyerrlab1;
11441 
11442 
11443 /*-------------------------------------------------------------.
11444 | yyerrlab1 -- common code for both syntax error and YYERROR. |
11445 `-------------------------------------------------------------*/
11446 yyerrlab1:
11447  yyerrstatus = 3; /* Each real token shifted decrements this. */
11448 
11449  for (;;)
11450  {
11451  yyn = yypact[yystate];
11452  if (!yypact_value_is_default (yyn))
11453  {
11454  yyn += YYTERROR;
11455  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11456  {
11457  yyn = yytable[yyn];
11458  if (0 < yyn)
11459  break;
11460  }
11461  }
11462 
11463  /* Pop the current state because it cannot handle the error token. */
11464  if (yyssp == yyss)
11465  YYABORT;
11466 
11467 
11468  yydestruct ("Error: popping",
11469  yystos[yystate], yyvsp, parser);
11470  YYPOPSTACK (1);
11471  yystate = *yyssp;
11472  YY_STACK_PRINT (yyss, yyssp);
11473  }
11474 
11475  *++yyvsp = yylval;
11476 
11477 
11478  /* Shift the error token. */
11479  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11480 
11481  yystate = yyn;
11482  goto yynewstate;
11483 
11484 
11485 /*-------------------------------------.
11486 | yyacceptlab -- YYACCEPT comes here. |
11487 `-------------------------------------*/
11488 yyacceptlab:
11489  yyresult = 0;
11490  goto yyreturn;
11491 
11492 /*-----------------------------------.
11493 | yyabortlab -- YYABORT comes here. |
11494 `-----------------------------------*/
11495 yyabortlab:
11496  yyresult = 1;
11497  goto yyreturn;
11498 
11499 #if !defined(yyoverflow) || YYERROR_VERBOSE
11500 /*-------------------------------------------------.
11501 | yyexhaustedlab -- memory exhaustion comes here. |
11502 `-------------------------------------------------*/
11503 yyexhaustedlab:
11504  parser_yyerror (parser, YY_("memory exhausted"));
11505  yyresult = 2;
11506  /* Fall through. */
11507 #endif
11508 
11509 yyreturn:
11510  if (yychar != YYEMPTY)
11511  {
11512  /* Make sure we have latest lookahead translation. See comments at
11513  user semantic actions for why this is necessary. */
11514  yytoken = YYTRANSLATE (yychar);
11515  yydestruct ("Cleanup: discarding lookahead",
11516  yytoken, &yylval, parser);
11517  }
11518  /* Do not reclaim the symbols of the rule which action triggered
11519  this YYABORT or YYACCEPT. */
11520  YYPOPSTACK (yylen);
11521  YY_STACK_PRINT (yyss, yyssp);
11522  while (yyssp != yyss)
11523  {
11524  yydestruct ("Cleanup: popping",
11525  yystos[*yyssp], yyvsp, parser);
11526  YYPOPSTACK (1);
11527  }
11528 #ifndef yyoverflow
11529  if (yyss != yyssa)
11530  YYSTACK_FREE (yyss);
11531 #endif
11532 #if YYERROR_VERBOSE
11533  if (yymsg != yymsgbuf)
11534  YYSTACK_FREE (yymsg);
11535 #endif
11536  /* Make sure YYID is used. */
11537  return YYID (yyresult);
11538 }
11539 
11540 
11541 
11542 /* Line 2067 of yacc.c */
11543 #line 5035 "parse.y"
11544 
11545 # undef parser
11546 # undef yylex
11547 # undef yylval
11548 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
11549 
11550 static int parser_regx_options(struct parser_params*);
11551 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11552 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11553 static int parser_parse_string(struct parser_params*,NODE*);
11554 static int parser_here_document(struct parser_params*,NODE*);
11555 
11556 
11557 # define nextc() parser_nextc(parser)
11558 # define pushback(c) parser_pushback(parser, (c))
11559 # define newtok() parser_newtok(parser)
11560 # define tokspace(n) parser_tokspace(parser, (n))
11561 # define tokadd(c) parser_tokadd(parser, (c))
11562 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
11563 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
11564 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
11565 # define regx_options() parser_regx_options(parser)
11566 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11567 # define parse_string(n) parser_parse_string(parser,(n))
11568 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
11569 # define here_document(n) parser_here_document(parser,(n))
11570 # define heredoc_identifier() parser_heredoc_identifier(parser)
11571 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
11572 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
11573 # define number_literal_suffix(f) parser_number_literal_suffix(parser, (f))
11574 # define set_number_literal(v, t, f) parser_set_number_literal(parser, (v), (t), (f))
11575 # define set_integer_literal(v, f) parser_set_integer_literal(parser, (v), (f))
11576 
11577 #ifndef RIPPER
11578 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11579 # define set_yylval_num(x) (yylval.num = (x))
11580 # define set_yylval_id(x) (yylval.id = (x))
11581 # define set_yylval_name(x) (yylval.id = (x))
11582 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11583 # define set_yylval_node(x) (yylval.node = (x))
11584 # define yylval_id() (yylval.id)
11585 #else
11586 static inline VALUE
11587 ripper_yylval_id(ID x)
11588 {
11589  return (VALUE)NEW_LASGN(x, ID2SYM(x));
11590 }
11591 # define set_yylval_str(x) (void)(x)
11592 # define set_yylval_num(x) (void)(x)
11593 # define set_yylval_id(x) (void)(x)
11594 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11595 # define set_yylval_literal(x) (void)(x)
11596 # define set_yylval_node(x) (void)(x)
11597 # define yylval_id() yylval.id
11598 #endif
11599 
11600 #ifndef RIPPER
11601 #define ripper_flush(p) (void)(p)
11602 #else
11603 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11604 
11605 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11606 
11607 static int
11608 ripper_has_scan_event(struct parser_params *parser)
11609 {
11610 
11611  if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11612  return lex_p > parser->tokp;
11613 }
11614 
11615 static VALUE
11616 ripper_scan_event_val(struct parser_params *parser, int t)
11617 {
11618  VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11619  VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11620  ripper_flush(parser);
11621  return rval;
11622 }
11623 
11624 static void
11625 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11626 {
11627  if (!ripper_has_scan_event(parser)) return;
11628  yylval_rval = ripper_scan_event_val(parser, t);
11629 }
11630 
11631 static void
11632 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11633 {
11634  if (!ripper_has_scan_event(parser)) return;
11635  (void)ripper_scan_event_val(parser, t);
11636 }
11637 
11638 static void
11639 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11640 {
11641  int saved_line = ruby_sourceline;
11642  const char *saved_tokp = parser->tokp;
11643 
11644  ruby_sourceline = parser->delayed_line;
11645  parser->tokp = lex_pbeg + parser->delayed_col;
11646  yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11647  parser->delayed = Qnil;
11648  ruby_sourceline = saved_line;
11649  parser->tokp = saved_tokp;
11650 }
11651 #endif /* RIPPER */
11652 
11653 #include "ruby/regex.h"
11654 #include "ruby/util.h"
11655 
11656 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11657  since ours (we hope) works properly with all combinations of
11658  machines, compilers, `char' and `unsigned char' argument types.
11659  (Per Bothner suggested the basic approach.) */
11660 #undef SIGN_EXTEND_CHAR
11661 #if __STDC__
11662 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11663 #else /* not __STDC__ */
11664 /* As in Harbison and Steele. */
11665 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11666 #endif
11667 
11668 #define parser_encoding_name() (current_enc->name)
11669 #define parser_mbclen() mbclen((lex_p-1),lex_pend,current_enc)
11670 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
11671 #define is_identchar(p,e,enc) (rb_enc_isalnum((unsigned char)(*(p)),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11672 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11673 
11674 #define parser_isascii() ISASCII(*(lex_p-1))
11675 
11676 #ifndef RIPPER
11677 static int
11678 token_info_get_column(struct parser_params *parser, const char *token)
11679 {
11680  int column = 1;
11681  const char *p, *pend = lex_p - strlen(token);
11682  for (p = lex_pbeg; p < pend; p++) {
11683  if (*p == '\t') {
11684  column = (((column - 1) / 8) + 1) * 8;
11685  }
11686  column++;
11687  }
11688  return column;
11689 }
11690 
11691 static int
11692 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11693 {
11694  const char *p, *pend = lex_p - strlen(token);
11695  for (p = lex_pbeg; p < pend; p++) {
11696  if (*p != ' ' && *p != '\t') {
11697  return 1;
11698  }
11699  }
11700  return 0;
11701 }
11702 
11703 #undef token_info_push
11704 static void
11705 token_info_push(struct parser_params *parser, const char *token)
11706 {
11707  token_info *ptinfo;
11708 
11709  if (!parser->parser_token_info_enabled) return;
11710  ptinfo = ALLOC(token_info);
11711  ptinfo->token = token;
11712  ptinfo->linenum = ruby_sourceline;
11713  ptinfo->column = token_info_get_column(parser, token);
11714  ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11715  ptinfo->next = parser->parser_token_info;
11716 
11717  parser->parser_token_info = ptinfo;
11718 }
11719 
11720 #undef token_info_pop
11721 static void
11722 token_info_pop(struct parser_params *parser, const char *token)
11723 {
11724  int linenum;
11725  token_info *ptinfo = parser->parser_token_info;
11726 
11727  if (!ptinfo) return;
11728  parser->parser_token_info = ptinfo->next;
11729  if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11730  goto finish;
11731  }
11732  linenum = ruby_sourceline;
11733  if (linenum == ptinfo->linenum) { /* SKIP */
11734  goto finish;
11735  }
11736  if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11737  goto finish;
11738  }
11739  if (parser->parser_token_info_enabled) {
11741  "mismatched indentations at '%s' with '%s' at %d",
11742  token, ptinfo->token, ptinfo->linenum);
11743  }
11744 
11745  finish:
11746  xfree(ptinfo);
11747 }
11748 #endif /* RIPPER */
11749 
11750 static int
11751 parser_yyerror(struct parser_params *parser, const char *msg)
11752 {
11753 #ifndef RIPPER
11754  const int max_line_margin = 30;
11755  const char *p, *pe;
11756  char *buf;
11757  long len;
11758  int i;
11759 
11760  compile_error(PARSER_ARG "%s", msg);
11761  p = lex_p;
11762  while (lex_pbeg <= p) {
11763  if (*p == '\n') break;
11764  p--;
11765  }
11766  p++;
11767 
11768  pe = lex_p;
11769  while (pe < lex_pend) {
11770  if (*pe == '\n') break;
11771  pe++;
11772  }
11773 
11774  len = pe - p;
11775  if (len > 4) {
11776  char *p2;
11777  const char *pre = "", *post = "";
11778 
11779  if (len > max_line_margin * 2 + 10) {
11780  if (lex_p - p > max_line_margin) {
11781  p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11782  pre = "...";
11783  }
11784  if (pe - lex_p > max_line_margin) {
11785  pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11786  post = "...";
11787  }
11788  len = pe - p;
11789  }
11790  buf = ALLOCA_N(char, len+2);
11791  MEMCPY(buf, p, char, len);
11792  buf[len] = '\0';
11793  rb_compile_error_with_enc(NULL, 0, (void *)current_enc, "%s%s%s", pre, buf, post);
11794 
11795  i = (int)(lex_p - p);
11796  p2 = buf; pe = buf + len;
11797 
11798  while (p2 < pe) {
11799  if (*p2 != '\t') *p2 = ' ';
11800  p2++;
11801  }
11802  buf[i] = '^';
11803  buf[i+1] = '\0';
11804  rb_compile_error_append("%s%s", pre, buf);
11805  }
11806 #else
11807  dispatch1(parse_error, STR_NEW2(msg));
11808 #endif /* !RIPPER */
11809  return 0;
11810 }
11811 
11812 static void parser_prepare(struct parser_params *parser);
11813 
11814 #ifndef RIPPER
11815 static VALUE
11817 {
11818  ID script_lines;
11819  CONST_ID(script_lines, "SCRIPT_LINES__");
11820  if (rb_const_defined_at(rb_cObject, script_lines)) {
11821  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11822  if (RB_TYPE_P(hash, T_HASH)) {
11823  VALUE lines = rb_ary_new();
11824  rb_hash_aset(hash, fname, lines);
11825  return lines;
11826  }
11827  }
11828  return 0;
11829 }
11830 
11831 static VALUE
11832 coverage(VALUE fname, int n)
11833 {
11834  VALUE coverages = rb_get_coverages();
11835  if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11836  VALUE lines = rb_ary_new2(n);
11837  int i;
11838  RBASIC_CLEAR_CLASS(lines);
11839  for (i = 0; i < n; i++) RARRAY_ASET(lines, i, Qnil);
11840  RARRAY(lines)->as.heap.len = n;
11841  rb_hash_aset(coverages, fname, lines);
11842  return lines;
11843  }
11844  return 0;
11845 }
11846 
11847 static int
11849 {
11850  return strcmp(ruby_sourcefile, "-e") == 0;
11851 }
11852 
11853 static VALUE
11855 {
11856  int n;
11857  NODE *tree;
11858  struct parser_params *parser = (struct parser_params *)arg;
11859 
11860  if (!compile_for_eval && rb_safe_level() == 0) {
11862  if (ruby_debug_lines && ruby_sourceline > 0) {
11863  VALUE str = STR_NEW0();
11864  n = ruby_sourceline;
11865  do {
11867  } while (--n);
11868  }
11869 
11870  if (!e_option_supplied(parser)) {
11872  }
11873  }
11874  parser->last_cr_line = ruby_sourceline - 1;
11875 
11876  parser_prepare(parser);
11877  deferred_nodes = 0;
11878 #ifndef RIPPER
11880 #endif
11881 #ifndef RIPPER
11884  parser->parser_ruby_sourceline);
11885  }
11886 #endif
11887  n = yyparse((void*)parser);
11888 #ifndef RIPPER
11890  RUBY_DTRACE_PARSE_END(parser->parser_ruby_sourcefile,
11891  parser->parser_ruby_sourceline);
11892  }
11893 #endif
11894  ruby_debug_lines = 0;
11895  ruby_coverage = 0;
11896  compile_for_eval = 0;
11897 
11898  lex_strterm = 0;
11899  lex_p = lex_pbeg = lex_pend = 0;
11900  lex_lastline = lex_nextline = 0;
11901  if (parser->nerr) {
11902  return 0;
11903  }
11904  tree = ruby_eval_tree;
11905  if (!tree) {
11906  tree = NEW_NIL();
11907  }
11908  else if (ruby_eval_tree_begin) {
11909  tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11910  }
11911  return (VALUE)tree;
11912 }
11913 
11914 static NODE*
11915 yycompile(struct parser_params *parser, VALUE fname, int line)
11916 {
11918  ruby_sourcefile = RSTRING_PTR(fname);
11919  ruby_sourceline = line - 1;
11920  return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
11921 }
11922 #endif /* !RIPPER */
11923 
11924 static rb_encoding *
11926 {
11927  rb_encoding *enc = rb_enc_get(s);
11928  if (!rb_enc_asciicompat(enc)) {
11929  rb_raise(rb_eArgError, "invalid source encoding");
11930  }
11931  return enc;
11932 }
11933 
11934 static VALUE
11935 lex_get_str(struct parser_params *parser, VALUE s)
11936 {
11937  char *beg, *end, *pend;
11939 
11940  beg = RSTRING_PTR(s);
11941  if (lex_gets_ptr) {
11942  if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
11943  beg += lex_gets_ptr;
11944  }
11945  pend = RSTRING_PTR(s) + RSTRING_LEN(s);
11946  end = beg;
11947  while (end < pend) {
11948  if (*end++ == '\n') break;
11949  }
11950  lex_gets_ptr = end - RSTRING_PTR(s);
11951  return rb_enc_str_new(beg, end - beg, enc);
11952 }
11953 
11954 static VALUE
11956 {
11957  VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
11958  if (NIL_P(line)) return line;
11960 #ifndef RIPPER
11961  if (ruby_debug_lines) {
11964  }
11965  if (ruby_coverage) {
11967  }
11968 #endif
11969  return line;
11970 }
11971 
11972 #ifdef RIPPER
11974 #else
11976 
11977 static NODE*
11978 parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
11979 {
11980  struct parser_params *parser;
11981  NODE *node;
11982 
11983  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11985  lex_gets_ptr = 0;
11986  lex_input = s;
11987  lex_pbeg = lex_p = lex_pend = 0;
11989 
11990  node = yycompile(parser, fname, line);
11991  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11992 
11993  return node;
11994 }
11995 
11996 NODE*
11997 rb_compile_string(const char *f, VALUE s, int line)
11998 {
12001 }
12002 
12003 NODE*
12004 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
12005 {
12006  return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
12007 }
12008 
12009 NODE*
12010 rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
12011 {
12013  return parser_compile_string(vparser, f, s, line);
12014 }
12015 
12016 NODE*
12017 rb_compile_cstr(const char *f, const char *s, int len, int line)
12018 {
12019  VALUE str = rb_str_new(s, len);
12021 }
12022 
12023 NODE*
12024 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
12025 {
12026  VALUE str = rb_str_new(s, len);
12027  return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line);
12028 }
12029 
12030 static VALUE
12031 lex_io_gets(struct parser_params *parser, VALUE io)
12032 {
12033  return rb_io_gets(io);
12034 }
12035 
12036 NODE*
12037 rb_compile_file(const char *f, VALUE file, int start)
12038 {
12039  VALUE volatile vparser = rb_parser_new();
12040 
12041  return rb_parser_compile_file(vparser, f, file, start);
12042 }
12043 
12044 NODE*
12045 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
12046 {
12047  return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start);
12048 }
12049 
12050 NODE*
12051 rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
12052 {
12053  struct parser_params *parser;
12054  NODE *node;
12055 
12056  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12058  lex_input = file;
12059  lex_pbeg = lex_p = lex_pend = 0;
12061 
12062  node = yycompile(parser, fname, start);
12063  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12064 
12065  return node;
12066 }
12067 #endif /* !RIPPER */
12068 
12069 #define STR_FUNC_ESCAPE 0x01
12070 #define STR_FUNC_EXPAND 0x02
12071 #define STR_FUNC_REGEXP 0x04
12072 #define STR_FUNC_QWORDS 0x08
12073 #define STR_FUNC_SYMBOL 0x10
12074 #define STR_FUNC_INDENT 0x20
12075 
12077  str_squote = (0),
12085 };
12086 
12087 static VALUE
12088 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
12089 {
12090  VALUE str;
12091 
12092  str = rb_enc_str_new(p, n, enc);
12093  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12095  }
12096  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12098  }
12099  }
12100 
12101  return str;
12102 }
12103 
12104 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
12105 #define lex_eol_p() (lex_p >= lex_pend)
12106 #define peek(c) peek_n((c), 0)
12107 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
12108 
12109 static inline int
12111 {
12112  int c;
12113 
12114  if (lex_p == lex_pend) {
12115  VALUE v = lex_nextline;
12116  lex_nextline = 0;
12117  if (!v) {
12118  if (parser->eofp)
12119  return -1;
12120 
12121  if (!lex_input || NIL_P(v = lex_getline(parser))) {
12122  parser->eofp = Qtrue;
12123  lex_goto_eol(parser);
12124  return -1;
12125  }
12126  }
12127  {
12128 #ifdef RIPPER
12129  if (parser->tokp < lex_pend) {
12130  if (NIL_P(parser->delayed)) {
12131  parser->delayed = rb_str_buf_new(1024);
12132  rb_enc_associate(parser->delayed, current_enc);
12133  rb_str_buf_cat(parser->delayed,
12134  parser->tokp, lex_pend - parser->tokp);
12135  parser->delayed_line = ruby_sourceline;
12136  parser->delayed_col = (int)(parser->tokp - lex_pbeg);
12137  }
12138  else {
12139  rb_str_buf_cat(parser->delayed,
12140  parser->tokp, lex_pend - parser->tokp);
12141  }
12142  }
12143 #endif
12144  if (heredoc_end > 0) {
12146  heredoc_end = 0;
12147  }
12148  ruby_sourceline++;
12149  parser->line_count++;
12150  lex_pbeg = lex_p = RSTRING_PTR(v);
12151  lex_pend = lex_p + RSTRING_LEN(v);
12152  ripper_flush(parser);
12153  lex_lastline = v;
12154  }
12155  }
12156  c = (unsigned char)*lex_p++;
12157  if (c == '\r') {
12158  if (peek('\n')) {
12159  lex_p++;
12160  c = '\n';
12161  }
12162  else if (ruby_sourceline > parser->last_cr_line) {
12163  parser->last_cr_line = ruby_sourceline;
12164  rb_compile_warn(ruby_sourcefile, ruby_sourceline, "encountered \\r in middle of line, treated as a mere space");
12165  }
12166  }
12167 
12168  return c;
12169 }
12170 
12171 static void
12172 parser_pushback(struct parser_params *parser, int c)
12173 {
12174  if (c == -1) return;
12175  lex_p--;
12176  if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
12177  lex_p--;
12178  }
12179 }
12180 
12181 #define was_bol() (lex_p == lex_pbeg + 1)
12182 
12183 #define tokfix() (tokenbuf[tokidx]='\0')
12184 #define tok() tokenbuf
12185 #define toklen() tokidx
12186 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
12187 
12188 static char*
12190 {
12191  tokidx = 0;
12193  if (!tokenbuf) {
12194  toksiz = 60;
12195  tokenbuf = ALLOC_N(char, 60);
12196  }
12197  if (toksiz > 4096) {
12198  toksiz = 60;
12199  REALLOC_N(tokenbuf, char, 60);
12200  }
12201  return tokenbuf;
12202 }
12203 
12204 static char *
12205 parser_tokspace(struct parser_params *parser, int n)
12206 {
12207  tokidx += n;
12208 
12209  if (tokidx >= toksiz) {
12210  do {toksiz *= 2;} while (toksiz < tokidx);
12211  REALLOC_N(tokenbuf, char, toksiz);
12212  }
12213  return &tokenbuf[tokidx-n];
12214 }
12215 
12216 static void
12217 parser_tokadd(struct parser_params *parser, int c)
12218 {
12219  tokenbuf[tokidx++] = (char)c;
12220  if (tokidx >= toksiz) {
12221  toksiz *= 2;
12222  REALLOC_N(tokenbuf, char, toksiz);
12223  }
12224 }
12225 
12226 static int
12227 parser_tok_hex(struct parser_params *parser, size_t *numlen)
12228 {
12229  int c;
12230 
12231  c = scan_hex(lex_p, 2, numlen);
12232  if (!*numlen) {
12233  yyerror("invalid hex escape");
12234  return 0;
12235  }
12236  lex_p += *numlen;
12237  return c;
12238 }
12239 
12240 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
12241 
12242 /* return value is for ?\u3042 */
12243 static int
12245  int string_literal, int symbol_literal, int regexp_literal)
12246 {
12247  /*
12248  * If string_literal is true, then we allow multiple codepoints
12249  * in \u{}, and add the codepoints to the current token.
12250  * Otherwise we're parsing a character literal and return a single
12251  * codepoint without adding it
12252  */
12253 
12254  int codepoint;
12255  size_t numlen;
12256 
12257  if (regexp_literal) { tokadd('\\'); tokadd('u'); }
12258 
12259  if (peek('{')) { /* handle \u{...} form */
12260  do {
12261  if (regexp_literal) { tokadd(*lex_p); }
12262  nextc();
12263  codepoint = scan_hex(lex_p, 6, &numlen);
12264  if (numlen == 0) {
12265  yyerror("invalid Unicode escape");
12266  return 0;
12267  }
12268  if (codepoint > 0x10ffff) {
12269  yyerror("invalid Unicode codepoint (too large)");
12270  return 0;
12271  }
12272  lex_p += numlen;
12273  if (regexp_literal) {
12274  tokcopy((int)numlen);
12275  }
12276  else if (codepoint >= 0x80) {
12277  *encp = rb_utf8_encoding();
12278  if (string_literal) tokaddmbc(codepoint, *encp);
12279  }
12280  else if (string_literal) {
12281  tokadd(codepoint);
12282  }
12283  } while (string_literal && (peek(' ') || peek('\t')));
12284 
12285  if (!peek('}')) {
12286  yyerror("unterminated Unicode escape");
12287  return 0;
12288  }
12289 
12290  if (regexp_literal) { tokadd('}'); }
12291  nextc();
12292  }
12293  else { /* handle \uxxxx form */
12294  codepoint = scan_hex(lex_p, 4, &numlen);
12295  if (numlen < 4) {
12296  yyerror("invalid Unicode escape");
12297  return 0;
12298  }
12299  lex_p += 4;
12300  if (regexp_literal) {
12301  tokcopy(4);
12302  }
12303  else if (codepoint >= 0x80) {
12304  *encp = rb_utf8_encoding();
12305  if (string_literal) tokaddmbc(codepoint, *encp);
12306  }
12307  else if (string_literal) {
12308  tokadd(codepoint);
12309  }
12310  }
12311 
12312  return codepoint;
12313 }
12314 
12315 #define ESCAPE_CONTROL 1
12316 #define ESCAPE_META 2
12317 
12318 static int
12319 parser_read_escape(struct parser_params *parser, int flags,
12320  rb_encoding **encp)
12321 {
12322  int c;
12323  size_t numlen;
12324 
12325  switch (c = nextc()) {
12326  case '\\': /* Backslash */
12327  return c;
12328 
12329  case 'n': /* newline */
12330  return '\n';
12331 
12332  case 't': /* horizontal tab */
12333  return '\t';
12334 
12335  case 'r': /* carriage-return */
12336  return '\r';
12337 
12338  case 'f': /* form-feed */
12339  return '\f';
12340 
12341  case 'v': /* vertical tab */
12342  return '\13';
12343 
12344  case 'a': /* alarm(bell) */
12345  return '\007';
12346 
12347  case 'e': /* escape */
12348  return 033;
12349 
12350  case '0': case '1': case '2': case '3': /* octal constant */
12351  case '4': case '5': case '6': case '7':
12352  pushback(c);
12353  c = scan_oct(lex_p, 3, &numlen);
12354  lex_p += numlen;
12355  return c;
12356 
12357  case 'x': /* hex constant */
12358  c = tok_hex(&numlen);
12359  if (numlen == 0) return 0;
12360  return c;
12361 
12362  case 'b': /* backspace */
12363  return '\010';
12364 
12365  case 's': /* space */
12366  return ' ';
12367 
12368  case 'M':
12369  if (flags & ESCAPE_META) goto eof;
12370  if ((c = nextc()) != '-') {
12371  pushback(c);
12372  goto eof;
12373  }
12374  if ((c = nextc()) == '\\') {
12375  if (peek('u')) goto eof;
12376  return read_escape(flags|ESCAPE_META, encp) | 0x80;
12377  }
12378  else if (c == -1 || !ISASCII(c)) goto eof;
12379  else {
12380  return ((c & 0xff) | 0x80);
12381  }
12382 
12383  case 'C':
12384  if ((c = nextc()) != '-') {
12385  pushback(c);
12386  goto eof;
12387  }
12388  case 'c':
12389  if (flags & ESCAPE_CONTROL) goto eof;
12390  if ((c = nextc())== '\\') {
12391  if (peek('u')) goto eof;
12392  c = read_escape(flags|ESCAPE_CONTROL, encp);
12393  }
12394  else if (c == '?')
12395  return 0177;
12396  else if (c == -1 || !ISASCII(c)) goto eof;
12397  return c & 0x9f;
12398 
12399  eof:
12400  case -1:
12401  yyerror("Invalid escape character syntax");
12402  return '\0';
12403 
12404  default:
12405  return c;
12406  }
12407 }
12408 
12409 static void
12411 {
12412  int len = rb_enc_codelen(c, enc);
12413  rb_enc_mbcput(c, tokspace(len), enc);
12414 }
12415 
12416 static int
12418 {
12419  int c;
12420  int flags = 0;
12421  size_t numlen;
12422 
12423  first:
12424  switch (c = nextc()) {
12425  case '\n':
12426  return 0; /* just ignore */
12427 
12428  case '0': case '1': case '2': case '3': /* octal constant */
12429  case '4': case '5': case '6': case '7':
12430  {
12431  ruby_scan_oct(--lex_p, 3, &numlen);
12432  if (numlen == 0) goto eof;
12433  lex_p += numlen;
12434  tokcopy((int)numlen + 1);
12435  }
12436  return 0;
12437 
12438  case 'x': /* hex constant */
12439  {
12440  tok_hex(&numlen);
12441  if (numlen == 0) return -1;
12442  tokcopy((int)numlen + 2);
12443  }
12444  return 0;
12445 
12446  case 'M':
12447  if (flags & ESCAPE_META) goto eof;
12448  if ((c = nextc()) != '-') {
12449  pushback(c);
12450  goto eof;
12451  }
12452  tokcopy(3);
12453  flags |= ESCAPE_META;
12454  goto escaped;
12455 
12456  case 'C':
12457  if (flags & ESCAPE_CONTROL) goto eof;
12458  if ((c = nextc()) != '-') {
12459  pushback(c);
12460  goto eof;
12461  }
12462  tokcopy(3);
12463  goto escaped;
12464 
12465  case 'c':
12466  if (flags & ESCAPE_CONTROL) goto eof;
12467  tokcopy(2);
12468  flags |= ESCAPE_CONTROL;
12469  escaped:
12470  if ((c = nextc()) == '\\') {
12471  goto first;
12472  }
12473  else if (c == -1) goto eof;
12474  tokadd(c);
12475  return 0;
12476 
12477  eof:
12478  case -1:
12479  yyerror("Invalid escape character syntax");
12480  return -1;
12481 
12482  default:
12483  tokadd('\\');
12484  tokadd(c);
12485  }
12486  return 0;
12487 }
12488 
12489 static int
12491 {
12492  int kcode = 0;
12493  int kopt = 0;
12494  int options = 0;
12495  int c, opt, kc;
12496 
12497  newtok();
12498  while (c = nextc(), ISALPHA(c)) {
12499  if (c == 'o') {
12501  }
12502  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12503  if (kc >= 0) {
12504  if (kc != rb_ascii8bit_encindex()) kcode = c;
12505  kopt = opt;
12506  }
12507  else {
12508  options |= opt;
12509  }
12510  }
12511  else {
12512  tokadd(c);
12513  }
12514  }
12515  options |= kopt;
12516  pushback(c);
12517  if (toklen()) {
12518  tokfix();
12519  compile_error(PARSER_ARG "unknown regexp option%s - %s",
12520  toklen() > 1 ? "s" : "", tok());
12521  }
12522  return options | RE_OPTION_ENCODING(kcode);
12523 }
12524 
12525 static void
12527 {
12528  rb_str_free(str);
12529  rb_gc_force_recycle(str);
12530 }
12531 
12532 static int
12533 parser_tokadd_mbchar(struct parser_params *parser, int c)
12534 {
12535  int len = parser_precise_mbclen();
12536  if (!MBCLEN_CHARFOUND_P(len)) {
12537  compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12538  return -1;
12539  }
12540  tokadd(c);
12541  lex_p += --len;
12542  if (len > 0) tokcopy(len);
12543  return c;
12544 }
12545 
12546 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12547 
12548 static inline int
12550 {
12551  switch (c) {
12552  case '$': case '*': case '+': case '.':
12553  case '?': case '^': case '|':
12554  case ')': case ']': case '}': case '>':
12555  return TRUE;
12556  default:
12557  return FALSE;
12558  }
12559 }
12560 
12561 static int
12563  int func, int term, int paren, long *nest,
12564  rb_encoding **encp)
12565 {
12566  int c;
12567  int has_nonascii = 0;
12568  rb_encoding *enc = *encp;
12569  char *errbuf = 0;
12570  static const char mixed_msg[] = "%s mixed within %s source";
12571 
12572 #define mixed_error(enc1, enc2) if (!errbuf) { \
12573  size_t len = sizeof(mixed_msg) - 4; \
12574  len += strlen(rb_enc_name(enc1)); \
12575  len += strlen(rb_enc_name(enc2)); \
12576  errbuf = ALLOCA_N(char, len); \
12577  snprintf(errbuf, len, mixed_msg, \
12578  rb_enc_name(enc1), \
12579  rb_enc_name(enc2)); \
12580  yyerror(errbuf); \
12581  }
12582 #define mixed_escape(beg, enc1, enc2) do { \
12583  const char *pos = lex_p; \
12584  lex_p = (beg); \
12585  mixed_error((enc1), (enc2)); \
12586  lex_p = pos; \
12587  } while (0)
12588 
12589  while ((c = nextc()) != -1) {
12590  if (paren && c == paren) {
12591  ++*nest;
12592  }
12593  else if (c == term) {
12594  if (!nest || !*nest) {
12595  pushback(c);
12596  break;
12597  }
12598  --*nest;
12599  }
12600  else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12601  int c2 = *lex_p;
12602  if (c2 == '$' || c2 == '@' || c2 == '{') {
12603  pushback(c);
12604  break;
12605  }
12606  }
12607  else if (c == '\\') {
12608  const char *beg = lex_p - 1;
12609  c = nextc();
12610  switch (c) {
12611  case '\n':
12612  if (func & STR_FUNC_QWORDS) break;
12613  if (func & STR_FUNC_EXPAND) continue;
12614  tokadd('\\');
12615  break;
12616 
12617  case '\\':
12618  if (func & STR_FUNC_ESCAPE) tokadd(c);
12619  break;
12620 
12621  case 'u':
12622  if ((func & STR_FUNC_EXPAND) == 0) {
12623  tokadd('\\');
12624  break;
12625  }
12626  parser_tokadd_utf8(parser, &enc, 1,
12628  func & STR_FUNC_REGEXP);
12629  if (has_nonascii && enc != *encp) {
12630  mixed_escape(beg, enc, *encp);
12631  }
12632  continue;
12633 
12634  default:
12635  if (c == -1) return -1;
12636  if (!ISASCII(c)) {
12637  if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12638  goto non_ascii;
12639  }
12640  if (func & STR_FUNC_REGEXP) {
12641  if (c == term && !simple_re_meta(c)) {
12642  tokadd(c);
12643  continue;
12644  }
12645  pushback(c);
12646  if ((c = tokadd_escape(&enc)) < 0)
12647  return -1;
12648  if (has_nonascii && enc != *encp) {
12649  mixed_escape(beg, enc, *encp);
12650  }
12651  continue;
12652  }
12653  else if (func & STR_FUNC_EXPAND) {
12654  pushback(c);
12655  if (func & STR_FUNC_ESCAPE) tokadd('\\');
12656  c = read_escape(0, &enc);
12657  }
12658  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12659  /* ignore backslashed spaces in %w */
12660  }
12661  else if (c != term && !(paren && c == paren)) {
12662  tokadd('\\');
12663  pushback(c);
12664  continue;
12665  }
12666  }
12667  }
12668  else if (!parser_isascii()) {
12669  non_ascii:
12670  has_nonascii = 1;
12671  if (enc != *encp) {
12672  mixed_error(enc, *encp);
12673  continue;
12674  }
12675  if (tokadd_mbchar(c) == -1) return -1;
12676  continue;
12677  }
12678  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12679  pushback(c);
12680  break;
12681  }
12682  if (c & 0x80) {
12683  has_nonascii = 1;
12684  if (enc != *encp) {
12685  mixed_error(enc, *encp);
12686  continue;
12687  }
12688  }
12689  tokadd(c);
12690  }
12691  *encp = enc;
12692  return c;
12693 }
12694 
12695 #define NEW_STRTERM(func, term, paren) \
12696  rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12697 
12698 #ifdef RIPPER
12699 static void
12700 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12701 {
12702  if (!NIL_P(parser->delayed)) {
12703  ptrdiff_t len = lex_p - parser->tokp;
12704  if (len > 0) {
12705  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12706  }
12707  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12708  parser->tokp = lex_p;
12709  }
12710 }
12711 
12712 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12713 #else
12714 #define flush_string_content(enc) ((void)(enc))
12715 #endif
12716 
12717 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12718 /* this can be shared with ripper, since it's independent from struct
12719  * parser_params. */
12720 #ifndef RIPPER
12721 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12722 #define SPECIAL_PUNCT(idx) ( \
12723  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12724  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12725  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12726  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12727  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12728  BIT('0', idx))
12729 const unsigned int ruby_global_name_punct_bits[] = {
12730  SPECIAL_PUNCT(0),
12731  SPECIAL_PUNCT(1),
12732  SPECIAL_PUNCT(2),
12733 };
12734 #undef BIT
12735 #undef SPECIAL_PUNCT
12736 #endif
12737 
12738 static inline int
12740 {
12741  if (c <= 0x20 || 0x7e < c) return 0;
12742  return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12743 }
12744 
12745 static int
12747 {
12748  int c;
12749  const char *p = lex_p;
12750 
12751  if (p + 1 >= lex_pend) return 0;
12752  c = *p++;
12753  switch (c) {
12754  case '$':
12755  if ((c = *p) == '-') {
12756  if (++p >= lex_pend) return 0;
12757  c = *p;
12758  }
12759  else if (is_global_name_punct(c) || ISDIGIT(c)) {
12760  return tSTRING_DVAR;
12761  }
12762  break;
12763  case '@':
12764  if ((c = *p) == '@') {
12765  if (++p >= lex_pend) return 0;
12766  c = *p;
12767  }
12768  break;
12769  case '{':
12770  lex_p = p;
12771  command_start = TRUE;
12772  return tSTRING_DBEG;
12773  default:
12774  return 0;
12775  }
12776  if (!ISASCII(c) || c == '_' || ISALPHA(c))
12777  return tSTRING_DVAR;
12778  return 0;
12779 }
12780 
12781 static int
12782 parser_parse_string(struct parser_params *parser, NODE *quote)
12783 {
12784  int func = (int)quote->nd_func;
12785  int term = nd_term(quote);
12786  int paren = nd_paren(quote);
12787  int c, space = 0;
12789 
12790  if (func == -1) return tSTRING_END;
12791  c = nextc();
12792  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12793  do {c = nextc();} while (ISSPACE(c));
12794  space = 1;
12795  }
12796  if (c == term && !quote->nd_nest) {
12797  if (func & STR_FUNC_QWORDS) {
12798  quote->nd_func = -1;
12799  return ' ';
12800  }
12801  if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12803  return tREGEXP_END;
12804  }
12805  if (space) {
12806  pushback(c);
12807  return ' ';
12808  }
12809  newtok();
12810  if ((func & STR_FUNC_EXPAND) && c == '#') {
12811  int t = parser_peek_variable_name(parser);
12812  if (t) return t;
12813  tokadd('#');
12814  c = nextc();
12815  }
12816  pushback(c);
12817  if (tokadd_string(func, term, paren, &quote->nd_nest,
12818  &enc) == -1) {
12819  ruby_sourceline = nd_line(quote);
12820  if (func & STR_FUNC_REGEXP) {
12821  if (parser->eofp)
12822  compile_error(PARSER_ARG "unterminated regexp meets end of file");
12823  return tREGEXP_END;
12824  }
12825  else {
12826  if (parser->eofp)
12827  compile_error(PARSER_ARG "unterminated string meets end of file");
12828  return tSTRING_END;
12829  }
12830  }
12831 
12832  tokfix();
12835 
12836  return tSTRING_CONTENT;
12837 }
12838 
12839 static int
12841 {
12842  int c = nextc(), term, func = 0;
12843  long len;
12844 
12845  if (c == '-') {
12846  c = nextc();
12848  }
12849  switch (c) {
12850  case '\'':
12851  func |= str_squote; goto quoted;
12852  case '"':
12853  func |= str_dquote; goto quoted;
12854  case '`':
12855  func |= str_xquote;
12856  quoted:
12857  newtok();
12858  tokadd(func);
12859  term = c;
12860  while ((c = nextc()) != -1 && c != term) {
12861  if (tokadd_mbchar(c) == -1) return 0;
12862  }
12863  if (c == -1) {
12864  compile_error(PARSER_ARG "unterminated here document identifier");
12865  return 0;
12866  }
12867  break;
12868 
12869  default:
12870  if (!parser_is_identchar()) {
12871  pushback(c);
12872  if (func & STR_FUNC_INDENT) {
12873  pushback('-');
12874  }
12875  return 0;
12876  }
12877  newtok();
12878  term = '"';
12879  tokadd(func |= str_dquote);
12880  do {
12881  if (tokadd_mbchar(c) == -1) return 0;
12882  } while ((c = nextc()) != -1 && parser_is_identchar());
12883  pushback(c);
12884  break;
12885  }
12886 
12887  tokfix();
12888 #ifdef RIPPER
12889  ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12890 #endif
12891  len = lex_p - lex_pbeg;
12892  lex_goto_eol(parser);
12894  STR_NEW(tok(), toklen()), /* nd_lit */
12895  len, /* nd_nth */
12896  lex_lastline); /* nd_orig */
12898  ripper_flush(parser);
12899  return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12900 }
12901 
12902 static void
12904 {
12905  VALUE line;
12906 
12907  lex_strterm = 0;
12908  line = here->nd_orig;
12909  lex_lastline = line;
12910  lex_pbeg = RSTRING_PTR(line);
12911  lex_pend = lex_pbeg + RSTRING_LEN(line);
12912  lex_p = lex_pbeg + here->nd_nth;
12914  ruby_sourceline = nd_line(here);
12915  dispose_string(here->nd_lit);
12916  rb_gc_force_recycle((VALUE)here);
12917  ripper_flush(parser);
12918 }
12919 
12920 static int
12922  const char *eos, long len, int indent)
12923 {
12924  const char *p = lex_pbeg;
12925  long n;
12926 
12927  if (indent) {
12928  while (*p && ISSPACE(*p)) p++;
12929  }
12930  n = lex_pend - (p + len);
12931  if (n < 0) return FALSE;
12932  if (n > 0 && p[len] != '\n') {
12933  if (p[len] != '\r') return FALSE;
12934  if (n <= 1 || p[len+1] != '\n') return FALSE;
12935  }
12936  return strncmp(eos, p, len) == 0;
12937 }
12938 
12939 #define NUM_SUFFIX_R (1<<0)
12940 #define NUM_SUFFIX_I (1<<1)
12941 #define NUM_SUFFIX_ALL 3
12942 
12943 static int
12945 {
12946  int c, result = 0;
12947  const char *lastp = lex_p;
12948 
12949  while ((c = nextc()) != -1) {
12950  if ((mask & NUM_SUFFIX_I) && c == 'i') {
12951  result |= (mask & NUM_SUFFIX_I);
12952  mask &= ~NUM_SUFFIX_I;
12953  /* r after i, rational of complex is disallowed */
12954  mask &= ~NUM_SUFFIX_R;
12955  continue;
12956  }
12957  if ((mask & NUM_SUFFIX_R) && c == 'r') {
12958  result |= (mask & NUM_SUFFIX_R);
12959  mask &= ~NUM_SUFFIX_R;
12960  continue;
12961  }
12962  if (!ISASCII(c) || ISALPHA(c) || c == '_') {
12963  lex_p = lastp;
12964  return 0;
12965  }
12966  pushback(c);
12967  break;
12968  }
12969  return result;
12970 }
12971 
12972 static int
12973 parser_set_number_literal(struct parser_params *parser, VALUE v, int type, int suffix)
12974 {
12975  if (suffix & NUM_SUFFIX_I) {
12976  v = rb_complex_raw(INT2FIX(0), v);
12977  type = tIMAGINARY;
12978  }
12979  set_yylval_literal(v);
12980  return type;
12981 }
12982 
12983 static int
12984 parser_set_integer_literal(struct parser_params *parser, VALUE v, int suffix)
12985 {
12986  int type = tINTEGER;
12987  if (suffix & NUM_SUFFIX_R) {
12988  v = rb_rational_raw1(v);
12989  type = tRATIONAL;
12990  }
12991  return set_number_literal(v, type, suffix);
12992 }
12993 
12994 #ifdef RIPPER
12995 static void
12996 ripper_dispatch_heredoc_end(struct parser_params *parser)
12997 {
12998  if (!NIL_P(parser->delayed))
12999  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
13000  lex_goto_eol(parser);
13001  ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
13002 }
13003 
13004 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
13005 #else
13006 #define dispatch_heredoc_end() ((void)0)
13007 #endif
13008 
13009 static int
13011 {
13012  int c, func, indent = 0;
13013  const char *eos, *p, *pend;
13014  long len;
13015  VALUE str = 0;
13017 
13018  eos = RSTRING_PTR(here->nd_lit);
13019  len = RSTRING_LEN(here->nd_lit) - 1;
13020  indent = (func = *eos++) & STR_FUNC_INDENT;
13021 
13022  if ((c = nextc()) == -1) {
13023  error:
13024  compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
13025 #ifdef RIPPER
13026  if (NIL_P(parser->delayed)) {
13027  ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
13028  }
13029  else {
13030  if (str ||
13031  ((len = lex_p - parser->tokp) > 0 &&
13032  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
13033  rb_str_append(parser->delayed, str);
13034  }
13035  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
13036  }
13037  lex_goto_eol(parser);
13038 #endif
13039  restore:
13041  return 0;
13042  }
13043  if (was_bol() && whole_match_p(eos, len, indent)) {
13046  return tSTRING_END;
13047  }
13048 
13049  if (!(func & STR_FUNC_EXPAND)) {
13050  do {
13052  pend = lex_pend;
13053  if (pend > p) {
13054  switch (pend[-1]) {
13055  case '\n':
13056  if (--pend == p || pend[-1] != '\r') {
13057  pend++;
13058  break;
13059  }
13060  case '\r':
13061  --pend;
13062  }
13063  }
13064  if (str)
13065  rb_str_cat(str, p, pend - p);
13066  else
13067  str = STR_NEW(p, pend - p);
13068  if (pend < lex_pend) rb_str_cat(str, "\n", 1);
13069  lex_goto_eol(parser);
13070  if (nextc() == -1) {
13071  if (str) {
13072  dispose_string(str);
13073  str = 0;
13074  }
13075  goto error;
13076  }
13077  } while (!whole_match_p(eos, len, indent));
13078  }
13079  else {
13080  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
13081  newtok();
13082  if (c == '#') {
13083  int t = parser_peek_variable_name(parser);
13084  if (t) return t;
13085  tokadd('#');
13086  c = nextc();
13087  }
13088  do {
13089  pushback(c);
13090  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
13091  if (parser->eofp) goto error;
13092  goto restore;
13093  }
13094  if (c != '\n') {
13097  return tSTRING_CONTENT;
13098  }
13099  tokadd(nextc());
13100  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
13101  if ((c = nextc()) == -1) goto error;
13102  } while (!whole_match_p(eos, len, indent));
13103  str = STR_NEW3(tok(), toklen(), enc, func);
13104  }
13107  lex_strterm = NEW_STRTERM(-1, 0, 0);
13108  set_yylval_str(str);
13109  return tSTRING_CONTENT;
13110 }
13111 
13112 #include "lex.c"
13113 
13114 static void
13116 {
13117 #ifndef RIPPER
13118  rb_warning0("ambiguous first argument; put parentheses or even spaces");
13119 #else
13120  dispatch0(arg_ambiguous);
13121 #endif
13122 }
13123 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
13124 
13125 static ID
13127 {
13128 #ifndef RIPPER
13129  if (!is_local_id(lhs))
13130  yyerror("formal argument must be local variable");
13131 #endif
13132  shadowing_lvar(lhs);
13133  return lhs;
13134 }
13135 
13136 static int
13137 lvar_defined_gen(struct parser_params *parser, ID id)
13138 {
13139  return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
13140 }
13141 
13142 /* emacsen -*- hack */
13143 static long
13144 parser_encode_length(struct parser_params *parser, const char *name, long len)
13145 {
13146  long nlen;
13147 
13148  if (len > 5 && name[nlen = len - 5] == '-') {
13149  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
13150  return nlen;
13151  }
13152  if (len > 4 && name[nlen = len - 4] == '-') {
13153  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
13154  return nlen;
13155  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
13156  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
13157  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
13158  return nlen;
13159  }
13160  return len;
13161 }
13162 
13163 static void
13164 parser_set_encode(struct parser_params *parser, const char *name)
13165 {
13166  int idx = rb_enc_find_index(name);
13167  rb_encoding *enc;
13168  VALUE excargs[3];
13169 
13170  if (idx < 0) {
13171  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
13172  error:
13173  excargs[0] = rb_eArgError;
13174  excargs[2] = rb_make_backtrace();
13175  rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
13176  rb_exc_raise(rb_make_exception(3, excargs));
13177  }
13178  enc = rb_enc_from_index(idx);
13179  if (!rb_enc_asciicompat(enc)) {
13180  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13181  goto error;
13182  }
13183  parser->enc = enc;
13184 #ifndef RIPPER
13185  if (ruby_debug_lines) {
13186  VALUE lines = ruby_debug_lines;
13187  long i, n = RARRAY_LEN(lines);
13188  for (i = 0; i < n; ++i) {
13189  rb_enc_associate_index(RARRAY_AREF(lines, i), idx);
13190  }
13191  }
13192 #endif
13193 }
13194 
13195 static int
13197 {
13198  const char *p = lex_pbeg, *pend = lex_p - 1;
13199  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13200  while (p < pend) {
13201  if (!ISSPACE(*p)) return 0;
13202  p++;
13203  }
13204  return 1;
13205 }
13206 
13207 #ifndef RIPPER
13208 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13209 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13210 
13211 static void
13212 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13213 {
13214  if (!comment_at_top(parser)) {
13215  return;
13216  }
13217  parser_set_encode(parser, val);
13218 }
13219 
13220 static void
13221 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13222 {
13223  int *p = &parser->parser_token_info_enabled;
13224 
13225  switch (*val) {
13226  case 't': case 'T':
13227  if (strcasecmp(val, "true") == 0) {
13228  *p = TRUE;
13229  return;
13230  }
13231  break;
13232  case 'f': case 'F':
13233  if (strcasecmp(val, "false") == 0) {
13234  *p = FALSE;
13235  return;
13236  }
13237  break;
13238  }
13239  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13240 }
13241 
13242 struct magic_comment {
13243  const char *name;
13246 };
13247 
13248 static const struct magic_comment magic_comments[] = {
13251  {"warn_indent", parser_set_token_info},
13252 };
13253 #endif
13254 
13255 static const char *
13256 magic_comment_marker(const char *str, long len)
13257 {
13258  long i = 2;
13259 
13260  while (i < len) {
13261  switch (str[i]) {
13262  case '-':
13263  if (str[i-1] == '*' && str[i-2] == '-') {
13264  return str + i + 1;
13265  }
13266  i += 2;
13267  break;
13268  case '*':
13269  if (i + 1 >= len) return 0;
13270  if (str[i+1] != '-') {
13271  i += 4;
13272  }
13273  else if (str[i-1] != '-') {
13274  i += 2;
13275  }
13276  else {
13277  return str + i + 2;
13278  }
13279  break;
13280  default:
13281  i += 3;
13282  break;
13283  }
13284  }
13285  return 0;
13286 }
13287 
13288 static int
13289 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13290 {
13291  VALUE name = 0, val = 0;
13292  const char *beg, *end, *vbeg, *vend;
13293 #define str_copy(_s, _p, _n) ((_s) \
13294  ? (void)(rb_str_resize((_s), (_n)), \
13295  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13296  : (void)((_s) = STR_NEW((_p), (_n))))
13297 
13298  if (len <= 7) return FALSE;
13299  if (!(beg = magic_comment_marker(str, len))) return FALSE;
13300  if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13301  str = beg;
13302  len = end - beg - 3;
13303 
13304  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13305  while (len > 0) {
13306 #ifndef RIPPER
13307  const struct magic_comment *p = magic_comments;
13308 #endif
13309  char *s;
13310  int i;
13311  long n = 0;
13312 
13313  for (; len > 0 && *str; str++, --len) {
13314  switch (*str) {
13315  case '\'': case '"': case ':': case ';':
13316  continue;
13317  }
13318  if (!ISSPACE(*str)) break;
13319  }
13320  for (beg = str; len > 0; str++, --len) {
13321  switch (*str) {
13322  case '\'': case '"': case ':': case ';':
13323  break;
13324  default:
13325  if (ISSPACE(*str)) break;
13326  continue;
13327  }
13328  break;
13329  }
13330  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13331  if (!len) break;
13332  if (*str != ':') continue;
13333 
13334  do str++; while (--len > 0 && ISSPACE(*str));
13335  if (!len) break;
13336  if (*str == '"') {
13337  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13338  if (*str == '\\') {
13339  --len;
13340  ++str;
13341  }
13342  }
13343  vend = str;
13344  if (len) {
13345  --len;
13346  ++str;
13347  }
13348  }
13349  else {
13350  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13351  vend = str;
13352  }
13353  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13354 
13355  n = end - beg;
13356  str_copy(name, beg, n);
13357  s = RSTRING_PTR(name);
13358  for (i = 0; i < n; ++i) {
13359  if (s[i] == '-') s[i] = '_';
13360  }
13361 #ifndef RIPPER
13362  do {
13363  if (STRNCASECMP(p->name, s, n) == 0) {
13364  n = vend - vbeg;
13365  if (p->length) {
13366  n = (*p->length)(parser, vbeg, n);
13367  }
13368  str_copy(val, vbeg, n);
13369  (*p->func)(parser, s, RSTRING_PTR(val));
13370  break;
13371  }
13372  } while (++p < magic_comments + numberof(magic_comments));
13373 #else
13374  str_copy(val, vbeg, vend - vbeg);
13375  dispatch2(magic_comment, name, val);
13376 #endif
13377  }
13378 
13379  return TRUE;
13380 }
13381 
13382 static void
13383 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13384 {
13385  int sep = 0;
13386  const char *beg = str;
13387  VALUE s;
13388 
13389  for (;;) {
13390  if (send - str <= 6) return;
13391  switch (str[6]) {
13392  case 'C': case 'c': str += 6; continue;
13393  case 'O': case 'o': str += 5; continue;
13394  case 'D': case 'd': str += 4; continue;
13395  case 'I': case 'i': str += 3; continue;
13396  case 'N': case 'n': str += 2; continue;
13397  case 'G': case 'g': str += 1; continue;
13398  case '=': case ':':
13399  sep = 1;
13400  str += 6;
13401  break;
13402  default:
13403  str += 6;
13404  if (ISSPACE(*str)) break;
13405  continue;
13406  }
13407  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13408  }
13409  for (;;) {
13410  do {
13411  if (++str >= send) return;
13412  } while (ISSPACE(*str));
13413  if (sep) break;
13414  if (*str != '=' && *str != ':') return;
13415  sep = 1;
13416  str++;
13417  }
13418  beg = str;
13419  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13420  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13421  parser_set_encode(parser, RSTRING_PTR(s));
13422  rb_str_resize(s, 0);
13423 }
13424 
13425 static void
13427 {
13428  int c = nextc();
13429  switch (c) {
13430  case '#':
13431  if (peek('!')) parser->has_shebang = 1;
13432  break;
13433  case 0xef: /* UTF-8 BOM marker */
13434  if (lex_pend - lex_p >= 2 &&
13435  (unsigned char)lex_p[0] == 0xbb &&
13436  (unsigned char)lex_p[1] == 0xbf) {
13437  parser->enc = rb_utf8_encoding();
13438  lex_p += 2;
13439  lex_pbeg = lex_p;
13440  return;
13441  }
13442  break;
13443  case EOF:
13444  return;
13445  }
13446  pushback(c);
13447  parser->enc = rb_enc_get(lex_lastline);
13448 }
13449 
13450 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13451 #define IS_END() IS_lex_state(EXPR_END_ANY)
13452 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13453 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13454 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13455 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13456 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13457 
13458 #ifndef RIPPER
13459 #define ambiguous_operator(op, syn) ( \
13460  rb_warning0("`"op"' after local variable or literal is interpreted as binary operator"), \
13461  rb_warning0("even though it seems like "syn""))
13462 #else
13463 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13464 #endif
13465 #define warn_balanced(op, syn) ((void) \
13466  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13467  space_seen && !ISSPACE(c) && \
13468  (ambiguous_operator(op, syn), 0)))
13469 
13470 static int
13472 {
13473  size_t len;
13474  int overflow;
13475  unsigned long n = ruby_scan_digits(tok()+1, toklen()-1, 10, &len, &overflow);
13476  const unsigned long nth_ref_max =
13477  ((FIXNUM_MAX < INT_MAX) ? FIXNUM_MAX : INT_MAX) >> 1;
13478  /* NTH_REF is left-shifted to be ORed with back-ref flag and
13479  * turned into a Fixnum, in compile.c */
13480 
13481  if (overflow || n > nth_ref_max) {
13482  /* compile_error()? */
13483  rb_warnS("`%s' is too big for a number variable, always nil", tok());
13484  return 0; /* $0 is $PROGRAM_NAME, not NTH_REF */
13485  }
13486  else {
13487  return (int)n;
13488  }
13489 }
13490 
13491 static int
13493 {
13494  register int c;
13495  int space_seen = 0;
13496  int cmd_state;
13497  enum lex_state_e last_state;
13498  rb_encoding *enc;
13499  int mb;
13500 #ifdef RIPPER
13501  int fallthru = FALSE;
13502 #endif
13503 
13504  if (lex_strterm) {
13505  int token;
13506  if (nd_type(lex_strterm) == NODE_HEREDOC) {
13508  if (token == tSTRING_END) {
13509  lex_strterm = 0;
13510  lex_state = EXPR_END;
13511  }
13512  }
13513  else {
13515  if (token == tSTRING_END || token == tREGEXP_END) {
13517  lex_strterm = 0;
13518  lex_state = EXPR_END;
13519  }
13520  }
13521  return token;
13522  }
13523  cmd_state = command_start;
13524  command_start = FALSE;
13525  retry:
13526  last_state = lex_state;
13527  switch (c = nextc()) {
13528  case '\0': /* NUL */
13529  case '\004': /* ^D */
13530  case '\032': /* ^Z */
13531  case -1: /* end of script. */
13532  return 0;
13533 
13534  /* white spaces */
13535  case ' ': case '\t': case '\f': case '\r':
13536  case '\13': /* '\v' */
13537  space_seen = 1;
13538 #ifdef RIPPER
13539  while ((c = nextc())) {
13540  switch (c) {
13541  case ' ': case '\t': case '\f': case '\r':
13542  case '\13': /* '\v' */
13543  break;
13544  default:
13545  goto outofloop;
13546  }
13547  }
13548  outofloop:
13549  pushback(c);
13550  ripper_dispatch_scan_event(parser, tSP);
13551 #endif
13552  goto retry;
13553 
13554  case '#': /* it's a comment */
13555  /* no magic_comment in shebang line */
13556  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13557  if (comment_at_top(parser)) {
13558  set_file_encoding(parser, lex_p, lex_pend);
13559  }
13560  }
13561  lex_p = lex_pend;
13562 #ifdef RIPPER
13563  ripper_dispatch_scan_event(parser, tCOMMENT);
13564  fallthru = TRUE;
13565 #endif
13566  /* fall through */
13567  case '\n':
13568  if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT | EXPR_LABELARG)) {
13569 #ifdef RIPPER
13570  if (!fallthru) {
13571  ripper_dispatch_scan_event(parser, tIGNORED_NL);
13572  }
13573  fallthru = FALSE;
13574 #endif
13575  if (IS_lex_state(EXPR_LABELARG) && parser->parser_in_kwarg) {
13576  goto normal_newline;
13577  }
13578  goto retry;
13579  }
13580  while ((c = nextc())) {
13581  switch (c) {
13582  case ' ': case '\t': case '\f': case '\r':
13583  case '\13': /* '\v' */
13584  space_seen = 1;
13585  break;
13586  case '.': {
13587  if ((c = nextc()) != '.') {
13588  pushback(c);
13589  pushback('.');
13590  goto retry;
13591  }
13592  }
13593  default:
13594  --ruby_sourceline;
13596  case -1: /* EOF no decrement*/
13597  lex_goto_eol(parser);
13598 #ifdef RIPPER
13599  if (c != -1) {
13600  parser->tokp = lex_p;
13601  }
13602 #endif
13603  goto normal_newline;
13604  }
13605  }
13606  normal_newline:
13607  command_start = TRUE;
13608  lex_state = EXPR_BEG;
13609  return '\n';
13610 
13611  case '*':
13612  if ((c = nextc()) == '*') {
13613  if ((c = nextc()) == '=') {
13615  lex_state = EXPR_BEG;
13616  return tOP_ASGN;
13617  }
13618  pushback(c);
13619  if (IS_SPCARG(c)) {
13620  rb_warning0("`**' interpreted as argument prefix");
13621  c = tDSTAR;
13622  }
13623  else if (IS_BEG()) {
13624  c = tDSTAR;
13625  }
13626  else {
13627  warn_balanced("**", "argument prefix");
13628  c = tPOW;
13629  }
13630  }
13631  else {
13632  if (c == '=') {
13633  set_yylval_id('*');
13634  lex_state = EXPR_BEG;
13635  return tOP_ASGN;
13636  }
13637  pushback(c);
13638  if (IS_SPCARG(c)) {
13639  rb_warning0("`*' interpreted as argument prefix");
13640  c = tSTAR;
13641  }
13642  else if (IS_BEG()) {
13643  c = tSTAR;
13644  }
13645  else {
13646  warn_balanced("*", "argument prefix");
13647  c = '*';
13648  }
13649  }
13650  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13651  return c;
13652 
13653  case '!':
13654  c = nextc();
13655  if (IS_AFTER_OPERATOR()) {
13656  lex_state = EXPR_ARG;
13657  if (c == '@') {
13658  return '!';
13659  }
13660  }
13661  else {
13662  lex_state = EXPR_BEG;
13663  }
13664  if (c == '=') {
13665  return tNEQ;
13666  }
13667  if (c == '~') {
13668  return tNMATCH;
13669  }
13670  pushback(c);
13671  return '!';
13672 
13673  case '=':
13674  if (was_bol()) {
13675  /* skip embedded rd document */
13676  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13677 #ifdef RIPPER
13678  int first_p = TRUE;
13679 
13680  lex_goto_eol(parser);
13681  ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13682 #endif
13683  for (;;) {
13684  lex_goto_eol(parser);
13685 #ifdef RIPPER
13686  if (!first_p) {
13687  ripper_dispatch_scan_event(parser, tEMBDOC);
13688  }
13689  first_p = FALSE;
13690 #endif
13691  c = nextc();
13692  if (c == -1) {
13693  compile_error(PARSER_ARG "embedded document meets end of file");
13694  return 0;
13695  }
13696  if (c != '=') continue;
13697  if (strncmp(lex_p, "end", 3) == 0 &&
13698  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13699  break;
13700  }
13701  }
13702  lex_goto_eol(parser);
13703 #ifdef RIPPER
13704  ripper_dispatch_scan_event(parser, tEMBDOC_END);
13705 #endif
13706  goto retry;
13707  }
13708  }
13709 
13710  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13711  if ((c = nextc()) == '=') {
13712  if ((c = nextc()) == '=') {
13713  return tEQQ;
13714  }
13715  pushback(c);
13716  return tEQ;
13717  }
13718  if (c == '~') {
13719  return tMATCH;
13720  }
13721  else if (c == '>') {
13722  return tASSOC;
13723  }
13724  pushback(c);
13725  return '=';
13726 
13727  case '<':
13728  last_state = lex_state;
13729  c = nextc();
13730  if (c == '<' &&
13731  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13732  !IS_END() &&
13733  (!IS_ARG() || space_seen)) {
13734  int token = heredoc_identifier();
13735  if (token) return token;
13736  }
13737  if (IS_AFTER_OPERATOR()) {
13738  lex_state = EXPR_ARG;
13739  }
13740  else {
13741  if (IS_lex_state(EXPR_CLASS))
13742  command_start = TRUE;
13743  lex_state = EXPR_BEG;
13744  }
13745  if (c == '=') {
13746  if ((c = nextc()) == '>') {
13747  return tCMP;
13748  }
13749  pushback(c);
13750  return tLEQ;
13751  }
13752  if (c == '<') {
13753  if ((c = nextc()) == '=') {
13755  lex_state = EXPR_BEG;
13756  return tOP_ASGN;
13757  }
13758  pushback(c);
13759  warn_balanced("<<", "here document");
13760  return tLSHFT;
13761  }
13762  pushback(c);
13763  return '<';
13764 
13765  case '>':
13766  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13767  if ((c = nextc()) == '=') {
13768  return tGEQ;
13769  }
13770  if (c == '>') {
13771  if ((c = nextc()) == '=') {
13773  lex_state = EXPR_BEG;
13774  return tOP_ASGN;
13775  }
13776  pushback(c);
13777  return tRSHFT;
13778  }
13779  pushback(c);
13780  return '>';
13781 
13782  case '"':
13783  lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13784  return tSTRING_BEG;
13785 
13786  case '`':
13787  if (IS_lex_state(EXPR_FNAME)) {
13788  lex_state = EXPR_ENDFN;
13789  return c;
13790  }
13791  if (IS_lex_state(EXPR_DOT)) {
13792  if (cmd_state)
13793  lex_state = EXPR_CMDARG;
13794  else
13795  lex_state = EXPR_ARG;
13796  return c;
13797  }
13798  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13799  return tXSTRING_BEG;
13800 
13801  case '\'':
13802  lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13803  return tSTRING_BEG;
13804 
13805  case '?':
13806  if (IS_END()) {
13807  lex_state = EXPR_VALUE;
13808  return '?';
13809  }
13810  c = nextc();
13811  if (c == -1) {
13812  compile_error(PARSER_ARG "incomplete character syntax");
13813  return 0;
13814  }
13815  if (rb_enc_isspace(c, current_enc)) {
13816  if (!IS_ARG()) {
13817  int c2 = 0;
13818  switch (c) {
13819  case ' ':
13820  c2 = 's';
13821  break;
13822  case '\n':
13823  c2 = 'n';
13824  break;
13825  case '\t':
13826  c2 = 't';
13827  break;
13828  case '\v':
13829  c2 = 'v';
13830  break;
13831  case '\r':
13832  c2 = 'r';
13833  break;
13834  case '\f':
13835  c2 = 'f';
13836  break;
13837  }
13838  if (c2) {
13839  rb_warnI("invalid character syntax; use ?\\%c", c2);
13840  }
13841  }
13842  ternary:
13843  pushback(c);
13844  lex_state = EXPR_VALUE;
13845  return '?';
13846  }
13847  newtok();
13848  enc = current_enc;
13849  if (!parser_isascii()) {
13850  if (tokadd_mbchar(c) == -1) return 0;
13851  }
13852  else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13854  goto ternary;
13855  }
13856  else if (c == '\\') {
13857  if (peek('u')) {
13858  nextc();
13859  c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13860  if (0x80 <= c) {
13861  tokaddmbc(c, enc);
13862  }
13863  else {
13864  tokadd(c);
13865  }
13866  }
13867  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13868  nextc();
13869  if (tokadd_mbchar(c) == -1) return 0;
13870  }
13871  else {
13872  c = read_escape(0, &enc);
13873  tokadd(c);
13874  }
13875  }
13876  else {
13877  tokadd(c);
13878  }
13879  tokfix();
13880  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13881  lex_state = EXPR_END;
13882  return tCHAR;
13883 
13884  case '&':
13885  if ((c = nextc()) == '&') {
13886  lex_state = EXPR_BEG;
13887  if ((c = nextc()) == '=') {
13889  lex_state = EXPR_BEG;
13890  return tOP_ASGN;
13891  }
13892  pushback(c);
13893  return tANDOP;
13894  }
13895  else if (c == '=') {
13896  set_yylval_id('&');
13897  lex_state = EXPR_BEG;
13898  return tOP_ASGN;
13899  }
13900  pushback(c);
13901  if (IS_SPCARG(c)) {
13902  rb_warning0("`&' interpreted as argument prefix");
13903  c = tAMPER;
13904  }
13905  else if (IS_BEG()) {
13906  c = tAMPER;
13907  }
13908  else {
13909  warn_balanced("&", "argument prefix");
13910  c = '&';
13911  }
13912  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13913  return c;
13914 
13915  case '|':
13916  if ((c = nextc()) == '|') {
13917  lex_state = EXPR_BEG;
13918  if ((c = nextc()) == '=') {
13920  lex_state = EXPR_BEG;
13921  return tOP_ASGN;
13922  }
13923  pushback(c);
13924  return tOROP;
13925  }
13926  if (c == '=') {
13927  set_yylval_id('|');
13928  lex_state = EXPR_BEG;
13929  return tOP_ASGN;
13930  }
13931  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13932  pushback(c);
13933  return '|';
13934 
13935  case '+':
13936  c = nextc();
13937  if (IS_AFTER_OPERATOR()) {
13938  lex_state = EXPR_ARG;
13939  if (c == '@') {
13940  return tUPLUS;
13941  }
13942  pushback(c);
13943  return '+';
13944  }
13945  if (c == '=') {
13946  set_yylval_id('+');
13947  lex_state = EXPR_BEG;
13948  return tOP_ASGN;
13949  }
13950  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13951  lex_state = EXPR_BEG;
13952  pushback(c);
13953  if (c != -1 && ISDIGIT(c)) {
13954  c = '+';
13955  goto start_num;
13956  }
13957  return tUPLUS;
13958  }
13959  lex_state = EXPR_BEG;
13960  pushback(c);
13961  warn_balanced("+", "unary operator");
13962  return '+';
13963 
13964  case '-':
13965  c = nextc();
13966  if (IS_AFTER_OPERATOR()) {
13967  lex_state = EXPR_ARG;
13968  if (c == '@') {
13969  return tUMINUS;
13970  }
13971  pushback(c);
13972  return '-';
13973  }
13974  if (c == '=') {
13975  set_yylval_id('-');
13976  lex_state = EXPR_BEG;
13977  return tOP_ASGN;
13978  }
13979  if (c == '>') {
13980  lex_state = EXPR_ENDFN;
13981  return tLAMBDA;
13982  }
13983  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13984  lex_state = EXPR_BEG;
13985  pushback(c);
13986  if (c != -1 && ISDIGIT(c)) {
13987  return tUMINUS_NUM;
13988  }
13989  return tUMINUS;
13990  }
13991  lex_state = EXPR_BEG;
13992  pushback(c);
13993  warn_balanced("-", "unary operator");
13994  return '-';
13995 
13996  case '.':
13997  lex_state = EXPR_BEG;
13998  if ((c = nextc()) == '.') {
13999  if ((c = nextc()) == '.') {
14000  return tDOT3;
14001  }
14002  pushback(c);
14003  return tDOT2;
14004  }
14005  pushback(c);
14006  if (c != -1 && ISDIGIT(c)) {
14007  yyerror("no .<digit> floating literal anymore; put 0 before dot");
14008  }
14009  lex_state = EXPR_DOT;
14010  return '.';
14011 
14012  start_num:
14013  case '0': case '1': case '2': case '3': case '4':
14014  case '5': case '6': case '7': case '8': case '9':
14015  {
14016  int is_float, seen_point, seen_e, nondigit;
14017  int suffix;
14018 
14019  is_float = seen_point = seen_e = nondigit = 0;
14020  lex_state = EXPR_END;
14021  newtok();
14022  if (c == '-' || c == '+') {
14023  tokadd(c);
14024  c = nextc();
14025  }
14026  if (c == '0') {
14027 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
14028  int start = toklen();
14029  c = nextc();
14030  if (c == 'x' || c == 'X') {
14031  /* hexadecimal */
14032  c = nextc();
14033  if (c != -1 && ISXDIGIT(c)) {
14034  do {
14035  if (c == '_') {
14036  if (nondigit) break;
14037  nondigit = c;
14038  continue;
14039  }
14040  if (!ISXDIGIT(c)) break;
14041  nondigit = 0;
14042  tokadd(c);
14043  } while ((c = nextc()) != -1);
14044  }
14045  pushback(c);
14046  tokfix();
14047  if (toklen() == start) {
14048  no_digits();
14049  }
14050  else if (nondigit) goto trailing_uc;
14052  return set_integer_literal(rb_cstr_to_inum(tok(), 16, FALSE), suffix);
14053  }
14054  if (c == 'b' || c == 'B') {
14055  /* binary */
14056  c = nextc();
14057  if (c == '0' || c == '1') {
14058  do {
14059  if (c == '_') {
14060  if (nondigit) break;
14061  nondigit = c;
14062  continue;
14063  }
14064  if (c != '0' && c != '1') break;
14065  nondigit = 0;
14066  tokadd(c);
14067  } while ((c = nextc()) != -1);
14068  }
14069  pushback(c);
14070  tokfix();
14071  if (toklen() == start) {
14072  no_digits();
14073  }
14074  else if (nondigit) goto trailing_uc;
14076  return set_integer_literal(rb_cstr_to_inum(tok(), 2, FALSE), suffix);
14077  }
14078  if (c == 'd' || c == 'D') {
14079  /* decimal */
14080  c = nextc();
14081  if (c != -1 && ISDIGIT(c)) {
14082  do {
14083  if (c == '_') {
14084  if (nondigit) break;
14085  nondigit = c;
14086  continue;
14087  }
14088  if (!ISDIGIT(c)) break;
14089  nondigit = 0;
14090  tokadd(c);
14091  } while ((c = nextc()) != -1);
14092  }
14093  pushback(c);
14094  tokfix();
14095  if (toklen() == start) {
14096  no_digits();
14097  }
14098  else if (nondigit) goto trailing_uc;
14100  return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
14101  }
14102  if (c == '_') {
14103  /* 0_0 */
14104  goto octal_number;
14105  }
14106  if (c == 'o' || c == 'O') {
14107  /* prefixed octal */
14108  c = nextc();
14109  if (c == -1 || c == '_' || !ISDIGIT(c)) {
14110  no_digits();
14111  }
14112  }
14113  if (c >= '0' && c <= '7') {
14114  /* octal */
14115  octal_number:
14116  do {
14117  if (c == '_') {
14118  if (nondigit) break;
14119  nondigit = c;
14120  continue;
14121  }
14122  if (c < '0' || c > '9') break;
14123  if (c > '7') goto invalid_octal;
14124  nondigit = 0;
14125  tokadd(c);
14126  } while ((c = nextc()) != -1);
14127  if (toklen() > start) {
14128  pushback(c);
14129  tokfix();
14130  if (nondigit) goto trailing_uc;
14132  return set_integer_literal(rb_cstr_to_inum(tok(), 8, FALSE), suffix);
14133  }
14134  if (nondigit) {
14135  pushback(c);
14136  goto trailing_uc;
14137  }
14138  }
14139  if (c > '7' && c <= '9') {
14140  invalid_octal:
14141  yyerror("Invalid octal digit");
14142  }
14143  else if (c == '.' || c == 'e' || c == 'E') {
14144  tokadd('0');
14145  }
14146  else {
14147  pushback(c);
14149  return set_integer_literal(INT2FIX(0), suffix);
14150  }
14151  }
14152 
14153  for (;;) {
14154  switch (c) {
14155  case '0': case '1': case '2': case '3': case '4':
14156  case '5': case '6': case '7': case '8': case '9':
14157  nondigit = 0;
14158  tokadd(c);
14159  break;
14160 
14161  case '.':
14162  if (nondigit) goto trailing_uc;
14163  if (seen_point || seen_e) {
14164  goto decode_num;
14165  }
14166  else {
14167  int c0 = nextc();
14168  if (c0 == -1 || !ISDIGIT(c0)) {
14169  pushback(c0);
14170  goto decode_num;
14171  }
14172  c = c0;
14173  }
14174  seen_point = toklen();
14175  tokadd('.');
14176  tokadd(c);
14177  is_float++;
14178  nondigit = 0;
14179  break;
14180 
14181  case 'e':
14182  case 'E':
14183  if (nondigit) {
14184  pushback(c);
14185  c = nondigit;
14186  goto decode_num;
14187  }
14188  if (seen_e) {
14189  goto decode_num;
14190  }
14191  nondigit = c;
14192  c = nextc();
14193  if (c != '-' && c != '+' && !ISDIGIT(c)) {
14194  pushback(c);
14195  nondigit = 0;
14196  goto decode_num;
14197  }
14198  tokadd(nondigit);
14199  seen_e++;
14200  is_float++;
14201  tokadd(c);
14202  nondigit = (c == '-' || c == '+') ? c : 0;
14203  break;
14204 
14205  case '_': /* `_' in number just ignored */
14206  if (nondigit) goto decode_num;
14207  nondigit = c;
14208  break;
14209 
14210  default:
14211  goto decode_num;
14212  }
14213  c = nextc();
14214  }
14215 
14216  decode_num:
14217  pushback(c);
14218  if (nondigit) {
14219  char tmp[30];
14220  trailing_uc:
14221  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14222  yyerror(tmp);
14223  }
14224  tokfix();
14225  if (is_float) {
14226  int type = tFLOAT;
14227  VALUE v;
14228 
14229  suffix = number_literal_suffix(seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
14230  if (suffix & NUM_SUFFIX_R) {
14231  char *point = &tok()[seen_point];
14232  size_t fraclen = toklen()-seen_point-1;
14233  type = tRATIONAL;
14234  memmove(point, point+1, fraclen+1);
14235  v = rb_cstr_to_inum(tok(), 10, FALSE);
14236  v = rb_rational_new(v, rb_int_positive_pow(10, fraclen));
14237  }
14238  else {
14239  double d = strtod(tok(), 0);
14240  if (errno == ERANGE) {
14241  rb_warningS("Float %s out of range", tok());
14242  errno = 0;
14243  }
14244  v = DBL2NUM(d);
14245  }
14246  return set_number_literal(v, type, suffix);
14247  }
14249  return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
14250  }
14251 
14252  case ')':
14253  case ']':
14254  paren_nest--;
14255  case '}':
14256  COND_LEXPOP();
14257  CMDARG_LEXPOP();
14258  if (c == ')')
14259  lex_state = EXPR_ENDFN;
14260  else
14261  lex_state = EXPR_ENDARG;
14262  if (c == '}') {
14263  if (!brace_nest--) c = tSTRING_DEND;
14264  }
14265  return c;
14266 
14267  case ':':
14268  c = nextc();
14269  if (c == ':') {
14270  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14271  lex_state = EXPR_BEG;
14272  return tCOLON3;
14273  }
14274  lex_state = EXPR_DOT;
14275  return tCOLON2;
14276  }
14277  if (IS_END() || ISSPACE(c)) {
14278  pushback(c);
14279  warn_balanced(":", "symbol literal");
14280  lex_state = EXPR_BEG;
14281  return ':';
14282  }
14283  switch (c) {
14284  case '\'':
14285  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14286  break;
14287  case '"':
14288  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14289  break;
14290  default:
14291  pushback(c);
14292  break;
14293  }
14294  lex_state = EXPR_FNAME;
14295  return tSYMBEG;
14296 
14297  case '/':
14298  if (IS_lex_state(EXPR_BEG_ANY)) {
14299  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14300  return tREGEXP_BEG;
14301  }
14302  if ((c = nextc()) == '=') {
14303  set_yylval_id('/');
14304  lex_state = EXPR_BEG;
14305  return tOP_ASGN;
14306  }
14307  pushback(c);
14308  if (IS_SPCARG(c)) {
14309  (void)arg_ambiguous();
14310  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14311  return tREGEXP_BEG;
14312  }
14313  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14314  warn_balanced("/", "regexp literal");
14315  return '/';
14316 
14317  case '^':
14318  if ((c = nextc()) == '=') {
14319  set_yylval_id('^');
14320  lex_state = EXPR_BEG;
14321  return tOP_ASGN;
14322  }
14323  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14324  pushback(c);
14325  return '^';
14326 
14327  case ';':
14328  lex_state = EXPR_BEG;
14329  command_start = TRUE;
14330  return ';';
14331 
14332  case ',':
14333  lex_state = EXPR_BEG;
14334  return ',';
14335 
14336  case '~':
14337  if (IS_AFTER_OPERATOR()) {
14338  if ((c = nextc()) != '@') {
14339  pushback(c);
14340  }
14341  lex_state = EXPR_ARG;
14342  }
14343  else {
14344  lex_state = EXPR_BEG;
14345  }
14346  return '~';
14347 
14348  case '(':
14349  if (IS_BEG()) {
14350  c = tLPAREN;
14351  }
14352  else if (IS_SPCARG(-1)) {
14353  c = tLPAREN_ARG;
14354  }
14355  paren_nest++;
14356  COND_PUSH(0);
14357  CMDARG_PUSH(0);
14358  lex_state = EXPR_BEG;
14359  return c;
14360 
14361  case '[':
14362  paren_nest++;
14363  if (IS_AFTER_OPERATOR()) {
14364  lex_state = EXPR_ARG;
14365  if ((c = nextc()) == ']') {
14366  if ((c = nextc()) == '=') {
14367  return tASET;
14368  }
14369  pushback(c);
14370  return tAREF;
14371  }
14372  pushback(c);
14373  return '[';
14374  }
14375  else if (IS_BEG()) {
14376  c = tLBRACK;
14377  }
14378  else if (IS_ARG() && space_seen) {
14379  c = tLBRACK;
14380  }
14381  lex_state = EXPR_BEG;
14382  COND_PUSH(0);
14383  CMDARG_PUSH(0);
14384  return c;
14385 
14386  case '{':
14387  ++brace_nest;
14388  if (lpar_beg && lpar_beg == paren_nest) {
14389  lex_state = EXPR_BEG;
14390  lpar_beg = 0;
14391  --paren_nest;
14392  COND_PUSH(0);
14393  CMDARG_PUSH(0);
14394  return tLAMBEG;
14395  }
14396  if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14397  c = '{'; /* block (primary) */
14398  else if (IS_lex_state(EXPR_ENDARG))
14399  c = tLBRACE_ARG; /* block (expr) */
14400  else
14401  c = tLBRACE; /* hash */
14402  COND_PUSH(0);
14403  CMDARG_PUSH(0);
14404  lex_state = EXPR_BEG;
14405  if (c != tLBRACE) command_start = TRUE;
14406  return c;
14407 
14408  case '\\':
14409  c = nextc();
14410  if (c == '\n') {
14411  space_seen = 1;
14412 #ifdef RIPPER
14413  ripper_dispatch_scan_event(parser, tSP);
14414 #endif
14415  goto retry; /* skip \\n */
14416  }
14417  pushback(c);
14418  return '\\';
14419 
14420  case '%':
14421  if (IS_lex_state(EXPR_BEG_ANY)) {
14422  int term;
14423  int paren;
14424 
14425  c = nextc();
14426  quotation:
14427  if (c == -1 || !ISALNUM(c)) {
14428  term = c;
14429  c = 'Q';
14430  }
14431  else {
14432  term = nextc();
14433  if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14434  yyerror("unknown type of %string");
14435  return 0;
14436  }
14437  }
14438  if (c == -1 || term == -1) {
14439  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14440  return 0;
14441  }
14442  paren = term;
14443  if (term == '(') term = ')';
14444  else if (term == '[') term = ']';
14445  else if (term == '{') term = '}';
14446  else if (term == '<') term = '>';
14447  else paren = 0;
14448 
14449  switch (c) {
14450  case 'Q':
14451  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14452  return tSTRING_BEG;
14453 
14454  case 'q':
14455  lex_strterm = NEW_STRTERM(str_squote, term, paren);
14456  return tSTRING_BEG;
14457 
14458  case 'W':
14459  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14460  do {c = nextc();} while (ISSPACE(c));
14461  pushback(c);
14462  return tWORDS_BEG;
14463 
14464  case 'w':
14465  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14466  do {c = nextc();} while (ISSPACE(c));
14467  pushback(c);
14468  return tQWORDS_BEG;
14469 
14470  case 'I':
14471  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14472  do {c = nextc();} while (ISSPACE(c));
14473  pushback(c);
14474  return tSYMBOLS_BEG;
14475 
14476  case 'i':
14477  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14478  do {c = nextc();} while (ISSPACE(c));
14479  pushback(c);
14480  return tQSYMBOLS_BEG;
14481 
14482  case 'x':
14483  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14484  return tXSTRING_BEG;
14485 
14486  case 'r':
14487  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14488  return tREGEXP_BEG;
14489 
14490  case 's':
14491  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14492  lex_state = EXPR_FNAME;
14493  return tSYMBEG;
14494 
14495  default:
14496  yyerror("unknown type of %string");
14497  return 0;
14498  }
14499  }
14500  if ((c = nextc()) == '=') {
14501  set_yylval_id('%');
14502  lex_state = EXPR_BEG;
14503  return tOP_ASGN;
14504  }
14505  if (IS_SPCARG(c)) {
14506  goto quotation;
14507  }
14508  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14509  pushback(c);
14510  warn_balanced("%%", "string literal");
14511  return '%';
14512 
14513  case '$':
14514  lex_state = EXPR_END;
14515  newtok();
14516  c = nextc();
14517  switch (c) {
14518  case '_': /* $_: last read line string */
14519  c = nextc();
14520  if (parser_is_identchar()) {
14521  tokadd('$');
14522  tokadd('_');
14523  break;
14524  }
14525  pushback(c);
14526  c = '_';
14527  /* fall through */
14528  case '~': /* $~: match-data */
14529  case '*': /* $*: argv */
14530  case '$': /* $$: pid */
14531  case '?': /* $?: last status */
14532  case '!': /* $!: error string */
14533  case '@': /* $@: error position */
14534  case '/': /* $/: input record separator */
14535  case '\\': /* $\: output record separator */
14536  case ';': /* $;: field separator */
14537  case ',': /* $,: output field separator */
14538  case '.': /* $.: last read line number */
14539  case '=': /* $=: ignorecase */
14540  case ':': /* $:: load path */
14541  case '<': /* $<: reading filename */
14542  case '>': /* $>: default output handle */
14543  case '\"': /* $": already loaded files */
14544  tokadd('$');
14545  tokadd(c);
14546  goto gvar;
14547 
14548  case '-':
14549  tokadd('$');
14550  tokadd(c);
14551  c = nextc();
14552  if (parser_is_identchar()) {
14553  if (tokadd_mbchar(c) == -1) return 0;
14554  }
14555  else {
14556  pushback(c);
14557  pushback('-');
14558  return '$';
14559  }
14560  gvar:
14562  return tGVAR;
14563 
14564  case '&': /* $&: last match */
14565  case '`': /* $`: string before last match */
14566  case '\'': /* $': string after last match */
14567  case '+': /* $+: string matches last paren. */
14568  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14569  tokadd('$');
14570  tokadd(c);
14571  goto gvar;
14572  }
14574  return tBACK_REF;
14575 
14576  case '1': case '2': case '3':
14577  case '4': case '5': case '6':
14578  case '7': case '8': case '9':
14579  tokadd('$');
14580  do {
14581  tokadd(c);
14582  c = nextc();
14583  } while (c != -1 && ISDIGIT(c));
14584  pushback(c);
14585  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14586  tokfix();
14588  return tNTH_REF;
14589 
14590  default:
14591  if (!parser_is_identchar()) {
14592  pushback(c);
14593  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14594  return 0;
14595  }
14596  case '0':
14597  tokadd('$');
14598  }
14599  break;
14600 
14601  case '@':
14602  c = nextc();
14603  newtok();
14604  tokadd('@');
14605  if (c == '@') {
14606  tokadd('@');
14607  c = nextc();
14608  }
14609  if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14610  pushback(c);
14611  if (tokidx == 1) {
14612  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14613  }
14614  else {
14615  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14616  }
14617  return 0;
14618  }
14619  break;
14620 
14621  case '_':
14622  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14623  ruby__end__seen = 1;
14624  parser->eofp = Qtrue;
14625 #ifndef RIPPER
14626  return -1;
14627 #else
14628  lex_goto_eol(parser);
14629  ripper_dispatch_scan_event(parser, k__END__);
14630  return 0;
14631 #endif
14632  }
14633  newtok();
14634  break;
14635 
14636  default:
14637  if (!parser_is_identchar()) {
14638  compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14639  goto retry;
14640  }
14641 
14642  newtok();
14643  break;
14644  }
14645 
14646  mb = ENC_CODERANGE_7BIT;
14647  do {
14648  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14649  if (tokadd_mbchar(c) == -1) return 0;
14650  c = nextc();
14651  } while (parser_is_identchar());
14652  switch (tok()[0]) {
14653  case '@': case '$':
14654  pushback(c);
14655  break;
14656  default:
14657  if ((c == '!' || c == '?') && !peek('=')) {
14658  tokadd(c);
14659  }
14660  else {
14661  pushback(c);
14662  }
14663  }
14664  tokfix();
14665 
14666  {
14667  int result = 0;
14668 
14669  last_state = lex_state;
14670  switch (tok()[0]) {
14671  case '$':
14672  lex_state = EXPR_END;
14673  result = tGVAR;
14674  break;
14675  case '@':
14676  lex_state = EXPR_END;
14677  if (tok()[1] == '@')
14678  result = tCVAR;
14679  else
14680  result = tIVAR;
14681  break;
14682 
14683  default:
14684  if (toklast() == '!' || toklast() == '?') {
14685  result = tFID;
14686  }
14687  else {
14688  if (IS_lex_state(EXPR_FNAME)) {
14689  if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14690  (!peek('=') || (peek_n('>', 1)))) {
14691  result = tIDENTIFIER;
14692  tokadd(c);
14693  tokfix();
14694  }
14695  else {
14696  pushback(c);
14697  }
14698  }
14699  if (result == 0 && ISUPPER(tok()[0])) {
14700  result = tCONSTANT;
14701  }
14702  else {
14703  result = tIDENTIFIER;
14704  }
14705  }
14706 
14707  if (IS_LABEL_POSSIBLE()) {
14708  if (IS_LABEL_SUFFIX(0)) {
14709  lex_state = EXPR_LABELARG;
14710  nextc();
14712  return tLABEL;
14713  }
14714  }
14715  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14716  const struct kwtable *kw;
14717 
14718  /* See if it is a reserved word. */
14719  kw = rb_reserved_word(tok(), toklen());
14720  if (kw) {
14721  enum lex_state_e state = lex_state;
14722  lex_state = kw->state;
14723  if (IS_lex_state_for(state, EXPR_FNAME)) {
14725  return kw->id[0];
14726  }
14727  if (IS_lex_state(EXPR_BEG)) {
14728  command_start = TRUE;
14729  }
14730  if (kw->id[0] == keyword_do) {
14731  if (lpar_beg && lpar_beg == paren_nest) {
14732  lpar_beg = 0;
14733  --paren_nest;
14734  return keyword_do_LAMBDA;
14735  }
14736  if (COND_P()) return keyword_do_cond;
14737  if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG))
14738  return keyword_do_block;
14739  if (IS_lex_state_for(state, (EXPR_BEG | EXPR_ENDARG)))
14740  return keyword_do_block;
14741  return keyword_do;
14742  }
14743  if (IS_lex_state_for(state, (EXPR_BEG | EXPR_VALUE | EXPR_LABELARG)))
14744  return kw->id[0];
14745  else {
14746  if (kw->id[0] != kw->id[1])
14747  lex_state = EXPR_BEG;
14748  return kw->id[1];
14749  }
14750  }
14751  }
14752 
14753  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14754  if (cmd_state) {
14755  lex_state = EXPR_CMDARG;
14756  }
14757  else {
14758  lex_state = EXPR_ARG;
14759  }
14760  }
14761  else if (lex_state == EXPR_FNAME) {
14762  lex_state = EXPR_ENDFN;
14763  }
14764  else {
14765  lex_state = EXPR_END;
14766  }
14767  }
14768  {
14769  ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14770 
14771  set_yylval_name(ident);
14772  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14773  is_local_id(ident) && lvar_defined(ident)) {
14774  lex_state = EXPR_END;
14775  }
14776  }
14777  return result;
14778  }
14779 }
14780 
14781 #if YYPURE
14782 static int
14783 yylex(void *lval, void *p)
14784 #else
14785 yylex(void *p)
14786 #endif
14787 {
14788  struct parser_params *parser = (struct parser_params*)p;
14789  int t;
14790 
14791 #if YYPURE
14792  parser->parser_yylval = lval;
14793  parser->parser_yylval->val = Qundef;
14794 #endif
14795  t = parser_yylex(parser);
14796 #ifdef RIPPER
14797  if (!NIL_P(parser->delayed)) {
14798  ripper_dispatch_delayed_token(parser, t);
14799  return t;
14800  }
14801  if (t != 0)
14802  ripper_dispatch_scan_event(parser, t);
14803 #endif
14804 
14805  return t;
14806 }
14807 
14808 #ifndef RIPPER
14809 static NODE*
14810 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14811 {
14812  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14814  return n;
14815 }
14816 
14817 static enum node_type
14818 nodetype(NODE *node) /* for debug */
14819 {
14820  return (enum node_type)nd_type(node);
14821 }
14822 
14823 static int
14825 {
14826  return nd_line(node);
14827 }
14828 
14829 static NODE*
14831 {
14832  if (node) {
14833  node = remove_begin(node);
14834  node->flags |= NODE_FL_NEWLINE;
14835  }
14836  return node;
14837 }
14838 
14839 static void
14840 fixpos(NODE *node, NODE *orig)
14841 {
14842  if (!node) return;
14843  if (!orig) return;
14844  if (orig == (NODE*)1) return;
14845  nd_set_line(node, nd_line(orig));
14846 }
14847 
14848 static void
14849 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14850 {
14851  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14852 }
14853 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14854 
14855 static void
14856 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14857 {
14858  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14859 }
14860 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14861 
14862 static NODE*
14864 {
14865  NODE *end, *h = head, *nd;
14866 
14867  if (tail == 0) return head;
14868 
14869  if (h == 0) return tail;
14870  switch (nd_type(h)) {
14871  case NODE_LIT:
14872  case NODE_STR:
14873  case NODE_SELF:
14874  case NODE_TRUE:
14875  case NODE_FALSE:
14876  case NODE_NIL:
14877  parser_warning(h, "unused literal ignored");
14878  return tail;
14879  default:
14880  h = end = NEW_BLOCK(head);
14881  end->nd_end = end;
14882  fixpos(end, head);
14883  head = end;
14884  break;
14885  case NODE_BLOCK:
14886  end = h->nd_end;
14887  break;
14888  }
14889 
14890  nd = end->nd_head;
14891  switch (nd_type(nd)) {
14892  case NODE_RETURN:
14893  case NODE_BREAK:
14894  case NODE_NEXT:
14895  case NODE_REDO:
14896  case NODE_RETRY:
14897  if (RTEST(ruby_verbose)) {
14898  parser_warning(tail, "statement not reached");
14899  }
14900  break;
14901 
14902  default:
14903  break;
14904  }
14905 
14906  if (nd_type(tail) != NODE_BLOCK) {
14907  tail = NEW_BLOCK(tail);
14908  tail->nd_end = tail;
14909  }
14910  end->nd_next = tail;
14911  h->nd_end = tail->nd_end;
14912  return head;
14913 }
14914 
14915 /* append item to the list */
14916 static NODE*
14917 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14918 {
14919  NODE *last;
14920 
14921  if (list == 0) return NEW_LIST(item);
14922  if (list->nd_next) {
14923  last = list->nd_next->nd_end;
14924  }
14925  else {
14926  last = list;
14927  }
14928 
14929  list->nd_alen += 1;
14930  last->nd_next = NEW_LIST(item);
14931  list->nd_next->nd_end = last->nd_next;
14932  return list;
14933 }
14934 
14935 /* concat two lists */
14936 static NODE*
14938 {
14939  NODE *last;
14940 
14941  if (head->nd_next) {
14942  last = head->nd_next->nd_end;
14943  }
14944  else {
14945  last = head;
14946  }
14947 
14948  head->nd_alen += tail->nd_alen;
14949  last->nd_next = tail;
14950  if (tail->nd_next) {
14951  head->nd_next->nd_end = tail->nd_next->nd_end;
14952  }
14953  else {
14954  head->nd_next->nd_end = tail;
14955  }
14956 
14957  return head;
14958 }
14959 
14960 static int
14962 {
14963  if (NIL_P(tail)) return 1;
14964  if (!rb_enc_compatible(head, tail)) {
14965  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14968  rb_str_resize(head, 0);
14969  rb_str_resize(tail, 0);
14970  return 0;
14971  }
14973  return 1;
14974 }
14975 
14976 /* concat two string literals */
14977 static NODE *
14979 {
14980  enum node_type htype;
14981  NODE *headlast;
14982  VALUE lit;
14983 
14984  if (!head) return tail;
14985  if (!tail) return head;
14986 
14987  htype = nd_type(head);
14988  if (htype == NODE_EVSTR) {
14989  NODE *node = NEW_DSTR(STR_NEW0());
14990  head = list_append(node, head);
14991  htype = NODE_DSTR;
14992  }
14993  switch (nd_type(tail)) {
14994  case NODE_STR:
14995  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14996  nd_type(headlast) == NODE_STR) {
14997  htype = NODE_STR;
14998  lit = headlast->nd_lit;
14999  }
15000  else {
15001  lit = head->nd_lit;
15002  }
15003  if (htype == NODE_STR) {
15004  if (!literal_concat0(parser, lit, tail->nd_lit)) {
15005  error:
15008  return 0;
15009  }
15011  }
15012  else {
15013  list_append(head, tail);
15014  }
15015  break;
15016 
15017  case NODE_DSTR:
15018  if (htype == NODE_STR) {
15019  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
15020  goto error;
15021  tail->nd_lit = head->nd_lit;
15023  head = tail;
15024  }
15025  else if (NIL_P(tail->nd_lit)) {
15026  append:
15027  head->nd_alen += tail->nd_alen - 1;
15028  head->nd_next->nd_end->nd_next = tail->nd_next;
15029  head->nd_next->nd_end = tail->nd_next->nd_end;
15031  }
15032  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
15033  nd_type(headlast) == NODE_STR) {
15034  lit = headlast->nd_lit;
15035  if (!literal_concat0(parser, lit, tail->nd_lit))
15036  goto error;
15037  tail->nd_lit = Qnil;
15038  goto append;
15039  }
15040  else {
15042  tail->nd_head = NEW_STR(tail->nd_lit);
15043  list_concat(head, tail);
15044  }
15045  break;
15046 
15047  case NODE_EVSTR:
15048  if (htype == NODE_STR) {
15050  head->nd_alen = 1;
15051  }
15052  list_append(head, tail);
15053  break;
15054  }
15055  return head;
15056 }
15057 
15058 static NODE *
15059 evstr2dstr_gen(struct parser_params *parser, NODE *node)
15060 {
15061  if (nd_type(node) == NODE_EVSTR) {
15062  node = list_append(NEW_DSTR(STR_NEW0()), node);
15063  }
15064  return node;
15065 }
15066 
15067 static NODE *
15068 new_evstr_gen(struct parser_params *parser, NODE *node)
15069 {
15070  NODE *head = node;
15071 
15072  if (node) {
15073  switch (nd_type(node)) {
15074  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
15075  return node;
15076  }
15077  }
15078  return NEW_EVSTR(head);
15079 }
15080 
15081 static NODE *
15082 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
15083 {
15084  value_expr(recv);
15085  value_expr(arg1);
15086  return NEW_CALL(recv, id, NEW_LIST(arg1));
15087 }
15088 
15089 static NODE *
15090 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
15091 {
15092  value_expr(recv);
15093  return NEW_CALL(recv, id, 0);
15094 }
15095 
15096 static NODE*
15097 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15098 {
15099  value_expr(node1);
15100  value_expr(node2);
15101  if (node1) {
15102  switch (nd_type(node1)) {
15103  case NODE_DREGX:
15104  case NODE_DREGX_ONCE:
15105  return NEW_MATCH2(node1, node2);
15106 
15107  case NODE_LIT:
15108  if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
15109  return NEW_MATCH2(node1, node2);
15110  }
15111  }
15112  }
15113 
15114  if (node2) {
15115  switch (nd_type(node2)) {
15116  case NODE_DREGX:
15117  case NODE_DREGX_ONCE:
15118  return NEW_MATCH3(node2, node1);
15119 
15120  case NODE_LIT:
15121  if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
15122  return NEW_MATCH3(node2, node1);
15123  }
15124  }
15125  }
15126 
15127  return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
15128 }
15129 
15130 static NODE*
15131 gettable_gen(struct parser_params *parser, ID id)
15132 {
15133  switch (id) {
15134  case keyword_self:
15135  return NEW_SELF();
15136  case keyword_nil:
15137  return NEW_NIL();
15138  case keyword_true:
15139  return NEW_TRUE();
15140  case keyword_false:
15141  return NEW_FALSE();
15142  case keyword__FILE__:
15144  case keyword__LINE__:
15145  return NEW_LIT(INT2FIX(tokline));
15146  case keyword__ENCODING__:
15148  }
15149  switch (id_type(id)) {
15150  case ID_LOCAL:
15151  if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
15152  if (local_id(id)) return NEW_LVAR(id);
15153  /* method call without arguments */
15154  return NEW_VCALL(id);
15155  case ID_GLOBAL:
15156  return NEW_GVAR(id);
15157  case ID_INSTANCE:
15158  return NEW_IVAR(id);
15159  case ID_CONST:
15160  return NEW_CONST(id);
15161  case ID_CLASS:
15162  return NEW_CVAR(id);
15163  }
15164  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15165  return 0;
15166 }
15167 #else /* !RIPPER */
15168 static int
15169 id_is_var_gen(struct parser_params *parser, ID id)
15170 {
15171  if (is_notop_id(id)) {
15172  switch (id & ID_SCOPE_MASK) {
15173  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
15174  return 1;
15175  case ID_LOCAL:
15176  if (dyna_in_block() && dvar_defined(id)) return 1;
15177  if (local_id(id)) return 1;
15178  /* method call without arguments */
15179  return 0;
15180  }
15181  }
15182  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15183  return 0;
15184 }
15185 #endif /* !RIPPER */
15186 
15187 #if PARSER_DEBUG
15188 static const char *
15189 lex_state_name(enum lex_state_e state)
15190 {
15191  static const char names[][12] = {
15192  "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG",
15193  "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS",
15194  "EXPR_VALUE",
15195  };
15196 
15197  if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
15198  return names[ffs(state)];
15199  return NULL;
15200 }
15201 #endif
15202 
15203 #ifdef RIPPER
15204 static VALUE
15205 assignable_gen(struct parser_params *parser, VALUE lhs)
15206 #else
15207 static NODE*
15208 assignable_gen(struct parser_params *parser, ID id, NODE *val)
15209 #endif
15210 {
15211 #ifdef RIPPER
15212  ID id = get_id(lhs);
15213 # define assignable_result(x) get_value(lhs)
15214 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
15215 #else
15216 # define assignable_result(x) (x)
15217 #endif
15218  if (!id) return assignable_result(0);
15219  switch (id) {
15220  case keyword_self:
15221  yyerror("Can't change the value of self");
15222  goto error;
15223  case keyword_nil:
15224  yyerror("Can't assign to nil");
15225  goto error;
15226  case keyword_true:
15227  yyerror("Can't assign to true");
15228  goto error;
15229  case keyword_false:
15230  yyerror("Can't assign to false");
15231  goto error;
15232  case keyword__FILE__:
15233  yyerror("Can't assign to __FILE__");
15234  goto error;
15235  case keyword__LINE__:
15236  yyerror("Can't assign to __LINE__");
15237  goto error;
15238  case keyword__ENCODING__:
15239  yyerror("Can't assign to __ENCODING__");
15240  goto error;
15241  }
15242  switch (id_type(id)) {
15243  case ID_LOCAL:
15244  if (dyna_in_block()) {
15245  if (dvar_curr(id)) {
15246  return assignable_result(NEW_DASGN_CURR(id, val));
15247  }
15248  else if (dvar_defined(id)) {
15249  return assignable_result(NEW_DASGN(id, val));
15250  }
15251  else if (local_id(id)) {
15252  return assignable_result(NEW_LASGN(id, val));
15253  }
15254  else {
15255  dyna_var(id);
15256  return assignable_result(NEW_DASGN_CURR(id, val));
15257  }
15258  }
15259  else {
15260  if (!local_id(id)) {
15261  local_var(id);
15262  }
15263  return assignable_result(NEW_LASGN(id, val));
15264  }
15265  break;
15266  case ID_GLOBAL:
15267  return assignable_result(NEW_GASGN(id, val));
15268  case ID_INSTANCE:
15269  return assignable_result(NEW_IASGN(id, val));
15270  case ID_CONST:
15271  if (!in_def && !in_single)
15272  return assignable_result(NEW_CDECL(id, val, 0));
15273  yyerror("dynamic constant assignment");
15274  break;
15275  case ID_CLASS:
15276  return assignable_result(NEW_CVASGN(id, val));
15277  default:
15278  compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15279  }
15280  error:
15281  return assignable_result(0);
15282 #undef assignable_result
15283 #undef parser_yyerror
15284 }
15285 
15286 static int
15288 {
15289  VALUE s;
15290  if (name == idUScore) return 1;
15291  if (!is_local_id(name)) return 0;
15292  s = rb_id2str(name);
15293  if (!s) return 0;
15294  return RSTRING_PTR(s)[0] == '_';
15295 }
15296 
15297 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15298 
15299 static int
15301 {
15302  if (is_private_local_id(name)) return 1;
15303  if (dyna_in_block()) {
15304  if (dvar_curr(name)) {
15305  yyerror("duplicated argument name");
15306  }
15307  else if (dvar_defined_get(name) || local_id(name)) {
15308  rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15309  vtable_add(lvtbl->vars, name);
15310  if (lvtbl->used) {
15312  }
15313  return 0;
15314  }
15315  }
15316  else {
15317  if (local_id(name)) {
15318  yyerror("duplicated argument name");
15319  }
15320  }
15321  return 1;
15322 }
15323 
15324 static ID
15326 {
15327  shadowing_lvar_0(parser, name);
15328  return name;
15329 }
15330 
15331 static void
15333 {
15334  if (!name) return;
15335  if (!is_local_id(name)) {
15336  compile_error(PARSER_ARG "invalid local variable - %s",
15337  rb_id2name(name));
15338  return;
15339  }
15340  if (!shadowing_lvar_0(parser, name)) return;
15341  dyna_var(name);
15342 }
15343 
15344 #ifndef RIPPER
15345 static NODE *
15346 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15347 {
15348  if (recv && nd_type(recv) == NODE_SELF)
15349  recv = (NODE *)1;
15350  return NEW_ATTRASGN(recv, tASET, idx);
15351 }
15352 
15353 static void
15354 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15355 {
15356  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15357  compile_error(PARSER_ARG "both block arg and actual block given");
15358  }
15359 }
15360 
15361 static const char id_type_names[][9] = {
15362  "LOCAL",
15363  "INSTANCE",
15364  "", /* INSTANCE2 */
15365  "GLOBAL",
15366  "ATTRSET",
15367  "CONST",
15368  "CLASS",
15369  "JUNK",
15370 };
15371 
15372 ID
15374 {
15375  if (!is_notop_id(id)) {
15376  switch (id) {
15377  case tAREF: case tASET:
15378  return tASET; /* only exception */
15379  }
15380  rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
15381  }
15382  else {
15383  int scope = (int)(id & ID_SCOPE_MASK);
15384  switch (scope) {
15385  case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
15386  case ID_CONST: case ID_CLASS: case ID_JUNK:
15387  break;
15388  case ID_ATTRSET:
15389  return id;
15390  default:
15391  rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset",
15392  id_type_names[scope], ID2SYM(id));
15393 
15394  }
15395  }
15396  id &= ~ID_SCOPE_MASK;
15397  id |= ID_ATTRSET;
15398  return id;
15399 }
15400 
15401 static NODE *
15402 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15403 {
15404  if (recv && nd_type(recv) == NODE_SELF)
15405  recv = (NODE *)1;
15406  return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15407 }
15408 
15409 static void
15411 {
15412  switch (nd_type(node)) {
15413  case NODE_NTH_REF:
15414  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15415  break;
15416  case NODE_BACK_REF:
15417  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15418  break;
15419  }
15420 }
15421 
15422 static NODE *
15423 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15424 {
15425  if (!node2) return node1;
15426  switch (nd_type(node1)) {
15427  case NODE_BLOCK_PASS:
15428  if (node1->nd_head)
15429  node1->nd_head = arg_concat(node1->nd_head, node2);
15430  else
15431  node1->nd_head = NEW_LIST(node2);
15432  return node1;
15433  case NODE_ARGSPUSH:
15434  if (nd_type(node2) != NODE_ARRAY) break;
15435  node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15436  nd_set_type(node1, NODE_ARGSCAT);
15437  return node1;
15438  case NODE_ARGSCAT:
15439  if (nd_type(node2) != NODE_ARRAY ||
15440  nd_type(node1->nd_body) != NODE_ARRAY) break;
15441  node1->nd_body = list_concat(node1->nd_body, node2);
15442  return node1;
15443  }
15444  return NEW_ARGSCAT(node1, node2);
15445 }
15446 
15447 static NODE *
15448 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15449 {
15450  if (!node1) return NEW_LIST(node2);
15451  switch (nd_type(node1)) {
15452  case NODE_ARRAY:
15453  return list_append(node1, node2);
15454  case NODE_BLOCK_PASS:
15455  node1->nd_head = arg_append(node1->nd_head, node2);
15456  return node1;
15457  case NODE_ARGSPUSH:
15458  node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15459  nd_set_type(node1, NODE_ARGSCAT);
15460  return node1;
15461  }
15462  return NEW_ARGSPUSH(node1, node2);
15463 }
15464 
15465 static NODE *
15467 {
15468  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15469  if (nd_type(node) == NODE_ARRAY) return node;
15470  return 0;
15471 }
15472 
15473 static NODE *
15474 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15475 {
15476  if (!lhs) return 0;
15477 
15478  switch (nd_type(lhs)) {
15479  case NODE_GASGN:
15480  case NODE_IASGN:
15481  case NODE_IASGN2:
15482  case NODE_LASGN:
15483  case NODE_DASGN:
15484  case NODE_DASGN_CURR:
15485  case NODE_MASGN:
15486  case NODE_CDECL:
15487  case NODE_CVASGN:
15488  lhs->nd_value = rhs;
15489  break;
15490 
15491  case NODE_ATTRASGN:
15492  case NODE_CALL:
15493  lhs->nd_args = arg_append(lhs->nd_args, rhs);
15494  break;
15495 
15496  default:
15497  /* should not happen */
15498  break;
15499  }
15500 
15501  return lhs;
15502 }
15503 
15504 static int
15505 value_expr_gen(struct parser_params *parser, NODE *node)
15506 {
15507  int cond = 0;
15508 
15509  if (!node) {
15510  rb_warning0("empty expression");
15511  }
15512  while (node) {
15513  switch (nd_type(node)) {
15514  case NODE_RETURN:
15515  case NODE_BREAK:
15516  case NODE_NEXT:
15517  case NODE_REDO:
15518  case NODE_RETRY:
15519  if (!cond) yyerror("void value expression");
15520  /* or "control never reach"? */
15521  return FALSE;
15522 
15523  case NODE_BLOCK:
15524  while (node->nd_next) {
15525  node = node->nd_next;
15526  }
15527  node = node->nd_head;
15528  break;
15529 
15530  case NODE_BEGIN:
15531  node = node->nd_body;
15532  break;
15533 
15534  case NODE_IF:
15535  if (!node->nd_body) {
15536  node = node->nd_else;
15537  break;
15538  }
15539  else if (!node->nd_else) {
15540  node = node->nd_body;
15541  break;
15542  }
15543  if (!value_expr(node->nd_body)) return FALSE;
15544  node = node->nd_else;
15545  break;
15546 
15547  case NODE_AND:
15548  case NODE_OR:
15549  cond = 1;
15550  node = node->nd_2nd;
15551  break;
15552 
15553  default:
15554  return TRUE;
15555  }
15556  }
15557 
15558  return TRUE;
15559 }
15560 
15561 static void
15562 void_expr_gen(struct parser_params *parser, NODE *node)
15563 {
15564  const char *useless = 0;
15565 
15566  if (!RTEST(ruby_verbose)) return;
15567 
15568  if (!node) return;
15569  switch (nd_type(node)) {
15570  case NODE_CALL:
15571  switch (node->nd_mid) {
15572  case '+':
15573  case '-':
15574  case '*':
15575  case '/':
15576  case '%':
15577  case tPOW:
15578  case tUPLUS:
15579  case tUMINUS:
15580  case '|':
15581  case '^':
15582  case '&':
15583  case tCMP:
15584  case '>':
15585  case tGEQ:
15586  case '<':
15587  case tLEQ:
15588  case tEQ:
15589  case tNEQ:
15590  useless = rb_id2name(node->nd_mid);
15591  break;
15592  }
15593  break;
15594 
15595  case NODE_LVAR:
15596  case NODE_DVAR:
15597  case NODE_GVAR:
15598  case NODE_IVAR:
15599  case NODE_CVAR:
15600  case NODE_NTH_REF:
15601  case NODE_BACK_REF:
15602  useless = "a variable";
15603  break;
15604  case NODE_CONST:
15605  useless = "a constant";
15606  break;
15607  case NODE_LIT:
15608  case NODE_STR:
15609  case NODE_DSTR:
15610  case NODE_DREGX:
15611  case NODE_DREGX_ONCE:
15612  useless = "a literal";
15613  break;
15614  case NODE_COLON2:
15615  case NODE_COLON3:
15616  useless = "::";
15617  break;
15618  case NODE_DOT2:
15619  useless = "..";
15620  break;
15621  case NODE_DOT3:
15622  useless = "...";
15623  break;
15624  case NODE_SELF:
15625  useless = "self";
15626  break;
15627  case NODE_NIL:
15628  useless = "nil";
15629  break;
15630  case NODE_TRUE:
15631  useless = "true";
15632  break;
15633  case NODE_FALSE:
15634  useless = "false";
15635  break;
15636  case NODE_DEFINED:
15637  useless = "defined?";
15638  break;
15639  }
15640 
15641  if (useless) {
15642  int line = ruby_sourceline;
15643 
15644  ruby_sourceline = nd_line(node);
15645  rb_warnS("possibly useless use of %s in void context", useless);
15646  ruby_sourceline = line;
15647  }
15648 }
15649 
15650 static void
15651 void_stmts_gen(struct parser_params *parser, NODE *node)
15652 {
15653  if (!RTEST(ruby_verbose)) return;
15654  if (!node) return;
15655  if (nd_type(node) != NODE_BLOCK) return;
15656 
15657  for (;;) {
15658  if (!node->nd_next) return;
15659  void_expr0(node->nd_head);
15660  node = node->nd_next;
15661  }
15662 }
15663 
15664 static NODE *
15666 {
15667  NODE **n = &node, *n1 = node;
15668  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15669  *n = n1 = n1->nd_body;
15670  }
15671  return node;
15672 }
15673 
15674 static NODE *
15676 {
15677  NODE **n = &node, *n1 = node;
15678  while (n1 && nd_type(n1) == NODE_BEGIN) {
15679  *n = n1 = n1->nd_body;
15680  }
15681  return node;
15682 }
15683 
15684 static void
15685 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15686 {
15687  NODE *node = *body;
15688 
15689  if (!node) {
15690  *body = NEW_NIL();
15691  return;
15692  }
15693 #define subnodes(n1, n2) \
15694  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15695  (!node->n2) ? (body = &node->n1, 1) : \
15696  (reduce_nodes(&node->n1), body = &node->n2, 1))
15697 
15698  while (node) {
15699  int newline = (int)(node->flags & NODE_FL_NEWLINE);
15700  switch (nd_type(node)) {
15701  end:
15702  case NODE_NIL:
15703  *body = 0;
15704  return;
15705  case NODE_RETURN:
15706  *body = node = node->nd_stts;
15707  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15708  continue;
15709  case NODE_BEGIN:
15710  *body = node = node->nd_body;
15711  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15712  continue;
15713  case NODE_BLOCK:
15714  body = &node->nd_end->nd_head;
15715  break;
15716  case NODE_IF:
15717  if (subnodes(nd_body, nd_else)) break;
15718  return;
15719  case NODE_CASE:
15720  body = &node->nd_body;
15721  break;
15722  case NODE_WHEN:
15723  if (!subnodes(nd_body, nd_next)) goto end;
15724  break;
15725  case NODE_ENSURE:
15726  if (!subnodes(nd_head, nd_resq)) goto end;
15727  break;
15728  case NODE_RESCUE:
15729  if (node->nd_else) {
15730  body = &node->nd_resq;
15731  break;
15732  }
15733  if (!subnodes(nd_head, nd_resq)) goto end;
15734  break;
15735  default:
15736  return;
15737  }
15738  node = *body;
15739  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15740  }
15741 
15742 #undef subnodes
15743 }
15744 
15745 static int
15747 {
15748  if (!node) return 1;
15749  switch (nd_type(node)) {
15750  case NODE_HASH:
15751  if (!(node = node->nd_head)) break;
15752  case NODE_ARRAY:
15753  do {
15754  if (!is_static_content(node->nd_head)) return 0;
15755  } while ((node = node->nd_next) != 0);
15756  case NODE_LIT:
15757  case NODE_STR:
15758  case NODE_NIL:
15759  case NODE_TRUE:
15760  case NODE_FALSE:
15761  case NODE_ZARRAY:
15762  break;
15763  default:
15764  return 0;
15765  }
15766  return 1;
15767 }
15768 
15769 static int
15770 assign_in_cond(struct parser_params *parser, NODE *node)
15771 {
15772  switch (nd_type(node)) {
15773  case NODE_MASGN:
15774  yyerror("multiple assignment in conditional");
15775  return 1;
15776 
15777  case NODE_LASGN:
15778  case NODE_DASGN:
15779  case NODE_DASGN_CURR:
15780  case NODE_GASGN:
15781  case NODE_IASGN:
15782  break;
15783 
15784  default:
15785  return 0;
15786  }
15787 
15788  if (!node->nd_value) return 1;
15789  if (is_static_content(node->nd_value)) {
15790  /* reports always */
15791  parser_warn(node->nd_value, "found = in conditional, should be ==");
15792  }
15793  return 1;
15794 }
15795 
15796 static void
15797 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15798 {
15799  if (!e_option_supplied(parser)) parser_warn(node, str);
15800 }
15801 
15802 static void
15803 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15804 {
15805  if (!e_option_supplied(parser)) parser_warning(node, str);
15806 }
15807 
15808 static void
15809 fixup_nodes(NODE **rootnode)
15810 {
15811  NODE *node, *next, *head;
15812 
15813  for (node = *rootnode; node; node = next) {
15814  enum node_type type;
15815  VALUE val;
15816 
15817  next = node->nd_next;
15818  head = node->nd_head;
15819  rb_gc_force_recycle((VALUE)node);
15820  *rootnode = next;
15821  switch (type = nd_type(head)) {
15822  case NODE_DOT2:
15823  case NODE_DOT3:
15824  val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15825  type == NODE_DOT3);
15826  rb_gc_force_recycle((VALUE)head->nd_beg);
15827  rb_gc_force_recycle((VALUE)head->nd_end);
15829  head->nd_lit = val;
15830  break;
15831  default:
15832  break;
15833  }
15834  }
15835 }
15836 
15837 static NODE *cond0(struct parser_params*,NODE*);
15838 
15839 static NODE*
15840 range_op(struct parser_params *parser, NODE *node)
15841 {
15842  enum node_type type;
15843 
15844  if (node == 0) return 0;
15845 
15846  type = nd_type(node);
15847  value_expr(node);
15848  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15849  warn_unless_e_option(parser, node, "integer literal in conditional range");
15850  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15851  }
15852  return cond0(parser, node);
15853 }
15854 
15855 static int
15857 {
15858  if (!node) return 1; /* same as NODE_NIL */
15859  switch (nd_type(node)) {
15860  case NODE_LIT:
15861  case NODE_STR:
15862  case NODE_DSTR:
15863  case NODE_EVSTR:
15864  case NODE_DREGX:
15865  case NODE_DREGX_ONCE:
15866  case NODE_DSYM:
15867  return 2;
15868  case NODE_TRUE:
15869  case NODE_FALSE:
15870  case NODE_NIL:
15871  return 1;
15872  }
15873  return 0;
15874 }
15875 
15876 static NODE*
15877 cond0(struct parser_params *parser, NODE *node)
15878 {
15879  if (node == 0) return 0;
15880  assign_in_cond(parser, node);
15881 
15882  switch (nd_type(node)) {
15883  case NODE_DSTR:
15884  case NODE_EVSTR:
15885  case NODE_STR:
15886  rb_warn0("string literal in condition");
15887  break;
15888 
15889  case NODE_DREGX:
15890  case NODE_DREGX_ONCE:
15891  warning_unless_e_option(parser, node, "regex literal in condition");
15892  return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15893 
15894  case NODE_AND:
15895  case NODE_OR:
15896  node->nd_1st = cond0(parser, node->nd_1st);
15897  node->nd_2nd = cond0(parser, node->nd_2nd);
15898  break;
15899 
15900  case NODE_DOT2:
15901  case NODE_DOT3:
15902  node->nd_beg = range_op(parser, node->nd_beg);
15903  node->nd_end = range_op(parser, node->nd_end);
15904  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15905  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15906  if (!e_option_supplied(parser)) {
15907  int b = literal_node(node->nd_beg);
15908  int e = literal_node(node->nd_end);
15909  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15910  parser_warn(node, "range literal in condition");
15911  }
15912  }
15913  break;
15914 
15915  case NODE_DSYM:
15916  parser_warning(node, "literal in condition");
15917  break;
15918 
15919  case NODE_LIT:
15920  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
15921  warn_unless_e_option(parser, node, "regex literal in condition");
15922  nd_set_type(node, NODE_MATCH);
15923  }
15924  else {
15925  parser_warning(node, "literal in condition");
15926  }
15927  default:
15928  break;
15929  }
15930  return node;
15931 }
15932 
15933 static NODE*
15934 cond_gen(struct parser_params *parser, NODE *node)
15935 {
15936  if (node == 0) return 0;
15937  return cond0(parser, node);
15938 }
15939 
15940 static NODE*
15941 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15942 {
15943  value_expr(left);
15944  if (left && (enum node_type)nd_type(left) == type) {
15945  NODE *node = left, *second;
15946  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15947  node = second;
15948  }
15949  node->nd_2nd = NEW_NODE(type, second, right, 0);
15950  return left;
15951  }
15952  return NEW_NODE(type, left, right, 0);
15953 }
15954 
15955 static void
15956 no_blockarg(struct parser_params *parser, NODE *node)
15957 {
15958  if (node && nd_type(node) == NODE_BLOCK_PASS) {
15959  compile_error(PARSER_ARG "block argument should not be given");
15960  }
15961 }
15962 
15963 static NODE *
15964 ret_args_gen(struct parser_params *parser, NODE *node)
15965 {
15966  if (node) {
15967  no_blockarg(parser, node);
15968  if (nd_type(node) == NODE_ARRAY) {
15969  if (node->nd_next == 0) {
15970  node = node->nd_head;
15971  }
15972  else {
15973  nd_set_type(node, NODE_VALUES);
15974  }
15975  }
15976  }
15977  return node;
15978 }
15979 
15980 static NODE *
15981 new_yield_gen(struct parser_params *parser, NODE *node)
15982 {
15983  if (node) no_blockarg(parser, node);
15984 
15985  return NEW_YIELD(node);
15986 }
15987 
15988 static NODE*
15990 {
15991  switch (TYPE(node->nd_lit)) {
15992  case T_FIXNUM:
15993  node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
15994  break;
15995  case T_BIGNUM:
15996  case T_RATIONAL:
15997  case T_COMPLEX:
15998  node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
15999  break;
16000  case T_FLOAT:
16001 #if USE_FLONUM
16002  if (FLONUM_P(node->nd_lit)) {
16003  node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
16004  }
16005  else {
16006  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
16007  }
16008 #else
16009  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
16010 #endif
16011  break;
16012  default:
16013  rb_bug("unknown literal type passed to negate_lit");
16014  break;
16015  }
16016  return node;
16017 }
16018 
16019 static NODE *
16020 arg_blk_pass(NODE *node1, NODE *node2)
16021 {
16022  if (node2) {
16023  node2->nd_head = node1;
16024  return node2;
16025  }
16026  return node1;
16027 }
16028 
16029 
16030 static NODE*
16031 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
16032 {
16033  int saved_line = ruby_sourceline;
16034  struct rb_args_info *args = tail->nd_ainfo;
16035 
16036  args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0;
16037  args->pre_init = m ? m->nd_next : 0;
16038 
16039  args->post_args_num = p ? rb_long2int(p->nd_plen) : 0;
16040  args->post_init = p ? p->nd_next : 0;
16041  args->first_post_arg = p ? p->nd_pid : 0;
16042 
16043  args->rest_arg = r;
16044 
16045  args->opt_args = o;
16046 
16047  ruby_sourceline = saved_line;
16048 
16049  return tail;
16050 }
16051 
16052 static NODE*
16053 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
16054 {
16055  int saved_line = ruby_sourceline;
16056  struct rb_args_info *args;
16057  NODE *kw_rest_arg = 0;
16058  NODE *node;
16059  int check = 0;
16060 
16061  args = ALLOC(struct rb_args_info);
16062  MEMZERO(args, struct rb_args_info, 1);
16063  node = NEW_NODE(NODE_ARGS, 0, 0, args);
16064 
16065  args->block_arg = b;
16066  args->kw_args = k;
16067  if (k && !kr) {
16068  check = 1;
16069  kr = internal_id();
16070  }
16071  if (kr) {
16072  arg_var(kr);
16073  kw_rest_arg = NEW_DVAR(kr);
16074  kw_rest_arg->nd_cflag = check;
16075  }
16076  args->kw_rest_arg = kw_rest_arg;
16077 
16078  ruby_sourceline = saved_line;
16079  return node;
16080 }
16081 
16082 static NODE*
16083 dsym_node_gen(struct parser_params *parser, NODE *node)
16084 {
16085  VALUE lit;
16086 
16087  if (!node) {
16088  return NEW_LIT(ID2SYM(idNULL));
16089  }
16090 
16091  switch (nd_type(node)) {
16092  case NODE_DSTR:
16093  nd_set_type(node, NODE_DSYM);
16094  break;
16095  case NODE_STR:
16096  lit = node->nd_lit;
16097  node->nd_lit = ID2SYM(rb_intern_str(lit));
16098  nd_set_type(node, NODE_LIT);
16099  break;
16100  default:
16101  node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
16102  break;
16103  }
16104  return node;
16105 }
16106 #endif /* !RIPPER */
16107 
16108 #ifndef RIPPER
16109 static NODE *
16110 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16111 {
16112  NODE *asgn;
16113 
16114  if (lhs) {
16115  ID vid = lhs->nd_vid;
16116  if (op == tOROP) {
16117  lhs->nd_value = rhs;
16118  asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
16119  if (is_asgn_or_id(vid)) {
16120  asgn->nd_aid = vid;
16121  }
16122  }
16123  else if (op == tANDOP) {
16124  lhs->nd_value = rhs;
16125  asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
16126  }
16127  else {
16128  asgn = lhs;
16129  asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
16130  }
16131  }
16132  else {
16133  asgn = NEW_BEGIN(0);
16134  }
16135  return asgn;
16136 }
16137 
16138 static NODE *
16139 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
16140 {
16141  NODE *asgn;
16142 
16143  if (op == tOROP) {
16144  op = 0;
16145  }
16146  else if (op == tANDOP) {
16147  op = 1;
16148  }
16149  asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
16150  fixpos(asgn, lhs);
16151  return asgn;
16152 }
16153 
16154 static NODE *
16155 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16156 {
16157  NODE *asgn;
16158 
16159  if (op == tOROP) {
16160  op = 0;
16161  }
16162  else if (op == tANDOP) {
16163  op = 1;
16164  }
16165  if (lhs) {
16166  asgn = NEW_OP_CDECL(lhs, op, rhs);
16167  }
16168  else {
16169  asgn = NEW_BEGIN(0);
16170  }
16171  fixpos(asgn, lhs);
16172  return asgn;
16173 }
16174 #else
16175 static VALUE
16176 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
16177 {
16178  return dispatch3(opassign, lhs, op, rhs);
16179 }
16180 
16181 static VALUE
16182 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
16183 {
16184  VALUE recv = dispatch3(field, lhs, type, attr);
16185  return dispatch3(opassign, recv, op, rhs);
16186 }
16187 #endif
16188 
16189 static void
16190 warn_unused_var(struct parser_params *parser, struct local_vars *local)
16191 {
16192  int i, cnt;
16193  ID *v, *u;
16194 
16195  if (!local->used) return;
16196  v = local->vars->tbl;
16197  u = local->used->tbl;
16198  cnt = local->used->pos;
16199  if (cnt != local->vars->pos) {
16200  rb_bug("local->used->pos != local->vars->pos");
16201  }
16202  for (i = 0; i < cnt; ++i) {
16203  if (!v[i] || (u[i] & LVAR_USED)) continue;
16204  if (is_private_local_id(v[i])) continue;
16205  rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
16206  }
16207 }
16208 
16209 static void
16210 local_push_gen(struct parser_params *parser, int inherit_dvars)
16211 {
16212  struct local_vars *local;
16213 
16214  local = ALLOC(struct local_vars);
16215  local->prev = lvtbl;
16216  local->args = vtable_alloc(0);
16217  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
16218  local->used = !(inherit_dvars &&
16220  RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
16221  local->cmdargs = cmdarg_stack;
16222  cmdarg_stack = 0;
16223  lvtbl = local;
16224 }
16225 
16226 static void
16228 {
16229  struct local_vars *local = lvtbl->prev;
16230  if (lvtbl->used) {
16231  warn_unused_var(parser, lvtbl);
16232  vtable_free(lvtbl->used);
16233  }
16234  vtable_free(lvtbl->args);
16235  vtable_free(lvtbl->vars);
16236  cmdarg_stack = lvtbl->cmdargs;
16237  xfree(lvtbl);
16238  lvtbl = local;
16239 }
16240 
16241 #ifndef RIPPER
16242 static ID*
16244 {
16245  int cnt_args = vtable_size(lvtbl->args);
16246  int cnt_vars = vtable_size(lvtbl->vars);
16247  int cnt = cnt_args + cnt_vars;
16248  int i, j;
16249  ID *buf;
16250 
16251  if (cnt <= 0) return 0;
16252  buf = ALLOC_N(ID, cnt + 1);
16253  MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args);
16254  /* remove IDs duplicated to warn shadowing */
16255  for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
16256  ID id = lvtbl->vars->tbl[i];
16257  if (!vtable_included(lvtbl->args, id)) {
16258  buf[j++] = id;
16259  }
16260  }
16261  if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1);
16262  buf[0] = cnt;
16263  return buf;
16264 }
16265 #endif
16266 
16267 static int
16268 arg_var_gen(struct parser_params *parser, ID id)
16269 {
16270  vtable_add(lvtbl->args, id);
16271  return vtable_size(lvtbl->args) - 1;
16272 }
16273 
16274 static int
16275 local_var_gen(struct parser_params *parser, ID id)
16276 {
16277  vtable_add(lvtbl->vars, id);
16278  if (lvtbl->used) {
16280  }
16281  return vtable_size(lvtbl->vars) - 1;
16282 }
16283 
16284 static int
16285 local_id_gen(struct parser_params *parser, ID id)
16286 {
16287  struct vtable *vars, *args, *used;
16288 
16289  vars = lvtbl->vars;
16290  args = lvtbl->args;
16291  used = lvtbl->used;
16292 
16293  while (vars && POINTER_P(vars->prev)) {
16294  vars = vars->prev;
16295  args = args->prev;
16296  if (used) used = used->prev;
16297  }
16298 
16299  if (vars && vars->prev == DVARS_INHERIT) {
16300  return rb_local_defined(id);
16301  }
16302  else if (vtable_included(args, id)) {
16303  return 1;
16304  }
16305  else {
16306  int i = vtable_included(vars, id);
16307  if (i && used) used->tbl[i-1] |= LVAR_USED;
16308  return i != 0;
16309  }
16310 }
16311 
16312 static const struct vtable *
16314 {
16315  lvtbl->args = vtable_alloc(lvtbl->args);
16316  lvtbl->vars = vtable_alloc(lvtbl->vars);
16317  if (lvtbl->used) {
16318  lvtbl->used = vtable_alloc(lvtbl->used);
16319  }
16320  return lvtbl->args;
16321 }
16322 
16323 static void
16324 dyna_pop_1(struct parser_params *parser)
16325 {
16326  struct vtable *tmp;
16327 
16328  if ((tmp = lvtbl->used) != 0) {
16329  warn_unused_var(parser, lvtbl);
16330  lvtbl->used = lvtbl->used->prev;
16331  vtable_free(tmp);
16332  }
16333  tmp = lvtbl->args;
16334  lvtbl->args = lvtbl->args->prev;
16335  vtable_free(tmp);
16336  tmp = lvtbl->vars;
16337  lvtbl->vars = lvtbl->vars->prev;
16338  vtable_free(tmp);
16339 }
16340 
16341 static void
16342 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16343 {
16344  while (lvtbl->args != lvargs) {
16345  dyna_pop_1(parser);
16346  if (!lvtbl->args) {
16347  struct local_vars *local = lvtbl->prev;
16348  xfree(lvtbl);
16349  lvtbl = local;
16350  }
16351  }
16352  dyna_pop_1(parser);
16353 }
16354 
16355 static int
16357 {
16358  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16359 }
16360 
16361 static int
16362 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16363 {
16364  struct vtable *vars, *args, *used;
16365  int i;
16366 
16367  args = lvtbl->args;
16368  vars = lvtbl->vars;
16369  used = lvtbl->used;
16370 
16371  while (POINTER_P(vars)) {
16372  if (vtable_included(args, id)) {
16373  return 1;
16374  }
16375  if ((i = vtable_included(vars, id)) != 0) {
16376  if (used) used->tbl[i-1] |= LVAR_USED;
16377  return 1;
16378  }
16379  args = args->prev;
16380  vars = vars->prev;
16381  if (get) used = 0;
16382  if (used) used = used->prev;
16383  }
16384 
16385  if (vars == DVARS_INHERIT) {
16386  return rb_dvar_defined(id);
16387  }
16388 
16389  return 0;
16390 }
16391 
16392 static int
16393 dvar_curr_gen(struct parser_params *parser, ID id)
16394 {
16395  return (vtable_included(lvtbl->args, id) ||
16396  vtable_included(lvtbl->vars, id));
16397 }
16398 
16399 #ifndef RIPPER
16400 static void
16402 {
16404 
16405  if (c) {
16406  int opt, idx;
16407  rb_char_to_option_kcode(c, &opt, &idx);
16408  if (idx != ENCODING_GET(str) &&
16410  goto error;
16411  }
16412  ENCODING_SET(str, idx);
16413  }
16414  else if (RE_OPTION_ENCODING_NONE(options)) {
16415  if (!ENCODING_IS_ASCII8BIT(str) &&
16417  c = 'n';
16418  goto error;
16419  }
16421  }
16422  else if (current_enc == rb_usascii_encoding()) {
16424  /* raise in re.c */
16426  }
16427  else {
16429  }
16430  }
16431  return;
16432 
16433  error:
16435  "regexp encoding option '%c' differs from source encoding '%s'",
16436  c, rb_enc_name(rb_enc_get(str)));
16437 }
16438 
16439 static int
16441 {
16442  VALUE err;
16445  if (err != Qnil) {
16448  return 0;
16449  }
16450  return 1;
16451 }
16452 
16453 typedef struct {
16454  struct parser_params* parser;
16455  rb_encoding *enc;
16456  NODE *succ_block;
16457  NODE *fail_block;
16458  int num;
16460 
16461 static int
16463  int back_num, int *back_refs, OnigRegex regex, void *arg0)
16464 {
16466  struct parser_params* parser = arg->parser;
16467  rb_encoding *enc = arg->enc;
16468  long len = name_end - name;
16469  const char *s = (const char *)name;
16470  ID var;
16471 
16472  arg->num++;
16473 
16474  if (arg->succ_block == 0) {
16475  arg->succ_block = NEW_BEGIN(0);
16476  arg->fail_block = NEW_BEGIN(0);
16477  }
16478 
16479  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16480  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16481  !rb_enc_symname2_p(s, len, enc)) {
16482  return ST_CONTINUE;
16483  }
16484  var = rb_intern3(s, len, enc);
16485  if (dvar_defined(var) || local_id(var)) {
16486  rb_warningS("named capture conflicts a local variable - %s",
16487  rb_id2name(var));
16488  }
16489  arg->succ_block = block_append(arg->succ_block,
16491  NEW_CALL(
16492  gettable(rb_intern("$~")),
16493  idAREF,
16494  NEW_LIST(NEW_LIT(ID2SYM(var))))
16495  )));
16496  arg->fail_block = block_append(arg->fail_block,
16498  return ST_CONTINUE;
16499 }
16500 
16501 static NODE *
16503 {
16505 
16506  arg.parser = parser;
16507  arg.enc = rb_enc_get(regexp);
16508  arg.succ_block = 0;
16509  arg.fail_block = 0;
16510  arg.num = 0;
16511  onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
16512 
16513  if (arg.num == 0)
16514  return match;
16515 
16516  return
16517  block_append(
16519  NEW_IF(gettable(rb_intern("$~")),
16520  block_append(
16521  newline_node(arg.succ_block),
16522  newline_node(
16523  NEW_CALL(
16524  gettable(rb_intern("$~")),
16525  rb_intern("begin"),
16526  NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16527  block_append(
16528  newline_node(arg.fail_block),
16529  newline_node(
16530  NEW_LIT(Qnil)))));
16531 }
16532 
16533 static VALUE
16534 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16535 {
16536  VALUE re;
16537  VALUE err;
16538 
16540  err = rb_errinfo();
16542  if (NIL_P(re)) {
16543  ID mesg = rb_intern("mesg");
16544  VALUE m = rb_attr_get(rb_errinfo(), mesg);
16546  if (!NIL_P(err)) {
16547  rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16548  }
16549  else {
16551  }
16552  return Qnil;
16553  }
16554  return re;
16555 }
16556 
16557 void
16559 {
16560 }
16561 
16562 NODE*
16564 {
16565  NODE *prelude = 0;
16566  NODE *scope = node;
16567  struct parser_params *parser;
16568 
16569  if (!node) return node;
16570 
16571  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16572 
16573  node = node->nd_body;
16574 
16575  if (nd_type(node) == NODE_PRELUDE) {
16576  prelude = node;
16577  node = node->nd_body;
16578  }
16579 
16580  node = block_append(node,
16581  NEW_FCALL(rb_intern("print"),
16582  NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16583  if (prelude) {
16584  prelude->nd_body = node;
16585  scope->nd_body = prelude;
16586  }
16587  else {
16588  scope->nd_body = node;
16589  }
16590 
16591  return scope;
16592 }
16593 
16594 NODE *
16595 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16596 {
16597  NODE *prelude = 0;
16598  NODE *scope = node;
16599  struct parser_params *parser;
16600 
16601  if (!node) return node;
16602 
16603  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16604 
16605  node = node->nd_body;
16606 
16607  if (nd_type(node) == NODE_PRELUDE) {
16608  prelude = node;
16609  node = node->nd_body;
16610  }
16611  if (split) {
16612  node = block_append(NEW_GASGN(rb_intern("$F"),
16613  NEW_CALL(NEW_GVAR(rb_intern("$_")),
16614  rb_intern("split"), 0)),
16615  node);
16616  }
16617  if (chop) {
16618  node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16619  rb_intern("chop!"), 0), node);
16620  }
16621 
16622  node = NEW_OPT_N(node);
16623 
16624  if (prelude) {
16625  prelude->nd_body = node;
16626  scope->nd_body = prelude;
16627  }
16628  else {
16629  scope->nd_body = node;
16630  }
16631 
16632  return scope;
16633 }
16634 
16635 static const struct {
16637  const char *name;
16638 } op_tbl[] = {
16639  {tDOT2, ".."},
16640  {tDOT3, "..."},
16641  {tPOW, "**"},
16642  {tDSTAR, "**"},
16643  {tUPLUS, "+@"},
16644  {tUMINUS, "-@"},
16645  {tCMP, "<=>"},
16646  {tGEQ, ">="},
16647  {tLEQ, "<="},
16648  {tEQ, "=="},
16649  {tEQQ, "==="},
16650  {tNEQ, "!="},
16651  {tMATCH, "=~"},
16652  {tNMATCH, "!~"},
16653  {tAREF, "[]"},
16654  {tASET, "[]="},
16655  {tLSHFT, "<<"},
16656  {tRSHFT, ">>"},
16657  {tCOLON2, "::"},
16658 };
16659 
16660 #define op_tbl_count numberof(op_tbl)
16661 
16662 #ifndef ENABLE_SELECTOR_NAMESPACE
16663 #define ENABLE_SELECTOR_NAMESPACE 0
16664 #endif
16665 
16666 static struct symbols {
16667  ID last_id;
16668  st_table *sym_id;
16669  st_table *id_str;
16670 #if ENABLE_SELECTOR_NAMESPACE
16671  st_table *ivar2_id;
16672  st_table *id_ivar2;
16673 #endif
16675  int minor_marked;
16677 
16678 static const struct st_hash_type symhash = {
16680  rb_str_hash,
16681 };
16682 
16683 #if ENABLE_SELECTOR_NAMESPACE
16684 struct ivar2_key {
16685  ID id;
16686  VALUE klass;
16687 };
16688 
16689 static int
16690 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16691 {
16692  if (key1->id == key2->id && key1->klass == key2->klass) {
16693  return 0;
16694  }
16695  return 1;
16696 }
16697 
16698 static int
16699 ivar2_hash(struct ivar2_key *key)
16700 {
16701  return (key->id << 8) ^ (key->klass >> 2);
16702 }
16703 
16704 static const struct st_hash_type ivar2_hash_type = {
16705  ivar2_cmp,
16706  ivar2_hash,
16707 };
16708 #endif
16709 
16710 void
16712 {
16715 #if ENABLE_SELECTOR_NAMESPACE
16716  global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16717  global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16718 #endif
16719 
16720  (void)nodetype;
16721  (void)nodeline;
16722 #if PARSER_DEBUG
16723  (void)lex_state_name(-1);
16724 #endif
16725 
16726  Init_id();
16727 }
16728 
16729 void
16730 rb_gc_mark_symbols(int full_mark)
16731 {
16732  if (full_mark || global_symbols.minor_marked == 0) {
16736 
16737  if (!full_mark) global_symbols.minor_marked = 1;
16738  }
16739 }
16740 #endif /* !RIPPER */
16741 
16742 static ID
16744 {
16745  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16746  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16747  return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16748 }
16749 
16750 #ifndef RIPPER
16751 static int
16752 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16753 {
16754  int mb = 0;
16755 
16756  if (m >= e) return 0;
16757  if (is_global_name_punct(*m)) {
16758  ++m;
16759  }
16760  else if (*m == '-') {
16761  if (++m >= e) return 0;
16762  if (is_identchar(m, e, enc)) {
16763  if (!ISASCII(*m)) mb = 1;
16764  m += rb_enc_mbclen(m, e, enc);
16765  }
16766  }
16767  else {
16768  if (!rb_enc_isdigit(*m, enc)) return 0;
16769  do {
16770  if (!ISASCII(*m)) mb = 1;
16771  ++m;
16772  } while (m < e && rb_enc_isdigit(*m, enc));
16773  }
16774  return m == e ? mb + 1 : 0;
16775 }
16776 
16777 int
16778 rb_symname_p(const char *name)
16779 {
16781 }
16782 
16783 int
16785 {
16786  return rb_enc_symname2_p(name, strlen(name), enc);
16787 }
16788 
16789 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
16790 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<ID_SCOPE_MASK) & ~(1U<<ID_ATTRSET))
16791 
16792 static int
16793 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset)
16794 {
16795  const char *m = name;
16796  const char *e = m + len;
16797  int type = ID_JUNK;
16798 
16799  if (!m || len <= 0) return -1;
16800  switch (*m) {
16801  case '\0':
16802  return -1;
16803 
16804  case '$':
16805  type = ID_GLOBAL;
16806  if (is_special_global_name(++m, e, enc)) return type;
16807  goto id;
16808 
16809  case '@':
16810  type = ID_INSTANCE;
16811  if (*++m == '@') {
16812  ++m;
16813  type = ID_CLASS;
16814  }
16815  goto id;
16816 
16817  case '<':
16818  switch (*++m) {
16819  case '<': ++m; break;
16820  case '=': if (*++m == '>') ++m; break;
16821  default: break;
16822  }
16823  break;
16824 
16825  case '>':
16826  switch (*++m) {
16827  case '>': case '=': ++m; break;
16828  }
16829  break;
16830 
16831  case '=':
16832  switch (*++m) {
16833  case '~': ++m; break;
16834  case '=': if (*++m == '=') ++m; break;
16835  default: return -1;
16836  }
16837  break;
16838 
16839  case '*':
16840  if (*++m == '*') ++m;
16841  break;
16842 
16843  case '+': case '-':
16844  if (*++m == '@') ++m;
16845  break;
16846 
16847  case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16848  ++m;
16849  break;
16850 
16851  case '[':
16852  if (*++m != ']') return -1;
16853  if (*++m == '=') ++m;
16854  break;
16855 
16856  case '!':
16857  if (len == 1) return ID_JUNK;
16858  switch (*++m) {
16859  case '=': case '~': ++m; break;
16860  default: return -1;
16861  }
16862  break;
16863 
16864  default:
16865  type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16866  id:
16867  if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16868  return -1;
16869  while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16870  if (m >= e) break;
16871  switch (*m) {
16872  case '!': case '?':
16873  if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16874  type = ID_JUNK;
16875  ++m;
16876  break;
16877  case '=':
16878  if (!(allowed_attrset & (1U << type))) return -1;
16879  type = ID_ATTRSET;
16880  ++m;
16881  break;
16882  }
16883  break;
16884  }
16885  return m == e ? type : -1;
16886 }
16887 
16888 int
16889 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16890 {
16891  return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
16892 }
16893 
16894 static int
16895 rb_str_symname_type(VALUE name, unsigned int allowed_attrset)
16896 {
16897  const char *ptr = StringValuePtr(name);
16898  long len = RSTRING_LEN(name);
16899  int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_attrset);
16900  RB_GC_GUARD(name);
16901  return type;
16902 }
16903 
16904 static ID
16905 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16906 {
16907  VALUE str = rb_enc_str_new(name, len, enc);
16908  return register_symid_str(id, str);
16909 }
16910 
16911 static ID
16913 {
16914  OBJ_FREEZE(str);
16915  str = rb_fstring(str);
16916 
16919  }
16920 
16924  return id;
16925 }
16926 
16927 static int
16929 {
16930  if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
16931  switch (rb_enc_str_coderange(str)) {
16932  case ENC_CODERANGE_BROKEN:
16933  rb_raise(rb_eEncodingError, "invalid encoding symbol");
16934  case ENC_CODERANGE_7BIT:
16935  return TRUE;
16936  }
16937  return FALSE;
16938 }
16939 
16940 /*
16941  * _str_ itself will be registered at the global symbol table. _str_
16942  * can be modified before the registration, since the encoding will be
16943  * set to ASCII-8BIT if it is a special global name.
16944  */
16945 static ID intern_str(VALUE str);
16946 
16947 static VALUE
16948 setup_fake_str(struct RString *fake_str, const char *name, long len)
16949 {
16950  fake_str->basic.flags = T_STRING|RSTRING_NOEMBED;
16952  fake_str->as.heap.len = len;
16953  fake_str->as.heap.ptr = (char *)name;
16954  fake_str->as.heap.aux.capa = len;
16955  return (VALUE)fake_str;
16956 }
16957 
16958 ID
16959 rb_intern3(const char *name, long len, rb_encoding *enc)
16960 {
16961  st_data_t data;
16962  struct RString fake_str;
16963  VALUE str = setup_fake_str(&fake_str, name, len);
16964  rb_enc_associate(str, enc);
16965  OBJ_FREEZE(str);
16966 
16967  if (st_lookup(global_symbols.sym_id, str, &data))
16968  return (ID)data;
16969 
16970  str = rb_enc_str_new(name, len, enc); /* make true string */
16971  return intern_str(str);
16972 }
16973 
16974 static ID
16976 {
16977  const char *name, *m, *e;
16978  long len, last;
16979  rb_encoding *enc, *symenc;
16980  unsigned char c;
16981  ID id;
16982  int mb;
16983 
16984  RSTRING_GETMEM(str, name, len);
16985  m = name;
16986  e = m + len;
16987  enc = rb_enc_get(str);
16988  symenc = enc;
16989 
16990  if (!len || (rb_cString && !rb_enc_asciicompat(enc))) {
16991  junk:
16992  id = ID_JUNK;
16993  goto new_id;
16994  }
16995  last = len-1;
16996  id = 0;
16997  switch (*m) {
16998  case '$':
16999  if (len < 2) goto junk;
17000  id |= ID_GLOBAL;
17001  if ((mb = is_special_global_name(++m, e, enc)) != 0) {
17002  if (!--mb) symenc = rb_usascii_encoding();
17003  goto new_id;
17004  }
17005  break;
17006  case '@':
17007  if (m[1] == '@') {
17008  if (len < 3) goto junk;
17009  m++;
17010  id |= ID_CLASS;
17011  }
17012  else {
17013  if (len < 2) goto junk;
17014  id |= ID_INSTANCE;
17015  }
17016  m++;
17017  break;
17018  default:
17019  c = m[0];
17020  if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
17021  /* operators */
17022  int i;
17023 
17024  if (len == 1) {
17025  id = c;
17026  goto id_register;
17027  }
17028  for (i = 0; i < op_tbl_count; i++) {
17029  if (*op_tbl[i].name == *m &&
17030  strcmp(op_tbl[i].name, m) == 0) {
17031  id = op_tbl[i].token;
17032  goto id_register;
17033  }
17034  }
17035  }
17036  break;
17037  }
17038  if (name[last] == '=') {
17039  /* attribute assignment */
17040  if (last > 1 && name[last-1] == '=')
17041  goto junk;
17042  id = rb_intern3(name, last, enc);
17043  if (id > tLAST_OP_ID && !is_attrset_id(id)) {
17044  enc = rb_enc_get(rb_id2str(id));
17045  id = rb_id_attrset(id);
17046  goto id_register;
17047  }
17048  id = ID_ATTRSET;
17049  }
17050  else if (id == 0) {
17051  if (rb_enc_isupper(m[0], enc)) {
17052  id = ID_CONST;
17053  }
17054  else {
17055  id = ID_LOCAL;
17056  }
17057  }
17058  if (!rb_enc_isdigit(*m, enc)) {
17059  while (m <= name + last && is_identchar(m, e, enc)) {
17060  if (ISASCII(*m)) {
17061  m++;
17062  }
17063  else {
17064  m += rb_enc_mbclen(m, e, enc);
17065  }
17066  }
17067  }
17068  if (id != ID_ATTRSET && m - name < len) id = ID_JUNK;
17069  if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
17070  new_id:
17071  if (symenc != enc) rb_enc_associate(str, symenc);
17073  if (len > 20) {
17074  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
17075  name);
17076  }
17077  else {
17078  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
17079  (int)len, name);
17080  }
17081  }
17083  id_register:
17084  return register_symid_str(id, str);
17085 }
17086 
17087 ID
17088 rb_intern2(const char *name, long len)
17089 {
17090  return rb_intern3(name, len, rb_usascii_encoding());
17091 }
17092 
17093 #undef rb_intern
17094 ID
17095 rb_intern(const char *name)
17096 {
17097  return rb_intern2(name, strlen(name));
17098 }
17099 
17100 ID
17102 {
17103  st_data_t id;
17104 
17105  if (st_lookup(global_symbols.sym_id, str, &id))
17106  return (ID)id;
17107  return intern_str(rb_str_dup(str));
17108 }
17109 
17110 VALUE
17112 {
17113  st_data_t data;
17114 
17115  if (id < tLAST_TOKEN) {
17116  int i = 0;
17117 
17118  if (id < INT_MAX && rb_ispunct((int)id)) {
17119  VALUE str = global_symbols.op_sym[i = (int)id];
17120  if (!str) {
17121  char name[2];
17122  name[0] = (char)id;
17123  name[1] = 0;
17124  str = rb_usascii_str_new(name, 1);
17125  OBJ_FREEZE(str);
17126  str = rb_fstring(str);
17127  global_symbols.op_sym[i] = str;
17129  }
17130  return str;
17131  }
17132  for (i = 0; i < op_tbl_count; i++) {
17133  if (op_tbl[i].token == id) {
17134  VALUE str = global_symbols.op_sym[i];
17135  if (!str) {
17136  str = rb_usascii_str_new2(op_tbl[i].name);
17137  OBJ_FREEZE(str);
17138  str = rb_fstring(str);
17139  global_symbols.op_sym[i] = str;
17141  }
17142  return str;
17143  }
17144  }
17145  }
17146 
17147  if (st_lookup(global_symbols.id_str, id, &data)) {
17148  VALUE str = (VALUE)data;
17149  if (RBASIC(str)->klass == 0)
17151  return str;
17152  }
17153 
17154  if (is_attrset_id(id)) {
17155  ID id_stem = (id & ~ID_SCOPE_MASK);
17156  VALUE str;
17157 
17158  do {
17159  if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break;
17160  if (!!(str = rb_id2str(id_stem | ID_CONST))) break;
17161  if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break;
17162  if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break;
17163  if (!!(str = rb_id2str(id_stem | ID_CLASS))) break;
17164  if (!!(str = rb_id2str(id_stem | ID_JUNK))) break;
17165  return 0;
17166  } while (0);
17167  str = rb_str_dup(str);
17168  rb_str_cat(str, "=", 1);
17169  register_symid_str(id, str);
17170  if (st_lookup(global_symbols.id_str, id, &data)) {
17171  VALUE str = (VALUE)data;
17172  if (RBASIC(str)->klass == 0)
17174  return str;
17175  }
17176  }
17177  return 0;
17178 }
17179 
17180 const char *
17182 {
17183  VALUE str = rb_id2str(id);
17184 
17185  if (!str) return 0;
17186  return RSTRING_PTR(str);
17187 }
17188 
17189 static int
17191 {
17192  rb_ary_push(ary, ID2SYM(value));
17193  return ST_CONTINUE;
17194 }
17195 
17196 /*
17197  * call-seq:
17198  * Symbol.all_symbols => array
17199  *
17200  * Returns an array of all the symbols currently in Ruby's symbol
17201  * table.
17202  *
17203  * Symbol.all_symbols.size #=> 903
17204  * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
17205  * :chown, :EOFError, :$;, :String,
17206  * :LOCK_SH, :"setuid?", :$<,
17207  * :default_proc, :compact, :extend,
17208  * :Tms, :getwd, :$=, :ThreadGroup,
17209  * :wait2, :$>]
17210  */
17211 
17212 VALUE
17214 {
17216 
17218  return ary;
17219 }
17220 
17221 int
17223 {
17224  return is_const_id(id);
17225 }
17226 
17227 int
17229 {
17230  return is_class_id(id);
17231 }
17232 
17233 int
17235 {
17236  return is_global_id(id);
17237 }
17238 
17239 int
17241 {
17242  return is_instance_id(id);
17243 }
17244 
17245 int
17247 {
17248  return is_attrset_id(id);
17249 }
17250 
17251 int
17253 {
17254  return is_local_id(id);
17255 }
17256 
17257 int
17259 {
17260  return is_junk_id(id);
17261 }
17262 
17274 ID
17275 rb_check_id(volatile VALUE *namep)
17276 {
17277  st_data_t id;
17278  VALUE tmp;
17279  VALUE name = *namep;
17280 
17281  if (SYMBOL_P(name)) {
17282  return SYM2ID(name);
17283  }
17284  else if (!RB_TYPE_P(name, T_STRING)) {
17285  tmp = rb_check_string_type(name);
17286  if (NIL_P(tmp)) {
17287  tmp = rb_inspect(name);
17288  rb_raise(rb_eTypeError, "%s is not a symbol",
17289  RSTRING_PTR(tmp));
17290  }
17291  name = tmp;
17292  *namep = name;
17293  }
17294 
17296 
17298  return (ID)id;
17299 
17300  if (rb_is_attrset_name(name)) {
17301  struct RString fake_str;
17302  /* make local name by chopping '=' */
17303  const VALUE localname = setup_fake_str(&fake_str, RSTRING_PTR(name), RSTRING_LEN(name) - 1);
17304  rb_enc_copy(localname, name);
17305  OBJ_FREEZE(localname);
17306 
17307  if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17308  return rb_id_attrset((ID)id);
17309  }
17310  RB_GC_GUARD(name);
17311  }
17312 
17313  return (ID)0;
17314 }
17315 
17316 ID
17317 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
17318 {
17319  st_data_t id;
17320  struct RString fake_str;
17321  const VALUE name = setup_fake_str(&fake_str, ptr, len);
17322  rb_enc_associate(name, enc);
17323 
17325 
17327  return (ID)id;
17328 
17329  if (rb_is_attrset_name(name)) {
17330  fake_str.as.heap.len = len - 1;
17332  return rb_id_attrset((ID)id);
17333  }
17334  }
17335 
17336  return (ID)0;
17337 }
17338 
17339 int
17341 {
17342  return rb_str_symname_type(name, 0) == ID_CONST;
17343 }
17344 
17345 int
17347 {
17348  return rb_str_symname_type(name, 0) == ID_CLASS;
17349 }
17350 
17351 int
17353 {
17354  return rb_str_symname_type(name, 0) == ID_GLOBAL;
17355 }
17356 
17357 int
17359 {
17360  return rb_str_symname_type(name, 0) == ID_INSTANCE;
17361 }
17362 
17363 int
17365 {
17367 }
17368 
17369 int
17371 {
17372  return rb_str_symname_type(name, 0) == ID_LOCAL;
17373 }
17374 
17375 int
17377 {
17378  switch (rb_str_symname_type(name, 0)) {
17379  case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17380  return TRUE;
17381  }
17382  return FALSE;
17383 }
17384 
17385 int
17387 {
17389 }
17390 
17391 #endif /* !RIPPER */
17392 
17393 static void
17395 {
17396  parser->eofp = Qfalse;
17397 
17398  parser->parser_lex_strterm = 0;
17399  parser->parser_cond_stack = 0;
17400  parser->parser_cmdarg_stack = 0;
17401  parser->parser_class_nest = 0;
17402  parser->parser_paren_nest = 0;
17403  parser->parser_lpar_beg = 0;
17404  parser->parser_brace_nest = 0;
17405  parser->parser_in_single = 0;
17406  parser->parser_in_def = 0;
17407  parser->parser_in_defined = 0;
17408  parser->parser_in_kwarg = 0;
17409  parser->parser_compile_for_eval = 0;
17410  parser->parser_cur_mid = 0;
17411  parser->parser_tokenbuf = NULL;
17412  parser->parser_tokidx = 0;
17413  parser->parser_toksiz = 0;
17414  parser->parser_heredoc_end = 0;
17415  parser->parser_command_start = TRUE;
17416  parser->parser_deferred_nodes = 0;
17417  parser->parser_lex_pbeg = 0;
17418  parser->parser_lex_p = 0;
17419  parser->parser_lex_pend = 0;
17420  parser->parser_lvtbl = 0;
17421  parser->parser_ruby__end__seen = 0;
17422  parser->parser_ruby_sourcefile = 0;
17424 #ifndef RIPPER
17425  parser->is_ripper = 0;
17426  parser->parser_eval_tree_begin = 0;
17427  parser->parser_eval_tree = 0;
17428 #else
17429  parser->is_ripper = 1;
17430  parser->delayed = Qnil;
17431 
17432  parser->result = Qnil;
17433  parser->parsing_thread = Qnil;
17434  parser->toplevel_p = TRUE;
17435 #endif
17436 #ifdef YYMALLOC
17437  parser->heap = NULL;
17438 #endif
17439  parser->enc = rb_utf8_encoding();
17440 }
17441 
17442 #ifdef RIPPER
17443 #define parser_mark ripper_parser_mark
17444 #define parser_free ripper_parser_free
17445 #endif
17446 
17447 static void
17449 {
17450  struct parser_params *p = (struct parser_params*)ptr;
17451 
17458 #ifndef RIPPER
17461  rb_gc_mark(p->debug_lines);
17462 #else
17463  rb_gc_mark(p->delayed);
17464  rb_gc_mark(p->value);
17465  rb_gc_mark(p->result);
17466  rb_gc_mark(p->parsing_thread);
17467 #endif
17468 #ifdef YYMALLOC
17469  rb_gc_mark((VALUE)p->heap);
17470 #endif
17471 }
17472 
17473 static void
17474 parser_free(void *ptr)
17475 {
17476  struct parser_params *p = (struct parser_params*)ptr;
17477  struct local_vars *local, *prev;
17478 
17479  if (p->parser_tokenbuf) {
17480  xfree(p->parser_tokenbuf);
17481  }
17482  for (local = p->parser_lvtbl; local; local = prev) {
17483  if (local->vars) xfree(local->vars);
17484  prev = local->prev;
17485  xfree(local);
17486  }
17487  xfree(p);
17488 }
17489 
17490 static size_t
17491 parser_memsize(const void *ptr)
17492 {
17493  struct parser_params *p = (struct parser_params*)ptr;
17494  struct local_vars *local;
17495  size_t size = sizeof(*p);
17496 
17497  if (!ptr) return 0;
17498  size += p->parser_toksiz;
17499  for (local = p->parser_lvtbl; local; local = local->prev) {
17500  size += sizeof(*local);
17501  if (local->vars) size += local->vars->capa * sizeof(ID);
17502  }
17503  return size;
17504 }
17505 
17506 static
17507 #ifndef RIPPER
17508 const
17509 #endif
17511  "parser",
17512  {
17513  parser_mark,
17514  parser_free,
17516  },
17518 };
17519 
17520 #ifndef RIPPER
17521 #undef rb_reserved_word
17522 
17523 const struct kwtable *
17524 rb_reserved_word(const char *str, unsigned int len)
17525 {
17526  return reserved_word(str, len);
17527 }
17528 
17529 static struct parser_params *
17531 {
17532  struct parser_params *p;
17533 
17534  p = ALLOC_N(struct parser_params, 1);
17535  MEMZERO(p, struct parser_params, 1);
17536  parser_initialize(p);
17537  return p;
17538 }
17539 
17540 VALUE
17542 {
17543  struct parser_params *p = parser_new();
17544 
17545  return TypedData_Wrap_Struct(0, &parser_data_type, p);
17546 }
17547 
17548 /*
17549  * call-seq:
17550  * ripper#end_seen? -> Boolean
17551  *
17552  * Return true if parsed source ended by +\_\_END\_\_+.
17553  */
17554 VALUE
17556 {
17557  struct parser_params *parser;
17558 
17559  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17560  return ruby__end__seen ? Qtrue : Qfalse;
17561 }
17562 
17563 /*
17564  * call-seq:
17565  * ripper#encoding -> encoding
17566  *
17567  * Return encoding of the source.
17568  */
17569 VALUE
17571 {
17572  struct parser_params *parser;
17573 
17574  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17576 }
17577 
17578 /*
17579  * call-seq:
17580  * ripper.yydebug -> true or false
17581  *
17582  * Get yydebug.
17583  */
17584 VALUE
17586 {
17587  struct parser_params *parser;
17588 
17589  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17590  return yydebug ? Qtrue : Qfalse;
17591 }
17592 
17593 /*
17594  * call-seq:
17595  * ripper.yydebug = flag
17596  *
17597  * Set yydebug.
17598  */
17599 VALUE
17601 {
17602  struct parser_params *parser;
17603 
17604  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17605  yydebug = RTEST(flag);
17606  return flag;
17607 }
17608 
17609 #ifdef YYMALLOC
17610 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17611 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17612 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17613  (n)->u3.cnt = (c), (p))
17614 
17615 void *
17616 rb_parser_malloc(struct parser_params *parser, size_t size)
17617 {
17618  size_t cnt = HEAPCNT(1, size);
17619  NODE *n = NEWHEAP();
17620  void *ptr = xmalloc(size);
17621 
17622  return ADD2HEAP(n, cnt, ptr);
17623 }
17624 
17625 void *
17626 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17627 {
17628  size_t cnt = HEAPCNT(nelem, size);
17629  NODE *n = NEWHEAP();
17630  void *ptr = xcalloc(nelem, size);
17631 
17632  return ADD2HEAP(n, cnt, ptr);
17633 }
17634 
17635 void *
17636 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17637 {
17638  NODE *n;
17639  size_t cnt = HEAPCNT(1, size);
17640 
17641  if (ptr && (n = parser->heap) != NULL) {
17642  do {
17643  if (n->u1.node == ptr) {
17644  n->u1.node = ptr = xrealloc(ptr, size);
17645  if (n->u3.cnt) n->u3.cnt = cnt;
17646  return ptr;
17647  }
17648  } while ((n = n->u2.node) != NULL);
17649  }
17650  n = NEWHEAP();
17651  ptr = xrealloc(ptr, size);
17652  return ADD2HEAP(n, cnt, ptr);
17653 }
17654 
17655 void
17656 rb_parser_free(struct parser_params *parser, void *ptr)
17657 {
17658  NODE **prev = &parser->heap, *n;
17659 
17660  while ((n = *prev) != NULL) {
17661  if (n->u1.node == ptr) {
17662  *prev = n->u2.node;
17664  break;
17665  }
17666  prev = &n->u2.node;
17667  }
17668  xfree(ptr);
17669 }
17670 #endif
17671 #endif
17672 
17673 #ifdef RIPPER
17674 #ifdef RIPPER_DEBUG
17675 extern int rb_is_pointer_to_heap(VALUE);
17676 
17677 /* :nodoc: */
17678 static VALUE
17679 ripper_validate_object(VALUE self, VALUE x)
17680 {
17681  if (x == Qfalse) return x;
17682  if (x == Qtrue) return x;
17683  if (x == Qnil) return x;
17684  if (x == Qundef)
17685  rb_raise(rb_eArgError, "Qundef given");
17686  if (FIXNUM_P(x)) return x;
17687  if (SYMBOL_P(x)) return x;
17688  if (!rb_is_pointer_to_heap(x))
17689  rb_raise(rb_eArgError, "invalid pointer: %p", x);
17690  switch (BUILTIN_TYPE(x)) {
17691  case T_STRING:
17692  case T_OBJECT:
17693  case T_ARRAY:
17694  case T_BIGNUM:
17695  case T_FLOAT:
17696  case T_COMPLEX:
17697  case T_RATIONAL:
17698  return x;
17699  case T_NODE:
17700  if (nd_type(x) != NODE_LASGN) {
17701  rb_raise(rb_eArgError, "NODE given: %p", x);
17702  }
17703  return ((NODE *)x)->nd_rval;
17704  default:
17705  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17706  x, rb_obj_classname(x));
17707  }
17708  return x;
17709 }
17710 #endif
17711 
17712 #define validate(x) ((x) = get_value(x))
17713 
17714 static VALUE
17715 ripper_dispatch0(struct parser_params *parser, ID mid)
17716 {
17717  return rb_funcall(parser->value, mid, 0);
17718 }
17719 
17720 static VALUE
17721 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17722 {
17723  validate(a);
17724  return rb_funcall(parser->value, mid, 1, a);
17725 }
17726 
17727 static VALUE
17728 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17729 {
17730  validate(a);
17731  validate(b);
17732  return rb_funcall(parser->value, mid, 2, a, b);
17733 }
17734 
17735 static VALUE
17736 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17737 {
17738  validate(a);
17739  validate(b);
17740  validate(c);
17741  return rb_funcall(parser->value, mid, 3, a, b, c);
17742 }
17743 
17744 static VALUE
17745 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17746 {
17747  validate(a);
17748  validate(b);
17749  validate(c);
17750  validate(d);
17751  return rb_funcall(parser->value, mid, 4, a, b, c, d);
17752 }
17753 
17754 static VALUE
17755 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17756 {
17757  validate(a);
17758  validate(b);
17759  validate(c);
17760  validate(d);
17761  validate(e);
17762  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17763 }
17764 
17765 static VALUE
17766 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17767 {
17768  validate(a);
17769  validate(b);
17770  validate(c);
17771  validate(d);
17772  validate(e);
17773  validate(f);
17774  validate(g);
17775  return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17776 }
17777 
17778 static const struct kw_assoc {
17779  ID id;
17780  const char *name;
17781 } keyword_to_name[] = {
17782  {keyword_class, "class"},
17783  {keyword_module, "module"},
17784  {keyword_def, "def"},
17785  {keyword_undef, "undef"},
17786  {keyword_begin, "begin"},
17787  {keyword_rescue, "rescue"},
17788  {keyword_ensure, "ensure"},
17789  {keyword_end, "end"},
17790  {keyword_if, "if"},
17791  {keyword_unless, "unless"},
17792  {keyword_then, "then"},
17793  {keyword_elsif, "elsif"},
17794  {keyword_else, "else"},
17795  {keyword_case, "case"},
17796  {keyword_when, "when"},
17797  {keyword_while, "while"},
17798  {keyword_until, "until"},
17799  {keyword_for, "for"},
17800  {keyword_break, "break"},
17801  {keyword_next, "next"},
17802  {keyword_redo, "redo"},
17803  {keyword_retry, "retry"},
17804  {keyword_in, "in"},
17805  {keyword_do, "do"},
17806  {keyword_do_cond, "do"},
17807  {keyword_do_block, "do"},
17808  {keyword_return, "return"},
17809  {keyword_yield, "yield"},
17810  {keyword_super, "super"},
17811  {keyword_self, "self"},
17812  {keyword_nil, "nil"},
17813  {keyword_true, "true"},
17814  {keyword_false, "false"},
17815  {keyword_and, "and"},
17816  {keyword_or, "or"},
17817  {keyword_not, "not"},
17818  {modifier_if, "if"},
17819  {modifier_unless, "unless"},
17820  {modifier_while, "while"},
17821  {modifier_until, "until"},
17822  {modifier_rescue, "rescue"},
17823  {keyword_alias, "alias"},
17824  {keyword_defined, "defined?"},
17825  {keyword_BEGIN, "BEGIN"},
17826  {keyword_END, "END"},
17827  {keyword__LINE__, "__LINE__"},
17828  {keyword__FILE__, "__FILE__"},
17829  {keyword__ENCODING__, "__ENCODING__"},
17830  {0, NULL}
17831 };
17832 
17833 static const char*
17834 keyword_id_to_str(ID id)
17835 {
17836  const struct kw_assoc *a;
17837 
17838  for (a = keyword_to_name; a->id; a++) {
17839  if (a->id == id)
17840  return a->name;
17841  }
17842  return NULL;
17843 }
17844 
17845 #undef ripper_id2sym
17846 static VALUE
17847 ripper_id2sym(ID id)
17848 {
17849  const char *name;
17850  char buf[8];
17851 
17852  if (id <= 256) {
17853  buf[0] = (char)id;
17854  buf[1] = '\0';
17855  return ID2SYM(rb_intern2(buf, 1));
17856  }
17857  if ((name = keyword_id_to_str(id))) {
17858  return ID2SYM(rb_intern(name));
17859  }
17860  switch (id) {
17861  case tOROP:
17862  name = "||";
17863  break;
17864  case tANDOP:
17865  name = "&&";
17866  break;
17867  default:
17868  name = rb_id2name(id);
17869  if (!name) {
17870  rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17871  }
17872  return ID2SYM(id);
17873  }
17874  return ID2SYM(rb_intern(name));
17875 }
17876 
17877 static ID
17878 ripper_get_id(VALUE v)
17879 {
17880  NODE *nd;
17881  if (!RB_TYPE_P(v, T_NODE)) return 0;
17882  nd = (NODE *)v;
17883  if (nd_type(nd) != NODE_LASGN) return 0;
17884  return nd->nd_vid;
17885 }
17886 
17887 static VALUE
17888 ripper_get_value(VALUE v)
17889 {
17890  NODE *nd;
17891  if (v == Qundef) return Qnil;
17892  if (!RB_TYPE_P(v, T_NODE)) return v;
17893  nd = (NODE *)v;
17894  if (nd_type(nd) != NODE_LASGN) return Qnil;
17895  return nd->nd_rval;
17896 }
17897 
17898 static void
17899 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17900 {
17901  VALUE str;
17902  va_list args;
17903 
17904  va_start(args, fmt);
17905  str = rb_vsprintf(fmt, args);
17906  va_end(args);
17907  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17908 }
17909 
17910 static void
17911 ripper_warn0(struct parser_params *parser, const char *fmt)
17912 {
17913  rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
17914 }
17915 
17916 static void
17917 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
17918 {
17919  rb_funcall(parser->value, rb_intern("warn"), 2,
17920  STR_NEW2(fmt), INT2NUM(a));
17921 }
17922 
17923 static void
17924 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
17925 {
17926  rb_funcall(parser->value, rb_intern("warn"), 2,
17927  STR_NEW2(fmt), STR_NEW2(str));
17928 }
17929 
17930 static void
17931 ripper_warning0(struct parser_params *parser, const char *fmt)
17932 {
17933  rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
17934 }
17935 
17936 static void
17937 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
17938 {
17939  rb_funcall(parser->value, rb_intern("warning"), 2,
17940  STR_NEW2(fmt), STR_NEW2(str));
17941 }
17942 
17943 static VALUE
17944 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
17945 {
17946  return rb_io_gets(src);
17947 }
17948 
17949 static VALUE
17950 ripper_s_allocate(VALUE klass)
17951 {
17952  struct parser_params *p;
17953  VALUE self;
17954 
17955  p = ALLOC_N(struct parser_params, 1);
17956  MEMZERO(p, struct parser_params, 1);
17957  self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
17958  p->value = self;
17959  return self;
17960 }
17961 
17962 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
17963 
17964 /*
17965  * call-seq:
17966  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
17967  *
17968  * Create a new Ripper object.
17969  * _src_ must be a String, an IO, or an Object which has #gets method.
17970  *
17971  * This method does not starts parsing.
17972  * See also Ripper#parse and Ripper.parse.
17973  */
17974 static VALUE
17975 ripper_initialize(int argc, VALUE *argv, VALUE self)
17976 {
17977  struct parser_params *parser;
17978  VALUE src, fname, lineno;
17979 
17980  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17981  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
17982  if (RB_TYPE_P(src, T_FILE)) {
17983  parser->parser_lex_gets = ripper_lex_get_generic;
17984  }
17985  else {
17986  StringValue(src);
17987  parser->parser_lex_gets = lex_get_str;
17988  }
17989  parser->parser_lex_input = src;
17990  parser->eofp = Qfalse;
17991  if (NIL_P(fname)) {
17992  fname = STR_NEW2("(ripper)");
17993  }
17994  else {
17995  StringValue(fname);
17996  }
17997  parser_initialize(parser);
17998 
17999  parser->parser_ruby_sourcefile_string = fname;
18000  parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
18001  parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
18002 
18003  return Qnil;
18004 }
18005 
18006 struct ripper_args {
18007  struct parser_params *parser;
18008  int argc;
18009  VALUE *argv;
18010 };
18011 
18012 static VALUE
18013 ripper_parse0(VALUE parser_v)
18014 {
18015  struct parser_params *parser;
18016 
18017  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
18018  parser_prepare(parser);
18019  ripper_yyparse((void*)parser);
18020  return parser->result;
18021 }
18022 
18023 static VALUE
18024 ripper_ensure(VALUE parser_v)
18025 {
18026  struct parser_params *parser;
18027 
18028  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
18029  parser->parsing_thread = Qnil;
18030  return Qnil;
18031 }
18032 
18033 /*
18034  * call-seq:
18035  * ripper#parse
18036  *
18037  * Start parsing and returns the value of the root action.
18038  */
18039 static VALUE
18040 ripper_parse(VALUE self)
18041 {
18042  struct parser_params *parser;
18043 
18044  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18045  if (!ripper_initialized_p(parser)) {
18046  rb_raise(rb_eArgError, "method called for uninitialized object");
18047  }
18048  if (!NIL_P(parser->parsing_thread)) {
18049  if (parser->parsing_thread == rb_thread_current())
18050  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
18051  else
18052  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
18053  }
18054  parser->parsing_thread = rb_thread_current();
18055  rb_ensure(ripper_parse0, self, ripper_ensure, self);
18056 
18057  return parser->result;
18058 }
18059 
18060 /*
18061  * call-seq:
18062  * ripper#column -> Integer
18063  *
18064  * Return column number of current parsing line.
18065  * This number starts from 0.
18066  */
18067 static VALUE
18068 ripper_column(VALUE self)
18069 {
18070  struct parser_params *parser;
18071  long col;
18072 
18073  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18074  if (!ripper_initialized_p(parser)) {
18075  rb_raise(rb_eArgError, "method called for uninitialized object");
18076  }
18077  if (NIL_P(parser->parsing_thread)) return Qnil;
18078  col = parser->tokp - parser->parser_lex_pbeg;
18079  return LONG2NUM(col);
18080 }
18081 
18082 /*
18083  * call-seq:
18084  * ripper#filename -> String
18085  *
18086  * Return current parsing filename.
18087  */
18088 static VALUE
18089 ripper_filename(VALUE self)
18090 {
18091  struct parser_params *parser;
18092 
18093  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18094  if (!ripper_initialized_p(parser)) {
18095  rb_raise(rb_eArgError, "method called for uninitialized object");
18096  }
18097  return parser->parser_ruby_sourcefile_string;
18098 }
18099 
18100 /*
18101  * call-seq:
18102  * ripper#lineno -> Integer
18103  *
18104  * Return line number of current parsing line.
18105  * This number starts from 1.
18106  */
18107 static VALUE
18108 ripper_lineno(VALUE self)
18109 {
18110  struct parser_params *parser;
18111 
18112  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18113  if (!ripper_initialized_p(parser)) {
18114  rb_raise(rb_eArgError, "method called for uninitialized object");
18115  }
18116  if (NIL_P(parser->parsing_thread)) return Qnil;
18117  return INT2NUM(parser->parser_ruby_sourceline);
18118 }
18119 
18120 #ifdef RIPPER_DEBUG
18121 /* :nodoc: */
18122 static VALUE
18123 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
18124 {
18125  StringValue(msg);
18126  if (obj == Qundef) {
18128  }
18129  return Qnil;
18130 }
18131 
18132 /* :nodoc: */
18133 static VALUE
18134 ripper_value(VALUE self, VALUE obj)
18135 {
18136  return ULONG2NUM(obj);
18137 }
18138 #endif
18139 
18140 
18141 void
18142 Init_ripper(void)
18143 {
18145 
18148  /* ensure existing in symbol table */
18149  (void)rb_intern("||");
18150  (void)rb_intern("&&");
18151 
18152  InitVM(ripper);
18153 }
18154 
18155 void
18156 InitVM_ripper(void)
18157 {
18158  VALUE Ripper;
18159 
18160  Ripper = rb_define_class("Ripper", rb_cObject);
18161  /* version of Ripper */
18162  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
18163  rb_define_alloc_func(Ripper, ripper_s_allocate);
18164  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
18165  rb_define_method(Ripper, "parse", ripper_parse, 0);
18166  rb_define_method(Ripper, "column", ripper_column, 0);
18167  rb_define_method(Ripper, "filename", ripper_filename, 0);
18168  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
18169  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
18170  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
18171  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
18172  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
18173 #ifdef RIPPER_DEBUG
18174  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
18175  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
18176  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
18177 #endif
18178 
18181 
18182 # if 0
18183  /* Hack to let RDoc document SCRIPT_LINES__ */
18184 
18185  /*
18186  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
18187  * after the assignment will be added as an Array of lines with the file
18188  * name as the key.
18189  */
18190  rb_define_global_const("SCRIPT_LINES__", Qnil);
18191 #endif
18192 
18193 }
18194 #endif /* RIPPER */
18195 
#define STRNCASECMP(s1, s2, n)
Definition: ruby.h:1792
#define toklast()
Definition: parse.c:12186
RUBY_EXTERN VALUE rb_cString
Definition: ruby.h:1591
#define tokadd_mbchar(c)
Definition: parse.c:12546
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:2239
#define command_start
Definition: parse.c:395
char * parser_ruby_sourcefile
Definition: ripper.c:328
#define RBASIC_CLEAR_CLASS(obj)
Definition: internal.h:609
VALUE val
Definition: parse.h:166
#define YYFPRINTF
Definition: parse.c:4491
#define YYLAST
Definition: parse.c:1148
#define evstr2dstr(n)
Definition: parse.c:464
static const char id_type_names[][9]
Definition: parse.c:15361
#define T_OBJECT
Definition: ruby.h:477
Definition: node.h:93
Definition: node.h:29
static NODE * call_bin_op_gen(struct parser_params *, NODE *, ID, NODE *)
Definition: parse.c:15082
stack_type cmdargs
Definition: ripper.c:193
#define ISDIGIT(c)
Definition: ruby.h:1783
#define NEW_RETURN(s)
Definition: node.h:389
enum lex_state_e state
Definition: lex.c:33
struct local_vars * parser_lvtbl
Definition: ripper.c:324
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: parse.c:4735
VALUE rb_ary_unshift(VALUE ary, VALUE item)
Definition: array.c:1161
static ID ripper_token2eventid(int tok)
Definition: eventids2.c:279
static ID internal_id_gen(struct parser_params *)
Definition: parse.c:16743
Definition: lex.c:33
#define tokenbuf
Definition: parse.c:384
int rb_enc_codelen(int c, rb_encoding *enc)
Definition: encoding.c:1014
#define NEW_OP_ASGN_AND(i, val)
Definition: node.h:409
static double zero(void)
Definition: isinf.c:51
#define YY_REDUCE_PRINT(Rule)
Definition: parse.c:4637
#define shadowing_lvar(name)
Definition: parse.c:555
#define MBCLEN_CHARFOUND_P(ret)
Definition: encoding.h:139
static void arg_ambiguous_gen(struct parser_params *parser)
Definition: parse.c:13115
#define nextc()
Definition: parse.c:11557
static long parser_encode_length(struct parser_params *parser, const char *name, long len)
Definition: parse.c:13144
#define RE_OPTION_ENCODING_IDX(o)
Definition: parse.c:591
Definition: parse.c:872
#define NEW_OP_ASGN1(p, id, a)
Definition: node.h:405
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:17616
#define NEW_SCLASS(r, b)
Definition: node.h:448
#define lex_strterm
Definition: parse.c:371
static void Init_id(void)
Definition: id.c:14
#define RARRAY_LEN(a)
Definition: ruby.h:878
Definition: parse.c:880
void rb_bug(const char *fmt,...)
Definition: error.c:327
int num
Definition: parse.h:169
#define mixed_escape(beg, enc1, enc2)
static const yytype_uint8 yyr2[]
Definition: parse.c:1704
struct token_info * next
Definition: ripper.c:275
int rb_is_local_name(VALUE name)
Definition: parse.c:17370
static NODE * attrset_gen(struct parser_params *, NODE *, ID)
Definition: parse.c:15402
void rb_enc_copy(VALUE obj1, VALUE obj2)
Definition: encoding.c:916
#define FALSE
Definition: nkf.h:174
#define RUBY_TYPED_FREE_IMMEDIATELY
Definition: ruby.h:1015
static const struct kwtable * reserved_word(const char *, unsigned int)
#define NUM_SUFFIX_R
Definition: parse.c:12939
#define CMDARG_P()
Definition: parse.c:179
#define tail
Definition: st.c:108
int minor_marked
Definition: ripper.c:16765
#define heredoc_end
Definition: parse.c:394
static VALUE setup_fake_str(struct RString *fake_str, const char *name, long len)
Definition: parse.c:16948
#define NEW_LIST(a)
Definition: node.h:391
int rb_is_class_name(VALUE name)
Definition: parse.c:17346
struct vtable * used
Definition: ripper.c:191
#define tHEREDOC_BEG
Definition: eventids2.c:7
#define pushback(c)
Definition: parse.c:11558
#define rb_gc_mark_locations(start, end)
Definition: gc.c:3319
size_t strlen(const char *)
#define INT2NUM(x)
Definition: ruby.h:1296
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2580
int rb_is_attrset_name(VALUE name)
Definition: parse.c:17364
VALUE parser_lex_nextline
Definition: ripper.c:315
VALUE rb_make_exception(int argc, VALUE *argv)
Definition: eval.c:682
#define is_const_id(id)
Definition: parse.c:113
#define scan_oct(s, l, e)
Definition: util.h:50
#define nd_plen
Definition: node.h:333
#define compile_error
Definition: parse.c:729
#define T_FIXNUM
Definition: ruby.h:489
Definition: st.h:69
static NODE * negate_lit(NODE *)
Definition: parse.c:15989
VALUE stack_type
Definition: ripper.c:164
#define toklen()
Definition: parse.c:12185
#define new_yield(node)
Definition: parse.c:482
#define dispatch_heredoc_end()
Definition: parse.c:13006
static NODE * node_assign_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15474
Definition: node.h:47
#define NEW_XSTR(s)
Definition: node.h:425
int parser_ruby__end__seen
Definition: ripper.c:325
static void local_push_gen(struct parser_params *, int)
Definition: parse.c:16210
static int vtable_size(const struct vtable *tbl)
Definition: parse.c:202
#define formal_argument(id)
Definition: parse.c:553
int parser_command_start
Definition: ripper.c:320
#define set_number_literal(v, t, f)
Definition: parse.c:11574
const struct kwtable * rb_reserved_word(const char *str, unsigned int len)
Definition: parse.c:17524
VALUE rb_range_new(VALUE, VALUE, int)
Definition: range.c:70
#define YY_STACK_PRINT(Bottom, Top)
Definition: parse.c:4598
static NODE * arg_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15423
#define NUM2INT(x)
Definition: ruby.h:630
static const struct @132 op_tbl[]
#define is_notop_id(id)
Definition: parse.c:108
ID rb_check_id(volatile VALUE *namep)
Returns ID for the given name if it is interned already, or 0.
Definition: parse.c:17275
#define NEW_DOT2(b, e)
Definition: node.h:453
#define tokfix()
Definition: parse.c:12183
static NODE * evstr2dstr_gen(struct parser_params *, NODE *)
Definition: parse.c:15059
#define local_pop()
Definition: parse.c:562
static void yy_reduce_print(YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
Definition: parse.c:4615
static int nodeline(NODE *node)
Definition: parse.c:14824
static int token_info_has_nonspaces(struct parser_params *parser, const char *token)
Definition: parse.c:11692
#define malloc
Definition: parse.c:96
#define local_var(id)
Definition: parse.c:564
static NODE * arg_blk_pass(NODE *, NODE *)
Definition: parse.c:16020
#define IS_LABEL_POSSIBLE()
Definition: parse.c:13454
#define is_asgn_or_id(id)
Definition: parse.c:118
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:16401
#define POINTER_P(val)
Definition: parse.c:199
int parser_compile_for_eval
Definition: ripper.c:305
int parser_token_info_enabled
Definition: ripper.c:345
#define parser_precise_mbclen()
Definition: parse.c:11670
static ID formal_argument_gen(struct parser_params *, ID)
Definition: parse.c:13126
#define rb_usascii_str_new2
Definition: intern.h:846
RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20+31)/32]
Definition: parse.c:12717
static int parser_read_escape(struct parser_params *parser, int flags, rb_encoding **encp)
Definition: parse.c:12319
#define internal_id()
Definition: parse.c:570
int parser_brace_nest
Definition: ripper.c:304
static VALUE reg_compile_gen(struct parser_params *, VALUE, int)
Definition: parse.c:16534
#define InitVM(ext)
Definition: ruby.h:1797
static ID register_symid(ID, const char *, long, rb_encoding *)
Definition: parse.c:16905
unsigned short int yytype_uint16
Definition: parse.c:953
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:2139
#define lex_nextline
Definition: parse.c:390
ID rb_intern_str(VALUE str)
Definition: parse.c:17101
Definition: id.h:94
#define nd_line(n)
Definition: node.h:288
#define Qtrue
Definition: ruby.h:426
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2357
#define RE_OPTION_ENCODING(e)
Definition: parse.c:590
NODE * rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
Definition: parse.c:16595
Definition: id.h:91
#define yyparse
Definition: parse.c:421
#define DVARS_TOPSCOPE
Definition: parse.c:197
#define set_yylval_str(x)
Definition: parse.c:11578
static const yytype_uint16 yyr1[]
Definition: parse.c:1636
#define gettable(id)
Definition: parse.c:487
#define set_yylval_literal(x)
Definition: parse.c:11582
#define TypedData_Wrap_Struct(klass, data_type, sval)
Definition: ruby.h:1027
#define yytable_value_is_error(yytable_value)
Definition: parse.c:3169
#define IDSET_ATTRSET_FOR_SYNTAX
Definition: parse.c:16789
#define YYPOPSTACK(N)
Definition: parse.c:864
#define ADD2HEAP(n, c, p)
Definition: parse.c:17612
VALUE rb_parser_encoding(VALUE vparser)
Definition: parse.c:17570
#define TypedData_Get_Struct(obj, type, data_type, sval)
Definition: ruby.h:1041
#define literal_concat(h, t)
Definition: parse.c:459
int parser_in_kwarg
Definition: ripper.c:307
const int id
Definition: nkf.c:209
static void block_dup_check_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15354
int line_count
Definition: ripper.c:326
union RString::@109 as
stack_type parser_cmdarg_stack
Definition: ripper.c:298
node_type
Definition: node.h:22
#define strcasecmp
Definition: win32.h:220
#define STR_NEW2(p)
Definition: parse.c:363
Definition: parse.c:849
static int lvar_defined_gen(struct parser_params *, ID)
Definition: parse.c:13137
Definition: parse.c:877
#define ID_CONST
Definition: id.h:35
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:390
#define tokspace(n)
Definition: parse.c:11560
VALUE rb_enc_from_encoding(rb_encoding *encoding)
Definition: encoding.c:102
int rb_is_method_name(VALUE name)
Definition: parse.c:17376
static ID * local_tbl_gen(struct parser_params *)
Definition: parse.c:16243
VALUE rb_eTypeError
Definition: error.c:548
#define rb_warnI(fmt, a)
Definition: parse.c:703
NODE * node
Definition: parse.h:167
#define T_RATIONAL
Definition: ruby.h:495
#define PARSER_ARG
Definition: parse.c:730
st_table * names
Definition: encoding.c:50
#define new_defined(expr)
Definition: parse.c:507
#define ID_JUNK
Definition: id.h:37
#define ULONG2NUM(x)
Definition: ruby.h:1327
#define lvar_defined(id)
Definition: parse.c:586
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:900
#define rb_long2int(n)
Definition: ruby.h:317
ID rb_intern3(const char *name, long len, rb_encoding *enc)
Definition: parse.c:16959
#define NEW_CLASS(n, b, s)
Definition: node.h:447
#define current_enc
Definition: parse.c:404
#define lex_pbeg
Definition: parse.c:391
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:113
#define MAX_WORD_LENGTH
Definition: lex.c:43
VALUE rb_eEncodingError
Definition: error.c:554
NODE * rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
Definition: parse.c:12045
#define SYM2ID(x)
Definition: ruby.h:356
#define subnodes(n1, n2)
#define yydebug
Definition: parse.c:405
struct RBasic basic
Definition: ruby.h:821
#define YYSTACK_BYTES(N)
Definition: parse.c:1101
#define nd_term(node)
Definition: parse.c:603
unsigned short int yytype_uint16
Definition: ripper.c:953
static int parser_yylex(struct parser_params *parser)
Definition: parse.c:13492
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:849
#define new_args_tail(k, kr, b)
Definition: parse.c:475
Definition: parse.c:870
#define NEW_OPT_N(b)
Definition: node.h:375
#define CMDARG_LEXPOP()
Definition: parse.c:178
static NODE * remove_begin_all(NODE *)
Definition: parse.c:15675
static NODE * new_evstr_gen(struct parser_params *, NODE *)
Definition: parse.c:15068
VALUE op_sym[tLAST_OP_ID]
Definition: ripper.c:16764
int rb_is_junk_name(VALUE name)
Definition: parse.c:17386
VALUE debug_lines
Definition: ripper.c:341
static int parser_regx_options(struct parser_params *)
Definition: parse.c:12490
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
Definition: vm_eval.c:781
ID id
Definition: parse.h:168
static VALUE coverage(VALUE fname, int n)
Definition: parse.c:11832
static int rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset)
Definition: parse.c:16793
static void set_file_encoding(struct parser_params *parser, const char *str, const char *send)
Definition: parse.c:13383
static NODE * newline_node(NODE *)
Definition: parse.c:14830
int rb_enc_str_coderange(VALUE)
Definition: string.c:435
static void ripper_init_eventids1_table(VALUE self)
Definition: eventids1.c:270
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1857
Definition: parse.c:850
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: parse.c:4500
#define RE_OPTION_ONCE
Definition: parse.c:588
#define NEW_NIL()
Definition: node.h:456
static const yytype_uint16 yyprhs[]
Definition: parse.c:1210
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Definition: ruby.h:854
#define block_dup_check(n1, n2)
Definition: parse.c:446
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
Definition: encoding.c:826
static void warn_unused_var(struct parser_params *parser, struct local_vars *local)
Definition: parse.c:16190
ID * tbl
Definition: ripper.c:182
const rb_data_type_t * parent
Definition: ruby.h:975
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:179
#define attrset(node, id)
Definition: parse.c:494
int pre_args_num
Definition: node.h:514
#define RB_GC_GUARD(v)
Definition: ruby.h:523
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
#define T_HASH
Definition: ruby.h:485
#define new_const_op_assign(lhs, op, rhs)
Definition: parse.c:505
int parser_toksiz
Definition: ripper.c:311
static NODE * assignable_gen(struct parser_params *, ID, NODE *)
Definition: parse.c:15208
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
Definition: encoding.c:946
#define ID_LOCAL
Definition: id.h:31
st_index_t rb_str_hash(VALUE)
Definition: string.c:2421
#define nd_args
Definition: node.h:337
Definition: parse.c:892
#define nd_set_type(n, t)
Definition: node.h:283
ID last_id
Definition: ripper.c:16757
static size_t parser_memsize(const void *ptr)
Definition: parse.c:17491
static NODE * new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: parse.c:16110
static void fixpos(NODE *, NODE *)
Definition: parse.c:14840
unsigned long ruby_scan_digits(const char *str, ssize_t len, int base, size_t *retlen, int *overflow)
Definition: util.c:79
void rb_gc_mark(VALUE ptr)
Definition: gc.c:3607
#define lex_pend
Definition: parse.c:393
static NODE * gettable_gen(struct parser_params *, ID)
Definition: parse.c:15131
#define T_ARRAY
Definition: ruby.h:484
#define NEW_DOT3(b, e)
Definition: node.h:454
#define nd_paren(node)
Definition: parse.c:605
#define cmdarg_stack
Definition: parse.c:374
#define rb_enc_islower(c, enc)
Definition: encoding.h:180
static struct symbols global_symbols
#define is_class_id(id)
Definition: parse.c:114
static NODE * cond0(struct parser_params *, NODE *)
Definition: parse.c:15877
#define NEW_ITER(a, b)
Definition: node.h:379
#define STR_NEW0()
Definition: parse.c:362
void rb_gc_mark_parser(void)
Definition: parse.c:16558
#define reg_compile(str, options)
Definition: parse.c:518
NODE * pre_init
Definition: node.h:511
static int local_var_gen(struct parser_params *, ID)
Definition: parse.c:16275
#define str_copy(_s, _p, _n)
#define NEW_IVAR(v)
Definition: node.h:414
unsigned int last
Definition: nkf.c:4310
static NODE * match_op_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15097
ID block_arg
Definition: node.h:520
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
Definition: parse.c:4584
struct RNode * node
Definition: node.h:243
#define NEW_IASGN(v, val)
Definition: node.h:400
#define FIXNUM_P(f)
Definition: ruby.h:347
rb_encoding * rb_utf8_encoding(void)
Definition: encoding.c:1257
static int rb_str_symname_type(VALUE name, unsigned int allowed_attrset)
Definition: parse.c:16895
VALUE parser_lex_input
Definition: ripper.c:313
static int dvar_defined_gen(struct parser_params *, ID, int)
Definition: parse.c:16362
#define nd_type(n)
Definition: node.h:282
static NODE * new_yield_gen(struct parser_params *, NODE *)
Definition: parse.c:15981
#define RE_OPTION_ENCODING_NONE(o)
Definition: parse.c:592
#define YYNTOKENS
Definition: parse.c:1151
static char * parser_tokspace(struct parser_params *parser, int n)
Definition: parse.c:12205
Definition: parse.c:869
int rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
Definition: parse.c:16889
#define tokadd_string(f, t, p, n, e)
Definition: parse.c:11566
#define paren_nest
Definition: parse.c:376
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2281
#define number_literal_suffix(f)
Definition: parse.c:11573
#define is_identchar(p, e, enc)
Definition: parse.c:11671
#define RUBY_DTRACE_PARSE_BEGIN(arg0, arg1)
Definition: probes.h:55
int pos
Definition: ripper.c:183
VALUE parser_ruby_sourcefile_string
Definition: ripper.c:330
union RNode::@131 u3
Definition: parse.c:833
Definition: parse.c:893
static void parser_heredoc_restore(struct parser_params *parser, NODE *here)
Definition: parse.c:12903
static NODE * remove_begin(NODE *)
Definition: parse.c:15665
NODE * rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: parse.c:12004
#define ENC_CODERANGE_7BIT
Definition: encoding.h:49
const char * rb_obj_classname(VALUE)
Definition: variable.c:406
static int parser_set_integer_literal(struct parser_params *parser, VALUE v, int suffix)
Definition: parse.c:12984
void rb_gc_force_recycle(VALUE p)
Definition: gc.c:4900
#define lex_lastline
Definition: parse.c:389
#define rb_ary_new2
Definition: intern.h:90
#define NEW_SCOPE(a, b)
Definition: node.h:369
#define head
Definition: st.c:107
#define tok_hex(numlen)
Definition: parse.c:11562
RUBY_EXTERN void * memmove(void *, const void *, size_t)
Definition: memmove.c:7
unsigned char OnigUChar
Definition: oniguruma.h:111
int parser_yydebug
Definition: ripper.c:333
#define NUM_SUFFIX_I
Definition: parse.c:12940
Definition: node.h:27
st_table * id_str
Definition: ripper.c:16759
static const yytype_int16 yytable[]
Definition: parse.c:2053
NODE * parser_eval_tree
Definition: ripper.c:340
NODE * parser_deferred_nodes
Definition: ripper.c:321
#define sym(x)
Definition: date_core.c:3695
VALUE rb_str_buf_cat(VALUE, const char *, long)
Definition: string.c:2123
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
Definition: st.h:20
void rb_name_error(ID id, const char *fmt,...)
Definition: error.c:967
static int dyna_in_block_gen(struct parser_params *)
Definition: parse.c:16356
static const rb_data_type_t parser_data_type
Definition: parse.c:11975
Definition: node.h:239
#define YYSYNTAX_ERROR
#define YYABORT
Definition: parse.c:4403
Definition: parse.h:161
int has_shebang
Definition: ripper.c:327
#define logop(type, node1, node2)
Definition: parse.c:429
static rb_encoding * must_be_ascii_compatible(VALUE s)
Definition: parse.c:11925
#define ISALPHA(c)
Definition: ruby.h:1782
static void dyna_pop_1(struct parser_params *parser)
Definition: parse.c:16324
void rb_exc_raise(VALUE mesg)
Definition: eval.c:567
#define in_single
Definition: parse.c:379
#define NEW_VCALL(m)
Definition: node.h:431
static NODE * new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: parse.c:16155
#define strtod(s, e)
Definition: util.h:74
#define parser_warn(node, mesg)
Definition: parse.c:14860
struct vtable * prev
Definition: ripper.c:185
#define RBASIC_SET_CLASS_RAW(obj, cls)
Definition: internal.h:610
#define NEW_VALIAS(n, o)
Definition: node.h:445
#define RUBY_DTRACE_PARSE_END(arg0, arg1)
Definition: probes.h:58
#define RB_TYPE_P(obj, type)
Definition: ruby.h:1672
#define NEW_LVAR(v)
Definition: node.h:412
static void warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: parse.c:15797
int st_lookup(st_table *, st_data_t, st_data_t *)
#define NEW_ATTRASGN(r, m, a)
Definition: node.h:464
#define MEMZERO(p, type, n)
Definition: ruby.h:1359
#define toksiz
Definition: parse.c:386
Definition: ruby.h:820
int rb_is_instance_name(VALUE name)
Definition: parse.c:17358
#define ID_SCOPE_MASK
Definition: id.h:30
rb_encoding * enc
Definition: ripper.c:331
static void parser_free(void *ptr)
Definition: parse.c:17474
#define free
Definition: parse.c:99
enum lex_state_e parser_lex_state
Definition: ripper.c:296
int rb_is_local_id(ID id)
Definition: parse.c:17252
#define lex_gets
Definition: parse.c:398
#define NEW_POSTEXE(b)
Definition: node.h:462
int capa
Definition: ripper.c:184
VALUE parser_lex_lastline
Definition: ripper.c:314
void * rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
Definition: parse.c:17636
#define void_expr(node)
Definition: parse.c:440
static void parser_initialize(struct parser_params *parser)
Definition: parse.c:17394
int t(void)
Definition: conftest.c:13
#define scan_hex(s, l, e)
Definition: util.h:52
static void parser_set_encode(struct parser_params *parser, const char *name)
Definition: parse.c:13164
#define NEW_IF(c, t, e)
Definition: node.h:371
#define local_id(id)
Definition: parse.c:568
#define here_document(n)
Definition: parse.c:11569
#define lex_goto_eol(parser)
Definition: parse.c:12104
#define rb_rational_raw1(x)
Definition: intern.h:167
#define RARRAY(obj)
Definition: ruby.h:1123
#define ruby_sourcefile
Definition: parse.c:402
#define ALLOC_N(type, n)
Definition: ruby.h:1341
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
Definition: hash.c:1402
void rb_compile_error_append(const char *fmt,...)
Definition: error.c:157
void rb_compile_error_with_enc(const char *file, int line, void *enc, const char *fmt,...)
Definition: error.c:133
VALUE rb_parser_get_yydebug(VALUE self)
Definition: parse.c:17585
#define YYTRANSLATE(YYX)
Definition: parse.c:1163
#define NEW_PRELUDE(p, b)
Definition: node.h:465
#define val
int rb_ispunct(int c)
Definition: encoding.c:1946
Definition: parse.c:843
#define NEW_ARRAY(a)
Definition: node.h:392
#define tokidx
Definition: parse.c:385
RUBY_EXTERN VALUE rb_cObject
Definition: ruby.h:1561
VALUE rb_eRuntimeError
Definition: error.c:547
#define match_op(node1, node2)
Definition: parse.c:510
static enum node_type nodetype(NODE *node)
Definition: parse.c:14818
#define NEW_STRTERM(func, term, paren)
Definition: parse.c:12695
#define ID_INSTANCE
Definition: id.h:32
static const struct magic_comment magic_comments[]
Definition: parse.c:13248
#define rb_enc_isascii(c, enc)
Definition: encoding.h:178
#define CMDARG_PUSH(n)
Definition: parse.c:176
#define reg_named_capture_assign(regexp, match)
Definition: parse.c:524
#define arg_concat(h, t)
Definition: parse.c:457
void rb_str_free(VALUE)
Definition: string.c:941
struct parser_params * parser
Definition: ripper.c:16544
static void magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
Definition: parse.c:13212
static int parser_number_literal_suffix(struct parser_params *parser, int mask)
Definition: parse.c:12944
#define RE_OPTION_MASK
Definition: parse.c:593
void * rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
Definition: parse.c:17626
#define NEW_HASH(a)
Definition: node.h:394
#define DEF_EXPR(n)
Definition: parse.c:140
VALUE rb_get_coverages(void)
Definition: thread.c:5297
static int e_option_supplied(struct parser_params *parser)
Definition: parse.c:11848
union RNode::@130 u2
#define NEW_ZARRAY()
Definition: node.h:393
static struct vtable * vtable_alloc(struct vtable *prev)
Definition: parse.c:215
#define NEW_FALSE()
Definition: node.h:458
#define token_info_push(token)
Definition: parse.c:745
VALUE rb_obj_as_string(VALUE)
Definition: string.c:1011
int parser_paren_nest
Definition: ripper.c:300
VALUE rb_ary_new(void)
Definition: array.c:499
#define YY_(msgid)
Definition: parse.c:986
#define NODE_HEREDOC
Definition: parse.c:597
#define NEW_ARGSPUSH(a, b)
Definition: node.h:439
#define VTBL_DEBUG
Definition: parse.c:212
#define cond_stack
Definition: parse.c:373
static int is_special_global_name(const char *m, const char *e, rb_encoding *enc)
Definition: parse.c:16752
static const yytype_uint16 yyrline[]
Definition: parse.c:1474
#define NEW_REDO()
Definition: node.h:383
#define NEW_NTH_REF(n)
Definition: node.h:417
#define NEW_UNLESS(c, t, e)
Definition: node.h:372
RUBY_EXTERN VALUE rb_mKernel
Definition: ruby.h:1549
#define snprintf
Definition: subst.h:6
VALUE rb_thread_current(void)
Definition: thread.c:2405
#define IS_SPCARG(c)
Definition: parse.c:13453
#define set_yylval_id(x)
Definition: parse.c:11580
NODE * rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
Definition: parse.c:12051
#define NIL_P(v)
Definition: ruby.h:438
#define ISASCII(c)
Definition: ruby.h:1774
void st_add_direct(st_table *, st_data_t, st_data_t)
Definition: st.c:629
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:611
static char msg[50]
Definition: strerror.c:8
#define NEW_GVAR(v)
Definition: node.h:411
NODE * opt_args
Definition: node.h:525
int rb_is_attrset_id(ID id)
Definition: parse.c:17246
static int reg_fragment_check_gen(struct parser_params *, VALUE, int)
Definition: parse.c:16440
#define NEW_YIELD(a)
Definition: node.h:390
#define YYSTACK_ALLOC
Definition: parse.c:1054
static NODE * dsym_node_gen(struct parser_params *, NODE *)
Definition: parse.c:16083
#define STR_FUNC_REGEXP
Definition: parse.c:12071
NODE * rb_compile_string(const char *f, VALUE s, int line)
Definition: parse.c:11997
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:2228
#define ID_SCOPE_SHIFT
Definition: id.h:29
static NODE * new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
Definition: parse.c:16139
#define k__END__
Definition: eventids2.c:9
#define ISALNUM(c)
Definition: ruby.h:1781
#define NEW_CASE(h, b)
Definition: node.h:373
rb_atomic_t cnt[RUBY_NSIG]
Definition: signal.c:496
#define RFLOAT(obj)
Definition: ruby.h:1120
static void no_blockarg(struct parser_params *parser, NODE *node)
Definition: parse.c:15956
Definition: parse.c:839
union RNode::@129 u1
static double one(void)
Definition: isinf.c:52
Definition: parse.c:837
static NODE * splat_array(NODE *)
Definition: parse.c:15466
Definition: parse.c:874
#define FLONUM_P(x)
Definition: ruby.h:367
static void parser_mark(void *ptr)
Definition: parse.c:17448
#define T_FLOAT
Definition: ruby.h:481
static void parser_tokadd(struct parser_params *parser, int c)
Definition: parse.c:12217
#define is_local_id(id)
Definition: parse.c:109
static YYSIZE_T yystrlen(char *yystr) const
Definition: parse.c:4686
#define LVAR_USED
Definition: parse.c:15297
#define TYPE(x)
Definition: ruby.h:505
static void ripper_init_eventids1(void)
Definition: eventids1.c:134
int argc
Definition: ruby.c:131
Definition: node.h:59
static int sym_check_asciionly(VALUE str)
Definition: parse.c:16928
yytype_int16 yyss_alloc
Definition: ripper.c:1092
static ID intern_str(VALUE str)
Definition: parse.c:16975
Definition: parse.c:862
#define STR_FUNC_INDENT
Definition: parse.c:12074
char ary[RSTRING_EMBED_LEN_MAX+1]
Definition: ruby.h:831
#define Qfalse
Definition: ruby.h:425
#define rb_sourcefile()
Definition: tcltklib.c:98
#define NEW_EVSTR(n)
Definition: node.h:428
#define arg_append(h, t)
Definition: parse.c:455
VALUE rb_rational_new(VALUE, VALUE)
Definition: rational.c:1762
static VALUE lex_get_str(struct parser_params *parser, VALUE s)
Definition: parse.c:11935
#define ALLOCA_N(type, n)
Definition: ruby.h:1345
static int assign_in_cond(struct parser_params *parser, NODE *node)
Definition: parse.c:15770
#define op_tbl_count
Definition: parse.c:16660
#define warn_balanced(op, syn)
Definition: parse.c:13465
#define tokadd(c)
Definition: parse.c:11561
#define NEW_OP_CDECL(v, op, val)
Definition: node.h:410
#define no_digits()
#define peek_n(c, n)
Definition: parse.c:12107
#define T_BIGNUM
Definition: ruby.h:487
#define ENC_CODERANGE_UNKNOWN
Definition: encoding.h:48
#define YYFINAL
Definition: parse.c:1146
#define ISUPPER(c)
Definition: ruby.h:1779
static void void_expr_gen(struct parser_params *, NODE *)
Definition: parse.c:15562
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:16462
#define RUBY_FUNC_EXPORTED
Definition: defines.h:246
#define MEMCPY(p1, p2, type, n)
Definition: ruby.h:1360
#define T_NODE
Definition: ruby.h:498
#define ENC_CODERANGE_BROKEN
Definition: encoding.h:51
Definition: parse.c:879
#define rb_enc_isupper(c, enc)
Definition: encoding.h:181
VALUE rb_enc_associate_index(VALUE obj, int idx)
Definition: encoding.c:798
int rb_parse_in_main(void)
Definition: compile.c:6020
static VALUE debug_lines(VALUE fname)
Definition: parse.c:11816
#define YYCASE_(N, S)
int err
Definition: win32.c:114
#define IS_AFTER_OPERATOR()
Definition: parse.c:13456
Definition: parse.c:855
#define OBJ_FREEZE(x)
Definition: ruby.h:1194
const char * parser_lex_pend
Definition: ripper.c:318
static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
Definition: parse.c:12410
#define T_COMPLEX
Definition: ruby.h:496
#define nd_else
Definition: node.h:300
#define IDSET_ATTRSET_FOR_INTERN
Definition: parse.c:16790
#define set_yylval_num(x)
Definition: parse.c:11579
long cnt
Definition: node.h:261
Definition: util.c:796
#define parser_encoding_name()
Definition: parse.c:11668
token_info * parser_token_info
Definition: ripper.c:346
#define new_op_assign(lhs, op, rhs)
Definition: parse.c:550
int column
Definition: ripper.c:273
#define YYSIZE_T
Definition: parse.c:972
#define numberof(array)
Definition: etc.c:602
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:817
#define ALLOC(type)
Definition: ruby.h:1342
#define END(no)
Definition: re.c:26
#define NEW_FOR(v, i, b)
Definition: node.h:378
#define brace_nest
Definition: parse.c:378
#define EOF
Definition: vsnprintf.c:207
static NODE * list_append_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14917
#define NEW_WHEN(c, t, e)
Definition: node.h:374
static const yytype_int16 yycheck[]
Definition: parse.c:3172
VALUE rb_str_resize(VALUE, long)
Definition: string.c:2024
static int literal_node(NODE *node)
Definition: parse.c:15856
static int dvar_curr_gen(struct parser_params *, ID)
Definition: parse.c:16393
#define tHEREDOC_END
Definition: eventids2.c:8
#define NEW_DASGN(v, val)
Definition: node.h:398
YYSTYPE yyvs_alloc
Definition: ripper.c:1093
#define flush_string_content(enc)
Definition: parse.c:12714
int rb_str_hash_cmp(VALUE, VALUE)
Definition: string.c:2431
#define NEW_ERRINFO()
Definition: node.h:459
#define NEW_BLOCK_PASS(b)
Definition: node.h:443
Definition: parse.c:856
string_type
Definition: ripper.c:12166
int rb_dvar_defined(ID id)
Definition: compile.c:5970
#define RSTRING_LEN(str)
Definition: ruby.h:841
int parser_in_single
Definition: ripper.c:302
lex_state_bits
Definition: ripper.c:123
#define ret_args(node)
Definition: parse.c:479
static int parser_yyerror(struct parser_params *, const char *)
Definition: parse.c:11751
#define RUBY_DTRACE_PARSE_END_ENABLED()
Definition: probes.h:57
#define COND_LEXPOP()
Definition: parse.c:173
ID rest_arg
Definition: node.h:519
#define REALLOC_N(var, type, n)
Definition: ruby.h:1343
static const yytype_int16 yypgoto[]
Definition: parse.c:2024
int errno
#define TRUE
Definition: nkf.h:175
static int parser_tokadd_mbchar(struct parser_params *parser, int c)
Definition: parse.c:12533
#define nd_next
Definition: node.h:296
#define NEW_CONST(v)
Definition: node.h:415
int rb_symname_p(const char *name)
Definition: parse.c:16778
#define COND_POP()
Definition: parse.c:172
#define TOK_INTERN(mb)
Definition: parse.c:366
#define NEW_LIT(l)
Definition: node.h:422
VALUE rb_io_gets(VALUE)
Definition: io.c:3189
int rb_is_junk_id(ID id)
Definition: parse.c:17258
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1250
#define set_integer_literal(v, f)
Definition: parse.c:11575
#define COND_P()
Definition: parse.c:174
#define ruby_coverage
Definition: parse.c:411
#define NEW_OP_ASGN_OR(i, val)
Definition: node.h:408
static void yydestruct(char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser) const
Definition: parse.c:4922
#define rb_enc_isspace(c, enc)
Definition: encoding.h:185
#define ruby_sourcefile_string
Definition: parse.c:403
#define NEW_NEXT(s)
Definition: node.h:382
#define rb_warnS(fmt, a)
Definition: parse.c:704
#define parser_warning(node, mesg)
Definition: parse.c:14853
#define mixed_error(enc1, enc2)
#define rb_enc_name(enc)
Definition: encoding.h:125
#define value_expr(node)
Definition: parse.c:438
#define rb_warning0(fmt)
Definition: parse.c:706
#define reg_fragment_setenc(str, options)
Definition: parse.c:520
static int value_expr_gen(struct parser_params *, NODE *)
Definition: parse.c:15505
static const yytype_int16 yyrhs[]
Definition: parse.c:1278
const char * rb_id2name(ID id)
Definition: parse.c:17181
static int parser_whole_match_p(struct parser_params *parser, const char *eos, long len, int indent)
Definition: parse.c:12921
#define NEW_RESCUE(b, res, e)
Definition: node.h:386
#define YYDPRINTF(Args)
Definition: parse.c:4494
static const char * magic_comment_marker(const char *str, long len)
Definition: parse.c:13256
#define rb_warn0(fmt)
Definition: parse.c:702
rb_magic_comment_length_t length
Definition: ripper.c:13335
int parser_in_def
Definition: ripper.c:303
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1719
static const yytype_uint8 yytranslate[]
Definition: parse.c:1167
#define new_bv(id)
Definition: parse.c:557
#define YYEMPTY
Definition: parse.c:4399
#define YYSTACK_FREE
Definition: parse.c:1055
#define YYID(n)
Definition: parse.c:999
VALUE parser_cur_mid
Definition: ripper.c:306
VALUE stack_type
Definition: parse.c:164
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4308
short int yytype_int16
Definition: ripper.c:959
Definition: parse.c:834
Definition: parse.c:876
#define PRIsVALUE
Definition: ruby.h:137
static char * parser_newtok(struct parser_params *parser)
Definition: parse.c:12189
long parser_lex_gets_ptr
Definition: ripper.c:322
unsigned long ID
Definition: ruby.h:89
static void fixup_nodes(NODE **)
Definition: parse.c:15809
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1272
#define rb_enc_isalnum(c, enc)
Definition: encoding.h:183
#define dyna_pop(node)
Definition: parse.c:575
#define rb_enc_isdigit(c, enc)
Definition: encoding.h:186
unsigned char yytype_uint8
Definition: ripper.c:938
#define nd_resq
Definition: node.h:304
#define list_concat(h, t)
Definition: parse.c:453
#define dyna_in_block()
Definition: parse.c:577
#define Qnil
Definition: ruby.h:427
#define dyna_var(id)
Definition: parse.c:578
#define NEW_BACK_REF(n)
Definition: node.h:418
Definition: parse.c:867
#define STR_FUNC_ESCAPE
Definition: parse.c:12069
int type
Definition: tcltklib.c:112
int id[2]
Definition: lex.c:33
#define NODE_FL_NEWLINE
Definition: node.h:275
static int options(unsigned char *cp)
Definition: nkf.c:6357
#define NEW_MASGN(l, r)
Definition: node.h:395
#define heredoc_restore(n)
Definition: parse.c:11571
#define BUILTIN_TYPE(x)
Definition: ruby.h:502
#define NEW_COLON2(c, i)
Definition: node.h:450
unsigned long VALUE
Definition: ruby.h:88
#define yyerror(msg)
Definition: parse.c:369
#define peek(c)
Definition: parse.c:12106
stack_type parser_cond_stack
Definition: ripper.c:297
#define IS_lex_state_for(x, ls)
Definition: parse.c:157
static VALUE result
Definition: nkf.c:40
NODE * post_init
Definition: node.h:512
static NODE * arg_append_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15448
static void ripper_init_eventids2(void)
Definition: eventids2.c:66
#define RBASIC(obj)
Definition: ruby.h:1116
#define heredoc_identifier()
Definition: parse.c:11570
int parser_heredoc_end
Definition: ripper.c:319
#define rb_enc_ispunct(c, enc)
Definition: encoding.h:182
#define NEW_KW_ARG(i, v)
Definition: node.h:436
static VALUE parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
Definition: parse.c:12088
#define ripper_flush(p)
Definition: parse.c:11601
void rb_mark_tbl(st_table *tbl)
Definition: gc.c:3522
#define dsym_node(node)
Definition: parse.c:484
#define regx_options()
Definition: parse.c:11565
int post_args_num
Definition: node.h:515
static int parser_magic_comment(struct parser_params *parser, const char *str, long len)
Definition: parse.c:13289
#define NEW_ENSURE(b, en)
Definition: node.h:388
yytokentype
Definition: parse.c:780
#define token_info_pop(token)
Definition: parse.c:746
static int arg_var_gen(struct parser_params *, ID)
Definition: parse.c:16268
#define call_bin_op(recv, id, arg1)
Definition: parse.c:468
#define rb_warn4S(file, line, fmt, a)
Definition: parse.c:705
#define NEW_ZSUPER()
Definition: node.h:433
#define rb_enc_asciicompat(enc)
Definition: encoding.h:188
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
Definition: eval.c:839
VALUE flags
Definition: ruby.h:748
static VALUE yycompile0(VALUE arg)
Definition: parse.c:11854
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Definition: re.c:333
#define NEW_COLON3(i)
Definition: node.h:451
#define NEW_BLOCK(a)
Definition: node.h:370
#define Qnone
Definition: parse.c:694
#define assignable_result(x)
static int parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
Definition: parse.c:12417
static int parser_tokadd_string(struct parser_params *, int, int, int, long *, rb_encoding **)
Definition: parse.c:12562
#define nd_body
Definition: node.h:299
VALUE flags
Definition: node.h:240
VALUE rb_fstring(VALUE)
Definition: string.c:201
const char * token
Definition: ripper.c:271
#define ENCODING_IS_ASCII8BIT(obj)
Definition: encoding.h:43
VALUE rb_str_dup(VALUE)
Definition: string.c:1062
#define dvar_defined_get(id)
Definition: parse.c:581
#define RUBY_DTRACE_PARSE_BEGIN_ENABLED()
Definition: probes.h:54
#define rb_enc_isalpha(c, enc)
Definition: encoding.h:179
static NODE * new_args_gen(struct parser_params *, NODE *, NODE *, ID, NODE *, NODE *)
Definition: parse.c:16031
#define ruby_sourceline
Definition: parse.c:401
#define is_global_id(id)
Definition: parse.c:110
#define lex_input
Definition: parse.c:388
Definition: parse.c:857
#define STR_FUNC_QWORDS
Definition: parse.c:12072
static int vtable_included(const struct vtable *tbl, ID id)
Definition: parse.c:254
ID rb_intern(const char *name)
Definition: parse.c:17095
int parser_in_defined
Definition: ripper.c:308
static int parser_set_number_literal(struct parser_params *parser, VALUE v, int type, int suffix)
Definition: parse.c:12973
#define ruby_eval_tree
Definition: parse.c:408
#define LONG2NUM(x)
Definition: ruby.h:1317
int parser_class_nest
Definition: ripper.c:299
ID token
Definition: parse.c:16636
static VALUE lex_io_gets(struct parser_params *parser, VALUE io)
Definition: parse.c:12031
NODE * rb_compile_cstr(const char *f, const char *s, int len, int line)
Definition: parse.c:12017
#define parser_is_identchar()
Definition: parse.c:11672
#define NEW_BEGIN(b)
Definition: node.h:385
#define ruby__end__seen
Definition: parse.c:400
#define dvar_curr(id)
Definition: parse.c:583
#define set_yylval_node(x)
Definition: parse.c:11583
static void yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: parse.c:4523
static void vtable_free(struct vtable *tbl)
Definition: parse.c:227
#define RSTRING_PTR(str)
Definition: ruby.h:845
#define NEW_SPLAT(a)
Definition: node.h:440
#define reg_fragment_check(str, options)
Definition: parse.c:522
#define RARRAY_ASET(a, i, v)
Definition: ruby.h:902
const struct vtable * vars
Definition: parse.h:170
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:2133
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:38
#define lex_state
Definition: parse.c:372
#define arg_ambiguous()
Definition: parse.c:13123
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:832
RUBY_EXTERN int ffs(int)
Definition: ffs.c:6
static void reduce_nodes_gen(struct parser_params *, NODE **)
Definition: parse.c:15685
#define RFLOAT_VALUE(v)
Definition: ruby.h:814
int nonspc
Definition: ripper.c:274
int size
Definition: encoding.c:49
#define YYSTACK_ALLOC_MAXIMUM
Definition: parse.c:1057
#define NEW_DSTR(s)
Definition: node.h:424
#define newtok()
Definition: parse.c:11559
#define f
#define yylval
Definition: parse.c:11548
#define INT2FIX(i)
Definition: ruby.h:231
#define set_yylval_name(x)
Definition: parse.c:11581
#define NEW_GASGN(v, val)
Definition: node.h:396
#define NEW_BREAK(s)
Definition: node.h:381
int rb_sourceline(void)
Definition: vm.c:1001
Definition: parse.c:852
static NODE * reg_named_capture_assign_gen(struct parser_params *parser, VALUE regexp, NODE *match)
Definition: parse.c:16502
static void parser_pushback(struct parser_params *parser, int c)
Definition: parse.c:12172
int rb_enc_symname_p(const char *name, rb_encoding *enc)
Definition: parse.c:16784
#define RARRAY_AREF(a, i)
Definition: ruby.h:901
int parser_tokidx
Definition: ripper.c:310
static const yytype_uint16 yydefact[]
Definition: parse.c:1774
Definition: node.h:45
#define lpar_beg
Definition: parse.c:377
static int parser_here_document(struct parser_params *, NODE *)
Definition: parse.c:13010
VALUE rb_int_positive_pow(long x, unsigned long y)
Definition: numeric.c:3056
#define YYUSE(e)
Definition: parse.c:992
#define COND_PUSH(n)
Definition: parse.c:171
#define xmalloc
Definition: defines.h:108
int rb_is_const_name(VALUE name)
Definition: parse.c:17340
static NODE * ret_args_gen(struct parser_params *, NODE *)
Definition: parse.c:15964
#define YYACCEPT
Definition: parse.c:4402
VALUE coverage
Definition: ripper.c:342
void rb_set_errinfo(VALUE err)
Definition: eval.c:1517
#define lex_gets_ptr
Definition: parse.c:397
#define NEW_TRUE()
Definition: node.h:457
static void dyna_pop_gen(struct parser_params *, const struct vtable *)
Definition: parse.c:16342
NODE * parser_lex_strterm
Definition: ripper.c:295
int rb_is_global_id(ID id)
Definition: parse.c:17234
const char * name
Definition: parse.c:16637
const char * name
Definition: ripper.c:13333
static void local_pop_gen(struct parser_params *)
Definition: parse.c:16227
#define RUBY_DTRACE_SYMBOL_CREATE_ENABLED()
Definition: probes.h:51
#define tSP
Definition: eventids2.c:6
#define NEW_LAMBDA(a, b)
Definition: node.h:380
VALUE rb_complex_raw(VALUE x, VALUE y)
Definition: complex.c:1319
#define IS_lex_state(ls)
Definition: parse.c:158
static int simple_re_meta(int c)
Definition: parse.c:12549
Definition: node.h:207
#define NEW_UNTIL(c, b, n)
Definition: node.h:377
#define lvtbl
Definition: parse.c:399
#define new_attr_op_assign(lhs, type, attr, op, rhs)
Definition: parse.c:503
#define aryset(node1, node2)
Definition: parse.c:492
#define NEW_MODULE(n, b)
Definition: node.h:449
static const struct st_hash_type symhash
Definition: parse.c:16678
#define list_append(l, i)
Definition: parse.c:451
#define tokaddmbc(c, enc)
Definition: parse.c:11568
short int yytype_int16
Definition: parse.c:959
#define cur_mid
Definition: parse.c:382
#define STR_NEW3(p, n, e, func)
Definition: parse.c:364
#define IS_BEG()
Definition: parse.c:13452
rb_magic_comment_setter_t func
Definition: ripper.c:13334
static const yytype_int16 yypact[]
Definition: parse.c:1913
#define dvar_defined(id)
Definition: parse.c:580
int parser_lpar_beg
Definition: ripper.c:301
#define ESCAPE_CONTROL
Definition: parse.c:12315
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:192
VALUE rb_check_string_type(VALUE)
Definition: string.c:1678
st_table * sym_id
Definition: ripper.c:16758
static void warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: parse.c:15803
#define yypact_value_is_default(yystate)
Definition: parse.c:3166
Definition: parse.c:860
uint8_t key[16]
Definition: random.c:1250
static int symbols_i(VALUE sym, ID value, VALUE ary)
Definition: parse.c:17190
#define nd_head
Definition: node.h:294
struct local_vars * prev
Definition: ripper.c:192
#define IS_END()
Definition: parse.c:13451
static void parser_prepare(struct parser_params *parser)
Definition: parse.c:13426
#define LONG2FIX(i)
Definition: ruby.h:232
ID rb_id_attrset(ID id)
Definition: parse.c:15373
static struct parser_params * parser_new(void)
Definition: parse.c:17530
#define NEW_WHILE(c, b, n)
Definition: node.h:376
struct vtable * vars
Definition: ripper.c:190
#define RTEST(v)
Definition: ruby.h:437
static void yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: parse.c:4557
Definition: node.h:139
#define new_args(f, o, r, p, t)
Definition: parse.c:473
#define T_STRING
Definition: ruby.h:482
static void rb_backref_error_gen(struct parser_params *, NODE *)
Definition: parse.c:15410
VALUE rb_id2str(ID id)
Definition: parse.c:17111
#define NEW_POSTARG(i, v)
Definition: node.h:437
#define YYINITDEPTH
Definition: parse.c:4658
#define RREGEXP(obj)
Definition: ruby.h:1122
static NODE * logop_gen(struct parser_params *, enum node_type, NODE *, NODE *)
Definition: parse.c:15941
VALUE rb_parser_new(void)
Definition: parse.c:17541
static void void_stmts_gen(struct parser_params *, NODE *)
Definition: parse.c:15651
#define ENC_SINGLE(cr)
Definition: parse.c:365
static int parse_numvar(struct parser_params *parser)
Definition: parse.c:13471
#define NEW_UNDEF(i)
Definition: node.h:446
struct rb_encoding_entry * list
Definition: encoding.c:47
static const yytype_int16 yydefgoto[]
Definition: parse.c:1885
static NODE * parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
Definition: parse.c:11978
#define parse_string(n)
Definition: parse.c:11567
#define ID_ATTRSET
Definition: id.h:34
#define T_FILE
Definition: ruby.h:488
#define NEWHEAP()
Definition: parse.c:17611
#define NEW_CVASGN(v, val)
Definition: node.h:403
static int yylex(void *, void *)
Definition: parse.c:14783
#define NEW_FCALL(m, a)
Definition: node.h:430
Definition: parse.c:854
int linenum
Definition: ripper.c:272
#define YYEOF
Definition: parse.c:4400
#define tEMBDOC
Definition: eventids2.c:4
int rb_is_global_name(VALUE name)
Definition: parse.c:17352
#define NEW_OP_ASGN2(r, i, o, val)
Definition: node.h:406
#define NEW_MATCH3(r, n2)
Definition: node.h:421
#define deferred_nodes
Definition: parse.c:396
Definition: parse.c:873
long(* rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len)
Definition: parse.c:13208
char * parser_tokenbuf
Definition: ripper.c:309
#define node_assign(node1, node2)
Definition: parse.c:499
#define get_id(id)
Definition: parse.c:526
VALUE rb_cArray
Definition: array.c:27
#define NEW_OPT_ARG(i, v)
Definition: node.h:435
#define BEG(no)
Definition: re.c:25
short int yytype_int8
Definition: parse.c:947
static unsigned int hash(const char *str, unsigned int len)
Definition: lex.c:56
#define id_type(id)
Definition: parse.c:116
int parser_tokline
Definition: ripper.c:312
#define RUBY_DTRACE_SYMBOL_CREATE(arg0, arg1, arg2)
Definition: probes.h:52
#define YYTERROR
Definition: parse.c:4441
static int parser_parse_string(struct parser_params *, NODE *)
Definition: parse.c:12782
#define tok()
Definition: parse.c:12184
#define cond(node)
Definition: parse.c:427
VALUE rb_filesystem_str_new_cstr(const char *)
Definition: string.c:737
#define ruby_eval_tree_begin
Definition: parse.c:409
#define is_instance_id(id)
Definition: parse.c:111
NODE * rb_parser_append_print(VALUE vparser, NODE *node)
Definition: parse.c:16563
ID rb_intern2(const char *name, long len)
Definition: parse.c:17088
const char * parser_lex_pbeg
Definition: ripper.c:316
static NODE * cond_gen(struct parser_params *, NODE *)
Definition: parse.c:15934
NODE * rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
Definition: parse.c:12024
static int shadowing_lvar_0(struct parser_params *parser, ID name)
Definition: parse.c:15300
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
Definition: string.c:548
#define rb_safe_level()
Definition: tcltklib.c:95
static NODE * list_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14937
Definition: ripper.c:181
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:1886
static int is_global_name_punct(const int c)
Definition: parse.c:12739
#define NUM_SUFFIX_ALL
Definition: parse.c:12941
static int is_private_local_id(ID name)
Definition: parse.c:15287
#define lex_p
Definition: parse.c:392
static int comment_at_top(struct parser_params *parser)
Definition: parse.c:13196
const char * parser_lex_p
Definition: ripper.c:317
static void dispose_string(VALUE str)
Definition: parse.c:12526
Definition: parse.c:851
#define xrealloc
Definition: defines.h:111
static int parser_nextc(struct parser_params *parser)
Definition: parse.c:12110
lex_state_e
Definition: ripper.c:139
#define read_escape(flags, e)
Definition: parse.c:11563
#define parser_isascii()
Definition: parse.c:11674
#define ID2SYM(x)
Definition: ruby.h:355
static const char *const yytname[]
Definition: parse.c:1545
Definition: node.h:61
static char * yystpcpy(char *yydest, const char *yysrc)
Definition: parse.c:4710
int parser_ruby_sourceline
Definition: ripper.c:329
#define NEW_RETRY()
Definition: node.h:384
#define call_uni_op(recv, id)
Definition: parse.c:470
#define rb_errinfo()
Definition: tcltklib.c:90
static ID register_symid_str(ID, VALUE)
Definition: parse.c:16912
#define StringValuePtr(v)
Definition: ruby.h:540
struct RString::@109::@110 heap
#define STR_FUNC_SYMBOL
Definition: parse.c:12073
#define nd_value
Definition: node.h:324
#define DVARS_INHERIT
Definition: parse.c:196
#define ID_INTERNAL
Definition: id.h:38
Definition: parse.c:861
static ID shadowing_lvar_gen(struct parser_params *, ID)
Definition: parse.c:15325
YYSTYPE * parser_yylval
Definition: ripper.c:292
VALUE rb_str_new_frozen(VALUE)
Definition: string.c:833
static int token_info_get_column(struct parser_params *parser, const char *token)
Definition: parse.c:11678
unsigned char yytype_uint8
Definition: parse.c:938
void(* rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val)
Definition: parse.c:13209
static NODE * yycompile(struct parser_params *parser, VALUE fname, int line)
Definition: parse.c:11915
#define NEW_RESBODY(a, ex, n)
Definition: node.h:387
Definition: parse.c:863
#define NEW_ARGSCAT(a, b)
Definition: node.h:438
#define arg_var(id)
Definition: parse.c:566
#define NEW_DASGN_CURR(v, val)
Definition: node.h:399
VALUE rb_inspect(VALUE)
Definition: object.c:470
#define is_junk_id(id)
Definition: parse.c:115
static void vtable_add(struct vtable *tbl, ID id)
Definition: parse.c:239
int rb_is_class_id(ID id)
Definition: parse.c:17228
#define NEW_SUPER(a)
Definition: node.h:432
#define NEW_CALL(r, m, a)
Definition: node.h:429
static const yytype_uint16 yystos[]
Definition: parse.c:4287
static int is_static_content(NODE *node)
Definition: parse.c:15746
int is_ripper
Definition: ripper.c:289
#define in_defined
Definition: parse.c:383
rb_encoding * rb_ascii8bit_encoding(void)
Definition: encoding.c:1242
int rb_enc_find_index(const char *name)
Definition: encoding.c:684
VALUE eofp
Definition: ripper.c:293
static NODE * aryset_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:15346
VALUE rb_parser_end_seen_p(VALUE vparser)
Definition: parse.c:17555
static int parser_heredoc_identifier(struct parser_params *parser)
Definition: parse.c:12840
Definition: node.h:31
int rb_is_const_id(ID id)
Definition: parse.c:17222
static int parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp, int string_literal, int symbol_literal, int regexp_literal)
Definition: parse.c:12244
long len
Definition: ruby.h:824
static const struct vtable * dyna_push_gen(struct parser_params *)
Definition: parse.c:16313
#define CONST_ID(var, str)
Definition: ruby.h:1436
NODE * heap
Definition: ripper.c:290
static NODE * block_append_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14863
VALUE rb_str_intern(VALUE)
Definition: string.c:7467
#define NEW_CVAR(v)
Definition: node.h:416
#define tokline
Definition: parse.c:387
#define ESCAPE_META
Definition: parse.c:12316
#define local_push(top)
Definition: parse.c:560
void void xfree(void *)
Definition: parse.c:878
#define NEW_MATCH2(n1, n2)
Definition: node.h:420
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: parse.c:17600
static void new_bv_gen(struct parser_params *, ID)
Definition: parse.c:15332
#define assignable(id, node)
Definition: parse.c:489
ID first_post_arg
Definition: node.h:517
st_table * st_init_numtable_with_size(st_index_t)
Definition: st.c:278
Definition: parse.c:866
VALUE rb_cstr_to_inum(const char *str, int base, int badcheck)
Definition: bignum.c:3963
static NODE * range_op(struct parser_params *parser, NODE *node)
Definition: parse.c:15840
#define ruby_debug_lines
Definition: parse.c:410
Definition: id.h:84
#define rb_enc_mbcput(c, buf, enc)
Definition: encoding.h:165
#define IS_ARG()
Definition: parse.c:13450
#define NEW_DVAR(v)
Definition: node.h:413
#define NEW_DEFN(i, a, d, p)
Definition: node.h:366
static int parser_tok_hex(struct parser_params *parser, size_t *numlen)
Definition: parse.c:12227
#define new_evstr(n)
Definition: parse.c:462
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
Definition: parse.c:17317
int rb_parse_in_eval(void)
Definition: compile.c:6014
NODE * rb_compile_file(const char *f, VALUE file, int start)
Definition: parse.c:12037
VALUE rb_str_buf_new(long)
Definition: string.c:891
VALUE rb_usascii_str_new(const char *, long)
Definition: string.c:540
#define lex_eol_p()
Definition: parse.c:12105
#define rb_node_newnode(type, a1, a2, a3)
Definition: parse.c:424
#define SYMBOL_P(x)
Definition: ruby.h:354
#define tCOMMENT
Definition: eventids2.c:2
int last_cr_line
Definition: ripper.c:335
NODE * kw_args
Definition: node.h:522
#define nd_iter
Definition: node.h:322
#define nd_set_line(n, l)
Definition: node.h:289
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1244
Definition: parse.c:848
#define void_stmts(node)
Definition: parse.c:442
#define block_append(h, t)
Definition: parse.c:449
VALUE(* parser_lex_gets)(struct parser_params *, VALUE)
Definition: ripper.c:323
#define NULL
Definition: _sdbm.c:102
#define compile_for_eval
Definition: parse.c:381
#define RTYPEDDATA_TYPE(v)
Definition: ruby.h:995
#define NEW_LASGN(v, val)
Definition: node.h:397
struct token_info token_info
#define FIX2LONG(x)
Definition: ruby.h:345
#define Qundef
Definition: ruby.h:428
static NODE * literal_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: parse.c:14978
#define tIGNORED_NL
Definition: eventids2.c:1
#define yyerrok
Definition: parse.c:4397
#define NEW_STR(s)
Definition: node.h:423
static NODE * call_uni_op_gen(struct parser_params *, NODE *, ID)
Definition: parse.c:15090
#define YYMAXDEPTH
Definition: parse.c:4669
static int literal_concat0(struct parser_params *, VALUE, VALUE)
Definition: parse.c:14961
int rb_is_instance_id(ID id)
Definition: parse.c:17240
void rb_parser_free(struct parser_params *parser, void *ptr)
Definition: parse.c:17656
Definition: parse.c:847
NODE * kw_rest_arg
Definition: node.h:523
#define ID_GLOBAL
Definition: id.h:33
#define in_def
Definition: parse.c:380
#define ISXDIGIT(c)
Definition: ruby.h:1784
#define ENCODING_SET(obj, i)
Definition: encoding.h:35
int rb_local_defined(ID id)
Definition: compile.c:5995
st_index_t num_entries
Definition: st.h:85
Definition: parse.c:858
#define IS_LABEL_SUFFIX(n)
Definition: parse.c:13455
#define NEW_SELF()
Definition: node.h:455
Definition: parse.c:832
NODE * parser_eval_tree_begin
Definition: ripper.c:339
static int match(VALUE str, VALUE pat, VALUE hash, int(*cb)(VALUE, VALUE))
Definition: date_parse.c:273
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1479
Definition: parse.c:865
#define ruby_verbose
Definition: ruby.h:1483
VALUE rb_str_append(VALUE, VALUE)
Definition: string.c:2297
#define rb_ascii8bit_encindex()
Definition: internal.h:402
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
Definition: st.c:1034
static void parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
Definition: parse.c:13221
#define NEW_NODE(t, a0, a1, a2)
Definition: node.h:364
#define NEW_ARGS_AUX(r, b)
Definition: node.h:434
#define RSTRING_NOEMBED
Definition: ruby.h:834
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:80
#define NEW_ALIAS(n, o)
Definition: node.h:444
NODE * rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
Definition: parse.c:12010
#define ifndef_ripper(x)
Definition: parse.c:695
#define YYLEX
Definition: parse.c:4483
static VALUE lex_getline(struct parser_params *parser)
Definition: parse.c:11955
VALUE rb_sym_all_symbols(void)
Definition: parse.c:17213
VALUE rb_eArgError
Definition: error.c:549
#define nd_lit
Definition: node.h:327
#define rb_enc_prev_char(s, p, e, enc)
Definition: encoding.h:168
#define T_REGEXP
Definition: ruby.h:483
#define tokadd_escape(e)
Definition: parse.c:11564
static NODE * node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE)
Definition: parse.c:14810
Definition: node.h:137
#define dyna_push()
Definition: parse.c:573
#define whole_match_p(e, l, i)
Definition: parse.c:11572
#define was_bol()
Definition: parse.c:12181
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:4783
#define HEAPCNT(n, size)
Definition: parse.c:17610
#define STR_FUNC_EXPAND
Definition: parse.c:12070
static int parser_peek_variable_name(struct parser_params *parser)
Definition: parse.c:12746
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1127
#define is_attrset_id(id)
Definition: parse.c:112
struct vtable * args
Definition: ripper.c:189
static int local_id_gen(struct parser_params *, ID)
Definition: parse.c:16285
#define SPECIAL_PUNCT(idx)
Definition: parse.c:12722
#define NEW_CDECL(v, val, path)
Definition: node.h:402
void rb_gc_mark_symbols(int full_mark)
Definition: parse.c:16730
#define rb_backref_error(n)
Definition: parse.c:497
#define NEW_DEFS(r, i, a, d)
Definition: node.h:367
char ** argv
Definition: ruby.c:132
#define tEMBDOC_END
Definition: eventids2.c:5
char * ptr
Definition: ruby.h:825
#define DBL2NUM(dbl)
Definition: ruby.h:815
static void ripper_init_eventids2_table(VALUE self)
Definition: eventids2table.c:2
Definition: parse.c:859
#define ISSPACE(c)
Definition: ruby.h:1778
#define StringValue(v)
Definition: ruby.h:539
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:2250
#define STR_NEW(p, n)
Definition: parse.c:361
static NODE * new_args_tail_gen(struct parser_params *, NODE *, ID, ID)
Definition: parse.c:16053
#define rb_warningS(fmt, a)
Definition: parse.c:707
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: parse.c:1112
#define reduce_nodes(n)
Definition: parse.c:444
#define void_expr0(node)
Definition: parse.c:439
rb_encoding * rb_enc_from_index(int index)
Definition: encoding.c:590
#define tokcopy(n)
Definition: parse.c:12240
void Init_sym(void)
Definition: parse.c:16711
VALUE rb_str_new(const char *, long)
Definition: string.c:534
Definition: parse.c:836
#define xcalloc
Definition: defines.h:110
#define ID_CLASS
Definition: id.h:36
Definition: parse.c:853