Ruby  2.1.4p265(2014-10-27revision48166)
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) {
13142  dispose_string(str);
13143  str = 0;
13144  }
13145  goto error;
13146  }
13147  } while (!whole_match_p(eos, len, indent));
13148  }
13149  else {
13150  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
13151  newtok();
13152  if (c == '#') {
13153  int t = parser_peek_variable_name(parser);
13154  if (t) return t;
13155  tokadd('#');
13156  c = nextc();
13157  }
13158  do {
13159  pushback(c);
13160  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
13161  if (parser->eofp) goto error;
13162  goto restore;
13163  }
13164  if (c != '\n') {
13165  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
13166  flush_string_content(enc);
13167  return tSTRING_CONTENT;
13168  }
13169  tokadd(nextc());
13170  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
13171  if ((c = nextc()) == -1) goto error;
13172  } while (!whole_match_p(eos, len, indent));
13173  str = STR_NEW3(tok(), toklen(), enc, func);
13174  }
13175  dispatch_heredoc_end();
13176  heredoc_restore(lex_strterm);
13177  lex_strterm = NEW_STRTERM(-1, 0, 0);
13178  set_yylval_str(str);
13179  return tSTRING_CONTENT;
13180 }
13181 
13182 #include "lex.c"
13183 
13184 static void
13185 arg_ambiguous_gen(struct parser_params *parser)
13186 {
13187 #ifndef RIPPER
13188  rb_warning0("ambiguous first argument; put parentheses or even spaces");
13189 #else
13190  dispatch0(arg_ambiguous);
13191 #endif
13192 }
13193 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
13194 
13195 static ID
13196 formal_argument_gen(struct parser_params *parser, ID lhs)
13197 {
13198 #ifndef RIPPER
13199  if (!is_local_id(lhs))
13200  yyerror("formal argument must be local variable");
13201 #endif
13202  shadowing_lvar(lhs);
13203  return lhs;
13204 }
13205 
13206 static int
13207 lvar_defined_gen(struct parser_params *parser, ID id)
13208 {
13209  return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
13210 }
13211 
13212 /* emacsen -*- hack */
13213 static long
13214 parser_encode_length(struct parser_params *parser, const char *name, long len)
13215 {
13216  long nlen;
13217 
13218  if (len > 5 && name[nlen = len - 5] == '-') {
13219  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
13220  return nlen;
13221  }
13222  if (len > 4 && name[nlen = len - 4] == '-') {
13223  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
13224  return nlen;
13225  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
13226  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
13227  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
13228  return nlen;
13229  }
13230  return len;
13231 }
13232 
13233 static void
13234 parser_set_encode(struct parser_params *parser, const char *name)
13235 {
13236  int idx = rb_enc_find_index(name);
13237  rb_encoding *enc;
13238  VALUE excargs[3];
13239 
13240  if (idx < 0) {
13241  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
13242  error:
13243  excargs[0] = rb_eArgError;
13244  excargs[2] = rb_make_backtrace();
13245  rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
13246  rb_exc_raise(rb_make_exception(3, excargs));
13247  }
13248  enc = rb_enc_from_index(idx);
13249  if (!rb_enc_asciicompat(enc)) {
13250  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13251  goto error;
13252  }
13253  parser->enc = enc;
13254 #ifndef RIPPER
13255  if (ruby_debug_lines) {
13256  VALUE lines = ruby_debug_lines;
13257  long i, n = RARRAY_LEN(lines);
13258  for (i = 0; i < n; ++i) {
13259  rb_enc_associate_index(RARRAY_AREF(lines, i), idx);
13260  }
13261  }
13262 #endif
13263 }
13264 
13265 static int
13266 comment_at_top(struct parser_params *parser)
13267 {
13268  const char *p = lex_pbeg, *pend = lex_p - 1;
13269  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13270  while (p < pend) {
13271  if (!ISSPACE(*p)) return 0;
13272  p++;
13273  }
13274  return 1;
13275 }
13276 
13277 #ifndef RIPPER
13278 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13279 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13280 
13281 static void
13282 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13283 {
13284  if (!comment_at_top(parser)) {
13285  return;
13286  }
13287  parser_set_encode(parser, val);
13288 }
13289 
13290 static void
13291 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13292 {
13293  int *p = &parser->parser_token_info_enabled;
13294 
13295  switch (*val) {
13296  case 't': case 'T':
13297  if (strcasecmp(val, "true") == 0) {
13298  *p = TRUE;
13299  return;
13300  }
13301  break;
13302  case 'f': case 'F':
13303  if (strcasecmp(val, "false") == 0) {
13304  *p = FALSE;
13305  return;
13306  }
13307  break;
13308  }
13309  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13310 }
13311 
13312 struct magic_comment {
13313  const char *name;
13314  rb_magic_comment_setter_t func;
13315  rb_magic_comment_length_t length;
13316 };
13317 
13318 static const struct magic_comment magic_comments[] = {
13319  {"coding", magic_comment_encoding, parser_encode_length},
13320  {"encoding", magic_comment_encoding, parser_encode_length},
13321  {"warn_indent", parser_set_token_info},
13322 };
13323 #endif
13324 
13325 static const char *
13326 magic_comment_marker(const char *str, long len)
13327 {
13328  long i = 2;
13329 
13330  while (i < len) {
13331  switch (str[i]) {
13332  case '-':
13333  if (str[i-1] == '*' && str[i-2] == '-') {
13334  return str + i + 1;
13335  }
13336  i += 2;
13337  break;
13338  case '*':
13339  if (i + 1 >= len) return 0;
13340  if (str[i+1] != '-') {
13341  i += 4;
13342  }
13343  else if (str[i-1] != '-') {
13344  i += 2;
13345  }
13346  else {
13347  return str + i + 2;
13348  }
13349  break;
13350  default:
13351  i += 3;
13352  break;
13353  }
13354  }
13355  return 0;
13356 }
13357 
13358 static int
13359 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13360 {
13361  VALUE name = 0, val = 0;
13362  const char *beg, *end, *vbeg, *vend;
13363 #define str_copy(_s, _p, _n) ((_s) \
13364  ? (void)(rb_str_resize((_s), (_n)), \
13365  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13366  : (void)((_s) = STR_NEW((_p), (_n))))
13367 
13368  if (len <= 7) return FALSE;
13369  if (!(beg = magic_comment_marker(str, len))) return FALSE;
13370  if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
13371  str = beg;
13372  len = end - beg - 3;
13373 
13374  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13375  while (len > 0) {
13376 #ifndef RIPPER
13377  const struct magic_comment *p = magic_comments;
13378 #endif
13379  char *s;
13380  int i;
13381  long n = 0;
13382 
13383  for (; len > 0 && *str; str++, --len) {
13384  switch (*str) {
13385  case '\'': case '"': case ':': case ';':
13386  continue;
13387  }
13388  if (!ISSPACE(*str)) break;
13389  }
13390  for (beg = str; len > 0; str++, --len) {
13391  switch (*str) {
13392  case '\'': case '"': case ':': case ';':
13393  break;
13394  default:
13395  if (ISSPACE(*str)) break;
13396  continue;
13397  }
13398  break;
13399  }
13400  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13401  if (!len) break;
13402  if (*str != ':') continue;
13403 
13404  do str++; while (--len > 0 && ISSPACE(*str));
13405  if (!len) break;
13406  if (*str == '"') {
13407  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13408  if (*str == '\\') {
13409  --len;
13410  ++str;
13411  }
13412  }
13413  vend = str;
13414  if (len) {
13415  --len;
13416  ++str;
13417  }
13418  }
13419  else {
13420  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13421  vend = str;
13422  }
13423  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13424 
13425  n = end - beg;
13426  str_copy(name, beg, n);
13427  s = RSTRING_PTR(name);
13428  for (i = 0; i < n; ++i) {
13429  if (s[i] == '-') s[i] = '_';
13430  }
13431 #ifndef RIPPER
13432  do {
13433  if (STRNCASECMP(p->name, s, n) == 0) {
13434  n = vend - vbeg;
13435  if (p->length) {
13436  n = (*p->length)(parser, vbeg, n);
13437  }
13438  str_copy(val, vbeg, n);
13439  (*p->func)(parser, s, RSTRING_PTR(val));
13440  break;
13441  }
13442  } while (++p < magic_comments + numberof(magic_comments));
13443 #else
13444  str_copy(val, vbeg, vend - vbeg);
13445  dispatch2(magic_comment, name, val);
13446 #endif
13447  }
13448 
13449  return TRUE;
13450 }
13451 
13452 static void
13453 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13454 {
13455  int sep = 0;
13456  const char *beg = str;
13457  VALUE s;
13458 
13459  for (;;) {
13460  if (send - str <= 6) return;
13461  switch (str[6]) {
13462  case 'C': case 'c': str += 6; continue;
13463  case 'O': case 'o': str += 5; continue;
13464  case 'D': case 'd': str += 4; continue;
13465  case 'I': case 'i': str += 3; continue;
13466  case 'N': case 'n': str += 2; continue;
13467  case 'G': case 'g': str += 1; continue;
13468  case '=': case ':':
13469  sep = 1;
13470  str += 6;
13471  break;
13472  default:
13473  str += 6;
13474  if (ISSPACE(*str)) break;
13475  continue;
13476  }
13477  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13478  }
13479  for (;;) {
13480  do {
13481  if (++str >= send) return;
13482  } while (ISSPACE(*str));
13483  if (sep) break;
13484  if (*str != '=' && *str != ':') return;
13485  sep = 1;
13486  str++;
13487  }
13488  beg = str;
13489  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13490  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13491  parser_set_encode(parser, RSTRING_PTR(s));
13492  rb_str_resize(s, 0);
13493 }
13494 
13495 static void
13496 parser_prepare(struct parser_params *parser)
13497 {
13498  int c = nextc();
13499  switch (c) {
13500  case '#':
13501  if (peek('!')) parser->has_shebang = 1;
13502  break;
13503  case 0xef: /* UTF-8 BOM marker */
13504  if (lex_pend - lex_p >= 2 &&
13505  (unsigned char)lex_p[0] == 0xbb &&
13506  (unsigned char)lex_p[1] == 0xbf) {
13507  parser->enc = rb_utf8_encoding();
13508  lex_p += 2;
13509  lex_pbeg = lex_p;
13510  return;
13511  }
13512  break;
13513  case EOF:
13514  return;
13515  }
13516  pushback(c);
13517  parser->enc = rb_enc_get(lex_lastline);
13518 }
13519 
13520 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13521 #define IS_END() IS_lex_state(EXPR_END_ANY)
13522 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
13523 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13524 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
13525 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
13526 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13527 
13528 #ifndef RIPPER
13529 #define ambiguous_operator(op, syn) ( \
13530  rb_warning0("`"op"' after local variable or literal is interpreted as binary operator"), \
13531  rb_warning0("even though it seems like "syn""))
13532 #else
13533 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
13534 #endif
13535 #define warn_balanced(op, syn) ((void) \
13536  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
13537  space_seen && !ISSPACE(c) && \
13538  (ambiguous_operator(op, syn), 0)))
13539 
13540 static int
13541 parser_yylex(struct parser_params *parser)
13542 {
13543  register int c;
13544  int space_seen = 0;
13545  int cmd_state;
13546  enum lex_state_e last_state;
13547  rb_encoding *enc;
13548  int mb;
13549 #ifdef RIPPER
13550  int fallthru = FALSE;
13551 #endif
13552 
13553  if (lex_strterm) {
13554  int token;
13555  if (nd_type(lex_strterm) == NODE_HEREDOC) {
13556  token = here_document(lex_strterm);
13557  if (token == tSTRING_END) {
13558  lex_strterm = 0;
13559  lex_state = EXPR_END;
13560  }
13561  }
13562  else {
13563  token = parse_string(lex_strterm);
13564  if (token == tSTRING_END || token == tREGEXP_END) {
13565  rb_gc_force_recycle((VALUE)lex_strterm);
13566  lex_strterm = 0;
13567  lex_state = EXPR_END;
13568  }
13569  }
13570  return token;
13571  }
13572  cmd_state = command_start;
13573  command_start = FALSE;
13574  retry:
13575  last_state = lex_state;
13576  switch (c = nextc()) {
13577  case '\0': /* NUL */
13578  case '\004': /* ^D */
13579  case '\032': /* ^Z */
13580  case -1: /* end of script. */
13581  return 0;
13582 
13583  /* white spaces */
13584  case ' ': case '\t': case '\f': case '\r':
13585  case '\13': /* '\v' */
13586  space_seen = 1;
13587 #ifdef RIPPER
13588  while ((c = nextc())) {
13589  switch (c) {
13590  case ' ': case '\t': case '\f': case '\r':
13591  case '\13': /* '\v' */
13592  break;
13593  default:
13594  goto outofloop;
13595  }
13596  }
13597  outofloop:
13598  pushback(c);
13599  ripper_dispatch_scan_event(parser, tSP);
13600 #endif
13601  goto retry;
13602 
13603  case '#': /* it's a comment */
13604  /* no magic_comment in shebang line */
13605  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
13606  if (comment_at_top(parser)) {
13607  set_file_encoding(parser, lex_p, lex_pend);
13608  }
13609  }
13610  lex_p = lex_pend;
13611 #ifdef RIPPER
13612  ripper_dispatch_scan_event(parser, tCOMMENT);
13613  fallthru = TRUE;
13614 #endif
13615  /* fall through */
13616  case '\n':
13617  if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT | EXPR_LABELARG)) {
13618 #ifdef RIPPER
13619  if (!fallthru) {
13620  ripper_dispatch_scan_event(parser, tIGNORED_NL);
13621  }
13622  fallthru = FALSE;
13623 #endif
13624  if (IS_lex_state(EXPR_LABELARG) && parser->parser_in_kwarg) {
13625  goto normal_newline;
13626  }
13627  goto retry;
13628  }
13629  while ((c = nextc())) {
13630  switch (c) {
13631  case ' ': case '\t': case '\f': case '\r':
13632  case '\13': /* '\v' */
13633  space_seen = 1;
13634  break;
13635  case '.': {
13636  if ((c = nextc()) != '.') {
13637  pushback(c);
13638  pushback('.');
13639  goto retry;
13640  }
13641  }
13642  default:
13643  --ruby_sourceline;
13644  lex_nextline = lex_lastline;
13645  case -1: /* EOF no decrement*/
13646  lex_goto_eol(parser);
13647 #ifdef RIPPER
13648  if (c != -1) {
13649  parser->tokp = lex_p;
13650  }
13651 #endif
13652  goto normal_newline;
13653  }
13654  }
13655  normal_newline:
13656  command_start = TRUE;
13657  lex_state = EXPR_BEG;
13658  return '\n';
13659 
13660  case '*':
13661  if ((c = nextc()) == '*') {
13662  if ((c = nextc()) == '=') {
13663  set_yylval_id(tPOW);
13664  lex_state = EXPR_BEG;
13665  return tOP_ASGN;
13666  }
13667  pushback(c);
13668  if (IS_SPCARG(c)) {
13669  rb_warning0("`**' interpreted as argument prefix");
13670  c = tDSTAR;
13671  }
13672  else if (IS_BEG()) {
13673  c = tDSTAR;
13674  }
13675  else {
13676  warn_balanced("**", "argument prefix");
13677  c = tPOW;
13678  }
13679  }
13680  else {
13681  if (c == '=') {
13682  set_yylval_id('*');
13683  lex_state = EXPR_BEG;
13684  return tOP_ASGN;
13685  }
13686  pushback(c);
13687  if (IS_SPCARG(c)) {
13688  rb_warning0("`*' interpreted as argument prefix");
13689  c = tSTAR;
13690  }
13691  else if (IS_BEG()) {
13692  c = tSTAR;
13693  }
13694  else {
13695  warn_balanced("*", "argument prefix");
13696  c = '*';
13697  }
13698  }
13699  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13700  return c;
13701 
13702  case '!':
13703  c = nextc();
13704  if (IS_AFTER_OPERATOR()) {
13705  lex_state = EXPR_ARG;
13706  if (c == '@') {
13707  return '!';
13708  }
13709  }
13710  else {
13711  lex_state = EXPR_BEG;
13712  }
13713  if (c == '=') {
13714  return tNEQ;
13715  }
13716  if (c == '~') {
13717  return tNMATCH;
13718  }
13719  pushback(c);
13720  return '!';
13721 
13722  case '=':
13723  if (was_bol()) {
13724  /* skip embedded rd document */
13725  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
13726 #ifdef RIPPER
13727  int first_p = TRUE;
13728 
13729  lex_goto_eol(parser);
13730  ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
13731 #endif
13732  for (;;) {
13733  lex_goto_eol(parser);
13734 #ifdef RIPPER
13735  if (!first_p) {
13736  ripper_dispatch_scan_event(parser, tEMBDOC);
13737  }
13738  first_p = FALSE;
13739 #endif
13740  c = nextc();
13741  if (c == -1) {
13742  compile_error(PARSER_ARG "embedded document meets end of file");
13743  return 0;
13744  }
13745  if (c != '=') continue;
13746  if (strncmp(lex_p, "end", 3) == 0 &&
13747  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
13748  break;
13749  }
13750  }
13751  lex_goto_eol(parser);
13752 #ifdef RIPPER
13753  ripper_dispatch_scan_event(parser, tEMBDOC_END);
13754 #endif
13755  goto retry;
13756  }
13757  }
13758 
13759  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13760  if ((c = nextc()) == '=') {
13761  if ((c = nextc()) == '=') {
13762  return tEQQ;
13763  }
13764  pushback(c);
13765  return tEQ;
13766  }
13767  if (c == '~') {
13768  return tMATCH;
13769  }
13770  else if (c == '>') {
13771  return tASSOC;
13772  }
13773  pushback(c);
13774  return '=';
13775 
13776  case '<':
13777  last_state = lex_state;
13778  c = nextc();
13779  if (c == '<' &&
13780  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
13781  !IS_END() &&
13782  (!IS_ARG() || space_seen)) {
13783  int token = heredoc_identifier();
13784  if (token) return token;
13785  }
13786  if (IS_AFTER_OPERATOR()) {
13787  lex_state = EXPR_ARG;
13788  }
13789  else {
13790  if (IS_lex_state(EXPR_CLASS))
13791  command_start = TRUE;
13792  lex_state = EXPR_BEG;
13793  }
13794  if (c == '=') {
13795  if ((c = nextc()) == '>') {
13796  return tCMP;
13797  }
13798  pushback(c);
13799  return tLEQ;
13800  }
13801  if (c == '<') {
13802  if ((c = nextc()) == '=') {
13803  set_yylval_id(tLSHFT);
13804  lex_state = EXPR_BEG;
13805  return tOP_ASGN;
13806  }
13807  pushback(c);
13808  warn_balanced("<<", "here document");
13809  return tLSHFT;
13810  }
13811  pushback(c);
13812  return '<';
13813 
13814  case '>':
13815  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13816  if ((c = nextc()) == '=') {
13817  return tGEQ;
13818  }
13819  if (c == '>') {
13820  if ((c = nextc()) == '=') {
13821  set_yylval_id(tRSHFT);
13822  lex_state = EXPR_BEG;
13823  return tOP_ASGN;
13824  }
13825  pushback(c);
13826  return tRSHFT;
13827  }
13828  pushback(c);
13829  return '>';
13830 
13831  case '"':
13832  lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
13833  return tSTRING_BEG;
13834 
13835  case '`':
13836  if (IS_lex_state(EXPR_FNAME)) {
13837  lex_state = EXPR_ENDFN;
13838  return c;
13839  }
13840  if (IS_lex_state(EXPR_DOT)) {
13841  if (cmd_state)
13842  lex_state = EXPR_CMDARG;
13843  else
13844  lex_state = EXPR_ARG;
13845  return c;
13846  }
13847  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
13848  return tXSTRING_BEG;
13849 
13850  case '\'':
13851  lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
13852  return tSTRING_BEG;
13853 
13854  case '?':
13855  if (IS_END()) {
13856  lex_state = EXPR_VALUE;
13857  return '?';
13858  }
13859  c = nextc();
13860  if (c == -1) {
13861  compile_error(PARSER_ARG "incomplete character syntax");
13862  return 0;
13863  }
13864  if (rb_enc_isspace(c, current_enc)) {
13865  if (!IS_ARG()) {
13866  int c2 = 0;
13867  switch (c) {
13868  case ' ':
13869  c2 = 's';
13870  break;
13871  case '\n':
13872  c2 = 'n';
13873  break;
13874  case '\t':
13875  c2 = 't';
13876  break;
13877  case '\v':
13878  c2 = 'v';
13879  break;
13880  case '\r':
13881  c2 = 'r';
13882  break;
13883  case '\f':
13884  c2 = 'f';
13885  break;
13886  }
13887  if (c2) {
13888  rb_warnI("invalid character syntax; use ?\\%c", c2);
13889  }
13890  }
13891  ternary:
13892  pushback(c);
13893  lex_state = EXPR_VALUE;
13894  return '?';
13895  }
13896  newtok();
13897  enc = current_enc;
13898  if (!parser_isascii()) {
13899  if (tokadd_mbchar(c) == -1) return 0;
13900  }
13901  else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13902  lex_p < lex_pend && is_identchar(lex_p, lex_pend, current_enc)) {
13903  goto ternary;
13904  }
13905  else if (c == '\\') {
13906  if (peek('u')) {
13907  nextc();
13908  c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
13909  if (0x80 <= c) {
13910  tokaddmbc(c, enc);
13911  }
13912  else {
13913  tokadd(c);
13914  }
13915  }
13916  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13917  nextc();
13918  if (tokadd_mbchar(c) == -1) return 0;
13919  }
13920  else {
13921  c = read_escape(0, &enc);
13922  tokadd(c);
13923  }
13924  }
13925  else {
13926  tokadd(c);
13927  }
13928  tokfix();
13929  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13930  lex_state = EXPR_END;
13931  return tCHAR;
13932 
13933  case '&':
13934  if ((c = nextc()) == '&') {
13935  lex_state = EXPR_BEG;
13936  if ((c = nextc()) == '=') {
13937  set_yylval_id(tANDOP);
13938  lex_state = EXPR_BEG;
13939  return tOP_ASGN;
13940  }
13941  pushback(c);
13942  return tANDOP;
13943  }
13944  else if (c == '=') {
13945  set_yylval_id('&');
13946  lex_state = EXPR_BEG;
13947  return tOP_ASGN;
13948  }
13949  pushback(c);
13950  if (IS_SPCARG(c)) {
13951  rb_warning0("`&' interpreted as argument prefix");
13952  c = tAMPER;
13953  }
13954  else if (IS_BEG()) {
13955  c = tAMPER;
13956  }
13957  else {
13958  warn_balanced("&", "argument prefix");
13959  c = '&';
13960  }
13961  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13962  return c;
13963 
13964  case '|':
13965  if ((c = nextc()) == '|') {
13966  lex_state = EXPR_BEG;
13967  if ((c = nextc()) == '=') {
13968  set_yylval_id(tOROP);
13969  lex_state = EXPR_BEG;
13970  return tOP_ASGN;
13971  }
13972  pushback(c);
13973  return tOROP;
13974  }
13975  if (c == '=') {
13976  set_yylval_id('|');
13977  lex_state = EXPR_BEG;
13978  return tOP_ASGN;
13979  }
13980  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
13981  pushback(c);
13982  return '|';
13983 
13984  case '+':
13985  c = nextc();
13986  if (IS_AFTER_OPERATOR()) {
13987  lex_state = EXPR_ARG;
13988  if (c == '@') {
13989  return tUPLUS;
13990  }
13991  pushback(c);
13992  return '+';
13993  }
13994  if (c == '=') {
13995  set_yylval_id('+');
13996  lex_state = EXPR_BEG;
13997  return tOP_ASGN;
13998  }
13999  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
14000  lex_state = EXPR_BEG;
14001  pushback(c);
14002  if (c != -1 && ISDIGIT(c)) {
14003  c = '+';
14004  goto start_num;
14005  }
14006  return tUPLUS;
14007  }
14008  lex_state = EXPR_BEG;
14009  pushback(c);
14010  warn_balanced("+", "unary operator");
14011  return '+';
14012 
14013  case '-':
14014  c = nextc();
14015  if (IS_AFTER_OPERATOR()) {
14016  lex_state = EXPR_ARG;
14017  if (c == '@') {
14018  return tUMINUS;
14019  }
14020  pushback(c);
14021  return '-';
14022  }
14023  if (c == '=') {
14024  set_yylval_id('-');
14025  lex_state = EXPR_BEG;
14026  return tOP_ASGN;
14027  }
14028  if (c == '>') {
14029  lex_state = EXPR_ENDFN;
14030  return tLAMBDA;
14031  }
14032  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
14033  lex_state = EXPR_BEG;
14034  pushback(c);
14035  if (c != -1 && ISDIGIT(c)) {
14036  return tUMINUS_NUM;
14037  }
14038  return tUMINUS;
14039  }
14040  lex_state = EXPR_BEG;
14041  pushback(c);
14042  warn_balanced("-", "unary operator");
14043  return '-';
14044 
14045  case '.':
14046  lex_state = EXPR_BEG;
14047  if ((c = nextc()) == '.') {
14048  if ((c = nextc()) == '.') {
14049  return tDOT3;
14050  }
14051  pushback(c);
14052  return tDOT2;
14053  }
14054  pushback(c);
14055  if (c != -1 && ISDIGIT(c)) {
14056  yyerror("no .<digit> floating literal anymore; put 0 before dot");
14057  }
14058  lex_state = EXPR_DOT;
14059  return '.';
14060 
14061  start_num:
14062  case '0': case '1': case '2': case '3': case '4':
14063  case '5': case '6': case '7': case '8': case '9':
14064  {
14065  int is_float, seen_point, seen_e, nondigit;
14066  int suffix;
14067 
14068  is_float = seen_point = seen_e = nondigit = 0;
14069  lex_state = EXPR_END;
14070  newtok();
14071  if (c == '-' || c == '+') {
14072  tokadd(c);
14073  c = nextc();
14074  }
14075  if (c == '0') {
14076 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
14077  int start = toklen();
14078  c = nextc();
14079  if (c == 'x' || c == 'X') {
14080  /* hexadecimal */
14081  c = nextc();
14082  if (c != -1 && ISXDIGIT(c)) {
14083  do {
14084  if (c == '_') {
14085  if (nondigit) break;
14086  nondigit = c;
14087  continue;
14088  }
14089  if (!ISXDIGIT(c)) break;
14090  nondigit = 0;
14091  tokadd(c);
14092  } while ((c = nextc()) != -1);
14093  }
14094  pushback(c);
14095  tokfix();
14096  if (toklen() == start) {
14097  no_digits();
14098  }
14099  else if (nondigit) goto trailing_uc;
14100  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14101  return set_integer_literal(rb_cstr_to_inum(tok(), 16, FALSE), suffix);
14102  }
14103  if (c == 'b' || c == 'B') {
14104  /* binary */
14105  c = nextc();
14106  if (c == '0' || c == '1') {
14107  do {
14108  if (c == '_') {
14109  if (nondigit) break;
14110  nondigit = c;
14111  continue;
14112  }
14113  if (c != '0' && c != '1') break;
14114  nondigit = 0;
14115  tokadd(c);
14116  } while ((c = nextc()) != -1);
14117  }
14118  pushback(c);
14119  tokfix();
14120  if (toklen() == start) {
14121  no_digits();
14122  }
14123  else if (nondigit) goto trailing_uc;
14124  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14125  return set_integer_literal(rb_cstr_to_inum(tok(), 2, FALSE), suffix);
14126  }
14127  if (c == 'd' || c == 'D') {
14128  /* decimal */
14129  c = nextc();
14130  if (c != -1 && ISDIGIT(c)) {
14131  do {
14132  if (c == '_') {
14133  if (nondigit) break;
14134  nondigit = c;
14135  continue;
14136  }
14137  if (!ISDIGIT(c)) break;
14138  nondigit = 0;
14139  tokadd(c);
14140  } while ((c = nextc()) != -1);
14141  }
14142  pushback(c);
14143  tokfix();
14144  if (toklen() == start) {
14145  no_digits();
14146  }
14147  else if (nondigit) goto trailing_uc;
14148  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14149  return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
14150  }
14151  if (c == '_') {
14152  /* 0_0 */
14153  goto octal_number;
14154  }
14155  if (c == 'o' || c == 'O') {
14156  /* prefixed octal */
14157  c = nextc();
14158  if (c == -1 || c == '_' || !ISDIGIT(c)) {
14159  no_digits();
14160  }
14161  }
14162  if (c >= '0' && c <= '7') {
14163  /* octal */
14164  octal_number:
14165  do {
14166  if (c == '_') {
14167  if (nondigit) break;
14168  nondigit = c;
14169  continue;
14170  }
14171  if (c < '0' || c > '9') break;
14172  if (c > '7') goto invalid_octal;
14173  nondigit = 0;
14174  tokadd(c);
14175  } while ((c = nextc()) != -1);
14176  if (toklen() > start) {
14177  pushback(c);
14178  tokfix();
14179  if (nondigit) goto trailing_uc;
14180  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14181  return set_integer_literal(rb_cstr_to_inum(tok(), 8, FALSE), suffix);
14182  }
14183  if (nondigit) {
14184  pushback(c);
14185  goto trailing_uc;
14186  }
14187  }
14188  if (c > '7' && c <= '9') {
14189  invalid_octal:
14190  yyerror("Invalid octal digit");
14191  }
14192  else if (c == '.' || c == 'e' || c == 'E') {
14193  tokadd('0');
14194  }
14195  else {
14196  pushback(c);
14197  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14198  return set_integer_literal(INT2FIX(0), suffix);
14199  }
14200  }
14201 
14202  for (;;) {
14203  switch (c) {
14204  case '0': case '1': case '2': case '3': case '4':
14205  case '5': case '6': case '7': case '8': case '9':
14206  nondigit = 0;
14207  tokadd(c);
14208  break;
14209 
14210  case '.':
14211  if (nondigit) goto trailing_uc;
14212  if (seen_point || seen_e) {
14213  goto decode_num;
14214  }
14215  else {
14216  int c0 = nextc();
14217  if (c0 == -1 || !ISDIGIT(c0)) {
14218  pushback(c0);
14219  goto decode_num;
14220  }
14221  c = c0;
14222  }
14223  seen_point = toklen();
14224  tokadd('.');
14225  tokadd(c);
14226  is_float++;
14227  nondigit = 0;
14228  break;
14229 
14230  case 'e':
14231  case 'E':
14232  if (nondigit) {
14233  pushback(c);
14234  c = nondigit;
14235  goto decode_num;
14236  }
14237  if (seen_e) {
14238  goto decode_num;
14239  }
14240  nondigit = c;
14241  c = nextc();
14242  if (c != '-' && c != '+' && !ISDIGIT(c)) {
14243  pushback(c);
14244  nondigit = 0;
14245  goto decode_num;
14246  }
14247  tokadd(nondigit);
14248  seen_e++;
14249  is_float++;
14250  tokadd(c);
14251  nondigit = (c == '-' || c == '+') ? c : 0;
14252  break;
14253 
14254  case '_': /* `_' in number just ignored */
14255  if (nondigit) goto decode_num;
14256  nondigit = c;
14257  break;
14258 
14259  default:
14260  goto decode_num;
14261  }
14262  c = nextc();
14263  }
14264 
14265  decode_num:
14266  pushback(c);
14267  if (nondigit) {
14268  char tmp[30];
14269  trailing_uc:
14270  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
14271  yyerror(tmp);
14272  }
14273  tokfix();
14274  if (is_float) {
14275  int type = tFLOAT;
14276  VALUE v;
14277 
14278  suffix = number_literal_suffix(seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
14279  if (suffix & NUM_SUFFIX_R) {
14280  char *point = &tok()[seen_point];
14281  size_t fraclen = toklen()-seen_point-1;
14282  type = tRATIONAL;
14283  memmove(point, point+1, fraclen+1);
14284  v = rb_cstr_to_inum(tok(), 10, FALSE);
14285  v = rb_rational_new(v, rb_int_positive_pow(10, fraclen));
14286  }
14287  else {
14288  double d = strtod(tok(), 0);
14289  if (errno == ERANGE) {
14290  rb_warningS("Float %s out of range", tok());
14291  errno = 0;
14292  }
14293  v = DBL2NUM(d);
14294  }
14295  return set_number_literal(v, type, suffix);
14296  }
14297  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
14298  return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
14299  }
14300 
14301  case ')':
14302  case ']':
14303  paren_nest--;
14304  case '}':
14305  COND_LEXPOP();
14306  CMDARG_LEXPOP();
14307  if (c == ')')
14308  lex_state = EXPR_ENDFN;
14309  else
14310  lex_state = EXPR_ENDARG;
14311  if (c == '}') {
14312  if (!brace_nest--) c = tSTRING_DEND;
14313  }
14314  return c;
14315 
14316  case ':':
14317  c = nextc();
14318  if (c == ':') {
14319  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14320  lex_state = EXPR_BEG;
14321  return tCOLON3;
14322  }
14323  lex_state = EXPR_DOT;
14324  return tCOLON2;
14325  }
14326  if (IS_END() || ISSPACE(c)) {
14327  pushback(c);
14328  warn_balanced(":", "symbol literal");
14329  lex_state = EXPR_BEG;
14330  return ':';
14331  }
14332  switch (c) {
14333  case '\'':
14334  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14335  break;
14336  case '"':
14337  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14338  break;
14339  default:
14340  pushback(c);
14341  break;
14342  }
14343  lex_state = EXPR_FNAME;
14344  return tSYMBEG;
14345 
14346  case '/':
14347  if (IS_lex_state(EXPR_BEG_ANY)) {
14348  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14349  return tREGEXP_BEG;
14350  }
14351  if ((c = nextc()) == '=') {
14352  set_yylval_id('/');
14353  lex_state = EXPR_BEG;
14354  return tOP_ASGN;
14355  }
14356  pushback(c);
14357  if (IS_SPCARG(c)) {
14358  (void)arg_ambiguous();
14359  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14360  return tREGEXP_BEG;
14361  }
14362  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14363  warn_balanced("/", "regexp literal");
14364  return '/';
14365 
14366  case '^':
14367  if ((c = nextc()) == '=') {
14368  set_yylval_id('^');
14369  lex_state = EXPR_BEG;
14370  return tOP_ASGN;
14371  }
14372  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14373  pushback(c);
14374  return '^';
14375 
14376  case ';':
14377  lex_state = EXPR_BEG;
14378  command_start = TRUE;
14379  return ';';
14380 
14381  case ',':
14382  lex_state = EXPR_BEG;
14383  return ',';
14384 
14385  case '~':
14386  if (IS_AFTER_OPERATOR()) {
14387  if ((c = nextc()) != '@') {
14388  pushback(c);
14389  }
14390  lex_state = EXPR_ARG;
14391  }
14392  else {
14393  lex_state = EXPR_BEG;
14394  }
14395  return '~';
14396 
14397  case '(':
14398  if (IS_BEG()) {
14399  c = tLPAREN;
14400  }
14401  else if (IS_SPCARG(-1)) {
14402  c = tLPAREN_ARG;
14403  }
14404  paren_nest++;
14405  COND_PUSH(0);
14406  CMDARG_PUSH(0);
14407  lex_state = EXPR_BEG;
14408  return c;
14409 
14410  case '[':
14411  paren_nest++;
14412  if (IS_AFTER_OPERATOR()) {
14413  lex_state = EXPR_ARG;
14414  if ((c = nextc()) == ']') {
14415  if ((c = nextc()) == '=') {
14416  return tASET;
14417  }
14418  pushback(c);
14419  return tAREF;
14420  }
14421  pushback(c);
14422  return '[';
14423  }
14424  else if (IS_BEG()) {
14425  c = tLBRACK;
14426  }
14427  else if (IS_ARG() && space_seen) {
14428  c = tLBRACK;
14429  }
14430  lex_state = EXPR_BEG;
14431  COND_PUSH(0);
14432  CMDARG_PUSH(0);
14433  return c;
14434 
14435  case '{':
14436  ++brace_nest;
14437  if (lpar_beg && lpar_beg == paren_nest) {
14438  lex_state = EXPR_BEG;
14439  lpar_beg = 0;
14440  --paren_nest;
14441  COND_PUSH(0);
14442  CMDARG_PUSH(0);
14443  return tLAMBEG;
14444  }
14445  if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
14446  c = '{'; /* block (primary) */
14447  else if (IS_lex_state(EXPR_ENDARG))
14448  c = tLBRACE_ARG; /* block (expr) */
14449  else
14450  c = tLBRACE; /* hash */
14451  COND_PUSH(0);
14452  CMDARG_PUSH(0);
14453  lex_state = EXPR_BEG;
14454  if (c != tLBRACE) command_start = TRUE;
14455  return c;
14456 
14457  case '\\':
14458  c = nextc();
14459  if (c == '\n') {
14460  space_seen = 1;
14461 #ifdef RIPPER
14462  ripper_dispatch_scan_event(parser, tSP);
14463 #endif
14464  goto retry; /* skip \\n */
14465  }
14466  pushback(c);
14467  return '\\';
14468 
14469  case '%':
14470  if (IS_lex_state(EXPR_BEG_ANY)) {
14471  int term;
14472  int paren;
14473 
14474  c = nextc();
14475  quotation:
14476  if (c == -1 || !ISALNUM(c)) {
14477  term = c;
14478  c = 'Q';
14479  }
14480  else {
14481  term = nextc();
14482  if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
14483  yyerror("unknown type of %string");
14484  return 0;
14485  }
14486  }
14487  if (c == -1 || term == -1) {
14488  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
14489  return 0;
14490  }
14491  paren = term;
14492  if (term == '(') term = ')';
14493  else if (term == '[') term = ']';
14494  else if (term == '{') term = '}';
14495  else if (term == '<') term = '>';
14496  else paren = 0;
14497 
14498  switch (c) {
14499  case 'Q':
14500  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
14501  return tSTRING_BEG;
14502 
14503  case 'q':
14504  lex_strterm = NEW_STRTERM(str_squote, term, paren);
14505  return tSTRING_BEG;
14506 
14507  case 'W':
14508  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14509  do {c = nextc();} while (ISSPACE(c));
14510  pushback(c);
14511  return tWORDS_BEG;
14512 
14513  case 'w':
14514  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14515  do {c = nextc();} while (ISSPACE(c));
14516  pushback(c);
14517  return tQWORDS_BEG;
14518 
14519  case 'I':
14520  lex_strterm = NEW_STRTERM(str_dword, term, paren);
14521  do {c = nextc();} while (ISSPACE(c));
14522  pushback(c);
14523  return tSYMBOLS_BEG;
14524 
14525  case 'i':
14526  lex_strterm = NEW_STRTERM(str_sword, term, paren);
14527  do {c = nextc();} while (ISSPACE(c));
14528  pushback(c);
14529  return tQSYMBOLS_BEG;
14530 
14531  case 'x':
14532  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
14533  return tXSTRING_BEG;
14534 
14535  case 'r':
14536  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
14537  return tREGEXP_BEG;
14538 
14539  case 's':
14540  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
14541  lex_state = EXPR_FNAME;
14542  return tSYMBEG;
14543 
14544  default:
14545  yyerror("unknown type of %string");
14546  return 0;
14547  }
14548  }
14549  if ((c = nextc()) == '=') {
14550  set_yylval_id('%');
14551  lex_state = EXPR_BEG;
14552  return tOP_ASGN;
14553  }
14554  if (IS_SPCARG(c)) {
14555  goto quotation;
14556  }
14557  lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
14558  pushback(c);
14559  warn_balanced("%%", "string literal");
14560  return '%';
14561 
14562  case '$':
14563  lex_state = EXPR_END;
14564  newtok();
14565  c = nextc();
14566  switch (c) {
14567  case '_': /* $_: last read line string */
14568  c = nextc();
14569  if (parser_is_identchar()) {
14570  tokadd('$');
14571  tokadd('_');
14572  break;
14573  }
14574  pushback(c);
14575  c = '_';
14576  /* fall through */
14577  case '~': /* $~: match-data */
14578  case '*': /* $*: argv */
14579  case '$': /* $$: pid */
14580  case '?': /* $?: last status */
14581  case '!': /* $!: error string */
14582  case '@': /* $@: error position */
14583  case '/': /* $/: input record separator */
14584  case '\\': /* $\: output record separator */
14585  case ';': /* $;: field separator */
14586  case ',': /* $,: output field separator */
14587  case '.': /* $.: last read line number */
14588  case '=': /* $=: ignorecase */
14589  case ':': /* $:: load path */
14590  case '<': /* $<: reading filename */
14591  case '>': /* $>: default output handle */
14592  case '\"': /* $": already loaded files */
14593  tokadd('$');
14594  tokadd(c);
14595  goto gvar;
14596 
14597  case '-':
14598  tokadd('$');
14599  tokadd(c);
14600  c = nextc();
14601  if (parser_is_identchar()) {
14602  if (tokadd_mbchar(c) == -1) return 0;
14603  }
14604  else {
14605  pushback(c);
14606  pushback('-');
14607  return '$';
14608  }
14609  gvar:
14610  set_yylval_name(rb_intern3(tok(), tokidx, current_enc));
14611  return tGVAR;
14612 
14613  case '&': /* $&: last match */
14614  case '`': /* $`: string before last match */
14615  case '\'': /* $': string after last match */
14616  case '+': /* $+: string matches last paren. */
14617  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
14618  tokadd('$');
14619  tokadd(c);
14620  goto gvar;
14621  }
14622  set_yylval_node(NEW_BACK_REF(c));
14623  return tBACK_REF;
14624 
14625  case '1': case '2': case '3':
14626  case '4': case '5': case '6':
14627  case '7': case '8': case '9':
14628  tokadd('$');
14629  do {
14630  tokadd(c);
14631  c = nextc();
14632  } while (c != -1 && ISDIGIT(c));
14633  pushback(c);
14634  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
14635  tokfix();
14636  set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
14637  return tNTH_REF;
14638 
14639  default:
14640  if (!parser_is_identchar()) {
14641  pushback(c);
14642  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
14643  return 0;
14644  }
14645  case '0':
14646  tokadd('$');
14647  }
14648  break;
14649 
14650  case '@':
14651  c = nextc();
14652  newtok();
14653  tokadd('@');
14654  if (c == '@') {
14655  tokadd('@');
14656  c = nextc();
14657  }
14658  if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
14659  pushback(c);
14660  if (tokidx == 1) {
14661  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
14662  }
14663  else {
14664  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
14665  }
14666  return 0;
14667  }
14668  break;
14669 
14670  case '_':
14671  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14672  ruby__end__seen = 1;
14673  parser->eofp = Qtrue;
14674 #ifndef RIPPER
14675  return -1;
14676 #else
14677  lex_goto_eol(parser);
14678  ripper_dispatch_scan_event(parser, k__END__);
14679  return 0;
14680 #endif
14681  }
14682  newtok();
14683  break;
14684 
14685  default:
14686  if (!parser_is_identchar()) {
14687  compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14688  goto retry;
14689  }
14690 
14691  newtok();
14692  break;
14693  }
14694 
14695  mb = ENC_CODERANGE_7BIT;
14696  do {
14697  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
14698  if (tokadd_mbchar(c) == -1) return 0;
14699  c = nextc();
14700  } while (parser_is_identchar());
14701  switch (tok()[0]) {
14702  case '@': case '$':
14703  pushback(c);
14704  break;
14705  default:
14706  if ((c == '!' || c == '?') && !peek('=')) {
14707  tokadd(c);
14708  }
14709  else {
14710  pushback(c);
14711  }
14712  }
14713  tokfix();
14714 
14715  {
14716  int result = 0;
14717 
14718  last_state = lex_state;
14719  switch (tok()[0]) {
14720  case '$':
14721  lex_state = EXPR_END;
14722  result = tGVAR;
14723  break;
14724  case '@':
14725  lex_state = EXPR_END;
14726  if (tok()[1] == '@')
14727  result = tCVAR;
14728  else
14729  result = tIVAR;
14730  break;
14731 
14732  default:
14733  if (toklast() == '!' || toklast() == '?') {
14734  result = tFID;
14735  }
14736  else {
14737  if (IS_lex_state(EXPR_FNAME)) {
14738  if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
14739  (!peek('=') || (peek_n('>', 1)))) {
14740  result = tIDENTIFIER;
14741  tokadd(c);
14742  tokfix();
14743  }
14744  else {
14745  pushback(c);
14746  }
14747  }
14748  if (result == 0 && ISUPPER(tok()[0])) {
14749  result = tCONSTANT;
14750  }
14751  else {
14752  result = tIDENTIFIER;
14753  }
14754  }
14755 
14756  if (IS_LABEL_POSSIBLE()) {
14757  if (IS_LABEL_SUFFIX(0)) {
14758  lex_state = EXPR_LABELARG;
14759  nextc();
14760  set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb)));
14761  return tLABEL;
14762  }
14763  }
14764  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
14765  const struct kwtable *kw;
14766 
14767  /* See if it is a reserved word. */
14768  kw = rb_reserved_word(tok(), toklen());
14769  if (kw) {
14770  enum lex_state_e state = lex_state;
14771  lex_state = kw->state;
14772  if (IS_lex_state_for(state, EXPR_FNAME)) {
14773  set_yylval_name(rb_intern(kw->name));
14774  return kw->id[0];
14775  }
14776  if (IS_lex_state(EXPR_BEG)) {
14777  command_start = TRUE;
14778  }
14779  if (kw->id[0] == keyword_do) {
14780  if (lpar_beg && lpar_beg == paren_nest) {
14781  lpar_beg = 0;
14782  --paren_nest;
14783  return keyword_do_LAMBDA;
14784  }
14785  if (COND_P()) return keyword_do_cond;
14786  if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG))
14787  return keyword_do_block;
14788  if (IS_lex_state_for(state, (EXPR_BEG | EXPR_ENDARG)))
14789  return keyword_do_block;
14790  return keyword_do;
14791  }
14792  if (IS_lex_state_for(state, (EXPR_BEG | EXPR_VALUE | EXPR_LABELARG)))
14793  return kw->id[0];
14794  else {
14795  if (kw->id[0] != kw->id[1])
14796  lex_state = EXPR_BEG;
14797  return kw->id[1];
14798  }
14799  }
14800  }
14801 
14802  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14803  if (cmd_state) {
14804  lex_state = EXPR_CMDARG;
14805  }
14806  else {
14807  lex_state = EXPR_ARG;
14808  }
14809  }
14810  else if (lex_state == EXPR_FNAME) {
14811  lex_state = EXPR_ENDFN;
14812  }
14813  else {
14814  lex_state = EXPR_END;
14815  }
14816  }
14817  {
14818  ID ident = TOK_INTERN(!ENC_SINGLE(mb));
14819 
14820  set_yylval_name(ident);
14821  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14822  is_local_id(ident) && lvar_defined(ident)) {
14823  lex_state = EXPR_END;
14824  }
14825  }
14826  return result;
14827  }
14828 }
14829 
14830 #if YYPURE
14831 static int
14832 yylex(void *lval, void *p)
14833 #else
14834 yylex(void *p)
14835 #endif
14836 {
14837  struct parser_params *parser = (struct parser_params*)p;
14838  int t;
14839 
14840 #if YYPURE
14841  parser->parser_yylval = lval;
14842  parser->parser_yylval->val = Qundef;
14843 #endif
14844  t = parser_yylex(parser);
14845 #ifdef RIPPER
14846  if (!NIL_P(parser->delayed)) {
14847  ripper_dispatch_delayed_token(parser, t);
14848  return t;
14849  }
14850  if (t != 0)
14851  ripper_dispatch_scan_event(parser, t);
14852 #endif
14853 
14854  return t;
14855 }
14856 
14857 #ifndef RIPPER
14858 static NODE*
14859 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14860 {
14861  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14862  nd_set_line(n, ruby_sourceline);
14863  return n;
14864 }
14865 
14866 static enum node_type
14867 nodetype(NODE *node) /* for debug */
14868 {
14869  return (enum node_type)nd_type(node);
14870 }
14871 
14872 static int
14873 nodeline(NODE *node)
14874 {
14875  return nd_line(node);
14876 }
14877 
14878 static NODE*
14879 newline_node(NODE *node)
14880 {
14881  if (node) {
14882  node = remove_begin(node);
14883  node->flags |= NODE_FL_NEWLINE;
14884  }
14885  return node;
14886 }
14887 
14888 static void
14889 fixpos(NODE *node, NODE *orig)
14890 {
14891  if (!node) return;
14892  if (!orig) return;
14893  if (orig == (NODE*)1) return;
14894  nd_set_line(node, nd_line(orig));
14895 }
14896 
14897 static void
14898 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14899 {
14900  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14901 }
14902 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14903 
14904 static void
14905 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14906 {
14907  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14908 }
14909 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14910 
14911 static NODE*
14912 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
14913 {
14914  NODE *end, *h = head, *nd;
14915 
14916  if (tail == 0) return head;
14917 
14918  if (h == 0) return tail;
14919  switch (nd_type(h)) {
14920  case NODE_LIT:
14921  case NODE_STR:
14922  case NODE_SELF:
14923  case NODE_TRUE:
14924  case NODE_FALSE:
14925  case NODE_NIL:
14926  parser_warning(h, "unused literal ignored");
14927  return tail;
14928  default:
14929  h = end = NEW_BLOCK(head);
14930  end->nd_end = end;
14931  fixpos(end, head);
14932  head = end;
14933  break;
14934  case NODE_BLOCK:
14935  end = h->nd_end;
14936  break;
14937  }
14938 
14939  nd = end->nd_head;
14940  switch (nd_type(nd)) {
14941  case NODE_RETURN:
14942  case NODE_BREAK:
14943  case NODE_NEXT:
14944  case NODE_REDO:
14945  case NODE_RETRY:
14946  if (RTEST(ruby_verbose)) {
14947  parser_warning(tail, "statement not reached");
14948  }
14949  break;
14950 
14951  default:
14952  break;
14953  }
14954 
14955  if (nd_type(tail) != NODE_BLOCK) {
14956  tail = NEW_BLOCK(tail);
14957  tail->nd_end = tail;
14958  }
14959  end->nd_next = tail;
14960  h->nd_end = tail->nd_end;
14961  return head;
14962 }
14963 
14964 /* append item to the list */
14965 static NODE*
14966 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
14967 {
14968  NODE *last;
14969 
14970  if (list == 0) return NEW_LIST(item);
14971  if (list->nd_next) {
14972  last = list->nd_next->nd_end;
14973  }
14974  else {
14975  last = list;
14976  }
14977 
14978  list->nd_alen += 1;
14979  last->nd_next = NEW_LIST(item);
14980  list->nd_next->nd_end = last->nd_next;
14981  return list;
14982 }
14983 
14984 /* concat two lists */
14985 static NODE*
14986 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
14987 {
14988  NODE *last;
14989 
14990  if (head->nd_next) {
14991  last = head->nd_next->nd_end;
14992  }
14993  else {
14994  last = head;
14995  }
14996 
14997  head->nd_alen += tail->nd_alen;
14998  last->nd_next = tail;
14999  if (tail->nd_next) {
15000  head->nd_next->nd_end = tail->nd_next->nd_end;
15001  }
15002  else {
15003  head->nd_next->nd_end = tail;
15004  }
15005 
15006  return head;
15007 }
15008 
15009 static int
15010 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
15011 {
15012  if (NIL_P(tail)) return 1;
15013  if (!rb_enc_compatible(head, tail)) {
15014  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
15015  rb_enc_name(rb_enc_get(head)),
15016  rb_enc_name(rb_enc_get(tail)));
15017  rb_str_resize(head, 0);
15018  rb_str_resize(tail, 0);
15019  return 0;
15020  }
15021  rb_str_buf_append(head, tail);
15022  return 1;
15023 }
15024 
15025 /* concat two string literals */
15026 static NODE *
15027 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
15028 {
15029  enum node_type htype;
15030  NODE *headlast;
15031  VALUE lit;
15032 
15033  if (!head) return tail;
15034  if (!tail) return head;
15035 
15036  htype = nd_type(head);
15037  if (htype == NODE_EVSTR) {
15038  NODE *node = NEW_DSTR(Qnil);
15039  head = list_append(node, head);
15040  htype = NODE_DSTR;
15041  }
15042  switch (nd_type(tail)) {
15043  case NODE_STR:
15044  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
15045  nd_type(headlast) == NODE_STR) {
15046  htype = NODE_STR;
15047  lit = headlast->nd_lit;
15048  }
15049  else {
15050  lit = head->nd_lit;
15051  }
15052  if (htype == NODE_STR) {
15053  if (!literal_concat0(parser, lit, tail->nd_lit)) {
15054  error:
15055  rb_gc_force_recycle((VALUE)head);
15056  rb_gc_force_recycle((VALUE)tail);
15057  return 0;
15058  }
15059  rb_gc_force_recycle((VALUE)tail);
15060  }
15061  else {
15062  list_append(head, tail);
15063  }
15064  break;
15065 
15066  case NODE_DSTR:
15067  if (htype == NODE_STR) {
15068  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
15069  goto error;
15070  tail->nd_lit = head->nd_lit;
15071  rb_gc_force_recycle((VALUE)head);
15072  head = tail;
15073  }
15074  else if (NIL_P(tail->nd_lit)) {
15075  append:
15076  head->nd_alen += tail->nd_alen - 1;
15077  head->nd_next->nd_end->nd_next = tail->nd_next;
15078  head->nd_next->nd_end = tail->nd_next->nd_end;
15079  rb_gc_force_recycle((VALUE)tail);
15080  }
15081  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
15082  nd_type(headlast) == NODE_STR) {
15083  lit = headlast->nd_lit;
15084  if (!literal_concat0(parser, lit, tail->nd_lit))
15085  goto error;
15086  tail->nd_lit = Qnil;
15087  goto append;
15088  }
15089  else {
15090  nd_set_type(tail, NODE_ARRAY);
15091  tail->nd_head = NEW_STR(tail->nd_lit);
15092  list_concat(head, tail);
15093  }
15094  break;
15095 
15096  case NODE_EVSTR:
15097  if (htype == NODE_STR) {
15098  nd_set_type(head, NODE_DSTR);
15099  head->nd_alen = 1;
15100  }
15101  list_append(head, tail);
15102  break;
15103  }
15104  return head;
15105 }
15106 
15107 static NODE *
15108 evstr2dstr_gen(struct parser_params *parser, NODE *node)
15109 {
15110  if (nd_type(node) == NODE_EVSTR) {
15111  node = list_append(NEW_DSTR(Qnil), node);
15112  }
15113  return node;
15114 }
15115 
15116 static NODE *
15117 new_evstr_gen(struct parser_params *parser, NODE *node)
15118 {
15119  NODE *head = node;
15120 
15121  if (node) {
15122  switch (nd_type(node)) {
15123  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
15124  return node;
15125  }
15126  }
15127  return NEW_EVSTR(head);
15128 }
15129 
15130 static NODE *
15131 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
15132 {
15133  value_expr(recv);
15134  value_expr(arg1);
15135  return NEW_CALL(recv, id, NEW_LIST(arg1));
15136 }
15137 
15138 static NODE *
15139 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
15140 {
15141  value_expr(recv);
15142  return NEW_CALL(recv, id, 0);
15143 }
15144 
15145 static NODE*
15146 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15147 {
15148  value_expr(node1);
15149  value_expr(node2);
15150  if (node1) {
15151  switch (nd_type(node1)) {
15152  case NODE_DREGX:
15153  case NODE_DREGX_ONCE:
15154  return NEW_MATCH2(node1, node2);
15155 
15156  case NODE_LIT:
15157  if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
15158  return NEW_MATCH2(node1, node2);
15159  }
15160  }
15161  }
15162 
15163  if (node2) {
15164  switch (nd_type(node2)) {
15165  case NODE_DREGX:
15166  case NODE_DREGX_ONCE:
15167  return NEW_MATCH3(node2, node1);
15168 
15169  case NODE_LIT:
15170  if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
15171  return NEW_MATCH3(node2, node1);
15172  }
15173  }
15174  }
15175 
15176  return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
15177 }
15178 
15179 static NODE*
15180 gettable_gen(struct parser_params *parser, ID id)
15181 {
15182  switch (id) {
15183  case keyword_self:
15184  return NEW_SELF();
15185  case keyword_nil:
15186  return NEW_NIL();
15187  case keyword_true:
15188  return NEW_TRUE();
15189  case keyword_false:
15190  return NEW_FALSE();
15191  case keyword__FILE__:
15192  return NEW_STR(rb_str_dup(ruby_sourcefile_string));
15193  case keyword__LINE__:
15194  return NEW_LIT(INT2FIX(tokline));
15195  case keyword__ENCODING__:
15196  return NEW_LIT(rb_enc_from_encoding(current_enc));
15197  }
15198  switch (id_type(id)) {
15199  case ID_LOCAL:
15200  if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
15201  if (local_id(id)) return NEW_LVAR(id);
15202  /* method call without arguments */
15203  return NEW_VCALL(id);
15204  case ID_GLOBAL:
15205  return NEW_GVAR(id);
15206  case ID_INSTANCE:
15207  return NEW_IVAR(id);
15208  case ID_CONST:
15209  return NEW_CONST(id);
15210  case ID_CLASS:
15211  return NEW_CVAR(id);
15212  }
15213  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15214  return 0;
15215 }
15216 #else /* !RIPPER */
15217 static int
15218 id_is_var_gen(struct parser_params *parser, ID id)
15219 {
15220  if (is_notop_id(id)) {
15221  switch (id & ID_SCOPE_MASK) {
15222  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
15223  return 1;
15224  case ID_LOCAL:
15225  if (dyna_in_block() && dvar_defined(id)) return 1;
15226  if (local_id(id)) return 1;
15227  /* method call without arguments */
15228  return 0;
15229  }
15230  }
15231  compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
15232  return 0;
15233 }
15234 #endif /* !RIPPER */
15235 
15236 #if PARSER_DEBUG
15237 static const char *
15238 lex_state_name(enum lex_state_e state)
15239 {
15240  static const char names[][12] = {
15241  "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG",
15242  "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS",
15243  "EXPR_VALUE",
15244  };
15245 
15246  if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
15247  return names[ffs(state)];
15248  return NULL;
15249 }
15250 #endif
15251 
15252 #ifdef RIPPER
15253 static VALUE
15254 assignable_gen(struct parser_params *parser, VALUE lhs)
15255 #else
15256 static NODE*
15257 assignable_gen(struct parser_params *parser, ID id, NODE *val)
15258 #endif
15259 {
15260 #ifdef RIPPER
15261  ID id = get_id(lhs);
15262 # define assignable_result(x) get_value(lhs)
15263 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
15264 #else
15265 # define assignable_result(x) (x)
15266 #endif
15267  if (!id) return assignable_result(0);
15268  switch (id) {
15269  case keyword_self:
15270  yyerror("Can't change the value of self");
15271  goto error;
15272  case keyword_nil:
15273  yyerror("Can't assign to nil");
15274  goto error;
15275  case keyword_true:
15276  yyerror("Can't assign to true");
15277  goto error;
15278  case keyword_false:
15279  yyerror("Can't assign to false");
15280  goto error;
15281  case keyword__FILE__:
15282  yyerror("Can't assign to __FILE__");
15283  goto error;
15284  case keyword__LINE__:
15285  yyerror("Can't assign to __LINE__");
15286  goto error;
15287  case keyword__ENCODING__:
15288  yyerror("Can't assign to __ENCODING__");
15289  goto error;
15290  }
15291  switch (id_type(id)) {
15292  case ID_LOCAL:
15293  if (dyna_in_block()) {
15294  if (dvar_curr(id)) {
15295  return assignable_result(NEW_DASGN_CURR(id, val));
15296  }
15297  else if (dvar_defined(id)) {
15298  return assignable_result(NEW_DASGN(id, val));
15299  }
15300  else if (local_id(id)) {
15301  return assignable_result(NEW_LASGN(id, val));
15302  }
15303  else {
15304  dyna_var(id);
15305  return assignable_result(NEW_DASGN_CURR(id, val));
15306  }
15307  }
15308  else {
15309  if (!local_id(id)) {
15310  local_var(id);
15311  }
15312  return assignable_result(NEW_LASGN(id, val));
15313  }
15314  break;
15315  case ID_GLOBAL:
15316  return assignable_result(NEW_GASGN(id, val));
15317  case ID_INSTANCE:
15318  return assignable_result(NEW_IASGN(id, val));
15319  case ID_CONST:
15320  if (!in_def && !in_single)
15321  return assignable_result(NEW_CDECL(id, val, 0));
15322  yyerror("dynamic constant assignment");
15323  break;
15324  case ID_CLASS:
15325  return assignable_result(NEW_CVASGN(id, val));
15326  default:
15327  compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
15328  }
15329  error:
15330  return assignable_result(0);
15331 #undef assignable_result
15332 #undef parser_yyerror
15333 }
15334 
15335 static int
15336 is_private_local_id(ID name)
15337 {
15338  VALUE s;
15339  if (name == idUScore) return 1;
15340  if (!is_local_id(name)) return 0;
15341  s = rb_id2str(name);
15342  if (!s) return 0;
15343  return RSTRING_PTR(s)[0] == '_';
15344 }
15345 
15346 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
15347 
15348 static int
15349 shadowing_lvar_0(struct parser_params *parser, ID name)
15350 {
15351  if (is_private_local_id(name)) return 1;
15352  if (dyna_in_block()) {
15353  if (dvar_curr(name)) {
15354  yyerror("duplicated argument name");
15355  }
15356  else if (dvar_defined_get(name) || local_id(name)) {
15357  rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
15358  vtable_add(lvtbl->vars, name);
15359  if (lvtbl->used) {
15360  vtable_add(lvtbl->used, (ID)ruby_sourceline | LVAR_USED);
15361  }
15362  return 0;
15363  }
15364  }
15365  else {
15366  if (local_id(name)) {
15367  yyerror("duplicated argument name");
15368  }
15369  }
15370  return 1;
15371 }
15372 
15373 static ID
15374 shadowing_lvar_gen(struct parser_params *parser, ID name)
15375 {
15376  shadowing_lvar_0(parser, name);
15377  return name;
15378 }
15379 
15380 static void
15381 new_bv_gen(struct parser_params *parser, ID name)
15382 {
15383  if (!name) return;
15384  if (!is_local_id(name)) {
15385  compile_error(PARSER_ARG "invalid local variable - %s",
15386  rb_id2name(name));
15387  return;
15388  }
15389  if (!shadowing_lvar_0(parser, name)) return;
15390  dyna_var(name);
15391 }
15392 
15393 #ifndef RIPPER
15394 static NODE *
15395 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
15396 {
15397  if (recv && nd_type(recv) == NODE_SELF)
15398  recv = (NODE *)1;
15399  return NEW_ATTRASGN(recv, tASET, idx);
15400 }
15401 
15402 static void
15403 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15404 {
15405  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15406  compile_error(PARSER_ARG "both block arg and actual block given");
15407  }
15408 }
15409 
15410 static const char id_type_names[][9] = {
15411  "LOCAL",
15412  "INSTANCE",
15413  "", /* INSTANCE2 */
15414  "GLOBAL",
15415  "ATTRSET",
15416  "CONST",
15417  "CLASS",
15418  "JUNK",
15419 };
15420 
15421 ID
15422 rb_id_attrset(ID id)
15423 {
15424  if (!is_notop_id(id)) {
15425  switch (id) {
15426  case tAREF: case tASET:
15427  return tASET; /* only exception */
15428  }
15429  rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
15430  }
15431  else {
15432  int scope = (int)(id & ID_SCOPE_MASK);
15433  switch (scope) {
15434  case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
15435  case ID_CONST: case ID_CLASS: case ID_JUNK:
15436  break;
15437  case ID_ATTRSET:
15438  return id;
15439  default:
15440  rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset",
15441  id_type_names[scope], ID2SYM(id));
15442 
15443  }
15444  }
15445  id &= ~ID_SCOPE_MASK;
15446  id |= ID_ATTRSET;
15447  return id;
15448 }
15449 
15450 static NODE *
15451 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
15452 {
15453  if (recv && nd_type(recv) == NODE_SELF)
15454  recv = (NODE *)1;
15455  return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
15456 }
15457 
15458 static void
15459 rb_backref_error_gen(struct parser_params *parser, NODE *node)
15460 {
15461  switch (nd_type(node)) {
15462  case NODE_NTH_REF:
15463  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15464  break;
15465  case NODE_BACK_REF:
15466  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15467  break;
15468  }
15469 }
15470 
15471 static NODE *
15472 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15473 {
15474  if (!node2) return node1;
15475  switch (nd_type(node1)) {
15476  case NODE_BLOCK_PASS:
15477  if (node1->nd_head)
15478  node1->nd_head = arg_concat(node1->nd_head, node2);
15479  else
15480  node1->nd_head = NEW_LIST(node2);
15481  return node1;
15482  case NODE_ARGSPUSH:
15483  if (nd_type(node2) != NODE_ARRAY) break;
15484  node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
15485  nd_set_type(node1, NODE_ARGSCAT);
15486  return node1;
15487  case NODE_ARGSCAT:
15488  if (nd_type(node2) != NODE_ARRAY ||
15489  nd_type(node1->nd_body) != NODE_ARRAY) break;
15490  node1->nd_body = list_concat(node1->nd_body, node2);
15491  return node1;
15492  }
15493  return NEW_ARGSCAT(node1, node2);
15494 }
15495 
15496 static NODE *
15497 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15498 {
15499  if (!node1) return NEW_LIST(node2);
15500  switch (nd_type(node1)) {
15501  case NODE_ARRAY:
15502  return list_append(node1, node2);
15503  case NODE_BLOCK_PASS:
15504  node1->nd_head = arg_append(node1->nd_head, node2);
15505  return node1;
15506  case NODE_ARGSPUSH:
15507  node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
15508  nd_set_type(node1, NODE_ARGSCAT);
15509  return node1;
15510  }
15511  return NEW_ARGSPUSH(node1, node2);
15512 }
15513 
15514 static NODE *
15515 splat_array(NODE* node)
15516 {
15517  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15518  if (nd_type(node) == NODE_ARRAY) return node;
15519  return 0;
15520 }
15521 
15522 static NODE *
15523 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
15524 {
15525  if (!lhs) return 0;
15526 
15527  switch (nd_type(lhs)) {
15528  case NODE_GASGN:
15529  case NODE_IASGN:
15530  case NODE_IASGN2:
15531  case NODE_LASGN:
15532  case NODE_DASGN:
15533  case NODE_DASGN_CURR:
15534  case NODE_MASGN:
15535  case NODE_CDECL:
15536  case NODE_CVASGN:
15537  lhs->nd_value = rhs;
15538  break;
15539 
15540  case NODE_ATTRASGN:
15541  case NODE_CALL:
15542  lhs->nd_args = arg_append(lhs->nd_args, rhs);
15543  break;
15544 
15545  default:
15546  /* should not happen */
15547  break;
15548  }
15549 
15550  return lhs;
15551 }
15552 
15553 static int
15554 value_expr_gen(struct parser_params *parser, NODE *node)
15555 {
15556  int cond = 0;
15557 
15558  if (!node) {
15559  rb_warning0("empty expression");
15560  }
15561  while (node) {
15562  switch (nd_type(node)) {
15563  case NODE_RETURN:
15564  case NODE_BREAK:
15565  case NODE_NEXT:
15566  case NODE_REDO:
15567  case NODE_RETRY:
15568  if (!cond) yyerror("void value expression");
15569  /* or "control never reach"? */
15570  return FALSE;
15571 
15572  case NODE_BLOCK:
15573  while (node->nd_next) {
15574  node = node->nd_next;
15575  }
15576  node = node->nd_head;
15577  break;
15578 
15579  case NODE_BEGIN:
15580  node = node->nd_body;
15581  break;
15582 
15583  case NODE_IF:
15584  if (!node->nd_body) {
15585  node = node->nd_else;
15586  break;
15587  }
15588  else if (!node->nd_else) {
15589  node = node->nd_body;
15590  break;
15591  }
15592  if (!value_expr(node->nd_body)) return FALSE;
15593  node = node->nd_else;
15594  break;
15595 
15596  case NODE_AND:
15597  case NODE_OR:
15598  cond = 1;
15599  node = node->nd_2nd;
15600  break;
15601 
15602  default:
15603  return TRUE;
15604  }
15605  }
15606 
15607  return TRUE;
15608 }
15609 
15610 static void
15611 void_expr_gen(struct parser_params *parser, NODE *node)
15612 {
15613  const char *useless = 0;
15614 
15615  if (!RTEST(ruby_verbose)) return;
15616 
15617  if (!node) return;
15618  switch (nd_type(node)) {
15619  case NODE_CALL:
15620  switch (node->nd_mid) {
15621  case '+':
15622  case '-':
15623  case '*':
15624  case '/':
15625  case '%':
15626  case tPOW:
15627  case tUPLUS:
15628  case tUMINUS:
15629  case '|':
15630  case '^':
15631  case '&':
15632  case tCMP:
15633  case '>':
15634  case tGEQ:
15635  case '<':
15636  case tLEQ:
15637  case tEQ:
15638  case tNEQ:
15639  useless = rb_id2name(node->nd_mid);
15640  break;
15641  }
15642  break;
15643 
15644  case NODE_LVAR:
15645  case NODE_DVAR:
15646  case NODE_GVAR:
15647  case NODE_IVAR:
15648  case NODE_CVAR:
15649  case NODE_NTH_REF:
15650  case NODE_BACK_REF:
15651  useless = "a variable";
15652  break;
15653  case NODE_CONST:
15654  useless = "a constant";
15655  break;
15656  case NODE_LIT:
15657  case NODE_STR:
15658  case NODE_DSTR:
15659  case NODE_DREGX:
15660  case NODE_DREGX_ONCE:
15661  useless = "a literal";
15662  break;
15663  case NODE_COLON2:
15664  case NODE_COLON3:
15665  useless = "::";
15666  break;
15667  case NODE_DOT2:
15668  useless = "..";
15669  break;
15670  case NODE_DOT3:
15671  useless = "...";
15672  break;
15673  case NODE_SELF:
15674  useless = "self";
15675  break;
15676  case NODE_NIL:
15677  useless = "nil";
15678  break;
15679  case NODE_TRUE:
15680  useless = "true";
15681  break;
15682  case NODE_FALSE:
15683  useless = "false";
15684  break;
15685  case NODE_DEFINED:
15686  useless = "defined?";
15687  break;
15688  }
15689 
15690  if (useless) {
15691  int line = ruby_sourceline;
15692 
15693  ruby_sourceline = nd_line(node);
15694  rb_warnS("possibly useless use of %s in void context", useless);
15695  ruby_sourceline = line;
15696  }
15697 }
15698 
15699 static void
15700 void_stmts_gen(struct parser_params *parser, NODE *node)
15701 {
15702  if (!RTEST(ruby_verbose)) return;
15703  if (!node) return;
15704  if (nd_type(node) != NODE_BLOCK) return;
15705 
15706  for (;;) {
15707  if (!node->nd_next) return;
15708  void_expr0(node->nd_head);
15709  node = node->nd_next;
15710  }
15711 }
15712 
15713 static NODE *
15714 remove_begin(NODE *node)
15715 {
15716  NODE **n = &node, *n1 = node;
15717  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
15718  *n = n1 = n1->nd_body;
15719  }
15720  return node;
15721 }
15722 
15723 static NODE *
15724 remove_begin_all(NODE *node)
15725 {
15726  NODE **n = &node, *n1 = node;
15727  while (n1 && nd_type(n1) == NODE_BEGIN) {
15728  *n = n1 = n1->nd_body;
15729  }
15730  return node;
15731 }
15732 
15733 static void
15734 reduce_nodes_gen(struct parser_params *parser, NODE **body)
15735 {
15736  NODE *node = *body;
15737 
15738  if (!node) {
15739  *body = NEW_NIL();
15740  return;
15741  }
15742 #define subnodes(n1, n2) \
15743  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
15744  (!node->n2) ? (body = &node->n1, 1) : \
15745  (reduce_nodes(&node->n1), body = &node->n2, 1))
15746 
15747  while (node) {
15748  int newline = (int)(node->flags & NODE_FL_NEWLINE);
15749  switch (nd_type(node)) {
15750  end:
15751  case NODE_NIL:
15752  *body = 0;
15753  return;
15754  case NODE_RETURN:
15755  *body = node = node->nd_stts;
15756  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15757  continue;
15758  case NODE_BEGIN:
15759  *body = node = node->nd_body;
15760  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15761  continue;
15762  case NODE_BLOCK:
15763  body = &node->nd_end->nd_head;
15764  break;
15765  case NODE_IF:
15766  if (subnodes(nd_body, nd_else)) break;
15767  return;
15768  case NODE_CASE:
15769  body = &node->nd_body;
15770  break;
15771  case NODE_WHEN:
15772  if (!subnodes(nd_body, nd_next)) goto end;
15773  break;
15774  case NODE_ENSURE:
15775  if (!subnodes(nd_head, nd_resq)) goto end;
15776  break;
15777  case NODE_RESCUE:
15778  if (node->nd_else) {
15779  body = &node->nd_resq;
15780  break;
15781  }
15782  if (!subnodes(nd_head, nd_resq)) goto end;
15783  break;
15784  default:
15785  return;
15786  }
15787  node = *body;
15788  if (newline && node) node->flags |= NODE_FL_NEWLINE;
15789  }
15790 
15791 #undef subnodes
15792 }
15793 
15794 static int
15795 is_static_content(NODE *node)
15796 {
15797  if (!node) return 1;
15798  switch (nd_type(node)) {
15799  case NODE_HASH:
15800  if (!(node = node->nd_head)) break;
15801  case NODE_ARRAY:
15802  do {
15803  if (!is_static_content(node->nd_head)) return 0;
15804  } while ((node = node->nd_next) != 0);
15805  case NODE_LIT:
15806  case NODE_STR:
15807  case NODE_NIL:
15808  case NODE_TRUE:
15809  case NODE_FALSE:
15810  case NODE_ZARRAY:
15811  break;
15812  default:
15813  return 0;
15814  }
15815  return 1;
15816 }
15817 
15818 static int
15819 assign_in_cond(struct parser_params *parser, NODE *node)
15820 {
15821  switch (nd_type(node)) {
15822  case NODE_MASGN:
15823  yyerror("multiple assignment in conditional");
15824  return 1;
15825 
15826  case NODE_LASGN:
15827  case NODE_DASGN:
15828  case NODE_DASGN_CURR:
15829  case NODE_GASGN:
15830  case NODE_IASGN:
15831  break;
15832 
15833  default:
15834  return 0;
15835  }
15836 
15837  if (!node->nd_value) return 1;
15838  if (is_static_content(node->nd_value)) {
15839  /* reports always */
15840  parser_warn(node->nd_value, "found = in conditional, should be ==");
15841  }
15842  return 1;
15843 }
15844 
15845 static void
15846 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15847 {
15848  if (!e_option_supplied(parser)) parser_warn(node, str);
15849 }
15850 
15851 static void
15852 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
15853 {
15854  if (!e_option_supplied(parser)) parser_warning(node, str);
15855 }
15856 
15857 static void
15858 fixup_nodes(NODE **rootnode)
15859 {
15860  NODE *node, *next, *head;
15861 
15862  for (node = *rootnode; node; node = next) {
15863  enum node_type type;
15864  VALUE val;
15865 
15866  next = node->nd_next;
15867  head = node->nd_head;
15868  rb_gc_force_recycle((VALUE)node);
15869  *rootnode = next;
15870  switch (type = nd_type(head)) {
15871  case NODE_DOT2:
15872  case NODE_DOT3:
15873  val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
15874  type == NODE_DOT3);
15875  rb_gc_force_recycle((VALUE)head->nd_beg);
15876  rb_gc_force_recycle((VALUE)head->nd_end);
15877  nd_set_type(head, NODE_LIT);
15878  head->nd_lit = val;
15879  break;
15880  default:
15881  break;
15882  }
15883  }
15884 }
15885 
15886 static NODE *cond0(struct parser_params*,NODE*);
15887 
15888 static NODE*
15889 range_op(struct parser_params *parser, NODE *node)
15890 {
15891  enum node_type type;
15892 
15893  if (node == 0) return 0;
15894 
15895  type = nd_type(node);
15896  value_expr(node);
15897  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
15898  warn_unless_e_option(parser, node, "integer literal in conditional range");
15899  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
15900  }
15901  return cond0(parser, node);
15902 }
15903 
15904 static int
15905 literal_node(NODE *node)
15906 {
15907  if (!node) return 1; /* same as NODE_NIL */
15908  switch (nd_type(node)) {
15909  case NODE_LIT:
15910  case NODE_STR:
15911  case NODE_DSTR:
15912  case NODE_EVSTR:
15913  case NODE_DREGX:
15914  case NODE_DREGX_ONCE:
15915  case NODE_DSYM:
15916  return 2;
15917  case NODE_TRUE:
15918  case NODE_FALSE:
15919  case NODE_NIL:
15920  return 1;
15921  }
15922  return 0;
15923 }
15924 
15925 static NODE*
15926 cond0(struct parser_params *parser, NODE *node)
15927 {
15928  if (node == 0) return 0;
15929  assign_in_cond(parser, node);
15930 
15931  switch (nd_type(node)) {
15932  case NODE_DSTR:
15933  case NODE_EVSTR:
15934  case NODE_STR:
15935  rb_warn0("string literal in condition");
15936  break;
15937 
15938  case NODE_DREGX:
15939  case NODE_DREGX_ONCE:
15940  warning_unless_e_option(parser, node, "regex literal in condition");
15941  return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
15942 
15943  case NODE_AND:
15944  case NODE_OR:
15945  node->nd_1st = cond0(parser, node->nd_1st);
15946  node->nd_2nd = cond0(parser, node->nd_2nd);
15947  break;
15948 
15949  case NODE_DOT2:
15950  case NODE_DOT3:
15951  node->nd_beg = range_op(parser, node->nd_beg);
15952  node->nd_end = range_op(parser, node->nd_end);
15953  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
15954  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
15955  if (!e_option_supplied(parser)) {
15956  int b = literal_node(node->nd_beg);
15957  int e = literal_node(node->nd_end);
15958  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
15959  parser_warn(node, "range literal in condition");
15960  }
15961  }
15962  break;
15963 
15964  case NODE_DSYM:
15965  parser_warning(node, "literal in condition");
15966  break;
15967 
15968  case NODE_LIT:
15969  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
15970  warn_unless_e_option(parser, node, "regex literal in condition");
15971  nd_set_type(node, NODE_MATCH);
15972  }
15973  else {
15974  parser_warning(node, "literal in condition");
15975  }
15976  default:
15977  break;
15978  }
15979  return node;
15980 }
15981 
15982 static NODE*
15983 cond_gen(struct parser_params *parser, NODE *node)
15984 {
15985  if (node == 0) return 0;
15986  return cond0(parser, node);
15987 }
15988 
15989 static NODE*
15990 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
15991 {
15992  value_expr(left);
15993  if (left && (enum node_type)nd_type(left) == type) {
15994  NODE *node = left, *second;
15995  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
15996  node = second;
15997  }
15998  node->nd_2nd = NEW_NODE(type, second, right, 0);
15999  return left;
16000  }
16001  return NEW_NODE(type, left, right, 0);
16002 }
16003 
16004 static void
16005 no_blockarg(struct parser_params *parser, NODE *node)
16006 {
16007  if (node && nd_type(node) == NODE_BLOCK_PASS) {
16008  compile_error(PARSER_ARG "block argument should not be given");
16009  }
16010 }
16011 
16012 static NODE *
16013 ret_args_gen(struct parser_params *parser, NODE *node)
16014 {
16015  if (node) {
16016  no_blockarg(parser, node);
16017  if (nd_type(node) == NODE_ARRAY) {
16018  if (node->nd_next == 0) {
16019  node = node->nd_head;
16020  }
16021  else {
16022  nd_set_type(node, NODE_VALUES);
16023  }
16024  }
16025  }
16026  return node;
16027 }
16028 
16029 static NODE *
16030 new_yield_gen(struct parser_params *parser, NODE *node)
16031 {
16032  if (node) no_blockarg(parser, node);
16033 
16034  return NEW_YIELD(node);
16035 }
16036 
16037 static NODE*
16038 negate_lit(NODE *node)
16039 {
16040  switch (TYPE(node->nd_lit)) {
16041  case T_FIXNUM:
16042  node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
16043  break;
16044  case T_BIGNUM:
16045  case T_RATIONAL:
16046  case T_COMPLEX:
16047  node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
16048  break;
16049  case T_FLOAT:
16050 #if USE_FLONUM
16051  if (FLONUM_P(node->nd_lit)) {
16052  node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
16053  }
16054  else {
16055  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
16056  }
16057 #else
16058  RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
16059 #endif
16060  break;
16061  default:
16062  rb_bug("unknown literal type passed to negate_lit");
16063  break;
16064  }
16065  return node;
16066 }
16067 
16068 static NODE *
16069 arg_blk_pass(NODE *node1, NODE *node2)
16070 {
16071  if (node2) {
16072  node2->nd_head = node1;
16073  return node2;
16074  }
16075  return node1;
16076 }
16077 
16078 
16079 static NODE*
16080 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
16081 {
16082  int saved_line = ruby_sourceline;
16083  struct rb_args_info *args = tail->nd_ainfo;
16084 
16085  args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0;
16086  args->pre_init = m ? m->nd_next : 0;
16087 
16088  args->post_args_num = p ? rb_long2int(p->nd_plen) : 0;
16089  args->post_init = p ? p->nd_next : 0;
16090  args->first_post_arg = p ? p->nd_pid : 0;
16091 
16092  args->rest_arg = r;
16093 
16094  args->opt_args = o;
16095 
16096  ruby_sourceline = saved_line;
16097 
16098  return tail;
16099 }
16100 
16101 static NODE*
16102 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
16103 {
16104  int saved_line = ruby_sourceline;
16105  struct rb_args_info *args;
16106  NODE *kw_rest_arg = 0;
16107  NODE *node;
16108  int check = 0;
16109 
16110  args = ALLOC(struct rb_args_info);
16111  MEMZERO(args, struct rb_args_info, 1);
16112  node = NEW_NODE(NODE_ARGS, 0, 0, args);
16113 
16114  args->block_arg = b;
16115  args->kw_args = k;
16116  if (k && !kr) {
16117  check = 1;
16118  kr = internal_id();
16119  }
16120  if (kr) {
16121  arg_var(kr);
16122  kw_rest_arg = NEW_DVAR(kr);
16123  kw_rest_arg->nd_cflag = check;
16124  }
16125  args->kw_rest_arg = kw_rest_arg;
16126 
16127  ruby_sourceline = saved_line;
16128  return node;
16129 }
16130 
16131 static NODE*
16132 dsym_node_gen(struct parser_params *parser, NODE *node)
16133 {
16134  VALUE lit;
16135 
16136  if (!node) {
16137  return NEW_LIT(ID2SYM(idNULL));
16138  }
16139 
16140  switch (nd_type(node)) {
16141  case NODE_DSTR:
16142  nd_set_type(node, NODE_DSYM);
16143  break;
16144  case NODE_STR:
16145  lit = node->nd_lit;
16146  node->nd_lit = ID2SYM(rb_intern_str(lit));
16147  nd_set_type(node, NODE_LIT);
16148  break;
16149  default:
16150  node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
16151  break;
16152  }
16153  return node;
16154 }
16155 #endif /* !RIPPER */
16156 
16157 #ifndef RIPPER
16158 static NODE *
16159 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16160 {
16161  NODE *asgn;
16162 
16163  if (lhs) {
16164  ID vid = lhs->nd_vid;
16165  if (op == tOROP) {
16166  lhs->nd_value = rhs;
16167  asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
16168  if (is_asgn_or_id(vid)) {
16169  asgn->nd_aid = vid;
16170  }
16171  }
16172  else if (op == tANDOP) {
16173  lhs->nd_value = rhs;
16174  asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
16175  }
16176  else {
16177  asgn = lhs;
16178  asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
16179  }
16180  }
16181  else {
16182  asgn = NEW_BEGIN(0);
16183  }
16184  return asgn;
16185 }
16186 
16187 static NODE *
16188 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
16189 {
16190  NODE *asgn;
16191 
16192  if (op == tOROP) {
16193  op = 0;
16194  }
16195  else if (op == tANDOP) {
16196  op = 1;
16197  }
16198  asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
16199  fixpos(asgn, lhs);
16200  return asgn;
16201 }
16202 
16203 static NODE *
16204 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
16205 {
16206  NODE *asgn;
16207 
16208  if (op == tOROP) {
16209  op = 0;
16210  }
16211  else if (op == tANDOP) {
16212  op = 1;
16213  }
16214  if (lhs) {
16215  asgn = NEW_OP_CDECL(lhs, op, rhs);
16216  }
16217  else {
16218  asgn = NEW_BEGIN(0);
16219  }
16220  fixpos(asgn, lhs);
16221  return asgn;
16222 }
16223 #else
16224 static VALUE
16225 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
16226 {
16227  return dispatch3(opassign, lhs, op, rhs);
16228 }
16229 
16230 static VALUE
16231 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
16232 {
16233  VALUE recv = dispatch3(field, lhs, type, attr);
16234  return dispatch3(opassign, recv, op, rhs);
16235 }
16236 #endif
16237 
16238 static void
16239 warn_unused_var(struct parser_params *parser, struct local_vars *local)
16240 {
16241  int i, cnt;
16242  ID *v, *u;
16243 
16244  if (!local->used) return;
16245  v = local->vars->tbl;
16246  u = local->used->tbl;
16247  cnt = local->used->pos;
16248  if (cnt != local->vars->pos) {
16249  rb_bug("local->used->pos != local->vars->pos");
16250  }
16251  for (i = 0; i < cnt; ++i) {
16252  if (!v[i] || (u[i] & LVAR_USED)) continue;
16253  if (is_private_local_id(v[i])) continue;
16254  rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
16255  }
16256 }
16257 
16258 static void
16259 local_push_gen(struct parser_params *parser, int inherit_dvars)
16260 {
16261  struct local_vars *local;
16262 
16263  local = ALLOC(struct local_vars);
16264  local->prev = lvtbl;
16265  local->args = vtable_alloc(0);
16266  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
16267  local->used = !(inherit_dvars &&
16268  (ifndef_ripper(compile_for_eval || e_option_supplied(parser))+0)) &&
16269  RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
16270  local->cmdargs = cmdarg_stack;
16271  cmdarg_stack = 0;
16272  lvtbl = local;
16273 }
16274 
16275 static void
16276 local_pop_gen(struct parser_params *parser)
16277 {
16278  struct local_vars *local = lvtbl->prev;
16279  if (lvtbl->used) {
16280  warn_unused_var(parser, lvtbl);
16281  vtable_free(lvtbl->used);
16282  }
16283  vtable_free(lvtbl->args);
16284  vtable_free(lvtbl->vars);
16285  cmdarg_stack = lvtbl->cmdargs;
16286  xfree(lvtbl);
16287  lvtbl = local;
16288 }
16289 
16290 #ifndef RIPPER
16291 static ID*
16292 local_tbl_gen(struct parser_params *parser)
16293 {
16294  int cnt_args = vtable_size(lvtbl->args);
16295  int cnt_vars = vtable_size(lvtbl->vars);
16296  int cnt = cnt_args + cnt_vars;
16297  int i, j;
16298  ID *buf;
16299 
16300  if (cnt <= 0) return 0;
16301  buf = ALLOC_N(ID, cnt + 1);
16302  MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args);
16303  /* remove IDs duplicated to warn shadowing */
16304  for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
16305  ID id = lvtbl->vars->tbl[i];
16306  if (!vtable_included(lvtbl->args, id)) {
16307  buf[j++] = id;
16308  }
16309  }
16310  if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1);
16311  buf[0] = cnt;
16312  return buf;
16313 }
16314 #endif
16315 
16316 static int
16317 arg_var_gen(struct parser_params *parser, ID id)
16318 {
16319  vtable_add(lvtbl->args, id);
16320  return vtable_size(lvtbl->args) - 1;
16321 }
16322 
16323 static int
16324 local_var_gen(struct parser_params *parser, ID id)
16325 {
16326  vtable_add(lvtbl->vars, id);
16327  if (lvtbl->used) {
16328  vtable_add(lvtbl->used, (ID)ruby_sourceline);
16329  }
16330  return vtable_size(lvtbl->vars) - 1;
16331 }
16332 
16333 static int
16334 local_id_gen(struct parser_params *parser, ID id)
16335 {
16336  struct vtable *vars, *args, *used;
16337 
16338  vars = lvtbl->vars;
16339  args = lvtbl->args;
16340  used = lvtbl->used;
16341 
16342  while (vars && POINTER_P(vars->prev)) {
16343  vars = vars->prev;
16344  args = args->prev;
16345  if (used) used = used->prev;
16346  }
16347 
16348  if (vars && vars->prev == DVARS_INHERIT) {
16349  return rb_local_defined(id);
16350  }
16351  else if (vtable_included(args, id)) {
16352  return 1;
16353  }
16354  else {
16355  int i = vtable_included(vars, id);
16356  if (i && used) used->tbl[i-1] |= LVAR_USED;
16357  return i != 0;
16358  }
16359 }
16360 
16361 static const struct vtable *
16362 dyna_push_gen(struct parser_params *parser)
16363 {
16364  lvtbl->args = vtable_alloc(lvtbl->args);
16365  lvtbl->vars = vtable_alloc(lvtbl->vars);
16366  if (lvtbl->used) {
16367  lvtbl->used = vtable_alloc(lvtbl->used);
16368  }
16369  return lvtbl->args;
16370 }
16371 
16372 static void
16373 dyna_pop_1(struct parser_params *parser)
16374 {
16375  struct vtable *tmp;
16376 
16377  if ((tmp = lvtbl->used) != 0) {
16378  warn_unused_var(parser, lvtbl);
16379  lvtbl->used = lvtbl->used->prev;
16380  vtable_free(tmp);
16381  }
16382  tmp = lvtbl->args;
16383  lvtbl->args = lvtbl->args->prev;
16384  vtable_free(tmp);
16385  tmp = lvtbl->vars;
16386  lvtbl->vars = lvtbl->vars->prev;
16387  vtable_free(tmp);
16388 }
16389 
16390 static void
16391 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16392 {
16393  while (lvtbl->args != lvargs) {
16394  dyna_pop_1(parser);
16395  if (!lvtbl->args) {
16396  struct local_vars *local = lvtbl->prev;
16397  xfree(lvtbl);
16398  lvtbl = local;
16399  }
16400  }
16401  dyna_pop_1(parser);
16402 }
16403 
16404 static int
16405 dyna_in_block_gen(struct parser_params *parser)
16406 {
16407  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16408 }
16409 
16410 static int
16411 dvar_defined_gen(struct parser_params *parser, ID id, int get)
16412 {
16413  struct vtable *vars, *args, *used;
16414  int i;
16415 
16416  args = lvtbl->args;
16417  vars = lvtbl->vars;
16418  used = lvtbl->used;
16419 
16420  while (POINTER_P(vars)) {
16421  if (vtable_included(args, id)) {
16422  return 1;
16423  }
16424  if ((i = vtable_included(vars, id)) != 0) {
16425  if (used) used->tbl[i-1] |= LVAR_USED;
16426  return 1;
16427  }
16428  args = args->prev;
16429  vars = vars->prev;
16430  if (get) used = 0;
16431  if (used) used = used->prev;
16432  }
16433 
16434  if (vars == DVARS_INHERIT) {
16435  return rb_dvar_defined(id);
16436  }
16437 
16438  return 0;
16439 }
16440 
16441 static int
16442 dvar_curr_gen(struct parser_params *parser, ID id)
16443 {
16444  return (vtable_included(lvtbl->args, id) ||
16445  vtable_included(lvtbl->vars, id));
16446 }
16447 
16448 #ifndef RIPPER
16449 static void
16450 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
16451 {
16452  int c = RE_OPTION_ENCODING_IDX(options);
16453 
16454  if (c) {
16455  int opt, idx;
16456  rb_char_to_option_kcode(c, &opt, &idx);
16457  if (idx != ENCODING_GET(str) &&
16458  rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16459  goto error;
16460  }
16461  ENCODING_SET(str, idx);
16462  }
16463  else if (RE_OPTION_ENCODING_NONE(options)) {
16464  if (!ENCODING_IS_ASCII8BIT(str) &&
16465  rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16466  c = 'n';
16467  goto error;
16468  }
16469  rb_enc_associate(str, rb_ascii8bit_encoding());
16470  }
16471  else if (current_enc == rb_usascii_encoding()) {
16472  if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
16473  /* raise in re.c */
16474  rb_enc_associate(str, rb_usascii_encoding());
16475  }
16476  else {
16477  rb_enc_associate(str, rb_ascii8bit_encoding());
16478  }
16479  }
16480  return;
16481 
16482  error:
16483  compile_error(PARSER_ARG
16484  "regexp encoding option '%c' differs from source encoding '%s'",
16485  c, rb_enc_name(rb_enc_get(str)));
16486 }
16487 
16488 static int
16489 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
16490 {
16491  VALUE err;
16492  reg_fragment_setenc(str, options);
16493  err = rb_reg_check_preprocess(str);
16494  if (err != Qnil) {
16495  err = rb_obj_as_string(err);
16496  compile_error(PARSER_ARG "%"PRIsVALUE, err);
16497  return 0;
16498  }
16499  return 1;
16500 }
16501 
16502 typedef struct {
16503  struct parser_params* parser;
16504  rb_encoding *enc;
16505  NODE *succ_block;
16506  NODE *fail_block;
16507  int num;
16508 } reg_named_capture_assign_t;
16509 
16510 static int
16511 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
16512  int back_num, int *back_refs, OnigRegex regex, void *arg0)
16513 {
16514  reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
16515  struct parser_params* parser = arg->parser;
16516  rb_encoding *enc = arg->enc;
16517  long len = name_end - name;
16518  const char *s = (const char *)name;
16519  ID var;
16520 
16521  arg->num++;
16522 
16523  if (arg->succ_block == 0) {
16524  arg->succ_block = NEW_BEGIN(0);
16525  arg->fail_block = NEW_BEGIN(0);
16526  }
16527 
16528  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
16529  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
16530  !rb_enc_symname2_p(s, len, enc)) {
16531  return ST_CONTINUE;
16532  }
16533  var = rb_intern3(s, len, enc);
16534  if (dvar_defined(var) || local_id(var)) {
16535  rb_warningS("named capture conflicts a local variable - %s",
16536  rb_id2name(var));
16537  }
16538  arg->succ_block = block_append(arg->succ_block,
16539  newline_node(node_assign(assignable(var,0),
16540  NEW_CALL(
16541  gettable(rb_intern("$~")),
16542  idAREF,
16543  NEW_LIST(NEW_LIT(ID2SYM(var))))
16544  )));
16545  arg->fail_block = block_append(arg->fail_block,
16546  newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil))));
16547  return ST_CONTINUE;
16548 }
16549 
16550 static NODE *
16551 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match)
16552 {
16553  reg_named_capture_assign_t arg;
16554 
16555  arg.parser = parser;
16556  arg.enc = rb_enc_get(regexp);
16557  arg.succ_block = 0;
16558  arg.fail_block = 0;
16559  arg.num = 0;
16560  onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
16561 
16562  if (arg.num == 0)
16563  return match;
16564 
16565  return
16566  block_append(
16567  newline_node(match),
16568  NEW_IF(gettable(rb_intern("$~")),
16569  block_append(
16570  newline_node(arg.succ_block),
16571  newline_node(
16572  NEW_CALL(
16573  gettable(rb_intern("$~")),
16574  rb_intern("begin"),
16575  NEW_LIST(NEW_LIT(INT2FIX(0)))))),
16576  block_append(
16577  newline_node(arg.fail_block),
16578  newline_node(
16579  NEW_LIT(Qnil)))));
16580 }
16581 
16582 static VALUE
16583 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
16584 {
16585  VALUE re;
16586  VALUE err;
16587 
16588  reg_fragment_setenc(str, options);
16589  err = rb_errinfo();
16590  re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
16591  if (NIL_P(re)) {
16592  ID mesg = rb_intern("mesg");
16593  VALUE m = rb_attr_get(rb_errinfo(), mesg);
16594  rb_set_errinfo(err);
16595  if (!NIL_P(err)) {
16596  rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
16597  }
16598  else {
16599  compile_error(PARSER_ARG "%"PRIsVALUE, m);
16600  }
16601  return Qnil;
16602  }
16603  return re;
16604 }
16605 
16606 void
16607 rb_gc_mark_parser(void)
16608 {
16609 }
16610 
16611 NODE*
16612 rb_parser_append_print(VALUE vparser, NODE *node)
16613 {
16614  NODE *prelude = 0;
16615  NODE *scope = node;
16616  struct parser_params *parser;
16617 
16618  if (!node) return node;
16619 
16620  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16621 
16622  node = node->nd_body;
16623 
16624  if (nd_type(node) == NODE_PRELUDE) {
16625  prelude = node;
16626  node = node->nd_body;
16627  }
16628 
16629  node = block_append(node,
16630  NEW_FCALL(rb_intern("print"),
16631  NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
16632  if (prelude) {
16633  prelude->nd_body = node;
16634  scope->nd_body = prelude;
16635  }
16636  else {
16637  scope->nd_body = node;
16638  }
16639 
16640  return scope;
16641 }
16642 
16643 NODE *
16644 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
16645 {
16646  NODE *prelude = 0;
16647  NODE *scope = node;
16648  struct parser_params *parser;
16649 
16650  if (!node) return node;
16651 
16652  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
16653 
16654  node = node->nd_body;
16655 
16656  if (nd_type(node) == NODE_PRELUDE) {
16657  prelude = node;
16658  node = node->nd_body;
16659  }
16660  if (split) {
16661  node = block_append(NEW_GASGN(rb_intern("$F"),
16662  NEW_CALL(NEW_GVAR(rb_intern("$_")),
16663  rb_intern("split"), 0)),
16664  node);
16665  }
16666  if (chop) {
16667  node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
16668  rb_intern("chop!"), 0), node);
16669  }
16670 
16671  node = NEW_OPT_N(node);
16672 
16673  if (prelude) {
16674  prelude->nd_body = node;
16675  scope->nd_body = prelude;
16676  }
16677  else {
16678  scope->nd_body = node;
16679  }
16680 
16681  return scope;
16682 }
16683 
16684 static const struct {
16685  ID token;
16686  const char *name;
16687 } op_tbl[] = {
16688  {tDOT2, ".."},
16689  {tDOT3, "..."},
16690  {tPOW, "**"},
16691  {tDSTAR, "**"},
16692  {tUPLUS, "+@"},
16693  {tUMINUS, "-@"},
16694  {tCMP, "<=>"},
16695  {tGEQ, ">="},
16696  {tLEQ, "<="},
16697  {tEQ, "=="},
16698  {tEQQ, "==="},
16699  {tNEQ, "!="},
16700  {tMATCH, "=~"},
16701  {tNMATCH, "!~"},
16702  {tAREF, "[]"},
16703  {tASET, "[]="},
16704  {tLSHFT, "<<"},
16705  {tRSHFT, ">>"},
16706  {tCOLON2, "::"},
16707 };
16708 
16709 #define op_tbl_count numberof(op_tbl)
16710 
16711 #ifndef ENABLE_SELECTOR_NAMESPACE
16712 #define ENABLE_SELECTOR_NAMESPACE 0
16713 #endif
16714 
16715 static struct symbols {
16716  ID last_id;
16717  st_table *sym_id;
16718  st_table *id_str;
16719 #if ENABLE_SELECTOR_NAMESPACE
16720  st_table *ivar2_id;
16721  st_table *id_ivar2;
16722 #endif
16723  VALUE op_sym[tLAST_OP_ID];
16724  int minor_marked;
16725 } global_symbols = {tLAST_TOKEN};
16726 
16727 static const struct st_hash_type symhash = {
16728  rb_str_hash_cmp,
16729  rb_str_hash,
16730 };
16731 
16732 #if ENABLE_SELECTOR_NAMESPACE
16733 struct ivar2_key {
16734  ID id;
16735  VALUE klass;
16736 };
16737 
16738 static int
16739 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
16740 {
16741  if (key1->id == key2->id && key1->klass == key2->klass) {
16742  return 0;
16743  }
16744  return 1;
16745 }
16746 
16747 static int
16748 ivar2_hash(struct ivar2_key *key)
16749 {
16750  return (key->id << 8) ^ (key->klass >> 2);
16751 }
16752 
16753 static const struct st_hash_type ivar2_hash_type = {
16754  ivar2_cmp,
16755  ivar2_hash,
16756 };
16757 #endif
16758 
16759 void
16760 Init_sym(void)
16761 {
16762  global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
16763  global_symbols.id_str = st_init_numtable_with_size(1000);
16764 #if ENABLE_SELECTOR_NAMESPACE
16765  global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
16766  global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
16767 #endif
16768 
16769  (void)nodetype;
16770  (void)nodeline;
16771 #if PARSER_DEBUG
16772  (void)lex_state_name(-1);
16773 #endif
16774 
16775  Init_id();
16776 }
16777 
16778 void
16779 rb_gc_mark_symbols(int full_mark)
16780 {
16781  if (full_mark || global_symbols.minor_marked == 0) {
16782  rb_mark_tbl(global_symbols.id_str);
16783  rb_gc_mark_locations(global_symbols.op_sym,
16784  global_symbols.op_sym + numberof(global_symbols.op_sym));
16785 
16786  if (!full_mark) global_symbols.minor_marked = 1;
16787  }
16788 }
16789 #endif /* !RIPPER */
16790 
16791 static ID
16792 internal_id_gen(struct parser_params *parser)
16793 {
16794  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
16795  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
16796  return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
16797 }
16798 
16799 #ifndef RIPPER
16800 static int
16801 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
16802 {
16803  int mb = 0;
16804 
16805  if (m >= e) return 0;
16806  if (is_global_name_punct(*m)) {
16807  ++m;
16808  }
16809  else if (*m == '-') {
16810  if (++m >= e) return 0;
16811  if (is_identchar(m, e, enc)) {
16812  if (!ISASCII(*m)) mb = 1;
16813  m += rb_enc_mbclen(m, e, enc);
16814  }
16815  }
16816  else {
16817  if (!rb_enc_isdigit(*m, enc)) return 0;
16818  do {
16819  if (!ISASCII(*m)) mb = 1;
16820  ++m;
16821  } while (m < e && rb_enc_isdigit(*m, enc));
16822  }
16823  return m == e ? mb + 1 : 0;
16824 }
16825 
16826 int
16827 rb_symname_p(const char *name)
16828 {
16829  return rb_enc_symname_p(name, rb_ascii8bit_encoding());
16830 }
16831 
16832 int
16833 rb_enc_symname_p(const char *name, rb_encoding *enc)
16834 {
16835  return rb_enc_symname2_p(name, strlen(name), enc);
16836 }
16837 
16838 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
16839 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<ID_SCOPE_MASK) & ~(1U<<ID_ATTRSET))
16840 
16841 static int
16842 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset)
16843 {
16844  const char *m = name;
16845  const char *e = m + len;
16846  int type = ID_JUNK;
16847 
16848  if (!m || len <= 0) return -1;
16849  switch (*m) {
16850  case '\0':
16851  return -1;
16852 
16853  case '$':
16854  type = ID_GLOBAL;
16855  if (is_special_global_name(++m, e, enc)) return type;
16856  goto id;
16857 
16858  case '@':
16859  type = ID_INSTANCE;
16860  if (*++m == '@') {
16861  ++m;
16862  type = ID_CLASS;
16863  }
16864  goto id;
16865 
16866  case '<':
16867  switch (*++m) {
16868  case '<': ++m; break;
16869  case '=': if (*++m == '>') ++m; break;
16870  default: break;
16871  }
16872  break;
16873 
16874  case '>':
16875  switch (*++m) {
16876  case '>': case '=': ++m; break;
16877  }
16878  break;
16879 
16880  case '=':
16881  switch (*++m) {
16882  case '~': ++m; break;
16883  case '=': if (*++m == '=') ++m; break;
16884  default: return -1;
16885  }
16886  break;
16887 
16888  case '*':
16889  if (*++m == '*') ++m;
16890  break;
16891 
16892  case '+': case '-':
16893  if (*++m == '@') ++m;
16894  break;
16895 
16896  case '|': case '^': case '&': case '/': case '%': case '~': case '`':
16897  ++m;
16898  break;
16899 
16900  case '[':
16901  if (*++m != ']') return -1;
16902  if (*++m == '=') ++m;
16903  break;
16904 
16905  case '!':
16906  if (len == 1) return ID_JUNK;
16907  switch (*++m) {
16908  case '=': case '~': ++m; break;
16909  default: return -1;
16910  }
16911  break;
16912 
16913  default:
16914  type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
16915  id:
16916  if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
16917  return -1;
16918  while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
16919  if (m >= e) break;
16920  switch (*m) {
16921  case '!': case '?':
16922  if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
16923  type = ID_JUNK;
16924  ++m;
16925  break;
16926  case '=':
16927  if (!(allowed_attrset & (1U << type))) return -1;
16928  type = ID_ATTRSET;
16929  ++m;
16930  break;
16931  }
16932  break;
16933  }
16934  return m == e ? type : -1;
16935 }
16936 
16937 int
16938 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
16939 {
16940  return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
16941 }
16942 
16943 static int
16944 rb_str_symname_type(VALUE name, unsigned int allowed_attrset)
16945 {
16946  const char *ptr = StringValuePtr(name);
16947  long len = RSTRING_LEN(name);
16948  int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_attrset);
16949  RB_GC_GUARD(name);
16950  return type;
16951 }
16952 
16953 static ID
16954 register_symid(ID id, const char *name, long len, rb_encoding *enc)
16955 {
16956  VALUE str = rb_enc_str_new(name, len, enc);
16957  return register_symid_str(id, str);
16958 }
16959 
16960 static ID
16961 register_symid_str(ID id, VALUE str)
16962 {
16963  OBJ_FREEZE(str);
16964  str = rb_fstring(str);
16965 
16966  if (RUBY_DTRACE_SYMBOL_CREATE_ENABLED()) {
16967  RUBY_DTRACE_SYMBOL_CREATE(RSTRING_PTR(str), rb_sourcefile(), rb_sourceline());
16968  }
16969 
16970  st_add_direct(global_symbols.sym_id, (st_data_t)str, id);
16971  st_add_direct(global_symbols.id_str, id, (st_data_t)str);
16972  global_symbols.minor_marked = 0;
16973  return id;
16974 }
16975 
16976 static int
16977 sym_check_asciionly(VALUE str)
16978 {
16979  if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
16980  switch (rb_enc_str_coderange(str)) {
16981  case ENC_CODERANGE_BROKEN:
16982  rb_raise(rb_eEncodingError, "invalid encoding symbol");
16983  case ENC_CODERANGE_7BIT:
16984  return TRUE;
16985  }
16986  return FALSE;
16987 }
16988 
16989 /*
16990  * _str_ itself will be registered at the global symbol table. _str_
16991  * can be modified before the registration, since the encoding will be
16992  * set to ASCII-8BIT if it is a special global name.
16993  */
16994 static ID intern_str(VALUE str);
16995 
16996 static VALUE
16997 setup_fake_str(struct RString *fake_str, const char *name, long len)
16998 {
16999  fake_str->basic.flags = T_STRING|RSTRING_NOEMBED;
17000  RBASIC_SET_CLASS_RAW((VALUE)fake_str, rb_cString);
17001  fake_str->as.heap.len = len;
17002  fake_str->as.heap.ptr = (char *)name;
17003  fake_str->as.heap.aux.capa = len;
17004  return (VALUE)fake_str;
17005 }
17006 
17007 ID
17008 rb_intern3(const char *name, long len, rb_encoding *enc)
17009 {
17010  st_data_t data;
17011  struct RString fake_str;
17012  VALUE str = setup_fake_str(&fake_str, name, len);
17013  rb_enc_associate(str, enc);
17014  OBJ_FREEZE(str);
17015 
17016  if (st_lookup(global_symbols.sym_id, str, &data))
17017  return (ID)data;
17018 
17019  str = rb_enc_str_new(name, len, enc); /* make true string */
17020  return intern_str(str);
17021 }
17022 
17023 static ID
17024 intern_str(VALUE str)
17025 {
17026  const char *name, *m, *e;
17027  long len, last;
17028  rb_encoding *enc, *symenc;
17029  unsigned char c;
17030  ID id;
17031  int mb;
17032 
17033  RSTRING_GETMEM(str, name, len);
17034  m = name;
17035  e = m + len;
17036  enc = rb_enc_get(str);
17037  symenc = enc;
17038 
17039  if (!len || (rb_cString && !rb_enc_asciicompat(enc))) {
17040  junk:
17041  id = ID_JUNK;
17042  goto new_id;
17043  }
17044  last = len-1;
17045  id = 0;
17046  switch (*m) {
17047  case '$':
17048  if (len < 2) goto junk;
17049  id |= ID_GLOBAL;
17050  if ((mb = is_special_global_name(++m, e, enc)) != 0) {
17051  if (!--mb) symenc = rb_usascii_encoding();
17052  goto new_id;
17053  }
17054  break;
17055  case '@':
17056  if (m[1] == '@') {
17057  if (len < 3) goto junk;
17058  m++;
17059  id |= ID_CLASS;
17060  }
17061  else {
17062  if (len < 2) goto junk;
17063  id |= ID_INSTANCE;
17064  }
17065  m++;
17066  break;
17067  default:
17068  c = m[0];
17069  if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
17070  /* operators */
17071  int i;
17072 
17073  if (len == 1) {
17074  id = c;
17075  goto id_register;
17076  }
17077  for (i = 0; i < op_tbl_count; i++) {
17078  if (*op_tbl[i].name == *m &&
17079  strcmp(op_tbl[i].name, m) == 0) {
17080  id = op_tbl[i].token;
17081  goto id_register;
17082  }
17083  }
17084  }
17085  break;
17086  }
17087  if (name[last] == '=') {
17088  /* attribute assignment */
17089  if (last > 1 && name[last-1] == '=')
17090  goto junk;
17091  id = rb_intern3(name, last, enc);
17092  if (id > tLAST_OP_ID && !is_attrset_id(id)) {
17093  enc = rb_enc_get(rb_id2str(id));
17094  id = rb_id_attrset(id);
17095  goto id_register;
17096  }
17097  id = ID_ATTRSET;
17098  }
17099  else if (id == 0) {
17100  if (rb_enc_isupper(m[0], enc)) {
17101  id = ID_CONST;
17102  }
17103  else {
17104  id = ID_LOCAL;
17105  }
17106  }
17107  if (!rb_enc_isdigit(*m, enc)) {
17108  while (m <= name + last && is_identchar(m, e, enc)) {
17109  if (ISASCII(*m)) {
17110  m++;
17111  }
17112  else {
17113  m += rb_enc_mbclen(m, e, enc);
17114  }
17115  }
17116  }
17117  if (id != ID_ATTRSET && m - name < len) id = ID_JUNK;
17118  if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
17119  new_id:
17120  if (symenc != enc) rb_enc_associate(str, symenc);
17121  if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) {
17122  if (len > 20) {
17123  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
17124  name);
17125  }
17126  else {
17127  rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
17128  (int)len, name);
17129  }
17130  }
17131  id |= ++global_symbols.last_id << ID_SCOPE_SHIFT;
17132  id_register:
17133  return register_symid_str(id, str);
17134 }
17135 
17136 ID
17137 rb_intern2(const char *name, long len)
17138 {
17139  return rb_intern3(name, len, rb_usascii_encoding());
17140 }
17141 
17142 #undef rb_intern
17143 ID
17144 rb_intern(const char *name)
17145 {
17146  return rb_intern2(name, strlen(name));
17147 }
17148 
17149 ID
17150 rb_intern_str(VALUE str)
17151 {
17152  st_data_t id;
17153 
17154  if (st_lookup(global_symbols.sym_id, str, &id))
17155  return (ID)id;
17156  return intern_str(rb_str_dup(str));
17157 }
17158 
17159 VALUE
17160 rb_id2str(ID id)
17161 {
17162  st_data_t data;
17163 
17164  if (id < tLAST_TOKEN) {
17165  int i = 0;
17166 
17167  if (id < INT_MAX && rb_ispunct((int)id)) {
17168  VALUE str = global_symbols.op_sym[i = (int)id];
17169  if (!str) {
17170  char name[2];
17171  name[0] = (char)id;
17172  name[1] = 0;
17173  str = rb_usascii_str_new(name, 1);
17174  OBJ_FREEZE(str);
17175  str = rb_fstring(str);
17176  global_symbols.op_sym[i] = str;
17177  global_symbols.minor_marked = 0;
17178  }
17179  return str;
17180  }
17181  for (i = 0; i < op_tbl_count; i++) {
17182  if (op_tbl[i].token == id) {
17183  VALUE str = global_symbols.op_sym[i];
17184  if (!str) {
17185  str = rb_usascii_str_new2(op_tbl[i].name);
17186  OBJ_FREEZE(str);
17187  str = rb_fstring(str);
17188  global_symbols.op_sym[i] = str;
17189  global_symbols.minor_marked = 0;
17190  }
17191  return str;
17192  }
17193  }
17194  }
17195 
17196  if (st_lookup(global_symbols.id_str, id, &data)) {
17197  VALUE str = (VALUE)data;
17198  if (RBASIC(str)->klass == 0)
17199  RBASIC_SET_CLASS_RAW(str, rb_cString);
17200  return str;
17201  }
17202 
17203  if (is_attrset_id(id)) {
17204  ID id_stem = (id & ~ID_SCOPE_MASK);
17205  VALUE str;
17206 
17207  do {
17208  if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break;
17209  if (!!(str = rb_id2str(id_stem | ID_CONST))) break;
17210  if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break;
17211  if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break;
17212  if (!!(str = rb_id2str(id_stem | ID_CLASS))) break;
17213  if (!!(str = rb_id2str(id_stem | ID_JUNK))) break;
17214  return 0;
17215  } while (0);
17216  str = rb_str_dup(str);
17217  rb_str_cat(str, "=", 1);
17218  register_symid_str(id, str);
17219  if (st_lookup(global_symbols.id_str, id, &data)) {
17220  VALUE str = (VALUE)data;
17221  if (RBASIC(str)->klass == 0)
17222  RBASIC_SET_CLASS_RAW(str, rb_cString);
17223  return str;
17224  }
17225  }
17226  return 0;
17227 }
17228 
17229 const char *
17230 rb_id2name(ID id)
17231 {
17232  VALUE str = rb_id2str(id);
17233 
17234  if (!str) return 0;
17235  return RSTRING_PTR(str);
17236 }
17237 
17238 static int
17239 symbols_i(VALUE sym, ID value, VALUE ary)
17240 {
17241  rb_ary_push(ary, ID2SYM(value));
17242  return ST_CONTINUE;
17243 }
17244 
17245 /*
17246  * call-seq:
17247  * Symbol.all_symbols => array
17248  *
17249  * Returns an array of all the symbols currently in Ruby's symbol
17250  * table.
17251  *
17252  * Symbol.all_symbols.size #=> 903
17253  * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
17254  * :chown, :EOFError, :$;, :String,
17255  * :LOCK_SH, :"setuid?", :$<,
17256  * :default_proc, :compact, :extend,
17257  * :Tms, :getwd, :$=, :ThreadGroup,
17258  * :wait2, :$>]
17259  */
17260 
17261 VALUE
17262 rb_sym_all_symbols(void)
17263 {
17264  VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries);
17265 
17266  st_foreach(global_symbols.sym_id, symbols_i, ary);
17267  return ary;
17268 }
17269 
17270 int
17271 rb_is_const_id(ID id)
17272 {
17273  return is_const_id(id);
17274 }
17275 
17276 int
17277 rb_is_class_id(ID id)
17278 {
17279  return is_class_id(id);
17280 }
17281 
17282 int
17283 rb_is_global_id(ID id)
17284 {
17285  return is_global_id(id);
17286 }
17287 
17288 int
17289 rb_is_instance_id(ID id)
17290 {
17291  return is_instance_id(id);
17292 }
17293 
17294 int
17295 rb_is_attrset_id(ID id)
17296 {
17297  return is_attrset_id(id);
17298 }
17299 
17300 int
17301 rb_is_local_id(ID id)
17302 {
17303  return is_local_id(id);
17304 }
17305 
17306 int
17307 rb_is_junk_id(ID id)
17308 {
17309  return is_junk_id(id);
17310 }
17311 
17323 ID
17324 rb_check_id(volatile VALUE *namep)
17325 {
17326  st_data_t id;
17327  VALUE tmp;
17328  VALUE name = *namep;
17329 
17330  if (SYMBOL_P(name)) {
17331  return SYM2ID(name);
17332  }
17333  else if (!RB_TYPE_P(name, T_STRING)) {
17334  tmp = rb_check_string_type(name);
17335  if (NIL_P(tmp)) {
17336  tmp = rb_inspect(name);
17337  rb_raise(rb_eTypeError, "%s is not a symbol",
17338  RSTRING_PTR(tmp));
17339  }
17340  name = tmp;
17341  *namep = name;
17342  }
17343 
17344  sym_check_asciionly(name);
17345 
17346  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17347  return (ID)id;
17348 
17349  if (rb_is_attrset_name(name)) {
17350  struct RString fake_str;
17351  /* make local name by chopping '=' */
17352  const VALUE localname = setup_fake_str(&fake_str, RSTRING_PTR(name), RSTRING_LEN(name) - 1);
17353  rb_enc_copy(localname, name);
17354  OBJ_FREEZE(localname);
17355 
17356  if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
17357  return rb_id_attrset((ID)id);
17358  }
17359  RB_GC_GUARD(name);
17360  }
17361 
17362  return (ID)0;
17363 }
17364 
17365 ID
17366 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
17367 {
17368  st_data_t id;
17369  struct RString fake_str;
17370  const VALUE name = setup_fake_str(&fake_str, ptr, len);
17371  rb_enc_associate(name, enc);
17372 
17373  sym_check_asciionly(name);
17374 
17375  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
17376  return (ID)id;
17377 
17378  if (rb_is_attrset_name(name)) {
17379  fake_str.as.heap.len = len - 1;
17380  if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
17381  return rb_id_attrset((ID)id);
17382  }
17383  }
17384 
17385  return (ID)0;
17386 }
17387 
17388 int
17389 rb_is_const_name(VALUE name)
17390 {
17391  return rb_str_symname_type(name, 0) == ID_CONST;
17392 }
17393 
17394 int
17395 rb_is_class_name(VALUE name)
17396 {
17397  return rb_str_symname_type(name, 0) == ID_CLASS;
17398 }
17399 
17400 int
17401 rb_is_global_name(VALUE name)
17402 {
17403  return rb_str_symname_type(name, 0) == ID_GLOBAL;
17404 }
17405 
17406 int
17407 rb_is_instance_name(VALUE name)
17408 {
17409  return rb_str_symname_type(name, 0) == ID_INSTANCE;
17410 }
17411 
17412 int
17413 rb_is_attrset_name(VALUE name)
17414 {
17415  return rb_str_symname_type(name, IDSET_ATTRSET_FOR_INTERN) == ID_ATTRSET;
17416 }
17417 
17418 int
17419 rb_is_local_name(VALUE name)
17420 {
17421  return rb_str_symname_type(name, 0) == ID_LOCAL;
17422 }
17423 
17424 int
17425 rb_is_method_name(VALUE name)
17426 {
17427  switch (rb_str_symname_type(name, 0)) {
17428  case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
17429  return TRUE;
17430  }
17431  return FALSE;
17432 }
17433 
17434 int
17435 rb_is_junk_name(VALUE name)
17436 {
17437  return rb_str_symname_type(name, IDSET_ATTRSET_FOR_SYNTAX) == -1;
17438 }
17439 
17440 #endif /* !RIPPER */
17441 
17442 static void
17443 parser_initialize(struct parser_params *parser)
17444 {
17445  parser->eofp = Qfalse;
17446 
17447  parser->parser_lex_strterm = 0;
17448  parser->parser_cond_stack = 0;
17449  parser->parser_cmdarg_stack = 0;
17450  parser->parser_class_nest = 0;
17451  parser->parser_paren_nest = 0;
17452  parser->parser_lpar_beg = 0;
17453  parser->parser_brace_nest = 0;
17454  parser->parser_in_single = 0;
17455  parser->parser_in_def = 0;
17456  parser->parser_in_defined = 0;
17457  parser->parser_in_kwarg = 0;
17458  parser->parser_compile_for_eval = 0;
17459  parser->parser_cur_mid = 0;
17460  parser->parser_tokenbuf = NULL;
17461  parser->parser_tokidx = 0;
17462  parser->parser_toksiz = 0;
17463  parser->parser_heredoc_end = 0;
17464  parser->parser_command_start = TRUE;
17465  parser->parser_deferred_nodes = 0;
17466  parser->parser_lex_pbeg = 0;
17467  parser->parser_lex_p = 0;
17468  parser->parser_lex_pend = 0;
17469  parser->parser_lvtbl = 0;
17470  parser->parser_ruby__end__seen = 0;
17471  parser->parser_ruby_sourcefile = 0;
17472  parser->parser_ruby_sourcefile_string = Qnil;
17473 #ifndef RIPPER
17474  parser->is_ripper = 0;
17475  parser->parser_eval_tree_begin = 0;
17476  parser->parser_eval_tree = 0;
17477 #else
17478  parser->is_ripper = 1;
17479  parser->delayed = Qnil;
17480 
17481  parser->result = Qnil;
17482  parser->parsing_thread = Qnil;
17483  parser->toplevel_p = TRUE;
17484 #endif
17485 #ifdef YYMALLOC
17486  parser->heap = NULL;
17487 #endif
17488  parser->enc = rb_utf8_encoding();
17489 }
17490 
17491 #ifdef RIPPER
17492 #define parser_mark ripper_parser_mark
17493 #define parser_free ripper_parser_free
17494 #endif
17495 
17496 static void
17497 parser_mark(void *ptr)
17498 {
17499  struct parser_params *p = (struct parser_params*)ptr;
17500 
17501  rb_gc_mark((VALUE)p->parser_lex_strterm);
17502  rb_gc_mark((VALUE)p->parser_deferred_nodes);
17503  rb_gc_mark(p->parser_lex_input);
17504  rb_gc_mark(p->parser_lex_lastline);
17505  rb_gc_mark(p->parser_lex_nextline);
17506  rb_gc_mark(p->parser_ruby_sourcefile_string);
17507 #ifndef RIPPER
17508  rb_gc_mark((VALUE)p->parser_eval_tree_begin) ;
17509  rb_gc_mark((VALUE)p->parser_eval_tree) ;
17510  rb_gc_mark(p->debug_lines);
17511 #else
17512  rb_gc_mark(p->delayed);
17513  rb_gc_mark(p->value);
17514  rb_gc_mark(p->result);
17515  rb_gc_mark(p->parsing_thread);
17516 #endif
17517 #ifdef YYMALLOC
17518  rb_gc_mark((VALUE)p->heap);
17519 #endif
17520 }
17521 
17522 static void
17523 parser_free(void *ptr)
17524 {
17525  struct parser_params *p = (struct parser_params*)ptr;
17526  struct local_vars *local, *prev;
17527 
17528  if (p->parser_tokenbuf) {
17529  xfree(p->parser_tokenbuf);
17530  }
17531  for (local = p->parser_lvtbl; local; local = prev) {
17532  if (local->vars) xfree(local->vars);
17533  prev = local->prev;
17534  xfree(local);
17535  }
17536  xfree(p);
17537 }
17538 
17539 static size_t
17540 parser_memsize(const void *ptr)
17541 {
17542  struct parser_params *p = (struct parser_params*)ptr;
17543  struct local_vars *local;
17544  size_t size = sizeof(*p);
17545 
17546  if (!ptr) return 0;
17547  size += p->parser_toksiz;
17548  for (local = p->parser_lvtbl; local; local = local->prev) {
17549  size += sizeof(*local);
17550  if (local->vars) size += local->vars->capa * sizeof(ID);
17551  }
17552  return size;
17553 }
17554 
17555 static
17556 #ifndef RIPPER
17557 const
17558 #endif
17559 rb_data_type_t parser_data_type = {
17560  "parser",
17561  {
17562  parser_mark,
17563  parser_free,
17564  parser_memsize,
17565  },
17566  NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
17567 };
17568 
17569 #ifndef RIPPER
17570 #undef rb_reserved_word
17571 
17572 const struct kwtable *
17573 rb_reserved_word(const char *str, unsigned int len)
17574 {
17575  return reserved_word(str, len);
17576 }
17577 
17578 static struct parser_params *
17579 parser_new(void)
17580 {
17581  struct parser_params *p;
17582 
17583  p = ALLOC_N(struct parser_params, 1);
17584  MEMZERO(p, struct parser_params, 1);
17585  parser_initialize(p);
17586  return p;
17587 }
17588 
17589 VALUE
17590 rb_parser_new(void)
17591 {
17592  struct parser_params *p = parser_new();
17593 
17594  return TypedData_Wrap_Struct(0, &parser_data_type, p);
17595 }
17596 
17597 /*
17598  * call-seq:
17599  * ripper#end_seen? -> Boolean
17600  *
17601  * Return true if parsed source ended by +\_\_END\_\_+.
17602  */
17603 VALUE
17604 rb_parser_end_seen_p(VALUE vparser)
17605 {
17606  struct parser_params *parser;
17607 
17608  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17609  return ruby__end__seen ? Qtrue : Qfalse;
17610 }
17611 
17612 /*
17613  * call-seq:
17614  * ripper#encoding -> encoding
17615  *
17616  * Return encoding of the source.
17617  */
17618 VALUE
17619 rb_parser_encoding(VALUE vparser)
17620 {
17621  struct parser_params *parser;
17622 
17623  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17624  return rb_enc_from_encoding(current_enc);
17625 }
17626 
17627 /*
17628  * call-seq:
17629  * ripper.yydebug -> true or false
17630  *
17631  * Get yydebug.
17632  */
17633 VALUE
17634 rb_parser_get_yydebug(VALUE self)
17635 {
17636  struct parser_params *parser;
17637 
17638  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17639  return yydebug ? Qtrue : Qfalse;
17640 }
17641 
17642 /*
17643  * call-seq:
17644  * ripper.yydebug = flag
17645  *
17646  * Set yydebug.
17647  */
17648 VALUE
17649 rb_parser_set_yydebug(VALUE self, VALUE flag)
17650 {
17651  struct parser_params *parser;
17652 
17653  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17654  yydebug = RTEST(flag);
17655  return flag;
17656 }
17657 
17658 #ifdef YYMALLOC
17659 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17660 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
17661 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
17662  (n)->u3.cnt = (c), (p))
17663 
17664 void *
17665 rb_parser_malloc(struct parser_params *parser, size_t size)
17666 {
17667  size_t cnt = HEAPCNT(1, size);
17668  NODE *n = NEWHEAP();
17669  void *ptr = xmalloc(size);
17670 
17671  return ADD2HEAP(n, cnt, ptr);
17672 }
17673 
17674 void *
17675 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17676 {
17677  size_t cnt = HEAPCNT(nelem, size);
17678  NODE *n = NEWHEAP();
17679  void *ptr = xcalloc(nelem, size);
17680 
17681  return ADD2HEAP(n, cnt, ptr);
17682 }
17683 
17684 void *
17685 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17686 {
17687  NODE *n;
17688  size_t cnt = HEAPCNT(1, size);
17689 
17690  if (ptr && (n = parser->heap) != NULL) {
17691  do {
17692  if (n->u1.node == ptr) {
17693  n->u1.node = ptr = xrealloc(ptr, size);
17694  if (n->u3.cnt) n->u3.cnt = cnt;
17695  return ptr;
17696  }
17697  } while ((n = n->u2.node) != NULL);
17698  }
17699  n = NEWHEAP();
17700  ptr = xrealloc(ptr, size);
17701  return ADD2HEAP(n, cnt, ptr);
17702 }
17703 
17704 void
17705 rb_parser_free(struct parser_params *parser, void *ptr)
17706 {
17707  NODE **prev = &parser->heap, *n;
17708 
17709  while ((n = *prev) != NULL) {
17710  if (n->u1.node == ptr) {
17711  *prev = n->u2.node;
17712  rb_gc_force_recycle((VALUE)n);
17713  break;
17714  }
17715  prev = &n->u2.node;
17716  }
17717  xfree(ptr);
17718 }
17719 #endif
17720 #endif
17721 
17722 #ifdef RIPPER
17723 #ifdef RIPPER_DEBUG
17724 extern int rb_is_pointer_to_heap(VALUE);
17725 
17726 /* :nodoc: */
17727 static VALUE
17728 ripper_validate_object(VALUE self, VALUE x)
17729 {
17730  if (x == Qfalse) return x;
17731  if (x == Qtrue) return x;
17732  if (x == Qnil) return x;
17733  if (x == Qundef)
17734  rb_raise(rb_eArgError, "Qundef given");
17735  if (FIXNUM_P(x)) return x;
17736  if (SYMBOL_P(x)) return x;
17737  if (!rb_is_pointer_to_heap(x))
17738  rb_raise(rb_eArgError, "invalid pointer: %p", x);
17739  switch (BUILTIN_TYPE(x)) {
17740  case T_STRING:
17741  case T_OBJECT:
17742  case T_ARRAY:
17743  case T_BIGNUM:
17744  case T_FLOAT:
17745  case T_COMPLEX:
17746  case T_RATIONAL:
17747  return x;
17748  case T_NODE:
17749  if (nd_type(x) != NODE_LASGN) {
17750  rb_raise(rb_eArgError, "NODE given: %p", x);
17751  }
17752  return ((NODE *)x)->nd_rval;
17753  default:
17754  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17755  x, rb_obj_classname(x));
17756  }
17757  return x;
17758 }
17759 #endif
17760 
17761 #define validate(x) ((x) = get_value(x))
17762 
17763 static VALUE
17764 ripper_dispatch0(struct parser_params *parser, ID mid)
17765 {
17766  return rb_funcall(parser->value, mid, 0);
17767 }
17768 
17769 static VALUE
17770 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17771 {
17772  validate(a);
17773  return rb_funcall(parser->value, mid, 1, a);
17774 }
17775 
17776 static VALUE
17777 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17778 {
17779  validate(a);
17780  validate(b);
17781  return rb_funcall(parser->value, mid, 2, a, b);
17782 }
17783 
17784 static VALUE
17785 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17786 {
17787  validate(a);
17788  validate(b);
17789  validate(c);
17790  return rb_funcall(parser->value, mid, 3, a, b, c);
17791 }
17792 
17793 static VALUE
17794 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17795 {
17796  validate(a);
17797  validate(b);
17798  validate(c);
17799  validate(d);
17800  return rb_funcall(parser->value, mid, 4, a, b, c, d);
17801 }
17802 
17803 static VALUE
17804 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17805 {
17806  validate(a);
17807  validate(b);
17808  validate(c);
17809  validate(d);
17810  validate(e);
17811  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17812 }
17813 
17814 static VALUE
17815 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17816 {
17817  validate(a);
17818  validate(b);
17819  validate(c);
17820  validate(d);
17821  validate(e);
17822  validate(f);
17823  validate(g);
17824  return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17825 }
17826 
17827 static const struct kw_assoc {
17828  ID id;
17829  const char *name;
17830 } keyword_to_name[] = {
17831  {keyword_class, "class"},
17832  {keyword_module, "module"},
17833  {keyword_def, "def"},
17834  {keyword_undef, "undef"},
17835  {keyword_begin, "begin"},
17836  {keyword_rescue, "rescue"},
17837  {keyword_ensure, "ensure"},
17838  {keyword_end, "end"},
17839  {keyword_if, "if"},
17840  {keyword_unless, "unless"},
17841  {keyword_then, "then"},
17842  {keyword_elsif, "elsif"},
17843  {keyword_else, "else"},
17844  {keyword_case, "case"},
17845  {keyword_when, "when"},
17846  {keyword_while, "while"},
17847  {keyword_until, "until"},
17848  {keyword_for, "for"},
17849  {keyword_break, "break"},
17850  {keyword_next, "next"},
17851  {keyword_redo, "redo"},
17852  {keyword_retry, "retry"},
17853  {keyword_in, "in"},
17854  {keyword_do, "do"},
17855  {keyword_do_cond, "do"},
17856  {keyword_do_block, "do"},
17857  {keyword_return, "return"},
17858  {keyword_yield, "yield"},
17859  {keyword_super, "super"},
17860  {keyword_self, "self"},
17861  {keyword_nil, "nil"},
17862  {keyword_true, "true"},
17863  {keyword_false, "false"},
17864  {keyword_and, "and"},
17865  {keyword_or, "or"},
17866  {keyword_not, "not"},
17867  {modifier_if, "if"},
17868  {modifier_unless, "unless"},
17869  {modifier_while, "while"},
17870  {modifier_until, "until"},
17871  {modifier_rescue, "rescue"},
17872  {keyword_alias, "alias"},
17873  {keyword_defined, "defined?"},
17874  {keyword_BEGIN, "BEGIN"},
17875  {keyword_END, "END"},
17876  {keyword__LINE__, "__LINE__"},
17877  {keyword__FILE__, "__FILE__"},
17878  {keyword__ENCODING__, "__ENCODING__"},
17879  {0, NULL}
17880 };
17881 
17882 static const char*
17883 keyword_id_to_str(ID id)
17884 {
17885  const struct kw_assoc *a;
17886 
17887  for (a = keyword_to_name; a->id; a++) {
17888  if (a->id == id)
17889  return a->name;
17890  }
17891  return NULL;
17892 }
17893 
17894 #undef ripper_id2sym
17895 static VALUE
17896 ripper_id2sym(ID id)
17897 {
17898  const char *name;
17899  char buf[8];
17900 
17901  if (id <= 256) {
17902  buf[0] = (char)id;
17903  buf[1] = '\0';
17904  return ID2SYM(rb_intern2(buf, 1));
17905  }
17906  if ((name = keyword_id_to_str(id))) {
17907  return ID2SYM(rb_intern(name));
17908  }
17909  switch (id) {
17910  case tOROP:
17911  name = "||";
17912  break;
17913  case tANDOP:
17914  name = "&&";
17915  break;
17916  default:
17917  name = rb_id2name(id);
17918  if (!name) {
17919  rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
17920  }
17921  return ID2SYM(id);
17922  }
17923  return ID2SYM(rb_intern(name));
17924 }
17925 
17926 static ID
17927 ripper_get_id(VALUE v)
17928 {
17929  NODE *nd;
17930  if (!RB_TYPE_P(v, T_NODE)) return 0;
17931  nd = (NODE *)v;
17932  if (nd_type(nd) != NODE_LASGN) return 0;
17933  return nd->nd_vid;
17934 }
17935 
17936 static VALUE
17937 ripper_get_value(VALUE v)
17938 {
17939  NODE *nd;
17940  if (v == Qundef) return Qnil;
17941  if (!RB_TYPE_P(v, T_NODE)) return v;
17942  nd = (NODE *)v;
17943  if (nd_type(nd) != NODE_LASGN) return Qnil;
17944  return nd->nd_rval;
17945 }
17946 
17947 static void
17948 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17949 {
17950  VALUE str;
17951  va_list args;
17952 
17953  va_start(args, fmt);
17954  str = rb_vsprintf(fmt, args);
17955  va_end(args);
17956  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17957 }
17958 
17959 static void
17960 ripper_warn0(struct parser_params *parser, const char *fmt)
17961 {
17962  rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
17963 }
17964 
17965 static void
17966 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
17967 {
17968  rb_funcall(parser->value, rb_intern("warn"), 2,
17969  STR_NEW2(fmt), INT2NUM(a));
17970 }
17971 
17972 static void
17973 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
17974 {
17975  rb_funcall(parser->value, rb_intern("warn"), 2,
17976  STR_NEW2(fmt), STR_NEW2(str));
17977 }
17978 
17979 static void
17980 ripper_warning0(struct parser_params *parser, const char *fmt)
17981 {
17982  rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
17983 }
17984 
17985 static void
17986 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
17987 {
17988  rb_funcall(parser->value, rb_intern("warning"), 2,
17989  STR_NEW2(fmt), STR_NEW2(str));
17990 }
17991 
17992 static VALUE
17993 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
17994 {
17995  return rb_io_gets(src);
17996 }
17997 
17998 static VALUE
17999 ripper_s_allocate(VALUE klass)
18000 {
18001  struct parser_params *p;
18002  VALUE self;
18003 
18004  p = ALLOC_N(struct parser_params, 1);
18005  MEMZERO(p, struct parser_params, 1);
18006  self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
18007  p->value = self;
18008  return self;
18009 }
18010 
18011 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
18012 
18013 /*
18014  * call-seq:
18015  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
18016  *
18017  * Create a new Ripper object.
18018  * _src_ must be a String, an IO, or an Object which has #gets method.
18019  *
18020  * This method does not starts parsing.
18021  * See also Ripper#parse and Ripper.parse.
18022  */
18023 static VALUE
18024 ripper_initialize(int argc, VALUE *argv, VALUE self)
18025 {
18026  struct parser_params *parser;
18027  VALUE src, fname, lineno;
18028 
18029  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18030  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
18031  if (RB_TYPE_P(src, T_FILE)) {
18032  parser->parser_lex_gets = ripper_lex_get_generic;
18033  }
18034  else {
18035  StringValue(src);
18036  parser->parser_lex_gets = lex_get_str;
18037  }
18038  parser->parser_lex_input = src;
18039  parser->eofp = Qfalse;
18040  if (NIL_P(fname)) {
18041  fname = STR_NEW2("(ripper)");
18042  }
18043  else {
18044  StringValue(fname);
18045  }
18046  parser_initialize(parser);
18047 
18048  parser->parser_ruby_sourcefile_string = fname;
18049  parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
18050  parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
18051 
18052  return Qnil;
18053 }
18054 
18055 struct ripper_args {
18056  struct parser_params *parser;
18057  int argc;
18058  VALUE *argv;
18059 };
18060 
18061 static VALUE
18062 ripper_parse0(VALUE parser_v)
18063 {
18064  struct parser_params *parser;
18065 
18066  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
18067  parser_prepare(parser);
18068  ripper_yyparse((void*)parser);
18069  return parser->result;
18070 }
18071 
18072 static VALUE
18073 ripper_ensure(VALUE parser_v)
18074 {
18075  struct parser_params *parser;
18076 
18077  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
18078  parser->parsing_thread = Qnil;
18079  return Qnil;
18080 }
18081 
18082 /*
18083  * call-seq:
18084  * ripper#parse
18085  *
18086  * Start parsing and returns the value of the root action.
18087  */
18088 static VALUE
18089 ripper_parse(VALUE self)
18090 {
18091  struct parser_params *parser;
18092 
18093  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18094  if (!ripper_initialized_p(parser)) {
18095  rb_raise(rb_eArgError, "method called for uninitialized object");
18096  }
18097  if (!NIL_P(parser->parsing_thread)) {
18098  if (parser->parsing_thread == rb_thread_current())
18099  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
18100  else
18101  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
18102  }
18103  parser->parsing_thread = rb_thread_current();
18104  rb_ensure(ripper_parse0, self, ripper_ensure, self);
18105 
18106  return parser->result;
18107 }
18108 
18109 /*
18110  * call-seq:
18111  * ripper#column -> Integer
18112  *
18113  * Return column number of current parsing line.
18114  * This number starts from 0.
18115  */
18116 static VALUE
18117 ripper_column(VALUE self)
18118 {
18119  struct parser_params *parser;
18120  long col;
18121 
18122  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18123  if (!ripper_initialized_p(parser)) {
18124  rb_raise(rb_eArgError, "method called for uninitialized object");
18125  }
18126  if (NIL_P(parser->parsing_thread)) return Qnil;
18127  col = parser->tokp - parser->parser_lex_pbeg;
18128  return LONG2NUM(col);
18129 }
18130 
18131 /*
18132  * call-seq:
18133  * ripper#filename -> String
18134  *
18135  * Return current parsing filename.
18136  */
18137 static VALUE
18138 ripper_filename(VALUE self)
18139 {
18140  struct parser_params *parser;
18141 
18142  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18143  if (!ripper_initialized_p(parser)) {
18144  rb_raise(rb_eArgError, "method called for uninitialized object");
18145  }
18146  return parser->parser_ruby_sourcefile_string;
18147 }
18148 
18149 /*
18150  * call-seq:
18151  * ripper#lineno -> Integer
18152  *
18153  * Return line number of current parsing line.
18154  * This number starts from 1.
18155  */
18156 static VALUE
18157 ripper_lineno(VALUE self)
18158 {
18159  struct parser_params *parser;
18160 
18161  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
18162  if (!ripper_initialized_p(parser)) {
18163  rb_raise(rb_eArgError, "method called for uninitialized object");
18164  }
18165  if (NIL_P(parser->parsing_thread)) return Qnil;
18166  return INT2NUM(parser->parser_ruby_sourceline);
18167 }
18168 
18169 #ifdef RIPPER_DEBUG
18170 /* :nodoc: */
18171 static VALUE
18172 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
18173 {
18174  StringValue(msg);
18175  if (obj == Qundef) {
18176  rb_raise(rb_eArgError, "%"PRIsVALUE, msg);
18177  }
18178  return Qnil;
18179 }
18180 
18181 /* :nodoc: */
18182 static VALUE
18183 ripper_value(VALUE self, VALUE obj)
18184 {
18185  return ULONG2NUM(obj);
18186 }
18187 #endif
18188 
18189 
18190 void
18191 Init_ripper(void)
18192 {
18193  parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
18194 
18195  ripper_init_eventids1();
18196  ripper_init_eventids2();
18197  /* ensure existing in symbol table */
18198  (void)rb_intern("||");
18199  (void)rb_intern("&&");
18200 
18201  InitVM(ripper);
18202 }
18203 
18204 void
18205 InitVM_ripper(void)
18206 {
18207  VALUE Ripper;
18208 
18209  Ripper = rb_define_class("Ripper", rb_cObject);
18210  /* version of Ripper */
18211  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
18212  rb_define_alloc_func(Ripper, ripper_s_allocate);
18213  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
18214  rb_define_method(Ripper, "parse", ripper_parse, 0);
18215  rb_define_method(Ripper, "column", ripper_column, 0);
18216  rb_define_method(Ripper, "filename", ripper_filename, 0);
18217  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
18218  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
18219  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
18220  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
18221  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
18222 #ifdef RIPPER_DEBUG
18223  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
18224  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
18225  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
18226 #endif
18227 
18228  ripper_init_eventids1_table(Ripper);
18229  ripper_init_eventids2_table(Ripper);
18230 
18231 # if 0
18232  /* Hack to let RDoc document SCRIPT_LINES__ */
18233 
18234  /*
18235  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
18236  * after the assignment will be added as an Array of lines with the file
18237  * name as the key.
18238  */
18239  rb_define_global_const("SCRIPT_LINES__", Qnil);
18240 #endif
18241 
18242 }
18243 #endif /* RIPPER */
18244 
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:13525
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:17295
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:15714
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:17579
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:16069
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:16792
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:13521
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:15990
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:16724
NEW_LIST
#define NEW_LIST(a)
Definition: node.h:391
rb_is_class_name
int rb_is_class_name(VALUE name)
Definition: ripper.c:17395
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:13266
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:17540
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:16838
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:17160
call_uni_op_gen
static NODE * call_uni_op_gen(struct parser_params *, NODE *, ID)
Definition: ripper.c:15139
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:14889
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:15734
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:15131
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:16204
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:15180
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:13523
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:16502
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:17604
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:13278
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:15108
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:16511
warn_unused_var
static void warn_unused_var(struct parser_params *parser, struct local_vars *local)
Definition: ripper.c:16239
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:17573
is_identchar
#define is_identchar(p, e, enc)
Definition: ripper.c:11741
symbols::op_sym
VALUE op_sym[tLAST_OP_ID]
Definition: ripper.c:16723
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:13535
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:15146
rb_raise
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1857
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:15523
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:14912
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:14879
reg_named_capture_assign_t::succ_block
NODE * succ_block
Definition: ripper.c:16505
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:15889
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:15724
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:16716
Qnone
#define Qnone
Definition: ripper.c:694
lvar_defined_gen
static int lvar_defined_gen(struct parser_params *, ID)
Definition: ripper.c:13207
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:13279
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:17443
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:14859
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:17324
rb_check_id_cstr
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
Definition: ripper.c:17366
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:13214
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:14867
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:17262
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:16013
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:16938
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:17649
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:14832
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:16718
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:15403
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:17660
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:15819
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:14966
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:17271
rb_is_instance_id
int rb_is_instance_id(ID id)
Definition: ripper.c:17289
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:17425
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:15472
parser_params::enc
rb_encoding * enc
Definition: ripper.c:331
parser_warning
#define parser_warning(node, mesg)
Definition: ripper.c:14902
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:16709
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:13541
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:16405
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:13193
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:17523
IS_ARG
#define IS_ARG()
Definition: ripper.c:13520
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:17239
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:16442
rb_parser_encoding
VALUE rb_parser_encoding(VALUE vparser)
Definition: ripper.c:17619
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:16503
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:14986
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:16839
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:15497
local_push_gen
static void local_push_gen(struct parser_params *, int)
Definition: ripper.c:16259
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:17144
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:13291
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:17497
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:496
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:13312
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:16612
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:16030
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:13196
void_expr_gen
static void void_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15611
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:16132
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:16685
intern_str
static ID intern_str(VALUE str)
Definition: ripper.c:17024
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:16644
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:13282
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:17665
setup_fake_str
static VALUE setup_fake_str(struct RString *fake_str, const char *name, long len)
Definition: ripper.c:16997
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:16961
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:15395
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:15374
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:16827
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:15349
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:16391
new_evstr_gen
static NODE * new_evstr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15117
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:16450
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:13453
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:17413
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:16833
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:13318
Init_sym
void Init_sym(void)
Definition: ripper.c:16760
name
const char * name
Definition: ripper.c:16686
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:16102
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:16411
rb_is_local_id
int rb_is_local_id(ID id)
Definition: ripper.c:17301
magic_comment::length
rb_magic_comment_length_t length
Definition: ripper.c:13315
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:16334
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:15459
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:16779
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:13185
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:13496
cond_gen
static NODE * cond_gen(struct parser_params *, NODE *)
Definition: ripper.c:15983
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:16842
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:16506
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:17307
dyna_pop_1
static void dyna_pop_1(struct parser_params *parser)
Definition: ripper.c:16373
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:15422
value_expr_gen
static int value_expr_gen(struct parser_params *, NODE *)
Definition: ripper.c:15554
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:16944
yytokentype
yytokentype
Definition: parse.c:780
rb_is_global_id
int rb_is_global_id(ID id)
Definition: ripper.c:17283
reg_fragment_check_gen
static int reg_fragment_check_gen(struct parser_params *, VALUE, int)
Definition: ripper.c:16489
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:16188
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:15795
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:16317
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:15010
local_tbl_gen
static ID * local_tbl_gen(struct parser_params *)
Definition: ripper.c:16292
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:16504
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:16507
parser_yyerror
static int parser_yyerror(struct parser_params *, const char *)
Definition: ripper.c:11821
HEAPCNT
#define HEAPCNT(n, size)
Definition: ripper.c:17659
warning_unless_e_option
static void warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
Definition: ripper.c:15852
RSTRING_PTR
#define RSTRING_PTR(str)
Definition: ruby.h:845
rb_is_const_name
int rb_is_const_name(VALUE name)
Definition: ripper.c:17389
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:15451
rb_is_local_name
int rb_is_local_name(VALUE name)
Definition: ripper.c:17419
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:16583
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:16607
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:17661
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:15336
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:1001
no_blockarg
static void no_blockarg(struct parser_params *parser, NODE *node)
Definition: ripper.c:16005
local_pop_gen
static void local_pop_gen(struct parser_params *)
Definition: ripper.c:16276
tEQQ
Definition: parse.c:852
rb_parser_free
void rb_parser_free(struct parser_params *parser, void *ptr)
Definition: ripper.c:17705
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:15027
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:14909
rb_intern_str
ID rb_intern_str(VALUE str)
Definition: ripper.c:17150
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:13313
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:16727
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:15700
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:16324
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:13314
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:16717
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:16159
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:17675
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:15381
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:16038
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:15858
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:13326
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:13359
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:13524
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:15410
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:17277
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:17590
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:13234
call_uni_op
#define call_uni_op(recv, id)
Definition: ripper.c:470
literal_node
static int literal_node(NODE *node)
Definition: ripper.c:15905
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:13522
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:17407
parser_params::parser_ruby_sourceline
int parser_ruby_sourceline
Definition: ripper.c:329
rb_id2name
const char * rb_id2name(ID id)
Definition: ripper.c:17230
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:14873
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:470
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:15926
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:17435
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:15515
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:17008
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:16954
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:16362
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:17685
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:17137
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:16801
is_class_id
#define is_class_id(id)
Definition: ripper.c:114
LVAR_USED
#define LVAR_USED
Definition: ripper.c:15346
assignable_gen
static NODE * assignable_gen(struct parser_params *, ID, NODE *)
Definition: ripper.c:15257
rb_parser_get_yydebug
VALUE rb_parser_get_yydebug(VALUE self)
Definition: ripper.c:17634
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:15846
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:16977
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:16551
IS_AFTER_OPERATOR
#define IS_AFTER_OPERATOR()
Definition: ripper.c:13526
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:16080
tNEQ
Definition: parse.c:853
rb_is_global_name
int rb_is_global_name(VALUE name)
Definition: ripper.c:17401
parser_tokadd_mbchar
static int parser_tokadd_mbchar(struct parser_params *parser, int c)
Definition: ripper.c:12603
Generated on Mon Oct 27 2014 12:16:34 for Ruby by   doxygen 1.8.8