Ruby  2.7.2p137(2020-10-01revision5445e0435260b449decf2ac16f9d09bae3cafe72)
ripper.c
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 3.0.4. */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989-1990, 2000-2015 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 "3.0.4"
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 
62 
63 
64 /* Copy the first part of user declarations. */
65 #line 12 "ripper.y" /* yacc.c:339 */
66 
67 
68 #if !YYPURE
69 # error needs pure parser
70 #endif
71 #define YYDEBUG 1
72 #define YYERROR_VERBOSE 1
73 #define YYSTACK_USE_ALLOCA 0
74 #define YYLTYPE rb_code_location_t
75 #define YYLTYPE_IS_DECLARED 1
76 
77 #include "ruby/ruby.h"
78 #include "ruby/st.h"
79 #include "ruby/encoding.h"
80 #include "internal.h"
81 #include "node.h"
82 #include "parse.h"
83 #include "symbol.h"
84 #include "regenc.h"
85 #include <stdio.h>
86 #include <errno.h>
87 #include <ctype.h>
88 #include "probes.h"
89 
90 #ifndef WARN_PAST_SCOPE
91 # define WARN_PAST_SCOPE 0
92 #endif
93 
94 #define TAB_WIDTH 8
95 
96 #define yydebug (p->debug) /* disable the global variable definition */
97 
98 #define YYMALLOC(size) rb_parser_malloc(p, (size))
99 #define YYREALLOC(ptr, size) rb_parser_realloc(p, (ptr), (size))
100 #define YYCALLOC(nelem, size) rb_parser_calloc(p, (nelem), (size))
101 #define YYFREE(ptr) rb_parser_free(p, (ptr))
102 #define YYFPRINTF rb_parser_printf
103 #define YYPRINT(out, tok, val) parser_token_value_print(p, (tok), &(val))
104 #define YY_LOCATION_PRINT(File, loc) \
105  rb_parser_printf(p, "%d.%d-%d.%d", \
106  (loc).beg_pos.lineno, (loc).beg_pos.column,\
107  (loc).end_pos.lineno, (loc).end_pos.column)
108 #define YYLLOC_DEFAULT(Current, Rhs, N) \
109  do \
110  if (N) \
111  { \
112  (Current).beg_pos = YYRHSLOC(Rhs, 1).beg_pos; \
113  (Current).end_pos = YYRHSLOC(Rhs, N).end_pos; \
114  } \
115  else \
116  { \
117  (Current).beg_pos = YYRHSLOC(Rhs, 0).end_pos; \
118  (Current).end_pos = YYRHSLOC(Rhs, 0).end_pos; \
119  } \
120  while (0)
121 
122 #define RUBY_SET_YYLLOC_FROM_STRTERM_HEREDOC(Current) \
123  rb_parser_set_location_from_strterm_heredoc(p, &p->lex.strterm->u.heredoc, &(Current))
124 #define RUBY_SET_YYLLOC_OF_NONE(Current) \
125  rb_parser_set_location_of_none(p, &(Current))
126 #define RUBY_SET_YYLLOC(Current) \
127  rb_parser_set_location(p, &(Current))
128 #define RUBY_INIT_YYLLOC() \
129  { \
130  {p->ruby_sourceline, (int)(p->lex.ptok - p->lex.pbeg)}, \
131  {p->ruby_sourceline, (int)(p->lex.pcur - p->lex.pbeg)}, \
132  }
133 
135  EXPR_BEG_bit, /* ignore newline, +/- is a sign. */
136  EXPR_END_bit, /* newline significant, +/- is an operator. */
137  EXPR_ENDARG_bit, /* ditto, and unbound braces. */
138  EXPR_ENDFN_bit, /* ditto, and unbound braces. */
139  EXPR_ARG_bit, /* newline significant, +/- is an operator. */
140  EXPR_CMDARG_bit, /* newline significant, +/- is an operator. */
141  EXPR_MID_bit, /* newline significant, +/- is an operator. */
142  EXPR_FNAME_bit, /* ignore newline, no reserved words. */
143  EXPR_DOT_bit, /* right after `.' or `::', no reserved words. */
144  EXPR_CLASS_bit, /* immediate after `class', no here document. */
145  EXPR_LABEL_bit, /* flag bit, label is allowed. */
146  EXPR_LABELED_bit, /* flag bit, just after a label. */
147  EXPR_FITEM_bit, /* symbol literal as FNAME. */
149 };
150 /* examine combinations */
152 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
154  DEF_EXPR(END),
155  DEF_EXPR(ENDARG),
156  DEF_EXPR(ENDFN),
157  DEF_EXPR(ARG),
158  DEF_EXPR(CMDARG),
159  DEF_EXPR(MID),
160  DEF_EXPR(FNAME),
161  DEF_EXPR(DOT),
162  DEF_EXPR(CLASS),
163  DEF_EXPR(LABEL),
164  DEF_EXPR(LABELED),
165  DEF_EXPR(FITEM),
166  EXPR_VALUE = EXPR_BEG,
167  EXPR_BEG_ANY = (EXPR_BEG | EXPR_MID | EXPR_CLASS),
168  EXPR_ARG_ANY = (EXPR_ARG | EXPR_CMDARG),
169  EXPR_END_ANY = (EXPR_END | EXPR_ENDARG | EXPR_ENDFN),
170  EXPR_NONE = 0
171 };
172 #define IS_lex_state_for(x, ls) ((x) & (ls))
173 #define IS_lex_state_all_for(x, ls) (((x) & (ls)) == (ls))
174 #define IS_lex_state(ls) IS_lex_state_for(p->lex.state, (ls))
175 #define IS_lex_state_all(ls) IS_lex_state_all_for(p->lex.state, (ls))
176 
177 # define SET_LEX_STATE(ls) \
178  (p->lex.state = \
179  (p->debug ? \
180  rb_parser_trace_lex_state(p, p->lex.state, (ls), __LINE__) : \
181  (enum lex_state_e)(ls)))
182 
184 
185 static const rb_code_location_t NULL_LOC = { {0, -1}, {0, -1} };
186 
187 # define SHOW_BITSTACK(stack, name) (p->debug ? rb_parser_show_bitstack(p, stack, name, __LINE__) : (void)0)
188 # define BITSTACK_PUSH(stack, n) (((p->stack) = ((p->stack)<<1)|((n)&1)), SHOW_BITSTACK(p->stack, #stack"(push)"))
189 # define BITSTACK_POP(stack) (((p->stack) = (p->stack) >> 1), SHOW_BITSTACK(p->stack, #stack"(pop)"))
190 # define BITSTACK_SET_P(stack) (SHOW_BITSTACK(p->stack, #stack), (p->stack)&1)
191 # define BITSTACK_SET(stack, n) ((p->stack)=(n), SHOW_BITSTACK(p->stack, #stack"(set)"))
192 
193 /* A flag to identify keyword_do_cond, "do" keyword after condition expression.
194  Examples: `while ... do`, `until ... do`, and `for ... in ... do` */
195 #define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n))
196 #define COND_POP() BITSTACK_POP(cond_stack)
197 #define COND_P() BITSTACK_SET_P(cond_stack)
198 #define COND_SET(n) BITSTACK_SET(cond_stack, (n))
199 
200 /* A flag to identify keyword_do_block; "do" keyword after command_call.
201  Example: `foo 1, 2 do`. */
202 #define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n))
203 #define CMDARG_POP() BITSTACK_POP(cmdarg_stack)
204 #define CMDARG_P() BITSTACK_SET_P(cmdarg_stack)
205 #define CMDARG_SET(n) BITSTACK_SET(cmdarg_stack, (n))
206 
207 struct vtable {
208  ID *tbl;
209  int pos;
210  int capa;
211  struct vtable *prev;
212 };
213 
214 struct local_vars {
215  struct vtable *args;
216  struct vtable *vars;
217  struct vtable *used;
218 # if WARN_PAST_SCOPE
219  struct vtable *past;
220 # endif
221  struct local_vars *prev;
222 # ifndef RIPPER
223  struct {
226 # endif
227 };
228 
229 enum {
231  NO_PARAM = 0,
233 };
234 
235 #define NUMPARAM_ID_P(id) numparam_id_p(id)
236 #define NUMPARAM_ID_TO_IDX(id) (unsigned int)(((id) >> ID_SCOPE_SHIFT) - tNUMPARAM_1 + 1)
237 #define NUMPARAM_IDX_TO_ID(idx) TOKEN2LOCALID((tNUMPARAM_1 + (idx) - 1))
238 static int
239 numparam_id_p(ID id)
240 {
241  if (!is_local_id(id)) return 0;
242  unsigned int idx = NUMPARAM_ID_TO_IDX(id);
243  return idx > 0 && idx <= NUMPARAM_MAX;
244 }
245 static void numparam_name(struct parser_params *p, ID id);
246 
247 #define DVARS_INHERIT ((void*)1)
248 #define DVARS_TOPSCOPE NULL
249 #define DVARS_TERMINAL_P(tbl) ((tbl) == DVARS_INHERIT || (tbl) == DVARS_TOPSCOPE)
250 
251 typedef struct token_info {
252  const char *token;
254  int indent;
255  int nonspc;
256  struct token_info *next;
258 
259 typedef struct rb_strterm_struct rb_strterm_t;
260 
261 /*
262  Structure of Lexer Buffer:
263 
264  lex.pbeg lex.ptok lex.pcur lex.pend
265  | | | |
266  |------------+------------+------------|
267  |<---------->|
268  token
269 */
272 
274 
275  struct {
282  const char *pbeg;
283  const char *pcur;
284  const char *pend;
285  const char *ptok;
286  union {
287  long ptr;
289  } gets_;
290  enum lex_state_e state;
291  /* track the nest level of any parens "()[]{}" */
293  /* keep p->lex.paren_nest at the beginning of lambda "->" to detect tLAMBEG and keyword_do_LAMBDA */
294  int lpar_beg;
295  /* track the nest level of only braces "{}" */
297  } lex;
300  int tokidx;
301  int toksiz;
302  int tokline;
306  char *tokenbuf;
307  struct local_vars *lvtbl;
311  int ruby_sourceline; /* current line no. */
312  const char *ruby_sourcefile; /* current source file */
318 
321 
323 
325  int node_id;
326 
328 
329  unsigned int command_start:1;
330  unsigned int eofp: 1;
331  unsigned int ruby__end__seen: 1;
332  unsigned int debug: 1;
333  unsigned int has_shebang: 1;
334  unsigned int in_defined: 1;
335  unsigned int in_kwarg: 1;
336  unsigned int in_def: 1;
337  unsigned int in_class: 1;
338  unsigned int token_seen: 1;
339  unsigned int token_info_enabled: 1;
340 # if WARN_PAST_SCOPE
341  unsigned int past_scope_enabled: 1;
342 # endif
343  unsigned int error_p: 1;
344  unsigned int cr_seen: 1;
345 
346 #ifndef RIPPER
347  /* Ruby core only */
348 
349  unsigned int do_print: 1;
350  unsigned int do_loop: 1;
351  unsigned int do_chomp: 1;
352  unsigned int do_split: 1;
353  unsigned int warn_location: 1;
354 
360 #else
361  /* Ripper only */
362 
363  struct {
364  VALUE token;
365  int line;
366  int col;
367  } delayed;
368 
369  VALUE value;
370  VALUE result;
371  VALUE parsing_thread;
372 #endif
373 };
374 
375 #define intern_cstr(n,l,en) rb_intern3(n,l,en)
376 
377 #define STR_NEW(ptr,len) rb_enc_str_new((ptr),(len),p->enc)
378 #define STR_NEW0() rb_enc_str_new(0,0,p->enc)
379 #define STR_NEW2(ptr) rb_enc_str_new((ptr),strlen(ptr),p->enc)
380 #define STR_NEW3(ptr,len,e,func) parser_str_new((ptr),(len),(e),(func),p->enc)
381 #define TOK_INTERN() intern_cstr(tok(p), toklen(p), p->enc)
382 
383 static st_table *
384 push_pvtbl(struct parser_params *p)
385 {
386  st_table *tbl = p->pvtbl;
387  p->pvtbl = st_init_numtable();
388  return tbl;
389 }
390 
391 static void
392 pop_pvtbl(struct parser_params *p, st_table *tbl)
393 {
394  st_free_table(p->pvtbl);
395  p->pvtbl = tbl;
396 }
397 
398 static st_table *
399 push_pktbl(struct parser_params *p)
400 {
401  st_table *tbl = p->pktbl;
402  p->pktbl = 0;
403  return tbl;
404 }
405 
406 static void
407 pop_pktbl(struct parser_params *p, st_table *tbl)
408 {
409  if (p->pktbl) st_free_table(p->pktbl);
410  p->pktbl = tbl;
411 }
412 
413 static int parser_yyerror(struct parser_params*, const YYLTYPE *yylloc, const char*);
414 #define yyerror0(msg) parser_yyerror(p, NULL, (msg))
415 #define yyerror1(loc, msg) parser_yyerror(p, (loc), (msg))
416 #define yyerror(yylloc, p, msg) parser_yyerror(p, yylloc, msg)
417 #define token_flush(ptr) ((ptr)->lex.ptok = (ptr)->lex.pcur)
418 
419 #ifdef RIPPER
420 #define compile_for_eval (0)
421 #else
422 #define compile_for_eval (p->parent_iseq != 0)
423 #endif
424 
425 #define token_column ((int)(p->lex.ptok - p->lex.pbeg))
426 
427 #define CALL_Q_P(q) ((q) == TOKEN2VAL(tANDDOT))
428 #define NODE_CALL_Q(q) (CALL_Q_P(q) ? NODE_QCALL : NODE_CALL)
429 #define NEW_QCALL(q,r,m,a,loc) NEW_NODE(NODE_CALL_Q(q),r,m,a,loc)
430 
431 #define lambda_beginning_p() (p->lex.lpar_beg == p->lex.paren_nest)
432 
433 static enum yytokentype yylex(YYSTYPE*, YYLTYPE*, struct parser_params*);
434 
435 #ifndef RIPPER
436 static inline void
437 rb_discard_node(struct parser_params *p, NODE *n)
438 {
439  rb_ast_delete_node(p->ast, n);
440 }
441 #endif
442 
443 #ifdef RIPPER
444 static inline VALUE
445 add_mark_object(struct parser_params *p, VALUE obj)
446 {
447  if (!SPECIAL_CONST_P(obj)
448  && !RB_TYPE_P(obj, T_NODE) /* Ripper jumbles NODE objects and other objects... */
449  ) {
451  }
452  return obj;
453 }
454 #else
455 static NODE* node_newnode_with_locals(struct parser_params *, enum node_type, VALUE, VALUE, const rb_code_location_t*);
456 #endif
457 
458 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE, const rb_code_location_t*);
459 #define rb_node_newnode(type, a1, a2, a3, loc) node_newnode(p, (type), (a1), (a2), (a3), (loc))
460 
461 static NODE *nd_set_loc(NODE *nd, const YYLTYPE *loc);
462 
463 static int
464 parser_get_node_id(struct parser_params *p)
465 {
466  int node_id = p->node_id;
467  p->node_id++;
468  return node_id;
469 }
470 
471 #ifndef RIPPER
472 static inline void
473 set_line_body(NODE *body, int line)
474 {
475  if (!body) return;
476  switch (nd_type(body)) {
477  case NODE_RESCUE:
478  case NODE_ENSURE:
479  nd_set_line(body, line);
480  }
481 }
482 
483 #define yyparse ruby_yyparse
484 
485 static NODE* cond(struct parser_params *p, NODE *node, const YYLTYPE *loc);
486 static NODE* method_cond(struct parser_params *p, NODE *node, const YYLTYPE *loc);
487 #define new_nil(loc) NEW_NIL(loc)
488 static NODE *new_if(struct parser_params*,NODE*,NODE*,NODE*,const YYLTYPE*);
489 static NODE *new_unless(struct parser_params*,NODE*,NODE*,NODE*,const YYLTYPE*);
490 static NODE *logop(struct parser_params*,ID,NODE*,NODE*,const YYLTYPE*,const YYLTYPE*);
491 
492 static NODE *newline_node(NODE*);
493 static void fixpos(NODE*,NODE*);
494 
495 static int value_expr_gen(struct parser_params*,NODE*);
496 static void void_expr(struct parser_params*,NODE*);
497 static NODE *remove_begin(NODE*);
498 static NODE *remove_begin_all(NODE*);
499 #define value_expr(node) value_expr_gen(p, (node) = remove_begin(node))
500 static NODE *void_stmts(struct parser_params*,NODE*);
501 static void reduce_nodes(struct parser_params*,NODE**);
502 static void block_dup_check(struct parser_params*,NODE*,NODE*);
503 
504 static NODE *block_append(struct parser_params*,NODE*,NODE*);
505 static NODE *list_append(struct parser_params*,NODE*,NODE*);
506 static NODE *list_concat(NODE*,NODE*);
507 static NODE *arg_append(struct parser_params*,NODE*,NODE*,const YYLTYPE*);
508 static NODE *last_arg_append(struct parser_params *p, NODE *args, NODE *last_arg, const YYLTYPE *loc);
509 static NODE *rest_arg_append(struct parser_params *p, NODE *args, NODE *rest_arg, const YYLTYPE *loc);
510 static NODE *literal_concat(struct parser_params*,NODE*,NODE*,const YYLTYPE*);
511 static NODE *new_evstr(struct parser_params*,NODE*,const YYLTYPE*);
512 static NODE *evstr2dstr(struct parser_params*,NODE*);
513 static NODE *splat_array(NODE*);
514 static void mark_lvar_used(struct parser_params *p, NODE *rhs);
515 
516 static NODE *call_bin_op(struct parser_params*,NODE*,ID,NODE*,const YYLTYPE*,const YYLTYPE*);
517 static NODE *call_uni_op(struct parser_params*,NODE*,ID,const YYLTYPE*,const YYLTYPE*);
518 static NODE *new_qcall(struct parser_params* p, ID atype, NODE *recv, ID mid, NODE *args, const YYLTYPE *op_loc, const YYLTYPE *loc);
519 static NODE *new_command_qcall(struct parser_params* p, ID atype, NODE *recv, ID mid, NODE *args, NODE *block, const YYLTYPE *op_loc, const YYLTYPE *loc);
520 static NODE *method_add_block(struct parser_params*p, NODE *m, NODE *b, const YYLTYPE *loc) {b->nd_iter = m; b->nd_loc = *loc; return b;}
521 
522 static bool args_info_empty_p(struct rb_args_info *args);
523 static NODE *new_args(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*,const YYLTYPE*);
524 static NODE *new_args_tail(struct parser_params*,NODE*,ID,ID,const YYLTYPE*);
525 static NODE *new_array_pattern(struct parser_params *p, NODE *constant, NODE *pre_arg, NODE *aryptn, const YYLTYPE *loc);
526 static NODE *new_array_pattern_tail(struct parser_params *p, NODE *pre_args, int has_rest, ID rest_arg, NODE *post_args, const YYLTYPE *loc);
527 static NODE *new_hash_pattern(struct parser_params *p, NODE *constant, NODE *hshptn, const YYLTYPE *loc);
528 static NODE *new_hash_pattern_tail(struct parser_params *p, NODE *kw_args, ID kw_rest_arg, const YYLTYPE *loc);
529 static NODE *new_case3(struct parser_params *p, NODE *val, NODE *pat, const YYLTYPE *loc);
530 
531 static NODE *new_kw_arg(struct parser_params *p, NODE *k, const YYLTYPE *loc);
532 static NODE *args_with_numbered(struct parser_params*,NODE*,int);
533 
534 static VALUE negate_lit(struct parser_params*, VALUE);
535 static NODE *ret_args(struct parser_params*,NODE*);
536 static NODE *arg_blk_pass(NODE*,NODE*);
537 static NODE *new_yield(struct parser_params*,NODE*,const YYLTYPE*);
538 static NODE *dsym_node(struct parser_params*,NODE*,const YYLTYPE*);
539 
540 static NODE *gettable(struct parser_params*,ID,const YYLTYPE*);
541 static NODE *assignable(struct parser_params*,ID,NODE*,const YYLTYPE*);
542 
543 static NODE *aryset(struct parser_params*,NODE*,NODE*,const YYLTYPE*);
544 static NODE *attrset(struct parser_params*,NODE*,ID,ID,const YYLTYPE*);
545 
546 static void rb_backref_error(struct parser_params*,NODE*);
547 static NODE *node_assign(struct parser_params*,NODE*,NODE*,const YYLTYPE*);
548 
549 static NODE *new_op_assign(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *loc);
550 static NODE *new_ary_op_assign(struct parser_params *p, NODE *ary, NODE *args, ID op, NODE *rhs, const YYLTYPE *args_loc, const YYLTYPE *loc);
551 static NODE *new_attr_op_assign(struct parser_params *p, NODE *lhs, ID atype, ID attr, ID op, NODE *rhs, const YYLTYPE *loc);
552 static NODE *new_const_op_assign(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *loc);
553 static NODE *new_bodystmt(struct parser_params *p, NODE *head, NODE *rescue, NODE *rescue_else, NODE *ensure, const YYLTYPE *loc);
554 
555 static NODE *const_decl(struct parser_params *p, NODE* path, const YYLTYPE *loc);
556 
557 static NODE *opt_arg_append(NODE*, NODE*);
558 static NODE *kwd_append(NODE*, NODE*);
559 
560 static NODE *new_hash(struct parser_params *p, NODE *hash, const YYLTYPE *loc);
561 static NODE *new_unique_key_hash(struct parser_params *p, NODE *hash, const YYLTYPE *loc);
562 
563 static NODE *new_defined(struct parser_params *p, NODE *expr, const YYLTYPE *loc);
564 
565 static NODE *new_regexp(struct parser_params *, NODE *, int, const YYLTYPE *);
566 
567 #define make_list(list, loc) ((list) ? (nd_set_loc(list, loc), list) : NEW_ZLIST(loc))
568 
569 static NODE *new_xstring(struct parser_params *, NODE *, const YYLTYPE *loc);
570 
571 static NODE *symbol_append(struct parser_params *p, NODE *symbols, NODE *symbol);
572 
573 static NODE *match_op(struct parser_params*,NODE*,NODE*,const YYLTYPE*,const YYLTYPE*);
574 
575 static ID *local_tbl(struct parser_params*);
576 
577 static VALUE reg_compile(struct parser_params*, VALUE, int);
578 static void reg_fragment_setenc(struct parser_params*, VALUE, int);
579 static int reg_fragment_check(struct parser_params*, VALUE, int);
580 static NODE *reg_named_capture_assign(struct parser_params* p, VALUE regexp, const YYLTYPE *loc);
581 
582 static int literal_concat0(struct parser_params *p, VALUE head, VALUE tail);
583 static NODE *heredoc_dedent(struct parser_params*,NODE*);
584 
585 static void check_literal_when(struct parser_params *p, NODE *args, const YYLTYPE *loc);
586 
587 #define get_id(id) (id)
588 #define get_value(val) (val)
589 #define get_num(num) (num)
590 #else /* RIPPER */
591 #define NODE_RIPPER NODE_CDECL
592 
593 static inline int ripper_is_node_yylval(VALUE n);
594 
595 static inline VALUE
596 ripper_new_yylval(struct parser_params *p, ID a, VALUE b, VALUE c)
597 {
598  if (ripper_is_node_yylval(c)) c = RNODE(c)->nd_cval;
599  add_mark_object(p, b);
600  add_mark_object(p, c);
601  return (VALUE)NEW_CDECL(a, b, c, &NULL_LOC);
602 }
603 
604 static inline int
605 ripper_is_node_yylval(VALUE n)
606 {
607  return RB_TYPE_P(n, T_NODE) && nd_type(RNODE(n)) == NODE_RIPPER;
608 }
609 
610 #define value_expr(node) ((void)(node))
611 #define remove_begin(node) (node)
612 #define void_stmts(p,x) (x)
613 #define rb_dvar_defined(id, base) 0
614 #define rb_local_defined(id, base) 0
615 static ID ripper_get_id(VALUE);
616 #define get_id(id) ripper_get_id(id)
617 static VALUE ripper_get_value(VALUE);
618 #define get_value(val) ripper_get_value(val)
619 #define get_num(num) (int)get_id(num)
620 static VALUE assignable(struct parser_params*,VALUE);
621 static int id_is_var(struct parser_params *p, ID id);
622 
623 #define method_cond(p,node,loc) (node)
624 #define call_bin_op(p, recv,id,arg1,op_loc,loc) dispatch3(binary, (recv), STATIC_ID2SYM(id), (arg1))
625 #define match_op(p,node1,node2,op_loc,loc) call_bin_op(0, (node1), idEqTilde, (node2), op_loc, loc)
626 #define call_uni_op(p, recv,id,op_loc,loc) dispatch2(unary, STATIC_ID2SYM(id), (recv))
627 #define logop(p,id,node1,node2,op_loc,loc) call_bin_op(0, (node1), (id), (node2), op_loc, loc)
628 
629 #define new_nil(loc) Qnil
630 
631 static VALUE new_regexp(struct parser_params *, VALUE, VALUE, const YYLTYPE *);
632 
633 static VALUE const_decl(struct parser_params *p, VALUE path);
634 
635 static VALUE var_field(struct parser_params *p, VALUE a);
636 static VALUE assign_error(struct parser_params *p, VALUE a);
637 
638 static VALUE parser_reg_compile(struct parser_params*, VALUE, int, VALUE *);
639 
640 #endif /* !RIPPER */
641 
642 /* forward declaration */
644 
646 VALUE rb_parser_reg_compile(struct parser_params* p, VALUE str, int options);
647 int rb_reg_fragment_setenc(struct parser_params*, VALUE, int);
650 void rb_parser_show_bitstack(struct parser_params *, stack_type, const char *, int);
651 PRINTF_ARGS(void rb_parser_fatal(struct parser_params *p, const char *fmt, ...), 2, 3);
656 
657 static void error_duplicate_pattern_variable(struct parser_params *p, ID id, const YYLTYPE *loc);
658 static void error_duplicate_pattern_key(struct parser_params *p, ID id, const YYLTYPE *loc);
659 static void parser_token_value_print(struct parser_params *p, enum yytokentype type, const YYSTYPE *valp);
660 static ID formal_argument(struct parser_params*, ID);
661 static ID shadowing_lvar(struct parser_params*,ID);
662 static void new_bv(struct parser_params*,ID);
663 
664 static void local_push(struct parser_params*,int);
665 static void local_pop(struct parser_params*);
666 static void local_var(struct parser_params*, ID);
667 static void arg_var(struct parser_params*, ID);
668 static int local_id(struct parser_params *p, ID id);
669 static int local_id_ref(struct parser_params*, ID, ID **);
670 #ifndef RIPPER
671 static ID internal_id(struct parser_params*);
672 #endif
673 
674 static const struct vtable *dyna_push(struct parser_params *);
675 static void dyna_pop(struct parser_params*, const struct vtable *);
676 static int dyna_in_block(struct parser_params*);
677 #define dyna_var(p, id) local_var(p, id)
678 static int dvar_defined(struct parser_params*, ID);
679 static int dvar_defined_ref(struct parser_params*, ID, ID**);
680 static int dvar_curr(struct parser_params*,ID);
681 
682 static int lvar_defined(struct parser_params*, ID);
683 
684 static NODE *numparam_push(struct parser_params *p);
685 static void numparam_pop(struct parser_params *p, NODE *prev_inner);
686 
687 #ifdef RIPPER
688 # define METHOD_NOT idNOT
689 #else
690 # define METHOD_NOT '!'
691 #endif
692 
693 #define idFWD_REST '*'
694 #ifdef RUBY3_KEYWORDS
695 #define idFWD_KWREST idPow /* Use simple "**", as tDSTAR is "**arg" */
696 #else
697 #define idFWD_KWREST 0
698 #endif
699 #define idFWD_BLOCK '&'
700 
701 #define RE_OPTION_ONCE (1<<16)
702 #define RE_OPTION_ENCODING_SHIFT 8
703 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
704 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
705 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
706 #define RE_OPTION_MASK 0xff
707 #define RE_OPTION_ARG_ENCODING_NONE 32
708 
709 /* structs for managing terminator of string literal and heredocment */
711  union {
713  long nest;
714  } u0;
715  union {
716  VALUE dummy;
717  long func; /* STR_FUNC_* (e.g., STR_FUNC_ESCAPE and STR_FUNC_EXPAND) */
718  } u1;
719  union {
720  VALUE dummy;
721  long paren; /* '(' of `%q(...)` */
722  } u2;
723  union {
724  VALUE dummy;
725  long term; /* ')' of `%q(...)` */
726  } u3;
728 
729 #define HERETERM_LENGTH_BITS ((SIZEOF_VALUE - 1) * CHAR_BIT - 1)
730 
732  VALUE lastline; /* the string of line that contains `<<"END"` */
733  long offset; /* the column of END in `<<"END"` */
734  int sourceline; /* lineno of the line that contains `<<"END"` */
735  unsigned length /* the length of END in `<<"END"` */
736 #if HERETERM_LENGTH_BITS < SIZEOF_INT * CHAR_BIT
738 # define HERETERM_LENGTH_MAX ((1U << HERETERM_LENGTH_BITS) - 1)
739 #else
740 # define HERETERM_LENGTH_MAX UINT_MAX
741 #endif
742  ;
743 #if HERETERM_LENGTH_BITS < SIZEOF_INT * CHAR_BIT
744  unsigned quote: 1;
745  unsigned func: 8;
746 #else
747  uint8_t quote;
748  uint8_t func;
749 #endif
750 };
752 
753 #define STRTERM_HEREDOC IMEMO_FL_USER0
754 
757  union {
760  } u;
761 };
762 
763 #ifndef RIPPER
764 void
766 {
767  rb_strterm_t *strterm = (rb_strterm_t*)obj;
768  if (RBASIC(obj)->flags & STRTERM_HEREDOC) {
769  rb_strterm_heredoc_t *heredoc = &strterm->u.heredoc;
770  rb_gc_mark(heredoc->lastline);
771  }
772 }
773 #endif
774 
775 #define yytnamerr(yyres, yystr) (YYSIZE_T)rb_yytnamerr(p, yyres, yystr)
776 size_t rb_yytnamerr(struct parser_params *p, char *yyres, const char *yystr);
777 
778 #define TOKEN2ID(tok) ( \
779  tTOKEN_LOCAL_BEGIN<(tok)&&(tok)<tTOKEN_LOCAL_END ? TOKEN2LOCALID(tok) : \
780  tTOKEN_INSTANCE_BEGIN<(tok)&&(tok)<tTOKEN_INSTANCE_END ? TOKEN2INSTANCEID(tok) : \
781  tTOKEN_GLOBAL_BEGIN<(tok)&&(tok)<tTOKEN_GLOBAL_END ? TOKEN2GLOBALID(tok) : \
782  tTOKEN_CONST_BEGIN<(tok)&&(tok)<tTOKEN_CONST_END ? TOKEN2CONSTID(tok) : \
783  tTOKEN_CLASS_BEGIN<(tok)&&(tok)<tTOKEN_CLASS_END ? TOKEN2CLASSID(tok) : \
784  tTOKEN_ATTRSET_BEGIN<(tok)&&(tok)<tTOKEN_ATTRSET_END ? TOKEN2ATTRSETID(tok) : \
785  ((tok) / ((tok)<tPRESERVED_ID_END && ((tok)>=128 || rb_ispunct(tok)))))
786 
787 /****** Ripper *******/
788 
789 #ifdef RIPPER
790 #define RIPPER_VERSION "0.1.0"
791 
792 static inline VALUE intern_sym(const char *name);
793 
794 #include "eventids1.c"
795 #include "eventids2.c"
796 
797 static VALUE ripper_dispatch0(struct parser_params*,ID);
798 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
799 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
800 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
801 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
802 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
803 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
804 static void ripper_error(struct parser_params *p);
805 
806 #define dispatch0(n) ripper_dispatch0(p, TOKEN_PASTE(ripper_id_, n))
807 #define dispatch1(n,a) ripper_dispatch1(p, TOKEN_PASTE(ripper_id_, n), (a))
808 #define dispatch2(n,a,b) ripper_dispatch2(p, TOKEN_PASTE(ripper_id_, n), (a), (b))
809 #define dispatch3(n,a,b,c) ripper_dispatch3(p, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
810 #define dispatch4(n,a,b,c,d) ripper_dispatch4(p, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
811 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(p, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
812 #define dispatch7(n,a,b,c,d,e,f,g) ripper_dispatch7(p, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e), (f), (g))
813 
814 #define yyparse ripper_yyparse
815 
816 #define ID2VAL(id) STATIC_ID2SYM(id)
817 #define TOKEN2VAL(t) ID2VAL(TOKEN2ID(t))
818 #define KWD2EID(t, v) ripper_new_yylval(p, keyword_##t, get_value(v), 0)
819 
820 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
821  dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
822 
823 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
824 
825 static inline VALUE
826 new_args(struct parser_params *p, VALUE pre_args, VALUE opt_args, VALUE rest_arg, VALUE post_args, VALUE tail, YYLTYPE *loc)
827 {
828  NODE *t = (NODE *)tail;
829  VALUE kw_args = t->u1.value, kw_rest_arg = t->u2.value, block = t->u3.value;
830  return params_new(pre_args, opt_args, rest_arg, post_args, kw_args, kw_rest_arg, escape_Qundef(block));
831 }
832 
833 static inline VALUE
834 new_args_tail(struct parser_params *p, VALUE kw_args, VALUE kw_rest_arg, VALUE block, YYLTYPE *loc)
835 {
836  NODE *t = rb_node_newnode(NODE_ARGS_AUX, kw_args, kw_rest_arg, block, &NULL_LOC);
837  add_mark_object(p, kw_args);
838  add_mark_object(p, kw_rest_arg);
839  add_mark_object(p, block);
840  return (VALUE)t;
841 }
842 
843 static inline VALUE
844 args_with_numbered(struct parser_params *p, VALUE args, int max_numparam)
845 {
846  return args;
847 }
848 
849 static VALUE
850 new_array_pattern(struct parser_params *p, VALUE constant, VALUE pre_arg, VALUE aryptn, const YYLTYPE *loc)
851 {
852  NODE *t = (NODE *)aryptn;
853  struct rb_ary_pattern_info *apinfo = t->nd_apinfo;
855 
856  if (apinfo) {
857  pre_args = rb_ary_entry(apinfo->imemo, 0);
858  rest_arg = rb_ary_entry(apinfo->imemo, 1);
859  post_args = rb_ary_entry(apinfo->imemo, 2);
860  }
861 
862  if (!NIL_P(pre_arg)) {
863  if (!NIL_P(pre_args)) {
864  rb_ary_unshift(pre_args, pre_arg);
865  }
866  else {
867  pre_args = rb_ary_new_from_args(1, pre_arg);
868  }
869  }
870  return dispatch4(aryptn, constant, pre_args, rest_arg, post_args);
871 }
872 
873 static VALUE
874 new_array_pattern_tail(struct parser_params *p, VALUE pre_args, VALUE has_rest, VALUE rest_arg, VALUE post_args, const YYLTYPE *loc)
875 {
876  NODE *t;
877  struct rb_ary_pattern_info *apinfo;
878 
879  if (has_rest) {
880  rest_arg = dispatch1(var_field, rest_arg ? rest_arg : Qnil);
881  }
882  else {
883  rest_arg = Qnil;
884  }
885 
887  apinfo = ZALLOC(struct rb_ary_pattern_info);
888  rb_imemo_tmpbuf_set_ptr(tmpbuf, apinfo);
889  apinfo->imemo = rb_ary_new_from_args(4, pre_args, rest_arg, post_args, tmpbuf);
890 
891  t = rb_node_newnode(NODE_ARYPTN, Qnil, Qnil, (VALUE)apinfo, &NULL_LOC);
892  RB_OBJ_WRITTEN(p->ast, Qnil, apinfo->imemo);
893 
894  return (VALUE)t;
895 }
896 
897 #define new_hash(p,h,l) rb_ary_new_from_args(0)
898 
899 static VALUE
900 new_unique_key_hash(struct parser_params *p, VALUE ary, const YYLTYPE *loc)
901 {
902  return ary;
903 }
904 
905 static VALUE
906 new_hash_pattern(struct parser_params *p, VALUE constant, VALUE hshptn, const YYLTYPE *loc)
907 {
908  NODE *t = (NODE *)hshptn;
909  VALUE kw_args = t->u1.value, kw_rest_arg = t->u2.value;
910  return dispatch3(hshptn, constant, kw_args, kw_rest_arg);
911 }
912 
913 static VALUE
914 new_hash_pattern_tail(struct parser_params *p, VALUE kw_args, VALUE kw_rest_arg, const YYLTYPE *loc)
915 {
916  NODE *t;
917  if (kw_rest_arg) {
918  kw_rest_arg = dispatch1(var_field, kw_rest_arg);
919  }
920  else {
921  kw_rest_arg = Qnil;
922  }
923  t = rb_node_newnode(NODE_HSHPTN, kw_args, kw_rest_arg, 0, &NULL_LOC);
924 
925  add_mark_object(p, kw_args);
926  add_mark_object(p, kw_rest_arg);
927  return (VALUE)t;
928 }
929 
930 #define new_defined(p,expr,loc) dispatch1(defined, (expr))
931 
932 static VALUE heredoc_dedent(struct parser_params*,VALUE);
933 
934 #else
935 #define ID2VAL(id) (id)
936 #define TOKEN2VAL(t) ID2VAL(t)
937 #define KWD2EID(t, v) keyword_##t
938 #endif /* RIPPER */
939 
940 #ifndef RIPPER
941 # define Qnone 0
942 # define Qnull 0
943 # define ifndef_ripper(x) (x)
944 #else
945 # define Qnone Qnil
946 # define Qnull Qundef
947 # define ifndef_ripper(x)
948 #endif
949 
950 # define rb_warn0(fmt) WARN_CALL(WARN_ARGS(fmt, 1))
951 # define rb_warn1(fmt,a) WARN_CALL(WARN_ARGS(fmt, 2), (a))
952 # define rb_warn2(fmt,a,b) WARN_CALL(WARN_ARGS(fmt, 3), (a), (b))
953 # define rb_warn3(fmt,a,b,c) WARN_CALL(WARN_ARGS(fmt, 4), (a), (b), (c))
954 # define rb_warn4(fmt,a,b,c,d) WARN_CALL(WARN_ARGS(fmt, 5), (a), (b), (c), (d))
955 # define rb_warning0(fmt) WARNING_CALL(WARNING_ARGS(fmt, 1))
956 # define rb_warning1(fmt,a) WARNING_CALL(WARNING_ARGS(fmt, 2), (a))
957 # define rb_warning2(fmt,a,b) WARNING_CALL(WARNING_ARGS(fmt, 3), (a), (b))
958 # define rb_warning3(fmt,a,b,c) WARNING_CALL(WARNING_ARGS(fmt, 4), (a), (b), (c))
959 # define rb_warning4(fmt,a,b,c,d) WARNING_CALL(WARNING_ARGS(fmt, 5), (a), (b), (c), (d))
960 # define rb_warn0L(l,fmt) WARN_CALL(WARN_ARGS_L(l, fmt, 1))
961 # define rb_warn1L(l,fmt,a) WARN_CALL(WARN_ARGS_L(l, fmt, 2), (a))
962 # define rb_warn2L(l,fmt,a,b) WARN_CALL(WARN_ARGS_L(l, fmt, 3), (a), (b))
963 # define rb_warn3L(l,fmt,a,b,c) WARN_CALL(WARN_ARGS_L(l, fmt, 4), (a), (b), (c))
964 # define rb_warn4L(l,fmt,a,b,c,d) WARN_CALL(WARN_ARGS_L(l, fmt, 5), (a), (b), (c), (d))
965 # define rb_warning0L(l,fmt) WARNING_CALL(WARNING_ARGS_L(l, fmt, 1))
966 # define rb_warning1L(l,fmt,a) WARNING_CALL(WARNING_ARGS_L(l, fmt, 2), (a))
967 # define rb_warning2L(l,fmt,a,b) WARNING_CALL(WARNING_ARGS_L(l, fmt, 3), (a), (b))
968 # define rb_warning3L(l,fmt,a,b,c) WARNING_CALL(WARNING_ARGS_L(l, fmt, 4), (a), (b), (c))
969 # define rb_warning4L(l,fmt,a,b,c,d) WARNING_CALL(WARNING_ARGS_L(l, fmt, 5), (a), (b), (c), (d))
970 #ifdef RIPPER
971 static ID id_warn, id_warning, id_gets, id_assoc;
972 # define WARN_S_L(s,l) STR_NEW(s,l)
973 # define WARN_S(s) STR_NEW2(s)
974 # define WARN_I(i) INT2NUM(i)
975 # define WARN_ID(i) rb_id2str(i)
976 # define WARN_IVAL(i) i
977 # define PRIsWARN "s"
978 # define WARN_ARGS(fmt,n) p->value, id_warn, n, rb_usascii_str_new_lit(fmt)
979 # define WARN_ARGS_L(l,fmt,n) WARN_ARGS(fmt,n)
980 # ifdef HAVE_VA_ARGS_MACRO
981 # define WARN_CALL(...) rb_funcall(__VA_ARGS__)
982 # else
983 # define WARN_CALL rb_funcall
984 # endif
985 # define WARNING_ARGS(fmt,n) p->value, id_warning, n, rb_usascii_str_new_lit(fmt)
986 # define WARNING_ARGS_L(l, fmt,n) WARNING_ARGS(fmt,n)
987 # ifdef HAVE_VA_ARGS_MACRO
988 # define WARNING_CALL(...) rb_funcall(__VA_ARGS__)
989 # else
990 # define WARNING_CALL rb_funcall
991 # endif
992 PRINTF_ARGS(static void ripper_compile_error(struct parser_params*, const char *fmt, ...), 2, 3);
993 # define compile_error ripper_compile_error
994 #else
995 # define WARN_S_L(s,l) s
996 # define WARN_S(s) s
997 # define WARN_I(i) i
998 # define WARN_ID(i) rb_id2name(i)
999 # define WARN_IVAL(i) NUM2INT(i)
1000 # define PRIsWARN PRIsVALUE
1001 # define WARN_ARGS(fmt,n) WARN_ARGS_L(p->ruby_sourceline,fmt,n)
1002 # define WARN_ARGS_L(l,fmt,n) p->ruby_sourcefile, (l), (fmt)
1003 # define WARN_CALL rb_compile_warn
1004 # define WARNING_ARGS(fmt,n) WARN_ARGS(fmt,n)
1005 # define WARNING_ARGS_L(l,fmt,n) WARN_ARGS_L(l,fmt,n)
1006 # define WARNING_CALL rb_compile_warning
1007 PRINTF_ARGS(static void parser_compile_error(struct parser_params*, const char *fmt, ...), 2, 3);
1008 # define compile_error parser_compile_error
1009 #endif
1010 
1011 static void token_info_setup(token_info *ptinfo, const char *ptr, const rb_code_location_t *loc);
1012 static void token_info_push(struct parser_params*, const char *token, const rb_code_location_t *loc);
1013 static void token_info_pop(struct parser_params*, const char *token, const rb_code_location_t *loc);
1014 static void token_info_warn(struct parser_params *p, const char *token, token_info *ptinfo_beg, int same, const rb_code_location_t *loc);
1015 
1016 #define WARN_EOL(tok) \
1017  (looking_at_eol_p(p) ? \
1018  (void)rb_warning0("`" tok "' at the end of line without an expression") : \
1019  (void)0)
1020 static int looking_at_eol_p(struct parser_params *p);
1021 
1022 #line 1023 "ripper.c" /* yacc.c:339 */
1023 
1024 # ifndef YY_NULLPTR
1025 # if defined __cplusplus && 201103L <= __cplusplus
1026 # define YY_NULLPTR nullptr
1027 # else
1028 # define YY_NULLPTR 0
1029 # endif
1030 # endif
1031 
1032 /* Enabling verbose error messages. */
1033 #ifdef YYERROR_VERBOSE
1034 # undef YYERROR_VERBOSE
1035 # define YYERROR_VERBOSE 1
1036 #else
1037 # define YYERROR_VERBOSE 1
1038 #endif
1039 
1040 
1041 /* Debug traces. */
1042 #ifndef YYDEBUG
1043 # define YYDEBUG 1
1044 #endif
1045 #if YYDEBUG
1046 #ifndef yydebug
1047 extern int yydebug;
1048 #endif
1049 #endif
1050 
1051 /* Token type. */
1052 #ifndef YYTOKENTYPE
1053 # define YYTOKENTYPE
1054  enum yytokentype
1055  {
1056  END_OF_INPUT = 0,
1057  keyword_class = 258,
1058  keyword_module = 259,
1059  keyword_def = 260,
1060  keyword_undef = 261,
1061  keyword_begin = 262,
1062  keyword_rescue = 263,
1063  keyword_ensure = 264,
1064  keyword_end = 265,
1065  keyword_if = 266,
1066  keyword_unless = 267,
1067  keyword_then = 268,
1068  keyword_elsif = 269,
1069  keyword_else = 270,
1070  keyword_case = 271,
1071  keyword_when = 272,
1072  keyword_while = 273,
1073  keyword_until = 274,
1074  keyword_for = 275,
1075  keyword_break = 276,
1076  keyword_next = 277,
1077  keyword_redo = 278,
1078  keyword_retry = 279,
1079  keyword_in = 280,
1080  keyword_do = 281,
1081  keyword_do_cond = 282,
1082  keyword_do_block = 283,
1083  keyword_do_LAMBDA = 284,
1084  keyword_return = 285,
1085  keyword_yield = 286,
1086  keyword_super = 287,
1087  keyword_self = 288,
1088  keyword_nil = 289,
1089  keyword_true = 290,
1090  keyword_false = 291,
1091  keyword_and = 292,
1092  keyword_or = 293,
1093  keyword_not = 294,
1094  modifier_if = 295,
1095  modifier_unless = 296,
1096  modifier_while = 297,
1097  modifier_until = 298,
1098  modifier_rescue = 299,
1099  keyword_alias = 300,
1100  keyword_defined = 301,
1101  keyword_BEGIN = 302,
1102  keyword_END = 303,
1103  keyword__LINE__ = 304,
1104  keyword__FILE__ = 305,
1105  keyword__ENCODING__ = 306,
1106  tIDENTIFIER = 307,
1107  tFID = 308,
1108  tGVAR = 309,
1109  tIVAR = 310,
1110  tCONSTANT = 311,
1111  tCVAR = 312,
1112  tLABEL = 313,
1113  tINTEGER = 314,
1114  tFLOAT = 315,
1115  tRATIONAL = 316,
1116  tIMAGINARY = 317,
1117  tCHAR = 318,
1118  tNTH_REF = 319,
1119  tBACK_REF = 320,
1120  tSTRING_CONTENT = 321,
1121  tREGEXP_END = 322,
1122  tSP = 323,
1123  tUPLUS = 132,
1124  tUMINUS = 133,
1125  tPOW = 134,
1126  tCMP = 135,
1127  tEQ = 140,
1128  tEQQ = 141,
1129  tNEQ = 142,
1130  tGEQ = 139,
1131  tLEQ = 138,
1132  tANDOP = 148,
1133  tOROP = 149,
1134  tMATCH = 143,
1135  tNMATCH = 144,
1136  tDOT2 = 128,
1137  tDOT3 = 129,
1138  tBDOT2 = 130,
1139  tBDOT3 = 131,
1140  tAREF = 145,
1141  tASET = 146,
1142  tLSHFT = 136,
1143  tRSHFT = 137,
1144  tANDDOT = 150,
1145  tCOLON2 = 147,
1146  tCOLON3 = 324,
1147  tOP_ASGN = 325,
1148  tASSOC = 326,
1149  tLPAREN = 327,
1150  tLPAREN_ARG = 328,
1151  tRPAREN = 329,
1152  tLBRACK = 330,
1153  tLBRACE = 331,
1154  tLBRACE_ARG = 332,
1155  tSTAR = 333,
1156  tDSTAR = 334,
1157  tAMPER = 335,
1158  tLAMBDA = 336,
1159  tSYMBEG = 337,
1160  tSTRING_BEG = 338,
1161  tXSTRING_BEG = 339,
1162  tREGEXP_BEG = 340,
1163  tWORDS_BEG = 341,
1164  tQWORDS_BEG = 342,
1165  tSYMBOLS_BEG = 343,
1166  tQSYMBOLS_BEG = 344,
1167  tSTRING_END = 345,
1168  tSTRING_DEND = 346,
1169  tSTRING_DBEG = 347,
1170  tSTRING_DVAR = 348,
1171  tLAMBEG = 349,
1172  tLABEL_END = 350,
1173  tLOWEST = 351,
1174  tUMINUS_NUM = 352,
1175  tLAST_TOKEN = 353
1176  };
1177 #endif
1178 
1179 /* Value type. */
1180 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1181 
1182 union YYSTYPE
1183 {
1184 #line 979 "ripper.y" /* yacc.c:355 */
1185 
1186  VALUE val;
1187  NODE *node;
1188  ID id;
1189  int num;
1190  st_table *tbl;
1191  const struct vtable *vars;
1192  struct rb_strterm_struct *strterm;
1193 
1194 #line 1193 "ripper.c" /* yacc.c:355 */
1195 };
1196 
1197 typedef union YYSTYPE YYSTYPE;
1198 # define YYSTYPE_IS_TRIVIAL 1
1199 # define YYSTYPE_IS_DECLARED 1
1200 #endif
1201 
1202 /* Location type. */
1203 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
1204 typedef struct YYLTYPE YYLTYPE;
1205 struct YYLTYPE
1206 {
1207  int first_line;
1208  int first_column;
1209  int last_line;
1210  int last_column;
1211 };
1212 # define YYLTYPE_IS_DECLARED 1
1213 # define YYLTYPE_IS_TRIVIAL 1
1214 #endif
1215 
1216 
1217 
1218 int yyparse (struct parser_params *p);
1219 
1220 
1221 
1222 /* Copy the second part of user declarations. */
1223 
1224 #line 1223 "ripper.c" /* yacc.c:358 */
1225 
1226 #ifdef short
1227 # undef short
1228 #endif
1229 
1230 #ifdef YYTYPE_UINT8
1231 typedef YYTYPE_UINT8 yytype_uint8;
1232 #else
1233 typedef unsigned char yytype_uint8;
1234 #endif
1235 
1236 #ifdef YYTYPE_INT8
1237 typedef YYTYPE_INT8 yytype_int8;
1238 #else
1239 typedef signed char yytype_int8;
1240 #endif
1241 
1242 #ifdef YYTYPE_UINT16
1243 typedef YYTYPE_UINT16 yytype_uint16;
1244 #else
1245 typedef unsigned short int yytype_uint16;
1246 #endif
1247 
1248 #ifdef YYTYPE_INT16
1249 typedef YYTYPE_INT16 yytype_int16;
1250 #else
1251 typedef short int yytype_int16;
1252 #endif
1253 
1254 #ifndef YYSIZE_T
1255 # ifdef __SIZE_TYPE__
1256 # define YYSIZE_T __SIZE_TYPE__
1257 # elif defined size_t
1258 # define YYSIZE_T size_t
1259 # elif ! defined YYSIZE_T
1260 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1261 # define YYSIZE_T size_t
1262 # else
1263 # define YYSIZE_T unsigned int
1264 # endif
1265 #endif
1266 
1267 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
1268 
1269 #ifndef YY_
1270 # if defined YYENABLE_NLS && YYENABLE_NLS
1271 # if ENABLE_NLS
1272 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
1273 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
1274 # endif
1275 # endif
1276 # ifndef YY_
1277 # define YY_(Msgid) Msgid
1278 # endif
1279 #endif
1280 
1281 #ifndef YY_ATTRIBUTE
1282 # if (defined __GNUC__ \
1283  && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
1284  || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
1285 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
1286 # else
1287 # define YY_ATTRIBUTE(Spec) /* empty */
1288 # endif
1289 #endif
1290 
1291 #ifndef YY_ATTRIBUTE_PURE
1292 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
1293 #endif
1294 
1295 #ifndef YY_ATTRIBUTE_UNUSED
1296 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
1297 #endif
1298 
1299 #if !defined _Noreturn \
1300  && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
1301 # if defined _MSC_VER && 1200 <= _MSC_VER
1302 # define _Noreturn __declspec (noreturn)
1303 # else
1304 # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
1305 # endif
1306 #endif
1307 
1308 /* Suppress unused-variable warnings by "using" E. */
1309 #if ! defined lint || defined __GNUC__
1310 # define YYUSE(E) ((void) (E))
1311 #else
1312 # define YYUSE(E) /* empty */
1313 #endif
1314 
1315 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
1316 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
1317 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
1318  _Pragma ("GCC diagnostic push") \
1319  _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
1320  _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
1321 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
1322  _Pragma ("GCC diagnostic pop")
1323 #else
1324 # define YY_INITIAL_VALUE(Value) Value
1325 #endif
1326 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1327 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1328 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
1329 #endif
1330 #ifndef YY_INITIAL_VALUE
1331 # define YY_INITIAL_VALUE(Value) /* Nothing. */
1332 #endif
1333 
1334 
1335 #if ! defined yyoverflow || YYERROR_VERBOSE
1336 
1337 /* The parser invokes alloca or malloc; define the necessary symbols. */
1338 
1339 # ifdef YYSTACK_USE_ALLOCA
1340 # if YYSTACK_USE_ALLOCA
1341 # ifdef __GNUC__
1342 # define YYSTACK_ALLOC __builtin_alloca
1343 # elif defined __BUILTIN_VA_ARG_INCR
1344 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1345 # elif defined _AIX
1346 # define YYSTACK_ALLOC __alloca
1347 # elif defined _MSC_VER
1348 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1349 # define alloca _alloca
1350 # else
1351 # define YYSTACK_ALLOC alloca
1352 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
1353 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1354  /* Use EXIT_SUCCESS as a witness for stdlib.h. */
1355 # ifndef EXIT_SUCCESS
1356 # define EXIT_SUCCESS 0
1357 # endif
1358 # endif
1359 # endif
1360 # endif
1361 # endif
1362 
1363 # ifdef YYSTACK_ALLOC
1364  /* Pacify GCC's 'empty if-body' warning. */
1365 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
1366 # ifndef YYSTACK_ALLOC_MAXIMUM
1367  /* The OS might guarantee only one guard page at the bottom of the stack,
1368  and a page size can be as small as 4096 bytes. So we cannot safely
1369  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1370  to allow for a few compiler-allocated temporary stack slots. */
1371 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1372 # endif
1373 # else
1374 # define YYSTACK_ALLOC YYMALLOC
1375 # define YYSTACK_FREE YYFREE
1376 # ifndef YYSTACK_ALLOC_MAXIMUM
1377 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1378 # endif
1379 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
1380  && ! ((defined YYMALLOC || defined malloc) \
1381  && (defined YYFREE || defined free)))
1382 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1383 # ifndef EXIT_SUCCESS
1384 # define EXIT_SUCCESS 0
1385 # endif
1386 # endif
1387 # ifndef YYMALLOC
1388 # define YYMALLOC malloc
1389 # if ! defined malloc && ! defined EXIT_SUCCESS
1390 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1391 # endif
1392 # endif
1393 # ifndef YYFREE
1394 # define YYFREE free
1395 # if ! defined free && ! defined EXIT_SUCCESS
1396 void free (void *); /* INFRINGES ON USER NAME SPACE */
1397 # endif
1398 # endif
1399 # endif
1400 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1401 
1402 
1403 #if (! defined yyoverflow \
1404  && (! defined __cplusplus \
1405  || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
1406  && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1407 
1408 /* A type that is properly aligned for any stack member. */
1409 union yyalloc
1410 {
1414 };
1415 
1416 /* The size of the maximum gap between one aligned stack and the next. */
1417 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1418 
1419 /* The size of an array large to enough to hold all stacks, each with
1420  N elements. */
1421 # define YYSTACK_BYTES(N) \
1422  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
1423  + 2 * YYSTACK_GAP_MAXIMUM)
1424 
1425 # define YYCOPY_NEEDED 1
1426 
1427 /* Relocate STACK from its old location to the new one. The
1428  local variables YYSIZE and YYSTACKSIZE give the old and new number of
1429  elements in the stack, and YYPTR gives the new location of the
1430  stack. Advance YYPTR to a properly aligned location for the next
1431  stack. */
1432 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1433  do \
1434  { \
1435  YYSIZE_T yynewbytes; \
1436  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1437  Stack = &yyptr->Stack_alloc; \
1438  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1439  yyptr += yynewbytes / sizeof (*yyptr); \
1440  } \
1441  while (0)
1442 
1443 #endif
1444 
1445 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1446 /* Copy COUNT objects from SRC to DST. The source and destination do
1447  not overlap. */
1448 # ifndef YYCOPY
1449 # if defined __GNUC__ && 1 < __GNUC__
1450 # define YYCOPY(Dst, Src, Count) \
1451  __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
1452 # else
1453 # define YYCOPY(Dst, Src, Count) \
1454  do \
1455  { \
1456  YYSIZE_T yyi; \
1457  for (yyi = 0; yyi < (Count); yyi++) \
1458  (Dst)[yyi] = (Src)[yyi]; \
1459  } \
1460  while (0)
1461 # endif
1462 # endif
1463 #endif /* !YYCOPY_NEEDED */
1464 
1465 /* YYFINAL -- State number of the termination state. */
1466 #define YYFINAL 3
1467 /* YYLAST -- Last index in YYTABLE. */
1468 #define YYLAST 13766
1469 
1470 /* YYNTOKENS -- Number of terminals. */
1471 #define YYNTOKENS 154
1472 /* YYNNTS -- Number of nonterminals. */
1473 #define YYNNTS 266
1474 /* YYNRULES -- Number of rules. */
1475 #define YYNRULES 759
1476 /* YYNSTATES -- Number of states. */
1477 #define YYNSTATES 1243
1478 
1479 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
1480  by yylex, with out-of-bounds checking. */
1481 #define YYUNDEFTOK 2
1482 #define YYMAXUTOK 353
1483 
1484 #define YYTRANSLATE(YYX) \
1485  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1486 
1487 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
1488  as returned by yylex, without out-of-bounds checking. */
1489 static const yytype_uint8 yytranslate[] =
1490 {
1491  0, 2, 2, 2, 2, 2, 2, 2, 2, 71,
1492  153, 74, 72, 73, 2, 2, 2, 2, 2, 2,
1493  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1494  2, 2, 152, 140, 2, 2, 2, 138, 133, 2,
1495  148, 149, 136, 134, 146, 135, 68, 137, 2, 2,
1496  2, 2, 2, 2, 2, 2, 2, 2, 128, 151,
1497  130, 126, 129, 127, 2, 2, 2, 2, 2, 2,
1498  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1499  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1500  2, 145, 69, 150, 132, 2, 147, 2, 2, 2,
1501  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1502  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1503  2, 2, 2, 143, 131, 144, 141, 2, 88, 89,
1504  90, 91, 75, 76, 77, 78, 94, 95, 83, 82,
1505  79, 80, 81, 86, 87, 92, 93, 97, 84, 85,
1506  96, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1507  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1508  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1509  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1510  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1511  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1512  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1513  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1514  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1515  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1516  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1517  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1518  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1519  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1520  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1521  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1522  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1523  65, 66, 67, 70, 98, 99, 100, 101, 102, 103,
1524  104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
1525  114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
1526  124, 125, 139, 142
1527 };
1528 
1529 #if YYDEBUG
1530  /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
1531 static const yytype_uint16 yyrline[] =
1532 {
1533  0, 1177, 1177, 1177, 1203, 1209, 1216, 1223, 1230, 1236,
1534  1237, 1243, 1256, 1254, 1265, 1276, 1282, 1289, 1296, 1303,
1535  1309, 1314, 1313, 1323, 1323, 1330, 1337, 1347, 1355, 1362,
1536  1370, 1378, 1390, 1402, 1412, 1426, 1427, 1435, 1443, 1452,
1537  1459, 1462, 1469, 1476, 1484, 1491, 1498, 1506, 1513, 1523,
1538  1528, 1537, 1540, 1541, 1545, 1549, 1553, 1558, 1565, 1567,
1539  1557, 1575, 1578, 1585, 1585, 1585, 1591, 1592, 1595, 1596,
1540  1605, 1615, 1625, 1634, 1645, 1652, 1659, 1666, 1673, 1681,
1541  1689, 1696, 1703, 1712, 1713, 1722, 1723, 1732, 1739, 1746,
1542  1753, 1760, 1767, 1774, 1781, 1788, 1795, 1804, 1805, 1814,
1543  1821, 1830, 1837, 1846, 1853, 1860, 1867, 1877, 1884, 1894,
1544  1901, 1908, 1918, 1925, 1932, 1939, 1946, 1953, 1960, 1967,
1545  1974, 1984, 1991, 1994, 2001, 2008, 2017, 2018, 2019, 2020,
1546  2025, 2028, 2035, 2038, 2045, 2045, 2055, 2056, 2057, 2058,
1547  2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068,
1548  2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078,
1549  2079, 2080, 2081, 2082, 2083, 2084, 2087, 2087, 2087, 2088,
1550  2088, 2089, 2089, 2089, 2090, 2090, 2090, 2090, 2091, 2091,
1551  2091, 2091, 2092, 2092, 2092, 2093, 2093, 2093, 2093, 2094,
1552  2094, 2094, 2094, 2095, 2095, 2095, 2095, 2096, 2096, 2096,
1553  2096, 2097, 2097, 2097, 2097, 2098, 2098, 2101, 2108, 2115,
1554  2123, 2131, 2139, 2147, 2155, 2162, 2170, 2179, 2188, 2200,
1555  2212, 2224, 2236, 2240, 2244, 2248, 2252, 2256, 2260, 2264,
1556  2268, 2272, 2276, 2280, 2284, 2288, 2289, 2293, 2297, 2301,
1557  2305, 2309, 2313, 2317, 2321, 2325, 2329, 2333, 2333, 2338,
1558  2347, 2353, 2354, 2355, 2356, 2359, 2363, 2370, 2377, 2378,
1559  2382, 2389, 2398, 2403, 2414, 2421, 2450, 2451, 2454, 2455,
1560  2456, 2460, 2467, 2476, 2484, 2491, 2499, 2507, 2511, 2511,
1561  2548, 2557, 2561, 2567, 2574, 2581, 2588, 2597, 2598, 2601,
1562  2608, 2615, 2624, 2625, 2626, 2627, 2628, 2629, 2630, 2631,
1563  2632, 2633, 2634, 2642, 2641, 2656, 2656, 2663, 2663, 2671,
1564  2679, 2686, 2693, 2700, 2708, 2715, 2722, 2729, 2736, 2736,
1565  2741, 2745, 2749, 2756, 2757, 2766, 2765, 2776, 2787, 2798,
1566  2808, 2819, 2818, 2835, 2834, 2849, 2858, 2903, 2902, 2926,
1567  2925, 2948, 2947, 2971, 2977, 2970, 2997, 2998, 2997, 3023,
1568  3030, 3037, 3044, 3053, 3060, 3066, 3083, 3089, 3095, 3101,
1569  3107, 3113, 3119, 3125, 3131, 3137, 3143, 3149, 3155, 3161,
1570  3176, 3183, 3189, 3196, 3197, 3198, 3201, 3202, 3205, 3206,
1571  3218, 3219, 3228, 3229, 3232, 3240, 3249, 3256, 3265, 3272,
1572  3279, 3286, 3293, 3302, 3310, 3319, 3323, 3327, 3331, 3335,
1573  3341, 3346, 3351, 3355, 3359, 3363, 3367, 3371, 3379, 3383,
1574  3387, 3391, 3395, 3399, 3403, 3407, 3411, 3417, 3418, 3424,
1575  3433, 3445, 3449, 3458, 3460, 3464, 3469, 3475, 3478, 3482,
1576  3486, 3490, 3475, 3514, 3522, 3532, 3537, 3543, 3553, 3567,
1577  3574, 3581, 3590, 3599, 3607, 3615, 3622, 3630, 3638, 3645,
1578  3652, 3665, 3673, 3683, 3684, 3688, 3683, 3705, 3706, 3710,
1579  3705, 3729, 3737, 3744, 3752, 3761, 3773, 3774, 3778, 3784,
1580  3785, 3787, 3788, 3789, 3777, 3802, 3803, 3806, 3807, 3815,
1581  3825, 3826, 3831, 3839, 3843, 3849, 3852, 3861, 3864, 3871,
1582  3874, 3875, 3877, 3878, 3887, 3896, 3901, 3910, 3919, 3924,
1583  3924, 3929, 3935, 3934, 3946, 3951, 3951, 3958, 3967, 3971,
1584  3980, 3984, 3988, 3992, 3996, 3999, 4003, 4012, 4016, 4020,
1585  4024, 4030, 4031, 4040, 4049, 4053, 4057, 4061, 4065, 4069,
1586  4075, 4077, 4086, 4094, 4108, 4109, 4132, 4136, 4142, 4148,
1587  4149, 4158, 4167, 4179, 4191, 4192, 4193, 4194, 4206, 4220,
1588  4221, 4222, 4223, 4224, 4225, 4226, 4227, 4228, 4236, 4235,
1589  4248, 4258, 4271, 4278, 4285, 4294, 4306, 4309, 4316, 4323,
1590  4326, 4330, 4333, 4340, 4343, 4344, 4347, 4364, 4365, 4366,
1591  4375, 4385, 4394, 4400, 4410, 4416, 4425, 4427, 4436, 4446,
1592  4452, 4461, 4470, 4480, 4486, 4496, 4502, 4512, 4522, 4541,
1593  4547, 4557, 4567, 4608, 4611, 4610, 4627, 4631, 4636, 4640,
1594  4644, 4626, 4665, 4672, 4679, 4686, 4689, 4690, 4693, 4703,
1595  4704, 4705, 4706, 4709, 4719, 4720, 4730, 4731, 4732, 4733,
1596  4736, 4737, 4738, 4739, 4740, 4743, 4744, 4745, 4746, 4747,
1597  4748, 4749, 4752, 4765, 4774, 4781, 4790, 4791, 4795, 4794,
1598  4804, 4812, 4821, 4836, 4836, 4850, 4854, 4858, 4862, 4866,
1599  4872, 4877, 4882, 4886, 4890, 4894, 4898, 4902, 4906, 4910,
1600  4914, 4918, 4922, 4926, 4930, 4934, 4939, 4945, 4954, 4962,
1601  4970, 4978, 4988, 4989, 4997, 5006, 5014, 5035, 5037, 5050,
1602  5060, 5068, 5078, 5085, 5094, 5101, 5111, 5118, 5127, 5128,
1603  5131, 5139, 5147, 5157, 5167, 5177, 5184, 5193, 5200, 5209,
1604  5210, 5213, 5221, 5231, 5232, 5235, 5245, 5249, 5255, 5260,
1605  5260, 5284, 5285, 5294, 5296, 5319, 5330, 5337, 5345, 5364,
1606  5365, 5366, 5369, 5370, 5371, 5372, 5375, 5376, 5377, 5380,
1607  5381, 5384, 5385, 5388, 5389, 5392, 5393, 5396, 5397, 5400,
1608  5403, 5406, 5409, 5410, 5411, 5414, 5415, 5418, 5419, 5423
1609 };
1610 #endif
1611 
1612 #if YYDEBUG || YYERROR_VERBOSE || 1
1613 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1614  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1615 static const char *const yytname[] =
1616 {
1617  "\"end-of-input\"", "error", "$undefined", "\"`class'\"",
1618  "\"`module'\"", "\"`def'\"", "\"`undef'\"", "\"`begin'\"",
1619  "\"`rescue'\"", "\"`ensure'\"", "\"`end'\"", "\"`if'\"", "\"`unless'\"",
1620  "\"`then'\"", "\"`elsif'\"", "\"`else'\"", "\"`case'\"", "\"`when'\"",
1621  "\"`while'\"", "\"`until'\"", "\"`for'\"", "\"`break'\"", "\"`next'\"",
1622  "\"`redo'\"", "\"`retry'\"", "\"`in'\"", "\"`do'\"",
1623  "\"`do' for condition\"", "\"`do' for block\"", "\"`do' for lambda\"",
1624  "\"`return'\"", "\"`yield'\"", "\"`super'\"", "\"`self'\"", "\"`nil'\"",
1625  "\"`true'\"", "\"`false'\"", "\"`and'\"", "\"`or'\"", "\"`not'\"",
1626  "\"`if' modifier\"", "\"`unless' modifier\"", "\"`while' modifier\"",
1627  "\"`until' modifier\"", "\"`rescue' modifier\"", "\"`alias'\"",
1628  "\"`defined?'\"", "\"`BEGIN'\"", "\"`END'\"", "\"`__LINE__'\"",
1629  "\"`__FILE__'\"", "\"`__ENCODING__'\"", "\"local variable or method\"",
1630  "\"method\"", "\"global variable\"", "\"instance variable\"",
1631  "\"constant\"", "\"class variable\"", "tLABEL", "\"integer literal\"",
1632  "\"float literal\"", "\"rational literal\"", "\"imaginary literal\"",
1633  "\"char literal\"", "\"numbered reference\"", "\"back reference\"",
1634  "\"literal content\"", "tREGEXP_END", "'.'", "\"backslash\"",
1635  "\"escaped space\"", "\"escaped horizontal tab\"",
1636  "\"escaped form feed\"", "\"escaped carriage return\"",
1637  "\"escaped vertical tab\"", "\"unary+\"", "\"unary-\"", "\"**\"",
1638  "\"<=>\"", "\"==\"", "\"===\"", "\"!=\"", "\">=\"", "\"<=\"", "\"&&\"",
1639  "\"||\"", "\"=~\"", "\"!~\"", "\"..\"", "\"...\"", "\"(..\"", "\"(...\"",
1640  "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"", "\"&.\"", "\"::\"",
1641  "\":: at EXPR_BEG\"", "\"operator-assignment\"", "\"=>\"", "\"(\"",
1642  "\"( arg\"", "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"",
1643  "\"**arg\"", "\"&\"", "\"->\"", "\"symbol literal\"",
1644  "\"string literal\"", "\"backtick literal\"", "\"regexp literal\"",
1645  "\"word list\"", "\"verbatim word list\"", "\"symbol list\"",
1646  "\"verbatim symbol list\"", "\"terminator\"", "\"'}'\"", "tSTRING_DBEG",
1647  "tSTRING_DVAR", "tLAMBEG", "tLABEL_END", "tLOWEST", "'='", "'?'", "':'",
1648  "'>'", "'<'", "'|'", "'^'", "'&'", "'+'", "'-'", "'*'", "'/'", "'%'",
1649  "tUMINUS_NUM", "'!'", "'~'", "tLAST_TOKEN", "'{'", "'}'", "'['", "','",
1650  "'`'", "'('", "')'", "']'", "';'", "' '", "'\\n'", "$accept", "program",
1651  "$@1", "top_compstmt", "top_stmts", "top_stmt", "begin_block",
1652  "bodystmt", "$@2", "compstmt", "stmts", "stmt_or_begin", "$@3", "stmt",
1653  "$@4", "command_asgn", "command_rhs", "expr", "@5", "@6", "$@7",
1654  "expr_value", "expr_value_do", "$@8", "$@9", "command_call",
1655  "block_command", "cmd_brace_block", "fcall", "command", "mlhs",
1656  "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head", "mlhs_post",
1657  "mlhs_node", "lhs", "cname", "cpath", "fname", "fitem", "undef_list",
1658  "$@10", "op", "reswords", "arg", "$@11", "relop", "rel_expr",
1659  "arg_value", "aref_args", "arg_rhs", "paren_args", "opt_paren_args",
1660  "opt_call_args", "call_args", "command_args", "$@12", "block_arg",
1661  "opt_block_arg", "args", "mrhs_arg", "mrhs", "primary", "$@13", "$@14",
1662  "$@15", "$@16", "$@17", "@18", "@19", "$@20", "@21", "$@22", "@23",
1663  "@24", "@25", "@26", "primary_value", "k_begin", "k_if", "k_unless",
1664  "k_while", "k_until", "k_case", "k_for", "k_class", "k_module", "k_def",
1665  "k_do", "k_do_block", "k_rescue", "k_ensure", "k_when", "k_else",
1666  "k_elsif", "k_end", "k_return", "then", "do", "if_tail", "opt_else",
1667  "for_var", "f_marg", "f_marg_list", "f_margs", "f_rest_marg",
1668  "block_args_tail", "opt_block_args_tail", "block_param",
1669  "opt_block_param", "block_param_def", "opt_bv_decl", "bv_decls", "bvar",
1670  "lambda", "@27", "@28", "@29", "@30", "$@31", "f_larglist",
1671  "lambda_body", "do_block", "block_call", "method_call", "brace_block",
1672  "brace_body", "@32", "@33", "@34", "do_body", "@35", "@36", "@37",
1673  "case_args", "case_body", "cases", "p_case_body", "@38", "@39", "@40",
1674  "$@41", "$@42", "$@43", "p_cases", "p_top_expr", "p_top_expr_body",
1675  "p_expr", "p_as", "p_alt", "p_lparen", "p_lbracket", "p_expr_basic",
1676  "@44", "@45", "@46", "p_args", "p_args_head", "p_args_tail",
1677  "p_args_post", "p_arg", "p_kwargs", "p_kwarg", "p_kw", "p_kw_label",
1678  "p_kwrest", "p_kwnorest", "p_value", "p_primitive", "$@47", "p_variable",
1679  "p_var_ref", "p_const", "opt_rescue", "exc_list", "exc_var",
1680  "opt_ensure", "literal", "strings", "string", "string1", "xstring",
1681  "regexp", "words", "word_list", "word", "symbols", "symbol_list",
1682  "qwords", "qsymbols", "qword_list", "qsym_list", "string_contents",
1683  "xstring_contents", "regexp_contents", "string_content", "@48", "$@49",
1684  "@50", "@51", "@52", "@53", "string_dvar", "symbol", "ssym", "sym",
1685  "dsym", "numeric", "simple_numeric", "user_variable", "keyword_variable",
1686  "var_ref", "var_lhs", "backref", "superclass", "$@54", "f_arglist",
1687  "@55", "args_tail", "opt_args_tail", "f_args", "args_forward",
1688  "f_bad_arg", "f_norm_arg", "f_arg_asgn", "f_arg_item", "f_arg",
1689  "f_label", "f_kw", "f_block_kw", "f_block_kwarg", "f_kwarg",
1690  "kwrest_mark", "f_no_kwarg", "f_kwrest", "f_opt", "f_block_opt",
1691  "f_block_optarg", "f_optarg", "restarg_mark", "f_rest_arg",
1692  "blkarg_mark", "f_block_arg", "opt_f_block_arg", "singleton", "$@56",
1693  "assoc_list", "assocs", "assoc", "operation", "operation2", "operation3",
1694  "dot_or_colon", "call_op", "call_op2", "opt_terms", "opt_nl", "rparen",
1695  "rbracket", "rbrace", "trailer", "term", "terms", "none", YY_NULLPTR
1696 };
1697 #endif
1698 
1699 # ifdef YYPRINT
1700 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
1701  (internal) symbol number NUM (which must be that of a token). */
1702 static const yytype_uint16 yytoknum[] =
1703 {
1704  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1705  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1706  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1707  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1708  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1709  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1710  315, 316, 317, 318, 319, 320, 321, 322, 46, 92,
1711  323, 9, 12, 13, 11, 132, 133, 134, 135, 140,
1712  141, 142, 139, 138, 148, 149, 143, 144, 128, 129,
1713  130, 131, 145, 146, 136, 137, 150, 147, 324, 325,
1714  326, 327, 328, 329, 330, 331, 332, 333, 334, 335,
1715  336, 337, 338, 339, 340, 341, 342, 343, 344, 345,
1716  346, 347, 348, 349, 350, 351, 61, 63, 58, 62,
1717  60, 124, 94, 38, 43, 45, 42, 47, 37, 352,
1718  33, 126, 353, 123, 125, 91, 44, 96, 40, 41,
1719  93, 59, 32, 10
1720 };
1721 # endif
1722 
1723 #define YYPACT_NINF -1028
1724 
1725 #define yypact_value_is_default(Yystate) \
1726  (!!((Yystate) == (-1028)))
1727 
1728 #define YYTABLE_NINF -760
1729 
1730 #define yytable_value_is_error(Yytable_value) \
1731  (!!((Yytable_value) == (-760)))
1732 
1733  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1734  STATE-NUM. */
1735 static const yytype_int16 yypact[] =
1736 {
1737  -1028, 133, 3772, -1028, 9176, -1028, -1028, -1028, 8634, -1028,
1738  -1028, -1028, -1028, -1028, -1028, -1028, 9302, 9302, -1028, -1028,
1739  -1028, 5241, 4800, -1028, -1028, -1028, -1028, 533, 8489, 1,
1740  100, 124, -1028, -1028, -1028, 4065, 4947, -1028, -1028, 4212,
1741  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, 10940, 10940,
1742  10940, 10940, 200, 6689, 9428, 9806, 10184, 8918, -1028, 8344,
1743  -1028, -1028, -1028, 155, 181, 247, 265, 1275, 11066, 10940,
1744  -1028, 232, -1028, 1140, -1028, 319, -1028, -1028, 14, 411,
1745  330, -1028, 332, 11318, -1028, 380, 2654, 644, 46, 425,
1746  -1028, 11192, 11192, -1028, -1028, 7671, 11440, 11562, 11684, 8198,
1747  9302, 819, 108, -1028, -1028, 456, -1028, -1028, -1028, -1028,
1748  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, 717, 729,
1749  -1028, 420, 783, -1028, -1028, -1028, -1028, -1028, -1028, -1028,
1750  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028,
1751  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028,
1752  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028,
1753  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028,
1754  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028,
1755  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028,
1756  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028,
1757  -1028, -1028, 432, -1028, -1028, -1028, 479, 10940, 524, 6840,
1758  10940, 10940, 10940, -1028, 10940, -1028, 503, 4337, 542, -1028,
1759  -1028, 513, 515, 267, 365, 614, 366, 545, -1028, -1028,
1760  7545, -1028, 9302, 9554, -1028, -1028, 7797, -1028, 11192, 858,
1761  -1028, 574, 6991, -1028, 7142, -1028, -1028, 598, 605, 14,
1762  -1028, 522, -1028, 718, 3380, 3380, 791, 9428, -1028, 6689,
1763  657, 232, -1028, 1140, 1, 682, -1028, 1140, 1, 665,
1764  371, 519, -1028, 542, 673, 519, -1028, 1, 763, 1275,
1765  11806, 677, -1028, 690, 708, 716, 724, -1028, -1028, -1028,
1766  -1028, -1028, 481, -1028, 580, 678, 953, -1028, -1028, -1028,
1767  -1028, 748, -1028, -1028, -1028, -1028, -1028, -1028, -1028, 7923,
1768  11192, 11192, 11192, 11192, 9428, 11192, 11192, -1028, -1028, -1028,
1769  721, -1028, -1028, -1028, -1028, -1028, 10310, -1028, 6689, 9047,
1770  684, 10310, -1028, 10940, 10940, 10940, 10940, 10940, -1028, -1028,
1771  10940, 10940, 10940, 10940, 10940, 10940, 10940, 10940, 10940, -1028,
1772  -1028, 10940, 10940, 10940, 10940, 10940, 10940, 10940, 10940, 10940,
1773  10940, -1028, -1028, 12269, 9302, 12359, 5833, 319, 86, 86,
1774  7293, 11192, 7293, 232, -1028, 691, 777, -1028, -1028, 741,
1775  822, 53, 68, 69, 681, 956, 11192, 733, -1028, 714,
1776  891, -1028, -1028, -1028, -1028, 130, 291, 527, 572, 582,
1777  586, 608, 653, 663, -1028, -1028, -1028, 666, -1028, -1028,
1778  -1028, 13619, -1028, -1028, 11066, 11066, -1028, -1028, 374, -1028,
1779  -1028, -1028, 618, 10940, 10940, 9680, -1028, -1028, 12449, 9302,
1780  12539, 10940, 10940, 9932, -1028, 1, 710, -1028, -1028, 10940,
1781  1, -1028, 711, 1, 722, -1028, 107, -1028, -1028, -1028,
1782  -1028, -1028, 8634, -1028, 10940, 726, 728, 12449, 12539, 10940,
1783  1140, 100, 1, -1028, -1028, 8049, 732, 1, -1028, -1028,
1784  10058, -1028, -1028, 10184, -1028, -1028, -1028, 574, 893, -1028,
1785  -1028, 734, 11806, 12629, 9302, 12719, -1028, -1028, -1028, -1028,
1786  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, 786, 101,
1787  988, 102, 10940, -1028, -1028, -1028, -1028, -1028, -1028, -1028,
1788  -1028, -1028, 757, -1028, -1028, -1028, 882, -1028, 882, 10940,
1789  -1028, 760, 767, 874, -1028, 1, 11806, 774, -1028, -1028,
1790  -1028, 880, 806, 4043, -1028, -1028, -1028, 963, 400, -1028,
1791  718, 3896, 3896, 3896, 3896, 4484, 3134, 3896, 3896, 3380,
1792  3380, 759, 759, 3267, 1222, 1222, 1464, 406, 406, 718,
1793  718, 718, 1115, 1115, 3482, 4359, 5535, 4506, -1028, 605,
1794  -1028, 1, 850, -1028, 1016, -1028, -1028, 5094, 882, 925,
1795  -1028, 5984, 922, 6437, 882, 60, 882, 914, 927, 76,
1796  12809, 9302, 12899, -1028, 319, -1028, 893, -1028, -1028, -1028,
1797  12989, 9302, 13079, 5833, 11192, -1028, -1028, -1028, -1028, -1028,
1798  -1028, 2683, -1028, 4190, -1028, -1028, -1028, 8634, 10940, -1028,
1799  10940, 542, -1028, 545, 3918, 4653, 1, 453, 458, -1028,
1800  -1028, -1028, -1028, 9680, -1028, 9932, -1028, -1028, 11192, 4337,
1801  -1028, -1028, 605, 605, -1028, -1028, -9, -1028, -1028, 519,
1802  11806, 734, 381, 686, 1, 362, 407, -1028, -1028, 1249,
1803  -1028, 566, -1028, 794, -1028, -1028, 568, 795, -1028, 718,
1804  -1028, -1028, 804, -1028, -1028, -1028, -1028, 812, 10436, 9428,
1805  -1028, 734, 11806, 9428, 11066, 10940, 13169, 9302, 13259, 12202,
1806  832, 11066, 11066, -1028, 721, 816, 1020, 11066, 11066, -1028,
1807  -1028, 721, -1028, -1028, -1028, 10562, 755, -1028, 825, -1028,
1808  950, -1028, -1028, -1028, -1028, -1028, -1028, 927, 882, -1028,
1809  10688, 882, 33, 278, 1, 77, 83, 7293, 232, 11192,
1810  5833, 995, 686, -1028, 1, 882, 107, 820, 8779, 108,
1811  411, -1028, -1028, -1028, -1028, 10940, 10940, 462, 10940, 10940,
1812  824, 107, -1028, -1028, 626, -1028, -1028, -1028, -1028, -1028,
1813  -1028, -1028, -1028, -1028, -1028, -1028, -1028, 843, -1028, 843,
1814  10940, 833, -1028, 734, -1028, 4337, 5388, 5682, 1, 466,
1815  470, -1028, -1028, 3091, 3091, 751, -1028, 616, 345, -1028,
1816  940, 899, -1028, 871, -1028, -1028, 815, -1028, -1028, 336,
1817  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, 10940,
1818  -1028, -1028, -1028, -1028, -1028, -1028, 11066, -1028, -1028, -1028,
1819  -1028, -1028, 760, -1028, 904, -1028, -1028, -1028, 7293, -1028,
1820  -1028, -1028, -1028, 7293, 11192, 882, -1028, -1028, 882, -1028,
1821  -1028, 882, -1028, 10940, -1028, 54, -1028, 113, 882, 5833,
1822  232, 882, -1028, -1028, -1028, 1877, 5833, 1686, -1028, -1028,
1823  -1028, 10940, 9932, -1028, 1519, -1028, 1385, 7142, -1028, -1028,
1824  5833, 862, 538, -1028, -1028, -1028, -1028, 12202, 12083, -1028,
1825  257, 866, -1028, -1028, -1028, 964, -1028, 12202, 3091, 3091,
1826  751, 616, 547, 3621, 3621, 4337, -1028, -1028, 11928, 86,
1827  -1028, -1028, 6563, -1028, 86, -1028, -1028, -1028, -1028, -1028,
1828  10814, 6135, -1028, 882, -1028, -1028, -1028, -1028, -1028, -1028,
1829  -1028, -1028, -1028, -1028, 1537, -1028, -1028, -1028, -1028, -1028,
1830  -1028, 1, 1, -1028, -1028, 896, -1028, 877, 10940, -1028,
1831  883, 106, 887, 887, -1028, 894, 980, 895, 987, -1028,
1832  882, 232, 820, 1686, -1028, -1028, -1028, -1028, 1, 912,
1833  920, 901, 12050, -1028, 911, 887, 887, -1028, 916, 918,
1834  -1028, 929, -1028, -1028, 276, 27, 3, 1, 12169, -1028,
1835  919, -1028, -1028, 1, 932, -1028, 12202, -1028, -1028, 348,
1836  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028,
1837  1, 1, 1, 1, 994, -1028, 1025, 118, 135, 179,
1838  5833, 1078, 5984, 3621, 10940, -1028, 92, -1028, 1537, 1208,
1839  -1028, 949, 1, 954, -1028, -1028, -1028, 10940, 1686, -1028,
1840  -1028, 1060, -1028, -1028, -1028, -1028, 216, -1028, -1028, 1686,
1841  -1028, -1028, 1096, -1028, -1028, -1028, -1028, 5833, 1, 63,
1842  7419, 972, -1028, 12050, 1686, -1028, 1049, 1030, 1060, -1028,
1843  -1028, -1028, 1686, -1028, 1096, -1028, 1424, -1028, 978, 12202,
1844  -1028, 43, 899, 982, -1028, 288, -1028, 257, 899, -1028,
1845  -1028, 1079, -1028, -1028, -1028, -1028, 222, 13349, 9302, 13439,
1846  925, -1028, 825, 86, 886, 255, -1028, -1028, -1028, -1028,
1847  -1028, -1028, 1, -1028, 1537, -1028, 1560, -1028, -1028, -1028,
1848  983, 986, -1028, 1082, 887, -1028, 989, -1028, 990, -1028,
1849  989, 882, 992, 5833, 7142, -1028, 1019, -1028, 1030, -1028,
1850  998, 1001, -1028, 13529, -1028, 887, 1003, -1028, 1011, 1003,
1851  -1028, 592, -1028, -1028, 12202, 1012, -1028, 1015, 12202, -1028,
1852  -1028, -1028, -1028, -1028, 134, 158, 1, 315, 318, -1028,
1853  -1028, -1028, 11192, 11192, 12083, -1028, -1028, 1017, 1021, 1686,
1854  -1028, 1096, -1028, -1028, 1096, -1028, 1096, -1028, -1028, -1028,
1855  -1028, 882, 1027, -1028, 1686, -1028, 1096, -1028, 1024, 1029,
1856  -1028, 1096, -1028, 1096, -1028, -1028, 1424, -1028, 1012, 12202,
1857  12202, 1012, 457, -1028, -1028, -1028, -1028, 1560, 1560, 989,
1858  1041, 989, 989, -1028, -1028, 1003, 1043, 1003, 1003, -1028,
1859  -1028, 1012, -1028, 1021, -1028, 1096, -1028, -1028, -1028, -1028,
1860  1096, -1028, -1028, -1028, 6286, 989, 1003, 150, -1028, -1028,
1861  -1028, -1028, -1028
1862 };
1863 
1864  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1865  Performed when YYTABLE does not specify something else to do. Zero
1866  means the default is an error. */
1867 static const yytype_uint16 yydefact[] =
1868 {
1869  2, 0, 0, 1, 0, 361, 362, 363, 0, 354,
1870  355, 356, 359, 357, 358, 360, 349, 350, 351, 352,
1871  372, 278, 278, 636, 635, 637, 638, 747, 0, 747,
1872  0, 0, 640, 639, 641, 729, 731, 632, 631, 730,
1873  634, 626, 627, 628, 629, 577, 646, 647, 0, 0,
1874  0, 0, 0, 0, 305, 759, 759, 95, 325, 597,
1875  597, 599, 601, 0, 0, 0, 0, 0, 0, 0,
1876  3, 745, 6, 9, 35, 40, 52, 67, 278, 66,
1877  0, 83, 0, 87, 97, 0, 61, 235, 250, 0,
1878  303, 0, 0, 63, 63, 745, 0, 0, 0, 0,
1879  314, 68, 323, 292, 293, 576, 578, 294, 295, 296,
1880  298, 297, 299, 575, 616, 617, 574, 624, 642, 643,
1881  300, 0, 301, 71, 5, 8, 176, 187, 177, 200,
1882  173, 193, 183, 182, 203, 204, 198, 181, 180, 175,
1883  201, 205, 206, 185, 174, 188, 192, 194, 186, 179,
1884  195, 202, 197, 196, 189, 199, 184, 172, 191, 190,
1885  171, 178, 169, 170, 166, 167, 168, 126, 128, 127,
1886  161, 162, 157, 139, 140, 141, 148, 145, 147, 142,
1887  143, 163, 164, 149, 150, 154, 158, 144, 146, 136,
1888  137, 138, 151, 152, 153, 155, 156, 159, 160, 165,
1889  131, 133, 28, 129, 130, 132, 0, 0, 0, 0,
1890  0, 0, 0, 597, 0, 273, 0, 257, 283, 81,
1891  277, 759, 0, 642, 643, 0, 301, 759, 723, 82,
1892  747, 79, 0, 759, 448, 78, 747, 748, 0, 0,
1893  23, 247, 0, 10, 0, 349, 350, 317, 449, 0,
1894  229, 0, 314, 230, 220, 221, 311, 0, 21, 0,
1895  0, 745, 17, 20, 747, 85, 16, 307, 747, 0,
1896  752, 752, 258, 0, 0, 752, 721, 747, 0, 0,
1897  0, 93, 353, 0, 103, 104, 111, 427, 621, 620,
1898  622, 619, 0, 618, 0, 0, 0, 584, 593, 589,
1899  595, 625, 56, 241, 242, 755, 756, 4, 757, 746,
1900  0, 0, 0, 0, 0, 0, 0, 364, 453, 442,
1901  72, 457, 322, 365, 457, 438, 0, 99, 0, 91,
1902  88, 0, 57, 0, 0, 0, 0, 0, 253, 254,
1903  0, 0, 0, 0, 218, 219, 0, 0, 0, 251,
1904  252, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1905  0, 741, 742, 0, 759, 0, 0, 62, 0, 0,
1906  0, 0, 0, 745, 333, 746, 0, 383, 382, 0,
1907  0, 642, 643, 301, 121, 122, 0, 0, 124, 650,
1908  0, 642, 643, 301, 341, 196, 189, 199, 184, 166,
1909  167, 168, 126, 127, 719, 343, 718, 0, 80, 744,
1910  743, 0, 324, 579, 0, 0, 134, 726, 311, 284,
1911  728, 280, 0, 0, 0, 0, 274, 282, 0, 759,
1912  0, 0, 0, 0, 275, 747, 0, 316, 279, 677,
1913  747, 269, 759, 747, 759, 268, 747, 321, 55, 25,
1914  27, 26, 0, 318, 0, 0, 0, 0, 0, 0,
1915  19, 0, 747, 309, 15, 746, 84, 747, 306, 312,
1916  754, 753, 259, 754, 261, 313, 722, 0, 110, 625,
1917  101, 96, 0, 0, 759, 0, 326, 428, 603, 623,
1918  606, 604, 598, 580, 581, 600, 582, 602, 0, 0,
1919  0, 0, 0, 758, 7, 29, 30, 31, 32, 33,
1920  53, 54, 0, 454, 453, 73, 0, 458, 0, 0,
1921  36, 288, 0, 39, 287, 747, 0, 89, 100, 51,
1922  41, 49, 0, 262, 283, 207, 37, 0, 301, 58,
1923  227, 234, 236, 237, 238, 245, 246, 239, 240, 216,
1924  217, 243, 244, 747, 231, 232, 233, 222, 223, 224,
1925  225, 226, 255, 256, 732, 734, 733, 735, 447, 278,
1926  445, 747, 732, 734, 733, 735, 446, 278, 0, 759,
1927  374, 0, 373, 0, 0, 0, 0, 331, 0, 311,
1928  0, 759, 0, 63, 339, 121, 122, 123, 648, 337,
1929  0, 759, 0, 0, 0, 344, 739, 740, 346, 732,
1930  733, 278, 42, 262, 208, 48, 215, 0, 0, 725,
1931  0, 285, 281, 759, 732, 733, 747, 732, 733, 724,
1932  315, 749, 264, 270, 265, 272, 320, 24, 0, 248,
1933  11, 34, 0, 759, 214, 22, 86, 18, 308, 752,
1934  0, 94, 736, 109, 747, 732, 733, 429, 607, 0,
1935  583, 0, 586, 0, 591, 588, 0, 0, 592, 228,
1936  451, 455, 0, 371, 452, 459, 437, 291, 0, 0,
1937  98, 92, 0, 0, 0, 0, 0, 759, 0, 0,
1938  0, 0, 0, 444, 76, 0, 450, 0, 0, 267,
1939  443, 74, 266, 304, 366, 759, 759, 566, 759, 375,
1940  759, 329, 377, 64, 376, 330, 468, 0, 0, 368,
1941  0, 0, 736, 310, 747, 732, 733, 0, 0, 0,
1942  0, 121, 122, 125, 747, 0, 747, 653, 0, 439,
1943  69, 135, 727, 286, 276, 0, 0, 450, 0, 0,
1944  759, 747, 260, 102, 450, 430, 608, 612, 613, 614,
1945  605, 615, 585, 587, 594, 590, 596, 759, 70, 759,
1946  0, 289, 38, 90, 50, 263, 732, 733, 747, 732,
1947  733, 560, 564, 0, 0, 0, 505, 499, 502, 558,
1948  0, 59, 485, 487, 489, 492, 539, 544, 545, 546,
1949  549, 550, 551, 552, 553, 555, 554, 556, 557, 0,
1950  47, 212, 46, 213, 77, 750, 0, 44, 210, 45,
1951  211, 75, 567, 568, 759, 569, 367, 369, 0, 12,
1952  14, 573, 370, 0, 0, 0, 378, 380, 0, 65,
1953  469, 0, 335, 0, 461, 0, 334, 450, 0, 0,
1954  0, 0, 450, 342, 720, 676, 0, 676, 347, 440,
1955  441, 0, 271, 319, 676, 609, 747, 0, 418, 417,
1956  0, 290, 450, 547, 548, 122, 562, 0, 0, 501,
1957  0, 0, 504, 427, 561, 0, 60, 0, 542, 543,
1958  0, 491, 490, 0, 0, 249, 43, 209, 0, 0,
1959  571, 572, 0, 381, 0, 327, 328, 470, 332, 462,
1960  0, 0, 336, 0, 649, 338, 683, 680, 679, 678,
1961  681, 689, 698, 677, 0, 710, 699, 714, 713, 709,
1962  675, 747, 747, 682, 684, 685, 687, 661, 691, 696,
1963  759, 702, 759, 759, 707, 661, 712, 661, 0, 659,
1964  0, 0, 653, 676, 431, 434, 610, 416, 747, 0,
1965  685, 401, 693, 694, 759, 759, 759, 705, 401, 401,
1966  399, 421, 456, 460, 747, 519, 507, 747, 508, 514,
1967  0, 534, 597, 747, 525, 530, 533, 527, 529, 537,
1968  751, 559, 486, 488, 540, 541, 563, 498, 495, 597,
1969  747, 747, 747, 747, 0, 570, 0, 642, 643, 301,
1970  0, 759, 0, 0, 0, 463, 759, 340, 0, 394,
1971  386, 388, 747, 391, 384, 651, 652, 0, 0, 668,
1972  690, 0, 656, 717, 700, 701, 0, 658, 657, 0,
1973  671, 711, 0, 673, 715, 345, 654, 0, 747, 0,
1974  0, 0, 419, 0, 407, 409, 0, 692, 0, 396,
1975  398, 397, 0, 412, 0, 414, 0, 506, 517, 0,
1976  500, 512, 523, 509, 515, 0, 503, 526, 532, 538,
1977  536, 0, 493, 494, 496, 497, 311, 0, 759, 0,
1978  759, 13, 759, 0, 477, 480, 483, 484, 464, 466,
1979  467, 465, 747, 393, 0, 686, 0, 703, 660, 688,
1980  661, 661, 697, 702, 759, 716, 661, 708, 661, 685,
1981  661, 0, 0, 0, 0, 432, 0, 420, 704, 400,
1982  401, 401, 311, 0, 695, 759, 401, 706, 401, 401,
1983  425, 747, 423, 426, 0, 520, 521, 510, 0, 516,
1984  535, 531, 524, 528, 736, 310, 747, 732, 733, 565,
1985  379, 471, 0, 0, 481, 385, 387, 389, 392, 0,
1986  664, 0, 666, 655, 0, 672, 0, 669, 674, 348,
1987  433, 0, 0, 611, 0, 404, 0, 406, 736, 310,
1988  395, 0, 413, 0, 410, 415, 0, 422, 518, 0,
1989  0, 513, 450, 472, 478, 479, 482, 0, 0, 661,
1990  661, 661, 661, 436, 435, 401, 401, 401, 401, 424,
1991  522, 511, 473, 390, 665, 0, 662, 667, 670, 405,
1992  0, 402, 408, 411, 0, 661, 401, 759, 663, 403,
1993  475, 476, 474
1994 };
1995 
1996  /* YYPGOTO[NTERM-NUM]. */
1997 static const yytype_int16 yypgoto[] =
1998 {
1999  -1028, -1028, -1028, 923, -1028, 62, 730, -552, -1028, -35,
2000  -1028, 731, -1028, 72, -1028, -212, -254, -66, -1028, -1028,
2001  -1028, -32, -88, -1028, -1028, -36, -1028, -260, 641, 25,
2002  1106, -141, -6, -68, -1028, -410, -19, 2212, -370, 1108,
2003  -40, -24, -1028, -1028, 5, -1028, 2954, -1028, 1121, -1028,
2004  1541, -1028, 652, 426, 601, -307, 94, -10, -1028, -360,
2005  -218, 66, -1028, -310, -52, -1028, -1028, -1028, -1028, -1028,
2006  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, 32,
2007  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028,
2008  -1028, -1028, -1028, -1028, -1028, 509, -1028, 210, 981, -368,
2009  -1028, 126, -700, -1028, -1024, -1001, 198, 116, 355, 317,
2010  -1028, 461, -1028, -860, -1028, 30, 350, -1028, -1028, -1028,
2011  -1028, -1028, -1028, -1028, 494, -1028, -1028, -95, 723, -1028,
2012  -1028, -1028, 915, -1028, -1028, -1028, -1028, -680, -1028, -1,
2013  -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -1028, -526,
2014  -1028, -1028, -1028, -1028, 354, -1028, -1028, -1028, -824, -1028,
2015  230, -609, -594, -781, -1028, 177, -1028, 178, 190, -1028,
2016  -376, -1028, 373, -1028, -1028, 166, -1028, -1028, 263, 485,
2017  499, -1028, 1171, 747, 1110, 1394, -1028, 780, 1448, -1028,
2018  1612, 1744, -1028, -1028, -57, -1028, -1028, -199, -1028, -1028,
2019  -1028, -1028, -1028, -1028, -1028, 0, -1028, -1028, -1028, -1028,
2020  -37, 2020, 1174, 1178, 2236, 1512, -1028, -1028, 329, -1028,
2021  -705, 314, -773, 429, -1027, -785, -603, -908, 236, -200,
2022  258, 243, -1028, -1028, -503, -690, -213, -984, -987, 234,
2023  274, -1028, -846, -1028, -513, -379, -1028, -1028, -1028, 6,
2024  -417, -1028, -275, -1028, -1028, -87, -1028, -71, 23, 185,
2025  -583, 322, -194, -60, -44, -2
2026 };
2027 
2028  /* YYDEFGOTO[NTERM-NUM]. */
2029 static const yytype_int16 yydefgoto[] =
2030 {
2031  -1, 1, 2, 70, 71, 72, 243, 578, 902, 579,
2032  261, 262, 461, 263, 452, 74, 530, 75, 539, 689,
2033  886, 368, 370, 371, 839, 76, 77, 515, 249, 79,
2034  80, 264, 81, 82, 83, 481, 84, 216, 388, 389,
2035  200, 201, 202, 617, 567, 204, 86, 454, 359, 87,
2036  218, 269, 535, 568, 700, 440, 441, 231, 232, 220,
2037  426, 442, 523, 524, 88, 366, 268, 467, 638, 287,
2038  717, 588, 730, 728, 603, 605, 737, 738, 952, 251,
2039  90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
2040  321, 324, 705, 828, 720, 833, 834, 674, 252, 581,
2041  713, 835, 836, 380, 1020, 1021, 1022, 1023, 1129, 1055,
2042  958, 867, 868, 959, 1141, 1142, 486, 487, 657, 755,
2043  864, 1049, 954, 1125, 325, 101, 102, 322, 512, 513,
2044  671, 767, 516, 517, 675, 769, 845, 721, 1101, 718,
2045  840, 907, 1013, 1203, 1222, 1234, 1242, 1093, 1094, 1072,
2046  792, 793, 893, 894, 794, 878, 880, 877, 977, 978,
2047  979, 1145, 980, 983, 984, 985, 986, 987, 988, 795,
2048  796, 883, 797, 798, 799, 706, 824, 899, 830, 103,
2049  104, 105, 106, 107, 108, 109, 498, 661, 110, 500,
2050  111, 112, 499, 501, 292, 295, 296, 492, 659, 658,
2051  756, 865, 956, 1050, 760, 113, 114, 293, 115, 116,
2052  117, 223, 224, 120, 225, 226, 599, 729, 856, 857,
2053  1108, 1029, 931, 443, 933, 934, 1119, 936, 937, 938,
2054  939, 963, 964, 940, 941, 942, 943, 944, 967, 968,
2055  945, 946, 947, 948, 949, 1032, 407, 604, 274, 444,
2056  228, 123, 642, 570, 608, 602, 411, 307, 436, 437,
2057  696, 882, 472, 582, 375, 266
2058 };
2059 
2060  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
2061  positive, shift that token. If negative, reduce the rule whose
2062  number is the opposite. If YYTABLE_NINF, syntax error. */
2063 static const yytype_int16 yytable[] =
2064 {
2065  124, 583, 365, 294, 240, 282, 372, 412, 205, 434,
2066  838, 308, 235, 203, 410, 330, 629, 597, 260, 291,
2067  969, 536, 227, 227, 374, 367, 367, 309, 205, 367,
2068  301, 282, 302, 203, 89, 308, 89, 841, 281, 1143,
2069  317, 215, 215, 747, 282, 282, 282, 265, 222, 222,
2070  238, 735, 241, 272, 276, 1117, 629, 571, -116, 405,
2071  369, 271, 275, 373, 203, 622, 125, 580, 320, 1000,
2072  1002, 754, 651, 622, 73, 1137, 73, 474, -112, 1068,
2073  1166, 476, 221, 221, 951, 89, 89, 712, 569, 283,
2074  577, 955, 1123, -113, -120, 1147, 495, 497, 1051, 580,
2075  222, -119, -115, 885, 203, 1168, 227, 827, -117, 719,
2076  219, 229, 1001, 1003, -353, 283, 681, -84, 462, 529,
2077  1109, 270, 626, 222, 222, 215, 267, 222, 379, 390,
2078  390, -112, 222, 3, 317, 430, 611, -98, -114, 1024,
2079  1034, 847, -353, -353, 315, 316, 1109, -116, -113, -523,
2080  930, 852, 930, 569, 237, 577, 422, 318, 1035, 930,
2081  612, 615, 233, 791, 458, 827, 221, 663, 667, 1143,
2082  446, -118, 448, 1069, 260, 716, 965, 654, 851, -107,
2083  1048, -732, 1111, 643, 1166, 1117, 1124, 525, 1122, 1148,
2084  464, -353, -120, 1118, 408, 872, 485, 1137, -636, -103,
2085  910, 308, 529, 529, 879, 305, 1223, 306, 1131, 456,
2086  643, 305, 480, 306, -104, -111, 1138, 465, 629, 427,
2087  664, 668, -110, -106, 260, 427, 434, -636, 282, -108,
2088  733, 445, 1097, 1024, 1103, -119, 227, 305, 227, 306,
2089  124, 89, 479, 242, 367, 367, 367, 367, 930, 510,
2090  511, 318, 935, 265, 935, 215, 256, 215, 215, -105,
2091  237, 935, 222, 960, 222, 222, 1109, 244, 222, -112,
2092  222, -112, 773, 622, 89, 622, 89, 282, 505, 506,
2093  507, 508, -732, 1109, 724, -116, -113, -116, -113, 89,
2094  520, 89, 592, 260, 734, 531, 221, 913, 221, 662,
2095  477, 662, 587, -118, 950, 367, -733, 297, 997, -118,
2096  527, -118, 283, 308, 73, 981, 1099, 643, 973, 1024,
2097  594, 1024, 265, 1210, 435, 927, 438, 643, -115, 460,
2098  -120, -117, -120, 298, 922, 584, 1100, 586, 1216, 585,
2099  1206, 89, 222, 222, 222, 222, 89, 222, 222, 928,
2100  935, 974, 976, 970, 488, 885, 315, 316, 222, -635,
2101  89, 283, 445, 537, 965, 926, -644, 976, 976, 982,
2102  575, 504, 965, -119, 965, -119, 885, 989, 531, 531,
2103  778, 73, 1079, 305, 1073, 306, 509, -106, -635, 215,
2104  989, 989, 522, -112, 1070, 823, 222, 522, 89, 299,
2105  1080, 1164, 89, 222, 89, 744, -107, 873, 874, 490,
2106  491, 569, 1150, 577, 480, 876, 575, 300, 222, 1084,
2107  1085, 447, 1024, 1024, -109, 935, -733, 445, 637, 237,
2108  282, 623, -108, 890, 814, 575, 935, 810, 812, 323,
2109  427, 821, 427, 817, 819, 629, 537, 537, 234, 466,
2110  688, 960, 205, 468, 215, 752, 326, 203, 480, 960,
2111  1078, 222, 763, 575, -645, 432, -115, 763, -115, -117,
2112  -114, -117, 529, 459, 282, 1146, 649, 911, 327, 529,
2113  529, 891, 445, 333, 892, 529, 529, 1095, -106, -747,
2114  575, -113, -120, 361, 965, 1121, 965, 89, 237, 415,
2115  -119, 965, 622, 965, 319, 727, 331, -107, -106, 215,
2116  989, -106, 994, 995, 283, -106, 222, 470, 1115, 414,
2117  996, 362, 363, 1115, 471, 714, -120, -107, 1113, -732,
2118  -107, 1010, 744, -108, -107, 1198, 1012, 1240, 736, 1201,
2119  965, 970, 356, 357, 358, 1115, 708, 488, 710, 970,
2120  1146, 970, 748, -108, 1146, 1113, -108, 749, 283, 694,
2121  -108, 861, 896, 1037, 1038, 697, 935, 701, 60, 698,
2122  364, 1181, 751, 1202, 989, 702, 690, 707, 416, -115,
2123  418, 960, 753, 361, -117, 1059, 1060, 1061, -114, 445,
2124  361, 1221, -115, 741, 695, -637, -117, 575, 282, 445,
2125  489, 740, 490, 491, 529, 1220, 1146, 575, -114, 702,
2126  -114, 362, 428, 89, 480, 89, 215, 205, 362, 457,
2127  630, 427, 203, 222, -637, 632, 215, 236, 634, 423,
2128  282, 636, 488, 222, 488, 89, 222, 816, 976, 750,
2129  -638, 702, 424, 78, 859, 78, 488, 646, 531, 695,
2130  -640, -105, 648, 966, -639, 531, 531, 78, 78, 425,
2131  429, 531, 531, 367, -114, 473, 962, 429, 849, -638,
2132  222, 970, 471, 970, 234, 319, -641, 695, 970, -640,
2133  970, 236, 283, -639, 488, 445, 237, 490, 491, 490,
2134  491, 433, 848, 575, 78, 78, -747, 850, 858, 493,
2135  237, 490, 491, 825, 831, -641, 837, -729, 837, 78,
2136  680, 89, 215, 431, 283, 89, 537, 970, 762, 222,
2137  765, -630, 453, 537, 537, 1161, 338, 339, 676, 537,
2138  537, -633, 78, 78, 606, 1173, 78, 493, 1196, 490,
2139  491, 78, 618, 203, 488, 237, 230, 695, 427, -630,
2140  -630, 772, -105, 233, -310, 774, 1190, 695, 361, 89,
2141  -633, 222, 89, 607, 826, 869, -747, 869, 367, 237,
2142  827, 522, -105, 349, 350, -105, -642, -630, -630, -105,
2143  531, 1156, -310, -310, -643, 595, 362, 483, 703, 596,
2144  914, 576, -301, 901, 711, 333, 715, 494, 903, 490,
2145  491, 695, 904, 595, -642, -642, 463, 875, -83, 361,
2146  695, 881, -643, -643, 643, 469, -644, 475, 1114, 478,
2147  -301, -301, 900, 482, -729, 502, -630, 514, -645, -729,
2148  528, -310, 972, 589, -733, 484, 333, 362, 590, 832,
2149  827, 966, 503, -112, 598, 1135, 282, 593, 537, 966,
2150  78, 966, 488, -642, 962, -113, 576, 633, 962, 631,
2151  89, -643, 962, -103, 962, 89, 222, 1011, 635, -301,
2152  640, 78, 641, 78, 78, -104, 1016, 78, -98, 78,
2153  650, 89, 415, 78, 576, 78, 591, 361, 89, 971,
2154  459, 1046, 673, 354, 355, 356, 357, 358, 78, 89,
2155  78, 670, 89, 888, 889, 660, -283, 490, 491, -120,
2156  282, 576, 449, 678, 695, 362, 409, -119, 679, 1089,
2157  682, 854, 450, 451, 683, 1075, 1162, 1163, 842, -111,
2158  1006, 846, 684, 704, 89, 709, 863, -110, 1033, 716,
2159  1033, 1033, 1081, 89, 719, 853, 764, 766, 768, 697,
2160  78, 78, 78, 78, 78, 78, 78, 78, -284, 361,
2161  809, -311, 1033, 1033, 1033, 827, 815, 78, 855, 78,
2162  862, 966, 78, 966, 866, 1090, -115, 1092, 966, -285,
2163  966, 971, -730, 100, 962, 100, 962, 362, 600, -311,
2164  -311, 962, 884, 962, 1057, 693, -106, 100, 100, 885,
2165  695, 282, 887, 699, 898, 78, 881, 78, -286, 831,
2166  990, 78, 78, 78, 837, 1126, 781, 966, 576, 488,
2167  496, -736, 1027, 1028, -633, 695, 695, 78, 576, 1031,
2168  962, 361, 1041, 1036, 100, 100, 601, 699, -311, 1044,
2169  1039, 1042, 89, 1052, 89, 905, 1053, 1054, 906, 100,
2170  1086, 908, -633, -633, 488, 78, 78, 1058, 912, 362,
2171  686, 915, 1062, -736, 1064, 1074, 614, 616, 693, 699,
2172  78, 971, 100, 100, 490, 491, 100, 998, 1077, 89,
2173  1066, 100, 89, 614, 616, 1128, 445, 826, 707, 1182,
2174  837, -736, -736, 361, 575, 1104, 367, 367, 361, -730,
2175  1106, -633, 961, 1127, -730, 1132, 78, 665, 687, 490,
2176  491, 644, 1033, 215, 576, 698, 1025, 1026, 921, 816,
2177  222, 362, 1087, 1017, 1144, 78, 362, 1133, 1149, 1169,
2178  1204, 1205, 1171, 1033, 1035, 1174, 1176, 922, -736, 1183,
2179  -736, 1180, -117, -732, 1184, 488, -114, 1186, 916, 1191,
2180  917, 918, 919, 920, 921, 89, 89, 1193, 1199, 1067,
2181  1045, 1200, -108, 1207, 1197, 455, -105, 1208, 926, 927,
2182  1088, 1214, -732, 922, 800, 601, 119, -733, 119, 695,
2183  310, 311, 312, 313, 314, 1082, 1083, 1225, 801, 1230,
2184  100, 645, 333, 928, 222, 222, 647, 924, 493, 1237,
2185  490, 491, 377, 1150, 926, 927, 394, 1105, 360, 346,
2186  347, 100, 739, 100, 100, 829, 1102, 100, 1160, 100,
2187  1167, 957, 78, 100, 78, 100, 1219, 119, 119, 928,
2188  870, 285, 78, 991, 860, 837, 1241, 672, 100, 518,
2189  100, 993, 78, 1096, 78, 78, 351, 352, 353, 354,
2190  355, 356, 357, 358, 1151, 1152, 1159, 285, 992, 1040,
2191  916, 1043, 917, 918, 919, 920, 89, 1153, 800, 800,
2192  382, 392, 392, 392, 1091, 1116, 413, 406, 1120, 78,
2193  666, 1047, 801, 801, 932, 1063, 1065, 1165, 1130, 1112,
2194  100, 100, 100, 100, 100, 100, 100, 100, 1136, 333,
2195  1139, 1134, 1110, 757, 758, 1076, 759, 100, 0, 100,
2196  0, 0, 100, 46, 47, 0, 346, 347, 0, 0,
2197  78, 0, 0, 0, 78, 78, 0, 0, 78, 0,
2198  0, 1179, 78, 78, 41, 42, 43, 44, 78, 78,
2199  0, 0, 0, 811, 813, 100, 0, 100, 0, 818,
2200  820, 100, 100, 100, 0, 353, 354, 355, 356, 357,
2201  358, 0, 800, 800, 0, 0, 0, 100, 78, 0,
2202  78, 78, 800, 800, 800, 0, 801, 801, 800, 800,
2203  0, 0, 0, 119, 0, 0, 801, 801, 801, 0,
2204  0, 1213, 801, 801, 0, 100, 100, 811, 813, 0,
2205  818, 820, 0, 0, 0, 1209, 0, 1211, 0, 0,
2206  100, 0, 1212, 0, 0, 0, 119, 0, 119, 0,
2207  1215, 0, 1217, 0, 1170, 1172, 0, 0, 0, 1218,
2208  1175, 119, 1177, 119, 1178, 0, 802, 916, 0, 917,
2209  918, 919, 920, 921, 0, 0, 100, 1185, 1187, 0,
2210  0, 0, 0, 1192, 285, 1194, 1195, 78, 0, 0,
2211  0, 1235, 922, 800, 0, 100, 1236, 0, 897, 78,
2212  0, 800, 0, 0, 78, 78, 1140, 801, 917, 918,
2213  919, 920, 0, 119, 0, 801, 924, 0, 119, 0,
2214  78, 0, 925, 926, 927, 0, 0, 78, 800, 0,
2215  0, 0, 119, 285, 0, 0, 0, 0, 78, 0,
2216  0, 78, 801, 897, 122, 576, 122, 0, 928, 0,
2217  0, 929, 0, 1224, 1226, 1227, 1228, 0, 0, 0,
2218  802, 802, 1229, 1231, 1232, 1233, 0, 0, 237, 0,
2219  119, 333, 0, 78, 119, 0, 119, 0, 0, 1238,
2220  0, 0, 78, 1239, 800, 0, 0, 0, 346, 347,
2221  0, 0, 100, 0, 100, 122, 122, 0, 801, 286,
2222  0, 916, 100, 917, 918, 919, 920, 921, 0, 0,
2223  0, 0, 100, 0, 100, 100, 0, 0, 0, 916,
2224  0, 917, 918, 919, 920, 286, 922, 273, 354, 355,
2225  356, 357, 358, 0, 0, 0, 0, 0, 383, 393,
2226  393, 0, 916, 0, 917, 918, 919, 920, 0, 100,
2227  924, 0, 0, 0, 802, 802, 925, 926, 927, 800,
2228  0, 0, 0, 800, 802, 802, 802, 0, 1018, 119,
2229  802, 802, 0, 801, 1019, 0, 0, 801, 0, 800,
2230  0, 78, 928, 78, 0, 929, 285, 0, 0, 0,
2231  100, 1018, 0, 801, 100, 100, 0, 953, 100, 0,
2232  0, 0, 100, 100, 0, 0, 0, 0, 100, 100,
2233  0, 0, 0, 0, 800, 800, 0, 0, 78, 0,
2234  0, 78, 0, 0, 0, 0, 0, 0, 801, 801,
2235  285, 0, 0, 0, 0, 0, 0, 0, 100, 0,
2236  100, 100, 0, 0, 0, 0, 0, 0, 0, 0,
2237  0, 122, 0, 0, 0, 802, 0, 0, 0, 78,
2238  0, 0, 0, 802, 0, 0, 0, 0, 916, 0,
2239  917, 918, 919, 920, 921, 0, 0, 0, 417, 0,
2240  0, 419, 420, 421, 122, 119, 122, 119, 0, 0,
2241  802, 0, 0, 922, 78, 78, 0, 0, 0, 122,
2242  0, 122, 0, 0, 0, 0, 0, 119, 0, 0,
2243  0, 0, 0, 0, 0, 0, 0, 924, 0, 0,
2244  0, 0, 286, 925, 926, 927, 0, 100, 0, 803,
2245  0, 0, 0, 78, 78, 0, 0, 0, 0, 100,
2246  0, 0, 0, 0, 100, 100, 802, 0, 0, 928,
2247  0, 122, 929, 0, 285, 0, 122, 0, 0, 0,
2248  100, 0, 0, 0, 0, 0, 0, 100, 0, 0,
2249  122, 286, 0, 538, 0, 0, 0, 0, 100, 0,
2250  0, 100, 0, 119, 0, 0, 285, 119, 0, 0,
2251  0, 0, 0, 808, 0, 0, 0, 521, 0, 0,
2252  0, 0, 534, 0, 0, 78, 0, 0, 122, 0,
2253  0, 0, 122, 100, 122, 0, 0, 0, 0, 0,
2254  0, 802, 100, 803, 803, 802, 0, 0, 0, 0,
2255  0, 119, 0, 0, 119, 0, 0, 0, 0, 0,
2256  0, 802, 0, 0, 0, 0, 0, 0, 0, 0,
2257  0, 0, 0, 0, 0, 0, 538, 538, 0, 916,
2258  0, 917, 918, 919, 920, 921, 0, 0, 0, 0,
2259  0, 0, 0, 0, 0, 0, 802, 802, 0, 0,
2260  0, 0, 0, 0, 922, 0, 0, 808, 808, 0,
2261  0, 0, 0, 0, 0, 619, 621, 0, 923, 0,
2262  0, 0, 0, 0, 273, 0, 0, 122, 924, 0,
2263  0, 0, 0, 0, 925, 926, 927, 803, 803, 0,
2264  0, 100, 0, 100, 286, 0, 0, 803, 803, 803,
2265  0, 0, 119, 803, 803, 0, 0, 119, 0, 0,
2266  928, 621, 0, 929, 273, 0, 0, 0, 0, 0,
2267  0, 0, 118, 119, 118, 0, 0, 0, 100, 0,
2268  119, 100, 0, 0, 0, 0, 0, 0, 286, 0,
2269  0, 119, 0, 0, 119, 0, 0, 0, 0, 0,
2270  0, 808, 808, 0, 0, 0, 0, 0, 0, 0,
2271  677, 808, 808, 808, 0, 0, 0, 808, 808, 100,
2272  0, 0, 1008, 118, 118, 0, 119, 284, 0, 0,
2273  0, 0, 0, 804, 0, 119, 0, 0, 803, 0,
2274  0, 0, 0, 122, 0, 122, 803, 0, 0, 0,
2275  0, 0, 0, 284, 100, 100, 0, 0, 0, 0,
2276  0, 0, 0, 0, 0, 122, 381, 391, 391, 391,
2277  0, 0, 0, 803, 0, 0, 0, 0, 0, 0,
2278  0, 0, 0, 0, 0, 0, 392, 805, 0, 0,
2279  0, 0, 0, 100, 100, 0, 0, 0, 0, 0,
2280  0, 0, 808, 0, 0, 0, 0, 0, 0, 742,
2281  808, 743, 286, 0, 0, 0, 0, 0, 0, 0,
2282  0, 761, 0, 0, 621, 0, 273, 804, 804, 803,
2283  0, 0, 0, 0, 119, 0, 119, 808, 0, 0,
2284  0, 122, 0, 0, 286, 122, 538, 0, 0, 0,
2285  0, 0, 0, 538, 538, 0, 0, 0, 0, 538,
2286  538, 0, 0, 0, 85, 100, 85, 0, 0, 771,
2287  0, 119, 0, 0, 119, 0, 0, 392, 0, 118,
2288  0, 805, 805, 0, 0, 0, 0, 0, 121, 122,
2289  121, 0, 122, 808, 0, 0, 822, 0, 0, 0,
2290  0, 0, 0, 0, 803, 0, 0, 0, 803, 0,
2291  0, 844, 118, 0, 118, 85, 85, 0, 0, 0,
2292  0, 804, 804, 0, 803, 0, 0, 118, 0, 118,
2293  0, 804, 804, 804, 0, 0, 0, 804, 804, 121,
2294  121, 0, 0, 0, 0, 0, 0, 119, 119, 0,
2295  284, 806, 0, 0, 0, 0, 0, 0, 378, 803,
2296  803, 871, 0, 0, 0, 0, 0, 0, 808, 0,
2297  0, 0, 808, 0, 0, 805, 805, 0, 538, 118,
2298  0, 0, 0, 0, 118, 805, 805, 805, 808, 0,
2299  122, 805, 805, 0, 0, 122, 0, 0, 118, 284,
2300  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2301  0, 122, 0, 0, 0, 0, 0, 0, 122, 0,
2302  0, 0, 804, 808, 808, 0, 0, 0, 0, 122,
2303  804, 0, 122, 0, 909, 0, 118, 0, 0, 0,
2304  118, 0, 118, 0, 0, 806, 806, 0, 0, 0,
2305  0, 0, 0, 273, 0, 0, 0, 804, 119, 0,
2306  1009, 0, 0, 0, 122, 0, 0, 0, 0, 0,
2307  0, 85, 0, 122, 0, 0, 805, 0, 0, 0,
2308  0, 0, 0, 807, 805, 0, 0, 0, 0, 0,
2309  0, 0, 0, 0, 0, 121, 0, 0, 0, 0,
2310  0, 1015, 0, 0, 85, 0, 85, 0, 0, 0,
2311  0, 805, 0, 804, 0, 0, 0, 0, 0, 85,
2312  0, 85, 0, 0, 393, 0, 0, 0, 121, 1030,
2313  121, 0, 0, 0, 0, 118, 0, 0, 0, 806,
2314  806, 0, 0, 121, 0, 121, 0, 0, 0, 806,
2315  806, 806, 284, 0, 0, 806, 806, 0, 0, 0,
2316  0, 0, 0, 0, 0, 0, 0, 805, 0, 0,
2317  0, 85, 122, 0, 122, 0, 85, 807, 807, 0,
2318  0, 0, 0, 0, 0, 0, 0, 0, 804, 0,
2319  85, 0, 804, 532, 0, 121, 284, 0, 0, 0,
2320  121, 0, 0, 0, 0, 1098, 0, 0, 804, 122,
2321  0, 0, 122, 0, 121, 393, 0, 121, 1107, 0,
2322  0, 0, 0, 0, 0, 0, 0, 0, 85, 0,
2323  0, 0, 85, 0, 85, 0, 0, 0, 0, 0,
2324  806, 0, 805, 804, 804, 0, 805, 0, 806, 0,
2325  0, 118, 121, 118, 0, 0, 121, 0, 121, 0,
2326  0, 0, 805, 0, 0, 0, 0, 0, 0, 0,
2327  0, 807, 807, 118, 0, 806, 532, 532, 0, 0,
2328  0, 807, 807, 807, 0, 122, 122, 807, 807, 0,
2329  0, 0, 0, 0, 0, 0, 0, 805, 805, 0,
2330  121, 121, 0, 0, 0, 0, 0, 0, 0, 0,
2331  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2332  284, 0, 0, 0, 0, 0, 0, 85, 0, 332,
2333  0, 806, 0, -759, 0, 0, 0, 0, 0, 0,
2334  0, -759, -759, -759, 0, 0, -759, -759, -759, 118,
2335  -759, 121, 284, 118, 0, 0, 0, 0, -759, -759,
2336  -759, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2337  -759, -759, 807, -759, -759, -759, -759, -759, 0, 0,
2338  807, 333, 334, 335, 336, 337, 338, 339, 340, 341,
2339  342, 343, 344, 345, 0, 0, 122, 118, 346, 347,
2340  118, -759, 0, 0, 0, 0, 806, 807, 0, 0,
2341  806, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2342  0, 0, 0, 0, 0, 0, 806, 0, 0, -759,
2343  -759, 348, 0, 349, 350, 351, 352, 353, 354, 355,
2344  356, 357, 358, 85, 0, 85, 0, 0, 0, 0,
2345  0, 0, 0, -759, 0, 0, 0, 0, 0, 0,
2346  0, 806, 806, 807, 0, 85, 0, 121, 0, 121,
2347  0, 0, 0, 0, 0, 0, -759, -759, 0, 0,
2348  0, 233, -759, 0, -759, 0, -759, 0, 0, 121,
2349  0, 0, 0, 0, 0, 0, 0, 0, 118, 0,
2350  0, 0, 0, 118, 0, 0, 0, 0, 0, 0,
2351  0, 0, 0, 0, 0, 0, 0, 0, 0, 118,
2352  0, 0, 0, 0, 0, 0, 118, 0, 0, 0,
2353  0, 0, 0, 0, 0, 0, 0, 118, 807, 0,
2354  118, 85, 807, 0, 0, 85, 532, 0, 0, 0,
2355  0, 0, 0, 532, 532, 0, 0, 0, 807, 532,
2356  532, 0, 0, 0, 0, 121, 0, 0, 1007, 121,
2357  121, 0, 118, 0, 0, 0, 0, 121, 121, 0,
2358  0, 118, 0, 121, 121, 0, 0, 0, 0, 85,
2359  0, 0, 85, 807, 807, 0, 0, 0, 0, 0,
2360  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2361  0, 0, 0, 121, 0, 0, 121, 0, 0, 0,
2362  217, 217, 0, 0, 0, 0, 0, 0, 0, 0,
2363  0, 0, 391, 0, 0, 0, 0, 0, 0, 0,
2364  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2365  0, 0, 250, 253, 254, 255, 0, 0, 0, 217,
2366  217, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2367  0, 0, 303, 304, 0, 0, 0, 0, 532, 0,
2368  118, 0, 118, 0, 0, 0, 0, 0, 0, 0,
2369  85, 0, 0, 0, 0, 85, 0, 0, 0, 0,
2370  0, 0, 121, 0, 217, 0, 0, 0, 0, 0,
2371  0, 85, 0, 0, 121, 0, 0, 118, 85, 121,
2372  118, 0, 0, 391, 0, 0, 0, 0, 0, 85,
2373  0, 0, 85, 0, 0, 121, 0, 0, 0, 0,
2374  0, 0, 121, 0, 0, 0, 0, 0, 0, 0,
2375  0, 0, 0, 121, 0, 0, 121, 0, 0, 0,
2376  1005, 0, 0, 0, 85, 0, 0, 0, 0, 0,
2377  0, 0, 0, 85, 23, 24, 25, 26, 0, 0,
2378  0, 0, 0, 0, 0, 0, 0, 0, 121, 0,
2379  32, 33, 34, 118, 118, 0, 0, 121, 0, 0,
2380  41, 42, 43, 44, 45, 0, 0, 0, 0, 0,
2381  0, 217, 0, 0, 217, 217, 217, 0, 303, 0,
2382  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2383  0, 0, 0, 0, 217, 0, 217, 217, 0, 0,
2384  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2385  0, 789, 59, 60, 61, 62, 63, 64, 65, 66,
2386  0, 333, 334, 335, 336, 337, 338, 339, 340, 0,
2387  342, 343, 85, 0, 85, 0, 0, 0, 346, 347,
2388  279, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2389  0, 0, 0, 0, 0, 0, 121, 0, 121, 0,
2390  0, 0, 0, 0, 118, 0, 0, 0, 0, 85,
2391  0, 0, 85, 349, 350, 351, 352, 353, 354, 355,
2392  356, 357, 358, 0, 0, 0, 0, 0, 0, 0,
2393  217, 0, 0, 121, 0, 533, 121, 540, 541, 542,
2394  543, 544, 0, 0, 545, 546, 547, 548, 549, 550,
2395  551, 552, 553, 0, 0, 554, 555, 556, 557, 558,
2396  559, 560, 561, 562, 563, 0, 0, 0, 217, 0,
2397  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2398  0, 0, 0, 0, 0, 85, 85, 0, 0, 0,
2399  0, 0, 0, 0, 333, 334, 335, 336, 337, 338,
2400  339, 340, 341, 342, 343, 344, 345, 0, 0, 121,
2401  121, 346, 347, 0, 0, 0, 0, 0, 613, 613,
2402  0, 0, 0, 0, 0, 0, 0, 613, 217, 217,
2403  0, 0, 0, 217, 0, 613, 613, 217, 0, 0,
2404  0, 0, 0, 255, 348, 0, 349, 350, 351, 352,
2405  353, 354, 355, 356, 357, 358, 0, 0, 639, 0,
2406  0, 0, 0, 613, 0, 0, 0, 0, 0, 0,
2407  237, 0, 0, 0, 217, 0, 0, 217, 0, 0,
2408  0, 0, 0, 0, 0, 0, 0, 0, 217, 0,
2409  0, 0, 0, 0, 0, 0, 85, 0, 0, 0,
2410  0, 0, 0, 0, 0, 0, 669, 333, 334, 335,
2411  336, 337, 338, 339, 340, 341, 342, 343, -760, -760,
2412  121, 0, 0, 217, 346, 347, 0, 0, 0, 0,
2413  0, 0, -736, 0, 0, 0, 0, 0, 0, 0,
2414  -736, -736, -736, 0, 0, 0, -736, -736, 0, -736,
2415  0, 0, 0, 0, 0, 0, 0, -736, -736, 349,
2416  350, 351, 352, 353, 354, 355, 356, 357, 358, -736,
2417  -736, 0, -736, -736, -736, -736, -736, 0, 0, 0,
2418  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2419  0, 0, 0, 0, 0, 217, 0, 0, 0, 0,
2420  -736, 0, 0, 0, 0, 217, 0, 0, 0, -736,
2421  -736, -736, -736, -736, -736, -736, -736, -736, -736, -736,
2422  -736, -736, 217, 0, 217, 0, -736, -736, -736, -736,
2423  0, 691, 0, 0, 0, 0, 0, 217, 0, 217,
2424  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2425  0, 0, -736, 0, 0, 0, 0, 0, -116, -736,
2426  0, -736, -736, -736, -736, -736, -736, -736, -736, -736,
2427  -736, 0, 0, 0, 0, -736, -736, -736, -107, 0,
2428  0, -736, 217, -736, 0, -736, 0, 0, 613, 775,
2429  0, 217, 0, 0, 0, 613, 613, 0, 0, 0,
2430  0, 613, 613, 0, 23, 24, 25, 26, 0, 217,
2431  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2432  32, 33, 34, 781, 217, 0, 0, 782, 0, 981,
2433  41, 42, 43, 44, 45, 0, 0, 0, 0, 0,
2434  0, 0, 0, 0, 0, 0, 0, 0, 922, 613,
2435  613, 0, 613, 613, 0, 0, 0, 0, 0, 0,
2436  0, 783, 784, 0, 0, 0, 0, 0, 0, 785,
2437  0, 0, 786, 0, 217, 787, 788, 0, 975, 926,
2438  0, 789, 59, 999, 61, 62, 63, 64, 65, 66,
2439  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2440  0, 0, 0, 790, 0, 0, 0, 0, 0, 0,
2441  279, 0, 0, 895, 0, 0, 0, 0, 0, 0,
2442  613, 0, -759, 4, 0, 5, 6, 7, 8, 9,
2443  0, 0, 0, 10, 11, 0, 0, 0, 12, 0,
2444  13, 14, 15, 16, 17, 18, 19, 217, 0, 0,
2445  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2446  0, 27, 0, 0, 0, 613, 217, 28, 29, 30,
2447  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2448  0, 41, 42, 43, 44, 45, 46, 47, 0, 0,
2449  0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
2450  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2451  0, 0, 50, 51, 217, 0, 0, 0, 0, 0,
2452  52, 0, 0, 53, 54, 0, 55, 56, 0, 57,
2453  0, 0, 58, 59, 60, 61, 62, 63, 64, 65,
2454  66, 0, 217, 0, 0, 0, 0, 0, 0, 0,
2455  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2456  0, 67, 68, 69, 0, 0, 0, 0, -736, 0,
2457  0, 0, 0, -759, 0, -759, -736, -736, -736, 0,
2458  0, -736, -736, -736, 0, -736, 0, 0, 0, 0,
2459  0, 0, 0, -736, -736, -736, -736, -736, 0, 0,
2460  0, 0, 0, 0, 0, -736, -736, 0, -736, -736,
2461  -736, -736, -736, 0, 0, 0, 0, 0, 217, 0,
2462  0, 0, 0, 333, -760, -760, -760, -760, 338, 339,
2463  0, 217, -760, -760, 0, 0, -736, 0, 0, 0,
2464  346, 347, 0, 0, 0, -736, -736, -736, -736, -736,
2465  -736, -736, -736, -736, -736, -736, -736, -736, 0, 0,
2466  0, 0, -736, -736, -736, -736, 0, 745, -736, 0,
2467  0, 0, 0, 0, -736, 349, 350, 351, 352, 353,
2468  354, 355, 356, 357, 358, 0, 0, 0, -736, 0,
2469  0, -736, 217, 0, -116, -736, -736, -736, -736, -736,
2470  -736, -736, -736, -736, -736, -736, -736, 0, 0, 0,
2471  0, -736, -736, -736, -736, -630, 0, -736, -736, -736,
2472  0, -736, 0, -630, -630, -630, 0, 0, -630, -630,
2473  -630, 0, -630, 0, 0, 0, 0, 685, 0, 0,
2474  -630, 0, -630, -630, -630, 0, 0, 0, 0, 0,
2475  0, 0, -630, -630, 0, -630, -630, -630, -630, -630,
2476  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2477  333, 334, 335, 336, 337, 338, 339, 340, 341, 342,
2478  343, 344, 345, -630, 0, 0, 0, 346, 347, 0,
2479  0, 0, -630, -630, -630, -630, -630, -630, -630, -630,
2480  -630, -630, -630, -630, -630, 0, 0, 0, 0, -630,
2481  -630, -630, -630, 0, -630, -630, 0, 0, 0, 0,
2482  348, -630, 349, 350, 351, 352, 353, 354, 355, 356,
2483  357, 358, 0, 0, 0, -630, 0, 0, -630, -257,
2484  0, -630, -630, -630, -630, -630, -630, -630, -630, -630,
2485  -630, -630, -630, -630, 0, 0, 0, 0, 0, -630,
2486  -630, -630, -633, 0, -630, -630, -630, 0, -630, 0,
2487  -633, -633, -633, 0, 0, -633, -633, -633, 0, -633,
2488  0, 0, 0, 0, 685, 0, 0, -633, 0, -633,
2489  -633, -633, 0, 0, 0, 0, 0, 0, 0, -633,
2490  -633, 0, -633, -633, -633, -633, -633, 0, 0, 0,
2491  0, 0, 0, 0, 0, 0, 0, 333, 334, 335,
2492  336, 337, 338, 339, 340, 341, 342, 343, 344, 345,
2493  -633, 0, 0, 0, 346, 347, 0, 0, 0, -633,
2494  -633, -633, -633, -633, -633, -633, -633, -633, -633, -633,
2495  -633, -633, 0, 0, 0, 0, -633, -633, -633, -633,
2496  0, -633, -633, 0, 0, 0, 0, 348, -633, 349,
2497  350, 351, 352, 353, 354, 355, 356, 357, 358, 0,
2498  0, 0, -633, 0, 0, -633, 0, 0, -633, -633,
2499  -633, -633, -633, -633, -633, -633, -633, -633, -633, -633,
2500  -633, 0, 0, 0, 0, 0, -633, -633, -633, -737,
2501  0, -633, -633, -633, 0, -633, 0, -737, -737, -737,
2502  0, 0, -737, -737, -737, 0, -737, 0, 0, 0,
2503  0, 0, 0, 0, -737, -737, -737, -737, -737, 0,
2504  0, 0, 0, 0, 0, 0, -737, -737, 0, -737,
2505  -737, -737, -737, -737, 0, 0, 0, 0, 0, 0,
2506  0, 0, 0, 0, 333, 334, 335, 336, 337, 338,
2507  339, 340, 341, 342, 343, 344, 345, -737, 0, 0,
2508  0, 346, 347, 0, 0, 0, -737, -737, -737, -737,
2509  -737, -737, -737, -737, -737, -737, -737, -737, -737, 0,
2510  0, 0, 0, -737, -737, -737, -737, 0, 0, -737,
2511  0, 0, 0, 0, 348, -737, 349, 350, 351, 352,
2512  353, 354, 355, 356, 357, 358, 0, 0, 0, -737,
2513  0, 0, -737, 0, 0, 0, -737, -737, -737, -737,
2514  -737, -737, -737, -737, -737, -737, -737, -737, 0, 0,
2515  0, 0, -737, -737, -737, -737, -738, 0, -737, -737,
2516  -737, 0, -737, 0, -738, -738, -738, 0, 0, -738,
2517  -738, -738, 0, -738, 0, 0, 0, 0, 0, 0,
2518  0, -738, -738, -738, -738, -738, 0, 0, 0, 0,
2519  0, 0, 0, -738, -738, 0, -738, -738, -738, -738,
2520  -738, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2521  0, 333, 334, 335, 336, 337, 338, 339, 0, 0,
2522  342, 343, 0, 0, -738, 0, 0, 0, 346, 347,
2523  0, 0, 0, -738, -738, -738, -738, -738, -738, -738,
2524  -738, -738, -738, -738, -738, -738, 0, 0, 0, 0,
2525  -738, -738, -738, -738, 0, 0, -738, 0, 0, 0,
2526  0, 0, -738, 349, 350, 351, 352, 353, 354, 355,
2527  356, 357, 358, 0, 0, 0, -738, 0, 0, -738,
2528  0, 0, 0, -738, -738, -738, -738, -738, -738, -738,
2529  -738, -738, -738, -738, -738, 0, 0, 0, 0, -738,
2530  -738, -738, -738, -310, 0, -738, -738, -738, 0, -738,
2531  0, -310, -310, -310, 0, 0, -310, -310, -310, 0,
2532  -310, 0, 0, 0, 0, 0, 0, 0, -310, 0,
2533  -310, -310, -310, 0, 0, 0, 0, 0, 0, 0,
2534  -310, -310, 0, -310, -310, -310, -310, -310, 0, 0,
2535  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2536  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2537  0, -310, 0, 0, 0, 0, 0, 0, 0, 0,
2538  -310, -310, -310, -310, -310, -310, -310, -310, -310, -310,
2539  -310, -310, -310, 0, 0, 0, 0, -310, -310, -310,
2540  -310, 0, 746, -310, 0, 0, 0, 0, 0, -310,
2541  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2542  0, 0, 0, -310, 0, 0, -310, 0, 0, -118,
2543  -310, -310, -310, -310, -310, -310, -310, -310, -310, -310,
2544  -310, -310, 0, 0, 0, 0, 0, -310, -310, -310,
2545  -449, 0, -310, -310, -310, 0, -310, 0, -449, -449,
2546  -449, 0, 0, -449, -449, -449, 0, -449, 0, 0,
2547  0, 0, 0, 0, 0, -449, -449, -449, -449, 0,
2548  0, 0, 0, 0, 0, 0, 0, -449, -449, 0,
2549  -449, -449, -449, -449, -449, 0, 0, 0, 0, 0,
2550  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2551  0, 0, 0, 0, 0, 0, 0, 0, -449, 0,
2552  0, 0, 0, 0, 0, 0, 0, -449, -449, -449,
2553  -449, -449, -449, -449, -449, -449, -449, -449, -449, -449,
2554  0, 0, 0, 0, -449, -449, -449, -449, 0, 0,
2555  -449, 0, 0, 0, 0, 0, -449, 0, 0, 0,
2556  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2557  -449, 0, 0, 0, 0, 0, 0, -449, 0, -449,
2558  -449, -449, -449, -449, -449, -449, -449, -449, -449, 0,
2559  0, 0, 0, -449, -449, -449, -449, -302, 233, -449,
2560  -449, -449, 0, -449, 0, -302, -302, -302, 0, 0,
2561  -302, -302, -302, 0, -302, 0, 0, 0, 0, 0,
2562  0, 0, -302, 0, -302, -302, -302, 0, 0, 0,
2563  0, 0, 0, 0, -302, -302, 0, -302, -302, -302,
2564  -302, -302, 0, 0, 0, 0, 0, 0, 0, 0,
2565  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2566  0, 0, 0, 0, 0, -302, 0, 0, 0, 0,
2567  0, 0, 0, 0, -302, -302, -302, -302, -302, -302,
2568  -302, -302, -302, -302, -302, -302, -302, 0, 0, 0,
2569  0, -302, -302, -302, -302, 0, 0, -302, 0, 0,
2570  0, 0, 0, -302, 0, 0, 0, 0, 0, 0,
2571  0, 0, 0, 0, 0, 0, 0, -302, 0, 0,
2572  -302, 0, 0, 0, -302, -302, -302, -302, -302, -302,
2573  -302, -302, -302, -302, -302, -302, 0, 0, 0, 0,
2574  0, -302, -302, -302, -759, 0, -302, -302, -302, 0,
2575  -302, 0, -759, -759, -759, 0, 0, -759, -759, -759,
2576  0, -759, 0, 0, 0, 0, 0, 0, 0, -759,
2577  -759, -759, -759, 0, 0, 0, 0, 0, 0, 0,
2578  0, -759, -759, 0, -759, -759, -759, -759, -759, 0,
2579  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2580  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2581  0, 0, -759, 0, 0, 0, 0, 0, 0, 0,
2582  0, -759, -759, -759, -759, -759, -759, -759, -759, -759,
2583  -759, -759, -759, -759, 0, 0, 0, 0, -759, -759,
2584  -759, -759, 0, 0, -759, 0, 0, 0, 0, 0,
2585  -759, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2586  0, 0, 0, 0, -759, 0, 0, 0, 0, 0,
2587  0, -759, 0, -759, -759, -759, -759, -759, -759, -759,
2588  -759, -759, -759, 0, 0, 0, 0, -759, -759, -759,
2589  -759, -317, 233, -759, -759, -759, 0, -759, 0, -317,
2590  -317, -317, 0, 0, -317, -317, -317, 0, -317, 0,
2591  0, 0, 0, 0, 0, 0, -317, 0, -317, -317,
2592  0, 0, 0, 0, 0, 0, 0, 0, -317, -317,
2593  0, -317, -317, -317, -317, -317, 0, 0, 0, 0,
2594  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2595  0, 0, 0, 0, 0, 0, 0, 0, 0, -317,
2596  0, 0, 0, 0, 0, 0, 0, 0, -317, -317,
2597  -317, -317, -317, -317, -317, -317, -317, -317, -317, -317,
2598  -317, 0, 0, 0, 0, -317, -317, -317, -317, 0,
2599  0, -317, 0, 0, 0, 0, 0, -317, 0, 0,
2600  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2601  0, -317, 0, 0, 0, 0, 0, 0, -317, 0,
2602  -317, -317, -317, -317, -317, -317, -317, -317, -317, -317,
2603  0, 0, 0, 0, 0, -317, -317, -317, -736, 230,
2604  -317, -317, -317, 0, -317, 0, -736, -736, -736, 0,
2605  0, 0, -736, -736, 0, -736, 0, 0, 0, 0,
2606  0, 0, 0, -736, -736, 0, 0, 0, 0, 0,
2607  0, 0, 0, 0, 0, -736, -736, 0, -736, -736,
2608  -736, -736, -736, 0, 0, 0, 0, 0, 0, 0,
2609  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2610  0, 0, 0, 0, 0, 0, -736, 0, 0, 0,
2611  0, 0, 0, 0, 0, -736, -736, -736, -736, -736,
2612  -736, -736, -736, -736, -736, -736, -736, -736, 0, 0,
2613  0, 0, -736, -736, -736, -736, 0, 691, 0, 0,
2614  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2615  0, 0, 0, 0, 0, 0, 0, 0, -736, 0,
2616  0, 0, 0, 0, -116, -736, 0, -736, -736, -736,
2617  -736, -736, -736, -736, -736, -736, -736, 0, 0, 0,
2618  0, -736, -736, -736, -736, -310, 0, -736, 0, -736,
2619  0, -736, 0, -310, -310, -310, 0, 0, 0, -310,
2620  -310, 0, -310, 0, 0, 0, 0, 0, 0, 0,
2621  -310, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2622  0, 0, -310, -310, 0, -310, -310, -310, -310, -310,
2623  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2624  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2625  0, 0, 0, -310, 0, 0, 0, 0, 0, 0,
2626  0, 0, -310, -310, -310, -310, -310, -310, -310, -310,
2627  -310, -310, -310, -310, -310, 0, 0, 0, 0, -310,
2628  -310, -310, -310, 0, 692, 0, 0, 0, 0, 0,
2629  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2630  0, 0, 0, 0, 0, -310, 0, 0, 0, 0,
2631  0, -118, -310, 0, -310, -310, -310, -310, -310, -310,
2632  -310, -310, -310, -310, 0, 0, 0, 0, 0, -310,
2633  -310, -109, -310, 0, -310, 0, -310, 0, -310, 0,
2634  -310, -310, -310, 0, 0, 0, -310, -310, 0, -310,
2635  0, 0, 0, 0, 0, 0, 0, -310, 0, 0,
2636  0, 0, 0, 0, 0, 0, 0, 0, 0, -310,
2637  -310, 0, -310, -310, -310, -310, -310, 0, 0, 0,
2638  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2639  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2640  -310, 0, 0, 0, 0, 0, 0, 0, 0, -310,
2641  -310, -310, -310, -310, -310, -310, -310, -310, -310, -310,
2642  -310, -310, 0, 0, 0, 0, -310, -310, -310, -310,
2643  0, 692, 0, 0, 0, 0, 0, 0, 0, 0,
2644  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2645  0, 0, -310, 0, 0, 0, 0, 0, -118, -310,
2646  0, -310, -310, -310, -310, -310, -310, -310, -310, -310,
2647  -310, 0, 0, 0, 0, 0, -310, -310, -310, 0,
2648  0, -310, 0, -310, 257, -310, 5, 6, 7, 8,
2649  9, -759, -759, -759, 10, 11, 0, 0, -759, 12,
2650  0, 13, 14, 15, 16, 17, 18, 19, 0, 0,
2651  0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
2652  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2653  258, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2654  40, 0, 41, 42, 43, 44, 45, 46, 47, 0,
2655  0, 0, 0, 0, 0, 0, 0, 0, 48, 49,
2656  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2657  0, 0, 0, 50, 51, 0, 0, 0, 0, 0,
2658  0, 52, 0, 0, 53, 54, 0, 55, 56, 0,
2659  57, 0, 0, 58, 59, 60, 61, 62, 63, 64,
2660  65, 66, 0, 0, 0, 0, 0, 0, 0, 0,
2661  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2662  0, 0, 67, 68, 69, 0, 0, 0, 0, 0,
2663  0, 0, 0, 0, -759, 257, -759, 5, 6, 7,
2664  8, 9, 0, 0, -759, 10, 11, 0, -759, -759,
2665  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2666  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2667  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2668  29, 258, 31, 32, 33, 34, 35, 36, 37, 38,
2669  39, 40, 0, 41, 42, 43, 44, 45, 46, 47,
2670  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
2671  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2672  0, 0, 0, 0, 50, 51, 0, 0, 0, 0,
2673  0, 0, 52, 0, 0, 53, 54, 0, 55, 56,
2674  0, 57, 0, 0, 58, 59, 60, 61, 62, 63,
2675  64, 65, 66, 0, 0, 0, 0, 0, 0, 0,
2676  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2677  0, 0, 0, 67, 68, 69, 0, 0, 0, 0,
2678  0, 0, 0, 0, 0, -759, 257, -759, 5, 6,
2679  7, 8, 9, 0, 0, -759, 10, 11, 0, 0,
2680  -759, 12, -759, 13, 14, 15, 16, 17, 18, 19,
2681  0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2682  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2683  28, 29, 258, 31, 32, 33, 34, 35, 36, 37,
2684  38, 39, 40, 0, 41, 42, 43, 44, 45, 46,
2685  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2686  48, 49, 0, 0, 0, 0, 0, 0, 0, 0,
2687  0, 0, 0, 0, 0, 50, 51, 0, 0, 0,
2688  0, 0, 0, 52, 0, 0, 53, 54, 0, 55,
2689  56, 0, 57, 0, 0, 58, 59, 60, 61, 62,
2690  63, 64, 65, 66, 0, 0, 0, 0, 0, 0,
2691  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2692  0, 0, 0, 0, 67, 68, 69, 0, 0, 0,
2693  0, 0, 0, 0, 0, 0, -759, 257, -759, 5,
2694  6, 7, 8, 9, 0, 0, -759, 10, 11, 0,
2695  0, -759, 12, 0, 13, 14, 15, 16, 17, 18,
2696  19, -759, 0, 0, 0, 0, 20, 21, 22, 23,
2697  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2698  0, 28, 29, 258, 31, 32, 33, 34, 35, 36,
2699  37, 38, 39, 40, 0, 41, 42, 43, 44, 45,
2700  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2701  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
2702  0, 0, 0, 0, 0, 0, 50, 51, 0, 0,
2703  0, 0, 0, 0, 52, 0, 0, 53, 54, 0,
2704  55, 56, 0, 57, 0, 0, 58, 59, 60, 61,
2705  62, 63, 64, 65, 66, 0, 0, 0, 0, 0,
2706  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2707  0, 0, 0, 0, 0, 67, 68, 69, 0, 0,
2708  0, 0, 0, 0, 0, 0, 0, -759, 257, -759,
2709  5, 6, 7, 8, 9, 0, 0, -759, 10, 11,
2710  0, 0, -759, 12, 0, 13, 14, 15, 16, 17,
2711  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2712  23, 24, 25, 26, 0, 0, 27, 0, 0, 0,
2713  0, 0, 28, 29, 258, 31, 32, 33, 34, 35,
2714  36, 37, 38, 39, 40, 0, 41, 42, 43, 44,
2715  45, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2716  0, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2717  0, 0, 0, 0, 0, 0, 0, 50, 51, 0,
2718  0, 0, 0, 0, 0, 52, 0, 0, 53, 54,
2719  0, 55, 56, 0, 57, 0, 0, 58, 59, 60,
2720  61, 62, 63, 64, 65, 66, 0, 0, 0, 0,
2721  0, 0, 0, 0, 257, 0, 5, 6, 7, 8,
2722  9, 0, -759, -759, 10, 11, 67, 68, 69, 12,
2723  0, 13, 14, 15, 16, 17, 18, 19, -759, 0,
2724  -759, 0, 0, 20, 21, 22, 23, 24, 25, 26,
2725  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2726  258, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2727  40, 0, 41, 42, 43, 44, 45, 46, 47, 0,
2728  0, 0, 0, 0, 0, 0, 0, 0, 48, 49,
2729  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2730  0, 0, 0, 50, 51, 0, 0, 0, 0, 0,
2731  0, 52, 0, 0, 53, 54, 0, 55, 56, 0,
2732  57, 0, 0, 58, 59, 60, 61, 62, 63, 64,
2733  65, 66, 0, 0, 0, 0, 0, 0, 0, 0,
2734  257, 0, 5, 6, 7, 8, 9, 0, 0, 0,
2735  10, 11, 67, 68, 69, 12, 0, 13, 14, 15,
2736  16, 17, 18, 19, -759, 0, -759, 0, 0, 20,
2737  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2738  0, 0, 0, 0, 28, 29, 258, 31, 32, 33,
2739  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2740  43, 44, 45, 46, 47, 0, 0, 0, 0, 0,
2741  0, 0, 0, 0, 48, 49, 0, 0, 0, 0,
2742  0, 0, 0, 0, 0, 0, 0, 0, 0, 50,
2743  51, 0, 0, 0, 0, 0, 0, 52, 0, 0,
2744  259, 54, 0, 55, 56, 0, 57, 0, 0, 58,
2745  59, 60, 61, 62, 63, 64, 65, 66, 0, 0,
2746  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2747  0, 0, 0, 0, 0, 0, 0, 0, 67, 68,
2748  69, 0, 0, 0, 0, 0, 0, 0, -759, 0,
2749  -759, 257, -759, 5, 6, 7, 8, 9, 0, 0,
2750  0, 10, 11, 0, 0, 0, 12, 0, 13, 14,
2751  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2752  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2753  0, 0, 0, 0, 0, 28, 29, 258, 31, 32,
2754  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2755  42, 43, 44, 45, 46, 47, 0, 0, 0, 0,
2756  0, 0, 0, 0, 0, 48, 49, 0, 0, 0,
2757  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2758  50, 51, 0, 0, 0, 0, 0, 0, 52, 0,
2759  0, 53, 54, 0, 55, 56, 0, 57, 0, 0,
2760  58, 59, 60, 61, 62, 63, 64, 65, 66, 0,
2761  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2762  0, 0, 0, 0, 0, 0, 0, 0, 0, 67,
2763  68, 69, 0, 0, 0, 0, 0, 0, 0, -759,
2764  0, -759, 4, -759, 5, 6, 7, 8, 9, 0,
2765  0, 0, 10, 11, 0, 0, 0, 12, 0, 13,
2766  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2767  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2768  27, 0, 0, 0, 0, 0, 28, 29, 30, 31,
2769  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2770  41, 42, 43, 44, 45, 46, 47, 0, 0, 0,
2771  0, 0, 0, 0, 0, 0, 48, 49, 0, 0,
2772  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2773  0, 50, 51, 0, 0, 0, 0, 0, 0, 52,
2774  0, 0, 53, 54, 0, 55, 56, 0, 57, 0,
2775  0, 58, 59, 60, 61, 62, 63, 64, 65, 66,
2776  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2777  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2778  67, 68, 69, 0, 0, -759, 0, 0, 0, 0,
2779  0, 0, -759, 257, -759, 5, 6, 7, 8, 9,
2780  0, 0, 0, 10, 11, 0, 0, 0, 12, 0,
2781  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2782  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2783  0, 27, 0, 0, 0, 0, 0, 28, 29, 258,
2784  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2785  0, 41, 42, 43, 44, 45, 46, 47, 0, 0,
2786  0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
2787  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2788  0, 0, 50, 51, 0, 0, 0, 0, 0, 0,
2789  52, 0, 0, 53, 54, 0, 55, 56, 0, 57,
2790  0, 0, 58, 59, 60, 61, 62, 63, 64, 65,
2791  66, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2792  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2793  0, 67, 68, 69, 0, 0, -759, 0, 0, 0,
2794  0, 0, 0, -759, 257, -759, 5, 6, 7, 8,
2795  9, 0, 0, -759, 10, 11, 0, 0, 0, 12,
2796  0, 13, 14, 15, 16, 17, 18, 19, 0, 0,
2797  0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
2798  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2799  258, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2800  40, 0, 41, 42, 43, 44, 45, 46, 47, 0,
2801  0, 0, 0, 0, 0, 0, 0, 0, 48, 49,
2802  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2803  0, 0, 0, 50, 51, 0, 0, 0, 0, 0,
2804  0, 52, 0, 0, 53, 54, 0, 55, 56, 0,
2805  57, 0, 0, 58, 59, 60, 61, 62, 63, 64,
2806  65, 66, 0, 0, 0, 0, 0, 0, 0, 0,
2807  257, 0, 5, 6, 7, 8, 9, 0, 0, 0,
2808  10, 11, 67, 68, 69, 12, 0, 13, 14, 15,
2809  16, 17, 18, 19, -759, 0, -759, 0, 0, 20,
2810  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2811  0, 0, 0, 0, 28, 29, 258, 31, 32, 33,
2812  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2813  43, 44, 45, 46, 47, 0, 0, 0, 0, 0,
2814  0, 0, 0, 0, 48, 49, 0, 0, 0, 0,
2815  0, 0, 0, 0, 0, 0, 0, 0, 0, 50,
2816  51, 0, 0, 0, 0, 0, 0, 52, 0, 0,
2817  53, 54, 0, 55, 56, 0, 57, 0, 0, 58,
2818  59, 60, 61, 62, 63, 64, 65, 66, 0, -759,
2819  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2820  7, 0, 9, 0, 0, 0, 10, 11, 67, 68,
2821  69, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2822  -759, 0, -759, 0, 0, 20, 21, 22, 23, 24,
2823  25, 26, 0, 0, 206, 0, 0, 0, 0, 0,
2824  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
2825  38, 39, 40, 207, 41, 42, 43, 44, 45, 46,
2826  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2827  48, 49, 0, 0, 0, 0, 0, 0, 0, 0,
2828  0, 0, 0, 0, 0, 50, 51, 0, 0, 0,
2829  0, 0, 0, 208, 0, 0, 209, 54, 0, 55,
2830  56, 0, 210, 211, 212, 58, 59, 213, 61, 62,
2831  63, 64, 65, 66, 0, 0, 0, 0, 0, 0,
2832  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2833  0, 0, 10, 11, 67, 214, 69, 12, 0, 13,
2834  14, 15, 16, 17, 18, 19, 0, 0, 237, 0,
2835  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2836  27, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2837  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2838  41, 42, 43, 44, 45, 46, 47, 0, 0, 0,
2839  0, 0, 0, 0, 0, 0, 48, 49, 0, 0,
2840  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2841  0, 50, 51, 0, 0, 0, 0, 0, 0, 208,
2842  0, 0, 209, 54, 0, 55, 56, 0, 0, 0,
2843  0, 58, 59, 60, 61, 62, 63, 64, 65, 66,
2844  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2845  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2846  67, 68, 69, 12, 0, 13, 14, 15, 16, 17,
2847  18, 19, 305, 0, 306, 0, 0, 20, 21, 22,
2848  23, 24, 25, 26, 0, 0, 27, 0, 0, 0,
2849  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2850  36, 37, 38, 39, 40, 0, 41, 42, 43, 44,
2851  45, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2852  0, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2853  0, 0, 0, 0, 0, 0, 0, 50, 51, 0,
2854  0, 0, 0, 0, 0, 208, 0, 0, 209, 54,
2855  0, 55, 56, 0, 0, 0, 0, 58, 59, 60,
2856  61, 62, 63, 64, 65, 66, 0, 0, 0, 0,
2857  0, 0, 0, 0, 0, 0, 5, 6, 7, 8,
2858  9, 0, 0, 0, 10, 11, 67, 68, 69, 12,
2859  0, 13, 14, 15, 16, 17, 18, 19, 0, 0,
2860  237, 0, 0, 20, 21, 22, 23, 24, 25, 26,
2861  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2862  30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2863  40, 0, 41, 42, 43, 44, 45, 46, 47, 0,
2864  0, 0, 0, 0, 0, 0, 0, 0, 48, 49,
2865  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2866  0, 0, 0, 50, 51, 0, 0, 0, 0, 0,
2867  0, 52, 0, 0, 53, 54, 0, 55, 56, 0,
2868  57, 0, 0, 58, 59, 60, 61, 62, 63, 64,
2869  65, 66, 0, 0, 0, 0, 0, 0, 0, 0,
2870  0, 0, 5, 6, 7, 8, 9, 0, 0, 0,
2871  10, 11, 67, 68, 69, 12, 0, 13, 14, 15,
2872  16, 17, 18, 19, 503, 0, 0, 0, 0, 20,
2873  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2874  0, 0, 0, 0, 28, 29, 258, 31, 32, 33,
2875  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2876  43, 44, 45, 46, 47, 0, 0, 0, 0, 0,
2877  0, 0, 0, 0, 48, 49, 0, 0, 0, 0,
2878  0, 0, 0, 0, 0, 0, 0, 0, 0, 50,
2879  51, 0, 0, 0, 0, 0, 0, 52, 0, 0,
2880  53, 54, 0, 55, 56, 0, 57, 0, 0, 58,
2881  59, 60, 61, 62, 63, 64, 65, 66, 0, 0,
2882  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2883  0, 0, 0, 0, 0, 0, 0, 0, 67, 68,
2884  69, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2885  503, 126, 127, 128, 129, 130, 131, 132, 133, 134,
2886  135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
2887  145, 146, 147, 148, 149, 0, 0, 0, 150, 151,
2888  152, 395, 396, 397, 398, 157, 158, 159, 0, 0,
2889  0, 0, 0, 160, 161, 162, 163, 399, 400, 401,
2890  402, 168, 37, 38, 403, 40, 0, 0, 0, 0,
2891  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2892  0, 0, 0, 170, 171, 172, 173, 174, 175, 176,
2893  177, 178, 0, 0, 179, 180, 0, 0, 0, 0,
2894  181, 182, 183, 184, 0, 0, 0, 0, 0, 0,
2895  0, 0, 0, 0, 0, 185, 186, 0, 0, 0,
2896  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2897  0, 0, 0, 0, 0, 0, 0, 187, 188, 189,
2898  190, 191, 192, 193, 194, 195, 196, 0, 197, 198,
2899  0, 0, 0, 0, 0, 199, 404, 126, 127, 128,
2900  129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2901  139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
2902  149, 0, 0, 0, 150, 151, 152, 153, 154, 155,
2903  156, 157, 158, 159, 0, 0, 0, 0, 0, 160,
2904  161, 162, 163, 164, 165, 166, 167, 168, 288, 289,
2905  169, 290, 0, 0, 0, 0, 0, 0, 0, 0,
2906  0, 0, 0, 0, 0, 0, 0, 0, 0, 170,
2907  171, 172, 173, 174, 175, 176, 177, 178, 0, 0,
2908  179, 180, 0, 0, 0, 0, 181, 182, 183, 184,
2909  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2910  0, 185, 186, 0, 0, 0, 0, 0, 0, 0,
2911  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2912  0, 0, 0, 187, 188, 189, 190, 191, 192, 193,
2913  194, 195, 196, 0, 197, 198, 0, 0, 0, 0,
2914  0, 199, 126, 127, 128, 129, 130, 131, 132, 133,
2915  134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
2916  144, 145, 146, 147, 148, 149, 0, 0, 0, 150,
2917  151, 152, 153, 154, 155, 156, 157, 158, 159, 0,
2918  0, 0, 0, 0, 160, 161, 162, 163, 164, 165,
2919  166, 167, 168, 239, 0, 169, 0, 0, 0, 0,
2920  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2921  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
2922  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
2923  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
2924  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
2925  59, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2926  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
2927  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
2928  198, 0, 0, 0, 0, 0, 199, 126, 127, 128,
2929  129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2930  139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
2931  149, 0, 0, 0, 150, 151, 152, 153, 154, 155,
2932  156, 157, 158, 159, 0, 0, 0, 0, 0, 160,
2933  161, 162, 163, 164, 165, 166, 167, 168, 0, 0,
2934  169, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2935  0, 0, 0, 0, 0, 0, 0, 0, 0, 170,
2936  171, 172, 173, 174, 175, 176, 177, 178, 0, 0,
2937  179, 180, 0, 0, 0, 0, 181, 182, 183, 184,
2938  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2939  0, 185, 186, 0, 0, 59, 0, 0, 0, 0,
2940  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2941  0, 0, 0, 187, 188, 189, 190, 191, 192, 193,
2942  194, 195, 196, 0, 197, 198, 0, 0, 0, 0,
2943  0, 199, 126, 127, 128, 129, 130, 131, 132, 133,
2944  134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
2945  144, 145, 146, 147, 148, 149, 0, 0, 0, 150,
2946  151, 152, 153, 154, 155, 156, 157, 158, 159, 0,
2947  0, 0, 0, 0, 160, 161, 162, 163, 164, 165,
2948  166, 167, 168, 0, 0, 169, 0, 0, 0, 0,
2949  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2950  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
2951  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
2952  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
2953  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
2954  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2955  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
2956  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
2957  198, 5, 6, 7, 0, 9, 199, 0, 0, 10,
2958  11, 0, 0, 0, 12, 0, 13, 14, 15, 245,
2959  246, 18, 19, 0, 0, 0, 0, 0, 20, 247,
2960  248, 23, 24, 25, 26, 0, 0, 206, 0, 0,
2961  0, 0, 0, 0, 277, 0, 0, 32, 33, 34,
2962  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
2963  44, 45, 46, 47, 0, 0, 0, 0, 0, 0,
2964  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2965  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2966  0, 0, 0, 0, 0, 0, 278, 0, 0, 209,
2967  54, 0, 55, 56, 0, 0, 0, 0, 58, 59,
2968  60, 61, 62, 63, 64, 65, 66, 0, 0, 0,
2969  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2970  5, 6, 7, 0, 9, 0, 0, 279, 10, 11,
2971  0, 0, 0, 12, 280, 13, 14, 15, 245, 246,
2972  18, 19, 0, 0, 0, 0, 0, 20, 247, 248,
2973  23, 24, 25, 26, 0, 0, 206, 0, 0, 0,
2974  0, 0, 0, 277, 0, 0, 32, 33, 34, 35,
2975  36, 37, 38, 39, 40, 0, 41, 42, 43, 44,
2976  45, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2977  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2978  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2979  0, 0, 0, 0, 0, 278, 0, 0, 209, 54,
2980  0, 55, 56, 0, 0, 0, 0, 58, 59, 60,
2981  61, 62, 63, 64, 65, 66, 0, 0, 0, 0,
2982  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
2983  6, 7, 8, 9, 0, 0, 279, 10, 11, 0,
2984  0, 0, 12, 526, 13, 14, 15, 16, 17, 18,
2985  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2986  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2987  0, 28, 29, 30, 31, 32, 33, 34, 35, 36,
2988  37, 38, 39, 40, 0, 41, 42, 43, 44, 45,
2989  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2990  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
2991  0, 0, 0, 0, 0, 0, 50, 51, 0, 0,
2992  0, 0, 0, 0, 52, 0, 0, 53, 54, 0,
2993  55, 56, 0, 57, 0, 0, 58, 59, 60, 61,
2994  62, 63, 64, 65, 66, 0, 0, 0, 0, 0,
2995  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
2996  0, 0, 0, 10, 11, 67, 68, 69, 12, 0,
2997  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2998  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2999  0, 206, 0, 0, 0, 0, 0, 0, 29, 0,
3000  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3001  207, 41, 42, 43, 44, 45, 46, 47, 0, 0,
3002  0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
3003  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3004  0, 0, 50, 51, 0, 0, 0, 0, 0, 0,
3005  208, 0, 0, 209, 54, 0, 55, 56, 0, 210,
3006  211, 212, 58, 59, 213, 61, 62, 63, 64, 65,
3007  66, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3008  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
3009  11, 67, 214, 69, 12, 0, 13, 14, 15, 16,
3010  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
3011  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
3012  0, 0, 0, 28, 29, 0, 31, 32, 33, 34,
3013  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
3014  44, 45, 46, 47, 0, 0, 0, 0, 0, 0,
3015  0, 0, 0, 48, 49, 0, 0, 0, 0, 0,
3016  0, 0, 0, 0, 0, 0, 0, 0, 50, 51,
3017  0, 0, 0, 0, 0, 0, 52, 0, 0, 53,
3018  54, 0, 55, 56, 0, 57, 0, 0, 58, 59,
3019  60, 61, 62, 63, 64, 65, 66, 0, 0, 0,
3020  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3021  0, 9, 0, 0, 0, 10, 11, 67, 68, 69,
3022  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
3023  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
3024  26, 0, 0, 206, 0, 0, 0, 0, 0, 0,
3025  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
3026  39, 40, 207, 41, 42, 43, 44, 45, 46, 47,
3027  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
3028  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3029  0, 0, 0, 0, 50, 439, 0, 0, 0, 0,
3030  0, 0, 208, 0, 0, 209, 54, 0, 55, 56,
3031  0, 210, 211, 212, 58, 59, 213, 61, 62, 63,
3032  64, 65, 66, 0, 0, 0, 0, 0, 0, 0,
3033  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3034  0, 10, 11, 67, 214, 69, 12, 0, 13, 14,
3035  15, 245, 246, 18, 19, 0, 0, 0, 0, 0,
3036  20, 247, 248, 23, 24, 25, 26, 0, 0, 206,
3037  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
3038  33, 34, 35, 36, 37, 38, 39, 40, 207, 41,
3039  42, 43, 44, 45, 46, 47, 0, 0, 0, 0,
3040  0, 0, 0, 0, 0, 48, 49, 0, 0, 0,
3041  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3042  50, 51, 0, 0, 0, 0, 0, 0, 208, 0,
3043  0, 209, 54, 0, 55, 56, 0, 620, 211, 212,
3044  58, 59, 213, 61, 62, 63, 64, 65, 66, 0,
3045  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
3046  6, 7, 0, 9, 0, 0, 0, 10, 11, 67,
3047  214, 69, 12, 0, 13, 14, 15, 245, 246, 18,
3048  19, 0, 0, 0, 0, 0, 20, 247, 248, 23,
3049  24, 25, 26, 0, 0, 206, 0, 0, 0, 0,
3050  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
3051  37, 38, 39, 40, 207, 41, 42, 43, 44, 45,
3052  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
3053  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
3054  0, 0, 0, 0, 0, 0, 50, 51, 0, 0,
3055  0, 0, 0, 0, 208, 0, 0, 209, 54, 0,
3056  55, 56, 0, 210, 211, 0, 58, 59, 213, 61,
3057  62, 63, 64, 65, 66, 0, 0, 0, 0, 0,
3058  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
3059  0, 0, 0, 10, 11, 67, 214, 69, 12, 0,
3060  13, 14, 15, 245, 246, 18, 19, 0, 0, 0,
3061  0, 0, 20, 247, 248, 23, 24, 25, 26, 0,
3062  0, 206, 0, 0, 0, 0, 0, 0, 29, 0,
3063  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3064  207, 41, 42, 43, 44, 45, 46, 47, 0, 0,
3065  0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
3066  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3067  0, 0, 50, 51, 0, 0, 0, 0, 0, 0,
3068  208, 0, 0, 209, 54, 0, 55, 56, 0, 0,
3069  211, 212, 58, 59, 213, 61, 62, 63, 64, 65,
3070  66, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3071  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
3072  11, 67, 214, 69, 12, 0, 13, 14, 15, 245,
3073  246, 18, 19, 0, 0, 0, 0, 0, 20, 247,
3074  248, 23, 24, 25, 26, 0, 0, 206, 0, 0,
3075  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
3076  35, 36, 37, 38, 39, 40, 207, 41, 42, 43,
3077  44, 45, 46, 47, 0, 0, 0, 0, 0, 0,
3078  0, 0, 0, 48, 49, 0, 0, 0, 0, 0,
3079  0, 0, 0, 0, 0, 0, 0, 0, 50, 51,
3080  0, 0, 0, 0, 0, 0, 208, 0, 0, 209,
3081  54, 0, 55, 56, 0, 620, 211, 0, 58, 59,
3082  213, 61, 62, 63, 64, 65, 66, 0, 0, 0,
3083  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3084  0, 9, 0, 0, 0, 10, 11, 67, 214, 69,
3085  12, 0, 13, 14, 15, 245, 246, 18, 19, 0,
3086  0, 0, 0, 0, 20, 247, 248, 23, 24, 25,
3087  26, 0, 0, 206, 0, 0, 0, 0, 0, 0,
3088  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
3089  39, 40, 207, 41, 42, 43, 44, 45, 46, 47,
3090  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
3091  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3092  0, 0, 0, 0, 50, 51, 0, 0, 0, 0,
3093  0, 0, 208, 0, 0, 209, 54, 0, 55, 56,
3094  0, 0, 211, 0, 58, 59, 213, 61, 62, 63,
3095  64, 65, 66, 0, 0, 0, 0, 0, 0, 0,
3096  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3097  0, 10, 11, 67, 214, 69, 12, 0, 13, 14,
3098  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
3099  20, 21, 22, 23, 24, 25, 26, 0, 0, 206,
3100  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
3101  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
3102  42, 43, 44, 45, 46, 47, 0, 0, 0, 0,
3103  0, 0, 0, 0, 0, 48, 49, 0, 0, 0,
3104  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3105  50, 51, 0, 0, 0, 0, 0, 0, 208, 0,
3106  0, 209, 54, 0, 55, 56, 0, 519, 0, 0,
3107  58, 59, 60, 61, 62, 63, 64, 65, 66, 0,
3108  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
3109  6, 7, 0, 9, 0, 0, 0, 10, 11, 67,
3110  214, 69, 12, 0, 13, 14, 15, 245, 246, 18,
3111  19, 0, 0, 0, 0, 0, 20, 247, 248, 23,
3112  24, 25, 26, 0, 0, 206, 0, 0, 0, 0,
3113  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
3114  37, 38, 39, 40, 0, 41, 42, 43, 44, 45,
3115  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
3116  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
3117  0, 0, 0, 0, 0, 0, 50, 51, 0, 0,
3118  0, 0, 0, 0, 208, 0, 0, 209, 54, 0,
3119  55, 56, 0, 770, 0, 0, 58, 59, 60, 61,
3120  62, 63, 64, 65, 66, 0, 0, 0, 0, 0,
3121  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
3122  0, 0, 0, 10, 11, 67, 214, 69, 12, 0,
3123  13, 14, 15, 245, 246, 18, 19, 0, 0, 0,
3124  0, 0, 20, 247, 248, 23, 24, 25, 26, 0,
3125  0, 206, 0, 0, 0, 0, 0, 0, 29, 0,
3126  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3127  0, 41, 42, 43, 44, 45, 46, 47, 0, 0,
3128  0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
3129  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3130  0, 0, 50, 51, 0, 0, 0, 0, 0, 0,
3131  208, 0, 0, 209, 54, 0, 55, 56, 0, 519,
3132  0, 0, 58, 59, 60, 61, 62, 63, 64, 65,
3133  66, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3134  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
3135  11, 67, 214, 69, 12, 0, 13, 14, 15, 245,
3136  246, 18, 19, 0, 0, 0, 0, 0, 20, 247,
3137  248, 23, 24, 25, 26, 0, 0, 206, 0, 0,
3138  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
3139  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
3140  44, 45, 46, 47, 0, 0, 0, 0, 0, 0,
3141  0, 0, 0, 48, 49, 0, 0, 0, 0, 0,
3142  0, 0, 0, 0, 0, 0, 0, 0, 50, 51,
3143  0, 0, 0, 0, 0, 0, 208, 0, 0, 209,
3144  54, 0, 55, 56, 0, 843, 0, 0, 58, 59,
3145  60, 61, 62, 63, 64, 65, 66, 0, 0, 0,
3146  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3147  0, 9, 0, 0, 0, 10, 11, 67, 214, 69,
3148  12, 0, 13, 14, 15, 245, 246, 18, 19, 0,
3149  0, 0, 0, 0, 20, 247, 248, 23, 24, 25,
3150  26, 0, 0, 206, 0, 0, 0, 0, 0, 0,
3151  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
3152  39, 40, 0, 41, 42, 43, 44, 45, 46, 47,
3153  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
3154  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3155  0, 0, 0, 0, 50, 51, 0, 0, 0, 0,
3156  0, 0, 208, 0, 0, 209, 54, 0, 55, 56,
3157  0, 1014, 0, 0, 58, 59, 60, 61, 62, 63,
3158  64, 65, 66, 0, 0, 0, 0, 0, 0, 0,
3159  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3160  0, 10, 11, 67, 214, 69, 12, 0, 13, 14,
3161  15, 245, 246, 18, 19, 0, 0, 0, 0, 0,
3162  20, 247, 248, 23, 24, 25, 26, 0, 0, 206,
3163  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
3164  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
3165  42, 43, 44, 45, 46, 47, 0, 0, 0, 0,
3166  0, 0, 0, 0, 0, 48, 49, 0, 0, 0,
3167  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3168  50, 51, 0, 0, 0, 0, 0, 0, 208, 0,
3169  0, 209, 54, 0, 55, 56, 0, 0, 0, 0,
3170  58, 59, 60, 61, 62, 63, 64, 65, 66, 0,
3171  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
3172  6, 7, 0, 9, 0, 0, 0, 10, 11, 67,
3173  214, 69, 12, 0, 13, 14, 15, 16, 17, 18,
3174  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
3175  24, 25, 26, 0, 0, 206, 0, 0, 0, 0,
3176  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
3177  37, 38, 39, 40, 0, 41, 42, 43, 44, 45,
3178  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
3179  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
3180  0, 0, 0, 0, 0, 0, 50, 51, 0, 0,
3181  0, 0, 0, 0, 208, 0, 0, 209, 54, 0,
3182  55, 56, 0, 0, 0, 0, 58, 59, 60, 61,
3183  62, 63, 64, 65, 66, 0, 0, 0, 0, 0,
3184  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
3185  0, 0, 0, 10, 11, 67, 214, 69, 12, 0,
3186  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
3187  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
3188  0, 27, 0, 0, 0, 0, 0, 0, 29, 0,
3189  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3190  0, 41, 42, 43, 44, 45, 46, 47, 0, 0,
3191  0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
3192  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3193  0, 0, 50, 51, 0, 0, 0, 0, 0, 0,
3194  208, 0, 0, 209, 54, 0, 55, 56, 0, 0,
3195  0, 0, 58, 59, 60, 61, 62, 63, 64, 65,
3196  66, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3197  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
3198  11, 67, 68, 69, 12, 0, 13, 14, 15, 245,
3199  246, 18, 19, 0, 0, 0, 0, 0, 20, 247,
3200  248, 23, 24, 25, 26, 0, 0, 206, 0, 0,
3201  0, 0, 0, 0, 277, 0, 0, 32, 33, 34,
3202  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
3203  44, 45, 46, 47, 0, 0, 0, 0, 0, 0,
3204  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3205  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3206  0, 0, 0, 0, 0, 0, 278, 0, 0, 328,
3207  54, 0, 55, 56, 0, 329, 0, 0, 58, 59,
3208  60, 61, 62, 63, 64, 65, 66, 0, 0, 0,
3209  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3210  0, 10, 11, 0, 0, 0, 12, 279, 13, 14,
3211  15, 245, 246, 18, 19, 0, 0, 0, 0, 0,
3212  20, 247, 248, 23, 24, 25, 26, 0, 0, 206,
3213  0, 0, 0, 0, 0, 0, 277, 0, 0, 32,
3214  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
3215  42, 43, 44, 45, 46, 47, 0, 0, 0, 0,
3216  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3217  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3218  0, 0, 0, 0, 0, 0, 0, 0, 376, 0,
3219  0, 53, 54, 0, 55, 56, 0, 57, 0, 0,
3220  58, 59, 60, 61, 62, 63, 64, 65, 66, 0,
3221  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
3222  0, 0, 0, 10, 11, 0, 0, 0, 12, 279,
3223  13, 14, 15, 245, 246, 18, 19, 0, 0, 0,
3224  0, 0, 20, 247, 248, 23, 24, 25, 26, 0,
3225  0, 206, 0, 0, 0, 0, 0, 0, 277, 0,
3226  0, 32, 33, 34, 384, 36, 37, 38, 385, 40,
3227  0, 41, 42, 43, 44, 45, 46, 47, 0, 0,
3228  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3229  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3230  0, 0, 0, 0, 0, 0, 386, 0, 0, 0,
3231  387, 0, 0, 209, 54, 0, 55, 56, 0, 0,
3232  0, 0, 58, 59, 60, 61, 62, 63, 64, 65,
3233  66, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3234  0, 9, 0, 0, 0, 10, 11, 0, 0, 0,
3235  12, 279, 13, 14, 15, 245, 246, 18, 19, 0,
3236  0, 0, 0, 0, 20, 247, 248, 23, 24, 25,
3237  26, 0, 0, 206, 0, 0, 0, 0, 0, 0,
3238  277, 0, 0, 32, 33, 34, 384, 36, 37, 38,
3239  385, 40, 0, 41, 42, 43, 44, 45, 46, 47,
3240  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3241  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3242  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3243  0, 0, 387, 0, 0, 209, 54, 0, 55, 56,
3244  0, 0, 0, 0, 58, 59, 60, 61, 62, 63,
3245  64, 65, 66, 0, 0, 0, 0, 0, 0, 5,
3246  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
3247  0, 0, 12, 279, 13, 14, 15, 245, 246, 18,
3248  19, 0, 0, 0, 0, 0, 20, 247, 248, 23,
3249  24, 25, 26, 0, 0, 206, 0, 0, 0, 0,
3250  0, 0, 277, 0, 0, 32, 33, 34, 35, 36,
3251  37, 38, 39, 40, 0, 41, 42, 43, 44, 45,
3252  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
3253  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3254  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3255  0, 0, 0, 0, 278, 0, 0, 328, 54, 0,
3256  55, 56, 0, 0, 0, 0, 58, 59, 60, 61,
3257  62, 63, 64, 65, 66, 0, 0, 0, 0, 0,
3258  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
3259  11, 0, 0, 0, 12, 279, 13, 14, 15, 245,
3260  246, 18, 19, 0, 0, 0, 0, 0, 20, 247,
3261  248, 23, 24, 25, 26, 0, 0, 206, 0, 0,
3262  0, 0, 0, 0, 277, 0, 0, 32, 33, 34,
3263  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
3264  44, 45, 46, 47, 0, 0, 0, 0, 0, 0,
3265  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3266  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3267  0, 0, 0, 0, 0, 0, 1004, 0, 0, 209,
3268  54, 0, 55, 56, 0, 0, 0, 0, 58, 59,
3269  60, 61, 62, 63, 64, 65, 66, 0, 0, 0,
3270  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3271  0, 10, 11, 0, 0, 0, 12, 279, 13, 14,
3272  15, 245, 246, 18, 19, 0, 0, 0, 0, 0,
3273  20, 247, 248, 23, 24, 25, 26, 0, 0, 206,
3274  0, 0, 0, 0, 0, 0, 277, 0, 0, 32,
3275  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
3276  42, 43, 44, 45, 46, 47, 23, 24, 25, 26,
3277  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3278  0, 0, 32, 33, 34, 781, 0, 0, 0, 782,
3279  0, 0, 41, 42, 43, 44, 45, 0, 1056, 0,
3280  0, 209, 54, 0, 55, 56, 0, 0, 0, 0,
3281  58, 59, 60, 61, 62, 63, 64, 65, 66, 0,
3282  0, 0, 0, 783, 784, 0, 0, 0, 0, 0,
3283  0, 785, 0, 0, 786, 0, 0, 787, 788, 279,
3284  975, 0, 0, 789, 59, 60, 61, 62, 63, 64,
3285  65, 66, 23, 24, 25, 26, 0, 0, 0, 0,
3286  0, 0, 0, 0, 0, 790, 0, 0, 32, 33,
3287  34, 781, 279, 0, 0, 782, 0, 0, 41, 42,
3288  43, 44, 45, 0, 0, 23, 24, 25, 26, 0,
3289  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3290  0, 32, 33, 34, 781, 0, 0, 0, 782, 783,
3291  784, 41, 42, 43, 44, 45, 0, 785, 0, 0,
3292  786, 0, 0, 787, 788, 0, 1071, 0, 0, 789,
3293  59, 60, 61, 62, 63, 64, 65, 66, 0, 0,
3294  0, 0, 783, 784, 0, 0, 0, 0, 0, 0,
3295  785, 790, 0, 786, 0, 0, 787, 788, 279, 0,
3296  0, 0, 789, 59, 60, 61, 62, 63, 64, 65,
3297  66, 564, 565, 0, 0, 566, 0, 0, 0, 0,
3298  0, 0, 0, 0, 790, 0, 0, 0, 0, 0,
3299  0, 279, 0, 0, 170, 171, 172, 173, 174, 175,
3300  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3301  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3302  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3303  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3304  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3305  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3306  198, 572, 573, 0, 0, 574, 199, 233, 0, 0,
3307  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3308  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3309  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3310  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3311  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3312  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3313  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3314  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3315  198, 624, 565, 0, 0, 625, 199, 233, 0, 0,
3316  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3317  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3318  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3319  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3320  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3321  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3322  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3323  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3324  198, 627, 573, 0, 0, 628, 199, 233, 0, 0,
3325  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3326  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3327  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3328  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3329  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3330  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3331  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3332  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3333  198, 652, 565, 0, 0, 653, 199, 233, 0, 0,
3334  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3335  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3336  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3337  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3338  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3339  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3340  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3341  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3342  198, 655, 573, 0, 0, 656, 199, 233, 0, 0,
3343  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3344  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3345  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3346  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3347  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3348  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3349  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3350  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3351  198, 722, 565, 0, 0, 723, 199, 233, 0, 0,
3352  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3353  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3354  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3355  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3356  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3357  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3358  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3359  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3360  198, 725, 573, 0, 0, 726, 199, 233, 0, 0,
3361  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3362  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3363  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3364  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3365  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3366  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3367  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3368  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3369  198, 731, 565, 0, 0, 732, 199, 233, 0, 0,
3370  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3371  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3372  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3373  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3374  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3375  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3376  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3377  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3378  198, 609, 573, 0, 0, 610, 199, 233, 0, 0,
3379  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3380  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3381  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3382  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3383  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3384  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3385  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3386  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3387  198, 776, 565, 0, 0, 777, 199, 233, 0, 0,
3388  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3389  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3390  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3391  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3392  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3393  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3394  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3395  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3396  198, 779, 573, 0, 0, 780, 199, 233, 0, 0,
3397  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3398  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3399  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3400  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3401  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3402  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3403  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3404  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3405  198, 1154, 565, 0, 0, 1155, 199, 233, 0, 0,
3406  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3407  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3408  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3409  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3410  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3411  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3412  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3413  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3414  198, 1157, 573, 0, 0, 1158, 199, 233, 0, 0,
3415  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3416  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3417  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3418  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3419  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3420  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3421  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3422  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3423  198, 1188, 565, 0, 0, 1189, 199, 233, 0, 0,
3424  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3425  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3426  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3427  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3428  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3429  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3430  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3431  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3432  198, 609, 573, 0, 0, 610, 199, 233, 0, 0,
3433  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3434  0, 0, 0, 0, 170, 171, 172, 173, 174, 175,
3435  176, 177, 178, 0, 0, 179, 180, 0, 0, 0,
3436  0, 181, 182, 183, 184, 0, 0, 0, 0, 0,
3437  0, 0, 0, 0, 0, 0, 185, 186, 0, 0,
3438  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3439  0, 0, 0, 0, 0, 0, 0, 0, 187, 188,
3440  189, 190, 191, 192, 193, 194, 195, 196, 0, 197,
3441  198, 0, 0, 0, 0, 0, 199
3442 };
3443 
3444 static const yytype_int16 yycheck[] =
3445 {
3446  2, 369, 89, 60, 28, 57, 94, 102, 8, 227,
3447  710, 71, 22, 8, 101, 83, 433, 387, 53, 59,
3448  866, 331, 16, 17, 95, 91, 92, 71, 28, 95,
3449  67, 83, 68, 28, 2, 95, 4, 717, 57, 1066,
3450  26, 16, 17, 626, 96, 97, 98, 53, 16, 17,
3451  27, 603, 29, 55, 56, 1039, 473, 364, 25, 99,
3452  92, 55, 56, 95, 59, 425, 4, 13, 78, 893,
3453  894, 654, 482, 433, 2, 1062, 4, 271, 25, 52,
3454  1104, 275, 16, 17, 857, 53, 54, 27, 363, 57,
3455  365, 864, 29, 25, 25, 52, 295, 296, 958, 13,
3456  68, 25, 25, 100, 99, 1106, 100, 15, 25, 17,
3457  16, 17, 893, 894, 68, 83, 526, 126, 259, 331,
3458  1028, 55, 429, 91, 92, 100, 54, 95, 96, 97,
3459  98, 13, 100, 0, 26, 222, 411, 146, 25, 924,
3460  34, 724, 96, 97, 37, 38, 1054, 13, 13, 146,
3461  855, 734, 857, 428, 153, 430, 213, 143, 52, 864,
3462  414, 415, 148, 689, 251, 15, 100, 66, 66, 1196,
3463  236, 13, 238, 146, 209, 25, 866, 484, 730, 146,
3464  953, 148, 1028, 458, 1208, 1169, 123, 328, 1048, 146,
3465  261, 145, 13, 1039, 100, 778, 283, 1184, 68, 146,
3466  146, 261, 414, 415, 787, 151, 1207, 153, 1054, 244,
3467  485, 151, 280, 153, 146, 146, 1062, 261, 635, 221,
3468  119, 119, 146, 146, 259, 227, 444, 97, 280, 146,
3469  600, 233, 1013, 1018, 1019, 13, 230, 151, 232, 153,
3470  242, 209, 279, 143, 310, 311, 312, 313, 953, 315,
3471  316, 143, 855, 259, 857, 230, 56, 232, 233, 146,
3472  153, 864, 230, 866, 232, 233, 1174, 143, 236, 151,
3473  238, 153, 682, 633, 242, 635, 244, 329, 310, 311,
3474  312, 313, 148, 1191, 591, 151, 151, 153, 153, 257,
3475  326, 259, 379, 328, 601, 331, 230, 849, 232, 498,
3476  277, 500, 373, 25, 856, 371, 148, 152, 891, 151,
3477  329, 153, 280, 373, 242, 58, 1016, 592, 870, 1104,
3478  386, 1106, 328, 1169, 230, 109, 232, 602, 13, 257,
3479  151, 13, 153, 152, 77, 370, 1016, 372, 1184, 371,
3480  1164, 309, 310, 311, 312, 313, 314, 315, 316, 133,
3481  953, 877, 878, 866, 66, 100, 37, 38, 326, 68,
3482  328, 329, 364, 331, 1054, 108, 99, 893, 894, 112,
3483  365, 309, 1062, 151, 1064, 153, 100, 880, 414, 415,
3484  687, 309, 34, 151, 978, 153, 314, 25, 97, 364,
3485  893, 894, 326, 126, 977, 705, 364, 331, 366, 152,
3486  52, 146, 370, 371, 372, 623, 25, 783, 784, 121,
3487  122, 686, 124, 688, 482, 785, 411, 152, 386, 1002,
3488  1003, 236, 1207, 1208, 146, 1028, 148, 429, 452, 153,
3489  482, 425, 25, 97, 694, 430, 1039, 691, 692, 28,
3490  442, 701, 444, 697, 698, 862, 414, 415, 22, 264,
3491  537, 1054, 452, 268, 429, 649, 126, 452, 526, 1062,
3492  986, 429, 661, 458, 99, 99, 151, 666, 153, 151,
3493  13, 153, 684, 99, 526, 1069, 470, 845, 146, 691,
3494  692, 145, 484, 77, 148, 697, 698, 1013, 126, 144,
3495  485, 126, 126, 68, 1184, 1047, 1186, 465, 153, 99,
3496  126, 1191, 862, 1193, 78, 593, 126, 126, 146, 484,
3497  1013, 149, 888, 889, 482, 153, 484, 146, 1031, 99,
3498  890, 96, 97, 1036, 153, 585, 126, 146, 1031, 148,
3499  149, 899, 750, 126, 153, 1144, 904, 1237, 604, 1148,
3500  1230, 1054, 136, 137, 138, 1058, 581, 66, 583, 1062,
3501  1144, 1064, 99, 146, 1148, 1058, 149, 99, 526, 569,
3502  153, 99, 816, 942, 943, 99, 1169, 577, 112, 99,
3503  145, 1123, 638, 1156, 1077, 577, 553, 579, 146, 126,
3504  56, 1184, 650, 68, 126, 964, 965, 966, 126, 591,
3505  68, 1200, 126, 617, 571, 68, 126, 592, 650, 601,
3506  119, 611, 121, 122, 816, 1199, 1200, 602, 151, 611,
3507  153, 96, 97, 581, 682, 583, 591, 617, 96, 97,
3508  435, 623, 617, 591, 97, 440, 601, 148, 443, 126,
3509  682, 446, 66, 601, 66, 603, 604, 99, 1164, 633,
3510  68, 643, 100, 2, 739, 4, 66, 462, 684, 626,
3511  68, 25, 467, 866, 68, 691, 692, 16, 17, 146,
3512  145, 697, 698, 729, 126, 146, 866, 145, 728, 97,
3513  638, 1184, 153, 1186, 248, 249, 68, 654, 1191, 97,
3514  1193, 148, 650, 97, 66, 687, 153, 121, 122, 121,
3515  122, 146, 727, 688, 53, 54, 149, 729, 738, 119,
3516  153, 121, 122, 705, 706, 97, 708, 26, 710, 68,
3517  525, 679, 687, 99, 682, 683, 684, 1230, 152, 687,
3518  152, 68, 148, 691, 692, 1093, 82, 83, 518, 697,
3519  698, 68, 91, 92, 68, 1114, 95, 119, 146, 121,
3520  122, 100, 124, 738, 66, 153, 148, 724, 750, 68,
3521  97, 679, 126, 148, 68, 683, 1135, 734, 68, 727,
3522  97, 729, 730, 97, 9, 767, 150, 769, 834, 153,
3523  15, 705, 146, 129, 130, 149, 68, 96, 97, 153,
3524  816, 1088, 96, 97, 68, 52, 96, 97, 578, 56,
3525  850, 365, 68, 828, 584, 77, 586, 119, 833, 121,
3526  122, 778, 834, 52, 96, 97, 149, 56, 126, 68,
3527  787, 788, 96, 97, 1089, 150, 99, 144, 1031, 56,
3528  96, 97, 824, 146, 143, 77, 145, 106, 99, 148,
3529  146, 145, 867, 56, 148, 145, 77, 96, 97, 14,
3530  15, 1054, 151, 126, 130, 1058, 898, 25, 816, 1062,
3531  209, 1064, 66, 145, 1054, 126, 430, 146, 1058, 149,
3532  828, 145, 1062, 146, 1064, 833, 834, 902, 146, 145,
3533  144, 230, 144, 232, 233, 146, 911, 236, 146, 238,
3534  146, 849, 99, 242, 458, 244, 145, 68, 856, 866,
3535  99, 951, 10, 134, 135, 136, 137, 138, 257, 867,
3536  259, 144, 870, 88, 89, 119, 146, 121, 122, 126,
3537  962, 485, 54, 146, 891, 96, 97, 126, 44, 1006,
3538  146, 736, 64, 65, 44, 982, 40, 41, 718, 146,
3539  898, 721, 126, 8, 902, 13, 751, 146, 940, 25,
3540  942, 943, 999, 911, 17, 735, 152, 152, 144, 99,
3541  309, 310, 311, 312, 313, 314, 315, 316, 146, 68,
3542  128, 68, 964, 965, 966, 15, 150, 326, 148, 328,
3543  146, 1184, 331, 1186, 131, 1010, 126, 1012, 1191, 146,
3544  1193, 958, 26, 2, 1184, 4, 1186, 96, 97, 96,
3545  97, 1191, 52, 1193, 962, 569, 146, 16, 17, 100,
3546  977, 1053, 131, 577, 100, 364, 983, 366, 146, 1011,
3547  144, 370, 371, 372, 1016, 1050, 52, 1230, 592, 66,
3548  67, 26, 126, 146, 68, 1002, 1003, 386, 602, 146,
3549  1230, 68, 52, 146, 53, 54, 145, 611, 145, 52,
3550  146, 146, 1010, 131, 1012, 835, 126, 146, 838, 68,
3551  56, 841, 96, 97, 66, 414, 415, 146, 848, 96,
3552  97, 851, 146, 68, 146, 146, 414, 415, 642, 643,
3553  429, 1048, 91, 92, 121, 122, 95, 892, 146, 1047,
3554  151, 100, 1050, 431, 432, 1053, 1088, 9, 1090, 1124,
3555  1092, 96, 97, 68, 1089, 146, 1162, 1163, 68, 143,
3556  146, 145, 866, 131, 148, 56, 465, 119, 145, 121,
3557  122, 459, 1114, 1088, 688, 99, 931, 932, 58, 99,
3558  1088, 96, 97, 913, 146, 484, 96, 97, 146, 146,
3559  1162, 1163, 146, 1135, 52, 146, 146, 77, 143, 120,
3560  145, 149, 126, 148, 146, 66, 126, 146, 52, 146,
3561  54, 55, 56, 57, 58, 1123, 1124, 146, 146, 974,
3562  950, 146, 146, 146, 1141, 242, 146, 146, 108, 109,
3563  145, 144, 148, 77, 689, 145, 2, 148, 4, 1156,
3564  40, 41, 42, 43, 44, 1000, 1001, 146, 689, 146,
3565  209, 461, 77, 133, 1162, 1163, 465, 101, 119, 1234,
3566  121, 122, 96, 124, 108, 109, 98, 1022, 87, 94,
3567  95, 230, 611, 232, 233, 706, 1018, 236, 1092, 238,
3568  1104, 866, 581, 242, 583, 244, 1196, 53, 54, 133,
3569  769, 57, 591, 883, 740, 1237, 1237, 514, 257, 324,
3570  259, 887, 601, 1013, 603, 604, 131, 132, 133, 134,
3571  135, 136, 137, 138, 1077, 1077, 1090, 83, 885, 945,
3572  52, 947, 54, 55, 56, 57, 1234, 1077, 783, 784,
3573  96, 97, 98, 99, 1011, 1039, 105, 99, 1042, 638,
3574  500, 952, 783, 784, 855, 968, 969, 1102, 1054, 1031,
3575  309, 310, 311, 312, 313, 314, 315, 316, 1062, 77,
3576  1064, 1058, 1028, 54, 55, 983, 57, 326, -1, 328,
3577  -1, -1, 331, 64, 65, -1, 94, 95, -1, -1,
3578  679, -1, -1, -1, 683, 684, -1, -1, 687, -1,
3579  -1, 1121, 691, 692, 59, 60, 61, 62, 697, 698,
3580  -1, -1, -1, 691, 692, 364, -1, 366, -1, 697,
3581  698, 370, 371, 372, -1, 133, 134, 135, 136, 137,
3582  138, -1, 877, 878, -1, -1, -1, 386, 727, -1,
3583  729, 730, 887, 888, 889, -1, 877, 878, 893, 894,
3584  -1, -1, -1, 209, -1, -1, 887, 888, 889, -1,
3585  -1, 1181, 893, 894, -1, 414, 415, 745, 746, -1,
3586  748, 749, -1, -1, -1, 1169, -1, 1171, -1, -1,
3587  429, -1, 1176, -1, -1, -1, 242, -1, 244, -1,
3588  1184, -1, 1186, -1, 1110, 1111, -1, -1, -1, 1193,
3589  1116, 257, 1118, 259, 1120, -1, 689, 52, -1, 54,
3590  55, 56, 57, 58, -1, -1, 465, 1130, 1131, -1,
3591  -1, -1, -1, 1136, 280, 1138, 1139, 816, -1, -1,
3592  -1, 1225, 77, 978, -1, 484, 1230, -1, 816, 828,
3593  -1, 986, -1, -1, 833, 834, 52, 978, 54, 55,
3594  56, 57, -1, 309, -1, 986, 101, -1, 314, -1,
3595  849, -1, 107, 108, 109, -1, -1, 856, 1013, -1,
3596  -1, -1, 328, 329, -1, -1, -1, -1, 867, -1,
3597  -1, 870, 1013, 861, 2, 1089, 4, -1, 133, -1,
3598  -1, 136, -1, 1209, 1210, 1211, 1212, -1, -1, -1,
3599  783, 784, 1215, 1216, 1217, 1218, -1, -1, 153, -1,
3600  366, 77, -1, 902, 370, -1, 372, -1, -1, 1235,
3601  -1, -1, 911, 1236, 1069, -1, -1, -1, 94, 95,
3602  -1, -1, 581, -1, 583, 53, 54, -1, 1069, 57,
3603  -1, 52, 591, 54, 55, 56, 57, 58, -1, -1,
3604  -1, -1, 601, -1, 603, 604, -1, -1, -1, 52,
3605  -1, 54, 55, 56, 57, 83, 77, 56, 134, 135,
3606  136, 137, 138, -1, -1, -1, -1, -1, 96, 97,
3607  98, -1, 52, -1, 54, 55, 56, 57, -1, 638,
3608  101, -1, -1, -1, 877, 878, 107, 108, 109, 1144,
3609  -1, -1, -1, 1148, 887, 888, 889, -1, 101, 465,
3610  893, 894, -1, 1144, 107, -1, -1, 1148, -1, 1164,
3611  -1, 1010, 133, 1012, -1, 136, 482, -1, -1, -1,
3612  679, 101, -1, 1164, 683, 684, -1, 148, 687, -1,
3613  -1, -1, 691, 692, -1, -1, -1, -1, 697, 698,
3614  -1, -1, -1, -1, 1199, 1200, -1, -1, 1047, -1,
3615  -1, 1050, -1, -1, -1, -1, -1, -1, 1199, 1200,
3616  526, -1, -1, -1, -1, -1, -1, -1, 727, -1,
3617  729, 730, -1, -1, -1, -1, -1, -1, -1, -1,
3618  -1, 209, -1, -1, -1, 978, -1, -1, -1, 1088,
3619  -1, -1, -1, 986, -1, -1, -1, -1, 52, -1,
3620  54, 55, 56, 57, 58, -1, -1, -1, 207, -1,
3621  -1, 210, 211, 212, 242, 581, 244, 583, -1, -1,
3622  1013, -1, -1, 77, 1123, 1124, -1, -1, -1, 257,
3623  -1, 259, -1, -1, -1, -1, -1, 603, -1, -1,
3624  -1, -1, -1, -1, -1, -1, -1, 101, -1, -1,
3625  -1, -1, 280, 107, 108, 109, -1, 816, -1, 689,
3626  -1, -1, -1, 1162, 1163, -1, -1, -1, -1, 828,
3627  -1, -1, -1, -1, 833, 834, 1069, -1, -1, 133,
3628  -1, 309, 136, -1, 650, -1, 314, -1, -1, -1,
3629  849, -1, -1, -1, -1, -1, -1, 856, -1, -1,
3630  328, 329, -1, 331, -1, -1, -1, -1, 867, -1,
3631  -1, 870, -1, 679, -1, -1, 682, 683, -1, -1,
3632  -1, -1, -1, 689, -1, -1, -1, 326, -1, -1,
3633  -1, -1, 331, -1, -1, 1234, -1, -1, 366, -1,
3634  -1, -1, 370, 902, 372, -1, -1, -1, -1, -1,
3635  -1, 1144, 911, 783, 784, 1148, -1, -1, -1, -1,
3636  -1, 727, -1, -1, 730, -1, -1, -1, -1, -1,
3637  -1, 1164, -1, -1, -1, -1, -1, -1, -1, -1,
3638  -1, -1, -1, -1, -1, -1, 414, 415, -1, 52,
3639  -1, 54, 55, 56, 57, 58, -1, -1, -1, -1,
3640  -1, -1, -1, -1, -1, -1, 1199, 1200, -1, -1,
3641  -1, -1, -1, -1, 77, -1, -1, 783, 784, -1,
3642  -1, -1, -1, -1, -1, 424, 425, -1, 91, -1,
3643  -1, -1, -1, -1, 433, -1, -1, 465, 101, -1,
3644  -1, -1, -1, -1, 107, 108, 109, 877, 878, -1,
3645  -1, 1010, -1, 1012, 482, -1, -1, 887, 888, 889,
3646  -1, -1, 828, 893, 894, -1, -1, 833, -1, -1,
3647  133, 470, -1, 136, 473, -1, -1, -1, -1, -1,
3648  -1, -1, 2, 849, 4, -1, -1, -1, 1047, -1,
3649  856, 1050, -1, -1, -1, -1, -1, -1, 526, -1,
3650  -1, 867, -1, -1, 870, -1, -1, -1, -1, -1,
3651  -1, 877, 878, -1, -1, -1, -1, -1, -1, -1,
3652  519, 887, 888, 889, -1, -1, -1, 893, 894, 1088,
3653  -1, -1, 898, 53, 54, -1, 902, 57, -1, -1,
3654  -1, -1, -1, 689, -1, 911, -1, -1, 978, -1,
3655  -1, -1, -1, 581, -1, 583, 986, -1, -1, -1,
3656  -1, -1, -1, 83, 1123, 1124, -1, -1, -1, -1,
3657  -1, -1, -1, -1, -1, 603, 96, 97, 98, 99,
3658  -1, -1, -1, 1013, -1, -1, -1, -1, -1, -1,
3659  -1, -1, -1, -1, -1, -1, 962, 689, -1, -1,
3660  -1, -1, -1, 1162, 1163, -1, -1, -1, -1, -1,
3661  -1, -1, 978, -1, -1, -1, -1, -1, -1, 618,
3662  986, 620, 650, -1, -1, -1, -1, -1, -1, -1,
3663  -1, 659, -1, -1, 633, -1, 635, 783, 784, 1069,
3664  -1, -1, -1, -1, 1010, -1, 1012, 1013, -1, -1,
3665  -1, 679, -1, -1, 682, 683, 684, -1, -1, -1,
3666  -1, -1, -1, 691, 692, -1, -1, -1, -1, 697,
3667  698, -1, -1, -1, 2, 1234, 4, -1, -1, 678,
3668  -1, 1047, -1, -1, 1050, -1, -1, 1053, -1, 209,
3669  -1, 783, 784, -1, -1, -1, -1, -1, 2, 727,
3670  4, -1, 730, 1069, -1, -1, 705, -1, -1, -1,
3671  -1, -1, -1, -1, 1144, -1, -1, -1, 1148, -1,
3672  -1, 720, 242, -1, 244, 53, 54, -1, -1, -1,
3673  -1, 877, 878, -1, 1164, -1, -1, 257, -1, 259,
3674  -1, 887, 888, 889, -1, -1, -1, 893, 894, 53,
3675  54, -1, -1, -1, -1, -1, -1, 1123, 1124, -1,
3676  280, 689, -1, -1, -1, -1, -1, -1, 96, 1199,
3677  1200, 770, -1, -1, -1, -1, -1, -1, 1144, -1,
3678  -1, -1, 1148, -1, -1, 877, 878, -1, 816, 309,
3679  -1, -1, -1, -1, 314, 887, 888, 889, 1164, -1,
3680  828, 893, 894, -1, -1, 833, -1, -1, 328, 329,
3681  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3682  -1, 849, -1, -1, -1, -1, -1, -1, 856, -1,
3683  -1, -1, 978, 1199, 1200, -1, -1, -1, -1, 867,
3684  986, -1, 870, -1, 843, -1, 366, -1, -1, -1,
3685  370, -1, 372, -1, -1, 783, 784, -1, -1, -1,
3686  -1, -1, -1, 862, -1, -1, -1, 1013, 1234, -1,
3687  898, -1, -1, -1, 902, -1, -1, -1, -1, -1,
3688  -1, 209, -1, 911, -1, -1, 978, -1, -1, -1,
3689  -1, -1, -1, 689, 986, -1, -1, -1, -1, -1,
3690  -1, -1, -1, -1, -1, 209, -1, -1, -1, -1,
3691  -1, 910, -1, -1, 242, -1, 244, -1, -1, -1,
3692  -1, 1013, -1, 1069, -1, -1, -1, -1, -1, 257,
3693  -1, 259, -1, -1, 962, -1, -1, -1, 242, 938,
3694  244, -1, -1, -1, -1, 465, -1, -1, -1, 877,
3695  878, -1, -1, 257, -1, 259, -1, -1, -1, 887,
3696  888, 889, 482, -1, -1, 893, 894, -1, -1, -1,
3697  -1, -1, -1, -1, -1, -1, -1, 1069, -1, -1,
3698  -1, 309, 1010, -1, 1012, -1, 314, 783, 784, -1,
3699  -1, -1, -1, -1, -1, -1, -1, -1, 1144, -1,
3700  328, -1, 1148, 331, -1, 309, 526, -1, -1, -1,
3701  314, -1, -1, -1, -1, 1014, -1, -1, 1164, 1047,
3702  -1, -1, 1050, -1, 328, 1053, -1, 331, 1027, -1,
3703  -1, -1, -1, -1, -1, -1, -1, -1, 366, -1,
3704  -1, -1, 370, -1, 372, -1, -1, -1, -1, -1,
3705  978, -1, 1144, 1199, 1200, -1, 1148, -1, 986, -1,
3706  -1, 581, 366, 583, -1, -1, 370, -1, 372, -1,
3707  -1, -1, 1164, -1, -1, -1, -1, -1, -1, -1,
3708  -1, 877, 878, 603, -1, 1013, 414, 415, -1, -1,
3709  -1, 887, 888, 889, -1, 1123, 1124, 893, 894, -1,
3710  -1, -1, -1, -1, -1, -1, -1, 1199, 1200, -1,
3711  414, 415, -1, -1, -1, -1, -1, -1, -1, -1,
3712  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3713  650, -1, -1, -1, -1, -1, -1, 465, -1, 25,
3714  -1, 1069, -1, 0, -1, -1, -1, -1, -1, -1,
3715  -1, 8, 9, 10, -1, -1, 13, 14, 15, 679,
3716  17, 465, 682, 683, -1, -1, -1, -1, 25, 26,
3717  27, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3718  37, 38, 978, 40, 41, 42, 43, 44, -1, -1,
3719  986, 77, 78, 79, 80, 81, 82, 83, 84, 85,
3720  86, 87, 88, 89, -1, -1, 1234, 727, 94, 95,
3721  730, 68, -1, -1, -1, -1, 1144, 1013, -1, -1,
3722  1148, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3723  -1, -1, -1, -1, -1, -1, 1164, -1, -1, 96,
3724  97, 127, -1, 129, 130, 131, 132, 133, 134, 135,
3725  136, 137, 138, 581, -1, 583, -1, -1, -1, -1,
3726  -1, -1, -1, 120, -1, -1, -1, -1, -1, -1,
3727  -1, 1199, 1200, 1069, -1, 603, -1, 581, -1, 583,
3728  -1, -1, -1, -1, -1, -1, 143, 144, -1, -1,
3729  -1, 148, 149, -1, 151, -1, 153, -1, -1, 603,
3730  -1, -1, -1, -1, -1, -1, -1, -1, 828, -1,
3731  -1, -1, -1, 833, -1, -1, -1, -1, -1, -1,
3732  -1, -1, -1, -1, -1, -1, -1, -1, -1, 849,
3733  -1, -1, -1, -1, -1, -1, 856, -1, -1, -1,
3734  -1, -1, -1, -1, -1, -1, -1, 867, 1144, -1,
3735  870, 679, 1148, -1, -1, 683, 684, -1, -1, -1,
3736  -1, -1, -1, 691, 692, -1, -1, -1, 1164, 697,
3737  698, -1, -1, -1, -1, 679, -1, -1, 898, 683,
3738  684, -1, 902, -1, -1, -1, -1, 691, 692, -1,
3739  -1, 911, -1, 697, 698, -1, -1, -1, -1, 727,
3740  -1, -1, 730, 1199, 1200, -1, -1, -1, -1, -1,
3741  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3742  -1, -1, -1, 727, -1, -1, 730, -1, -1, -1,
3743  16, 17, -1, -1, -1, -1, -1, -1, -1, -1,
3744  -1, -1, 962, -1, -1, -1, -1, -1, -1, -1,
3745  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3746  -1, -1, 48, 49, 50, 51, -1, -1, -1, 55,
3747  56, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3748  -1, -1, 68, 69, -1, -1, -1, -1, 816, -1,
3749  1010, -1, 1012, -1, -1, -1, -1, -1, -1, -1,
3750  828, -1, -1, -1, -1, 833, -1, -1, -1, -1,
3751  -1, -1, 816, -1, 100, -1, -1, -1, -1, -1,
3752  -1, 849, -1, -1, 828, -1, -1, 1047, 856, 833,
3753  1050, -1, -1, 1053, -1, -1, -1, -1, -1, 867,
3754  -1, -1, 870, -1, -1, 849, -1, -1, -1, -1,
3755  -1, -1, 856, -1, -1, -1, -1, -1, -1, -1,
3756  -1, -1, -1, 867, -1, -1, 870, -1, -1, -1,
3757  898, -1, -1, -1, 902, -1, -1, -1, -1, -1,
3758  -1, -1, -1, 911, 33, 34, 35, 36, -1, -1,
3759  -1, -1, -1, -1, -1, -1, -1, -1, 902, -1,
3760  49, 50, 51, 1123, 1124, -1, -1, 911, -1, -1,
3761  59, 60, 61, 62, 63, -1, -1, -1, -1, -1,
3762  -1, 207, -1, -1, 210, 211, 212, -1, 214, -1,
3763  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3764  -1, -1, -1, -1, 230, -1, 232, 233, -1, -1,
3765  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3766  -1, 110, 111, 112, 113, 114, 115, 116, 117, 118,
3767  -1, 77, 78, 79, 80, 81, 82, 83, 84, -1,
3768  86, 87, 1010, -1, 1012, -1, -1, -1, 94, 95,
3769  139, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3770  -1, -1, -1, -1, -1, -1, 1010, -1, 1012, -1,
3771  -1, -1, -1, -1, 1234, -1, -1, -1, -1, 1047,
3772  -1, -1, 1050, 129, 130, 131, 132, 133, 134, 135,
3773  136, 137, 138, -1, -1, -1, -1, -1, -1, -1,
3774  326, -1, -1, 1047, -1, 331, 1050, 333, 334, 335,
3775  336, 337, -1, -1, 340, 341, 342, 343, 344, 345,
3776  346, 347, 348, -1, -1, 351, 352, 353, 354, 355,
3777  356, 357, 358, 359, 360, -1, -1, -1, 364, -1,
3778  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3779  -1, -1, -1, -1, -1, 1123, 1124, -1, -1, -1,
3780  -1, -1, -1, -1, 77, 78, 79, 80, 81, 82,
3781  83, 84, 85, 86, 87, 88, 89, -1, -1, 1123,
3782  1124, 94, 95, -1, -1, -1, -1, -1, 414, 415,
3783  -1, -1, -1, -1, -1, -1, -1, 423, 424, 425,
3784  -1, -1, -1, 429, -1, 431, 432, 433, -1, -1,
3785  -1, -1, -1, 439, 127, -1, 129, 130, 131, 132,
3786  133, 134, 135, 136, 137, 138, -1, -1, 454, -1,
3787  -1, -1, -1, 459, -1, -1, -1, -1, -1, -1,
3788  153, -1, -1, -1, 470, -1, -1, 473, -1, -1,
3789  -1, -1, -1, -1, -1, -1, -1, -1, 484, -1,
3790  -1, -1, -1, -1, -1, -1, 1234, -1, -1, -1,
3791  -1, -1, -1, -1, -1, -1, 502, 77, 78, 79,
3792  80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
3793  1234, -1, -1, 519, 94, 95, -1, -1, -1, -1,
3794  -1, -1, 0, -1, -1, -1, -1, -1, -1, -1,
3795  8, 9, 10, -1, -1, -1, 14, 15, -1, 17,
3796  -1, -1, -1, -1, -1, -1, -1, 25, 26, 129,
3797  130, 131, 132, 133, 134, 135, 136, 137, 138, 37,
3798  38, -1, 40, 41, 42, 43, 44, -1, -1, -1,
3799  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3800  -1, -1, -1, -1, -1, 591, -1, -1, -1, -1,
3801  68, -1, -1, -1, -1, 601, -1, -1, -1, 77,
3802  78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
3803  88, 89, 618, -1, 620, -1, 94, 95, 96, 97,
3804  -1, 99, -1, -1, -1, -1, -1, 633, -1, 635,
3805  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3806  -1, -1, 120, -1, -1, -1, -1, -1, 126, 127,
3807  -1, 129, 130, 131, 132, 133, 134, 135, 136, 137,
3808  138, -1, -1, -1, -1, 143, 144, 145, 146, -1,
3809  -1, 149, 678, 151, -1, 153, -1, -1, 684, 685,
3810  -1, 687, -1, -1, -1, 691, 692, -1, -1, -1,
3811  -1, 697, 698, -1, 33, 34, 35, 36, -1, 705,
3812  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3813  49, 50, 51, 52, 720, -1, -1, 56, -1, 58,
3814  59, 60, 61, 62, 63, -1, -1, -1, -1, -1,
3815  -1, -1, -1, -1, -1, -1, -1, -1, 77, 745,
3816  746, -1, 748, 749, -1, -1, -1, -1, -1, -1,
3817  -1, 90, 91, -1, -1, -1, -1, -1, -1, 98,
3818  -1, -1, 101, -1, 770, 104, 105, -1, 107, 108,
3819  -1, 110, 111, 112, 113, 114, 115, 116, 117, 118,
3820  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3821  -1, -1, -1, 132, -1, -1, -1, -1, -1, -1,
3822  139, -1, -1, 809, -1, -1, -1, -1, -1, -1,
3823  816, -1, 0, 1, -1, 3, 4, 5, 6, 7,
3824  -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
3825  18, 19, 20, 21, 22, 23, 24, 843, -1, -1,
3826  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
3827  -1, 39, -1, -1, -1, 861, 862, 45, 46, 47,
3828  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
3829  -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
3830  -1, -1, -1, -1, -1, -1, -1, 75, 76, -1,
3831  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3832  -1, -1, 90, 91, 910, -1, -1, -1, -1, -1,
3833  98, -1, -1, 101, 102, -1, 104, 105, -1, 107,
3834  -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
3835  118, -1, 938, -1, -1, -1, -1, -1, -1, -1,
3836  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3837  -1, 139, 140, 141, -1, -1, -1, -1, 0, -1,
3838  -1, -1, -1, 151, -1, 153, 8, 9, 10, -1,
3839  -1, 13, 14, 15, -1, 17, -1, -1, -1, -1,
3840  -1, -1, -1, 25, 26, 27, 28, 29, -1, -1,
3841  -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
3842  42, 43, 44, -1, -1, -1, -1, -1, 1014, -1,
3843  -1, -1, -1, 77, 78, 79, 80, 81, 82, 83,
3844  -1, 1027, 86, 87, -1, -1, 68, -1, -1, -1,
3845  94, 95, -1, -1, -1, 77, 78, 79, 80, 81,
3846  82, 83, 84, 85, 86, 87, 88, 89, -1, -1,
3847  -1, -1, 94, 95, 96, 97, -1, 99, 100, -1,
3848  -1, -1, -1, -1, 106, 129, 130, 131, 132, 133,
3849  134, 135, 136, 137, 138, -1, -1, -1, 120, -1,
3850  -1, 123, 1088, -1, 126, 127, 128, 129, 130, 131,
3851  132, 133, 134, 135, 136, 137, 138, -1, -1, -1,
3852  -1, 143, 144, 145, 146, 0, -1, 149, 150, 151,
3853  -1, 153, -1, 8, 9, 10, -1, -1, 13, 14,
3854  15, -1, 17, -1, -1, -1, -1, 44, -1, -1,
3855  25, -1, 27, 28, 29, -1, -1, -1, -1, -1,
3856  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3857  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3858  77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
3859  87, 88, 89, 68, -1, -1, -1, 94, 95, -1,
3860  -1, -1, 77, 78, 79, 80, 81, 82, 83, 84,
3861  85, 86, 87, 88, 89, -1, -1, -1, -1, 94,
3862  95, 96, 97, -1, 99, 100, -1, -1, -1, -1,
3863  127, 106, 129, 130, 131, 132, 133, 134, 135, 136,
3864  137, 138, -1, -1, -1, 120, -1, -1, 123, 146,
3865  -1, 126, 127, 128, 129, 130, 131, 132, 133, 134,
3866  135, 136, 137, 138, -1, -1, -1, -1, -1, 144,
3867  145, 146, 0, -1, 149, 150, 151, -1, 153, -1,
3868  8, 9, 10, -1, -1, 13, 14, 15, -1, 17,
3869  -1, -1, -1, -1, 44, -1, -1, 25, -1, 27,
3870  28, 29, -1, -1, -1, -1, -1, -1, -1, 37,
3871  38, -1, 40, 41, 42, 43, 44, -1, -1, -1,
3872  -1, -1, -1, -1, -1, -1, -1, 77, 78, 79,
3873  80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
3874  68, -1, -1, -1, 94, 95, -1, -1, -1, 77,
3875  78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
3876  88, 89, -1, -1, -1, -1, 94, 95, 96, 97,
3877  -1, 99, 100, -1, -1, -1, -1, 127, 106, 129,
3878  130, 131, 132, 133, 134, 135, 136, 137, 138, -1,
3879  -1, -1, 120, -1, -1, 123, -1, -1, 126, 127,
3880  128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
3881  138, -1, -1, -1, -1, -1, 144, 145, 146, 0,
3882  -1, 149, 150, 151, -1, 153, -1, 8, 9, 10,
3883  -1, -1, 13, 14, 15, -1, 17, -1, -1, -1,
3884  -1, -1, -1, -1, 25, 26, 27, 28, 29, -1,
3885  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3886  41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
3887  -1, -1, -1, -1, 77, 78, 79, 80, 81, 82,
3888  83, 84, 85, 86, 87, 88, 89, 68, -1, -1,
3889  -1, 94, 95, -1, -1, -1, 77, 78, 79, 80,
3890  81, 82, 83, 84, 85, 86, 87, 88, 89, -1,
3891  -1, -1, -1, 94, 95, 96, 97, -1, -1, 100,
3892  -1, -1, -1, -1, 127, 106, 129, 130, 131, 132,
3893  133, 134, 135, 136, 137, 138, -1, -1, -1, 120,
3894  -1, -1, 123, -1, -1, -1, 127, 128, 129, 130,
3895  131, 132, 133, 134, 135, 136, 137, 138, -1, -1,
3896  -1, -1, 143, 144, 145, 146, 0, -1, 149, 150,
3897  151, -1, 153, -1, 8, 9, 10, -1, -1, 13,
3898  14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
3899  -1, 25, 26, 27, 28, 29, -1, -1, -1, -1,
3900  -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
3901  44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3902  -1, 77, 78, 79, 80, 81, 82, 83, -1, -1,
3903  86, 87, -1, -1, 68, -1, -1, -1, 94, 95,
3904  -1, -1, -1, 77, 78, 79, 80, 81, 82, 83,
3905  84, 85, 86, 87, 88, 89, -1, -1, -1, -1,
3906  94, 95, 96, 97, -1, -1, 100, -1, -1, -1,
3907  -1, -1, 106, 129, 130, 131, 132, 133, 134, 135,
3908  136, 137, 138, -1, -1, -1, 120, -1, -1, 123,
3909  -1, -1, -1, 127, 128, 129, 130, 131, 132, 133,
3910  134, 135, 136, 137, 138, -1, -1, -1, -1, 143,
3911  144, 145, 146, 0, -1, 149, 150, 151, -1, 153,
3912  -1, 8, 9, 10, -1, -1, 13, 14, 15, -1,
3913  17, -1, -1, -1, -1, -1, -1, -1, 25, -1,
3914  27, 28, 29, -1, -1, -1, -1, -1, -1, -1,
3915  37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
3916  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3917  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3918  -1, 68, -1, -1, -1, -1, -1, -1, -1, -1,
3919  77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
3920  87, 88, 89, -1, -1, -1, -1, 94, 95, 96,
3921  97, -1, 99, 100, -1, -1, -1, -1, -1, 106,
3922  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3923  -1, -1, -1, 120, -1, -1, 123, -1, -1, 126,
3924  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
3925  137, 138, -1, -1, -1, -1, -1, 144, 145, 146,
3926  0, -1, 149, 150, 151, -1, 153, -1, 8, 9,
3927  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3928  -1, -1, -1, -1, -1, 25, 26, 27, 28, -1,
3929  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3930  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3931  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3932  -1, -1, -1, -1, -1, -1, -1, -1, 68, -1,
3933  -1, -1, -1, -1, -1, -1, -1, 77, 78, 79,
3934  80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
3935  -1, -1, -1, -1, 94, 95, 96, 97, -1, -1,
3936  100, -1, -1, -1, -1, -1, 106, -1, -1, -1,
3937  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3938  120, -1, -1, -1, -1, -1, -1, 127, -1, 129,
3939  130, 131, 132, 133, 134, 135, 136, 137, 138, -1,
3940  -1, -1, -1, 143, 144, 145, 146, 0, 148, 149,
3941  150, 151, -1, 153, -1, 8, 9, 10, -1, -1,
3942  13, 14, 15, -1, 17, -1, -1, -1, -1, -1,
3943  -1, -1, 25, -1, 27, 28, 29, -1, -1, -1,
3944  -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
3945  43, 44, -1, -1, -1, -1, -1, -1, -1, -1,
3946  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3947  -1, -1, -1, -1, -1, 68, -1, -1, -1, -1,
3948  -1, -1, -1, -1, 77, 78, 79, 80, 81, 82,
3949  83, 84, 85, 86, 87, 88, 89, -1, -1, -1,
3950  -1, 94, 95, 96, 97, -1, -1, 100, -1, -1,
3951  -1, -1, -1, 106, -1, -1, -1, -1, -1, -1,
3952  -1, -1, -1, -1, -1, -1, -1, 120, -1, -1,
3953  123, -1, -1, -1, 127, 128, 129, 130, 131, 132,
3954  133, 134, 135, 136, 137, 138, -1, -1, -1, -1,
3955  -1, 144, 145, 146, 0, -1, 149, 150, 151, -1,
3956  153, -1, 8, 9, 10, -1, -1, 13, 14, 15,
3957  -1, 17, -1, -1, -1, -1, -1, -1, -1, 25,
3958  26, 27, 28, -1, -1, -1, -1, -1, -1, -1,
3959  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3960  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3961  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3962  -1, -1, 68, -1, -1, -1, -1, -1, -1, -1,
3963  -1, 77, 78, 79, 80, 81, 82, 83, 84, 85,
3964  86, 87, 88, 89, -1, -1, -1, -1, 94, 95,
3965  96, 97, -1, -1, 100, -1, -1, -1, -1, -1,
3966  106, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3967  -1, -1, -1, -1, 120, -1, -1, -1, -1, -1,
3968  -1, 127, -1, 129, 130, 131, 132, 133, 134, 135,
3969  136, 137, 138, -1, -1, -1, -1, 143, 144, 145,
3970  146, 0, 148, 149, 150, 151, -1, 153, -1, 8,
3971  9, 10, -1, -1, 13, 14, 15, -1, 17, -1,
3972  -1, -1, -1, -1, -1, -1, 25, -1, 27, 28,
3973  -1, -1, -1, -1, -1, -1, -1, -1, 37, 38,
3974  -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
3975  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3976  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
3977  -1, -1, -1, -1, -1, -1, -1, -1, 77, 78,
3978  79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
3979  89, -1, -1, -1, -1, 94, 95, 96, 97, -1,
3980  -1, 100, -1, -1, -1, -1, -1, 106, -1, -1,
3981  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3982  -1, 120, -1, -1, -1, -1, -1, -1, 127, -1,
3983  129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
3984  -1, -1, -1, -1, -1, 144, 145, 146, 0, 148,
3985  149, 150, 151, -1, 153, -1, 8, 9, 10, -1,
3986  -1, -1, 14, 15, -1, 17, -1, -1, -1, -1,
3987  -1, -1, -1, 25, 26, -1, -1, -1, -1, -1,
3988  -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
3989  42, 43, 44, -1, -1, -1, -1, -1, -1, -1,
3990  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3991  -1, -1, -1, -1, -1, -1, 68, -1, -1, -1,
3992  -1, -1, -1, -1, -1, 77, 78, 79, 80, 81,
3993  82, 83, 84, 85, 86, 87, 88, 89, -1, -1,
3994  -1, -1, 94, 95, 96, 97, -1, 99, -1, -1,
3995  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3996  -1, -1, -1, -1, -1, -1, -1, -1, 120, -1,
3997  -1, -1, -1, -1, 126, 127, -1, 129, 130, 131,
3998  132, 133, 134, 135, 136, 137, 138, -1, -1, -1,
3999  -1, 143, 144, 145, 146, 0, -1, 149, -1, 151,
4000  -1, 153, -1, 8, 9, 10, -1, -1, -1, 14,
4001  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
4002  25, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4003  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
4004  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4005  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4006  -1, -1, -1, 68, -1, -1, -1, -1, -1, -1,
4007  -1, -1, 77, 78, 79, 80, 81, 82, 83, 84,
4008  85, 86, 87, 88, 89, -1, -1, -1, -1, 94,
4009  95, 96, 97, -1, 99, -1, -1, -1, -1, -1,
4010  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4011  -1, -1, -1, -1, -1, 120, -1, -1, -1, -1,
4012  -1, 126, 127, -1, 129, 130, 131, 132, 133, 134,
4013  135, 136, 137, 138, -1, -1, -1, -1, -1, 144,
4014  145, 146, 0, -1, 149, -1, 151, -1, 153, -1,
4015  8, 9, 10, -1, -1, -1, 14, 15, -1, 17,
4016  -1, -1, -1, -1, -1, -1, -1, 25, -1, -1,
4017  -1, -1, -1, -1, -1, -1, -1, -1, -1, 37,
4018  38, -1, 40, 41, 42, 43, 44, -1, -1, -1,
4019  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4020  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4021  68, -1, -1, -1, -1, -1, -1, -1, -1, 77,
4022  78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
4023  88, 89, -1, -1, -1, -1, 94, 95, 96, 97,
4024  -1, 99, -1, -1, -1, -1, -1, -1, -1, -1,
4025  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4026  -1, -1, 120, -1, -1, -1, -1, -1, 126, 127,
4027  -1, 129, 130, 131, 132, 133, 134, 135, 136, 137,
4028  138, -1, -1, -1, -1, -1, 144, 145, 146, -1,
4029  -1, 149, -1, 151, 1, 153, 3, 4, 5, 6,
4030  7, 8, 9, 10, 11, 12, -1, -1, 15, 16,
4031  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
4032  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4033  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
4034  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4035  57, -1, 59, 60, 61, 62, 63, 64, 65, -1,
4036  -1, -1, -1, -1, -1, -1, -1, -1, 75, 76,
4037  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4038  -1, -1, -1, 90, 91, -1, -1, -1, -1, -1,
4039  -1, 98, -1, -1, 101, 102, -1, 104, 105, -1,
4040  107, -1, -1, 110, 111, 112, 113, 114, 115, 116,
4041  117, 118, -1, -1, -1, -1, -1, -1, -1, -1,
4042  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4043  -1, -1, 139, 140, 141, -1, -1, -1, -1, -1,
4044  -1, -1, -1, -1, 151, 1, 153, 3, 4, 5,
4045  6, 7, -1, -1, 10, 11, 12, -1, 14, 15,
4046  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4047  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4048  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
4049  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
4050  56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
4051  -1, -1, -1, -1, -1, -1, -1, -1, -1, 75,
4052  76, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4053  -1, -1, -1, -1, 90, 91, -1, -1, -1, -1,
4054  -1, -1, 98, -1, -1, 101, 102, -1, 104, 105,
4055  -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
4056  116, 117, 118, -1, -1, -1, -1, -1, -1, -1,
4057  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4058  -1, -1, -1, 139, 140, 141, -1, -1, -1, -1,
4059  -1, -1, -1, -1, -1, 151, 1, 153, 3, 4,
4060  5, 6, 7, -1, -1, 10, 11, 12, -1, -1,
4061  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
4062  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4063  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4064  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
4065  55, 56, 57, -1, 59, 60, 61, 62, 63, 64,
4066  65, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4067  75, 76, -1, -1, -1, -1, -1, -1, -1, -1,
4068  -1, -1, -1, -1, -1, 90, 91, -1, -1, -1,
4069  -1, -1, -1, 98, -1, -1, 101, 102, -1, 104,
4070  105, -1, 107, -1, -1, 110, 111, 112, 113, 114,
4071  115, 116, 117, 118, -1, -1, -1, -1, -1, -1,
4072  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4073  -1, -1, -1, -1, 139, 140, 141, -1, -1, -1,
4074  -1, -1, -1, -1, -1, -1, 151, 1, 153, 3,
4075  4, 5, 6, 7, -1, -1, 10, 11, 12, -1,
4076  -1, 15, 16, -1, 18, 19, 20, 21, 22, 23,
4077  24, 25, -1, -1, -1, -1, 30, 31, 32, 33,
4078  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4079  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
4080  54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
4081  64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
4082  -1, 75, 76, -1, -1, -1, -1, -1, -1, -1,
4083  -1, -1, -1, -1, -1, -1, 90, 91, -1, -1,
4084  -1, -1, -1, -1, 98, -1, -1, 101, 102, -1,
4085  104, 105, -1, 107, -1, -1, 110, 111, 112, 113,
4086  114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
4087  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4088  -1, -1, -1, -1, -1, 139, 140, 141, -1, -1,
4089  -1, -1, -1, -1, -1, -1, -1, 151, 1, 153,
4090  3, 4, 5, 6, 7, -1, -1, 10, 11, 12,
4091  -1, -1, 15, 16, -1, 18, 19, 20, 21, 22,
4092  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4093  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4094  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
4095  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
4096  63, 64, 65, -1, -1, -1, -1, -1, -1, -1,
4097  -1, -1, 75, 76, -1, -1, -1, -1, -1, -1,
4098  -1, -1, -1, -1, -1, -1, -1, 90, 91, -1,
4099  -1, -1, -1, -1, -1, 98, -1, -1, 101, 102,
4100  -1, 104, 105, -1, 107, -1, -1, 110, 111, 112,
4101  113, 114, 115, 116, 117, 118, -1, -1, -1, -1,
4102  -1, -1, -1, -1, 1, -1, 3, 4, 5, 6,
4103  7, -1, 9, 10, 11, 12, 139, 140, 141, 16,
4104  -1, 18, 19, 20, 21, 22, 23, 24, 151, -1,
4105  153, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4106  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
4107  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4108  57, -1, 59, 60, 61, 62, 63, 64, 65, -1,
4109  -1, -1, -1, -1, -1, -1, -1, -1, 75, 76,
4110  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4111  -1, -1, -1, 90, 91, -1, -1, -1, -1, -1,
4112  -1, 98, -1, -1, 101, 102, -1, 104, 105, -1,
4113  107, -1, -1, 110, 111, 112, 113, 114, 115, 116,
4114  117, 118, -1, -1, -1, -1, -1, -1, -1, -1,
4115  1, -1, 3, 4, 5, 6, 7, -1, -1, -1,
4116  11, 12, 139, 140, 141, 16, -1, 18, 19, 20,
4117  21, 22, 23, 24, 151, -1, 153, -1, -1, 30,
4118  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4119  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
4120  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4121  61, 62, 63, 64, 65, -1, -1, -1, -1, -1,
4122  -1, -1, -1, -1, 75, 76, -1, -1, -1, -1,
4123  -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
4124  91, -1, -1, -1, -1, -1, -1, 98, -1, -1,
4125  101, 102, -1, 104, 105, -1, 107, -1, -1, 110,
4126  111, 112, 113, 114, 115, 116, 117, 118, -1, -1,
4127  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4128  -1, -1, -1, -1, -1, -1, -1, -1, 139, 140,
4129  141, -1, -1, -1, -1, -1, -1, -1, 149, -1,
4130  151, 1, 153, 3, 4, 5, 6, 7, -1, -1,
4131  -1, 11, 12, -1, -1, -1, 16, -1, 18, 19,
4132  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4133  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4134  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
4135  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4136  60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
4137  -1, -1, -1, -1, -1, 75, 76, -1, -1, -1,
4138  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4139  90, 91, -1, -1, -1, -1, -1, -1, 98, -1,
4140  -1, 101, 102, -1, 104, 105, -1, 107, -1, -1,
4141  110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
4142  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4143  -1, -1, -1, -1, -1, -1, -1, -1, -1, 139,
4144  140, 141, -1, -1, -1, -1, -1, -1, -1, 149,
4145  -1, 151, 1, 153, 3, 4, 5, 6, 7, -1,
4146  -1, -1, 11, 12, -1, -1, -1, 16, -1, 18,
4147  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4148  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4149  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
4150  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4151  59, 60, 61, 62, 63, 64, 65, -1, -1, -1,
4152  -1, -1, -1, -1, -1, -1, 75, 76, -1, -1,
4153  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4154  -1, 90, 91, -1, -1, -1, -1, -1, -1, 98,
4155  -1, -1, 101, 102, -1, 104, 105, -1, 107, -1,
4156  -1, 110, 111, 112, 113, 114, 115, 116, 117, 118,
4157  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4158  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4159  139, 140, 141, -1, -1, 144, -1, -1, -1, -1,
4160  -1, -1, 151, 1, 153, 3, 4, 5, 6, 7,
4161  -1, -1, -1, 11, 12, -1, -1, -1, 16, -1,
4162  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4163  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4164  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
4165  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4166  -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
4167  -1, -1, -1, -1, -1, -1, -1, 75, 76, -1,
4168  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4169  -1, -1, 90, 91, -1, -1, -1, -1, -1, -1,
4170  98, -1, -1, 101, 102, -1, 104, 105, -1, 107,
4171  -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
4172  118, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4173  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4174  -1, 139, 140, 141, -1, -1, 144, -1, -1, -1,
4175  -1, -1, -1, 151, 1, 153, 3, 4, 5, 6,
4176  7, -1, -1, 10, 11, 12, -1, -1, -1, 16,
4177  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
4178  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4179  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
4180  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4181  57, -1, 59, 60, 61, 62, 63, 64, 65, -1,
4182  -1, -1, -1, -1, -1, -1, -1, -1, 75, 76,
4183  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4184  -1, -1, -1, 90, 91, -1, -1, -1, -1, -1,
4185  -1, 98, -1, -1, 101, 102, -1, 104, 105, -1,
4186  107, -1, -1, 110, 111, 112, 113, 114, 115, 116,
4187  117, 118, -1, -1, -1, -1, -1, -1, -1, -1,
4188  1, -1, 3, 4, 5, 6, 7, -1, -1, -1,
4189  11, 12, 139, 140, 141, 16, -1, 18, 19, 20,
4190  21, 22, 23, 24, 151, -1, 153, -1, -1, 30,
4191  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4192  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
4193  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4194  61, 62, 63, 64, 65, -1, -1, -1, -1, -1,
4195  -1, -1, -1, -1, 75, 76, -1, -1, -1, -1,
4196  -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
4197  91, -1, -1, -1, -1, -1, -1, 98, -1, -1,
4198  101, 102, -1, 104, 105, -1, 107, -1, -1, 110,
4199  111, 112, 113, 114, 115, 116, 117, 118, -1, 120,
4200  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
4201  5, -1, 7, -1, -1, -1, 11, 12, 139, 140,
4202  141, 16, -1, 18, 19, 20, 21, 22, 23, 24,
4203  151, -1, 153, -1, -1, 30, 31, 32, 33, 34,
4204  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4205  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
4206  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
4207  65, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4208  75, 76, -1, -1, -1, -1, -1, -1, -1, -1,
4209  -1, -1, -1, -1, -1, 90, 91, -1, -1, -1,
4210  -1, -1, -1, 98, -1, -1, 101, 102, -1, 104,
4211  105, -1, 107, 108, 109, 110, 111, 112, 113, 114,
4212  115, 116, 117, 118, -1, -1, -1, -1, -1, -1,
4213  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4214  -1, -1, 11, 12, 139, 140, 141, 16, -1, 18,
4215  19, 20, 21, 22, 23, 24, -1, -1, 153, -1,
4216  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4217  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4218  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4219  59, 60, 61, 62, 63, 64, 65, -1, -1, -1,
4220  -1, -1, -1, -1, -1, -1, 75, 76, -1, -1,
4221  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4222  -1, 90, 91, -1, -1, -1, -1, -1, -1, 98,
4223  -1, -1, 101, 102, -1, 104, 105, -1, -1, -1,
4224  -1, 110, 111, 112, 113, 114, 115, 116, 117, 118,
4225  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4226  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4227  139, 140, 141, 16, -1, 18, 19, 20, 21, 22,
4228  23, 24, 151, -1, 153, -1, -1, 30, 31, 32,
4229  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4230  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4231  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
4232  63, 64, 65, -1, -1, -1, -1, -1, -1, -1,
4233  -1, -1, 75, 76, -1, -1, -1, -1, -1, -1,
4234  -1, -1, -1, -1, -1, -1, -1, 90, 91, -1,
4235  -1, -1, -1, -1, -1, 98, -1, -1, 101, 102,
4236  -1, 104, 105, -1, -1, -1, -1, 110, 111, 112,
4237  113, 114, 115, 116, 117, 118, -1, -1, -1, -1,
4238  -1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
4239  7, -1, -1, -1, 11, 12, 139, 140, 141, 16,
4240  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
4241  153, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4242  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
4243  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4244  57, -1, 59, 60, 61, 62, 63, 64, 65, -1,
4245  -1, -1, -1, -1, -1, -1, -1, -1, 75, 76,
4246  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4247  -1, -1, -1, 90, 91, -1, -1, -1, -1, -1,
4248  -1, 98, -1, -1, 101, 102, -1, 104, 105, -1,
4249  107, -1, -1, 110, 111, 112, 113, 114, 115, 116,
4250  117, 118, -1, -1, -1, -1, -1, -1, -1, -1,
4251  -1, -1, 3, 4, 5, 6, 7, -1, -1, -1,
4252  11, 12, 139, 140, 141, 16, -1, 18, 19, 20,
4253  21, 22, 23, 24, 151, -1, -1, -1, -1, 30,
4254  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4255  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
4256  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4257  61, 62, 63, 64, 65, -1, -1, -1, -1, -1,
4258  -1, -1, -1, -1, 75, 76, -1, -1, -1, -1,
4259  -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
4260  91, -1, -1, -1, -1, -1, -1, 98, -1, -1,
4261  101, 102, -1, 104, 105, -1, 107, -1, -1, 110,
4262  111, 112, 113, 114, 115, 116, 117, 118, -1, -1,
4263  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4264  -1, -1, -1, -1, -1, -1, -1, -1, 139, 140,
4265  141, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4266  151, 3, 4, 5, 6, 7, 8, 9, 10, 11,
4267  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
4268  22, 23, 24, 25, 26, -1, -1, -1, 30, 31,
4269  32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
4270  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
4271  52, 53, 54, 55, 56, 57, -1, -1, -1, -1,
4272  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4273  -1, -1, -1, 75, 76, 77, 78, 79, 80, 81,
4274  82, 83, -1, -1, 86, 87, -1, -1, -1, -1,
4275  92, 93, 94, 95, -1, -1, -1, -1, -1, -1,
4276  -1, -1, -1, -1, -1, 107, 108, -1, -1, -1,
4277  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4278  -1, -1, -1, -1, -1, -1, -1, 129, 130, 131,
4279  132, 133, 134, 135, 136, 137, 138, -1, 140, 141,
4280  -1, -1, -1, -1, -1, 147, 148, 3, 4, 5,
4281  6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
4282  16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
4283  26, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4284  36, 37, 38, 39, -1, -1, -1, -1, -1, 45,
4285  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
4286  56, 57, -1, -1, -1, -1, -1, -1, -1, -1,
4287  -1, -1, -1, -1, -1, -1, -1, -1, -1, 75,
4288  76, 77, 78, 79, 80, 81, 82, 83, -1, -1,
4289  86, 87, -1, -1, -1, -1, 92, 93, 94, 95,
4290  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4291  -1, 107, 108, -1, -1, -1, -1, -1, -1, -1,
4292  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4293  -1, -1, -1, 129, 130, 131, 132, 133, 134, 135,
4294  136, 137, 138, -1, 140, 141, -1, -1, -1, -1,
4295  -1, 147, 3, 4, 5, 6, 7, 8, 9, 10,
4296  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
4297  21, 22, 23, 24, 25, 26, -1, -1, -1, 30,
4298  31, 32, 33, 34, 35, 36, 37, 38, 39, -1,
4299  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
4300  51, 52, 53, 54, -1, 56, -1, -1, -1, -1,
4301  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4302  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4303  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4304  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4305  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4306  111, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4307  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4308  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4309  141, -1, -1, -1, -1, -1, 147, 3, 4, 5,
4310  6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
4311  16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
4312  26, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4313  36, 37, 38, 39, -1, -1, -1, -1, -1, 45,
4314  46, 47, 48, 49, 50, 51, 52, 53, -1, -1,
4315  56, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4316  -1, -1, -1, -1, -1, -1, -1, -1, -1, 75,
4317  76, 77, 78, 79, 80, 81, 82, 83, -1, -1,
4318  86, 87, -1, -1, -1, -1, 92, 93, 94, 95,
4319  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4320  -1, 107, 108, -1, -1, 111, -1, -1, -1, -1,
4321  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4322  -1, -1, -1, 129, 130, 131, 132, 133, 134, 135,
4323  136, 137, 138, -1, 140, 141, -1, -1, -1, -1,
4324  -1, 147, 3, 4, 5, 6, 7, 8, 9, 10,
4325  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
4326  21, 22, 23, 24, 25, 26, -1, -1, -1, 30,
4327  31, 32, 33, 34, 35, 36, 37, 38, 39, -1,
4328  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
4329  51, 52, 53, -1, -1, 56, -1, -1, -1, -1,
4330  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4331  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4332  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4333  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4334  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4335  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4336  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4337  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4338  141, 3, 4, 5, -1, 7, 147, -1, -1, 11,
4339  12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
4340  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4341  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4342  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4343  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4344  62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
4345  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4346  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4347  -1, -1, -1, -1, -1, -1, 98, -1, -1, 101,
4348  102, -1, 104, 105, -1, -1, -1, -1, 110, 111,
4349  112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
4350  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4351  3, 4, 5, -1, 7, -1, -1, 139, 11, 12,
4352  -1, -1, -1, 16, 146, 18, 19, 20, 21, 22,
4353  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4354  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4355  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4356  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
4357  63, 64, 65, -1, -1, -1, -1, -1, -1, -1,
4358  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4359  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4360  -1, -1, -1, -1, -1, 98, -1, -1, 101, 102,
4361  -1, 104, 105, -1, -1, -1, -1, 110, 111, 112,
4362  113, 114, 115, 116, 117, 118, -1, -1, -1, -1,
4363  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4364  4, 5, 6, 7, -1, -1, 139, 11, 12, -1,
4365  -1, -1, 16, 146, 18, 19, 20, 21, 22, 23,
4366  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4367  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4368  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
4369  54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
4370  64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
4371  -1, 75, 76, -1, -1, -1, -1, -1, -1, -1,
4372  -1, -1, -1, -1, -1, -1, 90, 91, -1, -1,
4373  -1, -1, -1, -1, 98, -1, -1, 101, 102, -1,
4374  104, 105, -1, 107, -1, -1, 110, 111, 112, 113,
4375  114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
4376  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4377  -1, -1, -1, 11, 12, 139, 140, 141, 16, -1,
4378  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4379  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4380  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4381  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4382  58, 59, 60, 61, 62, 63, 64, 65, -1, -1,
4383  -1, -1, -1, -1, -1, -1, -1, 75, 76, -1,
4384  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4385  -1, -1, 90, 91, -1, -1, -1, -1, -1, -1,
4386  98, -1, -1, 101, 102, -1, 104, 105, -1, 107,
4387  108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
4388  118, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4389  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
4390  12, 139, 140, 141, 16, -1, 18, 19, 20, 21,
4391  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4392  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4393  -1, -1, -1, 45, 46, -1, 48, 49, 50, 51,
4394  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4395  62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
4396  -1, -1, -1, 75, 76, -1, -1, -1, -1, -1,
4397  -1, -1, -1, -1, -1, -1, -1, -1, 90, 91,
4398  -1, -1, -1, -1, -1, -1, 98, -1, -1, 101,
4399  102, -1, 104, 105, -1, 107, -1, -1, 110, 111,
4400  112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
4401  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4402  -1, 7, -1, -1, -1, 11, 12, 139, 140, 141,
4403  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4404  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4405  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4406  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4407  56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
4408  -1, -1, -1, -1, -1, -1, -1, -1, -1, 75,
4409  76, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4410  -1, -1, -1, -1, 90, 91, -1, -1, -1, -1,
4411  -1, -1, 98, -1, -1, 101, 102, -1, 104, 105,
4412  -1, 107, 108, 109, 110, 111, 112, 113, 114, 115,
4413  116, 117, 118, -1, -1, -1, -1, -1, -1, -1,
4414  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4415  -1, 11, 12, 139, 140, 141, 16, -1, 18, 19,
4416  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4417  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4418  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4419  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
4420  60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
4421  -1, -1, -1, -1, -1, 75, 76, -1, -1, -1,
4422  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4423  90, 91, -1, -1, -1, -1, -1, -1, 98, -1,
4424  -1, 101, 102, -1, 104, 105, -1, 107, 108, 109,
4425  110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
4426  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4427  4, 5, -1, 7, -1, -1, -1, 11, 12, 139,
4428  140, 141, 16, -1, 18, 19, 20, 21, 22, 23,
4429  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4430  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4431  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4432  54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
4433  64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
4434  -1, 75, 76, -1, -1, -1, -1, -1, -1, -1,
4435  -1, -1, -1, -1, -1, -1, 90, 91, -1, -1,
4436  -1, -1, -1, -1, 98, -1, -1, 101, 102, -1,
4437  104, 105, -1, 107, 108, -1, 110, 111, 112, 113,
4438  114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
4439  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4440  -1, -1, -1, 11, 12, 139, 140, 141, 16, -1,
4441  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4442  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4443  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4444  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4445  58, 59, 60, 61, 62, 63, 64, 65, -1, -1,
4446  -1, -1, -1, -1, -1, -1, -1, 75, 76, -1,
4447  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4448  -1, -1, 90, 91, -1, -1, -1, -1, -1, -1,
4449  98, -1, -1, 101, 102, -1, 104, 105, -1, -1,
4450  108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
4451  118, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4452  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4453  12, 139, 140, 141, 16, -1, 18, 19, 20, 21,
4454  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4455  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4456  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4457  52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
4458  62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
4459  -1, -1, -1, 75, 76, -1, -1, -1, -1, -1,
4460  -1, -1, -1, -1, -1, -1, -1, -1, 90, 91,
4461  -1, -1, -1, -1, -1, -1, 98, -1, -1, 101,
4462  102, -1, 104, 105, -1, 107, 108, -1, 110, 111,
4463  112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
4464  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4465  -1, 7, -1, -1, -1, 11, 12, 139, 140, 141,
4466  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4467  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4468  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4469  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4470  56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
4471  -1, -1, -1, -1, -1, -1, -1, -1, -1, 75,
4472  76, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4473  -1, -1, -1, -1, 90, 91, -1, -1, -1, -1,
4474  -1, -1, 98, -1, -1, 101, 102, -1, 104, 105,
4475  -1, -1, 108, -1, 110, 111, 112, 113, 114, 115,
4476  116, 117, 118, -1, -1, -1, -1, -1, -1, -1,
4477  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4478  -1, 11, 12, 139, 140, 141, 16, -1, 18, 19,
4479  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4480  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4481  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4482  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4483  60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
4484  -1, -1, -1, -1, -1, 75, 76, -1, -1, -1,
4485  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4486  90, 91, -1, -1, -1, -1, -1, -1, 98, -1,
4487  -1, 101, 102, -1, 104, 105, -1, 107, -1, -1,
4488  110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
4489  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4490  4, 5, -1, 7, -1, -1, -1, 11, 12, 139,
4491  140, 141, 16, -1, 18, 19, 20, 21, 22, 23,
4492  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4493  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4494  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4495  54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
4496  64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
4497  -1, 75, 76, -1, -1, -1, -1, -1, -1, -1,
4498  -1, -1, -1, -1, -1, -1, 90, 91, -1, -1,
4499  -1, -1, -1, -1, 98, -1, -1, 101, 102, -1,
4500  104, 105, -1, 107, -1, -1, 110, 111, 112, 113,
4501  114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
4502  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4503  -1, -1, -1, 11, 12, 139, 140, 141, 16, -1,
4504  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4505  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4506  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4507  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4508  -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
4509  -1, -1, -1, -1, -1, -1, -1, 75, 76, -1,
4510  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4511  -1, -1, 90, 91, -1, -1, -1, -1, -1, -1,
4512  98, -1, -1, 101, 102, -1, 104, 105, -1, 107,
4513  -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
4514  118, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4515  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4516  12, 139, 140, 141, 16, -1, 18, 19, 20, 21,
4517  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4518  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4519  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4520  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4521  62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
4522  -1, -1, -1, 75, 76, -1, -1, -1, -1, -1,
4523  -1, -1, -1, -1, -1, -1, -1, -1, 90, 91,
4524  -1, -1, -1, -1, -1, -1, 98, -1, -1, 101,
4525  102, -1, 104, 105, -1, 107, -1, -1, 110, 111,
4526  112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
4527  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4528  -1, 7, -1, -1, -1, 11, 12, 139, 140, 141,
4529  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4530  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4531  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4532  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4533  56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
4534  -1, -1, -1, -1, -1, -1, -1, -1, -1, 75,
4535  76, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4536  -1, -1, -1, -1, 90, 91, -1, -1, -1, -1,
4537  -1, -1, 98, -1, -1, 101, 102, -1, 104, 105,
4538  -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
4539  116, 117, 118, -1, -1, -1, -1, -1, -1, -1,
4540  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4541  -1, 11, 12, 139, 140, 141, 16, -1, 18, 19,
4542  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4543  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4544  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4545  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4546  60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
4547  -1, -1, -1, -1, -1, 75, 76, -1, -1, -1,
4548  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4549  90, 91, -1, -1, -1, -1, -1, -1, 98, -1,
4550  -1, 101, 102, -1, 104, 105, -1, -1, -1, -1,
4551  110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
4552  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4553  4, 5, -1, 7, -1, -1, -1, 11, 12, 139,
4554  140, 141, 16, -1, 18, 19, 20, 21, 22, 23,
4555  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4556  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4557  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4558  54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
4559  64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
4560  -1, 75, 76, -1, -1, -1, -1, -1, -1, -1,
4561  -1, -1, -1, -1, -1, -1, 90, 91, -1, -1,
4562  -1, -1, -1, -1, 98, -1, -1, 101, 102, -1,
4563  104, 105, -1, -1, -1, -1, 110, 111, 112, 113,
4564  114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
4565  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4566  -1, -1, -1, 11, 12, 139, 140, 141, 16, -1,
4567  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4568  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4569  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4570  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4571  -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
4572  -1, -1, -1, -1, -1, -1, -1, 75, 76, -1,
4573  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4574  -1, -1, 90, 91, -1, -1, -1, -1, -1, -1,
4575  98, -1, -1, 101, 102, -1, 104, 105, -1, -1,
4576  -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
4577  118, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4578  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4579  12, 139, 140, 141, 16, -1, 18, 19, 20, 21,
4580  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4581  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4582  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4583  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4584  62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
4585  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4586  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4587  -1, -1, -1, -1, -1, -1, 98, -1, -1, 101,
4588  102, -1, 104, 105, -1, 107, -1, -1, 110, 111,
4589  112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
4590  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4591  -1, 11, 12, -1, -1, -1, 16, 139, 18, 19,
4592  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4593  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4594  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4595  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4596  60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
4597  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4598  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4599  -1, -1, -1, -1, -1, -1, -1, -1, 98, -1,
4600  -1, 101, 102, -1, 104, 105, -1, 107, -1, -1,
4601  110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
4602  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4603  -1, -1, -1, 11, 12, -1, -1, -1, 16, 139,
4604  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4605  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4606  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4607  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4608  -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
4609  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4610  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4611  -1, -1, -1, -1, -1, -1, 94, -1, -1, -1,
4612  98, -1, -1, 101, 102, -1, 104, 105, -1, -1,
4613  -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
4614  118, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4615  -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
4616  16, 139, 18, 19, 20, 21, 22, 23, 24, -1,
4617  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4618  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4619  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4620  56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
4621  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4622  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4623  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4624  -1, -1, 98, -1, -1, 101, 102, -1, 104, 105,
4625  -1, -1, -1, -1, 110, 111, 112, 113, 114, 115,
4626  116, 117, 118, -1, -1, -1, -1, -1, -1, 3,
4627  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
4628  -1, -1, 16, 139, 18, 19, 20, 21, 22, 23,
4629  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4630  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4631  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4632  54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
4633  64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
4634  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4635  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4636  -1, -1, -1, -1, 98, -1, -1, 101, 102, -1,
4637  104, 105, -1, -1, -1, -1, 110, 111, 112, 113,
4638  114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
4639  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4640  12, -1, -1, -1, 16, 139, 18, 19, 20, 21,
4641  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4642  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4643  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4644  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4645  62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
4646  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4647  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4648  -1, -1, -1, -1, -1, -1, 98, -1, -1, 101,
4649  102, -1, 104, 105, -1, -1, -1, -1, 110, 111,
4650  112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
4651  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4652  -1, 11, 12, -1, -1, -1, 16, 139, 18, 19,
4653  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4654  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4655  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4656  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4657  60, 61, 62, 63, 64, 65, 33, 34, 35, 36,
4658  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4659  -1, -1, 49, 50, 51, 52, -1, -1, -1, 56,
4660  -1, -1, 59, 60, 61, 62, 63, -1, 98, -1,
4661  -1, 101, 102, -1, 104, 105, -1, -1, -1, -1,
4662  110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
4663  -1, -1, -1, 90, 91, -1, -1, -1, -1, -1,
4664  -1, 98, -1, -1, 101, -1, -1, 104, 105, 139,
4665  107, -1, -1, 110, 111, 112, 113, 114, 115, 116,
4666  117, 118, 33, 34, 35, 36, -1, -1, -1, -1,
4667  -1, -1, -1, -1, -1, 132, -1, -1, 49, 50,
4668  51, 52, 139, -1, -1, 56, -1, -1, 59, 60,
4669  61, 62, 63, -1, -1, 33, 34, 35, 36, -1,
4670  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4671  -1, 49, 50, 51, 52, -1, -1, -1, 56, 90,
4672  91, 59, 60, 61, 62, 63, -1, 98, -1, -1,
4673  101, -1, -1, 104, 105, -1, 107, -1, -1, 110,
4674  111, 112, 113, 114, 115, 116, 117, 118, -1, -1,
4675  -1, -1, 90, 91, -1, -1, -1, -1, -1, -1,
4676  98, 132, -1, 101, -1, -1, 104, 105, 139, -1,
4677  -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
4678  118, 52, 53, -1, -1, 56, -1, -1, -1, -1,
4679  -1, -1, -1, -1, 132, -1, -1, -1, -1, -1,
4680  -1, 139, -1, -1, 75, 76, 77, 78, 79, 80,
4681  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4682  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4683  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4684  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4685  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4686  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4687  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4688  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4689  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4690  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4691  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4692  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4693  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4694  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4695  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4696  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4697  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4698  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4699  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4700  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4701  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4702  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4703  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4704  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4705  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4706  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4707  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4708  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4709  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4710  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4711  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4712  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4713  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4714  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4715  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4716  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4717  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4718  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4719  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4720  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4721  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4722  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4723  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4724  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4725  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4726  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4727  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4728  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4729  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4730  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4731  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4732  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4733  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4734  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4735  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4736  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4737  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4738  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4739  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4740  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4741  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4742  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4743  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4744  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4745  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4746  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4747  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4748  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4749  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4750  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4751  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4752  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4753  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4754  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4755  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4756  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4757  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4758  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4759  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4760  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4761  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4762  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4763  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4764  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4765  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4766  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4767  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4768  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4769  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4770  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4771  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4772  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4773  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4774  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4775  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4776  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4777  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4778  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4779  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4780  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4781  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4782  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4783  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4784  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4785  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4786  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4787  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4788  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4789  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4790  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4791  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4792  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4793  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4794  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4795  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4796  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4797  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4798  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4799  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4800  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4801  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4802  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4803  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4804  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4805  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4806  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4807  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4808  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4809  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4810  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4811  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4812  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4813  141, 52, 53, -1, -1, 56, 147, 148, -1, -1,
4814  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4815  -1, -1, -1, -1, 75, 76, 77, 78, 79, 80,
4816  81, 82, 83, -1, -1, 86, 87, -1, -1, -1,
4817  -1, 92, 93, 94, 95, -1, -1, -1, -1, -1,
4818  -1, -1, -1, -1, -1, -1, 107, 108, -1, -1,
4819  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4820  -1, -1, -1, -1, -1, -1, -1, -1, 129, 130,
4821  131, 132, 133, 134, 135, 136, 137, 138, -1, 140,
4822  141, -1, -1, -1, -1, -1, 147
4823 };
4824 
4825  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4826  symbol of state STATE-NUM. */
4827 static const yytype_uint16 yystos[] =
4828 {
4829  0, 155, 156, 0, 1, 3, 4, 5, 6, 7,
4830  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4831  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4832  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4833  57, 59, 60, 61, 62, 63, 64, 65, 75, 76,
4834  90, 91, 98, 101, 102, 104, 105, 107, 110, 111,
4835  112, 113, 114, 115, 116, 117, 118, 139, 140, 141,
4836  157, 158, 159, 167, 169, 171, 179, 180, 182, 183,
4837  184, 186, 187, 188, 190, 191, 200, 203, 218, 233,
4838  234, 235, 236, 237, 238, 239, 240, 241, 242, 243,
4839  252, 279, 280, 333, 334, 335, 336, 337, 338, 339,
4840  342, 344, 345, 359, 360, 362, 363, 364, 365, 366,
4841  367, 368, 369, 405, 419, 159, 3, 4, 5, 6,
4842  7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
4843  17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
4844  30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
4845  45, 46, 47, 48, 49, 50, 51, 52, 53, 56,
4846  75, 76, 77, 78, 79, 80, 81, 82, 83, 86,
4847  87, 92, 93, 94, 95, 107, 108, 129, 130, 131,
4848  132, 133, 134, 135, 136, 137, 138, 140, 141, 147,
4849  194, 195, 196, 198, 199, 359, 39, 58, 98, 101,
4850  107, 108, 109, 112, 140, 183, 191, 200, 204, 210,
4851  213, 215, 233, 365, 366, 368, 369, 403, 404, 210,
4852  148, 211, 212, 148, 207, 211, 148, 153, 412, 54,
4853  195, 412, 143, 160, 143, 21, 22, 31, 32, 182,
4854  200, 233, 252, 200, 200, 200, 56, 1, 47, 101,
4855  163, 164, 165, 167, 185, 186, 419, 167, 220, 205,
4856  215, 403, 419, 204, 402, 403, 419, 46, 98, 139,
4857  146, 190, 218, 233, 365, 366, 369, 223, 54, 55,
4858  57, 194, 348, 361, 348, 349, 350, 152, 152, 152,
4859  152, 364, 179, 200, 200, 151, 153, 411, 417, 418,
4860  40, 41, 42, 43, 44, 37, 38, 26, 143, 207,
4861  211, 244, 281, 28, 245, 278, 126, 146, 101, 107,
4862  187, 126, 25, 77, 78, 79, 80, 81, 82, 83,
4863  84, 85, 86, 87, 88, 89, 94, 95, 127, 129,
4864  130, 131, 132, 133, 134, 135, 136, 137, 138, 202,
4865  202, 68, 96, 97, 145, 409, 219, 171, 175, 175,
4866  176, 177, 176, 175, 411, 418, 98, 184, 191, 233,
4867  257, 365, 366, 369, 52, 56, 94, 98, 192, 193,
4868  233, 365, 366, 369, 193, 33, 34, 35, 36, 49,
4869  50, 51, 52, 56, 148, 194, 367, 400, 210, 97,
4870  409, 410, 281, 336, 99, 99, 146, 204, 56, 204,
4871  204, 204, 348, 126, 100, 146, 214, 419, 97, 145,
4872  409, 99, 99, 146, 214, 210, 412, 413, 210, 91,
4873  209, 210, 215, 377, 403, 419, 171, 413, 171, 54,
4874  64, 65, 168, 148, 201, 157, 163, 97, 409, 99,
4875  167, 166, 185, 149, 411, 418, 413, 221, 413, 150,
4876  146, 153, 416, 146, 416, 144, 416, 412, 56, 364,
4877  187, 189, 146, 97, 145, 409, 270, 271, 66, 119,
4878  121, 122, 351, 119, 119, 351, 67, 351, 340, 346,
4879  343, 347, 77, 151, 159, 175, 175, 175, 175, 167,
4880  171, 171, 282, 283, 106, 181, 286, 287, 286, 107,
4881  179, 204, 215, 216, 217, 185, 146, 190, 146, 169,
4882  170, 179, 191, 200, 204, 206, 217, 233, 369, 172,
4883  200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
4884  200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
4885  200, 200, 200, 200, 52, 53, 56, 198, 207, 406,
4886  407, 209, 52, 53, 56, 198, 207, 406, 161, 163,
4887  13, 253, 417, 253, 163, 175, 163, 411, 225, 56,
4888  97, 145, 409, 25, 171, 52, 56, 192, 130, 370,
4889  97, 145, 409, 228, 401, 229, 68, 97, 408, 52,
4890  56, 406, 170, 200, 206, 170, 206, 197, 124, 204,
4891  107, 204, 213, 403, 52, 56, 209, 52, 56, 404,
4892  413, 149, 413, 146, 413, 146, 413, 195, 222, 200,
4893  144, 144, 406, 406, 206, 160, 413, 165, 413, 403,
4894  146, 189, 52, 56, 209, 52, 56, 272, 353, 352,
4895  119, 341, 351, 66, 119, 119, 341, 66, 119, 200,
4896  144, 284, 282, 10, 251, 288, 251, 204, 146, 44,
4897  413, 189, 146, 44, 126, 44, 97, 145, 409, 173,
4898  412, 99, 99, 207, 211, 412, 414, 99, 99, 207,
4899  208, 211, 419, 251, 8, 246, 329, 419, 163, 13,
4900  163, 251, 27, 254, 417, 251, 25, 224, 293, 17,
4901  248, 291, 52, 56, 209, 52, 56, 176, 227, 371,
4902  226, 52, 56, 192, 209, 161, 171, 230, 231, 208,
4903  211, 195, 204, 204, 214, 99, 99, 414, 99, 99,
4904  403, 171, 416, 187, 414, 273, 354, 54, 55, 57,
4905  358, 369, 152, 351, 152, 152, 152, 285, 144, 289,
4906  107, 204, 167, 189, 167, 200, 52, 56, 209, 52,
4907  56, 52, 56, 90, 91, 98, 101, 104, 105, 110,
4908  132, 303, 304, 305, 308, 323, 324, 326, 327, 328,
4909  333, 334, 337, 338, 339, 342, 344, 345, 366, 128,
4910  170, 206, 170, 206, 181, 150, 99, 170, 206, 170,
4911  206, 181, 204, 217, 330, 419, 9, 15, 247, 249,
4912  332, 419, 14, 249, 250, 255, 256, 419, 256, 178,
4913  294, 291, 251, 107, 204, 290, 251, 414, 163, 417,
4914  175, 161, 414, 251, 413, 148, 372, 373, 194, 281,
4915  278, 99, 146, 413, 274, 355, 131, 265, 266, 419,
4916  265, 204, 414, 324, 324, 56, 192, 311, 309, 414,
4917  310, 412, 415, 325, 52, 100, 174, 131, 88, 89,
4918  97, 145, 148, 306, 307, 200, 170, 206, 100, 331,
4919  419, 163, 162, 163, 175, 251, 251, 295, 251, 204,
4920  146, 253, 251, 161, 417, 251, 52, 54, 55, 56,
4921  57, 58, 77, 91, 101, 107, 108, 109, 133, 136,
4922  374, 376, 377, 378, 379, 380, 381, 382, 383, 384,
4923  387, 388, 389, 390, 391, 394, 395, 396, 397, 398,
4924  161, 376, 232, 148, 276, 376, 356, 262, 264, 267,
4925  380, 382, 383, 385, 386, 389, 390, 392, 393, 396,
4926  398, 412, 163, 161, 303, 107, 303, 312, 313, 314,
4927  316, 58, 112, 317, 318, 319, 320, 321, 322, 388,
4928  144, 270, 326, 308, 324, 324, 192, 414, 413, 112,
4929  312, 317, 312, 317, 98, 191, 233, 365, 366, 369,
4930  253, 163, 253, 296, 107, 204, 163, 251, 101, 107,
4931  258, 259, 260, 261, 379, 413, 413, 126, 146, 375,
4932  204, 146, 399, 419, 34, 52, 146, 399, 399, 146,
4933  375, 52, 146, 375, 52, 251, 417, 372, 376, 275,
4934  357, 267, 131, 126, 146, 263, 98, 233, 146, 399,
4935  399, 399, 146, 263, 146, 263, 151, 413, 52, 146,
4936  414, 107, 303, 316, 146, 348, 415, 146, 303, 34,
4937  52, 348, 413, 413, 414, 414, 56, 97, 145, 409,
4938  163, 332, 163, 301, 302, 303, 314, 317, 204, 256,
4939  291, 292, 260, 379, 146, 413, 146, 204, 374, 381,
4940  394, 396, 384, 388, 390, 398, 382, 391, 396, 380,
4941  382, 161, 267, 29, 123, 277, 163, 131, 233, 262,
4942  393, 396, 56, 97, 385, 390, 382, 392, 396, 382,
4943  52, 268, 269, 378, 146, 315, 316, 52, 146, 146,
4944  124, 319, 321, 322, 52, 56, 209, 52, 56, 329,
4945  255, 253, 40, 41, 146, 413, 258, 261, 259, 146,
4946  375, 146, 375, 399, 146, 375, 146, 375, 375, 251,
4947  149, 161, 163, 120, 146, 263, 146, 263, 52, 56,
4948  399, 146, 263, 146, 263, 263, 146, 412, 315, 146,
4949  146, 315, 414, 297, 175, 175, 312, 146, 146, 382,
4950  396, 382, 382, 251, 144, 382, 396, 382, 382, 269,
4951  316, 315, 298, 259, 375, 146, 375, 375, 375, 263,
4952  146, 263, 263, 263, 299, 382, 382, 163, 375, 263,
4953  256, 293, 300
4954 };
4955 
4956  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
4957 static const yytype_uint16 yyr1[] =
4958 {
4959  0, 154, 156, 155, 157, 158, 158, 158, 158, 159,
4960  159, 160, 162, 161, 161, 163, 164, 164, 164, 164,
4961  165, 166, 165, 168, 167, 167, 167, 167, 167, 167,
4962  167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
4963  167, 169, 169, 169, 169, 169, 169, 169, 169, 170,
4964  170, 170, 171, 171, 171, 171, 171, 172, 173, 174,
4965  171, 171, 175, 177, 178, 176, 179, 179, 180, 180,
4966  181, 182, 183, 183, 183, 183, 183, 183, 183, 183,
4967  183, 183, 183, 184, 184, 185, 185, 186, 186, 186,
4968  186, 186, 186, 186, 186, 186, 186, 187, 187, 188,
4969  188, 189, 189, 190, 190, 190, 190, 190, 190, 190,
4970  190, 190, 191, 191, 191, 191, 191, 191, 191, 191,
4971  191, 192, 192, 193, 193, 193, 194, 194, 194, 194,
4972  194, 195, 195, 196, 197, 196, 198, 198, 198, 198,
4973  198, 198, 198, 198, 198, 198, 198, 198, 198, 198,
4974  198, 198, 198, 198, 198, 198, 198, 198, 198, 198,
4975  198, 198, 198, 198, 198, 198, 199, 199, 199, 199,
4976  199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
4977  199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
4978  199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
4979  199, 199, 199, 199, 199, 199, 199, 200, 200, 200,
4980  200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
4981  200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
4982  200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
4983  200, 200, 200, 200, 200, 200, 200, 201, 200, 200,
4984  200, 202, 202, 202, 202, 203, 203, 204, 205, 205,
4985  205, 205, 206, 206, 207, 207, 208, 208, 209, 209,
4986  209, 209, 209, 210, 210, 210, 210, 210, 212, 211,
4987  213, 214, 214, 215, 215, 215, 215, 216, 216, 217,
4988  217, 217, 218, 218, 218, 218, 218, 218, 218, 218,
4989  218, 218, 218, 219, 218, 220, 218, 221, 218, 218,
4990  218, 218, 218, 218, 218, 218, 218, 218, 222, 218,
4991  218, 218, 218, 218, 218, 223, 218, 218, 218, 218,
4992  218, 224, 218, 225, 218, 218, 218, 226, 218, 227,
4993  218, 228, 218, 229, 230, 218, 231, 232, 218, 218,
4994  218, 218, 218, 233, 234, 235, 236, 237, 238, 239,
4995  240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
4996  250, 251, 252, 253, 253, 253, 254, 254, 255, 255,
4997  256, 256, 257, 257, 258, 258, 259, 259, 260, 260,
4998  260, 260, 260, 261, 261, 262, 262, 262, 262, 262,
4999  263, 263, 264, 264, 264, 264, 264, 264, 264, 264,
5000  264, 264, 264, 264, 264, 264, 264, 265, 265, 266,
5001  266, 267, 267, 268, 268, 269, 269, 271, 272, 273,
5002  274, 275, 270, 276, 276, 277, 277, 278, 279, 279,
5003  279, 279, 280, 280, 280, 280, 280, 280, 280, 280,
5004  280, 281, 281, 283, 284, 285, 282, 287, 288, 289,
5005  286, 290, 290, 290, 290, 291, 292, 292, 294, 295,
5006  296, 297, 298, 299, 293, 300, 300, 301, 301, 301,
5007  302, 302, 302, 302, 302, 303, 304, 304, 305, 305,
5008  306, 307, 308, 308, 308, 308, 308, 308, 308, 309,
5009  308, 308, 310, 308, 308, 311, 308, 312, 312, 312,
5010  312, 312, 312, 312, 312, 313, 313, 314, 314, 314,
5011  314, 315, 315, 316, 317, 317, 317, 317, 317, 317,
5012  318, 318, 319, 319, 320, 320, 321, 321, 322, 323,
5013  323, 323, 323, 323, 323, 323, 323, 323, 323, 324,
5014  324, 324, 324, 324, 324, 324, 324, 324, 325, 324,
5015  326, 327, 328, 328, 328, 329, 329, 330, 330, 330,
5016  331, 331, 332, 332, 333, 333, 334, 335, 335, 335,
5017  336, 337, 338, 339, 340, 340, 341, 341, 342, 343,
5018  343, 344, 345, 346, 346, 347, 347, 348, 348, 349,
5019  349, 350, 350, 351, 352, 351, 353, 354, 355, 356,
5020  357, 351, 358, 358, 358, 358, 359, 359, 360, 361,
5021  361, 361, 361, 362, 363, 363, 364, 364, 364, 364,
5022  365, 365, 365, 365, 365, 366, 366, 366, 366, 366,
5023  366, 366, 367, 367, 368, 368, 369, 369, 371, 370,
5024  370, 372, 372, 373, 372, 374, 374, 374, 374, 374,
5025  375, 375, 376, 376, 376, 376, 376, 376, 376, 376,
5026  376, 376, 376, 376, 376, 376, 376, 377, 378, 378,
5027  378, 378, 379, 379, 380, 381, 381, 382, 382, 383,
5028  384, 384, 385, 385, 386, 386, 387, 387, 388, 388,
5029  389, 390, 390, 391, 392, 393, 393, 394, 394, 395,
5030  395, 396, 396, 397, 397, 398, 399, 399, 400, 401,
5031  400, 402, 402, 403, 403, 404, 404, 404, 404, 405,
5032  405, 405, 406, 406, 406, 406, 407, 407, 407, 408,
5033  408, 409, 409, 410, 410, 411, 411, 412, 412, 413,
5034  414, 415, 416, 416, 416, 417, 417, 418, 418, 419
5035 };
5036 
5037  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
5038 static const yytype_uint8 yyr2[] =
5039 {
5040  0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
5041  2, 3, 0, 6, 3, 2, 1, 1, 3, 2,
5042  1, 0, 3, 0, 4, 3, 3, 3, 2, 3,
5043  3, 3, 3, 3, 4, 1, 3, 3, 5, 3,
5044  1, 3, 3, 6, 5, 5, 5, 5, 3, 1,
5045  3, 1, 1, 3, 3, 3, 2, 0, 0, 0,
5046  6, 1, 1, 0, 0, 4, 1, 1, 1, 4,
5047  3, 1, 2, 3, 4, 5, 4, 5, 2, 2,
5048  2, 2, 2, 1, 3, 1, 3, 1, 2, 3,
5049  5, 2, 4, 2, 4, 1, 3, 1, 3, 2,
5050  3, 1, 3, 1, 1, 4, 3, 3, 3, 3,
5051  2, 1, 1, 1, 4, 3, 3, 3, 3, 2,
5052  1, 1, 1, 2, 1, 3, 1, 1, 1, 1,
5053  1, 1, 1, 1, 0, 4, 1, 1, 1, 1,
5054  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5055  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5056  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5057  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5058  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5059  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5060  1, 1, 1, 1, 1, 1, 1, 3, 3, 6,
5061  5, 5, 5, 5, 4, 3, 3, 3, 2, 2,
5062  2, 2, 3, 3, 3, 3, 3, 3, 4, 2,
5063  2, 3, 3, 3, 3, 1, 3, 3, 3, 3,
5064  3, 2, 2, 3, 3, 3, 3, 0, 4, 6,
5065  1, 1, 1, 1, 1, 3, 3, 1, 1, 2,
5066  4, 2, 1, 3, 3, 3, 1, 1, 1, 1,
5067  2, 4, 2, 1, 2, 2, 4, 1, 0, 2,
5068  2, 2, 1, 1, 2, 3, 4, 1, 1, 3,
5069  4, 2, 1, 1, 1, 1, 1, 1, 1, 1,
5070  1, 1, 1, 0, 4, 0, 3, 0, 4, 3,
5071  3, 2, 3, 3, 1, 4, 3, 1, 0, 6,
5072  4, 3, 2, 1, 2, 0, 3, 6, 6, 4,
5073  4, 0, 6, 0, 5, 5, 6, 0, 6, 0,
5074  7, 0, 5, 0, 0, 7, 0, 0, 9, 1,
5075  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5076  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5077  1, 1, 1, 1, 1, 2, 1, 1, 1, 5,
5078  1, 2, 1, 1, 1, 3, 1, 3, 1, 3,
5079  5, 1, 3, 2, 1, 4, 2, 2, 2, 1,
5080  2, 0, 6, 8, 4, 6, 4, 2, 6, 2,
5081  4, 6, 2, 4, 2, 4, 1, 1, 1, 3,
5082  4, 1, 4, 1, 3, 1, 1, 0, 0, 0,
5083  0, 0, 7, 4, 1, 3, 3, 3, 2, 4,
5084  5, 5, 2, 4, 4, 3, 3, 3, 2, 1,
5085  4, 3, 3, 0, 0, 0, 5, 0, 0, 0,
5086  5, 1, 2, 3, 4, 5, 1, 1, 0, 0,
5087  0, 0, 0, 0, 11, 1, 1, 1, 3, 3,
5088  1, 2, 3, 1, 1, 1, 3, 1, 3, 1,
5089  1, 1, 1, 4, 4, 3, 4, 4, 3, 0,
5090  4, 2, 0, 4, 2, 0, 4, 1, 1, 2,
5091  3, 5, 2, 4, 1, 2, 3, 2, 4, 1,
5092  3, 1, 3, 1, 3, 1, 2, 1, 3, 1,
5093  1, 3, 2, 1, 1, 3, 2, 1, 2, 1,
5094  3, 3, 2, 2, 1, 1, 1, 2, 2, 1,
5095  1, 1, 1, 1, 1, 1, 1, 1, 0, 3,
5096  1, 2, 2, 3, 1, 6, 1, 1, 1, 1,
5097  2, 1, 2, 1, 1, 1, 1, 1, 1, 2,
5098  3, 3, 3, 4, 0, 3, 1, 2, 4, 0,
5099  3, 4, 4, 0, 3, 0, 3, 0, 2, 0,
5100  2, 0, 2, 1, 0, 3, 0, 0, 0, 0,
5101  0, 8, 1, 1, 1, 1, 1, 1, 2, 1,
5102  1, 1, 1, 3, 1, 2, 1, 1, 1, 1,
5103  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5104  1, 1, 1, 1, 1, 1, 1, 1, 0, 4,
5105  0, 3, 3, 0, 3, 4, 2, 2, 2, 1,
5106  2, 0, 6, 8, 4, 6, 4, 6, 2, 4,
5107  6, 2, 4, 2, 4, 1, 0, 1, 1, 1,
5108  1, 1, 1, 1, 1, 1, 3, 1, 3, 1,
5109  2, 1, 2, 1, 1, 3, 1, 3, 1, 1,
5110  2, 2, 1, 3, 3, 1, 3, 1, 3, 1,
5111  1, 2, 1, 1, 1, 2, 2, 1, 1, 0,
5112  4, 1, 2, 1, 3, 3, 2, 4, 2, 1,
5113  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5114  1, 1, 1, 1, 1, 0, 1, 0, 1, 2,
5115  2, 2, 0, 1, 1, 1, 1, 1, 2, 0
5116 };
5117 
5118 
5119 #define yyerrok (yyerrstatus = 0)
5120 #define yyclearin (yychar = YYEMPTY)
5121 #define YYEMPTY (-2)
5122 #define YYEOF 0
5123 
5124 #define YYACCEPT goto yyacceptlab
5125 #define YYABORT goto yyabortlab
5126 #define YYERROR goto yyerrorlab
5127 
5128 
5129 #define YYRECOVERING() (!!yyerrstatus)
5130 
5131 #define YYBACKUP(Token, Value) \
5132 do \
5133  if (yychar == YYEMPTY) \
5134  { \
5135  yychar = (Token); \
5136  yylval = (Value); \
5137  YYPOPSTACK (yylen); \
5138  yystate = *yyssp; \
5139  goto yybackup; \
5140  } \
5141  else \
5142  { \
5143  yyerror (&yylloc, p, YY_("syntax error: cannot back up")); \
5144  YYERROR; \
5145  } \
5146 while (0)
5147 
5148 /* Error token number */
5149 #define YYTERROR 1
5150 #define YYERRCODE 256
5151 
5152 
5153 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
5154  If N is 0, then set CURRENT to the empty location which ends
5155  the previous symbol: RHS[0] (always defined). */
5156 
5157 #ifndef YYLLOC_DEFAULT
5158 # define YYLLOC_DEFAULT(Current, Rhs, N) \
5159  do \
5160  if (N) \
5161  { \
5162  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
5163  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
5164  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
5165  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
5166  } \
5167  else \
5168  { \
5169  (Current).first_line = (Current).last_line = \
5170  YYRHSLOC (Rhs, 0).last_line; \
5171  (Current).first_column = (Current).last_column = \
5172  YYRHSLOC (Rhs, 0).last_column; \
5173  } \
5174  while (0)
5175 #endif
5176 
5177 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
5178 
5179 
5180 /* Enable debugging if requested. */
5181 #if YYDEBUG
5182 
5183 # ifndef YYFPRINTF
5184 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
5185 # define YYFPRINTF fprintf
5186 # endif
5187 
5188 # define YYDPRINTF(Args) \
5189 do { \
5190  if (yydebug) \
5191  YYFPRINTF Args; \
5192 } while (0)
5193 
5194 
5195 /* YY_LOCATION_PRINT -- Print the location on the stream.
5196  This macro was not mandated originally: define only if we know
5197  we won't break user code: when these are the locations we know. */
5198 
5199 #ifndef YY_LOCATION_PRINT
5200 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
5201 
5202 /* Print *YYLOCP on YYO. Private, do not rely on its existence. */
5203 
5205 static unsigned
5206 yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
5207 {
5208  unsigned res = 0;
5209  int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
5210  if (0 <= yylocp->first_line)
5211  {
5212  res += YYFPRINTF (p, "%d", yylocp->first_line);
5213  if (0 <= yylocp->first_column)
5214  res += YYFPRINTF (p, ".%d", yylocp->first_column);
5215  }
5216  if (0 <= yylocp->last_line)
5217  {
5218  if (yylocp->first_line < yylocp->last_line)
5219  {
5220  res += YYFPRINTF (p, "-%d", yylocp->last_line);
5221  if (0 <= end_col)
5222  res += YYFPRINTF (p, ".%d", end_col);
5223  }
5224  else if (0 <= end_col && yylocp->first_column < end_col)
5225  res += YYFPRINTF (p, "-%d", end_col);
5226  }
5227  return res;
5228  }
5229 
5230 # define YY_LOCATION_PRINT(File, Loc) \
5231  yy_location_print_ (File, &(Loc))
5232 
5233 # else
5234 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
5235 # endif
5236 #endif
5237 
5238 
5239 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
5240 do { \
5241  if (yydebug) \
5242  { \
5243  YYFPRINTF (p, "%s ", Title); \
5244  yy_symbol_print (stderr, \
5245  Type, Value, Location, p); \
5246  YYFPRINTF (p, "\n"); \
5247  } \
5248 } while (0)
5249 
5250 
5251 /*----------------------------------------.
5252 | Print this symbol's value on YYOUTPUT. |
5253 `----------------------------------------*/
5254 
5255 static void
5256 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parser_params *p)
5257 {
5258  FILE *yyo = yyoutput;
5259  YYUSE (yyo);
5260  YYUSE (yylocationp);
5261  YYUSE (p);
5262  if (!yyvaluep)
5263  return;
5264 # ifdef YYPRINT
5265  if (yytype < YYNTOKENS)
5266  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
5267 # endif
5268  YYUSE (yytype);
5269 }
5270 
5271 
5272 /*--------------------------------.
5273 | Print this symbol on YYOUTPUT. |
5274 `--------------------------------*/
5275 
5276 static void
5277 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parser_params *p)
5278 {
5279  YYFPRINTF (p, "%s %s (",
5280  yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
5281 
5282  YY_LOCATION_PRINT (yyoutput, *yylocationp);
5283  YYFPRINTF (p, ": ");
5284  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, p);
5285  YYFPRINTF (p, ")");
5286 }
5287 
5288 /*------------------------------------------------------------------.
5289 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
5290 | TOP (included). |
5291 `------------------------------------------------------------------*/
5292 
5293 static void
5294 ruby_parser_yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop, struct parser_params *p)
5295 #define yy_stack_print(b, t) ruby_parser_yy_stack_print(b, t, p)
5296 {
5297  YYFPRINTF (p, "Stack now");
5298  for (; yybottom <= yytop; yybottom++)
5299  {
5300  int yybot = *yybottom;
5301  YYFPRINTF (p, " %d", yybot);
5302  }
5303  YYFPRINTF (p, "\n");
5304 }
5305 
5306 # define YY_STACK_PRINT(Bottom, Top) \
5307 do { \
5308  if (yydebug) \
5309  yy_stack_print ((Bottom), (Top)); \
5310 } while (0)
5311 
5312 
5313 /*------------------------------------------------.
5314 | Report that the YYRULE is going to be reduced. |
5315 `------------------------------------------------*/
5316 
5317 static void
5318 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, struct parser_params *p)
5319 {
5320  unsigned long int yylno = yyrline[yyrule];
5321  int yynrhs = yyr2[yyrule];
5322  int yyi;
5323  YYFPRINTF (p, "Reducing stack by rule %d (line %lu):\n",
5324  yyrule - 1, yylno);
5325  /* The symbols being reduced. */
5326  for (yyi = 0; yyi < yynrhs; yyi++)
5327  {
5328  YYFPRINTF (p, " $%d = ", yyi + 1);
5329  yy_symbol_print (stderr,
5330  yystos[yyssp[yyi + 1 - yynrhs]],
5331  &(yyvsp[(yyi + 1) - (yynrhs)])
5332  , &(yylsp[(yyi + 1) - (yynrhs)]) , p);
5333  YYFPRINTF (p, "\n");
5334  }
5335 }
5336 
5337 # define YY_REDUCE_PRINT(Rule) \
5338 do { \
5339  if (yydebug) \
5340  yy_reduce_print (yyssp, yyvsp, yylsp, Rule, p); \
5341 } while (0)
5342 
5343 /* Nonzero means print parse trace. It is left uninitialized so that
5344  multiple parsers can coexist. */
5345 #ifndef yydebug
5346 int yydebug;
5347 #endif
5348 #else /* !YYDEBUG */
5349 # define YYDPRINTF(Args)
5350 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
5351 # define YY_STACK_PRINT(Bottom, Top)
5352 # define YY_REDUCE_PRINT(Rule)
5353 #endif /* !YYDEBUG */
5354 
5355 
5356 /* YYINITDEPTH -- initial size of the parser's stacks. */
5357 #ifndef YYINITDEPTH
5358 # define YYINITDEPTH 200
5359 #endif
5360 
5361 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
5362  if the built-in stack extension method is used).
5363 
5364  Do not make this value too large; the results are undefined if
5365  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
5366  evaluated with infinite-precision integer arithmetic. */
5367 
5368 #ifndef YYMAXDEPTH
5369 # define YYMAXDEPTH 10000
5370 #endif
5371 
5372 
5373 #if YYERROR_VERBOSE
5374 
5375 # ifndef yystrlen
5376 # if defined __GLIBC__ && defined _STRING_H
5377 # define yystrlen strlen
5378 # else
5379 /* Return the length of YYSTR. */
5380 static YYSIZE_T
5381 yystrlen (const char *yystr)
5382 {
5383  YYSIZE_T yylen;
5384  for (yylen = 0; yystr[yylen]; yylen++)
5385  continue;
5386  return yylen;
5387 }
5388 # endif
5389 # endif
5390 
5391 # ifndef yystpcpy
5392 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
5393 # define yystpcpy stpcpy
5394 # else
5395 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
5396  YYDEST. */
5397 static char *
5398 yystpcpy (char *yydest, const char *yysrc)
5399 {
5400  char *yyd = yydest;
5401  const char *yys = yysrc;
5402 
5403  while ((*yyd++ = *yys++) != '\0')
5404  continue;
5405 
5406  return yyd - 1;
5407 }
5408 # endif
5409 # endif
5410 
5411 # ifndef yytnamerr
5412 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
5413  quotes and backslashes, so that it's suitable for yyerror. The
5414  heuristic is that double-quoting is unnecessary unless the string
5415  contains an apostrophe, a comma, or backslash (other than
5416  backslash-backslash). YYSTR is taken from yytname. If YYRES is
5417  null, do not copy; instead, return the length of what the result
5418  would have been. */
5419 static YYSIZE_T
5420 yytnamerr (char *yyres, const char *yystr)
5421 {
5422  if (*yystr == '"')
5423  {
5424  YYSIZE_T yyn = 0;
5425  char const *yyp = yystr;
5426 
5427  for (;;)
5428  switch (*++yyp)
5429  {
5430  case '\'':
5431  case ',':
5432  goto do_not_strip_quotes;
5433 
5434  case '\\':
5435  if (*++yyp != '\\')
5436  goto do_not_strip_quotes;
5437  /* Fall through. */
5438  default:
5439  if (yyres)
5440  yyres[yyn] = *yyp;
5441  yyn++;
5442  break;
5443 
5444  case '"':
5445  if (yyres)
5446  yyres[yyn] = '\0';
5447  return yyn;
5448  }
5449  do_not_strip_quotes: ;
5450  }
5451 
5452  if (! yyres)
5453  return yystrlen (yystr);
5454 
5455  return yystpcpy (yyres, yystr) - yyres;
5456 }
5457 # endif
5458 
5459 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
5460  about the unexpected token YYTOKEN for the state stack whose top is
5461  YYSSP.
5462 
5463  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
5464  not large enough to hold the message. In that case, also set
5465  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
5466  required number of bytes is too large to store. */
5467 static int
5468 yysyntax_error (struct parser_params *p, YYSIZE_T *yymsg_alloc, char **yymsg,
5469  yytype_int16 *yyssp, int yytoken)
5470 {
5471  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
5472  YYSIZE_T yysize = yysize0;
5473  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
5474  /* Internationalized format string. */
5475  const char *yyformat = YY_NULLPTR;
5476  /* Arguments of yyformat. */
5477  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
5478  /* Number of reported tokens (one for the "unexpected", one per
5479  "expected"). */
5480  int yycount = 0;
5481 
5482  /* There are many possibilities here to consider:
5483  - If this state is a consistent state with a default action, then
5484  the only way this function was invoked is if the default action
5485  is an error action. In that case, don't check for expected
5486  tokens because there are none.
5487  - The only way there can be no lookahead present (in yychar) is if
5488  this state is a consistent state with a default action. Thus,
5489  detecting the absence of a lookahead is sufficient to determine
5490  that there is no unexpected or expected token to report. In that
5491  case, just report a simple "syntax error".
5492  - Don't assume there isn't a lookahead just because this state is a
5493  consistent state with a default action. There might have been a
5494  previous inconsistent state, consistent state with a non-default
5495  action, or user semantic action that manipulated yychar.
5496  - Of course, the expected token list depends on states to have
5497  correct lookahead information, and it depends on the parser not
5498  to perform extra reductions after fetching a lookahead from the
5499  scanner and before detecting a syntax error. Thus, state merging
5500  (from LALR or IELR) and default reductions corrupt the expected
5501  token list. However, the list is correct for canonical LR with
5502  one exception: it will still contain any token that will not be
5503  accepted due to an error action in a later state.
5504  */
5505  if (yytoken != YYEMPTY)
5506  {
5507  int yyn = yypact[*yyssp];
5508  yyarg[yycount++] = yytname[yytoken];
5509  if (!yypact_value_is_default (yyn))
5510  {
5511  /* Start YYX at -YYN if negative to avoid negative indexes in
5512  YYCHECK. In other words, skip the first -YYN actions for
5513  this state because they are default actions. */
5514  int yyxbegin = yyn < 0 ? -yyn : 0;
5515  /* Stay within bounds of both yycheck and yytname. */
5516  int yychecklim = YYLAST - yyn + 1;
5517  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
5518  int yyx;
5519 
5520  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
5521  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
5522  && !yytable_value_is_error (yytable[yyx + yyn]))
5523  {
5524  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
5525  {
5526  yycount = 1;
5527  yysize = yysize0;
5528  break;
5529  }
5530  yyarg[yycount++] = yytname[yyx];
5531  {
5532  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
5533  if (! (yysize <= yysize1
5534  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
5535  return 2;
5536  yysize = yysize1;
5537  }
5538  }
5539  }
5540  }
5541 
5542  switch (yycount)
5543  {
5544 # define YYCASE_(N, S) \
5545  case N: \
5546  yyformat = S; \
5547  break
5548  YYCASE_(0, YY_("syntax error"));
5549  YYCASE_(1, YY_("syntax error, unexpected %s"));
5550  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
5551  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
5552  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
5553  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
5554 # undef YYCASE_
5555  }
5556 
5557  {
5558  YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
5559  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
5560  return 2;
5561  yysize = yysize1;
5562  }
5563 
5564  if (*yymsg_alloc < yysize)
5565  {
5566  *yymsg_alloc = 2 * yysize;
5567  if (! (yysize <= *yymsg_alloc
5568  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
5569  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
5570  return 1;
5571  }
5572 
5573  /* Avoid sprintf, as that infringes on the user's name space.
5574  Don't have undefined behavior even if the translation
5575  produced a string with the wrong number of "%s"s. */
5576  {
5577  char *yyp = *yymsg;
5578  int yyi = 0;
5579  while ((*yyp = *yyformat) != '\0')
5580  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
5581  {
5582  yyp += yytnamerr (yyp, yyarg[yyi++]);
5583  yyformat += 2;
5584  }
5585  else
5586  {
5587  yyp++;
5588  yyformat++;
5589  }
5590  }
5591  return 0;
5592 }
5593 #endif /* YYERROR_VERBOSE */
5594 
5595 /*-----------------------------------------------.
5596 | Release the memory associated to this symbol. |
5597 `-----------------------------------------------*/
5598 
5599 static void
5600 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, struct parser_params *p)
5601 {
5602  YYUSE (yyvaluep);
5603  YYUSE (yylocationp);
5604  YYUSE (p);
5605  if (!yymsg)
5606  yymsg = "Deleting";
5607  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
5608 
5610  YYUSE (yytype);
5612 }
5613 
5614 
5615 
5616 
5617 /*----------.
5618 | yyparse. |
5619 `----------*/
5620 
5621 int
5623 {
5624 /* The lookahead symbol. */
5625 int yychar;
5626 
5627 
5628 /* The semantic value of the lookahead symbol. */
5629 /* Default value used for initialization, for pacifying older GCCs
5630  or non-GCC compilers. */
5631 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
5632 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
5633 
5634 /* Location data for the lookahead symbol. */
5635 static YYLTYPE yyloc_default
5636 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
5637  = { 1, 1, 1, 1 }
5638 # endif
5639 ;
5640 YYLTYPE yylloc = yyloc_default;
5641 
5642  /* Number of syntax errors so far. */
5643  int yynerrs;
5644 
5645  int yystate;
5646  /* Number of tokens to shift before error messages enabled. */
5647  int yyerrstatus;
5648 
5649  /* The stacks and their tools:
5650  'yyss': related to states.
5651  'yyvs': related to semantic values.
5652  'yyls': related to locations.
5653 
5654  Refer to the stacks through separate pointers, to allow yyoverflow
5655  to reallocate them elsewhere. */
5656 
5657  /* The state stack. */
5658  yytype_int16 yyssa[YYINITDEPTH];
5659  yytype_int16 *yyss;
5660  yytype_int16 *yyssp;
5661 
5662  /* The semantic value stack. */
5663  YYSTYPE yyvsa[YYINITDEPTH];
5664  YYSTYPE *yyvs;
5665  YYSTYPE *yyvsp;
5666 
5667  /* The location stack. */
5668  YYLTYPE yylsa[YYINITDEPTH];
5669  YYLTYPE *yyls;
5670  YYLTYPE *yylsp;
5671 
5672  /* The locations where the error started and ended. */
5673  YYLTYPE yyerror_range[3];
5674 
5675  YYSIZE_T yystacksize;
5676 
5677  int yyn;
5678  int yyresult;
5679  /* Lookahead token as an internal (translated) token number. */
5680  int yytoken = 0;
5681  /* The variables used to return semantic value and location from the
5682  action routines. */
5683  YYSTYPE yyval;
5684  YYLTYPE yyloc;
5685 
5686 #if YYERROR_VERBOSE
5687  /* Buffer for error messages, and its allocated size. */
5688  char yymsgbuf[128];
5689  char *yymsg = yymsgbuf;
5690  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
5691 #endif
5692 
5693 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
5694 
5695  /* The number of symbols on the RHS of the reduced rule.
5696  Keep to zero when no symbol should be popped. */
5697  int yylen = 0;
5698 
5699  yyssp = yyss = yyssa;
5700  yyvsp = yyvs = yyvsa;
5701  yylsp = yyls = yylsa;
5702  yystacksize = YYINITDEPTH;
5703 
5704  YYDPRINTF ((p, "Starting parse\n"));
5705 
5706  yystate = 0;
5707  yyerrstatus = 0;
5708  yynerrs = 0;
5709  yychar = YYEMPTY; /* Cause a token to be read. */
5710 
5711 /* User initialization code. */
5712 #line 975 "ripper.y" /* yacc.c:1429 */
5713 {
5714  RUBY_SET_YYLLOC_OF_NONE(yylloc);
5715 }
5716 
5717 #line 5713 "ripper.c" /* yacc.c:1429 */
5718  yylsp[0] = yylloc;
5719  goto yysetstate;
5720 
5721 /*------------------------------------------------------------.
5722 | yynewstate -- Push a new state, which is found in yystate. |
5723 `------------------------------------------------------------*/
5724  yynewstate:
5725  /* In all cases, when you get here, the value and location stacks
5726  have just been pushed. So pushing a state here evens the stacks. */
5727  yyssp++;
5728 
5729  yysetstate:
5730  *yyssp = yystate;
5731 
5732  if (yyss + yystacksize - 1 <= yyssp)
5733  {
5734  /* Get the current used size of the three stacks, in elements. */
5735  YYSIZE_T yysize = yyssp - yyss + 1;
5736 
5737 #ifdef yyoverflow
5738  {
5739  /* Give user a chance to reallocate the stack. Use copies of
5740  these so that the &'s don't force the real ones into
5741  memory. */
5742  YYSTYPE *yyvs1 = yyvs;
5743  yytype_int16 *yyss1 = yyss;
5744  YYLTYPE *yyls1 = yyls;
5745 
5746  /* Each stack pointer address is followed by the size of the
5747  data in use in that stack, in bytes. This used to be a
5748  conditional around just the two extra args, but that might
5749  be undefined if yyoverflow is a macro. */
5750  yyoverflow (YY_("memory exhausted"),
5751  &yyss1, yysize * sizeof (*yyssp),
5752  &yyvs1, yysize * sizeof (*yyvsp),
5753  &yyls1, yysize * sizeof (*yylsp),
5754  &yystacksize);
5755 
5756  yyls = yyls1;
5757  yyss = yyss1;
5758  yyvs = yyvs1;
5759  }
5760 #else /* no yyoverflow */
5761 # ifndef YYSTACK_RELOCATE
5762  goto yyexhaustedlab;
5763 # else
5764  /* Extend the stack our own way. */
5765  if (YYMAXDEPTH <= yystacksize)
5766  goto yyexhaustedlab;
5767  yystacksize *= 2;
5768  if (YYMAXDEPTH < yystacksize)
5769  yystacksize = YYMAXDEPTH;
5770 
5771  {
5772  yytype_int16 *yyss1 = yyss;
5773  union yyalloc *yyptr =
5774  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
5775  if (! yyptr)
5776  goto yyexhaustedlab;
5777  YYSTACK_RELOCATE (yyss_alloc, yyss);
5778  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
5779  YYSTACK_RELOCATE (yyls_alloc, yyls);
5780 # undef YYSTACK_RELOCATE
5781  if (yyss1 != yyssa)
5782  YYSTACK_FREE (yyss1);
5783  }
5784 # endif
5785 #endif /* no yyoverflow */
5786 
5787  yyssp = yyss + yysize - 1;
5788  yyvsp = yyvs + yysize - 1;
5789  yylsp = yyls + yysize - 1;
5790 
5791  YYDPRINTF ((p, "Stack size increased to %lu\n",
5792  (unsigned long int) yystacksize));
5793 
5794  if (yyss + yystacksize - 1 <= yyssp)
5795  YYABORT;
5796  }
5797 
5798  YYDPRINTF ((p, "Entering state %d\n", yystate));
5799 
5800  if (yystate == YYFINAL)
5801  YYACCEPT;
5802 
5803  goto yybackup;
5804 
5805 /*-----------.
5806 | yybackup. |
5807 `-----------*/
5808 yybackup:
5809 
5810  /* Do appropriate processing given the current state. Read a
5811  lookahead token if we need one and don't already have one. */
5812 
5813  /* First try to decide what to do without reference to lookahead token. */
5814  yyn = yypact[yystate];
5815  if (yypact_value_is_default (yyn))
5816  goto yydefault;
5817 
5818  /* Not known => get a lookahead token if don't already have one. */
5819 
5820  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5821  if (yychar == YYEMPTY)
5822  {
5823  YYDPRINTF ((p, "Reading a token: "));
5824  yychar = yylex (&yylval, &yylloc, p);
5825  }
5826 
5827  if (yychar <= YYEOF)
5828  {
5829  yychar = yytoken = YYEOF;
5830  YYDPRINTF ((p, "Now at end of input.\n"));
5831  }
5832  else
5833  {
5834  yytoken = YYTRANSLATE (yychar);
5835  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
5836  }
5837 
5838  /* If the proper action on seeing token YYTOKEN is to reduce or to
5839  detect an error, take that action. */
5840  yyn += yytoken;
5841  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
5842  goto yydefault;
5843  yyn = yytable[yyn];
5844  if (yyn <= 0)
5845  {
5846  if (yytable_value_is_error (yyn))
5847  goto yyerrlab;
5848  yyn = -yyn;
5849  goto yyreduce;
5850  }
5851 
5852  /* Count tokens shifted since error; after three, turn off error
5853  status. */
5854  if (yyerrstatus)
5855  yyerrstatus--;
5856 
5857  /* Shift the lookahead token. */
5858  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
5859 
5860  /* Discard the shifted token. */
5861  yychar = YYEMPTY;
5862 
5863  yystate = yyn;
5865  *++yyvsp = yylval;
5867  *++yylsp = yylloc;
5868  goto yynewstate;
5869 
5870 
5871 /*-----------------------------------------------------------.
5872 | yydefault -- do the default action for the current state. |
5873 `-----------------------------------------------------------*/
5874 yydefault:
5875  yyn = yydefact[yystate];
5876  if (yyn == 0)
5877  goto yyerrlab;
5878  goto yyreduce;
5879 
5880 
5881 /*-----------------------------.
5882 | yyreduce -- Do a reduction. |
5883 `-----------------------------*/
5884 yyreduce:
5885  /* yyn is the number of a rule to reduce with. */
5886  yylen = yyr2[yyn];
5887 
5888  /* If YYLEN is nonzero, implement the default value of the action:
5889  '$$ = $1'.
5890 
5891  Otherwise, the following line sets YYVAL to garbage.
5892  This behavior is undocumented and Bison
5893  users should not rely upon it. Assigning to YYVAL
5894  unconditionally makes the parser a bit smaller, and it avoids a
5895  GCC warning that YYVAL may be used uninitialized. */
5896  yyval = yyvsp[1-yylen];
5897 
5898  /* Default location. */
5899  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
5900  YY_REDUCE_PRINT (yyn);
5901  switch (yyn)
5902  {
5903  case 2:
5904 #line 1177 "ripper.y" /* yacc.c:1646 */
5905  {
5906  SET_LEX_STATE(EXPR_BEG);
5907  local_push(p, ifndef_ripper(1)+0);
5908  }
5909 #line 5905 "ripper.c" /* yacc.c:1646 */
5910  break;
5911 
5912  case 3:
5913 #line 1182 "ripper.y" /* yacc.c:1646 */
5914  {
5915 #if 0
5916  if ((yyvsp[0].val) && !compile_for_eval) {
5917  NODE *node = (yyvsp[0].val);
5918  /* last expression should not be void */
5919  if (nd_type(node) == NODE_BLOCK) {
5920  while (node->nd_next) {
5921  node = node->nd_next;
5922  }
5923  node = node->nd_head;
5924  }
5925  node = remove_begin(node);
5926  void_expr(p, node);
5927  }
5928  p->eval_tree = NEW_SCOPE(0, block_append(p, p->eval_tree, (yyvsp[0].val)), &(yyloc));
5929 #endif
5930  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(program,v1);p->result=v2;}
5931  local_pop(p);
5932  }
5933 #line 5929 "ripper.c" /* yacc.c:1646 */
5934  break;
5935 
5936  case 4:
5937 #line 1204 "ripper.y" /* yacc.c:1646 */
5938  {
5939  (yyval.val) = void_stmts(p, (yyvsp[-1].val));
5940  }
5941 #line 5937 "ripper.c" /* yacc.c:1646 */
5942  break;
5943 
5944  case 5:
5945 #line 1210 "ripper.y" /* yacc.c:1646 */
5946  {
5947 #if 0
5948  (yyval.val) = NEW_BEGIN(0, &(yyloc));
5949 #endif
5950  {VALUE v1,v2,v3,v4,v5;v1=dispatch0(stmts_new);v2=dispatch0(void_stmt);v3=v1;v4=v2;v5=dispatch2(stmts_add,v3,v4);(yyval.val)=v5;}
5951  }
5952 #line 5948 "ripper.c" /* yacc.c:1646 */
5953  break;
5954 
5955  case 6:
5956 #line 1217 "ripper.y" /* yacc.c:1646 */
5957  {
5958 #if 0
5959  (yyval.val) = newline_node((yyvsp[0].val));
5960 #endif
5961  {VALUE v1,v2,v3,v4;v1=dispatch0(stmts_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(stmts_add,v2,v3);(yyval.val)=v4;}
5962  }
5963 #line 5959 "ripper.c" /* yacc.c:1646 */
5964  break;
5965 
5966  case 7:
5967 #line 1224 "ripper.y" /* yacc.c:1646 */
5968  {
5969 #if 0
5970  (yyval.val) = block_append(p, (yyvsp[-2].val), newline_node((yyvsp[0].val)));
5971 #endif
5972  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(stmts_add,v1,v2);(yyval.val)=v3;}
5973  }
5974 #line 5970 "ripper.c" /* yacc.c:1646 */
5975  break;
5976 
5977  case 8:
5978 #line 1231 "ripper.y" /* yacc.c:1646 */
5979  {
5980  (yyval.val) = remove_begin((yyvsp[0].val));
5981  }
5982 #line 5978 "ripper.c" /* yacc.c:1646 */
5983  break;
5984 
5985  case 10:
5986 #line 1238 "ripper.y" /* yacc.c:1646 */
5987  {
5988  (yyval.val) = (yyvsp[0].val);
5989  }
5990 #line 5986 "ripper.c" /* yacc.c:1646 */
5991  break;
5992 
5993  case 11:
5994 #line 1244 "ripper.y" /* yacc.c:1646 */
5995  {
5996 #if 0
5997  p->eval_tree_begin = block_append(p, p->eval_tree_begin,
5998  NEW_BEGIN((yyvsp[-1].val), &(yyloc)));
5999  (yyval.val) = NEW_BEGIN(0, &(yyloc));
6000 #endif
6001  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(BEGIN,v1);(yyval.val)=v2;}
6002  }
6003 #line 5999 "ripper.c" /* yacc.c:1646 */
6004  break;
6005 
6006  case 12:
6007 #line 1256 "ripper.y" /* yacc.c:1646 */
6008  {if (!(yyvsp[-1].val)) {yyerror1(&(yylsp[0]), "else without rescue is useless");}}
6009 #line 6005 "ripper.c" /* yacc.c:1646 */
6010  break;
6011 
6012  case 13:
6013 #line 1259 "ripper.y" /* yacc.c:1646 */
6014  {
6015 #if 0
6016  (yyval.val) = new_bodystmt(p, (yyvsp[-5].val), (yyvsp[-4].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6017 #endif
6018  {VALUE v1,v2,v3,v4,v5;v1=escape_Qundef((yyvsp[-5].val));v2=escape_Qundef((yyvsp[-4].val));v3=escape_Qundef((yyvsp[-1].val));v4=escape_Qundef((yyvsp[0].val));v5=dispatch4(bodystmt,v1,v2,v3,v4);(yyval.val)=v5;}
6019  }
6020 #line 6016 "ripper.c" /* yacc.c:1646 */
6021  break;
6022 
6023  case 14:
6024 #line 1268 "ripper.y" /* yacc.c:1646 */
6025  {
6026 #if 0
6027  (yyval.val) = new_bodystmt(p, (yyvsp[-2].val), (yyvsp[-1].val), 0, (yyvsp[0].val), &(yyloc));
6028 #endif
6029  {VALUE v1,v2,v3,v4,v5;v1=escape_Qundef((yyvsp[-2].val));v2=escape_Qundef((yyvsp[-1].val));v3=Qnil;v4=escape_Qundef((yyvsp[0].val));v5=dispatch4(bodystmt,v1,v2,v3,v4);(yyval.val)=v5;}
6030  }
6031 #line 6027 "ripper.c" /* yacc.c:1646 */
6032  break;
6033 
6034  case 15:
6035 #line 1277 "ripper.y" /* yacc.c:1646 */
6036  {
6037  (yyval.val) = void_stmts(p, (yyvsp[-1].val));
6038  }
6039 #line 6035 "ripper.c" /* yacc.c:1646 */
6040  break;
6041 
6042  case 16:
6043 #line 1283 "ripper.y" /* yacc.c:1646 */
6044  {
6045 #if 0
6046  (yyval.val) = NEW_BEGIN(0, &(yyloc));
6047 #endif
6048  {VALUE v1,v2,v3,v4,v5;v1=dispatch0(stmts_new);v2=dispatch0(void_stmt);v3=v1;v4=v2;v5=dispatch2(stmts_add,v3,v4);(yyval.val)=v5;}
6049  }
6050 #line 6046 "ripper.c" /* yacc.c:1646 */
6051  break;
6052 
6053  case 17:
6054 #line 1290 "ripper.y" /* yacc.c:1646 */
6055  {
6056 #if 0
6057  (yyval.val) = newline_node((yyvsp[0].val));
6058 #endif
6059  {VALUE v1,v2,v3,v4;v1=dispatch0(stmts_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(stmts_add,v2,v3);(yyval.val)=v4;}
6060  }
6061 #line 6057 "ripper.c" /* yacc.c:1646 */
6062  break;
6063 
6064  case 18:
6065 #line 1297 "ripper.y" /* yacc.c:1646 */
6066  {
6067 #if 0
6068  (yyval.val) = block_append(p, (yyvsp[-2].val), newline_node((yyvsp[0].val)));
6069 #endif
6070  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(stmts_add,v1,v2);(yyval.val)=v3;}
6071  }
6072 #line 6068 "ripper.c" /* yacc.c:1646 */
6073  break;
6074 
6075  case 19:
6076 #line 1304 "ripper.y" /* yacc.c:1646 */
6077  {
6078  (yyval.val) = remove_begin((yyvsp[0].val));
6079  }
6080 #line 6076 "ripper.c" /* yacc.c:1646 */
6081  break;
6082 
6083  case 20:
6084 #line 1310 "ripper.y" /* yacc.c:1646 */
6085  {
6086  (yyval.val) = (yyvsp[0].val);
6087  }
6088 #line 6084 "ripper.c" /* yacc.c:1646 */
6089  break;
6090 
6091  case 21:
6092 #line 1314 "ripper.y" /* yacc.c:1646 */
6093  {
6094  yyerror1(&(yylsp[0]), "BEGIN is permitted only at toplevel");
6095  }
6096 #line 6092 "ripper.c" /* yacc.c:1646 */
6097  break;
6098 
6099  case 22:
6100 #line 1318 "ripper.y" /* yacc.c:1646 */
6101  {
6102  (yyval.val) = (yyvsp[0].val);
6103  }
6104 #line 6100 "ripper.c" /* yacc.c:1646 */
6105  break;
6106 
6107  case 23:
6108 #line 1323 "ripper.y" /* yacc.c:1646 */
6109  {SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);}
6110 #line 6106 "ripper.c" /* yacc.c:1646 */
6111  break;
6112 
6113  case 24:
6114 #line 1324 "ripper.y" /* yacc.c:1646 */
6115  {
6116 #if 0
6117  (yyval.val) = NEW_ALIAS((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6118 #endif
6119  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(alias,v1,v2);(yyval.val)=v3;}
6120  }
6121 #line 6117 "ripper.c" /* yacc.c:1646 */
6122  break;
6123 
6124  case 25:
6125 #line 1331 "ripper.y" /* yacc.c:1646 */
6126  {
6127 #if 0
6128  (yyval.val) = NEW_VALIAS((yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6129 #endif
6130  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(var_alias,v1,v2);(yyval.val)=v3;}
6131  }
6132 #line 6128 "ripper.c" /* yacc.c:1646 */
6133  break;
6134 
6135  case 26:
6136 #line 1338 "ripper.y" /* yacc.c:1646 */
6137  {
6138 #if 0
6139  char buf[2];
6140  buf[0] = '$';
6141  buf[1] = (char)(yyvsp[0].val)->nd_nth;
6142  (yyval.val) = NEW_VALIAS((yyvsp[-1].val), rb_intern2(buf, 2), &(yyloc));
6143 #endif
6144  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(var_alias,v1,v2);(yyval.val)=v3;}
6145  }
6146 #line 6142 "ripper.c" /* yacc.c:1646 */
6147  break;
6148 
6149  case 27:
6150 #line 1348 "ripper.y" /* yacc.c:1646 */
6151  {
6152 #if 0
6153  yyerror1(&(yylsp[0]), "can't make alias for the number variables");
6154  (yyval.val) = NEW_BEGIN(0, &(yyloc));
6155 #endif
6156  {VALUE v1,v2,v3,v4,v5;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(var_alias,v1,v2);v4=v3;v5=dispatch1(alias_error,v4);(yyval.val)=v5;}ripper_error(p);
6157  }
6158 #line 6154 "ripper.c" /* yacc.c:1646 */
6159  break;
6160 
6161  case 28:
6162 #line 1356 "ripper.y" /* yacc.c:1646 */
6163  {
6164 #if 0
6165  (yyval.val) = (yyvsp[0].val);
6166 #endif
6167  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(undef,v1);(yyval.val)=v2;}
6168  }
6169 #line 6165 "ripper.c" /* yacc.c:1646 */
6170  break;
6171 
6172  case 29:
6173 #line 1363 "ripper.y" /* yacc.c:1646 */
6174  {
6175 #if 0
6176  (yyval.val) = new_if(p, (yyvsp[0].val), remove_begin((yyvsp[-2].val)), 0, &(yyloc));
6177  fixpos((yyval.val), (yyvsp[0].val));
6178 #endif
6179  {VALUE v1,v2,v3;v1=(yyvsp[0].val);v2=(yyvsp[-2].val);v3=dispatch2(if_mod,v1,v2);(yyval.val)=v3;}
6180  }
6181 #line 6177 "ripper.c" /* yacc.c:1646 */
6182  break;
6183 
6184  case 30:
6185 #line 1371 "ripper.y" /* yacc.c:1646 */
6186  {
6187 #if 0
6188  (yyval.val) = new_unless(p, (yyvsp[0].val), remove_begin((yyvsp[-2].val)), 0, &(yyloc));
6189  fixpos((yyval.val), (yyvsp[0].val));
6190 #endif
6191  {VALUE v1,v2,v3;v1=(yyvsp[0].val);v2=(yyvsp[-2].val);v3=dispatch2(unless_mod,v1,v2);(yyval.val)=v3;}
6192  }
6193 #line 6189 "ripper.c" /* yacc.c:1646 */
6194  break;
6195 
6196  case 31:
6197 #line 1379 "ripper.y" /* yacc.c:1646 */
6198  {
6199 #if 0
6200  if ((yyvsp[-2].val) && nd_type((yyvsp[-2].val)) == NODE_BEGIN) {
6201  (yyval.val) = NEW_WHILE(cond(p, (yyvsp[0].val), &(yylsp[0])), (yyvsp[-2].val)->nd_body, 0, &(yyloc));
6202  }
6203  else {
6204  (yyval.val) = NEW_WHILE(cond(p, (yyvsp[0].val), &(yylsp[0])), (yyvsp[-2].val), 1, &(yyloc));
6205  }
6206 #endif
6207  {VALUE v1,v2,v3;v1=(yyvsp[0].val);v2=(yyvsp[-2].val);v3=dispatch2(while_mod,v1,v2);(yyval.val)=v3;}
6208  }
6209 #line 6205 "ripper.c" /* yacc.c:1646 */
6210  break;
6211 
6212  case 32:
6213 #line 1391 "ripper.y" /* yacc.c:1646 */
6214  {
6215 #if 0
6216  if ((yyvsp[-2].val) && nd_type((yyvsp[-2].val)) == NODE_BEGIN) {
6217  (yyval.val) = NEW_UNTIL(cond(p, (yyvsp[0].val), &(yylsp[0])), (yyvsp[-2].val)->nd_body, 0, &(yyloc));
6218  }
6219  else {
6220  (yyval.val) = NEW_UNTIL(cond(p, (yyvsp[0].val), &(yylsp[0])), (yyvsp[-2].val), 1, &(yyloc));
6221  }
6222 #endif
6223  {VALUE v1,v2,v3;v1=(yyvsp[0].val);v2=(yyvsp[-2].val);v3=dispatch2(until_mod,v1,v2);(yyval.val)=v3;}
6224  }
6225 #line 6221 "ripper.c" /* yacc.c:1646 */
6226  break;
6227 
6228  case 33:
6229 #line 1403 "ripper.y" /* yacc.c:1646 */
6230  {
6231 #if 0
6232  NODE *resq;
6233  YYLTYPE loc = code_loc_gen(&(yylsp[-1]), &(yylsp[0]));
6234  resq = NEW_RESBODY(0, remove_begin((yyvsp[0].val)), 0, &loc);
6235  (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[-2].val)), resq, 0, &(yyloc));
6236 #endif
6237  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(rescue_mod,v1,v2);(yyval.val)=v3;}
6238  }
6239 #line 6235 "ripper.c" /* yacc.c:1646 */
6240  break;
6241 
6242  case 34:
6243 #line 1413 "ripper.y" /* yacc.c:1646 */
6244  {
6245  if (p->in_def) {
6246  rb_warn0("END in method; use at_exit");
6247  }
6248 #if 0
6249  {
6250  NODE *scope = NEW_NODE(
6251  NODE_SCOPE, 0 /* tbl */, (yyvsp[-1].val) /* body */, 0 /* args */, &(yyloc));
6252  (yyval.val) = NEW_POSTEXE(scope, &(yyloc));
6253  }
6254 #endif
6255  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(END,v1);(yyval.val)=v2;}
6256  }
6257 #line 6253 "ripper.c" /* yacc.c:1646 */
6258  break;
6259 
6260  case 36:
6261 #line 1428 "ripper.y" /* yacc.c:1646 */
6262  {
6263 #if 0
6264  value_expr((yyvsp[0].val));
6265  (yyval.val) = node_assign(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6266 #endif
6267  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(massign,v1,v2);(yyval.val)=v3;}
6268  }
6269 #line 6265 "ripper.c" /* yacc.c:1646 */
6270  break;
6271 
6272  case 37:
6273 #line 1436 "ripper.y" /* yacc.c:1646 */
6274  {
6275 #if 0
6276  value_expr((yyvsp[0].val));
6277  (yyval.val) = node_assign(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6278 #endif
6279  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(assign,v1,v2);(yyval.val)=v3;}
6280  }
6281 #line 6277 "ripper.c" /* yacc.c:1646 */
6282  break;
6283 
6284  case 38:
6285 #line 1444 "ripper.y" /* yacc.c:1646 */
6286  {
6287 #if 0
6288  YYLTYPE loc = code_loc_gen(&(yylsp[-1]), &(yylsp[0]));
6289  value_expr((yyvsp[-2].val));
6290  (yyval.val) = node_assign(p, (yyvsp[-4].val), NEW_RESCUE((yyvsp[-2].val), NEW_RESBODY(0, remove_begin((yyvsp[0].val)), 0, &loc), 0, &(yyloc)), &(yyloc));
6291 #endif
6292  {VALUE v1,v2,v3,v4,v5,v6;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(rescue_mod,v1,v2);v4=(yyvsp[-4].val);v5=v3;v6=dispatch2(massign,v4,v5);(yyval.val)=v6;}
6293  }
6294 #line 6290 "ripper.c" /* yacc.c:1646 */
6295  break;
6296 
6297  case 39:
6298 #line 1453 "ripper.y" /* yacc.c:1646 */
6299  {
6300 #if 0
6301  (yyval.val) = node_assign(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6302 #endif
6303  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(massign,v1,v2);(yyval.val)=v3;}
6304  }
6305 #line 6301 "ripper.c" /* yacc.c:1646 */
6306  break;
6307 
6308  case 41:
6309 #line 1463 "ripper.y" /* yacc.c:1646 */
6310  {
6311 #if 0
6312  (yyval.val) = node_assign(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6313 #endif
6314  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(assign,v1,v2);(yyval.val)=v3;}
6315  }
6316 #line 6312 "ripper.c" /* yacc.c:1646 */
6317  break;
6318 
6319  case 42:
6320 #line 1470 "ripper.y" /* yacc.c:1646 */
6321  {
6322 #if 0
6323  (yyval.val) = new_op_assign(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6324 #endif
6325  {VALUE v1,v2,v3,v4;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=(yyvsp[0].val);v4=dispatch3(opassign,v1,v2,v3);(yyval.val)=v4;}
6326  }
6327 #line 6323 "ripper.c" /* yacc.c:1646 */
6328  break;
6329 
6330  case 43:
6331 #line 1477 "ripper.y" /* yacc.c:1646 */
6332  {
6333 #if 0
6334  (yyval.val) = new_ary_op_assign(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-3]), &(yyloc));
6335 #endif
6336  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=(yyvsp[-5].val);v2=escape_Qundef((yyvsp[-3].val));v3=dispatch2(aref_field,v1,v2);v4=v3;v5=(yyvsp[-1].val);v6=(yyvsp[0].val);v7=dispatch3(opassign,v4,v5,v6);(yyval.val)=v7;}
6337 
6338  }
6339 #line 6335 "ripper.c" /* yacc.c:1646 */
6340  break;
6341 
6342  case 44:
6343 #line 1485 "ripper.y" /* yacc.c:1646 */
6344  {
6345 #if 0
6346  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), (yyvsp[-3].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6347 #endif
6348  {VALUE v1,v2,v3,v4,v5,v6,v7,v8;v1=(yyvsp[-4].val);v2=(yyvsp[-3].val);v3=(yyvsp[-2].val);v4=dispatch3(field,v1,v2,v3);v5=v4;v6=(yyvsp[-1].val);v7=(yyvsp[0].val);v8=dispatch3(opassign,v5,v6,v7);(yyval.val)=v8;}
6349  }
6350 #line 6346 "ripper.c" /* yacc.c:1646 */
6351  break;
6352 
6353  case 45:
6354 #line 1492 "ripper.y" /* yacc.c:1646 */
6355  {
6356 #if 0
6357  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), (yyvsp[-3].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6358 #endif
6359  {VALUE v1,v2,v3,v4,v5,v6,v7,v8;v1=(yyvsp[-4].val);v2=(yyvsp[-3].val);v3=(yyvsp[-2].val);v4=dispatch3(field,v1,v2,v3);v5=v4;v6=(yyvsp[-1].val);v7=(yyvsp[0].val);v8=dispatch3(opassign,v5,v6,v7);(yyval.val)=v8;}
6360  }
6361 #line 6357 "ripper.c" /* yacc.c:1646 */
6362  break;
6363 
6364  case 46:
6365 #line 1499 "ripper.y" /* yacc.c:1646 */
6366  {
6367 #if 0
6368  YYLTYPE loc = code_loc_gen(&(yylsp[-4]), &(yylsp[-2]));
6369  (yyval.val) = new_const_op_assign(p, NEW_COLON2((yyvsp[-4].val), (yyvsp[-2].val), &loc), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6370 #endif
6371  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=(yyvsp[-4].val);v2=(yyvsp[-2].val);v3=dispatch2(const_path_field,v1,v2);v4=v3;v5=(yyvsp[-1].val);v6=(yyvsp[0].val);v7=dispatch3(opassign,v4,v5,v6);(yyval.val)=v7;}
6372  }
6373 #line 6369 "ripper.c" /* yacc.c:1646 */
6374  break;
6375 
6376  case 47:
6377 #line 1507 "ripper.y" /* yacc.c:1646 */
6378  {
6379 #if 0
6380  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), ID2VAL(idCOLON2), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6381 #endif
6382  {VALUE v1,v2,v3,v4,v5,v6,v7,v8;v1=(yyvsp[-4].val);v2=ID2VAL(idCOLON2);v3=(yyvsp[-2].val);v4=dispatch3(field,v1,v2,v3);v5=v4;v6=(yyvsp[-1].val);v7=(yyvsp[0].val);v8=dispatch3(opassign,v5,v6,v7);(yyval.val)=v8;}
6383  }
6384 #line 6380 "ripper.c" /* yacc.c:1646 */
6385  break;
6386 
6387  case 48:
6388 #line 1514 "ripper.y" /* yacc.c:1646 */
6389  {
6390 #if 0
6391  rb_backref_error(p, (yyvsp[-2].val));
6392  (yyval.val) = NEW_BEGIN(0, &(yyloc));
6393 #endif
6394  {VALUE v1,v2,v3,v4,v5;v1=var_field(p, (yyvsp[-2].val));v2=(yyvsp[0].val);v3=dispatch2(assign,v1,v2);v4=v3;v5=dispatch1(assign_error,v4);(yyval.val)=v5;}ripper_error(p);
6395  }
6396 #line 6392 "ripper.c" /* yacc.c:1646 */
6397  break;
6398 
6399  case 49:
6400 #line 1524 "ripper.y" /* yacc.c:1646 */
6401  {
6402  value_expr((yyvsp[0].val));
6403  (yyval.val) = (yyvsp[0].val);
6404  }
6405 #line 6401 "ripper.c" /* yacc.c:1646 */
6406  break;
6407 
6408  case 50:
6409 #line 1529 "ripper.y" /* yacc.c:1646 */
6410  {
6411 #if 0
6412  YYLTYPE loc = code_loc_gen(&(yylsp[-1]), &(yylsp[0]));
6413  value_expr((yyvsp[-2].val));
6414  (yyval.val) = NEW_RESCUE((yyvsp[-2].val), NEW_RESBODY(0, remove_begin((yyvsp[0].val)), 0, &loc), 0, &(yyloc));
6415 #endif
6416  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(rescue_mod,v1,v2);(yyval.val)=v3;}
6417  }
6418 #line 6414 "ripper.c" /* yacc.c:1646 */
6419  break;
6420 
6421  case 53:
6422 #line 1542 "ripper.y" /* yacc.c:1646 */
6423  {
6424  (yyval.val) = logop(p, idAND, (yyvsp[-2].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
6425  }
6426 #line 6422 "ripper.c" /* yacc.c:1646 */
6427  break;
6428 
6429  case 54:
6430 #line 1546 "ripper.y" /* yacc.c:1646 */
6431  {
6432  (yyval.val) = logop(p, idOR, (yyvsp[-2].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
6433  }
6434 #line 6430 "ripper.c" /* yacc.c:1646 */
6435  break;
6436 
6437  case 55:
6438 #line 1550 "ripper.y" /* yacc.c:1646 */
6439  {
6440  (yyval.val) = call_uni_op(p, method_cond(p, (yyvsp[0].val), &(yylsp[0])), METHOD_NOT, &(yylsp[-2]), &(yyloc));
6441  }
6442 #line 6438 "ripper.c" /* yacc.c:1646 */
6443  break;
6444 
6445  case 56:
6446 #line 1554 "ripper.y" /* yacc.c:1646 */
6447  {
6448  (yyval.val) = call_uni_op(p, method_cond(p, (yyvsp[0].val), &(yylsp[0])), '!', &(yylsp[-1]), &(yyloc));
6449  }
6450 #line 6446 "ripper.c" /* yacc.c:1646 */
6451  break;
6452 
6453  case 57:
6454 #line 1558 "ripper.y" /* yacc.c:1646 */
6455  {
6456  value_expr((yyvsp[-1].val));
6457  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
6458  p->command_start = FALSE;
6459  (yyval.num) = p->in_kwarg;
6460  p->in_kwarg = 1;
6461  }
6462 #line 6458 "ripper.c" /* yacc.c:1646 */
6463  break;
6464 
6465  case 58:
6466 #line 1565 "ripper.y" /* yacc.c:1646 */
6467  {(yyval.tbl) = push_pvtbl(p);}
6468 #line 6464 "ripper.c" /* yacc.c:1646 */
6469  break;
6470 
6471  case 59:
6472 #line 1567 "ripper.y" /* yacc.c:1646 */
6473  {pop_pvtbl(p, (yyvsp[-1].tbl));}
6474 #line 6470 "ripper.c" /* yacc.c:1646 */
6475  break;
6476 
6477  case 60:
6478 #line 1568 "ripper.y" /* yacc.c:1646 */
6479  {
6480  p->in_kwarg = !!(yyvsp[-3].num);
6481 #if 0
6482  (yyval.val) = new_case3(p, (yyvsp[-5].val), NEW_IN((yyvsp[-1].val), 0, 0, &(yylsp[-1])), &(yyloc));
6483 #endif
6484  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=(yyvsp[-1].val);v2=Qnil;v3=Qnil;v4=dispatch3(in,v1,v2,v3);v5=(yyvsp[-5].val);v6=v4;v7=dispatch2(case,v5,v6);(yyval.val)=v7;}
6485  }
6486 #line 6482 "ripper.c" /* yacc.c:1646 */
6487  break;
6488 
6489  case 62:
6490 #line 1579 "ripper.y" /* yacc.c:1646 */
6491  {
6492  value_expr((yyvsp[0].val));
6493  (yyval.val) = (yyvsp[0].val);
6494  }
6495 #line 6491 "ripper.c" /* yacc.c:1646 */
6496  break;
6497 
6498  case 63:
6499 #line 1585 "ripper.y" /* yacc.c:1646 */
6500  {COND_PUSH(1);}
6501 #line 6497 "ripper.c" /* yacc.c:1646 */
6502  break;
6503 
6504  case 64:
6505 #line 1585 "ripper.y" /* yacc.c:1646 */
6506  {COND_POP();}
6507 #line 6503 "ripper.c" /* yacc.c:1646 */
6508  break;
6509 
6510  case 65:
6511 #line 1586 "ripper.y" /* yacc.c:1646 */
6512  {
6513  (yyval.val) = (yyvsp[-2].val);
6514  }
6515 #line 6511 "ripper.c" /* yacc.c:1646 */
6516  break;
6517 
6518  case 69:
6519 #line 1597 "ripper.y" /* yacc.c:1646 */
6520  {
6521 #if 0
6522  (yyval.val) = new_qcall(p, (yyvsp[-2].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
6523 #endif
6524  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=(yyvsp[-3].val);v2=(yyvsp[-2].val);v3=(yyvsp[-1].val);v4=dispatch3(call,v1,v2,v3);v5=v4;v6=(yyvsp[0].val);v7=dispatch2(method_add_arg,v5,v6);(yyval.val)=v7;}
6525  }
6526 #line 6522 "ripper.c" /* yacc.c:1646 */
6527  break;
6528 
6529  case 70:
6530 #line 1606 "ripper.y" /* yacc.c:1646 */
6531  {
6532  (yyval.val) = (yyvsp[-1].val);
6533 #if 0
6534  (yyval.val)->nd_body->nd_loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
6535  nd_set_line((yyval.val), (yylsp[-2]).end_pos.lineno);
6536 #endif
6537  }
6538 #line 6534 "ripper.c" /* yacc.c:1646 */
6539  break;
6540 
6541  case 71:
6542 #line 1616 "ripper.y" /* yacc.c:1646 */
6543  {
6544 #if 0
6545  (yyval.val) = NEW_FCALL((yyvsp[0].val), 0, &(yyloc));
6546  nd_set_line((yyval.val), p->tokline);
6547 #endif
6548  (yyval.val)=(yyvsp[0].val);
6549  }
6550 #line 6546 "ripper.c" /* yacc.c:1646 */
6551  break;
6552 
6553  case 72:
6554 #line 1626 "ripper.y" /* yacc.c:1646 */
6555  {
6556 #if 0
6557  (yyvsp[-1].val)->nd_args = (yyvsp[0].val);
6558  nd_set_last_loc((yyvsp[-1].val), (yylsp[0]).end_pos);
6559  (yyval.val) = (yyvsp[-1].val);
6560 #endif
6561  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(command,v1,v2);(yyval.val)=v3;}
6562  }
6563 #line 6559 "ripper.c" /* yacc.c:1646 */
6564  break;
6565 
6566  case 73:
6567 #line 1635 "ripper.y" /* yacc.c:1646 */
6568  {
6569 #if 0
6570  block_dup_check(p, (yyvsp[-1].val), (yyvsp[0].val));
6571  (yyvsp[-2].val)->nd_args = (yyvsp[-1].val);
6572  (yyval.val) = method_add_block(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6573  fixpos((yyval.val), (yyvsp[-2].val));
6574  nd_set_last_loc((yyvsp[-2].val), (yylsp[-1]).end_pos);
6575 #endif
6576  {VALUE v1,v2,v3,v4,v5,v6;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(command,v1,v2);v4=v3;v5=(yyvsp[0].val);v6=dispatch2(method_add_block,v4,v5);(yyval.val)=v6;}
6577  }
6578 #line 6574 "ripper.c" /* yacc.c:1646 */
6579  break;
6580 
6581  case 74:
6582 #line 1646 "ripper.y" /* yacc.c:1646 */
6583  {
6584 #if 0
6585  (yyval.val) = new_command_qcall(p, (yyvsp[-2].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), Qnull, &(yylsp[-1]), &(yyloc));
6586 #endif
6587  {VALUE v1,v2,v3,v4,v5;v1=(yyvsp[-3].val);v2=(yyvsp[-2].val);v3=(yyvsp[-1].val);v4=(yyvsp[0].val);v5=dispatch4(command_call,v1,v2,v3,v4);(yyval.val)=v5;}
6588  }
6589 #line 6585 "ripper.c" /* yacc.c:1646 */
6590  break;
6591 
6592  case 75:
6593 #line 1653 "ripper.y" /* yacc.c:1646 */
6594  {
6595 #if 0
6596  (yyval.val) = new_command_qcall(p, (yyvsp[-3].val), (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-2]), &(yyloc));
6597 #endif
6598  {VALUE v1,v2,v3,v4,v5,v6,v7,v8;v1=(yyvsp[-4].val);v2=(yyvsp[-3].val);v3=(yyvsp[-2].val);v4=(yyvsp[-1].val);v5=dispatch4(command_call,v1,v2,v3,v4);v6=v5;v7=(yyvsp[0].val);v8=dispatch2(method_add_block,v6,v7);(yyval.val)=v8;}
6599  }
6600 #line 6596 "ripper.c" /* yacc.c:1646 */
6601  break;
6602 
6603  case 76:
6604 #line 1660 "ripper.y" /* yacc.c:1646 */
6605  {
6606 #if 0
6607  (yyval.val) = new_command_qcall(p, ID2VAL(idCOLON2), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), Qnull, &(yylsp[-1]), &(yyloc));
6608 #endif
6609  {VALUE v1,v2,v3,v4,v5;v1=(yyvsp[-3].val);v2=ID2VAL(idCOLON2);v3=(yyvsp[-1].val);v4=(yyvsp[0].val);v5=dispatch4(command_call,v1,v2,v3,v4);(yyval.val)=v5;}
6610  }
6611 #line 6607 "ripper.c" /* yacc.c:1646 */
6612  break;
6613 
6614  case 77:
6615 #line 1667 "ripper.y" /* yacc.c:1646 */
6616  {
6617 #if 0
6618  (yyval.val) = new_command_qcall(p, ID2VAL(idCOLON2), (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-2]), &(yyloc));
6619 #endif
6620  {VALUE v1,v2,v3,v4,v5,v6,v7,v8;v1=(yyvsp[-4].val);v2=ID2VAL(idCOLON2);v3=(yyvsp[-2].val);v4=(yyvsp[-1].val);v5=dispatch4(command_call,v1,v2,v3,v4);v6=v5;v7=(yyvsp[0].val);v8=dispatch2(method_add_block,v6,v7);(yyval.val)=v8;}
6621  }
6622 #line 6618 "ripper.c" /* yacc.c:1646 */
6623  break;
6624 
6625  case 78:
6626 #line 1674 "ripper.y" /* yacc.c:1646 */
6627  {
6628 #if 0
6629  (yyval.val) = NEW_SUPER((yyvsp[0].val), &(yyloc));
6630  fixpos((yyval.val), (yyvsp[0].val));
6631 #endif
6632  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(super,v1);(yyval.val)=v2;}
6633  }
6634 #line 6630 "ripper.c" /* yacc.c:1646 */
6635  break;
6636 
6637  case 79:
6638 #line 1682 "ripper.y" /* yacc.c:1646 */
6639  {
6640 #if 0
6641  (yyval.val) = new_yield(p, (yyvsp[0].val), &(yyloc));
6642  fixpos((yyval.val), (yyvsp[0].val));
6643 #endif
6644  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(yield,v1);(yyval.val)=v2;}
6645  }
6646 #line 6642 "ripper.c" /* yacc.c:1646 */
6647  break;
6648 
6649  case 80:
6650 #line 1690 "ripper.y" /* yacc.c:1646 */
6651  {
6652 #if 0
6653  (yyval.val) = NEW_RETURN(ret_args(p, (yyvsp[0].val)), &(yyloc));
6654 #endif
6655  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(return,v1);(yyval.val)=v2;}
6656  }
6657 #line 6653 "ripper.c" /* yacc.c:1646 */
6658  break;
6659 
6660  case 81:
6661 #line 1697 "ripper.y" /* yacc.c:1646 */
6662  {
6663 #if 0
6664  (yyval.val) = NEW_BREAK(ret_args(p, (yyvsp[0].val)), &(yyloc));
6665 #endif
6666  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(break,v1);(yyval.val)=v2;}
6667  }
6668 #line 6664 "ripper.c" /* yacc.c:1646 */
6669  break;
6670 
6671  case 82:
6672 #line 1704 "ripper.y" /* yacc.c:1646 */
6673  {
6674 #if 0
6675  (yyval.val) = NEW_NEXT(ret_args(p, (yyvsp[0].val)), &(yyloc));
6676 #endif
6677  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(next,v1);(yyval.val)=v2;}
6678  }
6679 #line 6675 "ripper.c" /* yacc.c:1646 */
6680  break;
6681 
6682  case 84:
6683 #line 1714 "ripper.y" /* yacc.c:1646 */
6684  {
6685 #if 0
6686  (yyval.val) = (yyvsp[-1].val);
6687 #endif
6688  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(mlhs_paren,v1);(yyval.val)=v2;}
6689  }
6690 #line 6686 "ripper.c" /* yacc.c:1646 */
6691  break;
6692 
6693  case 86:
6694 #line 1724 "ripper.y" /* yacc.c:1646 */
6695  {
6696 #if 0
6697  (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[-1].val), &(yyloc)), 0, &(yyloc));
6698 #endif
6699  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(mlhs_paren,v1);(yyval.val)=v2;}
6700  }
6701 #line 6697 "ripper.c" /* yacc.c:1646 */
6702  break;
6703 
6704  case 87:
6705 #line 1733 "ripper.y" /* yacc.c:1646 */
6706  {
6707 #if 0
6708  (yyval.val) = NEW_MASGN((yyvsp[0].val), 0, &(yyloc));
6709 #endif
6710  (yyval.val)=(yyvsp[0].val);
6711  }
6712 #line 6708 "ripper.c" /* yacc.c:1646 */
6713  break;
6714 
6715  case 88:
6716 #line 1740 "ripper.y" /* yacc.c:1646 */
6717  {
6718 #if 0
6719  (yyval.val) = NEW_MASGN(list_append(p, (yyvsp[-1].val),(yyvsp[0].val)), 0, &(yyloc));
6720 #endif
6721  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(mlhs_add,v1,v2);(yyval.val)=v3;}
6722  }
6723 #line 6719 "ripper.c" /* yacc.c:1646 */
6724  break;
6725 
6726  case 89:
6727 #line 1747 "ripper.y" /* yacc.c:1646 */
6728  {
6729 #if 0
6730  (yyval.val) = NEW_MASGN((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6731 #endif
6732  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(mlhs_add_star,v1,v2);(yyval.val)=v3;}
6733  }
6734 #line 6730 "ripper.c" /* yacc.c:1646 */
6735  break;
6736 
6737  case 90:
6738 #line 1754 "ripper.y" /* yacc.c:1646 */
6739  {
6740 #if 0
6741  (yyval.val) = NEW_MASGN((yyvsp[-4].val), NEW_POSTARG((yyvsp[-2].val),(yyvsp[0].val),&(yyloc)), &(yyloc));
6742 #endif
6743  {VALUE v1,v2,v3,v4,v5,v6;v1=(yyvsp[-4].val);v2=(yyvsp[-2].val);v3=dispatch2(mlhs_add_star,v1,v2);v4=v3;v5=(yyvsp[0].val);v6=dispatch2(mlhs_add_post,v4,v5);(yyval.val)=v6;}
6744  }
6745 #line 6741 "ripper.c" /* yacc.c:1646 */
6746  break;
6747 
6748  case 91:
6749 #line 1761 "ripper.y" /* yacc.c:1646 */
6750  {
6751 #if 0
6752  (yyval.val) = NEW_MASGN((yyvsp[-1].val), NODE_SPECIAL_NO_NAME_REST, &(yyloc));
6753 #endif
6754  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(mlhs_add_star,v1,v2);(yyval.val)=v3;}
6755  }
6756 #line 6752 "ripper.c" /* yacc.c:1646 */
6757  break;
6758 
6759  case 92:
6760 #line 1768 "ripper.y" /* yacc.c:1646 */
6761  {
6762 #if 0
6763  (yyval.val) = NEW_MASGN((yyvsp[-3].val), NEW_POSTARG(NODE_SPECIAL_NO_NAME_REST, (yyvsp[0].val), &(yyloc)), &(yyloc));
6764 #endif
6765  {VALUE v1,v2,v3,v4,v5,v6;v1=(yyvsp[-3].val);v2=Qnil;v3=dispatch2(mlhs_add_star,v1,v2);v4=v3;v5=(yyvsp[0].val);v6=dispatch2(mlhs_add_post,v4,v5);(yyval.val)=v6;}
6766  }
6767 #line 6763 "ripper.c" /* yacc.c:1646 */
6768  break;
6769 
6770  case 93:
6771 #line 1775 "ripper.y" /* yacc.c:1646 */
6772  {
6773 #if 0
6774  (yyval.val) = NEW_MASGN(0, (yyvsp[0].val), &(yyloc));
6775 #endif
6776  {VALUE v1,v2,v3,v4;v1=dispatch0(mlhs_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(mlhs_add_star,v2,v3);(yyval.val)=v4;}
6777  }
6778 #line 6774 "ripper.c" /* yacc.c:1646 */
6779  break;
6780 
6781  case 94:
6782 #line 1782 "ripper.y" /* yacc.c:1646 */
6783  {
6784 #if 0
6785  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[-2].val),(yyvsp[0].val),&(yyloc)), &(yyloc));
6786 #endif
6787  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=dispatch0(mlhs_new);v2=v1;v3=(yyvsp[-2].val);v4=dispatch2(mlhs_add_star,v2,v3);v5=v4;v6=(yyvsp[0].val);v7=dispatch2(mlhs_add_post,v5,v6);(yyval.val)=v7;}
6788  }
6789 #line 6785 "ripper.c" /* yacc.c:1646 */
6790  break;
6791 
6792  case 95:
6793 #line 1789 "ripper.y" /* yacc.c:1646 */
6794  {
6795 #if 0
6796  (yyval.val) = NEW_MASGN(0, NODE_SPECIAL_NO_NAME_REST, &(yyloc));
6797 #endif
6798  {VALUE v1,v2,v3,v4;v1=dispatch0(mlhs_new);v2=v1;v3=Qnil;v4=dispatch2(mlhs_add_star,v2,v3);(yyval.val)=v4;}
6799  }
6800 #line 6796 "ripper.c" /* yacc.c:1646 */
6801  break;
6802 
6803  case 96:
6804 #line 1796 "ripper.y" /* yacc.c:1646 */
6805  {
6806 #if 0
6807  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(NODE_SPECIAL_NO_NAME_REST, (yyvsp[0].val), &(yyloc)), &(yyloc));
6808 #endif
6809  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=dispatch0(mlhs_new);v2=v1;v3=Qnil;v4=dispatch2(mlhs_add_star,v2,v3);v5=v4;v6=(yyvsp[0].val);v7=dispatch2(mlhs_add_post,v5,v6);(yyval.val)=v7;}
6810  }
6811 #line 6807 "ripper.c" /* yacc.c:1646 */
6812  break;
6813 
6814  case 98:
6815 #line 1806 "ripper.y" /* yacc.c:1646 */
6816  {
6817 #if 0
6818  (yyval.val) = (yyvsp[-1].val);
6819 #endif
6820  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(mlhs_paren,v1);(yyval.val)=v2;}
6821  }
6822 #line 6818 "ripper.c" /* yacc.c:1646 */
6823  break;
6824 
6825  case 99:
6826 #line 1815 "ripper.y" /* yacc.c:1646 */
6827  {
6828 #if 0
6829  (yyval.val) = NEW_LIST((yyvsp[-1].val), &(yylsp[-1]));
6830 #endif
6831  {VALUE v1,v2,v3,v4;v1=dispatch0(mlhs_new);v2=v1;v3=(yyvsp[-1].val);v4=dispatch2(mlhs_add,v2,v3);(yyval.val)=v4;}
6832  }
6833 #line 6829 "ripper.c" /* yacc.c:1646 */
6834  break;
6835 
6836  case 100:
6837 #line 1822 "ripper.y" /* yacc.c:1646 */
6838  {
6839 #if 0
6840  (yyval.val) = list_append(p, (yyvsp[-2].val), (yyvsp[-1].val));
6841 #endif
6842  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(mlhs_add,v1,v2);(yyval.val)=v3;}
6843  }
6844 #line 6840 "ripper.c" /* yacc.c:1646 */
6845  break;
6846 
6847  case 101:
6848 #line 1831 "ripper.y" /* yacc.c:1646 */
6849  {
6850 #if 0
6851  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
6852 #endif
6853  {VALUE v1,v2,v3,v4;v1=dispatch0(mlhs_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(mlhs_add,v2,v3);(yyval.val)=v4;}
6854  }
6855 #line 6851 "ripper.c" /* yacc.c:1646 */
6856  break;
6857 
6858  case 102:
6859 #line 1838 "ripper.y" /* yacc.c:1646 */
6860  {
6861 #if 0
6862  (yyval.val) = list_append(p, (yyvsp[-2].val), (yyvsp[0].val));
6863 #endif
6864  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(mlhs_add,v1,v2);(yyval.val)=v3;}
6865  }
6866 #line 6862 "ripper.c" /* yacc.c:1646 */
6867  break;
6868 
6869  case 103:
6870 #line 1847 "ripper.y" /* yacc.c:1646 */
6871  {
6872 #if 0
6873  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
6874 #endif
6875  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
6876  }
6877 #line 6873 "ripper.c" /* yacc.c:1646 */
6878  break;
6879 
6880  case 104:
6881 #line 1854 "ripper.y" /* yacc.c:1646 */
6882  {
6883 #if 0
6884  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
6885 #endif
6886  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
6887  }
6888 #line 6884 "ripper.c" /* yacc.c:1646 */
6889  break;
6890 
6891  case 105:
6892 #line 1861 "ripper.y" /* yacc.c:1646 */
6893  {
6894 #if 0
6895  (yyval.val) = aryset(p, (yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
6896 #endif
6897  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=escape_Qundef((yyvsp[-1].val));v3=dispatch2(aref_field,v1,v2);(yyval.val)=v3;}
6898  }
6899 #line 6895 "ripper.c" /* yacc.c:1646 */
6900  break;
6901 
6902  case 106:
6903 #line 1868 "ripper.y" /* yacc.c:1646 */
6904  {
6905  if ((yyvsp[-1].val) == tANDDOT) {
6906  yyerror1(&(yylsp[-1]), "&. inside multiple assignment destination");
6907  }
6908 #if 0
6909  (yyval.val) = attrset(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6910 #endif
6911  {VALUE v1,v2,v3,v4;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=(yyvsp[0].val);v4=dispatch3(field,v1,v2,v3);(yyval.val)=v4;}
6912  }
6913 #line 6909 "ripper.c" /* yacc.c:1646 */
6914  break;
6915 
6916  case 107:
6917 #line 1878 "ripper.y" /* yacc.c:1646 */
6918  {
6919 #if 0
6920  (yyval.val) = attrset(p, (yyvsp[-2].val), idCOLON2, (yyvsp[0].val), &(yyloc));
6921 #endif
6922  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(const_path_field,v1,v2);(yyval.val)=v3;}
6923  }
6924 #line 6920 "ripper.c" /* yacc.c:1646 */
6925  break;
6926 
6927  case 108:
6928 #line 1885 "ripper.y" /* yacc.c:1646 */
6929  {
6930  if ((yyvsp[-1].val) == tANDDOT) {
6931  yyerror1(&(yylsp[-1]), "&. inside multiple assignment destination");
6932  }
6933 #if 0
6934  (yyval.val) = attrset(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6935 #endif
6936  {VALUE v1,v2,v3,v4;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=(yyvsp[0].val);v4=dispatch3(field,v1,v2,v3);(yyval.val)=v4;}
6937  }
6938 #line 6934 "ripper.c" /* yacc.c:1646 */
6939  break;
6940 
6941  case 109:
6942 #line 1895 "ripper.y" /* yacc.c:1646 */
6943  {
6944 #if 0
6945  (yyval.val) = const_decl(p, NEW_COLON2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
6946 #endif
6947  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(const_path_field,v1,v2);(yyval.val)=const_decl(p, v3);}
6948  }
6949 #line 6945 "ripper.c" /* yacc.c:1646 */
6950  break;
6951 
6952  case 110:
6953 #line 1902 "ripper.y" /* yacc.c:1646 */
6954  {
6955 #if 0
6956  (yyval.val) = const_decl(p, NEW_COLON3((yyvsp[0].val), &(yyloc)), &(yyloc));
6957 #endif
6958  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(top_const_field,v1);(yyval.val)=const_decl(p, v2);}
6959  }
6960 #line 6956 "ripper.c" /* yacc.c:1646 */
6961  break;
6962 
6963  case 111:
6964 #line 1909 "ripper.y" /* yacc.c:1646 */
6965  {
6966 #if 0
6967  rb_backref_error(p, (yyvsp[0].val));
6968  (yyval.val) = NEW_BEGIN(0, &(yyloc));
6969 #endif
6970  {VALUE v1,v2;v1=var_field(p, (yyvsp[0].val));v2=dispatch1(assign_error,v1);(yyval.val)=v2;}ripper_error(p);
6971  }
6972 #line 6968 "ripper.c" /* yacc.c:1646 */
6973  break;
6974 
6975  case 112:
6976 #line 1919 "ripper.y" /* yacc.c:1646 */
6977  {
6978 #if 0
6979  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
6980 #endif
6981  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
6982  }
6983 #line 6979 "ripper.c" /* yacc.c:1646 */
6984  break;
6985 
6986  case 113:
6987 #line 1926 "ripper.y" /* yacc.c:1646 */
6988  {
6989 #if 0
6990  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
6991 #endif
6992  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
6993  }
6994 #line 6990 "ripper.c" /* yacc.c:1646 */
6995  break;
6996 
6997  case 114:
6998 #line 1933 "ripper.y" /* yacc.c:1646 */
6999  {
7000 #if 0
7001  (yyval.val) = aryset(p, (yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
7002 #endif
7003  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=escape_Qundef((yyvsp[-1].val));v3=dispatch2(aref_field,v1,v2);(yyval.val)=v3;}
7004  }
7005 #line 7001 "ripper.c" /* yacc.c:1646 */
7006  break;
7007 
7008  case 115:
7009 #line 1940 "ripper.y" /* yacc.c:1646 */
7010  {
7011 #if 0
7012  (yyval.val) = attrset(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7013 #endif
7014  {VALUE v1,v2,v3,v4;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=(yyvsp[0].val);v4=dispatch3(field,v1,v2,v3);(yyval.val)=v4;}
7015  }
7016 #line 7012 "ripper.c" /* yacc.c:1646 */
7017  break;
7018 
7019  case 116:
7020 #line 1947 "ripper.y" /* yacc.c:1646 */
7021  {
7022 #if 0
7023  (yyval.val) = attrset(p, (yyvsp[-2].val), idCOLON2, (yyvsp[0].val), &(yyloc));
7024 #endif
7025  {VALUE v1,v2,v3,v4;v1=(yyvsp[-2].val);v2=ID2VAL(idCOLON2);v3=(yyvsp[0].val);v4=dispatch3(field,v1,v2,v3);(yyval.val)=v4;}
7026  }
7027 #line 7023 "ripper.c" /* yacc.c:1646 */
7028  break;
7029 
7030  case 117:
7031 #line 1954 "ripper.y" /* yacc.c:1646 */
7032  {
7033 #if 0
7034  (yyval.val) = attrset(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7035 #endif
7036  {VALUE v1,v2,v3,v4;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=(yyvsp[0].val);v4=dispatch3(field,v1,v2,v3);(yyval.val)=v4;}
7037  }
7038 #line 7034 "ripper.c" /* yacc.c:1646 */
7039  break;
7040 
7041  case 118:
7042 #line 1961 "ripper.y" /* yacc.c:1646 */
7043  {
7044 #if 0
7045  (yyval.val) = const_decl(p, NEW_COLON2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
7046 #endif
7047  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(const_path_field,v1,v2);(yyval.val)=const_decl(p, v3);}
7048  }
7049 #line 7045 "ripper.c" /* yacc.c:1646 */
7050  break;
7051 
7052  case 119:
7053 #line 1968 "ripper.y" /* yacc.c:1646 */
7054  {
7055 #if 0
7056  (yyval.val) = const_decl(p, NEW_COLON3((yyvsp[0].val), &(yyloc)), &(yyloc));
7057 #endif
7058  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(top_const_field,v1);(yyval.val)=const_decl(p, v2);}
7059  }
7060 #line 7056 "ripper.c" /* yacc.c:1646 */
7061  break;
7062 
7063  case 120:
7064 #line 1975 "ripper.y" /* yacc.c:1646 */
7065  {
7066 #if 0
7067  rb_backref_error(p, (yyvsp[0].val));
7068  (yyval.val) = NEW_BEGIN(0, &(yyloc));
7069 #endif
7070  {VALUE v1,v2;v1=var_field(p, (yyvsp[0].val));v2=dispatch1(assign_error,v1);(yyval.val)=v2;}ripper_error(p);
7071  }
7072 #line 7068 "ripper.c" /* yacc.c:1646 */
7073  break;
7074 
7075  case 121:
7076 #line 1985 "ripper.y" /* yacc.c:1646 */
7077  {
7078 #if 0
7079  yyerror1(&(yylsp[0]), "class/module name must be CONSTANT");
7080 #endif
7081  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(class_name_error,v1);(yyval.val)=v2;}ripper_error(p);
7082  }
7083 #line 7079 "ripper.c" /* yacc.c:1646 */
7084  break;
7085 
7086  case 123:
7087 #line 1995 "ripper.y" /* yacc.c:1646 */
7088  {
7089 #if 0
7090  (yyval.val) = NEW_COLON3((yyvsp[0].val), &(yyloc));
7091 #endif
7092  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(top_const_ref,v1);(yyval.val)=v2;}
7093  }
7094 #line 7090 "ripper.c" /* yacc.c:1646 */
7095  break;
7096 
7097  case 124:
7098 #line 2002 "ripper.y" /* yacc.c:1646 */
7099  {
7100 #if 0
7101  (yyval.val) = NEW_COLON2(0, (yyval.val), &(yyloc));
7102 #endif
7103  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(const_ref,v1);(yyval.val)=v2;}
7104  }
7105 #line 7101 "ripper.c" /* yacc.c:1646 */
7106  break;
7107 
7108  case 125:
7109 #line 2009 "ripper.y" /* yacc.c:1646 */
7110  {
7111 #if 0
7112  (yyval.val) = NEW_COLON2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
7113 #endif
7114  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(const_path_ref,v1,v2);(yyval.val)=v3;}
7115  }
7116 #line 7112 "ripper.c" /* yacc.c:1646 */
7117  break;
7118 
7119  case 129:
7120 #line 2021 "ripper.y" /* yacc.c:1646 */
7121  {
7122  SET_LEX_STATE(EXPR_ENDFN);
7123  (yyval.val) = (yyvsp[0].val);
7124  }
7125 #line 7121 "ripper.c" /* yacc.c:1646 */
7126  break;
7127 
7128  case 131:
7129 #line 2029 "ripper.y" /* yacc.c:1646 */
7130  {
7131 #if 0
7132  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[0].val)), &(yyloc));
7133 #endif
7134  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(symbol_literal,v1);(yyval.val)=v2;}
7135  }
7136 #line 7132 "ripper.c" /* yacc.c:1646 */
7137  break;
7138 
7139  case 133:
7140 #line 2039 "ripper.y" /* yacc.c:1646 */
7141  {
7142 #if 0
7143  (yyval.val) = NEW_UNDEF((yyvsp[0].val), &(yyloc));
7144 #endif
7145  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
7146  }
7147 #line 7143 "ripper.c" /* yacc.c:1646 */
7148  break;
7149 
7150  case 134:
7151 #line 2045 "ripper.y" /* yacc.c:1646 */
7152  {SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);}
7153 #line 7149 "ripper.c" /* yacc.c:1646 */
7154  break;
7155 
7156  case 135:
7157 #line 2046 "ripper.y" /* yacc.c:1646 */
7158  {
7159 #if 0
7160  NODE *undef = NEW_UNDEF((yyvsp[0].val), &(yylsp[0]));
7161  (yyval.val) = block_append(p, (yyvsp[-3].val), undef);
7162 #endif
7163  (yyval.val)=rb_ary_push((yyvsp[-3].val), get_value((yyvsp[0].val)));
7164  }
7165 #line 7161 "ripper.c" /* yacc.c:1646 */
7166  break;
7167 
7168  case 136:
7169 #line 2055 "ripper.y" /* yacc.c:1646 */
7170  { ifndef_ripper((yyval.val) = '|'); }
7171 #line 7167 "ripper.c" /* yacc.c:1646 */
7172  break;
7173 
7174  case 137:
7175 #line 2056 "ripper.y" /* yacc.c:1646 */
7176  { ifndef_ripper((yyval.val) = '^'); }
7177 #line 7173 "ripper.c" /* yacc.c:1646 */
7178  break;
7179 
7180  case 138:
7181 #line 2057 "ripper.y" /* yacc.c:1646 */
7182  { ifndef_ripper((yyval.val) = '&'); }
7183 #line 7179 "ripper.c" /* yacc.c:1646 */
7184  break;
7185 
7186  case 139:
7187 #line 2058 "ripper.y" /* yacc.c:1646 */
7188  { ifndef_ripper((yyval.val) = tCMP); }
7189 #line 7185 "ripper.c" /* yacc.c:1646 */
7190  break;
7191 
7192  case 140:
7193 #line 2059 "ripper.y" /* yacc.c:1646 */
7194  { ifndef_ripper((yyval.val) = tEQ); }
7195 #line 7191 "ripper.c" /* yacc.c:1646 */
7196  break;
7197 
7198  case 141:
7199 #line 2060 "ripper.y" /* yacc.c:1646 */
7200  { ifndef_ripper((yyval.val) = tEQQ); }
7201 #line 7197 "ripper.c" /* yacc.c:1646 */
7202  break;
7203 
7204  case 142:
7205 #line 2061 "ripper.y" /* yacc.c:1646 */
7206  { ifndef_ripper((yyval.val) = tMATCH); }
7207 #line 7203 "ripper.c" /* yacc.c:1646 */
7208  break;
7209 
7210  case 143:
7211 #line 2062 "ripper.y" /* yacc.c:1646 */
7212  { ifndef_ripper((yyval.val) = tNMATCH); }
7213 #line 7209 "ripper.c" /* yacc.c:1646 */
7214  break;
7215 
7216  case 144:
7217 #line 2063 "ripper.y" /* yacc.c:1646 */
7218  { ifndef_ripper((yyval.val) = '>'); }
7219 #line 7215 "ripper.c" /* yacc.c:1646 */
7220  break;
7221 
7222  case 145:
7223 #line 2064 "ripper.y" /* yacc.c:1646 */
7224  { ifndef_ripper((yyval.val) = tGEQ); }
7225 #line 7221 "ripper.c" /* yacc.c:1646 */
7226  break;
7227 
7228  case 146:
7229 #line 2065 "ripper.y" /* yacc.c:1646 */
7230  { ifndef_ripper((yyval.val) = '<'); }
7231 #line 7227 "ripper.c" /* yacc.c:1646 */
7232  break;
7233 
7234  case 147:
7235 #line 2066 "ripper.y" /* yacc.c:1646 */
7236  { ifndef_ripper((yyval.val) = tLEQ); }
7237 #line 7233 "ripper.c" /* yacc.c:1646 */
7238  break;
7239 
7240  case 148:
7241 #line 2067 "ripper.y" /* yacc.c:1646 */
7242  { ifndef_ripper((yyval.val) = tNEQ); }
7243 #line 7239 "ripper.c" /* yacc.c:1646 */
7244  break;
7245 
7246  case 149:
7247 #line 2068 "ripper.y" /* yacc.c:1646 */
7248  { ifndef_ripper((yyval.val) = tLSHFT); }
7249 #line 7245 "ripper.c" /* yacc.c:1646 */
7250  break;
7251 
7252  case 150:
7253 #line 2069 "ripper.y" /* yacc.c:1646 */
7254  { ifndef_ripper((yyval.val) = tRSHFT); }
7255 #line 7251 "ripper.c" /* yacc.c:1646 */
7256  break;
7257 
7258  case 151:
7259 #line 2070 "ripper.y" /* yacc.c:1646 */
7260  { ifndef_ripper((yyval.val) = '+'); }
7261 #line 7257 "ripper.c" /* yacc.c:1646 */
7262  break;
7263 
7264  case 152:
7265 #line 2071 "ripper.y" /* yacc.c:1646 */
7266  { ifndef_ripper((yyval.val) = '-'); }
7267 #line 7263 "ripper.c" /* yacc.c:1646 */
7268  break;
7269 
7270  case 153:
7271 #line 2072 "ripper.y" /* yacc.c:1646 */
7272  { ifndef_ripper((yyval.val) = '*'); }
7273 #line 7269 "ripper.c" /* yacc.c:1646 */
7274  break;
7275 
7276  case 154:
7277 #line 2073 "ripper.y" /* yacc.c:1646 */
7278  { ifndef_ripper((yyval.val) = '*'); }
7279 #line 7275 "ripper.c" /* yacc.c:1646 */
7280  break;
7281 
7282  case 155:
7283 #line 2074 "ripper.y" /* yacc.c:1646 */
7284  { ifndef_ripper((yyval.val) = '/'); }
7285 #line 7281 "ripper.c" /* yacc.c:1646 */
7286  break;
7287 
7288  case 156:
7289 #line 2075 "ripper.y" /* yacc.c:1646 */
7290  { ifndef_ripper((yyval.val) = '%'); }
7291 #line 7287 "ripper.c" /* yacc.c:1646 */
7292  break;
7293 
7294  case 157:
7295 #line 2076 "ripper.y" /* yacc.c:1646 */
7296  { ifndef_ripper((yyval.val) = tPOW); }
7297 #line 7293 "ripper.c" /* yacc.c:1646 */
7298  break;
7299 
7300  case 158:
7301 #line 2077 "ripper.y" /* yacc.c:1646 */
7302  { ifndef_ripper((yyval.val) = tDSTAR); }
7303 #line 7299 "ripper.c" /* yacc.c:1646 */
7304  break;
7305 
7306  case 159:
7307 #line 2078 "ripper.y" /* yacc.c:1646 */
7308  { ifndef_ripper((yyval.val) = '!'); }
7309 #line 7305 "ripper.c" /* yacc.c:1646 */
7310  break;
7311 
7312  case 160:
7313 #line 2079 "ripper.y" /* yacc.c:1646 */
7314  { ifndef_ripper((yyval.val) = '~'); }
7315 #line 7311 "ripper.c" /* yacc.c:1646 */
7316  break;
7317 
7318  case 161:
7319 #line 2080 "ripper.y" /* yacc.c:1646 */
7320  { ifndef_ripper((yyval.val) = tUPLUS); }
7321 #line 7317 "ripper.c" /* yacc.c:1646 */
7322  break;
7323 
7324  case 162:
7325 #line 2081 "ripper.y" /* yacc.c:1646 */
7326  { ifndef_ripper((yyval.val) = tUMINUS); }
7327 #line 7323 "ripper.c" /* yacc.c:1646 */
7328  break;
7329 
7330  case 163:
7331 #line 2082 "ripper.y" /* yacc.c:1646 */
7332  { ifndef_ripper((yyval.val) = tAREF); }
7333 #line 7329 "ripper.c" /* yacc.c:1646 */
7334  break;
7335 
7336  case 164:
7337 #line 2083 "ripper.y" /* yacc.c:1646 */
7338  { ifndef_ripper((yyval.val) = tASET); }
7339 #line 7335 "ripper.c" /* yacc.c:1646 */
7340  break;
7341 
7342  case 165:
7343 #line 2084 "ripper.y" /* yacc.c:1646 */
7344  { ifndef_ripper((yyval.val) = '`'); }
7345 #line 7341 "ripper.c" /* yacc.c:1646 */
7346  break;
7347 
7348  case 207:
7349 #line 2102 "ripper.y" /* yacc.c:1646 */
7350  {
7351 #if 0
7352  (yyval.val) = node_assign(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
7353 #endif
7354  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(assign,v1,v2);(yyval.val)=v3;}
7355  }
7356 #line 7352 "ripper.c" /* yacc.c:1646 */
7357  break;
7358 
7359  case 208:
7360 #line 2109 "ripper.y" /* yacc.c:1646 */
7361  {
7362 #if 0
7363  (yyval.val) = new_op_assign(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7364 #endif
7365  {VALUE v1,v2,v3,v4;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=(yyvsp[0].val);v4=dispatch3(opassign,v1,v2,v3);(yyval.val)=v4;}
7366  }
7367 #line 7363 "ripper.c" /* yacc.c:1646 */
7368  break;
7369 
7370  case 209:
7371 #line 2116 "ripper.y" /* yacc.c:1646 */
7372  {
7373 #if 0
7374  value_expr((yyvsp[0].val));
7375  (yyval.val) = new_ary_op_assign(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-3]), &(yyloc));
7376 #endif
7377  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=(yyvsp[-5].val);v2=escape_Qundef((yyvsp[-3].val));v3=dispatch2(aref_field,v1,v2);v4=v3;v5=(yyvsp[-1].val);v6=(yyvsp[0].val);v7=dispatch3(opassign,v4,v5,v6);(yyval.val)=v7;}
7378  }
7379 #line 7375 "ripper.c" /* yacc.c:1646 */
7380  break;
7381 
7382  case 210:
7383 #line 2124 "ripper.y" /* yacc.c:1646 */
7384  {
7385 #if 0
7386  value_expr((yyvsp[0].val));
7387  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), (yyvsp[-3].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7388 #endif
7389  {VALUE v1,v2,v3,v4,v5,v6,v7,v8;v1=(yyvsp[-4].val);v2=(yyvsp[-3].val);v3=(yyvsp[-2].val);v4=dispatch3(field,v1,v2,v3);v5=v4;v6=(yyvsp[-1].val);v7=(yyvsp[0].val);v8=dispatch3(opassign,v5,v6,v7);(yyval.val)=v8;}
7390  }
7391 #line 7387 "ripper.c" /* yacc.c:1646 */
7392  break;
7393 
7394  case 211:
7395 #line 2132 "ripper.y" /* yacc.c:1646 */
7396  {
7397 #if 0
7398  value_expr((yyvsp[0].val));
7399  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), (yyvsp[-3].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7400 #endif
7401  {VALUE v1,v2,v3,v4,v5,v6,v7,v8;v1=(yyvsp[-4].val);v2=(yyvsp[-3].val);v3=(yyvsp[-2].val);v4=dispatch3(field,v1,v2,v3);v5=v4;v6=(yyvsp[-1].val);v7=(yyvsp[0].val);v8=dispatch3(opassign,v5,v6,v7);(yyval.val)=v8;}
7402  }
7403 #line 7399 "ripper.c" /* yacc.c:1646 */
7404  break;
7405 
7406  case 212:
7407 #line 2140 "ripper.y" /* yacc.c:1646 */
7408  {
7409 #if 0
7410  value_expr((yyvsp[0].val));
7411  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), ID2VAL(idCOLON2), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7412 #endif
7413  {VALUE v1,v2,v3,v4,v5,v6,v7,v8;v1=(yyvsp[-4].val);v2=ID2VAL(idCOLON2);v3=(yyvsp[-2].val);v4=dispatch3(field,v1,v2,v3);v5=v4;v6=(yyvsp[-1].val);v7=(yyvsp[0].val);v8=dispatch3(opassign,v5,v6,v7);(yyval.val)=v8;}
7414  }
7415 #line 7411 "ripper.c" /* yacc.c:1646 */
7416  break;
7417 
7418  case 213:
7419 #line 2148 "ripper.y" /* yacc.c:1646 */
7420  {
7421 #if 0
7422  YYLTYPE loc = code_loc_gen(&(yylsp[-4]), &(yylsp[-2]));
7423  (yyval.val) = new_const_op_assign(p, NEW_COLON2((yyvsp[-4].val), (yyvsp[-2].val), &loc), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7424 #endif
7425  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=(yyvsp[-4].val);v2=(yyvsp[-2].val);v3=dispatch2(const_path_field,v1,v2);v4=v3;v5=(yyvsp[-1].val);v6=(yyvsp[0].val);v7=dispatch3(opassign,v4,v5,v6);(yyval.val)=v7;}
7426  }
7427 #line 7423 "ripper.c" /* yacc.c:1646 */
7428  break;
7429 
7430  case 214:
7431 #line 2156 "ripper.y" /* yacc.c:1646 */
7432  {
7433 #if 0
7434  (yyval.val) = new_const_op_assign(p, NEW_COLON3((yyvsp[-2].val), &(yyloc)), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7435 #endif
7436  {VALUE v1,v2,v3,v4,v5,v6;v1=(yyvsp[-2].val);v2=dispatch1(top_const_field,v1);v3=v2;v4=(yyvsp[-1].val);v5=(yyvsp[0].val);v6=dispatch3(opassign,v3,v4,v5);(yyval.val)=v6;}
7437  }
7438 #line 7434 "ripper.c" /* yacc.c:1646 */
7439  break;
7440 
7441  case 215:
7442 #line 2163 "ripper.y" /* yacc.c:1646 */
7443  {
7444 #if 0
7445  rb_backref_error(p, (yyvsp[-2].val));
7446  (yyval.val) = NEW_BEGIN(0, &(yyloc));
7447 #endif
7448  {VALUE v1,v2,v3,v4,v5,v6;v1=var_field(p, (yyvsp[-2].val));v2=(yyvsp[-1].val);v3=(yyvsp[0].val);v4=dispatch3(opassign,v1,v2,v3);v5=v4;v6=dispatch1(assign_error,v5);(yyval.val)=v6;}ripper_error(p);
7449  }
7450 #line 7446 "ripper.c" /* yacc.c:1646 */
7451  break;
7452 
7453  case 216:
7454 #line 2171 "ripper.y" /* yacc.c:1646 */
7455  {
7456 #if 0
7457  value_expr((yyvsp[-2].val));
7458  value_expr((yyvsp[0].val));
7459  (yyval.val) = NEW_DOT2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
7460 #endif
7461  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
7462  }
7463 #line 7459 "ripper.c" /* yacc.c:1646 */
7464  break;
7465 
7466  case 217:
7467 #line 2180 "ripper.y" /* yacc.c:1646 */
7468  {
7469 #if 0
7470  value_expr((yyvsp[-2].val));
7471  value_expr((yyvsp[0].val));
7472  (yyval.val) = NEW_DOT3((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
7473 #endif
7474  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
7475  }
7476 #line 7472 "ripper.c" /* yacc.c:1646 */
7477  break;
7478 
7479  case 218:
7480 #line 2189 "ripper.y" /* yacc.c:1646 */
7481  {
7482 #if 0
7483  YYLTYPE loc;
7484  loc.beg_pos = (yylsp[0]).end_pos;
7485  loc.end_pos = (yylsp[0]).end_pos;
7486 
7487  value_expr((yyvsp[-1].val));
7488  (yyval.val) = NEW_DOT2((yyvsp[-1].val), new_nil(&loc), &(yyloc));
7489 #endif
7490  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
7491  }
7492 #line 7488 "ripper.c" /* yacc.c:1646 */
7493  break;
7494 
7495  case 219:
7496 #line 2201 "ripper.y" /* yacc.c:1646 */
7497  {
7498 #if 0
7499  YYLTYPE loc;
7500  loc.beg_pos = (yylsp[0]).end_pos;
7501  loc.end_pos = (yylsp[0]).end_pos;
7502 
7503  value_expr((yyvsp[-1].val));
7504  (yyval.val) = NEW_DOT3((yyvsp[-1].val), new_nil(&loc), &(yyloc));
7505 #endif
7506  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
7507  }
7508 #line 7504 "ripper.c" /* yacc.c:1646 */
7509  break;
7510 
7511  case 220:
7512 #line 2213 "ripper.y" /* yacc.c:1646 */
7513  {
7514 #if 0
7515  YYLTYPE loc;
7516  loc.beg_pos = (yylsp[-1]).beg_pos;
7517  loc.end_pos = (yylsp[-1]).beg_pos;
7518 
7519  value_expr((yyvsp[0].val));
7520  (yyval.val) = NEW_DOT2(new_nil(&loc), (yyvsp[0].val), &(yyloc));
7521 #endif
7522  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[0].val);v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
7523  }
7524 #line 7520 "ripper.c" /* yacc.c:1646 */
7525  break;
7526 
7527  case 221:
7528 #line 2225 "ripper.y" /* yacc.c:1646 */
7529  {
7530 #if 0
7531  YYLTYPE loc;
7532  loc.beg_pos = (yylsp[-1]).beg_pos;
7533  loc.end_pos = (yylsp[-1]).beg_pos;
7534 
7535  value_expr((yyvsp[0].val));
7536  (yyval.val) = NEW_DOT3(new_nil(&loc), (yyvsp[0].val), &(yyloc));
7537 #endif
7538  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[0].val);v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
7539  }
7540 #line 7536 "ripper.c" /* yacc.c:1646 */
7541  break;
7542 
7543  case 222:
7544 #line 2237 "ripper.y" /* yacc.c:1646 */
7545  {
7546  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '+', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7547  }
7548 #line 7544 "ripper.c" /* yacc.c:1646 */
7549  break;
7550 
7551  case 223:
7552 #line 2241 "ripper.y" /* yacc.c:1646 */
7553  {
7554  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '-', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7555  }
7556 #line 7552 "ripper.c" /* yacc.c:1646 */
7557  break;
7558 
7559  case 224:
7560 #line 2245 "ripper.y" /* yacc.c:1646 */
7561  {
7562  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '*', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7563  }
7564 #line 7560 "ripper.c" /* yacc.c:1646 */
7565  break;
7566 
7567  case 225:
7568 #line 2249 "ripper.y" /* yacc.c:1646 */
7569  {
7570  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '/', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7571  }
7572 #line 7568 "ripper.c" /* yacc.c:1646 */
7573  break;
7574 
7575  case 226:
7576 #line 2253 "ripper.y" /* yacc.c:1646 */
7577  {
7578  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '%', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7579  }
7580 #line 7576 "ripper.c" /* yacc.c:1646 */
7581  break;
7582 
7583  case 227:
7584 #line 2257 "ripper.y" /* yacc.c:1646 */
7585  {
7586  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idPow, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7587  }
7588 #line 7584 "ripper.c" /* yacc.c:1646 */
7589  break;
7590 
7591  case 228:
7592 #line 2261 "ripper.y" /* yacc.c:1646 */
7593  {
7594  (yyval.val) = call_uni_op(p, call_bin_op(p, (yyvsp[-2].val), idPow, (yyvsp[0].val), &(yylsp[-2]), &(yyloc)), idUMinus, &(yylsp[-3]), &(yyloc));
7595  }
7596 #line 7592 "ripper.c" /* yacc.c:1646 */
7597  break;
7598 
7599  case 229:
7600 #line 2265 "ripper.y" /* yacc.c:1646 */
7601  {
7602  (yyval.val) = call_uni_op(p, (yyvsp[0].val), idUPlus, &(yylsp[-1]), &(yyloc));
7603  }
7604 #line 7600 "ripper.c" /* yacc.c:1646 */
7605  break;
7606 
7607  case 230:
7608 #line 2269 "ripper.y" /* yacc.c:1646 */
7609  {
7610  (yyval.val) = call_uni_op(p, (yyvsp[0].val), idUMinus, &(yylsp[-1]), &(yyloc));
7611  }
7612 #line 7608 "ripper.c" /* yacc.c:1646 */
7613  break;
7614 
7615  case 231:
7616 #line 2273 "ripper.y" /* yacc.c:1646 */
7617  {
7618  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '|', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7619  }
7620 #line 7616 "ripper.c" /* yacc.c:1646 */
7621  break;
7622 
7623  case 232:
7624 #line 2277 "ripper.y" /* yacc.c:1646 */
7625  {
7626  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '^', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7627  }
7628 #line 7624 "ripper.c" /* yacc.c:1646 */
7629  break;
7630 
7631  case 233:
7632 #line 2281 "ripper.y" /* yacc.c:1646 */
7633  {
7634  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '&', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7635  }
7636 #line 7632 "ripper.c" /* yacc.c:1646 */
7637  break;
7638 
7639  case 234:
7640 #line 2285 "ripper.y" /* yacc.c:1646 */
7641  {
7642  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idCmp, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7643  }
7644 #line 7640 "ripper.c" /* yacc.c:1646 */
7645  break;
7646 
7647  case 236:
7648 #line 2290 "ripper.y" /* yacc.c:1646 */
7649  {
7650  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idEq, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7651  }
7652 #line 7648 "ripper.c" /* yacc.c:1646 */
7653  break;
7654 
7655  case 237:
7656 #line 2294 "ripper.y" /* yacc.c:1646 */
7657  {
7658  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idEqq, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7659  }
7660 #line 7656 "ripper.c" /* yacc.c:1646 */
7661  break;
7662 
7663  case 238:
7664 #line 2298 "ripper.y" /* yacc.c:1646 */
7665  {
7666  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idNeq, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7667  }
7668 #line 7664 "ripper.c" /* yacc.c:1646 */
7669  break;
7670 
7671  case 239:
7672 #line 2302 "ripper.y" /* yacc.c:1646 */
7673  {
7674  (yyval.val) = match_op(p, (yyvsp[-2].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7675  }
7676 #line 7672 "ripper.c" /* yacc.c:1646 */
7677  break;
7678 
7679  case 240:
7680 #line 2306 "ripper.y" /* yacc.c:1646 */
7681  {
7682  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idNeqTilde, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7683  }
7684 #line 7680 "ripper.c" /* yacc.c:1646 */
7685  break;
7686 
7687  case 241:
7688 #line 2310 "ripper.y" /* yacc.c:1646 */
7689  {
7690  (yyval.val) = call_uni_op(p, method_cond(p, (yyvsp[0].val), &(yylsp[0])), '!', &(yylsp[-1]), &(yyloc));
7691  }
7692 #line 7688 "ripper.c" /* yacc.c:1646 */
7693  break;
7694 
7695  case 242:
7696 #line 2314 "ripper.y" /* yacc.c:1646 */
7697  {
7698  (yyval.val) = call_uni_op(p, (yyvsp[0].val), '~', &(yylsp[-1]), &(yyloc));
7699  }
7700 #line 7696 "ripper.c" /* yacc.c:1646 */
7701  break;
7702 
7703  case 243:
7704 #line 2318 "ripper.y" /* yacc.c:1646 */
7705  {
7706  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idLTLT, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7707  }
7708 #line 7704 "ripper.c" /* yacc.c:1646 */
7709  break;
7710 
7711  case 244:
7712 #line 2322 "ripper.y" /* yacc.c:1646 */
7713  {
7714  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idGTGT, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7715  }
7716 #line 7712 "ripper.c" /* yacc.c:1646 */
7717  break;
7718 
7719  case 245:
7720 #line 2326 "ripper.y" /* yacc.c:1646 */
7721  {
7722  (yyval.val) = logop(p, idANDOP, (yyvsp[-2].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7723  }
7724 #line 7720 "ripper.c" /* yacc.c:1646 */
7725  break;
7726 
7727  case 246:
7728 #line 2330 "ripper.y" /* yacc.c:1646 */
7729  {
7730  (yyval.val) = logop(p, idOROP, (yyvsp[-2].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7731  }
7732 #line 7728 "ripper.c" /* yacc.c:1646 */
7733  break;
7734 
7735  case 247:
7736 #line 2333 "ripper.y" /* yacc.c:1646 */
7737  {p->in_defined = 1;}
7738 #line 7734 "ripper.c" /* yacc.c:1646 */
7739  break;
7740 
7741  case 248:
7742 #line 2334 "ripper.y" /* yacc.c:1646 */
7743  {
7744  p->in_defined = 0;
7745  (yyval.val) = new_defined(p, (yyvsp[0].val), &(yyloc));
7746  }
7747 #line 7743 "ripper.c" /* yacc.c:1646 */
7748  break;
7749 
7750  case 249:
7751 #line 2339 "ripper.y" /* yacc.c:1646 */
7752  {
7753 #if 0
7754  value_expr((yyvsp[-5].val));
7755  (yyval.val) = new_if(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[0].val), &(yyloc));
7756  fixpos((yyval.val), (yyvsp[-5].val));
7757 #endif
7758  {VALUE v1,v2,v3,v4;v1=(yyvsp[-5].val);v2=(yyvsp[-3].val);v3=(yyvsp[0].val);v4=dispatch3(ifop,v1,v2,v3);(yyval.val)=v4;}
7759  }
7760 #line 7756 "ripper.c" /* yacc.c:1646 */
7761  break;
7762 
7763  case 250:
7764 #line 2348 "ripper.y" /* yacc.c:1646 */
7765  {
7766  (yyval.val) = (yyvsp[0].val);
7767  }
7768 #line 7764 "ripper.c" /* yacc.c:1646 */
7769  break;
7770 
7771  case 251:
7772 #line 2353 "ripper.y" /* yacc.c:1646 */
7773  {(yyval.val) = '>';}
7774 #line 7770 "ripper.c" /* yacc.c:1646 */
7775  break;
7776 
7777  case 252:
7778 #line 2354 "ripper.y" /* yacc.c:1646 */
7779  {(yyval.val) = '<';}
7780 #line 7776 "ripper.c" /* yacc.c:1646 */
7781  break;
7782 
7783  case 253:
7784 #line 2355 "ripper.y" /* yacc.c:1646 */
7785  {(yyval.val) = idGE;}
7786 #line 7782 "ripper.c" /* yacc.c:1646 */
7787  break;
7788 
7789  case 254:
7790 #line 2356 "ripper.y" /* yacc.c:1646 */
7791  {(yyval.val) = idLE;}
7792 #line 7788 "ripper.c" /* yacc.c:1646 */
7793  break;
7794 
7795  case 255:
7796 #line 2360 "ripper.y" /* yacc.c:1646 */
7797  {
7798  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7799  }
7800 #line 7796 "ripper.c" /* yacc.c:1646 */
7801  break;
7802 
7803  case 256:
7804 #line 2364 "ripper.y" /* yacc.c:1646 */
7805  {
7806  rb_warning1("comparison '%s' after comparison", WARN_ID((yyvsp[-1].val)));
7807  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7808  }
7809 #line 7805 "ripper.c" /* yacc.c:1646 */
7810  break;
7811 
7812  case 257:
7813 #line 2371 "ripper.y" /* yacc.c:1646 */
7814  {
7815  value_expr((yyvsp[0].val));
7816  (yyval.val) = (yyvsp[0].val);
7817  }
7818 #line 7814 "ripper.c" /* yacc.c:1646 */
7819  break;
7820 
7821  case 259:
7822 #line 2379 "ripper.y" /* yacc.c:1646 */
7823  {
7824  (yyval.val) = (yyvsp[-1].val);
7825  }
7826 #line 7822 "ripper.c" /* yacc.c:1646 */
7827  break;
7828 
7829  case 260:
7830 #line 2383 "ripper.y" /* yacc.c:1646 */
7831  {
7832 #if 0
7833  (yyval.val) = (yyvsp[-1].val) ? arg_append(p, (yyvsp[-3].val), new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].val);
7834 #endif
7835  {VALUE v1,v2,v3,v4,v5;v1=(yyvsp[-1].val);v2=dispatch1(bare_assoc_hash,v1);v3=(yyvsp[-3].val);v4=v2;v5=dispatch2(args_add,v3,v4);(yyval.val)=v5;}
7836  }
7837 #line 7833 "ripper.c" /* yacc.c:1646 */
7838  break;
7839 
7840  case 261:
7841 #line 2390 "ripper.y" /* yacc.c:1646 */
7842  {
7843 #if 0
7844  (yyval.val) = (yyvsp[-1].val) ? NEW_LIST(new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yyloc)) : 0;
7845 #endif
7846  {VALUE v1,v2,v3,v4,v5,v6;v1=dispatch0(args_new);v2=(yyvsp[-1].val);v3=dispatch1(bare_assoc_hash,v2);v4=v1;v5=v3;v6=dispatch2(args_add,v4,v5);(yyval.val)=v6;}
7847  }
7848 #line 7844 "ripper.c" /* yacc.c:1646 */
7849  break;
7850 
7851  case 262:
7852 #line 2399 "ripper.y" /* yacc.c:1646 */
7853  {
7854  value_expr((yyvsp[0].val));
7855  (yyval.val) = (yyvsp[0].val);
7856  }
7857 #line 7853 "ripper.c" /* yacc.c:1646 */
7858  break;
7859 
7860  case 263:
7861 #line 2404 "ripper.y" /* yacc.c:1646 */
7862  {
7863 #if 0
7864  YYLTYPE loc = code_loc_gen(&(yylsp[-1]), &(yylsp[0]));
7865  value_expr((yyvsp[-2].val));
7866  (yyval.val) = NEW_RESCUE((yyvsp[-2].val), NEW_RESBODY(0, remove_begin((yyvsp[0].val)), 0, &loc), 0, &(yyloc));
7867 #endif
7868  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(rescue_mod,v1,v2);(yyval.val)=v3;}
7869  }
7870 #line 7866 "ripper.c" /* yacc.c:1646 */
7871  break;
7872 
7873  case 264:
7874 #line 2415 "ripper.y" /* yacc.c:1646 */
7875  {
7876 #if 0
7877  (yyval.val) = (yyvsp[-1].val);
7878 #endif
7879  {VALUE v1,v2;v1=escape_Qundef((yyvsp[-1].val));v2=dispatch1(arg_paren,v1);(yyval.val)=v2;}
7880  }
7881 #line 7877 "ripper.c" /* yacc.c:1646 */
7882  break;
7883 
7884  case 265:
7885 #line 2422 "ripper.y" /* yacc.c:1646 */
7886  {
7887  if (!local_id(p, idFWD_REST) ||
7888 #if idFWD_KWREST
7889  !local_id(p, idFWD_KWREST) ||
7890 #endif
7891  !local_id(p, idFWD_BLOCK)) {
7892  compile_error(p, "unexpected ...");
7893  (yyval.val) = Qnone;
7894  }
7895  else {
7896 #if 0
7897  NODE *splat = NEW_SPLAT(NEW_LVAR(idFWD_REST, &(yylsp[-1])), &(yylsp[-1]));
7898 #if idFWD_KWREST
7899  NODE *kwrest = list_append(p, NEW_LIST(0, &(yylsp[-1])), NEW_LVAR(idFWD_KWREST, &(yylsp[-1])));
7900 #endif
7901  NODE *block = NEW_BLOCK_PASS(NEW_LVAR(idFWD_BLOCK, &(yylsp[-1])), &(yylsp[-1]));
7902 #if idFWD_KWREST
7903  (yyval.val) = arg_append(p, splat, new_hash(p, kwrest, &(yylsp[-1])), &(yylsp[-1]));
7904 #else
7905  (yyval.val) = splat;
7906 #endif
7907  (yyval.val) = arg_blk_pass((yyval.val), block);
7908 #endif
7909  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(arg_paren,v1);(yyval.val)=v2;}
7910  }
7911  }
7912 #line 7908 "ripper.c" /* yacc.c:1646 */
7913  break;
7914 
7915  case 270:
7916 #line 2457 "ripper.y" /* yacc.c:1646 */
7917  {
7918  (yyval.val) = (yyvsp[-1].val);
7919  }
7920 #line 7916 "ripper.c" /* yacc.c:1646 */
7921  break;
7922 
7923  case 271:
7924 #line 2461 "ripper.y" /* yacc.c:1646 */
7925  {
7926 #if 0
7927  (yyval.val) = (yyvsp[-1].val) ? arg_append(p, (yyvsp[-3].val), new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].val);
7928 #endif
7929  {VALUE v1,v2,v3,v4,v5;v1=(yyvsp[-1].val);v2=dispatch1(bare_assoc_hash,v1);v3=(yyvsp[-3].val);v4=v2;v5=dispatch2(args_add,v3,v4);(yyval.val)=v5;}
7930  }
7931 #line 7927 "ripper.c" /* yacc.c:1646 */
7932  break;
7933 
7934  case 272:
7935 #line 2468 "ripper.y" /* yacc.c:1646 */
7936  {
7937 #if 0
7938  (yyval.val) = (yyvsp[-1].val) ? NEW_LIST(new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yylsp[-1])) : 0;
7939 #endif
7940  {VALUE v1,v2,v3,v4,v5,v6;v1=dispatch0(args_new);v2=(yyvsp[-1].val);v3=dispatch1(bare_assoc_hash,v2);v4=v1;v5=v3;v6=dispatch2(args_add,v4,v5);(yyval.val)=v6;}
7941  }
7942 #line 7938 "ripper.c" /* yacc.c:1646 */
7943  break;
7944 
7945  case 273:
7946 #line 2477 "ripper.y" /* yacc.c:1646 */
7947  {
7948 #if 0
7949  value_expr((yyvsp[0].val));
7950  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
7951 #endif
7952  {VALUE v1,v2,v3,v4;v1=dispatch0(args_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(args_add,v2,v3);(yyval.val)=v4;}
7953  }
7954 #line 7950 "ripper.c" /* yacc.c:1646 */
7955  break;
7956 
7957  case 274:
7958 #line 2485 "ripper.y" /* yacc.c:1646 */
7959  {
7960 #if 0
7961  (yyval.val) = arg_blk_pass((yyvsp[-1].val), (yyvsp[0].val));
7962 #endif
7963  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(args_add_block,v1,v2);(yyval.val)=v3;}
7964  }
7965 #line 7961 "ripper.c" /* yacc.c:1646 */
7966  break;
7967 
7968  case 275:
7969 #line 2492 "ripper.y" /* yacc.c:1646 */
7970  {
7971 #if 0
7972  (yyval.val) = (yyvsp[-1].val) ? NEW_LIST(new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yylsp[-1])) : 0;
7973  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[0].val));
7974 #endif
7975  {VALUE v1,v2,v3,v4,v5,v6,v7,v8,v9;v1=dispatch0(args_new);v2=(yyvsp[-1].val);v3=dispatch1(bare_assoc_hash,v2);v4=v1;v5=v3;v6=dispatch2(args_add,v4,v5);v7=v6;v8=(yyvsp[0].val);v9=dispatch2(args_add_block,v7,v8);(yyval.val)=v9;}
7976  }
7977 #line 7973 "ripper.c" /* yacc.c:1646 */
7978  break;
7979 
7980  case 276:
7981 #line 2500 "ripper.y" /* yacc.c:1646 */
7982  {
7983 #if 0
7984  (yyval.val) = (yyvsp[-1].val) ? arg_append(p, (yyvsp[-3].val), new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].val);
7985  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[0].val));
7986 #endif
7987  {VALUE v1,v2,v3,v4,v5,v6,v7,v8;v1=(yyvsp[-1].val);v2=dispatch1(bare_assoc_hash,v1);v3=(yyvsp[-3].val);v4=v2;v5=dispatch2(args_add,v3,v4);v6=v5;v7=(yyvsp[0].val);v8=dispatch2(args_add_block,v6,v7);(yyval.val)=v8;}
7988  }
7989 #line 7985 "ripper.c" /* yacc.c:1646 */
7990  break;
7991 
7992  case 277:
7993 #line 2508 "ripper.y" /* yacc.c:1646 */
7994  {{VALUE v1,v2,v3,v4;v1=dispatch0(args_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(args_add_block,v2,v3);(yyval.val)=v4;}}
7995 #line 7991 "ripper.c" /* yacc.c:1646 */
7996  break;
7997 
7998  case 278:
7999 #line 2511 "ripper.y" /* yacc.c:1646 */
8000  {
8001  /* If call_args starts with a open paren '(' or '[',
8002  * look-ahead reading of the letters calls CMDARG_PUSH(0),
8003  * but the push must be done after CMDARG_PUSH(1).
8004  * So this code makes them consistent by first cancelling
8005  * the premature CMDARG_PUSH(0), doing CMDARG_PUSH(1),
8006  * and finally redoing CMDARG_PUSH(0).
8007  */
8008  int lookahead = 0;
8009  switch (yychar) {
8010  case '(': case tLPAREN: case tLPAREN_ARG: case '[': case tLBRACK:
8011  lookahead = 1;
8012  }
8013  if (lookahead) CMDARG_POP();
8014  CMDARG_PUSH(1);
8015  if (lookahead) CMDARG_PUSH(0);
8016  }
8017 #line 8013 "ripper.c" /* yacc.c:1646 */
8018  break;
8019 
8020  case 279:
8021 #line 2529 "ripper.y" /* yacc.c:1646 */
8022  {
8023  /* call_args can be followed by tLBRACE_ARG (that does CMDARG_PUSH(0) in the lexer)
8024  * but the push must be done after CMDARG_POP() in the parser.
8025  * So this code does CMDARG_POP() to pop 0 pushed by tLBRACE_ARG,
8026  * CMDARG_POP() to pop 1 pushed by command_args,
8027  * and CMDARG_PUSH(0) to restore back the flag set by tLBRACE_ARG.
8028  */
8029  int lookahead = 0;
8030  switch (yychar) {
8031  case tLBRACE_ARG:
8032  lookahead = 1;
8033  }
8034  if (lookahead) CMDARG_POP();
8035  CMDARG_POP();
8036  if (lookahead) CMDARG_PUSH(0);
8037  (yyval.val) = (yyvsp[0].val);
8038  }
8039 #line 8035 "ripper.c" /* yacc.c:1646 */
8040  break;
8041 
8042  case 280:
8043 #line 2549 "ripper.y" /* yacc.c:1646 */
8044  {
8045 #if 0
8046  (yyval.val) = NEW_BLOCK_PASS((yyvsp[0].val), &(yyloc));
8047 #endif
8048  (yyval.val)=(yyvsp[0].val);
8049  }
8050 #line 8046 "ripper.c" /* yacc.c:1646 */
8051  break;
8052 
8053  case 281:
8054 #line 2558 "ripper.y" /* yacc.c:1646 */
8055  {
8056  (yyval.val) = (yyvsp[0].val);
8057  }
8058 #line 8054 "ripper.c" /* yacc.c:1646 */
8059  break;
8060 
8061  case 282:
8062 #line 2562 "ripper.y" /* yacc.c:1646 */
8063  {
8064  (yyval.val) = 0;
8065  }
8066 #line 8062 "ripper.c" /* yacc.c:1646 */
8067  break;
8068 
8069  case 283:
8070 #line 2568 "ripper.y" /* yacc.c:1646 */
8071  {
8072 #if 0
8073  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
8074 #endif
8075  {VALUE v1,v2,v3,v4;v1=dispatch0(args_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(args_add,v2,v3);(yyval.val)=v4;}
8076  }
8077 #line 8073 "ripper.c" /* yacc.c:1646 */
8078  break;
8079 
8080  case 284:
8081 #line 2575 "ripper.y" /* yacc.c:1646 */
8082  {
8083 #if 0
8084  (yyval.val) = NEW_SPLAT((yyvsp[0].val), &(yyloc));
8085 #endif
8086  {VALUE v1,v2,v3,v4;v1=dispatch0(args_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(args_add_star,v2,v3);(yyval.val)=v4;}
8087  }
8088 #line 8084 "ripper.c" /* yacc.c:1646 */
8089  break;
8090 
8091  case 285:
8092 #line 2582 "ripper.y" /* yacc.c:1646 */
8093  {
8094 #if 0
8095  (yyval.val) = last_arg_append(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
8096 #endif
8097  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(args_add,v1,v2);(yyval.val)=v3;}
8098  }
8099 #line 8095 "ripper.c" /* yacc.c:1646 */
8100  break;
8101 
8102  case 286:
8103 #line 2589 "ripper.y" /* yacc.c:1646 */
8104  {
8105 #if 0
8106  (yyval.val) = rest_arg_append(p, (yyvsp[-3].val), (yyvsp[0].val), &(yyloc));
8107 #endif
8108  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=(yyvsp[0].val);v3=dispatch2(args_add_star,v1,v2);(yyval.val)=v3;}
8109  }
8110 #line 8106 "ripper.c" /* yacc.c:1646 */
8111  break;
8112 
8113  case 289:
8114 #line 2602 "ripper.y" /* yacc.c:1646 */
8115  {
8116 #if 0
8117  (yyval.val) = last_arg_append(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
8118 #endif
8119  {VALUE v1,v2,v3,v4,v5;v1=(yyvsp[-2].val);v2=dispatch1(mrhs_new_from_args,v1);v3=v2;v4=(yyvsp[0].val);v5=dispatch2(mrhs_add,v3,v4);(yyval.val)=v5;}
8120  }
8121 #line 8117 "ripper.c" /* yacc.c:1646 */
8122  break;
8123 
8124  case 290:
8125 #line 2609 "ripper.y" /* yacc.c:1646 */
8126  {
8127 #if 0
8128  (yyval.val) = rest_arg_append(p, (yyvsp[-3].val), (yyvsp[0].val), &(yyloc));
8129 #endif
8130  {VALUE v1,v2,v3,v4,v5;v1=(yyvsp[-3].val);v2=dispatch1(mrhs_new_from_args,v1);v3=v2;v4=(yyvsp[0].val);v5=dispatch2(mrhs_add_star,v3,v4);(yyval.val)=v5;}
8131  }
8132 #line 8128 "ripper.c" /* yacc.c:1646 */
8133  break;
8134 
8135  case 291:
8136 #line 2616 "ripper.y" /* yacc.c:1646 */
8137  {
8138 #if 0
8139  (yyval.val) = NEW_SPLAT((yyvsp[0].val), &(yyloc));
8140 #endif
8141  {VALUE v1,v2,v3,v4;v1=dispatch0(mrhs_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(mrhs_add_star,v2,v3);(yyval.val)=v4;}
8142  }
8143 #line 8139 "ripper.c" /* yacc.c:1646 */
8144  break;
8145 
8146  case 302:
8147 #line 2635 "ripper.y" /* yacc.c:1646 */
8148  {
8149 #if 0
8150  (yyval.val) = NEW_FCALL((yyvsp[0].val), 0, &(yyloc));
8151 #endif
8152  {VALUE v1,v2,v3,v4,v5,v6;v1=(yyvsp[0].val);v2=dispatch1(fcall,v1);v3=dispatch0(args_new);v4=v2;v5=v3;v6=dispatch2(method_add_arg,v4,v5);(yyval.val)=v6;}
8153  }
8154 #line 8150 "ripper.c" /* yacc.c:1646 */
8155  break;
8156 
8157  case 303:
8158 #line 2642 "ripper.y" /* yacc.c:1646 */
8159  {
8160  CMDARG_PUSH(0);
8161  }
8162 #line 8158 "ripper.c" /* yacc.c:1646 */
8163  break;
8164 
8165  case 304:
8166 #line 2647 "ripper.y" /* yacc.c:1646 */
8167  {
8168  CMDARG_POP();
8169 #if 0
8170  set_line_body((yyvsp[-1].val), (yylsp[-3]).end_pos.lineno);
8171  (yyval.val) = NEW_BEGIN((yyvsp[-1].val), &(yyloc));
8172  nd_set_line((yyval.val), (yylsp[-3]).end_pos.lineno);
8173 #endif
8174  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(begin,v1);(yyval.val)=v2;}
8175  }
8176 #line 8172 "ripper.c" /* yacc.c:1646 */
8177  break;
8178 
8179  case 305:
8180 #line 2656 "ripper.y" /* yacc.c:1646 */
8181  {SET_LEX_STATE(EXPR_ENDARG);}
8182 #line 8178 "ripper.c" /* yacc.c:1646 */
8183  break;
8184 
8185  case 306:
8186 #line 2657 "ripper.y" /* yacc.c:1646 */
8187  {
8188 #if 0
8189  (yyval.val) = NEW_BEGIN(0, &(yyloc));
8190 #endif
8191  {VALUE v1,v2;v1=0;v2=dispatch1(paren,v1);(yyval.val)=v2;}
8192  }
8193 #line 8189 "ripper.c" /* yacc.c:1646 */
8194  break;
8195 
8196  case 307:
8197 #line 2663 "ripper.y" /* yacc.c:1646 */
8198  {SET_LEX_STATE(EXPR_ENDARG);}
8199 #line 8195 "ripper.c" /* yacc.c:1646 */
8200  break;
8201 
8202  case 308:
8203 #line 2664 "ripper.y" /* yacc.c:1646 */
8204  {
8205 #if 0
8206  if (nd_type((yyvsp[-2].val)) == NODE_SELF) (yyvsp[-2].val)->nd_state = 0;
8207  (yyval.val) = (yyvsp[-2].val);
8208 #endif
8209  {VALUE v1,v2;v1=(yyvsp[-2].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
8210  }
8211 #line 8207 "ripper.c" /* yacc.c:1646 */
8212  break;
8213 
8214  case 309:
8215 #line 2672 "ripper.y" /* yacc.c:1646 */
8216  {
8217 #if 0
8218  if (nd_type((yyvsp[-1].val)) == NODE_SELF) (yyvsp[-1].val)->nd_state = 0;
8219  (yyval.val) = (yyvsp[-1].val);
8220 #endif
8221  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
8222  }
8223 #line 8219 "ripper.c" /* yacc.c:1646 */
8224  break;
8225 
8226  case 310:
8227 #line 2680 "ripper.y" /* yacc.c:1646 */
8228  {
8229 #if 0
8230  (yyval.val) = NEW_COLON2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
8231 #endif
8232  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(const_path_ref,v1,v2);(yyval.val)=v3;}
8233  }
8234 #line 8230 "ripper.c" /* yacc.c:1646 */
8235  break;
8236 
8237  case 311:
8238 #line 2687 "ripper.y" /* yacc.c:1646 */
8239  {
8240 #if 0
8241  (yyval.val) = NEW_COLON3((yyvsp[0].val), &(yyloc));
8242 #endif
8243  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(top_const_ref,v1);(yyval.val)=v2;}
8244  }
8245 #line 8241 "ripper.c" /* yacc.c:1646 */
8246  break;
8247 
8248  case 312:
8249 #line 2694 "ripper.y" /* yacc.c:1646 */
8250  {
8251 #if 0
8252  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
8253 #endif
8254  {VALUE v1,v2;v1=escape_Qundef((yyvsp[-1].val));v2=dispatch1(array,v1);(yyval.val)=v2;}
8255  }
8256 #line 8252 "ripper.c" /* yacc.c:1646 */
8257  break;
8258 
8259  case 313:
8260 #line 2701 "ripper.y" /* yacc.c:1646 */
8261  {
8262 #if 0
8263  (yyval.val) = new_hash(p, (yyvsp[-1].val), &(yyloc));
8264  (yyval.val)->nd_brace = TRUE;
8265 #endif
8266  {VALUE v1,v2;v1=escape_Qundef((yyvsp[-1].val));v2=dispatch1(hash,v1);(yyval.val)=v2;}
8267  }
8268 #line 8264 "ripper.c" /* yacc.c:1646 */
8269  break;
8270 
8271  case 314:
8272 #line 2709 "ripper.y" /* yacc.c:1646 */
8273  {
8274 #if 0
8275  (yyval.val) = NEW_RETURN(0, &(yyloc));
8276 #endif
8277  {VALUE v1;v1=dispatch0(return0);(yyval.val)=v1;}
8278  }
8279 #line 8275 "ripper.c" /* yacc.c:1646 */
8280  break;
8281 
8282  case 315:
8283 #line 2716 "ripper.y" /* yacc.c:1646 */
8284  {
8285 #if 0
8286  (yyval.val) = new_yield(p, (yyvsp[-1].val), &(yyloc));
8287 #endif
8288  {VALUE v1,v2,v3,v4;v1=(yyvsp[-1].val);v2=dispatch1(paren,v1);v3=v2;v4=dispatch1(yield,v3);(yyval.val)=v4;}
8289  }
8290 #line 8286 "ripper.c" /* yacc.c:1646 */
8291  break;
8292 
8293  case 316:
8294 #line 2723 "ripper.y" /* yacc.c:1646 */
8295  {
8296 #if 0
8297  (yyval.val) = NEW_YIELD(0, &(yyloc));
8298 #endif
8299  {VALUE v1,v2,v3,v4,v5;v1=dispatch0(args_new);v2=v1;v3=dispatch1(paren,v2);v4=v3;v5=dispatch1(yield,v4);(yyval.val)=v5;}
8300  }
8301 #line 8297 "ripper.c" /* yacc.c:1646 */
8302  break;
8303 
8304  case 317:
8305 #line 2730 "ripper.y" /* yacc.c:1646 */
8306  {
8307 #if 0
8308  (yyval.val) = NEW_YIELD(0, &(yyloc));
8309 #endif
8310  {VALUE v1;v1=dispatch0(yield0);(yyval.val)=v1;}
8311  }
8312 #line 8308 "ripper.c" /* yacc.c:1646 */
8313  break;
8314 
8315  case 318:
8316 #line 2736 "ripper.y" /* yacc.c:1646 */
8317  {p->in_defined = 1;}
8318 #line 8314 "ripper.c" /* yacc.c:1646 */
8319  break;
8320 
8321  case 319:
8322 #line 2737 "ripper.y" /* yacc.c:1646 */
8323  {
8324  p->in_defined = 0;
8325  (yyval.val) = new_defined(p, (yyvsp[-1].val), &(yyloc));
8326  }
8327 #line 8323 "ripper.c" /* yacc.c:1646 */
8328  break;
8329 
8330  case 320:
8331 #line 2742 "ripper.y" /* yacc.c:1646 */
8332  {
8333  (yyval.val) = call_uni_op(p, method_cond(p, (yyvsp[-1].val), &(yylsp[-1])), METHOD_NOT, &(yylsp[-3]), &(yyloc));
8334  }
8335 #line 8331 "ripper.c" /* yacc.c:1646 */
8336  break;
8337 
8338  case 321:
8339 #line 2746 "ripper.y" /* yacc.c:1646 */
8340  {
8341  (yyval.val) = call_uni_op(p, method_cond(p, new_nil(&(yylsp[-1])), &(yylsp[-1])), METHOD_NOT, &(yylsp[-2]), &(yyloc));
8342  }
8343 #line 8339 "ripper.c" /* yacc.c:1646 */
8344  break;
8345 
8346  case 322:
8347 #line 2750 "ripper.y" /* yacc.c:1646 */
8348  {
8349 #if 0
8350  (yyval.val) = method_add_block(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
8351 #endif
8352  {VALUE v1,v2,v3,v4,v5,v6,v7,v8,v9;v1=(yyvsp[-1].val);v2=dispatch1(fcall,v1);v3=dispatch0(args_new);v4=v2;v5=v3;v6=dispatch2(method_add_arg,v4,v5);v7=v6;v8=(yyvsp[0].val);v9=dispatch2(method_add_block,v7,v8);(yyval.val)=v9;}
8353  }
8354 #line 8350 "ripper.c" /* yacc.c:1646 */
8355  break;
8356 
8357  case 324:
8358 #line 2758 "ripper.y" /* yacc.c:1646 */
8359  {
8360 #if 0
8361  block_dup_check(p, (yyvsp[-1].val)->nd_args, (yyvsp[0].val));
8362  (yyval.val) = method_add_block(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
8363 #endif
8364  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(method_add_block,v1,v2);(yyval.val)=v3;}
8365  }
8366 #line 8362 "ripper.c" /* yacc.c:1646 */
8367  break;
8368 
8369  case 325:
8370 #line 2766 "ripper.y" /* yacc.c:1646 */
8371  {
8372  token_info_push(p, "->", &(yylsp[0]));
8373  }
8374 #line 8370 "ripper.c" /* yacc.c:1646 */
8375  break;
8376 
8377  case 326:
8378 #line 2770 "ripper.y" /* yacc.c:1646 */
8379  {
8380  (yyval.val) = (yyvsp[0].val);
8381 #if 0
8382  nd_set_first_loc((yyval.val), (yylsp[-2]).beg_pos);
8383 #endif
8384  }
8385 #line 8381 "ripper.c" /* yacc.c:1646 */
8386  break;
8387 
8388  case 327:
8389 #line 2780 "ripper.y" /* yacc.c:1646 */
8390  {
8391 #if 0
8392  (yyval.val) = new_if(p, (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), &(yyloc));
8393  fixpos((yyval.val), (yyvsp[-4].val));
8394 #endif
8395  {VALUE v1,v2,v3,v4;v1=(yyvsp[-4].val);v2=(yyvsp[-2].val);v3=escape_Qundef((yyvsp[-1].val));v4=dispatch3(if,v1,v2,v3);(yyval.val)=v4;}
8396  }
8397 #line 8393 "ripper.c" /* yacc.c:1646 */
8398  break;
8399 
8400  case 328:
8401 #line 2791 "ripper.y" /* yacc.c:1646 */
8402  {
8403 #if 0
8404  (yyval.val) = new_unless(p, (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), &(yyloc));
8405  fixpos((yyval.val), (yyvsp[-4].val));
8406 #endif
8407  {VALUE v1,v2,v3,v4;v1=(yyvsp[-4].val);v2=(yyvsp[-2].val);v3=escape_Qundef((yyvsp[-1].val));v4=dispatch3(unless,v1,v2,v3);(yyval.val)=v4;}
8408  }
8409 #line 8405 "ripper.c" /* yacc.c:1646 */
8410  break;
8411 
8412  case 329:
8413 #line 2801 "ripper.y" /* yacc.c:1646 */
8414  {
8415 #if 0
8416  (yyval.val) = NEW_WHILE(cond(p, (yyvsp[-2].val), &(yylsp[-2])), (yyvsp[-1].val), 1, &(yyloc));
8417  fixpos((yyval.val), (yyvsp[-2].val));
8418 #endif
8419  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(while,v1,v2);(yyval.val)=v3;}
8420  }
8421 #line 8417 "ripper.c" /* yacc.c:1646 */
8422  break;
8423 
8424  case 330:
8425 #line 2811 "ripper.y" /* yacc.c:1646 */
8426  {
8427 #if 0
8428  (yyval.val) = NEW_UNTIL(cond(p, (yyvsp[-2].val), &(yylsp[-2])), (yyvsp[-1].val), 1, &(yyloc));
8429  fixpos((yyval.val), (yyvsp[-2].val));
8430 #endif
8431  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(until,v1,v2);(yyval.val)=v3;}
8432  }
8433 #line 8429 "ripper.c" /* yacc.c:1646 */
8434  break;
8435 
8436  case 331:
8437 #line 2819 "ripper.y" /* yacc.c:1646 */
8438  {
8439  (yyval.val) = p->case_labels;
8440  p->case_labels = Qnil;
8441  }
8442 #line 8438 "ripper.c" /* yacc.c:1646 */
8443  break;
8444 
8445  case 332:
8446 #line 2825 "ripper.y" /* yacc.c:1646 */
8447  {
8449  p->case_labels = (yyvsp[-2].val);
8450 #if 0
8451  (yyval.val) = NEW_CASE((yyvsp[-4].val), (yyvsp[-1].val), &(yyloc));
8452  fixpos((yyval.val), (yyvsp[-4].val));
8453 #endif
8454  {VALUE v1,v2,v3;v1=(yyvsp[-4].val);v2=(yyvsp[-1].val);v3=dispatch2(case,v1,v2);(yyval.val)=v3;}
8455  }
8456 #line 8452 "ripper.c" /* yacc.c:1646 */
8457  break;
8458 
8459  case 333:
8460 #line 2835 "ripper.y" /* yacc.c:1646 */
8461  {
8462  (yyval.val) = p->case_labels;
8463  p->case_labels = 0;
8464  }
8465 #line 8461 "ripper.c" /* yacc.c:1646 */
8466  break;
8467 
8468  case 334:
8469 #line 2841 "ripper.y" /* yacc.c:1646 */
8470  {
8472  p->case_labels = (yyvsp[-2].val);
8473 #if 0
8474  (yyval.val) = NEW_CASE2((yyvsp[-1].val), &(yyloc));
8475 #endif
8476  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[-1].val);v3=dispatch2(case,v1,v2);(yyval.val)=v3;}
8477  }
8478 #line 8474 "ripper.c" /* yacc.c:1646 */
8479  break;
8480 
8481  case 335:
8482 #line 2852 "ripper.y" /* yacc.c:1646 */
8483  {
8484 #if 0
8485  (yyval.val) = new_case3(p, (yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
8486 #endif
8487  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=(yyvsp[-1].val);v3=dispatch2(case,v1,v2);(yyval.val)=v3;}
8488  }
8489 #line 8485 "ripper.c" /* yacc.c:1646 */
8490  break;
8491 
8492  case 336:
8493 #line 2861 "ripper.y" /* yacc.c:1646 */
8494  {
8495 #if 0
8496  /*
8497  * for a, b, c in e
8498  * #=>
8499  * e.each{|*x| a, b, c = x}
8500  *
8501  * for a in e
8502  * #=>
8503  * e.each{|x| a, = x}
8504  */
8505  ID id = internal_id(p);
8506  NODE *m = NEW_ARGS_AUX(0, 0, &NULL_LOC);
8507  NODE *args, *scope, *internal_var = NEW_DVAR(id, &(yylsp[-4]));
8508  ID *tbl = ALLOC_N(ID, 3);
8509  tbl[0] = 1 /* length of local var table */; tbl[1] = id /* internal id */;
8510  rb_ast_add_local_table(p->ast, tbl);
8511 
8512  switch (nd_type((yyvsp[-4].val))) {
8513  case NODE_LASGN:
8514  case NODE_DASGN:
8515  case NODE_DASGN_CURR: /* e.each {|internal_var| a = internal_var; ... } */
8516  (yyvsp[-4].val)->nd_value = internal_var;
8517  id = 0;
8518  m->nd_plen = 1;
8519  m->nd_next = (yyvsp[-4].val);
8520  break;
8521  case NODE_MASGN: /* e.each {|*internal_var| a, b, c = (internal_var.length == 1 && Array === (tmp = internal_var[0]) ? tmp : internal_var); ... } */
8522  m->nd_next = node_assign(p, (yyvsp[-4].val), NEW_FOR_MASGN(internal_var, &(yylsp[-4])), &(yylsp[-4]));
8523  break;
8524  default: /* e.each {|*internal_var| @a, B, c[1], d.attr = internal_val; ... } */
8525  m->nd_next = node_assign(p, NEW_MASGN(NEW_LIST((yyvsp[-4].val), &(yylsp[-4])), 0, &(yylsp[-4])), internal_var, &(yylsp[-4]));
8526  }
8527  /* {|*internal_id| <m> = internal_id; ... } */
8528  args = new_args(p, m, 0, id, 0, new_args_tail(p, 0, 0, 0, &(yylsp[-4])), &(yylsp[-4]));
8529  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[-1].val), args, &(yyloc));
8530  (yyval.val) = NEW_FOR((yyvsp[-2].val), scope, &(yyloc));
8531  fixpos((yyval.val), (yyvsp[-4].val));
8532 #endif
8533  {VALUE v1,v2,v3,v4;v1=(yyvsp[-4].val);v2=(yyvsp[-2].val);v3=(yyvsp[-1].val);v4=dispatch3(for,v1,v2,v3);(yyval.val)=v4;}
8534  }
8535 #line 8531 "ripper.c" /* yacc.c:1646 */
8536  break;
8537 
8538  case 337:
8539 #line 2903 "ripper.y" /* yacc.c:1646 */
8540  {
8541  if (p->in_def) {
8542  YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[-1]));
8543  yyerror1(&loc, "class definition in method body");
8544  }
8545  (yyvsp[-2].num) = p->in_class;
8546  p->in_class = 1;
8547  local_push(p, 0);
8548  }
8549 #line 8545 "ripper.c" /* yacc.c:1646 */
8550  break;
8551 
8552  case 338:
8553 #line 2914 "ripper.y" /* yacc.c:1646 */
8554  {
8555 #if 0
8556  (yyval.val) = NEW_CLASS((yyvsp[-4].val), (yyvsp[-1].val), (yyvsp[-3].val), &(yyloc));
8557  nd_set_line((yyval.val)->nd_body, (yylsp[0]).end_pos.lineno);
8558  set_line_body((yyvsp[-1].val), (yylsp[-3]).end_pos.lineno);
8559  nd_set_line((yyval.val), (yylsp[-3]).end_pos.lineno);
8560 #endif
8561  {VALUE v1,v2,v3,v4;v1=(yyvsp[-4].val);v2=(yyvsp[-3].val);v3=(yyvsp[-1].val);v4=dispatch3(class,v1,v2,v3);(yyval.val)=v4;}
8562  local_pop(p);
8563  p->in_class = (yyvsp[-5].num) & 1;
8564  }
8565 #line 8561 "ripper.c" /* yacc.c:1646 */
8566  break;
8567 
8568  case 339:
8569 #line 2926 "ripper.y" /* yacc.c:1646 */
8570  {
8571  (yyval.num) = (p->in_class << 1) | p->in_def;
8572  p->in_def = 0;
8573  p->in_class = 0;
8574  local_push(p, 0);
8575  }
8576 #line 8572 "ripper.c" /* yacc.c:1646 */
8577  break;
8578 
8579  case 340:
8580 #line 2935 "ripper.y" /* yacc.c:1646 */
8581  {
8582 #if 0
8583  (yyval.val) = NEW_SCLASS((yyvsp[-4].val), (yyvsp[-1].val), &(yyloc));
8584  nd_set_line((yyval.val)->nd_body, (yylsp[0]).end_pos.lineno);
8585  set_line_body((yyvsp[-1].val), nd_line((yyvsp[-4].val)));
8586  fixpos((yyval.val), (yyvsp[-4].val));
8587 #endif
8588  {VALUE v1,v2,v3;v1=(yyvsp[-4].val);v2=(yyvsp[-1].val);v3=dispatch2(sclass,v1,v2);(yyval.val)=v3;}
8589  local_pop(p);
8590  p->in_def = (yyvsp[-3].num) & 1;
8591  p->in_class = ((yyvsp[-3].num) >> 1) & 1;
8592  }
8593 #line 8589 "ripper.c" /* yacc.c:1646 */
8594  break;
8595 
8596  case 341:
8597 #line 2948 "ripper.y" /* yacc.c:1646 */
8598  {
8599  if (p->in_def) {
8600  YYLTYPE loc = code_loc_gen(&(yylsp[-1]), &(yylsp[0]));
8601  yyerror1(&loc, "module definition in method body");
8602  }
8603  (yyvsp[-1].num) = p->in_class;
8604  p->in_class = 1;
8605  local_push(p, 0);
8606  }
8607 #line 8603 "ripper.c" /* yacc.c:1646 */
8608  break;
8609 
8610  case 342:
8611 #line 2959 "ripper.y" /* yacc.c:1646 */
8612  {
8613 #if 0
8614  (yyval.val) = NEW_MODULE((yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
8615  nd_set_line((yyval.val)->nd_body, (yylsp[0]).end_pos.lineno);
8616  set_line_body((yyvsp[-1].val), (yylsp[-3]).end_pos.lineno);
8617  nd_set_line((yyval.val), (yylsp[-3]).end_pos.lineno);
8618 #endif
8619  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=(yyvsp[-1].val);v3=dispatch2(module,v1,v2);(yyval.val)=v3;}
8620  local_pop(p);
8621  p->in_class = (yyvsp[-4].num) & 1;
8622  }
8623 #line 8619 "ripper.c" /* yacc.c:1646 */
8624  break;
8625 
8626  case 343:
8627 #line 2971 "ripper.y" /* yacc.c:1646 */
8628  {
8629  numparam_name(p, get_id((yyvsp[0].val)));
8630  local_push(p, 0);
8631  (yyval.id) = p->cur_arg;
8632  p->cur_arg = 0;
8633  }
8634 #line 8630 "ripper.c" /* yacc.c:1646 */
8635  break;
8636 
8637  case 344:
8638 #line 2977 "ripper.y" /* yacc.c:1646 */
8639  {
8640  (yyval.num) = p->in_def;
8641  p->in_def = 1;
8642  }
8643 #line 8639 "ripper.c" /* yacc.c:1646 */
8644  break;
8645 
8646  case 345:
8647 #line 2984 "ripper.y" /* yacc.c:1646 */
8648  {
8649 #if 0
8650  NODE *body = remove_begin((yyvsp[-1].val));
8651  reduce_nodes(p, &body);
8652  (yyval.val) = NEW_DEFN((yyvsp[-5].val), (yyvsp[-2].val), body, &(yyloc));
8653  nd_set_line((yyval.val)->nd_defn, (yylsp[0]).end_pos.lineno);
8654  set_line_body(body, (yylsp[-6]).beg_pos.lineno);
8655 #endif
8656  {VALUE v1,v2,v3,v4;v1=(yyvsp[-5].val);v2=(yyvsp[-2].val);v3=(yyvsp[-1].val);v4=dispatch3(def,v1,v2,v3);(yyval.val)=v4;}
8657  local_pop(p);
8658  p->in_def = (yyvsp[-3].num) & 1;
8659  p->cur_arg = (yyvsp[-4].id);
8660  }
8661 #line 8657 "ripper.c" /* yacc.c:1646 */
8662  break;
8663 
8664  case 346:
8665 #line 2997 "ripper.y" /* yacc.c:1646 */
8666  {SET_LEX_STATE(EXPR_FNAME);}
8667 #line 8663 "ripper.c" /* yacc.c:1646 */
8668  break;
8669 
8670  case 347:
8671 #line 2998 "ripper.y" /* yacc.c:1646 */
8672  {
8673  numparam_name(p, get_id((yyvsp[0].val)));
8674  (yyvsp[-1].num) = p->in_def;
8675  p->in_def = 1;
8676  SET_LEX_STATE(EXPR_ENDFN|EXPR_LABEL); /* force for args */
8677  local_push(p, 0);
8678  (yyval.id) = p->cur_arg;
8679  p->cur_arg = 0;
8680  }
8681 #line 8677 "ripper.c" /* yacc.c:1646 */
8682  break;
8683 
8684  case 348:
8685 #line 3010 "ripper.y" /* yacc.c:1646 */
8686  {
8687 #if 0
8688  NODE *body = remove_begin((yyvsp[-1].val));
8689  reduce_nodes(p, &body);
8690  (yyval.val) = NEW_DEFS((yyvsp[-7].val), (yyvsp[-4].val), (yyvsp[-2].val), body, &(yyloc));
8691  nd_set_line((yyval.val)->nd_defn, (yylsp[0]).end_pos.lineno);
8692  set_line_body(body, (yylsp[-8]).beg_pos.lineno);
8693 #endif
8694  {VALUE v1,v2,v3,v4,v5,v6;v1=(yyvsp[-7].val);v2=(yyvsp[-6].val);v3=(yyvsp[-4].val);v4=(yyvsp[-2].val);v5=(yyvsp[-1].val);v6=dispatch5(defs,v1,v2,v3,v4,v5);(yyval.val)=v6;}
8695  local_pop(p);
8696  p->in_def = (yyvsp[-5].num) & 1;
8697  p->cur_arg = (yyvsp[-3].id);
8698  }
8699 #line 8695 "ripper.c" /* yacc.c:1646 */
8700  break;
8701 
8702  case 349:
8703 #line 3024 "ripper.y" /* yacc.c:1646 */
8704  {
8705 #if 0
8706  (yyval.val) = NEW_BREAK(0, &(yyloc));
8707 #endif
8708  {VALUE v1,v2,v3;v1=dispatch0(args_new);v2=v1;v3=dispatch1(break,v2);(yyval.val)=v3;}
8709  }
8710 #line 8706 "ripper.c" /* yacc.c:1646 */
8711  break;
8712 
8713  case 350:
8714 #line 3031 "ripper.y" /* yacc.c:1646 */
8715  {
8716 #if 0
8717  (yyval.val) = NEW_NEXT(0, &(yyloc));
8718 #endif
8719  {VALUE v1,v2,v3;v1=dispatch0(args_new);v2=v1;v3=dispatch1(next,v2);(yyval.val)=v3;}
8720  }
8721 #line 8717 "ripper.c" /* yacc.c:1646 */
8722  break;
8723 
8724  case 351:
8725 #line 3038 "ripper.y" /* yacc.c:1646 */
8726  {
8727 #if 0
8728  (yyval.val) = NEW_REDO(&(yyloc));
8729 #endif
8730  {VALUE v1;v1=dispatch0(redo);(yyval.val)=v1;}
8731  }
8732 #line 8728 "ripper.c" /* yacc.c:1646 */
8733  break;
8734 
8735  case 352:
8736 #line 3045 "ripper.y" /* yacc.c:1646 */
8737  {
8738 #if 0
8739  (yyval.val) = NEW_RETRY(&(yyloc));
8740 #endif
8741  {VALUE v1;v1=dispatch0(retry);(yyval.val)=v1;}
8742  }
8743 #line 8739 "ripper.c" /* yacc.c:1646 */
8744  break;
8745 
8746  case 353:
8747 #line 3054 "ripper.y" /* yacc.c:1646 */
8748  {
8749  value_expr((yyvsp[0].val));
8750  (yyval.val) = (yyvsp[0].val);
8751  }
8752 #line 8748 "ripper.c" /* yacc.c:1646 */
8753  break;
8754 
8755  case 354:
8756 #line 3061 "ripper.y" /* yacc.c:1646 */
8757  {
8758  token_info_push(p, "begin", &(yyloc));
8759  }
8760 #line 8756 "ripper.c" /* yacc.c:1646 */
8761  break;
8762 
8763  case 355:
8764 #line 3067 "ripper.y" /* yacc.c:1646 */
8765  {
8766  WARN_EOL("if");
8767  token_info_push(p, "if", &(yyloc));
8768  if (p->token_info && p->token_info->nonspc &&
8769  p->token_info->next && !strcmp(p->token_info->next->token, "else")) {
8770  const char *tok = p->lex.ptok;
8771  const char *beg = p->lex.pbeg + p->token_info->next->beg.column;
8772  beg += rb_strlen_lit("else");
8773  while (beg < tok && ISSPACE(*beg)) beg++;
8774  if (beg == tok) {
8775  p->token_info->nonspc = 0;
8776  }
8777  }
8778  }
8779 #line 8775 "ripper.c" /* yacc.c:1646 */
8780  break;
8781 
8782  case 356:
8783 #line 3084 "ripper.y" /* yacc.c:1646 */
8784  {
8785  token_info_push(p, "unless", &(yyloc));
8786  }
8787 #line 8783 "ripper.c" /* yacc.c:1646 */
8788  break;
8789 
8790  case 357:
8791 #line 3090 "ripper.y" /* yacc.c:1646 */
8792  {
8793  token_info_push(p, "while", &(yyloc));
8794  }
8795 #line 8791 "ripper.c" /* yacc.c:1646 */
8796  break;
8797 
8798  case 358:
8799 #line 3096 "ripper.y" /* yacc.c:1646 */
8800  {
8801  token_info_push(p, "until", &(yyloc));
8802  }
8803 #line 8799 "ripper.c" /* yacc.c:1646 */
8804  break;
8805 
8806  case 359:
8807 #line 3102 "ripper.y" /* yacc.c:1646 */
8808  {
8809  token_info_push(p, "case", &(yyloc));
8810  }
8811 #line 8807 "ripper.c" /* yacc.c:1646 */
8812  break;
8813 
8814  case 360:
8815 #line 3108 "ripper.y" /* yacc.c:1646 */
8816  {
8817  token_info_push(p, "for", &(yyloc));
8818  }
8819 #line 8815 "ripper.c" /* yacc.c:1646 */
8820  break;
8821 
8822  case 361:
8823 #line 3114 "ripper.y" /* yacc.c:1646 */
8824  {
8825  token_info_push(p, "class", &(yyloc));
8826  }
8827 #line 8823 "ripper.c" /* yacc.c:1646 */
8828  break;
8829 
8830  case 362:
8831 #line 3120 "ripper.y" /* yacc.c:1646 */
8832  {
8833  token_info_push(p, "module", &(yyloc));
8834  }
8835 #line 8831 "ripper.c" /* yacc.c:1646 */
8836  break;
8837 
8838  case 363:
8839 #line 3126 "ripper.y" /* yacc.c:1646 */
8840  {
8841  token_info_push(p, "def", &(yyloc));
8842  }
8843 #line 8839 "ripper.c" /* yacc.c:1646 */
8844  break;
8845 
8846  case 364:
8847 #line 3132 "ripper.y" /* yacc.c:1646 */
8848  {
8849  token_info_push(p, "do", &(yyloc));
8850  }
8851 #line 8847 "ripper.c" /* yacc.c:1646 */
8852  break;
8853 
8854  case 365:
8855 #line 3138 "ripper.y" /* yacc.c:1646 */
8856  {
8857  token_info_push(p, "do", &(yyloc));
8858  }
8859 #line 8855 "ripper.c" /* yacc.c:1646 */
8860  break;
8861 
8862  case 366:
8863 #line 3144 "ripper.y" /* yacc.c:1646 */
8864  {
8865  token_info_warn(p, "rescue", p->token_info, 1, &(yyloc));
8866  }
8867 #line 8863 "ripper.c" /* yacc.c:1646 */
8868  break;
8869 
8870  case 367:
8871 #line 3150 "ripper.y" /* yacc.c:1646 */
8872  {
8873  token_info_warn(p, "ensure", p->token_info, 1, &(yyloc));
8874  }
8875 #line 8871 "ripper.c" /* yacc.c:1646 */
8876  break;
8877 
8878  case 368:
8879 #line 3156 "ripper.y" /* yacc.c:1646 */
8880  {
8881  token_info_warn(p, "when", p->token_info, 0, &(yyloc));
8882  }
8883 #line 8879 "ripper.c" /* yacc.c:1646 */
8884  break;
8885 
8886  case 369:
8887 #line 3162 "ripper.y" /* yacc.c:1646 */
8888  {
8889  token_info *ptinfo_beg = p->token_info;
8890  int same = ptinfo_beg && strcmp(ptinfo_beg->token, "case") != 0;
8891  token_info_warn(p, "else", p->token_info, same, &(yyloc));
8892  if (same) {
8893  token_info e;
8894  e.next = ptinfo_beg->next;
8895  e.token = "else";
8896  token_info_setup(&e, p->lex.pbeg, &(yyloc));
8897  if (!e.nonspc) *ptinfo_beg = e;
8898  }
8899  }
8900 #line 8896 "ripper.c" /* yacc.c:1646 */
8901  break;
8902 
8903  case 370:
8904 #line 3177 "ripper.y" /* yacc.c:1646 */
8905  {
8906  WARN_EOL("elsif");
8907  token_info_warn(p, "elsif", p->token_info, 1, &(yyloc));
8908  }
8909 #line 8905 "ripper.c" /* yacc.c:1646 */
8910  break;
8911 
8912  case 371:
8913 #line 3184 "ripper.y" /* yacc.c:1646 */
8914  {
8915  token_info_pop(p, "end", &(yyloc));
8916  }
8917 #line 8913 "ripper.c" /* yacc.c:1646 */
8918  break;
8919 
8920  case 372:
8921 #line 3190 "ripper.y" /* yacc.c:1646 */
8922  {
8923  if (p->in_class && !p->in_def && !dyna_in_block(p))
8924  yyerror1(&(yylsp[0]), "Invalid return in class/module body");
8925  }
8926 #line 8922 "ripper.c" /* yacc.c:1646 */
8927  break;
8928 
8929  case 379:
8930 #line 3209 "ripper.y" /* yacc.c:1646 */
8931  {
8932 #if 0
8933  (yyval.val) = new_if(p, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
8934  fixpos((yyval.val), (yyvsp[-3].val));
8935 #endif
8936  {VALUE v1,v2,v3,v4;v1=(yyvsp[-3].val);v2=(yyvsp[-1].val);v3=escape_Qundef((yyvsp[0].val));v4=dispatch3(elsif,v1,v2,v3);(yyval.val)=v4;}
8937  }
8938 #line 8934 "ripper.c" /* yacc.c:1646 */
8939  break;
8940 
8941  case 381:
8942 #line 3220 "ripper.y" /* yacc.c:1646 */
8943  {
8944 #if 0
8945  (yyval.val) = (yyvsp[0].val);
8946 #endif
8947  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(else,v1);(yyval.val)=v2;}
8948  }
8949 #line 8945 "ripper.c" /* yacc.c:1646 */
8950  break;
8951 
8952  case 384:
8953 #line 3233 "ripper.y" /* yacc.c:1646 */
8954  {
8955 #if 0
8956  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
8957  mark_lvar_used(p, (yyval.val));
8958 #endif
8959  (yyval.val)=assignable(p, (yyvsp[0].val));
8960  }
8961 #line 8957 "ripper.c" /* yacc.c:1646 */
8962  break;
8963 
8964  case 385:
8965 #line 3241 "ripper.y" /* yacc.c:1646 */
8966  {
8967 #if 0
8968  (yyval.val) = (yyvsp[-1].val);
8969 #endif
8970  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(mlhs_paren,v1);(yyval.val)=v2;}
8971  }
8972 #line 8968 "ripper.c" /* yacc.c:1646 */
8973  break;
8974 
8975  case 386:
8976 #line 3250 "ripper.y" /* yacc.c:1646 */
8977  {
8978 #if 0
8979  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
8980 #endif
8981  {VALUE v1,v2,v3,v4;v1=dispatch0(mlhs_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(mlhs_add,v2,v3);(yyval.val)=v4;}
8982  }
8983 #line 8979 "ripper.c" /* yacc.c:1646 */
8984  break;
8985 
8986  case 387:
8987 #line 3257 "ripper.y" /* yacc.c:1646 */
8988  {
8989 #if 0
8990  (yyval.val) = list_append(p, (yyvsp[-2].val), (yyvsp[0].val));
8991 #endif
8992  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(mlhs_add,v1,v2);(yyval.val)=v3;}
8993  }
8994 #line 8990 "ripper.c" /* yacc.c:1646 */
8995  break;
8996 
8997  case 388:
8998 #line 3266 "ripper.y" /* yacc.c:1646 */
8999  {
9000 #if 0
9001  (yyval.val) = NEW_MASGN((yyvsp[0].val), 0, &(yyloc));
9002 #endif
9003  (yyval.val)=(yyvsp[0].val);
9004  }
9005 #line 9001 "ripper.c" /* yacc.c:1646 */
9006  break;
9007 
9008  case 389:
9009 #line 3273 "ripper.y" /* yacc.c:1646 */
9010  {
9011 #if 0
9012  (yyval.val) = NEW_MASGN((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
9013 #endif
9014  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(mlhs_add_star,v1,v2);(yyval.val)=v3;}
9015  }
9016 #line 9012 "ripper.c" /* yacc.c:1646 */
9017  break;
9018 
9019  case 390:
9020 #line 3280 "ripper.y" /* yacc.c:1646 */
9021  {
9022 #if 0
9023  (yyval.val) = NEW_MASGN((yyvsp[-4].val), NEW_POSTARG((yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
9024 #endif
9025  {VALUE v1,v2,v3,v4,v5,v6;v1=(yyvsp[-4].val);v2=(yyvsp[-2].val);v3=dispatch2(mlhs_add_star,v1,v2);v4=v3;v5=(yyvsp[0].val);v6=dispatch2(mlhs_add_post,v4,v5);(yyval.val)=v6;}
9026  }
9027 #line 9023 "ripper.c" /* yacc.c:1646 */
9028  break;
9029 
9030  case 391:
9031 #line 3287 "ripper.y" /* yacc.c:1646 */
9032  {
9033 #if 0
9034  (yyval.val) = NEW_MASGN(0, (yyvsp[0].val), &(yyloc));
9035 #endif
9036  {VALUE v1,v2,v3,v4;v1=dispatch0(mlhs_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(mlhs_add_star,v2,v3);(yyval.val)=v4;}
9037  }
9038 #line 9034 "ripper.c" /* yacc.c:1646 */
9039  break;
9040 
9041  case 392:
9042 #line 3294 "ripper.y" /* yacc.c:1646 */
9043  {
9044 #if 0
9045  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
9046 #endif
9047  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=dispatch0(mlhs_new);v2=v1;v3=(yyvsp[-2].val);v4=dispatch2(mlhs_add_star,v2,v3);v5=v4;v6=(yyvsp[0].val);v7=dispatch2(mlhs_add_post,v5,v6);(yyval.val)=v7;}
9048  }
9049 #line 9045 "ripper.c" /* yacc.c:1646 */
9050  break;
9051 
9052  case 393:
9053 #line 3303 "ripper.y" /* yacc.c:1646 */
9054  {
9055 #if 0
9056  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
9057  mark_lvar_used(p, (yyval.val));
9058 #endif
9059  (yyval.val)=assignable(p, (yyvsp[0].val));
9060  }
9061 #line 9057 "ripper.c" /* yacc.c:1646 */
9062  break;
9063 
9064  case 394:
9065 #line 3311 "ripper.y" /* yacc.c:1646 */
9066  {
9067 #if 0
9068  (yyval.val) = NODE_SPECIAL_NO_NAME_REST;
9069 #endif
9070  (yyval.val)=Qnil;
9071  }
9072 #line 9068 "ripper.c" /* yacc.c:1646 */
9073  break;
9074 
9075  case 395:
9076 #line 3320 "ripper.y" /* yacc.c:1646 */
9077  {
9078  (yyval.val) = new_args_tail(p, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]));
9079  }
9080 #line 9076 "ripper.c" /* yacc.c:1646 */
9081  break;
9082 
9083  case 396:
9084 #line 3324 "ripper.y" /* yacc.c:1646 */
9085  {
9086  (yyval.val) = new_args_tail(p, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yylsp[-1]));
9087  }
9088 #line 9084 "ripper.c" /* yacc.c:1646 */
9089  break;
9090 
9091  case 397:
9092 #line 3328 "ripper.y" /* yacc.c:1646 */
9093  {
9094  (yyval.val) = new_args_tail(p, Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]));
9095  }
9096 #line 9092 "ripper.c" /* yacc.c:1646 */
9097  break;
9098 
9099  case 398:
9100 #line 3332 "ripper.y" /* yacc.c:1646 */
9101  {
9102  (yyval.val) = new_args_tail(p, Qnone, ID2VAL(idNil), (yyvsp[0].val), &(yylsp[-1]));
9103  }
9104 #line 9100 "ripper.c" /* yacc.c:1646 */
9105  break;
9106 
9107  case 399:
9108 #line 3336 "ripper.y" /* yacc.c:1646 */
9109  {
9110  (yyval.val) = new_args_tail(p, Qnone, Qnone, (yyvsp[0].val), &(yylsp[0]));
9111  }
9112 #line 9108 "ripper.c" /* yacc.c:1646 */
9113  break;
9114 
9115  case 400:
9116 #line 3342 "ripper.y" /* yacc.c:1646 */
9117  {
9118  (yyval.val) = (yyvsp[0].val);
9119  }
9120 #line 9116 "ripper.c" /* yacc.c:1646 */
9121  break;
9122 
9123  case 401:
9124 #line 3346 "ripper.y" /* yacc.c:1646 */
9125  {
9126  (yyval.val) = new_args_tail(p, Qnone, Qnone, Qnone, &(yylsp[0]));
9127  }
9128 #line 9124 "ripper.c" /* yacc.c:1646 */
9129  break;
9130 
9131  case 402:
9132 #line 3352 "ripper.y" /* yacc.c:1646 */
9133  {
9134  (yyval.val) = new_args(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
9135  }
9136 #line 9132 "ripper.c" /* yacc.c:1646 */
9137  break;
9138 
9139  case 403:
9140 #line 3356 "ripper.y" /* yacc.c:1646 */
9141  {
9142  (yyval.val) = new_args(p, (yyvsp[-7].val), (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9143  }
9144 #line 9140 "ripper.c" /* yacc.c:1646 */
9145  break;
9146 
9147  case 404:
9148 #line 3360 "ripper.y" /* yacc.c:1646 */
9149  {
9150  (yyval.val) = new_args(p, (yyvsp[-3].val), (yyvsp[-1].val), Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9151  }
9152 #line 9148 "ripper.c" /* yacc.c:1646 */
9153  break;
9154 
9155  case 405:
9156 #line 3364 "ripper.y" /* yacc.c:1646 */
9157  {
9158  (yyval.val) = new_args(p, (yyvsp[-5].val), (yyvsp[-3].val), Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9159  }
9160 #line 9156 "ripper.c" /* yacc.c:1646 */
9161  break;
9162 
9163  case 406:
9164 #line 3368 "ripper.y" /* yacc.c:1646 */
9165  {
9166  (yyval.val) = new_args(p, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
9167  }
9168 #line 9164 "ripper.c" /* yacc.c:1646 */
9169  break;
9170 
9171  case 407:
9172 #line 3372 "ripper.y" /* yacc.c:1646 */
9173  {
9174 #if 0
9175  /* magic number for rest_id in iseq_set_arguments() */
9176  (yyval.val) = new_args(p, (yyvsp[-1].val), Qnone, NODE_SPECIAL_EXCESSIVE_COMMA, Qnone, new_args_tail(p, Qnone, Qnone, Qnone, &(yylsp[-1])), &(yyloc));
9177 #endif
9178  {VALUE v1;v1=dispatch0(excessed_comma);(yyval.val)=new_args(p, (yyvsp[-1].val), Qnone, v1, Qnone, new_args_tail(p, Qnone, Qnone, Qnone, NULL), NULL);}
9179  }
9180 #line 9176 "ripper.c" /* yacc.c:1646 */
9181  break;
9182 
9183  case 408:
9184 #line 3380 "ripper.y" /* yacc.c:1646 */
9185  {
9186  (yyval.val) = new_args(p, (yyvsp[-5].val), Qnone, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9187  }
9188 #line 9184 "ripper.c" /* yacc.c:1646 */
9189  break;
9190 
9191  case 409:
9192 #line 3384 "ripper.y" /* yacc.c:1646 */
9193  {
9194  (yyval.val) = new_args(p, (yyvsp[-1].val), Qnone, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9195  }
9196 #line 9192 "ripper.c" /* yacc.c:1646 */
9197  break;
9198 
9199  case 410:
9200 #line 3388 "ripper.y" /* yacc.c:1646 */
9201  {
9202  (yyval.val) = new_args(p, Qnone, (yyvsp[-3].val), (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
9203  }
9204 #line 9200 "ripper.c" /* yacc.c:1646 */
9205  break;
9206 
9207  case 411:
9208 #line 3392 "ripper.y" /* yacc.c:1646 */
9209  {
9210  (yyval.val) = new_args(p, Qnone, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9211  }
9212 #line 9208 "ripper.c" /* yacc.c:1646 */
9213  break;
9214 
9215  case 412:
9216 #line 3396 "ripper.y" /* yacc.c:1646 */
9217  {
9218  (yyval.val) = new_args(p, Qnone, (yyvsp[-1].val), Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9219  }
9220 #line 9216 "ripper.c" /* yacc.c:1646 */
9221  break;
9222 
9223  case 413:
9224 #line 3400 "ripper.y" /* yacc.c:1646 */
9225  {
9226  (yyval.val) = new_args(p, Qnone, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9227  }
9228 #line 9224 "ripper.c" /* yacc.c:1646 */
9229  break;
9230 
9231  case 414:
9232 #line 3404 "ripper.y" /* yacc.c:1646 */
9233  {
9234  (yyval.val) = new_args(p, Qnone, Qnone, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
9235  }
9236 #line 9232 "ripper.c" /* yacc.c:1646 */
9237  break;
9238 
9239  case 415:
9240 #line 3408 "ripper.y" /* yacc.c:1646 */
9241  {
9242  (yyval.val) = new_args(p, Qnone, Qnone, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9243  }
9244 #line 9240 "ripper.c" /* yacc.c:1646 */
9245  break;
9246 
9247  case 416:
9248 #line 3412 "ripper.y" /* yacc.c:1646 */
9249  {
9250  (yyval.val) = new_args(p, Qnone, Qnone, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9251  }
9252 #line 9248 "ripper.c" /* yacc.c:1646 */
9253  break;
9254 
9255  case 418:
9256 #line 3419 "ripper.y" /* yacc.c:1646 */
9257  {
9258  p->command_start = TRUE;
9259  }
9260 #line 9256 "ripper.c" /* yacc.c:1646 */
9261  break;
9262 
9263  case 419:
9264 #line 3425 "ripper.y" /* yacc.c:1646 */
9265  {
9266  p->cur_arg = 0;
9268 #if 0
9269  (yyval.val) = 0;
9270 #endif
9271  {VALUE v1,v2,v3,v4,v5,v6,v7,v8,v9,v10,v11;v1=Qnil;v2=Qnil;v3=Qnil;v4=Qnil;v5=Qnil;v6=Qnil;v7=Qnil;v8=dispatch7(params,v1,v2,v3,v4,v5,v6,v7);v9=v8;v10=escape_Qundef((yyvsp[-1].val));v11=dispatch2(block_var,v9,v10);(yyval.val)=v11;}
9272  }
9273 #line 9269 "ripper.c" /* yacc.c:1646 */
9274  break;
9275 
9276  case 420:
9277 #line 3434 "ripper.y" /* yacc.c:1646 */
9278  {
9279  p->cur_arg = 0;
9281 #if 0
9282  (yyval.val) = (yyvsp[-2].val);
9283 #endif
9284  {VALUE v1,v2,v3;v1=escape_Qundef((yyvsp[-2].val));v2=escape_Qundef((yyvsp[-1].val));v3=dispatch2(block_var,v1,v2);(yyval.val)=v3;}
9285  }
9286 #line 9282 "ripper.c" /* yacc.c:1646 */
9287  break;
9288 
9289  case 421:
9290 #line 3446 "ripper.y" /* yacc.c:1646 */
9291  {
9292  (yyval.val) = 0;
9293  }
9294 #line 9290 "ripper.c" /* yacc.c:1646 */
9295  break;
9296 
9297  case 422:
9298 #line 3450 "ripper.y" /* yacc.c:1646 */
9299  {
9300 #if 0
9301  (yyval.val) = 0;
9302 #endif
9303  (yyval.val)=(yyvsp[-1].val);
9304  }
9305 #line 9301 "ripper.c" /* yacc.c:1646 */
9306  break;
9307 
9308  case 423:
9309 #line 3459 "ripper.y" /* yacc.c:1646 */
9310  {(yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));}
9311 #line 9307 "ripper.c" /* yacc.c:1646 */
9312  break;
9313 
9314  case 424:
9315 #line 3461 "ripper.y" /* yacc.c:1646 */
9316  {(yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));}
9317 #line 9313 "ripper.c" /* yacc.c:1646 */
9318  break;
9319 
9320  case 425:
9321 #line 3465 "ripper.y" /* yacc.c:1646 */
9322  {
9323  new_bv(p, get_id((yyvsp[0].val)));
9324  (yyval.val)=get_value((yyvsp[0].val));
9325  }
9326 #line 9322 "ripper.c" /* yacc.c:1646 */
9327  break;
9328 
9329  case 426:
9330 #line 3470 "ripper.y" /* yacc.c:1646 */
9331  {
9332  (yyval.val) = 0;
9333  }
9334 #line 9330 "ripper.c" /* yacc.c:1646 */
9335  break;
9336 
9337  case 427:
9338 #line 3475 "ripper.y" /* yacc.c:1646 */
9339  {
9340  (yyval.vars) = dyna_push(p);
9341  }
9342 #line 9338 "ripper.c" /* yacc.c:1646 */
9343  break;
9344 
9345  case 428:
9346 #line 3478 "ripper.y" /* yacc.c:1646 */
9347  {
9348  (yyval.num) = p->lex.lpar_beg;
9349  p->lex.lpar_beg = p->lex.paren_nest;
9350  }
9351 #line 9347 "ripper.c" /* yacc.c:1646 */
9352  break;
9353 
9354  case 429:
9355 #line 3482 "ripper.y" /* yacc.c:1646 */
9356  {
9357  (yyval.num) = p->max_numparam;
9358  p->max_numparam = 0;
9359  }
9360 #line 9356 "ripper.c" /* yacc.c:1646 */
9361  break;
9362 
9363  case 430:
9364 #line 3486 "ripper.y" /* yacc.c:1646 */
9365  {
9366  (yyval.node) = numparam_push(p);
9367  }
9368 #line 9364 "ripper.c" /* yacc.c:1646 */
9369  break;
9370 
9371  case 431:
9372 #line 3490 "ripper.y" /* yacc.c:1646 */
9373  {
9374  CMDARG_PUSH(0);
9375  }
9376 #line 9372 "ripper.c" /* yacc.c:1646 */
9377  break;
9378 
9379  case 432:
9380 #line 3494 "ripper.y" /* yacc.c:1646 */
9381  {
9382  int max_numparam = p->max_numparam;
9383  p->lex.lpar_beg = (yyvsp[-5].num);
9384  p->max_numparam = (yyvsp[-4].num);
9385  CMDARG_POP();
9386  (yyvsp[-2].val) = args_with_numbered(p, (yyvsp[-2].val), max_numparam);
9387 #if 0
9388  {
9389  YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
9390  (yyval.val) = NEW_LAMBDA((yyvsp[-2].val), (yyvsp[0].val), &loc);
9391  nd_set_line((yyval.val)->nd_body, (yylsp[0]).end_pos.lineno);
9392  nd_set_line((yyval.val), (yylsp[-2]).end_pos.lineno);
9393  }
9394 #endif
9395  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(lambda,v1,v2);(yyval.val)=v3;}
9396  numparam_pop(p, (yyvsp[-3].node));
9397  dyna_pop(p, (yyvsp[-6].vars));
9398  }
9399 #line 9395 "ripper.c" /* yacc.c:1646 */
9400  break;
9401 
9402  case 433:
9403 #line 3515 "ripper.y" /* yacc.c:1646 */
9404  {
9405 #if 0
9406  (yyval.val) = (yyvsp[-2].val);
9408 #endif
9409  {VALUE v1,v2;v1=(yyvsp[-2].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
9410  }
9411 #line 9407 "ripper.c" /* yacc.c:1646 */
9412  break;
9413 
9414  case 434:
9415 #line 3523 "ripper.y" /* yacc.c:1646 */
9416  {
9417 #if 0
9418  if (!args_info_empty_p((yyvsp[0].val)->nd_ainfo))
9420 #endif
9421  (yyval.val) = (yyvsp[0].val);
9422  }
9423 #line 9419 "ripper.c" /* yacc.c:1646 */
9424  break;
9425 
9426  case 435:
9427 #line 3533 "ripper.y" /* yacc.c:1646 */
9428  {
9429  token_info_pop(p, "}", &(yylsp[0]));
9430  (yyval.val) = (yyvsp[-1].val);
9431  }
9432 #line 9428 "ripper.c" /* yacc.c:1646 */
9433  break;
9434 
9435  case 436:
9436 #line 3538 "ripper.y" /* yacc.c:1646 */
9437  {
9438  (yyval.val) = (yyvsp[-1].val);
9439  }
9440 #line 9436 "ripper.c" /* yacc.c:1646 */
9441  break;
9442 
9443  case 437:
9444 #line 3544 "ripper.y" /* yacc.c:1646 */
9445  {
9446  (yyval.val) = (yyvsp[-1].val);
9447 #if 0
9448  (yyval.val)->nd_body->nd_loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
9449  nd_set_line((yyval.val), (yylsp[-2]).end_pos.lineno);
9450 #endif
9451  }
9452 #line 9448 "ripper.c" /* yacc.c:1646 */
9453  break;
9454 
9455  case 438:
9456 #line 3554 "ripper.y" /* yacc.c:1646 */
9457  {
9458 #if 0
9459  if (nd_type((yyvsp[-1].val)) == NODE_YIELD) {
9460  compile_error(p, "block given to yield");
9461  }
9462  else {
9463  block_dup_check(p, (yyvsp[-1].val)->nd_args, (yyvsp[0].val));
9464  }
9465  (yyval.val) = method_add_block(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9466  fixpos((yyval.val), (yyvsp[-1].val));
9467 #endif
9468  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(method_add_block,v1,v2);(yyval.val)=v3;}
9469  }
9470 #line 9466 "ripper.c" /* yacc.c:1646 */
9471  break;
9472 
9473  case 439:
9474 #line 3568 "ripper.y" /* yacc.c:1646 */
9475  {
9476 #if 0
9477  (yyval.val) = new_qcall(p, (yyvsp[-2].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
9478 #endif
9479  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=(yyvsp[-3].val);v2=(yyvsp[-2].val);v3=(yyvsp[-1].val);v4=dispatch3(call,v1,v2,v3);v5=v4;v6=(yyvsp[0].val);v7=v6==Qundef ? v5 : dispatch2(method_add_arg,v5,v6);(yyval.val)=v7;}
9480  }
9481 #line 9477 "ripper.c" /* yacc.c:1646 */
9482  break;
9483 
9484  case 440:
9485 #line 3575 "ripper.y" /* yacc.c:1646 */
9486  {
9487 #if 0
9488  (yyval.val) = new_command_qcall(p, (yyvsp[-3].val), (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-2]), &(yyloc));
9489 #endif
9490  {VALUE v1,v2,v3,v4,v5,v6,v7,v8;v1=(yyvsp[-4].val);v2=(yyvsp[-3].val);v3=(yyvsp[-2].val);v4=(yyvsp[-1].val);v5=dispatch4(command_call,v1,v2,v3,v4);v6=v5;v7=(yyvsp[0].val);v8=v7==Qundef ? v6 : dispatch2(method_add_block,v6,v7);(yyval.val)=v8;}
9491  }
9492 #line 9488 "ripper.c" /* yacc.c:1646 */
9493  break;
9494 
9495  case 441:
9496 #line 3582 "ripper.y" /* yacc.c:1646 */
9497  {
9498 #if 0
9499  (yyval.val) = new_command_qcall(p, (yyvsp[-3].val), (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-2]), &(yyloc));
9500 #endif
9501  {VALUE v1,v2,v3,v4,v5,v6,v7,v8;v1=(yyvsp[-4].val);v2=(yyvsp[-3].val);v3=(yyvsp[-2].val);v4=(yyvsp[-1].val);v5=dispatch4(command_call,v1,v2,v3,v4);v6=v5;v7=(yyvsp[0].val);v8=dispatch2(method_add_block,v6,v7);(yyval.val)=v8;}
9502  }
9503 #line 9499 "ripper.c" /* yacc.c:1646 */
9504  break;
9505 
9506  case 442:
9507 #line 3591 "ripper.y" /* yacc.c:1646 */
9508  {
9509 #if 0
9510  (yyval.val) = (yyvsp[-1].val);
9511  (yyval.val)->nd_args = (yyvsp[0].val);
9512  nd_set_last_loc((yyvsp[-1].val), (yylsp[0]).end_pos);
9513 #endif
9514  {VALUE v1,v2,v3,v4,v5;v1=(yyvsp[-1].val);v2=dispatch1(fcall,v1);v3=v2;v4=(yyvsp[0].val);v5=dispatch2(method_add_arg,v3,v4);(yyval.val)=v5;}
9515  }
9516 #line 9512 "ripper.c" /* yacc.c:1646 */
9517  break;
9518 
9519  case 443:
9520 #line 3600 "ripper.y" /* yacc.c:1646 */
9521  {
9522 #if 0
9523  (yyval.val) = new_qcall(p, (yyvsp[-2].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
9524  nd_set_line((yyval.val), (yylsp[-1]).end_pos.lineno);
9525 #endif
9526  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=(yyvsp[-3].val);v2=(yyvsp[-2].val);v3=(yyvsp[-1].val);v4=dispatch3(call,v1,v2,v3);v5=v4;v6=(yyvsp[0].val);v7=v6==Qundef ? v5 : dispatch2(method_add_arg,v5,v6);(yyval.val)=v7;}
9527  }
9528 #line 9524 "ripper.c" /* yacc.c:1646 */
9529  break;
9530 
9531  case 444:
9532 #line 3608 "ripper.y" /* yacc.c:1646 */
9533  {
9534 #if 0
9535  (yyval.val) = new_qcall(p, ID2VAL(idCOLON2), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
9536  nd_set_line((yyval.val), (yylsp[-1]).end_pos.lineno);
9537 #endif
9538  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=(yyvsp[-3].val);v2=ID2VAL(idCOLON2);v3=(yyvsp[-1].val);v4=dispatch3(call,v1,v2,v3);v5=v4;v6=(yyvsp[0].val);v7=dispatch2(method_add_arg,v5,v6);(yyval.val)=v7;}
9539  }
9540 #line 9536 "ripper.c" /* yacc.c:1646 */
9541  break;
9542 
9543  case 445:
9544 #line 3616 "ripper.y" /* yacc.c:1646 */
9545  {
9546 #if 0
9547  (yyval.val) = new_qcall(p, ID2VAL(idCOLON2), (yyvsp[-2].val), (yyvsp[0].val), Qnull, &(yylsp[0]), &(yyloc));
9548 #endif
9549  {VALUE v1,v2,v3,v4;v1=(yyvsp[-2].val);v2=ID2VAL(idCOLON2);v3=(yyvsp[0].val);v4=dispatch3(call,v1,v2,v3);(yyval.val)=v4;}
9550  }
9551 #line 9547 "ripper.c" /* yacc.c:1646 */
9552  break;
9553 
9554  case 446:
9555 #line 3623 "ripper.y" /* yacc.c:1646 */
9556  {
9557 #if 0
9558  (yyval.val) = new_qcall(p, (yyvsp[-1].val), (yyvsp[-2].val), ID2VAL(idCall), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
9559  nd_set_line((yyval.val), (yylsp[-1]).end_pos.lineno);
9560 #endif
9561  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=ID2VAL(idCall);v4=dispatch3(call,v1,v2,v3);v5=v4;v6=(yyvsp[0].val);v7=dispatch2(method_add_arg,v5,v6);(yyval.val)=v7;}
9562  }
9563 #line 9559 "ripper.c" /* yacc.c:1646 */
9564  break;
9565 
9566  case 447:
9567 #line 3631 "ripper.y" /* yacc.c:1646 */
9568  {
9569 #if 0
9570  (yyval.val) = new_qcall(p, ID2VAL(idCOLON2), (yyvsp[-2].val), ID2VAL(idCall), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
9571  nd_set_line((yyval.val), (yylsp[-1]).end_pos.lineno);
9572 #endif
9573  {VALUE v1,v2,v3,v4,v5,v6,v7;v1=(yyvsp[-2].val);v2=ID2VAL(idCOLON2);v3=ID2VAL(idCall);v4=dispatch3(call,v1,v2,v3);v5=v4;v6=(yyvsp[0].val);v7=dispatch2(method_add_arg,v5,v6);(yyval.val)=v7;}
9574  }
9575 #line 9571 "ripper.c" /* yacc.c:1646 */
9576  break;
9577 
9578  case 448:
9579 #line 3639 "ripper.y" /* yacc.c:1646 */
9580  {
9581 #if 0
9582  (yyval.val) = NEW_SUPER((yyvsp[0].val), &(yyloc));
9583 #endif
9584  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(super,v1);(yyval.val)=v2;}
9585  }
9586 #line 9582 "ripper.c" /* yacc.c:1646 */
9587  break;
9588 
9589  case 449:
9590 #line 3646 "ripper.y" /* yacc.c:1646 */
9591  {
9592 #if 0
9593  (yyval.val) = NEW_ZSUPER(&(yyloc));
9594 #endif
9595  {VALUE v1;v1=dispatch0(zsuper);(yyval.val)=v1;}
9596  }
9597 #line 9593 "ripper.c" /* yacc.c:1646 */
9598  break;
9599 
9600  case 450:
9601 #line 3653 "ripper.y" /* yacc.c:1646 */
9602  {
9603 #if 0
9604  if ((yyvsp[-3].val) && nd_type((yyvsp[-3].val)) == NODE_SELF)
9605  (yyval.val) = NEW_FCALL(tAREF, (yyvsp[-1].val), &(yyloc));
9606  else
9607  (yyval.val) = NEW_CALL((yyvsp[-3].val), tAREF, (yyvsp[-1].val), &(yyloc));
9608  fixpos((yyval.val), (yyvsp[-3].val));
9609 #endif
9610  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=escape_Qundef((yyvsp[-1].val));v3=dispatch2(aref,v1,v2);(yyval.val)=v3;}
9611  }
9612 #line 9608 "ripper.c" /* yacc.c:1646 */
9613  break;
9614 
9615  case 451:
9616 #line 3666 "ripper.y" /* yacc.c:1646 */
9617  {
9618  (yyval.val) = (yyvsp[-1].val);
9619 #if 0
9620  (yyval.val)->nd_body->nd_loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
9621  nd_set_line((yyval.val), (yylsp[-2]).end_pos.lineno);
9622 #endif
9623  }
9624 #line 9620 "ripper.c" /* yacc.c:1646 */
9625  break;
9626 
9627  case 452:
9628 #line 3674 "ripper.y" /* yacc.c:1646 */
9629  {
9630  (yyval.val) = (yyvsp[-1].val);
9631 #if 0
9632  (yyval.val)->nd_body->nd_loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
9633  nd_set_line((yyval.val), (yylsp[-2]).end_pos.lineno);
9634 #endif
9635  }
9636 #line 9632 "ripper.c" /* yacc.c:1646 */
9637  break;
9638 
9639  case 453:
9640 #line 3683 "ripper.y" /* yacc.c:1646 */
9641  {(yyval.vars) = dyna_push(p);}
9642 #line 9638 "ripper.c" /* yacc.c:1646 */
9643  break;
9644 
9645  case 454:
9646 #line 3684 "ripper.y" /* yacc.c:1646 */
9647  {
9648  (yyval.num) = p->max_numparam;
9649  p->max_numparam = 0;
9650  }
9651 #line 9647 "ripper.c" /* yacc.c:1646 */
9652  break;
9653 
9654  case 455:
9655 #line 3688 "ripper.y" /* yacc.c:1646 */
9656  {
9657  (yyval.node) = numparam_push(p);
9658  }
9659 #line 9655 "ripper.c" /* yacc.c:1646 */
9660  break;
9661 
9662  case 456:
9663 #line 3692 "ripper.y" /* yacc.c:1646 */
9664  {
9665  int max_numparam = p->max_numparam;
9666  p->max_numparam = (yyvsp[-3].num);
9667  (yyvsp[-1].val) = args_with_numbered(p, (yyvsp[-1].val), max_numparam);
9668 #if 0
9669  (yyval.val) = NEW_ITER((yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9670 #endif
9671  {VALUE v1,v2,v3;v1=escape_Qundef((yyvsp[-1].val));v2=(yyvsp[0].val);v3=dispatch2(brace_block,v1,v2);(yyval.val)=v3;}
9672  numparam_pop(p, (yyvsp[-2].node));
9673  dyna_pop(p, (yyvsp[-4].vars));
9674  }
9675 #line 9671 "ripper.c" /* yacc.c:1646 */
9676  break;
9677 
9678  case 457:
9679 #line 3705 "ripper.y" /* yacc.c:1646 */
9680  {(yyval.vars) = dyna_push(p);}
9681 #line 9677 "ripper.c" /* yacc.c:1646 */
9682  break;
9683 
9684  case 458:
9685 #line 3706 "ripper.y" /* yacc.c:1646 */
9686  {
9687  (yyval.num) = p->max_numparam;
9688  p->max_numparam = 0;
9689  }
9690 #line 9686 "ripper.c" /* yacc.c:1646 */
9691  break;
9692 
9693  case 459:
9694 #line 3710 "ripper.y" /* yacc.c:1646 */
9695  {
9696  (yyval.node) = numparam_push(p);
9697  CMDARG_PUSH(0);
9698  }
9699 #line 9695 "ripper.c" /* yacc.c:1646 */
9700  break;
9701 
9702  case 460:
9703 #line 3715 "ripper.y" /* yacc.c:1646 */
9704  {
9705  int max_numparam = p->max_numparam;
9706  p->max_numparam = (yyvsp[-3].num);
9707  (yyvsp[-1].val) = args_with_numbered(p, (yyvsp[-1].val), max_numparam);
9708 #if 0
9709  (yyval.val) = NEW_ITER((yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9710 #endif
9711  {VALUE v1,v2,v3;v1=escape_Qundef((yyvsp[-1].val));v2=(yyvsp[0].val);v3=dispatch2(do_block,v1,v2);(yyval.val)=v3;}
9712  CMDARG_POP();
9713  numparam_pop(p, (yyvsp[-2].node));
9714  dyna_pop(p, (yyvsp[-4].vars));
9715  }
9716 #line 9712 "ripper.c" /* yacc.c:1646 */
9717  break;
9718 
9719  case 461:
9720 #line 3730 "ripper.y" /* yacc.c:1646 */
9721  {
9722 #if 0
9723  check_literal_when(p, (yyvsp[0].val), &(yylsp[0]));
9724  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
9725 #endif
9726  {VALUE v1,v2,v3,v4;v1=dispatch0(args_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(args_add,v2,v3);(yyval.val)=v4;}
9727  }
9728 #line 9724 "ripper.c" /* yacc.c:1646 */
9729  break;
9730 
9731  case 462:
9732 #line 3738 "ripper.y" /* yacc.c:1646 */
9733  {
9734 #if 0
9735  (yyval.val) = NEW_SPLAT((yyvsp[0].val), &(yyloc));
9736 #endif
9737  {VALUE v1,v2,v3,v4;v1=dispatch0(args_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(args_add_star,v2,v3);(yyval.val)=v4;}
9738  }
9739 #line 9735 "ripper.c" /* yacc.c:1646 */
9740  break;
9741 
9742  case 463:
9743 #line 3745 "ripper.y" /* yacc.c:1646 */
9744  {
9745 #if 0
9746  check_literal_when(p, (yyvsp[0].val), &(yylsp[0]));
9747  (yyval.val) = last_arg_append(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
9748 #endif
9749  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(args_add,v1,v2);(yyval.val)=v3;}
9750  }
9751 #line 9747 "ripper.c" /* yacc.c:1646 */
9752  break;
9753 
9754  case 464:
9755 #line 3753 "ripper.y" /* yacc.c:1646 */
9756  {
9757 #if 0
9758  (yyval.val) = rest_arg_append(p, (yyvsp[-3].val), (yyvsp[0].val), &(yyloc));
9759 #endif
9760  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=(yyvsp[0].val);v3=dispatch2(args_add_star,v1,v2);(yyval.val)=v3;}
9761  }
9762 #line 9758 "ripper.c" /* yacc.c:1646 */
9763  break;
9764 
9765  case 465:
9766 #line 3764 "ripper.y" /* yacc.c:1646 */
9767  {
9768 #if 0
9769  (yyval.val) = NEW_WHEN((yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9770  fixpos((yyval.val), (yyvsp[-3].val));
9771 #endif
9772  {VALUE v1,v2,v3,v4;v1=(yyvsp[-3].val);v2=(yyvsp[-1].val);v3=escape_Qundef((yyvsp[0].val));v4=dispatch3(when,v1,v2,v3);(yyval.val)=v4;}
9773  }
9774 #line 9770 "ripper.c" /* yacc.c:1646 */
9775  break;
9776 
9777  case 468:
9778 #line 3778 "ripper.y" /* yacc.c:1646 */
9779  {
9780  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
9781  p->command_start = FALSE;
9782  (yyval.num) = p->in_kwarg;
9783  p->in_kwarg = 1;
9784  }
9785 #line 9781 "ripper.c" /* yacc.c:1646 */
9786  break;
9787 
9788  case 469:
9789 #line 3784 "ripper.y" /* yacc.c:1646 */
9790  {(yyval.tbl) = push_pvtbl(p);}
9791 #line 9787 "ripper.c" /* yacc.c:1646 */
9792  break;
9793 
9794  case 470:
9795 #line 3785 "ripper.y" /* yacc.c:1646 */
9796  {(yyval.tbl) = push_pktbl(p);}
9797 #line 9793 "ripper.c" /* yacc.c:1646 */
9798  break;
9799 
9800  case 471:
9801 #line 3787 "ripper.y" /* yacc.c:1646 */
9802  {pop_pktbl(p, (yyvsp[-2].tbl));}
9803 #line 9799 "ripper.c" /* yacc.c:1646 */
9804  break;
9805 
9806  case 472:
9807 #line 3788 "ripper.y" /* yacc.c:1646 */
9808  {pop_pvtbl(p, (yyvsp[-4].tbl));}
9809 #line 9805 "ripper.c" /* yacc.c:1646 */
9810  break;
9811 
9812  case 473:
9813 #line 3789 "ripper.y" /* yacc.c:1646 */
9814  {
9815  p->in_kwarg = !!(yyvsp[-6].num);
9816  }
9817 #line 9813 "ripper.c" /* yacc.c:1646 */
9818  break;
9819 
9820  case 474:
9821 #line 3794 "ripper.y" /* yacc.c:1646 */
9822  {
9823 #if 0
9824  (yyval.val) = NEW_IN((yyvsp[-6].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9825 #endif
9826  {VALUE v1,v2,v3,v4;v1=(yyvsp[-6].val);v2=(yyvsp[-1].val);v3=escape_Qundef((yyvsp[0].val));v4=dispatch3(in,v1,v2,v3);(yyval.val)=v4;}
9827  }
9828 #line 9824 "ripper.c" /* yacc.c:1646 */
9829  break;
9830 
9831  case 478:
9832 #line 3808 "ripper.y" /* yacc.c:1646 */
9833  {
9834 #if 0
9835  (yyval.val) = new_if(p, (yyvsp[0].val), remove_begin((yyvsp[-2].val)), 0, &(yyloc));
9836  fixpos((yyval.val), (yyvsp[0].val));
9837 #endif
9838  {VALUE v1,v2,v3;v1=(yyvsp[0].val);v2=(yyvsp[-2].val);v3=dispatch2(if_mod,v1,v2);(yyval.val)=v3;}
9839  }
9840 #line 9836 "ripper.c" /* yacc.c:1646 */
9841  break;
9842 
9843  case 479:
9844 #line 3816 "ripper.y" /* yacc.c:1646 */
9845  {
9846 #if 0
9847  (yyval.val) = new_unless(p, (yyvsp[0].val), remove_begin((yyvsp[-2].val)), 0, &(yyloc));
9848  fixpos((yyval.val), (yyvsp[0].val));
9849 #endif
9850  {VALUE v1,v2,v3;v1=(yyvsp[0].val);v2=(yyvsp[-2].val);v3=dispatch2(unless_mod,v1,v2);(yyval.val)=v3;}
9851  }
9852 #line 9848 "ripper.c" /* yacc.c:1646 */
9853  break;
9854 
9855  case 481:
9856 #line 3827 "ripper.y" /* yacc.c:1646 */
9857  {
9858  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, 0, Qnone, &(yyloc));
9859  (yyval.val) = new_array_pattern(p, Qnone, get_value((yyvsp[-1].val)), (yyval.val), &(yyloc));
9860  }
9861 #line 9857 "ripper.c" /* yacc.c:1646 */
9862  break;
9863 
9864  case 482:
9865 #line 3832 "ripper.y" /* yacc.c:1646 */
9866  {
9867  (yyval.val) = new_array_pattern(p, Qnone, get_value((yyvsp[-2].val)), (yyvsp[0].val), &(yyloc));
9868 #if 0
9869  nd_set_first_loc((yyval.val), (yylsp[-2]).beg_pos);
9870 #endif
9871 
9872  }
9873 #line 9869 "ripper.c" /* yacc.c:1646 */
9874  break;
9875 
9876  case 483:
9877 #line 3840 "ripper.y" /* yacc.c:1646 */
9878  {
9879  (yyval.val) = new_array_pattern(p, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9880  }
9881 #line 9877 "ripper.c" /* yacc.c:1646 */
9882  break;
9883 
9884  case 484:
9885 #line 3844 "ripper.y" /* yacc.c:1646 */
9886  {
9887  (yyval.val) = new_hash_pattern(p, Qnone, (yyvsp[0].val), &(yyloc));
9888  }
9889 #line 9885 "ripper.c" /* yacc.c:1646 */
9890  break;
9891 
9892  case 486:
9893 #line 3853 "ripper.y" /* yacc.c:1646 */
9894  {
9895 #if 0
9896  NODE *n = NEW_LIST((yyvsp[-2].val), &(yyloc));
9897  n = list_append(p, n, (yyvsp[0].val));
9898  (yyval.val) = new_hash(p, n, &(yyloc));
9899 #endif
9900  {VALUE v1,v2,v3,v4;v1=(yyvsp[-2].val);v2=STATIC_ID2SYM(id_assoc);v3=(yyvsp[0].val);v4=dispatch3(binary,v1,v2,v3);(yyval.val)=v4;}
9901  }
9902 #line 9898 "ripper.c" /* yacc.c:1646 */
9903  break;
9904 
9905  case 488:
9906 #line 3865 "ripper.y" /* yacc.c:1646 */
9907  {
9908 #if 0
9909  (yyval.val) = NEW_NODE(NODE_OR, (yyvsp[-2].val), (yyvsp[0].val), 0, &(yyloc));
9910 #endif
9911  {VALUE v1,v2,v3,v4;v1=(yyvsp[-2].val);v2=STATIC_ID2SYM(idOr);v3=(yyvsp[0].val);v4=dispatch3(binary,v1,v2,v3);(yyval.val)=v4;}
9912  }
9913 #line 9909 "ripper.c" /* yacc.c:1646 */
9914  break;
9915 
9916  case 490:
9917 #line 3874 "ripper.y" /* yacc.c:1646 */
9918  {(yyval.tbl) = push_pktbl(p);}
9919 #line 9915 "ripper.c" /* yacc.c:1646 */
9920  break;
9921 
9922  case 491:
9923 #line 3875 "ripper.y" /* yacc.c:1646 */
9924  {(yyval.tbl) = push_pktbl(p);}
9925 #line 9921 "ripper.c" /* yacc.c:1646 */
9926  break;
9927 
9928  case 493:
9929 #line 3879 "ripper.y" /* yacc.c:1646 */
9930  {
9931  pop_pktbl(p, (yyvsp[-2].tbl));
9932  (yyval.val) = new_array_pattern(p, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), &(yyloc));
9933 #if 0
9934  nd_set_first_loc((yyval.val), (yylsp[-3]).beg_pos);
9935 #endif
9936 
9937  }
9938 #line 9934 "ripper.c" /* yacc.c:1646 */
9939  break;
9940 
9941  case 494:
9942 #line 3888 "ripper.y" /* yacc.c:1646 */
9943  {
9944  pop_pktbl(p, (yyvsp[-2].tbl));
9945  (yyval.val) = new_hash_pattern(p, (yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
9946 #if 0
9947  nd_set_first_loc((yyval.val), (yylsp[-3]).beg_pos);
9948 #endif
9949 
9950  }
9951 #line 9947 "ripper.c" /* yacc.c:1646 */
9952  break;
9953 
9954  case 495:
9955 #line 3897 "ripper.y" /* yacc.c:1646 */
9956  {
9957  (yyval.val) = new_array_pattern_tail(p, Qnone, 0, 0, Qnone, &(yyloc));
9958  (yyval.val) = new_array_pattern(p, (yyvsp[-2].val), Qnone, (yyval.val), &(yyloc));
9959  }
9960 #line 9956 "ripper.c" /* yacc.c:1646 */
9961  break;
9962 
9963  case 496:
9964 #line 3902 "ripper.y" /* yacc.c:1646 */
9965  {
9966  pop_pktbl(p, (yyvsp[-2].tbl));
9967  (yyval.val) = new_array_pattern(p, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), &(yyloc));
9968 #if 0
9969  nd_set_first_loc((yyval.val), (yylsp[-3]).beg_pos);
9970 #endif
9971 
9972  }
9973 #line 9969 "ripper.c" /* yacc.c:1646 */
9974  break;
9975 
9976  case 497:
9977 #line 3911 "ripper.y" /* yacc.c:1646 */
9978  {
9979  pop_pktbl(p, (yyvsp[-2].tbl));
9980  (yyval.val) = new_hash_pattern(p, (yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
9981 #if 0
9982  nd_set_first_loc((yyval.val), (yylsp[-3]).beg_pos);
9983 #endif
9984 
9985  }
9986 #line 9982 "ripper.c" /* yacc.c:1646 */
9987  break;
9988 
9989  case 498:
9990 #line 3920 "ripper.y" /* yacc.c:1646 */
9991  {
9992  (yyval.val) = new_array_pattern_tail(p, Qnone, 0, 0, Qnone, &(yyloc));
9993  (yyval.val) = new_array_pattern(p, (yyvsp[-2].val), Qnone, (yyval.val), &(yyloc));
9994  }
9995 #line 9991 "ripper.c" /* yacc.c:1646 */
9996  break;
9997 
9998  case 499:
9999 #line 3924 "ripper.y" /* yacc.c:1646 */
10000  {(yyval.tbl) = push_pktbl(p);}
10001 #line 9997 "ripper.c" /* yacc.c:1646 */
10002  break;
10003 
10004  case 500:
10005 #line 3925 "ripper.y" /* yacc.c:1646 */
10006  {
10007  pop_pktbl(p, (yyvsp[-2].tbl));
10008  (yyval.val) = new_array_pattern(p, Qnone, Qnone, (yyvsp[-1].val), &(yyloc));
10009  }
10010 #line 10006 "ripper.c" /* yacc.c:1646 */
10011  break;
10012 
10013  case 501:
10014 #line 3930 "ripper.y" /* yacc.c:1646 */
10015  {
10016  (yyval.val) = new_array_pattern_tail(p, Qnone, 0, 0, Qnone, &(yyloc));
10017  (yyval.val) = new_array_pattern(p, Qnone, Qnone, (yyval.val), &(yyloc));
10018  }
10019 #line 10015 "ripper.c" /* yacc.c:1646 */
10020  break;
10021 
10022  case 502:
10023 #line 3935 "ripper.y" /* yacc.c:1646 */
10024  {
10025  (yyval.tbl) = push_pktbl(p);
10026  (yyvsp[0].num) = p->in_kwarg;
10027  p->in_kwarg = 0;
10028  }
10029 #line 10025 "ripper.c" /* yacc.c:1646 */
10030  break;
10031 
10032  case 503:
10033 #line 3941 "ripper.y" /* yacc.c:1646 */
10034  {
10035  pop_pktbl(p, (yyvsp[-2].tbl));
10036  p->in_kwarg = (yyvsp[-3].num);
10037  (yyval.val) = new_hash_pattern(p, Qnone, (yyvsp[-1].val), &(yyloc));
10038  }
10039 #line 10035 "ripper.c" /* yacc.c:1646 */
10040  break;
10041 
10042  case 504:
10043 #line 3947 "ripper.y" /* yacc.c:1646 */
10044  {
10045  (yyval.val) = new_hash_pattern_tail(p, Qnone, 0, &(yyloc));
10046  (yyval.val) = new_hash_pattern(p, Qnone, (yyval.val), &(yyloc));
10047  }
10048 #line 10044 "ripper.c" /* yacc.c:1646 */
10049  break;
10050 
10051  case 505:
10052 #line 3951 "ripper.y" /* yacc.c:1646 */
10053  {(yyval.tbl) = push_pktbl(p);}
10054 #line 10050 "ripper.c" /* yacc.c:1646 */
10055  break;
10056 
10057  case 506:
10058 #line 3952 "ripper.y" /* yacc.c:1646 */
10059  {
10060  pop_pktbl(p, (yyvsp[-2].tbl));
10061  (yyval.val) = (yyvsp[-1].val);
10062  }
10063 #line 10059 "ripper.c" /* yacc.c:1646 */
10064  break;
10065 
10066  case 507:
10067 #line 3959 "ripper.y" /* yacc.c:1646 */
10068  {
10069 #if 0
10070  NODE *pre_args = NEW_LIST((yyvsp[0].val), &(yyloc));
10071  (yyval.val) = new_array_pattern_tail(p, pre_args, 0, 0, Qnone, &(yyloc));
10072 #endif
10073  (yyval.val) = new_array_pattern_tail(p, rb_ary_new_from_args(1, get_value((yyvsp[0].val))), 0, 0, Qnone, &(yyloc));
10074 
10075  }
10076 #line 10072 "ripper.c" /* yacc.c:1646 */
10077  break;
10078 
10079  case 508:
10080 #line 3968 "ripper.y" /* yacc.c:1646 */
10081  {
10082  (yyval.val) = new_array_pattern_tail(p, (yyvsp[0].val), 1, 0, Qnone, &(yyloc));
10083  }
10084 #line 10080 "ripper.c" /* yacc.c:1646 */
10085  break;
10086 
10087  case 509:
10088 #line 3972 "ripper.y" /* yacc.c:1646 */
10089  {
10090 #if 0
10091  (yyval.val) = new_array_pattern_tail(p, list_concat((yyvsp[-1].val), (yyvsp[0].val)), 0, 0, Qnone, &(yyloc));
10092 #endif
10093  VALUE pre_args = rb_ary_concat((yyvsp[-1].val), get_value((yyvsp[0].val)));
10094  (yyval.val) = new_array_pattern_tail(p, pre_args, 0, 0, Qnone, &(yyloc));
10095 
10096  }
10097 #line 10093 "ripper.c" /* yacc.c:1646 */
10098  break;
10099 
10100  case 510:
10101 #line 3981 "ripper.y" /* yacc.c:1646 */
10102  {
10103  (yyval.val) = new_array_pattern_tail(p, (yyvsp[-2].val), 1, (yyvsp[0].val), Qnone, &(yyloc));
10104  }
10105 #line 10101 "ripper.c" /* yacc.c:1646 */
10106  break;
10107 
10108  case 511:
10109 #line 3985 "ripper.y" /* yacc.c:1646 */
10110  {
10111  (yyval.val) = new_array_pattern_tail(p, (yyvsp[-4].val), 1, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10112  }
10113 #line 10109 "ripper.c" /* yacc.c:1646 */
10114  break;
10115 
10116  case 512:
10117 #line 3989 "ripper.y" /* yacc.c:1646 */
10118  {
10119  (yyval.val) = new_array_pattern_tail(p, (yyvsp[-1].val), 1, 0, Qnone, &(yyloc));
10120  }
10121 #line 10117 "ripper.c" /* yacc.c:1646 */
10122  break;
10123 
10124  case 513:
10125 #line 3993 "ripper.y" /* yacc.c:1646 */
10126  {
10127  (yyval.val) = new_array_pattern_tail(p, (yyvsp[-3].val), 1, 0, (yyvsp[0].val), &(yyloc));
10128  }
10129 #line 10125 "ripper.c" /* yacc.c:1646 */
10130  break;
10131 
10132  case 515:
10133 #line 4000 "ripper.y" /* yacc.c:1646 */
10134  {
10135  (yyval.val) = (yyvsp[-1].val);
10136  }
10137 #line 10133 "ripper.c" /* yacc.c:1646 */
10138  break;
10139 
10140  case 516:
10141 #line 4004 "ripper.y" /* yacc.c:1646 */
10142  {
10143 #if 0
10144  (yyval.val) = list_concat((yyvsp[-2].val), (yyvsp[-1].val));
10145 #endif
10146  (yyval.val)=rb_ary_concat((yyvsp[-2].val), get_value((yyvsp[-1].val)));
10147  }
10148 #line 10144 "ripper.c" /* yacc.c:1646 */
10149  break;
10150 
10151  case 517:
10152 #line 4013 "ripper.y" /* yacc.c:1646 */
10153  {
10154  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, (yyvsp[0].val), Qnone, &(yyloc));
10155  }
10156 #line 10152 "ripper.c" /* yacc.c:1646 */
10157  break;
10158 
10159  case 518:
10160 #line 4017 "ripper.y" /* yacc.c:1646 */
10161  {
10162  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10163  }
10164 #line 10160 "ripper.c" /* yacc.c:1646 */
10165  break;
10166 
10167  case 519:
10168 #line 4021 "ripper.y" /* yacc.c:1646 */
10169  {
10170  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, 0, Qnone, &(yyloc));
10171  }
10172 #line 10168 "ripper.c" /* yacc.c:1646 */
10173  break;
10174 
10175  case 520:
10176 #line 4025 "ripper.y" /* yacc.c:1646 */
10177  {
10178  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, 0, (yyvsp[0].val), &(yyloc));
10179  }
10180 #line 10176 "ripper.c" /* yacc.c:1646 */
10181  break;
10182 
10183  case 522:
10184 #line 4032 "ripper.y" /* yacc.c:1646 */
10185  {
10186 #if 0
10187  (yyval.val) = list_concat((yyvsp[-2].val), (yyvsp[0].val));
10188 #endif
10189  (yyval.val)=rb_ary_concat((yyvsp[-2].val), get_value((yyvsp[0].val)));
10190  }
10191 #line 10187 "ripper.c" /* yacc.c:1646 */
10192  break;
10193 
10194  case 523:
10195 #line 4041 "ripper.y" /* yacc.c:1646 */
10196  {
10197 #if 0
10198  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
10199 #endif
10200  (yyval.val)=rb_ary_new_from_args(1, get_value((yyvsp[0].val)));
10201  }
10202 #line 10198 "ripper.c" /* yacc.c:1646 */
10203  break;
10204 
10205  case 524:
10206 #line 4050 "ripper.y" /* yacc.c:1646 */
10207  {
10208  (yyval.val) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[-2].val), &(yyloc)), (yyvsp[0].val), &(yyloc));
10209  }
10210 #line 10206 "ripper.c" /* yacc.c:1646 */
10211  break;
10212 
10213  case 525:
10214 #line 4054 "ripper.y" /* yacc.c:1646 */
10215  {
10216  (yyval.val) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[0].val), &(yyloc)), 0, &(yyloc));
10217  }
10218 #line 10214 "ripper.c" /* yacc.c:1646 */
10219  break;
10220 
10221  case 526:
10222 #line 4058 "ripper.y" /* yacc.c:1646 */
10223  {
10224  (yyval.val) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[-1].val), &(yyloc)), 0, &(yyloc));
10225  }
10226 #line 10222 "ripper.c" /* yacc.c:1646 */
10227  break;
10228 
10229  case 527:
10230 #line 4062 "ripper.y" /* yacc.c:1646 */
10231  {
10232  (yyval.val) = new_hash_pattern_tail(p, new_hash(p, Qnone, &(yyloc)), (yyvsp[0].val), &(yyloc));
10233  }
10234 #line 10230 "ripper.c" /* yacc.c:1646 */
10235  break;
10236 
10237  case 528:
10238 #line 4066 "ripper.y" /* yacc.c:1646 */
10239  {
10240  (yyval.val) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[-2].val), &(yyloc)), ID2VAL(idNil), &(yyloc));
10241  }
10242 #line 10238 "ripper.c" /* yacc.c:1646 */
10243  break;
10244 
10245  case 529:
10246 #line 4070 "ripper.y" /* yacc.c:1646 */
10247  {
10248  (yyval.val) = new_hash_pattern_tail(p, new_hash(p, Qnone, &(yyloc)), ID2VAL(idNil), &(yyloc));
10249  }
10250 #line 10246 "ripper.c" /* yacc.c:1646 */
10251  break;
10252 
10253  case 530:
10254 #line 4076 "ripper.y" /* yacc.c:1646 */
10255  {(yyval.val)=rb_ary_new_from_args(1, (yyvsp[0].val));}
10256 #line 10252 "ripper.c" /* yacc.c:1646 */
10257  break;
10258 
10259  case 531:
10260 #line 4078 "ripper.y" /* yacc.c:1646 */
10261  {
10262 #if 0
10263  (yyval.val) = list_concat((yyvsp[-2].val), (yyvsp[0].val));
10264 #endif
10265  (yyval.val)=rb_ary_push((yyvsp[-2].val), (yyvsp[0].val));
10266  }
10267 #line 10263 "ripper.c" /* yacc.c:1646 */
10268  break;
10269 
10270  case 532:
10271 #line 4087 "ripper.y" /* yacc.c:1646 */
10272  {
10273  error_duplicate_pattern_key(p, get_id((yyvsp[-1].val)), &(yylsp[-1]));
10274 #if 0
10275  (yyval.val) = list_append(p, NEW_LIST(NEW_LIT(ID2SYM((yyvsp[-1].val)), &(yyloc)), &(yyloc)), (yyvsp[0].val));
10276 #endif
10277  (yyval.val)=rb_ary_new_from_args(2, get_value((yyvsp[-1].val)), get_value((yyvsp[0].val)));
10278  }
10279 #line 10275 "ripper.c" /* yacc.c:1646 */
10280  break;
10281 
10282  case 533:
10283 #line 4095 "ripper.y" /* yacc.c:1646 */
10284  {
10285  error_duplicate_pattern_key(p, get_id((yyvsp[0].val)), &(yylsp[0]));
10286  if ((yyvsp[0].val) && !is_local_id(get_id((yyvsp[0].val)))) {
10287  yyerror1(&(yylsp[0]), "key must be valid as local variables");
10288  }
10289  error_duplicate_pattern_variable(p, get_id((yyvsp[0].val)), &(yylsp[0]));
10290 #if 0
10291  (yyval.val) = list_append(p, NEW_LIST(NEW_LIT(ID2SYM((yyvsp[0].val)), &(yyloc)), &(yyloc)), assignable(p, (yyvsp[0].val), 0, &(yyloc)));
10292 #endif
10293  (yyval.val)=rb_ary_new_from_args(2, get_value((yyvsp[0].val)), Qnil);
10294  }
10295 #line 10291 "ripper.c" /* yacc.c:1646 */
10296  break;
10297 
10298  case 535:
10299 #line 4110 "ripper.y" /* yacc.c:1646 */
10300  {
10301  YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
10302 #if 0
10303  if (!(yyvsp[-1].val) || nd_type((yyvsp[-1].val)) == NODE_STR) {
10304  NODE *node = dsym_node(p, (yyvsp[-1].val), &loc);
10305  (yyval.val) = SYM2ID(node->nd_lit);
10306  }
10307 #endif
10308  if (ripper_is_node_yylval((yyvsp[-1].val)) && RNODE((yyvsp[-1].val))->nd_cval) {
10309  VALUE label = RNODE((yyvsp[-1].val))->nd_cval;
10310  VALUE rval = RNODE((yyvsp[-1].val))->nd_rval;
10311  (yyval.val) = ripper_new_yylval(p, rb_intern_str(label), rval, label);
10312  RNODE((yyval.val))->nd_loc = loc;
10313  }
10314 
10315  else {
10316  yyerror1(&loc, "symbol literal with interpolation is not allowed");
10317  (yyval.val) = 0;
10318  }
10319  }
10320 #line 10316 "ripper.c" /* yacc.c:1646 */
10321  break;
10322 
10323  case 536:
10324 #line 4133 "ripper.y" /* yacc.c:1646 */
10325  {
10326  (yyval.val) = (yyvsp[0].val);
10327  }
10328 #line 10324 "ripper.c" /* yacc.c:1646 */
10329  break;
10330 
10331  case 537:
10332 #line 4137 "ripper.y" /* yacc.c:1646 */
10333  {
10334  (yyval.val) = 0;
10335  }
10336 #line 10332 "ripper.c" /* yacc.c:1646 */
10337  break;
10338 
10339  case 538:
10340 #line 4143 "ripper.y" /* yacc.c:1646 */
10341  {
10342  (yyval.val) = 0;
10343  }
10344 #line 10340 "ripper.c" /* yacc.c:1646 */
10345  break;
10346 
10347  case 540:
10348 #line 4150 "ripper.y" /* yacc.c:1646 */
10349  {
10350 #if 0
10351  value_expr((yyvsp[-2].val));
10352  value_expr((yyvsp[0].val));
10353  (yyval.val) = NEW_DOT2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10354 #endif
10355  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
10356  }
10357 #line 10353 "ripper.c" /* yacc.c:1646 */
10358  break;
10359 
10360  case 541:
10361 #line 4159 "ripper.y" /* yacc.c:1646 */
10362  {
10363 #if 0
10364  value_expr((yyvsp[-2].val));
10365  value_expr((yyvsp[0].val));
10366  (yyval.val) = NEW_DOT3((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10367 #endif
10368  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
10369  }
10370 #line 10366 "ripper.c" /* yacc.c:1646 */
10371  break;
10372 
10373  case 542:
10374 #line 4168 "ripper.y" /* yacc.c:1646 */
10375  {
10376 #if 0
10377  YYLTYPE loc;
10378  loc.beg_pos = (yylsp[0]).end_pos;
10379  loc.end_pos = (yylsp[0]).end_pos;
10380 
10381  value_expr((yyvsp[-1].val));
10382  (yyval.val) = NEW_DOT2((yyvsp[-1].val), new_nil(&loc), &(yyloc));
10383 #endif
10384  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
10385  }
10386 #line 10382 "ripper.c" /* yacc.c:1646 */
10387  break;
10388 
10389  case 543:
10390 #line 4180 "ripper.y" /* yacc.c:1646 */
10391  {
10392 #if 0
10393  YYLTYPE loc;
10394  loc.beg_pos = (yylsp[0]).end_pos;
10395  loc.end_pos = (yylsp[0]).end_pos;
10396 
10397  value_expr((yyvsp[-1].val));
10398  (yyval.val) = NEW_DOT3((yyvsp[-1].val), new_nil(&loc), &(yyloc));
10399 #endif
10400  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
10401  }
10402 #line 10398 "ripper.c" /* yacc.c:1646 */
10403  break;
10404 
10405  case 547:
10406 #line 4195 "ripper.y" /* yacc.c:1646 */
10407  {
10408 #if 0
10409  YYLTYPE loc;
10410  loc.beg_pos = (yylsp[-1]).beg_pos;
10411  loc.end_pos = (yylsp[-1]).beg_pos;
10412 
10413  value_expr((yyvsp[0].val));
10414  (yyval.val) = NEW_DOT2(new_nil(&loc), (yyvsp[0].val), &(yyloc));
10415 #endif
10416  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[0].val);v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
10417  }
10418 #line 10414 "ripper.c" /* yacc.c:1646 */
10419  break;
10420 
10421  case 548:
10422 #line 4207 "ripper.y" /* yacc.c:1646 */
10423  {
10424 #if 0
10425  YYLTYPE loc;
10426  loc.beg_pos = (yylsp[-1]).beg_pos;
10427  loc.end_pos = (yylsp[-1]).beg_pos;
10428 
10429  value_expr((yyvsp[0].val));
10430  (yyval.val) = NEW_DOT3(new_nil(&loc), (yyvsp[0].val), &(yyloc));
10431 #endif
10432  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[0].val);v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
10433  }
10434 #line 10430 "ripper.c" /* yacc.c:1646 */
10435  break;
10436 
10437  case 557:
10438 #line 4229 "ripper.y" /* yacc.c:1646 */
10439  {
10440 #if 0
10441  if (!((yyval.val) = gettable(p, (yyvsp[0].val), &(yyloc)))) (yyval.val) = NEW_BEGIN(0, &(yyloc));
10442 #endif
10443  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
10444  }
10445 #line 10441 "ripper.c" /* yacc.c:1646 */
10446  break;
10447 
10448  case 558:
10449 #line 4236 "ripper.y" /* yacc.c:1646 */
10450  {
10451  token_info_push(p, "->", &(yylsp[0]));
10452  }
10453 #line 10449 "ripper.c" /* yacc.c:1646 */
10454  break;
10455 
10456  case 559:
10457 #line 4240 "ripper.y" /* yacc.c:1646 */
10458  {
10459  (yyval.val) = (yyvsp[0].val);
10460 #if 0
10461  nd_set_first_loc((yyval.val), (yylsp[-2]).beg_pos);
10462 #endif
10463  }
10464 #line 10460 "ripper.c" /* yacc.c:1646 */
10465  break;
10466 
10467  case 560:
10468 #line 4249 "ripper.y" /* yacc.c:1646 */
10469  {
10470 #if 0
10471  error_duplicate_pattern_variable(p, (yyvsp[0].val), &(yylsp[0]));
10472  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
10473 #endif
10474  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
10475  }
10476 #line 10472 "ripper.c" /* yacc.c:1646 */
10477  break;
10478 
10479  case 561:
10480 #line 4259 "ripper.y" /* yacc.c:1646 */
10481  {
10482 #if 0
10483  NODE *n = gettable(p, (yyvsp[0].val), &(yyloc));
10484  if (!(nd_type(n) == NODE_LVAR || nd_type(n) == NODE_DVAR)) {
10485  compile_error(p, "%"PRIsVALUE": no such local variable", rb_id2str((yyvsp[0].val)));
10486  }
10487  (yyval.val) = n;
10488 #endif
10489  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
10490  }
10491 #line 10487 "ripper.c" /* yacc.c:1646 */
10492  break;
10493 
10494  case 562:
10495 #line 4272 "ripper.y" /* yacc.c:1646 */
10496  {
10497 #if 0
10498  (yyval.val) = NEW_COLON3((yyvsp[0].val), &(yyloc));
10499 #endif
10500  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(top_const_ref,v1);(yyval.val)=v2;}
10501  }
10502 #line 10498 "ripper.c" /* yacc.c:1646 */
10503  break;
10504 
10505  case 563:
10506 #line 4279 "ripper.y" /* yacc.c:1646 */
10507  {
10508 #if 0
10509  (yyval.val) = NEW_COLON2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10510 #endif
10511  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(const_path_ref,v1,v2);(yyval.val)=v3;}
10512  }
10513 #line 10509 "ripper.c" /* yacc.c:1646 */
10514  break;
10515 
10516  case 564:
10517 #line 4286 "ripper.y" /* yacc.c:1646 */
10518  {
10519 #if 0
10520  (yyval.val) = gettable(p, (yyvsp[0].val), &(yyloc));
10521 #endif
10522  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
10523  }
10524 #line 10520 "ripper.c" /* yacc.c:1646 */
10525  break;
10526 
10527  case 565:
10528 #line 4297 "ripper.y" /* yacc.c:1646 */
10529  {
10530 #if 0
10531  (yyval.val) = NEW_RESBODY((yyvsp[-4].val),
10532  (yyvsp[-3].val) ? block_append(p, node_assign(p, (yyvsp[-3].val), NEW_ERRINFO(&(yylsp[-3])), &(yylsp[-3])), (yyvsp[-1].val)) : (yyvsp[-1].val),
10533  (yyvsp[0].val), &(yyloc));
10534  fixpos((yyval.val), (yyvsp[-4].val)?(yyvsp[-4].val):(yyvsp[-1].val));
10535 #endif
10536  {VALUE v1,v2,v3,v4,v5;v1=escape_Qundef((yyvsp[-4].val));v2=escape_Qundef((yyvsp[-3].val));v3=escape_Qundef((yyvsp[-1].val));v4=escape_Qundef((yyvsp[0].val));v5=dispatch4(rescue,v1,v2,v3,v4);(yyval.val)=v5;}
10537  }
10538 #line 10534 "ripper.c" /* yacc.c:1646 */
10539  break;
10540 
10541  case 567:
10542 #line 4310 "ripper.y" /* yacc.c:1646 */
10543  {
10544 #if 0
10545  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
10546 #endif
10547  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
10548  }
10549 #line 10545 "ripper.c" /* yacc.c:1646 */
10550  break;
10551 
10552  case 568:
10553 #line 4317 "ripper.y" /* yacc.c:1646 */
10554  {
10555 #if 0
10556  if (!((yyval.val) = splat_array((yyvsp[0].val)))) (yyval.val) = (yyvsp[0].val);
10557 #endif
10558  (yyval.val)=(yyvsp[0].val);
10559  }
10560 #line 10556 "ripper.c" /* yacc.c:1646 */
10561  break;
10562 
10563  case 570:
10564 #line 4327 "ripper.y" /* yacc.c:1646 */
10565  {
10566  (yyval.val) = (yyvsp[0].val);
10567  }
10568 #line 10564 "ripper.c" /* yacc.c:1646 */
10569  break;
10570 
10571  case 572:
10572 #line 4334 "ripper.y" /* yacc.c:1646 */
10573  {
10574 #if 0
10575  (yyval.val) = (yyvsp[0].val);
10576 #endif
10577  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(ensure,v1);(yyval.val)=v2;}
10578  }
10579 #line 10575 "ripper.c" /* yacc.c:1646 */
10580  break;
10581 
10582  case 576:
10583 #line 4348 "ripper.y" /* yacc.c:1646 */
10584  {
10585 #if 0
10586  NODE *node = (yyvsp[0].val);
10587  if (!node) {
10588  node = NEW_STR(STR_NEW0(), &(yyloc));
10589  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit);
10590  }
10591  else {
10592  node = evstr2dstr(p, node);
10593  }
10594  (yyval.val) = node;
10595 #endif
10596  (yyval.val)=(yyvsp[0].val);
10597  }
10598 #line 10594 "ripper.c" /* yacc.c:1646 */
10599  break;
10600 
10601  case 579:
10602 #line 4367 "ripper.y" /* yacc.c:1646 */
10603  {
10604 #if 0
10605  (yyval.val) = literal_concat(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10606 #endif
10607  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(string_concat,v1,v2);(yyval.val)=v3;}
10608  }
10609 #line 10605 "ripper.c" /* yacc.c:1646 */
10610  break;
10611 
10612  case 580:
10613 #line 4376 "ripper.y" /* yacc.c:1646 */
10614  {
10615 #if 0
10616  (yyval.val) = heredoc_dedent(p, (yyvsp[-1].val));
10617  if ((yyval.val)) nd_set_loc((yyval.val), &(yyloc));
10618 #endif
10619  {VALUE v1,v2;v1=heredoc_dedent(p, (yyvsp[-1].val));v2=dispatch1(string_literal,v1);(yyval.val)=v2;}
10620  }
10621 #line 10617 "ripper.c" /* yacc.c:1646 */
10622  break;
10623 
10624  case 581:
10625 #line 4386 "ripper.y" /* yacc.c:1646 */
10626  {
10627 #if 0
10628  (yyval.val) = new_xstring(p, heredoc_dedent(p, (yyvsp[-1].val)), &(yyloc));
10629 #endif
10630  {VALUE v1,v2;v1=heredoc_dedent(p, (yyvsp[-1].val));v2=dispatch1(xstring_literal,v1);(yyval.val)=v2;}
10631  }
10632 #line 10628 "ripper.c" /* yacc.c:1646 */
10633  break;
10634 
10635  case 582:
10636 #line 4395 "ripper.y" /* yacc.c:1646 */
10637  {
10638  (yyval.val) = new_regexp(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10639  }
10640 #line 10636 "ripper.c" /* yacc.c:1646 */
10641  break;
10642 
10643  case 583:
10644 #line 4401 "ripper.y" /* yacc.c:1646 */
10645  {
10646 #if 0
10647  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
10648 #endif
10649  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(array,v1);(yyval.val)=v2;}
10650  }
10651 #line 10647 "ripper.c" /* yacc.c:1646 */
10652  break;
10653 
10654  case 584:
10655 #line 4410 "ripper.y" /* yacc.c:1646 */
10656  {
10657 #if 0
10658  (yyval.val) = 0;
10659 #endif
10660  {VALUE v1;v1=dispatch0(words_new);(yyval.val)=v1;}
10661  }
10662 #line 10658 "ripper.c" /* yacc.c:1646 */
10663  break;
10664 
10665  case 585:
10666 #line 4417 "ripper.y" /* yacc.c:1646 */
10667  {
10668 #if 0
10669  (yyval.val) = list_append(p, (yyvsp[-2].val), evstr2dstr(p, (yyvsp[-1].val)));
10670 #endif
10671  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(words_add,v1,v2);(yyval.val)=v3;}
10672  }
10673 #line 10669 "ripper.c" /* yacc.c:1646 */
10674  break;
10675 
10676  case 586:
10677 #line 4426 "ripper.y" /* yacc.c:1646 */
10678  {{VALUE v1,v2,v3,v4;v1=dispatch0(word_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(word_add,v2,v3);(yyval.val)=v4;}}
10679 #line 10675 "ripper.c" /* yacc.c:1646 */
10680  break;
10681 
10682  case 587:
10683 #line 4428 "ripper.y" /* yacc.c:1646 */
10684  {
10685 #if 0
10686  (yyval.val) = literal_concat(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10687 #endif
10688  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(word_add,v1,v2);(yyval.val)=v3;}
10689  }
10690 #line 10686 "ripper.c" /* yacc.c:1646 */
10691  break;
10692 
10693  case 588:
10694 #line 4437 "ripper.y" /* yacc.c:1646 */
10695  {
10696 #if 0
10697  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
10698 #endif
10699  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(array,v1);(yyval.val)=v2;}
10700  }
10701 #line 10697 "ripper.c" /* yacc.c:1646 */
10702  break;
10703 
10704  case 589:
10705 #line 4446 "ripper.y" /* yacc.c:1646 */
10706  {
10707 #if 0
10708  (yyval.val) = 0;
10709 #endif
10710  {VALUE v1;v1=dispatch0(symbols_new);(yyval.val)=v1;}
10711  }
10712 #line 10708 "ripper.c" /* yacc.c:1646 */
10713  break;
10714 
10715  case 590:
10716 #line 4453 "ripper.y" /* yacc.c:1646 */
10717  {
10718 #if 0
10719  (yyval.val) = symbol_append(p, (yyvsp[-2].val), evstr2dstr(p, (yyvsp[-1].val)));
10720 #endif
10721  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(symbols_add,v1,v2);(yyval.val)=v3;}
10722  }
10723 #line 10719 "ripper.c" /* yacc.c:1646 */
10724  break;
10725 
10726  case 591:
10727 #line 4462 "ripper.y" /* yacc.c:1646 */
10728  {
10729 #if 0
10730  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
10731 #endif
10732  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(array,v1);(yyval.val)=v2;}
10733  }
10734 #line 10730 "ripper.c" /* yacc.c:1646 */
10735  break;
10736 
10737  case 592:
10738 #line 4471 "ripper.y" /* yacc.c:1646 */
10739  {
10740 #if 0
10741  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
10742 #endif
10743  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(array,v1);(yyval.val)=v2;}
10744  }
10745 #line 10741 "ripper.c" /* yacc.c:1646 */
10746  break;
10747 
10748  case 593:
10749 #line 4480 "ripper.y" /* yacc.c:1646 */
10750  {
10751 #if 0
10752  (yyval.val) = 0;
10753 #endif
10754  {VALUE v1;v1=dispatch0(qwords_new);(yyval.val)=v1;}
10755  }
10756 #line 10752 "ripper.c" /* yacc.c:1646 */
10757  break;
10758 
10759  case 594:
10760 #line 4487 "ripper.y" /* yacc.c:1646 */
10761  {
10762 #if 0
10763  (yyval.val) = list_append(p, (yyvsp[-2].val), (yyvsp[-1].val));
10764 #endif
10765  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(qwords_add,v1,v2);(yyval.val)=v3;}
10766  }
10767 #line 10763 "ripper.c" /* yacc.c:1646 */
10768  break;
10769 
10770  case 595:
10771 #line 4496 "ripper.y" /* yacc.c:1646 */
10772  {
10773 #if 0
10774  (yyval.val) = 0;
10775 #endif
10776  {VALUE v1;v1=dispatch0(qsymbols_new);(yyval.val)=v1;}
10777  }
10778 #line 10774 "ripper.c" /* yacc.c:1646 */
10779  break;
10780 
10781  case 596:
10782 #line 4503 "ripper.y" /* yacc.c:1646 */
10783  {
10784 #if 0
10785  (yyval.val) = symbol_append(p, (yyvsp[-2].val), (yyvsp[-1].val));
10786 #endif
10787  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(qsymbols_add,v1,v2);(yyval.val)=v3;}
10788  }
10789 #line 10785 "ripper.c" /* yacc.c:1646 */
10790  break;
10791 
10792  case 597:
10793 #line 4512 "ripper.y" /* yacc.c:1646 */
10794  {
10795 #if 0
10796  (yyval.val) = 0;
10797 #endif
10798  {VALUE v1;v1=dispatch0(string_content);(yyval.val)=v1;}
10799 #if 0
10800 #endif
10801  (yyval.val) = ripper_new_yylval(p, 0, (yyval.val), 0);
10802 
10803  }
10804 #line 10800 "ripper.c" /* yacc.c:1646 */
10805  break;
10806 
10807  case 598:
10808 #line 4523 "ripper.y" /* yacc.c:1646 */
10809  {
10810 #if 0
10811  (yyval.val) = literal_concat(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10812 #endif
10813  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(string_add,v1,v2);(yyval.val)=v3;}
10814 #if 0
10815 #endif
10816  if (ripper_is_node_yylval((yyvsp[-1].val)) && ripper_is_node_yylval((yyvsp[0].val)) &&
10817  !RNODE((yyvsp[-1].val))->nd_cval) {
10818  RNODE((yyvsp[-1].val))->nd_cval = RNODE((yyvsp[0].val))->nd_cval;
10819  RNODE((yyvsp[-1].val))->nd_rval = add_mark_object(p, (yyval.val));
10820  (yyval.val) = (yyvsp[-1].val);
10821  }
10822 
10823  }
10824 #line 10820 "ripper.c" /* yacc.c:1646 */
10825  break;
10826 
10827  case 599:
10828 #line 4541 "ripper.y" /* yacc.c:1646 */
10829  {
10830 #if 0
10831  (yyval.val) = 0;
10832 #endif
10833  {VALUE v1;v1=dispatch0(xstring_new);(yyval.val)=v1;}
10834  }
10835 #line 10831 "ripper.c" /* yacc.c:1646 */
10836  break;
10837 
10838  case 600:
10839 #line 4548 "ripper.y" /* yacc.c:1646 */
10840  {
10841 #if 0
10842  (yyval.val) = literal_concat(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10843 #endif
10844  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(xstring_add,v1,v2);(yyval.val)=v3;}
10845  }
10846 #line 10842 "ripper.c" /* yacc.c:1646 */
10847  break;
10848 
10849  case 601:
10850 #line 4557 "ripper.y" /* yacc.c:1646 */
10851  {
10852 #if 0
10853  (yyval.val) = 0;
10854 #endif
10855  {VALUE v1;v1=dispatch0(regexp_new);(yyval.val)=v1;}
10856 #if 0
10857 #endif
10858  (yyval.val) = ripper_new_yylval(p, 0, (yyval.val), 0);
10859 
10860  }
10861 #line 10857 "ripper.c" /* yacc.c:1646 */
10862  break;
10863 
10864  case 602:
10865 #line 4568 "ripper.y" /* yacc.c:1646 */
10866  {
10867 #if 0
10868  NODE *head = (yyvsp[-1].val), *tail = (yyvsp[0].val);
10869  if (!head) {
10870  (yyval.val) = tail;
10871  }
10872  else if (!tail) {
10873  (yyval.val) = head;
10874  }
10875  else {
10876  switch (nd_type(head)) {
10877  case NODE_STR:
10878  nd_set_type(head, NODE_DSTR);
10879  break;
10880  case NODE_DSTR:
10881  break;
10882  default:
10883  head = list_append(p, NEW_DSTR(Qnil, &(yyloc)), head);
10884  break;
10885  }
10886  (yyval.val) = list_append(p, head, tail);
10887  }
10888 #endif
10889  VALUE s1 = 1, s2 = 0, n1 = (yyvsp[-1].val), n2 = (yyvsp[0].val);
10890  if (ripper_is_node_yylval(n1)) {
10891  s1 = RNODE(n1)->nd_cval;
10892  n1 = RNODE(n1)->nd_rval;
10893  }
10894  if (ripper_is_node_yylval(n2)) {
10895  s2 = RNODE(n2)->nd_cval;
10896  n2 = RNODE(n2)->nd_rval;
10897  }
10898  (yyval.val) = dispatch2(regexp_add, n1, n2);
10899  if (!s1 && s2) {
10900  (yyval.val) = ripper_new_yylval(p, 0, (yyval.val), s2);
10901  }
10902 
10903  }
10904 #line 10900 "ripper.c" /* yacc.c:1646 */
10905  break;
10906 
10907  case 603:
10908 #line 4609 "ripper.y" /* yacc.c:1646 */
10909  {(yyval.val)=ripper_new_yylval(p, 0, get_value((yyvsp[0].val)), (yyvsp[0].val));}
10910 #line 10906 "ripper.c" /* yacc.c:1646 */
10911  break;
10912 
10913  case 604:
10914 #line 4611 "ripper.y" /* yacc.c:1646 */
10915  {
10916  /* need to backup p->lex.strterm so that a string literal `%&foo,#$&,bar&` can be parsed */
10917  (yyval.strterm) = p->lex.strterm;
10918  p->lex.strterm = 0;
10919  SET_LEX_STATE(EXPR_BEG);
10920  }
10921 #line 10917 "ripper.c" /* yacc.c:1646 */
10922  break;
10923 
10924  case 605:
10925 #line 4618 "ripper.y" /* yacc.c:1646 */
10926  {
10927  p->lex.strterm = (yyvsp[-1].strterm);
10928 #if 0
10929  (yyval.val) = NEW_EVSTR((yyvsp[0].val), &(yyloc));
10930  nd_set_line((yyval.val), (yylsp[0]).end_pos.lineno);
10931 #endif
10932  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(string_dvar,v1);(yyval.val)=v2;}
10933  }
10934 #line 10930 "ripper.c" /* yacc.c:1646 */
10935  break;
10936 
10937  case 606:
10938 #line 4627 "ripper.y" /* yacc.c:1646 */
10939  {
10940  CMDARG_PUSH(0);
10941  COND_PUSH(0);
10942  }
10943 #line 10939 "ripper.c" /* yacc.c:1646 */
10944  break;
10945 
10946  case 607:
10947 #line 4631 "ripper.y" /* yacc.c:1646 */
10948  {
10949  /* need to backup p->lex.strterm so that a string literal `%!foo,#{ !0 },bar!` can be parsed */
10950  (yyval.strterm) = p->lex.strterm;
10951  p->lex.strterm = 0;
10952  }
10953 #line 10949 "ripper.c" /* yacc.c:1646 */
10954  break;
10955 
10956  case 608:
10957 #line 4636 "ripper.y" /* yacc.c:1646 */
10958  {
10959  (yyval.num) = p->lex.state;
10960  SET_LEX_STATE(EXPR_BEG);
10961  }
10962 #line 10958 "ripper.c" /* yacc.c:1646 */
10963  break;
10964 
10965  case 609:
10966 #line 4640 "ripper.y" /* yacc.c:1646 */
10967  {
10968  (yyval.num) = p->lex.brace_nest;
10969  p->lex.brace_nest = 0;
10970  }
10971 #line 10967 "ripper.c" /* yacc.c:1646 */
10972  break;
10973 
10974  case 610:
10975 #line 4644 "ripper.y" /* yacc.c:1646 */
10976  {
10977  (yyval.num) = p->heredoc_indent;
10978  p->heredoc_indent = 0;
10979  }
10980 #line 10976 "ripper.c" /* yacc.c:1646 */
10981  break;
10982 
10983  case 611:
10984 #line 4649 "ripper.y" /* yacc.c:1646 */
10985  {
10986  COND_POP();
10987  CMDARG_POP();
10988  p->lex.strterm = (yyvsp[-5].strterm);
10989  SET_LEX_STATE((yyvsp[-4].num));
10990  p->lex.brace_nest = (yyvsp[-3].num);
10991  p->heredoc_indent = (yyvsp[-2].num);
10992  p->heredoc_line_indent = -1;
10993 #if 0
10994  if ((yyvsp[-1].val)) (yyvsp[-1].val)->flags &= ~NODE_FL_NEWLINE;
10995  (yyval.val) = new_evstr(p, (yyvsp[-1].val), &(yyloc));
10996 #endif
10997  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(string_embexpr,v1);(yyval.val)=v2;}
10998  }
10999 #line 10995 "ripper.c" /* yacc.c:1646 */
11000  break;
11001 
11002  case 612:
11003 #line 4666 "ripper.y" /* yacc.c:1646 */
11004  {
11005 #if 0
11006  (yyval.val) = NEW_GVAR((yyvsp[0].val), &(yyloc));
11007 #endif
11008  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
11009  }
11010 #line 11006 "ripper.c" /* yacc.c:1646 */
11011  break;
11012 
11013  case 613:
11014 #line 4673 "ripper.y" /* yacc.c:1646 */
11015  {
11016 #if 0
11017  (yyval.val) = NEW_IVAR((yyvsp[0].val), &(yyloc));
11018 #endif
11019  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
11020  }
11021 #line 11017 "ripper.c" /* yacc.c:1646 */
11022  break;
11023 
11024  case 614:
11025 #line 4680 "ripper.y" /* yacc.c:1646 */
11026  {
11027 #if 0
11028  (yyval.val) = NEW_CVAR((yyvsp[0].val), &(yyloc));
11029 #endif
11030  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
11031  }
11032 #line 11028 "ripper.c" /* yacc.c:1646 */
11033  break;
11034 
11035  case 618:
11036 #line 4694 "ripper.y" /* yacc.c:1646 */
11037  {
11038  SET_LEX_STATE(EXPR_END);
11039 #if 0
11040  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[0].val)), &(yyloc));
11041 #endif
11042  {VALUE v1,v2,v3,v4;v1=(yyvsp[0].val);v2=dispatch1(symbol,v1);v3=v2;v4=dispatch1(symbol_literal,v3);(yyval.val)=v4;}
11043  }
11044 #line 11040 "ripper.c" /* yacc.c:1646 */
11045  break;
11046 
11047  case 623:
11048 #line 4710 "ripper.y" /* yacc.c:1646 */
11049  {
11050  SET_LEX_STATE(EXPR_END);
11051 #if 0
11052  (yyval.val) = dsym_node(p, (yyvsp[-1].val), &(yyloc));
11053 #endif
11054  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(dyna_symbol,v1);(yyval.val)=v2;}
11055  }
11056 #line 11052 "ripper.c" /* yacc.c:1646 */
11057  break;
11058 
11059  case 625:
11060 #line 4721 "ripper.y" /* yacc.c:1646 */
11061  {
11062 #if 0
11063  (yyval.val) = (yyvsp[0].val);
11064  RB_OBJ_WRITE(p->ast, &(yyval.val)->nd_lit, negate_lit(p, (yyval.val)->nd_lit));
11065 #endif
11066  {VALUE v1,v2,v3;v1=ID2VAL(idUMinus);v2=(yyvsp[0].val);v3=dispatch2(unary,v1,v2);(yyval.val)=v3;}
11067  }
11068 #line 11064 "ripper.c" /* yacc.c:1646 */
11069  break;
11070 
11071  case 635:
11072 #line 4743 "ripper.y" /* yacc.c:1646 */
11073  {(yyval.val) = KWD2EID(nil, (yyvsp[0].val));}
11074 #line 11070 "ripper.c" /* yacc.c:1646 */
11075  break;
11076 
11077  case 636:
11078 #line 4744 "ripper.y" /* yacc.c:1646 */
11079  {(yyval.val) = KWD2EID(self, (yyvsp[0].val));}
11080 #line 11076 "ripper.c" /* yacc.c:1646 */
11081  break;
11082 
11083  case 637:
11084 #line 4745 "ripper.y" /* yacc.c:1646 */
11085  {(yyval.val) = KWD2EID(true, (yyvsp[0].val));}
11086 #line 11082 "ripper.c" /* yacc.c:1646 */
11087  break;
11088 
11089  case 638:
11090 #line 4746 "ripper.y" /* yacc.c:1646 */
11091  {(yyval.val) = KWD2EID(false, (yyvsp[0].val));}
11092 #line 11088 "ripper.c" /* yacc.c:1646 */
11093  break;
11094 
11095  case 639:
11096 #line 4747 "ripper.y" /* yacc.c:1646 */
11097  {(yyval.val) = KWD2EID(_FILE__, (yyvsp[0].val));}
11098 #line 11094 "ripper.c" /* yacc.c:1646 */
11099  break;
11100 
11101  case 640:
11102 #line 4748 "ripper.y" /* yacc.c:1646 */
11103  {(yyval.val) = KWD2EID(_LINE__, (yyvsp[0].val));}
11104 #line 11100 "ripper.c" /* yacc.c:1646 */
11105  break;
11106 
11107  case 641:
11108 #line 4749 "ripper.y" /* yacc.c:1646 */
11109  {(yyval.val) = KWD2EID(_ENCODING__, (yyvsp[0].val));}
11110 #line 11106 "ripper.c" /* yacc.c:1646 */
11111  break;
11112 
11113  case 642:
11114 #line 4753 "ripper.y" /* yacc.c:1646 */
11115  {
11116 #if 0
11117  if (!((yyval.val) = gettable(p, (yyvsp[0].val), &(yyloc)))) (yyval.val) = NEW_BEGIN(0, &(yyloc));
11118 #endif
11119  if (id_is_var(p, get_id((yyvsp[0].val)))) {
11120  (yyval.val) = dispatch1(var_ref, (yyvsp[0].val));
11121  }
11122  else {
11123  (yyval.val) = dispatch1(vcall, (yyvsp[0].val));
11124  }
11125 
11126  }
11127 #line 11123 "ripper.c" /* yacc.c:1646 */
11128  break;
11129 
11130  case 643:
11131 #line 4766 "ripper.y" /* yacc.c:1646 */
11132  {
11133 #if 0
11134  if (!((yyval.val) = gettable(p, (yyvsp[0].val), &(yyloc)))) (yyval.val) = NEW_BEGIN(0, &(yyloc));
11135 #endif
11136  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
11137  }
11138 #line 11134 "ripper.c" /* yacc.c:1646 */
11139  break;
11140 
11141  case 644:
11142 #line 4775 "ripper.y" /* yacc.c:1646 */
11143  {
11144 #if 0
11145  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
11146 #endif
11147  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
11148  }
11149 #line 11145 "ripper.c" /* yacc.c:1646 */
11150  break;
11151 
11152  case 645:
11153 #line 4782 "ripper.y" /* yacc.c:1646 */
11154  {
11155 #if 0
11156  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
11157 #endif
11158  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
11159  }
11160 #line 11156 "ripper.c" /* yacc.c:1646 */
11161  break;
11162 
11163  case 648:
11164 #line 4795 "ripper.y" /* yacc.c:1646 */
11165  {
11166  SET_LEX_STATE(EXPR_BEG);
11167  p->command_start = TRUE;
11168  }
11169 #line 11165 "ripper.c" /* yacc.c:1646 */
11170  break;
11171 
11172  case 649:
11173 #line 4800 "ripper.y" /* yacc.c:1646 */
11174  {
11175  (yyval.val) = (yyvsp[-1].val);
11176  }
11177 #line 11173 "ripper.c" /* yacc.c:1646 */
11178  break;
11179 
11180  case 650:
11181 #line 4804 "ripper.y" /* yacc.c:1646 */
11182  {
11183 #if 0
11184  (yyval.val) = 0;
11185 #endif
11186  (yyval.val)=Qnil;
11187  }
11188 #line 11184 "ripper.c" /* yacc.c:1646 */
11189  break;
11190 
11191  case 651:
11192 #line 4813 "ripper.y" /* yacc.c:1646 */
11193  {
11194 #if 0
11195  (yyval.val) = (yyvsp[-1].val);
11196 #endif
11197  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
11198  SET_LEX_STATE(EXPR_BEG);
11199  p->command_start = TRUE;
11200  }
11201 #line 11197 "ripper.c" /* yacc.c:1646 */
11202  break;
11203 
11204  case 652:
11205 #line 4822 "ripper.y" /* yacc.c:1646 */
11206  {
11207  arg_var(p, idFWD_REST);
11208 #if idFWD_KWREST
11209  arg_var(p, idFWD_KWREST);
11210 #endif
11211  arg_var(p, idFWD_BLOCK);
11212 #if 0
11213  (yyval.val) = new_args_tail(p, Qnone, idFWD_KWREST, idFWD_BLOCK, &(yylsp[-1]));
11214  (yyval.val) = new_args(p, Qnone, Qnone, idFWD_REST, Qnone, (yyval.val), &(yylsp[-1]));
11215 #endif
11216  {VALUE v1,v2;v1=params_new(Qnone, Qnone, (yyvsp[-1].val), Qnone, Qnone, Qnone, Qnone);v2=dispatch1(paren,v1);(yyval.val)=v2;}
11217  SET_LEX_STATE(EXPR_BEG);
11218  p->command_start = TRUE;
11219  }
11220 #line 11216 "ripper.c" /* yacc.c:1646 */
11221  break;
11222 
11223  case 653:
11224 #line 4836 "ripper.y" /* yacc.c:1646 */
11225  {
11226  (yyval.num) = p->in_kwarg;
11227  p->in_kwarg = 1;
11228  SET_LEX_STATE(p->lex.state|EXPR_LABEL); /* force for args */
11229  }
11230 #line 11226 "ripper.c" /* yacc.c:1646 */
11231  break;
11232 
11233  case 654:
11234 #line 4842 "ripper.y" /* yacc.c:1646 */
11235  {
11236  p->in_kwarg = !!(yyvsp[-2].num);
11237  (yyval.val) = (yyvsp[-1].val);
11238  SET_LEX_STATE(EXPR_BEG);
11239  p->command_start = TRUE;
11240  }
11241 #line 11237 "ripper.c" /* yacc.c:1646 */
11242  break;
11243 
11244  case 655:
11245 #line 4851 "ripper.y" /* yacc.c:1646 */
11246  {
11247  (yyval.val) = new_args_tail(p, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]));
11248  }
11249 #line 11245 "ripper.c" /* yacc.c:1646 */
11250  break;
11251 
11252  case 656:
11253 #line 4855 "ripper.y" /* yacc.c:1646 */
11254  {
11255  (yyval.val) = new_args_tail(p, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yylsp[-1]));
11256  }
11257 #line 11253 "ripper.c" /* yacc.c:1646 */
11258  break;
11259 
11260  case 657:
11261 #line 4859 "ripper.y" /* yacc.c:1646 */
11262  {
11263  (yyval.val) = new_args_tail(p, Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]));
11264  }
11265 #line 11261 "ripper.c" /* yacc.c:1646 */
11266  break;
11267 
11268  case 658:
11269 #line 4863 "ripper.y" /* yacc.c:1646 */
11270  {
11271  (yyval.val) = new_args_tail(p, Qnone, ID2VAL(idNil), (yyvsp[0].val), &(yylsp[-1]));
11272  }
11273 #line 11269 "ripper.c" /* yacc.c:1646 */
11274  break;
11275 
11276  case 659:
11277 #line 4867 "ripper.y" /* yacc.c:1646 */
11278  {
11279  (yyval.val) = new_args_tail(p, Qnone, Qnone, (yyvsp[0].val), &(yylsp[0]));
11280  }
11281 #line 11277 "ripper.c" /* yacc.c:1646 */
11282  break;
11283 
11284  case 660:
11285 #line 4873 "ripper.y" /* yacc.c:1646 */
11286  {
11287  (yyval.val) = (yyvsp[0].val);
11288  }
11289 #line 11285 "ripper.c" /* yacc.c:1646 */
11290  break;
11291 
11292  case 661:
11293 #line 4877 "ripper.y" /* yacc.c:1646 */
11294  {
11295  (yyval.val) = new_args_tail(p, Qnone, Qnone, Qnone, &(yylsp[0]));
11296  }
11297 #line 11293 "ripper.c" /* yacc.c:1646 */
11298  break;
11299 
11300  case 662:
11301 #line 4883 "ripper.y" /* yacc.c:1646 */
11302  {
11303  (yyval.val) = new_args(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
11304  }
11305 #line 11301 "ripper.c" /* yacc.c:1646 */
11306  break;
11307 
11308  case 663:
11309 #line 4887 "ripper.y" /* yacc.c:1646 */
11310  {
11311  (yyval.val) = new_args(p, (yyvsp[-7].val), (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11312  }
11313 #line 11309 "ripper.c" /* yacc.c:1646 */
11314  break;
11315 
11316  case 664:
11317 #line 4891 "ripper.y" /* yacc.c:1646 */
11318  {
11319  (yyval.val) = new_args(p, (yyvsp[-3].val), (yyvsp[-1].val), Qnone, Qnone, (yyvsp[0].val), &(yyloc));
11320  }
11321 #line 11317 "ripper.c" /* yacc.c:1646 */
11322  break;
11323 
11324  case 665:
11325 #line 4895 "ripper.y" /* yacc.c:1646 */
11326  {
11327  (yyval.val) = new_args(p, (yyvsp[-5].val), (yyvsp[-3].val), Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11328  }
11329 #line 11325 "ripper.c" /* yacc.c:1646 */
11330  break;
11331 
11332  case 666:
11333 #line 4899 "ripper.y" /* yacc.c:1646 */
11334  {
11335  (yyval.val) = new_args(p, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
11336  }
11337 #line 11333 "ripper.c" /* yacc.c:1646 */
11338  break;
11339 
11340  case 667:
11341 #line 4903 "ripper.y" /* yacc.c:1646 */
11342  {
11343  (yyval.val) = new_args(p, (yyvsp[-5].val), Qnone, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11344  }
11345 #line 11341 "ripper.c" /* yacc.c:1646 */
11346  break;
11347 
11348  case 668:
11349 #line 4907 "ripper.y" /* yacc.c:1646 */
11350  {
11351  (yyval.val) = new_args(p, (yyvsp[-1].val), Qnone, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
11352  }
11353 #line 11349 "ripper.c" /* yacc.c:1646 */
11354  break;
11355 
11356  case 669:
11357 #line 4911 "ripper.y" /* yacc.c:1646 */
11358  {
11359  (yyval.val) = new_args(p, Qnone, (yyvsp[-3].val), (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
11360  }
11361 #line 11357 "ripper.c" /* yacc.c:1646 */
11362  break;
11363 
11364  case 670:
11365 #line 4915 "ripper.y" /* yacc.c:1646 */
11366  {
11367  (yyval.val) = new_args(p, Qnone, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11368  }
11369 #line 11365 "ripper.c" /* yacc.c:1646 */
11370  break;
11371 
11372  case 671:
11373 #line 4919 "ripper.y" /* yacc.c:1646 */
11374  {
11375  (yyval.val) = new_args(p, Qnone, (yyvsp[-1].val), Qnone, Qnone, (yyvsp[0].val), &(yyloc));
11376  }
11377 #line 11373 "ripper.c" /* yacc.c:1646 */
11378  break;
11379 
11380  case 672:
11381 #line 4923 "ripper.y" /* yacc.c:1646 */
11382  {
11383  (yyval.val) = new_args(p, Qnone, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11384  }
11385 #line 11381 "ripper.c" /* yacc.c:1646 */
11386  break;
11387 
11388  case 673:
11389 #line 4927 "ripper.y" /* yacc.c:1646 */
11390  {
11391  (yyval.val) = new_args(p, Qnone, Qnone, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
11392  }
11393 #line 11389 "ripper.c" /* yacc.c:1646 */
11394  break;
11395 
11396  case 674:
11397 #line 4931 "ripper.y" /* yacc.c:1646 */
11398  {
11399  (yyval.val) = new_args(p, Qnone, Qnone, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11400  }
11401 #line 11397 "ripper.c" /* yacc.c:1646 */
11402  break;
11403 
11404  case 675:
11405 #line 4935 "ripper.y" /* yacc.c:1646 */
11406  {
11407  (yyval.val) = new_args(p, Qnone, Qnone, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
11408  }
11409 #line 11405 "ripper.c" /* yacc.c:1646 */
11410  break;
11411 
11412  case 676:
11413 #line 4939 "ripper.y" /* yacc.c:1646 */
11414  {
11415  (yyval.val) = new_args_tail(p, Qnone, Qnone, Qnone, &(yylsp[0]));
11416  (yyval.val) = new_args(p, Qnone, Qnone, Qnone, Qnone, (yyval.val), &(yylsp[0]));
11417  }
11418 #line 11414 "ripper.c" /* yacc.c:1646 */
11419  break;
11420 
11421  case 677:
11422 #line 4946 "ripper.y" /* yacc.c:1646 */
11423  {
11424 #if 0
11425  (yyval.val) = idDot3;
11426 #endif
11427  {VALUE v1;v1=dispatch0(args_forward);(yyval.val)=v1;}
11428  }
11429 #line 11425 "ripper.c" /* yacc.c:1646 */
11430  break;
11431 
11432  case 678:
11433 #line 4955 "ripper.y" /* yacc.c:1646 */
11434  {
11435 #if 0
11436  yyerror1(&(yylsp[0]), "formal argument cannot be a constant");
11437  (yyval.val) = 0;
11438 #endif
11439  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(param_error,v1);(yyval.val)=v2;}ripper_error(p);
11440  }
11441 #line 11437 "ripper.c" /* yacc.c:1646 */
11442  break;
11443 
11444  case 679:
11445 #line 4963 "ripper.y" /* yacc.c:1646 */
11446  {
11447 #if 0
11448  yyerror1(&(yylsp[0]), "formal argument cannot be an instance variable");
11449  (yyval.val) = 0;
11450 #endif
11451  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(param_error,v1);(yyval.val)=v2;}ripper_error(p);
11452  }
11453 #line 11449 "ripper.c" /* yacc.c:1646 */
11454  break;
11455 
11456  case 680:
11457 #line 4971 "ripper.y" /* yacc.c:1646 */
11458  {
11459 #if 0
11460  yyerror1(&(yylsp[0]), "formal argument cannot be a global variable");
11461  (yyval.val) = 0;
11462 #endif
11463  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(param_error,v1);(yyval.val)=v2;}ripper_error(p);
11464  }
11465 #line 11461 "ripper.c" /* yacc.c:1646 */
11466  break;
11467 
11468  case 681:
11469 #line 4979 "ripper.y" /* yacc.c:1646 */
11470  {
11471 #if 0
11472  yyerror1(&(yylsp[0]), "formal argument cannot be a class variable");
11473  (yyval.val) = 0;
11474 #endif
11475  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(param_error,v1);(yyval.val)=v2;}ripper_error(p);
11476  }
11477 #line 11473 "ripper.c" /* yacc.c:1646 */
11478  break;
11479 
11480  case 683:
11481 #line 4990 "ripper.y" /* yacc.c:1646 */
11482  {
11483  formal_argument(p, get_id((yyvsp[0].val)));
11485  (yyval.val) = (yyvsp[0].val);
11486  }
11487 #line 11483 "ripper.c" /* yacc.c:1646 */
11488  break;
11489 
11490  case 684:
11491 #line 4998 "ripper.y" /* yacc.c:1646 */
11492  {
11493  ID id = get_id((yyvsp[0].val));
11494  arg_var(p, id);
11495  p->cur_arg = id;
11496  (yyval.val) = (yyvsp[0].val);
11497  }
11498 #line 11494 "ripper.c" /* yacc.c:1646 */
11499  break;
11500 
11501  case 685:
11502 #line 5007 "ripper.y" /* yacc.c:1646 */
11503  {
11504  p->cur_arg = 0;
11505 #if 0
11506  (yyval.val) = NEW_ARGS_AUX((yyvsp[0].val), 1, &NULL_LOC);
11507 #endif
11508  (yyval.val)=get_value((yyvsp[0].val));
11509  }
11510 #line 11506 "ripper.c" /* yacc.c:1646 */
11511  break;
11512 
11513  case 686:
11514 #line 5015 "ripper.y" /* yacc.c:1646 */
11515  {
11516 #if 0
11517  ID tid = internal_id(p);
11518  YYLTYPE loc;
11519  loc.beg_pos = (yylsp[-1]).beg_pos;
11520  loc.end_pos = (yylsp[-1]).beg_pos;
11521  arg_var(p, tid);
11522  if (dyna_in_block(p)) {
11523  (yyvsp[-1].val)->nd_value = NEW_DVAR(tid, &loc);
11524  }
11525  else {
11526  (yyvsp[-1].val)->nd_value = NEW_LVAR(tid, &loc);
11527  }
11528  (yyval.val) = NEW_ARGS_AUX(tid, 1, &NULL_LOC);
11529  (yyval.val)->nd_next = (yyvsp[-1].val);
11530 #endif
11531  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(mlhs_paren,v1);(yyval.val)=v2;}
11532  }
11533 #line 11529 "ripper.c" /* yacc.c:1646 */
11534  break;
11535 
11536  case 687:
11537 #line 5036 "ripper.y" /* yacc.c:1646 */
11538  {(yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));}
11539 #line 11535 "ripper.c" /* yacc.c:1646 */
11540  break;
11541 
11542  case 688:
11543 #line 5038 "ripper.y" /* yacc.c:1646 */
11544  {
11545 #if 0
11546  (yyval.val) = (yyvsp[-2].val);
11547  (yyval.val)->nd_plen++;
11548  (yyval.val)->nd_next = block_append(p, (yyval.val)->nd_next, (yyvsp[0].val)->nd_next);
11549  rb_discard_node(p, (yyvsp[0].val));
11550 #endif
11551  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11552  }
11553 #line 11549 "ripper.c" /* yacc.c:1646 */
11554  break;
11555 
11556  case 689:
11557 #line 5051 "ripper.y" /* yacc.c:1646 */
11558  {
11559  ID id = get_id((yyvsp[0].val));
11560  arg_var(p, formal_argument(p, id));
11561  p->cur_arg = id;
11563  (yyval.val) = (yyvsp[0].val);
11564  }
11565 #line 11561 "ripper.c" /* yacc.c:1646 */
11566  break;
11567 
11568  case 690:
11569 #line 5061 "ripper.y" /* yacc.c:1646 */
11570  {
11571  p->cur_arg = 0;
11572 #if 0
11573  (yyval.val) = new_kw_arg(p, assignable(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
11574 #endif
11575  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[-1].val))), get_value((yyvsp[0].val)));
11576  }
11577 #line 11573 "ripper.c" /* yacc.c:1646 */
11578  break;
11579 
11580  case 691:
11581 #line 5069 "ripper.y" /* yacc.c:1646 */
11582  {
11583  p->cur_arg = 0;
11584 #if 0
11585  (yyval.val) = new_kw_arg(p, assignable(p, (yyvsp[0].val), NODE_SPECIAL_REQUIRED_KEYWORD, &(yyloc)), &(yyloc));
11586 #endif
11587  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[0].val))), 0);
11588  }
11589 #line 11585 "ripper.c" /* yacc.c:1646 */
11590  break;
11591 
11592  case 692:
11593 #line 5079 "ripper.y" /* yacc.c:1646 */
11594  {
11595 #if 0
11596  (yyval.val) = new_kw_arg(p, assignable(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
11597 #endif
11598  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[-1].val))), get_value((yyvsp[0].val)));
11599  }
11600 #line 11596 "ripper.c" /* yacc.c:1646 */
11601  break;
11602 
11603  case 693:
11604 #line 5086 "ripper.y" /* yacc.c:1646 */
11605  {
11606 #if 0
11607  (yyval.val) = new_kw_arg(p, assignable(p, (yyvsp[0].val), NODE_SPECIAL_REQUIRED_KEYWORD, &(yyloc)), &(yyloc));
11608 #endif
11609  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[0].val))), 0);
11610  }
11611 #line 11607 "ripper.c" /* yacc.c:1646 */
11612  break;
11613 
11614  case 694:
11615 #line 5095 "ripper.y" /* yacc.c:1646 */
11616  {
11617 #if 0
11618  (yyval.val) = (yyvsp[0].val);
11619 #endif
11620  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
11621  }
11622 #line 11618 "ripper.c" /* yacc.c:1646 */
11623  break;
11624 
11625  case 695:
11626 #line 5102 "ripper.y" /* yacc.c:1646 */
11627  {
11628 #if 0
11629  (yyval.val) = kwd_append((yyvsp[-2].val), (yyvsp[0].val));
11630 #endif
11631  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11632  }
11633 #line 11629 "ripper.c" /* yacc.c:1646 */
11634  break;
11635 
11636  case 696:
11637 #line 5112 "ripper.y" /* yacc.c:1646 */
11638  {
11639 #if 0
11640  (yyval.val) = (yyvsp[0].val);
11641 #endif
11642  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
11643  }
11644 #line 11640 "ripper.c" /* yacc.c:1646 */
11645  break;
11646 
11647  case 697:
11648 #line 5119 "ripper.y" /* yacc.c:1646 */
11649  {
11650 #if 0
11651  (yyval.val) = kwd_append((yyvsp[-2].val), (yyvsp[0].val));
11652 #endif
11653  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11654  }
11655 #line 11651 "ripper.c" /* yacc.c:1646 */
11656  break;
11657 
11658  case 700:
11659 #line 5132 "ripper.y" /* yacc.c:1646 */
11660  {
11661 #if 0
11662 #endif
11663  {VALUE v1,v2;v1=Qnil;v2=dispatch1(nokw_param,v1);(yyval.val)=v2;}
11664  }
11665 #line 11661 "ripper.c" /* yacc.c:1646 */
11666  break;
11667 
11668  case 701:
11669 #line 5140 "ripper.y" /* yacc.c:1646 */
11670  {
11671  arg_var(p, shadowing_lvar(p, get_id((yyvsp[0].val))));
11672 #if 0
11673  (yyval.val) = (yyvsp[0].val);
11674 #endif
11675  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(kwrest_param,v1);(yyval.val)=v2;}
11676  }
11677 #line 11673 "ripper.c" /* yacc.c:1646 */
11678  break;
11679 
11680  case 702:
11681 #line 5148 "ripper.y" /* yacc.c:1646 */
11682  {
11683 #if 0
11684  (yyval.val) = internal_id(p);
11685  arg_var(p, (yyval.val));
11686 #endif
11687  {VALUE v1,v2;v1=Qnil;v2=dispatch1(kwrest_param,v1);(yyval.val)=v2;}
11688  }
11689 #line 11685 "ripper.c" /* yacc.c:1646 */
11690  break;
11691 
11692  case 703:
11693 #line 5158 "ripper.y" /* yacc.c:1646 */
11694  {
11695  p->cur_arg = 0;
11696 #if 0
11697  (yyval.val) = NEW_OPT_ARG(0, assignable(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
11698 #endif
11699  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[-2].val))), get_value((yyvsp[0].val)));
11700  }
11701 #line 11697 "ripper.c" /* yacc.c:1646 */
11702  break;
11703 
11704  case 704:
11705 #line 5168 "ripper.y" /* yacc.c:1646 */
11706  {
11707  p->cur_arg = 0;
11708 #if 0
11709  (yyval.val) = NEW_OPT_ARG(0, assignable(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
11710 #endif
11711  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[-2].val))), get_value((yyvsp[0].val)));
11712  }
11713 #line 11709 "ripper.c" /* yacc.c:1646 */
11714  break;
11715 
11716  case 705:
11717 #line 5178 "ripper.y" /* yacc.c:1646 */
11718  {
11719 #if 0
11720  (yyval.val) = (yyvsp[0].val);
11721 #endif
11722  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
11723  }
11724 #line 11720 "ripper.c" /* yacc.c:1646 */
11725  break;
11726 
11727  case 706:
11728 #line 5185 "ripper.y" /* yacc.c:1646 */
11729  {
11730 #if 0
11731  (yyval.val) = opt_arg_append((yyvsp[-2].val), (yyvsp[0].val));
11732 #endif
11733  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11734  }
11735 #line 11731 "ripper.c" /* yacc.c:1646 */
11736  break;
11737 
11738  case 707:
11739 #line 5194 "ripper.y" /* yacc.c:1646 */
11740  {
11741 #if 0
11742  (yyval.val) = (yyvsp[0].val);
11743 #endif
11744  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
11745  }
11746 #line 11742 "ripper.c" /* yacc.c:1646 */
11747  break;
11748 
11749  case 708:
11750 #line 5201 "ripper.y" /* yacc.c:1646 */
11751  {
11752 #if 0
11753  (yyval.val) = opt_arg_append((yyvsp[-2].val), (yyvsp[0].val));
11754 #endif
11755  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11756  }
11757 #line 11753 "ripper.c" /* yacc.c:1646 */
11758  break;
11759 
11760  case 711:
11761 #line 5214 "ripper.y" /* yacc.c:1646 */
11762  {
11763  arg_var(p, shadowing_lvar(p, get_id((yyvsp[0].val))));
11764 #if 0
11765  (yyval.val) = (yyvsp[0].val);
11766 #endif
11767  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(rest_param,v1);(yyval.val)=v2;}
11768  }
11769 #line 11765 "ripper.c" /* yacc.c:1646 */
11770  break;
11771 
11772  case 712:
11773 #line 5222 "ripper.y" /* yacc.c:1646 */
11774  {
11775 #if 0
11776  (yyval.val) = internal_id(p);
11777  arg_var(p, (yyval.val));
11778 #endif
11779  {VALUE v1,v2;v1=Qnil;v2=dispatch1(rest_param,v1);(yyval.val)=v2;}
11780  }
11781 #line 11777 "ripper.c" /* yacc.c:1646 */
11782  break;
11783 
11784  case 715:
11785 #line 5236 "ripper.y" /* yacc.c:1646 */
11786  {
11787  arg_var(p, shadowing_lvar(p, get_id((yyvsp[0].val))));
11788 #if 0
11789  (yyval.val) = (yyvsp[0].val);
11790 #endif
11791  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(blockarg,v1);(yyval.val)=v2;}
11792  }
11793 #line 11789 "ripper.c" /* yacc.c:1646 */
11794  break;
11795 
11796  case 716:
11797 #line 5246 "ripper.y" /* yacc.c:1646 */
11798  {
11799  (yyval.val) = (yyvsp[0].val);
11800  }
11801 #line 11797 "ripper.c" /* yacc.c:1646 */
11802  break;
11803 
11804  case 717:
11805 #line 5250 "ripper.y" /* yacc.c:1646 */
11806  {
11807  (yyval.val) = Qnull;
11808  }
11809 #line 11805 "ripper.c" /* yacc.c:1646 */
11810  break;
11811 
11812  case 718:
11813 #line 5256 "ripper.y" /* yacc.c:1646 */
11814  {
11815  value_expr((yyvsp[0].val));
11816  (yyval.val) = (yyvsp[0].val);
11817  }
11818 #line 11814 "ripper.c" /* yacc.c:1646 */
11819  break;
11820 
11821  case 719:
11822 #line 5260 "ripper.y" /* yacc.c:1646 */
11823  {SET_LEX_STATE(EXPR_BEG);}
11824 #line 11820 "ripper.c" /* yacc.c:1646 */
11825  break;
11826 
11827  case 720:
11828 #line 5261 "ripper.y" /* yacc.c:1646 */
11829  {
11830 #if 0
11831  switch (nd_type((yyvsp[-1].val))) {
11832  case NODE_STR:
11833  case NODE_DSTR:
11834  case NODE_XSTR:
11835  case NODE_DXSTR:
11836  case NODE_DREGX:
11837  case NODE_LIT:
11838  case NODE_LIST:
11839  case NODE_ZLIST:
11840  yyerror1(&(yylsp[-1]), "can't define singleton method for literals");
11841  break;
11842  default:
11843  value_expr((yyvsp[-1].val));
11844  break;
11845  }
11846  (yyval.val) = (yyvsp[-1].val);
11847 #endif
11848  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
11849  }
11850 #line 11846 "ripper.c" /* yacc.c:1646 */
11851  break;
11852 
11853  case 722:
11854 #line 5286 "ripper.y" /* yacc.c:1646 */
11855  {
11856 #if 0
11857  (yyval.val) = (yyvsp[-1].val);
11858 #endif
11859  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(assoclist_from_args,v1);(yyval.val)=v2;}
11860  }
11861 #line 11857 "ripper.c" /* yacc.c:1646 */
11862  break;
11863 
11864  case 723:
11865 #line 5295 "ripper.y" /* yacc.c:1646 */
11866  {(yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));}
11867 #line 11863 "ripper.c" /* yacc.c:1646 */
11868  break;
11869 
11870  case 724:
11871 #line 5297 "ripper.y" /* yacc.c:1646 */
11872  {
11873 #if 0
11874  NODE *assocs = (yyvsp[-2].val);
11875  NODE *tail = (yyvsp[0].val);
11876  if (!assocs) {
11877  assocs = tail;
11878  }
11879  else if (tail) {
11880  if (assocs->nd_head &&
11881  !tail->nd_head && nd_type(tail->nd_next) == NODE_LIST &&
11882  nd_type(tail->nd_next->nd_head) == NODE_HASH) {
11883  /* DSTAR */
11884  tail = tail->nd_next->nd_head->nd_head;
11885  }
11886  assocs = list_concat(assocs, tail);
11887  }
11888  (yyval.val) = assocs;
11889 #endif
11890  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11891  }
11892 #line 11888 "ripper.c" /* yacc.c:1646 */
11893  break;
11894 
11895  case 725:
11896 #line 5320 "ripper.y" /* yacc.c:1646 */
11897  {
11898 #if 0
11899  if (nd_type((yyvsp[-2].val)) == NODE_STR) {
11900  nd_set_type((yyvsp[-2].val), NODE_LIT);
11901  RB_OBJ_WRITE(p->ast, &(yyvsp[-2].val)->nd_lit, rb_fstring((yyvsp[-2].val)->nd_lit));
11902  }
11903  (yyval.val) = list_append(p, NEW_LIST((yyvsp[-2].val), &(yyloc)), (yyvsp[0].val));
11904 #endif
11905  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(assoc_new,v1,v2);(yyval.val)=v3;}
11906  }
11907 #line 11903 "ripper.c" /* yacc.c:1646 */
11908  break;
11909 
11910  case 726:
11911 #line 5331 "ripper.y" /* yacc.c:1646 */
11912  {
11913 #if 0
11914  (yyval.val) = list_append(p, NEW_LIST(NEW_LIT(ID2SYM((yyvsp[-1].val)), &(yylsp[-1])), &(yyloc)), (yyvsp[0].val));
11915 #endif
11916  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(assoc_new,v1,v2);(yyval.val)=v3;}
11917  }
11918 #line 11914 "ripper.c" /* yacc.c:1646 */
11919  break;
11920 
11921  case 727:
11922 #line 5338 "ripper.y" /* yacc.c:1646 */
11923  {
11924 #if 0
11925  YYLTYPE loc = code_loc_gen(&(yylsp[-3]), &(yylsp[-1]));
11926  (yyval.val) = list_append(p, NEW_LIST(dsym_node(p, (yyvsp[-2].val), &loc), &loc), (yyvsp[0].val));
11927 #endif
11928  {VALUE v1,v2,v3,v4,v5;v1=(yyvsp[-2].val);v2=dispatch1(dyna_symbol,v1);v3=v2;v4=(yyvsp[0].val);v5=dispatch2(assoc_new,v3,v4);(yyval.val)=v5;}
11929  }
11930 #line 11926 "ripper.c" /* yacc.c:1646 */
11931  break;
11932 
11933  case 728:
11934 #line 5346 "ripper.y" /* yacc.c:1646 */
11935  {
11936 #if 0
11937  if (nd_type((yyvsp[0].val)) == NODE_HASH &&
11938  !((yyvsp[0].val)->nd_head && (yyvsp[0].val)->nd_head->nd_alen)) {
11939  static VALUE empty_hash;
11940  if (!empty_hash) {
11941  empty_hash = rb_obj_freeze(rb_hash_new());
11942  rb_gc_register_mark_object(empty_hash);
11943  }
11944  (yyval.val) = list_append(p, NEW_LIST(0, &(yyloc)), NEW_LIT(empty_hash, &(yyloc)));
11945  }
11946  else
11947  (yyval.val) = list_append(p, NEW_LIST(0, &(yyloc)), (yyvsp[0].val));
11948 #endif
11949  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(assoc_splat,v1);(yyval.val)=v2;}
11950  }
11951 #line 11947 "ripper.c" /* yacc.c:1646 */
11952  break;
11953 
11954  case 755:
11955 #line 5414 "ripper.y" /* yacc.c:1646 */
11956  {yyerrok;token_flush(p);}
11957 #line 11953 "ripper.c" /* yacc.c:1646 */
11958  break;
11959 
11960  case 756:
11961 #line 5415 "ripper.y" /* yacc.c:1646 */
11962  {token_flush(p);}
11963 #line 11959 "ripper.c" /* yacc.c:1646 */
11964  break;
11965 
11966  case 758:
11967 #line 5419 "ripper.y" /* yacc.c:1646 */
11968  {yyerrok;}
11969 #line 11965 "ripper.c" /* yacc.c:1646 */
11970  break;
11971 
11972  case 759:
11973 #line 5423 "ripper.y" /* yacc.c:1646 */
11974  {
11975  (yyval.val) = Qnull;
11976  }
11977 #line 11973 "ripper.c" /* yacc.c:1646 */
11978  break;
11979 
11980 
11981 #line 11977 "ripper.c" /* yacc.c:1646 */
11982  default: break;
11983  }
11984  /* User semantic actions sometimes alter yychar, and that requires
11985  that yytoken be updated with the new translation. We take the
11986  approach of translating immediately before every use of yytoken.
11987  One alternative is translating here after every semantic action,
11988  but that translation would be missed if the semantic action invokes
11989  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
11990  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
11991  incorrect destructor might then be invoked immediately. In the
11992  case of YYERROR or YYBACKUP, subsequent parser actions might lead
11993  to an incorrect destructor call or verbose syntax error message
11994  before the lookahead is translated. */
11995  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
11996 
11997  YYPOPSTACK (yylen);
11998  yylen = 0;
11999  YY_STACK_PRINT (yyss, yyssp);
12000 
12001  *++yyvsp = yyval;
12002  *++yylsp = yyloc;
12003 
12004  /* Now 'shift' the result of the reduction. Determine what state
12005  that goes to, based on the state we popped back to and the rule
12006  number reduced by. */
12007 
12008  yyn = yyr1[yyn];
12009 
12010  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
12011  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
12012  yystate = yytable[yystate];
12013  else
12014  yystate = yydefgoto[yyn - YYNTOKENS];
12015 
12016  goto yynewstate;
12017 
12018 
12019 /*--------------------------------------.
12020 | yyerrlab -- here on detecting error. |
12021 `--------------------------------------*/
12022 yyerrlab:
12023  /* Make sure we have latest lookahead translation. See comments at
12024  user semantic actions for why this is necessary. */
12025  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
12026 
12027  /* If not already recovering from an error, report this error. */
12028  if (!yyerrstatus)
12029  {
12030  ++yynerrs;
12031 #if ! YYERROR_VERBOSE
12032  yyerror (&yylloc, p, YY_("syntax error"));
12033 #else
12034 # define YYSYNTAX_ERROR yysyntax_error (p, &yymsg_alloc, &yymsg, \
12035  yyssp, yytoken)
12036  {
12037  char const *yymsgp = YY_("syntax error");
12038  int yysyntax_error_status;
12039  yysyntax_error_status = YYSYNTAX_ERROR;
12040  if (yysyntax_error_status == 0)
12041  yymsgp = yymsg;
12042  else if (yysyntax_error_status == 1)
12043  {
12044  if (yymsg != yymsgbuf)
12045  YYSTACK_FREE (yymsg);
12046  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
12047  if (!yymsg)
12048  {
12049  yymsg = yymsgbuf;
12050  yymsg_alloc = sizeof yymsgbuf;
12051  yysyntax_error_status = 2;
12052  }
12053  else
12054  {
12055  yysyntax_error_status = YYSYNTAX_ERROR;
12056  yymsgp = yymsg;
12057  }
12058  }
12059  yyerror (&yylloc, p, yymsgp);
12060  if (yysyntax_error_status == 2)
12061  goto yyexhaustedlab;
12062  }
12063 # undef YYSYNTAX_ERROR
12064 #endif
12065  }
12066 
12067  yyerror_range[1] = yylloc;
12068 
12069  if (yyerrstatus == 3)
12070  {
12071  /* If just tried and failed to reuse lookahead token after an
12072  error, discard it. */
12073 
12074  if (yychar <= YYEOF)
12075  {
12076  /* Return failure if at end of input. */
12077  if (yychar == YYEOF)
12078  YYABORT;
12079  }
12080  else
12081  {
12082  yydestruct ("Error: discarding",
12083  yytoken, &yylval, &yylloc, p);
12084  yychar = YYEMPTY;
12085  }
12086  }
12087 
12088  /* Else will try to reuse lookahead token after shifting the error
12089  token. */
12090  goto yyerrlab1;
12091 
12092 
12093 /*---------------------------------------------------.
12094 | yyerrorlab -- error raised explicitly by YYERROR. |
12095 `---------------------------------------------------*/
12096 yyerrorlab:
12097 
12098  /* Pacify compilers like GCC when the user code never invokes
12099  YYERROR and the label yyerrorlab therefore never appears in user
12100  code. */
12101  if (/*CONSTCOND*/ 0)
12102  goto yyerrorlab;
12103 
12104  yyerror_range[1] = yylsp[1-yylen];
12105  /* Do not reclaim the symbols of the rule whose action triggered
12106  this YYERROR. */
12107  YYPOPSTACK (yylen);
12108  yylen = 0;
12109  YY_STACK_PRINT (yyss, yyssp);
12110  yystate = *yyssp;
12111  goto yyerrlab1;
12112 
12113 
12114 /*-------------------------------------------------------------.
12115 | yyerrlab1 -- common code for both syntax error and YYERROR. |
12116 `-------------------------------------------------------------*/
12117 yyerrlab1:
12118  yyerrstatus = 3; /* Each real token shifted decrements this. */
12119 
12120  for (;;)
12121  {
12122  yyn = yypact[yystate];
12123  if (!yypact_value_is_default (yyn))
12124  {
12125  yyn += YYTERROR;
12126  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
12127  {
12128  yyn = yytable[yyn];
12129  if (0 < yyn)
12130  break;
12131  }
12132  }
12133 
12134  /* Pop the current state because it cannot handle the error token. */
12135  if (yyssp == yyss)
12136  YYABORT;
12137 
12138  yyerror_range[1] = *yylsp;
12139  yydestruct ("Error: popping",
12140  yystos[yystate], yyvsp, yylsp, p);
12141  YYPOPSTACK (1);
12142  yystate = *yyssp;
12143  YY_STACK_PRINT (yyss, yyssp);
12144  }
12145 
12147  *++yyvsp = yylval;
12149 
12150  yyerror_range[2] = yylloc;
12151  /* Using YYLLOC is tempting, but would change the location of
12152  the lookahead. YYLOC is available though. */
12153  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
12154  *++yylsp = yyloc;
12155 
12156  /* Shift the error token. */
12157  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
12158 
12159  yystate = yyn;
12160  goto yynewstate;
12161 
12162 
12163 /*-------------------------------------.
12164 | yyacceptlab -- YYACCEPT comes here. |
12165 `-------------------------------------*/
12166 yyacceptlab:
12167  yyresult = 0;
12168  goto yyreturn;
12169 
12170 /*-----------------------------------.
12171 | yyabortlab -- YYABORT comes here. |
12172 `-----------------------------------*/
12173 yyabortlab:
12174  yyresult = 1;
12175  goto yyreturn;
12176 
12177 #if !defined yyoverflow || YYERROR_VERBOSE
12178 /*-------------------------------------------------.
12179 | yyexhaustedlab -- memory exhaustion comes here. |
12180 `-------------------------------------------------*/
12181 yyexhaustedlab:
12182  yyerror (&yylloc, p, YY_("memory exhausted"));
12183  yyresult = 2;
12184  /* Fall through. */
12185 #endif
12186 
12187 yyreturn:
12188  if (yychar != YYEMPTY)
12189  {
12190  /* Make sure we have latest lookahead translation. See comments at
12191  user semantic actions for why this is necessary. */
12192  yytoken = YYTRANSLATE (yychar);
12193  yydestruct ("Cleanup: discarding lookahead",
12194  yytoken, &yylval, &yylloc, p);
12195  }
12196  /* Do not reclaim the symbols of the rule whose action triggered
12197  this YYABORT or YYACCEPT. */
12198  YYPOPSTACK (yylen);
12199  YY_STACK_PRINT (yyss, yyssp);
12200  while (yyssp != yyss)
12201  {
12202  yydestruct ("Cleanup: popping",
12203  yystos[*yyssp], yyvsp, yylsp, p);
12204  YYPOPSTACK (1);
12205  }
12206 #ifndef yyoverflow
12207  if (yyss != yyssa)
12208  YYSTACK_FREE (yyss);
12209 #endif
12210 #if YYERROR_VERBOSE
12211  if (yymsg != yymsgbuf)
12212  YYSTACK_FREE (yymsg);
12213 #endif
12214  return yyresult;
12215 }
12216 #line 5427 "ripper.y" /* yacc.c:1906 */
12217 
12218 # undef p
12219 # undef yylex
12220 # undef yylval
12221 # define yylval (*p->lval)
12222 
12223 static int regx_options(struct parser_params*);
12224 static int tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**,rb_encoding**);
12225 static void tokaddmbc(struct parser_params *p, int c, rb_encoding *enc);
12226 static enum yytokentype parse_string(struct parser_params*,rb_strterm_literal_t*);
12227 static enum yytokentype here_document(struct parser_params*,rb_strterm_heredoc_t*);
12228 
12229 #ifndef RIPPER
12230 # define set_yylval_node(x) { \
12231  YYLTYPE _cur_loc; \
12232  rb_parser_set_location(p, &_cur_loc); \
12233  yylval.node = (x); \
12234 }
12235 # define set_yylval_str(x) \
12236 do { \
12237  set_yylval_node(NEW_STR(x, &_cur_loc)); \
12238  RB_OBJ_WRITTEN(p->ast, Qnil, x); \
12239 } while(0)
12240 # define set_yylval_literal(x) \
12241 do { \
12242  set_yylval_node(NEW_LIT(x, &_cur_loc)); \
12243  RB_OBJ_WRITTEN(p->ast, Qnil, x); \
12244 } while(0)
12245 # define set_yylval_num(x) (yylval.num = (x))
12246 # define set_yylval_id(x) (yylval.id = (x))
12247 # define set_yylval_name(x) (yylval.id = (x))
12248 # define yylval_id() (yylval.id)
12249 #else
12250 static inline VALUE
12251 ripper_yylval_id(struct parser_params *p, ID x)
12252 {
12253  return ripper_new_yylval(p, x, ID2SYM(x), 0);
12254 }
12255 # define set_yylval_str(x) (yylval.val = add_mark_object(p, (x)))
12256 # define set_yylval_num(x) (yylval.val = ripper_new_yylval(p, (x), 0, 0))
12257 # define set_yylval_id(x) (void)(x)
12258 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(p, x))
12259 # define set_yylval_literal(x) add_mark_object(p, (x))
12260 # define set_yylval_node(x) (void)(x)
12261 # define yylval_id() yylval.id
12262 # define _cur_loc NULL_LOC /* dummy */
12263 #endif
12264 
12265 #define set_yylval_noname() set_yylval_id(keyword_nil)
12266 
12267 #ifndef RIPPER
12268 #define literal_flush(p, ptr) ((p)->lex.ptok = (ptr))
12269 #define dispatch_scan_event(p, t) ((void)0)
12270 #define dispatch_delayed_token(p, t) ((void)0)
12271 #define has_delayed_token(p) (0)
12272 #else
12273 #define literal_flush(p, ptr) ((void)(ptr))
12274 
12275 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
12276 
12277 static inline VALUE
12278 intern_sym(const char *name)
12279 {
12280  ID id = rb_intern_const(name);
12281  return ID2SYM(id);
12282 }
12283 
12284 static int
12285 ripper_has_scan_event(struct parser_params *p)
12286 {
12287  if (p->lex.pcur < p->lex.ptok) rb_raise(rb_eRuntimeError, "lex.pcur < lex.ptok");
12288  return p->lex.pcur > p->lex.ptok;
12289 }
12290 
12291 static VALUE
12292 ripper_scan_event_val(struct parser_params *p, enum yytokentype t)
12293 {
12294  VALUE str = STR_NEW(p->lex.ptok, p->lex.pcur - p->lex.ptok);
12295  VALUE rval = ripper_dispatch1(p, ripper_token2eventid(t), str);
12296  token_flush(p);
12297  return rval;
12298 }
12299 
12300 static void
12301 ripper_dispatch_scan_event(struct parser_params *p, enum yytokentype t)
12302 {
12303  if (!ripper_has_scan_event(p)) return;
12304  add_mark_object(p, yylval_rval = ripper_scan_event_val(p, t));
12305 }
12306 #define dispatch_scan_event(p, t) ripper_dispatch_scan_event(p, t)
12307 
12308 static void
12309 ripper_dispatch_delayed_token(struct parser_params *p, enum yytokentype t)
12310 {
12311  int saved_line = p->ruby_sourceline;
12312  const char *saved_tokp = p->lex.ptok;
12313 
12314  if (NIL_P(p->delayed.token)) return;
12315  p->ruby_sourceline = p->delayed.line;
12316  p->lex.ptok = p->lex.pbeg + p->delayed.col;
12317  add_mark_object(p, yylval_rval = ripper_dispatch1(p, ripper_token2eventid(t), p->delayed.token));
12318  p->delayed.token = Qnil;
12319  p->ruby_sourceline = saved_line;
12320  p->lex.ptok = saved_tokp;
12321 }
12322 #define dispatch_delayed_token(p, t) ripper_dispatch_delayed_token(p, t)
12323 #define has_delayed_token(p) (!NIL_P(p->delayed.token))
12324 #endif /* RIPPER */
12325 
12326 #include "ruby/regex.h"
12327 #include "ruby/util.h"
12328 
12329 static inline int
12330 is_identchar(const char *ptr, const char *MAYBE_UNUSED(ptr_end), rb_encoding *enc)
12331 {
12332  return rb_enc_isalnum((unsigned char)*ptr, enc) || *ptr == '_' || !ISASCII(*ptr);
12333 }
12334 
12335 static inline int
12336 parser_is_identchar(struct parser_params *p)
12337 {
12338  return !(p)->eofp && is_identchar(p->lex.pcur-1, p->lex.pend, p->enc);
12339 }
12340 
12341 static inline int
12342 parser_isascii(struct parser_params *p)
12343 {
12344  return ISASCII(*(p->lex.pcur-1));
12345 }
12346 
12347 static void
12348 token_info_setup(token_info *ptinfo, const char *ptr, const rb_code_location_t *loc)
12349 {
12350  int column = 1, nonspc = 0, i;
12351  for (i = 0; i < loc->beg_pos.column; i++, ptr++) {
12352  if (*ptr == '\t') {
12353  column = (((column - 1) / TAB_WIDTH) + 1) * TAB_WIDTH;
12354  }
12355  column++;
12356  if (*ptr != ' ' && *ptr != '\t') {
12357  nonspc = 1;
12358  }
12359  }
12360 
12361  ptinfo->beg = loc->beg_pos;
12362  ptinfo->indent = column;
12363  ptinfo->nonspc = nonspc;
12364 }
12365 
12366 static void
12367 token_info_push(struct parser_params *p, const char *token, const rb_code_location_t *loc)
12368 {
12369  token_info *ptinfo;
12370 
12371  if (!p->token_info_enabled) return;
12372  ptinfo = ALLOC(token_info);
12373  ptinfo->token = token;
12374  ptinfo->next = p->token_info;
12375  token_info_setup(ptinfo, p->lex.pbeg, loc);
12376 
12377  p->token_info = ptinfo;
12378 }
12379 
12380 static void
12381 token_info_pop(struct parser_params *p, const char *token, const rb_code_location_t *loc)
12382 {
12383  token_info *ptinfo_beg = p->token_info;
12384 
12385  if (!ptinfo_beg) return;
12386  p->token_info = ptinfo_beg->next;
12387 
12388  /* indentation check of matched keywords (begin..end, if..end, etc.) */
12389  token_info_warn(p, token, ptinfo_beg, 1, loc);
12390  ruby_sized_xfree(ptinfo_beg, sizeof(*ptinfo_beg));
12391 }
12392 
12393 static void
12394 token_info_warn(struct parser_params *p, const char *token, token_info *ptinfo_beg, int same, const rb_code_location_t *loc)
12395 {
12396  token_info ptinfo_end_body, *ptinfo_end = &ptinfo_end_body;
12397  if (!p->token_info_enabled) return;
12398  if (!ptinfo_beg) return;
12399  token_info_setup(ptinfo_end, p->lex.pbeg, loc);
12400  if (ptinfo_beg->beg.lineno == ptinfo_end->beg.lineno) return; /* ignore one-line block */
12401  if (ptinfo_beg->nonspc || ptinfo_end->nonspc) return; /* ignore keyword in the middle of a line */
12402  if (ptinfo_beg->indent == ptinfo_end->indent) return; /* the indents are matched */
12403  if (!same && ptinfo_beg->indent < ptinfo_end->indent) return;
12404  rb_warn3L(ptinfo_end->beg.lineno,
12405  "mismatched indentations at '%s' with '%s' at %d",
12406  WARN_S(token), WARN_S(ptinfo_beg->token), WARN_I(ptinfo_beg->beg.lineno));
12407 }
12408 
12409 static int
12410 parser_precise_mbclen(struct parser_params *p, const char *ptr)
12411 {
12412  int len = rb_enc_precise_mbclen(ptr, p->lex.pend, p->enc);
12413  if (!MBCLEN_CHARFOUND_P(len)) {
12414  compile_error(p, "invalid multibyte char (%s)", rb_enc_name(p->enc));
12415  return -1;
12416  }
12417  return len;
12418 }
12419 
12420 #ifndef RIPPER
12421 static void ruby_show_error_line(VALUE errbuf, const YYLTYPE *yylloc, int lineno, VALUE str);
12422 
12423 static inline void
12424 parser_show_error_line(struct parser_params *p, const YYLTYPE *yylloc)
12425 {
12426  VALUE str;
12427  int lineno = p->ruby_sourceline;
12428  if (!yylloc) {
12429  return;
12430  }
12431  else if (yylloc->beg_pos.lineno == lineno) {
12432  str = p->lex.lastline;
12433  }
12434  else {
12435  return;
12436  }
12437  ruby_show_error_line(p->error_buffer, yylloc, lineno, str);
12438 }
12439 
12440 static int
12441 parser_yyerror(struct parser_params *p, const YYLTYPE *yylloc, const char *msg)
12442 {
12443  YYLTYPE current;
12444 
12445  if (!yylloc) {
12446  yylloc = RUBY_SET_YYLLOC(current);
12447  }
12448  else if ((p->ruby_sourceline != yylloc->beg_pos.lineno &&
12449  p->ruby_sourceline != yylloc->end_pos.lineno) ||
12450  (yylloc->beg_pos.lineno == yylloc->end_pos.lineno &&
12451  yylloc->beg_pos.column == yylloc->end_pos.column)) {
12452  yylloc = 0;
12453  }
12454  compile_error(p, "%s", msg);
12455  parser_show_error_line(p, yylloc);
12456  return 0;
12457 }
12458 
12459 static void
12460 ruby_show_error_line(VALUE errbuf, const YYLTYPE *yylloc, int lineno, VALUE str)
12461 {
12462  VALUE mesg;
12463  const int max_line_margin = 30;
12464  const char *ptr, *ptr_end, *pt, *pb;
12465  const char *pre = "", *post = "", *pend;
12466  const char *code = "", *caret = "";
12467  const char *lim;
12468  const char *const pbeg = RSTRING_PTR(str);
12469  char *buf;
12470  long len;
12471  int i;
12472 
12473  if (!yylloc) return;
12474  pend = RSTRING_END(str);
12475  if (pend > pbeg && pend[-1] == '\n') {
12476  if (--pend > pbeg && pend[-1] == '\r') --pend;
12477  }
12478 
12479  pt = pend;
12480  if (lineno == yylloc->end_pos.lineno &&
12481  (pend - pbeg) > yylloc->end_pos.column) {
12482  pt = pbeg + yylloc->end_pos.column;
12483  }
12484 
12485  ptr = ptr_end = pt;
12486  lim = ptr - pbeg > max_line_margin ? ptr - max_line_margin : pbeg;
12487  while ((lim < ptr) && (*(ptr-1) != '\n')) ptr--;
12488 
12489  lim = pend - ptr_end > max_line_margin ? ptr_end + max_line_margin : pend;
12490  while ((ptr_end < lim) && (*ptr_end != '\n') && (*ptr_end != '\r')) ptr_end++;
12491 
12492  len = ptr_end - ptr;
12493  if (len > 4) {
12494  if (ptr > pbeg) {
12495  ptr = rb_enc_prev_char(pbeg, ptr, pt, rb_enc_get(str));
12496  if (ptr > pbeg) pre = "...";
12497  }
12498  if (ptr_end < pend) {
12499  ptr_end = rb_enc_prev_char(pt, ptr_end, pend, rb_enc_get(str));
12500  if (ptr_end < pend) post = "...";
12501  }
12502  }
12503  pb = pbeg;
12504  if (lineno == yylloc->beg_pos.lineno) {
12505  pb += yylloc->beg_pos.column;
12506  if (pb > pt) pb = pt;
12507  }
12508  if (pb < ptr) pb = ptr;
12509  if (len <= 4 && yylloc->beg_pos.lineno == yylloc->end_pos.lineno) {
12510  return;
12511  }
12512  if (RTEST(errbuf)) {
12513  mesg = rb_attr_get(errbuf, idMesg);
12514  if (RSTRING_LEN(mesg) > 0 && *(RSTRING_END(mesg)-1) != '\n')
12515  rb_str_cat_cstr(mesg, "\n");
12516  }
12517  else {
12518  mesg = rb_enc_str_new(0, 0, rb_enc_get(str));
12519  }
12520  if (!errbuf && rb_stderr_tty_p()) {
12521 #define CSI_BEGIN "\033["
12522 #define CSI_SGR "m"
12523  rb_str_catf(mesg,
12524  CSI_BEGIN""CSI_SGR"%s" /* pre */
12525  CSI_BEGIN"1"CSI_SGR"%.*s"
12526  CSI_BEGIN"1;4"CSI_SGR"%.*s"
12527  CSI_BEGIN";1"CSI_SGR"%.*s"
12528  CSI_BEGIN""CSI_SGR"%s" /* post */
12529  "\n",
12530  pre,
12531  (int)(pb - ptr), ptr,
12532  (int)(pt - pb), pb,
12533  (int)(ptr_end - pt), pt,
12534  post);
12535  }
12536  else {
12537  char *p2;
12538 
12539  len = ptr_end - ptr;
12540  lim = pt < pend ? pt : pend;
12541  i = (int)(lim - ptr);
12542  buf = ALLOCA_N(char, i+2);
12543  code = ptr;
12544  caret = p2 = buf;
12545  if (ptr <= pb) {
12546  while (ptr < pb) {
12547  *p2++ = *ptr++ == '\t' ? '\t' : ' ';
12548  }
12549  *p2++ = '^';
12550  ptr++;
12551  }
12552  if (lim > ptr) {
12553  memset(p2, '~', (lim - ptr));
12554  p2 += (lim - ptr);
12555  }
12556  *p2 = '\0';
12557  rb_str_catf(mesg, "%s%.*s%s\n""%s%s\n",
12558  pre, (int)len, code, post,
12559  pre, caret);
12560  }
12561  if (!errbuf) rb_write_error_str(mesg);
12562 }
12563 #else
12564 static int
12565 parser_yyerror(struct parser_params *p, const YYLTYPE *yylloc, const char *msg)
12566 {
12567  const char *pcur = 0, *ptok = 0;
12568  if (yylloc &&
12569  p->ruby_sourceline == yylloc->beg_pos.lineno &&
12570  p->ruby_sourceline == yylloc->end_pos.lineno) {
12571  pcur = p->lex.pcur;
12572  ptok = p->lex.ptok;
12573  p->lex.ptok = p->lex.pbeg + yylloc->beg_pos.column;
12574  p->lex.pcur = p->lex.pbeg + yylloc->end_pos.column;
12575  }
12576  dispatch1(parse_error, STR_NEW2(msg));
12577  ripper_error(p);
12578  if (pcur) {
12579  p->lex.ptok = ptok;
12580  p->lex.pcur = pcur;
12581  }
12582  return 0;
12583 }
12584 
12585 static inline void
12586 parser_show_error_line(struct parser_params *p, const YYLTYPE *yylloc)
12587 {
12588 }
12589 #endif /* !RIPPER */
12590 
12591 #ifndef RIPPER
12592 static int
12593 vtable_size(const struct vtable *tbl)
12594 {
12595  if (!DVARS_TERMINAL_P(tbl)) {
12596  return tbl->pos;
12597  }
12598  else {
12599  return 0;
12600  }
12601 }
12602 #endif
12603 
12604 static struct vtable *
12605 vtable_alloc_gen(struct parser_params *p, int line, struct vtable *prev)
12606 {
12607  struct vtable *tbl = ALLOC(struct vtable);
12608  tbl->pos = 0;
12609  tbl->capa = 8;
12610  tbl->tbl = ALLOC_N(ID, tbl->capa);
12611  tbl->prev = prev;
12612 #ifndef RIPPER
12613  if (p->debug) {
12614  rb_parser_printf(p, "vtable_alloc:%d: %p\n", line, (void *)tbl);
12615  }
12616 #endif
12617  return tbl;
12618 }
12619 #define vtable_alloc(prev) vtable_alloc_gen(p, __LINE__, prev)
12620 
12621 static void
12622 vtable_free_gen(struct parser_params *p, int line, const char *name,
12623  struct vtable *tbl)
12624 {
12625 #ifndef RIPPER
12626  if (p->debug) {
12627  rb_parser_printf(p, "vtable_free:%d: %s(%p)\n", line, name, (void *)tbl);
12628  }
12629 #endif
12630  if (!DVARS_TERMINAL_P(tbl)) {
12631  if (tbl->tbl) {
12632  ruby_sized_xfree(tbl->tbl, tbl->capa * sizeof(ID));
12633  }
12634  ruby_sized_xfree(tbl, sizeof(tbl));
12635  }
12636 }
12637 #define vtable_free(tbl) vtable_free_gen(p, __LINE__, #tbl, tbl)
12638 
12639 static void
12640 vtable_add_gen(struct parser_params *p, int line, const char *name,
12641  struct vtable *tbl, ID id)
12642 {
12643 #ifndef RIPPER
12644  if (p->debug) {
12645  rb_parser_printf(p, "vtable_add:%d: %s(%p), %s\n",
12646  line, name, (void *)tbl, rb_id2name(id));
12647  }
12648 #endif
12649  if (DVARS_TERMINAL_P(tbl)) {
12650  rb_parser_fatal(p, "vtable_add: vtable is not allocated (%p)", (void *)tbl);
12651  return;
12652  }
12653  if (tbl->pos == tbl->capa) {
12654  tbl->capa = tbl->capa * 2;
12655  SIZED_REALLOC_N(tbl->tbl, ID, tbl->capa, tbl->pos);
12656  }
12657  tbl->tbl[tbl->pos++] = id;
12658 }
12659 #define vtable_add(tbl, id) vtable_add_gen(p, __LINE__, #tbl, tbl, id)
12660 
12661 #ifndef RIPPER
12662 static void
12663 vtable_pop_gen(struct parser_params *p, int line, const char *name,
12664  struct vtable *tbl, int n)
12665 {
12666  if (p->debug) {
12667  rb_parser_printf(p, "vtable_pop:%d: %s(%p), %d\n",
12668  line, name, (void *)tbl, n);
12669  }
12670  if (tbl->pos < n) {
12671  rb_parser_fatal(p, "vtable_pop: unreachable (%d < %d)", tbl->pos, n);
12672  return;
12673  }
12674  tbl->pos -= n;
12675 }
12676 #define vtable_pop(tbl, n) vtable_pop_gen(p, __LINE__, #tbl, tbl, n)
12677 #endif
12678 
12679 static int
12680 vtable_included(const struct vtable * tbl, ID id)
12681 {
12682  int i;
12683 
12684  if (!DVARS_TERMINAL_P(tbl)) {
12685  for (i = 0; i < tbl->pos; i++) {
12686  if (tbl->tbl[i] == id) {
12687  return i+1;
12688  }
12689  }
12690  }
12691  return 0;
12692 }
12693 
12694 static void parser_prepare(struct parser_params *p);
12695 
12696 #ifndef RIPPER
12697 static NODE *parser_append_options(struct parser_params *p, NODE *node);
12698 
12699 static VALUE
12700 debug_lines(VALUE fname)
12701 {
12702  ID script_lines;
12703  CONST_ID(script_lines, "SCRIPT_LINES__");
12704  if (rb_const_defined_at(rb_cObject, script_lines)) {
12705  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
12706  if (RB_TYPE_P(hash, T_HASH)) {
12707  VALUE lines = rb_ary_new();
12708  rb_hash_aset(hash, fname, lines);
12709  return lines;
12710  }
12711  }
12712  return 0;
12713 }
12714 
12715 static int
12716 e_option_supplied(struct parser_params *p)
12717 {
12718  return strcmp(p->ruby_sourcefile, "-e") == 0;
12719 }
12720 
12721 static VALUE
12722 yycompile0(VALUE arg)
12723 {
12724  int n;
12725  NODE *tree;
12726  struct parser_params *p = (struct parser_params *)arg;
12727  VALUE cov = Qfalse;
12728 
12731  if (p->debug_lines && p->ruby_sourceline > 0) {
12732  VALUE str = STR_NEW0();
12733  n = p->ruby_sourceline;
12734  do {
12736  } while (--n);
12737  }
12738 
12739  if (!e_option_supplied(p)) {
12740  cov = Qtrue;
12741  }
12742  }
12743 
12744  parser_prepare(p);
12745 #define RUBY_DTRACE_PARSE_HOOK(name) \
12746  if (RUBY_DTRACE_PARSE_##name##_ENABLED()) { \
12747  RUBY_DTRACE_PARSE_##name(p->ruby_sourcefile, p->ruby_sourceline); \
12748  }
12749  RUBY_DTRACE_PARSE_HOOK(BEGIN);
12750  n = yyparse(p);
12752  p->debug_lines = 0;
12753 
12754  p->lex.strterm = 0;
12755  p->lex.pcur = p->lex.pbeg = p->lex.pend = 0;
12756  p->lex.prevline = p->lex.lastline = p->lex.nextline = 0;
12757  if (n || p->error_p) {
12758  VALUE mesg = p->error_buffer;
12759  if (!mesg) {
12760  mesg = rb_class_new_instance(0, 0, rb_eSyntaxError);
12761  }
12762  rb_set_errinfo(mesg);
12763  return FALSE;
12764  }
12765  tree = p->eval_tree;
12766  if (!tree) {
12767  tree = NEW_NIL(&NULL_LOC);
12768  }
12769  else {
12770  VALUE opt = p->compile_option;
12771  NODE *prelude;
12772  NODE *body = parser_append_options(p, tree->nd_body);
12773  if (!opt) opt = rb_obj_hide(rb_ident_hash_new());
12774  rb_hash_aset(opt, rb_sym_intern_ascii_cstr("coverage_enabled"), cov);
12775  prelude = block_append(p, p->eval_tree_begin, body);
12776  tree->nd_body = prelude;
12777  RB_OBJ_WRITE(p->ast, &p->ast->body.compile_option, opt);
12778  }
12779  p->ast->body.root = tree;
12780  p->ast->body.line_count = p->line_count;
12781  return TRUE;
12782 }
12783 
12784 static rb_ast_t *
12785 yycompile(VALUE vparser, struct parser_params *p, VALUE fname, int line)
12786 {
12787  rb_ast_t *ast;
12788  if (NIL_P(fname)) {
12790  p->ruby_sourcefile = "(none)";
12791  }
12792  else {
12793  p->ruby_sourcefile_string = rb_fstring(fname);
12794  p->ruby_sourcefile = StringValueCStr(fname);
12795  }
12796  p->ruby_sourceline = line - 1;
12797 
12798  p->ast = ast = rb_ast_new();
12799  rb_suppress_tracing(yycompile0, (VALUE)p);
12800  p->ast = 0;
12801  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12802 
12803  return ast;
12804 }
12805 #endif /* !RIPPER */
12806 
12807 static rb_encoding *
12808 must_be_ascii_compatible(VALUE s)
12809 {
12810  rb_encoding *enc = rb_enc_get(s);
12811  if (!rb_enc_asciicompat(enc)) {
12812  rb_raise(rb_eArgError, "invalid source encoding");
12813  }
12814  return enc;
12815 }
12816 
12817 static VALUE
12818 lex_get_str(struct parser_params *p, VALUE s)
12819 {
12820  char *beg, *end, *start;
12821  long len;
12822 
12823  beg = RSTRING_PTR(s);
12824  len = RSTRING_LEN(s);
12825  start = beg;
12826  if (p->lex.gets_.ptr) {
12827  if (len == p->lex.gets_.ptr) return Qnil;
12828  beg += p->lex.gets_.ptr;
12829  len -= p->lex.gets_.ptr;
12830  }
12831  end = memchr(beg, '\n', len);
12832  if (end) len = ++end - beg;
12833  p->lex.gets_.ptr += len;
12834  return rb_str_subseq(s, beg - start, len);
12835 }
12836 
12837 static VALUE
12838 lex_getline(struct parser_params *p)
12839 {
12840  VALUE line = (*p->lex.gets)(p, p->lex.input);
12841  if (NIL_P(line)) return line;
12842  must_be_ascii_compatible(line);
12843 #ifndef RIPPER
12844  if (p->debug_lines) {
12845  rb_enc_associate(line, p->enc);
12846  rb_ary_push(p->debug_lines, line);
12847  }
12848 #endif
12849  p->line_count++;
12850  return line;
12851 }
12852 
12853 static const rb_data_type_t parser_data_type;
12854 
12855 #ifndef RIPPER
12856 static rb_ast_t*
12857 parser_compile_string(VALUE vparser, VALUE fname, VALUE s, int line)
12858 {
12859  struct parser_params *p;
12860 
12861  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
12862 
12863  p->lex.gets = lex_get_str;
12864  p->lex.gets_.ptr = 0;
12865  p->lex.input = rb_str_new_frozen(s);
12866  p->lex.pbeg = p->lex.pcur = p->lex.pend = 0;
12867 
12868  return yycompile(vparser, p, fname, line);
12869 }
12870 
12871 rb_ast_t*
12872 rb_parser_compile_string(VALUE vparser, const char *f, VALUE s, int line)
12873 {
12874  return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
12875 }
12876 
12877 rb_ast_t*
12879 {
12880  must_be_ascii_compatible(s);
12881  return parser_compile_string(vparser, f, s, line);
12882 }
12883 
12885 
12886 static VALUE
12887 lex_io_gets(struct parser_params *p, VALUE io)
12888 {
12889  return rb_io_gets_internal(io);
12890 }
12891 
12892 rb_ast_t*
12893 rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE file, int start)
12894 {
12895  struct parser_params *p;
12896 
12897  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
12898 
12899  p->lex.gets = lex_io_gets;
12900  p->lex.input = file;
12901  p->lex.pbeg = p->lex.pcur = p->lex.pend = 0;
12902 
12903  return yycompile(vparser, p, fname, start);
12904 }
12905 
12906 static VALUE
12907 lex_generic_gets(struct parser_params *p, VALUE input)
12908 {
12909  return (*p->lex.gets_.call)(input, p->line_count);
12910 }
12911 
12912 rb_ast_t*
12913 rb_parser_compile_generic(VALUE vparser, VALUE (*lex_gets)(VALUE, int), VALUE fname, VALUE input, int start)
12914 {
12915  struct parser_params *p;
12916 
12917  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
12918 
12919  p->lex.gets = lex_generic_gets;
12920  p->lex.gets_.call = lex_gets;
12921  p->lex.input = input;
12922  p->lex.pbeg = p->lex.pcur = p->lex.pend = 0;
12923 
12924  return yycompile(vparser, p, fname, start);
12925 }
12926 #endif /* !RIPPER */
12927 
12928 #define STR_FUNC_ESCAPE 0x01
12929 #define STR_FUNC_EXPAND 0x02
12930 #define STR_FUNC_REGEXP 0x04
12931 #define STR_FUNC_QWORDS 0x08
12932 #define STR_FUNC_SYMBOL 0x10
12933 #define STR_FUNC_INDENT 0x20
12934 #define STR_FUNC_LABEL 0x40
12935 #define STR_FUNC_LIST 0x4000
12936 #define STR_FUNC_TERM 0x8000
12937 
12940  str_squote = (0),
12948 };
12949 
12950 static VALUE
12951 parser_str_new(const char *ptr, long len, rb_encoding *enc, int func, rb_encoding *enc0)
12952 {
12953  VALUE str;
12954 
12955  str = rb_enc_str_new(ptr, len, enc);
12956  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12958  }
12959  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12961  }
12962  }
12963 
12964  return str;
12965 }
12966 
12967 #define lex_goto_eol(p) ((p)->lex.pcur = (p)->lex.pend)
12968 #define lex_eol_p(p) ((p)->lex.pcur >= (p)->lex.pend)
12969 #define lex_eol_n_p(p,n) ((p)->lex.pcur+(n) >= (p)->lex.pend)
12970 #define peek(p,c) peek_n(p, (c), 0)
12971 #define peek_n(p,c,n) (!lex_eol_n_p(p, n) && (c) == (unsigned char)(p)->lex.pcur[n])
12972 #define peekc(p) peekc_n(p, 0)
12973 #define peekc_n(p,n) (lex_eol_n_p(p, n) ? -1 : (unsigned char)(p)->lex.pcur[n])
12974 
12975 #ifdef RIPPER
12976 static void
12977 add_delayed_token(struct parser_params *p, const char *tok, const char *end)
12978 {
12979  if (tok < end) {
12980  if (!has_delayed_token(p)) {
12981  p->delayed.token = rb_str_buf_new(end - tok);
12982  rb_enc_associate(p->delayed.token, p->enc);
12983  p->delayed.line = p->ruby_sourceline;
12984  p->delayed.col = rb_long2int(tok - p->lex.pbeg);
12985  }
12986  rb_str_buf_cat(p->delayed.token, tok, end - tok);
12987  p->lex.ptok = end;
12988  }
12989 }
12990 #else
12991 #define add_delayed_token(p, tok, end) ((void)(tok), (void)(end))
12992 #endif
12993 
12994 static int
12995 nextline(struct parser_params *p)
12996 {
12997  VALUE v = p->lex.nextline;
12998  p->lex.nextline = 0;
12999  if (!v) {
13000  if (p->eofp)
13001  return -1;
13002 
13003  if (p->lex.pend > p->lex.pbeg && *(p->lex.pend-1) != '\n') {
13004  goto end_of_input;
13005  }
13006 
13007  if (!p->lex.input || NIL_P(v = lex_getline(p))) {
13008  end_of_input:
13009  p->eofp = 1;
13010  lex_goto_eol(p);
13011  return -1;
13012  }
13013  p->cr_seen = FALSE;
13014  }
13015  else if (NIL_P(v)) {
13016  /* after here-document without terminator */
13017  goto end_of_input;
13018  }
13019  add_delayed_token(p, p->lex.ptok, p->lex.pend);
13020  if (p->heredoc_end > 0) {
13021  p->ruby_sourceline = p->heredoc_end;
13022  p->heredoc_end = 0;
13023  }
13024  p->ruby_sourceline++;
13025  p->lex.pbeg = p->lex.pcur = RSTRING_PTR(v);
13026  p->lex.pend = p->lex.pcur + RSTRING_LEN(v);
13027  token_flush(p);
13028  p->lex.prevline = p->lex.lastline;
13029  p->lex.lastline = v;
13030  return 0;
13031 }
13032 
13033 static int
13034 parser_cr(struct parser_params *p, int c)
13035 {
13036  if (peek(p, '\n')) {
13037  p->lex.pcur++;
13038  c = '\n';
13039  }
13040  else if (!p->cr_seen) {
13041  p->cr_seen = TRUE;
13042  /* carried over with p->lex.nextline for nextc() */
13043  rb_warn0("encountered \\r in middle of line, treated as a mere space");
13044  }
13045  return c;
13046 }
13047 
13048 static inline int
13049 nextc(struct parser_params *p)
13050 {
13051  int c;
13052 
13053  if (UNLIKELY((p->lex.pcur == p->lex.pend) || p->eofp || RTEST(p->lex.nextline))) {
13054  if (nextline(p)) return -1;
13055  }
13056  c = (unsigned char)*p->lex.pcur++;
13057  if (UNLIKELY(c == '\r')) {
13058  c = parser_cr(p, c);
13059  }
13060 
13061  return c;
13062 }
13063 
13064 static void
13065 pushback(struct parser_params *p, int c)
13066 {
13067  if (c == -1) return;
13068  p->lex.pcur--;
13069  if (p->lex.pcur > p->lex.pbeg && p->lex.pcur[0] == '\n' && p->lex.pcur[-1] == '\r') {
13070  p->lex.pcur--;
13071  }
13072 }
13073 
13074 #define was_bol(p) ((p)->lex.pcur == (p)->lex.pbeg + 1)
13075 
13076 #define tokfix(p) ((p)->tokenbuf[(p)->tokidx]='\0')
13077 #define tok(p) (p)->tokenbuf
13078 #define toklen(p) (p)->tokidx
13079 
13080 static int
13081 looking_at_eol_p(struct parser_params *p)
13082 {
13083  const char *ptr = p->lex.pcur;
13084  while (ptr < p->lex.pend) {
13085  int c = (unsigned char)*ptr++;
13086  int eol = (c == '\n' || c == '#');
13087  if (eol || !ISSPACE(c)) {
13088  return eol;
13089  }
13090  }
13091  return TRUE;
13092 }
13093 
13094 static char*
13095 newtok(struct parser_params *p)
13096 {
13097  p->tokidx = 0;
13098  p->tokline = p->ruby_sourceline;
13099  if (!p->tokenbuf) {
13100  p->toksiz = 60;
13101  p->tokenbuf = ALLOC_N(char, 60);
13102  }
13103  if (p->toksiz > 4096) {
13104  p->toksiz = 60;
13105  REALLOC_N(p->tokenbuf, char, 60);
13106  }
13107  return p->tokenbuf;
13108 }
13109 
13110 static char *
13111 tokspace(struct parser_params *p, int n)
13112 {
13113  p->tokidx += n;
13114 
13115  if (p->tokidx >= p->toksiz) {
13116  do {p->toksiz *= 2;} while (p->toksiz < p->tokidx);
13117  REALLOC_N(p->tokenbuf, char, p->toksiz);
13118  }
13119  return &p->tokenbuf[p->tokidx-n];
13120 }
13121 
13122 static void
13123 tokadd(struct parser_params *p, int c)
13124 {
13125  p->tokenbuf[p->tokidx++] = (char)c;
13126  if (p->tokidx >= p->toksiz) {
13127  p->toksiz *= 2;
13128  REALLOC_N(p->tokenbuf, char, p->toksiz);
13129  }
13130 }
13131 
13132 static int
13133 tok_hex(struct parser_params *p, size_t *numlen)
13134 {
13135  int c;
13136 
13137  c = scan_hex(p->lex.pcur, 2, numlen);
13138  if (!*numlen) {
13139  yyerror0("invalid hex escape");
13140  token_flush(p);
13141  return 0;
13142  }
13143  p->lex.pcur += *numlen;
13144  return c;
13145 }
13146 
13147 #define tokcopy(p, n) memcpy(tokspace(p, n), (p)->lex.pcur - (n), (n))
13148 
13149 static int
13150 escaped_control_code(int c)
13151 {
13152  int c2 = 0;
13153  switch (c) {
13154  case ' ':
13155  c2 = 's';
13156  break;
13157  case '\n':
13158  c2 = 'n';
13159  break;
13160  case '\t':
13161  c2 = 't';
13162  break;
13163  case '\v':
13164  c2 = 'v';
13165  break;
13166  case '\r':
13167  c2 = 'r';
13168  break;
13169  case '\f':
13170  c2 = 'f';
13171  break;
13172  }
13173  return c2;
13174 }
13175 
13176 #define WARN_SPACE_CHAR(c, prefix) \
13177  rb_warn1("invalid character syntax; use "prefix"\\%c", WARN_I(c2))
13178 
13179 static int
13180 tokadd_codepoint(struct parser_params *p, rb_encoding **encp,
13181  int regexp_literal, int wide)
13182 {
13183  size_t numlen;
13184  int codepoint = scan_hex(p->lex.pcur, wide ? p->lex.pend - p->lex.pcur : 4, &numlen);
13185  literal_flush(p, p->lex.pcur);
13186  p->lex.pcur += numlen;
13187  if (wide ? (numlen == 0 || numlen > 6) : (numlen < 4)) {
13188  yyerror0("invalid Unicode escape");
13189  return wide && numlen > 0;
13190  }
13191  if (codepoint > 0x10ffff) {
13192  yyerror0("invalid Unicode codepoint (too large)");
13193  return wide;
13194  }
13195  if ((codepoint & 0xfffff800) == 0xd800) {
13196  yyerror0("invalid Unicode codepoint");
13197  return wide;
13198  }
13199  if (regexp_literal) {
13200  tokcopy(p, (int)numlen);
13201  }
13202  else if (codepoint >= 0x80) {
13203  rb_encoding *utf8 = rb_utf8_encoding();
13204  if (*encp && utf8 != *encp) {
13205  YYLTYPE loc = RUBY_INIT_YYLLOC();
13206  compile_error(p, "UTF-8 mixed within %s source", rb_enc_name(*encp));
13207  parser_show_error_line(p, &loc);
13208  return wide;
13209  }
13210  *encp = utf8;
13211  tokaddmbc(p, codepoint, *encp);
13212  }
13213  else {
13214  tokadd(p, codepoint);
13215  }
13216  return TRUE;
13217 }
13218 
13219 /* return value is for ?\u3042 */
13220 static void
13221 tokadd_utf8(struct parser_params *p, rb_encoding **encp,
13222  int term, int symbol_literal, int regexp_literal)
13223 {
13224  /*
13225  * If `term` is not -1, then we allow multiple codepoints in \u{}
13226  * upto `term` byte, otherwise we're parsing a character literal.
13227  * And then add the codepoints to the current token.
13228  */
13229  static const char multiple_codepoints[] = "Multiple codepoints at single character literal";
13230 
13231  const int open_brace = '{', close_brace = '}';
13232 
13233  if (regexp_literal) { tokadd(p, '\\'); tokadd(p, 'u'); }
13234 
13235  if (peek(p, open_brace)) { /* handle \u{...} form */
13236  const char *second = NULL;
13237  int c, last = nextc(p);
13238  if (p->lex.pcur >= p->lex.pend) goto unterminated;
13239  while (ISSPACE(c = *p->lex.pcur) && ++p->lex.pcur < p->lex.pend);
13240  while (c != close_brace) {
13241  if (c == term) goto unterminated;
13242  if (second == multiple_codepoints)
13243  second = p->lex.pcur;
13244  if (regexp_literal) tokadd(p, last);
13245  if (!tokadd_codepoint(p, encp, regexp_literal, TRUE)) {
13246  break;
13247  }
13248  while (ISSPACE(c = *p->lex.pcur)) {
13249  if (++p->lex.pcur >= p->lex.pend) goto unterminated;
13250  last = c;
13251  }
13252  if (term == -1 && !second)
13253  second = multiple_codepoints;
13254  }
13255 
13256  if (c != close_brace) {
13257  unterminated:
13258  token_flush(p);
13259  yyerror0("unterminated Unicode escape");
13260  return;
13261  }
13262  if (second && second != multiple_codepoints) {
13263  const char *pcur = p->lex.pcur;
13264  p->lex.pcur = second;
13266  token_flush(p);
13267  p->lex.pcur = pcur;
13268  yyerror0(multiple_codepoints);
13269  token_flush(p);
13270  }
13271 
13272  if (regexp_literal) tokadd(p, close_brace);
13273  nextc(p);
13274  }
13275  else { /* handle \uxxxx form */
13276  if (!tokadd_codepoint(p, encp, regexp_literal, FALSE)) {
13277  token_flush(p);
13278  return;
13279  }
13280  }
13281 }
13282 
13283 #define ESCAPE_CONTROL 1
13284 #define ESCAPE_META 2
13285 
13286 static int
13287 read_escape(struct parser_params *p, int flags, rb_encoding **encp)
13288 {
13289  int c;
13290  size_t numlen;
13291 
13292  switch (c = nextc(p)) {
13293  case '\\': /* Backslash */
13294  return c;
13295 
13296  case 'n': /* newline */
13297  return '\n';
13298 
13299  case 't': /* horizontal tab */
13300  return '\t';
13301 
13302  case 'r': /* carriage-return */
13303  return '\r';
13304 
13305  case 'f': /* form-feed */
13306  return '\f';
13307 
13308  case 'v': /* vertical tab */
13309  return '\13';
13310 
13311  case 'a': /* alarm(bell) */
13312  return '\007';
13313 
13314  case 'e': /* escape */
13315  return 033;
13316 
13317  case '0': case '1': case '2': case '3': /* octal constant */
13318  case '4': case '5': case '6': case '7':
13319  pushback(p, c);
13320  c = scan_oct(p->lex.pcur, 3, &numlen);
13321  p->lex.pcur += numlen;
13322  return c;
13323 
13324  case 'x': /* hex constant */
13325  c = tok_hex(p, &numlen);
13326  if (numlen == 0) return 0;
13327  return c;
13328 
13329  case 'b': /* backspace */
13330  return '\010';
13331 
13332  case 's': /* space */
13333  return ' ';
13334 
13335  case 'M':
13336  if (flags & ESCAPE_META) goto eof;
13337  if ((c = nextc(p)) != '-') {
13338  goto eof;
13339  }
13340  if ((c = nextc(p)) == '\\') {
13341  if (peek(p, 'u')) goto eof;
13342  return read_escape(p, flags|ESCAPE_META, encp) | 0x80;
13343  }
13344  else if (c == -1 || !ISASCII(c)) goto eof;
13345  else {
13346  int c2 = escaped_control_code(c);
13347  if (c2) {
13348  if (ISCNTRL(c) || !(flags & ESCAPE_CONTROL)) {
13349  WARN_SPACE_CHAR(c2, "\\M-");
13350  }
13351  else {
13352  WARN_SPACE_CHAR(c2, "\\C-\\M-");
13353  }
13354  }
13355  else if (ISCNTRL(c)) goto eof;
13356  return ((c & 0xff) | 0x80);
13357  }
13358 
13359  case 'C':
13360  if ((c = nextc(p)) != '-') {
13361  goto eof;
13362  }
13363  case 'c':
13364  if (flags & ESCAPE_CONTROL) goto eof;
13365  if ((c = nextc(p))== '\\') {
13366  if (peek(p, 'u')) goto eof;
13367  c = read_escape(p, flags|ESCAPE_CONTROL, encp);
13368  }
13369  else if (c == '?')
13370  return 0177;
13371  else if (c == -1 || !ISASCII(c)) goto eof;
13372  else {
13373  int c2 = escaped_control_code(c);
13374  if (c2) {
13375  if (ISCNTRL(c)) {
13376  if (flags & ESCAPE_META) {
13377  WARN_SPACE_CHAR(c2, "\\M-");
13378  }
13379  else {
13380  WARN_SPACE_CHAR(c2, "");
13381  }
13382  }
13383  else {
13384  if (flags & ESCAPE_META) {
13385  WARN_SPACE_CHAR(c2, "\\M-\\C-");
13386  }
13387  else {
13388  WARN_SPACE_CHAR(c2, "\\C-");
13389  }
13390  }
13391  }
13392  else if (ISCNTRL(c)) goto eof;
13393  }
13394  return c & 0x9f;
13395 
13396  eof:
13397  case -1:
13398  yyerror0("Invalid escape character syntax");
13399  token_flush(p);
13400  return '\0';
13401 
13402  default:
13403  return c;
13404  }
13405 }
13406 
13407 static void
13408 tokaddmbc(struct parser_params *p, int c, rb_encoding *enc)
13409 {
13410  int len = rb_enc_codelen(c, enc);
13411  rb_enc_mbcput(c, tokspace(p, len), enc);
13412 }
13413 
13414 static int
13415 tokadd_escape(struct parser_params *p, rb_encoding **encp)
13416 {
13417  int c;
13418  int flags = 0;
13419  size_t numlen;
13420 
13421  first:
13422  switch (c = nextc(p)) {
13423  case '\n':
13424  return 0; /* just ignore */
13425 
13426  case '0': case '1': case '2': case '3': /* octal constant */
13427  case '4': case '5': case '6': case '7':
13428  {
13429  ruby_scan_oct(--p->lex.pcur, 3, &numlen);
13430  if (numlen == 0) goto eof;
13431  p->lex.pcur += numlen;
13432  tokcopy(p, (int)numlen + 1);
13433  }
13434  return 0;
13435 
13436  case 'x': /* hex constant */
13437  {
13438  tok_hex(p, &numlen);
13439  if (numlen == 0) return -1;
13440  tokcopy(p, (int)numlen + 2);
13441  }
13442  return 0;
13443 
13444  case 'M':
13445  if (flags & ESCAPE_META) goto eof;
13446  if ((c = nextc(p)) != '-') {
13447  pushback(p, c);
13448  goto eof;
13449  }
13450  tokcopy(p, 3);
13451  flags |= ESCAPE_META;
13452  goto escaped;
13453 
13454  case 'C':
13455  if (flags & ESCAPE_CONTROL) goto eof;
13456  if ((c = nextc(p)) != '-') {
13457  pushback(p, c);
13458  goto eof;
13459  }
13460  tokcopy(p, 3);
13461  goto escaped;
13462 
13463  case 'c':
13464  if (flags & ESCAPE_CONTROL) goto eof;
13465  tokcopy(p, 2);
13466  flags |= ESCAPE_CONTROL;
13467  escaped:
13468  if ((c = nextc(p)) == '\\') {
13469  goto first;
13470  }
13471  else if (c == -1) goto eof;
13472  tokadd(p, c);
13473  return 0;
13474 
13475  eof:
13476  case -1:
13477  yyerror0("Invalid escape character syntax");
13478  token_flush(p);
13479  return -1;
13480 
13481  default:
13482  tokadd(p, '\\');
13483  tokadd(p, c);
13484  }
13485  return 0;
13486 }
13487 
13488 static int
13489 regx_options(struct parser_params *p)
13490 {
13491  int kcode = 0;
13492  int kopt = 0;
13493  int options = 0;
13494  int c, opt, kc;
13495 
13496  newtok(p);
13497  while (c = nextc(p), ISALPHA(c)) {
13498  if (c == 'o') {
13499  options |= RE_OPTION_ONCE;
13500  }
13501  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
13502  if (kc >= 0) {
13503  if (kc != rb_ascii8bit_encindex()) kcode = c;
13504  kopt = opt;
13505  }
13506  else {
13507  options |= opt;
13508  }
13509  }
13510  else {
13511  tokadd(p, c);
13512  }
13513  }
13514  options |= kopt;
13515  pushback(p, c);
13516  if (toklen(p)) {
13517  YYLTYPE loc = RUBY_INIT_YYLLOC();
13518  tokfix(p);
13519  compile_error(p, "unknown regexp option%s - %*s",
13520  toklen(p) > 1 ? "s" : "", toklen(p), tok(p));
13521  parser_show_error_line(p, &loc);
13522  }
13523  return options | RE_OPTION_ENCODING(kcode);
13524 }
13525 
13526 static int
13527 tokadd_mbchar(struct parser_params *p, int c)
13528 {
13529  int len = parser_precise_mbclen(p, p->lex.pcur-1);
13530  if (len < 0) return -1;
13531  tokadd(p, c);
13532  p->lex.pcur += --len;
13533  if (len > 0) tokcopy(p, len);
13534  return c;
13535 }
13536 
13537 static inline int
13538 simple_re_meta(int c)
13539 {
13540  switch (c) {
13541  case '$': case '*': case '+': case '.':
13542  case '?': case '^': case '|':
13543  case ')': case ']': case '}': case '>':
13544  return TRUE;
13545  default:
13546  return FALSE;
13547  }
13548 }
13549 
13550 static int
13551 parser_update_heredoc_indent(struct parser_params *p, int c)
13552 {
13553  if (p->heredoc_line_indent == -1) {
13554  if (c == '\n') p->heredoc_line_indent = 0;
13555  }
13556  else {
13557  if (c == ' ') {
13558  p->heredoc_line_indent++;
13559  return TRUE;
13560  }
13561  else if (c == '\t') {
13562  int w = (p->heredoc_line_indent / TAB_WIDTH) + 1;
13563  p->heredoc_line_indent = w * TAB_WIDTH;
13564  return TRUE;
13565  }
13566  else if (c != '\n') {
13567  if (p->heredoc_indent > p->heredoc_line_indent) {
13569  }
13570  p->heredoc_line_indent = -1;
13571  }
13572  }
13573  return FALSE;
13574 }
13575 
13576 static void
13577 parser_mixed_error(struct parser_params *p, rb_encoding *enc1, rb_encoding *enc2)
13578 {
13579  YYLTYPE loc = RUBY_INIT_YYLLOC();
13580  const char *n1 = rb_enc_name(enc1), *n2 = rb_enc_name(enc2);
13581  compile_error(p, "%s mixed within %s source", n1, n2);
13582  parser_show_error_line(p, &loc);
13583 }
13584 
13585 static void
13586 parser_mixed_escape(struct parser_params *p, const char *beg, rb_encoding *enc1, rb_encoding *enc2)
13587 {
13588  const char *pos = p->lex.pcur;
13589  p->lex.pcur = beg;
13590  parser_mixed_error(p, enc1, enc2);
13591  p->lex.pcur = pos;
13592 }
13593 
13594 static int
13595 tokadd_string(struct parser_params *p,
13596  int func, int term, int paren, long *nest,
13597  rb_encoding **encp, rb_encoding **enc)
13598 {
13599  int c;
13600  bool erred = false;
13601 
13602 #define mixed_error(enc1, enc2) \
13603  (void)(erred || (parser_mixed_error(p, enc1, enc2), erred = true))
13604 #define mixed_escape(beg, enc1, enc2) \
13605  (void)(erred || (parser_mixed_escape(p, beg, enc1, enc2), erred = true))
13606 
13607  while ((c = nextc(p)) != -1) {
13608  if (p->heredoc_indent > 0) {
13609  parser_update_heredoc_indent(p, c);
13610  }
13611 
13612  if (paren && c == paren) {
13613  ++*nest;
13614  }
13615  else if (c == term) {
13616  if (!nest || !*nest) {
13617  pushback(p, c);
13618  break;
13619  }
13620  --*nest;
13621  }
13622  else if ((func & STR_FUNC_EXPAND) && c == '#' && p->lex.pcur < p->lex.pend) {
13623  int c2 = *p->lex.pcur;
13624  if (c2 == '$' || c2 == '@' || c2 == '{') {
13625  pushback(p, c);
13626  break;
13627  }
13628  }
13629  else if (c == '\\') {
13630  literal_flush(p, p->lex.pcur - 1);
13631  c = nextc(p);
13632  switch (c) {
13633  case '\n':
13634  if (func & STR_FUNC_QWORDS) break;
13635  if (func & STR_FUNC_EXPAND) {
13636  if (!(func & STR_FUNC_INDENT) || (p->heredoc_indent < 0))
13637  continue;
13638  if (c == term) {
13639  c = '\\';
13640  goto terminate;
13641  }
13642  }
13643  tokadd(p, '\\');
13644  break;
13645 
13646  case '\\':
13647  if (func & STR_FUNC_ESCAPE) tokadd(p, c);
13648  break;
13649 
13650  case 'u':
13651  if ((func & STR_FUNC_EXPAND) == 0) {
13652  tokadd(p, '\\');
13653  break;
13654  }
13655  tokadd_utf8(p, enc, term,
13656  func & STR_FUNC_SYMBOL,
13657  func & STR_FUNC_REGEXP);
13658  continue;
13659 
13660  default:
13661  if (c == -1) return -1;
13662  if (!ISASCII(c)) {
13663  if ((func & STR_FUNC_EXPAND) == 0) tokadd(p, '\\');
13664  goto non_ascii;
13665  }
13666  if (func & STR_FUNC_REGEXP) {
13667  if (c == term && !simple_re_meta(c)) {
13668  tokadd(p, c);
13669  continue;
13670  }
13671  pushback(p, c);
13672  if ((c = tokadd_escape(p, enc)) < 0)
13673  return -1;
13674  if (*enc && *enc != *encp) {
13675  mixed_escape(p->lex.ptok+2, *enc, *encp);
13676  }
13677  continue;
13678  }
13679  else if (func & STR_FUNC_EXPAND) {
13680  pushback(p, c);
13681  if (func & STR_FUNC_ESCAPE) tokadd(p, '\\');
13682  c = read_escape(p, 0, enc);
13683  }
13684  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
13685  /* ignore backslashed spaces in %w */
13686  }
13687  else if (c != term && !(paren && c == paren)) {
13688  tokadd(p, '\\');
13689  pushback(p, c);
13690  continue;
13691  }
13692  }
13693  }
13694  else if (!parser_isascii(p)) {
13695  non_ascii:
13696  if (!*enc) {
13697  *enc = *encp;
13698  }
13699  else if (*enc != *encp) {
13700  mixed_error(*enc, *encp);
13701  continue;
13702  }
13703  if (tokadd_mbchar(p, c) == -1) return -1;
13704  continue;
13705  }
13706  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
13707  pushback(p, c);
13708  break;
13709  }
13710  if (c & 0x80) {
13711  if (!*enc) {
13712  *enc = *encp;
13713  }
13714  else if (*enc != *encp) {
13715  mixed_error(*enc, *encp);
13716  continue;
13717  }
13718  }
13719  tokadd(p, c);
13720  }
13721  terminate:
13722  if (*enc) *encp = *enc;
13723  return c;
13724 }
13725 
13726 static inline rb_strterm_t *
13727 new_strterm(VALUE v1, VALUE v2, VALUE v3, VALUE v0)
13728 {
13729  return (rb_strterm_t*)rb_imemo_new(imemo_parser_strterm, v1, v2, v3, v0);
13730 }
13731 
13732 /* imemo_parser_strterm for literal */
13733 #define NEW_STRTERM(func, term, paren) \
13734  new_strterm((VALUE)(func), (VALUE)(paren), (VALUE)(term), 0)
13735 
13736 #ifdef RIPPER
13737 static void
13739 {
13740  VALUE content = yylval.val;
13741  if (!ripper_is_node_yylval(content))
13742  content = ripper_new_yylval(p, 0, 0, content);
13743  if (has_delayed_token(p)) {
13744  ptrdiff_t len = p->lex.pcur - p->lex.ptok;
13745  if (len > 0) {
13746  rb_enc_str_buf_cat(p->delayed.token, p->lex.ptok, len, enc);
13747  }
13749  p->lex.ptok = p->lex.pcur;
13750  RNODE(content)->nd_rval = yylval.val;
13751  }
13753  if (yylval.val != content)
13754  RNODE(content)->nd_rval = yylval.val;
13755  yylval.val = content;
13756 }
13757 #else
13758 #define flush_string_content(p, enc) ((void)(enc))
13759 #endif
13760 
13761 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
13762 /* this can be shared with ripper, since it's independent from struct
13763  * parser_params. */
13764 #ifndef RIPPER
13765 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
13766 #define SPECIAL_PUNCT(idx) ( \
13767  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
13768  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
13769  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
13770  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
13771  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
13772  BIT('0', idx))
13773 const unsigned int ruby_global_name_punct_bits[] = {
13774  SPECIAL_PUNCT(0),
13775  SPECIAL_PUNCT(1),
13776  SPECIAL_PUNCT(2),
13777 };
13778 #undef BIT
13779 #undef SPECIAL_PUNCT
13780 #endif
13781 
13782 static enum yytokentype
13783 parser_peek_variable_name(struct parser_params *p)
13784 {
13785  int c;
13786  const char *ptr = p->lex.pcur;
13787 
13788  if (ptr + 1 >= p->lex.pend) return 0;
13789  c = *ptr++;
13790  switch (c) {
13791  case '$':
13792  if ((c = *ptr) == '-') {
13793  if (++ptr >= p->lex.pend) return 0;
13794  c = *ptr;
13795  }
13796  else if (is_global_name_punct(c) || ISDIGIT(c)) {
13797  return tSTRING_DVAR;
13798  }
13799  break;
13800  case '@':
13801  if ((c = *ptr) == '@') {
13802  if (++ptr >= p->lex.pend) return 0;
13803  c = *ptr;
13804  }
13805  break;
13806  case '{':
13807  p->lex.pcur = ptr;
13808  p->command_start = TRUE;
13809  return tSTRING_DBEG;
13810  default:
13811  return 0;
13812  }
13813  if (!ISASCII(c) || c == '_' || ISALPHA(c))
13814  return tSTRING_DVAR;
13815  return 0;
13816 }
13817 
13818 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13819 #define IS_END() IS_lex_state(EXPR_END_ANY)
13820 #define IS_BEG() (IS_lex_state(EXPR_BEG_ANY) || IS_lex_state_all(EXPR_ARG|EXPR_LABELED))
13821 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13822 #define IS_LABEL_POSSIBLE() (\
13823  (IS_lex_state(EXPR_LABEL|EXPR_ENDFN) && !cmd_state) || \
13824  IS_ARG())
13825 #define IS_LABEL_SUFFIX(n) (peek_n(p, ':',(n)) && !peek_n(p, ':', (n)+1))
13826 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13827 
13828 static inline enum yytokentype
13829 parser_string_term(struct parser_params *p, int func)
13830 {
13831  p->lex.strterm = 0;
13832  if (func & STR_FUNC_REGEXP) {
13833  set_yylval_num(regx_options(p));
13835  SET_LEX_STATE(EXPR_END);
13836  return tREGEXP_END;
13837  }
13838  if ((func & STR_FUNC_LABEL) && IS_LABEL_SUFFIX(0)) {
13839  nextc(p);
13840  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
13841  return tLABEL_END;
13842  }
13843  SET_LEX_STATE(EXPR_END);
13844  return tSTRING_END;
13845 }
13846 
13847 static enum yytokentype
13848 parse_string(struct parser_params *p, rb_strterm_literal_t *quote)
13849 {
13850  int func = (int)quote->u1.func;
13851  int term = (int)quote->u3.term;
13852  int paren = (int)quote->u2.paren;
13853  int c, space = 0;
13854  rb_encoding *enc = p->enc;
13855  rb_encoding *base_enc = 0;
13856  VALUE lit;
13857 
13858  if (func & STR_FUNC_TERM) {
13859  if (func & STR_FUNC_QWORDS) nextc(p); /* delayed term */
13860  SET_LEX_STATE(EXPR_END);
13861  p->lex.strterm = 0;
13862  return func & STR_FUNC_REGEXP ? tREGEXP_END : tSTRING_END;
13863  }
13864  c = nextc(p);
13865  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
13866  do {c = nextc(p);} while (ISSPACE(c));
13867  space = 1;
13868  }
13869  if (func & STR_FUNC_LIST) {
13870  quote->u1.func &= ~STR_FUNC_LIST;
13871  space = 1;
13872  }
13873  if (c == term && !quote->u0.nest) {
13874  if (func & STR_FUNC_QWORDS) {
13875  quote->u1.func |= STR_FUNC_TERM;
13876  pushback(p, c); /* dispatch the term at tSTRING_END */
13877  add_delayed_token(p, p->lex.ptok, p->lex.pcur);
13878  return ' ';
13879  }
13880  return parser_string_term(p, func);
13881  }
13882  if (space) {
13883  pushback(p, c);
13884  add_delayed_token(p, p->lex.ptok, p->lex.pcur);
13885  return ' ';
13886  }
13887  newtok(p);
13888  if ((func & STR_FUNC_EXPAND) && c == '#') {
13889  int t = parser_peek_variable_name(p);
13890  if (t) return t;
13891  tokadd(p, '#');
13892  c = nextc(p);
13893  }
13894  pushback(p, c);
13895  if (tokadd_string(p, func, term, paren, &quote->u0.nest,
13896  &enc, &base_enc) == -1) {
13897  if (p->eofp) {
13898 #ifndef RIPPER
13899 # define unterminated_literal(mesg) yyerror0(mesg)
13900 #else
13901 # define unterminated_literal(mesg) compile_error(p, mesg)
13902 #endif
13903  literal_flush(p, p->lex.pcur);
13904  if (func & STR_FUNC_QWORDS) {
13905  /* no content to add, bailing out here */
13906  unterminated_literal("unterminated list meets end of file");
13907  p->lex.strterm = 0;
13908  return tSTRING_END;
13909  }
13910  if (func & STR_FUNC_REGEXP) {
13911  unterminated_literal("unterminated regexp meets end of file");
13912  }
13913  else {
13914  unterminated_literal("unterminated string meets end of file");
13915  }
13916  quote->u1.func |= STR_FUNC_TERM;
13917  }
13918  }
13919 
13920  tokfix(p);
13921  lit = STR_NEW3(tok(p), toklen(p), enc, func);
13922  set_yylval_str(lit);
13924 
13925  return tSTRING_CONTENT;
13926 }
13927 
13928 static enum yytokentype
13929 heredoc_identifier(struct parser_params *p)
13930 {
13931  /*
13932  * term_len is length of `<<"END"` except `END`,
13933  * in this case term_len is 4 (<, <, " and ").
13934  */
13935  long len, offset = p->lex.pcur - p->lex.pbeg;
13936  int c = nextc(p), term, func = 0, quote = 0;
13937  enum yytokentype token = tSTRING_BEG;
13938  int indent = 0;
13939 
13940  if (c == '-') {
13941  c = nextc(p);
13942  func = STR_FUNC_INDENT;
13943  offset++;
13944  }
13945  else if (c == '~') {
13946  c = nextc(p);
13947  func = STR_FUNC_INDENT;
13948  offset++;
13949  indent = INT_MAX;
13950  }
13951  switch (c) {
13952  case '\'':
13953  func |= str_squote; goto quoted;
13954  case '"':
13955  func |= str_dquote; goto quoted;
13956  case '`':
13957  token = tXSTRING_BEG;
13958  func |= str_xquote; goto quoted;
13959 
13960  quoted:
13961  quote++;
13962  offset++;
13963  term = c;
13964  len = 0;
13965  while ((c = nextc(p)) != term) {
13966  if (c == -1 || c == '\r' || c == '\n') {
13967  yyerror(NULL, p, "unterminated here document identifier");
13968  return -1;
13969  }
13970  }
13971  break;
13972 
13973  default:
13974  if (!parser_is_identchar(p)) {
13975  pushback(p, c);
13976  if (func & STR_FUNC_INDENT) {
13977  pushback(p, indent > 0 ? '~' : '-');
13978  }
13979  return 0;
13980  }
13981  func |= str_dquote;
13982  do {
13983  int n = parser_precise_mbclen(p, p->lex.pcur-1);
13984  if (n < 0) return 0;
13985  p->lex.pcur += --n;
13986  } while ((c = nextc(p)) != -1 && parser_is_identchar(p));
13987  pushback(p, c);
13988  break;
13989  }
13990 
13991  len = p->lex.pcur - (p->lex.pbeg + offset) - quote;
13992  if ((unsigned long)len >= HERETERM_LENGTH_MAX)
13993  yyerror(NULL, p, "too long here document identifier");
13995  lex_goto_eol(p);
13996 
13997  p->lex.strterm = new_strterm(0, 0, 0, p->lex.lastline);
13999  rb_strterm_heredoc_t *here = &p->lex.strterm->u.heredoc;
14000  here->offset = offset;
14001  here->sourceline = p->ruby_sourceline;
14002  here->length = (int)len;
14003  here->quote = quote;
14004  here->func = func;
14005 
14006  token_flush(p);
14007  p->heredoc_indent = indent;
14008  p->heredoc_line_indent = 0;
14009  return token;
14010 }
14011 
14012 static void
14013 heredoc_restore(struct parser_params *p, rb_strterm_heredoc_t *here)
14014 {
14015  VALUE line;
14016 
14017  p->lex.strterm = 0;
14018  line = here->lastline;
14019  p->lex.lastline = line;
14020  p->lex.pbeg = RSTRING_PTR(line);
14021  p->lex.pend = p->lex.pbeg + RSTRING_LEN(line);
14022  p->lex.pcur = p->lex.pbeg + here->offset + here->length + here->quote;
14023  p->lex.ptok = p->lex.pbeg + here->offset - here->quote;
14024  p->heredoc_end = p->ruby_sourceline;
14025  p->ruby_sourceline = (int)here->sourceline;
14026  if (p->eofp) p->lex.nextline = Qnil;
14027  p->eofp = 0;
14028 }
14029 
14030 static int
14031 dedent_string(VALUE string, int width)
14032 {
14033  char *str;
14034  long len;
14035  int i, col = 0;
14036 
14037  RSTRING_GETMEM(string, str, len);
14038  for (i = 0; i < len && col < width; i++) {
14039  if (str[i] == ' ') {
14040  col++;
14041  }
14042  else if (str[i] == '\t') {
14043  int n = TAB_WIDTH * (col / TAB_WIDTH + 1);
14044  if (n > width) break;
14045  col = n;
14046  }
14047  else {
14048  break;
14049  }
14050  }
14051  if (!i) return 0;
14052  rb_str_modify(string);
14053  str = RSTRING_PTR(string);
14054  if (RSTRING_LEN(string) != len)
14055  rb_fatal("literal string changed: %+"PRIsVALUE, string);
14056  MEMMOVE(str, str + i, char, len - i);
14057  rb_str_set_len(string, len - i);
14058  return i;
14059 }
14060 
14061 #ifndef RIPPER
14062 static NODE *
14063 heredoc_dedent(struct parser_params *p, NODE *root)
14064 {
14065  NODE *node, *str_node, *prev_node;
14066  int indent = p->heredoc_indent;
14067  VALUE prev_lit = 0;
14068 
14069  if (indent <= 0) return root;
14070  p->heredoc_indent = 0;
14071  if (!root) return root;
14072 
14073  prev_node = node = str_node = root;
14074  if (nd_type(root) == NODE_LIST) str_node = root->nd_head;
14075 
14076  while (str_node) {
14077  VALUE lit = str_node->nd_lit;
14078  if (str_node->flags & NODE_FL_NEWLINE) {
14079  dedent_string(lit, indent);
14080  }
14081  if (!prev_lit) {
14082  prev_lit = lit;
14083  }
14084  else if (!literal_concat0(p, prev_lit, lit)) {
14085  return 0;
14086  }
14087  else {
14088  NODE *end = node->nd_end;
14089  node = prev_node->nd_next = node->nd_next;
14090  if (!node) {
14091  if (nd_type(prev_node) == NODE_DSTR)
14092  nd_set_type(prev_node, NODE_STR);
14093  break;
14094  }
14095  node->nd_end = end;
14096  goto next_str;
14097  }
14098 
14099  str_node = 0;
14100  while ((node = (prev_node = node)->nd_next) != 0) {
14101  next_str:
14102  if (nd_type(node) != NODE_LIST) break;
14103  if ((str_node = node->nd_head) != 0) {
14104  enum node_type type = nd_type(str_node);
14105  if (type == NODE_STR || type == NODE_DSTR) break;
14106  prev_lit = 0;
14107  str_node = 0;
14108  }
14109  }
14110  }
14111  return root;
14112 }
14113 #else /* RIPPER */
14114 static VALUE
14115 heredoc_dedent(struct parser_params *p, VALUE array)
14116 {
14117  int indent = p->heredoc_indent;
14118 
14119  if (indent <= 0) return array;
14120  p->heredoc_indent = 0;
14121  dispatch2(heredoc_dedent, array, INT2NUM(indent));
14122  return array;
14123 }
14124 
14125 /*
14126  * call-seq:
14127  * Ripper.dedent_string(input, width) -> Integer
14128  *
14129  * USE OF RIPPER LIBRARY ONLY.
14130  *
14131  * Strips up to +width+ leading whitespaces from +input+,
14132  * and returns the stripped column width.
14133  */
14134 static VALUE
14135 parser_dedent_string(VALUE self, VALUE input, VALUE width)
14136 {
14137  int wid, col;
14138 
14139  StringValue(input);
14140  wid = NUM2UINT(width);
14141  col = dedent_string(input, wid);
14142  return INT2NUM(col);
14143 }
14144 #endif
14145 
14146 static int
14147 whole_match_p(struct parser_params *p, const char *eos, long len, int indent)
14148 {
14149  const char *ptr = p->lex.pbeg;
14150  long n;
14151 
14152  if (indent) {
14153  while (*ptr && ISSPACE(*ptr)) ptr++;
14154  }
14155  n = p->lex.pend - (ptr + len);
14156  if (n < 0) return FALSE;
14157  if (n > 0 && ptr[len] != '\n') {
14158  if (ptr[len] != '\r') return FALSE;
14159  if (n <= 1 || ptr[len+1] != '\n') return FALSE;
14160  }
14161  return strncmp(eos, ptr, len) == 0;
14162 }
14163 
14164 static int
14165 word_match_p(struct parser_params *p, const char *word, long len)
14166 {
14167  if (strncmp(p->lex.pcur, word, len)) return 0;
14168  if (p->lex.pcur + len == p->lex.pend) return 1;
14169  int c = (unsigned char)p->lex.pcur[len];
14170  if (ISSPACE(c)) return 1;
14171  switch (c) {
14172  case '\0': case '\004': case '\032': return 1;
14173  }
14174  return 0;
14175 }
14176 
14177 #define NUM_SUFFIX_R (1<<0)
14178 #define NUM_SUFFIX_I (1<<1)
14179 #define NUM_SUFFIX_ALL 3
14180 
14181 static int
14182 number_literal_suffix(struct parser_params *p, int mask)
14183 {
14184  int c, result = 0;
14185  const char *lastp = p->lex.pcur;
14186 
14187  while ((c = nextc(p)) != -1) {
14188  if ((mask & NUM_SUFFIX_I) && c == 'i') {
14189  result |= (mask & NUM_SUFFIX_I);
14190  mask &= ~NUM_SUFFIX_I;
14191  /* r after i, rational of complex is disallowed */
14192  mask &= ~NUM_SUFFIX_R;
14193  continue;
14194  }
14195  if ((mask & NUM_SUFFIX_R) && c == 'r') {
14196  result |= (mask & NUM_SUFFIX_R);
14197  mask &= ~NUM_SUFFIX_R;
14198  continue;
14199  }
14200  if (!ISASCII(c) || ISALPHA(c) || c == '_') {
14201  p->lex.pcur = lastp;
14202  literal_flush(p, p->lex.pcur);
14203  return 0;
14204  }
14205  pushback(p, c);
14206  break;
14207  }
14208  return result;
14209 }
14210 
14211 static enum yytokentype
14212 set_number_literal(struct parser_params *p, VALUE v,
14213  enum yytokentype type, int suffix)
14214 {
14215  if (suffix & NUM_SUFFIX_I) {
14216  v = rb_complex_raw(INT2FIX(0), v);
14217  type = tIMAGINARY;
14218  }
14220  SET_LEX_STATE(EXPR_END);
14221  return type;
14222 }
14223 
14224 static enum yytokentype
14225 set_integer_literal(struct parser_params *p, VALUE v, int suffix)
14226 {
14227  enum yytokentype type = tINTEGER;
14228  if (suffix & NUM_SUFFIX_R) {
14229  v = rb_rational_raw1(v);
14230  type = tRATIONAL;
14231  }
14232  return set_number_literal(p, v, type, suffix);
14233 }
14234 
14235 #ifdef RIPPER
14236 static void
14238 {
14239  VALUE str;
14240  if (has_delayed_token(p))
14242  str = STR_NEW(p->lex.ptok, p->lex.pend - p->lex.ptok);
14243  ripper_dispatch1(p, ripper_token2eventid(tHEREDOC_END), str);
14244  lex_goto_eol(p);
14245  token_flush(p);
14246 }
14247 
14248 #else
14249 #define dispatch_heredoc_end(p) ((void)0)
14250 #endif
14251 
14252 static enum yytokentype
14253 here_document(struct parser_params *p, rb_strterm_heredoc_t *here)
14254 {
14255  int c, func, indent = 0;
14256  const char *eos, *ptr, *ptr_end;
14257  long len;
14258  VALUE str = 0;
14259  rb_encoding *enc = p->enc;
14260  rb_encoding *base_enc = 0;
14261  int bol;
14262 
14263  eos = RSTRING_PTR(here->lastline) + here->offset;
14264  len = here->length;
14265  indent = (func = here->func) & STR_FUNC_INDENT;
14266 
14267  if ((c = nextc(p)) == -1) {
14268  error:
14269 #ifdef RIPPER
14270  if (!has_delayed_token(p)) {
14272  }
14273  else {
14274  if ((len = p->lex.pcur - p->lex.ptok) > 0) {
14275  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
14276  int cr = ENC_CODERANGE_UNKNOWN;
14278  if (cr != ENC_CODERANGE_7BIT &&
14279  p->enc == rb_usascii_encoding() &&
14280  enc != rb_utf8_encoding()) {
14282  }
14283  }
14284  rb_enc_str_buf_cat(p->delayed.token, p->lex.ptok, len, enc);
14285  }
14287  }
14288  lex_goto_eol(p);
14289 #endif
14290  heredoc_restore(p, &p->lex.strterm->u.heredoc);
14291  compile_error(p, "can't find string \"%.*s\" anywhere before EOF",
14292  (int)len, eos);
14293  token_flush(p);
14294  p->lex.strterm = 0;
14295  SET_LEX_STATE(EXPR_END);
14296  return tSTRING_END;
14297  }
14298  bol = was_bol(p);
14299  if (!bol) {
14300  /* not beginning of line, cannot be the terminator */
14301  }
14302  else if (p->heredoc_line_indent == -1) {
14303  /* `heredoc_line_indent == -1` means
14304  * - "after an interpolation in the same line", or
14305  * - "in a continuing line"
14306  */
14307  p->heredoc_line_indent = 0;
14308  }
14309  else if (whole_match_p(p, eos, len, indent)) {
14311  restore:
14312  heredoc_restore(p, &p->lex.strterm->u.heredoc);
14313  token_flush(p);
14314  p->lex.strterm = 0;
14315  SET_LEX_STATE(EXPR_END);
14316  return tSTRING_END;
14317  }
14318 
14319  if (!(func & STR_FUNC_EXPAND)) {
14320  do {
14321  ptr = RSTRING_PTR(p->lex.lastline);
14322  ptr_end = p->lex.pend;
14323  if (ptr_end > ptr) {
14324  switch (ptr_end[-1]) {
14325  case '\n':
14326  if (--ptr_end == ptr || ptr_end[-1] != '\r') {
14327  ptr_end++;
14328  break;
14329  }
14330  case '\r':
14331  --ptr_end;
14332  }
14333  }
14334 
14335  if (p->heredoc_indent > 0) {
14336  long i = 0;
14337  while (ptr + i < ptr_end && parser_update_heredoc_indent(p, ptr[i]))
14338  i++;
14339  p->heredoc_line_indent = 0;
14340  }
14341 
14342  if (str)
14343  rb_str_cat(str, ptr, ptr_end - ptr);
14344  else
14345  str = STR_NEW(ptr, ptr_end - ptr);
14346  if (ptr_end < p->lex.pend) rb_str_cat(str, "\n", 1);
14347  lex_goto_eol(p);
14348  if (p->heredoc_indent > 0) {
14349  goto flush_str;
14350  }
14351  if (nextc(p) == -1) {
14352  if (str) {
14353  str = 0;
14354  }
14355  goto error;
14356  }
14357  } while (!whole_match_p(p, eos, len, indent));
14358  }
14359  else {
14360  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
14361  newtok(p);
14362  if (c == '#') {
14363  int t = parser_peek_variable_name(p);
14364  if (p->heredoc_line_indent != -1) {
14365  if (p->heredoc_indent > p->heredoc_line_indent) {
14367  }
14368  p->heredoc_line_indent = -1;
14369  }
14370  if (t) return t;
14371  tokadd(p, '#');
14372  c = nextc(p);
14373  }
14374  do {
14375  pushback(p, c);
14376  enc = p->enc;
14377  if ((c = tokadd_string(p, func, '\n', 0, NULL, &enc, &base_enc)) == -1) {
14378  if (p->eofp) goto error;
14379  goto restore;
14380  }
14381  if (c != '\n') {
14382  if (c == '\\') p->heredoc_line_indent = -1;
14383  flush:
14384  str = STR_NEW3(tok(p), toklen(p), enc, func);
14385  flush_str:
14387 #ifndef RIPPER
14388  if (bol) yylval.node->flags |= NODE_FL_NEWLINE;
14389 #endif
14391  return tSTRING_CONTENT;
14392  }
14393  tokadd(p, nextc(p));
14394  if (p->heredoc_indent > 0) {
14395  lex_goto_eol(p);
14396  goto flush;
14397  }
14398  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
14399  if ((c = nextc(p)) == -1) goto error;
14400  } while (!whole_match_p(p, eos, len, indent));
14401  str = STR_NEW3(tok(p), toklen(p), enc, func);
14402  }
14404 #ifdef RIPPER
14405  str = ripper_new_yylval(p, ripper_token2eventid(tSTRING_CONTENT),
14406  yylval.val, str);
14407 #endif
14408  heredoc_restore(p, &p->lex.strterm->u.heredoc);
14409  token_flush(p);
14410  p->lex.strterm = NEW_STRTERM(func | STR_FUNC_TERM, 0, 0);
14412 #ifndef RIPPER
14413  if (bol) yylval.node->flags |= NODE_FL_NEWLINE;
14414 #endif
14415  return tSTRING_CONTENT;
14416 }
14417 
14418 #include "lex.c"
14419 
14420 static int
14421 arg_ambiguous(struct parser_params *p, char c)
14422 {
14423 #ifndef RIPPER
14424  rb_warning1("ambiguous first argument; put parentheses or a space even after `%c' operator", WARN_I(c));
14425 #else
14426  dispatch1(arg_ambiguous, rb_usascii_str_new(&c, 1));
14427 #endif
14428  return TRUE;
14429 }
14430 
14431 static ID
14432 formal_argument(struct parser_params *p, ID lhs)
14433 {
14434  switch (id_type(lhs)) {
14435  case ID_LOCAL:
14436  break;
14437 #ifndef RIPPER
14438  case ID_CONST:
14439  yyerror0("formal argument cannot be a constant");
14440  return 0;
14441  case ID_INSTANCE:
14442  yyerror0("formal argument cannot be an instance variable");
14443  return 0;
14444  case ID_GLOBAL:
14445  yyerror0("formal argument cannot be a global variable");
14446  return 0;
14447  case ID_CLASS:
14448  yyerror0("formal argument cannot be a class variable");
14449  return 0;
14450  default:
14451  yyerror0("formal argument must be local variable");
14452  return 0;
14453 #else
14454  default:
14455  lhs = dispatch1(param_error, lhs);
14456  ripper_error(p);
14457  return 0;
14458 #endif
14459  }
14460  shadowing_lvar(p, lhs);
14461  return lhs;
14462 }
14463 
14464 static int
14465 lvar_defined(struct parser_params *p, ID id)
14466 {
14467  return (dyna_in_block(p) && dvar_defined(p, id)) || local_id(p, id);
14468 }
14469 
14470 /* emacsen -*- hack */
14471 static long
14472 parser_encode_length(struct parser_params *p, const char *name, long len)
14473 {
14474  long nlen;
14475 
14476  if (len > 5 && name[nlen = len - 5] == '-') {
14477  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
14478  return nlen;
14479  }
14480  if (len > 4 && name[nlen = len - 4] == '-') {
14481  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
14482  return nlen;
14483  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
14484  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
14485  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
14486  return nlen;
14487  }
14488  return len;
14489 }
14490 
14491 static void
14492 parser_set_encode(struct parser_params *p, const char *name)
14493 {
14494  int idx = rb_enc_find_index(name);
14495  rb_encoding *enc;
14496  VALUE excargs[3];
14497 
14498  if (idx < 0) {
14499  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
14500  error:
14501  excargs[0] = rb_eArgError;
14502  excargs[2] = rb_make_backtrace();
14504  rb_exc_raise(rb_make_exception(3, excargs));
14505  }
14506  enc = rb_enc_from_index(idx);
14507  if (!rb_enc_asciicompat(enc)) {
14508  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
14509  goto error;
14510  }
14511  p->enc = enc;
14512 #ifndef RIPPER
14513  if (p->debug_lines) {
14514  VALUE lines = p->debug_lines;
14515  long i, n = RARRAY_LEN(lines);
14516  for (i = 0; i < n; ++i) {
14517  rb_enc_associate_index(RARRAY_AREF(lines, i), idx);
14518  }
14519  }
14520 #endif
14521 }
14522 
14523 static int
14524 comment_at_top(struct parser_params *p)
14525 {
14526  const char *ptr = p->lex.pbeg, *ptr_end = p->lex.pcur - 1;
14527  if (p->line_count != (p->has_shebang ? 2 : 1)) return 0;
14528  while (ptr < ptr_end) {
14529  if (!ISSPACE(*ptr)) return 0;
14530  ptr++;
14531  }
14532  return 1;
14533 }
14534 
14535 typedef long (*rb_magic_comment_length_t)(struct parser_params *p, const char *name, long len);
14536 typedef void (*rb_magic_comment_setter_t)(struct parser_params *p, const char *name, const char *val);
14537 
14538 static void
14539 magic_comment_encoding(struct parser_params *p, const char *name, const char *val)
14540 {
14541  if (!comment_at_top(p)) {
14542  return;
14543  }
14544  parser_set_encode(p, val);
14545 }
14546 
14547 static int
14548 parser_get_bool(struct parser_params *p, const char *name, const char *val)
14549 {
14550  switch (*val) {
14551  case 't': case 'T':
14552  if (strcasecmp(val, "true") == 0) {
14553  return TRUE;
14554  }
14555  break;
14556  case 'f': case 'F':
14557  if (strcasecmp(val, "false") == 0) {
14558  return FALSE;
14559  }
14560  break;
14561  }
14562  rb_compile_warning(p->ruby_sourcefile, p->ruby_sourceline, "invalid value for %s: %s", name, val);
14563  return -1;
14564 }
14565 
14566 static void
14567 parser_set_token_info(struct parser_params *p, const char *name, const char *val)
14568 {
14569  int b = parser_get_bool(p, name, val);
14570  if (b >= 0) p->token_info_enabled = b;
14571 }
14572 
14573 static void
14574 parser_set_compile_option_flag(struct parser_params *p, const char *name, const char *val)
14575 {
14576  int b;
14577 
14578  if (p->token_seen) {
14579  rb_warning1("`%s' is ignored after any tokens", WARN_S(name));
14580  return;
14581  }
14582 
14583  b = parser_get_bool(p, name, val);
14584  if (b < 0) return;
14585 
14586  if (!p->compile_option)
14589  (b ? Qtrue : Qfalse));
14590 }
14591 
14592 # if WARN_PAST_SCOPE
14593 static void
14594 parser_set_past_scope(struct parser_params *p, const char *name, const char *val)
14595 {
14596  int b = parser_get_bool(p, name, val);
14597  if (b >= 0) p->past_scope_enabled = b;
14598 }
14599 # endif
14600 
14602  const char *name;
14605 };
14606 
14607 static const struct magic_comment magic_comments[] = {
14608  {"coding", magic_comment_encoding, parser_encode_length},
14609  {"encoding", magic_comment_encoding, parser_encode_length},
14610  {"frozen_string_literal", parser_set_compile_option_flag},
14611  {"warn_indent", parser_set_token_info},
14612 # if WARN_PAST_SCOPE
14613  {"warn_past_scope", parser_set_past_scope},
14614 # endif
14615 };
14616 
14617 static const char *
14618 magic_comment_marker(const char *str, long len)
14619 {
14620  long i = 2;
14621 
14622  while (i < len) {
14623  switch (str[i]) {
14624  case '-':
14625  if (str[i-1] == '*' && str[i-2] == '-') {
14626  return str + i + 1;
14627  }
14628  i += 2;
14629  break;
14630  case '*':
14631  if (i + 1 >= len) return 0;
14632  if (str[i+1] != '-') {
14633  i += 4;
14634  }
14635  else if (str[i-1] != '-') {
14636  i += 2;
14637  }
14638  else {
14639  return str + i + 2;
14640  }
14641  break;
14642  default:
14643  i += 3;
14644  break;
14645  }
14646  }
14647  return 0;
14648 }
14649 
14650 static int
14651 parser_magic_comment(struct parser_params *p, const char *str, long len)
14652 {
14653  int indicator = 0;
14654  VALUE name = 0, val = 0;
14655  const char *beg, *end, *vbeg, *vend;
14656 #define str_copy(_s, _p, _n) ((_s) \
14657  ? (void)(rb_str_resize((_s), (_n)), \
14658  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
14659  : (void)((_s) = STR_NEW((_p), (_n))))
14660 
14661  if (len <= 7) return FALSE;
14662  if (!!(beg = magic_comment_marker(str, len))) {
14663  if (!(end = magic_comment_marker(beg, str + len - beg)))
14664  return FALSE;
14665  indicator = TRUE;
14666  str = beg;
14667  len = end - beg - 3;
14668  }
14669 
14670  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
14671  while (len > 0) {
14672  const struct magic_comment *mc = magic_comments;
14673  char *s;
14674  int i;
14675  long n = 0;
14676 
14677  for (; len > 0 && *str; str++, --len) {
14678  switch (*str) {
14679  case '\'': case '"': case ':': case ';':
14680  continue;
14681  }
14682  if (!ISSPACE(*str)) break;
14683  }
14684  for (beg = str; len > 0; str++, --len) {
14685  switch (*str) {
14686  case '\'': case '"': case ':': case ';':
14687  break;
14688  default:
14689  if (ISSPACE(*str)) break;
14690  continue;
14691  }
14692  break;
14693  }
14694  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
14695  if (!len) break;
14696  if (*str != ':') {
14697  if (!indicator) return FALSE;
14698  continue;
14699  }
14700 
14701  do str++; while (--len > 0 && ISSPACE(*str));
14702  if (!len) break;
14703  if (*str == '"') {
14704  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
14705  if (*str == '\\') {
14706  --len;
14707  ++str;
14708  }
14709  }
14710  vend = str;
14711  if (len) {
14712  --len;
14713  ++str;
14714  }
14715  }
14716  else {
14717  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
14718  vend = str;
14719  }
14720  if (indicator) {
14721  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
14722  }
14723  else {
14724  while (len > 0 && (ISSPACE(*str))) --len, str++;
14725  if (len) return FALSE;
14726  }
14727 
14728  n = end - beg;
14729  str_copy(name, beg, n);
14730  s = RSTRING_PTR(name);
14731  for (i = 0; i < n; ++i) {
14732  if (s[i] == '-') s[i] = '_';
14733  }
14734  do {
14735  if (STRNCASECMP(mc->name, s, n) == 0 && !mc->name[n]) {
14736  n = vend - vbeg;
14737  if (mc->length) {
14738  n = (*mc->length)(p, vbeg, n);
14739  }
14740  str_copy(val, vbeg, n);
14741  (*mc->func)(p, mc->name, RSTRING_PTR(val));
14742  break;
14743  }
14744  } while (++mc < magic_comments + numberof(magic_comments));
14745 #ifdef RIPPER
14746  str_copy(val, vbeg, vend - vbeg);
14747  dispatch2(magic_comment, name, val);
14748 #endif
14749  }
14750 
14751  return TRUE;
14752 }
14753 
14754 static void
14755 set_file_encoding(struct parser_params *p, const char *str, const char *send)
14756 {
14757  int sep = 0;
14758  const char *beg = str;
14759  VALUE s;
14760 
14761  for (;;) {
14762  if (send - str <= 6) return;
14763  switch (str[6]) {
14764  case 'C': case 'c': str += 6; continue;
14765  case 'O': case 'o': str += 5; continue;
14766  case 'D': case 'd': str += 4; continue;
14767  case 'I': case 'i': str += 3; continue;
14768  case 'N': case 'n': str += 2; continue;
14769  case 'G': case 'g': str += 1; continue;
14770  case '=': case ':':
14771  sep = 1;
14772  str += 6;
14773  break;
14774  default:
14775  str += 6;
14776  if (ISSPACE(*str)) break;
14777  continue;
14778  }
14779  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
14780  }
14781  for (;;) {
14782  do {
14783  if (++str >= send) return;
14784  } while (ISSPACE(*str));
14785  if (sep) break;
14786  if (*str != '=' && *str != ':') return;
14787  sep = 1;
14788  str++;
14789  }
14790  beg = str;
14791  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
14792  s = rb_str_new(beg, parser_encode_length(p, beg, str - beg));
14793  parser_set_encode(p, RSTRING_PTR(s));
14794  rb_str_resize(s, 0);
14795 }
14796 
14797 static void
14798 parser_prepare(struct parser_params *p)
14799 {
14800  int c = nextc(p);
14802  switch (c) {
14803  case '#':
14804  if (peek(p, '!')) p->has_shebang = 1;
14805  break;
14806  case 0xef: /* UTF-8 BOM marker */
14807  if (p->lex.pend - p->lex.pcur >= 2 &&
14808  (unsigned char)p->lex.pcur[0] == 0xbb &&
14809  (unsigned char)p->lex.pcur[1] == 0xbf) {
14810  p->enc = rb_utf8_encoding();
14811  p->lex.pcur += 2;
14812  p->lex.pbeg = p->lex.pcur;
14813  return;
14814  }
14815  break;
14816  case EOF:
14817  return;
14818  }
14819  pushback(p, c);
14820  p->enc = rb_enc_get(p->lex.lastline);
14821 }
14822 
14823 #ifndef RIPPER
14824 #define ambiguous_operator(tok, op, syn) ( \
14825  rb_warning0("`"op"' after local variable or literal is interpreted as binary operator"), \
14826  rb_warning0("even though it seems like "syn""))
14827 #else
14828 #define ambiguous_operator(tok, op, syn) \
14829  dispatch2(operator_ambiguous, TOKEN2VAL(tok), rb_str_new_cstr(syn))
14830 #endif
14831 #define warn_balanced(tok, op, syn) ((void) \
14832  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN) && \
14833  space_seen && !ISSPACE(c) && \
14834  (ambiguous_operator(tok, op, syn), 0)), \
14835  (enum yytokentype)(tok))
14836 
14837 static VALUE
14838 parse_rational(struct parser_params *p, char *str, int len, int seen_point)
14839 {
14840  VALUE v;
14841  char *point = &str[seen_point];
14842  size_t fraclen = len-seen_point-1;
14843  memmove(point, point+1, fraclen+1);
14844  v = rb_cstr_to_inum(str, 10, FALSE);
14845  return rb_rational_new(v, rb_int_positive_pow(10, fraclen));
14846 }
14847 
14848 static enum yytokentype
14849 no_digits(struct parser_params *p)
14850 {
14851  yyerror0("numeric literal without digits");
14852  if (peek(p, '_')) nextc(p);
14853  /* dummy 0, for tUMINUS_NUM at numeric */
14854  return set_integer_literal(p, INT2FIX(0), 0);
14855 }
14856 
14857 static enum yytokentype
14858 parse_numeric(struct parser_params *p, int c)
14859 {
14860  int is_float, seen_point, seen_e, nondigit;
14861  int suffix;
14862 
14863  is_float = seen_point = seen_e = nondigit = 0;
14864  SET_LEX_STATE(EXPR_END);
14865  newtok(p);
14866  if (c == '-' || c == '+') {
14867  tokadd(p, c);
14868  c = nextc(p);
14869  }
14870  if (c == '0') {
14871  int start = toklen(p);
14872  c = nextc(p);
14873  if (c == 'x' || c == 'X') {
14874  /* hexadecimal */
14875  c = nextc(p);
14876  if (c != -1 && ISXDIGIT(c)) {
14877  do {
14878  if (c == '_') {
14879  if (nondigit) break;
14880  nondigit = c;
14881  continue;
14882  }
14883  if (!ISXDIGIT(c)) break;
14884  nondigit = 0;
14885  tokadd(p, c);
14886  } while ((c = nextc(p)) != -1);
14887  }
14888  pushback(p, c);
14889  tokfix(p);
14890  if (toklen(p) == start) {
14891  return no_digits(p);
14892  }
14893  else if (nondigit) goto trailing_uc;
14894  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
14895  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 16, FALSE), suffix);
14896  }
14897  if (c == 'b' || c == 'B') {
14898  /* binary */
14899  c = nextc(p);
14900  if (c == '0' || c == '1') {
14901  do {
14902  if (c == '_') {
14903  if (nondigit) break;
14904  nondigit = c;
14905  continue;
14906  }
14907  if (c != '0' && c != '1') break;
14908  nondigit = 0;
14909  tokadd(p, c);
14910  } while ((c = nextc(p)) != -1);
14911  }
14912  pushback(p, c);
14913  tokfix(p);
14914  if (toklen(p) == start) {
14915  return no_digits(p);
14916  }
14917  else if (nondigit) goto trailing_uc;
14918  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
14919  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 2, FALSE), suffix);
14920  }
14921  if (c == 'd' || c == 'D') {
14922  /* decimal */
14923  c = nextc(p);
14924  if (c != -1 && ISDIGIT(c)) {
14925  do {
14926  if (c == '_') {
14927  if (nondigit) break;
14928  nondigit = c;
14929  continue;
14930  }
14931  if (!ISDIGIT(c)) break;
14932  nondigit = 0;
14933  tokadd(p, c);
14934  } while ((c = nextc(p)) != -1);
14935  }
14936  pushback(p, c);
14937  tokfix(p);
14938  if (toklen(p) == start) {
14939  return no_digits(p);
14940  }
14941  else if (nondigit) goto trailing_uc;
14942  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
14943  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 10, FALSE), suffix);
14944  }
14945  if (c == '_') {
14946  /* 0_0 */
14947  goto octal_number;
14948  }
14949  if (c == 'o' || c == 'O') {
14950  /* prefixed octal */
14951  c = nextc(p);
14952  if (c == -1 || c == '_' || !ISDIGIT(c)) {
14953  return no_digits(p);
14954  }
14955  }
14956  if (c >= '0' && c <= '7') {
14957  /* octal */
14958  octal_number:
14959  do {
14960  if (c == '_') {
14961  if (nondigit) break;
14962  nondigit = c;
14963  continue;
14964  }
14965  if (c < '0' || c > '9') break;
14966  if (c > '7') goto invalid_octal;
14967  nondigit = 0;
14968  tokadd(p, c);
14969  } while ((c = nextc(p)) != -1);
14970  if (toklen(p) > start) {
14971  pushback(p, c);
14972  tokfix(p);
14973  if (nondigit) goto trailing_uc;
14974  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
14975  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 8, FALSE), suffix);
14976  }
14977  if (nondigit) {
14978  pushback(p, c);
14979  goto trailing_uc;
14980  }
14981  }
14982  if (c > '7' && c <= '9') {
14983  invalid_octal:
14984  yyerror0("Invalid octal digit");
14985  }
14986  else if (c == '.' || c == 'e' || c == 'E') {
14987  tokadd(p, '0');
14988  }
14989  else {
14990  pushback(p, c);
14991  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
14992  return set_integer_literal(p, INT2FIX(0), suffix);
14993  }
14994  }
14995 
14996  for (;;) {
14997  switch (c) {
14998  case '0': case '1': case '2': case '3': case '4':
14999  case '5': case '6': case '7': case '8': case '9':
15000  nondigit = 0;
15001  tokadd(p, c);
15002  break;
15003 
15004  case '.':
15005  if (nondigit) goto trailing_uc;
15006  if (seen_point || seen_e) {
15007  goto decode_num;
15008  }
15009  else {
15010  int c0 = nextc(p);
15011  if (c0 == -1 || !ISDIGIT(c0)) {
15012  pushback(p, c0);
15013  goto decode_num;
15014  }
15015  c = c0;
15016  }
15017  seen_point = toklen(p);
15018  tokadd(p, '.');
15019  tokadd(p, c);
15020  is_float++;
15021  nondigit = 0;
15022  break;
15023 
15024  case 'e':
15025  case 'E':
15026  if (nondigit) {
15027  pushback(p, c);
15028  c = nondigit;
15029  goto decode_num;
15030  }
15031  if (seen_e) {
15032  goto decode_num;
15033  }
15034  nondigit = c;
15035  c = nextc(p);
15036  if (c != '-' && c != '+' && !ISDIGIT(c)) {
15037  pushback(p, c);
15038  nondigit = 0;
15039  goto decode_num;
15040  }
15041  tokadd(p, nondigit);
15042  seen_e++;
15043  is_float++;
15044  tokadd(p, c);
15045  nondigit = (c == '-' || c == '+') ? c : 0;
15046  break;
15047 
15048  case '_': /* `_' in number just ignored */
15049  if (nondigit) goto decode_num;
15050  nondigit = c;
15051  break;
15052 
15053  default:
15054  goto decode_num;
15055  }
15056  c = nextc(p);
15057  }
15058 
15059  decode_num:
15060  pushback(p, c);
15061  if (nondigit) {
15062  trailing_uc:
15063  literal_flush(p, p->lex.pcur - 1);
15064  YYLTYPE loc = RUBY_INIT_YYLLOC();
15065  compile_error(p, "trailing `%c' in number", nondigit);
15066  parser_show_error_line(p, &loc);
15067  }
15068  tokfix(p);
15069  if (is_float) {
15070  enum yytokentype type = tFLOAT;
15071  VALUE v;
15072 
15073  suffix = number_literal_suffix(p, seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
15074  if (suffix & NUM_SUFFIX_R) {
15075  type = tRATIONAL;
15076  v = parse_rational(p, tok(p), toklen(p), seen_point);
15077  }
15078  else {
15079  double d = strtod(tok(p), 0);
15080  if (errno == ERANGE) {
15081  rb_warning1("Float %s out of range", WARN_S(tok(p)));
15082  errno = 0;
15083  }
15084  v = DBL2NUM(d);
15085  }
15086  return set_number_literal(p, v, type, suffix);
15087  }
15088  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
15089  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 10, FALSE), suffix);
15090 }
15091 
15092 static enum yytokentype
15093 parse_qmark(struct parser_params *p, int space_seen)
15094 {
15095  rb_encoding *enc;
15096  register int c;
15097  VALUE lit;
15098 
15099  if (IS_END()) {
15101  return '?';
15102  }
15103  c = nextc(p);
15104  if (c == -1) {
15105  compile_error(p, "incomplete character syntax");
15106  return 0;
15107  }
15108  if (rb_enc_isspace(c, p->enc)) {
15109  if (!IS_ARG()) {
15110  int c2 = escaped_control_code(c);
15111  if (c2) {
15112  WARN_SPACE_CHAR(c2, "?");
15113  }
15114  }
15115  ternary:
15116  pushback(p, c);
15118  return '?';
15119  }
15120  newtok(p);
15121  enc = p->enc;
15122  if (!parser_isascii(p)) {
15123  if (tokadd_mbchar(p, c) == -1) return 0;
15124  }
15125  else if ((rb_enc_isalnum(c, p->enc) || c == '_') &&
15126  p->lex.pcur < p->lex.pend && is_identchar(p->lex.pcur, p->lex.pend, p->enc)) {
15127  if (space_seen) {
15128  const char *start = p->lex.pcur - 1, *ptr = start;
15129  do {
15130  int n = parser_precise_mbclen(p, ptr);
15131  if (n < 0) return -1;
15132  ptr += n;
15133  } while (ptr < p->lex.pend && is_identchar(ptr, p->lex.pend, p->enc));
15134  rb_warn2("`?' just followed by `%.*s' is interpreted as" \
15135  " a conditional operator, put a space after `?'",
15136  WARN_I((int)(ptr - start)), WARN_S_L(start, (ptr - start)));
15137  }
15138  goto ternary;
15139  }
15140  else if (c == '\\') {
15141  if (peek(p, 'u')) {
15142  nextc(p);
15143  enc = rb_utf8_encoding();
15144  tokadd_utf8(p, &enc, -1, 0, 0);
15145  }
15146  else if (!lex_eol_p(p) && !(c = *p->lex.pcur, ISASCII(c))) {
15147  nextc(p);
15148  if (tokadd_mbchar(p, c) == -1) return 0;
15149  }
15150  else {
15151  c = read_escape(p, 0, &enc);
15152  tokadd(p, c);
15153  }
15154  }
15155  else {
15156  tokadd(p, c);
15157  }
15158  tokfix(p);
15159  lit = STR_NEW3(tok(p), toklen(p), enc, 0);
15160  set_yylval_str(lit);
15161  SET_LEX_STATE(EXPR_END);
15162  return tCHAR;
15163 }
15164 
15165 static enum yytokentype
15166 parse_percent(struct parser_params *p, const int space_seen, const enum lex_state_e last_state)
15167 {
15168  register int c;
15169  const char *ptok = p->lex.pcur;
15170 
15171  if (IS_BEG()) {
15172  int term;
15173  int paren;
15174 
15175  c = nextc(p);
15176  quotation:
15177  if (c == -1 || !ISALNUM(c)) {
15178  term = c;
15179  c = 'Q';
15180  }
15181  else {
15182  term = nextc(p);
15183  if (rb_enc_isalnum(term, p->enc) || !parser_isascii(p)) {
15184  yyerror0("unknown type of %string");
15185  return 0;
15186  }
15187  }
15188  if (c == -1 || term == -1) {
15189  compile_error(p, "unterminated quoted string meets end of file");
15190  return 0;
15191  }
15192  paren = term;
15193  if (term == '(') term = ')';
15194  else if (term == '[') term = ']';
15195  else if (term == '{') term = '}';
15196  else if (term == '<') term = '>';
15197  else paren = 0;
15198 
15199  p->lex.ptok = ptok-1;
15200  switch (c) {
15201  case 'Q':
15202  p->lex.strterm = NEW_STRTERM(str_dquote, term, paren);
15203  return tSTRING_BEG;
15204 
15205  case 'q':
15206  p->lex.strterm = NEW_STRTERM(str_squote, term, paren);
15207  return tSTRING_BEG;
15208 
15209  case 'W':
15210  p->lex.strterm = NEW_STRTERM(str_dword, term, paren);
15211  return tWORDS_BEG;
15212 
15213  case 'w':
15214  p->lex.strterm = NEW_STRTERM(str_sword, term, paren);
15215  return tQWORDS_BEG;
15216 
15217  case 'I':
15218  p->lex.strterm = NEW_STRTERM(str_dword, term, paren);
15219  return tSYMBOLS_BEG;
15220 
15221  case 'i':
15222  p->lex.strterm = NEW_STRTERM(str_sword, term, paren);
15223  return tQSYMBOLS_BEG;
15224 
15225  case 'x':
15226  p->lex.strterm = NEW_STRTERM(str_xquote, term, paren);
15227  return tXSTRING_BEG;
15228 
15229  case 'r':
15230  p->lex.strterm = NEW_STRTERM(str_regexp, term, paren);
15231  return tREGEXP_BEG;
15232 
15233  case 's':
15234  p->lex.strterm = NEW_STRTERM(str_ssym, term, paren);
15235  SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);
15236  return tSYMBEG;
15237 
15238  default:
15239  yyerror0("unknown type of %string");
15240  return 0;
15241  }
15242  }
15243  if ((c = nextc(p)) == '=') {
15244  set_yylval_id('%');
15245  SET_LEX_STATE(EXPR_BEG);
15246  return tOP_ASGN;
15247  }
15248  if (IS_SPCARG(c) || (IS_lex_state(EXPR_FITEM) && c == 's')) {
15249  goto quotation;
15250  }
15251  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15252  pushback(p, c);
15253  return warn_balanced('%', "%%", "string literal");
15254 }
15255 
15256 static int
15257 tokadd_ident(struct parser_params *p, int c)
15258 {
15259  do {
15260  if (tokadd_mbchar(p, c) == -1) return -1;
15261  c = nextc(p);
15262  } while (parser_is_identchar(p));
15263  pushback(p, c);
15264  return 0;
15265 }
15266 
15267 static ID
15268 tokenize_ident(struct parser_params *p, const enum lex_state_e last_state)
15269 {
15270  ID ident = TOK_INTERN();
15271 
15272  set_yylval_name(ident);
15273 
15274  return ident;
15275 }
15276 
15277 static int
15278 parse_numvar(struct parser_params *p)
15279 {
15280  size_t len;
15281  int overflow;
15282  unsigned long n = ruby_scan_digits(tok(p)+1, toklen(p)-1, 10, &len, &overflow);
15283  const unsigned long nth_ref_max =
15284  ((FIXNUM_MAX < INT_MAX) ? FIXNUM_MAX : INT_MAX) >> 1;
15285  /* NTH_REF is left-shifted to be ORed with back-ref flag and
15286  * turned into a Fixnum, in compile.c */
15287 
15288  if (overflow || n > nth_ref_max) {
15289  /* compile_error()? */
15290  rb_warn1("`%s' is too big for a number variable, always nil", WARN_S(tok(p)));
15291  return 0; /* $0 is $PROGRAM_NAME, not NTH_REF */
15292  }
15293  else {
15294  return (int)n;
15295  }
15296 }
15297 
15298 static enum yytokentype
15299 parse_gvar(struct parser_params *p, const enum lex_state_e last_state)
15300 {
15301  const char *ptr = p->lex.pcur;
15302  register int c;
15303 
15304  SET_LEX_STATE(EXPR_END);
15305  p->lex.ptok = ptr - 1; /* from '$' */
15306  newtok(p);
15307  c = nextc(p);
15308  switch (c) {
15309  case '_': /* $_: last read line string */
15310  c = nextc(p);
15311  if (parser_is_identchar(p)) {
15312  tokadd(p, '$');
15313  tokadd(p, '_');
15314  break;
15315  }
15316  pushback(p, c);
15317  c = '_';
15318  /* fall through */
15319  case '~': /* $~: match-data */
15320  case '*': /* $*: argv */
15321  case '$': /* $$: pid */
15322  case '?': /* $?: last status */
15323  case '!': /* $!: error string */
15324  case '@': /* $@: error position */
15325  case '/': /* $/: input record separator */
15326  case '\\': /* $\: output record separator */
15327  case ';': /* $;: field separator */
15328  case ',': /* $,: output field separator */
15329  case '.': /* $.: last read line number */
15330  case '=': /* $=: ignorecase */
15331  case ':': /* $:: load path */
15332  case '<': /* $<: reading filename */
15333  case '>': /* $>: default output handle */
15334  case '\"': /* $": already loaded files */
15335  tokadd(p, '$');
15336  tokadd(p, c);
15337  goto gvar;
15338 
15339  case '-':
15340  tokadd(p, '$');
15341  tokadd(p, c);
15342  c = nextc(p);
15343  if (parser_is_identchar(p)) {
15344  if (tokadd_mbchar(p, c) == -1) return 0;
15345  }
15346  else {
15347  pushback(p, c);
15348  pushback(p, '-');
15349  return '$';
15350  }
15351  gvar:
15353  return tGVAR;
15354 
15355  case '&': /* $&: last match */
15356  case '`': /* $`: string before last match */
15357  case '\'': /* $': string after last match */
15358  case '+': /* $+: string matches last paren. */
15359  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
15360  tokadd(p, '$');
15361  tokadd(p, c);
15362  goto gvar;
15363  }
15364  set_yylval_node(NEW_BACK_REF(c, &_cur_loc));
15365  return tBACK_REF;
15366 
15367  case '1': case '2': case '3':
15368  case '4': case '5': case '6':
15369  case '7': case '8': case '9':
15370  tokadd(p, '$');
15371  do {
15372  tokadd(p, c);
15373  c = nextc(p);
15374  } while (c != -1 && ISDIGIT(c));
15375  pushback(p, c);
15376  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
15377  tokfix(p);
15378  set_yylval_node(NEW_NTH_REF(parse_numvar(p), &_cur_loc));
15379  return tNTH_REF;
15380 
15381  default:
15382  if (!parser_is_identchar(p)) {
15383  YYLTYPE loc = RUBY_INIT_YYLLOC();
15384  if (c == -1 || ISSPACE(c)) {
15385  compile_error(p, "`$' without identifiers is not allowed as a global variable name");
15386  }
15387  else {
15388  pushback(p, c);
15389  compile_error(p, "`$%c' is not allowed as a global variable name", c);
15390  }
15391  parser_show_error_line(p, &loc);
15393  return tGVAR;
15394  }
15395  /* fall through */
15396  case '0':
15397  tokadd(p, '$');
15398  }
15399 
15400  if (tokadd_ident(p, c)) return 0;
15401  SET_LEX_STATE(EXPR_END);
15402  tokenize_ident(p, last_state);
15403  return tGVAR;
15404 }
15405 
15406 #ifndef RIPPER
15407 static bool
15408 parser_numbered_param(struct parser_params *p, int n)
15409 {
15410  if (n < 0) return false;
15411 
15413  return false;
15414  }
15415  if (p->max_numparam == ORDINAL_PARAM) {
15416  compile_error(p, "ordinary parameter is defined");
15417  return false;
15418  }
15419  struct vtable *args = p->lvtbl->args;
15420  if (p->max_numparam < n) {
15421  p->max_numparam = n;
15422  }
15423  while (n > args->pos) {
15424  vtable_add(args, NUMPARAM_IDX_TO_ID(args->pos+1));
15425  }
15426  return true;
15427 }
15428 #endif
15429 
15430 static enum yytokentype
15431 parse_atmark(struct parser_params *p, const enum lex_state_e last_state)
15432 {
15433  const char *ptr = p->lex.pcur;
15434  enum yytokentype result = tIVAR;
15435  register int c = nextc(p);
15436  YYLTYPE loc;
15437 
15438  p->lex.ptok = ptr - 1; /* from '@' */
15439  newtok(p);
15440  tokadd(p, '@');
15441  if (c == '@') {
15442  result = tCVAR;
15443  tokadd(p, '@');
15444  c = nextc(p);
15445  }
15446  SET_LEX_STATE(IS_lex_state_for(last_state, EXPR_FNAME) ? EXPR_ENDFN : EXPR_END);
15447  if (c == -1 || !parser_is_identchar(p)) {
15448  pushback(p, c);
15449  RUBY_SET_YYLLOC(loc);
15450  if (result == tIVAR) {
15451  compile_error(p, "`@' without identifiers is not allowed as an instance variable name");
15452  }
15453  else {
15454  compile_error(p, "`@@' without identifiers is not allowed as a class variable name");
15455  }
15456  parser_show_error_line(p, &loc);
15458  SET_LEX_STATE(EXPR_END);
15459  return result;
15460  }
15461  else if (ISDIGIT(c)) {
15462  pushback(p, c);
15463  RUBY_SET_YYLLOC(loc);
15464  if (result == tIVAR) {
15465  compile_error(p, "`@%c' is not allowed as an instance variable name", c);
15466  }
15467  else {
15468  compile_error(p, "`@@%c' is not allowed as a class variable name", c);
15469  }
15470  parser_show_error_line(p, &loc);
15472  SET_LEX_STATE(EXPR_END);
15473  return result;
15474  }
15475 
15476  if (tokadd_ident(p, c)) return 0;
15477  tokenize_ident(p, last_state);
15478  return result;
15479 }
15480 
15481 static enum yytokentype
15482 parse_ident(struct parser_params *p, int c, int cmd_state)
15483 {
15484  enum yytokentype result;
15485  int mb = ENC_CODERANGE_7BIT;
15486  const enum lex_state_e last_state = p->lex.state;
15487  ID ident;
15488 
15489  do {
15490  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
15491  if (tokadd_mbchar(p, c) == -1) return 0;
15492  c = nextc(p);
15493  } while (parser_is_identchar(p));
15494  if ((c == '!' || c == '?') && !peek(p, '=')) {
15495  result = tFID;
15496  tokadd(p, c);
15497  }
15498  else if (c == '=' && IS_lex_state(EXPR_FNAME) &&
15499  (!peek(p, '~') && !peek(p, '>') && (!peek(p, '=') || (peek_n(p, '>', 1))))) {
15500  result = tIDENTIFIER;
15501  tokadd(p, c);
15502  }
15503  else {
15504  result = tCONSTANT; /* assume provisionally */
15505  pushback(p, c);
15506  }
15507  tokfix(p);
15508 
15509  if (IS_LABEL_POSSIBLE()) {
15510  if (IS_LABEL_SUFFIX(0)) {
15511  SET_LEX_STATE(EXPR_ARG|EXPR_LABELED);
15512  nextc(p);
15514  return tLABEL;
15515  }
15516  }
15517  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
15518  const struct kwtable *kw;
15519 
15520  /* See if it is a reserved word. */
15521  kw = rb_reserved_word(tok(p), toklen(p));
15522  if (kw) {
15523  enum lex_state_e state = p->lex.state;
15524  if (IS_lex_state_for(state, EXPR_FNAME)) {
15525  SET_LEX_STATE(EXPR_ENDFN);
15527  return kw->id[0];
15528  }
15529  SET_LEX_STATE(kw->state);
15530  if (IS_lex_state(EXPR_BEG)) {
15531  p->command_start = TRUE;
15532  }
15533  if (kw->id[0] == keyword_do) {
15534  if (lambda_beginning_p()) {
15535  p->lex.lpar_beg = -1; /* make lambda_beginning_p() == FALSE in the body of "-> do ... end" */
15536  return keyword_do_LAMBDA;
15537  }
15538  if (COND_P()) return keyword_do_cond;
15539  if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG))
15540  return keyword_do_block;
15541  return keyword_do;
15542  }
15543  if (IS_lex_state_for(state, (EXPR_BEG | EXPR_LABELED)))
15544  return kw->id[0];
15545  else {
15546  if (kw->id[0] != kw->id[1])
15547  SET_LEX_STATE(EXPR_BEG | EXPR_LABEL);
15548  return kw->id[1];
15549  }
15550  }
15551  }
15552 
15553  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
15554  if (cmd_state) {
15555  SET_LEX_STATE(EXPR_CMDARG);
15556  }
15557  else {
15558  SET_LEX_STATE(EXPR_ARG);
15559  }
15560  }
15561  else if (p->lex.state == EXPR_FNAME) {
15562  SET_LEX_STATE(EXPR_ENDFN);
15563  }
15564  else {
15565  SET_LEX_STATE(EXPR_END);
15566  }
15567 
15568  ident = tokenize_ident(p, last_state);
15569  if (result == tCONSTANT && is_local_id(ident)) result = tIDENTIFIER;
15570  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
15571  (result == tIDENTIFIER) && /* not EXPR_FNAME, not attrasgn */
15572  lvar_defined(p, ident)) {
15573  SET_LEX_STATE(EXPR_END|EXPR_LABEL);
15574  }
15575  return result;
15576 }
15577 
15578 static enum yytokentype
15579 parser_yylex(struct parser_params *p)
15580 {
15581  register int c;
15582  int space_seen = 0;
15583  int cmd_state;
15584  int label;
15585  enum lex_state_e last_state;
15586  int fallthru = FALSE;
15587  int token_seen = p->token_seen;
15588 
15589  if (p->lex.strterm) {
15590  if (p->lex.strterm->flags & STRTERM_HEREDOC) {
15591  return here_document(p, &p->lex.strterm->u.heredoc);
15592  }
15593  else {
15594  token_flush(p);
15595  return parse_string(p, &p->lex.strterm->u.literal);
15596  }
15597  }
15598  cmd_state = p->command_start;
15599  p->command_start = FALSE;
15600  p->token_seen = TRUE;
15601  retry:
15602  last_state = p->lex.state;
15603 #ifndef RIPPER
15604  token_flush(p);
15605 #endif
15606  switch (c = nextc(p)) {
15607  case '\0': /* NUL */
15608  case '\004': /* ^D */
15609  case '\032': /* ^Z */
15610  case -1: /* end of script. */
15611  return 0;
15612 
15613  /* white spaces */
15614  case ' ': case '\t': case '\f': case '\r':
15615  case '\13': /* '\v' */
15616  space_seen = 1;
15617 #ifdef RIPPER
15618  while ((c = nextc(p))) {
15619  switch (c) {
15620  case ' ': case '\t': case '\f': case '\r':
15621  case '\13': /* '\v' */
15622  break;
15623  default:
15624  goto outofloop;
15625  }
15626  }
15627  outofloop:
15628  pushback(p, c);
15630 #endif
15631  goto retry;
15632 
15633  case '#': /* it's a comment */
15634  p->token_seen = token_seen;
15635  /* no magic_comment in shebang line */
15636  if (!parser_magic_comment(p, p->lex.pcur, p->lex.pend - p->lex.pcur)) {
15637  if (comment_at_top(p)) {
15638  set_file_encoding(p, p->lex.pcur, p->lex.pend);
15639  }
15640  }
15641  lex_goto_eol(p);
15643  fallthru = TRUE;
15644  /* fall through */
15645  case '\n':
15646  p->token_seen = token_seen;
15647  c = (IS_lex_state(EXPR_BEG|EXPR_CLASS|EXPR_FNAME|EXPR_DOT) &&
15648  !IS_lex_state(EXPR_LABELED));
15649  if (c || IS_lex_state_all(EXPR_ARG|EXPR_LABELED)) {
15650  if (!fallthru) {
15652  }
15653  fallthru = FALSE;
15654  if (!c && p->in_kwarg) {
15655  goto normal_newline;
15656  }
15657  goto retry;
15658  }
15659  while (1) {
15660  switch (c = nextc(p)) {
15661  case ' ': case '\t': case '\f': case '\r':
15662  case '\13': /* '\v' */
15663  space_seen = 1;
15664  break;
15665  case '#':
15666  pushback(p, c);
15667  if (space_seen) dispatch_scan_event(p, tSP);
15668  goto retry;
15669  case '&':
15670  case '.': {
15672  if (peek(p, '.') == (c == '&')) {
15673  pushback(p, c);
15675  goto retry;
15676  }
15677  }
15678  default:
15679  p->ruby_sourceline--;
15680  p->lex.nextline = p->lex.lastline;
15681  case -1: /* EOF no decrement*/
15682 #ifndef RIPPER
15683  if (p->lex.prevline && !p->eofp) p->lex.lastline = p->lex.prevline;
15684  p->lex.pbeg = RSTRING_PTR(p->lex.lastline);
15685  p->lex.pend = p->lex.pcur = p->lex.pbeg + RSTRING_LEN(p->lex.lastline);
15686  pushback(p, 1); /* always pushback */
15687  p->lex.ptok = p->lex.pcur;
15688 #else
15689  lex_goto_eol(p);
15690  if (c != -1) {
15691  p->lex.ptok = p->lex.pcur;
15692  }
15693 #endif
15694  goto normal_newline;
15695  }
15696  }
15697  normal_newline:
15698  p->command_start = TRUE;
15699  SET_LEX_STATE(EXPR_BEG);
15700  return '\n';
15701 
15702  case '*':
15703  if ((c = nextc(p)) == '*') {
15704  if ((c = nextc(p)) == '=') {
15706  SET_LEX_STATE(EXPR_BEG);
15707  return tOP_ASGN;
15708  }
15709  pushback(p, c);
15710  if (IS_SPCARG(c)) {
15711  rb_warning0("`**' interpreted as argument prefix");
15712  c = tDSTAR;
15713  }
15714  else if (IS_BEG()) {
15715  c = tDSTAR;
15716  }
15717  else {
15718  c = warn_balanced((enum ruby_method_ids)tPOW, "**", "argument prefix");
15719  }
15720  }
15721  else {
15722  if (c == '=') {
15723  set_yylval_id('*');
15724  SET_LEX_STATE(EXPR_BEG);
15725  return tOP_ASGN;
15726  }
15727  pushback(p, c);
15728  if (IS_SPCARG(c)) {
15729  rb_warning0("`*' interpreted as argument prefix");
15730  c = tSTAR;
15731  }
15732  else if (IS_BEG()) {
15733  c = tSTAR;
15734  }
15735  else {
15736  c = warn_balanced('*', "*", "argument prefix");
15737  }
15738  }
15739  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15740  return c;
15741 
15742  case '!':
15743  c = nextc(p);
15744  if (IS_AFTER_OPERATOR()) {
15745  SET_LEX_STATE(EXPR_ARG);
15746  if (c == '@') {
15747  return '!';
15748  }
15749  }
15750  else {
15751  SET_LEX_STATE(EXPR_BEG);
15752  }
15753  if (c == '=') {
15754  return tNEQ;
15755  }
15756  if (c == '~') {
15757  return tNMATCH;
15758  }
15759  pushback(p, c);
15760  return '!';
15761 
15762  case '=':
15763  if (was_bol(p)) {
15764  /* skip embedded rd document */
15765  if (word_match_p(p, "begin", 5)) {
15766  int first_p = TRUE;
15767 
15768  lex_goto_eol(p);
15770  for (;;) {
15771  lex_goto_eol(p);
15772  if (!first_p) {
15774  }
15775  first_p = FALSE;
15776  c = nextc(p);
15777  if (c == -1) {
15778  compile_error(p, "embedded document meets end of file");
15779  return 0;
15780  }
15781  if (c == '=' && word_match_p(p, "end", 3)) {
15782  break;
15783  }
15784  pushback(p, c);
15785  }
15786  lex_goto_eol(p);
15788  goto retry;
15789  }
15790  }
15791 
15792  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15793  if ((c = nextc(p)) == '=') {
15794  if ((c = nextc(p)) == '=') {
15795  return tEQQ;
15796  }
15797  pushback(p, c);
15798  return tEQ;
15799  }
15800  if (c == '~') {
15801  return tMATCH;
15802  }
15803  else if (c == '>') {
15804  return tASSOC;
15805  }
15806  pushback(p, c);
15807  return '=';
15808 
15809  case '<':
15810  c = nextc(p);
15811  if (c == '<' &&
15812  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
15813  !IS_END() &&
15814  (!IS_ARG() || IS_lex_state(EXPR_LABELED) || space_seen)) {
15815  int token = heredoc_identifier(p);
15816  if (token) return token < 0 ? 0 : token;
15817  }
15818  if (IS_AFTER_OPERATOR()) {
15819  SET_LEX_STATE(EXPR_ARG);
15820  }
15821  else {
15822  if (IS_lex_state(EXPR_CLASS))
15823  p->command_start = TRUE;
15824  SET_LEX_STATE(EXPR_BEG);
15825  }
15826  if (c == '=') {
15827  if ((c = nextc(p)) == '>') {
15828  return tCMP;
15829  }
15830  pushback(p, c);
15831  return tLEQ;
15832  }
15833  if (c == '<') {
15834  if ((c = nextc(p)) == '=') {
15836  SET_LEX_STATE(EXPR_BEG);
15837  return tOP_ASGN;
15838  }
15839  pushback(p, c);
15840  return warn_balanced((enum ruby_method_ids)tLSHFT, "<<", "here document");
15841  }
15842  pushback(p, c);
15843  return '<';
15844 
15845  case '>':
15846  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15847  if ((c = nextc(p)) == '=') {
15848  return tGEQ;
15849  }
15850  if (c == '>') {
15851  if ((c = nextc(p)) == '=') {
15853  SET_LEX_STATE(EXPR_BEG);
15854  return tOP_ASGN;
15855  }
15856  pushback(p, c);
15857  return tRSHFT;
15858  }
15859  pushback(p, c);
15860  return '>';
15861 
15862  case '"':
15863  label = (IS_LABEL_POSSIBLE() ? str_label : 0);
15864  p->lex.strterm = NEW_STRTERM(str_dquote | label, '"', 0);
15865  p->lex.ptok = p->lex.pcur-1;
15866  return tSTRING_BEG;
15867 
15868  case '`':
15869  if (IS_lex_state(EXPR_FNAME)) {
15870  SET_LEX_STATE(EXPR_ENDFN);
15871  return c;
15872  }
15873  if (IS_lex_state(EXPR_DOT)) {
15874  if (cmd_state)
15875  SET_LEX_STATE(EXPR_CMDARG);
15876  else
15877  SET_LEX_STATE(EXPR_ARG);
15878  return c;
15879  }
15880  p->lex.strterm = NEW_STRTERM(str_xquote, '`', 0);
15881  return tXSTRING_BEG;
15882 
15883  case '\'':
15884  label = (IS_LABEL_POSSIBLE() ? str_label : 0);
15885  p->lex.strterm = NEW_STRTERM(str_squote | label, '\'', 0);
15886  p->lex.ptok = p->lex.pcur-1;
15887  return tSTRING_BEG;
15888 
15889  case '?':
15890  return parse_qmark(p, space_seen);
15891 
15892  case '&':
15893  if ((c = nextc(p)) == '&') {
15894  SET_LEX_STATE(EXPR_BEG);
15895  if ((c = nextc(p)) == '=') {
15897  SET_LEX_STATE(EXPR_BEG);
15898  return tOP_ASGN;
15899  }
15900  pushback(p, c);
15901  return tANDOP;
15902  }
15903  else if (c == '=') {
15904  set_yylval_id('&');
15905  SET_LEX_STATE(EXPR_BEG);
15906  return tOP_ASGN;
15907  }
15908  else if (c == '.') {
15910  SET_LEX_STATE(EXPR_DOT);
15911  return tANDDOT;
15912  }
15913  pushback(p, c);
15914  if (IS_SPCARG(c)) {
15915  if ((c != ':') ||
15916  (c = peekc_n(p, 1)) == -1 ||
15917  !(c == '\'' || c == '"' ||
15918  is_identchar((p->lex.pcur+1), p->lex.pend, p->enc))) {
15919  rb_warning0("`&' interpreted as argument prefix");
15920  }
15921  c = tAMPER;
15922  }
15923  else if (IS_BEG()) {
15924  c = tAMPER;
15925  }
15926  else {
15927  c = warn_balanced('&', "&", "argument prefix");
15928  }
15929  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15930  return c;
15931 
15932  case '|':
15933  if ((c = nextc(p)) == '|') {
15934  SET_LEX_STATE(EXPR_BEG);
15935  if ((c = nextc(p)) == '=') {
15937  SET_LEX_STATE(EXPR_BEG);
15938  return tOP_ASGN;
15939  }
15940  pushback(p, c);
15941  if (IS_lex_state_for(last_state, EXPR_BEG)) {
15942  c = '|';
15943  pushback(p, '|');
15944  return c;
15945  }
15946  return tOROP;
15947  }
15948  if (c == '=') {
15949  set_yylval_id('|');
15950  SET_LEX_STATE(EXPR_BEG);
15951  return tOP_ASGN;
15952  }
15953  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG|EXPR_LABEL);
15954  pushback(p, c);
15955  return '|';
15956 
15957  case '+':
15958  c = nextc(p);
15959  if (IS_AFTER_OPERATOR()) {
15960  SET_LEX_STATE(EXPR_ARG);
15961  if (c == '@') {
15962  return tUPLUS;
15963  }
15964  pushback(p, c);
15965  return '+';
15966  }
15967  if (c == '=') {
15968  set_yylval_id('+');
15969  SET_LEX_STATE(EXPR_BEG);
15970  return tOP_ASGN;
15971  }
15972  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p, '+'))) {
15973  SET_LEX_STATE(EXPR_BEG);
15974  pushback(p, c);
15975  if (c != -1 && ISDIGIT(c)) {
15976  return parse_numeric(p, '+');
15977  }
15978  return tUPLUS;
15979  }
15980  SET_LEX_STATE(EXPR_BEG);
15981  pushback(p, c);
15982  return warn_balanced('+', "+", "unary operator");
15983 
15984  case '-':
15985  c = nextc(p);
15986  if (IS_AFTER_OPERATOR()) {
15987  SET_LEX_STATE(EXPR_ARG);
15988  if (c == '@') {
15989  return tUMINUS;
15990  }
15991  pushback(p, c);
15992  return '-';
15993  }
15994  if (c == '=') {
15995  set_yylval_id('-');
15996  SET_LEX_STATE(EXPR_BEG);
15997  return tOP_ASGN;
15998  }
15999  if (c == '>') {
16000  SET_LEX_STATE(EXPR_ENDFN);
16001  return tLAMBDA;
16002  }
16003  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p, '-'))) {
16004  SET_LEX_STATE(EXPR_BEG);
16005  pushback(p, c);
16006  if (c != -1 && ISDIGIT(c)) {
16007  return tUMINUS_NUM;
16008  }
16009  return tUMINUS;
16010  }
16011  SET_LEX_STATE(EXPR_BEG);
16012  pushback(p, c);
16013  return warn_balanced('-', "-", "unary operator");
16014 
16015  case '.': {
16016  int is_beg = IS_BEG();
16017  SET_LEX_STATE(EXPR_BEG);
16018  if ((c = nextc(p)) == '.') {
16019  if ((c = nextc(p)) == '.') {
16020  if (p->lex.paren_nest == 0 && looking_at_eol_p(p)) {
16021  rb_warn0("... at EOL, should be parenthesized?");
16022  }
16023  return is_beg ? tBDOT3 : tDOT3;
16024  }
16025  pushback(p, c);
16026  return is_beg ? tBDOT2 : tDOT2;
16027  }
16028  pushback(p, c);
16029  if (c != -1 && ISDIGIT(c)) {
16030  char prev = p->lex.pcur-1 > p->lex.pbeg ? *(p->lex.pcur-2) : 0;
16031  parse_numeric(p, '.');
16032  if (ISDIGIT(prev)) {
16033  yyerror0("unexpected fraction part after numeric literal");
16034  }
16035  else {
16036  yyerror0("no .<digit> floating literal anymore; put 0 before dot");
16037  }
16038  SET_LEX_STATE(EXPR_END);
16039  p->lex.ptok = p->lex.pcur;
16040  goto retry;
16041  }
16042  set_yylval_id('.');
16043  SET_LEX_STATE(EXPR_DOT);
16044  return '.';
16045  }
16046 
16047  case '0': case '1': case '2': case '3': case '4':
16048  case '5': case '6': case '7': case '8': case '9':
16049  return parse_numeric(p, c);
16050 
16051  case ')':
16052  COND_POP();
16053  CMDARG_POP();
16054  SET_LEX_STATE(EXPR_ENDFN);
16055  p->lex.paren_nest--;
16056  return c;
16057 
16058  case ']':
16059  COND_POP();
16060  CMDARG_POP();
16061  SET_LEX_STATE(EXPR_END);
16062  p->lex.paren_nest--;
16063  return c;
16064 
16065  case '}':
16066  /* tSTRING_DEND does COND_POP and CMDARG_POP in the yacc's rule */
16067  if (!p->lex.brace_nest--) return tSTRING_DEND;
16068  COND_POP();
16069  CMDARG_POP();
16070  SET_LEX_STATE(EXPR_END);
16071  p->lex.paren_nest--;
16072  return c;
16073 
16074  case ':':
16075  c = nextc(p);
16076  if (c == ':') {
16077  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
16078  SET_LEX_STATE(EXPR_BEG);
16079  return tCOLON3;
16080  }
16082  SET_LEX_STATE(EXPR_DOT);
16083  return tCOLON2;
16084  }
16085  if (IS_END() || ISSPACE(c) || c == '#') {
16086  pushback(p, c);
16087  c = warn_balanced(':', ":", "symbol literal");
16088  SET_LEX_STATE(EXPR_BEG);
16089  return c;
16090  }
16091  switch (c) {
16092  case '\'':
16093  p->lex.strterm = NEW_STRTERM(str_ssym, c, 0);
16094  break;
16095  case '"':
16096  p->lex.strterm = NEW_STRTERM(str_dsym, c, 0);
16097  break;
16098  default:
16099  pushback(p, c);
16100  break;
16101  }
16102  SET_LEX_STATE(EXPR_FNAME);
16103  return tSYMBEG;
16104 
16105  case '/':
16106  if (IS_BEG()) {
16107  p->lex.strterm = NEW_STRTERM(str_regexp, '/', 0);
16108  return tREGEXP_BEG;
16109  }
16110  if ((c = nextc(p)) == '=') {
16111  set_yylval_id('/');
16112  SET_LEX_STATE(EXPR_BEG);
16113  return tOP_ASGN;
16114  }
16115  pushback(p, c);
16116  if (IS_SPCARG(c)) {
16117  arg_ambiguous(p, '/');
16118  p->lex.strterm = NEW_STRTERM(str_regexp, '/', 0);
16119  return tREGEXP_BEG;
16120  }
16121  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
16122  return warn_balanced('/', "/", "regexp literal");
16123 
16124  case '^':
16125  if ((c = nextc(p)) == '=') {
16126  set_yylval_id('^');
16127  SET_LEX_STATE(EXPR_BEG);
16128  return tOP_ASGN;
16129  }
16130  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
16131  pushback(p, c);
16132  return '^';
16133 
16134  case ';':
16135  SET_LEX_STATE(EXPR_BEG);
16136  p->command_start = TRUE;
16137  return ';';
16138 
16139  case ',':
16140  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
16141  return ',';
16142 
16143  case '~':
16144  if (IS_AFTER_OPERATOR()) {
16145  if ((c = nextc(p)) != '@') {
16146  pushback(p, c);
16147  }
16148  SET_LEX_STATE(EXPR_ARG);
16149  }
16150  else {
16151  SET_LEX_STATE(EXPR_BEG);
16152  }
16153  return '~';
16154 
16155  case '(':
16156  if (IS_BEG()) {
16157  c = tLPAREN;
16158  }
16159  else if (!space_seen) {
16160  /* foo( ... ) => method call, no ambiguity */
16161  }
16162  else if (IS_ARG() || IS_lex_state_all(EXPR_END|EXPR_LABEL)) {
16163  c = tLPAREN_ARG;
16164  }
16165  else if (IS_lex_state(EXPR_ENDFN) && !lambda_beginning_p()) {
16166  rb_warning0("parentheses after method name is interpreted as "
16167  "an argument list, not a decomposed argument");
16168  }
16169  p->lex.paren_nest++;
16170  COND_PUSH(0);
16171  CMDARG_PUSH(0);
16172  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
16173  return c;
16174 
16175  case '[':
16176  p->lex.paren_nest++;
16177  if (IS_AFTER_OPERATOR()) {
16178  if ((c = nextc(p)) == ']') {
16179  SET_LEX_STATE(EXPR_ARG);
16180  if ((c = nextc(p)) == '=') {
16181  return tASET;
16182  }
16183  pushback(p, c);
16184  return tAREF;
16185  }
16186  pushback(p, c);
16187  SET_LEX_STATE(EXPR_ARG|EXPR_LABEL);
16188  return '[';
16189  }
16190  else if (IS_BEG()) {
16191  c = tLBRACK;
16192  }
16193  else if (IS_ARG() && (space_seen || IS_lex_state(EXPR_LABELED))) {
16194  c = tLBRACK;
16195  }
16196  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
16197  COND_PUSH(0);
16198  CMDARG_PUSH(0);
16199  return c;
16200 
16201  case '{':
16202  ++p->lex.brace_nest;
16203  if (lambda_beginning_p())
16204  c = tLAMBEG;
16205  else if (IS_lex_state(EXPR_LABELED))
16206  c = tLBRACE; /* hash */
16207  else if (IS_lex_state(EXPR_ARG_ANY | EXPR_END | EXPR_ENDFN))
16208  c = '{'; /* block (primary) */
16209  else if (IS_lex_state(EXPR_ENDARG))
16210  c = tLBRACE_ARG; /* block (expr) */
16211  else
16212  c = tLBRACE; /* hash */
16213  if (c != tLBRACE) {
16214  p->command_start = TRUE;
16215  SET_LEX_STATE(EXPR_BEG);
16216  }
16217  else {
16218  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
16219  }
16220  ++p->lex.paren_nest; /* after lambda_beginning_p() */
16221  COND_PUSH(0);
16222  CMDARG_PUSH(0);
16223  return c;
16224 
16225  case '\\':
16226  c = nextc(p);
16227  if (c == '\n') {
16228  space_seen = 1;
16230  goto retry; /* skip \\n */
16231  }
16232  if (c == ' ') return tSP;
16233  if (ISSPACE(c)) return c;
16234  pushback(p, c);
16235  return '\\';
16236 
16237  case '%':
16238  return parse_percent(p, space_seen, last_state);
16239 
16240  case '$':
16241  return parse_gvar(p, last_state);
16242 
16243  case '@':
16244  return parse_atmark(p, last_state);
16245 
16246  case '_':
16247  if (was_bol(p) && whole_match_p(p, "__END__", 7, 0)) {
16248  p->ruby__end__seen = 1;
16249  p->eofp = 1;
16250 #ifndef RIPPER
16251  return -1;
16252 #else
16253  lex_goto_eol(p);
16255  return 0;
16256 #endif
16257  }
16258  newtok(p);
16259  break;
16260 
16261  default:
16262  if (!parser_is_identchar(p)) {
16263  compile_error(p, "Invalid char `\\x%02X' in expression", c);
16264  token_flush(p);
16265  goto retry;
16266  }
16267 
16268  newtok(p);
16269  break;
16270  }
16271 
16272  return parse_ident(p, c, cmd_state);
16273 }
16274 
16275 static enum yytokentype
16276 yylex(YYSTYPE *lval, YYLTYPE *yylloc, struct parser_params *p)
16277 {
16278  enum yytokentype t;
16279 
16280  p->lval = lval;
16281  lval->val = Qundef;
16282  t = parser_yylex(p);
16283 
16284  if (p->lex.strterm && (p->lex.strterm->flags & STRTERM_HEREDOC))
16286  else
16287  RUBY_SET_YYLLOC(*yylloc);
16288 
16289  if (has_delayed_token(p))
16290  dispatch_delayed_token(p, t);
16291  else if (t != 0)
16292  dispatch_scan_event(p, t);
16293 
16294  return t;
16295 }
16296 
16297 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
16298 
16299 static NODE*
16300 node_newnode(struct parser_params *p, enum node_type type, VALUE a0, VALUE a1, VALUE a2, const rb_code_location_t *loc)
16301 {
16302  NODE *n = rb_ast_newnode(p->ast, type);
16303 
16304  rb_node_init(n, type, a0, a1, a2);
16305 
16306  nd_set_loc(n, loc);
16307  nd_set_node_id(n, parser_get_node_id(p));
16308  return n;
16309 }
16310 
16311 static NODE *
16312 nd_set_loc(NODE *nd, const YYLTYPE *loc)
16313 {
16314  nd->nd_loc = *loc;
16315  nd_set_line(nd, loc->beg_pos.lineno);
16316  return nd;
16317 }
16318 
16319 #ifndef RIPPER
16320 static enum node_type
16321 nodetype(NODE *node) /* for debug */
16322 {
16323  return (enum node_type)nd_type(node);
16324 }
16325 
16326 static int
16327 nodeline(NODE *node)
16328 {
16329  return nd_line(node);
16330 }
16331 
16332 static NODE*
16333 newline_node(NODE *node)
16334 {
16335  if (node) {
16336  node = remove_begin(node);
16337  node->flags |= NODE_FL_NEWLINE;
16338  }
16339  return node;
16340 }
16341 
16342 static void
16343 fixpos(NODE *node, NODE *orig)
16344 {
16345  if (!node) return;
16346  if (!orig) return;
16347  nd_set_line(node, nd_line(orig));
16348 }
16349 
16350 static void
16351 parser_warning(struct parser_params *p, NODE *node, const char *mesg)
16352 {
16353  rb_compile_warning(p->ruby_sourcefile, nd_line(node), "%s", mesg);
16354 }
16355 
16356 static void
16357 parser_warn(struct parser_params *p, NODE *node, const char *mesg)
16358 {
16359  rb_compile_warn(p->ruby_sourcefile, nd_line(node), "%s", mesg);
16360 }
16361 
16362 static NODE*
16363 block_append(struct parser_params *p, NODE *head, NODE *tail)
16364 {
16365  NODE *end, *h = head, *nd;
16366 
16367  if (tail == 0) return head;
16368 
16369  if (h == 0) return tail;
16370  switch (nd_type(h)) {
16371  case NODE_LIT:
16372  case NODE_STR:
16373  case NODE_SELF:
16374  case NODE_TRUE:
16375  case NODE_FALSE:
16376  case NODE_NIL:
16377  parser_warning(p, h, "unused literal ignored");
16378  return tail;
16379  default:
16380  h = end = NEW_BLOCK(head, &head->nd_loc);
16381  end->nd_end = end;
16382  head = end;
16383  break;
16384  case NODE_BLOCK:
16385  end = h->nd_end;
16386  break;
16387  }
16388 
16389  nd = end->nd_head;
16390  switch (nd_type(nd)) {
16391  case NODE_RETURN:
16392  case NODE_BREAK:
16393  case NODE_NEXT:
16394  case NODE_REDO:
16395  case NODE_RETRY:
16396  if (RTEST(ruby_verbose)) {
16397  parser_warning(p, tail, "statement not reached");
16398  }
16399  break;
16400 
16401  default:
16402  break;
16403  }
16404 
16405  if (nd_type(tail) != NODE_BLOCK) {
16406  tail = NEW_BLOCK(tail, &tail->nd_loc);
16407  tail->nd_end = tail;
16408  }
16409  end->nd_next = tail;
16410  h->nd_end = tail->nd_end;
16411  nd_set_last_loc(head, nd_last_loc(tail));
16412  return head;
16413 }
16414 
16415 /* append item to the list */
16416 static NODE*
16417 list_append(struct parser_params *p, NODE *list, NODE *item)
16418 {
16419  NODE *last;
16420 
16421  if (list == 0) return NEW_LIST(item, &item->nd_loc);
16422  if (list->nd_next) {
16423  last = list->nd_next->nd_end;
16424  }
16425  else {
16426  last = list;
16427  }
16428 
16429  list->nd_alen += 1;
16430  last->nd_next = NEW_LIST(item, &item->nd_loc);
16431  list->nd_next->nd_end = last->nd_next;
16432 
16434 
16435  return list;
16436 }
16437 
16438 /* concat two lists */
16439 static NODE*
16440 list_concat(NODE *head, NODE *tail)
16441 {
16442  NODE *last;
16443 
16444  if (head->nd_next) {
16445  last = head->nd_next->nd_end;
16446  }
16447  else {
16448  last = head;
16449  }
16450 
16451  head->nd_alen += tail->nd_alen;
16452  last->nd_next = tail;
16453  if (tail->nd_next) {
16454  head->nd_next->nd_end = tail->nd_next->nd_end;
16455  }
16456  else {
16457  head->nd_next->nd_end = tail;
16458  }
16459 
16460  nd_set_last_loc(head, nd_last_loc(tail));
16461 
16462  return head;
16463 }
16464 
16465 static int
16466 literal_concat0(struct parser_params *p, VALUE head, VALUE tail)
16467 {
16468  if (NIL_P(tail)) return 1;
16469  if (!rb_enc_compatible(head, tail)) {
16470  compile_error(p, "string literal encodings differ (%s / %s)",
16471  rb_enc_name(rb_enc_get(head)),
16472  rb_enc_name(rb_enc_get(tail)));
16473  rb_str_resize(head, 0);
16474  rb_str_resize(tail, 0);
16475  return 0;
16476  }
16477  rb_str_buf_append(head, tail);
16478  return 1;
16479 }
16480 
16481 /* concat two string literals */
16482 static NODE *
16483 literal_concat(struct parser_params *p, NODE *head, NODE *tail, const YYLTYPE *loc)
16484 {
16485  enum node_type htype;
16486  NODE *headlast;
16487  VALUE lit;
16488 
16489  if (!head) return tail;
16490  if (!tail) return head;
16491 
16492  htype = nd_type(head);
16493  if (htype == NODE_EVSTR) {
16494  NODE *node = NEW_DSTR(STR_NEW0(), loc);
16495  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit);
16496  head = list_append(p, node, head);
16497  htype = NODE_DSTR;
16498  }
16499  if (p->heredoc_indent > 0) {
16500  switch (htype) {
16501  case NODE_STR:
16502  nd_set_type(head, NODE_DSTR);
16503  case NODE_DSTR:
16504  return list_append(p, head, tail);
16505  default:
16506  break;
16507  }
16508  }
16509  switch (nd_type(tail)) {
16510  case NODE_STR:
16511  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
16512  nd_type(headlast) == NODE_STR) {
16513  htype = NODE_STR;
16514  lit = headlast->nd_lit;
16515  }
16516  else {
16517  lit = head->nd_lit;
16518  }
16519  if (htype == NODE_STR) {
16520  if (!literal_concat0(p, lit, tail->nd_lit)) {
16521  error:
16522  rb_discard_node(p, head);
16523  rb_discard_node(p, tail);
16524  return 0;
16525  }
16526  rb_discard_node(p, tail);
16527  }
16528  else {
16529  list_append(p, head, tail);
16530  }
16531  break;
16532 
16533  case NODE_DSTR:
16534  if (htype == NODE_STR) {
16535  if (!literal_concat0(p, head->nd_lit, tail->nd_lit))
16536  goto error;
16537  tail->nd_lit = head->nd_lit;
16538  rb_discard_node(p, head);
16539  head = tail;
16540  }
16541  else if (NIL_P(tail->nd_lit)) {
16542  append:
16543  head->nd_alen += tail->nd_alen - 1;
16544  head->nd_next->nd_end->nd_next = tail->nd_next;
16545  head->nd_next->nd_end = tail->nd_next->nd_end;
16546  rb_discard_node(p, tail);
16547  }
16548  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
16549  nd_type(headlast) == NODE_STR) {
16550  lit = headlast->nd_lit;
16551  if (!literal_concat0(p, lit, tail->nd_lit))
16552  goto error;
16553  tail->nd_lit = Qnil;
16554  goto append;
16555  }
16556  else {
16557  list_concat(head, NEW_NODE(NODE_LIST, NEW_STR(tail->nd_lit, loc), tail->nd_alen, tail->nd_next, loc));
16558  }
16559  break;
16560 
16561  case NODE_EVSTR:
16562  if (htype == NODE_STR) {
16563  nd_set_type(head, NODE_DSTR);
16564  head->nd_alen = 1;
16565  }
16566  list_append(p, head, tail);
16567  break;
16568  }
16569  return head;
16570 }
16571 
16572 static NODE *
16573 evstr2dstr(struct parser_params *p, NODE *node)
16574 {
16575  if (nd_type(node) == NODE_EVSTR) {
16576  NODE * dstr = NEW_DSTR(STR_NEW0(), &node->nd_loc);
16577  RB_OBJ_WRITTEN(p->ast, Qnil, dstr->nd_lit);
16578  node = list_append(p, dstr, node);
16579  }
16580  return node;
16581 }
16582 
16583 static NODE *
16584 new_evstr(struct parser_params *p, NODE *node, const YYLTYPE *loc)
16585 {
16586  NODE *head = node;
16587 
16588  if (node) {
16589  switch (nd_type(node)) {
16590  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
16591  return node;
16592  }
16593  }
16594  return NEW_EVSTR(head, loc);
16595 }
16596 
16597 static NODE *
16598 call_bin_op(struct parser_params *p, NODE *recv, ID id, NODE *arg1,
16599  const YYLTYPE *op_loc, const YYLTYPE *loc)
16600 {
16601  NODE *expr;
16602  value_expr(recv);
16603  value_expr(arg1);
16604  expr = NEW_OPCALL(recv, id, NEW_LIST(arg1, &arg1->nd_loc), loc);
16605  nd_set_line(expr, op_loc->beg_pos.lineno);
16606  return expr;
16607 }
16608 
16609 static NODE *
16610 call_uni_op(struct parser_params *p, NODE *recv, ID id, const YYLTYPE *op_loc, const YYLTYPE *loc)
16611 {
16612  NODE *opcall;
16613  value_expr(recv);
16614  opcall = NEW_OPCALL(recv, id, 0, loc);
16615  nd_set_line(opcall, op_loc->beg_pos.lineno);
16616  return opcall;
16617 }
16618 
16619 static NODE *
16620 new_qcall(struct parser_params* p, ID atype, NODE *recv, ID mid, NODE *args, const YYLTYPE *op_loc, const YYLTYPE *loc)
16621 {
16622  NODE *qcall = NEW_QCALL(atype, recv, mid, args, loc);
16623  nd_set_line(qcall, op_loc->beg_pos.lineno);
16624  return qcall;
16625 }
16626 
16627 static NODE*
16628 new_command_qcall(struct parser_params* p, ID atype, NODE *recv, ID mid, NODE *args, NODE *block, const YYLTYPE *op_loc, const YYLTYPE *loc)
16629 {
16630  NODE *ret;
16631  if (block) block_dup_check(p, args, block);
16632  ret = new_qcall(p, atype, recv, mid, args, op_loc, loc);
16633  if (block) ret = method_add_block(p, ret, block, loc);
16634  fixpos(ret, recv);
16635  return ret;
16636 }
16637 
16638 #define nd_once_body(node) (nd_type(node) == NODE_ONCE ? (node)->nd_body : node)
16639 static NODE*
16640 match_op(struct parser_params *p, NODE *node1, NODE *node2, const YYLTYPE *op_loc, const YYLTYPE *loc)
16641 {
16642  NODE *n;
16643  int line = op_loc->beg_pos.lineno;
16644 
16645  value_expr(node1);
16646  value_expr(node2);
16647  if (node1 && (n = nd_once_body(node1)) != 0) {
16648  switch (nd_type(n)) {
16649  case NODE_DREGX:
16650  {
16651  NODE *match = NEW_MATCH2(node1, node2, loc);
16652  nd_set_line(match, line);
16653  return match;
16654  }
16655 
16656  case NODE_LIT:
16657  if (RB_TYPE_P(n->nd_lit, T_REGEXP)) {
16658  const VALUE lit = n->nd_lit;
16659  NODE *match = NEW_MATCH2(node1, node2, loc);
16660  match->nd_args = reg_named_capture_assign(p, lit, loc);
16661  nd_set_line(match, line);
16662  return match;
16663  }
16664  }
16665  }
16666 
16667  if (node2 && (n = nd_once_body(node2)) != 0) {
16668  NODE *match3;
16669 
16670  switch (nd_type(n)) {
16671  case NODE_LIT:
16672  if (!RB_TYPE_P(n->nd_lit, T_REGEXP)) break;
16673  /* fallthru */
16674  case NODE_DREGX:
16675  match3 = NEW_MATCH3(node2, node1, loc);
16676  return match3;
16677  }
16678  }
16679 
16680  n = NEW_CALL(node1, tMATCH, NEW_LIST(node2, &node2->nd_loc), loc);
16681  nd_set_line(n, line);
16682  return n;
16683 }
16684 
16685 # if WARN_PAST_SCOPE
16686 static int
16687 past_dvar_p(struct parser_params *p, ID id)
16688 {
16689  struct vtable *past = p->lvtbl->past;
16690  while (past) {
16691  if (vtable_included(past, id)) return 1;
16692  past = past->prev;
16693  }
16694  return 0;
16695 }
16696 # endif
16697 
16698 /* As Ripper#warn does not have arguments for the location, so the
16699  * following messages cannot be separated */
16700 #define WARN_LOCATION(type) do { \
16701  if (p->warn_location) { \
16702  int line; \
16703  VALUE file = rb_source_location(&line); \
16704  rb_warn3(type" in eval may not return location in binding;" \
16705  " use Binding#source_location instead\n" \
16706  "%"PRIsWARN":%d: warning: in `%"PRIsWARN"'", \
16707  file, WARN_I(line), rb_id2str(rb_frame_this_func())); \
16708  } \
16709 } while (0)
16710 
16711 static int
16712 numparam_nested_p(struct parser_params *p)
16713 {
16714  struct local_vars *local = p->lvtbl;
16715  NODE *outer = local->numparam.outer;
16716  NODE *inner = local->numparam.inner;
16717  if (outer || inner) {
16718  NODE *used = outer ? outer : inner;
16719  compile_error(p, "numbered parameter is already used in\n"
16720  "%s:%d: %s block here",
16722  outer ? "outer" : "inner");
16723  parser_show_error_line(p, &used->nd_loc);
16724  return 1;
16725  }
16726  return 0;
16727 }
16728 
16729 static NODE*
16730 gettable(struct parser_params *p, ID id, const YYLTYPE *loc)
16731 {
16732  ID *vidp = NULL;
16733  NODE *node;
16734  switch (id) {
16735  case keyword_self:
16736  return NEW_SELF(loc);
16737  case keyword_nil:
16738  return NEW_NIL(loc);
16739  case keyword_true:
16740  return NEW_TRUE(loc);
16741  case keyword_false:
16742  return NEW_FALSE(loc);
16743  case keyword__FILE__:
16744  WARN_LOCATION("__FILE__");
16745  {
16746  VALUE file = p->ruby_sourcefile_string;
16747  if (NIL_P(file))
16748  file = rb_str_new(0, 0);
16749  else
16750  file = rb_str_dup(file);
16751  node = NEW_STR(file, loc);
16752  RB_OBJ_WRITTEN(p->ast, Qnil, file);
16753  }
16754  return node;
16755  case keyword__LINE__:
16756  WARN_LOCATION("__LINE__");
16757  return NEW_LIT(INT2FIX(p->tokline), loc);
16758  case keyword__ENCODING__:
16759  node = NEW_LIT(rb_enc_from_encoding(p->enc), loc);
16760  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit);
16761  return node;
16762 
16763  }
16764  switch (id_type(id)) {
16765  case ID_LOCAL:
16766  if (dyna_in_block(p) && dvar_defined_ref(p, id, &vidp)) {
16767  if (NUMPARAM_ID_P(id) && numparam_nested_p(p)) return 0;
16768  if (id == p->cur_arg) {
16769  compile_error(p, "circular argument reference - %"PRIsWARN, rb_id2str(id));
16770  return 0;
16771  }
16772  if (vidp) *vidp |= LVAR_USED;
16773  node = NEW_DVAR(id, loc);
16774  return node;
16775  }
16776  if (local_id_ref(p, id, &vidp)) {
16777  if (id == p->cur_arg) {
16778  compile_error(p, "circular argument reference - %"PRIsWARN, rb_id2str(id));
16779  return 0;
16780  }
16781  if (vidp) *vidp |= LVAR_USED;
16782  node = NEW_LVAR(id, loc);
16783  return node;
16784  }
16785  if (dyna_in_block(p) && NUMPARAM_ID_P(id) &&
16786  parser_numbered_param(p, NUMPARAM_ID_TO_IDX(id))) {
16787  if (numparam_nested_p(p)) return 0;
16788  node = NEW_DVAR(id, loc);
16789  struct local_vars *local = p->lvtbl;
16790  if (!local->numparam.current) local->numparam.current = node;
16791  return node;
16792  }
16793 # if WARN_PAST_SCOPE
16794  if (!p->in_defined && RTEST(ruby_verbose) && past_dvar_p(p, id)) {
16795  rb_warning1("possible reference to past scope - %"PRIsWARN, rb_id2str(id));
16796  }
16797 # endif
16798  /* method call without arguments */
16799  return NEW_VCALL(id, loc);
16800  case ID_GLOBAL:
16801  return NEW_GVAR(id, loc);
16802  case ID_INSTANCE:
16803  return NEW_IVAR(id, loc);
16804  case ID_CONST:
16805  return NEW_CONST(id, loc);
16806  case ID_CLASS:
16807  return NEW_CVAR(id, loc);
16808  }
16809  compile_error(p, "identifier %"PRIsVALUE" is not valid to get", rb_id2str(id));
16810  return 0;
16811 }
16812 
16813 static NODE *
16814 opt_arg_append(NODE *opt_list, NODE *opt)
16815 {
16816  NODE *opts = opt_list;
16817  opts->nd_loc.end_pos = opt->nd_loc.end_pos;
16818 
16819  while (opts->nd_next) {
16820  opts = opts->nd_next;
16821  opts->nd_loc.end_pos = opt->nd_loc.end_pos;
16822  }
16823  opts->nd_next = opt;
16824 
16825  return opt_list;
16826 }
16827 
16828 static NODE *
16829 kwd_append(NODE *kwlist, NODE *kw)
16830 {
16831  if (kwlist) {
16832  NODE *kws = kwlist;
16833  kws->nd_loc.end_pos = kw->nd_loc.end_pos;
16834  while (kws->nd_next) {
16835  kws = kws->nd_next;
16836  kws->nd_loc.end_pos = kw->nd_loc.end_pos;
16837  }
16838  kws->nd_next = kw;
16839  }
16840  return kwlist;
16841 }
16842 
16843 static NODE *
16844 new_defined(struct parser_params *p, NODE *expr, const YYLTYPE *loc)
16845 {
16846  return NEW_DEFINED(remove_begin_all(expr), loc);
16847 }
16848 
16849 static NODE*
16850 symbol_append(struct parser_params *p, NODE *symbols, NODE *symbol)
16851 {
16852  if (nd_type(symbol) == NODE_DSTR) {
16853  nd_set_type(symbol, NODE_DSYM);
16854  }
16855  else {
16856  nd_set_type(symbol, NODE_LIT);
16857  RB_OBJ_WRITTEN(p->ast, Qnil, symbol->nd_lit = rb_str_intern(symbol->nd_lit));
16858  }
16859  return list_append(p, symbols, symbol);
16860 }
16861 
16862 static NODE *
16863 new_regexp(struct parser_params *p, NODE *node, int options, const YYLTYPE *loc)
16864 {
16865  NODE *list, *prev;
16866  VALUE lit;
16867 
16868  if (!node) {
16869  node = NEW_LIT(reg_compile(p, STR_NEW0(), options), loc);
16870  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit);
16871  return node;
16872  }
16873  switch (nd_type(node)) {
16874  case NODE_STR:
16875  {
16876  VALUE src = node->nd_lit;
16877  nd_set_type(node, NODE_LIT);
16878  nd_set_loc(node, loc);
16879  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit = reg_compile(p, src, options));
16880  }
16881  break;
16882  default:
16883  lit = STR_NEW0();
16884  node = NEW_NODE(NODE_DSTR, lit, 1, NEW_LIST(node, loc), loc);
16885  RB_OBJ_WRITTEN(p->ast, Qnil, lit);
16886  /* fall through */
16887  case NODE_DSTR:
16888  nd_set_type(node, NODE_DREGX);
16889  nd_set_loc(node, loc);
16890  node->nd_cflag = options & RE_OPTION_MASK;
16891  if (!NIL_P(node->nd_lit)) reg_fragment_check(p, node->nd_lit, options);
16892  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
16893  if (nd_type(list->nd_head) == NODE_STR) {
16894  VALUE tail = list->nd_head->nd_lit;
16895  if (reg_fragment_check(p, tail, options) && prev && !NIL_P(prev->nd_lit)) {
16896  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
16897  if (!literal_concat0(p, lit, tail)) {
16898  return NEW_NIL(loc); /* dummy node on error */
16899  }
16900  rb_str_resize(tail, 0);
16901  prev->nd_next = list->nd_next;
16902  rb_discard_node(p, list->nd_head);
16903  rb_discard_node(p, list);
16904  list = prev;
16905  }
16906  else {
16907  prev = list;
16908  }
16909  }
16910  else {
16911  prev = 0;
16912  }
16913  }
16914  if (!node->nd_next) {
16915  VALUE src = node->nd_lit;
16916  nd_set_type(node, NODE_LIT);
16917  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit = reg_compile(p, src, options));
16918  }
16919  if (options & RE_OPTION_ONCE) {
16920  node = NEW_NODE(NODE_ONCE, 0, node, 0, loc);
16921  }
16922  break;
16923  }
16924  return node;
16925 }
16926 
16927 static NODE *
16928 new_kw_arg(struct parser_params *p, NODE *k, const YYLTYPE *loc)
16929 {
16930  if (!k) return 0;
16931  return NEW_KW_ARG(0, (k), loc);
16932 }
16933 
16934 static NODE *
16935 new_xstring(struct parser_params *p, NODE *node, const YYLTYPE *loc)
16936 {
16937  if (!node) {
16938  VALUE lit = STR_NEW0();
16939  NODE *xstr = NEW_XSTR(lit, loc);
16940  RB_OBJ_WRITTEN(p->ast, Qnil, lit);
16941  return xstr;
16942  }
16943  switch (nd_type(node)) {
16944  case NODE_STR:
16945  nd_set_type(node, NODE_XSTR);
16946  nd_set_loc(node, loc);
16947  break;
16948  case NODE_DSTR:
16949  nd_set_type(node, NODE_DXSTR);
16950  nd_set_loc(node, loc);
16951  break;
16952  default:
16953  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node, loc), loc);
16954  break;
16955  }
16956  return node;
16957 }
16958 
16959 static void
16960 check_literal_when(struct parser_params *p, NODE *arg, const YYLTYPE *loc)
16961 {
16962  VALUE lit;
16963 
16964  if (!arg || !p->case_labels) return;
16965 
16967  if (lit == Qundef) return;
16968  if (nd_type(arg) == NODE_STR) {
16969  RB_OBJ_WRITTEN(p->ast, Qnil, arg->nd_lit = lit);
16970  }
16971 
16972  if (NIL_P(p->case_labels)) {
16974  }
16975  else {
16976  VALUE line = rb_hash_lookup(p->case_labels, lit);
16977  if (!NIL_P(line)) {
16978  rb_warning1("duplicated `when' clause with line %d is ignored",
16979  WARN_IVAL(line));
16980  return;
16981  }
16982  }
16984 }
16985 
16986 #else /* !RIPPER */
16987 static int
16988 id_is_var(struct parser_params *p, ID id)
16989 {
16990  if (is_notop_id(id)) {
16991  switch (id & ID_SCOPE_MASK) {
16992  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
16993  return 1;
16994  case ID_LOCAL:
16995  if (dyna_in_block(p)) {
16996  if (NUMPARAM_ID_P(id) || dvar_defined(p, id)) return 1;
16997  }
16998  if (local_id(p, id)) return 1;
16999  /* method call without arguments */
17000  return 0;
17001  }
17002  }
17003  compile_error(p, "identifier %"PRIsVALUE" is not valid to get", rb_id2str(id));
17004  return 0;
17005 }
17006 
17007 static VALUE
17008 new_regexp(struct parser_params *p, VALUE re, VALUE opt, const YYLTYPE *loc)
17009 {
17010  VALUE src = 0, err;
17011  int options = 0;
17012  if (ripper_is_node_yylval(re)) {
17013  src = RNODE(re)->nd_cval;
17014  re = RNODE(re)->nd_rval;
17015  }
17016  if (ripper_is_node_yylval(opt)) {
17017  options = (int)RNODE(opt)->nd_tag;
17018  opt = RNODE(opt)->nd_rval;
17019  }
17020  if (src && NIL_P(parser_reg_compile(p, src, options, &err))) {
17021  compile_error(p, "%"PRIsVALUE, err);
17022  }
17023  return dispatch2(regexp_literal, re, opt);
17024 }
17025 #endif /* !RIPPER */
17026 
17027 
17028 #ifndef RIPPER
17029 static const char rb_parser_lex_state_names[][8] = {
17030  "BEG", "END", "ENDARG", "ENDFN", "ARG",
17031  "CMDARG", "MID", "FNAME", "DOT", "CLASS",
17032  "LABEL", "LABELED","FITEM",
17033 };
17034 
17035 static VALUE
17036 append_lex_state_name(enum lex_state_e state, VALUE buf)
17037 {
17038  int i, sep = 0;
17039  unsigned int mask = 1;
17040  static const char none[] = "NONE";
17041 
17042  for (i = 0; i < EXPR_MAX_STATE; ++i, mask <<= 1) {
17043  if ((unsigned)state & mask) {
17044  if (sep) {
17045  rb_str_cat(buf, "|", 1);
17046  }
17047  sep = 1;
17048  rb_str_cat_cstr(buf, rb_parser_lex_state_names[i]);
17049  }
17050  }
17051  if (!sep) {
17052  rb_str_cat(buf, none, sizeof(none)-1);
17053  }
17054  return buf;
17055 }
17056 
17057 static void
17058 flush_debug_buffer(struct parser_params *p, VALUE out, VALUE str)
17059 {
17060  VALUE mesg = p->debug_buffer;
17061 
17062  if (!NIL_P(mesg) && RSTRING_LEN(mesg)) {
17063  p->debug_buffer = Qnil;
17064  rb_io_puts(1, &mesg, out);
17065  }
17066  if (!NIL_P(str) && RSTRING_LEN(str)) {
17068  }
17069 }
17070 
17071 enum lex_state_e
17073  enum lex_state_e to, int line)
17074 {
17075  VALUE mesg;
17076  mesg = rb_str_new_cstr("lex_state: ");
17077  append_lex_state_name(from, mesg);
17078  rb_str_cat_cstr(mesg, " -> ");
17079  append_lex_state_name(to, mesg);
17080  rb_str_catf(mesg, " at line %d\n", line);
17081  flush_debug_buffer(p, p->debug_output, mesg);
17082  return to;
17083 }
17084 
17085 VALUE
17087 {
17088  return rb_fstring(append_lex_state_name(state, rb_str_new(0, 0)));
17089 }
17090 
17091 static void
17092 append_bitstack_value(stack_type stack, VALUE mesg)
17093 {
17094  if (stack == 0) {
17095  rb_str_cat_cstr(mesg, "0");
17096  }
17097  else {
17098  stack_type mask = (stack_type)1U << (CHAR_BIT * sizeof(stack_type) - 1);
17099  for (; mask && !(stack & mask); mask >>= 1) continue;
17100  for (; mask; mask >>= 1) rb_str_cat(mesg, stack & mask ? "1" : "0", 1);
17101  }
17102 }
17103 
17104 void
17106  const char *name, int line)
17107 {
17108  VALUE mesg = rb_sprintf("%s: ", name);
17109  append_bitstack_value(stack, mesg);
17110  rb_str_catf(mesg, " at line %d\n", line);
17111  flush_debug_buffer(p, p->debug_output, mesg);
17112 }
17113 
17114 void
17115 rb_parser_fatal(struct parser_params *p, const char *fmt, ...)
17116 {
17117  va_list ap;
17118  VALUE mesg = rb_str_new_cstr("internal parser error: ");
17119 
17120  va_start(ap, fmt);
17121  rb_str_vcatf(mesg, fmt, ap);
17122  va_end(ap);
17123  parser_yyerror(p, NULL, RSTRING_PTR(mesg));
17124  RB_GC_GUARD(mesg);
17125 
17126  mesg = rb_str_new(0, 0);
17127  append_lex_state_name(p->lex.state, mesg);
17128  compile_error(p, "lex.state: %"PRIsVALUE, mesg);
17129  rb_str_resize(mesg, 0);
17130  append_bitstack_value(p->cond_stack, mesg);
17131  compile_error(p, "cond_stack: %"PRIsVALUE, mesg);
17132  rb_str_resize(mesg, 0);
17133  append_bitstack_value(p->cmdarg_stack, mesg);
17134  compile_error(p, "cmdarg_stack: %"PRIsVALUE, mesg);
17135  if (p->debug_output == rb_stdout)
17136  p->debug_output = rb_stderr;
17137  p->debug = TRUE;
17138 }
17139 
17140 YYLTYPE *
17142 {
17143  int sourceline = here->sourceline;
17144  int beg_pos = (int)here->offset - here->quote
17145  - (rb_strlen_lit("<<-") - !(here->func & STR_FUNC_INDENT));
17146  int end_pos = (int)here->offset + here->length + here->quote;
17147 
17148  yylloc->beg_pos.lineno = sourceline;
17149  yylloc->beg_pos.column = beg_pos;
17150  yylloc->end_pos.lineno = sourceline;
17151  yylloc->end_pos.column = end_pos;
17152  return yylloc;
17153 }
17154 
17155 YYLTYPE *
17157 {
17158  yylloc->beg_pos.lineno = p->ruby_sourceline;
17159  yylloc->beg_pos.column = (int)(p->lex.ptok - p->lex.pbeg);
17160  yylloc->end_pos.lineno = p->ruby_sourceline;
17161  yylloc->end_pos.column = (int)(p->lex.ptok - p->lex.pbeg);
17162  return yylloc;
17163 }
17164 
17165 YYLTYPE *
17167 {
17168  yylloc->beg_pos.lineno = p->ruby_sourceline;
17169  yylloc->beg_pos.column = (int)(p->lex.ptok - p->lex.pbeg);
17170  yylloc->end_pos.lineno = p->ruby_sourceline;
17171  yylloc->end_pos.column = (int)(p->lex.pcur - p->lex.pbeg);
17172  return yylloc;
17173 }
17174 #endif /* !RIPPER */
17175 
17176 static void
17177 parser_token_value_print(struct parser_params *p, enum yytokentype type, const YYSTYPE *valp)
17178 {
17179  VALUE v;
17180 
17181  switch (type) {
17182  case tIDENTIFIER: case tFID: case tGVAR: case tIVAR:
17183  case tCONSTANT: case tCVAR: case tLABEL: case tOP_ASGN:
17184 #ifndef RIPPER
17185  v = rb_id2str(valp->id);
17186 #else
17187  v = valp->node->nd_rval;
17188 #endif
17189  rb_parser_printf(p, "%"PRIsVALUE, v);
17190  break;
17191  case tINTEGER: case tFLOAT: case tRATIONAL: case tIMAGINARY:
17192  case tSTRING_CONTENT: case tCHAR:
17193 #ifndef RIPPER
17194  v = valp->node->nd_lit;
17195 #else
17196  v = valp->val;
17197 #endif
17198  rb_parser_printf(p, "%+"PRIsVALUE, v);
17199  break;
17200  case tNTH_REF:
17201 #ifndef RIPPER
17202  rb_parser_printf(p, "$%ld", valp->node->nd_nth);
17203 #else
17204  rb_parser_printf(p, "%"PRIsVALUE, valp->val);
17205 #endif
17206  break;
17207  case tBACK_REF:
17208 #ifndef RIPPER
17209  rb_parser_printf(p, "$%c", (int)valp->node->nd_nth);
17210 #else
17211  rb_parser_printf(p, "%"PRIsVALUE, valp->val);
17212 #endif
17213  break;
17214  default:
17215  break;
17216  }
17217 }
17218 
17219 static int
17220 assignable0(struct parser_params *p, ID id, const char **err)
17221 {
17222  if (!id) return -1;
17223  switch (id) {
17224  case keyword_self:
17225  *err = "Can't change the value of self";
17226  return -1;
17227  case keyword_nil:
17228  *err = "Can't assign to nil";
17229  return -1;
17230  case keyword_true:
17231  *err = "Can't assign to true";
17232  return -1;
17233  case keyword_false:
17234  *err = "Can't assign to false";
17235  return -1;
17236  case keyword__FILE__:
17237  *err = "Can't assign to __FILE__";
17238  return -1;
17239  case keyword__LINE__:
17240  *err = "Can't assign to __LINE__";
17241  return -1;
17242  case keyword__ENCODING__:
17243  *err = "Can't assign to __ENCODING__";
17244  return -1;
17245  }
17246  switch (id_type(id)) {
17247  case ID_LOCAL:
17248  if (dyna_in_block(p)) {
17249  if (p->max_numparam > NO_PARAM && NUMPARAM_ID_P(id)) {
17250  compile_error(p, "Can't assign to numbered parameter _%d",
17251  NUMPARAM_ID_TO_IDX(id));
17252  return -1;
17253  }
17254  if (dvar_curr(p, id)) return NODE_DASGN_CURR;
17255  if (dvar_defined(p, id)) return NODE_DASGN;
17256  if (local_id(p, id)) return NODE_LASGN;
17257  dyna_var(p, id);
17258  return NODE_DASGN_CURR;
17259  }
17260  else {
17261  if (!local_id(p, id)) local_var(p, id);
17262  return NODE_LASGN;
17263  }
17264  break;
17265  case ID_GLOBAL: return NODE_GASGN;
17266  case ID_INSTANCE: return NODE_IASGN;
17267  case ID_CONST:
17268  if (!p->in_def) return NODE_CDECL;
17269  *err = "dynamic constant assignment";
17270  return -1;
17271  case ID_CLASS: return NODE_CVASGN;
17272  default:
17273  compile_error(p, "identifier %"PRIsVALUE" is not valid to set", rb_id2str(id));
17274  }
17275  return -1;
17276 }
17277 
17278 #ifndef RIPPER
17279 static NODE*
17280 assignable(struct parser_params *p, ID id, NODE *val, const YYLTYPE *loc)
17281 {
17282  const char *err = 0;
17283  int node_type = assignable0(p, id, &err);
17284  switch (node_type) {
17285  case NODE_DASGN_CURR: return NEW_DASGN_CURR(id, val, loc);
17286  case NODE_DASGN: return NEW_DASGN(id, val, loc);
17287  case NODE_LASGN: return NEW_LASGN(id, val, loc);
17288  case NODE_GASGN: return NEW_GASGN(id, val, loc);
17289  case NODE_IASGN: return NEW_IASGN(id, val, loc);
17290  case NODE_CDECL: return NEW_CDECL(id, val, 0, loc);
17291  case NODE_CVASGN: return NEW_CVASGN(id, val, loc);
17292  }
17293  if (err) yyerror1(loc, err);
17294  return NEW_BEGIN(0, loc);
17295 }
17296 #else
17297 static VALUE
17298 assignable(struct parser_params *p, VALUE lhs)
17299 {
17300  const char *err = 0;
17301  assignable0(p, get_id(lhs), &err);
17302  if (err) lhs = assign_error(p, lhs);
17303  return lhs;
17304 }
17305 #endif
17306 
17307 static int
17308 is_private_local_id(ID name)
17309 {
17310  VALUE s;
17311  if (name == idUScore) return 1;
17312  if (!is_local_id(name)) return 0;
17313  s = rb_id2str(name);
17314  if (!s) return 0;
17315  return RSTRING_PTR(s)[0] == '_';
17316 }
17317 
17318 static int
17319 shadowing_lvar_0(struct parser_params *p, ID name)
17320 {
17321  if (is_private_local_id(name)) return 1;
17322  if (dyna_in_block(p)) {
17323  if (dvar_curr(p, name)) {
17324  yyerror0("duplicated argument name");
17325  }
17326  else if (dvar_defined(p, name) || local_id(p, name)) {
17327  vtable_add(p->lvtbl->vars, name);
17328  if (p->lvtbl->used) {
17330  }
17331  return 0;
17332  }
17333  }
17334  else {
17335  if (local_id(p, name)) {
17336  yyerror0("duplicated argument name");
17337  }
17338  }
17339  return 1;
17340 }
17341 
17342 static ID
17343 shadowing_lvar(struct parser_params *p, ID name)
17344 {
17345  shadowing_lvar_0(p, name);
17346  return name;
17347 }
17348 
17349 static void
17350 new_bv(struct parser_params *p, ID name)
17351 {
17352  if (!name) return;
17353  if (!is_local_id(name)) {
17354  compile_error(p, "invalid local variable - %"PRIsVALUE,
17355  rb_id2str(name));
17356  return;
17357  }
17358  if (!shadowing_lvar_0(p, name)) return;
17359  dyna_var(p, name);
17360 }
17361 
17362 #ifndef RIPPER
17363 static NODE *
17364 aryset(struct parser_params *p, NODE *recv, NODE *idx, const YYLTYPE *loc)
17365 {
17366  return NEW_ATTRASGN(recv, tASET, idx, loc);
17367 }
17368 
17369 static void
17370 block_dup_check(struct parser_params *p, NODE *node1, NODE *node2)
17371 {
17372  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
17373  compile_error(p, "both block arg and actual block given");
17374  }
17375 }
17376 
17377 static NODE *
17378 attrset(struct parser_params *p, NODE *recv, ID atype, ID id, const YYLTYPE *loc)
17379 {
17380  if (!CALL_Q_P(atype)) id = rb_id_attrset(id);
17381  return NEW_ATTRASGN(recv, id, 0, loc);
17382 }
17383 
17384 static void
17385 rb_backref_error(struct parser_params *p, NODE *node)
17386 {
17387  switch (nd_type(node)) {
17388  case NODE_NTH_REF:
17389  compile_error(p, "Can't set variable $%ld", node->nd_nth);
17390  break;
17391  case NODE_BACK_REF:
17392  compile_error(p, "Can't set variable $%c", (int)node->nd_nth);
17393  break;
17394  }
17395 }
17396 
17397 static NODE *
17398 arg_append(struct parser_params *p, NODE *node1, NODE *node2, const YYLTYPE *loc)
17399 {
17400  if (!node1) return NEW_LIST(node2, &node2->nd_loc);
17401  switch (nd_type(node1)) {
17402  case NODE_LIST:
17403  return list_append(p, node1, node2);
17404  case NODE_BLOCK_PASS:
17405  node1->nd_head = arg_append(p, node1->nd_head, node2, loc);
17406  node1->nd_loc.end_pos = node1->nd_head->nd_loc.end_pos;
17407  return node1;
17408  case NODE_ARGSPUSH:
17409  node1->nd_body = list_append(p, NEW_LIST(node1->nd_body, &node1->nd_body->nd_loc), node2);
17410  node1->nd_loc.end_pos = node1->nd_body->nd_loc.end_pos;
17411  nd_set_type(node1, NODE_ARGSCAT);
17412  return node1;
17413  case NODE_ARGSCAT:
17414  if (nd_type(node1->nd_body) != NODE_LIST) break;
17415  node1->nd_body = list_append(p, node1->nd_body, node2);
17416  node1->nd_loc.end_pos = node1->nd_body->nd_loc.end_pos;
17417  return node1;
17418  }
17419  return NEW_ARGSPUSH(node1, node2, loc);
17420 }
17421 
17422 static NODE *
17423 arg_concat(struct parser_params *p, NODE *node1, NODE *node2, const YYLTYPE *loc)
17424 {
17425  if (!node2) return node1;
17426  switch (nd_type(node1)) {
17427  case NODE_BLOCK_PASS:
17428  if (node1->nd_head)
17429  node1->nd_head = arg_concat(p, node1->nd_head, node2, loc);
17430  else
17431  node1->nd_head = NEW_LIST(node2, loc);
17432  return node1;
17433  case NODE_ARGSPUSH:
17434  if (nd_type(node2) != NODE_LIST) break;
17435  node1->nd_body = list_concat(NEW_LIST(node1->nd_body, loc), node2);
17436  nd_set_type(node1, NODE_ARGSCAT);
17437  return node1;
17438  case NODE_ARGSCAT:
17439  if (nd_type(node2) != NODE_LIST ||
17440  nd_type(node1->nd_body) != NODE_LIST) break;
17441  node1->nd_body = list_concat(node1->nd_body, node2);
17442  return node1;
17443  }
17444  return NEW_ARGSCAT(node1, node2, loc);
17445 }
17446 
17447 static NODE *
17448 last_arg_append(struct parser_params *p, NODE *args, NODE *last_arg, const YYLTYPE *loc)
17449 {
17450  NODE *n1;
17451  if ((n1 = splat_array(args)) != 0) {
17452  return list_append(p, n1, last_arg);
17453  }
17454  return arg_append(p, args, last_arg, loc);
17455 }
17456 
17457 static NODE *
17458 rest_arg_append(struct parser_params *p, NODE *args, NODE *rest_arg, const YYLTYPE *loc)
17459 {
17460  NODE *n1;
17461  if ((nd_type(rest_arg) == NODE_LIST) && (n1 = splat_array(args)) != 0) {
17462  return list_concat(n1, rest_arg);
17463  }
17464  return arg_concat(p, args, rest_arg, loc);
17465 }
17466 
17467 static NODE *
17468 splat_array(NODE* node)
17469 {
17470  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
17471  if (nd_type(node) == NODE_LIST) return node;
17472  return 0;
17473 }
17474 
17475 static void
17476 mark_lvar_used(struct parser_params *p, NODE *rhs)
17477 {
17478  ID *vidp = NULL;
17479  if (!rhs) return;
17480  switch (nd_type(rhs)) {
17481  case NODE_LASGN:
17482  if (local_id_ref(p, rhs->nd_vid, &vidp)) {
17483  if (vidp) *vidp |= LVAR_USED;
17484  }
17485  break;
17486  case NODE_DASGN:
17487  case NODE_DASGN_CURR:
17488  if (dvar_defined_ref(p, rhs->nd_vid, &vidp)) {
17489  if (vidp) *vidp |= LVAR_USED;
17490  }
17491  break;
17492 #if 0
17493  case NODE_MASGN:
17494  for (rhs = rhs->nd_head; rhs; rhs = rhs->nd_next) {
17495  mark_lvar_used(p, rhs->nd_head);
17496  }
17497  break;
17498 #endif
17499  }
17500 }
17501 
17502 static NODE *
17503 node_assign(struct parser_params *p, NODE *lhs, NODE *rhs, const YYLTYPE *loc)
17504 {
17505  if (!lhs) return 0;
17506 
17507  switch (nd_type(lhs)) {
17508  case NODE_GASGN:
17509  case NODE_IASGN:
17510  case NODE_LASGN:
17511  case NODE_DASGN:
17512  case NODE_DASGN_CURR:
17513  case NODE_MASGN:
17514  case NODE_CDECL:
17515  case NODE_CVASGN:
17516  lhs->nd_value = rhs;
17517  nd_set_loc(lhs, loc);
17518  break;
17519 
17520  case NODE_ATTRASGN:
17521  lhs->nd_args = arg_append(p, lhs->nd_args, rhs, loc);
17522  nd_set_loc(lhs, loc);
17523  break;
17524 
17525  default:
17526  /* should not happen */
17527  break;
17528  }
17529 
17530  return lhs;
17531 }
17532 
17533 static NODE *
17534 value_expr_check(struct parser_params *p, NODE *node)
17535 {
17536  NODE *void_node = 0, *vn;
17537 
17538  if (!node) {
17539  rb_warning0("empty expression");
17540  }
17541  while (node) {
17542  switch (nd_type(node)) {
17543  case NODE_RETURN:
17544  case NODE_BREAK:
17545  case NODE_NEXT:
17546  case NODE_REDO:
17547  case NODE_RETRY:
17548  return void_node ? void_node : node;
17549 
17550  case NODE_CASE3:
17551  if (!node->nd_body || nd_type(node->nd_body) != NODE_IN) {
17552  compile_error(p, "unexpected node");
17553  return NULL;
17554  }
17555  if (node->nd_body->nd_body) {
17556  return NULL;
17557  }
17558  /* single line pattern matching */
17559  return void_node ? void_node : node;
17560 
17561  case NODE_BLOCK:
17562  while (node->nd_next) {
17563  node = node->nd_next;
17564  }
17565  node = node->nd_head;
17566  break;
17567 
17568  case NODE_BEGIN:
17569  node = node->nd_body;
17570  break;
17571 
17572  case NODE_IF:
17573  case NODE_UNLESS:
17574  if (!node->nd_body) {
17575  return NULL;
17576  }
17577  else if (!node->nd_else) {
17578  return NULL;
17579  }
17580  vn = value_expr_check(p, node->nd_body);
17581  if (!vn) return NULL;
17582  if (!void_node) void_node = vn;
17583  node = node->nd_else;
17584  break;
17585 
17586  case NODE_AND:
17587  case NODE_OR:
17588  node = node->nd_1st;
17589  break;
17590 
17591  case NODE_LASGN:
17592  case NODE_DASGN:
17593  case NODE_DASGN_CURR:
17594  case NODE_MASGN:
17595  mark_lvar_used(p, node);
17596  return NULL;
17597 
17598  default:
17599  return NULL;
17600  }
17601  }
17602 
17603  return NULL;
17604 }
17605 
17606 static int
17607 value_expr_gen(struct parser_params *p, NODE *node)
17608 {
17609  NODE *void_node = value_expr_check(p, node);
17610  if (void_node) {
17611  yyerror1(&void_node->nd_loc, "void value expression");
17612  /* or "control never reach"? */
17613  return FALSE;
17614  }
17615  return TRUE;
17616 }
17617 static void
17618 void_expr(struct parser_params *p, NODE *node)
17619 {
17620  const char *useless = 0;
17621 
17622  if (!RTEST(ruby_verbose)) return;
17623 
17624  if (!node || !(node = nd_once_body(node))) return;
17625  switch (nd_type(node)) {
17626  case NODE_OPCALL:
17627  switch (node->nd_mid) {
17628  case '+':
17629  case '-':
17630  case '*':
17631  case '/':
17632  case '%':
17633  case tPOW:
17634  case tUPLUS:
17635  case tUMINUS:
17636  case '|':
17637  case '^':
17638  case '&':
17639  case tCMP:
17640  case '>':
17641  case tGEQ:
17642  case '<':
17643  case tLEQ:
17644  case tEQ:
17645  case tNEQ:
17646  useless = rb_id2name(node->nd_mid);
17647  break;
17648  }
17649  break;
17650 
17651  case NODE_LVAR:
17652  case NODE_DVAR:
17653  case NODE_GVAR:
17654  case NODE_IVAR:
17655  case NODE_CVAR:
17656  case NODE_NTH_REF:
17657  case NODE_BACK_REF:
17658  useless = "a variable";
17659  break;
17660  case NODE_CONST:
17661  useless = "a constant";
17662  break;
17663  case NODE_LIT:
17664  case NODE_STR:
17665  case NODE_DSTR:
17666  case NODE_DREGX:
17667  useless = "a literal";
17668  break;
17669  case NODE_COLON2:
17670  case NODE_COLON3:
17671  useless = "::";
17672  break;
17673  case NODE_DOT2:
17674  useless = "..";
17675  break;
17676  case NODE_DOT3:
17677  useless = "...";
17678  break;
17679  case NODE_SELF:
17680  useless = "self";
17681  break;
17682  case NODE_NIL:
17683  useless = "nil";
17684  break;
17685  case NODE_TRUE:
17686  useless = "true";
17687  break;
17688  case NODE_FALSE:
17689  useless = "false";
17690  break;
17691  case NODE_DEFINED:
17692  useless = "defined?";
17693  break;
17694  }
17695 
17696  if (useless) {
17697  rb_warn1L(nd_line(node), "possibly useless use of %s in void context", WARN_S(useless));
17698  }
17699 }
17700 
17701 static NODE *
17702 void_stmts(struct parser_params *p, NODE *node)
17703 {
17704  NODE *const n = node;
17705  if (!RTEST(ruby_verbose)) return n;
17706  if (!node) return n;
17707  if (nd_type(node) != NODE_BLOCK) return n;
17708 
17709  while (node->nd_next) {
17710  void_expr(p, node->nd_head);
17711  node = node->nd_next;
17712  }
17713  return n;
17714 }
17715 
17716 static NODE *
17717 remove_begin(NODE *node)
17718 {
17719  NODE **n = &node, *n1 = node;
17720  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
17721  *n = n1 = n1->nd_body;
17722  }
17723  return node;
17724 }
17725 
17726 static NODE *
17727 remove_begin_all(NODE *node)
17728 {
17729  NODE **n = &node, *n1 = node;
17730  while (n1 && nd_type(n1) == NODE_BEGIN) {
17731  *n = n1 = n1->nd_body;
17732  }
17733  return node;
17734 }
17735 
17736 static void
17737 reduce_nodes(struct parser_params *p, NODE **body)
17738 {
17739  NODE *node = *body;
17740 
17741  if (!node) {
17742  *body = NEW_NIL(&NULL_LOC);
17743  return;
17744  }
17745 #define subnodes(n1, n2) \
17746  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
17747  (!node->n2) ? (body = &node->n1, 1) : \
17748  (reduce_nodes(p, &node->n1), body = &node->n2, 1))
17749 
17750  while (node) {
17751  int newline = (int)(node->flags & NODE_FL_NEWLINE);
17752  switch (nd_type(node)) {
17753  end:
17754  case NODE_NIL:
17755  *body = 0;
17756  return;
17757  case NODE_RETURN:
17758  *body = node = node->nd_stts;
17759  if (newline && node) node->flags |= NODE_FL_NEWLINE;
17760  continue;
17761  case NODE_BEGIN:
17762  *body = node = node->nd_body;
17763  if (newline && node) node->flags |= NODE_FL_NEWLINE;
17764  continue;
17765  case NODE_BLOCK:
17766  body = &node->nd_end->nd_head;
17767  break;
17768  case NODE_IF:
17769  case NODE_UNLESS:
17770  if (subnodes(nd_body, nd_else)) break;
17771  return;
17772  case NODE_CASE:
17773  body = &node->nd_body;
17774  break;
17775  case NODE_WHEN:
17776  if (!subnodes(nd_body, nd_next)) goto end;
17777  break;
17778  case NODE_ENSURE:
17779  if (!subnodes(nd_head, nd_resq)) goto end;
17780  break;
17781  case NODE_RESCUE:
17782  if (node->nd_else) {
17783  body = &node->nd_resq;
17784  break;
17785  }
17786  if (!subnodes(nd_head, nd_resq)) goto end;
17787  break;
17788  default:
17789  return;
17790  }
17791  node = *body;
17792  if (newline && node) node->flags |= NODE_FL_NEWLINE;
17793  }
17794 
17795 #undef subnodes
17796 }
17797 
17798 static int
17799 is_static_content(NODE *node)
17800 {
17801  if (!node) return 1;
17802  switch (nd_type(node)) {
17803  case NODE_HASH:
17804  if (!(node = node->nd_head)) break;
17805  case NODE_LIST:
17806  do {
17807  if (!is_static_content(node->nd_head)) return 0;
17808  } while ((node = node->nd_next) != 0);
17809  case NODE_LIT:
17810  case NODE_STR:
17811  case NODE_NIL:
17812  case NODE_TRUE:
17813  case NODE_FALSE:
17814  case NODE_ZLIST:
17815  break;
17816  default:
17817  return 0;
17818  }
17819  return 1;
17820 }
17821 
17822 static int
17823 assign_in_cond(struct parser_params *p, NODE *node)
17824 {
17825  switch (nd_type(node)) {
17826  case NODE_MASGN:
17827  case NODE_LASGN:
17828  case NODE_DASGN:
17829  case NODE_DASGN_CURR:
17830  case NODE_GASGN:
17831  case NODE_IASGN:
17832  break;
17833 
17834  default:
17835  return 0;
17836  }
17837 
17838  if (!node->nd_value) return 1;
17839  if (is_static_content(node->nd_value)) {
17840  /* reports always */
17841  parser_warn(p, node->nd_value, "found `= literal' in conditional, should be ==");
17842  }
17843  return 1;
17844 }
17845 
17849  COND_IN_FF
17850 };
17851 
17852 #define SWITCH_BY_COND_TYPE(t, w, arg) \
17853  switch (t) { \
17854  case COND_IN_OP: break; \
17855  case COND_IN_COND: rb_##w##0(arg "literal in condition"); break; \
17856  case COND_IN_FF: rb_##w##0(arg "literal in flip-flop"); break; \
17857  }
17858 
17859 static NODE *cond0(struct parser_params*,NODE*,enum cond_type,const YYLTYPE*);
17860 
17861 static NODE*
17862 range_op(struct parser_params *p, NODE *node, const YYLTYPE *loc)
17863 {
17864  enum node_type type;
17865 
17866  if (node == 0) return 0;
17867 
17868  type = nd_type(node);
17869  value_expr(node);
17870  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
17871  if (!e_option_supplied(p)) parser_warn(p, node, "integer literal in flip-flop");
17872  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."), loc), loc), loc);
17873  }
17874  return cond0(p, node, COND_IN_FF, loc);
17875 }
17876 
17877 static NODE*
17878 cond0(struct parser_params *p, NODE *node, enum cond_type type, const YYLTYPE *loc)
17879 {
17880  if (node == 0) return 0;
17881  if (!(node = nd_once_body(node))) return 0;
17882  assign_in_cond(p, node);
17883 
17884  switch (nd_type(node)) {
17885  case NODE_DSTR:
17886  case NODE_EVSTR:
17887  case NODE_STR:
17888  SWITCH_BY_COND_TYPE(type, warn, "string ")
17889  break;
17890 
17891  case NODE_DREGX:
17892  if (!e_option_supplied(p)) SWITCH_BY_COND_TYPE(type, warning, "regex ")
17893 
17894  return NEW_MATCH2(node, NEW_GVAR(idLASTLINE, loc), loc);
17895 
17896  case NODE_AND:
17897  case NODE_OR:
17898  node->nd_1st = cond0(p, node->nd_1st, COND_IN_COND, loc);
17899  node->nd_2nd = cond0(p, node->nd_2nd, COND_IN_COND, loc);
17900  break;
17901 
17902  case NODE_DOT2:
17903  case NODE_DOT3:
17904  node->nd_beg = range_op(p, node->nd_beg, loc);
17905  node->nd_end = range_op(p, node->nd_end, loc);
17906  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
17907  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
17908  break;
17909 
17910  case NODE_DSYM:
17911  SWITCH_BY_COND_TYPE(type, warning, "string ")
17912  break;
17913 
17914  case NODE_LIT:
17915  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
17916  if (!e_option_supplied(p)) SWITCH_BY_COND_TYPE(type, warn, "regex ")
17917  nd_set_type(node, NODE_MATCH);
17918  }
17919  else if (node->nd_lit == Qtrue ||
17920  node->nd_lit == Qfalse) {
17921  /* booleans are OK, e.g., while true */
17922  }
17923  else {
17924  SWITCH_BY_COND_TYPE(type, warning, "")
17925  }
17926  default:
17927  break;
17928  }
17929  return node;
17930 }
17931 
17932 static NODE*
17933 cond(struct parser_params *p, NODE *node, const YYLTYPE *loc)
17934 {
17935  if (node == 0) return 0;
17936  return cond0(p, node, COND_IN_COND, loc);
17937 }
17938 
17939 static NODE*
17940 method_cond(struct parser_params *p, NODE *node, const YYLTYPE *loc)
17941 {
17942  if (node == 0) return 0;
17943  return cond0(p, node, COND_IN_OP, loc);
17944 }
17945 
17946 static NODE*
17947 new_if(struct parser_params *p, NODE *cc, NODE *left, NODE *right, const YYLTYPE *loc)
17948 {
17949  if (!cc) return right;
17950  cc = cond0(p, cc, COND_IN_COND, loc);
17951  return newline_node(NEW_IF(cc, left, right, loc));
17952 }
17953 
17954 static NODE*
17955 new_unless(struct parser_params *p, NODE *cc, NODE *left, NODE *right, const YYLTYPE *loc)
17956 {
17957  if (!cc) return right;
17958  cc = cond0(p, cc, COND_IN_COND, loc);
17959  return newline_node(NEW_UNLESS(cc, left, right, loc));
17960 }
17961 
17962 static NODE*
17963 logop(struct parser_params *p, ID id, NODE *left, NODE *right,
17964  const YYLTYPE *op_loc, const YYLTYPE *loc)
17965 {
17966  enum node_type type = id == idAND || id == idANDOP ? NODE_AND : NODE_OR;
17967  NODE *op;
17968  value_expr(left);
17969  if (left && (enum node_type)nd_type(left) == type) {
17970  NODE *node = left, *second;
17971  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
17972  node = second;
17973  }
17974  node->nd_2nd = NEW_NODE(type, second, right, 0, loc);
17975  nd_set_line(node->nd_2nd, op_loc->beg_pos.lineno);
17976  left->nd_loc.end_pos = loc->end_pos;
17977  return left;
17978  }
17979  op = NEW_NODE(type, left, right, 0, loc);
17980  nd_set_line(op, op_loc->beg_pos.lineno);
17981  return op;
17982 }
17983 
17984 static void
17985 no_blockarg(struct parser_params *p, NODE *node)
17986 {
17987  if (node && nd_type(node) == NODE_BLOCK_PASS) {
17988  compile_error(p, "block argument should not be given");
17989  }
17990 }
17991 
17992 static NODE *
17993 ret_args(struct parser_params *p, NODE *node)
17994 {
17995  if (node) {
17996  no_blockarg(p, node);
17997  if (nd_type(node) == NODE_LIST) {
17998  if (node->nd_next == 0) {
17999  node = node->nd_head;
18000  }
18001  else {
18002  nd_set_type(node, NODE_VALUES);
18003  }
18004  }
18005  }
18006  return node;
18007 }
18008 
18009 static NODE *
18010 new_yield(struct parser_params *p, NODE *node, const YYLTYPE *loc)
18011 {
18012  if (node) no_blockarg(p, node);
18013 
18014  return NEW_YIELD(node, loc);
18015 }
18016 
18017 static VALUE
18018 negate_lit(struct parser_params *p, VALUE lit)
18019 {
18020  if (FIXNUM_P(lit)) {
18021  return LONG2FIX(-FIX2LONG(lit));
18022  }
18023  if (SPECIAL_CONST_P(lit)) {
18024 #if USE_FLONUM
18025  if (FLONUM_P(lit)) {
18026  return DBL2NUM(-RFLOAT_VALUE(lit));
18027  }
18028 #endif
18029  goto unknown;
18030  }
18031  switch (BUILTIN_TYPE(lit)) {
18032  case T_BIGNUM:
18033  BIGNUM_NEGATE(lit);
18034  lit = rb_big_norm(lit);
18035  break;
18036  case T_RATIONAL:
18037  RRATIONAL_SET_NUM(lit, negate_lit(p, RRATIONAL(lit)->num));
18038  break;
18039  case T_COMPLEX:
18040  RCOMPLEX_SET_REAL(lit, negate_lit(p, RCOMPLEX(lit)->real));
18041  RCOMPLEX_SET_IMAG(lit, negate_lit(p, RCOMPLEX(lit)->imag));
18042  break;
18043  case T_FLOAT:
18044  RFLOAT(lit)->float_value = -RFLOAT_VALUE(lit);
18045  break;
18046  unknown:
18047  default:
18048  rb_parser_fatal(p, "unknown literal type (%s) passed to negate_lit",
18049  rb_builtin_class_name(lit));
18050  break;
18051  }
18052  return lit;
18053 }
18054 
18055 static NODE *
18056 arg_blk_pass(NODE *node1, NODE *node2)
18057 {
18058  if (node2) {
18059  if (!node1) return node2;
18060  node2->nd_head = node1;
18061  nd_set_first_lineno(node2, nd_first_lineno(node1));
18062  nd_set_first_column(node2, nd_first_column(node1));
18063  return node2;
18064  }
18065  return node1;
18066 }
18067 
18068 static bool
18069 args_info_empty_p(struct rb_args_info *args)
18070 {
18071  if (args->pre_args_num) return false;
18072  if (args->post_args_num) return false;
18073  if (args->rest_arg) return false;
18074  if (args->opt_args) return false;
18075  if (args->block_arg) return false;
18076  if (args->kw_args) return false;
18077  if (args->kw_rest_arg) return false;
18078  return true;
18079 }
18080 
18081 static NODE*
18082 new_args(struct parser_params *p, NODE *pre_args, NODE *opt_args, ID rest_arg, NODE *post_args, NODE *tail, const YYLTYPE *loc)
18083 {
18084  int saved_line = p->ruby_sourceline;
18085  struct rb_args_info *args = tail->nd_ainfo;
18086 
18087  args->pre_args_num = pre_args ? rb_long2int(pre_args->nd_plen) : 0;
18088  args->pre_init = pre_args ? pre_args->nd_next : 0;
18089 
18090  args->post_args_num = post_args ? rb_long2int(post_args->nd_plen) : 0;
18091  args->post_init = post_args ? post_args->nd_next : 0;
18092  args->first_post_arg = post_args ? post_args->nd_pid : 0;
18093 
18094  args->rest_arg = rest_arg;
18095 
18096  args->opt_args = opt_args;
18097 
18098  args->ruby2_keywords = rest_arg == idFWD_REST;
18099 
18100  p->ruby_sourceline = saved_line;
18101  nd_set_loc(tail, loc);
18102 
18103  return tail;
18104 }
18105 
18106 static NODE*
18107 new_args_tail(struct parser_params *p, NODE *kw_args, ID kw_rest_arg, ID block, const YYLTYPE *loc)
18108 {
18109  int saved_line = p->ruby_sourceline;
18110  NODE *node;
18112  struct rb_args_info *args = ZALLOC(struct rb_args_info);
18113  rb_imemo_tmpbuf_set_ptr(tmpbuf, args);
18114  args->imemo = tmpbuf;
18115  node = NEW_NODE(NODE_ARGS, 0, 0, args, &NULL_LOC);
18116  RB_OBJ_WRITTEN(p->ast, Qnil, tmpbuf);
18117  if (p->error_p) return node;
18118 
18119  args->block_arg = block;
18120  args->kw_args = kw_args;
18121 
18122  if (kw_args) {
18123  /*
18124  * def foo(k1: 1, kr1:, k2: 2, **krest, &b)
18125  * variable order: k1, kr1, k2, &b, internal_id, krest
18126  * #=> <reorder>
18127  * variable order: kr1, k1, k2, internal_id, krest, &b
18128  */
18129  ID kw_bits = internal_id(p), *required_kw_vars, *kw_vars;
18130  struct vtable *vtargs = p->lvtbl->args;
18131  NODE *kwn = kw_args;
18132 
18133  vtable_pop(vtargs, !!block + !!kw_rest_arg);
18134  required_kw_vars = kw_vars = &vtargs->tbl[vtargs->pos];
18135  while (kwn) {
18136  if (!NODE_REQUIRED_KEYWORD_P(kwn->nd_body))
18137  --kw_vars;
18138  --required_kw_vars;
18139  kwn = kwn->nd_next;
18140  }
18141 
18142  for (kwn = kw_args; kwn; kwn = kwn->nd_next) {
18143  ID vid = kwn->nd_body->nd_vid;
18144  if (NODE_REQUIRED_KEYWORD_P(kwn->nd_body)) {
18145  *required_kw_vars++ = vid;
18146  }
18147  else {
18148  *kw_vars++ = vid;
18149  }
18150  }
18151 
18152  arg_var(p, kw_bits);
18153  if (kw_rest_arg) arg_var(p, kw_rest_arg);
18154  if (block) arg_var(p, block);
18155 
18156  args->kw_rest_arg = NEW_DVAR(kw_rest_arg, loc);
18157  args->kw_rest_arg->nd_cflag = kw_bits;
18158  }
18159  else if (kw_rest_arg == idNil) {
18160  args->no_kwarg = 1;
18161  }
18162  else if (kw_rest_arg) {
18163  args->kw_rest_arg = NEW_DVAR(kw_rest_arg, loc);
18164  }
18165 
18166  p->ruby_sourceline = saved_line;
18167  return node;
18168 }
18169 
18170 static NODE *
18171 args_with_numbered(struct parser_params *p, NODE *args, int max_numparam)
18172 {
18173  if (max_numparam > NO_PARAM) {
18174  if (!args) {
18175  YYLTYPE loc = RUBY_INIT_YYLLOC();
18176  args = new_args_tail(p, 0, 0, 0, 0);
18177  nd_set_loc(args, &loc);
18178  }
18179  args->nd_ainfo->pre_args_num = max_numparam;
18180  }
18181  return args;
18182 }
18183 
18184 static NODE*
18185 new_array_pattern(struct parser_params *p, NODE *constant, NODE *pre_arg, NODE *aryptn, const YYLTYPE *loc)
18186 {
18187  struct rb_ary_pattern_info *apinfo = aryptn->nd_apinfo;
18188 
18189  aryptn->nd_pconst = constant;
18190 
18191  if (pre_arg) {
18192  NODE *pre_args = NEW_LIST(pre_arg, loc);
18193  if (apinfo->pre_args) {
18194  apinfo->pre_args = list_concat(pre_args, apinfo->pre_args);
18195  }
18196  else {
18197  apinfo->pre_args = pre_args;
18198  }
18199  }
18200  return aryptn;
18201 }
18202 
18203 static NODE*
18204 new_array_pattern_tail(struct parser_params *p, NODE *pre_args, int has_rest, ID rest_arg, NODE *post_args, const YYLTYPE *loc)
18205 {
18206  int saved_line = p->ruby_sourceline;
18207  NODE *node;
18209  struct rb_ary_pattern_info *apinfo = ZALLOC(struct rb_ary_pattern_info);
18210  rb_imemo_tmpbuf_set_ptr(tmpbuf, apinfo);
18211  node = NEW_NODE(NODE_ARYPTN, 0, 0, apinfo, loc);
18212  apinfo->imemo = tmpbuf;
18213  RB_OBJ_WRITTEN(p->ast, Qnil, tmpbuf);
18214 
18215  apinfo->pre_args = pre_args;
18216 
18217  if (has_rest) {
18218  if (rest_arg) {
18219  apinfo->rest_arg = assignable(p, rest_arg, 0, loc);
18220  }
18221  else {
18223  }
18224  }
18225  else {
18226  apinfo->rest_arg = NULL;
18227  }
18228 
18229  apinfo->post_args = post_args;
18230 
18231  p->ruby_sourceline = saved_line;
18232  return node;
18233 }
18234 
18235 static NODE*
18236 new_hash_pattern(struct parser_params *p, NODE *constant, NODE *hshptn, const YYLTYPE *loc)
18237 {
18238  hshptn->nd_pconst = constant;
18239  return hshptn;
18240 }
18241 
18242 static NODE*
18243 new_hash_pattern_tail(struct parser_params *p, NODE *kw_args, ID kw_rest_arg, const YYLTYPE *loc)
18244 {
18245  int saved_line = p->ruby_sourceline;
18246  NODE *node, *kw_rest_arg_node;
18247 
18248  if (kw_rest_arg == idNil) {
18249  kw_rest_arg_node = NODE_SPECIAL_NO_REST_KEYWORD;
18250  }
18251  else if (kw_rest_arg) {
18252  kw_rest_arg_node = assignable(p, kw_rest_arg, 0, loc);
18253  }
18254  else {
18255  kw_rest_arg_node = NULL;
18256  }
18257 
18258  node = NEW_NODE(NODE_HSHPTN, 0, kw_args, kw_rest_arg_node, loc);
18259 
18260  p->ruby_sourceline = saved_line;
18261  return node;
18262 }
18263 
18264 static NODE *
18265 new_case3(struct parser_params *p, NODE *val, NODE *pat, const YYLTYPE *loc)
18266 {
18267  NODE *node = NEW_CASE3(val, pat, loc);
18268 
18270  rb_warn0L(nd_line(node), "Pattern matching is experimental, and the behavior may change in future versions of Ruby!");
18271  return node;
18272 }
18273 
18274 static NODE*
18275 dsym_node(struct parser_params *p, NODE *node, const YYLTYPE *loc)
18276 {
18277  VALUE lit;
18278 
18279  if (!node) {
18280  return NEW_LIT(ID2SYM(idNULL), loc);
18281  }
18282 
18283  switch (nd_type(node)) {
18284  case NODE_DSTR:
18285  nd_set_type(node, NODE_DSYM);
18286  nd_set_loc(node, loc);
18287  break;
18288  case NODE_STR:
18289  lit = node->nd_lit;
18290  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit = ID2SYM(rb_intern_str(lit)));
18291  nd_set_type(node, NODE_LIT);
18292  nd_set_loc(node, loc);
18293  break;
18294  default:
18295  node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node, loc), loc);
18296  break;
18297  }
18298  return node;
18299 }
18300 
18301 static int
18302 append_literal_keys(st_data_t k, st_data_t v, st_data_t h)
18303 {
18304  NODE *node = (NODE *)v;
18305  NODE **result = (NODE **)h;
18306  node->nd_alen = 2;
18307  node->nd_next->nd_end = node->nd_next;
18308  node->nd_next->nd_next = 0;
18309  if (*result)
18310  list_concat(*result, node);
18311  else
18312  *result = node;
18313  return ST_CONTINUE;
18314 }
18315 
18316 static NODE *
18317 remove_duplicate_keys(struct parser_params *p, NODE *hash)
18318 {
18319  st_table *literal_keys = st_init_numtable_with_size(hash->nd_alen / 2);
18320  NODE *result = 0;
18321  rb_code_location_t loc = hash->nd_loc;
18322  while (hash && hash->nd_head && hash->nd_next) {
18323  NODE *head = hash->nd_head;
18324  NODE *value = hash->nd_next;
18325  NODE *next = value->nd_next;
18326  VALUE key = (VALUE)head;
18327  st_data_t data;
18328  if (nd_type(head) == NODE_LIT &&
18329  st_lookup(literal_keys, (key = head->nd_lit), &data)) {
18331  "key %+"PRIsVALUE" is duplicated and overwritten on line %d",
18332  head->nd_lit, nd_line(head));
18333  head = ((NODE *)data)->nd_next;
18334  head->nd_head = block_append(p, head->nd_head, value->nd_head);
18335  }
18336  else {
18337  st_insert(literal_keys, (st_data_t)key, (st_data_t)hash);
18338  }
18339  hash = next;
18340  }
18341  st_foreach(literal_keys, append_literal_keys, (st_data_t)&result);
18342  st_free_table(literal_keys);
18343  if (hash) {
18344  if (!result) result = hash;
18345  else list_concat(result, hash);
18346  }
18347  result->nd_loc = loc;
18348  return result;
18349 }
18350 
18351 static NODE *
18352 new_hash(struct parser_params *p, NODE *hash, const YYLTYPE *loc)
18353 {
18354  if (hash) hash = remove_duplicate_keys(p, hash);
18355  return NEW_HASH(hash, loc);
18356 }
18357 #endif
18358 
18359 static void
18360 error_duplicate_pattern_variable(struct parser_params *p, ID id, const YYLTYPE *loc)
18361 {
18362  if (is_private_local_id(id)) {
18363  return;
18364  }
18365  if (st_is_member(p->pvtbl, id)) {
18366  yyerror1(loc, "duplicated variable name");
18367  }
18368  else {
18369  st_insert(p->pvtbl, (st_data_t)id, 0);
18370  }
18371 }
18372 
18373 static void
18374 error_duplicate_pattern_key(struct parser_params *p, VALUE key, const YYLTYPE *loc)
18375 {
18376  if (!p->pktbl) {
18377  p->pktbl = st_init_numtable();
18378  }
18379  else if (st_is_member(p->pktbl, key)) {
18380  yyerror1(loc, "duplicated key name");
18381  return;
18382  }
18383  st_insert(p->pktbl, (st_data_t)key, 0);
18384 }
18385 
18386 #ifndef RIPPER
18387 static NODE *
18388 new_unique_key_hash(struct parser_params *p, NODE *hash, const YYLTYPE *loc)
18389 {
18390  return NEW_HASH(hash, loc);
18391 }
18392 #endif /* !RIPPER */
18393 
18394 #ifndef RIPPER
18395 static NODE *
18396 new_op_assign(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *loc)
18397 {
18398  NODE *asgn;
18399 
18400  if (lhs) {
18401  ID vid = lhs->nd_vid;
18402  YYLTYPE lhs_loc = lhs->nd_loc;
18403  if (op == tOROP) {
18404  lhs->nd_value = rhs;
18405  nd_set_loc(lhs, loc);
18406  asgn = NEW_OP_ASGN_OR(gettable(p, vid, &lhs_loc), lhs, loc);
18407  if (is_notop_id(vid)) {
18408  switch (id_type(vid)) {
18409  case ID_GLOBAL:
18410  case ID_INSTANCE:
18411  case ID_CLASS:
18412  asgn->nd_aid = vid;
18413  }
18414  }
18415  }
18416  else if (op == tANDOP) {
18417  lhs->nd_value = rhs;
18418  nd_set_loc(lhs, loc);
18419  asgn = NEW_OP_ASGN_AND(gettable(p, vid, &lhs_loc), lhs, loc);
18420  }
18421  else {
18422  asgn = lhs;
18423  asgn->nd_value = NEW_CALL(gettable(p, vid, &lhs_loc), op, NEW_LIST(rhs, &rhs->nd_loc), loc);
18424  nd_set_loc(asgn, loc);
18425  }
18426  }
18427  else {
18428  asgn = NEW_BEGIN(0, loc);
18429  }
18430  return asgn;
18431 }
18432 
18433 static NODE *
18434 new_ary_op_assign(struct parser_params *p, NODE *ary,
18435  NODE *args, ID op, NODE *rhs, const YYLTYPE *args_loc, const YYLTYPE *loc)
18436 {
18437  NODE *asgn;
18438 
18439  args = make_list(args, args_loc);
18440  if (nd_type(args) == NODE_BLOCK_PASS) {
18441  args = NEW_ARGSCAT(args, rhs, loc);
18442  }
18443  else {
18444  args = arg_concat(p, args, rhs, loc);
18445  }
18446  asgn = NEW_OP_ASGN1(ary, op, args, loc);
18447  fixpos(asgn, ary);
18448  return asgn;
18449 }
18450 
18451 static NODE *
18452 new_attr_op_assign(struct parser_params *p, NODE *lhs,
18453  ID atype, ID attr, ID op, NODE *rhs, const YYLTYPE *loc)
18454 {
18455  NODE *asgn;
18456 
18457  asgn = NEW_OP_ASGN2(lhs, CALL_Q_P(atype), attr, op, rhs, loc);
18458  fixpos(asgn, lhs);
18459  return asgn;
18460 }
18461 
18462 static NODE *
18463 new_const_op_assign(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *loc)
18464 {
18465  NODE *asgn;
18466 
18467  if (lhs) {
18468  asgn = NEW_OP_CDECL(lhs, op, rhs, loc);
18469  }
18470  else {
18471  asgn = NEW_BEGIN(0, loc);
18472  }
18473  fixpos(asgn, lhs);
18474  return asgn;
18475 }
18476 
18477 static NODE *
18478 const_decl(struct parser_params *p, NODE *path, const YYLTYPE *loc)
18479 {
18480  if (p->in_def) {
18481  yyerror1(loc, "dynamic constant assignment");
18482  }
18483  return NEW_CDECL(0, 0, (path), loc);
18484 }
18485 #else
18486 static VALUE
18487 const_decl(struct parser_params *p, VALUE path)
18488 {
18489  if (p->in_def) {
18490  path = dispatch1(assign_error, path);
18491  ripper_error(p);
18492  }
18493  return path;
18494 }
18495 
18496 static VALUE
18497 assign_error(struct parser_params *p, VALUE a)
18498 {
18499  a = dispatch1(assign_error, a);
18500  ripper_error(p);
18501  return a;
18502 }
18503 
18504 static VALUE
18505 var_field(struct parser_params *p, VALUE a)
18506 {
18507  return ripper_new_yylval(p, get_id(a), dispatch1(var_field, a), 0);
18508 }
18509 #endif
18510 
18511 #ifndef RIPPER
18512 static NODE *
18513 new_bodystmt(struct parser_params *p, NODE *head, NODE *rescue, NODE *rescue_else, NODE *ensure, const YYLTYPE *loc)
18514 {
18515  NODE *result = head;
18516  if (rescue) {
18517  NODE *tmp = rescue_else ? rescue_else : rescue;
18518  YYLTYPE rescue_loc = code_loc_gen(&head->nd_loc, &tmp->nd_loc);
18519 
18520  result = NEW_RESCUE(head, rescue, rescue_else, &rescue_loc);
18521  nd_set_line(result, rescue->nd_loc.beg_pos.lineno);
18522  }
18523  else if (rescue_else) {
18524  result = block_append(p, result, rescue_else);
18525  }
18526  if (ensure) {
18527  result = NEW_ENSURE(result, ensure, loc);
18528  }
18529  fixpos(result, head);
18530  return result;
18531 }
18532 #endif
18533 
18534 static void
18535 warn_unused_var(struct parser_params *p, struct local_vars *local)
18536 {
18537  int cnt;
18538 
18539  if (!local->used) return;
18540  cnt = local->used->pos;
18541  if (cnt != local->vars->pos) {
18542  rb_parser_fatal(p, "local->used->pos != local->vars->pos");
18543  }
18544 #ifndef RIPPER
18545  ID *v = local->vars->tbl;
18546  ID *u = local->used->tbl;
18547  for (int i = 0; i < cnt; ++i) {
18548  if (!v[i] || (u[i] & LVAR_USED)) continue;
18549  if (is_private_local_id(v[i])) continue;
18550  rb_warn1L((int)u[i], "assigned but unused variable - %"PRIsWARN, rb_id2str(v[i]));
18551  }
18552 #endif
18553 }
18554 
18555 static void
18556 local_push(struct parser_params *p, int toplevel_scope)
18557 {
18558  struct local_vars *local;
18559  int inherits_dvars = toplevel_scope && compile_for_eval;
18560  int warn_unused_vars = RTEST(ruby_verbose);
18561 
18562  local = ALLOC(struct local_vars);
18563  local->prev = p->lvtbl;
18564  local->args = vtable_alloc(0);
18565  local->vars = vtable_alloc(inherits_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
18566 #ifndef RIPPER
18567  if (toplevel_scope && compile_for_eval) warn_unused_vars = 0;
18568  if (toplevel_scope && e_option_supplied(p)) warn_unused_vars = 0;
18569  local->numparam.outer = 0;
18570  local->numparam.inner = 0;
18571  local->numparam.current = 0;
18572 #endif
18573  local->used = warn_unused_vars ? vtable_alloc(0) : 0;
18574 
18575 # if WARN_PAST_SCOPE
18576  local->past = 0;
18577 # endif
18578  CMDARG_PUSH(0);
18579  COND_PUSH(0);
18580  p->lvtbl = local;
18581 }
18582 
18583 static void
18584 local_pop(struct parser_params *p)
18585 {
18586  struct local_vars *local = p->lvtbl->prev;
18587  if (p->lvtbl->used) {
18588  warn_unused_var(p, p->lvtbl);
18589  vtable_free(p->lvtbl->used);
18590  }
18591 # if WARN_PAST_SCOPE
18592  while (p->lvtbl->past) {
18593  struct vtable *past = p->lvtbl->past;
18594  p->lvtbl->past = past->prev;
18595  vtable_free(past);
18596  }
18597 # endif
18598  vtable_free(p->lvtbl->args);
18599  vtable_free(p->lvtbl->vars);
18600  CMDARG_POP();
18601  COND_POP();
18602  ruby_sized_xfree(p->lvtbl, sizeof(*p->lvtbl));
18603  p->lvtbl = local;
18604 }
18605 
18606 #ifndef RIPPER
18607 static ID*
18608 local_tbl(struct parser_params *p)
18609 {
18610  int cnt_args = vtable_size(p->lvtbl->args);
18611  int cnt_vars = vtable_size(p->lvtbl->vars);
18612  int cnt = cnt_args + cnt_vars;
18613  int i, j;
18614  ID *buf;
18615 
18616  if (cnt <= 0) return 0;
18617  buf = ALLOC_N(ID, cnt + 2);
18618  MEMCPY(buf+1, p->lvtbl->args->tbl, ID, cnt_args);
18619  /* remove IDs duplicated to warn shadowing */
18620  for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
18621  ID id = p->lvtbl->vars->tbl[i];
18622  if (!vtable_included(p->lvtbl->args, id)) {
18623  buf[j++] = id;
18624  }
18625  }
18626  if (--j < cnt) {
18627  REALLOC_N(buf, ID, (cnt = j) + 2);
18628  }
18629  buf[0] = cnt;
18631 
18632  return buf;
18633 }
18634 
18635 static NODE*
18636 node_newnode_with_locals(struct parser_params *p, enum node_type type, VALUE a1, VALUE a2, const rb_code_location_t *loc)
18637 {
18638  ID *a0;
18639  NODE *n;
18640 
18641  a0 = local_tbl(p);
18642  n = NEW_NODE(type, a0, a1, a2, loc);
18643  return n;
18644 }
18645 
18646 #endif
18647 
18648 static void
18649 numparam_name(struct parser_params *p, ID id)
18650 {
18651  if (!NUMPARAM_ID_P(id)) return;
18652  rb_warn1("`_%d' is reserved for numbered parameter; consider another name",
18653  WARN_I(NUMPARAM_ID_TO_IDX(id)));
18654 }
18655 
18656 static void
18657 arg_var(struct parser_params *p, ID id)
18658 {
18659  numparam_name(p, id);
18660  vtable_add(p->lvtbl->args, id);
18661 }
18662 
18663 static void
18664 local_var(struct parser_params *p, ID id)
18665 {
18666  numparam_name(p, id);
18667  vtable_add(p->lvtbl->vars, id);
18668  if (p->lvtbl->used) {
18670  }
18671 }
18672 
18673 static int
18674 local_id_ref(struct parser_params *p, ID id, ID **vidrefp)
18675 {
18676  struct vtable *vars, *args, *used;
18677 
18678  vars = p->lvtbl->vars;
18679  args = p->lvtbl->args;
18680  used = p->lvtbl->used;
18681 
18682  while (vars && !DVARS_TERMINAL_P(vars->prev)) {
18683  vars = vars->prev;
18684  args = args->prev;
18685  if (used) used = used->prev;
18686  }
18687 
18688  if (vars && vars->prev == DVARS_INHERIT) {
18689  return rb_local_defined(id, p->parent_iseq);
18690  }
18691  else if (vtable_included(args, id)) {
18692  return 1;
18693  }
18694  else {
18695  int i = vtable_included(vars, id);
18696  if (i && used && vidrefp) *vidrefp = &used->tbl[i-1];
18697  return i != 0;
18698  }
18699 }
18700 
18701 static int
18702 local_id(struct parser_params *p, ID id)
18703 {
18704  return local_id_ref(p, id, NULL);
18705 }
18706 
18707 static NODE *
18708 numparam_push(struct parser_params *p)
18709 {
18710 #ifndef RIPPER
18711  struct local_vars *local = p->lvtbl;
18712  NODE *inner = local->numparam.inner;
18713  if (!local->numparam.outer) {
18714  local->numparam.outer = local->numparam.current;
18715  }
18716  local->numparam.inner = 0;
18717  local->numparam.current = 0;
18718  return inner;
18719 #else
18720  return 0;
18721 #endif
18722 }
18723 
18724 static void
18725 numparam_pop(struct parser_params *p, NODE *prev_inner)
18726 {
18727 #ifndef RIPPER
18728  struct local_vars *local = p->lvtbl;
18729  if (prev_inner) {
18730  /* prefer first one */
18731  local->numparam.inner = prev_inner;
18732  }
18733  else if (local->numparam.current) {
18734  /* current and inner are exclusive */
18735  local->numparam.inner = local->numparam.current;
18736  }
18737  if (p->max_numparam > NO_PARAM) {
18738  /* current and outer are exclusive */
18739  local->numparam.current = local->numparam.outer;
18740  local->numparam.outer = 0;
18741  }
18742  else {
18743  /* no numbered parameter */
18744  local->numparam.current = 0;
18745  }
18746 #endif
18747 }
18748 
18749 static const struct vtable *
18750 dyna_push(struct parser_params *p)
18751 {
18752  p->lvtbl->args = vtable_alloc(p->lvtbl->args);
18753  p->lvtbl->vars = vtable_alloc(p->lvtbl->vars);
18754  if (p->lvtbl->used) {
18755  p->lvtbl->used = vtable_alloc(p->lvtbl->used);
18756  }
18757  return p->lvtbl->args;
18758 }
18759 
18760 static void
18761 dyna_pop_vtable(struct parser_params *p, struct vtable **vtblp)
18762 {
18763  struct vtable *tmp = *vtblp;
18764  *vtblp = tmp->prev;
18765 # if WARN_PAST_SCOPE
18766  if (p->past_scope_enabled) {
18767  tmp->prev = p->lvtbl->past;
18768  p->lvtbl->past = tmp;
18769  return;
18770  }
18771 # endif
18772  vtable_free(tmp);
18773 }
18774 
18775 static void
18776 dyna_pop_1(struct parser_params *p)
18777 {
18778  struct vtable *tmp;
18779 
18780  if ((tmp = p->lvtbl->used) != 0) {
18781  warn_unused_var(p, p->lvtbl);
18782  p->lvtbl->used = p->lvtbl->used->prev;
18783  vtable_free(tmp);
18784  }
18785  dyna_pop_vtable(p, &p->lvtbl->args);
18786  dyna_pop_vtable(p, &p->lvtbl->vars);
18787 }
18788 
18789 static void
18790 dyna_pop(struct parser_params *p, const struct vtable *lvargs)
18791 {
18792  while (p->lvtbl->args != lvargs) {
18793  dyna_pop_1(p);
18794  if (!p->lvtbl->args) {
18795  struct local_vars *local = p->lvtbl->prev;
18796  ruby_sized_xfree(p->lvtbl, sizeof(*p->lvtbl));
18797  p->lvtbl = local;
18798  }
18799  }
18800  dyna_pop_1(p);
18801 }
18802 
18803 static int
18804 dyna_in_block(struct parser_params *p)
18805 {
18806  return !DVARS_TERMINAL_P(p->lvtbl->vars) && p->lvtbl->vars->prev != DVARS_TOPSCOPE;
18807 }
18808 
18809 static int
18810 dvar_defined_ref(struct parser_params *p, ID id, ID **vidrefp)
18811 {
18812  struct vtable *vars, *args, *used;
18813  int i;
18814 
18815  args = p->lvtbl->args;
18816  vars = p->lvtbl->vars;
18817  used = p->lvtbl->used;
18818 
18819  while (!DVARS_TERMINAL_P(vars)) {
18820  if (vtable_included(args, id)) {
18821  return 1;
18822  }
18823  if ((i = vtable_included(vars, id)) != 0) {
18824  if (used && vidrefp) *vidrefp = &used->tbl[i-1];
18825  return 1;
18826  }
18827  args = args->prev;
18828  vars = vars->prev;
18829  if (!vidrefp) used = 0;
18830  if (used) used = used->prev;
18831  }
18832 
18833  if (vars == DVARS_INHERIT) {
18834  return rb_dvar_defined(id, p->parent_iseq);
18835  }
18836 
18837  return 0;
18838 }
18839 
18840 static int
18841 dvar_defined(struct parser_params *p, ID id)
18842 {
18843  return dvar_defined_ref(p, id, NULL);
18844 }
18845 
18846 static int
18847 dvar_curr(struct parser_params *p, ID id)
18848 {
18849  return (vtable_included(p->lvtbl->args, id) ||
18850  vtable_included(p->lvtbl->vars, id));
18851 }
18852 
18853 static void
18854 reg_fragment_enc_error(struct parser_params* p, VALUE str, int c)
18855 {
18856  compile_error(p,
18857  "regexp encoding option '%c' differs from source encoding '%s'",
18858  c, rb_enc_name(rb_enc_get(str)));
18859 }
18860 
18861 #ifndef RIPPER
18862 int
18864 {
18865  int c = RE_OPTION_ENCODING_IDX(options);
18866 
18867  if (c) {
18868  int opt, idx;
18869  rb_char_to_option_kcode(c, &opt, &idx);
18870  if (idx != ENCODING_GET(str) &&
18872  goto error;
18873  }
18874  ENCODING_SET(str, idx);
18875  }
18876  else if (RE_OPTION_ENCODING_NONE(options)) {
18877  if (!ENCODING_IS_ASCII8BIT(str) &&
18879  c = 'n';
18880  goto error;
18881  }
18883  }
18884  else if (p->enc == rb_usascii_encoding()) {
18886  /* raise in re.c */
18888  }
18889  else {
18891  }
18892  }
18893  return 0;
18894 
18895  error:
18896  return c;
18897 }
18898 
18899 static void
18900 reg_fragment_setenc(struct parser_params* p, VALUE str, int options)
18901 {
18902  int c = rb_reg_fragment_setenc(p, str, options);
18903  if (c) reg_fragment_enc_error(p, str, c);
18904 }
18905 
18906 static int
18907 reg_fragment_check(struct parser_params* p, VALUE str, int options)
18908 {
18909  VALUE err;
18910  reg_fragment_setenc(p, str, options);
18912  if (err != Qnil) {
18914  compile_error(p, "%"PRIsVALUE, err);
18915  return 0;
18916  }
18917  return 1;
18918 }
18919 
18920 typedef struct {
18924  const YYLTYPE *loc;
18926 
18927 static int
18928 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
18929  int back_num, int *back_refs, OnigRegex regex, void *arg0)
18930 {
18932  struct parser_params* p = arg->parser;
18933  rb_encoding *enc = arg->enc;
18934  long len = name_end - name;
18935  const char *s = (const char *)name;
18936  ID var;
18937  NODE *node, *succ;
18938 
18939  if (!len) return ST_CONTINUE;
18940  if (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len))
18941  return ST_CONTINUE;
18942  if (rb_enc_symname_type(s, len, enc, (1U<<ID_LOCAL)) != ID_LOCAL)
18943  return ST_CONTINUE;
18944 
18945  var = intern_cstr(s, len, enc);
18946  node = node_assign(p, assignable(p, var, 0, arg->loc), NEW_LIT(ID2SYM(var), arg->loc), arg->loc);
18947  succ = arg->succ_block;
18948  if (!succ) succ = NEW_BEGIN(0, arg->loc);
18949  succ = block_append(p, succ, node);
18950  arg->succ_block = succ;
18951  return ST_CONTINUE;
18952 }
18953 
18954 static NODE *
18955 reg_named_capture_assign(struct parser_params* p, VALUE regexp, const YYLTYPE *loc)
18956 {
18958 
18959  arg.parser = p;
18960  arg.enc = rb_enc_get(regexp);
18961  arg.succ_block = 0;
18962  arg.loc = loc;
18963  onig_foreach_name(RREGEXP_PTR(regexp), reg_named_capture_assign_iter, &arg);
18964 
18965  if (!arg.succ_block) return 0;
18966  return arg.succ_block->nd_next;
18967 }
18968 
18969 static VALUE
18970 parser_reg_compile(struct parser_params* p, VALUE str, int options)
18971 {
18972  reg_fragment_setenc(p, str, options);
18973  return rb_parser_reg_compile(p, str, options);
18974 }
18975 
18976 VALUE
18978 {
18980 }
18981 
18982 static VALUE
18983 reg_compile(struct parser_params* p, VALUE str, int options)
18984 {
18985  VALUE re;
18986  VALUE err;
18987 
18988  err = rb_errinfo();
18989  re = parser_reg_compile(p, str, options);
18990  if (NIL_P(re)) {
18993  compile_error(p, "%"PRIsVALUE, m);
18994  return Qnil;
18995  }
18996  return re;
18997 }
18998 #else
18999 static VALUE
19000 parser_reg_compile(struct parser_params* p, VALUE str, int options, VALUE *errmsg)
19001 {
19002  VALUE err = rb_errinfo();
19003  VALUE re;
19004  str = ripper_is_node_yylval(str) ? RNODE(str)->nd_cval : str;
19005  int c = rb_reg_fragment_setenc(p, str, options);
19006  if (c) reg_fragment_enc_error(p, str, c);
19007  re = rb_parser_reg_compile(p, str, options);
19008  if (NIL_P(re)) {
19009  *errmsg = rb_attr_get(rb_errinfo(), idMesg);
19011  }
19012  return re;
19013 }
19014 #endif
19015 
19016 #ifndef RIPPER
19017 void
19018 rb_parser_set_options(VALUE vparser, int print, int loop, int chomp, int split)
19019 {
19020  struct parser_params *p;
19021  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19022  p->do_print = print;
19023  p->do_loop = loop;
19024  p->do_chomp = chomp;
19025  p->do_split = split;
19026 }
19027 
19028 void
19029 rb_parser_warn_location(VALUE vparser, int warn)
19030 {
19031  struct parser_params *p;
19032  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19033  p->warn_location = warn;
19034 }
19035 
19036 static NODE *
19037 parser_append_options(struct parser_params *p, NODE *node)
19038 {
19039  static const YYLTYPE default_location = {{1, 0}, {1, 0}};
19040  const YYLTYPE *const LOC = &default_location;
19041 
19042  if (p->do_print) {
19043  NODE *print = NEW_FCALL(rb_intern("print"),
19044  NEW_LIST(NEW_GVAR(idLASTLINE, LOC), LOC),
19045  LOC);
19046  node = block_append(p, node, print);
19047  }
19048 
19049  if (p->do_loop) {
19050  if (p->do_split) {
19051  NODE *args = NEW_LIST(NEW_GVAR(rb_intern("$;"), LOC), LOC);
19052  NODE *split = NEW_GASGN(rb_intern("$F"),
19054  rb_intern("split"), args, LOC),
19055  LOC);
19056  node = block_append(p, split, node);
19057  }
19058  if (p->do_chomp) {
19059  NODE *chomp = NEW_CALL(NEW_GVAR(idLASTLINE, LOC),
19060  rb_intern("chomp!"), 0, LOC);
19061  node = block_append(p, chomp, node);
19062  }
19063 
19064  node = NEW_WHILE(NEW_VCALL(idGets, LOC), node, 1, LOC);
19065  }
19066 
19067  return node;
19068 }
19069 
19070 void
19072 {
19073  /* just to suppress unused-function warnings */
19074  (void)nodetype;
19075  (void)nodeline;
19076 }
19077 
19078 static ID
19079 internal_id(struct parser_params *p)
19080 {
19081  const ID max_id = RB_ID_SERIAL_MAX & ~0xffff;
19082  ID id = (ID)vtable_size(p->lvtbl->args) + (ID)vtable_size(p->lvtbl->vars);
19083  id = max_id - id;
19084  return ID_STATIC_SYM | ID_INTERNAL | (id << ID_SCOPE_SHIFT);
19085 }
19086 #endif /* !RIPPER */
19087 
19088 static void
19089 parser_initialize(struct parser_params *p)
19090 {
19091  /* note: we rely on TypedData_Make_Struct to set most fields to 0 */
19092  p->command_start = TRUE;
19094  p->lex.lpar_beg = -1; /* make lambda_beginning_p() == FALSE at first */
19095  p->node_id = 0;
19096 #ifdef RIPPER
19097  p->delayed.token = Qnil;
19098  p->result = Qnil;
19099  p->parsing_thread = Qnil;
19100 #else
19101  p->error_buffer = Qfalse;
19102 #endif
19103  p->debug_buffer = Qnil;
19104  p->debug_output = rb_stdout;
19105  p->enc = rb_utf8_encoding();
19106 }
19107 
19108 #ifdef RIPPER
19109 #define parser_mark ripper_parser_mark
19110 #define parser_free ripper_parser_free
19111 #endif
19112 
19113 static void
19114 parser_mark(void *ptr)
19115 {
19116  struct parser_params *p = (struct parser_params*)ptr;
19117 
19118  rb_gc_mark(p->lex.input);
19119  rb_gc_mark(p->lex.prevline);
19120  rb_gc_mark(p->lex.lastline);
19121  rb_gc_mark(p->lex.nextline);
19123  rb_gc_mark((VALUE)p->lex.strterm);
19124  rb_gc_mark((VALUE)p->ast);
19125  rb_gc_mark(p->case_labels);
19126 #ifndef RIPPER
19127  rb_gc_mark(p->debug_lines);
19130 #else
19131  rb_gc_mark(p->delayed.token);
19132  rb_gc_mark(p->value);
19133  rb_gc_mark(p->result);
19134  rb_gc_mark(p->parsing_thread);
19135 #endif
19138 #ifdef YYMALLOC
19139  rb_gc_mark((VALUE)p->heap);
19140 #endif
19141 }
19142 
19143 static void
19144 parser_free(void *ptr)
19145 {
19146  struct parser_params *p = (struct parser_params*)ptr;
19147  struct local_vars *local, *prev;
19148 
19149  if (p->tokenbuf) {
19151  }
19152  for (local = p->lvtbl; local; local = prev) {
19153  if (local->vars) xfree(local->vars);
19154  prev = local->prev;
19155  xfree(local);
19156  }
19157  {
19158  token_info *ptinfo;
19159  while ((ptinfo = p->token_info) != 0) {
19160  p->token_info = ptinfo->next;
19161  xfree(ptinfo);
19162  }
19163  }
19164  xfree(ptr);
19165 }
19166 
19167 static size_t
19168 parser_memsize(const void *ptr)
19169 {
19170  struct parser_params *p = (struct parser_params*)ptr;
19171  struct local_vars *local;
19172  size_t size = sizeof(*p);
19173 
19174  size += p->toksiz;
19175  for (local = p->lvtbl; local; local = local->prev) {
19176  size += sizeof(*local);
19177  if (local->vars) size += local->vars->capa * sizeof(ID);
19178  }
19179  return size;
19180 }
19181 
19182 static const rb_data_type_t parser_data_type = {
19183 #ifndef RIPPER
19184  "parser",
19185 #else
19186  "ripper",
19187 #endif
19188  {
19189  parser_mark,
19190  parser_free,
19191  parser_memsize,
19192  },
19194 };
19195 
19196 #ifndef RIPPER
19197 #undef rb_reserved_word
19198 
19199 const struct kwtable *
19200 rb_reserved_word(const char *str, unsigned int len)
19201 {
19202  return reserved_word(str, len);
19203 }
19204 
19205 VALUE
19207 {
19208  struct parser_params *p;
19209  VALUE parser = TypedData_Make_Struct(0, struct parser_params,
19210  &parser_data_type, p);
19211  parser_initialize(p);
19212  return parser;
19213 }
19214 
19215 VALUE
19216 rb_parser_set_context(VALUE vparser, const struct rb_iseq_struct *base, int main)
19217 {
19218  struct parser_params *p;
19219 
19220  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19221  p->error_buffer = main ? Qfalse : Qnil;
19222  p->parent_iseq = base;
19223  return vparser;
19224 }
19225 #endif
19226 
19227 #ifdef RIPPER
19228 #define rb_parser_end_seen_p ripper_parser_end_seen_p
19229 #define rb_parser_encoding ripper_parser_encoding
19230 #define rb_parser_get_yydebug ripper_parser_get_yydebug
19231 #define rb_parser_set_yydebug ripper_parser_set_yydebug
19232 #define rb_parser_get_debug_output ripper_parser_get_debug_output
19233 #define rb_parser_set_debug_output ripper_parser_set_debug_output
19234 static VALUE ripper_parser_end_seen_p(VALUE vparser);
19235 static VALUE ripper_parser_encoding(VALUE vparser);
19236 static VALUE ripper_parser_get_yydebug(VALUE self);
19237 static VALUE ripper_parser_set_yydebug(VALUE self, VALUE flag);
19238 static VALUE ripper_parser_get_debug_output(VALUE self);
19239 static VALUE ripper_parser_set_debug_output(VALUE self, VALUE output);
19240 
19241 /*
19242  * call-seq:
19243  * ripper.error? -> Boolean
19244  *
19245  * Return true if parsed source has errors.
19246  */
19247 static VALUE
19248 ripper_error_p(VALUE vparser)
19249 {
19250  struct parser_params *p;
19251 
19252  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19253  return p->error_p ? Qtrue : Qfalse;
19254 }
19255 #endif
19256 
19257 /*
19258  * call-seq:
19259  * ripper.end_seen? -> Boolean
19260  *
19261  * Return true if parsed source ended by +\_\_END\_\_+.
19262  */
19263 VALUE
19265 {
19266  struct parser_params *p;
19267 
19268  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19269  return p->ruby__end__seen ? Qtrue : Qfalse;
19270 }
19271 
19272 /*
19273  * call-seq:
19274  * ripper.encoding -> encoding
19275  *
19276  * Return encoding of the source.
19277  */
19278 VALUE
19280 {
19281  struct parser_params *p;
19282 
19283  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19284  return rb_enc_from_encoding(p->enc);
19285 }
19286 
19287 #ifdef RIPPER
19288 /*
19289  * call-seq:
19290  * ripper.yydebug -> true or false
19291  *
19292  * Get yydebug.
19293  */
19294 VALUE
19295 rb_parser_get_yydebug(VALUE self)
19296 {
19297  struct parser_params *p;
19298 
19299  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19300  return p->debug ? Qtrue : Qfalse;
19301 }
19302 #endif
19303 
19304 /*
19305  * call-seq:
19306  * ripper.yydebug = flag
19307  *
19308  * Set yydebug.
19309  */
19310 VALUE
19312 {
19313  struct parser_params *p;
19314 
19315  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19316  p->debug = RTEST(flag);
19317  return flag;
19318 }
19319 
19320 /*
19321  * call-seq:
19322  * ripper.debug_output -> obj
19323  *
19324  * Get debug output.
19325  */
19326 VALUE
19328 {
19329  struct parser_params *p;
19330 
19331  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19332  return p->debug_output;
19333 }
19334 
19335 /*
19336  * call-seq:
19337  * ripper.debug_output = obj
19338  *
19339  * Set debug output.
19340  */
19341 VALUE
19343 {
19344  struct parser_params *p;
19345 
19346  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19347  return p->debug_output = output;
19348 }
19349 
19350 #ifndef RIPPER
19351 #ifdef YYMALLOC
19352 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
19353 /* Keep the order; NEWHEAP then xmalloc and ADD2HEAP to get rid of
19354  * potential memory leak */
19355 #define NEWHEAP() rb_imemo_tmpbuf_parser_heap(0, p->heap, 0)
19356 #define ADD2HEAP(new, cnt, ptr) ((p->heap = (new))->ptr = (ptr), \
19357  (new)->cnt = (cnt), (ptr))
19358 
19359 void *
19361 {
19362  size_t cnt = HEAPCNT(1, size);
19364  void *ptr = xmalloc(size);
19365 
19366  return ADD2HEAP(n, cnt, ptr);
19367 }
19368 
19369 void *
19370 rb_parser_calloc(struct parser_params *p, size_t nelem, size_t size)
19371 {
19372  size_t cnt = HEAPCNT(nelem, size);
19374  void *ptr = xcalloc(nelem, size);
19375 
19376  return ADD2HEAP(n, cnt, ptr);
19377 }
19378 
19379 void *
19380 rb_parser_realloc(struct parser_params *p, void *ptr, size_t size)
19381 {
19383  size_t cnt = HEAPCNT(1, size);
19384 
19385  if (ptr && (n = p->heap) != NULL) {
19386  do {
19387  if (n->ptr == ptr) {
19388  n->ptr = ptr = xrealloc(ptr, size);
19389  if (n->cnt) n->cnt = cnt;
19390  return ptr;
19391  }
19392  } while ((n = n->next) != NULL);
19393  }
19394  n = NEWHEAP();
19395  ptr = xrealloc(ptr, size);
19396  return ADD2HEAP(n, cnt, ptr);
19397 }
19398 
19399 void
19401 {
19402  rb_imemo_tmpbuf_t **prev = &p->heap, *n;
19403 
19404  while ((n = *prev) != NULL) {
19405  if (n->ptr == ptr) {
19406  *prev = n->next;
19408  break;
19409  }
19410  prev = &n->next;
19411  }
19412  xfree(ptr);
19413 }
19414 #endif
19415 
19416 void
19417 rb_parser_printf(struct parser_params *p, const char *fmt, ...)
19418 {
19419  va_list ap;
19420  VALUE mesg = p->debug_buffer;
19421 
19422  if (NIL_P(mesg)) p->debug_buffer = mesg = rb_str_new(0, 0);
19423  va_start(ap, fmt);
19424  rb_str_vcatf(mesg, fmt, ap);
19425  va_end(ap);
19426  if (RSTRING_END(mesg)[-1] == '\n') {
19427  rb_io_write(p->debug_output, mesg);
19428  p->debug_buffer = Qnil;
19429  }
19430 }
19431 
19432 static void
19433 parser_compile_error(struct parser_params *p, const char *fmt, ...)
19434 {
19435  va_list ap;
19436 
19438  p->error_p = 1;
19439  va_start(ap, fmt);
19440  p->error_buffer =
19443  p->ruby_sourceline,
19444  rb_long2int(p->lex.pcur - p->lex.pbeg),
19445  p->enc, fmt, ap);
19446  va_end(ap);
19447 }
19448 
19449 static size_t
19450 count_char(const char *str, int c)
19451 {
19452  int n = 0;
19453  while (str[n] == c) ++n;
19454  return n;
19455 }
19456 
19457 /*
19458  * strip enclosing double-quotes, same as the default yytnamerr except
19459  * for that single-quotes matching back-quotes do not stop stripping.
19460  *
19461  * "\"`class' keyword\"" => "`class' keyword"
19462  */
19463 RUBY_FUNC_EXPORTED size_t
19464 rb_yytnamerr(struct parser_params *p, char *yyres, const char *yystr)
19465 {
19466  YYUSE(p);
19467  if (*yystr == '"') {
19468  size_t yyn = 0, bquote = 0;
19469  const char *yyp = yystr;
19470 
19471  while (*++yyp) {
19472  switch (*yyp) {
19473  case '`':
19474  if (!bquote) {
19475  bquote = count_char(yyp+1, '`') + 1;
19476  if (yyres) memcpy(&yyres[yyn], yyp, bquote);
19477  yyn += bquote;
19478  yyp += bquote - 1;
19479  break;
19480  }
19481  goto default_char;
19482 
19483  case '\'':
19484  if (bquote && count_char(yyp+1, '\'') + 1 == bquote) {
19485  if (yyres) memcpy(yyres + yyn, yyp, bquote);
19486  yyn += bquote;
19487  yyp += bquote - 1;
19488  bquote = 0;
19489  break;
19490  }
19491  if (yyp[1] && yyp[1] != '\'' && yyp[2] == '\'') {
19492  if (yyres) memcpy(yyres + yyn, yyp, 3);
19493  yyn += 3;
19494  yyp += 2;
19495  break;
19496  }
19497  goto do_not_strip_quotes;
19498 
19499  case ',':
19500  goto do_not_strip_quotes;
19501 
19502  case '\\':
19503  if (*++yyp != '\\')
19504  goto do_not_strip_quotes;
19505  /* Fall through. */
19506  default_char:
19507  default:
19508  if (yyres)
19509  yyres[yyn] = *yyp;
19510  yyn++;
19511  break;
19512 
19513  case '"':
19514  case '\0':
19515  if (yyres)
19516  yyres[yyn] = '\0';
19517  return yyn;
19518  }
19519  }
19520  do_not_strip_quotes: ;
19521  }
19522 
19523  if (!yyres) return strlen(yystr);
19524 
19525  return (YYSIZE_T)(yystpcpy(yyres, yystr) - yyres);
19526 }
19527 #endif
19528 
19529 #ifdef RIPPER
19530 #ifdef RIPPER_DEBUG
19531 /* :nodoc: */
19532 static VALUE
19533 ripper_validate_object(VALUE self, VALUE x)
19534 {
19535  if (x == Qfalse) return x;
19536  if (x == Qtrue) return x;
19537  if (x == Qnil) return x;
19538  if (x == Qundef)
19539  rb_raise(rb_eArgError, "Qundef given");
19540  if (FIXNUM_P(x)) return x;
19541  if (SYMBOL_P(x)) return x;
19542  switch (BUILTIN_TYPE(x)) {
19543  case T_STRING:
19544  case T_OBJECT:
19545  case T_ARRAY:
19546  case T_BIGNUM:
19547  case T_FLOAT:
19548  case T_COMPLEX:
19549  case T_RATIONAL:
19550  break;
19551  case T_NODE:
19552  if (nd_type((NODE *)x) != NODE_RIPPER) {
19553  rb_raise(rb_eArgError, "NODE given: %p", (void *)x);
19554  }
19555  x = ((NODE *)x)->nd_rval;
19556  break;
19557  default:
19558  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
19559  (void *)x, rb_obj_classname(x));
19560  }
19561  if (!RBASIC_CLASS(x)) {
19562  rb_raise(rb_eArgError, "hidden ruby object: %p (%s)",
19563  (void *)x, rb_builtin_type_name(TYPE(x)));
19564  }
19565  return x;
19566 }
19567 #endif
19568 
19569 #define validate(x) ((x) = get_value(x))
19570 
19571 static VALUE
19572 ripper_dispatch0(struct parser_params *p, ID mid)
19573 {
19574  return rb_funcall(p->value, mid, 0);
19575 }
19576 
19577 static VALUE
19578 ripper_dispatch1(struct parser_params *p, ID mid, VALUE a)
19579 {
19580  validate(a);
19581  return rb_funcall(p->value, mid, 1, a);
19582 }
19583 
19584 static VALUE
19585 ripper_dispatch2(struct parser_params *p, ID mid, VALUE a, VALUE b)
19586 {
19587  validate(a);
19588  validate(b);
19589  return rb_funcall(p->value, mid, 2, a, b);
19590 }
19591 
19592 static VALUE
19593 ripper_dispatch3(struct parser_params *p, ID mid, VALUE a, VALUE b, VALUE c)
19594 {
19595  validate(a);
19596  validate(b);
19597  validate(c);
19598  return rb_funcall(p->value, mid, 3, a, b, c);
19599 }
19600 
19601 static VALUE
19602 ripper_dispatch4(struct parser_params *p, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
19603 {
19604  validate(a);
19605  validate(b);
19606  validate(c);
19607  validate(d);
19608  return rb_funcall(p->value, mid, 4, a, b, c, d);
19609 }
19610 
19611 static VALUE
19612 ripper_dispatch5(struct parser_params *p, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
19613 {
19614  validate(a);
19615  validate(b);
19616  validate(c);
19617  validate(d);
19618  validate(e);
19619  return rb_funcall(p->value, mid, 5, a, b, c, d, e);
19620 }
19621 
19622 static VALUE
19623 ripper_dispatch7(struct parser_params *p, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
19624 {
19625  validate(a);
19626  validate(b);
19627  validate(c);
19628  validate(d);
19629  validate(e);
19630  validate(f);
19631  validate(g);
19632  return rb_funcall(p->value, mid, 7, a, b, c, d, e, f, g);
19633 }
19634 
19635 static ID
19636 ripper_get_id(VALUE v)
19637 {
19638  NODE *nd;
19639  if (!RB_TYPE_P(v, T_NODE)) return 0;
19640  nd = (NODE *)v;
19641  if (nd_type(nd) != NODE_RIPPER) return 0;
19642  return nd->nd_vid;
19643 }
19644 
19645 static VALUE
19646 ripper_get_value(VALUE v)
19647 {
19648  NODE *nd;
19649  if (v == Qundef) return Qnil;
19650  if (!RB_TYPE_P(v, T_NODE)) return v;
19651  nd = (NODE *)v;
19652  if (nd_type(nd) != NODE_RIPPER) return Qnil;
19653  return nd->nd_rval;
19654 }
19655 
19656 static void
19657 ripper_error(struct parser_params *p)
19658 {
19659  p->error_p = TRUE;
19660 }
19661 
19662 static void
19663 ripper_compile_error(struct parser_params *p, const char *fmt, ...)
19664 {
19665  VALUE str;
19666  va_list args;
19667 
19668  va_start(args, fmt);
19669  str = rb_vsprintf(fmt, args);
19670  va_end(args);
19671  rb_funcall(p->value, rb_intern("compile_error"), 1, str);
19672  ripper_error(p);
19673 }
19674 
19675 static VALUE
19676 ripper_lex_get_generic(struct parser_params *p, VALUE src)
19677 {
19678  VALUE line = rb_funcallv_public(src, id_gets, 0, 0);
19679  if (!NIL_P(line) && !RB_TYPE_P(line, T_STRING)) {
19681  "gets returned %"PRIsVALUE" (expected String or nil)",
19682  rb_obj_class(line));
19683  }
19684  return line;
19685 }
19686 
19687 static VALUE
19688 ripper_lex_io_get(struct parser_params *p, VALUE src)
19689 {
19690  return rb_io_gets(src);
19691 }
19692 
19693 static VALUE
19694 ripper_s_allocate(VALUE klass)
19695 {
19696  struct parser_params *p;
19698  &parser_data_type, p);
19699  p->value = self;
19700  return self;
19701 }
19702 
19703 #define ripper_initialized_p(r) ((r)->lex.input != 0)
19704 
19705 /*
19706  * call-seq:
19707  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
19708  *
19709  * Create a new Ripper object.
19710  * _src_ must be a String, an IO, or an Object which has #gets method.
19711  *
19712  * This method does not starts parsing.
19713  * See also Ripper#parse and Ripper.parse.
19714  */
19715 static VALUE
19716 ripper_initialize(int argc, VALUE *argv, VALUE self)
19717 {
19718  struct parser_params *p;
19719  VALUE src, fname, lineno;
19720 
19721  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19722  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
19723  if (RB_TYPE_P(src, T_FILE)) {
19724  p->lex.gets = ripper_lex_io_get;
19725  }
19726  else if (rb_respond_to(src, id_gets)) {
19727  p->lex.gets = ripper_lex_get_generic;
19728  }
19729  else {
19730  StringValue(src);
19731  p->lex.gets = lex_get_str;
19732  }
19733  p->lex.input = src;
19734  p->eofp = 0;
19735  if (NIL_P(fname)) {
19736  fname = STR_NEW2("(ripper)");
19737  OBJ_FREEZE(fname);
19738  }
19739  else {
19740  StringValueCStr(fname);
19741  fname = rb_str_new_frozen(fname);
19742  }
19743  parser_initialize(p);
19744 
19745  p->ruby_sourcefile_string = fname;
19746  p->ruby_sourcefile = RSTRING_PTR(fname);
19747  p->ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
19748 
19749  return Qnil;
19750 }
19751 
19752 static VALUE
19753 ripper_parse0(VALUE parser_v)
19754 {
19755  struct parser_params *p;
19756 
19757  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, p);
19758  parser_prepare(p);
19759  p->ast = rb_ast_new();
19760  ripper_yyparse((void*)p);
19761  rb_ast_dispose(p->ast);
19762  p->ast = 0;
19763  return p->result;
19764 }
19765 
19766 static VALUE
19767 ripper_ensure(VALUE parser_v)
19768 {
19769  struct parser_params *p;
19770 
19771  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, p);
19772  p->parsing_thread = Qnil;
19773  return Qnil;
19774 }
19775 
19776 /*
19777  * call-seq:
19778  * ripper.parse
19779  *
19780  * Start parsing and returns the value of the root action.
19781  */
19782 static VALUE
19783 ripper_parse(VALUE self)
19784 {
19785  struct parser_params *p;
19786 
19787  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19788  if (!ripper_initialized_p(p)) {
19789  rb_raise(rb_eArgError, "method called for uninitialized object");
19790  }
19791  if (!NIL_P(p->parsing_thread)) {
19792  if (p->parsing_thread == rb_thread_current())
19793  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
19794  else
19795  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
19796  }
19797  p->parsing_thread = rb_thread_current();
19798  rb_ensure(ripper_parse0, self, ripper_ensure, self);
19799 
19800  return p->result;
19801 }
19802 
19803 /*
19804  * call-seq:
19805  * ripper.column -> Integer
19806  *
19807  * Return column number of current parsing line.
19808  * This number starts from 0.
19809  */
19810 static VALUE
19811 ripper_column(VALUE self)
19812 {
19813  struct parser_params *p;
19814  long col;
19815 
19816  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19817  if (!ripper_initialized_p(p)) {
19818  rb_raise(rb_eArgError, "method called for uninitialized object");
19819  }
19820  if (NIL_P(p->parsing_thread)) return Qnil;
19821  col = p->lex.ptok - p->lex.pbeg;
19822  return LONG2NUM(col);
19823 }
19824 
19825 /*
19826  * call-seq:
19827  * ripper.filename -> String
19828  *
19829  * Return current parsing filename.
19830  */
19831 static VALUE
19832 ripper_filename(VALUE self)
19833 {
19834  struct parser_params *p;
19835 
19836  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19837  if (!ripper_initialized_p(p)) {
19838  rb_raise(rb_eArgError, "method called for uninitialized object");
19839  }
19840  return p->ruby_sourcefile_string;
19841 }
19842 
19843 /*
19844  * call-seq:
19845  * ripper.lineno -> Integer
19846  *
19847  * Return line number of current parsing line.
19848  * This number starts from 1.
19849  */
19850 static VALUE
19851 ripper_lineno(VALUE self)
19852 {
19853  struct parser_params *p;
19854 
19855  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19856  if (!ripper_initialized_p(p)) {
19857  rb_raise(rb_eArgError, "method called for uninitialized object");
19858  }
19859  if (NIL_P(p->parsing_thread)) return Qnil;
19860  return INT2NUM(p->ruby_sourceline);
19861 }
19862 
19863 /*
19864  * call-seq:
19865  * ripper.state -> Integer
19866  *
19867  * Return scanner state of current token.
19868  */
19869 static VALUE
19870 ripper_state(VALUE self)
19871 {
19872  struct parser_params *p;
19873 
19874  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19875  if (!ripper_initialized_p(p)) {
19876  rb_raise(rb_eArgError, "method called for uninitialized object");
19877  }
19878  if (NIL_P(p->parsing_thread)) return Qnil;
19879  return INT2NUM(p->lex.state);
19880 }
19881 
19882 /*
19883  * call-seq:
19884  * ripper.token -> String
19885  *
19886  * Return the current token string.
19887  */
19888 static VALUE
19889 ripper_token(VALUE self)
19890 {
19891  struct parser_params *p;
19892  long pos, len;
19893 
19894  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19895  if (!ripper_initialized_p(p)) {
19896  rb_raise(rb_eArgError, "method called for uninitialized object");
19897  }
19898  if (NIL_P(p->parsing_thread)) return Qnil;
19899  pos = p->lex.ptok - p->lex.pbeg;
19900  len = p->lex.pcur - p->lex.ptok;
19901  return rb_str_subseq(p->lex.lastline, pos, len);
19902 }
19903 
19904 #ifdef RIPPER_DEBUG
19905 /* :nodoc: */
19906 static VALUE
19907 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
19908 {
19909  StringValue(msg);
19910  if (obj == Qundef) {
19911  rb_raise(rb_eArgError, "%"PRIsVALUE, msg);
19912  }
19913  return Qnil;
19914 }
19915 
19916 /* :nodoc: */
19917 static VALUE
19918 ripper_value(VALUE self, VALUE obj)
19919 {
19920  return ULONG2NUM(obj);
19921 }
19922 #endif
19923 
19924 /*
19925  * call-seq:
19926  * Ripper.lex_state_name(integer) -> string
19927  *
19928  * Returns a string representation of lex_state.
19929  */
19930 static VALUE
19931 ripper_lex_state_name(VALUE self, VALUE state)
19932 {
19934 }
19935 
19936 void
19937 Init_ripper(void)
19938 {
19939  ripper_init_eventids1();
19940  ripper_init_eventids2();
19941  id_warn = rb_intern_const("warn");
19942  id_warning = rb_intern_const("warning");
19943  id_gets = rb_intern_const("gets");
19944  id_assoc = rb_intern_const("=>");
19945 
19946  (void)yystpcpy; /* may not used in newer bison */
19947 
19948  InitVM(ripper);
19949 }
19950 
19951 void
19952 InitVM_ripper(void)
19953 {
19954  VALUE Ripper;
19955 
19956  Ripper = rb_define_class("Ripper", rb_cObject);
19957  /* version of Ripper */
19958  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
19959  rb_define_alloc_func(Ripper, ripper_s_allocate);
19960  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
19961  rb_define_method(Ripper, "parse", ripper_parse, 0);
19962  rb_define_method(Ripper, "column", ripper_column, 0);
19963  rb_define_method(Ripper, "filename", ripper_filename, 0);
19964  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
19965  rb_define_method(Ripper, "state", ripper_state, 0);
19966  rb_define_method(Ripper, "token", ripper_token, 0);
19967  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
19968  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
19969  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
19970  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
19971  rb_define_method(Ripper, "debug_output", rb_parser_get_debug_output, 0);
19972  rb_define_method(Ripper, "debug_output=", rb_parser_set_debug_output, 1);
19973  rb_define_method(Ripper, "error?", ripper_error_p, 0);
19974 #ifdef RIPPER_DEBUG
19975  rb_define_method(Ripper, "assert_Qundef", ripper_assert_Qundef, 2);
19976  rb_define_method(Ripper, "rawVALUE", ripper_value, 1);
19977  rb_define_method(Ripper, "validate_object", ripper_validate_object, 1);
19978 #endif
19979 
19980  rb_define_singleton_method(Ripper, "dedent_string", parser_dedent_string, 2);
19981  rb_define_private_method(Ripper, "dedent_string", parser_dedent_string, 2);
19982 
19983  rb_define_singleton_method(Ripper, "lex_state_name", ripper_lex_state_name, 1);
19984 
19985  /* ignore newline, +/- is a sign. */
19986  rb_define_const(Ripper, "EXPR_BEG", INT2NUM(EXPR_BEG));
19987  /* newline significant, +/- is an operator. */
19988  rb_define_const(Ripper, "EXPR_END", INT2NUM(EXPR_END));
19989  /* ditto, and unbound braces. */
19990  rb_define_const(Ripper, "EXPR_ENDARG", INT2NUM(EXPR_ENDARG));
19991  /* ditto, and unbound braces. */
19992  rb_define_const(Ripper, "EXPR_ENDFN", INT2NUM(EXPR_ENDFN));
19993  /* newline significant, +/- is an operator. */
19994  rb_define_const(Ripper, "EXPR_ARG", INT2NUM(EXPR_ARG));
19995  /* newline significant, +/- is an operator. */
19996  rb_define_const(Ripper, "EXPR_CMDARG", INT2NUM(EXPR_CMDARG));
19997  /* newline significant, +/- is an operator. */
19998  rb_define_const(Ripper, "EXPR_MID", INT2NUM(EXPR_MID));
19999  /* ignore newline, no reserved words. */
20000  rb_define_const(Ripper, "EXPR_FNAME", INT2NUM(EXPR_FNAME));
20001  /* right after `.' or `::', no reserved words. */
20002  rb_define_const(Ripper, "EXPR_DOT", INT2NUM(EXPR_DOT));
20003  /* immediate after `class', no here document. */
20004  rb_define_const(Ripper, "EXPR_CLASS", INT2NUM(EXPR_CLASS));
20005  /* flag bit, label is allowed. */
20006  rb_define_const(Ripper, "EXPR_LABEL", INT2NUM(EXPR_LABEL));
20007  /* flag bit, just after a label. */
20008  rb_define_const(Ripper, "EXPR_LABELED", INT2NUM(EXPR_LABELED));
20009  /* symbol literal as FNAME. */
20010  rb_define_const(Ripper, "EXPR_FITEM", INT2NUM(EXPR_FITEM));
20011  /* equals to +EXPR_BEG+ */
20012  rb_define_const(Ripper, "EXPR_VALUE", INT2NUM(EXPR_VALUE));
20013  /* equals to <tt>(EXPR_BEG | EXPR_MID | EXPR_CLASS)</tt> */
20014  rb_define_const(Ripper, "EXPR_BEG_ANY", INT2NUM(EXPR_BEG_ANY));
20015  /* equals to <tt>(EXPR_ARG | EXPR_CMDARG)</tt> */
20016  rb_define_const(Ripper, "EXPR_ARG_ANY", INT2NUM(EXPR_ARG_ANY));
20017  /* equals to <tt>(EXPR_END | EXPR_ENDARG | EXPR_ENDFN)</tt> */
20018  rb_define_const(Ripper, "EXPR_END_ANY", INT2NUM(EXPR_END_ANY));
20019  /* equals to +0+ */
20020  rb_define_const(Ripper, "EXPR_NONE", INT2NUM(EXPR_NONE));
20021 
20022  ripper_init_eventids1_table(Ripper);
20023  ripper_init_eventids2_table(Ripper);
20024 
20025 # if 0
20026  /* Hack to let RDoc document SCRIPT_LINES__ */
20027 
20028  /*
20029  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
20030  * after the assignment will be added as an Array of lines with the file
20031  * name as the key.
20032  */
20033  rb_define_global_const("SCRIPT_LINES__", Qnil);
20034 #endif
20035 
20036 }
20037 #endif /* RIPPER */
20038 
20039 /*
20040  * Local variables:
20041  * mode: c
20042  * c-file-style: "ruby"
20043  * End:
20044  */
rb_parser_printf
void rb_parser_printf(struct parser_params *p, const char *fmt,...)
Definition: ripper.c:19417
memset
void * memset(void *, int, size_t)
idNULL
@ idNULL
Definition: id.h:113
token_info::indent
int indent
Definition: ripper.c:254
NODE_NEXT
@ NODE_NEXT
Definition: node.h:38
parser_params::has_shebang
unsigned int has_shebang
Definition: ripper.c:333
IS_LABEL_POSSIBLE
#define IS_LABEL_POSSIBLE()
Definition: ripper.c:13822
kwtable
Definition: lex.c:34
new_nil
#define new_nil(loc)
Definition: ripper.c:487
rb_io_gets
VALUE rb_io_gets(VALUE)
Definition: io.c:3573
strncmp
int strncmp(const char *, const char *, size_t)
FLONUM_P
#define FLONUM_P(x)
Definition: ruby.h:430
RE_OPTION_ENCODING
#define RE_OPTION_ENCODING(e)
Definition: ripper.c:703
va_end
#define va_end(v)
Definition: rb_mjit_min_header-2.7.2.h:4014
kwtable::state
short state
Definition: lex.c:34
idFWD_BLOCK
#define idFWD_BLOCK
Definition: ripper.c:699
str_label
@ str_label
Definition: ripper.c:12939
WARN_S_L
#define WARN_S_L(s, l)
Definition: ripper.c:995
rb_parser_new
VALUE rb_parser_new(void)
Definition: ripper.c:19206
rb_strterm_struct::flags
VALUE flags
Definition: ripper.c:756
local_vars::outer
NODE * outer
Definition: ripper.c:224
rb_io_puts
VALUE rb_io_puts(int, const VALUE *, VALUE)
Definition: io.c:7747
NEW_CDECL
#define NEW_CDECL(v, val, path, loc)
Definition: node.h:321
NODE_COLON3
@ NODE_COLON3
Definition: node.h:110
parser_params::input
VALUE input
Definition: ripper.c:278
tUPLUS
@ tUPLUS
Definition: parse.h:115
NODE_FL_NEWLINE
#define NODE_FL_NEWLINE
Definition: node.h:183
reg_named_capture_assign_t::enc
rb_encoding * enc
Definition: ripper.c:18922
UNLIKELY
#define UNLIKELY(x)
Definition: ffi_common.h:126
parser_params::do_print
unsigned int do_print
Definition: ripper.c:349
NODE_NIL
@ NODE_NIL
Definition: node.h:116
ISASCII
#define ISASCII(c)
Definition: ruby.h:2304
ID
unsigned long ID
Definition: ruby.h:103
RUBY_SYMBOL_EXPORT_END
#define RUBY_SYMBOL_EXPORT_END
Definition: missing.h:49
STATIC_ASSERT
STATIC_ASSERT(rb_strterm_heredoc_t, sizeof(rb_strterm_heredoc_t)<=4 *SIZEOF_VALUE)
NEW_FOR_MASGN
#define NEW_FOR_MASGN(v, loc)
Definition: node.h:299
rb_define_class
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:649
keyword_defined
@ keyword_defined
Definition: parse.h:92
parser_params::call
VALUE(* call)(VALUE, int)
Definition: ripper.c:288
Qnull
#define Qnull
Definition: ripper.c:942
rb_id2name
const char * rb_id2name(ID)
Definition: symbol.c:801
NEW_RESBODY
#define NEW_RESBODY(a, ex, n, loc)
Definition: node.h:308
yyerrok
#define yyerrok
Definition: ripper.c:5119
set_yylval_noname
#define set_yylval_noname()
Definition: ripper.c:12265
rb_fstring
VALUE rb_fstring(VALUE)
Definition: string.c:312
RNode::value
VALUE value
Definition: node.h:154
tSTRING_CONTENT
@ tSTRING_CONTENT
Definition: parse.h:112
vtable::tbl
ID * tbl
Definition: ripper.c:208
TypedData_Make_Struct
#define TypedData_Make_Struct(klass, type, data_type, sval)
Definition: ruby.h:1244
WARN_I
#define WARN_I(i)
Definition: ripper.c:997
idEq
@ idEq
Definition: id.h:96
magic_comment::name
const char * name
Definition: ripper.c:14602
TRUE
#define TRUE
Definition: nkf.h:175
rb_str_vcatf
VALUE rb_str_vcatf(VALUE, const char *, va_list)
Definition: sprintf.c:1210
tEQ
@ tEQ
Definition: parse.h:119
NODE_ATTRASGN
@ NODE_ATTRASGN
Definition: node.h:123
error
const rb_iseq_t const char * error
Definition: rb_mjit_min_header-2.7.2.h:13554
nd_set_first_loc
#define nd_set_first_loc(n, v)
Definition: node.h:203
tCONSTANT
@ tCONSTANT
Definition: parse.h:102
YYEMPTY
#define YYEMPTY
Definition: ripper.c:5121
RSTRING_GETMEM
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Definition: ruby.h:1018
WARN_LOCATION
#define WARN_LOCATION(type)
Definition: ripper.c:16700
YYLAST
#define YYLAST
Definition: ripper.c:1468
NEW_OP_ASGN2
#define NEW_OP_ASGN2(r, t, i, o, val, loc)
Definition: node.h:324
compile_error
#define compile_error
Definition: ripper.c:1008
rb_reserved_word
const struct kwtable * rb_reserved_word(const char *str, unsigned int len)
Definition: ripper.c:19200
keyword_class
@ keyword_class
Definition: parse.h:49
rb_parser_warn_location
void rb_parser_warn_location(VALUE vparser, int warn)
Definition: ripper.c:19029
PRIsWARN
#define PRIsWARN
Definition: ripper.c:1000
T_FLOAT
#define T_FLOAT
Definition: ruby.h:527
local_vars::vars
struct vtable * vars
Definition: ripper.c:216
xcalloc
#define xcalloc
Definition: defines.h:213
STR_FUNC_TERM
#define STR_FUNC_TERM
Definition: ripper.c:12936
idANDOP
@ idANDOP
Definition: id.h:108
YYSTYPE::tbl
st_table * tbl
Definition: parse.h:181
rb_enc_str_buf_cat
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:2919
rb_suppress_tracing
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:415
rb_assoc_new
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Definition: array.c:896
NUM_SUFFIX_ALL
#define NUM_SUFFIX_ALL
Definition: ripper.c:14179
NODE_DSYM
@ NODE_DSYM
Definition: node.h:122
tNMATCH
@ tNMATCH
Definition: parse.h:127
rb_ast_newnode
NODE * rb_ast_newnode(rb_ast_t *ast, enum node_type type)
Definition: node.c:1198
strtod
#define strtod(s, e)
Definition: util.h:76
local_vars::inner
NODE * inner
Definition: ripper.c:224
rb_obj_hide
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
Definition: object.c:78
ruby_method_ids
ruby_method_ids
Definition: id.h:78
NODE_HSHPTN
@ NODE_HSHPTN
Definition: node.h:126
parser_params::nextline
VALUE nextline
Definition: ripper.c:281
rb_enc_name
#define rb_enc_name(enc)
Definition: encoding.h:177
keyword_self
@ keyword_self
Definition: parse.h:79
NEW_MATCH3
#define NEW_MATCH3(r, n2, loc)
Definition: node.h:339
rb_warn3L
#define rb_warn3L(l, fmt, a, b, c)
Definition: ripper.c:963
rb_strterm_struct::literal
rb_strterm_literal_t literal
Definition: ripper.c:758
NODE_RESCUE
@ NODE_RESCUE
Definition: node.h:42
rb_ast_struct::body
rb_ast_body_t body
Definition: node.h:402
local_vars
Definition: ripper.c:214
nd_state
#define nd_state
Definition: node.h:263
id
const int id
Definition: nkf.c:209
ID_INTERNAL
#define ID_INTERNAL
Definition: id.h:40
NEW_NODE
#define NEW_NODE(t, a0, a1, a2, loc)
Definition: node.h:282
KWD2EID
#define KWD2EID(t, v)
Definition: ripper.c:937
yytype_uint8
unsigned char yytype_uint8
Definition: ripper.c:1233
rb_ary_pattern_info::pre_args
NODE * pre_args
Definition: node.h:455
rb_iseq_struct
Definition: vm_core.h:456
parser_params::in_kwarg
unsigned int in_kwarg
Definition: ripper.c:335
tLAMBDA
@ tLAMBDA
Definition: parse.h:150
nd_head
#define nd_head
Definition: node.h:214
DEF_EXPR
#define DEF_EXPR(n)
Definition: ripper.c:152
ID2VAL
#define ID2VAL(id)
Definition: ripper.c:935
rb_ident_hash_new
VALUE rb_ident_hash_new(void)
Definition: hash.c:4278
rb_hash_new
VALUE rb_hash_new(void)
Definition: hash.c:1523
tSTRING_BEG
@ tSTRING_BEG
Definition: parse.h:152
ID_LOCAL
#define ID_LOCAL
Definition: id.h:33
rb_gc_register_mark_object
void rb_gc_register_mark_object(VALUE obj)
Definition: gc.c:7066
tLAMBEG
@ tLAMBEG
Definition: parse.h:163
eventids1.c
NODE_TRUE
@ NODE_TRUE
Definition: node.h:117
string_type
string_type
Definition: ripper.c:12938
rb_enc_mbcput
#define rb_enc_mbcput(c, buf, enc)
Definition: encoding.h:217
keyword_next
@ keyword_next
Definition: parse.h:68
keyword_if
@ keyword_if
Definition: parse.h:57
s2
const char * s2
Definition: rb_mjit_min_header-2.7.2.h:5489
rb_str_buf_new
VALUE rb_str_buf_new(long)
Definition: string.c:1315
YYUSE
#define YYUSE(E)
Definition: ripper.c:1310
STR_FUNC_QWORDS
#define STR_FUNC_QWORDS
Definition: ripper.c:12931
parser_params::in_defined
unsigned int in_defined
Definition: ripper.c:334
rb_local_defined
int rb_local_defined(ID id, const rb_iseq_t *iseq)
Definition: compile.c:9382
idOr
@ idOr
Definition: id.h:101
NODE_NTH_REF
@ NODE_NTH_REF
Definition: node.h:79
rb_stderr
RUBY_EXTERN VALUE rb_stderr
Definition: ruby.h:2090
tokfix
#define tokfix(p)
Definition: ripper.c:13076
RE_OPTION_MASK
#define RE_OPTION_MASK
Definition: ripper.c:706
NODE_ZLIST
@ NODE_ZLIST
Definition: node.h:68
ID_GLOBAL
#define ID_GLOBAL
Definition: id.h:35
NODE_SPECIAL_EXCESSIVE_COMMA
#define NODE_SPECIAL_EXCESSIVE_COMMA
Definition: node.h:385
NODE_DREGX
@ NODE_DREGX
Definition: node.h:90
k__END__
@ k__END__
Definition: eventids2.c:9
ISDIGIT
#define ISDIGIT(c)
Definition: ruby.h:2312
RUBY_DTRACE_PARSE_HOOK
#define RUBY_DTRACE_PARSE_HOOK(name)
NEW_ZSUPER
#define NEW_ZSUPER(loc)
Definition: node.h:352
parser_params::debug
unsigned int debug
Definition: ripper.c:332
tLBRACK
@ tLBRACK
Definition: parse.h:144
idMesg
@ idMesg
Definition: rb_mjit_min_header-2.7.2.h:8770
keyword_do_cond
@ keyword_do_cond
Definition: parse.h:73
NEW_SCOPE
#define NEW_SCOPE(a, b, loc)
Definition: node.h:287
EXPR_ENDFN_bit
@ EXPR_ENDFN_bit
Definition: ripper.c:138
yyerror0
#define yyerror0(msg)
Definition: ripper.c:414
NODE_OR
@ NODE_OR
Definition: node.h:46
int
__inline__ int
Definition: rb_mjit_min_header-2.7.2.h:2877
NODE_ARYPTN
@ NODE_ARYPTN
Definition: node.h:125
regenc.h
tLAST_TOKEN
@ tLAST_TOKEN
Definition: parse.h:167
RUBY_SET_YYLLOC_FROM_STRTERM_HEREDOC
#define RUBY_SET_YYLLOC_FROM_STRTERM_HEREDOC(Current)
Definition: ripper.c:122
CALL_Q_P
#define CALL_Q_P(q)
Definition: ripper.c:427
token_info
struct token_info token_info
MAX_WORD_LENGTH
#define MAX_WORD_LENGTH
Definition: zonetab.h:45
rb_ast_dispose
void rb_ast_dispose(rb_ast_t *ast)
Definition: node.c:1387
token_info
Definition: ripper.c:251
str_dquote
@ str_dquote
Definition: ripper.c:12941
EXPR_BEG_bit
@ EXPR_BEG_bit
Definition: ripper.c:135
keyword_module
@ keyword_module
Definition: parse.h:50
parser_params::eofp
unsigned int eofp
Definition: ripper.c:330
parser_params::heredoc_line_indent
int heredoc_line_indent
Definition: ripper.c:305
NEW_OPT_ARG
#define NEW_OPT_ARG(i, v, loc)
Definition: node.h:354
idNil
@ idNil
Definition: rb_mjit_min_header-2.7.2.h:8781
idEqq
@ idEqq
Definition: id.h:97
rb_gc_force_recycle
void rb_gc_force_recycle(VALUE obj)
Definition: gc.c:7014
tLPAREN
@ tLPAREN
Definition: parse.h:141
EXPR_LABEL_bit
@ EXPR_LABEL_bit
Definition: ripper.c:145
IS_lex_state_for
#define IS_lex_state_for(x, ls)
Definition: ripper.c:172
INT2FIX
#define INT2FIX(i)
Definition: ruby.h:263
rb_hash_clear
VALUE rb_hash_clear(VALUE hash)
Definition: hash.c:2769
NEW_BEGIN
#define NEW_BEGIN(b, loc)
Definition: node.h:306
st_is_member
#define st_is_member(table, key)
Definition: st.h:97
NEW_RESCUE
#define NEW_RESCUE(b, res, e, loc)
Definition: node.h:307
HERETERM_LENGTH_BITS
#define HERETERM_LENGTH_BITS
Definition: ripper.c:729
vtable_add
#define vtable_add(tbl, id)
Definition: ripper.c:12659
toklen
#define toklen(p)
Definition: ripper.c:13078
rb_char_to_option_kcode
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Definition: re.c:319
NODE_HASH
@ NODE_HASH
Definition: node.h:70
rb_parser_reg_compile
RUBY_SYMBOL_EXPORT_BEGIN VALUE rb_parser_reg_compile(struct parser_params *p, VALUE str, int options)
Definition: ripper.c:18977
rb_strterm_heredoc_struct::func
unsigned func
Definition: ripper.c:745
NEW_ITER
#define NEW_ITER(a, b, loc)
Definition: node.h:300
vtable::capa
int capa
Definition: ripper.c:210
NODE_CONST
@ NODE_CONST
Definition: node.h:77
keyword_false
@ keyword_false
Definition: parse.h:82
NEW_IVAR
#define NEW_IVAR(v, loc)
Definition: node.h:332
rb_warning_category_enabled_p
MJIT_FUNC_EXPORTED bool rb_warning_category_enabled_p(rb_warning_category_t category)
Definition: error.c:166
RE_OPTION_ONCE
#define RE_OPTION_ONCE
Definition: ripper.c:701
RSTRING_PTR
#define RSTRING_PTR(str)
Definition: ruby.h:1009
YYSTACK_ALLOC_MAXIMUM
#define YYSTACK_ALLOC_MAXIMUM
Definition: ripper.c:1377
parser_params::gets
VALUE(* gets)(struct parser_params *, VALUE)
Definition: ripper.c:277
i
uint32_t i
Definition: rb_mjit_min_header-2.7.2.h:5499
NODE_LASGN
@ NODE_LASGN
Definition: node.h:48
idUMinus
@ idUMinus
Definition: id.h:82
rb_str_cat_cstr
#define rb_str_cat_cstr(str, ptr)
Definition: rb_mjit_min_header-2.7.2.h:6161
parser_params::do_chomp
unsigned int do_chomp
Definition: ripper.c:351
IS_ARG
#define IS_ARG()
Definition: ripper.c:13818
rb_attr_get
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1084
parser_params::pend
const char * pend
Definition: ripper.c:284
keyword_not
@ keyword_not
Definition: parse.h:85
parser_params::debug_buffer
VALUE debug_buffer
Definition: ripper.c:319
keyword_alias
@ keyword_alias
Definition: parse.h:91
rb_strterm_mark
void rb_strterm_mark(VALUE obj)
Definition: ripper.c:765
parser_params::debug_lines
VALUE debug_lines
Definition: ripper.c:358
parser_params::heredoc_indent
int heredoc_indent
Definition: ripper.c:304
str_squote
@ str_squote
Definition: ripper.c:12940
ESCAPE_META
#define ESCAPE_META
Definition: ripper.c:13284
NEW_POSTEXE
#define NEW_POSTEXE(b, loc)
Definition: node.h:378
NEW_OP_CDECL
#define NEW_OP_CDECL(v, op, val, loc)
Definition: node.h:328
ENCODING_IS_ASCII8BIT
#define ENCODING_IS_ASCII8BIT(obj)
Definition: encoding.h:63
st_init_numtable
st_table * st_init_numtable(void)
Definition: st.c:653
tNTH_REF
@ tNTH_REF
Definition: parse.h:110
rb_strterm_literal_t
struct rb_strterm_literal_struct rb_strterm_literal_t
parser_params::parent_iseq
const struct rb_iseq_struct * parent_iseq
Definition: ripper.c:359
CSI_SGR
#define CSI_SGR
NODE_FLIP2
@ NODE_FLIP2
Definition: node.h:113
NODE_ARGSPUSH
@ NODE_ARGSPUSH
Definition: node.h:98
rb_ary_unshift
VALUE rb_ary_unshift(VALUE ary, VALUE item)
Definition: array.c:1494
tANDDOT
@ tANDDOT
Definition: parse.h:136
WARN_ID
#define WARN_ID(i)
Definition: ripper.c:998
rb_int_positive_pow
RUBY_EXTERN VALUE rb_int_positive_pow(long x, unsigned long y)
Definition: numeric.c:4033
token_info::next
struct token_info * next
Definition: ripper.c:256
YYACCEPT
#define YYACCEPT
Definition: ripper.c:5124
NEW_ERRINFO
#define NEW_ERRINFO(loc)
Definition: node.h:375
VALUE
unsigned long VALUE
Definition: ruby.h:102
NODE_CASE
@ NODE_CASE
Definition: node.h:27
long
#define long
Definition: rb_mjit_min_header-2.7.2.h:2921
rb_id_attrset
ID rb_id_attrset(ID)
Definition: symbol.c:98
rb_strterm_literal_struct::paren
long paren
Definition: ripper.c:721
rb_funcallv_public
VALUE rb_funcallv_public(VALUE, ID, int, const VALUE *)
Calls a method.
Definition: vm_eval.c:980
rb_obj_as_string
VALUE rb_obj_as_string(VALUE)
Definition: string.c:1440
rb_eArgError
VALUE rb_eArgError
Definition: error.c:925
va_list
__gnuc_va_list va_list
Definition: rb_mjit_min_header-2.7.2.h:839
set_yylval_name
#define set_yylval_name(x)
Definition: ripper.c:12247
encoding.h
NEW_REDO
#define NEW_REDO(loc)
Definition: node.h:304
STR_FUNC_SYMBOL
#define STR_FUNC_SYMBOL
Definition: ripper.c:12932
ruby_verbose
#define ruby_verbose
Definition: ruby.h:1925
ZALLOC
#define ZALLOC(type)
Definition: ruby.h:1666
rb_intern
#define rb_intern(str)
NODE_ARGSCAT
@ NODE_ARGSCAT
Definition: node.h:97
rb_eSyntaxError
VALUE rb_eSyntaxError
Definition: error.c:940
YYSTACK_RELOCATE
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: ripper.c:1432
RB_TYPE_P
#define RB_TYPE_P(obj, type)
Definition: ruby.h:560
rb_enc_isalnum
#define rb_enc_isalnum(c, enc)
Definition: encoding.h:235
rb_intern_const
#define rb_intern_const(str)
Definition: ruby.h:1879
parser_params::max_numparam
int max_numparam
Definition: ripper.c:327
set_yylval_id
#define set_yylval_id(x)
Definition: ripper.c:12246
WARN_S
#define WARN_S(s)
Definition: ripper.c:996
TYPE
#define TYPE(x)
Definition: ruby.h:554
rb_thread_current
VALUE rb_thread_current(void)
Definition: thread.c:2676
rb_enc_get
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:872
DVARS_INHERIT
#define DVARS_INHERIT
Definition: ripper.c:247
NEW_UNLESS
#define NEW_UNLESS(c, t, e, loc)
Definition: node.h:290
parser_params::cur_arg
ID cur_arg
Definition: ripper.c:322
rb_enc_asciicompat
#define rb_enc_asciicompat(enc)
Definition: encoding.h:245
tAMPER
@ tAMPER
Definition: parse.h:149
rb_args_info::pre_args_num
int pre_args_num
Definition: node.h:436
NEW_CLASS
#define NEW_CLASS(n, b, s, loc)
Definition: node.h:364
CMDARG_POP
#define CMDARG_POP()
Definition: ripper.c:203
local_vars::current
NODE * current
Definition: ripper.c:224
NODE_DOT2
@ NODE_DOT2
Definition: node.h:111
NODE_EVSTR
@ NODE_EVSTR
Definition: node.h:89
ID_STATIC_SYM
#define ID_STATIC_SYM
Definition: id.h:30
rb_code_position_struct
Definition: node.h:130
rb_enc_precise_mbclen
int rb_enc_precise_mbclen(const char *p, const char *e, rb_encoding *enc)
Definition: encoding.c:1032
tSTRING_END
@ tSTRING_END
Definition: parse.h:159
rb_strterm_struct::u
union rb_strterm_struct::@8 u
NEW_LAMBDA
#define NEW_LAMBDA(a, b, loc)
Definition: node.h:301
magic_comment::length
rb_magic_comment_length_t length
Definition: ripper.c:14604
rb_args_info::kw_rest_arg
NODE * kw_rest_arg
Definition: node.h:445
rb_strterm_literal_struct::u2
union rb_strterm_literal_struct::@6 u2
PRINTF_ARGS
PRINTF_ARGS(void rb_parser_fatal(struct parser_params *p, const char *fmt,...), 2, 3)
modifier_rescue
@ modifier_rescue
Definition: parse.h:90
rb_const_get_at
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:2397
tLABEL_END
@ tLABEL_END
Definition: parse.h:164
rb_parser_show_bitstack
void rb_parser_show_bitstack(struct parser_params *, stack_type, const char *, int)
Definition: ripper.c:17105
tASSOC
@ tASSOC
Definition: parse.h:140
keyword_begin
@ keyword_begin
Definition: parse.h:53
eventids2.c
ID_SCOPE_MASK
#define ID_SCOPE_MASK
Definition: id.h:32
alias
const char * alias
Definition: nkf.c:1159
NEW_CALL
#define NEW_CALL(r, m, a, loc)
Definition: node.h:347
nd_set_line
#define nd_set_line(n, l)
Definition: node.h:195
rb_rational_raw1
#define rb_rational_raw1(x)
Definition: intern.h:176
rb_args_info::post_init
NODE * post_init
Definition: node.h:434
parser_params::ruby_sourceline
int ruby_sourceline
Definition: ripper.c:311
NEW_RETRY
#define NEW_RETRY(loc)
Definition: node.h:305
idGets
@ idGets
Definition: rb_mjit_min_header-2.7.2.h:8743
NODE_CVASGN
@ NODE_CVASGN
Definition: node.h:54
NODE_AND
@ NODE_AND
Definition: node.h:45
NEW_TRUE
#define NEW_TRUE(loc)
Definition: node.h:373
scan_oct
#define scan_oct(s, l, e)
Definition: util.h:53
rb_parser_lex_state_name
VALUE rb_parser_lex_state_name(enum lex_state_e state)
Definition: ripper.c:17086
tCOLON2
@ tCOLON2
Definition: parse.h:137
rb_code_position_struct::lineno
int lineno
Definition: node.h:131
NODE_LIT
@ NODE_LIT
Definition: node.h:84
YYSTYPE::vars
const struct vtable * vars
Definition: parse.h:182
rb_parser_compile_file_path
rb_ast_t * rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE file, int start)
Definition: ripper.c:12893
nd_once_body
#define nd_once_body(node)
Definition: ripper.c:16638
tIVAR
@ tIVAR
Definition: parse.h:101
tASET
@ tASET
Definition: parse.h:133
rb_parser_malloc
void * rb_parser_malloc(struct parser_params *p, size_t size)
Definition: ripper.c:19360
parser_params::command_start
unsigned int command_start
Definition: ripper.c:329
NEW_STR
#define NEW_STR(s, loc)
Definition: node.h:341
rb_str_dup
VALUE rb_str_dup(VALUE)
Definition: string.c:1516
NODE_MASGN
@ NODE_MASGN
Definition: node.h:47
str_dword
@ str_dword
Definition: ripper.c:12945
RRATIONAL
#define RRATIONAL(obj)
Definition: internal.h:794
ISALPHA
#define ISALPHA(c)
Definition: ruby.h:2311
lambda_beginning_p
#define lambda_beginning_p()
Definition: ripper.c:431
parser_params::gets_
union parser_params::@2::@3 gets_
NEW_MATCH2
#define NEW_MATCH2(n1, n2, loc)
Definition: node.h:338
rb_parser_compile_generic
rb_ast_t * rb_parser_compile_generic(VALUE vparser, VALUE(*lex_gets)(VALUE, int), VALUE fname, VALUE input, int start)
Definition: ripper.c:12913
NEW_DEFINED
#define NEW_DEFINED(e, loc)
Definition: node.h:376
NEW_BLOCK
#define NEW_BLOCK(a, loc)
Definition: node.h:288
NEW_SUPER
#define NEW_SUPER(a, loc)
Definition: node.h:351
yypact_value_is_default
#define yypact_value_is_default(Yystate)
Definition: ripper.c:1725
yytokentype
yytokentype
Definition: parse.h:47
Qundef
#define Qundef
Definition: ruby.h:470
rb_strterm_literal_struct
Definition: ripper.c:710
parser_params::ptok
const char * ptok
Definition: ripper.c:285
rb_define_singleton_method
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
Definition: class.c:1755
T_RATIONAL
#define T_RATIONAL
Definition: ruby.h:541
parser_params::error_buffer
VALUE error_buffer
Definition: ripper.c:357
NODE_DXSTR
@ NODE_DXSTR
Definition: node.h:88
NEW_MASGN
#define NEW_MASGN(l, r, loc)
Definition: node.h:315
CHAR_BIT
#define CHAR_BIT
Definition: ruby.h:227
rb_usascii_str_new
#define rb_usascii_str_new(str, len)
Definition: rb_mjit_min_header-2.7.2.h:6153
rb_str_modify
void rb_str_modify(VALUE)
Definition: string.c:2114
rb_make_exception
VALUE rb_make_exception(int argc, const VALUE *argv)
Make an Exception object from the list of arguments in a manner similar to Kernel#raise.
Definition: eval.c:851
NEW_LVAR
#define NEW_LVAR(v, loc)
Definition: node.h:330
keyword_do_block
@ keyword_do_block
Definition: parse.h:74
NEW_KW_ARG
#define NEW_KW_ARG(i, v, loc)
Definition: node.h:355
NODE_OPCALL
@ NODE_OPCALL
Definition: node.h:61
NODE_SPECIAL_REQUIRED_KEYWORD
#define NODE_SPECIAL_REQUIRED_KEYWORD
Definition: node.h:381
rb_define_method
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1551
NEW_LIST
#define NEW_LIST(a, loc)
Definition: node.h:312
ID_INSTANCE
#define ID_INSTANCE
Definition: id.h:34
rb_long2int
#define rb_long2int(n)
Definition: ruby.h:350
NUMPARAM_ID_P
#define NUMPARAM_ID_P(id)
Definition: ripper.c:235
INT2NUM
#define INT2NUM(x)
Definition: ruby.h:1609
rb_cstr_to_inum
VALUE rb_cstr_to_inum(const char *str, int base, int badcheck)
Definition: bignum.c:4012
ruby_global_name_punct_bits
RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20+31)/32]
Definition: ripper.c:13761
CSI_BEGIN
#define CSI_BEGIN
idLE
@ idLE
Definition: id.h:93
ptr
struct RIMemo * ptr
Definition: debug.c:65
idUPlus
@ idUPlus
Definition: id.h:81
yyparse
#define yyparse
Definition: ripper.c:483
get_value
#define get_value(val)
Definition: ripper.c:588
NEW_LIT
#define NEW_LIT(l, loc)
Definition: node.h:340
ruby_scan_oct
unsigned long ruby_scan_oct(const char *, size_t, size_t *)
Definition: util.c:34
NODE_SPECIAL_NO_REST_KEYWORD
#define NODE_SPECIAL_NO_REST_KEYWORD
Definition: node.h:386
Qfalse
#define Qfalse
Definition: ruby.h:467
NEW_UNDEF
#define NEW_UNDEF(i, loc)
Definition: node.h:363
modifier_while
@ modifier_while
Definition: parse.h:88
literal_flush
#define literal_flush(p, ptr)
Definition: ripper.c:12268
subnodes
#define subnodes(n1, n2)
rb_stdout
RUBY_EXTERN VALUE rb_stdout
Definition: ruby.h:2090
DBL2NUM
#define DBL2NUM(dbl)
Definition: ruby.h:967
RNode::flags
VALUE flags
Definition: node.h:150
rb_ast_new
rb_ast_t * rb_ast_new(void)
Definition: node.c:1235
EXPR_CLASS_bit
@ EXPR_CLASS_bit
Definition: ripper.c:144
tGEQ
@ tGEQ
Definition: parse.h:122
yyerror
#define yyerror(yylloc, p, msg)
Definition: ripper.c:416
keyword_when
@ keyword_when
Definition: parse.h:63
IS_LABEL_SUFFIX
#define IS_LABEL_SUFFIX(n)
Definition: ripper.c:13825
tSYMBOLS_BEG
@ tSYMBOLS_BEG
Definition: parse.h:157
tSYMBEG
@ tSYMBEG
Definition: parse.h:151
rb_id2str
#define rb_id2str(id)
Definition: vm_backtrace.c:30
YY_ATTRIBUTE_UNUSED
#define YY_ATTRIBUTE_UNUSED
Definition: ripper.c:1296
T_NODE
#define T_NODE
Definition: ruby.h:545
parser_params::do_loop
unsigned int do_loop
Definition: ripper.c:350
tXSTRING_BEG
@ tXSTRING_BEG
Definition: parse.h:153
NODE_DASGN
@ NODE_DASGN
Definition: node.h:49
rb_stderr_tty_p
int rb_stderr_tty_p(void)
Definition: io.c:7958
SPECIAL_CONST_P
#define SPECIAL_CONST_P(x)
Definition: ruby.h:1313
BIGNUM_NEGATE
#define BIGNUM_NEGATE(b)
Definition: internal.h:767
NODE_BLOCK
@ NODE_BLOCK
Definition: node.h:24
rb_ary_new3
#define rb_ary_new3
Definition: intern.h:104
st.h
idFWD_REST
#define idFWD_REST
Definition: ripper.c:693
NULL
#define NULL
Definition: _sdbm.c:101
T_COMPLEX
#define T_COMPLEX
Definition: ruby.h:542
NEW_ARGSPUSH
#define NEW_ARGSPUSH(a, b, loc)
Definition: node.h:358
rb_filesystem_str_new_cstr
VALUE rb_filesystem_str_new_cstr(const char *)
Definition: string.c:1117
ruby_scan_digits
RUBY_EXTERN unsigned long ruby_scan_digits(const char *str, ssize_t len, int base, size_t *retlen, int *overflow)
Definition: util.c:97
NEW_GVAR
#define NEW_GVAR(v, loc)
Definition: node.h:329
parser_params::tokenbuf
char * tokenbuf
Definition: ripper.c:306
rb_args_info::first_post_arg
ID first_post_arg
Definition: node.h:439
rb_strterm_literal_struct::dummy
VALUE dummy
Definition: ripper.c:712
NEW_IN
#define NEW_IN(c, t, e, loc)
Definition: node.h:295
tRSHFT
@ tRSHFT
Definition: parse.h:135
tLEQ
@ tLEQ
Definition: parse.h:123
fmt
const VALUE int int int int int int VALUE char * fmt
Definition: rb_mjit_min_header-2.7.2.h:6497
set_yylval_str
#define set_yylval_str(x)
Definition: ripper.c:12235
PRIsVALUE
#define PRIsVALUE
Definition: ruby.h:166
parser_params::pcur
const char * pcur
Definition: ripper.c:283
token_info::beg
rb_code_position_t beg
Definition: ripper.c:253
tOROP
@ tOROP
Definition: parse.h:125
tWORDS_BEG
@ tWORDS_BEG
Definition: parse.h:155
nd_set_node_id
#define nd_set_node_id(n, id)
Definition: node.h:212
rb_enc_from_encoding
VALUE rb_enc_from_encoding(rb_encoding *encoding)
Definition: encoding.c:116
NUMPARAM_ID_TO_IDX
#define NUMPARAM_ID_TO_IDX(id)
Definition: ripper.c:236
last
unsigned int last
Definition: nkf.c:4324
RE_OPTION_ENCODING_IDX
#define RE_OPTION_ENCODING_IDX(o)
Definition: ripper.c:704
peek_n
#define peek_n(p, c, n)
Definition: ripper.c:12971
NODE_DSTR
@ NODE_DSTR
Definition: node.h:86
rb_fatal
void rb_fatal(const char *fmt,...)
Definition: error.c:2722
RUBY_INIT_YYLLOC
#define RUBY_INIT_YYLLOC()
Definition: ripper.c:128
st_insert
int st_insert(st_table *tab, st_data_t key, st_data_t value)
Definition: st.c:1171
OnigUChar
unsigned char OnigUChar
Definition: onigmo.h:79
RUBY_SET_YYLLOC
#define RUBY_SET_YYLLOC(Current)
Definition: ripper.c:126
FIX2LONG
#define FIX2LONG(x)
Definition: ruby.h:394
ID2SYM
#define ID2SYM(x)
Definition: ruby.h:414
ruby.h
strlen
size_t strlen(const char *)
tBDOT2
@ tBDOT2
Definition: parse.h:130
yytable_value_is_error
#define yytable_value_is_error(Yytable_value)
Definition: ripper.c:1730
OBJ_FREEZE
#define OBJ_FREEZE(x)
Definition: ruby.h:1377
T_OBJECT
#define T_OBJECT
Definition: ruby.h:523
yyalloc::yyss_alloc
yytype_int16 yyss_alloc
Definition: ripper.c:1411
NODE_SPLAT
@ NODE_SPLAT
Definition: node.h:99
EXPR_FITEM_bit
@ EXPR_FITEM_bit
Definition: ripper.c:147
RB_WARN_CATEGORY_EXPERIMENTAL
@ RB_WARN_CATEGORY_EXPERIMENTAL
Definition: internal.h:1563
rb_ascii8bit_encindex
int rb_ascii8bit_encindex(void)
Definition: encoding.c:1322
NODE_CDECL
@ NODE_CDECL
Definition: node.h:53
rb_args_info::kw_args
NODE * kw_args
Definition: node.h:444
rb_init_parse
void rb_init_parse(void)
Definition: ripper.c:19071
NEW_QCALL
#define NEW_QCALL(q, r, m, a, loc)
Definition: ripper.c:429
rb_warn1L
#define rb_warn1L(l, fmt, a)
Definition: ripper.c:961
peek
#define peek(p, c)
Definition: ripper.c:12970
rb_respond_to
int rb_respond_to(VALUE, ID)
Definition: vm_method.c:2190
NODE_CVAR
@ NODE_CVAR
Definition: node.h:78
rb_imemo_new
VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0)
Definition: gc.c:2308
YYEOF
#define YYEOF
Definition: ripper.c:5122
tCMP
@ tCMP
Definition: parse.h:118
warn_balanced
#define warn_balanced(tok, op, syn)
Definition: ripper.c:14831
RUBY_FUNC_EXPORTED
#define RUBY_FUNC_EXPORTED
Definition: defines.h:391
NEW_ATTRASGN
#define NEW_ATTRASGN(r, m, a, loc)
Definition: node.h:379
RNODE
#define RNODE(obj)
Definition: node.h:176
keyword_do_LAMBDA
@ keyword_do_LAMBDA
Definition: parse.h:75
lex_eol_p
#define lex_eol_p(p)
Definition: ripper.c:12968
yytype_int16
short int yytype_int16
Definition: ripper.c:1251
InitVM
#define InitVM(ext)
Definition: ruby.h:2329
parser_params::token_info
token_info * token_info
Definition: ripper.c:315
HEAPCNT
#define HEAPCNT(n, size)
Definition: ripper.c:19352
parse.h
rb_args_info::pre_init
NODE * pre_init
Definition: node.h:433
keyword_def
@ keyword_def
Definition: parse.h:51
ALLOC_N
#define ALLOC_N(type, n)
Definition: ruby.h:1663
rb_str_resize
VALUE rb_str_resize(VALUE, long)
Definition: string.c:2709
parser_params::ast
rb_ast_t * ast
Definition: ripper.c:324
YYSTYPE
Definition: parse.h:175
rb_ast_delete_node
void rb_ast_delete_node(rb_ast_t *ast, NODE *n)
Definition: node.c:1227
tCOMMENT
@ tCOMMENT
Definition: eventids2.c:3
NODE_IN
@ NODE_IN
Definition: node.h:31
void
void
Definition: rb_mjit_min_header-2.7.2.h:13321
keyword_ensure
@ keyword_ensure
Definition: parse.h:55
rb_ast_body_struct::compile_option
VALUE compile_option
Definition: node.h:396
yytype_uint16
unsigned short int yytype_uint16
Definition: ripper.c:1245
idANDDOT
@ idANDDOT
Definition: id.h:110
keyword_rescue
@ keyword_rescue
Definition: parse.h:54
rb_vsprintf
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1191
tokcopy
#define tokcopy(p, n)
Definition: ripper.c:13147
EXPR_ARG_ANY
@ EXPR_ARG_ANY
Definition: ripper.c:168
keyword_redo
@ keyword_redo
Definition: parse.h:69
vtable_alloc
#define vtable_alloc(prev)
Definition: ripper.c:12619
lex.c
rb_raise
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:2671
rb_reg_compile
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2953
YYABORT
#define YYABORT
Definition: ripper.c:5125
COND_IN_FF
@ COND_IN_FF
Definition: ripper.c:17849
ESCAPE_CONTROL
#define ESCAPE_CONTROL
Definition: ripper.c:13283
rb_sym_intern_ascii_cstr
#define rb_sym_intern_ascii_cstr(ptr)
Definition: rb_mjit_min_header-2.7.2.h:7799
rb_ary_entry
VALUE rb_ary_entry(VALUE ary, long offset)
Definition: array.c:1512
onig_foreach_name
ONIG_EXTERN int onig_foreach_name(OnigRegex reg, int(*func)(const OnigUChar *, const OnigUChar *, int, int *, OnigRegex, void *), void *arg)
T_FILE
#define T_FILE
Definition: ruby.h:534
tGVAR
@ tGVAR
Definition: parse.h:100
tCOLON3
@ tCOLON3
Definition: parse.h:138
NEW_IF
#define NEW_IF(c, t, e, loc)
Definition: node.h:289
YYSTYPE::val
VALUE val
Definition: parse.h:177
idLASTLINE
@ idLASTLINE
Definition: rb_mjit_min_header-2.7.2.h:8794
NUM2UINT
#define NUM2UINT(x)
Definition: ruby.h:716
keyword__LINE__
@ keyword__LINE__
Definition: parse.h:95
imemo_parser_strterm
@ imemo_parser_strterm
Definition: internal.h:1143
reg_named_capture_assign_t::loc
const YYLTYPE * loc
Definition: ripper.c:18924
if
if((ID)(DISPID) nameid !=nameid)
Definition: win32ole.c:357
keyword_unless
@ keyword_unless
Definition: parse.h:58
LONG2NUM
#define LONG2NUM(x)
Definition: ruby.h:1644
NEW_ENSURE
#define NEW_ENSURE(b, en, loc)
Definition: node.h:309
NODE_UNLESS
@ NODE_UNLESS
Definition: node.h:26
rb_obj_class
VALUE rb_obj_class(VALUE)
Equivalent to Object#class in Ruby.
Definition: object.c:217
tFID
@ tFID
Definition: parse.h:99
intern_cstr
#define intern_cstr(n, l, en)
Definition: ripper.c:375
parser_params::warn_location
unsigned int warn_location
Definition: ripper.c:353
nd_args
#define nd_args
Definition: node.h:253
lex_state_bits
lex_state_bits
Definition: ripper.c:134
probes.h
rb_io_flush
VALUE rb_io_flush(VALUE)
Definition: io.c:1903
SIZEOF_VALUE
#define SIZEOF_VALUE
Definition: ruby.h:105
parser_params::pbeg
const char * pbeg
Definition: ripper.c:282
YY_NULLPTR
#define YY_NULLPTR
Definition: ripper.c:1028
NEW_GASGN
#define NEW_GASGN(v, val, loc)
Definition: node.h:316
YYSTYPE::strterm
struct rb_strterm_struct * strterm
Definition: parse.h:183
rb_parser_calloc
void * rb_parser_calloc(struct parser_params *p, size_t nelem, size_t size)
Definition: ripper.c:19370
NEW_CASE
#define NEW_CASE(h, b, loc)
Definition: node.h:291
ULONG2NUM
#define ULONG2NUM(x)
Definition: ruby.h:1645
RRATIONAL_SET_NUM
#define RRATIONAL_SET_NUM(rat, n)
Definition: internal.h:795
set_yylval_node
#define set_yylval_node(x)
Definition: ripper.c:12230
NEW_OPCALL
#define NEW_OPCALL(r, m, a, loc)
Definition: node.h:348
rb_parser_free
void rb_parser_free(struct parser_params *p, void *ptr)
Definition: ripper.c:19400
NEW_ALIAS
#define NEW_ALIAS(n, o, loc)
Definition: node.h:361
tLABEL
@ tLABEL
Definition: parse.h:104
rb_ast_struct
Definition: node.h:399
tEMBDOC
@ tEMBDOC
Definition: eventids2.c:5
rb_args_info::opt_args
NODE * opt_args
Definition: node.h:447
tEMBDOC_END
@ tEMBDOC_END
Definition: eventids2.c:6
BEG
#define BEG(no)
Definition: re.c:25
tFLOAT
@ tFLOAT
Definition: parse.h:106
rb_node_init
void rb_node_init(NODE *n, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
Definition: node.c:1095
rb_ascii8bit_encoding
rb_encoding * rb_ascii8bit_encoding(void)
Definition: encoding.c:1316
rb_magic_comment_setter_t
void(* rb_magic_comment_setter_t)(struct parser_params *p, const char *name, const char *val)
Definition: ripper.c:14536
ADD2HEAP
#define ADD2HEAP(new, cnt, ptr)
Definition: ripper.c:19356
keyword_true
@ keyword_true
Definition: parse.h:81
dispatch_delayed_token
#define dispatch_delayed_token(p, t)
Definition: ripper.c:12270
NEW_CONST
#define NEW_CONST(v, loc)
Definition: node.h:333
YY_
#define YY_(Msgid)
Definition: ripper.c:1277
nd_ainfo
#define nd_ainfo
Definition: node.h:254
klass
VALUE klass
Definition: rb_mjit_min_header-2.7.2.h:13302
rb_args_info
Definition: node.h:432
kwtable::id
short id[2]
Definition: lex.c:34
rb_ary_pattern_info::post_args
NODE * post_args
Definition: node.h:457
NEW_NIL
#define NEW_NIL(loc)
Definition: node.h:372
token_flush
#define token_flush(ptr)
Definition: ripper.c:417
parser_params::pvtbl
st_table * pvtbl
Definition: ripper.c:308
NEW_DSTR
#define NEW_DSTR(s, loc)
Definition: node.h:342
YYFPRINTF
#define YYFPRINTF
Definition: ripper.c:102
local_vars::numparam
struct local_vars::@1 numparam
idLTLT
@ idLTLT
Definition: id.h:90
rb_str_intern
VALUE rb_str_intern(VALUE)
Definition: symbol.c:710
tREGEXP_BEG
@ tREGEXP_BEG
Definition: parse.h:154
WARN_IVAL
#define WARN_IVAL(i)
Definition: ripper.c:999
value_expr
#define value_expr(node)
Definition: ripper.c:499
h
size_t st_index_t h
Definition: rb_mjit_min_header-2.7.2.h:5497
token
unsigned short token
Definition: id.c:36
rb_ary_pattern_info::rest_arg
NODE * rest_arg
Definition: node.h:456
tQSYMBOLS_BEG
@ tQSYMBOLS_BEG
Definition: parse.h:158
tIMAGINARY
@ tIMAGINARY
Definition: parse.h:108
st_init_numtable_with_size
st_table * st_init_numtable_with_size(st_index_t size)
Definition: st.c:660
nd_set_first_lineno
#define nd_set_first_lineno(n, v)
Definition: node.h:201
STR_NEW2
#define STR_NEW2(ptr)
Definition: ripper.c:379
idNeq
@ idNeq
Definition: id.h:98
rb_strterm_literal_struct::u3
union rb_strterm_literal_struct::@7 u3
NEW_CVAR
#define NEW_CVAR(v, loc)
Definition: node.h:334
node.h
compile_for_eval
#define compile_for_eval
Definition: ripper.c:422
rb_args_info::imemo
VALUE imemo
Definition: node.h:451
NEW_NTH_REF
#define NEW_NTH_REF(n, loc)
Definition: node.h:335
rb_enc_from_index
rb_encoding * rb_enc_from_index(int index)
Definition: encoding.c:609
NEW_SELF
#define NEW_SELF(loc)
Definition: node.h:371
keyword_END
@ keyword_END
Definition: parse.h:94
rb_args_info::ruby2_keywords
unsigned int ruby2_keywords
Definition: node.h:449
parser_params::do_split
unsigned int do_split
Definition: ripper.c:352
tREGEXP_END
@ tREGEXP_END
Definition: parse.h:113
NEW_DASGN
#define NEW_DASGN(v, val, loc)
Definition: node.h:318
vtable_pop
#define vtable_pop(tbl, n)
Definition: ripper.c:12676
EXPR_NONE
@ EXPR_NONE
Definition: ripper.c:170
nd_value
#define nd_value
Definition: node.h:241
EXPR_LABELED_bit
@ EXPR_LABELED_bit
Definition: ripper.c:146
was_bol
#define was_bol(p)
Definition: ripper.c:13074
is_local_id
#define is_local_id(id)
Definition: symbol.h:36
RB_OBJ_WRITTEN
#define RB_OBJ_WRITTEN(a, oldv, b)
Definition: ruby.h:1509
tSTRING_DEND
@ tSTRING_DEND
Definition: parse.h:160
NODE_IF
@ NODE_IF
Definition: node.h:25
rb_parser_set_yydebug
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: ripper.c:19311
tLBRACE_ARG
@ tLBRACE_ARG
Definition: parse.h:146
NODE_ENSURE
@ NODE_ENSURE
Definition: node.h:44
keyword_else
@ keyword_else
Definition: parse.h:61
OnigEncodingTypeST
Definition: onigmo.h:160
idUScore
@ idUScore
Definition: rb_mjit_min_header-2.7.2.h:8782
vtable
Definition: ripper.c:207
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: ripper.c:5239
rb_compile_warning
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:287
rb_builtin_type_name
const char * rb_builtin_type_name(int t)
Definition: error.c:763
keyword_retry
@ keyword_retry
Definition: parse.h:70
lex_state_e
lex_state_e
Definition: ripper.c:151
add_delayed_token
#define add_delayed_token(p, tok, end)
Definition: ripper.c:12991
keyword__FILE__
@ keyword__FILE__
Definition: parse.h:96
rb_parser_set_options
void rb_parser_set_options(VALUE vparser, int print, int loop, int chomp, int split)
Definition: ripper.c:19018
RCOMPLEX_SET_IMAG
#define RCOMPLEX_SET_IMAG(cmp, i)
Definition: internal.h:815
rb_node_case_when_optimizable_literal
VALUE rb_node_case_when_optimizable_literal(const NODE *const node)
Definition: compile.c:4289
T_REGEXP
#define T_REGEXP
Definition: ruby.h:529
nd_set_type
#define nd_set_type(n, t)
Definition: node.h:189
parser_params::ruby_sourcefile
const char * ruby_sourcefile
Definition: ripper.c:312
NEW_NEXT
#define NEW_NEXT(s, loc)
Definition: node.h:303
rb_memcicmp
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:80
tCHAR
@ tCHAR
Definition: parse.h:109
ISALNUM
#define ISALNUM(c)
Definition: ruby.h:2310
IS_BEG
#define IS_BEG()
Definition: ripper.c:13820
parser_params::case_labels
VALUE case_labels
Definition: ripper.c:316
SPECIAL_PUNCT
#define SPECIAL_PUNCT(idx)
Definition: ripper.c:13766
rb_hash_lookup
VALUE rb_hash_lookup(VALUE hash, VALUE key)
Definition: hash.c:2063
rb_errinfo
VALUE rb_errinfo(void)
The current exception in the current thread.
Definition: eval.c:1882
memchr
void * memchr(const void *, int, size_t)
parser_params::cr_seen
unsigned int cr_seen
Definition: ripper.c:344
rb_ary_push
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:1195
rb_code_position_struct::column
int column
Definition: node.h:132
NEW_YIELD
#define NEW_YIELD(a, loc)
Definition: node.h:311
YY_LOCATION_PRINT
#define YY_LOCATION_PRINT(File, loc)
Definition: ripper.c:104
NEW_DEFS
#define NEW_DEFS(r, i, a, d, loc)
Definition: node.h:286
nd_body
#define nd_body
Definition: node.h:219
tPOW
@ tPOW
Definition: parse.h:117
DVARS_TERMINAL_P
#define DVARS_TERMINAL_P(tbl)
Definition: ripper.c:249
NODE_CASE3
@ NODE_CASE3
Definition: node.h:29
nd_end
#define nd_end
Definition: node.h:262
tANDOP
@ tANDOP
Definition: parse.h:124
cnt
rb_atomic_t cnt[RUBY_NSIG]
Definition: signal.c:503
idGE
@ idGE
Definition: id.h:95
idPow
@ idPow
Definition: id.h:83
rb_obj_freeze
VALUE rb_obj_freeze(VALUE)
Make the object unmodifiable.
Definition: object.c:1080
YYLTYPE
Definition: parse.h:196
keyword_then
@ keyword_then
Definition: parse.h:59
RARRAY_AREF
#define RARRAY_AREF(a, i)
Definition: psych_emitter.c:7
rb_strterm_literal_struct::u0
union rb_strterm_literal_struct::@4 u0
rb_strterm_literal_struct::nest
long nest
Definition: ripper.c:713
tHEREDOC_END
@ tHEREDOC_END
Definition: eventids2.c:8
RUBY_SET_YYLLOC_OF_NONE
#define RUBY_SET_YYLLOC_OF_NONE(Current)
Definition: ripper.c:124
term
const char term
Definition: id.c:37
reg_named_capture_assign_t::succ_block
NODE * succ_block
Definition: ripper.c:18923
has_delayed_token
#define has_delayed_token(p)
Definition: ripper.c:12271
tLSHFT
@ tLSHFT
Definition: parse.h:134
YYINITDEPTH
#define YYINITDEPTH
Definition: ripper.c:5358
YYPRINT
#define YYPRINT(out, tok, val)
Definition: ripper.c:103
YYSTACK_FREE
#define YYSTACK_FREE
Definition: ripper.c:1375
magic_comment
Definition: ripper.c:14601
NODE_DASGN_CURR
@ NODE_DASGN_CURR
Definition: node.h:50
EXPR_MAX_STATE
@ EXPR_MAX_STATE
Definition: ripper.c:148
CMDARG_PUSH
#define CMDARG_PUSH(n)
Definition: ripper.c:202
rb_eTypeError
VALUE rb_eTypeError
Definition: error.c:924
rb_ary_concat
VALUE rb_ary_concat(VALUE x, VALUE y)
Definition: array.c:4069
RBASIC_CLASS
#define RBASIC_CLASS(obj)
Definition: ruby.h:906
SIZED_REALLOC_N
#define SIZED_REALLOC_N(var, type, n, old_n)
Definition: internal.h:1663
SWITCH_BY_COND_TYPE
#define SWITCH_BY_COND_TYPE(t, w, arg)
Definition: ripper.c:17852
NODE_COLON2
@ NODE_COLON2
Definition: node.h:109
NODE_DOT3
@ NODE_DOT3
Definition: node.h:112
yytnamerr
#define yytnamerr(yyres, yystr)
Definition: ripper.c:775
NEW_DOT2
#define NEW_DOT2(b, e, loc)
Definition: node.h:369
rb_node_newnode
#define rb_node_newnode(type, a1, a2, a3, loc)
Definition: ripper.c:459
rb_ast_add_local_table
void rb_ast_add_local_table(rb_ast_t *ast, ID *buf)
Definition: node.c:1219
node_type
node_type
Definition: node.h:22
vars
const VALUE int int int int int int VALUE * vars[]
Definition: rb_mjit_min_header-2.7.2.h:6497
ALLOC
#define ALLOC(type)
Definition: ruby.h:1664
reg_named_capture_assign_t
Definition: ripper.c:18920
COND_PUSH
#define COND_PUSH(n)
Definition: ripper.c:195
NEW_MODULE
#define NEW_MODULE(n, b, loc)
Definition: node.h:366
rb_warn2
#define rb_warn2(fmt, a, b)
Definition: ripper.c:952
tOP_ASGN
@ tOP_ASGN
Definition: parse.h:139
idCall
@ idCall
Definition: rb_mjit_min_header-2.7.2.h:8769
NODE_BREAK
@ NODE_BREAK
Definition: node.h:37
END_OF_INPUT
@ END_OF_INPUT
Definition: parse.h:48
rb_eRuntimeError
VALUE rb_eRuntimeError
Definition: error.c:922
parser_params::in_def
unsigned int in_def
Definition: ripper.c:336
input
unsigned int input
Definition: nkf.c:4325
yytype_int8
signed char yytype_int8
Definition: ripper.c:1239
YYSTYPE::num
int num
Definition: parse.h:180
NODE_GVAR
@ NODE_GVAR
Definition: node.h:75
NEW_DEFN
#define NEW_DEFN(i, a, d, loc)
Definition: node.h:285
ALLOCA_N
#define ALLOCA_N(type, n)
Definition: ruby.h:1684
parser_params::strterm
rb_strterm_t * strterm
Definition: ripper.c:276
LVAR_USED
#define LVAR_USED
Definition: ripper.c:16297
vtable::pos
int pos
Definition: ripper.c:209
ruby_sized_xfree
#define ruby_sized_xfree(ptr, size)
Definition: rb_mjit_min_header-2.7.2.h:7408
rb_ast_add_mark_object
void rb_ast_add_mark_object(rb_ast_t *ast, VALUE obj)
Definition: node.c:1393
NODE_XSTR
@ NODE_XSTR
Definition: node.h:87
keyword_end
@ keyword_end
Definition: parse.h:56
STRNCASECMP
#define STRNCASECMP(s1, s2, n)
Definition: ruby.h:2324
parser_params::heredoc_end
int heredoc_end
Definition: ripper.c:303
rb_strterm_literal_struct::u1
union rb_strterm_literal_struct::@5 u1
idGTGT
@ idGTGT
Definition: id.h:91
NEW_LASGN
#define NEW_LASGN(v, val, loc)
Definition: node.h:317
symbol.h
size
int size
Definition: encoding.c:58
rb_enc_compatible
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:974
rb_str_set_len
void rb_str_set_len(VALUE, long)
Definition: string.c:2692
uint8_t
unsigned char uint8_t
Definition: sha2.h:100
FALSE
#define FALSE
Definition: nkf.h:174
rb_ast_body_struct::line_count
int line_count
Definition: node.h:397
FIXNUM_P
#define FIXNUM_P(f)
Definition: ruby.h:396
idAND
@ idAND
Definition: rb_mjit_min_header-2.7.2.h:8774
NODE_ARGS
@ NODE_ARGS
Definition: node.h:92
NEW_COLON3
#define NEW_COLON3(i, loc)
Definition: node.h:368
NEW_XSTR
#define NEW_XSTR(s, loc)
Definition: node.h:343
HERETERM_LENGTH_MAX
#define HERETERM_LENGTH_MAX
YYCASE_
#define YYCASE_(N, S)
tRATIONAL
@ tRATIONAL
Definition: parse.h:107
nd_first_column
#define nd_first_column(n)
Definition: node.h:198
NEW_HASH
#define NEW_HASH(a, loc)
Definition: node.h:314
arg
VALUE arg
Definition: rb_mjit_min_header-2.7.2.h:5636
parser_params::heap
rb_imemo_tmpbuf_t * heap
Definition: ripper.c:271
rb_parser_compile_string_path
rb_ast_t * rb_parser_compile_string_path(VALUE vparser, VALUE f, VALUE s, int line)
Definition: ripper.c:12878
NODE_DVAR
@ NODE_DVAR
Definition: node.h:74
YYLTYPE::last_column
int last_column
Definition: parse.h:200
tok
#define tok(p)
Definition: ripper.c:13077
regex.h
rb_parser_trace_lex_state
enum lex_state_e rb_parser_trace_lex_state(struct parser_params *, enum lex_state_e, enum lex_state_e, int)
Definition: ripper.c:17072
list
struct rb_encoding_entry * list
Definition: encoding.c:56
yyalloc::yyvs_alloc
YYSTYPE yyvs_alloc
Definition: ripper.c:1412
str_copy
#define str_copy(_s, _p, _n)
unterminated_literal
#define unterminated_literal(mesg)
ISSPACE
#define ISSPACE(c)
Definition: ruby.h:2307
RE_OPTION_ENCODING_NONE
#define RE_OPTION_ENCODING_NONE(o)
Definition: ripper.c:705
rb_str_new_frozen
VALUE rb_str_new_frozen(VALUE)
Definition: string.c:1203
NEW_BLOCK_PASS
#define NEW_BLOCK_PASS(b, loc)
Definition: node.h:360
YYLTYPE::last_line
int last_line
Definition: parse.h:199
NEW_OP_ASGN_OR
#define NEW_OP_ASGN_OR(i, val, loc)
Definition: node.h:326
rb_syntax_error_append
VALUE rb_syntax_error_append(VALUE exc, VALUE file, int line, int column, rb_encoding *enc, const char *fmt, va_list args)
Definition: error.c:104
rb_parser_end_seen_p
VALUE rb_parser_end_seen_p(VALUE vparser)
Definition: ripper.c:19264
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: ripper.c:5306
RB_OBJ_WRITE
#define RB_OBJ_WRITE(a, slot, b)
Definition: ruby.h:1508
modifier_unless
@ modifier_unless
Definition: parse.h:87
rb_args_info::post_args_num
int post_args_num
Definition: node.h:437
keyword_while
@ keyword_while
Definition: parse.h:64
Qnone
#define Qnone
Definition: ripper.c:941
mask
enum @0::@2::@3 mask
tLPAREN_ARG
@ tLPAREN_ARG
Definition: parse.h:142
CONST_ID
#define CONST_ID(var, str)
Definition: ruby.h:1841
NUM_SUFFIX_R
#define NUM_SUFFIX_R
Definition: ripper.c:14177
StringValueCStr
#define StringValueCStr(v)
Definition: ruby.h:604
tDSTAR
@ tDSTAR
Definition: parse.h:148
ID_SCOPE_SHIFT
#define ID_SCOPE_SHIFT
Definition: id.h:31
key
key
Definition: openssl_missing.h:181
T_HASH
#define T_HASH
Definition: ruby.h:531
rb_strterm_heredoc_struct::offset
long offset
Definition: ripper.c:733
STR_FUNC_LIST
#define STR_FUNC_LIST
Definition: ripper.c:12935
TOK_INTERN
#define TOK_INTERN()
Definition: ripper.c:381
NODE_SELF
@ NODE_SELF
Definition: node.h:115
local_vars::prev
struct local_vars * prev
Definition: ripper.c:221
WARN_EOL
#define WARN_EOL(tok)
Definition: ripper.c:1016
idOR
@ idOR
Definition: rb_mjit_min_header-2.7.2.h:8775
parser_params::lval
YYSTYPE * lval
Definition: ripper.c:273
rb_scan_args
#define rb_scan_args(argc, argvp, fmt,...)
Definition: rb_mjit_min_header-2.7.2.h:6407
rb_parser_set_location_from_strterm_heredoc
YYLTYPE * rb_parser_set_location_from_strterm_heredoc(struct parser_params *p, rb_strterm_heredoc_t *here, YYLTYPE *yylloc)
Definition: ripper.c:17141
EOF
#define EOF
Definition: vsnprintf.c:203
rb_args_info::no_kwarg
unsigned int no_kwarg
Definition: node.h:448
tEMBDOC_BEG
@ tEMBDOC_BEG
Definition: eventids2.c:4
NODE_LVAR
@ NODE_LVAR
Definition: node.h:73
COND_IN_OP
@ COND_IN_OP
Definition: ripper.c:17847
nd_last_loc
#define nd_last_loc(n)
Definition: node.h:209
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition: ripper.c:1484
parser_params::token_seen
unsigned int token_seen
Definition: ripper.c:338
YYDPRINTF
#define YYDPRINTF(Args)
Definition: ripper.c:5188
STR_NEW3
#define STR_NEW3(ptr, len, e, func)
Definition: ripper.c:380
NODE_STR
@ NODE_STR
Definition: node.h:85
rb_str_buf_append
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2950
keyword_super
@ keyword_super
Definition: parse.h:78
U
Definition: dtoa.c:290
rb_parser_get_debug_output
VALUE rb_parser_get_debug_output(VALUE self)
Definition: ripper.c:19327
ISCNTRL
#define ISCNTRL(c)
Definition: ruby.h:2315
str_xquote
@ str_xquote
Definition: ripper.c:12942
RCOMPLEX
#define RCOMPLEX(obj)
Definition: internal.h:811
keyword_BEGIN
@ keyword_BEGIN
Definition: parse.h:93
parser_params::ptr
long ptr
Definition: ripper.c:287
call
return cc call
Definition: rb_mjit_min_header-2.7.2.h:13297
NEW_SCLASS
#define NEW_SCLASS(r, b, loc)
Definition: node.h:365
MBCLEN_CHARFOUND_P
#define MBCLEN_CHARFOUND_P(ret)
Definition: encoding.h:191
tSTRING_DBEG
@ tSTRING_DBEG
Definition: parse.h:161
RARRAY_LEN
#define RARRAY_LEN(a)
Definition: ruby.h:1070
st_foreach
int st_foreach(st_table *tab, st_foreach_callback_func *func, st_data_t arg)
Definition: st.c:1718
END
#define END(name)
Definition: asm.h:115
rb_rational_new
VALUE rb_rational_new(VALUE, VALUE)
Definition: rational.c:1945
iseq_label_data
Definition: compile.c:62
idFWD_KWREST
#define idFWD_KWREST
Definition: ripper.c:697
NODE_IVAR
@ NODE_IVAR
Definition: node.h:76
tHEREDOC_BEG
@ tHEREDOC_BEG
Definition: eventids2.c:7
COND_IN_COND
@ COND_IN_COND
Definition: ripper.c:17848
NEW_OP_ASGN1
#define NEW_OP_ASGN1(p, id, a, loc)
Definition: node.h:323
EXPR_CMDARG_bit
@ EXPR_CMDARG_bit
Definition: ripper.c:140
parser_params::lvtbl
struct local_vars * lvtbl
Definition: ripper.c:307
parser_params::lastline
VALUE lastline
Definition: ripper.c:280
rb_cObject
RUBY_EXTERN VALUE rb_cObject
Definition: ruby.h:2010
nd_beg
#define nd_beg
Definition: node.h:261
CMDARG_P
#define CMDARG_P()
Definition: ripper.c:204
parser_params::toksiz
int toksiz
Definition: ripper.c:301
buf
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4322
YY_IGNORE_MAYBE_UNINITIALIZED_END
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: ripper.c:1328
rb_exc_raise
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
Definition: eval.c:668
DVARS_TOPSCOPE
#define DVARS_TOPSCOPE
Definition: ripper.c:248
obj
const VALUE VALUE obj
Definition: rb_mjit_min_header-2.7.2.h:5777
yyerror1
#define yyerror1(loc, msg)
Definition: ripper.c:415
re_pattern_buffer
Definition: onigmo.h:755
T_BIGNUM
#define T_BIGNUM
Definition: ruby.h:533
NODE_BEGIN
@ NODE_BEGIN
Definition: node.h:41
TypedData_Get_Struct
#define TypedData_Get_Struct(obj, type, data_type, sval)
Definition: ruby.h:1252
RCOMPLEX_SET_REAL
#define RCOMPLEX_SET_REAL(cmp, r)
Definition: internal.h:814
IS_lex_state_all
#define IS_lex_state_all(ls)
Definition: ripper.c:175
rb_intern2
ID rb_intern2(const char *, long)
Definition: symbol.c:653
str_dsym
@ str_dsym
Definition: ripper.c:12947
rb_enc_str_coderange
int rb_enc_str_coderange(VALUE)
Definition: string.c:657
NEW_ARGSCAT
#define NEW_ARGSCAT(a, b, loc)
Definition: node.h:357
NODE_RETURN
@ NODE_RETURN
Definition: node.h:71
scan_hex
#define scan_hex(s, l, e)
Definition: util.h:55
keyword_and
@ keyword_and
Definition: parse.h:83
NEW_FOR
#define NEW_FOR(i, b, loc)
Definition: node.h:298
internal.h
rb_parser_compile_string
rb_ast_t * rb_parser_compile_string(VALUE vparser, const char *f, VALUE s, int line)
Definition: ripper.c:12872
rb_parser_encoding
VALUE rb_parser_encoding(VALUE vparser)
Definition: ripper.c:19279
rb_magic_comment_length_t
long(* rb_magic_comment_length_t)(struct parser_params *p, const char *name, long len)
Definition: ripper.c:14535
NODE_FALSE
@ NODE_FALSE
Definition: node.h:118
T_ARRAY
#define T_ARRAY
Definition: ruby.h:530
idCOLON2
@ idCOLON2
Definition: id.h:107
rb_strterm_literal_struct::term
long term
Definition: ripper.c:725
NEW_STRTERM
#define NEW_STRTERM(func, term, paren)
Definition: ripper.c:13733
argv
char ** argv
Definition: ruby.c:223
NODE_ONCE
@ NODE_ONCE
Definition: node.h:91
f
#define f
rb_set_errinfo
void rb_set_errinfo(VALUE err)
Sets the current exception ($!) to the given value.
Definition: eval.c:1896
yydebug
#define yydebug
Definition: ripper.c:96
RNode::nd_loc
rb_code_location_t nd_loc
Definition: node.h:172
idOROP
@ idOROP
Definition: id.h:109
YYSTACK_BYTES
#define YYSTACK_BYTES(N)
Definition: ripper.c:1421
rb_strterm_heredoc_struct::length
unsigned length
Definition: ripper.c:742
parser_params::debug_output
VALUE debug_output
Definition: ripper.c:320
YYNTOKENS
#define YYNTOKENS
Definition: ripper.c:1471
keyword_return
@ keyword_return
Definition: parse.h:76
rb_write_error_str
RUBY_EXTERN void rb_write_error_str(VALUE mesg)
Definition: io.c:7936
rb_define_global_const
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:2903
STR_FUNC_LABEL
#define STR_FUNC_LABEL
Definition: ripper.c:12934
ST_CONTINUE
@ ST_CONTINUE
Definition: st.h:99
rb_make_backtrace
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:872
NODE_IASGN
@ NODE_IASGN
Definition: node.h:52
RUBY_SYMBOL_EXPORT_BEGIN
#define RUBY_SYMBOL_EXPORT_BEGIN
Definition: missing.h:48
xmalloc
#define xmalloc
Definition: defines.h:211
xrealloc
#define xrealloc
Definition: defines.h:214
nd_set_first_column
#define nd_set_first_column(n, v)
Definition: node.h:199
set_yylval_num
#define set_yylval_num(x)
Definition: ripper.c:12245
str_sword
@ str_sword
Definition: ripper.c:12944
NEW_VCALL
#define NEW_VCALL(m, loc)
Definition: node.h:350
dispatch_heredoc_end
#define dispatch_heredoc_end(p)
Definition: ripper.c:14249
ENCODING_GET
#define ENCODING_GET(obj)
Definition: encoding.h:62
tSP
@ tSP
Definition: parse.h:114
NEWHEAP
#define NEWHEAP()
Definition: ripper.c:19355
rb_sprintf
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1197
keyword_do
@ keyword_do
Definition: parse.h:72
StringValue
use StringValue() instead")))
NODE_ARGS_AUX
@ NODE_ARGS_AUX
Definition: node.h:93
nd_lit
#define nd_lit
Definition: node.h:244
NEW_CASE3
#define NEW_CASE3(h, b, loc)
Definition: node.h:293
rb_complex_raw
VALUE rb_complex_raw(VALUE x, VALUE y)
Definition: complex.c:1521
rb_str_subseq
VALUE rb_str_subseq(VALUE, long, long)
Definition: string.c:2474
idDot3
@ idDot3
Definition: id.h:80
vtable_free
#define vtable_free(tbl)
Definition: ripper.c:12637
tEQQ
@ tEQQ
Definition: parse.h:120
NUMPARAM_MAX
@ NUMPARAM_MAX
Definition: ripper.c:232
rb_utf8_encoding
rb_encoding * rb_utf8_encoding(void)
Definition: encoding.c:1328
rb_strterm_heredoc_struct::quote
unsigned quote
Definition: ripper.c:744
rb_parser_set_debug_output
VALUE rb_parser_set_debug_output(VALUE self, VALUE output)
Definition: ripper.c:19342
NEW_ARGS_AUX
#define NEW_ARGS_AUX(r, b, loc)
Definition: node.h:353
parser_params::line_count
int line_count
Definition: ripper.c:310
str
char str[HTML_ESCAPE_MAX_LEN+1]
Definition: escape.c:18
NEW_BACK_REF
#define NEW_BACK_REF(n, loc)
Definition: node.h:336
NEW_IASGN
#define NEW_IASGN(v, val, loc)
Definition: node.h:320
nd_first_lineno
#define nd_first_lineno(n)
Definition: node.h:200
keyword_undef
@ keyword_undef
Definition: parse.h:52
parser_params::lex
struct parser_params::@2 lex
EXPR_FNAME_bit
@ EXPR_FNAME_bit
Definition: ripper.c:142
nd_set_last_loc
#define nd_set_last_loc(n, v)
Definition: node.h:210
rb_enc_find_index
int rb_enc_find_index(const char *name)
Definition: encoding.c:693
yyalloc::yyls_alloc
YYLTYPE yyls_alloc
Definition: ripper.c:1413
IS_AFTER_OPERATOR
#define IS_AFTER_OPERATOR()
Definition: ripper.c:13826
src
__inline__ const void *__restrict src
Definition: rb_mjit_min_header-2.7.2.h:2874
RFLOAT
#define RFLOAT(obj)
Definition: internal.h:803
NODE_WHEN
@ NODE_WHEN
Definition: node.h:30
YYTERROR
#define YYTERROR
Definition: ripper.c:5149
NODE_BLOCK_PASS
@ NODE_BLOCK_PASS
Definition: node.h:100
parser_params::prevline
VALUE prevline
Definition: ripper.c:279
mixed_error
#define mixed_error(enc1, enc2)
NODE_MATCH
@ NODE_MATCH
Definition: node.h:81
memcpy
void * memcpy(void *__restrict, const void *__restrict, size_t)
set_yylval_literal
#define set_yylval_literal(x)
Definition: ripper.c:12240
RUBY_TYPED_FREE_IMMEDIATELY
#define RUBY_TYPED_FREE_IMMEDIATELY
Definition: ruby.h:1207
STATIC_ID2SYM
#define STATIC_ID2SYM(id)
Definition: symbol.h:18
YYMAXDEPTH
#define YYMAXDEPTH
Definition: ripper.c:5369
nd_1st
#define nd_1st
Definition: node.h:225
ENC_CODERANGE_7BIT
#define ENC_CODERANGE_7BIT
Definition: encoding.h:104
COND_P
#define COND_P()
Definition: ripper.c:197
MEMCPY
#define MEMCPY(p1, p2, type, n)
Definition: ruby.h:1753
keyword_until
@ keyword_until
Definition: parse.h:65
NEW_OP_ASGN_AND
#define NEW_OP_ASGN_AND(i, val, loc)
Definition: node.h:327
parser_params::tokidx
int tokidx
Definition: ripper.c:300
keyword_for
@ keyword_for
Definition: parse.h:66
rb_parser_set_context
VALUE rb_parser_set_context(VALUE vparser, const struct rb_iseq_struct *base, int main)
Definition: ripper.c:19216
path
VALUE path
Definition: rb_mjit_min_header-2.7.2.h:7389
rb_hash_aset
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
Definition: hash.c:2852
rb_io_gets_internal
VALUE rb_io_gets_internal(VALUE io)
Definition: io.c:3579
NO_PARAM
@ NO_PARAM
Definition: ripper.c:231
EXPR_END_bit
@ EXPR_END_bit
Definition: ripper.c:136
keyword_or
@ keyword_or
Definition: parse.h:84
parser_params::error_p
unsigned int error_p
Definition: ripper.c:343
NIL_P
#define NIL_P(v)
Definition: ruby.h:482
rb_strterm_heredoc_struct::sourceline
int sourceline
Definition: ripper.c:734
rb_funcall
#define rb_funcall(recv, mid, argc,...)
Definition: rb_mjit_min_header-2.7.2.h:6620
NEW_FALSE
#define NEW_FALSE(loc)
Definition: node.h:374
nd_else
#define nd_else
Definition: node.h:220
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition: ripper.c:1374
EXPR_ARG_bit
@ EXPR_ARG_bit
Definition: ripper.c:139
va_start
#define va_start(v, l)
Definition: rb_mjit_min_header-2.7.2.h:4013
parser_params::compile_option
VALUE compile_option
Definition: ripper.c:317
STR_FUNC_INDENT
#define STR_FUNC_INDENT
Definition: ripper.c:12933
memmove
#define memmove(dst, src, len)
Definition: rb_mjit_min_header-2.7.2.h:2886
IS_lex_state
#define IS_lex_state(ls)
Definition: ripper.c:174
NEW_WHEN
#define NEW_WHEN(c, t, e, loc)
Definition: node.h:294
argc
int argc
Definition: ruby.c:222
vtable::prev
struct vtable * prev
Definition: ripper.c:211
rb_parser_set_location
YYLTYPE * rb_parser_set_location(struct parser_params *p, YYLTYPE *yylloc)
Definition: ripper.c:17166
rb_warn0
#define rb_warn0(fmt)
Definition: ripper.c:950
parser_params::ruby__end__seen
unsigned int ruby__end__seen
Definition: ripper.c:331
NEW_BREAK
#define NEW_BREAK(s, loc)
Definition: node.h:302
rb_obj_classname
const char * rb_obj_classname(VALUE)
Definition: variable.c:289
rb_strterm_struct
Definition: ripper.c:755
NUM_SUFFIX_I
#define NUM_SUFFIX_I
Definition: ripper.c:14178
keyword_in
@ keyword_in
Definition: parse.h:71
REALLOC_N
#define REALLOC_N(var, type, n)
Definition: ruby.h:1667
rb_code_location_struct::beg_pos
rb_code_position_t beg_pos
Definition: node.h:136
rb_define_const
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:2891
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: ripper.c:5337
tBACK_REF
@ tBACK_REF
Definition: parse.h:111
NEW_EVSTR
#define NEW_EVSTR(n, loc)
Definition: node.h:346
free
#define free(x)
Definition: dln.c:52
tSTRING_DVAR
@ tSTRING_DVAR
Definition: parse.h:162
YYSTYPE::id
ID id
Definition: parse.h:179
STR_FUNC_REGEXP
#define STR_FUNC_REGEXP
Definition: ripper.c:12930
NEW_WHILE
#define NEW_WHILE(c, b, n, loc)
Definition: node.h:296
err
int err
Definition: win32.c:135
peekc_n
#define peekc_n(p, n)
Definition: ripper.c:12973
mixed_escape
#define mixed_escape(beg, enc1, enc2)
parser_params::pktbl
st_table * pktbl
Definition: ripper.c:309
EXPR_BEG_ANY
@ EXPR_BEG_ANY
Definition: ripper.c:167
token_info::nonspc
int nonspc
Definition: ripper.c:255
tUMINUS_NUM
@ tUMINUS_NUM
Definition: parse.h:166
NEW_DOT3
#define NEW_DOT3(b, e, loc)
Definition: node.h:370
reg_named_capture_assign_t::parser
struct parser_params * parser
Definition: ripper.c:18921
IS_END
#define IS_END()
Definition: ripper.c:13819
tNEQ
@ tNEQ
Definition: parse.h:121
rb_io_write
VALUE rb_io_write(VALUE, VALUE)
Definition: io.c:1804
tDOT2
@ tDOT2
Definition: parse.h:128
rb_data_type_struct
Definition: ruby.h:1148
BUILTIN_TYPE
#define BUILTIN_TYPE(x)
Definition: ruby.h:551
rb_big_norm
VALUE rb_big_norm(VALUE x)
Definition: bignum.c:3152
RFLOAT_VALUE
#define RFLOAT_VALUE(v)
Definition: ruby.h:966
parser_params::cond_stack
stack_type cond_stack
Definition: ripper.c:298
yyalloc
Definition: ripper.c:1410
YYLTYPE::first_column
int first_column
Definition: parse.h:198
EXPR_DOT_bit
@ EXPR_DOT_bit
Definition: ripper.c:143
NEW_POSTARG
#define NEW_POSTARG(i, v, loc)
Definition: node.h:356
xfree
#define xfree
Definition: defines.h:216
rb_warning0
#define rb_warning0(fmt)
Definition: ripper.c:955
rb_parser_fatal
void rb_parser_fatal(struct parser_params *p, const char *fmt,...)
Definition: ripper.c:17115
stack_type
VALUE stack_type
Definition: ripper.c:183
st_data_t
unsigned long st_data_t
Definition: rb_mjit_min_header-2.7.2.h:5398
RBASIC
#define RBASIC(obj)
Definition: ruby.h:1267
RNode::u2
union RNode::@1 u2
rb_ary_pattern_info::imemo
VALUE imemo
Definition: node.h:458
parser_params::token_info_enabled
unsigned int token_info_enabled
Definition: ripper.c:339
rb_gc_mark
void rb_gc_mark(VALUE ptr)
Definition: gc.c:5215
rb_reg_fragment_setenc
int rb_reg_fragment_setenc(struct parser_params *, VALUE, int)
Definition: ripper.c:18863
rb_ary_new_from_args
#define rb_ary_new_from_args(n,...)
Definition: rb_mjit_min_header-2.7.2.h:7249
local_vars::args
struct vtable * args
Definition: ripper.c:215
ENCODING_SET
#define ENCODING_SET(obj, i)
Definition: encoding.h:60
tDOT3
@ tDOT3
Definition: parse.h:129
rb_strterm_heredoc_struct
Definition: ripper.c:731
INT_MAX
#define INT_MAX
Definition: rb_mjit_min_header-2.7.2.h:4087
rb_compile_warn
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:272
parser_params::cmdarg_stack
stack_type cmdarg_stack
Definition: ripper.c:299
rb_imemo_tmpbuf_auto_free_pointer
#define rb_imemo_tmpbuf_auto_free_pointer()
Definition: internal.h:1239
NODE_YIELD
@ NODE_YIELD
Definition: node.h:72
NEW_DASGN_CURR
#define NEW_DASGN_CURR(v, val, loc)
Definition: node.h:319
Qtrue
#define Qtrue
Definition: ruby.h:468
errno
int errno
rb_str_catf
VALUE rb_str_catf(VALUE str, const char *format,...)
Definition: sprintf.c:1237
parser_params::paren_nest
int paren_nest
Definition: ripper.c:292
lex_goto_eol
#define lex_goto_eol(p)
Definition: ripper.c:12967
is_notop_id
#define is_notop_id(id)
Definition: symbol.h:35
ORDINAL_PARAM
@ ORDINAL_PARAM
Definition: ripper.c:230
YYLLOC_DEFAULT
#define YYLLOC_DEFAULT(Current, Rhs, N)
Definition: ripper.c:108
rb_parser_realloc
void * rb_parser_realloc(struct parser_params *p, void *ptr, size_t size)
Definition: ripper.c:19380
WARN_SPACE_CHAR
#define WARN_SPACE_CHAR(c, prefix)
Definition: ripper.c:13176
v
int VALUE v
Definition: rb_mjit_min_header-2.7.2.h:12380
len
uint8_t len
Definition: escape.c:17
ID_CLASS
#define ID_CLASS
Definition: id.h:38
idCmp
@ idCmp
Definition: id.h:84
SYMBOL_P
#define SYMBOL_P(x)
Definition: ruby.h:413
NEW_CVASGN
#define NEW_CVASGN(v, val, loc)
Definition: node.h:322
NEW_RETURN
#define NEW_RETURN(s, loc)
Definition: node.h:310
rb_enc_prev_char
#define rb_enc_prev_char(s, p, e, enc)
Definition: encoding.h:220
rb_usascii_str_new2
#define rb_usascii_str_new2
Definition: intern.h:909
tLBRACE
@ tLBRACE
Definition: parse.h:145
cc
const struct rb_call_cache * cc
Definition: rb_mjit_min_header-2.7.2.h:13276
YYLTYPE::first_line
int first_line
Definition: parse.h:197
rb_parser_set_location_of_none
YYLTYPE * rb_parser_set_location_of_none(struct parser_params *p, YYLTYPE *yylloc)
Definition: ripper.c:17156
modifier_until
@ modifier_until
Definition: parse.h:89
cond_type
cond_type
Definition: ripper.c:17846
ptrdiff_t
long int ptrdiff_t
Definition: rb_mjit_min_header-2.7.2.h:805
nd_next
#define nd_next
Definition: node.h:216
rb_class_new_instance
VALUE rb_class_new_instance(int, const VALUE *, VALUE)
Allocates and initializes an instance of klass.
Definition: object.c:1955
stderr
#define stderr
Definition: rb_mjit_min_header-2.7.2.h:1522
tBDOT3
@ tBDOT3
Definition: parse.h:131
YYSIZE_T
#define YYSIZE_T
Definition: ripper.c:1261
MEMMOVE
#define MEMMOVE(p1, p2, type, n)
Definition: ruby.h:1754
EXPR_ENDARG_bit
@ EXPR_ENDARG_bit
Definition: ripper.c:137
tCVAR
@ tCVAR
Definition: parse.h:103
EXPR_MID_bit
@ EXPR_MID_bit
Definition: ripper.c:141
EXPR_END_ANY
@ EXPR_END_ANY
Definition: ripper.c:169
magic_comment::func
rb_magic_comment_setter_t func
Definition: ripper.c:14603
NODE_SPECIAL_NO_NAME_REST
#define NODE_SPECIAL_NO_NAME_REST
Definition: node.h:383
ERANGE
#define ERANGE
Definition: rb_mjit_min_header-2.7.2.h:11019
LONG2FIX
#define LONG2FIX(i)
Definition: ruby.h:265
ifndef_ripper
#define ifndef_ripper(x)
Definition: ripper.c:943
rb_enc_codelen
int rb_enc_codelen(int c, rb_encoding *enc)
Definition: encoding.c:1089
NODE_BACK_REF
@ NODE_BACK_REF
Definition: node.h:80
nd_line
#define nd_line(n)
Definition: node.h:194
rb_intern_str
#define rb_intern_str(string)
Definition: generator.h:16
T_STRING
#define T_STRING
Definition: ruby.h:528
rb_enc_symname_type
int rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset)
Definition: symbol.c:233
NODE_DEFINED
@ NODE_DEFINED
Definition: node.h:120
MAYBE_UNUSED
#define MAYBE_UNUSED
Definition: ffi_common.h:32
SET_LEX_STATE
#define SET_LEX_STATE(ls)
Definition: ripper.c:177
STRTERM_HEREDOC
#define STRTERM_HEREDOC
Definition: ripper.c:753
parser_params
Definition: ripper.c:270
parser_params::eval_tree
NODE * eval_tree
Definition: ripper.c:356
rb_yytnamerr
size_t rb_yytnamerr(struct parser_params *p, char *yyres, const char *yystr)
Definition: ripper.c:19464
tSTAR
@ tSTAR
Definition: parse.h:147
rb_args_info::block_arg
ID block_arg
Definition: node.h:442
keyword_case
@ keyword_case
Definition: parse.h:62
NODE_REQUIRED_KEYWORD_P
#define NODE_REQUIRED_KEYWORD_P(node)
Definition: node.h:382
YYPOPSTACK
#define YYPOPSTACK(N)
rb_const_defined_at
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:2692
rb_warn1
#define rb_warn1(fmt, a)
Definition: ripper.c:951
malloc
void * malloc(size_t) __attribute__((__malloc__)) __attribute__((__warn_unused_result__)) __attribute__((__alloc_size__(1)))
make_list
#define make_list(list, loc)
Definition: ripper.c:567
rb_str_new_cstr
#define rb_str_new_cstr(str)
Definition: rb_mjit_min_header-2.7.2.h:6152
NUMPARAM_IDX_TO_ID
#define NUMPARAM_IDX_TO_ID(idx)
Definition: ripper.c:237
parser_params::enc
rb_encoding * enc
Definition: ripper.c:314
flush_string_content
#define flush_string_content(p, enc)
Definition: ripper.c:13758
YYSTYPE::node
NODE * node
Definition: parse.h:178
rb_ensure
VALUE rb_ensure(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*e_proc)(VALUE), VALUE data2)
An equivalent to ensure clause.
Definition: eval.c:1115
NODE_VALUES
@ NODE_VALUES
Definition: node.h:69
keyword_break
@ keyword_break
Definition: parse.h:67
parser_params::eval_tree_begin
NODE * eval_tree_begin
Definition: ripper.c:355
NODE_FLIP3
@ NODE_FLIP3
Definition: node.h:114
nd_type
#define nd_type(n)
Definition: node.h:188
parser_params::state
enum lex_state_e state
Definition: ripper.c:290
else
else
Definition: rb_mjit_min_header-2.7.2.h:13294
YYSYNTAX_ERROR
#define YYSYNTAX_ERROR
rb_builtin_class_name
const char * rb_builtin_class_name(VALUE x)
Definition: error.c:799
tQWORDS_BEG
@ tQWORDS_BEG
Definition: parse.h:156
is_identchar
#define is_identchar(p, e, enc)
Definition: symbol.c:35
rb_ary_new
VALUE rb_ary_new(void)
Definition: array.c:723
rb_code_location_struct::end_pos
rb_code_position_t end_pos
Definition: node.h:137
YY_INITIAL_VALUE
#define YY_INITIAL_VALUE(Value)
Definition: ripper.c:1324
rb_code_location_struct
Definition: node.h:135
nd_resq
#define nd_resq
Definition: node.h:222
STR_FUNC_ESCAPE
#define STR_FUNC_ESCAPE
Definition: ripper.c:12928
rb_imemo_tmpbuf_struct
Definition: internal.h:1231
rb_ast_body_struct::root
const NODE * root
Definition: node.h:395
NUM2INT
#define NUM2INT(x)
Definition: ruby.h:715
keyword__ENCODING__
@ keyword__ENCODING__
Definition: parse.h:97
Qnil
#define Qnil
Definition: ruby.h:469
rb_str_new
#define rb_str_new(str, len)
Definition: rb_mjit_min_header-2.7.2.h:6151
parser_params::brace_nest
int brace_nest
Definition: ripper.c:296
nd_plen
#define nd_plen
Definition: node.h:249
keyword_yield
@ keyword_yield
Definition: parse.h:77
keyword_nil
@ keyword_nil
Definition: parse.h:80
rb_str_buf_cat
#define rb_str_buf_cat
Definition: intern.h:910
ISXDIGIT
#define ISXDIGIT(c)
Definition: ruby.h:2313
tMATCH
@ tMATCH
Definition: parse.h:126
rb_warn0L
#define rb_warn0L(l, fmt)
Definition: ripper.c:960
token_info::token
const char * token
Definition: ripper.c:252
parser_params::ruby_sourcefile_string
VALUE ruby_sourcefile_string
Definition: ripper.c:313
NODE_REDO
@ NODE_REDO
Definition: node.h:39
nd_brace
#define nd_brace
Definition: node.h:274
st_lookup
int st_lookup(st_table *tab, st_data_t key, st_data_t *value)
Definition: st.c:1101
tIDENTIFIER
@ tIDENTIFIER
Definition: parse.h:98
NEW_COLON2
#define NEW_COLON2(c, i, loc)
Definition: node.h:367
util.h
rb_strterm_heredoc_struct::lastline
VALUE lastline
Definition: ripper.c:732
rb_ary_pattern_info
Definition: node.h:454
NEW_UNTIL
#define NEW_UNTIL(c, b, n, loc)
Definition: node.h:297
EXPR_VALUE
@ EXPR_VALUE
Definition: ripper.c:166
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: ripper.c:1327
strcasecmp
int strcasecmp(const char *, const char *) __attribute__((__pure__))
YYFINAL
#define YYFINAL
Definition: ripper.c:1466
RB_GC_GUARD
#define RB_GC_GUARD(v)
Definition: ruby.h:585
numberof
#define numberof(array)
Definition: etc.c:618
METHOD_NOT
#define METHOD_NOT
Definition: ripper.c:690
RNode::u1
union RNode::@0 u1
rb_str_coderange_scan_restartable
long rb_str_coderange_scan_restartable(const char *, const char *, rb_encoding *, int *)
Definition: string.c:567
rb_strlen_lit
#define rb_strlen_lit(str)
Definition: intern.h:913
tAREF
@ tAREF
Definition: parse.h:132
modifier_if
@ modifier_if
Definition: parse.h:86
parser_params::lpar_beg
int lpar_beg
Definition: ripper.c:294
get_id
#define get_id(id)
Definition: ripper.c:587
RSTRING_LEN
#define RSTRING_LEN(str)
Definition: ruby.h:1005
STR_FUNC_EXPAND
#define STR_FUNC_EXPAND
Definition: ripper.c:12929
char
#define char
Definition: rb_mjit_min_header-2.7.2.h:2916
st_free_table
void st_free_table(st_table *tab)
Definition: st.c:709
NEW_SPLAT
#define NEW_SPLAT(a, loc)
Definition: node.h:359
tIGNORED_NL
@ tIGNORED_NL
Definition: eventids2.c:2
st_table
Definition: st.h:79
TAB_WIDTH
#define TAB_WIDTH
Definition: ripper.c:94
str_regexp
@ str_regexp
Definition: ripper.c:12943
rb_strterm_struct::heredoc
rb_strterm_heredoc_t heredoc
Definition: ripper.c:759
rb_strterm_literal_struct::func
long func
Definition: ripper.c:717
nd_2nd
#define nd_2nd
Definition: node.h:226
rb_args_info::rest_arg
ID rest_arg
Definition: node.h:441
tRPAREN
@ tRPAREN
Definition: parse.h:143
ID_CONST
#define ID_CONST
Definition: id.h:37
rb_define_private_method
void rb_define_private_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1569
parser_params::tokline
int tokline
Definition: ripper.c:302
parser_params::node_id
int node_id
Definition: ripper.c:325
NEW_CASE2
#define NEW_CASE2(b, loc)
Definition: node.h:292
rb_enc_isspace
#define rb_enc_isspace(c, enc)
Definition: encoding.h:237
NEW_VALIAS
#define NEW_VALIAS(n, o, loc)
Definition: node.h:362
local_vars::used
struct vtable * used
Definition: ripper.c:217
NODE_SCOPE
@ NODE_SCOPE
Definition: node.h:23
idNeqTilde
@ idNeqTilde
Definition: id.h:104
NEW_DVAR
#define NEW_DVAR(v, loc)
Definition: node.h:331
yylval
#define yylval
Definition: ripper.c:12221
NODE_RETRY
@ NODE_RETRY
Definition: node.h:40
rb_enc_str_new
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
Definition: string.c:796
NODE_LIST
@ NODE_LIST
Definition: node.h:67
dyna_var
#define dyna_var(p, id)
Definition: ripper.c:677
rb_str_cat
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:2812
rb_enc_associate
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
Definition: encoding.c:866
tINTEGER
@ tINTEGER
Definition: parse.h:105
RREGEXP_PTR
#define RREGEXP_PTR(r)
Definition: ruby.h:1118
rb_reg_check_preprocess
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2707
ENC_CODERANGE_UNKNOWN
#define ENC_CODERANGE_UNKNOWN
Definition: encoding.h:103
rb_define_alloc_func
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
IS_SPCARG
#define IS_SPCARG(c)
Definition: ripper.c:13821
keyword_elsif
@ keyword_elsif
Definition: parse.h:60
parser_params::in_class
unsigned int in_class
Definition: ripper.c:337
RTEST
#define RTEST(v)
Definition: ruby.h:481
ruby::backward::cxxanyargs::type
VALUE type(ANYARGS)
ANYARGS-ed function type.
Definition: cxxanyargs.hpp:39
SYM2ID
#define SYM2ID(x)
Definition: ruby.h:415
STR_NEW0
#define STR_NEW0()
Definition: ripper.c:378
main
int main(void)
Definition: closure_fn0.c:49
strcmp
int strcmp(const char *, const char *)
RNode
Definition: node.h:149
__sFILE
Definition: vsnprintf.c:169
tUMINUS
@ tUMINUS
Definition: parse.h:116
rb_enc_associate_index
VALUE rb_enc_associate_index(VALUE obj, int idx)
Definition: encoding.c:838
NEW_FCALL
#define NEW_FCALL(m, a, loc)
Definition: node.h:349
rb_usascii_encoding
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1340
rb_dvar_defined
int rb_dvar_defined(ID id, const rb_iseq_t *iseq)
Definition: compile.c:9357
RSTRING_END
#define RSTRING_END(str)
Definition: ruby.h:1013
str_ssym
@ str_ssym
Definition: ripper.c:12946
STR_NEW
#define STR_NEW(ptr, len)
Definition: ripper.c:377
tLOWEST
@ tLOWEST
Definition: parse.h:165
rb_warning1
#define rb_warning1(fmt, a)
Definition: ripper.c:956
name
const char * name
Definition: nkf.c:208
dispatch_scan_event
#define dispatch_scan_event(p, t)
Definition: ripper.c:12269
NODE_GASGN
@ NODE_GASGN
Definition: node.h:51
RNode::u3
union RNode::@2 u3
n
const char size_t n
Definition: rb_mjit_min_header-2.7.2.h:5491
COND_POP
#define COND_POP()
Definition: ripper.c:196