Ruby  2.1.3p242(2014-09-19revision47630)
ripper.c
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 2.5. */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
6 
7  This program is free software: you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation, either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 /* As a special exception, you may create a larger work that contains
21  part or all of the Bison parser skeleton and distribute that work
22  under terms of your choice, so long as that work isn't itself a
23  parser generator using the skeleton or a modified version thereof
24  as a parser skeleton. Alternatively, if you modify or redistribute
25  the parser skeleton itself, you may (at your option) remove this
26  special exception, which will cause the skeleton and the resulting
27  Bison output files to be licensed under the GNU General Public
28  License without this special exception.
29 
30  This special exception was added by the Free Software Foundation in
31  version 2.2 of Bison. */
32 
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34  simplifying the original so-called "semantic" parser. */
35 
36 /* All symbols defined below should begin with yy or YY, to avoid
37  infringing on user name space. This should be done even for local
38  variables, as they might otherwise be expanded by user macros.
39  There are some unavoidable exceptions within include files to
40  define necessary library symbols; they are noted "INFRINGES ON
41  USER NAME SPACE" below. */
42 
43 /* Identify Bison output. */
44 #define YYBISON 1
45 
46 /* Bison version. */
47 #define YYBISON_VERSION "2.5"
48 
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51 
52 /* Pure parsers. */
53 #define YYPURE 1
54 
55 /* Push parsers. */
56 #define YYPUSH 0
57 
58 /* Pull parsers. */
59 #define YYPULL 1
60 
61 /* Using locations. */
62 #define YYLSP_NEEDED 0
63 
64 
65 
66 /* Copy the first part of user declarations. */
67 
68 /* Line 268 of yacc.c */
69 #line 12 "ripper.y"
70 
71 
72 #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 
123 enum lex_state_bits {
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. */
136  EXPR_MAX_STATE
137 };
138 /* examine combinations */
139 enum lex_state_e {
140 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
141  DEF_EXPR(BEG),
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 
164 typedef VALUE stack_type;
165 
166 # define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
167 # define BITSTACK_POP(stack) ((stack) = (stack) >> 1)
168 # define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
169 # define BITSTACK_SET_P(stack) ((stack)&1)
170 
171 #define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n))
172 #define COND_POP() BITSTACK_POP(cond_stack)
173 #define COND_LEXPOP() BITSTACK_LEXPOP(cond_stack)
174 #define COND_P() BITSTACK_SET_P(cond_stack)
175 
176 #define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n))
177 #define CMDARG_POP() BITSTACK_POP(cmdarg_stack)
178 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
179 #define CMDARG_P() BITSTACK_SET_P(cmdarg_stack)
180 
181 struct vtable {
182  ID *tbl;
183  int pos;
184  int capa;
185  struct vtable *prev;
186 };
187 
188 struct local_vars {
189  struct vtable *args;
190  struct vtable *vars;
191  struct vtable *used;
192  struct local_vars *prev;
193  stack_type cmdargs;
194 };
195 
196 #define DVARS_INHERIT ((void*)1)
197 #define DVARS_TOPSCOPE NULL
198 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
199 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
200 
201 static int
202 vtable_size(const struct vtable *tbl)
203 {
204  if (POINTER_P(tbl)) {
205  return tbl->pos;
206  }
207  else {
208  return 0;
209  }
210 }
211 
212 #define VTBL_DEBUG 0
213 
214 static struct vtable *
215 vtable_alloc(struct vtable *prev)
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
227 vtable_free(struct vtable *tbl)
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 
292  YYSTYPE *parser_yylval;
293  VALUE eofp;
294 
295  NODE *parser_lex_strterm;
296  enum lex_state_e parser_lex_state;
297  stack_type parser_cond_stack;
298  stack_type parser_cmdarg_stack;
299  int parser_class_nest;
300  int parser_paren_nest;
301  int parser_lpar_beg;
302  int parser_in_single;
303  int parser_in_def;
304  int parser_brace_nest;
305  int parser_compile_for_eval;
306  VALUE parser_cur_mid;
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;
313  VALUE parser_lex_input;
314  VALUE parser_lex_lastline;
315  VALUE parser_lex_nextline;
316  const char *parser_lex_pbeg;
317  const char *parser_lex_p;
318  const char *parser_lex_pend;
319  int parser_heredoc_end;
320  int parser_command_start;
321  NODE *parser_deferred_nodes;
322  long parser_lex_gets_ptr;
323  VALUE (*parser_lex_gets)(struct parser_params*,VALUE);
324  struct local_vars *parser_lvtbl;
325  int parser_ruby__end__seen;
326  int line_count;
327  int has_shebang;
328  char *parser_ruby_sourcefile; /* current source file */
329  int parser_ruby_sourceline; /* current line no. */
330  VALUE parser_ruby_sourcefile_string;
331  rb_encoding *enc;
332 
333  int parser_yydebug;
334 
335  int last_cr_line;
336 
337 #ifndef RIPPER
338  /* Ruby core only */
339  NODE *parser_eval_tree_begin;
340  NODE *parser_eval_tree;
341  VALUE debug_lines;
342  VALUE coverage;
343  int nerr;
344 
345  int parser_token_info_enabled;
346  token_info *parser_token_info;
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 1
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 {
781  END_OF_INPUT = 0,
782  keyword_class = 258,
783  keyword_module = 259,
784  keyword_def = 260,
785  keyword_undef = 261,
786  keyword_begin = 262,
787  keyword_rescue = 263,
788  keyword_ensure = 264,
789  keyword_end = 265,
790  keyword_if = 266,
791  keyword_unless = 267,
792  keyword_then = 268,
793  keyword_elsif = 269,
794  keyword_else = 270,
795  keyword_case = 271,
796  keyword_when = 272,
797  keyword_while = 273,
798  keyword_until = 274,
799  keyword_for = 275,
800  keyword_break = 276,
801  keyword_next = 277,
802  keyword_redo = 278,
803  keyword_retry = 279,
804  keyword_in = 280,
805  keyword_do = 281,
806  keyword_do_cond = 282,
807  keyword_do_block = 283,
808  keyword_do_LAMBDA = 284,
809  keyword_return = 285,
810  keyword_yield = 286,
811  keyword_super = 287,
812  keyword_self = 288,
813  keyword_nil = 289,
814  keyword_true = 290,
815  keyword_false = 291,
816  keyword_and = 292,
817  keyword_or = 293,
818  keyword_not = 294,
819  modifier_if = 295,
820  modifier_unless = 296,
821  modifier_while = 297,
822  modifier_until = 298,
823  modifier_rescue = 299,
824  keyword_alias = 300,
825  keyword_defined = 301,
826  keyword_BEGIN = 302,
827  keyword_END = 303,
828  keyword__LINE__ = 304,
829  keyword__FILE__ = 305,
830  keyword__ENCODING__ = 306,
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,
842  tSTRING_CONTENT = 318,
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,
882  tXSTRING_BEG = 341,
883  tREGEXP_BEG = 342,
884  tWORDS_BEG = 343,
885  tQWORDS_BEG = 344,
886  tSYMBOLS_BEG = 345,
887  tQSYMBOLS_BEG = 346,
888  tSTRING_DBEG = 347,
889  tSTRING_DEND = 348,
890  tSTRING_DVAR = 349,
891  tSTRING_END = 350,
892  tLAMBEG = 351,
893  tLOWEST = 352,
894  tUMINUS_NUM = 353,
895  tLAST_TOKEN = 354
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 "ripper.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 {
1092  yytype_int16 yyss_alloc;
1093  YYSTYPE yyvs_alloc;
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 11071
1149 
1150 /* YYNTOKENS -- Number of terminals. */
1151 #define YYNTOKENS 144
1152 /* YYNNTS -- Number of nonterminals. */
1153 #define YYNNTS 203
1154 /* YYNRULES -- Number of rules. */
1155 #define YYNRULES 626
1156 /* YYNRULES -- Number of states. */
1157 #define YYNSTATES 1059
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, 1296, 1301, 1303, 1307, 1311, 1312, 1318, 1321, 1326,
1254  1332, 1338, 1341, 1342, 1348, 1349, 1355, 1359, 1360, 1365,
1255  1366, 1371, 1374, 1376, 1381, 1382, 1388, 1389, 1395, 1401,
1256  1403, 1405, 1412, 1414, 1416, 1418, 1420, 1423, 1425, 1428,
1257  1430, 1432, 1434, 1436, 1438, 1440, 1442, 1445, 1449, 1453,
1258  1457, 1461, 1465, 1466, 1470, 1472, 1475, 1479, 1483, 1484,
1259  1488, 1492, 1496, 1500, 1504, 1505, 1509, 1510, 1514, 1515,
1260  1518, 1519, 1522, 1523, 1526, 1528, 1529, 1533, 1534, 1535,
1261  1536, 1543, 1545, 1547, 1549, 1551, 1554, 1556, 1558, 1560,
1262  1562, 1566, 1568, 1571, 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, 1618, 1623, 1626,
1265  1630, 1631, 1635, 1640, 1643, 1646, 1648, 1651, 1652, 1659,
1266  1668, 1673, 1680, 1685, 1692, 1695, 1700, 1707, 1710, 1715,
1267  1718, 1723, 1725, 1726, 1728, 1730, 1732, 1734, 1736, 1738,
1268  1740, 1744, 1746, 1750, 1752, 1755, 1757, 1760, 1762, 1764,
1269  1768, 1770, 1774, 1776, 1778, 1781, 1783, 1787, 1791, 1793,
1270  1797, 1799, 1803, 1805, 1807, 1810, 1812, 1814, 1816, 1819,
1271  1822, 1824, 1826, 1827, 1832, 1834, 1837, 1839, 1843, 1847,
1272  1850, 1853, 1855, 1857, 1859, 1861, 1863, 1865, 1867, 1869,
1273  1871, 1873, 1875, 1877, 1878, 1880, 1881, 1883, 1886, 1889,
1274  1890, 1892, 1894, 1896, 1898, 1900, 1903
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, 339, -1,
1281  346, -1, 149, -1, 148, 345, 149, -1, 1, 149,
1282  -1, 156, -1, -1, 47, 150, 132, 147, 133, -1,
1283  152, 265, 233, 268, -1, 153, 339, -1, 346, -1,
1284  154, -1, 153, 345, 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  301, 89, 161, -1, 218, 134, 190, 342, 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, 302, 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, 340, 159,
1298  -1, 129, 161, -1, 184, -1, 159, -1, 166, -1,
1299  162, -1, 254, -1, 254, 338, 336, 192, -1, -1,
1300  96, 164, 241, 152, 133, -1, 335, -1, 165, 192,
1301  -1, 165, 192, 163, -1, 218, 135, 336, 192, -1,
1302  218, 135, 336, 192, 163, -1, 218, 87, 336, 192,
1303  -1, 218, 87, 336, 192, 163, -1, 32, 192, -1,
1304  31, 192, -1, 30, 191, -1, 21, 191, -1, 22,
1305  191, -1, 169, -1, 91, 168, 341, -1, 169, -1,
1306  91, 168, 341, -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, 341, -1, 170, 136, -1,
1311  171, 170, 136, -1, 170, -1, 172, 136, 170, -1,
1312  298, -1, 299, -1, 218, 134, 190, 342, -1, 218,
1313  135, 52, -1, 218, 87, 52, -1, 218, 135, 56,
1314  -1, 218, 87, 56, -1, 88, 56, -1, 302, -1,
1315  298, -1, 299, -1, 218, 134, 190, 342, -1, 218,
1316  135, 52, -1, 218, 87, 52, -1, 218, 135, 56,
1317  -1, 218, 87, 56, -1, 88, 56, -1, 302, -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, 293, -1, 178, -1, 295,
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, 301, 89, 184, -1, 301, 89, 184, 44, 184,
1338  -1, 218, 134, 190, 342, 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, 302, 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, 297, 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  340, 185, 184, -1, 184, 116, 184, 340, 117, 184,
1355  -1, 199, -1, 184, -1, 346, -1, 196, 343, -1,
1356  196, 136, 333, 343, -1, 333, 343, -1, 138, 190,
1357  341, -1, 346, -1, 188, -1, 346, -1, 191, -1,
1358  196, 136, -1, 196, 136, 333, 136, -1, 333, 136,
1359  -1, 166, -1, 196, 195, -1, 333, 195, -1, 196,
1360  136, 333, 195, -1, 194, -1, -1, 193, 191, -1,
1361  99, 186, -1, 136, 194, -1, 346, -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, 269, -1,
1365  270, -1, 273, -1, 274, -1, 275, -1, 280, -1,
1366  278, -1, 281, -1, 300, -1, 302, -1, 53, -1,
1367  -1, 219, 200, 151, 229, -1, -1, 92, 201, 341,
1368  -1, -1, -1, 92, 202, 159, 203, 341, -1, 91,
1369  152, 139, -1, 218, 87, 56, -1, 88, 56, -1,
1370  94, 187, 140, -1, 95, 332, 133, -1, 30, -1,
1371  31, 138, 191, 341, -1, 31, 138, 341, -1, 31,
1372  -1, -1, 46, 340, 138, 204, 159, 341, -1, 39,
1373  138, 159, 341, -1, 39, 138, 341, -1, 165, 260,
1374  -1, 255, -1, 255, 260, -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, 339, 263, 229, -1, 224,
1379  339, 263, 229, -1, -1, -1, 225, 234, 25, 209,
1380  160, 231, 210, 152, 229, -1, -1, 226, 176, 303,
1381  211, 151, 229, -1, -1, -1, 226, 85, 159, 212,
1382  344, 213, 151, 229, -1, -1, 227, 176, 214, 151,
1383  229, -1, -1, 228, 177, 215, 305, 151, 229, -1,
1384  -1, -1, 228, 330, 338, 216, 177, 217, 305, 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, 344, -1, 13, -1, 344, 13,
1389  -1, 344, -1, 27, -1, 233, -1, 14, 160, 230,
1390  152, 232, -1, 346, -1, 15, 152, -1, 174, -1,
1391  167, -1, 311, -1, 91, 237, 341, -1, 235, -1,
1392  236, 136, 235, -1, 236, -1, 236, 136, 97, 311,
1393  -1, 236, 136, 97, 311, 136, 236, -1, 236, 136,
1394  97, -1, 236, 136, 97, 136, 236, -1, 97, 311,
1395  -1, 97, 311, 136, 236, -1, 97, -1, 97, 136,
1396  236, -1, 317, 136, 320, 329, -1, 317, 329, -1,
1397  320, 329, -1, 328, -1, 136, 238, -1, -1, 313,
1398  136, 323, 136, 326, 239, -1, 313, 136, 323, 136,
1399  326, 136, 313, 239, -1, 313, 136, 323, 239, -1,
1400  313, 136, 323, 136, 313, 239, -1, 313, 136, 326,
1401  239, -1, 313, 136, -1, 313, 136, 326, 136, 313,
1402  239, -1, 313, 239, -1, 323, 136, 326, 239, -1,
1403  323, 136, 326, 136, 313, 239, -1, 323, 239, -1,
1404  323, 136, 313, 239, -1, 326, 239, -1, 326, 136,
1405  313, 239, -1, 238, -1, 346, -1, 242, -1, 120,
1406  243, 120, -1, 78, -1, 120, 240, 243, 120, -1,
1407  340, -1, 340, 141, 244, 340, -1, 245, -1, 244,
1408  136, 245, -1, 52, -1, 310, -1, -1, -1, -1,
1409  247, 248, 250, 249, 251, -1, 138, 309, 243, 139,
1410  -1, 309, -1, 113, 152, 133, -1, 29, 152, 10,
1411  -1, -1, 28, 253, 241, 152, 10, -1, 166, 252,
1412  -1, 254, 338, 336, 189, -1, 254, 338, 336, 189,
1413  260, -1, 254, 338, 336, 192, 252, -1, 165, 188,
1414  -1, -1, 218, 135, 336, 256, 189, -1, -1, 218,
1415  87, 336, 257, 188, -1, 218, 87, 337, -1, -1,
1416  218, 135, 258, 188, -1, -1, 218, 87, 259, 188,
1417  -1, 32, 188, -1, 32, -1, 218, 134, 190, 342,
1418  -1, -1, 132, 261, 241, 152, 133, -1, -1, 26,
1419  262, 241, 152, 10, -1, 17, 196, 230, 152, 264,
1420  -1, 233, -1, 263, -1, 8, 266, 267, 230, 152,
1421  265, -1, 346, -1, 186, -1, 198, -1, 346, -1,
1422  90, 174, -1, 346, -1, 9, 152, -1, 346, -1,
1423  296, -1, 293, -1, 295, -1, 271, -1, 64, -1,
1424  272, -1, 271, 272, -1, 102, 284, 112, -1, 103,
1425  285, 112, -1, 104, 286, 67, -1, 105, 142, 112,
1426  -1, 105, 276, 112, -1, -1, 276, 277, 142, -1,
1427  287, -1, 277, 287, -1, 107, 142, 112, -1, 107,
1428  279, 112, -1, -1, 279, 277, 142, -1, 106, 142,
1429  112, -1, 106, 282, 112, -1, 108, 142, 112, -1,
1430  108, 283, 112, -1, -1, 282, 63, 142, -1, -1,
1431  283, 63, 142, -1, -1, 284, 287, -1, -1, 285,
1432  287, -1, -1, 286, 287, -1, 63, -1, -1, 111,
1433  288, 292, -1, -1, -1, -1, 109, 289, 290, 291,
1434  152, 110, -1, 54, -1, 55, -1, 57, -1, 302,
1435  -1, 101, 294, -1, 177, -1, 55, -1, 54, -1,
1436  57, -1, 101, 285, 112, -1, 297, -1, 128, 297,
1437  -1, 59, -1, 60, -1, 61, -1, 62, -1, 52,
1438  -1, 55, -1, 54, -1, 56, -1, 57, -1, 34,
1439  -1, 33, -1, 35, -1, 36, -1, 50, -1, 49,
1440  -1, 51, -1, 298, -1, 299, -1, 298, -1, 299,
1441  -1, 65, -1, 66, -1, 344, -1, -1, 119, 304,
1442  160, 344, -1, 1, 344, -1, 138, 309, 341, -1,
1443  -1, 306, 309, 344, -1, 318, 136, 320, 329, -1,
1444  318, 329, -1, 320, 329, -1, 328, -1, 136, 307,
1445  -1, -1, 313, 136, 324, 136, 326, 308, -1, 313,
1446  136, 324, 136, 326, 136, 313, 308, -1, 313, 136,
1447  324, 308, -1, 313, 136, 324, 136, 313, 308, -1,
1448  313, 136, 326, 308, -1, 313, 136, 326, 136, 313,
1449  308, -1, 313, 308, -1, 324, 136, 326, 308, -1,
1450  324, 136, 326, 136, 313, 308, -1, 324, 308, -1,
1451  324, 136, 313, 308, -1, 326, 308, -1, 326, 136,
1452  313, 308, -1, 307, -1, -1, 56, -1, 55, -1,
1453  54, -1, 57, -1, 310, -1, 52, -1, 311, -1,
1454  91, 237, 341, -1, 312, -1, 313, 136, 312, -1,
1455  58, -1, 314, 186, -1, 314, -1, 314, 218, -1,
1456  314, -1, 316, -1, 317, 136, 316, -1, 315, -1,
1457  318, 136, 315, -1, 70, -1, 98, -1, 319, 52,
1458  -1, 319, -1, 311, 115, 186, -1, 311, 115, 218,
1459  -1, 322, -1, 323, 136, 322, -1, 321, -1, 324,
1460  136, 321, -1, 125, -1, 97, -1, 325, 52, -1,
1461  325, -1, 122, -1, 99, -1, 327, 52, -1, 136,
1462  328, -1, 346, -1, 300, -1, -1, 138, 331, 159,
1463  341, -1, 346, -1, 333, 343, -1, 334, -1, 333,
1464  136, 334, -1, 186, 90, 186, -1, 58, 186, -1,
1465  98, 186, -1, 52, -1, 56, -1, 53, -1, 52,
1466  -1, 56, -1, 53, -1, 182, -1, 52, -1, 53,
1467  -1, 182, -1, 135, -1, 87, -1, -1, 345, -1,
1468  -1, 143, -1, 340, 139, -1, 340, 140, -1, -1,
1469  143, -1, 136, -1, 141, -1, 143, -1, 344, -1,
1470  345, 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  3459, 3483, 3491, 3497, 3501, 3508, 3507, 3528, 3544, 3553,
1518  3565, 3579, 3589, 3588, 3605, 3604, 3620, 3629, 3628, 3646,
1519  3645, 3662, 3670, 3678, 3693, 3692, 3712, 3711, 3732, 3744,
1520  3745, 3748, 3767, 3770, 3778, 3786, 3789, 3793, 3796, 3804,
1521  3807, 3808, 3816, 3819, 3836, 3837, 3838, 3848, 3858, 3885,
1522  3950, 3959, 3970, 3977, 3987, 3995, 4005, 4014, 4025, 4032,
1523  4044, 4053, 4063, 4072, 4083, 4090, 4101, 4108, 4123, 4130,
1524  4141, 4148, 4159, 4166, 4195, 4197, 4196, 4213, 4219, 4224,
1525  4212, 4243, 4251, 4259, 4267, 4270, 4281, 4282, 4283, 4284,
1526  4287, 4298, 4299, 4309, 4310, 4311, 4312, 4315, 4316, 4317,
1527  4318, 4319, 4322, 4323, 4324, 4325, 4326, 4327, 4328, 4331,
1528  4344, 4354, 4362, 4372, 4373, 4376, 4385, 4384, 4393, 4405,
1529  4415, 4415, 4428, 4432, 4436, 4440, 4446, 4451, 4456, 4460,
1530  4464, 4468, 4472, 4476, 4480, 4484, 4488, 4492, 4496, 4500,
1531  4504, 4508, 4513, 4519, 4528, 4537, 4546, 4557, 4558, 4565,
1532  4574, 4593, 4600, 4614, 4621, 4630, 4641, 4650, 4661, 4669,
1533  4686, 4694, 4710, 4711, 4714, 4719, 4725, 4737, 4749, 4757,
1534  4773, 4781, 4797, 4798, 4801, 4814, 4825, 4826, 4829, 4846,
1535  4850, 4860, 4870, 4870, 4899, 4900, 4910, 4917, 4927, 4939,
1536  4947, 4959, 4960, 4961, 4964, 4965, 4966, 4967, 4970, 4971,
1537  4972, 4975, 4980, 4987, 4988, 4991, 4992, 4995, 4998, 5001,
1538  5002, 5003, 5006, 5007, 5010, 5011, 5015
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", "f_larglist", "lambda_body", "do_block",
1592  "@30", "block_call", "method_call", "@31", "@32", "@33", "@34",
1593  "brace_block", "@35", "@36", "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", "@37", "@38", "@39", "@40", "string_dvar", "symbol",
1599  "sym", "dsym", "numeric", "simple_numeric", "user_variable",
1600  "keyword_variable", "var_ref", "var_lhs", "backref", "superclass",
1601  "$@41", "f_arglist", "@42", "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", "$@43", "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  246, 250, 250, 251, 251, 253, 252, 254, 254, 254,
1680  254, 255, 256, 255, 257, 255, 255, 258, 255, 259,
1681  255, 255, 255, 255, 261, 260, 262, 260, 263, 264,
1682  264, 265, 265, 266, 266, 266, 267, 267, 268, 268,
1683  269, 269, 269, 270, 271, 271, 271, 272, 273, 274,
1684  275, 275, 276, 276, 277, 277, 278, 278, 279, 279,
1685  280, 280, 281, 281, 282, 282, 283, 283, 284, 284,
1686  285, 285, 286, 286, 287, 288, 287, 289, 290, 291,
1687  287, 292, 292, 292, 292, 293, 294, 294, 294, 294,
1688  295, 296, 296, 297, 297, 297, 297, 298, 298, 298,
1689  298, 298, 299, 299, 299, 299, 299, 299, 299, 300,
1690  300, 301, 301, 302, 302, 303, 304, 303, 303, 305,
1691  306, 305, 307, 307, 307, 307, 308, 308, 309, 309,
1692  309, 309, 309, 309, 309, 309, 309, 309, 309, 309,
1693  309, 309, 309, 310, 310, 310, 310, 311, 311, 312,
1694  312, 313, 313, 314, 315, 315, 316, 316, 317, 317,
1695  318, 318, 319, 319, 320, 320, 321, 322, 323, 323,
1696  324, 324, 325, 325, 326, 326, 327, 327, 328, 329,
1697  329, 330, 331, 330, 332, 332, 333, 333, 334, 334,
1698  334, 335, 335, 335, 336, 336, 336, 336, 337, 337,
1699  337, 338, 338, 339, 339, 340, 340, 341, 342, 343,
1700  343, 343, 344, 344, 345, 345, 346
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  5, 4, 1, 3, 3, 0, 5, 2, 4, 5,
1748  5, 2, 0, 5, 0, 5, 3, 0, 4, 0,
1749  4, 2, 1, 4, 0, 5, 0, 5, 5, 1,
1750  1, 6, 1, 1, 1, 1, 2, 1, 2, 1,
1751  1, 1, 1, 1, 1, 1, 2, 3, 3, 3,
1752  3, 3, 0, 3, 1, 2, 3, 3, 0, 3,
1753  3, 3, 3, 3, 0, 3, 0, 3, 0, 2,
1754  0, 2, 0, 2, 1, 0, 3, 0, 0, 0,
1755  6, 1, 1, 1, 1, 2, 1, 1, 1, 1,
1756  3, 1, 2, 1, 1, 1, 1, 1, 1, 1,
1757  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1758  1, 1, 1, 1, 1, 1, 0, 4, 2, 3,
1759  0, 3, 4, 2, 2, 1, 2, 0, 6, 8,
1760  4, 6, 4, 6, 2, 4, 6, 2, 4, 2,
1761  4, 1, 0, 1, 1, 1, 1, 1, 1, 1,
1762  3, 1, 3, 1, 2, 1, 2, 1, 1, 3,
1763  1, 3, 1, 1, 2, 1, 3, 3, 1, 3,
1764  1, 3, 1, 1, 2, 1, 1, 1, 2, 2,
1765  1, 1, 0, 4, 1, 2, 1, 3, 3, 2,
1766  2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1767  1, 1, 1, 0, 1, 0, 1, 2, 2, 0,
1768  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, 513, 512, 514, 515, 615, 0, 615,
1779  10, 0, 517, 516, 518, 601, 603, 509, 508, 602,
1780  511, 503, 504, 505, 506, 454, 523, 524, 0, 0,
1781  0, 0, 290, 626, 626, 84, 407, 480, 478, 480,
1782  482, 462, 474, 468, 476, 0, 0, 0, 3, 613,
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, 613, 0, 0, 0, 0, 56, 307, 275,
1786  276, 453, 455, 277, 278, 279, 281, 280, 282, 451,
1787  452, 450, 501, 519, 520, 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, 626, 0, 519,
1798  520, 0, 284, 626, 596, 71, 69, 615, 68, 0,
1799  626, 431, 67, 615, 616, 0, 0, 21, 239, 0,
1800  0, 335, 336, 298, 301, 432, 0, 218, 0, 219,
1801  295, 0, 19, 0, 0, 613, 15, 18, 615, 74,
1802  14, 615, 0, 0, 619, 619, 244, 0, 0, 619,
1803  594, 615, 0, 0, 0, 82, 339, 0, 92, 93,
1804  100, 309, 408, 498, 497, 499, 496, 0, 495, 0,
1805  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1806  502, 51, 233, 234, 622, 623, 4, 624, 614, 0,
1807  0, 0, 0, 0, 0, 0, 436, 434, 421, 61,
1808  306, 415, 417, 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, 429, 626, 427, 0, 53,
1812  0, 0, 0, 0, 613, 0, 614, 0, 361, 360,
1813  0, 0, 519, 520, 284, 110, 111, 0, 0, 113,
1814  0, 0, 519, 520, 284, 328, 187, 180, 190, 175,
1815  157, 158, 159, 115, 116, 592, 330, 591, 0, 612,
1816  611, 0, 308, 456, 0, 0, 125, 599, 295, 267,
1817  600, 263, 0, 0, 0, 257, 265, 429, 626, 427,
1818  0, 0, 0, 258, 615, 0, 300, 262, 615, 252,
1819  626, 626, 251, 615, 305, 50, 23, 25, 24, 0,
1820  302, 0, 0, 0, 429, 427, 0, 17, 0, 615,
1821  293, 13, 614, 73, 289, 291, 296, 621, 620, 245,
1822  621, 247, 297, 595, 0, 99, 502, 90, 85, 0,
1823  429, 626, 427, 552, 484, 487, 485, 500, 481, 457,
1824  479, 458, 459, 483, 460, 461, 0, 464, 470, 0,
1825  471, 466, 467, 0, 472, 0, 473, 0, 625, 7,
1826  27, 28, 29, 30, 31, 48, 49, 626, 626, 58,
1827  62, 626, 0, 34, 271, 0, 43, 270, 615, 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, 615, 224, 226, 220, 221, 222, 211,
1831  212, 213, 214, 215, 604, 606, 605, 607, 0, 261,
1832  426, 615, 604, 606, 605, 607, 0, 261, 0, 626,
1833  352, 0, 351, 0, 0, 0, 0, 0, 0, 295,
1834  429, 626, 427, 320, 325, 110, 111, 112, 0, 526,
1835  323, 525, 429, 626, 427, 0, 0, 530, 332, 604,
1836  605, 261, 35, 200, 41, 208, 0, 198, 598, 0,
1837  268, 264, 626, 604, 605, 615, 604, 605, 597, 299,
1838  617, 248, 253, 255, 304, 22, 0, 240, 0, 32,
1839  424, 422, 207, 0, 75, 16, 615, 619, 0, 83,
1840  96, 98, 615, 604, 605, 558, 555, 554, 553, 556,
1841  563, 572, 0, 583, 573, 587, 586, 582, 552, 409,
1842  551, 412, 557, 559, 561, 537, 565, 570, 626, 575,
1843  626, 580, 537, 585, 537, 0, 535, 488, 0, 463,
1844  465, 475, 469, 477, 217, 399, 615, 0, 397, 396,
1845  0, 626, 0, 274, 0, 87, 81, 0, 0, 0,
1846  0, 0, 0, 430, 65, 0, 0, 433, 0, 0,
1847  428, 63, 626, 350, 287, 626, 626, 442, 626, 353,
1848  626, 355, 313, 354, 316, 0, 0, 319, 608, 294,
1849  615, 604, 605, 0, 0, 528, 0, 0, 110, 111,
1850  114, 615, 0, 615, 552, 0, 552, 0, 250, 418,
1851  57, 249, 0, 126, 269, 259, 0, 0, 433, 0,
1852  0, 626, 615, 11, 0, 292, 246, 91, 94, 0,
1853  373, 364, 366, 615, 362, 615, 0, 0, 0, 544,
1854  564, 0, 533, 590, 574, 0, 534, 0, 547, 584,
1855  0, 549, 588, 489, 491, 492, 493, 486, 494, 395,
1856  615, 0, 559, 380, 567, 568, 626, 626, 578, 380,
1857  380, 378, 401, 0, 0, 0, 0, 0, 272, 79,
1858  199, 0, 40, 205, 39, 206, 66, 425, 618, 0,
1859  37, 203, 38, 204, 64, 423, 443, 444, 626, 445,
1860  0, 626, 358, 0, 0, 356, 0, 0, 0, 318,
1861  0, 0, 433, 0, 326, 0, 0, 433, 329, 593,
1862  615, 0, 0, 333, 419, 420, 201, 0, 254, 303,
1863  20, 615, 0, 371, 0, 560, 0, 0, 0, 410,
1864  576, 536, 562, 537, 537, 571, 626, 589, 537, 581,
1865  537, 559, 537, 0, 0, 398, 0, 386, 388, 0,
1866  566, 0, 376, 377, 0, 391, 0, 393, 0, 437,
1867  435, 0, 416, 273, 241, 36, 202, 0, 0, 447,
1868  359, 0, 12, 449, 0, 310, 311, 0, 0, 268,
1869  626, 321, 0, 527, 324, 529, 331, 531, 530, 363,
1870  374, 0, 369, 365, 411, 0, 0, 0, 540, 0,
1871  542, 532, 0, 548, 0, 545, 550, 0, 400, 577,
1872  379, 380, 380, 295, 429, 569, 626, 380, 579, 380,
1873  380, 405, 615, 403, 406, 59, 0, 446, 0, 101,
1874  102, 109, 0, 448, 0, 314, 317, 439, 440, 438,
1875  0, 0, 0, 0, 372, 0, 367, 414, 413, 537,
1876  537, 537, 537, 490, 0, 383, 0, 385, 608, 294,
1877  375, 0, 392, 0, 389, 394, 0, 402, 108, 429,
1878  626, 427, 626, 626, 0, 327, 0, 370, 0, 541,
1879  0, 538, 543, 546, 380, 380, 380, 380, 404, 608,
1880  107, 615, 604, 605, 441, 357, 322, 334, 368, 537,
1881  384, 0, 381, 387, 390, 433, 539, 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, 990, 737, 734, 932,
1894  595, 597, 747, 938, 248, 87, 88, 89, 90, 91,
1895  92, 93, 94, 95, 96, 714, 571, 722, 844, 845,
1896  371, 771, 772, 773, 960, 898, 800, 687, 688, 801,
1897  972, 973, 281, 282, 473, 776, 659, 879, 322, 511,
1898  97, 98, 712, 705, 566, 558, 320, 508, 507, 578,
1899  989, 716, 838, 918, 922, 99, 100, 101, 102, 103,
1900  104, 105, 293, 486, 106, 297, 107, 108, 295, 299,
1901  289, 287, 291, 478, 678, 677, 793, 893, 797, 109,
1902  288, 110, 111, 112, 219, 220, 115, 221, 222, 590,
1903  736, 745, 746, 881, 779, 661, 662, 891, 664, 665,
1904  666, 667, 805, 806, 668, 669, 670, 671, 808, 809,
1905  672, 673, 674, 675, 676, 782, 398, 596, 268, 431,
1906  224, 118, 630, 560, 401, 306, 425, 426, 707, 459,
1907  572, 366, 260
1908 };
1909 
1910 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1911  STATE-NUM. */
1912 #define YYPACT_NINF -816
1913 static const yytype_int16 yypact[] =
1914 {
1915  -816, 132, 2698, -816, 7384, -816, -816, -816, 6899, -816,
1916  -816, -816, -816, -816, -816, -816, 7499, 7499, -816, -816,
1917  7499, 4040, 3629, -816, -816, -816, -816, 140, 6764, 0,
1918  -816, 27, -816, -816, -816, 2944, 3766, -816, -816, 3081,
1919  -816, -816, -816, -816, -816, -816, -816, -816, 8879, 8879,
1920  166, 5108, 288, 7844, 8189, 7162, -816, 6629, -816, -816,
1921  -816, 105, 123, 177, 196, 941, 8994, 8879, -816, 17,
1922  -816, 867, -816, 484, -816, -816, 76, 294, 226, -816,
1923  210, 9224, -816, 237, 3060, 285, 311, -816, 9109, 9109,
1924  -816, -816, 6009, 9335, 9446, 9557, 6493, 30, 62, -816,
1925  -816, 256, -816, -816, -816, -816, -816, -816, -816, -816,
1926  -816, -816, -816, 491, 593, -816, 303, 616, -816, -816,
1927  -816, -816, -816, -816, -816, -816, -816, -816, -816, -816,
1928  -816, -816, -816, -816, -816, -816, -816, -816, -816, -816,
1929  -816, -816, -816, -816, -816, -816, -816, -816, -816, -816,
1930  -816, -816, -816, -816, -816, -816, -816, -816, -816, -816,
1931  -816, -816, -816, -816, -816, -816, -816, -816, -816, -816,
1932  -816, -816, -816, -816, -816, -816, -816, -816, -816, -816,
1933  -816, -816, -816, -816, -816, -816, -816, -816, -816, -816,
1934  -816, -816, -816, -816, -816, -816, -816, -816, 229, -816,
1935  -816, -816, -816, 270, 8879, 359, 5249, 8879, 8879, 8879,
1936  8879, -816, 310, 3060, 349, -816, -816, 322, 393, 34,
1937  38, 365, 63, 325, -816, -816, -816, 5894, -816, 7499,
1938  7499, -816, -816, 6124, -816, 9109, 679, -816, 309, 332,
1939  5390, -816, -816, -816, 328, 361, 76, -816, 421, 402,
1940  736, 7614, -816, 5108, 362, 17, -816, 867, 0, 408,
1941  -816, 0, 9109, 398, -15, 180, -816, 349, 429, 180,
1942  -816, 0, 502, 941, 9668, 440, -816, 466, 563, 601,
1943  645, -816, -816, -816, -816, -816, -816, 425, -816, 506,
1944  540, 545, 453, 575, 469, 101, 474, 658, 476, 222,
1945  522, -816, -816, -816, -816, -816, -816, -816, 6239, 9109,
1946  9109, 9109, 9109, 7614, 9109, 9109, -816, -816, -816, 498,
1947  -816, -816, -816, 8304, -816, 5108, 7273, 460, 8304, 8879,
1948  8879, 8879, 8879, 8879, 8879, 8879, 8879, 8879, 8879, 8879,
1949  8879, 8879, 8879, 8879, 8879, 8879, 8879, 8879, 8879, 8879,
1950  8879, 8879, 8879, 8879, 8879, 9951, 7499, 10030, 4455, 484,
1951  113, 113, 9109, 9109, 17, 585, 472, 551, -816, -816,
1952  651, 595, 67, 88, 93, 487, 542, 9109, 78, -816,
1953  114, 686, -816, -816, -816, -816, 48, 50, 60, 266,
1954  276, 289, 347, 380, 416, -816, -816, -816, 30, -816,
1955  -816, 10109, -816, -816, 8994, 8994, -816, -816, 240, -816,
1956  -816, -816, 8879, 8879, 7729, -816, -816, 10188, 7499, 10267,
1957  8879, 8879, 7959, -816, 0, 494, -816, -816, 0, -816,
1958  490, 500, -816, 136, -816, -816, -816, -816, -816, 6899,
1959  -816, 8879, 5523, 497, 10188, 10267, 8879, 867, 512, 0,
1960  -816, -816, 6354, 528, -816, 484, -816, 8074, -816, -816,
1961  8189, -816, -816, -816, 309, 703, -816, -816, 529, 9668,
1962  10346, 7499, 10425, 1091, -816, -816, -816, -816, -816, -816,
1963  -816, -816, -816, -816, -816, -816, 35, -816, -816, 481,
1964  -816, -816, -816, 45, -816, 521, -816, 8879, -816, -816,
1965  -816, -816, -816, -816, -816, -816, -816, 70, 70, -816,
1966  -816, 70, 8879, -816, 536, 537, -816, -816, 0, 9668,
1967  557, -816, -816, -816, 566, 3197, -816, -816, 402, 2451,
1968  2451, 2451, 2451, 1100, 1100, 2544, 2079, 2451, 2451, 3334,
1969  3334, 708, 708, 10928, 1100, 1100, 849, 849, 944, 385,
1970  385, 402, 402, 402, 4177, 3218, 4314, 3355, 361, 558,
1971  -816, 0, 760, -816, 768, -816, 361, 3903, 685, 693,
1972  -816, 4596, 689, 4878, 59, 59, 585, 8419, 685, 106,
1973  10504, 7499, 10583, -816, 484, -816, 703, -816, 17, -816,
1974  -816, -816, 10662, 7499, 10109, 4455, 9109, 565, -816, -816,
1975  -816, 1231, -816, 2786, -816, 3060, 6899, 2923, -816, 8879,
1976  349, -816, 325, 2807, 3492, 0, 241, 306, -816, -816,
1977  -816, -816, 7729, 7959, -816, -816, 9109, 3060, 576, -816,
1978  -816, -816, 3060, 5523, 278, -816, 0, 180, 9668, 529,
1979  588, 351, 0, 334, 348, -816, -816, -816, -816, -816,
1980  -816, -816, 893, -816, -816, -816, -816, -816, 1256, -816,
1981  -816, -816, -816, 596, -816, 581, 8879, -816, 583, 672,
1982  589, -816, 591, 682, 603, 702, -816, -816, 858, -816,
1983  -816, -816, -816, -816, 402, -816, 1059, 5664, -816, -816,
1984  5390, 70, 5664, 620, 8534, -816, 529, 9668, 8994, 8879,
1985  646, 8994, 8994, -816, 498, 361, 625, 770, 8994, 8994,
1986  -816, 498, 361, -816, -816, 8649, 766, -816, 527, -816,
1987  766, -816, -816, -816, -816, 685, 228, -816, 71, 89,
1988  0, 116, 125, 9109, 17, -816, 9109, 4455, 588, 351,
1989  -816, 0, 685, 136, 1256, 4455, 1256, 7034, -816, 62,
1990  294, -816, 8879, -816, -816, -816, 8879, 8879, 415, 8879,
1991  8879, 653, 136, -816, 654, -816, -816, -816, 318, 893,
1992  441, -816, 659, 0, -816, 0, 297, 8879, 1256, -816,
1993  -816, 742, -816, -816, -816, 58, -816, 1256, -816, -816,
1994  772, -816, -816, -816, -816, -816, -816, -816, -816, -816,
1995  0, 674, 683, 666, 9779, -816, 667, 589, -816, 673,
1996  677, -816, 675, 807, 690, 5390, 812, 8879, 710, 529,
1997  3060, 8879, -816, 3060, -816, 3060, -816, -816, -816, 8994,
1998  -816, 3060, -816, 3060, -816, -816, 536, -816, 757, -816,
1999  4993, 845, -816, 9109, 685, -816, 685, 5664, 5664, -816,
2000  8764, 4737, 126, 59, -816, 17, 685, -816, -816, -816,
2001  0, 685, 17, -816, -816, -816, 3060, 8879, 7959, -816,
2002  -816, 0, 942, 725, 1005, -816, 723, 5664, 5390, -816,
2003  -816, -816, -816, 733, 738, -816, 589, -816, 740, -816,
2004  743, -816, 740, 5779, 761, -816, 9779, 1256, -816, 830,
2005  709, 742, -816, -816, 1256, -816, 772, -816, 1080, -816,
2006  -816, 754, -816, 752, 3060, -816, 3060, 9890, 113, -816,
2007  -816, 5664, -816, -816, 113, -816, -816, 685, 685, -816,
2008  171, -816, 4455, -816, -816, -816, -816, -816, 565, -816,
2009  756, 942, 492, -816, -816, 880, 762, 1256, -816, 772,
2010  -816, -816, 772, -816, 772, -816, -816, 789, -816, 709,
2011  -816, 780, 782, -816, 10741, -816, 589, 784, -816, 790,
2012  784, -816, 225, -816, -816, -816, 874, -816, 721, 563,
2013  601, 645, 4455, -816, 4596, -816, -816, -816, -816, -816,
2014  5664, 685, 4455, 942, 756, 942, 797, -816, -816, 740,
2015  800, 740, 740, -816, 1256, -816, 772, -816, 764, 799,
2016  -816, 772, -816, 772, -816, -816, 1080, -816, 703, 10820,
2017  7499, 10899, 693, 527, 685, -816, 685, 756, 942, -816,
2018  772, -816, -816, -816, 784, 808, 784, 784, -816, 253,
2019  351, 0, 148, 159, -816, -816, -816, -816, 756, 740,
2020  -816, 772, -816, -816, -816, 169, -816, 784, -816
2021 };
2022 
2023 /* YYPGOTO[NTERM-NUM]. */
2024 static const yytype_int16 yypgoto[] =
2025 {
2026  -816, -816, -816, -380, -816, 23, -816, -566, 358, -816,
2027  505, -816, 20, -816, -308, -42, -75, 39, -816, -330,
2028  -816, 726, -11, 850, -141, 7, -63, -816, -416, 16,
2029  1705, -294, 859, -55, -816, -16, -816, -816, 3, -816,
2030  1056, -816, 1763, -816, -6, 246, -349, 122, 4, -816,
2031  -374, -200, 47, -816, -312, -51, -816, -816, -816, -816,
2032  -816, -816, -816, -816, -816, -816, -816, -816, -816, -816,
2033  -816, -816, -816, -816, 74, -816, -816, -816, -816, -816,
2034  -816, -816, -816, -816, -816, -550, -346, -536, -61, -648,
2035  -816, -787, -765, 191, 277, 43, -816, -392, -816, -655,
2036  -816, -48, -816, -816, -816, -816, -816, -816, 215, -816,
2037  -816, -816, -816, -816, -816, -816, -90, -816, -816, -551,
2038  -816, -53, -816, -816, -816, -816, -816, -816, 877, -816,
2039  -816, -816, -816, 684, -816, -816, -816, -816, -816, -816,
2040  -816, 924, -816, -196, -816, -816, -816, -816, -816, 26,
2041  -816, 51, -816, -9, 846, 1250, 889, 1597, 1618, -816,
2042  -816, 54, -816, -407, -359, -311, -804, 957, -693, -447,
2043  -113, 205, 92, -816, -816, -816, -24, -730, -815, 110,
2044  230, -816, -654, -816, -146, -609, -816, -816, -816, 57,
2045  -385, -816, -336, -816, 613, -59, -26, -223, -560, -220,
2046  -56, 37, -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 -627
2053 static const yytype_int16 yytable[] =
2054 {
2055  119, 235, 286, 238, 276, 211, 211, 561, 402, 211,
2056  434, 199, 237, 307, 361, 573, 527, 364, 327, 559,
2057  522, 567, 71, 423, 71, 725, 232, 120, 727, 742,
2058  276, 199, 810, 365, 201, 453, 307, 618, 454, 724,
2059  611, 396, 276, 276, 276, 461, 359, 359, 611, 463,
2060  359, 266, 270, 639, 201, 758, 300, 889, 259, 202,
2061  199, 786, 628, 217, 217, 601, 660, 217, 841, 615,
2062  318, 275, 846, 223, 223, 618, 86, 223, 86, 202,
2063  319, 559, 768, 567, 587, 882, 721, 943, 316, 968,
2064  218, 218, -101, 480, 218, 483, -105, 487, 474, 199,
2065  264, 487, 316, 696, 974, 301, 308, 940, 474, 631,
2066  265, 269, 449, -102, -107, 588, 690, 399, -109, 692,
2067  876, 457, 642, -521, 884, 86, 570, -522, 458, 277,
2068  585, -108, 3, 890, 586, -513, 631, -512, 215, 225,
2069  218, -104, 226, 234, 475, 894, 476, -514, 685, -101,
2070  -106, -103, 421, -102, 475, 277, 476, 655, 304, 240,
2071  305, -104, 218, 218, 489, 400, 218, 370, 381, 381,
2072  852, 856, -106, 314, 315, 849, 994, 679, -109, 861,
2073  656, 857, -103, -513, 518, -512, 840, 682, 577, 968,
2074  686, 433, 858, 435, 317, -514, 451, 902, 903, 307,
2075  304, 619, 305, -92, 882, 621, 943, -96, 317, -604,
2076  624, 467, 974, 490, 230, 416, 211, 889, 211, 211,
2077  455, 416, 250, 276, -93, -98, 634, -605, 432, -100,
2078  1027, 423, 730, 589, 500, 501, 502, 503, 618, 803,
2079  318, 570, -99, 962, 741, 464, 631, 292, 611, 611,
2080  969, 660, -95, 764, 304, 304, 305, 305, 631, 882,
2081  259, -97, -94, 1048, 466, 294, -105, 359, 359, 359,
2082  359, 447, 505, 506, 217, 276, 217, 951, 233, 234,
2083  86, 819, 987, 234, 223, 495, 223, 574, 575, -104,
2084  680, -104, 452, 1000, 925, 695, 926, 680, 740, 815,
2085  -106, 218, -106, 218, 218, 576, 934, 218, 307, 218,
2086  -103, 936, -103, 788, 86, 791, 460, 931, 882, 296,
2087  359, 359, 321, 458, 591, 86, 877, 86, 71, 446,
2088  759, 499, 259, 504, 496, 584, 218, 660, 298, 660,
2089  888, 323, 520, 892, -433, 211, 324, 775, 277, 424,
2090  1035, 427, 328, -515, 432, -108, -104, 1010, 58, -95,
2091  565, 1016, 513, -517, 850, 406, 991, 523, 234, 304,
2092  515, 305, -339, -97, 826, 515, -516, 985, 986, 988,
2093  851, 834, 86, 218, 218, 218, 218, 86, 218, 218,
2094  522, -604, 404, -73, -105, 760, -105, 218, 355, 86,
2095  277, -515, 218, 837, 565, -433, 467, 211, 233, 254,
2096  878, -517, 755, 765, -87, 408, 432, 766, 276, -339,
2097  -339, -106, 565, 625, -516, 412, 1026, -288, 416, 416,
2098  218, -288, 86, 860, -518, 862, 218, 218, -294, 413,
2099  119, 1025, 199, 602, 604, 356, 357, 440, 565, -95,
2100  -433, 218, -433, -433, 420, 329, 467, 967, 414, 970,
2101  211, 422, 71, -97, 442, 201, 227, -507, 276, 432,
2102  -95, 612, 329, -95, 1046, 565, 1047, -95, 218, 218,
2103  417, 1055, -518, 618, -97, -294, -294, -97, 474, -605,
2104  202, -97, 218, 645, 611, 646, 647, 648, 649, 230,
2105  999, 450, 1001, -510, 867, 689, 689, 1002, 444, 689,
2106  352, 353, 354, -601, 637, -507, 86, 700, 723, 723,
2107  859, 314, 315, -72, 948, 950, 86, 418, 419, 953,
2108  -103, 955, 735, 956, 475, 706, 476, 477, 456, 869,
2109  811, 843, 840, 277, 645, 218, 646, 647, 648, 649,
2110  875, -510, 703, 470, 743, 418, 445, 1034, 465, 1036,
2111  710, 755, 462, 704, 254, 484, 1037, 717, -602, 474,
2112  211, 711, 982, 804, -507, 767, 469, 872, 984, 432,
2113  -521, 488, 211, 1049, 762, 565, 491, 276, 494, 706,
2114  753, 432, 497, 277, 509, 748, 521, 565, 443, 751,
2115  471, 472, 577, 474, 1057, 750, -101, 579, 474, 199,
2116  416, 254, 482, 498, -608, 475, 706, 476, 479, -601,
2117  583, -507, -507, 681, 726, -601, 622, -92, 995, -510,
2118  629, 119, 201, 620, 467, 887, 623, 935, 474, 887,
2119  1029, 1031, 1032, 1033, 633, 86, 276, 86, 939, 475,
2120  -519, 476, 481, 71, 475, 218, 476, 202, 853, 864,
2121  812, 855, 807, 683, -87, 638, 783, 218, 783, 86,
2122  218, 1041, -266, 694, -602, -608, -510, -510, 854, 761,
2123  -602, 698, -522, 254, 475, 631, 476, 485, -520, 689,
2124  1056, 359, 863, 697, 359, 713, -424, -519, -519, 827,
2125  218, 715, 719, 744, 706, 405, 748, 86, -102, 763,
2126  751, 777, 277, 839, 842, 706, 842, 778, 842, 781,
2127  -608, 474, -608, -608, 784, 785, -604, 787, 76, -93,
2128  76, -109, -284, 436, 789, -520, -520, 523, 580, 790,
2129  822, 824, 76, 76, 437, 438, 76, 830, 832, 812,
2130  199, 811, -100, 276, 792, 887, -267, 886, 811, 416,
2131  811, 86, 515, 821, 86, 828, 86, 475, 924, 476,
2132  492, 277, 218, 592, 812, 218, 218, 76, 329, -284,
2133  -284, 840, 218, 218, 804, 581, 582, 870, 804, 868,
2134  -295, 804, 76, 804, 895, 874, 964, 723, 896, 933,
2135  650, 359, 897, 901, 783, 783, 937, 218, 1019, 904,
2136  218, 86, 651, 906, 76, 76, 908, 909, 76, 86,
2137  593, 594, 912, 910, 645, 446, 646, 647, 648, 649,
2138  650, 350, 351, 352, 353, 354, 919, -295, -295, 923,
2139  654, 655, 651, 593, 594, 276, -268, 917, 113, 708,
2140  113, -108, 905, 907, 921, 1020, 1021, 709, 811, 829,
2141  811, 941, 944, 652, 656, 811, 276, 811, 915, 947,
2142  654, 655, -99, 807, 949, -104, 952, 966, 900, 954,
2143  807, 958, 807, -106, 783, -103, 963, 975, -269, 86,
2144  997, 804, 993, 804, 656, 998, -95, 113, 804, 1003,
2145  804, 278, -604, 218, -97, 811, -94, 309, 310, 311,
2146  312, 313, 794, 795, 86, 796, 1004, 218, 1006, 329,
2147  1011, 86, 86, 46, 47, 86, 1013, 278, 842, 718,
2148  1018, 720, 76, 1028, 342, 343, 1030, -605, 804, 372,
2149  382, 382, 382, 368, 1051, 645, 1017, 646, 647, 648,
2150  649, 86, 86, 76, 385, 76, 76, 635, 835, 76,
2151  871, 76, 1045, 799, 783, 865, 76, 86, 1038, 1044,
2152  959, 349, 350, 351, 352, 353, 354, 76, 403, 76,
2153  807, 493, 807, 290, 769, 397, 885, 807, 76, 807,
2154  770, 978, 992, 965, 645, 86, 646, 647, 648, 649,
2155  41, 42, 43, 44, 1005, 1007, 86, 961, 883, 211,
2156  1012, 598, 1014, 1015, 329, 706, 0, 0, 432, 0,
2157  717, 842, 0, 0, 565, 0, 0, 807, 0, 342,
2158  343, 0, 0, 769, 76, 76, 76, 76, 76, 76,
2159  76, 76, 0, 0, 0, 813, 0, 0, 814, 76,
2160  816, 76, 113, 0, 76, 0, 86, 645, 86, 646,
2161  647, 648, 649, 0, 86, 0, 86, 350, 351, 352,
2162  353, 354, 213, 213, 0, 0, 213, 1050, 1052, 1053,
2163  1054, 0, 76, 0, 76, 0, 113, 0, 76, 76,
2164  0, 0, 0, 0, 218, 0, 769, 113, 0, 113,
2165  1058, 0, 942, 76, 247, 249, 0, 0, 0, 213,
2166  213, 645, 0, 646, 647, 648, 649, 650, 0, 0,
2167  278, 0, 302, 303, 0, 0, 0, 0, 0, 651,
2168  76, 76, 971, 0, 646, 647, 648, 649, 0, 0,
2169  0, 0, 0, 645, 76, 646, 647, 648, 649, 650,
2170  652, 0, 0, 0, 113, 0, 653, 654, 655, 113,
2171  0, 651, 0, 0, 0, 0, 0, 0, 76, 0,
2172  329, 113, 278, 911, 0, 0, 0, 0, 76, 0,
2173  0, 656, 652, 0, 657, 342, 343, 0, 653, 654,
2174  655, 0, 0, 0, 0, 0, 0, 76, 920, 0,
2175  0, 0, 234, 0, 113, 927, 928, 0, 0, 930,
2176  0, 0, 0, 656, 0, 0, 657, 0, 0, 0,
2177  347, 348, 349, 350, 351, 352, 353, 354, 0, 658,
2178  0, -626, 0, 0, 0, 945, 946, 0, 0, -626,
2179  -626, -626, 0, 0, -626, -626, -626, 0, -626, 0,
2180  0, 957, 114, 0, 114, 0, 0, -626, -626, 0,
2181  213, 0, 0, 213, 213, 213, 302, 0, -626, -626,
2182  0, -626, -626, -626, -626, -626, 0, 0, 0, 983,
2183  0, 0, 0, 213, 0, 213, 213, 0, 113, 0,
2184  0, 0, 0, 0, 0, 0, 0, 76, 113, 76,
2185  0, 114, 0, 0, 0, 279, 0, 76, 645, 0,
2186  646, 647, 648, 649, 650, 278, 0, 0, -626, 76,
2187  0, 76, 76, 0, 0, 0, 651, 0, 0, 0,
2188  0, 279, 0, 0, 0, 0, 0, 0, 0, 0,
2189  1022, -626, 1023, 373, 383, 383, 383, 652, 1024, 0,
2190  0, 0, 76, 653, 654, 655, 0, 0, 0, 76,
2191  0, 0, 0, -626, -626, 278, -626, 0, 0, 230,
2192  -626, 0, -626, 0, -626, 0, 0, 0, 656, 213,
2193  0, 657, 0, 0, 525, 528, 529, 530, 531, 532,
2194  533, 534, 535, 536, 537, 538, 539, 540, 541, 542,
2195  543, 544, 545, 546, 547, 548, 549, 550, 551, 552,
2196  553, 0, 213, 76, 0, 0, 76, 113, 76, 113,
2197  0, 0, 0, 0, 76, 0, 0, 76, 76, 0,
2198  663, 0, 0, 0, 76, 76, 0, 0, 0, 0,
2199  0, 113, 0, 0, 0, 0, 0, 0, 0, 0,
2200  0, 0, 0, 0, 0, 0, 114, 0, 0, 76,
2201  603, 605, 76, 76, 0, 0, 0, 0, 607, 213,
2202  213, 76, 0, 0, 213, 0, 603, 605, 213, 113,
2203  0, 0, 0, 0, 278, 0, 0, 0, 0, 0,
2204  114, 0, 0, 0, 0, 0, 0, 627, 0, 0,
2205  0, 114, 632, 114, 0, 0, 0, 0, 0, 0,
2206  0, 0, 0, 213, 0, 0, 213, 0, 0, 0,
2207  0, 0, 0, 0, 279, 0, 0, 213, 0, 0,
2208  0, 0, 0, 113, 0, 0, 113, 0, 113, 0,
2209  0, 76, 0, 278, 0, 0, 0, 0, 0, 0,
2210  0, 0, 0, 684, 0, 76, 0, 0, 114, 0,
2211  0, 0, 0, 114, 0, 0, 76, 0, 213, 76,
2212  0, 0, 0, 76, 76, 114, 279, 76, 0, 0,
2213  0, 0, 0, 113, 0, 0, 0, 0, 0, 0,
2214  0, 113, 0, 0, 0, 0, 0, 0, 0, 116,
2215  0, 116, 0, 76, 76, 0, 0, 0, 114, 774,
2216  0, 0, 0, 0, 0, 663, 0, 0, 0, 76,
2217  117, 0, 117, 0, 0, 0, 0, 0, 0, 0,
2218  0, 0, 0, 213, 0, 0, 0, 213, 0, 0,
2219  0, 0, 0, 802, 0, 0, 0, 76, 116, 213,
2220  382, 0, 0, 0, 0, 0, 0, 0, 76, 0,
2221  0, 113, 0, 0, 0, 213, 0, 0, 0, 117,
2222  0, 0, 0, 280, 0, 0, 0, 0, 213, 213,
2223  0, 0, 0, 0, 0, 0, 113, 0, 0, 0,
2224  0, 0, 114, 113, 113, 0, 0, 113, 0, 280,
2225  0, 663, 114, 663, 0, 0, 0, 83, 76, 83,
2226  76, 374, 384, 384, 0, 0, 76, 0, 76, 279,
2227  0, 0, 213, 113, 113, 0, 774, 873, 0, 0,
2228  0, 0, 0, 0, 0, 663, 0, 0, 0, 113,
2229  0, 0, 382, 0, 663, 0, 76, 0, 0, 0,
2230  213, 0, 0, 0, 607, 820, 83, 823, 825, 0,
2231  0, 0, 0, 979, 831, 833, 0, 113, 0, 279,
2232  0, 213, 0, 0, 0, 0, 0, 0, 113, 0,
2233  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2234  0, 0, 0, 0, 0, 0, 0, 0, 369, 0,
2235  0, 0, 0, 116, 0, 0, 0, 0, 866, 0,
2236  0, 0, 823, 825, 0, 831, 833, 267, 0, 0,
2237  0, 114, 0, 114, 117, 0, 0, 0, 113, 774,
2238  113, 774, 0, 213, 0, 0, 113, 116, 113, 0,
2239  0, 0, 0, 0, 0, 114, 0, 0, 116, 0,
2240  116, 0, 0, 0, 802, 0, 0, 0, 117, 0,
2241  0, 802, 0, 0, 0, 0, 0, 0, 0, 117,
2242  0, 117, 0, 213, 0, 0, 0, 914, 0, 0,
2243  0, 0, 0, 114, 0, 916, 0, 0, 279, 0,
2244  0, 0, 280, 0, 0, 0, 0, 0, 774, 996,
2245  0, 0, 0, 0, 663, 116, 213, 0, 0, 0,
2246  116, 83, 0, 0, 0, 0, 0, 0, 0, 0,
2247  0, 0, 116, 916, 213, 0, 117, 0, 0, 0,
2248  0, 117, 0, 0, 0, 0, 0, 114, 0, 0,
2249  114, 0, 114, 117, 280, 83, 0, 279, 0, 0,
2250  774, 0, 774, 0, 0, 116, 83, 0, 83, 0,
2251  0, 802, 0, 0, 0, 0, 0, 407, 0, 0,
2252  409, 410, 411, 0, 0, 0, 117, 0, 0, 0,
2253  0, 0, 0, 0, 0, 774, 0, 114, 0, 0,
2254  0, 0, 0, 0, 0, 114, 0, 0, 0, 0,
2255  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2256  0, 0, 0, 83, 0, 0, 0, 0, 83, 0,
2257  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2258  83, 0, 0, 524, 0, 0, 0, 0, 0, 116,
2259  0, 0, 0, 0, 0, 0, 0, 0, 0, 116,
2260  0, 0, 0, 0, 383, 0, 0, 0, 0, 0,
2261  117, 0, 0, 83, 0, 114, 0, 0, 0, 0,
2262  117, 0, 0, 0, 0, 0, 213, 0, 0, 0,
2263  0, 0, 0, 0, 0, 0, 514, 280, 0, 0,
2264  114, 526, 0, 0, 0, 0, 0, 114, 114, 0,
2265  0, 114, 0, 0, 0, 0, 0, 0, 0, 0,
2266  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2267  0, 0, 0, 0, 0, 0, 0, 114, 114, 0,
2268  0, 0, 0, 0, 0, 0, 0, 280, 0, 0,
2269  0, 0, 0, 114, 0, 0, 383, 83, 0, 329,
2270  330, 331, 332, 333, 334, 335, 336, 83, 338, 339,
2271  0, 0, 0, 0, 342, 343, 0, 980, 116, 0,
2272  116, 114, 0, 0, 0, 0, 608, 610, 0, 0,
2273  0, 0, 114, 0, 0, 267, 0, 0, 0, 117,
2274  0, 117, 116, 0, 0, 0, 0, 345, 346, 347,
2275  348, 349, 350, 351, 352, 353, 354, 0, 0, 0,
2276  0, 0, 0, 117, 0, 0, 0, 0, 0, 0,
2277  610, 0, 0, 267, 0, 0, 0, 0, 0, 0,
2278  116, 0, 114, 0, 114, 0, 0, 0, 0, 0,
2279  114, 0, 114, 0, 0, 0, 0, 0, 0, 0,
2280  0, 117, 0, 0, 0, 0, 280, 0, 0, 0,
2281  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2282  0, 0, 0, 0, 0, 693, 83, 0, 83, 0,
2283  0, 0, 0, 0, 116, 0, 0, 116, 0, 116,
2284  0, 0, 0, 0, 0, 0, 798, 0, 0, 0,
2285  83, 0, 0, 0, 0, 117, 0, 0, 117, 0,
2286  117, 0, 0, 0, 0, 280, 0, 0, 0, 0,
2287  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2288  0, 0, 0, 0, 116, 0, 0, 0, 83, 0,
2289  526, 0, 116, 0, 0, 0, 0, 0, 0, 0,
2290  0, 0, 0, 0, 0, 117, 0, 0, 0, 0,
2291  0, 0, 0, 117, 0, 0, 0, 0, 0, 0,
2292  0, 0, 754, 0, 0, 0, 0, 0, 0, 0,
2293  0, 0, 0, 0, 0, 610, 267, 0, 0, 0,
2294  0, 0, 83, 0, 0, 83, 0, 83, 0, 0,
2295  0, 0, 0, 524, 0, 0, 0, 0, 0, 0,
2296  0, 0, 116, 0, 0, 0, 0, 0, 0, 0,
2297  0, 0, 384, 0, 0, 0, 0, 0, 0, 780,
2298  0, 0, 0, 117, 0, 0, 0, 116, 0, 0,
2299  0, 0, 83, 0, 116, 116, 0, 0, 116, 0,
2300  83, 0, 0, 0, 0, 0, 0, 818, 117, 0,
2301  0, 0, 0, 0, 0, 117, 117, 0, 0, 117,
2302  0, 0, 0, 0, 116, 116, 0, 0, 836, 0,
2303  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2304  116, 0, 0, 0, 0, 117, 117, 0, 0, 0,
2305  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2306  0, 117, 0, 0, 384, 0, 0, 0, 116, 0,
2307  83, 329, -627, -627, -627, -627, 334, 335, 0, 116,
2308  -627, -627, 0, 0, 0, 981, 342, 343, 0, 117,
2309  880, 0, 0, 0, 0, 83, 0, 0, 0, 0,
2310  117, 0, 83, 83, 0, 0, 83, 0, 0, 0,
2311  0, 0, 0, 0, 0, 0, 0, 0, 0, 345,
2312  346, 347, 348, 349, 350, 351, 352, 353, 354, 116,
2313  913, 116, 83, 83, 0, 0, 0, 116, 0, 116,
2314  0, 0, 0, 0, 0, 0, 0, 0, 83, 0,
2315  117, 0, 117, 0, 0, 0, 0, 0, 117, 0,
2316  117, 0, 0, 929, 329, 330, 331, 332, 333, 334,
2317  335, 0, 977, 338, 339, 0, 83, 0, 0, 342,
2318  343, 267, 0, 0, 0, 0, 0, 83, 0, 0,
2319  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2320  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2321  0, 0, 345, 346, 347, 348, 349, 350, 351, 352,
2322  353, 354, 0, 0, 0, 0, 0, 0, 0, 0,
2323  0, 0, 0, 0, 0, 0, 0, 83, 0, 83,
2324  0, 0, 0, 0, 0, 83, 0, 83, -626, 4,
2325  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2326  11, 0, 0, 0, 12, 0, 13, 14, 15, 16,
2327  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2328  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2329  0, 0, 0, 28, 29, 30, 31, 32, 33, 34,
2330  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
2331  44, 0, 45, 46, 47, 0, 48, 49, 0, 0,
2332  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2333  0, 0, 0, 0, 0, 0, 50, 0, 0, 51,
2334  52, 0, 53, 54, 0, 55, 0, 0, 56, 57,
2335  58, 59, 60, 61, 62, 63, 64, -608, 0, 0,
2336  0, 0, 0, 0, 0, -608, -608, -608, 0, 0,
2337  -608, -608, -608, 0, -608, 0, 65, 66, 67, 0,
2338  752, 0, 0, -608, -608, -608, -608, 0, 0, -626,
2339  0, -626, 0, 0, -608, -608, 0, -608, -608, -608,
2340  -608, -608, 0, 0, 0, 0, 329, 330, 331, 332,
2341  333, 334, 335, 336, 337, 338, 339, 340, 341, 0,
2342  0, 342, 343, 0, 0, 0, 0, -608, -608, -608,
2343  -608, -608, -608, -608, -608, -608, -608, -608, -608, -608,
2344  0, 0, -608, -608, -608, 0, 756, -608, 0, 0,
2345  0, 0, 344, -608, 345, 346, 347, 348, 349, 350,
2346  351, 352, 353, 354, 0, 0, 0, -608, 0, 0,
2347  -608, 0, -105, -608, -608, -608, -608, -608, -608, -608,
2348  -608, -608, -608, -608, -608, 0, 0, 0, 0, -608,
2349  -608, -608, -608, -608, -507, 0, -608, -608, -608, 0,
2350  -608, 0, -507, -507, -507, 0, 0, -507, -507, -507,
2351  0, -507, 0, 0, 0, 0, 0, 699, 0, -507,
2352  0, -507, -507, -507, 0, 0, 0, 0, 0, 0,
2353  0, -507, -507, 0, -507, -507, -507, -507, -507, 0,
2354  0, 0, 0, 329, 330, 331, 332, 333, 334, 335,
2355  336, 337, 338, 339, 340, 341, 0, 0, 342, 343,
2356  0, 0, 0, 0, -507, -507, -507, -507, -507, -507,
2357  -507, -507, -507, -507, -507, -507, -507, 0, 0, -507,
2358  -507, -507, 0, -507, -507, 0, 0, 0, 0, 344,
2359  -507, 345, 346, 347, 348, 349, 350, 351, 352, 353,
2360  354, 0, 0, 0, -507, 0, 0, -507, 0, -507,
2361  -507, -507, -507, -507, -507, -507, -507, -507, -507, -507,
2362  -507, -507, 0, 0, 0, 0, 0, -507, -507, -507,
2363  -507, -510, 0, -507, -507, -507, 0, -507, 0, -510,
2364  -510, -510, 0, 0, -510, -510, -510, 0, -510, 0,
2365  0, 0, 0, 0, 0, 0, -510, 0, -510, -510,
2366  -510, 0, 0, 0, 0, 0, 0, 0, -510, -510,
2367  0, -510, -510, -510, -510, -510, 0, 0, 0, 0,
2368  329, 330, 331, 332, 333, 334, 335, 336, 337, 338,
2369  339, 340, 341, 0, 0, 342, 343, 0, 0, 0,
2370  0, -510, -510, -510, -510, -510, -510, -510, -510, -510,
2371  -510, -510, -510, -510, 0, 0, -510, -510, -510, 0,
2372  -510, -510, 0, 0, 0, 0, 344, -510, 345, 346,
2373  347, 348, 349, 350, 351, 352, 353, 354, 0, 0,
2374  0, -510, 0, 0, -510, 0, -510, -510, -510, -510,
2375  -510, -510, -510, -510, -510, -510, -510, -510, -510, 0,
2376  0, 0, 0, 0, -510, -510, -510, -510, -609, 0,
2377  -510, -510, -510, 0, -510, 0, -609, -609, -609, 0,
2378  0, -609, -609, -609, 0, -609, 0, 0, 0, 0,
2379  0, 699, 0, 0, -609, -609, -609, -609, 0, 0,
2380  0, 0, 0, 0, 0, -609, -609, 0, -609, -609,
2381  -609, -609, -609, 0, 0, 0, 0, 329, 330, 331,
2382  332, 333, 334, 335, 336, 337, 338, 339, 340, 341,
2383  0, 0, 342, 343, 0, 0, 0, 0, -609, -609,
2384  -609, -609, -609, -609, -609, -609, -609, -609, -609, -609,
2385  -609, 0, 0, -609, -609, -609, 0, 0, -609, 0,
2386  0, 0, 0, 344, -609, 345, 346, 347, 348, 349,
2387  350, 351, 352, 353, 354, 0, 0, 0, -609, 0,
2388  0, -609, 0, -243, -609, -609, -609, -609, -609, -609,
2389  -609, -609, -609, -609, -609, -609, 0, 0, 0, 0,
2390  -609, -609, -609, -609, -609, -610, 0, -609, -609, -609,
2391  0, -609, 0, -610, -610, -610, 0, 0, -610, -610,
2392  -610, 0, -610, 0, 0, 0, 0, 0, 0, 0,
2393  0, -610, -610, -610, -610, 0, 0, 0, 0, 0,
2394  0, 0, -610, -610, 0, -610, -610, -610, -610, -610,
2395  0, 0, 0, 0, 329, 330, 331, 332, 333, 334,
2396  335, 336, 337, 338, 339, -627, -627, 0, 0, 342,
2397  343, 0, 0, 0, 0, -610, -610, -610, -610, -610,
2398  -610, -610, -610, -610, -610, -610, -610, -610, 0, 0,
2399  -610, -610, -610, 0, 0, -610, 0, 0, 0, 0,
2400  0, -610, 345, 346, 347, 348, 349, 350, 351, 352,
2401  353, 354, 0, 0, 0, -610, 0, 0, -610, 0,
2402  0, -610, -610, -610, -610, -610, -610, -610, -610, -610,
2403  -610, -610, -610, 0, 0, 0, 0, -610, -610, -610,
2404  -610, -610, -294, 0, -610, -610, -610, 0, -610, 0,
2405  -294, -294, -294, 0, 0, -294, -294, -294, 0, -294,
2406  0, 0, 0, 0, 0, 0, 0, 0, 0, -294,
2407  -294, -294, 0, 0, 0, 0, 0, 0, 0, -294,
2408  -294, 0, -294, -294, -294, -294, -294, 0, 0, 0,
2409  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2410  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2411  0, 0, -294, -294, -294, -294, -294, -294, -294, -294,
2412  -294, -294, -294, -294, -294, 0, 0, -294, -294, -294,
2413  0, 757, -294, 0, 0, 0, 0, 0, -294, 0,
2414  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2415  0, 0, -294, 0, 0, -294, 0, -107, -294, -294,
2416  -294, -294, -294, -294, -294, -294, -294, -294, -294, -294,
2417  0, 0, 0, 0, 0, -294, -294, -294, -294, -432,
2418  0, -294, -294, -294, 0, -294, 0, -432, -432, -432,
2419  0, 0, -432, -432, -432, 0, -432, 0, 0, 0,
2420  0, 0, 0, 0, 0, -432, -432, -432, 0, 0,
2421  0, 0, 0, 0, 0, 0, -432, -432, 0, -432,
2422  -432, -432, -432, -432, 0, 0, 0, 0, 0, 0,
2423  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2424  0, 0, 0, 0, 0, 0, 0, 0, 0, -432,
2425  -432, -432, -432, -432, -432, -432, -432, -432, -432, -432,
2426  -432, -432, 0, 0, -432, -432, -432, 0, 0, -432,
2427  0, 0, 0, 0, 0, -432, 0, 0, 0, 0,
2428  0, 0, 0, 0, 0, 0, 0, 0, 0, -432,
2429  0, 0, 0, 0, 0, -432, 0, -432, -432, -432,
2430  -432, -432, -432, -432, -432, -432, -432, 0, 0, 0,
2431  0, -432, -432, -432, -432, -432, -285, 230, -432, -432,
2432  -432, 0, -432, 0, -285, -285, -285, 0, 0, -285,
2433  -285, -285, 0, -285, 0, 0, 0, 0, 0, 0,
2434  0, 0, 0, -285, -285, -285, 0, 0, 0, 0,
2435  0, 0, 0, -285, -285, 0, -285, -285, -285, -285,
2436  -285, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2437  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2438  0, 0, 0, 0, 0, 0, -285, -285, -285, -285,
2439  -285, -285, -285, -285, -285, -285, -285, -285, -285, 0,
2440  0, -285, -285, -285, 0, 0, -285, 0, 0, 0,
2441  0, 0, -285, 0, 0, 0, 0, 0, 0, 0,
2442  0, 0, 0, 0, 0, 0, -285, 0, 0, -285,
2443  0, 0, -285, -285, -285, -285, -285, -285, -285, -285,
2444  -285, -285, -285, -285, 0, 0, 0, 0, 0, -285,
2445  -285, -285, -285, -422, 0, -285, -285, -285, 0, -285,
2446  0, -422, -422, -422, 0, 0, -422, -422, -422, 0,
2447  -422, 0, 0, 0, 0, 0, 0, 0, 0, -422,
2448  -422, -422, 0, 0, 0, 0, 0, 0, 0, 0,
2449  -422, -422, 0, -422, -422, -422, -422, -422, 0, 0,
2450  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2451  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2452  0, 0, 0, -422, -422, -422, -422, -422, -422, -422,
2453  -422, -422, -422, -422, -422, -422, 0, 0, -422, -422,
2454  -422, 0, 0, -422, 0, 0, 0, 0, 0, -422,
2455  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2456  0, 0, 0, -422, 0, 0, 0, 0, 0, -422,
2457  0, -422, -422, -422, -422, -422, -422, -422, -422, -422,
2458  -422, 0, 0, 0, 0, -422, -422, -422, -422, -422,
2459  -301, -422, -422, -422, -422, 0, -422, 0, -301, -301,
2460  -301, 0, 0, -301, -301, -301, 0, -301, 0, 0,
2461  0, 0, 0, 0, 0, 0, 0, -301, -301, 0,
2462  0, 0, 0, 0, 0, 0, 0, -301, -301, 0,
2463  -301, -301, -301, -301, -301, 0, 0, 0, 0, 0,
2464  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2465  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2466  -301, -301, -301, -301, -301, -301, -301, -301, -301, -301,
2467  -301, -301, -301, 0, 0, -301, -301, -301, 0, 0,
2468  -301, 0, 0, 0, 0, 0, -301, 0, 0, 0,
2469  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2470  -301, 0, 0, 0, 0, 0, -301, 0, -301, -301,
2471  -301, -301, -301, -301, -301, -301, -301, -301, 0, 0,
2472  0, 0, 0, -301, -301, -301, -301, -608, 227, -301,
2473  -301, -301, 0, -301, 0, -608, -608, -608, 0, 0,
2474  0, -608, -608, 0, -608, 0, 0, 0, 0, 0,
2475  0, 0, 0, -608, 0, 0, 0, 0, 0, 0,
2476  0, 0, 0, 0, -608, -608, 0, -608, -608, -608,
2477  -608, -608, 0, 0, 0, 0, 0, 0, 0, 0,
2478  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2479  0, 0, 0, 0, 0, 0, 0, -608, -608, -608,
2480  -608, -608, -608, -608, -608, -608, -608, -608, -608, -608,
2481  0, 0, -608, -608, -608, 0, 701, 0, 0, 0,
2482  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2483  0, 0, 0, 0, 0, 0, 0, -608, 0, 0,
2484  0, 0, -105, -608, 0, -608, -608, -608, -608, -608,
2485  -608, -608, -608, -608, -608, 0, 0, 0, 0, -608,
2486  -608, -608, -608, -96, -294, 0, -608, 0, -608, 0,
2487  -608, 0, -294, -294, -294, 0, 0, 0, -294, -294,
2488  0, -294, 0, 0, 0, 0, 0, 0, 0, 0,
2489  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2490  0, -294, -294, 0, -294, -294, -294, -294, -294, 0,
2491  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2492  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2493  0, 0, 0, 0, -294, -294, -294, -294, -294, -294,
2494  -294, -294, -294, -294, -294, -294, -294, 0, 0, -294,
2495  -294, -294, 0, 702, 0, 0, 0, 0, 0, 0,
2496  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2497  0, 0, 0, 0, -294, 0, 0, 0, 0, -107,
2498  -294, 0, -294, -294, -294, -294, -294, -294, -294, -294,
2499  -294, -294, 0, 0, 0, 0, 0, -294, -294, -294,
2500  -98, 0, 0, -294, 0, -294, 251, -294, 5, 6,
2501  7, 8, 9, -626, -626, -626, 10, 11, 0, 0,
2502  -626, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2503  0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2504  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2505  28, 29, 252, 31, 32, 33, 34, 35, 36, 37,
2506  38, 39, 40, 0, 41, 42, 43, 44, 0, 45,
2507  46, 47, 0, 48, 49, 0, 0, 0, 0, 0,
2508  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2509  0, 0, 0, 50, 0, 0, 51, 52, 0, 53,
2510  54, 0, 55, 0, 0, 56, 57, 58, 59, 60,
2511  61, 62, 63, 64, 0, 0, 0, 0, 0, 0,
2512  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2513  0, 0, 0, 65, 66, 67, 0, 0, 0, 0,
2514  0, 0, 0, 0, 0, 0, -626, 251, -626, 5,
2515  6, 7, 8, 9, 0, 0, -626, 10, 11, 0,
2516  -626, -626, 12, 0, 13, 14, 15, 16, 17, 18,
2517  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2518  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2519  0, 28, 29, 252, 31, 32, 33, 34, 35, 36,
2520  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
2521  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
2522  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2523  0, 0, 0, 0, 50, 0, 0, 51, 52, 0,
2524  53, 54, 0, 55, 0, 0, 56, 57, 58, 59,
2525  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2526  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2527  0, 0, 0, 0, 65, 66, 67, 0, 0, 0,
2528  0, 0, 0, 0, 0, 0, 0, -626, 251, -626,
2529  5, 6, 7, 8, 9, 0, 0, -626, 10, 11,
2530  0, 0, -626, 12, -626, 13, 14, 15, 16, 17,
2531  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2532  23, 24, 25, 26, 0, 0, 27, 0, 0, 0,
2533  0, 0, 28, 29, 252, 31, 32, 33, 34, 35,
2534  36, 37, 38, 39, 40, 0, 41, 42, 43, 44,
2535  0, 45, 46, 47, 0, 48, 49, 0, 0, 0,
2536  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2537  0, 0, 0, 0, 0, 50, 0, 0, 51, 52,
2538  0, 53, 54, 0, 55, 0, 0, 56, 57, 58,
2539  59, 60, 61, 62, 63, 64, 0, 0, 0, 0,
2540  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2541  0, 0, 0, 0, 0, 65, 66, 67, 0, 0,
2542  0, 0, 0, 0, 0, 0, 0, 0, -626, 251,
2543  -626, 5, 6, 7, 8, 9, 0, 0, -626, 10,
2544  11, 0, 0, -626, 12, 0, 13, 14, 15, 16,
2545  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2546  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2547  0, 0, 0, 28, 29, 252, 31, 32, 33, 34,
2548  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
2549  44, 0, 45, 46, 47, 0, 48, 49, 0, 0,
2550  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2551  0, 0, 0, 0, 0, 0, 50, 0, 0, 51,
2552  52, 0, 53, 54, 0, 55, 0, 0, 56, 57,
2553  58, 59, 60, 61, 62, 63, 64, 0, 0, 0,
2554  0, 0, 0, 0, 251, 0, 5, 6, 7, 8,
2555  9, 0, -626, -626, 10, 11, 65, 66, 67, 12,
2556  0, 13, 14, 15, 16, 17, 18, 19, 0, -626,
2557  0, -626, 0, 20, 21, 22, 23, 24, 25, 26,
2558  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2559  252, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2560  40, 0, 41, 42, 43, 44, 0, 45, 46, 47,
2561  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
2562  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2563  0, 50, 0, 0, 51, 52, 0, 53, 54, 0,
2564  55, 0, 0, 56, 57, 58, 59, 60, 61, 62,
2565  63, 64, 0, 0, 0, 0, 0, 0, 0, 251,
2566  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2567  11, 65, 66, 67, 12, 0, 13, 14, 15, 16,
2568  17, 18, 19, 0, -626, 0, -626, 0, 20, 21,
2569  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2570  0, 0, 0, 28, 29, 252, 31, 32, 33, 34,
2571  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
2572  44, 0, 45, 46, 47, 0, 48, 49, 0, 0,
2573  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2574  0, 0, 0, 0, 0, 0, 50, 0, 0, 253,
2575  52, 0, 53, 54, 0, 55, 0, 0, 56, 57,
2576  58, 59, 60, 61, 62, 63, 64, 0, 0, 0,
2577  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2578  0, 0, 0, 0, 0, 0, 65, 66, 67, 0,
2579  0, 0, 0, 0, 0, 0, 0, -626, 0, -626,
2580  251, -626, 5, 6, 7, 8, 9, 0, 0, 0,
2581  10, 11, 0, 0, 0, 12, 0, 13, 14, 15,
2582  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2583  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2584  0, 0, 0, 0, 28, 29, 252, 31, 32, 33,
2585  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2586  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2587  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2588  0, 0, 0, 0, 0, 0, 0, 50, 0, 0,
2589  51, 52, 0, 53, 54, 0, 55, 0, 0, 56,
2590  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2591  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2592  0, 0, 0, 0, 0, 0, 0, 65, 66, 67,
2593  0, 0, 0, 0, 0, 0, 0, 0, -626, 0,
2594  -626, 251, -626, 5, 6, 7, 8, 9, 0, 0,
2595  0, 10, 11, 0, 0, 0, 12, 0, 13, 14,
2596  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2597  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2598  0, 0, 0, 0, 0, 28, 29, 252, 31, 32,
2599  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2600  42, 43, 44, 0, 45, 46, 47, 0, 48, 49,
2601  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2602  0, 0, 0, 0, 0, 0, 0, 0, 50, 0,
2603  0, 51, 52, 0, 53, 54, 0, 55, 0, 0,
2604  56, 57, 58, 59, 60, 61, 62, 63, 64, 0,
2605  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2606  0, 0, 0, 0, 0, 0, 0, 0, 65, 66,
2607  67, 0, 0, -626, 4, 0, 5, 6, 7, 8,
2608  9, -626, 0, -626, 10, 11, 0, 0, 0, 12,
2609  0, 13, 14, 15, 16, 17, 18, 19, 0, 0,
2610  0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
2611  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2612  30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2613  40, 0, 41, 42, 43, 44, 0, 45, 46, 47,
2614  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
2615  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2616  0, 50, 0, 0, 51, 52, 0, 53, 54, 0,
2617  55, 0, 0, 56, 57, 58, 59, 60, 61, 62,
2618  63, 64, 0, 0, 0, 0, 0, 0, 0, 0,
2619  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2620  0, 65, 66, 67, 0, 0, -626, 0, 0, 0,
2621  0, 0, 0, 0, -626, 251, -626, 5, 6, 7,
2622  8, 9, 0, 0, -626, 10, 11, 0, 0, 0,
2623  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2624  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2625  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2626  29, 252, 31, 32, 33, 34, 35, 36, 37, 38,
2627  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2628  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2629  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2630  0, 0, 50, 0, 0, 51, 52, 0, 53, 54,
2631  0, 55, 0, 0, 56, 57, 58, 59, 60, 61,
2632  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
2633  251, 0, 5, 6, 7, 8, 9, 0, 0, 0,
2634  10, 11, 65, 66, 67, 12, 0, 13, 14, 15,
2635  16, 17, 18, 19, 0, -626, 0, -626, 0, 20,
2636  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2637  0, 0, 0, 0, 28, 29, 252, 31, 32, 33,
2638  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2639  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2640  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2641  0, 0, 0, 0, 0, 0, 0, 50, 0, 0,
2642  51, 52, 0, 53, 54, 0, 55, 0, 0, 56,
2643  57, 58, 59, 60, 61, 62, 63, 64, 0, -626,
2644  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2645  0, 9, 0, 0, 0, 10, 11, 65, 66, 67,
2646  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2647  -626, 0, -626, 0, 20, 21, 22, 23, 24, 25,
2648  26, 0, 0, 203, 0, 0, 0, 0, 0, 0,
2649  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2650  39, 40, 204, 41, 42, 43, 44, 0, 45, 46,
2651  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2652  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2653  0, 0, 205, 0, 0, 206, 52, 0, 53, 54,
2654  0, 207, 208, 209, 56, 57, 58, 59, 60, 61,
2655  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
2656  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2657  10, 11, 65, 210, 67, 12, 0, 13, 14, 15,
2658  16, 17, 18, 19, 0, 0, 0, 234, 0, 20,
2659  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2660  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2661  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2662  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2663  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2664  0, 0, 0, 0, 0, 0, 0, 205, 0, 0,
2665  206, 52, 0, 53, 54, 0, 0, 0, 0, 56,
2666  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2667  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2668  0, 9, 0, 0, 0, 10, 11, 65, 66, 67,
2669  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2670  304, 0, 305, 0, 20, 21, 22, 23, 24, 25,
2671  26, 0, 0, 27, 0, 0, 0, 0, 0, 0,
2672  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2673  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2674  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2675  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2676  0, 0, 205, 0, 0, 206, 52, 0, 53, 54,
2677  0, 0, 0, 0, 56, 57, 58, 59, 60, 61,
2678  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
2679  0, 0, 5, 6, 7, 8, 9, 0, 0, 0,
2680  10, 11, 65, 66, 67, 12, 0, 13, 14, 15,
2681  16, 17, 18, 19, 0, 0, 0, 234, 0, 20,
2682  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2683  0, 0, 0, 0, 28, 29, 30, 31, 32, 33,
2684  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2685  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2686  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2687  0, 0, 0, 0, 0, 0, 0, 50, 0, 0,
2688  51, 52, 0, 53, 54, 0, 55, 0, 0, 56,
2689  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2690  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2691  8, 9, 0, 0, 0, 10, 11, 65, 66, 67,
2692  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2693  498, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2694  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2695  29, 252, 31, 32, 33, 34, 35, 36, 37, 38,
2696  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2697  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2698  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2699  0, 0, 50, 0, 0, 51, 52, 0, 53, 54,
2700  0, 55, 0, 0, 56, 57, 58, 59, 60, 61,
2701  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
2702  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2703  0, 0, 65, 66, 67, 0, 0, 0, 0, 0,
2704  0, 0, 0, 0, 0, 498, 121, 122, 123, 124,
2705  125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
2706  135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
2707  0, 0, 0, 145, 146, 147, 386, 387, 388, 389,
2708  152, 153, 154, 0, 0, 0, 0, 0, 155, 156,
2709  157, 158, 390, 391, 392, 393, 163, 37, 38, 394,
2710  40, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2711  0, 165, 166, 167, 168, 169, 170, 171, 172, 173,
2712  0, 0, 174, 175, 0, 0, 176, 177, 178, 179,
2713  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2714  180, 181, 0, 0, 0, 0, 0, 0, 0, 0,
2715  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2716  0, 182, 183, 184, 185, 186, 187, 188, 189, 190,
2717  191, 0, 192, 193, 0, 0, 0, 0, 0, 0,
2718  194, 395, 121, 122, 123, 124, 125, 126, 127, 128,
2719  129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2720  139, 140, 141, 142, 143, 144, 0, 0, 0, 145,
2721  146, 147, 148, 149, 150, 151, 152, 153, 154, 0,
2722  0, 0, 0, 0, 155, 156, 157, 158, 159, 160,
2723  161, 162, 163, 283, 284, 164, 285, 0, 0, 0,
2724  0, 0, 0, 0, 0, 0, 0, 165, 166, 167,
2725  168, 169, 170, 171, 172, 173, 0, 0, 174, 175,
2726  0, 0, 176, 177, 178, 179, 0, 0, 0, 0,
2727  0, 0, 0, 0, 0, 0, 180, 181, 0, 0,
2728  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2729  0, 0, 0, 0, 0, 0, 0, 182, 183, 184,
2730  185, 186, 187, 188, 189, 190, 191, 0, 192, 193,
2731  0, 0, 0, 0, 0, 0, 194, 121, 122, 123,
2732  124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
2733  134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
2734  144, 0, 0, 0, 145, 146, 147, 148, 149, 150,
2735  151, 152, 153, 154, 0, 0, 0, 0, 0, 155,
2736  156, 157, 158, 159, 160, 161, 162, 163, 236, 0,
2737  164, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2738  0, 0, 165, 166, 167, 168, 169, 170, 171, 172,
2739  173, 0, 0, 174, 175, 0, 0, 176, 177, 178,
2740  179, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2741  0, 180, 181, 0, 0, 57, 0, 0, 0, 0,
2742  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2743  0, 0, 182, 183, 184, 185, 186, 187, 188, 189,
2744  190, 191, 0, 192, 193, 0, 0, 0, 0, 0,
2745  0, 194, 121, 122, 123, 124, 125, 126, 127, 128,
2746  129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2747  139, 140, 141, 142, 143, 144, 0, 0, 0, 145,
2748  146, 147, 148, 149, 150, 151, 152, 153, 154, 0,
2749  0, 0, 0, 0, 155, 156, 157, 158, 159, 160,
2750  161, 162, 163, 0, 0, 164, 0, 0, 0, 0,
2751  0, 0, 0, 0, 0, 0, 0, 165, 166, 167,
2752  168, 169, 170, 171, 172, 173, 0, 0, 174, 175,
2753  0, 0, 176, 177, 178, 179, 0, 0, 0, 0,
2754  0, 0, 0, 0, 0, 0, 180, 181, 0, 0,
2755  57, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2756  0, 0, 0, 0, 0, 0, 0, 182, 183, 184,
2757  185, 186, 187, 188, 189, 190, 191, 0, 192, 193,
2758  0, 0, 0, 0, 0, 0, 194, 121, 122, 123,
2759  124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
2760  134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
2761  144, 0, 0, 0, 145, 146, 147, 148, 149, 150,
2762  151, 152, 153, 154, 0, 0, 0, 0, 0, 155,
2763  156, 157, 158, 159, 160, 161, 162, 163, 0, 0,
2764  164, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2765  0, 0, 165, 166, 167, 168, 169, 170, 171, 172,
2766  173, 0, 0, 174, 175, 0, 0, 176, 177, 178,
2767  179, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2768  0, 180, 181, 0, 0, 0, 0, 0, 0, 0,
2769  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2770  0, 0, 182, 183, 184, 185, 186, 187, 188, 189,
2771  190, 191, 0, 192, 193, 5, 6, 7, 0, 9,
2772  0, 194, 0, 10, 11, 0, 0, 0, 12, 0,
2773  13, 14, 15, 241, 242, 18, 19, 0, 0, 0,
2774  0, 0, 243, 244, 245, 23, 24, 25, 26, 0,
2775  0, 203, 0, 0, 0, 0, 0, 0, 271, 0,
2776  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2777  0, 41, 42, 43, 44, 0, 45, 46, 47, 0,
2778  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2779  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2780  272, 0, 0, 206, 52, 0, 53, 54, 0, 0,
2781  0, 0, 56, 57, 58, 59, 60, 61, 62, 63,
2782  64, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2783  9, 0, 0, 0, 10, 11, 0, 0, 0, 12,
2784  273, 13, 14, 15, 241, 242, 18, 19, 274, 0,
2785  0, 0, 0, 243, 244, 245, 23, 24, 25, 26,
2786  0, 0, 203, 0, 0, 0, 0, 0, 0, 271,
2787  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2788  40, 0, 41, 42, 43, 44, 0, 45, 46, 47,
2789  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2790  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2791  0, 272, 0, 0, 206, 52, 0, 53, 54, 0,
2792  0, 0, 0, 56, 57, 58, 59, 60, 61, 62,
2793  63, 64, 0, 0, 0, 0, 0, 5, 6, 7,
2794  8, 9, 0, 0, 0, 10, 11, 0, 0, 0,
2795  12, 273, 13, 14, 15, 16, 17, 18, 19, 519,
2796  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2797  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2798  29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
2799  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2800  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2801  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2802  0, 0, 50, 0, 0, 51, 52, 0, 53, 54,
2803  0, 55, 0, 0, 56, 57, 58, 59, 60, 61,
2804  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
2805  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2806  10, 11, 65, 66, 67, 12, 0, 13, 14, 15,
2807  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2808  21, 22, 23, 24, 25, 26, 0, 0, 203, 0,
2809  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2810  34, 35, 36, 37, 38, 39, 40, 204, 41, 42,
2811  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2812  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2813  0, 0, 0, 0, 0, 0, 0, 205, 0, 0,
2814  206, 52, 0, 53, 54, 0, 207, 208, 209, 56,
2815  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2816  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2817  8, 9, 0, 0, 0, 10, 11, 65, 210, 67,
2818  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2819  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2820  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2821  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
2822  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2823  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2824  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2825  0, 0, 50, 0, 0, 51, 52, 0, 53, 54,
2826  0, 55, 0, 0, 56, 57, 58, 59, 60, 61,
2827  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
2828  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2829  10, 11, 65, 66, 67, 12, 0, 13, 14, 15,
2830  241, 242, 18, 19, 0, 0, 0, 0, 0, 243,
2831  244, 245, 23, 24, 25, 26, 0, 0, 203, 0,
2832  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2833  34, 35, 36, 37, 38, 39, 40, 204, 41, 42,
2834  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2835  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2836  0, 0, 0, 0, 0, 0, 0, 205, 0, 0,
2837  206, 52, 0, 53, 54, 0, 609, 208, 209, 56,
2838  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2839  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2840  0, 9, 0, 0, 0, 10, 11, 65, 210, 67,
2841  12, 0, 13, 14, 15, 241, 242, 18, 19, 0,
2842  0, 0, 0, 0, 243, 244, 245, 23, 24, 25,
2843  26, 0, 0, 203, 0, 0, 0, 0, 0, 0,
2844  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2845  39, 40, 204, 41, 42, 43, 44, 0, 45, 46,
2846  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2847  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2848  0, 0, 205, 0, 0, 206, 52, 0, 53, 54,
2849  0, 207, 208, 0, 56, 57, 58, 59, 60, 61,
2850  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
2851  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2852  10, 11, 65, 210, 67, 12, 0, 13, 14, 15,
2853  241, 242, 18, 19, 0, 0, 0, 0, 0, 243,
2854  244, 245, 23, 24, 25, 26, 0, 0, 203, 0,
2855  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2856  34, 35, 36, 37, 38, 39, 40, 204, 41, 42,
2857  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2858  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2859  0, 0, 0, 0, 0, 0, 0, 205, 0, 0,
2860  206, 52, 0, 53, 54, 0, 0, 208, 209, 56,
2861  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2862  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2863  0, 9, 0, 0, 0, 10, 11, 65, 210, 67,
2864  12, 0, 13, 14, 15, 241, 242, 18, 19, 0,
2865  0, 0, 0, 0, 243, 244, 245, 23, 24, 25,
2866  26, 0, 0, 203, 0, 0, 0, 0, 0, 0,
2867  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2868  39, 40, 204, 41, 42, 43, 44, 0, 45, 46,
2869  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2870  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2871  0, 0, 205, 0, 0, 206, 52, 0, 53, 54,
2872  0, 609, 208, 0, 56, 57, 58, 59, 60, 61,
2873  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
2874  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2875  10, 11, 65, 210, 67, 12, 0, 13, 14, 15,
2876  241, 242, 18, 19, 0, 0, 0, 0, 0, 243,
2877  244, 245, 23, 24, 25, 26, 0, 0, 203, 0,
2878  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2879  34, 35, 36, 37, 38, 39, 40, 204, 41, 42,
2880  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2881  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2882  0, 0, 0, 0, 0, 0, 0, 205, 0, 0,
2883  206, 52, 0, 53, 54, 0, 0, 208, 0, 56,
2884  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2885  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2886  0, 9, 0, 0, 0, 10, 11, 65, 210, 67,
2887  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2888  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2889  26, 0, 0, 203, 0, 0, 0, 0, 0, 0,
2890  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2891  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2892  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2893  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2894  0, 0, 205, 0, 0, 206, 52, 0, 53, 54,
2895  0, 512, 0, 0, 56, 57, 58, 59, 60, 61,
2896  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
2897  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2898  10, 11, 65, 210, 67, 12, 0, 13, 14, 15,
2899  241, 242, 18, 19, 0, 0, 0, 0, 0, 243,
2900  244, 245, 23, 24, 25, 26, 0, 0, 203, 0,
2901  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2902  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2903  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2904  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2905  0, 0, 0, 0, 0, 0, 0, 205, 0, 0,
2906  206, 52, 0, 53, 54, 0, 207, 0, 0, 56,
2907  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2908  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2909  0, 9, 0, 0, 0, 10, 11, 65, 210, 67,
2910  12, 0, 13, 14, 15, 241, 242, 18, 19, 0,
2911  0, 0, 0, 0, 243, 244, 245, 23, 24, 25,
2912  26, 0, 0, 203, 0, 0, 0, 0, 0, 0,
2913  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2914  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2915  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2916  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2917  0, 0, 205, 0, 0, 206, 52, 0, 53, 54,
2918  0, 817, 0, 0, 56, 57, 58, 59, 60, 61,
2919  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
2920  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2921  10, 11, 65, 210, 67, 12, 0, 13, 14, 15,
2922  241, 242, 18, 19, 0, 0, 0, 0, 0, 243,
2923  244, 245, 23, 24, 25, 26, 0, 0, 203, 0,
2924  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2925  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2926  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2927  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2928  0, 0, 0, 0, 0, 0, 0, 205, 0, 0,
2929  206, 52, 0, 53, 54, 0, 512, 0, 0, 56,
2930  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2931  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2932  0, 9, 0, 0, 0, 10, 11, 65, 210, 67,
2933  12, 0, 13, 14, 15, 241, 242, 18, 19, 0,
2934  0, 0, 0, 0, 243, 244, 245, 23, 24, 25,
2935  26, 0, 0, 203, 0, 0, 0, 0, 0, 0,
2936  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2937  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2938  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2939  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2940  0, 0, 205, 0, 0, 206, 52, 0, 53, 54,
2941  0, 609, 0, 0, 56, 57, 58, 59, 60, 61,
2942  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
2943  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2944  10, 11, 65, 210, 67, 12, 0, 13, 14, 15,
2945  241, 242, 18, 19, 0, 0, 0, 0, 0, 243,
2946  244, 245, 23, 24, 25, 26, 0, 0, 203, 0,
2947  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2948  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2949  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2950  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2951  0, 0, 0, 0, 0, 0, 0, 205, 0, 0,
2952  206, 52, 0, 53, 54, 0, 0, 0, 0, 56,
2953  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2954  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2955  0, 9, 0, 0, 0, 10, 11, 65, 210, 67,
2956  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2957  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2958  26, 0, 0, 203, 0, 0, 0, 0, 0, 0,
2959  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2960  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2961  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2962  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2963  0, 0, 205, 0, 0, 206, 52, 0, 53, 54,
2964  0, 0, 0, 0, 56, 57, 58, 59, 60, 61,
2965  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
2966  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
2967  10, 11, 65, 210, 67, 12, 0, 13, 14, 15,
2968  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2969  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2970  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
2971  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2972  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
2973  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2974  0, 0, 0, 0, 0, 0, 0, 205, 0, 0,
2975  206, 52, 0, 53, 54, 0, 0, 0, 0, 56,
2976  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2977  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
2978  0, 9, 0, 0, 0, 10, 11, 65, 66, 67,
2979  12, 0, 13, 14, 15, 241, 242, 18, 19, 0,
2980  0, 0, 0, 0, 243, 244, 245, 23, 24, 25,
2981  26, 0, 0, 203, 0, 0, 0, 0, 0, 0,
2982  271, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2983  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2984  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2985  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2986  0, 0, 272, 0, 0, 325, 52, 0, 53, 54,
2987  0, 326, 0, 0, 56, 57, 58, 59, 60, 61,
2988  62, 63, 64, 0, 0, 0, 0, 0, 5, 6,
2989  7, 0, 9, 0, 0, 0, 10, 11, 0, 0,
2990  0, 12, 273, 13, 14, 15, 241, 242, 18, 19,
2991  0, 0, 0, 0, 0, 243, 244, 245, 23, 24,
2992  25, 26, 0, 0, 203, 0, 0, 0, 0, 0,
2993  0, 271, 0, 0, 32, 33, 34, 35, 36, 37,
2994  38, 39, 40, 0, 41, 42, 43, 44, 0, 45,
2995  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2996  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2997  0, 0, 0, 367, 0, 0, 51, 52, 0, 53,
2998  54, 0, 55, 0, 0, 56, 57, 58, 59, 60,
2999  61, 62, 63, 64, 0, 0, 0, 0, 0, 5,
3000  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
3001  0, 0, 12, 273, 13, 14, 15, 241, 242, 18,
3002  19, 0, 0, 0, 0, 0, 243, 244, 245, 23,
3003  24, 25, 26, 0, 0, 203, 0, 0, 0, 0,
3004  0, 0, 271, 0, 0, 32, 33, 34, 375, 36,
3005  37, 38, 376, 40, 0, 41, 42, 43, 44, 0,
3006  45, 46, 47, 0, 0, 0, 0, 0, 0, 0,
3007  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3008  0, 377, 0, 0, 378, 0, 0, 206, 52, 0,
3009  53, 54, 0, 0, 0, 0, 56, 57, 58, 59,
3010  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
3011  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
3012  0, 0, 0, 12, 273, 13, 14, 15, 241, 242,
3013  18, 19, 0, 0, 0, 0, 0, 243, 244, 245,
3014  23, 24, 25, 26, 0, 0, 203, 0, 0, 0,
3015  0, 0, 0, 271, 0, 0, 32, 33, 34, 375,
3016  36, 37, 38, 376, 40, 0, 41, 42, 43, 44,
3017  0, 45, 46, 47, 0, 0, 0, 0, 0, 0,
3018  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3019  0, 0, 0, 0, 0, 378, 0, 0, 206, 52,
3020  0, 53, 54, 0, 0, 0, 0, 56, 57, 58,
3021  59, 60, 61, 62, 63, 64, 0, 0, 0, 0,
3022  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
3023  11, 0, 0, 0, 12, 273, 13, 14, 15, 241,
3024  242, 18, 19, 0, 0, 0, 0, 0, 243, 244,
3025  245, 23, 24, 25, 26, 0, 0, 203, 0, 0,
3026  0, 0, 0, 0, 271, 0, 0, 32, 33, 34,
3027  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
3028  44, 0, 45, 46, 47, 0, 0, 0, 0, 0,
3029  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3030  0, 0, 0, 0, 0, 0, 272, 0, 0, 325,
3031  52, 0, 53, 54, 0, 0, 0, 0, 56, 57,
3032  58, 59, 60, 61, 62, 63, 64, 0, 0, 0,
3033  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
3034  10, 11, 0, 0, 0, 12, 273, 13, 14, 15,
3035  241, 242, 18, 19, 0, 0, 0, 0, 0, 243,
3036  244, 245, 23, 24, 25, 26, 0, 0, 203, 0,
3037  0, 0, 0, 0, 0, 271, 0, 0, 32, 33,
3038  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
3039  43, 44, 0, 45, 46, 47, 0, 0, 0, 0,
3040  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3041  0, 0, 0, 0, 0, 0, 0, 899, 0, 0,
3042  206, 52, 0, 53, 54, 0, 0, 0, 0, 56,
3043  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
3044  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3045  0, 10, 11, 0, 0, 0, 12, 273, 13, 14,
3046  15, 241, 242, 18, 19, 0, 0, 0, 0, 0,
3047  243, 244, 245, 23, 24, 25, 26, 0, 0, 203,
3048  0, 0, 0, 0, 0, 0, 271, 0, 0, 32,
3049  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
3050  42, 43, 44, 0, 45, 46, 47, 0, 0, 0,
3051  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3052  0, 0, 0, 0, 0, 0, 0, 0, 976, 0,
3053  0, 206, 52, 0, 53, 54, 0, 0, 0, 0,
3054  56, 57, 58, 59, 60, 61, 62, 63, 64, 0,
3055  0, 0, 0, 554, 555, 0, 0, 556, 0, 0,
3056  0, 0, 0, 0, 0, 0, 0, 0, 273, 165,
3057  166, 167, 168, 169, 170, 171, 172, 173, 0, 0,
3058  174, 175, 0, 0, 176, 177, 178, 179, 0, 0,
3059  0, 0, 0, 0, 0, 0, 0, 0, 180, 181,
3060  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3061  0, 0, 0, 0, 0, 0, 0, 0, 0, 182,
3062  183, 184, 185, 186, 187, 188, 189, 190, 191, 0,
3063  192, 193, 562, 563, 0, 0, 564, 0, 194, 0,
3064  0, 0, 0, 0, 0, 0, 0, 0, 165, 166,
3065  167, 168, 169, 170, 171, 172, 173, 0, 0, 174,
3066  175, 0, 0, 176, 177, 178, 179, 0, 0, 0,
3067  0, 0, 0, 0, 0, 0, 0, 180, 181, 0,
3068  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3069  0, 0, 0, 0, 0, 0, 0, 0, 182, 183,
3070  184, 185, 186, 187, 188, 189, 190, 191, 0, 192,
3071  193, 599, 563, 0, 0, 600, 0, 194, 0, 0,
3072  0, 0, 0, 0, 0, 0, 0, 165, 166, 167,
3073  168, 169, 170, 171, 172, 173, 0, 0, 174, 175,
3074  0, 0, 176, 177, 178, 179, 0, 0, 0, 0,
3075  0, 0, 0, 0, 0, 0, 180, 181, 0, 0,
3076  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3077  0, 0, 0, 0, 0, 0, 0, 182, 183, 184,
3078  185, 186, 187, 188, 189, 190, 191, 0, 192, 193,
3079  613, 555, 0, 0, 614, 0, 194, 0, 0, 0,
3080  0, 0, 0, 0, 0, 0, 165, 166, 167, 168,
3081  169, 170, 171, 172, 173, 0, 0, 174, 175, 0,
3082  0, 176, 177, 178, 179, 0, 0, 0, 0, 0,
3083  0, 0, 0, 0, 0, 180, 181, 0, 0, 0,
3084  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3085  0, 0, 0, 0, 0, 0, 182, 183, 184, 185,
3086  186, 187, 188, 189, 190, 191, 0, 192, 193, 616,
3087  563, 0, 0, 617, 0, 194, 0, 0, 0, 0,
3088  0, 0, 0, 0, 0, 165, 166, 167, 168, 169,
3089  170, 171, 172, 173, 0, 0, 174, 175, 0, 0,
3090  176, 177, 178, 179, 0, 0, 0, 0, 0, 0,
3091  0, 0, 0, 0, 180, 181, 0, 0, 0, 0,
3092  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3093  0, 0, 0, 0, 0, 182, 183, 184, 185, 186,
3094  187, 188, 189, 190, 191, 0, 192, 193, 640, 555,
3095  0, 0, 641, 0, 194, 0, 0, 0, 0, 0,
3096  0, 0, 0, 0, 165, 166, 167, 168, 169, 170,
3097  171, 172, 173, 0, 0, 174, 175, 0, 0, 176,
3098  177, 178, 179, 0, 0, 0, 0, 0, 0, 0,
3099  0, 0, 0, 180, 181, 0, 0, 0, 0, 0,
3100  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3101  0, 0, 0, 0, 182, 183, 184, 185, 186, 187,
3102  188, 189, 190, 191, 0, 192, 193, 643, 563, 0,
3103  0, 644, 0, 194, 0, 0, 0, 0, 0, 0,
3104  0, 0, 0, 165, 166, 167, 168, 169, 170, 171,
3105  172, 173, 0, 0, 174, 175, 0, 0, 176, 177,
3106  178, 179, 0, 0, 0, 0, 0, 0, 0, 0,
3107  0, 0, 180, 181, 0, 0, 0, 0, 0, 0,
3108  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3109  0, 0, 0, 182, 183, 184, 185, 186, 187, 188,
3110  189, 190, 191, 0, 192, 193, 728, 555, 0, 0,
3111  729, 0, 194, 0, 0, 0, 0, 0, 0, 0,
3112  0, 0, 165, 166, 167, 168, 169, 170, 171, 172,
3113  173, 0, 0, 174, 175, 0, 0, 176, 177, 178,
3114  179, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3115  0, 180, 181, 0, 0, 0, 0, 0, 0, 0,
3116  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3117  0, 0, 182, 183, 184, 185, 186, 187, 188, 189,
3118  190, 191, 0, 192, 193, 731, 563, 0, 0, 732,
3119  0, 194, 0, 0, 0, 0, 0, 0, 0, 0,
3120  0, 165, 166, 167, 168, 169, 170, 171, 172, 173,
3121  0, 0, 174, 175, 0, 0, 176, 177, 178, 179,
3122  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3123  180, 181, 0, 0, 0, 0, 0, 0, 0, 0,
3124  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3125  0, 182, 183, 184, 185, 186, 187, 188, 189, 190,
3126  191, 0, 192, 193, 738, 555, 0, 0, 739, 0,
3127  194, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3128  165, 166, 167, 168, 169, 170, 171, 172, 173, 0,
3129  0, 174, 175, 0, 0, 176, 177, 178, 179, 0,
3130  0, 0, 0, 0, 0, 0, 0, 0, 0, 180,
3131  181, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3132  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3133  182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
3134  0, 192, 193, 1008, 555, 0, 0, 1009, 0, 194,
3135  0, 0, 0, 0, 0, 0, 0, 0, 0, 165,
3136  166, 167, 168, 169, 170, 171, 172, 173, 0, 0,
3137  174, 175, 0, 0, 176, 177, 178, 179, 0, 0,
3138  0, 0, 0, 0, 0, 0, 0, 0, 180, 181,
3139  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3140  0, 0, 0, 0, 0, 0, 0, 0, 0, 182,
3141  183, 184, 185, 186, 187, 188, 189, 190, 191, 0,
3142  192, 193, 1039, 555, 0, 0, 1040, 0, 194, 0,
3143  0, 0, 0, 0, 0, 0, 0, 0, 165, 166,
3144  167, 168, 169, 170, 171, 172, 173, 0, 0, 174,
3145  175, 0, 0, 176, 177, 178, 179, 0, 0, 0,
3146  0, 0, 0, 0, 0, 0, 0, 180, 181, 0,
3147  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3148  0, 0, 0, 0, 0, 0, 0, 0, 182, 183,
3149  184, 185, 186, 187, 188, 189, 190, 191, 0, 192,
3150  193, 1042, 563, 0, 0, 1043, 0, 194, 0, 0,
3151  0, 0, 0, 0, 0, 0, 0, 165, 166, 167,
3152  168, 169, 170, 171, 172, 173, 0, 0, 174, 175,
3153  0, 0, 176, 177, 178, 179, 0, 0, 0, 0,
3154  0, 0, 0, 0, 0, 0, 180, 181, 329, 330,
3155  331, 332, 333, 334, 335, 336, 337, 338, 339, 340,
3156  341, 0, 0, 342, 343, 0, 0, 182, 183, 184,
3157  185, 186, 187, 188, 189, 190, 191, 0, 192, 193,
3158  0, 0, 0, 0, 0, 0, 194, 0, 0, 0,
3159  0, 0, 0, 0, 344, 0, 345, 346, 347, 348,
3160  349, 350, 351, 352, 353, 354, 0, 0, 0, 0,
3161  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3162  0, 234
3163 };
3164 
3165 #define yypact_value_is_default(yystate) \
3166  ((yystate) == (-816))
3167 
3168 #define yytable_value_is_error(yytable_value) \
3169  ((yytable_value) == (-627))
3170 
3171 static const yytype_int16 yycheck[] =
3172 {
3173  2, 27, 57, 29, 55, 16, 17, 356, 98, 20,
3174  233, 8, 28, 69, 89, 361, 328, 92, 81, 355,
3175  328, 357, 2, 223, 4, 576, 22, 4, 578, 595,
3176  81, 28, 686, 92, 8, 258, 92, 422, 261, 575,
3177  414, 96, 93, 94, 95, 265, 88, 89, 422, 269,
3178  92, 53, 54, 469, 28, 615, 65, 787, 51, 8,
3179  57, 670, 442, 16, 17, 401, 473, 20, 716, 418,
3180  76, 55, 720, 16, 17, 460, 2, 20, 4, 28,
3181  76, 417, 642, 419, 378, 778, 27, 874, 26, 904,
3182  16, 17, 25, 289, 20, 291, 25, 293, 63, 96,
3183  53, 297, 26, 519, 908, 66, 69, 872, 63, 445,
3184  53, 54, 253, 25, 25, 1, 508, 87, 25, 511,
3185  775, 136, 471, 89, 778, 51, 13, 89, 143, 55,
3186  52, 25, 0, 787, 56, 87, 472, 87, 16, 17,
3187  66, 25, 20, 143, 109, 800, 111, 87, 78, 115,
3188  25, 25, 89, 115, 109, 81, 111, 99, 141, 132,
3189  143, 13, 88, 89, 63, 135, 92, 93, 94, 95,
3190  730, 737, 13, 37, 38, 725, 941, 142, 115, 745,
3191  122, 741, 13, 135, 325, 135, 15, 142, 17, 1004,
3192  120, 233, 742, 235, 132, 135, 255, 806, 807, 255,
3193  141, 424, 143, 136, 897, 428, 993, 136, 132, 138,
3194  433, 274, 1016, 112, 138, 217, 227, 947, 229, 230,
3195  262, 223, 56, 274, 136, 136, 449, 138, 230, 136,
3196  995, 431, 581, 119, 309, 310, 311, 312, 623, 686,
3197  246, 13, 136, 897, 593, 271, 582, 142, 622, 623,
3198  904, 658, 136, 633, 141, 141, 143, 143, 594, 952,
3199  253, 136, 136, 1028, 273, 142, 13, 309, 310, 311,
3200  312, 251, 314, 315, 227, 326, 229, 886, 138, 143,
3201  206, 697, 930, 143, 227, 63, 229, 362, 363, 141,
3202  486, 143, 255, 947, 844, 518, 846, 493, 592, 691,
3203  141, 227, 143, 229, 230, 364, 856, 233, 364, 235,
3204  141, 861, 143, 672, 240, 674, 136, 853, 1011, 142,
3205  362, 363, 28, 143, 380, 251, 29, 253, 308, 89,
3206  89, 308, 325, 313, 112, 377, 262, 744, 142, 746,
3207  787, 115, 326, 790, 26, 356, 136, 658, 274, 227,
3208  1004, 229, 115, 87, 356, 115, 115, 966, 102, 25,
3209  357, 136, 323, 87, 136, 136, 932, 328, 143, 141,
3210  323, 143, 87, 25, 704, 328, 87, 927, 928, 930,
3211  726, 711, 308, 309, 310, 311, 312, 313, 314, 315,
3212  698, 138, 89, 115, 141, 89, 143, 323, 87, 325,
3213  326, 135, 328, 715, 401, 87, 469, 418, 138, 51,
3214  113, 135, 612, 636, 136, 56, 418, 637, 469, 134,
3215  135, 115, 419, 439, 135, 115, 992, 139, 430, 431,
3216  356, 143, 358, 744, 87, 746, 362, 363, 87, 90,
3217  442, 991, 439, 404, 405, 134, 135, 138, 445, 115,
3218  132, 377, 134, 135, 89, 70, 519, 904, 136, 906,
3219  471, 136, 442, 115, 132, 439, 138, 87, 519, 471,
3220  136, 414, 70, 139, 1024, 472, 1026, 143, 404, 405,
3221  87, 1041, 135, 868, 136, 134, 135, 139, 63, 138,
3222  439, 143, 418, 52, 868, 54, 55, 56, 57, 138,
3223  947, 139, 949, 87, 89, 507, 508, 954, 87, 511,
3224  125, 126, 127, 26, 457, 135, 442, 543, 574, 575,
3225  743, 37, 38, 115, 883, 884, 452, 134, 135, 888,
3226  115, 890, 588, 892, 109, 561, 111, 112, 140, 762,
3227  686, 14, 15, 469, 52, 471, 54, 55, 56, 57,
3228  773, 135, 558, 87, 596, 134, 135, 1004, 56, 1006,
3229  566, 761, 133, 559, 206, 112, 1013, 569, 26, 63,
3230  581, 567, 918, 686, 87, 638, 136, 136, 924, 581,
3231  89, 112, 593, 1030, 626, 582, 112, 638, 112, 615,
3232  606, 593, 70, 519, 96, 601, 136, 594, 240, 601,
3233  134, 135, 17, 63, 1051, 601, 115, 56, 63, 606,
3234  612, 253, 67, 141, 26, 109, 642, 111, 112, 132,
3235  25, 134, 135, 142, 577, 138, 136, 136, 136, 87,
3236  133, 633, 606, 139, 697, 781, 136, 860, 63, 785,
3237  999, 1000, 1001, 1002, 132, 571, 697, 573, 871, 109,
3238  87, 111, 112, 633, 109, 581, 111, 606, 733, 749,
3239  686, 736, 686, 142, 136, 136, 668, 593, 670, 595,
3240  596, 1020, 136, 136, 132, 87, 134, 135, 734, 622,
3241  138, 115, 89, 325, 109, 1021, 111, 112, 87, 691,
3242  1049, 733, 747, 136, 736, 10, 138, 134, 135, 705,
3243  626, 8, 13, 138, 730, 89, 712, 633, 115, 133,
3244  712, 115, 638, 715, 716, 741, 718, 136, 720, 136,
3245  132, 63, 134, 135, 52, 136, 138, 136, 2, 136,
3246  4, 115, 87, 54, 52, 134, 135, 698, 87, 136,
3247  701, 702, 16, 17, 65, 66, 20, 708, 709, 775,
3248  747, 897, 136, 804, 52, 901, 136, 781, 904, 761,
3249  906, 687, 715, 117, 690, 140, 692, 109, 843, 111,
3250  112, 697, 698, 87, 800, 701, 702, 51, 70, 134,
3251  135, 15, 708, 709, 897, 134, 135, 133, 901, 136,
3252  87, 904, 66, 906, 120, 136, 87, 853, 115, 855,
3253  58, 843, 136, 136, 806, 807, 862, 733, 87, 136,
3254  736, 737, 70, 136, 88, 89, 141, 10, 92, 745,
3255  134, 135, 10, 133, 52, 89, 54, 55, 56, 57,
3256  58, 123, 124, 125, 126, 127, 838, 134, 135, 841,
3257  98, 99, 70, 134, 135, 896, 136, 90, 2, 89,
3258  4, 115, 809, 810, 9, 134, 135, 89, 1004, 89,
3259  1006, 136, 139, 91, 122, 1011, 917, 1013, 829, 136,
3260  98, 99, 136, 897, 136, 115, 136, 901, 804, 136,
3261  904, 120, 906, 115, 886, 115, 56, 133, 136, 815,
3262  10, 1004, 136, 1006, 122, 133, 136, 51, 1011, 110,
3263  1013, 55, 138, 829, 136, 1051, 136, 40, 41, 42,
3264  43, 44, 54, 55, 840, 57, 136, 843, 136, 70,
3265  136, 847, 848, 65, 66, 851, 136, 81, 930, 571,
3266  56, 573, 206, 136, 85, 86, 136, 138, 1051, 93,
3267  94, 95, 96, 93, 136, 52, 972, 54, 55, 56,
3268  57, 877, 878, 227, 95, 229, 230, 452, 712, 233,
3269  769, 235, 1023, 686, 966, 750, 240, 893, 1016, 1022,
3270  896, 122, 123, 124, 125, 126, 127, 251, 101, 253,
3271  1004, 297, 1006, 59, 91, 96, 781, 1011, 262, 1013,
3272  97, 917, 938, 901, 52, 921, 54, 55, 56, 57,
3273  59, 60, 61, 62, 961, 962, 932, 897, 778, 1020,
3274  967, 398, 969, 970, 70, 1041, -1, -1, 1020, -1,
3275  1022, 1023, -1, -1, 1021, -1, -1, 1051, -1, 85,
3276  86, -1, -1, 91, 308, 309, 310, 311, 312, 313,
3277  314, 315, -1, -1, -1, 687, -1, -1, 690, 323,
3278  692, 325, 206, -1, 328, -1, 982, 52, 984, 54,
3279  55, 56, 57, -1, 990, -1, 992, 123, 124, 125,
3280  126, 127, 16, 17, -1, -1, 20, 1034, 1035, 1036,
3281  1037, -1, 356, -1, 358, -1, 240, -1, 362, 363,
3282  -1, -1, -1, -1, 1020, -1, 91, 251, -1, 253,
3283  1057, -1, 97, 377, 48, 49, -1, -1, -1, 53,
3284  54, 52, -1, 54, 55, 56, 57, 58, -1, -1,
3285  274, -1, 66, 67, -1, -1, -1, -1, -1, 70,
3286  404, 405, 52, -1, 54, 55, 56, 57, -1, -1,
3287  -1, -1, -1, 52, 418, 54, 55, 56, 57, 58,
3288  91, -1, -1, -1, 308, -1, 97, 98, 99, 313,
3289  -1, 70, -1, -1, -1, -1, -1, -1, 442, -1,
3290  70, 325, 326, 815, -1, -1, -1, -1, 452, -1,
3291  -1, 122, 91, -1, 125, 85, 86, -1, 97, 98,
3292  99, -1, -1, -1, -1, -1, -1, 471, 840, -1,
3293  -1, -1, 143, -1, 358, 847, 848, -1, -1, 851,
3294  -1, -1, -1, 122, -1, -1, 125, -1, -1, -1,
3295  120, 121, 122, 123, 124, 125, 126, 127, -1, 138,
3296  -1, 0, -1, -1, -1, 877, 878, -1, -1, 8,
3297  9, 10, -1, -1, 13, 14, 15, -1, 17, -1,
3298  -1, 893, 2, -1, 4, -1, -1, 26, 27, -1,
3299  204, -1, -1, 207, 208, 209, 210, -1, 37, 38,
3300  -1, 40, 41, 42, 43, 44, -1, -1, -1, 921,
3301  -1, -1, -1, 227, -1, 229, 230, -1, 442, -1,
3302  -1, -1, -1, -1, -1, -1, -1, 571, 452, 573,
3303  -1, 51, -1, -1, -1, 55, -1, 581, 52, -1,
3304  54, 55, 56, 57, 58, 469, -1, -1, 87, 593,
3305  -1, 595, 596, -1, -1, -1, 70, -1, -1, -1,
3306  -1, 81, -1, -1, -1, -1, -1, -1, -1, -1,
3307  982, 110, 984, 93, 94, 95, 96, 91, 990, -1,
3308  -1, -1, 626, 97, 98, 99, -1, -1, -1, 633,
3309  -1, -1, -1, 132, 133, 519, 135, -1, -1, 138,
3310  139, -1, 141, -1, 143, -1, -1, -1, 122, 323,
3311  -1, 125, -1, -1, 328, 329, 330, 331, 332, 333,
3312  334, 335, 336, 337, 338, 339, 340, 341, 342, 343,
3313  344, 345, 346, 347, 348, 349, 350, 351, 352, 353,
3314  354, -1, 356, 687, -1, -1, 690, 571, 692, 573,
3315  -1, -1, -1, -1, 698, -1, -1, 701, 702, -1,
3316  473, -1, -1, -1, 708, 709, -1, -1, -1, -1,
3317  -1, 595, -1, -1, -1, -1, -1, -1, -1, -1,
3318  -1, -1, -1, -1, -1, -1, 206, -1, -1, 733,
3319  404, 405, 736, 737, -1, -1, -1, -1, 412, 413,
3320  414, 745, -1, -1, 418, -1, 420, 421, 422, 633,
3321  -1, -1, -1, -1, 638, -1, -1, -1, -1, -1,
3322  240, -1, -1, -1, -1, -1, -1, 441, -1, -1,
3323  -1, 251, 446, 253, -1, -1, -1, -1, -1, -1,
3324  -1, -1, -1, 457, -1, -1, 460, -1, -1, -1,
3325  -1, -1, -1, -1, 274, -1, -1, 471, -1, -1,
3326  -1, -1, -1, 687, -1, -1, 690, -1, 692, -1,
3327  -1, 815, -1, 697, -1, -1, -1, -1, -1, -1,
3328  -1, -1, -1, 497, -1, 829, -1, -1, 308, -1,
3329  -1, -1, -1, 313, -1, -1, 840, -1, 512, 843,
3330  -1, -1, -1, 847, 848, 325, 326, 851, -1, -1,
3331  -1, -1, -1, 737, -1, -1, -1, -1, -1, -1,
3332  -1, 745, -1, -1, -1, -1, -1, -1, -1, 2,
3333  -1, 4, -1, 877, 878, -1, -1, -1, 358, 652,
3334  -1, -1, -1, -1, -1, 658, -1, -1, -1, 893,
3335  2, -1, 4, -1, -1, -1, -1, -1, -1, -1,
3336  -1, -1, -1, 577, -1, -1, -1, 581, -1, -1,
3337  -1, -1, -1, 686, -1, -1, -1, 921, 51, 593,
3338  804, -1, -1, -1, -1, -1, -1, -1, 932, -1,
3339  -1, 815, -1, -1, -1, 609, -1, -1, -1, 51,
3340  -1, -1, -1, 55, -1, -1, -1, -1, 622, 623,
3341  -1, -1, -1, -1, -1, -1, 840, -1, -1, -1,
3342  -1, -1, 442, 847, 848, -1, -1, 851, -1, 81,
3343  -1, 744, 452, 746, -1, -1, -1, 2, 982, 4,
3344  984, 93, 94, 95, -1, -1, 990, -1, 992, 469,
3345  -1, -1, 666, 877, 878, -1, 769, 770, -1, -1,
3346  -1, -1, -1, -1, -1, 778, -1, -1, -1, 893,
3347  -1, -1, 896, -1, 787, -1, 1020, -1, -1, -1,
3348  694, -1, -1, -1, 698, 699, 51, 701, 702, -1,
3349  -1, -1, -1, 917, 708, 709, -1, 921, -1, 519,
3350  -1, 715, -1, -1, -1, -1, -1, -1, 932, -1,
3351  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3352  -1, -1, -1, -1, -1, -1, -1, -1, 93, -1,
3353  -1, -1, -1, 206, -1, -1, -1, -1, 752, -1,
3354  -1, -1, 756, 757, -1, 759, 760, 54, -1, -1,
3355  -1, 571, -1, 573, 206, -1, -1, -1, 982, 872,
3356  984, 874, -1, 777, -1, -1, 990, 240, 992, -1,
3357  -1, -1, -1, -1, -1, 595, -1, -1, 251, -1,
3358  253, -1, -1, -1, 897, -1, -1, -1, 240, -1,
3359  -1, 904, -1, -1, -1, -1, -1, -1, -1, 251,
3360  -1, 253, -1, 817, -1, -1, -1, 821, -1, -1,
3361  -1, -1, -1, 633, -1, 829, -1, -1, 638, -1,
3362  -1, -1, 274, -1, -1, -1, -1, -1, 941, 942,
3363  -1, -1, -1, -1, 947, 308, 850, -1, -1, -1,
3364  313, 206, -1, -1, -1, -1, -1, -1, -1, -1,
3365  -1, -1, 325, 867, 868, -1, 308, -1, -1, -1,
3366  -1, 313, -1, -1, -1, -1, -1, 687, -1, -1,
3367  690, -1, 692, 325, 326, 240, -1, 697, -1, -1,
3368  993, -1, 995, -1, -1, 358, 251, -1, 253, -1,
3369  -1, 1004, -1, -1, -1, -1, -1, 204, -1, -1,
3370  207, 208, 209, -1, -1, -1, 358, -1, -1, -1,
3371  -1, -1, -1, -1, -1, 1028, -1, 737, -1, -1,
3372  -1, -1, -1, -1, -1, 745, -1, -1, -1, -1,
3373  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3374  -1, -1, -1, 308, -1, -1, -1, -1, 313, -1,
3375  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3376  325, -1, -1, 328, -1, -1, -1, -1, -1, 442,
3377  -1, -1, -1, -1, -1, -1, -1, -1, -1, 452,
3378  -1, -1, -1, -1, 804, -1, -1, -1, -1, -1,
3379  442, -1, -1, 358, -1, 815, -1, -1, -1, -1,
3380  452, -1, -1, -1, -1, -1, 1020, -1, -1, -1,
3381  -1, -1, -1, -1, -1, -1, 323, 469, -1, -1,
3382  840, 328, -1, -1, -1, -1, -1, 847, 848, -1,
3383  -1, 851, -1, -1, -1, -1, -1, -1, -1, -1,
3384  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3385  -1, -1, -1, -1, -1, -1, -1, 877, 878, -1,
3386  -1, -1, -1, -1, -1, -1, -1, 519, -1, -1,
3387  -1, -1, -1, 893, -1, -1, 896, 442, -1, 70,
3388  71, 72, 73, 74, 75, 76, 77, 452, 79, 80,
3389  -1, -1, -1, -1, 85, 86, -1, 917, 571, -1,
3390  573, 921, -1, -1, -1, -1, 413, 414, -1, -1,
3391  -1, -1, 932, -1, -1, 422, -1, -1, -1, 571,
3392  -1, 573, 595, -1, -1, -1, -1, 118, 119, 120,
3393  121, 122, 123, 124, 125, 126, 127, -1, -1, -1,
3394  -1, -1, -1, 595, -1, -1, -1, -1, -1, -1,
3395  457, -1, -1, 460, -1, -1, -1, -1, -1, -1,
3396  633, -1, 982, -1, 984, -1, -1, -1, -1, -1,
3397  990, -1, 992, -1, -1, -1, -1, -1, -1, -1,
3398  -1, 633, -1, -1, -1, -1, 638, -1, -1, -1,
3399  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3400  -1, -1, -1, -1, -1, 512, 571, -1, 573, -1,
3401  -1, -1, -1, -1, 687, -1, -1, 690, -1, 692,
3402  -1, -1, -1, -1, -1, -1, 678, -1, -1, -1,
3403  595, -1, -1, -1, -1, 687, -1, -1, 690, -1,
3404  692, -1, -1, -1, -1, 697, -1, -1, -1, -1,
3405  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3406  -1, -1, -1, -1, 737, -1, -1, -1, 633, -1,
3407  577, -1, 745, -1, -1, -1, -1, -1, -1, -1,
3408  -1, -1, -1, -1, -1, 737, -1, -1, -1, -1,
3409  -1, -1, -1, 745, -1, -1, -1, -1, -1, -1,
3410  -1, -1, 609, -1, -1, -1, -1, -1, -1, -1,
3411  -1, -1, -1, -1, -1, 622, 623, -1, -1, -1,
3412  -1, -1, 687, -1, -1, 690, -1, 692, -1, -1,
3413  -1, -1, -1, 698, -1, -1, -1, -1, -1, -1,
3414  -1, -1, 815, -1, -1, -1, -1, -1, -1, -1,
3415  -1, -1, 804, -1, -1, -1, -1, -1, -1, 666,
3416  -1, -1, -1, 815, -1, -1, -1, 840, -1, -1,
3417  -1, -1, 737, -1, 847, 848, -1, -1, 851, -1,
3418  745, -1, -1, -1, -1, -1, -1, 694, 840, -1,
3419  -1, -1, -1, -1, -1, 847, 848, -1, -1, 851,
3420  -1, -1, -1, -1, 877, 878, -1, -1, 715, -1,
3421  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3422  893, -1, -1, -1, -1, 877, 878, -1, -1, -1,
3423  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3424  -1, 893, -1, -1, 896, -1, -1, -1, 921, -1,
3425  815, 70, 71, 72, 73, 74, 75, 76, -1, 932,
3426  79, 80, -1, -1, -1, 917, 85, 86, -1, 921,
3427  777, -1, -1, -1, -1, 840, -1, -1, -1, -1,
3428  932, -1, 847, 848, -1, -1, 851, -1, -1, -1,
3429  -1, -1, -1, -1, -1, -1, -1, -1, -1, 118,
3430  119, 120, 121, 122, 123, 124, 125, 126, 127, 982,
3431  817, 984, 877, 878, -1, -1, -1, 990, -1, 992,
3432  -1, -1, -1, -1, -1, -1, -1, -1, 893, -1,
3433  982, -1, 984, -1, -1, -1, -1, -1, 990, -1,
3434  992, -1, -1, 850, 70, 71, 72, 73, 74, 75,
3435  76, -1, 917, 79, 80, -1, 921, -1, -1, 85,
3436  86, 868, -1, -1, -1, -1, -1, 932, -1, -1,
3437  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3438  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3439  -1, -1, 118, 119, 120, 121, 122, 123, 124, 125,
3440  126, 127, -1, -1, -1, -1, -1, -1, -1, -1,
3441  -1, -1, -1, -1, -1, -1, -1, 982, -1, 984,
3442  -1, -1, -1, -1, -1, 990, -1, 992, 0, 1,
3443  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
3444  12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
3445  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3446  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3447  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3448  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
3449  62, -1, 64, 65, 66, -1, 68, 69, -1, -1,
3450  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3451  -1, -1, -1, -1, -1, -1, 88, -1, -1, 91,
3452  92, -1, 94, 95, -1, 97, -1, -1, 100, 101,
3453  102, 103, 104, 105, 106, 107, 108, 0, -1, -1,
3454  -1, -1, -1, -1, -1, 8, 9, 10, -1, -1,
3455  13, 14, 15, -1, 17, -1, 128, 129, 130, -1,
3456  44, -1, -1, 26, 27, 28, 29, -1, -1, 141,
3457  -1, 143, -1, -1, 37, 38, -1, 40, 41, 42,
3458  43, 44, -1, -1, -1, -1, 70, 71, 72, 73,
3459  74, 75, 76, 77, 78, 79, 80, 81, 82, -1,
3460  -1, 85, 86, -1, -1, -1, -1, 70, 71, 72,
3461  73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
3462  -1, -1, 85, 86, 87, -1, 89, 90, -1, -1,
3463  -1, -1, 116, 96, 118, 119, 120, 121, 122, 123,
3464  124, 125, 126, 127, -1, -1, -1, 110, -1, -1,
3465  113, -1, 115, 116, 117, 118, 119, 120, 121, 122,
3466  123, 124, 125, 126, 127, -1, -1, -1, -1, 132,
3467  133, 134, 135, 136, 0, -1, 139, 140, 141, -1,
3468  143, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3469  -1, 17, -1, -1, -1, -1, -1, 44, -1, 25,
3470  -1, 27, 28, 29, -1, -1, -1, -1, -1, -1,
3471  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3472  -1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
3473  77, 78, 79, 80, 81, 82, -1, -1, 85, 86,
3474  -1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
3475  76, 77, 78, 79, 80, 81, 82, -1, -1, 85,
3476  86, 87, -1, 89, 90, -1, -1, -1, -1, 116,
3477  96, 118, 119, 120, 121, 122, 123, 124, 125, 126,
3478  127, -1, -1, -1, 110, -1, -1, 113, -1, 115,
3479  116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
3480  126, 127, -1, -1, -1, -1, -1, 133, 134, 135,
3481  136, 0, -1, 139, 140, 141, -1, 143, -1, 8,
3482  9, 10, -1, -1, 13, 14, 15, -1, 17, -1,
3483  -1, -1, -1, -1, -1, -1, 25, -1, 27, 28,
3484  29, -1, -1, -1, -1, -1, -1, -1, 37, 38,
3485  -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
3486  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3487  80, 81, 82, -1, -1, 85, 86, -1, -1, -1,
3488  -1, 70, 71, 72, 73, 74, 75, 76, 77, 78,
3489  79, 80, 81, 82, -1, -1, 85, 86, 87, -1,
3490  89, 90, -1, -1, -1, -1, 116, 96, 118, 119,
3491  120, 121, 122, 123, 124, 125, 126, 127, -1, -1,
3492  -1, 110, -1, -1, 113, -1, 115, 116, 117, 118,
3493  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
3494  -1, -1, -1, -1, 133, 134, 135, 136, 0, -1,
3495  139, 140, 141, -1, 143, -1, 8, 9, 10, -1,
3496  -1, 13, 14, 15, -1, 17, -1, -1, -1, -1,
3497  -1, 44, -1, -1, 26, 27, 28, 29, -1, -1,
3498  -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
3499  42, 43, 44, -1, -1, -1, -1, 70, 71, 72,
3500  73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
3501  -1, -1, 85, 86, -1, -1, -1, -1, 70, 71,
3502  72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
3503  82, -1, -1, 85, 86, 87, -1, -1, 90, -1,
3504  -1, -1, -1, 116, 96, 118, 119, 120, 121, 122,
3505  123, 124, 125, 126, 127, -1, -1, -1, 110, -1,
3506  -1, 113, -1, 136, 116, 117, 118, 119, 120, 121,
3507  122, 123, 124, 125, 126, 127, -1, -1, -1, -1,
3508  132, 133, 134, 135, 136, 0, -1, 139, 140, 141,
3509  -1, 143, -1, 8, 9, 10, -1, -1, 13, 14,
3510  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3511  -1, 26, 27, 28, 29, -1, -1, -1, -1, -1,
3512  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3513  -1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
3514  76, 77, 78, 79, 80, 81, 82, -1, -1, 85,
3515  86, -1, -1, -1, -1, 70, 71, 72, 73, 74,
3516  75, 76, 77, 78, 79, 80, 81, 82, -1, -1,
3517  85, 86, 87, -1, -1, 90, -1, -1, -1, -1,
3518  -1, 96, 118, 119, 120, 121, 122, 123, 124, 125,
3519  126, 127, -1, -1, -1, 110, -1, -1, 113, -1,
3520  -1, 116, 117, 118, 119, 120, 121, 122, 123, 124,
3521  125, 126, 127, -1, -1, -1, -1, 132, 133, 134,
3522  135, 136, 0, -1, 139, 140, 141, -1, 143, -1,
3523  8, 9, 10, -1, -1, 13, 14, 15, -1, 17,
3524  -1, -1, -1, -1, -1, -1, -1, -1, -1, 27,
3525  28, 29, -1, -1, -1, -1, -1, -1, -1, 37,
3526  38, -1, 40, 41, 42, 43, 44, -1, -1, -1,
3527  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3528  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3529  -1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
3530  78, 79, 80, 81, 82, -1, -1, 85, 86, 87,
3531  -1, 89, 90, -1, -1, -1, -1, -1, 96, -1,
3532  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3533  -1, -1, 110, -1, -1, 113, -1, 115, 116, 117,
3534  118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
3535  -1, -1, -1, -1, -1, 133, 134, 135, 136, 0,
3536  -1, 139, 140, 141, -1, 143, -1, 8, 9, 10,
3537  -1, -1, 13, 14, 15, -1, 17, -1, -1, -1,
3538  -1, -1, -1, -1, -1, 26, 27, 28, -1, -1,
3539  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3540  41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
3541  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3542  -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
3543  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3544  81, 82, -1, -1, 85, 86, 87, -1, -1, 90,
3545  -1, -1, -1, -1, -1, 96, -1, -1, -1, -1,
3546  -1, -1, -1, -1, -1, -1, -1, -1, -1, 110,
3547  -1, -1, -1, -1, -1, 116, -1, 118, 119, 120,
3548  121, 122, 123, 124, 125, 126, 127, -1, -1, -1,
3549  -1, 132, 133, 134, 135, 136, 0, 138, 139, 140,
3550  141, -1, 143, -1, 8, 9, 10, -1, -1, 13,
3551  14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
3552  -1, -1, -1, 27, 28, 29, -1, -1, -1, -1,
3553  -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
3554  44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3555  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3556  -1, -1, -1, -1, -1, -1, 70, 71, 72, 73,
3557  74, 75, 76, 77, 78, 79, 80, 81, 82, -1,
3558  -1, 85, 86, 87, -1, -1, 90, -1, -1, -1,
3559  -1, -1, 96, -1, -1, -1, -1, -1, -1, -1,
3560  -1, -1, -1, -1, -1, -1, 110, -1, -1, 113,
3561  -1, -1, 116, 117, 118, 119, 120, 121, 122, 123,
3562  124, 125, 126, 127, -1, -1, -1, -1, -1, 133,
3563  134, 135, 136, 0, -1, 139, 140, 141, -1, 143,
3564  -1, 8, 9, 10, -1, -1, 13, 14, 15, -1,
3565  17, -1, -1, -1, -1, -1, -1, -1, -1, 26,
3566  27, 28, -1, -1, -1, -1, -1, -1, -1, -1,
3567  37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
3568  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3569  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3570  -1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
3571  77, 78, 79, 80, 81, 82, -1, -1, 85, 86,
3572  87, -1, -1, 90, -1, -1, -1, -1, -1, 96,
3573  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3574  -1, -1, -1, 110, -1, -1, -1, -1, -1, 116,
3575  -1, 118, 119, 120, 121, 122, 123, 124, 125, 126,
3576  127, -1, -1, -1, -1, 132, 133, 134, 135, 136,
3577  0, 138, 139, 140, 141, -1, 143, -1, 8, 9,
3578  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3579  -1, -1, -1, -1, -1, -1, -1, 27, 28, -1,
3580  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3581  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3582  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3583  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3584  70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
3585  80, 81, 82, -1, -1, 85, 86, 87, -1, -1,
3586  90, -1, -1, -1, -1, -1, 96, -1, -1, -1,
3587  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3588  110, -1, -1, -1, -1, -1, 116, -1, 118, 119,
3589  120, 121, 122, 123, 124, 125, 126, 127, -1, -1,
3590  -1, -1, -1, 133, 134, 135, 136, 0, 138, 139,
3591  140, 141, -1, 143, -1, 8, 9, 10, -1, -1,
3592  -1, 14, 15, -1, 17, -1, -1, -1, -1, -1,
3593  -1, -1, -1, 26, -1, -1, -1, -1, -1, -1,
3594  -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
3595  43, 44, -1, -1, -1, -1, -1, -1, -1, -1,
3596  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3597  -1, -1, -1, -1, -1, -1, -1, 70, 71, 72,
3598  73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
3599  -1, -1, 85, 86, 87, -1, 89, -1, -1, -1,
3600  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3601  -1, -1, -1, -1, -1, -1, -1, 110, -1, -1,
3602  -1, -1, 115, 116, -1, 118, 119, 120, 121, 122,
3603  123, 124, 125, 126, 127, -1, -1, -1, -1, 132,
3604  133, 134, 135, 136, 0, -1, 139, -1, 141, -1,
3605  143, -1, 8, 9, 10, -1, -1, -1, 14, 15,
3606  -1, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3607  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3608  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3609  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3610  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3611  -1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
3612  76, 77, 78, 79, 80, 81, 82, -1, -1, 85,
3613  86, 87, -1, 89, -1, -1, -1, -1, -1, -1,
3614  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3615  -1, -1, -1, -1, 110, -1, -1, -1, -1, 115,
3616  116, -1, 118, 119, 120, 121, 122, 123, 124, 125,
3617  126, 127, -1, -1, -1, -1, -1, 133, 134, 135,
3618  136, -1, -1, 139, -1, 141, 1, 143, 3, 4,
3619  5, 6, 7, 8, 9, 10, 11, 12, -1, -1,
3620  15, 16, -1, 18, 19, 20, 21, 22, 23, 24,
3621  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3622  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3623  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
3624  55, 56, 57, -1, 59, 60, 61, 62, -1, 64,
3625  65, 66, -1, 68, 69, -1, -1, -1, -1, -1,
3626  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3627  -1, -1, -1, 88, -1, -1, 91, 92, -1, 94,
3628  95, -1, 97, -1, -1, 100, 101, 102, 103, 104,
3629  105, 106, 107, 108, -1, -1, -1, -1, -1, -1,
3630  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3631  -1, -1, -1, 128, 129, 130, -1, -1, -1, -1,
3632  -1, -1, -1, -1, -1, -1, 141, 1, 143, 3,
3633  4, 5, 6, 7, -1, -1, 10, 11, 12, -1,
3634  14, 15, 16, -1, 18, 19, 20, 21, 22, 23,
3635  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
3636  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3637  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3638  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
3639  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
3640  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3641  -1, -1, -1, -1, 88, -1, -1, 91, 92, -1,
3642  94, 95, -1, 97, -1, -1, 100, 101, 102, 103,
3643  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
3644  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3645  -1, -1, -1, -1, 128, 129, 130, -1, -1, -1,
3646  -1, -1, -1, -1, -1, -1, -1, 141, 1, 143,
3647  3, 4, 5, 6, 7, -1, -1, 10, 11, 12,
3648  -1, -1, 15, 16, 17, 18, 19, 20, 21, 22,
3649  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3650  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3651  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
3652  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
3653  -1, 64, 65, 66, -1, 68, 69, -1, -1, -1,
3654  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3655  -1, -1, -1, -1, -1, 88, -1, -1, 91, 92,
3656  -1, 94, 95, -1, 97, -1, -1, 100, 101, 102,
3657  103, 104, 105, 106, 107, 108, -1, -1, -1, -1,
3658  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3659  -1, -1, -1, -1, -1, 128, 129, 130, -1, -1,
3660  -1, -1, -1, -1, -1, -1, -1, -1, 141, 1,
3661  143, 3, 4, 5, 6, 7, -1, -1, 10, 11,
3662  12, -1, -1, 15, 16, -1, 18, 19, 20, 21,
3663  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
3664  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3665  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3666  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
3667  62, -1, 64, 65, 66, -1, 68, 69, -1, -1,
3668  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3669  -1, -1, -1, -1, -1, -1, 88, -1, -1, 91,
3670  92, -1, 94, 95, -1, 97, -1, -1, 100, 101,
3671  102, 103, 104, 105, 106, 107, 108, -1, -1, -1,
3672  -1, -1, -1, -1, 1, -1, 3, 4, 5, 6,
3673  7, -1, 9, 10, 11, 12, 128, 129, 130, 16,
3674  -1, 18, 19, 20, 21, 22, 23, 24, -1, 141,
3675  -1, 143, -1, 30, 31, 32, 33, 34, 35, 36,
3676  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
3677  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
3678  57, -1, 59, 60, 61, 62, -1, 64, 65, 66,
3679  -1, 68, 69, -1, -1, -1, -1, -1, -1, -1,
3680  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3681  -1, 88, -1, -1, 91, 92, -1, 94, 95, -1,
3682  97, -1, -1, 100, 101, 102, 103, 104, 105, 106,
3683  107, 108, -1, -1, -1, -1, -1, -1, -1, 1,
3684  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
3685  12, 128, 129, 130, 16, -1, 18, 19, 20, 21,
3686  22, 23, 24, -1, 141, -1, 143, -1, 30, 31,
3687  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
3688  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
3689  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
3690  62, -1, 64, 65, 66, -1, 68, 69, -1, -1,
3691  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3692  -1, -1, -1, -1, -1, -1, 88, -1, -1, 91,
3693  92, -1, 94, 95, -1, 97, -1, -1, 100, 101,
3694  102, 103, 104, 105, 106, 107, 108, -1, -1, -1,
3695  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3696  -1, -1, -1, -1, -1, -1, 128, 129, 130, -1,
3697  -1, -1, -1, -1, -1, -1, -1, 139, -1, 141,
3698  1, 143, 3, 4, 5, 6, 7, -1, -1, -1,
3699  11, 12, -1, -1, -1, 16, -1, 18, 19, 20,
3700  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3701  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3702  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3703  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3704  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
3705  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3706  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
3707  91, 92, -1, 94, 95, -1, 97, -1, -1, 100,
3708  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
3709  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3710  -1, -1, -1, -1, -1, -1, -1, 128, 129, 130,
3711  -1, -1, -1, -1, -1, -1, -1, -1, 139, -1,
3712  141, 1, 143, 3, 4, 5, 6, 7, -1, -1,
3713  -1, 11, 12, -1, -1, -1, 16, -1, 18, 19,
3714  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3715  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3716  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
3717  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
3718  60, 61, 62, -1, 64, 65, 66, -1, 68, 69,
3719  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3720  -1, -1, -1, -1, -1, -1, -1, -1, 88, -1,
3721  -1, 91, 92, -1, 94, 95, -1, 97, -1, -1,
3722  100, 101, 102, 103, 104, 105, 106, 107, 108, -1,
3723  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3724  -1, -1, -1, -1, -1, -1, -1, -1, 128, 129,
3725  130, -1, -1, 133, 1, -1, 3, 4, 5, 6,
3726  7, 141, -1, 143, 11, 12, -1, -1, -1, 16,
3727  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3728  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3729  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
3730  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
3731  57, -1, 59, 60, 61, 62, -1, 64, 65, 66,
3732  -1, 68, 69, -1, -1, -1, -1, -1, -1, -1,
3733  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3734  -1, 88, -1, -1, 91, 92, -1, 94, 95, -1,
3735  97, -1, -1, 100, 101, 102, 103, 104, 105, 106,
3736  107, 108, -1, -1, -1, -1, -1, -1, -1, -1,
3737  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3738  -1, 128, 129, 130, -1, -1, 133, -1, -1, -1,
3739  -1, -1, -1, -1, 141, 1, 143, 3, 4, 5,
3740  6, 7, -1, -1, 10, 11, 12, -1, -1, -1,
3741  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3742  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3743  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3744  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
3745  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
3746  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
3747  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3748  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
3749  -1, 97, -1, -1, 100, 101, 102, 103, 104, 105,
3750  106, 107, 108, -1, -1, -1, -1, -1, -1, -1,
3751  1, -1, 3, 4, 5, 6, 7, -1, -1, -1,
3752  11, 12, 128, 129, 130, 16, -1, 18, 19, 20,
3753  21, 22, 23, 24, -1, 141, -1, 143, -1, 30,
3754  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3755  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3756  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3757  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
3758  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3759  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
3760  91, 92, -1, 94, 95, -1, 97, -1, -1, 100,
3761  101, 102, 103, 104, 105, 106, 107, 108, -1, 110,
3762  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3763  -1, 7, -1, -1, -1, 11, 12, 128, 129, 130,
3764  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3765  141, -1, 143, -1, 30, 31, 32, 33, 34, 35,
3766  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3767  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3768  56, 57, 58, 59, 60, 61, 62, -1, 64, 65,
3769  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
3770  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3771  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
3772  -1, 97, 98, 99, 100, 101, 102, 103, 104, 105,
3773  106, 107, 108, -1, -1, -1, -1, -1, -1, -1,
3774  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3775  11, 12, 128, 129, 130, 16, -1, 18, 19, 20,
3776  21, 22, 23, 24, -1, -1, -1, 143, -1, 30,
3777  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3778  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3779  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3780  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
3781  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3782  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
3783  91, 92, -1, 94, 95, -1, -1, -1, -1, 100,
3784  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
3785  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3786  -1, 7, -1, -1, -1, 11, 12, 128, 129, 130,
3787  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3788  141, -1, 143, -1, 30, 31, 32, 33, 34, 35,
3789  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3790  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3791  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
3792  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
3793  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3794  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
3795  -1, -1, -1, -1, 100, 101, 102, 103, 104, 105,
3796  106, 107, 108, -1, -1, -1, -1, -1, -1, -1,
3797  -1, -1, 3, 4, 5, 6, 7, -1, -1, -1,
3798  11, 12, 128, 129, 130, 16, -1, 18, 19, 20,
3799  21, 22, 23, 24, -1, -1, -1, 143, -1, 30,
3800  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3801  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3802  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
3803  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
3804  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3805  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
3806  91, 92, -1, 94, 95, -1, 97, -1, -1, 100,
3807  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
3808  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3809  6, 7, -1, -1, -1, 11, 12, 128, 129, 130,
3810  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3811  141, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3812  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3813  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
3814  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
3815  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
3816  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3817  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
3818  -1, 97, -1, -1, 100, 101, 102, 103, 104, 105,
3819  106, 107, 108, -1, -1, -1, -1, -1, -1, -1,
3820  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3821  -1, -1, 128, 129, 130, -1, -1, -1, -1, -1,
3822  -1, -1, -1, -1, -1, 141, 3, 4, 5, 6,
3823  7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
3824  17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
3825  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3826  37, 38, 39, -1, -1, -1, -1, -1, 45, 46,
3827  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
3828  57, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3829  -1, 68, 69, 70, 71, 72, 73, 74, 75, 76,
3830  -1, -1, 79, 80, -1, -1, 83, 84, 85, 86,
3831  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3832  97, 98, -1, -1, -1, -1, -1, -1, -1, -1,
3833  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3834  -1, 118, 119, 120, 121, 122, 123, 124, 125, 126,
3835  127, -1, 129, 130, -1, -1, -1, -1, -1, -1,
3836  137, 138, 3, 4, 5, 6, 7, 8, 9, 10,
3837  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
3838  21, 22, 23, 24, 25, 26, -1, -1, -1, 30,
3839  31, 32, 33, 34, 35, 36, 37, 38, 39, -1,
3840  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3841  51, 52, 53, 54, 55, 56, 57, -1, -1, -1,
3842  -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
3843  71, 72, 73, 74, 75, 76, -1, -1, 79, 80,
3844  -1, -1, 83, 84, 85, 86, -1, -1, -1, -1,
3845  -1, -1, -1, -1, -1, -1, 97, 98, -1, -1,
3846  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3847  -1, -1, -1, -1, -1, -1, -1, 118, 119, 120,
3848  121, 122, 123, 124, 125, 126, 127, -1, 129, 130,
3849  -1, -1, -1, -1, -1, -1, 137, 3, 4, 5,
3850  6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
3851  16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3852  26, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3853  36, 37, 38, 39, -1, -1, -1, -1, -1, 45,
3854  46, 47, 48, 49, 50, 51, 52, 53, 54, -1,
3855  56, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3856  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3857  76, -1, -1, 79, 80, -1, -1, 83, 84, 85,
3858  86, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3859  -1, 97, 98, -1, -1, 101, -1, -1, -1, -1,
3860  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3861  -1, -1, 118, 119, 120, 121, 122, 123, 124, 125,
3862  126, 127, -1, 129, 130, -1, -1, -1, -1, -1,
3863  -1, 137, 3, 4, 5, 6, 7, 8, 9, 10,
3864  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
3865  21, 22, 23, 24, 25, 26, -1, -1, -1, 30,
3866  31, 32, 33, 34, 35, 36, 37, 38, 39, -1,
3867  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
3868  51, 52, 53, -1, -1, 56, -1, -1, -1, -1,
3869  -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
3870  71, 72, 73, 74, 75, 76, -1, -1, 79, 80,
3871  -1, -1, 83, 84, 85, 86, -1, -1, -1, -1,
3872  -1, -1, -1, -1, -1, -1, 97, 98, -1, -1,
3873  101, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3874  -1, -1, -1, -1, -1, -1, -1, 118, 119, 120,
3875  121, 122, 123, 124, 125, 126, 127, -1, 129, 130,
3876  -1, -1, -1, -1, -1, -1, 137, 3, 4, 5,
3877  6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
3878  16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
3879  26, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3880  36, 37, 38, 39, -1, -1, -1, -1, -1, 45,
3881  46, 47, 48, 49, 50, 51, 52, 53, -1, -1,
3882  56, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3883  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
3884  76, -1, -1, 79, 80, -1, -1, 83, 84, 85,
3885  86, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3886  -1, 97, 98, -1, -1, -1, -1, -1, -1, -1,
3887  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3888  -1, -1, 118, 119, 120, 121, 122, 123, 124, 125,
3889  126, 127, -1, 129, 130, 3, 4, 5, -1, 7,
3890  -1, 137, -1, 11, 12, -1, -1, -1, 16, -1,
3891  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
3892  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3893  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
3894  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3895  -1, 59, 60, 61, 62, -1, 64, 65, 66, -1,
3896  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3897  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3898  88, -1, -1, 91, 92, -1, 94, 95, -1, -1,
3899  -1, -1, 100, 101, 102, 103, 104, 105, 106, 107,
3900  108, -1, -1, -1, -1, -1, 3, 4, 5, -1,
3901  7, -1, -1, -1, 11, 12, -1, -1, -1, 16,
3902  128, 18, 19, 20, 21, 22, 23, 24, 136, -1,
3903  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3904  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
3905  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
3906  57, -1, 59, 60, 61, 62, -1, 64, 65, 66,
3907  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3908  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3909  -1, 88, -1, -1, 91, 92, -1, 94, 95, -1,
3910  -1, -1, -1, 100, 101, 102, 103, 104, 105, 106,
3911  107, 108, -1, -1, -1, -1, -1, 3, 4, 5,
3912  6, 7, -1, -1, -1, 11, 12, -1, -1, -1,
3913  16, 128, 18, 19, 20, 21, 22, 23, 24, 136,
3914  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3915  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3916  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
3917  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
3918  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
3919  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3920  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
3921  -1, 97, -1, -1, 100, 101, 102, 103, 104, 105,
3922  106, 107, 108, -1, -1, -1, -1, -1, -1, -1,
3923  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3924  11, 12, 128, 129, 130, 16, -1, 18, 19, 20,
3925  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3926  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3927  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3928  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3929  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
3930  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3931  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
3932  91, 92, -1, 94, 95, -1, 97, 98, 99, 100,
3933  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
3934  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3935  6, 7, -1, -1, -1, 11, 12, 128, 129, 130,
3936  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3937  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3938  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
3939  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
3940  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
3941  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
3942  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3943  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
3944  -1, 97, -1, -1, 100, 101, 102, 103, 104, 105,
3945  106, 107, 108, -1, -1, -1, -1, -1, -1, -1,
3946  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3947  11, 12, 128, 129, 130, 16, -1, 18, 19, 20,
3948  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3949  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3950  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3951  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3952  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
3953  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3954  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
3955  91, 92, -1, 94, 95, -1, 97, 98, 99, 100,
3956  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
3957  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3958  -1, 7, -1, -1, -1, 11, 12, 128, 129, 130,
3959  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3960  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3961  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3962  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3963  56, 57, 58, 59, 60, 61, 62, -1, 64, 65,
3964  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
3965  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3966  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
3967  -1, 97, 98, -1, 100, 101, 102, 103, 104, 105,
3968  106, 107, 108, -1, -1, -1, -1, -1, -1, -1,
3969  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3970  11, 12, 128, 129, 130, 16, -1, 18, 19, 20,
3971  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3972  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3973  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3974  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3975  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
3976  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3977  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
3978  91, 92, -1, 94, 95, -1, -1, 98, 99, 100,
3979  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
3980  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
3981  -1, 7, -1, -1, -1, 11, 12, 128, 129, 130,
3982  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3983  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
3984  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
3985  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
3986  56, 57, 58, 59, 60, 61, 62, -1, 64, 65,
3987  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
3988  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3989  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
3990  -1, 97, 98, -1, 100, 101, 102, 103, 104, 105,
3991  106, 107, 108, -1, -1, -1, -1, -1, -1, -1,
3992  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
3993  11, 12, 128, 129, 130, 16, -1, 18, 19, 20,
3994  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3995  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3996  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
3997  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
3998  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
3999  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4000  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
4001  91, 92, -1, 94, 95, -1, -1, 98, -1, 100,
4002  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
4003  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4004  -1, 7, -1, -1, -1, 11, 12, 128, 129, 130,
4005  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4006  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4007  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4008  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4009  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
4010  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
4011  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4012  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
4013  -1, 97, -1, -1, 100, 101, 102, 103, 104, 105,
4014  106, 107, 108, -1, -1, -1, -1, -1, -1, -1,
4015  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4016  11, 12, 128, 129, 130, 16, -1, 18, 19, 20,
4017  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4018  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4019  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4020  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4021  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
4022  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4023  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
4024  91, 92, -1, 94, 95, -1, 97, -1, -1, 100,
4025  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
4026  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4027  -1, 7, -1, -1, -1, 11, 12, 128, 129, 130,
4028  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4029  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4030  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4031  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4032  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
4033  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
4034  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4035  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
4036  -1, 97, -1, -1, 100, 101, 102, 103, 104, 105,
4037  106, 107, 108, -1, -1, -1, -1, -1, -1, -1,
4038  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4039  11, 12, 128, 129, 130, 16, -1, 18, 19, 20,
4040  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4041  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4042  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4043  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4044  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
4045  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4046  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
4047  91, 92, -1, 94, 95, -1, 97, -1, -1, 100,
4048  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
4049  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4050  -1, 7, -1, -1, -1, 11, 12, 128, 129, 130,
4051  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4052  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4053  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4054  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4055  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
4056  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
4057  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4058  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
4059  -1, 97, -1, -1, 100, 101, 102, 103, 104, 105,
4060  106, 107, 108, -1, -1, -1, -1, -1, -1, -1,
4061  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4062  11, 12, 128, 129, 130, 16, -1, 18, 19, 20,
4063  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4064  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4065  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4066  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4067  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
4068  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4069  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
4070  91, 92, -1, 94, 95, -1, -1, -1, -1, 100,
4071  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
4072  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4073  -1, 7, -1, -1, -1, 11, 12, 128, 129, 130,
4074  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4075  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4076  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4077  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4078  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
4079  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
4080  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4081  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
4082  -1, -1, -1, -1, 100, 101, 102, 103, 104, 105,
4083  106, 107, 108, -1, -1, -1, -1, -1, -1, -1,
4084  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4085  11, 12, 128, 129, 130, 16, -1, 18, 19, 20,
4086  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4087  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4088  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4089  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4090  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
4091  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4092  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
4093  91, 92, -1, 94, 95, -1, -1, -1, -1, 100,
4094  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
4095  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4096  -1, 7, -1, -1, -1, 11, 12, 128, 129, 130,
4097  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4098  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4099  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4100  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4101  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
4102  66, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4103  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4104  -1, -1, 88, -1, -1, 91, 92, -1, 94, 95,
4105  -1, 97, -1, -1, 100, 101, 102, 103, 104, 105,
4106  106, 107, 108, -1, -1, -1, -1, -1, 3, 4,
4107  5, -1, 7, -1, -1, -1, 11, 12, -1, -1,
4108  -1, 16, 128, 18, 19, 20, 21, 22, 23, 24,
4109  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4110  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4111  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
4112  55, 56, 57, -1, 59, 60, 61, 62, -1, 64,
4113  65, 66, -1, -1, -1, -1, -1, -1, -1, -1,
4114  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4115  -1, -1, -1, 88, -1, -1, 91, 92, -1, 94,
4116  95, -1, 97, -1, -1, 100, 101, 102, 103, 104,
4117  105, 106, 107, 108, -1, -1, -1, -1, -1, 3,
4118  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
4119  -1, -1, 16, 128, 18, 19, 20, 21, 22, 23,
4120  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4121  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4122  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4123  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4124  64, 65, 66, -1, -1, -1, -1, -1, -1, -1,
4125  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4126  -1, 85, -1, -1, 88, -1, -1, 91, 92, -1,
4127  94, 95, -1, -1, -1, -1, 100, 101, 102, 103,
4128  104, 105, 106, 107, 108, -1, -1, -1, -1, -1,
4129  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4130  -1, -1, -1, 16, 128, 18, 19, 20, 21, 22,
4131  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4132  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4133  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4134  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
4135  -1, 64, 65, 66, -1, -1, -1, -1, -1, -1,
4136  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4137  -1, -1, -1, -1, -1, 88, -1, -1, 91, 92,
4138  -1, 94, 95, -1, -1, -1, -1, 100, 101, 102,
4139  103, 104, 105, 106, 107, 108, -1, -1, -1, -1,
4140  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4141  12, -1, -1, -1, 16, 128, 18, 19, 20, 21,
4142  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4143  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4144  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4145  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4146  62, -1, 64, 65, 66, -1, -1, -1, -1, -1,
4147  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4148  -1, -1, -1, -1, -1, -1, 88, -1, -1, 91,
4149  92, -1, 94, 95, -1, -1, -1, -1, 100, 101,
4150  102, 103, 104, 105, 106, 107, 108, -1, -1, -1,
4151  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4152  11, 12, -1, -1, -1, 16, 128, 18, 19, 20,
4153  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4154  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4155  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4156  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4157  61, 62, -1, 64, 65, 66, -1, -1, -1, -1,
4158  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4159  -1, -1, -1, -1, -1, -1, -1, 88, -1, -1,
4160  91, 92, -1, 94, 95, -1, -1, -1, -1, 100,
4161  101, 102, 103, 104, 105, 106, 107, 108, -1, -1,
4162  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4163  -1, 11, 12, -1, -1, -1, 16, 128, 18, 19,
4164  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4165  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4166  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4167  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4168  60, 61, 62, -1, 64, 65, 66, -1, -1, -1,
4169  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4170  -1, -1, -1, -1, -1, -1, -1, -1, 88, -1,
4171  -1, 91, 92, -1, 94, 95, -1, -1, -1, -1,
4172  100, 101, 102, 103, 104, 105, 106, 107, 108, -1,
4173  -1, -1, -1, 52, 53, -1, -1, 56, -1, -1,
4174  -1, -1, -1, -1, -1, -1, -1, -1, 128, 68,
4175  69, 70, 71, 72, 73, 74, 75, 76, -1, -1,
4176  79, 80, -1, -1, 83, 84, 85, 86, -1, -1,
4177  -1, -1, -1, -1, -1, -1, -1, -1, 97, 98,
4178  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4179  -1, -1, -1, -1, -1, -1, -1, -1, -1, 118,
4180  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
4181  129, 130, 52, 53, -1, -1, 56, -1, 137, -1,
4182  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
4183  70, 71, 72, 73, 74, 75, 76, -1, -1, 79,
4184  80, -1, -1, 83, 84, 85, 86, -1, -1, -1,
4185  -1, -1, -1, -1, -1, -1, -1, 97, 98, -1,
4186  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4187  -1, -1, -1, -1, -1, -1, -1, -1, 118, 119,
4188  120, 121, 122, 123, 124, 125, 126, 127, -1, 129,
4189  130, 52, 53, -1, -1, 56, -1, 137, -1, -1,
4190  -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
4191  71, 72, 73, 74, 75, 76, -1, -1, 79, 80,
4192  -1, -1, 83, 84, 85, 86, -1, -1, -1, -1,
4193  -1, -1, -1, -1, -1, -1, 97, 98, -1, -1,
4194  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4195  -1, -1, -1, -1, -1, -1, -1, 118, 119, 120,
4196  121, 122, 123, 124, 125, 126, 127, -1, 129, 130,
4197  52, 53, -1, -1, 56, -1, 137, -1, -1, -1,
4198  -1, -1, -1, -1, -1, -1, 68, 69, 70, 71,
4199  72, 73, 74, 75, 76, -1, -1, 79, 80, -1,
4200  -1, 83, 84, 85, 86, -1, -1, -1, -1, -1,
4201  -1, -1, -1, -1, -1, 97, 98, -1, -1, -1,
4202  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4203  -1, -1, -1, -1, -1, -1, 118, 119, 120, 121,
4204  122, 123, 124, 125, 126, 127, -1, 129, 130, 52,
4205  53, -1, -1, 56, -1, 137, -1, -1, -1, -1,
4206  -1, -1, -1, -1, -1, 68, 69, 70, 71, 72,
4207  73, 74, 75, 76, -1, -1, 79, 80, -1, -1,
4208  83, 84, 85, 86, -1, -1, -1, -1, -1, -1,
4209  -1, -1, -1, -1, 97, 98, -1, -1, -1, -1,
4210  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4211  -1, -1, -1, -1, -1, 118, 119, 120, 121, 122,
4212  123, 124, 125, 126, 127, -1, 129, 130, 52, 53,
4213  -1, -1, 56, -1, 137, -1, -1, -1, -1, -1,
4214  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
4215  74, 75, 76, -1, -1, 79, 80, -1, -1, 83,
4216  84, 85, 86, -1, -1, -1, -1, -1, -1, -1,
4217  -1, -1, -1, 97, 98, -1, -1, -1, -1, -1,
4218  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4219  -1, -1, -1, -1, 118, 119, 120, 121, 122, 123,
4220  124, 125, 126, 127, -1, 129, 130, 52, 53, -1,
4221  -1, 56, -1, 137, -1, -1, -1, -1, -1, -1,
4222  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
4223  75, 76, -1, -1, 79, 80, -1, -1, 83, 84,
4224  85, 86, -1, -1, -1, -1, -1, -1, -1, -1,
4225  -1, -1, 97, 98, -1, -1, -1, -1, -1, -1,
4226  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4227  -1, -1, -1, 118, 119, 120, 121, 122, 123, 124,
4228  125, 126, 127, -1, 129, 130, 52, 53, -1, -1,
4229  56, -1, 137, -1, -1, -1, -1, -1, -1, -1,
4230  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
4231  76, -1, -1, 79, 80, -1, -1, 83, 84, 85,
4232  86, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4233  -1, 97, 98, -1, -1, -1, -1, -1, -1, -1,
4234  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4235  -1, -1, 118, 119, 120, 121, 122, 123, 124, 125,
4236  126, 127, -1, 129, 130, 52, 53, -1, -1, 56,
4237  -1, 137, -1, -1, -1, -1, -1, -1, -1, -1,
4238  -1, 68, 69, 70, 71, 72, 73, 74, 75, 76,
4239  -1, -1, 79, 80, -1, -1, 83, 84, 85, 86,
4240  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4241  97, 98, -1, -1, -1, -1, -1, -1, -1, -1,
4242  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4243  -1, 118, 119, 120, 121, 122, 123, 124, 125, 126,
4244  127, -1, 129, 130, 52, 53, -1, -1, 56, -1,
4245  137, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4246  68, 69, 70, 71, 72, 73, 74, 75, 76, -1,
4247  -1, 79, 80, -1, -1, 83, 84, 85, 86, -1,
4248  -1, -1, -1, -1, -1, -1, -1, -1, -1, 97,
4249  98, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4250  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4251  118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
4252  -1, 129, 130, 52, 53, -1, -1, 56, -1, 137,
4253  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
4254  69, 70, 71, 72, 73, 74, 75, 76, -1, -1,
4255  79, 80, -1, -1, 83, 84, 85, 86, -1, -1,
4256  -1, -1, -1, -1, -1, -1, -1, -1, 97, 98,
4257  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4258  -1, -1, -1, -1, -1, -1, -1, -1, -1, 118,
4259  119, 120, 121, 122, 123, 124, 125, 126, 127, -1,
4260  129, 130, 52, 53, -1, -1, 56, -1, 137, -1,
4261  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
4262  70, 71, 72, 73, 74, 75, 76, -1, -1, 79,
4263  80, -1, -1, 83, 84, 85, 86, -1, -1, -1,
4264  -1, -1, -1, -1, -1, -1, -1, 97, 98, -1,
4265  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4266  -1, -1, -1, -1, -1, -1, -1, -1, 118, 119,
4267  120, 121, 122, 123, 124, 125, 126, 127, -1, 129,
4268  130, 52, 53, -1, -1, 56, -1, 137, -1, -1,
4269  -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
4270  71, 72, 73, 74, 75, 76, -1, -1, 79, 80,
4271  -1, -1, 83, 84, 85, 86, -1, -1, -1, -1,
4272  -1, -1, -1, -1, -1, -1, 97, 98, 70, 71,
4273  72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
4274  82, -1, -1, 85, 86, -1, -1, 118, 119, 120,
4275  121, 122, 123, 124, 125, 126, 127, -1, 129, 130,
4276  -1, -1, -1, -1, -1, -1, 137, -1, -1, -1,
4277  -1, -1, -1, -1, 116, -1, 118, 119, 120, 121,
4278  122, 123, 124, 125, 126, 127, -1, -1, -1, -1,
4279  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4280  -1, 143
4281 };
4282 
4283 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4284  symbol of state STATE-NUM. */
4285 static const yytype_uint16 yystos[] =
4286 {
4287  0, 145, 146, 0, 1, 3, 4, 5, 6, 7,
4288  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4289  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4290  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4291  57, 59, 60, 61, 62, 64, 65, 66, 68, 69,
4292  88, 91, 92, 94, 95, 97, 100, 101, 102, 103,
4293  104, 105, 106, 107, 108, 128, 129, 130, 147, 148,
4294  149, 156, 158, 159, 161, 162, 165, 166, 167, 169,
4295  170, 171, 173, 174, 184, 199, 218, 219, 220, 221,
4296  222, 223, 224, 225, 226, 227, 228, 254, 255, 269,
4297  270, 271, 272, 273, 274, 275, 278, 280, 281, 293,
4298  295, 296, 297, 298, 299, 300, 301, 302, 335, 346,
4299  149, 3, 4, 5, 6, 7, 8, 9, 10, 11,
4300  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
4301  22, 23, 24, 25, 26, 30, 31, 32, 33, 34,
4302  35, 36, 37, 38, 39, 45, 46, 47, 48, 49,
4303  50, 51, 52, 53, 56, 68, 69, 70, 71, 72,
4304  73, 74, 75, 76, 79, 80, 83, 84, 85, 86,
4305  97, 98, 118, 119, 120, 121, 122, 123, 124, 125,
4306  126, 127, 129, 130, 137, 177, 178, 179, 180, 182,
4307  183, 293, 295, 39, 58, 88, 91, 97, 98, 99,
4308  129, 166, 174, 184, 186, 191, 194, 196, 218, 298,
4309  299, 301, 302, 333, 334, 191, 191, 138, 192, 193,
4310  138, 188, 192, 138, 143, 340, 54, 179, 340, 150,
4311  132, 21, 22, 30, 31, 32, 165, 184, 218, 184,
4312  56, 1, 47, 91, 152, 153, 154, 156, 168, 169,
4313  346, 201, 202, 187, 196, 333, 346, 186, 332, 333,
4314  346, 46, 88, 128, 136, 173, 199, 218, 298, 299,
4315  302, 246, 247, 54, 55, 57, 177, 285, 294, 284,
4316  285, 286, 142, 276, 142, 282, 142, 279, 142, 283,
4317  297, 161, 184, 184, 141, 143, 339, 344, 345, 40,
4318  41, 42, 43, 44, 37, 38, 26, 132, 188, 192,
4319  260, 28, 252, 115, 136, 91, 97, 170, 115, 70,
4320  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
4321  81, 82, 85, 86, 116, 118, 119, 120, 121, 122,
4322  123, 124, 125, 126, 127, 87, 134, 135, 200, 159,
4323  160, 160, 205, 207, 160, 339, 345, 88, 167, 174,
4324  218, 234, 298, 299, 302, 52, 56, 85, 88, 175,
4325  176, 218, 298, 299, 302, 176, 33, 34, 35, 36,
4326  49, 50, 51, 52, 56, 138, 177, 300, 330, 87,
4327  135, 338, 260, 272, 89, 89, 136, 186, 56, 186,
4328  186, 186, 115, 90, 136, 195, 346, 87, 134, 135,
4329  89, 89, 136, 195, 191, 340, 341, 191, 190, 191,
4330  196, 333, 346, 159, 341, 159, 54, 65, 66, 157,
4331  138, 185, 132, 152, 87, 135, 89, 156, 155, 168,
4332  139, 339, 345, 341, 341, 159, 140, 136, 143, 343,
4333  136, 343, 133, 343, 340, 56, 297, 170, 172, 136,
4334  87, 134, 135, 248, 63, 109, 111, 112, 287, 112,
4335  287, 112, 67, 287, 112, 112, 277, 287, 112, 63,
4336  112, 112, 112, 277, 112, 63, 112, 70, 141, 149,
4337  160, 160, 160, 160, 156, 159, 159, 262, 261, 96,
4338  163, 253, 97, 161, 186, 196, 197, 198, 168, 136,
4339  173, 136, 158, 161, 174, 184, 186, 198, 184, 184,
4340  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
4341  184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
4342  184, 184, 184, 184, 52, 53, 56, 182, 259, 336,
4343  337, 190, 52, 53, 56, 182, 258, 336, 151, 152,
4344  13, 230, 344, 230, 160, 160, 339, 17, 263, 56,
4345  87, 134, 135, 25, 159, 52, 56, 175, 1, 119,
4346  303, 344, 87, 134, 135, 214, 331, 215, 338, 52,
4347  56, 336, 161, 184, 161, 184, 181, 184, 186, 97,
4348  186, 194, 333, 52, 56, 190, 52, 56, 334, 341,
4349  139, 341, 136, 136, 341, 179, 204, 184, 147, 133,
4350  336, 336, 184, 132, 341, 154, 203, 333, 136, 172,
4351  52, 56, 190, 52, 56, 52, 54, 55, 56, 57,
4352  58, 70, 91, 97, 98, 99, 122, 125, 138, 250,
4353  307, 309, 310, 311, 312, 313, 314, 315, 318, 319,
4354  320, 321, 324, 325, 326, 327, 328, 289, 288, 142,
4355  287, 142, 142, 142, 184, 78, 120, 241, 242, 346,
4356  241, 164, 241, 186, 136, 341, 172, 136, 115, 44,
4357  340, 89, 89, 188, 192, 257, 340, 342, 89, 89,
4358  188, 192, 256, 10, 229, 8, 265, 346, 152, 13,
4359  152, 27, 231, 344, 231, 263, 196, 229, 52, 56,
4360  190, 52, 56, 209, 212, 344, 304, 211, 52, 56,
4361  175, 190, 151, 159, 138, 305, 306, 216, 188, 189,
4362  192, 346, 44, 179, 186, 195, 89, 89, 342, 89,
4363  89, 333, 159, 133, 147, 341, 343, 170, 342, 91,
4364  97, 235, 236, 237, 311, 309, 249, 115, 136, 308,
4365  186, 136, 329, 346, 52, 136, 329, 136, 308, 52,
4366  136, 308, 52, 290, 54, 55, 57, 292, 302, 238,
4367  240, 243, 311, 313, 314, 316, 317, 320, 322, 323,
4368  326, 328, 340, 152, 152, 241, 152, 97, 186, 172,
4369  184, 117, 161, 184, 161, 184, 163, 188, 140, 89,
4370  161, 184, 161, 184, 163, 189, 186, 198, 266, 346,
4371  15, 233, 346, 14, 232, 233, 233, 206, 208, 229,
4372  136, 230, 342, 160, 344, 160, 151, 342, 229, 341,
4373  309, 151, 309, 177, 260, 252, 184, 89, 136, 341,
4374  133, 237, 136, 311, 136, 341, 243, 29, 113, 251,
4375  186, 307, 312, 324, 326, 315, 320, 328, 313, 321,
4376  326, 311, 313, 291, 243, 120, 115, 136, 239, 88,
4377  218, 136, 329, 329, 136, 239, 136, 239, 141, 10,
4378  133, 152, 10, 186, 184, 161, 184, 90, 267, 346,
4379  152, 9, 268, 346, 160, 229, 229, 152, 152, 186,
4380  152, 231, 213, 344, 229, 341, 229, 344, 217, 341,
4381  236, 136, 97, 235, 139, 152, 152, 136, 308, 136,
4382  308, 329, 136, 308, 136, 308, 308, 152, 120, 218,
4383  238, 323, 326, 56, 87, 316, 320, 313, 322, 326,
4384  313, 52, 244, 245, 310, 133, 88, 174, 218, 298,
4385  299, 302, 230, 152, 230, 229, 229, 233, 263, 264,
4386  210, 151, 305, 136, 236, 136, 311, 10, 133, 313,
4387  326, 313, 313, 110, 136, 239, 136, 239, 52, 56,
4388  329, 136, 239, 136, 239, 239, 136, 340, 56, 87,
4389  134, 135, 152, 152, 152, 229, 151, 236, 136, 308,
4390  136, 308, 308, 308, 313, 326, 313, 313, 245, 52,
4391  56, 190, 52, 56, 265, 232, 229, 229, 236, 313,
4392  239, 136, 239, 239, 239, 342, 308, 313, 239
4393 };
4394 
4395 #define yyerrok (yyerrstatus = 0)
4396 #define yyclearin (yychar = YYEMPTY)
4397 #define YYEMPTY (-2)
4398 #define YYEOF 0
4399 
4400 #define YYACCEPT goto yyacceptlab
4401 #define YYABORT goto yyabortlab
4402 #define YYERROR goto yyerrorlab
4403 
4404 
4405 /* Like YYERROR except do call yyerror. This remains here temporarily
4406  to ease the transition to the new meaning of YYERROR, for GCC.
4407  Once GCC version 2 has supplanted version 1, this can go. However,
4408  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
4409  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
4410  discussed. */
4411 
4412 #define YYFAIL goto yyerrlab
4413 #if defined YYFAIL
4414  /* This is here to suppress warnings from the GCC cpp's
4415  -Wunused-macros. Normally we don't worry about that warning, but
4416  some users do, and we want to make it easy for users to remove
4417  YYFAIL uses, which will produce warnings from Bison 2.5. */
4418 #endif
4419 
4420 #define YYRECOVERING() (!!yyerrstatus)
4421 
4422 #define YYBACKUP(Token, Value) \
4423 do \
4424  if (yychar == YYEMPTY && yylen == 1) \
4425  { \
4426  yychar = (Token); \
4427  yylval = (Value); \
4428  YYPOPSTACK (1); \
4429  goto yybackup; \
4430  } \
4431  else \
4432  { \
4433  parser_yyerror (parser, YY_("syntax error: cannot back up")); \
4434  YYERROR; \
4435  } \
4436 while (YYID (0))
4437 
4438 
4439 #define YYTERROR 1
4440 #define YYERRCODE 256
4441 
4442 
4443 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
4444  If N is 0, then set CURRENT to the empty location which ends
4445  the previous symbol: RHS[0] (always defined). */
4446 
4447 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
4448 #ifndef YYLLOC_DEFAULT
4449 # define YYLLOC_DEFAULT(Current, Rhs, N) \
4450  do \
4451  if (YYID (N)) \
4452  { \
4453  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
4454  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
4455  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
4456  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
4457  } \
4458  else \
4459  { \
4460  (Current).first_line = (Current).last_line = \
4461  YYRHSLOC (Rhs, 0).last_line; \
4462  (Current).first_column = (Current).last_column = \
4463  YYRHSLOC (Rhs, 0).last_column; \
4464  } \
4465  while (YYID (0))
4466 #endif
4467 
4468 
4469 /* This macro is provided for backward compatibility. */
4470 
4471 #ifndef YY_LOCATION_PRINT
4472 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
4473 #endif
4474 
4475 
4476 /* YYLEX -- calling `yylex' with the right arguments. */
4477 
4478 #ifdef YYLEX_PARAM
4479 # define YYLEX yylex (&yylval, YYLEX_PARAM)
4480 #else
4481 # define YYLEX yylex (&yylval, parser)
4482 #endif
4483 
4484 /* Enable debugging if requested. */
4485 #if YYDEBUG
4486 
4487 # ifndef YYFPRINTF
4488 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
4489 # define YYFPRINTF fprintf
4490 # endif
4491 
4492 # define YYDPRINTF(Args) \
4493 do { \
4494  if (yydebug) \
4495  YYFPRINTF Args; \
4496 } while (YYID (0))
4497 
4498 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
4499 do { \
4500  if (yydebug) \
4501  { \
4502  YYFPRINTF (stderr, "%s ", Title); \
4503  yy_symbol_print (stderr, \
4504  Type, Value, parser); \
4505  YYFPRINTF (stderr, "\n"); \
4506  } \
4507 } while (YYID (0))
4508 
4509 
4510 /*--------------------------------.
4511 | Print this symbol on YYOUTPUT. |
4512 `--------------------------------*/
4513 
4514 /*ARGSUSED*/
4515 #if (defined __STDC__ || defined __C99__FUNC__ \
4516  || defined __cplusplus || defined _MSC_VER)
4517 static void
4518 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4519 #else
4520 static void
4521 yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser)
4522  FILE *yyoutput;
4523  int yytype;
4524  YYSTYPE const * const yyvaluep;
4525  struct parser_params *parser;
4526 #endif
4527 {
4528  if (!yyvaluep)
4529  return;
4530  YYUSE (parser);
4531 # ifdef YYPRINT
4532  if (yytype < YYNTOKENS)
4533  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4534 # else
4535  YYUSE (yyoutput);
4536 # endif
4537  switch (yytype)
4538  {
4539  default:
4540  break;
4541  }
4542 }
4543 
4544 
4545 /*--------------------------------.
4546 | Print this symbol on YYOUTPUT. |
4547 `--------------------------------*/
4548 
4549 #if (defined __STDC__ || defined __C99__FUNC__ \
4550  || defined __cplusplus || defined _MSC_VER)
4551 static void
4552 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct parser_params *parser)
4553 #else
4554 static void
4555 yy_symbol_print (yyoutput, yytype, yyvaluep, parser)
4556  FILE *yyoutput;
4557  int yytype;
4558  YYSTYPE const * const yyvaluep;
4559  struct parser_params *parser;
4560 #endif
4561 {
4562  if (yytype < YYNTOKENS)
4563  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
4564  else
4565  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
4566 
4567  yy_symbol_value_print (yyoutput, yytype, yyvaluep, parser);
4568  YYFPRINTF (yyoutput, ")");
4569 }
4570 
4571 /*------------------------------------------------------------------.
4572 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
4573 | TOP (included). |
4574 `------------------------------------------------------------------*/
4575 
4576 #if (defined __STDC__ || defined __C99__FUNC__ \
4577  || defined __cplusplus || defined _MSC_VER)
4578 static void
4579 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
4580 #else
4581 static void
4582 yy_stack_print (yybottom, yytop)
4583  yytype_int16 *yybottom;
4584  yytype_int16 *yytop;
4585 #endif
4586 {
4587  YYFPRINTF (stderr, "Stack now");
4588  for (; yybottom <= yytop; yybottom++)
4589  {
4590  int yybot = *yybottom;
4591  YYFPRINTF (stderr, " %d", yybot);
4592  }
4593  YYFPRINTF (stderr, "\n");
4594 }
4595 
4596 # define YY_STACK_PRINT(Bottom, Top) \
4597 do { \
4598  if (yydebug) \
4599  yy_stack_print ((Bottom), (Top)); \
4600 } while (YYID (0))
4601 
4602 
4603 /*------------------------------------------------.
4604 | Report that the YYRULE is going to be reduced. |
4605 `------------------------------------------------*/
4606 
4607 #if (defined __STDC__ || defined __C99__FUNC__ \
4608  || defined __cplusplus || defined _MSC_VER)
4609 static void
4610 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
4611 #else
4612 static void
4613 yy_reduce_print (yyvsp, yyrule, parser)
4614  YYSTYPE *yyvsp;
4615  int yyrule;
4616  struct parser_params *parser;
4617 #endif
4618 {
4619  int yynrhs = yyr2[yyrule];
4620  int yyi;
4621  unsigned long int yylno = yyrline[yyrule];
4622  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
4623  yyrule - 1, yylno);
4624  /* The symbols being reduced. */
4625  for (yyi = 0; yyi < yynrhs; yyi++)
4626  {
4627  YYFPRINTF (stderr, " $%d = ", yyi + 1);
4628  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
4629  &(yyvsp[(yyi + 1) - (yynrhs)])
4630  , parser);
4631  YYFPRINTF (stderr, "\n");
4632  }
4633 }
4634 
4635 # define YY_REDUCE_PRINT(Rule) \
4636 do { \
4637  if (yydebug) \
4638  yy_reduce_print (yyvsp, Rule, parser); \
4639 } while (YYID (0))
4640 
4641 /* Nonzero means print parse trace. It is left uninitialized so that
4642  multiple parsers can coexist. */
4643 #ifndef yydebug
4644 int yydebug;
4645 #endif
4646 #else /* !YYDEBUG */
4647 # define YYDPRINTF(Args)
4648 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
4649 # define YY_STACK_PRINT(Bottom, Top)
4650 # define YY_REDUCE_PRINT(Rule)
4651 #endif /* !YYDEBUG */
4652 
4653 
4654 /* YYINITDEPTH -- initial size of the parser's stacks. */
4655 #ifndef YYINITDEPTH
4656 # define YYINITDEPTH 200
4657 #endif
4658 
4659 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
4660  if the built-in stack extension method is used).
4661 
4662  Do not make this value too large; the results are undefined if
4663  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
4664  evaluated with infinite-precision integer arithmetic. */
4665 
4666 #ifndef YYMAXDEPTH
4667 # define YYMAXDEPTH 10000
4668 #endif
4669 
4670 
4671 #if YYERROR_VERBOSE
4672 
4673 # ifndef yystrlen
4674 # if defined __GLIBC__ && defined _STRING_H
4675 # define yystrlen strlen
4676 # else
4677 /* Return the length of YYSTR. */
4678 #if (defined __STDC__ || defined __C99__FUNC__ \
4679  || defined __cplusplus || defined _MSC_VER)
4680 static YYSIZE_T
4681 yystrlen (const char *yystr)
4682 #else
4683 static YYSIZE_T
4684 yystrlen (yystr)
4685  const char *yystr;
4686 #endif
4687 {
4688  YYSIZE_T yylen;
4689  for (yylen = 0; yystr[yylen]; yylen++)
4690  continue;
4691  return yylen;
4692 }
4693 # endif
4694 # endif
4695 
4696 # ifndef yystpcpy
4697 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
4698 # define yystpcpy stpcpy
4699 # else
4700 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
4701  YYDEST. */
4702 #if (defined __STDC__ || defined __C99__FUNC__ \
4703  || defined __cplusplus || defined _MSC_VER)
4704 static char *
4705 yystpcpy (char *yydest, const char *yysrc)
4706 #else
4707 static char *
4708 yystpcpy (yydest, yysrc)
4709  char *yydest;
4710  const char *yysrc;
4711 #endif
4712 {
4713  char *yyd = yydest;
4714  const char *yys = yysrc;
4715 
4716  while ((*yyd++ = *yys++) != '\0')
4717  continue;
4718 
4719  return yyd - 1;
4720 }
4721 # endif
4722 # endif
4723 
4724 # ifndef yytnamerr
4725 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
4726  quotes and backslashes, so that it's suitable for yyerror. The
4727  heuristic is that double-quoting is unnecessary unless the string
4728  contains an apostrophe, a comma, or backslash (other than
4729  backslash-backslash). YYSTR is taken from yytname. If YYRES is
4730  null, do not copy; instead, return the length of what the result
4731  would have been. */
4732 static YYSIZE_T
4733 yytnamerr (char *yyres, const char *yystr)
4734 {
4735  if (*yystr == '"')
4736  {
4737  YYSIZE_T yyn = 0;
4738  char const *yyp = yystr;
4739 
4740  for (;;)
4741  switch (*++yyp)
4742  {
4743  case '\'':
4744  case ',':
4745  goto do_not_strip_quotes;
4746 
4747  case '\\':
4748  if (*++yyp != '\\')
4749  goto do_not_strip_quotes;
4750  /* Fall through. */
4751  default:
4752  if (yyres)
4753  yyres[yyn] = *yyp;
4754  yyn++;
4755  break;
4756 
4757  case '"':
4758  if (yyres)
4759  yyres[yyn] = '\0';
4760  return yyn;
4761  }
4762  do_not_strip_quotes: ;
4763  }
4764 
4765  if (! yyres)
4766  return yystrlen (yystr);
4767 
4768  return yystpcpy (yyres, yystr) - yyres;
4769 }
4770 # endif
4771 
4772 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
4773  about the unexpected token YYTOKEN for the state stack whose top is
4774  YYSSP.
4775 
4776  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
4777  not large enough to hold the message. In that case, also set
4778  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
4779  required number of bytes is too large to store. */
4780 static int
4781 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
4782  yytype_int16 *yyssp, int yytoken)
4783 {
4784  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
4785  YYSIZE_T yysize = yysize0;
4786  YYSIZE_T yysize1;
4787  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
4788  /* Internationalized format string. */
4789  const char *yyformat = 0;
4790  /* Arguments of yyformat. */
4791  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
4792  /* Number of reported tokens (one for the "unexpected", one per
4793  "expected"). */
4794  int yycount = 0;
4795 
4796  /* There are many possibilities here to consider:
4797  - Assume YYFAIL is not used. It's too flawed to consider. See
4798  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
4799  for details. YYERROR is fine as it does not invoke this
4800  function.
4801  - If this state is a consistent state with a default action, then
4802  the only way this function was invoked is if the default action
4803  is an error action. In that case, don't check for expected
4804  tokens because there are none.
4805  - The only way there can be no lookahead present (in yychar) is if
4806  this state is a consistent state with a default action. Thus,
4807  detecting the absence of a lookahead is sufficient to determine
4808  that there is no unexpected or expected token to report. In that
4809  case, just report a simple "syntax error".
4810  - Don't assume there isn't a lookahead just because this state is a
4811  consistent state with a default action. There might have been a
4812  previous inconsistent state, consistent state with a non-default
4813  action, or user semantic action that manipulated yychar.
4814  - Of course, the expected token list depends on states to have
4815  correct lookahead information, and it depends on the parser not
4816  to perform extra reductions after fetching a lookahead from the
4817  scanner and before detecting a syntax error. Thus, state merging
4818  (from LALR or IELR) and default reductions corrupt the expected
4819  token list. However, the list is correct for canonical LR with
4820  one exception: it will still contain any token that will not be
4821  accepted due to an error action in a later state.
4822  */
4823  if (yytoken != YYEMPTY)
4824  {
4825  int yyn = yypact[*yyssp];
4826  yyarg[yycount++] = yytname[yytoken];
4827  if (!yypact_value_is_default (yyn))
4828  {
4829  /* Start YYX at -YYN if negative to avoid negative indexes in
4830  YYCHECK. In other words, skip the first -YYN actions for
4831  this state because they are default actions. */
4832  int yyxbegin = yyn < 0 ? -yyn : 0;
4833  /* Stay within bounds of both yycheck and yytname. */
4834  int yychecklim = YYLAST - yyn + 1;
4835  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
4836  int yyx;
4837 
4838  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
4839  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
4840  && !yytable_value_is_error (yytable[yyx + yyn]))
4841  {
4842  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
4843  {
4844  yycount = 1;
4845  yysize = yysize0;
4846  break;
4847  }
4848  yyarg[yycount++] = yytname[yyx];
4849  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
4850  if (! (yysize <= yysize1
4851  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4852  return 2;
4853  yysize = yysize1;
4854  }
4855  }
4856  }
4857 
4858  switch (yycount)
4859  {
4860 # define YYCASE_(N, S) \
4861  case N: \
4862  yyformat = S; \
4863  break
4864  YYCASE_(0, YY_("syntax error"));
4865  YYCASE_(1, YY_("syntax error, unexpected %s"));
4866  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
4867  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
4868  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
4869  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
4870 # undef YYCASE_
4871  }
4872 
4873  yysize1 = yysize + yystrlen (yyformat);
4874  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
4875  return 2;
4876  yysize = yysize1;
4877 
4878  if (*yymsg_alloc < yysize)
4879  {
4880  *yymsg_alloc = 2 * yysize;
4881  if (! (yysize <= *yymsg_alloc
4882  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
4883  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
4884  return 1;
4885  }
4886 
4887  /* Avoid sprintf, as that infringes on the user's name space.
4888  Don't have undefined behavior even if the translation
4889  produced a string with the wrong number of "%s"s. */
4890  {
4891  char *yyp = *yymsg;
4892  int yyi = 0;
4893  while ((*yyp = *yyformat) != '\0')
4894  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
4895  {
4896  yyp += yytnamerr (yyp, yyarg[yyi++]);
4897  yyformat += 2;
4898  }
4899  else
4900  {
4901  yyp++;
4902  yyformat++;
4903  }
4904  }
4905  return 0;
4906 }
4907 #endif /* YYERROR_VERBOSE */
4908 
4909 /*-----------------------------------------------.
4910 | Release the memory associated to this symbol. |
4911 `-----------------------------------------------*/
4912 
4913 /*ARGSUSED*/
4914 #if (defined __STDC__ || defined __C99__FUNC__ \
4915  || defined __cplusplus || defined _MSC_VER)
4916 static void
4917 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser)
4918 #else
4919 static void
4920 yydestruct (yymsg, yytype, yyvaluep, parser)
4921  const char *yymsg;
4922  int yytype;
4923  YYSTYPE *yyvaluep;
4924  struct parser_params *parser;
4925 #endif
4926 {
4927  YYUSE (yyvaluep);
4928  YYUSE (parser);
4929 
4930  if (!yymsg)
4931  yymsg = "Deleting";
4932  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
4933 
4934  switch (yytype)
4935  {
4936 
4937  default:
4938  break;
4939  }
4940 }
4941 
4942 
4943 /* Prevent warnings from -Wmissing-prototypes. */
4944 #ifdef YYPARSE_PARAM
4945 #if defined __STDC__ || defined __cplusplus
4946 int yyparse (void *YYPARSE_PARAM);
4947 #else
4948 int yyparse ();
4949 #endif
4950 #else /* ! YYPARSE_PARAM */
4951 #if defined __STDC__ || defined __cplusplus
4952 int yyparse (struct parser_params *parser);
4953 #else
4954 int yyparse ();
4955 #endif
4956 #endif /* ! YYPARSE_PARAM */
4957 
4958 
4959 /*----------.
4960 | yyparse. |
4961 `----------*/
4962 
4963 #ifdef YYPARSE_PARAM
4964 #if (defined __STDC__ || defined __C99__FUNC__ \
4965  || defined __cplusplus || defined _MSC_VER)
4966 int
4967 yyparse (void *YYPARSE_PARAM)
4968 #else
4969 int
4970 yyparse (YYPARSE_PARAM)
4971  void *YYPARSE_PARAM;
4972 #endif
4973 #else /* ! YYPARSE_PARAM */
4974 #if (defined __STDC__ || defined __C99__FUNC__ \
4975  || defined __cplusplus || defined _MSC_VER)
4976 int
4977 yyparse (struct parser_params *parser)
4978 #else
4979 int
4980 yyparse (parser)
4981  struct parser_params *parser;
4982 #endif
4983 #endif
4984 {
4985 /* The lookahead symbol. */
4986 int yychar;
4987 
4988 /* The semantic value of the lookahead symbol. */
4989 YYSTYPE yylval;
4990 
4991  /* Number of syntax errors so far. */
4992  int yynerrs;
4993 
4994  int yystate;
4995  /* Number of tokens to shift before error messages enabled. */
4996  int yyerrstatus;
4997 
4998  /* The stacks and their tools:
4999  `yyss': related to states.
5000  `yyvs': related to semantic values.
5001 
5002  Refer to the stacks thru separate pointers, to allow yyoverflow
5003  to reallocate them elsewhere. */
5004 
5005  /* The state stack. */
5006  yytype_int16 yyssa[YYINITDEPTH];
5007  yytype_int16 *yyss;
5008  yytype_int16 *yyssp;
5009 
5010  /* The semantic value stack. */
5011  YYSTYPE yyvsa[YYINITDEPTH];
5012  YYSTYPE *yyvs;
5013  YYSTYPE *yyvsp;
5014 
5015  YYSIZE_T yystacksize;
5016 
5017  int yyn;
5018  int yyresult;
5019  /* Lookahead token as an internal (translated) token number. */
5020  int yytoken;
5021  /* The variables used to return semantic value and location from the
5022  action routines. */
5023  YYSTYPE yyval;
5024 
5025 #if YYERROR_VERBOSE
5026  /* Buffer for error messages, and its allocated size. */
5027  char yymsgbuf[128];
5028  char *yymsg = yymsgbuf;
5029  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
5030 #endif
5031 
5032 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
5033 
5034  /* The number of symbols on the RHS of the reduced rule.
5035  Keep to zero when no symbol should be popped. */
5036  int yylen = 0;
5037 
5038  yytoken = 0;
5039  yyss = yyssa;
5040  yyvs = yyvsa;
5041  yystacksize = YYINITDEPTH;
5042 
5043  YYDPRINTF ((stderr, "Starting parse\n"));
5044 
5045  yystate = 0;
5046  yyerrstatus = 0;
5047  yynerrs = 0;
5048  yychar = YYEMPTY; /* Cause a token to be read. */
5049 
5050  /* Initialize stack pointers.
5051  Waste one element of value and location stack
5052  so that they stay on the same level as the state stack.
5053  The wasted elements are never initialized. */
5054  yyssp = yyss;
5055  yyvsp = yyvs;
5056 
5057  goto yysetstate;
5058 
5059 /*------------------------------------------------------------.
5060 | yynewstate -- Push a new state, which is found in yystate. |
5061 `------------------------------------------------------------*/
5062  yynewstate:
5063  /* In all cases, when you get here, the value and location stacks
5064  have just been pushed. So pushing a state here evens the stacks. */
5065  yyssp++;
5066 
5067  yysetstate:
5068  *yyssp = yystate;
5069 
5070  if (yyss + yystacksize - 1 <= yyssp)
5071  {
5072  /* Get the current used size of the three stacks, in elements. */
5073  YYSIZE_T yysize = yyssp - yyss + 1;
5074 
5075 #ifdef yyoverflow
5076  {
5077  /* Give user a chance to reallocate the stack. Use copies of
5078  these so that the &'s don't force the real ones into
5079  memory. */
5080  YYSTYPE *yyvs1 = yyvs;
5081  yytype_int16 *yyss1 = yyss;
5082 
5083  /* Each stack pointer address is followed by the size of the
5084  data in use in that stack, in bytes. This used to be a
5085  conditional around just the two extra args, but that might
5086  be undefined if yyoverflow is a macro. */
5087  yyoverflow (YY_("memory exhausted"),
5088  &yyss1, yysize * sizeof (*yyssp),
5089  &yyvs1, yysize * sizeof (*yyvsp),
5090  &yystacksize);
5091 
5092  yyss = yyss1;
5093  yyvs = yyvs1;
5094  }
5095 #else /* no yyoverflow */
5096 # ifndef YYSTACK_RELOCATE
5097  goto yyexhaustedlab;
5098 # else
5099  /* Extend the stack our own way. */
5100  if (YYMAXDEPTH <= yystacksize)
5101  goto yyexhaustedlab;
5102  yystacksize *= 2;
5103  if (YYMAXDEPTH < yystacksize)
5104  yystacksize = YYMAXDEPTH;
5105 
5106  {
5107  yytype_int16 *yyss1 = yyss;
5108  union yyalloc *yyptr =
5109  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
5110  if (! yyptr)
5111  goto yyexhaustedlab;
5112  YYSTACK_RELOCATE (yyss_alloc, yyss);
5113  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
5114 # undef YYSTACK_RELOCATE
5115  if (yyss1 != yyssa)
5116  YYSTACK_FREE (yyss1);
5117  }
5118 # endif
5119 #endif /* no yyoverflow */
5120 
5121  yyssp = yyss + yysize - 1;
5122  yyvsp = yyvs + yysize - 1;
5123 
5124  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
5125  (unsigned long int) yystacksize));
5126 
5127  if (yyss + yystacksize - 1 <= yyssp)
5128  YYABORT;
5129  }
5130 
5131  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
5132 
5133  if (yystate == YYFINAL)
5134  YYACCEPT;
5135 
5136  goto yybackup;
5137 
5138 /*-----------.
5139 | yybackup. |
5140 `-----------*/
5141 yybackup:
5142 
5143  /* Do appropriate processing given the current state. Read a
5144  lookahead token if we need one and don't already have one. */
5145 
5146  /* First try to decide what to do without reference to lookahead token. */
5147  yyn = yypact[yystate];
5148  if (yypact_value_is_default (yyn))
5149  goto yydefault;
5150 
5151  /* Not known => get a lookahead token if don't already have one. */
5152 
5153  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5154  if (yychar == YYEMPTY)
5155  {
5156  YYDPRINTF ((stderr, "Reading a token: "));
5157  yychar = YYLEX;
5158  }
5159 
5160  if (yychar <= YYEOF)
5161  {
5162  yychar = yytoken = YYEOF;
5163  YYDPRINTF ((stderr, "Now at end of input.\n"));
5164  }
5165  else
5166  {
5167  yytoken = YYTRANSLATE (yychar);
5168  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
5169  }
5170 
5171  /* If the proper action on seeing token YYTOKEN is to reduce or to
5172  detect an error, take that action. */
5173  yyn += yytoken;
5174  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
5175  goto yydefault;
5176  yyn = yytable[yyn];
5177  if (yyn <= 0)
5178  {
5179  if (yytable_value_is_error (yyn))
5180  goto yyerrlab;
5181  yyn = -yyn;
5182  goto yyreduce;
5183  }
5184 
5185  /* Count tokens shifted since error; after three, turn off error
5186  status. */
5187  if (yyerrstatus)
5188  yyerrstatus--;
5189 
5190  /* Shift the lookahead token. */
5191  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
5192 
5193  /* Discard the shifted token. */
5194  yychar = YYEMPTY;
5195 
5196  yystate = yyn;
5197  *++yyvsp = yylval;
5198 
5199  goto yynewstate;
5200 
5201 
5202 /*-----------------------------------------------------------.
5203 | yydefault -- do the default action for the current state. |
5204 `-----------------------------------------------------------*/
5205 yydefault:
5206  yyn = yydefact[yystate];
5207  if (yyn == 0)
5208  goto yyerrlab;
5209  goto yyreduce;
5210 
5211 
5212 /*-----------------------------.
5213 | yyreduce -- Do a reduction. |
5214 `-----------------------------*/
5215 yyreduce:
5216  /* yyn is the number of a rule to reduce with. */
5217  yylen = yyr2[yyn];
5218 
5219  /* If YYLEN is nonzero, implement the default value of the action:
5220  `$$ = $1'.
5221 
5222  Otherwise, the following line sets YYVAL to garbage.
5223  This behavior is undocumented and Bison
5224  users should not rely upon it. Assigning to YYVAL
5225  unconditionally makes the parser a bit smaller, and it avoids a
5226  GCC warning that YYVAL may be used uninitialized. */
5227  yyval = yyvsp[1-yylen];
5228 
5229 
5230  YY_REDUCE_PRINT (yyn);
5231  switch (yyn)
5232  {
5233  case 2:
5234 
5235 /* Line 1806 of yacc.c */
5236 #line 863 "ripper.y"
5237  {
5238  lex_state = EXPR_BEG;
5239 #if 0
5240  local_push(compile_for_eval || rb_parse_in_main());
5241 #endif
5242  local_push(0);
5243 
5244  }
5245  break;
5246 
5247  case 3:
5248 
5249 /* Line 1806 of yacc.c */
5250 #line 872 "ripper.y"
5251  {
5252 #if 0
5253  if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
5254  /* last expression should not be void */
5255  if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
5256  else {
5257  NODE *node = (yyvsp[(2) - (2)].val);
5258  while (node->nd_next) {
5259  node = node->nd_next;
5260  }
5261  void_expr(node->nd_head);
5262  }
5263  }
5264  ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val)));
5265 #endif
5266  (yyval.val) = (yyvsp[(2) - (2)].val);
5267  parser->result = dispatch1(program, (yyval.val));
5268 
5269  local_pop();
5270  }
5271  break;
5272 
5273  case 4:
5274 
5275 /* Line 1806 of yacc.c */
5276 #line 895 "ripper.y"
5277  {
5278 #if 0
5279  void_stmts((yyvsp[(1) - (2)].val));
5280  fixup_nodes(&deferred_nodes);
5281 #endif
5282 
5283  (yyval.val) = (yyvsp[(1) - (2)].val);
5284  }
5285  break;
5286 
5287  case 5:
5288 
5289 /* Line 1806 of yacc.c */
5290 #line 906 "ripper.y"
5291  {
5292 #if 0
5293  (yyval.val) = NEW_BEGIN(0);
5294 #endif
5295  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5296  dispatch0(void_stmt));
5297 
5298  }
5299  break;
5300 
5301  case 6:
5302 
5303 /* Line 1806 of yacc.c */
5304 #line 915 "ripper.y"
5305  {
5306 #if 0
5307  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5308 #endif
5309  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5310 
5311  }
5312  break;
5313 
5314  case 7:
5315 
5316 /* Line 1806 of yacc.c */
5317 #line 923 "ripper.y"
5318  {
5319 #if 0
5320  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5321 #endif
5322  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5323 
5324  }
5325  break;
5326 
5327  case 8:
5328 
5329 /* Line 1806 of yacc.c */
5330 #line 931 "ripper.y"
5331  {
5332  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5333  }
5334  break;
5335 
5336  case 10:
5337 
5338 /* Line 1806 of yacc.c */
5339 #line 938 "ripper.y"
5340  {
5341 #if 0
5342  /* local_push(0); */
5343 #endif
5344 
5345  }
5346  break;
5347 
5348  case 11:
5349 
5350 /* Line 1806 of yacc.c */
5351 #line 945 "ripper.y"
5352  {
5353 #if 0
5354  ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
5355  (yyvsp[(4) - (5)].val));
5356  /* NEW_PREEXE($4)); */
5357  /* local_pop(); */
5358  (yyval.val) = NEW_BEGIN(0);
5359 #endif
5360  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5361 
5362  }
5363  break;
5364 
5365  case 12:
5366 
5367 /* Line 1806 of yacc.c */
5368 #line 962 "ripper.y"
5369  {
5370 #if 0
5371  (yyval.val) = (yyvsp[(1) - (4)].val);
5372  if ((yyvsp[(2) - (4)].val)) {
5373  (yyval.val) = NEW_RESCUE((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
5374  }
5375  else if ((yyvsp[(3) - (4)].val)) {
5376  rb_warn0("else without rescue is useless");
5377  (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val));
5378  }
5379  if ((yyvsp[(4) - (4)].val)) {
5380  if ((yyval.val)) {
5381  (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
5382  }
5383  else {
5384  (yyval.val) = block_append((yyvsp[(4) - (4)].val), NEW_NIL());
5385  }
5386  }
5387  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5388 #endif
5389  (yyval.val) = dispatch4(bodystmt,
5390  escape_Qundef((yyvsp[(1) - (4)].val)),
5391  escape_Qundef((yyvsp[(2) - (4)].val)),
5392  escape_Qundef((yyvsp[(3) - (4)].val)),
5393  escape_Qundef((yyvsp[(4) - (4)].val)));
5394 
5395  }
5396  break;
5397 
5398  case 13:
5399 
5400 /* Line 1806 of yacc.c */
5401 #line 992 "ripper.y"
5402  {
5403 #if 0
5404  void_stmts((yyvsp[(1) - (2)].val));
5405  fixup_nodes(&deferred_nodes);
5406 #endif
5407 
5408  (yyval.val) = (yyvsp[(1) - (2)].val);
5409  }
5410  break;
5411 
5412  case 14:
5413 
5414 /* Line 1806 of yacc.c */
5415 #line 1003 "ripper.y"
5416  {
5417 #if 0
5418  (yyval.val) = NEW_BEGIN(0);
5419 #endif
5420  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5421  dispatch0(void_stmt));
5422 
5423  }
5424  break;
5425 
5426  case 15:
5427 
5428 /* Line 1806 of yacc.c */
5429 #line 1012 "ripper.y"
5430  {
5431 #if 0
5432  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5433 #endif
5434  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5435 
5436  }
5437  break;
5438 
5439  case 16:
5440 
5441 /* Line 1806 of yacc.c */
5442 #line 1020 "ripper.y"
5443  {
5444 #if 0
5445  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)));
5446 #endif
5447  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5448 
5449  }
5450  break;
5451 
5452  case 17:
5453 
5454 /* Line 1806 of yacc.c */
5455 #line 1028 "ripper.y"
5456  {
5457  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5458  }
5459  break;
5460 
5461  case 18:
5462 
5463 /* Line 1806 of yacc.c */
5464 #line 1034 "ripper.y"
5465  {
5466  (yyval.val) = (yyvsp[(1) - (1)].val);
5467  }
5468  break;
5469 
5470  case 19:
5471 
5472 /* Line 1806 of yacc.c */
5473 #line 1038 "ripper.y"
5474  {
5475  yyerror("BEGIN is permitted only at toplevel");
5476 #if 0
5477  /* local_push(0); */
5478 #endif
5479 
5480  }
5481  break;
5482 
5483  case 20:
5484 
5485 /* Line 1806 of yacc.c */
5486 #line 1046 "ripper.y"
5487  {
5488 #if 0
5489  ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
5490  (yyvsp[(4) - (5)].val));
5491  /* NEW_PREEXE($4)); */
5492  /* local_pop(); */
5493  (yyval.val) = NEW_BEGIN(0);
5494 #endif
5495  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5496 
5497  }
5498  break;
5499 
5500  case 21:
5501 
5502 /* Line 1806 of yacc.c */
5503 #line 1058 "ripper.y"
5504  {lex_state = EXPR_FNAME;}
5505  break;
5506 
5507  case 22:
5508 
5509 /* Line 1806 of yacc.c */
5510 #line 1059 "ripper.y"
5511  {
5512 #if 0
5513  (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5514 #endif
5515  (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5516 
5517  }
5518  break;
5519 
5520  case 23:
5521 
5522 /* Line 1806 of yacc.c */
5523 #line 1067 "ripper.y"
5524  {
5525 #if 0
5526  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5527 #endif
5528  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5529 
5530  }
5531  break;
5532 
5533  case 24:
5534 
5535 /* Line 1806 of yacc.c */
5536 #line 1075 "ripper.y"
5537  {
5538 #if 0
5539  char buf[2];
5540  buf[0] = '$';
5541  buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
5542  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
5543 #endif
5544  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5545 
5546  }
5547  break;
5548 
5549  case 25:
5550 
5551 /* Line 1806 of yacc.c */
5552 #line 1086 "ripper.y"
5553  {
5554 #if 0
5555  yyerror("can't make alias for the number variables");
5556  (yyval.val) = NEW_BEGIN(0);
5557 #endif
5558  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5559  (yyval.val) = dispatch1(alias_error, (yyval.val));
5560 
5561  }
5562  break;
5563 
5564  case 26:
5565 
5566 /* Line 1806 of yacc.c */
5567 #line 1096 "ripper.y"
5568  {
5569 #if 0
5570  (yyval.val) = (yyvsp[(2) - (2)].val);
5571 #endif
5572  (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
5573 
5574  }
5575  break;
5576 
5577  case 27:
5578 
5579 /* Line 1806 of yacc.c */
5580 #line 1104 "ripper.y"
5581  {
5582 #if 0
5583  (yyval.val) = NEW_IF(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5584  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5585 #endif
5586  (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5587 
5588  }
5589  break;
5590 
5591  case 28:
5592 
5593 /* Line 1806 of yacc.c */
5594 #line 1113 "ripper.y"
5595  {
5596 #if 0
5597  (yyval.val) = NEW_UNLESS(cond((yyvsp[(3) - (3)].val)), remove_begin((yyvsp[(1) - (3)].val)), 0);
5598  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5599 #endif
5600  (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5601 
5602  }
5603  break;
5604 
5605  case 29:
5606 
5607 /* Line 1806 of yacc.c */
5608 #line 1122 "ripper.y"
5609  {
5610 #if 0
5611  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5612  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5613  }
5614  else {
5615  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5616  }
5617 #endif
5618  (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5619 
5620  }
5621  break;
5622 
5623  case 30:
5624 
5625 /* Line 1806 of yacc.c */
5626 #line 1135 "ripper.y"
5627  {
5628 #if 0
5629  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
5630  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val)->nd_body, 0);
5631  }
5632  else {
5633  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val)), (yyvsp[(1) - (3)].val), 1);
5634  }
5635 #endif
5636  (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
5637 
5638  }
5639  break;
5640 
5641  case 31:
5642 
5643 /* Line 1806 of yacc.c */
5644 #line 1148 "ripper.y"
5645  {
5646 #if 0
5647  NODE *resq = NEW_RESBODY(0, remove_begin((yyvsp[(3) - (3)].val)), 0);
5648  (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[(1) - (3)].val)), resq, 0);
5649 #endif
5650  (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5651 
5652  }
5653  break;
5654 
5655  case 32:
5656 
5657 /* Line 1806 of yacc.c */
5658 #line 1157 "ripper.y"
5659  {
5660  if (in_def || in_single) {
5661  rb_warn0("END in method; use at_exit");
5662  }
5663 #if 0
5664  (yyval.val) = NEW_POSTEXE(NEW_NODE(
5665  NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */));
5666 #endif
5667  (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
5668 
5669  }
5670  break;
5671 
5672  case 34:
5673 
5674 /* Line 1806 of yacc.c */
5675 #line 1170 "ripper.y"
5676  {
5677 #if 0
5678  value_expr((yyvsp[(3) - (3)].val));
5679  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5680  (yyval.val) = (yyvsp[(1) - (3)].val);
5681 #endif
5682  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5683 
5684  }
5685  break;
5686 
5687  case 35:
5688 
5689 /* Line 1806 of yacc.c */
5690 #line 1180 "ripper.y"
5691  {
5692  value_expr((yyvsp[(3) - (3)].val));
5693  (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5694  }
5695  break;
5696 
5697  case 36:
5698 
5699 /* Line 1806 of yacc.c */
5700 #line 1185 "ripper.y"
5701  {
5702 #if 0
5703  NODE *args;
5704 
5705  value_expr((yyvsp[(6) - (6)].val));
5706  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
5707  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
5708  if ((yyvsp[(5) - (6)].val) == tOROP) {
5709  (yyvsp[(5) - (6)].val) = 0;
5710  }
5711  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
5712  (yyvsp[(5) - (6)].val) = 1;
5713  }
5714  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
5715  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
5716 #endif
5717  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
5718  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
5719 
5720  }
5721  break;
5722 
5723  case 37:
5724 
5725 /* Line 1806 of yacc.c */
5726 #line 1206 "ripper.y"
5727  {
5728  value_expr((yyvsp[(5) - (5)].val));
5729  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5730  }
5731  break;
5732 
5733  case 38:
5734 
5735 /* Line 1806 of yacc.c */
5736 #line 1211 "ripper.y"
5737  {
5738  value_expr((yyvsp[(5) - (5)].val));
5739  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5740  }
5741  break;
5742 
5743  case 39:
5744 
5745 /* Line 1806 of yacc.c */
5746 #line 1216 "ripper.y"
5747  {
5748 #if 0
5749  (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
5750  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5751 #endif
5752  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
5753  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5754 
5755  }
5756  break;
5757 
5758  case 40:
5759 
5760 /* Line 1806 of yacc.c */
5761 #line 1226 "ripper.y"
5762  {
5763  value_expr((yyvsp[(5) - (5)].val));
5764  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
5765  }
5766  break;
5767 
5768  case 41:
5769 
5770 /* Line 1806 of yacc.c */
5771 #line 1231 "ripper.y"
5772  {
5773 #if 0
5774  rb_backref_error((yyvsp[(1) - (3)].val));
5775  (yyval.val) = NEW_BEGIN(0);
5776 #endif
5777  (yyval.val) = dispatch2(assign, dispatch1(var_field, (yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
5778  (yyval.val) = dispatch1(assign_error, (yyval.val));
5779 
5780  }
5781  break;
5782 
5783  case 42:
5784 
5785 /* Line 1806 of yacc.c */
5786 #line 1241 "ripper.y"
5787  {
5788 #if 0
5789  value_expr((yyvsp[(3) - (3)].val));
5790  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5791 #endif
5792  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5793 
5794  }
5795  break;
5796 
5797  case 43:
5798 
5799 /* Line 1806 of yacc.c */
5800 #line 1250 "ripper.y"
5801  {
5802 #if 0
5803  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
5804  (yyval.val) = (yyvsp[(1) - (3)].val);
5805 #endif
5806  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5807 
5808  }
5809  break;
5810 
5811  case 45:
5812 
5813 /* Line 1806 of yacc.c */
5814 #line 1262 "ripper.y"
5815  {
5816 #if 0
5817  value_expr((yyvsp[(3) - (3)].val));
5818  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5819 #endif
5820  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5821 
5822  }
5823  break;
5824 
5825  case 46:
5826 
5827 /* Line 1806 of yacc.c */
5828 #line 1271 "ripper.y"
5829  {
5830 #if 0
5831  value_expr((yyvsp[(3) - (3)].val));
5832  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5833 #endif
5834  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5835 
5836  }
5837  break;
5838 
5839  case 48:
5840 
5841 /* Line 1806 of yacc.c */
5842 #line 1284 "ripper.y"
5843  {
5844 #if 0
5845  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5846 #endif
5847  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("and"), (yyvsp[(3) - (3)].val));
5848 
5849  }
5850  break;
5851 
5852  case 49:
5853 
5854 /* Line 1806 of yacc.c */
5855 #line 1292 "ripper.y"
5856  {
5857 #if 0
5858  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5859 #endif
5860  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("or"), (yyvsp[(3) - (3)].val));
5861 
5862  }
5863  break;
5864 
5865  case 50:
5866 
5867 /* Line 1806 of yacc.c */
5868 #line 1300 "ripper.y"
5869  {
5870 #if 0
5871  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (3)].val)), '!');
5872 #endif
5873  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (3)].val));
5874 
5875  }
5876  break;
5877 
5878  case 51:
5879 
5880 /* Line 1806 of yacc.c */
5881 #line 1308 "ripper.y"
5882  {
5883 #if 0
5884  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
5885 #endif
5886  (yyval.val) = dispatch2(unary, ripper_id2sym('!'), (yyvsp[(2) - (2)].val));
5887 
5888  }
5889  break;
5890 
5891  case 53:
5892 
5893 /* Line 1806 of yacc.c */
5894 #line 1319 "ripper.y"
5895  {
5896 #if 0
5897  value_expr((yyvsp[(1) - (1)].val));
5898  (yyval.val) = (yyvsp[(1) - (1)].val);
5899  if (!(yyval.val)) (yyval.val) = NEW_NIL();
5900 #endif
5901  (yyval.val) = (yyvsp[(1) - (1)].val);
5902 
5903  }
5904  break;
5905 
5906  case 57:
5907 
5908 /* Line 1806 of yacc.c */
5909 #line 1336 "ripper.y"
5910  {
5911 #if 0
5912  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
5913 #endif
5914  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
5915  (yyval.val) = method_arg((yyval.val), (yyvsp[(4) - (4)].val));
5916 
5917  }
5918  break;
5919 
5920  case 58:
5921 
5922 /* Line 1806 of yacc.c */
5923 #line 1347 "ripper.y"
5924  {
5925  (yyvsp[(1) - (1)].vars) = dyna_push();
5926 #if 0
5927  (yyval.num) = ruby_sourceline;
5928 #endif
5929 
5930  }
5931  break;
5932 
5933  case 59:
5934 
5935 /* Line 1806 of yacc.c */
5936 #line 1357 "ripper.y"
5937  {
5938 #if 0
5939  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
5940  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
5941 #endif
5942  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
5943 
5944  dyna_pop((yyvsp[(1) - (5)].vars));
5945  }
5946  break;
5947 
5948  case 60:
5949 
5950 /* Line 1806 of yacc.c */
5951 #line 1369 "ripper.y"
5952  {
5953 #if 0
5954  (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
5955  nd_set_line((yyval.val), tokline);
5956 #endif
5957 
5958  }
5959  break;
5960 
5961  case 61:
5962 
5963 /* Line 1806 of yacc.c */
5964 #line 1379 "ripper.y"
5965  {
5966 #if 0
5967  (yyval.val) = (yyvsp[(1) - (2)].val);
5968  (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
5969 #endif
5970  (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
5971 
5972  }
5973  break;
5974 
5975  case 62:
5976 
5977 /* Line 1806 of yacc.c */
5978 #line 1388 "ripper.y"
5979  {
5980 #if 0
5981  block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
5982  (yyvsp[(1) - (3)].val)->nd_args = (yyvsp[(2) - (3)].val);
5983  (yyvsp[(3) - (3)].val)->nd_iter = (yyvsp[(1) - (3)].val);
5984  (yyval.val) = (yyvsp[(3) - (3)].val);
5985  fixpos((yyval.val), (yyvsp[(1) - (3)].val));
5986 #endif
5987  (yyval.val) = dispatch2(command, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
5988  (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
5989 
5990  }
5991  break;
5992 
5993  case 63:
5994 
5995 /* Line 1806 of yacc.c */
5996 #line 1401 "ripper.y"
5997  {
5998 #if 0
5999  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6000  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
6001 #endif
6002  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6003 
6004  }
6005  break;
6006 
6007  case 64:
6008 
6009 /* Line 1806 of yacc.c */
6010 #line 1410 "ripper.y"
6011  {
6012 #if 0
6013  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
6014  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6015  (yyval.val) = (yyvsp[(5) - (5)].val);
6016  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6017 #endif
6018  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6019  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
6020 
6021  }
6022  break;
6023 
6024  case 65:
6025 
6026 /* Line 1806 of yacc.c */
6027 #line 1422 "ripper.y"
6028  {
6029 #if 0
6030  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6031  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
6032 #endif
6033  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (4)].val), ripper_intern("::"), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
6034 
6035  }
6036  break;
6037 
6038  case 66:
6039 
6040 /* Line 1806 of yacc.c */
6041 #line 1431 "ripper.y"
6042  {
6043 #if 0
6044  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
6045  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6046  (yyval.val) = (yyvsp[(5) - (5)].val);
6047  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6048 #endif
6049  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
6050  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
6051 
6052  }
6053  break;
6054 
6055  case 67:
6056 
6057 /* Line 1806 of yacc.c */
6058 #line 1443 "ripper.y"
6059  {
6060 #if 0
6061  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
6062  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
6063 #endif
6064  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
6065 
6066  }
6067  break;
6068 
6069  case 68:
6070 
6071 /* Line 1806 of yacc.c */
6072 #line 1452 "ripper.y"
6073  {
6074 #if 0
6075  (yyval.val) = new_yield((yyvsp[(2) - (2)].val));
6076  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
6077 #endif
6078  (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
6079 
6080  }
6081  break;
6082 
6083  case 69:
6084 
6085 /* Line 1806 of yacc.c */
6086 #line 1461 "ripper.y"
6087  {
6088 #if 0
6089  (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
6090 #endif
6091  (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
6092 
6093  }
6094  break;
6095 
6096  case 70:
6097 
6098 /* Line 1806 of yacc.c */
6099 #line 1469 "ripper.y"
6100  {
6101 #if 0
6102  (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
6103 #endif
6104  (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
6105 
6106  }
6107  break;
6108 
6109  case 71:
6110 
6111 /* Line 1806 of yacc.c */
6112 #line 1477 "ripper.y"
6113  {
6114 #if 0
6115  (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
6116 #endif
6117  (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
6118 
6119  }
6120  break;
6121 
6122  case 73:
6123 
6124 /* Line 1806 of yacc.c */
6125 #line 1488 "ripper.y"
6126  {
6127 #if 0
6128  (yyval.val) = (yyvsp[(2) - (3)].val);
6129 #endif
6130  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6131 
6132  }
6133  break;
6134 
6135  case 75:
6136 
6137 /* Line 1806 of yacc.c */
6138 #line 1499 "ripper.y"
6139  {
6140 #if 0
6141  (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[(2) - (3)].val)), 0);
6142 #endif
6143  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6144 
6145  }
6146  break;
6147 
6148  case 76:
6149 
6150 /* Line 1806 of yacc.c */
6151 #line 1509 "ripper.y"
6152  {
6153 #if 0
6154  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
6155 #endif
6156  (yyval.val) = (yyvsp[(1) - (1)].val);
6157 
6158  }
6159  break;
6160 
6161  case 77:
6162 
6163 /* Line 1806 of yacc.c */
6164 #line 1517 "ripper.y"
6165  {
6166 #if 0
6167  (yyval.val) = NEW_MASGN(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val)), 0);
6168 #endif
6169  (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
6170 
6171  }
6172  break;
6173 
6174  case 78:
6175 
6176 /* Line 1806 of yacc.c */
6177 #line 1525 "ripper.y"
6178  {
6179 #if 0
6180  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6181 #endif
6182  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6183 
6184  }
6185  break;
6186 
6187  case 79:
6188 
6189 /* Line 1806 of yacc.c */
6190 #line 1533 "ripper.y"
6191  {
6192 #if 0
6193  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val)));
6194 #endif
6195  (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6196  (yyval.val) = mlhs_add((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
6197 
6198  }
6199  break;
6200 
6201  case 80:
6202 
6203 /* Line 1806 of yacc.c */
6204 #line 1542 "ripper.y"
6205  {
6206 #if 0
6207  (yyval.val) = NEW_MASGN((yyvsp[(1) - (2)].val), -1);
6208 #endif
6209  (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
6210 
6211  }
6212  break;
6213 
6214  case 81:
6215 
6216 /* Line 1806 of yacc.c */
6217 #line 1550 "ripper.y"
6218  {
6219 #if 0
6220  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
6221 #endif
6222  (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
6223  (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6224 
6225  }
6226  break;
6227 
6228  case 82:
6229 
6230 /* Line 1806 of yacc.c */
6231 #line 1559 "ripper.y"
6232  {
6233 #if 0
6234  (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
6235 #endif
6236  (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
6237 
6238  }
6239  break;
6240 
6241  case 83:
6242 
6243 /* Line 1806 of yacc.c */
6244 #line 1567 "ripper.y"
6245  {
6246 #if 0
6247  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
6248 #endif
6249  (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
6250  (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
6251 
6252  }
6253  break;
6254 
6255  case 84:
6256 
6257 /* Line 1806 of yacc.c */
6258 #line 1576 "ripper.y"
6259  {
6260 #if 0
6261  (yyval.val) = NEW_MASGN(0, -1);
6262 #endif
6263  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6264 
6265  }
6266  break;
6267 
6268  case 85:
6269 
6270 /* Line 1806 of yacc.c */
6271 #line 1584 "ripper.y"
6272  {
6273 #if 0
6274  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
6275 #endif
6276  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6277  (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
6278 
6279  }
6280  break;
6281 
6282  case 87:
6283 
6284 /* Line 1806 of yacc.c */
6285 #line 1596 "ripper.y"
6286  {
6287 #if 0
6288  (yyval.val) = (yyvsp[(2) - (3)].val);
6289 #endif
6290  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6291 
6292  }
6293  break;
6294 
6295  case 88:
6296 
6297 /* Line 1806 of yacc.c */
6298 #line 1606 "ripper.y"
6299  {
6300 #if 0
6301  (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
6302 #endif
6303  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
6304 
6305  }
6306  break;
6307 
6308  case 89:
6309 
6310 /* Line 1806 of yacc.c */
6311 #line 1614 "ripper.y"
6312  {
6313 #if 0
6314  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6315 #endif
6316  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6317 
6318  }
6319  break;
6320 
6321  case 90:
6322 
6323 /* Line 1806 of yacc.c */
6324 #line 1624 "ripper.y"
6325  {
6326 #if 0
6327  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
6328 #endif
6329  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
6330 
6331  }
6332  break;
6333 
6334  case 91:
6335 
6336 /* Line 1806 of yacc.c */
6337 #line 1632 "ripper.y"
6338  {
6339 #if 0
6340  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6341 #endif
6342  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6343 
6344  }
6345  break;
6346 
6347  case 92:
6348 
6349 /* Line 1806 of yacc.c */
6350 #line 1642 "ripper.y"
6351  {
6352  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6353  }
6354  break;
6355 
6356  case 93:
6357 
6358 /* Line 1806 of yacc.c */
6359 #line 1646 "ripper.y"
6360  {
6361  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6362  }
6363  break;
6364 
6365  case 94:
6366 
6367 /* Line 1806 of yacc.c */
6368 #line 1650 "ripper.y"
6369  {
6370 #if 0
6371  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6372 #endif
6373  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6374 
6375  }
6376  break;
6377 
6378  case 95:
6379 
6380 /* Line 1806 of yacc.c */
6381 #line 1658 "ripper.y"
6382  {
6383 #if 0
6384  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6385 #endif
6386  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6387 
6388  }
6389  break;
6390 
6391  case 96:
6392 
6393 /* Line 1806 of yacc.c */
6394 #line 1666 "ripper.y"
6395  {
6396 #if 0
6397  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6398 #endif
6399  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6400 
6401  }
6402  break;
6403 
6404  case 97:
6405 
6406 /* Line 1806 of yacc.c */
6407 #line 1674 "ripper.y"
6408  {
6409 #if 0
6410  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6411 #endif
6412  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6413 
6414  }
6415  break;
6416 
6417  case 98:
6418 
6419 /* Line 1806 of yacc.c */
6420 #line 1682 "ripper.y"
6421  {
6422 #if 0
6423  if (in_def || in_single)
6424  yyerror("dynamic constant assignment");
6425  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6426 #endif
6427  if (in_def || in_single)
6428  yyerror("dynamic constant assignment");
6429  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6430 
6431  }
6432  break;
6433 
6434  case 99:
6435 
6436 /* Line 1806 of yacc.c */
6437 #line 1694 "ripper.y"
6438  {
6439 #if 0
6440  if (in_def || in_single)
6441  yyerror("dynamic constant assignment");
6442  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6443 #endif
6444  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6445 
6446  }
6447  break;
6448 
6449  case 100:
6450 
6451 /* Line 1806 of yacc.c */
6452 #line 1704 "ripper.y"
6453  {
6454 #if 0
6455  rb_backref_error((yyvsp[(1) - (1)].val));
6456  (yyval.val) = NEW_BEGIN(0);
6457 #endif
6458  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (1)].val));
6459  (yyval.val) = dispatch1(assign_error, (yyval.val));
6460 
6461  }
6462  break;
6463 
6464  case 101:
6465 
6466 /* Line 1806 of yacc.c */
6467 #line 1716 "ripper.y"
6468  {
6469  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6470 #if 0
6471  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6472 #endif
6473  (yyval.val) = dispatch1(var_field, (yyval.val));
6474 
6475  }
6476  break;
6477 
6478  case 102:
6479 
6480 /* Line 1806 of yacc.c */
6481 #line 1725 "ripper.y"
6482  {
6483  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6484 #if 0
6485  if (!(yyval.val)) (yyval.val) = NEW_BEGIN(0);
6486 #endif
6487  (yyval.val) = dispatch1(var_field, (yyval.val));
6488 
6489  }
6490  break;
6491 
6492  case 103:
6493 
6494 /* Line 1806 of yacc.c */
6495 #line 1734 "ripper.y"
6496  {
6497 #if 0
6498  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6499 #endif
6500  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6501 
6502  }
6503  break;
6504 
6505  case 104:
6506 
6507 /* Line 1806 of yacc.c */
6508 #line 1742 "ripper.y"
6509  {
6510 #if 0
6511  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6512 #endif
6513  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6514 
6515  }
6516  break;
6517 
6518  case 105:
6519 
6520 /* Line 1806 of yacc.c */
6521 #line 1750 "ripper.y"
6522  {
6523 #if 0
6524  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6525 #endif
6526  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
6527 
6528  }
6529  break;
6530 
6531  case 106:
6532 
6533 /* Line 1806 of yacc.c */
6534 #line 1758 "ripper.y"
6535  {
6536 #if 0
6537  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6538 #endif
6539  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ripper_id2sym('.'), (yyvsp[(3) - (3)].val));
6540 
6541  }
6542  break;
6543 
6544  case 107:
6545 
6546 /* Line 1806 of yacc.c */
6547 #line 1766 "ripper.y"
6548  {
6549 #if 0
6550  if (in_def || in_single)
6551  yyerror("dynamic constant assignment");
6552  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val)));
6553 #endif
6554  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6555  if (in_def || in_single) {
6556  (yyval.val) = dispatch1(assign_error, (yyval.val));
6557  }
6558 
6559  }
6560  break;
6561 
6562  case 108:
6563 
6564 /* Line 1806 of yacc.c */
6565 #line 1779 "ripper.y"
6566  {
6567 #if 0
6568  if (in_def || in_single)
6569  yyerror("dynamic constant assignment");
6570  (yyval.val) = NEW_CDECL(0, 0, NEW_COLON3((yyvsp[(2) - (2)].val)));
6571 #endif
6572  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (2)].val));
6573  if (in_def || in_single) {
6574  (yyval.val) = dispatch1(assign_error, (yyval.val));
6575  }
6576 
6577  }
6578  break;
6579 
6580  case 109:
6581 
6582 /* Line 1806 of yacc.c */
6583 #line 1792 "ripper.y"
6584  {
6585 #if 0
6586  rb_backref_error((yyvsp[(1) - (1)].val));
6587  (yyval.val) = NEW_BEGIN(0);
6588 #endif
6589  (yyval.val) = dispatch1(assign_error, (yyvsp[(1) - (1)].val));
6590 
6591  }
6592  break;
6593 
6594  case 110:
6595 
6596 /* Line 1806 of yacc.c */
6597 #line 1803 "ripper.y"
6598  {
6599 #if 0
6600  yyerror("class/module name must be CONSTANT");
6601 #endif
6602  (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
6603 
6604  }
6605  break;
6606 
6607  case 112:
6608 
6609 /* Line 1806 of yacc.c */
6610 #line 1814 "ripper.y"
6611  {
6612 #if 0
6613  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
6614 #endif
6615  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
6616 
6617  }
6618  break;
6619 
6620  case 113:
6621 
6622 /* Line 1806 of yacc.c */
6623 #line 1822 "ripper.y"
6624  {
6625 #if 0
6626  (yyval.val) = NEW_COLON2(0, (yyval.val));
6627 #endif
6628  (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
6629 
6630  }
6631  break;
6632 
6633  case 114:
6634 
6635 /* Line 1806 of yacc.c */
6636 #line 1830 "ripper.y"
6637  {
6638 #if 0
6639  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6640 #endif
6641  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6642 
6643  }
6644  break;
6645 
6646  case 118:
6647 
6648 /* Line 1806 of yacc.c */
6649 #line 1843 "ripper.y"
6650  {
6651  lex_state = EXPR_ENDFN;
6652  (yyval.val) = (yyvsp[(1) - (1)].val);
6653  }
6654  break;
6655 
6656  case 119:
6657 
6658 /* Line 1806 of yacc.c */
6659 #line 1848 "ripper.y"
6660  {
6661  lex_state = EXPR_ENDFN;
6662 #if 0
6663  (yyval.val) = (yyvsp[(1) - (1)].id);
6664 #endif
6665  (yyval.val) = (yyvsp[(1) - (1)].val);
6666 
6667  }
6668  break;
6669 
6670  case 122:
6671 
6672 /* Line 1806 of yacc.c */
6673 #line 1863 "ripper.y"
6674  {
6675 #if 0
6676  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
6677 #endif
6678  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
6679 
6680  }
6681  break;
6682 
6683  case 124:
6684 
6685 /* Line 1806 of yacc.c */
6686 #line 1874 "ripper.y"
6687  {
6688 #if 0
6689  (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
6690 #endif
6691  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
6692 
6693  }
6694  break;
6695 
6696  case 125:
6697 
6698 /* Line 1806 of yacc.c */
6699 #line 1881 "ripper.y"
6700  {lex_state = EXPR_FNAME;}
6701  break;
6702 
6703  case 126:
6704 
6705 /* Line 1806 of yacc.c */
6706 #line 1882 "ripper.y"
6707  {
6708 #if 0
6709  (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
6710 #endif
6711  rb_ary_push((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6712 
6713  }
6714  break;
6715 
6716  case 127:
6717 
6718 /* Line 1806 of yacc.c */
6719 #line 1891 "ripper.y"
6720  { ifndef_ripper((yyval.val) = '|'); }
6721  break;
6722 
6723  case 128:
6724 
6725 /* Line 1806 of yacc.c */
6726 #line 1892 "ripper.y"
6727  { ifndef_ripper((yyval.val) = '^'); }
6728  break;
6729 
6730  case 129:
6731 
6732 /* Line 1806 of yacc.c */
6733 #line 1893 "ripper.y"
6734  { ifndef_ripper((yyval.val) = '&'); }
6735  break;
6736 
6737  case 130:
6738 
6739 /* Line 1806 of yacc.c */
6740 #line 1894 "ripper.y"
6741  { ifndef_ripper((yyval.val) = tCMP); }
6742  break;
6743 
6744  case 131:
6745 
6746 /* Line 1806 of yacc.c */
6747 #line 1895 "ripper.y"
6748  { ifndef_ripper((yyval.val) = tEQ); }
6749  break;
6750 
6751  case 132:
6752 
6753 /* Line 1806 of yacc.c */
6754 #line 1896 "ripper.y"
6755  { ifndef_ripper((yyval.val) = tEQQ); }
6756  break;
6757 
6758  case 133:
6759 
6760 /* Line 1806 of yacc.c */
6761 #line 1897 "ripper.y"
6762  { ifndef_ripper((yyval.val) = tMATCH); }
6763  break;
6764 
6765  case 134:
6766 
6767 /* Line 1806 of yacc.c */
6768 #line 1898 "ripper.y"
6769  { ifndef_ripper((yyval.val) = tNMATCH); }
6770  break;
6771 
6772  case 135:
6773 
6774 /* Line 1806 of yacc.c */
6775 #line 1899 "ripper.y"
6776  { ifndef_ripper((yyval.val) = '>'); }
6777  break;
6778 
6779  case 136:
6780 
6781 /* Line 1806 of yacc.c */
6782 #line 1900 "ripper.y"
6783  { ifndef_ripper((yyval.val) = tGEQ); }
6784  break;
6785 
6786  case 137:
6787 
6788 /* Line 1806 of yacc.c */
6789 #line 1901 "ripper.y"
6790  { ifndef_ripper((yyval.val) = '<'); }
6791  break;
6792 
6793  case 138:
6794 
6795 /* Line 1806 of yacc.c */
6796 #line 1902 "ripper.y"
6797  { ifndef_ripper((yyval.val) = tLEQ); }
6798  break;
6799 
6800  case 139:
6801 
6802 /* Line 1806 of yacc.c */
6803 #line 1903 "ripper.y"
6804  { ifndef_ripper((yyval.val) = tNEQ); }
6805  break;
6806 
6807  case 140:
6808 
6809 /* Line 1806 of yacc.c */
6810 #line 1904 "ripper.y"
6811  { ifndef_ripper((yyval.val) = tLSHFT); }
6812  break;
6813 
6814  case 141:
6815 
6816 /* Line 1806 of yacc.c */
6817 #line 1905 "ripper.y"
6818  { ifndef_ripper((yyval.val) = tRSHFT); }
6819  break;
6820 
6821  case 142:
6822 
6823 /* Line 1806 of yacc.c */
6824 #line 1906 "ripper.y"
6825  { ifndef_ripper((yyval.val) = '+'); }
6826  break;
6827 
6828  case 143:
6829 
6830 /* Line 1806 of yacc.c */
6831 #line 1907 "ripper.y"
6832  { ifndef_ripper((yyval.val) = '-'); }
6833  break;
6834 
6835  case 144:
6836 
6837 /* Line 1806 of yacc.c */
6838 #line 1908 "ripper.y"
6839  { ifndef_ripper((yyval.val) = '*'); }
6840  break;
6841 
6842  case 145:
6843 
6844 /* Line 1806 of yacc.c */
6845 #line 1909 "ripper.y"
6846  { ifndef_ripper((yyval.val) = '*'); }
6847  break;
6848 
6849  case 146:
6850 
6851 /* Line 1806 of yacc.c */
6852 #line 1910 "ripper.y"
6853  { ifndef_ripper((yyval.val) = '/'); }
6854  break;
6855 
6856  case 147:
6857 
6858 /* Line 1806 of yacc.c */
6859 #line 1911 "ripper.y"
6860  { ifndef_ripper((yyval.val) = '%'); }
6861  break;
6862 
6863  case 148:
6864 
6865 /* Line 1806 of yacc.c */
6866 #line 1912 "ripper.y"
6867  { ifndef_ripper((yyval.val) = tPOW); }
6868  break;
6869 
6870  case 149:
6871 
6872 /* Line 1806 of yacc.c */
6873 #line 1913 "ripper.y"
6874  { ifndef_ripper((yyval.val) = tDSTAR); }
6875  break;
6876 
6877  case 150:
6878 
6879 /* Line 1806 of yacc.c */
6880 #line 1914 "ripper.y"
6881  { ifndef_ripper((yyval.val) = '!'); }
6882  break;
6883 
6884  case 151:
6885 
6886 /* Line 1806 of yacc.c */
6887 #line 1915 "ripper.y"
6888  { ifndef_ripper((yyval.val) = '~'); }
6889  break;
6890 
6891  case 152:
6892 
6893 /* Line 1806 of yacc.c */
6894 #line 1916 "ripper.y"
6895  { ifndef_ripper((yyval.val) = tUPLUS); }
6896  break;
6897 
6898  case 153:
6899 
6900 /* Line 1806 of yacc.c */
6901 #line 1917 "ripper.y"
6902  { ifndef_ripper((yyval.val) = tUMINUS); }
6903  break;
6904 
6905  case 154:
6906 
6907 /* Line 1806 of yacc.c */
6908 #line 1918 "ripper.y"
6909  { ifndef_ripper((yyval.val) = tAREF); }
6910  break;
6911 
6912  case 155:
6913 
6914 /* Line 1806 of yacc.c */
6915 #line 1919 "ripper.y"
6916  { ifndef_ripper((yyval.val) = tASET); }
6917  break;
6918 
6919  case 156:
6920 
6921 /* Line 1806 of yacc.c */
6922 #line 1920 "ripper.y"
6923  { ifndef_ripper((yyval.val) = '`'); }
6924  break;
6925 
6926  case 198:
6927 
6928 /* Line 1806 of yacc.c */
6929 #line 1938 "ripper.y"
6930  {
6931 #if 0
6932  value_expr((yyvsp[(3) - (3)].val));
6933  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6934 #endif
6935  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6936 
6937  }
6938  break;
6939 
6940  case 199:
6941 
6942 /* Line 1806 of yacc.c */
6943 #line 1947 "ripper.y"
6944  {
6945 #if 0
6946  value_expr((yyvsp[(3) - (5)].val));
6947  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6948  (yyval.val) = node_assign((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6949 #endif
6950  (yyval.val) = dispatch2(assign, (yyvsp[(1) - (5)].val), dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val)));
6951 
6952  }
6953  break;
6954 
6955  case 200:
6956 
6957 /* Line 1806 of yacc.c */
6958 #line 1957 "ripper.y"
6959  {
6960  value_expr((yyvsp[(3) - (3)].val));
6961  (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
6962  }
6963  break;
6964 
6965  case 201:
6966 
6967 /* Line 1806 of yacc.c */
6968 #line 1962 "ripper.y"
6969  {
6970 #if 0
6971  value_expr((yyvsp[(3) - (5)].val));
6972  (yyvsp[(3) - (5)].val) = NEW_RESCUE((yyvsp[(3) - (5)].val), NEW_RESBODY(0,(yyvsp[(5) - (5)].val),0), 0);
6973 #endif
6974  (yyvsp[(3) - (5)].val) = dispatch2(rescue_mod, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
6975 
6976  (yyval.val) = new_op_assign((yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val));
6977  }
6978  break;
6979 
6980  case 202:
6981 
6982 /* Line 1806 of yacc.c */
6983 #line 1972 "ripper.y"
6984  {
6985 #if 0
6986  NODE *args;
6987 
6988  value_expr((yyvsp[(6) - (6)].val));
6989  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = NEW_ZARRAY();
6990  if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
6991  args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6992  }
6993  else {
6994  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
6995  }
6996  if ((yyvsp[(5) - (6)].val) == tOROP) {
6997  (yyvsp[(5) - (6)].val) = 0;
6998  }
6999  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
7000  (yyvsp[(5) - (6)].val) = 1;
7001  }
7002  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
7003  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
7004 #endif
7005  (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
7006  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
7007 
7008  }
7009  break;
7010 
7011  case 203:
7012 
7013 /* Line 1806 of yacc.c */
7014 #line 1998 "ripper.y"
7015  {
7016  value_expr((yyvsp[(5) - (5)].val));
7017  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7018  }
7019  break;
7020 
7021  case 204:
7022 
7023 /* Line 1806 of yacc.c */
7024 #line 2003 "ripper.y"
7025  {
7026  value_expr((yyvsp[(5) - (5)].val));
7027  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7028  }
7029  break;
7030 
7031  case 205:
7032 
7033 /* Line 1806 of yacc.c */
7034 #line 2008 "ripper.y"
7035  {
7036  value_expr((yyvsp[(5) - (5)].val));
7037  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ripper_intern("::"), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7038  }
7039  break;
7040 
7041  case 206:
7042 
7043 /* Line 1806 of yacc.c */
7044 #line 2013 "ripper.y"
7045  {
7046 #if 0
7047  (yyval.val) = NEW_COLON2((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
7048  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7049 #endif
7050  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
7051  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
7052 
7053  }
7054  break;
7055 
7056  case 207:
7057 
7058 /* Line 1806 of yacc.c */
7059 #line 2023 "ripper.y"
7060  {
7061 #if 0
7062  (yyval.val) = NEW_COLON3((yyvsp[(2) - (4)].val));
7063  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
7064 #endif
7065  (yyval.val) = dispatch1(top_const_field, (yyvsp[(2) - (4)].val));
7066  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
7067 
7068  }
7069  break;
7070 
7071  case 208:
7072 
7073 /* Line 1806 of yacc.c */
7074 #line 2033 "ripper.y"
7075  {
7076 #if 0
7077  rb_backref_error((yyvsp[(1) - (3)].val));
7078  (yyval.val) = NEW_BEGIN(0);
7079 #endif
7080  (yyval.val) = dispatch1(var_field, (yyvsp[(1) - (3)].val));
7081  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
7082  (yyval.val) = dispatch1(assign_error, (yyval.val));
7083 
7084  }
7085  break;
7086 
7087  case 209:
7088 
7089 /* Line 1806 of yacc.c */
7090 #line 2044 "ripper.y"
7091  {
7092 #if 0
7093  value_expr((yyvsp[(1) - (3)].val));
7094  value_expr((yyvsp[(3) - (3)].val));
7095  (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7096  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7097  nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7098  deferred_nodes = list_append(deferred_nodes, (yyval.val));
7099  }
7100 #endif
7101  (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7102 
7103  }
7104  break;
7105 
7106  case 210:
7107 
7108 /* Line 1806 of yacc.c */
7109 #line 2058 "ripper.y"
7110  {
7111 #if 0
7112  value_expr((yyvsp[(1) - (3)].val));
7113  value_expr((yyvsp[(3) - (3)].val));
7114  (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7115  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(1) - (3)].val)->nd_lit) &&
7116  nd_type((yyvsp[(3) - (3)].val)) == NODE_LIT && FIXNUM_P((yyvsp[(3) - (3)].val)->nd_lit)) {
7117  deferred_nodes = list_append(deferred_nodes, (yyval.val));
7118  }
7119 #endif
7120  (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7121 
7122  }
7123  break;
7124 
7125  case 211:
7126 
7127 /* Line 1806 of yacc.c */
7128 #line 2072 "ripper.y"
7129  {
7130 #if 0
7131  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
7132 #endif
7133  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('+'), (yyvsp[(3) - (3)].val));
7134 
7135  }
7136  break;
7137 
7138  case 212:
7139 
7140 /* Line 1806 of yacc.c */
7141 #line 2080 "ripper.y"
7142  {
7143 #if 0
7144  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
7145 #endif
7146  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('-'), (yyvsp[(3) - (3)].val));
7147 
7148  }
7149  break;
7150 
7151  case 213:
7152 
7153 /* Line 1806 of yacc.c */
7154 #line 2088 "ripper.y"
7155  {
7156 #if 0
7157  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
7158 #endif
7159  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('*'), (yyvsp[(3) - (3)].val));
7160 
7161  }
7162  break;
7163 
7164  case 214:
7165 
7166 /* Line 1806 of yacc.c */
7167 #line 2096 "ripper.y"
7168  {
7169 #if 0
7170  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
7171 #endif
7172  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('/'), (yyvsp[(3) - (3)].val));
7173 
7174  }
7175  break;
7176 
7177  case 215:
7178 
7179 /* Line 1806 of yacc.c */
7180 #line 2104 "ripper.y"
7181  {
7182 #if 0
7183  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
7184 #endif
7185  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('%'), (yyvsp[(3) - (3)].val));
7186 
7187  }
7188  break;
7189 
7190  case 216:
7191 
7192 /* Line 1806 of yacc.c */
7193 #line 2112 "ripper.y"
7194  {
7195 #if 0
7196  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
7197 #endif
7198  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("**"), (yyvsp[(3) - (3)].val));
7199 
7200  }
7201  break;
7202 
7203  case 217:
7204 
7205 /* Line 1806 of yacc.c */
7206 #line 2120 "ripper.y"
7207  {
7208 #if 0
7209  (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
7210 #endif
7211  (yyval.val) = dispatch3(binary, (yyvsp[(2) - (4)].val), ripper_intern("**"), (yyvsp[(4) - (4)].val));
7212  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyval.val));
7213 
7214  }
7215  break;
7216 
7217  case 218:
7218 
7219 /* Line 1806 of yacc.c */
7220 #line 2129 "ripper.y"
7221  {
7222 #if 0
7223  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
7224 #endif
7225  (yyval.val) = dispatch2(unary, ripper_intern("+@"), (yyvsp[(2) - (2)].val));
7226 
7227  }
7228  break;
7229 
7230  case 219:
7231 
7232 /* Line 1806 of yacc.c */
7233 #line 2137 "ripper.y"
7234  {
7235 #if 0
7236  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
7237 #endif
7238  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
7239 
7240  }
7241  break;
7242 
7243  case 220:
7244 
7245 /* Line 1806 of yacc.c */
7246 #line 2145 "ripper.y"
7247  {
7248 #if 0
7249  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val));
7250 #endif
7251  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('|'), (yyvsp[(3) - (3)].val));
7252 
7253  }
7254  break;
7255 
7256  case 221:
7257 
7258 /* Line 1806 of yacc.c */
7259 #line 2153 "ripper.y"
7260  {
7261 #if 0
7262  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
7263 #endif
7264  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('^'), (yyvsp[(3) - (3)].val));
7265 
7266  }
7267  break;
7268 
7269  case 222:
7270 
7271 /* Line 1806 of yacc.c */
7272 #line 2161 "ripper.y"
7273  {
7274 #if 0
7275  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
7276 #endif
7277  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('&'), (yyvsp[(3) - (3)].val));
7278 
7279  }
7280  break;
7281 
7282  case 223:
7283 
7284 /* Line 1806 of yacc.c */
7285 #line 2169 "ripper.y"
7286  {
7287 #if 0
7288  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
7289 #endif
7290  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<=>"), (yyvsp[(3) - (3)].val));
7291 
7292  }
7293  break;
7294 
7295  case 224:
7296 
7297 /* Line 1806 of yacc.c */
7298 #line 2177 "ripper.y"
7299  {
7300 #if 0
7301  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
7302 #endif
7303  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('>'), (yyvsp[(3) - (3)].val));
7304 
7305  }
7306  break;
7307 
7308  case 225:
7309 
7310 /* Line 1806 of yacc.c */
7311 #line 2185 "ripper.y"
7312  {
7313 #if 0
7314  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
7315 #endif
7316  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">="), (yyvsp[(3) - (3)].val));
7317 
7318  }
7319  break;
7320 
7321  case 226:
7322 
7323 /* Line 1806 of yacc.c */
7324 #line 2193 "ripper.y"
7325  {
7326 #if 0
7327  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
7328 #endif
7329  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ID2SYM('<'), (yyvsp[(3) - (3)].val));
7330 
7331  }
7332  break;
7333 
7334  case 227:
7335 
7336 /* Line 1806 of yacc.c */
7337 #line 2201 "ripper.y"
7338  {
7339 #if 0
7340  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
7341 #endif
7342  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<="), (yyvsp[(3) - (3)].val));
7343 
7344  }
7345  break;
7346 
7347  case 228:
7348 
7349 /* Line 1806 of yacc.c */
7350 #line 2209 "ripper.y"
7351  {
7352 #if 0
7353  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
7354 #endif
7355  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=="), (yyvsp[(3) - (3)].val));
7356 
7357  }
7358  break;
7359 
7360  case 229:
7361 
7362 /* Line 1806 of yacc.c */
7363 #line 2217 "ripper.y"
7364  {
7365 #if 0
7366  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
7367 #endif
7368  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("==="), (yyvsp[(3) - (3)].val));
7369 
7370  }
7371  break;
7372 
7373  case 230:
7374 
7375 /* Line 1806 of yacc.c */
7376 #line 2225 "ripper.y"
7377  {
7378 #if 0
7379  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
7380 #endif
7381  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!="), (yyvsp[(3) - (3)].val));
7382 
7383  }
7384  break;
7385 
7386  case 231:
7387 
7388 /* Line 1806 of yacc.c */
7389 #line 2233 "ripper.y"
7390  {
7391 #if 0
7392  (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7393  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_LIT && RB_TYPE_P((yyvsp[(1) - (3)].val)->nd_lit, T_REGEXP)) {
7394  (yyval.val) = reg_named_capture_assign((yyvsp[(1) - (3)].val)->nd_lit, (yyval.val));
7395  }
7396 #endif
7397  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("=~"), (yyvsp[(3) - (3)].val));
7398 
7399  }
7400  break;
7401 
7402  case 232:
7403 
7404 /* Line 1806 of yacc.c */
7405 #line 2244 "ripper.y"
7406  {
7407 #if 0
7408  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val));
7409 #endif
7410  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("!~"), (yyvsp[(3) - (3)].val));
7411 
7412  }
7413  break;
7414 
7415  case 233:
7416 
7417 /* Line 1806 of yacc.c */
7418 #line 2252 "ripper.y"
7419  {
7420 #if 0
7421  (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
7422 #endif
7423  (yyval.val) = dispatch2(unary, ID2SYM('!'), (yyvsp[(2) - (2)].val));
7424 
7425  }
7426  break;
7427 
7428  case 234:
7429 
7430 /* Line 1806 of yacc.c */
7431 #line 2260 "ripper.y"
7432  {
7433 #if 0
7434  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
7435 #endif
7436  (yyval.val) = dispatch2(unary, ID2SYM('~'), (yyvsp[(2) - (2)].val));
7437 
7438  }
7439  break;
7440 
7441  case 235:
7442 
7443 /* Line 1806 of yacc.c */
7444 #line 2268 "ripper.y"
7445  {
7446 #if 0
7447  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val));
7448 #endif
7449  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("<<"), (yyvsp[(3) - (3)].val));
7450 
7451  }
7452  break;
7453 
7454  case 236:
7455 
7456 /* Line 1806 of yacc.c */
7457 #line 2276 "ripper.y"
7458  {
7459 #if 0
7460  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val));
7461 #endif
7462  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern(">>"), (yyvsp[(3) - (3)].val));
7463 
7464  }
7465  break;
7466 
7467  case 237:
7468 
7469 /* Line 1806 of yacc.c */
7470 #line 2284 "ripper.y"
7471  {
7472 #if 0
7473  (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7474 #endif
7475  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("&&"), (yyvsp[(3) - (3)].val));
7476 
7477  }
7478  break;
7479 
7480  case 238:
7481 
7482 /* Line 1806 of yacc.c */
7483 #line 2292 "ripper.y"
7484  {
7485 #if 0
7486  (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7487 #endif
7488  (yyval.val) = dispatch3(binary, (yyvsp[(1) - (3)].val), ripper_intern("||"), (yyvsp[(3) - (3)].val));
7489 
7490  }
7491  break;
7492 
7493  case 239:
7494 
7495 /* Line 1806 of yacc.c */
7496 #line 2299 "ripper.y"
7497  {in_defined = 1;}
7498  break;
7499 
7500  case 240:
7501 
7502 /* Line 1806 of yacc.c */
7503 #line 2300 "ripper.y"
7504  {
7505 #if 0
7506  in_defined = 0;
7507  (yyval.val) = new_defined((yyvsp[(4) - (4)].val));
7508 #endif
7509  in_defined = 0;
7510  (yyval.val) = dispatch1(defined, (yyvsp[(4) - (4)].val));
7511 
7512  }
7513  break;
7514 
7515  case 241:
7516 
7517 /* Line 1806 of yacc.c */
7518 #line 2310 "ripper.y"
7519  {
7520 #if 0
7521  value_expr((yyvsp[(1) - (6)].val));
7522  (yyval.val) = NEW_IF(cond((yyvsp[(1) - (6)].val)), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7523  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
7524 #endif
7525  (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7526 
7527  }
7528  break;
7529 
7530  case 242:
7531 
7532 /* Line 1806 of yacc.c */
7533 #line 2320 "ripper.y"
7534  {
7535  (yyval.val) = (yyvsp[(1) - (1)].val);
7536  }
7537  break;
7538 
7539  case 243:
7540 
7541 /* Line 1806 of yacc.c */
7542 #line 2326 "ripper.y"
7543  {
7544 #if 0
7545  value_expr((yyvsp[(1) - (1)].val));
7546  (yyval.val) = (yyvsp[(1) - (1)].val);
7547  if (!(yyval.val)) (yyval.val) = NEW_NIL();
7548 #endif
7549  (yyval.val) = (yyvsp[(1) - (1)].val);
7550 
7551  }
7552  break;
7553 
7554  case 245:
7555 
7556 /* Line 1806 of yacc.c */
7557 #line 2339 "ripper.y"
7558  {
7559  (yyval.val) = (yyvsp[(1) - (2)].val);
7560  }
7561  break;
7562 
7563  case 246:
7564 
7565 /* Line 1806 of yacc.c */
7566 #line 2343 "ripper.y"
7567  {
7568 #if 0
7569  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7570 #endif
7571  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7572 
7573  }
7574  break;
7575 
7576  case 247:
7577 
7578 /* Line 1806 of yacc.c */
7579 #line 2351 "ripper.y"
7580  {
7581 #if 0
7582  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7583 #endif
7584  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7585 
7586  }
7587  break;
7588 
7589  case 248:
7590 
7591 /* Line 1806 of yacc.c */
7592 #line 2361 "ripper.y"
7593  {
7594 #if 0
7595  (yyval.val) = (yyvsp[(2) - (3)].val);
7596 #endif
7597  (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
7598 
7599  }
7600  break;
7601 
7602  case 253:
7603 
7604 /* Line 1806 of yacc.c */
7605 #line 2377 "ripper.y"
7606  {
7607  (yyval.val) = (yyvsp[(1) - (2)].val);
7608  }
7609  break;
7610 
7611  case 254:
7612 
7613 /* Line 1806 of yacc.c */
7614 #line 2381 "ripper.y"
7615  {
7616 #if 0
7617  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7618 #endif
7619  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7620 
7621  }
7622  break;
7623 
7624  case 255:
7625 
7626 /* Line 1806 of yacc.c */
7627 #line 2389 "ripper.y"
7628  {
7629 #if 0
7630  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7631 #endif
7632  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7633 
7634  }
7635  break;
7636 
7637  case 256:
7638 
7639 /* Line 1806 of yacc.c */
7640 #line 2399 "ripper.y"
7641  {
7642 #if 0
7643  value_expr((yyvsp[(1) - (1)].val));
7644  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7645 #endif
7646  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7647 
7648  }
7649  break;
7650 
7651  case 257:
7652 
7653 /* Line 1806 of yacc.c */
7654 #line 2408 "ripper.y"
7655  {
7656 #if 0
7657  (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7658 #endif
7659  (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7660 
7661  }
7662  break;
7663 
7664  case 258:
7665 
7666 /* Line 1806 of yacc.c */
7667 #line 2416 "ripper.y"
7668  {
7669 #if 0
7670  (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7671  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
7672 #endif
7673  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7674  (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
7675 
7676  }
7677  break;
7678 
7679  case 259:
7680 
7681 /* Line 1806 of yacc.c */
7682 #line 2426 "ripper.y"
7683  {
7684 #if 0
7685  (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7686  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
7687 #endif
7688  (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
7689 
7690  }
7691  break;
7692 
7693  case 260:
7694 
7695 /* Line 1806 of yacc.c */
7696 #line 2437 "ripper.y"
7697  {
7698  (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
7699  }
7700  break;
7701 
7702  case 261:
7703 
7704 /* Line 1806 of yacc.c */
7705 #line 2443 "ripper.y"
7706  {
7707  (yyval.val) = cmdarg_stack;
7708  CMDARG_PUSH(1);
7709  }
7710  break;
7711 
7712  case 262:
7713 
7714 /* Line 1806 of yacc.c */
7715 #line 2448 "ripper.y"
7716  {
7717  /* CMDARG_POP() */
7718  cmdarg_stack = (yyvsp[(1) - (2)].val);
7719  (yyval.val) = (yyvsp[(2) - (2)].val);
7720  }
7721  break;
7722 
7723  case 263:
7724 
7725 /* Line 1806 of yacc.c */
7726 #line 2456 "ripper.y"
7727  {
7728 #if 0
7729  (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
7730 #endif
7731  (yyval.val) = (yyvsp[(2) - (2)].val);
7732 
7733  }
7734  break;
7735 
7736  case 264:
7737 
7738 /* Line 1806 of yacc.c */
7739 #line 2466 "ripper.y"
7740  {
7741  (yyval.val) = (yyvsp[(2) - (2)].val);
7742  }
7743  break;
7744 
7745  case 265:
7746 
7747 /* Line 1806 of yacc.c */
7748 #line 2470 "ripper.y"
7749  {
7750  (yyval.val) = 0;
7751  }
7752  break;
7753 
7754  case 266:
7755 
7756 /* Line 1806 of yacc.c */
7757 #line 2476 "ripper.y"
7758  {
7759 #if 0
7760  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7761 #endif
7762  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7763 
7764  }
7765  break;
7766 
7767  case 267:
7768 
7769 /* Line 1806 of yacc.c */
7770 #line 2484 "ripper.y"
7771  {
7772 #if 0
7773  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7774 #endif
7775  (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
7776 
7777  }
7778  break;
7779 
7780  case 268:
7781 
7782 /* Line 1806 of yacc.c */
7783 #line 2492 "ripper.y"
7784  {
7785 #if 0
7786  NODE *n1;
7787  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7788  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7789  }
7790  else {
7791  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7792  }
7793 #endif
7794  (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7795 
7796  }
7797  break;
7798 
7799  case 269:
7800 
7801 /* Line 1806 of yacc.c */
7802 #line 2506 "ripper.y"
7803  {
7804 #if 0
7805  NODE *n1;
7806  if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7807  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7808  }
7809  else {
7810  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7811  }
7812 #endif
7813  (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7814 
7815  }
7816  break;
7817 
7818  case 272:
7819 
7820 /* Line 1806 of yacc.c */
7821 #line 2526 "ripper.y"
7822  {
7823 #if 0
7824  NODE *n1;
7825  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7826  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val));
7827  }
7828  else {
7829  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7830  }
7831 #endif
7832  (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
7833 
7834  }
7835  break;
7836 
7837  case 273:
7838 
7839 /* Line 1806 of yacc.c */
7840 #line 2540 "ripper.y"
7841  {
7842 #if 0
7843  NODE *n1;
7844  if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
7845  (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7846  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7847  }
7848  else {
7849  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7850  }
7851 #endif
7852  (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
7853 
7854  }
7855  break;
7856 
7857  case 274:
7858 
7859 /* Line 1806 of yacc.c */
7860 #line 2555 "ripper.y"
7861  {
7862 #if 0
7863  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7864 #endif
7865  (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
7866 
7867  }
7868  break;
7869 
7870  case 285:
7871 
7872 /* Line 1806 of yacc.c */
7873 #line 2575 "ripper.y"
7874  {
7875 #if 0
7876  (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
7877 #endif
7878  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
7879 
7880  }
7881  break;
7882 
7883  case 286:
7884 
7885 /* Line 1806 of yacc.c */
7886 #line 2583 "ripper.y"
7887  {
7888  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7889  cmdarg_stack = 0;
7890 #if 0
7891  (yyval.num) = ruby_sourceline;
7892 #endif
7893 
7894  }
7895  break;
7896 
7897  case 287:
7898 
7899 /* Line 1806 of yacc.c */
7900 #line 2593 "ripper.y"
7901  {
7902  cmdarg_stack = (yyvsp[(1) - (4)].val);
7903 #if 0
7904  if ((yyvsp[(3) - (4)].val) == NULL) {
7905  (yyval.val) = NEW_NIL();
7906  }
7907  else {
7908  if (nd_type((yyvsp[(3) - (4)].val)) == NODE_RESCUE ||
7909  nd_type((yyvsp[(3) - (4)].val)) == NODE_ENSURE)
7910  nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
7911  (yyval.val) = NEW_BEGIN((yyvsp[(3) - (4)].val));
7912  }
7913  nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
7914 #endif
7915  (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
7916 
7917  }
7918  break;
7919 
7920  case 288:
7921 
7922 /* Line 1806 of yacc.c */
7923 #line 2610 "ripper.y"
7924  {lex_state = EXPR_ENDARG;}
7925  break;
7926 
7927  case 289:
7928 
7929 /* Line 1806 of yacc.c */
7930 #line 2611 "ripper.y"
7931  {
7932 #if 0
7933  (yyval.val) = 0;
7934 #endif
7935  (yyval.val) = dispatch1(paren, 0);
7936 
7937  }
7938  break;
7939 
7940  case 290:
7941 
7942 /* Line 1806 of yacc.c */
7943 #line 2619 "ripper.y"
7944  {
7945  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7946  cmdarg_stack = 0;
7947  }
7948  break;
7949 
7950  case 291:
7951 
7952 /* Line 1806 of yacc.c */
7953 #line 2623 "ripper.y"
7954  {lex_state = EXPR_ENDARG;}
7955  break;
7956 
7957  case 292:
7958 
7959 /* Line 1806 of yacc.c */
7960 #line 2624 "ripper.y"
7961  {
7962  cmdarg_stack = (yyvsp[(1) - (5)].val);
7963 #if 0
7964  (yyval.val) = (yyvsp[(3) - (5)].val);
7965 #endif
7966  (yyval.val) = dispatch1(paren, (yyvsp[(3) - (5)].val));
7967 
7968  }
7969  break;
7970 
7971  case 293:
7972 
7973 /* Line 1806 of yacc.c */
7974 #line 2633 "ripper.y"
7975  {
7976 #if 0
7977  (yyval.val) = (yyvsp[(2) - (3)].val);
7978 #endif
7979  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
7980 
7981  }
7982  break;
7983 
7984  case 294:
7985 
7986 /* Line 1806 of yacc.c */
7987 #line 2641 "ripper.y"
7988  {
7989 #if 0
7990  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7991 #endif
7992  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7993 
7994  }
7995  break;
7996 
7997  case 295:
7998 
7999 /* Line 1806 of yacc.c */
8000 #line 2649 "ripper.y"
8001  {
8002 #if 0
8003  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
8004 #endif
8005  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
8006 
8007  }
8008  break;
8009 
8010  case 296:
8011 
8012 /* Line 1806 of yacc.c */
8013 #line 2657 "ripper.y"
8014  {
8015 #if 0
8016  if ((yyvsp[(2) - (3)].val) == 0) {
8017  (yyval.val) = NEW_ZARRAY(); /* zero length array*/
8018  }
8019  else {
8020  (yyval.val) = (yyvsp[(2) - (3)].val);
8021  }
8022 #endif
8023  (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
8024 
8025  }
8026  break;
8027 
8028  case 297:
8029 
8030 /* Line 1806 of yacc.c */
8031 #line 2670 "ripper.y"
8032  {
8033 #if 0
8034  (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
8035 #endif
8036  (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
8037 
8038  }
8039  break;
8040 
8041  case 298:
8042 
8043 /* Line 1806 of yacc.c */
8044 #line 2678 "ripper.y"
8045  {
8046 #if 0
8047  (yyval.val) = NEW_RETURN(0);
8048 #endif
8049  (yyval.val) = dispatch0(return0);
8050 
8051  }
8052  break;
8053 
8054  case 299:
8055 
8056 /* Line 1806 of yacc.c */
8057 #line 2686 "ripper.y"
8058  {
8059 #if 0
8060  (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
8061 #endif
8062  (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
8063 
8064  }
8065  break;
8066 
8067  case 300:
8068 
8069 /* Line 1806 of yacc.c */
8070 #line 2694 "ripper.y"
8071  {
8072 #if 0
8073  (yyval.val) = NEW_YIELD(0);
8074 #endif
8075  (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
8076 
8077  }
8078  break;
8079 
8080  case 301:
8081 
8082 /* Line 1806 of yacc.c */
8083 #line 2702 "ripper.y"
8084  {
8085 #if 0
8086  (yyval.val) = NEW_YIELD(0);
8087 #endif
8088  (yyval.val) = dispatch0(yield0);
8089 
8090  }
8091  break;
8092 
8093  case 302:
8094 
8095 /* Line 1806 of yacc.c */
8096 #line 2709 "ripper.y"
8097  {in_defined = 1;}
8098  break;
8099 
8100  case 303:
8101 
8102 /* Line 1806 of yacc.c */
8103 #line 2710 "ripper.y"
8104  {
8105 #if 0
8106  in_defined = 0;
8107  (yyval.val) = new_defined((yyvsp[(5) - (6)].val));
8108 #endif
8109  in_defined = 0;
8110  (yyval.val) = dispatch1(defined, (yyvsp[(5) - (6)].val));
8111 
8112  }
8113  break;
8114 
8115  case 304:
8116 
8117 /* Line 1806 of yacc.c */
8118 #line 2720 "ripper.y"
8119  {
8120 #if 0
8121  (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
8122 #endif
8123  (yyval.val) = dispatch2(unary, ripper_intern("not"), (yyvsp[(3) - (4)].val));
8124 
8125  }
8126  break;
8127 
8128  case 305:
8129 
8130 /* Line 1806 of yacc.c */
8131 #line 2728 "ripper.y"
8132  {
8133 #if 0
8134  (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
8135 #endif
8136  (yyval.val) = dispatch2(unary, ripper_intern("not"), Qnil);
8137 
8138  }
8139  break;
8140 
8141  case 306:
8142 
8143 /* Line 1806 of yacc.c */
8144 #line 2736 "ripper.y"
8145  {
8146 #if 0
8147  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
8148  (yyval.val) = (yyvsp[(2) - (2)].val);
8149 #endif
8150  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
8151  (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
8152 
8153  }
8154  break;
8155 
8156  case 308:
8157 
8158 /* Line 1806 of yacc.c */
8159 #line 2747 "ripper.y"
8160  {
8161 #if 0
8162  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
8163  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
8164  (yyval.val) = (yyvsp[(2) - (2)].val);
8165 #endif
8166  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
8167 
8168  }
8169  break;
8170 
8171  case 309:
8172 
8173 /* Line 1806 of yacc.c */
8174 #line 2757 "ripper.y"
8175  {
8176  (yyval.val) = (yyvsp[(2) - (2)].val);
8177  }
8178  break;
8179 
8180  case 310:
8181 
8182 /* Line 1806 of yacc.c */
8183 #line 2764 "ripper.y"
8184  {
8185 #if 0
8186  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8187  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8188 #endif
8189  (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8190 
8191  }
8192  break;
8193 
8194  case 311:
8195 
8196 /* Line 1806 of yacc.c */
8197 #line 2776 "ripper.y"
8198  {
8199 #if 0
8200  (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8201  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
8202 #endif
8203  (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
8204 
8205  }
8206  break;
8207 
8208  case 312:
8209 
8210 /* Line 1806 of yacc.c */
8211 #line 2784 "ripper.y"
8212  {COND_PUSH(1);}
8213  break;
8214 
8215  case 313:
8216 
8217 /* Line 1806 of yacc.c */
8218 #line 2784 "ripper.y"
8219  {COND_POP();}
8220  break;
8221 
8222  case 314:
8223 
8224 /* Line 1806 of yacc.c */
8225 #line 2787 "ripper.y"
8226  {
8227 #if 0
8228  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8229  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8230 #endif
8231  (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8232 
8233  }
8234  break;
8235 
8236  case 315:
8237 
8238 /* Line 1806 of yacc.c */
8239 #line 2795 "ripper.y"
8240  {COND_PUSH(1);}
8241  break;
8242 
8243  case 316:
8244 
8245 /* Line 1806 of yacc.c */
8246 #line 2795 "ripper.y"
8247  {COND_POP();}
8248  break;
8249 
8250  case 317:
8251 
8252 /* Line 1806 of yacc.c */
8253 #line 2798 "ripper.y"
8254  {
8255 #if 0
8256  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
8257  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8258 #endif
8259  (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8260 
8261  }
8262  break;
8263 
8264  case 318:
8265 
8266 /* Line 1806 of yacc.c */
8267 #line 2809 "ripper.y"
8268  {
8269 #if 0
8270  (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8271  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8272 #endif
8273  (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8274 
8275  }
8276  break;
8277 
8278  case 319:
8279 
8280 /* Line 1806 of yacc.c */
8281 #line 2818 "ripper.y"
8282  {
8283 #if 0
8284  (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
8285 #endif
8286  (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
8287 
8288  }
8289  break;
8290 
8291  case 320:
8292 
8293 /* Line 1806 of yacc.c */
8294 #line 2826 "ripper.y"
8295  {COND_PUSH(1);}
8296  break;
8297 
8298  case 321:
8299 
8300 /* Line 1806 of yacc.c */
8301 #line 2828 "ripper.y"
8302  {COND_POP();}
8303  break;
8304 
8305  case 322:
8306 
8307 /* Line 1806 of yacc.c */
8308 #line 2831 "ripper.y"
8309  {
8310 #if 0
8311  /*
8312  * for a, b, c in e
8313  * #=>
8314  * e.each{|*x| a, b, c = x
8315  *
8316  * for a in e
8317  * #=>
8318  * e.each{|x| a, = x}
8319  */
8320  ID id = internal_id();
8321  ID *tbl = ALLOC_N(ID, 2);
8322  NODE *m = NEW_ARGS_AUX(0, 0);
8323  NODE *args, *scope;
8324 
8325  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_MASGN) {
8326  /* if args.length == 1 && args[0].kind_of?(Array)
8327  * args = args[0]
8328  * end
8329  */
8330  NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
8331  NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
8332  m->nd_next = block_append(
8333  NEW_IF(
8334  NEW_NODE(NODE_AND,
8335  NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
8336  idEq, one),
8337  NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero),
8338  rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
8339  0),
8340  NEW_DASGN_CURR(id,
8341  NEW_CALL(NEW_DVAR(id), idAREF, zero)),
8342  0),
8343  node_assign((yyvsp[(2) - (9)].val), NEW_DVAR(id)));
8344 
8345  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8346  }
8347  else {
8348  if (nd_type((yyvsp[(2) - (9)].val)) == NODE_LASGN ||
8349  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN ||
8350  nd_type((yyvsp[(2) - (9)].val)) == NODE_DASGN_CURR) {
8351  (yyvsp[(2) - (9)].val)->nd_value = NEW_DVAR(id);
8352  m->nd_plen = 1;
8353  m->nd_next = (yyvsp[(2) - (9)].val);
8354  args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
8355  }
8356  else {
8357  m->nd_next = node_assign(NEW_MASGN(NEW_LIST((yyvsp[(2) - (9)].val)), 0), NEW_DVAR(id));
8358  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
8359  }
8360  }
8361  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
8362  tbl[0] = 1; tbl[1] = id;
8363  (yyval.val) = NEW_FOR(0, (yyvsp[(5) - (9)].val), scope);
8364  fixpos((yyval.val), (yyvsp[(2) - (9)].val));
8365 #endif
8366  (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
8367 
8368  }
8369  break;
8370 
8371  case 323:
8372 
8373 /* Line 1806 of yacc.c */
8374 #line 2892 "ripper.y"
8375  {
8376  if (in_def || in_single)
8377  yyerror("class definition in method body");
8378  local_push(0);
8379 #if 0
8380  (yyval.num) = ruby_sourceline;
8381 #endif
8382 
8383  }
8384  break;
8385 
8386  case 324:
8387 
8388 /* Line 1806 of yacc.c */
8389 #line 2903 "ripper.y"
8390  {
8391 #if 0
8392  (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
8393  nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
8394 #endif
8395  (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
8396 
8397  local_pop();
8398  }
8399  break;
8400 
8401  case 325:
8402 
8403 /* Line 1806 of yacc.c */
8404 #line 2913 "ripper.y"
8405  {
8406  (yyval.num) = in_def;
8407  in_def = 0;
8408  }
8409  break;
8410 
8411  case 326:
8412 
8413 /* Line 1806 of yacc.c */
8414 #line 2918 "ripper.y"
8415  {
8416  (yyval.num) = in_single;
8417  in_single = 0;
8418  local_push(0);
8419  }
8420  break;
8421 
8422  case 327:
8423 
8424 /* Line 1806 of yacc.c */
8425 #line 2925 "ripper.y"
8426  {
8427 #if 0
8428  (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8429  fixpos((yyval.val), (yyvsp[(3) - (8)].val));
8430 #endif
8431  (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8432 
8433  local_pop();
8434  in_def = (yyvsp[(4) - (8)].num);
8435  in_single = (yyvsp[(6) - (8)].num);
8436  }
8437  break;
8438 
8439  case 328:
8440 
8441 /* Line 1806 of yacc.c */
8442 #line 2937 "ripper.y"
8443  {
8444  if (in_def || in_single)
8445  yyerror("module definition in method body");
8446  local_push(0);
8447 #if 0
8448  (yyval.num) = ruby_sourceline;
8449 #endif
8450 
8451  }
8452  break;
8453 
8454  case 329:
8455 
8456 /* Line 1806 of yacc.c */
8457 #line 2948 "ripper.y"
8458  {
8459 #if 0
8460  (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8461  nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
8462 #endif
8463  (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8464 
8465  local_pop();
8466  }
8467  break;
8468 
8469  case 330:
8470 
8471 /* Line 1806 of yacc.c */
8472 #line 2958 "ripper.y"
8473  {
8474  (yyval.id) = cur_mid;
8475  cur_mid = (yyvsp[(2) - (2)].val);
8476  in_def++;
8477  local_push(0);
8478  }
8479  break;
8480 
8481  case 331:
8482 
8483 /* Line 1806 of yacc.c */
8484 #line 2967 "ripper.y"
8485  {
8486 #if 0
8487  NODE *body = remove_begin((yyvsp[(5) - (6)].val));
8488  reduce_nodes(&body);
8489  (yyval.val) = NEW_DEFN((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), body, NOEX_PRIVATE);
8490  nd_set_line((yyval.val), (yyvsp[(1) - (6)].num));
8491 #endif
8492  (yyval.val) = dispatch3(def, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
8493 
8494  local_pop();
8495  in_def--;
8496  cur_mid = (yyvsp[(3) - (6)].id);
8497  }
8498  break;
8499 
8500  case 332:
8501 
8502 /* Line 1806 of yacc.c */
8503 #line 2980 "ripper.y"
8504  {lex_state = EXPR_FNAME;}
8505  break;
8506 
8507  case 333:
8508 
8509 /* Line 1806 of yacc.c */
8510 #line 2981 "ripper.y"
8511  {
8512  in_single++;
8513  lex_state = EXPR_ENDFN; /* force for args */
8514  local_push(0);
8515  }
8516  break;
8517 
8518  case 334:
8519 
8520 /* Line 1806 of yacc.c */
8521 #line 2989 "ripper.y"
8522  {
8523 #if 0
8524  NODE *body = remove_begin((yyvsp[(8) - (9)].val));
8525  reduce_nodes(&body);
8526  (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
8527  nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
8528 #endif
8529  (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
8530 
8531  local_pop();
8532  in_single--;
8533  }
8534  break;
8535 
8536  case 335:
8537 
8538 /* Line 1806 of yacc.c */
8539 #line 3002 "ripper.y"
8540  {
8541 #if 0
8542  (yyval.val) = NEW_BREAK(0);
8543 #endif
8544  (yyval.val) = dispatch1(break, arg_new());
8545 
8546  }
8547  break;
8548 
8549  case 336:
8550 
8551 /* Line 1806 of yacc.c */
8552 #line 3010 "ripper.y"
8553  {
8554 #if 0
8555  (yyval.val) = NEW_NEXT(0);
8556 #endif
8557  (yyval.val) = dispatch1(next, arg_new());
8558 
8559  }
8560  break;
8561 
8562  case 337:
8563 
8564 /* Line 1806 of yacc.c */
8565 #line 3018 "ripper.y"
8566  {
8567 #if 0
8568  (yyval.val) = NEW_REDO();
8569 #endif
8570  (yyval.val) = dispatch0(redo);
8571 
8572  }
8573  break;
8574 
8575  case 338:
8576 
8577 /* Line 1806 of yacc.c */
8578 #line 3026 "ripper.y"
8579  {
8580 #if 0
8581  (yyval.val) = NEW_RETRY();
8582 #endif
8583  (yyval.val) = dispatch0(retry);
8584 
8585  }
8586  break;
8587 
8588  case 339:
8589 
8590 /* Line 1806 of yacc.c */
8591 #line 3036 "ripper.y"
8592  {
8593 #if 0
8594  value_expr((yyvsp[(1) - (1)].val));
8595  (yyval.val) = (yyvsp[(1) - (1)].val);
8596  if (!(yyval.val)) (yyval.val) = NEW_NIL();
8597 #endif
8598  (yyval.val) = (yyvsp[(1) - (1)].val);
8599 
8600  }
8601  break;
8602 
8603  case 340:
8604 
8605 /* Line 1806 of yacc.c */
8606 #line 3048 "ripper.y"
8607  {
8608  token_info_push("begin");
8609  }
8610  break;
8611 
8612  case 341:
8613 
8614 /* Line 1806 of yacc.c */
8615 #line 3054 "ripper.y"
8616  {
8617  token_info_push("if");
8618  }
8619  break;
8620 
8621  case 342:
8622 
8623 /* Line 1806 of yacc.c */
8624 #line 3060 "ripper.y"
8625  {
8626  token_info_push("unless");
8627  }
8628  break;
8629 
8630  case 343:
8631 
8632 /* Line 1806 of yacc.c */
8633 #line 3066 "ripper.y"
8634  {
8635  token_info_push("while");
8636  }
8637  break;
8638 
8639  case 344:
8640 
8641 /* Line 1806 of yacc.c */
8642 #line 3072 "ripper.y"
8643  {
8644  token_info_push("until");
8645  }
8646  break;
8647 
8648  case 345:
8649 
8650 /* Line 1806 of yacc.c */
8651 #line 3078 "ripper.y"
8652  {
8653  token_info_push("case");
8654  }
8655  break;
8656 
8657  case 346:
8658 
8659 /* Line 1806 of yacc.c */
8660 #line 3084 "ripper.y"
8661  {
8662  token_info_push("for");
8663  }
8664  break;
8665 
8666  case 347:
8667 
8668 /* Line 1806 of yacc.c */
8669 #line 3090 "ripper.y"
8670  {
8671  token_info_push("class");
8672  }
8673  break;
8674 
8675  case 348:
8676 
8677 /* Line 1806 of yacc.c */
8678 #line 3096 "ripper.y"
8679  {
8680  token_info_push("module");
8681  }
8682  break;
8683 
8684  case 349:
8685 
8686 /* Line 1806 of yacc.c */
8687 #line 3102 "ripper.y"
8688  {
8689  token_info_push("def");
8690 #if 0
8691  (yyval.num) = ruby_sourceline;
8692 #endif
8693 
8694  }
8695  break;
8696 
8697  case 350:
8698 
8699 /* Line 1806 of yacc.c */
8700 #line 3112 "ripper.y"
8701  {
8702  token_info_pop("end");
8703  }
8704  break;
8705 
8706  case 351:
8707 
8708 /* Line 1806 of yacc.c */
8709 #line 3120 "ripper.y"
8710  { (yyval.val) = Qnil; }
8711  break;
8712 
8713  case 353:
8714 
8715 /* Line 1806 of yacc.c */
8716 #line 3126 "ripper.y"
8717  { (yyval.val) = (yyvsp[(2) - (2)].val); }
8718  break;
8719 
8720  case 354:
8721 
8722 /* Line 1806 of yacc.c */
8723 #line 3133 "ripper.y"
8724  { (yyval.val) = Qnil; }
8725  break;
8726 
8727  case 357:
8728 
8729 /* Line 1806 of yacc.c */
8730 #line 3142 "ripper.y"
8731  {
8732 #if 0
8733  (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
8734  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8735 #endif
8736  (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
8737 
8738  }
8739  break;
8740 
8741  case 359:
8742 
8743 /* Line 1806 of yacc.c */
8744 #line 3154 "ripper.y"
8745  {
8746 #if 0
8747  (yyval.val) = (yyvsp[(2) - (2)].val);
8748 #endif
8749  (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
8750 
8751  }
8752  break;
8753 
8754  case 362:
8755 
8756 /* Line 1806 of yacc.c */
8757 #line 3168 "ripper.y"
8758  {
8759  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
8760 #if 0
8761 #endif
8762  (yyval.val) = dispatch1(mlhs_paren, (yyval.val));
8763 
8764  }
8765  break;
8766 
8767  case 363:
8768 
8769 /* Line 1806 of yacc.c */
8770 #line 3176 "ripper.y"
8771  {
8772 #if 0
8773  (yyval.val) = (yyvsp[(2) - (3)].val);
8774 #endif
8775  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
8776 
8777  }
8778  break;
8779 
8780  case 364:
8781 
8782 /* Line 1806 of yacc.c */
8783 #line 3186 "ripper.y"
8784  {
8785 #if 0
8786  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
8787 #endif
8788  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
8789 
8790  }
8791  break;
8792 
8793  case 365:
8794 
8795 /* Line 1806 of yacc.c */
8796 #line 3194 "ripper.y"
8797  {
8798 #if 0
8799  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8800 #endif
8801  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8802 
8803  }
8804  break;
8805 
8806  case 366:
8807 
8808 /* Line 1806 of yacc.c */
8809 #line 3204 "ripper.y"
8810  {
8811 #if 0
8812  (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
8813 #endif
8814  (yyval.val) = (yyvsp[(1) - (1)].val);
8815 
8816  }
8817  break;
8818 
8819  case 367:
8820 
8821 /* Line 1806 of yacc.c */
8822 #line 3212 "ripper.y"
8823  {
8824  (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
8825 #if 0
8826  (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), (yyval.val));
8827 #endif
8828  (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
8829 
8830  }
8831  break;
8832 
8833  case 368:
8834 
8835 /* Line 1806 of yacc.c */
8836 #line 3221 "ripper.y"
8837  {
8838  (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
8839 #if 0
8840  (yyval.val) = NEW_MASGN((yyvsp[(1) - (6)].val), NEW_POSTARG((yyval.val), (yyvsp[(6) - (6)].val)));
8841 #endif
8842  (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
8843 
8844  }
8845  break;
8846 
8847  case 369:
8848 
8849 /* Line 1806 of yacc.c */
8850 #line 3230 "ripper.y"
8851  {
8852 #if 0
8853  (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
8854 #endif
8855  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
8856 
8857  }
8858  break;
8859 
8860  case 370:
8861 
8862 /* Line 1806 of yacc.c */
8863 #line 3238 "ripper.y"
8864  {
8865 #if 0
8866  (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
8867 #endif
8868  (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
8869 
8870  }
8871  break;
8872 
8873  case 371:
8874 
8875 /* Line 1806 of yacc.c */
8876 #line 3246 "ripper.y"
8877  {
8878  (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
8879 #if 0
8880  (yyval.val) = NEW_MASGN(0, (yyval.val));
8881 #endif
8882  (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
8883 
8884  }
8885  break;
8886 
8887  case 372:
8888 
8889 /* Line 1806 of yacc.c */
8890 #line 3255 "ripper.y"
8891  {
8892  (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
8893 #if 0
8894  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyval.val), (yyvsp[(4) - (4)].val)));
8895 #endif
8896  #if 0
8897  TODO: Check me
8898  #endif
8899  (yyval.val) = mlhs_add_star((yyval.val), (yyvsp[(4) - (4)].val));
8900 
8901  }
8902  break;
8903 
8904  case 373:
8905 
8906 /* Line 1806 of yacc.c */
8907 #line 3267 "ripper.y"
8908  {
8909 #if 0
8910  (yyval.val) = NEW_MASGN(0, -1);
8911 #endif
8912  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8913 
8914  }
8915  break;
8916 
8917  case 374:
8918 
8919 /* Line 1806 of yacc.c */
8920 #line 3275 "ripper.y"
8921  {
8922 #if 0
8923  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
8924 #endif
8925  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8926 
8927  }
8928  break;
8929 
8930  case 375:
8931 
8932 /* Line 1806 of yacc.c */
8933 #line 3286 "ripper.y"
8934  {
8935  (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
8936  }
8937  break;
8938 
8939  case 376:
8940 
8941 /* Line 1806 of yacc.c */
8942 #line 3290 "ripper.y"
8943  {
8944  (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
8945  }
8946  break;
8947 
8948  case 377:
8949 
8950 /* Line 1806 of yacc.c */
8951 #line 3294 "ripper.y"
8952  {
8953  (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
8954  }
8955  break;
8956 
8957  case 378:
8958 
8959 /* Line 1806 of yacc.c */
8960 #line 3298 "ripper.y"
8961  {
8962  (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
8963  }
8964  break;
8965 
8966  case 379:
8967 
8968 /* Line 1806 of yacc.c */
8969 #line 3304 "ripper.y"
8970  {
8971  (yyval.val) = (yyvsp[(2) - (2)].val);
8972  }
8973  break;
8974 
8975  case 380:
8976 
8977 /* Line 1806 of yacc.c */
8978 #line 3308 "ripper.y"
8979  {
8980  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
8981  }
8982  break;
8983 
8984  case 381:
8985 
8986 /* Line 1806 of yacc.c */
8987 #line 3314 "ripper.y"
8988  {
8989  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
8990  }
8991  break;
8992 
8993  case 382:
8994 
8995 /* Line 1806 of yacc.c */
8996 #line 3318 "ripper.y"
8997  {
8998  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
8999  }
9000  break;
9001 
9002  case 383:
9003 
9004 /* Line 1806 of yacc.c */
9005 #line 3322 "ripper.y"
9006  {
9007  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
9008  }
9009  break;
9010 
9011  case 384:
9012 
9013 /* Line 1806 of yacc.c */
9014 #line 3326 "ripper.y"
9015  {
9016  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9017  }
9018  break;
9019 
9020  case 385:
9021 
9022 /* Line 1806 of yacc.c */
9023 #line 3330 "ripper.y"
9024  {
9025  (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
9026  }
9027  break;
9028 
9029  case 386:
9030 
9031 /* Line 1806 of yacc.c */
9032 #line 3334 "ripper.y"
9033  {
9034  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
9035 #if 0
9036 #endif
9037  dispatch1(excessed_comma, (yyval.val));
9038 
9039  }
9040  break;
9041 
9042  case 387:
9043 
9044 /* Line 1806 of yacc.c */
9045 #line 3342 "ripper.y"
9046  {
9047  (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9048  }
9049  break;
9050 
9051  case 388:
9052 
9053 /* Line 1806 of yacc.c */
9054 #line 3346 "ripper.y"
9055  {
9056  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
9057  }
9058  break;
9059 
9060  case 389:
9061 
9062 /* Line 1806 of yacc.c */
9063 #line 3350 "ripper.y"
9064  {
9065  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
9066  }
9067  break;
9068 
9069  case 390:
9070 
9071 /* Line 1806 of yacc.c */
9072 #line 3354 "ripper.y"
9073  {
9074  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9075  }
9076  break;
9077 
9078  case 391:
9079 
9080 /* Line 1806 of yacc.c */
9081 #line 3358 "ripper.y"
9082  {
9083  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
9084  }
9085  break;
9086 
9087  case 392:
9088 
9089 /* Line 1806 of yacc.c */
9090 #line 3362 "ripper.y"
9091  {
9092  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9093  }
9094  break;
9095 
9096  case 393:
9097 
9098 /* Line 1806 of yacc.c */
9099 #line 3366 "ripper.y"
9100  {
9101  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
9102  }
9103  break;
9104 
9105  case 394:
9106 
9107 /* Line 1806 of yacc.c */
9108 #line 3370 "ripper.y"
9109  {
9110  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9111  }
9112  break;
9113 
9114  case 395:
9115 
9116 /* Line 1806 of yacc.c */
9117 #line 3374 "ripper.y"
9118  {
9119  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
9120  }
9121  break;
9122 
9123  case 397:
9124 
9125 /* Line 1806 of yacc.c */
9126 #line 3381 "ripper.y"
9127  {
9128  command_start = TRUE;
9129  }
9130  break;
9131 
9132  case 398:
9133 
9134 /* Line 1806 of yacc.c */
9135 #line 3387 "ripper.y"
9136  {
9137 #if 0
9138  (yyval.val) = 0;
9139 #endif
9140  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9141  escape_Qundef((yyvsp[(2) - (3)].val)));
9142 
9143  }
9144  break;
9145 
9146  case 399:
9147 
9148 /* Line 1806 of yacc.c */
9149 #line 3396 "ripper.y"
9150  {
9151 #if 0
9152  (yyval.val) = 0;
9153 #endif
9154  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
9155  Qnil);
9156 
9157  }
9158  break;
9159 
9160  case 400:
9161 
9162 /* Line 1806 of yacc.c */
9163 #line 3405 "ripper.y"
9164  {
9165 #if 0
9166  (yyval.val) = (yyvsp[(2) - (4)].val);
9167 #endif
9168  (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
9169 
9170  }
9171  break;
9172 
9173  case 401:
9174 
9175 /* Line 1806 of yacc.c */
9176 #line 3416 "ripper.y"
9177  {
9178  (yyval.val) = 0;
9179  }
9180  break;
9181 
9182  case 402:
9183 
9184 /* Line 1806 of yacc.c */
9185 #line 3420 "ripper.y"
9186  {
9187 #if 0
9188  (yyval.val) = 0;
9189 #endif
9190  (yyval.val) = (yyvsp[(3) - (4)].val);
9191 
9192  }
9193  break;
9194 
9195  case 403:
9196 
9197 /* Line 1806 of yacc.c */
9198 #line 3432 "ripper.y"
9199  {
9200  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9201  }
9202  break;
9203 
9204  case 404:
9205 
9206 /* Line 1806 of yacc.c */
9207 #line 3439 "ripper.y"
9208  {
9209  rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
9210  }
9211  break;
9212 
9213  case 405:
9214 
9215 /* Line 1806 of yacc.c */
9216 #line 3446 "ripper.y"
9217  {
9218  new_bv(get_id((yyvsp[(1) - (1)].val)));
9219 #if 0
9220 #endif
9221  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
9222 
9223  }
9224  break;
9225 
9226  case 406:
9227 
9228 /* Line 1806 of yacc.c */
9229 #line 3454 "ripper.y"
9230  {
9231  (yyval.val) = 0;
9232  }
9233  break;
9234 
9235  case 407:
9236 
9237 /* Line 1806 of yacc.c */
9238 #line 3459 "ripper.y"
9239  {
9240  (yyval.vars) = dyna_push();
9241  }
9242  break;
9243 
9244  case 408:
9245 
9246 /* Line 1806 of yacc.c */
9247 #line 3462 "ripper.y"
9248  {
9249  (yyval.num) = lpar_beg;
9250  lpar_beg = ++paren_nest;
9251  }
9252  break;
9253 
9254  case 409:
9255 
9256 /* Line 1806 of yacc.c */
9257 #line 3467 "ripper.y"
9258  {
9259  (yyval.num) = ruby_sourceline;
9260  }
9261  break;
9262 
9263  case 410:
9264 
9265 /* Line 1806 of yacc.c */
9266 #line 3471 "ripper.y"
9267  {
9268  lpar_beg = (yyvsp[(2) - (5)].num);
9269 #if 0
9270  (yyval.val) = NEW_LAMBDA((yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9271  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9272 #endif
9273  (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9274 
9275  dyna_pop((yyvsp[(1) - (5)].vars));
9276  }
9277  break;
9278 
9279  case 411:
9280 
9281 /* Line 1806 of yacc.c */
9282 #line 3484 "ripper.y"
9283  {
9284 #if 0
9285  (yyval.val) = (yyvsp[(2) - (4)].val);
9286 #endif
9287  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
9288 
9289  }
9290  break;
9291 
9292  case 412:
9293 
9294 /* Line 1806 of yacc.c */
9295 #line 3492 "ripper.y"
9296  {
9297  (yyval.val) = (yyvsp[(1) - (1)].val);
9298  }
9299  break;
9300 
9301  case 413:
9302 
9303 /* Line 1806 of yacc.c */
9304 #line 3498 "ripper.y"
9305  {
9306  (yyval.val) = (yyvsp[(2) - (3)].val);
9307  }
9308  break;
9309 
9310  case 414:
9311 
9312 /* Line 1806 of yacc.c */
9313 #line 3502 "ripper.y"
9314  {
9315  (yyval.val) = (yyvsp[(2) - (3)].val);
9316  }
9317  break;
9318 
9319  case 415:
9320 
9321 /* Line 1806 of yacc.c */
9322 #line 3508 "ripper.y"
9323  {
9324  (yyvsp[(1) - (1)].vars) = dyna_push();
9325 #if 0
9326  (yyval.num) = ruby_sourceline;
9327 #endif
9328  }
9329  break;
9330 
9331  case 416:
9332 
9333 /* Line 1806 of yacc.c */
9334 #line 3517 "ripper.y"
9335  {
9336 #if 0
9337  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9338  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9339 #endif
9340  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9341 
9342  dyna_pop((yyvsp[(1) - (5)].vars));
9343  }
9344  break;
9345 
9346  case 417:
9347 
9348 /* Line 1806 of yacc.c */
9349 #line 3529 "ripper.y"
9350  {
9351 #if 0
9352  if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
9353  compile_error(PARSER_ARG "block given to yield");
9354  }
9355  else {
9356  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
9357  }
9358  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
9359  (yyval.val) = (yyvsp[(2) - (2)].val);
9360  fixpos((yyval.val), (yyvsp[(1) - (2)].val));
9361 #endif
9362  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9363 
9364  }
9365  break;
9366 
9367  case 418:
9368 
9369 /* Line 1806 of yacc.c */
9370 #line 3545 "ripper.y"
9371  {
9372 #if 0
9373  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9374 #endif
9375  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val));
9376  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9377 
9378  }
9379  break;
9380 
9381  case 419:
9382 
9383 /* Line 1806 of yacc.c */
9384 #line 3554 "ripper.y"
9385  {
9386 #if 0
9387  block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9388  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9389  (yyval.val) = (yyvsp[(5) - (5)].val);
9390  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
9391 #endif
9392  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9393  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
9394 
9395  }
9396  break;
9397 
9398  case 420:
9399 
9400 /* Line 1806 of yacc.c */
9401 #line 3566 "ripper.y"
9402  {
9403 #if 0
9404  block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9405  (yyvsp[(5) - (5)].val)->nd_iter = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9406  (yyval.val) = (yyvsp[(5) - (5)].val);
9407  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
9408 #endif
9409  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
9410  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
9411 
9412  }
9413  break;
9414 
9415  case 421:
9416 
9417 /* Line 1806 of yacc.c */
9418 #line 3580 "ripper.y"
9419  {
9420 #if 0
9421  (yyval.val) = (yyvsp[(1) - (2)].val);
9422  (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
9423 #endif
9424  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
9425 
9426  }
9427  break;
9428 
9429  case 422:
9430 
9431 /* Line 1806 of yacc.c */
9432 #line 3589 "ripper.y"
9433  {
9434 #if 0
9435  (yyval.num) = ruby_sourceline;
9436 #endif
9437  }
9438  break;
9439 
9440  case 423:
9441 
9442 /* Line 1806 of yacc.c */
9443 #line 3595 "ripper.y"
9444  {
9445 #if 0
9446  (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9447  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9448 #endif
9449  (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
9450  (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
9451 
9452  }
9453  break;
9454 
9455  case 424:
9456 
9457 /* Line 1806 of yacc.c */
9458 #line 3605 "ripper.y"
9459  {
9460 #if 0
9461  (yyval.num) = ruby_sourceline;
9462 #endif
9463  }
9464  break;
9465 
9466  case 425:
9467 
9468 /* Line 1806 of yacc.c */
9469 #line 3611 "ripper.y"
9470  {
9471 #if 0
9472  (yyval.val) = NEW_CALL((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val));
9473  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9474 #endif
9475  (yyval.val) = dispatch3(call, (yyvsp[(1) - (5)].val), ripper_id2sym('.'), (yyvsp[(3) - (5)].val));
9476  (yyval.val) = method_optarg((yyval.val), (yyvsp[(5) - (5)].val));
9477 
9478  }
9479  break;
9480 
9481  case 426:
9482 
9483 /* Line 1806 of yacc.c */
9484 #line 3621 "ripper.y"
9485  {
9486 #if 0
9487  (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
9488 #endif
9489  (yyval.val) = dispatch3(call, (yyvsp[(1) - (3)].val), ripper_intern("::"), (yyvsp[(3) - (3)].val));
9490 
9491  }
9492  break;
9493 
9494  case 427:
9495 
9496 /* Line 1806 of yacc.c */
9497 #line 3629 "ripper.y"
9498  {
9499 #if 0
9500  (yyval.num) = ruby_sourceline;
9501 #endif
9502  }
9503  break;
9504 
9505  case 428:
9506 
9507 /* Line 1806 of yacc.c */
9508 #line 3635 "ripper.y"
9509  {
9510 #if 0
9511  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
9512  nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
9513 #endif
9514  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_id2sym('.'),
9515  ripper_intern("call"));
9516  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9517 
9518  }
9519  break;
9520 
9521  case 429:
9522 
9523 /* Line 1806 of yacc.c */
9524 #line 3646 "ripper.y"
9525  {
9526 #if 0
9527  (yyval.num) = ruby_sourceline;
9528 #endif
9529  }
9530  break;
9531 
9532  case 430:
9533 
9534 /* Line 1806 of yacc.c */
9535 #line 3652 "ripper.y"
9536  {
9537 #if 0
9538  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), rb_intern("call"), (yyvsp[(4) - (4)].val));
9539  nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
9540 #endif
9541  (yyval.val) = dispatch3(call, (yyvsp[(1) - (4)].val), ripper_intern("::"),
9542  ripper_intern("call"));
9543  (yyval.val) = method_optarg((yyval.val), (yyvsp[(4) - (4)].val));
9544 
9545  }
9546  break;
9547 
9548  case 431:
9549 
9550 /* Line 1806 of yacc.c */
9551 #line 3663 "ripper.y"
9552  {
9553 #if 0
9554  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
9555 #endif
9556  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
9557 
9558  }
9559  break;
9560 
9561  case 432:
9562 
9563 /* Line 1806 of yacc.c */
9564 #line 3671 "ripper.y"
9565  {
9566 #if 0
9567  (yyval.val) = NEW_ZSUPER();
9568 #endif
9569  (yyval.val) = dispatch0(zsuper);
9570 
9571  }
9572  break;
9573 
9574  case 433:
9575 
9576 /* Line 1806 of yacc.c */
9577 #line 3679 "ripper.y"
9578  {
9579 #if 0
9580  if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
9581  (yyval.val) = NEW_FCALL(tAREF, (yyvsp[(3) - (4)].val));
9582  else
9583  (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val));
9584  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
9585 #endif
9586  (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
9587 
9588  }
9589  break;
9590 
9591  case 434:
9592 
9593 /* Line 1806 of yacc.c */
9594 #line 3693 "ripper.y"
9595  {
9596  (yyvsp[(1) - (1)].vars) = dyna_push();
9597 #if 0
9598  (yyval.num) = ruby_sourceline;
9599 #endif
9600 
9601  }
9602  break;
9603 
9604  case 435:
9605 
9606 /* Line 1806 of yacc.c */
9607 #line 3702 "ripper.y"
9608  {
9609 #if 0
9610  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9611  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9612 #endif
9613  (yyval.val) = dispatch2(brace_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9614 
9615  dyna_pop((yyvsp[(1) - (5)].vars));
9616  }
9617  break;
9618 
9619  case 436:
9620 
9621 /* Line 1806 of yacc.c */
9622 #line 3712 "ripper.y"
9623  {
9624  (yyvsp[(1) - (1)].vars) = dyna_push();
9625 #if 0
9626  (yyval.num) = ruby_sourceline;
9627 #endif
9628 
9629  }
9630  break;
9631 
9632  case 437:
9633 
9634 /* Line 1806 of yacc.c */
9635 #line 3721 "ripper.y"
9636  {
9637 #if 0
9638  (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9639  nd_set_line((yyval.val), (yyvsp[(2) - (5)].num));
9640 #endif
9641  (yyval.val) = dispatch2(do_block, escape_Qundef((yyvsp[(3) - (5)].val)), (yyvsp[(4) - (5)].val));
9642 
9643  dyna_pop((yyvsp[(1) - (5)].vars));
9644  }
9645  break;
9646 
9647  case 438:
9648 
9649 /* Line 1806 of yacc.c */
9650 #line 3735 "ripper.y"
9651  {
9652 #if 0
9653  (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9654 #endif
9655  (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
9656 
9657  }
9658  break;
9659 
9660  case 441:
9661 
9662 /* Line 1806 of yacc.c */
9663 #line 3751 "ripper.y"
9664  {
9665 #if 0
9666  if ((yyvsp[(3) - (6)].val)) {
9667  (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), NEW_ERRINFO());
9668  (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
9669  }
9670  (yyval.val) = NEW_RESBODY((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
9671  fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
9672 #endif
9673  (yyval.val) = dispatch4(rescue,
9674  escape_Qundef((yyvsp[(2) - (6)].val)),
9675  escape_Qundef((yyvsp[(3) - (6)].val)),
9676  escape_Qundef((yyvsp[(5) - (6)].val)),
9677  escape_Qundef((yyvsp[(6) - (6)].val)));
9678 
9679  }
9680  break;
9681 
9682  case 443:
9683 
9684 /* Line 1806 of yacc.c */
9685 #line 3771 "ripper.y"
9686  {
9687 #if 0
9688  (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
9689 #endif
9690  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
9691 
9692  }
9693  break;
9694 
9695  case 444:
9696 
9697 /* Line 1806 of yacc.c */
9698 #line 3779 "ripper.y"
9699  {
9700 #if 0
9701  if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
9702 #endif
9703  (yyval.val) = (yyvsp[(1) - (1)].val);
9704 
9705  }
9706  break;
9707 
9708  case 446:
9709 
9710 /* Line 1806 of yacc.c */
9711 #line 3790 "ripper.y"
9712  {
9713  (yyval.val) = (yyvsp[(2) - (2)].val);
9714  }
9715  break;
9716 
9717  case 448:
9718 
9719 /* Line 1806 of yacc.c */
9720 #line 3797 "ripper.y"
9721  {
9722 #if 0
9723  (yyval.val) = (yyvsp[(2) - (2)].val);
9724 #endif
9725  (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
9726 
9727  }
9728  break;
9729 
9730  case 451:
9731 
9732 /* Line 1806 of yacc.c */
9733 #line 3809 "ripper.y"
9734  {
9735 #if 0
9736  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
9737 #endif
9738  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
9739 
9740  }
9741  break;
9742 
9743  case 453:
9744 
9745 /* Line 1806 of yacc.c */
9746 #line 3820 "ripper.y"
9747  {
9748 #if 0
9749  NODE *node = (yyvsp[(1) - (1)].val);
9750  if (!node) {
9751  node = NEW_STR(STR_NEW0());
9752  }
9753  else {
9754  node = evstr2dstr(node);
9755  }
9756  (yyval.val) = node;
9757 #endif
9758  (yyval.val) = (yyvsp[(1) - (1)].val);
9759 
9760  }
9761  break;
9762 
9763  case 456:
9764 
9765 /* Line 1806 of yacc.c */
9766 #line 3839 "ripper.y"
9767  {
9768 #if 0
9769  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9770 #endif
9771  (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9772 
9773  }
9774  break;
9775 
9776  case 457:
9777 
9778 /* Line 1806 of yacc.c */
9779 #line 3849 "ripper.y"
9780  {
9781 #if 0
9782  (yyval.val) = (yyvsp[(2) - (3)].val);
9783 #endif
9784  (yyval.val) = dispatch1(string_literal, (yyvsp[(2) - (3)].val));
9785 
9786  }
9787  break;
9788 
9789  case 458:
9790 
9791 /* Line 1806 of yacc.c */
9792 #line 3859 "ripper.y"
9793  {
9794 #if 0
9795  NODE *node = (yyvsp[(2) - (3)].val);
9796  if (!node) {
9797  node = NEW_XSTR(STR_NEW0());
9798  }
9799  else {
9800  switch (nd_type(node)) {
9801  case NODE_STR:
9802  nd_set_type(node, NODE_XSTR);
9803  break;
9804  case NODE_DSTR:
9805  nd_set_type(node, NODE_DXSTR);
9806  break;
9807  default:
9808  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
9809  break;
9810  }
9811  }
9812  (yyval.val) = node;
9813 #endif
9814  (yyval.val) = dispatch1(xstring_literal, (yyvsp[(2) - (3)].val));
9815 
9816  }
9817  break;
9818 
9819  case 459:
9820 
9821 /* Line 1806 of yacc.c */
9822 #line 3886 "ripper.y"
9823  {
9824 #if 0
9825  int options = (yyvsp[(3) - (3)].val);
9826  NODE *node = (yyvsp[(2) - (3)].val);
9827  NODE *list, *prev;
9828  if (!node) {
9829  node = NEW_LIT(reg_compile(STR_NEW0(), options));
9830  }
9831  else switch (nd_type(node)) {
9832  case NODE_STR:
9833  {
9834  VALUE src = node->nd_lit;
9835  nd_set_type(node, NODE_LIT);
9836  node->nd_lit = reg_compile(src, options);
9837  }
9838  break;
9839  default:
9840  node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
9841  case NODE_DSTR:
9842  if (options & RE_OPTION_ONCE) {
9843  nd_set_type(node, NODE_DREGX_ONCE);
9844  }
9845  else {
9846  nd_set_type(node, NODE_DREGX);
9847  }
9848  node->nd_cflag = options & RE_OPTION_MASK;
9849  if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
9850  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
9851  if (nd_type(list->nd_head) == NODE_STR) {
9852  VALUE tail = list->nd_head->nd_lit;
9853  if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
9854  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
9855  if (!literal_concat0(parser, lit, tail)) {
9856  node = 0;
9857  break;
9858  }
9859  rb_str_resize(tail, 0);
9860  prev->nd_next = list->nd_next;
9861  rb_gc_force_recycle((VALUE)list->nd_head);
9862  rb_gc_force_recycle((VALUE)list);
9863  list = prev;
9864  }
9865  else {
9866  prev = list;
9867  }
9868  }
9869  else {
9870  prev = 0;
9871  }
9872  }
9873  if (!node->nd_next) {
9874  VALUE src = node->nd_lit;
9875  nd_set_type(node, NODE_LIT);
9876  node->nd_lit = reg_compile(src, options);
9877  }
9878  break;
9879  }
9880  (yyval.val) = node;
9881 #endif
9882  (yyval.val) = dispatch2(regexp_literal, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
9883 
9884  }
9885  break;
9886 
9887  case 460:
9888 
9889 /* Line 1806 of yacc.c */
9890 #line 3951 "ripper.y"
9891  {
9892 #if 0
9893  (yyval.val) = NEW_ZARRAY();
9894 #endif
9895  (yyval.val) = dispatch0(words_new);
9896  (yyval.val) = dispatch1(array, (yyval.val));
9897 
9898  }
9899  break;
9900 
9901  case 461:
9902 
9903 /* Line 1806 of yacc.c */
9904 #line 3960 "ripper.y"
9905  {
9906 #if 0
9907  (yyval.val) = (yyvsp[(2) - (3)].val);
9908 #endif
9909  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9910 
9911  }
9912  break;
9913 
9914  case 462:
9915 
9916 /* Line 1806 of yacc.c */
9917 #line 3970 "ripper.y"
9918  {
9919 #if 0
9920  (yyval.val) = 0;
9921 #endif
9922  (yyval.val) = dispatch0(words_new);
9923 
9924  }
9925  break;
9926 
9927  case 463:
9928 
9929 /* Line 1806 of yacc.c */
9930 #line 3978 "ripper.y"
9931  {
9932 #if 0
9933  (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
9934 #endif
9935  (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9936 
9937  }
9938  break;
9939 
9940  case 464:
9941 
9942 /* Line 1806 of yacc.c */
9943 #line 3990 "ripper.y"
9944  {
9945  (yyval.val) = dispatch0(word_new);
9946  (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
9947  }
9948  break;
9949 
9950  case 465:
9951 
9952 /* Line 1806 of yacc.c */
9953 #line 3996 "ripper.y"
9954  {
9955 #if 0
9956  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9957 #endif
9958  (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9959 
9960  }
9961  break;
9962 
9963  case 466:
9964 
9965 /* Line 1806 of yacc.c */
9966 #line 4006 "ripper.y"
9967  {
9968 #if 0
9969  (yyval.val) = NEW_ZARRAY();
9970 #endif
9971  (yyval.val) = dispatch0(symbols_new);
9972  (yyval.val) = dispatch1(array, (yyval.val));
9973 
9974  }
9975  break;
9976 
9977  case 467:
9978 
9979 /* Line 1806 of yacc.c */
9980 #line 4015 "ripper.y"
9981  {
9982 #if 0
9983  (yyval.val) = (yyvsp[(2) - (3)].val);
9984 #endif
9985  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9986 
9987  }
9988  break;
9989 
9990  case 468:
9991 
9992 /* Line 1806 of yacc.c */
9993 #line 4025 "ripper.y"
9994  {
9995 #if 0
9996  (yyval.val) = 0;
9997 #endif
9998  (yyval.val) = dispatch0(symbols_new);
9999 
10000  }
10001  break;
10002 
10003  case 469:
10004 
10005 /* Line 1806 of yacc.c */
10006 #line 4033 "ripper.y"
10007  {
10008 #if 0
10009  (yyvsp[(2) - (3)].val) = evstr2dstr((yyvsp[(2) - (3)].val));
10010  nd_set_type((yyvsp[(2) - (3)].val), NODE_DSYM);
10011  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10012 #endif
10013  (yyval.val) = dispatch2(symbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10014 
10015  }
10016  break;
10017 
10018  case 470:
10019 
10020 /* Line 1806 of yacc.c */
10021 #line 4045 "ripper.y"
10022  {
10023 #if 0
10024  (yyval.val) = NEW_ZARRAY();
10025 #endif
10026  (yyval.val) = dispatch0(qwords_new);
10027  (yyval.val) = dispatch1(array, (yyval.val));
10028 
10029  }
10030  break;
10031 
10032  case 471:
10033 
10034 /* Line 1806 of yacc.c */
10035 #line 4054 "ripper.y"
10036  {
10037 #if 0
10038  (yyval.val) = (yyvsp[(2) - (3)].val);
10039 #endif
10040  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10041 
10042  }
10043  break;
10044 
10045  case 472:
10046 
10047 /* Line 1806 of yacc.c */
10048 #line 4064 "ripper.y"
10049  {
10050 #if 0
10051  (yyval.val) = NEW_ZARRAY();
10052 #endif
10053  (yyval.val) = dispatch0(qsymbols_new);
10054  (yyval.val) = dispatch1(array, (yyval.val));
10055 
10056  }
10057  break;
10058 
10059  case 473:
10060 
10061 /* Line 1806 of yacc.c */
10062 #line 4073 "ripper.y"
10063  {
10064 #if 0
10065  (yyval.val) = (yyvsp[(2) - (3)].val);
10066 #endif
10067  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
10068 
10069  }
10070  break;
10071 
10072  case 474:
10073 
10074 /* Line 1806 of yacc.c */
10075 #line 4083 "ripper.y"
10076  {
10077 #if 0
10078  (yyval.val) = 0;
10079 #endif
10080  (yyval.val) = dispatch0(qwords_new);
10081 
10082  }
10083  break;
10084 
10085  case 475:
10086 
10087 /* Line 1806 of yacc.c */
10088 #line 4091 "ripper.y"
10089  {
10090 #if 0
10091  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10092 #endif
10093  (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10094 
10095  }
10096  break;
10097 
10098  case 476:
10099 
10100 /* Line 1806 of yacc.c */
10101 #line 4101 "ripper.y"
10102  {
10103 #if 0
10104  (yyval.val) = 0;
10105 #endif
10106  (yyval.val) = dispatch0(qsymbols_new);
10107 
10108  }
10109  break;
10110 
10111  case 477:
10112 
10113 /* Line 1806 of yacc.c */
10114 #line 4109 "ripper.y"
10115  {
10116 #if 0
10117  VALUE lit;
10118  lit = (yyvsp[(2) - (3)].val)->nd_lit;
10119  (yyvsp[(2) - (3)].val)->nd_lit = ID2SYM(rb_intern_str(lit));
10120  nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
10121  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10122 #endif
10123  (yyval.val) = dispatch2(qsymbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
10124 
10125  }
10126  break;
10127 
10128  case 478:
10129 
10130 /* Line 1806 of yacc.c */
10131 #line 4123 "ripper.y"
10132  {
10133 #if 0
10134  (yyval.val) = 0;
10135 #endif
10136  (yyval.val) = dispatch0(string_content);
10137 
10138  }
10139  break;
10140 
10141  case 479:
10142 
10143 /* Line 1806 of yacc.c */
10144 #line 4131 "ripper.y"
10145  {
10146 #if 0
10147  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10148 #endif
10149  (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10150 
10151  }
10152  break;
10153 
10154  case 480:
10155 
10156 /* Line 1806 of yacc.c */
10157 #line 4141 "ripper.y"
10158  {
10159 #if 0
10160  (yyval.val) = 0;
10161 #endif
10162  (yyval.val) = dispatch0(xstring_new);
10163 
10164  }
10165  break;
10166 
10167  case 481:
10168 
10169 /* Line 1806 of yacc.c */
10170 #line 4149 "ripper.y"
10171  {
10172 #if 0
10173  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10174 #endif
10175  (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10176 
10177  }
10178  break;
10179 
10180  case 482:
10181 
10182 /* Line 1806 of yacc.c */
10183 #line 4159 "ripper.y"
10184  {
10185 #if 0
10186  (yyval.val) = 0;
10187 #endif
10188  (yyval.val) = dispatch0(regexp_new);
10189 
10190  }
10191  break;
10192 
10193  case 483:
10194 
10195 /* Line 1806 of yacc.c */
10196 #line 4167 "ripper.y"
10197  {
10198 #if 0
10199  NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
10200  if (!head) {
10201  (yyval.val) = tail;
10202  }
10203  else if (!tail) {
10204  (yyval.val) = head;
10205  }
10206  else {
10207  switch (nd_type(head)) {
10208  case NODE_STR:
10209  nd_set_type(head, NODE_DSTR);
10210  break;
10211  case NODE_DSTR:
10212  break;
10213  default:
10214  head = list_append(NEW_DSTR(Qnil), head);
10215  break;
10216  }
10217  (yyval.val) = list_append(head, tail);
10218  }
10219 #endif
10220  (yyval.val) = dispatch2(regexp_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10221 
10222  }
10223  break;
10224 
10225  case 485:
10226 
10227 /* Line 1806 of yacc.c */
10228 #line 4197 "ripper.y"
10229  {
10230  (yyval.node) = lex_strterm;
10231  lex_strterm = 0;
10232  lex_state = EXPR_BEG;
10233  }
10234  break;
10235 
10236  case 486:
10237 
10238 /* Line 1806 of yacc.c */
10239 #line 4203 "ripper.y"
10240  {
10241 #if 0
10242  lex_strterm = (yyvsp[(2) - (3)].node);
10243  (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
10244 #endif
10245  lex_strterm = (yyvsp[(2) - (3)].node);
10246  (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
10247 
10248  }
10249  break;
10250 
10251  case 487:
10252 
10253 /* Line 1806 of yacc.c */
10254 #line 4213 "ripper.y"
10255  {
10256  (yyvsp[(1) - (1)].val) = cond_stack;
10257  (yyval.val) = cmdarg_stack;
10258  cond_stack = 0;
10259  cmdarg_stack = 0;
10260  }
10261  break;
10262 
10263  case 488:
10264 
10265 /* Line 1806 of yacc.c */
10266 #line 4219 "ripper.y"
10267  {
10268  (yyval.node) = lex_strterm;
10269  lex_strterm = 0;
10270  lex_state = EXPR_BEG;
10271  }
10272  break;
10273 
10274  case 489:
10275 
10276 /* Line 1806 of yacc.c */
10277 #line 4224 "ripper.y"
10278  {
10279  (yyval.num) = brace_nest;
10280  brace_nest = 0;
10281  }
10282  break;
10283 
10284  case 490:
10285 
10286 /* Line 1806 of yacc.c */
10287 #line 4229 "ripper.y"
10288  {
10289  cond_stack = (yyvsp[(1) - (6)].val);
10290  cmdarg_stack = (yyvsp[(2) - (6)].val);
10291  lex_strterm = (yyvsp[(3) - (6)].node);
10292  brace_nest = (yyvsp[(4) - (6)].num);
10293 #if 0
10294  if ((yyvsp[(5) - (6)].val)) (yyvsp[(5) - (6)].val)->flags &= ~NODE_FL_NEWLINE;
10295  (yyval.val) = new_evstr((yyvsp[(5) - (6)].val));
10296 #endif
10297  (yyval.val) = dispatch1(string_embexpr, (yyvsp[(5) - (6)].val));
10298 
10299  }
10300  break;
10301 
10302  case 491:
10303 
10304 /* Line 1806 of yacc.c */
10305 #line 4244 "ripper.y"
10306  {
10307 #if 0
10308  (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
10309 #endif
10310  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10311 
10312  }
10313  break;
10314 
10315  case 492:
10316 
10317 /* Line 1806 of yacc.c */
10318 #line 4252 "ripper.y"
10319  {
10320 #if 0
10321  (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
10322 #endif
10323  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10324 
10325  }
10326  break;
10327 
10328  case 493:
10329 
10330 /* Line 1806 of yacc.c */
10331 #line 4260 "ripper.y"
10332  {
10333 #if 0
10334  (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
10335 #endif
10336  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10337 
10338  }
10339  break;
10340 
10341  case 495:
10342 
10343 /* Line 1806 of yacc.c */
10344 #line 4271 "ripper.y"
10345  {
10346  lex_state = EXPR_END;
10347 #if 0
10348  (yyval.val) = (yyvsp[(2) - (2)].val);
10349 #endif
10350  (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
10351 
10352  }
10353  break;
10354 
10355  case 500:
10356 
10357 /* Line 1806 of yacc.c */
10358 #line 4288 "ripper.y"
10359  {
10360  lex_state = EXPR_END;
10361 #if 0
10362  (yyval.val) = dsym_node((yyvsp[(2) - (3)].val));
10363 #endif
10364  (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
10365 
10366  }
10367  break;
10368 
10369  case 502:
10370 
10371 /* Line 1806 of yacc.c */
10372 #line 4300 "ripper.y"
10373  {
10374 #if 0
10375  (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
10376 #endif
10377  (yyval.val) = dispatch2(unary, ripper_intern("-@"), (yyvsp[(2) - (2)].val));
10378 
10379  }
10380  break;
10381 
10382  case 512:
10383 
10384 /* Line 1806 of yacc.c */
10385 #line 4322 "ripper.y"
10386  {ifndef_ripper((yyval.val) = keyword_nil);}
10387  break;
10388 
10389  case 513:
10390 
10391 /* Line 1806 of yacc.c */
10392 #line 4323 "ripper.y"
10393  {ifndef_ripper((yyval.val) = keyword_self);}
10394  break;
10395 
10396  case 514:
10397 
10398 /* Line 1806 of yacc.c */
10399 #line 4324 "ripper.y"
10400  {ifndef_ripper((yyval.val) = keyword_true);}
10401  break;
10402 
10403  case 515:
10404 
10405 /* Line 1806 of yacc.c */
10406 #line 4325 "ripper.y"
10407  {ifndef_ripper((yyval.val) = keyword_false);}
10408  break;
10409 
10410  case 516:
10411 
10412 /* Line 1806 of yacc.c */
10413 #line 4326 "ripper.y"
10414  {ifndef_ripper((yyval.val) = keyword__FILE__);}
10415  break;
10416 
10417  case 517:
10418 
10419 /* Line 1806 of yacc.c */
10420 #line 4327 "ripper.y"
10421  {ifndef_ripper((yyval.val) = keyword__LINE__);}
10422  break;
10423 
10424  case 518:
10425 
10426 /* Line 1806 of yacc.c */
10427 #line 4328 "ripper.y"
10428  {ifndef_ripper((yyval.val) = keyword__ENCODING__);}
10429  break;
10430 
10431  case 519:
10432 
10433 /* Line 1806 of yacc.c */
10434 #line 4332 "ripper.y"
10435  {
10436 #if 0
10437  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10438 #endif
10439  if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) {
10440  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10441  }
10442  else {
10443  (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val));
10444  }
10445 
10446  }
10447  break;
10448 
10449  case 520:
10450 
10451 /* Line 1806 of yacc.c */
10452 #line 4345 "ripper.y"
10453  {
10454 #if 0
10455  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
10456 #endif
10457  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
10458 
10459  }
10460  break;
10461 
10462  case 521:
10463 
10464 /* Line 1806 of yacc.c */
10465 #line 4355 "ripper.y"
10466  {
10467  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10468 #if 0
10469 #endif
10470  (yyval.val) = dispatch1(var_field, (yyval.val));
10471 
10472  }
10473  break;
10474 
10475  case 522:
10476 
10477 /* Line 1806 of yacc.c */
10478 #line 4363 "ripper.y"
10479  {
10480  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10481 #if 0
10482 #endif
10483  (yyval.val) = dispatch1(var_field, (yyval.val));
10484 
10485  }
10486  break;
10487 
10488  case 525:
10489 
10490 /* Line 1806 of yacc.c */
10491 #line 4377 "ripper.y"
10492  {
10493 #if 0
10494  (yyval.val) = 0;
10495 #endif
10496  (yyval.val) = Qnil;
10497 
10498  }
10499  break;
10500 
10501  case 526:
10502 
10503 /* Line 1806 of yacc.c */
10504 #line 4385 "ripper.y"
10505  {
10506  lex_state = EXPR_BEG;
10507  command_start = TRUE;
10508  }
10509  break;
10510 
10511  case 527:
10512 
10513 /* Line 1806 of yacc.c */
10514 #line 4390 "ripper.y"
10515  {
10516  (yyval.val) = (yyvsp[(3) - (4)].val);
10517  }
10518  break;
10519 
10520  case 528:
10521 
10522 /* Line 1806 of yacc.c */
10523 #line 4394 "ripper.y"
10524  {
10525 #if 0
10526  yyerrok;
10527  (yyval.val) = 0;
10528 #endif
10529  yyerrok;
10530  (yyval.val) = Qnil;
10531 
10532  }
10533  break;
10534 
10535  case 529:
10536 
10537 /* Line 1806 of yacc.c */
10538 #line 4406 "ripper.y"
10539  {
10540 #if 0
10541  (yyval.val) = (yyvsp[(2) - (3)].val);
10542 #endif
10543  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
10544 
10545  lex_state = EXPR_BEG;
10546  command_start = TRUE;
10547  }
10548  break;
10549 
10550  case 530:
10551 
10552 /* Line 1806 of yacc.c */
10553 #line 4415 "ripper.y"
10554  {
10555  (yyval.num) = parser->parser_in_kwarg;
10556  parser->parser_in_kwarg = 1;
10557  }
10558  break;
10559 
10560  case 531:
10561 
10562 /* Line 1806 of yacc.c */
10563 #line 4420 "ripper.y"
10564  {
10565  parser->parser_in_kwarg = (yyvsp[(1) - (3)].num);
10566  (yyval.val) = (yyvsp[(2) - (3)].val);
10567  lex_state = EXPR_BEG;
10568  command_start = TRUE;
10569  }
10570  break;
10571 
10572  case 532:
10573 
10574 /* Line 1806 of yacc.c */
10575 #line 4429 "ripper.y"
10576  {
10577  (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10578  }
10579  break;
10580 
10581  case 533:
10582 
10583 /* Line 1806 of yacc.c */
10584 #line 4433 "ripper.y"
10585  {
10586  (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10587  }
10588  break;
10589 
10590  case 534:
10591 
10592 /* Line 1806 of yacc.c */
10593 #line 4437 "ripper.y"
10594  {
10595  (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10596  }
10597  break;
10598 
10599  case 535:
10600 
10601 /* Line 1806 of yacc.c */
10602 #line 4441 "ripper.y"
10603  {
10604  (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val));
10605  }
10606  break;
10607 
10608  case 536:
10609 
10610 /* Line 1806 of yacc.c */
10611 #line 4447 "ripper.y"
10612  {
10613  (yyval.val) = (yyvsp[(2) - (2)].val);
10614  }
10615  break;
10616 
10617  case 537:
10618 
10619 /* Line 1806 of yacc.c */
10620 #line 4451 "ripper.y"
10621  {
10622  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10623  }
10624  break;
10625 
10626  case 538:
10627 
10628 /* Line 1806 of yacc.c */
10629 #line 4457 "ripper.y"
10630  {
10631  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
10632  }
10633  break;
10634 
10635  case 539:
10636 
10637 /* Line 1806 of yacc.c */
10638 #line 4461 "ripper.y"
10639  {
10640  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10641  }
10642  break;
10643 
10644  case 540:
10645 
10646 /* Line 1806 of yacc.c */
10647 #line 4465 "ripper.y"
10648  {
10649  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
10650  }
10651  break;
10652 
10653  case 541:
10654 
10655 /* Line 1806 of yacc.c */
10656 #line 4469 "ripper.y"
10657  {
10658  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10659  }
10660  break;
10661 
10662  case 542:
10663 
10664 /* Line 1806 of yacc.c */
10665 #line 4473 "ripper.y"
10666  {
10667  (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10668  }
10669  break;
10670 
10671  case 543:
10672 
10673 /* Line 1806 of yacc.c */
10674 #line 4477 "ripper.y"
10675  {
10676  (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10677  }
10678  break;
10679 
10680  case 544:
10681 
10682 /* Line 1806 of yacc.c */
10683 #line 4481 "ripper.y"
10684  {
10685  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
10686  }
10687  break;
10688 
10689  case 545:
10690 
10691 /* Line 1806 of yacc.c */
10692 #line 4485 "ripper.y"
10693  {
10694  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10695  }
10696  break;
10697 
10698  case 546:
10699 
10700 /* Line 1806 of yacc.c */
10701 #line 4489 "ripper.y"
10702  {
10703  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10704  }
10705  break;
10706 
10707  case 547:
10708 
10709 /* Line 1806 of yacc.c */
10710 #line 4493 "ripper.y"
10711  {
10712  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
10713  }
10714  break;
10715 
10716  case 548:
10717 
10718 /* Line 1806 of yacc.c */
10719 #line 4497 "ripper.y"
10720  {
10721  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10722  }
10723  break;
10724 
10725  case 549:
10726 
10727 /* Line 1806 of yacc.c */
10728 #line 4501 "ripper.y"
10729  {
10730  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10731  }
10732  break;
10733 
10734  case 550:
10735 
10736 /* Line 1806 of yacc.c */
10737 #line 4505 "ripper.y"
10738  {
10739  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10740  }
10741  break;
10742 
10743  case 551:
10744 
10745 /* Line 1806 of yacc.c */
10746 #line 4509 "ripper.y"
10747  {
10748  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
10749  }
10750  break;
10751 
10752  case 552:
10753 
10754 /* Line 1806 of yacc.c */
10755 #line 4513 "ripper.y"
10756  {
10757  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone);
10758  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.val));
10759  }
10760  break;
10761 
10762  case 553:
10763 
10764 /* Line 1806 of yacc.c */
10765 #line 4520 "ripper.y"
10766  {
10767 #if 0
10768  yyerror("formal argument cannot be a constant");
10769  (yyval.val) = 0;
10770 #endif
10771  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10772 
10773  }
10774  break;
10775 
10776  case 554:
10777 
10778 /* Line 1806 of yacc.c */
10779 #line 4529 "ripper.y"
10780  {
10781 #if 0
10782  yyerror("formal argument cannot be an instance variable");
10783  (yyval.val) = 0;
10784 #endif
10785  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10786 
10787  }
10788  break;
10789 
10790  case 555:
10791 
10792 /* Line 1806 of yacc.c */
10793 #line 4538 "ripper.y"
10794  {
10795 #if 0
10796  yyerror("formal argument cannot be a global variable");
10797  (yyval.val) = 0;
10798 #endif
10799  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10800 
10801  }
10802  break;
10803 
10804  case 556:
10805 
10806 /* Line 1806 of yacc.c */
10807 #line 4547 "ripper.y"
10808  {
10809 #if 0
10810  yyerror("formal argument cannot be a class variable");
10811  (yyval.val) = 0;
10812 #endif
10813  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10814 
10815  }
10816  break;
10817 
10818  case 558:
10819 
10820 /* Line 1806 of yacc.c */
10821 #line 4559 "ripper.y"
10822  {
10823  formal_argument(get_id((yyvsp[(1) - (1)].val)));
10824  (yyval.val) = (yyvsp[(1) - (1)].val);
10825  }
10826  break;
10827 
10828  case 559:
10829 
10830 /* Line 1806 of yacc.c */
10831 #line 4566 "ripper.y"
10832  {
10833  arg_var(get_id((yyvsp[(1) - (1)].val)));
10834 #if 0
10835  (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10836 #endif
10837  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10838 
10839  }
10840  break;
10841 
10842  case 560:
10843 
10844 /* Line 1806 of yacc.c */
10845 #line 4575 "ripper.y"
10846  {
10847  ID tid = internal_id();
10848  arg_var(tid);
10849 #if 0
10850  if (dyna_in_block()) {
10851  (yyvsp[(2) - (3)].val)->nd_value = NEW_DVAR(tid);
10852  }
10853  else {
10854  (yyvsp[(2) - (3)].val)->nd_value = NEW_LVAR(tid);
10855  }
10856  (yyval.val) = NEW_ARGS_AUX(tid, 1);
10857  (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10858 #endif
10859  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10860 
10861  }
10862  break;
10863 
10864  case 561:
10865 
10866 /* Line 1806 of yacc.c */
10867 #line 4596 "ripper.y"
10868  {
10869  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10870  }
10871  break;
10872 
10873  case 562:
10874 
10875 /* Line 1806 of yacc.c */
10876 #line 4601 "ripper.y"
10877  {
10878 #if 0
10879  (yyval.val) = (yyvsp[(1) - (3)].val);
10880  (yyval.val)->nd_plen++;
10881  (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next);
10882  rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10883 #endif
10884  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10885 
10886  }
10887  break;
10888 
10889  case 563:
10890 
10891 /* Line 1806 of yacc.c */
10892 #line 4615 "ripper.y"
10893  {
10894  arg_var(formal_argument(get_id((yyvsp[(1) - (1)].val))));
10895  (yyval.val) = (yyvsp[(1) - (1)].val);
10896  }
10897  break;
10898 
10899  case 564:
10900 
10901 /* Line 1806 of yacc.c */
10902 #line 4622 "ripper.y"
10903  {
10904  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10905 #if 0
10906  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10907 #endif
10908  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10909 
10910  }
10911  break;
10912 
10913  case 565:
10914 
10915 /* Line 1806 of yacc.c */
10916 #line 4631 "ripper.y"
10917  {
10918  (yyval.val) = assignable((yyvsp[(1) - (1)].val), (NODE *)-1);
10919 #if 0
10920  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10921 #endif
10922  (yyval.val) = rb_assoc_new((yyval.val), 0);
10923 
10924  }
10925  break;
10926 
10927  case 566:
10928 
10929 /* Line 1806 of yacc.c */
10930 #line 4642 "ripper.y"
10931  {
10932  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10933 #if 0
10934  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10935 #endif
10936  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(2) - (2)].val));
10937 
10938  }
10939  break;
10940 
10941  case 567:
10942 
10943 /* Line 1806 of yacc.c */
10944 #line 4651 "ripper.y"
10945  {
10946  (yyval.val) = assignable((yyvsp[(1) - (1)].val), (NODE *)-1);
10947 #if 0
10948  (yyval.val) = NEW_KW_ARG(0, (yyval.val));
10949 #endif
10950  (yyval.val) = rb_assoc_new((yyval.val), 0);
10951 
10952  }
10953  break;
10954 
10955  case 568:
10956 
10957 /* Line 1806 of yacc.c */
10958 #line 4662 "ripper.y"
10959  {
10960 #if 0
10961  (yyval.val) = (yyvsp[(1) - (1)].val);
10962 #endif
10963  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10964 
10965  }
10966  break;
10967 
10968  case 569:
10969 
10970 /* Line 1806 of yacc.c */
10971 #line 4670 "ripper.y"
10972  {
10973 #if 0
10974  NODE *kws = (yyvsp[(1) - (3)].val);
10975 
10976  while (kws->nd_next) {
10977  kws = kws->nd_next;
10978  }
10979  kws->nd_next = (yyvsp[(3) - (3)].val);
10980  (yyval.val) = (yyvsp[(1) - (3)].val);
10981 #endif
10982  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10983 
10984  }
10985  break;
10986 
10987  case 570:
10988 
10989 /* Line 1806 of yacc.c */
10990 #line 4687 "ripper.y"
10991  {
10992 #if 0
10993  (yyval.val) = (yyvsp[(1) - (1)].val);
10994 #endif
10995  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10996 
10997  }
10998  break;
10999 
11000  case 571:
11001 
11002 /* Line 1806 of yacc.c */
11003 #line 4695 "ripper.y"
11004  {
11005 #if 0
11006  NODE *kws = (yyvsp[(1) - (3)].val);
11007 
11008  while (kws->nd_next) {
11009  kws = kws->nd_next;
11010  }
11011  kws->nd_next = (yyvsp[(3) - (3)].val);
11012  (yyval.val) = (yyvsp[(1) - (3)].val);
11013 #endif
11014  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11015 
11016  }
11017  break;
11018 
11019  case 574:
11020 
11021 /* Line 1806 of yacc.c */
11022 #line 4715 "ripper.y"
11023  {
11024  shadowing_lvar(get_id((yyvsp[(2) - (2)].val)));
11025  (yyval.val) = (yyvsp[(2) - (2)].val);
11026  }
11027  break;
11028 
11029  case 575:
11030 
11031 /* Line 1806 of yacc.c */
11032 #line 4720 "ripper.y"
11033  {
11034  (yyval.val) = internal_id();
11035  }
11036  break;
11037 
11038  case 576:
11039 
11040 /* Line 1806 of yacc.c */
11041 #line 4726 "ripper.y"
11042  {
11043  arg_var(get_id((yyvsp[(1) - (3)].val)));
11044  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11045 #if 0
11046  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
11047 #endif
11048  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
11049 
11050  }
11051  break;
11052 
11053  case 577:
11054 
11055 /* Line 1806 of yacc.c */
11056 #line 4738 "ripper.y"
11057  {
11058  arg_var(get_id((yyvsp[(1) - (3)].val)));
11059  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11060 #if 0
11061  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
11062 #endif
11063  (yyval.val) = rb_assoc_new((yyval.val), (yyvsp[(3) - (3)].val));
11064 
11065  }
11066  break;
11067 
11068  case 578:
11069 
11070 /* Line 1806 of yacc.c */
11071 #line 4750 "ripper.y"
11072  {
11073 #if 0
11074  (yyval.val) = (yyvsp[(1) - (1)].val);
11075 #endif
11076  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11077 
11078  }
11079  break;
11080 
11081  case 579:
11082 
11083 /* Line 1806 of yacc.c */
11084 #line 4758 "ripper.y"
11085  {
11086 #if 0
11087  NODE *opts = (yyvsp[(1) - (3)].val);
11088 
11089  while (opts->nd_next) {
11090  opts = opts->nd_next;
11091  }
11092  opts->nd_next = (yyvsp[(3) - (3)].val);
11093  (yyval.val) = (yyvsp[(1) - (3)].val);
11094 #endif
11095  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11096 
11097  }
11098  break;
11099 
11100  case 580:
11101 
11102 /* Line 1806 of yacc.c */
11103 #line 4774 "ripper.y"
11104  {
11105 #if 0
11106  (yyval.val) = (yyvsp[(1) - (1)].val);
11107 #endif
11108  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11109 
11110  }
11111  break;
11112 
11113  case 581:
11114 
11115 /* Line 1806 of yacc.c */
11116 #line 4782 "ripper.y"
11117  {
11118 #if 0
11119  NODE *opts = (yyvsp[(1) - (3)].val);
11120 
11121  while (opts->nd_next) {
11122  opts = opts->nd_next;
11123  }
11124  opts->nd_next = (yyvsp[(3) - (3)].val);
11125  (yyval.val) = (yyvsp[(1) - (3)].val);
11126 #endif
11127  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11128 
11129  }
11130  break;
11131 
11132  case 584:
11133 
11134 /* Line 1806 of yacc.c */
11135 #line 4802 "ripper.y"
11136  {
11137 #if 0
11138  if (!is_local_id((yyvsp[(2) - (2)].val)))
11139  yyerror("rest argument must be local variable");
11140 #endif
11141  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11142 #if 0
11143  (yyval.val) = (yyvsp[(2) - (2)].val);
11144 #endif
11145  (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
11146 
11147  }
11148  break;
11149 
11150  case 585:
11151 
11152 /* Line 1806 of yacc.c */
11153 #line 4815 "ripper.y"
11154  {
11155 #if 0
11156  (yyval.val) = internal_id();
11157  arg_var((yyval.val));
11158 #endif
11159  (yyval.val) = dispatch1(rest_param, Qnil);
11160 
11161  }
11162  break;
11163 
11164  case 588:
11165 
11166 /* Line 1806 of yacc.c */
11167 #line 4830 "ripper.y"
11168  {
11169 #if 0
11170  if (!is_local_id((yyvsp[(2) - (2)].val)))
11171  yyerror("block argument must be local variable");
11172  else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
11173  yyerror("duplicated block argument name");
11174 #endif
11175  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
11176 #if 0
11177  (yyval.val) = (yyvsp[(2) - (2)].val);
11178 #endif
11179  (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
11180 
11181  }
11182  break;
11183 
11184  case 589:
11185 
11186 /* Line 1806 of yacc.c */
11187 #line 4847 "ripper.y"
11188  {
11189  (yyval.val) = (yyvsp[(2) - (2)].val);
11190  }
11191  break;
11192 
11193  case 590:
11194 
11195 /* Line 1806 of yacc.c */
11196 #line 4851 "ripper.y"
11197  {
11198 #if 0
11199  (yyval.val) = 0;
11200 #endif
11201  (yyval.val) = Qundef;
11202 
11203  }
11204  break;
11205 
11206  case 591:
11207 
11208 /* Line 1806 of yacc.c */
11209 #line 4861 "ripper.y"
11210  {
11211 #if 0
11212  value_expr((yyvsp[(1) - (1)].val));
11213  (yyval.val) = (yyvsp[(1) - (1)].val);
11214  if (!(yyval.val)) (yyval.val) = NEW_NIL();
11215 #endif
11216  (yyval.val) = (yyvsp[(1) - (1)].val);
11217 
11218  }
11219  break;
11220 
11221  case 592:
11222 
11223 /* Line 1806 of yacc.c */
11224 #line 4870 "ripper.y"
11225  {lex_state = EXPR_BEG;}
11226  break;
11227 
11228  case 593:
11229 
11230 /* Line 1806 of yacc.c */
11231 #line 4871 "ripper.y"
11232  {
11233 #if 0
11234  if ((yyvsp[(3) - (4)].val) == 0) {
11235  yyerror("can't define singleton method for ().");
11236  }
11237  else {
11238  switch (nd_type((yyvsp[(3) - (4)].val))) {
11239  case NODE_STR:
11240  case NODE_DSTR:
11241  case NODE_XSTR:
11242  case NODE_DXSTR:
11243  case NODE_DREGX:
11244  case NODE_LIT:
11245  case NODE_ARRAY:
11246  case NODE_ZARRAY:
11247  yyerror("can't define singleton method for literals");
11248  default:
11249  value_expr((yyvsp[(3) - (4)].val));
11250  break;
11251  }
11252  }
11253  (yyval.val) = (yyvsp[(3) - (4)].val);
11254 #endif
11255  (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
11256 
11257  }
11258  break;
11259 
11260  case 595:
11261 
11262 /* Line 1806 of yacc.c */
11263 #line 4901 "ripper.y"
11264  {
11265 #if 0
11266  (yyval.val) = (yyvsp[(1) - (2)].val);
11267 #endif
11268  (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
11269 
11270  }
11271  break;
11272 
11273  case 596:
11274 
11275 /* Line 1806 of yacc.c */
11276 #line 4913 "ripper.y"
11277  {
11278  (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
11279  }
11280  break;
11281 
11282  case 597:
11283 
11284 /* Line 1806 of yacc.c */
11285 #line 4918 "ripper.y"
11286  {
11287 #if 0
11288  (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11289 #endif
11290  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11291 
11292  }
11293  break;
11294 
11295  case 598:
11296 
11297 /* Line 1806 of yacc.c */
11298 #line 4928 "ripper.y"
11299  {
11300 #if 0
11301  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_STR) {
11302  nd_set_type((yyvsp[(1) - (3)].val), NODE_LIT);
11303  (yyvsp[(1) - (3)].val)->nd_lit = rb_fstring((yyvsp[(1) - (3)].val)->nd_lit);
11304  }
11305  (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
11306 #endif
11307  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
11308 
11309  }
11310  break;
11311 
11312  case 599:
11313 
11314 /* Line 1806 of yacc.c */
11315 #line 4940 "ripper.y"
11316  {
11317 #if 0
11318  (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
11319 #endif
11320  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
11321 
11322  }
11323  break;
11324 
11325  case 600:
11326 
11327 /* Line 1806 of yacc.c */
11328 #line 4948 "ripper.y"
11329  {
11330 #if 0
11331  (yyval.val) = list_append(NEW_LIST(0), (yyvsp[(2) - (2)].val));
11332 #endif
11333  (yyval.val) = dispatch1(assoc_splat, (yyvsp[(2) - (2)].val));
11334 
11335  }
11336  break;
11337 
11338  case 611:
11339 
11340 /* Line 1806 of yacc.c */
11341 #line 4978 "ripper.y"
11342  { (yyval.val) = (yyvsp[(1) - (1)].val); }
11343  break;
11344 
11345  case 612:
11346 
11347 /* Line 1806 of yacc.c */
11348 #line 4983 "ripper.y"
11349  { (yyval.val) = (yyvsp[(1) - (1)].val); }
11350  break;
11351 
11352  case 622:
11353 
11354 /* Line 1806 of yacc.c */
11355 #line 5006 "ripper.y"
11356  {yyerrok;}
11357  break;
11358 
11359  case 625:
11360 
11361 /* Line 1806 of yacc.c */
11362 #line 5011 "ripper.y"
11363  {yyerrok;}
11364  break;
11365 
11366  case 626:
11367 
11368 /* Line 1806 of yacc.c */
11369 #line 5015 "ripper.y"
11370  {
11371 #if 0
11372  (yyval.val) = 0;
11373 #endif
11374  (yyval.val) = Qundef;
11375 
11376  }
11377  break;
11378 
11379 
11380 
11381 /* Line 1806 of yacc.c */
11382 #line 11381 "parse.c"
11383  default: break;
11384  }
11385  /* User semantic actions sometimes alter yychar, and that requires
11386  that yytoken be updated with the new translation. We take the
11387  approach of translating immediately before every use of yytoken.
11388  One alternative is translating here after every semantic action,
11389  but that translation would be missed if the semantic action invokes
11390  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11391  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
11392  incorrect destructor might then be invoked immediately. In the
11393  case of YYERROR or YYBACKUP, subsequent parser actions might lead
11394  to an incorrect destructor call or verbose syntax error message
11395  before the lookahead is translated. */
11396  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11397 
11398  YYPOPSTACK (yylen);
11399  yylen = 0;
11400  YY_STACK_PRINT (yyss, yyssp);
11401 
11402  *++yyvsp = yyval;
11403 
11404  /* Now `shift' the result of the reduction. Determine what state
11405  that goes to, based on the state we popped back to and the rule
11406  number reduced by. */
11407 
11408  yyn = yyr1[yyn];
11409 
11410  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
11411  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
11412  yystate = yytable[yystate];
11413  else
11414  yystate = yydefgoto[yyn - YYNTOKENS];
11415 
11416  goto yynewstate;
11417 
11418 
11419 /*------------------------------------.
11420 | yyerrlab -- here on detecting error |
11421 `------------------------------------*/
11422 yyerrlab:
11423  /* Make sure we have latest lookahead translation. See comments at
11424  user semantic actions for why this is necessary. */
11425  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
11426 
11427  /* If not already recovering from an error, report this error. */
11428  if (!yyerrstatus)
11429  {
11430  ++yynerrs;
11431 #if ! YYERROR_VERBOSE
11432  parser_yyerror (parser, YY_("syntax error"));
11433 #else
11434 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
11435  yyssp, yytoken)
11436  {
11437  char const *yymsgp = YY_("syntax error");
11438  int yysyntax_error_status;
11439  yysyntax_error_status = YYSYNTAX_ERROR;
11440  if (yysyntax_error_status == 0)
11441  yymsgp = yymsg;
11442  else if (yysyntax_error_status == 1)
11443  {
11444  if (yymsg != yymsgbuf)
11445  YYSTACK_FREE (yymsg);
11446  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
11447  if (!yymsg)
11448  {
11449  yymsg = yymsgbuf;
11450  yymsg_alloc = sizeof yymsgbuf;
11451  yysyntax_error_status = 2;
11452  }
11453  else
11454  {
11455  yysyntax_error_status = YYSYNTAX_ERROR;
11456  yymsgp = yymsg;
11457  }
11458  }
11459  parser_yyerror (parser, yymsgp);
11460  if (yysyntax_error_status == 2)
11461  goto yyexhaustedlab;
11462  }
11463 # undef YYSYNTAX_ERROR
11464 #endif
11465  }
11466 
11467 
11468 
11469  if (yyerrstatus == 3)
11470  {
11471  /* If just tried and failed to reuse lookahead token after an
11472  error, discard it. */
11473 
11474  if (yychar <= YYEOF)
11475  {
11476  /* Return failure if at end of input. */
11477  if (yychar == YYEOF)
11478  YYABORT;
11479  }
11480  else
11481  {
11482  yydestruct ("Error: discarding",
11483  yytoken, &yylval, parser);
11484  yychar = YYEMPTY;
11485  }
11486  }
11487 
11488  /* Else will try to reuse lookahead token after shifting the error
11489  token. */
11490  goto yyerrlab1;
11491 
11492 
11493 /*---------------------------------------------------.
11494 | yyerrorlab -- error raised explicitly by YYERROR. |
11495 `---------------------------------------------------*/
11496 yyerrorlab:
11497 
11498  /* Pacify compilers like GCC when the user code never invokes
11499  YYERROR and the label yyerrorlab therefore never appears in user
11500  code. */
11501  if (/*CONSTCOND*/ 0)
11502  goto yyerrorlab;
11503 
11504  /* Do not reclaim the symbols of the rule which action triggered
11505  this YYERROR. */
11506  YYPOPSTACK (yylen);
11507  yylen = 0;
11508  YY_STACK_PRINT (yyss, yyssp);
11509  yystate = *yyssp;
11510  goto yyerrlab1;
11511 
11512 
11513 /*-------------------------------------------------------------.
11514 | yyerrlab1 -- common code for both syntax error and YYERROR. |
11515 `-------------------------------------------------------------*/
11516 yyerrlab1:
11517  yyerrstatus = 3; /* Each real token shifted decrements this. */
11518 
11519  for (;;)
11520  {
11521  yyn = yypact[yystate];
11522  if (!yypact_value_is_default (yyn))
11523  {
11524  yyn += YYTERROR;
11525  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
11526  {
11527  yyn = yytable[yyn];
11528  if (0 < yyn)
11529  break;
11530  }
11531  }
11532 
11533  /* Pop the current state because it cannot handle the error token. */
11534  if (yyssp == yyss)
11535  YYABORT;
11536 
11537 
11538  yydestruct ("Error: popping",
11539  yystos[yystate], yyvsp, parser);
11540  YYPOPSTACK (1);
11541  yystate = *yyssp;
11542  YY_STACK_PRINT (yyss, yyssp);
11543  }
11544 
11545  *++yyvsp = yylval;
11546 
11547 
11548  /* Shift the error token. */
11549  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
11550 
11551  yystate = yyn;
11552  goto yynewstate;
11553 
11554 
11555 /*-------------------------------------.
11556 | yyacceptlab -- YYACCEPT comes here. |
11557 `-------------------------------------*/
11558 yyacceptlab:
11559  yyresult = 0;
11560  goto yyreturn;
11561 
11562 /*-----------------------------------.
11563 | yyabortlab -- YYABORT comes here. |
11564 `-----------------------------------*/
11565 yyabortlab:
11566  yyresult = 1;
11567  goto yyreturn;
11568 
11569 #if !defined(yyoverflow) || YYERROR_VERBOSE
11570 /*-------------------------------------------------.
11571 | yyexhaustedlab -- memory exhaustion comes here. |
11572 `-------------------------------------------------*/
11573 yyexhaustedlab:
11574  parser_yyerror (parser, YY_("memory exhausted"));
11575  yyresult = 2;
11576  /* Fall through. */
11577 #endif
11578 
11579 yyreturn:
11580  if (yychar != YYEMPTY)
11581  {
11582  /* Make sure we have latest lookahead translation. See comments at
11583  user semantic actions for why this is necessary. */
11584  yytoken = YYTRANSLATE (yychar);
11585  yydestruct ("Cleanup: discarding lookahead",
11586  yytoken, &yylval, parser);
11587  }
11588  /* Do not reclaim the symbols of the rule which action triggered
11589  this YYABORT or YYACCEPT. */
11590  YYPOPSTACK (yylen);
11591  YY_STACK_PRINT (yyss, yyssp);
11592  while (yyssp != yyss)
11593  {
11594  yydestruct ("Cleanup: popping",
11595  yystos[*yyssp], yyvsp, parser);
11596  YYPOPSTACK (1);
11597  }
11598 #ifndef yyoverflow
11599  if (yyss != yyssa)
11600  YYSTACK_FREE (yyss);
11601 #endif
11602 #if YYERROR_VERBOSE
11603  if (yymsg != yymsgbuf)
11604  YYSTACK_FREE (yymsg);
11605 #endif
11606  /* Make sure YYID is used. */
11607  return YYID (yyresult);
11608 }
11609 
11610 
11611 
11612 /* Line 2067 of yacc.c */
11613 #line 5023 "ripper.y"
11614 
11615 # undef parser
11616 # undef yylex
11617 # undef yylval
11618 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
11619 
11620 static int parser_regx_options(struct parser_params*);
11621 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
11622 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
11623 static int parser_parse_string(struct parser_params*,NODE*);
11624 static int parser_here_document(struct parser_params*,NODE*);
11625 
11626 
11627 # define nextc() parser_nextc(parser)
11628 # define pushback(c) parser_pushback(parser, (c))
11629 # define newtok() parser_newtok(parser)
11630 # define tokspace(n) parser_tokspace(parser, (n))
11631 # define tokadd(c) parser_tokadd(parser, (c))
11632 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
11633 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
11634 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
11635 # define regx_options() parser_regx_options(parser)
11636 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
11637 # define parse_string(n) parser_parse_string(parser,(n))
11638 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
11639 # define here_document(n) parser_here_document(parser,(n))
11640 # define heredoc_identifier() parser_heredoc_identifier(parser)
11641 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
11642 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
11643 # define number_literal_suffix(f) parser_number_literal_suffix(parser, (f))
11644 # define set_number_literal(v, t, f) parser_set_number_literal(parser, (v), (t), (f))
11645 # define set_integer_literal(v, f) parser_set_integer_literal(parser, (v), (f))
11646 
11647 #ifndef RIPPER
11648 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11649 # define set_yylval_num(x) (yylval.num = (x))
11650 # define set_yylval_id(x) (yylval.id = (x))
11651 # define set_yylval_name(x) (yylval.id = (x))
11652 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11653 # define set_yylval_node(x) (yylval.node = (x))
11654 # define yylval_id() (yylval.id)
11655 #else
11656 static inline VALUE
11657 ripper_yylval_id(ID x)
11658 {
11659  return (VALUE)NEW_LASGN(x, ID2SYM(x));
11660 }
11661 # define set_yylval_str(x) (void)(x)
11662 # define set_yylval_num(x) (void)(x)
11663 # define set_yylval_id(x) (void)(x)
11664 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11665 # define set_yylval_literal(x) (void)(x)
11666 # define set_yylval_node(x) (void)(x)
11667 # define yylval_id() yylval.id
11668 #endif
11669 
11670 #ifndef RIPPER
11671 #define ripper_flush(p) (void)(p)
11672 #else
11673 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
11674 
11675 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11676 
11677 static int
11678 ripper_has_scan_event(struct parser_params *parser)
11679 {
11680 
11681  if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11682  return lex_p > parser->tokp;
11683 }
11684 
11685 static VALUE
11686 ripper_scan_event_val(struct parser_params *parser, int t)
11687 {
11688  VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11689  VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11690  ripper_flush(parser);
11691  return rval;
11692 }
11693 
11694 static void
11695 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11696 {
11697  if (!ripper_has_scan_event(parser)) return;
11698  yylval_rval = ripper_scan_event_val(parser, t);
11699 }
11700 
11701 static void
11702 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
11703 {
11704  if (!ripper_has_scan_event(parser)) return;
11705  (void)ripper_scan_event_val(parser, t);
11706 }
11707 
11708 static void
11709 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11710 {
11711  int saved_line = ruby_sourceline;
11712  const char *saved_tokp = parser->tokp;
11713 
11714  ruby_sourceline = parser->delayed_line;
11715  parser->tokp = lex_pbeg + parser->delayed_col;
11716  yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11717  parser->delayed = Qnil;
11718  ruby_sourceline = saved_line;
11719  parser->tokp = saved_tokp;
11720 }
11721 #endif /* RIPPER */
11722 
11723 #include "ruby/regex.h"
11724 #include "ruby/util.h"
11725 
11726 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
11727  since ours (we hope) works properly with all combinations of
11728  machines, compilers, `char' and `unsigned char' argument types.
11729  (Per Bothner suggested the basic approach.) */
11730 #undef SIGN_EXTEND_CHAR
11731 #if __STDC__
11732 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
11733 #else /* not __STDC__ */
11734 /* As in Harbison and Steele. */
11735 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
11736 #endif
11737 
11738 #define parser_encoding_name() (current_enc->name)
11739 #define parser_mbclen() mbclen((lex_p-1),lex_pend,current_enc)
11740 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
11741 #define is_identchar(p,e,enc) (rb_enc_isalnum((unsigned char)(*(p)),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11742 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11743 
11744 #define parser_isascii() ISASCII(*(lex_p-1))
11745 
11746 #ifndef RIPPER
11747 static int
11748 token_info_get_column(struct parser_params *parser, const char *token)
11749 {
11750  int column = 1;
11751  const char *p, *pend = lex_p - strlen(token);
11752  for (p = lex_pbeg; p < pend; p++) {
11753  if (*p == '\t') {
11754  column = (((column - 1) / 8) + 1) * 8;
11755  }
11756  column++;
11757  }
11758  return column;
11759 }
11760 
11761 static int
11762 token_info_has_nonspaces(struct parser_params *parser, const char *token)
11763 {
11764  const char *p, *pend = lex_p - strlen(token);
11765  for (p = lex_pbeg; p < pend; p++) {
11766  if (*p != ' ' && *p != '\t') {
11767  return 1;
11768  }
11769  }
11770  return 0;
11771 }
11772 
11773 #undef token_info_push
11774 static void
11775 token_info_push(struct parser_params *parser, const char *token)
11776 {
11777  token_info *ptinfo;
11778 
11779  if (!parser->parser_token_info_enabled) return;
11780  ptinfo = ALLOC(token_info);
11781  ptinfo->token = token;
11782  ptinfo->linenum = ruby_sourceline;
11783  ptinfo->column = token_info_get_column(parser, token);
11784  ptinfo->nonspc = token_info_has_nonspaces(parser, token);
11785  ptinfo->next = parser->parser_token_info;
11786 
11787  parser->parser_token_info = ptinfo;
11788 }
11789 
11790 #undef token_info_pop
11791 static void
11792 token_info_pop(struct parser_params *parser, const char *token)
11793 {
11794  int linenum;
11795  token_info *ptinfo = parser->parser_token_info;
11796 
11797  if (!ptinfo) return;
11798  parser->parser_token_info = ptinfo->next;
11799  if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
11800  goto finish;
11801  }
11802  linenum = ruby_sourceline;
11803  if (linenum == ptinfo->linenum) { /* SKIP */
11804  goto finish;
11805  }
11806  if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
11807  goto finish;
11808  }
11809  if (parser->parser_token_info_enabled) {
11810  rb_compile_warn(ruby_sourcefile, linenum,
11811  "mismatched indentations at '%s' with '%s' at %d",
11812  token, ptinfo->token, ptinfo->linenum);
11813  }
11814 
11815  finish:
11816  xfree(ptinfo);
11817 }
11818 #endif /* RIPPER */
11819 
11820 static int
11821 parser_yyerror(struct parser_params *parser, const char *msg)
11822 {
11823 #ifndef RIPPER
11824  const int max_line_margin = 30;
11825  const char *p, *pe;
11826  char *buf;
11827  long len;
11828  int i;
11829 
11830  compile_error(PARSER_ARG "%s", msg);
11831  p = lex_p;
11832  while (lex_pbeg <= p) {
11833  if (*p == '\n') break;
11834  p--;
11835  }
11836  p++;
11837 
11838  pe = lex_p;
11839  while (pe < lex_pend) {
11840  if (*pe == '\n') break;
11841  pe++;
11842  }
11843 
11844  len = pe - p;
11845  if (len > 4) {
11846  char *p2;
11847  const char *pre = "", *post = "";
11848 
11849  if (len > max_line_margin * 2 + 10) {
11850  if (lex_p - p > max_line_margin) {
11851  p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
11852  pre = "...";
11853  }
11854  if (pe - lex_p > max_line_margin) {
11855  pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
11856  post = "...";
11857  }
11858  len = pe - p;
11859  }
11860  buf = ALLOCA_N(char, len+2);
11861  MEMCPY(buf, p, char, len);
11862  buf[len] = '\0';
11863  rb_compile_error_with_enc(NULL, 0, (void *)current_enc, "%s%s%s", pre, buf, post);
11864 
11865  i = (int)(lex_p - p);
11866  p2 = buf; pe = buf + len;
11867 
11868  while (p2 < pe) {
11869  if (*p2 != '\t') *p2 = ' ';
11870  p2++;
11871  }
11872  buf[i] = '^';
11873  buf[i+1] = '\0';
11874  rb_compile_error_append("%s%s", pre, buf);
11875  }
11876 #else
11877  dispatch1(parse_error, STR_NEW2(msg));
11878 #endif /* !RIPPER */
11879  return 0;
11880 }
11881 
11882 static void parser_prepare(struct parser_params *parser);
11883 
11884 #ifndef RIPPER
11885 static VALUE
11886 debug_lines(VALUE fname)
11887 {
11888  ID script_lines;
11889  CONST_ID(script_lines, "SCRIPT_LINES__");
11890  if (rb_const_defined_at(rb_cObject, script_lines)) {
11891  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11892  if (RB_TYPE_P(hash, T_HASH)) {
11893  VALUE lines = rb_ary_new();
11894  rb_hash_aset(hash, fname, lines);
11895  return lines;
11896  }
11897  }
11898  return 0;
11899 }
11900 
11901 static VALUE
11902 coverage(VALUE fname, int n)
11903 {
11904  VALUE coverages = rb_get_coverages();
11905  if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11906  VALUE lines = rb_ary_new2(n);
11907  int i;
11908  RBASIC_CLEAR_CLASS(lines);
11909  for (i = 0; i < n; i++) RARRAY_ASET(lines, i, Qnil);
11910  RARRAY(lines)->as.heap.len = n;
11911  rb_hash_aset(coverages, fname, lines);
11912  return lines;
11913  }
11914  return 0;
11915 }
11916 
11917 static int
11918 e_option_supplied(struct parser_params *parser)
11919 {
11920  return strcmp(ruby_sourcefile, "-e") == 0;
11921 }
11922 
11923 static VALUE
11924 yycompile0(VALUE arg)
11925 {
11926  int n;
11927  NODE *tree;
11928  struct parser_params *parser = (struct parser_params *)arg;
11929 
11930  if (!compile_for_eval && rb_safe_level() == 0) {
11931  ruby_debug_lines = debug_lines(ruby_sourcefile_string);
11932  if (ruby_debug_lines && ruby_sourceline > 0) {
11933  VALUE str = STR_NEW0();
11934  n = ruby_sourceline;
11935  do {
11936  rb_ary_push(ruby_debug_lines, str);
11937  } while (--n);
11938  }
11939 
11940  if (!e_option_supplied(parser)) {
11941  ruby_coverage = coverage(ruby_sourcefile_string, ruby_sourceline);
11942  }
11943  }
11944  parser->last_cr_line = ruby_sourceline - 1;
11945 
11946  parser_prepare(parser);
11947  deferred_nodes = 0;
11948 #ifndef RIPPER
11949  parser->parser_token_info_enabled = !compile_for_eval && RTEST(ruby_verbose);
11950 #endif
11951 #ifndef RIPPER
11952  if (RUBY_DTRACE_PARSE_BEGIN_ENABLED()) {
11953  RUBY_DTRACE_PARSE_BEGIN(parser->parser_ruby_sourcefile,
11954  parser->parser_ruby_sourceline);
11955  }
11956 #endif
11957  n = yyparse((void*)parser);
11958 #ifndef RIPPER
11959  if (RUBY_DTRACE_PARSE_END_ENABLED()) {
11960  RUBY_DTRACE_PARSE_END(parser->parser_ruby_sourcefile,
11961  parser->parser_ruby_sourceline);
11962  }
11963 #endif
11964  ruby_debug_lines = 0;
11965  ruby_coverage = 0;
11966  compile_for_eval = 0;
11967 
11968  lex_strterm = 0;
11969  lex_p = lex_pbeg = lex_pend = 0;
11970  lex_lastline = lex_nextline = 0;
11971  if (parser->nerr) {
11972  return 0;
11973  }
11974  tree = ruby_eval_tree;
11975  if (!tree) {
11976  tree = NEW_NIL();
11977  }
11978  else if (ruby_eval_tree_begin) {
11979  tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
11980  }
11981  return (VALUE)tree;
11982 }
11983 
11984 static NODE*
11985 yycompile(struct parser_params *parser, VALUE fname, int line)
11986 {
11987  ruby_sourcefile_string = rb_str_new_frozen(fname);
11988  ruby_sourcefile = RSTRING_PTR(fname);
11989  ruby_sourceline = line - 1;
11990  return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
11991 }
11992 #endif /* !RIPPER */
11993 
11994 static rb_encoding *
11995 must_be_ascii_compatible(VALUE s)
11996 {
11997  rb_encoding *enc = rb_enc_get(s);
11998  if (!rb_enc_asciicompat(enc)) {
11999  rb_raise(rb_eArgError, "invalid source encoding");
12000  }
12001  return enc;
12002 }
12003 
12004 static VALUE
12005 lex_get_str(struct parser_params *parser, VALUE s)
12006 {
12007  char *beg, *end, *pend;
12008  rb_encoding *enc = must_be_ascii_compatible(s);
12009 
12010  beg = RSTRING_PTR(s);
12011  if (lex_gets_ptr) {
12012  if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
12013  beg += lex_gets_ptr;
12014  }
12015  pend = RSTRING_PTR(s) + RSTRING_LEN(s);
12016  end = beg;
12017  while (end < pend) {
12018  if (*end++ == '\n') break;
12019  }
12020  lex_gets_ptr = end - RSTRING_PTR(s);
12021  return rb_enc_str_new(beg, end - beg, enc);
12022 }
12023 
12024 static VALUE
12025 lex_getline(struct parser_params *parser)
12026 {
12027  VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
12028  if (NIL_P(line)) return line;
12029  must_be_ascii_compatible(line);
12030 #ifndef RIPPER
12031  if (ruby_debug_lines) {
12032  rb_enc_associate(line, current_enc);
12033  rb_ary_push(ruby_debug_lines, line);
12034  }
12035  if (ruby_coverage) {
12036  rb_ary_push(ruby_coverage, Qnil);
12037  }
12038 #endif
12039  return line;
12040 }
12041 
12042 #ifdef RIPPER
12043 static rb_data_type_t parser_data_type;
12044 #else
12045 static const rb_data_type_t parser_data_type;
12046 
12047 static NODE*
12048 parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
12049 {
12050  struct parser_params *parser;
12051  NODE *node;
12052 
12053  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12054  lex_gets = lex_get_str;
12055  lex_gets_ptr = 0;
12056  lex_input = s;
12057  lex_pbeg = lex_p = lex_pend = 0;
12058  compile_for_eval = rb_parse_in_eval();
12059 
12060  node = yycompile(parser, fname, line);
12061  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12062 
12063  return node;
12064 }
12065 
12066 NODE*
12067 rb_compile_string(const char *f, VALUE s, int line)
12068 {
12069  must_be_ascii_compatible(s);
12070  return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), s, line);
12071 }
12072 
12073 NODE*
12074 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
12075 {
12076  return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
12077 }
12078 
12079 NODE*
12080 rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
12081 {
12082  must_be_ascii_compatible(s);
12083  return parser_compile_string(vparser, f, s, line);
12084 }
12085 
12086 NODE*
12087 rb_compile_cstr(const char *f, const char *s, int len, int line)
12088 {
12089  VALUE str = rb_str_new(s, len);
12090  return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), str, line);
12091 }
12092 
12093 NODE*
12094 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
12095 {
12096  VALUE str = rb_str_new(s, len);
12097  return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line);
12098 }
12099 
12100 static VALUE
12101 lex_io_gets(struct parser_params *parser, VALUE io)
12102 {
12103  return rb_io_gets(io);
12104 }
12105 
12106 NODE*
12107 rb_compile_file(const char *f, VALUE file, int start)
12108 {
12109  VALUE volatile vparser = rb_parser_new();
12110 
12111  return rb_parser_compile_file(vparser, f, file, start);
12112 }
12113 
12114 NODE*
12115 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
12116 {
12117  return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start);
12118 }
12119 
12120 NODE*
12121 rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
12122 {
12123  struct parser_params *parser;
12124  NODE *node;
12125 
12126  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
12127  lex_gets = lex_io_gets;
12128  lex_input = file;
12129  lex_pbeg = lex_p = lex_pend = 0;
12130  compile_for_eval = rb_parse_in_eval();
12131 
12132  node = yycompile(parser, fname, start);
12133  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12134 
12135  return node;
12136 }
12137 #endif /* !RIPPER */
12138 
12139 #define STR_FUNC_ESCAPE 0x01
12140 #define STR_FUNC_EXPAND 0x02
12141 #define STR_FUNC_REGEXP 0x04
12142 #define STR_FUNC_QWORDS 0x08
12143 #define STR_FUNC_SYMBOL 0x10
12144 #define STR_FUNC_INDENT 0x20
12145 
12146 enum string_type {
12147  str_squote = (0),
12148  str_dquote = (STR_FUNC_EXPAND),
12149  str_xquote = (STR_FUNC_EXPAND),
12150  str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
12151  str_sword = (STR_FUNC_QWORDS),
12152  str_dword = (STR_FUNC_QWORDS|STR_FUNC_EXPAND),
12153  str_ssym = (STR_FUNC_SYMBOL),
12154  str_dsym = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
12155 };
12156 
12157 static VALUE
12158 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
12159 {
12160  VALUE str;
12161 
12162  str = rb_enc_str_new(p, n, enc);
12163  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12164  if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
12165  }
12166  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12167  rb_enc_associate(str, rb_ascii8bit_encoding());
12168  }
12169  }
12170 
12171  return str;
12172 }
12173 
12174 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
12175 #define lex_eol_p() (lex_p >= lex_pend)
12176 #define peek(c) peek_n((c), 0)
12177 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
12178 
12179 static inline int
12180 parser_nextc(struct parser_params *parser)
12181 {
12182  int c;
12183 
12184  if (lex_p == lex_pend) {
12185  VALUE v = lex_nextline;
12186  lex_nextline = 0;
12187  if (!v) {
12188  if (parser->eofp)
12189  return -1;
12190 
12191  if (!lex_input || NIL_P(v = lex_getline(parser))) {
12192  parser->eofp = Qtrue;
12193  lex_goto_eol(parser);
12194  return -1;
12195  }
12196  }
12197  {
12198 #ifdef RIPPER
12199  if (parser->tokp < lex_pend) {
12200  if (NIL_P(parser->delayed)) {
12201  parser->delayed = rb_str_buf_new(1024);
12202  rb_enc_associate(parser->delayed, current_enc);
12203  rb_str_buf_cat(parser->delayed,
12204  parser->tokp, lex_pend - parser->tokp);
12205  parser->delayed_line = ruby_sourceline;
12206  parser->delayed_col = (int)(parser->tokp - lex_pbeg);
12207  }
12208  else {
12209  rb_str_buf_cat(parser->delayed,
12210  parser->tokp, lex_pend - parser->tokp);
12211  }
12212  }
12213 #endif
12214  if (heredoc_end > 0) {
12215  ruby_sourceline = heredoc_end;
12216  heredoc_end = 0;
12217  }
12218  ruby_sourceline++;
12219  parser->line_count++;
12220  lex_pbeg = lex_p = RSTRING_PTR(v);
12221  lex_pend = lex_p + RSTRING_LEN(v);
12222  ripper_flush(parser);
12223  lex_lastline = v;
12224  }
12225  }
12226  c = (unsigned char)*lex_p++;
12227  if (c == '\r') {
12228  if (peek('\n')) {
12229  lex_p++;
12230  c = '\n';
12231  }
12232  else if (ruby_sourceline > parser->last_cr_line) {
12233  parser->last_cr_line = ruby_sourceline;
12234  rb_compile_warn(ruby_sourcefile, ruby_sourceline, "encountered \\r in middle of line, treated as a mere space");
12235  }
12236  }
12237 
12238  return c;
12239 }
12240 
12241 static void
12242 parser_pushback(struct parser_params *parser, int c)
12243 {
12244  if (c == -1) return;
12245  lex_p--;
12246  if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
12247  lex_p--;
12248  }
12249 }
12250 
12251 #define was_bol() (lex_p == lex_pbeg + 1)
12252 
12253 #define tokfix() (tokenbuf[tokidx]='\0')
12254 #define tok() tokenbuf
12255 #define toklen() tokidx
12256 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
12257 
12258 static char*
12259 parser_newtok(struct parser_params *parser)
12260 {
12261  tokidx = 0;
12262  tokline = ruby_sourceline;
12263  if (!tokenbuf) {
12264  toksiz = 60;
12265  tokenbuf = ALLOC_N(char, 60);
12266  }
12267  if (toksiz > 4096) {
12268  toksiz = 60;
12269  REALLOC_N(tokenbuf, char, 60);
12270  }
12271  return tokenbuf;
12272 }
12273 
12274 static char *
12275 parser_tokspace(struct parser_params *parser, int n)
12276 {
12277  tokidx += n;
12278 
12279  if (tokidx >= toksiz) {
12280  do {toksiz *= 2;} while (toksiz < tokidx);
12281  REALLOC_N(tokenbuf, char, toksiz);
12282  }
12283  return &tokenbuf[tokidx-n];
12284 }
12285 
12286 static void
12287 parser_tokadd(struct parser_params *parser, int c)
12288 {
12289  tokenbuf[tokidx++] = (char)c;
12290  if (tokidx >= toksiz) {
12291  toksiz *= 2;
12292  REALLOC_N(tokenbuf, char, toksiz);
12293  }
12294 }
12295 
12296 static int
12297 parser_tok_hex(struct parser_params *parser, size_t *numlen)
12298 {
12299  int c;
12300 
12301  c = scan_hex(lex_p, 2, numlen);
12302  if (!*numlen) {
12303  yyerror("invalid hex escape");
12304  return 0;
12305  }
12306  lex_p += *numlen;
12307  return c;
12308 }
12309 
12310 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
12311 
12312 /* return value is for ?\u3042 */
12313 static int
12314 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
12315  int string_literal, int symbol_literal, int regexp_literal)
12316 {
12317  /*
12318  * If string_literal is true, then we allow multiple codepoints
12319  * in \u{}, and add the codepoints to the current token.
12320  * Otherwise we're parsing a character literal and return a single
12321  * codepoint without adding it
12322  */
12323 
12324  int codepoint;
12325  size_t numlen;
12326 
12327  if (regexp_literal) { tokadd('\\'); tokadd('u'); }
12328 
12329  if (peek('{')) { /* handle \u{...} form */
12330  do {
12331  if (regexp_literal) { tokadd(*lex_p); }
12332  nextc();
12333  codepoint = scan_hex(lex_p, 6, &numlen);
12334  if (numlen == 0) {
12335  yyerror("invalid Unicode escape");
12336  return 0;
12337  }
12338  if (codepoint > 0x10ffff) {
12339  yyerror("invalid Unicode codepoint (too large)");
12340  return 0;
12341  }
12342  lex_p += numlen;
12343  if (regexp_literal) {
12344  tokcopy((int)numlen);
12345  }
12346  else if (codepoint >= 0x80) {
12347  *encp = rb_utf8_encoding();
12348  if (string_literal) tokaddmbc(codepoint, *encp);
12349  }
12350  else if (string_literal) {
12351  tokadd(codepoint);
12352  }
12353  } while (string_literal && (peek(' ') || peek('\t')));
12354 
12355  if (!peek('}')) {
12356  yyerror("unterminated Unicode escape");
12357  return 0;
12358  }
12359 
12360  if (regexp_literal) { tokadd('}'); }
12361  nextc();
12362  }
12363  else { /* handle \uxxxx form */
12364  codepoint = scan_hex(lex_p, 4, &numlen);
12365  if (numlen < 4) {
12366  yyerror("invalid Unicode escape");
12367  return 0;
12368  }
12369  lex_p += 4;
12370  if (regexp_literal) {
12371  tokcopy(4);
12372  }
12373  else if (codepoint >= 0x80) {
12374  *encp = rb_utf8_encoding();
12375  if (string_literal) tokaddmbc(codepoint, *encp);
12376  }
12377  else if (string_literal) {
12378  tokadd(codepoint);
12379  }
12380  }
12381 
12382  return codepoint;
12383 }
12384 
12385 #define ESCAPE_CONTROL 1
12386 #define ESCAPE_META 2
12387 
12388 static int
12389 parser_read_escape(struct parser_params *parser, int flags,
12390  rb_encoding **encp)
12391 {
12392  int c;
12393  size_t numlen;
12394 
12395  switch (c = nextc()) {
12396  case '\\': /* Backslash */
12397  return c;
12398 
12399  case 'n': /* newline */
12400  return '\n';
12401 
12402  case 't': /* horizontal tab */
12403  return '\t';
12404 
12405  case 'r': /* carriage-return */
12406  return '\r';
12407 
12408  case 'f': /* form-feed */
12409  return '\f';
12410 
12411  case 'v': /* vertical tab */
12412  return '\13';
12413 
12414  case 'a': /* alarm(bell) */
12415  return '\007';
12416 
12417  case 'e': /* escape */
12418  return 033;
12419 
12420  case '0': case '1': case '2': case '3': /* octal constant */
12421  case '4': case '5': case '6': case '7':
12422  pushback(c);
12423  c = scan_oct(lex_p, 3, &numlen);
12424  lex_p += numlen;
12425  return c;
12426 
12427  case 'x': /* hex constant */
12428  c = tok_hex(&numlen);
12429  if (numlen == 0) return 0;
12430  return c;
12431 
12432  case 'b': /* backspace */
12433  return '\010';
12434 
12435  case 's': /* space */
12436  return ' ';
12437 
12438  case 'M':
12439  if (flags & ESCAPE_META) goto eof;
12440  if ((c = nextc()) != '-') {
12441  pushback(c);
12442  goto eof;
12443  }
12444  if ((c = nextc()) == '\\') {
12445  if (peek('u')) goto eof;
12446  return read_escape(flags|ESCAPE_META, encp) | 0x80;
12447  }
12448  else if (c == -1 || !ISASCII(c)) goto eof;
12449  else {
12450  return ((c & 0xff) | 0x80);
12451  }
12452 
12453  case 'C':
12454  if ((c = nextc()) != '-') {
12455  pushback(c);
12456  goto eof;
12457  }
12458  case 'c':
12459  if (flags & ESCAPE_CONTROL) goto eof;
12460  if ((c = nextc())== '\\') {
12461  if (peek('u')) goto eof;
12462  c = read_escape(flags|ESCAPE_CONTROL, encp);
12463  }
12464  else if (c == '?')
12465  return 0177;
12466  else if (c == -1 || !ISASCII(c)) goto eof;
12467  return c & 0x9f;
12468 
12469  eof:
12470  case -1:
12471  yyerror("Invalid escape character syntax");
12472  return '\0';
12473 
12474  default:
12475  return c;
12476  }
12477 }
12478 
12479 static void
12480 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
12481 {
12482  int len = rb_enc_codelen(c, enc);
12483  rb_enc_mbcput(c, tokspace(len), enc);
12484 }
12485 
12486 static int
12487 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
12488 {
12489  int c;
12490  int flags = 0;
12491  size_t numlen;
12492 
12493  first:
12494  switch (c = nextc()) {
12495  case '\n':
12496  return 0; /* just ignore */
12497 
12498  case '0': case '1': case '2': case '3': /* octal constant */
12499  case '4': case '5': case '6': case '7':
12500  {
12501  ruby_scan_oct(--lex_p, 3, &numlen);
12502  if (numlen == 0) goto eof;
12503  lex_p += numlen;
12504  tokcopy((int)numlen + 1);
12505  }
12506  return 0;
12507 
12508  case 'x': /* hex constant */
12509  {
12510  tok_hex(&numlen);
12511  if (numlen == 0) return -1;
12512  tokcopy((int)numlen + 2);
12513  }
12514  return 0;
12515 
12516  case 'M':
12517  if (flags & ESCAPE_META) goto eof;
12518  if ((c = nextc()) != '-') {
12519  pushback(c);
12520  goto eof;
12521  }
12522  tokcopy(3);
12523  flags |= ESCAPE_META;
12524  goto escaped;
12525 
12526  case 'C':
12527  if (flags & ESCAPE_CONTROL) goto eof;
12528  if ((c = nextc()) != '-') {
12529  pushback(c);
12530  goto eof;
12531  }
12532  tokcopy(3);
12533  goto escaped;
12534 
12535  case 'c':
12536  if (flags & ESCAPE_CONTROL) goto eof;
12537  tokcopy(2);
12538  flags |= ESCAPE_CONTROL;
12539  escaped:
12540  if ((c = nextc()) == '\\') {
12541  goto first;
12542  }
12543  else if (c == -1) goto eof;
12544  tokadd(c);
12545  return 0;
12546 
12547  eof:
12548  case -1:
12549  yyerror("Invalid escape character syntax");
12550  return -1;
12551 
12552  default:
12553  tokadd('\\');
12554  tokadd(c);
12555  }
12556  return 0;
12557 }
12558 
12559 static int
12560 parser_regx_options(struct parser_params *parser)
12561 {
12562  int kcode = 0;
12563  int kopt = 0;
12564  int options = 0;
12565  int c, opt, kc;
12566 
12567  newtok();
12568  while (c = nextc(), ISALPHA(c)) {
12569  if (c == 'o') {
12570  options |= RE_OPTION_ONCE;
12571  }
12572  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12573  if (kc >= 0) {
12574  if (kc != rb_ascii8bit_encindex()) kcode = c;
12575  kopt = opt;
12576  }
12577  else {
12578  options |= opt;
12579  }
12580  }
12581  else {
12582  tokadd(c);
12583  }
12584  }
12585  options |= kopt;
12586  pushback(c);
12587  if (toklen()) {
12588  tokfix();
12589  compile_error(PARSER_ARG "unknown regexp option%s - %s",
12590  toklen() > 1 ? "s" : "", tok());
12591  }
12592  return options | RE_OPTION_ENCODING(kcode);
12593 }
12594 
12595 static void
12596 dispose_string(VALUE str)
12597 {
12598  rb_str_free(str);
12599  rb_gc_force_recycle(str);
12600 }
12601 
12602 static int
12603 parser_tokadd_mbchar(struct parser_params *parser, int c)
12604 {
12605  int len = parser_precise_mbclen();
12606  if (!MBCLEN_CHARFOUND_P(len)) {
12607  compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
12608  return -1;
12609  }
12610  tokadd(c);
12611  lex_p += --len;
12612  if (len > 0) tokcopy(len);
12613  return c;
12614 }
12615 
12616 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12617 
12618 static inline int
12619 simple_re_meta(int c)
12620 {
12621  switch (c) {
12622  case '$': case '*': case '+': case '.':
12623  case '?': case '^': case '|':
12624  case ')': case ']': case '}': case '>':
12625  return TRUE;
12626  default:
12627  return FALSE;
12628  }
12629 }
12630 
12631 static int
12632 parser_tokadd_string(struct parser_params *parser,
12633  int func, int term, int paren, long *nest,
12634  rb_encoding **encp)
12635 {
12636  int c;
12637  int has_nonascii = 0;
12638  rb_encoding *enc = *encp;
12639  char *errbuf = 0;
12640  static const char mixed_msg[] = "%s mixed within %s source";
12641 
12642 #define mixed_error(enc1, enc2) if (!errbuf) { \
12643  size_t len = sizeof(mixed_msg) - 4; \
12644  len += strlen(rb_enc_name(enc1)); \
12645  len += strlen(rb_enc_name(enc2)); \
12646  errbuf = ALLOCA_N(char, len); \
12647  snprintf(errbuf, len, mixed_msg, \
12648  rb_enc_name(enc1), \
12649  rb_enc_name(enc2)); \
12650  yyerror(errbuf); \
12651  }
12652 #define mixed_escape(beg, enc1, enc2) do { \
12653  const char *pos = lex_p; \
12654  lex_p = (beg); \
12655  mixed_error((enc1), (enc2)); \
12656  lex_p = pos; \
12657  } while (0)
12658 
12659  while ((c = nextc()) != -1) {
12660  if (paren && c == paren) {
12661  ++*nest;
12662  }
12663  else if (c == term) {
12664  if (!nest || !*nest) {
12665  pushback(c);
12666  break;
12667  }
12668  --*nest;
12669  }
12670  else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12671  int c2 = *lex_p;
12672  if (c2 == '$' || c2 == '@' || c2 == '{') {
12673  pushback(c);
12674  break;
12675  }
12676  }
12677  else if (c == '\\') {
12678  const char *beg = lex_p - 1;
12679  c = nextc();
12680  switch (c) {
12681  case '\n':
12682  if (func & STR_FUNC_QWORDS) break;
12683  if (func & STR_FUNC_EXPAND) continue;
12684  tokadd('\\');
12685  break;
12686 
12687  case '\\':
12688  if (func & STR_FUNC_ESCAPE) tokadd(c);
12689  break;
12690 
12691  case 'u':
12692  if ((func & STR_FUNC_EXPAND) == 0) {
12693  tokadd('\\');
12694  break;
12695  }
12696  parser_tokadd_utf8(parser, &enc, 1,
12697  func & STR_FUNC_SYMBOL,
12698  func & STR_FUNC_REGEXP);
12699  if (has_nonascii && enc != *encp) {
12700  mixed_escape(beg, enc, *encp);
12701  }
12702  continue;
12703 
12704  default:
12705  if (c == -1) return -1;
12706  if (!ISASCII(c)) {
12707  if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12708  goto non_ascii;
12709  }
12710  if (func & STR_FUNC_REGEXP) {
12711  if (c == term && !simple_re_meta(c)) {
12712  tokadd(c);
12713  continue;
12714  }
12715  pushback(c);
12716  if ((c = tokadd_escape(&enc)) < 0)
12717  return -1;
12718  if (has_nonascii && enc != *encp) {
12719  mixed_escape(beg, enc, *encp);
12720  }
12721  continue;
12722  }
12723  else if (func & STR_FUNC_EXPAND) {
12724  pushback(c);
12725  if (func & STR_FUNC_ESCAPE) tokadd('\\');
12726  c = read_escape(0, &enc);
12727  }
12728  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12729  /* ignore backslashed spaces in %w */
12730  }
12731  else if (c != term && !(paren && c == paren)) {
12732  tokadd('\\');
12733  pushback(c);
12734  continue;
12735  }
12736  }
12737  }
12738  else if (!parser_isascii()) {
12739  non_ascii:
12740  has_nonascii = 1;
12741  if (enc != *encp) {
12742  mixed_error(enc, *encp);
12743  continue;
12744  }
12745  if (tokadd_mbchar(c) == -1) return -1;
12746  continue;
12747  }
12748  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12749  pushback(c);
12750  break;
12751  }
12752  if (c & 0x80) {
12753  has_nonascii = 1;
12754  if (enc != *encp) {
12755  mixed_error(enc, *encp);
12756  continue;
12757  }
12758  }
12759  tokadd(c);
12760  }
12761  *encp = enc;
12762  return c;
12763 }
12764 
12765 #define NEW_STRTERM(func, term, paren) \
12766  rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12767 
12768 #ifdef RIPPER
12769 static void
12770 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12771 {
12772  if (!NIL_P(parser->delayed)) {
12773  ptrdiff_t len = lex_p - parser->tokp;
12774  if (len > 0) {
12775  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12776  }
12777  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
12778  parser->tokp = lex_p;
12779  }
12780 }
12781 
12782 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
12783 #else
12784 #define flush_string_content(enc) ((void)(enc))
12785 #endif
12786 
12787 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12788 /* this can be shared with ripper, since it's independent from struct
12789  * parser_params. */
12790 #ifndef RIPPER
12791 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12792 #define SPECIAL_PUNCT(idx) ( \
12793  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12794  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12795  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12796  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12797  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12798  BIT('0', idx))
12799 const unsigned int ruby_global_name_punct_bits[] = {
12800  SPECIAL_PUNCT(0),
12801  SPECIAL_PUNCT(1),
12802  SPECIAL_PUNCT(2),
12803 };
12804 #undef BIT
12805 #undef SPECIAL_PUNCT
12806 #endif
12807 
12808 static inline int
12809 is_global_name_punct(const int c)
12810 {
12811  if (c <= 0x20 || 0x7e < c) return 0;
12812  return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
12813 }
12814 
12815 static int
12816 parser_peek_variable_name(struct parser_params *parser)
12817 {
12818  int c;
12819  const char *p = lex_p;
12820 
12821  if (p + 1 >= lex_pend) return 0;
12822  c = *p++;
12823  switch (c) {
12824  case '$':
12825  if ((c = *p) == '-') {
12826  if (++p >= lex_pend) return 0;
12827  c = *p;
12828  }
12829  else if (is_global_name_punct(c) || ISDIGIT(c)) {
12830  return tSTRING_DVAR;
12831  }
12832  break;
12833  case '@':
12834  if ((c = *p) == '@') {
12835  if (++p >= lex_pend) return 0;
12836  c = *p;
12837  }
12838  break;
12839  case '{':
12840  lex_p = p;
12841  command_start = TRUE;
12842  return tSTRING_DBEG;
12843  default:
12844  return 0;
12845  }
12846  if (!ISASCII(c) || c == '_' || ISALPHA(c))
12847  return tSTRING_DVAR;
12848  return 0;
12849 }
12850 
12851 static int
12852 parser_parse_string(struct parser_params *parser, NODE *quote)
12853 {
12854  int func = (int)quote->nd_func;
12855  int term = nd_term(quote);
12856  int paren = nd_paren(quote);
12857  int c, space = 0;
12858  rb_encoding *enc = current_enc;
12859 
12860  if (func == -1) return tSTRING_END;
12861  c = nextc();
12862  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12863  do {c = nextc();} while (ISSPACE(c));
12864  space = 1;
12865  }
12866  if (c == term && !quote->nd_nest) {
12867  if (func & STR_FUNC_QWORDS) {
12868  quote->nd_func = -1;
12869  return ' ';
12870  }
12871  if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
12872  set_yylval_num(regx_options());
12873  return tREGEXP_END;
12874  }
12875  if (space) {
12876  pushback(c);
12877  return ' ';
12878  }
12879  newtok();
12880  if ((func & STR_FUNC_EXPAND) && c == '#') {
12881  int t = parser_peek_variable_name(parser);
12882  if (t) return t;
12883  tokadd('#');
12884  c = nextc();
12885  }
12886  pushback(c);
12887  if (tokadd_string(func, term, paren, &quote->nd_nest,
12888  &enc) == -1) {
12889  ruby_sourceline = nd_line(quote);
12890  if (func & STR_FUNC_REGEXP) {
12891  if (parser->eofp)
12892  compile_error(PARSER_ARG "unterminated regexp meets end of file");
12893  return tREGEXP_END;
12894  }
12895  else {
12896  if (parser->eofp)
12897  compile_error(PARSER_ARG "unterminated string meets end of file");
12898  return tSTRING_END;
12899  }
12900  }
12901 
12902  tokfix();
12903  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12904  flush_string_content(enc);
12905 
12906  return tSTRING_CONTENT;
12907 }
12908 
12909 static int
12910 parser_heredoc_identifier(struct parser_params *parser)
12911 {
12912  int c = nextc(), term, func = 0;
12913  long len;
12914 
12915  if (c == '-') {
12916  c = nextc();
12917  func = STR_FUNC_INDENT;
12918  }
12919  switch (c) {
12920  case '\'':
12921  func |= str_squote; goto quoted;
12922  case '"':
12923  func |= str_dquote; goto quoted;
12924  case '`':
12925  func |= str_xquote;
12926  quoted:
12927  newtok();
12928  tokadd(func);
12929  term = c;
12930  while ((c = nextc()) != -1 && c != term) {
12931  if (tokadd_mbchar(c) == -1) return 0;
12932  }
12933  if (c == -1) {
12934  compile_error(PARSER_ARG "unterminated here document identifier");
12935  return 0;
12936  }
12937  break;
12938 
12939  default:
12940  if (!parser_is_identchar()) {
12941  pushback(c);
12942  if (func & STR_FUNC_INDENT) {
12943  pushback('-');
12944  }
12945  return 0;
12946  }
12947  newtok();
12948  term = '"';
12949  tokadd(func |= str_dquote);
12950  do {
12951  if (tokadd_mbchar(c) == -1) return 0;
12952  } while ((c = nextc()) != -1 && parser_is_identchar());
12953  pushback(c);
12954  break;
12955  }
12956 
12957  tokfix();
12958 #ifdef RIPPER
12959  ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
12960 #endif
12961  len = lex_p - lex_pbeg;
12962  lex_goto_eol(parser);
12963  lex_strterm = rb_node_newnode(NODE_HEREDOC,
12964  STR_NEW(tok(), toklen()), /* nd_lit */
12965  len, /* nd_nth */
12966  lex_lastline); /* nd_orig */
12967  nd_set_line(lex_strterm, ruby_sourceline);
12968  ripper_flush(parser);
12969  return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
12970 }
12971 
12972 static void
12973 parser_heredoc_restore(struct parser_params *parser, NODE *here)
12974 {
12975  VALUE line;
12976 
12977  lex_strterm = 0;
12978  line = here->nd_orig;
12979  lex_lastline = line;
12980  lex_pbeg = RSTRING_PTR(line);
12981  lex_pend = lex_pbeg + RSTRING_LEN(line);
12982  lex_p = lex_pbeg + here->nd_nth;
12983  heredoc_end = ruby_sourceline;
12984  ruby_sourceline = nd_line(here);
12985  dispose_string(here->nd_lit);
12986  rb_gc_force_recycle((VALUE)here);
12987  ripper_flush(parser);
12988 }
12989 
12990 static int
12991 parser_whole_match_p(struct parser_params *parser,
12992  const char *eos, long len, int indent)
12993 {
12994  const char *p = lex_pbeg;
12995  long n;
12996 
12997  if (indent) {
12998  while (*p && ISSPACE(*p)) p++;
12999  }
13000  n = lex_pend - (p + len);
13001  if (n < 0) return FALSE;
13002  if (n > 0 && p[len] != '\n') {
13003  if (p[len] != '\r') return FALSE;
13004  if (n <= 1 || p[len+1] != '\n') return FALSE;
13005  }
13006  return strncmp(eos, p, len) == 0;
13007 }
13008 
13009 #define NUM_SUFFIX_R (1<<0)
13010 #define NUM_SUFFIX_I (1<<1)
13011 #define NUM_SUFFIX_ALL 3
13012 
13013 static int
13014 parser_number_literal_suffix(struct parser_params *parser, int mask)
13015 {
13016  int c, result = 0;
13017  const char *lastp = lex_p;
13018 
13019  while ((c = nextc()) != -1) {
13020  if ((mask & NUM_SUFFIX_I) && c == 'i') {
13021  result |= (mask & NUM_SUFFIX_I);
13022  mask &= ~NUM_SUFFIX_I;
13023  /* r after i, rational of complex is disallowed */
13024  mask &= ~NUM_SUFFIX_R;
13025  continue;
13026  }
13027  if ((mask & NUM_SUFFIX_R) && c == 'r') {
13028  result |= (mask & NUM_SUFFIX_R);
13029  mask &= ~NUM_SUFFIX_R;
13030  continue;
13031  }
13032  if (!ISASCII(c) || ISALPHA(c) || c == '_') {
13033  lex_p = lastp;
13034  return 0;
13035  }
13036  pushback(c);
13037  break;
13038  }
13039  return result;
13040 }
13041 
13042 static int
13043 parser_set_number_literal(struct parser_params *parser, VALUE v, int type, int suffix)
13044 {
13045  if (suffix & NUM_SUFFIX_I) {
13046  v = rb_complex_raw(INT2FIX(0), v);
13047  type = tIMAGINARY;
13048  }
13049  set_yylval_literal(v);
13050  return type;
13051 }
13052 
13053 static int
13054 parser_set_integer_literal(struct parser_params *parser, VALUE v, int suffix)
13055 {
13056  int type = tINTEGER;
13057  if (suffix & NUM_SUFFIX_R) {
13058  v = rb_rational_raw1(v);
13059  type = tRATIONAL;
13060  }
13061  return set_number_literal(v, type, suffix);
13062 }
13063 
13064 #ifdef RIPPER
13065 static void
13066 ripper_dispatch_heredoc_end(struct parser_params *parser)
13067 {
13068  if (!NIL_P(parser->delayed))
13069  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
13070  lex_goto_eol(parser);
13071  ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
13072 }
13073 
13074 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
13075 #else
13076 #define dispatch_heredoc_end() ((void)0)
13077 #endif
13078 
13079 static int
13080 parser_here_document(struct parser_params *parser, NODE *here)
13081 {
13082  int c, func, indent = 0;
13083  const char *eos, *p, *pend;
13084  long len;
13085  VALUE str = 0;
13086  rb_encoding *enc = current_enc;
13087 
13088  eos = RSTRING_PTR(here->nd_lit);
13089  len = RSTRING_LEN(here->nd_lit) - 1;
13090  indent = (func = *eos++) & STR_FUNC_INDENT;
13091 
13092  if ((c = nextc()) == -1) {
13093  error:
13094  compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
13095 #ifdef RIPPER
13096  if (NIL_P(parser->delayed)) {
13097  ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
13098  }
13099  else {
13100  if (str ||
13101  ((len = lex_p - parser->tokp) > 0 &&
13102  (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
13103  rb_str_append(parser->delayed, str);
13104  }
13105  ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
13106  }
13107  lex_goto_eol(parser);
13108 #endif
13109  restore:
13110  heredoc_restore(lex_strterm);
13111  return 0;
13112  }
13113  if (was_bol() && whole_match_p(eos, len, indent)) {
13114  dispatch_heredoc_end();
13115  heredoc_restore(lex_strterm);
13116  return tSTRING_END;
13117  }
13118 
13119  if (!(func & STR_FUNC_EXPAND)) {
13120  do {
13121  p = RSTRING_PTR(lex_lastline);
13122  pend = lex_pend;
13123  if (pend > p) {
13124  switch (pend[-1]) {
13125  case '\n':
13126  if (--pend == p || pend[-1] != '\r') {
13127  pend++;
13128  break;
13129  }
13130  case '\r':
13131  --pend;
13132  }
13133  }
13134  if (str)
13135  rb_str_cat(str, p, pend - p);
13136  else
13137  str = STR_NEW(p, pend - p);
13138  if (pend < lex_pend) rb_str_cat(str, "\n", 1);
13139  lex_goto_eol(parser);
13140  if (nextc() == -1) {
13141  if (str) dispose_string(str);
13142  goto error;
13143  }
13144  } while (!whole_match_p(eos, len, indent));
13145  }
13146  else {
13147  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
13148  newtok();
13149  if (c == '#') {
13150  int t = parser_peek_variable_name(parser);
13151  if (t) return t;
13152  tokadd('#');
13153  c = nextc();
13154  }
13155  do {
13156  pushback(c);
13157  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
13158  if (parser->eofp) goto error;
13159  goto restore;
13160  }
13161  if (c != '\n') {
13162  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
13163  flush_string_content(enc);
13164  return tSTRING_CONTENT;
13165  }
13166  tokadd(nextc());
13167  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
13168  if ((c = nextc()) == -1) goto error;
13169  } while (!whole_match_p(eos, len, indent));
13170  str = STR_NEW3(tok(), toklen(), enc, func);
13171  }
13172  dispatch_heredoc_end();
13173  heredoc_restore(lex_strterm);
13174  lex_strterm = NEW_STRTERM(-1, 0, 0);
13175  set_yylval_str(str);
13176  return tSTRING_CONTENT;
13177 }
13178 
13179 #include "lex.c"
13180 
13181 static void
13182 arg_ambiguous_gen(struct parser_params *parser)
13183 {
13184 #ifndef RIPPER
13185  rb_warning0("ambiguous first argument; put parentheses or even spaces");
13186 #else
13187  dispatch0(arg_ambiguous);
13188 #endif
13189 }
13190 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
13191 
13192 static ID
13193 formal_argument_gen(struct parser_params *parser, ID lhs)
13194 {
13195 #ifndef RIPPER
13196  if (!is_local_id(lhs))
13197  yyerror("formal argument must be local variable");
13198 #endif
13199  shadowing_lvar(lhs);
13200  return lhs;
13201 }
13202 
13203 static int
13204 lvar_defined_gen(struct parser_params *parser, ID id)
13205 {
13206  return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
13207 }
13208 
13209 /* emacsen -*- hack */
13210 static long
13211 parser_encode_length(struct parser_params *parser, const char *name, long len)
13212 {
13213  long nlen;
13214 
13215  if (len > 5 && name[nlen = len - 5] == '-') {
13216  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
13217  return nlen;
13218  }
13219  if (len > 4 && name[nlen = len - 4] == '-') {
13220  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
13221  return nlen;
13222  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
13223  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
13224  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
13225  return nlen;
13226  }
13227  return len;
13228 }
13229 
13230 static void
13231 parser_set_encode(struct parser_params *parser, const char *name)
13232 {
13233  int idx = rb_enc_find_index(name);
13234  rb_encoding *enc;
13235  VALUE excargs[3];
13236 
13237  if (idx < 0) {
13238  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
13239  error:
13240  excargs[0] = rb_eArgError;
13241  excargs[2] = rb_make_backtrace();
13242  rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
13243  rb_exc_raise(rb_make_exception(3, excargs));
13244  }
13245  enc = rb_enc_from_index(idx);
13246  if (!rb_enc_asciicompat(enc)) {
13247  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13248  goto error;
13249  }
13250  parser->enc = enc;
13251 #ifndef RIPPER
13252  if (ruby_debug_lines) {
13253  VALUE lines = ruby_debug_lines;
13254  long i, n = RARRAY_LEN(lines);
13255  for (i = 0; i < n; ++i) {
13256  rb_enc_associate_index(RARRAY_AREF(lines, i), idx);
13257  }
13258  }
13259 #endif
13260 }
13261 
13262 static int
13263 comment_at_top(struct parser_params *parser)
13264 {
13265  const char *p = lex_pbeg, *pend = lex_p - 1;
13266  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13267  while (p < pend) {
13268  if (!ISSPACE(*p)) return 0;
13269  p++;
13270  }
13271  return 1;
13272 }
13273 
13274 #ifndef RIPPER
13275 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13276 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13277 
13278 static void
13279 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13280 {
13281  if (!comment_at_top(parser)) {
13282  return;
13283  }
13284  parser_set_encode(parser, val);
13285 }
13286 
13287 static void
13288 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13289 {
13290  int *p = &parser->parser_token_info_enabled;
13291 
13292  switch (*val) {
13293  case 't': case 'T':
13294  if (strcasecmp(val, "true") == 0) {
13295  *p = TRUE;
13296  return;
13297  }
13298  break;
13299  case 'f': case 'F':
13300  if (strcasecmp(val, "false") == 0) {
13301  *p = FALSE;
13302  return;
13303  }
13304  break;
13305  }
13306  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13307 }
13308 
13309 struct magic_comment {
13310  const char *name;
13311  rb_magic_comment_setter_t func;
13312  rb_magic_comment_length_t length;
13313 };
13314 
13315 static const struct magic_comment magic_comments[] = {
13316  {"coding", magic_comment_encoding, parser_encode_length},
13317  {"encoding", magic_comment_encoding, parser_encode_length},
13318  {"warn_indent", parser_set_token_info},
13319 };
13320 #endif
13321 
13322 static const char *
13323 magic_comment_marker(const char *str, long len)
13324 {
13325  long i = 2;
13326 
13327  while (i < len) {
13328  switch (str[i]) {
13329  case '-':
13330  if (str[i-1] == '*' && str[i-2] == '-') {
13331  return str + i + 1;
13332  }
13333  i += 2;
13334  break;
13335  case '*':
13336  if (i + 1 >= len) return 0;
13337  if (str[i+1] != '-') {
13338  i += 4;
13339  }
13340  else if (str[i-1] != '-') {
13341  i += 2;
13342  }
13343  else {
13344  return str + i + 2;
13345  }
13346  break;
13347  default:
13348  i += 3;
13349  break;
13350  }
13351  }
13352  return 0;
13353 }
13354 
13355 static int
13356 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13357 {
13358  VALUE name = 0, val = 0;
13359  const char *beg, *end, *vbeg, *vend;
13360 #define str_copy(_s, _p, _n) ((_s) \
13361  ? (void)(rb_str_resize((_s), (_n)), \
13362  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13363  : (void)((_s) = STR_NEW((_p), (_n))))
13364 
13365  if (len <= 7) return FALSE;
13366  if (!(beg = magic_comment_marker(str, len))) return FALSE;
13367  if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13368  str = beg;
13369  len = end - beg - 3;
13370 
13371  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13372  while (len > 0) {
13373 #ifndef RIPPER
13374  const struct magic_comment *p = magic_comments;
13375 #endif
13376  char *s;
13377  int i;
13378  long n = 0;
13379 
13380  for (; len > 0 && *str; str++, --len) {
13381  switch (*str) {
13382  case '\'': case '"': case ':': case ';':
13383  continue;
13384  }
13385  if (!ISSPACE(*str)) break;
13386  }
13387  for (beg = str; len > 0; str++, --len) {
13388  switch (*str) {
13389  case '\'': case '"': case ':': case ';':
13390  break;
13391  default:
13392  if (ISSPACE(*str)) break;
13393  continue;
13394  }
13395  break;
13396  }
13397  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13398  if (!len) break;
13399  if (*str != ':') continue;
13400 
13401  do str++; while (--len > 0 && ISSPACE(*str));
13402  if (!len) break;
13403  if (*str == '"') {
13404  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13405  if (*str == '\\') {
13406  --len;
13407  ++str;
13408  }
13409  }
13410  vend = str;
13411  if (len) {
13412  --len;
13413  ++str;
13414  }
13415  }
13416  else {
13417  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13418  vend = str;
13419  }
13420  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13421 
13422  n = end - beg;
13423  str_copy(name, beg, n);
13424  s = RSTRING_PTR(name);
13425  for (i = 0; i < n; ++i) {
13426  if (s[i] == '-') s[i] = '_';
13427  }
13428 #ifndef RIPPER
13429  do {
13430  if (STRNCASECMP(p->name, s, n) == 0) {
13431  n = vend - vbeg;
13432  if (p->length) {
13433  n = (*p->length)(parser, vbeg, n);
13434  }
13435  str_copy(val, vbeg, n);
13436  (*p->func)(parser, s, RSTRING_PTR(val));
13437  break;
13438  }
13439  } while (++p < magic_comments + numberof(magic_comments));
13440 #else
13441  str_copy(val, vbeg, vend - vbeg);
13442  dispatch2(magic_comment, name, val);
13443 #endif
13444  }
13445 
13446  return TRUE;
13447 }
13448 
13449 static void
13450 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13451 {
13452  int sep = 0;
13453  const char *beg = str;
13454  VALUE s;
13455 
13456  for (;;) {
13457  if (send - str <= 6) return;
13458  switch (str[6]) {
13459  case 'C': case 'c': str += 6; continue;
13460  case 'O': case 'o': str += 5; continue;
13461  case 'D': case 'd': str += 4; continue;
13462  case 'I': case 'i': str += 3; continue;
13463  case 'N': case 'n': str += 2; continue;
13464  case 'G': case 'g': str += 1; continue;
13465  case '=': case ':':
13466  sep = 1;
13467  str += 6;
13468  break;
13469  default:
13470  str += 6;
13471  if (ISSPACE(*str)) break;
13472  continue;
13473  }
13474  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13475  }
13476  for (;;) {
13477  do {
13478  if (++str >= send) return;
13479  } while (ISSPACE(*str));
13480  if (sep) break;
13481  if (*str != '=' && *str != ':') return;
13482  sep = 1;
13483  str++;
13484  }
13485  beg = str;
13486  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13487  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13488  parser_set_encode(parser, RSTRING_PTR(s));
13489  rb_str_resize(s, 0);
13490 }
13491 
13492 static void
13493 parser_prepare(struct parser_params *parser)
13494 {
13495  int c = nextc();
13496  switch (c) {
13497  case '#':
13498  if (peek('!')) parser->has_shebang = 1;
13499  break;
13500  case 0xef: /* UTF-8 BOM marker */
13501  if (lex_pend - lex_p >= 2 &&
13502  (unsigned char)lex_p[0] == 0xbb &&
13503  (unsigned char)lex_p[1] == 0xbf) {
13504  parser->enc = rb_utf8_encoding();
13505  lex_p += 2;
13506  lex_pbeg = lex_p;
13507  return;
13508  }
13509  break;
13510  case EOF:
13511  return;
13512  }
13513  pushback(c);
13514  parser->enc = rb_enc_get(lex_lastline);
13515 }
13516 
13517 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13518 #define IS_END() IS_lex_state(EXPR_END_ANY)
13519 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13520 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13521 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13522 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13523 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13524 
13525 #ifndef RIPPER
13526 #define ambiguous_operator(op, syn) ( \
13527  rb_warning0("`"op"' after local variable or literal is interpreted as binary operator"), \
13528  rb_warning0("even though it seems like "syn""))
13529 #else
13530 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13531 #endif
13532 #define warn_balanced(op, syn) ((void) \
13533  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13534  space_seen && !ISSPACE(c) && \
13535  (ambiguous_operator(op, syn), 0)))
13536 
13537 static int
13538 parser_yylex(struct parser_params *parser)
13539 {
13540  register int c;
13541  int space_seen = 0;
13542  int cmd_state;
13543  enum lex_state_e last_state;
13544  rb_encoding *enc;
13545  int mb;
13546 #ifdef RIPPER
13547  int fallthru = FALSE;
13548 #endif
13549 
13550  if (lex_strterm) {
13551  int token;
13552  if (nd_type(lex_strterm) == NODE_HEREDOC) {
13553  token = here_document(lex_strterm);
13554  if (token == tSTRING_END) {
13555  lex_strterm = 0;
13556  lex_state = EXPR_END;
13557  }
13558  }
13559  else {
13560  token = parse_string(lex_strterm);
13561  if (token == tSTRING_END || token == tREGEXP_END) {
13562  rb_gc_force_recycle((VALUE)lex_strterm);
13563  lex_strterm = 0;
13564  lex_state = EXPR_END;
13565  }
13566  }
13567  return token;
13568  }
13569  cmd_state = command_start;
13570  command_start = FALSE;
13571  retry:
13572  last_state = lex_state;
13573  switch (c = nextc()) {
13574  case '\0': /* NUL */
13575  case '\004': /* ^D */
13576  case '\032': /* ^Z */
13577  case -1: /* end of script. */
13578  return 0;
13579 
13580  /* white spaces */
13581  case ' ': case '\t': case '\f': case '\r':
13582  case '\13': /* '\v' */
13583  space_seen = 1;
13584 #ifdef RIPPER
13585  while ((c = nextc())) {
13586  switch (c) {
13587  case ' ': case '\t': case '\f': case '\r':
13588  case '\13': /* '\v' */
13589  break;
13590  default:
13591  goto outofloop;
13592  }
13593  }
13594  outofloop:
13595  pushback(c);
13596  ripper_dispatch_scan_event(parser, tSP);
13597 #endif
13598  goto retry;
13599 
13600  case '#': /* it's a comment */
13601  /* no magic_comment in shebang line */
13602  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13603  if (comment_at_top(parser)) {
13604  set_file_encoding(parser, lex_p, lex_pend);
13605  }
13606  }
13607  lex_p = lex_pend;
13608 #ifdef RIPPER
13609  ripper_dispatch_scan_event(parser, tCOMMENT);
13610  fallthru = TRUE;
13611 #endif
13612  /* fall through */
13613  case '\n':
13614  if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT | EXPR_LABELARG)) {
13615 #ifdef RIPPER
13616  if (!fallthru) {
13617  ripper_dispatch_scan_event(parser, tIGNORED_NL);
13618  }
13619  fallthru = FALSE;
13620 #endif
13621  if (IS_lex_state(EXPR_LABELARG) && parser->parser_in_kwarg) {
13622  goto normal_newline;
13623  }
13624  goto retry;
13625  }
13626  while ((c = nextc())) {
13627  switch (c) {
13628  case ' ': case '\t': case '\f': case '\r':
13629  case '\13': /* '\v' */
13630  space_seen = 1;
13631  break;
13632  case '.': {
13633  if ((c = nextc()) != '.') {
13634  pushback(c);
13635  pushback('.');
13636  goto retry;
13637  }
13638  }
13639  default:
13640  --ruby_sourceline;
13641  lex_nextline = lex_lastline;
13642  case -1: /* EOF no decrement*/
13643  lex_goto_eol(parser);
13644 #ifdef RIPPER
13645  if (c != -1) {
13646  parser->tokp = lex_p;
13647  }
13648 #endif
13649  goto normal_newline;
13650  }
13651  }
13652  normal_newline:
13653  command_start = TRUE;
13654  lex_state = EXPR_BEG;
13655  return '\n';
13656 
13657  case '*':
13658  if ((c = nextc()) == '*') {
13659  if ((c = nextc()) == '=') {
13660  set_yylval_id(tPOW);
13661  lex_state = EXPR_BEG;
13662  return tOP_ASGN;
13663  }
13664  pushback(c);
13665  if (IS_SPCARG(c)) {
13666  rb_warning0("`**' interpreted as argument prefix");
13667  c = tDSTAR;
13668  }
13669  else if (IS_BEG()) {
13670  c = tDSTAR;
13671  }
13672  else {
13673  warn_balanced("**", "argument prefix");
13674  c = tPOW;
13675  }
13676  }
13677  else {
13678  if (c == '=') {
13679  set_yylval_id('*');
13680  lex_state = EXPR_BEG;
13681  return tOP_ASGN;
13682  }
13683  pushback(c);
13684  if (IS_SPCARG(c)) {
13685  rb_warning0("`*' interpreted as argument prefix");
13686  c = tSTAR;
13687  }
13688  else if (IS_BEG()) {
13689  c = tSTAR;
13690  }
13691  else {
13692  warn_balanced("*", "argument prefix");
13693  c = '*';
13694  }
13695  }
13696  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13697  return c;
13698 
13699  case '!':
13700  c = nextc();
13701  if (IS_AFTER_OPERATOR()) {
13702  lex_state = EXPR_ARG;
13703  if (c == '@') {
13704  return '!';
13705  }
13706  }
13707  else {
13708  lex_state = EXPR_BEG;
13709  }
13710  if (c == '=') {
13711  return tNEQ;
13712  }
13713  if (c == '~') {
13714  return tNMATCH;
13715  }
13716  pushback(c);
13717  return '!';
13718 
13719  case '=':
13720  if (was_bol()) {
13721  /* skip embedded rd document */
13722  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13723 #ifdef RIPPER
13724  int first_p = TRUE;
13725 
13726  lex_goto_eol(parser);
13727  ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13728 #endif
13729  for (;;) {
13730  lex_goto_eol(parser);
13731 #ifdef RIPPER
13732  if (!first_p) {
13733  ripper_dispatch_scan_event(parser, tEMBDOC);
13734  }
13735  first_p = FALSE;
13736 #endif
13737  c = nextc();
13738  if (c == -1) {
13739  compile_error(PARSER_ARG "embedded document meets end of file");
13740  return 0;
13741  }
13742  if (c != '=') continue;
13743  if (strncmp(lex_p, "end", 3) == 0 &&
13744  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13745  break;
13746  }
13747  }
13748  lex_goto_eol(parser);
13749 #ifdef RIPPER
13750  ripper_dispatch_scan_event(parser, tEMBDOC_END);
13751 #endif
13752  goto retry;
13753  }
13754  }
13755 
13756  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13757  if ((c = nextc()) == '=') {
13758  if ((c = nextc()) == '=') {
13759  return tEQQ;
13760  }
13761  pushback(c);
13762  return tEQ;
13763  }
13764  if (c == '~') {
13765  return tMATCH;
13766  }
13767  else if (c == '>') {
13768  return tASSOC;
13769  }
13770  pushback(c);
13771  return '=';
13772 
13773  case '<':
13774  last_state = lex_state;
13775  c = nextc();
13776  if (c == '<' &&
13777  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13778  !IS_END() &&
13779  (!IS_ARG() || space_seen)) {
13780  int token = heredoc_identifier();
13781  if (token) return token;
13782  }
13783  if (IS_AFTER_OPERATOR()) {
13784  lex_state = EXPR_ARG;
13785  }
13786  else {
13787  if (IS_lex_state(EXPR_CLASS))
13788  command_start = TRUE;
13789  lex_state = EXPR_BEG;
13790  }
13791  if (c == '=') {
13792  if ((c = nextc()) == '>') {
13793  return tCMP;
13794  }
13795  pushback(c);
13796  return tLEQ;
13797  }
13798  if (c == '<') {
13799  if ((c = nextc()) == '=') {
13800  set_yylval_id(tLSHFT);
13801  lex_state = EXPR_BEG;
13802  return tOP_ASGN;
13803  }
13804  pushback(c);
13805  warn_balanced("<<", "here document");
13806  return tLSHFT;
13807  }
13808  pushback(c);
13809  return '<';
13810 
13811  case '>':
13812  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13813  if ((c = nextc()) == '=') {
13814  return tGEQ;
13815  }
13816  if (c == '>') {
13817  if ((c = nextc()) == '=') {
13818  set_yylval_id(tRSHFT);
13819  lex_state = EXPR_BEG;
13820  return tOP_ASGN;
13821  }
13822  pushback(c);
13823  return tRSHFT;
13824  }
13825  pushback(c);
13826  return '>';
13827 
13828  case '"':
13829  lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13830  return tSTRING_BEG;
13831 
13832  case '`':
13833  if (IS_lex_state(EXPR_FNAME)) {
13834  lex_state = EXPR_ENDFN;
13835  return c;
13836  }
13837  if (IS_lex_state(EXPR_DOT)) {
13838  if (cmd_state)
13839  lex_state = EXPR_CMDARG;
13840  else
13841  lex_state = EXPR_ARG;
13842  return c;
13843  }
13844  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13845  return tXSTRING_BEG;
13846 
13847  case '\'':
13848  lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13849  return tSTRING_BEG;
13850 
13851  case '?':
13852  if (IS_END()) {
13853  lex_state = EXPR_VALUE;
13854  return '?';
13855  }
13856  c = nextc();
13857  if (c == -1) {
13858  compile_error(PARSER_ARG "incomplete character syntax");
13859  return 0;
13860  }
13861  if (rb_enc_isspace(c, current_enc)) {
13862  if (!IS_ARG()) {
13863  int c2 = 0;
13864  switch (c) {
13865  case ' ':
13866  c2 = 's';
13867  break;
13868  case '\n':
13869  c2 = 'n';
13870  break;
13871  case '\t':
13872  c2 = 't';
13873  break;
13874  case '\v':
13875  c2 = 'v';
13876  break;
13877  case '\r':
13878  c2 = 'r';
13879  break;
13880  case '\f':
13881  c2 = 'f';
13882  break;
13883  }
13884  if (c2) {
13885  rb_warnI("invalid character syntax; use ?\\%c", c2);
13886  }
13887  }
13888  ternary:
13889  pushback(c);
13890  lex_state = EXPR_VALUE;
13891  return '?';
13892  }
13893  newtok();
13894  enc = current_enc;
13895  if (!parser_isascii()) {
13896  if (tokadd_mbchar(c) == -1) return 0;
13897  }
13898  else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13899  lex_p < lex_pend && is_identchar(lex_p, lex_pend, current_enc)) {
13900  goto ternary;
13901  }
13902  else if (c == '\\') {
13903  if (peek('u')) {
13904  nextc();
13905  c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13906  if (0x80 <= c) {
13907  tokaddmbc(c, enc);
13908  }
13909  else {
13910  tokadd(c);
13911  }
13912  }
13913  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13914  nextc();
13915  if (tokadd_mbchar(c) == -1) return 0;
13916  }
13917  else {
13918  c = read_escape(0, &enc);
13919  tokadd(c);
13920  }
13921  }
13922  else {
13923  tokadd(c);
13924  }
13925  tokfix();
13926  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13927  lex_state = EXPR_END;
13928  return tCHAR;
13929 
13930  case '&':
13931  if ((c = nextc()) == '&') {
13932  lex_state = EXPR_BEG;
13933  if ((c = nextc()) == '=') {
13934  set_yylval_id(tANDOP);
13935  lex_state = EXPR_BEG;
13936  return tOP_ASGN;
13937  }
13938  pushback(c);
13939  return tANDOP;
13940  }
13941  else if (c == '=') {
13942  set_yylval_id('&');
13943  lex_state = EXPR_BEG;
13944  return tOP_ASGN;
13945  }
13946  pushback(c);
13947  if (IS_SPCARG(c)) {
13948  rb_warning0("`&' interpreted as argument prefix");
13949  c = tAMPER;
13950  }
13951  else if (IS_BEG()) {
13952  c = tAMPER;
13953  }
13954  else {
13955  warn_balanced("&", "argument prefix");
13956  c = '&';
13957  }
13958  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13959  return c;
13960 
13961  case '|':
13962  if ((c = nextc()) == '|') {
13963  lex_state = EXPR_BEG;
13964  if ((c = nextc()) == '=') {
13965  set_yylval_id(tOROP);
13966  lex_state = EXPR_BEG;
13967  return tOP_ASGN;
13968  }
13969  pushback(c);
13970  return tOROP;
13971  }
13972  if (c == '=') {
13973  set_yylval_id('|');
13974  lex_state = EXPR_BEG;
13975  return tOP_ASGN;
13976  }
13977  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13978  pushback(c);
13979  return '|';
13980 
13981  case '+':
13982  c = nextc();
13983  if (IS_AFTER_OPERATOR()) {
13984  lex_state = EXPR_ARG;
13985  if (c == '@') {
13986  return tUPLUS;
13987  }
13988  pushback(c);
13989  return '+';
13990  }
13991  if (c == '=') {
13992  set_yylval_id('+');
13993  lex_state = EXPR_BEG;
13994  return tOP_ASGN;
13995  }
13996  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
13997  lex_state = EXPR_BEG;
13998  pushback(c);
13999  if (c != -1 && ISDIGIT(c)) {
14000  c = '+';
14001  goto start_num;
14002  }
14003  return tUPLUS;
14004  }
14005  lex_state = EXPR_BEG;
14006  pushback(c);
14007  warn_balanced("+", "unary operator");
14008  return '+';
14009 
14010  case '-':
14011  c = nextc();
14012  if (IS_AFTER_OPERATOR()) {
14013  lex_state = EXPR_ARG;
14014  if (c == '@') {
14015  return tUMINUS;
14016  }
14017  pushback(c);
14018  return '-';
14019  }
14020  if (c == '=') {
14021  set_yylval_id('-');
14022  lex_state = EXPR_BEG;
14023  return tOP_ASGN;
14024  }
14025  if (c == '>') {
14026  lex_state = EXPR_ENDFN;
14027  return tLAMBDA;
14028  }
14029  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
14030  lex_state = EXPR_BEG;
14031  pushback(c);
14032  if (c != -1 && ISDIGIT(c)) {
14033  return tUMINUS_NUM;
14034  }
14035  return tUMINUS;
14036  }
14037  lex_state = EXPR_BEG;
14038  pushback(c);
14039  warn_balanced("-", "unary operator");
14040  return '-';
14041 
14042  case '.':
14043  lex_state = EXPR_BEG;
14044  if ((c = nextc()) == '.') {
14045  if ((c = nextc()) == '.') {
14046  return tDOT3;
14047  }
14048  pushback(c);
14049  return tDOT2;
14050  }
14051  pushback(c);
14052  if (c != -1 && ISDIGIT(c)) {
14053  yyerror("no .<digit> floating literal anymore; put 0 before dot");
14054  }
14055  lex_state = EXPR_DOT;
14056  return '.';
14057 
14058  start_num:
14059  case '0': case '1': case '2': case '3': case '4':
14060  case '5': case '6': case '7': case '8': case '9':
14061  {
14062  int is_float, seen_point, seen_e, nondigit;
14063  int suffix;
14064 
14065  is_float = seen_point = seen_e = nondigit = 0;
14066  lex_state = EXPR_END;
14067  newtok();
14068  if (c == '-' || c == '+') {
14069  tokadd(c);
14070  c = nextc();
14071  }
14072  if (c == '0') {
14073 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
14074  int start = toklen();
14075  c = nextc();
14076  if (c == 'x' || c == 'X') {
14077  /* hexadecimal */
14078  c = nextc();
14079  if (c != -1 && ISXDIGIT(c)) {
14080  do {
14081  if (c == '_') {
14082  if (nondigit) break;
14083  nondigit = c;
14084  continue;
14085  }
14086  if (!ISXDIGIT(c)) break;
14087  nondigit = 0;
14088  tokadd(c);
14089  } while ((c = nextc()) != -1);
14090  }
14091  pushback(c);
14092  tokfix();
14093  if (toklen() == start) {
14094  no_digits();
14095  }
14096  else if (nondigit) goto trailing_uc;
14097  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14098  return set_integer_literal(rb_cstr_to_inum(tok(), 16, FALSE), suffix);
14099  }
14100  if (c == 'b' || c == 'B') {
14101  /* binary */
14102  c = nextc();
14103  if (c == '0' || c == '1') {
14104  do {
14105  if (c == '_') {
14106  if (nondigit) break;
14107  nondigit = c;
14108  continue;
14109  }
14110  if (c != '0' && c != '1') break;
14111  nondigit = 0;
14112  tokadd(c);
14113  } while ((c = nextc()) != -1);
14114  }
14115  pushback(c);
14116  tokfix();
14117  if (toklen() == start) {
14118  no_digits();
14119  }
14120  else if (nondigit) goto trailing_uc;
14121  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14122  return set_integer_literal(rb_cstr_to_inum(tok(), 2, FALSE), suffix);
14123  }
14124  if (c == 'd' || c == 'D') {
14125  /* decimal */
14126  c = nextc();
14127  if (c != -1 && ISDIGIT(c)) {
14128  do {
14129  if (c == '_') {
14130  if (nondigit) break;
14131  nondigit = c;
14132  continue;
14133  }
14134  if (!ISDIGIT(c)) break;
14135  nondigit = 0;
14136  tokadd(c);
14137  } while ((c = nextc()) != -1);
14138  }
14139  pushback(c);
14140  tokfix();
14141  if (toklen() == start) {
14142  no_digits();
14143  }
14144  else if (nondigit) goto trailing_uc;
14145  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14146  return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
14147  }
14148  if (c == '_') {
14149  /* 0_0 */
14150  goto octal_number;
14151  }
14152  if (c == 'o' || c == 'O') {
14153  /* prefixed octal */
14154  c = nextc();
14155  if (c == -1 || c == '_' || !ISDIGIT(c)) {
14156  no_digits();
14157  }
14158  }
14159  if (c >= '0' && c <= '7') {
14160  /* octal */
14161  octal_number:
14162  do {
14163  if (c == '_') {
14164  if (nondigit) break;
14165  nondigit = c;
14166  continue;
14167  }
14168  if (c < '0' || c > '9') break;
14169  if (c > '7') goto invalid_octal;
14170  nondigit = 0;
14171  tokadd(c);
14172  } while ((c = nextc()) != -1);
14173  if (toklen() > start) {
14174  pushback(c);
14175  tokfix();
14176  if (nondigit) goto trailing_uc;
14177  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14178  return set_integer_literal(rb_cstr_to_inum(tok(), 8, FALSE), suffix);
14179  }
14180  if (nondigit) {
14181  pushback(c);
14182  goto trailing_uc;
14183  }
14184  }
14185  if (c > '7' && c <= '9') {
14186  invalid_octal:
14187  yyerror("Invalid octal digit");
14188  }
14189  else if (c == '.' || c == 'e' || c == 'E') {
14190  tokadd('0');
14191  }
14192  else {
14193  pushback(c);
14194  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14195  return set_integer_literal(INT2FIX(0), suffix);
14196  }
14197  }
14198 
14199  for (;;) {
14200  switch (c) {
14201  case '0': case '1': case '2': case '3': case '4':
14202  case '5': case '6': case '7': case '8': case '9':
14203  nondigit = 0;
14204  tokadd(c);
14205  break;
14206 
14207  case '.':
14208  if (nondigit) goto trailing_uc;
14209  if (seen_point || seen_e) {
14210  goto decode_num;
14211  }
14212  else {
14213  int c0 = nextc();
14214  if (c0 == -1 || !ISDIGIT(c0)) {
14215  pushback(c0);
14216  goto decode_num;
14217  }
14218  c = c0;
14219  }
14220  seen_point = toklen();
14221  tokadd('.');
14222  tokadd(c);
14223  is_float++;
14224  nondigit = 0;
14225  break;
14226 
14227  case 'e':
14228  case 'E':
14229  if (nondigit) {
14230  pushback(c);
14231  c = nondigit;
14232  goto decode_num;
14233  }
14234  if (seen_e) {
14235  goto decode_num;
14236  }
14237  nondigit = c;
14238  c = nextc();
14239  if (c != '-' && c != '+' && !ISDIGIT(c)) {
14240  pushback(c);
14241  nondigit = 0;
14242  goto decode_num;
14243  }
14244  tokadd(nondigit);
14245  seen_e++;
14246  is_float++;
14247  tokadd(c);
14248  nondigit = (c == '-' || c == '+') ? c : 0;
14249  break;
14250 
14251  case '_': /* `_' in number just ignored */
14252  if (nondigit) goto decode_num;
14253  nondigit = c;
14254  break;
14255 
14256  default:
14257  goto decode_num;
14258  }
14259  c = nextc();
14260  }
14261 
14262  decode_num:
14263  pushback(c);
14264  if (nondigit) {
14265  char tmp[30];
14266  trailing_uc:
14267  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14268  yyerror(tmp);
14269  }
14270  tokfix();
14271  if (is_float) {
14272  int type = tFLOAT;
14273  VALUE v;
14274 
14275  suffix = number_literal_suffix(seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
14276  if (suffix & NUM_SUFFIX_R) {
14277  char *point = &tok()[seen_point];
14278  size_t fraclen = toklen()-seen_point-1;
14279  type = tRATIONAL;
14280  memmove(point, point+1, fraclen+1);
14281  v = rb_cstr_to_inum(tok(), 10, FALSE);
14282  v = rb_rational_new(v, rb_int_positive_pow(10, fraclen));
14283  }
14284  else {
14285  double d = strtod(tok(), 0);
14286  if (errno == ERANGE) {
14287  rb_warningS("Float %s out of range", tok());
14288  errno = 0;
14289  }
14290  v = DBL2NUM(d);
14291  }
14292  return set_number_literal(v, type, suffix);
14293  }
14294  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14295  return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
14296  }
14297 
14298  case ')':
14299  case ']':
14300  paren_nest--;
14301  case '}':
14302  COND_LEXPOP();
14303  CMDARG_LEXPOP();
14304  if (c == ')')
14305  lex_state = EXPR_ENDFN;
14306  else
14307  lex_state = EXPR_ENDARG;
14308  if (c == '}') {
14309  if (!brace_nest--) c = tSTRING_DEND;
14310  }
14311  return c;
14312 
14313  case ':':
14314  c = nextc();
14315  if (c == ':') {
14316  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14317  lex_state = EXPR_BEG;
14318  return tCOLON3;
14319  }
14320  lex_state = EXPR_DOT;
14321  return tCOLON2;
14322  }
14323  if (IS_END() || ISSPACE(c)) {
14324  pushback(c);
14325  warn_balanced(":", "symbol literal");
14326  lex_state = EXPR_BEG;
14327  return ':';
14328  }
14329  switch (c) {
14330  case '\'':
14331  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14332  break;
14333  case '"':
14334  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14335  break;
14336  default:
14337  pushback(c);
14338  break;
14339  }
14340  lex_state = EXPR_FNAME;
14341  return tSYMBEG;
14342 
14343  case '/':
14344  if (IS_lex_state(EXPR_BEG_ANY)) {
14345  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14346  return tREGEXP_BEG;
14347  }
14348  if ((c = nextc()) == '=') {
14349  set_yylval_id('/');
14350  lex_state = EXPR_BEG;
14351  return tOP_ASGN;
14352  }
14353  pushback(c);
14354  if (IS_SPCARG(c)) {
14355  (void)arg_ambiguous();
14356  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14357  return tREGEXP_BEG;
14358  }
14359  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14360  warn_balanced("/", "regexp literal");
14361  return '/';
14362 
14363  case '^':
14364  if ((c = nextc()) == '=') {
14365  set_yylval_id('^');
14366  lex_state = EXPR_BEG;
14367  return tOP_ASGN;
14368  }
14369  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14370  pushback(c);
14371  return '^';
14372 
14373  case ';':
14374  lex_state = EXPR_BEG;
14375  command_start = TRUE;
14376  return ';';
14377 
14378  case ',':
14379  lex_state = EXPR_BEG;
14380  return ',';
14381 
14382  case '~':
14383  if (IS_AFTER_OPERATOR()) {
14384  if ((c = nextc()) != '@') {
14385  pushback(c);
14386  }
14387  lex_state = EXPR_ARG;
14388  }
14389  else {
14390  lex_state = EXPR_BEG;
14391  }
14392  return '~';
14393 
14394  case '(':
14395  if (IS_BEG()) {
14396  c = tLPAREN;
14397  }
14398  else if (IS_SPCARG(-1)) {
14399  c = tLPAREN_ARG;
14400  }
14401  paren_nest++;
14402  COND_PUSH(0);
14403  CMDARG_PUSH(0);
14404  lex_state = EXPR_BEG;
14405  return c;
14406 
14407  case '[':
14408  paren_nest++;
14409  if (IS_AFTER_OPERATOR()) {
14410  lex_state = EXPR_ARG;
14411  if ((c = nextc()) == ']') {
14412  if ((c = nextc()) == '=') {
14413  return tASET;
14414  }
14415  pushback(c);
14416  return tAREF;
14417  }
14418  pushback(c);
14419  return '[';
14420  }
14421  else if (IS_BEG()) {
14422  c = tLBRACK;
14423  }
14424  else if (IS_ARG() && space_seen) {
14425  c = tLBRACK;
14426  }
14427  lex_state = EXPR_BEG;
14428  COND_PUSH(0);
14429  CMDARG_PUSH(0);
14430  return c;
14431 
14432  case '{':
14433  ++brace_nest;
14434  if (lpar_beg && lpar_beg == paren_nest) {
14435  lex_state = EXPR_BEG;
14436  lpar_beg = 0;
14437  --paren_nest;
14438  COND_PUSH(0);
14439  CMDARG_PUSH(0);
14440  return tLAMBEG;
14441  }
14442  if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14443  c = '{'; /* block (primary) */
14444  else if (IS_lex_state(EXPR_ENDARG))
14445  c = tLBRACE_ARG; /* block (expr) */
14446  else
14447  c = tLBRACE; /* hash */
14448  COND_PUSH(0);
14449  CMDARG_PUSH(0);
14450  lex_state = EXPR_BEG;
14451  if (c != tLBRACE) command_start = TRUE;
14452  return c;
14453 
14454  case '\\':
14455  c = nextc();
14456  if (c == '\n') {
14457  space_seen = 1;
14458 #ifdef RIPPER
14459  ripper_dispatch_scan_event(parser, tSP);
14460 #endif
14461  goto retry; /* skip \\n */
14462  }
14463  pushback(c);
14464  return '\\';
14465 
14466  case '%':
14467  if (IS_lex_state(EXPR_BEG_ANY)) {
14468  int term;
14469  int paren;
14470 
14471  c = nextc();
14472  quotation:
14473  if (c == -1 || !ISALNUM(c)) {
14474  term = c;
14475  c = 'Q';
14476  }
14477  else {
14478  term = nextc();
14479  if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14480  yyerror("unknown type of %string");
14481  return 0;
14482  }
14483  }
14484  if (c == -1 || term == -1) {
14485  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14486  return 0;
14487  }
14488  paren = term;
14489  if (term == '(') term = ')';
14490  else if (term == '[') term = ']';
14491  else if (term == '{') term = '}';
14492  else if (term == '<') term = '>';
14493  else paren = 0;
14494 
14495  switch (c) {
14496  case 'Q':
14497  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14498  return tSTRING_BEG;
14499 
14500  case 'q':
14501  lex_strterm = NEW_STRTERM(str_squote, term, paren);
14502  return tSTRING_BEG;
14503 
14504  case 'W':
14505  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14506  do {c = nextc();} while (ISSPACE(c));
14507  pushback(c);
14508  return tWORDS_BEG;
14509 
14510  case 'w':
14511  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14512  do {c = nextc();} while (ISSPACE(c));
14513  pushback(c);
14514  return tQWORDS_BEG;
14515 
14516  case 'I':
14517  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14518  do {c = nextc();} while (ISSPACE(c));
14519  pushback(c);
14520  return tSYMBOLS_BEG;
14521 
14522  case 'i':
14523  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14524  do {c = nextc();} while (ISSPACE(c));
14525  pushback(c);
14526  return tQSYMBOLS_BEG;
14527 
14528  case 'x':
14529  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14530  return tXSTRING_BEG;
14531 
14532  case 'r':
14533  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14534  return tREGEXP_BEG;
14535 
14536  case 's':
14537  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14538  lex_state = EXPR_FNAME;
14539  return tSYMBEG;
14540 
14541  default:
14542  yyerror("unknown type of %string");
14543  return 0;
14544  }
14545  }
14546  if ((c = nextc()) == '=') {
14547  set_yylval_id('%');
14548  lex_state = EXPR_BEG;
14549  return tOP_ASGN;
14550  }
14551  if (IS_SPCARG(c)) {
14552  goto quotation;
14553  }
14554  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14555  pushback(c);
14556  warn_balanced("%%", "string literal");
14557  return '%';
14558 
14559  case '$':
14560  lex_state = EXPR_END;
14561  newtok();
14562  c = nextc();
14563  switch (c) {
14564  case '_': /* $_: last read line string */
14565  c = nextc();
14566  if (parser_is_identchar()) {
14567  tokadd('$');
14568  tokadd('_');
14569  break;
14570  }
14571  pushback(c);
14572  c = '_';
14573  /* fall through */
14574  case '~': /* $~: match-data */
14575  case '*': /* $*: argv */
14576  case '$': /* $$: pid */
14577  case '?': /* $?: last status */
14578  case '!': /* $!: error string */
14579  case '@': /* $@: error position */
14580  case '/': /* $/: input record separator */
14581  case '\\': /* $\: output record separator */
14582  case ';': /* $;: field separator */
14583  case ',': /* $,: output field separator */
14584  case '.': /* $.: last read line number */
14585  case '=': /* $=: ignorecase */
14586  case ':': /* $:: load path */
14587  case '<': /* $<: reading filename */
14588  case '>': /* $>: default output handle */
14589  case '\"': /* $": already loaded files */
14590  tokadd('$');
14591  tokadd(c);
14592  goto gvar;
14593 
14594  case '-':
14595  tokadd('$');
14596  tokadd(c);
14597  c = nextc();
14598  if (parser_is_identchar()) {
14599  if (tokadd_mbchar(c) == -1) return 0;
14600  }
14601  else {
14602  pushback(c);
14603  pushback('-');
14604  return '$';
14605  }
14606  gvar:
14607  set_yylval_name(rb_intern3(tok(), tokidx, current_enc));
14608  return tGVAR;
14609 
14610  case '&': /* $&: last match */
14611  case '`': /* $`: string before last match */
14612  case '\'': /* $': string after last match */
14613  case '+': /* $+: string matches last paren. */
14614  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14615  tokadd('$');
14616  tokadd(c);
14617  goto gvar;
14618  }
14619  set_yylval_node(NEW_BACK_REF(c));
14620  return tBACK_REF;
14621 
14622  case '1': case '2': case '3':
14623  case '4': case '5': case '6':
14624  case '7': case '8': case '9':
14625  tokadd('$');
14626  do {
14627  tokadd(c);
14628  c = nextc();
14629  } while (c != -1 && ISDIGIT(c));
14630  pushback(c);
14631  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14632  tokfix();
14633  set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
14634  return tNTH_REF;
14635 
14636  default:
14637  if (!parser_is_identchar()) {
14638  pushback(c);
14639  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14640  return 0;
14641  }
14642  case '0':
14643  tokadd('$');
14644  }
14645  break;
14646 
14647  case '@':
14648  c = nextc();
14649  newtok();
14650  tokadd('@');
14651  if (c == '@') {
14652  tokadd('@');
14653  c = nextc();
14654  }
14655  if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14656  pushback(c);
14657  if (tokidx == 1) {
14658  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14659  }
14660  else {
14661  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14662  }
14663  return 0;
14664  }
14665  break;
14666 
14667  case '_':
14668  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14669  ruby__end__seen = 1;
14670  parser->eofp = Qtrue;
14671 #ifndef RIPPER
14672  return -1;
14673 #else
14674  lex_goto_eol(parser);
14675  ripper_dispatch_scan_event(parser, k__END__);
14676  return 0;
14677 #endif
14678  }
14679  newtok();
14680  break;
14681 
14682  default:
14683  if (!parser_is_identchar()) {
14684  compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14685  goto retry;
14686  }
14687 
14688  newtok();
14689  break;
14690  }
14691 
14692  mb = ENC_CODERANGE_7BIT;
14693  do {
14694  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14695  if (tokadd_mbchar(c) == -1) return 0;
14696  c = nextc();
14697  } while (parser_is_identchar());
14698  switch (tok()[0]) {
14699  case '@': case '$':
14700  pushback(c);
14701  break;
14702  default:
14703  if ((c == '!' || c == '?') && !peek('=')) {
14704  tokadd(c);
14705  }
14706  else {
14707  pushback(c);
14708  }
14709  }
14710  tokfix();
14711 
14712  {
14713  int result = 0;
14714 
14715  last_state = lex_state;
14716  switch (tok()[0]) {
14717  case '$':
14718  lex_state = EXPR_END;
14719  result = tGVAR;
14720  break;
14721  case '@':
14722  lex_state = EXPR_END;
14723  if (tok()[1] == '@')
14724  result = tCVAR;
14725  else
14726  result = tIVAR;
14727  break;
14728 
14729  default:
14730  if (toklast() == '!' || toklast() == '?') {
14731  result = tFID;
14732  }
14733  else {
14734  if (IS_lex_state(EXPR_FNAME)) {
14735  if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14736  (!peek('=') || (peek_n('>', 1)))) {
14737  result = tIDENTIFIER;
14738  tokadd(c);
14739  tokfix();
14740  }
14741  else {
14742  pushback(c);
14743  }
14744  }
14745  if (result == 0 && ISUPPER(tok()[0])) {
14746  result = tCONSTANT;
14747  }
14748  else {
14749  result = tIDENTIFIER;
14750  }
14751  }
14752 
14753  if (IS_LABEL_POSSIBLE()) {
14754  if (IS_LABEL_SUFFIX(0)) {
14755  lex_state = EXPR_LABELARG;
14756  nextc();
14757  set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb)));
14758  return tLABEL;
14759  }
14760  }
14761  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14762  const struct kwtable *kw;
14763 
14764  /* See if it is a reserved word. */
14765  kw = rb_reserved_word(tok(), toklen());
14766  if (kw) {
14767  enum lex_state_e state = lex_state;
14768  lex_state = kw->state;
14769  if (IS_lex_state_for(state, EXPR_FNAME)) {
14770  set_yylval_name(rb_intern(kw->name));
14771  return kw->id[0];
14772  }
14773  if (IS_lex_state(EXPR_BEG)) {
14774  command_start = TRUE;
14775  }
14776  if (kw->id[0] == keyword_do) {
14777  if (lpar_beg && lpar_beg == paren_nest) {
14778  lpar_beg = 0;
14779  --paren_nest;
14780  return keyword_do_LAMBDA;
14781  }
14782  if (COND_P()) return keyword_do_cond;
14783  if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG))
14784  return keyword_do_block;
14785  if (IS_lex_state_for(state, (EXPR_BEG | EXPR_ENDARG)))
14786  return keyword_do_block;
14787  return keyword_do;
14788  }
14789  if (IS_lex_state_for(state, (EXPR_BEG | EXPR_VALUE)))
14790  return kw->id[0];
14791  else {
14792  if (kw->id[0] != kw->id[1])
14793  lex_state = EXPR_BEG;
14794  return kw->id[1];
14795  }
14796  }
14797  }
14798 
14799  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14800  if (cmd_state) {
14801  lex_state = EXPR_CMDARG;
14802  }
14803  else {
14804  lex_state = EXPR_ARG;
14805  }
14806  }
14807  else if (lex_state == EXPR_FNAME) {
14808  lex_state = EXPR_ENDFN;
14809  }
14810  else {
14811  lex_state = EXPR_END;
14812  }
14813  }
14814  {
14815  ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14816 
14817  set_yylval_name(ident);
14818  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14819  is_local_id(ident) && lvar_defined(ident)) {
14820  lex_state = EXPR_END;
14821  }
14822  }
14823  return result;
14824  }
14825 }
14826 
14827 #if YYPURE
14828 static int
14829 yylex(void *lval, void *p)
14830 #else
14831 yylex(void *p)
14832 #endif
14833 {
14834  struct parser_params *parser = (struct parser_params*)p;
14835  int t;
14836 
14837 #if YYPURE
14838  parser->parser_yylval = lval;
14839  parser->parser_yylval->val = Qundef;
14840 #endif
14841  t = parser_yylex(parser);
14842 #ifdef RIPPER
14843  if (!NIL_P(parser->delayed)) {
14844  ripper_dispatch_delayed_token(parser, t);
14845  return t;
14846  }
14847  if (t != 0)
14848  ripper_dispatch_scan_event(parser, t);
14849 #endif
14850 
14851  return t;
14852 }
14853 
14854 #ifndef RIPPER
14855 static NODE*
14856 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14857 {
14858  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14859  nd_set_line(n, ruby_sourceline);
14860  return n;
14861 }
14862 
14863 static enum node_type
14864 nodetype(NODE *node) /* for debug */
14865 {
14866  return (enum node_type)nd_type(node);
14867 }
14868 
14869 static int
14870 nodeline(NODE *node)
14871 {
14872  return nd_line(node);
14873 }
14874 
14875 static NODE*
14876 newline_node(NODE *node)
14877 {
14878  if (node) {
14879  node = remove_begin(node);
14880  node->flags |= NODE_FL_NEWLINE;
14881  }
14882  return node;
14883 }
14884 
14885 static void
14886 fixpos(NODE *node, NODE *orig)
14887 {
14888  if (!node) return;
14889  if (!orig) return;
14890  if (orig == (NODE*)1) return;
14891  nd_set_line(node, nd_line(orig));
14892 }
14893 
14894 static void
14895 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14896 {
14897  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14898 }
14899 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14900 
14901 static void
14902 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14903 {
14904  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14905 }
14906 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14907 
14908 static NODE*
14909 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14910 {
14911  NODE *end, *h = head, *nd;
14912 
14913  if (tail == 0) return head;
14914 
14915  if (h == 0) return tail;
14916  switch (nd_type(h)) {
14917  case NODE_LIT:
14918  case NODE_STR:
14919  case NODE_SELF:
14920  case NODE_TRUE:
14921  case NODE_FALSE:
14922  case NODE_NIL:
14923  parser_warning(h, "unused literal ignored");
14924  return tail;
14925  default:
14926  h = end = NEW_BLOCK(head);
14927  end->nd_end = end;
14928  fixpos(end, head);
14929  head = end;
14930  break;
14931  case NODE_BLOCK:
14932  end = h->nd_end;
14933  break;
14934  }
14935 
14936  nd = end->nd_head;
14937  switch (nd_type(nd)) {
14938  case NODE_RETURN:
14939  case NODE_BREAK:
14940  case NODE_NEXT:
14941  case NODE_REDO:
14942  case NODE_RETRY:
14943  if (RTEST(ruby_verbose)) {
14944  parser_warning(tail, "statement not reached");
14945  }
14946  break;
14947 
14948  default:
14949  break;
14950  }
14951 
14952  if (nd_type(tail) != NODE_BLOCK) {
14953  tail = NEW_BLOCK(tail);
14954  tail->nd_end = tail;
14955  }
14956  end->nd_next = tail;
14957  h->nd_end = tail->nd_end;
14958  return head;
14959 }
14960 
14961 /* append item to the list */
14962 static NODE*
14963 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14964 {
14965  NODE *last;
14966 
14967  if (list == 0) return NEW_LIST(item);
14968  if (list->nd_next) {
14969  last = list->nd_next->nd_end;
14970  }
14971  else {
14972  last = list;
14973  }
14974 
14975  list->nd_alen += 1;
14976  last->nd_next = NEW_LIST(item);
14977  list->nd_next->nd_end = last->nd_next;
14978  return list;
14979 }
14980 
14981 /* concat two lists */
14982 static NODE*
14983 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14984 {
14985  NODE *last;
14986 
14987  if (head->nd_next) {
14988  last = head->nd_next->nd_end;
14989  }
14990  else {
14991  last = head;
14992  }
14993 
14994  head->nd_alen += tail->nd_alen;
14995  last->nd_next = tail;
14996  if (tail->nd_next) {
14997  head->nd_next->nd_end = tail->nd_next->nd_end;
14998  }
14999  else {
15000  head->nd_next->nd_end = tail;
15001  }
15002 
15003  return head;
15004 }
15005 
15006 static int
15007 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
15008 {
15009  if (NIL_P(tail)) return 1;
15010  if (!rb_enc_compatible(head, tail)) {
15011  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
15012  rb_enc_name(rb_enc_get(head)),
15013  rb_enc_name(rb_enc_get(tail)));
15014  rb_str_resize(head, 0);
15015  rb_str_resize(tail, 0);
15016  return 0;
15017  }
15018  rb_str_buf_append(head, tail);
15019  return 1;
15020 }
15021 
15022 /* concat two string literals */
15023 static NODE *
15024 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
15025 {
15026  enum node_type htype;
15027  NODE *headlast;
15028  VALUE lit;
15029 
15030  if (!head) return tail;
15031  if (!tail) return head;
15032 
15033  htype = nd_type(head);
15034  if (htype == NODE_EVSTR) {
15035  NODE *node = NEW_DSTR(Qnil);
15036  head = list_append(node, head);
15037  htype = NODE_DSTR;
15038  }
15039  switch (nd_type(tail)) {
15040  case NODE_STR:
15041  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
15042  nd_type(headlast) == NODE_STR) {
15043  htype = NODE_STR;
15044  lit = headlast->nd_lit;
15045  }
15046  else {
15047  lit = head->nd_lit;
15048  }
15049  if (htype == NODE_STR) {
15050  if (!literal_concat0(parser, lit, tail->nd_lit)) {
15051  error:
15052  rb_gc_force_recycle((VALUE)head);
15053  rb_gc_force_recycle((VALUE)tail);
15054  return 0;
15055  }
15056  rb_gc_force_recycle((VALUE)tail);
15057  }
15058  else {
15059  list_append(head, tail);
15060  }
15061  break;
15062 
15063  case NODE_DSTR:
15064  if (htype == NODE_STR) {
15065  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
15066  goto error;
15067  tail->nd_lit = head->nd_lit;
15068  rb_gc_force_recycle((VALUE)head);
15069  head = tail;
15070  }
15071  else if (NIL_P(tail->nd_lit)) {
15072  append:
15073  head->nd_alen += tail->nd_alen - 1;
15074  head->nd_next->nd_end->nd_next = tail->nd_next;
15075  head->nd_next->nd_end = tail->nd_next->nd_end;
15076  rb_gc_force_recycle((VALUE)tail);
15077  }
15078  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
15079  nd_type(headlast) == NODE_STR) {
15080  lit = headlast->nd_lit;
15081  if (!literal_concat0(parser, lit, tail->nd_lit))
15082  goto error;
15083  tail->nd_lit = Qnil;
15084  goto append;
15085  }
15086  else {
15087  nd_set_type(tail, NODE_ARRAY);
15088  tail->nd_head = NEW_STR(tail->nd_lit);
15089  list_concat(head, tail);
15090  }
15091  break;
15092 
15093  case NODE_EVSTR:
15094  if (htype == NODE_STR) {
15095  nd_set_type(head, NODE_DSTR);
15096  head->nd_alen = 1;
15097  }
15098  list_append(head, tail);
15099  break;
15100  }
15101  return head;
15102 }
15103 
15104 static NODE *
15105 evstr2dstr_gen(struct parser_params *parser, NODE *node)
15106 {
15107  if (nd_type(node) == NODE_EVSTR) {
15108  node = list_append(NEW_DSTR(Qnil), node);
15109  }
15110  return node;
15111 }
15112 
15113 static NODE *
15114 new_evstr_gen(struct parser_params *parser, NODE *node)
15115 {
15116  NODE *head = node;
15117 
15118  if (node) {
15119  switch (nd_type(node)) {
15120  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
15121  return node;
15122  }
15123  }
15124  return NEW_EVSTR(head);
15125 }
15126 
15127 static NODE *
15128 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
15129 {
15130  value_expr(recv);
15131  value_expr(arg1);
15132  return NEW_CALL(recv, id, NEW_LIST(arg1));
15133 }
15134 
15135 static NODE *
15136 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
15137 {
15138  value_expr(recv);
15139  return NEW_CALL(recv, id, 0);
15140 }
15141 
15142 static NODE*
15143 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15144 {
15145  value_expr(node1);
15146  value_expr(node2);
15147  if (node1) {
15148  switch (nd_type(node1)) {
15149  case NODE_DREGX:
15150  case NODE_DREGX_ONCE:
15151  return NEW_MATCH2(node1, node2);
15152 
15153  case NODE_LIT:
15154  if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
15155  return NEW_MATCH2(node1, node2);
15156  }
15157  }
15158  }
15159 
15160  if (node2) {
15161  switch (nd_type(node2)) {
15162  case NODE_DREGX:
15163  case NODE_DREGX_ONCE:
15164  return NEW_MATCH3(node2, node1);
15165 
15166  case NODE_LIT:
15167  if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
15168  return NEW_MATCH3(node2, node1);
15169  }
15170  }
15171  }
15172 
15173  return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
15174 }
15175 
15176 static NODE*
15177 gettable_gen(struct parser_params *parser, ID id)
15178 {
15179  switch (id) {
15180  case keyword_self:
15181  return NEW_SELF();
15182  case keyword_nil:
15183  return NEW_NIL();
15184  case keyword_true:
15185  return NEW_TRUE();
15186  case keyword_false:
15187  return NEW_FALSE();
15188  case keyword__FILE__:
15189  return NEW_STR(rb_str_dup(ruby_sourcefile_string));
15190  case keyword__LINE__:
15191  return NEW_LIT(INT2FIX(tokline));
15192  case keyword__ENCODING__:
15193  return NEW_LIT(rb_enc_from_encoding(current_enc));
15194  }
15195  switch (id_type(id)) {
15196  case ID_LOCAL:
15197  if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
15198  if (local_id(id)) return NEW_LVAR(id);
15199  /* method call without arguments */
15200  return NEW_VCALL(id);
15201  case ID_GLOBAL:
15202  return NEW_GVAR(id);
15203  case ID_INSTANCE:
15204  return NEW_IVAR(id);
15205  case ID_CONST:
15206  return NEW_CONST(id);
15207  case ID_CLASS:
15208  return NEW_CVAR(id);
15209  }
15210  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15211  return 0;
15212 }
15213 #else /* !RIPPER */
15214 static int
15215 id_is_var_gen(struct parser_params *parser, ID id)
15216 {
15217  if (is_notop_id(id)) {
15218  switch (id & ID_SCOPE_MASK) {
15219  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
15220  return 1;
15221  case ID_LOCAL:
15222  if (dyna_in_block() && dvar_defined(id)) return 1;
15223  if (local_id(id)) return 1;
15224  /* method call without arguments */
15225  return 0;
15226  }
15227  }
15228  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15229  return 0;
15230 }
15231 #endif /* !RIPPER */
15232 
15233 #if PARSER_DEBUG
15234 static const char *
15235 lex_state_name(enum lex_state_e state)
15236 {
15237  static const char names[][12] = {
15238  "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG",
15239  "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS",
15240  "EXPR_VALUE",
15241  };
15242 
15243  if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
15244  return names[ffs(state)];
15245  return NULL;
15246 }
15247 #endif
15248 
15249 #ifdef RIPPER
15250 static VALUE
15251 assignable_gen(struct parser_params *parser, VALUE lhs)
15252 #else
15253 static NODE*
15254 assignable_gen(struct parser_params *parser, ID id, NODE *val)
15255 #endif
15256 {
15257 #ifdef RIPPER
15258  ID id = get_id(lhs);
15259 # define assignable_result(x) get_value(lhs)
15260 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
15261 #else
15262 # define assignable_result(x) (x)
15263 #endif
15264  if (!id) return assignable_result(0);
15265  switch (id) {
15266  case keyword_self:
15267  yyerror("Can't change the value of self");
15268  goto error;
15269  case keyword_nil:
15270  yyerror("Can't assign to nil");
15271  goto error;
15272  case keyword_true:
15273  yyerror("Can't assign to true");
15274  goto error;
15275  case keyword_false:
15276  yyerror("Can't assign to false");
15277  goto error;
15278  case keyword__FILE__:
15279  yyerror("Can't assign to __FILE__");
15280  goto error;
15281  case keyword__LINE__:
15282  yyerror("Can't assign to __LINE__");
15283  goto error;
15284  case keyword__ENCODING__:
15285  yyerror("Can't assign to __ENCODING__");
15286  goto error;
15287  }
15288  switch (id_type(id)) {
15289  case ID_LOCAL:
15290  if (dyna_in_block()) {
15291  if (dvar_curr(id)) {
15292  return assignable_result(NEW_DASGN_CURR(id, val));
15293  }
15294  else if (dvar_defined(id)) {
15295  return assignable_result(NEW_DASGN(id, val));
15296  }
15297  else if (local_id(id)) {
15298  return assignable_result(NEW_LASGN(id, val));
15299  }
15300  else {
15301  dyna_var(id);
15302  return assignable_result(NEW_DASGN_CURR(id, val));
15303  }
15304  }
15305  else {
15306  if (!local_id(id)) {
15307  local_var(id);
15308  }
15309  return assignable_result(NEW_LASGN(id, val));
15310  }
15311  break;
15312  case ID_GLOBAL:
15313  return assignable_result(NEW_GASGN(id, val));
15314  case ID_INSTANCE:
15315  return assignable_result(NEW_IASGN(id, val));
15316  case ID_CONST:
15317  if (!in_def && !in_single)
15318  return assignable_result(NEW_CDECL(id, val, 0));
15319  yyerror("dynamic constant assignment");
15320  break;
15321  case ID_CLASS:
15322  return assignable_result(NEW_CVASGN(id, val));
15323  default:
15324  compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15325  }
15326  error:
15327  return assignable_result(0);
15328 #undef assignable_result
15329 #undef parser_yyerror
15330 }
15331 
15332 static int
15333 is_private_local_id(ID name)
15334 {
15335  VALUE s;
15336  if (name == idUScore) return 1;
15337  if (!is_local_id(name)) return 0;
15338  s = rb_id2str(name);
15339  if (!s) return 0;
15340  return RSTRING_PTR(s)[0] == '_';
15341 }
15342 
15343 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15344 
15345 static int
15346 shadowing_lvar_0(struct parser_params *parser, ID name)
15347 {
15348  if (is_private_local_id(name)) return 1;
15349  if (dyna_in_block()) {
15350  if (dvar_curr(name)) {
15351  yyerror("duplicated argument name");
15352  }
15353  else if (dvar_defined_get(name) || local_id(name)) {
15354  rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15355  vtable_add(lvtbl->vars, name);
15356  if (lvtbl->used) {
15357  vtable_add(lvtbl->used, (ID)ruby_sourceline | LVAR_USED);
15358  }
15359  return 0;
15360  }
15361  }
15362  else {
15363  if (local_id(name)) {
15364  yyerror("duplicated argument name");
15365  }
15366  }
15367  return 1;
15368 }
15369 
15370 static ID
15371 shadowing_lvar_gen(struct parser_params *parser, ID name)
15372 {
15373  shadowing_lvar_0(parser, name);
15374  return name;
15375 }
15376 
15377 static void
15378 new_bv_gen(struct parser_params *parser, ID name)
15379 {
15380  if (!name) return;
15381  if (!is_local_id(name)) {
15382  compile_error(PARSER_ARG "invalid local variable - %s",
15383  rb_id2name(name));
15384  return;
15385  }
15386  if (!shadowing_lvar_0(parser, name)) return;
15387  dyna_var(name);
15388 }
15389 
15390 #ifndef RIPPER
15391 static NODE *
15392 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15393 {
15394  if (recv && nd_type(recv) == NODE_SELF)
15395  recv = (NODE *)1;
15396  return NEW_ATTRASGN(recv, tASET, idx);
15397 }
15398 
15399 static void
15400 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15401 {
15402  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15403  compile_error(PARSER_ARG "both block arg and actual block given");
15404  }
15405 }
15406 
15407 static const char id_type_names[][9] = {
15408  "LOCAL",
15409  "INSTANCE",
15410  "", /* INSTANCE2 */
15411  "GLOBAL",
15412  "ATTRSET",
15413  "CONST",
15414  "CLASS",
15415  "JUNK",
15416 };
15417 
15418 ID
15419 rb_id_attrset(ID id)
15420 {
15421  if (!is_notop_id(id)) {
15422  switch (id) {
15423  case tAREF: case tASET:
15424  return tASET; /* only exception */
15425  }
15426  rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
15427  }
15428  else {
15429  int scope = (int)(id & ID_SCOPE_MASK);
15430  switch (scope) {
15431  case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
15432  case ID_CONST: case ID_CLASS: case ID_JUNK:
15433  break;
15434  case ID_ATTRSET:
15435  return id;
15436  default:
15437  rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset",
15438  id_type_names[scope], ID2SYM(id));
15439 
15440  }
15441  }
15442  id &= ~ID_SCOPE_MASK;
15443  id |= ID_ATTRSET;
15444  return id;
15445 }
15446 
15447 static NODE *
15448 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15449 {
15450  if (recv && nd_type(recv) == NODE_SELF)
15451  recv = (NODE *)1;
15452  return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15453 }
15454 
15455 static void
15456 rb_backref_error_gen(struct parser_params *parser, NODE *node)
15457 {
15458  switch (nd_type(node)) {
15459  case NODE_NTH_REF:
15460  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15461  break;
15462  case NODE_BACK_REF:
15463  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15464  break;
15465  }
15466 }
15467 
15468 static NODE *
15469 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15470 {
15471  if (!node2) return node1;
15472  switch (nd_type(node1)) {
15473  case NODE_BLOCK_PASS:
15474  if (node1->nd_head)
15475  node1->nd_head = arg_concat(node1->nd_head, node2);
15476  else
15477  node1->nd_head = NEW_LIST(node2);
15478  return node1;
15479  case NODE_ARGSPUSH:
15480  if (nd_type(node2) != NODE_ARRAY) break;
15481  node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15482  nd_set_type(node1, NODE_ARGSCAT);
15483  return node1;
15484  case NODE_ARGSCAT:
15485  if (nd_type(node2) != NODE_ARRAY ||
15486  nd_type(node1->nd_body) != NODE_ARRAY) break;
15487  node1->nd_body = list_concat(node1->nd_body, node2);
15488  return node1;
15489  }
15490  return NEW_ARGSCAT(node1, node2);
15491 }
15492 
15493 static NODE *
15494 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15495 {
15496  if (!node1) return NEW_LIST(node2);
15497  switch (nd_type(node1)) {
15498  case NODE_ARRAY:
15499  return list_append(node1, node2);
15500  case NODE_BLOCK_PASS:
15501  node1->nd_head = arg_append(node1->nd_head, node2);
15502  return node1;
15503  case NODE_ARGSPUSH:
15504  node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15505  nd_set_type(node1, NODE_ARGSCAT);
15506  return node1;
15507  }
15508  return NEW_ARGSPUSH(node1, node2);
15509 }
15510 
15511 static NODE *
15512 splat_array(NODE* node)
15513 {
15514  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15515  if (nd_type(node) == NODE_ARRAY) return node;
15516  return 0;
15517 }
15518 
15519 static NODE *
15520 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15521 {
15522  if (!lhs) return 0;
15523 
15524  switch (nd_type(lhs)) {
15525  case NODE_GASGN:
15526  case NODE_IASGN:
15527  case NODE_IASGN2:
15528  case NODE_LASGN:
15529  case NODE_DASGN:
15530  case NODE_DASGN_CURR:
15531  case NODE_MASGN:
15532  case NODE_CDECL:
15533  case NODE_CVASGN:
15534  lhs->nd_value = rhs;
15535  break;
15536 
15537  case NODE_ATTRASGN:
15538  case NODE_CALL:
15539  lhs->nd_args = arg_append(lhs->nd_args, rhs);
15540  break;
15541 
15542  default:
15543  /* should not happen */
15544  break;
15545  }
15546 
15547  return lhs;
15548 }
15549 
15550 static int
15551 value_expr_gen(struct parser_params *parser, NODE *node)
15552 {
15553  int cond = 0;
15554 
15555  if (!node) {
15556  rb_warning0("empty expression");
15557  }
15558  while (node) {
15559  switch (nd_type(node)) {
15560  case NODE_RETURN:
15561  case NODE_BREAK:
15562  case NODE_NEXT:
15563  case NODE_REDO:
15564  case NODE_RETRY:
15565  if (!cond) yyerror("void value expression");
15566  /* or "control never reach"? */
15567  return FALSE;
15568 
15569  case NODE_BLOCK:
15570  while (node->nd_next) {
15571  node = node->nd_next;
15572  }
15573  node = node->nd_head;
15574  break;
15575 
15576  case NODE_BEGIN:
15577  node = node->nd_body;
15578  break;
15579 
15580  case NODE_IF:
15581  if (!node->nd_body) {
15582  node = node->nd_else;
15583  break;
15584  }
15585  else if (!node->nd_else) {
15586  node = node->nd_body;
15587  break;
15588  }
15589  if (!value_expr(node->nd_body)) return FALSE;
15590  node = node->nd_else;
15591  break;
15592 
15593  case NODE_AND:
15594  case NODE_OR:
15595  cond = 1;
15596  node = node->nd_2nd;
15597  break;
15598 
15599  default:
15600  return TRUE;
15601  }
15602  }
15603 
15604  return TRUE;
15605 }
15606 
15607 static void
15608 void_expr_gen(struct parser_params *parser, NODE *node)
15609 {
15610  const char *useless = 0;
15611 
15612  if (!RTEST(ruby_verbose)) return;
15613 
15614  if (!node) return;
15615  switch (nd_type(node)) {
15616  case NODE_CALL:
15617  switch (node->nd_mid) {
15618  case '+':
15619  case '-':
15620  case '*':
15621  case '/':
15622  case '%':
15623  case tPOW:
15624  case tUPLUS:
15625  case tUMINUS:
15626  case '|':
15627  case '^':
15628  case '&':
15629  case tCMP:
15630  case '>':
15631  case tGEQ:
15632  case '<':
15633  case tLEQ:
15634  case tEQ:
15635  case tNEQ:
15636  useless = rb_id2name(node->nd_mid);
15637  break;
15638  }
15639  break;
15640 
15641  case NODE_LVAR:
15642  case NODE_DVAR:
15643  case NODE_GVAR:
15644  case NODE_IVAR:
15645  case NODE_CVAR:
15646  case NODE_NTH_REF:
15647  case NODE_BACK_REF:
15648  useless = "a variable";
15649  break;
15650  case NODE_CONST:
15651  useless = "a constant";
15652  break;
15653  case NODE_LIT:
15654  case NODE_STR:
15655  case NODE_DSTR:
15656  case NODE_DREGX:
15657  case NODE_DREGX_ONCE:
15658  useless = "a literal";
15659  break;
15660  case NODE_COLON2:
15661  case NODE_COLON3:
15662  useless = "::";
15663  break;
15664  case NODE_DOT2:
15665  useless = "..";
15666  break;
15667  case NODE_DOT3:
15668  useless = "...";
15669  break;
15670  case NODE_SELF:
15671  useless = "self";
15672  break;
15673  case NODE_NIL:
15674  useless = "nil";
15675  break;
15676  case NODE_TRUE:
15677  useless = "true";
15678  break;
15679  case NODE_FALSE:
15680  useless = "false";
15681  break;
15682  case NODE_DEFINED:
15683  useless = "defined?";
15684  break;
15685  }
15686 
15687  if (useless) {
15688  int line = ruby_sourceline;
15689 
15690  ruby_sourceline = nd_line(node);
15691  rb_warnS("possibly useless use of %s in void context", useless);
15692  ruby_sourceline = line;
15693  }
15694 }
15695 
15696 static void
15697 void_stmts_gen(struct parser_params *parser, NODE *node)
15698 {
15699  if (!RTEST(ruby_verbose)) return;
15700  if (!node) return;
15701  if (nd_type(node) != NODE_BLOCK) return;
15702 
15703  for (;;) {
15704  if (!node->nd_next) return;
15705  void_expr0(node->nd_head);
15706  node = node->nd_next;
15707  }
15708 }
15709 
15710 static NODE *
15711 remove_begin(NODE *node)
15712 {
15713  NODE **n = &node, *n1 = node;
15714  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15715  *n = n1 = n1->nd_body;
15716  }
15717  return node;
15718 }
15719 
15720 static NODE *
15721 remove_begin_all(NODE *node)
15722 {
15723  NODE **n = &node, *n1 = node;
15724  while (n1 && nd_type(n1) == NODE_BEGIN) {
15725  *n = n1 = n1->nd_body;
15726  }
15727  return node;
15728 }
15729 
15730 static void
15731 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15732 {
15733  NODE *node = *body;
15734 
15735  if (!node) {
15736  *body = NEW_NIL();
15737  return;
15738  }
15739 #define subnodes(n1, n2) \
15740  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15741  (!node->n2) ? (body = &node->n1, 1) : \
15742  (reduce_nodes(&node->n1), body = &node->n2, 1))
15743 
15744  while (node) {
15745  int newline = (int)(node->flags & NODE_FL_NEWLINE);
15746  switch (nd_type(node)) {
15747  end:
15748  case NODE_NIL:
15749  *body = 0;
15750  return;
15751  case NODE_RETURN:
15752  *body = node = node->nd_stts;
15753  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15754  continue;
15755  case NODE_BEGIN:
15756  *body = node = node->nd_body;
15757  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15758  continue;
15759  case NODE_BLOCK:
15760  body = &node->nd_end->nd_head;
15761  break;
15762  case NODE_IF:
15763  if (subnodes(nd_body, nd_else)) break;
15764  return;
15765  case NODE_CASE:
15766  body = &node->nd_body;
15767  break;
15768  case NODE_WHEN:
15769  if (!subnodes(nd_body, nd_next)) goto end;
15770  break;
15771  case NODE_ENSURE:
15772  if (!subnodes(nd_head, nd_resq)) goto end;
15773  break;
15774  case NODE_RESCUE:
15775  if (node->nd_else) {
15776  body = &node->nd_resq;
15777  break;
15778  }
15779  if (!subnodes(nd_head, nd_resq)) goto end;
15780  break;
15781  default:
15782  return;
15783  }
15784  node = *body;
15785  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15786  }
15787 
15788 #undef subnodes
15789 }
15790 
15791 static int
15792 is_static_content(NODE *node)
15793 {
15794  if (!node) return 1;
15795  switch (nd_type(node)) {
15796  case NODE_HASH:
15797  if (!(node = node->nd_head)) break;
15798  case NODE_ARRAY:
15799  do {
15800  if (!is_static_content(node->nd_head)) return 0;
15801  } while ((node = node->nd_next) != 0);
15802  case NODE_LIT:
15803  case NODE_STR:
15804  case NODE_NIL:
15805  case NODE_TRUE:
15806  case NODE_FALSE:
15807  case NODE_ZARRAY:
15808  break;
15809  default:
15810  return 0;
15811  }
15812  return 1;
15813 }
15814 
15815 static int
15816 assign_in_cond(struct parser_params *parser, NODE *node)
15817 {
15818  switch (nd_type(node)) {
15819  case NODE_MASGN:
15820  yyerror("multiple assignment in conditional");
15821  return 1;
15822 
15823  case NODE_LASGN:
15824  case NODE_DASGN:
15825  case NODE_DASGN_CURR:
15826  case NODE_GASGN:
15827  case NODE_IASGN:
15828  break;
15829 
15830  default:
15831  return 0;
15832  }
15833 
15834  if (!node->nd_value) return 1;
15835  if (is_static_content(node->nd_value)) {
15836  /* reports always */
15837  parser_warn(node->nd_value, "found = in conditional, should be ==");
15838  }
15839  return 1;
15840 }
15841 
15842 static void
15843 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15844 {
15845  if (!e_option_supplied(parser)) parser_warn(node, str);
15846 }
15847 
15848 static void
15849 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15850 {
15851  if (!e_option_supplied(parser)) parser_warning(node, str);
15852 }
15853 
15854 static void
15855 fixup_nodes(NODE **rootnode)
15856 {
15857  NODE *node, *next, *head;
15858 
15859  for (node = *rootnode; node; node = next) {
15860  enum node_type type;
15861  VALUE val;
15862 
15863  next = node->nd_next;
15864  head = node->nd_head;
15865  rb_gc_force_recycle((VALUE)node);
15866  *rootnode = next;
15867  switch (type = nd_type(head)) {
15868  case NODE_DOT2:
15869  case NODE_DOT3:
15870  val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15871  type == NODE_DOT3);
15872  rb_gc_force_recycle((VALUE)head->nd_beg);
15873  rb_gc_force_recycle((VALUE)head->nd_end);
15874  nd_set_type(head, NODE_LIT);
15875  head->nd_lit = val;
15876  break;
15877  default:
15878  break;
15879  }
15880  }
15881 }
15882 
15883 static NODE *cond0(struct parser_params*,NODE*);
15884 
15885 static NODE*
15886 range_op(struct parser_params *parser, NODE *node)
15887 {
15888  enum node_type type;
15889 
15890  if (node == 0) return 0;
15891 
15892  type = nd_type(node);
15893  value_expr(node);
15894  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15895  warn_unless_e_option(parser, node, "integer literal in conditional range");
15896  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15897  }
15898  return cond0(parser, node);
15899 }
15900 
15901 static int
15902 literal_node(NODE *node)
15903 {
15904  if (!node) return 1; /* same as NODE_NIL */
15905  switch (nd_type(node)) {
15906  case NODE_LIT:
15907  case NODE_STR:
15908  case NODE_DSTR:
15909  case NODE_EVSTR:
15910  case NODE_DREGX:
15911  case NODE_DREGX_ONCE:
15912  case NODE_DSYM:
15913  return 2;
15914  case NODE_TRUE:
15915  case NODE_FALSE:
15916  case NODE_NIL:
15917  return 1;
15918  }
15919  return 0;
15920 }
15921 
15922 static NODE*
15923 cond0(struct parser_params *parser, NODE *node)
15924 {
15925  if (node == 0) return 0;
15926  assign_in_cond(parser, node);
15927 
15928  switch (nd_type(node)) {
15929  case NODE_DSTR:
15930  case NODE_EVSTR:
15931  case NODE_STR:
15932  rb_warn0("string literal in condition");
15933  break;
15934 
15935  case NODE_DREGX:
15936  case NODE_DREGX_ONCE:
15937  warning_unless_e_option(parser, node, "regex literal in condition");
15938  return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15939 
15940  case NODE_AND:
15941  case NODE_OR:
15942  node->nd_1st = cond0(parser, node->nd_1st);
15943  node->nd_2nd = cond0(parser, node->nd_2nd);
15944  break;
15945 
15946  case NODE_DOT2:
15947  case NODE_DOT3:
15948  node->nd_beg = range_op(parser, node->nd_beg);
15949  node->nd_end = range_op(parser, node->nd_end);
15950  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15951  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15952  if (!e_option_supplied(parser)) {
15953  int b = literal_node(node->nd_beg);
15954  int e = literal_node(node->nd_end);
15955  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15956  parser_warn(node, "range literal in condition");
15957  }
15958  }
15959  break;
15960 
15961  case NODE_DSYM:
15962  parser_warning(node, "literal in condition");
15963  break;
15964 
15965  case NODE_LIT:
15966  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
15967  warn_unless_e_option(parser, node, "regex literal in condition");
15968  nd_set_type(node, NODE_MATCH);
15969  }
15970  else {
15971  parser_warning(node, "literal in condition");
15972  }
15973  default:
15974  break;
15975  }
15976  return node;
15977 }
15978 
15979 static NODE*
15980 cond_gen(struct parser_params *parser, NODE *node)
15981 {
15982  if (node == 0) return 0;
15983  return cond0(parser, node);
15984 }
15985 
15986 static NODE*
15987 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15988 {
15989  value_expr(left);
15990  if (left && (enum node_type)nd_type(left) == type) {
15991  NODE *node = left, *second;
15992  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15993  node = second;
15994  }
15995  node->nd_2nd = NEW_NODE(type, second, right, 0);
15996  return left;
15997  }
15998  return NEW_NODE(type, left, right, 0);
15999 }
16000 
16001 static void
16002 no_blockarg(struct parser_params *parser, NODE *node)
16003 {
16004  if (node && nd_type(node) == NODE_BLOCK_PASS) {
16005  compile_error(PARSER_ARG "block argument should not be given");
16006  }
16007 }
16008 
16009 static NODE *
16010 ret_args_gen(struct parser_params *parser, NODE *node)
16011 {
16012  if (node) {
16013  no_blockarg(parser, node);
16014  if (nd_type(node) == NODE_ARRAY) {
16015  if (node->nd_next == 0) {
16016  node = node->nd_head;
16017  }
16018  else {
16019  nd_set_type(node, NODE_VALUES);
16020  }
16021  }
16022  }
16023  return node;
16024 }
16025 
16026 static NODE *
16027 new_yield_gen(struct parser_params *parser, NODE *node)
16028 {
16029  if (node) no_blockarg(parser, node);
16030 
16031  return NEW_YIELD(node);
16032 }
16033 
16034 static NODE*
16035 negate_lit(NODE *node)
16036 {
16037  switch (TYPE(node->nd_lit)) {
16038  case T_FIXNUM:
16039  node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
16040  break;
16041  case T_BIGNUM:
16042  case T_RATIONAL:
16043  case T_COMPLEX:
16044  node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
16045  break;
16046  case T_FLOAT:
16047 #if USE_FLONUM
16048  if (FLONUM_P(node->nd_lit)) {
16049  node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
16050  }
16051  else {
16052  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
16053  }
16054 #else
16055  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
16056 #endif
16057  break;
16058  default:
16059  rb_bug("unknown literal type passed to negate_lit");
16060  break;
16061  }
16062  return node;
16063 }
16064 
16065 static NODE *
16066 arg_blk_pass(NODE *node1, NODE *node2)
16067 {
16068  if (node2) {
16069  node2->nd_head = node1;
16070  return node2;
16071  }
16072  return node1;
16073 }
16074 
16075 
16076 static NODE*
16077 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
16078 {
16079  int saved_line = ruby_sourceline;
16080  struct rb_args_info *args = tail->nd_ainfo;
16081 
16082  args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0;
16083  args->pre_init = m ? m->nd_next : 0;
16084 
16085  args->post_args_num = p ? rb_long2int(p->nd_plen) : 0;
16086  args->post_init = p ? p->nd_next : 0;
16087  args->first_post_arg = p ? p->nd_pid : 0;
16088 
16089  args->rest_arg = r;
16090 
16091  args->opt_args = o;
16092 
16093  ruby_sourceline = saved_line;
16094 
16095  return tail;
16096 }
16097 
16098 static NODE*
16099 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
16100 {
16101  int saved_line = ruby_sourceline;
16102  struct rb_args_info *args;
16103  NODE *kw_rest_arg = 0;
16104  NODE *node;
16105  int check = 0;
16106 
16107  args = ALLOC(struct rb_args_info);
16108  MEMZERO(args, struct rb_args_info, 1);
16109  node = NEW_NODE(NODE_ARGS, 0, 0, args);
16110 
16111  args->block_arg = b;
16112  args->kw_args = k;
16113  if (k && !kr) {
16114  check = 1;
16115  kr = internal_id();
16116  }
16117  if (kr) {
16118  arg_var(kr);
16119  kw_rest_arg = NEW_DVAR(kr);
16120  kw_rest_arg->nd_cflag = check;
16121  }
16122  args->kw_rest_arg = kw_rest_arg;
16123 
16124  ruby_sourceline = saved_line;
16125  return node;
16126 }
16127 
16128 static NODE*
16129 dsym_node_gen(struct parser_params *parser, NODE *node)
16130 {
16131  VALUE lit;
16132 
16133  if (!node) {
16134  return NEW_LIT(ID2SYM(idNULL));
16135  }
16136 
16137  switch (nd_type(node)) {
16138  case NODE_DSTR:
16139  nd_set_type(node, NODE_DSYM);
16140  break;
16141  case NODE_STR:
16142  lit = node->nd_lit;
16143  node->nd_lit = ID2SYM(rb_intern_str(lit));
16144  nd_set_type(node, NODE_LIT);
16145  break;
16146  default:
16147  node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
16148  break;
16149  }
16150  return node;
16151 }
16152 #endif /* !RIPPER */
16153 
16154 #ifndef RIPPER
16155 static NODE *
16156 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16157 {
16158  NODE *asgn;
16159 
16160  if (lhs) {
16161  ID vid = lhs->nd_vid;
16162  if (op == tOROP) {
16163  lhs->nd_value = rhs;
16164  asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
16165  if (is_asgn_or_id(vid)) {
16166  asgn->nd_aid = vid;
16167  }
16168  }
16169  else if (op == tANDOP) {
16170  lhs->nd_value = rhs;
16171  asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
16172  }
16173  else {
16174  asgn = lhs;
16175  asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
16176  }
16177  }
16178  else {
16179  asgn = NEW_BEGIN(0);
16180  }
16181  return asgn;
16182 }
16183 
16184 static NODE *
16185 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
16186 {
16187  NODE *asgn;
16188 
16189  if (op == tOROP) {
16190  op = 0;
16191  }
16192  else if (op == tANDOP) {
16193  op = 1;
16194  }
16195  asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
16196  fixpos(asgn, lhs);
16197  return asgn;
16198 }
16199 
16200 static NODE *
16201 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16202 {
16203  NODE *asgn;
16204 
16205  if (op == tOROP) {
16206  op = 0;
16207  }
16208  else if (op == tANDOP) {
16209  op = 1;
16210  }
16211  if (lhs) {
16212  asgn = NEW_OP_CDECL(lhs, op, rhs);
16213  }
16214  else {
16215  asgn = NEW_BEGIN(0);
16216  }
16217  fixpos(asgn, lhs);
16218  return asgn;
16219 }
16220 #else
16221 static VALUE
16222 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
16223 {
16224  return dispatch3(opassign, lhs, op, rhs);
16225 }
16226 
16227 static VALUE
16228 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
16229 {
16230  VALUE recv = dispatch3(field, lhs, type, attr);
16231  return dispatch3(opassign, recv, op, rhs);
16232 }
16233 #endif
16234 
16235 static void
16236 warn_unused_var(struct parser_params *parser, struct local_vars *local)
16237 {
16238  int i, cnt;
16239  ID *v, *u;
16240 
16241  if (!local->used) return;
16242  v = local->vars->tbl;
16243  u = local->used->tbl;
16244  cnt = local->used->pos;
16245  if (cnt != local->vars->pos) {
16246  rb_bug("local->used->pos != local->vars->pos");
16247  }
16248  for (i = 0; i < cnt; ++i) {
16249  if (!v[i] || (u[i] & LVAR_USED)) continue;
16250  if (is_private_local_id(v[i])) continue;
16251  rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
16252  }
16253 }
16254 
16255 static void
16256 local_push_gen(struct parser_params *parser, int inherit_dvars)
16257 {
16258  struct local_vars *local;
16259 
16260  local = ALLOC(struct local_vars);
16261  local->prev = lvtbl;
16262  local->args = vtable_alloc(0);
16263  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
16264  local->used = !(inherit_dvars &&
16265  (ifndef_ripper(compile_for_eval || e_option_supplied(parser))+0)) &&
16266  RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
16267  local->cmdargs = cmdarg_stack;
16268  cmdarg_stack = 0;
16269  lvtbl = local;
16270 }
16271 
16272 static void
16273 local_pop_gen(struct parser_params *parser)
16274 {
16275  struct local_vars *local = lvtbl->prev;
16276  if (lvtbl->used) {
16277  warn_unused_var(parser, lvtbl);
16278  vtable_free(lvtbl->used);
16279  }
16280  vtable_free(lvtbl->args);
16281  vtable_free(lvtbl->vars);
16282  cmdarg_stack = lvtbl->cmdargs;
16283  xfree(lvtbl);
16284  lvtbl = local;
16285 }
16286 
16287 #ifndef RIPPER
16288 static ID*
16289 local_tbl_gen(struct parser_params *parser)
16290 {
16291  int cnt_args = vtable_size(lvtbl->args);
16292  int cnt_vars = vtable_size(lvtbl->vars);
16293  int cnt = cnt_args + cnt_vars;
16294  int i, j;
16295  ID *buf;
16296 
16297  if (cnt <= 0) return 0;
16298  buf = ALLOC_N(ID, cnt + 1);
16299  MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args);
16300  /* remove IDs duplicated to warn shadowing */
16301  for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
16302  ID id = lvtbl->vars->tbl[i];
16303  if (!vtable_included(lvtbl->args, id)) {
16304  buf[j++] = id;
16305  }
16306  }
16307  if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1);
16308  buf[0] = cnt;
16309  return buf;
16310 }
16311 #endif
16312 
16313 static int
16314 arg_var_gen(struct parser_params *parser, ID id)
16315 {
16316  vtable_add(lvtbl->args, id);
16317  return vtable_size(lvtbl->args) - 1;
16318 }
16319 
16320 static int
16321 local_var_gen(struct parser_params *parser, ID id)
16322 {
16323  vtable_add(lvtbl->vars, id);
16324  if (lvtbl->used) {
16325  vtable_add(lvtbl->used, (ID)ruby_sourceline);
16326  }
16327  return vtable_size(lvtbl->vars) - 1;
16328 }
16329 
16330 static int
16331 local_id_gen(struct parser_params *parser, ID id)
16332 {
16333  struct vtable *vars, *args, *used;
16334 
16335  vars = lvtbl->vars;
16336  args = lvtbl->args;
16337  used = lvtbl->used;
16338 
16339  while (vars && POINTER_P(vars->prev)) {
16340  vars = vars->prev;
16341  args = args->prev;
16342  if (used) used = used->prev;
16343  }
16344 
16345  if (vars && vars->prev == DVARS_INHERIT) {
16346  return rb_local_defined(id);
16347  }
16348  else if (vtable_included(args, id)) {
16349  return 1;
16350  }
16351  else {
16352  int i = vtable_included(vars, id);
16353  if (i && used) used->tbl[i-1] |= LVAR_USED;
16354  return i != 0;
16355  }
16356 }
16357 
16358 static const struct vtable *
16359 dyna_push_gen(struct parser_params *parser)
16360 {
16361  lvtbl->args = vtable_alloc(lvtbl->args);
16362  lvtbl->vars = vtable_alloc(lvtbl->vars);
16363  if (lvtbl->used) {
16364  lvtbl->used = vtable_alloc(lvtbl->used);
16365  }
16366  return lvtbl->args;
16367 }
16368 
16369 static void
16370 dyna_pop_1(struct parser_params *parser)
16371 {
16372  struct vtable *tmp;
16373 
16374  if ((tmp = lvtbl->used) != 0) {
16375  warn_unused_var(parser, lvtbl);
16376  lvtbl->used = lvtbl->used->prev;
16377  vtable_free(tmp);
16378  }
16379  tmp = lvtbl->args;
16380  lvtbl->args = lvtbl->args->prev;
16381  vtable_free(tmp);
16382  tmp = lvtbl->vars;
16383  lvtbl->vars = lvtbl->vars->prev;
16384  vtable_free(tmp);
16385 }
16386 
16387 static void
16388 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16389 {
16390  while (lvtbl->args != lvargs) {
16391  dyna_pop_1(parser);
16392  if (!lvtbl->args) {
16393  struct local_vars *local = lvtbl->prev;
16394  xfree(lvtbl);
16395  lvtbl = local;
16396  }
16397  }
16398  dyna_pop_1(parser);
16399 }
16400 
16401 static int
16402 dyna_in_block_gen(struct parser_params *parser)
16403 {
16404  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16405 }
16406 
16407 static int
16408 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16409 {
16410  struct vtable *vars, *args, *used;
16411  int i;
16412 
16413  args = lvtbl->args;
16414  vars = lvtbl->vars;
16415  used = lvtbl->used;
16416 
16417  while (POINTER_P(vars)) {
16418  if (vtable_included(args, id)) {
16419  return 1;
16420  }
16421  if ((i = vtable_included(vars, id)) != 0) {
16422  if (used) used->tbl[i-1] |= LVAR_USED;
16423  return 1;
16424  }
16425  args = args->prev;
16426  vars = vars->prev;
16427  if (get) used = 0;
16428  if (used) used = used->prev;
16429  }
16430 
16431  if (vars == DVARS_INHERIT) {
16432  return rb_dvar_defined(id);
16433  }
16434 
16435  return 0;
16436 }
16437 
16438 static int
16439 dvar_curr_gen(struct parser_params *parser, ID id)
16440 {
16441  return (vtable_included(lvtbl->args, id) ||
16442  vtable_included(lvtbl->vars, id));
16443 }
16444 
16445 #ifndef RIPPER
16446 static void
16447 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
16448 {
16449  int c = RE_OPTION_ENCODING_IDX(options);
16450 
16451  if (c) {
16452  int opt, idx;
16453  rb_char_to_option_kcode(c, &opt, &idx);
16454  if (idx != ENCODING_GET(str) &&
16455  rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16456  goto error;
16457  }
16458  ENCODING_SET(str, idx);
16459  }
16460  else if (RE_OPTION_ENCODING_NONE(options)) {
16461  if (!ENCODING_IS_ASCII8BIT(str) &&
16462  rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16463  c = 'n';
16464  goto error;
16465  }
16466  rb_enc_associate(str, rb_ascii8bit_encoding());
16467  }
16468  else if (current_enc == rb_usascii_encoding()) {
16469  if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16470  /* raise in re.c */
16471  rb_enc_associate(str, rb_usascii_encoding());
16472  }
16473  else {
16474  rb_enc_associate(str, rb_ascii8bit_encoding());
16475  }
16476  }
16477  return;
16478 
16479  error:
16480  compile_error(PARSER_ARG
16481  "regexp encoding option '%c' differs from source encoding '%s'",
16482  c, rb_enc_name(rb_enc_get(str)));
16483 }
16484 
16485 static int
16486 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
16487 {
16488  VALUE err;
16489  reg_fragment_setenc(str, options);
16490  err = rb_reg_check_preprocess(str);
16491  if (err != Qnil) {
16492  err = rb_obj_as_string(err);
16493  compile_error(PARSER_ARG "%"PRIsVALUE, err);
16494  return 0;
16495  }
16496  return 1;
16497 }
16498 
16499 typedef struct {
16500  struct parser_params* parser;
16501  rb_encoding *enc;
16502  NODE *succ_block;
16503  NODE *fail_block;
16504  int num;
16505 } reg_named_capture_assign_t;
16506 
16507 static int
16508 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
16509  int back_num, int *back_refs, OnigRegex regex, void *arg0)
16510 {
16511  reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
16512  struct parser_params* parser = arg->parser;
16513  rb_encoding *enc = arg->enc;
16514  long len = name_end - name;
16515  const char *s = (const char *)name;
16516  ID var;
16517 
16518  arg->num++;
16519 
16520  if (arg->succ_block == 0) {
16521  arg->succ_block = NEW_BEGIN(0);
16522  arg->fail_block = NEW_BEGIN(0);
16523  }
16524 
16525  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16526  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16527  !rb_enc_symname2_p(s, len, enc)) {
16528  return ST_CONTINUE;
16529  }
16530  var = rb_intern3(s, len, enc);
16531  if (dvar_defined(var) || local_id(var)) {
16532  rb_warningS("named capture conflicts a local variable - %s",
16533  rb_id2name(var));
16534  }
16535  arg->succ_block = block_append(arg->succ_block,
16536  newline_node(node_assign(assignable(var,0),
16537  NEW_CALL(
16538  gettable(rb_intern("$~")),
16539  idAREF,
16540  NEW_LIST(NEW_LIT(ID2SYM(var))))
16541  )));
16542  arg->fail_block = block_append(arg->fail_block,
16543  newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil))));
16544  return ST_CONTINUE;
16545 }
16546 
16547 static NODE *
16548 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match)
16549 {
16550  reg_named_capture_assign_t arg;
16551 
16552  arg.parser = parser;
16553  arg.enc = rb_enc_get(regexp);
16554  arg.succ_block = 0;
16555  arg.fail_block = 0;
16556  arg.num = 0;
16557  onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
16558 
16559  if (arg.num == 0)
16560  return match;
16561 
16562  return
16563  block_append(
16564  newline_node(match),
16565  NEW_IF(gettable(rb_intern("$~")),
16566  block_append(
16567  newline_node(arg.succ_block),
16568  newline_node(
16569  NEW_CALL(
16570  gettable(rb_intern("$~")),
16571  rb_intern("begin"),
16572  NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16573  block_append(
16574  newline_node(arg.fail_block),
16575  newline_node(
16576  NEW_LIT(Qnil)))));
16577 }
16578 
16579 static VALUE
16580 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16581 {
16582  VALUE re;
16583  VALUE err;
16584 
16585  reg_fragment_setenc(str, options);
16586  err = rb_errinfo();
16587  re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
16588  if (NIL_P(re)) {
16589  ID mesg = rb_intern("mesg");
16590  VALUE m = rb_attr_get(rb_errinfo(), mesg);
16591  rb_set_errinfo(err);
16592  if (!NIL_P(err)) {
16593  rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16594  }
16595  else {
16596  compile_error(PARSER_ARG "%"PRIsVALUE, m);
16597  }
16598  return Qnil;
16599  }
16600  return re;
16601 }
16602 
16603 void
16604 rb_gc_mark_parser(void)
16605 {
16606 }
16607 
16608 NODE*
16609 rb_parser_append_print(VALUE vparser, NODE *node)
16610 {
16611  NODE *prelude = 0;
16612  NODE *scope = node;
16613  struct parser_params *parser;
16614 
16615  if (!node) return node;
16616 
16617  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16618 
16619  node = node->nd_body;
16620 
16621  if (nd_type(node) == NODE_PRELUDE) {
16622  prelude = node;
16623  node = node->nd_body;
16624  }
16625 
16626  node = block_append(node,
16627  NEW_FCALL(rb_intern("print"),
16628  NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16629  if (prelude) {
16630  prelude->nd_body = node;
16631  scope->nd_body = prelude;
16632  }
16633  else {
16634  scope->nd_body = node;
16635  }
16636 
16637  return scope;
16638 }
16639 
16640 NODE *
16641 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16642 {
16643  NODE *prelude = 0;
16644  NODE *scope = node;
16645  struct parser_params *parser;
16646 
16647  if (!node) return node;
16648 
16649  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16650 
16651  node = node->nd_body;
16652 
16653  if (nd_type(node) == NODE_PRELUDE) {
16654  prelude = node;
16655  node = node->nd_body;
16656  }
16657  if (split) {
16658  node = block_append(NEW_GASGN(rb_intern("$F"),
16659  NEW_CALL(NEW_GVAR(rb_intern("$_")),
16660  rb_intern("split"), 0)),
16661  node);
16662  }
16663  if (chop) {
16664  node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16665  rb_intern("chop!"), 0), node);
16666  }
16667 
16668  node = NEW_OPT_N(node);
16669 
16670  if (prelude) {
16671  prelude->nd_body = node;
16672  scope->nd_body = prelude;
16673  }
16674  else {
16675  scope->nd_body = node;
16676  }
16677 
16678  return scope;
16679 }
16680 
16681 static const struct {
16682  ID token;
16683  const char *name;
16684 } op_tbl[] = {
16685  {tDOT2, ".."},
16686  {tDOT3, "..."},
16687  {tPOW, "**"},
16688  {tDSTAR, "**"},
16689  {tUPLUS, "+@"},
16690  {tUMINUS, "-@"},
16691  {tCMP, "<=>"},
16692  {tGEQ, ">="},
16693  {tLEQ, "<="},
16694  {tEQ, "=="},
16695  {tEQQ, "==="},
16696  {tNEQ, "!="},
16697  {tMATCH, "=~"},
16698  {tNMATCH, "!~"},
16699  {tAREF, "[]"},
16700  {tASET, "[]="},
16701  {tLSHFT, "<<"},
16702  {tRSHFT, ">>"},
16703  {tCOLON2, "::"},
16704 };
16705 
16706 #define op_tbl_count numberof(op_tbl)
16707 
16708 #ifndef ENABLE_SELECTOR_NAMESPACE
16709 #define ENABLE_SELECTOR_NAMESPACE 0
16710 #endif
16711 
16712 static struct symbols {
16713  ID last_id;
16714  st_table *sym_id;
16715  st_table *id_str;
16716 #if ENABLE_SELECTOR_NAMESPACE
16717  st_table *ivar2_id;
16718  st_table *id_ivar2;
16719 #endif
16720  VALUE op_sym[tLAST_OP_ID];
16721  int minor_marked;
16722 } global_symbols = {tLAST_TOKEN};
16723 
16724 static const struct st_hash_type symhash = {
16725  rb_str_hash_cmp,
16726  rb_str_hash,
16727 };
16728 
16729 #if ENABLE_SELECTOR_NAMESPACE
16730 struct ivar2_key {
16731  ID id;
16732  VALUE klass;
16733 };
16734 
16735 static int
16736 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16737 {
16738  if (key1->id == key2->id && key1->klass == key2->klass) {
16739  return 0;
16740  }
16741  return 1;
16742 }
16743 
16744 static int
16745 ivar2_hash(struct ivar2_key *key)
16746 {
16747  return (key->id << 8) ^ (key->klass >> 2);
16748 }
16749 
16750 static const struct st_hash_type ivar2_hash_type = {
16751  ivar2_cmp,
16752  ivar2_hash,
16753 };
16754 #endif
16755 
16756 void
16757 Init_sym(void)
16758 {
16759  global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
16760  global_symbols.id_str = st_init_numtable_with_size(1000);
16761 #if ENABLE_SELECTOR_NAMESPACE
16762  global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16763  global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16764 #endif
16765 
16766  (void)nodetype;
16767  (void)nodeline;
16768 #if PARSER_DEBUG
16769  (void)lex_state_name(-1);
16770 #endif
16771 
16772  Init_id();
16773 }
16774 
16775 void
16776 rb_gc_mark_symbols(int full_mark)
16777 {
16778  if (full_mark || global_symbols.minor_marked == 0) {
16779  rb_mark_tbl(global_symbols.id_str);
16780  rb_gc_mark_locations(global_symbols.op_sym,
16781  global_symbols.op_sym + numberof(global_symbols.op_sym));
16782 
16783  if (!full_mark) global_symbols.minor_marked = 1;
16784  }
16785 }
16786 #endif /* !RIPPER */
16787 
16788 static ID
16789 internal_id_gen(struct parser_params *parser)
16790 {
16791  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16792  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16793  return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16794 }
16795 
16796 #ifndef RIPPER
16797 static int
16798 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16799 {
16800  int mb = 0;
16801 
16802  if (m >= e) return 0;
16803  if (is_global_name_punct(*m)) {
16804  ++m;
16805  }
16806  else if (*m == '-') {
16807  if (++m >= e) return 0;
16808  if (is_identchar(m, e, enc)) {
16809  if (!ISASCII(*m)) mb = 1;
16810  m += rb_enc_mbclen(m, e, enc);
16811  }
16812  }
16813  else {
16814  if (!rb_enc_isdigit(*m, enc)) return 0;
16815  do {
16816  if (!ISASCII(*m)) mb = 1;
16817  ++m;
16818  } while (m < e && rb_enc_isdigit(*m, enc));
16819  }
16820  return m == e ? mb + 1 : 0;
16821 }
16822 
16823 int
16824 rb_symname_p(const char *name)
16825 {
16826  return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16827 }
16828 
16829 int
16830 rb_enc_symname_p(const char *name, rb_encoding *enc)
16831 {
16832  return rb_enc_symname2_p(name, strlen(name), enc);
16833 }
16834 
16835 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
16836 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<ID_SCOPE_MASK) & ~(1U<<ID_ATTRSET))
16837 
16838 static int
16839 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset)
16840 {
16841  const char *m = name;
16842  const char *e = m + len;
16843  int type = ID_JUNK;
16844 
16845  if (!m || len <= 0) return -1;
16846  switch (*m) {
16847  case '\0':
16848  return -1;
16849 
16850  case '$':
16851  type = ID_GLOBAL;
16852  if (is_special_global_name(++m, e, enc)) return type;
16853  goto id;
16854 
16855  case '@':
16856  type = ID_INSTANCE;
16857  if (*++m == '@') {
16858  ++m;
16859  type = ID_CLASS;
16860  }
16861  goto id;
16862 
16863  case '<':
16864  switch (*++m) {
16865  case '<': ++m; break;
16866  case '=': if (*++m == '>') ++m; break;
16867  default: break;
16868  }
16869  break;
16870 
16871  case '>':
16872  switch (*++m) {
16873  case '>': case '=': ++m; break;
16874  }
16875  break;
16876 
16877  case '=':
16878  switch (*++m) {
16879  case '~': ++m; break;
16880  case '=': if (*++m == '=') ++m; break;
16881  default: return -1;
16882  }
16883  break;
16884 
16885  case '*':
16886  if (*++m == '*') ++m;
16887  break;
16888 
16889  case '+': case '-':
16890  if (*++m == '@') ++m;
16891  break;
16892 
16893  case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16894  ++m;
16895  break;
16896 
16897  case '[':
16898  if (*++m != ']') return -1;
16899  if (*++m == '=') ++m;
16900  break;
16901 
16902  case '!':
16903  if (len == 1) return ID_JUNK;
16904  switch (*++m) {
16905  case '=': case '~': ++m; break;
16906  default: return -1;
16907  }
16908  break;
16909 
16910  default:
16911  type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16912  id:
16913  if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16914  return -1;
16915  while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16916  if (m >= e) break;
16917  switch (*m) {
16918  case '!': case '?':
16919  if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16920  type = ID_JUNK;
16921  ++m;
16922  break;
16923  case '=':
16924  if (!(allowed_attrset & (1U << type))) return -1;
16925  type = ID_ATTRSET;
16926  ++m;
16927  break;
16928  }
16929  break;
16930  }
16931  return m == e ? type : -1;
16932 }
16933 
16934 int
16935 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16936 {
16937  return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
16938 }
16939 
16940 static int
16941 rb_str_symname_type(VALUE name, unsigned int allowed_attrset)
16942 {
16943  const char *ptr = StringValuePtr(name);
16944  long len = RSTRING_LEN(name);
16945  int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_attrset);
16946  RB_GC_GUARD(name);
16947  return type;
16948 }
16949 
16950 static ID
16951 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16952 {
16953  VALUE str = rb_enc_str_new(name, len, enc);
16954  return register_symid_str(id, str);
16955 }
16956 
16957 static ID
16958 register_symid_str(ID id, VALUE str)
16959 {
16960  OBJ_FREEZE(str);
16961  str = rb_fstring(str);
16962 
16963  if (RUBY_DTRACE_SYMBOL_CREATE_ENABLED()) {
16964  RUBY_DTRACE_SYMBOL_CREATE(RSTRING_PTR(str), rb_sourcefile(), rb_sourceline());
16965  }
16966 
16967  st_add_direct(global_symbols.sym_id, (st_data_t)str, id);
16968  st_add_direct(global_symbols.id_str, id, (st_data_t)str);
16969  global_symbols.minor_marked = 0;
16970  return id;
16971 }
16972 
16973 static int
16974 sym_check_asciionly(VALUE str)
16975 {
16976  if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
16977  switch (rb_enc_str_coderange(str)) {
16978  case ENC_CODERANGE_BROKEN:
16979  rb_raise(rb_eEncodingError, "invalid encoding symbol");
16980  case ENC_CODERANGE_7BIT:
16981  return TRUE;
16982  }
16983  return FALSE;
16984 }
16985 
16986 /*
16987  * _str_ itself will be registered at the global symbol table. _str_
16988  * can be modified before the registration, since the encoding will be
16989  * set to ASCII-8BIT if it is a special global name.
16990  */
16991 static ID intern_str(VALUE str);
16992 
16993 static VALUE
16994 setup_fake_str(struct RString *fake_str, const char *name, long len)
16995 {
16996  fake_str->basic.flags = T_STRING|RSTRING_NOEMBED;
16997  RBASIC_SET_CLASS_RAW((VALUE)fake_str, rb_cString);
16998  fake_str->as.heap.len = len;
16999  fake_str->as.heap.ptr = (char *)name;
17000  fake_str->as.heap.aux.capa = len;
17001  return (VALUE)fake_str;
17002 }
17003 
17004 ID
17005 rb_intern3(const char *name, long len, rb_encoding *enc)
17006 {
17007  st_data_t data;
17008  struct RString fake_str;
17009  VALUE str = setup_fake_str(&fake_str, name, len);
17010  rb_enc_associate(str, enc);
17011  OBJ_FREEZE(str);
17012 
17013  if (st_lookup(global_symbols.sym_id, str, &data))
17014  return (ID)data;
17015 
17016  str = rb_enc_str_new(name, len, enc); /* make true string */
17017  return intern_str(str);
17018 }
17019 
17020 static ID
17021 intern_str(VALUE str)
17022 {
17023  const char *name, *m, *e;
17024  long len, last;
17025  rb_encoding *enc, *symenc;
17026  unsigned char c;
17027  ID id;
17028  int mb;
17029 
17030  RSTRING_GETMEM(str, name, len);
17031  m = name;
17032  e = m + len;
17033  enc = rb_enc_get(str);
17034  symenc = enc;
17035 
17036  if (!len || (rb_cString && !rb_enc_asciicompat(enc))) {
17037  junk:
17038  id = ID_JUNK;
17039  goto new_id;
17040  }
17041  last = len-1;
17042  id = 0;
17043  switch (*m) {
17044  case '$':
17045  if (len < 2) goto junk;
17046  id |= ID_GLOBAL;
17047  if ((mb = is_special_global_name(++m, e, enc)) != 0) {
17048  if (!--mb) symenc = rb_usascii_encoding();
17049  goto new_id;
17050  }
17051  break;
17052  case '@':
17053  if (m[1] == '@') {
17054  if (len < 3) goto junk;
17055  m++;
17056  id |= ID_CLASS;
17057  }
17058  else {
17059  if (len < 2) goto junk;
17060  id |= ID_INSTANCE;
17061  }
17062  m++;
17063  break;
17064  default:
17065  c = m[0];
17066  if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
17067  /* operators */
17068  int i;
17069 
17070  if (len == 1) {
17071  id = c;
17072  goto id_register;
17073  }
17074  for (i = 0; i < op_tbl_count; i++) {
17075  if (*op_tbl[i].name == *m &&
17076  strcmp(op_tbl[i].name, m) == 0) {
17077  id = op_tbl[i].token;
17078  goto id_register;
17079  }
17080  }
17081  }
17082  break;
17083  }
17084  if (name[last] == '=') {
17085  /* attribute assignment */
17086  if (last > 1 && name[last-1] == '=')
17087  goto junk;
17088  id = rb_intern3(name, last, enc);
17089  if (id > tLAST_OP_ID && !is_attrset_id(id)) {
17090  enc = rb_enc_get(rb_id2str(id));
17091  id = rb_id_attrset(id);
17092  goto id_register;
17093  }
17094  id = ID_ATTRSET;
17095  }
17096  else if (id == 0) {
17097  if (rb_enc_isupper(m[0], enc)) {
17098  id = ID_CONST;
17099  }
17100  else {
17101  id = ID_LOCAL;
17102  }
17103  }
17104  if (!rb_enc_isdigit(*m, enc)) {
17105  while (m <= name + last && is_identchar(m, e, enc)) {
17106  if (ISASCII(*m)) {
17107  m++;
17108  }
17109  else {
17110  m += rb_enc_mbclen(m, e, enc);
17111  }
17112  }
17113  }
17114  if (id != ID_ATTRSET && m - name < len) id = ID_JUNK;
17115  if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
17116  new_id:
17117  if (symenc != enc) rb_enc_associate(str, symenc);
17118  if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) {
17119  if (len > 20) {
17120  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
17121  name);
17122  }
17123  else {
17124  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
17125  (int)len, name);
17126  }
17127  }
17128  id |= ++global_symbols.last_id << ID_SCOPE_SHIFT;
17129  id_register:
17130  return register_symid_str(id, str);
17131 }
17132 
17133 ID
17134 rb_intern2(const char *name, long len)
17135 {
17136  return rb_intern3(name, len, rb_usascii_encoding());
17137 }
17138 
17139 #undef rb_intern
17140 ID
17141 rb_intern(const char *name)
17142 {
17143  return rb_intern2(name, strlen(name));
17144 }
17145 
17146 ID
17147 rb_intern_str(VALUE str)
17148 {
17149  st_data_t id;
17150 
17151  if (st_lookup(global_symbols.sym_id, str, &id))
17152  return (ID)id;
17153  return intern_str(rb_str_dup(str));
17154 }
17155 
17156 VALUE
17157 rb_id2str(ID id)
17158 {
17159  st_data_t data;
17160 
17161  if (id < tLAST_TOKEN) {
17162  int i = 0;
17163 
17164  if (id < INT_MAX && rb_ispunct((int)id)) {
17165  VALUE str = global_symbols.op_sym[i = (int)id];
17166  if (!str) {
17167  char name[2];
17168  name[0] = (char)id;
17169  name[1] = 0;
17170  str = rb_usascii_str_new(name, 1);
17171  OBJ_FREEZE(str);
17172  str = rb_fstring(str);
17173  global_symbols.op_sym[i] = str;
17174  global_symbols.minor_marked = 0;
17175  }
17176  return str;
17177  }
17178  for (i = 0; i < op_tbl_count; i++) {
17179  if (op_tbl[i].token == id) {
17180  VALUE str = global_symbols.op_sym[i];
17181  if (!str) {
17182  str = rb_usascii_str_new2(op_tbl[i].name);
17183  OBJ_FREEZE(str);
17184  str = rb_fstring(str);
17185  global_symbols.op_sym[i] = str;
17186  global_symbols.minor_marked = 0;
17187  }
17188  return str;
17189  }
17190  }
17191  }
17192 
17193  if (st_lookup(global_symbols.id_str, id, &data)) {
17194  VALUE str = (VALUE)data;
17195  if (RBASIC(str)->klass == 0)
17196  RBASIC_SET_CLASS_RAW(str, rb_cString);
17197  return str;
17198  }
17199 
17200  if (is_attrset_id(id)) {
17201  ID id_stem = (id & ~ID_SCOPE_MASK);
17202  VALUE str;
17203 
17204  do {
17205  if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break;
17206  if (!!(str = rb_id2str(id_stem | ID_CONST))) break;
17207  if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break;
17208  if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break;
17209  if (!!(str = rb_id2str(id_stem | ID_CLASS))) break;
17210  if (!!(str = rb_id2str(id_stem | ID_JUNK))) break;
17211  return 0;
17212  } while (0);
17213  str = rb_str_dup(str);
17214  rb_str_cat(str, "=", 1);
17215  register_symid_str(id, str);
17216  if (st_lookup(global_symbols.id_str, id, &data)) {
17217  VALUE str = (VALUE)data;
17218  if (RBASIC(str)->klass == 0)
17219  RBASIC_SET_CLASS_RAW(str, rb_cString);
17220  return str;
17221  }
17222  }
17223  return 0;
17224 }
17225 
17226 const char *
17227 rb_id2name(ID id)
17228 {
17229  VALUE str = rb_id2str(id);
17230 
17231  if (!str) return 0;
17232  return RSTRING_PTR(str);
17233 }
17234 
17235 static int
17236 symbols_i(VALUE sym, ID value, VALUE ary)
17237 {
17238  rb_ary_push(ary, ID2SYM(value));
17239  return ST_CONTINUE;
17240 }
17241 
17242 /*
17243  * call-seq:
17244  * Symbol.all_symbols => array
17245  *
17246  * Returns an array of all the symbols currently in Ruby's symbol
17247  * table.
17248  *
17249  * Symbol.all_symbols.size #=> 903
17250  * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
17251  * :chown, :EOFError, :$;, :String,
17252  * :LOCK_SH, :"setuid?", :$<,
17253  * :default_proc, :compact, :extend,
17254  * :Tms, :getwd, :$=, :ThreadGroup,
17255  * :wait2, :$>]
17256  */
17257 
17258 VALUE
17259 rb_sym_all_symbols(void)
17260 {
17261  VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries);
17262 
17263  st_foreach(global_symbols.sym_id, symbols_i, ary);
17264  return ary;
17265 }
17266 
17267 int
17268 rb_is_const_id(ID id)
17269 {
17270  return is_const_id(id);
17271 }
17272 
17273 int
17274 rb_is_class_id(ID id)
17275 {
17276  return is_class_id(id);
17277 }
17278 
17279 int
17280 rb_is_global_id(ID id)
17281 {
17282  return is_global_id(id);
17283 }
17284 
17285 int
17286 rb_is_instance_id(ID id)
17287 {
17288  return is_instance_id(id);
17289 }
17290 
17291 int
17292 rb_is_attrset_id(ID id)
17293 {
17294  return is_attrset_id(id);
17295 }
17296 
17297 int
17298 rb_is_local_id(ID id)
17299 {
17300  return is_local_id(id);
17301 }
17302 
17303 int
17304 rb_is_junk_id(ID id)
17305 {
17306  return is_junk_id(id);
17307 }
17308 
17320 ID
17321 rb_check_id(volatile VALUE *namep)
17322 {
17323  st_data_t id;
17324  VALUE tmp;
17325  VALUE name = *namep;
17326 
17327  if (SYMBOL_P(name)) {
17328  return SYM2ID(name);
17329  }
17330  else if (!RB_TYPE_P(name, T_STRING)) {
17331  tmp = rb_check_string_type(name);
17332  if (NIL_P(tmp)) {
17333  tmp = rb_inspect(name);
17334  rb_raise(rb_eTypeError, "%s is not a symbol",
17335  RSTRING_PTR(tmp));
17336  }
17337  name = tmp;
17338  *namep = name;
17339  }
17340 
17341  sym_check_asciionly(name);
17342 
17343  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17344  return (ID)id;
17345 
17346  if (rb_is_attrset_name(name)) {
17347  struct RString fake_str;
17348  /* make local name by chopping '=' */
17349  const VALUE localname = setup_fake_str(&fake_str, RSTRING_PTR(name), RSTRING_LEN(name) - 1);
17350  rb_enc_copy(localname, name);
17351  OBJ_FREEZE(localname);
17352 
17353  if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17354  return rb_id_attrset((ID)id);
17355  }
17356  RB_GC_GUARD(name);
17357  }
17358 
17359  return (ID)0;
17360 }
17361 
17362 ID
17363 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
17364 {
17365  st_data_t id;
17366  struct RString fake_str;
17367  const VALUE name = setup_fake_str(&fake_str, ptr, len);
17368  rb_enc_associate(name, enc);
17369 
17370  sym_check_asciionly(name);
17371 
17372  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17373  return (ID)id;
17374 
17375  if (rb_is_attrset_name(name)) {
17376  fake_str.as.heap.len = len - 1;
17377  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
17378  return rb_id_attrset((ID)id);
17379  }
17380  }
17381 
17382  return (ID)0;
17383 }
17384 
17385 int
17386 rb_is_const_name(VALUE name)
17387 {
17388  return rb_str_symname_type(name, 0) == ID_CONST;
17389 }
17390 
17391 int
17392 rb_is_class_name(VALUE name)
17393 {
17394  return rb_str_symname_type(name, 0) == ID_CLASS;
17395 }
17396 
17397 int
17398 rb_is_global_name(VALUE name)
17399 {
17400  return rb_str_symname_type(name, 0) == ID_GLOBAL;
17401 }
17402 
17403 int
17404 rb_is_instance_name(VALUE name)
17405 {
17406  return rb_str_symname_type(name, 0) == ID_INSTANCE;
17407 }
17408 
17409 int
17410 rb_is_attrset_name(VALUE name)
17411 {
17412  return rb_str_symname_type(name, IDSET_ATTRSET_FOR_INTERN) == ID_ATTRSET;
17413 }
17414 
17415 int
17416 rb_is_local_name(VALUE name)
17417 {
17418  return rb_str_symname_type(name, 0) == ID_LOCAL;
17419 }
17420 
17421 int
17422 rb_is_method_name(VALUE name)
17423 {
17424  switch (rb_str_symname_type(name, 0)) {
17425  case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17426  return TRUE;
17427  }
17428  return FALSE;
17429 }
17430 
17431 int
17432 rb_is_junk_name(VALUE name)
17433 {
17434  return rb_str_symname_type(name, IDSET_ATTRSET_FOR_SYNTAX) == -1;
17435 }
17436 
17437 #endif /* !RIPPER */
17438 
17439 static void
17440 parser_initialize(struct parser_params *parser)
17441 {
17442  parser->eofp = Qfalse;
17443 
17444  parser->parser_lex_strterm = 0;
17445  parser->parser_cond_stack = 0;
17446  parser->parser_cmdarg_stack = 0;
17447  parser->parser_class_nest = 0;
17448  parser->parser_paren_nest = 0;
17449  parser->parser_lpar_beg = 0;
17450  parser->parser_brace_nest = 0;
17451  parser->parser_in_single = 0;
17452  parser->parser_in_def = 0;
17453  parser->parser_in_defined = 0;
17454  parser->parser_in_kwarg = 0;
17455  parser->parser_compile_for_eval = 0;
17456  parser->parser_cur_mid = 0;
17457  parser->parser_tokenbuf = NULL;
17458  parser->parser_tokidx = 0;
17459  parser->parser_toksiz = 0;
17460  parser->parser_heredoc_end = 0;
17461  parser->parser_command_start = TRUE;
17462  parser->parser_deferred_nodes = 0;
17463  parser->parser_lex_pbeg = 0;
17464  parser->parser_lex_p = 0;
17465  parser->parser_lex_pend = 0;
17466  parser->parser_lvtbl = 0;
17467  parser->parser_ruby__end__seen = 0;
17468  parser->parser_ruby_sourcefile = 0;
17469  parser->parser_ruby_sourcefile_string = Qnil;
17470 #ifndef RIPPER
17471  parser->is_ripper = 0;
17472  parser->parser_eval_tree_begin = 0;
17473  parser->parser_eval_tree = 0;
17474 #else
17475  parser->is_ripper = 1;
17476  parser->delayed = Qnil;
17477 
17478  parser->result = Qnil;
17479  parser->parsing_thread = Qnil;
17480  parser->toplevel_p = TRUE;
17481 #endif
17482 #ifdef YYMALLOC
17483  parser->heap = NULL;
17484 #endif
17485  parser->enc = rb_utf8_encoding();
17486 }
17487 
17488 #ifdef RIPPER
17489 #define parser_mark ripper_parser_mark
17490 #define parser_free ripper_parser_free
17491 #endif
17492 
17493 static void
17494 parser_mark(void *ptr)
17495 {
17496  struct parser_params *p = (struct parser_params*)ptr;
17497 
17498  rb_gc_mark((VALUE)p->parser_lex_strterm);
17499  rb_gc_mark((VALUE)p->parser_deferred_nodes);
17500  rb_gc_mark(p->parser_lex_input);
17501  rb_gc_mark(p->parser_lex_lastline);
17502  rb_gc_mark(p->parser_lex_nextline);
17503  rb_gc_mark(p->parser_ruby_sourcefile_string);
17504 #ifndef RIPPER
17505  rb_gc_mark((VALUE)p->parser_eval_tree_begin) ;
17506  rb_gc_mark((VALUE)p->parser_eval_tree) ;
17507  rb_gc_mark(p->debug_lines);
17508 #else
17509  rb_gc_mark(p->delayed);
17510  rb_gc_mark(p->value);
17511  rb_gc_mark(p->result);
17512  rb_gc_mark(p->parsing_thread);
17513 #endif
17514 #ifdef YYMALLOC
17515  rb_gc_mark((VALUE)p->heap);
17516 #endif
17517 }
17518 
17519 static void
17520 parser_free(void *ptr)
17521 {
17522  struct parser_params *p = (struct parser_params*)ptr;
17523  struct local_vars *local, *prev;
17524 
17525  if (p->parser_tokenbuf) {
17526  xfree(p->parser_tokenbuf);
17527  }
17528  for (local = p->parser_lvtbl; local; local = prev) {
17529  if (local->vars) xfree(local->vars);
17530  prev = local->prev;
17531  xfree(local);
17532  }
17533  xfree(p);
17534 }
17535 
17536 static size_t
17537 parser_memsize(const void *ptr)
17538 {
17539  struct parser_params *p = (struct parser_params*)ptr;
17540  struct local_vars *local;
17541  size_t size = sizeof(*p);
17542 
17543  if (!ptr) return 0;
17544  size += p->parser_toksiz;
17545  for (local = p->parser_lvtbl; local; local = local->prev) {
17546  size += sizeof(*local);
17547  if (local->vars) size += local->vars->capa * sizeof(ID);
17548  }
17549  return size;
17550 }
17551 
17552 static
17553 #ifndef RIPPER
17554 const
17555 #endif
17556 rb_data_type_t parser_data_type = {
17557  "parser",
17558  {
17559  parser_mark,
17560  parser_free,
17561  parser_memsize,
17562  },
17563  NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
17564 };
17565 
17566 #ifndef RIPPER
17567 #undef rb_reserved_word
17568 
17569 const struct kwtable *
17570 rb_reserved_word(const char *str, unsigned int len)
17571 {
17572  return reserved_word(str, len);
17573 }
17574 
17575 static struct parser_params *
17576 parser_new(void)
17577 {
17578  struct parser_params *p;
17579 
17580  p = ALLOC_N(struct parser_params, 1);
17581  MEMZERO(p, struct parser_params, 1);
17582  parser_initialize(p);
17583  return p;
17584 }
17585 
17586 VALUE
17587 rb_parser_new(void)
17588 {
17589  struct parser_params *p = parser_new();
17590 
17591  return TypedData_Wrap_Struct(0, &parser_data_type, p);
17592 }
17593 
17594 /*
17595  * call-seq:
17596  * ripper#end_seen? -> Boolean
17597  *
17598  * Return true if parsed source ended by +\_\_END\_\_+.
17599  */
17600 VALUE
17601 rb_parser_end_seen_p(VALUE vparser)
17602 {
17603  struct parser_params *parser;
17604 
17605  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17606  return ruby__end__seen ? Qtrue : Qfalse;
17607 }
17608 
17609 /*
17610  * call-seq:
17611  * ripper#encoding -> encoding
17612  *
17613  * Return encoding of the source.
17614  */
17615 VALUE
17616 rb_parser_encoding(VALUE vparser)
17617 {
17618  struct parser_params *parser;
17619 
17620  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17621  return rb_enc_from_encoding(current_enc);
17622 }
17623 
17624 /*
17625  * call-seq:
17626  * ripper.yydebug -> true or false
17627  *
17628  * Get yydebug.
17629  */
17630 VALUE
17631 rb_parser_get_yydebug(VALUE self)
17632 {
17633  struct parser_params *parser;
17634 
17635  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17636  return yydebug ? Qtrue : Qfalse;
17637 }
17638 
17639 /*
17640  * call-seq:
17641  * ripper.yydebug = flag
17642  *
17643  * Set yydebug.
17644  */
17645 VALUE
17646 rb_parser_set_yydebug(VALUE self, VALUE flag)
17647 {
17648  struct parser_params *parser;
17649 
17650  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17651  yydebug = RTEST(flag);
17652  return flag;
17653 }
17654 
17655 #ifdef YYMALLOC
17656 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17657 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17658 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17659  (n)->u3.cnt = (c), (p))
17660 
17661 void *
17662 rb_parser_malloc(struct parser_params *parser, size_t size)
17663 {
17664  size_t cnt = HEAPCNT(1, size);
17665  NODE *n = NEWHEAP();
17666  void *ptr = xmalloc(size);
17667 
17668  return ADD2HEAP(n, cnt, ptr);
17669 }
17670 
17671 void *
17672 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17673 {
17674  size_t cnt = HEAPCNT(nelem, size);
17675  NODE *n = NEWHEAP();
17676  void *ptr = xcalloc(nelem, size);
17677 
17678  return ADD2HEAP(n, cnt, ptr);
17679 }
17680 
17681 void *
17682 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17683 {
17684  NODE *n;
17685  size_t cnt = HEAPCNT(1, size);
17686 
17687  if (ptr && (n = parser->heap) != NULL) {
17688  do {
17689  if (n->u1.node == ptr) {
17690  n->u1.node = ptr = xrealloc(ptr, size);
17691  if (n->u3.cnt) n->u3.cnt = cnt;
17692  return ptr;
17693  }
17694  } while ((n = n->u2.node) != NULL);
17695  }
17696  n = NEWHEAP();
17697  ptr = xrealloc(ptr, size);
17698  return ADD2HEAP(n, cnt, ptr);
17699 }
17700 
17701 void
17702 rb_parser_free(struct parser_params *parser, void *ptr)
17703 {
17704  NODE **prev = &parser->heap, *n;
17705 
17706  while ((n = *prev) != NULL) {
17707  if (n->u1.node == ptr) {
17708  *prev = n->u2.node;
17709  rb_gc_force_recycle((VALUE)n);
17710  break;
17711  }
17712  prev = &n->u2.node;
17713  }
17714  xfree(ptr);
17715 }
17716 #endif
17717 #endif
17718 
17719 #ifdef RIPPER
17720 #ifdef RIPPER_DEBUG
17721 extern int rb_is_pointer_to_heap(VALUE);
17722 
17723 /* :nodoc: */
17724 static VALUE
17725 ripper_validate_object(VALUE self, VALUE x)
17726 {
17727  if (x == Qfalse) return x;
17728  if (x == Qtrue) return x;
17729  if (x == Qnil) return x;
17730  if (x == Qundef)
17731  rb_raise(rb_eArgError, "Qundef given");
17732  if (FIXNUM_P(x)) return x;
17733  if (SYMBOL_P(x)) return x;
17734  if (!rb_is_pointer_to_heap(x))
17735  rb_raise(rb_eArgError, "invalid pointer: %p", x);
17736  switch (BUILTIN_TYPE(x)) {
17737  case T_STRING:
17738  case T_OBJECT:
17739  case T_ARRAY:
17740  case T_BIGNUM:
17741  case T_FLOAT:
17742  case T_COMPLEX:
17743  case T_RATIONAL:
17744  return x;
17745  case T_NODE:
17746  if (nd_type(x) != NODE_LASGN) {
17747  rb_raise(rb_eArgError, "NODE given: %p", x);
17748  }
17749  return ((NODE *)x)->nd_rval;
17750  default:
17751  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17752  x, rb_obj_classname(x));
17753  }
17754  return x;
17755 }
17756 #endif
17757 
17758 #define validate(x) ((x) = get_value(x))
17759 
17760 static VALUE
17761 ripper_dispatch0(struct parser_params *parser, ID mid)
17762 {
17763  return rb_funcall(parser->value, mid, 0);
17764 }
17765 
17766 static VALUE
17767 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17768 {
17769  validate(a);
17770  return rb_funcall(parser->value, mid, 1, a);
17771 }
17772 
17773 static VALUE
17774 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17775 {
17776  validate(a);
17777  validate(b);
17778  return rb_funcall(parser->value, mid, 2, a, b);
17779 }
17780 
17781 static VALUE
17782 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17783 {
17784  validate(a);
17785  validate(b);
17786  validate(c);
17787  return rb_funcall(parser->value, mid, 3, a, b, c);
17788 }
17789 
17790 static VALUE
17791 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17792 {
17793  validate(a);
17794  validate(b);
17795  validate(c);
17796  validate(d);
17797  return rb_funcall(parser->value, mid, 4, a, b, c, d);
17798 }
17799 
17800 static VALUE
17801 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17802 {
17803  validate(a);
17804  validate(b);
17805  validate(c);
17806  validate(d);
17807  validate(e);
17808  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17809 }
17810 
17811 static VALUE
17812 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17813 {
17814  validate(a);
17815  validate(b);
17816  validate(c);
17817  validate(d);
17818  validate(e);
17819  validate(f);
17820  validate(g);
17821  return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17822 }
17823 
17824 static const struct kw_assoc {
17825  ID id;
17826  const char *name;
17827 } keyword_to_name[] = {
17828  {keyword_class, "class"},
17829  {keyword_module, "module"},
17830  {keyword_def, "def"},
17831  {keyword_undef, "undef"},
17832  {keyword_begin, "begin"},
17833  {keyword_rescue, "rescue"},
17834  {keyword_ensure, "ensure"},
17835  {keyword_end, "end"},
17836  {keyword_if, "if"},
17837  {keyword_unless, "unless"},
17838  {keyword_then, "then"},
17839  {keyword_elsif, "elsif"},
17840  {keyword_else, "else"},
17841  {keyword_case, "case"},
17842  {keyword_when, "when"},
17843  {keyword_while, "while"},
17844  {keyword_until, "until"},
17845  {keyword_for, "for"},
17846  {keyword_break, "break"},
17847  {keyword_next, "next"},
17848  {keyword_redo, "redo"},
17849  {keyword_retry, "retry"},
17850  {keyword_in, "in"},
17851  {keyword_do, "do"},
17852  {keyword_do_cond, "do"},
17853  {keyword_do_block, "do"},
17854  {keyword_return, "return"},
17855  {keyword_yield, "yield"},
17856  {keyword_super, "super"},
17857  {keyword_self, "self"},
17858  {keyword_nil, "nil"},
17859  {keyword_true, "true"},
17860  {keyword_false, "false"},
17861  {keyword_and, "and"},
17862  {keyword_or, "or"},
17863  {keyword_not, "not"},
17864  {modifier_if, "if"},
17865  {modifier_unless, "unless"},
17866  {modifier_while, "while"},
17867  {modifier_until, "until"},
17868  {modifier_rescue, "rescue"},
17869  {keyword_alias, "alias"},
17870  {keyword_defined, "defined?"},
17871  {keyword_BEGIN, "BEGIN"},
17872  {keyword_END, "END"},
17873  {keyword__LINE__, "__LINE__"},
17874  {keyword__FILE__, "__FILE__"},
17875  {keyword__ENCODING__, "__ENCODING__"},
17876  {0, NULL}
17877 };
17878 
17879 static const char*
17880 keyword_id_to_str(ID id)
17881 {
17882  const struct kw_assoc *a;
17883 
17884  for (a = keyword_to_name; a->id; a++) {
17885  if (a->id == id)
17886  return a->name;
17887  }
17888  return NULL;
17889 }
17890 
17891 #undef ripper_id2sym
17892 static VALUE
17893 ripper_id2sym(ID id)
17894 {
17895  const char *name;
17896  char buf[8];
17897 
17898  if (id <= 256) {
17899  buf[0] = (char)id;
17900  buf[1] = '\0';
17901  return ID2SYM(rb_intern2(buf, 1));
17902  }
17903  if ((name = keyword_id_to_str(id))) {
17904  return ID2SYM(rb_intern(name));
17905  }
17906  switch (id) {
17907  case tOROP:
17908  name = "||";
17909  break;
17910  case tANDOP:
17911  name = "&&";
17912  break;
17913  default:
17914  name = rb_id2name(id);
17915  if (!name) {
17916  rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17917  }
17918  return ID2SYM(id);
17919  }
17920  return ID2SYM(rb_intern(name));
17921 }
17922 
17923 static ID
17924 ripper_get_id(VALUE v)
17925 {
17926  NODE *nd;
17927  if (!RB_TYPE_P(v, T_NODE)) return 0;
17928  nd = (NODE *)v;
17929  if (nd_type(nd) != NODE_LASGN) return 0;
17930  return nd->nd_vid;
17931 }
17932 
17933 static VALUE
17934 ripper_get_value(VALUE v)
17935 {
17936  NODE *nd;
17937  if (v == Qundef) return Qnil;
17938  if (!RB_TYPE_P(v, T_NODE)) return v;
17939  nd = (NODE *)v;
17940  if (nd_type(nd) != NODE_LASGN) return Qnil;
17941  return nd->nd_rval;
17942 }
17943 
17944 static void
17945 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17946 {
17947  VALUE str;
17948  va_list args;
17949 
17950  va_start(args, fmt);
17951  str = rb_vsprintf(fmt, args);
17952  va_end(args);
17953  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17954 }
17955 
17956 static void
17957 ripper_warn0(struct parser_params *parser, const char *fmt)
17958 {
17959  rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
17960 }
17961 
17962 static void
17963 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
17964 {
17965  rb_funcall(parser->value, rb_intern("warn"), 2,
17966  STR_NEW2(fmt), INT2NUM(a));
17967 }
17968 
17969 static void
17970 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
17971 {
17972  rb_funcall(parser->value, rb_intern("warn"), 2,
17973  STR_NEW2(fmt), STR_NEW2(str));
17974 }
17975 
17976 static void
17977 ripper_warning0(struct parser_params *parser, const char *fmt)
17978 {
17979  rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
17980 }
17981 
17982 static void
17983 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
17984 {
17985  rb_funcall(parser->value, rb_intern("warning"), 2,
17986  STR_NEW2(fmt), STR_NEW2(str));
17987 }
17988 
17989 static VALUE
17990 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
17991 {
17992  return rb_io_gets(src);
17993 }
17994 
17995 static VALUE
17996 ripper_s_allocate(VALUE klass)
17997 {
17998  struct parser_params *p;
17999  VALUE self;
18000 
18001  p = ALLOC_N(struct parser_params, 1);
18002  MEMZERO(p, struct parser_params, 1);
18003  self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
18004  p->value = self;
18005  return self;
18006 }
18007 
18008 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
18009 
18010 /*
18011  * call-seq:
18012  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
18013  *
18014  * Create a new Ripper object.
18015  * _src_ must be a String, an IO, or an Object which has #gets method.
18016  *
18017  * This method does not starts parsing.
18018  * See also Ripper#parse and Ripper.parse.
18019  */
18020 static VALUE
18021 ripper_initialize(int argc, VALUE *argv, VALUE self)
18022 {
18023  struct parser_params *parser;
18024  VALUE src, fname, lineno;
18025 
18026  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18027  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
18028  if (RB_TYPE_P(src, T_FILE)) {
18029  parser->parser_lex_gets = ripper_lex_get_generic;
18030  }
18031  else {
18032  StringValue(src);
18033  parser->parser_lex_gets = lex_get_str;
18034  }
18035  parser->parser_lex_input = src;
18036  parser->eofp = Qfalse;
18037  if (NIL_P(fname)) {
18038  fname = STR_NEW2("(ripper)");
18039  }
18040  else {
18041  StringValue(fname);
18042  }
18043  parser_initialize(parser);
18044 
18045  parser->parser_ruby_sourcefile_string = fname;
18046  parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
18047  parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
18048 
18049  return Qnil;
18050 }
18051 
18052 struct ripper_args {
18053  struct parser_params *parser;
18054  int argc;
18055  VALUE *argv;
18056 };
18057 
18058 static VALUE
18059 ripper_parse0(VALUE parser_v)
18060 {
18061  struct parser_params *parser;
18062 
18063  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
18064  parser_prepare(parser);
18065  ripper_yyparse((void*)parser);
18066  return parser->result;
18067 }
18068 
18069 static VALUE
18070 ripper_ensure(VALUE parser_v)
18071 {
18072  struct parser_params *parser;
18073 
18074  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
18075  parser->parsing_thread = Qnil;
18076  return Qnil;
18077 }
18078 
18079 /*
18080  * call-seq:
18081  * ripper#parse
18082  *
18083  * Start parsing and returns the value of the root action.
18084  */
18085 static VALUE
18086 ripper_parse(VALUE self)
18087 {
18088  struct parser_params *parser;
18089 
18090  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18091  if (!ripper_initialized_p(parser)) {
18092  rb_raise(rb_eArgError, "method called for uninitialized object");
18093  }
18094  if (!NIL_P(parser->parsing_thread)) {
18095  if (parser->parsing_thread == rb_thread_current())
18096  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
18097  else
18098  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
18099  }
18100  parser->parsing_thread = rb_thread_current();
18101  rb_ensure(ripper_parse0, self, ripper_ensure, self);
18102 
18103  return parser->result;
18104 }
18105 
18106 /*
18107  * call-seq:
18108  * ripper#column -> Integer
18109  *
18110  * Return column number of current parsing line.
18111  * This number starts from 0.
18112  */
18113 static VALUE
18114 ripper_column(VALUE self)
18115 {
18116  struct parser_params *parser;
18117  long col;
18118 
18119  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18120  if (!ripper_initialized_p(parser)) {
18121  rb_raise(rb_eArgError, "method called for uninitialized object");
18122  }
18123  if (NIL_P(parser->parsing_thread)) return Qnil;
18124  col = parser->tokp - parser->parser_lex_pbeg;
18125  return LONG2NUM(col);
18126 }
18127 
18128 /*
18129  * call-seq:
18130  * ripper#filename -> String
18131  *
18132  * Return current parsing filename.
18133  */
18134 static VALUE
18135 ripper_filename(VALUE self)
18136 {
18137  struct parser_params *parser;
18138 
18139  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18140  if (!ripper_initialized_p(parser)) {
18141  rb_raise(rb_eArgError, "method called for uninitialized object");
18142  }
18143  return parser->parser_ruby_sourcefile_string;
18144 }
18145 
18146 /*
18147  * call-seq:
18148  * ripper#lineno -> Integer
18149  *
18150  * Return line number of current parsing line.
18151  * This number starts from 1.
18152  */
18153 static VALUE
18154 ripper_lineno(VALUE self)
18155 {
18156  struct parser_params *parser;
18157 
18158  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18159  if (!ripper_initialized_p(parser)) {
18160  rb_raise(rb_eArgError, "method called for uninitialized object");
18161  }
18162  if (NIL_P(parser->parsing_thread)) return Qnil;
18163  return INT2NUM(parser->parser_ruby_sourceline);
18164 }
18165 
18166 #ifdef RIPPER_DEBUG
18167 /* :nodoc: */
18168 static VALUE
18169 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
18170 {
18171  StringValue(msg);
18172  if (obj == Qundef) {
18173  rb_raise(rb_eArgError, "%"PRIsVALUE, msg);
18174  }
18175  return Qnil;
18176 }
18177 
18178 /* :nodoc: */
18179 static VALUE
18180 ripper_value(VALUE self, VALUE obj)
18181 {
18182  return ULONG2NUM(obj);
18183 }
18184 #endif
18185 
18186 
18187 void
18188 Init_ripper(void)
18189 {
18190  parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
18191 
18192  ripper_init_eventids1();
18193  ripper_init_eventids2();
18194  /* ensure existing in symbol table */
18195  (void)rb_intern("||");
18196  (void)rb_intern("&&");
18197 
18198  InitVM(ripper);
18199 }
18200 
18201 void
18202 InitVM_ripper(void)
18203 {
18204  VALUE Ripper;
18205 
18206  Ripper = rb_define_class("Ripper", rb_cObject);
18207  /* version of Ripper */
18208  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
18209  rb_define_alloc_func(Ripper, ripper_s_allocate);
18210  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
18211  rb_define_method(Ripper, "parse", ripper_parse, 0);
18212  rb_define_method(Ripper, "column", ripper_column, 0);
18213  rb_define_method(Ripper, "filename", ripper_filename, 0);
18214  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
18215  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
18216  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
18217  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
18218  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
18219 #ifdef RIPPER_DEBUG
18220  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
18221  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
18222  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
18223 #endif
18224 
18225  ripper_init_eventids1_table(Ripper);
18226  ripper_init_eventids2_table(Ripper);
18227 
18228 # if 0
18229  /* Hack to let RDoc document SCRIPT_LINES__ */
18230 
18231  /*
18232  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
18233  * after the assignment will be added as an Array of lines with the file
18234  * name as the key.
18235  */
18236  rb_define_global_const("SCRIPT_LINES__", Qnil);
18237 #endif
18238 
18239 }
18240 #endif /* RIPPER */
18241 
STRNCASECMP
#define STRNCASECMP(s1, s2, n)
Definition: ruby.h:1784
rb_cString
RUBY_EXTERN VALUE rb_cString
Definition: ruby.h:1583
in_defined
#define in_defined
Definition: ripper.c:383
rb_define_global_const
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:2236
parser_params::parser_ruby_sourcefile
char * parser_ruby_sourcefile
Definition: ripper.c:328
RBASIC_CLEAR_CLASS
#define RBASIC_CLEAR_CLASS(obj)
Definition: internal.h:607
YYSTYPE::val
VALUE val
Definition: parse.h:166
local_var
#define local_var(id)
Definition: ripper.c:564
cond
#define cond(node)
Definition: ripper.c:427
arg_var
#define arg_var(id)
Definition: ripper.c:566
ret_args
#define ret_args(node)
Definition: ripper.c:479
yyparse
#define yyparse
Definition: ripper.c:421
T_OBJECT
#define T_OBJECT
Definition: ruby.h:477
NODE_CALL
Definition: node.h:93
NODE_CASE
Definition: node.h:29
local_vars::cmdargs
stack_type cmdargs
Definition: ripper.c:193
ISDIGIT
#define ISDIGIT(c)
Definition: ruby.h:1775
NEW_RETURN
#define NEW_RETURN(s)
Definition: node.h:389
yytnamerr
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: ripper.c:4733
kwtable::state
enum lex_state_e state
Definition: lex.c:33
parser_params::parser_lvtbl
struct local_vars * parser_lvtbl
Definition: ripper.c:324
rb_ary_unshift
VALUE rb_ary_unshift(VALUE ary, VALUE item)
Definition: array.c:1153
ripper_token2eventid
static ID ripper_token2eventid(int tok)
Definition: eventids2.c:279
kwtable
Definition: lex.c:33
IS_LABEL_SUFFIX
#define IS_LABEL_SUFFIX(n)
Definition: ripper.c:13522
new_args_tail
#define new_args_tail(k, kr, b)
Definition: ripper.c:475
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition: ripper.c:1054
rb_is_attrset_id
int rb_is_attrset_id(ID id)
Definition: ripper.c:17292
rb_enc_codelen
int rb_enc_codelen(int c, rb_encoding *enc)
Definition: encoding.c:1014
NEW_OP_ASGN_AND
#define NEW_OP_ASGN_AND(i, val)
Definition: node.h:409
zero
static double zero(void)
Definition: isinf.c:51
lex_input
#define lex_input
Definition: ripper.c:388
lex_state
#define lex_state
Definition: ripper.c:372
subnodes
#define subnodes(n1, n2)
parser_precise_mbclen
#define parser_precise_mbclen()
Definition: ripper.c:11740
remove_begin
static NODE * remove_begin(NODE *)
Definition: ripper.c:15711
MBCLEN_CHARFOUND_P
#define MBCLEN_CHARFOUND_P(ret)
Definition: encoding.h:139
NEW_STRTERM
#define NEW_STRTERM(func, term, paren)
Definition: ripper.c:12765
yydefgoto
static const yytype_int16 yydefgoto[]
Definition: ripper.c:1885
list_concat
#define list_concat(h, t)
Definition: ripper.c:453
parser_new
static struct parser_params * parser_new(void)
Definition: ripper.c:17576
tRPAREN
Definition: parse.c:872
NEW_OP_ASGN1
#define NEW_OP_ASGN1(p, id, a)
Definition: node.h:405
onig_foreach_name
int onig_foreach_name(regex_t *reg, int(*func)(const UChar *, const UChar *, int, int *, regex_t *, void *), void *arg)
Definition: regparse.c:537
YYSTYPE
union YYSTYPE YYSTYPE
NEW_SCLASS
#define NEW_SCLASS(r, b)
Definition: node.h:448
yydebug
#define yydebug
Definition: ripper.c:405
arg_blk_pass
static NODE * arg_blk_pass(NODE *, NODE *)
Definition: ripper.c:16066
Init_id
static void Init_id(void)
Definition: id.c:14
internal_id_gen
static ID internal_id_gen(struct parser_params *)
Definition: ripper.c:16789
RARRAY_LEN
#define RARRAY_LEN(a)
Definition: ruby.h:878
tSYMBEG
Definition: parse.c:880
rb_bug
void rb_bug(const char *fmt,...)
Definition: error.c:327
YYSTYPE::num
int num
Definition: parse.h:169
IS_END
#define IS_END()
Definition: ripper.c:13518
token_info::next
struct token_info * next
Definition: ripper.c:275
local_vars
Definition: ripper.c:188
ENC_SINGLE
#define ENC_SINGLE(cr)
Definition: ripper.c:365
rb_enc_copy
void rb_enc_copy(VALUE obj1, VALUE obj2)
Definition: encoding.c:916
FALSE
#define FALSE
Definition: nkf.h:174
RUBY_TYPED_FREE_IMMEDIATELY
#define RUBY_TYPED_FREE_IMMEDIATELY
Definition: ruby.h:1015
logop_gen
static NODE * logop_gen(struct parser_params *, enum node_type, NODE *, NODE *)
Definition: ripper.c:15987
reserved_word
static const struct kwtable * reserved_word(const char *, unsigned int)
tail
#define tail
Definition: st.c:108
symbols::minor_marked
int minor_marked
Definition: ripper.c:16721
NEW_LIST
#define NEW_LIST(a)
Definition: node.h:391
rb_is_class_name
int rb_is_class_name(VALUE name)
Definition: ripper.c:17392
local_vars::used
struct vtable * used
Definition: ripper.c:191
tHEREDOC_BEG
#define tHEREDOC_BEG
Definition: eventids2.c:7
rb_parser_compile_file
NODE * rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
Definition: ripper.c:12115
comment_at_top
static int comment_at_top(struct parser_params *parser)
Definition: ripper.c:13263
RE_OPTION_ENCODING_IDX
#define RE_OPTION_ENCODING_IDX(o)
Definition: ripper.c:591
rb_gc_mark_locations
#define rb_gc_mark_locations(start, end)
Definition: gc.c:3316
strlen
size_t strlen(const char *)
assignable
#define assignable(id, node)
Definition: ripper.c:489
INT2NUM
#define INT2NUM(x)
Definition: ruby.h:1288
rb_reg_compile
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2548
parser_memsize
static size_t parser_memsize(const void *ptr)
Definition: ripper.c:17537
parser_params::parser_lex_nextline
VALUE parser_lex_nextline
Definition: ripper.c:315
rb_make_exception
VALUE rb_make_exception(int argc, VALUE *argv)
Definition: eval.c:682
STR_FUNC_ESCAPE
#define STR_FUNC_ESCAPE
Definition: ripper.c:12139
scan_oct
#define scan_oct(s, l, e)
Definition: util.h:50
nd_plen
#define nd_plen
Definition: node.h:333
T_FIXNUM
#define T_FIXNUM
Definition: ruby.h:489
st_table
Definition: st.h:69
stack_type
VALUE stack_type
Definition: ripper.c:164
IDSET_ATTRSET_FOR_SYNTAX
#define IDSET_ATTRSET_FOR_SYNTAX
Definition: ripper.c:16835
reg_compile
#define reg_compile(str, options)
Definition: ripper.c:518
parser_params::nerr
int nerr
Definition: ripper.c:343
rb_id2str
VALUE rb_id2str(ID id)
Definition: ripper.c:17157
call_uni_op_gen
static NODE * call_uni_op_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:15136
NODE_REDO
Definition: node.h:47
toksiz
#define toksiz
Definition: ripper.c:386
NEW_XSTR
#define NEW_XSTR(s)
Definition: node.h:425
YY_
#define YY_(msgid)
Definition: ripper.c:986
parser_params::parser_ruby__end__seen
int parser_ruby__end__seen
Definition: ripper.c:325
parser_params::parser_command_start
int parser_command_start
Definition: ripper.c:320
fixpos
static void fixpos(NODE *, NODE *)
Definition: ripper.c:14886
rb_range_new
VALUE rb_range_new(VALUE, VALUE, int)
Definition: range.c:70
NUM2INT
#define NUM2INT(x)
Definition: ruby.h:630
YYSTACK_FREE
#define YYSTACK_FREE
Definition: ripper.c:1055
NEW_DOT2
#define NEW_DOT2(b, e)
Definition: node.h:453
reduce_nodes_gen
static void reduce_nodes_gen(struct parser_params *, NODE **)
Definition: ripper.c:15731
value_expr
#define value_expr(node)
Definition: ripper.c:438
nd_paren
#define nd_paren(node)
Definition: ripper.c:605
call_bin_op_gen
static NODE * call_bin_op_gen(struct parser_params *, NODE *, ID, NODE *)
Definition: ripper.c:15128
kwtable::name
const char * name
Definition: lex.c:33
tEMBDOC_BEG
#define tEMBDOC_BEG
Definition: eventids2.c:3
parser_tokadd_utf8
static int parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp, int string_literal, int symbol_literal, int regexp_literal)
Definition: ripper.c:12314
parser_params::parser_compile_for_eval
int parser_compile_for_eval
Definition: ripper.c:305
get_id
#define get_id(id)
Definition: ripper.c:526
parser_params::parser_token_info_enabled
int parser_token_info_enabled
Definition: ripper.c:345
rb_usascii_str_new2
#define rb_usascii_str_new2
Definition: intern.h:846
parser_params::parser_brace_nest
int parser_brace_nest
Definition: ripper.c:304
YYLEX
#define YYLEX
Definition: ripper.c:4481
InitVM
#define InitVM(ext)
Definition: ruby.h:1789
new_const_op_assign_gen
static NODE * new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: ripper.c:16201
rb_str_cat
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:2140
YYABORT
#define YYABORT
Definition: ripper.c:4401
idNULL
Definition: id.h:94
nd_line
#define nd_line(n)
Definition: node.h:288
parser_heredoc_restore
static void parser_heredoc_restore(struct parser_params *parser, NODE *here)
Definition: ripper.c:12973
lex_eol_p
#define lex_eol_p()
Definition: ripper.c:12175
Qtrue
#define Qtrue
Definition: ruby.h:426
rb_reg_check_preprocess
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2325
idAREF
Definition: id.h:91
yysyntax_error
static int yysyntax_error(YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
Definition: ripper.c:4781
dyna_in_block
#define dyna_in_block()
Definition: ripper.c:577
CMDARG_LEXPOP
#define CMDARG_LEXPOP()
Definition: ripper.c:178
gettable_gen
static NODE * gettable_gen(struct parser_params *, ID)
Definition: ripper.c:15177
str_copy
#define str_copy(_s, _p, _n)
was_bol
#define was_bol()
Definition: ripper.c:12251
TypedData_Wrap_Struct
#define TypedData_Wrap_Struct(klass, data_type, sval)
Definition: ruby.h:1027
IS_SPCARG
#define IS_SPCARG(c)
Definition: ripper.c:13520
void_stmts
#define void_stmts(node)
Definition: ripper.c:442
global_symbols
static struct symbols global_symbols
tLSHFT
Definition: parse.c:864
reg_named_capture_assign_t
Definition: ripper.c:16499
yystrlen
static YYSIZE_T yystrlen(char *yystr) const
Definition: ripper.c:4684
rb_parser_end_seen_p
VALUE rb_parser_end_seen_p(VALUE vparser)
Definition: ripper.c:17601
TypedData_Get_Struct
#define TypedData_Get_Struct(obj, type, data_type, sval)
Definition: ruby.h:1041
parser_params::parser_in_kwarg
int parser_in_kwarg
Definition: ripper.c:307
id
const int id
Definition: nkf.c:209
current_enc
#define current_enc
Definition: ripper.c:404
parser_params::line_count
int line_count
Definition: ripper.c:326
YYNTOKENS
#define YYNTOKENS
Definition: ripper.c:1151
RString::as
union RString::@109 as
token_info
struct token_info token_info
new_op_assign
#define new_op_assign(lhs, op, rhs)
Definition: ripper.c:550
parser_params::parser_cmdarg_stack
stack_type parser_cmdarg_stack
Definition: ripper.c:298
node_type
node_type
Definition: node.h:22
parser_compile_string
static NODE * parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
Definition: ripper.c:12048
new_args
#define new_args(f, o, r, p, t)
Definition: ripper.c:473
strcasecmp
#define strcasecmp
Definition: win32.h:220
tPOW
Definition: parse.c:849
tDSTAR
Definition: parse.c:877
ID_CONST
#define ID_CONST
Definition: id.h:35
rb_suppress_tracing
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:388
nextc
#define nextc()
Definition: ripper.c:11627
rb_warning0
#define rb_warning0(fmt)
Definition: ripper.c:706
rb_enc_from_encoding
VALUE rb_enc_from_encoding(rb_encoding *encoding)
Definition: encoding.c:102
token_info_push
#define token_info_push(token)
Definition: ripper.c:745
NUM_SUFFIX_R
#define NUM_SUFFIX_R
Definition: ripper.c:13009
rb_eTypeError
VALUE rb_eTypeError
Definition: error.c:548
parser_here_document
static int parser_here_document(struct parser_params *, NODE *)
Definition: ripper.c:13080
YYSTYPE::node
NODE * node
Definition: parse.h:167
T_RATIONAL
#define T_RATIONAL
Definition: ruby.h:495
rb_warnS
#define rb_warnS(fmt, a)
Definition: ripper.c:704
dsym_node
#define dsym_node(node)
Definition: ripper.c:484
rb_magic_comment_length_t
long(* rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len)
Definition: ripper.c:13275
names
st_table * names
Definition: encoding.c:50
ID_JUNK
#define ID_JUNK
Definition: id.h:37
ULONG2NUM
#define ULONG2NUM(x)
Definition: ruby.h:1319
logop
#define logop(type, node1, node2)
Definition: ripper.c:429
rb_ary_push
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:896
rb_long2int
#define rb_long2int(n)
Definition: ruby.h:317
yydestruct
static void yydestruct(char *yymsg, int yytype, YYSTYPE *yyvaluep, struct parser_params *parser) const
Definition: ripper.c:4920
NEW_CLASS
#define NEW_CLASS(n, b, s)
Definition: node.h:447
MAX_WORD_LENGTH
#define MAX_WORD_LENGTH
Definition: lex.c:43
evstr2dstr_gen
static NODE * evstr2dstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15105
rb_eEncodingError
VALUE rb_eEncodingError
Definition: error.c:554
reg_named_capture_assign_iter
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: ripper.c:16508
warn_unused_var
static void warn_unused_var(struct parser_params *parser, struct local_vars *local)
Definition: ripper.c:16236
SYM2ID
#define SYM2ID(x)
Definition: ruby.h:356
RString::basic
struct RBasic basic
Definition: ruby.h:821
yytype_uint16
unsigned short int yytype_uint16
Definition: ripper.c:953
parse_string
#define parse_string(n)
Definition: ripper.c:11637
rb_enc_compatible
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:849
tLPAREN
Definition: parse.c:870
NEW_OPT_N
#define NEW_OPT_N(b)
Definition: node.h:375
rb_reserved_word
const struct kwtable * rb_reserved_word(const char *str, unsigned int len)
Definition: ripper.c:17570
is_identchar
#define is_identchar(p, e, enc)
Definition: ripper.c:11741
symbols::op_sym
VALUE op_sym[tLAST_OP_ID]
Definition: ripper.c:16720
COND_PUSH
#define COND_PUSH(n)
Definition: ripper.c:171
parser_params::debug_lines
VALUE debug_lines
Definition: ripper.c:341
rb_funcall
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
Definition: vm_eval.c:775
warn_balanced
#define warn_balanced(op, syn)
Definition: ripper.c:13532
YYSTYPE::id
ID id
Definition: parse.h:168
match_op
#define match_op(node1, node2)
Definition: ripper.c:510
CMDARG_P
#define CMDARG_P()
Definition: ripper.c:179
dvar_defined
#define dvar_defined(id)
Definition: ripper.c:580
yyerrok
#define yyerrok
Definition: ripper.c:4395
YYEMPTY
#define YYEMPTY
Definition: ripper.c:4397
tok
#define tok()
Definition: ripper.c:12254
rb_enc_str_coderange
int rb_enc_str_coderange(VALUE)
Definition: string.c:435
ripper_init_eventids1_table
static void ripper_init_eventids1_table(VALUE self)
Definition: eventids1.c:270
reg_fragment_setenc
#define reg_fragment_setenc(str, options)
Definition: ripper.c:520
match_op_gen
static NODE * match_op_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15143
rb_raise
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1854
rb_warn4S
#define rb_warn4S(file, line, fmt, a)
Definition: ripper.c:705
tCMP
Definition: parse.c:850
rb_warnI
#define rb_warnI(fmt, a)
Definition: ripper.c:703
NEW_NIL
#define NEW_NIL()
Definition: node.h:456
RSTRING_GETMEM
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Definition: ruby.h:854
node_assign_gen
static NODE * node_assign_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15520
rb_enc_associate
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
Definition: encoding.c:826
block_append_gen
static NODE * block_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14909
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: ripper.c:4498
newline_node
static NODE * newline_node(NODE *)
Definition: ripper.c:14876
reg_named_capture_assign_t::succ_block
NODE * succ_block
Definition: ripper.c:16502
vtable::tbl
ID * tbl
Definition: ripper.c:182
rb_data_type_struct::parent
const rb_data_type_t * parent
Definition: ruby.h:975
rb_compile_warn
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:179
newtok
#define newtok()
Definition: ripper.c:11629
range_op
static NODE * range_op(struct parser_params *parser, NODE *node)
Definition: ripper.c:15886
reduce_nodes
#define reduce_nodes(n)
Definition: ripper.c:444
YYPOPSTACK
#define YYPOPSTACK(N)
dyna_var
#define dyna_var(id)
Definition: ripper.c:578
rb_args_info::pre_args_num
int pre_args_num
Definition: node.h:514
RB_GC_GUARD
#define RB_GC_GUARD(v)
Definition: ruby.h:523
rb_define_alloc_func
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
NODE_HEREDOC
#define NODE_HEREDOC
Definition: ripper.c:597
T_HASH
#define T_HASH
Definition: ruby.h:485
parser_params::parser_toksiz
int parser_toksiz
Definition: ripper.c:311
POINTER_P
#define POINTER_P(val)
Definition: ripper.c:199
remove_begin_all
static NODE * remove_begin_all(NODE *)
Definition: ripper.c:15721
STR_FUNC_INDENT
#define STR_FUNC_INDENT
Definition: ripper.c:12144
rb_enc_mbclen
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
Definition: encoding.c:946
ID_LOCAL
#define ID_LOCAL
Definition: id.h:31
rb_str_hash
st_index_t rb_str_hash(VALUE)
Definition: string.c:2422
nd_args
#define nd_args
Definition: node.h:337
tLAMBEG
Definition: parse.c:892
parser_pushback
static void parser_pushback(struct parser_params *parser, int c)
Definition: ripper.c:12242
nd_set_type
#define nd_set_type(n, t)
Definition: node.h:283
symbols::last_id
ID last_id
Definition: ripper.c:16713
Qnone
#define Qnone
Definition: ripper.c:694
lvar_defined_gen
static int lvar_defined_gen(struct parser_params *, ID)
Definition: ripper.c:13204
alias
const char * alias
Definition: nkf.c:1151
rb_gc_mark
void rb_gc_mark(VALUE ptr)
Definition: gc.c:3604
ruby__end__seen
#define ruby__end__seen
Definition: ripper.c:400
rb_magic_comment_setter_t
void(* rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13276
T_ARRAY
#define T_ARRAY
Definition: ruby.h:484
NEW_DOT3
#define NEW_DOT3(b, e)
Definition: node.h:454
ruby_debug_lines
#define ruby_debug_lines
Definition: ripper.c:410
parser_is_identchar
#define parser_is_identchar()
Definition: ripper.c:11742
rb_enc_islower
#define rb_enc_islower(c, enc)
Definition: encoding.h:180
local_pop
#define local_pop()
Definition: ripper.c:562
re_pattern_buffer
Definition: oniguruma.h:658
NEW_ITER
#define NEW_ITER(a, b)
Definition: node.h:379
parser_whole_match_p
static int parser_whole_match_p(struct parser_params *parser, const char *eos, long len, int indent)
Definition: ripper.c:12991
RE_OPTION_ENCODING
#define RE_OPTION_ENCODING(e)
Definition: ripper.c:590
rb_backref_error
#define rb_backref_error(n)
Definition: ripper.c:497
rb_args_info::pre_init
NODE * pre_init
Definition: node.h:511
NEW_IVAR
#define NEW_IVAR(v)
Definition: node.h:414
last
unsigned int last
Definition: nkf.c:4310
parser_initialize
static void parser_initialize(struct parser_params *parser)
Definition: ripper.c:17440
rb_args_info::block_arg
ID block_arg
Definition: node.h:520
node_newnode
static NODE * node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE)
Definition: ripper.c:14856
yyr1
static const yytype_uint16 yyr1[]
Definition: ripper.c:1636
rb_check_id
ID rb_check_id(volatile VALUE *namep)
Returns ID for the given name if it is interned already, or 0.
Definition: ripper.c:17321
rb_check_id_cstr
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
Definition: ripper.c:17363
RNode::node
struct RNode * node
Definition: node.h:243
NEW_IASGN
#define NEW_IASGN(v, val)
Definition: node.h:400
FIXNUM_P
#define FIXNUM_P(f)
Definition: ruby.h:347
lex_gets_ptr
#define lex_gets_ptr
Definition: ripper.c:397
rb_utf8_encoding
rb_encoding * rb_utf8_encoding(void)
Definition: encoding.c:1242
here_document
#define here_document(n)
Definition: ripper.c:11639
parser_params::parser_lex_input
VALUE parser_lex_input
Definition: ripper.c:313
parser_encode_length
static long parser_encode_length(struct parser_params *parser, const char *name, long len)
Definition: ripper.c:13211
nd_type
#define nd_type(n)
Definition: node.h:282
is_instance_id
#define is_instance_id(id)
Definition: ripper.c:111
call_bin_op
#define call_bin_op(recv, id, arg1)
Definition: ripper.c:468
tASSOC
Definition: parse.c:869
arg_concat
#define arg_concat(h, t)
Definition: ripper.c:457
nodetype
static enum node_type nodetype(NODE *node)
Definition: ripper.c:14864
rb_str_buf_append
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2282
rb_sym_all_symbols
VALUE rb_sym_all_symbols(void)
Definition: ripper.c:17259
lex_getline
static VALUE lex_getline(struct parser_params *parser)
Definition: ripper.c:12025
ret_args_gen
static NODE * ret_args_gen(struct parser_params *, NODE *)
Definition: ripper.c:16010
yytable
static const yytype_int16 yytable[]
Definition: ripper.c:2053
RUBY_DTRACE_PARSE_BEGIN
#define RUBY_DTRACE_PARSE_BEGIN(arg0, arg1)
Definition: probes.h:55
vtable::pos
int pos
Definition: ripper.c:183
parser_params::parser_ruby_sourcefile_string
VALUE parser_ruby_sourcefile_string
Definition: ripper.c:330
RNode::u3
union RNode::@131 u3
tGVAR
Definition: parse.c:833
tLOWEST
Definition: parse.c:893
YYLAST
#define YYLAST
Definition: ripper.c:1148
YYID
#define YYID(n)
Definition: ripper.c:999
rb_enc_symname2_p
int rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:16935
yycompile
static NODE * yycompile(struct parser_params *parser, VALUE fname, int line)
Definition: ripper.c:11985
rb_parser_set_yydebug
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: ripper.c:17646
ENC_CODERANGE_7BIT
#define ENC_CODERANGE_7BIT
Definition: encoding.h:49
rb_obj_classname
const char * rb_obj_classname(VALUE)
Definition: variable.c:406
rb_gc_force_recycle
void rb_gc_force_recycle(VALUE p)
Definition: gc.c:4897
yylex
static int yylex(void *, void *)
Definition: ripper.c:14829
rb_ary_new2
#define rb_ary_new2
Definition: intern.h:90
NEW_SCOPE
#define NEW_SCOPE(a, b)
Definition: node.h:369
head
#define head
Definition: st.c:107
ruby_sourcefile
#define ruby_sourcefile
Definition: ripper.c:402
memmove
RUBY_EXTERN void * memmove(void *, const void *, size_t)
Definition: memmove.c:7
OnigUChar
unsigned char OnigUChar
Definition: oniguruma.h:111
parser_params::parser_yydebug
int parser_yydebug
Definition: ripper.c:333
gettable
#define gettable(id)
Definition: ripper.c:487
NODE_IF
Definition: node.h:27
symbols::id_str
st_table * id_str
Definition: ripper.c:16715
parser_params::parser_eval_tree
NODE * parser_eval_tree
Definition: ripper.c:340
list_append
#define list_append(l, i)
Definition: ripper.c:451
parser_params::parser_deferred_nodes
NODE * parser_deferred_nodes
Definition: ripper.c:321
sym
#define sym(x)
Definition: date_core.c:3695
simple_re_meta
static int simple_re_meta(int c)
Definition: ripper.c:12619
rb_str_buf_cat
VALUE rb_str_buf_cat(VALUE, const char *, long)
Definition: string.c:2124
st_data_t
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
Definition: st.h:20
rb_name_error
void rb_name_error(ID id, const char *fmt,...)
Definition: error.c:967
__sFILE
Definition: vsnprintf.c:175
STR_NEW0
#define STR_NEW0()
Definition: ripper.c:362
RNode
Definition: node.h:239
e_option_supplied
static int e_option_supplied(struct parser_params *parser)
Definition: ripper.c:11918
block_dup_check_gen
static void block_dup_check_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15400
YYSTYPE
Definition: parse.h:161
parser_params::has_shebang
int has_shebang
Definition: ripper.c:327
NUM_SUFFIX_I
#define NUM_SUFFIX_I
Definition: ripper.c:13010
NEWHEAP
#define NEWHEAP()
Definition: ripper.c:17657
SPECIAL_PUNCT
#define SPECIAL_PUNCT(idx)
Definition: ripper.c:12792
vtable_size
static int vtable_size(const struct vtable *tbl)
Definition: ripper.c:202
assign_in_cond
static int assign_in_cond(struct parser_params *parser, NODE *node)
Definition: ripper.c:15816
ISALPHA
#define ISALPHA(c)
Definition: ruby.h:1774
rb_exc_raise
void rb_exc_raise(VALUE mesg)
Definition: eval.c:567
STR_FUNC_REGEXP
#define STR_FUNC_REGEXP
Definition: ripper.c:12141
NEW_VCALL
#define NEW_VCALL(m)
Definition: node.h:431
list_append_gen
static NODE * list_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14963
strtod
#define strtod(s, e)
Definition: util.h:74
must_be_ascii_compatible
static rb_encoding * must_be_ascii_compatible(VALUE s)
Definition: ripper.c:11995
vtable::prev
struct vtable * prev
Definition: ripper.c:185
rb_is_const_id
int rb_is_const_id(ID id)
Definition: ripper.c:17268
rb_is_instance_id
int rb_is_instance_id(ID id)
Definition: ripper.c:17286
RBASIC_SET_CLASS_RAW
#define RBASIC_SET_CLASS_RAW(obj, cls)
Definition: internal.h:608
NEW_VALIAS
#define NEW_VALIAS(n, o)
Definition: node.h:445
RUBY_DTRACE_PARSE_END
#define RUBY_DTRACE_PARSE_END(arg0, arg1)
Definition: probes.h:58
parser_number_literal_suffix
static int parser_number_literal_suffix(struct parser_params *parser, int mask)
Definition: ripper.c:13014
RB_TYPE_P
#define RB_TYPE_P(obj, type)
Definition: ruby.h:1664
rb_args_info
Definition: node.h:510
parser_tokadd_string
static int parser_tokadd_string(struct parser_params *, int, int, int, long *, rb_encoding **)
Definition: ripper.c:12632
NEW_LVAR
#define NEW_LVAR(v)
Definition: node.h:412
VTBL_DEBUG
#define VTBL_DEBUG
Definition: ripper.c:212
rb_is_method_name
int rb_is_method_name(VALUE name)
Definition: ripper.c:17422
arg_append
#define arg_append(h, t)
Definition: ripper.c:455
st_hash_type
Definition: st.h:55
assignable_result
#define assignable_result(x)
st_lookup
int st_lookup(st_table *, st_data_t, st_data_t *)
CMDARG_PUSH
#define CMDARG_PUSH(n)
Definition: ripper.c:176
NEW_ATTRASGN
#define NEW_ATTRASGN(r, m, a)
Definition: node.h:464
MEMZERO
#define MEMZERO(p, type, n)
Definition: ruby.h:1351
RString
Definition: ruby.h:820
coverage
static VALUE coverage(VALUE fname, int n)
Definition: ripper.c:11902
RE_OPTION_MASK
#define RE_OPTION_MASK
Definition: ripper.c:593
ID_SCOPE_MASK
#define ID_SCOPE_MASK
Definition: id.h:30
arg_concat_gen
static NODE * arg_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15469
parser_params::enc
rb_encoding * enc
Definition: ripper.c:331
parser_warning
#define parser_warning(node, mesg)
Definition: ripper.c:14899
parser_regx_options
static int parser_regx_options(struct parser_params *)
Definition: ripper.c:12560
yy_symbol_value_print
static void yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: ripper.c:4521
parser_params::parser_lex_state
enum lex_state_e parser_lex_state
Definition: ripper.c:296
whole_match_p
#define whole_match_p(e, l, i)
Definition: ripper.c:11642
op_tbl_count
#define op_tbl_count
Definition: ripper.c:16706
NEW_POSTEXE
#define NEW_POSTEXE(b)
Definition: node.h:462
vtable::capa
int capa
Definition: ripper.c:184
parser_params::parser_lex_lastline
VALUE parser_lex_lastline
Definition: ripper.c:314
lex_nextline
#define lex_nextline
Definition: ripper.c:390
YYTERROR
#define YYTERROR
Definition: ripper.c:4439
rb_parser_compile_string
NODE * rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
Definition: ripper.c:12074
set_yylval_literal
#define set_yylval_literal(x)
Definition: ripper.c:11652
parser_yylex
static int parser_yylex(struct parser_params *parser)
Definition: ripper.c:13538
parser_str_new
static VALUE parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
Definition: ripper.c:12158
scan_hex
#define scan_hex(s, l, e)
Definition: util.h:52
dyna_in_block_gen
static int dyna_in_block_gen(struct parser_params *)
Definition: ripper.c:16402
NEW_IF
#define NEW_IF(c, t, e)
Definition: node.h:371
yystos
static const yytype_uint16 yystos[]
Definition: ripper.c:4285
rb_rational_raw1
#define rb_rational_raw1(x)
Definition: intern.h:167
parser_tokspace
static char * parser_tokspace(struct parser_params *parser, int n)
Definition: ripper.c:12275
RARRAY
#define RARRAY(obj)
Definition: ruby.h:1123
arg_ambiguous
#define arg_ambiguous()
Definition: ripper.c:13190
ALLOC_N
#define ALLOC_N(type, n)
Definition: ruby.h:1333
rb_hash_aset
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
Definition: hash.c:1393
rb_compile_error_append
void rb_compile_error_append(const char *fmt,...)
Definition: error.c:157
rb_compile_error_with_enc
void rb_compile_error_with_enc(const char *file, int line, void *enc, const char *fmt,...)
Definition: error.c:133
evstr2dstr
#define evstr2dstr(n)
Definition: ripper.c:464
parser_free
static void parser_free(void *ptr)
Definition: ripper.c:17520
IS_ARG
#define IS_ARG()
Definition: ripper.c:13517
PARSER_ARG
#define PARSER_ARG
Definition: ripper.c:730
NEW_PRELUDE
#define NEW_PRELUDE(p, b)
Definition: node.h:465
literal_concat
#define literal_concat(h, t)
Definition: ripper.c:459
val
#define val
rb_ispunct
int rb_ispunct(int c)
Definition: encoding.c:1929
tCHAR
Definition: parse.c:843
NEW_ARRAY
#define NEW_ARRAY(a)
Definition: node.h:392
rb_cObject
RUBY_EXTERN VALUE rb_cObject
Definition: ruby.h:1553
rb_eRuntimeError
VALUE rb_eRuntimeError
Definition: error.c:547
compile_error
#define compile_error
Definition: ripper.c:729
symbols_i
static int symbols_i(VALUE sym, ID value, VALUE ary)
Definition: ripper.c:17236
ID_INSTANCE
#define ID_INSTANCE
Definition: id.h:32
yylval
#define yylval
Definition: ripper.c:11618
parser_tokadd_escape
static int parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
Definition: ripper.c:12487
rb_enc_isascii
#define rb_enc_isascii(c, enc)
Definition: encoding.h:178
dvar_curr_gen
static int dvar_curr_gen(struct parser_params *, ID)
Definition: ripper.c:16439
rb_parser_encoding
VALUE rb_parser_encoding(VALUE vparser)
Definition: ripper.c:17616
ifndef_ripper
#define ifndef_ripper(x)
Definition: ripper.c:695
yyrline
static const yytype_uint16 yyrline[]
Definition: ripper.c:1474
rb_str_free
void rb_str_free(VALUE)
Definition: string.c:941
reg_named_capture_assign_t::parser
struct parser_params * parser
Definition: ripper.c:16500
yytable_value_is_error
#define yytable_value_is_error(yytable_value)
Definition: ripper.c:3168
cur_mid
#define cur_mid
Definition: ripper.c:382
NEW_HASH
#define NEW_HASH(a)
Definition: node.h:394
rb_get_coverages
VALUE rb_get_coverages(void)
Definition: thread.c:5287
RNode::u2
union RNode::@130 u2
NEW_ZARRAY
#define NEW_ZARRAY()
Definition: node.h:393
rb_compile_string
NODE * rb_compile_string(const char *f, VALUE s, int line)
Definition: ripper.c:12067
yyprhs
static const yytype_uint16 yyprhs[]
Definition: ripper.c:1210
NEW_FALSE
#define NEW_FALSE()
Definition: node.h:458
rb_obj_as_string
VALUE rb_obj_as_string(VALUE)
Definition: string.c:1011
list_concat_gen
static NODE * list_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:14983
parser_params::parser_paren_nest
int parser_paren_nest
Definition: ripper.c:300
rb_ary_new
VALUE rb_ary_new(void)
Definition: array.c:495
NEW_ARGSPUSH
#define NEW_ARGSPUSH(a, b)
Definition: node.h:439
is_attrset_id
#define is_attrset_id(id)
Definition: ripper.c:112
set_yylval_name
#define set_yylval_name(x)
Definition: ripper.c:11651
NEW_REDO
#define NEW_REDO()
Definition: node.h:383
NEW_NTH_REF
#define NEW_NTH_REF(n)
Definition: node.h:417
IDSET_ATTRSET_FOR_INTERN
#define IDSET_ATTRSET_FOR_INTERN
Definition: ripper.c:16836
tokline
#define tokline
Definition: ripper.c:387
NEW_UNLESS
#define NEW_UNLESS(c, t, e)
Definition: node.h:372
parser_newtok
static char * parser_newtok(struct parser_params *parser)
Definition: ripper.c:12259
rb_mKernel
RUBY_EXTERN VALUE rb_mKernel
Definition: ruby.h:1541
snprintf
#define snprintf
Definition: subst.h:6
rb_thread_current
VALUE rb_thread_current(void)
Definition: thread.c:2401
vtable_included
static int vtable_included(const struct vtable *tbl, ID id)
Definition: ripper.c:254
block_dup_check
#define block_dup_check(n1, n2)
Definition: ripper.c:446
tokadd
#define tokadd(c)
Definition: ripper.c:11631
arg_append_gen
static NODE * arg_append_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15494
local_push_gen
static void local_push_gen(struct parser_params *, int)
Definition: ripper.c:16256
NIL_P
#define NIL_P(v)
Definition: ruby.h:438
ISASCII
#define ISASCII(c)
Definition: ruby.h:1766
st_add_direct
void st_add_direct(st_table *, st_data_t, st_data_t)
Definition: st.c:629
tokenbuf
#define tokenbuf
Definition: ripper.c:384
rb_define_class
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:630
msg
static char msg[50]
Definition: strerror.c:8
rb_intern
ID rb_intern(const char *name)
Definition: ripper.c:17141
COND_POP
#define COND_POP()
Definition: ripper.c:172
NEW_GVAR
#define NEW_GVAR(v)
Definition: node.h:411
heredoc_identifier
#define heredoc_identifier()
Definition: ripper.c:11640
rb_args_info::opt_args
NODE * opt_args
Definition: node.h:525
parser_set_token_info
static void parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13288
NEW_YIELD
#define NEW_YIELD(a)
Definition: node.h:390
YYSYNTAX_ERROR
#define YYSYNTAX_ERROR
new_const_op_assign
#define new_const_op_assign(lhs, op, rhs)
Definition: ripper.c:505
rb_define_const
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:2225
RNode::value
VALUE value
Definition: node.h:245
parser_tokadd
static void parser_tokadd(struct parser_params *parser, int c)
Definition: ripper.c:12287
ID_SCOPE_SHIFT
#define ID_SCOPE_SHIFT
Definition: id.h:29
k__END__
#define k__END__
Definition: eventids2.c:9
parser_mark
static void parser_mark(void *ptr)
Definition: ripper.c:17494
yy_reduce_print
static void yy_reduce_print(YYSTYPE *yyvsp, int yyrule, struct parser_params *parser)
Definition: ripper.c:4613
ISALNUM
#define ISALNUM(c)
Definition: ruby.h:1773
YYDPRINTF
#define YYDPRINTF(Args)
Definition: ripper.c:4492
NEW_CASE
#define NEW_CASE(h, b)
Definition: node.h:373
cnt
rb_atomic_t cnt[RUBY_NSIG]
Definition: signal.c:489
RFLOAT
#define RFLOAT(obj)
Definition: ruby.h:1120
tFLOAT
Definition: parse.c:839
lex_goto_eol
#define lex_goto_eol(parser)
Definition: ripper.c:12174
magic_comment
Definition: ripper.c:13309
one
static double one(void)
Definition: isinf.c:52
RNode::u1
union RNode::@129 u1
tLABEL
Definition: parse.c:837
tLBRACE
Definition: parse.c:874
FLONUM_P
#define FLONUM_P(x)
Definition: ruby.h:367
local_id
#define local_id(id)
Definition: ripper.c:568
T_FLOAT
#define T_FLOAT
Definition: ruby.h:481
rb_parser_append_print
NODE * rb_parser_append_print(VALUE vparser, NODE *node)
Definition: ripper.c:16609
TYPE
#define TYPE(x)
Definition: ruby.h:505
ripper_init_eventids1
static void ripper_init_eventids1(void)
Definition: eventids1.c:134
argc
int argc
Definition: ruby.c:131
NODE_AND
Definition: node.h:59
yyalloc::yyss_alloc
yytype_int16 yyss_alloc
Definition: ripper.c:1092
vtable_add
static void vtable_add(struct vtable *tbl, ID id)
Definition: ripper.c:239
tAREF
Definition: parse.c:862
RString::ary
char ary[RSTRING_EMBED_LEN_MAX+1]
Definition: ruby.h:831
YYFINAL
#define YYFINAL
Definition: ripper.c:1146
Qfalse
#define Qfalse
Definition: ruby.h:425
dvar_curr
#define dvar_curr(id)
Definition: ripper.c:583
rb_sourcefile
#define rb_sourcefile()
Definition: tcltklib.c:98
NEW_EVSTR
#define NEW_EVSTR(n)
Definition: node.h:428
rb_rational_new
VALUE rb_rational_new(VALUE, VALUE)
Definition: rational.c:1760
ALLOCA_N
#define ALLOCA_N(type, n)
Definition: ruby.h:1337
flush_string_content
#define flush_string_content(enc)
Definition: ripper.c:12784
NEW_OP_CDECL
#define NEW_OP_CDECL(v, op, val)
Definition: node.h:410
T_BIGNUM
#define T_BIGNUM
Definition: ruby.h:487
ENC_CODERANGE_UNKNOWN
#define ENC_CODERANGE_UNKNOWN
Definition: encoding.h:48
tokadd_string
#define tokadd_string(f, t, p, n, e)
Definition: ripper.c:11636
new_yield_gen
static NODE * new_yield_gen(struct parser_params *, NODE *)
Definition: ripper.c:16027
ripper_flush
#define ripper_flush(p)
Definition: ripper.c:11671
lex_get_str
static VALUE lex_get_str(struct parser_params *parser, VALUE s)
Definition: ripper.c:12005
ISUPPER
#define ISUPPER(c)
Definition: ruby.h:1771
RUBY_FUNC_EXPORTED
#define RUBY_FUNC_EXPORTED
Definition: defines.h:246
MEMCPY
#define MEMCPY(p1, p2, type, n)
Definition: ruby.h:1352
T_NODE
#define T_NODE
Definition: ruby.h:498
ENC_CODERANGE_BROKEN
#define ENC_CODERANGE_BROKEN
Definition: encoding.h:51
tLAMBDA
Definition: parse.c:879
rb_enc_isupper
#define rb_enc_isupper(c, enc)
Definition: encoding.h:181
rb_enc_associate_index
VALUE rb_enc_associate_index(VALUE obj, int idx)
Definition: encoding.c:798
rb_parse_in_main
int rb_parse_in_main(void)
Definition: compile.c:5948
parser_nextc
static int parser_nextc(struct parser_params *parser)
Definition: ripper.c:12180
err
int err
Definition: win32.c:114
dyna_pop
#define dyna_pop(node)
Definition: ripper.c:575
tLEQ
Definition: parse.c:855
OBJ_FREEZE
#define OBJ_FREEZE(x)
Definition: ruby.h:1186
YYACCEPT
#define YYACCEPT
Definition: ripper.c:4400
parser_params::parser_lex_pend
const char * parser_lex_pend
Definition: ripper.c:318
formal_argument_gen
static ID formal_argument_gen(struct parser_params *, ID)
Definition: ripper.c:13193
void_expr_gen
static void void_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15608
T_COMPLEX
#define T_COMPLEX
Definition: ruby.h:496
YYEOF
#define YYEOF
Definition: ripper.c:4398
nd_else
#define nd_else
Definition: node.h:300
dsym_node_gen
static NODE * dsym_node_gen(struct parser_params *, NODE *)
Definition: ripper.c:16129
set_integer_literal
#define set_integer_literal(v, f)
Definition: ripper.c:11645
NUM_SUFFIX_ALL
#define NUM_SUFFIX_ALL
Definition: ripper.c:13011
RNode::cnt
long cnt
Definition: node.h:261
token
ID token
Definition: ripper.c:16682
intern_str
static ID intern_str(VALUE str)
Definition: ripper.c:17021
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: ripper.c:4635
rb_parser_while_loop
NODE * rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
Definition: ripper.c:16641
U
Definition: util.c:792
rb_compile_cstr
NODE * rb_compile_cstr(const char *f, const char *s, int len, int line)
Definition: ripper.c:12087
parser_params::parser_token_info
token_info * parser_token_info
Definition: ripper.c:346
magic_comment_encoding
static void magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13279
token_info::column
int column
Definition: ripper.c:273
yystpcpy
static char * yystpcpy(char *yydest, const char *yysrc)
Definition: ripper.c:4708
numberof
#define numberof(array)
Definition: etc.c:595
IS_lex_state
#define IS_lex_state(ls)
Definition: ripper.c:158
rb_make_backtrace
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:817
ALLOC
#define ALLOC(type)
Definition: ruby.h:1334
END
#define END(no)
Definition: re.c:26
NEW_FOR
#define NEW_FOR(v, i, b)
Definition: node.h:378
EOF
#define EOF
Definition: vsnprintf.c:207
rb_parser_malloc
void * rb_parser_malloc(struct parser_params *parser, size_t size)
Definition: ripper.c:17662
setup_fake_str
static VALUE setup_fake_str(struct RString *fake_str, const char *name, long len)
Definition: ripper.c:16994
NEW_WHEN
#define NEW_WHEN(c, t, e)
Definition: node.h:374
peek_n
#define peek_n(c, n)
Definition: ripper.c:12177
rb_str_resize
VALUE rb_str_resize(VALUE, long)
Definition: string.c:2025
DEF_EXPR
#define DEF_EXPR(n)
Definition: ripper.c:140
tHEREDOC_END
#define tHEREDOC_END
Definition: eventids2.c:8
STR_NEW
#define STR_NEW(p, n)
Definition: ripper.c:361
NEW_DASGN
#define NEW_DASGN(v, val)
Definition: node.h:398
yyalloc::yyvs_alloc
YYSTYPE yyvs_alloc
Definition: ripper.c:1093
parser_peek_variable_name
static int parser_peek_variable_name(struct parser_params *parser)
Definition: ripper.c:12816
tokcopy
#define tokcopy(n)
Definition: ripper.c:12310
STR_FUNC_SYMBOL
#define STR_FUNC_SYMBOL
Definition: ripper.c:12143
yycompile0
static VALUE yycompile0(VALUE arg)
Definition: ripper.c:11924
mixed_escape
#define mixed_escape(beg, enc1, enc2)
rb_str_hash_cmp
int rb_str_hash_cmp(VALUE, VALUE)
Definition: string.c:2432
set_yylval_num
#define set_yylval_num(x)
Definition: ripper.c:11649
register_symid_str
static ID register_symid_str(ID, VALUE)
Definition: ripper.c:16958
NEW_ERRINFO
#define NEW_ERRINFO()
Definition: node.h:459
NEW_BLOCK_PASS
#define NEW_BLOCK_PASS(b)
Definition: node.h:443
STR_FUNC_QWORDS
#define STR_FUNC_QWORDS
Definition: ripper.c:12142
tANDOP
Definition: parse.c:856
dyna_push
#define dyna_push()
Definition: ripper.c:573
command_start
#define command_start
Definition: ripper.c:395
string_type
string_type
Definition: ripper.c:12146
rb_dvar_defined
int rb_dvar_defined(ID id)
Definition: compile.c:5898
dispose_string
static void dispose_string(VALUE str)
Definition: ripper.c:12596
is_notop_id
#define is_notop_id(id)
Definition: ripper.c:108
RSTRING_LEN
#define RSTRING_LEN(str)
Definition: ruby.h:841
aryset_gen
static NODE * aryset_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15392
parser_params::parser_in_single
int parser_in_single
Definition: ripper.c:302
lex_state_bits
lex_state_bits
Definition: ripper.c:123
RUBY_DTRACE_PARSE_END_ENABLED
#define RUBY_DTRACE_PARSE_END_ENABLED()
Definition: probes.h:57
shadowing_lvar_gen
static ID shadowing_lvar_gen(struct parser_params *, ID)
Definition: ripper.c:15371
set_number_literal
#define set_number_literal(v, t, f)
Definition: ripper.c:11644
rb_args_info::rest_arg
ID rest_arg
Definition: node.h:519
REALLOC_N
#define REALLOC_N(var, type, n)
Definition: ruby.h:1335
local_push
#define local_push(top)
Definition: ripper.c:560
func
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:113
errno
int errno
TRUE
#define TRUE
Definition: nkf.h:175
rb_symname_p
int rb_symname_p(const char *name)
Definition: ripper.c:16824
nd_next
#define nd_next
Definition: node.h:296
new_attr_op_assign
#define new_attr_op_assign(lhs, type, attr, op, rhs)
Definition: ripper.c:503
NEW_CONST
#define NEW_CONST(v)
Definition: node.h:415
shadowing_lvar_0
static int shadowing_lvar_0(struct parser_params *parser, ID name)
Definition: ripper.c:15346
yy_stack_print
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
Definition: ripper.c:4582
NEW_LIT
#define NEW_LIT(l)
Definition: node.h:422
rb_io_gets
VALUE rb_io_gets(VALUE)
Definition: io.c:3187
paren_nest
#define paren_nest
Definition: ripper.c:376
token_info_pop
#define token_info_pop(token)
Definition: ripper.c:746
dyna_pop_gen
static void dyna_pop_gen(struct parser_params *, const struct vtable *)
Definition: ripper.c:16388
new_evstr_gen
static NODE * new_evstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15114
rb_sprintf
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1250
IS_lex_state_for
#define IS_lex_state_for(x, ls)
Definition: ripper.c:157
tokadd_mbchar
#define tokadd_mbchar(c)
Definition: ripper.c:12616
reg_fragment_setenc_gen
static void reg_fragment_setenc_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16447
NEW_OP_ASGN_OR
#define NEW_OP_ASGN_OR(i, val)
Definition: node.h:408
rb_enc_isspace
#define rb_enc_isspace(c, enc)
Definition: encoding.h:185
rb_node_newnode
#define rb_node_newnode(type, a1, a2, a3)
Definition: ripper.c:424
YYMAXDEPTH
#define YYMAXDEPTH
Definition: ripper.c:4667
NEW_NEXT
#define NEW_NEXT(s)
Definition: node.h:382
set_file_encoding
static void set_file_encoding(struct parser_params *parser, const char *str, const char *send)
Definition: ripper.c:13450
const
#define const
Definition: strftime.c:102
rb_enc_name
#define rb_enc_name(enc)
Definition: encoding.h:125
rb_is_attrset_name
int rb_is_attrset_name(VALUE name)
Definition: ripper.c:17410
RE_OPTION_ONCE
#define RE_OPTION_ONCE
Definition: ripper.c:588
rb_enc_symname_p
int rb_enc_symname_p(const char *name, rb_encoding *enc)
Definition: ripper.c:16830
tokidx
#define tokidx
Definition: ripper.c:385
malloc
#define malloc
Definition: ripper.c:96
magic_comments
static const struct magic_comment magic_comments[]
Definition: ripper.c:13315
Init_sym
void Init_sym(void)
Definition: ripper.c:16757
name
const char * name
Definition: ripper.c:16683
parser_parse_string
static int parser_parse_string(struct parser_params *, NODE *)
Definition: ripper.c:12852
nd_term
#define nd_term(node)
Definition: ripper.c:603
STR_FUNC_EXPAND
#define STR_FUNC_EXPAND
Definition: ripper.c:12140
rb_warningS
#define rb_warningS(fmt, a)
Definition: ripper.c:707
new_args_tail_gen
static NODE * new_args_tail_gen(struct parser_params *, NODE *, ID, ID)
Definition: ripper.c:16099
NEW_RESCUE
#define NEW_RESCUE(b, res, e)
Definition: node.h:386
dvar_defined_gen
static int dvar_defined_gen(struct parser_params *, ID, int)
Definition: ripper.c:16408
rb_is_local_id
int rb_is_local_id(ID id)
Definition: ripper.c:17298
magic_comment::length
rb_magic_comment_length_t length
Definition: ripper.c:13312
parser_params::parser_in_def
int parser_in_def
Definition: ripper.c:303
is_global_id
#define is_global_id(id)
Definition: ripper.c:110
rb_scan_args
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1728
local_id_gen
static int local_id_gen(struct parser_params *, ID)
Definition: ripper.c:16331
YYSIZE_T
#define YYSIZE_T
Definition: ripper.c:972
ESCAPE_META
#define ESCAPE_META
Definition: ripper.c:12386
parser_params::parser_cur_mid
VALUE parser_cur_mid
Definition: ripper.c:306
buf
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4308
yytype_int16
short int yytype_int16
Definition: ripper.c:959
tIVAR
Definition: parse.c:834
tSTAR
Definition: parse.c:876
rb_assoc_new
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Definition: array.c:616
PRIsVALUE
#define PRIsVALUE
Definition: ruby.h:137
parser_params::parser_lex_gets_ptr
long parser_lex_gets_ptr
Definition: ripper.c:322
no_digits
#define no_digits()
ID
unsigned long ID
Definition: ruby.h:89
rb_usascii_encoding
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1257
rb_enc_isalnum
#define rb_enc_isalnum(c, enc)
Definition: encoding.h:183
rb_backref_error_gen
static void rb_backref_error_gen(struct parser_params *, NODE *)
Definition: ripper.c:15456
rb_enc_isdigit
#define rb_enc_isdigit(c, enc)
Definition: encoding.h:186
yytype_uint8
unsigned char yytype_uint8
Definition: ripper.c:938
nd_resq
#define nd_resq
Definition: node.h:304
rb_gc_mark_symbols
void rb_gc_mark_symbols(int full_mark)
Definition: ripper.c:16776
yyrhs
static const yytype_int16 yyrhs[]
Definition: ripper.c:1278
Qnil
#define Qnil
Definition: ruby.h:427
arg_ambiguous_gen
static void arg_ambiguous_gen(struct parser_params *parser)
Definition: ripper.c:13182
heredoc_restore
#define heredoc_restore(n)
Definition: ripper.c:11641
NEW_BACK_REF
#define NEW_BACK_REF(n)
Definition: node.h:418
parser_prepare
static void parser_prepare(struct parser_params *parser)
Definition: ripper.c:13493
cond_gen
static NODE * cond_gen(struct parser_params *, NODE *)
Definition: ripper.c:15980
rb_enc_symname_type
static int rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset)
Definition: ripper.c:16839
tCOLON3
Definition: parse.c:867
lex_lastline
#define lex_lastline
Definition: ripper.c:389
type
int type
Definition: tcltklib.c:112
kwtable::id
int id[2]
Definition: lex.c:33
NODE_FL_NEWLINE
#define NODE_FL_NEWLINE
Definition: node.h:275
options
static int options(unsigned char *cp)
Definition: nkf.c:6357
NEW_MASGN
#define NEW_MASGN(l, r)
Definition: node.h:395
yytname
static const char *const yytname[]
Definition: ripper.c:1545
YYSTACK_RELOCATE
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: ripper.c:1112
BUILTIN_TYPE
#define BUILTIN_TYPE(x)
Definition: ruby.h:502
NEW_COLON2
#define NEW_COLON2(c, i)
Definition: node.h:450
VALUE
unsigned long VALUE
Definition: ruby.h:88
parser_params::parser_cond_stack
stack_type parser_cond_stack
Definition: ripper.c:297
result
static VALUE result
Definition: nkf.c:40
rb_args_info::post_init
NODE * post_init
Definition: node.h:512
reg_named_capture_assign_t::fail_block
NODE * fail_block
Definition: ripper.c:16503
ripper_init_eventids2
static void ripper_init_eventids2(void)
Definition: eventids2.c:66
RBASIC
#define RBASIC(obj)
Definition: ruby.h:1116
rb_is_junk_id
int rb_is_junk_id(ID id)
Definition: ripper.c:17304
dyna_pop_1
static void dyna_pop_1(struct parser_params *parser)
Definition: ripper.c:16370
parser_read_escape
static int parser_read_escape(struct parser_params *parser, int flags, rb_encoding **encp)
Definition: ripper.c:12389
parser_params::parser_heredoc_end
int parser_heredoc_end
Definition: ripper.c:319
ruby_sourceline
#define ruby_sourceline
Definition: ripper.c:401
parser_heredoc_identifier
static int parser_heredoc_identifier(struct parser_params *parser)
Definition: ripper.c:12910
rb_enc_ispunct
#define rb_enc_ispunct(c, enc)
Definition: encoding.h:182
rb_id_attrset
ID rb_id_attrset(ID id)
Definition: ripper.c:15419
value_expr_gen
static int value_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15551
NEW_KW_ARG
#define NEW_KW_ARG(i, v)
Definition: node.h:436
rb_mark_tbl
void rb_mark_tbl(st_table *tbl)
Definition: gc.c:3519
rb_args_info::post_args_num
int post_args_num
Definition: node.h:515
lex_pend
#define lex_pend
Definition: ripper.c:393
NEW_ENSURE
#define NEW_ENSURE(b, en)
Definition: node.h:388
rb_str_symname_type
static int rb_str_symname_type(VALUE name, unsigned int allowed_attrset)
Definition: ripper.c:16941
yytokentype
yytokentype
Definition: parse.c:780
rb_is_global_id
int rb_is_global_id(ID id)
Definition: ripper.c:17280
reg_fragment_check_gen
static int reg_fragment_check_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16486
rb_ary_new3
#define rb_ary_new3
Definition: intern.h:91
yycheck
static const yytype_int16 yycheck[]
Definition: ripper.c:3171
YYUSE
#define YYUSE(e)
Definition: ripper.c:992
lvtbl
#define lvtbl
Definition: ripper.c:399
lex_strterm
#define lex_strterm
Definition: ripper.c:371
NEW_ZSUPER
#define NEW_ZSUPER()
Definition: node.h:433
rb_enc_asciicompat
#define rb_enc_asciicompat(enc)
Definition: encoding.h:188
rb_ensure
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
Definition: eval.c:839
RBasic::flags
VALUE flags
Definition: ruby.h:748
free
#define free
Definition: ripper.c:99
new_attr_op_assign_gen
static NODE * new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
Definition: ripper.c:16185
set_yylval_str
#define set_yylval_str(x)
Definition: ripper.c:11648
rb_char_to_option_kcode
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Definition: re.c:301
NEW_COLON3
#define NEW_COLON3(i)
Definition: node.h:451
NEW_BLOCK
#define NEW_BLOCK(a)
Definition: node.h:370
cond_stack
#define cond_stack
Definition: ripper.c:373
yytype_int8
short int yytype_int8
Definition: ripper.c:947
nd_body
#define nd_body
Definition: node.h:299
RNode::flags
VALUE flags
Definition: node.h:240
rb_fstring
VALUE rb_fstring(VALUE)
Definition: string.c:201
is_static_content
static int is_static_content(NODE *node)
Definition: ripper.c:15792
token_info::token
const char * token
Definition: ripper.c:271
ENCODING_IS_ASCII8BIT
#define ENCODING_IS_ASCII8BIT(obj)
Definition: encoding.h:43
rb_str_dup
VALUE rb_str_dup(VALUE)
Definition: string.c:1062
RUBY_DTRACE_PARSE_BEGIN_ENABLED
#define RUBY_DTRACE_PARSE_BEGIN_ENABLED()
Definition: probes.h:54
yypgoto
static const yytype_int16 yypgoto[]
Definition: ripper.c:2024
arg_var_gen
static int arg_var_gen(struct parser_params *, ID)
Definition: ripper.c:16314
rb_enc_isalpha
#define rb_enc_isalpha(c, enc)
Definition: encoding.h:179
is_local_id
#define is_local_id(id)
Definition: ripper.c:109
tOROP
Definition: parse.c:857
parser_params::parser_in_defined
int parser_in_defined
Definition: ripper.c:308
literal_concat0
static int literal_concat0(struct parser_params *, VALUE, VALUE)
Definition: ripper.c:15007
local_tbl_gen
static ID * local_tbl_gen(struct parser_params *)
Definition: ripper.c:16289
is_global_name_punct
static int is_global_name_punct(const int c)
Definition: ripper.c:12809
LONG2NUM
#define LONG2NUM(x)
Definition: ruby.h:1309
parser_params::parser_class_nest
int parser_class_nest
Definition: ripper.c:299
brace_nest
#define brace_nest
Definition: ripper.c:378
reg_named_capture_assign
#define reg_named_capture_assign(regexp, match)
Definition: ripper.c:524
reg_named_capture_assign_t::enc
rb_encoding * enc
Definition: ripper.c:16501
op_tbl
static const struct @92 op_tbl[]
NEW_BEGIN
#define NEW_BEGIN(b)
Definition: node.h:385
reg_named_capture_assign_t::num
int num
Definition: ripper.c:16504
parser_yyerror
static int parser_yyerror(struct parser_params *, const char *)
Definition: ripper.c:11821
HEAPCNT
#define HEAPCNT(n, size)
Definition: ripper.c:17656
warning_unless_e_option
static void warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15849
RSTRING_PTR
#define RSTRING_PTR(str)
Definition: ruby.h:845
rb_is_const_name
int rb_is_const_name(VALUE name)
Definition: ripper.c:17386
is_asgn_or_id
#define is_asgn_or_id(id)
Definition: ripper.c:118
parser_tokaddmbc
static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
Definition: ripper.c:12480
yy_symbol_print
static void yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, struct parser_params *parser)
Definition: ripper.c:4555
NEW_SPLAT
#define NEW_SPLAT(a)
Definition: node.h:440
attrset_gen
static NODE * attrset_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:15448
rb_is_local_name
int rb_is_local_name(VALUE name)
Definition: ripper.c:17416
RARRAY_ASET
#define RARRAY_ASET(a, i, v)
Definition: ruby.h:902
YYSTYPE::vars
const struct vtable * vars
Definition: parse.h:170
rb_const_defined_at
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:2130
reg_compile_gen
static VALUE reg_compile_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16580
st_init_table_with_size
st_table * st_init_table_with_size(const struct st_hash_type *, st_index_t)
Definition: st.c:229
ENCODING_GET
#define ENCODING_GET(obj)
Definition: encoding.h:38
ESCAPE_CONTROL
#define ESCAPE_CONTROL
Definition: ripper.c:12385
rb_enc_get
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:832
ffs
RUBY_EXTERN int ffs(int)
Definition: ffs.c:6
parser_isascii
#define parser_isascii()
Definition: ripper.c:11744
rb_gc_mark_parser
void rb_gc_mark_parser(void)
Definition: ripper.c:16604
yytranslate
static const yytype_uint8 yytranslate[]
Definition: ripper.c:1167
RFLOAT_VALUE
#define RFLOAT_VALUE(v)
Definition: ruby.h:814
token_info::nonspc
int nonspc
Definition: ripper.c:274
size
int size
Definition: encoding.c:49
NEW_DSTR
#define NEW_DSTR(s)
Definition: node.h:424
ADD2HEAP
#define ADD2HEAP(n, c, p)
Definition: ripper.c:17658
tokspace
#define tokspace(n)
Definition: ripper.c:11630
f
#define f
in_def
#define in_def
Definition: ripper.c:380
INT2FIX
#define INT2FIX(i)
Definition: ruby.h:231
is_private_local_id
static int is_private_local_id(ID name)
Definition: ripper.c:15333
NEW_GASGN
#define NEW_GASGN(v, val)
Definition: node.h:396
is_const_id
#define is_const_id(id)
Definition: ripper.c:113
NEW_BREAK
#define NEW_BREAK(s)
Definition: node.h:381
rb_sourceline
int rb_sourceline(void)
Definition: vm.c:966
no_blockarg
static void no_blockarg(struct parser_params *parser, NODE *node)
Definition: ripper.c:16002
local_pop_gen
static void local_pop_gen(struct parser_params *)
Definition: ripper.c:16273
tEQQ
Definition: parse.c:852
rb_parser_free
void rb_parser_free(struct parser_params *parser, void *ptr)
Definition: ripper.c:17702
RARRAY_AREF
#define RARRAY_AREF(a, i)
Definition: ruby.h:901
parser_params::parser_tokidx
int parser_tokidx
Definition: ripper.c:310
read_escape
#define read_escape(flags, e)
Definition: ripper.c:11633
NODE_NEXT
Definition: node.h:45
tok_hex
#define tok_hex(numlen)
Definition: ripper.c:11632
literal_concat_gen
static NODE * literal_concat_gen(struct parser_params *, NODE *, NODE *)
Definition: ripper.c:15024
rb_int_positive_pow
VALUE rb_int_positive_pow(long x, unsigned long y)
Definition: numeric.c:3047
new_evstr
#define new_evstr(n)
Definition: ripper.c:462
xmalloc
#define xmalloc
Definition: defines.h:108
parser_warn
#define parser_warn(node, mesg)
Definition: ripper.c:14906
rb_intern_str
ID rb_intern_str(VALUE str)
Definition: ripper.c:17147
parser_params::coverage
VALUE coverage
Definition: ripper.c:342
rb_set_errinfo
void rb_set_errinfo(VALUE err)
Definition: eval.c:1504
tokfix
#define tokfix()
Definition: ripper.c:12253
NEW_TRUE
#define NEW_TRUE()
Definition: node.h:457
internal_id
#define internal_id()
Definition: ripper.c:570
parser_params::parser_lex_strterm
NODE * parser_lex_strterm
Definition: ripper.c:295
magic_comment::name
const char * name
Definition: ripper.c:13310
COND_LEXPOP
#define COND_LEXPOP()
Definition: ripper.c:173
lex_p
#define lex_p
Definition: ripper.c:392
rb_data_type_struct
Definition: ruby.h:966
RUBY_DTRACE_SYMBOL_CREATE_ENABLED
#define RUBY_DTRACE_SYMBOL_CREATE_ENABLED()
Definition: probes.h:51
tSP
#define tSP
Definition: eventids2.c:6
NEW_LAMBDA
#define NEW_LAMBDA(a, b)
Definition: node.h:380
rb_complex_raw
VALUE rb_complex_raw(VALUE x, VALUE y)
Definition: complex.c:1317
NODE_NIL
Definition: node.h:207
NEW_UNTIL
#define NEW_UNTIL(c, b, n)
Definition: node.h:377
token_info_get_column
static int token_info_get_column(struct parser_params *parser, const char *token)
Definition: ripper.c:11748
symhash
static const struct st_hash_type symhash
Definition: ripper.c:16724
node_assign
#define node_assign(node1, node2)
Definition: ripper.c:499
void_stmts_gen
static void void_stmts_gen(struct parser_params *, NODE *)
Definition: ripper.c:15697
void_expr
#define void_expr(node)
Definition: ripper.c:440
local_var_gen
static int local_var_gen(struct parser_params *, ID)
Definition: ripper.c:16321
void_expr0
#define void_expr0(node)
Definition: ripper.c:439
lex_pbeg
#define lex_pbeg
Definition: ripper.c:391
regx_options
#define regx_options()
Definition: ripper.c:11635
NEW_MODULE
#define NEW_MODULE(n, b)
Definition: node.h:449
token_info_has_nonspaces
static int token_info_has_nonspaces(struct parser_params *parser, const char *token)
Definition: ripper.c:11762
YYSTACK_ALLOC_MAXIMUM
#define YYSTACK_ALLOC_MAXIMUM
Definition: ripper.c:1057
TOK_INTERN
#define TOK_INTERN(mb)
Definition: ripper.c:366
new_defined
#define new_defined(expr)
Definition: ripper.c:507
parser_data_type
static const rb_data_type_t parser_data_type
Definition: ripper.c:12045
magic_comment::func
rb_magic_comment_setter_t func
Definition: ripper.c:13311
parser_params::parser_lpar_beg
int parser_lpar_beg
Definition: ripper.c:301
rb_compile_warning
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:192
rb_check_string_type
VALUE rb_check_string_type(VALUE)
Definition: string.c:1679
symbols::sym_id
st_table * sym_id
Definition: ripper.c:16714
tDOT2
Definition: parse.c:860
key
uint8_t key[16]
Definition: random.c:1250
nd_head
#define nd_head
Definition: node.h:294
local_vars::prev
struct local_vars * prev
Definition: ripper.c:192
yydefact
static const yytype_uint16 yydefact[]
Definition: ripper.c:1774
new_op_assign_gen
static NODE * new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
Definition: ripper.c:16156
LONG2FIX
#define LONG2FIX(i)
Definition: ruby.h:232
parser_encoding_name
#define parser_encoding_name()
Definition: ripper.c:11738
tokadd_escape
#define tokadd_escape(e)
Definition: ripper.c:11634
NEW_WHILE
#define NEW_WHILE(c, b, n)
Definition: node.h:376
local_vars::vars
struct vtable * vars
Definition: ripper.c:190
RTEST
#define RTEST(v)
Definition: ruby.h:437
NODE_STR
Definition: node.h:139
T_STRING
#define T_STRING
Definition: ruby.h:482
parser_set_integer_literal
static int parser_set_integer_literal(struct parser_params *parser, VALUE v, int suffix)
Definition: ripper.c:13054
yypact
static const yytype_int16 yypact[]
Definition: ripper.c:1913
lex_io_gets
static VALUE lex_io_gets(struct parser_params *parser, VALUE io)
Definition: ripper.c:12101
new_yield
#define new_yield(node)
Definition: ripper.c:482
lvar_defined
#define lvar_defined(id)
Definition: ripper.c:586
NEW_POSTARG
#define NEW_POSTARG(i, v)
Definition: node.h:437
RREGEXP
#define RREGEXP(obj)
Definition: ruby.h:1122
NEW_UNDEF
#define NEW_UNDEF(i)
Definition: node.h:446
list
struct rb_encoding_entry * list
Definition: encoding.c:47
lpar_beg
#define lpar_beg
Definition: ripper.c:377
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition: ripper.c:1163
rb_parser_calloc
void * rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
Definition: ripper.c:17672
ID_ATTRSET
#define ID_ATTRSET
Definition: id.h:34
T_FILE
#define T_FILE
Definition: ruby.h:488
NEW_CVASGN
#define NEW_CVASGN(v, val)
Definition: node.h:403
yyerror
#define yyerror(msg)
Definition: ripper.c:369
is_junk_id
#define is_junk_id(id)
Definition: ripper.c:115
new_bv_gen
static void new_bv_gen(struct parser_params *, ID)
Definition: ripper.c:15378
deferred_nodes
#define deferred_nodes
Definition: ripper.c:396
ruby_coverage
#define ruby_coverage
Definition: ripper.c:411
NEW_FCALL
#define NEW_FCALL(m, a)
Definition: node.h:430
tGEQ
Definition: parse.c:854
token_info::linenum
int linenum
Definition: ripper.c:272
negate_lit
static NODE * negate_lit(NODE *)
Definition: ripper.c:16035
tEMBDOC
#define tEMBDOC
Definition: eventids2.c:4
NEW_OP_ASGN2
#define NEW_OP_ASGN2(r, i, o, val)
Definition: node.h:406
id_type
#define id_type(id)
Definition: ripper.c:116
NEW_MATCH3
#define NEW_MATCH3(r, n2)
Definition: node.h:421
number_literal_suffix
#define number_literal_suffix(f)
Definition: ripper.c:11643
tLBRACK
Definition: parse.c:873
fixup_nodes
static void fixup_nodes(NODE **)
Definition: ripper.c:15855
DVARS_INHERIT
#define DVARS_INHERIT
Definition: ripper.c:196
STR_NEW3
#define STR_NEW3(p, n, e, func)
Definition: ripper.c:364
parser_params::parser_tokenbuf
char * parser_tokenbuf
Definition: ripper.c:309
rb_cArray
VALUE rb_cArray
Definition: array.c:27
magic_comment_marker
static const char * magic_comment_marker(const char *str, long len)
Definition: ripper.c:13323
NEW_OPT_ARG
#define NEW_OPT_ARG(i, v)
Definition: node.h:435
BEG
#define BEG(no)
Definition: re.c:25
hash
static unsigned int hash(const char *str, unsigned int len)
Definition: lex.c:56
parser_magic_comment
static int parser_magic_comment(struct parser_params *parser, const char *str, long len)
Definition: ripper.c:13356
parser_params::parser_tokline
int parser_tokline
Definition: ripper.c:312
RUBY_DTRACE_SYMBOL_CREATE
#define RUBY_DTRACE_SYMBOL_CREATE(arg0, arg1, arg2)
Definition: probes.h:52
IS_LABEL_POSSIBLE
#define IS_LABEL_POSSIBLE()
Definition: ripper.c:13521
rb_filesystem_str_new_cstr
VALUE rb_filesystem_str_new_cstr(const char *)
Definition: string.c:737
id_type_names
static const char id_type_names[][9]
Definition: ripper.c:15407
parser_params::parser_lex_pbeg
const char * parser_lex_pbeg
Definition: ripper.c:316
rb_is_class_id
int rb_is_class_id(ID id)
Definition: ripper.c:17274
DVARS_TOPSCOPE
#define DVARS_TOPSCOPE
Definition: ripper.c:197
rb_enc_str_new
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
Definition: string.c:548
YYCASE_
#define YYCASE_(N, S)
rb_safe_level
#define rb_safe_level()
Definition: tcltklib.c:95
rb_parser_new
VALUE rb_parser_new(void)
Definition: ripper.c:17587
vtable
Definition: ripper.c:181
rb_const_get_at
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:1886
parser_set_encode
static void parser_set_encode(struct parser_params *parser, const char *name)
Definition: ripper.c:13231
call_uni_op
#define call_uni_op(recv, id)
Definition: ripper.c:470
literal_node
static int literal_node(NODE *node)
Definition: ripper.c:15902
set_yylval_node
#define set_yylval_node(x)
Definition: ripper.c:11653
YYSTACK_BYTES
#define YYSTACK_BYTES(N)
Definition: ripper.c:1101
IS_BEG
#define IS_BEG()
Definition: ripper.c:13519
parser_params::parser_lex_p
const char * parser_lex_p
Definition: ripper.c:317
parser_tok_hex
static int parser_tok_hex(struct parser_params *parser, size_t *numlen)
Definition: ripper.c:12297
tEQ
Definition: parse.c:851
xrealloc
#define xrealloc
Definition: defines.h:111
RE_OPTION_ENCODING_NONE
#define RE_OPTION_ENCODING_NONE(o)
Definition: ripper.c:592
lex_state_e
lex_state_e
Definition: ripper.c:139
ID2SYM
#define ID2SYM(x)
Definition: ruby.h:355
NODE_OR
Definition: node.h:61
dvar_defined_get
#define dvar_defined_get(id)
Definition: ripper.c:581
rb_is_instance_name
int rb_is_instance_name(VALUE name)
Definition: ripper.c:17404
parser_params::parser_ruby_sourceline
int parser_ruby_sourceline
Definition: ripper.c:329
rb_id2name
const char * rb_id2name(ID id)
Definition: ripper.c:17227
NEW_RETRY
#define NEW_RETRY()
Definition: node.h:384
token_info
Definition: ripper.c:270
ruby_eval_tree_begin
#define ruby_eval_tree_begin
Definition: ripper.c:409
rb_errinfo
#define rb_errinfo()
Definition: tcltklib.c:90
ruby_sourcefile_string
#define ruby_sourcefile_string
Definition: ripper.c:403
StringValuePtr
#define StringValuePtr(v)
Definition: ruby.h:540
RString::heap
struct RString::@109::@110 heap
formal_argument
#define formal_argument(id)
Definition: ripper.c:553
nd_value
#define nd_value
Definition: node.h:324
ID_INTERNAL
#define ID_INTERNAL
Definition: id.h:38
tDOT3
Definition: parse.c:861
nodeline
static int nodeline(NODE *node)
Definition: ripper.c:14870
dispatch_heredoc_end
#define dispatch_heredoc_end()
Definition: ripper.c:13076
parser_params::parser_yylval
YYSTYPE * parser_yylval
Definition: ripper.c:292
ruby_eval_tree
#define ruby_eval_tree
Definition: ripper.c:408
rb_str_new_frozen
VALUE rb_str_new_frozen(VALUE)
Definition: string.c:833
toklast
#define toklast()
Definition: ripper.c:12256
lex_gets
#define lex_gets
Definition: ripper.c:398
toklen
#define toklen()
Definition: ripper.c:12255
yyr2
static const yytype_uint8 yyr2[]
Definition: ripper.c:1704
NEW_RESBODY
#define NEW_RESBODY(a, ex, n)
Definition: node.h:387
tASET
Definition: parse.c:863
NEW_ARGSCAT
#define NEW_ARGSCAT(a, b)
Definition: node.h:438
NEW_DASGN_CURR
#define NEW_DASGN_CURR(v, val)
Definition: node.h:399
rb_inspect
VALUE rb_inspect(VALUE)
Definition: object.c:471
cmdarg_stack
#define cmdarg_stack
Definition: ripper.c:374
in_single
#define in_single
Definition: ripper.c:379
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: ripper.c:4596
YYFPRINTF
#define YYFPRINTF
Definition: ripper.c:4489
rb_parser_compile_string_path
NODE * rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
Definition: ripper.c:12080
NEW_SUPER
#define NEW_SUPER(a)
Definition: node.h:432
NEW_CALL
#define NEW_CALL(r, m, a)
Definition: node.h:429
parser_params::is_ripper
int is_ripper
Definition: ripper.c:289
cond0
static NODE * cond0(struct parser_params *, NODE *)
Definition: ripper.c:15923
rb_ascii8bit_encoding
rb_encoding * rb_ascii8bit_encoding(void)
Definition: encoding.c:1227
rb_is_junk_name
int rb_is_junk_name(VALUE name)
Definition: ripper.c:17432
peek
#define peek(c)
Definition: ripper.c:12176
rb_enc_find_index
int rb_enc_find_index(const char *name)
Definition: encoding.c:684
splat_array
static NODE * splat_array(NODE *)
Definition: ripper.c:15512
vtable_alloc
static struct vtable * vtable_alloc(struct vtable *prev)
Definition: ripper.c:215
parser_params::eofp
VALUE eofp
Definition: ripper.c:293
NODE_WHEN
Definition: node.h:31
ruby_global_name_punct_bits
RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e-0x20+31)/32]
Definition: ripper.c:12787
RString::len
long len
Definition: ruby.h:824
CONST_ID
#define CONST_ID(var, str)
Definition: ruby.h:1428
parser_params::heap
NODE * heap
Definition: ripper.c:290
rb_intern3
ID rb_intern3(const char *name, long len, rb_encoding *enc)
Definition: ripper.c:17005
attrset
#define attrset(node, id)
Definition: ripper.c:494
NEW_CVAR
#define NEW_CVAR(v)
Definition: node.h:416
COND_P
#define COND_P()
Definition: ripper.c:174
mixed_error
#define mixed_error(enc1, enc2)
register_symid
static ID register_symid(ID, const char *, long, rb_encoding *)
Definition: ripper.c:16951
xfree
void void xfree(void *)
tAMPER
Definition: parse.c:878
NEW_MATCH2
#define NEW_MATCH2(n1, n2)
Definition: node.h:420
dyna_push_gen
static const struct vtable * dyna_push_gen(struct parser_params *)
Definition: ripper.c:16359
rb_args_info::first_post_arg
ID first_post_arg
Definition: node.h:517
rb_parser_realloc
void * rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
Definition: ripper.c:17682
st_init_numtable_with_size
st_table * st_init_numtable_with_size(st_index_t)
Definition: st.c:278
shadowing_lvar
#define shadowing_lvar(name)
Definition: ripper.c:555
tCOLON2
Definition: parse.c:866
rb_cstr_to_inum
VALUE rb_cstr_to_inum(const char *str, int base, int badcheck)
Definition: bignum.c:3961
get_value
#define get_value(val)
Definition: ripper.c:527
parser_set_number_literal
static int parser_set_number_literal(struct parser_params *parser, VALUE v, int type, int suffix)
Definition: ripper.c:13043
idEq
Definition: id.h:84
rb_enc_mbcput
#define rb_enc_mbcput(c, buf, enc)
Definition: encoding.h:165
NEW_DVAR
#define NEW_DVAR(v)
Definition: node.h:413
NEW_DEFN
#define NEW_DEFN(i, a, d, p)
Definition: node.h:366
reg_fragment_check
#define reg_fragment_check(str, options)
Definition: ripper.c:522
rb_parse_in_eval
int rb_parse_in_eval(void)
Definition: compile.c:5942
rb_str_buf_new
VALUE rb_str_buf_new(long)
Definition: string.c:891
rb_usascii_str_new
VALUE rb_usascii_str_new(const char *, long)
Definition: string.c:540
compile_for_eval
#define compile_for_eval
Definition: ripper.c:381
SYMBOL_P
#define SYMBOL_P(x)
Definition: ruby.h:354
tCOMMENT
#define tCOMMENT
Definition: eventids2.c:2
parser_params::last_cr_line
int last_cr_line
Definition: ripper.c:335
rb_args_info::kw_args
NODE * kw_args
Definition: node.h:522
set_yylval_id
#define set_yylval_id(x)
Definition: ripper.c:11650
rb_intern2
ID rb_intern2(const char *name, long len)
Definition: ripper.c:17134
nd_iter
#define nd_iter
Definition: node.h:322
nd_set_line
#define nd_set_line(n, l)
Definition: node.h:289
rb_vsprintf
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1244
rb_compile_file
NODE * rb_compile_file(const char *f, VALUE file, int start)
Definition: ripper.c:12107
tUMINUS
Definition: parse.c:848
is_special_global_name
static int is_special_global_name(const char *m, const char *e, rb_encoding *enc)
Definition: ripper.c:16798
is_class_id
#define is_class_id(id)
Definition: ripper.c:114
LVAR_USED
#define LVAR_USED
Definition: ripper.c:15343
assignable_gen
static NODE * assignable_gen(struct parser_params *, ID, NODE *)
Definition: ripper.c:15254
rb_parser_get_yydebug
VALUE rb_parser_get_yydebug(VALUE self)
Definition: ripper.c:17631
parser_params::parser_lex_gets
VALUE(* parser_lex_gets)(struct parser_params *, VALUE)
Definition: ripper.c:323
NULL
#define NULL
Definition: _sdbm.c:103
RTYPEDDATA_TYPE
#define RTYPEDDATA_TYPE(v)
Definition: ruby.h:995
NEW_LASGN
#define NEW_LASGN(v, val)
Definition: node.h:397
FIX2LONG
#define FIX2LONG(x)
Definition: ruby.h:345
debug_lines
static VALUE debug_lines(VALUE fname)
Definition: ripper.c:11886
Qundef
#define Qundef
Definition: ruby.h:428
tIGNORED_NL
#define tIGNORED_NL
Definition: eventids2.c:1
rb_parser_compile_cstr
NODE * rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
Definition: ripper.c:12094
NEW_STR
#define NEW_STR(s)
Definition: node.h:423
yypact_value_is_default
#define yypact_value_is_default(yystate)
Definition: ripper.c:3165
tUPLUS
Definition: parse.c:847
rb_args_info::kw_rest_arg
NODE * kw_rest_arg
Definition: node.h:523
ID_GLOBAL
#define ID_GLOBAL
Definition: id.h:33
ISXDIGIT
#define ISXDIGIT(c)
Definition: ruby.h:1776
rb_warn0
#define rb_warn0(fmt)
Definition: ripper.c:702
ENCODING_SET
#define ENCODING_SET(obj, i)
Definition: encoding.h:35
rb_local_defined
int rb_local_defined(ID id)
Definition: compile.c:5923
st_table::num_entries
st_index_t num_entries
Definition: st.h:85
tMATCH
Definition: parse.c:858
NEW_SELF
#define NEW_SELF()
Definition: node.h:455
tFID
Definition: parse.c:832
parser_params::parser_eval_tree_begin
NODE * parser_eval_tree_begin
Definition: ripper.c:339
match
static int match(VALUE str, VALUE pat, VALUE hash, int(*cb)(VALUE, VALUE))
Definition: date_parse.c:273
rb_define_method
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1488
tRSHFT
Definition: parse.c:865
ruby_verbose
#define ruby_verbose
Definition: ruby.h:1475
rb_str_append
VALUE rb_str_append(VALUE, VALUE)
Definition: string.c:2298
rb_ascii8bit_encindex
#define rb_ascii8bit_encindex()
Definition: internal.h:402
new_bv
#define new_bv(id)
Definition: ripper.c:557
st_foreach
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
Definition: st.c:1034
warn_unless_e_option
static void warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15843
NEW_NODE
#define NEW_NODE(t, a0, a1, a2)
Definition: node.h:364
NEW_ARGS_AUX
#define NEW_ARGS_AUX(r, b)
Definition: node.h:434
parser_params
Definition: ripper.c:288
RSTRING_NOEMBED
#define RSTRING_NOEMBED
Definition: ruby.h:834
rb_memcicmp
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:80
block_append
#define block_append(h, t)
Definition: ripper.c:449
NEW_ALIAS
#define NEW_ALIAS(n, o)
Definition: node.h:444
rb_parser_compile_file_path
NODE * rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
Definition: ripper.c:12121
rb_eArgError
VALUE rb_eArgError
Definition: error.c:549
vtable_free
static void vtable_free(struct vtable *tbl)
Definition: ripper.c:227
nd_lit
#define nd_lit
Definition: node.h:327
rb_enc_prev_char
#define rb_enc_prev_char(s, p, e, enc)
Definition: encoding.h:168
T_REGEXP
#define T_REGEXP
Definition: ruby.h:483
NODE_LIT
Definition: node.h:137
ruby_scan_oct
unsigned long ruby_scan_oct(const char *, size_t, size_t *)
Definition: util.c:28
heredoc_end
#define heredoc_end
Definition: ripper.c:394
rb_attr_get
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1127
local_vars::args
struct vtable * args
Definition: ripper.c:189
tokaddmbc
#define tokaddmbc(c, enc)
Definition: ripper.c:11638
NEW_CDECL
#define NEW_CDECL(v, val, path)
Definition: node.h:402
NEW_DEFS
#define NEW_DEFS(r, i, a, d)
Definition: node.h:367
argv
char ** argv
Definition: ruby.c:132
tEMBDOC_END
#define tEMBDOC_END
Definition: eventids2.c:5
RString::ptr
char * ptr
Definition: ruby.h:825
DBL2NUM
#define DBL2NUM(dbl)
Definition: ruby.h:815
ripper_init_eventids2_table
static void ripper_init_eventids2_table(VALUE self)
Definition: eventids2table.c:2
tNMATCH
Definition: parse.c:859
ISSPACE
#define ISSPACE(c)
Definition: ruby.h:1770
StringValue
#define StringValue(v)
Definition: ruby.h:539
rb_enc_str_buf_cat
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:2251
pushback
#define pushback(c)
Definition: ripper.c:11628
STR_NEW2
#define STR_NEW2(p)
Definition: ripper.c:363
YYINITDEPTH
#define YYINITDEPTH
Definition: ripper.c:4656
sym_check_asciionly
static int sym_check_asciionly(VALUE str)
Definition: ripper.c:16974
rb_enc_from_index
rb_encoding * rb_enc_from_index(int index)
Definition: encoding.c:590
aryset
#define aryset(node1, node2)
Definition: ripper.c:492
reg_named_capture_assign_gen
static NODE * reg_named_capture_assign_gen(struct parser_params *parser, VALUE regexp, NODE *match)
Definition: ripper.c:16548
IS_AFTER_OPERATOR
#define IS_AFTER_OPERATOR()
Definition: ripper.c:13523
rb_str_new
VALUE rb_str_new(const char *, long)
Definition: string.c:534
tCVAR
Definition: parse.c:836
xcalloc
#define xcalloc
Definition: defines.h:110
ID_CLASS
#define ID_CLASS
Definition: id.h:36
new_args_gen
static NODE * new_args_gen(struct parser_params *, NODE *, NODE *, ID, NODE *, NODE *)
Definition: ripper.c:16077
tNEQ
Definition: parse.c:853
rb_is_global_name
int rb_is_global_name(VALUE name)
Definition: ripper.c:17398
parser_tokadd_mbchar
static int parser_tokadd_mbchar(struct parser_params *parser, int c)
Definition: ripper.c:12603
Generated on Mon Sep 22 2014 08:59:43 for Ruby by   doxygen 1.8.8