Ruby  2.7.1p83(2020-03-31revisiona0c7c23c9cec0d0ffcba012279cd652d28ad5bf3)
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),
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 {
225  } numparam;
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;
257 } token_info;
258 
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_;
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 0
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 978 "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, 1176, 1176, 1176, 1202, 1208, 1215, 1222, 1229, 1235,
1534  1236, 1242, 1255, 1253, 1264, 1275, 1281, 1288, 1295, 1302,
1535  1308, 1313, 1312, 1322, 1322, 1329, 1336, 1346, 1354, 1361,
1536  1369, 1377, 1389, 1401, 1411, 1425, 1426, 1434, 1442, 1451,
1537  1458, 1461, 1468, 1475, 1483, 1490, 1497, 1505, 1512, 1522,
1538  1527, 1536, 1539, 1540, 1544, 1548, 1552, 1557, 1564, 1566,
1539  1556, 1574, 1577, 1584, 1584, 1584, 1590, 1591, 1594, 1595,
1540  1604, 1614, 1624, 1633, 1644, 1651, 1658, 1665, 1672, 1680,
1541  1688, 1695, 1702, 1711, 1712, 1721, 1722, 1731, 1738, 1745,
1542  1752, 1759, 1766, 1773, 1780, 1787, 1794, 1803, 1804, 1813,
1543  1820, 1829, 1836, 1845, 1852, 1859, 1866, 1876, 1883, 1893,
1544  1900, 1907, 1917, 1924, 1931, 1938, 1945, 1952, 1959, 1966,
1545  1973, 1983, 1990, 1993, 2000, 2007, 2016, 2017, 2018, 2019,
1546  2024, 2031, 2038, 2041, 2048, 2048, 2058, 2059, 2060, 2061,
1547  2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071,
1548  2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081,
1549  2082, 2083, 2084, 2085, 2086, 2087, 2090, 2090, 2090, 2091,
1550  2091, 2092, 2092, 2092, 2093, 2093, 2093, 2093, 2094, 2094,
1551  2094, 2094, 2095, 2095, 2095, 2096, 2096, 2096, 2096, 2097,
1552  2097, 2097, 2097, 2098, 2098, 2098, 2098, 2099, 2099, 2099,
1553  2099, 2100, 2100, 2100, 2100, 2101, 2101, 2104, 2111, 2118,
1554  2126, 2134, 2142, 2150, 2158, 2165, 2173, 2182, 2191, 2203,
1555  2215, 2227, 2239, 2243, 2247, 2251, 2255, 2259, 2263, 2267,
1556  2271, 2275, 2279, 2283, 2287, 2291, 2292, 2296, 2300, 2304,
1557  2308, 2312, 2316, 2320, 2324, 2328, 2332, 2336, 2336, 2341,
1558  2350, 2356, 2357, 2358, 2359, 2362, 2366, 2373, 2380, 2381,
1559  2385, 2392, 2401, 2406, 2417, 2424, 2453, 2454, 2457, 2458,
1560  2459, 2463, 2470, 2479, 2487, 2494, 2502, 2510, 2514, 2514,
1561  2551, 2560, 2564, 2570, 2577, 2584, 2591, 2600, 2601, 2604,
1562  2611, 2618, 2627, 2628, 2629, 2630, 2631, 2632, 2633, 2634,
1563  2635, 2636, 2637, 2645, 2644, 2659, 2659, 2666, 2666, 2674,
1564  2682, 2689, 2696, 2703, 2711, 2718, 2725, 2732, 2739, 2739,
1565  2744, 2748, 2752, 2759, 2760, 2769, 2768, 2779, 2790, 2801,
1566  2811, 2822, 2821, 2838, 2837, 2852, 2861, 2909, 2908, 2932,
1567  2931, 2954, 2953, 2977, 2983, 2976, 3003, 3004, 3003, 3029,
1568  3036, 3043, 3050, 3059, 3066, 3072, 3089, 3095, 3101, 3107,
1569  3113, 3119, 3125, 3131, 3137, 3143, 3149, 3155, 3161, 3167,
1570  3182, 3189, 3195, 3202, 3203, 3204, 3207, 3208, 3211, 3212,
1571  3224, 3225, 3234, 3235, 3238, 3246, 3255, 3262, 3271, 3278,
1572  3285, 3292, 3299, 3308, 3316, 3325, 3329, 3333, 3337, 3341,
1573  3347, 3352, 3357, 3361, 3365, 3369, 3373, 3377, 3385, 3389,
1574  3393, 3397, 3401, 3405, 3409, 3413, 3417, 3423, 3424, 3430,
1575  3439, 3451, 3455, 3464, 3466, 3470, 3475, 3481, 3484, 3488,
1576  3492, 3496, 3481, 3520, 3528, 3538, 3543, 3549, 3559, 3573,
1577  3580, 3587, 3596, 3605, 3613, 3621, 3628, 3636, 3644, 3651,
1578  3658, 3671, 3679, 3689, 3690, 3694, 3689, 3711, 3712, 3716,
1579  3711, 3735, 3743, 3750, 3758, 3767, 3779, 3780, 3784, 3790,
1580  3791, 3793, 3794, 3795, 3783, 3808, 3809, 3812, 3813, 3821,
1581  3831, 3832, 3837, 3845, 3849, 3855, 3858, 3867, 3870, 3877,
1582  3880, 3881, 3883, 3884, 3893, 3902, 3907, 3916, 3925, 3930,
1583  3930, 3935, 3941, 3940, 3952, 3957, 3957, 3964, 3973, 3977,
1584  3986, 3990, 3994, 3998, 4002, 4005, 4009, 4018, 4022, 4026,
1585  4030, 4036, 4037, 4046, 4055, 4059, 4063, 4067, 4071, 4075,
1586  4081, 4083, 4092, 4100, 4114, 4115, 4138, 4142, 4148, 4154,
1587  4155, 4164, 4173, 4185, 4197, 4198, 4199, 4200, 4212, 4226,
1588  4227, 4228, 4229, 4230, 4231, 4232, 4233, 4234, 4242, 4241,
1589  4254, 4264, 4277, 4284, 4291, 4300, 4312, 4315, 4322, 4329,
1590  4332, 4336, 4339, 4346, 4349, 4350, 4353, 4370, 4371, 4372,
1591  4381, 4391, 4400, 4406, 4416, 4422, 4431, 4433, 4442, 4452,
1592  4458, 4467, 4476, 4486, 4492, 4502, 4508, 4518, 4528, 4547,
1593  4553, 4563, 4573, 4614, 4617, 4616, 4633, 4637, 4642, 4646,
1594  4650, 4632, 4671, 4678, 4685, 4692, 4695, 4696, 4699, 4709,
1595  4710, 4711, 4712, 4715, 4725, 4726, 4736, 4737, 4738, 4739,
1596  4742, 4743, 4744, 4745, 4746, 4749, 4750, 4751, 4752, 4753,
1597  4754, 4755, 4758, 4771, 4780, 4787, 4796, 4797, 4801, 4800,
1598  4810, 4818, 4827, 4842, 4842, 4856, 4860, 4864, 4868, 4872,
1599  4878, 4883, 4888, 4892, 4896, 4900, 4904, 4908, 4912, 4916,
1600  4920, 4924, 4928, 4932, 4936, 4940, 4945, 4951, 4960, 4968,
1601  4976, 4984, 4994, 4995, 5003, 5012, 5020, 5041, 5043, 5056,
1602  5066, 5074, 5084, 5091, 5100, 5107, 5117, 5124, 5133, 5134,
1603  5137, 5145, 5153, 5163, 5173, 5183, 5190, 5199, 5206, 5215,
1604  5216, 5219, 5227, 5237, 5238, 5241, 5251, 5255, 5261, 5266,
1605  5266, 5290, 5291, 5300, 5302, 5325, 5336, 5343, 5351, 5370,
1606  5371, 5372, 5375, 5376, 5377, 5378, 5381, 5382, 5383, 5386,
1607  5387, 5390, 5391, 5394, 5395, 5398, 5399, 5402, 5403, 5406,
1608  5409, 5412, 5415, 5416, 5417, 5420, 5421, 5424, 5425, 5429
1609 };
1610 #endif
1611 
1612 #if YYDEBUG || YYERROR_VERBOSE || 0
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 974 "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 1176 "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 1181 "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 1203 "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 1209 "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 1216 "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 1223 "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 1230 "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 1237 "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 1243 "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 1255 "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 1258 "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 1267 "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 1276 "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 1282 "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 1289 "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 1296 "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 1303 "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 1309 "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 1313 "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 1317 "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 1322 "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 1323 "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 1330 "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 1337 "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 1347 "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 1355 "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 1362 "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 1370 "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 1378 "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 1390 "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 1402 "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 1412 "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 1427 "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 1435 "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 1443 "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 1452 "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 1462 "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 1469 "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 1476 "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 1484 "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 1491 "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 1498 "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 1506 "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 1513 "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 1523 "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 1528 "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 1541 "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 1545 "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 1549 "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 1553 "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 1557 "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 1564 "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 1566 "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 1567 "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 1578 "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 1584 "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 1584 "ripper.y" /* yacc.c:1646 */
6506  {COND_POP();}
6507 #line 6503 "ripper.c" /* yacc.c:1646 */
6508  break;
6509 
6510  case 65:
6511 #line 1585 "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 1596 "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 1605 "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 1615 "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 1625 "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 1634 "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 1645 "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 1652 "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 1659 "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 1666 "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 1673 "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 1681 "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 1689 "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 1696 "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 1703 "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 1713 "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 1723 "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 1732 "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 1739 "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 1746 "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 1753 "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 1760 "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 1767 "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 1774 "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 1781 "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 1788 "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 1795 "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 1805 "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 1814 "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 1821 "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 1830 "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 1837 "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 1846 "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 1853 "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 1860 "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 1867 "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 1877 "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 1884 "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 1894 "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 1901 "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 1908 "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 1918 "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 1925 "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 1932 "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 1939 "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 1946 "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 1953 "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 1960 "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 1967 "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 1974 "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 1984 "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 1994 "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 2001 "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 2008 "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 2020 "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 130:
7129 #line 2025 "ripper.y" /* yacc.c:1646 */
7130  {
7131  SET_LEX_STATE(EXPR_ENDFN);
7132  (yyval.val) = (yyvsp[0].val);
7133  }
7134 #line 7130 "ripper.c" /* yacc.c:1646 */
7135  break;
7136 
7137  case 131:
7138 #line 2032 "ripper.y" /* yacc.c:1646 */
7139  {
7140 #if 0
7141  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[0].val)), &(yyloc));
7142 #endif
7143  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(symbol_literal,v1);(yyval.val)=v2;}
7144  }
7145 #line 7141 "ripper.c" /* yacc.c:1646 */
7146  break;
7147 
7148  case 133:
7149 #line 2042 "ripper.y" /* yacc.c:1646 */
7150  {
7151 #if 0
7152  (yyval.val) = NEW_UNDEF((yyvsp[0].val), &(yyloc));
7153 #endif
7154  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
7155  }
7156 #line 7152 "ripper.c" /* yacc.c:1646 */
7157  break;
7158 
7159  case 134:
7160 #line 2048 "ripper.y" /* yacc.c:1646 */
7161  {SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);}
7162 #line 7158 "ripper.c" /* yacc.c:1646 */
7163  break;
7164 
7165  case 135:
7166 #line 2049 "ripper.y" /* yacc.c:1646 */
7167  {
7168 #if 0
7169  NODE *undef = NEW_UNDEF((yyvsp[0].val), &(yylsp[0]));
7170  (yyval.val) = block_append(p, (yyvsp[-3].val), undef);
7171 #endif
7172  (yyval.val)=rb_ary_push((yyvsp[-3].val), get_value((yyvsp[0].val)));
7173  }
7174 #line 7170 "ripper.c" /* yacc.c:1646 */
7175  break;
7176 
7177  case 136:
7178 #line 2058 "ripper.y" /* yacc.c:1646 */
7179  { ifndef_ripper((yyval.val) = '|'); }
7180 #line 7176 "ripper.c" /* yacc.c:1646 */
7181  break;
7182 
7183  case 137:
7184 #line 2059 "ripper.y" /* yacc.c:1646 */
7185  { ifndef_ripper((yyval.val) = '^'); }
7186 #line 7182 "ripper.c" /* yacc.c:1646 */
7187  break;
7188 
7189  case 138:
7190 #line 2060 "ripper.y" /* yacc.c:1646 */
7191  { ifndef_ripper((yyval.val) = '&'); }
7192 #line 7188 "ripper.c" /* yacc.c:1646 */
7193  break;
7194 
7195  case 139:
7196 #line 2061 "ripper.y" /* yacc.c:1646 */
7197  { ifndef_ripper((yyval.val) = tCMP); }
7198 #line 7194 "ripper.c" /* yacc.c:1646 */
7199  break;
7200 
7201  case 140:
7202 #line 2062 "ripper.y" /* yacc.c:1646 */
7203  { ifndef_ripper((yyval.val) = tEQ); }
7204 #line 7200 "ripper.c" /* yacc.c:1646 */
7205  break;
7206 
7207  case 141:
7208 #line 2063 "ripper.y" /* yacc.c:1646 */
7209  { ifndef_ripper((yyval.val) = tEQQ); }
7210 #line 7206 "ripper.c" /* yacc.c:1646 */
7211  break;
7212 
7213  case 142:
7214 #line 2064 "ripper.y" /* yacc.c:1646 */
7215  { ifndef_ripper((yyval.val) = tMATCH); }
7216 #line 7212 "ripper.c" /* yacc.c:1646 */
7217  break;
7218 
7219  case 143:
7220 #line 2065 "ripper.y" /* yacc.c:1646 */
7221  { ifndef_ripper((yyval.val) = tNMATCH); }
7222 #line 7218 "ripper.c" /* yacc.c:1646 */
7223  break;
7224 
7225  case 144:
7226 #line 2066 "ripper.y" /* yacc.c:1646 */
7227  { ifndef_ripper((yyval.val) = '>'); }
7228 #line 7224 "ripper.c" /* yacc.c:1646 */
7229  break;
7230 
7231  case 145:
7232 #line 2067 "ripper.y" /* yacc.c:1646 */
7233  { ifndef_ripper((yyval.val) = tGEQ); }
7234 #line 7230 "ripper.c" /* yacc.c:1646 */
7235  break;
7236 
7237  case 146:
7238 #line 2068 "ripper.y" /* yacc.c:1646 */
7239  { ifndef_ripper((yyval.val) = '<'); }
7240 #line 7236 "ripper.c" /* yacc.c:1646 */
7241  break;
7242 
7243  case 147:
7244 #line 2069 "ripper.y" /* yacc.c:1646 */
7245  { ifndef_ripper((yyval.val) = tLEQ); }
7246 #line 7242 "ripper.c" /* yacc.c:1646 */
7247  break;
7248 
7249  case 148:
7250 #line 2070 "ripper.y" /* yacc.c:1646 */
7251  { ifndef_ripper((yyval.val) = tNEQ); }
7252 #line 7248 "ripper.c" /* yacc.c:1646 */
7253  break;
7254 
7255  case 149:
7256 #line 2071 "ripper.y" /* yacc.c:1646 */
7257  { ifndef_ripper((yyval.val) = tLSHFT); }
7258 #line 7254 "ripper.c" /* yacc.c:1646 */
7259  break;
7260 
7261  case 150:
7262 #line 2072 "ripper.y" /* yacc.c:1646 */
7263  { ifndef_ripper((yyval.val) = tRSHFT); }
7264 #line 7260 "ripper.c" /* yacc.c:1646 */
7265  break;
7266 
7267  case 151:
7268 #line 2073 "ripper.y" /* yacc.c:1646 */
7269  { ifndef_ripper((yyval.val) = '+'); }
7270 #line 7266 "ripper.c" /* yacc.c:1646 */
7271  break;
7272 
7273  case 152:
7274 #line 2074 "ripper.y" /* yacc.c:1646 */
7275  { ifndef_ripper((yyval.val) = '-'); }
7276 #line 7272 "ripper.c" /* yacc.c:1646 */
7277  break;
7278 
7279  case 153:
7280 #line 2075 "ripper.y" /* yacc.c:1646 */
7281  { ifndef_ripper((yyval.val) = '*'); }
7282 #line 7278 "ripper.c" /* yacc.c:1646 */
7283  break;
7284 
7285  case 154:
7286 #line 2076 "ripper.y" /* yacc.c:1646 */
7287  { ifndef_ripper((yyval.val) = '*'); }
7288 #line 7284 "ripper.c" /* yacc.c:1646 */
7289  break;
7290 
7291  case 155:
7292 #line 2077 "ripper.y" /* yacc.c:1646 */
7293  { ifndef_ripper((yyval.val) = '/'); }
7294 #line 7290 "ripper.c" /* yacc.c:1646 */
7295  break;
7296 
7297  case 156:
7298 #line 2078 "ripper.y" /* yacc.c:1646 */
7299  { ifndef_ripper((yyval.val) = '%'); }
7300 #line 7296 "ripper.c" /* yacc.c:1646 */
7301  break;
7302 
7303  case 157:
7304 #line 2079 "ripper.y" /* yacc.c:1646 */
7305  { ifndef_ripper((yyval.val) = tPOW); }
7306 #line 7302 "ripper.c" /* yacc.c:1646 */
7307  break;
7308 
7309  case 158:
7310 #line 2080 "ripper.y" /* yacc.c:1646 */
7311  { ifndef_ripper((yyval.val) = tDSTAR); }
7312 #line 7308 "ripper.c" /* yacc.c:1646 */
7313  break;
7314 
7315  case 159:
7316 #line 2081 "ripper.y" /* yacc.c:1646 */
7317  { ifndef_ripper((yyval.val) = '!'); }
7318 #line 7314 "ripper.c" /* yacc.c:1646 */
7319  break;
7320 
7321  case 160:
7322 #line 2082 "ripper.y" /* yacc.c:1646 */
7323  { ifndef_ripper((yyval.val) = '~'); }
7324 #line 7320 "ripper.c" /* yacc.c:1646 */
7325  break;
7326 
7327  case 161:
7328 #line 2083 "ripper.y" /* yacc.c:1646 */
7329  { ifndef_ripper((yyval.val) = tUPLUS); }
7330 #line 7326 "ripper.c" /* yacc.c:1646 */
7331  break;
7332 
7333  case 162:
7334 #line 2084 "ripper.y" /* yacc.c:1646 */
7335  { ifndef_ripper((yyval.val) = tUMINUS); }
7336 #line 7332 "ripper.c" /* yacc.c:1646 */
7337  break;
7338 
7339  case 163:
7340 #line 2085 "ripper.y" /* yacc.c:1646 */
7341  { ifndef_ripper((yyval.val) = tAREF); }
7342 #line 7338 "ripper.c" /* yacc.c:1646 */
7343  break;
7344 
7345  case 164:
7346 #line 2086 "ripper.y" /* yacc.c:1646 */
7347  { ifndef_ripper((yyval.val) = tASET); }
7348 #line 7344 "ripper.c" /* yacc.c:1646 */
7349  break;
7350 
7351  case 165:
7352 #line 2087 "ripper.y" /* yacc.c:1646 */
7353  { ifndef_ripper((yyval.val) = '`'); }
7354 #line 7350 "ripper.c" /* yacc.c:1646 */
7355  break;
7356 
7357  case 207:
7358 #line 2105 "ripper.y" /* yacc.c:1646 */
7359  {
7360 #if 0
7361  (yyval.val) = node_assign(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
7362 #endif
7363  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(assign,v1,v2);(yyval.val)=v3;}
7364  }
7365 #line 7361 "ripper.c" /* yacc.c:1646 */
7366  break;
7367 
7368  case 208:
7369 #line 2112 "ripper.y" /* yacc.c:1646 */
7370  {
7371 #if 0
7372  (yyval.val) = new_op_assign(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7373 #endif
7374  {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;}
7375  }
7376 #line 7372 "ripper.c" /* yacc.c:1646 */
7377  break;
7378 
7379  case 209:
7380 #line 2119 "ripper.y" /* yacc.c:1646 */
7381  {
7382 #if 0
7383  value_expr((yyvsp[0].val));
7384  (yyval.val) = new_ary_op_assign(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-3]), &(yyloc));
7385 #endif
7386  {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;}
7387  }
7388 #line 7384 "ripper.c" /* yacc.c:1646 */
7389  break;
7390 
7391  case 210:
7392 #line 2127 "ripper.y" /* yacc.c:1646 */
7393  {
7394 #if 0
7395  value_expr((yyvsp[0].val));
7396  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), (yyvsp[-3].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7397 #endif
7398  {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;}
7399  }
7400 #line 7396 "ripper.c" /* yacc.c:1646 */
7401  break;
7402 
7403  case 211:
7404 #line 2135 "ripper.y" /* yacc.c:1646 */
7405  {
7406 #if 0
7407  value_expr((yyvsp[0].val));
7408  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), (yyvsp[-3].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7409 #endif
7410  {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;}
7411  }
7412 #line 7408 "ripper.c" /* yacc.c:1646 */
7413  break;
7414 
7415  case 212:
7416 #line 2143 "ripper.y" /* yacc.c:1646 */
7417  {
7418 #if 0
7419  value_expr((yyvsp[0].val));
7420  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), ID2VAL(idCOLON2), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7421 #endif
7422  {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;}
7423  }
7424 #line 7420 "ripper.c" /* yacc.c:1646 */
7425  break;
7426 
7427  case 213:
7428 #line 2151 "ripper.y" /* yacc.c:1646 */
7429  {
7430 #if 0
7431  YYLTYPE loc = code_loc_gen(&(yylsp[-4]), &(yylsp[-2]));
7432  (yyval.val) = new_const_op_assign(p, NEW_COLON2((yyvsp[-4].val), (yyvsp[-2].val), &loc), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7433 #endif
7434  {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;}
7435  }
7436 #line 7432 "ripper.c" /* yacc.c:1646 */
7437  break;
7438 
7439  case 214:
7440 #line 2159 "ripper.y" /* yacc.c:1646 */
7441  {
7442 #if 0
7443  (yyval.val) = new_const_op_assign(p, NEW_COLON3((yyvsp[-2].val), &(yyloc)), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7444 #endif
7445  {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;}
7446  }
7447 #line 7443 "ripper.c" /* yacc.c:1646 */
7448  break;
7449 
7450  case 215:
7451 #line 2166 "ripper.y" /* yacc.c:1646 */
7452  {
7453 #if 0
7454  rb_backref_error(p, (yyvsp[-2].val));
7455  (yyval.val) = NEW_BEGIN(0, &(yyloc));
7456 #endif
7457  {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);
7458  }
7459 #line 7455 "ripper.c" /* yacc.c:1646 */
7460  break;
7461 
7462  case 216:
7463 #line 2174 "ripper.y" /* yacc.c:1646 */
7464  {
7465 #if 0
7466  value_expr((yyvsp[-2].val));
7467  value_expr((yyvsp[0].val));
7468  (yyval.val) = NEW_DOT2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
7469 #endif
7470  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
7471  }
7472 #line 7468 "ripper.c" /* yacc.c:1646 */
7473  break;
7474 
7475  case 217:
7476 #line 2183 "ripper.y" /* yacc.c:1646 */
7477  {
7478 #if 0
7479  value_expr((yyvsp[-2].val));
7480  value_expr((yyvsp[0].val));
7481  (yyval.val) = NEW_DOT3((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
7482 #endif
7483  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
7484  }
7485 #line 7481 "ripper.c" /* yacc.c:1646 */
7486  break;
7487 
7488  case 218:
7489 #line 2192 "ripper.y" /* yacc.c:1646 */
7490  {
7491 #if 0
7492  YYLTYPE loc;
7493  loc.beg_pos = (yylsp[0]).end_pos;
7494  loc.end_pos = (yylsp[0]).end_pos;
7495 
7496  value_expr((yyvsp[-1].val));
7497  (yyval.val) = NEW_DOT2((yyvsp[-1].val), new_nil(&loc), &(yyloc));
7498 #endif
7499  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
7500  }
7501 #line 7497 "ripper.c" /* yacc.c:1646 */
7502  break;
7503 
7504  case 219:
7505 #line 2204 "ripper.y" /* yacc.c:1646 */
7506  {
7507 #if 0
7508  YYLTYPE loc;
7509  loc.beg_pos = (yylsp[0]).end_pos;
7510  loc.end_pos = (yylsp[0]).end_pos;
7511 
7512  value_expr((yyvsp[-1].val));
7513  (yyval.val) = NEW_DOT3((yyvsp[-1].val), new_nil(&loc), &(yyloc));
7514 #endif
7515  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
7516  }
7517 #line 7513 "ripper.c" /* yacc.c:1646 */
7518  break;
7519 
7520  case 220:
7521 #line 2216 "ripper.y" /* yacc.c:1646 */
7522  {
7523 #if 0
7524  YYLTYPE loc;
7525  loc.beg_pos = (yylsp[-1]).beg_pos;
7526  loc.end_pos = (yylsp[-1]).beg_pos;
7527 
7528  value_expr((yyvsp[0].val));
7529  (yyval.val) = NEW_DOT2(new_nil(&loc), (yyvsp[0].val), &(yyloc));
7530 #endif
7531  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[0].val);v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
7532  }
7533 #line 7529 "ripper.c" /* yacc.c:1646 */
7534  break;
7535 
7536  case 221:
7537 #line 2228 "ripper.y" /* yacc.c:1646 */
7538  {
7539 #if 0
7540  YYLTYPE loc;
7541  loc.beg_pos = (yylsp[-1]).beg_pos;
7542  loc.end_pos = (yylsp[-1]).beg_pos;
7543 
7544  value_expr((yyvsp[0].val));
7545  (yyval.val) = NEW_DOT3(new_nil(&loc), (yyvsp[0].val), &(yyloc));
7546 #endif
7547  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[0].val);v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
7548  }
7549 #line 7545 "ripper.c" /* yacc.c:1646 */
7550  break;
7551 
7552  case 222:
7553 #line 2240 "ripper.y" /* yacc.c:1646 */
7554  {
7555  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '+', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7556  }
7557 #line 7553 "ripper.c" /* yacc.c:1646 */
7558  break;
7559 
7560  case 223:
7561 #line 2244 "ripper.y" /* yacc.c:1646 */
7562  {
7563  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '-', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7564  }
7565 #line 7561 "ripper.c" /* yacc.c:1646 */
7566  break;
7567 
7568  case 224:
7569 #line 2248 "ripper.y" /* yacc.c:1646 */
7570  {
7571  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '*', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7572  }
7573 #line 7569 "ripper.c" /* yacc.c:1646 */
7574  break;
7575 
7576  case 225:
7577 #line 2252 "ripper.y" /* yacc.c:1646 */
7578  {
7579  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '/', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7580  }
7581 #line 7577 "ripper.c" /* yacc.c:1646 */
7582  break;
7583 
7584  case 226:
7585 #line 2256 "ripper.y" /* yacc.c:1646 */
7586  {
7587  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '%', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7588  }
7589 #line 7585 "ripper.c" /* yacc.c:1646 */
7590  break;
7591 
7592  case 227:
7593 #line 2260 "ripper.y" /* yacc.c:1646 */
7594  {
7595  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idPow, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7596  }
7597 #line 7593 "ripper.c" /* yacc.c:1646 */
7598  break;
7599 
7600  case 228:
7601 #line 2264 "ripper.y" /* yacc.c:1646 */
7602  {
7603  (yyval.val) = call_uni_op(p, call_bin_op(p, (yyvsp[-2].val), idPow, (yyvsp[0].val), &(yylsp[-2]), &(yyloc)), idUMinus, &(yylsp[-3]), &(yyloc));
7604  }
7605 #line 7601 "ripper.c" /* yacc.c:1646 */
7606  break;
7607 
7608  case 229:
7609 #line 2268 "ripper.y" /* yacc.c:1646 */
7610  {
7611  (yyval.val) = call_uni_op(p, (yyvsp[0].val), idUPlus, &(yylsp[-1]), &(yyloc));
7612  }
7613 #line 7609 "ripper.c" /* yacc.c:1646 */
7614  break;
7615 
7616  case 230:
7617 #line 2272 "ripper.y" /* yacc.c:1646 */
7618  {
7619  (yyval.val) = call_uni_op(p, (yyvsp[0].val), idUMinus, &(yylsp[-1]), &(yyloc));
7620  }
7621 #line 7617 "ripper.c" /* yacc.c:1646 */
7622  break;
7623 
7624  case 231:
7625 #line 2276 "ripper.y" /* yacc.c:1646 */
7626  {
7627  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '|', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7628  }
7629 #line 7625 "ripper.c" /* yacc.c:1646 */
7630  break;
7631 
7632  case 232:
7633 #line 2280 "ripper.y" /* yacc.c:1646 */
7634  {
7635  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '^', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7636  }
7637 #line 7633 "ripper.c" /* yacc.c:1646 */
7638  break;
7639 
7640  case 233:
7641 #line 2284 "ripper.y" /* yacc.c:1646 */
7642  {
7643  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '&', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7644  }
7645 #line 7641 "ripper.c" /* yacc.c:1646 */
7646  break;
7647 
7648  case 234:
7649 #line 2288 "ripper.y" /* yacc.c:1646 */
7650  {
7651  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idCmp, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7652  }
7653 #line 7649 "ripper.c" /* yacc.c:1646 */
7654  break;
7655 
7656  case 236:
7657 #line 2293 "ripper.y" /* yacc.c:1646 */
7658  {
7659  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idEq, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7660  }
7661 #line 7657 "ripper.c" /* yacc.c:1646 */
7662  break;
7663 
7664  case 237:
7665 #line 2297 "ripper.y" /* yacc.c:1646 */
7666  {
7667  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idEqq, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7668  }
7669 #line 7665 "ripper.c" /* yacc.c:1646 */
7670  break;
7671 
7672  case 238:
7673 #line 2301 "ripper.y" /* yacc.c:1646 */
7674  {
7675  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idNeq, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7676  }
7677 #line 7673 "ripper.c" /* yacc.c:1646 */
7678  break;
7679 
7680  case 239:
7681 #line 2305 "ripper.y" /* yacc.c:1646 */
7682  {
7683  (yyval.val) = match_op(p, (yyvsp[-2].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7684  }
7685 #line 7681 "ripper.c" /* yacc.c:1646 */
7686  break;
7687 
7688  case 240:
7689 #line 2309 "ripper.y" /* yacc.c:1646 */
7690  {
7691  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idNeqTilde, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7692  }
7693 #line 7689 "ripper.c" /* yacc.c:1646 */
7694  break;
7695 
7696  case 241:
7697 #line 2313 "ripper.y" /* yacc.c:1646 */
7698  {
7699  (yyval.val) = call_uni_op(p, method_cond(p, (yyvsp[0].val), &(yylsp[0])), '!', &(yylsp[-1]), &(yyloc));
7700  }
7701 #line 7697 "ripper.c" /* yacc.c:1646 */
7702  break;
7703 
7704  case 242:
7705 #line 2317 "ripper.y" /* yacc.c:1646 */
7706  {
7707  (yyval.val) = call_uni_op(p, (yyvsp[0].val), '~', &(yylsp[-1]), &(yyloc));
7708  }
7709 #line 7705 "ripper.c" /* yacc.c:1646 */
7710  break;
7711 
7712  case 243:
7713 #line 2321 "ripper.y" /* yacc.c:1646 */
7714  {
7715  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idLTLT, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7716  }
7717 #line 7713 "ripper.c" /* yacc.c:1646 */
7718  break;
7719 
7720  case 244:
7721 #line 2325 "ripper.y" /* yacc.c:1646 */
7722  {
7723  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idGTGT, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7724  }
7725 #line 7721 "ripper.c" /* yacc.c:1646 */
7726  break;
7727 
7728  case 245:
7729 #line 2329 "ripper.y" /* yacc.c:1646 */
7730  {
7731  (yyval.val) = logop(p, idANDOP, (yyvsp[-2].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7732  }
7733 #line 7729 "ripper.c" /* yacc.c:1646 */
7734  break;
7735 
7736  case 246:
7737 #line 2333 "ripper.y" /* yacc.c:1646 */
7738  {
7739  (yyval.val) = logop(p, idOROP, (yyvsp[-2].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7740  }
7741 #line 7737 "ripper.c" /* yacc.c:1646 */
7742  break;
7743 
7744  case 247:
7745 #line 2336 "ripper.y" /* yacc.c:1646 */
7746  {p->in_defined = 1;}
7747 #line 7743 "ripper.c" /* yacc.c:1646 */
7748  break;
7749 
7750  case 248:
7751 #line 2337 "ripper.y" /* yacc.c:1646 */
7752  {
7753  p->in_defined = 0;
7754  (yyval.val) = new_defined(p, (yyvsp[0].val), &(yyloc));
7755  }
7756 #line 7752 "ripper.c" /* yacc.c:1646 */
7757  break;
7758 
7759  case 249:
7760 #line 2342 "ripper.y" /* yacc.c:1646 */
7761  {
7762 #if 0
7763  value_expr((yyvsp[-5].val));
7764  (yyval.val) = new_if(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[0].val), &(yyloc));
7765  fixpos((yyval.val), (yyvsp[-5].val));
7766 #endif
7767  {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;}
7768  }
7769 #line 7765 "ripper.c" /* yacc.c:1646 */
7770  break;
7771 
7772  case 250:
7773 #line 2351 "ripper.y" /* yacc.c:1646 */
7774  {
7775  (yyval.val) = (yyvsp[0].val);
7776  }
7777 #line 7773 "ripper.c" /* yacc.c:1646 */
7778  break;
7779 
7780  case 251:
7781 #line 2356 "ripper.y" /* yacc.c:1646 */
7782  {(yyval.val) = '>';}
7783 #line 7779 "ripper.c" /* yacc.c:1646 */
7784  break;
7785 
7786  case 252:
7787 #line 2357 "ripper.y" /* yacc.c:1646 */
7788  {(yyval.val) = '<';}
7789 #line 7785 "ripper.c" /* yacc.c:1646 */
7790  break;
7791 
7792  case 253:
7793 #line 2358 "ripper.y" /* yacc.c:1646 */
7794  {(yyval.val) = idGE;}
7795 #line 7791 "ripper.c" /* yacc.c:1646 */
7796  break;
7797 
7798  case 254:
7799 #line 2359 "ripper.y" /* yacc.c:1646 */
7800  {(yyval.val) = idLE;}
7801 #line 7797 "ripper.c" /* yacc.c:1646 */
7802  break;
7803 
7804  case 255:
7805 #line 2363 "ripper.y" /* yacc.c:1646 */
7806  {
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 256:
7813 #line 2367 "ripper.y" /* yacc.c:1646 */
7814  {
7815  rb_warning1("comparison '%s' after comparison", WARN_ID((yyvsp[-1].val)));
7816  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7817  }
7818 #line 7814 "ripper.c" /* yacc.c:1646 */
7819  break;
7820 
7821  case 257:
7822 #line 2374 "ripper.y" /* yacc.c:1646 */
7823  {
7824  value_expr((yyvsp[0].val));
7825  (yyval.val) = (yyvsp[0].val);
7826  }
7827 #line 7823 "ripper.c" /* yacc.c:1646 */
7828  break;
7829 
7830  case 259:
7831 #line 2382 "ripper.y" /* yacc.c:1646 */
7832  {
7833  (yyval.val) = (yyvsp[-1].val);
7834  }
7835 #line 7831 "ripper.c" /* yacc.c:1646 */
7836  break;
7837 
7838  case 260:
7839 #line 2386 "ripper.y" /* yacc.c:1646 */
7840  {
7841 #if 0
7842  (yyval.val) = (yyvsp[-1].val) ? arg_append(p, (yyvsp[-3].val), new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].val);
7843 #endif
7844  {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;}
7845  }
7846 #line 7842 "ripper.c" /* yacc.c:1646 */
7847  break;
7848 
7849  case 261:
7850 #line 2393 "ripper.y" /* yacc.c:1646 */
7851  {
7852 #if 0
7853  (yyval.val) = (yyvsp[-1].val) ? NEW_LIST(new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yyloc)) : 0;
7854 #endif
7855  {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;}
7856  }
7857 #line 7853 "ripper.c" /* yacc.c:1646 */
7858  break;
7859 
7860  case 262:
7861 #line 2402 "ripper.y" /* yacc.c:1646 */
7862  {
7863  value_expr((yyvsp[0].val));
7864  (yyval.val) = (yyvsp[0].val);
7865  }
7866 #line 7862 "ripper.c" /* yacc.c:1646 */
7867  break;
7868 
7869  case 263:
7870 #line 2407 "ripper.y" /* yacc.c:1646 */
7871  {
7872 #if 0
7873  YYLTYPE loc = code_loc_gen(&(yylsp[-1]), &(yylsp[0]));
7874  value_expr((yyvsp[-2].val));
7875  (yyval.val) = NEW_RESCUE((yyvsp[-2].val), NEW_RESBODY(0, remove_begin((yyvsp[0].val)), 0, &loc), 0, &(yyloc));
7876 #endif
7877  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(rescue_mod,v1,v2);(yyval.val)=v3;}
7878  }
7879 #line 7875 "ripper.c" /* yacc.c:1646 */
7880  break;
7881 
7882  case 264:
7883 #line 2418 "ripper.y" /* yacc.c:1646 */
7884  {
7885 #if 0
7886  (yyval.val) = (yyvsp[-1].val);
7887 #endif
7888  {VALUE v1,v2;v1=escape_Qundef((yyvsp[-1].val));v2=dispatch1(arg_paren,v1);(yyval.val)=v2;}
7889  }
7890 #line 7886 "ripper.c" /* yacc.c:1646 */
7891  break;
7892 
7893  case 265:
7894 #line 2425 "ripper.y" /* yacc.c:1646 */
7895  {
7896  if (!local_id(p, idFWD_REST) ||
7897 #if idFWD_KWREST
7898  !local_id(p, idFWD_KWREST) ||
7899 #endif
7900  !local_id(p, idFWD_BLOCK)) {
7901  compile_error(p, "unexpected ...");
7902  (yyval.val) = Qnone;
7903  }
7904  else {
7905 #if 0
7906  NODE *splat = NEW_SPLAT(NEW_LVAR(idFWD_REST, &(yylsp[-1])), &(yylsp[-1]));
7907 #if idFWD_KWREST
7908  NODE *kwrest = list_append(p, NEW_LIST(0, &(yylsp[-1])), NEW_LVAR(idFWD_KWREST, &(yylsp[-1])));
7909 #endif
7910  NODE *block = NEW_BLOCK_PASS(NEW_LVAR(idFWD_BLOCK, &(yylsp[-1])), &(yylsp[-1]));
7911 #if idFWD_KWREST
7912  (yyval.val) = arg_append(p, splat, new_hash(p, kwrest, &(yylsp[-1])), &(yylsp[-1]));
7913 #else
7914  (yyval.val) = splat;
7915 #endif
7916  (yyval.val) = arg_blk_pass((yyval.val), block);
7917 #endif
7918  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(arg_paren,v1);(yyval.val)=v2;}
7919  }
7920  }
7921 #line 7917 "ripper.c" /* yacc.c:1646 */
7922  break;
7923 
7924  case 270:
7925 #line 2460 "ripper.y" /* yacc.c:1646 */
7926  {
7927  (yyval.val) = (yyvsp[-1].val);
7928  }
7929 #line 7925 "ripper.c" /* yacc.c:1646 */
7930  break;
7931 
7932  case 271:
7933 #line 2464 "ripper.y" /* yacc.c:1646 */
7934  {
7935 #if 0
7936  (yyval.val) = (yyvsp[-1].val) ? arg_append(p, (yyvsp[-3].val), new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].val);
7937 #endif
7938  {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;}
7939  }
7940 #line 7936 "ripper.c" /* yacc.c:1646 */
7941  break;
7942 
7943  case 272:
7944 #line 2471 "ripper.y" /* yacc.c:1646 */
7945  {
7946 #if 0
7947  (yyval.val) = (yyvsp[-1].val) ? NEW_LIST(new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yylsp[-1])) : 0;
7948 #endif
7949  {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;}
7950  }
7951 #line 7947 "ripper.c" /* yacc.c:1646 */
7952  break;
7953 
7954  case 273:
7955 #line 2480 "ripper.y" /* yacc.c:1646 */
7956  {
7957 #if 0
7958  value_expr((yyvsp[0].val));
7959  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
7960 #endif
7961  {VALUE v1,v2,v3,v4;v1=dispatch0(args_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(args_add,v2,v3);(yyval.val)=v4;}
7962  }
7963 #line 7959 "ripper.c" /* yacc.c:1646 */
7964  break;
7965 
7966  case 274:
7967 #line 2488 "ripper.y" /* yacc.c:1646 */
7968  {
7969 #if 0
7970  (yyval.val) = arg_blk_pass((yyvsp[-1].val), (yyvsp[0].val));
7971 #endif
7972  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(args_add_block,v1,v2);(yyval.val)=v3;}
7973  }
7974 #line 7970 "ripper.c" /* yacc.c:1646 */
7975  break;
7976 
7977  case 275:
7978 #line 2495 "ripper.y" /* yacc.c:1646 */
7979  {
7980 #if 0
7981  (yyval.val) = (yyvsp[-1].val) ? NEW_LIST(new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yylsp[-1])) : 0;
7982  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[0].val));
7983 #endif
7984  {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;}
7985  }
7986 #line 7982 "ripper.c" /* yacc.c:1646 */
7987  break;
7988 
7989  case 276:
7990 #line 2503 "ripper.y" /* yacc.c:1646 */
7991  {
7992 #if 0
7993  (yyval.val) = (yyvsp[-1].val) ? arg_append(p, (yyvsp[-3].val), new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].val);
7994  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[0].val));
7995 #endif
7996  {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;}
7997  }
7998 #line 7994 "ripper.c" /* yacc.c:1646 */
7999  break;
8000 
8001  case 277:
8002 #line 2511 "ripper.y" /* yacc.c:1646 */
8003  {{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;}}
8004 #line 8000 "ripper.c" /* yacc.c:1646 */
8005  break;
8006 
8007  case 278:
8008 #line 2514 "ripper.y" /* yacc.c:1646 */
8009  {
8010  /* If call_args starts with a open paren '(' or '[',
8011  * look-ahead reading of the letters calls CMDARG_PUSH(0),
8012  * but the push must be done after CMDARG_PUSH(1).
8013  * So this code makes them consistent by first cancelling
8014  * the premature CMDARG_PUSH(0), doing CMDARG_PUSH(1),
8015  * and finally redoing CMDARG_PUSH(0).
8016  */
8017  int lookahead = 0;
8018  switch (yychar) {
8019  case '(': case tLPAREN: case tLPAREN_ARG: case '[': case tLBRACK:
8020  lookahead = 1;
8021  }
8022  if (lookahead) CMDARG_POP();
8023  CMDARG_PUSH(1);
8024  if (lookahead) CMDARG_PUSH(0);
8025  }
8026 #line 8022 "ripper.c" /* yacc.c:1646 */
8027  break;
8028 
8029  case 279:
8030 #line 2532 "ripper.y" /* yacc.c:1646 */
8031  {
8032  /* call_args can be followed by tLBRACE_ARG (that does CMDARG_PUSH(0) in the lexer)
8033  * but the push must be done after CMDARG_POP() in the parser.
8034  * So this code does CMDARG_POP() to pop 0 pushed by tLBRACE_ARG,
8035  * CMDARG_POP() to pop 1 pushed by command_args,
8036  * and CMDARG_PUSH(0) to restore back the flag set by tLBRACE_ARG.
8037  */
8038  int lookahead = 0;
8039  switch (yychar) {
8040  case tLBRACE_ARG:
8041  lookahead = 1;
8042  }
8043  if (lookahead) CMDARG_POP();
8044  CMDARG_POP();
8045  if (lookahead) CMDARG_PUSH(0);
8046  (yyval.val) = (yyvsp[0].val);
8047  }
8048 #line 8044 "ripper.c" /* yacc.c:1646 */
8049  break;
8050 
8051  case 280:
8052 #line 2552 "ripper.y" /* yacc.c:1646 */
8053  {
8054 #if 0
8055  (yyval.val) = NEW_BLOCK_PASS((yyvsp[0].val), &(yyloc));
8056 #endif
8057  (yyval.val)=(yyvsp[0].val);
8058  }
8059 #line 8055 "ripper.c" /* yacc.c:1646 */
8060  break;
8061 
8062  case 281:
8063 #line 2561 "ripper.y" /* yacc.c:1646 */
8064  {
8065  (yyval.val) = (yyvsp[0].val);
8066  }
8067 #line 8063 "ripper.c" /* yacc.c:1646 */
8068  break;
8069 
8070  case 282:
8071 #line 2565 "ripper.y" /* yacc.c:1646 */
8072  {
8073  (yyval.val) = 0;
8074  }
8075 #line 8071 "ripper.c" /* yacc.c:1646 */
8076  break;
8077 
8078  case 283:
8079 #line 2571 "ripper.y" /* yacc.c:1646 */
8080  {
8081 #if 0
8082  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
8083 #endif
8084  {VALUE v1,v2,v3,v4;v1=dispatch0(args_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(args_add,v2,v3);(yyval.val)=v4;}
8085  }
8086 #line 8082 "ripper.c" /* yacc.c:1646 */
8087  break;
8088 
8089  case 284:
8090 #line 2578 "ripper.y" /* yacc.c:1646 */
8091  {
8092 #if 0
8093  (yyval.val) = NEW_SPLAT((yyvsp[0].val), &(yyloc));
8094 #endif
8095  {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;}
8096  }
8097 #line 8093 "ripper.c" /* yacc.c:1646 */
8098  break;
8099 
8100  case 285:
8101 #line 2585 "ripper.y" /* yacc.c:1646 */
8102  {
8103 #if 0
8104  (yyval.val) = last_arg_append(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
8105 #endif
8106  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(args_add,v1,v2);(yyval.val)=v3;}
8107  }
8108 #line 8104 "ripper.c" /* yacc.c:1646 */
8109  break;
8110 
8111  case 286:
8112 #line 2592 "ripper.y" /* yacc.c:1646 */
8113  {
8114 #if 0
8115  (yyval.val) = rest_arg_append(p, (yyvsp[-3].val), (yyvsp[0].val), &(yyloc));
8116 #endif
8117  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=(yyvsp[0].val);v3=dispatch2(args_add_star,v1,v2);(yyval.val)=v3;}
8118  }
8119 #line 8115 "ripper.c" /* yacc.c:1646 */
8120  break;
8121 
8122  case 289:
8123 #line 2605 "ripper.y" /* yacc.c:1646 */
8124  {
8125 #if 0
8126  (yyval.val) = last_arg_append(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
8127 #endif
8128  {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;}
8129  }
8130 #line 8126 "ripper.c" /* yacc.c:1646 */
8131  break;
8132 
8133  case 290:
8134 #line 2612 "ripper.y" /* yacc.c:1646 */
8135  {
8136 #if 0
8137  (yyval.val) = rest_arg_append(p, (yyvsp[-3].val), (yyvsp[0].val), &(yyloc));
8138 #endif
8139  {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;}
8140  }
8141 #line 8137 "ripper.c" /* yacc.c:1646 */
8142  break;
8143 
8144  case 291:
8145 #line 2619 "ripper.y" /* yacc.c:1646 */
8146  {
8147 #if 0
8148  (yyval.val) = NEW_SPLAT((yyvsp[0].val), &(yyloc));
8149 #endif
8150  {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;}
8151  }
8152 #line 8148 "ripper.c" /* yacc.c:1646 */
8153  break;
8154 
8155  case 302:
8156 #line 2638 "ripper.y" /* yacc.c:1646 */
8157  {
8158 #if 0
8159  (yyval.val) = NEW_FCALL((yyvsp[0].val), 0, &(yyloc));
8160 #endif
8161  {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;}
8162  }
8163 #line 8159 "ripper.c" /* yacc.c:1646 */
8164  break;
8165 
8166  case 303:
8167 #line 2645 "ripper.y" /* yacc.c:1646 */
8168  {
8169  CMDARG_PUSH(0);
8170  }
8171 #line 8167 "ripper.c" /* yacc.c:1646 */
8172  break;
8173 
8174  case 304:
8175 #line 2650 "ripper.y" /* yacc.c:1646 */
8176  {
8177  CMDARG_POP();
8178 #if 0
8179  set_line_body((yyvsp[-1].val), (yylsp[-3]).end_pos.lineno);
8180  (yyval.val) = NEW_BEGIN((yyvsp[-1].val), &(yyloc));
8181  nd_set_line((yyval.val), (yylsp[-3]).end_pos.lineno);
8182 #endif
8183  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(begin,v1);(yyval.val)=v2;}
8184  }
8185 #line 8181 "ripper.c" /* yacc.c:1646 */
8186  break;
8187 
8188  case 305:
8189 #line 2659 "ripper.y" /* yacc.c:1646 */
8190  {SET_LEX_STATE(EXPR_ENDARG);}
8191 #line 8187 "ripper.c" /* yacc.c:1646 */
8192  break;
8193 
8194  case 306:
8195 #line 2660 "ripper.y" /* yacc.c:1646 */
8196  {
8197 #if 0
8198  (yyval.val) = NEW_BEGIN(0, &(yyloc));
8199 #endif
8200  {VALUE v1,v2;v1=0;v2=dispatch1(paren,v1);(yyval.val)=v2;}
8201  }
8202 #line 8198 "ripper.c" /* yacc.c:1646 */
8203  break;
8204 
8205  case 307:
8206 #line 2666 "ripper.y" /* yacc.c:1646 */
8207  {SET_LEX_STATE(EXPR_ENDARG);}
8208 #line 8204 "ripper.c" /* yacc.c:1646 */
8209  break;
8210 
8211  case 308:
8212 #line 2667 "ripper.y" /* yacc.c:1646 */
8213  {
8214 #if 0
8215  if (nd_type((yyvsp[-2].val)) == NODE_SELF) (yyvsp[-2].val)->nd_state = 0;
8216  (yyval.val) = (yyvsp[-2].val);
8217 #endif
8218  {VALUE v1,v2;v1=(yyvsp[-2].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
8219  }
8220 #line 8216 "ripper.c" /* yacc.c:1646 */
8221  break;
8222 
8223  case 309:
8224 #line 2675 "ripper.y" /* yacc.c:1646 */
8225  {
8226 #if 0
8227  if (nd_type((yyvsp[-1].val)) == NODE_SELF) (yyvsp[-1].val)->nd_state = 0;
8228  (yyval.val) = (yyvsp[-1].val);
8229 #endif
8230  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
8231  }
8232 #line 8228 "ripper.c" /* yacc.c:1646 */
8233  break;
8234 
8235  case 310:
8236 #line 2683 "ripper.y" /* yacc.c:1646 */
8237  {
8238 #if 0
8239  (yyval.val) = NEW_COLON2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
8240 #endif
8241  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(const_path_ref,v1,v2);(yyval.val)=v3;}
8242  }
8243 #line 8239 "ripper.c" /* yacc.c:1646 */
8244  break;
8245 
8246  case 311:
8247 #line 2690 "ripper.y" /* yacc.c:1646 */
8248  {
8249 #if 0
8250  (yyval.val) = NEW_COLON3((yyvsp[0].val), &(yyloc));
8251 #endif
8252  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(top_const_ref,v1);(yyval.val)=v2;}
8253  }
8254 #line 8250 "ripper.c" /* yacc.c:1646 */
8255  break;
8256 
8257  case 312:
8258 #line 2697 "ripper.y" /* yacc.c:1646 */
8259  {
8260 #if 0
8261  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
8262 #endif
8263  {VALUE v1,v2;v1=escape_Qundef((yyvsp[-1].val));v2=dispatch1(array,v1);(yyval.val)=v2;}
8264  }
8265 #line 8261 "ripper.c" /* yacc.c:1646 */
8266  break;
8267 
8268  case 313:
8269 #line 2704 "ripper.y" /* yacc.c:1646 */
8270  {
8271 #if 0
8272  (yyval.val) = new_hash(p, (yyvsp[-1].val), &(yyloc));
8273  (yyval.val)->nd_brace = TRUE;
8274 #endif
8275  {VALUE v1,v2;v1=escape_Qundef((yyvsp[-1].val));v2=dispatch1(hash,v1);(yyval.val)=v2;}
8276  }
8277 #line 8273 "ripper.c" /* yacc.c:1646 */
8278  break;
8279 
8280  case 314:
8281 #line 2712 "ripper.y" /* yacc.c:1646 */
8282  {
8283 #if 0
8284  (yyval.val) = NEW_RETURN(0, &(yyloc));
8285 #endif
8286  {VALUE v1;v1=dispatch0(return0);(yyval.val)=v1;}
8287  }
8288 #line 8284 "ripper.c" /* yacc.c:1646 */
8289  break;
8290 
8291  case 315:
8292 #line 2719 "ripper.y" /* yacc.c:1646 */
8293  {
8294 #if 0
8295  (yyval.val) = new_yield(p, (yyvsp[-1].val), &(yyloc));
8296 #endif
8297  {VALUE v1,v2,v3,v4;v1=(yyvsp[-1].val);v2=dispatch1(paren,v1);v3=v2;v4=dispatch1(yield,v3);(yyval.val)=v4;}
8298  }
8299 #line 8295 "ripper.c" /* yacc.c:1646 */
8300  break;
8301 
8302  case 316:
8303 #line 2726 "ripper.y" /* yacc.c:1646 */
8304  {
8305 #if 0
8306  (yyval.val) = NEW_YIELD(0, &(yyloc));
8307 #endif
8308  {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;}
8309  }
8310 #line 8306 "ripper.c" /* yacc.c:1646 */
8311  break;
8312 
8313  case 317:
8314 #line 2733 "ripper.y" /* yacc.c:1646 */
8315  {
8316 #if 0
8317  (yyval.val) = NEW_YIELD(0, &(yyloc));
8318 #endif
8319  {VALUE v1;v1=dispatch0(yield0);(yyval.val)=v1;}
8320  }
8321 #line 8317 "ripper.c" /* yacc.c:1646 */
8322  break;
8323 
8324  case 318:
8325 #line 2739 "ripper.y" /* yacc.c:1646 */
8326  {p->in_defined = 1;}
8327 #line 8323 "ripper.c" /* yacc.c:1646 */
8328  break;
8329 
8330  case 319:
8331 #line 2740 "ripper.y" /* yacc.c:1646 */
8332  {
8333  p->in_defined = 0;
8334  (yyval.val) = new_defined(p, (yyvsp[-1].val), &(yyloc));
8335  }
8336 #line 8332 "ripper.c" /* yacc.c:1646 */
8337  break;
8338 
8339  case 320:
8340 #line 2745 "ripper.y" /* yacc.c:1646 */
8341  {
8342  (yyval.val) = call_uni_op(p, method_cond(p, (yyvsp[-1].val), &(yylsp[-1])), METHOD_NOT, &(yylsp[-3]), &(yyloc));
8343  }
8344 #line 8340 "ripper.c" /* yacc.c:1646 */
8345  break;
8346 
8347  case 321:
8348 #line 2749 "ripper.y" /* yacc.c:1646 */
8349  {
8350  (yyval.val) = call_uni_op(p, method_cond(p, new_nil(&(yylsp[-1])), &(yylsp[-1])), METHOD_NOT, &(yylsp[-2]), &(yyloc));
8351  }
8352 #line 8348 "ripper.c" /* yacc.c:1646 */
8353  break;
8354 
8355  case 322:
8356 #line 2753 "ripper.y" /* yacc.c:1646 */
8357  {
8358 #if 0
8359  (yyval.val) = method_add_block(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
8360 #endif
8361  {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;}
8362  }
8363 #line 8359 "ripper.c" /* yacc.c:1646 */
8364  break;
8365 
8366  case 324:
8367 #line 2761 "ripper.y" /* yacc.c:1646 */
8368  {
8369 #if 0
8370  block_dup_check(p, (yyvsp[-1].val)->nd_args, (yyvsp[0].val));
8371  (yyval.val) = method_add_block(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
8372 #endif
8373  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(method_add_block,v1,v2);(yyval.val)=v3;}
8374  }
8375 #line 8371 "ripper.c" /* yacc.c:1646 */
8376  break;
8377 
8378  case 325:
8379 #line 2769 "ripper.y" /* yacc.c:1646 */
8380  {
8381  token_info_push(p, "->", &(yylsp[0]));
8382  }
8383 #line 8379 "ripper.c" /* yacc.c:1646 */
8384  break;
8385 
8386  case 326:
8387 #line 2773 "ripper.y" /* yacc.c:1646 */
8388  {
8389  (yyval.val) = (yyvsp[0].val);
8390 #if 0
8391  nd_set_first_loc((yyval.val), (yylsp[-2]).beg_pos);
8392 #endif
8393  }
8394 #line 8390 "ripper.c" /* yacc.c:1646 */
8395  break;
8396 
8397  case 327:
8398 #line 2783 "ripper.y" /* yacc.c:1646 */
8399  {
8400 #if 0
8401  (yyval.val) = new_if(p, (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), &(yyloc));
8402  fixpos((yyval.val), (yyvsp[-4].val));
8403 #endif
8404  {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;}
8405  }
8406 #line 8402 "ripper.c" /* yacc.c:1646 */
8407  break;
8408 
8409  case 328:
8410 #line 2794 "ripper.y" /* yacc.c:1646 */
8411  {
8412 #if 0
8413  (yyval.val) = new_unless(p, (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), &(yyloc));
8414  fixpos((yyval.val), (yyvsp[-4].val));
8415 #endif
8416  {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;}
8417  }
8418 #line 8414 "ripper.c" /* yacc.c:1646 */
8419  break;
8420 
8421  case 329:
8422 #line 2804 "ripper.y" /* yacc.c:1646 */
8423  {
8424 #if 0
8425  (yyval.val) = NEW_WHILE(cond(p, (yyvsp[-2].val), &(yylsp[-2])), (yyvsp[-1].val), 1, &(yyloc));
8426  fixpos((yyval.val), (yyvsp[-2].val));
8427 #endif
8428  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(while,v1,v2);(yyval.val)=v3;}
8429  }
8430 #line 8426 "ripper.c" /* yacc.c:1646 */
8431  break;
8432 
8433  case 330:
8434 #line 2814 "ripper.y" /* yacc.c:1646 */
8435  {
8436 #if 0
8437  (yyval.val) = NEW_UNTIL(cond(p, (yyvsp[-2].val), &(yylsp[-2])), (yyvsp[-1].val), 1, &(yyloc));
8438  fixpos((yyval.val), (yyvsp[-2].val));
8439 #endif
8440  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(until,v1,v2);(yyval.val)=v3;}
8441  }
8442 #line 8438 "ripper.c" /* yacc.c:1646 */
8443  break;
8444 
8445  case 331:
8446 #line 2822 "ripper.y" /* yacc.c:1646 */
8447  {
8448  (yyval.val) = p->case_labels;
8449  p->case_labels = Qnil;
8450  }
8451 #line 8447 "ripper.c" /* yacc.c:1646 */
8452  break;
8453 
8454  case 332:
8455 #line 2828 "ripper.y" /* yacc.c:1646 */
8456  {
8458  p->case_labels = (yyvsp[-2].val);
8459 #if 0
8460  (yyval.val) = NEW_CASE((yyvsp[-4].val), (yyvsp[-1].val), &(yyloc));
8461  fixpos((yyval.val), (yyvsp[-4].val));
8462 #endif
8463  {VALUE v1,v2,v3;v1=(yyvsp[-4].val);v2=(yyvsp[-1].val);v3=dispatch2(case,v1,v2);(yyval.val)=v3;}
8464  }
8465 #line 8461 "ripper.c" /* yacc.c:1646 */
8466  break;
8467 
8468  case 333:
8469 #line 2838 "ripper.y" /* yacc.c:1646 */
8470  {
8471  (yyval.val) = p->case_labels;
8472  p->case_labels = 0;
8473  }
8474 #line 8470 "ripper.c" /* yacc.c:1646 */
8475  break;
8476 
8477  case 334:
8478 #line 2844 "ripper.y" /* yacc.c:1646 */
8479  {
8481  p->case_labels = (yyvsp[-2].val);
8482 #if 0
8483  (yyval.val) = NEW_CASE2((yyvsp[-1].val), &(yyloc));
8484 #endif
8485  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[-1].val);v3=dispatch2(case,v1,v2);(yyval.val)=v3;}
8486  }
8487 #line 8483 "ripper.c" /* yacc.c:1646 */
8488  break;
8489 
8490  case 335:
8491 #line 2855 "ripper.y" /* yacc.c:1646 */
8492  {
8493 #if 0
8494  (yyval.val) = new_case3(p, (yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
8495 #endif
8496  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=(yyvsp[-1].val);v3=dispatch2(case,v1,v2);(yyval.val)=v3;}
8497  }
8498 #line 8494 "ripper.c" /* yacc.c:1646 */
8499  break;
8500 
8501  case 336:
8502 #line 2864 "ripper.y" /* yacc.c:1646 */
8503  {
8504 #if 0
8505  /*
8506  * for a, b, c in e
8507  * #=>
8508  * e.each{|*x| a, b, c = x}
8509  *
8510  * for a in e
8511  * #=>
8512  * e.each{|x| a, = x}
8513  */
8514  ID id = internal_id(p);
8515  NODE *m = NEW_ARGS_AUX(0, 0, &NULL_LOC);
8516  NODE *args, *scope, *internal_var = NEW_DVAR(id, &(yylsp[-4]));
8518  ID *tbl = ALLOC_N(ID, 3);
8519  rb_imemo_tmpbuf_set_ptr(tmpbuf, tbl);
8520  tbl[0] = 1 /* length of local var table */; tbl[1] = id /* internal id */;
8521  tbl[2] = tmpbuf;
8522 
8523  switch (nd_type((yyvsp[-4].val))) {
8524  case NODE_LASGN:
8525  case NODE_DASGN:
8526  case NODE_DASGN_CURR: /* e.each {|internal_var| a = internal_var; ... } */
8527  (yyvsp[-4].val)->nd_value = internal_var;
8528  id = 0;
8529  m->nd_plen = 1;
8530  m->nd_next = (yyvsp[-4].val);
8531  break;
8532  case NODE_MASGN: /* e.each {|*internal_var| a, b, c = (internal_var.length == 1 && Array === (tmp = internal_var[0]) ? tmp : internal_var); ... } */
8533  m->nd_next = node_assign(p, (yyvsp[-4].val), NEW_FOR_MASGN(internal_var, &(yylsp[-4])), &(yylsp[-4]));
8534  break;
8535  default: /* e.each {|*internal_var| @a, B, c[1], d.attr = internal_val; ... } */
8536  m->nd_next = node_assign(p, NEW_MASGN(NEW_LIST((yyvsp[-4].val), &(yylsp[-4])), 0, &(yylsp[-4])), internal_var, &(yylsp[-4]));
8537  }
8538  /* {|*internal_id| <m> = internal_id; ... } */
8539  args = new_args(p, m, 0, id, 0, new_args_tail(p, 0, 0, 0, &(yylsp[-4])), &(yylsp[-4]));
8540  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[-1].val), args, &(yyloc));
8541  RB_OBJ_WRITTEN(p->ast, Qnil, tmpbuf);
8542  (yyval.val) = NEW_FOR((yyvsp[-2].val), scope, &(yyloc));
8543  fixpos((yyval.val), (yyvsp[-4].val));
8544 #endif
8545  {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;}
8546  }
8547 #line 8543 "ripper.c" /* yacc.c:1646 */
8548  break;
8549 
8550  case 337:
8551 #line 2909 "ripper.y" /* yacc.c:1646 */
8552  {
8553  if (p->in_def) {
8554  YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[-1]));
8555  yyerror1(&loc, "class definition in method body");
8556  }
8557  (yyvsp[-2].num) = p->in_class;
8558  p->in_class = 1;
8559  local_push(p, 0);
8560  }
8561 #line 8557 "ripper.c" /* yacc.c:1646 */
8562  break;
8563 
8564  case 338:
8565 #line 2920 "ripper.y" /* yacc.c:1646 */
8566  {
8567 #if 0
8568  (yyval.val) = NEW_CLASS((yyvsp[-4].val), (yyvsp[-1].val), (yyvsp[-3].val), &(yyloc));
8569  nd_set_line((yyval.val)->nd_body, (yylsp[0]).end_pos.lineno);
8570  set_line_body((yyvsp[-1].val), (yylsp[-3]).end_pos.lineno);
8571  nd_set_line((yyval.val), (yylsp[-3]).end_pos.lineno);
8572 #endif
8573  {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;}
8574  local_pop(p);
8575  p->in_class = (yyvsp[-5].num) & 1;
8576  }
8577 #line 8573 "ripper.c" /* yacc.c:1646 */
8578  break;
8579 
8580  case 339:
8581 #line 2932 "ripper.y" /* yacc.c:1646 */
8582  {
8583  (yyval.num) = (p->in_class << 1) | p->in_def;
8584  p->in_def = 0;
8585  p->in_class = 0;
8586  local_push(p, 0);
8587  }
8588 #line 8584 "ripper.c" /* yacc.c:1646 */
8589  break;
8590 
8591  case 340:
8592 #line 2941 "ripper.y" /* yacc.c:1646 */
8593  {
8594 #if 0
8595  (yyval.val) = NEW_SCLASS((yyvsp[-4].val), (yyvsp[-1].val), &(yyloc));
8596  nd_set_line((yyval.val)->nd_body, (yylsp[0]).end_pos.lineno);
8597  set_line_body((yyvsp[-1].val), nd_line((yyvsp[-4].val)));
8598  fixpos((yyval.val), (yyvsp[-4].val));
8599 #endif
8600  {VALUE v1,v2,v3;v1=(yyvsp[-4].val);v2=(yyvsp[-1].val);v3=dispatch2(sclass,v1,v2);(yyval.val)=v3;}
8601  local_pop(p);
8602  p->in_def = (yyvsp[-3].num) & 1;
8603  p->in_class = ((yyvsp[-3].num) >> 1) & 1;
8604  }
8605 #line 8601 "ripper.c" /* yacc.c:1646 */
8606  break;
8607 
8608  case 341:
8609 #line 2954 "ripper.y" /* yacc.c:1646 */
8610  {
8611  if (p->in_def) {
8612  YYLTYPE loc = code_loc_gen(&(yylsp[-1]), &(yylsp[0]));
8613  yyerror1(&loc, "module definition in method body");
8614  }
8615  (yyvsp[-1].num) = p->in_class;
8616  p->in_class = 1;
8617  local_push(p, 0);
8618  }
8619 #line 8615 "ripper.c" /* yacc.c:1646 */
8620  break;
8621 
8622  case 342:
8623 #line 2965 "ripper.y" /* yacc.c:1646 */
8624  {
8625 #if 0
8626  (yyval.val) = NEW_MODULE((yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
8627  nd_set_line((yyval.val)->nd_body, (yylsp[0]).end_pos.lineno);
8628  set_line_body((yyvsp[-1].val), (yylsp[-3]).end_pos.lineno);
8629  nd_set_line((yyval.val), (yylsp[-3]).end_pos.lineno);
8630 #endif
8631  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=(yyvsp[-1].val);v3=dispatch2(module,v1,v2);(yyval.val)=v3;}
8632  local_pop(p);
8633  p->in_class = (yyvsp[-4].num) & 1;
8634  }
8635 #line 8631 "ripper.c" /* yacc.c:1646 */
8636  break;
8637 
8638  case 343:
8639 #line 2977 "ripper.y" /* yacc.c:1646 */
8640  {
8641  numparam_name(p, get_id((yyvsp[0].val)));
8642  local_push(p, 0);
8643  (yyval.id) = p->cur_arg;
8644  p->cur_arg = 0;
8645  }
8646 #line 8642 "ripper.c" /* yacc.c:1646 */
8647  break;
8648 
8649  case 344:
8650 #line 2983 "ripper.y" /* yacc.c:1646 */
8651  {
8652  (yyval.num) = p->in_def;
8653  p->in_def = 1;
8654  }
8655 #line 8651 "ripper.c" /* yacc.c:1646 */
8656  break;
8657 
8658  case 345:
8659 #line 2990 "ripper.y" /* yacc.c:1646 */
8660  {
8661 #if 0
8662  NODE *body = remove_begin((yyvsp[-1].val));
8663  reduce_nodes(p, &body);
8664  (yyval.val) = NEW_DEFN((yyvsp[-5].val), (yyvsp[-2].val), body, &(yyloc));
8665  nd_set_line((yyval.val)->nd_defn, (yylsp[0]).end_pos.lineno);
8666  set_line_body(body, (yylsp[-6]).beg_pos.lineno);
8667 #endif
8668  {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;}
8669  local_pop(p);
8670  p->in_def = (yyvsp[-3].num) & 1;
8671  p->cur_arg = (yyvsp[-4].id);
8672  }
8673 #line 8669 "ripper.c" /* yacc.c:1646 */
8674  break;
8675 
8676  case 346:
8677 #line 3003 "ripper.y" /* yacc.c:1646 */
8678  {SET_LEX_STATE(EXPR_FNAME);}
8679 #line 8675 "ripper.c" /* yacc.c:1646 */
8680  break;
8681 
8682  case 347:
8683 #line 3004 "ripper.y" /* yacc.c:1646 */
8684  {
8685  numparam_name(p, get_id((yyvsp[0].val)));
8686  (yyvsp[-1].num) = p->in_def;
8687  p->in_def = 1;
8688  SET_LEX_STATE(EXPR_ENDFN|EXPR_LABEL); /* force for args */
8689  local_push(p, 0);
8690  (yyval.id) = p->cur_arg;
8691  p->cur_arg = 0;
8692  }
8693 #line 8689 "ripper.c" /* yacc.c:1646 */
8694  break;
8695 
8696  case 348:
8697 #line 3016 "ripper.y" /* yacc.c:1646 */
8698  {
8699 #if 0
8700  NODE *body = remove_begin((yyvsp[-1].val));
8701  reduce_nodes(p, &body);
8702  (yyval.val) = NEW_DEFS((yyvsp[-7].val), (yyvsp[-4].val), (yyvsp[-2].val), body, &(yyloc));
8703  nd_set_line((yyval.val)->nd_defn, (yylsp[0]).end_pos.lineno);
8704  set_line_body(body, (yylsp[-8]).beg_pos.lineno);
8705 #endif
8706  {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;}
8707  local_pop(p);
8708  p->in_def = (yyvsp[-5].num) & 1;
8709  p->cur_arg = (yyvsp[-3].id);
8710  }
8711 #line 8707 "ripper.c" /* yacc.c:1646 */
8712  break;
8713 
8714  case 349:
8715 #line 3030 "ripper.y" /* yacc.c:1646 */
8716  {
8717 #if 0
8718  (yyval.val) = NEW_BREAK(0, &(yyloc));
8719 #endif
8720  {VALUE v1,v2,v3;v1=dispatch0(args_new);v2=v1;v3=dispatch1(break,v2);(yyval.val)=v3;}
8721  }
8722 #line 8718 "ripper.c" /* yacc.c:1646 */
8723  break;
8724 
8725  case 350:
8726 #line 3037 "ripper.y" /* yacc.c:1646 */
8727  {
8728 #if 0
8729  (yyval.val) = NEW_NEXT(0, &(yyloc));
8730 #endif
8731  {VALUE v1,v2,v3;v1=dispatch0(args_new);v2=v1;v3=dispatch1(next,v2);(yyval.val)=v3;}
8732  }
8733 #line 8729 "ripper.c" /* yacc.c:1646 */
8734  break;
8735 
8736  case 351:
8737 #line 3044 "ripper.y" /* yacc.c:1646 */
8738  {
8739 #if 0
8740  (yyval.val) = NEW_REDO(&(yyloc));
8741 #endif
8742  {VALUE v1;v1=dispatch0(redo);(yyval.val)=v1;}
8743  }
8744 #line 8740 "ripper.c" /* yacc.c:1646 */
8745  break;
8746 
8747  case 352:
8748 #line 3051 "ripper.y" /* yacc.c:1646 */
8749  {
8750 #if 0
8751  (yyval.val) = NEW_RETRY(&(yyloc));
8752 #endif
8753  {VALUE v1;v1=dispatch0(retry);(yyval.val)=v1;}
8754  }
8755 #line 8751 "ripper.c" /* yacc.c:1646 */
8756  break;
8757 
8758  case 353:
8759 #line 3060 "ripper.y" /* yacc.c:1646 */
8760  {
8761  value_expr((yyvsp[0].val));
8762  (yyval.val) = (yyvsp[0].val);
8763  }
8764 #line 8760 "ripper.c" /* yacc.c:1646 */
8765  break;
8766 
8767  case 354:
8768 #line 3067 "ripper.y" /* yacc.c:1646 */
8769  {
8770  token_info_push(p, "begin", &(yyloc));
8771  }
8772 #line 8768 "ripper.c" /* yacc.c:1646 */
8773  break;
8774 
8775  case 355:
8776 #line 3073 "ripper.y" /* yacc.c:1646 */
8777  {
8778  WARN_EOL("if");
8779  token_info_push(p, "if", &(yyloc));
8780  if (p->token_info && p->token_info->nonspc &&
8781  p->token_info->next && !strcmp(p->token_info->next->token, "else")) {
8782  const char *tok = p->lex.ptok;
8783  const char *beg = p->lex.pbeg + p->token_info->next->beg.column;
8784  beg += rb_strlen_lit("else");
8785  while (beg < tok && ISSPACE(*beg)) beg++;
8786  if (beg == tok) {
8787  p->token_info->nonspc = 0;
8788  }
8789  }
8790  }
8791 #line 8787 "ripper.c" /* yacc.c:1646 */
8792  break;
8793 
8794  case 356:
8795 #line 3090 "ripper.y" /* yacc.c:1646 */
8796  {
8797  token_info_push(p, "unless", &(yyloc));
8798  }
8799 #line 8795 "ripper.c" /* yacc.c:1646 */
8800  break;
8801 
8802  case 357:
8803 #line 3096 "ripper.y" /* yacc.c:1646 */
8804  {
8805  token_info_push(p, "while", &(yyloc));
8806  }
8807 #line 8803 "ripper.c" /* yacc.c:1646 */
8808  break;
8809 
8810  case 358:
8811 #line 3102 "ripper.y" /* yacc.c:1646 */
8812  {
8813  token_info_push(p, "until", &(yyloc));
8814  }
8815 #line 8811 "ripper.c" /* yacc.c:1646 */
8816  break;
8817 
8818  case 359:
8819 #line 3108 "ripper.y" /* yacc.c:1646 */
8820  {
8821  token_info_push(p, "case", &(yyloc));
8822  }
8823 #line 8819 "ripper.c" /* yacc.c:1646 */
8824  break;
8825 
8826  case 360:
8827 #line 3114 "ripper.y" /* yacc.c:1646 */
8828  {
8829  token_info_push(p, "for", &(yyloc));
8830  }
8831 #line 8827 "ripper.c" /* yacc.c:1646 */
8832  break;
8833 
8834  case 361:
8835 #line 3120 "ripper.y" /* yacc.c:1646 */
8836  {
8837  token_info_push(p, "class", &(yyloc));
8838  }
8839 #line 8835 "ripper.c" /* yacc.c:1646 */
8840  break;
8841 
8842  case 362:
8843 #line 3126 "ripper.y" /* yacc.c:1646 */
8844  {
8845  token_info_push(p, "module", &(yyloc));
8846  }
8847 #line 8843 "ripper.c" /* yacc.c:1646 */
8848  break;
8849 
8850  case 363:
8851 #line 3132 "ripper.y" /* yacc.c:1646 */
8852  {
8853  token_info_push(p, "def", &(yyloc));
8854  }
8855 #line 8851 "ripper.c" /* yacc.c:1646 */
8856  break;
8857 
8858  case 364:
8859 #line 3138 "ripper.y" /* yacc.c:1646 */
8860  {
8861  token_info_push(p, "do", &(yyloc));
8862  }
8863 #line 8859 "ripper.c" /* yacc.c:1646 */
8864  break;
8865 
8866  case 365:
8867 #line 3144 "ripper.y" /* yacc.c:1646 */
8868  {
8869  token_info_push(p, "do", &(yyloc));
8870  }
8871 #line 8867 "ripper.c" /* yacc.c:1646 */
8872  break;
8873 
8874  case 366:
8875 #line 3150 "ripper.y" /* yacc.c:1646 */
8876  {
8877  token_info_warn(p, "rescue", p->token_info, 1, &(yyloc));
8878  }
8879 #line 8875 "ripper.c" /* yacc.c:1646 */
8880  break;
8881 
8882  case 367:
8883 #line 3156 "ripper.y" /* yacc.c:1646 */
8884  {
8885  token_info_warn(p, "ensure", p->token_info, 1, &(yyloc));
8886  }
8887 #line 8883 "ripper.c" /* yacc.c:1646 */
8888  break;
8889 
8890  case 368:
8891 #line 3162 "ripper.y" /* yacc.c:1646 */
8892  {
8893  token_info_warn(p, "when", p->token_info, 0, &(yyloc));
8894  }
8895 #line 8891 "ripper.c" /* yacc.c:1646 */
8896  break;
8897 
8898  case 369:
8899 #line 3168 "ripper.y" /* yacc.c:1646 */
8900  {
8901  token_info *ptinfo_beg = p->token_info;
8902  int same = ptinfo_beg && strcmp(ptinfo_beg->token, "case") != 0;
8903  token_info_warn(p, "else", p->token_info, same, &(yyloc));
8904  if (same) {
8905  token_info e;
8906  e.next = ptinfo_beg->next;
8907  e.token = "else";
8908  token_info_setup(&e, p->lex.pbeg, &(yyloc));
8909  if (!e.nonspc) *ptinfo_beg = e;
8910  }
8911  }
8912 #line 8908 "ripper.c" /* yacc.c:1646 */
8913  break;
8914 
8915  case 370:
8916 #line 3183 "ripper.y" /* yacc.c:1646 */
8917  {
8918  WARN_EOL("elsif");
8919  token_info_warn(p, "elsif", p->token_info, 1, &(yyloc));
8920  }
8921 #line 8917 "ripper.c" /* yacc.c:1646 */
8922  break;
8923 
8924  case 371:
8925 #line 3190 "ripper.y" /* yacc.c:1646 */
8926  {
8927  token_info_pop(p, "end", &(yyloc));
8928  }
8929 #line 8925 "ripper.c" /* yacc.c:1646 */
8930  break;
8931 
8932  case 372:
8933 #line 3196 "ripper.y" /* yacc.c:1646 */
8934  {
8935  if (p->in_class && !p->in_def && !dyna_in_block(p))
8936  yyerror1(&(yylsp[0]), "Invalid return in class/module body");
8937  }
8938 #line 8934 "ripper.c" /* yacc.c:1646 */
8939  break;
8940 
8941  case 379:
8942 #line 3215 "ripper.y" /* yacc.c:1646 */
8943  {
8944 #if 0
8945  (yyval.val) = new_if(p, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
8946  fixpos((yyval.val), (yyvsp[-3].val));
8947 #endif
8948  {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;}
8949  }
8950 #line 8946 "ripper.c" /* yacc.c:1646 */
8951  break;
8952 
8953  case 381:
8954 #line 3226 "ripper.y" /* yacc.c:1646 */
8955  {
8956 #if 0
8957  (yyval.val) = (yyvsp[0].val);
8958 #endif
8959  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(else,v1);(yyval.val)=v2;}
8960  }
8961 #line 8957 "ripper.c" /* yacc.c:1646 */
8962  break;
8963 
8964  case 384:
8965 #line 3239 "ripper.y" /* yacc.c:1646 */
8966  {
8967 #if 0
8968  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
8969  mark_lvar_used(p, (yyval.val));
8970 #endif
8971  (yyval.val)=assignable(p, (yyvsp[0].val));
8972  }
8973 #line 8969 "ripper.c" /* yacc.c:1646 */
8974  break;
8975 
8976  case 385:
8977 #line 3247 "ripper.y" /* yacc.c:1646 */
8978  {
8979 #if 0
8980  (yyval.val) = (yyvsp[-1].val);
8981 #endif
8982  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(mlhs_paren,v1);(yyval.val)=v2;}
8983  }
8984 #line 8980 "ripper.c" /* yacc.c:1646 */
8985  break;
8986 
8987  case 386:
8988 #line 3256 "ripper.y" /* yacc.c:1646 */
8989  {
8990 #if 0
8991  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
8992 #endif
8993  {VALUE v1,v2,v3,v4;v1=dispatch0(mlhs_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(mlhs_add,v2,v3);(yyval.val)=v4;}
8994  }
8995 #line 8991 "ripper.c" /* yacc.c:1646 */
8996  break;
8997 
8998  case 387:
8999 #line 3263 "ripper.y" /* yacc.c:1646 */
9000  {
9001 #if 0
9002  (yyval.val) = list_append(p, (yyvsp[-2].val), (yyvsp[0].val));
9003 #endif
9004  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(mlhs_add,v1,v2);(yyval.val)=v3;}
9005  }
9006 #line 9002 "ripper.c" /* yacc.c:1646 */
9007  break;
9008 
9009  case 388:
9010 #line 3272 "ripper.y" /* yacc.c:1646 */
9011  {
9012 #if 0
9013  (yyval.val) = NEW_MASGN((yyvsp[0].val), 0, &(yyloc));
9014 #endif
9015  (yyval.val)=(yyvsp[0].val);
9016  }
9017 #line 9013 "ripper.c" /* yacc.c:1646 */
9018  break;
9019 
9020  case 389:
9021 #line 3279 "ripper.y" /* yacc.c:1646 */
9022  {
9023 #if 0
9024  (yyval.val) = NEW_MASGN((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
9025 #endif
9026  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(mlhs_add_star,v1,v2);(yyval.val)=v3;}
9027  }
9028 #line 9024 "ripper.c" /* yacc.c:1646 */
9029  break;
9030 
9031  case 390:
9032 #line 3286 "ripper.y" /* yacc.c:1646 */
9033  {
9034 #if 0
9035  (yyval.val) = NEW_MASGN((yyvsp[-4].val), NEW_POSTARG((yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
9036 #endif
9037  {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;}
9038  }
9039 #line 9035 "ripper.c" /* yacc.c:1646 */
9040  break;
9041 
9042  case 391:
9043 #line 3293 "ripper.y" /* yacc.c:1646 */
9044  {
9045 #if 0
9046  (yyval.val) = NEW_MASGN(0, (yyvsp[0].val), &(yyloc));
9047 #endif
9048  {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;}
9049  }
9050 #line 9046 "ripper.c" /* yacc.c:1646 */
9051  break;
9052 
9053  case 392:
9054 #line 3300 "ripper.y" /* yacc.c:1646 */
9055  {
9056 #if 0
9057  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
9058 #endif
9059  {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;}
9060  }
9061 #line 9057 "ripper.c" /* yacc.c:1646 */
9062  break;
9063 
9064  case 393:
9065 #line 3309 "ripper.y" /* yacc.c:1646 */
9066  {
9067 #if 0
9068  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
9069  mark_lvar_used(p, (yyval.val));
9070 #endif
9071  (yyval.val)=assignable(p, (yyvsp[0].val));
9072  }
9073 #line 9069 "ripper.c" /* yacc.c:1646 */
9074  break;
9075 
9076  case 394:
9077 #line 3317 "ripper.y" /* yacc.c:1646 */
9078  {
9079 #if 0
9080  (yyval.val) = NODE_SPECIAL_NO_NAME_REST;
9081 #endif
9082  (yyval.val)=Qnil;
9083  }
9084 #line 9080 "ripper.c" /* yacc.c:1646 */
9085  break;
9086 
9087  case 395:
9088 #line 3326 "ripper.y" /* yacc.c:1646 */
9089  {
9090  (yyval.val) = new_args_tail(p, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]));
9091  }
9092 #line 9088 "ripper.c" /* yacc.c:1646 */
9093  break;
9094 
9095  case 396:
9096 #line 3330 "ripper.y" /* yacc.c:1646 */
9097  {
9098  (yyval.val) = new_args_tail(p, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yylsp[-1]));
9099  }
9100 #line 9096 "ripper.c" /* yacc.c:1646 */
9101  break;
9102 
9103  case 397:
9104 #line 3334 "ripper.y" /* yacc.c:1646 */
9105  {
9106  (yyval.val) = new_args_tail(p, Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]));
9107  }
9108 #line 9104 "ripper.c" /* yacc.c:1646 */
9109  break;
9110 
9111  case 398:
9112 #line 3338 "ripper.y" /* yacc.c:1646 */
9113  {
9114  (yyval.val) = new_args_tail(p, Qnone, ID2VAL(idNil), (yyvsp[0].val), &(yylsp[-1]));
9115  }
9116 #line 9112 "ripper.c" /* yacc.c:1646 */
9117  break;
9118 
9119  case 399:
9120 #line 3342 "ripper.y" /* yacc.c:1646 */
9121  {
9122  (yyval.val) = new_args_tail(p, Qnone, Qnone, (yyvsp[0].val), &(yylsp[0]));
9123  }
9124 #line 9120 "ripper.c" /* yacc.c:1646 */
9125  break;
9126 
9127  case 400:
9128 #line 3348 "ripper.y" /* yacc.c:1646 */
9129  {
9130  (yyval.val) = (yyvsp[0].val);
9131  }
9132 #line 9128 "ripper.c" /* yacc.c:1646 */
9133  break;
9134 
9135  case 401:
9136 #line 3352 "ripper.y" /* yacc.c:1646 */
9137  {
9138  (yyval.val) = new_args_tail(p, Qnone, Qnone, Qnone, &(yylsp[0]));
9139  }
9140 #line 9136 "ripper.c" /* yacc.c:1646 */
9141  break;
9142 
9143  case 402:
9144 #line 3358 "ripper.y" /* yacc.c:1646 */
9145  {
9146  (yyval.val) = new_args(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
9147  }
9148 #line 9144 "ripper.c" /* yacc.c:1646 */
9149  break;
9150 
9151  case 403:
9152 #line 3362 "ripper.y" /* yacc.c:1646 */
9153  {
9154  (yyval.val) = new_args(p, (yyvsp[-7].val), (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9155  }
9156 #line 9152 "ripper.c" /* yacc.c:1646 */
9157  break;
9158 
9159  case 404:
9160 #line 3366 "ripper.y" /* yacc.c:1646 */
9161  {
9162  (yyval.val) = new_args(p, (yyvsp[-3].val), (yyvsp[-1].val), Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9163  }
9164 #line 9160 "ripper.c" /* yacc.c:1646 */
9165  break;
9166 
9167  case 405:
9168 #line 3370 "ripper.y" /* yacc.c:1646 */
9169  {
9170  (yyval.val) = new_args(p, (yyvsp[-5].val), (yyvsp[-3].val), Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9171  }
9172 #line 9168 "ripper.c" /* yacc.c:1646 */
9173  break;
9174 
9175  case 406:
9176 #line 3374 "ripper.y" /* yacc.c:1646 */
9177  {
9178  (yyval.val) = new_args(p, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
9179  }
9180 #line 9176 "ripper.c" /* yacc.c:1646 */
9181  break;
9182 
9183  case 407:
9184 #line 3378 "ripper.y" /* yacc.c:1646 */
9185  {
9186 #if 0
9187  /* magic number for rest_id in iseq_set_arguments() */
9188  (yyval.val) = new_args(p, (yyvsp[-1].val), Qnone, NODE_SPECIAL_EXCESSIVE_COMMA, Qnone, new_args_tail(p, Qnone, Qnone, Qnone, &(yylsp[-1])), &(yyloc));
9189 #endif
9190  {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);}
9191  }
9192 #line 9188 "ripper.c" /* yacc.c:1646 */
9193  break;
9194 
9195  case 408:
9196 #line 3386 "ripper.y" /* yacc.c:1646 */
9197  {
9198  (yyval.val) = new_args(p, (yyvsp[-5].val), Qnone, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9199  }
9200 #line 9196 "ripper.c" /* yacc.c:1646 */
9201  break;
9202 
9203  case 409:
9204 #line 3390 "ripper.y" /* yacc.c:1646 */
9205  {
9206  (yyval.val) = new_args(p, (yyvsp[-1].val), Qnone, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9207  }
9208 #line 9204 "ripper.c" /* yacc.c:1646 */
9209  break;
9210 
9211  case 410:
9212 #line 3394 "ripper.y" /* yacc.c:1646 */
9213  {
9214  (yyval.val) = new_args(p, Qnone, (yyvsp[-3].val), (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
9215  }
9216 #line 9212 "ripper.c" /* yacc.c:1646 */
9217  break;
9218 
9219  case 411:
9220 #line 3398 "ripper.y" /* yacc.c:1646 */
9221  {
9222  (yyval.val) = new_args(p, Qnone, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9223  }
9224 #line 9220 "ripper.c" /* yacc.c:1646 */
9225  break;
9226 
9227  case 412:
9228 #line 3402 "ripper.y" /* yacc.c:1646 */
9229  {
9230  (yyval.val) = new_args(p, Qnone, (yyvsp[-1].val), Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9231  }
9232 #line 9228 "ripper.c" /* yacc.c:1646 */
9233  break;
9234 
9235  case 413:
9236 #line 3406 "ripper.y" /* yacc.c:1646 */
9237  {
9238  (yyval.val) = new_args(p, Qnone, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9239  }
9240 #line 9236 "ripper.c" /* yacc.c:1646 */
9241  break;
9242 
9243  case 414:
9244 #line 3410 "ripper.y" /* yacc.c:1646 */
9245  {
9246  (yyval.val) = new_args(p, Qnone, Qnone, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
9247  }
9248 #line 9244 "ripper.c" /* yacc.c:1646 */
9249  break;
9250 
9251  case 415:
9252 #line 3414 "ripper.y" /* yacc.c:1646 */
9253  {
9254  (yyval.val) = new_args(p, Qnone, Qnone, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9255  }
9256 #line 9252 "ripper.c" /* yacc.c:1646 */
9257  break;
9258 
9259  case 416:
9260 #line 3418 "ripper.y" /* yacc.c:1646 */
9261  {
9262  (yyval.val) = new_args(p, Qnone, Qnone, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9263  }
9264 #line 9260 "ripper.c" /* yacc.c:1646 */
9265  break;
9266 
9267  case 418:
9268 #line 3425 "ripper.y" /* yacc.c:1646 */
9269  {
9270  p->command_start = TRUE;
9271  }
9272 #line 9268 "ripper.c" /* yacc.c:1646 */
9273  break;
9274 
9275  case 419:
9276 #line 3431 "ripper.y" /* yacc.c:1646 */
9277  {
9278  p->cur_arg = 0;
9280 #if 0
9281  (yyval.val) = 0;
9282 #endif
9283  {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;}
9284  }
9285 #line 9281 "ripper.c" /* yacc.c:1646 */
9286  break;
9287 
9288  case 420:
9289 #line 3440 "ripper.y" /* yacc.c:1646 */
9290  {
9291  p->cur_arg = 0;
9293 #if 0
9294  (yyval.val) = (yyvsp[-2].val);
9295 #endif
9296  {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;}
9297  }
9298 #line 9294 "ripper.c" /* yacc.c:1646 */
9299  break;
9300 
9301  case 421:
9302 #line 3452 "ripper.y" /* yacc.c:1646 */
9303  {
9304  (yyval.val) = 0;
9305  }
9306 #line 9302 "ripper.c" /* yacc.c:1646 */
9307  break;
9308 
9309  case 422:
9310 #line 3456 "ripper.y" /* yacc.c:1646 */
9311  {
9312 #if 0
9313  (yyval.val) = 0;
9314 #endif
9315  (yyval.val)=(yyvsp[-1].val);
9316  }
9317 #line 9313 "ripper.c" /* yacc.c:1646 */
9318  break;
9319 
9320  case 423:
9321 #line 3465 "ripper.y" /* yacc.c:1646 */
9322  {(yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));}
9323 #line 9319 "ripper.c" /* yacc.c:1646 */
9324  break;
9325 
9326  case 424:
9327 #line 3467 "ripper.y" /* yacc.c:1646 */
9328  {(yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));}
9329 #line 9325 "ripper.c" /* yacc.c:1646 */
9330  break;
9331 
9332  case 425:
9333 #line 3471 "ripper.y" /* yacc.c:1646 */
9334  {
9335  new_bv(p, get_id((yyvsp[0].val)));
9336  (yyval.val)=get_value((yyvsp[0].val));
9337  }
9338 #line 9334 "ripper.c" /* yacc.c:1646 */
9339  break;
9340 
9341  case 426:
9342 #line 3476 "ripper.y" /* yacc.c:1646 */
9343  {
9344  (yyval.val) = 0;
9345  }
9346 #line 9342 "ripper.c" /* yacc.c:1646 */
9347  break;
9348 
9349  case 427:
9350 #line 3481 "ripper.y" /* yacc.c:1646 */
9351  {
9352  (yyval.vars) = dyna_push(p);
9353  }
9354 #line 9350 "ripper.c" /* yacc.c:1646 */
9355  break;
9356 
9357  case 428:
9358 #line 3484 "ripper.y" /* yacc.c:1646 */
9359  {
9360  (yyval.num) = p->lex.lpar_beg;
9361  p->lex.lpar_beg = p->lex.paren_nest;
9362  }
9363 #line 9359 "ripper.c" /* yacc.c:1646 */
9364  break;
9365 
9366  case 429:
9367 #line 3488 "ripper.y" /* yacc.c:1646 */
9368  {
9369  (yyval.num) = p->max_numparam;
9370  p->max_numparam = 0;
9371  }
9372 #line 9368 "ripper.c" /* yacc.c:1646 */
9373  break;
9374 
9375  case 430:
9376 #line 3492 "ripper.y" /* yacc.c:1646 */
9377  {
9378  (yyval.node) = numparam_push(p);
9379  }
9380 #line 9376 "ripper.c" /* yacc.c:1646 */
9381  break;
9382 
9383  case 431:
9384 #line 3496 "ripper.y" /* yacc.c:1646 */
9385  {
9386  CMDARG_PUSH(0);
9387  }
9388 #line 9384 "ripper.c" /* yacc.c:1646 */
9389  break;
9390 
9391  case 432:
9392 #line 3500 "ripper.y" /* yacc.c:1646 */
9393  {
9394  int max_numparam = p->max_numparam;
9395  p->lex.lpar_beg = (yyvsp[-5].num);
9396  p->max_numparam = (yyvsp[-4].num);
9397  CMDARG_POP();
9398  (yyvsp[-2].val) = args_with_numbered(p, (yyvsp[-2].val), max_numparam);
9399 #if 0
9400  {
9401  YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
9402  (yyval.val) = NEW_LAMBDA((yyvsp[-2].val), (yyvsp[0].val), &loc);
9403  nd_set_line((yyval.val)->nd_body, (yylsp[0]).end_pos.lineno);
9404  nd_set_line((yyval.val), (yylsp[-2]).end_pos.lineno);
9405  }
9406 #endif
9407  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(lambda,v1,v2);(yyval.val)=v3;}
9408  numparam_pop(p, (yyvsp[-3].node));
9409  dyna_pop(p, (yyvsp[-6].vars));
9410  }
9411 #line 9407 "ripper.c" /* yacc.c:1646 */
9412  break;
9413 
9414  case 433:
9415 #line 3521 "ripper.y" /* yacc.c:1646 */
9416  {
9417 #if 0
9418  (yyval.val) = (yyvsp[-2].val);
9420 #endif
9421  {VALUE v1,v2;v1=(yyvsp[-2].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
9422  }
9423 #line 9419 "ripper.c" /* yacc.c:1646 */
9424  break;
9425 
9426  case 434:
9427 #line 3529 "ripper.y" /* yacc.c:1646 */
9428  {
9429 #if 0
9430  if (!args_info_empty_p((yyvsp[0].val)->nd_ainfo))
9432 #endif
9433  (yyval.val) = (yyvsp[0].val);
9434  }
9435 #line 9431 "ripper.c" /* yacc.c:1646 */
9436  break;
9437 
9438  case 435:
9439 #line 3539 "ripper.y" /* yacc.c:1646 */
9440  {
9441  token_info_pop(p, "}", &(yylsp[0]));
9442  (yyval.val) = (yyvsp[-1].val);
9443  }
9444 #line 9440 "ripper.c" /* yacc.c:1646 */
9445  break;
9446 
9447  case 436:
9448 #line 3544 "ripper.y" /* yacc.c:1646 */
9449  {
9450  (yyval.val) = (yyvsp[-1].val);
9451  }
9452 #line 9448 "ripper.c" /* yacc.c:1646 */
9453  break;
9454 
9455  case 437:
9456 #line 3550 "ripper.y" /* yacc.c:1646 */
9457  {
9458  (yyval.val) = (yyvsp[-1].val);
9459 #if 0
9460  (yyval.val)->nd_body->nd_loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
9461  nd_set_line((yyval.val), (yylsp[-2]).end_pos.lineno);
9462 #endif
9463  }
9464 #line 9460 "ripper.c" /* yacc.c:1646 */
9465  break;
9466 
9467  case 438:
9468 #line 3560 "ripper.y" /* yacc.c:1646 */
9469  {
9470 #if 0
9471  if (nd_type((yyvsp[-1].val)) == NODE_YIELD) {
9472  compile_error(p, "block given to yield");
9473  }
9474  else {
9475  block_dup_check(p, (yyvsp[-1].val)->nd_args, (yyvsp[0].val));
9476  }
9477  (yyval.val) = method_add_block(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9478  fixpos((yyval.val), (yyvsp[-1].val));
9479 #endif
9480  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(method_add_block,v1,v2);(yyval.val)=v3;}
9481  }
9482 #line 9478 "ripper.c" /* yacc.c:1646 */
9483  break;
9484 
9485  case 439:
9486 #line 3574 "ripper.y" /* yacc.c:1646 */
9487  {
9488 #if 0
9489  (yyval.val) = new_qcall(p, (yyvsp[-2].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
9490 #endif
9491  {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;}
9492  }
9493 #line 9489 "ripper.c" /* yacc.c:1646 */
9494  break;
9495 
9496  case 440:
9497 #line 3581 "ripper.y" /* yacc.c:1646 */
9498  {
9499 #if 0
9500  (yyval.val) = new_command_qcall(p, (yyvsp[-3].val), (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-2]), &(yyloc));
9501 #endif
9502  {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;}
9503  }
9504 #line 9500 "ripper.c" /* yacc.c:1646 */
9505  break;
9506 
9507  case 441:
9508 #line 3588 "ripper.y" /* yacc.c:1646 */
9509  {
9510 #if 0
9511  (yyval.val) = new_command_qcall(p, (yyvsp[-3].val), (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-2]), &(yyloc));
9512 #endif
9513  {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;}
9514  }
9515 #line 9511 "ripper.c" /* yacc.c:1646 */
9516  break;
9517 
9518  case 442:
9519 #line 3597 "ripper.y" /* yacc.c:1646 */
9520  {
9521 #if 0
9522  (yyval.val) = (yyvsp[-1].val);
9523  (yyval.val)->nd_args = (yyvsp[0].val);
9524  nd_set_last_loc((yyvsp[-1].val), (yylsp[0]).end_pos);
9525 #endif
9526  {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;}
9527  }
9528 #line 9524 "ripper.c" /* yacc.c:1646 */
9529  break;
9530 
9531  case 443:
9532 #line 3606 "ripper.y" /* yacc.c:1646 */
9533  {
9534 #if 0
9535  (yyval.val) = new_qcall(p, (yyvsp[-2].val), (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=(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;}
9539  }
9540 #line 9536 "ripper.c" /* yacc.c:1646 */
9541  break;
9542 
9543  case 444:
9544 #line 3614 "ripper.y" /* yacc.c:1646 */
9545  {
9546 #if 0
9547  (yyval.val) = new_qcall(p, ID2VAL(idCOLON2), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
9548  nd_set_line((yyval.val), (yylsp[-1]).end_pos.lineno);
9549 #endif
9550  {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;}
9551  }
9552 #line 9548 "ripper.c" /* yacc.c:1646 */
9553  break;
9554 
9555  case 445:
9556 #line 3622 "ripper.y" /* yacc.c:1646 */
9557  {
9558 #if 0
9559  (yyval.val) = new_qcall(p, ID2VAL(idCOLON2), (yyvsp[-2].val), (yyvsp[0].val), Qnull, &(yylsp[0]), &(yyloc));
9560 #endif
9561  {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;}
9562  }
9563 #line 9559 "ripper.c" /* yacc.c:1646 */
9564  break;
9565 
9566  case 446:
9567 #line 3629 "ripper.y" /* yacc.c:1646 */
9568  {
9569 #if 0
9570  (yyval.val) = new_qcall(p, (yyvsp[-1].val), (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=(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;}
9574  }
9575 #line 9571 "ripper.c" /* yacc.c:1646 */
9576  break;
9577 
9578  case 447:
9579 #line 3637 "ripper.y" /* yacc.c:1646 */
9580  {
9581 #if 0
9582  (yyval.val) = new_qcall(p, ID2VAL(idCOLON2), (yyvsp[-2].val), ID2VAL(idCall), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
9583  nd_set_line((yyval.val), (yylsp[-1]).end_pos.lineno);
9584 #endif
9585  {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;}
9586  }
9587 #line 9583 "ripper.c" /* yacc.c:1646 */
9588  break;
9589 
9590  case 448:
9591 #line 3645 "ripper.y" /* yacc.c:1646 */
9592  {
9593 #if 0
9594  (yyval.val) = NEW_SUPER((yyvsp[0].val), &(yyloc));
9595 #endif
9596  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(super,v1);(yyval.val)=v2;}
9597  }
9598 #line 9594 "ripper.c" /* yacc.c:1646 */
9599  break;
9600 
9601  case 449:
9602 #line 3652 "ripper.y" /* yacc.c:1646 */
9603  {
9604 #if 0
9605  (yyval.val) = NEW_ZSUPER(&(yyloc));
9606 #endif
9607  {VALUE v1;v1=dispatch0(zsuper);(yyval.val)=v1;}
9608  }
9609 #line 9605 "ripper.c" /* yacc.c:1646 */
9610  break;
9611 
9612  case 450:
9613 #line 3659 "ripper.y" /* yacc.c:1646 */
9614  {
9615 #if 0
9616  if ((yyvsp[-3].val) && nd_type((yyvsp[-3].val)) == NODE_SELF)
9617  (yyval.val) = NEW_FCALL(tAREF, (yyvsp[-1].val), &(yyloc));
9618  else
9619  (yyval.val) = NEW_CALL((yyvsp[-3].val), tAREF, (yyvsp[-1].val), &(yyloc));
9620  fixpos((yyval.val), (yyvsp[-3].val));
9621 #endif
9622  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=escape_Qundef((yyvsp[-1].val));v3=dispatch2(aref,v1,v2);(yyval.val)=v3;}
9623  }
9624 #line 9620 "ripper.c" /* yacc.c:1646 */
9625  break;
9626 
9627  case 451:
9628 #line 3672 "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 452:
9640 #line 3680 "ripper.y" /* yacc.c:1646 */
9641  {
9642  (yyval.val) = (yyvsp[-1].val);
9643 #if 0
9644  (yyval.val)->nd_body->nd_loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
9645  nd_set_line((yyval.val), (yylsp[-2]).end_pos.lineno);
9646 #endif
9647  }
9648 #line 9644 "ripper.c" /* yacc.c:1646 */
9649  break;
9650 
9651  case 453:
9652 #line 3689 "ripper.y" /* yacc.c:1646 */
9653  {(yyval.vars) = dyna_push(p);}
9654 #line 9650 "ripper.c" /* yacc.c:1646 */
9655  break;
9656 
9657  case 454:
9658 #line 3690 "ripper.y" /* yacc.c:1646 */
9659  {
9660  (yyval.num) = p->max_numparam;
9661  p->max_numparam = 0;
9662  }
9663 #line 9659 "ripper.c" /* yacc.c:1646 */
9664  break;
9665 
9666  case 455:
9667 #line 3694 "ripper.y" /* yacc.c:1646 */
9668  {
9669  (yyval.node) = numparam_push(p);
9670  }
9671 #line 9667 "ripper.c" /* yacc.c:1646 */
9672  break;
9673 
9674  case 456:
9675 #line 3698 "ripper.y" /* yacc.c:1646 */
9676  {
9677  int max_numparam = p->max_numparam;
9678  p->max_numparam = (yyvsp[-3].num);
9679  (yyvsp[-1].val) = args_with_numbered(p, (yyvsp[-1].val), max_numparam);
9680 #if 0
9681  (yyval.val) = NEW_ITER((yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9682 #endif
9683  {VALUE v1,v2,v3;v1=escape_Qundef((yyvsp[-1].val));v2=(yyvsp[0].val);v3=dispatch2(brace_block,v1,v2);(yyval.val)=v3;}
9684  numparam_pop(p, (yyvsp[-2].node));
9685  dyna_pop(p, (yyvsp[-4].vars));
9686  }
9687 #line 9683 "ripper.c" /* yacc.c:1646 */
9688  break;
9689 
9690  case 457:
9691 #line 3711 "ripper.y" /* yacc.c:1646 */
9692  {(yyval.vars) = dyna_push(p);}
9693 #line 9689 "ripper.c" /* yacc.c:1646 */
9694  break;
9695 
9696  case 458:
9697 #line 3712 "ripper.y" /* yacc.c:1646 */
9698  {
9699  (yyval.num) = p->max_numparam;
9700  p->max_numparam = 0;
9701  }
9702 #line 9698 "ripper.c" /* yacc.c:1646 */
9703  break;
9704 
9705  case 459:
9706 #line 3716 "ripper.y" /* yacc.c:1646 */
9707  {
9708  (yyval.node) = numparam_push(p);
9709  CMDARG_PUSH(0);
9710  }
9711 #line 9707 "ripper.c" /* yacc.c:1646 */
9712  break;
9713 
9714  case 460:
9715 #line 3721 "ripper.y" /* yacc.c:1646 */
9716  {
9717  int max_numparam = p->max_numparam;
9718  p->max_numparam = (yyvsp[-3].num);
9719  (yyvsp[-1].val) = args_with_numbered(p, (yyvsp[-1].val), max_numparam);
9720 #if 0
9721  (yyval.val) = NEW_ITER((yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9722 #endif
9723  {VALUE v1,v2,v3;v1=escape_Qundef((yyvsp[-1].val));v2=(yyvsp[0].val);v3=dispatch2(do_block,v1,v2);(yyval.val)=v3;}
9724  CMDARG_POP();
9725  numparam_pop(p, (yyvsp[-2].node));
9726  dyna_pop(p, (yyvsp[-4].vars));
9727  }
9728 #line 9724 "ripper.c" /* yacc.c:1646 */
9729  break;
9730 
9731  case 461:
9732 #line 3736 "ripper.y" /* yacc.c:1646 */
9733  {
9734 #if 0
9735  check_literal_when(p, (yyvsp[0].val), &(yylsp[0]));
9736  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
9737 #endif
9738  {VALUE v1,v2,v3,v4;v1=dispatch0(args_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(args_add,v2,v3);(yyval.val)=v4;}
9739  }
9740 #line 9736 "ripper.c" /* yacc.c:1646 */
9741  break;
9742 
9743  case 462:
9744 #line 3744 "ripper.y" /* yacc.c:1646 */
9745  {
9746 #if 0
9747  (yyval.val) = NEW_SPLAT((yyvsp[0].val), &(yyloc));
9748 #endif
9749  {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;}
9750  }
9751 #line 9747 "ripper.c" /* yacc.c:1646 */
9752  break;
9753 
9754  case 463:
9755 #line 3751 "ripper.y" /* yacc.c:1646 */
9756  {
9757 #if 0
9758  check_literal_when(p, (yyvsp[0].val), &(yylsp[0]));
9759  (yyval.val) = last_arg_append(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
9760 #endif
9761  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(args_add,v1,v2);(yyval.val)=v3;}
9762  }
9763 #line 9759 "ripper.c" /* yacc.c:1646 */
9764  break;
9765 
9766  case 464:
9767 #line 3759 "ripper.y" /* yacc.c:1646 */
9768  {
9769 #if 0
9770  (yyval.val) = rest_arg_append(p, (yyvsp[-3].val), (yyvsp[0].val), &(yyloc));
9771 #endif
9772  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=(yyvsp[0].val);v3=dispatch2(args_add_star,v1,v2);(yyval.val)=v3;}
9773  }
9774 #line 9770 "ripper.c" /* yacc.c:1646 */
9775  break;
9776 
9777  case 465:
9778 #line 3770 "ripper.y" /* yacc.c:1646 */
9779  {
9780 #if 0
9781  (yyval.val) = NEW_WHEN((yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9782  fixpos((yyval.val), (yyvsp[-3].val));
9783 #endif
9784  {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;}
9785  }
9786 #line 9782 "ripper.c" /* yacc.c:1646 */
9787  break;
9788 
9789  case 468:
9790 #line 3784 "ripper.y" /* yacc.c:1646 */
9791  {
9792  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
9793  p->command_start = FALSE;
9794  (yyval.num) = p->in_kwarg;
9795  p->in_kwarg = 1;
9796  }
9797 #line 9793 "ripper.c" /* yacc.c:1646 */
9798  break;
9799 
9800  case 469:
9801 #line 3790 "ripper.y" /* yacc.c:1646 */
9802  {(yyval.tbl) = push_pvtbl(p);}
9803 #line 9799 "ripper.c" /* yacc.c:1646 */
9804  break;
9805 
9806  case 470:
9807 #line 3791 "ripper.y" /* yacc.c:1646 */
9808  {(yyval.tbl) = push_pktbl(p);}
9809 #line 9805 "ripper.c" /* yacc.c:1646 */
9810  break;
9811 
9812  case 471:
9813 #line 3793 "ripper.y" /* yacc.c:1646 */
9814  {pop_pktbl(p, (yyvsp[-2].tbl));}
9815 #line 9811 "ripper.c" /* yacc.c:1646 */
9816  break;
9817 
9818  case 472:
9819 #line 3794 "ripper.y" /* yacc.c:1646 */
9820  {pop_pvtbl(p, (yyvsp[-4].tbl));}
9821 #line 9817 "ripper.c" /* yacc.c:1646 */
9822  break;
9823 
9824  case 473:
9825 #line 3795 "ripper.y" /* yacc.c:1646 */
9826  {
9827  p->in_kwarg = !!(yyvsp[-6].num);
9828  }
9829 #line 9825 "ripper.c" /* yacc.c:1646 */
9830  break;
9831 
9832  case 474:
9833 #line 3800 "ripper.y" /* yacc.c:1646 */
9834  {
9835 #if 0
9836  (yyval.val) = NEW_IN((yyvsp[-6].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9837 #endif
9838  {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;}
9839  }
9840 #line 9836 "ripper.c" /* yacc.c:1646 */
9841  break;
9842 
9843  case 478:
9844 #line 3814 "ripper.y" /* yacc.c:1646 */
9845  {
9846 #if 0
9847  (yyval.val) = new_if(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(if_mod,v1,v2);(yyval.val)=v3;}
9851  }
9852 #line 9848 "ripper.c" /* yacc.c:1646 */
9853  break;
9854 
9855  case 479:
9856 #line 3822 "ripper.y" /* yacc.c:1646 */
9857  {
9858 #if 0
9859  (yyval.val) = new_unless(p, (yyvsp[0].val), remove_begin((yyvsp[-2].val)), 0, &(yyloc));
9860  fixpos((yyval.val), (yyvsp[0].val));
9861 #endif
9862  {VALUE v1,v2,v3;v1=(yyvsp[0].val);v2=(yyvsp[-2].val);v3=dispatch2(unless_mod,v1,v2);(yyval.val)=v3;}
9863  }
9864 #line 9860 "ripper.c" /* yacc.c:1646 */
9865  break;
9866 
9867  case 481:
9868 #line 3833 "ripper.y" /* yacc.c:1646 */
9869  {
9870  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, 0, Qnone, &(yyloc));
9871  (yyval.val) = new_array_pattern(p, Qnone, get_value((yyvsp[-1].val)), (yyval.val), &(yyloc));
9872  }
9873 #line 9869 "ripper.c" /* yacc.c:1646 */
9874  break;
9875 
9876  case 482:
9877 #line 3838 "ripper.y" /* yacc.c:1646 */
9878  {
9879  (yyval.val) = new_array_pattern(p, Qnone, get_value((yyvsp[-2].val)), (yyvsp[0].val), &(yyloc));
9880 #if 0
9881  nd_set_first_loc((yyval.val), (yylsp[-2]).beg_pos);
9882 #endif
9883 
9884  }
9885 #line 9881 "ripper.c" /* yacc.c:1646 */
9886  break;
9887 
9888  case 483:
9889 #line 3846 "ripper.y" /* yacc.c:1646 */
9890  {
9891  (yyval.val) = new_array_pattern(p, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9892  }
9893 #line 9889 "ripper.c" /* yacc.c:1646 */
9894  break;
9895 
9896  case 484:
9897 #line 3850 "ripper.y" /* yacc.c:1646 */
9898  {
9899  (yyval.val) = new_hash_pattern(p, Qnone, (yyvsp[0].val), &(yyloc));
9900  }
9901 #line 9897 "ripper.c" /* yacc.c:1646 */
9902  break;
9903 
9904  case 486:
9905 #line 3859 "ripper.y" /* yacc.c:1646 */
9906  {
9907 #if 0
9908  NODE *n = NEW_LIST((yyvsp[-2].val), &(yyloc));
9909  n = list_append(p, n, (yyvsp[0].val));
9910  (yyval.val) = new_hash(p, n, &(yyloc));
9911 #endif
9912  {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;}
9913  }
9914 #line 9910 "ripper.c" /* yacc.c:1646 */
9915  break;
9916 
9917  case 488:
9918 #line 3871 "ripper.y" /* yacc.c:1646 */
9919  {
9920 #if 0
9921  (yyval.val) = NEW_NODE(NODE_OR, (yyvsp[-2].val), (yyvsp[0].val), 0, &(yyloc));
9922 #endif
9923  {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;}
9924  }
9925 #line 9921 "ripper.c" /* yacc.c:1646 */
9926  break;
9927 
9928  case 490:
9929 #line 3880 "ripper.y" /* yacc.c:1646 */
9930  {(yyval.tbl) = push_pktbl(p);}
9931 #line 9927 "ripper.c" /* yacc.c:1646 */
9932  break;
9933 
9934  case 491:
9935 #line 3881 "ripper.y" /* yacc.c:1646 */
9936  {(yyval.tbl) = push_pktbl(p);}
9937 #line 9933 "ripper.c" /* yacc.c:1646 */
9938  break;
9939 
9940  case 493:
9941 #line 3885 "ripper.y" /* yacc.c:1646 */
9942  {
9943  pop_pktbl(p, (yyvsp[-2].tbl));
9944  (yyval.val) = new_array_pattern(p, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), &(yyloc));
9945 #if 0
9946  nd_set_first_loc((yyval.val), (yylsp[-3]).beg_pos);
9947 #endif
9948 
9949  }
9950 #line 9946 "ripper.c" /* yacc.c:1646 */
9951  break;
9952 
9953  case 494:
9954 #line 3894 "ripper.y" /* yacc.c:1646 */
9955  {
9956  pop_pktbl(p, (yyvsp[-2].tbl));
9957  (yyval.val) = new_hash_pattern(p, (yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
9958 #if 0
9959  nd_set_first_loc((yyval.val), (yylsp[-3]).beg_pos);
9960 #endif
9961 
9962  }
9963 #line 9959 "ripper.c" /* yacc.c:1646 */
9964  break;
9965 
9966  case 495:
9967 #line 3903 "ripper.y" /* yacc.c:1646 */
9968  {
9969  (yyval.val) = new_array_pattern_tail(p, Qnone, 0, 0, Qnone, &(yyloc));
9970  (yyval.val) = new_array_pattern(p, (yyvsp[-2].val), Qnone, (yyval.val), &(yyloc));
9971  }
9972 #line 9968 "ripper.c" /* yacc.c:1646 */
9973  break;
9974 
9975  case 496:
9976 #line 3908 "ripper.y" /* yacc.c:1646 */
9977  {
9978  pop_pktbl(p, (yyvsp[-2].tbl));
9979  (yyval.val) = new_array_pattern(p, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), &(yyloc));
9980 #if 0
9981  nd_set_first_loc((yyval.val), (yylsp[-3]).beg_pos);
9982 #endif
9983 
9984  }
9985 #line 9981 "ripper.c" /* yacc.c:1646 */
9986  break;
9987 
9988  case 497:
9989 #line 3917 "ripper.y" /* yacc.c:1646 */
9990  {
9991  pop_pktbl(p, (yyvsp[-2].tbl));
9992  (yyval.val) = new_hash_pattern(p, (yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
9993 #if 0
9994  nd_set_first_loc((yyval.val), (yylsp[-3]).beg_pos);
9995 #endif
9996 
9997  }
9998 #line 9994 "ripper.c" /* yacc.c:1646 */
9999  break;
10000 
10001  case 498:
10002 #line 3926 "ripper.y" /* yacc.c:1646 */
10003  {
10004  (yyval.val) = new_array_pattern_tail(p, Qnone, 0, 0, Qnone, &(yyloc));
10005  (yyval.val) = new_array_pattern(p, (yyvsp[-2].val), Qnone, (yyval.val), &(yyloc));
10006  }
10007 #line 10003 "ripper.c" /* yacc.c:1646 */
10008  break;
10009 
10010  case 499:
10011 #line 3930 "ripper.y" /* yacc.c:1646 */
10012  {(yyval.tbl) = push_pktbl(p);}
10013 #line 10009 "ripper.c" /* yacc.c:1646 */
10014  break;
10015 
10016  case 500:
10017 #line 3931 "ripper.y" /* yacc.c:1646 */
10018  {
10019  pop_pktbl(p, (yyvsp[-2].tbl));
10020  (yyval.val) = new_array_pattern(p, Qnone, Qnone, (yyvsp[-1].val), &(yyloc));
10021  }
10022 #line 10018 "ripper.c" /* yacc.c:1646 */
10023  break;
10024 
10025  case 501:
10026 #line 3936 "ripper.y" /* yacc.c:1646 */
10027  {
10028  (yyval.val) = new_array_pattern_tail(p, Qnone, 0, 0, Qnone, &(yyloc));
10029  (yyval.val) = new_array_pattern(p, Qnone, Qnone, (yyval.val), &(yyloc));
10030  }
10031 #line 10027 "ripper.c" /* yacc.c:1646 */
10032  break;
10033 
10034  case 502:
10035 #line 3941 "ripper.y" /* yacc.c:1646 */
10036  {
10037  (yyval.tbl) = push_pktbl(p);
10038  (yyvsp[0].num) = p->in_kwarg;
10039  p->in_kwarg = 0;
10040  }
10041 #line 10037 "ripper.c" /* yacc.c:1646 */
10042  break;
10043 
10044  case 503:
10045 #line 3947 "ripper.y" /* yacc.c:1646 */
10046  {
10047  pop_pktbl(p, (yyvsp[-2].tbl));
10048  p->in_kwarg = (yyvsp[-3].num);
10049  (yyval.val) = new_hash_pattern(p, Qnone, (yyvsp[-1].val), &(yyloc));
10050  }
10051 #line 10047 "ripper.c" /* yacc.c:1646 */
10052  break;
10053 
10054  case 504:
10055 #line 3953 "ripper.y" /* yacc.c:1646 */
10056  {
10057  (yyval.val) = new_hash_pattern_tail(p, Qnone, 0, &(yyloc));
10058  (yyval.val) = new_hash_pattern(p, Qnone, (yyval.val), &(yyloc));
10059  }
10060 #line 10056 "ripper.c" /* yacc.c:1646 */
10061  break;
10062 
10063  case 505:
10064 #line 3957 "ripper.y" /* yacc.c:1646 */
10065  {(yyval.tbl) = push_pktbl(p);}
10066 #line 10062 "ripper.c" /* yacc.c:1646 */
10067  break;
10068 
10069  case 506:
10070 #line 3958 "ripper.y" /* yacc.c:1646 */
10071  {
10072  pop_pktbl(p, (yyvsp[-2].tbl));
10073  (yyval.val) = (yyvsp[-1].val);
10074  }
10075 #line 10071 "ripper.c" /* yacc.c:1646 */
10076  break;
10077 
10078  case 507:
10079 #line 3965 "ripper.y" /* yacc.c:1646 */
10080  {
10081 #if 0
10082  NODE *pre_args = NEW_LIST((yyvsp[0].val), &(yyloc));
10083  (yyval.val) = new_array_pattern_tail(p, pre_args, 0, 0, Qnone, &(yyloc));
10084 #endif
10085  (yyval.val) = new_array_pattern_tail(p, rb_ary_new_from_args(1, get_value((yyvsp[0].val))), 0, 0, Qnone, &(yyloc));
10086 
10087  }
10088 #line 10084 "ripper.c" /* yacc.c:1646 */
10089  break;
10090 
10091  case 508:
10092 #line 3974 "ripper.y" /* yacc.c:1646 */
10093  {
10094  (yyval.val) = new_array_pattern_tail(p, (yyvsp[0].val), 1, 0, Qnone, &(yyloc));
10095  }
10096 #line 10092 "ripper.c" /* yacc.c:1646 */
10097  break;
10098 
10099  case 509:
10100 #line 3978 "ripper.y" /* yacc.c:1646 */
10101  {
10102 #if 0
10103  (yyval.val) = new_array_pattern_tail(p, list_concat((yyvsp[-1].val), (yyvsp[0].val)), 0, 0, Qnone, &(yyloc));
10104 #endif
10105  VALUE pre_args = rb_ary_concat((yyvsp[-1].val), get_value((yyvsp[0].val)));
10106  (yyval.val) = new_array_pattern_tail(p, pre_args, 0, 0, Qnone, &(yyloc));
10107 
10108  }
10109 #line 10105 "ripper.c" /* yacc.c:1646 */
10110  break;
10111 
10112  case 510:
10113 #line 3987 "ripper.y" /* yacc.c:1646 */
10114  {
10115  (yyval.val) = new_array_pattern_tail(p, (yyvsp[-2].val), 1, (yyvsp[0].val), Qnone, &(yyloc));
10116  }
10117 #line 10113 "ripper.c" /* yacc.c:1646 */
10118  break;
10119 
10120  case 511:
10121 #line 3991 "ripper.y" /* yacc.c:1646 */
10122  {
10123  (yyval.val) = new_array_pattern_tail(p, (yyvsp[-4].val), 1, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10124  }
10125 #line 10121 "ripper.c" /* yacc.c:1646 */
10126  break;
10127 
10128  case 512:
10129 #line 3995 "ripper.y" /* yacc.c:1646 */
10130  {
10131  (yyval.val) = new_array_pattern_tail(p, (yyvsp[-1].val), 1, 0, Qnone, &(yyloc));
10132  }
10133 #line 10129 "ripper.c" /* yacc.c:1646 */
10134  break;
10135 
10136  case 513:
10137 #line 3999 "ripper.y" /* yacc.c:1646 */
10138  {
10139  (yyval.val) = new_array_pattern_tail(p, (yyvsp[-3].val), 1, 0, (yyvsp[0].val), &(yyloc));
10140  }
10141 #line 10137 "ripper.c" /* yacc.c:1646 */
10142  break;
10143 
10144  case 515:
10145 #line 4006 "ripper.y" /* yacc.c:1646 */
10146  {
10147  (yyval.val) = (yyvsp[-1].val);
10148  }
10149 #line 10145 "ripper.c" /* yacc.c:1646 */
10150  break;
10151 
10152  case 516:
10153 #line 4010 "ripper.y" /* yacc.c:1646 */
10154  {
10155 #if 0
10156  (yyval.val) = list_concat((yyvsp[-2].val), (yyvsp[-1].val));
10157 #endif
10158  (yyval.val)=rb_ary_concat((yyvsp[-2].val), get_value((yyvsp[-1].val)));
10159  }
10160 #line 10156 "ripper.c" /* yacc.c:1646 */
10161  break;
10162 
10163  case 517:
10164 #line 4019 "ripper.y" /* yacc.c:1646 */
10165  {
10166  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, (yyvsp[0].val), Qnone, &(yyloc));
10167  }
10168 #line 10164 "ripper.c" /* yacc.c:1646 */
10169  break;
10170 
10171  case 518:
10172 #line 4023 "ripper.y" /* yacc.c:1646 */
10173  {
10174  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10175  }
10176 #line 10172 "ripper.c" /* yacc.c:1646 */
10177  break;
10178 
10179  case 519:
10180 #line 4027 "ripper.y" /* yacc.c:1646 */
10181  {
10182  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, 0, Qnone, &(yyloc));
10183  }
10184 #line 10180 "ripper.c" /* yacc.c:1646 */
10185  break;
10186 
10187  case 520:
10188 #line 4031 "ripper.y" /* yacc.c:1646 */
10189  {
10190  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, 0, (yyvsp[0].val), &(yyloc));
10191  }
10192 #line 10188 "ripper.c" /* yacc.c:1646 */
10193  break;
10194 
10195  case 522:
10196 #line 4038 "ripper.y" /* yacc.c:1646 */
10197  {
10198 #if 0
10199  (yyval.val) = list_concat((yyvsp[-2].val), (yyvsp[0].val));
10200 #endif
10201  (yyval.val)=rb_ary_concat((yyvsp[-2].val), get_value((yyvsp[0].val)));
10202  }
10203 #line 10199 "ripper.c" /* yacc.c:1646 */
10204  break;
10205 
10206  case 523:
10207 #line 4047 "ripper.y" /* yacc.c:1646 */
10208  {
10209 #if 0
10210  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
10211 #endif
10212  (yyval.val)=rb_ary_new_from_args(1, get_value((yyvsp[0].val)));
10213  }
10214 #line 10210 "ripper.c" /* yacc.c:1646 */
10215  break;
10216 
10217  case 524:
10218 #line 4056 "ripper.y" /* yacc.c:1646 */
10219  {
10220  (yyval.val) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[-2].val), &(yyloc)), (yyvsp[0].val), &(yyloc));
10221  }
10222 #line 10218 "ripper.c" /* yacc.c:1646 */
10223  break;
10224 
10225  case 525:
10226 #line 4060 "ripper.y" /* yacc.c:1646 */
10227  {
10228  (yyval.val) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[0].val), &(yyloc)), 0, &(yyloc));
10229  }
10230 #line 10226 "ripper.c" /* yacc.c:1646 */
10231  break;
10232 
10233  case 526:
10234 #line 4064 "ripper.y" /* yacc.c:1646 */
10235  {
10236  (yyval.val) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[-1].val), &(yyloc)), 0, &(yyloc));
10237  }
10238 #line 10234 "ripper.c" /* yacc.c:1646 */
10239  break;
10240 
10241  case 527:
10242 #line 4068 "ripper.y" /* yacc.c:1646 */
10243  {
10244  (yyval.val) = new_hash_pattern_tail(p, new_hash(p, Qnone, &(yyloc)), (yyvsp[0].val), &(yyloc));
10245  }
10246 #line 10242 "ripper.c" /* yacc.c:1646 */
10247  break;
10248 
10249  case 528:
10250 #line 4072 "ripper.y" /* yacc.c:1646 */
10251  {
10252  (yyval.val) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[-2].val), &(yyloc)), ID2VAL(idNil), &(yyloc));
10253  }
10254 #line 10250 "ripper.c" /* yacc.c:1646 */
10255  break;
10256 
10257  case 529:
10258 #line 4076 "ripper.y" /* yacc.c:1646 */
10259  {
10260  (yyval.val) = new_hash_pattern_tail(p, new_hash(p, Qnone, &(yyloc)), ID2VAL(idNil), &(yyloc));
10261  }
10262 #line 10258 "ripper.c" /* yacc.c:1646 */
10263  break;
10264 
10265  case 530:
10266 #line 4082 "ripper.y" /* yacc.c:1646 */
10267  {(yyval.val)=rb_ary_new_from_args(1, (yyvsp[0].val));}
10268 #line 10264 "ripper.c" /* yacc.c:1646 */
10269  break;
10270 
10271  case 531:
10272 #line 4084 "ripper.y" /* yacc.c:1646 */
10273  {
10274 #if 0
10275  (yyval.val) = list_concat((yyvsp[-2].val), (yyvsp[0].val));
10276 #endif
10277  (yyval.val)=rb_ary_push((yyvsp[-2].val), (yyvsp[0].val));
10278  }
10279 #line 10275 "ripper.c" /* yacc.c:1646 */
10280  break;
10281 
10282  case 532:
10283 #line 4093 "ripper.y" /* yacc.c:1646 */
10284  {
10285  error_duplicate_pattern_key(p, get_id((yyvsp[-1].val)), &(yylsp[-1]));
10286 #if 0
10287  (yyval.val) = list_append(p, NEW_LIST(NEW_LIT(ID2SYM((yyvsp[-1].val)), &(yyloc)), &(yyloc)), (yyvsp[0].val));
10288 #endif
10289  (yyval.val)=rb_ary_new_from_args(2, get_value((yyvsp[-1].val)), get_value((yyvsp[0].val)));
10290  }
10291 #line 10287 "ripper.c" /* yacc.c:1646 */
10292  break;
10293 
10294  case 533:
10295 #line 4101 "ripper.y" /* yacc.c:1646 */
10296  {
10297  error_duplicate_pattern_key(p, get_id((yyvsp[0].val)), &(yylsp[0]));
10298  if ((yyvsp[0].val) && !is_local_id(get_id((yyvsp[0].val)))) {
10299  yyerror1(&(yylsp[0]), "key must be valid as local variables");
10300  }
10301  error_duplicate_pattern_variable(p, get_id((yyvsp[0].val)), &(yylsp[0]));
10302 #if 0
10303  (yyval.val) = list_append(p, NEW_LIST(NEW_LIT(ID2SYM((yyvsp[0].val)), &(yyloc)), &(yyloc)), assignable(p, (yyvsp[0].val), 0, &(yyloc)));
10304 #endif
10305  (yyval.val)=rb_ary_new_from_args(2, get_value((yyvsp[0].val)), Qnil);
10306  }
10307 #line 10303 "ripper.c" /* yacc.c:1646 */
10308  break;
10309 
10310  case 535:
10311 #line 4116 "ripper.y" /* yacc.c:1646 */
10312  {
10313  YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
10314 #if 0
10315  if (!(yyvsp[-1].val) || nd_type((yyvsp[-1].val)) == NODE_STR) {
10316  NODE *node = dsym_node(p, (yyvsp[-1].val), &loc);
10317  (yyval.val) = SYM2ID(node->nd_lit);
10318  }
10319 #endif
10320  if (ripper_is_node_yylval((yyvsp[-1].val)) && RNODE((yyvsp[-1].val))->nd_cval) {
10321  VALUE label = RNODE((yyvsp[-1].val))->nd_cval;
10322  VALUE rval = RNODE((yyvsp[-1].val))->nd_rval;
10323  (yyval.val) = ripper_new_yylval(p, rb_intern_str(label), rval, label);
10324  RNODE((yyval.val))->nd_loc = loc;
10325  }
10326 
10327  else {
10328  yyerror1(&loc, "symbol literal with interpolation is not allowed");
10329  (yyval.val) = 0;
10330  }
10331  }
10332 #line 10328 "ripper.c" /* yacc.c:1646 */
10333  break;
10334 
10335  case 536:
10336 #line 4139 "ripper.y" /* yacc.c:1646 */
10337  {
10338  (yyval.val) = (yyvsp[0].val);
10339  }
10340 #line 10336 "ripper.c" /* yacc.c:1646 */
10341  break;
10342 
10343  case 537:
10344 #line 4143 "ripper.y" /* yacc.c:1646 */
10345  {
10346  (yyval.val) = 0;
10347  }
10348 #line 10344 "ripper.c" /* yacc.c:1646 */
10349  break;
10350 
10351  case 538:
10352 #line 4149 "ripper.y" /* yacc.c:1646 */
10353  {
10354  (yyval.val) = 0;
10355  }
10356 #line 10352 "ripper.c" /* yacc.c:1646 */
10357  break;
10358 
10359  case 540:
10360 #line 4156 "ripper.y" /* yacc.c:1646 */
10361  {
10362 #if 0
10363  value_expr((yyvsp[-2].val));
10364  value_expr((yyvsp[0].val));
10365  (yyval.val) = NEW_DOT2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10366 #endif
10367  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
10368  }
10369 #line 10365 "ripper.c" /* yacc.c:1646 */
10370  break;
10371 
10372  case 541:
10373 #line 4165 "ripper.y" /* yacc.c:1646 */
10374  {
10375 #if 0
10376  value_expr((yyvsp[-2].val));
10377  value_expr((yyvsp[0].val));
10378  (yyval.val) = NEW_DOT3((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10379 #endif
10380  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
10381  }
10382 #line 10378 "ripper.c" /* yacc.c:1646 */
10383  break;
10384 
10385  case 542:
10386 #line 4174 "ripper.y" /* yacc.c:1646 */
10387  {
10388 #if 0
10389  YYLTYPE loc;
10390  loc.beg_pos = (yylsp[0]).end_pos;
10391  loc.end_pos = (yylsp[0]).end_pos;
10392 
10393  value_expr((yyvsp[-1].val));
10394  (yyval.val) = NEW_DOT2((yyvsp[-1].val), new_nil(&loc), &(yyloc));
10395 #endif
10396  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
10397  }
10398 #line 10394 "ripper.c" /* yacc.c:1646 */
10399  break;
10400 
10401  case 543:
10402 #line 4186 "ripper.y" /* yacc.c:1646 */
10403  {
10404 #if 0
10405  YYLTYPE loc;
10406  loc.beg_pos = (yylsp[0]).end_pos;
10407  loc.end_pos = (yylsp[0]).end_pos;
10408 
10409  value_expr((yyvsp[-1].val));
10410  (yyval.val) = NEW_DOT3((yyvsp[-1].val), new_nil(&loc), &(yyloc));
10411 #endif
10412  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
10413  }
10414 #line 10410 "ripper.c" /* yacc.c:1646 */
10415  break;
10416 
10417  case 547:
10418 #line 4201 "ripper.y" /* yacc.c:1646 */
10419  {
10420 #if 0
10421  YYLTYPE loc;
10422  loc.beg_pos = (yylsp[-1]).beg_pos;
10423  loc.end_pos = (yylsp[-1]).beg_pos;
10424 
10425  value_expr((yyvsp[0].val));
10426  (yyval.val) = NEW_DOT2(new_nil(&loc), (yyvsp[0].val), &(yyloc));
10427 #endif
10428  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[0].val);v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
10429  }
10430 #line 10426 "ripper.c" /* yacc.c:1646 */
10431  break;
10432 
10433  case 548:
10434 #line 4213 "ripper.y" /* yacc.c:1646 */
10435  {
10436 #if 0
10437  YYLTYPE loc;
10438  loc.beg_pos = (yylsp[-1]).beg_pos;
10439  loc.end_pos = (yylsp[-1]).beg_pos;
10440 
10441  value_expr((yyvsp[0].val));
10442  (yyval.val) = NEW_DOT3(new_nil(&loc), (yyvsp[0].val), &(yyloc));
10443 #endif
10444  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[0].val);v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
10445  }
10446 #line 10442 "ripper.c" /* yacc.c:1646 */
10447  break;
10448 
10449  case 557:
10450 #line 4235 "ripper.y" /* yacc.c:1646 */
10451  {
10452 #if 0
10453  if (!((yyval.val) = gettable(p, (yyvsp[0].val), &(yyloc)))) (yyval.val) = NEW_BEGIN(0, &(yyloc));
10454 #endif
10455  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
10456  }
10457 #line 10453 "ripper.c" /* yacc.c:1646 */
10458  break;
10459 
10460  case 558:
10461 #line 4242 "ripper.y" /* yacc.c:1646 */
10462  {
10463  token_info_push(p, "->", &(yylsp[0]));
10464  }
10465 #line 10461 "ripper.c" /* yacc.c:1646 */
10466  break;
10467 
10468  case 559:
10469 #line 4246 "ripper.y" /* yacc.c:1646 */
10470  {
10471  (yyval.val) = (yyvsp[0].val);
10472 #if 0
10473  nd_set_first_loc((yyval.val), (yylsp[-2]).beg_pos);
10474 #endif
10475  }
10476 #line 10472 "ripper.c" /* yacc.c:1646 */
10477  break;
10478 
10479  case 560:
10480 #line 4255 "ripper.y" /* yacc.c:1646 */
10481  {
10482 #if 0
10483  error_duplicate_pattern_variable(p, (yyvsp[0].val), &(yylsp[0]));
10484  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
10485 #endif
10486  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
10487  }
10488 #line 10484 "ripper.c" /* yacc.c:1646 */
10489  break;
10490 
10491  case 561:
10492 #line 4265 "ripper.y" /* yacc.c:1646 */
10493  {
10494 #if 0
10495  NODE *n = gettable(p, (yyvsp[0].val), &(yyloc));
10496  if (!(nd_type(n) == NODE_LVAR || nd_type(n) == NODE_DVAR)) {
10497  compile_error(p, "%"PRIsVALUE": no such local variable", rb_id2str((yyvsp[0].val)));
10498  }
10499  (yyval.val) = n;
10500 #endif
10501  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
10502  }
10503 #line 10499 "ripper.c" /* yacc.c:1646 */
10504  break;
10505 
10506  case 562:
10507 #line 4278 "ripper.y" /* yacc.c:1646 */
10508  {
10509 #if 0
10510  (yyval.val) = NEW_COLON3((yyvsp[0].val), &(yyloc));
10511 #endif
10512  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(top_const_ref,v1);(yyval.val)=v2;}
10513  }
10514 #line 10510 "ripper.c" /* yacc.c:1646 */
10515  break;
10516 
10517  case 563:
10518 #line 4285 "ripper.y" /* yacc.c:1646 */
10519  {
10520 #if 0
10521  (yyval.val) = NEW_COLON2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10522 #endif
10523  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(const_path_ref,v1,v2);(yyval.val)=v3;}
10524  }
10525 #line 10521 "ripper.c" /* yacc.c:1646 */
10526  break;
10527 
10528  case 564:
10529 #line 4292 "ripper.y" /* yacc.c:1646 */
10530  {
10531 #if 0
10532  (yyval.val) = gettable(p, (yyvsp[0].val), &(yyloc));
10533 #endif
10534  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
10535  }
10536 #line 10532 "ripper.c" /* yacc.c:1646 */
10537  break;
10538 
10539  case 565:
10540 #line 4303 "ripper.y" /* yacc.c:1646 */
10541  {
10542 #if 0
10543  (yyval.val) = NEW_RESBODY((yyvsp[-4].val),
10544  (yyvsp[-3].val) ? block_append(p, node_assign(p, (yyvsp[-3].val), NEW_ERRINFO(&(yylsp[-3])), &(yylsp[-3])), (yyvsp[-1].val)) : (yyvsp[-1].val),
10545  (yyvsp[0].val), &(yyloc));
10546  fixpos((yyval.val), (yyvsp[-4].val)?(yyvsp[-4].val):(yyvsp[-1].val));
10547 #endif
10548  {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;}
10549  }
10550 #line 10546 "ripper.c" /* yacc.c:1646 */
10551  break;
10552 
10553  case 567:
10554 #line 4316 "ripper.y" /* yacc.c:1646 */
10555  {
10556 #if 0
10557  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
10558 #endif
10559  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
10560  }
10561 #line 10557 "ripper.c" /* yacc.c:1646 */
10562  break;
10563 
10564  case 568:
10565 #line 4323 "ripper.y" /* yacc.c:1646 */
10566  {
10567 #if 0
10568  if (!((yyval.val) = splat_array((yyvsp[0].val)))) (yyval.val) = (yyvsp[0].val);
10569 #endif
10570  (yyval.val)=(yyvsp[0].val);
10571  }
10572 #line 10568 "ripper.c" /* yacc.c:1646 */
10573  break;
10574 
10575  case 570:
10576 #line 4333 "ripper.y" /* yacc.c:1646 */
10577  {
10578  (yyval.val) = (yyvsp[0].val);
10579  }
10580 #line 10576 "ripper.c" /* yacc.c:1646 */
10581  break;
10582 
10583  case 572:
10584 #line 4340 "ripper.y" /* yacc.c:1646 */
10585  {
10586 #if 0
10587  (yyval.val) = (yyvsp[0].val);
10588 #endif
10589  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(ensure,v1);(yyval.val)=v2;}
10590  }
10591 #line 10587 "ripper.c" /* yacc.c:1646 */
10592  break;
10593 
10594  case 576:
10595 #line 4354 "ripper.y" /* yacc.c:1646 */
10596  {
10597 #if 0
10598  NODE *node = (yyvsp[0].val);
10599  if (!node) {
10600  node = NEW_STR(STR_NEW0(), &(yyloc));
10601  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit);
10602  }
10603  else {
10604  node = evstr2dstr(p, node);
10605  }
10606  (yyval.val) = node;
10607 #endif
10608  (yyval.val)=(yyvsp[0].val);
10609  }
10610 #line 10606 "ripper.c" /* yacc.c:1646 */
10611  break;
10612 
10613  case 579:
10614 #line 4373 "ripper.y" /* yacc.c:1646 */
10615  {
10616 #if 0
10617  (yyval.val) = literal_concat(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10618 #endif
10619  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(string_concat,v1,v2);(yyval.val)=v3;}
10620  }
10621 #line 10617 "ripper.c" /* yacc.c:1646 */
10622  break;
10623 
10624  case 580:
10625 #line 4382 "ripper.y" /* yacc.c:1646 */
10626  {
10627 #if 0
10628  (yyval.val) = heredoc_dedent(p, (yyvsp[-1].val));
10629  if ((yyval.val)) nd_set_loc((yyval.val), &(yyloc));
10630 #endif
10631  {VALUE v1,v2;v1=heredoc_dedent(p, (yyvsp[-1].val));v2=dispatch1(string_literal,v1);(yyval.val)=v2;}
10632  }
10633 #line 10629 "ripper.c" /* yacc.c:1646 */
10634  break;
10635 
10636  case 581:
10637 #line 4392 "ripper.y" /* yacc.c:1646 */
10638  {
10639 #if 0
10640  (yyval.val) = new_xstring(p, heredoc_dedent(p, (yyvsp[-1].val)), &(yyloc));
10641 #endif
10642  {VALUE v1,v2;v1=heredoc_dedent(p, (yyvsp[-1].val));v2=dispatch1(xstring_literal,v1);(yyval.val)=v2;}
10643  }
10644 #line 10640 "ripper.c" /* yacc.c:1646 */
10645  break;
10646 
10647  case 582:
10648 #line 4401 "ripper.y" /* yacc.c:1646 */
10649  {
10650  (yyval.val) = new_regexp(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10651  }
10652 #line 10648 "ripper.c" /* yacc.c:1646 */
10653  break;
10654 
10655  case 583:
10656 #line 4407 "ripper.y" /* yacc.c:1646 */
10657  {
10658 #if 0
10659  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
10660 #endif
10661  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(array,v1);(yyval.val)=v2;}
10662  }
10663 #line 10659 "ripper.c" /* yacc.c:1646 */
10664  break;
10665 
10666  case 584:
10667 #line 4416 "ripper.y" /* yacc.c:1646 */
10668  {
10669 #if 0
10670  (yyval.val) = 0;
10671 #endif
10672  {VALUE v1;v1=dispatch0(words_new);(yyval.val)=v1;}
10673  }
10674 #line 10670 "ripper.c" /* yacc.c:1646 */
10675  break;
10676 
10677  case 585:
10678 #line 4423 "ripper.y" /* yacc.c:1646 */
10679  {
10680 #if 0
10681  (yyval.val) = list_append(p, (yyvsp[-2].val), evstr2dstr(p, (yyvsp[-1].val)));
10682 #endif
10683  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(words_add,v1,v2);(yyval.val)=v3;}
10684  }
10685 #line 10681 "ripper.c" /* yacc.c:1646 */
10686  break;
10687 
10688  case 586:
10689 #line 4432 "ripper.y" /* yacc.c:1646 */
10690  {{VALUE v1,v2,v3,v4;v1=dispatch0(word_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(word_add,v2,v3);(yyval.val)=v4;}}
10691 #line 10687 "ripper.c" /* yacc.c:1646 */
10692  break;
10693 
10694  case 587:
10695 #line 4434 "ripper.y" /* yacc.c:1646 */
10696  {
10697 #if 0
10698  (yyval.val) = literal_concat(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10699 #endif
10700  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(word_add,v1,v2);(yyval.val)=v3;}
10701  }
10702 #line 10698 "ripper.c" /* yacc.c:1646 */
10703  break;
10704 
10705  case 588:
10706 #line 4443 "ripper.y" /* yacc.c:1646 */
10707  {
10708 #if 0
10709  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
10710 #endif
10711  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(array,v1);(yyval.val)=v2;}
10712  }
10713 #line 10709 "ripper.c" /* yacc.c:1646 */
10714  break;
10715 
10716  case 589:
10717 #line 4452 "ripper.y" /* yacc.c:1646 */
10718  {
10719 #if 0
10720  (yyval.val) = 0;
10721 #endif
10722  {VALUE v1;v1=dispatch0(symbols_new);(yyval.val)=v1;}
10723  }
10724 #line 10720 "ripper.c" /* yacc.c:1646 */
10725  break;
10726 
10727  case 590:
10728 #line 4459 "ripper.y" /* yacc.c:1646 */
10729  {
10730 #if 0
10731  (yyval.val) = symbol_append(p, (yyvsp[-2].val), evstr2dstr(p, (yyvsp[-1].val)));
10732 #endif
10733  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(symbols_add,v1,v2);(yyval.val)=v3;}
10734  }
10735 #line 10731 "ripper.c" /* yacc.c:1646 */
10736  break;
10737 
10738  case 591:
10739 #line 4468 "ripper.y" /* yacc.c:1646 */
10740  {
10741 #if 0
10742  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
10743 #endif
10744  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(array,v1);(yyval.val)=v2;}
10745  }
10746 #line 10742 "ripper.c" /* yacc.c:1646 */
10747  break;
10748 
10749  case 592:
10750 #line 4477 "ripper.y" /* yacc.c:1646 */
10751  {
10752 #if 0
10753  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
10754 #endif
10755  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(array,v1);(yyval.val)=v2;}
10756  }
10757 #line 10753 "ripper.c" /* yacc.c:1646 */
10758  break;
10759 
10760  case 593:
10761 #line 4486 "ripper.y" /* yacc.c:1646 */
10762  {
10763 #if 0
10764  (yyval.val) = 0;
10765 #endif
10766  {VALUE v1;v1=dispatch0(qwords_new);(yyval.val)=v1;}
10767  }
10768 #line 10764 "ripper.c" /* yacc.c:1646 */
10769  break;
10770 
10771  case 594:
10772 #line 4493 "ripper.y" /* yacc.c:1646 */
10773  {
10774 #if 0
10775  (yyval.val) = list_append(p, (yyvsp[-2].val), (yyvsp[-1].val));
10776 #endif
10777  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(qwords_add,v1,v2);(yyval.val)=v3;}
10778  }
10779 #line 10775 "ripper.c" /* yacc.c:1646 */
10780  break;
10781 
10782  case 595:
10783 #line 4502 "ripper.y" /* yacc.c:1646 */
10784  {
10785 #if 0
10786  (yyval.val) = 0;
10787 #endif
10788  {VALUE v1;v1=dispatch0(qsymbols_new);(yyval.val)=v1;}
10789  }
10790 #line 10786 "ripper.c" /* yacc.c:1646 */
10791  break;
10792 
10793  case 596:
10794 #line 4509 "ripper.y" /* yacc.c:1646 */
10795  {
10796 #if 0
10797  (yyval.val) = symbol_append(p, (yyvsp[-2].val), (yyvsp[-1].val));
10798 #endif
10799  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(qsymbols_add,v1,v2);(yyval.val)=v3;}
10800  }
10801 #line 10797 "ripper.c" /* yacc.c:1646 */
10802  break;
10803 
10804  case 597:
10805 #line 4518 "ripper.y" /* yacc.c:1646 */
10806  {
10807 #if 0
10808  (yyval.val) = 0;
10809 #endif
10810  {VALUE v1;v1=dispatch0(string_content);(yyval.val)=v1;}
10811 #if 0
10812 #endif
10813  (yyval.val) = ripper_new_yylval(p, 0, (yyval.val), 0);
10814 
10815  }
10816 #line 10812 "ripper.c" /* yacc.c:1646 */
10817  break;
10818 
10819  case 598:
10820 #line 4529 "ripper.y" /* yacc.c:1646 */
10821  {
10822 #if 0
10823  (yyval.val) = literal_concat(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10824 #endif
10825  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(string_add,v1,v2);(yyval.val)=v3;}
10826 #if 0
10827 #endif
10828  if (ripper_is_node_yylval((yyvsp[-1].val)) && ripper_is_node_yylval((yyvsp[0].val)) &&
10829  !RNODE((yyvsp[-1].val))->nd_cval) {
10830  RNODE((yyvsp[-1].val))->nd_cval = RNODE((yyvsp[0].val))->nd_cval;
10831  RNODE((yyvsp[-1].val))->nd_rval = add_mark_object(p, (yyval.val));
10832  (yyval.val) = (yyvsp[-1].val);
10833  }
10834 
10835  }
10836 #line 10832 "ripper.c" /* yacc.c:1646 */
10837  break;
10838 
10839  case 599:
10840 #line 4547 "ripper.y" /* yacc.c:1646 */
10841  {
10842 #if 0
10843  (yyval.val) = 0;
10844 #endif
10845  {VALUE v1;v1=dispatch0(xstring_new);(yyval.val)=v1;}
10846  }
10847 #line 10843 "ripper.c" /* yacc.c:1646 */
10848  break;
10849 
10850  case 600:
10851 #line 4554 "ripper.y" /* yacc.c:1646 */
10852  {
10853 #if 0
10854  (yyval.val) = literal_concat(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10855 #endif
10856  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(xstring_add,v1,v2);(yyval.val)=v3;}
10857  }
10858 #line 10854 "ripper.c" /* yacc.c:1646 */
10859  break;
10860 
10861  case 601:
10862 #line 4563 "ripper.y" /* yacc.c:1646 */
10863  {
10864 #if 0
10865  (yyval.val) = 0;
10866 #endif
10867  {VALUE v1;v1=dispatch0(regexp_new);(yyval.val)=v1;}
10868 #if 0
10869 #endif
10870  (yyval.val) = ripper_new_yylval(p, 0, (yyval.val), 0);
10871 
10872  }
10873 #line 10869 "ripper.c" /* yacc.c:1646 */
10874  break;
10875 
10876  case 602:
10877 #line 4574 "ripper.y" /* yacc.c:1646 */
10878  {
10879 #if 0
10880  NODE *head = (yyvsp[-1].val), *tail = (yyvsp[0].val);
10881  if (!head) {
10882  (yyval.val) = tail;
10883  }
10884  else if (!tail) {
10885  (yyval.val) = head;
10886  }
10887  else {
10888  switch (nd_type(head)) {
10889  case NODE_STR:
10890  nd_set_type(head, NODE_DSTR);
10891  break;
10892  case NODE_DSTR:
10893  break;
10894  default:
10895  head = list_append(p, NEW_DSTR(Qnil, &(yyloc)), head);
10896  break;
10897  }
10898  (yyval.val) = list_append(p, head, tail);
10899  }
10900 #endif
10901  VALUE s1 = 1, s2 = 0, n1 = (yyvsp[-1].val), n2 = (yyvsp[0].val);
10902  if (ripper_is_node_yylval(n1)) {
10903  s1 = RNODE(n1)->nd_cval;
10904  n1 = RNODE(n1)->nd_rval;
10905  }
10906  if (ripper_is_node_yylval(n2)) {
10907  s2 = RNODE(n2)->nd_cval;
10908  n2 = RNODE(n2)->nd_rval;
10909  }
10910  (yyval.val) = dispatch2(regexp_add, n1, n2);
10911  if (!s1 && s2) {
10912  (yyval.val) = ripper_new_yylval(p, 0, (yyval.val), s2);
10913  }
10914 
10915  }
10916 #line 10912 "ripper.c" /* yacc.c:1646 */
10917  break;
10918 
10919  case 603:
10920 #line 4615 "ripper.y" /* yacc.c:1646 */
10921  {(yyval.val)=ripper_new_yylval(p, 0, get_value((yyvsp[0].val)), (yyvsp[0].val));}
10922 #line 10918 "ripper.c" /* yacc.c:1646 */
10923  break;
10924 
10925  case 604:
10926 #line 4617 "ripper.y" /* yacc.c:1646 */
10927  {
10928  /* need to backup p->lex.strterm so that a string literal `%&foo,#$&,bar&` can be parsed */
10929  (yyval.strterm) = p->lex.strterm;
10930  p->lex.strterm = 0;
10931  SET_LEX_STATE(EXPR_BEG);
10932  }
10933 #line 10929 "ripper.c" /* yacc.c:1646 */
10934  break;
10935 
10936  case 605:
10937 #line 4624 "ripper.y" /* yacc.c:1646 */
10938  {
10939  p->lex.strterm = (yyvsp[-1].strterm);
10940 #if 0
10941  (yyval.val) = NEW_EVSTR((yyvsp[0].val), &(yyloc));
10942  nd_set_line((yyval.val), (yylsp[0]).end_pos.lineno);
10943 #endif
10944  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(string_dvar,v1);(yyval.val)=v2;}
10945  }
10946 #line 10942 "ripper.c" /* yacc.c:1646 */
10947  break;
10948 
10949  case 606:
10950 #line 4633 "ripper.y" /* yacc.c:1646 */
10951  {
10952  CMDARG_PUSH(0);
10953  COND_PUSH(0);
10954  }
10955 #line 10951 "ripper.c" /* yacc.c:1646 */
10956  break;
10957 
10958  case 607:
10959 #line 4637 "ripper.y" /* yacc.c:1646 */
10960  {
10961  /* need to backup p->lex.strterm so that a string literal `%!foo,#{ !0 },bar!` can be parsed */
10962  (yyval.strterm) = p->lex.strterm;
10963  p->lex.strterm = 0;
10964  }
10965 #line 10961 "ripper.c" /* yacc.c:1646 */
10966  break;
10967 
10968  case 608:
10969 #line 4642 "ripper.y" /* yacc.c:1646 */
10970  {
10971  (yyval.num) = p->lex.state;
10972  SET_LEX_STATE(EXPR_BEG);
10973  }
10974 #line 10970 "ripper.c" /* yacc.c:1646 */
10975  break;
10976 
10977  case 609:
10978 #line 4646 "ripper.y" /* yacc.c:1646 */
10979  {
10980  (yyval.num) = p->lex.brace_nest;
10981  p->lex.brace_nest = 0;
10982  }
10983 #line 10979 "ripper.c" /* yacc.c:1646 */
10984  break;
10985 
10986  case 610:
10987 #line 4650 "ripper.y" /* yacc.c:1646 */
10988  {
10989  (yyval.num) = p->heredoc_indent;
10990  p->heredoc_indent = 0;
10991  }
10992 #line 10988 "ripper.c" /* yacc.c:1646 */
10993  break;
10994 
10995  case 611:
10996 #line 4655 "ripper.y" /* yacc.c:1646 */
10997  {
10998  COND_POP();
10999  CMDARG_POP();
11000  p->lex.strterm = (yyvsp[-5].strterm);
11001  SET_LEX_STATE((yyvsp[-4].num));
11002  p->lex.brace_nest = (yyvsp[-3].num);
11003  p->heredoc_indent = (yyvsp[-2].num);
11004  p->heredoc_line_indent = -1;
11005 #if 0
11006  if ((yyvsp[-1].val)) (yyvsp[-1].val)->flags &= ~NODE_FL_NEWLINE;
11007  (yyval.val) = new_evstr(p, (yyvsp[-1].val), &(yyloc));
11008 #endif
11009  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(string_embexpr,v1);(yyval.val)=v2;}
11010  }
11011 #line 11007 "ripper.c" /* yacc.c:1646 */
11012  break;
11013 
11014  case 612:
11015 #line 4672 "ripper.y" /* yacc.c:1646 */
11016  {
11017 #if 0
11018  (yyval.val) = NEW_GVAR((yyvsp[0].val), &(yyloc));
11019 #endif
11020  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
11021  }
11022 #line 11018 "ripper.c" /* yacc.c:1646 */
11023  break;
11024 
11025  case 613:
11026 #line 4679 "ripper.y" /* yacc.c:1646 */
11027  {
11028 #if 0
11029  (yyval.val) = NEW_IVAR((yyvsp[0].val), &(yyloc));
11030 #endif
11031  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
11032  }
11033 #line 11029 "ripper.c" /* yacc.c:1646 */
11034  break;
11035 
11036  case 614:
11037 #line 4686 "ripper.y" /* yacc.c:1646 */
11038  {
11039 #if 0
11040  (yyval.val) = NEW_CVAR((yyvsp[0].val), &(yyloc));
11041 #endif
11042  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
11043  }
11044 #line 11040 "ripper.c" /* yacc.c:1646 */
11045  break;
11046 
11047  case 618:
11048 #line 4700 "ripper.y" /* yacc.c:1646 */
11049  {
11050  SET_LEX_STATE(EXPR_END);
11051 #if 0
11052  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[0].val)), &(yyloc));
11053 #endif
11054  {VALUE v1,v2,v3,v4;v1=(yyvsp[0].val);v2=dispatch1(symbol,v1);v3=v2;v4=dispatch1(symbol_literal,v3);(yyval.val)=v4;}
11055  }
11056 #line 11052 "ripper.c" /* yacc.c:1646 */
11057  break;
11058 
11059  case 623:
11060 #line 4716 "ripper.y" /* yacc.c:1646 */
11061  {
11062  SET_LEX_STATE(EXPR_END);
11063 #if 0
11064  (yyval.val) = dsym_node(p, (yyvsp[-1].val), &(yyloc));
11065 #endif
11066  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(dyna_symbol,v1);(yyval.val)=v2;}
11067  }
11068 #line 11064 "ripper.c" /* yacc.c:1646 */
11069  break;
11070 
11071  case 625:
11072 #line 4727 "ripper.y" /* yacc.c:1646 */
11073  {
11074 #if 0
11075  (yyval.val) = (yyvsp[0].val);
11076  RB_OBJ_WRITE(p->ast, &(yyval.val)->nd_lit, negate_lit(p, (yyval.val)->nd_lit));
11077 #endif
11078  {VALUE v1,v2,v3;v1=ID2VAL(idUMinus);v2=(yyvsp[0].val);v3=dispatch2(unary,v1,v2);(yyval.val)=v3;}
11079  }
11080 #line 11076 "ripper.c" /* yacc.c:1646 */
11081  break;
11082 
11083  case 635:
11084 #line 4749 "ripper.y" /* yacc.c:1646 */
11085  {(yyval.val) = KWD2EID(nil, (yyvsp[0].val));}
11086 #line 11082 "ripper.c" /* yacc.c:1646 */
11087  break;
11088 
11089  case 636:
11090 #line 4750 "ripper.y" /* yacc.c:1646 */
11091  {(yyval.val) = KWD2EID(self, (yyvsp[0].val));}
11092 #line 11088 "ripper.c" /* yacc.c:1646 */
11093  break;
11094 
11095  case 637:
11096 #line 4751 "ripper.y" /* yacc.c:1646 */
11097  {(yyval.val) = KWD2EID(true, (yyvsp[0].val));}
11098 #line 11094 "ripper.c" /* yacc.c:1646 */
11099  break;
11100 
11101  case 638:
11102 #line 4752 "ripper.y" /* yacc.c:1646 */
11103  {(yyval.val) = KWD2EID(false, (yyvsp[0].val));}
11104 #line 11100 "ripper.c" /* yacc.c:1646 */
11105  break;
11106 
11107  case 639:
11108 #line 4753 "ripper.y" /* yacc.c:1646 */
11109  {(yyval.val) = KWD2EID(_FILE__, (yyvsp[0].val));}
11110 #line 11106 "ripper.c" /* yacc.c:1646 */
11111  break;
11112 
11113  case 640:
11114 #line 4754 "ripper.y" /* yacc.c:1646 */
11115  {(yyval.val) = KWD2EID(_LINE__, (yyvsp[0].val));}
11116 #line 11112 "ripper.c" /* yacc.c:1646 */
11117  break;
11118 
11119  case 641:
11120 #line 4755 "ripper.y" /* yacc.c:1646 */
11121  {(yyval.val) = KWD2EID(_ENCODING__, (yyvsp[0].val));}
11122 #line 11118 "ripper.c" /* yacc.c:1646 */
11123  break;
11124 
11125  case 642:
11126 #line 4759 "ripper.y" /* yacc.c:1646 */
11127  {
11128 #if 0
11129  if (!((yyval.val) = gettable(p, (yyvsp[0].val), &(yyloc)))) (yyval.val) = NEW_BEGIN(0, &(yyloc));
11130 #endif
11131  if (id_is_var(p, get_id((yyvsp[0].val)))) {
11132  (yyval.val) = dispatch1(var_ref, (yyvsp[0].val));
11133  }
11134  else {
11135  (yyval.val) = dispatch1(vcall, (yyvsp[0].val));
11136  }
11137 
11138  }
11139 #line 11135 "ripper.c" /* yacc.c:1646 */
11140  break;
11141 
11142  case 643:
11143 #line 4772 "ripper.y" /* yacc.c:1646 */
11144  {
11145 #if 0
11146  if (!((yyval.val) = gettable(p, (yyvsp[0].val), &(yyloc)))) (yyval.val) = NEW_BEGIN(0, &(yyloc));
11147 #endif
11148  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
11149  }
11150 #line 11146 "ripper.c" /* yacc.c:1646 */
11151  break;
11152 
11153  case 644:
11154 #line 4781 "ripper.y" /* yacc.c:1646 */
11155  {
11156 #if 0
11157  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
11158 #endif
11159  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
11160  }
11161 #line 11157 "ripper.c" /* yacc.c:1646 */
11162  break;
11163 
11164  case 645:
11165 #line 4788 "ripper.y" /* yacc.c:1646 */
11166  {
11167 #if 0
11168  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
11169 #endif
11170  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
11171  }
11172 #line 11168 "ripper.c" /* yacc.c:1646 */
11173  break;
11174 
11175  case 648:
11176 #line 4801 "ripper.y" /* yacc.c:1646 */
11177  {
11178  SET_LEX_STATE(EXPR_BEG);
11179  p->command_start = TRUE;
11180  }
11181 #line 11177 "ripper.c" /* yacc.c:1646 */
11182  break;
11183 
11184  case 649:
11185 #line 4806 "ripper.y" /* yacc.c:1646 */
11186  {
11187  (yyval.val) = (yyvsp[-1].val);
11188  }
11189 #line 11185 "ripper.c" /* yacc.c:1646 */
11190  break;
11191 
11192  case 650:
11193 #line 4810 "ripper.y" /* yacc.c:1646 */
11194  {
11195 #if 0
11196  (yyval.val) = 0;
11197 #endif
11198  (yyval.val)=Qnil;
11199  }
11200 #line 11196 "ripper.c" /* yacc.c:1646 */
11201  break;
11202 
11203  case 651:
11204 #line 4819 "ripper.y" /* yacc.c:1646 */
11205  {
11206 #if 0
11207  (yyval.val) = (yyvsp[-1].val);
11208 #endif
11209  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
11210  SET_LEX_STATE(EXPR_BEG);
11211  p->command_start = TRUE;
11212  }
11213 #line 11209 "ripper.c" /* yacc.c:1646 */
11214  break;
11215 
11216  case 652:
11217 #line 4828 "ripper.y" /* yacc.c:1646 */
11218  {
11219  arg_var(p, idFWD_REST);
11220 #if idFWD_KWREST
11221  arg_var(p, idFWD_KWREST);
11222 #endif
11223  arg_var(p, idFWD_BLOCK);
11224 #if 0
11225  (yyval.val) = new_args_tail(p, Qnone, idFWD_KWREST, idFWD_BLOCK, &(yylsp[-1]));
11226  (yyval.val) = new_args(p, Qnone, Qnone, idFWD_REST, Qnone, (yyval.val), &(yylsp[-1]));
11227 #endif
11228  {VALUE v1,v2;v1=params_new(Qnone, Qnone, (yyvsp[-1].val), Qnone, Qnone, Qnone, Qnone);v2=dispatch1(paren,v1);(yyval.val)=v2;}
11229  SET_LEX_STATE(EXPR_BEG);
11230  p->command_start = TRUE;
11231  }
11232 #line 11228 "ripper.c" /* yacc.c:1646 */
11233  break;
11234 
11235  case 653:
11236 #line 4842 "ripper.y" /* yacc.c:1646 */
11237  {
11238  (yyval.num) = p->in_kwarg;
11239  p->in_kwarg = 1;
11240  SET_LEX_STATE(p->lex.state|EXPR_LABEL); /* force for args */
11241  }
11242 #line 11238 "ripper.c" /* yacc.c:1646 */
11243  break;
11244 
11245  case 654:
11246 #line 4848 "ripper.y" /* yacc.c:1646 */
11247  {
11248  p->in_kwarg = !!(yyvsp[-2].num);
11249  (yyval.val) = (yyvsp[-1].val);
11250  SET_LEX_STATE(EXPR_BEG);
11251  p->command_start = TRUE;
11252  }
11253 #line 11249 "ripper.c" /* yacc.c:1646 */
11254  break;
11255 
11256  case 655:
11257 #line 4857 "ripper.y" /* yacc.c:1646 */
11258  {
11259  (yyval.val) = new_args_tail(p, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]));
11260  }
11261 #line 11257 "ripper.c" /* yacc.c:1646 */
11262  break;
11263 
11264  case 656:
11265 #line 4861 "ripper.y" /* yacc.c:1646 */
11266  {
11267  (yyval.val) = new_args_tail(p, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yylsp[-1]));
11268  }
11269 #line 11265 "ripper.c" /* yacc.c:1646 */
11270  break;
11271 
11272  case 657:
11273 #line 4865 "ripper.y" /* yacc.c:1646 */
11274  {
11275  (yyval.val) = new_args_tail(p, Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]));
11276  }
11277 #line 11273 "ripper.c" /* yacc.c:1646 */
11278  break;
11279 
11280  case 658:
11281 #line 4869 "ripper.y" /* yacc.c:1646 */
11282  {
11283  (yyval.val) = new_args_tail(p, Qnone, ID2VAL(idNil), (yyvsp[0].val), &(yylsp[-1]));
11284  }
11285 #line 11281 "ripper.c" /* yacc.c:1646 */
11286  break;
11287 
11288  case 659:
11289 #line 4873 "ripper.y" /* yacc.c:1646 */
11290  {
11291  (yyval.val) = new_args_tail(p, Qnone, Qnone, (yyvsp[0].val), &(yylsp[0]));
11292  }
11293 #line 11289 "ripper.c" /* yacc.c:1646 */
11294  break;
11295 
11296  case 660:
11297 #line 4879 "ripper.y" /* yacc.c:1646 */
11298  {
11299  (yyval.val) = (yyvsp[0].val);
11300  }
11301 #line 11297 "ripper.c" /* yacc.c:1646 */
11302  break;
11303 
11304  case 661:
11305 #line 4883 "ripper.y" /* yacc.c:1646 */
11306  {
11307  (yyval.val) = new_args_tail(p, Qnone, Qnone, Qnone, &(yylsp[0]));
11308  }
11309 #line 11305 "ripper.c" /* yacc.c:1646 */
11310  break;
11311 
11312  case 662:
11313 #line 4889 "ripper.y" /* yacc.c:1646 */
11314  {
11315  (yyval.val) = new_args(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
11316  }
11317 #line 11313 "ripper.c" /* yacc.c:1646 */
11318  break;
11319 
11320  case 663:
11321 #line 4893 "ripper.y" /* yacc.c:1646 */
11322  {
11323  (yyval.val) = new_args(p, (yyvsp[-7].val), (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11324  }
11325 #line 11321 "ripper.c" /* yacc.c:1646 */
11326  break;
11327 
11328  case 664:
11329 #line 4897 "ripper.y" /* yacc.c:1646 */
11330  {
11331  (yyval.val) = new_args(p, (yyvsp[-3].val), (yyvsp[-1].val), Qnone, Qnone, (yyvsp[0].val), &(yyloc));
11332  }
11333 #line 11329 "ripper.c" /* yacc.c:1646 */
11334  break;
11335 
11336  case 665:
11337 #line 4901 "ripper.y" /* yacc.c:1646 */
11338  {
11339  (yyval.val) = new_args(p, (yyvsp[-5].val), (yyvsp[-3].val), Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11340  }
11341 #line 11337 "ripper.c" /* yacc.c:1646 */
11342  break;
11343 
11344  case 666:
11345 #line 4905 "ripper.y" /* yacc.c:1646 */
11346  {
11347  (yyval.val) = new_args(p, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
11348  }
11349 #line 11345 "ripper.c" /* yacc.c:1646 */
11350  break;
11351 
11352  case 667:
11353 #line 4909 "ripper.y" /* yacc.c:1646 */
11354  {
11355  (yyval.val) = new_args(p, (yyvsp[-5].val), Qnone, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11356  }
11357 #line 11353 "ripper.c" /* yacc.c:1646 */
11358  break;
11359 
11360  case 668:
11361 #line 4913 "ripper.y" /* yacc.c:1646 */
11362  {
11363  (yyval.val) = new_args(p, (yyvsp[-1].val), Qnone, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
11364  }
11365 #line 11361 "ripper.c" /* yacc.c:1646 */
11366  break;
11367 
11368  case 669:
11369 #line 4917 "ripper.y" /* yacc.c:1646 */
11370  {
11371  (yyval.val) = new_args(p, Qnone, (yyvsp[-3].val), (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
11372  }
11373 #line 11369 "ripper.c" /* yacc.c:1646 */
11374  break;
11375 
11376  case 670:
11377 #line 4921 "ripper.y" /* yacc.c:1646 */
11378  {
11379  (yyval.val) = new_args(p, Qnone, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11380  }
11381 #line 11377 "ripper.c" /* yacc.c:1646 */
11382  break;
11383 
11384  case 671:
11385 #line 4925 "ripper.y" /* yacc.c:1646 */
11386  {
11387  (yyval.val) = new_args(p, Qnone, (yyvsp[-1].val), Qnone, Qnone, (yyvsp[0].val), &(yyloc));
11388  }
11389 #line 11385 "ripper.c" /* yacc.c:1646 */
11390  break;
11391 
11392  case 672:
11393 #line 4929 "ripper.y" /* yacc.c:1646 */
11394  {
11395  (yyval.val) = new_args(p, Qnone, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11396  }
11397 #line 11393 "ripper.c" /* yacc.c:1646 */
11398  break;
11399 
11400  case 673:
11401 #line 4933 "ripper.y" /* yacc.c:1646 */
11402  {
11403  (yyval.val) = new_args(p, Qnone, Qnone, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
11404  }
11405 #line 11401 "ripper.c" /* yacc.c:1646 */
11406  break;
11407 
11408  case 674:
11409 #line 4937 "ripper.y" /* yacc.c:1646 */
11410  {
11411  (yyval.val) = new_args(p, Qnone, Qnone, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11412  }
11413 #line 11409 "ripper.c" /* yacc.c:1646 */
11414  break;
11415 
11416  case 675:
11417 #line 4941 "ripper.y" /* yacc.c:1646 */
11418  {
11419  (yyval.val) = new_args(p, Qnone, Qnone, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
11420  }
11421 #line 11417 "ripper.c" /* yacc.c:1646 */
11422  break;
11423 
11424  case 676:
11425 #line 4945 "ripper.y" /* yacc.c:1646 */
11426  {
11427  (yyval.val) = new_args_tail(p, Qnone, Qnone, Qnone, &(yylsp[0]));
11428  (yyval.val) = new_args(p, Qnone, Qnone, Qnone, Qnone, (yyval.val), &(yylsp[0]));
11429  }
11430 #line 11426 "ripper.c" /* yacc.c:1646 */
11431  break;
11432 
11433  case 677:
11434 #line 4952 "ripper.y" /* yacc.c:1646 */
11435  {
11436 #if 0
11437  (yyval.val) = idDot3;
11438 #endif
11439  {VALUE v1;v1=dispatch0(args_forward);(yyval.val)=v1;}
11440  }
11441 #line 11437 "ripper.c" /* yacc.c:1646 */
11442  break;
11443 
11444  case 678:
11445 #line 4961 "ripper.y" /* yacc.c:1646 */
11446  {
11447 #if 0
11448  yyerror1(&(yylsp[0]), "formal argument cannot be a constant");
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 679:
11457 #line 4969 "ripper.y" /* yacc.c:1646 */
11458  {
11459 #if 0
11460  yyerror1(&(yylsp[0]), "formal argument cannot be an instance 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 680:
11469 #line 4977 "ripper.y" /* yacc.c:1646 */
11470  {
11471 #if 0
11472  yyerror1(&(yylsp[0]), "formal argument cannot be a global 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 681:
11481 #line 4985 "ripper.y" /* yacc.c:1646 */
11482  {
11483 #if 0
11484  yyerror1(&(yylsp[0]), "formal argument cannot be a class variable");
11485  (yyval.val) = 0;
11486 #endif
11487  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(param_error,v1);(yyval.val)=v2;}ripper_error(p);
11488  }
11489 #line 11485 "ripper.c" /* yacc.c:1646 */
11490  break;
11491 
11492  case 683:
11493 #line 4996 "ripper.y" /* yacc.c:1646 */
11494  {
11495  formal_argument(p, get_id((yyvsp[0].val)));
11497  (yyval.val) = (yyvsp[0].val);
11498  }
11499 #line 11495 "ripper.c" /* yacc.c:1646 */
11500  break;
11501 
11502  case 684:
11503 #line 5004 "ripper.y" /* yacc.c:1646 */
11504  {
11505  ID id = get_id((yyvsp[0].val));
11506  arg_var(p, id);
11507  p->cur_arg = id;
11508  (yyval.val) = (yyvsp[0].val);
11509  }
11510 #line 11506 "ripper.c" /* yacc.c:1646 */
11511  break;
11512 
11513  case 685:
11514 #line 5013 "ripper.y" /* yacc.c:1646 */
11515  {
11516  p->cur_arg = 0;
11517 #if 0
11518  (yyval.val) = NEW_ARGS_AUX((yyvsp[0].val), 1, &NULL_LOC);
11519 #endif
11520  (yyval.val)=get_value((yyvsp[0].val));
11521  }
11522 #line 11518 "ripper.c" /* yacc.c:1646 */
11523  break;
11524 
11525  case 686:
11526 #line 5021 "ripper.y" /* yacc.c:1646 */
11527  {
11528 #if 0
11529  ID tid = internal_id(p);
11530  YYLTYPE loc;
11531  loc.beg_pos = (yylsp[-1]).beg_pos;
11532  loc.end_pos = (yylsp[-1]).beg_pos;
11533  arg_var(p, tid);
11534  if (dyna_in_block(p)) {
11535  (yyvsp[-1].val)->nd_value = NEW_DVAR(tid, &loc);
11536  }
11537  else {
11538  (yyvsp[-1].val)->nd_value = NEW_LVAR(tid, &loc);
11539  }
11540  (yyval.val) = NEW_ARGS_AUX(tid, 1, &NULL_LOC);
11541  (yyval.val)->nd_next = (yyvsp[-1].val);
11542 #endif
11543  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(mlhs_paren,v1);(yyval.val)=v2;}
11544  }
11545 #line 11541 "ripper.c" /* yacc.c:1646 */
11546  break;
11547 
11548  case 687:
11549 #line 5042 "ripper.y" /* yacc.c:1646 */
11550  {(yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));}
11551 #line 11547 "ripper.c" /* yacc.c:1646 */
11552  break;
11553 
11554  case 688:
11555 #line 5044 "ripper.y" /* yacc.c:1646 */
11556  {
11557 #if 0
11558  (yyval.val) = (yyvsp[-2].val);
11559  (yyval.val)->nd_plen++;
11560  (yyval.val)->nd_next = block_append(p, (yyval.val)->nd_next, (yyvsp[0].val)->nd_next);
11561  rb_discard_node(p, (yyvsp[0].val));
11562 #endif
11563  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11564  }
11565 #line 11561 "ripper.c" /* yacc.c:1646 */
11566  break;
11567 
11568  case 689:
11569 #line 5057 "ripper.y" /* yacc.c:1646 */
11570  {
11571  ID id = get_id((yyvsp[0].val));
11572  arg_var(p, formal_argument(p, id));
11573  p->cur_arg = id;
11575  (yyval.val) = (yyvsp[0].val);
11576  }
11577 #line 11573 "ripper.c" /* yacc.c:1646 */
11578  break;
11579 
11580  case 690:
11581 #line 5067 "ripper.y" /* yacc.c:1646 */
11582  {
11583  p->cur_arg = 0;
11584 #if 0
11585  (yyval.val) = new_kw_arg(p, assignable(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
11586 #endif
11587  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[-1].val))), get_value((yyvsp[0].val)));
11588  }
11589 #line 11585 "ripper.c" /* yacc.c:1646 */
11590  break;
11591 
11592  case 691:
11593 #line 5075 "ripper.y" /* yacc.c:1646 */
11594  {
11595  p->cur_arg = 0;
11596 #if 0
11597  (yyval.val) = new_kw_arg(p, assignable(p, (yyvsp[0].val), NODE_SPECIAL_REQUIRED_KEYWORD, &(yyloc)), &(yyloc));
11598 #endif
11599  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[0].val))), 0);
11600  }
11601 #line 11597 "ripper.c" /* yacc.c:1646 */
11602  break;
11603 
11604  case 692:
11605 #line 5085 "ripper.y" /* yacc.c:1646 */
11606  {
11607 #if 0
11608  (yyval.val) = new_kw_arg(p, assignable(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
11609 #endif
11610  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[-1].val))), get_value((yyvsp[0].val)));
11611  }
11612 #line 11608 "ripper.c" /* yacc.c:1646 */
11613  break;
11614 
11615  case 693:
11616 #line 5092 "ripper.y" /* yacc.c:1646 */
11617  {
11618 #if 0
11619  (yyval.val) = new_kw_arg(p, assignable(p, (yyvsp[0].val), NODE_SPECIAL_REQUIRED_KEYWORD, &(yyloc)), &(yyloc));
11620 #endif
11621  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[0].val))), 0);
11622  }
11623 #line 11619 "ripper.c" /* yacc.c:1646 */
11624  break;
11625 
11626  case 694:
11627 #line 5101 "ripper.y" /* yacc.c:1646 */
11628  {
11629 #if 0
11630  (yyval.val) = (yyvsp[0].val);
11631 #endif
11632  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
11633  }
11634 #line 11630 "ripper.c" /* yacc.c:1646 */
11635  break;
11636 
11637  case 695:
11638 #line 5108 "ripper.y" /* yacc.c:1646 */
11639  {
11640 #if 0
11641  (yyval.val) = kwd_append((yyvsp[-2].val), (yyvsp[0].val));
11642 #endif
11643  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11644  }
11645 #line 11641 "ripper.c" /* yacc.c:1646 */
11646  break;
11647 
11648  case 696:
11649 #line 5118 "ripper.y" /* yacc.c:1646 */
11650  {
11651 #if 0
11652  (yyval.val) = (yyvsp[0].val);
11653 #endif
11654  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
11655  }
11656 #line 11652 "ripper.c" /* yacc.c:1646 */
11657  break;
11658 
11659  case 697:
11660 #line 5125 "ripper.y" /* yacc.c:1646 */
11661  {
11662 #if 0
11663  (yyval.val) = kwd_append((yyvsp[-2].val), (yyvsp[0].val));
11664 #endif
11665  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11666  }
11667 #line 11663 "ripper.c" /* yacc.c:1646 */
11668  break;
11669 
11670  case 700:
11671 #line 5138 "ripper.y" /* yacc.c:1646 */
11672  {
11673 #if 0
11674 #endif
11675  {VALUE v1,v2;v1=Qnil;v2=dispatch1(nokw_param,v1);(yyval.val)=v2;}
11676  }
11677 #line 11673 "ripper.c" /* yacc.c:1646 */
11678  break;
11679 
11680  case 701:
11681 #line 5146 "ripper.y" /* yacc.c:1646 */
11682  {
11683  arg_var(p, shadowing_lvar(p, get_id((yyvsp[0].val))));
11684 #if 0
11685  (yyval.val) = (yyvsp[0].val);
11686 #endif
11687  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(kwrest_param,v1);(yyval.val)=v2;}
11688  }
11689 #line 11685 "ripper.c" /* yacc.c:1646 */
11690  break;
11691 
11692  case 702:
11693 #line 5154 "ripper.y" /* yacc.c:1646 */
11694  {
11695 #if 0
11696  (yyval.val) = internal_id(p);
11697  arg_var(p, (yyval.val));
11698 #endif
11699  {VALUE v1,v2;v1=Qnil;v2=dispatch1(kwrest_param,v1);(yyval.val)=v2;}
11700  }
11701 #line 11697 "ripper.c" /* yacc.c:1646 */
11702  break;
11703 
11704  case 703:
11705 #line 5164 "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 704:
11717 #line 5174 "ripper.y" /* yacc.c:1646 */
11718  {
11719  p->cur_arg = 0;
11720 #if 0
11721  (yyval.val) = NEW_OPT_ARG(0, assignable(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
11722 #endif
11723  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[-2].val))), get_value((yyvsp[0].val)));
11724  }
11725 #line 11721 "ripper.c" /* yacc.c:1646 */
11726  break;
11727 
11728  case 705:
11729 #line 5184 "ripper.y" /* yacc.c:1646 */
11730  {
11731 #if 0
11732  (yyval.val) = (yyvsp[0].val);
11733 #endif
11734  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
11735  }
11736 #line 11732 "ripper.c" /* yacc.c:1646 */
11737  break;
11738 
11739  case 706:
11740 #line 5191 "ripper.y" /* yacc.c:1646 */
11741  {
11742 #if 0
11743  (yyval.val) = opt_arg_append((yyvsp[-2].val), (yyvsp[0].val));
11744 #endif
11745  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11746  }
11747 #line 11743 "ripper.c" /* yacc.c:1646 */
11748  break;
11749 
11750  case 707:
11751 #line 5200 "ripper.y" /* yacc.c:1646 */
11752  {
11753 #if 0
11754  (yyval.val) = (yyvsp[0].val);
11755 #endif
11756  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
11757  }
11758 #line 11754 "ripper.c" /* yacc.c:1646 */
11759  break;
11760 
11761  case 708:
11762 #line 5207 "ripper.y" /* yacc.c:1646 */
11763  {
11764 #if 0
11765  (yyval.val) = opt_arg_append((yyvsp[-2].val), (yyvsp[0].val));
11766 #endif
11767  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11768  }
11769 #line 11765 "ripper.c" /* yacc.c:1646 */
11770  break;
11771 
11772  case 711:
11773 #line 5220 "ripper.y" /* yacc.c:1646 */
11774  {
11775  arg_var(p, shadowing_lvar(p, get_id((yyvsp[0].val))));
11776 #if 0
11777  (yyval.val) = (yyvsp[0].val);
11778 #endif
11779  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(rest_param,v1);(yyval.val)=v2;}
11780  }
11781 #line 11777 "ripper.c" /* yacc.c:1646 */
11782  break;
11783 
11784  case 712:
11785 #line 5228 "ripper.y" /* yacc.c:1646 */
11786  {
11787 #if 0
11788  (yyval.val) = internal_id(p);
11789  arg_var(p, (yyval.val));
11790 #endif
11791  {VALUE v1,v2;v1=Qnil;v2=dispatch1(rest_param,v1);(yyval.val)=v2;}
11792  }
11793 #line 11789 "ripper.c" /* yacc.c:1646 */
11794  break;
11795 
11796  case 715:
11797 #line 5242 "ripper.y" /* yacc.c:1646 */
11798  {
11799  arg_var(p, shadowing_lvar(p, get_id((yyvsp[0].val))));
11800 #if 0
11801  (yyval.val) = (yyvsp[0].val);
11802 #endif
11803  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(blockarg,v1);(yyval.val)=v2;}
11804  }
11805 #line 11801 "ripper.c" /* yacc.c:1646 */
11806  break;
11807 
11808  case 716:
11809 #line 5252 "ripper.y" /* yacc.c:1646 */
11810  {
11811  (yyval.val) = (yyvsp[0].val);
11812  }
11813 #line 11809 "ripper.c" /* yacc.c:1646 */
11814  break;
11815 
11816  case 717:
11817 #line 5256 "ripper.y" /* yacc.c:1646 */
11818  {
11819  (yyval.val) = Qnull;
11820  }
11821 #line 11817 "ripper.c" /* yacc.c:1646 */
11822  break;
11823 
11824  case 718:
11825 #line 5262 "ripper.y" /* yacc.c:1646 */
11826  {
11827  value_expr((yyvsp[0].val));
11828  (yyval.val) = (yyvsp[0].val);
11829  }
11830 #line 11826 "ripper.c" /* yacc.c:1646 */
11831  break;
11832 
11833  case 719:
11834 #line 5266 "ripper.y" /* yacc.c:1646 */
11835  {SET_LEX_STATE(EXPR_BEG);}
11836 #line 11832 "ripper.c" /* yacc.c:1646 */
11837  break;
11838 
11839  case 720:
11840 #line 5267 "ripper.y" /* yacc.c:1646 */
11841  {
11842 #if 0
11843  switch (nd_type((yyvsp[-1].val))) {
11844  case NODE_STR:
11845  case NODE_DSTR:
11846  case NODE_XSTR:
11847  case NODE_DXSTR:
11848  case NODE_DREGX:
11849  case NODE_LIT:
11850  case NODE_LIST:
11851  case NODE_ZLIST:
11852  yyerror1(&(yylsp[-1]), "can't define singleton method for literals");
11853  break;
11854  default:
11855  value_expr((yyvsp[-1].val));
11856  break;
11857  }
11858  (yyval.val) = (yyvsp[-1].val);
11859 #endif
11860  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
11861  }
11862 #line 11858 "ripper.c" /* yacc.c:1646 */
11863  break;
11864 
11865  case 722:
11866 #line 5292 "ripper.y" /* yacc.c:1646 */
11867  {
11868 #if 0
11869  (yyval.val) = (yyvsp[-1].val);
11870 #endif
11871  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(assoclist_from_args,v1);(yyval.val)=v2;}
11872  }
11873 #line 11869 "ripper.c" /* yacc.c:1646 */
11874  break;
11875 
11876  case 723:
11877 #line 5301 "ripper.y" /* yacc.c:1646 */
11878  {(yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));}
11879 #line 11875 "ripper.c" /* yacc.c:1646 */
11880  break;
11881 
11882  case 724:
11883 #line 5303 "ripper.y" /* yacc.c:1646 */
11884  {
11885 #if 0
11886  NODE *assocs = (yyvsp[-2].val);
11887  NODE *tail = (yyvsp[0].val);
11888  if (!assocs) {
11889  assocs = tail;
11890  }
11891  else if (tail) {
11892  if (assocs->nd_head &&
11893  !tail->nd_head && nd_type(tail->nd_next) == NODE_LIST &&
11894  nd_type(tail->nd_next->nd_head) == NODE_HASH) {
11895  /* DSTAR */
11896  tail = tail->nd_next->nd_head->nd_head;
11897  }
11898  assocs = list_concat(assocs, tail);
11899  }
11900  (yyval.val) = assocs;
11901 #endif
11902  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11903  }
11904 #line 11900 "ripper.c" /* yacc.c:1646 */
11905  break;
11906 
11907  case 725:
11908 #line 5326 "ripper.y" /* yacc.c:1646 */
11909  {
11910 #if 0
11911  if (nd_type((yyvsp[-2].val)) == NODE_STR) {
11912  nd_set_type((yyvsp[-2].val), NODE_LIT);
11913  RB_OBJ_WRITE(p->ast, &(yyvsp[-2].val)->nd_lit, rb_fstring((yyvsp[-2].val)->nd_lit));
11914  }
11915  (yyval.val) = list_append(p, NEW_LIST((yyvsp[-2].val), &(yyloc)), (yyvsp[0].val));
11916 #endif
11917  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(assoc_new,v1,v2);(yyval.val)=v3;}
11918  }
11919 #line 11915 "ripper.c" /* yacc.c:1646 */
11920  break;
11921 
11922  case 726:
11923 #line 5337 "ripper.y" /* yacc.c:1646 */
11924  {
11925 #if 0
11926  (yyval.val) = list_append(p, NEW_LIST(NEW_LIT(ID2SYM((yyvsp[-1].val)), &(yylsp[-1])), &(yyloc)), (yyvsp[0].val));
11927 #endif
11928  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(assoc_new,v1,v2);(yyval.val)=v3;}
11929  }
11930 #line 11926 "ripper.c" /* yacc.c:1646 */
11931  break;
11932 
11933  case 727:
11934 #line 5344 "ripper.y" /* yacc.c:1646 */
11935  {
11936 #if 0
11937  YYLTYPE loc = code_loc_gen(&(yylsp[-3]), &(yylsp[-1]));
11938  (yyval.val) = list_append(p, NEW_LIST(dsym_node(p, (yyvsp[-2].val), &loc), &loc), (yyvsp[0].val));
11939 #endif
11940  {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;}
11941  }
11942 #line 11938 "ripper.c" /* yacc.c:1646 */
11943  break;
11944 
11945  case 728:
11946 #line 5352 "ripper.y" /* yacc.c:1646 */
11947  {
11948 #if 0
11949  if (nd_type((yyvsp[0].val)) == NODE_HASH &&
11950  !((yyvsp[0].val)->nd_head && (yyvsp[0].val)->nd_head->nd_alen)) {
11951  static VALUE empty_hash;
11952  if (!empty_hash) {
11953  empty_hash = rb_obj_freeze(rb_hash_new());
11954  rb_gc_register_mark_object(empty_hash);
11955  }
11956  (yyval.val) = list_append(p, NEW_LIST(0, &(yyloc)), NEW_LIT(empty_hash, &(yyloc)));
11957  }
11958  else
11959  (yyval.val) = list_append(p, NEW_LIST(0, &(yyloc)), (yyvsp[0].val));
11960 #endif
11961  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(assoc_splat,v1);(yyval.val)=v2;}
11962  }
11963 #line 11959 "ripper.c" /* yacc.c:1646 */
11964  break;
11965 
11966  case 755:
11967 #line 5420 "ripper.y" /* yacc.c:1646 */
11968  {yyerrok;token_flush(p);}
11969 #line 11965 "ripper.c" /* yacc.c:1646 */
11970  break;
11971 
11972  case 756:
11973 #line 5421 "ripper.y" /* yacc.c:1646 */
11974  {token_flush(p);}
11975 #line 11971 "ripper.c" /* yacc.c:1646 */
11976  break;
11977 
11978  case 758:
11979 #line 5425 "ripper.y" /* yacc.c:1646 */
11980  {yyerrok;}
11981 #line 11977 "ripper.c" /* yacc.c:1646 */
11982  break;
11983 
11984  case 759:
11985 #line 5429 "ripper.y" /* yacc.c:1646 */
11986  {
11987  (yyval.val) = Qnull;
11988  }
11989 #line 11985 "ripper.c" /* yacc.c:1646 */
11990  break;
11991 
11992 
11993 #line 11989 "ripper.c" /* yacc.c:1646 */
11994  default: break;
11995  }
11996  /* User semantic actions sometimes alter yychar, and that requires
11997  that yytoken be updated with the new translation. We take the
11998  approach of translating immediately before every use of yytoken.
11999  One alternative is translating here after every semantic action,
12000  but that translation would be missed if the semantic action invokes
12001  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
12002  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
12003  incorrect destructor might then be invoked immediately. In the
12004  case of YYERROR or YYBACKUP, subsequent parser actions might lead
12005  to an incorrect destructor call or verbose syntax error message
12006  before the lookahead is translated. */
12007  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
12008 
12009  YYPOPSTACK (yylen);
12010  yylen = 0;
12011  YY_STACK_PRINT (yyss, yyssp);
12012 
12013  *++yyvsp = yyval;
12014  *++yylsp = yyloc;
12015 
12016  /* Now 'shift' the result of the reduction. Determine what state
12017  that goes to, based on the state we popped back to and the rule
12018  number reduced by. */
12019 
12020  yyn = yyr1[yyn];
12021 
12022  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
12023  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
12024  yystate = yytable[yystate];
12025  else
12026  yystate = yydefgoto[yyn - YYNTOKENS];
12027 
12028  goto yynewstate;
12029 
12030 
12031 /*--------------------------------------.
12032 | yyerrlab -- here on detecting error. |
12033 `--------------------------------------*/
12034 yyerrlab:
12035  /* Make sure we have latest lookahead translation. See comments at
12036  user semantic actions for why this is necessary. */
12037  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
12038 
12039  /* If not already recovering from an error, report this error. */
12040  if (!yyerrstatus)
12041  {
12042  ++yynerrs;
12043 #if ! YYERROR_VERBOSE
12044  yyerror (&yylloc, p, YY_("syntax error"));
12045 #else
12046 # define YYSYNTAX_ERROR yysyntax_error (p, &yymsg_alloc, &yymsg, \
12047  yyssp, yytoken)
12048  {
12049  char const *yymsgp = YY_("syntax error");
12050  int yysyntax_error_status;
12051  yysyntax_error_status = YYSYNTAX_ERROR;
12052  if (yysyntax_error_status == 0)
12053  yymsgp = yymsg;
12054  else if (yysyntax_error_status == 1)
12055  {
12056  if (yymsg != yymsgbuf)
12057  YYSTACK_FREE (yymsg);
12058  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
12059  if (!yymsg)
12060  {
12061  yymsg = yymsgbuf;
12062  yymsg_alloc = sizeof yymsgbuf;
12063  yysyntax_error_status = 2;
12064  }
12065  else
12066  {
12067  yysyntax_error_status = YYSYNTAX_ERROR;
12068  yymsgp = yymsg;
12069  }
12070  }
12071  yyerror (&yylloc, p, yymsgp);
12072  if (yysyntax_error_status == 2)
12073  goto yyexhaustedlab;
12074  }
12075 # undef YYSYNTAX_ERROR
12076 #endif
12077  }
12078 
12079  yyerror_range[1] = yylloc;
12080 
12081  if (yyerrstatus == 3)
12082  {
12083  /* If just tried and failed to reuse lookahead token after an
12084  error, discard it. */
12085 
12086  if (yychar <= YYEOF)
12087  {
12088  /* Return failure if at end of input. */
12089  if (yychar == YYEOF)
12090  YYABORT;
12091  }
12092  else
12093  {
12094  yydestruct ("Error: discarding",
12095  yytoken, &yylval, &yylloc, p);
12096  yychar = YYEMPTY;
12097  }
12098  }
12099 
12100  /* Else will try to reuse lookahead token after shifting the error
12101  token. */
12102  goto yyerrlab1;
12103 
12104 
12105 /*---------------------------------------------------.
12106 | yyerrorlab -- error raised explicitly by YYERROR. |
12107 `---------------------------------------------------*/
12108 yyerrorlab:
12109 
12110  /* Pacify compilers like GCC when the user code never invokes
12111  YYERROR and the label yyerrorlab therefore never appears in user
12112  code. */
12113  if (/*CONSTCOND*/ 0)
12114  goto yyerrorlab;
12115 
12116  yyerror_range[1] = yylsp[1-yylen];
12117  /* Do not reclaim the symbols of the rule whose action triggered
12118  this YYERROR. */
12119  YYPOPSTACK (yylen);
12120  yylen = 0;
12121  YY_STACK_PRINT (yyss, yyssp);
12122  yystate = *yyssp;
12123  goto yyerrlab1;
12124 
12125 
12126 /*-------------------------------------------------------------.
12127 | yyerrlab1 -- common code for both syntax error and YYERROR. |
12128 `-------------------------------------------------------------*/
12129 yyerrlab1:
12130  yyerrstatus = 3; /* Each real token shifted decrements this. */
12131 
12132  for (;;)
12133  {
12134  yyn = yypact[yystate];
12135  if (!yypact_value_is_default (yyn))
12136  {
12137  yyn += YYTERROR;
12138  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
12139  {
12140  yyn = yytable[yyn];
12141  if (0 < yyn)
12142  break;
12143  }
12144  }
12145 
12146  /* Pop the current state because it cannot handle the error token. */
12147  if (yyssp == yyss)
12148  YYABORT;
12149 
12150  yyerror_range[1] = *yylsp;
12151  yydestruct ("Error: popping",
12152  yystos[yystate], yyvsp, yylsp, p);
12153  YYPOPSTACK (1);
12154  yystate = *yyssp;
12155  YY_STACK_PRINT (yyss, yyssp);
12156  }
12157 
12159  *++yyvsp = yylval;
12161 
12162  yyerror_range[2] = yylloc;
12163  /* Using YYLLOC is tempting, but would change the location of
12164  the lookahead. YYLOC is available though. */
12165  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
12166  *++yylsp = yyloc;
12167 
12168  /* Shift the error token. */
12169  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
12170 
12171  yystate = yyn;
12172  goto yynewstate;
12173 
12174 
12175 /*-------------------------------------.
12176 | yyacceptlab -- YYACCEPT comes here. |
12177 `-------------------------------------*/
12178 yyacceptlab:
12179  yyresult = 0;
12180  goto yyreturn;
12181 
12182 /*-----------------------------------.
12183 | yyabortlab -- YYABORT comes here. |
12184 `-----------------------------------*/
12185 yyabortlab:
12186  yyresult = 1;
12187  goto yyreturn;
12188 
12189 #if !defined yyoverflow || YYERROR_VERBOSE
12190 /*-------------------------------------------------.
12191 | yyexhaustedlab -- memory exhaustion comes here. |
12192 `-------------------------------------------------*/
12193 yyexhaustedlab:
12194  yyerror (&yylloc, p, YY_("memory exhausted"));
12195  yyresult = 2;
12196  /* Fall through. */
12197 #endif
12198 
12199 yyreturn:
12200  if (yychar != YYEMPTY)
12201  {
12202  /* Make sure we have latest lookahead translation. See comments at
12203  user semantic actions for why this is necessary. */
12204  yytoken = YYTRANSLATE (yychar);
12205  yydestruct ("Cleanup: discarding lookahead",
12206  yytoken, &yylval, &yylloc, p);
12207  }
12208  /* Do not reclaim the symbols of the rule whose action triggered
12209  this YYABORT or YYACCEPT. */
12210  YYPOPSTACK (yylen);
12211  YY_STACK_PRINT (yyss, yyssp);
12212  while (yyssp != yyss)
12213  {
12214  yydestruct ("Cleanup: popping",
12215  yystos[*yyssp], yyvsp, yylsp, p);
12216  YYPOPSTACK (1);
12217  }
12218 #ifndef yyoverflow
12219  if (yyss != yyssa)
12220  YYSTACK_FREE (yyss);
12221 #endif
12222 #if YYERROR_VERBOSE
12223  if (yymsg != yymsgbuf)
12224  YYSTACK_FREE (yymsg);
12225 #endif
12226  return yyresult;
12227 }
12228 #line 5433 "ripper.y" /* yacc.c:1906 */
12229 
12230 # undef p
12231 # undef yylex
12232 # undef yylval
12233 # define yylval (*p->lval)
12234 
12235 static int regx_options(struct parser_params*);
12236 static int tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**,rb_encoding**);
12237 static void tokaddmbc(struct parser_params *p, int c, rb_encoding *enc);
12238 static enum yytokentype parse_string(struct parser_params*,rb_strterm_literal_t*);
12239 static enum yytokentype here_document(struct parser_params*,rb_strterm_heredoc_t*);
12240 
12241 #ifndef RIPPER
12242 # define set_yylval_node(x) { \
12243  YYLTYPE _cur_loc; \
12244  rb_parser_set_location(p, &_cur_loc); \
12245  yylval.node = (x); \
12246 }
12247 # define set_yylval_str(x) \
12248 do { \
12249  set_yylval_node(NEW_STR(x, &_cur_loc)); \
12250  RB_OBJ_WRITTEN(p->ast, Qnil, x); \
12251 } while(0)
12252 # define set_yylval_literal(x) \
12253 do { \
12254  set_yylval_node(NEW_LIT(x, &_cur_loc)); \
12255  RB_OBJ_WRITTEN(p->ast, Qnil, x); \
12256 } while(0)
12257 # define set_yylval_num(x) (yylval.num = (x))
12258 # define set_yylval_id(x) (yylval.id = (x))
12259 # define set_yylval_name(x) (yylval.id = (x))
12260 # define yylval_id() (yylval.id)
12261 #else
12262 static inline VALUE
12263 ripper_yylval_id(struct parser_params *p, ID x)
12264 {
12265  return ripper_new_yylval(p, x, ID2SYM(x), 0);
12266 }
12267 # define set_yylval_str(x) (yylval.val = add_mark_object(p, (x)))
12268 # define set_yylval_num(x) (yylval.val = ripper_new_yylval(p, (x), 0, 0))
12269 # define set_yylval_id(x) (void)(x)
12270 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(p, x))
12271 # define set_yylval_literal(x) add_mark_object(p, (x))
12272 # define set_yylval_node(x) (void)(x)
12273 # define yylval_id() yylval.id
12274 # define _cur_loc NULL_LOC /* dummy */
12275 #endif
12276 
12277 #define set_yylval_noname() set_yylval_id(keyword_nil)
12278 
12279 #ifndef RIPPER
12280 #define literal_flush(p, ptr) ((p)->lex.ptok = (ptr))
12281 #define dispatch_scan_event(p, t) ((void)0)
12282 #define dispatch_delayed_token(p, t) ((void)0)
12283 #define has_delayed_token(p) (0)
12284 #else
12285 #define literal_flush(p, ptr) ((void)(ptr))
12286 
12287 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
12288 
12289 static inline VALUE
12290 intern_sym(const char *name)
12291 {
12292  ID id = rb_intern_const(name);
12293  return ID2SYM(id);
12294 }
12295 
12296 static int
12297 ripper_has_scan_event(struct parser_params *p)
12298 {
12299  if (p->lex.pcur < p->lex.ptok) rb_raise(rb_eRuntimeError, "lex.pcur < lex.ptok");
12300  return p->lex.pcur > p->lex.ptok;
12301 }
12302 
12303 static VALUE
12304 ripper_scan_event_val(struct parser_params *p, enum yytokentype t)
12305 {
12306  VALUE str = STR_NEW(p->lex.ptok, p->lex.pcur - p->lex.ptok);
12307  VALUE rval = ripper_dispatch1(p, ripper_token2eventid(t), str);
12308  token_flush(p);
12309  return rval;
12310 }
12311 
12312 static void
12313 ripper_dispatch_scan_event(struct parser_params *p, enum yytokentype t)
12314 {
12315  if (!ripper_has_scan_event(p)) return;
12316  add_mark_object(p, yylval_rval = ripper_scan_event_val(p, t));
12317 }
12318 #define dispatch_scan_event(p, t) ripper_dispatch_scan_event(p, t)
12319 
12320 static void
12321 ripper_dispatch_delayed_token(struct parser_params *p, enum yytokentype t)
12322 {
12323  int saved_line = p->ruby_sourceline;
12324  const char *saved_tokp = p->lex.ptok;
12325 
12326  if (NIL_P(p->delayed.token)) return;
12327  p->ruby_sourceline = p->delayed.line;
12328  p->lex.ptok = p->lex.pbeg + p->delayed.col;
12329  add_mark_object(p, yylval_rval = ripper_dispatch1(p, ripper_token2eventid(t), p->delayed.token));
12330  p->delayed.token = Qnil;
12331  p->ruby_sourceline = saved_line;
12332  p->lex.ptok = saved_tokp;
12333 }
12334 #define dispatch_delayed_token(p, t) ripper_dispatch_delayed_token(p, t)
12335 #define has_delayed_token(p) (!NIL_P(p->delayed.token))
12336 #endif /* RIPPER */
12337 
12338 #include "ruby/regex.h"
12339 #include "ruby/util.h"
12340 
12341 static inline int
12342 is_identchar(const char *ptr, const char *MAYBE_UNUSED(ptr_end), rb_encoding *enc)
12343 {
12344  return rb_enc_isalnum((unsigned char)*ptr, enc) || *ptr == '_' || !ISASCII(*ptr);
12345 }
12346 
12347 static inline int
12348 parser_is_identchar(struct parser_params *p)
12349 {
12350  return !(p)->eofp && is_identchar(p->lex.pcur-1, p->lex.pend, p->enc);
12351 }
12352 
12353 static inline int
12354 parser_isascii(struct parser_params *p)
12355 {
12356  return ISASCII(*(p->lex.pcur-1));
12357 }
12358 
12359 static void
12360 token_info_setup(token_info *ptinfo, const char *ptr, const rb_code_location_t *loc)
12361 {
12362  int column = 1, nonspc = 0, i;
12363  for (i = 0; i < loc->beg_pos.column; i++, ptr++) {
12364  if (*ptr == '\t') {
12365  column = (((column - 1) / TAB_WIDTH) + 1) * TAB_WIDTH;
12366  }
12367  column++;
12368  if (*ptr != ' ' && *ptr != '\t') {
12369  nonspc = 1;
12370  }
12371  }
12372 
12373  ptinfo->beg = loc->beg_pos;
12374  ptinfo->indent = column;
12375  ptinfo->nonspc = nonspc;
12376 }
12377 
12378 static void
12379 token_info_push(struct parser_params *p, const char *token, const rb_code_location_t *loc)
12380 {
12381  token_info *ptinfo;
12382 
12383  if (!p->token_info_enabled) return;
12384  ptinfo = ALLOC(token_info);
12385  ptinfo->token = token;
12386  ptinfo->next = p->token_info;
12387  token_info_setup(ptinfo, p->lex.pbeg, loc);
12388 
12389  p->token_info = ptinfo;
12390 }
12391 
12392 static void
12393 token_info_pop(struct parser_params *p, const char *token, const rb_code_location_t *loc)
12394 {
12395  token_info *ptinfo_beg = p->token_info;
12396 
12397  if (!ptinfo_beg) return;
12398  p->token_info = ptinfo_beg->next;
12399 
12400  /* indentation check of matched keywords (begin..end, if..end, etc.) */
12401  token_info_warn(p, token, ptinfo_beg, 1, loc);
12402  ruby_sized_xfree(ptinfo_beg, sizeof(*ptinfo_beg));
12403 }
12404 
12405 static void
12406 token_info_warn(struct parser_params *p, const char *token, token_info *ptinfo_beg, int same, const rb_code_location_t *loc)
12407 {
12408  token_info ptinfo_end_body, *ptinfo_end = &ptinfo_end_body;
12409  if (!p->token_info_enabled) return;
12410  if (!ptinfo_beg) return;
12411  token_info_setup(ptinfo_end, p->lex.pbeg, loc);
12412  if (ptinfo_beg->beg.lineno == ptinfo_end->beg.lineno) return; /* ignore one-line block */
12413  if (ptinfo_beg->nonspc || ptinfo_end->nonspc) return; /* ignore keyword in the middle of a line */
12414  if (ptinfo_beg->indent == ptinfo_end->indent) return; /* the indents are matched */
12415  if (!same && ptinfo_beg->indent < ptinfo_end->indent) return;
12416  rb_warn3L(ptinfo_end->beg.lineno,
12417  "mismatched indentations at '%s' with '%s' at %d",
12418  WARN_S(token), WARN_S(ptinfo_beg->token), WARN_I(ptinfo_beg->beg.lineno));
12419 }
12420 
12421 static int
12422 parser_precise_mbclen(struct parser_params *p, const char *ptr)
12423 {
12424  int len = rb_enc_precise_mbclen(ptr, p->lex.pend, p->enc);
12425  if (!MBCLEN_CHARFOUND_P(len)) {
12426  compile_error(p, "invalid multibyte char (%s)", rb_enc_name(p->enc));
12427  return -1;
12428  }
12429  return len;
12430 }
12431 
12432 #ifndef RIPPER
12433 static void ruby_show_error_line(VALUE errbuf, const YYLTYPE *yylloc, int lineno, VALUE str);
12434 
12435 static inline void
12436 parser_show_error_line(struct parser_params *p, const YYLTYPE *yylloc)
12437 {
12438  VALUE str;
12439  int lineno = p->ruby_sourceline;
12440  if (!yylloc) {
12441  return;
12442  }
12443  else if (yylloc->beg_pos.lineno == lineno) {
12444  str = p->lex.lastline;
12445  }
12446  else {
12447  return;
12448  }
12449  ruby_show_error_line(p->error_buffer, yylloc, lineno, str);
12450 }
12451 
12452 static int
12453 parser_yyerror(struct parser_params *p, const YYLTYPE *yylloc, const char *msg)
12454 {
12455  YYLTYPE current;
12456 
12457  if (!yylloc) {
12458  yylloc = RUBY_SET_YYLLOC(current);
12459  }
12460  else if ((p->ruby_sourceline != yylloc->beg_pos.lineno &&
12461  p->ruby_sourceline != yylloc->end_pos.lineno) ||
12462  (yylloc->beg_pos.lineno == yylloc->end_pos.lineno &&
12463  yylloc->beg_pos.column == yylloc->end_pos.column)) {
12464  yylloc = 0;
12465  }
12466  compile_error(p, "%s", msg);
12467  parser_show_error_line(p, yylloc);
12468  return 0;
12469 }
12470 
12471 static void
12472 ruby_show_error_line(VALUE errbuf, const YYLTYPE *yylloc, int lineno, VALUE str)
12473 {
12474  VALUE mesg;
12475  const int max_line_margin = 30;
12476  const char *ptr, *ptr_end, *pt, *pb;
12477  const char *pre = "", *post = "", *pend;
12478  const char *code = "", *caret = "";
12479  const char *lim;
12480  const char *const pbeg = RSTRING_PTR(str);
12481  char *buf;
12482  long len;
12483  int i;
12484 
12485  if (!yylloc) return;
12486  pend = RSTRING_END(str);
12487  if (pend > pbeg && pend[-1] == '\n') {
12488  if (--pend > pbeg && pend[-1] == '\r') --pend;
12489  }
12490 
12491  pt = pend;
12492  if (lineno == yylloc->end_pos.lineno &&
12493  (pend - pbeg) > yylloc->end_pos.column) {
12494  pt = pbeg + yylloc->end_pos.column;
12495  }
12496 
12497  ptr = ptr_end = pt;
12498  lim = ptr - pbeg > max_line_margin ? ptr - max_line_margin : pbeg;
12499  while ((lim < ptr) && (*(ptr-1) != '\n')) ptr--;
12500 
12501  lim = pend - ptr_end > max_line_margin ? ptr_end + max_line_margin : pend;
12502  while ((ptr_end < lim) && (*ptr_end != '\n') && (*ptr_end != '\r')) ptr_end++;
12503 
12504  len = ptr_end - ptr;
12505  if (len > 4) {
12506  if (ptr > pbeg) {
12507  ptr = rb_enc_prev_char(pbeg, ptr, pt, rb_enc_get(str));
12508  if (ptr > pbeg) pre = "...";
12509  }
12510  if (ptr_end < pend) {
12511  ptr_end = rb_enc_prev_char(pt, ptr_end, pend, rb_enc_get(str));
12512  if (ptr_end < pend) post = "...";
12513  }
12514  }
12515  pb = pbeg;
12516  if (lineno == yylloc->beg_pos.lineno) {
12517  pb += yylloc->beg_pos.column;
12518  if (pb > pt) pb = pt;
12519  }
12520  if (pb < ptr) pb = ptr;
12521  if (len <= 4 && yylloc->beg_pos.lineno == yylloc->end_pos.lineno) {
12522  return;
12523  }
12524  if (RTEST(errbuf)) {
12525  mesg = rb_attr_get(errbuf, idMesg);
12526  if (RSTRING_LEN(mesg) > 0 && *(RSTRING_END(mesg)-1) != '\n')
12527  rb_str_cat_cstr(mesg, "\n");
12528  }
12529  else {
12530  mesg = rb_enc_str_new(0, 0, rb_enc_get(str));
12531  }
12532  if (!errbuf && rb_stderr_tty_p()) {
12533 #define CSI_BEGIN "\033["
12534 #define CSI_SGR "m"
12535  rb_str_catf(mesg,
12536  CSI_BEGIN""CSI_SGR"%s" /* pre */
12537  CSI_BEGIN"1"CSI_SGR"%.*s"
12538  CSI_BEGIN"1;4"CSI_SGR"%.*s"
12539  CSI_BEGIN";1"CSI_SGR"%.*s"
12540  CSI_BEGIN""CSI_SGR"%s" /* post */
12541  "\n",
12542  pre,
12543  (int)(pb - ptr), ptr,
12544  (int)(pt - pb), pb,
12545  (int)(ptr_end - pt), pt,
12546  post);
12547  }
12548  else {
12549  char *p2;
12550 
12551  len = ptr_end - ptr;
12552  lim = pt < pend ? pt : pend;
12553  i = (int)(lim - ptr);
12554  buf = ALLOCA_N(char, i+2);
12555  code = ptr;
12556  caret = p2 = buf;
12557  if (ptr <= pb) {
12558  while (ptr < pb) {
12559  *p2++ = *ptr++ == '\t' ? '\t' : ' ';
12560  }
12561  *p2++ = '^';
12562  ptr++;
12563  }
12564  if (lim > ptr) {
12565  memset(p2, '~', (lim - ptr));
12566  p2 += (lim - ptr);
12567  }
12568  *p2 = '\0';
12569  rb_str_catf(mesg, "%s%.*s%s\n""%s%s\n",
12570  pre, (int)len, code, post,
12571  pre, caret);
12572  }
12573  if (!errbuf) rb_write_error_str(mesg);
12574 }
12575 #else
12576 static int
12577 parser_yyerror(struct parser_params *p, const YYLTYPE *yylloc, const char *msg)
12578 {
12579  const char *pcur = 0, *ptok = 0;
12580  if (yylloc &&
12581  p->ruby_sourceline == yylloc->beg_pos.lineno &&
12582  p->ruby_sourceline == yylloc->end_pos.lineno) {
12583  pcur = p->lex.pcur;
12584  ptok = p->lex.ptok;
12585  p->lex.ptok = p->lex.pbeg + yylloc->beg_pos.column;
12586  p->lex.pcur = p->lex.pbeg + yylloc->end_pos.column;
12587  }
12588  dispatch1(parse_error, STR_NEW2(msg));
12589  ripper_error(p);
12590  if (pcur) {
12591  p->lex.ptok = ptok;
12592  p->lex.pcur = pcur;
12593  }
12594  return 0;
12595 }
12596 
12597 static inline void
12598 parser_show_error_line(struct parser_params *p, const YYLTYPE *yylloc)
12599 {
12600 }
12601 #endif /* !RIPPER */
12602 
12603 #ifndef RIPPER
12604 static int
12605 vtable_size(const struct vtable *tbl)
12606 {
12607  if (!DVARS_TERMINAL_P(tbl)) {
12608  return tbl->pos;
12609  }
12610  else {
12611  return 0;
12612  }
12613 }
12614 #endif
12615 
12616 static struct vtable *
12617 vtable_alloc_gen(struct parser_params *p, int line, struct vtable *prev)
12618 {
12619  struct vtable *tbl = ALLOC(struct vtable);
12620  tbl->pos = 0;
12621  tbl->capa = 8;
12622  tbl->tbl = ALLOC_N(ID, tbl->capa);
12623  tbl->prev = prev;
12624 #ifndef RIPPER
12625  if (p->debug) {
12626  rb_parser_printf(p, "vtable_alloc:%d: %p\n", line, (void *)tbl);
12627  }
12628 #endif
12629  return tbl;
12630 }
12631 #define vtable_alloc(prev) vtable_alloc_gen(p, __LINE__, prev)
12632 
12633 static void
12634 vtable_free_gen(struct parser_params *p, int line, const char *name,
12635  struct vtable *tbl)
12636 {
12637 #ifndef RIPPER
12638  if (p->debug) {
12639  rb_parser_printf(p, "vtable_free:%d: %s(%p)\n", line, name, (void *)tbl);
12640  }
12641 #endif
12642  if (!DVARS_TERMINAL_P(tbl)) {
12643  if (tbl->tbl) {
12644  ruby_sized_xfree(tbl->tbl, tbl->capa * sizeof(ID));
12645  }
12646  ruby_sized_xfree(tbl, sizeof(tbl));
12647  }
12648 }
12649 #define vtable_free(tbl) vtable_free_gen(p, __LINE__, #tbl, tbl)
12650 
12651 static void
12652 vtable_add_gen(struct parser_params *p, int line, const char *name,
12653  struct vtable *tbl, ID id)
12654 {
12655 #ifndef RIPPER
12656  if (p->debug) {
12657  rb_parser_printf(p, "vtable_add:%d: %s(%p), %s\n",
12658  line, name, (void *)tbl, rb_id2name(id));
12659  }
12660 #endif
12661  if (DVARS_TERMINAL_P(tbl)) {
12662  rb_parser_fatal(p, "vtable_add: vtable is not allocated (%p)", (void *)tbl);
12663  return;
12664  }
12665  if (tbl->pos == tbl->capa) {
12666  tbl->capa = tbl->capa * 2;
12667  SIZED_REALLOC_N(tbl->tbl, ID, tbl->capa, tbl->pos);
12668  }
12669  tbl->tbl[tbl->pos++] = id;
12670 }
12671 #define vtable_add(tbl, id) vtable_add_gen(p, __LINE__, #tbl, tbl, id)
12672 
12673 #ifndef RIPPER
12674 static void
12675 vtable_pop_gen(struct parser_params *p, int line, const char *name,
12676  struct vtable *tbl, int n)
12677 {
12678  if (p->debug) {
12679  rb_parser_printf(p, "vtable_pop:%d: %s(%p), %d\n",
12680  line, name, (void *)tbl, n);
12681  }
12682  if (tbl->pos < n) {
12683  rb_parser_fatal(p, "vtable_pop: unreachable (%d < %d)", tbl->pos, n);
12684  return;
12685  }
12686  tbl->pos -= n;
12687 }
12688 #define vtable_pop(tbl, n) vtable_pop_gen(p, __LINE__, #tbl, tbl, n)
12689 #endif
12690 
12691 static int
12692 vtable_included(const struct vtable * tbl, ID id)
12693 {
12694  int i;
12695 
12696  if (!DVARS_TERMINAL_P(tbl)) {
12697  for (i = 0; i < tbl->pos; i++) {
12698  if (tbl->tbl[i] == id) {
12699  return i+1;
12700  }
12701  }
12702  }
12703  return 0;
12704 }
12705 
12706 static void parser_prepare(struct parser_params *p);
12707 
12708 #ifndef RIPPER
12709 static NODE *parser_append_options(struct parser_params *p, NODE *node);
12710 
12711 static VALUE
12712 debug_lines(VALUE fname)
12713 {
12714  ID script_lines;
12715  CONST_ID(script_lines, "SCRIPT_LINES__");
12716  if (rb_const_defined_at(rb_cObject, script_lines)) {
12717  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
12718  if (RB_TYPE_P(hash, T_HASH)) {
12719  VALUE lines = rb_ary_new();
12720  rb_hash_aset(hash, fname, lines);
12721  return lines;
12722  }
12723  }
12724  return 0;
12725 }
12726 
12727 static int
12728 e_option_supplied(struct parser_params *p)
12729 {
12730  return strcmp(p->ruby_sourcefile, "-e") == 0;
12731 }
12732 
12733 static VALUE
12734 yycompile0(VALUE arg)
12735 {
12736  int n;
12737  NODE *tree;
12738  struct parser_params *p = (struct parser_params *)arg;
12739  VALUE cov = Qfalse;
12740 
12743  if (p->debug_lines && p->ruby_sourceline > 0) {
12744  VALUE str = STR_NEW0();
12745  n = p->ruby_sourceline;
12746  do {
12748  } while (--n);
12749  }
12750 
12751  if (!e_option_supplied(p)) {
12752  cov = Qtrue;
12753  }
12754  }
12755 
12756  parser_prepare(p);
12757 #define RUBY_DTRACE_PARSE_HOOK(name) \
12758  if (RUBY_DTRACE_PARSE_##name##_ENABLED()) { \
12759  RUBY_DTRACE_PARSE_##name(p->ruby_sourcefile, p->ruby_sourceline); \
12760  }
12761  RUBY_DTRACE_PARSE_HOOK(BEGIN);
12762  n = yyparse(p);
12764  p->debug_lines = 0;
12765 
12766  p->lex.strterm = 0;
12767  p->lex.pcur = p->lex.pbeg = p->lex.pend = 0;
12768  p->lex.prevline = p->lex.lastline = p->lex.nextline = 0;
12769  if (n || p->error_p) {
12770  VALUE mesg = p->error_buffer;
12771  if (!mesg) {
12772  mesg = rb_class_new_instance(0, 0, rb_eSyntaxError);
12773  }
12774  rb_set_errinfo(mesg);
12775  return FALSE;
12776  }
12777  tree = p->eval_tree;
12778  if (!tree) {
12779  tree = NEW_NIL(&NULL_LOC);
12780  }
12781  else {
12782  VALUE opt = p->compile_option;
12783  NODE *prelude;
12784  NODE *body = parser_append_options(p, tree->nd_body);
12785  if (!opt) opt = rb_obj_hide(rb_ident_hash_new());
12786  rb_hash_aset(opt, rb_sym_intern_ascii_cstr("coverage_enabled"), cov);
12787  prelude = block_append(p, p->eval_tree_begin, body);
12788  tree->nd_body = prelude;
12789  RB_OBJ_WRITE(p->ast, &p->ast->body.compile_option, opt);
12790  }
12791  p->ast->body.root = tree;
12792  p->ast->body.line_count = p->line_count;
12793  return TRUE;
12794 }
12795 
12796 static rb_ast_t *
12797 yycompile(VALUE vparser, struct parser_params *p, VALUE fname, int line)
12798 {
12799  rb_ast_t *ast;
12800  if (NIL_P(fname)) {
12802  p->ruby_sourcefile = "(none)";
12803  }
12804  else {
12805  p->ruby_sourcefile_string = rb_fstring(fname);
12806  p->ruby_sourcefile = StringValueCStr(fname);
12807  }
12808  p->ruby_sourceline = line - 1;
12809 
12810  p->ast = ast = rb_ast_new();
12811  rb_suppress_tracing(yycompile0, (VALUE)p);
12812  p->ast = 0;
12813  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12814 
12815  return ast;
12816 }
12817 #endif /* !RIPPER */
12818 
12819 static rb_encoding *
12820 must_be_ascii_compatible(VALUE s)
12821 {
12822  rb_encoding *enc = rb_enc_get(s);
12823  if (!rb_enc_asciicompat(enc)) {
12824  rb_raise(rb_eArgError, "invalid source encoding");
12825  }
12826  return enc;
12827 }
12828 
12829 static VALUE
12830 lex_get_str(struct parser_params *p, VALUE s)
12831 {
12832  char *beg, *end, *start;
12833  long len;
12834 
12835  beg = RSTRING_PTR(s);
12836  len = RSTRING_LEN(s);
12837  start = beg;
12838  if (p->lex.gets_.ptr) {
12839  if (len == p->lex.gets_.ptr) return Qnil;
12840  beg += p->lex.gets_.ptr;
12841  len -= p->lex.gets_.ptr;
12842  }
12843  end = memchr(beg, '\n', len);
12844  if (end) len = ++end - beg;
12845  p->lex.gets_.ptr += len;
12846  return rb_str_subseq(s, beg - start, len);
12847 }
12848 
12849 static VALUE
12850 lex_getline(struct parser_params *p)
12851 {
12852  VALUE line = (*p->lex.gets)(p, p->lex.input);
12853  if (NIL_P(line)) return line;
12854  must_be_ascii_compatible(line);
12855 #ifndef RIPPER
12856  if (p->debug_lines) {
12857  rb_enc_associate(line, p->enc);
12858  rb_ary_push(p->debug_lines, line);
12859  }
12860 #endif
12861  p->line_count++;
12862  return line;
12863 }
12864 
12865 static const rb_data_type_t parser_data_type;
12866 
12867 #ifndef RIPPER
12868 static rb_ast_t*
12869 parser_compile_string(VALUE vparser, VALUE fname, VALUE s, int line)
12870 {
12871  struct parser_params *p;
12872 
12873  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
12874 
12875  p->lex.gets = lex_get_str;
12876  p->lex.gets_.ptr = 0;
12877  p->lex.input = rb_str_new_frozen(s);
12878  p->lex.pbeg = p->lex.pcur = p->lex.pend = 0;
12879 
12880  return yycompile(vparser, p, fname, line);
12881 }
12882 
12883 rb_ast_t*
12884 rb_parser_compile_string(VALUE vparser, const char *f, VALUE s, int line)
12885 {
12886  return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
12887 }
12888 
12889 rb_ast_t*
12891 {
12892  must_be_ascii_compatible(s);
12893  return parser_compile_string(vparser, f, s, line);
12894 }
12895 
12897 
12898 static VALUE
12899 lex_io_gets(struct parser_params *p, VALUE io)
12900 {
12901  return rb_io_gets_internal(io);
12902 }
12903 
12904 rb_ast_t*
12905 rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE file, int start)
12906 {
12907  struct parser_params *p;
12908 
12909  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
12910 
12911  p->lex.gets = lex_io_gets;
12912  p->lex.input = file;
12913  p->lex.pbeg = p->lex.pcur = p->lex.pend = 0;
12914 
12915  return yycompile(vparser, p, fname, start);
12916 }
12917 
12918 static VALUE
12919 lex_generic_gets(struct parser_params *p, VALUE input)
12920 {
12921  return (*p->lex.gets_.call)(input, p->line_count);
12922 }
12923 
12924 rb_ast_t*
12925 rb_parser_compile_generic(VALUE vparser, VALUE (*lex_gets)(VALUE, int), VALUE fname, VALUE input, int start)
12926 {
12927  struct parser_params *p;
12928 
12929  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
12930 
12931  p->lex.gets = lex_generic_gets;
12932  p->lex.gets_.call = lex_gets;
12933  p->lex.input = input;
12934  p->lex.pbeg = p->lex.pcur = p->lex.pend = 0;
12935 
12936  return yycompile(vparser, p, fname, start);
12937 }
12938 #endif /* !RIPPER */
12939 
12940 #define STR_FUNC_ESCAPE 0x01
12941 #define STR_FUNC_EXPAND 0x02
12942 #define STR_FUNC_REGEXP 0x04
12943 #define STR_FUNC_QWORDS 0x08
12944 #define STR_FUNC_SYMBOL 0x10
12945 #define STR_FUNC_INDENT 0x20
12946 #define STR_FUNC_LABEL 0x40
12947 #define STR_FUNC_LIST 0x4000
12948 #define STR_FUNC_TERM 0x8000
12949 
12952  str_squote = (0),
12960 };
12961 
12962 static VALUE
12963 parser_str_new(const char *ptr, long len, rb_encoding *enc, int func, rb_encoding *enc0)
12964 {
12965  VALUE str;
12966 
12967  str = rb_enc_str_new(ptr, len, enc);
12968  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12970  }
12971  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12973  }
12974  }
12975 
12976  return str;
12977 }
12978 
12979 #define lex_goto_eol(p) ((p)->lex.pcur = (p)->lex.pend)
12980 #define lex_eol_p(p) ((p)->lex.pcur >= (p)->lex.pend)
12981 #define lex_eol_n_p(p,n) ((p)->lex.pcur+(n) >= (p)->lex.pend)
12982 #define peek(p,c) peek_n(p, (c), 0)
12983 #define peek_n(p,c,n) (!lex_eol_n_p(p, n) && (c) == (unsigned char)(p)->lex.pcur[n])
12984 #define peekc(p) peekc_n(p, 0)
12985 #define peekc_n(p,n) (lex_eol_n_p(p, n) ? -1 : (unsigned char)(p)->lex.pcur[n])
12986 
12987 #ifdef RIPPER
12988 static void
12989 add_delayed_token(struct parser_params *p, const char *tok, const char *end)
12990 {
12991  if (tok < end) {
12992  if (!has_delayed_token(p)) {
12993  p->delayed.token = rb_str_buf_new(end - tok);
12994  rb_enc_associate(p->delayed.token, p->enc);
12995  p->delayed.line = p->ruby_sourceline;
12996  p->delayed.col = rb_long2int(tok - p->lex.pbeg);
12997  }
12998  rb_str_buf_cat(p->delayed.token, tok, end - tok);
12999  p->lex.ptok = end;
13000  }
13001 }
13002 #else
13003 #define add_delayed_token(p, tok, end) ((void)(tok), (void)(end))
13004 #endif
13005 
13006 static int
13007 nextline(struct parser_params *p)
13008 {
13009  VALUE v = p->lex.nextline;
13010  p->lex.nextline = 0;
13011  if (!v) {
13012  if (p->eofp)
13013  return -1;
13014 
13015  if (p->lex.pend > p->lex.pbeg && *(p->lex.pend-1) != '\n') {
13016  goto end_of_input;
13017  }
13018 
13019  if (!p->lex.input || NIL_P(v = lex_getline(p))) {
13020  end_of_input:
13021  p->eofp = 1;
13022  lex_goto_eol(p);
13023  return -1;
13024  }
13025  p->cr_seen = FALSE;
13026  }
13027  else if (NIL_P(v)) {
13028  /* after here-document without terminator */
13029  goto end_of_input;
13030  }
13031  add_delayed_token(p, p->lex.ptok, p->lex.pend);
13032  if (p->heredoc_end > 0) {
13033  p->ruby_sourceline = p->heredoc_end;
13034  p->heredoc_end = 0;
13035  }
13036  p->ruby_sourceline++;
13037  p->lex.pbeg = p->lex.pcur = RSTRING_PTR(v);
13038  p->lex.pend = p->lex.pcur + RSTRING_LEN(v);
13039  token_flush(p);
13040  p->lex.prevline = p->lex.lastline;
13041  p->lex.lastline = v;
13042  return 0;
13043 }
13044 
13045 static int
13046 parser_cr(struct parser_params *p, int c)
13047 {
13048  if (peek(p, '\n')) {
13049  p->lex.pcur++;
13050  c = '\n';
13051  }
13052  else if (!p->cr_seen) {
13053  p->cr_seen = TRUE;
13054  /* carried over with p->lex.nextline for nextc() */
13055  rb_warn0("encountered \\r in middle of line, treated as a mere space");
13056  }
13057  return c;
13058 }
13059 
13060 static inline int
13061 nextc(struct parser_params *p)
13062 {
13063  int c;
13064 
13065  if (UNLIKELY((p->lex.pcur == p->lex.pend) || p->eofp || RTEST(p->lex.nextline))) {
13066  if (nextline(p)) return -1;
13067  }
13068  c = (unsigned char)*p->lex.pcur++;
13069  if (UNLIKELY(c == '\r')) {
13070  c = parser_cr(p, c);
13071  }
13072 
13073  return c;
13074 }
13075 
13076 static void
13077 pushback(struct parser_params *p, int c)
13078 {
13079  if (c == -1) return;
13080  p->lex.pcur--;
13081  if (p->lex.pcur > p->lex.pbeg && p->lex.pcur[0] == '\n' && p->lex.pcur[-1] == '\r') {
13082  p->lex.pcur--;
13083  }
13084 }
13085 
13086 #define was_bol(p) ((p)->lex.pcur == (p)->lex.pbeg + 1)
13087 
13088 #define tokfix(p) ((p)->tokenbuf[(p)->tokidx]='\0')
13089 #define tok(p) (p)->tokenbuf
13090 #define toklen(p) (p)->tokidx
13091 
13092 static int
13093 looking_at_eol_p(struct parser_params *p)
13094 {
13095  const char *ptr = p->lex.pcur;
13096  while (ptr < p->lex.pend) {
13097  int c = (unsigned char)*ptr++;
13098  int eol = (c == '\n' || c == '#');
13099  if (eol || !ISSPACE(c)) {
13100  return eol;
13101  }
13102  }
13103  return TRUE;
13104 }
13105 
13106 static char*
13107 newtok(struct parser_params *p)
13108 {
13109  p->tokidx = 0;
13110  p->tokline = p->ruby_sourceline;
13111  if (!p->tokenbuf) {
13112  p->toksiz = 60;
13113  p->tokenbuf = ALLOC_N(char, 60);
13114  }
13115  if (p->toksiz > 4096) {
13116  p->toksiz = 60;
13117  REALLOC_N(p->tokenbuf, char, 60);
13118  }
13119  return p->tokenbuf;
13120 }
13121 
13122 static char *
13123 tokspace(struct parser_params *p, int n)
13124 {
13125  p->tokidx += n;
13126 
13127  if (p->tokidx >= p->toksiz) {
13128  do {p->toksiz *= 2;} while (p->toksiz < p->tokidx);
13129  REALLOC_N(p->tokenbuf, char, p->toksiz);
13130  }
13131  return &p->tokenbuf[p->tokidx-n];
13132 }
13133 
13134 static void
13135 tokadd(struct parser_params *p, int c)
13136 {
13137  p->tokenbuf[p->tokidx++] = (char)c;
13138  if (p->tokidx >= p->toksiz) {
13139  p->toksiz *= 2;
13140  REALLOC_N(p->tokenbuf, char, p->toksiz);
13141  }
13142 }
13143 
13144 static int
13145 tok_hex(struct parser_params *p, size_t *numlen)
13146 {
13147  int c;
13148 
13149  c = scan_hex(p->lex.pcur, 2, numlen);
13150  if (!*numlen) {
13151  yyerror0("invalid hex escape");
13152  token_flush(p);
13153  return 0;
13154  }
13155  p->lex.pcur += *numlen;
13156  return c;
13157 }
13158 
13159 #define tokcopy(p, n) memcpy(tokspace(p, n), (p)->lex.pcur - (n), (n))
13160 
13161 static int
13162 escaped_control_code(int c)
13163 {
13164  int c2 = 0;
13165  switch (c) {
13166  case ' ':
13167  c2 = 's';
13168  break;
13169  case '\n':
13170  c2 = 'n';
13171  break;
13172  case '\t':
13173  c2 = 't';
13174  break;
13175  case '\v':
13176  c2 = 'v';
13177  break;
13178  case '\r':
13179  c2 = 'r';
13180  break;
13181  case '\f':
13182  c2 = 'f';
13183  break;
13184  }
13185  return c2;
13186 }
13187 
13188 #define WARN_SPACE_CHAR(c, prefix) \
13189  rb_warn1("invalid character syntax; use "prefix"\\%c", WARN_I(c2))
13190 
13191 static int
13192 tokadd_codepoint(struct parser_params *p, rb_encoding **encp,
13193  int regexp_literal, int wide)
13194 {
13195  size_t numlen;
13196  int codepoint = scan_hex(p->lex.pcur, wide ? p->lex.pend - p->lex.pcur : 4, &numlen);
13197  literal_flush(p, p->lex.pcur);
13198  p->lex.pcur += numlen;
13199  if (wide ? (numlen == 0 || numlen > 6) : (numlen < 4)) {
13200  yyerror0("invalid Unicode escape");
13201  return wide && numlen > 0;
13202  }
13203  if (codepoint > 0x10ffff) {
13204  yyerror0("invalid Unicode codepoint (too large)");
13205  return wide;
13206  }
13207  if ((codepoint & 0xfffff800) == 0xd800) {
13208  yyerror0("invalid Unicode codepoint");
13209  return wide;
13210  }
13211  if (regexp_literal) {
13212  tokcopy(p, (int)numlen);
13213  }
13214  else if (codepoint >= 0x80) {
13215  rb_encoding *utf8 = rb_utf8_encoding();
13216  if (*encp && utf8 != *encp) {
13217  YYLTYPE loc = RUBY_INIT_YYLLOC();
13218  compile_error(p, "UTF-8 mixed within %s source", rb_enc_name(*encp));
13219  parser_show_error_line(p, &loc);
13220  return wide;
13221  }
13222  *encp = utf8;
13223  tokaddmbc(p, codepoint, *encp);
13224  }
13225  else {
13226  tokadd(p, codepoint);
13227  }
13228  return TRUE;
13229 }
13230 
13231 /* return value is for ?\u3042 */
13232 static void
13233 tokadd_utf8(struct parser_params *p, rb_encoding **encp,
13234  int term, int symbol_literal, int regexp_literal)
13235 {
13236  /*
13237  * If `term` is not -1, then we allow multiple codepoints in \u{}
13238  * upto `term` byte, otherwise we're parsing a character literal.
13239  * And then add the codepoints to the current token.
13240  */
13241  static const char multiple_codepoints[] = "Multiple codepoints at single character literal";
13242 
13243  const int open_brace = '{', close_brace = '}';
13244 
13245  if (regexp_literal) { tokadd(p, '\\'); tokadd(p, 'u'); }
13246 
13247  if (peek(p, open_brace)) { /* handle \u{...} form */
13248  const char *second = NULL;
13249  int c, last = nextc(p);
13250  if (p->lex.pcur >= p->lex.pend) goto unterminated;
13251  while (ISSPACE(c = *p->lex.pcur) && ++p->lex.pcur < p->lex.pend);
13252  while (c != close_brace) {
13253  if (c == term) goto unterminated;
13254  if (second == multiple_codepoints)
13255  second = p->lex.pcur;
13256  if (regexp_literal) tokadd(p, last);
13257  if (!tokadd_codepoint(p, encp, regexp_literal, TRUE)) {
13258  break;
13259  }
13260  while (ISSPACE(c = *p->lex.pcur)) {
13261  if (++p->lex.pcur >= p->lex.pend) goto unterminated;
13262  last = c;
13263  }
13264  if (term == -1 && !second)
13265  second = multiple_codepoints;
13266  }
13267 
13268  if (c != close_brace) {
13269  unterminated:
13270  token_flush(p);
13271  yyerror0("unterminated Unicode escape");
13272  return;
13273  }
13274  if (second && second != multiple_codepoints) {
13275  const char *pcur = p->lex.pcur;
13276  p->lex.pcur = second;
13278  token_flush(p);
13279  p->lex.pcur = pcur;
13280  yyerror0(multiple_codepoints);
13281  token_flush(p);
13282  }
13283 
13284  if (regexp_literal) tokadd(p, close_brace);
13285  nextc(p);
13286  }
13287  else { /* handle \uxxxx form */
13288  if (!tokadd_codepoint(p, encp, regexp_literal, FALSE)) {
13289  token_flush(p);
13290  return;
13291  }
13292  }
13293 }
13294 
13295 #define ESCAPE_CONTROL 1
13296 #define ESCAPE_META 2
13297 
13298 static int
13299 read_escape(struct parser_params *p, int flags, rb_encoding **encp)
13300 {
13301  int c;
13302  size_t numlen;
13303 
13304  switch (c = nextc(p)) {
13305  case '\\': /* Backslash */
13306  return c;
13307 
13308  case 'n': /* newline */
13309  return '\n';
13310 
13311  case 't': /* horizontal tab */
13312  return '\t';
13313 
13314  case 'r': /* carriage-return */
13315  return '\r';
13316 
13317  case 'f': /* form-feed */
13318  return '\f';
13319 
13320  case 'v': /* vertical tab */
13321  return '\13';
13322 
13323  case 'a': /* alarm(bell) */
13324  return '\007';
13325 
13326  case 'e': /* escape */
13327  return 033;
13328 
13329  case '0': case '1': case '2': case '3': /* octal constant */
13330  case '4': case '5': case '6': case '7':
13331  pushback(p, c);
13332  c = scan_oct(p->lex.pcur, 3, &numlen);
13333  p->lex.pcur += numlen;
13334  return c;
13335 
13336  case 'x': /* hex constant */
13337  c = tok_hex(p, &numlen);
13338  if (numlen == 0) return 0;
13339  return c;
13340 
13341  case 'b': /* backspace */
13342  return '\010';
13343 
13344  case 's': /* space */
13345  return ' ';
13346 
13347  case 'M':
13348  if (flags & ESCAPE_META) goto eof;
13349  if ((c = nextc(p)) != '-') {
13350  goto eof;
13351  }
13352  if ((c = nextc(p)) == '\\') {
13353  if (peek(p, 'u')) goto eof;
13354  return read_escape(p, flags|ESCAPE_META, encp) | 0x80;
13355  }
13356  else if (c == -1 || !ISASCII(c)) goto eof;
13357  else {
13358  int c2 = escaped_control_code(c);
13359  if (c2) {
13360  if (ISCNTRL(c) || !(flags & ESCAPE_CONTROL)) {
13361  WARN_SPACE_CHAR(c2, "\\M-");
13362  }
13363  else {
13364  WARN_SPACE_CHAR(c2, "\\C-\\M-");
13365  }
13366  }
13367  else if (ISCNTRL(c)) goto eof;
13368  return ((c & 0xff) | 0x80);
13369  }
13370 
13371  case 'C':
13372  if ((c = nextc(p)) != '-') {
13373  goto eof;
13374  }
13375  case 'c':
13376  if (flags & ESCAPE_CONTROL) goto eof;
13377  if ((c = nextc(p))== '\\') {
13378  if (peek(p, 'u')) goto eof;
13379  c = read_escape(p, flags|ESCAPE_CONTROL, encp);
13380  }
13381  else if (c == '?')
13382  return 0177;
13383  else if (c == -1 || !ISASCII(c)) goto eof;
13384  else {
13385  int c2 = escaped_control_code(c);
13386  if (c2) {
13387  if (ISCNTRL(c)) {
13388  if (flags & ESCAPE_META) {
13389  WARN_SPACE_CHAR(c2, "\\M-");
13390  }
13391  else {
13392  WARN_SPACE_CHAR(c2, "");
13393  }
13394  }
13395  else {
13396  if (flags & ESCAPE_META) {
13397  WARN_SPACE_CHAR(c2, "\\M-\\C-");
13398  }
13399  else {
13400  WARN_SPACE_CHAR(c2, "\\C-");
13401  }
13402  }
13403  }
13404  else if (ISCNTRL(c)) goto eof;
13405  }
13406  return c & 0x9f;
13407 
13408  eof:
13409  case -1:
13410  yyerror0("Invalid escape character syntax");
13411  token_flush(p);
13412  return '\0';
13413 
13414  default:
13415  return c;
13416  }
13417 }
13418 
13419 static void
13420 tokaddmbc(struct parser_params *p, int c, rb_encoding *enc)
13421 {
13422  int len = rb_enc_codelen(c, enc);
13423  rb_enc_mbcput(c, tokspace(p, len), enc);
13424 }
13425 
13426 static int
13427 tokadd_escape(struct parser_params *p, rb_encoding **encp)
13428 {
13429  int c;
13430  int flags = 0;
13431  size_t numlen;
13432 
13433  first:
13434  switch (c = nextc(p)) {
13435  case '\n':
13436  return 0; /* just ignore */
13437 
13438  case '0': case '1': case '2': case '3': /* octal constant */
13439  case '4': case '5': case '6': case '7':
13440  {
13441  ruby_scan_oct(--p->lex.pcur, 3, &numlen);
13442  if (numlen == 0) goto eof;
13443  p->lex.pcur += numlen;
13444  tokcopy(p, (int)numlen + 1);
13445  }
13446  return 0;
13447 
13448  case 'x': /* hex constant */
13449  {
13450  tok_hex(p, &numlen);
13451  if (numlen == 0) return -1;
13452  tokcopy(p, (int)numlen + 2);
13453  }
13454  return 0;
13455 
13456  case 'M':
13457  if (flags & ESCAPE_META) goto eof;
13458  if ((c = nextc(p)) != '-') {
13459  pushback(p, c);
13460  goto eof;
13461  }
13462  tokcopy(p, 3);
13463  flags |= ESCAPE_META;
13464  goto escaped;
13465 
13466  case 'C':
13467  if (flags & ESCAPE_CONTROL) goto eof;
13468  if ((c = nextc(p)) != '-') {
13469  pushback(p, c);
13470  goto eof;
13471  }
13472  tokcopy(p, 3);
13473  goto escaped;
13474 
13475  case 'c':
13476  if (flags & ESCAPE_CONTROL) goto eof;
13477  tokcopy(p, 2);
13478  flags |= ESCAPE_CONTROL;
13479  escaped:
13480  if ((c = nextc(p)) == '\\') {
13481  goto first;
13482  }
13483  else if (c == -1) goto eof;
13484  tokadd(p, c);
13485  return 0;
13486 
13487  eof:
13488  case -1:
13489  yyerror0("Invalid escape character syntax");
13490  token_flush(p);
13491  return -1;
13492 
13493  default:
13494  tokadd(p, '\\');
13495  tokadd(p, c);
13496  }
13497  return 0;
13498 }
13499 
13500 static int
13501 regx_options(struct parser_params *p)
13502 {
13503  int kcode = 0;
13504  int kopt = 0;
13505  int options = 0;
13506  int c, opt, kc;
13507 
13508  newtok(p);
13509  while (c = nextc(p), ISALPHA(c)) {
13510  if (c == 'o') {
13511  options |= RE_OPTION_ONCE;
13512  }
13513  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
13514  if (kc >= 0) {
13515  if (kc != rb_ascii8bit_encindex()) kcode = c;
13516  kopt = opt;
13517  }
13518  else {
13519  options |= opt;
13520  }
13521  }
13522  else {
13523  tokadd(p, c);
13524  }
13525  }
13526  options |= kopt;
13527  pushback(p, c);
13528  if (toklen(p)) {
13529  YYLTYPE loc = RUBY_INIT_YYLLOC();
13530  tokfix(p);
13531  compile_error(p, "unknown regexp option%s - %*s",
13532  toklen(p) > 1 ? "s" : "", toklen(p), tok(p));
13533  parser_show_error_line(p, &loc);
13534  }
13535  return options | RE_OPTION_ENCODING(kcode);
13536 }
13537 
13538 static int
13539 tokadd_mbchar(struct parser_params *p, int c)
13540 {
13541  int len = parser_precise_mbclen(p, p->lex.pcur-1);
13542  if (len < 0) return -1;
13543  tokadd(p, c);
13544  p->lex.pcur += --len;
13545  if (len > 0) tokcopy(p, len);
13546  return c;
13547 }
13548 
13549 static inline int
13550 simple_re_meta(int c)
13551 {
13552  switch (c) {
13553  case '$': case '*': case '+': case '.':
13554  case '?': case '^': case '|':
13555  case ')': case ']': case '}': case '>':
13556  return TRUE;
13557  default:
13558  return FALSE;
13559  }
13560 }
13561 
13562 static int
13563 parser_update_heredoc_indent(struct parser_params *p, int c)
13564 {
13565  if (p->heredoc_line_indent == -1) {
13566  if (c == '\n') p->heredoc_line_indent = 0;
13567  }
13568  else {
13569  if (c == ' ') {
13570  p->heredoc_line_indent++;
13571  return TRUE;
13572  }
13573  else if (c == '\t') {
13574  int w = (p->heredoc_line_indent / TAB_WIDTH) + 1;
13575  p->heredoc_line_indent = w * TAB_WIDTH;
13576  return TRUE;
13577  }
13578  else if (c != '\n') {
13579  if (p->heredoc_indent > p->heredoc_line_indent) {
13581  }
13582  p->heredoc_line_indent = -1;
13583  }
13584  }
13585  return FALSE;
13586 }
13587 
13588 static void
13589 parser_mixed_error(struct parser_params *p, rb_encoding *enc1, rb_encoding *enc2)
13590 {
13591  YYLTYPE loc = RUBY_INIT_YYLLOC();
13592  const char *n1 = rb_enc_name(enc1), *n2 = rb_enc_name(enc2);
13593  compile_error(p, "%s mixed within %s source", n1, n2);
13594  parser_show_error_line(p, &loc);
13595 }
13596 
13597 static void
13598 parser_mixed_escape(struct parser_params *p, const char *beg, rb_encoding *enc1, rb_encoding *enc2)
13599 {
13600  const char *pos = p->lex.pcur;
13601  p->lex.pcur = beg;
13602  parser_mixed_error(p, enc1, enc2);
13603  p->lex.pcur = pos;
13604 }
13605 
13606 static int
13607 tokadd_string(struct parser_params *p,
13608  int func, int term, int paren, long *nest,
13609  rb_encoding **encp, rb_encoding **enc)
13610 {
13611  int c;
13612  bool erred = false;
13613 
13614 #define mixed_error(enc1, enc2) \
13615  (void)(erred || (parser_mixed_error(p, enc1, enc2), erred = true))
13616 #define mixed_escape(beg, enc1, enc2) \
13617  (void)(erred || (parser_mixed_escape(p, beg, enc1, enc2), erred = true))
13618 
13619  while ((c = nextc(p)) != -1) {
13620  if (p->heredoc_indent > 0) {
13621  parser_update_heredoc_indent(p, c);
13622  }
13623 
13624  if (paren && c == paren) {
13625  ++*nest;
13626  }
13627  else if (c == term) {
13628  if (!nest || !*nest) {
13629  pushback(p, c);
13630  break;
13631  }
13632  --*nest;
13633  }
13634  else if ((func & STR_FUNC_EXPAND) && c == '#' && p->lex.pcur < p->lex.pend) {
13635  int c2 = *p->lex.pcur;
13636  if (c2 == '$' || c2 == '@' || c2 == '{') {
13637  pushback(p, c);
13638  break;
13639  }
13640  }
13641  else if (c == '\\') {
13642  literal_flush(p, p->lex.pcur - 1);
13643  c = nextc(p);
13644  switch (c) {
13645  case '\n':
13646  if (func & STR_FUNC_QWORDS) break;
13647  if (func & STR_FUNC_EXPAND) {
13648  if (!(func & STR_FUNC_INDENT) || (p->heredoc_indent < 0))
13649  continue;
13650  if (c == term) {
13651  c = '\\';
13652  goto terminate;
13653  }
13654  }
13655  tokadd(p, '\\');
13656  break;
13657 
13658  case '\\':
13659  if (func & STR_FUNC_ESCAPE) tokadd(p, c);
13660  break;
13661 
13662  case 'u':
13663  if ((func & STR_FUNC_EXPAND) == 0) {
13664  tokadd(p, '\\');
13665  break;
13666  }
13667  tokadd_utf8(p, enc, term,
13668  func & STR_FUNC_SYMBOL,
13669  func & STR_FUNC_REGEXP);
13670  continue;
13671 
13672  default:
13673  if (c == -1) return -1;
13674  if (!ISASCII(c)) {
13675  if ((func & STR_FUNC_EXPAND) == 0) tokadd(p, '\\');
13676  goto non_ascii;
13677  }
13678  if (func & STR_FUNC_REGEXP) {
13679  if (c == term && !simple_re_meta(c)) {
13680  tokadd(p, c);
13681  continue;
13682  }
13683  pushback(p, c);
13684  if ((c = tokadd_escape(p, enc)) < 0)
13685  return -1;
13686  if (*enc && *enc != *encp) {
13687  mixed_escape(p->lex.ptok+2, *enc, *encp);
13688  }
13689  continue;
13690  }
13691  else if (func & STR_FUNC_EXPAND) {
13692  pushback(p, c);
13693  if (func & STR_FUNC_ESCAPE) tokadd(p, '\\');
13694  c = read_escape(p, 0, enc);
13695  }
13696  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
13697  /* ignore backslashed spaces in %w */
13698  }
13699  else if (c != term && !(paren && c == paren)) {
13700  tokadd(p, '\\');
13701  pushback(p, c);
13702  continue;
13703  }
13704  }
13705  }
13706  else if (!parser_isascii(p)) {
13707  non_ascii:
13708  if (!*enc) {
13709  *enc = *encp;
13710  }
13711  else if (*enc != *encp) {
13712  mixed_error(*enc, *encp);
13713  continue;
13714  }
13715  if (tokadd_mbchar(p, c) == -1) return -1;
13716  continue;
13717  }
13718  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
13719  pushback(p, c);
13720  break;
13721  }
13722  if (c & 0x80) {
13723  if (!*enc) {
13724  *enc = *encp;
13725  }
13726  else if (*enc != *encp) {
13727  mixed_error(*enc, *encp);
13728  continue;
13729  }
13730  }
13731  tokadd(p, c);
13732  }
13733  terminate:
13734  if (*enc) *encp = *enc;
13735  return c;
13736 }
13737 
13738 static inline rb_strterm_t *
13739 new_strterm(VALUE v1, VALUE v2, VALUE v3, VALUE v0)
13740 {
13741  return (rb_strterm_t*)rb_imemo_new(imemo_parser_strterm, v1, v2, v3, v0);
13742 }
13743 
13744 /* imemo_parser_strterm for literal */
13745 #define NEW_STRTERM(func, term, paren) \
13746  new_strterm((VALUE)(func), (VALUE)(paren), (VALUE)(term), 0)
13747 
13748 #ifdef RIPPER
13749 static void
13751 {
13752  VALUE content = yylval.val;
13753  if (!ripper_is_node_yylval(content))
13754  content = ripper_new_yylval(p, 0, 0, content);
13755  if (has_delayed_token(p)) {
13756  ptrdiff_t len = p->lex.pcur - p->lex.ptok;
13757  if (len > 0) {
13758  rb_enc_str_buf_cat(p->delayed.token, p->lex.ptok, len, enc);
13759  }
13761  p->lex.ptok = p->lex.pcur;
13762  RNODE(content)->nd_rval = yylval.val;
13763  }
13765  if (yylval.val != content)
13766  RNODE(content)->nd_rval = yylval.val;
13767  yylval.val = content;
13768 }
13769 #else
13770 #define flush_string_content(p, enc) ((void)(enc))
13771 #endif
13772 
13773 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
13774 /* this can be shared with ripper, since it's independent from struct
13775  * parser_params. */
13776 #ifndef RIPPER
13777 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
13778 #define SPECIAL_PUNCT(idx) ( \
13779  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
13780  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
13781  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
13782  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
13783  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
13784  BIT('0', idx))
13785 const unsigned int ruby_global_name_punct_bits[] = {
13786  SPECIAL_PUNCT(0),
13787  SPECIAL_PUNCT(1),
13788  SPECIAL_PUNCT(2),
13789 };
13790 #undef BIT
13791 #undef SPECIAL_PUNCT
13792 #endif
13793 
13794 static enum yytokentype
13795 parser_peek_variable_name(struct parser_params *p)
13796 {
13797  int c;
13798  const char *ptr = p->lex.pcur;
13799 
13800  if (ptr + 1 >= p->lex.pend) return 0;
13801  c = *ptr++;
13802  switch (c) {
13803  case '$':
13804  if ((c = *ptr) == '-') {
13805  if (++ptr >= p->lex.pend) return 0;
13806  c = *ptr;
13807  }
13808  else if (is_global_name_punct(c) || ISDIGIT(c)) {
13809  return tSTRING_DVAR;
13810  }
13811  break;
13812  case '@':
13813  if ((c = *ptr) == '@') {
13814  if (++ptr >= p->lex.pend) return 0;
13815  c = *ptr;
13816  }
13817  break;
13818  case '{':
13819  p->lex.pcur = ptr;
13820  p->command_start = TRUE;
13821  return tSTRING_DBEG;
13822  default:
13823  return 0;
13824  }
13825  if (!ISASCII(c) || c == '_' || ISALPHA(c))
13826  return tSTRING_DVAR;
13827  return 0;
13828 }
13829 
13830 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13831 #define IS_END() IS_lex_state(EXPR_END_ANY)
13832 #define IS_BEG() (IS_lex_state(EXPR_BEG_ANY) || IS_lex_state_all(EXPR_ARG|EXPR_LABELED))
13833 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13834 #define IS_LABEL_POSSIBLE() (\
13835  (IS_lex_state(EXPR_LABEL|EXPR_ENDFN) && !cmd_state) || \
13836  IS_ARG())
13837 #define IS_LABEL_SUFFIX(n) (peek_n(p, ':',(n)) && !peek_n(p, ':', (n)+1))
13838 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13839 
13840 static inline enum yytokentype
13841 parser_string_term(struct parser_params *p, int func)
13842 {
13843  p->lex.strterm = 0;
13844  if (func & STR_FUNC_REGEXP) {
13845  set_yylval_num(regx_options(p));
13847  SET_LEX_STATE(EXPR_END);
13848  return tREGEXP_END;
13849  }
13850  if ((func & STR_FUNC_LABEL) && IS_LABEL_SUFFIX(0)) {
13851  nextc(p);
13852  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
13853  return tLABEL_END;
13854  }
13855  SET_LEX_STATE(EXPR_END);
13856  return tSTRING_END;
13857 }
13858 
13859 static enum yytokentype
13860 parse_string(struct parser_params *p, rb_strterm_literal_t *quote)
13861 {
13862  int func = (int)quote->u1.func;
13863  int term = (int)quote->u3.term;
13864  int paren = (int)quote->u2.paren;
13865  int c, space = 0;
13866  rb_encoding *enc = p->enc;
13867  rb_encoding *base_enc = 0;
13868  VALUE lit;
13869 
13870  if (func & STR_FUNC_TERM) {
13871  if (func & STR_FUNC_QWORDS) nextc(p); /* delayed term */
13872  SET_LEX_STATE(EXPR_END);
13873  p->lex.strterm = 0;
13874  return func & STR_FUNC_REGEXP ? tREGEXP_END : tSTRING_END;
13875  }
13876  c = nextc(p);
13877  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
13878  do {c = nextc(p);} while (ISSPACE(c));
13879  space = 1;
13880  }
13881  if (func & STR_FUNC_LIST) {
13882  quote->u1.func &= ~STR_FUNC_LIST;
13883  space = 1;
13884  }
13885  if (c == term && !quote->u0.nest) {
13886  if (func & STR_FUNC_QWORDS) {
13887  quote->u1.func |= STR_FUNC_TERM;
13888  pushback(p, c); /* dispatch the term at tSTRING_END */
13889  add_delayed_token(p, p->lex.ptok, p->lex.pcur);
13890  return ' ';
13891  }
13892  return parser_string_term(p, func);
13893  }
13894  if (space) {
13895  pushback(p, c);
13896  add_delayed_token(p, p->lex.ptok, p->lex.pcur);
13897  return ' ';
13898  }
13899  newtok(p);
13900  if ((func & STR_FUNC_EXPAND) && c == '#') {
13901  int t = parser_peek_variable_name(p);
13902  if (t) return t;
13903  tokadd(p, '#');
13904  c = nextc(p);
13905  }
13906  pushback(p, c);
13907  if (tokadd_string(p, func, term, paren, &quote->u0.nest,
13908  &enc, &base_enc) == -1) {
13909  if (p->eofp) {
13910 #ifndef RIPPER
13911 # define unterminated_literal(mesg) yyerror0(mesg)
13912 #else
13913 # define unterminated_literal(mesg) compile_error(p, mesg)
13914 #endif
13915  literal_flush(p, p->lex.pcur);
13916  if (func & STR_FUNC_QWORDS) {
13917  /* no content to add, bailing out here */
13918  unterminated_literal("unterminated list meets end of file");
13919  p->lex.strterm = 0;
13920  return tSTRING_END;
13921  }
13922  if (func & STR_FUNC_REGEXP) {
13923  unterminated_literal("unterminated regexp meets end of file");
13924  }
13925  else {
13926  unterminated_literal("unterminated string meets end of file");
13927  }
13928  quote->u1.func |= STR_FUNC_TERM;
13929  }
13930  }
13931 
13932  tokfix(p);
13933  lit = STR_NEW3(tok(p), toklen(p), enc, func);
13934  set_yylval_str(lit);
13936 
13937  return tSTRING_CONTENT;
13938 }
13939 
13940 static enum yytokentype
13941 heredoc_identifier(struct parser_params *p)
13942 {
13943  /*
13944  * term_len is length of `<<"END"` except `END`,
13945  * in this case term_len is 4 (<, <, " and ").
13946  */
13947  long len, offset = p->lex.pcur - p->lex.pbeg;
13948  int c = nextc(p), term, func = 0, quote = 0;
13949  enum yytokentype token = tSTRING_BEG;
13950  int indent = 0;
13951 
13952  if (c == '-') {
13953  c = nextc(p);
13954  func = STR_FUNC_INDENT;
13955  offset++;
13956  }
13957  else if (c == '~') {
13958  c = nextc(p);
13959  func = STR_FUNC_INDENT;
13960  offset++;
13961  indent = INT_MAX;
13962  }
13963  switch (c) {
13964  case '\'':
13965  func |= str_squote; goto quoted;
13966  case '"':
13967  func |= str_dquote; goto quoted;
13968  case '`':
13969  token = tXSTRING_BEG;
13970  func |= str_xquote; goto quoted;
13971 
13972  quoted:
13973  quote++;
13974  offset++;
13975  term = c;
13976  len = 0;
13977  while ((c = nextc(p)) != term) {
13978  if (c == -1 || c == '\r' || c == '\n') {
13979  yyerror(NULL, p, "unterminated here document identifier");
13980  return -1;
13981  }
13982  }
13983  break;
13984 
13985  default:
13986  if (!parser_is_identchar(p)) {
13987  pushback(p, c);
13988  if (func & STR_FUNC_INDENT) {
13989  pushback(p, indent > 0 ? '~' : '-');
13990  }
13991  return 0;
13992  }
13993  func |= str_dquote;
13994  do {
13995  int n = parser_precise_mbclen(p, p->lex.pcur-1);
13996  if (n < 0) return 0;
13997  p->lex.pcur += --n;
13998  } while ((c = nextc(p)) != -1 && parser_is_identchar(p));
13999  pushback(p, c);
14000  break;
14001  }
14002 
14003  len = p->lex.pcur - (p->lex.pbeg + offset) - quote;
14004  if ((unsigned long)len >= HERETERM_LENGTH_MAX)
14005  yyerror(NULL, p, "too long here document identifier");
14007  lex_goto_eol(p);
14008 
14009  p->lex.strterm = new_strterm(0, 0, 0, p->lex.lastline);
14011  rb_strterm_heredoc_t *here = &p->lex.strterm->u.heredoc;
14012  here->offset = offset;
14013  here->sourceline = p->ruby_sourceline;
14014  here->length = (int)len;
14015  here->quote = quote;
14016  here->func = func;
14017 
14018  token_flush(p);
14019  p->heredoc_indent = indent;
14020  p->heredoc_line_indent = 0;
14021  return token;
14022 }
14023 
14024 static void
14025 heredoc_restore(struct parser_params *p, rb_strterm_heredoc_t *here)
14026 {
14027  VALUE line;
14028 
14029  p->lex.strterm = 0;
14030  line = here->lastline;
14031  p->lex.lastline = line;
14032  p->lex.pbeg = RSTRING_PTR(line);
14033  p->lex.pend = p->lex.pbeg + RSTRING_LEN(line);
14034  p->lex.pcur = p->lex.pbeg + here->offset + here->length + here->quote;
14035  p->lex.ptok = p->lex.pbeg + here->offset - here->quote;
14036  p->heredoc_end = p->ruby_sourceline;
14037  p->ruby_sourceline = (int)here->sourceline;
14038  if (p->eofp) p->lex.nextline = Qnil;
14039  p->eofp = 0;
14040 }
14041 
14042 static int
14043 dedent_string(VALUE string, int width)
14044 {
14045  char *str;
14046  long len;
14047  int i, col = 0;
14048 
14049  RSTRING_GETMEM(string, str, len);
14050  for (i = 0; i < len && col < width; i++) {
14051  if (str[i] == ' ') {
14052  col++;
14053  }
14054  else if (str[i] == '\t') {
14055  int n = TAB_WIDTH * (col / TAB_WIDTH + 1);
14056  if (n > width) break;
14057  col = n;
14058  }
14059  else {
14060  break;
14061  }
14062  }
14063  if (!i) return 0;
14064  rb_str_modify(string);
14065  str = RSTRING_PTR(string);
14066  if (RSTRING_LEN(string) != len)
14067  rb_fatal("literal string changed: %+"PRIsVALUE, string);
14068  MEMMOVE(str, str + i, char, len - i);
14069  rb_str_set_len(string, len - i);
14070  return i;
14071 }
14072 
14073 #ifndef RIPPER
14074 static NODE *
14075 heredoc_dedent(struct parser_params *p, NODE *root)
14076 {
14077  NODE *node, *str_node, *prev_node;
14078  int indent = p->heredoc_indent;
14079  VALUE prev_lit = 0;
14080 
14081  if (indent <= 0) return root;
14082  p->heredoc_indent = 0;
14083  if (!root) return root;
14084 
14085  prev_node = node = str_node = root;
14086  if (nd_type(root) == NODE_LIST) str_node = root->nd_head;
14087 
14088  while (str_node) {
14089  VALUE lit = str_node->nd_lit;
14090  if (str_node->flags & NODE_FL_NEWLINE) {
14091  dedent_string(lit, indent);
14092  }
14093  if (!prev_lit) {
14094  prev_lit = lit;
14095  }
14096  else if (!literal_concat0(p, prev_lit, lit)) {
14097  return 0;
14098  }
14099  else {
14100  NODE *end = node->nd_end;
14101  node = prev_node->nd_next = node->nd_next;
14102  if (!node) {
14103  if (nd_type(prev_node) == NODE_DSTR)
14104  nd_set_type(prev_node, NODE_STR);
14105  break;
14106  }
14107  node->nd_end = end;
14108  goto next_str;
14109  }
14110 
14111  str_node = 0;
14112  while ((node = (prev_node = node)->nd_next) != 0) {
14113  next_str:
14114  if (nd_type(node) != NODE_LIST) break;
14115  if ((str_node = node->nd_head) != 0) {
14116  enum node_type type = nd_type(str_node);
14117  if (type == NODE_STR || type == NODE_DSTR) break;
14118  prev_lit = 0;
14119  str_node = 0;
14120  }
14121  }
14122  }
14123  return root;
14124 }
14125 #else /* RIPPER */
14126 static VALUE
14127 heredoc_dedent(struct parser_params *p, VALUE array)
14128 {
14129  int indent = p->heredoc_indent;
14130 
14131  if (indent <= 0) return array;
14132  p->heredoc_indent = 0;
14133  dispatch2(heredoc_dedent, array, INT2NUM(indent));
14134  return array;
14135 }
14136 
14137 /*
14138  * call-seq:
14139  * Ripper.dedent_string(input, width) -> Integer
14140  *
14141  * USE OF RIPPER LIBRARY ONLY.
14142  *
14143  * Strips up to +width+ leading whitespaces from +input+,
14144  * and returns the stripped column width.
14145  */
14146 static VALUE
14147 parser_dedent_string(VALUE self, VALUE input, VALUE width)
14148 {
14149  int wid, col;
14150 
14151  StringValue(input);
14152  wid = NUM2UINT(width);
14153  col = dedent_string(input, wid);
14154  return INT2NUM(col);
14155 }
14156 #endif
14157 
14158 static int
14159 whole_match_p(struct parser_params *p, const char *eos, long len, int indent)
14160 {
14161  const char *ptr = p->lex.pbeg;
14162  long n;
14163 
14164  if (indent) {
14165  while (*ptr && ISSPACE(*ptr)) ptr++;
14166  }
14167  n = p->lex.pend - (ptr + len);
14168  if (n < 0) return FALSE;
14169  if (n > 0 && ptr[len] != '\n') {
14170  if (ptr[len] != '\r') return FALSE;
14171  if (n <= 1 || ptr[len+1] != '\n') return FALSE;
14172  }
14173  return strncmp(eos, ptr, len) == 0;
14174 }
14175 
14176 static int
14177 word_match_p(struct parser_params *p, const char *word, long len)
14178 {
14179  if (strncmp(p->lex.pcur, word, len)) return 0;
14180  if (p->lex.pcur + len == p->lex.pend) return 1;
14181  int c = (unsigned char)p->lex.pcur[len];
14182  if (ISSPACE(c)) return 1;
14183  switch (c) {
14184  case '\0': case '\004': case '\032': return 1;
14185  }
14186  return 0;
14187 }
14188 
14189 #define NUM_SUFFIX_R (1<<0)
14190 #define NUM_SUFFIX_I (1<<1)
14191 #define NUM_SUFFIX_ALL 3
14192 
14193 static int
14194 number_literal_suffix(struct parser_params *p, int mask)
14195 {
14196  int c, result = 0;
14197  const char *lastp = p->lex.pcur;
14198 
14199  while ((c = nextc(p)) != -1) {
14200  if ((mask & NUM_SUFFIX_I) && c == 'i') {
14201  result |= (mask & NUM_SUFFIX_I);
14202  mask &= ~NUM_SUFFIX_I;
14203  /* r after i, rational of complex is disallowed */
14204  mask &= ~NUM_SUFFIX_R;
14205  continue;
14206  }
14207  if ((mask & NUM_SUFFIX_R) && c == 'r') {
14208  result |= (mask & NUM_SUFFIX_R);
14209  mask &= ~NUM_SUFFIX_R;
14210  continue;
14211  }
14212  if (!ISASCII(c) || ISALPHA(c) || c == '_') {
14213  p->lex.pcur = lastp;
14214  literal_flush(p, p->lex.pcur);
14215  return 0;
14216  }
14217  pushback(p, c);
14218  break;
14219  }
14220  return result;
14221 }
14222 
14223 static enum yytokentype
14224 set_number_literal(struct parser_params *p, VALUE v,
14225  enum yytokentype type, int suffix)
14226 {
14227  if (suffix & NUM_SUFFIX_I) {
14228  v = rb_complex_raw(INT2FIX(0), v);
14229  type = tIMAGINARY;
14230  }
14232  SET_LEX_STATE(EXPR_END);
14233  return type;
14234 }
14235 
14236 static enum yytokentype
14237 set_integer_literal(struct parser_params *p, VALUE v, int suffix)
14238 {
14239  enum yytokentype type = tINTEGER;
14240  if (suffix & NUM_SUFFIX_R) {
14241  v = rb_rational_raw1(v);
14242  type = tRATIONAL;
14243  }
14244  return set_number_literal(p, v, type, suffix);
14245 }
14246 
14247 #ifdef RIPPER
14248 static void
14250 {
14251  VALUE str;
14252  if (has_delayed_token(p))
14254  str = STR_NEW(p->lex.ptok, p->lex.pend - p->lex.ptok);
14255  ripper_dispatch1(p, ripper_token2eventid(tHEREDOC_END), str);
14256  lex_goto_eol(p);
14257  token_flush(p);
14258 }
14259 
14260 #else
14261 #define dispatch_heredoc_end(p) ((void)0)
14262 #endif
14263 
14264 static enum yytokentype
14265 here_document(struct parser_params *p, rb_strterm_heredoc_t *here)
14266 {
14267  int c, func, indent = 0;
14268  const char *eos, *ptr, *ptr_end;
14269  long len;
14270  VALUE str = 0;
14271  rb_encoding *enc = p->enc;
14272  rb_encoding *base_enc = 0;
14273  int bol;
14274 
14275  eos = RSTRING_PTR(here->lastline) + here->offset;
14276  len = here->length;
14277  indent = (func = here->func) & STR_FUNC_INDENT;
14278 
14279  if ((c = nextc(p)) == -1) {
14280  error:
14281 #ifdef RIPPER
14282  if (!has_delayed_token(p)) {
14284  }
14285  else {
14286  if ((len = p->lex.pcur - p->lex.ptok) > 0) {
14287  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
14288  int cr = ENC_CODERANGE_UNKNOWN;
14290  if (cr != ENC_CODERANGE_7BIT &&
14291  p->enc == rb_usascii_encoding() &&
14292  enc != rb_utf8_encoding()) {
14294  }
14295  }
14296  rb_enc_str_buf_cat(p->delayed.token, p->lex.ptok, len, enc);
14297  }
14299  }
14300  lex_goto_eol(p);
14301 #endif
14302  heredoc_restore(p, &p->lex.strterm->u.heredoc);
14303  compile_error(p, "can't find string \"%.*s\" anywhere before EOF",
14304  (int)len, eos);
14305  token_flush(p);
14306  p->lex.strterm = 0;
14307  SET_LEX_STATE(EXPR_END);
14308  return tSTRING_END;
14309  }
14310  bol = was_bol(p);
14311  if (!bol) {
14312  /* not beginning of line, cannot be the terminator */
14313  }
14314  else if (p->heredoc_line_indent == -1) {
14315  /* `heredoc_line_indent == -1` means
14316  * - "after an interpolation in the same line", or
14317  * - "in a continuing line"
14318  */
14319  p->heredoc_line_indent = 0;
14320  }
14321  else if (whole_match_p(p, eos, len, indent)) {
14323  restore:
14324  heredoc_restore(p, &p->lex.strterm->u.heredoc);
14325  token_flush(p);
14326  p->lex.strterm = 0;
14327  SET_LEX_STATE(EXPR_END);
14328  return tSTRING_END;
14329  }
14330 
14331  if (!(func & STR_FUNC_EXPAND)) {
14332  do {
14333  ptr = RSTRING_PTR(p->lex.lastline);
14334  ptr_end = p->lex.pend;
14335  if (ptr_end > ptr) {
14336  switch (ptr_end[-1]) {
14337  case '\n':
14338  if (--ptr_end == ptr || ptr_end[-1] != '\r') {
14339  ptr_end++;
14340  break;
14341  }
14342  case '\r':
14343  --ptr_end;
14344  }
14345  }
14346 
14347  if (p->heredoc_indent > 0) {
14348  long i = 0;
14349  while (ptr + i < ptr_end && parser_update_heredoc_indent(p, ptr[i]))
14350  i++;
14351  p->heredoc_line_indent = 0;
14352  }
14353 
14354  if (str)
14355  rb_str_cat(str, ptr, ptr_end - ptr);
14356  else
14357  str = STR_NEW(ptr, ptr_end - ptr);
14358  if (ptr_end < p->lex.pend) rb_str_cat(str, "\n", 1);
14359  lex_goto_eol(p);
14360  if (p->heredoc_indent > 0) {
14361  goto flush_str;
14362  }
14363  if (nextc(p) == -1) {
14364  if (str) {
14365  str = 0;
14366  }
14367  goto error;
14368  }
14369  } while (!whole_match_p(p, eos, len, indent));
14370  }
14371  else {
14372  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
14373  newtok(p);
14374  if (c == '#') {
14375  int t = parser_peek_variable_name(p);
14376  if (p->heredoc_line_indent != -1) {
14377  if (p->heredoc_indent > p->heredoc_line_indent) {
14379  }
14380  p->heredoc_line_indent = -1;
14381  }
14382  if (t) return t;
14383  tokadd(p, '#');
14384  c = nextc(p);
14385  }
14386  do {
14387  pushback(p, c);
14388  enc = p->enc;
14389  if ((c = tokadd_string(p, func, '\n', 0, NULL, &enc, &base_enc)) == -1) {
14390  if (p->eofp) goto error;
14391  goto restore;
14392  }
14393  if (c != '\n') {
14394  if (c == '\\') p->heredoc_line_indent = -1;
14395  flush:
14396  str = STR_NEW3(tok(p), toklen(p), enc, func);
14397  flush_str:
14399 #ifndef RIPPER
14400  if (bol) yylval.node->flags |= NODE_FL_NEWLINE;
14401 #endif
14403  return tSTRING_CONTENT;
14404  }
14405  tokadd(p, nextc(p));
14406  if (p->heredoc_indent > 0) {
14407  lex_goto_eol(p);
14408  goto flush;
14409  }
14410  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
14411  if ((c = nextc(p)) == -1) goto error;
14412  } while (!whole_match_p(p, eos, len, indent));
14413  str = STR_NEW3(tok(p), toklen(p), enc, func);
14414  }
14416 #ifdef RIPPER
14417  str = ripper_new_yylval(p, ripper_token2eventid(tSTRING_CONTENT),
14418  yylval.val, str);
14419 #endif
14420  heredoc_restore(p, &p->lex.strterm->u.heredoc);
14421  token_flush(p);
14422  p->lex.strterm = NEW_STRTERM(func | STR_FUNC_TERM, 0, 0);
14424 #ifndef RIPPER
14425  if (bol) yylval.node->flags |= NODE_FL_NEWLINE;
14426 #endif
14427  return tSTRING_CONTENT;
14428 }
14429 
14430 #include "lex.c"
14431 
14432 static int
14433 arg_ambiguous(struct parser_params *p, char c)
14434 {
14435 #ifndef RIPPER
14436  rb_warning1("ambiguous first argument; put parentheses or a space even after `%c' operator", WARN_I(c));
14437 #else
14438  dispatch1(arg_ambiguous, rb_usascii_str_new(&c, 1));
14439 #endif
14440  return TRUE;
14441 }
14442 
14443 static ID
14444 formal_argument(struct parser_params *p, ID lhs)
14445 {
14446  switch (id_type(lhs)) {
14447  case ID_LOCAL:
14448  break;
14449 #ifndef RIPPER
14450  case ID_CONST:
14451  yyerror0("formal argument cannot be a constant");
14452  return 0;
14453  case ID_INSTANCE:
14454  yyerror0("formal argument cannot be an instance variable");
14455  return 0;
14456  case ID_GLOBAL:
14457  yyerror0("formal argument cannot be a global variable");
14458  return 0;
14459  case ID_CLASS:
14460  yyerror0("formal argument cannot be a class variable");
14461  return 0;
14462  default:
14463  yyerror0("formal argument must be local variable");
14464  return 0;
14465 #else
14466  default:
14467  lhs = dispatch1(param_error, lhs);
14468  ripper_error(p);
14469  return 0;
14470 #endif
14471  }
14472  shadowing_lvar(p, lhs);
14473  return lhs;
14474 }
14475 
14476 static int
14477 lvar_defined(struct parser_params *p, ID id)
14478 {
14479  return (dyna_in_block(p) && dvar_defined(p, id)) || local_id(p, id);
14480 }
14481 
14482 /* emacsen -*- hack */
14483 static long
14484 parser_encode_length(struct parser_params *p, const char *name, long len)
14485 {
14486  long nlen;
14487 
14488  if (len > 5 && name[nlen = len - 5] == '-') {
14489  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
14490  return nlen;
14491  }
14492  if (len > 4 && name[nlen = len - 4] == '-') {
14493  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
14494  return nlen;
14495  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
14496  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
14497  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
14498  return nlen;
14499  }
14500  return len;
14501 }
14502 
14503 static void
14504 parser_set_encode(struct parser_params *p, const char *name)
14505 {
14506  int idx = rb_enc_find_index(name);
14507  rb_encoding *enc;
14508  VALUE excargs[3];
14509 
14510  if (idx < 0) {
14511  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
14512  error:
14513  excargs[0] = rb_eArgError;
14514  excargs[2] = rb_make_backtrace();
14516  rb_exc_raise(rb_make_exception(3, excargs));
14517  }
14518  enc = rb_enc_from_index(idx);
14519  if (!rb_enc_asciicompat(enc)) {
14520  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
14521  goto error;
14522  }
14523  p->enc = enc;
14524 #ifndef RIPPER
14525  if (p->debug_lines) {
14526  VALUE lines = p->debug_lines;
14527  long i, n = RARRAY_LEN(lines);
14528  for (i = 0; i < n; ++i) {
14529  rb_enc_associate_index(RARRAY_AREF(lines, i), idx);
14530  }
14531  }
14532 #endif
14533 }
14534 
14535 static int
14536 comment_at_top(struct parser_params *p)
14537 {
14538  const char *ptr = p->lex.pbeg, *ptr_end = p->lex.pcur - 1;
14539  if (p->line_count != (p->has_shebang ? 2 : 1)) return 0;
14540  while (ptr < ptr_end) {
14541  if (!ISSPACE(*ptr)) return 0;
14542  ptr++;
14543  }
14544  return 1;
14545 }
14546 
14547 typedef long (*rb_magic_comment_length_t)(struct parser_params *p, const char *name, long len);
14548 typedef void (*rb_magic_comment_setter_t)(struct parser_params *p, const char *name, const char *val);
14549 
14550 static void
14551 magic_comment_encoding(struct parser_params *p, const char *name, const char *val)
14552 {
14553  if (!comment_at_top(p)) {
14554  return;
14555  }
14556  parser_set_encode(p, val);
14557 }
14558 
14559 static int
14560 parser_get_bool(struct parser_params *p, const char *name, const char *val)
14561 {
14562  switch (*val) {
14563  case 't': case 'T':
14564  if (strcasecmp(val, "true") == 0) {
14565  return TRUE;
14566  }
14567  break;
14568  case 'f': case 'F':
14569  if (strcasecmp(val, "false") == 0) {
14570  return FALSE;
14571  }
14572  break;
14573  }
14574  rb_compile_warning(p->ruby_sourcefile, p->ruby_sourceline, "invalid value for %s: %s", name, val);
14575  return -1;
14576 }
14577 
14578 static void
14579 parser_set_token_info(struct parser_params *p, const char *name, const char *val)
14580 {
14581  int b = parser_get_bool(p, name, val);
14582  if (b >= 0) p->token_info_enabled = b;
14583 }
14584 
14585 static void
14586 parser_set_compile_option_flag(struct parser_params *p, const char *name, const char *val)
14587 {
14588  int b;
14589 
14590  if (p->token_seen) {
14591  rb_warning1("`%s' is ignored after any tokens", WARN_S(name));
14592  return;
14593  }
14594 
14595  b = parser_get_bool(p, name, val);
14596  if (b < 0) return;
14597 
14598  if (!p->compile_option)
14601  (b ? Qtrue : Qfalse));
14602 }
14603 
14604 # if WARN_PAST_SCOPE
14605 static void
14606 parser_set_past_scope(struct parser_params *p, const char *name, const char *val)
14607 {
14608  int b = parser_get_bool(p, name, val);
14609  if (b >= 0) p->past_scope_enabled = b;
14610 }
14611 # endif
14612 
14614  const char *name;
14617 };
14618 
14619 static const struct magic_comment magic_comments[] = {
14620  {"coding", magic_comment_encoding, parser_encode_length},
14621  {"encoding", magic_comment_encoding, parser_encode_length},
14622  {"frozen_string_literal", parser_set_compile_option_flag},
14623  {"warn_indent", parser_set_token_info},
14624 # if WARN_PAST_SCOPE
14625  {"warn_past_scope", parser_set_past_scope},
14626 # endif
14627 };
14628 
14629 static const char *
14630 magic_comment_marker(const char *str, long len)
14631 {
14632  long i = 2;
14633 
14634  while (i < len) {
14635  switch (str[i]) {
14636  case '-':
14637  if (str[i-1] == '*' && str[i-2] == '-') {
14638  return str + i + 1;
14639  }
14640  i += 2;
14641  break;
14642  case '*':
14643  if (i + 1 >= len) return 0;
14644  if (str[i+1] != '-') {
14645  i += 4;
14646  }
14647  else if (str[i-1] != '-') {
14648  i += 2;
14649  }
14650  else {
14651  return str + i + 2;
14652  }
14653  break;
14654  default:
14655  i += 3;
14656  break;
14657  }
14658  }
14659  return 0;
14660 }
14661 
14662 static int
14663 parser_magic_comment(struct parser_params *p, const char *str, long len)
14664 {
14665  int indicator = 0;
14666  VALUE name = 0, val = 0;
14667  const char *beg, *end, *vbeg, *vend;
14668 #define str_copy(_s, _p, _n) ((_s) \
14669  ? (void)(rb_str_resize((_s), (_n)), \
14670  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
14671  : (void)((_s) = STR_NEW((_p), (_n))))
14672 
14673  if (len <= 7) return FALSE;
14674  if (!!(beg = magic_comment_marker(str, len))) {
14675  if (!(end = magic_comment_marker(beg, str + len - beg)))
14676  return FALSE;
14677  indicator = TRUE;
14678  str = beg;
14679  len = end - beg - 3;
14680  }
14681 
14682  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
14683  while (len > 0) {
14684  const struct magic_comment *mc = magic_comments;
14685  char *s;
14686  int i;
14687  long n = 0;
14688 
14689  for (; len > 0 && *str; str++, --len) {
14690  switch (*str) {
14691  case '\'': case '"': case ':': case ';':
14692  continue;
14693  }
14694  if (!ISSPACE(*str)) break;
14695  }
14696  for (beg = str; len > 0; str++, --len) {
14697  switch (*str) {
14698  case '\'': case '"': case ':': case ';':
14699  break;
14700  default:
14701  if (ISSPACE(*str)) break;
14702  continue;
14703  }
14704  break;
14705  }
14706  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
14707  if (!len) break;
14708  if (*str != ':') {
14709  if (!indicator) return FALSE;
14710  continue;
14711  }
14712 
14713  do str++; while (--len > 0 && ISSPACE(*str));
14714  if (!len) break;
14715  if (*str == '"') {
14716  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
14717  if (*str == '\\') {
14718  --len;
14719  ++str;
14720  }
14721  }
14722  vend = str;
14723  if (len) {
14724  --len;
14725  ++str;
14726  }
14727  }
14728  else {
14729  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
14730  vend = str;
14731  }
14732  if (indicator) {
14733  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
14734  }
14735  else {
14736  while (len > 0 && (ISSPACE(*str))) --len, str++;
14737  if (len) return FALSE;
14738  }
14739 
14740  n = end - beg;
14741  str_copy(name, beg, n);
14742  s = RSTRING_PTR(name);
14743  for (i = 0; i < n; ++i) {
14744  if (s[i] == '-') s[i] = '_';
14745  }
14746  do {
14747  if (STRNCASECMP(mc->name, s, n) == 0 && !mc->name[n]) {
14748  n = vend - vbeg;
14749  if (mc->length) {
14750  n = (*mc->length)(p, vbeg, n);
14751  }
14752  str_copy(val, vbeg, n);
14753  (*mc->func)(p, mc->name, RSTRING_PTR(val));
14754  break;
14755  }
14756  } while (++mc < magic_comments + numberof(magic_comments));
14757 #ifdef RIPPER
14758  str_copy(val, vbeg, vend - vbeg);
14759  dispatch2(magic_comment, name, val);
14760 #endif
14761  }
14762 
14763  return TRUE;
14764 }
14765 
14766 static void
14767 set_file_encoding(struct parser_params *p, const char *str, const char *send)
14768 {
14769  int sep = 0;
14770  const char *beg = str;
14771  VALUE s;
14772 
14773  for (;;) {
14774  if (send - str <= 6) return;
14775  switch (str[6]) {
14776  case 'C': case 'c': str += 6; continue;
14777  case 'O': case 'o': str += 5; continue;
14778  case 'D': case 'd': str += 4; continue;
14779  case 'I': case 'i': str += 3; continue;
14780  case 'N': case 'n': str += 2; continue;
14781  case 'G': case 'g': str += 1; continue;
14782  case '=': case ':':
14783  sep = 1;
14784  str += 6;
14785  break;
14786  default:
14787  str += 6;
14788  if (ISSPACE(*str)) break;
14789  continue;
14790  }
14791  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
14792  }
14793  for (;;) {
14794  do {
14795  if (++str >= send) return;
14796  } while (ISSPACE(*str));
14797  if (sep) break;
14798  if (*str != '=' && *str != ':') return;
14799  sep = 1;
14800  str++;
14801  }
14802  beg = str;
14803  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
14804  s = rb_str_new(beg, parser_encode_length(p, beg, str - beg));
14805  parser_set_encode(p, RSTRING_PTR(s));
14806  rb_str_resize(s, 0);
14807 }
14808 
14809 static void
14810 parser_prepare(struct parser_params *p)
14811 {
14812  int c = nextc(p);
14814  switch (c) {
14815  case '#':
14816  if (peek(p, '!')) p->has_shebang = 1;
14817  break;
14818  case 0xef: /* UTF-8 BOM marker */
14819  if (p->lex.pend - p->lex.pcur >= 2 &&
14820  (unsigned char)p->lex.pcur[0] == 0xbb &&
14821  (unsigned char)p->lex.pcur[1] == 0xbf) {
14822  p->enc = rb_utf8_encoding();
14823  p->lex.pcur += 2;
14824  p->lex.pbeg = p->lex.pcur;
14825  return;
14826  }
14827  break;
14828  case EOF:
14829  return;
14830  }
14831  pushback(p, c);
14832  p->enc = rb_enc_get(p->lex.lastline);
14833 }
14834 
14835 #ifndef RIPPER
14836 #define ambiguous_operator(tok, op, syn) ( \
14837  rb_warning0("`"op"' after local variable or literal is interpreted as binary operator"), \
14838  rb_warning0("even though it seems like "syn""))
14839 #else
14840 #define ambiguous_operator(tok, op, syn) \
14841  dispatch2(operator_ambiguous, TOKEN2VAL(tok), rb_str_new_cstr(syn))
14842 #endif
14843 #define warn_balanced(tok, op, syn) ((void) \
14844  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN) && \
14845  space_seen && !ISSPACE(c) && \
14846  (ambiguous_operator(tok, op, syn), 0)), \
14847  (enum yytokentype)(tok))
14848 
14849 static VALUE
14850 parse_rational(struct parser_params *p, char *str, int len, int seen_point)
14851 {
14852  VALUE v;
14853  char *point = &str[seen_point];
14854  size_t fraclen = len-seen_point-1;
14855  memmove(point, point+1, fraclen+1);
14856  v = rb_cstr_to_inum(str, 10, FALSE);
14857  return rb_rational_new(v, rb_int_positive_pow(10, fraclen));
14858 }
14859 
14860 static enum yytokentype
14861 no_digits(struct parser_params *p)
14862 {
14863  yyerror0("numeric literal without digits");
14864  if (peek(p, '_')) nextc(p);
14865  /* dummy 0, for tUMINUS_NUM at numeric */
14866  return set_integer_literal(p, INT2FIX(0), 0);
14867 }
14868 
14869 static enum yytokentype
14870 parse_numeric(struct parser_params *p, int c)
14871 {
14872  int is_float, seen_point, seen_e, nondigit;
14873  int suffix;
14874 
14875  is_float = seen_point = seen_e = nondigit = 0;
14876  SET_LEX_STATE(EXPR_END);
14877  newtok(p);
14878  if (c == '-' || c == '+') {
14879  tokadd(p, c);
14880  c = nextc(p);
14881  }
14882  if (c == '0') {
14883  int start = toklen(p);
14884  c = nextc(p);
14885  if (c == 'x' || c == 'X') {
14886  /* hexadecimal */
14887  c = nextc(p);
14888  if (c != -1 && ISXDIGIT(c)) {
14889  do {
14890  if (c == '_') {
14891  if (nondigit) break;
14892  nondigit = c;
14893  continue;
14894  }
14895  if (!ISXDIGIT(c)) break;
14896  nondigit = 0;
14897  tokadd(p, c);
14898  } while ((c = nextc(p)) != -1);
14899  }
14900  pushback(p, c);
14901  tokfix(p);
14902  if (toklen(p) == start) {
14903  return no_digits(p);
14904  }
14905  else if (nondigit) goto trailing_uc;
14906  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
14907  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 16, FALSE), suffix);
14908  }
14909  if (c == 'b' || c == 'B') {
14910  /* binary */
14911  c = nextc(p);
14912  if (c == '0' || c == '1') {
14913  do {
14914  if (c == '_') {
14915  if (nondigit) break;
14916  nondigit = c;
14917  continue;
14918  }
14919  if (c != '0' && c != '1') break;
14920  nondigit = 0;
14921  tokadd(p, c);
14922  } while ((c = nextc(p)) != -1);
14923  }
14924  pushback(p, c);
14925  tokfix(p);
14926  if (toklen(p) == start) {
14927  return no_digits(p);
14928  }
14929  else if (nondigit) goto trailing_uc;
14930  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
14931  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 2, FALSE), suffix);
14932  }
14933  if (c == 'd' || c == 'D') {
14934  /* decimal */
14935  c = nextc(p);
14936  if (c != -1 && ISDIGIT(c)) {
14937  do {
14938  if (c == '_') {
14939  if (nondigit) break;
14940  nondigit = c;
14941  continue;
14942  }
14943  if (!ISDIGIT(c)) break;
14944  nondigit = 0;
14945  tokadd(p, c);
14946  } while ((c = nextc(p)) != -1);
14947  }
14948  pushback(p, c);
14949  tokfix(p);
14950  if (toklen(p) == start) {
14951  return no_digits(p);
14952  }
14953  else if (nondigit) goto trailing_uc;
14954  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
14955  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 10, FALSE), suffix);
14956  }
14957  if (c == '_') {
14958  /* 0_0 */
14959  goto octal_number;
14960  }
14961  if (c == 'o' || c == 'O') {
14962  /* prefixed octal */
14963  c = nextc(p);
14964  if (c == -1 || c == '_' || !ISDIGIT(c)) {
14965  return no_digits(p);
14966  }
14967  }
14968  if (c >= '0' && c <= '7') {
14969  /* octal */
14970  octal_number:
14971  do {
14972  if (c == '_') {
14973  if (nondigit) break;
14974  nondigit = c;
14975  continue;
14976  }
14977  if (c < '0' || c > '9') break;
14978  if (c > '7') goto invalid_octal;
14979  nondigit = 0;
14980  tokadd(p, c);
14981  } while ((c = nextc(p)) != -1);
14982  if (toklen(p) > start) {
14983  pushback(p, c);
14984  tokfix(p);
14985  if (nondigit) goto trailing_uc;
14986  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
14987  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 8, FALSE), suffix);
14988  }
14989  if (nondigit) {
14990  pushback(p, c);
14991  goto trailing_uc;
14992  }
14993  }
14994  if (c > '7' && c <= '9') {
14995  invalid_octal:
14996  yyerror0("Invalid octal digit");
14997  }
14998  else if (c == '.' || c == 'e' || c == 'E') {
14999  tokadd(p, '0');
15000  }
15001  else {
15002  pushback(p, c);
15003  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
15004  return set_integer_literal(p, INT2FIX(0), suffix);
15005  }
15006  }
15007 
15008  for (;;) {
15009  switch (c) {
15010  case '0': case '1': case '2': case '3': case '4':
15011  case '5': case '6': case '7': case '8': case '9':
15012  nondigit = 0;
15013  tokadd(p, c);
15014  break;
15015 
15016  case '.':
15017  if (nondigit) goto trailing_uc;
15018  if (seen_point || seen_e) {
15019  goto decode_num;
15020  }
15021  else {
15022  int c0 = nextc(p);
15023  if (c0 == -1 || !ISDIGIT(c0)) {
15024  pushback(p, c0);
15025  goto decode_num;
15026  }
15027  c = c0;
15028  }
15029  seen_point = toklen(p);
15030  tokadd(p, '.');
15031  tokadd(p, c);
15032  is_float++;
15033  nondigit = 0;
15034  break;
15035 
15036  case 'e':
15037  case 'E':
15038  if (nondigit) {
15039  pushback(p, c);
15040  c = nondigit;
15041  goto decode_num;
15042  }
15043  if (seen_e) {
15044  goto decode_num;
15045  }
15046  nondigit = c;
15047  c = nextc(p);
15048  if (c != '-' && c != '+' && !ISDIGIT(c)) {
15049  pushback(p, c);
15050  nondigit = 0;
15051  goto decode_num;
15052  }
15053  tokadd(p, nondigit);
15054  seen_e++;
15055  is_float++;
15056  tokadd(p, c);
15057  nondigit = (c == '-' || c == '+') ? c : 0;
15058  break;
15059 
15060  case '_': /* `_' in number just ignored */
15061  if (nondigit) goto decode_num;
15062  nondigit = c;
15063  break;
15064 
15065  default:
15066  goto decode_num;
15067  }
15068  c = nextc(p);
15069  }
15070 
15071  decode_num:
15072  pushback(p, c);
15073  if (nondigit) {
15074  trailing_uc:
15075  literal_flush(p, p->lex.pcur - 1);
15076  YYLTYPE loc = RUBY_INIT_YYLLOC();
15077  compile_error(p, "trailing `%c' in number", nondigit);
15078  parser_show_error_line(p, &loc);
15079  }
15080  tokfix(p);
15081  if (is_float) {
15082  enum yytokentype type = tFLOAT;
15083  VALUE v;
15084 
15085  suffix = number_literal_suffix(p, seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
15086  if (suffix & NUM_SUFFIX_R) {
15087  type = tRATIONAL;
15088  v = parse_rational(p, tok(p), toklen(p), seen_point);
15089  }
15090  else {
15091  double d = strtod(tok(p), 0);
15092  if (errno == ERANGE) {
15093  rb_warning1("Float %s out of range", WARN_S(tok(p)));
15094  errno = 0;
15095  }
15096  v = DBL2NUM(d);
15097  }
15098  return set_number_literal(p, v, type, suffix);
15099  }
15100  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
15101  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 10, FALSE), suffix);
15102 }
15103 
15104 static enum yytokentype
15105 parse_qmark(struct parser_params *p, int space_seen)
15106 {
15107  rb_encoding *enc;
15108  register int c;
15109  VALUE lit;
15110 
15111  if (IS_END()) {
15113  return '?';
15114  }
15115  c = nextc(p);
15116  if (c == -1) {
15117  compile_error(p, "incomplete character syntax");
15118  return 0;
15119  }
15120  if (rb_enc_isspace(c, p->enc)) {
15121  if (!IS_ARG()) {
15122  int c2 = escaped_control_code(c);
15123  if (c2) {
15124  WARN_SPACE_CHAR(c2, "?");
15125  }
15126  }
15127  ternary:
15128  pushback(p, c);
15130  return '?';
15131  }
15132  newtok(p);
15133  enc = p->enc;
15134  if (!parser_isascii(p)) {
15135  if (tokadd_mbchar(p, c) == -1) return 0;
15136  }
15137  else if ((rb_enc_isalnum(c, p->enc) || c == '_') &&
15138  p->lex.pcur < p->lex.pend && is_identchar(p->lex.pcur, p->lex.pend, p->enc)) {
15139  if (space_seen) {
15140  const char *start = p->lex.pcur - 1, *ptr = start;
15141  do {
15142  int n = parser_precise_mbclen(p, ptr);
15143  if (n < 0) return -1;
15144  ptr += n;
15145  } while (ptr < p->lex.pend && is_identchar(ptr, p->lex.pend, p->enc));
15146  rb_warn2("`?' just followed by `%.*s' is interpreted as" \
15147  " a conditional operator, put a space after `?'",
15148  WARN_I((int)(ptr - start)), WARN_S_L(start, (ptr - start)));
15149  }
15150  goto ternary;
15151  }
15152  else if (c == '\\') {
15153  if (peek(p, 'u')) {
15154  nextc(p);
15155  enc = rb_utf8_encoding();
15156  tokadd_utf8(p, &enc, -1, 0, 0);
15157  }
15158  else if (!lex_eol_p(p) && !(c = *p->lex.pcur, ISASCII(c))) {
15159  nextc(p);
15160  if (tokadd_mbchar(p, c) == -1) return 0;
15161  }
15162  else {
15163  c = read_escape(p, 0, &enc);
15164  tokadd(p, c);
15165  }
15166  }
15167  else {
15168  tokadd(p, c);
15169  }
15170  tokfix(p);
15171  lit = STR_NEW3(tok(p), toklen(p), enc, 0);
15172  set_yylval_str(lit);
15173  SET_LEX_STATE(EXPR_END);
15174  return tCHAR;
15175 }
15176 
15177 static enum yytokentype
15178 parse_percent(struct parser_params *p, const int space_seen, const enum lex_state_e last_state)
15179 {
15180  register int c;
15181  const char *ptok = p->lex.pcur;
15182 
15183  if (IS_BEG()) {
15184  int term;
15185  int paren;
15186 
15187  c = nextc(p);
15188  quotation:
15189  if (c == -1 || !ISALNUM(c)) {
15190  term = c;
15191  c = 'Q';
15192  }
15193  else {
15194  term = nextc(p);
15195  if (rb_enc_isalnum(term, p->enc) || !parser_isascii(p)) {
15196  yyerror0("unknown type of %string");
15197  return 0;
15198  }
15199  }
15200  if (c == -1 || term == -1) {
15201  compile_error(p, "unterminated quoted string meets end of file");
15202  return 0;
15203  }
15204  paren = term;
15205  if (term == '(') term = ')';
15206  else if (term == '[') term = ']';
15207  else if (term == '{') term = '}';
15208  else if (term == '<') term = '>';
15209  else paren = 0;
15210 
15211  p->lex.ptok = ptok-1;
15212  switch (c) {
15213  case 'Q':
15214  p->lex.strterm = NEW_STRTERM(str_dquote, term, paren);
15215  return tSTRING_BEG;
15216 
15217  case 'q':
15218  p->lex.strterm = NEW_STRTERM(str_squote, term, paren);
15219  return tSTRING_BEG;
15220 
15221  case 'W':
15222  p->lex.strterm = NEW_STRTERM(str_dword, term, paren);
15223  return tWORDS_BEG;
15224 
15225  case 'w':
15226  p->lex.strterm = NEW_STRTERM(str_sword, term, paren);
15227  return tQWORDS_BEG;
15228 
15229  case 'I':
15230  p->lex.strterm = NEW_STRTERM(str_dword, term, paren);
15231  return tSYMBOLS_BEG;
15232 
15233  case 'i':
15234  p->lex.strterm = NEW_STRTERM(str_sword, term, paren);
15235  return tQSYMBOLS_BEG;
15236 
15237  case 'x':
15238  p->lex.strterm = NEW_STRTERM(str_xquote, term, paren);
15239  return tXSTRING_BEG;
15240 
15241  case 'r':
15242  p->lex.strterm = NEW_STRTERM(str_regexp, term, paren);
15243  return tREGEXP_BEG;
15244 
15245  case 's':
15246  p->lex.strterm = NEW_STRTERM(str_ssym, term, paren);
15247  SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);
15248  return tSYMBEG;
15249 
15250  default:
15251  yyerror0("unknown type of %string");
15252  return 0;
15253  }
15254  }
15255  if ((c = nextc(p)) == '=') {
15256  set_yylval_id('%');
15257  SET_LEX_STATE(EXPR_BEG);
15258  return tOP_ASGN;
15259  }
15260  if (IS_SPCARG(c) || (IS_lex_state(EXPR_FITEM) && c == 's')) {
15261  goto quotation;
15262  }
15263  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15264  pushback(p, c);
15265  return warn_balanced('%', "%%", "string literal");
15266 }
15267 
15268 static int
15269 tokadd_ident(struct parser_params *p, int c)
15270 {
15271  do {
15272  if (tokadd_mbchar(p, c) == -1) return -1;
15273  c = nextc(p);
15274  } while (parser_is_identchar(p));
15275  pushback(p, c);
15276  return 0;
15277 }
15278 
15279 static ID
15280 tokenize_ident(struct parser_params *p, const enum lex_state_e last_state)
15281 {
15282  ID ident = TOK_INTERN();
15283 
15284  set_yylval_name(ident);
15285 
15286  return ident;
15287 }
15288 
15289 static int
15290 parse_numvar(struct parser_params *p)
15291 {
15292  size_t len;
15293  int overflow;
15294  unsigned long n = ruby_scan_digits(tok(p)+1, toklen(p)-1, 10, &len, &overflow);
15295  const unsigned long nth_ref_max =
15296  ((FIXNUM_MAX < INT_MAX) ? FIXNUM_MAX : INT_MAX) >> 1;
15297  /* NTH_REF is left-shifted to be ORed with back-ref flag and
15298  * turned into a Fixnum, in compile.c */
15299 
15300  if (overflow || n > nth_ref_max) {
15301  /* compile_error()? */
15302  rb_warn1("`%s' is too big for a number variable, always nil", WARN_S(tok(p)));
15303  return 0; /* $0 is $PROGRAM_NAME, not NTH_REF */
15304  }
15305  else {
15306  return (int)n;
15307  }
15308 }
15309 
15310 static enum yytokentype
15311 parse_gvar(struct parser_params *p, const enum lex_state_e last_state)
15312 {
15313  const char *ptr = p->lex.pcur;
15314  register int c;
15315 
15316  SET_LEX_STATE(EXPR_END);
15317  p->lex.ptok = ptr - 1; /* from '$' */
15318  newtok(p);
15319  c = nextc(p);
15320  switch (c) {
15321  case '_': /* $_: last read line string */
15322  c = nextc(p);
15323  if (parser_is_identchar(p)) {
15324  tokadd(p, '$');
15325  tokadd(p, '_');
15326  break;
15327  }
15328  pushback(p, c);
15329  c = '_';
15330  /* fall through */
15331  case '~': /* $~: match-data */
15332  case '*': /* $*: argv */
15333  case '$': /* $$: pid */
15334  case '?': /* $?: last status */
15335  case '!': /* $!: error string */
15336  case '@': /* $@: error position */
15337  case '/': /* $/: input record separator */
15338  case '\\': /* $\: output record separator */
15339  case ';': /* $;: field separator */
15340  case ',': /* $,: output field separator */
15341  case '.': /* $.: last read line number */
15342  case '=': /* $=: ignorecase */
15343  case ':': /* $:: load path */
15344  case '<': /* $<: reading filename */
15345  case '>': /* $>: default output handle */
15346  case '\"': /* $": already loaded files */
15347  tokadd(p, '$');
15348  tokadd(p, c);
15349  goto gvar;
15350 
15351  case '-':
15352  tokadd(p, '$');
15353  tokadd(p, c);
15354  c = nextc(p);
15355  if (parser_is_identchar(p)) {
15356  if (tokadd_mbchar(p, c) == -1) return 0;
15357  }
15358  else {
15359  pushback(p, c);
15360  pushback(p, '-');
15361  return '$';
15362  }
15363  gvar:
15365  return tGVAR;
15366 
15367  case '&': /* $&: last match */
15368  case '`': /* $`: string before last match */
15369  case '\'': /* $': string after last match */
15370  case '+': /* $+: string matches last paren. */
15371  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
15372  tokadd(p, '$');
15373  tokadd(p, c);
15374  goto gvar;
15375  }
15376  set_yylval_node(NEW_BACK_REF(c, &_cur_loc));
15377  return tBACK_REF;
15378 
15379  case '1': case '2': case '3':
15380  case '4': case '5': case '6':
15381  case '7': case '8': case '9':
15382  tokadd(p, '$');
15383  do {
15384  tokadd(p, c);
15385  c = nextc(p);
15386  } while (c != -1 && ISDIGIT(c));
15387  pushback(p, c);
15388  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
15389  tokfix(p);
15390  set_yylval_node(NEW_NTH_REF(parse_numvar(p), &_cur_loc));
15391  return tNTH_REF;
15392 
15393  default:
15394  if (!parser_is_identchar(p)) {
15395  YYLTYPE loc = RUBY_INIT_YYLLOC();
15396  if (c == -1 || ISSPACE(c)) {
15397  compile_error(p, "`$' without identifiers is not allowed as a global variable name");
15398  }
15399  else {
15400  pushback(p, c);
15401  compile_error(p, "`$%c' is not allowed as a global variable name", c);
15402  }
15403  parser_show_error_line(p, &loc);
15405  return tGVAR;
15406  }
15407  /* fall through */
15408  case '0':
15409  tokadd(p, '$');
15410  }
15411 
15412  if (tokadd_ident(p, c)) return 0;
15413  SET_LEX_STATE(EXPR_END);
15414  tokenize_ident(p, last_state);
15415  return tGVAR;
15416 }
15417 
15418 #ifndef RIPPER
15419 static bool
15420 parser_numbered_param(struct parser_params *p, int n)
15421 {
15422  if (n < 0) return false;
15423 
15425  return false;
15426  }
15427  if (p->max_numparam == ORDINAL_PARAM) {
15428  compile_error(p, "ordinary parameter is defined");
15429  return false;
15430  }
15431  struct vtable *args = p->lvtbl->args;
15432  if (p->max_numparam < n) {
15433  p->max_numparam = n;
15434  }
15435  while (n > args->pos) {
15436  vtable_add(args, NUMPARAM_IDX_TO_ID(args->pos+1));
15437  }
15438  return true;
15439 }
15440 #endif
15441 
15442 static enum yytokentype
15443 parse_atmark(struct parser_params *p, const enum lex_state_e last_state)
15444 {
15445  const char *ptr = p->lex.pcur;
15446  enum yytokentype result = tIVAR;
15447  register int c = nextc(p);
15448  YYLTYPE loc;
15449 
15450  p->lex.ptok = ptr - 1; /* from '@' */
15451  newtok(p);
15452  tokadd(p, '@');
15453  if (c == '@') {
15454  result = tCVAR;
15455  tokadd(p, '@');
15456  c = nextc(p);
15457  }
15458  SET_LEX_STATE(IS_lex_state_for(last_state, EXPR_FNAME) ? EXPR_ENDFN : EXPR_END);
15459  if (c == -1 || !parser_is_identchar(p)) {
15460  pushback(p, c);
15461  RUBY_SET_YYLLOC(loc);
15462  if (result == tIVAR) {
15463  compile_error(p, "`@' without identifiers is not allowed as an instance variable name");
15464  }
15465  else {
15466  compile_error(p, "`@@' without identifiers is not allowed as a class variable name");
15467  }
15468  parser_show_error_line(p, &loc);
15470  SET_LEX_STATE(EXPR_END);
15471  return result;
15472  }
15473  else if (ISDIGIT(c)) {
15474  pushback(p, c);
15475  RUBY_SET_YYLLOC(loc);
15476  if (result == tIVAR) {
15477  compile_error(p, "`@%c' is not allowed as an instance variable name", c);
15478  }
15479  else {
15480  compile_error(p, "`@@%c' is not allowed as a class variable name", c);
15481  }
15482  parser_show_error_line(p, &loc);
15484  SET_LEX_STATE(EXPR_END);
15485  return result;
15486  }
15487 
15488  if (tokadd_ident(p, c)) return 0;
15489  tokenize_ident(p, last_state);
15490  return result;
15491 }
15492 
15493 static enum yytokentype
15494 parse_ident(struct parser_params *p, int c, int cmd_state)
15495 {
15496  enum yytokentype result;
15497  int mb = ENC_CODERANGE_7BIT;
15498  const enum lex_state_e last_state = p->lex.state;
15499  ID ident;
15500 
15501  do {
15502  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
15503  if (tokadd_mbchar(p, c) == -1) return 0;
15504  c = nextc(p);
15505  } while (parser_is_identchar(p));
15506  if ((c == '!' || c == '?') && !peek(p, '=')) {
15507  result = tFID;
15508  tokadd(p, c);
15509  }
15510  else if (c == '=' && IS_lex_state(EXPR_FNAME) &&
15511  (!peek(p, '~') && !peek(p, '>') && (!peek(p, '=') || (peek_n(p, '>', 1))))) {
15512  result = tIDENTIFIER;
15513  tokadd(p, c);
15514  }
15515  else {
15516  result = tCONSTANT; /* assume provisionally */
15517  pushback(p, c);
15518  }
15519  tokfix(p);
15520 
15521  if (IS_LABEL_POSSIBLE()) {
15522  if (IS_LABEL_SUFFIX(0)) {
15523  SET_LEX_STATE(EXPR_ARG|EXPR_LABELED);
15524  nextc(p);
15526  return tLABEL;
15527  }
15528  }
15529  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
15530  const struct kwtable *kw;
15531 
15532  /* See if it is a reserved word. */
15533  kw = rb_reserved_word(tok(p), toklen(p));
15534  if (kw) {
15535  enum lex_state_e state = p->lex.state;
15536  SET_LEX_STATE(kw->state);
15537  if (IS_lex_state_for(state, EXPR_FNAME)) {
15539  return kw->id[0];
15540  }
15541  if (IS_lex_state(EXPR_BEG)) {
15542  p->command_start = TRUE;
15543  }
15544  if (kw->id[0] == keyword_do) {
15545  if (lambda_beginning_p()) {
15546  p->lex.lpar_beg = -1; /* make lambda_beginning_p() == FALSE in the body of "-> do ... end" */
15547  return keyword_do_LAMBDA;
15548  }
15549  if (COND_P()) return keyword_do_cond;
15550  if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG))
15551  return keyword_do_block;
15552  return keyword_do;
15553  }
15554  if (IS_lex_state_for(state, (EXPR_BEG | EXPR_LABELED)))
15555  return kw->id[0];
15556  else {
15557  if (kw->id[0] != kw->id[1])
15558  SET_LEX_STATE(EXPR_BEG | EXPR_LABEL);
15559  return kw->id[1];
15560  }
15561  }
15562  }
15563 
15564  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
15565  if (cmd_state) {
15566  SET_LEX_STATE(EXPR_CMDARG);
15567  }
15568  else {
15569  SET_LEX_STATE(EXPR_ARG);
15570  }
15571  }
15572  else if (p->lex.state == EXPR_FNAME) {
15573  SET_LEX_STATE(EXPR_ENDFN);
15574  }
15575  else {
15576  SET_LEX_STATE(EXPR_END);
15577  }
15578 
15579  ident = tokenize_ident(p, last_state);
15580  if (result == tCONSTANT && is_local_id(ident)) result = tIDENTIFIER;
15581  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
15582  (result == tIDENTIFIER) && /* not EXPR_FNAME, not attrasgn */
15583  lvar_defined(p, ident)) {
15584  SET_LEX_STATE(EXPR_END|EXPR_LABEL);
15585  }
15586  return result;
15587 }
15588 
15589 static enum yytokentype
15590 parser_yylex(struct parser_params *p)
15591 {
15592  register int c;
15593  int space_seen = 0;
15594  int cmd_state;
15595  int label;
15596  enum lex_state_e last_state;
15597  int fallthru = FALSE;
15598  int token_seen = p->token_seen;
15599 
15600  if (p->lex.strterm) {
15601  if (p->lex.strterm->flags & STRTERM_HEREDOC) {
15602  return here_document(p, &p->lex.strterm->u.heredoc);
15603  }
15604  else {
15605  token_flush(p);
15606  return parse_string(p, &p->lex.strterm->u.literal);
15607  }
15608  }
15609  cmd_state = p->command_start;
15610  p->command_start = FALSE;
15611  p->token_seen = TRUE;
15612  retry:
15613  last_state = p->lex.state;
15614 #ifndef RIPPER
15615  token_flush(p);
15616 #endif
15617  switch (c = nextc(p)) {
15618  case '\0': /* NUL */
15619  case '\004': /* ^D */
15620  case '\032': /* ^Z */
15621  case -1: /* end of script. */
15622  return 0;
15623 
15624  /* white spaces */
15625  case ' ': case '\t': case '\f': case '\r':
15626  case '\13': /* '\v' */
15627  space_seen = 1;
15628 #ifdef RIPPER
15629  while ((c = nextc(p))) {
15630  switch (c) {
15631  case ' ': case '\t': case '\f': case '\r':
15632  case '\13': /* '\v' */
15633  break;
15634  default:
15635  goto outofloop;
15636  }
15637  }
15638  outofloop:
15639  pushback(p, c);
15641 #endif
15642  goto retry;
15643 
15644  case '#': /* it's a comment */
15645  p->token_seen = token_seen;
15646  /* no magic_comment in shebang line */
15647  if (!parser_magic_comment(p, p->lex.pcur, p->lex.pend - p->lex.pcur)) {
15648  if (comment_at_top(p)) {
15649  set_file_encoding(p, p->lex.pcur, p->lex.pend);
15650  }
15651  }
15652  lex_goto_eol(p);
15654  fallthru = TRUE;
15655  /* fall through */
15656  case '\n':
15657  p->token_seen = token_seen;
15658  c = (IS_lex_state(EXPR_BEG|EXPR_CLASS|EXPR_FNAME|EXPR_DOT) &&
15659  !IS_lex_state(EXPR_LABELED));
15660  if (c || IS_lex_state_all(EXPR_ARG|EXPR_LABELED)) {
15661  if (!fallthru) {
15663  }
15664  fallthru = FALSE;
15665  if (!c && p->in_kwarg) {
15666  goto normal_newline;
15667  }
15668  goto retry;
15669  }
15670  while (1) {
15671  switch (c = nextc(p)) {
15672  case ' ': case '\t': case '\f': case '\r':
15673  case '\13': /* '\v' */
15674  space_seen = 1;
15675  break;
15676  case '#':
15677  pushback(p, c);
15678  if (space_seen) dispatch_scan_event(p, tSP);
15679  goto retry;
15680  case '&':
15681  case '.': {
15683  if (peek(p, '.') == (c == '&')) {
15684  pushback(p, c);
15686  goto retry;
15687  }
15688  }
15689  default:
15690  p->ruby_sourceline--;
15691  p->lex.nextline = p->lex.lastline;
15692  case -1: /* EOF no decrement*/
15693 #ifndef RIPPER
15694  if (p->lex.prevline && !p->eofp) p->lex.lastline = p->lex.prevline;
15695  p->lex.pbeg = RSTRING_PTR(p->lex.lastline);
15696  p->lex.pend = p->lex.pcur = p->lex.pbeg + RSTRING_LEN(p->lex.lastline);
15697  pushback(p, 1); /* always pushback */
15698  p->lex.ptok = p->lex.pcur;
15699 #else
15700  lex_goto_eol(p);
15701  if (c != -1) {
15702  p->lex.ptok = p->lex.pcur;
15703  }
15704 #endif
15705  goto normal_newline;
15706  }
15707  }
15708  normal_newline:
15709  p->command_start = TRUE;
15710  SET_LEX_STATE(EXPR_BEG);
15711  return '\n';
15712 
15713  case '*':
15714  if ((c = nextc(p)) == '*') {
15715  if ((c = nextc(p)) == '=') {
15717  SET_LEX_STATE(EXPR_BEG);
15718  return tOP_ASGN;
15719  }
15720  pushback(p, c);
15721  if (IS_SPCARG(c)) {
15722  rb_warning0("`**' interpreted as argument prefix");
15723  c = tDSTAR;
15724  }
15725  else if (IS_BEG()) {
15726  c = tDSTAR;
15727  }
15728  else {
15729  c = warn_balanced((enum ruby_method_ids)tPOW, "**", "argument prefix");
15730  }
15731  }
15732  else {
15733  if (c == '=') {
15734  set_yylval_id('*');
15735  SET_LEX_STATE(EXPR_BEG);
15736  return tOP_ASGN;
15737  }
15738  pushback(p, c);
15739  if (IS_SPCARG(c)) {
15740  rb_warning0("`*' interpreted as argument prefix");
15741  c = tSTAR;
15742  }
15743  else if (IS_BEG()) {
15744  c = tSTAR;
15745  }
15746  else {
15747  c = warn_balanced('*', "*", "argument prefix");
15748  }
15749  }
15750  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15751  return c;
15752 
15753  case '!':
15754  c = nextc(p);
15755  if (IS_AFTER_OPERATOR()) {
15756  SET_LEX_STATE(EXPR_ARG);
15757  if (c == '@') {
15758  return '!';
15759  }
15760  }
15761  else {
15762  SET_LEX_STATE(EXPR_BEG);
15763  }
15764  if (c == '=') {
15765  return tNEQ;
15766  }
15767  if (c == '~') {
15768  return tNMATCH;
15769  }
15770  pushback(p, c);
15771  return '!';
15772 
15773  case '=':
15774  if (was_bol(p)) {
15775  /* skip embedded rd document */
15776  if (word_match_p(p, "begin", 5)) {
15777  int first_p = TRUE;
15778 
15779  lex_goto_eol(p);
15781  for (;;) {
15782  lex_goto_eol(p);
15783  if (!first_p) {
15785  }
15786  first_p = FALSE;
15787  c = nextc(p);
15788  if (c == -1) {
15789  compile_error(p, "embedded document meets end of file");
15790  return 0;
15791  }
15792  if (c == '=' && word_match_p(p, "end", 3)) {
15793  break;
15794  }
15795  pushback(p, c);
15796  }
15797  lex_goto_eol(p);
15799  goto retry;
15800  }
15801  }
15802 
15803  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15804  if ((c = nextc(p)) == '=') {
15805  if ((c = nextc(p)) == '=') {
15806  return tEQQ;
15807  }
15808  pushback(p, c);
15809  return tEQ;
15810  }
15811  if (c == '~') {
15812  return tMATCH;
15813  }
15814  else if (c == '>') {
15815  return tASSOC;
15816  }
15817  pushback(p, c);
15818  return '=';
15819 
15820  case '<':
15821  c = nextc(p);
15822  if (c == '<' &&
15823  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
15824  !IS_END() &&
15825  (!IS_ARG() || IS_lex_state(EXPR_LABELED) || space_seen)) {
15826  int token = heredoc_identifier(p);
15827  if (token) return token < 0 ? 0 : token;
15828  }
15829  if (IS_AFTER_OPERATOR()) {
15830  SET_LEX_STATE(EXPR_ARG);
15831  }
15832  else {
15833  if (IS_lex_state(EXPR_CLASS))
15834  p->command_start = TRUE;
15835  SET_LEX_STATE(EXPR_BEG);
15836  }
15837  if (c == '=') {
15838  if ((c = nextc(p)) == '>') {
15839  return tCMP;
15840  }
15841  pushback(p, c);
15842  return tLEQ;
15843  }
15844  if (c == '<') {
15845  if ((c = nextc(p)) == '=') {
15847  SET_LEX_STATE(EXPR_BEG);
15848  return tOP_ASGN;
15849  }
15850  pushback(p, c);
15851  return warn_balanced((enum ruby_method_ids)tLSHFT, "<<", "here document");
15852  }
15853  pushback(p, c);
15854  return '<';
15855 
15856  case '>':
15857  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15858  if ((c = nextc(p)) == '=') {
15859  return tGEQ;
15860  }
15861  if (c == '>') {
15862  if ((c = nextc(p)) == '=') {
15864  SET_LEX_STATE(EXPR_BEG);
15865  return tOP_ASGN;
15866  }
15867  pushback(p, c);
15868  return tRSHFT;
15869  }
15870  pushback(p, c);
15871  return '>';
15872 
15873  case '"':
15874  label = (IS_LABEL_POSSIBLE() ? str_label : 0);
15875  p->lex.strterm = NEW_STRTERM(str_dquote | label, '"', 0);
15876  p->lex.ptok = p->lex.pcur-1;
15877  return tSTRING_BEG;
15878 
15879  case '`':
15880  if (IS_lex_state(EXPR_FNAME)) {
15881  SET_LEX_STATE(EXPR_ENDFN);
15882  return c;
15883  }
15884  if (IS_lex_state(EXPR_DOT)) {
15885  if (cmd_state)
15886  SET_LEX_STATE(EXPR_CMDARG);
15887  else
15888  SET_LEX_STATE(EXPR_ARG);
15889  return c;
15890  }
15891  p->lex.strterm = NEW_STRTERM(str_xquote, '`', 0);
15892  return tXSTRING_BEG;
15893 
15894  case '\'':
15895  label = (IS_LABEL_POSSIBLE() ? str_label : 0);
15896  p->lex.strterm = NEW_STRTERM(str_squote | label, '\'', 0);
15897  p->lex.ptok = p->lex.pcur-1;
15898  return tSTRING_BEG;
15899 
15900  case '?':
15901  return parse_qmark(p, space_seen);
15902 
15903  case '&':
15904  if ((c = nextc(p)) == '&') {
15905  SET_LEX_STATE(EXPR_BEG);
15906  if ((c = nextc(p)) == '=') {
15908  SET_LEX_STATE(EXPR_BEG);
15909  return tOP_ASGN;
15910  }
15911  pushback(p, c);
15912  return tANDOP;
15913  }
15914  else if (c == '=') {
15915  set_yylval_id('&');
15916  SET_LEX_STATE(EXPR_BEG);
15917  return tOP_ASGN;
15918  }
15919  else if (c == '.') {
15921  SET_LEX_STATE(EXPR_DOT);
15922  return tANDDOT;
15923  }
15924  pushback(p, c);
15925  if (IS_SPCARG(c)) {
15926  if ((c != ':') ||
15927  (c = peekc_n(p, 1)) == -1 ||
15928  !(c == '\'' || c == '"' ||
15929  is_identchar((p->lex.pcur+1), p->lex.pend, p->enc))) {
15930  rb_warning0("`&' interpreted as argument prefix");
15931  }
15932  c = tAMPER;
15933  }
15934  else if (IS_BEG()) {
15935  c = tAMPER;
15936  }
15937  else {
15938  c = warn_balanced('&', "&", "argument prefix");
15939  }
15940  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15941  return c;
15942 
15943  case '|':
15944  if ((c = nextc(p)) == '|') {
15945  SET_LEX_STATE(EXPR_BEG);
15946  if ((c = nextc(p)) == '=') {
15948  SET_LEX_STATE(EXPR_BEG);
15949  return tOP_ASGN;
15950  }
15951  pushback(p, c);
15952  if (IS_lex_state_for(last_state, EXPR_BEG)) {
15953  c = '|';
15954  pushback(p, '|');
15955  return c;
15956  }
15957  return tOROP;
15958  }
15959  if (c == '=') {
15960  set_yylval_id('|');
15961  SET_LEX_STATE(EXPR_BEG);
15962  return tOP_ASGN;
15963  }
15964  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG|EXPR_LABEL);
15965  pushback(p, c);
15966  return '|';
15967 
15968  case '+':
15969  c = nextc(p);
15970  if (IS_AFTER_OPERATOR()) {
15971  SET_LEX_STATE(EXPR_ARG);
15972  if (c == '@') {
15973  return tUPLUS;
15974  }
15975  pushback(p, c);
15976  return '+';
15977  }
15978  if (c == '=') {
15979  set_yylval_id('+');
15980  SET_LEX_STATE(EXPR_BEG);
15981  return tOP_ASGN;
15982  }
15983  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p, '+'))) {
15984  SET_LEX_STATE(EXPR_BEG);
15985  pushback(p, c);
15986  if (c != -1 && ISDIGIT(c)) {
15987  return parse_numeric(p, '+');
15988  }
15989  return tUPLUS;
15990  }
15991  SET_LEX_STATE(EXPR_BEG);
15992  pushback(p, c);
15993  return warn_balanced('+', "+", "unary operator");
15994 
15995  case '-':
15996  c = nextc(p);
15997  if (IS_AFTER_OPERATOR()) {
15998  SET_LEX_STATE(EXPR_ARG);
15999  if (c == '@') {
16000  return tUMINUS;
16001  }
16002  pushback(p, c);
16003  return '-';
16004  }
16005  if (c == '=') {
16006  set_yylval_id('-');
16007  SET_LEX_STATE(EXPR_BEG);
16008  return tOP_ASGN;
16009  }
16010  if (c == '>') {
16011  SET_LEX_STATE(EXPR_ENDFN);
16012  return tLAMBDA;
16013  }
16014  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p, '-'))) {
16015  SET_LEX_STATE(EXPR_BEG);
16016  pushback(p, c);
16017  if (c != -1 && ISDIGIT(c)) {
16018  return tUMINUS_NUM;
16019  }
16020  return tUMINUS;
16021  }
16022  SET_LEX_STATE(EXPR_BEG);
16023  pushback(p, c);
16024  return warn_balanced('-', "-", "unary operator");
16025 
16026  case '.': {
16027  int is_beg = IS_BEG();
16028  SET_LEX_STATE(EXPR_BEG);
16029  if ((c = nextc(p)) == '.') {
16030  if ((c = nextc(p)) == '.') {
16031  if (p->lex.paren_nest == 0 && looking_at_eol_p(p)) {
16032  rb_warn0("... at EOL, should be parenthesized?");
16033  }
16034  return is_beg ? tBDOT3 : tDOT3;
16035  }
16036  pushback(p, c);
16037  return is_beg ? tBDOT2 : tDOT2;
16038  }
16039  pushback(p, c);
16040  if (c != -1 && ISDIGIT(c)) {
16041  char prev = p->lex.pcur-1 > p->lex.pbeg ? *(p->lex.pcur-2) : 0;
16042  parse_numeric(p, '.');
16043  if (ISDIGIT(prev)) {
16044  yyerror0("unexpected fraction part after numeric literal");
16045  }
16046  else {
16047  yyerror0("no .<digit> floating literal anymore; put 0 before dot");
16048  }
16049  SET_LEX_STATE(EXPR_END);
16050  p->lex.ptok = p->lex.pcur;
16051  goto retry;
16052  }
16053  set_yylval_id('.');
16054  SET_LEX_STATE(EXPR_DOT);
16055  return '.';
16056  }
16057 
16058  case '0': case '1': case '2': case '3': case '4':
16059  case '5': case '6': case '7': case '8': case '9':
16060  return parse_numeric(p, c);
16061 
16062  case ')':
16063  COND_POP();
16064  CMDARG_POP();
16065  SET_LEX_STATE(EXPR_ENDFN);
16066  p->lex.paren_nest--;
16067  return c;
16068 
16069  case ']':
16070  COND_POP();
16071  CMDARG_POP();
16072  SET_LEX_STATE(EXPR_END);
16073  p->lex.paren_nest--;
16074  return c;
16075 
16076  case '}':
16077  /* tSTRING_DEND does COND_POP and CMDARG_POP in the yacc's rule */
16078  if (!p->lex.brace_nest--) return tSTRING_DEND;
16079  COND_POP();
16080  CMDARG_POP();
16081  SET_LEX_STATE(EXPR_END);
16082  p->lex.paren_nest--;
16083  return c;
16084 
16085  case ':':
16086  c = nextc(p);
16087  if (c == ':') {
16088  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
16089  SET_LEX_STATE(EXPR_BEG);
16090  return tCOLON3;
16091  }
16093  SET_LEX_STATE(EXPR_DOT);
16094  return tCOLON2;
16095  }
16096  if (IS_END() || ISSPACE(c) || c == '#') {
16097  pushback(p, c);
16098  c = warn_balanced(':', ":", "symbol literal");
16099  SET_LEX_STATE(EXPR_BEG);
16100  return c;
16101  }
16102  switch (c) {
16103  case '\'':
16104  p->lex.strterm = NEW_STRTERM(str_ssym, c, 0);
16105  break;
16106  case '"':
16107  p->lex.strterm = NEW_STRTERM(str_dsym, c, 0);
16108  break;
16109  default:
16110  pushback(p, c);
16111  break;
16112  }
16113  SET_LEX_STATE(EXPR_FNAME);
16114  return tSYMBEG;
16115 
16116  case '/':
16117  if (IS_BEG()) {
16118  p->lex.strterm = NEW_STRTERM(str_regexp, '/', 0);
16119  return tREGEXP_BEG;
16120  }
16121  if ((c = nextc(p)) == '=') {
16122  set_yylval_id('/');
16123  SET_LEX_STATE(EXPR_BEG);
16124  return tOP_ASGN;
16125  }
16126  pushback(p, c);
16127  if (IS_SPCARG(c)) {
16128  arg_ambiguous(p, '/');
16129  p->lex.strterm = NEW_STRTERM(str_regexp, '/', 0);
16130  return tREGEXP_BEG;
16131  }
16132  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
16133  return warn_balanced('/', "/", "regexp literal");
16134 
16135  case '^':
16136  if ((c = nextc(p)) == '=') {
16137  set_yylval_id('^');
16138  SET_LEX_STATE(EXPR_BEG);
16139  return tOP_ASGN;
16140  }
16141  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
16142  pushback(p, c);
16143  return '^';
16144 
16145  case ';':
16146  SET_LEX_STATE(EXPR_BEG);
16147  p->command_start = TRUE;
16148  return ';';
16149 
16150  case ',':
16151  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
16152  return ',';
16153 
16154  case '~':
16155  if (IS_AFTER_OPERATOR()) {
16156  if ((c = nextc(p)) != '@') {
16157  pushback(p, c);
16158  }
16159  SET_LEX_STATE(EXPR_ARG);
16160  }
16161  else {
16162  SET_LEX_STATE(EXPR_BEG);
16163  }
16164  return '~';
16165 
16166  case '(':
16167  if (IS_BEG()) {
16168  c = tLPAREN;
16169  }
16170  else if (!space_seen) {
16171  /* foo( ... ) => method call, no ambiguity */
16172  }
16173  else if (IS_ARG() || IS_lex_state_all(EXPR_END|EXPR_LABEL)) {
16174  c = tLPAREN_ARG;
16175  }
16176  else if (IS_lex_state(EXPR_ENDFN) && !lambda_beginning_p()) {
16177  rb_warning0("parentheses after method name is interpreted as "
16178  "an argument list, not a decomposed argument");
16179  }
16180  p->lex.paren_nest++;
16181  COND_PUSH(0);
16182  CMDARG_PUSH(0);
16183  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
16184  return c;
16185 
16186  case '[':
16187  p->lex.paren_nest++;
16188  if (IS_AFTER_OPERATOR()) {
16189  if ((c = nextc(p)) == ']') {
16190  SET_LEX_STATE(EXPR_ARG);
16191  if ((c = nextc(p)) == '=') {
16192  return tASET;
16193  }
16194  pushback(p, c);
16195  return tAREF;
16196  }
16197  pushback(p, c);
16198  SET_LEX_STATE(EXPR_ARG|EXPR_LABEL);
16199  return '[';
16200  }
16201  else if (IS_BEG()) {
16202  c = tLBRACK;
16203  }
16204  else if (IS_ARG() && (space_seen || IS_lex_state(EXPR_LABELED))) {
16205  c = tLBRACK;
16206  }
16207  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
16208  COND_PUSH(0);
16209  CMDARG_PUSH(0);
16210  return c;
16211 
16212  case '{':
16213  ++p->lex.brace_nest;
16214  if (lambda_beginning_p())
16215  c = tLAMBEG;
16216  else if (IS_lex_state(EXPR_LABELED))
16217  c = tLBRACE; /* hash */
16218  else if (IS_lex_state(EXPR_ARG_ANY | EXPR_END | EXPR_ENDFN))
16219  c = '{'; /* block (primary) */
16220  else if (IS_lex_state(EXPR_ENDARG))
16221  c = tLBRACE_ARG; /* block (expr) */
16222  else
16223  c = tLBRACE; /* hash */
16224  if (c != tLBRACE) {
16225  p->command_start = TRUE;
16226  SET_LEX_STATE(EXPR_BEG);
16227  }
16228  else {
16229  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
16230  }
16231  ++p->lex.paren_nest; /* after lambda_beginning_p() */
16232  COND_PUSH(0);
16233  CMDARG_PUSH(0);
16234  return c;
16235 
16236  case '\\':
16237  c = nextc(p);
16238  if (c == '\n') {
16239  space_seen = 1;
16241  goto retry; /* skip \\n */
16242  }
16243  if (c == ' ') return tSP;
16244  if (ISSPACE(c)) return c;
16245  pushback(p, c);
16246  return '\\';
16247 
16248  case '%':
16249  return parse_percent(p, space_seen, last_state);
16250 
16251  case '$':
16252  return parse_gvar(p, last_state);
16253 
16254  case '@':
16255  return parse_atmark(p, last_state);
16256 
16257  case '_':
16258  if (was_bol(p) && whole_match_p(p, "__END__", 7, 0)) {
16259  p->ruby__end__seen = 1;
16260  p->eofp = 1;
16261 #ifndef RIPPER
16262  return -1;
16263 #else
16264  lex_goto_eol(p);
16266  return 0;
16267 #endif
16268  }
16269  newtok(p);
16270  break;
16271 
16272  default:
16273  if (!parser_is_identchar(p)) {
16274  compile_error(p, "Invalid char `\\x%02X' in expression", c);
16275  token_flush(p);
16276  goto retry;
16277  }
16278 
16279  newtok(p);
16280  break;
16281  }
16282 
16283  return parse_ident(p, c, cmd_state);
16284 }
16285 
16286 static enum yytokentype
16287 yylex(YYSTYPE *lval, YYLTYPE *yylloc, struct parser_params *p)
16288 {
16289  enum yytokentype t;
16290 
16291  p->lval = lval;
16292  lval->val = Qundef;
16293  t = parser_yylex(p);
16294  if (has_delayed_token(p))
16295  dispatch_delayed_token(p, t);
16296  else if (t != 0)
16297  dispatch_scan_event(p, t);
16298 
16299  if (p->lex.strterm && (p->lex.strterm->flags & STRTERM_HEREDOC))
16301  else
16302  RUBY_SET_YYLLOC(*yylloc);
16303 
16304  return t;
16305 }
16306 
16307 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
16308 
16309 static NODE*
16310 node_newnode(struct parser_params *p, enum node_type type, VALUE a0, VALUE a1, VALUE a2, const rb_code_location_t *loc)
16311 {
16312  NODE *n = rb_ast_newnode(p->ast, type);
16313 
16314  rb_node_init(n, type, a0, a1, a2);
16315 
16316  nd_set_loc(n, loc);
16317  nd_set_node_id(n, parser_get_node_id(p));
16318  return n;
16319 }
16320 
16321 static NODE *
16322 nd_set_loc(NODE *nd, const YYLTYPE *loc)
16323 {
16324  nd->nd_loc = *loc;
16325  nd_set_line(nd, loc->beg_pos.lineno);
16326  return nd;
16327 }
16328 
16329 #ifndef RIPPER
16330 static enum node_type
16331 nodetype(NODE *node) /* for debug */
16332 {
16333  return (enum node_type)nd_type(node);
16334 }
16335 
16336 static int
16337 nodeline(NODE *node)
16338 {
16339  return nd_line(node);
16340 }
16341 
16342 static NODE*
16343 newline_node(NODE *node)
16344 {
16345  if (node) {
16346  node = remove_begin(node);
16347  node->flags |= NODE_FL_NEWLINE;
16348  }
16349  return node;
16350 }
16351 
16352 static void
16353 fixpos(NODE *node, NODE *orig)
16354 {
16355  if (!node) return;
16356  if (!orig) return;
16357  nd_set_line(node, nd_line(orig));
16358 }
16359 
16360 static void
16361 parser_warning(struct parser_params *p, NODE *node, const char *mesg)
16362 {
16363  rb_compile_warning(p->ruby_sourcefile, nd_line(node), "%s", mesg);
16364 }
16365 
16366 static void
16367 parser_warn(struct parser_params *p, NODE *node, const char *mesg)
16368 {
16369  rb_compile_warn(p->ruby_sourcefile, nd_line(node), "%s", mesg);
16370 }
16371 
16372 static NODE*
16373 block_append(struct parser_params *p, NODE *head, NODE *tail)
16374 {
16375  NODE *end, *h = head, *nd;
16376 
16377  if (tail == 0) return head;
16378 
16379  if (h == 0) return tail;
16380  switch (nd_type(h)) {
16381  case NODE_LIT:
16382  case NODE_STR:
16383  case NODE_SELF:
16384  case NODE_TRUE:
16385  case NODE_FALSE:
16386  case NODE_NIL:
16387  parser_warning(p, h, "unused literal ignored");
16388  return tail;
16389  default:
16390  h = end = NEW_BLOCK(head, &head->nd_loc);
16391  end->nd_end = end;
16392  head = end;
16393  break;
16394  case NODE_BLOCK:
16395  end = h->nd_end;
16396  break;
16397  }
16398 
16399  nd = end->nd_head;
16400  switch (nd_type(nd)) {
16401  case NODE_RETURN:
16402  case NODE_BREAK:
16403  case NODE_NEXT:
16404  case NODE_REDO:
16405  case NODE_RETRY:
16406  if (RTEST(ruby_verbose)) {
16407  parser_warning(p, tail, "statement not reached");
16408  }
16409  break;
16410 
16411  default:
16412  break;
16413  }
16414 
16415  if (nd_type(tail) != NODE_BLOCK) {
16416  tail = NEW_BLOCK(tail, &tail->nd_loc);
16417  tail->nd_end = tail;
16418  }
16419  end->nd_next = tail;
16420  h->nd_end = tail->nd_end;
16421  nd_set_last_loc(head, nd_last_loc(tail));
16422  return head;
16423 }
16424 
16425 /* append item to the list */
16426 static NODE*
16427 list_append(struct parser_params *p, NODE *list, NODE *item)
16428 {
16429  NODE *last;
16430 
16431  if (list == 0) return NEW_LIST(item, &item->nd_loc);
16432  if (list->nd_next) {
16433  last = list->nd_next->nd_end;
16434  }
16435  else {
16436  last = list;
16437  }
16438 
16439  list->nd_alen += 1;
16440  last->nd_next = NEW_LIST(item, &item->nd_loc);
16441  list->nd_next->nd_end = last->nd_next;
16442 
16444 
16445  return list;
16446 }
16447 
16448 /* concat two lists */
16449 static NODE*
16450 list_concat(NODE *head, NODE *tail)
16451 {
16452  NODE *last;
16453 
16454  if (head->nd_next) {
16455  last = head->nd_next->nd_end;
16456  }
16457  else {
16458  last = head;
16459  }
16460 
16461  head->nd_alen += tail->nd_alen;
16462  last->nd_next = tail;
16463  if (tail->nd_next) {
16464  head->nd_next->nd_end = tail->nd_next->nd_end;
16465  }
16466  else {
16467  head->nd_next->nd_end = tail;
16468  }
16469 
16470  nd_set_last_loc(head, nd_last_loc(tail));
16471 
16472  return head;
16473 }
16474 
16475 static int
16476 literal_concat0(struct parser_params *p, VALUE head, VALUE tail)
16477 {
16478  if (NIL_P(tail)) return 1;
16479  if (!rb_enc_compatible(head, tail)) {
16480  compile_error(p, "string literal encodings differ (%s / %s)",
16481  rb_enc_name(rb_enc_get(head)),
16482  rb_enc_name(rb_enc_get(tail)));
16483  rb_str_resize(head, 0);
16484  rb_str_resize(tail, 0);
16485  return 0;
16486  }
16487  rb_str_buf_append(head, tail);
16488  return 1;
16489 }
16490 
16491 /* concat two string literals */
16492 static NODE *
16493 literal_concat(struct parser_params *p, NODE *head, NODE *tail, const YYLTYPE *loc)
16494 {
16495  enum node_type htype;
16496  NODE *headlast;
16497  VALUE lit;
16498 
16499  if (!head) return tail;
16500  if (!tail) return head;
16501 
16502  htype = nd_type(head);
16503  if (htype == NODE_EVSTR) {
16504  NODE *node = NEW_DSTR(STR_NEW0(), loc);
16505  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit);
16506  head = list_append(p, node, head);
16507  htype = NODE_DSTR;
16508  }
16509  if (p->heredoc_indent > 0) {
16510  switch (htype) {
16511  case NODE_STR:
16512  nd_set_type(head, NODE_DSTR);
16513  case NODE_DSTR:
16514  return list_append(p, head, tail);
16515  default:
16516  break;
16517  }
16518  }
16519  switch (nd_type(tail)) {
16520  case NODE_STR:
16521  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
16522  nd_type(headlast) == NODE_STR) {
16523  htype = NODE_STR;
16524  lit = headlast->nd_lit;
16525  }
16526  else {
16527  lit = head->nd_lit;
16528  }
16529  if (htype == NODE_STR) {
16530  if (!literal_concat0(p, lit, tail->nd_lit)) {
16531  error:
16532  rb_discard_node(p, head);
16533  rb_discard_node(p, tail);
16534  return 0;
16535  }
16536  rb_discard_node(p, tail);
16537  }
16538  else {
16539  list_append(p, head, tail);
16540  }
16541  break;
16542 
16543  case NODE_DSTR:
16544  if (htype == NODE_STR) {
16545  if (!literal_concat0(p, head->nd_lit, tail->nd_lit))
16546  goto error;
16547  tail->nd_lit = head->nd_lit;
16548  rb_discard_node(p, head);
16549  head = tail;
16550  }
16551  else if (NIL_P(tail->nd_lit)) {
16552  append:
16553  head->nd_alen += tail->nd_alen - 1;
16554  head->nd_next->nd_end->nd_next = tail->nd_next;
16555  head->nd_next->nd_end = tail->nd_next->nd_end;
16556  rb_discard_node(p, tail);
16557  }
16558  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
16559  nd_type(headlast) == NODE_STR) {
16560  lit = headlast->nd_lit;
16561  if (!literal_concat0(p, lit, tail->nd_lit))
16562  goto error;
16563  tail->nd_lit = Qnil;
16564  goto append;
16565  }
16566  else {
16567  list_concat(head, NEW_NODE(NODE_LIST, NEW_STR(tail->nd_lit, loc), tail->nd_alen, tail->nd_next, loc));
16568  }
16569  break;
16570 
16571  case NODE_EVSTR:
16572  if (htype == NODE_STR) {
16573  nd_set_type(head, NODE_DSTR);
16574  head->nd_alen = 1;
16575  }
16576  list_append(p, head, tail);
16577  break;
16578  }
16579  return head;
16580 }
16581 
16582 static NODE *
16583 evstr2dstr(struct parser_params *p, NODE *node)
16584 {
16585  if (nd_type(node) == NODE_EVSTR) {
16586  NODE * dstr = NEW_DSTR(STR_NEW0(), &node->nd_loc);
16587  RB_OBJ_WRITTEN(p->ast, Qnil, dstr->nd_lit);
16588  node = list_append(p, dstr, node);
16589  }
16590  return node;
16591 }
16592 
16593 static NODE *
16594 new_evstr(struct parser_params *p, NODE *node, const YYLTYPE *loc)
16595 {
16596  NODE *head = node;
16597 
16598  if (node) {
16599  switch (nd_type(node)) {
16600  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
16601  return node;
16602  }
16603  }
16604  return NEW_EVSTR(head, loc);
16605 }
16606 
16607 static NODE *
16608 call_bin_op(struct parser_params *p, NODE *recv, ID id, NODE *arg1,
16609  const YYLTYPE *op_loc, const YYLTYPE *loc)
16610 {
16611  NODE *expr;
16612  value_expr(recv);
16613  value_expr(arg1);
16614  expr = NEW_OPCALL(recv, id, NEW_LIST(arg1, &arg1->nd_loc), loc);
16615  nd_set_line(expr, op_loc->beg_pos.lineno);
16616  return expr;
16617 }
16618 
16619 static NODE *
16620 call_uni_op(struct parser_params *p, NODE *recv, ID id, const YYLTYPE *op_loc, const YYLTYPE *loc)
16621 {
16622  NODE *opcall;
16623  value_expr(recv);
16624  opcall = NEW_OPCALL(recv, id, 0, loc);
16625  nd_set_line(opcall, op_loc->beg_pos.lineno);
16626  return opcall;
16627 }
16628 
16629 static NODE *
16630 new_qcall(struct parser_params* p, ID atype, NODE *recv, ID mid, NODE *args, const YYLTYPE *op_loc, const YYLTYPE *loc)
16631 {
16632  NODE *qcall = NEW_QCALL(atype, recv, mid, args, loc);
16633  nd_set_line(qcall, op_loc->beg_pos.lineno);
16634  return qcall;
16635 }
16636 
16637 static NODE*
16638 new_command_qcall(struct parser_params* p, ID atype, NODE *recv, ID mid, NODE *args, NODE *block, const YYLTYPE *op_loc, const YYLTYPE *loc)
16639 {
16640  NODE *ret;
16641  if (block) block_dup_check(p, args, block);
16642  ret = new_qcall(p, atype, recv, mid, args, op_loc, loc);
16643  if (block) ret = method_add_block(p, ret, block, loc);
16644  fixpos(ret, recv);
16645  return ret;
16646 }
16647 
16648 #define nd_once_body(node) (nd_type(node) == NODE_ONCE ? (node)->nd_body : node)
16649 static NODE*
16650 match_op(struct parser_params *p, NODE *node1, NODE *node2, const YYLTYPE *op_loc, const YYLTYPE *loc)
16651 {
16652  NODE *n;
16653  int line = op_loc->beg_pos.lineno;
16654 
16655  value_expr(node1);
16656  value_expr(node2);
16657  if (node1 && (n = nd_once_body(node1)) != 0) {
16658  switch (nd_type(n)) {
16659  case NODE_DREGX:
16660  {
16661  NODE *match = NEW_MATCH2(node1, node2, loc);
16662  nd_set_line(match, line);
16663  return match;
16664  }
16665 
16666  case NODE_LIT:
16667  if (RB_TYPE_P(n->nd_lit, T_REGEXP)) {
16668  const VALUE lit = n->nd_lit;
16669  NODE *match = NEW_MATCH2(node1, node2, loc);
16670  match->nd_args = reg_named_capture_assign(p, lit, loc);
16671  nd_set_line(match, line);
16672  return match;
16673  }
16674  }
16675  }
16676 
16677  if (node2 && (n = nd_once_body(node2)) != 0) {
16678  NODE *match3;
16679 
16680  switch (nd_type(n)) {
16681  case NODE_LIT:
16682  if (!RB_TYPE_P(n->nd_lit, T_REGEXP)) break;
16683  /* fallthru */
16684  case NODE_DREGX:
16685  match3 = NEW_MATCH3(node2, node1, loc);
16686  return match3;
16687  }
16688  }
16689 
16690  n = NEW_CALL(node1, tMATCH, NEW_LIST(node2, &node2->nd_loc), loc);
16691  nd_set_line(n, line);
16692  return n;
16693 }
16694 
16695 # if WARN_PAST_SCOPE
16696 static int
16697 past_dvar_p(struct parser_params *p, ID id)
16698 {
16699  struct vtable *past = p->lvtbl->past;
16700  while (past) {
16701  if (vtable_included(past, id)) return 1;
16702  past = past->prev;
16703  }
16704  return 0;
16705 }
16706 # endif
16707 
16708 /* As Ripper#warn does not have arguments for the location, so the
16709  * following messages cannot be separated */
16710 #define WARN_LOCATION(type) do { \
16711  if (p->warn_location) { \
16712  int line; \
16713  VALUE file = rb_source_location(&line); \
16714  rb_warn3(type" in eval may not return location in binding;" \
16715  " use Binding#source_location instead\n" \
16716  "%"PRIsWARN":%d: warning: in `%"PRIsWARN"'", \
16717  file, WARN_I(line), rb_id2str(rb_frame_this_func())); \
16718  } \
16719 } while (0)
16720 
16721 static int
16722 numparam_nested_p(struct parser_params *p)
16723 {
16724  struct local_vars *local = p->lvtbl;
16725  NODE *outer = local->numparam.outer;
16726  NODE *inner = local->numparam.inner;
16727  if (outer || inner) {
16728  NODE *used = outer ? outer : inner;
16729  compile_error(p, "numbered parameter is already used in\n"
16730  "%s:%d: %s block here",
16732  outer ? "outer" : "inner");
16733  parser_show_error_line(p, &used->nd_loc);
16734  return 1;
16735  }
16736  return 0;
16737 }
16738 
16739 static NODE*
16740 gettable(struct parser_params *p, ID id, const YYLTYPE *loc)
16741 {
16742  ID *vidp = NULL;
16743  NODE *node;
16744  switch (id) {
16745  case keyword_self:
16746  return NEW_SELF(loc);
16747  case keyword_nil:
16748  return NEW_NIL(loc);
16749  case keyword_true:
16750  return NEW_TRUE(loc);
16751  case keyword_false:
16752  return NEW_FALSE(loc);
16753  case keyword__FILE__:
16754  WARN_LOCATION("__FILE__");
16755  {
16756  VALUE file = p->ruby_sourcefile_string;
16757  if (NIL_P(file))
16758  file = rb_str_new(0, 0);
16759  else
16760  file = rb_str_dup(file);
16761  node = NEW_STR(file, loc);
16762  RB_OBJ_WRITTEN(p->ast, Qnil, file);
16763  }
16764  return node;
16765  case keyword__LINE__:
16766  WARN_LOCATION("__LINE__");
16767  return NEW_LIT(INT2FIX(p->tokline), loc);
16768  case keyword__ENCODING__:
16769  node = NEW_LIT(rb_enc_from_encoding(p->enc), loc);
16770  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit);
16771  return node;
16772 
16773  }
16774  switch (id_type(id)) {
16775  case ID_LOCAL:
16776  if (dyna_in_block(p) && dvar_defined_ref(p, id, &vidp)) {
16777  if (NUMPARAM_ID_P(id) && numparam_nested_p(p)) return 0;
16778  if (id == p->cur_arg) {
16779  compile_error(p, "circular argument reference - %"PRIsWARN, rb_id2str(id));
16780  return 0;
16781  }
16782  if (vidp) *vidp |= LVAR_USED;
16783  node = NEW_DVAR(id, loc);
16784  return node;
16785  }
16786  if (local_id_ref(p, id, &vidp)) {
16787  if (id == p->cur_arg) {
16788  compile_error(p, "circular argument reference - %"PRIsWARN, rb_id2str(id));
16789  return 0;
16790  }
16791  if (vidp) *vidp |= LVAR_USED;
16792  node = NEW_LVAR(id, loc);
16793  return node;
16794  }
16795  if (dyna_in_block(p) && NUMPARAM_ID_P(id) &&
16796  parser_numbered_param(p, NUMPARAM_ID_TO_IDX(id))) {
16797  if (numparam_nested_p(p)) return 0;
16798  node = NEW_DVAR(id, loc);
16799  struct local_vars *local = p->lvtbl;
16800  if (!local->numparam.current) local->numparam.current = node;
16801  return node;
16802  }
16803 # if WARN_PAST_SCOPE
16804  if (!p->in_defined && RTEST(ruby_verbose) && past_dvar_p(p, id)) {
16805  rb_warning1("possible reference to past scope - %"PRIsWARN, rb_id2str(id));
16806  }
16807 # endif
16808  /* method call without arguments */
16809  return NEW_VCALL(id, loc);
16810  case ID_GLOBAL:
16811  return NEW_GVAR(id, loc);
16812  case ID_INSTANCE:
16813  return NEW_IVAR(id, loc);
16814  case ID_CONST:
16815  return NEW_CONST(id, loc);
16816  case ID_CLASS:
16817  return NEW_CVAR(id, loc);
16818  }
16819  compile_error(p, "identifier %"PRIsVALUE" is not valid to get", rb_id2str(id));
16820  return 0;
16821 }
16822 
16823 static NODE *
16824 opt_arg_append(NODE *opt_list, NODE *opt)
16825 {
16826  NODE *opts = opt_list;
16827  opts->nd_loc.end_pos = opt->nd_loc.end_pos;
16828 
16829  while (opts->nd_next) {
16830  opts = opts->nd_next;
16831  opts->nd_loc.end_pos = opt->nd_loc.end_pos;
16832  }
16833  opts->nd_next = opt;
16834 
16835  return opt_list;
16836 }
16837 
16838 static NODE *
16839 kwd_append(NODE *kwlist, NODE *kw)
16840 {
16841  if (kwlist) {
16842  NODE *kws = kwlist;
16843  kws->nd_loc.end_pos = kw->nd_loc.end_pos;
16844  while (kws->nd_next) {
16845  kws = kws->nd_next;
16846  kws->nd_loc.end_pos = kw->nd_loc.end_pos;
16847  }
16848  kws->nd_next = kw;
16849  }
16850  return kwlist;
16851 }
16852 
16853 static NODE *
16854 new_defined(struct parser_params *p, NODE *expr, const YYLTYPE *loc)
16855 {
16856  return NEW_DEFINED(remove_begin_all(expr), loc);
16857 }
16858 
16859 static NODE*
16860 symbol_append(struct parser_params *p, NODE *symbols, NODE *symbol)
16861 {
16862  if (nd_type(symbol) == NODE_DSTR) {
16863  nd_set_type(symbol, NODE_DSYM);
16864  }
16865  else {
16866  nd_set_type(symbol, NODE_LIT);
16867  RB_OBJ_WRITTEN(p->ast, Qnil, symbol->nd_lit = rb_str_intern(symbol->nd_lit));
16868  }
16869  return list_append(p, symbols, symbol);
16870 }
16871 
16872 static NODE *
16873 new_regexp(struct parser_params *p, NODE *node, int options, const YYLTYPE *loc)
16874 {
16875  NODE *list, *prev;
16876  VALUE lit;
16877 
16878  if (!node) {
16879  node = NEW_LIT(reg_compile(p, STR_NEW0(), options), loc);
16880  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit);
16881  return node;
16882  }
16883  switch (nd_type(node)) {
16884  case NODE_STR:
16885  {
16886  VALUE src = node->nd_lit;
16887  nd_set_type(node, NODE_LIT);
16888  nd_set_loc(node, loc);
16889  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit = reg_compile(p, src, options));
16890  }
16891  break;
16892  default:
16893  lit = STR_NEW0();
16894  node = NEW_NODE(NODE_DSTR, lit, 1, NEW_LIST(node, loc), loc);
16895  RB_OBJ_WRITTEN(p->ast, Qnil, lit);
16896  /* fall through */
16897  case NODE_DSTR:
16898  nd_set_type(node, NODE_DREGX);
16899  nd_set_loc(node, loc);
16900  node->nd_cflag = options & RE_OPTION_MASK;
16901  if (!NIL_P(node->nd_lit)) reg_fragment_check(p, node->nd_lit, options);
16902  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
16903  if (nd_type(list->nd_head) == NODE_STR) {
16904  VALUE tail = list->nd_head->nd_lit;
16905  if (reg_fragment_check(p, tail, options) && prev && !NIL_P(prev->nd_lit)) {
16906  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
16907  if (!literal_concat0(p, lit, tail)) {
16908  return NEW_NIL(loc); /* dummy node on error */
16909  }
16910  rb_str_resize(tail, 0);
16911  prev->nd_next = list->nd_next;
16912  rb_discard_node(p, list->nd_head);
16913  rb_discard_node(p, list);
16914  list = prev;
16915  }
16916  else {
16917  prev = list;
16918  }
16919  }
16920  else {
16921  prev = 0;
16922  }
16923  }
16924  if (!node->nd_next) {
16925  VALUE src = node->nd_lit;
16926  nd_set_type(node, NODE_LIT);
16927  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit = reg_compile(p, src, options));
16928  }
16929  if (options & RE_OPTION_ONCE) {
16930  node = NEW_NODE(NODE_ONCE, 0, node, 0, loc);
16931  }
16932  break;
16933  }
16934  return node;
16935 }
16936 
16937 static NODE *
16938 new_kw_arg(struct parser_params *p, NODE *k, const YYLTYPE *loc)
16939 {
16940  if (!k) return 0;
16941  return NEW_KW_ARG(0, (k), loc);
16942 }
16943 
16944 static NODE *
16945 new_xstring(struct parser_params *p, NODE *node, const YYLTYPE *loc)
16946 {
16947  if (!node) {
16948  VALUE lit = STR_NEW0();
16949  NODE *xstr = NEW_XSTR(lit, loc);
16950  RB_OBJ_WRITTEN(p->ast, Qnil, lit);
16951  return xstr;
16952  }
16953  switch (nd_type(node)) {
16954  case NODE_STR:
16955  nd_set_type(node, NODE_XSTR);
16956  nd_set_loc(node, loc);
16957  break;
16958  case NODE_DSTR:
16959  nd_set_type(node, NODE_DXSTR);
16960  nd_set_loc(node, loc);
16961  break;
16962  default:
16963  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node, loc), loc);
16964  break;
16965  }
16966  return node;
16967 }
16968 
16969 static void
16970 check_literal_when(struct parser_params *p, NODE *arg, const YYLTYPE *loc)
16971 {
16972  VALUE lit;
16973 
16974  if (!arg || !p->case_labels) return;
16975 
16977  if (lit == Qundef) return;
16978  if (nd_type(arg) == NODE_STR) {
16979  RB_OBJ_WRITTEN(p->ast, Qnil, arg->nd_lit = lit);
16980  }
16981 
16982  if (NIL_P(p->case_labels)) {
16984  }
16985  else {
16986  VALUE line = rb_hash_lookup(p->case_labels, lit);
16987  if (!NIL_P(line)) {
16988  rb_warning1("duplicated `when' clause with line %d is ignored",
16989  WARN_IVAL(line));
16990  return;
16991  }
16992  }
16994 }
16995 
16996 #else /* !RIPPER */
16997 static int
16998 id_is_var(struct parser_params *p, ID id)
16999 {
17000  if (is_notop_id(id)) {
17001  switch (id & ID_SCOPE_MASK) {
17002  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
17003  return 1;
17004  case ID_LOCAL:
17005  if (dyna_in_block(p)) {
17006  if (NUMPARAM_ID_P(id) || dvar_defined(p, id)) return 1;
17007  }
17008  if (local_id(p, id)) return 1;
17009  /* method call without arguments */
17010  return 0;
17011  }
17012  }
17013  compile_error(p, "identifier %"PRIsVALUE" is not valid to get", rb_id2str(id));
17014  return 0;
17015 }
17016 
17017 static VALUE
17018 new_regexp(struct parser_params *p, VALUE re, VALUE opt, const YYLTYPE *loc)
17019 {
17020  VALUE src = 0, err;
17021  int options = 0;
17022  if (ripper_is_node_yylval(re)) {
17023  src = RNODE(re)->nd_cval;
17024  re = RNODE(re)->nd_rval;
17025  }
17026  if (ripper_is_node_yylval(opt)) {
17027  options = (int)RNODE(opt)->nd_tag;
17028  opt = RNODE(opt)->nd_rval;
17029  }
17030  if (src && NIL_P(parser_reg_compile(p, src, options, &err))) {
17031  compile_error(p, "%"PRIsVALUE, err);
17032  }
17033  return dispatch2(regexp_literal, re, opt);
17034 }
17035 #endif /* !RIPPER */
17036 
17037 
17038 #ifndef RIPPER
17039 static const char rb_parser_lex_state_names[][8] = {
17040  "BEG", "END", "ENDARG", "ENDFN", "ARG",
17041  "CMDARG", "MID", "FNAME", "DOT", "CLASS",
17042  "LABEL", "LABELED","FITEM",
17043 };
17044 
17045 static VALUE
17046 append_lex_state_name(enum lex_state_e state, VALUE buf)
17047 {
17048  int i, sep = 0;
17049  unsigned int mask = 1;
17050  static const char none[] = "NONE";
17051 
17052  for (i = 0; i < EXPR_MAX_STATE; ++i, mask <<= 1) {
17053  if ((unsigned)state & mask) {
17054  if (sep) {
17055  rb_str_cat(buf, "|", 1);
17056  }
17057  sep = 1;
17058  rb_str_cat_cstr(buf, rb_parser_lex_state_names[i]);
17059  }
17060  }
17061  if (!sep) {
17062  rb_str_cat(buf, none, sizeof(none)-1);
17063  }
17064  return buf;
17065 }
17066 
17067 static void
17068 flush_debug_buffer(struct parser_params *p, VALUE out, VALUE str)
17069 {
17070  VALUE mesg = p->debug_buffer;
17071 
17072  if (!NIL_P(mesg) && RSTRING_LEN(mesg)) {
17073  p->debug_buffer = Qnil;
17074  rb_io_puts(1, &mesg, out);
17075  }
17076  if (!NIL_P(str) && RSTRING_LEN(str)) {
17078  }
17079 }
17080 
17081 enum lex_state_e
17083  enum lex_state_e to, int line)
17084 {
17085  VALUE mesg;
17086  mesg = rb_str_new_cstr("lex_state: ");
17087  append_lex_state_name(from, mesg);
17088  rb_str_cat_cstr(mesg, " -> ");
17089  append_lex_state_name(to, mesg);
17090  rb_str_catf(mesg, " at line %d\n", line);
17091  flush_debug_buffer(p, p->debug_output, mesg);
17092  return to;
17093 }
17094 
17095 VALUE
17097 {
17098  return rb_fstring(append_lex_state_name(state, rb_str_new(0, 0)));
17099 }
17100 
17101 static void
17102 append_bitstack_value(stack_type stack, VALUE mesg)
17103 {
17104  if (stack == 0) {
17105  rb_str_cat_cstr(mesg, "0");
17106  }
17107  else {
17108  stack_type mask = (stack_type)1U << (CHAR_BIT * sizeof(stack_type) - 1);
17109  for (; mask && !(stack & mask); mask >>= 1) continue;
17110  for (; mask; mask >>= 1) rb_str_cat(mesg, stack & mask ? "1" : "0", 1);
17111  }
17112 }
17113 
17114 void
17116  const char *name, int line)
17117 {
17118  VALUE mesg = rb_sprintf("%s: ", name);
17119  append_bitstack_value(stack, mesg);
17120  rb_str_catf(mesg, " at line %d\n", line);
17121  flush_debug_buffer(p, p->debug_output, mesg);
17122 }
17123 
17124 void
17125 rb_parser_fatal(struct parser_params *p, const char *fmt, ...)
17126 {
17127  va_list ap;
17128  VALUE mesg = rb_str_new_cstr("internal parser error: ");
17129 
17130  va_start(ap, fmt);
17131  rb_str_vcatf(mesg, fmt, ap);
17132  va_end(ap);
17133  parser_yyerror(p, NULL, RSTRING_PTR(mesg));
17134  RB_GC_GUARD(mesg);
17135 
17136  mesg = rb_str_new(0, 0);
17137  append_lex_state_name(p->lex.state, mesg);
17138  compile_error(p, "lex.state: %"PRIsVALUE, mesg);
17139  rb_str_resize(mesg, 0);
17140  append_bitstack_value(p->cond_stack, mesg);
17141  compile_error(p, "cond_stack: %"PRIsVALUE, mesg);
17142  rb_str_resize(mesg, 0);
17143  append_bitstack_value(p->cmdarg_stack, mesg);
17144  compile_error(p, "cmdarg_stack: %"PRIsVALUE, mesg);
17145  if (p->debug_output == rb_stdout)
17146  p->debug_output = rb_stderr;
17147  p->debug = TRUE;
17148 }
17149 
17150 YYLTYPE *
17152 {
17153  int sourceline = here->sourceline;
17154  int beg_pos = (int)here->offset - here->quote
17155  - (rb_strlen_lit("<<-") - !(here->func & STR_FUNC_INDENT));
17156  int end_pos = (int)here->offset + here->length + here->quote;
17157 
17158  yylloc->beg_pos.lineno = sourceline;
17159  yylloc->beg_pos.column = beg_pos;
17160  yylloc->end_pos.lineno = sourceline;
17161  yylloc->end_pos.column = end_pos;
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.ptok - p->lex.pbeg);
17172  return yylloc;
17173 }
17174 
17175 YYLTYPE *
17177 {
17178  yylloc->beg_pos.lineno = p->ruby_sourceline;
17179  yylloc->beg_pos.column = (int)(p->lex.ptok - p->lex.pbeg);
17180  yylloc->end_pos.lineno = p->ruby_sourceline;
17181  yylloc->end_pos.column = (int)(p->lex.pcur - p->lex.pbeg);
17182  return yylloc;
17183 }
17184 #endif /* !RIPPER */
17185 
17186 static void
17187 parser_token_value_print(struct parser_params *p, enum yytokentype type, const YYSTYPE *valp)
17188 {
17189  VALUE v;
17190 
17191  switch (type) {
17192  case tIDENTIFIER: case tFID: case tGVAR: case tIVAR:
17193  case tCONSTANT: case tCVAR: case tLABEL: case tOP_ASGN:
17194 #ifndef RIPPER
17195  v = rb_id2str(valp->id);
17196 #else
17197  v = valp->node->nd_rval;
17198 #endif
17199  rb_parser_printf(p, "%"PRIsVALUE, v);
17200  break;
17201  case tINTEGER: case tFLOAT: case tRATIONAL: case tIMAGINARY:
17202  case tSTRING_CONTENT: case tCHAR:
17203 #ifndef RIPPER
17204  v = valp->node->nd_lit;
17205 #else
17206  v = valp->val;
17207 #endif
17208  rb_parser_printf(p, "%+"PRIsVALUE, v);
17209  break;
17210  case tNTH_REF:
17211 #ifndef RIPPER
17212  rb_parser_printf(p, "$%ld", valp->node->nd_nth);
17213 #else
17214  rb_parser_printf(p, "%"PRIsVALUE, valp->val);
17215 #endif
17216  break;
17217  case tBACK_REF:
17218 #ifndef RIPPER
17219  rb_parser_printf(p, "$%c", (int)valp->node->nd_nth);
17220 #else
17221  rb_parser_printf(p, "%"PRIsVALUE, valp->val);
17222 #endif
17223  break;
17224  default:
17225  break;
17226  }
17227 }
17228 
17229 static int
17230 assignable0(struct parser_params *p, ID id, const char **err)
17231 {
17232  if (!id) return -1;
17233  switch (id) {
17234  case keyword_self:
17235  *err = "Can't change the value of self";
17236  return -1;
17237  case keyword_nil:
17238  *err = "Can't assign to nil";
17239  return -1;
17240  case keyword_true:
17241  *err = "Can't assign to true";
17242  return -1;
17243  case keyword_false:
17244  *err = "Can't assign to false";
17245  return -1;
17246  case keyword__FILE__:
17247  *err = "Can't assign to __FILE__";
17248  return -1;
17249  case keyword__LINE__:
17250  *err = "Can't assign to __LINE__";
17251  return -1;
17252  case keyword__ENCODING__:
17253  *err = "Can't assign to __ENCODING__";
17254  return -1;
17255  }
17256  switch (id_type(id)) {
17257  case ID_LOCAL:
17258  if (dyna_in_block(p)) {
17259  if (p->max_numparam > NO_PARAM && NUMPARAM_ID_P(id)) {
17260  compile_error(p, "Can't assign to numbered parameter _%d",
17261  NUMPARAM_ID_TO_IDX(id));
17262  return -1;
17263  }
17264  if (dvar_curr(p, id)) return NODE_DASGN_CURR;
17265  if (dvar_defined(p, id)) return NODE_DASGN;
17266  if (local_id(p, id)) return NODE_LASGN;
17267  dyna_var(p, id);
17268  return NODE_DASGN_CURR;
17269  }
17270  else {
17271  if (!local_id(p, id)) local_var(p, id);
17272  return NODE_LASGN;
17273  }
17274  break;
17275  case ID_GLOBAL: return NODE_GASGN;
17276  case ID_INSTANCE: return NODE_IASGN;
17277  case ID_CONST:
17278  if (!p->in_def) return NODE_CDECL;
17279  *err = "dynamic constant assignment";
17280  return -1;
17281  case ID_CLASS: return NODE_CVASGN;
17282  default:
17283  compile_error(p, "identifier %"PRIsVALUE" is not valid to set", rb_id2str(id));
17284  }
17285  return -1;
17286 }
17287 
17288 #ifndef RIPPER
17289 static NODE*
17290 assignable(struct parser_params *p, ID id, NODE *val, const YYLTYPE *loc)
17291 {
17292  const char *err = 0;
17293  int node_type = assignable0(p, id, &err);
17294  switch (node_type) {
17295  case NODE_DASGN_CURR: return NEW_DASGN_CURR(id, val, loc);
17296  case NODE_DASGN: return NEW_DASGN(id, val, loc);
17297  case NODE_LASGN: return NEW_LASGN(id, val, loc);
17298  case NODE_GASGN: return NEW_GASGN(id, val, loc);
17299  case NODE_IASGN: return NEW_IASGN(id, val, loc);
17300  case NODE_CDECL: return NEW_CDECL(id, val, 0, loc);
17301  case NODE_CVASGN: return NEW_CVASGN(id, val, loc);
17302  }
17303  if (err) yyerror1(loc, err);
17304  return NEW_BEGIN(0, loc);
17305 }
17306 #else
17307 static VALUE
17308 assignable(struct parser_params *p, VALUE lhs)
17309 {
17310  const char *err = 0;
17311  assignable0(p, get_id(lhs), &err);
17312  if (err) lhs = assign_error(p, lhs);
17313  return lhs;
17314 }
17315 #endif
17316 
17317 static int
17318 is_private_local_id(ID name)
17319 {
17320  VALUE s;
17321  if (name == idUScore) return 1;
17322  if (!is_local_id(name)) return 0;
17323  s = rb_id2str(name);
17324  if (!s) return 0;
17325  return RSTRING_PTR(s)[0] == '_';
17326 }
17327 
17328 static int
17329 shadowing_lvar_0(struct parser_params *p, ID name)
17330 {
17331  if (is_private_local_id(name)) return 1;
17332  if (dyna_in_block(p)) {
17333  if (dvar_curr(p, name)) {
17334  yyerror0("duplicated argument name");
17335  }
17336  else if (dvar_defined(p, name) || local_id(p, name)) {
17337  vtable_add(p->lvtbl->vars, name);
17338  if (p->lvtbl->used) {
17340  }
17341  return 0;
17342  }
17343  }
17344  else {
17345  if (local_id(p, name)) {
17346  yyerror0("duplicated argument name");
17347  }
17348  }
17349  return 1;
17350 }
17351 
17352 static ID
17353 shadowing_lvar(struct parser_params *p, ID name)
17354 {
17355  shadowing_lvar_0(p, name);
17356  return name;
17357 }
17358 
17359 static void
17360 new_bv(struct parser_params *p, ID name)
17361 {
17362  if (!name) return;
17363  if (!is_local_id(name)) {
17364  compile_error(p, "invalid local variable - %"PRIsVALUE,
17365  rb_id2str(name));
17366  return;
17367  }
17368  if (!shadowing_lvar_0(p, name)) return;
17369  dyna_var(p, name);
17370 }
17371 
17372 #ifndef RIPPER
17373 static NODE *
17374 aryset(struct parser_params *p, NODE *recv, NODE *idx, const YYLTYPE *loc)
17375 {
17376  return NEW_ATTRASGN(recv, tASET, idx, loc);
17377 }
17378 
17379 static void
17380 block_dup_check(struct parser_params *p, NODE *node1, NODE *node2)
17381 {
17382  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
17383  compile_error(p, "both block arg and actual block given");
17384  }
17385 }
17386 
17387 static NODE *
17388 attrset(struct parser_params *p, NODE *recv, ID atype, ID id, const YYLTYPE *loc)
17389 {
17390  if (!CALL_Q_P(atype)) id = rb_id_attrset(id);
17391  return NEW_ATTRASGN(recv, id, 0, loc);
17392 }
17393 
17394 static void
17395 rb_backref_error(struct parser_params *p, NODE *node)
17396 {
17397  switch (nd_type(node)) {
17398  case NODE_NTH_REF:
17399  compile_error(p, "Can't set variable $%ld", node->nd_nth);
17400  break;
17401  case NODE_BACK_REF:
17402  compile_error(p, "Can't set variable $%c", (int)node->nd_nth);
17403  break;
17404  }
17405 }
17406 
17407 static NODE *
17408 arg_append(struct parser_params *p, NODE *node1, NODE *node2, const YYLTYPE *loc)
17409 {
17410  if (!node1) return NEW_LIST(node2, &node2->nd_loc);
17411  switch (nd_type(node1)) {
17412  case NODE_LIST:
17413  return list_append(p, node1, node2);
17414  case NODE_BLOCK_PASS:
17415  node1->nd_head = arg_append(p, node1->nd_head, node2, loc);
17416  node1->nd_loc.end_pos = node1->nd_head->nd_loc.end_pos;
17417  return node1;
17418  case NODE_ARGSPUSH:
17419  node1->nd_body = list_append(p, NEW_LIST(node1->nd_body, &node1->nd_body->nd_loc), node2);
17420  node1->nd_loc.end_pos = node1->nd_body->nd_loc.end_pos;
17421  nd_set_type(node1, NODE_ARGSCAT);
17422  return node1;
17423  case NODE_ARGSCAT:
17424  if (nd_type(node1->nd_body) != NODE_LIST) break;
17425  node1->nd_body = list_append(p, node1->nd_body, node2);
17426  node1->nd_loc.end_pos = node1->nd_body->nd_loc.end_pos;
17427  return node1;
17428  }
17429  return NEW_ARGSPUSH(node1, node2, loc);
17430 }
17431 
17432 static NODE *
17433 arg_concat(struct parser_params *p, NODE *node1, NODE *node2, const YYLTYPE *loc)
17434 {
17435  if (!node2) return node1;
17436  switch (nd_type(node1)) {
17437  case NODE_BLOCK_PASS:
17438  if (node1->nd_head)
17439  node1->nd_head = arg_concat(p, node1->nd_head, node2, loc);
17440  else
17441  node1->nd_head = NEW_LIST(node2, loc);
17442  return node1;
17443  case NODE_ARGSPUSH:
17444  if (nd_type(node2) != NODE_LIST) break;
17445  node1->nd_body = list_concat(NEW_LIST(node1->nd_body, loc), node2);
17446  nd_set_type(node1, NODE_ARGSCAT);
17447  return node1;
17448  case NODE_ARGSCAT:
17449  if (nd_type(node2) != NODE_LIST ||
17450  nd_type(node1->nd_body) != NODE_LIST) break;
17451  node1->nd_body = list_concat(node1->nd_body, node2);
17452  return node1;
17453  }
17454  return NEW_ARGSCAT(node1, node2, loc);
17455 }
17456 
17457 static NODE *
17458 last_arg_append(struct parser_params *p, NODE *args, NODE *last_arg, const YYLTYPE *loc)
17459 {
17460  NODE *n1;
17461  if ((n1 = splat_array(args)) != 0) {
17462  return list_append(p, n1, last_arg);
17463  }
17464  return arg_append(p, args, last_arg, loc);
17465 }
17466 
17467 static NODE *
17468 rest_arg_append(struct parser_params *p, NODE *args, NODE *rest_arg, const YYLTYPE *loc)
17469 {
17470  NODE *n1;
17471  if ((nd_type(rest_arg) == NODE_LIST) && (n1 = splat_array(args)) != 0) {
17472  return list_concat(n1, rest_arg);
17473  }
17474  return arg_concat(p, args, rest_arg, loc);
17475 }
17476 
17477 static NODE *
17478 splat_array(NODE* node)
17479 {
17480  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
17481  if (nd_type(node) == NODE_LIST) return node;
17482  return 0;
17483 }
17484 
17485 static void
17486 mark_lvar_used(struct parser_params *p, NODE *rhs)
17487 {
17488  ID *vidp = NULL;
17489  if (!rhs) return;
17490  switch (nd_type(rhs)) {
17491  case NODE_LASGN:
17492  if (local_id_ref(p, rhs->nd_vid, &vidp)) {
17493  if (vidp) *vidp |= LVAR_USED;
17494  }
17495  break;
17496  case NODE_DASGN:
17497  case NODE_DASGN_CURR:
17498  if (dvar_defined_ref(p, rhs->nd_vid, &vidp)) {
17499  if (vidp) *vidp |= LVAR_USED;
17500  }
17501  break;
17502 #if 0
17503  case NODE_MASGN:
17504  for (rhs = rhs->nd_head; rhs; rhs = rhs->nd_next) {
17505  mark_lvar_used(p, rhs->nd_head);
17506  }
17507  break;
17508 #endif
17509  }
17510 }
17511 
17512 static NODE *
17513 node_assign(struct parser_params *p, NODE *lhs, NODE *rhs, const YYLTYPE *loc)
17514 {
17515  if (!lhs) return 0;
17516 
17517  switch (nd_type(lhs)) {
17518  case NODE_GASGN:
17519  case NODE_IASGN:
17520  case NODE_LASGN:
17521  case NODE_DASGN:
17522  case NODE_DASGN_CURR:
17523  case NODE_MASGN:
17524  case NODE_CDECL:
17525  case NODE_CVASGN:
17526  lhs->nd_value = rhs;
17527  nd_set_loc(lhs, loc);
17528  break;
17529 
17530  case NODE_ATTRASGN:
17531  lhs->nd_args = arg_append(p, lhs->nd_args, rhs, loc);
17532  nd_set_loc(lhs, loc);
17533  break;
17534 
17535  default:
17536  /* should not happen */
17537  break;
17538  }
17539 
17540  return lhs;
17541 }
17542 
17543 static NODE *
17544 value_expr_check(struct parser_params *p, NODE *node)
17545 {
17546  NODE *void_node = 0, *vn;
17547 
17548  if (!node) {
17549  rb_warning0("empty expression");
17550  }
17551  while (node) {
17552  switch (nd_type(node)) {
17553  case NODE_RETURN:
17554  case NODE_BREAK:
17555  case NODE_NEXT:
17556  case NODE_REDO:
17557  case NODE_RETRY:
17558  return void_node ? void_node : node;
17559 
17560  case NODE_CASE3:
17561  if (!node->nd_body || nd_type(node->nd_body) != NODE_IN) {
17562  compile_error(p, "unexpected node");
17563  return NULL;
17564  }
17565  if (node->nd_body->nd_body) {
17566  return NULL;
17567  }
17568  /* single line pattern matching */
17569  return void_node ? void_node : node;
17570 
17571  case NODE_BLOCK:
17572  while (node->nd_next) {
17573  node = node->nd_next;
17574  }
17575  node = node->nd_head;
17576  break;
17577 
17578  case NODE_BEGIN:
17579  node = node->nd_body;
17580  break;
17581 
17582  case NODE_IF:
17583  case NODE_UNLESS:
17584  if (!node->nd_body) {
17585  return NULL;
17586  }
17587  else if (!node->nd_else) {
17588  return NULL;
17589  }
17590  vn = value_expr_check(p, node->nd_body);
17591  if (!vn) return NULL;
17592  if (!void_node) void_node = vn;
17593  node = node->nd_else;
17594  break;
17595 
17596  case NODE_AND:
17597  case NODE_OR:
17598  node = node->nd_1st;
17599  break;
17600 
17601  case NODE_LASGN:
17602  case NODE_DASGN:
17603  case NODE_DASGN_CURR:
17604  case NODE_MASGN:
17605  mark_lvar_used(p, node);
17606  return NULL;
17607 
17608  default:
17609  return NULL;
17610  }
17611  }
17612 
17613  return NULL;
17614 }
17615 
17616 static int
17617 value_expr_gen(struct parser_params *p, NODE *node)
17618 {
17619  NODE *void_node = value_expr_check(p, node);
17620  if (void_node) {
17621  yyerror1(&void_node->nd_loc, "void value expression");
17622  /* or "control never reach"? */
17623  return FALSE;
17624  }
17625  return TRUE;
17626 }
17627 static void
17628 void_expr(struct parser_params *p, NODE *node)
17629 {
17630  const char *useless = 0;
17631 
17632  if (!RTEST(ruby_verbose)) return;
17633 
17634  if (!node || !(node = nd_once_body(node))) return;
17635  switch (nd_type(node)) {
17636  case NODE_OPCALL:
17637  switch (node->nd_mid) {
17638  case '+':
17639  case '-':
17640  case '*':
17641  case '/':
17642  case '%':
17643  case tPOW:
17644  case tUPLUS:
17645  case tUMINUS:
17646  case '|':
17647  case '^':
17648  case '&':
17649  case tCMP:
17650  case '>':
17651  case tGEQ:
17652  case '<':
17653  case tLEQ:
17654  case tEQ:
17655  case tNEQ:
17656  useless = rb_id2name(node->nd_mid);
17657  break;
17658  }
17659  break;
17660 
17661  case NODE_LVAR:
17662  case NODE_DVAR:
17663  case NODE_GVAR:
17664  case NODE_IVAR:
17665  case NODE_CVAR:
17666  case NODE_NTH_REF:
17667  case NODE_BACK_REF:
17668  useless = "a variable";
17669  break;
17670  case NODE_CONST:
17671  useless = "a constant";
17672  break;
17673  case NODE_LIT:
17674  case NODE_STR:
17675  case NODE_DSTR:
17676  case NODE_DREGX:
17677  useless = "a literal";
17678  break;
17679  case NODE_COLON2:
17680  case NODE_COLON3:
17681  useless = "::";
17682  break;
17683  case NODE_DOT2:
17684  useless = "..";
17685  break;
17686  case NODE_DOT3:
17687  useless = "...";
17688  break;
17689  case NODE_SELF:
17690  useless = "self";
17691  break;
17692  case NODE_NIL:
17693  useless = "nil";
17694  break;
17695  case NODE_TRUE:
17696  useless = "true";
17697  break;
17698  case NODE_FALSE:
17699  useless = "false";
17700  break;
17701  case NODE_DEFINED:
17702  useless = "defined?";
17703  break;
17704  }
17705 
17706  if (useless) {
17707  rb_warn1L(nd_line(node), "possibly useless use of %s in void context", WARN_S(useless));
17708  }
17709 }
17710 
17711 static NODE *
17712 void_stmts(struct parser_params *p, NODE *node)
17713 {
17714  NODE *const n = node;
17715  if (!RTEST(ruby_verbose)) return n;
17716  if (!node) return n;
17717  if (nd_type(node) != NODE_BLOCK) return n;
17718 
17719  while (node->nd_next) {
17720  void_expr(p, node->nd_head);
17721  node = node->nd_next;
17722  }
17723  return n;
17724 }
17725 
17726 static NODE *
17727 remove_begin(NODE *node)
17728 {
17729  NODE **n = &node, *n1 = node;
17730  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
17731  *n = n1 = n1->nd_body;
17732  }
17733  return node;
17734 }
17735 
17736 static NODE *
17737 remove_begin_all(NODE *node)
17738 {
17739  NODE **n = &node, *n1 = node;
17740  while (n1 && nd_type(n1) == NODE_BEGIN) {
17741  *n = n1 = n1->nd_body;
17742  }
17743  return node;
17744 }
17745 
17746 static void
17747 reduce_nodes(struct parser_params *p, NODE **body)
17748 {
17749  NODE *node = *body;
17750 
17751  if (!node) {
17752  *body = NEW_NIL(&NULL_LOC);
17753  return;
17754  }
17755 #define subnodes(n1, n2) \
17756  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
17757  (!node->n2) ? (body = &node->n1, 1) : \
17758  (reduce_nodes(p, &node->n1), body = &node->n2, 1))
17759 
17760  while (node) {
17761  int newline = (int)(node->flags & NODE_FL_NEWLINE);
17762  switch (nd_type(node)) {
17763  end:
17764  case NODE_NIL:
17765  *body = 0;
17766  return;
17767  case NODE_RETURN:
17768  *body = node = node->nd_stts;
17769  if (newline && node) node->flags |= NODE_FL_NEWLINE;
17770  continue;
17771  case NODE_BEGIN:
17772  *body = node = node->nd_body;
17773  if (newline && node) node->flags |= NODE_FL_NEWLINE;
17774  continue;
17775  case NODE_BLOCK:
17776  body = &node->nd_end->nd_head;
17777  break;
17778  case NODE_IF:
17779  case NODE_UNLESS:
17780  if (subnodes(nd_body, nd_else)) break;
17781  return;
17782  case NODE_CASE:
17783  body = &node->nd_body;
17784  break;
17785  case NODE_WHEN:
17786  if (!subnodes(nd_body, nd_next)) goto end;
17787  break;
17788  case NODE_ENSURE:
17789  if (!subnodes(nd_head, nd_resq)) goto end;
17790  break;
17791  case NODE_RESCUE:
17792  if (node->nd_else) {
17793  body = &node->nd_resq;
17794  break;
17795  }
17796  if (!subnodes(nd_head, nd_resq)) goto end;
17797  break;
17798  default:
17799  return;
17800  }
17801  node = *body;
17802  if (newline && node) node->flags |= NODE_FL_NEWLINE;
17803  }
17804 
17805 #undef subnodes
17806 }
17807 
17808 static int
17809 is_static_content(NODE *node)
17810 {
17811  if (!node) return 1;
17812  switch (nd_type(node)) {
17813  case NODE_HASH:
17814  if (!(node = node->nd_head)) break;
17815  case NODE_LIST:
17816  do {
17817  if (!is_static_content(node->nd_head)) return 0;
17818  } while ((node = node->nd_next) != 0);
17819  case NODE_LIT:
17820  case NODE_STR:
17821  case NODE_NIL:
17822  case NODE_TRUE:
17823  case NODE_FALSE:
17824  case NODE_ZLIST:
17825  break;
17826  default:
17827  return 0;
17828  }
17829  return 1;
17830 }
17831 
17832 static int
17833 assign_in_cond(struct parser_params *p, NODE *node)
17834 {
17835  switch (nd_type(node)) {
17836  case NODE_MASGN:
17837  case NODE_LASGN:
17838  case NODE_DASGN:
17839  case NODE_DASGN_CURR:
17840  case NODE_GASGN:
17841  case NODE_IASGN:
17842  break;
17843 
17844  default:
17845  return 0;
17846  }
17847 
17848  if (!node->nd_value) return 1;
17849  if (is_static_content(node->nd_value)) {
17850  /* reports always */
17851  parser_warn(p, node->nd_value, "found `= literal' in conditional, should be ==");
17852  }
17853  return 1;
17854 }
17855 
17860 };
17861 
17862 #define SWITCH_BY_COND_TYPE(t, w, arg) \
17863  switch (t) { \
17864  case COND_IN_OP: break; \
17865  case COND_IN_COND: rb_##w##0(arg "literal in condition"); break; \
17866  case COND_IN_FF: rb_##w##0(arg "literal in flip-flop"); break; \
17867  }
17868 
17869 static NODE *cond0(struct parser_params*,NODE*,enum cond_type,const YYLTYPE*);
17870 
17871 static NODE*
17872 range_op(struct parser_params *p, NODE *node, const YYLTYPE *loc)
17873 {
17874  enum node_type type;
17875 
17876  if (node == 0) return 0;
17877 
17878  type = nd_type(node);
17879  value_expr(node);
17880  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
17881  if (!e_option_supplied(p)) parser_warn(p, node, "integer literal in flip-flop");
17882  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."), loc), loc), loc);
17883  }
17884  return cond0(p, node, COND_IN_FF, loc);
17885 }
17886 
17887 static NODE*
17888 cond0(struct parser_params *p, NODE *node, enum cond_type type, const YYLTYPE *loc)
17889 {
17890  if (node == 0) return 0;
17891  if (!(node = nd_once_body(node))) return 0;
17892  assign_in_cond(p, node);
17893 
17894  switch (nd_type(node)) {
17895  case NODE_DSTR:
17896  case NODE_EVSTR:
17897  case NODE_STR:
17898  SWITCH_BY_COND_TYPE(type, warn, "string ")
17899  break;
17900 
17901  case NODE_DREGX:
17902  if (!e_option_supplied(p)) SWITCH_BY_COND_TYPE(type, warning, "regex ")
17903 
17904  return NEW_MATCH2(node, NEW_GVAR(idLASTLINE, loc), loc);
17905 
17906  case NODE_AND:
17907  case NODE_OR:
17908  node->nd_1st = cond0(p, node->nd_1st, COND_IN_COND, loc);
17909  node->nd_2nd = cond0(p, node->nd_2nd, COND_IN_COND, loc);
17910  break;
17911 
17912  case NODE_DOT2:
17913  case NODE_DOT3:
17914  node->nd_beg = range_op(p, node->nd_beg, loc);
17915  node->nd_end = range_op(p, node->nd_end, loc);
17916  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
17917  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
17918  break;
17919 
17920  case NODE_DSYM:
17921  SWITCH_BY_COND_TYPE(type, warning, "string ")
17922  break;
17923 
17924  case NODE_LIT:
17925  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
17926  if (!e_option_supplied(p)) SWITCH_BY_COND_TYPE(type, warn, "regex ")
17927  nd_set_type(node, NODE_MATCH);
17928  }
17929  else if (node->nd_lit == Qtrue ||
17930  node->nd_lit == Qfalse) {
17931  /* booleans are OK, e.g., while true */
17932  }
17933  else {
17934  SWITCH_BY_COND_TYPE(type, warning, "")
17935  }
17936  default:
17937  break;
17938  }
17939  return node;
17940 }
17941 
17942 static NODE*
17943 cond(struct parser_params *p, NODE *node, const YYLTYPE *loc)
17944 {
17945  if (node == 0) return 0;
17946  return cond0(p, node, COND_IN_COND, loc);
17947 }
17948 
17949 static NODE*
17950 method_cond(struct parser_params *p, NODE *node, const YYLTYPE *loc)
17951 {
17952  if (node == 0) return 0;
17953  return cond0(p, node, COND_IN_OP, loc);
17954 }
17955 
17956 static NODE*
17957 new_if(struct parser_params *p, NODE *cc, NODE *left, NODE *right, const YYLTYPE *loc)
17958 {
17959  if (!cc) return right;
17960  cc = cond0(p, cc, COND_IN_COND, loc);
17961  return newline_node(NEW_IF(cc, left, right, loc));
17962 }
17963 
17964 static NODE*
17965 new_unless(struct parser_params *p, NODE *cc, NODE *left, NODE *right, const YYLTYPE *loc)
17966 {
17967  if (!cc) return right;
17968  cc = cond0(p, cc, COND_IN_COND, loc);
17969  return newline_node(NEW_UNLESS(cc, left, right, loc));
17970 }
17971 
17972 static NODE*
17973 logop(struct parser_params *p, ID id, NODE *left, NODE *right,
17974  const YYLTYPE *op_loc, const YYLTYPE *loc)
17975 {
17976  enum node_type type = id == idAND || id == idANDOP ? NODE_AND : NODE_OR;
17977  NODE *op;
17978  value_expr(left);
17979  if (left && (enum node_type)nd_type(left) == type) {
17980  NODE *node = left, *second;
17981  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
17982  node = second;
17983  }
17984  node->nd_2nd = NEW_NODE(type, second, right, 0, loc);
17985  nd_set_line(node->nd_2nd, op_loc->beg_pos.lineno);
17986  left->nd_loc.end_pos = loc->end_pos;
17987  return left;
17988  }
17989  op = NEW_NODE(type, left, right, 0, loc);
17990  nd_set_line(op, op_loc->beg_pos.lineno);
17991  return op;
17992 }
17993 
17994 static void
17995 no_blockarg(struct parser_params *p, NODE *node)
17996 {
17997  if (node && nd_type(node) == NODE_BLOCK_PASS) {
17998  compile_error(p, "block argument should not be given");
17999  }
18000 }
18001 
18002 static NODE *
18003 ret_args(struct parser_params *p, NODE *node)
18004 {
18005  if (node) {
18006  no_blockarg(p, node);
18007  if (nd_type(node) == NODE_LIST) {
18008  if (node->nd_next == 0) {
18009  node = node->nd_head;
18010  }
18011  else {
18012  nd_set_type(node, NODE_VALUES);
18013  }
18014  }
18015  }
18016  return node;
18017 }
18018 
18019 static NODE *
18020 new_yield(struct parser_params *p, NODE *node, const YYLTYPE *loc)
18021 {
18022  if (node) no_blockarg(p, node);
18023 
18024  return NEW_YIELD(node, loc);
18025 }
18026 
18027 static VALUE
18028 negate_lit(struct parser_params *p, VALUE lit)
18029 {
18030  if (FIXNUM_P(lit)) {
18031  return LONG2FIX(-FIX2LONG(lit));
18032  }
18033  if (SPECIAL_CONST_P(lit)) {
18034 #if USE_FLONUM
18035  if (FLONUM_P(lit)) {
18036  return DBL2NUM(-RFLOAT_VALUE(lit));
18037  }
18038 #endif
18039  goto unknown;
18040  }
18041  switch (BUILTIN_TYPE(lit)) {
18042  case T_BIGNUM:
18043  BIGNUM_NEGATE(lit);
18044  lit = rb_big_norm(lit);
18045  break;
18046  case T_RATIONAL:
18047  RRATIONAL_SET_NUM(lit, negate_lit(p, RRATIONAL(lit)->num));
18048  break;
18049  case T_COMPLEX:
18050  RCOMPLEX_SET_REAL(lit, negate_lit(p, RCOMPLEX(lit)->real));
18051  RCOMPLEX_SET_IMAG(lit, negate_lit(p, RCOMPLEX(lit)->imag));
18052  break;
18053  case T_FLOAT:
18054  RFLOAT(lit)->float_value = -RFLOAT_VALUE(lit);
18055  break;
18056  unknown:
18057  default:
18058  rb_parser_fatal(p, "unknown literal type (%s) passed to negate_lit",
18059  rb_builtin_class_name(lit));
18060  break;
18061  }
18062  return lit;
18063 }
18064 
18065 static NODE *
18066 arg_blk_pass(NODE *node1, NODE *node2)
18067 {
18068  if (node2) {
18069  if (!node1) return node2;
18070  node2->nd_head = node1;
18071  nd_set_first_lineno(node2, nd_first_lineno(node1));
18072  nd_set_first_column(node2, nd_first_column(node1));
18073  return node2;
18074  }
18075  return node1;
18076 }
18077 
18078 static bool
18079 args_info_empty_p(struct rb_args_info *args)
18080 {
18081  if (args->pre_args_num) return false;
18082  if (args->post_args_num) return false;
18083  if (args->rest_arg) return false;
18084  if (args->opt_args) return false;
18085  if (args->block_arg) return false;
18086  if (args->kw_args) return false;
18087  if (args->kw_rest_arg) return false;
18088  return true;
18089 }
18090 
18091 static NODE*
18092 new_args(struct parser_params *p, NODE *pre_args, NODE *opt_args, ID rest_arg, NODE *post_args, NODE *tail, const YYLTYPE *loc)
18093 {
18094  int saved_line = p->ruby_sourceline;
18095  struct rb_args_info *args = tail->nd_ainfo;
18096 
18097  args->pre_args_num = pre_args ? rb_long2int(pre_args->nd_plen) : 0;
18098  args->pre_init = pre_args ? pre_args->nd_next : 0;
18099 
18100  args->post_args_num = post_args ? rb_long2int(post_args->nd_plen) : 0;
18101  args->post_init = post_args ? post_args->nd_next : 0;
18102  args->first_post_arg = post_args ? post_args->nd_pid : 0;
18103 
18104  args->rest_arg = rest_arg;
18105 
18106  args->opt_args = opt_args;
18107 
18108  args->ruby2_keywords = rest_arg == idFWD_REST;
18109 
18110  p->ruby_sourceline = saved_line;
18111  nd_set_loc(tail, loc);
18112 
18113  return tail;
18114 }
18115 
18116 static NODE*
18117 new_args_tail(struct parser_params *p, NODE *kw_args, ID kw_rest_arg, ID block, const YYLTYPE *loc)
18118 {
18119  int saved_line = p->ruby_sourceline;
18120  NODE *node;
18122  struct rb_args_info *args = ZALLOC(struct rb_args_info);
18123  rb_imemo_tmpbuf_set_ptr(tmpbuf, args);
18124  args->imemo = tmpbuf;
18125  node = NEW_NODE(NODE_ARGS, 0, 0, args, &NULL_LOC);
18126  RB_OBJ_WRITTEN(p->ast, Qnil, tmpbuf);
18127  if (p->error_p) return node;
18128 
18129  args->block_arg = block;
18130  args->kw_args = kw_args;
18131 
18132  if (kw_args) {
18133  /*
18134  * def foo(k1: 1, kr1:, k2: 2, **krest, &b)
18135  * variable order: k1, kr1, k2, &b, internal_id, krest
18136  * #=> <reorder>
18137  * variable order: kr1, k1, k2, internal_id, krest, &b
18138  */
18139  ID kw_bits = internal_id(p), *required_kw_vars, *kw_vars;
18140  struct vtable *vtargs = p->lvtbl->args;
18141  NODE *kwn = kw_args;
18142 
18143  vtable_pop(vtargs, !!block + !!kw_rest_arg);
18144  required_kw_vars = kw_vars = &vtargs->tbl[vtargs->pos];
18145  while (kwn) {
18146  if (!NODE_REQUIRED_KEYWORD_P(kwn->nd_body))
18147  --kw_vars;
18148  --required_kw_vars;
18149  kwn = kwn->nd_next;
18150  }
18151 
18152  for (kwn = kw_args; kwn; kwn = kwn->nd_next) {
18153  ID vid = kwn->nd_body->nd_vid;
18154  if (NODE_REQUIRED_KEYWORD_P(kwn->nd_body)) {
18155  *required_kw_vars++ = vid;
18156  }
18157  else {
18158  *kw_vars++ = vid;
18159  }
18160  }
18161 
18162  arg_var(p, kw_bits);
18163  if (kw_rest_arg) arg_var(p, kw_rest_arg);
18164  if (block) arg_var(p, block);
18165 
18166  args->kw_rest_arg = NEW_DVAR(kw_rest_arg, loc);
18167  args->kw_rest_arg->nd_cflag = kw_bits;
18168  }
18169  else if (kw_rest_arg == idNil) {
18170  args->no_kwarg = 1;
18171  }
18172  else if (kw_rest_arg) {
18173  args->kw_rest_arg = NEW_DVAR(kw_rest_arg, loc);
18174  }
18175 
18176  p->ruby_sourceline = saved_line;
18177  return node;
18178 }
18179 
18180 static NODE *
18181 args_with_numbered(struct parser_params *p, NODE *args, int max_numparam)
18182 {
18183  if (max_numparam > NO_PARAM) {
18184  if (!args) {
18185  YYLTYPE loc = RUBY_INIT_YYLLOC();
18186  args = new_args_tail(p, 0, 0, 0, 0);
18187  nd_set_loc(args, &loc);
18188  }
18189  args->nd_ainfo->pre_args_num = max_numparam;
18190  }
18191  return args;
18192 }
18193 
18194 static NODE*
18195 new_array_pattern(struct parser_params *p, NODE *constant, NODE *pre_arg, NODE *aryptn, const YYLTYPE *loc)
18196 {
18197  struct rb_ary_pattern_info *apinfo = aryptn->nd_apinfo;
18198 
18199  aryptn->nd_pconst = constant;
18200 
18201  if (pre_arg) {
18202  NODE *pre_args = NEW_LIST(pre_arg, loc);
18203  if (apinfo->pre_args) {
18204  apinfo->pre_args = list_concat(pre_args, apinfo->pre_args);
18205  }
18206  else {
18207  apinfo->pre_args = pre_args;
18208  }
18209  }
18210  return aryptn;
18211 }
18212 
18213 static NODE*
18214 new_array_pattern_tail(struct parser_params *p, NODE *pre_args, int has_rest, ID rest_arg, NODE *post_args, const YYLTYPE *loc)
18215 {
18216  int saved_line = p->ruby_sourceline;
18217  NODE *node;
18219  struct rb_ary_pattern_info *apinfo = ZALLOC(struct rb_ary_pattern_info);
18220  rb_imemo_tmpbuf_set_ptr(tmpbuf, apinfo);
18221  node = NEW_NODE(NODE_ARYPTN, 0, 0, apinfo, loc);
18222  apinfo->imemo = tmpbuf;
18223  RB_OBJ_WRITTEN(p->ast, Qnil, tmpbuf);
18224 
18225  apinfo->pre_args = pre_args;
18226 
18227  if (has_rest) {
18228  if (rest_arg) {
18229  apinfo->rest_arg = assignable(p, rest_arg, 0, loc);
18230  }
18231  else {
18233  }
18234  }
18235  else {
18236  apinfo->rest_arg = NULL;
18237  }
18238 
18239  apinfo->post_args = post_args;
18240 
18241  p->ruby_sourceline = saved_line;
18242  return node;
18243 }
18244 
18245 static NODE*
18246 new_hash_pattern(struct parser_params *p, NODE *constant, NODE *hshptn, const YYLTYPE *loc)
18247 {
18248  hshptn->nd_pconst = constant;
18249  return hshptn;
18250 }
18251 
18252 static NODE*
18253 new_hash_pattern_tail(struct parser_params *p, NODE *kw_args, ID kw_rest_arg, const YYLTYPE *loc)
18254 {
18255  int saved_line = p->ruby_sourceline;
18256  NODE *node, *kw_rest_arg_node;
18257 
18258  if (kw_rest_arg == idNil) {
18259  kw_rest_arg_node = NODE_SPECIAL_NO_REST_KEYWORD;
18260  }
18261  else if (kw_rest_arg) {
18262  kw_rest_arg_node = assignable(p, kw_rest_arg, 0, loc);
18263  }
18264  else {
18265  kw_rest_arg_node = NULL;
18266  }
18267 
18268  node = NEW_NODE(NODE_HSHPTN, 0, kw_args, kw_rest_arg_node, loc);
18269 
18270  p->ruby_sourceline = saved_line;
18271  return node;
18272 }
18273 
18274 static NODE *
18275 new_case3(struct parser_params *p, NODE *val, NODE *pat, const YYLTYPE *loc)
18276 {
18277  NODE *node = NEW_CASE3(val, pat, loc);
18278 
18280  rb_warn0L(nd_line(node), "Pattern matching is experimental, and the behavior may change in future versions of Ruby!");
18281  return node;
18282 }
18283 
18284 static NODE*
18285 dsym_node(struct parser_params *p, NODE *node, const YYLTYPE *loc)
18286 {
18287  VALUE lit;
18288 
18289  if (!node) {
18290  return NEW_LIT(ID2SYM(idNULL), loc);
18291  }
18292 
18293  switch (nd_type(node)) {
18294  case NODE_DSTR:
18295  nd_set_type(node, NODE_DSYM);
18296  nd_set_loc(node, loc);
18297  break;
18298  case NODE_STR:
18299  lit = node->nd_lit;
18300  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit = ID2SYM(rb_intern_str(lit)));
18301  nd_set_type(node, NODE_LIT);
18302  nd_set_loc(node, loc);
18303  break;
18304  default:
18305  node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node, loc), loc);
18306  break;
18307  }
18308  return node;
18309 }
18310 
18311 static int
18312 append_literal_keys(st_data_t k, st_data_t v, st_data_t h)
18313 {
18314  NODE *node = (NODE *)v;
18315  NODE **result = (NODE **)h;
18316  node->nd_alen = 2;
18317  node->nd_next->nd_end = node->nd_next;
18318  node->nd_next->nd_next = 0;
18319  if (*result)
18320  list_concat(*result, node);
18321  else
18322  *result = node;
18323  return ST_CONTINUE;
18324 }
18325 
18326 static NODE *
18327 remove_duplicate_keys(struct parser_params *p, NODE *hash)
18328 {
18329  st_table *literal_keys = st_init_numtable_with_size(hash->nd_alen / 2);
18330  NODE *result = 0;
18331  rb_code_location_t loc = hash->nd_loc;
18332  while (hash && hash->nd_head && hash->nd_next) {
18333  NODE *head = hash->nd_head;
18334  NODE *value = hash->nd_next;
18335  NODE *next = value->nd_next;
18336  VALUE key = (VALUE)head;
18337  st_data_t data;
18338  if (nd_type(head) == NODE_LIT &&
18339  st_lookup(literal_keys, (key = head->nd_lit), &data)) {
18341  "key %+"PRIsVALUE" is duplicated and overwritten on line %d",
18342  head->nd_lit, nd_line(head));
18343  head = ((NODE *)data)->nd_next;
18344  head->nd_head = block_append(p, head->nd_head, value->nd_head);
18345  }
18346  else {
18347  st_insert(literal_keys, (st_data_t)key, (st_data_t)hash);
18348  }
18349  hash = next;
18350  }
18351  st_foreach(literal_keys, append_literal_keys, (st_data_t)&result);
18352  st_free_table(literal_keys);
18353  if (hash) {
18354  if (!result) result = hash;
18355  else list_concat(result, hash);
18356  }
18357  result->nd_loc = loc;
18358  return result;
18359 }
18360 
18361 static NODE *
18362 new_hash(struct parser_params *p, NODE *hash, const YYLTYPE *loc)
18363 {
18364  if (hash) hash = remove_duplicate_keys(p, hash);
18365  return NEW_HASH(hash, loc);
18366 }
18367 #endif
18368 
18369 static void
18370 error_duplicate_pattern_variable(struct parser_params *p, ID id, const YYLTYPE *loc)
18371 {
18372  if (is_private_local_id(id)) {
18373  return;
18374  }
18375  if (st_is_member(p->pvtbl, id)) {
18376  yyerror1(loc, "duplicated variable name");
18377  }
18378  else {
18379  st_insert(p->pvtbl, (st_data_t)id, 0);
18380  }
18381 }
18382 
18383 static void
18384 error_duplicate_pattern_key(struct parser_params *p, VALUE key, const YYLTYPE *loc)
18385 {
18386  if (!p->pktbl) {
18387  p->pktbl = st_init_numtable();
18388  }
18389  else if (st_is_member(p->pktbl, key)) {
18390  yyerror1(loc, "duplicated key name");
18391  return;
18392  }
18393  st_insert(p->pktbl, (st_data_t)key, 0);
18394 }
18395 
18396 #ifndef RIPPER
18397 static NODE *
18398 new_unique_key_hash(struct parser_params *p, NODE *hash, const YYLTYPE *loc)
18399 {
18400  return NEW_HASH(hash, loc);
18401 }
18402 #endif /* !RIPPER */
18403 
18404 #ifndef RIPPER
18405 static NODE *
18406 new_op_assign(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *loc)
18407 {
18408  NODE *asgn;
18409 
18410  if (lhs) {
18411  ID vid = lhs->nd_vid;
18412  YYLTYPE lhs_loc = lhs->nd_loc;
18413  if (op == tOROP) {
18414  lhs->nd_value = rhs;
18415  nd_set_loc(lhs, loc);
18416  asgn = NEW_OP_ASGN_OR(gettable(p, vid, &lhs_loc), lhs, loc);
18417  if (is_notop_id(vid)) {
18418  switch (id_type(vid)) {
18419  case ID_GLOBAL:
18420  case ID_INSTANCE:
18421  case ID_CLASS:
18422  asgn->nd_aid = vid;
18423  }
18424  }
18425  }
18426  else if (op == tANDOP) {
18427  lhs->nd_value = rhs;
18428  nd_set_loc(lhs, loc);
18429  asgn = NEW_OP_ASGN_AND(gettable(p, vid, &lhs_loc), lhs, loc);
18430  }
18431  else {
18432  asgn = lhs;
18433  asgn->nd_value = NEW_CALL(gettable(p, vid, &lhs_loc), op, NEW_LIST(rhs, &rhs->nd_loc), loc);
18434  nd_set_loc(asgn, loc);
18435  }
18436  }
18437  else {
18438  asgn = NEW_BEGIN(0, loc);
18439  }
18440  return asgn;
18441 }
18442 
18443 static NODE *
18444 new_ary_op_assign(struct parser_params *p, NODE *ary,
18445  NODE *args, ID op, NODE *rhs, const YYLTYPE *args_loc, const YYLTYPE *loc)
18446 {
18447  NODE *asgn;
18448 
18449  args = make_list(args, args_loc);
18450  if (nd_type(args) == NODE_BLOCK_PASS) {
18451  args = NEW_ARGSCAT(args, rhs, loc);
18452  }
18453  else {
18454  args = arg_concat(p, args, rhs, loc);
18455  }
18456  asgn = NEW_OP_ASGN1(ary, op, args, loc);
18457  fixpos(asgn, ary);
18458  return asgn;
18459 }
18460 
18461 static NODE *
18462 new_attr_op_assign(struct parser_params *p, NODE *lhs,
18463  ID atype, ID attr, ID op, NODE *rhs, const YYLTYPE *loc)
18464 {
18465  NODE *asgn;
18466 
18467  asgn = NEW_OP_ASGN2(lhs, CALL_Q_P(atype), attr, op, rhs, loc);
18468  fixpos(asgn, lhs);
18469  return asgn;
18470 }
18471 
18472 static NODE *
18473 new_const_op_assign(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *loc)
18474 {
18475  NODE *asgn;
18476 
18477  if (lhs) {
18478  asgn = NEW_OP_CDECL(lhs, op, rhs, loc);
18479  }
18480  else {
18481  asgn = NEW_BEGIN(0, loc);
18482  }
18483  fixpos(asgn, lhs);
18484  return asgn;
18485 }
18486 
18487 static NODE *
18488 const_decl(struct parser_params *p, NODE *path, const YYLTYPE *loc)
18489 {
18490  if (p->in_def) {
18491  yyerror1(loc, "dynamic constant assignment");
18492  }
18493  return NEW_CDECL(0, 0, (path), loc);
18494 }
18495 #else
18496 static VALUE
18497 const_decl(struct parser_params *p, VALUE path)
18498 {
18499  if (p->in_def) {
18500  path = dispatch1(assign_error, path);
18501  ripper_error(p);
18502  }
18503  return path;
18504 }
18505 
18506 static VALUE
18507 assign_error(struct parser_params *p, VALUE a)
18508 {
18509  a = dispatch1(assign_error, a);
18510  ripper_error(p);
18511  return a;
18512 }
18513 
18514 static VALUE
18515 var_field(struct parser_params *p, VALUE a)
18516 {
18517  return ripper_new_yylval(p, get_id(a), dispatch1(var_field, a), 0);
18518 }
18519 #endif
18520 
18521 #ifndef RIPPER
18522 static NODE *
18523 new_bodystmt(struct parser_params *p, NODE *head, NODE *rescue, NODE *rescue_else, NODE *ensure, const YYLTYPE *loc)
18524 {
18525  NODE *result = head;
18526  if (rescue) {
18527  NODE *tmp = rescue_else ? rescue_else : rescue;
18528  YYLTYPE rescue_loc = code_loc_gen(&head->nd_loc, &tmp->nd_loc);
18529 
18530  result = NEW_RESCUE(head, rescue, rescue_else, &rescue_loc);
18531  nd_set_line(result, rescue->nd_loc.beg_pos.lineno);
18532  }
18533  else if (rescue_else) {
18534  result = block_append(p, result, rescue_else);
18535  }
18536  if (ensure) {
18537  result = NEW_ENSURE(result, ensure, loc);
18538  }
18539  fixpos(result, head);
18540  return result;
18541 }
18542 #endif
18543 
18544 static void
18545 warn_unused_var(struct parser_params *p, struct local_vars *local)
18546 {
18547  int cnt;
18548 
18549  if (!local->used) return;
18550  cnt = local->used->pos;
18551  if (cnt != local->vars->pos) {
18552  rb_parser_fatal(p, "local->used->pos != local->vars->pos");
18553  }
18554 #ifndef RIPPER
18555  ID *v = local->vars->tbl;
18556  ID *u = local->used->tbl;
18557  for (int i = 0; i < cnt; ++i) {
18558  if (!v[i] || (u[i] & LVAR_USED)) continue;
18559  if (is_private_local_id(v[i])) continue;
18560  rb_warn1L((int)u[i], "assigned but unused variable - %"PRIsWARN, rb_id2str(v[i]));
18561  }
18562 #endif
18563 }
18564 
18565 static void
18566 local_push(struct parser_params *p, int toplevel_scope)
18567 {
18568  struct local_vars *local;
18569  int inherits_dvars = toplevel_scope && compile_for_eval;
18570  int warn_unused_vars = RTEST(ruby_verbose);
18571 
18572  local = ALLOC(struct local_vars);
18573  local->prev = p->lvtbl;
18574  local->args = vtable_alloc(0);
18575  local->vars = vtable_alloc(inherits_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
18576 #ifndef RIPPER
18577  if (toplevel_scope && compile_for_eval) warn_unused_vars = 0;
18578  if (toplevel_scope && e_option_supplied(p)) warn_unused_vars = 0;
18579  local->numparam.outer = 0;
18580  local->numparam.inner = 0;
18581  local->numparam.current = 0;
18582 #endif
18583  local->used = warn_unused_vars ? vtable_alloc(0) : 0;
18584 
18585 # if WARN_PAST_SCOPE
18586  local->past = 0;
18587 # endif
18588  CMDARG_PUSH(0);
18589  COND_PUSH(0);
18590  p->lvtbl = local;
18591 }
18592 
18593 static void
18594 local_pop(struct parser_params *p)
18595 {
18596  struct local_vars *local = p->lvtbl->prev;
18597  if (p->lvtbl->used) {
18598  warn_unused_var(p, p->lvtbl);
18599  vtable_free(p->lvtbl->used);
18600  }
18601 # if WARN_PAST_SCOPE
18602  while (p->lvtbl->past) {
18603  struct vtable *past = p->lvtbl->past;
18604  p->lvtbl->past = past->prev;
18605  vtable_free(past);
18606  }
18607 # endif
18608  vtable_free(p->lvtbl->args);
18609  vtable_free(p->lvtbl->vars);
18610  CMDARG_POP();
18611  COND_POP();
18612  ruby_sized_xfree(p->lvtbl, sizeof(*p->lvtbl));
18613  p->lvtbl = local;
18614 }
18615 
18616 #ifndef RIPPER
18617 static ID*
18618 local_tbl(struct parser_params *p)
18619 {
18620  int cnt_args = vtable_size(p->lvtbl->args);
18621  int cnt_vars = vtable_size(p->lvtbl->vars);
18622  int cnt = cnt_args + cnt_vars;
18623  int i, j;
18624  ID *buf;
18625  VALUE tbl = 0;
18626 
18627  if (cnt <= 0) return 0;
18629  buf = ALLOC_N(ID, cnt + 2);
18630  rb_imemo_tmpbuf_set_ptr(tbl, buf);
18631  MEMCPY(buf+1, p->lvtbl->args->tbl, ID, cnt_args);
18632  /* remove IDs duplicated to warn shadowing */
18633  for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
18634  ID id = p->lvtbl->vars->tbl[i];
18635  if (!vtable_included(p->lvtbl->args, id)) {
18636  buf[j++] = id;
18637  }
18638  }
18639  if (--j < cnt) {
18640  REALLOC_N(buf, ID, (cnt = j) + 2);
18641  rb_imemo_tmpbuf_set_ptr(tbl, buf);
18642  }
18643  buf[0] = cnt;
18644  buf[cnt + 1] = (ID)tbl;
18645  RB_OBJ_WRITTEN(p->ast, Qnil, tbl);
18646 
18647  return buf;
18648 }
18649 
18650 static NODE*
18651 node_newnode_with_locals(struct parser_params *p, enum node_type type, VALUE a1, VALUE a2, const rb_code_location_t *loc)
18652 {
18653  ID *a0;
18654  NODE *n;
18655 
18656  a0 = local_tbl(p);
18657  n = NEW_NODE(type, a0, a1, a2, loc);
18658  return n;
18659 }
18660 
18661 #endif
18662 
18663 static void
18664 numparam_name(struct parser_params *p, ID id)
18665 {
18666  if (!NUMPARAM_ID_P(id)) return;
18667  rb_warn1("`_%d' is reserved for numbered parameter; consider another name",
18668  WARN_I(NUMPARAM_ID_TO_IDX(id)));
18669 }
18670 
18671 static void
18672 arg_var(struct parser_params *p, ID id)
18673 {
18674  numparam_name(p, id);
18675  vtable_add(p->lvtbl->args, id);
18676 }
18677 
18678 static void
18679 local_var(struct parser_params *p, ID id)
18680 {
18681  numparam_name(p, id);
18682  vtable_add(p->lvtbl->vars, id);
18683  if (p->lvtbl->used) {
18685  }
18686 }
18687 
18688 static int
18689 local_id_ref(struct parser_params *p, ID id, ID **vidrefp)
18690 {
18691  struct vtable *vars, *args, *used;
18692 
18693  vars = p->lvtbl->vars;
18694  args = p->lvtbl->args;
18695  used = p->lvtbl->used;
18696 
18697  while (vars && !DVARS_TERMINAL_P(vars->prev)) {
18698  vars = vars->prev;
18699  args = args->prev;
18700  if (used) used = used->prev;
18701  }
18702 
18703  if (vars && vars->prev == DVARS_INHERIT) {
18704  return rb_local_defined(id, p->parent_iseq);
18705  }
18706  else if (vtable_included(args, id)) {
18707  return 1;
18708  }
18709  else {
18710  int i = vtable_included(vars, id);
18711  if (i && used && vidrefp) *vidrefp = &used->tbl[i-1];
18712  return i != 0;
18713  }
18714 }
18715 
18716 static int
18717 local_id(struct parser_params *p, ID id)
18718 {
18719  return local_id_ref(p, id, NULL);
18720 }
18721 
18722 static NODE *
18723 numparam_push(struct parser_params *p)
18724 {
18725 #ifndef RIPPER
18726  struct local_vars *local = p->lvtbl;
18727  NODE *inner = local->numparam.inner;
18728  if (!local->numparam.outer) {
18729  local->numparam.outer = local->numparam.current;
18730  }
18731  local->numparam.inner = 0;
18732  local->numparam.current = 0;
18733  return inner;
18734 #else
18735  return 0;
18736 #endif
18737 }
18738 
18739 static void
18740 numparam_pop(struct parser_params *p, NODE *prev_inner)
18741 {
18742 #ifndef RIPPER
18743  struct local_vars *local = p->lvtbl;
18744  if (prev_inner) {
18745  /* prefer first one */
18746  local->numparam.inner = prev_inner;
18747  }
18748  else if (local->numparam.current) {
18749  /* current and inner are exclusive */
18750  local->numparam.inner = local->numparam.current;
18751  }
18752  if (p->max_numparam > NO_PARAM) {
18753  /* current and outer are exclusive */
18754  local->numparam.current = local->numparam.outer;
18755  local->numparam.outer = 0;
18756  }
18757  else {
18758  /* no numbered parameter */
18759  local->numparam.current = 0;
18760  }
18761 #endif
18762 }
18763 
18764 static const struct vtable *
18765 dyna_push(struct parser_params *p)
18766 {
18767  p->lvtbl->args = vtable_alloc(p->lvtbl->args);
18768  p->lvtbl->vars = vtable_alloc(p->lvtbl->vars);
18769  if (p->lvtbl->used) {
18770  p->lvtbl->used = vtable_alloc(p->lvtbl->used);
18771  }
18772  return p->lvtbl->args;
18773 }
18774 
18775 static void
18776 dyna_pop_vtable(struct parser_params *p, struct vtable **vtblp)
18777 {
18778  struct vtable *tmp = *vtblp;
18779  *vtblp = tmp->prev;
18780 # if WARN_PAST_SCOPE
18781  if (p->past_scope_enabled) {
18782  tmp->prev = p->lvtbl->past;
18783  p->lvtbl->past = tmp;
18784  return;
18785  }
18786 # endif
18787  vtable_free(tmp);
18788 }
18789 
18790 static void
18791 dyna_pop_1(struct parser_params *p)
18792 {
18793  struct vtable *tmp;
18794 
18795  if ((tmp = p->lvtbl->used) != 0) {
18796  warn_unused_var(p, p->lvtbl);
18797  p->lvtbl->used = p->lvtbl->used->prev;
18798  vtable_free(tmp);
18799  }
18800  dyna_pop_vtable(p, &p->lvtbl->args);
18801  dyna_pop_vtable(p, &p->lvtbl->vars);
18802 }
18803 
18804 static void
18805 dyna_pop(struct parser_params *p, const struct vtable *lvargs)
18806 {
18807  while (p->lvtbl->args != lvargs) {
18808  dyna_pop_1(p);
18809  if (!p->lvtbl->args) {
18810  struct local_vars *local = p->lvtbl->prev;
18811  ruby_sized_xfree(p->lvtbl, sizeof(*p->lvtbl));
18812  p->lvtbl = local;
18813  }
18814  }
18815  dyna_pop_1(p);
18816 }
18817 
18818 static int
18819 dyna_in_block(struct parser_params *p)
18820 {
18821  return !DVARS_TERMINAL_P(p->lvtbl->vars) && p->lvtbl->vars->prev != DVARS_TOPSCOPE;
18822 }
18823 
18824 static int
18825 dvar_defined_ref(struct parser_params *p, ID id, ID **vidrefp)
18826 {
18827  struct vtable *vars, *args, *used;
18828  int i;
18829 
18830  args = p->lvtbl->args;
18831  vars = p->lvtbl->vars;
18832  used = p->lvtbl->used;
18833 
18834  while (!DVARS_TERMINAL_P(vars)) {
18835  if (vtable_included(args, id)) {
18836  return 1;
18837  }
18838  if ((i = vtable_included(vars, id)) != 0) {
18839  if (used && vidrefp) *vidrefp = &used->tbl[i-1];
18840  return 1;
18841  }
18842  args = args->prev;
18843  vars = vars->prev;
18844  if (!vidrefp) used = 0;
18845  if (used) used = used->prev;
18846  }
18847 
18848  if (vars == DVARS_INHERIT) {
18849  return rb_dvar_defined(id, p->parent_iseq);
18850  }
18851 
18852  return 0;
18853 }
18854 
18855 static int
18856 dvar_defined(struct parser_params *p, ID id)
18857 {
18858  return dvar_defined_ref(p, id, NULL);
18859 }
18860 
18861 static int
18862 dvar_curr(struct parser_params *p, ID id)
18863 {
18864  return (vtable_included(p->lvtbl->args, id) ||
18865  vtable_included(p->lvtbl->vars, id));
18866 }
18867 
18868 static void
18869 reg_fragment_enc_error(struct parser_params* p, VALUE str, int c)
18870 {
18871  compile_error(p,
18872  "regexp encoding option '%c' differs from source encoding '%s'",
18873  c, rb_enc_name(rb_enc_get(str)));
18874 }
18875 
18876 #ifndef RIPPER
18877 int
18879 {
18880  int c = RE_OPTION_ENCODING_IDX(options);
18881 
18882  if (c) {
18883  int opt, idx;
18884  rb_char_to_option_kcode(c, &opt, &idx);
18885  if (idx != ENCODING_GET(str) &&
18887  goto error;
18888  }
18889  ENCODING_SET(str, idx);
18890  }
18891  else if (RE_OPTION_ENCODING_NONE(options)) {
18892  if (!ENCODING_IS_ASCII8BIT(str) &&
18894  c = 'n';
18895  goto error;
18896  }
18898  }
18899  else if (p->enc == rb_usascii_encoding()) {
18901  /* raise in re.c */
18903  }
18904  else {
18906  }
18907  }
18908  return 0;
18909 
18910  error:
18911  return c;
18912 }
18913 
18914 static void
18915 reg_fragment_setenc(struct parser_params* p, VALUE str, int options)
18916 {
18917  int c = rb_reg_fragment_setenc(p, str, options);
18918  if (c) reg_fragment_enc_error(p, str, c);
18919 }
18920 
18921 static int
18922 reg_fragment_check(struct parser_params* p, VALUE str, int options)
18923 {
18924  VALUE err;
18925  reg_fragment_setenc(p, str, options);
18927  if (err != Qnil) {
18929  compile_error(p, "%"PRIsVALUE, err);
18930  return 0;
18931  }
18932  return 1;
18933 }
18934 
18935 typedef struct {
18939  const YYLTYPE *loc;
18941 
18942 static int
18943 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
18944  int back_num, int *back_refs, OnigRegex regex, void *arg0)
18945 {
18947  struct parser_params* p = arg->parser;
18948  rb_encoding *enc = arg->enc;
18949  long len = name_end - name;
18950  const char *s = (const char *)name;
18951  ID var;
18952  NODE *node, *succ;
18953 
18954  if (!len) return ST_CONTINUE;
18955  if (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len))
18956  return ST_CONTINUE;
18957  if (rb_enc_symname_type(s, len, enc, (1U<<ID_LOCAL)) != ID_LOCAL)
18958  return ST_CONTINUE;
18959 
18960  var = intern_cstr(s, len, enc);
18961  node = node_assign(p, assignable(p, var, 0, arg->loc), NEW_LIT(ID2SYM(var), arg->loc), arg->loc);
18962  succ = arg->succ_block;
18963  if (!succ) succ = NEW_BEGIN(0, arg->loc);
18964  succ = block_append(p, succ, node);
18965  arg->succ_block = succ;
18966  return ST_CONTINUE;
18967 }
18968 
18969 static NODE *
18970 reg_named_capture_assign(struct parser_params* p, VALUE regexp, const YYLTYPE *loc)
18971 {
18973 
18974  arg.parser = p;
18975  arg.enc = rb_enc_get(regexp);
18976  arg.succ_block = 0;
18977  arg.loc = loc;
18978  onig_foreach_name(RREGEXP_PTR(regexp), reg_named_capture_assign_iter, &arg);
18979 
18980  if (!arg.succ_block) return 0;
18981  return arg.succ_block->nd_next;
18982 }
18983 
18984 static VALUE
18985 parser_reg_compile(struct parser_params* p, VALUE str, int options)
18986 {
18987  reg_fragment_setenc(p, str, options);
18988  return rb_parser_reg_compile(p, str, options);
18989 }
18990 
18991 VALUE
18993 {
18995 }
18996 
18997 static VALUE
18998 reg_compile(struct parser_params* p, VALUE str, int options)
18999 {
19000  VALUE re;
19001  VALUE err;
19002 
19003  err = rb_errinfo();
19004  re = parser_reg_compile(p, str, options);
19005  if (NIL_P(re)) {
19008  compile_error(p, "%"PRIsVALUE, m);
19009  return Qnil;
19010  }
19011  return re;
19012 }
19013 #else
19014 static VALUE
19015 parser_reg_compile(struct parser_params* p, VALUE str, int options, VALUE *errmsg)
19016 {
19017  VALUE err = rb_errinfo();
19018  VALUE re;
19019  str = ripper_is_node_yylval(str) ? RNODE(str)->nd_cval : str;
19020  int c = rb_reg_fragment_setenc(p, str, options);
19021  if (c) reg_fragment_enc_error(p, str, c);
19022  re = rb_parser_reg_compile(p, str, options);
19023  if (NIL_P(re)) {
19024  *errmsg = rb_attr_get(rb_errinfo(), idMesg);
19026  }
19027  return re;
19028 }
19029 #endif
19030 
19031 #ifndef RIPPER
19032 void
19033 rb_parser_set_options(VALUE vparser, int print, int loop, int chomp, int split)
19034 {
19035  struct parser_params *p;
19036  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19037  p->do_print = print;
19038  p->do_loop = loop;
19039  p->do_chomp = chomp;
19040  p->do_split = split;
19041 }
19042 
19043 void
19044 rb_parser_warn_location(VALUE vparser, int warn)
19045 {
19046  struct parser_params *p;
19047  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19048  p->warn_location = warn;
19049 }
19050 
19051 static NODE *
19052 parser_append_options(struct parser_params *p, NODE *node)
19053 {
19054  static const YYLTYPE default_location = {{1, 0}, {1, 0}};
19055  const YYLTYPE *const LOC = &default_location;
19056 
19057  if (p->do_print) {
19058  NODE *print = NEW_FCALL(rb_intern("print"),
19059  NEW_LIST(NEW_GVAR(idLASTLINE, LOC), LOC),
19060  LOC);
19061  node = block_append(p, node, print);
19062  }
19063 
19064  if (p->do_loop) {
19065  if (p->do_split) {
19066  NODE *args = NEW_LIST(NEW_GVAR(rb_intern("$;"), LOC), LOC);
19067  NODE *split = NEW_GASGN(rb_intern("$F"),
19069  rb_intern("split"), args, LOC),
19070  LOC);
19071  node = block_append(p, split, node);
19072  }
19073  if (p->do_chomp) {
19074  NODE *chomp = NEW_CALL(NEW_GVAR(idLASTLINE, LOC),
19075  rb_intern("chomp!"), 0, LOC);
19076  node = block_append(p, chomp, node);
19077  }
19078 
19079  node = NEW_WHILE(NEW_VCALL(idGets, LOC), node, 1, LOC);
19080  }
19081 
19082  return node;
19083 }
19084 
19085 void
19087 {
19088  /* just to suppress unused-function warnings */
19089  (void)nodetype;
19090  (void)nodeline;
19091 }
19092 
19093 static ID
19094 internal_id(struct parser_params *p)
19095 {
19096  const ID max_id = RB_ID_SERIAL_MAX & ~0xffff;
19097  ID id = (ID)vtable_size(p->lvtbl->args) + (ID)vtable_size(p->lvtbl->vars);
19098  id = max_id - id;
19099  return ID_STATIC_SYM | ID_INTERNAL | (id << ID_SCOPE_SHIFT);
19100 }
19101 #endif /* !RIPPER */
19102 
19103 static void
19104 parser_initialize(struct parser_params *p)
19105 {
19106  /* note: we rely on TypedData_Make_Struct to set most fields to 0 */
19107  p->command_start = TRUE;
19109  p->lex.lpar_beg = -1; /* make lambda_beginning_p() == FALSE at first */
19110  p->node_id = 0;
19111 #ifdef RIPPER
19112  p->delayed.token = Qnil;
19113  p->result = Qnil;
19114  p->parsing_thread = Qnil;
19115 #else
19116  p->error_buffer = Qfalse;
19117 #endif
19118  p->debug_buffer = Qnil;
19119  p->debug_output = rb_stdout;
19120  p->enc = rb_utf8_encoding();
19121 }
19122 
19123 #ifdef RIPPER
19124 #define parser_mark ripper_parser_mark
19125 #define parser_free ripper_parser_free
19126 #endif
19127 
19128 static void
19129 parser_mark(void *ptr)
19130 {
19131  struct parser_params *p = (struct parser_params*)ptr;
19132 
19133  rb_gc_mark(p->lex.input);
19134  rb_gc_mark(p->lex.prevline);
19135  rb_gc_mark(p->lex.lastline);
19136  rb_gc_mark(p->lex.nextline);
19138  rb_gc_mark((VALUE)p->lex.strterm);
19139  rb_gc_mark((VALUE)p->ast);
19140  rb_gc_mark(p->case_labels);
19141 #ifndef RIPPER
19142  rb_gc_mark(p->debug_lines);
19145 #else
19146  rb_gc_mark(p->delayed.token);
19147  rb_gc_mark(p->value);
19148  rb_gc_mark(p->result);
19149  rb_gc_mark(p->parsing_thread);
19150 #endif
19153 #ifdef YYMALLOC
19154  rb_gc_mark((VALUE)p->heap);
19155 #endif
19156 }
19157 
19158 static void
19159 parser_free(void *ptr)
19160 {
19161  struct parser_params *p = (struct parser_params*)ptr;
19162  struct local_vars *local, *prev;
19163 
19164  if (p->tokenbuf) {
19166  }
19167  for (local = p->lvtbl; local; local = prev) {
19168  if (local->vars) xfree(local->vars);
19169  prev = local->prev;
19170  xfree(local);
19171  }
19172  {
19173  token_info *ptinfo;
19174  while ((ptinfo = p->token_info) != 0) {
19175  p->token_info = ptinfo->next;
19176  xfree(ptinfo);
19177  }
19178  }
19179  xfree(ptr);
19180 }
19181 
19182 static size_t
19183 parser_memsize(const void *ptr)
19184 {
19185  struct parser_params *p = (struct parser_params*)ptr;
19186  struct local_vars *local;
19187  size_t size = sizeof(*p);
19188 
19189  size += p->toksiz;
19190  for (local = p->lvtbl; local; local = local->prev) {
19191  size += sizeof(*local);
19192  if (local->vars) size += local->vars->capa * sizeof(ID);
19193  }
19194  return size;
19195 }
19196 
19197 static const rb_data_type_t parser_data_type = {
19198 #ifndef RIPPER
19199  "parser",
19200 #else
19201  "ripper",
19202 #endif
19203  {
19204  parser_mark,
19205  parser_free,
19206  parser_memsize,
19207  },
19209 };
19210 
19211 #ifndef RIPPER
19212 #undef rb_reserved_word
19213 
19214 const struct kwtable *
19215 rb_reserved_word(const char *str, unsigned int len)
19216 {
19217  return reserved_word(str, len);
19218 }
19219 
19220 VALUE
19222 {
19223  struct parser_params *p;
19224  VALUE parser = TypedData_Make_Struct(0, struct parser_params,
19225  &parser_data_type, p);
19226  parser_initialize(p);
19227  return parser;
19228 }
19229 
19230 VALUE
19231 rb_parser_set_context(VALUE vparser, const struct rb_iseq_struct *base, int main)
19232 {
19233  struct parser_params *p;
19234 
19235  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19236  p->error_buffer = main ? Qfalse : Qnil;
19237  p->parent_iseq = base;
19238  return vparser;
19239 }
19240 #endif
19241 
19242 #ifdef RIPPER
19243 #define rb_parser_end_seen_p ripper_parser_end_seen_p
19244 #define rb_parser_encoding ripper_parser_encoding
19245 #define rb_parser_get_yydebug ripper_parser_get_yydebug
19246 #define rb_parser_set_yydebug ripper_parser_set_yydebug
19247 #define rb_parser_get_debug_output ripper_parser_get_debug_output
19248 #define rb_parser_set_debug_output ripper_parser_set_debug_output
19249 static VALUE ripper_parser_end_seen_p(VALUE vparser);
19250 static VALUE ripper_parser_encoding(VALUE vparser);
19251 static VALUE ripper_parser_get_yydebug(VALUE self);
19252 static VALUE ripper_parser_set_yydebug(VALUE self, VALUE flag);
19253 static VALUE ripper_parser_get_debug_output(VALUE self);
19254 static VALUE ripper_parser_set_debug_output(VALUE self, VALUE output);
19255 
19256 /*
19257  * call-seq:
19258  * ripper.error? -> Boolean
19259  *
19260  * Return true if parsed source has errors.
19261  */
19262 static VALUE
19263 ripper_error_p(VALUE vparser)
19264 {
19265  struct parser_params *p;
19266 
19267  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19268  return p->error_p ? Qtrue : Qfalse;
19269 }
19270 #endif
19271 
19272 /*
19273  * call-seq:
19274  * ripper.end_seen? -> Boolean
19275  *
19276  * Return true if parsed source ended by +\_\_END\_\_+.
19277  */
19278 VALUE
19280 {
19281  struct parser_params *p;
19282 
19283  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19284  return p->ruby__end__seen ? Qtrue : Qfalse;
19285 }
19286 
19287 /*
19288  * call-seq:
19289  * ripper.encoding -> encoding
19290  *
19291  * Return encoding of the source.
19292  */
19293 VALUE
19295 {
19296  struct parser_params *p;
19297 
19298  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19299  return rb_enc_from_encoding(p->enc);
19300 }
19301 
19302 #ifdef RIPPER
19303 /*
19304  * call-seq:
19305  * ripper.yydebug -> true or false
19306  *
19307  * Get yydebug.
19308  */
19309 VALUE
19310 rb_parser_get_yydebug(VALUE self)
19311 {
19312  struct parser_params *p;
19313 
19314  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19315  return p->debug ? Qtrue : Qfalse;
19316 }
19317 #endif
19318 
19319 /*
19320  * call-seq:
19321  * ripper.yydebug = flag
19322  *
19323  * Set yydebug.
19324  */
19325 VALUE
19327 {
19328  struct parser_params *p;
19329 
19330  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19331  p->debug = RTEST(flag);
19332  return flag;
19333 }
19334 
19335 /*
19336  * call-seq:
19337  * ripper.debug_output -> obj
19338  *
19339  * Get 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;
19348 }
19349 
19350 /*
19351  * call-seq:
19352  * ripper.debug_output = obj
19353  *
19354  * Set debug output.
19355  */
19356 VALUE
19358 {
19359  struct parser_params *p;
19360 
19361  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19362  return p->debug_output = output;
19363 }
19364 
19365 #ifndef RIPPER
19366 #ifdef YYMALLOC
19367 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
19368 /* Keep the order; NEWHEAP then xmalloc and ADD2HEAP to get rid of
19369  * potential memory leak */
19370 #define NEWHEAP() rb_imemo_tmpbuf_parser_heap(0, p->heap, 0)
19371 #define ADD2HEAP(new, cnt, ptr) ((p->heap = (new))->ptr = (ptr), \
19372  (new)->cnt = (cnt), (ptr))
19373 
19374 void *
19376 {
19377  size_t cnt = HEAPCNT(1, size);
19379  void *ptr = xmalloc(size);
19380 
19381  return ADD2HEAP(n, cnt, ptr);
19382 }
19383 
19384 void *
19385 rb_parser_calloc(struct parser_params *p, size_t nelem, size_t size)
19386 {
19387  size_t cnt = HEAPCNT(nelem, size);
19389  void *ptr = xcalloc(nelem, size);
19390 
19391  return ADD2HEAP(n, cnt, ptr);
19392 }
19393 
19394 void *
19395 rb_parser_realloc(struct parser_params *p, void *ptr, size_t size)
19396 {
19398  size_t cnt = HEAPCNT(1, size);
19399 
19400  if (ptr && (n = p->heap) != NULL) {
19401  do {
19402  if (n->ptr == ptr) {
19403  n->ptr = ptr = xrealloc(ptr, size);
19404  if (n->cnt) n->cnt = cnt;
19405  return ptr;
19406  }
19407  } while ((n = n->next) != NULL);
19408  }
19409  n = NEWHEAP();
19410  ptr = xrealloc(ptr, size);
19411  return ADD2HEAP(n, cnt, ptr);
19412 }
19413 
19414 void
19416 {
19417  rb_imemo_tmpbuf_t **prev = &p->heap, *n;
19418 
19419  while ((n = *prev) != NULL) {
19420  if (n->ptr == ptr) {
19421  *prev = n->next;
19423  break;
19424  }
19425  prev = &n->next;
19426  }
19427  xfree(ptr);
19428 }
19429 #endif
19430 
19431 void
19432 rb_parser_printf(struct parser_params *p, const char *fmt, ...)
19433 {
19434  va_list ap;
19435  VALUE mesg = p->debug_buffer;
19436 
19437  if (NIL_P(mesg)) p->debug_buffer = mesg = rb_str_new(0, 0);
19438  va_start(ap, fmt);
19439  rb_str_vcatf(mesg, fmt, ap);
19440  va_end(ap);
19441  if (RSTRING_END(mesg)[-1] == '\n') {
19442  rb_io_write(p->debug_output, mesg);
19443  p->debug_buffer = Qnil;
19444  }
19445 }
19446 
19447 static void
19448 parser_compile_error(struct parser_params *p, const char *fmt, ...)
19449 {
19450  va_list ap;
19451 
19453  p->error_p = 1;
19454  va_start(ap, fmt);
19455  p->error_buffer =
19458  p->ruby_sourceline,
19459  rb_long2int(p->lex.pcur - p->lex.pbeg),
19460  p->enc, fmt, ap);
19461  va_end(ap);
19462 }
19463 
19464 static size_t
19465 count_char(const char *str, int c)
19466 {
19467  int n = 0;
19468  while (str[n] == c) ++n;
19469  return n;
19470 }
19471 
19472 /*
19473  * strip enclosing double-quotes, same as the default yytnamerr except
19474  * for that single-quotes matching back-quotes do not stop stripping.
19475  *
19476  * "\"`class' keyword\"" => "`class' keyword"
19477  */
19478 RUBY_FUNC_EXPORTED size_t
19479 rb_yytnamerr(struct parser_params *p, char *yyres, const char *yystr)
19480 {
19481  YYUSE(p);
19482  if (*yystr == '"') {
19483  size_t yyn = 0, bquote = 0;
19484  const char *yyp = yystr;
19485 
19486  while (*++yyp) {
19487  switch (*yyp) {
19488  case '`':
19489  if (!bquote) {
19490  bquote = count_char(yyp+1, '`') + 1;
19491  if (yyres) memcpy(&yyres[yyn], yyp, bquote);
19492  yyn += bquote;
19493  yyp += bquote - 1;
19494  break;
19495  }
19496  goto default_char;
19497 
19498  case '\'':
19499  if (bquote && count_char(yyp+1, '\'') + 1 == bquote) {
19500  if (yyres) memcpy(yyres + yyn, yyp, bquote);
19501  yyn += bquote;
19502  yyp += bquote - 1;
19503  bquote = 0;
19504  break;
19505  }
19506  if (yyp[1] && yyp[1] != '\'' && yyp[2] == '\'') {
19507  if (yyres) memcpy(yyres + yyn, yyp, 3);
19508  yyn += 3;
19509  yyp += 2;
19510  break;
19511  }
19512  goto do_not_strip_quotes;
19513 
19514  case ',':
19515  goto do_not_strip_quotes;
19516 
19517  case '\\':
19518  if (*++yyp != '\\')
19519  goto do_not_strip_quotes;
19520  /* Fall through. */
19521  default_char:
19522  default:
19523  if (yyres)
19524  yyres[yyn] = *yyp;
19525  yyn++;
19526  break;
19527 
19528  case '"':
19529  case '\0':
19530  if (yyres)
19531  yyres[yyn] = '\0';
19532  return yyn;
19533  }
19534  }
19535  do_not_strip_quotes: ;
19536  }
19537 
19538  if (!yyres) return strlen(yystr);
19539 
19540  return (YYSIZE_T)(yystpcpy(yyres, yystr) - yyres);
19541 }
19542 #endif
19543 
19544 #ifdef RIPPER
19545 #ifdef RIPPER_DEBUG
19546 /* :nodoc: */
19547 static VALUE
19548 ripper_validate_object(VALUE self, VALUE x)
19549 {
19550  if (x == Qfalse) return x;
19551  if (x == Qtrue) return x;
19552  if (x == Qnil) return x;
19553  if (x == Qundef)
19554  rb_raise(rb_eArgError, "Qundef given");
19555  if (FIXNUM_P(x)) return x;
19556  if (SYMBOL_P(x)) return x;
19557  switch (BUILTIN_TYPE(x)) {
19558  case T_STRING:
19559  case T_OBJECT:
19560  case T_ARRAY:
19561  case T_BIGNUM:
19562  case T_FLOAT:
19563  case T_COMPLEX:
19564  case T_RATIONAL:
19565  break;
19566  case T_NODE:
19567  if (nd_type((NODE *)x) != NODE_RIPPER) {
19568  rb_raise(rb_eArgError, "NODE given: %p", (void *)x);
19569  }
19570  x = ((NODE *)x)->nd_rval;
19571  break;
19572  default:
19573  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
19574  (void *)x, rb_obj_classname(x));
19575  }
19576  if (!RBASIC_CLASS(x)) {
19577  rb_raise(rb_eArgError, "hidden ruby object: %p (%s)",
19578  (void *)x, rb_builtin_type_name(TYPE(x)));
19579  }
19580  return x;
19581 }
19582 #endif
19583 
19584 #define validate(x) ((x) = get_value(x))
19585 
19586 static VALUE
19587 ripper_dispatch0(struct parser_params *p, ID mid)
19588 {
19589  return rb_funcall(p->value, mid, 0);
19590 }
19591 
19592 static VALUE
19593 ripper_dispatch1(struct parser_params *p, ID mid, VALUE a)
19594 {
19595  validate(a);
19596  return rb_funcall(p->value, mid, 1, a);
19597 }
19598 
19599 static VALUE
19600 ripper_dispatch2(struct parser_params *p, ID mid, VALUE a, VALUE b)
19601 {
19602  validate(a);
19603  validate(b);
19604  return rb_funcall(p->value, mid, 2, a, b);
19605 }
19606 
19607 static VALUE
19608 ripper_dispatch3(struct parser_params *p, ID mid, VALUE a, VALUE b, VALUE c)
19609 {
19610  validate(a);
19611  validate(b);
19612  validate(c);
19613  return rb_funcall(p->value, mid, 3, a, b, c);
19614 }
19615 
19616 static VALUE
19617 ripper_dispatch4(struct parser_params *p, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
19618 {
19619  validate(a);
19620  validate(b);
19621  validate(c);
19622  validate(d);
19623  return rb_funcall(p->value, mid, 4, a, b, c, d);
19624 }
19625 
19626 static VALUE
19627 ripper_dispatch5(struct parser_params *p, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
19628 {
19629  validate(a);
19630  validate(b);
19631  validate(c);
19632  validate(d);
19633  validate(e);
19634  return rb_funcall(p->value, mid, 5, a, b, c, d, e);
19635 }
19636 
19637 static VALUE
19638 ripper_dispatch7(struct parser_params *p, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
19639 {
19640  validate(a);
19641  validate(b);
19642  validate(c);
19643  validate(d);
19644  validate(e);
19645  validate(f);
19646  validate(g);
19647  return rb_funcall(p->value, mid, 7, a, b, c, d, e, f, g);
19648 }
19649 
19650 static ID
19651 ripper_get_id(VALUE v)
19652 {
19653  NODE *nd;
19654  if (!RB_TYPE_P(v, T_NODE)) return 0;
19655  nd = (NODE *)v;
19656  if (nd_type(nd) != NODE_RIPPER) return 0;
19657  return nd->nd_vid;
19658 }
19659 
19660 static VALUE
19661 ripper_get_value(VALUE v)
19662 {
19663  NODE *nd;
19664  if (v == Qundef) return Qnil;
19665  if (!RB_TYPE_P(v, T_NODE)) return v;
19666  nd = (NODE *)v;
19667  if (nd_type(nd) != NODE_RIPPER) return Qnil;
19668  return nd->nd_rval;
19669 }
19670 
19671 static void
19672 ripper_error(struct parser_params *p)
19673 {
19674  p->error_p = TRUE;
19675 }
19676 
19677 static void
19678 ripper_compile_error(struct parser_params *p, const char *fmt, ...)
19679 {
19680  VALUE str;
19681  va_list args;
19682 
19683  va_start(args, fmt);
19684  str = rb_vsprintf(fmt, args);
19685  va_end(args);
19686  rb_funcall(p->value, rb_intern("compile_error"), 1, str);
19687  ripper_error(p);
19688 }
19689 
19690 static VALUE
19691 ripper_lex_get_generic(struct parser_params *p, VALUE src)
19692 {
19693  VALUE line = rb_funcallv_public(src, id_gets, 0, 0);
19694  if (!NIL_P(line) && !RB_TYPE_P(line, T_STRING)) {
19696  "gets returned %"PRIsVALUE" (expected String or nil)",
19697  rb_obj_class(line));
19698  }
19699  return line;
19700 }
19701 
19702 static VALUE
19703 ripper_lex_io_get(struct parser_params *p, VALUE src)
19704 {
19705  return rb_io_gets(src);
19706 }
19707 
19708 static VALUE
19709 ripper_s_allocate(VALUE klass)
19710 {
19711  struct parser_params *p;
19713  &parser_data_type, p);
19714  p->value = self;
19715  return self;
19716 }
19717 
19718 #define ripper_initialized_p(r) ((r)->lex.input != 0)
19719 
19720 /*
19721  * call-seq:
19722  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
19723  *
19724  * Create a new Ripper object.
19725  * _src_ must be a String, an IO, or an Object which has #gets method.
19726  *
19727  * This method does not starts parsing.
19728  * See also Ripper#parse and Ripper.parse.
19729  */
19730 static VALUE
19731 ripper_initialize(int argc, VALUE *argv, VALUE self)
19732 {
19733  struct parser_params *p;
19734  VALUE src, fname, lineno;
19735 
19736  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19737  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
19738  if (RB_TYPE_P(src, T_FILE)) {
19739  p->lex.gets = ripper_lex_io_get;
19740  }
19741  else if (rb_respond_to(src, id_gets)) {
19742  p->lex.gets = ripper_lex_get_generic;
19743  }
19744  else {
19745  StringValue(src);
19746  p->lex.gets = lex_get_str;
19747  }
19748  p->lex.input = src;
19749  p->eofp = 0;
19750  if (NIL_P(fname)) {
19751  fname = STR_NEW2("(ripper)");
19752  OBJ_FREEZE(fname);
19753  }
19754  else {
19755  StringValueCStr(fname);
19756  fname = rb_str_new_frozen(fname);
19757  }
19758  parser_initialize(p);
19759 
19760  p->ruby_sourcefile_string = fname;
19761  p->ruby_sourcefile = RSTRING_PTR(fname);
19762  p->ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
19763 
19764  return Qnil;
19765 }
19766 
19767 static VALUE
19768 ripper_parse0(VALUE parser_v)
19769 {
19770  struct parser_params *p;
19771 
19772  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, p);
19773  parser_prepare(p);
19774  p->ast = rb_ast_new();
19775  ripper_yyparse((void*)p);
19776  rb_ast_dispose(p->ast);
19777  p->ast = 0;
19778  return p->result;
19779 }
19780 
19781 static VALUE
19782 ripper_ensure(VALUE parser_v)
19783 {
19784  struct parser_params *p;
19785 
19786  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, p);
19787  p->parsing_thread = Qnil;
19788  return Qnil;
19789 }
19790 
19791 /*
19792  * call-seq:
19793  * ripper.parse
19794  *
19795  * Start parsing and returns the value of the root action.
19796  */
19797 static VALUE
19798 ripper_parse(VALUE self)
19799 {
19800  struct parser_params *p;
19801 
19802  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19803  if (!ripper_initialized_p(p)) {
19804  rb_raise(rb_eArgError, "method called for uninitialized object");
19805  }
19806  if (!NIL_P(p->parsing_thread)) {
19807  if (p->parsing_thread == rb_thread_current())
19808  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
19809  else
19810  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
19811  }
19812  p->parsing_thread = rb_thread_current();
19813  rb_ensure(ripper_parse0, self, ripper_ensure, self);
19814 
19815  return p->result;
19816 }
19817 
19818 /*
19819  * call-seq:
19820  * ripper.column -> Integer
19821  *
19822  * Return column number of current parsing line.
19823  * This number starts from 0.
19824  */
19825 static VALUE
19826 ripper_column(VALUE self)
19827 {
19828  struct parser_params *p;
19829  long col;
19830 
19831  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19832  if (!ripper_initialized_p(p)) {
19833  rb_raise(rb_eArgError, "method called for uninitialized object");
19834  }
19835  if (NIL_P(p->parsing_thread)) return Qnil;
19836  col = p->lex.ptok - p->lex.pbeg;
19837  return LONG2NUM(col);
19838 }
19839 
19840 /*
19841  * call-seq:
19842  * ripper.filename -> String
19843  *
19844  * Return current parsing filename.
19845  */
19846 static VALUE
19847 ripper_filename(VALUE self)
19848 {
19849  struct parser_params *p;
19850 
19851  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19852  if (!ripper_initialized_p(p)) {
19853  rb_raise(rb_eArgError, "method called for uninitialized object");
19854  }
19855  return p->ruby_sourcefile_string;
19856 }
19857 
19858 /*
19859  * call-seq:
19860  * ripper.lineno -> Integer
19861  *
19862  * Return line number of current parsing line.
19863  * This number starts from 1.
19864  */
19865 static VALUE
19866 ripper_lineno(VALUE self)
19867 {
19868  struct parser_params *p;
19869 
19870  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19871  if (!ripper_initialized_p(p)) {
19872  rb_raise(rb_eArgError, "method called for uninitialized object");
19873  }
19874  if (NIL_P(p->parsing_thread)) return Qnil;
19875  return INT2NUM(p->ruby_sourceline);
19876 }
19877 
19878 /*
19879  * call-seq:
19880  * ripper.state -> Integer
19881  *
19882  * Return scanner state of current token.
19883  */
19884 static VALUE
19885 ripper_state(VALUE self)
19886 {
19887  struct parser_params *p;
19888 
19889  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19890  if (!ripper_initialized_p(p)) {
19891  rb_raise(rb_eArgError, "method called for uninitialized object");
19892  }
19893  if (NIL_P(p->parsing_thread)) return Qnil;
19894  return INT2NUM(p->lex.state);
19895 }
19896 
19897 /*
19898  * call-seq:
19899  * ripper.token -> String
19900  *
19901  * Return the current token string.
19902  */
19903 static VALUE
19904 ripper_token(VALUE self)
19905 {
19906  struct parser_params *p;
19907  long pos, len;
19908 
19909  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19910  if (!ripper_initialized_p(p)) {
19911  rb_raise(rb_eArgError, "method called for uninitialized object");
19912  }
19913  if (NIL_P(p->parsing_thread)) return Qnil;
19914  pos = p->lex.ptok - p->lex.pbeg;
19915  len = p->lex.pcur - p->lex.ptok;
19916  return rb_str_subseq(p->lex.lastline, pos, len);
19917 }
19918 
19919 #ifdef RIPPER_DEBUG
19920 /* :nodoc: */
19921 static VALUE
19922 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
19923 {
19924  StringValue(msg);
19925  if (obj == Qundef) {
19926  rb_raise(rb_eArgError, "%"PRIsVALUE, msg);
19927  }
19928  return Qnil;
19929 }
19930 
19931 /* :nodoc: */
19932 static VALUE
19933 ripper_value(VALUE self, VALUE obj)
19934 {
19935  return ULONG2NUM(obj);
19936 }
19937 #endif
19938 
19939 /*
19940  * call-seq:
19941  * Ripper.lex_state_name(integer) -> string
19942  *
19943  * Returns a string representation of lex_state.
19944  */
19945 static VALUE
19946 ripper_lex_state_name(VALUE self, VALUE state)
19947 {
19949 }
19950 
19951 void
19952 Init_ripper(void)
19953 {
19954  ripper_init_eventids1();
19955  ripper_init_eventids2();
19956  id_warn = rb_intern_const("warn");
19957  id_warning = rb_intern_const("warning");
19958  id_gets = rb_intern_const("gets");
19959  id_assoc = rb_intern_const("=>");
19960 
19961  (void)yystpcpy; /* may not used in newer bison */
19962 
19963  InitVM(ripper);
19964 }
19965 
19966 void
19967 InitVM_ripper(void)
19968 {
19969  VALUE Ripper;
19970 
19971  Ripper = rb_define_class("Ripper", rb_cObject);
19972  /* version of Ripper */
19973  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
19974  rb_define_alloc_func(Ripper, ripper_s_allocate);
19975  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
19976  rb_define_method(Ripper, "parse", ripper_parse, 0);
19977  rb_define_method(Ripper, "column", ripper_column, 0);
19978  rb_define_method(Ripper, "filename", ripper_filename, 0);
19979  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
19980  rb_define_method(Ripper, "state", ripper_state, 0);
19981  rb_define_method(Ripper, "token", ripper_token, 0);
19982  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
19983  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
19984  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
19985  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
19986  rb_define_method(Ripper, "debug_output", rb_parser_get_debug_output, 0);
19987  rb_define_method(Ripper, "debug_output=", rb_parser_set_debug_output, 1);
19988  rb_define_method(Ripper, "error?", ripper_error_p, 0);
19989 #ifdef RIPPER_DEBUG
19990  rb_define_method(Ripper, "assert_Qundef", ripper_assert_Qundef, 2);
19991  rb_define_method(Ripper, "rawVALUE", ripper_value, 1);
19992  rb_define_method(Ripper, "validate_object", ripper_validate_object, 1);
19993 #endif
19994 
19995  rb_define_singleton_method(Ripper, "dedent_string", parser_dedent_string, 2);
19996  rb_define_private_method(Ripper, "dedent_string", parser_dedent_string, 2);
19997 
19998  rb_define_singleton_method(Ripper, "lex_state_name", ripper_lex_state_name, 1);
19999 
20000  /* ignore newline, +/- is a sign. */
20001  rb_define_const(Ripper, "EXPR_BEG", INT2NUM(EXPR_BEG));
20002  /* newline significant, +/- is an operator. */
20003  rb_define_const(Ripper, "EXPR_END", INT2NUM(EXPR_END));
20004  /* ditto, and unbound braces. */
20005  rb_define_const(Ripper, "EXPR_ENDARG", INT2NUM(EXPR_ENDARG));
20006  /* ditto, and unbound braces. */
20007  rb_define_const(Ripper, "EXPR_ENDFN", INT2NUM(EXPR_ENDFN));
20008  /* newline significant, +/- is an operator. */
20009  rb_define_const(Ripper, "EXPR_ARG", INT2NUM(EXPR_ARG));
20010  /* newline significant, +/- is an operator. */
20011  rb_define_const(Ripper, "EXPR_CMDARG", INT2NUM(EXPR_CMDARG));
20012  /* newline significant, +/- is an operator. */
20013  rb_define_const(Ripper, "EXPR_MID", INT2NUM(EXPR_MID));
20014  /* ignore newline, no reserved words. */
20015  rb_define_const(Ripper, "EXPR_FNAME", INT2NUM(EXPR_FNAME));
20016  /* right after `.' or `::', no reserved words. */
20017  rb_define_const(Ripper, "EXPR_DOT", INT2NUM(EXPR_DOT));
20018  /* immediate after `class', no here document. */
20019  rb_define_const(Ripper, "EXPR_CLASS", INT2NUM(EXPR_CLASS));
20020  /* flag bit, label is allowed. */
20021  rb_define_const(Ripper, "EXPR_LABEL", INT2NUM(EXPR_LABEL));
20022  /* flag bit, just after a label. */
20023  rb_define_const(Ripper, "EXPR_LABELED", INT2NUM(EXPR_LABELED));
20024  /* symbol literal as FNAME. */
20025  rb_define_const(Ripper, "EXPR_FITEM", INT2NUM(EXPR_FITEM));
20026  /* equals to +EXPR_BEG+ */
20027  rb_define_const(Ripper, "EXPR_VALUE", INT2NUM(EXPR_VALUE));
20028  /* equals to <tt>(EXPR_BEG | EXPR_MID | EXPR_CLASS)</tt> */
20029  rb_define_const(Ripper, "EXPR_BEG_ANY", INT2NUM(EXPR_BEG_ANY));
20030  /* equals to <tt>(EXPR_ARG | EXPR_CMDARG)</tt> */
20031  rb_define_const(Ripper, "EXPR_ARG_ANY", INT2NUM(EXPR_ARG_ANY));
20032  /* equals to <tt>(EXPR_END | EXPR_ENDARG | EXPR_ENDFN)</tt> */
20033  rb_define_const(Ripper, "EXPR_END_ANY", INT2NUM(EXPR_END_ANY));
20034  /* equals to +0+ */
20035  rb_define_const(Ripper, "EXPR_NONE", INT2NUM(EXPR_NONE));
20036 
20037  ripper_init_eventids1_table(Ripper);
20038  ripper_init_eventids2_table(Ripper);
20039 
20040 # if 0
20041  /* Hack to let RDoc document SCRIPT_LINES__ */
20042 
20043  /*
20044  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
20045  * after the assignment will be added as an Array of lines with the file
20046  * name as the key.
20047  */
20048  rb_define_global_const("SCRIPT_LINES__", Qnil);
20049 #endif
20050 
20051 }
20052 #endif /* RIPPER */
20053 
20054 /*
20055  * Local variables:
20056  * mode: c
20057  * c-file-style: "ruby"
20058  * End:
20059  */
rb_parser_printf
void rb_parser_printf(struct parser_params *p, const char *fmt,...)
Definition: ripper.c:19432
idNULL
@ idNULL
Definition: id.h:113
token_info::indent
int indent
Definition: ripper.c:254
NODE_NEXT
@ NODE_NEXT
Definition: node.h:47
parser_params::has_shebang
unsigned int has_shebang
Definition: ripper.c:333
strcmp
int strcmp(const char *, const char *)
IS_LABEL_POSSIBLE
#define IS_LABEL_POSSIBLE()
Definition: ripper.c:13834
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
FLONUM_P
#define FLONUM_P(x)
Definition: ruby.h:430
RE_OPTION_ENCODING
#define RE_OPTION_ENCODING(e)
Definition: ripper.c:703
tCOMMENT
@ tCOMMENT
Definition: eventids2.c:3
kwtable::state
short state
Definition: lex.c:34
idFWD_BLOCK
#define idFWD_BLOCK
Definition: ripper.c:699
str_label
@ str_label
Definition: ripper.c:12951
WARN_S_L
#define WARN_S_L(s, l)
Definition: ripper.c:995
rb_parser_new
VALUE rb_parser_new(void)
Definition: ripper.c:19221
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:119
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:18937
i
uint32_t i
Definition: rb_mjit_min_header-2.7.1.h:5464
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:125
ISASCII
#define ISASCII(c)
Definition: ruby.h:2304
ID
unsigned long ID
Definition: ruby.h:103
rb_str_cat_cstr
#define rb_str_cat_cstr(str, ptr)
Definition: rb_mjit_min_header-2.7.1.h:6126
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
obj
const VALUE VALUE obj
Definition: rb_mjit_min_header-2.7.1.h:5742
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:12277
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:14614
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:132
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
long
#define long
Definition: rb_mjit_min_header-2.7.1.h:2880
WARN_LOCATION
#define WARN_LOCATION(type)
Definition: ripper.c:16710
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:19215
keyword_class
@ keyword_class
Definition: parse.h:49
rb_parser_warn_location
void rb_parser_warn_location(VALUE vparser, int warn)
Definition: ripper.c:19044
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:12948
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:14191
NODE_DSYM
@ NODE_DSYM
Definition: node.h:131
tNMATCH
@ tNMATCH
Definition: parse.h:127
rb_ast_newnode
NODE * rb_ast_newnode(rb_ast_t *ast, enum node_type type)
Definition: node.c:1189
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:135
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:51
klass
VALUE klass
Definition: rb_mjit_min_header-2.7.1.h:13259
rb_ast_struct::body
rb_ast_body_t body
Definition: node.h:402
local_vars
Definition: ripper.c:214
st_data_t
unsigned long st_data_t
Definition: rb_mjit_min_header-2.7.1.h:5363
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:454
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:4272
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:7065
tLAMBEG
@ tLAMBEG
Definition: parse.h:163
eventids1.c
NODE_TRUE
@ NODE_TRUE
Definition: node.h:126
string_type
string_type
Definition: ripper.c:12950
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
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:12943
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:9381
idOr
@ idOr
Definition: id.h:101
NODE_NTH_REF
@ NODE_NTH_REF
Definition: node.h:88
rb_stderr
RUBY_EXTERN VALUE rb_stderr
Definition: ruby.h:2090
tokfix
#define tokfix(p)
Definition: ripper.c:13088
tEMBDOC
@ tEMBDOC
Definition: eventids2.c:5
RE_OPTION_MASK
#define RE_OPTION_MASK
Definition: ripper.c:706
NODE_ZLIST
@ NODE_ZLIST
Definition: node.h:77
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:99
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
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:55
NODE_ARYPTN
@ NODE_ARYPTN
Definition: node.h:134
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:1389
token_info
Definition: ripper.c:251
str_dquote
@ str_dquote
Definition: ripper.c:12953
rb_sym_intern_ascii_cstr
#define rb_sym_intern_ascii_cstr(ptr)
Definition: rb_mjit_min_header-2.7.1.h:7763
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
idEqq
@ idEqq
Definition: id.h:97
rb_funcall
#define rb_funcall(recv, mid, argc,...)
Definition: rb_mjit_min_header-2.7.1.h:6585
rb_gc_force_recycle
void rb_gc_force_recycle(VALUE obj)
Definition: gc.c:7013
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
n
const char size_t n
Definition: rb_mjit_min_header-2.7.1.h:5456
rb_hash_clear
VALUE rb_hash_clear(VALUE hash)
Definition: hash.c:2764
NEW_BEGIN
#define NEW_BEGIN(b, loc)
Definition: node.h:306
local_vars::numparam
struct local_vars::@63 numparam
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:12671
toklen
#define toklen(p)
Definition: ripper.c:13090
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:79
rb_parser_reg_compile
RUBY_SYMBOL_EXPORT_BEGIN VALUE rb_parser_reg_compile(struct parser_params *p, VALUE str, int options)
Definition: ripper.c:18992
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:86
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:164
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
NODE_LASGN
@ NODE_LASGN
Definition: node.h:57
idUMinus
@ idUMinus
Definition: id.h:82
parser_params::do_chomp
unsigned int do_chomp
Definition: ripper.c:351
IS_ARG
#define IS_ARG()
Definition: ripper.c:13830
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
rb_str_new_cstr
#define rb_str_new_cstr(str)
Definition: rb_mjit_min_header-2.7.1.h:6117
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:12952
ESCAPE_META
#define ESCAPE_META
Definition: ripper.c:13296
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:122
NODE_ARGSPUSH
@ NODE_ARGSPUSH
Definition: node.h:107
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
idNil
@ idNil
Definition: rb_mjit_min_header-2.7.1.h:8744
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:36
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:923
set_yylval_name
#define set_yylval_name(x)
Definition: ripper.c:12259
encoding.h
NEW_REDO
#define NEW_REDO(loc)
Definition: node.h:304
STR_FUNC_SYMBOL
#define STR_FUNC_SYMBOL
Definition: ripper.c:12944
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:106
rb_eSyntaxError
VALUE rb_eSyntaxError
Definition: error.c:938
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
fmt
const VALUE int int int int int int VALUE char * fmt
Definition: rb_mjit_min_header-2.7.1.h:6462
set_yylval_id
#define set_yylval_id(x)
Definition: ripper.c:12258
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:435
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:120
NODE_EVSTR
@ NODE_EVSTR
Definition: node.h:98
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
NEW_LAMBDA
#define NEW_LAMBDA(a, b, loc)
Definition: node.h:301
magic_comment::length
rb_magic_comment_length_t length
Definition: ripper.c:14616
tEMBDOC_END
@ tEMBDOC_END
Definition: eventids2.c:6
rb_args_info::kw_rest_arg
NODE * kw_rest_arg
Definition: node.h:444
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:2393
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:17115
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
NO_PARAM
@ NO_PARAM
Definition: ripper.c:231
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:433
parser_params::ruby_sourceline
int ruby_sourceline
Definition: ripper.c:311
NEW_RETRY
#define NEW_RETRY(loc)
Definition: node.h:305
NODE_CVASGN
@ NODE_CVASGN
Definition: node.h:63
NODE_AND
@ NODE_AND
Definition: node.h:54
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:17096
tCOLON2
@ tCOLON2
Definition: parse.h:137
rb_code_position_struct::lineno
int lineno
Definition: node.h:131
NODE_LIT
@ NODE_LIT
Definition: node.h:93
YYSTYPE::vars
const struct vtable * vars
Definition: parse.h:182
idCall
@ idCall
Definition: rb_mjit_min_header-2.7.1.h:8732
rb_parser_compile_file_path
rb_ast_t * rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE file, int start)
Definition: ripper.c:12905
nd_once_body
#define nd_once_body(node)
Definition: ripper.c:16648
tIVAR
@ tIVAR
Definition: parse.h:101
tASET
@ tASET
Definition: parse.h:133
arg
VALUE arg
Definition: rb_mjit_min_header-2.7.1.h:5601
rb_parser_malloc
void * rb_parser_malloc(struct parser_params *p, size_t size)
Definition: ripper.c:19375
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:56
str_dword
@ str_dword
Definition: ripper.c:12957
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
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:12925
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:46
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:97
NEW_MASGN
#define NEW_MASGN(l, r, loc)
Definition: node.h:315
CHAR_BIT
#define CHAR_BIT
Definition: ruby.h:227
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:70
NODE_SPECIAL_REQUIRED_KEYWORD
#define NODE_SPECIAL_REQUIRED_KEYWORD
Definition: node.h:381
idUScore
@ idUScore
Definition: rb_mjit_min_header-2.7.1.h:8745
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
const RUBY_FUNC_EXPORTED unsigned int ruby_global_name_punct_bits[(0x7e - 0x20+31)/32]
Definition: ripper.c:13773
CSI_BEGIN
#define CSI_BEGIN
idLE
@ idLE
Definition: id.h:93
ptr
struct RIMemo * ptr
Definition: debug.c:74
idUPlus
@ idUPlus
Definition: id.h:81
yyparse
#define yyparse
Definition: ripper.c:483
rb_str_new
#define rb_str_new(str, len)
Definition: rb_mjit_min_header-2.7.1.h:6116
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:12280
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:1219
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:13837
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
strcasecmp
int strcasecmp(const char *, const char *) __attribute__((__pure__))
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:58
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:33
rb_ary_new3
#define rb_ary_new3
Definition: intern.h:104
call
return cc call
Definition: rb_mjit_min_header-2.7.1.h:13254
st.h
rb_strterm_literal_struct::u1
union rb_strterm_literal_struct::@67 u1
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
char
#define char
Definition: rb_mjit_min_header-2.7.1.h:2876
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:438
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
RNode::u2
union RNode::@123 u2
tLEQ
@ tLEQ
Definition: parse.h:123
set_yylval_str
#define set_yylval_str(x)
Definition: ripper.c:12247
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:12983
NODE_DSTR
@ NODE_DSTR
Definition: node.h:95
rb_fatal
void rb_fatal(const char *fmt,...)
Definition: error.c:2720
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
idMesg
@ idMesg
Definition: rb_mjit_min_header-2.7.1.h:8733
yyalloc::yyss_alloc
yytype_int16 yyss_alloc
Definition: ripper.c:1411
NODE_SPLAT
@ NODE_SPLAT
Definition: node.h:108
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:62
rb_args_info::kw_args
NODE * kw_args
Definition: node.h:443
rb_init_parse
void rb_init_parse(void)
Definition: ripper.c:19086
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:12982
rb_respond_to
int rb_respond_to(VALUE, ID)
Definition: vm_method.c:2190
NODE_CVAR
@ NODE_CVAR
Definition: node.h:87
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:14843
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:12980
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:19367
parse.h
rb_args_info::pre_init
NODE * pre_init
Definition: node.h:432
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:174
rb_ast_delete_node
void rb_ast_delete_node(rb_ast_t *ast, NODE *n)
Definition: node.c:1211
NODE_IN
@ NODE_IN
Definition: node.h:40
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:13159
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:12631
lex.c
rb_raise
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:2669
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:17859
ESCAPE_CONTROL
#define ESCAPE_CONTROL
Definition: ripper.c:13295
rb_ary_entry
VALUE rb_ary_entry(VALUE ary, long offset)
Definition: array.c:1512
rb_usascii_str_new
#define rb_usascii_str_new(str, len)
Definition: rb_mjit_min_header-2.7.1.h:6118
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
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:18939
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
tEMBDOC_BEG
@ tEMBDOC_BEG
Definition: eventids2.c:4
NODE_UNLESS
@ NODE_UNLESS
Definition: node.h:35
void
void
Definition: rb_mjit_min_header-2.7.1.h:13278
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:19385
idOR
@ idOR
Definition: rb_mjit_min_header-2.7.1.h:8738
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:12242
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:19415
tIGNORED_NL
@ tIGNORED_NL
Definition: eventids2.c:2
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
rb_args_info::opt_args
NODE * opt_args
Definition: node.h:446
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:14548
ADD2HEAP
#define ADD2HEAP(new, cnt, ptr)
Definition: ripper.c:19371
va_start
#define va_start(v, l)
Definition: rb_mjit_min_header-2.7.1.h:3978
keyword_true
@ keyword_true
Definition: parse.h:81
dispatch_delayed_token
#define dispatch_delayed_token(p, t)
Definition: ripper.c:12282
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
rb_args_info
Definition: node.h:431
kwtable::id
short id[2]
Definition: lex.c:34
rb_ary_pattern_info::post_args
NODE * post_args
Definition: node.h:456
NEW_NIL
#define NEW_NIL(loc)
Definition: node.h:372
token_flush
#define token_flush(ptr)
Definition: ripper.c:417
rb_encoding
const typedef OnigEncodingType rb_encoding
Definition: encoding.h:115
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
idLTLT
@ idLTLT
Definition: id.h:90
rb_str_intern
VALUE rb_str_intern(VALUE)
Definition: symbol.c:710
tHEREDOC_BEG
@ tHEREDOC_BEG
Definition: eventids2.c:7
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
s2
const char * s2
Definition: rb_mjit_min_header-2.7.1.h:5454
token
unsigned short token
Definition: id.c:36
rb_ary_pattern_info::rest_arg
NODE * rest_arg
Definition: node.h:455
tQSYMBOLS_BEG
@ tQSYMBOLS_BEG
Definition: parse.h:158
tIMAGINARY
@ tIMAGINARY
Definition: parse.h:108
rb_strterm_literal_struct::u3
union rb_strterm_literal_struct::@69 u3
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
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:450
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:448
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
rb_ary_new_from_args
#define rb_ary_new_from_args(n,...)
Definition: rb_mjit_min_header-2.7.1.h:7214
vtable_pop
#define vtable_pop(tbl, n)
Definition: ripper.c:12688
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:13086
h
size_t st_index_t h
Definition: rb_mjit_min_header-2.7.1.h:5462
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:34
ORDINAL_PARAM
@ ORDINAL_PARAM
Definition: ripper.c:230
rb_parser_set_yydebug
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: ripper.c:19326
tLBRACE_ARG
@ tLBRACE_ARG
Definition: parse.h:146
NODE_ENSURE
@ NODE_ENSURE
Definition: node.h:53
keyword_else
@ keyword_else
Definition: parse.h:61
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:285
rb_builtin_type_name
const char * rb_builtin_type_name(int t)
Definition: error.c:761
keyword_retry
@ keyword_retry
Definition: parse.h:70
mask
enum @11::@13::@14 mask
lex_state_e
lex_state_e
Definition: ripper.c:151
add_delayed_token
#define add_delayed_token(p, tok, end)
Definition: ripper.c:13003
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:19033
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:4288
T_REGEXP
#define T_REGEXP
Definition: ruby.h:529
nd_set_type
#define nd_set_type(n, t)
Definition: node.h:189
ptrdiff_t
long int ptrdiff_t
Definition: rb_mjit_min_header-2.7.1.h:802
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:13832
parser_params::case_labels
VALUE case_labels
Definition: ripper.c:316
SPECIAL_PUNCT
#define SPECIAL_PUNCT(idx)
Definition: ripper.c:13778
rb_hash_lookup
VALUE rb_hash_lookup(VALUE hash, VALUE key)
Definition: hash.c:2058
rb_errinfo
VALUE rb_errinfo(void)
The current exception in the current thread.
Definition: eval.c:1882
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
vars
const VALUE int int int int int int VALUE * vars[]
Definition: rb_mjit_min_header-2.7.1.h:6462
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:38
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:195
keyword_then
@ keyword_then
Definition: parse.h:59
va_list
__gnuc_va_list va_list
Definition: rb_mjit_min_header-2.7.1.h:836
rb_strterm_literal_struct::nest
long nest
Definition: ripper.c:713
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:18938
has_delayed_token
#define has_delayed_token(p)
Definition: ripper.c:12283
malloc
void * malloc(size_t) __attribute__((__malloc__)) __attribute__((__warn_unused_result__)) __attribute__((__alloc_size__(1)))
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:14613
NODE_DASGN_CURR
@ NODE_DASGN_CURR
Definition: node.h:59
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:922
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:1662
SWITCH_BY_COND_TYPE
#define SWITCH_BY_COND_TYPE(t, w, arg)
Definition: ripper.c:17862
NODE_COLON2
@ NODE_COLON2
Definition: node.h:118
NODE_DOT3
@ NODE_DOT3
Definition: node.h:121
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
node_type
node_type
Definition: node.h:22
ALLOC
#define ALLOC(type)
Definition: ruby.h:1664
reg_named_capture_assign_t
Definition: ripper.c:18935
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
NODE_BREAK
@ NODE_BREAK
Definition: node.h:46
END_OF_INPUT
@ END_OF_INPUT
Definition: parse.h:48
rb_eRuntimeError
VALUE rb_eRuntimeError
Definition: error.c:920
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:84
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:16307
RARRAY_AREF
#define RARRAY_AREF(a, i)
Definition: ruby.h:1101
vtable::pos
int pos
Definition: ripper.c:209
rb_ast_add_mark_object
void rb_ast_add_mark_object(rb_ast_t *ast, VALUE obj)
Definition: node.c:1395
NODE_XSTR
@ NODE_XSTR
Definition: node.h:96
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
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
NODE_ARGS
@ NODE_ARGS
Definition: node.h:101
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
NUMPARAM_MAX
@ NUMPARAM_MAX
Definition: ripper.c:232
nd_first_column
#define nd_first_column(n)
Definition: node.h:198
NEW_HASH
#define NEW_HASH(a, loc)
Definition: node.h:314
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:12890
NODE_DVAR
@ NODE_DVAR
Definition: node.h:83
YYLTYPE::last_column
int last_column
Definition: parse.h:200
tok
#define tok(p)
Definition: ripper.c:13089
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:17082
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:19279
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:436
keyword_while
@ keyword_while
Definition: parse.h:64
Qnone
#define Qnone
Definition: ripper.c:941
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:14189
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:12947
path
VALUE path
Definition: rb_mjit_min_header-2.7.1.h:7353
TOK_INTERN
#define TOK_INTERN()
Definition: ripper.c:381
NODE_SELF
@ NODE_SELF
Definition: node.h:124
local_vars::prev
struct local_vars * prev
Definition: ripper.c:221
WARN_EOL
#define WARN_EOL(tok)
Definition: ripper.c:1016
parser_params::lval
YYSTYPE * lval
Definition: ripper.c:273
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:17151
EOF
#define EOF
Definition: vsnprintf.c:203
rb_args_info::no_kwarg
unsigned int no_kwarg
Definition: node.h:447
NODE_LVAR
@ NODE_LVAR
Definition: node.h:82
memchr
void * memchr(const void *, int, size_t)
COND_IN_OP
@ COND_IN_OP
Definition: ripper.c:17857
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:94
rb_str_buf_append
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2950
rb_strterm_literal_struct::u0
union rb_strterm_literal_struct::@66 u0
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:19342
ISCNTRL
#define ISCNTRL(c)
Definition: ruby.h:2315
str_xquote
@ str_xquote
Definition: ripper.c:12954
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
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
rb_scan_args
#define rb_scan_args(argc, argvp, fmt,...)
Definition: rb_mjit_min_header-2.7.1.h:6372
idFWD_KWREST
#define idFWD_KWREST
Definition: ripper.c:697
NODE_IVAR
@ NODE_IVAR
Definition: node.h:85
COND_IN_COND
@ COND_IN_COND
Definition: ripper.c:17858
NEW_OP_ASGN1
#define NEW_OP_ASGN1(p, id, a, loc)
Definition: node.h:323
k__END__
@ k__END__
Definition: eventids2.c:9
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::gets_
union parser_params::@64::@65 gets_
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
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:50
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:12959
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
StringValue
use StringValue() instead")))
NODE_RETURN
@ NODE_RETURN
Definition: node.h:80
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:12884
rb_parser_encoding
VALUE rb_parser_encoding(VALUE vparser)
Definition: ripper.c:19294
rb_magic_comment_length_t
long(* rb_magic_comment_length_t)(struct parser_params *p, const char *name, long len)
Definition: ripper.c:14547
error
const rb_iseq_t const char * error
Definition: rb_mjit_min_header-2.7.1.h:13511
NODE_FALSE
@ NODE_FALSE
Definition: node.h:127
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:13745
argv
char ** argv
Definition: ruby.c:223
NODE_ONCE
@ NODE_ONCE
Definition: node.h:100
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:2892
STR_FUNC_LABEL
#define STR_FUNC_LABEL
Definition: ripper.c:12946
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:61
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:12257
str_sword
@ str_sword
Definition: ripper.c:12956
NEW_VCALL
#define NEW_VCALL(m, loc)
Definition: node.h:350
dispatch_heredoc_end
#define dispatch_heredoc_end(p)
Definition: ripper.c:14261
ENCODING_GET
#define ENCODING_GET(obj)
Definition: encoding.h:62
tSP
@ tSP
Definition: parse.h:114
NEWHEAP
#define NEWHEAP()
Definition: ripper.c:19370
rb_sprintf
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1197
keyword_do
@ keyword_do
Definition: parse.h:72
NODE_ARGS_AUX
@ NODE_ARGS_AUX
Definition: node.h:102
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:12649
tEQQ
@ tEQQ
Definition: parse.h:120
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:19357
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
cc
const struct rb_call_cache * cc
Definition: rb_mjit_min_header-2.7.1.h:13233
keyword_undef
@ keyword_undef
Definition: parse.h:52
parser_params::lex
struct parser_params::@64 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:13838
RFLOAT
#define RFLOAT(obj)
Definition: internal.h:803
NODE_WHEN
@ NODE_WHEN
Definition: node.h:39
YYTERROR
#define YYTERROR
Definition: ripper.c:5149
NODE_BLOCK_PASS
@ NODE_BLOCK_PASS
Definition: node.h:109
parser_params::prevline
VALUE prevline
Definition: ripper.c:279
mixed_error
#define mixed_error(enc1, enc2)
NODE_MATCH
@ NODE_MATCH
Definition: node.h:90
set_yylval_literal
#define set_yylval_literal(x)
Definition: ripper.c:12252
RUBY_TYPED_FREE_IMMEDIATELY
#define RUBY_TYPED_FREE_IMMEDIATELY
Definition: ruby.h:1207
STATIC_ID2SYM
#define STATIC_ID2SYM(id)
Definition: symbol.h:18
ERANGE
#define ERANGE
Definition: rb_mjit_min_header-2.7.1.h:10976
YYMAXDEPTH
#define YYMAXDEPTH
Definition: ripper.c:5369
memset
void * memset(void *, int, size_t)
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:19231
rb_hash_aset
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
Definition: hash.c:2847
int
__inline__ int
Definition: rb_mjit_min_header-2.7.1.h:2839
rb_io_gets_internal
VALUE rb_io_gets_internal(VALUE io)
Definition: io.c:3579
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
memcpy
void * memcpy(void *__restrict, const void *__restrict, size_t)
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
parser_params::compile_option
VALUE compile_option
Definition: ripper.c:317
STR_FUNC_INDENT
#define STR_FUNC_INDENT
Definition: ripper.c:12945
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:17176
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:14190
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:2880
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: ripper.c:5337
RNode::u1
union RNode::@122 u1
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:12942
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:12985
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
rb_strterm_struct::u
union rb_strterm_struct::@70 u
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:18936
IS_END
#define IS_END()
Definition: ripper.c:13831
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
memmove
#define memmove(dst, src, len)
Definition: rb_mjit_min_header-2.7.1.h:2848
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:1409
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:17125
stack_type
VALUE stack_type
Definition: ripper.c:183
v
int VALUE v
Definition: rb_mjit_min_header-2.7.1.h:12337
RBASIC
#define RBASIC(obj)
Definition: ruby.h:1267
rb_ary_pattern_info::imemo
VALUE imemo
Definition: node.h:457
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:5214
rb_reg_fragment_setenc
int rb_reg_fragment_setenc(struct parser_params *, VALUE, int)
Definition: ripper.c:18878
ruby_sized_xfree
#define ruby_sized_xfree(ptr, size)
Definition: rb_mjit_min_header-2.7.1.h:7372
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
rb_compile_warn
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:270
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:81
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:12979
is_notop_id
#define is_notop_id(id)
Definition: symbol.h:35
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:19395
WARN_SPACE_CHAR
#define WARN_SPACE_CHAR(c, prefix)
Definition: ripper.c:13188
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
RNode::u3
union RNode::@124 u3
rb_usascii_str_new2
#define rb_usascii_str_new2
Definition: intern.h:909
tLBRACE
@ tLBRACE
Definition: parse.h:145
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:17166
modifier_until
@ modifier_until
Definition: parse.h:89
cond_type
cond_type
Definition: ripper.c:17856
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
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:14615
NODE_SPECIAL_NO_NAME_REST
#define NODE_SPECIAL_NO_NAME_REST
Definition: node.h:383
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:89
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:129
else
else
Definition: rb_mjit_min_header-2.7.1.h:13251
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
idLASTLINE
@ idLASTLINE
Definition: rb_mjit_min_header-2.7.1.h:8757
strncmp
int strncmp(const char *, const char *, size_t)
rb_yytnamerr
size_t rb_yytnamerr(struct parser_params *p, char *yyres, const char *yystr)
Definition: ripper.c:19479
tSTAR
@ tSTAR
Definition: parse.h:147
rb_args_info::block_arg
ID block_arg
Definition: node.h:441
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:2688
stderr
#define stderr
Definition: rb_mjit_min_header-2.7.1.h:1485
rb_warn1
#define rb_warn1(fmt, a)
Definition: ripper.c:951
rb_strterm_literal_struct::u2
union rb_strterm_literal_struct::@68 u2
make_list
#define make_list(list, loc)
Definition: ripper.c:567
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:13770
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:78
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:123
nd_type
#define nd_type(n)
Definition: node.h:188
parser_params::state
enum lex_state_e state
Definition: ripper.c:290
YYSYNTAX_ERROR
#define YYSYNTAX_ERROR
rb_builtin_class_name
const char * rb_builtin_class_name(VALUE x)
Definition: error.c:797
idAND
@ idAND
Definition: rb_mjit_min_header-2.7.1.h:8737
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:12940
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
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:48
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:453
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
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
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
tHEREDOC_END
@ tHEREDOC_END
Definition: eventids2.c:8
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:12941
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
st_table
Definition: st.h:79
TAB_WIDTH
#define TAB_WIDTH
Definition: ripper.c:94
str_regexp
@ str_regexp
Definition: ripper.c:12955
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:440
INT_MAX
#define INT_MAX
Definition: rb_mjit_min_header-2.7.1.h:4052
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:32
idNeqTilde
@ idNeqTilde
Definition: id.h:104
NEW_DVAR
#define NEW_DVAR(v, loc)
Definition: node.h:331
yylval
#define yylval
Definition: ripper.c:12233
NODE_RETRY
@ NODE_RETRY
Definition: node.h:49
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:76
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:13833
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
RNode
Definition: node.h:149
__sFILE
Definition: vsnprintf.c:169
va_end
#define va_end(v)
Definition: rb_mjit_min_header-2.7.1.h:3979
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:9356
RSTRING_END
#define RSTRING_END(str)
Definition: ruby.h:1013
str_ssym
@ str_ssym
Definition: ripper.c:12958
STR_NEW
#define STR_NEW(ptr, len)
Definition: ripper.c:377
src
__inline__ const void *__restrict src
Definition: rb_mjit_min_header-2.7.1.h:2836
tLOWEST
@ tLOWEST
Definition: parse.h:165
rb_warning1
#define rb_warning1(fmt, a)
Definition: ripper.c:956
idGets
@ idGets
Definition: rb_mjit_min_header-2.7.1.h:8706
name
const char * name
Definition: nkf.c:208
dispatch_scan_event
#define dispatch_scan_event(p, t)
Definition: ripper.c:12281
NODE_GASGN
@ NODE_GASGN
Definition: node.h:60
COND_POP
#define COND_POP()
Definition: ripper.c:196