Ruby  2.7.0p0(2019-12-25revision647ee6f091eafcce70ffb75ddf7e121e192ab217)
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 13832
1469 
1470 /* YYNTOKENS -- Number of terminals. */
1471 #define YYNTOKENS 154
1472 /* YYNNTS -- Number of nonterminals. */
1473 #define YYNNTS 265
1474 /* YYNRULES -- Number of rules. */
1475 #define YYNRULES 757
1476 /* YYNSTATES -- Number of states. */
1477 #define YYNSTATES 1241
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, 1469, 1477, 1486, 1494, 1502, 1510, 1518, 1528,
1538  1533, 1542, 1545, 1546, 1550, 1554, 1558, 1563, 1570, 1572,
1539  1562, 1580, 1583, 1590, 1590, 1590, 1596, 1597, 1600, 1601,
1540  1610, 1620, 1630, 1639, 1650, 1657, 1664, 1671, 1678, 1686,
1541  1694, 1701, 1708, 1717, 1718, 1727, 1728, 1737, 1744, 1751,
1542  1758, 1765, 1772, 1779, 1786, 1793, 1800, 1809, 1810, 1819,
1543  1826, 1835, 1842, 1851, 1858, 1865, 1872, 1882, 1889, 1899,
1544  1906, 1913, 1923, 1930, 1937, 1944, 1951, 1958, 1965, 1972,
1545  1979, 1989, 1996, 1999, 2006, 2013, 2022, 2023, 2024, 2025,
1546  2030, 2037, 2044, 2047, 2054, 2054, 2064, 2065, 2066, 2067,
1547  2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077,
1548  2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087,
1549  2088, 2089, 2090, 2091, 2092, 2093, 2096, 2096, 2096, 2097,
1550  2097, 2098, 2098, 2098, 2099, 2099, 2099, 2099, 2100, 2100,
1551  2100, 2100, 2101, 2101, 2101, 2102, 2102, 2102, 2102, 2103,
1552  2103, 2103, 2103, 2104, 2104, 2104, 2104, 2105, 2105, 2105,
1553  2105, 2106, 2106, 2106, 2106, 2107, 2107, 2110, 2117, 2124,
1554  2132, 2140, 2148, 2156, 2164, 2171, 2179, 2188, 2197, 2209,
1555  2221, 2233, 2245, 2249, 2253, 2257, 2261, 2265, 2269, 2273,
1556  2277, 2281, 2285, 2289, 2293, 2297, 2298, 2302, 2306, 2310,
1557  2314, 2318, 2322, 2326, 2330, 2334, 2338, 2342, 2342, 2347,
1558  2356, 2362, 2363, 2364, 2365, 2368, 2372, 2379, 2386, 2387,
1559  2391, 2398, 2407, 2412, 2423, 2430, 2459, 2460, 2463, 2464,
1560  2465, 2469, 2476, 2485, 2493, 2500, 2508, 2516, 2520, 2520,
1561  2557, 2566, 2570, 2576, 2583, 2590, 2597, 2606, 2607, 2610,
1562  2617, 2624, 2633, 2634, 2635, 2636, 2637, 2638, 2639, 2640,
1563  2641, 2642, 2643, 2651, 2650, 2665, 2665, 2672, 2672, 2680,
1564  2688, 2695, 2702, 2709, 2717, 2724, 2731, 2738, 2745, 2745,
1565  2750, 2754, 2758, 2765, 2766, 2775, 2774, 2785, 2796, 2807,
1566  2817, 2828, 2827, 2844, 2843, 2858, 2867, 2915, 2914, 2938,
1567  2937, 2960, 2959, 2983, 2989, 2982, 3009, 3010, 3009, 3035,
1568  3042, 3049, 3056, 3065, 3072, 3078, 3095, 3101, 3107, 3113,
1569  3119, 3125, 3131, 3137, 3143, 3149, 3155, 3161, 3167, 3173,
1570  3188, 3195, 3201, 3208, 3209, 3210, 3213, 3214, 3217, 3218,
1571  3230, 3231, 3240, 3241, 3244, 3252, 3261, 3268, 3277, 3284,
1572  3291, 3298, 3305, 3314, 3322, 3331, 3335, 3339, 3343, 3347,
1573  3353, 3358, 3363, 3367, 3371, 3375, 3379, 3383, 3391, 3395,
1574  3399, 3403, 3407, 3411, 3415, 3419, 3423, 3429, 3430, 3436,
1575  3445, 3457, 3461, 3470, 3472, 3476, 3481, 3487, 3490, 3494,
1576  3498, 3502, 3487, 3526, 3534, 3544, 3549, 3555, 3565, 3579,
1577  3586, 3593, 3602, 3611, 3619, 3627, 3634, 3642, 3650, 3657,
1578  3664, 3677, 3685, 3695, 3696, 3700, 3695, 3717, 3718, 3722,
1579  3717, 3741, 3749, 3756, 3764, 3773, 3785, 3786, 3790, 3796,
1580  3797, 3799, 3800, 3801, 3789, 3814, 3815, 3818, 3819, 3827,
1581  3837, 3838, 3843, 3851, 3855, 3861, 3864, 3873, 3876, 3883,
1582  3886, 3887, 3889, 3890, 3899, 3908, 3913, 3922, 3931, 3936,
1583  3936, 3941, 3946, 3946, 3951, 3956, 3956, 3963, 3972, 3976,
1584  3985, 3989, 3993, 3997, 4001, 4004, 4008, 4017, 4021, 4025,
1585  4029, 4035, 4036, 4045, 4054, 4058, 4062, 4066, 4070, 4076,
1586  4078, 4087, 4095, 4109, 4110, 4133, 4137, 4143, 4149, 4150,
1587  4159, 4168, 4180, 4192, 4193, 4194, 4195, 4207, 4221, 4222,
1588  4223, 4224, 4225, 4226, 4227, 4228, 4229, 4237, 4236, 4249,
1589  4259, 4272, 4279, 4286, 4295, 4307, 4310, 4317, 4324, 4327,
1590  4331, 4334, 4341, 4344, 4345, 4348, 4365, 4366, 4367, 4376,
1591  4386, 4395, 4401, 4411, 4417, 4426, 4428, 4437, 4447, 4453,
1592  4462, 4471, 4481, 4487, 4497, 4503, 4513, 4523, 4542, 4548,
1593  4558, 4568, 4609, 4612, 4611, 4628, 4632, 4637, 4641, 4645,
1594  4627, 4666, 4673, 4680, 4687, 4690, 4691, 4694, 4704, 4705,
1595  4706, 4707, 4710, 4720, 4721, 4731, 4732, 4733, 4734, 4737,
1596  4738, 4739, 4740, 4741, 4744, 4745, 4746, 4747, 4748, 4749,
1597  4750, 4753, 4766, 4775, 4782, 4791, 4792, 4796, 4795, 4805,
1598  4813, 4822, 4837, 4837, 4851, 4855, 4859, 4863, 4867, 4873,
1599  4878, 4883, 4887, 4891, 4895, 4899, 4903, 4907, 4911, 4915,
1600  4919, 4923, 4927, 4931, 4935, 4940, 4946, 4955, 4963, 4971,
1601  4979, 4989, 4990, 4998, 5007, 5015, 5036, 5038, 5051, 5061,
1602  5069, 5079, 5086, 5095, 5102, 5112, 5119, 5128, 5129, 5132,
1603  5140, 5148, 5158, 5168, 5178, 5185, 5194, 5201, 5210, 5211,
1604  5214, 5222, 5232, 5233, 5236, 5246, 5250, 5256, 5261, 5261,
1605  5285, 5286, 5295, 5297, 5320, 5331, 5338, 5346, 5365, 5366,
1606  5367, 5370, 5371, 5372, 5373, 5376, 5377, 5378, 5381, 5382,
1607  5385, 5386, 5389, 5390, 5393, 5394, 5397, 5398, 5401, 5404,
1608  5407, 5408, 5409, 5412, 5413, 5416, 5417, 5421
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", "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 -1056
1724 
1725 #define yypact_value_is_default(Yystate) \
1726  (!!((Yystate) == (-1056)))
1727 
1728 #define YYTABLE_NINF -758
1729 
1730 #define yytable_value_is_error(Yytable_value) \
1731  (!!((Yytable_value) == (-758)))
1732 
1733  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1734  STATE-NUM. */
1735 static const yytype_int16 yypact[] =
1736 {
1737  -1056, 97, 3943, -1056, 9202, -1056, -1056, -1056, 8660, -1056,
1738  -1056, -1056, -1056, -1056, -1056, -1056, 9328, 9328, -1056, -1056,
1739  -1056, 5267, 4826, -1056, -1056, -1056, -1056, -41, 8515, 18,
1740  -33, 124, -1056, -1056, -1056, 3778, 4973, -1056, -1056, 4238,
1741  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, 10966, 10966,
1742  10966, 10966, 90, 6715, 9454, 9832, 10210, 8944, -1056, 8370,
1743  -1056, -1056, -1056, 72, 143, 146, 197, 1315, 11092, 10966,
1744  -1056, 6, -1056, 1265, -1056, 411, -1056, -1056, 249, 152,
1745  253, -1056, 239, 11344, -1056, 279, 1752, 377, 542, 624,
1746  -1056, 11218, 11218, -1056, -1056, 7697, 11466, 11588, 11710, 8224,
1747  9328, 48, 21, -1056, -1056, 281, -1056, -1056, -1056, -1056,
1748  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, 394, 461,
1749  -1056, 355, 498, -1056, -1056, -1056, -1056, -1056, -1056, -1056,
1750  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056,
1751  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056,
1752  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056,
1753  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056,
1754  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056,
1755  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056,
1756  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056,
1757  -1056, -1056, 343, -1056, -1056, -1056, 346, 10966, 453, 6866,
1758  10966, 10966, 10966, -1056, 10966, -1056, 399, 4510, 448, -1056,
1759  -1056, 357, 723, 9, 300, 438, 547, 423, -1056, -1056,
1760  7571, -1056, 9328, 9580, -1056, -1056, 7823, -1056, 11218, 336,
1761  -1056, 430, 7017, -1056, 7168, -1056, -1056, 464, 483, 249,
1762  -1056, 740, -1056, 565, 3504, 3504, 581, 9454, -1056, 6715,
1763  549, 6, -1056, 1265, 18, 586, -1056, 1265, 18, 568,
1764  588, 640, -1056, 448, 578, 640, -1056, 18, 690, 1315,
1765  11832, 617, -1056, 790, 858, 885, 923, -1056, -1056, -1056,
1766  -1056, -1056, 362, -1056, 446, 562, 683, -1056, -1056, -1056,
1767  -1056, 694, -1056, -1056, -1056, -1056, -1056, -1056, -1056, 7949,
1768  11218, 11218, 11218, 11218, 9454, 11218, 11218, -1056, -1056, -1056,
1769  668, -1056, -1056, -1056, -1056, -1056, 10336, -1056, 6715, 9073,
1770  663, 10336, -1056, 10966, 10966, 10966, 10966, 10966, -1056, -1056,
1771  10966, 10966, 10966, 10966, 10966, 10966, 10966, 10966, 10966, -1056,
1772  -1056, 10966, 10966, 10966, 10966, 10966, 10966, 10966, 10966, 10966,
1773  10966, -1056, -1056, 12335, 9328, 12425, 5859, 411, 108, 108,
1774  7319, 11218, 7319, 6, -1056, 674, 758, -1056, -1056, 936,
1775  819, 53, 77, 126, 732, 827, 11218, 274, -1056, 727,
1776  940, -1056, -1056, -1056, -1056, 403, 437, 475, 517, 533,
1777  540, 543, 554, 558, -1056, -1056, -1056, 566, -1056, -1056,
1778  -1056, 13685, -1056, -1056, 11092, 11092, -1056, -1056, 629, -1056,
1779  -1056, -1056, 407, 10966, 10966, 9706, -1056, -1056, 12515, 9328,
1780  12605, 10966, 10966, 9958, -1056, 18, 718, -1056, -1056, 10966,
1781  18, -1056, 750, 18, 752, -1056, 96, -1056, -1056, -1056,
1782  -1056, -1056, 8660, -1056, 10966, 729, 757, 12515, 12605, 10966,
1783  1265, -33, 18, -1056, -1056, 8075, 754, 18, -1056, -1056,
1784  10084, -1056, -1056, 10210, -1056, -1056, -1056, 430, 963, -1056,
1785  -1056, 771, 11832, 12695, 9328, 12785, -1056, -1056, -1056, -1056,
1786  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, 824, 101,
1787  992, 141, 10966, -1056, -1056, -1056, -1056, -1056, -1056, -1056,
1788  -1056, -1056, 759, -1056, -1056, -1056, 866, -1056, 866, 10966,
1789  -1056, 773, 779, 860, -1056, 18, 11832, 781, -1056, -1056,
1790  -1056, 884, 806, 4216, -1056, -1056, -1056, 1006, 644, -1056,
1791  565, 2696, 2696, 2696, 2696, 4071, 2908, 2696, 2696, 3504,
1792  3504, 814, 814, 3389, 1310, 1310, 1335, 24, 24, 565,
1793  565, 565, 1921, 1921, 3606, 4385, 5561, 4532, -1056, 483,
1794  -1056, 18, 832, -1056, 870, -1056, -1056, 5120, 866, 922,
1795  -1056, 6010, 921, 6463, 866, 37, 866, 935, 947, 153,
1796  12875, 9328, 12965, -1056, 411, -1056, 963, -1056, -1056, -1056,
1797  13055, 9328, 13145, 5859, 11218, -1056, -1056, -1056, -1056, -1056,
1798  -1056, 3199, -1056, 4363, -1056, -1056, -1056, 8660, 10966, -1056,
1799  10966, 448, -1056, 423, 4091, 4679, 18, 655, 707, -1056,
1800  -1056, -1056, -1056, 9706, -1056, 9958, -1056, -1056, 11218, 4510,
1801  -1056, -1056, 483, 483, -1056, -1056, -6, -1056, -1056, 640,
1802  11832, 771, 57, 749, 18, 447, 519, -1056, -1056, 1173,
1803  -1056, 538, -1056, 831, -1056, -1056, 553, 843, -1056, 565,
1804  -1056, -1056, 822, -1056, -1056, -1056, -1056, 830, 10462, 9454,
1805  -1056, 771, 11832, 9454, 11092, 10966, 13235, 9328, 13325, 12268,
1806  856, 11092, 11092, -1056, 668, 848, 875, 11092, 11092, -1056,
1807  -1056, 668, -1056, -1056, -1056, 10588, 167, -1056, 817, -1056,
1808  991, -1056, -1056, -1056, -1056, -1056, -1056, 947, 866, -1056,
1809  10714, 866, 81, 177, 18, 288, 307, 7319, 6, 11218,
1810  5859, 1030, 749, -1056, 18, 866, 96, 862, 8805, 21,
1811  152, -1056, -1056, -1056, -1056, 10966, 10966, 714, 10966, 10966,
1812  868, 96, -1056, -1056, 607, -1056, -1056, -1056, -1056, -1056,
1813  -1056, -1056, -1056, -1056, -1056, -1056, -1056, 887, -1056, 887,
1814  10966, 876, -1056, 771, -1056, 4510, 5414, 5708, 18, 744,
1815  748, -1056, -1056, 2641, 2641, 534, -1056, 400, 881, -1056,
1816  975, 934, -1056, 904, -1056, -1056, 804, -1056, -1056, 267,
1817  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, 10966,
1818  -1056, -1056, -1056, -1056, -1056, -1056, 11092, -1056, -1056, -1056,
1819  -1056, -1056, 773, -1056, 938, -1056, -1056, -1056, 7319, -1056,
1820  -1056, -1056, -1056, 7319, 11218, 866, -1056, -1056, 866, -1056,
1821  -1056, 866, -1056, 10966, -1056, 63, -1056, 330, 866, 5859,
1822  6, 866, -1056, -1056, -1056, 1233, 5859, 1709, -1056, -1056,
1823  -1056, 10966, 9958, -1056, 1648, -1056, 1383, 7168, -1056, -1056,
1824  5859, 895, 756, -1056, -1056, -1056, -1056, 12268, 2069, -1056,
1825  -1056, 687, -1056, -1056, 1000, -1056, 12268, 2641, 2641, 534,
1826  400, 501, 12149, 12149, 4510, -1056, -1056, 11954, 108, -1056,
1827  -1056, 6589, -1056, 108, -1056, -1056, -1056, -1056, -1056, 10840,
1828  6161, -1056, 866, -1056, -1056, -1056, -1056, -1056, -1056, -1056,
1829  -1056, -1056, -1056, 1218, -1056, -1056, -1056, -1056, -1056, -1056,
1830  18, 18, -1056, -1056, 917, -1056, 907, 10966, -1056, 911,
1831  595, 916, 916, -1056, 919, 1015, 924, 1020, -1056, 866,
1832  6, 862, 1709, -1056, -1056, -1056, -1056, 18, 942, 949,
1833  932, 12076, -1056, 933, 916, 916, -1056, 943, 945, -1056,
1834  931, -1056, -1056, 206, 38, 117, 18, 12235, -1056, 948,
1835  -1056, -1056, 952, 954, -1056, 12268, -1056, -1056, 679, -1056,
1836  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, 18, 18,
1837  18, 18, 1060, -1056, 1049, 183, 292, 324, 5859, 1110,
1838  6010, 12149, 10966, -1056, 649, -1056, 1218, 1276, -1056, 974,
1839  18, 976, -1056, -1056, -1056, 10966, 1709, -1056, -1056, 1099,
1840  -1056, -1056, -1056, -1056, 359, -1056, -1056, 1709, -1056, -1056,
1841  1860, -1056, -1056, -1056, -1056, 5859, 18, 123, 7445, 994,
1842  -1056, 12076, 1709, -1056, 1074, 1070, 1099, -1056, -1056, -1056,
1843  1709, -1056, 1860, -1056, 1293, -1056, 988, 12268, -1056, 163,
1844  934, 990, -1056, 717, -1056, 687, 934, -1056, -1056, 730,
1845  -1056, -1056, -1056, -1056, 360, 13415, 9328, 13505, 922, -1056,
1846  817, 108, 838, 295, -1056, -1056, -1056, -1056, -1056, -1056,
1847  18, -1056, 1218, -1056, 855, -1056, -1056, -1056, 993, 996,
1848  -1056, 1091, 916, -1056, 998, -1056, 1001, -1056, 998, 866,
1849  999, 5859, 7168, -1056, 1032, -1056, 1070, -1056, 1009, 1014,
1850  -1056, 13595, -1056, 916, 1017, -1056, 1019, 1017, -1056, 710,
1851  -1056, -1056, 12268, 1023, -1056, 1026, 12268, -1056, -1056, -1056,
1852  -1056, -1056, 105, 187, 18, 371, 396, -1056, -1056, -1056,
1853  11218, 11218, 2069, -1056, -1056, 1037, 1038, 1709, -1056, 1860,
1854  -1056, -1056, 1860, -1056, 1860, -1056, -1056, -1056, -1056, 866,
1855  1042, -1056, 1709, -1056, 1860, -1056, 1013, 1040, -1056, 1860,
1856  -1056, 1860, -1056, -1056, 1293, -1056, 1023, 12268, 12268, 1023,
1857  406, -1056, -1056, -1056, -1056, 855, 855, 998, 1052, 998,
1858  998, -1056, -1056, 1017, 1053, 1017, 1017, -1056, -1056, 1023,
1859  -1056, 1038, -1056, 1860, -1056, -1056, -1056, -1056, 1860, -1056,
1860  -1056, -1056, 6312, 998, 1017, 80, -1056, -1056, -1056, -1056,
1861  -1056
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, 635, 634, 636, 637, 746, 0, 746,
1872  0, 0, 639, 638, 640, 728, 730, 631, 630, 729,
1873  633, 625, 626, 627, 628, 576, 645, 646, 0, 0,
1874  0, 0, 0, 0, 305, 757, 757, 95, 325, 596,
1875  596, 598, 600, 0, 0, 0, 0, 0, 0, 0,
1876  3, 744, 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, 744, 0, 0, 0, 0,
1879  314, 68, 323, 292, 293, 575, 577, 294, 295, 296,
1880  298, 297, 299, 574, 615, 616, 573, 623, 641, 642,
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, 596, 0, 273, 0, 257, 283, 81,
1891  277, 757, 0, 641, 642, 0, 301, 757, 722, 82,
1892  746, 79, 0, 757, 448, 78, 746, 747, 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, 744, 17, 20, 746, 85, 16, 307, 746, 0,
1896  750, 750, 258, 0, 0, 750, 720, 746, 0, 0,
1897  0, 93, 353, 0, 103, 104, 111, 427, 620, 619,
1898  621, 618, 0, 617, 0, 0, 0, 583, 592, 588,
1899  594, 624, 56, 241, 242, 753, 754, 4, 755, 745,
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, 740, 741, 0, 757, 0, 0, 62, 0, 0,
1906  0, 0, 0, 744, 333, 745, 0, 383, 382, 0,
1907  0, 641, 642, 301, 121, 122, 0, 0, 124, 649,
1908  0, 641, 642, 301, 341, 196, 189, 199, 184, 166,
1909  167, 168, 126, 127, 718, 343, 717, 0, 80, 743,
1910  742, 0, 324, 578, 0, 0, 134, 725, 311, 284,
1911  727, 280, 0, 0, 0, 0, 274, 282, 0, 757,
1912  0, 0, 0, 0, 275, 746, 0, 316, 279, 676,
1913  746, 269, 757, 746, 757, 268, 746, 321, 55, 25,
1914  27, 26, 0, 318, 0, 0, 0, 0, 0, 0,
1915  19, 0, 746, 309, 15, 745, 84, 746, 306, 312,
1916  752, 751, 259, 752, 261, 313, 721, 0, 110, 624,
1917  101, 96, 0, 0, 757, 0, 326, 428, 602, 622,
1918  605, 603, 597, 579, 580, 599, 581, 601, 0, 0,
1919  0, 0, 0, 756, 7, 29, 30, 31, 32, 33,
1920  53, 54, 0, 454, 453, 73, 0, 458, 0, 0,
1921  36, 288, 0, 39, 287, 746, 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, 746, 231, 232, 233, 222, 223, 224,
1925  225, 226, 255, 256, 731, 733, 732, 734, 447, 278,
1926  445, 746, 731, 733, 732, 734, 446, 278, 0, 757,
1927  374, 0, 373, 0, 0, 0, 0, 331, 0, 311,
1928  0, 757, 0, 63, 339, 121, 122, 123, 647, 337,
1929  0, 757, 0, 0, 0, 344, 738, 739, 346, 731,
1930  732, 278, 42, 262, 208, 48, 215, 0, 0, 724,
1931  0, 285, 281, 757, 731, 732, 746, 731, 732, 723,
1932  315, 748, 264, 270, 265, 272, 320, 24, 0, 248,
1933  11, 34, 0, 757, 214, 22, 86, 18, 308, 750,
1934  0, 94, 735, 109, 746, 731, 732, 429, 606, 0,
1935  582, 0, 585, 0, 590, 587, 0, 0, 591, 228,
1936  451, 455, 0, 371, 452, 459, 437, 291, 0, 0,
1937  98, 92, 0, 0, 0, 0, 0, 757, 0, 0,
1938  0, 0, 0, 444, 76, 0, 450, 0, 0, 267,
1939  443, 74, 266, 304, 366, 757, 757, 565, 757, 375,
1940  757, 329, 377, 64, 376, 330, 468, 0, 0, 368,
1941  0, 0, 735, 310, 746, 731, 732, 0, 0, 0,
1942  0, 121, 122, 125, 746, 0, 746, 652, 0, 439,
1943  69, 135, 726, 286, 276, 0, 0, 450, 0, 0,
1944  757, 746, 260, 102, 450, 430, 607, 611, 612, 613,
1945  604, 614, 584, 586, 593, 589, 595, 757, 70, 757,
1946  0, 289, 38, 90, 50, 263, 731, 732, 746, 731,
1947  732, 559, 563, 0, 0, 0, 505, 499, 502, 557,
1948  0, 59, 485, 487, 489, 492, 538, 543, 544, 545,
1949  548, 549, 550, 551, 552, 554, 553, 555, 556, 0,
1950  47, 212, 46, 213, 77, 749, 0, 44, 210, 45,
1951  211, 75, 566, 567, 757, 568, 367, 369, 0, 12,
1952  14, 572, 370, 0, 0, 0, 378, 380, 0, 65,
1953  469, 0, 335, 0, 461, 0, 334, 450, 0, 0,
1954  0, 0, 450, 342, 719, 675, 0, 675, 347, 440,
1955  441, 0, 271, 319, 675, 608, 746, 0, 418, 417,
1956  0, 290, 450, 546, 547, 122, 561, 0, 0, 501,
1957  504, 0, 427, 560, 0, 60, 0, 541, 542, 0,
1958  491, 490, 0, 0, 249, 43, 209, 0, 0, 570,
1959  571, 0, 381, 0, 327, 328, 470, 332, 462, 0,
1960  0, 336, 0, 648, 338, 682, 679, 678, 677, 680,
1961  688, 697, 676, 0, 709, 698, 713, 712, 708, 674,
1962  746, 746, 681, 683, 684, 686, 660, 690, 695, 757,
1963  701, 757, 757, 706, 660, 711, 660, 0, 658, 0,
1964  0, 652, 675, 431, 434, 609, 416, 746, 0, 684,
1965  401, 692, 693, 757, 757, 757, 704, 401, 401, 399,
1966  421, 456, 460, 746, 519, 507, 746, 508, 514, 0,
1967  533, 596, 0, 525, 529, 532, 526, 528, 536, 558,
1968  486, 488, 539, 540, 562, 498, 495, 596, 746, 746,
1969  746, 746, 0, 569, 0, 641, 642, 301, 0, 757,
1970  0, 0, 0, 463, 757, 340, 0, 394, 386, 388,
1971  746, 391, 384, 650, 651, 0, 0, 667, 689, 0,
1972  655, 716, 699, 700, 0, 657, 656, 0, 670, 710,
1973  0, 672, 714, 345, 653, 0, 746, 0, 0, 0,
1974  419, 0, 407, 409, 0, 691, 0, 396, 398, 397,
1975  0, 412, 0, 414, 0, 506, 517, 0, 500, 512,
1976  523, 509, 515, 0, 503, 0, 531, 537, 535, 0,
1977  493, 494, 496, 497, 311, 0, 757, 0, 757, 13,
1978  757, 0, 477, 480, 483, 484, 464, 466, 467, 465,
1979  746, 393, 0, 685, 0, 702, 659, 687, 660, 660,
1980  696, 701, 757, 715, 660, 707, 660, 684, 660, 0,
1981  0, 0, 0, 432, 0, 420, 703, 400, 401, 401,
1982  311, 0, 694, 757, 401, 705, 401, 401, 425, 746,
1983  423, 426, 0, 520, 521, 510, 0, 516, 534, 530,
1984  524, 527, 735, 310, 746, 731, 732, 564, 379, 471,
1985  0, 0, 481, 385, 387, 389, 392, 0, 663, 0,
1986  665, 654, 0, 671, 0, 668, 673, 348, 433, 0,
1987  0, 610, 0, 404, 0, 406, 735, 310, 395, 0,
1988  413, 0, 410, 415, 0, 422, 518, 0, 0, 513,
1989  450, 472, 478, 479, 482, 0, 0, 660, 660, 660,
1990  660, 436, 435, 401, 401, 401, 401, 424, 522, 511,
1991  473, 390, 664, 0, 661, 666, 669, 405, 0, 402,
1992  408, 411, 0, 660, 401, 757, 662, 403, 475, 476,
1993  474
1994 };
1995 
1996  /* YYPGOTO[NTERM-NUM]. */
1997 static const yytype_int16 yypgoto[] =
1998 {
1999  -1056, -1056, -1056, 953, -1056, 22, 743, -541, -1056, -51,
2000  -1056, 736, -1056, 115, -1056, -228, -321, -68, -1056, -1056,
2001  -1056, -32, -72, -1056, -1056, 2, -1056, -5, 735, 4,
2002  1113, -175, 26, -76, -1056, -452, -19, 2254, -362, 1108,
2003  -43, -14, -1056, -1056, 0, -1056, 3078, -1056, 1123, -1056,
2004  778, -1056, 709, 133, 601, -307, 121, -13, -1056, -283,
2005  -209, -4, -1056, -314, -25, -1056, -1056, -1056, -1056, -1056,
2006  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, 32,
2007  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056,
2008  -1056, -1056, -1056, -1056, -1056, 507, -1056, -296, 1267, -365,
2009  -1056, 127, -700, -1056, -1027, -1024, 200, 119, 363, 165,
2010  -1056, 454, -1056, -874, -1056, 40, 349, -1056, -1056, -1056,
2011  -1056, -1056, -1056, -1056, 495, -1056, -1056, -96, 722, -1056,
2012  -1056, -1056, 915, -1056, -1056, -1056, -1056, -698, -1056, 5,
2013  -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -1056, -591,
2014  -1056, -1056, -1056, -1056, 361, -1056, -1056, -1056, -851, -1056,
2015  230, -1055, -711, -779, -1056, 168, -1056, 170, 171, -1056,
2016  -409, -1056, 366, -1056, -1056, 166, -1056, -1056, 246, 28,
2017  375, -1056, 1151, 666, 777, 842, -1056, 760, 1516, -1056,
2018  2119, 2191, -1056, -1056, -59, -1056, -1056, -229, -1056, -1056,
2019  -1056, -1056, -1056, -1056, -1056, 3, -1056, -1056, -1056, -1056,
2020  -27, 2015, 1563, 1159, 2490, 1953, -1056, -1056, 314, -1056,
2021  -390, 71, -701, 421, -1019, -433, 145, -971, 75, -404,
2022  248, 226, -1056, -1056, -214, -674, -320, -969, -991, 234,
2023  266, -1056, -616, -1056, 162, -816, -1056, -1056, -1056, 157,
2024  -396, -1056, -319, -1056, -1056, -86, -1056, -7, 23, 56,
2025  -593, -236, -66, -28, -2
2026 };
2027 
2028  /* YYDEFGOTO[NTERM-NUM]. */
2029 static const yytype_int16 yydefgoto[] =
2030 {
2031  -1, 1, 2, 70, 71, 72, 243, 578, 901, 579,
2032  261, 262, 461, 263, 452, 74, 530, 75, 539, 689,
2033  885, 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, 951, 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, 1018, 1019, 1020, 1021, 1127, 1053,
2042  957, 867, 868, 958, 1139, 1140, 486, 487, 657, 755,
2043  864, 1047, 953, 1123, 325, 101, 102, 322, 512, 513,
2044  671, 767, 516, 517, 675, 769, 845, 721, 1099, 718,
2045  840, 906, 1011, 1201, 1220, 1232, 1240, 1091, 1092, 1070,
2046  792, 793, 892, 893, 794, 878, 881, 877, 976, 977,
2047  978, 1143, 979, 982, 983, 984, 985, 986, 987, 795,
2048  796, 882, 797, 798, 799, 706, 824, 898, 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, 955, 1048, 760, 113, 114, 293, 115, 116,
2052  117, 223, 224, 120, 225, 226, 599, 729, 856, 857,
2053  1106, 1027, 930, 443, 932, 933, 1117, 935, 936, 937,
2054  938, 962, 963, 939, 940, 941, 942, 943, 966, 967,
2055  944, 945, 946, 947, 948, 1030, 407, 604, 274, 444,
2056  228, 123, 642, 570, 608, 602, 411, 307, 436, 437,
2057  696, 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, 294, 260, 365, 583, 308, 412, 330, 203, 235,
2066  838, 205, 221, 221, 240, 410, 291, 536, 434, 841,
2067  215, 215, 372, 367, 367, 597, 125, 367, 203, 308,
2068  651, 205, 282, 747, 89, 474, 89, 629, 281, 476,
2069  301, 998, 1000, 309, 569, 1141, 577, 317, 222, 222,
2070  238, 270, 241, 272, 276, 1107, 405, 571, 282, 203,
2071  369, 754, 735, 373, 712, 320, 495, 497, 1115, 1135,
2072  302, 282, 282, 282, 681, 1164, 580, 629, -112, 265,
2073  1166, 1107, -107, 1049, 462, 89, 89, 1196, 374, 283,
2074  1066, 1199, 611, 612, 615, 827, 221, 3, 791, 203,
2075  222, 333, -113, 529, 215, 716, -116, 236, -643, 569,
2076  242, 577, 237, 999, 1001, 283, 361, 73, -116, 73,
2077  -84, 580, 626, 222, 222, 1035, 1036, 222, 379, 390,
2078  390, 847, 222, 315, 316, -112, 430, 219, 229, 643,
2079  -98, 852, 622, 1219, 362, 409, 256, 1057, 1058, 1059,
2080  622, -120, 1121, 525, 422, 234, 950, 305, 260, 306,
2081  356, 357, 358, 954, 318, 458, 643, 663, 446, 267,
2082  448, 237, 1120, 227, 227, 1141, 826, 654, -119, 1164,
2083  323, 1221, 827, -107, 1067, 872, 529, 529, 305, 851,
2084  306, 1135, 964, 456, 879, 308, -112, 485, 1115, -103,
2085  -118, 1107, -118, -107, 480, -731, -107, 667, 260, 909,
2086  -107, 319, 271, 275, 305, 1145, 306, 884, 1107, 427,
2087  664, 408, 676, -104, 297, 427, 221, -107, 221, -731,
2088  773, 445, 1095, 465, 215, 434, 215, 215, 733, 629,
2089  124, 89, 367, 367, 367, 367, 1122, 510, 511, 237,
2090  968, 1046, 479, -731, 464, 282, -116, 227, -116, 305,
2091  668, 306, 222, -523, 222, 222, 1071, 244, 222, 662,
2092  222, 662, -111, 643, 89, 317, 89, 260, 505, 506,
2093  507, 508, 703, 643, 724, 265, 973, 975, 711, 89,
2094  715, 89, 447, 592, 734, 298, 1171, 995, 299, -110,
2095  477, 975, 975, 367, 282, -113, 884, 308, 912, 1146,
2096  527, 1204, 283, -115, 1097, 949, 1098, 1188, 594, 584,
2097  466, 586, 522, -109, 468, -732, 595, 522, 520, 972,
2098  596, 504, -117, 531, -112, -732, -112, -120, -118, 585,
2099  -118, 89, 222, 222, 222, 222, 89, 222, 222, 300,
2100  622, 435, 622, 438, 265, -114, 1144, 73, 222, 237,
2101  89, 283, 445, 537, 889, 575, 587, 569, 215, 577,
2102  810, 812, 460, -119, 873, 874, 817, 819, 964, 326,
2103  778, 234, 319, 1068, -115, 327, 964, 227, 964, 227,
2104  449, 823, 318, 60, 1076, 884, 222, 233, 89, -644,
2105  450, 451, 89, 222, 89, 331, 480, 1082, 1083, -117,
2106  1109, 575, 890, 752, 744, 891, 531, 531, 222, -114,
2107  1093, 1116, 842, 876, 73, 846, -113, 445, 488, 509,
2108  575, 1144, 763, 215, -106, 1144, 1129, 763, 637, 853,
2109  427, 1162, 427, -113, 1136, -113, 537, 537, 315, 316,
2110  480, 688, 203, -108, 414, 205, 529, 282, 575, 338,
2111  339, 222, 961, 529, 529, 929, 629, 929, 926, 529,
2112  529, -635, -106, 488, 929, -120, -105, -120, 992, 993,
2113  910, 489, 445, 490, 491, 575, 1218, 1144, 215, 416,
2114  1022, 630, 927, -643, 236, 895, 632, 89, 576, 634,
2115  -635, 282, 636, 425, 1119, -634, 349, 350, 964, 418,
2116  964, -119, 488, -119, 283, 964, 222, 964, 646, 714,
2117  -112, 727, -115, 648, -115, 423, 493, 994, 490, 491,
2118  708, 618, 710, 1008, -634, 1238, 736, 431, 1010, 904,
2119  -103, 744, 905, -636, -108, 907, 965, -117, 424, -117,
2120  -746, 1208, 911, 237, 964, 914, 694, -114, 283, -114,
2121  -644, 1200, 929, 576, 701, 493, 1214, 490, 491, 433,
2122  751, 975, -636, -106, 753, 702, 690, 707, 453, 622,
2123  1179, 680, 623, 1022, 1101, -637, 595, -113, 529, 445,
2124  875, 576, 575, -106, 695, 215, -106, 415, 740, 445,
2125  -106, -639, 575, 741, 488, 215, 480, -104, -638, 702,
2126  -353, -640, 230, 89, -637, 89, 1015, 203, 576, 488,
2127  205, 427, -629, 222, -120, 282, -632, 649, 488, 1032,
2128  -639, 233, -105, 222, 606, 89, 222, -638, -353, -353,
2129  -640, 702, 333, 859, -111, -108, 432, 1033, 961, 695,
2130  -746, -629, 961, 1043, 237, -632, 961, 282, 961, 490,
2131  491, 367, 849, 607, 827, -108, 719, 988, -108, 1022,
2132  222, 1022, -108, -120, 490, 491, 848, 695, 988, 988,
2133  459, 494, 283, 490, 491, 445, 531, -353, 575, 814,
2134  762, 215, 361, 531, 531, 858, 821, 850, 463, 531,
2135  531, 522, 693, 825, 831, 765, 837, -119, 837, 1112,
2136  699, 89, -83, 1077, 283, 89, 537, 800, 469, 222,
2137  362, 363, 475, 537, 537, 576, 1159, -110, 459, 537,
2138  537, 1078, 965, -105, 470, 576, 1133, 78, 203, 78,
2139  965, 471, 965, 415, 699, 980, 478, 695, 427, 488,
2140  496, 78, 78, -105, 748, -119, -105, 695, -728, 89,
2141  -105, 222, 89, 482, 921, 869, 367, 869, 643, 364,
2142  -120, 502, 1022, 1022, 514, 693, 699, 900, 961, 1154,
2143  961, -115, 902, 488, 913, 961, 473, 961, 78, 78,
2144  750, 361, 854, 471, 772, 925, 488, 988, 774, 981,
2145  -629, 695, 903, 78, 490, 491, 749, 863, 361, 528,
2146  695, 800, 800, 861, 589, 1111, 971, -310, 531, 362,
2147  428, 576, 899, 1177, 961, 503, 78, 78, -629, -629,
2148  78, 832, 827, -117, 273, 78, 362, 457, 490, 491,
2149  -114, 1148, 1111, 697, 593, -310, -310, 698, 537, 493,
2150  1009, 490, 491, -729, 1148, 816, 1194, 598, 361, 1014,
2151  89, 988, 965, 237, 965, 89, 222, 631, 429, 965,
2152  -115, 965, 282, 640, -117, -728, 673, -629, 1160, 1161,
2153  -728, 89, -114, 1211, 1044, 429, 362, 483, 89, 970,
2154  488, 333, 887, 888, -310, -632, 633, -732, 635, 89,
2155  -98, 641, 89, 670, 679, 800, 800, 915, 965, 916,
2156  917, 918, 919, 695, 800, 800, 800, 650, 1087, -283,
2157  800, 800, 1073, -632, -632, 678, -641, 682, 683, 1004,
2158  704, 697, 684, 89, 709, 484, 282, 1031, 1079, 1031,
2159  1031, 960, 89, 660, 78, 490, 491, 996, 354, 355,
2160  356, 357, 358, -642, -641, -641, 1016, 1088, -115, 1090,
2161  716, 1031, 1031, 1031, 719, 78, 768, 78, 78, 698,
2162  -729, 78, -632, 78, 816, -729, -284, 78, -106, 78,
2163  970, -642, -642, 764, 809, 417, 1023, 1024, 419, 420,
2164  421, -301, 78, 1055, 78, 766, -117, 1124, 815, 695,
2165  934, -114, 934, -641, 361, 800, 827, 831, 361, 934,
2166  855, 959, 837, 800, 862, 1038, -108, 1041, 866, -301,
2167  -301, -105, -285, 695, 695, 880, 282, 883, 969, 1065,
2168  -642, -311, 362, 590, 884, 886, 362, 600, 897, 800,
2169  89, -286, 89, 1025, 78, 78, 78, 78, 78, 78,
2170  78, 78, 781, 1026, 1080, 1081, -735, 1029, 488, -311,
2171  -311, 78, 1034, 78, 801, 1037, 78, 1039, -301, 970,
2172  1040, 1180, 1042, 1050, 361, 1051, 1103, 89, 1052, 1056,
2173  89, 591, 1064, 1126, 445, 601, 707, 575, 837, 1060,
2174  215, 1062, 367, 367, 1072, 800, 1074, 934, -735, 78,
2175  1075, 78, 362, 686, 521, 78, 78, 78, -311, 534,
2176  1031, 665, 1114, 490, 491, 1118, 1084, 361, 222, 826,
2177  1102, 78, 1104, 614, 616, 1125, -735, -735, 1202, 1203,
2178  1130, 1031, 1061, 1063, 1142, 1134, 1147, 1137, 361, 1167,
2179  614, 616, 1169, 1033, 1172, 362, 1085, 1174, 1178, 78,
2180  78, 687, 1181, 89, 89, 1182, 1163, 920, 801, 801,
2181  1184, -731, 1195, 1189, 78, 1191, 362, 1131, 644, 1197,
2182  800, 934, 1198, -735, 800, -735, 921, 695, -731, 1168,
2183  1170, 1235, 934, 1205, 1206, 1173, 1212, 1175, -732, 1176,
2184  800, 1113, 222, 222, 1086, 455, 1113, 959, 1223, 1228,
2185  78, 647, 619, 621, 645, 959, 394, 925, 926, 377,
2186  360, 273, 739, 829, 969, 601, 1100, 1158, 1113, 78,
2187  576, 1165, 969, 870, 969, 800, 800, 757, 758, 956,
2188  759, 989, 927, 837, 1217, 860, 672, 46, 47, 518,
2189  1239, 1094, 1207, 1149, 1209, 1150, 1151, 991, 621, 1210,
2190  990, 273, 801, 801, 1157, 1089, 413, 1213, 406, 1215,
2191  666, 801, 801, 801, 89, 1045, 1216, 801, 801, 100,
2192  915, 100, 916, 917, 918, 919, 931, 1110, 1222, 1224,
2193  1225, 1226, 1132, 100, 100, 915, 1128, 916, 917, 918,
2194  919, 920, 1108, 1183, 1185, 0, 0, 677, 1233, 1190,
2195  0, 1192, 1193, 1234, 1236, 310, 311, 312, 313, 314,
2196  921, 0, 934, 0, 0, 0, 78, 0, 78, 1016,
2197  100, 100, 0, 0, 922, 1017, 78, 959, 915, 0,
2198  916, 917, 918, 919, 923, 100, 78, 0, 78, 78,
2199  924, 925, 926, 0, 969, 1138, 969, 916, 917, 918,
2200  919, 969, 801, 969, 0, 802, 0, 0, 100, 100,
2201  801, 0, 100, 0, 0, 0, 927, 100, 0, 928,
2202  0, 0, 0, 78, 41, 42, 43, 44, 1227, 1229,
2203  1230, 1231, 0, 0, 0, 0, 801, 333, 0, 0,
2204  969, 0, 0, 0, 0, 0, 742, 0, 743, 1237,
2205  811, 813, 0, 0, 346, 347, 818, 820, 0, 0,
2206  0, 621, 333, 273, 78, 0, 0, 0, 78, 78,
2207  0, 0, 78, 0, 0, 0, 78, 78, 0, 346,
2208  347, 0, 78, 78, 0, 915, 0, 916, 917, 918,
2209  919, 920, 801, 353, 354, 355, 356, 357, 358, 802,
2210  802, 0, 0, 0, 811, 813, 771, 818, 820, 0,
2211  921, 0, 78, 0, 78, 78, 803, 0, 0, 354,
2212  355, 356, 357, 358, 0, 0, 100, 0, 0, 0,
2213  0, 0, 0, 822, 923, 0, 0, 0, 0, 0,
2214  924, 925, 926, 0, 0, 0, 0, 100, 844, 100,
2215  100, 0, 0, 100, 0, 100, 0, 0, 0, 100,
2216  0, 100, 0, 0, 0, 0, 927, 801, 0, 928,
2217  0, 801, 0, 0, 100, 896, 100, 0, 0, 0,
2218  0, 804, 0, 0, 0, 0, 237, 801, 0, 0,
2219  0, 0, 0, 802, 802, 0, 0, 0, 871, 0,
2220  0, 78, 802, 802, 802, 0, 0, 0, 802, 802,
2221  803, 803, 0, 78, 0, 119, 0, 119, 78, 78,
2222  896, 0, 801, 801, 0, 0, 100, 100, 100, 100,
2223  100, 100, 100, 100, 78, 0, 0, 0, 0, 0,
2224  0, 78, 0, 100, 0, 100, 0, 0, 100, 0,
2225  0, 0, 78, 0, 0, 78, 0, 0, 0, 0,
2226  0, 0, 0, 0, 0, 0, 119, 119, 0, 0,
2227  285, 908, 0, 0, 0, 804, 804, 0, 0, 0,
2228  0, 100, 0, 100, 0, 0, 78, 100, 100, 100,
2229  273, 0, 0, 802, 0, 78, 285, 0, 0, 0,
2230  0, 802, 0, 100, 803, 803, 0, 0, 0, 382,
2231  392, 392, 392, 803, 803, 803, 0, 0, 0, 803,
2232  803, 0, 0, 0, 0, 0, 0, 802, 0, 0,
2233  0, 100, 100, 0, 0, 0, 0, 1013, 0, 0,
2234  0, 0, 0, 0, 0, 0, 100, 0, 0, 0,
2235  915, 0, 916, 917, 918, 919, 920, 0, 0, 0,
2236  0, 0, 0, 0, 0, 1028, 0, 0, 0, 804,
2237  804, 0, 0, 0, 0, 921, 0, 0, 804, 804,
2238  804, 0, 100, 802, 804, 804, 0, 0, 0, 0,
2239  0, 0, 0, 78, 0, 78, 0, 0, 0, 923,
2240  0, 100, 0, 0, 803, 924, 925, 926, 0, 0,
2241  0, 915, 803, 916, 917, 918, 919, 920, 0, 0,
2242  0, 0, 119, 0, 0, 0, 0, 332, 0, 0,
2243  78, 927, 0, 78, 928, 0, 921, 0, 803, 0,
2244  1096, 0, 0, 0, 0, 0, 952, 0, 0, 0,
2245  0, 0, 0, 1105, 0, 119, 0, 119, 802, 0,
2246  923, 0, 802, 0, 0, 0, 924, 925, 926, 804,
2247  119, 78, 119, 0, 0, 0, 0, 804, 802, 333,
2248  334, 335, 336, 337, 338, 339, 340, 341, 342, 343,
2249  344, 345, 927, 285, 803, 928, 346, 347, 100, 0,
2250  100, 0, 0, 804, 0, 0, 78, 78, 100, 0,
2251  0, 0, 0, 802, 802, 0, 0, 0, 100, 0,
2252  100, 100, 119, 0, 0, 0, 0, 119, 0, 348,
2253  0, 349, 350, 351, 352, 353, 354, 355, 356, 357,
2254  358, 119, 285, 0, 0, 78, 78, 0, 0, 0,
2255  0, 0, 0, 0, 0, 100, 0, 0, 0, 804,
2256  0, 0, 915, 0, 916, 917, 918, 919, 920, 803,
2257  0, 0, 0, 803, 0, 0, 0, 0, 0, 119,
2258  0, 0, 0, 119, 0, 119, 0, 921, 0, 803,
2259  0, 0, 0, 0, 0, 0, 100, 0, 0, 0,
2260  100, 100, 0, 0, 100, 122, 0, 122, 100, 100,
2261  0, 923, 0, 0, 100, 100, 0, 78, 925, 926,
2262  0, 0, 0, 0, 803, 803, 0, 0, 0, 0,
2263  0, 0, 0, 0, 804, 0, 0, 0, 804, 0,
2264  0, 0, 0, 927, 100, 0, 100, 100, 333, 0,
2265  0, 0, 0, 0, 804, 0, 122, 122, 0, 0,
2266  286, 0, 0, 0, 0, 346, 347, 118, 0, 118,
2267  0, 0, 0, 0, 0, 0, 0, 0, 119, 0,
2268  0, 0, 0, 0, 0, 0, 286, 0, 0, 804,
2269  804, 0, 0, 0, 0, 285, 0, 0, 0, 383,
2270  393, 393, 351, 352, 353, 354, 355, 356, 357, 358,
2271  0, 0, 0, 0, 0, 0, 0, 0, 118, 118,
2272  0, 0, 284, 0, 0, 0, 0, 0, 0, 0,
2273  0, 0, 0, 100, 0, 0, 0, 0, 0, 285,
2274  0, 0, 0, 0, 0, 100, 0, 0, 284, 0,
2275  100, 100, 23, 24, 25, 26, 0, 0, 0, 0,
2276  0, 381, 391, 391, 391, 0, 100, 0, 32, 33,
2277  34, 781, 0, 100, 0, 782, 0, 0, 41, 42,
2278  43, 44, 45, 0, 100, 0, 0, 100, 0, 0,
2279  0, 0, 0, 0, 119, 0, 119, 0, 0, 0,
2280  0, 0, 0, 0, 0, 0, 0, 0, 0, 783,
2281  784, 0, 122, 0, 0, 0, 119, 785, 100, 0,
2282  786, 0, 0, 787, 788, 0, 974, 100, 0, 789,
2283  59, 60, 61, 62, 63, 64, 65, 66, 0, 0,
2284  0, 0, 0, 0, 0, 122, 0, 122, 0, 0,
2285  0, 790, 0, 0, 0, 805, 0, 0, 279, 0,
2286  122, 0, 122, 285, 0, 0, 0, 0, 0, 0,
2287  0, 0, 0, 0, 118, 0, 0, 0, 0, 0,
2288  0, 0, 0, 286, 0, 0, 0, 0, 0, 0,
2289  0, 0, 119, 0, 0, 285, 119, 0, 0, 0,
2290  0, 0, 808, 0, 0, 0, 85, 118, 85, 118,
2291  0, 0, 122, 0, 0, 0, 0, 122, 0, 0,
2292  0, 0, 118, 0, 118, 100, 0, 100, 0, 0,
2293  0, 122, 286, 0, 538, 0, 0, 0, 0, 0,
2294  119, 0, 0, 119, 0, 284, 0, 0, 0, 805,
2295  805, 0, 0, 0, 0, 0, 0, 85, 85, 0,
2296  0, 0, 100, 0, 0, 100, 0, 0, 0, 122,
2297  0, 0, 0, 122, 118, 122, 0, 0, 0, 118,
2298  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2299  0, 0, 0, 118, 284, 0, 808, 808, 0, 0,
2300  378, 0, 0, 100, 0, 0, 0, 0, 0, 0,
2301  0, 0, 0, 0, 0, 0, 0, 538, 538, 0,
2302  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2303  0, 118, 0, 0, 0, 118, 0, 118, 100, 100,
2304  0, 119, 0, 805, 805, 0, 119, 0, 0, 0,
2305  0, 0, 805, 805, 805, 0, 0, 0, 805, 805,
2306  0, 0, 119, 0, 0, 0, 0, 0, 122, 119,
2307  0, 0, 0, 0, 0, 0, 0, 100, 100, 0,
2308  119, 0, 0, 119, 0, 286, 0, 0, 0, 0,
2309  808, 808, 0, 0, 0, 0, 0, 0, 0, 808,
2310  808, 808, 0, 0, 0, 808, 808, 0, 0, 0,
2311  1006, 0, 0, 85, 119, 0, 0, 0, 0, 0,
2312  0, 0, 0, 119, 0, 0, 0, 0, 0, 286,
2313  118, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2314  0, 0, 121, 805, 121, 0, 85, 284, 85, 100,
2315  0, 805, 0, 0, 0, 0, 0, 0, 0, 0,
2316  0, 85, 0, 85, 0, 0, 0, 0, 0, 0,
2317  0, 0, 0, 0, 392, 0, 0, 805, 0, 0,
2318  0, 0, 0, 0, 122, 0, 122, 0, 0, 0,
2319  808, 284, 0, 121, 121, 0, 0, 0, 808, 0,
2320  0, 0, 0, 0, 0, 0, 122, 0, 0, 0,
2321  0, 0, 0, 85, 0, 0, 0, 0, 85, 0,
2322  0, 119, 0, 119, 808, 0, 0, 0, 0, 0,
2323  0, 0, 85, 805, 0, 532, 0, 0, 0, 0,
2324  0, 0, 0, 0, 0, 0, 118, 0, 118, 0,
2325  0, 0, 0, 286, 0, 0, 0, 0, 119, 0,
2326  0, 119, 761, 0, 392, 0, 0, 0, 118, 0,
2327  85, 0, 0, 0, 85, 0, 85, 0, 0, 0,
2328  808, 0, 122, 0, 0, 286, 122, 538, 0, 0,
2329  0, 0, 0, 0, 538, 538, 0, 0, 0, 0,
2330  538, 538, 0, 0, 0, 0, 0, 0, 805, 0,
2331  0, 0, 805, 0, 0, 284, 0, 0, 532, 532,
2332  0, 0, 0, 0, 23, 24, 25, 26, 805, 0,
2333  122, 0, 0, 122, 119, 119, 0, 0, 0, 0,
2334  32, 33, 34, 0, 118, 0, 0, 284, 118, 121,
2335  41, 42, 43, 44, 45, 808, 0, 0, 0, 808,
2336  0, 0, 0, 805, 805, 0, 0, 0, 0, 85,
2337  0, 0, 0, 0, 0, 808, 0, 0, 0, 0,
2338  0, 0, 121, 0, 121, 0, 0, 0, 0, 0,
2339  0, 0, 118, 0, 0, 118, 0, 121, 0, 121,
2340  0, 789, 59, 60, 61, 62, 63, 64, 65, 66,
2341  808, 808, 0, 0, 0, 0, 0, 0, 0, 538,
2342  0, 0, 0, 333, -758, -758, -758, -758, 338, 339,
2343  279, 122, -758, -758, 0, 0, 122, 0, 0, 0,
2344  346, 347, 0, 0, 0, 119, 0, 0, 0, 121,
2345  0, 0, 122, 0, 121, 0, 0, 0, 806, 122,
2346  0, 0, 0, 0, 0, 0, 0, 0, 121, 0,
2347  122, 121, 0, 122, 0, 349, 350, 351, 352, 353,
2348  354, 355, 356, 357, 358, 85, 0, 85, 0, 0,
2349  0, 0, 0, 118, 0, 0, 0, 0, 118, 0,
2350  1007, 0, 0, 0, 122, 0, 121, 85, 0, 0,
2351  121, 0, 121, 122, 118, 0, 0, 0, 0, 0,
2352  0, 118, 0, 0, 0, 0, 0, 0, 0, 0,
2353  807, 0, 118, 0, 0, 118, 0, 0, 0, 0,
2354  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2355  0, 0, 806, 806, 121, 121, 0, 0, 0, 0,
2356  0, 0, 1005, 0, 393, 0, 118, 0, 0, 0,
2357  0, 0, 0, 0, 0, 118, 0, 0, 0, 0,
2358  0, 0, 0, 85, 0, 0, 0, 85, 532, 0,
2359  0, 0, 0, 0, 0, 532, 532, 0, 0, 0,
2360  0, 532, 532, 0, 0, 121, 0, 0, 0, 0,
2361  0, 122, 0, 122, 0, 0, 0, 0, 0, 0,
2362  0, 0, 0, 0, 807, 807, 391, 0, 0, 0,
2363  0, 85, 0, 0, 85, 333, 334, 335, 336, 337,
2364  338, 339, 340, 0, 342, 343, 806, 806, 122, 0,
2365  0, 122, 346, 347, 393, 806, 806, 806, 0, 0,
2366  0, 806, 806, 0, 0, 0, 0, 0, 0, 0,
2367  0, 0, 0, 118, 0, 118, 0, 0, 0, 0,
2368  0, 0, 0, 0, 0, 0, 0, 349, 350, 351,
2369  352, 353, 354, 355, 356, 357, 358, 0, 0, 0,
2370  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2371  118, 0, 0, 118, 0, 0, 391, 0, 807, 807,
2372  532, 121, 0, 121, 122, 122, 0, 807, 807, 807,
2373  0, 0, 85, 807, 807, 0, 0, 85, 0, 0,
2374  0, 0, 0, 121, 217, 217, 806, 0, 0, 0,
2375  0, 0, 0, 85, 806, 0, 0, 0, 0, 0,
2376  85, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2377  0, 85, 0, 0, 85, 0, 250, 253, 254, 255,
2378  806, 0, 0, 217, 217, 0, 118, 118, 0, 0,
2379  0, 0, 0, 0, 0, 0, 303, 304, 0, 0,
2380  0, 1003, 0, 0, 0, 85, 0, 0, 0, 0,
2381  0, 0, 0, 0, 85, 0, 0, 0, 807, 121,
2382  0, 0, 0, 121, 121, 0, 807, 0, 217, 0,
2383  0, 121, 121, 0, 0, 122, 806, 121, 121, 0,
2384  0, 0, 0, 0, 0, 0, 0, 0, 0, -757,
2385  0, 0, 807, 0, 0, 0, 0, -757, -757, -757,
2386  0, 0, -757, -757, -757, 0, -757, 121, 0, 0,
2387  121, 0, 0, 0, -757, -757, -757, 0, 0, 0,
2388  0, 0, 0, 0, 0, 0, -757, -757, 0, -757,
2389  -757, -757, -757, -757, 0, 0, 0, 118, 0, 0,
2390  0, 0, 0, 0, 0, 0, 0, 0, 807, 0,
2391  0, 806, 85, 0, 85, 806, 0, -757, 0, 0,
2392  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2393  0, 806, 0, 0, 0, 217, 0, 0, 217, 217,
2394  217, 0, 303, 0, 0, -757, -757, 0, 0, 85,
2395  0, 0, 85, 0, 0, 0, 121, 0, 217, 0,
2396  217, 217, 0, 0, 0, 0, 806, 806, 121, -757,
2397  0, 0, 0, 121, 0, 0, 0, 0, 0, 0,
2398  0, 0, 0, 807, 0, 0, 0, 807, 0, 121,
2399  0, 0, -757, -757, 0, 0, 121, 233, -757, 0,
2400  -757, 0, -757, 807, 0, 0, 0, 121, 0, 0,
2401  121, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2402  0, 0, 0, 0, 0, 85, 85, 0, 0, 0,
2403  0, 0, 0, 0, 0, 0, 0, 0, 807, 807,
2404  0, 121, 0, 0, 0, 0, 0, 0, 0, 0,
2405  121, 0, 0, 0, 217, 0, 0, 0, 0, 533,
2406  0, 540, 541, 542, 543, 544, 0, 0, 545, 546,
2407  547, 548, 549, 550, 551, 552, 553, 0, 0, 554,
2408  555, 556, 557, 558, 559, 560, 561, 562, 563, 0,
2409  0, 0, 217, 0, 0, 0, 0, 0, 0, 0,
2410  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2411  0, 0, 0, 0, 0, 0, 333, 334, 335, 336,
2412  337, 338, 339, 340, 341, 342, 343, 344, 345, 0,
2413  0, 0, 0, 346, 347, 0, 85, 0, 0, 0,
2414  0, 0, 613, 613, 0, 0, 0, 0, 121, 0,
2415  121, 613, 217, 217, 0, 0, 0, 217, 0, 613,
2416  613, 217, 0, 0, 0, 0, 348, 255, 349, 350,
2417  351, 352, 353, 354, 355, 356, 357, 358, 0, 0,
2418  0, 0, 639, 0, 0, 121, 0, 613, 121, 0,
2419  0, 0, 237, 0, 0, 0, 0, 0, 217, 0,
2420  0, 217, 0, 0, 0, 0, 0, 0, 0, 0,
2421  0, 0, 217, 0, 0, 0, 0, 0, 0, 0,
2422  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2423  669, 333, 334, 335, 336, 337, 338, 339, 340, 341,
2424  342, 343, -758, -758, 0, 0, 0, 217, 346, 347,
2425  0, 0, 0, 0, 0, 0, -735, 0, 0, 0,
2426  0, 121, 121, 0, -735, -735, -735, 0, 0, 0,
2427  -735, -735, 0, -735, 0, 0, 0, 0, 0, 0,
2428  0, -735, -735, 349, 350, 351, 352, 353, 354, 355,
2429  356, 357, 358, -735, -735, 0, -735, -735, -735, -735,
2430  -735, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2431  0, 0, 0, 0, 0, 0, 0, 0, 0, 217,
2432  0, 0, 0, 0, -735, 0, 0, 0, 0, 217,
2433  0, 0, 0, -735, -735, -735, -735, -735, -735, -735,
2434  -735, -735, -735, -735, -735, -735, 217, 0, 217, 0,
2435  -735, -735, -735, -735, 0, 691, 0, 0, 0, 0,
2436  0, 217, 0, 217, 0, 0, 0, 0, 0, 0,
2437  0, 0, 121, 0, 0, 0, -735, 0, 0, 0,
2438  0, 0, -116, -735, 0, -735, -735, -735, -735, -735,
2439  -735, -735, -735, -735, -735, 0, 0, 0, 0, -735,
2440  -735, -735, -107, 0, 0, -735, 217, -735, 0, -735,
2441  0, 0, 613, 775, 0, 217, 0, 0, 0, 613,
2442  613, 0, 0, 0, 0, 613, 613, 0, -629, 0,
2443  0, 0, 0, 217, 0, 0, -629, -629, -629, 0,
2444  0, -629, -629, -629, 0, -629, 0, 0, 217, 0,
2445  0, 0, 0, -629, 0, -629, -629, -629, 0, 0,
2446  0, 0, 0, 0, 0, -629, -629, 0, -629, -629,
2447  -629, -629, -629, 613, 613, 0, 613, 613, 0, 0,
2448  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2449  0, 0, 0, 0, 0, 0, -629, 0, 217, 0,
2450  0, 0, 0, 0, 0, -629, -629, -629, -629, -629,
2451  -629, -629, -629, -629, -629, -629, -629, -629, 0, 0,
2452  0, 0, -629, -629, -629, -629, 0, -629, -629, 0,
2453  0, 0, 0, 0, -629, 0, 0, 894, 0, 0,
2454  0, 0, 0, 0, 613, 0, 0, 0, -629, 0,
2455  0, -629, 0, 0, -629, -629, -629, -629, -629, -629,
2456  -629, -629, -629, -629, -629, -629, -629, 0, 0, 0,
2457  0, 217, -629, -629, -629, 0, 0, -629, -629, -629,
2458  0, -629, 0, 0, 0, 0, 0, 0, 0, 613,
2459  217, 0, 0, -757, 4, 0, 5, 6, 7, 8,
2460  9, 0, 0, 0, 10, 11, 0, 0, 0, 12,
2461  0, 13, 14, 15, 16, 17, 18, 19, 0, 0,
2462  0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
2463  0, 0, 27, 0, 0, 0, 0, 217, 28, 29,
2464  30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2465  40, 0, 41, 42, 43, 44, 45, 46, 47, 0,
2466  0, 0, 0, 0, 0, 217, 0, 0, 48, 49,
2467  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2468  0, 0, 0, 50, 51, 0, 0, 0, 0, 0,
2469  0, 52, 0, 0, 53, 54, 0, 55, 56, 0,
2470  57, 0, 0, 58, 59, 60, 61, 62, 63, 64,
2471  65, 66, 0, 0, 0, 0, 0, 0, 0, 0,
2472  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2473  0, 0, 67, 68, 69, 0, 0, 0, 0, 0,
2474  217, -735, 0, 0, -757, 0, -757, 0, 0, -735,
2475  -735, -735, 0, 217, -735, -735, -735, 0, -735, 0,
2476  0, 0, 0, 0, 0, 0, -735, -735, -735, -735,
2477  -735, 0, 0, 0, 0, 0, 0, 0, -735, -735,
2478  0, -735, -735, -735, -735, -735, 0, 0, 0, 0,
2479  0, 0, 0, 0, 0, 0, 0, 0, 333, 334,
2480  335, 336, 337, 338, 339, 0, 0, 342, 343, -735,
2481  0, 0, 0, 0, 217, 346, 347, 0, -735, -735,
2482  -735, -735, -735, -735, -735, -735, -735, -735, -735, -735,
2483  -735, 0, 0, 0, 0, -735, -735, -735, -735, 0,
2484  745, -735, 0, 0, 0, 0, 0, -735, 0, 0,
2485  349, 350, 351, 352, 353, 354, 355, 356, 357, 358,
2486  0, -735, 0, 0, -735, 0, 0, -116, -735, -735,
2487  -735, -735, -735, -735, -735, -735, -735, -735, -735, -735,
2488  0, 0, 0, 0, -735, -735, -735, -735, -632, 0,
2489  -735, -735, -735, 0, -735, 0, -632, -632, -632, 0,
2490  0, -632, -632, -632, 0, -632, 0, 0, 0, 0,
2491  685, 0, 0, -632, 0, -632, -632, -632, 0, 0,
2492  0, 0, 0, 0, 0, -632, -632, 0, -632, -632,
2493  -632, -632, -632, 0, 0, 0, 0, 0, 0, 0,
2494  0, 0, 0, 333, 334, 335, 336, 337, 338, 339,
2495  340, 341, 342, 343, 344, 345, -632, 0, 0, 0,
2496  346, 347, 0, 0, 0, -632, -632, -632, -632, -632,
2497  -632, -632, -632, -632, -632, -632, -632, -632, 0, 0,
2498  0, 0, -632, -632, -632, -632, 0, -632, -632, 0,
2499  0, 0, 0, 348, -632, 349, 350, 351, 352, 353,
2500  354, 355, 356, 357, 358, 0, 0, 0, -632, 0,
2501  0, -632, -257, 0, -632, -632, -632, -632, -632, -632,
2502  -632, -632, -632, -632, -632, -632, -632, 0, 0, 0,
2503  0, 0, -632, -632, -632, -736, 0, -632, -632, -632,
2504  0, -632, 0, -736, -736, -736, 0, 0, -736, -736,
2505  -736, 0, -736, 0, 0, 0, 0, 685, 0, 0,
2506  -736, -736, -736, -736, -736, 0, 0, 0, 0, 0,
2507  0, 0, -736, -736, 0, -736, -736, -736, -736, -736,
2508  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2509  333, 334, 335, 336, 337, 338, 339, 340, 341, 342,
2510  343, 344, 345, -736, 0, 0, 0, 346, 347, 0,
2511  0, 0, -736, -736, -736, -736, -736, -736, -736, -736,
2512  -736, -736, -736, -736, -736, 0, 0, 0, 0, -736,
2513  -736, -736, -736, 0, 0, -736, 0, 0, 0, 0,
2514  348, -736, 349, 350, 351, 352, 353, 354, 355, 356,
2515  357, 358, 0, 0, 0, -736, 0, 0, -736, 0,
2516  0, 0, -736, -736, -736, -736, -736, -736, -736, -736,
2517  -736, -736, -736, -736, 0, 0, 0, 0, -736, -736,
2518  -736, -736, -737, 0, -736, -736, -736, 0, -736, 0,
2519  -737, -737, -737, 0, 0, -737, -737, -737, 0, -737,
2520  0, 0, 0, 0, 0, 0, 0, -737, -737, -737,
2521  -737, -737, 0, 0, 0, 0, 0, 0, 0, -737,
2522  -737, 0, -737, -737, -737, -737, -737, 0, 0, 0,
2523  0, 0, 0, 0, 0, 0, 0, 333, 334, 335,
2524  336, 337, 338, 339, 340, 341, 342, 343, 344, 345,
2525  -737, 0, 0, 0, 346, 347, 0, 0, 0, -737,
2526  -737, -737, -737, -737, -737, -737, -737, -737, -737, -737,
2527  -737, -737, 0, 0, 0, 0, -737, -737, -737, -737,
2528  0, 0, -737, 0, 0, 0, 0, 348, -737, 349,
2529  350, 351, 352, 353, 354, 355, 356, 357, 358, 0,
2530  0, 0, -737, 0, 0, -737, 0, 0, 0, -737,
2531  -737, -737, -737, -737, -737, -737, -737, -737, -737, -737,
2532  -737, 0, 0, 0, 0, -737, -737, -737, -737, -310,
2533  0, -737, -737, -737, 0, -737, 0, -310, -310, -310,
2534  0, 0, -310, -310, -310, 0, -310, 0, 0, 0,
2535  0, 0, 0, 0, -310, 0, -310, -310, -310, 0,
2536  0, 0, 0, 0, 0, 0, -310, -310, 0, -310,
2537  -310, -310, -310, -310, 0, 0, 0, 0, 0, 0,
2538  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2539  0, 0, 0, 0, 0, 0, 0, -310, 0, 0,
2540  0, 0, 0, 0, 0, 0, -310, -310, -310, -310,
2541  -310, -310, -310, -310, -310, -310, -310, -310, -310, 0,
2542  0, 0, 0, -310, -310, -310, -310, 0, 746, -310,
2543  0, 0, 0, 0, 0, -310, 0, 0, 0, 0,
2544  0, 0, 0, 0, 0, 0, 0, 0, 0, -310,
2545  0, 0, -310, 0, 0, -118, -310, -310, -310, -310,
2546  -310, -310, -310, -310, -310, -310, -310, -310, 0, 0,
2547  0, 0, 0, -310, -310, -310, -449, 0, -310, -310,
2548  -310, 0, -310, 0, -449, -449, -449, 0, 0, -449,
2549  -449, -449, 0, -449, 0, 0, 0, 0, 0, 0,
2550  0, -449, -449, -449, -449, 0, 0, 0, 0, 0,
2551  0, 0, 0, -449, -449, 0, -449, -449, -449, -449,
2552  -449, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2553  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2554  0, 0, 0, 0, -449, 0, 0, 0, 0, 0,
2555  0, 0, 0, -449, -449, -449, -449, -449, -449, -449,
2556  -449, -449, -449, -449, -449, -449, 0, 0, 0, 0,
2557  -449, -449, -449, -449, 0, 0, -449, 0, 0, 0,
2558  0, 0, -449, 0, 0, 0, 0, 0, 0, 0,
2559  0, 0, 0, 0, 0, 0, -449, 0, 0, 0,
2560  0, 0, 0, -449, 0, -449, -449, -449, -449, -449,
2561  -449, -449, -449, -449, -449, 0, 0, 0, 0, -449,
2562  -449, -449, -449, -302, 233, -449, -449, -449, 0, -449,
2563  0, -302, -302, -302, 0, 0, -302, -302, -302, 0,
2564  -302, 0, 0, 0, 0, 0, 0, 0, -302, 0,
2565  -302, -302, -302, 0, 0, 0, 0, 0, 0, 0,
2566  -302, -302, 0, -302, -302, -302, -302, -302, 0, 0,
2567  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2568  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2569  0, -302, 0, 0, 0, 0, 0, 0, 0, 0,
2570  -302, -302, -302, -302, -302, -302, -302, -302, -302, -302,
2571  -302, -302, -302, 0, 0, 0, 0, -302, -302, -302,
2572  -302, 0, 0, -302, 0, 0, 0, 0, 0, -302,
2573  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2574  0, 0, 0, -302, 0, 0, -302, 0, 0, 0,
2575  -302, -302, -302, -302, -302, -302, -302, -302, -302, -302,
2576  -302, -302, 0, 0, 0, 0, 0, -302, -302, -302,
2577  -757, 0, -302, -302, -302, 0, -302, 0, -757, -757,
2578  -757, 0, 0, -757, -757, -757, 0, -757, 0, 0,
2579  0, 0, 0, 0, 0, -757, -757, -757, -757, 0,
2580  0, 0, 0, 0, 0, 0, 0, -757, -757, 0,
2581  -757, -757, -757, -757, -757, 0, 0, 0, 0, 0,
2582  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2583  0, 0, 0, 0, 0, 0, 0, 0, -757, 0,
2584  0, 0, 0, 0, 0, 0, 0, -757, -757, -757,
2585  -757, -757, -757, -757, -757, -757, -757, -757, -757, -757,
2586  0, 0, 0, 0, -757, -757, -757, -757, 0, 0,
2587  -757, 0, 0, 0, 0, 0, -757, 0, 0, 0,
2588  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2589  -757, 0, 0, 0, 0, 0, 0, -757, 0, -757,
2590  -757, -757, -757, -757, -757, -757, -757, -757, -757, 0,
2591  0, 0, 0, -757, -757, -757, -757, -317, 233, -757,
2592  -757, -757, 0, -757, 0, -317, -317, -317, 0, 0,
2593  -317, -317, -317, 0, -317, 0, 0, 0, 0, 0,
2594  0, 0, -317, 0, -317, -317, 0, 0, 0, 0,
2595  0, 0, 0, 0, -317, -317, 0, -317, -317, -317,
2596  -317, -317, 0, 0, 0, 0, 0, 0, 0, 0,
2597  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2598  0, 0, 0, 0, 0, -317, 0, 0, 0, 0,
2599  0, 0, 0, 0, -317, -317, -317, -317, -317, -317,
2600  -317, -317, -317, -317, -317, -317, -317, 0, 0, 0,
2601  0, -317, -317, -317, -317, 0, 0, -317, 0, 0,
2602  0, 0, 0, -317, 0, 0, 0, 0, 0, 0,
2603  0, 0, 0, 0, 0, 0, 0, -317, 0, 0,
2604  0, 0, 0, 0, -317, 0, -317, -317, -317, -317,
2605  -317, -317, -317, -317, -317, -317, 0, 0, 0, 0,
2606  0, -317, -317, -317, -735, 230, -317, -317, -317, 0,
2607  -317, 0, -735, -735, -735, 0, 0, 0, -735, -735,
2608  0, -735, 0, 0, 0, 0, 0, 0, 0, -735,
2609  -735, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2610  0, -735, -735, 0, -735, -735, -735, -735, -735, 0,
2611  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2612  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2613  0, 0, -735, 0, 0, 0, 0, 0, 0, 0,
2614  0, -735, -735, -735, -735, -735, -735, -735, -735, -735,
2615  -735, -735, -735, -735, 0, 0, 0, 0, -735, -735,
2616  -735, -735, 0, 691, 0, 0, 0, 0, 0, 0,
2617  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2618  0, 0, 0, 0, -735, 0, 0, 0, 0, 0,
2619  -116, -735, 0, -735, -735, -735, -735, -735, -735, -735,
2620  -735, -735, -735, 0, 0, 0, 0, -735, -735, -735,
2621  -735, -310, 0, -735, 0, -735, 0, -735, 0, -310,
2622  -310, -310, 0, 0, 0, -310, -310, 0, -310, 0,
2623  0, 0, 0, 0, 0, 0, -310, 0, 0, 0,
2624  0, 0, 0, 0, 0, 0, 0, 0, -310, -310,
2625  0, -310, -310, -310, -310, -310, 0, 0, 0, 0,
2626  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2627  0, 0, 0, 0, 0, 0, 0, 0, 0, -310,
2628  0, 0, 0, 0, 0, 0, 0, 0, -310, -310,
2629  -310, -310, -310, -310, -310, -310, -310, -310, -310, -310,
2630  -310, 0, 0, 0, 0, -310, -310, -310, -310, 0,
2631  692, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2632  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2633  0, -310, 0, 0, 0, 0, 0, -118, -310, 0,
2634  -310, -310, -310, -310, -310, -310, -310, -310, -310, -310,
2635  0, 0, 0, 0, 0, -310, -310, -109, -310, 0,
2636  -310, 0, -310, 0, -310, 0, -310, -310, -310, 0,
2637  0, 0, -310, -310, 0, -310, 0, 0, 0, 0,
2638  0, 0, 0, -310, 0, 0, 0, 0, 0, 0,
2639  0, 0, 0, 0, 0, -310, -310, 0, -310, -310,
2640  -310, -310, -310, 0, 0, 0, 0, 0, 0, 0,
2641  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2642  0, 0, 0, 0, 0, 0, -310, 0, 0, 0,
2643  0, 0, 0, 0, 0, -310, -310, -310, -310, -310,
2644  -310, -310, -310, -310, -310, -310, -310, -310, 0, 0,
2645  0, 0, -310, -310, -310, -310, 0, 692, 0, 0,
2646  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2647  0, 0, 0, 0, 0, 0, 0, 0, -310, 0,
2648  0, 0, 0, 0, -118, -310, 0, -310, -310, -310,
2649  -310, -310, -310, -310, -310, -310, -310, 0, 0, 0,
2650  0, 0, -310, -310, -310, 0, 0, -310, 0, -310,
2651  257, -310, 5, 6, 7, 8, 9, -757, -757, -757,
2652  10, 11, 0, 0, -757, 12, 0, 13, 14, 15,
2653  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2654  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2655  0, 0, 0, 0, 28, 29, 258, 31, 32, 33,
2656  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2657  43, 44, 45, 46, 47, 0, 0, 0, 0, 0,
2658  0, 0, 0, 0, 48, 49, 0, 0, 0, 0,
2659  0, 0, 0, 0, 0, 0, 0, 0, 0, 50,
2660  51, 0, 0, 0, 0, 0, 0, 52, 0, 0,
2661  53, 54, 0, 55, 56, 0, 57, 0, 0, 58,
2662  59, 60, 61, 62, 63, 64, 65, 66, 0, 0,
2663  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2664  0, 0, 0, 0, 0, 0, 0, 0, 67, 68,
2665  69, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2666  -757, 257, -757, 5, 6, 7, 8, 9, 0, 0,
2667  -757, 10, 11, 0, -757, -757, 12, 0, 13, 14,
2668  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2669  20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2670  0, 0, 0, 0, 0, 28, 29, 258, 31, 32,
2671  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
2672  42, 43, 44, 45, 46, 47, 0, 0, 0, 0,
2673  0, 0, 0, 0, 0, 48, 49, 0, 0, 0,
2674  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2675  50, 51, 0, 0, 0, 0, 0, 0, 52, 0,
2676  0, 53, 54, 0, 55, 56, 0, 57, 0, 0,
2677  58, 59, 60, 61, 62, 63, 64, 65, 66, 0,
2678  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2679  0, 0, 0, 0, 0, 0, 0, 0, 0, 67,
2680  68, 69, 0, 0, 0, 0, 0, 0, 0, 0,
2681  0, -757, 257, -757, 5, 6, 7, 8, 9, 0,
2682  0, -757, 10, 11, 0, 0, -757, 12, -757, 13,
2683  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2684  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2685  27, 0, 0, 0, 0, 0, 28, 29, 258, 31,
2686  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2687  41, 42, 43, 44, 45, 46, 47, 0, 0, 0,
2688  0, 0, 0, 0, 0, 0, 48, 49, 0, 0,
2689  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2690  0, 50, 51, 0, 0, 0, 0, 0, 0, 52,
2691  0, 0, 53, 54, 0, 55, 56, 0, 57, 0,
2692  0, 58, 59, 60, 61, 62, 63, 64, 65, 66,
2693  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2694  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2695  67, 68, 69, 0, 0, 0, 0, 0, 0, 0,
2696  0, 0, -757, 257, -757, 5, 6, 7, 8, 9,
2697  0, 0, -757, 10, 11, 0, 0, -757, 12, 0,
2698  13, 14, 15, 16, 17, 18, 19, -757, 0, 0,
2699  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2700  0, 27, 0, 0, 0, 0, 0, 28, 29, 258,
2701  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2702  0, 41, 42, 43, 44, 45, 46, 47, 0, 0,
2703  0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
2704  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2705  0, 0, 50, 51, 0, 0, 0, 0, 0, 0,
2706  52, 0, 0, 53, 54, 0, 55, 56, 0, 57,
2707  0, 0, 58, 59, 60, 61, 62, 63, 64, 65,
2708  66, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2709  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2710  0, 67, 68, 69, 0, 0, 0, 0, 0, 0,
2711  0, 0, 0, -757, 257, -757, 5, 6, 7, 8,
2712  9, 0, 0, -757, 10, 11, 0, 0, -757, 12,
2713  0, 13, 14, 15, 16, 17, 18, 19, 0, 0,
2714  0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
2715  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2716  258, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2717  40, 0, 41, 42, 43, 44, 45, 46, 47, 0,
2718  0, 0, 0, 0, 0, 0, 0, 0, 48, 49,
2719  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2720  0, 0, 0, 50, 51, 0, 0, 0, 0, 0,
2721  0, 52, 0, 0, 53, 54, 0, 55, 56, 0,
2722  57, 0, 0, 58, 59, 60, 61, 62, 63, 64,
2723  65, 66, 0, 0, 0, 0, 0, 0, 0, 0,
2724  257, 0, 5, 6, 7, 8, 9, 0, -757, -757,
2725  10, 11, 67, 68, 69, 12, 0, 13, 14, 15,
2726  16, 17, 18, 19, -757, 0, -757, 0, 0, 20,
2727  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2728  0, 0, 0, 0, 28, 29, 258, 31, 32, 33,
2729  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2730  43, 44, 45, 46, 47, 0, 0, 0, 0, 0,
2731  0, 0, 0, 0, 48, 49, 0, 0, 0, 0,
2732  0, 0, 0, 0, 0, 0, 0, 0, 0, 50,
2733  51, 0, 0, 0, 0, 0, 0, 52, 0, 0,
2734  53, 54, 0, 55, 56, 0, 57, 0, 0, 58,
2735  59, 60, 61, 62, 63, 64, 65, 66, 0, 0,
2736  0, 0, 0, 0, 0, 0, 257, 0, 5, 6,
2737  7, 8, 9, 0, 0, 0, 10, 11, 67, 68,
2738  69, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2739  -757, 0, -757, 0, 0, 20, 21, 22, 23, 24,
2740  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2741  28, 29, 258, 31, 32, 33, 34, 35, 36, 37,
2742  38, 39, 40, 0, 41, 42, 43, 44, 45, 46,
2743  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2744  48, 49, 0, 0, 0, 0, 0, 0, 0, 0,
2745  0, 0, 0, 0, 0, 50, 51, 0, 0, 0,
2746  0, 0, 0, 52, 0, 0, 259, 54, 0, 55,
2747  56, 0, 57, 0, 0, 58, 59, 60, 61, 62,
2748  63, 64, 65, 66, 0, 0, 0, 0, 0, 0,
2749  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2750  0, 0, 0, 0, 67, 68, 69, 0, 0, 0,
2751  0, 0, 0, 0, -757, 0, -757, 257, -757, 5,
2752  6, 7, 8, 9, 0, 0, 0, 10, 11, 0,
2753  0, 0, 12, 0, 13, 14, 15, 16, 17, 18,
2754  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
2755  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2756  0, 28, 29, 258, 31, 32, 33, 34, 35, 36,
2757  37, 38, 39, 40, 0, 41, 42, 43, 44, 45,
2758  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
2759  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
2760  0, 0, 0, 0, 0, 0, 50, 51, 0, 0,
2761  0, 0, 0, 0, 52, 0, 0, 53, 54, 0,
2762  55, 56, 0, 57, 0, 0, 58, 59, 60, 61,
2763  62, 63, 64, 65, 66, 0, 0, 0, 0, 0,
2764  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2765  0, 0, 0, 0, 0, 67, 68, 69, 0, 0,
2766  0, 0, 0, 0, 0, -757, 0, -757, 4, -757,
2767  5, 6, 7, 8, 9, 0, 0, 0, 10, 11,
2768  0, 0, 0, 12, 0, 13, 14, 15, 16, 17,
2769  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2770  23, 24, 25, 26, 0, 0, 27, 0, 0, 0,
2771  0, 0, 28, 29, 30, 31, 32, 33, 34, 35,
2772  36, 37, 38, 39, 40, 0, 41, 42, 43, 44,
2773  45, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2774  0, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2775  0, 0, 0, 0, 0, 0, 0, 50, 51, 0,
2776  0, 0, 0, 0, 0, 52, 0, 0, 53, 54,
2777  0, 55, 56, 0, 57, 0, 0, 58, 59, 60,
2778  61, 62, 63, 64, 65, 66, 0, 0, 0, 0,
2779  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2780  0, 0, 0, 0, 0, 0, 67, 68, 69, 0,
2781  0, -757, 0, 0, 0, 0, 0, 0, -757, 257,
2782  -757, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2783  11, 0, 0, 0, 12, 0, 13, 14, 15, 16,
2784  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2785  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2786  0, 0, 0, 28, 29, 258, 31, 32, 33, 34,
2787  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
2788  44, 45, 46, 47, 0, 0, 0, 0, 0, 0,
2789  0, 0, 0, 48, 49, 0, 0, 0, 0, 0,
2790  0, 0, 0, 0, 0, 0, 0, 0, 50, 51,
2791  0, 0, 0, 0, 0, 0, 52, 0, 0, 53,
2792  54, 0, 55, 56, 0, 57, 0, 0, 58, 59,
2793  60, 61, 62, 63, 64, 65, 66, 0, 0, 0,
2794  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2795  0, 0, 0, 0, 0, 0, 0, 67, 68, 69,
2796  0, 0, -757, 0, 0, 0, 0, 0, 0, -757,
2797  257, -757, 5, 6, 7, 8, 9, 0, 0, -757,
2798  10, 11, 0, 0, 0, 12, 0, 13, 14, 15,
2799  16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2800  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2801  0, 0, 0, 0, 28, 29, 258, 31, 32, 33,
2802  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2803  43, 44, 45, 46, 47, 0, 0, 0, 0, 0,
2804  0, 0, 0, 0, 48, 49, 0, 0, 0, 0,
2805  0, 0, 0, 0, 0, 0, 0, 0, 0, 50,
2806  51, 0, 0, 0, 0, 0, 0, 52, 0, 0,
2807  53, 54, 0, 55, 56, 0, 57, 0, 0, 58,
2808  59, 60, 61, 62, 63, 64, 65, 66, 0, 0,
2809  0, 0, 0, 0, 0, 0, 257, 0, 5, 6,
2810  7, 8, 9, 0, 0, 0, 10, 11, 67, 68,
2811  69, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2812  -757, 0, -757, 0, 0, 20, 21, 22, 23, 24,
2813  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2814  28, 29, 258, 31, 32, 33, 34, 35, 36, 37,
2815  38, 39, 40, 0, 41, 42, 43, 44, 45, 46,
2816  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2817  48, 49, 0, 0, 0, 0, 0, 0, 0, 0,
2818  0, 0, 0, 0, 0, 50, 51, 0, 0, 0,
2819  0, 0, 0, 52, 0, 0, 53, 54, 0, 55,
2820  56, 0, 57, 0, 0, 58, 59, 60, 61, 62,
2821  63, 64, 65, 66, 0, -757, 0, 0, 0, 0,
2822  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
2823  0, 0, 10, 11, 67, 68, 69, 12, 0, 13,
2824  14, 15, 16, 17, 18, 19, -757, 0, -757, 0,
2825  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2826  206, 0, 0, 0, 0, 0, 0, 29, 0, 0,
2827  32, 33, 34, 35, 36, 37, 38, 39, 40, 207,
2828  41, 42, 43, 44, 45, 46, 47, 0, 0, 0,
2829  0, 0, 0, 0, 0, 0, 48, 49, 0, 0,
2830  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2831  0, 50, 51, 0, 0, 0, 0, 0, 0, 208,
2832  0, 0, 209, 54, 0, 55, 56, 0, 210, 211,
2833  212, 58, 59, 213, 61, 62, 63, 64, 65, 66,
2834  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2835  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
2836  67, 214, 69, 12, 0, 13, 14, 15, 16, 17,
2837  18, 19, 0, 0, 237, 0, 0, 20, 21, 22,
2838  23, 24, 25, 26, 0, 0, 27, 0, 0, 0,
2839  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
2840  36, 37, 38, 39, 40, 0, 41, 42, 43, 44,
2841  45, 46, 47, 0, 0, 0, 0, 0, 0, 0,
2842  0, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2843  0, 0, 0, 0, 0, 0, 0, 50, 51, 0,
2844  0, 0, 0, 0, 0, 208, 0, 0, 209, 54,
2845  0, 55, 56, 0, 0, 0, 0, 58, 59, 60,
2846  61, 62, 63, 64, 65, 66, 0, 0, 0, 0,
2847  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2848  9, 0, 0, 0, 10, 11, 67, 68, 69, 12,
2849  0, 13, 14, 15, 16, 17, 18, 19, 305, 0,
2850  306, 0, 0, 20, 21, 22, 23, 24, 25, 26,
2851  0, 0, 27, 0, 0, 0, 0, 0, 0, 29,
2852  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2853  40, 0, 41, 42, 43, 44, 45, 46, 47, 0,
2854  0, 0, 0, 0, 0, 0, 0, 0, 48, 49,
2855  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2856  0, 0, 0, 50, 51, 0, 0, 0, 0, 0,
2857  0, 208, 0, 0, 209, 54, 0, 55, 56, 0,
2858  0, 0, 0, 58, 59, 60, 61, 62, 63, 64,
2859  65, 66, 0, 0, 0, 0, 0, 0, 0, 0,
2860  0, 0, 5, 6, 7, 8, 9, 0, 0, 0,
2861  10, 11, 67, 68, 69, 12, 0, 13, 14, 15,
2862  16, 17, 18, 19, 0, 0, 237, 0, 0, 20,
2863  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2864  0, 0, 0, 0, 28, 29, 30, 31, 32, 33,
2865  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
2866  43, 44, 45, 46, 47, 0, 0, 0, 0, 0,
2867  0, 0, 0, 0, 48, 49, 0, 0, 0, 0,
2868  0, 0, 0, 0, 0, 0, 0, 0, 0, 50,
2869  51, 0, 0, 0, 0, 0, 0, 52, 0, 0,
2870  53, 54, 0, 55, 56, 0, 57, 0, 0, 58,
2871  59, 60, 61, 62, 63, 64, 65, 66, 0, 0,
2872  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
2873  7, 8, 9, 0, 0, 0, 10, 11, 67, 68,
2874  69, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2875  503, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2876  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2877  28, 29, 258, 31, 32, 33, 34, 35, 36, 37,
2878  38, 39, 40, 0, 41, 42, 43, 44, 45, 46,
2879  47, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2880  48, 49, 0, 0, 0, 0, 0, 0, 0, 0,
2881  0, 0, 0, 0, 0, 50, 51, 0, 0, 0,
2882  0, 0, 0, 52, 0, 0, 53, 54, 0, 55,
2883  56, 0, 57, 0, 0, 58, 59, 60, 61, 62,
2884  63, 64, 65, 66, 0, 0, 0, 0, 0, 0,
2885  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2886  0, 0, 0, 0, 67, 68, 69, 0, 0, 0,
2887  0, 0, 0, 0, 0, 0, 503, 126, 127, 128,
2888  129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
2889  139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
2890  149, 0, 0, 0, 150, 151, 152, 395, 396, 397,
2891  398, 157, 158, 159, 0, 0, 0, 0, 0, 160,
2892  161, 162, 163, 399, 400, 401, 402, 168, 37, 38,
2893  403, 40, 0, 0, 0, 0, 0, 0, 0, 0,
2894  0, 0, 0, 0, 0, 0, 0, 0, 0, 170,
2895  171, 172, 173, 174, 175, 176, 177, 178, 0, 0,
2896  179, 180, 0, 0, 0, 0, 181, 182, 183, 184,
2897  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2898  0, 185, 186, 0, 0, 0, 0, 0, 0, 0,
2899  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2900  0, 0, 0, 187, 188, 189, 190, 191, 192, 193,
2901  194, 195, 196, 0, 197, 198, 0, 0, 0, 0,
2902  0, 199, 404, 126, 127, 128, 129, 130, 131, 132,
2903  133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
2904  143, 144, 145, 146, 147, 148, 149, 0, 0, 0,
2905  150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
2906  0, 0, 0, 0, 0, 160, 161, 162, 163, 164,
2907  165, 166, 167, 168, 288, 289, 169, 290, 0, 0,
2908  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2909  0, 0, 0, 0, 0, 170, 171, 172, 173, 174,
2910  175, 176, 177, 178, 0, 0, 179, 180, 0, 0,
2911  0, 0, 181, 182, 183, 184, 0, 0, 0, 0,
2912  0, 0, 0, 0, 0, 0, 0, 185, 186, 0,
2913  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2914  0, 0, 0, 0, 0, 0, 0, 0, 0, 187,
2915  188, 189, 190, 191, 192, 193, 194, 195, 196, 0,
2916  197, 198, 0, 0, 0, 0, 0, 199, 126, 127,
2917  128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
2918  138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
2919  148, 149, 0, 0, 0, 150, 151, 152, 153, 154,
2920  155, 156, 157, 158, 159, 0, 0, 0, 0, 0,
2921  160, 161, 162, 163, 164, 165, 166, 167, 168, 239,
2922  0, 169, 0, 0, 0, 0, 0, 0, 0, 0,
2923  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2924  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
2925  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
2926  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2927  0, 0, 185, 186, 0, 0, 59, 0, 0, 0,
2928  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2929  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
2930  193, 194, 195, 196, 0, 197, 198, 0, 0, 0,
2931  0, 0, 199, 126, 127, 128, 129, 130, 131, 132,
2932  133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
2933  143, 144, 145, 146, 147, 148, 149, 0, 0, 0,
2934  150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
2935  0, 0, 0, 0, 0, 160, 161, 162, 163, 164,
2936  165, 166, 167, 168, 0, 0, 169, 0, 0, 0,
2937  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2938  0, 0, 0, 0, 0, 170, 171, 172, 173, 174,
2939  175, 176, 177, 178, 0, 0, 179, 180, 0, 0,
2940  0, 0, 181, 182, 183, 184, 0, 0, 0, 0,
2941  0, 0, 0, 0, 0, 0, 0, 185, 186, 0,
2942  0, 59, 0, 0, 0, 0, 0, 0, 0, 0,
2943  0, 0, 0, 0, 0, 0, 0, 0, 0, 187,
2944  188, 189, 190, 191, 192, 193, 194, 195, 196, 0,
2945  197, 198, 0, 0, 0, 0, 0, 199, 126, 127,
2946  128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
2947  138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
2948  148, 149, 0, 0, 0, 150, 151, 152, 153, 154,
2949  155, 156, 157, 158, 159, 0, 0, 0, 0, 0,
2950  160, 161, 162, 163, 164, 165, 166, 167, 168, 0,
2951  0, 169, 0, 0, 0, 0, 0, 0, 0, 0,
2952  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2953  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
2954  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
2955  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2956  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
2957  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2958  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
2959  193, 194, 195, 196, 0, 197, 198, 5, 6, 7,
2960  0, 9, 199, 0, 0, 10, 11, 0, 0, 0,
2961  12, 0, 13, 14, 15, 245, 246, 18, 19, 0,
2962  0, 0, 0, 0, 20, 247, 248, 23, 24, 25,
2963  26, 0, 0, 206, 0, 0, 0, 0, 0, 0,
2964  277, 0, 0, 32, 33, 34, 35, 36, 37, 38,
2965  39, 40, 0, 41, 42, 43, 44, 45, 46, 47,
2966  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2967  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2968  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2969  0, 0, 278, 0, 0, 209, 54, 0, 55, 56,
2970  0, 0, 0, 0, 58, 59, 60, 61, 62, 63,
2971  64, 65, 66, 0, 0, 0, 0, 0, 0, 0,
2972  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
2973  9, 0, 0, 279, 10, 11, 0, 0, 0, 12,
2974  280, 13, 14, 15, 245, 246, 18, 19, 0, 0,
2975  0, 0, 0, 20, 247, 248, 23, 24, 25, 26,
2976  0, 0, 206, 0, 0, 0, 0, 0, 0, 277,
2977  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
2978  40, 0, 41, 42, 43, 44, 45, 46, 47, 0,
2979  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2980  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2981  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2982  0, 278, 0, 0, 209, 54, 0, 55, 56, 0,
2983  0, 0, 0, 58, 59, 60, 61, 62, 63, 64,
2984  65, 66, 0, 0, 0, 0, 0, 0, 0, 0,
2985  0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
2986  0, 0, 279, 10, 11, 0, 0, 0, 12, 526,
2987  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
2988  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
2989  0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
2990  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
2991  0, 41, 42, 43, 44, 45, 46, 47, 0, 0,
2992  0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
2993  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2994  0, 0, 50, 51, 0, 0, 0, 0, 0, 0,
2995  52, 0, 0, 53, 54, 0, 55, 56, 0, 57,
2996  0, 0, 58, 59, 60, 61, 62, 63, 64, 65,
2997  66, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2998  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
2999  11, 67, 68, 69, 12, 0, 13, 14, 15, 16,
3000  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
3001  22, 23, 24, 25, 26, 0, 0, 206, 0, 0,
3002  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
3003  35, 36, 37, 38, 39, 40, 207, 41, 42, 43,
3004  44, 45, 46, 47, 0, 0, 0, 0, 0, 0,
3005  0, 0, 0, 48, 49, 0, 0, 0, 0, 0,
3006  0, 0, 0, 0, 0, 0, 0, 0, 50, 51,
3007  0, 0, 0, 0, 0, 0, 208, 0, 0, 209,
3008  54, 0, 55, 56, 0, 210, 211, 212, 58, 59,
3009  213, 61, 62, 63, 64, 65, 66, 0, 0, 0,
3010  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3011  8, 9, 0, 0, 0, 10, 11, 67, 214, 69,
3012  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
3013  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
3014  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
3015  29, 0, 31, 32, 33, 34, 35, 36, 37, 38,
3016  39, 40, 0, 41, 42, 43, 44, 45, 46, 47,
3017  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
3018  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3019  0, 0, 0, 0, 50, 51, 0, 0, 0, 0,
3020  0, 0, 52, 0, 0, 53, 54, 0, 55, 56,
3021  0, 57, 0, 0, 58, 59, 60, 61, 62, 63,
3022  64, 65, 66, 0, 0, 0, 0, 0, 0, 0,
3023  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3024  0, 10, 11, 67, 68, 69, 12, 0, 13, 14,
3025  15, 16, 17, 18, 19, 0, 0, 0, 0, 0,
3026  20, 21, 22, 23, 24, 25, 26, 0, 0, 206,
3027  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
3028  33, 34, 35, 36, 37, 38, 39, 40, 207, 41,
3029  42, 43, 44, 45, 46, 47, 0, 0, 0, 0,
3030  0, 0, 0, 0, 0, 48, 49, 0, 0, 0,
3031  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3032  50, 439, 0, 0, 0, 0, 0, 0, 208, 0,
3033  0, 209, 54, 0, 55, 56, 0, 210, 211, 212,
3034  58, 59, 213, 61, 62, 63, 64, 65, 66, 0,
3035  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
3036  6, 7, 0, 9, 0, 0, 0, 10, 11, 67,
3037  214, 69, 12, 0, 13, 14, 15, 245, 246, 18,
3038  19, 0, 0, 0, 0, 0, 20, 247, 248, 23,
3039  24, 25, 26, 0, 0, 206, 0, 0, 0, 0,
3040  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
3041  37, 38, 39, 40, 207, 41, 42, 43, 44, 45,
3042  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
3043  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
3044  0, 0, 0, 0, 0, 0, 50, 51, 0, 0,
3045  0, 0, 0, 0, 208, 0, 0, 209, 54, 0,
3046  55, 56, 0, 620, 211, 212, 58, 59, 213, 61,
3047  62, 63, 64, 65, 66, 0, 0, 0, 0, 0,
3048  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
3049  0, 0, 0, 10, 11, 67, 214, 69, 12, 0,
3050  13, 14, 15, 245, 246, 18, 19, 0, 0, 0,
3051  0, 0, 20, 247, 248, 23, 24, 25, 26, 0,
3052  0, 206, 0, 0, 0, 0, 0, 0, 29, 0,
3053  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3054  207, 41, 42, 43, 44, 45, 46, 47, 0, 0,
3055  0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
3056  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3057  0, 0, 50, 51, 0, 0, 0, 0, 0, 0,
3058  208, 0, 0, 209, 54, 0, 55, 56, 0, 210,
3059  211, 0, 58, 59, 213, 61, 62, 63, 64, 65,
3060  66, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3061  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
3062  11, 67, 214, 69, 12, 0, 13, 14, 15, 245,
3063  246, 18, 19, 0, 0, 0, 0, 0, 20, 247,
3064  248, 23, 24, 25, 26, 0, 0, 206, 0, 0,
3065  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
3066  35, 36, 37, 38, 39, 40, 207, 41, 42, 43,
3067  44, 45, 46, 47, 0, 0, 0, 0, 0, 0,
3068  0, 0, 0, 48, 49, 0, 0, 0, 0, 0,
3069  0, 0, 0, 0, 0, 0, 0, 0, 50, 51,
3070  0, 0, 0, 0, 0, 0, 208, 0, 0, 209,
3071  54, 0, 55, 56, 0, 0, 211, 212, 58, 59,
3072  213, 61, 62, 63, 64, 65, 66, 0, 0, 0,
3073  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3074  0, 9, 0, 0, 0, 10, 11, 67, 214, 69,
3075  12, 0, 13, 14, 15, 245, 246, 18, 19, 0,
3076  0, 0, 0, 0, 20, 247, 248, 23, 24, 25,
3077  26, 0, 0, 206, 0, 0, 0, 0, 0, 0,
3078  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
3079  39, 40, 207, 41, 42, 43, 44, 45, 46, 47,
3080  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
3081  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3082  0, 0, 0, 0, 50, 51, 0, 0, 0, 0,
3083  0, 0, 208, 0, 0, 209, 54, 0, 55, 56,
3084  0, 620, 211, 0, 58, 59, 213, 61, 62, 63,
3085  64, 65, 66, 0, 0, 0, 0, 0, 0, 0,
3086  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3087  0, 10, 11, 67, 214, 69, 12, 0, 13, 14,
3088  15, 245, 246, 18, 19, 0, 0, 0, 0, 0,
3089  20, 247, 248, 23, 24, 25, 26, 0, 0, 206,
3090  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
3091  33, 34, 35, 36, 37, 38, 39, 40, 207, 41,
3092  42, 43, 44, 45, 46, 47, 0, 0, 0, 0,
3093  0, 0, 0, 0, 0, 48, 49, 0, 0, 0,
3094  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3095  50, 51, 0, 0, 0, 0, 0, 0, 208, 0,
3096  0, 209, 54, 0, 55, 56, 0, 0, 211, 0,
3097  58, 59, 213, 61, 62, 63, 64, 65, 66, 0,
3098  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
3099  6, 7, 0, 9, 0, 0, 0, 10, 11, 67,
3100  214, 69, 12, 0, 13, 14, 15, 16, 17, 18,
3101  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
3102  24, 25, 26, 0, 0, 206, 0, 0, 0, 0,
3103  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
3104  37, 38, 39, 40, 0, 41, 42, 43, 44, 45,
3105  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
3106  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
3107  0, 0, 0, 0, 0, 0, 50, 51, 0, 0,
3108  0, 0, 0, 0, 208, 0, 0, 209, 54, 0,
3109  55, 56, 0, 519, 0, 0, 58, 59, 60, 61,
3110  62, 63, 64, 65, 66, 0, 0, 0, 0, 0,
3111  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
3112  0, 0, 0, 10, 11, 67, 214, 69, 12, 0,
3113  13, 14, 15, 245, 246, 18, 19, 0, 0, 0,
3114  0, 0, 20, 247, 248, 23, 24, 25, 26, 0,
3115  0, 206, 0, 0, 0, 0, 0, 0, 29, 0,
3116  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3117  0, 41, 42, 43, 44, 45, 46, 47, 0, 0,
3118  0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
3119  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3120  0, 0, 50, 51, 0, 0, 0, 0, 0, 0,
3121  208, 0, 0, 209, 54, 0, 55, 56, 0, 770,
3122  0, 0, 58, 59, 60, 61, 62, 63, 64, 65,
3123  66, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3124  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
3125  11, 67, 214, 69, 12, 0, 13, 14, 15, 245,
3126  246, 18, 19, 0, 0, 0, 0, 0, 20, 247,
3127  248, 23, 24, 25, 26, 0, 0, 206, 0, 0,
3128  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
3129  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
3130  44, 45, 46, 47, 0, 0, 0, 0, 0, 0,
3131  0, 0, 0, 48, 49, 0, 0, 0, 0, 0,
3132  0, 0, 0, 0, 0, 0, 0, 0, 50, 51,
3133  0, 0, 0, 0, 0, 0, 208, 0, 0, 209,
3134  54, 0, 55, 56, 0, 519, 0, 0, 58, 59,
3135  60, 61, 62, 63, 64, 65, 66, 0, 0, 0,
3136  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3137  0, 9, 0, 0, 0, 10, 11, 67, 214, 69,
3138  12, 0, 13, 14, 15, 245, 246, 18, 19, 0,
3139  0, 0, 0, 0, 20, 247, 248, 23, 24, 25,
3140  26, 0, 0, 206, 0, 0, 0, 0, 0, 0,
3141  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
3142  39, 40, 0, 41, 42, 43, 44, 45, 46, 47,
3143  0, 0, 0, 0, 0, 0, 0, 0, 0, 48,
3144  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3145  0, 0, 0, 0, 50, 51, 0, 0, 0, 0,
3146  0, 0, 208, 0, 0, 209, 54, 0, 55, 56,
3147  0, 843, 0, 0, 58, 59, 60, 61, 62, 63,
3148  64, 65, 66, 0, 0, 0, 0, 0, 0, 0,
3149  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3150  0, 10, 11, 67, 214, 69, 12, 0, 13, 14,
3151  15, 245, 246, 18, 19, 0, 0, 0, 0, 0,
3152  20, 247, 248, 23, 24, 25, 26, 0, 0, 206,
3153  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
3154  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
3155  42, 43, 44, 45, 46, 47, 0, 0, 0, 0,
3156  0, 0, 0, 0, 0, 48, 49, 0, 0, 0,
3157  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3158  50, 51, 0, 0, 0, 0, 0, 0, 208, 0,
3159  0, 209, 54, 0, 55, 56, 0, 1012, 0, 0,
3160  58, 59, 60, 61, 62, 63, 64, 65, 66, 0,
3161  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
3162  6, 7, 0, 9, 0, 0, 0, 10, 11, 67,
3163  214, 69, 12, 0, 13, 14, 15, 245, 246, 18,
3164  19, 0, 0, 0, 0, 0, 20, 247, 248, 23,
3165  24, 25, 26, 0, 0, 206, 0, 0, 0, 0,
3166  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
3167  37, 38, 39, 40, 0, 41, 42, 43, 44, 45,
3168  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
3169  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
3170  0, 0, 0, 0, 0, 0, 50, 51, 0, 0,
3171  0, 0, 0, 0, 208, 0, 0, 209, 54, 0,
3172  55, 56, 0, 0, 0, 0, 58, 59, 60, 61,
3173  62, 63, 64, 65, 66, 0, 0, 0, 0, 0,
3174  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
3175  0, 0, 0, 10, 11, 67, 214, 69, 12, 0,
3176  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
3177  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
3178  0, 206, 0, 0, 0, 0, 0, 0, 29, 0,
3179  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3180  0, 41, 42, 43, 44, 45, 46, 47, 0, 0,
3181  0, 0, 0, 0, 0, 0, 0, 48, 49, 0,
3182  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3183  0, 0, 50, 51, 0, 0, 0, 0, 0, 0,
3184  208, 0, 0, 209, 54, 0, 55, 56, 0, 0,
3185  0, 0, 58, 59, 60, 61, 62, 63, 64, 65,
3186  66, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3187  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
3188  11, 67, 214, 69, 12, 0, 13, 14, 15, 16,
3189  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
3190  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
3191  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
3192  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
3193  44, 45, 46, 47, 0, 0, 0, 0, 0, 0,
3194  0, 0, 0, 48, 49, 0, 0, 0, 0, 0,
3195  0, 0, 0, 0, 0, 0, 0, 0, 50, 51,
3196  0, 0, 0, 0, 0, 0, 208, 0, 0, 209,
3197  54, 0, 55, 56, 0, 0, 0, 0, 58, 59,
3198  60, 61, 62, 63, 64, 65, 66, 0, 0, 0,
3199  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3200  0, 9, 0, 0, 0, 10, 11, 67, 68, 69,
3201  12, 0, 13, 14, 15, 245, 246, 18, 19, 0,
3202  0, 0, 0, 0, 20, 247, 248, 23, 24, 25,
3203  26, 0, 0, 206, 0, 0, 0, 0, 0, 0,
3204  277, 0, 0, 32, 33, 34, 35, 36, 37, 38,
3205  39, 40, 0, 41, 42, 43, 44, 45, 46, 47,
3206  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3207  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3208  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3209  0, 0, 278, 0, 0, 328, 54, 0, 55, 56,
3210  0, 329, 0, 0, 58, 59, 60, 61, 62, 63,
3211  64, 65, 66, 0, 0, 0, 0, 0, 0, 5,
3212  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
3213  0, 0, 12, 279, 13, 14, 15, 245, 246, 18,
3214  19, 0, 0, 0, 0, 0, 20, 247, 248, 23,
3215  24, 25, 26, 0, 0, 206, 0, 0, 0, 0,
3216  0, 0, 277, 0, 0, 32, 33, 34, 35, 36,
3217  37, 38, 39, 40, 0, 41, 42, 43, 44, 45,
3218  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
3219  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3220  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3221  0, 0, 0, 0, 376, 0, 0, 53, 54, 0,
3222  55, 56, 0, 57, 0, 0, 58, 59, 60, 61,
3223  62, 63, 64, 65, 66, 0, 0, 0, 0, 0,
3224  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
3225  11, 0, 0, 0, 12, 279, 13, 14, 15, 245,
3226  246, 18, 19, 0, 0, 0, 0, 0, 20, 247,
3227  248, 23, 24, 25, 26, 0, 0, 206, 0, 0,
3228  0, 0, 0, 0, 277, 0, 0, 32, 33, 34,
3229  384, 36, 37, 38, 385, 40, 0, 41, 42, 43,
3230  44, 45, 46, 47, 0, 0, 0, 0, 0, 0,
3231  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3232  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3233  0, 0, 386, 0, 0, 0, 387, 0, 0, 209,
3234  54, 0, 55, 56, 0, 0, 0, 0, 58, 59,
3235  60, 61, 62, 63, 64, 65, 66, 0, 0, 0,
3236  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3237  0, 10, 11, 0, 0, 0, 12, 279, 13, 14,
3238  15, 245, 246, 18, 19, 0, 0, 0, 0, 0,
3239  20, 247, 248, 23, 24, 25, 26, 0, 0, 206,
3240  0, 0, 0, 0, 0, 0, 277, 0, 0, 32,
3241  33, 34, 384, 36, 37, 38, 385, 40, 0, 41,
3242  42, 43, 44, 45, 46, 47, 0, 0, 0, 0,
3243  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3244  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3245  0, 0, 0, 0, 0, 0, 0, 0, 387, 0,
3246  0, 209, 54, 0, 55, 56, 0, 0, 0, 0,
3247  58, 59, 60, 61, 62, 63, 64, 65, 66, 0,
3248  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
3249  0, 0, 0, 10, 11, 0, 0, 0, 12, 279,
3250  13, 14, 15, 245, 246, 18, 19, 0, 0, 0,
3251  0, 0, 20, 247, 248, 23, 24, 25, 26, 0,
3252  0, 206, 0, 0, 0, 0, 0, 0, 277, 0,
3253  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3254  0, 41, 42, 43, 44, 45, 46, 47, 0, 0,
3255  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3256  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3257  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3258  278, 0, 0, 328, 54, 0, 55, 56, 0, 0,
3259  0, 0, 58, 59, 60, 61, 62, 63, 64, 65,
3260  66, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3261  0, 9, 0, 0, 0, 10, 11, 0, 0, 0,
3262  12, 279, 13, 14, 15, 245, 246, 18, 19, 0,
3263  0, 0, 0, 0, 20, 247, 248, 23, 24, 25,
3264  26, 0, 0, 206, 0, 0, 0, 0, 0, 0,
3265  277, 0, 0, 32, 33, 34, 35, 36, 37, 38,
3266  39, 40, 0, 41, 42, 43, 44, 45, 46, 47,
3267  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3268  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3269  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3270  0, 0, 1002, 0, 0, 209, 54, 0, 55, 56,
3271  0, 0, 0, 0, 58, 59, 60, 61, 62, 63,
3272  64, 65, 66, 0, 0, 0, 0, 0, 0, 5,
3273  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
3274  0, 0, 12, 279, 13, 14, 15, 245, 246, 18,
3275  19, 0, 0, 0, 0, 0, 20, 247, 248, 23,
3276  24, 25, 26, 0, 0, 206, 0, 0, 0, 0,
3277  0, 0, 277, 0, 0, 32, 33, 34, 35, 36,
3278  37, 38, 39, 40, 0, 41, 42, 43, 44, 45,
3279  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
3280  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3281  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3282  0, 0, 0, 0, 1054, 0, 0, 209, 54, 0,
3283  55, 56, 23, 24, 25, 26, 58, 59, 60, 61,
3284  62, 63, 64, 65, 66, 0, 0, 0, 32, 33,
3285  34, 781, 0, 0, 0, 782, 0, 980, 41, 42,
3286  43, 44, 45, 0, 0, 279, 0, 0, 0, 0,
3287  0, 0, 0, 0, 0, 0, 921, 0, 0, 0,
3288  0, 0, 0, 0, 0, 0, 0, 0, 0, 783,
3289  784, 0, 0, 0, 0, 0, 0, 785, 0, 0,
3290  786, 0, 0, 787, 788, 0, 974, 925, 0, 789,
3291  59, 997, 61, 62, 63, 64, 65, 66, 23, 24,
3292  25, 26, 0, 0, 0, 0, 0, 0, 0, 0,
3293  0, 790, 0, 0, 32, 33, 34, 781, 279, 0,
3294  0, 782, 0, 0, 41, 42, 43, 44, 45, 0,
3295  0, 23, 24, 25, 26, 0, 0, 0, 0, 0,
3296  0, 0, 0, 0, 0, 0, 0, 32, 33, 34,
3297  781, 0, 0, 0, 782, 783, 784, 41, 42, 43,
3298  44, 45, 0, 785, 0, 0, 786, 0, 0, 787,
3299  788, 0, 1069, 0, 0, 789, 59, 60, 61, 62,
3300  63, 64, 65, 66, 0, 0, 0, 0, 783, 784,
3301  0, 0, 0, 0, 0, 0, 785, 790, 0, 786,
3302  0, 0, 787, 788, 279, 0, 0, 0, 789, 59,
3303  60, 61, 62, 63, 64, 65, 66, 564, 565, 0,
3304  0, 566, 0, 0, 0, 0, 0, 0, 0, 0,
3305  790, 0, 0, 0, 0, 0, 0, 279, 0, 0,
3306  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3307  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3308  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3309  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3310  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3311  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3312  193, 194, 195, 196, 0, 197, 198, 572, 573, 0,
3313  0, 574, 199, 233, 0, 0, 0, 0, 0, 0,
3314  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3315  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3316  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3317  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3318  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3319  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3320  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3321  193, 194, 195, 196, 0, 197, 198, 624, 565, 0,
3322  0, 625, 199, 233, 0, 0, 0, 0, 0, 0,
3323  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3324  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3325  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3326  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3327  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3328  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3329  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3330  193, 194, 195, 196, 0, 197, 198, 627, 573, 0,
3331  0, 628, 199, 233, 0, 0, 0, 0, 0, 0,
3332  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3333  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3334  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3335  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3336  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3337  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3338  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3339  193, 194, 195, 196, 0, 197, 198, 652, 565, 0,
3340  0, 653, 199, 233, 0, 0, 0, 0, 0, 0,
3341  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3342  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3343  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3344  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3345  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3346  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3347  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3348  193, 194, 195, 196, 0, 197, 198, 655, 573, 0,
3349  0, 656, 199, 233, 0, 0, 0, 0, 0, 0,
3350  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3351  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3352  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3353  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3354  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3355  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3356  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3357  193, 194, 195, 196, 0, 197, 198, 722, 565, 0,
3358  0, 723, 199, 233, 0, 0, 0, 0, 0, 0,
3359  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3360  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3361  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3362  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3363  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3364  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3365  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3366  193, 194, 195, 196, 0, 197, 198, 725, 573, 0,
3367  0, 726, 199, 233, 0, 0, 0, 0, 0, 0,
3368  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3369  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3370  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3371  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3372  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3373  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3374  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3375  193, 194, 195, 196, 0, 197, 198, 731, 565, 0,
3376  0, 732, 199, 233, 0, 0, 0, 0, 0, 0,
3377  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3378  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3379  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3380  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3381  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3382  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3383  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3384  193, 194, 195, 196, 0, 197, 198, 609, 573, 0,
3385  0, 610, 199, 233, 0, 0, 0, 0, 0, 0,
3386  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3387  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3388  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3389  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3390  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3391  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3392  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3393  193, 194, 195, 196, 0, 197, 198, 776, 565, 0,
3394  0, 777, 199, 233, 0, 0, 0, 0, 0, 0,
3395  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3396  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3397  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3398  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3399  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3400  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3401  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3402  193, 194, 195, 196, 0, 197, 198, 779, 573, 0,
3403  0, 780, 199, 233, 0, 0, 0, 0, 0, 0,
3404  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3405  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3406  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3407  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3408  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3409  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3410  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3411  193, 194, 195, 196, 0, 197, 198, 1152, 565, 0,
3412  0, 1153, 199, 233, 0, 0, 0, 0, 0, 0,
3413  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3414  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3415  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3416  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3417  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3418  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3419  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3420  193, 194, 195, 196, 0, 197, 198, 1155, 573, 0,
3421  0, 1156, 199, 233, 0, 0, 0, 0, 0, 0,
3422  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3423  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3424  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3425  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3426  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3427  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3428  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3429  193, 194, 195, 196, 0, 197, 198, 1186, 565, 0,
3430  0, 1187, 199, 233, 0, 0, 0, 0, 0, 0,
3431  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3432  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3433  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3434  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3435  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3436  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3437  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3438  193, 194, 195, 196, 0, 197, 198, 609, 573, 0,
3439  0, 610, 199, 233, 0, 0, 0, 0, 0, 0,
3440  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3441  170, 171, 172, 173, 174, 175, 176, 177, 178, 0,
3442  0, 179, 180, 0, 0, 0, 0, 181, 182, 183,
3443  184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3444  0, 0, 185, 186, 0, 0, 0, 0, 0, 0,
3445  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3446  0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
3447  193, 194, 195, 196, 0, 197, 198, 0, 0, 0,
3448  0, 0, 199
3449 };
3450 
3451 static const yytype_int16 yycheck[] =
3452 {
3453  2, 60, 53, 89, 369, 71, 102, 83, 8, 22,
3454  710, 8, 16, 17, 28, 101, 59, 331, 227, 717,
3455  16, 17, 94, 91, 92, 387, 4, 95, 28, 95,
3456  482, 28, 57, 626, 2, 271, 4, 433, 57, 275,
3457  67, 892, 893, 71, 363, 1064, 365, 26, 16, 17,
3458  27, 55, 29, 55, 56, 1026, 99, 364, 83, 59,
3459  92, 654, 603, 95, 27, 78, 295, 296, 1037, 1060,
3460  68, 96, 97, 98, 526, 1102, 13, 473, 25, 53,
3461  1104, 1052, 25, 957, 259, 53, 54, 1142, 95, 57,
3462  52, 1146, 411, 414, 415, 15, 100, 0, 689, 99,
3463  68, 77, 25, 331, 100, 25, 25, 148, 99, 428,
3464  143, 430, 153, 892, 893, 83, 68, 2, 13, 4,
3465  126, 13, 429, 91, 92, 941, 942, 95, 96, 97,
3466  98, 724, 100, 37, 38, 126, 222, 16, 17, 458,
3467  146, 734, 425, 1198, 96, 97, 56, 963, 964, 965,
3468  433, 25, 29, 328, 213, 22, 857, 151, 209, 153,
3469  136, 137, 138, 864, 143, 251, 485, 66, 236, 54,
3470  238, 153, 1046, 16, 17, 1194, 9, 484, 25, 1206,
3471  28, 1205, 15, 126, 146, 778, 414, 415, 151, 730,
3472  153, 1182, 866, 244, 787, 261, 13, 283, 1167, 146,
3473  13, 1172, 25, 146, 280, 148, 149, 66, 259, 146,
3474  153, 78, 55, 56, 151, 52, 153, 100, 1189, 221,
3475  119, 100, 518, 146, 152, 227, 230, 146, 232, 148,
3476  682, 233, 1011, 261, 230, 444, 232, 233, 600, 635,
3477  242, 209, 310, 311, 312, 313, 123, 315, 316, 153,
3478  866, 952, 279, 148, 261, 280, 151, 100, 153, 151,
3479  119, 153, 230, 146, 232, 233, 977, 143, 236, 498,
3480  238, 500, 146, 592, 242, 26, 244, 328, 310, 311,
3481  312, 313, 578, 602, 591, 259, 877, 878, 584, 257,
3482  586, 259, 236, 379, 601, 152, 1112, 890, 152, 146,
3483  277, 892, 893, 371, 329, 13, 100, 373, 849, 146,
3484  329, 1162, 280, 25, 1014, 856, 1014, 1133, 386, 370,
3485  264, 372, 326, 146, 268, 148, 52, 331, 326, 870,
3486  56, 309, 25, 331, 151, 148, 153, 13, 151, 371,
3487  153, 309, 310, 311, 312, 313, 314, 315, 316, 152,
3488  633, 230, 635, 232, 328, 25, 1067, 242, 326, 153,
3489  328, 329, 364, 331, 97, 365, 373, 686, 364, 688,
3490  691, 692, 257, 13, 783, 784, 697, 698, 1052, 126,
3491  687, 248, 249, 976, 13, 146, 1060, 230, 1062, 232,
3492  54, 705, 143, 112, 985, 100, 364, 148, 366, 99,
3493  64, 65, 370, 371, 372, 126, 482, 1000, 1001, 13,
3494  1026, 411, 145, 649, 623, 148, 414, 415, 386, 13,
3495  1011, 1037, 718, 785, 309, 721, 126, 429, 66, 314,
3496  430, 1142, 661, 429, 146, 1146, 1052, 666, 452, 735,
3497  442, 146, 444, 151, 1060, 153, 414, 415, 37, 38,
3498  526, 537, 452, 146, 99, 452, 684, 482, 458, 82,
3499  83, 429, 866, 691, 692, 855, 862, 857, 109, 697,
3500  698, 68, 25, 66, 864, 151, 146, 153, 887, 888,
3501  845, 119, 484, 121, 122, 485, 1197, 1198, 484, 146,
3502  923, 435, 133, 99, 148, 816, 440, 465, 365, 443,
3503  97, 526, 446, 146, 1045, 68, 129, 130, 1182, 56,
3504  1184, 151, 66, 153, 482, 1189, 484, 1191, 462, 585,
3505  126, 593, 151, 467, 153, 126, 119, 889, 121, 122,
3506  581, 124, 583, 898, 97, 1235, 604, 99, 903, 835,
3507  146, 750, 838, 68, 25, 841, 866, 151, 100, 153,
3508  150, 1167, 848, 153, 1228, 851, 569, 151, 526, 153,
3509  99, 1154, 952, 430, 577, 119, 1182, 121, 122, 146,
3510  638, 1162, 97, 126, 650, 577, 553, 579, 148, 862,
3511  1121, 525, 425, 1016, 1017, 68, 52, 126, 816, 591,
3512  56, 458, 592, 146, 571, 591, 149, 99, 611, 601,
3513  153, 68, 602, 617, 66, 601, 682, 146, 68, 611,
3514  68, 68, 148, 581, 97, 583, 912, 617, 485, 66,
3515  617, 623, 68, 591, 126, 650, 68, 470, 66, 34,
3516  97, 148, 25, 601, 68, 603, 604, 97, 96, 97,
3517  97, 643, 77, 739, 146, 126, 99, 52, 1052, 626,
3518  149, 97, 1056, 949, 153, 97, 1060, 682, 1062, 121,
3519  122, 729, 728, 97, 15, 146, 17, 881, 149, 1102,
3520  638, 1104, 153, 126, 121, 122, 727, 654, 892, 893,
3521  99, 119, 650, 121, 122, 687, 684, 145, 688, 694,
3522  152, 687, 68, 691, 692, 738, 701, 729, 149, 697,
3523  698, 705, 569, 705, 706, 152, 708, 126, 710, 1029,
3524  577, 679, 126, 34, 682, 683, 684, 689, 150, 687,
3525  96, 97, 144, 691, 692, 592, 1091, 146, 99, 697,
3526  698, 52, 1052, 126, 146, 602, 1056, 2, 738, 4,
3527  1060, 153, 1062, 99, 611, 58, 56, 724, 750, 66,
3528  67, 16, 17, 146, 99, 126, 149, 734, 26, 727,
3529  153, 729, 730, 146, 77, 767, 834, 769, 1087, 145,
3530  126, 77, 1205, 1206, 106, 642, 643, 828, 1182, 1086,
3531  1184, 126, 833, 66, 850, 1189, 146, 1191, 53, 54,
3532  633, 68, 736, 153, 679, 108, 66, 1011, 683, 112,
3533  68, 778, 834, 68, 121, 122, 99, 751, 68, 146,
3534  787, 783, 784, 99, 56, 1029, 867, 68, 816, 96,
3535  97, 688, 824, 1119, 1228, 151, 91, 92, 96, 97,
3536  95, 14, 15, 126, 56, 100, 96, 97, 121, 122,
3537  126, 124, 1056, 99, 25, 96, 97, 99, 816, 119,
3538  901, 121, 122, 26, 124, 99, 146, 130, 68, 910,
3539  828, 1075, 1182, 153, 1184, 833, 834, 149, 145, 1189,
3540  126, 1191, 897, 144, 126, 143, 10, 145, 40, 41,
3541  148, 849, 126, 1179, 950, 145, 96, 97, 856, 866,
3542  66, 77, 88, 89, 145, 68, 146, 148, 146, 867,
3543  146, 144, 870, 144, 44, 877, 878, 52, 1228, 54,
3544  55, 56, 57, 890, 886, 887, 888, 146, 1004, 146,
3545  892, 893, 981, 96, 97, 146, 68, 146, 44, 897,
3546  8, 99, 126, 901, 13, 145, 961, 939, 997, 941,
3547  942, 866, 910, 119, 209, 121, 122, 891, 134, 135,
3548  136, 137, 138, 68, 96, 97, 101, 1008, 126, 1010,
3549  25, 963, 964, 965, 17, 230, 144, 232, 233, 99,
3550  143, 236, 145, 238, 99, 148, 146, 242, 146, 244,
3551  957, 96, 97, 152, 128, 207, 930, 931, 210, 211,
3552  212, 68, 257, 961, 259, 152, 126, 1048, 150, 976,
3553  855, 126, 857, 145, 68, 977, 15, 1009, 68, 864,
3554  148, 866, 1014, 985, 146, 944, 146, 946, 131, 96,
3555  97, 146, 146, 1000, 1001, 144, 1051, 52, 866, 973,
3556  145, 68, 96, 97, 100, 131, 96, 97, 100, 1011,
3557  1008, 146, 1010, 126, 309, 310, 311, 312, 313, 314,
3558  315, 316, 52, 146, 998, 999, 26, 146, 66, 96,
3559  97, 326, 146, 328, 689, 146, 331, 52, 145, 1046,
3560  146, 1122, 52, 131, 68, 126, 1020, 1045, 146, 146,
3561  1048, 145, 151, 1051, 1086, 145, 1088, 1087, 1090, 146,
3562  1086, 146, 1160, 1161, 146, 1067, 144, 952, 68, 364,
3563  146, 366, 96, 97, 326, 370, 371, 372, 145, 331,
3564  1112, 119, 1037, 121, 122, 1040, 56, 68, 1086, 9,
3565  146, 386, 146, 414, 415, 131, 96, 97, 1160, 1161,
3566  56, 1133, 967, 968, 146, 1060, 146, 1062, 68, 146,
3567  431, 432, 146, 52, 146, 96, 97, 146, 149, 414,
3568  415, 145, 120, 1121, 1122, 146, 1100, 58, 783, 784,
3569  146, 148, 1139, 146, 429, 146, 96, 97, 459, 146,
3570  1142, 1026, 146, 143, 1146, 145, 77, 1154, 148, 1108,
3571  1109, 1232, 1037, 146, 146, 1114, 144, 1116, 148, 1118,
3572  1162, 1029, 1160, 1161, 145, 242, 1034, 1052, 146, 146,
3573  465, 465, 424, 425, 461, 1060, 98, 108, 109, 96,
3574  87, 433, 611, 706, 1052, 145, 1016, 1090, 1056, 484,
3575  1087, 1102, 1060, 769, 1062, 1197, 1198, 54, 55, 866,
3576  57, 882, 133, 1235, 1194, 740, 514, 64, 65, 324,
3577  1235, 1011, 1167, 1075, 1169, 1075, 1075, 886, 470, 1174,
3578  884, 473, 877, 878, 1088, 1009, 105, 1182, 99, 1184,
3579  500, 886, 887, 888, 1232, 951, 1191, 892, 893, 2,
3580  52, 4, 54, 55, 56, 57, 855, 1029, 1207, 1208,
3581  1209, 1210, 1056, 16, 17, 52, 1052, 54, 55, 56,
3582  57, 58, 1026, 1128, 1129, -1, -1, 519, 1223, 1134,
3583  -1, 1136, 1137, 1228, 1233, 40, 41, 42, 43, 44,
3584  77, -1, 1167, -1, -1, -1, 581, -1, 583, 101,
3585  53, 54, -1, -1, 91, 107, 591, 1182, 52, -1,
3586  54, 55, 56, 57, 101, 68, 601, -1, 603, 604,
3587  107, 108, 109, -1, 1182, 52, 1184, 54, 55, 56,
3588  57, 1189, 977, 1191, -1, 689, -1, -1, 91, 92,
3589  985, -1, 95, -1, -1, -1, 133, 100, -1, 136,
3590  -1, -1, -1, 638, 59, 60, 61, 62, 1213, 1214,
3591  1215, 1216, -1, -1, -1, -1, 1011, 77, -1, -1,
3592  1228, -1, -1, -1, -1, -1, 618, -1, 620, 1234,
3593  691, 692, -1, -1, 94, 95, 697, 698, -1, -1,
3594  -1, 633, 77, 635, 679, -1, -1, -1, 683, 684,
3595  -1, -1, 687, -1, -1, -1, 691, 692, -1, 94,
3596  95, -1, 697, 698, -1, 52, -1, 54, 55, 56,
3597  57, 58, 1067, 133, 134, 135, 136, 137, 138, 783,
3598  784, -1, -1, -1, 745, 746, 678, 748, 749, -1,
3599  77, -1, 727, -1, 729, 730, 689, -1, -1, 134,
3600  135, 136, 137, 138, -1, -1, 209, -1, -1, -1,
3601  -1, -1, -1, 705, 101, -1, -1, -1, -1, -1,
3602  107, 108, 109, -1, -1, -1, -1, 230, 720, 232,
3603  233, -1, -1, 236, -1, 238, -1, -1, -1, 242,
3604  -1, 244, -1, -1, -1, -1, 133, 1142, -1, 136,
3605  -1, 1146, -1, -1, 257, 816, 259, -1, -1, -1,
3606  -1, 689, -1, -1, -1, -1, 153, 1162, -1, -1,
3607  -1, -1, -1, 877, 878, -1, -1, -1, 770, -1,
3608  -1, 816, 886, 887, 888, -1, -1, -1, 892, 893,
3609  783, 784, -1, 828, -1, 2, -1, 4, 833, 834,
3610  861, -1, 1197, 1198, -1, -1, 309, 310, 311, 312,
3611  313, 314, 315, 316, 849, -1, -1, -1, -1, -1,
3612  -1, 856, -1, 326, -1, 328, -1, -1, 331, -1,
3613  -1, -1, 867, -1, -1, 870, -1, -1, -1, -1,
3614  -1, -1, -1, -1, -1, -1, 53, 54, -1, -1,
3615  57, 843, -1, -1, -1, 783, 784, -1, -1, -1,
3616  -1, 364, -1, 366, -1, -1, 901, 370, 371, 372,
3617  862, -1, -1, 977, -1, 910, 83, -1, -1, -1,
3618  -1, 985, -1, 386, 877, 878, -1, -1, -1, 96,
3619  97, 98, 99, 886, 887, 888, -1, -1, -1, 892,
3620  893, -1, -1, -1, -1, -1, -1, 1011, -1, -1,
3621  -1, 414, 415, -1, -1, -1, -1, 909, -1, -1,
3622  -1, -1, -1, -1, -1, -1, 429, -1, -1, -1,
3623  52, -1, 54, 55, 56, 57, 58, -1, -1, -1,
3624  -1, -1, -1, -1, -1, 937, -1, -1, -1, 877,
3625  878, -1, -1, -1, -1, 77, -1, -1, 886, 887,
3626  888, -1, 465, 1067, 892, 893, -1, -1, -1, -1,
3627  -1, -1, -1, 1008, -1, 1010, -1, -1, -1, 101,
3628  -1, 484, -1, -1, 977, 107, 108, 109, -1, -1,
3629  -1, 52, 985, 54, 55, 56, 57, 58, -1, -1,
3630  -1, -1, 209, -1, -1, -1, -1, 25, -1, -1,
3631  1045, 133, -1, 1048, 136, -1, 77, -1, 1011, -1,
3632  1012, -1, -1, -1, -1, -1, 148, -1, -1, -1,
3633  -1, -1, -1, 1025, -1, 242, -1, 244, 1142, -1,
3634  101, -1, 1146, -1, -1, -1, 107, 108, 109, 977,
3635  257, 1086, 259, -1, -1, -1, -1, 985, 1162, 77,
3636  78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
3637  88, 89, 133, 280, 1067, 136, 94, 95, 581, -1,
3638  583, -1, -1, 1011, -1, -1, 1121, 1122, 591, -1,
3639  -1, -1, -1, 1197, 1198, -1, -1, -1, 601, -1,
3640  603, 604, 309, -1, -1, -1, -1, 314, -1, 127,
3641  -1, 129, 130, 131, 132, 133, 134, 135, 136, 137,
3642  138, 328, 329, -1, -1, 1160, 1161, -1, -1, -1,
3643  -1, -1, -1, -1, -1, 638, -1, -1, -1, 1067,
3644  -1, -1, 52, -1, 54, 55, 56, 57, 58, 1142,
3645  -1, -1, -1, 1146, -1, -1, -1, -1, -1, 366,
3646  -1, -1, -1, 370, -1, 372, -1, 77, -1, 1162,
3647  -1, -1, -1, -1, -1, -1, 679, -1, -1, -1,
3648  683, 684, -1, -1, 687, 2, -1, 4, 691, 692,
3649  -1, 101, -1, -1, 697, 698, -1, 1232, 108, 109,
3650  -1, -1, -1, -1, 1197, 1198, -1, -1, -1, -1,
3651  -1, -1, -1, -1, 1142, -1, -1, -1, 1146, -1,
3652  -1, -1, -1, 133, 727, -1, 729, 730, 77, -1,
3653  -1, -1, -1, -1, 1162, -1, 53, 54, -1, -1,
3654  57, -1, -1, -1, -1, 94, 95, 2, -1, 4,
3655  -1, -1, -1, -1, -1, -1, -1, -1, 465, -1,
3656  -1, -1, -1, -1, -1, -1, 83, -1, -1, 1197,
3657  1198, -1, -1, -1, -1, 482, -1, -1, -1, 96,
3658  97, 98, 131, 132, 133, 134, 135, 136, 137, 138,
3659  -1, -1, -1, -1, -1, -1, -1, -1, 53, 54,
3660  -1, -1, 57, -1, -1, -1, -1, -1, -1, -1,
3661  -1, -1, -1, 816, -1, -1, -1, -1, -1, 526,
3662  -1, -1, -1, -1, -1, 828, -1, -1, 83, -1,
3663  833, 834, 33, 34, 35, 36, -1, -1, -1, -1,
3664  -1, 96, 97, 98, 99, -1, 849, -1, 49, 50,
3665  51, 52, -1, 856, -1, 56, -1, -1, 59, 60,
3666  61, 62, 63, -1, 867, -1, -1, 870, -1, -1,
3667  -1, -1, -1, -1, 581, -1, 583, -1, -1, -1,
3668  -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
3669  91, -1, 209, -1, -1, -1, 603, 98, 901, -1,
3670  101, -1, -1, 104, 105, -1, 107, 910, -1, 110,
3671  111, 112, 113, 114, 115, 116, 117, 118, -1, -1,
3672  -1, -1, -1, -1, -1, 242, -1, 244, -1, -1,
3673  -1, 132, -1, -1, -1, 689, -1, -1, 139, -1,
3674  257, -1, 259, 650, -1, -1, -1, -1, -1, -1,
3675  -1, -1, -1, -1, 209, -1, -1, -1, -1, -1,
3676  -1, -1, -1, 280, -1, -1, -1, -1, -1, -1,
3677  -1, -1, 679, -1, -1, 682, 683, -1, -1, -1,
3678  -1, -1, 689, -1, -1, -1, 2, 242, 4, 244,
3679  -1, -1, 309, -1, -1, -1, -1, 314, -1, -1,
3680  -1, -1, 257, -1, 259, 1008, -1, 1010, -1, -1,
3681  -1, 328, 329, -1, 331, -1, -1, -1, -1, -1,
3682  727, -1, -1, 730, -1, 280, -1, -1, -1, 783,
3683  784, -1, -1, -1, -1, -1, -1, 53, 54, -1,
3684  -1, -1, 1045, -1, -1, 1048, -1, -1, -1, 366,
3685  -1, -1, -1, 370, 309, 372, -1, -1, -1, 314,
3686  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3687  -1, -1, -1, 328, 329, -1, 783, 784, -1, -1,
3688  96, -1, -1, 1086, -1, -1, -1, -1, -1, -1,
3689  -1, -1, -1, -1, -1, -1, -1, 414, 415, -1,
3690  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3691  -1, 366, -1, -1, -1, 370, -1, 372, 1121, 1122,
3692  -1, 828, -1, 877, 878, -1, 833, -1, -1, -1,
3693  -1, -1, 886, 887, 888, -1, -1, -1, 892, 893,
3694  -1, -1, 849, -1, -1, -1, -1, -1, 465, 856,
3695  -1, -1, -1, -1, -1, -1, -1, 1160, 1161, -1,
3696  867, -1, -1, 870, -1, 482, -1, -1, -1, -1,
3697  877, 878, -1, -1, -1, -1, -1, -1, -1, 886,
3698  887, 888, -1, -1, -1, 892, 893, -1, -1, -1,
3699  897, -1, -1, 209, 901, -1, -1, -1, -1, -1,
3700  -1, -1, -1, 910, -1, -1, -1, -1, -1, 526,
3701  465, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3702  -1, -1, 2, 977, 4, -1, 242, 482, 244, 1232,
3703  -1, 985, -1, -1, -1, -1, -1, -1, -1, -1,
3704  -1, 257, -1, 259, -1, -1, -1, -1, -1, -1,
3705  -1, -1, -1, -1, 961, -1, -1, 1011, -1, -1,
3706  -1, -1, -1, -1, 581, -1, 583, -1, -1, -1,
3707  977, 526, -1, 53, 54, -1, -1, -1, 985, -1,
3708  -1, -1, -1, -1, -1, -1, 603, -1, -1, -1,
3709  -1, -1, -1, 309, -1, -1, -1, -1, 314, -1,
3710  -1, 1008, -1, 1010, 1011, -1, -1, -1, -1, -1,
3711  -1, -1, 328, 1067, -1, 331, -1, -1, -1, -1,
3712  -1, -1, -1, -1, -1, -1, 581, -1, 583, -1,
3713  -1, -1, -1, 650, -1, -1, -1, -1, 1045, -1,
3714  -1, 1048, 659, -1, 1051, -1, -1, -1, 603, -1,
3715  366, -1, -1, -1, 370, -1, 372, -1, -1, -1,
3716  1067, -1, 679, -1, -1, 682, 683, 684, -1, -1,
3717  -1, -1, -1, -1, 691, 692, -1, -1, -1, -1,
3718  697, 698, -1, -1, -1, -1, -1, -1, 1142, -1,
3719  -1, -1, 1146, -1, -1, 650, -1, -1, 414, 415,
3720  -1, -1, -1, -1, 33, 34, 35, 36, 1162, -1,
3721  727, -1, -1, 730, 1121, 1122, -1, -1, -1, -1,
3722  49, 50, 51, -1, 679, -1, -1, 682, 683, 209,
3723  59, 60, 61, 62, 63, 1142, -1, -1, -1, 1146,
3724  -1, -1, -1, 1197, 1198, -1, -1, -1, -1, 465,
3725  -1, -1, -1, -1, -1, 1162, -1, -1, -1, -1,
3726  -1, -1, 242, -1, 244, -1, -1, -1, -1, -1,
3727  -1, -1, 727, -1, -1, 730, -1, 257, -1, 259,
3728  -1, 110, 111, 112, 113, 114, 115, 116, 117, 118,
3729  1197, 1198, -1, -1, -1, -1, -1, -1, -1, 816,
3730  -1, -1, -1, 77, 78, 79, 80, 81, 82, 83,
3731  139, 828, 86, 87, -1, -1, 833, -1, -1, -1,
3732  94, 95, -1, -1, -1, 1232, -1, -1, -1, 309,
3733  -1, -1, 849, -1, 314, -1, -1, -1, 689, 856,
3734  -1, -1, -1, -1, -1, -1, -1, -1, 328, -1,
3735  867, 331, -1, 870, -1, 129, 130, 131, 132, 133,
3736  134, 135, 136, 137, 138, 581, -1, 583, -1, -1,
3737  -1, -1, -1, 828, -1, -1, -1, -1, 833, -1,
3738  897, -1, -1, -1, 901, -1, 366, 603, -1, -1,
3739  370, -1, 372, 910, 849, -1, -1, -1, -1, -1,
3740  -1, 856, -1, -1, -1, -1, -1, -1, -1, -1,
3741  689, -1, 867, -1, -1, 870, -1, -1, -1, -1,
3742  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3743  -1, -1, 783, 784, 414, 415, -1, -1, -1, -1,
3744  -1, -1, 897, -1, 961, -1, 901, -1, -1, -1,
3745  -1, -1, -1, -1, -1, 910, -1, -1, -1, -1,
3746  -1, -1, -1, 679, -1, -1, -1, 683, 684, -1,
3747  -1, -1, -1, -1, -1, 691, 692, -1, -1, -1,
3748  -1, 697, 698, -1, -1, 465, -1, -1, -1, -1,
3749  -1, 1008, -1, 1010, -1, -1, -1, -1, -1, -1,
3750  -1, -1, -1, -1, 783, 784, 961, -1, -1, -1,
3751  -1, 727, -1, -1, 730, 77, 78, 79, 80, 81,
3752  82, 83, 84, -1, 86, 87, 877, 878, 1045, -1,
3753  -1, 1048, 94, 95, 1051, 886, 887, 888, -1, -1,
3754  -1, 892, 893, -1, -1, -1, -1, -1, -1, -1,
3755  -1, -1, -1, 1008, -1, 1010, -1, -1, -1, -1,
3756  -1, -1, -1, -1, -1, -1, -1, 129, 130, 131,
3757  132, 133, 134, 135, 136, 137, 138, -1, -1, -1,
3758  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3759  1045, -1, -1, 1048, -1, -1, 1051, -1, 877, 878,
3760  816, 581, -1, 583, 1121, 1122, -1, 886, 887, 888,
3761  -1, -1, 828, 892, 893, -1, -1, 833, -1, -1,
3762  -1, -1, -1, 603, 16, 17, 977, -1, -1, -1,
3763  -1, -1, -1, 849, 985, -1, -1, -1, -1, -1,
3764  856, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3765  -1, 867, -1, -1, 870, -1, 48, 49, 50, 51,
3766  1011, -1, -1, 55, 56, -1, 1121, 1122, -1, -1,
3767  -1, -1, -1, -1, -1, -1, 68, 69, -1, -1,
3768  -1, 897, -1, -1, -1, 901, -1, -1, -1, -1,
3769  -1, -1, -1, -1, 910, -1, -1, -1, 977, 679,
3770  -1, -1, -1, 683, 684, -1, 985, -1, 100, -1,
3771  -1, 691, 692, -1, -1, 1232, 1067, 697, 698, -1,
3772  -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,
3773  -1, -1, 1011, -1, -1, -1, -1, 8, 9, 10,
3774  -1, -1, 13, 14, 15, -1, 17, 727, -1, -1,
3775  730, -1, -1, -1, 25, 26, 27, -1, -1, -1,
3776  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3777  41, 42, 43, 44, -1, -1, -1, 1232, -1, -1,
3778  -1, -1, -1, -1, -1, -1, -1, -1, 1067, -1,
3779  -1, 1142, 1008, -1, 1010, 1146, -1, 68, -1, -1,
3780  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3781  -1, 1162, -1, -1, -1, 207, -1, -1, 210, 211,
3782  212, -1, 214, -1, -1, 96, 97, -1, -1, 1045,
3783  -1, -1, 1048, -1, -1, -1, 816, -1, 230, -1,
3784  232, 233, -1, -1, -1, -1, 1197, 1198, 828, 120,
3785  -1, -1, -1, 833, -1, -1, -1, -1, -1, -1,
3786  -1, -1, -1, 1142, -1, -1, -1, 1146, -1, 849,
3787  -1, -1, 143, 144, -1, -1, 856, 148, 149, -1,
3788  151, -1, 153, 1162, -1, -1, -1, 867, -1, -1,
3789  870, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3790  -1, -1, -1, -1, -1, 1121, 1122, -1, -1, -1,
3791  -1, -1, -1, -1, -1, -1, -1, -1, 1197, 1198,
3792  -1, 901, -1, -1, -1, -1, -1, -1, -1, -1,
3793  910, -1, -1, -1, 326, -1, -1, -1, -1, 331,
3794  -1, 333, 334, 335, 336, 337, -1, -1, 340, 341,
3795  342, 343, 344, 345, 346, 347, 348, -1, -1, 351,
3796  352, 353, 354, 355, 356, 357, 358, 359, 360, -1,
3797  -1, -1, 364, -1, -1, -1, -1, -1, -1, -1,
3798  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3799  -1, -1, -1, -1, -1, -1, 77, 78, 79, 80,
3800  81, 82, 83, 84, 85, 86, 87, 88, 89, -1,
3801  -1, -1, -1, 94, 95, -1, 1232, -1, -1, -1,
3802  -1, -1, 414, 415, -1, -1, -1, -1, 1008, -1,
3803  1010, 423, 424, 425, -1, -1, -1, 429, -1, 431,
3804  432, 433, -1, -1, -1, -1, 127, 439, 129, 130,
3805  131, 132, 133, 134, 135, 136, 137, 138, -1, -1,
3806  -1, -1, 454, -1, -1, 1045, -1, 459, 1048, -1,
3807  -1, -1, 153, -1, -1, -1, -1, -1, 470, -1,
3808  -1, 473, -1, -1, -1, -1, -1, -1, -1, -1,
3809  -1, -1, 484, -1, -1, -1, -1, -1, -1, -1,
3810  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3811  502, 77, 78, 79, 80, 81, 82, 83, 84, 85,
3812  86, 87, 88, 89, -1, -1, -1, 519, 94, 95,
3813  -1, -1, -1, -1, -1, -1, 0, -1, -1, -1,
3814  -1, 1121, 1122, -1, 8, 9, 10, -1, -1, -1,
3815  14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
3816  -1, 25, 26, 129, 130, 131, 132, 133, 134, 135,
3817  136, 137, 138, 37, 38, -1, 40, 41, 42, 43,
3818  44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3819  -1, -1, -1, -1, -1, -1, -1, -1, -1, 591,
3820  -1, -1, -1, -1, 68, -1, -1, -1, -1, 601,
3821  -1, -1, -1, 77, 78, 79, 80, 81, 82, 83,
3822  84, 85, 86, 87, 88, 89, 618, -1, 620, -1,
3823  94, 95, 96, 97, -1, 99, -1, -1, -1, -1,
3824  -1, 633, -1, 635, -1, -1, -1, -1, -1, -1,
3825  -1, -1, 1232, -1, -1, -1, 120, -1, -1, -1,
3826  -1, -1, 126, 127, -1, 129, 130, 131, 132, 133,
3827  134, 135, 136, 137, 138, -1, -1, -1, -1, 143,
3828  144, 145, 146, -1, -1, 149, 678, 151, -1, 153,
3829  -1, -1, 684, 685, -1, 687, -1, -1, -1, 691,
3830  692, -1, -1, -1, -1, 697, 698, -1, 0, -1,
3831  -1, -1, -1, 705, -1, -1, 8, 9, 10, -1,
3832  -1, 13, 14, 15, -1, 17, -1, -1, 720, -1,
3833  -1, -1, -1, 25, -1, 27, 28, 29, -1, -1,
3834  -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
3835  42, 43, 44, 745, 746, -1, 748, 749, -1, -1,
3836  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3837  -1, -1, -1, -1, -1, -1, 68, -1, 770, -1,
3838  -1, -1, -1, -1, -1, 77, 78, 79, 80, 81,
3839  82, 83, 84, 85, 86, 87, 88, 89, -1, -1,
3840  -1, -1, 94, 95, 96, 97, -1, 99, 100, -1,
3841  -1, -1, -1, -1, 106, -1, -1, 809, -1, -1,
3842  -1, -1, -1, -1, 816, -1, -1, -1, 120, -1,
3843  -1, 123, -1, -1, 126, 127, 128, 129, 130, 131,
3844  132, 133, 134, 135, 136, 137, 138, -1, -1, -1,
3845  -1, 843, 144, 145, 146, -1, -1, 149, 150, 151,
3846  -1, 153, -1, -1, -1, -1, -1, -1, -1, 861,
3847  862, -1, -1, 0, 1, -1, 3, 4, 5, 6,
3848  7, -1, -1, -1, 11, 12, -1, -1, -1, 16,
3849  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
3850  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
3851  -1, -1, 39, -1, -1, -1, -1, 909, 45, 46,
3852  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
3853  57, -1, 59, 60, 61, 62, 63, 64, 65, -1,
3854  -1, -1, -1, -1, -1, 937, -1, -1, 75, 76,
3855  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3856  -1, -1, -1, 90, 91, -1, -1, -1, -1, -1,
3857  -1, 98, -1, -1, 101, 102, -1, 104, 105, -1,
3858  107, -1, -1, 110, 111, 112, 113, 114, 115, 116,
3859  117, 118, -1, -1, -1, -1, -1, -1, -1, -1,
3860  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3861  -1, -1, 139, 140, 141, -1, -1, -1, -1, -1,
3862  1012, 0, -1, -1, 151, -1, 153, -1, -1, 8,
3863  9, 10, -1, 1025, 13, 14, 15, -1, 17, -1,
3864  -1, -1, -1, -1, -1, -1, 25, 26, 27, 28,
3865  29, -1, -1, -1, -1, -1, -1, -1, 37, 38,
3866  -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
3867  -1, -1, -1, -1, -1, -1, -1, -1, 77, 78,
3868  79, 80, 81, 82, 83, -1, -1, 86, 87, 68,
3869  -1, -1, -1, -1, 1086, 94, 95, -1, 77, 78,
3870  79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
3871  89, -1, -1, -1, -1, 94, 95, 96, 97, -1,
3872  99, 100, -1, -1, -1, -1, -1, 106, -1, -1,
3873  129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
3874  -1, 120, -1, -1, 123, -1, -1, 126, 127, 128,
3875  129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
3876  -1, -1, -1, -1, 143, 144, 145, 146, 0, -1,
3877  149, 150, 151, -1, 153, -1, 8, 9, 10, -1,
3878  -1, 13, 14, 15, -1, 17, -1, -1, -1, -1,
3879  44, -1, -1, 25, -1, 27, 28, 29, -1, -1,
3880  -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
3881  42, 43, 44, -1, -1, -1, -1, -1, -1, -1,
3882  -1, -1, -1, 77, 78, 79, 80, 81, 82, 83,
3883  84, 85, 86, 87, 88, 89, 68, -1, -1, -1,
3884  94, 95, -1, -1, -1, 77, 78, 79, 80, 81,
3885  82, 83, 84, 85, 86, 87, 88, 89, -1, -1,
3886  -1, -1, 94, 95, 96, 97, -1, 99, 100, -1,
3887  -1, -1, -1, 127, 106, 129, 130, 131, 132, 133,
3888  134, 135, 136, 137, 138, -1, -1, -1, 120, -1,
3889  -1, 123, 146, -1, 126, 127, 128, 129, 130, 131,
3890  132, 133, 134, 135, 136, 137, 138, -1, -1, -1,
3891  -1, -1, 144, 145, 146, 0, -1, 149, 150, 151,
3892  -1, 153, -1, 8, 9, 10, -1, -1, 13, 14,
3893  15, -1, 17, -1, -1, -1, -1, 44, -1, -1,
3894  25, 26, 27, 28, 29, -1, -1, -1, -1, -1,
3895  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3896  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3897  77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
3898  87, 88, 89, 68, -1, -1, -1, 94, 95, -1,
3899  -1, -1, 77, 78, 79, 80, 81, 82, 83, 84,
3900  85, 86, 87, 88, 89, -1, -1, -1, -1, 94,
3901  95, 96, 97, -1, -1, 100, -1, -1, -1, -1,
3902  127, 106, 129, 130, 131, 132, 133, 134, 135, 136,
3903  137, 138, -1, -1, -1, 120, -1, -1, 123, -1,
3904  -1, -1, 127, 128, 129, 130, 131, 132, 133, 134,
3905  135, 136, 137, 138, -1, -1, -1, -1, 143, 144,
3906  145, 146, 0, -1, 149, 150, 151, -1, 153, -1,
3907  8, 9, 10, -1, -1, 13, 14, 15, -1, 17,
3908  -1, -1, -1, -1, -1, -1, -1, 25, 26, 27,
3909  28, 29, -1, -1, -1, -1, -1, -1, -1, 37,
3910  38, -1, 40, 41, 42, 43, 44, -1, -1, -1,
3911  -1, -1, -1, -1, -1, -1, -1, 77, 78, 79,
3912  80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
3913  68, -1, -1, -1, 94, 95, -1, -1, -1, 77,
3914  78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
3915  88, 89, -1, -1, -1, -1, 94, 95, 96, 97,
3916  -1, -1, 100, -1, -1, -1, -1, 127, 106, 129,
3917  130, 131, 132, 133, 134, 135, 136, 137, 138, -1,
3918  -1, -1, 120, -1, -1, 123, -1, -1, -1, 127,
3919  128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
3920  138, -1, -1, -1, -1, 143, 144, 145, 146, 0,
3921  -1, 149, 150, 151, -1, 153, -1, 8, 9, 10,
3922  -1, -1, 13, 14, 15, -1, 17, -1, -1, -1,
3923  -1, -1, -1, -1, 25, -1, 27, 28, 29, -1,
3924  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3925  41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
3926  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3927  -1, -1, -1, -1, -1, -1, -1, 68, -1, -1,
3928  -1, -1, -1, -1, -1, -1, 77, 78, 79, 80,
3929  81, 82, 83, 84, 85, 86, 87, 88, 89, -1,
3930  -1, -1, -1, 94, 95, 96, 97, -1, 99, 100,
3931  -1, -1, -1, -1, -1, 106, -1, -1, -1, -1,
3932  -1, -1, -1, -1, -1, -1, -1, -1, -1, 120,
3933  -1, -1, 123, -1, -1, 126, 127, 128, 129, 130,
3934  131, 132, 133, 134, 135, 136, 137, 138, -1, -1,
3935  -1, -1, -1, 144, 145, 146, 0, -1, 149, 150,
3936  151, -1, 153, -1, 8, 9, 10, -1, -1, 13,
3937  14, 15, -1, 17, -1, -1, -1, -1, -1, -1,
3938  -1, 25, 26, 27, 28, -1, -1, -1, -1, -1,
3939  -1, -1, -1, 37, 38, -1, 40, 41, 42, 43,
3940  44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3941  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3942  -1, -1, -1, -1, 68, -1, -1, -1, -1, -1,
3943  -1, -1, -1, 77, 78, 79, 80, 81, 82, 83,
3944  84, 85, 86, 87, 88, 89, -1, -1, -1, -1,
3945  94, 95, 96, 97, -1, -1, 100, -1, -1, -1,
3946  -1, -1, 106, -1, -1, -1, -1, -1, -1, -1,
3947  -1, -1, -1, -1, -1, -1, 120, -1, -1, -1,
3948  -1, -1, -1, 127, -1, 129, 130, 131, 132, 133,
3949  134, 135, 136, 137, 138, -1, -1, -1, -1, 143,
3950  144, 145, 146, 0, 148, 149, 150, 151, -1, 153,
3951  -1, 8, 9, 10, -1, -1, 13, 14, 15, -1,
3952  17, -1, -1, -1, -1, -1, -1, -1, 25, -1,
3953  27, 28, 29, -1, -1, -1, -1, -1, -1, -1,
3954  37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
3955  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3956  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3957  -1, 68, -1, -1, -1, -1, -1, -1, -1, -1,
3958  77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
3959  87, 88, 89, -1, -1, -1, -1, 94, 95, 96,
3960  97, -1, -1, 100, -1, -1, -1, -1, -1, 106,
3961  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3962  -1, -1, -1, 120, -1, -1, 123, -1, -1, -1,
3963  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
3964  137, 138, -1, -1, -1, -1, -1, 144, 145, 146,
3965  0, -1, 149, 150, 151, -1, 153, -1, 8, 9,
3966  10, -1, -1, 13, 14, 15, -1, 17, -1, -1,
3967  -1, -1, -1, -1, -1, 25, 26, 27, 28, -1,
3968  -1, -1, -1, -1, -1, -1, -1, 37, 38, -1,
3969  40, 41, 42, 43, 44, -1, -1, -1, -1, -1,
3970  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3971  -1, -1, -1, -1, -1, -1, -1, -1, 68, -1,
3972  -1, -1, -1, -1, -1, -1, -1, 77, 78, 79,
3973  80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
3974  -1, -1, -1, -1, 94, 95, 96, 97, -1, -1,
3975  100, -1, -1, -1, -1, -1, 106, -1, -1, -1,
3976  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3977  120, -1, -1, -1, -1, -1, -1, 127, -1, 129,
3978  130, 131, 132, 133, 134, 135, 136, 137, 138, -1,
3979  -1, -1, -1, 143, 144, 145, 146, 0, 148, 149,
3980  150, 151, -1, 153, -1, 8, 9, 10, -1, -1,
3981  13, 14, 15, -1, 17, -1, -1, -1, -1, -1,
3982  -1, -1, 25, -1, 27, 28, -1, -1, -1, -1,
3983  -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
3984  43, 44, -1, -1, -1, -1, -1, -1, -1, -1,
3985  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3986  -1, -1, -1, -1, -1, 68, -1, -1, -1, -1,
3987  -1, -1, -1, -1, 77, 78, 79, 80, 81, 82,
3988  83, 84, 85, 86, 87, 88, 89, -1, -1, -1,
3989  -1, 94, 95, 96, 97, -1, -1, 100, -1, -1,
3990  -1, -1, -1, 106, -1, -1, -1, -1, -1, -1,
3991  -1, -1, -1, -1, -1, -1, -1, 120, -1, -1,
3992  -1, -1, -1, -1, 127, -1, 129, 130, 131, 132,
3993  133, 134, 135, 136, 137, 138, -1, -1, -1, -1,
3994  -1, 144, 145, 146, 0, 148, 149, 150, 151, -1,
3995  153, -1, 8, 9, 10, -1, -1, -1, 14, 15,
3996  -1, 17, -1, -1, -1, -1, -1, -1, -1, 25,
3997  26, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3998  -1, 37, 38, -1, 40, 41, 42, 43, 44, -1,
3999  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4000  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4001  -1, -1, 68, -1, -1, -1, -1, -1, -1, -1,
4002  -1, 77, 78, 79, 80, 81, 82, 83, 84, 85,
4003  86, 87, 88, 89, -1, -1, -1, -1, 94, 95,
4004  96, 97, -1, 99, -1, -1, -1, -1, -1, -1,
4005  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4006  -1, -1, -1, -1, 120, -1, -1, -1, -1, -1,
4007  126, 127, -1, 129, 130, 131, 132, 133, 134, 135,
4008  136, 137, 138, -1, -1, -1, -1, 143, 144, 145,
4009  146, 0, -1, 149, -1, 151, -1, 153, -1, 8,
4010  9, 10, -1, -1, -1, 14, 15, -1, 17, -1,
4011  -1, -1, -1, -1, -1, -1, 25, -1, -1, -1,
4012  -1, -1, -1, -1, -1, -1, -1, -1, 37, 38,
4013  -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
4014  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4015  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
4016  -1, -1, -1, -1, -1, -1, -1, -1, 77, 78,
4017  79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
4018  89, -1, -1, -1, -1, 94, 95, 96, 97, -1,
4019  99, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4020  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4021  -1, 120, -1, -1, -1, -1, -1, 126, 127, -1,
4022  129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
4023  -1, -1, -1, -1, -1, 144, 145, 146, 0, -1,
4024  149, -1, 151, -1, 153, -1, 8, 9, 10, -1,
4025  -1, -1, 14, 15, -1, 17, -1, -1, -1, -1,
4026  -1, -1, -1, 25, -1, -1, -1, -1, -1, -1,
4027  -1, -1, -1, -1, -1, 37, 38, -1, 40, 41,
4028  42, 43, 44, -1, -1, -1, -1, -1, -1, -1,
4029  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4030  -1, -1, -1, -1, -1, -1, 68, -1, -1, -1,
4031  -1, -1, -1, -1, -1, 77, 78, 79, 80, 81,
4032  82, 83, 84, 85, 86, 87, 88, 89, -1, -1,
4033  -1, -1, 94, 95, 96, 97, -1, 99, -1, -1,
4034  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4035  -1, -1, -1, -1, -1, -1, -1, -1, 120, -1,
4036  -1, -1, -1, -1, 126, 127, -1, 129, 130, 131,
4037  132, 133, 134, 135, 136, 137, 138, -1, -1, -1,
4038  -1, -1, 144, 145, 146, -1, -1, 149, -1, 151,
4039  1, 153, 3, 4, 5, 6, 7, 8, 9, 10,
4040  11, 12, -1, -1, 15, 16, -1, 18, 19, 20,
4041  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4042  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4043  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
4044  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4045  61, 62, 63, 64, 65, -1, -1, -1, -1, -1,
4046  -1, -1, -1, -1, 75, 76, -1, -1, -1, -1,
4047  -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
4048  91, -1, -1, -1, -1, -1, -1, 98, -1, -1,
4049  101, 102, -1, 104, 105, -1, 107, -1, -1, 110,
4050  111, 112, 113, 114, 115, 116, 117, 118, -1, -1,
4051  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4052  -1, -1, -1, -1, -1, -1, -1, -1, 139, 140,
4053  141, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4054  151, 1, 153, 3, 4, 5, 6, 7, -1, -1,
4055  10, 11, 12, -1, 14, 15, 16, -1, 18, 19,
4056  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4057  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4058  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
4059  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4060  60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
4061  -1, -1, -1, -1, -1, 75, 76, -1, -1, -1,
4062  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4063  90, 91, -1, -1, -1, -1, -1, -1, 98, -1,
4064  -1, 101, 102, -1, 104, 105, -1, 107, -1, -1,
4065  110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
4066  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4067  -1, -1, -1, -1, -1, -1, -1, -1, -1, 139,
4068  140, 141, -1, -1, -1, -1, -1, -1, -1, -1,
4069  -1, 151, 1, 153, 3, 4, 5, 6, 7, -1,
4070  -1, 10, 11, 12, -1, -1, 15, 16, 17, 18,
4071  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4072  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4073  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
4074  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4075  59, 60, 61, 62, 63, 64, 65, -1, -1, -1,
4076  -1, -1, -1, -1, -1, -1, 75, 76, -1, -1,
4077  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4078  -1, 90, 91, -1, -1, -1, -1, -1, -1, 98,
4079  -1, -1, 101, 102, -1, 104, 105, -1, 107, -1,
4080  -1, 110, 111, 112, 113, 114, 115, 116, 117, 118,
4081  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4082  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4083  139, 140, 141, -1, -1, -1, -1, -1, -1, -1,
4084  -1, -1, 151, 1, 153, 3, 4, 5, 6, 7,
4085  -1, -1, 10, 11, 12, -1, -1, 15, 16, -1,
4086  18, 19, 20, 21, 22, 23, 24, 25, -1, -1,
4087  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4088  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
4089  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4090  -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
4091  -1, -1, -1, -1, -1, -1, -1, 75, 76, -1,
4092  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4093  -1, -1, 90, 91, -1, -1, -1, -1, -1, -1,
4094  98, -1, -1, 101, 102, -1, 104, 105, -1, 107,
4095  -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
4096  118, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4097  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4098  -1, 139, 140, 141, -1, -1, -1, -1, -1, -1,
4099  -1, -1, -1, 151, 1, 153, 3, 4, 5, 6,
4100  7, -1, -1, 10, 11, 12, -1, -1, 15, 16,
4101  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
4102  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4103  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
4104  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4105  57, -1, 59, 60, 61, 62, 63, 64, 65, -1,
4106  -1, -1, -1, -1, -1, -1, -1, -1, 75, 76,
4107  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4108  -1, -1, -1, 90, 91, -1, -1, -1, -1, -1,
4109  -1, 98, -1, -1, 101, 102, -1, 104, 105, -1,
4110  107, -1, -1, 110, 111, 112, 113, 114, 115, 116,
4111  117, 118, -1, -1, -1, -1, -1, -1, -1, -1,
4112  1, -1, 3, 4, 5, 6, 7, -1, 9, 10,
4113  11, 12, 139, 140, 141, 16, -1, 18, 19, 20,
4114  21, 22, 23, 24, 151, -1, 153, -1, -1, 30,
4115  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4116  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
4117  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4118  61, 62, 63, 64, 65, -1, -1, -1, -1, -1,
4119  -1, -1, -1, -1, 75, 76, -1, -1, -1, -1,
4120  -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
4121  91, -1, -1, -1, -1, -1, -1, 98, -1, -1,
4122  101, 102, -1, 104, 105, -1, 107, -1, -1, 110,
4123  111, 112, 113, 114, 115, 116, 117, 118, -1, -1,
4124  -1, -1, -1, -1, -1, -1, 1, -1, 3, 4,
4125  5, 6, 7, -1, -1, -1, 11, 12, 139, 140,
4126  141, 16, -1, 18, 19, 20, 21, 22, 23, 24,
4127  151, -1, 153, -1, -1, 30, 31, 32, 33, 34,
4128  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4129  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
4130  55, 56, 57, -1, 59, 60, 61, 62, 63, 64,
4131  65, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4132  75, 76, -1, -1, -1, -1, -1, -1, -1, -1,
4133  -1, -1, -1, -1, -1, 90, 91, -1, -1, -1,
4134  -1, -1, -1, 98, -1, -1, 101, 102, -1, 104,
4135  105, -1, 107, -1, -1, 110, 111, 112, 113, 114,
4136  115, 116, 117, 118, -1, -1, -1, -1, -1, -1,
4137  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4138  -1, -1, -1, -1, 139, 140, 141, -1, -1, -1,
4139  -1, -1, -1, -1, 149, -1, 151, 1, 153, 3,
4140  4, 5, 6, 7, -1, -1, -1, 11, 12, -1,
4141  -1, -1, 16, -1, 18, 19, 20, 21, 22, 23,
4142  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4143  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4144  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
4145  54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
4146  64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
4147  -1, 75, 76, -1, -1, -1, -1, -1, -1, -1,
4148  -1, -1, -1, -1, -1, -1, 90, 91, -1, -1,
4149  -1, -1, -1, -1, 98, -1, -1, 101, 102, -1,
4150  104, 105, -1, 107, -1, -1, 110, 111, 112, 113,
4151  114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
4152  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4153  -1, -1, -1, -1, -1, 139, 140, 141, -1, -1,
4154  -1, -1, -1, -1, -1, 149, -1, 151, 1, 153,
4155  3, 4, 5, 6, 7, -1, -1, -1, 11, 12,
4156  -1, -1, -1, 16, -1, 18, 19, 20, 21, 22,
4157  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4158  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4159  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
4160  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
4161  63, 64, 65, -1, -1, -1, -1, -1, -1, -1,
4162  -1, -1, 75, 76, -1, -1, -1, -1, -1, -1,
4163  -1, -1, -1, -1, -1, -1, -1, 90, 91, -1,
4164  -1, -1, -1, -1, -1, 98, -1, -1, 101, 102,
4165  -1, 104, 105, -1, 107, -1, -1, 110, 111, 112,
4166  113, 114, 115, 116, 117, 118, -1, -1, -1, -1,
4167  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4168  -1, -1, -1, -1, -1, -1, 139, 140, 141, -1,
4169  -1, 144, -1, -1, -1, -1, -1, -1, 151, 1,
4170  153, 3, 4, 5, 6, 7, -1, -1, -1, 11,
4171  12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
4172  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4173  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4174  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
4175  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4176  62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
4177  -1, -1, -1, 75, 76, -1, -1, -1, -1, -1,
4178  -1, -1, -1, -1, -1, -1, -1, -1, 90, 91,
4179  -1, -1, -1, -1, -1, -1, 98, -1, -1, 101,
4180  102, -1, 104, 105, -1, 107, -1, -1, 110, 111,
4181  112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
4182  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4183  -1, -1, -1, -1, -1, -1, -1, 139, 140, 141,
4184  -1, -1, 144, -1, -1, -1, -1, -1, -1, 151,
4185  1, 153, 3, 4, 5, 6, 7, -1, -1, 10,
4186  11, 12, -1, -1, -1, 16, -1, 18, 19, 20,
4187  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4188  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4189  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
4190  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4191  61, 62, 63, 64, 65, -1, -1, -1, -1, -1,
4192  -1, -1, -1, -1, 75, 76, -1, -1, -1, -1,
4193  -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
4194  91, -1, -1, -1, -1, -1, -1, 98, -1, -1,
4195  101, 102, -1, 104, 105, -1, 107, -1, -1, 110,
4196  111, 112, 113, 114, 115, 116, 117, 118, -1, -1,
4197  -1, -1, -1, -1, -1, -1, 1, -1, 3, 4,
4198  5, 6, 7, -1, -1, -1, 11, 12, 139, 140,
4199  141, 16, -1, 18, 19, 20, 21, 22, 23, 24,
4200  151, -1, 153, -1, -1, 30, 31, 32, 33, 34,
4201  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4202  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
4203  55, 56, 57, -1, 59, 60, 61, 62, 63, 64,
4204  65, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4205  75, 76, -1, -1, -1, -1, -1, -1, -1, -1,
4206  -1, -1, -1, -1, -1, 90, 91, -1, -1, -1,
4207  -1, -1, -1, 98, -1, -1, 101, 102, -1, 104,
4208  105, -1, 107, -1, -1, 110, 111, 112, 113, 114,
4209  115, 116, 117, 118, -1, 120, -1, -1, -1, -1,
4210  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4211  -1, -1, 11, 12, 139, 140, 141, 16, -1, 18,
4212  19, 20, 21, 22, 23, 24, 151, -1, 153, -1,
4213  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4214  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4215  49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
4216  59, 60, 61, 62, 63, 64, 65, -1, -1, -1,
4217  -1, -1, -1, -1, -1, -1, 75, 76, -1, -1,
4218  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4219  -1, 90, 91, -1, -1, -1, -1, -1, -1, 98,
4220  -1, -1, 101, 102, -1, 104, 105, -1, 107, 108,
4221  109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
4222  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4223  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4224  139, 140, 141, 16, -1, 18, 19, 20, 21, 22,
4225  23, 24, -1, -1, 153, -1, -1, 30, 31, 32,
4226  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4227  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4228  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
4229  63, 64, 65, -1, -1, -1, -1, -1, -1, -1,
4230  -1, -1, 75, 76, -1, -1, -1, -1, -1, -1,
4231  -1, -1, -1, -1, -1, -1, -1, 90, 91, -1,
4232  -1, -1, -1, -1, -1, 98, -1, -1, 101, 102,
4233  -1, 104, 105, -1, -1, -1, -1, 110, 111, 112,
4234  113, 114, 115, 116, 117, 118, -1, -1, -1, -1,
4235  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
4236  7, -1, -1, -1, 11, 12, 139, 140, 141, 16,
4237  -1, 18, 19, 20, 21, 22, 23, 24, 151, -1,
4238  153, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4239  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
4240  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
4241  57, -1, 59, 60, 61, 62, 63, 64, 65, -1,
4242  -1, -1, -1, -1, -1, -1, -1, -1, 75, 76,
4243  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4244  -1, -1, -1, 90, 91, -1, -1, -1, -1, -1,
4245  -1, 98, -1, -1, 101, 102, -1, 104, 105, -1,
4246  -1, -1, -1, 110, 111, 112, 113, 114, 115, 116,
4247  117, 118, -1, -1, -1, -1, -1, -1, -1, -1,
4248  -1, -1, 3, 4, 5, 6, 7, -1, -1, -1,
4249  11, 12, 139, 140, 141, 16, -1, 18, 19, 20,
4250  21, 22, 23, 24, -1, -1, 153, -1, -1, 30,
4251  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4252  -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
4253  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4254  61, 62, 63, 64, 65, -1, -1, -1, -1, -1,
4255  -1, -1, -1, -1, 75, 76, -1, -1, -1, -1,
4256  -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
4257  91, -1, -1, -1, -1, -1, -1, 98, -1, -1,
4258  101, 102, -1, 104, 105, -1, 107, -1, -1, 110,
4259  111, 112, 113, 114, 115, 116, 117, 118, -1, -1,
4260  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
4261  5, 6, 7, -1, -1, -1, 11, 12, 139, 140,
4262  141, 16, -1, 18, 19, 20, 21, 22, 23, 24,
4263  151, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4264  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4265  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
4266  55, 56, 57, -1, 59, 60, 61, 62, 63, 64,
4267  65, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4268  75, 76, -1, -1, -1, -1, -1, -1, -1, -1,
4269  -1, -1, -1, -1, -1, 90, 91, -1, -1, -1,
4270  -1, -1, -1, 98, -1, -1, 101, 102, -1, 104,
4271  105, -1, 107, -1, -1, 110, 111, 112, 113, 114,
4272  115, 116, 117, 118, -1, -1, -1, -1, -1, -1,
4273  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4274  -1, -1, -1, -1, 139, 140, 141, -1, -1, -1,
4275  -1, -1, -1, -1, -1, -1, 151, 3, 4, 5,
4276  6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
4277  16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
4278  26, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4279  36, 37, 38, 39, -1, -1, -1, -1, -1, 45,
4280  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
4281  56, 57, -1, -1, -1, -1, -1, -1, -1, -1,
4282  -1, -1, -1, -1, -1, -1, -1, -1, -1, 75,
4283  76, 77, 78, 79, 80, 81, 82, 83, -1, -1,
4284  86, 87, -1, -1, -1, -1, 92, 93, 94, 95,
4285  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4286  -1, 107, 108, -1, -1, -1, -1, -1, -1, -1,
4287  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4288  -1, -1, -1, 129, 130, 131, 132, 133, 134, 135,
4289  136, 137, 138, -1, 140, 141, -1, -1, -1, -1,
4290  -1, 147, 148, 3, 4, 5, 6, 7, 8, 9,
4291  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
4292  20, 21, 22, 23, 24, 25, 26, -1, -1, -1,
4293  30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
4294  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
4295  50, 51, 52, 53, 54, 55, 56, 57, -1, -1,
4296  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4297  -1, -1, -1, -1, -1, 75, 76, 77, 78, 79,
4298  80, 81, 82, 83, -1, -1, 86, 87, -1, -1,
4299  -1, -1, 92, 93, 94, 95, -1, -1, -1, -1,
4300  -1, -1, -1, -1, -1, -1, -1, 107, 108, -1,
4301  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4302  -1, -1, -1, -1, -1, -1, -1, -1, -1, 129,
4303  130, 131, 132, 133, 134, 135, 136, 137, 138, -1,
4304  140, 141, -1, -1, -1, -1, -1, 147, 3, 4,
4305  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
4306  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
4307  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
4308  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
4309  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
4310  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
4311  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4312  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4313  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4314  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4315  -1, -1, 107, 108, -1, -1, 111, -1, -1, -1,
4316  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4317  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4318  135, 136, 137, 138, -1, 140, 141, -1, -1, -1,
4319  -1, -1, 147, 3, 4, 5, 6, 7, 8, 9,
4320  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
4321  20, 21, 22, 23, 24, 25, 26, -1, -1, -1,
4322  30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
4323  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
4324  50, 51, 52, 53, -1, -1, 56, -1, -1, -1,
4325  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4326  -1, -1, -1, -1, -1, 75, 76, 77, 78, 79,
4327  80, 81, 82, 83, -1, -1, 86, 87, -1, -1,
4328  -1, -1, 92, 93, 94, 95, -1, -1, -1, -1,
4329  -1, -1, -1, -1, -1, -1, -1, 107, 108, -1,
4330  -1, 111, -1, -1, -1, -1, -1, -1, -1, -1,
4331  -1, -1, -1, -1, -1, -1, -1, -1, -1, 129,
4332  130, 131, 132, 133, 134, 135, 136, 137, 138, -1,
4333  140, 141, -1, -1, -1, -1, -1, 147, 3, 4,
4334  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
4335  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
4336  25, 26, -1, -1, -1, 30, 31, 32, 33, 34,
4337  35, 36, 37, 38, 39, -1, -1, -1, -1, -1,
4338  45, 46, 47, 48, 49, 50, 51, 52, 53, -1,
4339  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
4340  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4341  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4342  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4343  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4344  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4345  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4346  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4347  135, 136, 137, 138, -1, 140, 141, 3, 4, 5,
4348  -1, 7, 147, -1, -1, 11, 12, -1, -1, -1,
4349  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4350  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4351  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4352  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4353  56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
4354  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4355  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4356  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4357  -1, -1, 98, -1, -1, 101, 102, -1, 104, 105,
4358  -1, -1, -1, -1, 110, 111, 112, 113, 114, 115,
4359  116, 117, 118, -1, -1, -1, -1, -1, -1, -1,
4360  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
4361  7, -1, -1, 139, 11, 12, -1, -1, -1, 16,
4362  146, 18, 19, 20, 21, 22, 23, 24, -1, -1,
4363  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4364  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
4365  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
4366  57, -1, 59, 60, 61, 62, 63, 64, 65, -1,
4367  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4368  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4369  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4370  -1, 98, -1, -1, 101, 102, -1, 104, 105, -1,
4371  -1, -1, -1, 110, 111, 112, 113, 114, 115, 116,
4372  117, 118, -1, -1, -1, -1, -1, -1, -1, -1,
4373  -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
4374  -1, -1, 139, 11, 12, -1, -1, -1, 16, 146,
4375  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4376  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4377  -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
4378  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4379  -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
4380  -1, -1, -1, -1, -1, -1, -1, 75, 76, -1,
4381  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4382  -1, -1, 90, 91, -1, -1, -1, -1, -1, -1,
4383  98, -1, -1, 101, 102, -1, 104, 105, -1, 107,
4384  -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
4385  118, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4386  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4387  12, 139, 140, 141, 16, -1, 18, 19, 20, 21,
4388  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4389  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4390  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4391  52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
4392  62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
4393  -1, -1, -1, 75, 76, -1, -1, -1, -1, -1,
4394  -1, -1, -1, -1, -1, -1, -1, -1, 90, 91,
4395  -1, -1, -1, -1, -1, -1, 98, -1, -1, 101,
4396  102, -1, 104, 105, -1, 107, 108, 109, 110, 111,
4397  112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
4398  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4399  6, 7, -1, -1, -1, 11, 12, 139, 140, 141,
4400  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4401  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4402  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
4403  46, -1, 48, 49, 50, 51, 52, 53, 54, 55,
4404  56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
4405  -1, -1, -1, -1, -1, -1, -1, -1, -1, 75,
4406  76, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4407  -1, -1, -1, -1, 90, 91, -1, -1, -1, -1,
4408  -1, -1, 98, -1, -1, 101, 102, -1, 104, 105,
4409  -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
4410  116, 117, 118, -1, -1, -1, -1, -1, -1, -1,
4411  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4412  -1, 11, 12, 139, 140, 141, 16, -1, 18, 19,
4413  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4414  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4415  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4416  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
4417  60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
4418  -1, -1, -1, -1, -1, 75, 76, -1, -1, -1,
4419  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4420  90, 91, -1, -1, -1, -1, -1, -1, 98, -1,
4421  -1, 101, 102, -1, 104, 105, -1, 107, 108, 109,
4422  110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
4423  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4424  4, 5, -1, 7, -1, -1, -1, 11, 12, 139,
4425  140, 141, 16, -1, 18, 19, 20, 21, 22, 23,
4426  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4427  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4428  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4429  54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
4430  64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
4431  -1, 75, 76, -1, -1, -1, -1, -1, -1, -1,
4432  -1, -1, -1, -1, -1, -1, 90, 91, -1, -1,
4433  -1, -1, -1, -1, 98, -1, -1, 101, 102, -1,
4434  104, 105, -1, 107, 108, 109, 110, 111, 112, 113,
4435  114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
4436  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4437  -1, -1, -1, 11, 12, 139, 140, 141, 16, -1,
4438  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4439  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4440  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4441  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4442  58, 59, 60, 61, 62, 63, 64, 65, -1, -1,
4443  -1, -1, -1, -1, -1, -1, -1, 75, 76, -1,
4444  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4445  -1, -1, 90, 91, -1, -1, -1, -1, -1, -1,
4446  98, -1, -1, 101, 102, -1, 104, 105, -1, 107,
4447  108, -1, 110, 111, 112, 113, 114, 115, 116, 117,
4448  118, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4449  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4450  12, 139, 140, 141, 16, -1, 18, 19, 20, 21,
4451  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4452  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4453  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4454  52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
4455  62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
4456  -1, -1, -1, 75, 76, -1, -1, -1, -1, -1,
4457  -1, -1, -1, -1, -1, -1, -1, -1, 90, 91,
4458  -1, -1, -1, -1, -1, -1, 98, -1, -1, 101,
4459  102, -1, 104, 105, -1, -1, 108, 109, 110, 111,
4460  112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
4461  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4462  -1, 7, -1, -1, -1, 11, 12, 139, 140, 141,
4463  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4464  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4465  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4466  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4467  56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
4468  -1, -1, -1, -1, -1, -1, -1, -1, -1, 75,
4469  76, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4470  -1, -1, -1, -1, 90, 91, -1, -1, -1, -1,
4471  -1, -1, 98, -1, -1, 101, 102, -1, 104, 105,
4472  -1, 107, 108, -1, 110, 111, 112, 113, 114, 115,
4473  116, 117, 118, -1, -1, -1, -1, -1, -1, -1,
4474  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4475  -1, 11, 12, 139, 140, 141, 16, -1, 18, 19,
4476  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4477  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4478  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4479  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
4480  60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
4481  -1, -1, -1, -1, -1, 75, 76, -1, -1, -1,
4482  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4483  90, 91, -1, -1, -1, -1, -1, -1, 98, -1,
4484  -1, 101, 102, -1, 104, 105, -1, -1, 108, -1,
4485  110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
4486  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4487  4, 5, -1, 7, -1, -1, -1, 11, 12, 139,
4488  140, 141, 16, -1, 18, 19, 20, 21, 22, 23,
4489  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4490  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4491  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4492  54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
4493  64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
4494  -1, 75, 76, -1, -1, -1, -1, -1, -1, -1,
4495  -1, -1, -1, -1, -1, -1, 90, 91, -1, -1,
4496  -1, -1, -1, -1, 98, -1, -1, 101, 102, -1,
4497  104, 105, -1, 107, -1, -1, 110, 111, 112, 113,
4498  114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
4499  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4500  -1, -1, -1, 11, 12, 139, 140, 141, 16, -1,
4501  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4502  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4503  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4504  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4505  -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
4506  -1, -1, -1, -1, -1, -1, -1, 75, 76, -1,
4507  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4508  -1, -1, 90, 91, -1, -1, -1, -1, -1, -1,
4509  98, -1, -1, 101, 102, -1, 104, 105, -1, 107,
4510  -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
4511  118, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4512  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4513  12, 139, 140, 141, 16, -1, 18, 19, 20, 21,
4514  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4515  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4516  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4517  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4518  62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
4519  -1, -1, -1, 75, 76, -1, -1, -1, -1, -1,
4520  -1, -1, -1, -1, -1, -1, -1, -1, 90, 91,
4521  -1, -1, -1, -1, -1, -1, 98, -1, -1, 101,
4522  102, -1, 104, 105, -1, 107, -1, -1, 110, 111,
4523  112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
4524  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4525  -1, 7, -1, -1, -1, 11, 12, 139, 140, 141,
4526  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4527  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4528  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4529  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4530  56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
4531  -1, -1, -1, -1, -1, -1, -1, -1, -1, 75,
4532  76, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4533  -1, -1, -1, -1, 90, 91, -1, -1, -1, -1,
4534  -1, -1, 98, -1, -1, 101, 102, -1, 104, 105,
4535  -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
4536  116, 117, 118, -1, -1, -1, -1, -1, -1, -1,
4537  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4538  -1, 11, 12, 139, 140, 141, 16, -1, 18, 19,
4539  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4540  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4541  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4542  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4543  60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
4544  -1, -1, -1, -1, -1, 75, 76, -1, -1, -1,
4545  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4546  90, 91, -1, -1, -1, -1, -1, -1, 98, -1,
4547  -1, 101, 102, -1, 104, 105, -1, 107, -1, -1,
4548  110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
4549  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4550  4, 5, -1, 7, -1, -1, -1, 11, 12, 139,
4551  140, 141, 16, -1, 18, 19, 20, 21, 22, 23,
4552  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4553  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4554  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4555  54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
4556  64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
4557  -1, 75, 76, -1, -1, -1, -1, -1, -1, -1,
4558  -1, -1, -1, -1, -1, -1, 90, 91, -1, -1,
4559  -1, -1, -1, -1, 98, -1, -1, 101, 102, -1,
4560  104, 105, -1, -1, -1, -1, 110, 111, 112, 113,
4561  114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
4562  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4563  -1, -1, -1, 11, 12, 139, 140, 141, 16, -1,
4564  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4565  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4566  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4567  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4568  -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
4569  -1, -1, -1, -1, -1, -1, -1, 75, 76, -1,
4570  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4571  -1, -1, 90, 91, -1, -1, -1, -1, -1, -1,
4572  98, -1, -1, 101, 102, -1, 104, 105, -1, -1,
4573  -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
4574  118, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4575  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4576  12, 139, 140, 141, 16, -1, 18, 19, 20, 21,
4577  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4578  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4579  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4580  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4581  62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
4582  -1, -1, -1, 75, 76, -1, -1, -1, -1, -1,
4583  -1, -1, -1, -1, -1, -1, -1, -1, 90, 91,
4584  -1, -1, -1, -1, -1, -1, 98, -1, -1, 101,
4585  102, -1, 104, 105, -1, -1, -1, -1, 110, 111,
4586  112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
4587  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4588  -1, 7, -1, -1, -1, 11, 12, 139, 140, 141,
4589  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4590  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4591  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4592  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4593  56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
4594  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4595  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4596  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4597  -1, -1, 98, -1, -1, 101, 102, -1, 104, 105,
4598  -1, 107, -1, -1, 110, 111, 112, 113, 114, 115,
4599  116, 117, 118, -1, -1, -1, -1, -1, -1, 3,
4600  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
4601  -1, -1, 16, 139, 18, 19, 20, 21, 22, 23,
4602  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4603  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4604  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4605  54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
4606  64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
4607  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4608  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4609  -1, -1, -1, -1, 98, -1, -1, 101, 102, -1,
4610  104, 105, -1, 107, -1, -1, 110, 111, 112, 113,
4611  114, 115, 116, 117, 118, -1, -1, -1, -1, -1,
4612  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4613  12, -1, -1, -1, 16, 139, 18, 19, 20, 21,
4614  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4615  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4616  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4617  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4618  62, 63, 64, 65, -1, -1, -1, -1, -1, -1,
4619  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4620  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4621  -1, -1, 94, -1, -1, -1, 98, -1, -1, 101,
4622  102, -1, 104, 105, -1, -1, -1, -1, 110, 111,
4623  112, 113, 114, 115, 116, 117, 118, -1, -1, -1,
4624  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4625  -1, 11, 12, -1, -1, -1, 16, 139, 18, 19,
4626  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4627  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4628  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4629  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4630  60, 61, 62, 63, 64, 65, -1, -1, -1, -1,
4631  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4632  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4633  -1, -1, -1, -1, -1, -1, -1, -1, 98, -1,
4634  -1, 101, 102, -1, 104, 105, -1, -1, -1, -1,
4635  110, 111, 112, 113, 114, 115, 116, 117, 118, -1,
4636  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4637  -1, -1, -1, 11, 12, -1, -1, -1, 16, 139,
4638  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4639  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4640  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4641  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4642  -1, 59, 60, 61, 62, 63, 64, 65, -1, -1,
4643  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4644  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4645  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4646  98, -1, -1, 101, 102, -1, 104, 105, -1, -1,
4647  -1, -1, 110, 111, 112, 113, 114, 115, 116, 117,
4648  118, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4649  -1, 7, -1, -1, -1, 11, 12, -1, -1, -1,
4650  16, 139, 18, 19, 20, 21, 22, 23, 24, -1,
4651  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4652  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4653  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4654  56, 57, -1, 59, 60, 61, 62, 63, 64, 65,
4655  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4656  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4657  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4658  -1, -1, 98, -1, -1, 101, 102, -1, 104, 105,
4659  -1, -1, -1, -1, 110, 111, 112, 113, 114, 115,
4660  116, 117, 118, -1, -1, -1, -1, -1, -1, 3,
4661  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
4662  -1, -1, 16, 139, 18, 19, 20, 21, 22, 23,
4663  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4664  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4665  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4666  54, 55, 56, 57, -1, 59, 60, 61, 62, 63,
4667  64, 65, -1, -1, -1, -1, -1, -1, -1, -1,
4668  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4669  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4670  -1, -1, -1, -1, 98, -1, -1, 101, 102, -1,
4671  104, 105, 33, 34, 35, 36, 110, 111, 112, 113,
4672  114, 115, 116, 117, 118, -1, -1, -1, 49, 50,
4673  51, 52, -1, -1, -1, 56, -1, 58, 59, 60,
4674  61, 62, 63, -1, -1, 139, -1, -1, -1, -1,
4675  -1, -1, -1, -1, -1, -1, 77, -1, -1, -1,
4676  -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
4677  91, -1, -1, -1, -1, -1, -1, 98, -1, -1,
4678  101, -1, -1, 104, 105, -1, 107, 108, -1, 110,
4679  111, 112, 113, 114, 115, 116, 117, 118, 33, 34,
4680  35, 36, -1, -1, -1, -1, -1, -1, -1, -1,
4681  -1, 132, -1, -1, 49, 50, 51, 52, 139, -1,
4682  -1, 56, -1, -1, 59, 60, 61, 62, 63, -1,
4683  -1, 33, 34, 35, 36, -1, -1, -1, -1, -1,
4684  -1, -1, -1, -1, -1, -1, -1, 49, 50, 51,
4685  52, -1, -1, -1, 56, 90, 91, 59, 60, 61,
4686  62, 63, -1, 98, -1, -1, 101, -1, -1, 104,
4687  105, -1, 107, -1, -1, 110, 111, 112, 113, 114,
4688  115, 116, 117, 118, -1, -1, -1, -1, 90, 91,
4689  -1, -1, -1, -1, -1, -1, 98, 132, -1, 101,
4690  -1, -1, 104, 105, 139, -1, -1, -1, 110, 111,
4691  112, 113, 114, 115, 116, 117, 118, 52, 53, -1,
4692  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1,
4693  132, -1, -1, -1, -1, -1, -1, 139, -1, -1,
4694  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4695  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4696  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4697  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4698  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4699  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4700  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4701  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4702  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4703  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4704  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4705  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4706  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4707  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4708  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4709  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4710  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4711  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4712  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4713  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4714  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4715  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4716  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4717  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4718  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4719  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4720  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4721  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4722  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4723  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4724  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4725  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4726  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4727  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4728  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4729  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4730  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4731  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4732  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4733  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4734  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4735  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4736  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4737  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4738  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4739  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4740  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4741  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4742  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4743  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4744  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4745  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4746  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4747  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4748  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4749  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4750  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4751  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4752  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4753  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4754  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4755  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4756  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4757  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4758  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4759  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4760  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4761  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4762  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4763  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4764  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4765  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4766  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4767  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4768  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4769  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4770  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4771  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4772  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4773  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4774  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4775  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4776  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4777  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4778  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4779  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4780  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4781  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4782  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4783  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4784  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4785  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4786  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4787  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4788  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4789  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4790  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4791  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4792  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4793  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4794  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4795  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4796  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4797  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4798  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4799  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4800  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4801  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4802  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4803  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4804  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4805  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4806  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4807  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4808  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4809  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4810  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4811  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4812  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4813  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4814  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4815  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4816  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4817  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4818  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4819  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4820  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4821  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4822  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4823  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4824  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4825  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4826  135, 136, 137, 138, -1, 140, 141, 52, 53, -1,
4827  -1, 56, 147, 148, -1, -1, -1, -1, -1, -1,
4828  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4829  75, 76, 77, 78, 79, 80, 81, 82, 83, -1,
4830  -1, 86, 87, -1, -1, -1, -1, 92, 93, 94,
4831  95, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4832  -1, -1, 107, 108, -1, -1, -1, -1, -1, -1,
4833  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4834  -1, -1, -1, -1, 129, 130, 131, 132, 133, 134,
4835  135, 136, 137, 138, -1, 140, 141, -1, -1, -1,
4836  -1, -1, 147
4837 };
4838 
4839  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4840  symbol of state STATE-NUM. */
4841 static const yytype_uint16 yystos[] =
4842 {
4843  0, 155, 156, 0, 1, 3, 4, 5, 6, 7,
4844  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4845  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4846  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4847  57, 59, 60, 61, 62, 63, 64, 65, 75, 76,
4848  90, 91, 98, 101, 102, 104, 105, 107, 110, 111,
4849  112, 113, 114, 115, 116, 117, 118, 139, 140, 141,
4850  157, 158, 159, 167, 169, 171, 179, 180, 182, 183,
4851  184, 186, 187, 188, 190, 191, 200, 203, 218, 233,
4852  234, 235, 236, 237, 238, 239, 240, 241, 242, 243,
4853  252, 279, 280, 333, 334, 335, 336, 337, 338, 339,
4854  342, 344, 345, 359, 360, 362, 363, 364, 365, 366,
4855  367, 368, 369, 405, 418, 159, 3, 4, 5, 6,
4856  7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
4857  17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
4858  30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
4859  45, 46, 47, 48, 49, 50, 51, 52, 53, 56,
4860  75, 76, 77, 78, 79, 80, 81, 82, 83, 86,
4861  87, 92, 93, 94, 95, 107, 108, 129, 130, 131,
4862  132, 133, 134, 135, 136, 137, 138, 140, 141, 147,
4863  194, 195, 196, 198, 199, 359, 39, 58, 98, 101,
4864  107, 108, 109, 112, 140, 183, 191, 200, 204, 210,
4865  213, 215, 233, 365, 366, 368, 369, 403, 404, 210,
4866  148, 211, 212, 148, 207, 211, 148, 153, 412, 54,
4867  195, 412, 143, 160, 143, 21, 22, 31, 32, 182,
4868  200, 233, 252, 200, 200, 200, 56, 1, 47, 101,
4869  163, 164, 165, 167, 185, 186, 418, 167, 220, 205,
4870  215, 403, 418, 204, 402, 403, 418, 46, 98, 139,
4871  146, 190, 218, 233, 365, 366, 369, 223, 54, 55,
4872  57, 194, 348, 361, 348, 349, 350, 152, 152, 152,
4873  152, 364, 179, 200, 200, 151, 153, 411, 416, 417,
4874  40, 41, 42, 43, 44, 37, 38, 26, 143, 207,
4875  211, 244, 281, 28, 245, 278, 126, 146, 101, 107,
4876  187, 126, 25, 77, 78, 79, 80, 81, 82, 83,
4877  84, 85, 86, 87, 88, 89, 94, 95, 127, 129,
4878  130, 131, 132, 133, 134, 135, 136, 137, 138, 202,
4879  202, 68, 96, 97, 145, 409, 219, 171, 175, 175,
4880  176, 177, 176, 175, 411, 417, 98, 184, 191, 233,
4881  257, 365, 366, 369, 52, 56, 94, 98, 192, 193,
4882  233, 365, 366, 369, 193, 33, 34, 35, 36, 49,
4883  50, 51, 52, 56, 148, 194, 367, 400, 210, 97,
4884  409, 410, 281, 336, 99, 99, 146, 204, 56, 204,
4885  204, 204, 348, 126, 100, 146, 214, 418, 97, 145,
4886  409, 99, 99, 146, 214, 210, 412, 413, 210, 91,
4887  209, 210, 215, 377, 403, 418, 171, 413, 171, 54,
4888  64, 65, 168, 148, 201, 157, 163, 97, 409, 99,
4889  167, 166, 185, 149, 411, 417, 413, 221, 413, 150,
4890  146, 153, 415, 146, 415, 144, 415, 412, 56, 364,
4891  187, 189, 146, 97, 145, 409, 270, 271, 66, 119,
4892  121, 122, 351, 119, 119, 351, 67, 351, 340, 346,
4893  343, 347, 77, 151, 159, 175, 175, 175, 175, 167,
4894  171, 171, 282, 283, 106, 181, 286, 287, 286, 107,
4895  179, 204, 215, 216, 217, 185, 146, 190, 146, 169,
4896  170, 179, 191, 200, 204, 206, 217, 233, 369, 172,
4897  200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
4898  200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
4899  200, 200, 200, 200, 52, 53, 56, 198, 207, 406,
4900  407, 209, 52, 53, 56, 198, 207, 406, 161, 163,
4901  13, 253, 416, 253, 163, 175, 163, 411, 225, 56,
4902  97, 145, 409, 25, 171, 52, 56, 192, 130, 370,
4903  97, 145, 409, 228, 401, 229, 68, 97, 408, 52,
4904  56, 406, 170, 200, 206, 170, 206, 197, 124, 204,
4905  107, 204, 213, 403, 52, 56, 209, 52, 56, 404,
4906  413, 149, 413, 146, 413, 146, 413, 195, 222, 200,
4907  144, 144, 406, 406, 206, 160, 413, 165, 413, 403,
4908  146, 189, 52, 56, 209, 52, 56, 272, 353, 352,
4909  119, 341, 351, 66, 119, 119, 341, 66, 119, 200,
4910  144, 284, 282, 10, 251, 288, 251, 204, 146, 44,
4911  413, 189, 146, 44, 126, 44, 97, 145, 409, 173,
4912  412, 99, 99, 207, 211, 412, 414, 99, 99, 207,
4913  208, 211, 418, 251, 8, 246, 329, 418, 163, 13,
4914  163, 251, 27, 254, 416, 251, 25, 224, 293, 17,
4915  248, 291, 52, 56, 209, 52, 56, 176, 227, 371,
4916  226, 52, 56, 192, 209, 161, 171, 230, 231, 208,
4917  211, 195, 204, 204, 214, 99, 99, 414, 99, 99,
4918  403, 171, 415, 187, 414, 273, 354, 54, 55, 57,
4919  358, 369, 152, 351, 152, 152, 152, 285, 144, 289,
4920  107, 204, 167, 189, 167, 200, 52, 56, 209, 52,
4921  56, 52, 56, 90, 91, 98, 101, 104, 105, 110,
4922  132, 303, 304, 305, 308, 323, 324, 326, 327, 328,
4923  333, 334, 337, 338, 339, 342, 344, 345, 366, 128,
4924  170, 206, 170, 206, 181, 150, 99, 170, 206, 170,
4925  206, 181, 204, 217, 330, 418, 9, 15, 247, 249,
4926  332, 418, 14, 249, 250, 255, 256, 418, 256, 178,
4927  294, 291, 251, 107, 204, 290, 251, 414, 163, 416,
4928  175, 161, 414, 251, 413, 148, 372, 373, 194, 281,
4929  278, 99, 146, 413, 274, 355, 131, 265, 266, 418,
4930  265, 204, 414, 324, 324, 56, 192, 311, 309, 414,
4931  144, 310, 325, 52, 100, 174, 131, 88, 89, 97,
4932  145, 148, 306, 307, 200, 170, 206, 100, 331, 418,
4933  163, 162, 163, 175, 251, 251, 295, 251, 204, 146,
4934  253, 251, 161, 416, 251, 52, 54, 55, 56, 57,
4935  58, 77, 91, 101, 107, 108, 109, 133, 136, 374,
4936  376, 377, 378, 379, 380, 381, 382, 383, 384, 387,
4937  388, 389, 390, 391, 394, 395, 396, 397, 398, 161,
4938  376, 232, 148, 276, 376, 356, 262, 264, 267, 380,
4939  382, 383, 385, 386, 389, 390, 392, 393, 396, 398,
4940  412, 163, 161, 303, 107, 303, 312, 313, 314, 316,
4941  58, 112, 317, 318, 319, 320, 321, 322, 388, 270,
4942  326, 308, 324, 324, 192, 414, 413, 112, 312, 317,
4943  312, 317, 98, 191, 233, 365, 366, 369, 253, 163,
4944  253, 296, 107, 204, 163, 251, 101, 107, 258, 259,
4945  260, 261, 379, 413, 413, 126, 146, 375, 204, 146,
4946  399, 418, 34, 52, 146, 399, 399, 146, 375, 52,
4947  146, 375, 52, 251, 416, 372, 376, 275, 357, 267,
4948  131, 126, 146, 263, 98, 233, 146, 399, 399, 399,
4949  146, 263, 146, 263, 151, 413, 52, 146, 414, 107,
4950  303, 316, 146, 348, 144, 146, 303, 34, 52, 348,
4951  413, 413, 414, 414, 56, 97, 145, 409, 163, 332,
4952  163, 301, 302, 303, 314, 317, 204, 256, 291, 292,
4953  260, 379, 146, 413, 146, 204, 374, 381, 394, 396,
4954  384, 388, 390, 398, 382, 391, 396, 380, 382, 161,
4955  267, 29, 123, 277, 163, 131, 233, 262, 393, 396,
4956  56, 97, 385, 390, 382, 392, 396, 382, 52, 268,
4957  269, 378, 146, 315, 316, 52, 146, 146, 124, 319,
4958  321, 322, 52, 56, 209, 52, 56, 329, 255, 253,
4959  40, 41, 146, 413, 258, 261, 259, 146, 375, 146,
4960  375, 399, 146, 375, 146, 375, 375, 251, 149, 161,
4961  163, 120, 146, 263, 146, 263, 52, 56, 399, 146,
4962  263, 146, 263, 263, 146, 412, 315, 146, 146, 315,
4963  414, 297, 175, 175, 312, 146, 146, 382, 396, 382,
4964  382, 251, 144, 382, 396, 382, 382, 269, 316, 315,
4965  298, 259, 375, 146, 375, 375, 375, 263, 146, 263,
4966  263, 263, 299, 382, 382, 163, 375, 263, 256, 293,
4967  300
4968 };
4969 
4970  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
4971 static const yytype_uint16 yyr1[] =
4972 {
4973  0, 154, 156, 155, 157, 158, 158, 158, 158, 159,
4974  159, 160, 162, 161, 161, 163, 164, 164, 164, 164,
4975  165, 166, 165, 168, 167, 167, 167, 167, 167, 167,
4976  167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
4977  167, 169, 169, 169, 169, 169, 169, 169, 169, 170,
4978  170, 170, 171, 171, 171, 171, 171, 172, 173, 174,
4979  171, 171, 175, 177, 178, 176, 179, 179, 180, 180,
4980  181, 182, 183, 183, 183, 183, 183, 183, 183, 183,
4981  183, 183, 183, 184, 184, 185, 185, 186, 186, 186,
4982  186, 186, 186, 186, 186, 186, 186, 187, 187, 188,
4983  188, 189, 189, 190, 190, 190, 190, 190, 190, 190,
4984  190, 190, 191, 191, 191, 191, 191, 191, 191, 191,
4985  191, 192, 192, 193, 193, 193, 194, 194, 194, 194,
4986  194, 195, 195, 196, 197, 196, 198, 198, 198, 198,
4987  198, 198, 198, 198, 198, 198, 198, 198, 198, 198,
4988  198, 198, 198, 198, 198, 198, 198, 198, 198, 198,
4989  198, 198, 198, 198, 198, 198, 199, 199, 199, 199,
4990  199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
4991  199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
4992  199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
4993  199, 199, 199, 199, 199, 199, 199, 200, 200, 200,
4994  200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
4995  200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
4996  200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
4997  200, 200, 200, 200, 200, 200, 200, 201, 200, 200,
4998  200, 202, 202, 202, 202, 203, 203, 204, 205, 205,
4999  205, 205, 206, 206, 207, 207, 208, 208, 209, 209,
5000  209, 209, 209, 210, 210, 210, 210, 210, 212, 211,
5001  213, 214, 214, 215, 215, 215, 215, 216, 216, 217,
5002  217, 217, 218, 218, 218, 218, 218, 218, 218, 218,
5003  218, 218, 218, 219, 218, 220, 218, 221, 218, 218,
5004  218, 218, 218, 218, 218, 218, 218, 218, 222, 218,
5005  218, 218, 218, 218, 218, 223, 218, 218, 218, 218,
5006  218, 224, 218, 225, 218, 218, 218, 226, 218, 227,
5007  218, 228, 218, 229, 230, 218, 231, 232, 218, 218,
5008  218, 218, 218, 233, 234, 235, 236, 237, 238, 239,
5009  240, 241, 242, 243, 244, 245, 246, 247, 248, 249,
5010  250, 251, 252, 253, 253, 253, 254, 254, 255, 255,
5011  256, 256, 257, 257, 258, 258, 259, 259, 260, 260,
5012  260, 260, 260, 261, 261, 262, 262, 262, 262, 262,
5013  263, 263, 264, 264, 264, 264, 264, 264, 264, 264,
5014  264, 264, 264, 264, 264, 264, 264, 265, 265, 266,
5015  266, 267, 267, 268, 268, 269, 269, 271, 272, 273,
5016  274, 275, 270, 276, 276, 277, 277, 278, 279, 279,
5017  279, 279, 280, 280, 280, 280, 280, 280, 280, 280,
5018  280, 281, 281, 283, 284, 285, 282, 287, 288, 289,
5019  286, 290, 290, 290, 290, 291, 292, 292, 294, 295,
5020  296, 297, 298, 299, 293, 300, 300, 301, 301, 301,
5021  302, 302, 302, 302, 302, 303, 304, 304, 305, 305,
5022  306, 307, 308, 308, 308, 308, 308, 308, 308, 309,
5023  308, 308, 310, 308, 308, 311, 308, 312, 312, 312,
5024  312, 312, 312, 312, 312, 313, 313, 314, 314, 314,
5025  314, 315, 315, 316, 317, 317, 317, 317, 317, 318,
5026  318, 319, 319, 320, 320, 321, 321, 322, 323, 323,
5027  323, 323, 323, 323, 323, 323, 323, 323, 324, 324,
5028  324, 324, 324, 324, 324, 324, 324, 325, 324, 326,
5029  327, 328, 328, 328, 329, 329, 330, 330, 330, 331,
5030  331, 332, 332, 333, 333, 334, 335, 335, 335, 336,
5031  337, 338, 339, 340, 340, 341, 341, 342, 343, 343,
5032  344, 345, 346, 346, 347, 347, 348, 348, 349, 349,
5033  350, 350, 351, 352, 351, 353, 354, 355, 356, 357,
5034  351, 358, 358, 358, 358, 359, 359, 360, 361, 361,
5035  361, 361, 362, 363, 363, 364, 364, 364, 364, 365,
5036  365, 365, 365, 365, 366, 366, 366, 366, 366, 366,
5037  366, 367, 367, 368, 368, 369, 369, 371, 370, 370,
5038  372, 372, 373, 372, 374, 374, 374, 374, 374, 375,
5039  375, 376, 376, 376, 376, 376, 376, 376, 376, 376,
5040  376, 376, 376, 376, 376, 376, 377, 378, 378, 378,
5041  378, 379, 379, 380, 381, 381, 382, 382, 383, 384,
5042  384, 385, 385, 386, 386, 387, 387, 388, 388, 389,
5043  390, 390, 391, 392, 393, 393, 394, 394, 395, 395,
5044  396, 396, 397, 397, 398, 399, 399, 400, 401, 400,
5045  402, 402, 403, 403, 404, 404, 404, 404, 405, 405,
5046  405, 406, 406, 406, 406, 407, 407, 407, 408, 408,
5047  409, 409, 410, 410, 411, 411, 412, 412, 413, 414,
5048  415, 415, 415, 416, 416, 417, 417, 418
5049 };
5050 
5051  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
5052 static const yytype_uint8 yyr2[] =
5053 {
5054  0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
5055  2, 3, 0, 6, 3, 2, 1, 1, 3, 2,
5056  1, 0, 3, 0, 4, 3, 3, 3, 2, 3,
5057  3, 3, 3, 3, 4, 1, 3, 3, 5, 3,
5058  1, 3, 3, 6, 5, 5, 5, 5, 3, 1,
5059  3, 1, 1, 3, 3, 3, 2, 0, 0, 0,
5060  6, 1, 1, 0, 0, 4, 1, 1, 1, 4,
5061  3, 1, 2, 3, 4, 5, 4, 5, 2, 2,
5062  2, 2, 2, 1, 3, 1, 3, 1, 2, 3,
5063  5, 2, 4, 2, 4, 1, 3, 1, 3, 2,
5064  3, 1, 3, 1, 1, 4, 3, 3, 3, 3,
5065  2, 1, 1, 1, 4, 3, 3, 3, 3, 2,
5066  1, 1, 1, 2, 1, 3, 1, 1, 1, 1,
5067  1, 1, 1, 1, 0, 4, 1, 1, 1, 1,
5068  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5069  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5070  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5071  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5072  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5073  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5074  1, 1, 1, 1, 1, 1, 1, 3, 3, 6,
5075  5, 5, 5, 5, 4, 3, 3, 3, 2, 2,
5076  2, 2, 3, 3, 3, 3, 3, 3, 4, 2,
5077  2, 3, 3, 3, 3, 1, 3, 3, 3, 3,
5078  3, 2, 2, 3, 3, 3, 3, 0, 4, 6,
5079  1, 1, 1, 1, 1, 3, 3, 1, 1, 2,
5080  4, 2, 1, 3, 3, 3, 1, 1, 1, 1,
5081  2, 4, 2, 1, 2, 2, 4, 1, 0, 2,
5082  2, 2, 1, 1, 2, 3, 4, 1, 1, 3,
5083  4, 2, 1, 1, 1, 1, 1, 1, 1, 1,
5084  1, 1, 1, 0, 4, 0, 3, 0, 4, 3,
5085  3, 2, 3, 3, 1, 4, 3, 1, 0, 6,
5086  4, 3, 2, 1, 2, 0, 3, 6, 6, 4,
5087  4, 0, 6, 0, 5, 5, 6, 0, 6, 0,
5088  7, 0, 5, 0, 0, 7, 0, 0, 9, 1,
5089  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5090  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5091  1, 1, 1, 1, 1, 2, 1, 1, 1, 5,
5092  1, 2, 1, 1, 1, 3, 1, 3, 1, 3,
5093  5, 1, 3, 2, 1, 4, 2, 2, 2, 1,
5094  2, 0, 6, 8, 4, 6, 4, 2, 6, 2,
5095  4, 6, 2, 4, 2, 4, 1, 1, 1, 3,
5096  4, 1, 4, 1, 3, 1, 1, 0, 0, 0,
5097  0, 0, 7, 4, 1, 3, 3, 3, 2, 4,
5098  5, 5, 2, 4, 4, 3, 3, 3, 2, 1,
5099  4, 3, 3, 0, 0, 0, 5, 0, 0, 0,
5100  5, 1, 2, 3, 4, 5, 1, 1, 0, 0,
5101  0, 0, 0, 0, 11, 1, 1, 1, 3, 3,
5102  1, 2, 3, 1, 1, 1, 3, 1, 3, 1,
5103  1, 1, 1, 4, 4, 3, 4, 4, 3, 0,
5104  4, 2, 0, 4, 2, 0, 4, 1, 1, 2,
5105  3, 5, 2, 4, 1, 2, 3, 2, 4, 1,
5106  3, 1, 3, 1, 3, 1, 1, 3, 1, 1,
5107  3, 2, 1, 1, 3, 2, 1, 2, 1, 3,
5108  3, 2, 2, 1, 1, 1, 2, 2, 1, 1,
5109  1, 1, 1, 1, 1, 1, 1, 0, 3, 1,
5110  2, 2, 3, 1, 6, 1, 1, 1, 1, 2,
5111  1, 2, 1, 1, 1, 1, 1, 1, 2, 3,
5112  3, 3, 4, 0, 3, 1, 2, 4, 0, 3,
5113  4, 4, 0, 3, 0, 3, 0, 2, 0, 2,
5114  0, 2, 1, 0, 3, 0, 0, 0, 0, 0,
5115  8, 1, 1, 1, 1, 1, 1, 2, 1, 1,
5116  1, 1, 3, 1, 2, 1, 1, 1, 1, 1,
5117  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5118  1, 1, 1, 1, 1, 1, 1, 0, 4, 0,
5119  3, 3, 0, 3, 4, 2, 2, 2, 1, 2,
5120  0, 6, 8, 4, 6, 4, 6, 2, 4, 6,
5121  2, 4, 2, 4, 1, 0, 1, 1, 1, 1,
5122  1, 1, 1, 1, 1, 3, 1, 3, 1, 2,
5123  1, 2, 1, 1, 3, 1, 3, 1, 1, 2,
5124  2, 1, 3, 3, 1, 3, 1, 3, 1, 1,
5125  2, 1, 1, 1, 2, 2, 1, 1, 0, 4,
5126  1, 2, 1, 3, 3, 2, 4, 2, 1, 1,
5127  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5128  1, 1, 1, 1, 0, 1, 0, 1, 2, 2,
5129  0, 1, 1, 1, 1, 1, 2, 0
5130 };
5131 
5132 
5133 #define yyerrok (yyerrstatus = 0)
5134 #define yyclearin (yychar = YYEMPTY)
5135 #define YYEMPTY (-2)
5136 #define YYEOF 0
5137 
5138 #define YYACCEPT goto yyacceptlab
5139 #define YYABORT goto yyabortlab
5140 #define YYERROR goto yyerrorlab
5141 
5142 
5143 #define YYRECOVERING() (!!yyerrstatus)
5144 
5145 #define YYBACKUP(Token, Value) \
5146 do \
5147  if (yychar == YYEMPTY) \
5148  { \
5149  yychar = (Token); \
5150  yylval = (Value); \
5151  YYPOPSTACK (yylen); \
5152  yystate = *yyssp; \
5153  goto yybackup; \
5154  } \
5155  else \
5156  { \
5157  yyerror (&yylloc, p, YY_("syntax error: cannot back up")); \
5158  YYERROR; \
5159  } \
5160 while (0)
5161 
5162 /* Error token number */
5163 #define YYTERROR 1
5164 #define YYERRCODE 256
5165 
5166 
5167 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
5168  If N is 0, then set CURRENT to the empty location which ends
5169  the previous symbol: RHS[0] (always defined). */
5170 
5171 #ifndef YYLLOC_DEFAULT
5172 # define YYLLOC_DEFAULT(Current, Rhs, N) \
5173  do \
5174  if (N) \
5175  { \
5176  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
5177  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
5178  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
5179  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
5180  } \
5181  else \
5182  { \
5183  (Current).first_line = (Current).last_line = \
5184  YYRHSLOC (Rhs, 0).last_line; \
5185  (Current).first_column = (Current).last_column = \
5186  YYRHSLOC (Rhs, 0).last_column; \
5187  } \
5188  while (0)
5189 #endif
5190 
5191 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
5192 
5193 
5194 /* Enable debugging if requested. */
5195 #if YYDEBUG
5196 
5197 # ifndef YYFPRINTF
5198 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
5199 # define YYFPRINTF fprintf
5200 # endif
5201 
5202 # define YYDPRINTF(Args) \
5203 do { \
5204  if (yydebug) \
5205  YYFPRINTF Args; \
5206 } while (0)
5207 
5208 
5209 /* YY_LOCATION_PRINT -- Print the location on the stream.
5210  This macro was not mandated originally: define only if we know
5211  we won't break user code: when these are the locations we know. */
5212 
5213 #ifndef YY_LOCATION_PRINT
5214 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
5215 
5216 /* Print *YYLOCP on YYO. Private, do not rely on its existence. */
5217 
5219 static unsigned
5220 yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
5221 {
5222  unsigned res = 0;
5223  int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
5224  if (0 <= yylocp->first_line)
5225  {
5226  res += YYFPRINTF (p, "%d", yylocp->first_line);
5227  if (0 <= yylocp->first_column)
5228  res += YYFPRINTF (p, ".%d", yylocp->first_column);
5229  }
5230  if (0 <= yylocp->last_line)
5231  {
5232  if (yylocp->first_line < yylocp->last_line)
5233  {
5234  res += YYFPRINTF (p, "-%d", yylocp->last_line);
5235  if (0 <= end_col)
5236  res += YYFPRINTF (p, ".%d", end_col);
5237  }
5238  else if (0 <= end_col && yylocp->first_column < end_col)
5239  res += YYFPRINTF (p, "-%d", end_col);
5240  }
5241  return res;
5242  }
5243 
5244 # define YY_LOCATION_PRINT(File, Loc) \
5245  yy_location_print_ (File, &(Loc))
5246 
5247 # else
5248 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
5249 # endif
5250 #endif
5251 
5252 
5253 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
5254 do { \
5255  if (yydebug) \
5256  { \
5257  YYFPRINTF (p, "%s ", Title); \
5258  yy_symbol_print (stderr, \
5259  Type, Value, Location, p); \
5260  YYFPRINTF (p, "\n"); \
5261  } \
5262 } while (0)
5263 
5264 
5265 /*----------------------------------------.
5266 | Print this symbol's value on YYOUTPUT. |
5267 `----------------------------------------*/
5268 
5269 static void
5270 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parser_params *p)
5271 {
5272  FILE *yyo = yyoutput;
5273  YYUSE (yyo);
5274  YYUSE (yylocationp);
5275  YYUSE (p);
5276  if (!yyvaluep)
5277  return;
5278 # ifdef YYPRINT
5279  if (yytype < YYNTOKENS)
5280  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
5281 # endif
5282  YYUSE (yytype);
5283 }
5284 
5285 
5286 /*--------------------------------.
5287 | Print this symbol on YYOUTPUT. |
5288 `--------------------------------*/
5289 
5290 static void
5291 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parser_params *p)
5292 {
5293  YYFPRINTF (p, "%s %s (",
5294  yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
5295 
5296  YY_LOCATION_PRINT (yyoutput, *yylocationp);
5297  YYFPRINTF (p, ": ");
5298  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, p);
5299  YYFPRINTF (p, ")");
5300 }
5301 
5302 /*------------------------------------------------------------------.
5303 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
5304 | TOP (included). |
5305 `------------------------------------------------------------------*/
5306 
5307 static void
5308 ruby_parser_yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop, struct parser_params *p)
5309 #define yy_stack_print(b, t) ruby_parser_yy_stack_print(b, t, p)
5310 {
5311  YYFPRINTF (p, "Stack now");
5312  for (; yybottom <= yytop; yybottom++)
5313  {
5314  int yybot = *yybottom;
5315  YYFPRINTF (p, " %d", yybot);
5316  }
5317  YYFPRINTF (p, "\n");
5318 }
5319 
5320 # define YY_STACK_PRINT(Bottom, Top) \
5321 do { \
5322  if (yydebug) \
5323  yy_stack_print ((Bottom), (Top)); \
5324 } while (0)
5325 
5326 
5327 /*------------------------------------------------.
5328 | Report that the YYRULE is going to be reduced. |
5329 `------------------------------------------------*/
5330 
5331 static void
5332 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, struct parser_params *p)
5333 {
5334  unsigned long int yylno = yyrline[yyrule];
5335  int yynrhs = yyr2[yyrule];
5336  int yyi;
5337  YYFPRINTF (p, "Reducing stack by rule %d (line %lu):\n",
5338  yyrule - 1, yylno);
5339  /* The symbols being reduced. */
5340  for (yyi = 0; yyi < yynrhs; yyi++)
5341  {
5342  YYFPRINTF (p, " $%d = ", yyi + 1);
5343  yy_symbol_print (stderr,
5344  yystos[yyssp[yyi + 1 - yynrhs]],
5345  &(yyvsp[(yyi + 1) - (yynrhs)])
5346  , &(yylsp[(yyi + 1) - (yynrhs)]) , p);
5347  YYFPRINTF (p, "\n");
5348  }
5349 }
5350 
5351 # define YY_REDUCE_PRINT(Rule) \
5352 do { \
5353  if (yydebug) \
5354  yy_reduce_print (yyssp, yyvsp, yylsp, Rule, p); \
5355 } while (0)
5356 
5357 /* Nonzero means print parse trace. It is left uninitialized so that
5358  multiple parsers can coexist. */
5359 #ifndef yydebug
5360 int yydebug;
5361 #endif
5362 #else /* !YYDEBUG */
5363 # define YYDPRINTF(Args)
5364 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
5365 # define YY_STACK_PRINT(Bottom, Top)
5366 # define YY_REDUCE_PRINT(Rule)
5367 #endif /* !YYDEBUG */
5368 
5369 
5370 /* YYINITDEPTH -- initial size of the parser's stacks. */
5371 #ifndef YYINITDEPTH
5372 # define YYINITDEPTH 200
5373 #endif
5374 
5375 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
5376  if the built-in stack extension method is used).
5377 
5378  Do not make this value too large; the results are undefined if
5379  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
5380  evaluated with infinite-precision integer arithmetic. */
5381 
5382 #ifndef YYMAXDEPTH
5383 # define YYMAXDEPTH 10000
5384 #endif
5385 
5386 
5387 #if YYERROR_VERBOSE
5388 
5389 # ifndef yystrlen
5390 # if defined __GLIBC__ && defined _STRING_H
5391 # define yystrlen strlen
5392 # else
5393 /* Return the length of YYSTR. */
5394 static YYSIZE_T
5395 yystrlen (const char *yystr)
5396 {
5397  YYSIZE_T yylen;
5398  for (yylen = 0; yystr[yylen]; yylen++)
5399  continue;
5400  return yylen;
5401 }
5402 # endif
5403 # endif
5404 
5405 # ifndef yystpcpy
5406 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
5407 # define yystpcpy stpcpy
5408 # else
5409 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
5410  YYDEST. */
5411 static char *
5412 yystpcpy (char *yydest, const char *yysrc)
5413 {
5414  char *yyd = yydest;
5415  const char *yys = yysrc;
5416 
5417  while ((*yyd++ = *yys++) != '\0')
5418  continue;
5419 
5420  return yyd - 1;
5421 }
5422 # endif
5423 # endif
5424 
5425 # ifndef yytnamerr
5426 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
5427  quotes and backslashes, so that it's suitable for yyerror. The
5428  heuristic is that double-quoting is unnecessary unless the string
5429  contains an apostrophe, a comma, or backslash (other than
5430  backslash-backslash). YYSTR is taken from yytname. If YYRES is
5431  null, do not copy; instead, return the length of what the result
5432  would have been. */
5433 static YYSIZE_T
5434 yytnamerr (char *yyres, const char *yystr)
5435 {
5436  if (*yystr == '"')
5437  {
5438  YYSIZE_T yyn = 0;
5439  char const *yyp = yystr;
5440 
5441  for (;;)
5442  switch (*++yyp)
5443  {
5444  case '\'':
5445  case ',':
5446  goto do_not_strip_quotes;
5447 
5448  case '\\':
5449  if (*++yyp != '\\')
5450  goto do_not_strip_quotes;
5451  /* Fall through. */
5452  default:
5453  if (yyres)
5454  yyres[yyn] = *yyp;
5455  yyn++;
5456  break;
5457 
5458  case '"':
5459  if (yyres)
5460  yyres[yyn] = '\0';
5461  return yyn;
5462  }
5463  do_not_strip_quotes: ;
5464  }
5465 
5466  if (! yyres)
5467  return yystrlen (yystr);
5468 
5469  return yystpcpy (yyres, yystr) - yyres;
5470 }
5471 # endif
5472 
5473 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
5474  about the unexpected token YYTOKEN for the state stack whose top is
5475  YYSSP.
5476 
5477  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
5478  not large enough to hold the message. In that case, also set
5479  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
5480  required number of bytes is too large to store. */
5481 static int
5482 yysyntax_error (struct parser_params *p, YYSIZE_T *yymsg_alloc, char **yymsg,
5483  yytype_int16 *yyssp, int yytoken)
5484 {
5485  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
5486  YYSIZE_T yysize = yysize0;
5487  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
5488  /* Internationalized format string. */
5489  const char *yyformat = YY_NULLPTR;
5490  /* Arguments of yyformat. */
5491  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
5492  /* Number of reported tokens (one for the "unexpected", one per
5493  "expected"). */
5494  int yycount = 0;
5495 
5496  /* There are many possibilities here to consider:
5497  - If this state is a consistent state with a default action, then
5498  the only way this function was invoked is if the default action
5499  is an error action. In that case, don't check for expected
5500  tokens because there are none.
5501  - The only way there can be no lookahead present (in yychar) is if
5502  this state is a consistent state with a default action. Thus,
5503  detecting the absence of a lookahead is sufficient to determine
5504  that there is no unexpected or expected token to report. In that
5505  case, just report a simple "syntax error".
5506  - Don't assume there isn't a lookahead just because this state is a
5507  consistent state with a default action. There might have been a
5508  previous inconsistent state, consistent state with a non-default
5509  action, or user semantic action that manipulated yychar.
5510  - Of course, the expected token list depends on states to have
5511  correct lookahead information, and it depends on the parser not
5512  to perform extra reductions after fetching a lookahead from the
5513  scanner and before detecting a syntax error. Thus, state merging
5514  (from LALR or IELR) and default reductions corrupt the expected
5515  token list. However, the list is correct for canonical LR with
5516  one exception: it will still contain any token that will not be
5517  accepted due to an error action in a later state.
5518  */
5519  if (yytoken != YYEMPTY)
5520  {
5521  int yyn = yypact[*yyssp];
5522  yyarg[yycount++] = yytname[yytoken];
5523  if (!yypact_value_is_default (yyn))
5524  {
5525  /* Start YYX at -YYN if negative to avoid negative indexes in
5526  YYCHECK. In other words, skip the first -YYN actions for
5527  this state because they are default actions. */
5528  int yyxbegin = yyn < 0 ? -yyn : 0;
5529  /* Stay within bounds of both yycheck and yytname. */
5530  int yychecklim = YYLAST - yyn + 1;
5531  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
5532  int yyx;
5533 
5534  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
5535  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
5536  && !yytable_value_is_error (yytable[yyx + yyn]))
5537  {
5538  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
5539  {
5540  yycount = 1;
5541  yysize = yysize0;
5542  break;
5543  }
5544  yyarg[yycount++] = yytname[yyx];
5545  {
5546  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
5547  if (! (yysize <= yysize1
5548  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
5549  return 2;
5550  yysize = yysize1;
5551  }
5552  }
5553  }
5554  }
5555 
5556  switch (yycount)
5557  {
5558 # define YYCASE_(N, S) \
5559  case N: \
5560  yyformat = S; \
5561  break
5562  YYCASE_(0, YY_("syntax error"));
5563  YYCASE_(1, YY_("syntax error, unexpected %s"));
5564  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
5565  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
5566  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
5567  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
5568 # undef YYCASE_
5569  }
5570 
5571  {
5572  YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
5573  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
5574  return 2;
5575  yysize = yysize1;
5576  }
5577 
5578  if (*yymsg_alloc < yysize)
5579  {
5580  *yymsg_alloc = 2 * yysize;
5581  if (! (yysize <= *yymsg_alloc
5582  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
5583  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
5584  return 1;
5585  }
5586 
5587  /* Avoid sprintf, as that infringes on the user's name space.
5588  Don't have undefined behavior even if the translation
5589  produced a string with the wrong number of "%s"s. */
5590  {
5591  char *yyp = *yymsg;
5592  int yyi = 0;
5593  while ((*yyp = *yyformat) != '\0')
5594  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
5595  {
5596  yyp += yytnamerr (yyp, yyarg[yyi++]);
5597  yyformat += 2;
5598  }
5599  else
5600  {
5601  yyp++;
5602  yyformat++;
5603  }
5604  }
5605  return 0;
5606 }
5607 #endif /* YYERROR_VERBOSE */
5608 
5609 /*-----------------------------------------------.
5610 | Release the memory associated to this symbol. |
5611 `-----------------------------------------------*/
5612 
5613 static void
5614 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, struct parser_params *p)
5615 {
5616  YYUSE (yyvaluep);
5617  YYUSE (yylocationp);
5618  YYUSE (p);
5619  if (!yymsg)
5620  yymsg = "Deleting";
5621  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
5622 
5624  YYUSE (yytype);
5626 }
5627 
5628 
5629 
5630 
5631 /*----------.
5632 | yyparse. |
5633 `----------*/
5634 
5635 int
5637 {
5638 /* The lookahead symbol. */
5639 int yychar;
5640 
5641 
5642 /* The semantic value of the lookahead symbol. */
5643 /* Default value used for initialization, for pacifying older GCCs
5644  or non-GCC compilers. */
5645 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
5646 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
5647 
5648 /* Location data for the lookahead symbol. */
5649 static YYLTYPE yyloc_default
5650 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
5651  = { 1, 1, 1, 1 }
5652 # endif
5653 ;
5654 YYLTYPE yylloc = yyloc_default;
5655 
5656  /* Number of syntax errors so far. */
5657  int yynerrs;
5658 
5659  int yystate;
5660  /* Number of tokens to shift before error messages enabled. */
5661  int yyerrstatus;
5662 
5663  /* The stacks and their tools:
5664  'yyss': related to states.
5665  'yyvs': related to semantic values.
5666  'yyls': related to locations.
5667 
5668  Refer to the stacks through separate pointers, to allow yyoverflow
5669  to reallocate them elsewhere. */
5670 
5671  /* The state stack. */
5672  yytype_int16 yyssa[YYINITDEPTH];
5673  yytype_int16 *yyss;
5674  yytype_int16 *yyssp;
5675 
5676  /* The semantic value stack. */
5677  YYSTYPE yyvsa[YYINITDEPTH];
5678  YYSTYPE *yyvs;
5679  YYSTYPE *yyvsp;
5680 
5681  /* The location stack. */
5682  YYLTYPE yylsa[YYINITDEPTH];
5683  YYLTYPE *yyls;
5684  YYLTYPE *yylsp;
5685 
5686  /* The locations where the error started and ended. */
5687  YYLTYPE yyerror_range[3];
5688 
5689  YYSIZE_T yystacksize;
5690 
5691  int yyn;
5692  int yyresult;
5693  /* Lookahead token as an internal (translated) token number. */
5694  int yytoken = 0;
5695  /* The variables used to return semantic value and location from the
5696  action routines. */
5697  YYSTYPE yyval;
5698  YYLTYPE yyloc;
5699 
5700 #if YYERROR_VERBOSE
5701  /* Buffer for error messages, and its allocated size. */
5702  char yymsgbuf[128];
5703  char *yymsg = yymsgbuf;
5704  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
5705 #endif
5706 
5707 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
5708 
5709  /* The number of symbols on the RHS of the reduced rule.
5710  Keep to zero when no symbol should be popped. */
5711  int yylen = 0;
5712 
5713  yyssp = yyss = yyssa;
5714  yyvsp = yyvs = yyvsa;
5715  yylsp = yyls = yylsa;
5716  yystacksize = YYINITDEPTH;
5717 
5718  YYDPRINTF ((p, "Starting parse\n"));
5719 
5720  yystate = 0;
5721  yyerrstatus = 0;
5722  yynerrs = 0;
5723  yychar = YYEMPTY; /* Cause a token to be read. */
5724 
5725 /* User initialization code. */
5726 #line 974 "ripper.y" /* yacc.c:1429 */
5727 {
5728  RUBY_SET_YYLLOC_OF_NONE(yylloc);
5729 }
5730 
5731 #line 5727 "ripper.c" /* yacc.c:1429 */
5732  yylsp[0] = yylloc;
5733  goto yysetstate;
5734 
5735 /*------------------------------------------------------------.
5736 | yynewstate -- Push a new state, which is found in yystate. |
5737 `------------------------------------------------------------*/
5738  yynewstate:
5739  /* In all cases, when you get here, the value and location stacks
5740  have just been pushed. So pushing a state here evens the stacks. */
5741  yyssp++;
5742 
5743  yysetstate:
5744  *yyssp = yystate;
5745 
5746  if (yyss + yystacksize - 1 <= yyssp)
5747  {
5748  /* Get the current used size of the three stacks, in elements. */
5749  YYSIZE_T yysize = yyssp - yyss + 1;
5750 
5751 #ifdef yyoverflow
5752  {
5753  /* Give user a chance to reallocate the stack. Use copies of
5754  these so that the &'s don't force the real ones into
5755  memory. */
5756  YYSTYPE *yyvs1 = yyvs;
5757  yytype_int16 *yyss1 = yyss;
5758  YYLTYPE *yyls1 = yyls;
5759 
5760  /* Each stack pointer address is followed by the size of the
5761  data in use in that stack, in bytes. This used to be a
5762  conditional around just the two extra args, but that might
5763  be undefined if yyoverflow is a macro. */
5764  yyoverflow (YY_("memory exhausted"),
5765  &yyss1, yysize * sizeof (*yyssp),
5766  &yyvs1, yysize * sizeof (*yyvsp),
5767  &yyls1, yysize * sizeof (*yylsp),
5768  &yystacksize);
5769 
5770  yyls = yyls1;
5771  yyss = yyss1;
5772  yyvs = yyvs1;
5773  }
5774 #else /* no yyoverflow */
5775 # ifndef YYSTACK_RELOCATE
5776  goto yyexhaustedlab;
5777 # else
5778  /* Extend the stack our own way. */
5779  if (YYMAXDEPTH <= yystacksize)
5780  goto yyexhaustedlab;
5781  yystacksize *= 2;
5782  if (YYMAXDEPTH < yystacksize)
5783  yystacksize = YYMAXDEPTH;
5784 
5785  {
5786  yytype_int16 *yyss1 = yyss;
5787  union yyalloc *yyptr =
5788  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
5789  if (! yyptr)
5790  goto yyexhaustedlab;
5791  YYSTACK_RELOCATE (yyss_alloc, yyss);
5792  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
5793  YYSTACK_RELOCATE (yyls_alloc, yyls);
5794 # undef YYSTACK_RELOCATE
5795  if (yyss1 != yyssa)
5796  YYSTACK_FREE (yyss1);
5797  }
5798 # endif
5799 #endif /* no yyoverflow */
5800 
5801  yyssp = yyss + yysize - 1;
5802  yyvsp = yyvs + yysize - 1;
5803  yylsp = yyls + yysize - 1;
5804 
5805  YYDPRINTF ((p, "Stack size increased to %lu\n",
5806  (unsigned long int) yystacksize));
5807 
5808  if (yyss + yystacksize - 1 <= yyssp)
5809  YYABORT;
5810  }
5811 
5812  YYDPRINTF ((p, "Entering state %d\n", yystate));
5813 
5814  if (yystate == YYFINAL)
5815  YYACCEPT;
5816 
5817  goto yybackup;
5818 
5819 /*-----------.
5820 | yybackup. |
5821 `-----------*/
5822 yybackup:
5823 
5824  /* Do appropriate processing given the current state. Read a
5825  lookahead token if we need one and don't already have one. */
5826 
5827  /* First try to decide what to do without reference to lookahead token. */
5828  yyn = yypact[yystate];
5829  if (yypact_value_is_default (yyn))
5830  goto yydefault;
5831 
5832  /* Not known => get a lookahead token if don't already have one. */
5833 
5834  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5835  if (yychar == YYEMPTY)
5836  {
5837  YYDPRINTF ((p, "Reading a token: "));
5838  yychar = yylex (&yylval, &yylloc, p);
5839  }
5840 
5841  if (yychar <= YYEOF)
5842  {
5843  yychar = yytoken = YYEOF;
5844  YYDPRINTF ((p, "Now at end of input.\n"));
5845  }
5846  else
5847  {
5848  yytoken = YYTRANSLATE (yychar);
5849  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
5850  }
5851 
5852  /* If the proper action on seeing token YYTOKEN is to reduce or to
5853  detect an error, take that action. */
5854  yyn += yytoken;
5855  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
5856  goto yydefault;
5857  yyn = yytable[yyn];
5858  if (yyn <= 0)
5859  {
5860  if (yytable_value_is_error (yyn))
5861  goto yyerrlab;
5862  yyn = -yyn;
5863  goto yyreduce;
5864  }
5865 
5866  /* Count tokens shifted since error; after three, turn off error
5867  status. */
5868  if (yyerrstatus)
5869  yyerrstatus--;
5870 
5871  /* Shift the lookahead token. */
5872  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
5873 
5874  /* Discard the shifted token. */
5875  yychar = YYEMPTY;
5876 
5877  yystate = yyn;
5879  *++yyvsp = yylval;
5881  *++yylsp = yylloc;
5882  goto yynewstate;
5883 
5884 
5885 /*-----------------------------------------------------------.
5886 | yydefault -- do the default action for the current state. |
5887 `-----------------------------------------------------------*/
5888 yydefault:
5889  yyn = yydefact[yystate];
5890  if (yyn == 0)
5891  goto yyerrlab;
5892  goto yyreduce;
5893 
5894 
5895 /*-----------------------------.
5896 | yyreduce -- Do a reduction. |
5897 `-----------------------------*/
5898 yyreduce:
5899  /* yyn is the number of a rule to reduce with. */
5900  yylen = yyr2[yyn];
5901 
5902  /* If YYLEN is nonzero, implement the default value of the action:
5903  '$$ = $1'.
5904 
5905  Otherwise, the following line sets YYVAL to garbage.
5906  This behavior is undocumented and Bison
5907  users should not rely upon it. Assigning to YYVAL
5908  unconditionally makes the parser a bit smaller, and it avoids a
5909  GCC warning that YYVAL may be used uninitialized. */
5910  yyval = yyvsp[1-yylen];
5911 
5912  /* Default location. */
5913  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
5914  YY_REDUCE_PRINT (yyn);
5915  switch (yyn)
5916  {
5917  case 2:
5918 #line 1176 "ripper.y" /* yacc.c:1646 */
5919  {
5920  SET_LEX_STATE(EXPR_BEG);
5921  local_push(p, ifndef_ripper(1)+0);
5922  }
5923 #line 5919 "ripper.c" /* yacc.c:1646 */
5924  break;
5925 
5926  case 3:
5927 #line 1181 "ripper.y" /* yacc.c:1646 */
5928  {
5929 #if 0
5930  if ((yyvsp[0].val) && !compile_for_eval) {
5931  NODE *node = (yyvsp[0].val);
5932  /* last expression should not be void */
5933  if (nd_type(node) == NODE_BLOCK) {
5934  while (node->nd_next) {
5935  node = node->nd_next;
5936  }
5937  node = node->nd_head;
5938  }
5939  node = remove_begin(node);
5940  void_expr(p, node);
5941  }
5942  p->eval_tree = NEW_SCOPE(0, block_append(p, p->eval_tree, (yyvsp[0].val)), &(yyloc));
5943 #endif
5944  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(program,v1);p->result=v2;}
5945  local_pop(p);
5946  }
5947 #line 5943 "ripper.c" /* yacc.c:1646 */
5948  break;
5949 
5950  case 4:
5951 #line 1203 "ripper.y" /* yacc.c:1646 */
5952  {
5953  (yyval.val) = void_stmts(p, (yyvsp[-1].val));
5954  }
5955 #line 5951 "ripper.c" /* yacc.c:1646 */
5956  break;
5957 
5958  case 5:
5959 #line 1209 "ripper.y" /* yacc.c:1646 */
5960  {
5961 #if 0
5962  (yyval.val) = NEW_BEGIN(0, &(yyloc));
5963 #endif
5964  {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;}
5965  }
5966 #line 5962 "ripper.c" /* yacc.c:1646 */
5967  break;
5968 
5969  case 6:
5970 #line 1216 "ripper.y" /* yacc.c:1646 */
5971  {
5972 #if 0
5973  (yyval.val) = newline_node((yyvsp[0].val));
5974 #endif
5975  {VALUE v1,v2,v3,v4;v1=dispatch0(stmts_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(stmts_add,v2,v3);(yyval.val)=v4;}
5976  }
5977 #line 5973 "ripper.c" /* yacc.c:1646 */
5978  break;
5979 
5980  case 7:
5981 #line 1223 "ripper.y" /* yacc.c:1646 */
5982  {
5983 #if 0
5984  (yyval.val) = block_append(p, (yyvsp[-2].val), newline_node((yyvsp[0].val)));
5985 #endif
5986  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(stmts_add,v1,v2);(yyval.val)=v3;}
5987  }
5988 #line 5984 "ripper.c" /* yacc.c:1646 */
5989  break;
5990 
5991  case 8:
5992 #line 1230 "ripper.y" /* yacc.c:1646 */
5993  {
5994  (yyval.val) = remove_begin((yyvsp[0].val));
5995  }
5996 #line 5992 "ripper.c" /* yacc.c:1646 */
5997  break;
5998 
5999  case 10:
6000 #line 1237 "ripper.y" /* yacc.c:1646 */
6001  {
6002  (yyval.val) = (yyvsp[0].val);
6003  }
6004 #line 6000 "ripper.c" /* yacc.c:1646 */
6005  break;
6006 
6007  case 11:
6008 #line 1243 "ripper.y" /* yacc.c:1646 */
6009  {
6010 #if 0
6011  p->eval_tree_begin = block_append(p, p->eval_tree_begin,
6012  NEW_BEGIN((yyvsp[-1].val), &(yyloc)));
6013  (yyval.val) = NEW_BEGIN(0, &(yyloc));
6014 #endif
6015  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(BEGIN,v1);(yyval.val)=v2;}
6016  }
6017 #line 6013 "ripper.c" /* yacc.c:1646 */
6018  break;
6019 
6020  case 12:
6021 #line 1255 "ripper.y" /* yacc.c:1646 */
6022  {if (!(yyvsp[-1].val)) {yyerror1(&(yylsp[0]), "else without rescue is useless");}}
6023 #line 6019 "ripper.c" /* yacc.c:1646 */
6024  break;
6025 
6026  case 13:
6027 #line 1258 "ripper.y" /* yacc.c:1646 */
6028  {
6029 #if 0
6030  (yyval.val) = new_bodystmt(p, (yyvsp[-5].val), (yyvsp[-4].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6031 #endif
6032  {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;}
6033  }
6034 #line 6030 "ripper.c" /* yacc.c:1646 */
6035  break;
6036 
6037  case 14:
6038 #line 1267 "ripper.y" /* yacc.c:1646 */
6039  {
6040 #if 0
6041  (yyval.val) = new_bodystmt(p, (yyvsp[-2].val), (yyvsp[-1].val), 0, (yyvsp[0].val), &(yyloc));
6042 #endif
6043  {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;}
6044  }
6045 #line 6041 "ripper.c" /* yacc.c:1646 */
6046  break;
6047 
6048  case 15:
6049 #line 1276 "ripper.y" /* yacc.c:1646 */
6050  {
6051  (yyval.val) = void_stmts(p, (yyvsp[-1].val));
6052  }
6053 #line 6049 "ripper.c" /* yacc.c:1646 */
6054  break;
6055 
6056  case 16:
6057 #line 1282 "ripper.y" /* yacc.c:1646 */
6058  {
6059 #if 0
6060  (yyval.val) = NEW_BEGIN(0, &(yyloc));
6061 #endif
6062  {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;}
6063  }
6064 #line 6060 "ripper.c" /* yacc.c:1646 */
6065  break;
6066 
6067  case 17:
6068 #line 1289 "ripper.y" /* yacc.c:1646 */
6069  {
6070 #if 0
6071  (yyval.val) = newline_node((yyvsp[0].val));
6072 #endif
6073  {VALUE v1,v2,v3,v4;v1=dispatch0(stmts_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(stmts_add,v2,v3);(yyval.val)=v4;}
6074  }
6075 #line 6071 "ripper.c" /* yacc.c:1646 */
6076  break;
6077 
6078  case 18:
6079 #line 1296 "ripper.y" /* yacc.c:1646 */
6080  {
6081 #if 0
6082  (yyval.val) = block_append(p, (yyvsp[-2].val), newline_node((yyvsp[0].val)));
6083 #endif
6084  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(stmts_add,v1,v2);(yyval.val)=v3;}
6085  }
6086 #line 6082 "ripper.c" /* yacc.c:1646 */
6087  break;
6088 
6089  case 19:
6090 #line 1303 "ripper.y" /* yacc.c:1646 */
6091  {
6092  (yyval.val) = remove_begin((yyvsp[0].val));
6093  }
6094 #line 6090 "ripper.c" /* yacc.c:1646 */
6095  break;
6096 
6097  case 20:
6098 #line 1309 "ripper.y" /* yacc.c:1646 */
6099  {
6100  (yyval.val) = (yyvsp[0].val);
6101  }
6102 #line 6098 "ripper.c" /* yacc.c:1646 */
6103  break;
6104 
6105  case 21:
6106 #line 1313 "ripper.y" /* yacc.c:1646 */
6107  {
6108  yyerror1(&(yylsp[0]), "BEGIN is permitted only at toplevel");
6109  }
6110 #line 6106 "ripper.c" /* yacc.c:1646 */
6111  break;
6112 
6113  case 22:
6114 #line 1317 "ripper.y" /* yacc.c:1646 */
6115  {
6116  (yyval.val) = (yyvsp[0].val);
6117  }
6118 #line 6114 "ripper.c" /* yacc.c:1646 */
6119  break;
6120 
6121  case 23:
6122 #line 1322 "ripper.y" /* yacc.c:1646 */
6123  {SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);}
6124 #line 6120 "ripper.c" /* yacc.c:1646 */
6125  break;
6126 
6127  case 24:
6128 #line 1323 "ripper.y" /* yacc.c:1646 */
6129  {
6130 #if 0
6131  (yyval.val) = NEW_ALIAS((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6132 #endif
6133  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(alias,v1,v2);(yyval.val)=v3;}
6134  }
6135 #line 6131 "ripper.c" /* yacc.c:1646 */
6136  break;
6137 
6138  case 25:
6139 #line 1330 "ripper.y" /* yacc.c:1646 */
6140  {
6141 #if 0
6142  (yyval.val) = NEW_VALIAS((yyvsp[-1].val), (yyvsp[0].val), &(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 26:
6150 #line 1337 "ripper.y" /* yacc.c:1646 */
6151  {
6152 #if 0
6153  char buf[2];
6154  buf[0] = '$';
6155  buf[1] = (char)(yyvsp[0].val)->nd_nth;
6156  (yyval.val) = NEW_VALIAS((yyvsp[-1].val), rb_intern2(buf, 2), &(yyloc));
6157 #endif
6158  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(var_alias,v1,v2);(yyval.val)=v3;}
6159  }
6160 #line 6156 "ripper.c" /* yacc.c:1646 */
6161  break;
6162 
6163  case 27:
6164 #line 1347 "ripper.y" /* yacc.c:1646 */
6165  {
6166 #if 0
6167  yyerror1(&(yylsp[0]), "can't make alias for the number variables");
6168  (yyval.val) = NEW_BEGIN(0, &(yyloc));
6169 #endif
6170  {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);
6171  }
6172 #line 6168 "ripper.c" /* yacc.c:1646 */
6173  break;
6174 
6175  case 28:
6176 #line 1355 "ripper.y" /* yacc.c:1646 */
6177  {
6178 #if 0
6179  (yyval.val) = (yyvsp[0].val);
6180 #endif
6181  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(undef,v1);(yyval.val)=v2;}
6182  }
6183 #line 6179 "ripper.c" /* yacc.c:1646 */
6184  break;
6185 
6186  case 29:
6187 #line 1362 "ripper.y" /* yacc.c:1646 */
6188  {
6189 #if 0
6190  (yyval.val) = new_if(p, (yyvsp[0].val), remove_begin((yyvsp[-2].val)), 0, &(yyloc));
6191  fixpos((yyval.val), (yyvsp[0].val));
6192 #endif
6193  {VALUE v1,v2,v3;v1=(yyvsp[0].val);v2=(yyvsp[-2].val);v3=dispatch2(if_mod,v1,v2);(yyval.val)=v3;}
6194  }
6195 #line 6191 "ripper.c" /* yacc.c:1646 */
6196  break;
6197 
6198  case 30:
6199 #line 1370 "ripper.y" /* yacc.c:1646 */
6200  {
6201 #if 0
6202  (yyval.val) = new_unless(p, (yyvsp[0].val), remove_begin((yyvsp[-2].val)), 0, &(yyloc));
6203  fixpos((yyval.val), (yyvsp[0].val));
6204 #endif
6205  {VALUE v1,v2,v3;v1=(yyvsp[0].val);v2=(yyvsp[-2].val);v3=dispatch2(unless_mod,v1,v2);(yyval.val)=v3;}
6206  }
6207 #line 6203 "ripper.c" /* yacc.c:1646 */
6208  break;
6209 
6210  case 31:
6211 #line 1378 "ripper.y" /* yacc.c:1646 */
6212  {
6213 #if 0
6214  if ((yyvsp[-2].val) && nd_type((yyvsp[-2].val)) == NODE_BEGIN) {
6215  (yyval.val) = NEW_WHILE(cond(p, (yyvsp[0].val), &(yylsp[0])), (yyvsp[-2].val)->nd_body, 0, &(yyloc));
6216  }
6217  else {
6218  (yyval.val) = NEW_WHILE(cond(p, (yyvsp[0].val), &(yylsp[0])), (yyvsp[-2].val), 1, &(yyloc));
6219  }
6220 #endif
6221  {VALUE v1,v2,v3;v1=(yyvsp[0].val);v2=(yyvsp[-2].val);v3=dispatch2(while_mod,v1,v2);(yyval.val)=v3;}
6222  }
6223 #line 6219 "ripper.c" /* yacc.c:1646 */
6224  break;
6225 
6226  case 32:
6227 #line 1390 "ripper.y" /* yacc.c:1646 */
6228  {
6229 #if 0
6230  if ((yyvsp[-2].val) && nd_type((yyvsp[-2].val)) == NODE_BEGIN) {
6231  (yyval.val) = NEW_UNTIL(cond(p, (yyvsp[0].val), &(yylsp[0])), (yyvsp[-2].val)->nd_body, 0, &(yyloc));
6232  }
6233  else {
6234  (yyval.val) = NEW_UNTIL(cond(p, (yyvsp[0].val), &(yylsp[0])), (yyvsp[-2].val), 1, &(yyloc));
6235  }
6236 #endif
6237  {VALUE v1,v2,v3;v1=(yyvsp[0].val);v2=(yyvsp[-2].val);v3=dispatch2(until_mod,v1,v2);(yyval.val)=v3;}
6238  }
6239 #line 6235 "ripper.c" /* yacc.c:1646 */
6240  break;
6241 
6242  case 33:
6243 #line 1402 "ripper.y" /* yacc.c:1646 */
6244  {
6245 #if 0
6246  NODE *resq;
6247  YYLTYPE loc = code_loc_gen(&(yylsp[-1]), &(yylsp[0]));
6248  resq = NEW_RESBODY(0, remove_begin((yyvsp[0].val)), 0, &loc);
6249  (yyval.val) = NEW_RESCUE(remove_begin((yyvsp[-2].val)), resq, 0, &(yyloc));
6250 #endif
6251  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(rescue_mod,v1,v2);(yyval.val)=v3;}
6252  }
6253 #line 6249 "ripper.c" /* yacc.c:1646 */
6254  break;
6255 
6256  case 34:
6257 #line 1412 "ripper.y" /* yacc.c:1646 */
6258  {
6259  if (p->in_def) {
6260  rb_warn0("END in method; use at_exit");
6261  }
6262 #if 0
6263  {
6264  NODE *scope = NEW_NODE(
6265  NODE_SCOPE, 0 /* tbl */, (yyvsp[-1].val) /* body */, 0 /* args */, &(yyloc));
6266  (yyval.val) = NEW_POSTEXE(scope, &(yyloc));
6267  }
6268 #endif
6269  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(END,v1);(yyval.val)=v2;}
6270  }
6271 #line 6267 "ripper.c" /* yacc.c:1646 */
6272  break;
6273 
6274  case 36:
6275 #line 1427 "ripper.y" /* yacc.c:1646 */
6276  {
6277 #if 0
6278  value_expr((yyvsp[0].val));
6279  (yyval.val) = node_assign(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6280 #endif
6281  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(massign,v1,v2);(yyval.val)=v3;}
6282  }
6283 #line 6279 "ripper.c" /* yacc.c:1646 */
6284  break;
6285 
6286  case 37:
6287 #line 1435 "ripper.y" /* yacc.c:1646 */
6288  {
6289 #if 0
6290  value_expr((yyvsp[0].val));
6291  (yyval.val) = node_assign(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6292 #endif
6293  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(assign,v1,v2);(yyval.val)=v3;}
6294  }
6295 #line 6291 "ripper.c" /* yacc.c:1646 */
6296  break;
6297 
6298  case 38:
6299 #line 1443 "ripper.y" /* yacc.c:1646 */
6300  {
6301 #if 0
6302  YYLTYPE loc = code_loc_gen(&(yylsp[-1]), &(yylsp[0]));
6303  value_expr((yyvsp[-2].val));
6304  (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));
6305 #endif
6306  {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;}
6307  }
6308 #line 6304 "ripper.c" /* yacc.c:1646 */
6309  break;
6310 
6311  case 39:
6312 #line 1452 "ripper.y" /* yacc.c:1646 */
6313  {
6314 #if 0
6315  (yyval.val) = node_assign(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6316 #endif
6317  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(massign,v1,v2);(yyval.val)=v3;}
6318  }
6319 #line 6315 "ripper.c" /* yacc.c:1646 */
6320  break;
6321 
6322  case 41:
6323 #line 1462 "ripper.y" /* yacc.c:1646 */
6324  {
6325 #if 0
6326  value_expr((yyvsp[0].val));
6327  (yyval.val) = node_assign(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6328 #endif
6329  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(assign,v1,v2);(yyval.val)=v3;}
6330  }
6331 #line 6327 "ripper.c" /* yacc.c:1646 */
6332  break;
6333 
6334  case 42:
6335 #line 1470 "ripper.y" /* yacc.c:1646 */
6336  {
6337 #if 0
6338  value_expr((yyvsp[0].val));
6339  (yyval.val) = new_op_assign(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6340 #endif
6341  {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;}
6342  }
6343 #line 6339 "ripper.c" /* yacc.c:1646 */
6344  break;
6345 
6346  case 43:
6347 #line 1478 "ripper.y" /* yacc.c:1646 */
6348  {
6349 #if 0
6350  value_expr((yyvsp[0].val));
6351  (yyval.val) = new_ary_op_assign(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-3]), &(yyloc));
6352 #endif
6353  {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;}
6354 
6355  }
6356 #line 6352 "ripper.c" /* yacc.c:1646 */
6357  break;
6358 
6359  case 44:
6360 #line 1487 "ripper.y" /* yacc.c:1646 */
6361  {
6362 #if 0
6363  value_expr((yyvsp[0].val));
6364  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), (yyvsp[-3].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6365 #endif
6366  {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;}
6367  }
6368 #line 6364 "ripper.c" /* yacc.c:1646 */
6369  break;
6370 
6371  case 45:
6372 #line 1495 "ripper.y" /* yacc.c:1646 */
6373  {
6374 #if 0
6375  value_expr((yyvsp[0].val));
6376  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), (yyvsp[-3].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6377 #endif
6378  {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;}
6379  }
6380 #line 6376 "ripper.c" /* yacc.c:1646 */
6381  break;
6382 
6383  case 46:
6384 #line 1503 "ripper.y" /* yacc.c:1646 */
6385  {
6386 #if 0
6387  YYLTYPE loc = code_loc_gen(&(yylsp[-4]), &(yylsp[-2]));
6388  (yyval.val) = new_const_op_assign(p, NEW_COLON2((yyvsp[-4].val), (yyvsp[-2].val), &loc), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6389 #endif
6390  {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;}
6391  }
6392 #line 6388 "ripper.c" /* yacc.c:1646 */
6393  break;
6394 
6395  case 47:
6396 #line 1511 "ripper.y" /* yacc.c:1646 */
6397  {
6398 #if 0
6399  value_expr((yyvsp[0].val));
6400  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), ID2VAL(idCOLON2), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6401 #endif
6402  {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;}
6403  }
6404 #line 6400 "ripper.c" /* yacc.c:1646 */
6405  break;
6406 
6407  case 48:
6408 #line 1519 "ripper.y" /* yacc.c:1646 */
6409  {
6410 #if 0
6411  rb_backref_error(p, (yyvsp[-2].val));
6412  (yyval.val) = NEW_BEGIN(0, &(yyloc));
6413 #endif
6414  {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);
6415  }
6416 #line 6412 "ripper.c" /* yacc.c:1646 */
6417  break;
6418 
6419  case 49:
6420 #line 1529 "ripper.y" /* yacc.c:1646 */
6421  {
6422  value_expr((yyvsp[0].val));
6423  (yyval.val) = (yyvsp[0].val);
6424  }
6425 #line 6421 "ripper.c" /* yacc.c:1646 */
6426  break;
6427 
6428  case 50:
6429 #line 1534 "ripper.y" /* yacc.c:1646 */
6430  {
6431 #if 0
6432  YYLTYPE loc = code_loc_gen(&(yylsp[-1]), &(yylsp[0]));
6433  value_expr((yyvsp[-2].val));
6434  (yyval.val) = NEW_RESCUE((yyvsp[-2].val), NEW_RESBODY(0, remove_begin((yyvsp[0].val)), 0, &loc), 0, &(yyloc));
6435 #endif
6436  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(rescue_mod,v1,v2);(yyval.val)=v3;}
6437  }
6438 #line 6434 "ripper.c" /* yacc.c:1646 */
6439  break;
6440 
6441  case 53:
6442 #line 1547 "ripper.y" /* yacc.c:1646 */
6443  {
6444  (yyval.val) = logop(p, idAND, (yyvsp[-2].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
6445  }
6446 #line 6442 "ripper.c" /* yacc.c:1646 */
6447  break;
6448 
6449  case 54:
6450 #line 1551 "ripper.y" /* yacc.c:1646 */
6451  {
6452  (yyval.val) = logop(p, idOR, (yyvsp[-2].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
6453  }
6454 #line 6450 "ripper.c" /* yacc.c:1646 */
6455  break;
6456 
6457  case 55:
6458 #line 1555 "ripper.y" /* yacc.c:1646 */
6459  {
6460  (yyval.val) = call_uni_op(p, method_cond(p, (yyvsp[0].val), &(yylsp[0])), METHOD_NOT, &(yylsp[-2]), &(yyloc));
6461  }
6462 #line 6458 "ripper.c" /* yacc.c:1646 */
6463  break;
6464 
6465  case 56:
6466 #line 1559 "ripper.y" /* yacc.c:1646 */
6467  {
6468  (yyval.val) = call_uni_op(p, method_cond(p, (yyvsp[0].val), &(yylsp[0])), '!', &(yylsp[-1]), &(yyloc));
6469  }
6470 #line 6466 "ripper.c" /* yacc.c:1646 */
6471  break;
6472 
6473  case 57:
6474 #line 1563 "ripper.y" /* yacc.c:1646 */
6475  {
6476  value_expr((yyvsp[-1].val));
6477  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
6478  p->command_start = FALSE;
6479  (yyval.num) = p->in_kwarg;
6480  p->in_kwarg = 1;
6481  }
6482 #line 6478 "ripper.c" /* yacc.c:1646 */
6483  break;
6484 
6485  case 58:
6486 #line 1570 "ripper.y" /* yacc.c:1646 */
6487  {(yyval.tbl) = push_pvtbl(p);}
6488 #line 6484 "ripper.c" /* yacc.c:1646 */
6489  break;
6490 
6491  case 59:
6492 #line 1572 "ripper.y" /* yacc.c:1646 */
6493  {pop_pvtbl(p, (yyvsp[-1].tbl));}
6494 #line 6490 "ripper.c" /* yacc.c:1646 */
6495  break;
6496 
6497  case 60:
6498 #line 1573 "ripper.y" /* yacc.c:1646 */
6499  {
6500  p->in_kwarg = !!(yyvsp[-3].num);
6501 #if 0
6502  (yyval.val) = new_case3(p, (yyvsp[-5].val), NEW_IN((yyvsp[-1].val), 0, 0, &(yylsp[-1])), &(yyloc));
6503 #endif
6504  {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;}
6505  }
6506 #line 6502 "ripper.c" /* yacc.c:1646 */
6507  break;
6508 
6509  case 62:
6510 #line 1584 "ripper.y" /* yacc.c:1646 */
6511  {
6512  value_expr((yyvsp[0].val));
6513  (yyval.val) = (yyvsp[0].val);
6514  }
6515 #line 6511 "ripper.c" /* yacc.c:1646 */
6516  break;
6517 
6518  case 63:
6519 #line 1590 "ripper.y" /* yacc.c:1646 */
6520  {COND_PUSH(1);}
6521 #line 6517 "ripper.c" /* yacc.c:1646 */
6522  break;
6523 
6524  case 64:
6525 #line 1590 "ripper.y" /* yacc.c:1646 */
6526  {COND_POP();}
6527 #line 6523 "ripper.c" /* yacc.c:1646 */
6528  break;
6529 
6530  case 65:
6531 #line 1591 "ripper.y" /* yacc.c:1646 */
6532  {
6533  (yyval.val) = (yyvsp[-2].val);
6534  }
6535 #line 6531 "ripper.c" /* yacc.c:1646 */
6536  break;
6537 
6538  case 69:
6539 #line 1602 "ripper.y" /* yacc.c:1646 */
6540  {
6541 #if 0
6542  (yyval.val) = new_qcall(p, (yyvsp[-2].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
6543 #endif
6544  {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;}
6545  }
6546 #line 6542 "ripper.c" /* yacc.c:1646 */
6547  break;
6548 
6549  case 70:
6550 #line 1611 "ripper.y" /* yacc.c:1646 */
6551  {
6552  (yyval.val) = (yyvsp[-1].val);
6553 #if 0
6554  (yyval.val)->nd_body->nd_loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
6555  nd_set_line((yyval.val), (yylsp[-2]).end_pos.lineno);
6556 #endif
6557  }
6558 #line 6554 "ripper.c" /* yacc.c:1646 */
6559  break;
6560 
6561  case 71:
6562 #line 1621 "ripper.y" /* yacc.c:1646 */
6563  {
6564 #if 0
6565  (yyval.val) = NEW_FCALL((yyvsp[0].val), 0, &(yyloc));
6566  nd_set_line((yyval.val), p->tokline);
6567 #endif
6568  (yyval.val)=(yyvsp[0].val);
6569  }
6570 #line 6566 "ripper.c" /* yacc.c:1646 */
6571  break;
6572 
6573  case 72:
6574 #line 1631 "ripper.y" /* yacc.c:1646 */
6575  {
6576 #if 0
6577  (yyvsp[-1].val)->nd_args = (yyvsp[0].val);
6578  nd_set_last_loc((yyvsp[-1].val), (yylsp[0]).end_pos);
6579  (yyval.val) = (yyvsp[-1].val);
6580 #endif
6581  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(command,v1,v2);(yyval.val)=v3;}
6582  }
6583 #line 6579 "ripper.c" /* yacc.c:1646 */
6584  break;
6585 
6586  case 73:
6587 #line 1640 "ripper.y" /* yacc.c:1646 */
6588  {
6589 #if 0
6590  block_dup_check(p, (yyvsp[-1].val), (yyvsp[0].val));
6591  (yyvsp[-2].val)->nd_args = (yyvsp[-1].val);
6592  (yyval.val) = method_add_block(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6593  fixpos((yyval.val), (yyvsp[-2].val));
6594  nd_set_last_loc((yyvsp[-2].val), (yylsp[-1]).end_pos);
6595 #endif
6596  {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;}
6597  }
6598 #line 6594 "ripper.c" /* yacc.c:1646 */
6599  break;
6600 
6601  case 74:
6602 #line 1651 "ripper.y" /* yacc.c:1646 */
6603  {
6604 #if 0
6605  (yyval.val) = new_command_qcall(p, (yyvsp[-2].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), Qnull, &(yylsp[-1]), &(yyloc));
6606 #endif
6607  {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;}
6608  }
6609 #line 6605 "ripper.c" /* yacc.c:1646 */
6610  break;
6611 
6612  case 75:
6613 #line 1658 "ripper.y" /* yacc.c:1646 */
6614  {
6615 #if 0
6616  (yyval.val) = new_command_qcall(p, (yyvsp[-3].val), (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-2]), &(yyloc));
6617 #endif
6618  {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;}
6619  }
6620 #line 6616 "ripper.c" /* yacc.c:1646 */
6621  break;
6622 
6623  case 76:
6624 #line 1665 "ripper.y" /* yacc.c:1646 */
6625  {
6626 #if 0
6627  (yyval.val) = new_command_qcall(p, ID2VAL(idCOLON2), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), Qnull, &(yylsp[-1]), &(yyloc));
6628 #endif
6629  {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;}
6630  }
6631 #line 6627 "ripper.c" /* yacc.c:1646 */
6632  break;
6633 
6634  case 77:
6635 #line 1672 "ripper.y" /* yacc.c:1646 */
6636  {
6637 #if 0
6638  (yyval.val) = new_command_qcall(p, ID2VAL(idCOLON2), (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-2]), &(yyloc));
6639 #endif
6640  {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;}
6641  }
6642 #line 6638 "ripper.c" /* yacc.c:1646 */
6643  break;
6644 
6645  case 78:
6646 #line 1679 "ripper.y" /* yacc.c:1646 */
6647  {
6648 #if 0
6649  (yyval.val) = NEW_SUPER((yyvsp[0].val), &(yyloc));
6650  fixpos((yyval.val), (yyvsp[0].val));
6651 #endif
6652  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(super,v1);(yyval.val)=v2;}
6653  }
6654 #line 6650 "ripper.c" /* yacc.c:1646 */
6655  break;
6656 
6657  case 79:
6658 #line 1687 "ripper.y" /* yacc.c:1646 */
6659  {
6660 #if 0
6661  (yyval.val) = new_yield(p, (yyvsp[0].val), &(yyloc));
6662  fixpos((yyval.val), (yyvsp[0].val));
6663 #endif
6664  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(yield,v1);(yyval.val)=v2;}
6665  }
6666 #line 6662 "ripper.c" /* yacc.c:1646 */
6667  break;
6668 
6669  case 80:
6670 #line 1695 "ripper.y" /* yacc.c:1646 */
6671  {
6672 #if 0
6673  (yyval.val) = NEW_RETURN(ret_args(p, (yyvsp[0].val)), &(yyloc));
6674 #endif
6675  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(return,v1);(yyval.val)=v2;}
6676  }
6677 #line 6673 "ripper.c" /* yacc.c:1646 */
6678  break;
6679 
6680  case 81:
6681 #line 1702 "ripper.y" /* yacc.c:1646 */
6682  {
6683 #if 0
6684  (yyval.val) = NEW_BREAK(ret_args(p, (yyvsp[0].val)), &(yyloc));
6685 #endif
6686  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(break,v1);(yyval.val)=v2;}
6687  }
6688 #line 6684 "ripper.c" /* yacc.c:1646 */
6689  break;
6690 
6691  case 82:
6692 #line 1709 "ripper.y" /* yacc.c:1646 */
6693  {
6694 #if 0
6695  (yyval.val) = NEW_NEXT(ret_args(p, (yyvsp[0].val)), &(yyloc));
6696 #endif
6697  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(next,v1);(yyval.val)=v2;}
6698  }
6699 #line 6695 "ripper.c" /* yacc.c:1646 */
6700  break;
6701 
6702  case 84:
6703 #line 1719 "ripper.y" /* yacc.c:1646 */
6704  {
6705 #if 0
6706  (yyval.val) = (yyvsp[-1].val);
6707 #endif
6708  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(mlhs_paren,v1);(yyval.val)=v2;}
6709  }
6710 #line 6706 "ripper.c" /* yacc.c:1646 */
6711  break;
6712 
6713  case 86:
6714 #line 1729 "ripper.y" /* yacc.c:1646 */
6715  {
6716 #if 0
6717  (yyval.val) = NEW_MASGN(NEW_LIST((yyvsp[-1].val), &(yyloc)), 0, &(yyloc));
6718 #endif
6719  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(mlhs_paren,v1);(yyval.val)=v2;}
6720  }
6721 #line 6717 "ripper.c" /* yacc.c:1646 */
6722  break;
6723 
6724  case 87:
6725 #line 1738 "ripper.y" /* yacc.c:1646 */
6726  {
6727 #if 0
6728  (yyval.val) = NEW_MASGN((yyvsp[0].val), 0, &(yyloc));
6729 #endif
6730  (yyval.val)=(yyvsp[0].val);
6731  }
6732 #line 6728 "ripper.c" /* yacc.c:1646 */
6733  break;
6734 
6735  case 88:
6736 #line 1745 "ripper.y" /* yacc.c:1646 */
6737  {
6738 #if 0
6739  (yyval.val) = NEW_MASGN(list_append(p, (yyvsp[-1].val),(yyvsp[0].val)), 0, &(yyloc));
6740 #endif
6741  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(mlhs_add,v1,v2);(yyval.val)=v3;}
6742  }
6743 #line 6739 "ripper.c" /* yacc.c:1646 */
6744  break;
6745 
6746  case 89:
6747 #line 1752 "ripper.y" /* yacc.c:1646 */
6748  {
6749 #if 0
6750  (yyval.val) = NEW_MASGN((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
6751 #endif
6752  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(mlhs_add_star,v1,v2);(yyval.val)=v3;}
6753  }
6754 #line 6750 "ripper.c" /* yacc.c:1646 */
6755  break;
6756 
6757  case 90:
6758 #line 1759 "ripper.y" /* yacc.c:1646 */
6759  {
6760 #if 0
6761  (yyval.val) = NEW_MASGN((yyvsp[-4].val), NEW_POSTARG((yyvsp[-2].val),(yyvsp[0].val),&(yyloc)), &(yyloc));
6762 #endif
6763  {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;}
6764  }
6765 #line 6761 "ripper.c" /* yacc.c:1646 */
6766  break;
6767 
6768  case 91:
6769 #line 1766 "ripper.y" /* yacc.c:1646 */
6770  {
6771 #if 0
6772  (yyval.val) = NEW_MASGN((yyvsp[-1].val), NODE_SPECIAL_NO_NAME_REST, &(yyloc));
6773 #endif
6774  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(mlhs_add_star,v1,v2);(yyval.val)=v3;}
6775  }
6776 #line 6772 "ripper.c" /* yacc.c:1646 */
6777  break;
6778 
6779  case 92:
6780 #line 1773 "ripper.y" /* yacc.c:1646 */
6781  {
6782 #if 0
6783  (yyval.val) = NEW_MASGN((yyvsp[-3].val), NEW_POSTARG(NODE_SPECIAL_NO_NAME_REST, (yyvsp[0].val), &(yyloc)), &(yyloc));
6784 #endif
6785  {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;}
6786  }
6787 #line 6783 "ripper.c" /* yacc.c:1646 */
6788  break;
6789 
6790  case 93:
6791 #line 1780 "ripper.y" /* yacc.c:1646 */
6792  {
6793 #if 0
6794  (yyval.val) = NEW_MASGN(0, (yyvsp[0].val), &(yyloc));
6795 #endif
6796  {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;}
6797  }
6798 #line 6794 "ripper.c" /* yacc.c:1646 */
6799  break;
6800 
6801  case 94:
6802 #line 1787 "ripper.y" /* yacc.c:1646 */
6803  {
6804 #if 0
6805  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[-2].val),(yyvsp[0].val),&(yyloc)), &(yyloc));
6806 #endif
6807  {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;}
6808  }
6809 #line 6805 "ripper.c" /* yacc.c:1646 */
6810  break;
6811 
6812  case 95:
6813 #line 1794 "ripper.y" /* yacc.c:1646 */
6814  {
6815 #if 0
6816  (yyval.val) = NEW_MASGN(0, NODE_SPECIAL_NO_NAME_REST, &(yyloc));
6817 #endif
6818  {VALUE v1,v2,v3,v4;v1=dispatch0(mlhs_new);v2=v1;v3=Qnil;v4=dispatch2(mlhs_add_star,v2,v3);(yyval.val)=v4;}
6819  }
6820 #line 6816 "ripper.c" /* yacc.c:1646 */
6821  break;
6822 
6823  case 96:
6824 #line 1801 "ripper.y" /* yacc.c:1646 */
6825  {
6826 #if 0
6827  (yyval.val) = NEW_MASGN(0, NEW_POSTARG(NODE_SPECIAL_NO_NAME_REST, (yyvsp[0].val), &(yyloc)), &(yyloc));
6828 #endif
6829  {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;}
6830  }
6831 #line 6827 "ripper.c" /* yacc.c:1646 */
6832  break;
6833 
6834  case 98:
6835 #line 1811 "ripper.y" /* yacc.c:1646 */
6836  {
6837 #if 0
6838  (yyval.val) = (yyvsp[-1].val);
6839 #endif
6840  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(mlhs_paren,v1);(yyval.val)=v2;}
6841  }
6842 #line 6838 "ripper.c" /* yacc.c:1646 */
6843  break;
6844 
6845  case 99:
6846 #line 1820 "ripper.y" /* yacc.c:1646 */
6847  {
6848 #if 0
6849  (yyval.val) = NEW_LIST((yyvsp[-1].val), &(yylsp[-1]));
6850 #endif
6851  {VALUE v1,v2,v3,v4;v1=dispatch0(mlhs_new);v2=v1;v3=(yyvsp[-1].val);v4=dispatch2(mlhs_add,v2,v3);(yyval.val)=v4;}
6852  }
6853 #line 6849 "ripper.c" /* yacc.c:1646 */
6854  break;
6855 
6856  case 100:
6857 #line 1827 "ripper.y" /* yacc.c:1646 */
6858  {
6859 #if 0
6860  (yyval.val) = list_append(p, (yyvsp[-2].val), (yyvsp[-1].val));
6861 #endif
6862  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(mlhs_add,v1,v2);(yyval.val)=v3;}
6863  }
6864 #line 6860 "ripper.c" /* yacc.c:1646 */
6865  break;
6866 
6867  case 101:
6868 #line 1836 "ripper.y" /* yacc.c:1646 */
6869  {
6870 #if 0
6871  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
6872 #endif
6873  {VALUE v1,v2,v3,v4;v1=dispatch0(mlhs_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(mlhs_add,v2,v3);(yyval.val)=v4;}
6874  }
6875 #line 6871 "ripper.c" /* yacc.c:1646 */
6876  break;
6877 
6878  case 102:
6879 #line 1843 "ripper.y" /* yacc.c:1646 */
6880  {
6881 #if 0
6882  (yyval.val) = list_append(p, (yyvsp[-2].val), (yyvsp[0].val));
6883 #endif
6884  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(mlhs_add,v1,v2);(yyval.val)=v3;}
6885  }
6886 #line 6882 "ripper.c" /* yacc.c:1646 */
6887  break;
6888 
6889  case 103:
6890 #line 1852 "ripper.y" /* yacc.c:1646 */
6891  {
6892 #if 0
6893  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
6894 #endif
6895  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
6896  }
6897 #line 6893 "ripper.c" /* yacc.c:1646 */
6898  break;
6899 
6900  case 104:
6901 #line 1859 "ripper.y" /* yacc.c:1646 */
6902  {
6903 #if 0
6904  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
6905 #endif
6906  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
6907  }
6908 #line 6904 "ripper.c" /* yacc.c:1646 */
6909  break;
6910 
6911  case 105:
6912 #line 1866 "ripper.y" /* yacc.c:1646 */
6913  {
6914 #if 0
6915  (yyval.val) = aryset(p, (yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
6916 #endif
6917  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=escape_Qundef((yyvsp[-1].val));v3=dispatch2(aref_field,v1,v2);(yyval.val)=v3;}
6918  }
6919 #line 6915 "ripper.c" /* yacc.c:1646 */
6920  break;
6921 
6922  case 106:
6923 #line 1873 "ripper.y" /* yacc.c:1646 */
6924  {
6925  if ((yyvsp[-1].val) == tANDDOT) {
6926  yyerror1(&(yylsp[-1]), "&. inside multiple assignment destination");
6927  }
6928 #if 0
6929  (yyval.val) = attrset(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6930 #endif
6931  {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;}
6932  }
6933 #line 6929 "ripper.c" /* yacc.c:1646 */
6934  break;
6935 
6936  case 107:
6937 #line 1883 "ripper.y" /* yacc.c:1646 */
6938  {
6939 #if 0
6940  (yyval.val) = attrset(p, (yyvsp[-2].val), idCOLON2, (yyvsp[0].val), &(yyloc));
6941 #endif
6942  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(const_path_field,v1,v2);(yyval.val)=v3;}
6943  }
6944 #line 6940 "ripper.c" /* yacc.c:1646 */
6945  break;
6946 
6947  case 108:
6948 #line 1890 "ripper.y" /* yacc.c:1646 */
6949  {
6950  if ((yyvsp[-1].val) == tANDDOT) {
6951  yyerror1(&(yylsp[-1]), "&. inside multiple assignment destination");
6952  }
6953 #if 0
6954  (yyval.val) = attrset(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
6955 #endif
6956  {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;}
6957  }
6958 #line 6954 "ripper.c" /* yacc.c:1646 */
6959  break;
6960 
6961  case 109:
6962 #line 1900 "ripper.y" /* yacc.c:1646 */
6963  {
6964 #if 0
6965  (yyval.val) = const_decl(p, NEW_COLON2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
6966 #endif
6967  {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);}
6968  }
6969 #line 6965 "ripper.c" /* yacc.c:1646 */
6970  break;
6971 
6972  case 110:
6973 #line 1907 "ripper.y" /* yacc.c:1646 */
6974  {
6975 #if 0
6976  (yyval.val) = const_decl(p, NEW_COLON3((yyvsp[0].val), &(yyloc)), &(yyloc));
6977 #endif
6978  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(top_const_field,v1);(yyval.val)=const_decl(p, v2);}
6979  }
6980 #line 6976 "ripper.c" /* yacc.c:1646 */
6981  break;
6982 
6983  case 111:
6984 #line 1914 "ripper.y" /* yacc.c:1646 */
6985  {
6986 #if 0
6987  rb_backref_error(p, (yyvsp[0].val));
6988  (yyval.val) = NEW_BEGIN(0, &(yyloc));
6989 #endif
6990  {VALUE v1,v2;v1=var_field(p, (yyvsp[0].val));v2=dispatch1(assign_error,v1);(yyval.val)=v2;}ripper_error(p);
6991  }
6992 #line 6988 "ripper.c" /* yacc.c:1646 */
6993  break;
6994 
6995  case 112:
6996 #line 1924 "ripper.y" /* yacc.c:1646 */
6997  {
6998 #if 0
6999  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
7000 #endif
7001  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
7002  }
7003 #line 6999 "ripper.c" /* yacc.c:1646 */
7004  break;
7005 
7006  case 113:
7007 #line 1931 "ripper.y" /* yacc.c:1646 */
7008  {
7009 #if 0
7010  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
7011 #endif
7012  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
7013  }
7014 #line 7010 "ripper.c" /* yacc.c:1646 */
7015  break;
7016 
7017  case 114:
7018 #line 1938 "ripper.y" /* yacc.c:1646 */
7019  {
7020 #if 0
7021  (yyval.val) = aryset(p, (yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
7022 #endif
7023  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=escape_Qundef((yyvsp[-1].val));v3=dispatch2(aref_field,v1,v2);(yyval.val)=v3;}
7024  }
7025 #line 7021 "ripper.c" /* yacc.c:1646 */
7026  break;
7027 
7028  case 115:
7029 #line 1945 "ripper.y" /* yacc.c:1646 */
7030  {
7031 #if 0
7032  (yyval.val) = attrset(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7033 #endif
7034  {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;}
7035  }
7036 #line 7032 "ripper.c" /* yacc.c:1646 */
7037  break;
7038 
7039  case 116:
7040 #line 1952 "ripper.y" /* yacc.c:1646 */
7041  {
7042 #if 0
7043  (yyval.val) = attrset(p, (yyvsp[-2].val), idCOLON2, (yyvsp[0].val), &(yyloc));
7044 #endif
7045  {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;}
7046  }
7047 #line 7043 "ripper.c" /* yacc.c:1646 */
7048  break;
7049 
7050  case 117:
7051 #line 1959 "ripper.y" /* yacc.c:1646 */
7052  {
7053 #if 0
7054  (yyval.val) = attrset(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7055 #endif
7056  {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;}
7057  }
7058 #line 7054 "ripper.c" /* yacc.c:1646 */
7059  break;
7060 
7061  case 118:
7062 #line 1966 "ripper.y" /* yacc.c:1646 */
7063  {
7064 #if 0
7065  (yyval.val) = const_decl(p, NEW_COLON2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
7066 #endif
7067  {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);}
7068  }
7069 #line 7065 "ripper.c" /* yacc.c:1646 */
7070  break;
7071 
7072  case 119:
7073 #line 1973 "ripper.y" /* yacc.c:1646 */
7074  {
7075 #if 0
7076  (yyval.val) = const_decl(p, NEW_COLON3((yyvsp[0].val), &(yyloc)), &(yyloc));
7077 #endif
7078  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(top_const_field,v1);(yyval.val)=const_decl(p, v2);}
7079  }
7080 #line 7076 "ripper.c" /* yacc.c:1646 */
7081  break;
7082 
7083  case 120:
7084 #line 1980 "ripper.y" /* yacc.c:1646 */
7085  {
7086 #if 0
7087  rb_backref_error(p, (yyvsp[0].val));
7088  (yyval.val) = NEW_BEGIN(0, &(yyloc));
7089 #endif
7090  {VALUE v1,v2;v1=var_field(p, (yyvsp[0].val));v2=dispatch1(assign_error,v1);(yyval.val)=v2;}ripper_error(p);
7091  }
7092 #line 7088 "ripper.c" /* yacc.c:1646 */
7093  break;
7094 
7095  case 121:
7096 #line 1990 "ripper.y" /* yacc.c:1646 */
7097  {
7098 #if 0
7099  yyerror1(&(yylsp[0]), "class/module name must be CONSTANT");
7100 #endif
7101  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(class_name_error,v1);(yyval.val)=v2;}ripper_error(p);
7102  }
7103 #line 7099 "ripper.c" /* yacc.c:1646 */
7104  break;
7105 
7106  case 123:
7107 #line 2000 "ripper.y" /* yacc.c:1646 */
7108  {
7109 #if 0
7110  (yyval.val) = NEW_COLON3((yyvsp[0].val), &(yyloc));
7111 #endif
7112  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(top_const_ref,v1);(yyval.val)=v2;}
7113  }
7114 #line 7110 "ripper.c" /* yacc.c:1646 */
7115  break;
7116 
7117  case 124:
7118 #line 2007 "ripper.y" /* yacc.c:1646 */
7119  {
7120 #if 0
7121  (yyval.val) = NEW_COLON2(0, (yyval.val), &(yyloc));
7122 #endif
7123  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(const_ref,v1);(yyval.val)=v2;}
7124  }
7125 #line 7121 "ripper.c" /* yacc.c:1646 */
7126  break;
7127 
7128  case 125:
7129 #line 2014 "ripper.y" /* yacc.c:1646 */
7130  {
7131 #if 0
7132  (yyval.val) = NEW_COLON2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
7133 #endif
7134  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(const_path_ref,v1,v2);(yyval.val)=v3;}
7135  }
7136 #line 7132 "ripper.c" /* yacc.c:1646 */
7137  break;
7138 
7139  case 129:
7140 #line 2026 "ripper.y" /* yacc.c:1646 */
7141  {
7142  SET_LEX_STATE(EXPR_ENDFN);
7143  (yyval.val) = (yyvsp[0].val);
7144  }
7145 #line 7141 "ripper.c" /* yacc.c:1646 */
7146  break;
7147 
7148  case 130:
7149 #line 2031 "ripper.y" /* yacc.c:1646 */
7150  {
7151  SET_LEX_STATE(EXPR_ENDFN);
7152  (yyval.val) = (yyvsp[0].val);
7153  }
7154 #line 7150 "ripper.c" /* yacc.c:1646 */
7155  break;
7156 
7157  case 131:
7158 #line 2038 "ripper.y" /* yacc.c:1646 */
7159  {
7160 #if 0
7161  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[0].val)), &(yyloc));
7162 #endif
7163  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(symbol_literal,v1);(yyval.val)=v2;}
7164  }
7165 #line 7161 "ripper.c" /* yacc.c:1646 */
7166  break;
7167 
7168  case 133:
7169 #line 2048 "ripper.y" /* yacc.c:1646 */
7170  {
7171 #if 0
7172  (yyval.val) = NEW_UNDEF((yyvsp[0].val), &(yyloc));
7173 #endif
7174  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
7175  }
7176 #line 7172 "ripper.c" /* yacc.c:1646 */
7177  break;
7178 
7179  case 134:
7180 #line 2054 "ripper.y" /* yacc.c:1646 */
7181  {SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);}
7182 #line 7178 "ripper.c" /* yacc.c:1646 */
7183  break;
7184 
7185  case 135:
7186 #line 2055 "ripper.y" /* yacc.c:1646 */
7187  {
7188 #if 0
7189  NODE *undef = NEW_UNDEF((yyvsp[0].val), &(yylsp[0]));
7190  (yyval.val) = block_append(p, (yyvsp[-3].val), undef);
7191 #endif
7192  (yyval.val)=rb_ary_push((yyvsp[-3].val), get_value((yyvsp[0].val)));
7193  }
7194 #line 7190 "ripper.c" /* yacc.c:1646 */
7195  break;
7196 
7197  case 136:
7198 #line 2064 "ripper.y" /* yacc.c:1646 */
7199  { ifndef_ripper((yyval.val) = '|'); }
7200 #line 7196 "ripper.c" /* yacc.c:1646 */
7201  break;
7202 
7203  case 137:
7204 #line 2065 "ripper.y" /* yacc.c:1646 */
7205  { ifndef_ripper((yyval.val) = '^'); }
7206 #line 7202 "ripper.c" /* yacc.c:1646 */
7207  break;
7208 
7209  case 138:
7210 #line 2066 "ripper.y" /* yacc.c:1646 */
7211  { ifndef_ripper((yyval.val) = '&'); }
7212 #line 7208 "ripper.c" /* yacc.c:1646 */
7213  break;
7214 
7215  case 139:
7216 #line 2067 "ripper.y" /* yacc.c:1646 */
7217  { ifndef_ripper((yyval.val) = tCMP); }
7218 #line 7214 "ripper.c" /* yacc.c:1646 */
7219  break;
7220 
7221  case 140:
7222 #line 2068 "ripper.y" /* yacc.c:1646 */
7223  { ifndef_ripper((yyval.val) = tEQ); }
7224 #line 7220 "ripper.c" /* yacc.c:1646 */
7225  break;
7226 
7227  case 141:
7228 #line 2069 "ripper.y" /* yacc.c:1646 */
7229  { ifndef_ripper((yyval.val) = tEQQ); }
7230 #line 7226 "ripper.c" /* yacc.c:1646 */
7231  break;
7232 
7233  case 142:
7234 #line 2070 "ripper.y" /* yacc.c:1646 */
7235  { ifndef_ripper((yyval.val) = tMATCH); }
7236 #line 7232 "ripper.c" /* yacc.c:1646 */
7237  break;
7238 
7239  case 143:
7240 #line 2071 "ripper.y" /* yacc.c:1646 */
7241  { ifndef_ripper((yyval.val) = tNMATCH); }
7242 #line 7238 "ripper.c" /* yacc.c:1646 */
7243  break;
7244 
7245  case 144:
7246 #line 2072 "ripper.y" /* yacc.c:1646 */
7247  { ifndef_ripper((yyval.val) = '>'); }
7248 #line 7244 "ripper.c" /* yacc.c:1646 */
7249  break;
7250 
7251  case 145:
7252 #line 2073 "ripper.y" /* yacc.c:1646 */
7253  { ifndef_ripper((yyval.val) = tGEQ); }
7254 #line 7250 "ripper.c" /* yacc.c:1646 */
7255  break;
7256 
7257  case 146:
7258 #line 2074 "ripper.y" /* yacc.c:1646 */
7259  { ifndef_ripper((yyval.val) = '<'); }
7260 #line 7256 "ripper.c" /* yacc.c:1646 */
7261  break;
7262 
7263  case 147:
7264 #line 2075 "ripper.y" /* yacc.c:1646 */
7265  { ifndef_ripper((yyval.val) = tLEQ); }
7266 #line 7262 "ripper.c" /* yacc.c:1646 */
7267  break;
7268 
7269  case 148:
7270 #line 2076 "ripper.y" /* yacc.c:1646 */
7271  { ifndef_ripper((yyval.val) = tNEQ); }
7272 #line 7268 "ripper.c" /* yacc.c:1646 */
7273  break;
7274 
7275  case 149:
7276 #line 2077 "ripper.y" /* yacc.c:1646 */
7277  { ifndef_ripper((yyval.val) = tLSHFT); }
7278 #line 7274 "ripper.c" /* yacc.c:1646 */
7279  break;
7280 
7281  case 150:
7282 #line 2078 "ripper.y" /* yacc.c:1646 */
7283  { ifndef_ripper((yyval.val) = tRSHFT); }
7284 #line 7280 "ripper.c" /* yacc.c:1646 */
7285  break;
7286 
7287  case 151:
7288 #line 2079 "ripper.y" /* yacc.c:1646 */
7289  { ifndef_ripper((yyval.val) = '+'); }
7290 #line 7286 "ripper.c" /* yacc.c:1646 */
7291  break;
7292 
7293  case 152:
7294 #line 2080 "ripper.y" /* yacc.c:1646 */
7295  { ifndef_ripper((yyval.val) = '-'); }
7296 #line 7292 "ripper.c" /* yacc.c:1646 */
7297  break;
7298 
7299  case 153:
7300 #line 2081 "ripper.y" /* yacc.c:1646 */
7301  { ifndef_ripper((yyval.val) = '*'); }
7302 #line 7298 "ripper.c" /* yacc.c:1646 */
7303  break;
7304 
7305  case 154:
7306 #line 2082 "ripper.y" /* yacc.c:1646 */
7307  { ifndef_ripper((yyval.val) = '*'); }
7308 #line 7304 "ripper.c" /* yacc.c:1646 */
7309  break;
7310 
7311  case 155:
7312 #line 2083 "ripper.y" /* yacc.c:1646 */
7313  { ifndef_ripper((yyval.val) = '/'); }
7314 #line 7310 "ripper.c" /* yacc.c:1646 */
7315  break;
7316 
7317  case 156:
7318 #line 2084 "ripper.y" /* yacc.c:1646 */
7319  { ifndef_ripper((yyval.val) = '%'); }
7320 #line 7316 "ripper.c" /* yacc.c:1646 */
7321  break;
7322 
7323  case 157:
7324 #line 2085 "ripper.y" /* yacc.c:1646 */
7325  { ifndef_ripper((yyval.val) = tPOW); }
7326 #line 7322 "ripper.c" /* yacc.c:1646 */
7327  break;
7328 
7329  case 158:
7330 #line 2086 "ripper.y" /* yacc.c:1646 */
7331  { ifndef_ripper((yyval.val) = tDSTAR); }
7332 #line 7328 "ripper.c" /* yacc.c:1646 */
7333  break;
7334 
7335  case 159:
7336 #line 2087 "ripper.y" /* yacc.c:1646 */
7337  { ifndef_ripper((yyval.val) = '!'); }
7338 #line 7334 "ripper.c" /* yacc.c:1646 */
7339  break;
7340 
7341  case 160:
7342 #line 2088 "ripper.y" /* yacc.c:1646 */
7343  { ifndef_ripper((yyval.val) = '~'); }
7344 #line 7340 "ripper.c" /* yacc.c:1646 */
7345  break;
7346 
7347  case 161:
7348 #line 2089 "ripper.y" /* yacc.c:1646 */
7349  { ifndef_ripper((yyval.val) = tUPLUS); }
7350 #line 7346 "ripper.c" /* yacc.c:1646 */
7351  break;
7352 
7353  case 162:
7354 #line 2090 "ripper.y" /* yacc.c:1646 */
7355  { ifndef_ripper((yyval.val) = tUMINUS); }
7356 #line 7352 "ripper.c" /* yacc.c:1646 */
7357  break;
7358 
7359  case 163:
7360 #line 2091 "ripper.y" /* yacc.c:1646 */
7361  { ifndef_ripper((yyval.val) = tAREF); }
7362 #line 7358 "ripper.c" /* yacc.c:1646 */
7363  break;
7364 
7365  case 164:
7366 #line 2092 "ripper.y" /* yacc.c:1646 */
7367  { ifndef_ripper((yyval.val) = tASET); }
7368 #line 7364 "ripper.c" /* yacc.c:1646 */
7369  break;
7370 
7371  case 165:
7372 #line 2093 "ripper.y" /* yacc.c:1646 */
7373  { ifndef_ripper((yyval.val) = '`'); }
7374 #line 7370 "ripper.c" /* yacc.c:1646 */
7375  break;
7376 
7377  case 207:
7378 #line 2111 "ripper.y" /* yacc.c:1646 */
7379  {
7380 #if 0
7381  (yyval.val) = node_assign(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
7382 #endif
7383  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(assign,v1,v2);(yyval.val)=v3;}
7384  }
7385 #line 7381 "ripper.c" /* yacc.c:1646 */
7386  break;
7387 
7388  case 208:
7389 #line 2118 "ripper.y" /* yacc.c:1646 */
7390  {
7391 #if 0
7392  (yyval.val) = new_op_assign(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7393 #endif
7394  {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;}
7395  }
7396 #line 7392 "ripper.c" /* yacc.c:1646 */
7397  break;
7398 
7399  case 209:
7400 #line 2125 "ripper.y" /* yacc.c:1646 */
7401  {
7402 #if 0
7403  value_expr((yyvsp[0].val));
7404  (yyval.val) = new_ary_op_assign(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-3]), &(yyloc));
7405 #endif
7406  {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;}
7407  }
7408 #line 7404 "ripper.c" /* yacc.c:1646 */
7409  break;
7410 
7411  case 210:
7412 #line 2133 "ripper.y" /* yacc.c:1646 */
7413  {
7414 #if 0
7415  value_expr((yyvsp[0].val));
7416  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), (yyvsp[-3].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7417 #endif
7418  {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;}
7419  }
7420 #line 7416 "ripper.c" /* yacc.c:1646 */
7421  break;
7422 
7423  case 211:
7424 #line 2141 "ripper.y" /* yacc.c:1646 */
7425  {
7426 #if 0
7427  value_expr((yyvsp[0].val));
7428  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), (yyvsp[-3].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7429 #endif
7430  {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;}
7431  }
7432 #line 7428 "ripper.c" /* yacc.c:1646 */
7433  break;
7434 
7435  case 212:
7436 #line 2149 "ripper.y" /* yacc.c:1646 */
7437  {
7438 #if 0
7439  value_expr((yyvsp[0].val));
7440  (yyval.val) = new_attr_op_assign(p, (yyvsp[-4].val), ID2VAL(idCOLON2), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7441 #endif
7442  {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;}
7443  }
7444 #line 7440 "ripper.c" /* yacc.c:1646 */
7445  break;
7446 
7447  case 213:
7448 #line 2157 "ripper.y" /* yacc.c:1646 */
7449  {
7450 #if 0
7451  YYLTYPE loc = code_loc_gen(&(yylsp[-4]), &(yylsp[-2]));
7452  (yyval.val) = new_const_op_assign(p, NEW_COLON2((yyvsp[-4].val), (yyvsp[-2].val), &loc), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7453 #endif
7454  {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;}
7455  }
7456 #line 7452 "ripper.c" /* yacc.c:1646 */
7457  break;
7458 
7459  case 214:
7460 #line 2165 "ripper.y" /* yacc.c:1646 */
7461  {
7462 #if 0
7463  (yyval.val) = new_const_op_assign(p, NEW_COLON3((yyvsp[-2].val), &(yyloc)), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
7464 #endif
7465  {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;}
7466  }
7467 #line 7463 "ripper.c" /* yacc.c:1646 */
7468  break;
7469 
7470  case 215:
7471 #line 2172 "ripper.y" /* yacc.c:1646 */
7472  {
7473 #if 0
7474  rb_backref_error(p, (yyvsp[-2].val));
7475  (yyval.val) = NEW_BEGIN(0, &(yyloc));
7476 #endif
7477  {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);
7478  }
7479 #line 7475 "ripper.c" /* yacc.c:1646 */
7480  break;
7481 
7482  case 216:
7483 #line 2180 "ripper.y" /* yacc.c:1646 */
7484  {
7485 #if 0
7486  value_expr((yyvsp[-2].val));
7487  value_expr((yyvsp[0].val));
7488  (yyval.val) = NEW_DOT2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
7489 #endif
7490  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
7491  }
7492 #line 7488 "ripper.c" /* yacc.c:1646 */
7493  break;
7494 
7495  case 217:
7496 #line 2189 "ripper.y" /* yacc.c:1646 */
7497  {
7498 #if 0
7499  value_expr((yyvsp[-2].val));
7500  value_expr((yyvsp[0].val));
7501  (yyval.val) = NEW_DOT3((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
7502 #endif
7503  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
7504  }
7505 #line 7501 "ripper.c" /* yacc.c:1646 */
7506  break;
7507 
7508  case 218:
7509 #line 2198 "ripper.y" /* yacc.c:1646 */
7510  {
7511 #if 0
7512  YYLTYPE loc;
7513  loc.beg_pos = (yylsp[0]).end_pos;
7514  loc.end_pos = (yylsp[0]).end_pos;
7515 
7516  value_expr((yyvsp[-1].val));
7517  (yyval.val) = NEW_DOT2((yyvsp[-1].val), new_nil(&loc), &(yyloc));
7518 #endif
7519  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
7520  }
7521 #line 7517 "ripper.c" /* yacc.c:1646 */
7522  break;
7523 
7524  case 219:
7525 #line 2210 "ripper.y" /* yacc.c:1646 */
7526  {
7527 #if 0
7528  YYLTYPE loc;
7529  loc.beg_pos = (yylsp[0]).end_pos;
7530  loc.end_pos = (yylsp[0]).end_pos;
7531 
7532  value_expr((yyvsp[-1].val));
7533  (yyval.val) = NEW_DOT3((yyvsp[-1].val), new_nil(&loc), &(yyloc));
7534 #endif
7535  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
7536  }
7537 #line 7533 "ripper.c" /* yacc.c:1646 */
7538  break;
7539 
7540  case 220:
7541 #line 2222 "ripper.y" /* yacc.c:1646 */
7542  {
7543 #if 0
7544  YYLTYPE loc;
7545  loc.beg_pos = (yylsp[-1]).beg_pos;
7546  loc.end_pos = (yylsp[-1]).beg_pos;
7547 
7548  value_expr((yyvsp[0].val));
7549  (yyval.val) = NEW_DOT2(new_nil(&loc), (yyvsp[0].val), &(yyloc));
7550 #endif
7551  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[0].val);v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
7552  }
7553 #line 7549 "ripper.c" /* yacc.c:1646 */
7554  break;
7555 
7556  case 221:
7557 #line 2234 "ripper.y" /* yacc.c:1646 */
7558  {
7559 #if 0
7560  YYLTYPE loc;
7561  loc.beg_pos = (yylsp[-1]).beg_pos;
7562  loc.end_pos = (yylsp[-1]).beg_pos;
7563 
7564  value_expr((yyvsp[0].val));
7565  (yyval.val) = NEW_DOT3(new_nil(&loc), (yyvsp[0].val), &(yyloc));
7566 #endif
7567  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[0].val);v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
7568  }
7569 #line 7565 "ripper.c" /* yacc.c:1646 */
7570  break;
7571 
7572  case 222:
7573 #line 2246 "ripper.y" /* yacc.c:1646 */
7574  {
7575  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '+', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7576  }
7577 #line 7573 "ripper.c" /* yacc.c:1646 */
7578  break;
7579 
7580  case 223:
7581 #line 2250 "ripper.y" /* yacc.c:1646 */
7582  {
7583  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '-', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7584  }
7585 #line 7581 "ripper.c" /* yacc.c:1646 */
7586  break;
7587 
7588  case 224:
7589 #line 2254 "ripper.y" /* yacc.c:1646 */
7590  {
7591  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '*', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7592  }
7593 #line 7589 "ripper.c" /* yacc.c:1646 */
7594  break;
7595 
7596  case 225:
7597 #line 2258 "ripper.y" /* yacc.c:1646 */
7598  {
7599  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '/', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7600  }
7601 #line 7597 "ripper.c" /* yacc.c:1646 */
7602  break;
7603 
7604  case 226:
7605 #line 2262 "ripper.y" /* yacc.c:1646 */
7606  {
7607  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '%', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7608  }
7609 #line 7605 "ripper.c" /* yacc.c:1646 */
7610  break;
7611 
7612  case 227:
7613 #line 2266 "ripper.y" /* yacc.c:1646 */
7614  {
7615  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idPow, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7616  }
7617 #line 7613 "ripper.c" /* yacc.c:1646 */
7618  break;
7619 
7620  case 228:
7621 #line 2270 "ripper.y" /* yacc.c:1646 */
7622  {
7623  (yyval.val) = call_uni_op(p, call_bin_op(p, (yyvsp[-2].val), idPow, (yyvsp[0].val), &(yylsp[-2]), &(yyloc)), idUMinus, &(yylsp[-3]), &(yyloc));
7624  }
7625 #line 7621 "ripper.c" /* yacc.c:1646 */
7626  break;
7627 
7628  case 229:
7629 #line 2274 "ripper.y" /* yacc.c:1646 */
7630  {
7631  (yyval.val) = call_uni_op(p, (yyvsp[0].val), idUPlus, &(yylsp[-1]), &(yyloc));
7632  }
7633 #line 7629 "ripper.c" /* yacc.c:1646 */
7634  break;
7635 
7636  case 230:
7637 #line 2278 "ripper.y" /* yacc.c:1646 */
7638  {
7639  (yyval.val) = call_uni_op(p, (yyvsp[0].val), idUMinus, &(yylsp[-1]), &(yyloc));
7640  }
7641 #line 7637 "ripper.c" /* yacc.c:1646 */
7642  break;
7643 
7644  case 231:
7645 #line 2282 "ripper.y" /* yacc.c:1646 */
7646  {
7647  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '|', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7648  }
7649 #line 7645 "ripper.c" /* yacc.c:1646 */
7650  break;
7651 
7652  case 232:
7653 #line 2286 "ripper.y" /* yacc.c:1646 */
7654  {
7655  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '^', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7656  }
7657 #line 7653 "ripper.c" /* yacc.c:1646 */
7658  break;
7659 
7660  case 233:
7661 #line 2290 "ripper.y" /* yacc.c:1646 */
7662  {
7663  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), '&', (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7664  }
7665 #line 7661 "ripper.c" /* yacc.c:1646 */
7666  break;
7667 
7668  case 234:
7669 #line 2294 "ripper.y" /* yacc.c:1646 */
7670  {
7671  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idCmp, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7672  }
7673 #line 7669 "ripper.c" /* yacc.c:1646 */
7674  break;
7675 
7676  case 236:
7677 #line 2299 "ripper.y" /* yacc.c:1646 */
7678  {
7679  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idEq, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7680  }
7681 #line 7677 "ripper.c" /* yacc.c:1646 */
7682  break;
7683 
7684  case 237:
7685 #line 2303 "ripper.y" /* yacc.c:1646 */
7686  {
7687  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idEqq, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7688  }
7689 #line 7685 "ripper.c" /* yacc.c:1646 */
7690  break;
7691 
7692  case 238:
7693 #line 2307 "ripper.y" /* yacc.c:1646 */
7694  {
7695  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idNeq, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7696  }
7697 #line 7693 "ripper.c" /* yacc.c:1646 */
7698  break;
7699 
7700  case 239:
7701 #line 2311 "ripper.y" /* yacc.c:1646 */
7702  {
7703  (yyval.val) = match_op(p, (yyvsp[-2].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7704  }
7705 #line 7701 "ripper.c" /* yacc.c:1646 */
7706  break;
7707 
7708  case 240:
7709 #line 2315 "ripper.y" /* yacc.c:1646 */
7710  {
7711  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idNeqTilde, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7712  }
7713 #line 7709 "ripper.c" /* yacc.c:1646 */
7714  break;
7715 
7716  case 241:
7717 #line 2319 "ripper.y" /* yacc.c:1646 */
7718  {
7719  (yyval.val) = call_uni_op(p, method_cond(p, (yyvsp[0].val), &(yylsp[0])), '!', &(yylsp[-1]), &(yyloc));
7720  }
7721 #line 7717 "ripper.c" /* yacc.c:1646 */
7722  break;
7723 
7724  case 242:
7725 #line 2323 "ripper.y" /* yacc.c:1646 */
7726  {
7727  (yyval.val) = call_uni_op(p, (yyvsp[0].val), '~', &(yylsp[-1]), &(yyloc));
7728  }
7729 #line 7725 "ripper.c" /* yacc.c:1646 */
7730  break;
7731 
7732  case 243:
7733 #line 2327 "ripper.y" /* yacc.c:1646 */
7734  {
7735  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idLTLT, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7736  }
7737 #line 7733 "ripper.c" /* yacc.c:1646 */
7738  break;
7739 
7740  case 244:
7741 #line 2331 "ripper.y" /* yacc.c:1646 */
7742  {
7743  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), idGTGT, (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7744  }
7745 #line 7741 "ripper.c" /* yacc.c:1646 */
7746  break;
7747 
7748  case 245:
7749 #line 2335 "ripper.y" /* yacc.c:1646 */
7750  {
7751  (yyval.val) = logop(p, idANDOP, (yyvsp[-2].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7752  }
7753 #line 7749 "ripper.c" /* yacc.c:1646 */
7754  break;
7755 
7756  case 246:
7757 #line 2339 "ripper.y" /* yacc.c:1646 */
7758  {
7759  (yyval.val) = logop(p, idOROP, (yyvsp[-2].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7760  }
7761 #line 7757 "ripper.c" /* yacc.c:1646 */
7762  break;
7763 
7764  case 247:
7765 #line 2342 "ripper.y" /* yacc.c:1646 */
7766  {p->in_defined = 1;}
7767 #line 7763 "ripper.c" /* yacc.c:1646 */
7768  break;
7769 
7770  case 248:
7771 #line 2343 "ripper.y" /* yacc.c:1646 */
7772  {
7773  p->in_defined = 0;
7774  (yyval.val) = new_defined(p, (yyvsp[0].val), &(yyloc));
7775  }
7776 #line 7772 "ripper.c" /* yacc.c:1646 */
7777  break;
7778 
7779  case 249:
7780 #line 2348 "ripper.y" /* yacc.c:1646 */
7781  {
7782 #if 0
7783  value_expr((yyvsp[-5].val));
7784  (yyval.val) = new_if(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[0].val), &(yyloc));
7785  fixpos((yyval.val), (yyvsp[-5].val));
7786 #endif
7787  {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;}
7788  }
7789 #line 7785 "ripper.c" /* yacc.c:1646 */
7790  break;
7791 
7792  case 250:
7793 #line 2357 "ripper.y" /* yacc.c:1646 */
7794  {
7795  (yyval.val) = (yyvsp[0].val);
7796  }
7797 #line 7793 "ripper.c" /* yacc.c:1646 */
7798  break;
7799 
7800  case 251:
7801 #line 2362 "ripper.y" /* yacc.c:1646 */
7802  {(yyval.val) = '>';}
7803 #line 7799 "ripper.c" /* yacc.c:1646 */
7804  break;
7805 
7806  case 252:
7807 #line 2363 "ripper.y" /* yacc.c:1646 */
7808  {(yyval.val) = '<';}
7809 #line 7805 "ripper.c" /* yacc.c:1646 */
7810  break;
7811 
7812  case 253:
7813 #line 2364 "ripper.y" /* yacc.c:1646 */
7814  {(yyval.val) = idGE;}
7815 #line 7811 "ripper.c" /* yacc.c:1646 */
7816  break;
7817 
7818  case 254:
7819 #line 2365 "ripper.y" /* yacc.c:1646 */
7820  {(yyval.val) = idLE;}
7821 #line 7817 "ripper.c" /* yacc.c:1646 */
7822  break;
7823 
7824  case 255:
7825 #line 2369 "ripper.y" /* yacc.c:1646 */
7826  {
7827  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7828  }
7829 #line 7825 "ripper.c" /* yacc.c:1646 */
7830  break;
7831 
7832  case 256:
7833 #line 2373 "ripper.y" /* yacc.c:1646 */
7834  {
7835  rb_warning1("comparison '%s' after comparison", WARN_ID((yyvsp[-1].val)));
7836  (yyval.val) = call_bin_op(p, (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
7837  }
7838 #line 7834 "ripper.c" /* yacc.c:1646 */
7839  break;
7840 
7841  case 257:
7842 #line 2380 "ripper.y" /* yacc.c:1646 */
7843  {
7844  value_expr((yyvsp[0].val));
7845  (yyval.val) = (yyvsp[0].val);
7846  }
7847 #line 7843 "ripper.c" /* yacc.c:1646 */
7848  break;
7849 
7850  case 259:
7851 #line 2388 "ripper.y" /* yacc.c:1646 */
7852  {
7853  (yyval.val) = (yyvsp[-1].val);
7854  }
7855 #line 7851 "ripper.c" /* yacc.c:1646 */
7856  break;
7857 
7858  case 260:
7859 #line 2392 "ripper.y" /* yacc.c:1646 */
7860  {
7861 #if 0
7862  (yyval.val) = (yyvsp[-1].val) ? arg_append(p, (yyvsp[-3].val), new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].val);
7863 #endif
7864  {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;}
7865  }
7866 #line 7862 "ripper.c" /* yacc.c:1646 */
7867  break;
7868 
7869  case 261:
7870 #line 2399 "ripper.y" /* yacc.c:1646 */
7871  {
7872 #if 0
7873  (yyval.val) = (yyvsp[-1].val) ? NEW_LIST(new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yyloc)) : 0;
7874 #endif
7875  {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;}
7876  }
7877 #line 7873 "ripper.c" /* yacc.c:1646 */
7878  break;
7879 
7880  case 262:
7881 #line 2408 "ripper.y" /* yacc.c:1646 */
7882  {
7883  value_expr((yyvsp[0].val));
7884  (yyval.val) = (yyvsp[0].val);
7885  }
7886 #line 7882 "ripper.c" /* yacc.c:1646 */
7887  break;
7888 
7889  case 263:
7890 #line 2413 "ripper.y" /* yacc.c:1646 */
7891  {
7892 #if 0
7893  YYLTYPE loc = code_loc_gen(&(yylsp[-1]), &(yylsp[0]));
7894  value_expr((yyvsp[-2].val));
7895  (yyval.val) = NEW_RESCUE((yyvsp[-2].val), NEW_RESBODY(0, remove_begin((yyvsp[0].val)), 0, &loc), 0, &(yyloc));
7896 #endif
7897  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(rescue_mod,v1,v2);(yyval.val)=v3;}
7898  }
7899 #line 7895 "ripper.c" /* yacc.c:1646 */
7900  break;
7901 
7902  case 264:
7903 #line 2424 "ripper.y" /* yacc.c:1646 */
7904  {
7905 #if 0
7906  (yyval.val) = (yyvsp[-1].val);
7907 #endif
7908  {VALUE v1,v2;v1=escape_Qundef((yyvsp[-1].val));v2=dispatch1(arg_paren,v1);(yyval.val)=v2;}
7909  }
7910 #line 7906 "ripper.c" /* yacc.c:1646 */
7911  break;
7912 
7913  case 265:
7914 #line 2431 "ripper.y" /* yacc.c:1646 */
7915  {
7916  if (!local_id(p, idFWD_REST) ||
7917 #if idFWD_KWREST
7918  !local_id(p, idFWD_KWREST) ||
7919 #endif
7920  !local_id(p, idFWD_BLOCK)) {
7921  compile_error(p, "unexpected ...");
7922  (yyval.val) = Qnone;
7923  }
7924  else {
7925 #if 0
7926  NODE *splat = NEW_SPLAT(NEW_LVAR(idFWD_REST, &(yylsp[-1])), &(yylsp[-1]));
7927 #if idFWD_KWREST
7928  NODE *kwrest = list_append(p, NEW_LIST(0, &(yylsp[-1])), NEW_LVAR(idFWD_KWREST, &(yylsp[-1])));
7929 #endif
7930  NODE *block = NEW_BLOCK_PASS(NEW_LVAR(idFWD_BLOCK, &(yylsp[-1])), &(yylsp[-1]));
7931 #if idFWD_KWREST
7932  (yyval.val) = arg_append(p, splat, new_hash(p, kwrest, &(yylsp[-1])), &(yylsp[-1]));
7933 #else
7934  (yyval.val) = splat;
7935 #endif
7936  (yyval.val) = arg_blk_pass((yyval.val), block);
7937 #endif
7938  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(arg_paren,v1);(yyval.val)=v2;}
7939  }
7940  }
7941 #line 7937 "ripper.c" /* yacc.c:1646 */
7942  break;
7943 
7944  case 270:
7945 #line 2466 "ripper.y" /* yacc.c:1646 */
7946  {
7947  (yyval.val) = (yyvsp[-1].val);
7948  }
7949 #line 7945 "ripper.c" /* yacc.c:1646 */
7950  break;
7951 
7952  case 271:
7953 #line 2470 "ripper.y" /* yacc.c:1646 */
7954  {
7955 #if 0
7956  (yyval.val) = (yyvsp[-1].val) ? arg_append(p, (yyvsp[-3].val), new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].val);
7957 #endif
7958  {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;}
7959  }
7960 #line 7956 "ripper.c" /* yacc.c:1646 */
7961  break;
7962 
7963  case 272:
7964 #line 2477 "ripper.y" /* yacc.c:1646 */
7965  {
7966 #if 0
7967  (yyval.val) = (yyvsp[-1].val) ? NEW_LIST(new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yylsp[-1])) : 0;
7968 #endif
7969  {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;}
7970  }
7971 #line 7967 "ripper.c" /* yacc.c:1646 */
7972  break;
7973 
7974  case 273:
7975 #line 2486 "ripper.y" /* yacc.c:1646 */
7976  {
7977 #if 0
7978  value_expr((yyvsp[0].val));
7979  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
7980 #endif
7981  {VALUE v1,v2,v3,v4;v1=dispatch0(args_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(args_add,v2,v3);(yyval.val)=v4;}
7982  }
7983 #line 7979 "ripper.c" /* yacc.c:1646 */
7984  break;
7985 
7986  case 274:
7987 #line 2494 "ripper.y" /* yacc.c:1646 */
7988  {
7989 #if 0
7990  (yyval.val) = arg_blk_pass((yyvsp[-1].val), (yyvsp[0].val));
7991 #endif
7992  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(args_add_block,v1,v2);(yyval.val)=v3;}
7993  }
7994 #line 7990 "ripper.c" /* yacc.c:1646 */
7995  break;
7996 
7997  case 275:
7998 #line 2501 "ripper.y" /* yacc.c:1646 */
7999  {
8000 #if 0
8001  (yyval.val) = (yyvsp[-1].val) ? NEW_LIST(new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yylsp[-1])) : 0;
8002  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[0].val));
8003 #endif
8004  {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;}
8005  }
8006 #line 8002 "ripper.c" /* yacc.c:1646 */
8007  break;
8008 
8009  case 276:
8010 #line 2509 "ripper.y" /* yacc.c:1646 */
8011  {
8012 #if 0
8013  (yyval.val) = (yyvsp[-1].val) ? arg_append(p, (yyvsp[-3].val), new_hash(p, (yyvsp[-1].val), &(yylsp[-1])), &(yyloc)) : (yyvsp[-3].val);
8014  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[0].val));
8015 #endif
8016  {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;}
8017  }
8018 #line 8014 "ripper.c" /* yacc.c:1646 */
8019  break;
8020 
8021  case 277:
8022 #line 2517 "ripper.y" /* yacc.c:1646 */
8023  {{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;}}
8024 #line 8020 "ripper.c" /* yacc.c:1646 */
8025  break;
8026 
8027  case 278:
8028 #line 2520 "ripper.y" /* yacc.c:1646 */
8029  {
8030  /* If call_args starts with a open paren '(' or '[',
8031  * look-ahead reading of the letters calls CMDARG_PUSH(0),
8032  * but the push must be done after CMDARG_PUSH(1).
8033  * So this code makes them consistent by first cancelling
8034  * the premature CMDARG_PUSH(0), doing CMDARG_PUSH(1),
8035  * and finally redoing CMDARG_PUSH(0).
8036  */
8037  int lookahead = 0;
8038  switch (yychar) {
8039  case '(': case tLPAREN: case tLPAREN_ARG: case '[': case tLBRACK:
8040  lookahead = 1;
8041  }
8042  if (lookahead) CMDARG_POP();
8043  CMDARG_PUSH(1);
8044  if (lookahead) CMDARG_PUSH(0);
8045  }
8046 #line 8042 "ripper.c" /* yacc.c:1646 */
8047  break;
8048 
8049  case 279:
8050 #line 2538 "ripper.y" /* yacc.c:1646 */
8051  {
8052  /* call_args can be followed by tLBRACE_ARG (that does CMDARG_PUSH(0) in the lexer)
8053  * but the push must be done after CMDARG_POP() in the parser.
8054  * So this code does CMDARG_POP() to pop 0 pushed by tLBRACE_ARG,
8055  * CMDARG_POP() to pop 1 pushed by command_args,
8056  * and CMDARG_PUSH(0) to restore back the flag set by tLBRACE_ARG.
8057  */
8058  int lookahead = 0;
8059  switch (yychar) {
8060  case tLBRACE_ARG:
8061  lookahead = 1;
8062  }
8063  if (lookahead) CMDARG_POP();
8064  CMDARG_POP();
8065  if (lookahead) CMDARG_PUSH(0);
8066  (yyval.val) = (yyvsp[0].val);
8067  }
8068 #line 8064 "ripper.c" /* yacc.c:1646 */
8069  break;
8070 
8071  case 280:
8072 #line 2558 "ripper.y" /* yacc.c:1646 */
8073  {
8074 #if 0
8075  (yyval.val) = NEW_BLOCK_PASS((yyvsp[0].val), &(yyloc));
8076 #endif
8077  (yyval.val)=(yyvsp[0].val);
8078  }
8079 #line 8075 "ripper.c" /* yacc.c:1646 */
8080  break;
8081 
8082  case 281:
8083 #line 2567 "ripper.y" /* yacc.c:1646 */
8084  {
8085  (yyval.val) = (yyvsp[0].val);
8086  }
8087 #line 8083 "ripper.c" /* yacc.c:1646 */
8088  break;
8089 
8090  case 282:
8091 #line 2571 "ripper.y" /* yacc.c:1646 */
8092  {
8093  (yyval.val) = 0;
8094  }
8095 #line 8091 "ripper.c" /* yacc.c:1646 */
8096  break;
8097 
8098  case 283:
8099 #line 2577 "ripper.y" /* yacc.c:1646 */
8100  {
8101 #if 0
8102  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
8103 #endif
8104  {VALUE v1,v2,v3,v4;v1=dispatch0(args_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(args_add,v2,v3);(yyval.val)=v4;}
8105  }
8106 #line 8102 "ripper.c" /* yacc.c:1646 */
8107  break;
8108 
8109  case 284:
8110 #line 2584 "ripper.y" /* yacc.c:1646 */
8111  {
8112 #if 0
8113  (yyval.val) = NEW_SPLAT((yyvsp[0].val), &(yyloc));
8114 #endif
8115  {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;}
8116  }
8117 #line 8113 "ripper.c" /* yacc.c:1646 */
8118  break;
8119 
8120  case 285:
8121 #line 2591 "ripper.y" /* yacc.c:1646 */
8122  {
8123 #if 0
8124  (yyval.val) = last_arg_append(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
8125 #endif
8126  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(args_add,v1,v2);(yyval.val)=v3;}
8127  }
8128 #line 8124 "ripper.c" /* yacc.c:1646 */
8129  break;
8130 
8131  case 286:
8132 #line 2598 "ripper.y" /* yacc.c:1646 */
8133  {
8134 #if 0
8135  (yyval.val) = rest_arg_append(p, (yyvsp[-3].val), (yyvsp[0].val), &(yyloc));
8136 #endif
8137  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=(yyvsp[0].val);v3=dispatch2(args_add_star,v1,v2);(yyval.val)=v3;}
8138  }
8139 #line 8135 "ripper.c" /* yacc.c:1646 */
8140  break;
8141 
8142  case 289:
8143 #line 2611 "ripper.y" /* yacc.c:1646 */
8144  {
8145 #if 0
8146  (yyval.val) = last_arg_append(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
8147 #endif
8148  {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;}
8149  }
8150 #line 8146 "ripper.c" /* yacc.c:1646 */
8151  break;
8152 
8153  case 290:
8154 #line 2618 "ripper.y" /* yacc.c:1646 */
8155  {
8156 #if 0
8157  (yyval.val) = rest_arg_append(p, (yyvsp[-3].val), (yyvsp[0].val), &(yyloc));
8158 #endif
8159  {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;}
8160  }
8161 #line 8157 "ripper.c" /* yacc.c:1646 */
8162  break;
8163 
8164  case 291:
8165 #line 2625 "ripper.y" /* yacc.c:1646 */
8166  {
8167 #if 0
8168  (yyval.val) = NEW_SPLAT((yyvsp[0].val), &(yyloc));
8169 #endif
8170  {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;}
8171  }
8172 #line 8168 "ripper.c" /* yacc.c:1646 */
8173  break;
8174 
8175  case 302:
8176 #line 2644 "ripper.y" /* yacc.c:1646 */
8177  {
8178 #if 0
8179  (yyval.val) = NEW_FCALL((yyvsp[0].val), 0, &(yyloc));
8180 #endif
8181  {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;}
8182  }
8183 #line 8179 "ripper.c" /* yacc.c:1646 */
8184  break;
8185 
8186  case 303:
8187 #line 2651 "ripper.y" /* yacc.c:1646 */
8188  {
8189  CMDARG_PUSH(0);
8190  }
8191 #line 8187 "ripper.c" /* yacc.c:1646 */
8192  break;
8193 
8194  case 304:
8195 #line 2656 "ripper.y" /* yacc.c:1646 */
8196  {
8197  CMDARG_POP();
8198 #if 0
8199  set_line_body((yyvsp[-1].val), (yylsp[-3]).end_pos.lineno);
8200  (yyval.val) = NEW_BEGIN((yyvsp[-1].val), &(yyloc));
8201  nd_set_line((yyval.val), (yylsp[-3]).end_pos.lineno);
8202 #endif
8203  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(begin,v1);(yyval.val)=v2;}
8204  }
8205 #line 8201 "ripper.c" /* yacc.c:1646 */
8206  break;
8207 
8208  case 305:
8209 #line 2665 "ripper.y" /* yacc.c:1646 */
8210  {SET_LEX_STATE(EXPR_ENDARG);}
8211 #line 8207 "ripper.c" /* yacc.c:1646 */
8212  break;
8213 
8214  case 306:
8215 #line 2666 "ripper.y" /* yacc.c:1646 */
8216  {
8217 #if 0
8218  (yyval.val) = NEW_BEGIN(0, &(yyloc));
8219 #endif
8220  {VALUE v1,v2;v1=0;v2=dispatch1(paren,v1);(yyval.val)=v2;}
8221  }
8222 #line 8218 "ripper.c" /* yacc.c:1646 */
8223  break;
8224 
8225  case 307:
8226 #line 2672 "ripper.y" /* yacc.c:1646 */
8227  {SET_LEX_STATE(EXPR_ENDARG);}
8228 #line 8224 "ripper.c" /* yacc.c:1646 */
8229  break;
8230 
8231  case 308:
8232 #line 2673 "ripper.y" /* yacc.c:1646 */
8233  {
8234 #if 0
8235  if (nd_type((yyvsp[-2].val)) == NODE_SELF) (yyvsp[-2].val)->nd_state = 0;
8236  (yyval.val) = (yyvsp[-2].val);
8237 #endif
8238  {VALUE v1,v2;v1=(yyvsp[-2].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
8239  }
8240 #line 8236 "ripper.c" /* yacc.c:1646 */
8241  break;
8242 
8243  case 309:
8244 #line 2681 "ripper.y" /* yacc.c:1646 */
8245  {
8246 #if 0
8247  if (nd_type((yyvsp[-1].val)) == NODE_SELF) (yyvsp[-1].val)->nd_state = 0;
8248  (yyval.val) = (yyvsp[-1].val);
8249 #endif
8250  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
8251  }
8252 #line 8248 "ripper.c" /* yacc.c:1646 */
8253  break;
8254 
8255  case 310:
8256 #line 2689 "ripper.y" /* yacc.c:1646 */
8257  {
8258 #if 0
8259  (yyval.val) = NEW_COLON2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
8260 #endif
8261  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(const_path_ref,v1,v2);(yyval.val)=v3;}
8262  }
8263 #line 8259 "ripper.c" /* yacc.c:1646 */
8264  break;
8265 
8266  case 311:
8267 #line 2696 "ripper.y" /* yacc.c:1646 */
8268  {
8269 #if 0
8270  (yyval.val) = NEW_COLON3((yyvsp[0].val), &(yyloc));
8271 #endif
8272  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(top_const_ref,v1);(yyval.val)=v2;}
8273  }
8274 #line 8270 "ripper.c" /* yacc.c:1646 */
8275  break;
8276 
8277  case 312:
8278 #line 2703 "ripper.y" /* yacc.c:1646 */
8279  {
8280 #if 0
8281  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
8282 #endif
8283  {VALUE v1,v2;v1=escape_Qundef((yyvsp[-1].val));v2=dispatch1(array,v1);(yyval.val)=v2;}
8284  }
8285 #line 8281 "ripper.c" /* yacc.c:1646 */
8286  break;
8287 
8288  case 313:
8289 #line 2710 "ripper.y" /* yacc.c:1646 */
8290  {
8291 #if 0
8292  (yyval.val) = new_hash(p, (yyvsp[-1].val), &(yyloc));
8293  (yyval.val)->nd_brace = TRUE;
8294 #endif
8295  {VALUE v1,v2;v1=escape_Qundef((yyvsp[-1].val));v2=dispatch1(hash,v1);(yyval.val)=v2;}
8296  }
8297 #line 8293 "ripper.c" /* yacc.c:1646 */
8298  break;
8299 
8300  case 314:
8301 #line 2718 "ripper.y" /* yacc.c:1646 */
8302  {
8303 #if 0
8304  (yyval.val) = NEW_RETURN(0, &(yyloc));
8305 #endif
8306  {VALUE v1;v1=dispatch0(return0);(yyval.val)=v1;}
8307  }
8308 #line 8304 "ripper.c" /* yacc.c:1646 */
8309  break;
8310 
8311  case 315:
8312 #line 2725 "ripper.y" /* yacc.c:1646 */
8313  {
8314 #if 0
8315  (yyval.val) = new_yield(p, (yyvsp[-1].val), &(yyloc));
8316 #endif
8317  {VALUE v1,v2,v3,v4;v1=(yyvsp[-1].val);v2=dispatch1(paren,v1);v3=v2;v4=dispatch1(yield,v3);(yyval.val)=v4;}
8318  }
8319 #line 8315 "ripper.c" /* yacc.c:1646 */
8320  break;
8321 
8322  case 316:
8323 #line 2732 "ripper.y" /* yacc.c:1646 */
8324  {
8325 #if 0
8326  (yyval.val) = NEW_YIELD(0, &(yyloc));
8327 #endif
8328  {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;}
8329  }
8330 #line 8326 "ripper.c" /* yacc.c:1646 */
8331  break;
8332 
8333  case 317:
8334 #line 2739 "ripper.y" /* yacc.c:1646 */
8335  {
8336 #if 0
8337  (yyval.val) = NEW_YIELD(0, &(yyloc));
8338 #endif
8339  {VALUE v1;v1=dispatch0(yield0);(yyval.val)=v1;}
8340  }
8341 #line 8337 "ripper.c" /* yacc.c:1646 */
8342  break;
8343 
8344  case 318:
8345 #line 2745 "ripper.y" /* yacc.c:1646 */
8346  {p->in_defined = 1;}
8347 #line 8343 "ripper.c" /* yacc.c:1646 */
8348  break;
8349 
8350  case 319:
8351 #line 2746 "ripper.y" /* yacc.c:1646 */
8352  {
8353  p->in_defined = 0;
8354  (yyval.val) = new_defined(p, (yyvsp[-1].val), &(yyloc));
8355  }
8356 #line 8352 "ripper.c" /* yacc.c:1646 */
8357  break;
8358 
8359  case 320:
8360 #line 2751 "ripper.y" /* yacc.c:1646 */
8361  {
8362  (yyval.val) = call_uni_op(p, method_cond(p, (yyvsp[-1].val), &(yylsp[-1])), METHOD_NOT, &(yylsp[-3]), &(yyloc));
8363  }
8364 #line 8360 "ripper.c" /* yacc.c:1646 */
8365  break;
8366 
8367  case 321:
8368 #line 2755 "ripper.y" /* yacc.c:1646 */
8369  {
8370  (yyval.val) = call_uni_op(p, method_cond(p, new_nil(&(yylsp[-1])), &(yylsp[-1])), METHOD_NOT, &(yylsp[-2]), &(yyloc));
8371  }
8372 #line 8368 "ripper.c" /* yacc.c:1646 */
8373  break;
8374 
8375  case 322:
8376 #line 2759 "ripper.y" /* yacc.c:1646 */
8377  {
8378 #if 0
8379  (yyval.val) = method_add_block(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
8380 #endif
8381  {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;}
8382  }
8383 #line 8379 "ripper.c" /* yacc.c:1646 */
8384  break;
8385 
8386  case 324:
8387 #line 2767 "ripper.y" /* yacc.c:1646 */
8388  {
8389 #if 0
8390  block_dup_check(p, (yyvsp[-1].val)->nd_args, (yyvsp[0].val));
8391  (yyval.val) = method_add_block(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
8392 #endif
8393  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(method_add_block,v1,v2);(yyval.val)=v3;}
8394  }
8395 #line 8391 "ripper.c" /* yacc.c:1646 */
8396  break;
8397 
8398  case 325:
8399 #line 2775 "ripper.y" /* yacc.c:1646 */
8400  {
8401  token_info_push(p, "->", &(yylsp[0]));
8402  }
8403 #line 8399 "ripper.c" /* yacc.c:1646 */
8404  break;
8405 
8406  case 326:
8407 #line 2779 "ripper.y" /* yacc.c:1646 */
8408  {
8409  (yyval.val) = (yyvsp[0].val);
8410 #if 0
8411  nd_set_first_loc((yyval.val), (yylsp[-2]).beg_pos);
8412 #endif
8413  }
8414 #line 8410 "ripper.c" /* yacc.c:1646 */
8415  break;
8416 
8417  case 327:
8418 #line 2789 "ripper.y" /* yacc.c:1646 */
8419  {
8420 #if 0
8421  (yyval.val) = new_if(p, (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), &(yyloc));
8422  fixpos((yyval.val), (yyvsp[-4].val));
8423 #endif
8424  {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;}
8425  }
8426 #line 8422 "ripper.c" /* yacc.c:1646 */
8427  break;
8428 
8429  case 328:
8430 #line 2800 "ripper.y" /* yacc.c:1646 */
8431  {
8432 #if 0
8433  (yyval.val) = new_unless(p, (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), &(yyloc));
8434  fixpos((yyval.val), (yyvsp[-4].val));
8435 #endif
8436  {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;}
8437  }
8438 #line 8434 "ripper.c" /* yacc.c:1646 */
8439  break;
8440 
8441  case 329:
8442 #line 2810 "ripper.y" /* yacc.c:1646 */
8443  {
8444 #if 0
8445  (yyval.val) = NEW_WHILE(cond(p, (yyvsp[-2].val), &(yylsp[-2])), (yyvsp[-1].val), 1, &(yyloc));
8446  fixpos((yyval.val), (yyvsp[-2].val));
8447 #endif
8448  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(while,v1,v2);(yyval.val)=v3;}
8449  }
8450 #line 8446 "ripper.c" /* yacc.c:1646 */
8451  break;
8452 
8453  case 330:
8454 #line 2820 "ripper.y" /* yacc.c:1646 */
8455  {
8456 #if 0
8457  (yyval.val) = NEW_UNTIL(cond(p, (yyvsp[-2].val), &(yylsp[-2])), (yyvsp[-1].val), 1, &(yyloc));
8458  fixpos((yyval.val), (yyvsp[-2].val));
8459 #endif
8460  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(until,v1,v2);(yyval.val)=v3;}
8461  }
8462 #line 8458 "ripper.c" /* yacc.c:1646 */
8463  break;
8464 
8465  case 331:
8466 #line 2828 "ripper.y" /* yacc.c:1646 */
8467  {
8468  (yyval.val) = p->case_labels;
8469  p->case_labels = Qnil;
8470  }
8471 #line 8467 "ripper.c" /* yacc.c:1646 */
8472  break;
8473 
8474  case 332:
8475 #line 2834 "ripper.y" /* yacc.c:1646 */
8476  {
8478  p->case_labels = (yyvsp[-2].val);
8479 #if 0
8480  (yyval.val) = NEW_CASE((yyvsp[-4].val), (yyvsp[-1].val), &(yyloc));
8481  fixpos((yyval.val), (yyvsp[-4].val));
8482 #endif
8483  {VALUE v1,v2,v3;v1=(yyvsp[-4].val);v2=(yyvsp[-1].val);v3=dispatch2(case,v1,v2);(yyval.val)=v3;}
8484  }
8485 #line 8481 "ripper.c" /* yacc.c:1646 */
8486  break;
8487 
8488  case 333:
8489 #line 2844 "ripper.y" /* yacc.c:1646 */
8490  {
8491  (yyval.val) = p->case_labels;
8492  p->case_labels = 0;
8493  }
8494 #line 8490 "ripper.c" /* yacc.c:1646 */
8495  break;
8496 
8497  case 334:
8498 #line 2850 "ripper.y" /* yacc.c:1646 */
8499  {
8501  p->case_labels = (yyvsp[-2].val);
8502 #if 0
8503  (yyval.val) = NEW_CASE2((yyvsp[-1].val), &(yyloc));
8504 #endif
8505  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[-1].val);v3=dispatch2(case,v1,v2);(yyval.val)=v3;}
8506  }
8507 #line 8503 "ripper.c" /* yacc.c:1646 */
8508  break;
8509 
8510  case 335:
8511 #line 2861 "ripper.y" /* yacc.c:1646 */
8512  {
8513 #if 0
8514  (yyval.val) = new_case3(p, (yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
8515 #endif
8516  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=(yyvsp[-1].val);v3=dispatch2(case,v1,v2);(yyval.val)=v3;}
8517  }
8518 #line 8514 "ripper.c" /* yacc.c:1646 */
8519  break;
8520 
8521  case 336:
8522 #line 2870 "ripper.y" /* yacc.c:1646 */
8523  {
8524 #if 0
8525  /*
8526  * for a, b, c in e
8527  * #=>
8528  * e.each{|*x| a, b, c = x}
8529  *
8530  * for a in e
8531  * #=>
8532  * e.each{|x| a, = x}
8533  */
8534  ID id = internal_id(p);
8535  NODE *m = NEW_ARGS_AUX(0, 0, &NULL_LOC);
8536  NODE *args, *scope, *internal_var = NEW_DVAR(id, &(yylsp[-4]));
8538  ID *tbl = ALLOC_N(ID, 3);
8539  rb_imemo_tmpbuf_set_ptr(tmpbuf, tbl);
8540  tbl[0] = 1 /* length of local var table */; tbl[1] = id /* internal id */;
8541  tbl[2] = tmpbuf;
8542 
8543  switch (nd_type((yyvsp[-4].val))) {
8544  case NODE_LASGN:
8545  case NODE_DASGN:
8546  case NODE_DASGN_CURR: /* e.each {|internal_var| a = internal_var; ... } */
8547  (yyvsp[-4].val)->nd_value = internal_var;
8548  id = 0;
8549  m->nd_plen = 1;
8550  m->nd_next = (yyvsp[-4].val);
8551  break;
8552  case NODE_MASGN: /* e.each {|*internal_var| a, b, c = (internal_var.length == 1 && Array === (tmp = internal_var[0]) ? tmp : internal_var); ... } */
8553  m->nd_next = node_assign(p, (yyvsp[-4].val), NEW_FOR_MASGN(internal_var, &(yylsp[-4])), &(yylsp[-4]));
8554  break;
8555  default: /* e.each {|*internal_var| @a, B, c[1], d.attr = internal_val; ... } */
8556  m->nd_next = node_assign(p, NEW_MASGN(NEW_LIST((yyvsp[-4].val), &(yylsp[-4])), 0, &(yylsp[-4])), internal_var, &(yylsp[-4]));
8557  }
8558  /* {|*internal_id| <m> = internal_id; ... } */
8559  args = new_args(p, m, 0, id, 0, new_args_tail(p, 0, 0, 0, &(yylsp[-4])), &(yylsp[-4]));
8560  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[-1].val), args, &(yyloc));
8561  RB_OBJ_WRITTEN(p->ast, Qnil, tmpbuf);
8562  (yyval.val) = NEW_FOR((yyvsp[-2].val), scope, &(yyloc));
8563  fixpos((yyval.val), (yyvsp[-4].val));
8564 #endif
8565  {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;}
8566  }
8567 #line 8563 "ripper.c" /* yacc.c:1646 */
8568  break;
8569 
8570  case 337:
8571 #line 2915 "ripper.y" /* yacc.c:1646 */
8572  {
8573  if (p->in_def) {
8574  YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[-1]));
8575  yyerror1(&loc, "class definition in method body");
8576  }
8577  (yyvsp[-2].num) = p->in_class;
8578  p->in_class = 1;
8579  local_push(p, 0);
8580  }
8581 #line 8577 "ripper.c" /* yacc.c:1646 */
8582  break;
8583 
8584  case 338:
8585 #line 2926 "ripper.y" /* yacc.c:1646 */
8586  {
8587 #if 0
8588  (yyval.val) = NEW_CLASS((yyvsp[-4].val), (yyvsp[-1].val), (yyvsp[-3].val), &(yyloc));
8589  nd_set_line((yyval.val)->nd_body, (yylsp[0]).end_pos.lineno);
8590  set_line_body((yyvsp[-1].val), (yylsp[-3]).end_pos.lineno);
8591  nd_set_line((yyval.val), (yylsp[-3]).end_pos.lineno);
8592 #endif
8593  {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;}
8594  local_pop(p);
8595  p->in_class = (yyvsp[-5].num) & 1;
8596  }
8597 #line 8593 "ripper.c" /* yacc.c:1646 */
8598  break;
8599 
8600  case 339:
8601 #line 2938 "ripper.y" /* yacc.c:1646 */
8602  {
8603  (yyval.num) = (p->in_class << 1) | p->in_def;
8604  p->in_def = 0;
8605  p->in_class = 0;
8606  local_push(p, 0);
8607  }
8608 #line 8604 "ripper.c" /* yacc.c:1646 */
8609  break;
8610 
8611  case 340:
8612 #line 2947 "ripper.y" /* yacc.c:1646 */
8613  {
8614 #if 0
8615  (yyval.val) = NEW_SCLASS((yyvsp[-4].val), (yyvsp[-1].val), &(yyloc));
8616  nd_set_line((yyval.val)->nd_body, (yylsp[0]).end_pos.lineno);
8617  set_line_body((yyvsp[-1].val), nd_line((yyvsp[-4].val)));
8618  fixpos((yyval.val), (yyvsp[-4].val));
8619 #endif
8620  {VALUE v1,v2,v3;v1=(yyvsp[-4].val);v2=(yyvsp[-1].val);v3=dispatch2(sclass,v1,v2);(yyval.val)=v3;}
8621  local_pop(p);
8622  p->in_def = (yyvsp[-3].num) & 1;
8623  p->in_class = ((yyvsp[-3].num) >> 1) & 1;
8624  }
8625 #line 8621 "ripper.c" /* yacc.c:1646 */
8626  break;
8627 
8628  case 341:
8629 #line 2960 "ripper.y" /* yacc.c:1646 */
8630  {
8631  if (p->in_def) {
8632  YYLTYPE loc = code_loc_gen(&(yylsp[-1]), &(yylsp[0]));
8633  yyerror1(&loc, "module definition in method body");
8634  }
8635  (yyvsp[-1].num) = p->in_class;
8636  p->in_class = 1;
8637  local_push(p, 0);
8638  }
8639 #line 8635 "ripper.c" /* yacc.c:1646 */
8640  break;
8641 
8642  case 342:
8643 #line 2971 "ripper.y" /* yacc.c:1646 */
8644  {
8645 #if 0
8646  (yyval.val) = NEW_MODULE((yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
8647  nd_set_line((yyval.val)->nd_body, (yylsp[0]).end_pos.lineno);
8648  set_line_body((yyvsp[-1].val), (yylsp[-3]).end_pos.lineno);
8649  nd_set_line((yyval.val), (yylsp[-3]).end_pos.lineno);
8650 #endif
8651  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=(yyvsp[-1].val);v3=dispatch2(module,v1,v2);(yyval.val)=v3;}
8652  local_pop(p);
8653  p->in_class = (yyvsp[-4].num) & 1;
8654  }
8655 #line 8651 "ripper.c" /* yacc.c:1646 */
8656  break;
8657 
8658  case 343:
8659 #line 2983 "ripper.y" /* yacc.c:1646 */
8660  {
8661  numparam_name(p, get_id((yyvsp[0].val)));
8662  local_push(p, 0);
8663  (yyval.id) = p->cur_arg;
8664  p->cur_arg = 0;
8665  }
8666 #line 8662 "ripper.c" /* yacc.c:1646 */
8667  break;
8668 
8669  case 344:
8670 #line 2989 "ripper.y" /* yacc.c:1646 */
8671  {
8672  (yyval.num) = p->in_def;
8673  p->in_def = 1;
8674  }
8675 #line 8671 "ripper.c" /* yacc.c:1646 */
8676  break;
8677 
8678  case 345:
8679 #line 2996 "ripper.y" /* yacc.c:1646 */
8680  {
8681 #if 0
8682  NODE *body = remove_begin((yyvsp[-1].val));
8683  reduce_nodes(p, &body);
8684  (yyval.val) = NEW_DEFN((yyvsp[-5].val), (yyvsp[-2].val), body, &(yyloc));
8685  nd_set_line((yyval.val)->nd_defn, (yylsp[0]).end_pos.lineno);
8686  set_line_body(body, (yylsp[-6]).beg_pos.lineno);
8687 #endif
8688  {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;}
8689  local_pop(p);
8690  p->in_def = (yyvsp[-3].num) & 1;
8691  p->cur_arg = (yyvsp[-4].id);
8692  }
8693 #line 8689 "ripper.c" /* yacc.c:1646 */
8694  break;
8695 
8696  case 346:
8697 #line 3009 "ripper.y" /* yacc.c:1646 */
8698  {SET_LEX_STATE(EXPR_FNAME);}
8699 #line 8695 "ripper.c" /* yacc.c:1646 */
8700  break;
8701 
8702  case 347:
8703 #line 3010 "ripper.y" /* yacc.c:1646 */
8704  {
8705  numparam_name(p, get_id((yyvsp[0].val)));
8706  (yyvsp[-1].num) = p->in_def;
8707  p->in_def = 1;
8708  SET_LEX_STATE(EXPR_ENDFN|EXPR_LABEL); /* force for args */
8709  local_push(p, 0);
8710  (yyval.id) = p->cur_arg;
8711  p->cur_arg = 0;
8712  }
8713 #line 8709 "ripper.c" /* yacc.c:1646 */
8714  break;
8715 
8716  case 348:
8717 #line 3022 "ripper.y" /* yacc.c:1646 */
8718  {
8719 #if 0
8720  NODE *body = remove_begin((yyvsp[-1].val));
8721  reduce_nodes(p, &body);
8722  (yyval.val) = NEW_DEFS((yyvsp[-7].val), (yyvsp[-4].val), (yyvsp[-2].val), body, &(yyloc));
8723  nd_set_line((yyval.val)->nd_defn, (yylsp[0]).end_pos.lineno);
8724  set_line_body(body, (yylsp[-8]).beg_pos.lineno);
8725 #endif
8726  {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;}
8727  local_pop(p);
8728  p->in_def = (yyvsp[-5].num) & 1;
8729  p->cur_arg = (yyvsp[-3].id);
8730  }
8731 #line 8727 "ripper.c" /* yacc.c:1646 */
8732  break;
8733 
8734  case 349:
8735 #line 3036 "ripper.y" /* yacc.c:1646 */
8736  {
8737 #if 0
8738  (yyval.val) = NEW_BREAK(0, &(yyloc));
8739 #endif
8740  {VALUE v1,v2,v3;v1=dispatch0(args_new);v2=v1;v3=dispatch1(break,v2);(yyval.val)=v3;}
8741  }
8742 #line 8738 "ripper.c" /* yacc.c:1646 */
8743  break;
8744 
8745  case 350:
8746 #line 3043 "ripper.y" /* yacc.c:1646 */
8747  {
8748 #if 0
8749  (yyval.val) = NEW_NEXT(0, &(yyloc));
8750 #endif
8751  {VALUE v1,v2,v3;v1=dispatch0(args_new);v2=v1;v3=dispatch1(next,v2);(yyval.val)=v3;}
8752  }
8753 #line 8749 "ripper.c" /* yacc.c:1646 */
8754  break;
8755 
8756  case 351:
8757 #line 3050 "ripper.y" /* yacc.c:1646 */
8758  {
8759 #if 0
8760  (yyval.val) = NEW_REDO(&(yyloc));
8761 #endif
8762  {VALUE v1;v1=dispatch0(redo);(yyval.val)=v1;}
8763  }
8764 #line 8760 "ripper.c" /* yacc.c:1646 */
8765  break;
8766 
8767  case 352:
8768 #line 3057 "ripper.y" /* yacc.c:1646 */
8769  {
8770 #if 0
8771  (yyval.val) = NEW_RETRY(&(yyloc));
8772 #endif
8773  {VALUE v1;v1=dispatch0(retry);(yyval.val)=v1;}
8774  }
8775 #line 8771 "ripper.c" /* yacc.c:1646 */
8776  break;
8777 
8778  case 353:
8779 #line 3066 "ripper.y" /* yacc.c:1646 */
8780  {
8781  value_expr((yyvsp[0].val));
8782  (yyval.val) = (yyvsp[0].val);
8783  }
8784 #line 8780 "ripper.c" /* yacc.c:1646 */
8785  break;
8786 
8787  case 354:
8788 #line 3073 "ripper.y" /* yacc.c:1646 */
8789  {
8790  token_info_push(p, "begin", &(yyloc));
8791  }
8792 #line 8788 "ripper.c" /* yacc.c:1646 */
8793  break;
8794 
8795  case 355:
8796 #line 3079 "ripper.y" /* yacc.c:1646 */
8797  {
8798  WARN_EOL("if");
8799  token_info_push(p, "if", &(yyloc));
8800  if (p->token_info && p->token_info->nonspc &&
8801  p->token_info->next && !strcmp(p->token_info->next->token, "else")) {
8802  const char *tok = p->lex.ptok;
8803  const char *beg = p->lex.pbeg + p->token_info->next->beg.column;
8804  beg += rb_strlen_lit("else");
8805  while (beg < tok && ISSPACE(*beg)) beg++;
8806  if (beg == tok) {
8807  p->token_info->nonspc = 0;
8808  }
8809  }
8810  }
8811 #line 8807 "ripper.c" /* yacc.c:1646 */
8812  break;
8813 
8814  case 356:
8815 #line 3096 "ripper.y" /* yacc.c:1646 */
8816  {
8817  token_info_push(p, "unless", &(yyloc));
8818  }
8819 #line 8815 "ripper.c" /* yacc.c:1646 */
8820  break;
8821 
8822  case 357:
8823 #line 3102 "ripper.y" /* yacc.c:1646 */
8824  {
8825  token_info_push(p, "while", &(yyloc));
8826  }
8827 #line 8823 "ripper.c" /* yacc.c:1646 */
8828  break;
8829 
8830  case 358:
8831 #line 3108 "ripper.y" /* yacc.c:1646 */
8832  {
8833  token_info_push(p, "until", &(yyloc));
8834  }
8835 #line 8831 "ripper.c" /* yacc.c:1646 */
8836  break;
8837 
8838  case 359:
8839 #line 3114 "ripper.y" /* yacc.c:1646 */
8840  {
8841  token_info_push(p, "case", &(yyloc));
8842  }
8843 #line 8839 "ripper.c" /* yacc.c:1646 */
8844  break;
8845 
8846  case 360:
8847 #line 3120 "ripper.y" /* yacc.c:1646 */
8848  {
8849  token_info_push(p, "for", &(yyloc));
8850  }
8851 #line 8847 "ripper.c" /* yacc.c:1646 */
8852  break;
8853 
8854  case 361:
8855 #line 3126 "ripper.y" /* yacc.c:1646 */
8856  {
8857  token_info_push(p, "class", &(yyloc));
8858  }
8859 #line 8855 "ripper.c" /* yacc.c:1646 */
8860  break;
8861 
8862  case 362:
8863 #line 3132 "ripper.y" /* yacc.c:1646 */
8864  {
8865  token_info_push(p, "module", &(yyloc));
8866  }
8867 #line 8863 "ripper.c" /* yacc.c:1646 */
8868  break;
8869 
8870  case 363:
8871 #line 3138 "ripper.y" /* yacc.c:1646 */
8872  {
8873  token_info_push(p, "def", &(yyloc));
8874  }
8875 #line 8871 "ripper.c" /* yacc.c:1646 */
8876  break;
8877 
8878  case 364:
8879 #line 3144 "ripper.y" /* yacc.c:1646 */
8880  {
8881  token_info_push(p, "do", &(yyloc));
8882  }
8883 #line 8879 "ripper.c" /* yacc.c:1646 */
8884  break;
8885 
8886  case 365:
8887 #line 3150 "ripper.y" /* yacc.c:1646 */
8888  {
8889  token_info_push(p, "do", &(yyloc));
8890  }
8891 #line 8887 "ripper.c" /* yacc.c:1646 */
8892  break;
8893 
8894  case 366:
8895 #line 3156 "ripper.y" /* yacc.c:1646 */
8896  {
8897  token_info_warn(p, "rescue", p->token_info, 1, &(yyloc));
8898  }
8899 #line 8895 "ripper.c" /* yacc.c:1646 */
8900  break;
8901 
8902  case 367:
8903 #line 3162 "ripper.y" /* yacc.c:1646 */
8904  {
8905  token_info_warn(p, "ensure", p->token_info, 1, &(yyloc));
8906  }
8907 #line 8903 "ripper.c" /* yacc.c:1646 */
8908  break;
8909 
8910  case 368:
8911 #line 3168 "ripper.y" /* yacc.c:1646 */
8912  {
8913  token_info_warn(p, "when", p->token_info, 0, &(yyloc));
8914  }
8915 #line 8911 "ripper.c" /* yacc.c:1646 */
8916  break;
8917 
8918  case 369:
8919 #line 3174 "ripper.y" /* yacc.c:1646 */
8920  {
8921  token_info *ptinfo_beg = p->token_info;
8922  int same = ptinfo_beg && strcmp(ptinfo_beg->token, "case") != 0;
8923  token_info_warn(p, "else", p->token_info, same, &(yyloc));
8924  if (same) {
8925  token_info e;
8926  e.next = ptinfo_beg->next;
8927  e.token = "else";
8928  token_info_setup(&e, p->lex.pbeg, &(yyloc));
8929  if (!e.nonspc) *ptinfo_beg = e;
8930  }
8931  }
8932 #line 8928 "ripper.c" /* yacc.c:1646 */
8933  break;
8934 
8935  case 370:
8936 #line 3189 "ripper.y" /* yacc.c:1646 */
8937  {
8938  WARN_EOL("elsif");
8939  token_info_warn(p, "elsif", p->token_info, 1, &(yyloc));
8940  }
8941 #line 8937 "ripper.c" /* yacc.c:1646 */
8942  break;
8943 
8944  case 371:
8945 #line 3196 "ripper.y" /* yacc.c:1646 */
8946  {
8947  token_info_pop(p, "end", &(yyloc));
8948  }
8949 #line 8945 "ripper.c" /* yacc.c:1646 */
8950  break;
8951 
8952  case 372:
8953 #line 3202 "ripper.y" /* yacc.c:1646 */
8954  {
8955  if (p->in_class && !p->in_def && !dyna_in_block(p))
8956  yyerror1(&(yylsp[0]), "Invalid return in class/module body");
8957  }
8958 #line 8954 "ripper.c" /* yacc.c:1646 */
8959  break;
8960 
8961  case 379:
8962 #line 3221 "ripper.y" /* yacc.c:1646 */
8963  {
8964 #if 0
8965  (yyval.val) = new_if(p, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
8966  fixpos((yyval.val), (yyvsp[-3].val));
8967 #endif
8968  {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;}
8969  }
8970 #line 8966 "ripper.c" /* yacc.c:1646 */
8971  break;
8972 
8973  case 381:
8974 #line 3232 "ripper.y" /* yacc.c:1646 */
8975  {
8976 #if 0
8977  (yyval.val) = (yyvsp[0].val);
8978 #endif
8979  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(else,v1);(yyval.val)=v2;}
8980  }
8981 #line 8977 "ripper.c" /* yacc.c:1646 */
8982  break;
8983 
8984  case 384:
8985 #line 3245 "ripper.y" /* yacc.c:1646 */
8986  {
8987 #if 0
8988  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
8989  mark_lvar_used(p, (yyval.val));
8990 #endif
8991  (yyval.val)=assignable(p, (yyvsp[0].val));
8992  }
8993 #line 8989 "ripper.c" /* yacc.c:1646 */
8994  break;
8995 
8996  case 385:
8997 #line 3253 "ripper.y" /* yacc.c:1646 */
8998  {
8999 #if 0
9000  (yyval.val) = (yyvsp[-1].val);
9001 #endif
9002  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(mlhs_paren,v1);(yyval.val)=v2;}
9003  }
9004 #line 9000 "ripper.c" /* yacc.c:1646 */
9005  break;
9006 
9007  case 386:
9008 #line 3262 "ripper.y" /* yacc.c:1646 */
9009  {
9010 #if 0
9011  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
9012 #endif
9013  {VALUE v1,v2,v3,v4;v1=dispatch0(mlhs_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(mlhs_add,v2,v3);(yyval.val)=v4;}
9014  }
9015 #line 9011 "ripper.c" /* yacc.c:1646 */
9016  break;
9017 
9018  case 387:
9019 #line 3269 "ripper.y" /* yacc.c:1646 */
9020  {
9021 #if 0
9022  (yyval.val) = list_append(p, (yyvsp[-2].val), (yyvsp[0].val));
9023 #endif
9024  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(mlhs_add,v1,v2);(yyval.val)=v3;}
9025  }
9026 #line 9022 "ripper.c" /* yacc.c:1646 */
9027  break;
9028 
9029  case 388:
9030 #line 3278 "ripper.y" /* yacc.c:1646 */
9031  {
9032 #if 0
9033  (yyval.val) = NEW_MASGN((yyvsp[0].val), 0, &(yyloc));
9034 #endif
9035  (yyval.val)=(yyvsp[0].val);
9036  }
9037 #line 9033 "ripper.c" /* yacc.c:1646 */
9038  break;
9039 
9040  case 389:
9041 #line 3285 "ripper.y" /* yacc.c:1646 */
9042  {
9043 #if 0
9044  (yyval.val) = NEW_MASGN((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
9045 #endif
9046  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(mlhs_add_star,v1,v2);(yyval.val)=v3;}
9047  }
9048 #line 9044 "ripper.c" /* yacc.c:1646 */
9049  break;
9050 
9051  case 390:
9052 #line 3292 "ripper.y" /* yacc.c:1646 */
9053  {
9054 #if 0
9055  (yyval.val) = NEW_MASGN((yyvsp[-4].val), NEW_POSTARG((yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
9056 #endif
9057  {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;}
9058  }
9059 #line 9055 "ripper.c" /* yacc.c:1646 */
9060  break;
9061 
9062  case 391:
9063 #line 3299 "ripper.y" /* yacc.c:1646 */
9064  {
9065 #if 0
9066  (yyval.val) = NEW_MASGN(0, (yyvsp[0].val), &(yyloc));
9067 #endif
9068  {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;}
9069  }
9070 #line 9066 "ripper.c" /* yacc.c:1646 */
9071  break;
9072 
9073  case 392:
9074 #line 3306 "ripper.y" /* yacc.c:1646 */
9075  {
9076 #if 0
9077  (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
9078 #endif
9079  {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;}
9080  }
9081 #line 9077 "ripper.c" /* yacc.c:1646 */
9082  break;
9083 
9084  case 393:
9085 #line 3315 "ripper.y" /* yacc.c:1646 */
9086  {
9087 #if 0
9088  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
9089  mark_lvar_used(p, (yyval.val));
9090 #endif
9091  (yyval.val)=assignable(p, (yyvsp[0].val));
9092  }
9093 #line 9089 "ripper.c" /* yacc.c:1646 */
9094  break;
9095 
9096  case 394:
9097 #line 3323 "ripper.y" /* yacc.c:1646 */
9098  {
9099 #if 0
9100  (yyval.val) = NODE_SPECIAL_NO_NAME_REST;
9101 #endif
9102  (yyval.val)=Qnil;
9103  }
9104 #line 9100 "ripper.c" /* yacc.c:1646 */
9105  break;
9106 
9107  case 395:
9108 #line 3332 "ripper.y" /* yacc.c:1646 */
9109  {
9110  (yyval.val) = new_args_tail(p, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]));
9111  }
9112 #line 9108 "ripper.c" /* yacc.c:1646 */
9113  break;
9114 
9115  case 396:
9116 #line 3336 "ripper.y" /* yacc.c:1646 */
9117  {
9118  (yyval.val) = new_args_tail(p, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yylsp[-1]));
9119  }
9120 #line 9116 "ripper.c" /* yacc.c:1646 */
9121  break;
9122 
9123  case 397:
9124 #line 3340 "ripper.y" /* yacc.c:1646 */
9125  {
9126  (yyval.val) = new_args_tail(p, Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]));
9127  }
9128 #line 9124 "ripper.c" /* yacc.c:1646 */
9129  break;
9130 
9131  case 398:
9132 #line 3344 "ripper.y" /* yacc.c:1646 */
9133  {
9134  (yyval.val) = new_args_tail(p, Qnone, ID2VAL(idNil), (yyvsp[0].val), &(yylsp[-1]));
9135  }
9136 #line 9132 "ripper.c" /* yacc.c:1646 */
9137  break;
9138 
9139  case 399:
9140 #line 3348 "ripper.y" /* yacc.c:1646 */
9141  {
9142  (yyval.val) = new_args_tail(p, Qnone, Qnone, (yyvsp[0].val), &(yylsp[0]));
9143  }
9144 #line 9140 "ripper.c" /* yacc.c:1646 */
9145  break;
9146 
9147  case 400:
9148 #line 3354 "ripper.y" /* yacc.c:1646 */
9149  {
9150  (yyval.val) = (yyvsp[0].val);
9151  }
9152 #line 9148 "ripper.c" /* yacc.c:1646 */
9153  break;
9154 
9155  case 401:
9156 #line 3358 "ripper.y" /* yacc.c:1646 */
9157  {
9158  (yyval.val) = new_args_tail(p, Qnone, Qnone, Qnone, &(yylsp[0]));
9159  }
9160 #line 9156 "ripper.c" /* yacc.c:1646 */
9161  break;
9162 
9163  case 402:
9164 #line 3364 "ripper.y" /* yacc.c:1646 */
9165  {
9166  (yyval.val) = new_args(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
9167  }
9168 #line 9164 "ripper.c" /* yacc.c:1646 */
9169  break;
9170 
9171  case 403:
9172 #line 3368 "ripper.y" /* yacc.c:1646 */
9173  {
9174  (yyval.val) = new_args(p, (yyvsp[-7].val), (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9175  }
9176 #line 9172 "ripper.c" /* yacc.c:1646 */
9177  break;
9178 
9179  case 404:
9180 #line 3372 "ripper.y" /* yacc.c:1646 */
9181  {
9182  (yyval.val) = new_args(p, (yyvsp[-3].val), (yyvsp[-1].val), Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9183  }
9184 #line 9180 "ripper.c" /* yacc.c:1646 */
9185  break;
9186 
9187  case 405:
9188 #line 3376 "ripper.y" /* yacc.c:1646 */
9189  {
9190  (yyval.val) = new_args(p, (yyvsp[-5].val), (yyvsp[-3].val), Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9191  }
9192 #line 9188 "ripper.c" /* yacc.c:1646 */
9193  break;
9194 
9195  case 406:
9196 #line 3380 "ripper.y" /* yacc.c:1646 */
9197  {
9198  (yyval.val) = new_args(p, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
9199  }
9200 #line 9196 "ripper.c" /* yacc.c:1646 */
9201  break;
9202 
9203  case 407:
9204 #line 3384 "ripper.y" /* yacc.c:1646 */
9205  {
9206 #if 0
9207  /* magic number for rest_id in iseq_set_arguments() */
9208  (yyval.val) = new_args(p, (yyvsp[-1].val), Qnone, NODE_SPECIAL_EXCESSIVE_COMMA, Qnone, new_args_tail(p, Qnone, Qnone, Qnone, &(yylsp[-1])), &(yyloc));
9209 #endif
9210  {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);}
9211  }
9212 #line 9208 "ripper.c" /* yacc.c:1646 */
9213  break;
9214 
9215  case 408:
9216 #line 3392 "ripper.y" /* yacc.c:1646 */
9217  {
9218  (yyval.val) = new_args(p, (yyvsp[-5].val), Qnone, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9219  }
9220 #line 9216 "ripper.c" /* yacc.c:1646 */
9221  break;
9222 
9223  case 409:
9224 #line 3396 "ripper.y" /* yacc.c:1646 */
9225  {
9226  (yyval.val) = new_args(p, (yyvsp[-1].val), Qnone, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9227  }
9228 #line 9224 "ripper.c" /* yacc.c:1646 */
9229  break;
9230 
9231  case 410:
9232 #line 3400 "ripper.y" /* yacc.c:1646 */
9233  {
9234  (yyval.val) = new_args(p, Qnone, (yyvsp[-3].val), (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
9235  }
9236 #line 9232 "ripper.c" /* yacc.c:1646 */
9237  break;
9238 
9239  case 411:
9240 #line 3404 "ripper.y" /* yacc.c:1646 */
9241  {
9242  (yyval.val) = new_args(p, Qnone, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9243  }
9244 #line 9240 "ripper.c" /* yacc.c:1646 */
9245  break;
9246 
9247  case 412:
9248 #line 3408 "ripper.y" /* yacc.c:1646 */
9249  {
9250  (yyval.val) = new_args(p, Qnone, (yyvsp[-1].val), Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9251  }
9252 #line 9248 "ripper.c" /* yacc.c:1646 */
9253  break;
9254 
9255  case 413:
9256 #line 3412 "ripper.y" /* yacc.c:1646 */
9257  {
9258  (yyval.val) = new_args(p, Qnone, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9259  }
9260 #line 9256 "ripper.c" /* yacc.c:1646 */
9261  break;
9262 
9263  case 414:
9264 #line 3416 "ripper.y" /* yacc.c:1646 */
9265  {
9266  (yyval.val) = new_args(p, Qnone, Qnone, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
9267  }
9268 #line 9264 "ripper.c" /* yacc.c:1646 */
9269  break;
9270 
9271  case 415:
9272 #line 3420 "ripper.y" /* yacc.c:1646 */
9273  {
9274  (yyval.val) = new_args(p, Qnone, Qnone, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9275  }
9276 #line 9272 "ripper.c" /* yacc.c:1646 */
9277  break;
9278 
9279  case 416:
9280 #line 3424 "ripper.y" /* yacc.c:1646 */
9281  {
9282  (yyval.val) = new_args(p, Qnone, Qnone, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9283  }
9284 #line 9280 "ripper.c" /* yacc.c:1646 */
9285  break;
9286 
9287  case 418:
9288 #line 3431 "ripper.y" /* yacc.c:1646 */
9289  {
9290  p->command_start = TRUE;
9291  }
9292 #line 9288 "ripper.c" /* yacc.c:1646 */
9293  break;
9294 
9295  case 419:
9296 #line 3437 "ripper.y" /* yacc.c:1646 */
9297  {
9298  p->cur_arg = 0;
9300 #if 0
9301  (yyval.val) = 0;
9302 #endif
9303  {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;}
9304  }
9305 #line 9301 "ripper.c" /* yacc.c:1646 */
9306  break;
9307 
9308  case 420:
9309 #line 3446 "ripper.y" /* yacc.c:1646 */
9310  {
9311  p->cur_arg = 0;
9313 #if 0
9314  (yyval.val) = (yyvsp[-2].val);
9315 #endif
9316  {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;}
9317  }
9318 #line 9314 "ripper.c" /* yacc.c:1646 */
9319  break;
9320 
9321  case 421:
9322 #line 3458 "ripper.y" /* yacc.c:1646 */
9323  {
9324  (yyval.val) = 0;
9325  }
9326 #line 9322 "ripper.c" /* yacc.c:1646 */
9327  break;
9328 
9329  case 422:
9330 #line 3462 "ripper.y" /* yacc.c:1646 */
9331  {
9332 #if 0
9333  (yyval.val) = 0;
9334 #endif
9335  (yyval.val)=(yyvsp[-1].val);
9336  }
9337 #line 9333 "ripper.c" /* yacc.c:1646 */
9338  break;
9339 
9340  case 423:
9341 #line 3471 "ripper.y" /* yacc.c:1646 */
9342  {(yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));}
9343 #line 9339 "ripper.c" /* yacc.c:1646 */
9344  break;
9345 
9346  case 424:
9347 #line 3473 "ripper.y" /* yacc.c:1646 */
9348  {(yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));}
9349 #line 9345 "ripper.c" /* yacc.c:1646 */
9350  break;
9351 
9352  case 425:
9353 #line 3477 "ripper.y" /* yacc.c:1646 */
9354  {
9355  new_bv(p, get_id((yyvsp[0].val)));
9356  (yyval.val)=get_value((yyvsp[0].val));
9357  }
9358 #line 9354 "ripper.c" /* yacc.c:1646 */
9359  break;
9360 
9361  case 426:
9362 #line 3482 "ripper.y" /* yacc.c:1646 */
9363  {
9364  (yyval.val) = 0;
9365  }
9366 #line 9362 "ripper.c" /* yacc.c:1646 */
9367  break;
9368 
9369  case 427:
9370 #line 3487 "ripper.y" /* yacc.c:1646 */
9371  {
9372  (yyval.vars) = dyna_push(p);
9373  }
9374 #line 9370 "ripper.c" /* yacc.c:1646 */
9375  break;
9376 
9377  case 428:
9378 #line 3490 "ripper.y" /* yacc.c:1646 */
9379  {
9380  (yyval.num) = p->lex.lpar_beg;
9381  p->lex.lpar_beg = p->lex.paren_nest;
9382  }
9383 #line 9379 "ripper.c" /* yacc.c:1646 */
9384  break;
9385 
9386  case 429:
9387 #line 3494 "ripper.y" /* yacc.c:1646 */
9388  {
9389  (yyval.num) = p->max_numparam;
9390  p->max_numparam = 0;
9391  }
9392 #line 9388 "ripper.c" /* yacc.c:1646 */
9393  break;
9394 
9395  case 430:
9396 #line 3498 "ripper.y" /* yacc.c:1646 */
9397  {
9398  (yyval.node) = numparam_push(p);
9399  }
9400 #line 9396 "ripper.c" /* yacc.c:1646 */
9401  break;
9402 
9403  case 431:
9404 #line 3502 "ripper.y" /* yacc.c:1646 */
9405  {
9406  CMDARG_PUSH(0);
9407  }
9408 #line 9404 "ripper.c" /* yacc.c:1646 */
9409  break;
9410 
9411  case 432:
9412 #line 3506 "ripper.y" /* yacc.c:1646 */
9413  {
9414  int max_numparam = p->max_numparam;
9415  p->lex.lpar_beg = (yyvsp[-5].num);
9416  p->max_numparam = (yyvsp[-4].num);
9417  CMDARG_POP();
9418  (yyvsp[-2].val) = args_with_numbered(p, (yyvsp[-2].val), max_numparam);
9419 #if 0
9420  {
9421  YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
9422  (yyval.val) = NEW_LAMBDA((yyvsp[-2].val), (yyvsp[0].val), &loc);
9423  nd_set_line((yyval.val)->nd_body, (yylsp[0]).end_pos.lineno);
9424  nd_set_line((yyval.val), (yylsp[-2]).end_pos.lineno);
9425  }
9426 #endif
9427  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(lambda,v1,v2);(yyval.val)=v3;}
9428  numparam_pop(p, (yyvsp[-3].node));
9429  dyna_pop(p, (yyvsp[-6].vars));
9430  }
9431 #line 9427 "ripper.c" /* yacc.c:1646 */
9432  break;
9433 
9434  case 433:
9435 #line 3527 "ripper.y" /* yacc.c:1646 */
9436  {
9437 #if 0
9438  (yyval.val) = (yyvsp[-2].val);
9440 #endif
9441  {VALUE v1,v2;v1=(yyvsp[-2].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
9442  }
9443 #line 9439 "ripper.c" /* yacc.c:1646 */
9444  break;
9445 
9446  case 434:
9447 #line 3535 "ripper.y" /* yacc.c:1646 */
9448  {
9449 #if 0
9450  if (!args_info_empty_p((yyvsp[0].val)->nd_ainfo))
9452 #endif
9453  (yyval.val) = (yyvsp[0].val);
9454  }
9455 #line 9451 "ripper.c" /* yacc.c:1646 */
9456  break;
9457 
9458  case 435:
9459 #line 3545 "ripper.y" /* yacc.c:1646 */
9460  {
9461  token_info_pop(p, "}", &(yylsp[0]));
9462  (yyval.val) = (yyvsp[-1].val);
9463  }
9464 #line 9460 "ripper.c" /* yacc.c:1646 */
9465  break;
9466 
9467  case 436:
9468 #line 3550 "ripper.y" /* yacc.c:1646 */
9469  {
9470  (yyval.val) = (yyvsp[-1].val);
9471  }
9472 #line 9468 "ripper.c" /* yacc.c:1646 */
9473  break;
9474 
9475  case 437:
9476 #line 3556 "ripper.y" /* yacc.c:1646 */
9477  {
9478  (yyval.val) = (yyvsp[-1].val);
9479 #if 0
9480  (yyval.val)->nd_body->nd_loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
9481  nd_set_line((yyval.val), (yylsp[-2]).end_pos.lineno);
9482 #endif
9483  }
9484 #line 9480 "ripper.c" /* yacc.c:1646 */
9485  break;
9486 
9487  case 438:
9488 #line 3566 "ripper.y" /* yacc.c:1646 */
9489  {
9490 #if 0
9491  if (nd_type((yyvsp[-1].val)) == NODE_YIELD) {
9492  compile_error(p, "block given to yield");
9493  }
9494  else {
9495  block_dup_check(p, (yyvsp[-1].val)->nd_args, (yyvsp[0].val));
9496  }
9497  (yyval.val) = method_add_block(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9498  fixpos((yyval.val), (yyvsp[-1].val));
9499 #endif
9500  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(method_add_block,v1,v2);(yyval.val)=v3;}
9501  }
9502 #line 9498 "ripper.c" /* yacc.c:1646 */
9503  break;
9504 
9505  case 439:
9506 #line 3580 "ripper.y" /* yacc.c:1646 */
9507  {
9508 #if 0
9509  (yyval.val) = new_qcall(p, (yyvsp[-2].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
9510 #endif
9511  {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;}
9512  }
9513 #line 9509 "ripper.c" /* yacc.c:1646 */
9514  break;
9515 
9516  case 440:
9517 #line 3587 "ripper.y" /* yacc.c:1646 */
9518  {
9519 #if 0
9520  (yyval.val) = new_command_qcall(p, (yyvsp[-3].val), (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-2]), &(yyloc));
9521 #endif
9522  {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;}
9523  }
9524 #line 9520 "ripper.c" /* yacc.c:1646 */
9525  break;
9526 
9527  case 441:
9528 #line 3594 "ripper.y" /* yacc.c:1646 */
9529  {
9530 #if 0
9531  (yyval.val) = new_command_qcall(p, (yyvsp[-3].val), (yyvsp[-4].val), (yyvsp[-2].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-2]), &(yyloc));
9532 #endif
9533  {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;}
9534  }
9535 #line 9531 "ripper.c" /* yacc.c:1646 */
9536  break;
9537 
9538  case 442:
9539 #line 3603 "ripper.y" /* yacc.c:1646 */
9540  {
9541 #if 0
9542  (yyval.val) = (yyvsp[-1].val);
9543  (yyval.val)->nd_args = (yyvsp[0].val);
9544  nd_set_last_loc((yyvsp[-1].val), (yylsp[0]).end_pos);
9545 #endif
9546  {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;}
9547  }
9548 #line 9544 "ripper.c" /* yacc.c:1646 */
9549  break;
9550 
9551  case 443:
9552 #line 3612 "ripper.y" /* yacc.c:1646 */
9553  {
9554 #if 0
9555  (yyval.val) = new_qcall(p, (yyvsp[-2].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
9556  nd_set_line((yyval.val), (yylsp[-1]).end_pos.lineno);
9557 #endif
9558  {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;}
9559  }
9560 #line 9556 "ripper.c" /* yacc.c:1646 */
9561  break;
9562 
9563  case 444:
9564 #line 3620 "ripper.y" /* yacc.c:1646 */
9565  {
9566 #if 0
9567  (yyval.val) = new_qcall(p, ID2VAL(idCOLON2), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
9568  nd_set_line((yyval.val), (yylsp[-1]).end_pos.lineno);
9569 #endif
9570  {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;}
9571  }
9572 #line 9568 "ripper.c" /* yacc.c:1646 */
9573  break;
9574 
9575  case 445:
9576 #line 3628 "ripper.y" /* yacc.c:1646 */
9577  {
9578 #if 0
9579  (yyval.val) = new_qcall(p, ID2VAL(idCOLON2), (yyvsp[-2].val), (yyvsp[0].val), Qnull, &(yylsp[0]), &(yyloc));
9580 #endif
9581  {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;}
9582  }
9583 #line 9579 "ripper.c" /* yacc.c:1646 */
9584  break;
9585 
9586  case 446:
9587 #line 3635 "ripper.y" /* yacc.c:1646 */
9588  {
9589 #if 0
9590  (yyval.val) = new_qcall(p, (yyvsp[-1].val), (yyvsp[-2].val), ID2VAL(idCall), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
9591  nd_set_line((yyval.val), (yylsp[-1]).end_pos.lineno);
9592 #endif
9593  {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;}
9594  }
9595 #line 9591 "ripper.c" /* yacc.c:1646 */
9596  break;
9597 
9598  case 447:
9599 #line 3643 "ripper.y" /* yacc.c:1646 */
9600  {
9601 #if 0
9602  (yyval.val) = new_qcall(p, ID2VAL(idCOLON2), (yyvsp[-2].val), ID2VAL(idCall), (yyvsp[0].val), &(yylsp[-1]), &(yyloc));
9603  nd_set_line((yyval.val), (yylsp[-1]).end_pos.lineno);
9604 #endif
9605  {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;}
9606  }
9607 #line 9603 "ripper.c" /* yacc.c:1646 */
9608  break;
9609 
9610  case 448:
9611 #line 3651 "ripper.y" /* yacc.c:1646 */
9612  {
9613 #if 0
9614  (yyval.val) = NEW_SUPER((yyvsp[0].val), &(yyloc));
9615 #endif
9616  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(super,v1);(yyval.val)=v2;}
9617  }
9618 #line 9614 "ripper.c" /* yacc.c:1646 */
9619  break;
9620 
9621  case 449:
9622 #line 3658 "ripper.y" /* yacc.c:1646 */
9623  {
9624 #if 0
9625  (yyval.val) = NEW_ZSUPER(&(yyloc));
9626 #endif
9627  {VALUE v1;v1=dispatch0(zsuper);(yyval.val)=v1;}
9628  }
9629 #line 9625 "ripper.c" /* yacc.c:1646 */
9630  break;
9631 
9632  case 450:
9633 #line 3665 "ripper.y" /* yacc.c:1646 */
9634  {
9635 #if 0
9636  if ((yyvsp[-3].val) && nd_type((yyvsp[-3].val)) == NODE_SELF)
9637  (yyval.val) = NEW_FCALL(tAREF, (yyvsp[-1].val), &(yyloc));
9638  else
9639  (yyval.val) = NEW_CALL((yyvsp[-3].val), tAREF, (yyvsp[-1].val), &(yyloc));
9640  fixpos((yyval.val), (yyvsp[-3].val));
9641 #endif
9642  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=escape_Qundef((yyvsp[-1].val));v3=dispatch2(aref,v1,v2);(yyval.val)=v3;}
9643  }
9644 #line 9640 "ripper.c" /* yacc.c:1646 */
9645  break;
9646 
9647  case 451:
9648 #line 3678 "ripper.y" /* yacc.c:1646 */
9649  {
9650  (yyval.val) = (yyvsp[-1].val);
9651 #if 0
9652  (yyval.val)->nd_body->nd_loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
9653  nd_set_line((yyval.val), (yylsp[-2]).end_pos.lineno);
9654 #endif
9655  }
9656 #line 9652 "ripper.c" /* yacc.c:1646 */
9657  break;
9658 
9659  case 452:
9660 #line 3686 "ripper.y" /* yacc.c:1646 */
9661  {
9662  (yyval.val) = (yyvsp[-1].val);
9663 #if 0
9664  (yyval.val)->nd_body->nd_loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
9665  nd_set_line((yyval.val), (yylsp[-2]).end_pos.lineno);
9666 #endif
9667  }
9668 #line 9664 "ripper.c" /* yacc.c:1646 */
9669  break;
9670 
9671  case 453:
9672 #line 3695 "ripper.y" /* yacc.c:1646 */
9673  {(yyval.vars) = dyna_push(p);}
9674 #line 9670 "ripper.c" /* yacc.c:1646 */
9675  break;
9676 
9677  case 454:
9678 #line 3696 "ripper.y" /* yacc.c:1646 */
9679  {
9680  (yyval.num) = p->max_numparam;
9681  p->max_numparam = 0;
9682  }
9683 #line 9679 "ripper.c" /* yacc.c:1646 */
9684  break;
9685 
9686  case 455:
9687 #line 3700 "ripper.y" /* yacc.c:1646 */
9688  {
9689  (yyval.node) = numparam_push(p);
9690  }
9691 #line 9687 "ripper.c" /* yacc.c:1646 */
9692  break;
9693 
9694  case 456:
9695 #line 3704 "ripper.y" /* yacc.c:1646 */
9696  {
9697  int max_numparam = p->max_numparam;
9698  p->max_numparam = (yyvsp[-3].num);
9699  (yyvsp[-1].val) = args_with_numbered(p, (yyvsp[-1].val), max_numparam);
9700 #if 0
9701  (yyval.val) = NEW_ITER((yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9702 #endif
9703  {VALUE v1,v2,v3;v1=escape_Qundef((yyvsp[-1].val));v2=(yyvsp[0].val);v3=dispatch2(brace_block,v1,v2);(yyval.val)=v3;}
9704  numparam_pop(p, (yyvsp[-2].node));
9705  dyna_pop(p, (yyvsp[-4].vars));
9706  }
9707 #line 9703 "ripper.c" /* yacc.c:1646 */
9708  break;
9709 
9710  case 457:
9711 #line 3717 "ripper.y" /* yacc.c:1646 */
9712  {(yyval.vars) = dyna_push(p);}
9713 #line 9709 "ripper.c" /* yacc.c:1646 */
9714  break;
9715 
9716  case 458:
9717 #line 3718 "ripper.y" /* yacc.c:1646 */
9718  {
9719  (yyval.num) = p->max_numparam;
9720  p->max_numparam = 0;
9721  }
9722 #line 9718 "ripper.c" /* yacc.c:1646 */
9723  break;
9724 
9725  case 459:
9726 #line 3722 "ripper.y" /* yacc.c:1646 */
9727  {
9728  (yyval.node) = numparam_push(p);
9729  CMDARG_PUSH(0);
9730  }
9731 #line 9727 "ripper.c" /* yacc.c:1646 */
9732  break;
9733 
9734  case 460:
9735 #line 3727 "ripper.y" /* yacc.c:1646 */
9736  {
9737  int max_numparam = p->max_numparam;
9738  p->max_numparam = (yyvsp[-3].num);
9739  (yyvsp[-1].val) = args_with_numbered(p, (yyvsp[-1].val), max_numparam);
9740 #if 0
9741  (yyval.val) = NEW_ITER((yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9742 #endif
9743  {VALUE v1,v2,v3;v1=escape_Qundef((yyvsp[-1].val));v2=(yyvsp[0].val);v3=dispatch2(do_block,v1,v2);(yyval.val)=v3;}
9744  CMDARG_POP();
9745  numparam_pop(p, (yyvsp[-2].node));
9746  dyna_pop(p, (yyvsp[-4].vars));
9747  }
9748 #line 9744 "ripper.c" /* yacc.c:1646 */
9749  break;
9750 
9751  case 461:
9752 #line 3742 "ripper.y" /* yacc.c:1646 */
9753  {
9754 #if 0
9755  check_literal_when(p, (yyvsp[0].val), &(yylsp[0]));
9756  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
9757 #endif
9758  {VALUE v1,v2,v3,v4;v1=dispatch0(args_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(args_add,v2,v3);(yyval.val)=v4;}
9759  }
9760 #line 9756 "ripper.c" /* yacc.c:1646 */
9761  break;
9762 
9763  case 462:
9764 #line 3750 "ripper.y" /* yacc.c:1646 */
9765  {
9766 #if 0
9767  (yyval.val) = NEW_SPLAT((yyvsp[0].val), &(yyloc));
9768 #endif
9769  {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;}
9770  }
9771 #line 9767 "ripper.c" /* yacc.c:1646 */
9772  break;
9773 
9774  case 463:
9775 #line 3757 "ripper.y" /* yacc.c:1646 */
9776  {
9777 #if 0
9778  check_literal_when(p, (yyvsp[0].val), &(yylsp[0]));
9779  (yyval.val) = last_arg_append(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
9780 #endif
9781  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(args_add,v1,v2);(yyval.val)=v3;}
9782  }
9783 #line 9779 "ripper.c" /* yacc.c:1646 */
9784  break;
9785 
9786  case 464:
9787 #line 3765 "ripper.y" /* yacc.c:1646 */
9788  {
9789 #if 0
9790  (yyval.val) = rest_arg_append(p, (yyvsp[-3].val), (yyvsp[0].val), &(yyloc));
9791 #endif
9792  {VALUE v1,v2,v3;v1=(yyvsp[-3].val);v2=(yyvsp[0].val);v3=dispatch2(args_add_star,v1,v2);(yyval.val)=v3;}
9793  }
9794 #line 9790 "ripper.c" /* yacc.c:1646 */
9795  break;
9796 
9797  case 465:
9798 #line 3776 "ripper.y" /* yacc.c:1646 */
9799  {
9800 #if 0
9801  (yyval.val) = NEW_WHEN((yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9802  fixpos((yyval.val), (yyvsp[-3].val));
9803 #endif
9804  {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;}
9805  }
9806 #line 9802 "ripper.c" /* yacc.c:1646 */
9807  break;
9808 
9809  case 468:
9810 #line 3790 "ripper.y" /* yacc.c:1646 */
9811  {
9812  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
9813  p->command_start = FALSE;
9814  (yyval.num) = p->in_kwarg;
9815  p->in_kwarg = 1;
9816  }
9817 #line 9813 "ripper.c" /* yacc.c:1646 */
9818  break;
9819 
9820  case 469:
9821 #line 3796 "ripper.y" /* yacc.c:1646 */
9822  {(yyval.tbl) = push_pvtbl(p);}
9823 #line 9819 "ripper.c" /* yacc.c:1646 */
9824  break;
9825 
9826  case 470:
9827 #line 3797 "ripper.y" /* yacc.c:1646 */
9828  {(yyval.tbl) = push_pktbl(p);}
9829 #line 9825 "ripper.c" /* yacc.c:1646 */
9830  break;
9831 
9832  case 471:
9833 #line 3799 "ripper.y" /* yacc.c:1646 */
9834  {pop_pktbl(p, (yyvsp[-2].tbl));}
9835 #line 9831 "ripper.c" /* yacc.c:1646 */
9836  break;
9837 
9838  case 472:
9839 #line 3800 "ripper.y" /* yacc.c:1646 */
9840  {pop_pvtbl(p, (yyvsp[-4].tbl));}
9841 #line 9837 "ripper.c" /* yacc.c:1646 */
9842  break;
9843 
9844  case 473:
9845 #line 3801 "ripper.y" /* yacc.c:1646 */
9846  {
9847  p->in_kwarg = !!(yyvsp[-6].num);
9848  }
9849 #line 9845 "ripper.c" /* yacc.c:1646 */
9850  break;
9851 
9852  case 474:
9853 #line 3806 "ripper.y" /* yacc.c:1646 */
9854  {
9855 #if 0
9856  (yyval.val) = NEW_IN((yyvsp[-6].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
9857 #endif
9858  {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;}
9859  }
9860 #line 9856 "ripper.c" /* yacc.c:1646 */
9861  break;
9862 
9863  case 478:
9864 #line 3820 "ripper.y" /* yacc.c:1646 */
9865  {
9866 #if 0
9867  (yyval.val) = new_if(p, (yyvsp[0].val), remove_begin((yyvsp[-2].val)), 0, &(yyloc));
9868  fixpos((yyval.val), (yyvsp[0].val));
9869 #endif
9870  {VALUE v1,v2,v3;v1=(yyvsp[0].val);v2=(yyvsp[-2].val);v3=dispatch2(if_mod,v1,v2);(yyval.val)=v3;}
9871  }
9872 #line 9868 "ripper.c" /* yacc.c:1646 */
9873  break;
9874 
9875  case 479:
9876 #line 3828 "ripper.y" /* yacc.c:1646 */
9877  {
9878 #if 0
9879  (yyval.val) = new_unless(p, (yyvsp[0].val), remove_begin((yyvsp[-2].val)), 0, &(yyloc));
9880  fixpos((yyval.val), (yyvsp[0].val));
9881 #endif
9882  {VALUE v1,v2,v3;v1=(yyvsp[0].val);v2=(yyvsp[-2].val);v3=dispatch2(unless_mod,v1,v2);(yyval.val)=v3;}
9883  }
9884 #line 9880 "ripper.c" /* yacc.c:1646 */
9885  break;
9886 
9887  case 481:
9888 #line 3839 "ripper.y" /* yacc.c:1646 */
9889  {
9890  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, 0, Qnone, &(yyloc));
9891  (yyval.val) = new_array_pattern(p, Qnone, get_value((yyvsp[-1].val)), (yyval.val), &(yyloc));
9892  }
9893 #line 9889 "ripper.c" /* yacc.c:1646 */
9894  break;
9895 
9896  case 482:
9897 #line 3844 "ripper.y" /* yacc.c:1646 */
9898  {
9899  (yyval.val) = new_array_pattern(p, Qnone, get_value((yyvsp[-2].val)), (yyvsp[0].val), &(yyloc));
9900 #if 0
9901  nd_set_first_loc((yyval.val), (yylsp[-2]).beg_pos);
9902 #endif
9903 
9904  }
9905 #line 9901 "ripper.c" /* yacc.c:1646 */
9906  break;
9907 
9908  case 483:
9909 #line 3852 "ripper.y" /* yacc.c:1646 */
9910  {
9911  (yyval.val) = new_array_pattern(p, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
9912  }
9913 #line 9909 "ripper.c" /* yacc.c:1646 */
9914  break;
9915 
9916  case 484:
9917 #line 3856 "ripper.y" /* yacc.c:1646 */
9918  {
9919  (yyval.val) = new_hash_pattern(p, Qnone, (yyvsp[0].val), &(yyloc));
9920  }
9921 #line 9917 "ripper.c" /* yacc.c:1646 */
9922  break;
9923 
9924  case 486:
9925 #line 3865 "ripper.y" /* yacc.c:1646 */
9926  {
9927 #if 0
9928  NODE *n = NEW_LIST((yyvsp[-2].val), &(yyloc));
9929  n = list_append(p, n, (yyvsp[0].val));
9930  (yyval.val) = new_hash(p, n, &(yyloc));
9931 #endif
9932  {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;}
9933  }
9934 #line 9930 "ripper.c" /* yacc.c:1646 */
9935  break;
9936 
9937  case 488:
9938 #line 3877 "ripper.y" /* yacc.c:1646 */
9939  {
9940 #if 0
9941  (yyval.val) = NEW_NODE(NODE_OR, (yyvsp[-2].val), (yyvsp[0].val), 0, &(yyloc));
9942 #endif
9943  {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;}
9944  }
9945 #line 9941 "ripper.c" /* yacc.c:1646 */
9946  break;
9947 
9948  case 490:
9949 #line 3886 "ripper.y" /* yacc.c:1646 */
9950  {(yyval.tbl) = push_pktbl(p);}
9951 #line 9947 "ripper.c" /* yacc.c:1646 */
9952  break;
9953 
9954  case 491:
9955 #line 3887 "ripper.y" /* yacc.c:1646 */
9956  {(yyval.tbl) = push_pktbl(p);}
9957 #line 9953 "ripper.c" /* yacc.c:1646 */
9958  break;
9959 
9960  case 493:
9961 #line 3891 "ripper.y" /* yacc.c:1646 */
9962  {
9963  pop_pktbl(p, (yyvsp[-2].tbl));
9964  (yyval.val) = new_array_pattern(p, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), &(yyloc));
9965 #if 0
9966  nd_set_first_loc((yyval.val), (yylsp[-3]).beg_pos);
9967 #endif
9968 
9969  }
9970 #line 9966 "ripper.c" /* yacc.c:1646 */
9971  break;
9972 
9973  case 494:
9974 #line 3900 "ripper.y" /* yacc.c:1646 */
9975  {
9976  pop_pktbl(p, (yyvsp[-2].tbl));
9977  (yyval.val) = new_hash_pattern(p, (yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
9978 #if 0
9979  nd_set_first_loc((yyval.val), (yylsp[-3]).beg_pos);
9980 #endif
9981 
9982  }
9983 #line 9979 "ripper.c" /* yacc.c:1646 */
9984  break;
9985 
9986  case 495:
9987 #line 3909 "ripper.y" /* yacc.c:1646 */
9988  {
9989  (yyval.val) = new_array_pattern_tail(p, Qnone, 0, 0, Qnone, &(yyloc));
9990  (yyval.val) = new_array_pattern(p, (yyvsp[-2].val), Qnone, (yyval.val), &(yyloc));
9991  }
9992 #line 9988 "ripper.c" /* yacc.c:1646 */
9993  break;
9994 
9995  case 496:
9996 #line 3914 "ripper.y" /* yacc.c:1646 */
9997  {
9998  pop_pktbl(p, (yyvsp[-2].tbl));
9999  (yyval.val) = new_array_pattern(p, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), &(yyloc));
10000 #if 0
10001  nd_set_first_loc((yyval.val), (yylsp[-3]).beg_pos);
10002 #endif
10003 
10004  }
10005 #line 10001 "ripper.c" /* yacc.c:1646 */
10006  break;
10007 
10008  case 497:
10009 #line 3923 "ripper.y" /* yacc.c:1646 */
10010  {
10011  pop_pktbl(p, (yyvsp[-2].tbl));
10012  (yyval.val) = new_hash_pattern(p, (yyvsp[-3].val), (yyvsp[-1].val), &(yyloc));
10013 #if 0
10014  nd_set_first_loc((yyval.val), (yylsp[-3]).beg_pos);
10015 #endif
10016 
10017  }
10018 #line 10014 "ripper.c" /* yacc.c:1646 */
10019  break;
10020 
10021  case 498:
10022 #line 3932 "ripper.y" /* yacc.c:1646 */
10023  {
10024  (yyval.val) = new_array_pattern_tail(p, Qnone, 0, 0, Qnone, &(yyloc));
10025  (yyval.val) = new_array_pattern(p, (yyvsp[-2].val), Qnone, (yyval.val), &(yyloc));
10026  }
10027 #line 10023 "ripper.c" /* yacc.c:1646 */
10028  break;
10029 
10030  case 499:
10031 #line 3936 "ripper.y" /* yacc.c:1646 */
10032  {(yyval.tbl) = push_pktbl(p);}
10033 #line 10029 "ripper.c" /* yacc.c:1646 */
10034  break;
10035 
10036  case 500:
10037 #line 3937 "ripper.y" /* yacc.c:1646 */
10038  {
10039  pop_pktbl(p, (yyvsp[-2].tbl));
10040  (yyval.val) = new_array_pattern(p, Qnone, Qnone, (yyvsp[-1].val), &(yyloc));
10041  }
10042 #line 10038 "ripper.c" /* yacc.c:1646 */
10043  break;
10044 
10045  case 501:
10046 #line 3942 "ripper.y" /* yacc.c:1646 */
10047  {
10048  (yyval.val) = new_array_pattern_tail(p, Qnone, 0, 0, Qnone, &(yyloc));
10049  (yyval.val) = new_array_pattern(p, Qnone, Qnone, (yyval.val), &(yyloc));
10050  }
10051 #line 10047 "ripper.c" /* yacc.c:1646 */
10052  break;
10053 
10054  case 502:
10055 #line 3946 "ripper.y" /* yacc.c:1646 */
10056  {(yyval.tbl) = push_pktbl(p);}
10057 #line 10053 "ripper.c" /* yacc.c:1646 */
10058  break;
10059 
10060  case 503:
10061 #line 3947 "ripper.y" /* yacc.c:1646 */
10062  {
10063  pop_pktbl(p, (yyvsp[-2].tbl));
10064  (yyval.val) = new_hash_pattern(p, Qnone, (yyvsp[-1].val), &(yyloc));
10065  }
10066 #line 10062 "ripper.c" /* yacc.c:1646 */
10067  break;
10068 
10069  case 504:
10070 #line 3952 "ripper.y" /* yacc.c:1646 */
10071  {
10072  (yyval.val) = new_hash_pattern_tail(p, Qnone, 0, &(yyloc));
10073  (yyval.val) = new_hash_pattern(p, Qnone, (yyval.val), &(yyloc));
10074  }
10075 #line 10071 "ripper.c" /* yacc.c:1646 */
10076  break;
10077 
10078  case 505:
10079 #line 3956 "ripper.y" /* yacc.c:1646 */
10080  {(yyval.tbl) = push_pktbl(p);}
10081 #line 10077 "ripper.c" /* yacc.c:1646 */
10082  break;
10083 
10084  case 506:
10085 #line 3957 "ripper.y" /* yacc.c:1646 */
10086  {
10087  pop_pktbl(p, (yyvsp[-2].tbl));
10088  (yyval.val) = (yyvsp[-1].val);
10089  }
10090 #line 10086 "ripper.c" /* yacc.c:1646 */
10091  break;
10092 
10093  case 507:
10094 #line 3964 "ripper.y" /* yacc.c:1646 */
10095  {
10096 #if 0
10097  NODE *pre_args = NEW_LIST((yyvsp[0].val), &(yyloc));
10098  (yyval.val) = new_array_pattern_tail(p, pre_args, 0, 0, Qnone, &(yyloc));
10099 #endif
10100  (yyval.val) = new_array_pattern_tail(p, rb_ary_new_from_args(1, get_value((yyvsp[0].val))), 0, 0, Qnone, &(yyloc));
10101 
10102  }
10103 #line 10099 "ripper.c" /* yacc.c:1646 */
10104  break;
10105 
10106  case 508:
10107 #line 3973 "ripper.y" /* yacc.c:1646 */
10108  {
10109  (yyval.val) = new_array_pattern_tail(p, (yyvsp[0].val), 1, 0, Qnone, &(yyloc));
10110  }
10111 #line 10107 "ripper.c" /* yacc.c:1646 */
10112  break;
10113 
10114  case 509:
10115 #line 3977 "ripper.y" /* yacc.c:1646 */
10116  {
10117 #if 0
10118  (yyval.val) = new_array_pattern_tail(p, list_concat((yyvsp[-1].val), (yyvsp[0].val)), 0, 0, Qnone, &(yyloc));
10119 #endif
10120  VALUE pre_args = rb_ary_concat((yyvsp[-1].val), get_value((yyvsp[0].val)));
10121  (yyval.val) = new_array_pattern_tail(p, pre_args, 0, 0, Qnone, &(yyloc));
10122 
10123  }
10124 #line 10120 "ripper.c" /* yacc.c:1646 */
10125  break;
10126 
10127  case 510:
10128 #line 3986 "ripper.y" /* yacc.c:1646 */
10129  {
10130  (yyval.val) = new_array_pattern_tail(p, (yyvsp[-2].val), 1, (yyvsp[0].val), Qnone, &(yyloc));
10131  }
10132 #line 10128 "ripper.c" /* yacc.c:1646 */
10133  break;
10134 
10135  case 511:
10136 #line 3990 "ripper.y" /* yacc.c:1646 */
10137  {
10138  (yyval.val) = new_array_pattern_tail(p, (yyvsp[-4].val), 1, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10139  }
10140 #line 10136 "ripper.c" /* yacc.c:1646 */
10141  break;
10142 
10143  case 512:
10144 #line 3994 "ripper.y" /* yacc.c:1646 */
10145  {
10146  (yyval.val) = new_array_pattern_tail(p, (yyvsp[-1].val), 1, 0, Qnone, &(yyloc));
10147  }
10148 #line 10144 "ripper.c" /* yacc.c:1646 */
10149  break;
10150 
10151  case 513:
10152 #line 3998 "ripper.y" /* yacc.c:1646 */
10153  {
10154  (yyval.val) = new_array_pattern_tail(p, (yyvsp[-3].val), 1, 0, (yyvsp[0].val), &(yyloc));
10155  }
10156 #line 10152 "ripper.c" /* yacc.c:1646 */
10157  break;
10158 
10159  case 515:
10160 #line 4005 "ripper.y" /* yacc.c:1646 */
10161  {
10162  (yyval.val) = (yyvsp[-1].val);
10163  }
10164 #line 10160 "ripper.c" /* yacc.c:1646 */
10165  break;
10166 
10167  case 516:
10168 #line 4009 "ripper.y" /* yacc.c:1646 */
10169  {
10170 #if 0
10171  (yyval.val) = list_concat((yyvsp[-2].val), (yyvsp[-1].val));
10172 #endif
10173  (yyval.val)=rb_ary_concat((yyvsp[-2].val), get_value((yyvsp[-1].val)));
10174  }
10175 #line 10171 "ripper.c" /* yacc.c:1646 */
10176  break;
10177 
10178  case 517:
10179 #line 4018 "ripper.y" /* yacc.c:1646 */
10180  {
10181  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, (yyvsp[0].val), Qnone, &(yyloc));
10182  }
10183 #line 10179 "ripper.c" /* yacc.c:1646 */
10184  break;
10185 
10186  case 518:
10187 #line 4022 "ripper.y" /* yacc.c:1646 */
10188  {
10189  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10190  }
10191 #line 10187 "ripper.c" /* yacc.c:1646 */
10192  break;
10193 
10194  case 519:
10195 #line 4026 "ripper.y" /* yacc.c:1646 */
10196  {
10197  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, 0, Qnone, &(yyloc));
10198  }
10199 #line 10195 "ripper.c" /* yacc.c:1646 */
10200  break;
10201 
10202  case 520:
10203 #line 4030 "ripper.y" /* yacc.c:1646 */
10204  {
10205  (yyval.val) = new_array_pattern_tail(p, Qnone, 1, 0, (yyvsp[0].val), &(yyloc));
10206  }
10207 #line 10203 "ripper.c" /* yacc.c:1646 */
10208  break;
10209 
10210  case 522:
10211 #line 4037 "ripper.y" /* yacc.c:1646 */
10212  {
10213 #if 0
10214  (yyval.val) = list_concat((yyvsp[-2].val), (yyvsp[0].val));
10215 #endif
10216  (yyval.val)=rb_ary_concat((yyvsp[-2].val), get_value((yyvsp[0].val)));
10217  }
10218 #line 10214 "ripper.c" /* yacc.c:1646 */
10219  break;
10220 
10221  case 523:
10222 #line 4046 "ripper.y" /* yacc.c:1646 */
10223  {
10224 #if 0
10225  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
10226 #endif
10227  (yyval.val)=rb_ary_new_from_args(1, get_value((yyvsp[0].val)));
10228  }
10229 #line 10225 "ripper.c" /* yacc.c:1646 */
10230  break;
10231 
10232  case 524:
10233 #line 4055 "ripper.y" /* yacc.c:1646 */
10234  {
10235  (yyval.val) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[-2].val), &(yyloc)), (yyvsp[0].val), &(yyloc));
10236  }
10237 #line 10233 "ripper.c" /* yacc.c:1646 */
10238  break;
10239 
10240  case 525:
10241 #line 4059 "ripper.y" /* yacc.c:1646 */
10242  {
10243  (yyval.val) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[0].val), &(yyloc)), 0, &(yyloc));
10244  }
10245 #line 10241 "ripper.c" /* yacc.c:1646 */
10246  break;
10247 
10248  case 526:
10249 #line 4063 "ripper.y" /* yacc.c:1646 */
10250  {
10251  (yyval.val) = new_hash_pattern_tail(p, new_hash(p, Qnone, &(yyloc)), (yyvsp[0].val), &(yyloc));
10252  }
10253 #line 10249 "ripper.c" /* yacc.c:1646 */
10254  break;
10255 
10256  case 527:
10257 #line 4067 "ripper.y" /* yacc.c:1646 */
10258  {
10259  (yyval.val) = new_hash_pattern_tail(p, new_unique_key_hash(p, (yyvsp[-2].val), &(yyloc)), ID2VAL(idNil), &(yyloc));
10260  }
10261 #line 10257 "ripper.c" /* yacc.c:1646 */
10262  break;
10263 
10264  case 528:
10265 #line 4071 "ripper.y" /* yacc.c:1646 */
10266  {
10267  (yyval.val) = new_hash_pattern_tail(p, new_hash(p, Qnone, &(yyloc)), ID2VAL(idNil), &(yyloc));
10268  }
10269 #line 10265 "ripper.c" /* yacc.c:1646 */
10270  break;
10271 
10272  case 529:
10273 #line 4077 "ripper.y" /* yacc.c:1646 */
10274  {(yyval.val)=rb_ary_new_from_args(1, (yyvsp[0].val));}
10275 #line 10271 "ripper.c" /* yacc.c:1646 */
10276  break;
10277 
10278  case 530:
10279 #line 4079 "ripper.y" /* yacc.c:1646 */
10280  {
10281 #if 0
10282  (yyval.val) = list_concat((yyvsp[-2].val), (yyvsp[0].val));
10283 #endif
10284  (yyval.val)=rb_ary_push((yyvsp[-2].val), (yyvsp[0].val));
10285  }
10286 #line 10282 "ripper.c" /* yacc.c:1646 */
10287  break;
10288 
10289  case 531:
10290 #line 4088 "ripper.y" /* yacc.c:1646 */
10291  {
10292  error_duplicate_pattern_key(p, get_id((yyvsp[-1].val)), &(yylsp[-1]));
10293 #if 0
10294  (yyval.val) = list_append(p, NEW_LIST(NEW_LIT(ID2SYM((yyvsp[-1].val)), &(yyloc)), &(yyloc)), (yyvsp[0].val));
10295 #endif
10296  (yyval.val)=rb_ary_new_from_args(2, get_value((yyvsp[-1].val)), get_value((yyvsp[0].val)));
10297  }
10298 #line 10294 "ripper.c" /* yacc.c:1646 */
10299  break;
10300 
10301  case 532:
10302 #line 4096 "ripper.y" /* yacc.c:1646 */
10303  {
10304  error_duplicate_pattern_key(p, get_id((yyvsp[0].val)), &(yylsp[0]));
10305  if ((yyvsp[0].val) && !is_local_id(get_id((yyvsp[0].val)))) {
10306  yyerror1(&(yylsp[0]), "key must be valid as local variables");
10307  }
10308  error_duplicate_pattern_variable(p, get_id((yyvsp[0].val)), &(yylsp[0]));
10309 #if 0
10310  (yyval.val) = list_append(p, NEW_LIST(NEW_LIT(ID2SYM((yyvsp[0].val)), &(yyloc)), &(yyloc)), assignable(p, (yyvsp[0].val), 0, &(yyloc)));
10311 #endif
10312  (yyval.val)=rb_ary_new_from_args(2, get_value((yyvsp[0].val)), Qnil);
10313  }
10314 #line 10310 "ripper.c" /* yacc.c:1646 */
10315  break;
10316 
10317  case 534:
10318 #line 4111 "ripper.y" /* yacc.c:1646 */
10319  {
10320  YYLTYPE loc = code_loc_gen(&(yylsp[-2]), &(yylsp[0]));
10321 #if 0
10322  if (!(yyvsp[-1].val) || nd_type((yyvsp[-1].val)) == NODE_STR) {
10323  NODE *node = dsym_node(p, (yyvsp[-1].val), &loc);
10324  (yyval.val) = SYM2ID(node->nd_lit);
10325  }
10326 #endif
10327  if (ripper_is_node_yylval((yyvsp[-1].val)) && RNODE((yyvsp[-1].val))->nd_cval) {
10328  VALUE label = RNODE((yyvsp[-1].val))->nd_cval;
10329  VALUE rval = RNODE((yyvsp[-1].val))->nd_rval;
10330  (yyval.val) = ripper_new_yylval(p, rb_intern_str(label), rval, label);
10331  RNODE((yyval.val))->nd_loc = loc;
10332  }
10333 
10334  else {
10335  yyerror1(&loc, "symbol literal with interpolation is not allowed");
10336  (yyval.val) = 0;
10337  }
10338  }
10339 #line 10335 "ripper.c" /* yacc.c:1646 */
10340  break;
10341 
10342  case 535:
10343 #line 4134 "ripper.y" /* yacc.c:1646 */
10344  {
10345  (yyval.val) = (yyvsp[0].val);
10346  }
10347 #line 10343 "ripper.c" /* yacc.c:1646 */
10348  break;
10349 
10350  case 536:
10351 #line 4138 "ripper.y" /* yacc.c:1646 */
10352  {
10353  (yyval.val) = 0;
10354  }
10355 #line 10351 "ripper.c" /* yacc.c:1646 */
10356  break;
10357 
10358  case 537:
10359 #line 4144 "ripper.y" /* yacc.c:1646 */
10360  {
10361  (yyval.val) = 0;
10362  }
10363 #line 10359 "ripper.c" /* yacc.c:1646 */
10364  break;
10365 
10366  case 539:
10367 #line 4151 "ripper.y" /* yacc.c:1646 */
10368  {
10369 #if 0
10370  value_expr((yyvsp[-2].val));
10371  value_expr((yyvsp[0].val));
10372  (yyval.val) = NEW_DOT2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10373 #endif
10374  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
10375  }
10376 #line 10372 "ripper.c" /* yacc.c:1646 */
10377  break;
10378 
10379  case 540:
10380 #line 4160 "ripper.y" /* yacc.c:1646 */
10381  {
10382 #if 0
10383  value_expr((yyvsp[-2].val));
10384  value_expr((yyvsp[0].val));
10385  (yyval.val) = NEW_DOT3((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10386 #endif
10387  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
10388  }
10389 #line 10385 "ripper.c" /* yacc.c:1646 */
10390  break;
10391 
10392  case 541:
10393 #line 4169 "ripper.y" /* yacc.c:1646 */
10394  {
10395 #if 0
10396  YYLTYPE loc;
10397  loc.beg_pos = (yylsp[0]).end_pos;
10398  loc.end_pos = (yylsp[0]).end_pos;
10399 
10400  value_expr((yyvsp[-1].val));
10401  (yyval.val) = NEW_DOT2((yyvsp[-1].val), new_nil(&loc), &(yyloc));
10402 #endif
10403  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
10404  }
10405 #line 10401 "ripper.c" /* yacc.c:1646 */
10406  break;
10407 
10408  case 542:
10409 #line 4181 "ripper.y" /* yacc.c:1646 */
10410  {
10411 #if 0
10412  YYLTYPE loc;
10413  loc.beg_pos = (yylsp[0]).end_pos;
10414  loc.end_pos = (yylsp[0]).end_pos;
10415 
10416  value_expr((yyvsp[-1].val));
10417  (yyval.val) = NEW_DOT3((yyvsp[-1].val), new_nil(&loc), &(yyloc));
10418 #endif
10419  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=Qnil;v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
10420  }
10421 #line 10417 "ripper.c" /* yacc.c:1646 */
10422  break;
10423 
10424  case 546:
10425 #line 4196 "ripper.y" /* yacc.c:1646 */
10426  {
10427 #if 0
10428  YYLTYPE loc;
10429  loc.beg_pos = (yylsp[-1]).beg_pos;
10430  loc.end_pos = (yylsp[-1]).beg_pos;
10431 
10432  value_expr((yyvsp[0].val));
10433  (yyval.val) = NEW_DOT2(new_nil(&loc), (yyvsp[0].val), &(yyloc));
10434 #endif
10435  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[0].val);v3=dispatch2(dot2,v1,v2);(yyval.val)=v3;}
10436  }
10437 #line 10433 "ripper.c" /* yacc.c:1646 */
10438  break;
10439 
10440  case 547:
10441 #line 4208 "ripper.y" /* yacc.c:1646 */
10442  {
10443 #if 0
10444  YYLTYPE loc;
10445  loc.beg_pos = (yylsp[-1]).beg_pos;
10446  loc.end_pos = (yylsp[-1]).beg_pos;
10447 
10448  value_expr((yyvsp[0].val));
10449  (yyval.val) = NEW_DOT3(new_nil(&loc), (yyvsp[0].val), &(yyloc));
10450 #endif
10451  {VALUE v1,v2,v3;v1=Qnil;v2=(yyvsp[0].val);v3=dispatch2(dot3,v1,v2);(yyval.val)=v3;}
10452  }
10453 #line 10449 "ripper.c" /* yacc.c:1646 */
10454  break;
10455 
10456  case 556:
10457 #line 4230 "ripper.y" /* yacc.c:1646 */
10458  {
10459 #if 0
10460  if (!((yyval.val) = gettable(p, (yyvsp[0].val), &(yyloc)))) (yyval.val) = NEW_BEGIN(0, &(yyloc));
10461 #endif
10462  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
10463  }
10464 #line 10460 "ripper.c" /* yacc.c:1646 */
10465  break;
10466 
10467  case 557:
10468 #line 4237 "ripper.y" /* yacc.c:1646 */
10469  {
10470  token_info_push(p, "->", &(yylsp[0]));
10471  }
10472 #line 10468 "ripper.c" /* yacc.c:1646 */
10473  break;
10474 
10475  case 558:
10476 #line 4241 "ripper.y" /* yacc.c:1646 */
10477  {
10478  (yyval.val) = (yyvsp[0].val);
10479 #if 0
10480  nd_set_first_loc((yyval.val), (yylsp[-2]).beg_pos);
10481 #endif
10482  }
10483 #line 10479 "ripper.c" /* yacc.c:1646 */
10484  break;
10485 
10486  case 559:
10487 #line 4250 "ripper.y" /* yacc.c:1646 */
10488  {
10489 #if 0
10490  error_duplicate_pattern_variable(p, (yyvsp[0].val), &(yylsp[0]));
10491  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
10492 #endif
10493  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
10494  }
10495 #line 10491 "ripper.c" /* yacc.c:1646 */
10496  break;
10497 
10498  case 560:
10499 #line 4260 "ripper.y" /* yacc.c:1646 */
10500  {
10501 #if 0
10502  NODE *n = gettable(p, (yyvsp[0].val), &(yyloc));
10503  if (!(nd_type(n) == NODE_LVAR || nd_type(n) == NODE_DVAR)) {
10504  compile_error(p, "%"PRIsVALUE": no such local variable", rb_id2str((yyvsp[0].val)));
10505  }
10506  (yyval.val) = n;
10507 #endif
10508  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
10509  }
10510 #line 10506 "ripper.c" /* yacc.c:1646 */
10511  break;
10512 
10513  case 561:
10514 #line 4273 "ripper.y" /* yacc.c:1646 */
10515  {
10516 #if 0
10517  (yyval.val) = NEW_COLON3((yyvsp[0].val), &(yyloc));
10518 #endif
10519  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(top_const_ref,v1);(yyval.val)=v2;}
10520  }
10521 #line 10517 "ripper.c" /* yacc.c:1646 */
10522  break;
10523 
10524  case 562:
10525 #line 4280 "ripper.y" /* yacc.c:1646 */
10526  {
10527 #if 0
10528  (yyval.val) = NEW_COLON2((yyvsp[-2].val), (yyvsp[0].val), &(yyloc));
10529 #endif
10530  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(const_path_ref,v1,v2);(yyval.val)=v3;}
10531  }
10532 #line 10528 "ripper.c" /* yacc.c:1646 */
10533  break;
10534 
10535  case 563:
10536 #line 4287 "ripper.y" /* yacc.c:1646 */
10537  {
10538 #if 0
10539  (yyval.val) = gettable(p, (yyvsp[0].val), &(yyloc));
10540 #endif
10541  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
10542  }
10543 #line 10539 "ripper.c" /* yacc.c:1646 */
10544  break;
10545 
10546  case 564:
10547 #line 4298 "ripper.y" /* yacc.c:1646 */
10548  {
10549 #if 0
10550  (yyval.val) = NEW_RESBODY((yyvsp[-4].val),
10551  (yyvsp[-3].val) ? block_append(p, node_assign(p, (yyvsp[-3].val), NEW_ERRINFO(&(yylsp[-3])), &(yylsp[-3])), (yyvsp[-1].val)) : (yyvsp[-1].val),
10552  (yyvsp[0].val), &(yyloc));
10553  fixpos((yyval.val), (yyvsp[-4].val)?(yyvsp[-4].val):(yyvsp[-1].val));
10554 #endif
10555  {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;}
10556  }
10557 #line 10553 "ripper.c" /* yacc.c:1646 */
10558  break;
10559 
10560  case 566:
10561 #line 4311 "ripper.y" /* yacc.c:1646 */
10562  {
10563 #if 0
10564  (yyval.val) = NEW_LIST((yyvsp[0].val), &(yyloc));
10565 #endif
10566  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
10567  }
10568 #line 10564 "ripper.c" /* yacc.c:1646 */
10569  break;
10570 
10571  case 567:
10572 #line 4318 "ripper.y" /* yacc.c:1646 */
10573  {
10574 #if 0
10575  if (!((yyval.val) = splat_array((yyvsp[0].val)))) (yyval.val) = (yyvsp[0].val);
10576 #endif
10577  (yyval.val)=(yyvsp[0].val);
10578  }
10579 #line 10575 "ripper.c" /* yacc.c:1646 */
10580  break;
10581 
10582  case 569:
10583 #line 4328 "ripper.y" /* yacc.c:1646 */
10584  {
10585  (yyval.val) = (yyvsp[0].val);
10586  }
10587 #line 10583 "ripper.c" /* yacc.c:1646 */
10588  break;
10589 
10590  case 571:
10591 #line 4335 "ripper.y" /* yacc.c:1646 */
10592  {
10593 #if 0
10594  (yyval.val) = (yyvsp[0].val);
10595 #endif
10596  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(ensure,v1);(yyval.val)=v2;}
10597  }
10598 #line 10594 "ripper.c" /* yacc.c:1646 */
10599  break;
10600 
10601  case 575:
10602 #line 4349 "ripper.y" /* yacc.c:1646 */
10603  {
10604 #if 0
10605  NODE *node = (yyvsp[0].val);
10606  if (!node) {
10607  node = NEW_STR(STR_NEW0(), &(yyloc));
10608  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit);
10609  }
10610  else {
10611  node = evstr2dstr(p, node);
10612  }
10613  (yyval.val) = node;
10614 #endif
10615  (yyval.val)=(yyvsp[0].val);
10616  }
10617 #line 10613 "ripper.c" /* yacc.c:1646 */
10618  break;
10619 
10620  case 578:
10621 #line 4368 "ripper.y" /* yacc.c:1646 */
10622  {
10623 #if 0
10624  (yyval.val) = literal_concat(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10625 #endif
10626  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(string_concat,v1,v2);(yyval.val)=v3;}
10627  }
10628 #line 10624 "ripper.c" /* yacc.c:1646 */
10629  break;
10630 
10631  case 579:
10632 #line 4377 "ripper.y" /* yacc.c:1646 */
10633  {
10634 #if 0
10635  (yyval.val) = heredoc_dedent(p, (yyvsp[-1].val));
10636  if ((yyval.val)) nd_set_loc((yyval.val), &(yyloc));
10637 #endif
10638  {VALUE v1,v2;v1=heredoc_dedent(p, (yyvsp[-1].val));v2=dispatch1(string_literal,v1);(yyval.val)=v2;}
10639  }
10640 #line 10636 "ripper.c" /* yacc.c:1646 */
10641  break;
10642 
10643  case 580:
10644 #line 4387 "ripper.y" /* yacc.c:1646 */
10645  {
10646 #if 0
10647  (yyval.val) = new_xstring(p, heredoc_dedent(p, (yyvsp[-1].val)), &(yyloc));
10648 #endif
10649  {VALUE v1,v2;v1=heredoc_dedent(p, (yyvsp[-1].val));v2=dispatch1(xstring_literal,v1);(yyval.val)=v2;}
10650  }
10651 #line 10647 "ripper.c" /* yacc.c:1646 */
10652  break;
10653 
10654  case 581:
10655 #line 4396 "ripper.y" /* yacc.c:1646 */
10656  {
10657  (yyval.val) = new_regexp(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10658  }
10659 #line 10655 "ripper.c" /* yacc.c:1646 */
10660  break;
10661 
10662  case 582:
10663 #line 4402 "ripper.y" /* yacc.c:1646 */
10664  {
10665 #if 0
10666  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
10667 #endif
10668  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(array,v1);(yyval.val)=v2;}
10669  }
10670 #line 10666 "ripper.c" /* yacc.c:1646 */
10671  break;
10672 
10673  case 583:
10674 #line 4411 "ripper.y" /* yacc.c:1646 */
10675  {
10676 #if 0
10677  (yyval.val) = 0;
10678 #endif
10679  {VALUE v1;v1=dispatch0(words_new);(yyval.val)=v1;}
10680  }
10681 #line 10677 "ripper.c" /* yacc.c:1646 */
10682  break;
10683 
10684  case 584:
10685 #line 4418 "ripper.y" /* yacc.c:1646 */
10686  {
10687 #if 0
10688  (yyval.val) = list_append(p, (yyvsp[-2].val), evstr2dstr(p, (yyvsp[-1].val)));
10689 #endif
10690  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(words_add,v1,v2);(yyval.val)=v3;}
10691  }
10692 #line 10688 "ripper.c" /* yacc.c:1646 */
10693  break;
10694 
10695  case 585:
10696 #line 4427 "ripper.y" /* yacc.c:1646 */
10697  {{VALUE v1,v2,v3,v4;v1=dispatch0(word_new);v2=v1;v3=(yyvsp[0].val);v4=dispatch2(word_add,v2,v3);(yyval.val)=v4;}}
10698 #line 10694 "ripper.c" /* yacc.c:1646 */
10699  break;
10700 
10701  case 586:
10702 #line 4429 "ripper.y" /* yacc.c:1646 */
10703  {
10704 #if 0
10705  (yyval.val) = literal_concat(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10706 #endif
10707  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(word_add,v1,v2);(yyval.val)=v3;}
10708  }
10709 #line 10705 "ripper.c" /* yacc.c:1646 */
10710  break;
10711 
10712  case 587:
10713 #line 4438 "ripper.y" /* yacc.c:1646 */
10714  {
10715 #if 0
10716  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
10717 #endif
10718  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(array,v1);(yyval.val)=v2;}
10719  }
10720 #line 10716 "ripper.c" /* yacc.c:1646 */
10721  break;
10722 
10723  case 588:
10724 #line 4447 "ripper.y" /* yacc.c:1646 */
10725  {
10726 #if 0
10727  (yyval.val) = 0;
10728 #endif
10729  {VALUE v1;v1=dispatch0(symbols_new);(yyval.val)=v1;}
10730  }
10731 #line 10727 "ripper.c" /* yacc.c:1646 */
10732  break;
10733 
10734  case 589:
10735 #line 4454 "ripper.y" /* yacc.c:1646 */
10736  {
10737 #if 0
10738  (yyval.val) = symbol_append(p, (yyvsp[-2].val), evstr2dstr(p, (yyvsp[-1].val)));
10739 #endif
10740  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(symbols_add,v1,v2);(yyval.val)=v3;}
10741  }
10742 #line 10738 "ripper.c" /* yacc.c:1646 */
10743  break;
10744 
10745  case 590:
10746 #line 4463 "ripper.y" /* yacc.c:1646 */
10747  {
10748 #if 0
10749  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
10750 #endif
10751  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(array,v1);(yyval.val)=v2;}
10752  }
10753 #line 10749 "ripper.c" /* yacc.c:1646 */
10754  break;
10755 
10756  case 591:
10757 #line 4472 "ripper.y" /* yacc.c:1646 */
10758  {
10759 #if 0
10760  (yyval.val) = make_list((yyvsp[-1].val), &(yyloc));
10761 #endif
10762  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(array,v1);(yyval.val)=v2;}
10763  }
10764 #line 10760 "ripper.c" /* yacc.c:1646 */
10765  break;
10766 
10767  case 592:
10768 #line 4481 "ripper.y" /* yacc.c:1646 */
10769  {
10770 #if 0
10771  (yyval.val) = 0;
10772 #endif
10773  {VALUE v1;v1=dispatch0(qwords_new);(yyval.val)=v1;}
10774  }
10775 #line 10771 "ripper.c" /* yacc.c:1646 */
10776  break;
10777 
10778  case 593:
10779 #line 4488 "ripper.y" /* yacc.c:1646 */
10780  {
10781 #if 0
10782  (yyval.val) = list_append(p, (yyvsp[-2].val), (yyvsp[-1].val));
10783 #endif
10784  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(qwords_add,v1,v2);(yyval.val)=v3;}
10785  }
10786 #line 10782 "ripper.c" /* yacc.c:1646 */
10787  break;
10788 
10789  case 594:
10790 #line 4497 "ripper.y" /* yacc.c:1646 */
10791  {
10792 #if 0
10793  (yyval.val) = 0;
10794 #endif
10795  {VALUE v1;v1=dispatch0(qsymbols_new);(yyval.val)=v1;}
10796  }
10797 #line 10793 "ripper.c" /* yacc.c:1646 */
10798  break;
10799 
10800  case 595:
10801 #line 4504 "ripper.y" /* yacc.c:1646 */
10802  {
10803 #if 0
10804  (yyval.val) = symbol_append(p, (yyvsp[-2].val), (yyvsp[-1].val));
10805 #endif
10806  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[-1].val);v3=dispatch2(qsymbols_add,v1,v2);(yyval.val)=v3;}
10807  }
10808 #line 10804 "ripper.c" /* yacc.c:1646 */
10809  break;
10810 
10811  case 596:
10812 #line 4513 "ripper.y" /* yacc.c:1646 */
10813  {
10814 #if 0
10815  (yyval.val) = 0;
10816 #endif
10817  {VALUE v1;v1=dispatch0(string_content);(yyval.val)=v1;}
10818 #if 0
10819 #endif
10820  (yyval.val) = ripper_new_yylval(p, 0, (yyval.val), 0);
10821 
10822  }
10823 #line 10819 "ripper.c" /* yacc.c:1646 */
10824  break;
10825 
10826  case 597:
10827 #line 4524 "ripper.y" /* yacc.c:1646 */
10828  {
10829 #if 0
10830  (yyval.val) = literal_concat(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10831 #endif
10832  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(string_add,v1,v2);(yyval.val)=v3;}
10833 #if 0
10834 #endif
10835  if (ripper_is_node_yylval((yyvsp[-1].val)) && ripper_is_node_yylval((yyvsp[0].val)) &&
10836  !RNODE((yyvsp[-1].val))->nd_cval) {
10837  RNODE((yyvsp[-1].val))->nd_cval = RNODE((yyvsp[0].val))->nd_cval;
10838  RNODE((yyvsp[-1].val))->nd_rval = add_mark_object(p, (yyval.val));
10839  (yyval.val) = (yyvsp[-1].val);
10840  }
10841 
10842  }
10843 #line 10839 "ripper.c" /* yacc.c:1646 */
10844  break;
10845 
10846  case 598:
10847 #line 4542 "ripper.y" /* yacc.c:1646 */
10848  {
10849 #if 0
10850  (yyval.val) = 0;
10851 #endif
10852  {VALUE v1;v1=dispatch0(xstring_new);(yyval.val)=v1;}
10853  }
10854 #line 10850 "ripper.c" /* yacc.c:1646 */
10855  break;
10856 
10857  case 599:
10858 #line 4549 "ripper.y" /* yacc.c:1646 */
10859  {
10860 #if 0
10861  (yyval.val) = literal_concat(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
10862 #endif
10863  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(xstring_add,v1,v2);(yyval.val)=v3;}
10864  }
10865 #line 10861 "ripper.c" /* yacc.c:1646 */
10866  break;
10867 
10868  case 600:
10869 #line 4558 "ripper.y" /* yacc.c:1646 */
10870  {
10871 #if 0
10872  (yyval.val) = 0;
10873 #endif
10874  {VALUE v1;v1=dispatch0(regexp_new);(yyval.val)=v1;}
10875 #if 0
10876 #endif
10877  (yyval.val) = ripper_new_yylval(p, 0, (yyval.val), 0);
10878 
10879  }
10880 #line 10876 "ripper.c" /* yacc.c:1646 */
10881  break;
10882 
10883  case 601:
10884 #line 4569 "ripper.y" /* yacc.c:1646 */
10885  {
10886 #if 0
10887  NODE *head = (yyvsp[-1].val), *tail = (yyvsp[0].val);
10888  if (!head) {
10889  (yyval.val) = tail;
10890  }
10891  else if (!tail) {
10892  (yyval.val) = head;
10893  }
10894  else {
10895  switch (nd_type(head)) {
10896  case NODE_STR:
10897  nd_set_type(head, NODE_DSTR);
10898  break;
10899  case NODE_DSTR:
10900  break;
10901  default:
10902  head = list_append(p, NEW_DSTR(Qnil, &(yyloc)), head);
10903  break;
10904  }
10905  (yyval.val) = list_append(p, head, tail);
10906  }
10907 #endif
10908  VALUE s1 = 1, s2 = 0, n1 = (yyvsp[-1].val), n2 = (yyvsp[0].val);
10909  if (ripper_is_node_yylval(n1)) {
10910  s1 = RNODE(n1)->nd_cval;
10911  n1 = RNODE(n1)->nd_rval;
10912  }
10913  if (ripper_is_node_yylval(n2)) {
10914  s2 = RNODE(n2)->nd_cval;
10915  n2 = RNODE(n2)->nd_rval;
10916  }
10917  (yyval.val) = dispatch2(regexp_add, n1, n2);
10918  if (!s1 && s2) {
10919  (yyval.val) = ripper_new_yylval(p, 0, (yyval.val), s2);
10920  }
10921 
10922  }
10923 #line 10919 "ripper.c" /* yacc.c:1646 */
10924  break;
10925 
10926  case 602:
10927 #line 4610 "ripper.y" /* yacc.c:1646 */
10928  {(yyval.val)=ripper_new_yylval(p, 0, get_value((yyvsp[0].val)), (yyvsp[0].val));}
10929 #line 10925 "ripper.c" /* yacc.c:1646 */
10930  break;
10931 
10932  case 603:
10933 #line 4612 "ripper.y" /* yacc.c:1646 */
10934  {
10935  /* need to backup p->lex.strterm so that a string literal `%&foo,#$&,bar&` can be parsed */
10936  (yyval.strterm) = p->lex.strterm;
10937  p->lex.strterm = 0;
10938  SET_LEX_STATE(EXPR_BEG);
10939  }
10940 #line 10936 "ripper.c" /* yacc.c:1646 */
10941  break;
10942 
10943  case 604:
10944 #line 4619 "ripper.y" /* yacc.c:1646 */
10945  {
10946  p->lex.strterm = (yyvsp[-1].strterm);
10947 #if 0
10948  (yyval.val) = NEW_EVSTR((yyvsp[0].val), &(yyloc));
10949  nd_set_line((yyval.val), (yylsp[0]).end_pos.lineno);
10950 #endif
10951  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(string_dvar,v1);(yyval.val)=v2;}
10952  }
10953 #line 10949 "ripper.c" /* yacc.c:1646 */
10954  break;
10955 
10956  case 605:
10957 #line 4628 "ripper.y" /* yacc.c:1646 */
10958  {
10959  CMDARG_PUSH(0);
10960  COND_PUSH(0);
10961  }
10962 #line 10958 "ripper.c" /* yacc.c:1646 */
10963  break;
10964 
10965  case 606:
10966 #line 4632 "ripper.y" /* yacc.c:1646 */
10967  {
10968  /* need to backup p->lex.strterm so that a string literal `%!foo,#{ !0 },bar!` can be parsed */
10969  (yyval.strterm) = p->lex.strterm;
10970  p->lex.strterm = 0;
10971  }
10972 #line 10968 "ripper.c" /* yacc.c:1646 */
10973  break;
10974 
10975  case 607:
10976 #line 4637 "ripper.y" /* yacc.c:1646 */
10977  {
10978  (yyval.num) = p->lex.state;
10979  SET_LEX_STATE(EXPR_BEG);
10980  }
10981 #line 10977 "ripper.c" /* yacc.c:1646 */
10982  break;
10983 
10984  case 608:
10985 #line 4641 "ripper.y" /* yacc.c:1646 */
10986  {
10987  (yyval.num) = p->lex.brace_nest;
10988  p->lex.brace_nest = 0;
10989  }
10990 #line 10986 "ripper.c" /* yacc.c:1646 */
10991  break;
10992 
10993  case 609:
10994 #line 4645 "ripper.y" /* yacc.c:1646 */
10995  {
10996  (yyval.num) = p->heredoc_indent;
10997  p->heredoc_indent = 0;
10998  }
10999 #line 10995 "ripper.c" /* yacc.c:1646 */
11000  break;
11001 
11002  case 610:
11003 #line 4650 "ripper.y" /* yacc.c:1646 */
11004  {
11005  COND_POP();
11006  CMDARG_POP();
11007  p->lex.strterm = (yyvsp[-5].strterm);
11008  SET_LEX_STATE((yyvsp[-4].num));
11009  p->lex.brace_nest = (yyvsp[-3].num);
11010  p->heredoc_indent = (yyvsp[-2].num);
11011  p->heredoc_line_indent = -1;
11012 #if 0
11013  if ((yyvsp[-1].val)) (yyvsp[-1].val)->flags &= ~NODE_FL_NEWLINE;
11014  (yyval.val) = new_evstr(p, (yyvsp[-1].val), &(yyloc));
11015 #endif
11016  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(string_embexpr,v1);(yyval.val)=v2;}
11017  }
11018 #line 11014 "ripper.c" /* yacc.c:1646 */
11019  break;
11020 
11021  case 611:
11022 #line 4667 "ripper.y" /* yacc.c:1646 */
11023  {
11024 #if 0
11025  (yyval.val) = NEW_GVAR((yyvsp[0].val), &(yyloc));
11026 #endif
11027  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
11028  }
11029 #line 11025 "ripper.c" /* yacc.c:1646 */
11030  break;
11031 
11032  case 612:
11033 #line 4674 "ripper.y" /* yacc.c:1646 */
11034  {
11035 #if 0
11036  (yyval.val) = NEW_IVAR((yyvsp[0].val), &(yyloc));
11037 #endif
11038  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
11039  }
11040 #line 11036 "ripper.c" /* yacc.c:1646 */
11041  break;
11042 
11043  case 613:
11044 #line 4681 "ripper.y" /* yacc.c:1646 */
11045  {
11046 #if 0
11047  (yyval.val) = NEW_CVAR((yyvsp[0].val), &(yyloc));
11048 #endif
11049  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
11050  }
11051 #line 11047 "ripper.c" /* yacc.c:1646 */
11052  break;
11053 
11054  case 617:
11055 #line 4695 "ripper.y" /* yacc.c:1646 */
11056  {
11057  SET_LEX_STATE(EXPR_END);
11058 #if 0
11059  (yyval.val) = NEW_LIT(ID2SYM((yyvsp[0].val)), &(yyloc));
11060 #endif
11061  {VALUE v1,v2,v3,v4;v1=(yyvsp[0].val);v2=dispatch1(symbol,v1);v3=v2;v4=dispatch1(symbol_literal,v3);(yyval.val)=v4;}
11062  }
11063 #line 11059 "ripper.c" /* yacc.c:1646 */
11064  break;
11065 
11066  case 622:
11067 #line 4711 "ripper.y" /* yacc.c:1646 */
11068  {
11069  SET_LEX_STATE(EXPR_END);
11070 #if 0
11071  (yyval.val) = dsym_node(p, (yyvsp[-1].val), &(yyloc));
11072 #endif
11073  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(dyna_symbol,v1);(yyval.val)=v2;}
11074  }
11075 #line 11071 "ripper.c" /* yacc.c:1646 */
11076  break;
11077 
11078  case 624:
11079 #line 4722 "ripper.y" /* yacc.c:1646 */
11080  {
11081 #if 0
11082  (yyval.val) = (yyvsp[0].val);
11083  RB_OBJ_WRITE(p->ast, &(yyval.val)->nd_lit, negate_lit(p, (yyval.val)->nd_lit));
11084 #endif
11085  {VALUE v1,v2,v3;v1=ID2VAL(idUMinus);v2=(yyvsp[0].val);v3=dispatch2(unary,v1,v2);(yyval.val)=v3;}
11086  }
11087 #line 11083 "ripper.c" /* yacc.c:1646 */
11088  break;
11089 
11090  case 634:
11091 #line 4744 "ripper.y" /* yacc.c:1646 */
11092  {(yyval.val) = KWD2EID(nil, (yyvsp[0].val));}
11093 #line 11089 "ripper.c" /* yacc.c:1646 */
11094  break;
11095 
11096  case 635:
11097 #line 4745 "ripper.y" /* yacc.c:1646 */
11098  {(yyval.val) = KWD2EID(self, (yyvsp[0].val));}
11099 #line 11095 "ripper.c" /* yacc.c:1646 */
11100  break;
11101 
11102  case 636:
11103 #line 4746 "ripper.y" /* yacc.c:1646 */
11104  {(yyval.val) = KWD2EID(true, (yyvsp[0].val));}
11105 #line 11101 "ripper.c" /* yacc.c:1646 */
11106  break;
11107 
11108  case 637:
11109 #line 4747 "ripper.y" /* yacc.c:1646 */
11110  {(yyval.val) = KWD2EID(false, (yyvsp[0].val));}
11111 #line 11107 "ripper.c" /* yacc.c:1646 */
11112  break;
11113 
11114  case 638:
11115 #line 4748 "ripper.y" /* yacc.c:1646 */
11116  {(yyval.val) = KWD2EID(_FILE__, (yyvsp[0].val));}
11117 #line 11113 "ripper.c" /* yacc.c:1646 */
11118  break;
11119 
11120  case 639:
11121 #line 4749 "ripper.y" /* yacc.c:1646 */
11122  {(yyval.val) = KWD2EID(_LINE__, (yyvsp[0].val));}
11123 #line 11119 "ripper.c" /* yacc.c:1646 */
11124  break;
11125 
11126  case 640:
11127 #line 4750 "ripper.y" /* yacc.c:1646 */
11128  {(yyval.val) = KWD2EID(_ENCODING__, (yyvsp[0].val));}
11129 #line 11125 "ripper.c" /* yacc.c:1646 */
11130  break;
11131 
11132  case 641:
11133 #line 4754 "ripper.y" /* yacc.c:1646 */
11134  {
11135 #if 0
11136  if (!((yyval.val) = gettable(p, (yyvsp[0].val), &(yyloc)))) (yyval.val) = NEW_BEGIN(0, &(yyloc));
11137 #endif
11138  if (id_is_var(p, get_id((yyvsp[0].val)))) {
11139  (yyval.val) = dispatch1(var_ref, (yyvsp[0].val));
11140  }
11141  else {
11142  (yyval.val) = dispatch1(vcall, (yyvsp[0].val));
11143  }
11144 
11145  }
11146 #line 11142 "ripper.c" /* yacc.c:1646 */
11147  break;
11148 
11149  case 642:
11150 #line 4767 "ripper.y" /* yacc.c:1646 */
11151  {
11152 #if 0
11153  if (!((yyval.val) = gettable(p, (yyvsp[0].val), &(yyloc)))) (yyval.val) = NEW_BEGIN(0, &(yyloc));
11154 #endif
11155  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(var_ref,v1);(yyval.val)=v2;}
11156  }
11157 #line 11153 "ripper.c" /* yacc.c:1646 */
11158  break;
11159 
11160  case 643:
11161 #line 4776 "ripper.y" /* yacc.c:1646 */
11162  {
11163 #if 0
11164  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
11165 #endif
11166  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
11167  }
11168 #line 11164 "ripper.c" /* yacc.c:1646 */
11169  break;
11170 
11171  case 644:
11172 #line 4783 "ripper.y" /* yacc.c:1646 */
11173  {
11174 #if 0
11175  (yyval.val) = assignable(p, (yyvsp[0].val), 0, &(yyloc));
11176 #endif
11177  (yyval.val)=assignable(p, var_field(p, (yyvsp[0].val)));
11178  }
11179 #line 11175 "ripper.c" /* yacc.c:1646 */
11180  break;
11181 
11182  case 647:
11183 #line 4796 "ripper.y" /* yacc.c:1646 */
11184  {
11185  SET_LEX_STATE(EXPR_BEG);
11186  p->command_start = TRUE;
11187  }
11188 #line 11184 "ripper.c" /* yacc.c:1646 */
11189  break;
11190 
11191  case 648:
11192 #line 4801 "ripper.y" /* yacc.c:1646 */
11193  {
11194  (yyval.val) = (yyvsp[-1].val);
11195  }
11196 #line 11192 "ripper.c" /* yacc.c:1646 */
11197  break;
11198 
11199  case 649:
11200 #line 4805 "ripper.y" /* yacc.c:1646 */
11201  {
11202 #if 0
11203  (yyval.val) = 0;
11204 #endif
11205  (yyval.val)=Qnil;
11206  }
11207 #line 11203 "ripper.c" /* yacc.c:1646 */
11208  break;
11209 
11210  case 650:
11211 #line 4814 "ripper.y" /* yacc.c:1646 */
11212  {
11213 #if 0
11214  (yyval.val) = (yyvsp[-1].val);
11215 #endif
11216  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
11217  SET_LEX_STATE(EXPR_BEG);
11218  p->command_start = TRUE;
11219  }
11220 #line 11216 "ripper.c" /* yacc.c:1646 */
11221  break;
11222 
11223  case 651:
11224 #line 4823 "ripper.y" /* yacc.c:1646 */
11225  {
11226  arg_var(p, idFWD_REST);
11227 #if idFWD_KWREST
11228  arg_var(p, idFWD_KWREST);
11229 #endif
11230  arg_var(p, idFWD_BLOCK);
11231 #if 0
11232  (yyval.val) = new_args_tail(p, Qnone, idFWD_KWREST, idFWD_BLOCK, &(yylsp[-1]));
11233  (yyval.val) = new_args(p, Qnone, Qnone, idFWD_REST, Qnone, (yyval.val), &(yylsp[-1]));
11234 #endif
11235  {VALUE v1,v2;v1=params_new(Qnone, Qnone, (yyvsp[-1].val), Qnone, Qnone, Qnone, Qnone);v2=dispatch1(paren,v1);(yyval.val)=v2;}
11236  SET_LEX_STATE(EXPR_BEG);
11237  p->command_start = TRUE;
11238  }
11239 #line 11235 "ripper.c" /* yacc.c:1646 */
11240  break;
11241 
11242  case 652:
11243 #line 4837 "ripper.y" /* yacc.c:1646 */
11244  {
11245  (yyval.num) = p->in_kwarg;
11246  p->in_kwarg = 1;
11247  SET_LEX_STATE(p->lex.state|EXPR_LABEL); /* force for args */
11248  }
11249 #line 11245 "ripper.c" /* yacc.c:1646 */
11250  break;
11251 
11252  case 653:
11253 #line 4843 "ripper.y" /* yacc.c:1646 */
11254  {
11255  p->in_kwarg = !!(yyvsp[-2].num);
11256  (yyval.val) = (yyvsp[-1].val);
11257  SET_LEX_STATE(EXPR_BEG);
11258  p->command_start = TRUE;
11259  }
11260 #line 11256 "ripper.c" /* yacc.c:1646 */
11261  break;
11262 
11263  case 654:
11264 #line 4852 "ripper.y" /* yacc.c:1646 */
11265  {
11266  (yyval.val) = new_args_tail(p, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]));
11267  }
11268 #line 11264 "ripper.c" /* yacc.c:1646 */
11269  break;
11270 
11271  case 655:
11272 #line 4856 "ripper.y" /* yacc.c:1646 */
11273  {
11274  (yyval.val) = new_args_tail(p, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yylsp[-1]));
11275  }
11276 #line 11272 "ripper.c" /* yacc.c:1646 */
11277  break;
11278 
11279  case 656:
11280 #line 4860 "ripper.y" /* yacc.c:1646 */
11281  {
11282  (yyval.val) = new_args_tail(p, Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yylsp[-1]));
11283  }
11284 #line 11280 "ripper.c" /* yacc.c:1646 */
11285  break;
11286 
11287  case 657:
11288 #line 4864 "ripper.y" /* yacc.c:1646 */
11289  {
11290  (yyval.val) = new_args_tail(p, Qnone, ID2VAL(idNil), (yyvsp[0].val), &(yylsp[-1]));
11291  }
11292 #line 11288 "ripper.c" /* yacc.c:1646 */
11293  break;
11294 
11295  case 658:
11296 #line 4868 "ripper.y" /* yacc.c:1646 */
11297  {
11298  (yyval.val) = new_args_tail(p, Qnone, Qnone, (yyvsp[0].val), &(yylsp[0]));
11299  }
11300 #line 11296 "ripper.c" /* yacc.c:1646 */
11301  break;
11302 
11303  case 659:
11304 #line 4874 "ripper.y" /* yacc.c:1646 */
11305  {
11306  (yyval.val) = (yyvsp[0].val);
11307  }
11308 #line 11304 "ripper.c" /* yacc.c:1646 */
11309  break;
11310 
11311  case 660:
11312 #line 4878 "ripper.y" /* yacc.c:1646 */
11313  {
11314  (yyval.val) = new_args_tail(p, Qnone, Qnone, Qnone, &(yylsp[0]));
11315  }
11316 #line 11312 "ripper.c" /* yacc.c:1646 */
11317  break;
11318 
11319  case 661:
11320 #line 4884 "ripper.y" /* yacc.c:1646 */
11321  {
11322  (yyval.val) = new_args(p, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
11323  }
11324 #line 11320 "ripper.c" /* yacc.c:1646 */
11325  break;
11326 
11327  case 662:
11328 #line 4888 "ripper.y" /* yacc.c:1646 */
11329  {
11330  (yyval.val) = new_args(p, (yyvsp[-7].val), (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11331  }
11332 #line 11328 "ripper.c" /* yacc.c:1646 */
11333  break;
11334 
11335  case 663:
11336 #line 4892 "ripper.y" /* yacc.c:1646 */
11337  {
11338  (yyval.val) = new_args(p, (yyvsp[-3].val), (yyvsp[-1].val), Qnone, Qnone, (yyvsp[0].val), &(yyloc));
11339  }
11340 #line 11336 "ripper.c" /* yacc.c:1646 */
11341  break;
11342 
11343  case 664:
11344 #line 4896 "ripper.y" /* yacc.c:1646 */
11345  {
11346  (yyval.val) = new_args(p, (yyvsp[-5].val), (yyvsp[-3].val), Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11347  }
11348 #line 11344 "ripper.c" /* yacc.c:1646 */
11349  break;
11350 
11351  case 665:
11352 #line 4900 "ripper.y" /* yacc.c:1646 */
11353  {
11354  (yyval.val) = new_args(p, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
11355  }
11356 #line 11352 "ripper.c" /* yacc.c:1646 */
11357  break;
11358 
11359  case 666:
11360 #line 4904 "ripper.y" /* yacc.c:1646 */
11361  {
11362  (yyval.val) = new_args(p, (yyvsp[-5].val), Qnone, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11363  }
11364 #line 11360 "ripper.c" /* yacc.c:1646 */
11365  break;
11366 
11367  case 667:
11368 #line 4908 "ripper.y" /* yacc.c:1646 */
11369  {
11370  (yyval.val) = new_args(p, (yyvsp[-1].val), Qnone, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
11371  }
11372 #line 11368 "ripper.c" /* yacc.c:1646 */
11373  break;
11374 
11375  case 668:
11376 #line 4912 "ripper.y" /* yacc.c:1646 */
11377  {
11378  (yyval.val) = new_args(p, Qnone, (yyvsp[-3].val), (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
11379  }
11380 #line 11376 "ripper.c" /* yacc.c:1646 */
11381  break;
11382 
11383  case 669:
11384 #line 4916 "ripper.y" /* yacc.c:1646 */
11385  {
11386  (yyval.val) = new_args(p, Qnone, (yyvsp[-5].val), (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11387  }
11388 #line 11384 "ripper.c" /* yacc.c:1646 */
11389  break;
11390 
11391  case 670:
11392 #line 4920 "ripper.y" /* yacc.c:1646 */
11393  {
11394  (yyval.val) = new_args(p, Qnone, (yyvsp[-1].val), Qnone, Qnone, (yyvsp[0].val), &(yyloc));
11395  }
11396 #line 11392 "ripper.c" /* yacc.c:1646 */
11397  break;
11398 
11399  case 671:
11400 #line 4924 "ripper.y" /* yacc.c:1646 */
11401  {
11402  (yyval.val) = new_args(p, Qnone, (yyvsp[-3].val), Qnone, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11403  }
11404 #line 11400 "ripper.c" /* yacc.c:1646 */
11405  break;
11406 
11407  case 672:
11408 #line 4928 "ripper.y" /* yacc.c:1646 */
11409  {
11410  (yyval.val) = new_args(p, Qnone, Qnone, (yyvsp[-1].val), Qnone, (yyvsp[0].val), &(yyloc));
11411  }
11412 #line 11408 "ripper.c" /* yacc.c:1646 */
11413  break;
11414 
11415  case 673:
11416 #line 4932 "ripper.y" /* yacc.c:1646 */
11417  {
11418  (yyval.val) = new_args(p, Qnone, Qnone, (yyvsp[-3].val), (yyvsp[-1].val), (yyvsp[0].val), &(yyloc));
11419  }
11420 #line 11416 "ripper.c" /* yacc.c:1646 */
11421  break;
11422 
11423  case 674:
11424 #line 4936 "ripper.y" /* yacc.c:1646 */
11425  {
11426  (yyval.val) = new_args(p, Qnone, Qnone, Qnone, Qnone, (yyvsp[0].val), &(yyloc));
11427  }
11428 #line 11424 "ripper.c" /* yacc.c:1646 */
11429  break;
11430 
11431  case 675:
11432 #line 4940 "ripper.y" /* yacc.c:1646 */
11433  {
11434  (yyval.val) = new_args_tail(p, Qnone, Qnone, Qnone, &(yylsp[0]));
11435  (yyval.val) = new_args(p, Qnone, Qnone, Qnone, Qnone, (yyval.val), &(yylsp[0]));
11436  }
11437 #line 11433 "ripper.c" /* yacc.c:1646 */
11438  break;
11439 
11440  case 676:
11441 #line 4947 "ripper.y" /* yacc.c:1646 */
11442  {
11443 #if 0
11444  (yyval.val) = idDot3;
11445 #endif
11446  {VALUE v1;v1=dispatch0(args_forward);(yyval.val)=v1;}
11447  }
11448 #line 11444 "ripper.c" /* yacc.c:1646 */
11449  break;
11450 
11451  case 677:
11452 #line 4956 "ripper.y" /* yacc.c:1646 */
11453  {
11454 #if 0
11455  yyerror1(&(yylsp[0]), "formal argument cannot be a constant");
11456  (yyval.val) = 0;
11457 #endif
11458  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(param_error,v1);(yyval.val)=v2;}ripper_error(p);
11459  }
11460 #line 11456 "ripper.c" /* yacc.c:1646 */
11461  break;
11462 
11463  case 678:
11464 #line 4964 "ripper.y" /* yacc.c:1646 */
11465  {
11466 #if 0
11467  yyerror1(&(yylsp[0]), "formal argument cannot be an instance variable");
11468  (yyval.val) = 0;
11469 #endif
11470  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(param_error,v1);(yyval.val)=v2;}ripper_error(p);
11471  }
11472 #line 11468 "ripper.c" /* yacc.c:1646 */
11473  break;
11474 
11475  case 679:
11476 #line 4972 "ripper.y" /* yacc.c:1646 */
11477  {
11478 #if 0
11479  yyerror1(&(yylsp[0]), "formal argument cannot be a global variable");
11480  (yyval.val) = 0;
11481 #endif
11482  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(param_error,v1);(yyval.val)=v2;}ripper_error(p);
11483  }
11484 #line 11480 "ripper.c" /* yacc.c:1646 */
11485  break;
11486 
11487  case 680:
11488 #line 4980 "ripper.y" /* yacc.c:1646 */
11489  {
11490 #if 0
11491  yyerror1(&(yylsp[0]), "formal argument cannot be a class variable");
11492  (yyval.val) = 0;
11493 #endif
11494  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(param_error,v1);(yyval.val)=v2;}ripper_error(p);
11495  }
11496 #line 11492 "ripper.c" /* yacc.c:1646 */
11497  break;
11498 
11499  case 682:
11500 #line 4991 "ripper.y" /* yacc.c:1646 */
11501  {
11502  formal_argument(p, get_id((yyvsp[0].val)));
11504  (yyval.val) = (yyvsp[0].val);
11505  }
11506 #line 11502 "ripper.c" /* yacc.c:1646 */
11507  break;
11508 
11509  case 683:
11510 #line 4999 "ripper.y" /* yacc.c:1646 */
11511  {
11512  ID id = get_id((yyvsp[0].val));
11513  arg_var(p, id);
11514  p->cur_arg = id;
11515  (yyval.val) = (yyvsp[0].val);
11516  }
11517 #line 11513 "ripper.c" /* yacc.c:1646 */
11518  break;
11519 
11520  case 684:
11521 #line 5008 "ripper.y" /* yacc.c:1646 */
11522  {
11523  p->cur_arg = 0;
11524 #if 0
11525  (yyval.val) = NEW_ARGS_AUX((yyvsp[0].val), 1, &NULL_LOC);
11526 #endif
11527  (yyval.val)=get_value((yyvsp[0].val));
11528  }
11529 #line 11525 "ripper.c" /* yacc.c:1646 */
11530  break;
11531 
11532  case 685:
11533 #line 5016 "ripper.y" /* yacc.c:1646 */
11534  {
11535 #if 0
11536  ID tid = internal_id(p);
11537  YYLTYPE loc;
11538  loc.beg_pos = (yylsp[-1]).beg_pos;
11539  loc.end_pos = (yylsp[-1]).beg_pos;
11540  arg_var(p, tid);
11541  if (dyna_in_block(p)) {
11542  (yyvsp[-1].val)->nd_value = NEW_DVAR(tid, &loc);
11543  }
11544  else {
11545  (yyvsp[-1].val)->nd_value = NEW_LVAR(tid, &loc);
11546  }
11547  (yyval.val) = NEW_ARGS_AUX(tid, 1, &NULL_LOC);
11548  (yyval.val)->nd_next = (yyvsp[-1].val);
11549 #endif
11550  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(mlhs_paren,v1);(yyval.val)=v2;}
11551  }
11552 #line 11548 "ripper.c" /* yacc.c:1646 */
11553  break;
11554 
11555  case 686:
11556 #line 5037 "ripper.y" /* yacc.c:1646 */
11557  {(yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));}
11558 #line 11554 "ripper.c" /* yacc.c:1646 */
11559  break;
11560 
11561  case 687:
11562 #line 5039 "ripper.y" /* yacc.c:1646 */
11563  {
11564 #if 0
11565  (yyval.val) = (yyvsp[-2].val);
11566  (yyval.val)->nd_plen++;
11567  (yyval.val)->nd_next = block_append(p, (yyval.val)->nd_next, (yyvsp[0].val)->nd_next);
11568  rb_discard_node(p, (yyvsp[0].val));
11569 #endif
11570  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11571  }
11572 #line 11568 "ripper.c" /* yacc.c:1646 */
11573  break;
11574 
11575  case 688:
11576 #line 5052 "ripper.y" /* yacc.c:1646 */
11577  {
11578  ID id = get_id((yyvsp[0].val));
11579  arg_var(p, formal_argument(p, id));
11580  p->cur_arg = id;
11582  (yyval.val) = (yyvsp[0].val);
11583  }
11584 #line 11580 "ripper.c" /* yacc.c:1646 */
11585  break;
11586 
11587  case 689:
11588 #line 5062 "ripper.y" /* yacc.c:1646 */
11589  {
11590  p->cur_arg = 0;
11591 #if 0
11592  (yyval.val) = new_kw_arg(p, assignable(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
11593 #endif
11594  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[-1].val))), get_value((yyvsp[0].val)));
11595  }
11596 #line 11592 "ripper.c" /* yacc.c:1646 */
11597  break;
11598 
11599  case 690:
11600 #line 5070 "ripper.y" /* yacc.c:1646 */
11601  {
11602  p->cur_arg = 0;
11603 #if 0
11604  (yyval.val) = new_kw_arg(p, assignable(p, (yyvsp[0].val), NODE_SPECIAL_REQUIRED_KEYWORD, &(yyloc)), &(yyloc));
11605 #endif
11606  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[0].val))), 0);
11607  }
11608 #line 11604 "ripper.c" /* yacc.c:1646 */
11609  break;
11610 
11611  case 691:
11612 #line 5080 "ripper.y" /* yacc.c:1646 */
11613  {
11614 #if 0
11615  (yyval.val) = new_kw_arg(p, assignable(p, (yyvsp[-1].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
11616 #endif
11617  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[-1].val))), get_value((yyvsp[0].val)));
11618  }
11619 #line 11615 "ripper.c" /* yacc.c:1646 */
11620  break;
11621 
11622  case 692:
11623 #line 5087 "ripper.y" /* yacc.c:1646 */
11624  {
11625 #if 0
11626  (yyval.val) = new_kw_arg(p, assignable(p, (yyvsp[0].val), NODE_SPECIAL_REQUIRED_KEYWORD, &(yyloc)), &(yyloc));
11627 #endif
11628  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[0].val))), 0);
11629  }
11630 #line 11626 "ripper.c" /* yacc.c:1646 */
11631  break;
11632 
11633  case 693:
11634 #line 5096 "ripper.y" /* yacc.c:1646 */
11635  {
11636 #if 0
11637  (yyval.val) = (yyvsp[0].val);
11638 #endif
11639  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
11640  }
11641 #line 11637 "ripper.c" /* yacc.c:1646 */
11642  break;
11643 
11644  case 694:
11645 #line 5103 "ripper.y" /* yacc.c:1646 */
11646  {
11647 #if 0
11648  (yyval.val) = kwd_append((yyvsp[-2].val), (yyvsp[0].val));
11649 #endif
11650  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11651  }
11652 #line 11648 "ripper.c" /* yacc.c:1646 */
11653  break;
11654 
11655  case 695:
11656 #line 5113 "ripper.y" /* yacc.c:1646 */
11657  {
11658 #if 0
11659  (yyval.val) = (yyvsp[0].val);
11660 #endif
11661  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
11662  }
11663 #line 11659 "ripper.c" /* yacc.c:1646 */
11664  break;
11665 
11666  case 696:
11667 #line 5120 "ripper.y" /* yacc.c:1646 */
11668  {
11669 #if 0
11670  (yyval.val) = kwd_append((yyvsp[-2].val), (yyvsp[0].val));
11671 #endif
11672  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11673  }
11674 #line 11670 "ripper.c" /* yacc.c:1646 */
11675  break;
11676 
11677  case 699:
11678 #line 5133 "ripper.y" /* yacc.c:1646 */
11679  {
11680 #if 0
11681 #endif
11682  {VALUE v1,v2;v1=Qnil;v2=dispatch1(nokw_param,v1);(yyval.val)=v2;}
11683  }
11684 #line 11680 "ripper.c" /* yacc.c:1646 */
11685  break;
11686 
11687  case 700:
11688 #line 5141 "ripper.y" /* yacc.c:1646 */
11689  {
11690  arg_var(p, shadowing_lvar(p, get_id((yyvsp[0].val))));
11691 #if 0
11692  (yyval.val) = (yyvsp[0].val);
11693 #endif
11694  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(kwrest_param,v1);(yyval.val)=v2;}
11695  }
11696 #line 11692 "ripper.c" /* yacc.c:1646 */
11697  break;
11698 
11699  case 701:
11700 #line 5149 "ripper.y" /* yacc.c:1646 */
11701  {
11702 #if 0
11703  (yyval.val) = internal_id(p);
11704  arg_var(p, (yyval.val));
11705 #endif
11706  {VALUE v1,v2;v1=Qnil;v2=dispatch1(kwrest_param,v1);(yyval.val)=v2;}
11707  }
11708 #line 11704 "ripper.c" /* yacc.c:1646 */
11709  break;
11710 
11711  case 702:
11712 #line 5159 "ripper.y" /* yacc.c:1646 */
11713  {
11714  p->cur_arg = 0;
11715 #if 0
11716  (yyval.val) = NEW_OPT_ARG(0, assignable(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
11717 #endif
11718  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[-2].val))), get_value((yyvsp[0].val)));
11719  }
11720 #line 11716 "ripper.c" /* yacc.c:1646 */
11721  break;
11722 
11723  case 703:
11724 #line 5169 "ripper.y" /* yacc.c:1646 */
11725  {
11726  p->cur_arg = 0;
11727 #if 0
11728  (yyval.val) = NEW_OPT_ARG(0, assignable(p, (yyvsp[-2].val), (yyvsp[0].val), &(yyloc)), &(yyloc));
11729 #endif
11730  (yyval.val)=rb_assoc_new(get_value(assignable(p, (yyvsp[-2].val))), get_value((yyvsp[0].val)));
11731  }
11732 #line 11728 "ripper.c" /* yacc.c:1646 */
11733  break;
11734 
11735  case 704:
11736 #line 5179 "ripper.y" /* yacc.c:1646 */
11737  {
11738 #if 0
11739  (yyval.val) = (yyvsp[0].val);
11740 #endif
11741  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
11742  }
11743 #line 11739 "ripper.c" /* yacc.c:1646 */
11744  break;
11745 
11746  case 705:
11747 #line 5186 "ripper.y" /* yacc.c:1646 */
11748  {
11749 #if 0
11750  (yyval.val) = opt_arg_append((yyvsp[-2].val), (yyvsp[0].val));
11751 #endif
11752  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11753  }
11754 #line 11750 "ripper.c" /* yacc.c:1646 */
11755  break;
11756 
11757  case 706:
11758 #line 5195 "ripper.y" /* yacc.c:1646 */
11759  {
11760 #if 0
11761  (yyval.val) = (yyvsp[0].val);
11762 #endif
11763  (yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));
11764  }
11765 #line 11761 "ripper.c" /* yacc.c:1646 */
11766  break;
11767 
11768  case 707:
11769 #line 5202 "ripper.y" /* yacc.c:1646 */
11770  {
11771 #if 0
11772  (yyval.val) = opt_arg_append((yyvsp[-2].val), (yyvsp[0].val));
11773 #endif
11774  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11775  }
11776 #line 11772 "ripper.c" /* yacc.c:1646 */
11777  break;
11778 
11779  case 710:
11780 #line 5215 "ripper.y" /* yacc.c:1646 */
11781  {
11782  arg_var(p, shadowing_lvar(p, get_id((yyvsp[0].val))));
11783 #if 0
11784  (yyval.val) = (yyvsp[0].val);
11785 #endif
11786  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(rest_param,v1);(yyval.val)=v2;}
11787  }
11788 #line 11784 "ripper.c" /* yacc.c:1646 */
11789  break;
11790 
11791  case 711:
11792 #line 5223 "ripper.y" /* yacc.c:1646 */
11793  {
11794 #if 0
11795  (yyval.val) = internal_id(p);
11796  arg_var(p, (yyval.val));
11797 #endif
11798  {VALUE v1,v2;v1=Qnil;v2=dispatch1(rest_param,v1);(yyval.val)=v2;}
11799  }
11800 #line 11796 "ripper.c" /* yacc.c:1646 */
11801  break;
11802 
11803  case 714:
11804 #line 5237 "ripper.y" /* yacc.c:1646 */
11805  {
11806  arg_var(p, shadowing_lvar(p, get_id((yyvsp[0].val))));
11807 #if 0
11808  (yyval.val) = (yyvsp[0].val);
11809 #endif
11810  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(blockarg,v1);(yyval.val)=v2;}
11811  }
11812 #line 11808 "ripper.c" /* yacc.c:1646 */
11813  break;
11814 
11815  case 715:
11816 #line 5247 "ripper.y" /* yacc.c:1646 */
11817  {
11818  (yyval.val) = (yyvsp[0].val);
11819  }
11820 #line 11816 "ripper.c" /* yacc.c:1646 */
11821  break;
11822 
11823  case 716:
11824 #line 5251 "ripper.y" /* yacc.c:1646 */
11825  {
11826  (yyval.val) = Qnull;
11827  }
11828 #line 11824 "ripper.c" /* yacc.c:1646 */
11829  break;
11830 
11831  case 717:
11832 #line 5257 "ripper.y" /* yacc.c:1646 */
11833  {
11834  value_expr((yyvsp[0].val));
11835  (yyval.val) = (yyvsp[0].val);
11836  }
11837 #line 11833 "ripper.c" /* yacc.c:1646 */
11838  break;
11839 
11840  case 718:
11841 #line 5261 "ripper.y" /* yacc.c:1646 */
11842  {SET_LEX_STATE(EXPR_BEG);}
11843 #line 11839 "ripper.c" /* yacc.c:1646 */
11844  break;
11845 
11846  case 719:
11847 #line 5262 "ripper.y" /* yacc.c:1646 */
11848  {
11849 #if 0
11850  switch (nd_type((yyvsp[-1].val))) {
11851  case NODE_STR:
11852  case NODE_DSTR:
11853  case NODE_XSTR:
11854  case NODE_DXSTR:
11855  case NODE_DREGX:
11856  case NODE_LIT:
11857  case NODE_LIST:
11858  case NODE_ZLIST:
11859  yyerror1(&(yylsp[-1]), "can't define singleton method for literals");
11860  break;
11861  default:
11862  value_expr((yyvsp[-1].val));
11863  break;
11864  }
11865  (yyval.val) = (yyvsp[-1].val);
11866 #endif
11867  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(paren,v1);(yyval.val)=v2;}
11868  }
11869 #line 11865 "ripper.c" /* yacc.c:1646 */
11870  break;
11871 
11872  case 721:
11873 #line 5287 "ripper.y" /* yacc.c:1646 */
11874  {
11875 #if 0
11876  (yyval.val) = (yyvsp[-1].val);
11877 #endif
11878  {VALUE v1,v2;v1=(yyvsp[-1].val);v2=dispatch1(assoclist_from_args,v1);(yyval.val)=v2;}
11879  }
11880 #line 11876 "ripper.c" /* yacc.c:1646 */
11881  break;
11882 
11883  case 722:
11884 #line 5296 "ripper.y" /* yacc.c:1646 */
11885  {(yyval.val)=rb_ary_new3(1, get_value((yyvsp[0].val)));}
11886 #line 11882 "ripper.c" /* yacc.c:1646 */
11887  break;
11888 
11889  case 723:
11890 #line 5298 "ripper.y" /* yacc.c:1646 */
11891  {
11892 #if 0
11893  NODE *assocs = (yyvsp[-2].val);
11894  NODE *tail = (yyvsp[0].val);
11895  if (!assocs) {
11896  assocs = tail;
11897  }
11898  else if (tail) {
11899  if (assocs->nd_head &&
11900  !tail->nd_head && nd_type(tail->nd_next) == NODE_LIST &&
11901  nd_type(tail->nd_next->nd_head) == NODE_HASH) {
11902  /* DSTAR */
11903  tail = tail->nd_next->nd_head->nd_head;
11904  }
11905  assocs = list_concat(assocs, tail);
11906  }
11907  (yyval.val) = assocs;
11908 #endif
11909  (yyval.val)=rb_ary_push((yyvsp[-2].val), get_value((yyvsp[0].val)));
11910  }
11911 #line 11907 "ripper.c" /* yacc.c:1646 */
11912  break;
11913 
11914  case 724:
11915 #line 5321 "ripper.y" /* yacc.c:1646 */
11916  {
11917 #if 0
11918  if (nd_type((yyvsp[-2].val)) == NODE_STR) {
11919  nd_set_type((yyvsp[-2].val), NODE_LIT);
11920  RB_OBJ_WRITE(p->ast, &(yyvsp[-2].val)->nd_lit, rb_fstring((yyvsp[-2].val)->nd_lit));
11921  }
11922  (yyval.val) = list_append(p, NEW_LIST((yyvsp[-2].val), &(yyloc)), (yyvsp[0].val));
11923 #endif
11924  {VALUE v1,v2,v3;v1=(yyvsp[-2].val);v2=(yyvsp[0].val);v3=dispatch2(assoc_new,v1,v2);(yyval.val)=v3;}
11925  }
11926 #line 11922 "ripper.c" /* yacc.c:1646 */
11927  break;
11928 
11929  case 725:
11930 #line 5332 "ripper.y" /* yacc.c:1646 */
11931  {
11932 #if 0
11933  (yyval.val) = list_append(p, NEW_LIST(NEW_LIT(ID2SYM((yyvsp[-1].val)), &(yylsp[-1])), &(yyloc)), (yyvsp[0].val));
11934 #endif
11935  {VALUE v1,v2,v3;v1=(yyvsp[-1].val);v2=(yyvsp[0].val);v3=dispatch2(assoc_new,v1,v2);(yyval.val)=v3;}
11936  }
11937 #line 11933 "ripper.c" /* yacc.c:1646 */
11938  break;
11939 
11940  case 726:
11941 #line 5339 "ripper.y" /* yacc.c:1646 */
11942  {
11943 #if 0
11944  YYLTYPE loc = code_loc_gen(&(yylsp[-3]), &(yylsp[-1]));
11945  (yyval.val) = list_append(p, NEW_LIST(dsym_node(p, (yyvsp[-2].val), &loc), &loc), (yyvsp[0].val));
11946 #endif
11947  {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;}
11948  }
11949 #line 11945 "ripper.c" /* yacc.c:1646 */
11950  break;
11951 
11952  case 727:
11953 #line 5347 "ripper.y" /* yacc.c:1646 */
11954  {
11955 #if 0
11956  if (nd_type((yyvsp[0].val)) == NODE_HASH &&
11957  !((yyvsp[0].val)->nd_head && (yyvsp[0].val)->nd_head->nd_alen)) {
11958  static VALUE empty_hash;
11959  if (!empty_hash) {
11960  empty_hash = rb_obj_freeze(rb_hash_new());
11961  rb_gc_register_mark_object(empty_hash);
11962  }
11963  (yyval.val) = list_append(p, NEW_LIST(0, &(yyloc)), NEW_LIT(empty_hash, &(yyloc)));
11964  }
11965  else
11966  (yyval.val) = list_append(p, NEW_LIST(0, &(yyloc)), (yyvsp[0].val));
11967 #endif
11968  {VALUE v1,v2;v1=(yyvsp[0].val);v2=dispatch1(assoc_splat,v1);(yyval.val)=v2;}
11969  }
11970 #line 11966 "ripper.c" /* yacc.c:1646 */
11971  break;
11972 
11973  case 753:
11974 #line 5412 "ripper.y" /* yacc.c:1646 */
11975  {yyerrok;token_flush(p);}
11976 #line 11972 "ripper.c" /* yacc.c:1646 */
11977  break;
11978 
11979  case 754:
11980 #line 5413 "ripper.y" /* yacc.c:1646 */
11981  {token_flush(p);}
11982 #line 11978 "ripper.c" /* yacc.c:1646 */
11983  break;
11984 
11985  case 756:
11986 #line 5417 "ripper.y" /* yacc.c:1646 */
11987  {yyerrok;}
11988 #line 11984 "ripper.c" /* yacc.c:1646 */
11989  break;
11990 
11991  case 757:
11992 #line 5421 "ripper.y" /* yacc.c:1646 */
11993  {
11994  (yyval.val) = Qnull;
11995  }
11996 #line 11992 "ripper.c" /* yacc.c:1646 */
11997  break;
11998 
11999 
12000 #line 11996 "ripper.c" /* yacc.c:1646 */
12001  default: break;
12002  }
12003  /* User semantic actions sometimes alter yychar, and that requires
12004  that yytoken be updated with the new translation. We take the
12005  approach of translating immediately before every use of yytoken.
12006  One alternative is translating here after every semantic action,
12007  but that translation would be missed if the semantic action invokes
12008  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
12009  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
12010  incorrect destructor might then be invoked immediately. In the
12011  case of YYERROR or YYBACKUP, subsequent parser actions might lead
12012  to an incorrect destructor call or verbose syntax error message
12013  before the lookahead is translated. */
12014  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
12015 
12016  YYPOPSTACK (yylen);
12017  yylen = 0;
12018  YY_STACK_PRINT (yyss, yyssp);
12019 
12020  *++yyvsp = yyval;
12021  *++yylsp = yyloc;
12022 
12023  /* Now 'shift' the result of the reduction. Determine what state
12024  that goes to, based on the state we popped back to and the rule
12025  number reduced by. */
12026 
12027  yyn = yyr1[yyn];
12028 
12029  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
12030  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
12031  yystate = yytable[yystate];
12032  else
12033  yystate = yydefgoto[yyn - YYNTOKENS];
12034 
12035  goto yynewstate;
12036 
12037 
12038 /*--------------------------------------.
12039 | yyerrlab -- here on detecting error. |
12040 `--------------------------------------*/
12041 yyerrlab:
12042  /* Make sure we have latest lookahead translation. See comments at
12043  user semantic actions for why this is necessary. */
12044  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
12045 
12046  /* If not already recovering from an error, report this error. */
12047  if (!yyerrstatus)
12048  {
12049  ++yynerrs;
12050 #if ! YYERROR_VERBOSE
12051  yyerror (&yylloc, p, YY_("syntax error"));
12052 #else
12053 # define YYSYNTAX_ERROR yysyntax_error (p, &yymsg_alloc, &yymsg, \
12054  yyssp, yytoken)
12055  {
12056  char const *yymsgp = YY_("syntax error");
12057  int yysyntax_error_status;
12058  yysyntax_error_status = YYSYNTAX_ERROR;
12059  if (yysyntax_error_status == 0)
12060  yymsgp = yymsg;
12061  else if (yysyntax_error_status == 1)
12062  {
12063  if (yymsg != yymsgbuf)
12064  YYSTACK_FREE (yymsg);
12065  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
12066  if (!yymsg)
12067  {
12068  yymsg = yymsgbuf;
12069  yymsg_alloc = sizeof yymsgbuf;
12070  yysyntax_error_status = 2;
12071  }
12072  else
12073  {
12074  yysyntax_error_status = YYSYNTAX_ERROR;
12075  yymsgp = yymsg;
12076  }
12077  }
12078  yyerror (&yylloc, p, yymsgp);
12079  if (yysyntax_error_status == 2)
12080  goto yyexhaustedlab;
12081  }
12082 # undef YYSYNTAX_ERROR
12083 #endif
12084  }
12085 
12086  yyerror_range[1] = yylloc;
12087 
12088  if (yyerrstatus == 3)
12089  {
12090  /* If just tried and failed to reuse lookahead token after an
12091  error, discard it. */
12092 
12093  if (yychar <= YYEOF)
12094  {
12095  /* Return failure if at end of input. */
12096  if (yychar == YYEOF)
12097  YYABORT;
12098  }
12099  else
12100  {
12101  yydestruct ("Error: discarding",
12102  yytoken, &yylval, &yylloc, p);
12103  yychar = YYEMPTY;
12104  }
12105  }
12106 
12107  /* Else will try to reuse lookahead token after shifting the error
12108  token. */
12109  goto yyerrlab1;
12110 
12111 
12112 /*---------------------------------------------------.
12113 | yyerrorlab -- error raised explicitly by YYERROR. |
12114 `---------------------------------------------------*/
12115 yyerrorlab:
12116 
12117  /* Pacify compilers like GCC when the user code never invokes
12118  YYERROR and the label yyerrorlab therefore never appears in user
12119  code. */
12120  if (/*CONSTCOND*/ 0)
12121  goto yyerrorlab;
12122 
12123  yyerror_range[1] = yylsp[1-yylen];
12124  /* Do not reclaim the symbols of the rule whose action triggered
12125  this YYERROR. */
12126  YYPOPSTACK (yylen);
12127  yylen = 0;
12128  YY_STACK_PRINT (yyss, yyssp);
12129  yystate = *yyssp;
12130  goto yyerrlab1;
12131 
12132 
12133 /*-------------------------------------------------------------.
12134 | yyerrlab1 -- common code for both syntax error and YYERROR. |
12135 `-------------------------------------------------------------*/
12136 yyerrlab1:
12137  yyerrstatus = 3; /* Each real token shifted decrements this. */
12138 
12139  for (;;)
12140  {
12141  yyn = yypact[yystate];
12142  if (!yypact_value_is_default (yyn))
12143  {
12144  yyn += YYTERROR;
12145  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
12146  {
12147  yyn = yytable[yyn];
12148  if (0 < yyn)
12149  break;
12150  }
12151  }
12152 
12153  /* Pop the current state because it cannot handle the error token. */
12154  if (yyssp == yyss)
12155  YYABORT;
12156 
12157  yyerror_range[1] = *yylsp;
12158  yydestruct ("Error: popping",
12159  yystos[yystate], yyvsp, yylsp, p);
12160  YYPOPSTACK (1);
12161  yystate = *yyssp;
12162  YY_STACK_PRINT (yyss, yyssp);
12163  }
12164 
12166  *++yyvsp = yylval;
12168 
12169  yyerror_range[2] = yylloc;
12170  /* Using YYLLOC is tempting, but would change the location of
12171  the lookahead. YYLOC is available though. */
12172  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
12173  *++yylsp = yyloc;
12174 
12175  /* Shift the error token. */
12176  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
12177 
12178  yystate = yyn;
12179  goto yynewstate;
12180 
12181 
12182 /*-------------------------------------.
12183 | yyacceptlab -- YYACCEPT comes here. |
12184 `-------------------------------------*/
12185 yyacceptlab:
12186  yyresult = 0;
12187  goto yyreturn;
12188 
12189 /*-----------------------------------.
12190 | yyabortlab -- YYABORT comes here. |
12191 `-----------------------------------*/
12192 yyabortlab:
12193  yyresult = 1;
12194  goto yyreturn;
12195 
12196 #if !defined yyoverflow || YYERROR_VERBOSE
12197 /*-------------------------------------------------.
12198 | yyexhaustedlab -- memory exhaustion comes here. |
12199 `-------------------------------------------------*/
12200 yyexhaustedlab:
12201  yyerror (&yylloc, p, YY_("memory exhausted"));
12202  yyresult = 2;
12203  /* Fall through. */
12204 #endif
12205 
12206 yyreturn:
12207  if (yychar != YYEMPTY)
12208  {
12209  /* Make sure we have latest lookahead translation. See comments at
12210  user semantic actions for why this is necessary. */
12211  yytoken = YYTRANSLATE (yychar);
12212  yydestruct ("Cleanup: discarding lookahead",
12213  yytoken, &yylval, &yylloc, p);
12214  }
12215  /* Do not reclaim the symbols of the rule whose action triggered
12216  this YYABORT or YYACCEPT. */
12217  YYPOPSTACK (yylen);
12218  YY_STACK_PRINT (yyss, yyssp);
12219  while (yyssp != yyss)
12220  {
12221  yydestruct ("Cleanup: popping",
12222  yystos[*yyssp], yyvsp, yylsp, p);
12223  YYPOPSTACK (1);
12224  }
12225 #ifndef yyoverflow
12226  if (yyss != yyssa)
12227  YYSTACK_FREE (yyss);
12228 #endif
12229 #if YYERROR_VERBOSE
12230  if (yymsg != yymsgbuf)
12231  YYSTACK_FREE (yymsg);
12232 #endif
12233  return yyresult;
12234 }
12235 #line 5425 "ripper.y" /* yacc.c:1906 */
12236 
12237 # undef p
12238 # undef yylex
12239 # undef yylval
12240 # define yylval (*p->lval)
12241 
12242 static int regx_options(struct parser_params*);
12243 static int tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**,rb_encoding**);
12244 static void tokaddmbc(struct parser_params *p, int c, rb_encoding *enc);
12245 static enum yytokentype parse_string(struct parser_params*,rb_strterm_literal_t*);
12246 static enum yytokentype here_document(struct parser_params*,rb_strterm_heredoc_t*);
12247 
12248 #ifndef RIPPER
12249 # define set_yylval_node(x) { \
12250  YYLTYPE _cur_loc; \
12251  rb_parser_set_location(p, &_cur_loc); \
12252  yylval.node = (x); \
12253 }
12254 # define set_yylval_str(x) \
12255 do { \
12256  set_yylval_node(NEW_STR(x, &_cur_loc)); \
12257  RB_OBJ_WRITTEN(p->ast, Qnil, x); \
12258 } while(0)
12259 # define set_yylval_literal(x) \
12260 do { \
12261  set_yylval_node(NEW_LIT(x, &_cur_loc)); \
12262  RB_OBJ_WRITTEN(p->ast, Qnil, x); \
12263 } while(0)
12264 # define set_yylval_num(x) (yylval.num = (x))
12265 # define set_yylval_id(x) (yylval.id = (x))
12266 # define set_yylval_name(x) (yylval.id = (x))
12267 # define yylval_id() (yylval.id)
12268 #else
12269 static inline VALUE
12270 ripper_yylval_id(struct parser_params *p, ID x)
12271 {
12272  return ripper_new_yylval(p, x, ID2SYM(x), 0);
12273 }
12274 # define set_yylval_str(x) (yylval.val = add_mark_object(p, (x)))
12275 # define set_yylval_num(x) (yylval.val = ripper_new_yylval(p, (x), 0, 0))
12276 # define set_yylval_id(x) (void)(x)
12277 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(p, x))
12278 # define set_yylval_literal(x) add_mark_object(p, (x))
12279 # define set_yylval_node(x) (void)(x)
12280 # define yylval_id() yylval.id
12281 # define _cur_loc NULL_LOC /* dummy */
12282 #endif
12283 
12284 #define set_yylval_noname() set_yylval_id(keyword_nil)
12285 
12286 #ifndef RIPPER
12287 #define literal_flush(p, ptr) ((p)->lex.ptok = (ptr))
12288 #define dispatch_scan_event(p, t) ((void)0)
12289 #define dispatch_delayed_token(p, t) ((void)0)
12290 #define has_delayed_token(p) (0)
12291 #else
12292 #define literal_flush(p, ptr) ((void)(ptr))
12293 
12294 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
12295 
12296 static inline VALUE
12297 intern_sym(const char *name)
12298 {
12299  ID id = rb_intern_const(name);
12300  return ID2SYM(id);
12301 }
12302 
12303 static int
12304 ripper_has_scan_event(struct parser_params *p)
12305 {
12306  if (p->lex.pcur < p->lex.ptok) rb_raise(rb_eRuntimeError, "lex.pcur < lex.ptok");
12307  return p->lex.pcur > p->lex.ptok;
12308 }
12309 
12310 static VALUE
12311 ripper_scan_event_val(struct parser_params *p, enum yytokentype t)
12312 {
12313  VALUE str = STR_NEW(p->lex.ptok, p->lex.pcur - p->lex.ptok);
12314  VALUE rval = ripper_dispatch1(p, ripper_token2eventid(t), str);
12315  token_flush(p);
12316  return rval;
12317 }
12318 
12319 static void
12320 ripper_dispatch_scan_event(struct parser_params *p, enum yytokentype t)
12321 {
12322  if (!ripper_has_scan_event(p)) return;
12323  add_mark_object(p, yylval_rval = ripper_scan_event_val(p, t));
12324 }
12325 #define dispatch_scan_event(p, t) ripper_dispatch_scan_event(p, t)
12326 
12327 static void
12328 ripper_dispatch_delayed_token(struct parser_params *p, enum yytokentype t)
12329 {
12330  int saved_line = p->ruby_sourceline;
12331  const char *saved_tokp = p->lex.ptok;
12332 
12333  if (NIL_P(p->delayed.token)) return;
12334  p->ruby_sourceline = p->delayed.line;
12335  p->lex.ptok = p->lex.pbeg + p->delayed.col;
12336  add_mark_object(p, yylval_rval = ripper_dispatch1(p, ripper_token2eventid(t), p->delayed.token));
12337  p->delayed.token = Qnil;
12338  p->ruby_sourceline = saved_line;
12339  p->lex.ptok = saved_tokp;
12340 }
12341 #define dispatch_delayed_token(p, t) ripper_dispatch_delayed_token(p, t)
12342 #define has_delayed_token(p) (!NIL_P(p->delayed.token))
12343 #endif /* RIPPER */
12344 
12345 #include "ruby/regex.h"
12346 #include "ruby/util.h"
12347 
12348 static inline int
12349 is_identchar(const char *ptr, const char *MAYBE_UNUSED(ptr_end), rb_encoding *enc)
12350 {
12351  return rb_enc_isalnum((unsigned char)*ptr, enc) || *ptr == '_' || !ISASCII(*ptr);
12352 }
12353 
12354 static inline int
12355 parser_is_identchar(struct parser_params *p)
12356 {
12357  return !(p)->eofp && is_identchar(p->lex.pcur-1, p->lex.pend, p->enc);
12358 }
12359 
12360 static inline int
12361 parser_isascii(struct parser_params *p)
12362 {
12363  return ISASCII(*(p->lex.pcur-1));
12364 }
12365 
12366 static void
12367 token_info_setup(token_info *ptinfo, const char *ptr, const rb_code_location_t *loc)
12368 {
12369  int column = 1, nonspc = 0, i;
12370  for (i = 0; i < loc->beg_pos.column; i++, ptr++) {
12371  if (*ptr == '\t') {
12372  column = (((column - 1) / TAB_WIDTH) + 1) * TAB_WIDTH;
12373  }
12374  column++;
12375  if (*ptr != ' ' && *ptr != '\t') {
12376  nonspc = 1;
12377  }
12378  }
12379 
12380  ptinfo->beg = loc->beg_pos;
12381  ptinfo->indent = column;
12382  ptinfo->nonspc = nonspc;
12383 }
12384 
12385 static void
12386 token_info_push(struct parser_params *p, const char *token, const rb_code_location_t *loc)
12387 {
12388  token_info *ptinfo;
12389 
12390  if (!p->token_info_enabled) return;
12391  ptinfo = ALLOC(token_info);
12392  ptinfo->token = token;
12393  ptinfo->next = p->token_info;
12394  token_info_setup(ptinfo, p->lex.pbeg, loc);
12395 
12396  p->token_info = ptinfo;
12397 }
12398 
12399 static void
12400 token_info_pop(struct parser_params *p, const char *token, const rb_code_location_t *loc)
12401 {
12402  token_info *ptinfo_beg = p->token_info;
12403 
12404  if (!ptinfo_beg) return;
12405  p->token_info = ptinfo_beg->next;
12406 
12407  /* indentation check of matched keywords (begin..end, if..end, etc.) */
12408  token_info_warn(p, token, ptinfo_beg, 1, loc);
12409  ruby_sized_xfree(ptinfo_beg, sizeof(*ptinfo_beg));
12410 }
12411 
12412 static void
12413 token_info_warn(struct parser_params *p, const char *token, token_info *ptinfo_beg, int same, const rb_code_location_t *loc)
12414 {
12415  token_info ptinfo_end_body, *ptinfo_end = &ptinfo_end_body;
12416  if (!p->token_info_enabled) return;
12417  if (!ptinfo_beg) return;
12418  token_info_setup(ptinfo_end, p->lex.pbeg, loc);
12419  if (ptinfo_beg->beg.lineno == ptinfo_end->beg.lineno) return; /* ignore one-line block */
12420  if (ptinfo_beg->nonspc || ptinfo_end->nonspc) return; /* ignore keyword in the middle of a line */
12421  if (ptinfo_beg->indent == ptinfo_end->indent) return; /* the indents are matched */
12422  if (!same && ptinfo_beg->indent < ptinfo_end->indent) return;
12423  rb_warn3L(ptinfo_end->beg.lineno,
12424  "mismatched indentations at '%s' with '%s' at %d",
12425  WARN_S(token), WARN_S(ptinfo_beg->token), WARN_I(ptinfo_beg->beg.lineno));
12426 }
12427 
12428 static int
12429 parser_precise_mbclen(struct parser_params *p, const char *ptr)
12430 {
12431  int len = rb_enc_precise_mbclen(ptr, p->lex.pend, p->enc);
12432  if (!MBCLEN_CHARFOUND_P(len)) {
12433  compile_error(p, "invalid multibyte char (%s)", rb_enc_name(p->enc));
12434  return -1;
12435  }
12436  return len;
12437 }
12438 
12439 #ifndef RIPPER
12440 static void ruby_show_error_line(VALUE errbuf, const YYLTYPE *yylloc, int lineno, VALUE str);
12441 
12442 static inline void
12443 parser_show_error_line(struct parser_params *p, const YYLTYPE *yylloc)
12444 {
12445  VALUE str;
12446  int lineno = p->ruby_sourceline;
12447  if (!yylloc) {
12448  return;
12449  }
12450  else if (yylloc->beg_pos.lineno == lineno) {
12451  str = p->lex.lastline;
12452  }
12453  else {
12454  return;
12455  }
12456  ruby_show_error_line(p->error_buffer, yylloc, lineno, str);
12457 }
12458 
12459 static int
12460 parser_yyerror(struct parser_params *p, const YYLTYPE *yylloc, const char *msg)
12461 {
12462  YYLTYPE current;
12463 
12464  if (!yylloc) {
12465  yylloc = RUBY_SET_YYLLOC(current);
12466  }
12467  else if ((p->ruby_sourceline != yylloc->beg_pos.lineno &&
12468  p->ruby_sourceline != yylloc->end_pos.lineno) ||
12469  (yylloc->beg_pos.lineno == yylloc->end_pos.lineno &&
12470  yylloc->beg_pos.column == yylloc->end_pos.column)) {
12471  yylloc = 0;
12472  }
12473  compile_error(p, "%s", msg);
12474  parser_show_error_line(p, yylloc);
12475  return 0;
12476 }
12477 
12478 static void
12479 ruby_show_error_line(VALUE errbuf, const YYLTYPE *yylloc, int lineno, VALUE str)
12480 {
12481  VALUE mesg;
12482  const int max_line_margin = 30;
12483  const char *ptr, *ptr_end, *pt, *pb;
12484  const char *pre = "", *post = "", *pend;
12485  const char *code = "", *caret = "";
12486  const char *lim;
12487  const char *const pbeg = RSTRING_PTR(str);
12488  char *buf;
12489  long len;
12490  int i;
12491 
12492  if (!yylloc) return;
12493  pend = RSTRING_END(str);
12494  if (pend > pbeg && pend[-1] == '\n') {
12495  if (--pend > pbeg && pend[-1] == '\r') --pend;
12496  }
12497 
12498  pt = pend;
12499  if (lineno == yylloc->end_pos.lineno &&
12500  (pend - pbeg) > yylloc->end_pos.column) {
12501  pt = pbeg + yylloc->end_pos.column;
12502  }
12503 
12504  ptr = ptr_end = pt;
12505  lim = ptr - pbeg > max_line_margin ? ptr - max_line_margin : pbeg;
12506  while ((lim < ptr) && (*(ptr-1) != '\n')) ptr--;
12507 
12508  lim = pend - ptr_end > max_line_margin ? ptr_end + max_line_margin : pend;
12509  while ((ptr_end < lim) && (*ptr_end != '\n') && (*ptr_end != '\r')) ptr_end++;
12510 
12511  len = ptr_end - ptr;
12512  if (len > 4) {
12513  if (ptr > pbeg) {
12514  ptr = rb_enc_prev_char(pbeg, ptr, pt, rb_enc_get(str));
12515  if (ptr > pbeg) pre = "...";
12516  }
12517  if (ptr_end < pend) {
12518  ptr_end = rb_enc_prev_char(pt, ptr_end, pend, rb_enc_get(str));
12519  if (ptr_end < pend) post = "...";
12520  }
12521  }
12522  pb = pbeg;
12523  if (lineno == yylloc->beg_pos.lineno) {
12524  pb += yylloc->beg_pos.column;
12525  if (pb > pt) pb = pt;
12526  }
12527  if (pb < ptr) pb = ptr;
12528  if (len <= 4 && yylloc->beg_pos.lineno == yylloc->end_pos.lineno) {
12529  return;
12530  }
12531  if (RTEST(errbuf)) {
12532  mesg = rb_attr_get(errbuf, idMesg);
12533  if (RSTRING_LEN(mesg) > 0 && *(RSTRING_END(mesg)-1) != '\n')
12534  rb_str_cat_cstr(mesg, "\n");
12535  }
12536  else {
12537  mesg = rb_enc_str_new(0, 0, rb_enc_get(str));
12538  }
12539  if (!errbuf && rb_stderr_tty_p()) {
12540 #define CSI_BEGIN "\033["
12541 #define CSI_SGR "m"
12542  rb_str_catf(mesg,
12543  CSI_BEGIN""CSI_SGR"%s" /* pre */
12544  CSI_BEGIN"1"CSI_SGR"%.*s"
12545  CSI_BEGIN"1;4"CSI_SGR"%.*s"
12546  CSI_BEGIN";1"CSI_SGR"%.*s"
12547  CSI_BEGIN""CSI_SGR"%s" /* post */
12548  "\n",
12549  pre,
12550  (int)(pb - ptr), ptr,
12551  (int)(pt - pb), pb,
12552  (int)(ptr_end - pt), pt,
12553  post);
12554  }
12555  else {
12556  char *p2;
12557 
12558  len = ptr_end - ptr;
12559  lim = pt < pend ? pt : pend;
12560  i = (int)(lim - ptr);
12561  buf = ALLOCA_N(char, i+2);
12562  code = ptr;
12563  caret = p2 = buf;
12564  if (ptr <= pb) {
12565  while (ptr < pb) {
12566  *p2++ = *ptr++ == '\t' ? '\t' : ' ';
12567  }
12568  *p2++ = '^';
12569  ptr++;
12570  }
12571  if (lim > ptr) {
12572  memset(p2, '~', (lim - ptr));
12573  p2 += (lim - ptr);
12574  }
12575  *p2 = '\0';
12576  rb_str_catf(mesg, "%s%.*s%s\n""%s%s\n",
12577  pre, (int)len, code, post,
12578  pre, caret);
12579  }
12580  if (!errbuf) rb_write_error_str(mesg);
12581 }
12582 #else
12583 static int
12584 parser_yyerror(struct parser_params *p, const YYLTYPE *yylloc, const char *msg)
12585 {
12586  const char *pcur = 0, *ptok = 0;
12587  if (yylloc &&
12588  p->ruby_sourceline == yylloc->beg_pos.lineno &&
12589  p->ruby_sourceline == yylloc->end_pos.lineno) {
12590  pcur = p->lex.pcur;
12591  ptok = p->lex.ptok;
12592  p->lex.ptok = p->lex.pbeg + yylloc->beg_pos.column;
12593  p->lex.pcur = p->lex.pbeg + yylloc->end_pos.column;
12594  }
12595  dispatch1(parse_error, STR_NEW2(msg));
12596  ripper_error(p);
12597  if (pcur) {
12598  p->lex.ptok = ptok;
12599  p->lex.pcur = pcur;
12600  }
12601  return 0;
12602 }
12603 
12604 static inline void
12605 parser_show_error_line(struct parser_params *p, const YYLTYPE *yylloc)
12606 {
12607 }
12608 #endif /* !RIPPER */
12609 
12610 #ifndef RIPPER
12611 static int
12612 vtable_size(const struct vtable *tbl)
12613 {
12614  if (!DVARS_TERMINAL_P(tbl)) {
12615  return tbl->pos;
12616  }
12617  else {
12618  return 0;
12619  }
12620 }
12621 #endif
12622 
12623 static struct vtable *
12624 vtable_alloc_gen(struct parser_params *p, int line, struct vtable *prev)
12625 {
12626  struct vtable *tbl = ALLOC(struct vtable);
12627  tbl->pos = 0;
12628  tbl->capa = 8;
12629  tbl->tbl = ALLOC_N(ID, tbl->capa);
12630  tbl->prev = prev;
12631 #ifndef RIPPER
12632  if (p->debug) {
12633  rb_parser_printf(p, "vtable_alloc:%d: %p\n", line, (void *)tbl);
12634  }
12635 #endif
12636  return tbl;
12637 }
12638 #define vtable_alloc(prev) vtable_alloc_gen(p, __LINE__, prev)
12639 
12640 static void
12641 vtable_free_gen(struct parser_params *p, int line, const char *name,
12642  struct vtable *tbl)
12643 {
12644 #ifndef RIPPER
12645  if (p->debug) {
12646  rb_parser_printf(p, "vtable_free:%d: %s(%p)\n", line, name, (void *)tbl);
12647  }
12648 #endif
12649  if (!DVARS_TERMINAL_P(tbl)) {
12650  if (tbl->tbl) {
12651  ruby_sized_xfree(tbl->tbl, tbl->capa * sizeof(ID));
12652  }
12653  ruby_sized_xfree(tbl, sizeof(tbl));
12654  }
12655 }
12656 #define vtable_free(tbl) vtable_free_gen(p, __LINE__, #tbl, tbl)
12657 
12658 static void
12659 vtable_add_gen(struct parser_params *p, int line, const char *name,
12660  struct vtable *tbl, ID id)
12661 {
12662 #ifndef RIPPER
12663  if (p->debug) {
12664  rb_parser_printf(p, "vtable_add:%d: %s(%p), %s\n",
12665  line, name, (void *)tbl, rb_id2name(id));
12666  }
12667 #endif
12668  if (DVARS_TERMINAL_P(tbl)) {
12669  rb_parser_fatal(p, "vtable_add: vtable is not allocated (%p)", (void *)tbl);
12670  return;
12671  }
12672  if (tbl->pos == tbl->capa) {
12673  tbl->capa = tbl->capa * 2;
12674  SIZED_REALLOC_N(tbl->tbl, ID, tbl->capa, tbl->pos);
12675  }
12676  tbl->tbl[tbl->pos++] = id;
12677 }
12678 #define vtable_add(tbl, id) vtable_add_gen(p, __LINE__, #tbl, tbl, id)
12679 
12680 #ifndef RIPPER
12681 static void
12682 vtable_pop_gen(struct parser_params *p, int line, const char *name,
12683  struct vtable *tbl, int n)
12684 {
12685  if (p->debug) {
12686  rb_parser_printf(p, "vtable_pop:%d: %s(%p), %d\n",
12687  line, name, (void *)tbl, n);
12688  }
12689  if (tbl->pos < n) {
12690  rb_parser_fatal(p, "vtable_pop: unreachable (%d < %d)", tbl->pos, n);
12691  return;
12692  }
12693  tbl->pos -= n;
12694 }
12695 #define vtable_pop(tbl, n) vtable_pop_gen(p, __LINE__, #tbl, tbl, n)
12696 #endif
12697 
12698 static int
12699 vtable_included(const struct vtable * tbl, ID id)
12700 {
12701  int i;
12702 
12703  if (!DVARS_TERMINAL_P(tbl)) {
12704  for (i = 0; i < tbl->pos; i++) {
12705  if (tbl->tbl[i] == id) {
12706  return i+1;
12707  }
12708  }
12709  }
12710  return 0;
12711 }
12712 
12713 static void parser_prepare(struct parser_params *p);
12714 
12715 #ifndef RIPPER
12716 static NODE *parser_append_options(struct parser_params *p, NODE *node);
12717 
12718 static VALUE
12719 debug_lines(VALUE fname)
12720 {
12721  ID script_lines;
12722  CONST_ID(script_lines, "SCRIPT_LINES__");
12723  if (rb_const_defined_at(rb_cObject, script_lines)) {
12724  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
12725  if (RB_TYPE_P(hash, T_HASH)) {
12726  VALUE lines = rb_ary_new();
12727  rb_hash_aset(hash, fname, lines);
12728  return lines;
12729  }
12730  }
12731  return 0;
12732 }
12733 
12734 static int
12735 e_option_supplied(struct parser_params *p)
12736 {
12737  return strcmp(p->ruby_sourcefile, "-e") == 0;
12738 }
12739 
12740 static VALUE
12741 yycompile0(VALUE arg)
12742 {
12743  int n;
12744  NODE *tree;
12745  struct parser_params *p = (struct parser_params *)arg;
12746  VALUE cov = Qfalse;
12747 
12750  if (p->debug_lines && p->ruby_sourceline > 0) {
12751  VALUE str = STR_NEW0();
12752  n = p->ruby_sourceline;
12753  do {
12755  } while (--n);
12756  }
12757 
12758  if (!e_option_supplied(p)) {
12759  cov = Qtrue;
12760  }
12761  }
12762 
12763  parser_prepare(p);
12764 #define RUBY_DTRACE_PARSE_HOOK(name) \
12765  if (RUBY_DTRACE_PARSE_##name##_ENABLED()) { \
12766  RUBY_DTRACE_PARSE_##name(p->ruby_sourcefile, p->ruby_sourceline); \
12767  }
12768  RUBY_DTRACE_PARSE_HOOK(BEGIN);
12769  n = yyparse(p);
12771  p->debug_lines = 0;
12772 
12773  p->lex.strterm = 0;
12774  p->lex.pcur = p->lex.pbeg = p->lex.pend = 0;
12775  p->lex.prevline = p->lex.lastline = p->lex.nextline = 0;
12776  if (n || p->error_p) {
12777  VALUE mesg = p->error_buffer;
12778  if (!mesg) {
12779  mesg = rb_class_new_instance(0, 0, rb_eSyntaxError);
12780  }
12781  rb_set_errinfo(mesg);
12782  return FALSE;
12783  }
12784  tree = p->eval_tree;
12785  if (!tree) {
12786  tree = NEW_NIL(&NULL_LOC);
12787  }
12788  else {
12789  VALUE opt = p->compile_option;
12790  NODE *prelude;
12791  NODE *body = parser_append_options(p, tree->nd_body);
12792  if (!opt) opt = rb_obj_hide(rb_ident_hash_new());
12793  rb_hash_aset(opt, rb_sym_intern_ascii_cstr("coverage_enabled"), cov);
12794  prelude = block_append(p, p->eval_tree_begin, body);
12795  tree->nd_body = prelude;
12796  RB_OBJ_WRITE(p->ast, &p->ast->body.compile_option, opt);
12797  }
12798  p->ast->body.root = tree;
12799  p->ast->body.line_count = p->line_count;
12800  return TRUE;
12801 }
12802 
12803 static rb_ast_t *
12804 yycompile(VALUE vparser, struct parser_params *p, VALUE fname, int line)
12805 {
12806  rb_ast_t *ast;
12807  if (NIL_P(fname)) {
12809  p->ruby_sourcefile = "(none)";
12810  }
12811  else {
12812  p->ruby_sourcefile_string = rb_fstring(fname);
12813  p->ruby_sourcefile = StringValueCStr(fname);
12814  }
12815  p->ruby_sourceline = line - 1;
12816 
12817  p->ast = ast = rb_ast_new();
12818  rb_suppress_tracing(yycompile0, (VALUE)p);
12819  p->ast = 0;
12820  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
12821 
12822  return ast;
12823 }
12824 #endif /* !RIPPER */
12825 
12826 static rb_encoding *
12827 must_be_ascii_compatible(VALUE s)
12828 {
12829  rb_encoding *enc = rb_enc_get(s);
12830  if (!rb_enc_asciicompat(enc)) {
12831  rb_raise(rb_eArgError, "invalid source encoding");
12832  }
12833  return enc;
12834 }
12835 
12836 static VALUE
12837 lex_get_str(struct parser_params *p, VALUE s)
12838 {
12839  char *beg, *end, *start;
12840  long len;
12841 
12842  beg = RSTRING_PTR(s);
12843  len = RSTRING_LEN(s);
12844  start = beg;
12845  if (p->lex.gets_.ptr) {
12846  if (len == p->lex.gets_.ptr) return Qnil;
12847  beg += p->lex.gets_.ptr;
12848  len -= p->lex.gets_.ptr;
12849  }
12850  end = memchr(beg, '\n', len);
12851  if (end) len = ++end - beg;
12852  p->lex.gets_.ptr += len;
12853  return rb_str_subseq(s, beg - start, len);
12854 }
12855 
12856 static VALUE
12857 lex_getline(struct parser_params *p)
12858 {
12859  VALUE line = (*p->lex.gets)(p, p->lex.input);
12860  if (NIL_P(line)) return line;
12861  must_be_ascii_compatible(line);
12862 #ifndef RIPPER
12863  if (p->debug_lines) {
12864  rb_enc_associate(line, p->enc);
12865  rb_ary_push(p->debug_lines, line);
12866  }
12867 #endif
12868  p->line_count++;
12869  return line;
12870 }
12871 
12872 static const rb_data_type_t parser_data_type;
12873 
12874 #ifndef RIPPER
12875 static rb_ast_t*
12876 parser_compile_string(VALUE vparser, VALUE fname, VALUE s, int line)
12877 {
12878  struct parser_params *p;
12879 
12880  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
12881 
12882  p->lex.gets = lex_get_str;
12883  p->lex.gets_.ptr = 0;
12884  p->lex.input = rb_str_new_frozen(s);
12885  p->lex.pbeg = p->lex.pcur = p->lex.pend = 0;
12886 
12887  return yycompile(vparser, p, fname, line);
12888 }
12889 
12890 rb_ast_t*
12891 rb_parser_compile_string(VALUE vparser, const char *f, VALUE s, int line)
12892 {
12893  return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
12894 }
12895 
12896 rb_ast_t*
12898 {
12899  must_be_ascii_compatible(s);
12900  return parser_compile_string(vparser, f, s, line);
12901 }
12902 
12904 
12905 static VALUE
12906 lex_io_gets(struct parser_params *p, VALUE io)
12907 {
12908  return rb_io_gets_internal(io);
12909 }
12910 
12911 rb_ast_t*
12912 rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE file, int start)
12913 {
12914  struct parser_params *p;
12915 
12916  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
12917 
12918  p->lex.gets = lex_io_gets;
12919  p->lex.input = file;
12920  p->lex.pbeg = p->lex.pcur = p->lex.pend = 0;
12921 
12922  return yycompile(vparser, p, fname, start);
12923 }
12924 
12925 static VALUE
12926 lex_generic_gets(struct parser_params *p, VALUE input)
12927 {
12928  return (*p->lex.gets_.call)(input, p->line_count);
12929 }
12930 
12931 rb_ast_t*
12932 rb_parser_compile_generic(VALUE vparser, VALUE (*lex_gets)(VALUE, int), VALUE fname, VALUE input, int start)
12933 {
12934  struct parser_params *p;
12935 
12936  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
12937 
12938  p->lex.gets = lex_generic_gets;
12939  p->lex.gets_.call = lex_gets;
12940  p->lex.input = input;
12941  p->lex.pbeg = p->lex.pcur = p->lex.pend = 0;
12942 
12943  return yycompile(vparser, p, fname, start);
12944 }
12945 #endif /* !RIPPER */
12946 
12947 #define STR_FUNC_ESCAPE 0x01
12948 #define STR_FUNC_EXPAND 0x02
12949 #define STR_FUNC_REGEXP 0x04
12950 #define STR_FUNC_QWORDS 0x08
12951 #define STR_FUNC_SYMBOL 0x10
12952 #define STR_FUNC_INDENT 0x20
12953 #define STR_FUNC_LABEL 0x40
12954 #define STR_FUNC_LIST 0x4000
12955 #define STR_FUNC_TERM 0x8000
12956 
12959  str_squote = (0),
12967 };
12968 
12969 static VALUE
12970 parser_str_new(const char *ptr, long len, rb_encoding *enc, int func, rb_encoding *enc0)
12971 {
12972  VALUE str;
12973 
12974  str = rb_enc_str_new(ptr, len, enc);
12975  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12977  }
12978  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
12980  }
12981  }
12982 
12983  return str;
12984 }
12985 
12986 #define lex_goto_eol(p) ((p)->lex.pcur = (p)->lex.pend)
12987 #define lex_eol_p(p) ((p)->lex.pcur >= (p)->lex.pend)
12988 #define lex_eol_n_p(p,n) ((p)->lex.pcur+(n) >= (p)->lex.pend)
12989 #define peek(p,c) peek_n(p, (c), 0)
12990 #define peek_n(p,c,n) (!lex_eol_n_p(p, n) && (c) == (unsigned char)(p)->lex.pcur[n])
12991 #define peekc(p) peekc_n(p, 0)
12992 #define peekc_n(p,n) (lex_eol_n_p(p, n) ? -1 : (unsigned char)(p)->lex.pcur[n])
12993 
12994 #ifdef RIPPER
12995 static void
12996 add_delayed_token(struct parser_params *p, const char *tok, const char *end)
12997 {
12998  if (tok < end) {
12999  if (!has_delayed_token(p)) {
13000  p->delayed.token = rb_str_buf_new(end - tok);
13001  rb_enc_associate(p->delayed.token, p->enc);
13002  p->delayed.line = p->ruby_sourceline;
13003  p->delayed.col = rb_long2int(tok - p->lex.pbeg);
13004  }
13005  rb_str_buf_cat(p->delayed.token, tok, end - tok);
13006  p->lex.ptok = end;
13007  }
13008 }
13009 #else
13010 #define add_delayed_token(p, tok, end) ((void)(tok), (void)(end))
13011 #endif
13012 
13013 static int
13014 nextline(struct parser_params *p)
13015 {
13016  VALUE v = p->lex.nextline;
13017  p->lex.nextline = 0;
13018  if (!v) {
13019  if (p->eofp)
13020  return -1;
13021 
13022  if (p->lex.pend > p->lex.pbeg && *(p->lex.pend-1) != '\n') {
13023  goto end_of_input;
13024  }
13025 
13026  if (!p->lex.input || NIL_P(v = lex_getline(p))) {
13027  end_of_input:
13028  p->eofp = 1;
13029  lex_goto_eol(p);
13030  return -1;
13031  }
13032  p->cr_seen = FALSE;
13033  }
13034  else if (NIL_P(v)) {
13035  /* after here-document without terminator */
13036  goto end_of_input;
13037  }
13038  add_delayed_token(p, p->lex.ptok, p->lex.pend);
13039  if (p->heredoc_end > 0) {
13040  p->ruby_sourceline = p->heredoc_end;
13041  p->heredoc_end = 0;
13042  }
13043  p->ruby_sourceline++;
13044  p->lex.pbeg = p->lex.pcur = RSTRING_PTR(v);
13045  p->lex.pend = p->lex.pcur + RSTRING_LEN(v);
13046  token_flush(p);
13047  p->lex.prevline = p->lex.lastline;
13048  p->lex.lastline = v;
13049  return 0;
13050 }
13051 
13052 static int
13053 parser_cr(struct parser_params *p, int c)
13054 {
13055  if (peek(p, '\n')) {
13056  p->lex.pcur++;
13057  c = '\n';
13058  }
13059  else if (!p->cr_seen) {
13060  p->cr_seen = TRUE;
13061  /* carried over with p->lex.nextline for nextc() */
13062  rb_warn0("encountered \\r in middle of line, treated as a mere space");
13063  }
13064  return c;
13065 }
13066 
13067 static inline int
13068 nextc(struct parser_params *p)
13069 {
13070  int c;
13071 
13072  if (UNLIKELY((p->lex.pcur == p->lex.pend) || p->eofp || RTEST(p->lex.nextline))) {
13073  if (nextline(p)) return -1;
13074  }
13075  c = (unsigned char)*p->lex.pcur++;
13076  if (UNLIKELY(c == '\r')) {
13077  c = parser_cr(p, c);
13078  }
13079 
13080  return c;
13081 }
13082 
13083 static void
13084 pushback(struct parser_params *p, int c)
13085 {
13086  if (c == -1) return;
13087  p->lex.pcur--;
13088  if (p->lex.pcur > p->lex.pbeg && p->lex.pcur[0] == '\n' && p->lex.pcur[-1] == '\r') {
13089  p->lex.pcur--;
13090  }
13091 }
13092 
13093 #define was_bol(p) ((p)->lex.pcur == (p)->lex.pbeg + 1)
13094 
13095 #define tokfix(p) ((p)->tokenbuf[(p)->tokidx]='\0')
13096 #define tok(p) (p)->tokenbuf
13097 #define toklen(p) (p)->tokidx
13098 
13099 static int
13100 looking_at_eol_p(struct parser_params *p)
13101 {
13102  const char *ptr = p->lex.pcur;
13103  while (ptr < p->lex.pend) {
13104  int c = (unsigned char)*ptr++;
13105  int eol = (c == '\n' || c == '#');
13106  if (eol || !ISSPACE(c)) {
13107  return eol;
13108  }
13109  }
13110  return TRUE;
13111 }
13112 
13113 static char*
13114 newtok(struct parser_params *p)
13115 {
13116  p->tokidx = 0;
13117  p->tokline = p->ruby_sourceline;
13118  if (!p->tokenbuf) {
13119  p->toksiz = 60;
13120  p->tokenbuf = ALLOC_N(char, 60);
13121  }
13122  if (p->toksiz > 4096) {
13123  p->toksiz = 60;
13124  REALLOC_N(p->tokenbuf, char, 60);
13125  }
13126  return p->tokenbuf;
13127 }
13128 
13129 static char *
13130 tokspace(struct parser_params *p, int n)
13131 {
13132  p->tokidx += n;
13133 
13134  if (p->tokidx >= p->toksiz) {
13135  do {p->toksiz *= 2;} while (p->toksiz < p->tokidx);
13136  REALLOC_N(p->tokenbuf, char, p->toksiz);
13137  }
13138  return &p->tokenbuf[p->tokidx-n];
13139 }
13140 
13141 static void
13142 tokadd(struct parser_params *p, int c)
13143 {
13144  p->tokenbuf[p->tokidx++] = (char)c;
13145  if (p->tokidx >= p->toksiz) {
13146  p->toksiz *= 2;
13147  REALLOC_N(p->tokenbuf, char, p->toksiz);
13148  }
13149 }
13150 
13151 static int
13152 tok_hex(struct parser_params *p, size_t *numlen)
13153 {
13154  int c;
13155 
13156  c = scan_hex(p->lex.pcur, 2, numlen);
13157  if (!*numlen) {
13158  yyerror0("invalid hex escape");
13159  token_flush(p);
13160  return 0;
13161  }
13162  p->lex.pcur += *numlen;
13163  return c;
13164 }
13165 
13166 #define tokcopy(p, n) memcpy(tokspace(p, n), (p)->lex.pcur - (n), (n))
13167 
13168 static int
13169 escaped_control_code(int c)
13170 {
13171  int c2 = 0;
13172  switch (c) {
13173  case ' ':
13174  c2 = 's';
13175  break;
13176  case '\n':
13177  c2 = 'n';
13178  break;
13179  case '\t':
13180  c2 = 't';
13181  break;
13182  case '\v':
13183  c2 = 'v';
13184  break;
13185  case '\r':
13186  c2 = 'r';
13187  break;
13188  case '\f':
13189  c2 = 'f';
13190  break;
13191  }
13192  return c2;
13193 }
13194 
13195 #define WARN_SPACE_CHAR(c, prefix) \
13196  rb_warn1("invalid character syntax; use "prefix"\\%c", WARN_I(c2))
13197 
13198 static int
13199 tokadd_codepoint(struct parser_params *p, rb_encoding **encp,
13200  int regexp_literal, int wide)
13201 {
13202  size_t numlen;
13203  int codepoint = scan_hex(p->lex.pcur, wide ? p->lex.pend - p->lex.pcur : 4, &numlen);
13204  literal_flush(p, p->lex.pcur);
13205  p->lex.pcur += numlen;
13206  if (wide ? (numlen == 0 || numlen > 6) : (numlen < 4)) {
13207  yyerror0("invalid Unicode escape");
13208  return wide && numlen > 0;
13209  }
13210  if (codepoint > 0x10ffff) {
13211  yyerror0("invalid Unicode codepoint (too large)");
13212  return wide;
13213  }
13214  if ((codepoint & 0xfffff800) == 0xd800) {
13215  yyerror0("invalid Unicode codepoint");
13216  return wide;
13217  }
13218  if (regexp_literal) {
13219  tokcopy(p, (int)numlen);
13220  }
13221  else if (codepoint >= 0x80) {
13222  rb_encoding *utf8 = rb_utf8_encoding();
13223  if (*encp && utf8 != *encp) {
13224  YYLTYPE loc = RUBY_INIT_YYLLOC();
13225  compile_error(p, "UTF-8 mixed within %s source", rb_enc_name(*encp));
13226  parser_show_error_line(p, &loc);
13227  return wide;
13228  }
13229  *encp = utf8;
13230  tokaddmbc(p, codepoint, *encp);
13231  }
13232  else {
13233  tokadd(p, codepoint);
13234  }
13235  return TRUE;
13236 }
13237 
13238 /* return value is for ?\u3042 */
13239 static void
13240 tokadd_utf8(struct parser_params *p, rb_encoding **encp,
13241  int term, int symbol_literal, int regexp_literal)
13242 {
13243  /*
13244  * If `term` is not -1, then we allow multiple codepoints in \u{}
13245  * upto `term` byte, otherwise we're parsing a character literal.
13246  * And then add the codepoints to the current token.
13247  */
13248  static const char multiple_codepoints[] = "Multiple codepoints at single character literal";
13249 
13250  const int open_brace = '{', close_brace = '}';
13251 
13252  if (regexp_literal) { tokadd(p, '\\'); tokadd(p, 'u'); }
13253 
13254  if (peek(p, open_brace)) { /* handle \u{...} form */
13255  const char *second = NULL;
13256  int c, last = nextc(p);
13257  if (p->lex.pcur >= p->lex.pend) goto unterminated;
13258  while (ISSPACE(c = *p->lex.pcur) && ++p->lex.pcur < p->lex.pend);
13259  while (c != close_brace) {
13260  if (c == term) goto unterminated;
13261  if (second == multiple_codepoints)
13262  second = p->lex.pcur;
13263  if (regexp_literal) tokadd(p, last);
13264  if (!tokadd_codepoint(p, encp, regexp_literal, TRUE)) {
13265  break;
13266  }
13267  while (ISSPACE(c = *p->lex.pcur)) {
13268  if (++p->lex.pcur >= p->lex.pend) goto unterminated;
13269  last = c;
13270  }
13271  if (term == -1 && !second)
13272  second = multiple_codepoints;
13273  }
13274 
13275  if (c != close_brace) {
13276  unterminated:
13277  token_flush(p);
13278  yyerror0("unterminated Unicode escape");
13279  return;
13280  }
13281  if (second && second != multiple_codepoints) {
13282  const char *pcur = p->lex.pcur;
13283  p->lex.pcur = second;
13285  token_flush(p);
13286  p->lex.pcur = pcur;
13287  yyerror0(multiple_codepoints);
13288  token_flush(p);
13289  }
13290 
13291  if (regexp_literal) tokadd(p, close_brace);
13292  nextc(p);
13293  }
13294  else { /* handle \uxxxx form */
13295  if (!tokadd_codepoint(p, encp, regexp_literal, FALSE)) {
13296  token_flush(p);
13297  return;
13298  }
13299  }
13300 }
13301 
13302 #define ESCAPE_CONTROL 1
13303 #define ESCAPE_META 2
13304 
13305 static int
13306 read_escape(struct parser_params *p, int flags, rb_encoding **encp)
13307 {
13308  int c;
13309  size_t numlen;
13310 
13311  switch (c = nextc(p)) {
13312  case '\\': /* Backslash */
13313  return c;
13314 
13315  case 'n': /* newline */
13316  return '\n';
13317 
13318  case 't': /* horizontal tab */
13319  return '\t';
13320 
13321  case 'r': /* carriage-return */
13322  return '\r';
13323 
13324  case 'f': /* form-feed */
13325  return '\f';
13326 
13327  case 'v': /* vertical tab */
13328  return '\13';
13329 
13330  case 'a': /* alarm(bell) */
13331  return '\007';
13332 
13333  case 'e': /* escape */
13334  return 033;
13335 
13336  case '0': case '1': case '2': case '3': /* octal constant */
13337  case '4': case '5': case '6': case '7':
13338  pushback(p, c);
13339  c = scan_oct(p->lex.pcur, 3, &numlen);
13340  p->lex.pcur += numlen;
13341  return c;
13342 
13343  case 'x': /* hex constant */
13344  c = tok_hex(p, &numlen);
13345  if (numlen == 0) return 0;
13346  return c;
13347 
13348  case 'b': /* backspace */
13349  return '\010';
13350 
13351  case 's': /* space */
13352  return ' ';
13353 
13354  case 'M':
13355  if (flags & ESCAPE_META) goto eof;
13356  if ((c = nextc(p)) != '-') {
13357  goto eof;
13358  }
13359  if ((c = nextc(p)) == '\\') {
13360  if (peek(p, 'u')) goto eof;
13361  return read_escape(p, flags|ESCAPE_META, encp) | 0x80;
13362  }
13363  else if (c == -1 || !ISASCII(c)) goto eof;
13364  else {
13365  int c2 = escaped_control_code(c);
13366  if (c2) {
13367  if (ISCNTRL(c) || !(flags & ESCAPE_CONTROL)) {
13368  WARN_SPACE_CHAR(c2, "\\M-");
13369  }
13370  else {
13371  WARN_SPACE_CHAR(c2, "\\C-\\M-");
13372  }
13373  }
13374  else if (ISCNTRL(c)) goto eof;
13375  return ((c & 0xff) | 0x80);
13376  }
13377 
13378  case 'C':
13379  if ((c = nextc(p)) != '-') {
13380  goto eof;
13381  }
13382  case 'c':
13383  if (flags & ESCAPE_CONTROL) goto eof;
13384  if ((c = nextc(p))== '\\') {
13385  if (peek(p, 'u')) goto eof;
13386  c = read_escape(p, flags|ESCAPE_CONTROL, encp);
13387  }
13388  else if (c == '?')
13389  return 0177;
13390  else if (c == -1 || !ISASCII(c)) goto eof;
13391  else {
13392  int c2 = escaped_control_code(c);
13393  if (c2) {
13394  if (ISCNTRL(c)) {
13395  if (flags & ESCAPE_META) {
13396  WARN_SPACE_CHAR(c2, "\\M-");
13397  }
13398  else {
13399  WARN_SPACE_CHAR(c2, "");
13400  }
13401  }
13402  else {
13403  if (flags & ESCAPE_META) {
13404  WARN_SPACE_CHAR(c2, "\\M-\\C-");
13405  }
13406  else {
13407  WARN_SPACE_CHAR(c2, "\\C-");
13408  }
13409  }
13410  }
13411  else if (ISCNTRL(c)) goto eof;
13412  }
13413  return c & 0x9f;
13414 
13415  eof:
13416  case -1:
13417  yyerror0("Invalid escape character syntax");
13418  token_flush(p);
13419  return '\0';
13420 
13421  default:
13422  return c;
13423  }
13424 }
13425 
13426 static void
13427 tokaddmbc(struct parser_params *p, int c, rb_encoding *enc)
13428 {
13429  int len = rb_enc_codelen(c, enc);
13430  rb_enc_mbcput(c, tokspace(p, len), enc);
13431 }
13432 
13433 static int
13434 tokadd_escape(struct parser_params *p, rb_encoding **encp)
13435 {
13436  int c;
13437  int flags = 0;
13438  size_t numlen;
13439 
13440  first:
13441  switch (c = nextc(p)) {
13442  case '\n':
13443  return 0; /* just ignore */
13444 
13445  case '0': case '1': case '2': case '3': /* octal constant */
13446  case '4': case '5': case '6': case '7':
13447  {
13448  ruby_scan_oct(--p->lex.pcur, 3, &numlen);
13449  if (numlen == 0) goto eof;
13450  p->lex.pcur += numlen;
13451  tokcopy(p, (int)numlen + 1);
13452  }
13453  return 0;
13454 
13455  case 'x': /* hex constant */
13456  {
13457  tok_hex(p, &numlen);
13458  if (numlen == 0) return -1;
13459  tokcopy(p, (int)numlen + 2);
13460  }
13461  return 0;
13462 
13463  case 'M':
13464  if (flags & ESCAPE_META) goto eof;
13465  if ((c = nextc(p)) != '-') {
13466  pushback(p, c);
13467  goto eof;
13468  }
13469  tokcopy(p, 3);
13470  flags |= ESCAPE_META;
13471  goto escaped;
13472 
13473  case 'C':
13474  if (flags & ESCAPE_CONTROL) goto eof;
13475  if ((c = nextc(p)) != '-') {
13476  pushback(p, c);
13477  goto eof;
13478  }
13479  tokcopy(p, 3);
13480  goto escaped;
13481 
13482  case 'c':
13483  if (flags & ESCAPE_CONTROL) goto eof;
13484  tokcopy(p, 2);
13485  flags |= ESCAPE_CONTROL;
13486  escaped:
13487  if ((c = nextc(p)) == '\\') {
13488  goto first;
13489  }
13490  else if (c == -1) goto eof;
13491  tokadd(p, c);
13492  return 0;
13493 
13494  eof:
13495  case -1:
13496  yyerror0("Invalid escape character syntax");
13497  token_flush(p);
13498  return -1;
13499 
13500  default:
13501  tokadd(p, '\\');
13502  tokadd(p, c);
13503  }
13504  return 0;
13505 }
13506 
13507 static int
13508 regx_options(struct parser_params *p)
13509 {
13510  int kcode = 0;
13511  int kopt = 0;
13512  int options = 0;
13513  int c, opt, kc;
13514 
13515  newtok(p);
13516  while (c = nextc(p), ISALPHA(c)) {
13517  if (c == 'o') {
13518  options |= RE_OPTION_ONCE;
13519  }
13520  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
13521  if (kc >= 0) {
13522  if (kc != rb_ascii8bit_encindex()) kcode = c;
13523  kopt = opt;
13524  }
13525  else {
13526  options |= opt;
13527  }
13528  }
13529  else {
13530  tokadd(p, c);
13531  }
13532  }
13533  options |= kopt;
13534  pushback(p, c);
13535  if (toklen(p)) {
13536  YYLTYPE loc = RUBY_INIT_YYLLOC();
13537  tokfix(p);
13538  compile_error(p, "unknown regexp option%s - %*s",
13539  toklen(p) > 1 ? "s" : "", toklen(p), tok(p));
13540  parser_show_error_line(p, &loc);
13541  }
13542  return options | RE_OPTION_ENCODING(kcode);
13543 }
13544 
13545 static int
13546 tokadd_mbchar(struct parser_params *p, int c)
13547 {
13548  int len = parser_precise_mbclen(p, p->lex.pcur-1);
13549  if (len < 0) return -1;
13550  tokadd(p, c);
13551  p->lex.pcur += --len;
13552  if (len > 0) tokcopy(p, len);
13553  return c;
13554 }
13555 
13556 static inline int
13557 simple_re_meta(int c)
13558 {
13559  switch (c) {
13560  case '$': case '*': case '+': case '.':
13561  case '?': case '^': case '|':
13562  case ')': case ']': case '}': case '>':
13563  return TRUE;
13564  default:
13565  return FALSE;
13566  }
13567 }
13568 
13569 static int
13570 parser_update_heredoc_indent(struct parser_params *p, int c)
13571 {
13572  if (p->heredoc_line_indent == -1) {
13573  if (c == '\n') p->heredoc_line_indent = 0;
13574  }
13575  else {
13576  if (c == ' ') {
13577  p->heredoc_line_indent++;
13578  return TRUE;
13579  }
13580  else if (c == '\t') {
13581  int w = (p->heredoc_line_indent / TAB_WIDTH) + 1;
13582  p->heredoc_line_indent = w * TAB_WIDTH;
13583  return TRUE;
13584  }
13585  else if (c != '\n') {
13586  if (p->heredoc_indent > p->heredoc_line_indent) {
13588  }
13589  p->heredoc_line_indent = -1;
13590  }
13591  }
13592  return FALSE;
13593 }
13594 
13595 static void
13596 parser_mixed_error(struct parser_params *p, rb_encoding *enc1, rb_encoding *enc2)
13597 {
13598  YYLTYPE loc = RUBY_INIT_YYLLOC();
13599  const char *n1 = rb_enc_name(enc1), *n2 = rb_enc_name(enc2);
13600  compile_error(p, "%s mixed within %s source", n1, n2);
13601  parser_show_error_line(p, &loc);
13602 }
13603 
13604 static void
13605 parser_mixed_escape(struct parser_params *p, const char *beg, rb_encoding *enc1, rb_encoding *enc2)
13606 {
13607  const char *pos = p->lex.pcur;
13608  p->lex.pcur = beg;
13609  parser_mixed_error(p, enc1, enc2);
13610  p->lex.pcur = pos;
13611 }
13612 
13613 static int
13614 tokadd_string(struct parser_params *p,
13615  int func, int term, int paren, long *nest,
13616  rb_encoding **encp, rb_encoding **enc)
13617 {
13618  int c;
13619  bool erred = false;
13620 
13621 #define mixed_error(enc1, enc2) \
13622  (void)(erred || (parser_mixed_error(p, enc1, enc2), erred = true))
13623 #define mixed_escape(beg, enc1, enc2) \
13624  (void)(erred || (parser_mixed_escape(p, beg, enc1, enc2), erred = true))
13625 
13626  while ((c = nextc(p)) != -1) {
13627  if (p->heredoc_indent > 0) {
13628  parser_update_heredoc_indent(p, c);
13629  }
13630 
13631  if (paren && c == paren) {
13632  ++*nest;
13633  }
13634  else if (c == term) {
13635  if (!nest || !*nest) {
13636  pushback(p, c);
13637  break;
13638  }
13639  --*nest;
13640  }
13641  else if ((func & STR_FUNC_EXPAND) && c == '#' && p->lex.pcur < p->lex.pend) {
13642  int c2 = *p->lex.pcur;
13643  if (c2 == '$' || c2 == '@' || c2 == '{') {
13644  pushback(p, c);
13645  break;
13646  }
13647  }
13648  else if (c == '\\') {
13649  literal_flush(p, p->lex.pcur - 1);
13650  c = nextc(p);
13651  switch (c) {
13652  case '\n':
13653  if (func & STR_FUNC_QWORDS) break;
13654  if (func & STR_FUNC_EXPAND) {
13655  if (!(func & STR_FUNC_INDENT) || (p->heredoc_indent < 0))
13656  continue;
13657  if (c == term) {
13658  c = '\\';
13659  goto terminate;
13660  }
13661  }
13662  tokadd(p, '\\');
13663  break;
13664 
13665  case '\\':
13666  if (func & STR_FUNC_ESCAPE) tokadd(p, c);
13667  break;
13668 
13669  case 'u':
13670  if ((func & STR_FUNC_EXPAND) == 0) {
13671  tokadd(p, '\\');
13672  break;
13673  }
13674  tokadd_utf8(p, enc, term,
13675  func & STR_FUNC_SYMBOL,
13676  func & STR_FUNC_REGEXP);
13677  continue;
13678 
13679  default:
13680  if (c == -1) return -1;
13681  if (!ISASCII(c)) {
13682  if ((func & STR_FUNC_EXPAND) == 0) tokadd(p, '\\');
13683  goto non_ascii;
13684  }
13685  if (func & STR_FUNC_REGEXP) {
13686  if (c == term && !simple_re_meta(c)) {
13687  tokadd(p, c);
13688  continue;
13689  }
13690  pushback(p, c);
13691  if ((c = tokadd_escape(p, enc)) < 0)
13692  return -1;
13693  if (*enc && *enc != *encp) {
13694  mixed_escape(p->lex.ptok+2, *enc, *encp);
13695  }
13696  continue;
13697  }
13698  else if (func & STR_FUNC_EXPAND) {
13699  pushback(p, c);
13700  if (func & STR_FUNC_ESCAPE) tokadd(p, '\\');
13701  c = read_escape(p, 0, enc);
13702  }
13703  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
13704  /* ignore backslashed spaces in %w */
13705  }
13706  else if (c != term && !(paren && c == paren)) {
13707  tokadd(p, '\\');
13708  pushback(p, c);
13709  continue;
13710  }
13711  }
13712  }
13713  else if (!parser_isascii(p)) {
13714  non_ascii:
13715  if (!*enc) {
13716  *enc = *encp;
13717  }
13718  else if (*enc != *encp) {
13719  mixed_error(*enc, *encp);
13720  continue;
13721  }
13722  if (tokadd_mbchar(p, c) == -1) return -1;
13723  continue;
13724  }
13725  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
13726  pushback(p, c);
13727  break;
13728  }
13729  if (c & 0x80) {
13730  if (!*enc) {
13731  *enc = *encp;
13732  }
13733  else if (*enc != *encp) {
13734  mixed_error(*enc, *encp);
13735  continue;
13736  }
13737  }
13738  tokadd(p, c);
13739  }
13740  terminate:
13741  if (*enc) *encp = *enc;
13742  return c;
13743 }
13744 
13745 static inline rb_strterm_t *
13746 new_strterm(VALUE v1, VALUE v2, VALUE v3, VALUE v0)
13747 {
13748  return (rb_strterm_t*)rb_imemo_new(imemo_parser_strterm, v1, v2, v3, v0);
13749 }
13750 
13751 /* imemo_parser_strterm for literal */
13752 #define NEW_STRTERM(func, term, paren) \
13753  new_strterm((VALUE)(func), (VALUE)(paren), (VALUE)(term), 0)
13754 
13755 #ifdef RIPPER
13756 static void
13758 {
13759  VALUE content = yylval.val;
13760  if (!ripper_is_node_yylval(content))
13761  content = ripper_new_yylval(p, 0, 0, content);
13762  if (has_delayed_token(p)) {
13763  ptrdiff_t len = p->lex.pcur - p->lex.ptok;
13764  if (len > 0) {
13765  rb_enc_str_buf_cat(p->delayed.token, p->lex.ptok, len, enc);
13766  }
13768  p->lex.ptok = p->lex.pcur;
13769  RNODE(content)->nd_rval = yylval.val;
13770  }
13772  if (yylval.val != content)
13773  RNODE(content)->nd_rval = yylval.val;
13774  yylval.val = content;
13775 }
13776 #else
13777 #define flush_string_content(p, enc) ((void)(enc))
13778 #endif
13779 
13780 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
13781 /* this can be shared with ripper, since it's independent from struct
13782  * parser_params. */
13783 #ifndef RIPPER
13784 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
13785 #define SPECIAL_PUNCT(idx) ( \
13786  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
13787  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
13788  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
13789  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
13790  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
13791  BIT('0', idx))
13792 const unsigned int ruby_global_name_punct_bits[] = {
13793  SPECIAL_PUNCT(0),
13794  SPECIAL_PUNCT(1),
13795  SPECIAL_PUNCT(2),
13796 };
13797 #undef BIT
13798 #undef SPECIAL_PUNCT
13799 #endif
13800 
13801 static enum yytokentype
13802 parser_peek_variable_name(struct parser_params *p)
13803 {
13804  int c;
13805  const char *ptr = p->lex.pcur;
13806 
13807  if (ptr + 1 >= p->lex.pend) return 0;
13808  c = *ptr++;
13809  switch (c) {
13810  case '$':
13811  if ((c = *ptr) == '-') {
13812  if (++ptr >= p->lex.pend) return 0;
13813  c = *ptr;
13814  }
13815  else if (is_global_name_punct(c) || ISDIGIT(c)) {
13816  return tSTRING_DVAR;
13817  }
13818  break;
13819  case '@':
13820  if ((c = *ptr) == '@') {
13821  if (++ptr >= p->lex.pend) return 0;
13822  c = *ptr;
13823  }
13824  break;
13825  case '{':
13826  p->lex.pcur = ptr;
13827  p->command_start = TRUE;
13828  return tSTRING_DBEG;
13829  default:
13830  return 0;
13831  }
13832  if (!ISASCII(c) || c == '_' || ISALPHA(c))
13833  return tSTRING_DVAR;
13834  return 0;
13835 }
13836 
13837 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
13838 #define IS_END() IS_lex_state(EXPR_END_ANY)
13839 #define IS_BEG() (IS_lex_state(EXPR_BEG_ANY) || IS_lex_state_all(EXPR_ARG|EXPR_LABELED))
13840 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
13841 #define IS_LABEL_POSSIBLE() (\
13842  (IS_lex_state(EXPR_LABEL|EXPR_ENDFN) && !cmd_state) || \
13843  IS_ARG())
13844 #define IS_LABEL_SUFFIX(n) (peek_n(p, ':',(n)) && !peek_n(p, ':', (n)+1))
13845 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
13846 
13847 static inline enum yytokentype
13848 parser_string_term(struct parser_params *p, int func)
13849 {
13850  p->lex.strterm = 0;
13851  if (func & STR_FUNC_REGEXP) {
13852  set_yylval_num(regx_options(p));
13854  SET_LEX_STATE(EXPR_END);
13855  return tREGEXP_END;
13856  }
13857  if ((func & STR_FUNC_LABEL) && IS_LABEL_SUFFIX(0)) {
13858  nextc(p);
13859  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
13860  return tLABEL_END;
13861  }
13862  SET_LEX_STATE(EXPR_END);
13863  return tSTRING_END;
13864 }
13865 
13866 static enum yytokentype
13867 parse_string(struct parser_params *p, rb_strterm_literal_t *quote)
13868 {
13869  int func = (int)quote->u1.func;
13870  int term = (int)quote->u3.term;
13871  int paren = (int)quote->u2.paren;
13872  int c, space = 0;
13873  rb_encoding *enc = p->enc;
13874  rb_encoding *base_enc = 0;
13875  VALUE lit;
13876 
13877  if (func & STR_FUNC_TERM) {
13878  if (func & STR_FUNC_QWORDS) nextc(p); /* delayed term */
13879  SET_LEX_STATE(EXPR_END);
13880  p->lex.strterm = 0;
13881  return func & STR_FUNC_REGEXP ? tREGEXP_END : tSTRING_END;
13882  }
13883  c = nextc(p);
13884  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
13885  do {c = nextc(p);} while (ISSPACE(c));
13886  space = 1;
13887  }
13888  if (func & STR_FUNC_LIST) {
13889  quote->u1.func &= ~STR_FUNC_LIST;
13890  space = 1;
13891  }
13892  if (c == term && !quote->u0.nest) {
13893  if (func & STR_FUNC_QWORDS) {
13894  quote->u1.func |= STR_FUNC_TERM;
13895  pushback(p, c); /* dispatch the term at tSTRING_END */
13896  add_delayed_token(p, p->lex.ptok, p->lex.pcur);
13897  return ' ';
13898  }
13899  return parser_string_term(p, func);
13900  }
13901  if (space) {
13902  pushback(p, c);
13903  add_delayed_token(p, p->lex.ptok, p->lex.pcur);
13904  return ' ';
13905  }
13906  newtok(p);
13907  if ((func & STR_FUNC_EXPAND) && c == '#') {
13908  int t = parser_peek_variable_name(p);
13909  if (t) return t;
13910  tokadd(p, '#');
13911  c = nextc(p);
13912  }
13913  pushback(p, c);
13914  if (tokadd_string(p, func, term, paren, &quote->u0.nest,
13915  &enc, &base_enc) == -1) {
13916  if (p->eofp) {
13917 #ifndef RIPPER
13918 # define unterminated_literal(mesg) yyerror0(mesg)
13919 #else
13920 # define unterminated_literal(mesg) compile_error(p, mesg)
13921 #endif
13922  literal_flush(p, p->lex.pcur);
13923  if (func & STR_FUNC_QWORDS) {
13924  /* no content to add, bailing out here */
13925  unterminated_literal("unterminated list meets end of file");
13926  p->lex.strterm = 0;
13927  return tSTRING_END;
13928  }
13929  if (func & STR_FUNC_REGEXP) {
13930  unterminated_literal("unterminated regexp meets end of file");
13931  }
13932  else {
13933  unterminated_literal("unterminated string meets end of file");
13934  }
13935  quote->u1.func |= STR_FUNC_TERM;
13936  }
13937  }
13938 
13939  tokfix(p);
13940  lit = STR_NEW3(tok(p), toklen(p), enc, func);
13941  set_yylval_str(lit);
13943 
13944  return tSTRING_CONTENT;
13945 }
13946 
13947 static enum yytokentype
13948 heredoc_identifier(struct parser_params *p)
13949 {
13950  /*
13951  * term_len is length of `<<"END"` except `END`,
13952  * in this case term_len is 4 (<, <, " and ").
13953  */
13954  long len, offset = p->lex.pcur - p->lex.pbeg;
13955  int c = nextc(p), term, func = 0, quote = 0;
13956  enum yytokentype token = tSTRING_BEG;
13957  int indent = 0;
13958 
13959  if (c == '-') {
13960  c = nextc(p);
13961  func = STR_FUNC_INDENT;
13962  offset++;
13963  }
13964  else if (c == '~') {
13965  c = nextc(p);
13966  func = STR_FUNC_INDENT;
13967  offset++;
13968  indent = INT_MAX;
13969  }
13970  switch (c) {
13971  case '\'':
13972  func |= str_squote; goto quoted;
13973  case '"':
13974  func |= str_dquote; goto quoted;
13975  case '`':
13976  token = tXSTRING_BEG;
13977  func |= str_xquote; goto quoted;
13978 
13979  quoted:
13980  quote++;
13981  offset++;
13982  term = c;
13983  len = 0;
13984  while ((c = nextc(p)) != term) {
13985  if (c == -1 || c == '\r' || c == '\n') {
13986  yyerror(NULL, p, "unterminated here document identifier");
13987  return -1;
13988  }
13989  }
13990  break;
13991 
13992  default:
13993  if (!parser_is_identchar(p)) {
13994  pushback(p, c);
13995  if (func & STR_FUNC_INDENT) {
13996  pushback(p, indent > 0 ? '~' : '-');
13997  }
13998  return 0;
13999  }
14000  func |= str_dquote;
14001  do {
14002  int n = parser_precise_mbclen(p, p->lex.pcur-1);
14003  if (n < 0) return 0;
14004  p->lex.pcur += --n;
14005  } while ((c = nextc(p)) != -1 && parser_is_identchar(p));
14006  pushback(p, c);
14007  break;
14008  }
14009 
14010  len = p->lex.pcur - (p->lex.pbeg + offset) - quote;
14011  if ((unsigned long)len >= HERETERM_LENGTH_MAX)
14012  yyerror(NULL, p, "too long here document identifier");
14014  lex_goto_eol(p);
14015 
14016  p->lex.strterm = new_strterm(0, 0, 0, p->lex.lastline);
14018  rb_strterm_heredoc_t *here = &p->lex.strterm->u.heredoc;
14019  here->offset = offset;
14020  here->sourceline = p->ruby_sourceline;
14021  here->length = (int)len;
14022  here->quote = quote;
14023  here->func = func;
14024 
14025  token_flush(p);
14026  p->heredoc_indent = indent;
14027  p->heredoc_line_indent = 0;
14028  return token;
14029 }
14030 
14031 static void
14032 heredoc_restore(struct parser_params *p, rb_strterm_heredoc_t *here)
14033 {
14034  VALUE line;
14035 
14036  p->lex.strterm = 0;
14037  line = here->lastline;
14038  p->lex.lastline = line;
14039  p->lex.pbeg = RSTRING_PTR(line);
14040  p->lex.pend = p->lex.pbeg + RSTRING_LEN(line);
14041  p->lex.pcur = p->lex.pbeg + here->offset + here->length + here->quote;
14042  p->lex.ptok = p->lex.pbeg + here->offset - here->quote;
14043  p->heredoc_end = p->ruby_sourceline;
14044  p->ruby_sourceline = (int)here->sourceline;
14045  if (p->eofp) p->lex.nextline = Qnil;
14046  p->eofp = 0;
14047 }
14048 
14049 static int
14050 dedent_string(VALUE string, int width)
14051 {
14052  char *str;
14053  long len;
14054  int i, col = 0;
14055 
14056  RSTRING_GETMEM(string, str, len);
14057  for (i = 0; i < len && col < width; i++) {
14058  if (str[i] == ' ') {
14059  col++;
14060  }
14061  else if (str[i] == '\t') {
14062  int n = TAB_WIDTH * (col / TAB_WIDTH + 1);
14063  if (n > width) break;
14064  col = n;
14065  }
14066  else {
14067  break;
14068  }
14069  }
14070  if (!i) return 0;
14071  rb_str_modify(string);
14072  str = RSTRING_PTR(string);
14073  if (RSTRING_LEN(string) != len)
14074  rb_fatal("literal string changed: %+"PRIsVALUE, string);
14075  MEMMOVE(str, str + i, char, len - i);
14076  rb_str_set_len(string, len - i);
14077  return i;
14078 }
14079 
14080 #ifndef RIPPER
14081 static NODE *
14082 heredoc_dedent(struct parser_params *p, NODE *root)
14083 {
14084  NODE *node, *str_node, *prev_node;
14085  int indent = p->heredoc_indent;
14086  VALUE prev_lit = 0;
14087 
14088  if (indent <= 0) return root;
14089  p->heredoc_indent = 0;
14090  if (!root) return root;
14091 
14092  prev_node = node = str_node = root;
14093  if (nd_type(root) == NODE_LIST) str_node = root->nd_head;
14094 
14095  while (str_node) {
14096  VALUE lit = str_node->nd_lit;
14097  if (str_node->flags & NODE_FL_NEWLINE) {
14098  dedent_string(lit, indent);
14099  }
14100  if (!prev_lit) {
14101  prev_lit = lit;
14102  }
14103  else if (!literal_concat0(p, prev_lit, lit)) {
14104  return 0;
14105  }
14106  else {
14107  NODE *end = node->nd_end;
14108  node = prev_node->nd_next = node->nd_next;
14109  if (!node) {
14110  if (nd_type(prev_node) == NODE_DSTR)
14111  nd_set_type(prev_node, NODE_STR);
14112  break;
14113  }
14114  node->nd_end = end;
14115  goto next_str;
14116  }
14117 
14118  str_node = 0;
14119  while ((node = (prev_node = node)->nd_next) != 0) {
14120  next_str:
14121  if (nd_type(node) != NODE_LIST) break;
14122  if ((str_node = node->nd_head) != 0) {
14123  enum node_type type = nd_type(str_node);
14124  if (type == NODE_STR || type == NODE_DSTR) break;
14125  prev_lit = 0;
14126  str_node = 0;
14127  }
14128  }
14129  }
14130  return root;
14131 }
14132 #else /* RIPPER */
14133 static VALUE
14134 heredoc_dedent(struct parser_params *p, VALUE array)
14135 {
14136  int indent = p->heredoc_indent;
14137 
14138  if (indent <= 0) return array;
14139  p->heredoc_indent = 0;
14140  dispatch2(heredoc_dedent, array, INT2NUM(indent));
14141  return array;
14142 }
14143 
14144 /*
14145  * call-seq:
14146  * Ripper.dedent_string(input, width) -> Integer
14147  *
14148  * USE OF RIPPER LIBRARY ONLY.
14149  *
14150  * Strips up to +width+ leading whitespaces from +input+,
14151  * and returns the stripped column width.
14152  */
14153 static VALUE
14154 parser_dedent_string(VALUE self, VALUE input, VALUE width)
14155 {
14156  int wid, col;
14157 
14158  StringValue(input);
14159  wid = NUM2UINT(width);
14160  col = dedent_string(input, wid);
14161  return INT2NUM(col);
14162 }
14163 #endif
14164 
14165 static int
14166 whole_match_p(struct parser_params *p, const char *eos, long len, int indent)
14167 {
14168  const char *ptr = p->lex.pbeg;
14169  long n;
14170 
14171  if (indent) {
14172  while (*ptr && ISSPACE(*ptr)) ptr++;
14173  }
14174  n = p->lex.pend - (ptr + len);
14175  if (n < 0) return FALSE;
14176  if (n > 0 && ptr[len] != '\n') {
14177  if (ptr[len] != '\r') return FALSE;
14178  if (n <= 1 || ptr[len+1] != '\n') return FALSE;
14179  }
14180  return strncmp(eos, ptr, len) == 0;
14181 }
14182 
14183 static int
14184 word_match_p(struct parser_params *p, const char *word, long len)
14185 {
14186  if (strncmp(p->lex.pcur, word, len)) return 0;
14187  if (p->lex.pcur + len == p->lex.pend) return 1;
14188  int c = (unsigned char)p->lex.pcur[len];
14189  if (ISSPACE(c)) return 1;
14190  switch (c) {
14191  case '\0': case '\004': case '\032': return 1;
14192  }
14193  return 0;
14194 }
14195 
14196 #define NUM_SUFFIX_R (1<<0)
14197 #define NUM_SUFFIX_I (1<<1)
14198 #define NUM_SUFFIX_ALL 3
14199 
14200 static int
14201 number_literal_suffix(struct parser_params *p, int mask)
14202 {
14203  int c, result = 0;
14204  const char *lastp = p->lex.pcur;
14205 
14206  while ((c = nextc(p)) != -1) {
14207  if ((mask & NUM_SUFFIX_I) && c == 'i') {
14208  result |= (mask & NUM_SUFFIX_I);
14209  mask &= ~NUM_SUFFIX_I;
14210  /* r after i, rational of complex is disallowed */
14211  mask &= ~NUM_SUFFIX_R;
14212  continue;
14213  }
14214  if ((mask & NUM_SUFFIX_R) && c == 'r') {
14215  result |= (mask & NUM_SUFFIX_R);
14216  mask &= ~NUM_SUFFIX_R;
14217  continue;
14218  }
14219  if (!ISASCII(c) || ISALPHA(c) || c == '_') {
14220  p->lex.pcur = lastp;
14221  literal_flush(p, p->lex.pcur);
14222  return 0;
14223  }
14224  pushback(p, c);
14225  break;
14226  }
14227  return result;
14228 }
14229 
14230 static enum yytokentype
14231 set_number_literal(struct parser_params *p, VALUE v,
14232  enum yytokentype type, int suffix)
14233 {
14234  if (suffix & NUM_SUFFIX_I) {
14235  v = rb_complex_raw(INT2FIX(0), v);
14236  type = tIMAGINARY;
14237  }
14239  SET_LEX_STATE(EXPR_END);
14240  return type;
14241 }
14242 
14243 static enum yytokentype
14244 set_integer_literal(struct parser_params *p, VALUE v, int suffix)
14245 {
14246  enum yytokentype type = tINTEGER;
14247  if (suffix & NUM_SUFFIX_R) {
14248  v = rb_rational_raw1(v);
14249  type = tRATIONAL;
14250  }
14251  return set_number_literal(p, v, type, suffix);
14252 }
14253 
14254 #ifdef RIPPER
14255 static void
14257 {
14258  VALUE str;
14259  if (has_delayed_token(p))
14261  str = STR_NEW(p->lex.ptok, p->lex.pend - p->lex.ptok);
14262  ripper_dispatch1(p, ripper_token2eventid(tHEREDOC_END), str);
14263  lex_goto_eol(p);
14264  token_flush(p);
14265 }
14266 
14267 #else
14268 #define dispatch_heredoc_end(p) ((void)0)
14269 #endif
14270 
14271 static enum yytokentype
14272 here_document(struct parser_params *p, rb_strterm_heredoc_t *here)
14273 {
14274  int c, func, indent = 0;
14275  const char *eos, *ptr, *ptr_end;
14276  long len;
14277  VALUE str = 0;
14278  rb_encoding *enc = p->enc;
14279  rb_encoding *base_enc = 0;
14280  int bol;
14281 
14282  eos = RSTRING_PTR(here->lastline) + here->offset;
14283  len = here->length;
14284  indent = (func = here->func) & STR_FUNC_INDENT;
14285 
14286  if ((c = nextc(p)) == -1) {
14287  error:
14288 #ifdef RIPPER
14289  if (!has_delayed_token(p)) {
14291  }
14292  else {
14293  if ((len = p->lex.pcur - p->lex.ptok) > 0) {
14294  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
14295  int cr = ENC_CODERANGE_UNKNOWN;
14297  if (cr != ENC_CODERANGE_7BIT &&
14298  p->enc == rb_usascii_encoding() &&
14299  enc != rb_utf8_encoding()) {
14301  }
14302  }
14303  rb_enc_str_buf_cat(p->delayed.token, p->lex.ptok, len, enc);
14304  }
14306  }
14307  lex_goto_eol(p);
14308 #endif
14309  heredoc_restore(p, &p->lex.strterm->u.heredoc);
14310  compile_error(p, "can't find string \"%.*s\" anywhere before EOF",
14311  (int)len, eos);
14312  token_flush(p);
14313  p->lex.strterm = 0;
14314  SET_LEX_STATE(EXPR_END);
14315  return tSTRING_END;
14316  }
14317  bol = was_bol(p);
14318  if (!bol) {
14319  /* not beginning of line, cannot be the terminator */
14320  }
14321  else if (p->heredoc_line_indent == -1) {
14322  /* `heredoc_line_indent == -1` means
14323  * - "after an interpolation in the same line", or
14324  * - "in a continuing line"
14325  */
14326  p->heredoc_line_indent = 0;
14327  }
14328  else if (whole_match_p(p, eos, len, indent)) {
14330  restore:
14331  heredoc_restore(p, &p->lex.strterm->u.heredoc);
14332  token_flush(p);
14333  p->lex.strterm = 0;
14334  SET_LEX_STATE(EXPR_END);
14335  return tSTRING_END;
14336  }
14337 
14338  if (!(func & STR_FUNC_EXPAND)) {
14339  do {
14340  ptr = RSTRING_PTR(p->lex.lastline);
14341  ptr_end = p->lex.pend;
14342  if (ptr_end > ptr) {
14343  switch (ptr_end[-1]) {
14344  case '\n':
14345  if (--ptr_end == ptr || ptr_end[-1] != '\r') {
14346  ptr_end++;
14347  break;
14348  }
14349  case '\r':
14350  --ptr_end;
14351  }
14352  }
14353 
14354  if (p->heredoc_indent > 0) {
14355  long i = 0;
14356  while (ptr + i < ptr_end && parser_update_heredoc_indent(p, ptr[i]))
14357  i++;
14358  p->heredoc_line_indent = 0;
14359  }
14360 
14361  if (str)
14362  rb_str_cat(str, ptr, ptr_end - ptr);
14363  else
14364  str = STR_NEW(ptr, ptr_end - ptr);
14365  if (ptr_end < p->lex.pend) rb_str_cat(str, "\n", 1);
14366  lex_goto_eol(p);
14367  if (p->heredoc_indent > 0) {
14368  goto flush_str;
14369  }
14370  if (nextc(p) == -1) {
14371  if (str) {
14372  str = 0;
14373  }
14374  goto error;
14375  }
14376  } while (!whole_match_p(p, eos, len, indent));
14377  }
14378  else {
14379  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
14380  newtok(p);
14381  if (c == '#') {
14382  int t = parser_peek_variable_name(p);
14383  if (p->heredoc_line_indent != -1) {
14384  if (p->heredoc_indent > p->heredoc_line_indent) {
14386  }
14387  p->heredoc_line_indent = -1;
14388  }
14389  if (t) return t;
14390  tokadd(p, '#');
14391  c = nextc(p);
14392  }
14393  do {
14394  pushback(p, c);
14395  enc = p->enc;
14396  if ((c = tokadd_string(p, func, '\n', 0, NULL, &enc, &base_enc)) == -1) {
14397  if (p->eofp) goto error;
14398  goto restore;
14399  }
14400  if (c != '\n') {
14401  if (c == '\\') p->heredoc_line_indent = -1;
14402  flush:
14403  str = STR_NEW3(tok(p), toklen(p), enc, func);
14404  flush_str:
14406 #ifndef RIPPER
14407  if (bol) yylval.node->flags |= NODE_FL_NEWLINE;
14408 #endif
14410  return tSTRING_CONTENT;
14411  }
14412  tokadd(p, nextc(p));
14413  if (p->heredoc_indent > 0) {
14414  lex_goto_eol(p);
14415  goto flush;
14416  }
14417  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
14418  if ((c = nextc(p)) == -1) goto error;
14419  } while (!whole_match_p(p, eos, len, indent));
14420  str = STR_NEW3(tok(p), toklen(p), enc, func);
14421  }
14423 #ifdef RIPPER
14424  str = ripper_new_yylval(p, ripper_token2eventid(tSTRING_CONTENT),
14425  yylval.val, str);
14426 #endif
14427  heredoc_restore(p, &p->lex.strterm->u.heredoc);
14428  token_flush(p);
14429  p->lex.strterm = NEW_STRTERM(func | STR_FUNC_TERM, 0, 0);
14431 #ifndef RIPPER
14432  if (bol) yylval.node->flags |= NODE_FL_NEWLINE;
14433 #endif
14434  return tSTRING_CONTENT;
14435 }
14436 
14437 #include "lex.c"
14438 
14439 static int
14440 arg_ambiguous(struct parser_params *p, char c)
14441 {
14442 #ifndef RIPPER
14443  rb_warning1("ambiguous first argument; put parentheses or a space even after `%c' operator", WARN_I(c));
14444 #else
14445  dispatch1(arg_ambiguous, rb_usascii_str_new(&c, 1));
14446 #endif
14447  return TRUE;
14448 }
14449 
14450 static ID
14451 formal_argument(struct parser_params *p, ID lhs)
14452 {
14453  switch (id_type(lhs)) {
14454  case ID_LOCAL:
14455  break;
14456 #ifndef RIPPER
14457  case ID_CONST:
14458  yyerror0("formal argument cannot be a constant");
14459  return 0;
14460  case ID_INSTANCE:
14461  yyerror0("formal argument cannot be an instance variable");
14462  return 0;
14463  case ID_GLOBAL:
14464  yyerror0("formal argument cannot be a global variable");
14465  return 0;
14466  case ID_CLASS:
14467  yyerror0("formal argument cannot be a class variable");
14468  return 0;
14469  default:
14470  yyerror0("formal argument must be local variable");
14471  return 0;
14472 #else
14473  default:
14474  lhs = dispatch1(param_error, lhs);
14475  ripper_error(p);
14476  return 0;
14477 #endif
14478  }
14479  shadowing_lvar(p, lhs);
14480  return lhs;
14481 }
14482 
14483 static int
14484 lvar_defined(struct parser_params *p, ID id)
14485 {
14486  return (dyna_in_block(p) && dvar_defined(p, id)) || local_id(p, id);
14487 }
14488 
14489 /* emacsen -*- hack */
14490 static long
14491 parser_encode_length(struct parser_params *p, const char *name, long len)
14492 {
14493  long nlen;
14494 
14495  if (len > 5 && name[nlen = len - 5] == '-') {
14496  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
14497  return nlen;
14498  }
14499  if (len > 4 && name[nlen = len - 4] == '-') {
14500  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
14501  return nlen;
14502  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
14503  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
14504  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
14505  return nlen;
14506  }
14507  return len;
14508 }
14509 
14510 static void
14511 parser_set_encode(struct parser_params *p, const char *name)
14512 {
14513  int idx = rb_enc_find_index(name);
14514  rb_encoding *enc;
14515  VALUE excargs[3];
14516 
14517  if (idx < 0) {
14518  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
14519  error:
14520  excargs[0] = rb_eArgError;
14521  excargs[2] = rb_make_backtrace();
14523  rb_exc_raise(rb_make_exception(3, excargs));
14524  }
14525  enc = rb_enc_from_index(idx);
14526  if (!rb_enc_asciicompat(enc)) {
14527  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
14528  goto error;
14529  }
14530  p->enc = enc;
14531 #ifndef RIPPER
14532  if (p->debug_lines) {
14533  VALUE lines = p->debug_lines;
14534  long i, n = RARRAY_LEN(lines);
14535  for (i = 0; i < n; ++i) {
14536  rb_enc_associate_index(RARRAY_AREF(lines, i), idx);
14537  }
14538  }
14539 #endif
14540 }
14541 
14542 static int
14543 comment_at_top(struct parser_params *p)
14544 {
14545  const char *ptr = p->lex.pbeg, *ptr_end = p->lex.pcur - 1;
14546  if (p->line_count != (p->has_shebang ? 2 : 1)) return 0;
14547  while (ptr < ptr_end) {
14548  if (!ISSPACE(*ptr)) return 0;
14549  ptr++;
14550  }
14551  return 1;
14552 }
14553 
14554 typedef long (*rb_magic_comment_length_t)(struct parser_params *p, const char *name, long len);
14555 typedef void (*rb_magic_comment_setter_t)(struct parser_params *p, const char *name, const char *val);
14556 
14557 static void
14558 magic_comment_encoding(struct parser_params *p, const char *name, const char *val)
14559 {
14560  if (!comment_at_top(p)) {
14561  return;
14562  }
14563  parser_set_encode(p, val);
14564 }
14565 
14566 static int
14567 parser_get_bool(struct parser_params *p, const char *name, const char *val)
14568 {
14569  switch (*val) {
14570  case 't': case 'T':
14571  if (strcasecmp(val, "true") == 0) {
14572  return TRUE;
14573  }
14574  break;
14575  case 'f': case 'F':
14576  if (strcasecmp(val, "false") == 0) {
14577  return FALSE;
14578  }
14579  break;
14580  }
14581  rb_compile_warning(p->ruby_sourcefile, p->ruby_sourceline, "invalid value for %s: %s", name, val);
14582  return -1;
14583 }
14584 
14585 static void
14586 parser_set_token_info(struct parser_params *p, const char *name, const char *val)
14587 {
14588  int b = parser_get_bool(p, name, val);
14589  if (b >= 0) p->token_info_enabled = b;
14590 }
14591 
14592 static void
14593 parser_set_compile_option_flag(struct parser_params *p, const char *name, const char *val)
14594 {
14595  int b;
14596 
14597  if (p->token_seen) {
14598  rb_warning1("`%s' is ignored after any tokens", WARN_S(name));
14599  return;
14600  }
14601 
14602  b = parser_get_bool(p, name, val);
14603  if (b < 0) return;
14604 
14605  if (!p->compile_option)
14608  (b ? Qtrue : Qfalse));
14609 }
14610 
14611 # if WARN_PAST_SCOPE
14612 static void
14613 parser_set_past_scope(struct parser_params *p, const char *name, const char *val)
14614 {
14615  int b = parser_get_bool(p, name, val);
14616  if (b >= 0) p->past_scope_enabled = b;
14617 }
14618 # endif
14619 
14621  const char *name;
14624 };
14625 
14626 static const struct magic_comment magic_comments[] = {
14627  {"coding", magic_comment_encoding, parser_encode_length},
14628  {"encoding", magic_comment_encoding, parser_encode_length},
14629  {"frozen_string_literal", parser_set_compile_option_flag},
14630  {"warn_indent", parser_set_token_info},
14631 # if WARN_PAST_SCOPE
14632  {"warn_past_scope", parser_set_past_scope},
14633 # endif
14634 };
14635 
14636 static const char *
14637 magic_comment_marker(const char *str, long len)
14638 {
14639  long i = 2;
14640 
14641  while (i < len) {
14642  switch (str[i]) {
14643  case '-':
14644  if (str[i-1] == '*' && str[i-2] == '-') {
14645  return str + i + 1;
14646  }
14647  i += 2;
14648  break;
14649  case '*':
14650  if (i + 1 >= len) return 0;
14651  if (str[i+1] != '-') {
14652  i += 4;
14653  }
14654  else if (str[i-1] != '-') {
14655  i += 2;
14656  }
14657  else {
14658  return str + i + 2;
14659  }
14660  break;
14661  default:
14662  i += 3;
14663  break;
14664  }
14665  }
14666  return 0;
14667 }
14668 
14669 static int
14670 parser_magic_comment(struct parser_params *p, const char *str, long len)
14671 {
14672  int indicator = 0;
14673  VALUE name = 0, val = 0;
14674  const char *beg, *end, *vbeg, *vend;
14675 #define str_copy(_s, _p, _n) ((_s) \
14676  ? (void)(rb_str_resize((_s), (_n)), \
14677  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
14678  : (void)((_s) = STR_NEW((_p), (_n))))
14679 
14680  if (len <= 7) return FALSE;
14681  if (!!(beg = magic_comment_marker(str, len))) {
14682  if (!(end = magic_comment_marker(beg, str + len - beg)))
14683  return FALSE;
14684  indicator = TRUE;
14685  str = beg;
14686  len = end - beg - 3;
14687  }
14688 
14689  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
14690  while (len > 0) {
14691  const struct magic_comment *mc = magic_comments;
14692  char *s;
14693  int i;
14694  long n = 0;
14695 
14696  for (; len > 0 && *str; str++, --len) {
14697  switch (*str) {
14698  case '\'': case '"': case ':': case ';':
14699  continue;
14700  }
14701  if (!ISSPACE(*str)) break;
14702  }
14703  for (beg = str; len > 0; str++, --len) {
14704  switch (*str) {
14705  case '\'': case '"': case ':': case ';':
14706  break;
14707  default:
14708  if (ISSPACE(*str)) break;
14709  continue;
14710  }
14711  break;
14712  }
14713  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
14714  if (!len) break;
14715  if (*str != ':') {
14716  if (!indicator) return FALSE;
14717  continue;
14718  }
14719 
14720  do str++; while (--len > 0 && ISSPACE(*str));
14721  if (!len) break;
14722  if (*str == '"') {
14723  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
14724  if (*str == '\\') {
14725  --len;
14726  ++str;
14727  }
14728  }
14729  vend = str;
14730  if (len) {
14731  --len;
14732  ++str;
14733  }
14734  }
14735  else {
14736  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
14737  vend = str;
14738  }
14739  if (indicator) {
14740  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
14741  }
14742  else {
14743  while (len > 0 && (ISSPACE(*str))) --len, str++;
14744  if (len) return FALSE;
14745  }
14746 
14747  n = end - beg;
14748  str_copy(name, beg, n);
14749  s = RSTRING_PTR(name);
14750  for (i = 0; i < n; ++i) {
14751  if (s[i] == '-') s[i] = '_';
14752  }
14753  do {
14754  if (STRNCASECMP(mc->name, s, n) == 0 && !mc->name[n]) {
14755  n = vend - vbeg;
14756  if (mc->length) {
14757  n = (*mc->length)(p, vbeg, n);
14758  }
14759  str_copy(val, vbeg, n);
14760  (*mc->func)(p, mc->name, RSTRING_PTR(val));
14761  break;
14762  }
14763  } while (++mc < magic_comments + numberof(magic_comments));
14764 #ifdef RIPPER
14765  str_copy(val, vbeg, vend - vbeg);
14766  dispatch2(magic_comment, name, val);
14767 #endif
14768  }
14769 
14770  return TRUE;
14771 }
14772 
14773 static void
14774 set_file_encoding(struct parser_params *p, const char *str, const char *send)
14775 {
14776  int sep = 0;
14777  const char *beg = str;
14778  VALUE s;
14779 
14780  for (;;) {
14781  if (send - str <= 6) return;
14782  switch (str[6]) {
14783  case 'C': case 'c': str += 6; continue;
14784  case 'O': case 'o': str += 5; continue;
14785  case 'D': case 'd': str += 4; continue;
14786  case 'I': case 'i': str += 3; continue;
14787  case 'N': case 'n': str += 2; continue;
14788  case 'G': case 'g': str += 1; continue;
14789  case '=': case ':':
14790  sep = 1;
14791  str += 6;
14792  break;
14793  default:
14794  str += 6;
14795  if (ISSPACE(*str)) break;
14796  continue;
14797  }
14798  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
14799  }
14800  for (;;) {
14801  do {
14802  if (++str >= send) return;
14803  } while (ISSPACE(*str));
14804  if (sep) break;
14805  if (*str != '=' && *str != ':') return;
14806  sep = 1;
14807  str++;
14808  }
14809  beg = str;
14810  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
14811  s = rb_str_new(beg, parser_encode_length(p, beg, str - beg));
14812  parser_set_encode(p, RSTRING_PTR(s));
14813  rb_str_resize(s, 0);
14814 }
14815 
14816 static void
14817 parser_prepare(struct parser_params *p)
14818 {
14819  int c = nextc(p);
14821  switch (c) {
14822  case '#':
14823  if (peek(p, '!')) p->has_shebang = 1;
14824  break;
14825  case 0xef: /* UTF-8 BOM marker */
14826  if (p->lex.pend - p->lex.pcur >= 2 &&
14827  (unsigned char)p->lex.pcur[0] == 0xbb &&
14828  (unsigned char)p->lex.pcur[1] == 0xbf) {
14829  p->enc = rb_utf8_encoding();
14830  p->lex.pcur += 2;
14831  p->lex.pbeg = p->lex.pcur;
14832  return;
14833  }
14834  break;
14835  case EOF:
14836  return;
14837  }
14838  pushback(p, c);
14839  p->enc = rb_enc_get(p->lex.lastline);
14840 }
14841 
14842 #ifndef RIPPER
14843 #define ambiguous_operator(tok, op, syn) ( \
14844  rb_warning0("`"op"' after local variable or literal is interpreted as binary operator"), \
14845  rb_warning0("even though it seems like "syn""))
14846 #else
14847 #define ambiguous_operator(tok, op, syn) \
14848  dispatch2(operator_ambiguous, TOKEN2VAL(tok), rb_str_new_cstr(syn))
14849 #endif
14850 #define warn_balanced(tok, op, syn) ((void) \
14851  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN) && \
14852  space_seen && !ISSPACE(c) && \
14853  (ambiguous_operator(tok, op, syn), 0)), \
14854  (enum yytokentype)(tok))
14855 
14856 static VALUE
14857 parse_rational(struct parser_params *p, char *str, int len, int seen_point)
14858 {
14859  VALUE v;
14860  char *point = &str[seen_point];
14861  size_t fraclen = len-seen_point-1;
14862  memmove(point, point+1, fraclen+1);
14863  v = rb_cstr_to_inum(str, 10, FALSE);
14864  return rb_rational_new(v, rb_int_positive_pow(10, fraclen));
14865 }
14866 
14867 static enum yytokentype
14868 no_digits(struct parser_params *p)
14869 {
14870  yyerror0("numeric literal without digits");
14871  if (peek(p, '_')) nextc(p);
14872  /* dummy 0, for tUMINUS_NUM at numeric */
14873  return set_integer_literal(p, INT2FIX(0), 0);
14874 }
14875 
14876 static enum yytokentype
14877 parse_numeric(struct parser_params *p, int c)
14878 {
14879  int is_float, seen_point, seen_e, nondigit;
14880  int suffix;
14881 
14882  is_float = seen_point = seen_e = nondigit = 0;
14883  SET_LEX_STATE(EXPR_END);
14884  newtok(p);
14885  if (c == '-' || c == '+') {
14886  tokadd(p, c);
14887  c = nextc(p);
14888  }
14889  if (c == '0') {
14890  int start = toklen(p);
14891  c = nextc(p);
14892  if (c == 'x' || c == 'X') {
14893  /* hexadecimal */
14894  c = nextc(p);
14895  if (c != -1 && ISXDIGIT(c)) {
14896  do {
14897  if (c == '_') {
14898  if (nondigit) break;
14899  nondigit = c;
14900  continue;
14901  }
14902  if (!ISXDIGIT(c)) break;
14903  nondigit = 0;
14904  tokadd(p, c);
14905  } while ((c = nextc(p)) != -1);
14906  }
14907  pushback(p, c);
14908  tokfix(p);
14909  if (toklen(p) == start) {
14910  return no_digits(p);
14911  }
14912  else if (nondigit) goto trailing_uc;
14913  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
14914  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 16, FALSE), suffix);
14915  }
14916  if (c == 'b' || c == 'B') {
14917  /* binary */
14918  c = nextc(p);
14919  if (c == '0' || c == '1') {
14920  do {
14921  if (c == '_') {
14922  if (nondigit) break;
14923  nondigit = c;
14924  continue;
14925  }
14926  if (c != '0' && c != '1') break;
14927  nondigit = 0;
14928  tokadd(p, c);
14929  } while ((c = nextc(p)) != -1);
14930  }
14931  pushback(p, c);
14932  tokfix(p);
14933  if (toklen(p) == start) {
14934  return no_digits(p);
14935  }
14936  else if (nondigit) goto trailing_uc;
14937  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
14938  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 2, FALSE), suffix);
14939  }
14940  if (c == 'd' || c == 'D') {
14941  /* decimal */
14942  c = nextc(p);
14943  if (c != -1 && ISDIGIT(c)) {
14944  do {
14945  if (c == '_') {
14946  if (nondigit) break;
14947  nondigit = c;
14948  continue;
14949  }
14950  if (!ISDIGIT(c)) break;
14951  nondigit = 0;
14952  tokadd(p, c);
14953  } while ((c = nextc(p)) != -1);
14954  }
14955  pushback(p, c);
14956  tokfix(p);
14957  if (toklen(p) == start) {
14958  return no_digits(p);
14959  }
14960  else if (nondigit) goto trailing_uc;
14961  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
14962  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 10, FALSE), suffix);
14963  }
14964  if (c == '_') {
14965  /* 0_0 */
14966  goto octal_number;
14967  }
14968  if (c == 'o' || c == 'O') {
14969  /* prefixed octal */
14970  c = nextc(p);
14971  if (c == -1 || c == '_' || !ISDIGIT(c)) {
14972  return no_digits(p);
14973  }
14974  }
14975  if (c >= '0' && c <= '7') {
14976  /* octal */
14977  octal_number:
14978  do {
14979  if (c == '_') {
14980  if (nondigit) break;
14981  nondigit = c;
14982  continue;
14983  }
14984  if (c < '0' || c > '9') break;
14985  if (c > '7') goto invalid_octal;
14986  nondigit = 0;
14987  tokadd(p, c);
14988  } while ((c = nextc(p)) != -1);
14989  if (toklen(p) > start) {
14990  pushback(p, c);
14991  tokfix(p);
14992  if (nondigit) goto trailing_uc;
14993  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
14994  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 8, FALSE), suffix);
14995  }
14996  if (nondigit) {
14997  pushback(p, c);
14998  goto trailing_uc;
14999  }
15000  }
15001  if (c > '7' && c <= '9') {
15002  invalid_octal:
15003  yyerror0("Invalid octal digit");
15004  }
15005  else if (c == '.' || c == 'e' || c == 'E') {
15006  tokadd(p, '0');
15007  }
15008  else {
15009  pushback(p, c);
15010  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
15011  return set_integer_literal(p, INT2FIX(0), suffix);
15012  }
15013  }
15014 
15015  for (;;) {
15016  switch (c) {
15017  case '0': case '1': case '2': case '3': case '4':
15018  case '5': case '6': case '7': case '8': case '9':
15019  nondigit = 0;
15020  tokadd(p, c);
15021  break;
15022 
15023  case '.':
15024  if (nondigit) goto trailing_uc;
15025  if (seen_point || seen_e) {
15026  goto decode_num;
15027  }
15028  else {
15029  int c0 = nextc(p);
15030  if (c0 == -1 || !ISDIGIT(c0)) {
15031  pushback(p, c0);
15032  goto decode_num;
15033  }
15034  c = c0;
15035  }
15036  seen_point = toklen(p);
15037  tokadd(p, '.');
15038  tokadd(p, c);
15039  is_float++;
15040  nondigit = 0;
15041  break;
15042 
15043  case 'e':
15044  case 'E':
15045  if (nondigit) {
15046  pushback(p, c);
15047  c = nondigit;
15048  goto decode_num;
15049  }
15050  if (seen_e) {
15051  goto decode_num;
15052  }
15053  nondigit = c;
15054  c = nextc(p);
15055  if (c != '-' && c != '+' && !ISDIGIT(c)) {
15056  pushback(p, c);
15057  nondigit = 0;
15058  goto decode_num;
15059  }
15060  tokadd(p, nondigit);
15061  seen_e++;
15062  is_float++;
15063  tokadd(p, c);
15064  nondigit = (c == '-' || c == '+') ? c : 0;
15065  break;
15066 
15067  case '_': /* `_' in number just ignored */
15068  if (nondigit) goto decode_num;
15069  nondigit = c;
15070  break;
15071 
15072  default:
15073  goto decode_num;
15074  }
15075  c = nextc(p);
15076  }
15077 
15078  decode_num:
15079  pushback(p, c);
15080  if (nondigit) {
15081  trailing_uc:
15082  literal_flush(p, p->lex.pcur - 1);
15083  YYLTYPE loc = RUBY_INIT_YYLLOC();
15084  compile_error(p, "trailing `%c' in number", nondigit);
15085  parser_show_error_line(p, &loc);
15086  }
15087  tokfix(p);
15088  if (is_float) {
15089  enum yytokentype type = tFLOAT;
15090  VALUE v;
15091 
15092  suffix = number_literal_suffix(p, seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
15093  if (suffix & NUM_SUFFIX_R) {
15094  type = tRATIONAL;
15095  v = parse_rational(p, tok(p), toklen(p), seen_point);
15096  }
15097  else {
15098  double d = strtod(tok(p), 0);
15099  if (errno == ERANGE) {
15100  rb_warning1("Float %s out of range", WARN_S(tok(p)));
15101  errno = 0;
15102  }
15103  v = DBL2NUM(d);
15104  }
15105  return set_number_literal(p, v, type, suffix);
15106  }
15107  suffix = number_literal_suffix(p, NUM_SUFFIX_ALL);
15108  return set_integer_literal(p, rb_cstr_to_inum(tok(p), 10, FALSE), suffix);
15109 }
15110 
15111 static enum yytokentype
15112 parse_qmark(struct parser_params *p, int space_seen)
15113 {
15114  rb_encoding *enc;
15115  register int c;
15116  VALUE lit;
15117 
15118  if (IS_END()) {
15120  return '?';
15121  }
15122  c = nextc(p);
15123  if (c == -1) {
15124  compile_error(p, "incomplete character syntax");
15125  return 0;
15126  }
15127  if (rb_enc_isspace(c, p->enc)) {
15128  if (!IS_ARG()) {
15129  int c2 = escaped_control_code(c);
15130  if (c2) {
15131  WARN_SPACE_CHAR(c2, "?");
15132  }
15133  }
15134  ternary:
15135  pushback(p, c);
15137  return '?';
15138  }
15139  newtok(p);
15140  enc = p->enc;
15141  if (!parser_isascii(p)) {
15142  if (tokadd_mbchar(p, c) == -1) return 0;
15143  }
15144  else if ((rb_enc_isalnum(c, p->enc) || c == '_') &&
15145  p->lex.pcur < p->lex.pend && is_identchar(p->lex.pcur, p->lex.pend, p->enc)) {
15146  if (space_seen) {
15147  const char *start = p->lex.pcur - 1, *ptr = start;
15148  do {
15149  int n = parser_precise_mbclen(p, ptr);
15150  if (n < 0) return -1;
15151  ptr += n;
15152  } while (ptr < p->lex.pend && is_identchar(ptr, p->lex.pend, p->enc));
15153  rb_warn2("`?' just followed by `%.*s' is interpreted as" \
15154  " a conditional operator, put a space after `?'",
15155  WARN_I((int)(ptr - start)), WARN_S_L(start, (ptr - start)));
15156  }
15157  goto ternary;
15158  }
15159  else if (c == '\\') {
15160  if (peek(p, 'u')) {
15161  nextc(p);
15162  enc = rb_utf8_encoding();
15163  tokadd_utf8(p, &enc, -1, 0, 0);
15164  }
15165  else if (!lex_eol_p(p) && !(c = *p->lex.pcur, ISASCII(c))) {
15166  nextc(p);
15167  if (tokadd_mbchar(p, c) == -1) return 0;
15168  }
15169  else {
15170  c = read_escape(p, 0, &enc);
15171  tokadd(p, c);
15172  }
15173  }
15174  else {
15175  tokadd(p, c);
15176  }
15177  tokfix(p);
15178  lit = STR_NEW3(tok(p), toklen(p), enc, 0);
15179  set_yylval_str(lit);
15180  SET_LEX_STATE(EXPR_END);
15181  return tCHAR;
15182 }
15183 
15184 static enum yytokentype
15185 parse_percent(struct parser_params *p, const int space_seen, const enum lex_state_e last_state)
15186 {
15187  register int c;
15188  const char *ptok = p->lex.pcur;
15189 
15190  if (IS_BEG()) {
15191  int term;
15192  int paren;
15193 
15194  c = nextc(p);
15195  quotation:
15196  if (c == -1 || !ISALNUM(c)) {
15197  term = c;
15198  c = 'Q';
15199  }
15200  else {
15201  term = nextc(p);
15202  if (rb_enc_isalnum(term, p->enc) || !parser_isascii(p)) {
15203  yyerror0("unknown type of %string");
15204  return 0;
15205  }
15206  }
15207  if (c == -1 || term == -1) {
15208  compile_error(p, "unterminated quoted string meets end of file");
15209  return 0;
15210  }
15211  paren = term;
15212  if (term == '(') term = ')';
15213  else if (term == '[') term = ']';
15214  else if (term == '{') term = '}';
15215  else if (term == '<') term = '>';
15216  else paren = 0;
15217 
15218  p->lex.ptok = ptok-1;
15219  switch (c) {
15220  case 'Q':
15221  p->lex.strterm = NEW_STRTERM(str_dquote, term, paren);
15222  return tSTRING_BEG;
15223 
15224  case 'q':
15225  p->lex.strterm = NEW_STRTERM(str_squote, term, paren);
15226  return tSTRING_BEG;
15227 
15228  case 'W':
15229  p->lex.strterm = NEW_STRTERM(str_dword, term, paren);
15230  return tWORDS_BEG;
15231 
15232  case 'w':
15233  p->lex.strterm = NEW_STRTERM(str_sword, term, paren);
15234  return tQWORDS_BEG;
15235 
15236  case 'I':
15237  p->lex.strterm = NEW_STRTERM(str_dword, term, paren);
15238  return tSYMBOLS_BEG;
15239 
15240  case 'i':
15241  p->lex.strterm = NEW_STRTERM(str_sword, term, paren);
15242  return tQSYMBOLS_BEG;
15243 
15244  case 'x':
15245  p->lex.strterm = NEW_STRTERM(str_xquote, term, paren);
15246  return tXSTRING_BEG;
15247 
15248  case 'r':
15249  p->lex.strterm = NEW_STRTERM(str_regexp, term, paren);
15250  return tREGEXP_BEG;
15251 
15252  case 's':
15253  p->lex.strterm = NEW_STRTERM(str_ssym, term, paren);
15254  SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);
15255  return tSYMBEG;
15256 
15257  default:
15258  yyerror0("unknown type of %string");
15259  return 0;
15260  }
15261  }
15262  if ((c = nextc(p)) == '=') {
15263  set_yylval_id('%');
15264  SET_LEX_STATE(EXPR_BEG);
15265  return tOP_ASGN;
15266  }
15267  if (IS_SPCARG(c) || (IS_lex_state(EXPR_FITEM) && c == 's')) {
15268  goto quotation;
15269  }
15270  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15271  pushback(p, c);
15272  return warn_balanced('%', "%%", "string literal");
15273 }
15274 
15275 static int
15276 tokadd_ident(struct parser_params *p, int c)
15277 {
15278  do {
15279  if (tokadd_mbchar(p, c) == -1) return -1;
15280  c = nextc(p);
15281  } while (parser_is_identchar(p));
15282  pushback(p, c);
15283  return 0;
15284 }
15285 
15286 static ID
15287 tokenize_ident(struct parser_params *p, const enum lex_state_e last_state)
15288 {
15289  ID ident = TOK_INTERN();
15290 
15291  set_yylval_name(ident);
15292 
15293  return ident;
15294 }
15295 
15296 static int
15297 parse_numvar(struct parser_params *p)
15298 {
15299  size_t len;
15300  int overflow;
15301  unsigned long n = ruby_scan_digits(tok(p)+1, toklen(p)-1, 10, &len, &overflow);
15302  const unsigned long nth_ref_max =
15303  ((FIXNUM_MAX < INT_MAX) ? FIXNUM_MAX : INT_MAX) >> 1;
15304  /* NTH_REF is left-shifted to be ORed with back-ref flag and
15305  * turned into a Fixnum, in compile.c */
15306 
15307  if (overflow || n > nth_ref_max) {
15308  /* compile_error()? */
15309  rb_warn1("`%s' is too big for a number variable, always nil", WARN_S(tok(p)));
15310  return 0; /* $0 is $PROGRAM_NAME, not NTH_REF */
15311  }
15312  else {
15313  return (int)n;
15314  }
15315 }
15316 
15317 static enum yytokentype
15318 parse_gvar(struct parser_params *p, const enum lex_state_e last_state)
15319 {
15320  const char *ptr = p->lex.pcur;
15321  register int c;
15322 
15323  SET_LEX_STATE(EXPR_END);
15324  p->lex.ptok = ptr - 1; /* from '$' */
15325  newtok(p);
15326  c = nextc(p);
15327  switch (c) {
15328  case '_': /* $_: last read line string */
15329  c = nextc(p);
15330  if (parser_is_identchar(p)) {
15331  tokadd(p, '$');
15332  tokadd(p, '_');
15333  break;
15334  }
15335  pushback(p, c);
15336  c = '_';
15337  /* fall through */
15338  case '~': /* $~: match-data */
15339  case '*': /* $*: argv */
15340  case '$': /* $$: pid */
15341  case '?': /* $?: last status */
15342  case '!': /* $!: error string */
15343  case '@': /* $@: error position */
15344  case '/': /* $/: input record separator */
15345  case '\\': /* $\: output record separator */
15346  case ';': /* $;: field separator */
15347  case ',': /* $,: output field separator */
15348  case '.': /* $.: last read line number */
15349  case '=': /* $=: ignorecase */
15350  case ':': /* $:: load path */
15351  case '<': /* $<: reading filename */
15352  case '>': /* $>: default output handle */
15353  case '\"': /* $": already loaded files */
15354  tokadd(p, '$');
15355  tokadd(p, c);
15356  goto gvar;
15357 
15358  case '-':
15359  tokadd(p, '$');
15360  tokadd(p, c);
15361  c = nextc(p);
15362  if (parser_is_identchar(p)) {
15363  if (tokadd_mbchar(p, c) == -1) return 0;
15364  }
15365  else {
15366  pushback(p, c);
15367  pushback(p, '-');
15368  return '$';
15369  }
15370  gvar:
15372  return tGVAR;
15373 
15374  case '&': /* $&: last match */
15375  case '`': /* $`: string before last match */
15376  case '\'': /* $': string after last match */
15377  case '+': /* $+: string matches last paren. */
15378  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
15379  tokadd(p, '$');
15380  tokadd(p, c);
15381  goto gvar;
15382  }
15383  set_yylval_node(NEW_BACK_REF(c, &_cur_loc));
15384  return tBACK_REF;
15385 
15386  case '1': case '2': case '3':
15387  case '4': case '5': case '6':
15388  case '7': case '8': case '9':
15389  tokadd(p, '$');
15390  do {
15391  tokadd(p, c);
15392  c = nextc(p);
15393  } while (c != -1 && ISDIGIT(c));
15394  pushback(p, c);
15395  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
15396  tokfix(p);
15397  set_yylval_node(NEW_NTH_REF(parse_numvar(p), &_cur_loc));
15398  return tNTH_REF;
15399 
15400  default:
15401  if (!parser_is_identchar(p)) {
15402  YYLTYPE loc = RUBY_INIT_YYLLOC();
15403  if (c == -1 || ISSPACE(c)) {
15404  compile_error(p, "`$' without identifiers is not allowed as a global variable name");
15405  }
15406  else {
15407  pushback(p, c);
15408  compile_error(p, "`$%c' is not allowed as a global variable name", c);
15409  }
15410  parser_show_error_line(p, &loc);
15412  return tGVAR;
15413  }
15414  /* fall through */
15415  case '0':
15416  tokadd(p, '$');
15417  }
15418 
15419  if (tokadd_ident(p, c)) return 0;
15420  SET_LEX_STATE(EXPR_END);
15421  tokenize_ident(p, last_state);
15422  return tGVAR;
15423 }
15424 
15425 #ifndef RIPPER
15426 static bool
15427 parser_numbered_param(struct parser_params *p, int n)
15428 {
15429  if (n < 0) return false;
15430 
15432  return false;
15433  }
15434  if (p->max_numparam == ORDINAL_PARAM) {
15435  compile_error(p, "ordinary parameter is defined");
15436  return false;
15437  }
15438  struct vtable *args = p->lvtbl->args;
15439  if (p->max_numparam < n) {
15440  p->max_numparam = n;
15441  }
15442  while (n > args->pos) {
15443  vtable_add(args, NUMPARAM_IDX_TO_ID(args->pos+1));
15444  }
15445  return true;
15446 }
15447 #endif
15448 
15449 static enum yytokentype
15450 parse_atmark(struct parser_params *p, const enum lex_state_e last_state)
15451 {
15452  const char *ptr = p->lex.pcur;
15453  enum yytokentype result = tIVAR;
15454  register int c = nextc(p);
15455  YYLTYPE loc;
15456 
15457  p->lex.ptok = ptr - 1; /* from '@' */
15458  newtok(p);
15459  tokadd(p, '@');
15460  if (c == '@') {
15461  result = tCVAR;
15462  tokadd(p, '@');
15463  c = nextc(p);
15464  }
15465  SET_LEX_STATE(IS_lex_state_for(last_state, EXPR_FNAME) ? EXPR_ENDFN : EXPR_END);
15466  if (c == -1 || !parser_is_identchar(p)) {
15467  pushback(p, c);
15468  RUBY_SET_YYLLOC(loc);
15469  if (result == tIVAR) {
15470  compile_error(p, "`@' without identifiers is not allowed as an instance variable name");
15471  }
15472  else {
15473  compile_error(p, "`@@' without identifiers is not allowed as a class variable name");
15474  }
15475  parser_show_error_line(p, &loc);
15477  SET_LEX_STATE(EXPR_END);
15478  return result;
15479  }
15480  else if (ISDIGIT(c)) {
15481  pushback(p, c);
15482  RUBY_SET_YYLLOC(loc);
15483  if (result == tIVAR) {
15484  compile_error(p, "`@%c' is not allowed as an instance variable name", c);
15485  }
15486  else {
15487  compile_error(p, "`@@%c' is not allowed as a class variable name", c);
15488  }
15489  parser_show_error_line(p, &loc);
15491  SET_LEX_STATE(EXPR_END);
15492  return result;
15493  }
15494 
15495  if (tokadd_ident(p, c)) return 0;
15496  tokenize_ident(p, last_state);
15497  return result;
15498 }
15499 
15500 static enum yytokentype
15501 parse_ident(struct parser_params *p, int c, int cmd_state)
15502 {
15503  enum yytokentype result;
15504  int mb = ENC_CODERANGE_7BIT;
15505  const enum lex_state_e last_state = p->lex.state;
15506  ID ident;
15507 
15508  do {
15509  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
15510  if (tokadd_mbchar(p, c) == -1) return 0;
15511  c = nextc(p);
15512  } while (parser_is_identchar(p));
15513  if ((c == '!' || c == '?') && !peek(p, '=')) {
15514  result = tFID;
15515  tokadd(p, c);
15516  }
15517  else if (c == '=' && IS_lex_state(EXPR_FNAME) &&
15518  (!peek(p, '~') && !peek(p, '>') && (!peek(p, '=') || (peek_n(p, '>', 1))))) {
15519  result = tIDENTIFIER;
15520  tokadd(p, c);
15521  }
15522  else {
15523  result = tCONSTANT; /* assume provisionally */
15524  pushback(p, c);
15525  }
15526  tokfix(p);
15527 
15528  if (IS_LABEL_POSSIBLE()) {
15529  if (IS_LABEL_SUFFIX(0)) {
15530  SET_LEX_STATE(EXPR_ARG|EXPR_LABELED);
15531  nextc(p);
15533  return tLABEL;
15534  }
15535  }
15536  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
15537  const struct kwtable *kw;
15538 
15539  /* See if it is a reserved word. */
15540  kw = rb_reserved_word(tok(p), toklen(p));
15541  if (kw) {
15542  enum lex_state_e state = p->lex.state;
15543  SET_LEX_STATE(kw->state);
15544  if (IS_lex_state_for(state, EXPR_FNAME)) {
15546  return kw->id[0];
15547  }
15548  if (IS_lex_state(EXPR_BEG)) {
15549  p->command_start = TRUE;
15550  }
15551  if (kw->id[0] == keyword_do) {
15552  if (lambda_beginning_p()) {
15553  p->lex.lpar_beg = -1; /* make lambda_beginning_p() == FALSE in the body of "-> do ... end" */
15554  return keyword_do_LAMBDA;
15555  }
15556  if (COND_P()) return keyword_do_cond;
15557  if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG))
15558  return keyword_do_block;
15559  return keyword_do;
15560  }
15561  if (IS_lex_state_for(state, (EXPR_BEG | EXPR_LABELED)))
15562  return kw->id[0];
15563  else {
15564  if (kw->id[0] != kw->id[1])
15565  SET_LEX_STATE(EXPR_BEG | EXPR_LABEL);
15566  return kw->id[1];
15567  }
15568  }
15569  }
15570 
15571  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
15572  if (cmd_state) {
15573  SET_LEX_STATE(EXPR_CMDARG);
15574  }
15575  else {
15576  SET_LEX_STATE(EXPR_ARG);
15577  }
15578  }
15579  else if (p->lex.state == EXPR_FNAME) {
15580  SET_LEX_STATE(EXPR_ENDFN);
15581  }
15582  else {
15583  SET_LEX_STATE(EXPR_END);
15584  }
15585 
15586  ident = tokenize_ident(p, last_state);
15587  if (result == tCONSTANT && is_local_id(ident)) result = tIDENTIFIER;
15588  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
15589  (result == tIDENTIFIER) && /* not EXPR_FNAME, not attrasgn */
15590  lvar_defined(p, ident)) {
15591  SET_LEX_STATE(EXPR_END|EXPR_LABEL);
15592  }
15593  return result;
15594 }
15595 
15596 static enum yytokentype
15597 parser_yylex(struct parser_params *p)
15598 {
15599  register int c;
15600  int space_seen = 0;
15601  int cmd_state;
15602  int label;
15603  enum lex_state_e last_state;
15604  int fallthru = FALSE;
15605  int token_seen = p->token_seen;
15606 
15607  if (p->lex.strterm) {
15608  if (p->lex.strterm->flags & STRTERM_HEREDOC) {
15609  return here_document(p, &p->lex.strterm->u.heredoc);
15610  }
15611  else {
15612  token_flush(p);
15613  return parse_string(p, &p->lex.strterm->u.literal);
15614  }
15615  }
15616  cmd_state = p->command_start;
15617  p->command_start = FALSE;
15618  p->token_seen = TRUE;
15619  retry:
15620  last_state = p->lex.state;
15621 #ifndef RIPPER
15622  token_flush(p);
15623 #endif
15624  switch (c = nextc(p)) {
15625  case '\0': /* NUL */
15626  case '\004': /* ^D */
15627  case '\032': /* ^Z */
15628  case -1: /* end of script. */
15629  return 0;
15630 
15631  /* white spaces */
15632  case ' ': case '\t': case '\f': case '\r':
15633  case '\13': /* '\v' */
15634  space_seen = 1;
15635 #ifdef RIPPER
15636  while ((c = nextc(p))) {
15637  switch (c) {
15638  case ' ': case '\t': case '\f': case '\r':
15639  case '\13': /* '\v' */
15640  break;
15641  default:
15642  goto outofloop;
15643  }
15644  }
15645  outofloop:
15646  pushback(p, c);
15648 #endif
15649  goto retry;
15650 
15651  case '#': /* it's a comment */
15652  p->token_seen = token_seen;
15653  /* no magic_comment in shebang line */
15654  if (!parser_magic_comment(p, p->lex.pcur, p->lex.pend - p->lex.pcur)) {
15655  if (comment_at_top(p)) {
15656  set_file_encoding(p, p->lex.pcur, p->lex.pend);
15657  }
15658  }
15659  lex_goto_eol(p);
15661  fallthru = TRUE;
15662  /* fall through */
15663  case '\n':
15664  p->token_seen = token_seen;
15665  c = (IS_lex_state(EXPR_BEG|EXPR_CLASS|EXPR_FNAME|EXPR_DOT) &&
15666  !IS_lex_state(EXPR_LABELED));
15667  if (c || IS_lex_state_all(EXPR_ARG|EXPR_LABELED)) {
15668  if (!fallthru) {
15670  }
15671  fallthru = FALSE;
15672  if (!c && p->in_kwarg) {
15673  goto normal_newline;
15674  }
15675  goto retry;
15676  }
15677  while (1) {
15678  switch (c = nextc(p)) {
15679  case ' ': case '\t': case '\f': case '\r':
15680  case '\13': /* '\v' */
15681  space_seen = 1;
15682  break;
15683  case '#':
15684  pushback(p, c);
15685  if (space_seen) dispatch_scan_event(p, tSP);
15686  goto retry;
15687  case '&':
15688  case '.': {
15690  if (peek(p, '.') == (c == '&')) {
15691  pushback(p, c);
15693  goto retry;
15694  }
15695  }
15696  default:
15697  p->ruby_sourceline--;
15698  p->lex.nextline = p->lex.lastline;
15699  case -1: /* EOF no decrement*/
15700 #ifndef RIPPER
15701  if (p->lex.prevline && !p->eofp) p->lex.lastline = p->lex.prevline;
15702  p->lex.pbeg = RSTRING_PTR(p->lex.lastline);
15703  p->lex.pend = p->lex.pcur = p->lex.pbeg + RSTRING_LEN(p->lex.lastline);
15704  pushback(p, 1); /* always pushback */
15705  p->lex.ptok = p->lex.pcur;
15706 #else
15707  lex_goto_eol(p);
15708  if (c != -1) {
15709  p->lex.ptok = p->lex.pcur;
15710  }
15711 #endif
15712  goto normal_newline;
15713  }
15714  }
15715  normal_newline:
15716  p->command_start = TRUE;
15717  SET_LEX_STATE(EXPR_BEG);
15718  return '\n';
15719 
15720  case '*':
15721  if ((c = nextc(p)) == '*') {
15722  if ((c = nextc(p)) == '=') {
15724  SET_LEX_STATE(EXPR_BEG);
15725  return tOP_ASGN;
15726  }
15727  pushback(p, c);
15728  if (IS_SPCARG(c)) {
15729  rb_warning0("`**' interpreted as argument prefix");
15730  c = tDSTAR;
15731  }
15732  else if (IS_BEG()) {
15733  c = tDSTAR;
15734  }
15735  else {
15736  c = warn_balanced((enum ruby_method_ids)tPOW, "**", "argument prefix");
15737  }
15738  }
15739  else {
15740  if (c == '=') {
15741  set_yylval_id('*');
15742  SET_LEX_STATE(EXPR_BEG);
15743  return tOP_ASGN;
15744  }
15745  pushback(p, c);
15746  if (IS_SPCARG(c)) {
15747  rb_warning0("`*' interpreted as argument prefix");
15748  c = tSTAR;
15749  }
15750  else if (IS_BEG()) {
15751  c = tSTAR;
15752  }
15753  else {
15754  c = warn_balanced('*', "*", "argument prefix");
15755  }
15756  }
15757  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15758  return c;
15759 
15760  case '!':
15761  c = nextc(p);
15762  if (IS_AFTER_OPERATOR()) {
15763  SET_LEX_STATE(EXPR_ARG);
15764  if (c == '@') {
15765  return '!';
15766  }
15767  }
15768  else {
15769  SET_LEX_STATE(EXPR_BEG);
15770  }
15771  if (c == '=') {
15772  return tNEQ;
15773  }
15774  if (c == '~') {
15775  return tNMATCH;
15776  }
15777  pushback(p, c);
15778  return '!';
15779 
15780  case '=':
15781  if (was_bol(p)) {
15782  /* skip embedded rd document */
15783  if (word_match_p(p, "begin", 5)) {
15784  int first_p = TRUE;
15785 
15786  lex_goto_eol(p);
15788  for (;;) {
15789  lex_goto_eol(p);
15790  if (!first_p) {
15792  }
15793  first_p = FALSE;
15794  c = nextc(p);
15795  if (c == -1) {
15796  compile_error(p, "embedded document meets end of file");
15797  return 0;
15798  }
15799  if (c == '=' && word_match_p(p, "end", 3)) {
15800  break;
15801  }
15802  pushback(p, c);
15803  }
15804  lex_goto_eol(p);
15806  goto retry;
15807  }
15808  }
15809 
15810  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15811  if ((c = nextc(p)) == '=') {
15812  if ((c = nextc(p)) == '=') {
15813  return tEQQ;
15814  }
15815  pushback(p, c);
15816  return tEQ;
15817  }
15818  if (c == '~') {
15819  return tMATCH;
15820  }
15821  else if (c == '>') {
15822  return tASSOC;
15823  }
15824  pushback(p, c);
15825  return '=';
15826 
15827  case '<':
15828  c = nextc(p);
15829  if (c == '<' &&
15830  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
15831  !IS_END() &&
15832  (!IS_ARG() || IS_lex_state(EXPR_LABELED) || space_seen)) {
15833  int token = heredoc_identifier(p);
15834  if (token) return token < 0 ? 0 : token;
15835  }
15836  if (IS_AFTER_OPERATOR()) {
15837  SET_LEX_STATE(EXPR_ARG);
15838  }
15839  else {
15840  if (IS_lex_state(EXPR_CLASS))
15841  p->command_start = TRUE;
15842  SET_LEX_STATE(EXPR_BEG);
15843  }
15844  if (c == '=') {
15845  if ((c = nextc(p)) == '>') {
15846  return tCMP;
15847  }
15848  pushback(p, c);
15849  return tLEQ;
15850  }
15851  if (c == '<') {
15852  if ((c = nextc(p)) == '=') {
15854  SET_LEX_STATE(EXPR_BEG);
15855  return tOP_ASGN;
15856  }
15857  pushback(p, c);
15858  return warn_balanced((enum ruby_method_ids)tLSHFT, "<<", "here document");
15859  }
15860  pushback(p, c);
15861  return '<';
15862 
15863  case '>':
15864  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15865  if ((c = nextc(p)) == '=') {
15866  return tGEQ;
15867  }
15868  if (c == '>') {
15869  if ((c = nextc(p)) == '=') {
15871  SET_LEX_STATE(EXPR_BEG);
15872  return tOP_ASGN;
15873  }
15874  pushback(p, c);
15875  return tRSHFT;
15876  }
15877  pushback(p, c);
15878  return '>';
15879 
15880  case '"':
15881  label = (IS_LABEL_POSSIBLE() ? str_label : 0);
15882  p->lex.strterm = NEW_STRTERM(str_dquote | label, '"', 0);
15883  p->lex.ptok = p->lex.pcur-1;
15884  return tSTRING_BEG;
15885 
15886  case '`':
15887  if (IS_lex_state(EXPR_FNAME)) {
15888  SET_LEX_STATE(EXPR_ENDFN);
15889  return c;
15890  }
15891  if (IS_lex_state(EXPR_DOT)) {
15892  if (cmd_state)
15893  SET_LEX_STATE(EXPR_CMDARG);
15894  else
15895  SET_LEX_STATE(EXPR_ARG);
15896  return c;
15897  }
15898  p->lex.strterm = NEW_STRTERM(str_xquote, '`', 0);
15899  return tXSTRING_BEG;
15900 
15901  case '\'':
15902  label = (IS_LABEL_POSSIBLE() ? str_label : 0);
15903  p->lex.strterm = NEW_STRTERM(str_squote | label, '\'', 0);
15904  p->lex.ptok = p->lex.pcur-1;
15905  return tSTRING_BEG;
15906 
15907  case '?':
15908  return parse_qmark(p, space_seen);
15909 
15910  case '&':
15911  if ((c = nextc(p)) == '&') {
15912  SET_LEX_STATE(EXPR_BEG);
15913  if ((c = nextc(p)) == '=') {
15915  SET_LEX_STATE(EXPR_BEG);
15916  return tOP_ASGN;
15917  }
15918  pushback(p, c);
15919  return tANDOP;
15920  }
15921  else if (c == '=') {
15922  set_yylval_id('&');
15923  SET_LEX_STATE(EXPR_BEG);
15924  return tOP_ASGN;
15925  }
15926  else if (c == '.') {
15928  SET_LEX_STATE(EXPR_DOT);
15929  return tANDDOT;
15930  }
15931  pushback(p, c);
15932  if (IS_SPCARG(c)) {
15933  if ((c != ':') ||
15934  (c = peekc_n(p, 1)) == -1 ||
15935  !(c == '\'' || c == '"' ||
15936  is_identchar((p->lex.pcur+1), p->lex.pend, p->enc))) {
15937  rb_warning0("`&' interpreted as argument prefix");
15938  }
15939  c = tAMPER;
15940  }
15941  else if (IS_BEG()) {
15942  c = tAMPER;
15943  }
15944  else {
15945  c = warn_balanced('&', "&", "argument prefix");
15946  }
15947  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
15948  return c;
15949 
15950  case '|':
15951  if ((c = nextc(p)) == '|') {
15952  SET_LEX_STATE(EXPR_BEG);
15953  if ((c = nextc(p)) == '=') {
15955  SET_LEX_STATE(EXPR_BEG);
15956  return tOP_ASGN;
15957  }
15958  pushback(p, c);
15959  if (IS_lex_state_for(last_state, EXPR_BEG)) {
15960  c = '|';
15961  pushback(p, '|');
15962  return c;
15963  }
15964  return tOROP;
15965  }
15966  if (c == '=') {
15967  set_yylval_id('|');
15968  SET_LEX_STATE(EXPR_BEG);
15969  return tOP_ASGN;
15970  }
15971  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG|EXPR_LABEL);
15972  pushback(p, c);
15973  return '|';
15974 
15975  case '+':
15976  c = nextc(p);
15977  if (IS_AFTER_OPERATOR()) {
15978  SET_LEX_STATE(EXPR_ARG);
15979  if (c == '@') {
15980  return tUPLUS;
15981  }
15982  pushback(p, c);
15983  return '+';
15984  }
15985  if (c == '=') {
15986  set_yylval_id('+');
15987  SET_LEX_STATE(EXPR_BEG);
15988  return tOP_ASGN;
15989  }
15990  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p, '+'))) {
15991  SET_LEX_STATE(EXPR_BEG);
15992  pushback(p, c);
15993  if (c != -1 && ISDIGIT(c)) {
15994  return parse_numeric(p, '+');
15995  }
15996  return tUPLUS;
15997  }
15998  SET_LEX_STATE(EXPR_BEG);
15999  pushback(p, c);
16000  return warn_balanced('+', "+", "unary operator");
16001 
16002  case '-':
16003  c = nextc(p);
16004  if (IS_AFTER_OPERATOR()) {
16005  SET_LEX_STATE(EXPR_ARG);
16006  if (c == '@') {
16007  return tUMINUS;
16008  }
16009  pushback(p, c);
16010  return '-';
16011  }
16012  if (c == '=') {
16013  set_yylval_id('-');
16014  SET_LEX_STATE(EXPR_BEG);
16015  return tOP_ASGN;
16016  }
16017  if (c == '>') {
16018  SET_LEX_STATE(EXPR_ENDFN);
16019  return tLAMBDA;
16020  }
16021  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p, '-'))) {
16022  SET_LEX_STATE(EXPR_BEG);
16023  pushback(p, c);
16024  if (c != -1 && ISDIGIT(c)) {
16025  return tUMINUS_NUM;
16026  }
16027  return tUMINUS;
16028  }
16029  SET_LEX_STATE(EXPR_BEG);
16030  pushback(p, c);
16031  return warn_balanced('-', "-", "unary operator");
16032 
16033  case '.': {
16034  int is_beg = IS_BEG();
16035  SET_LEX_STATE(EXPR_BEG);
16036  if ((c = nextc(p)) == '.') {
16037  if ((c = nextc(p)) == '.') {
16038  if (p->lex.paren_nest == 0 && looking_at_eol_p(p)) {
16039  rb_warn0("... at EOL, should be parenthesized?");
16040  }
16041  return is_beg ? tBDOT3 : tDOT3;
16042  }
16043  pushback(p, c);
16044  return is_beg ? tBDOT2 : tDOT2;
16045  }
16046  pushback(p, c);
16047  if (c != -1 && ISDIGIT(c)) {
16048  char prev = p->lex.pcur-1 > p->lex.pbeg ? *(p->lex.pcur-2) : 0;
16049  parse_numeric(p, '.');
16050  if (ISDIGIT(prev)) {
16051  yyerror0("unexpected fraction part after numeric literal");
16052  }
16053  else {
16054  yyerror0("no .<digit> floating literal anymore; put 0 before dot");
16055  }
16056  SET_LEX_STATE(EXPR_END);
16057  p->lex.ptok = p->lex.pcur;
16058  goto retry;
16059  }
16060  set_yylval_id('.');
16061  SET_LEX_STATE(EXPR_DOT);
16062  return '.';
16063  }
16064 
16065  case '0': case '1': case '2': case '3': case '4':
16066  case '5': case '6': case '7': case '8': case '9':
16067  return parse_numeric(p, c);
16068 
16069  case ')':
16070  COND_POP();
16071  CMDARG_POP();
16072  SET_LEX_STATE(EXPR_ENDFN);
16073  p->lex.paren_nest--;
16074  return c;
16075 
16076  case ']':
16077  COND_POP();
16078  CMDARG_POP();
16079  SET_LEX_STATE(EXPR_END);
16080  p->lex.paren_nest--;
16081  return c;
16082 
16083  case '}':
16084  /* tSTRING_DEND does COND_POP and CMDARG_POP in the yacc's rule */
16085  if (!p->lex.brace_nest--) return tSTRING_DEND;
16086  COND_POP();
16087  CMDARG_POP();
16088  SET_LEX_STATE(EXPR_END);
16089  p->lex.paren_nest--;
16090  return c;
16091 
16092  case ':':
16093  c = nextc(p);
16094  if (c == ':') {
16095  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
16096  SET_LEX_STATE(EXPR_BEG);
16097  return tCOLON3;
16098  }
16100  SET_LEX_STATE(EXPR_DOT);
16101  return tCOLON2;
16102  }
16103  if (IS_END() || ISSPACE(c) || c == '#') {
16104  pushback(p, c);
16105  c = warn_balanced(':', ":", "symbol literal");
16106  SET_LEX_STATE(EXPR_BEG);
16107  return c;
16108  }
16109  switch (c) {
16110  case '\'':
16111  p->lex.strterm = NEW_STRTERM(str_ssym, c, 0);
16112  break;
16113  case '"':
16114  p->lex.strterm = NEW_STRTERM(str_dsym, c, 0);
16115  break;
16116  default:
16117  pushback(p, c);
16118  break;
16119  }
16120  SET_LEX_STATE(EXPR_FNAME);
16121  return tSYMBEG;
16122 
16123  case '/':
16124  if (IS_BEG()) {
16125  p->lex.strterm = NEW_STRTERM(str_regexp, '/', 0);
16126  return tREGEXP_BEG;
16127  }
16128  if ((c = nextc(p)) == '=') {
16129  set_yylval_id('/');
16130  SET_LEX_STATE(EXPR_BEG);
16131  return tOP_ASGN;
16132  }
16133  pushback(p, c);
16134  if (IS_SPCARG(c)) {
16135  arg_ambiguous(p, '/');
16136  p->lex.strterm = NEW_STRTERM(str_regexp, '/', 0);
16137  return tREGEXP_BEG;
16138  }
16139  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
16140  return warn_balanced('/', "/", "regexp literal");
16141 
16142  case '^':
16143  if ((c = nextc(p)) == '=') {
16144  set_yylval_id('^');
16145  SET_LEX_STATE(EXPR_BEG);
16146  return tOP_ASGN;
16147  }
16148  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
16149  pushback(p, c);
16150  return '^';
16151 
16152  case ';':
16153  SET_LEX_STATE(EXPR_BEG);
16154  p->command_start = TRUE;
16155  return ';';
16156 
16157  case ',':
16158  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
16159  return ',';
16160 
16161  case '~':
16162  if (IS_AFTER_OPERATOR()) {
16163  if ((c = nextc(p)) != '@') {
16164  pushback(p, c);
16165  }
16166  SET_LEX_STATE(EXPR_ARG);
16167  }
16168  else {
16169  SET_LEX_STATE(EXPR_BEG);
16170  }
16171  return '~';
16172 
16173  case '(':
16174  if (IS_BEG()) {
16175  c = tLPAREN;
16176  }
16177  else if (!space_seen) {
16178  /* foo( ... ) => method call, no ambiguity */
16179  }
16180  else if (IS_ARG() || IS_lex_state_all(EXPR_END|EXPR_LABEL)) {
16181  c = tLPAREN_ARG;
16182  }
16183  else if (IS_lex_state(EXPR_ENDFN) && !lambda_beginning_p()) {
16184  rb_warning0("parentheses after method name is interpreted as "
16185  "an argument list, not a decomposed argument");
16186  }
16187  p->lex.paren_nest++;
16188  COND_PUSH(0);
16189  CMDARG_PUSH(0);
16190  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
16191  return c;
16192 
16193  case '[':
16194  p->lex.paren_nest++;
16195  if (IS_AFTER_OPERATOR()) {
16196  if ((c = nextc(p)) == ']') {
16197  SET_LEX_STATE(EXPR_ARG);
16198  if ((c = nextc(p)) == '=') {
16199  return tASET;
16200  }
16201  pushback(p, c);
16202  return tAREF;
16203  }
16204  pushback(p, c);
16205  SET_LEX_STATE(EXPR_ARG|EXPR_LABEL);
16206  return '[';
16207  }
16208  else if (IS_BEG()) {
16209  c = tLBRACK;
16210  }
16211  else if (IS_ARG() && (space_seen || IS_lex_state(EXPR_LABELED))) {
16212  c = tLBRACK;
16213  }
16214  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
16215  COND_PUSH(0);
16216  CMDARG_PUSH(0);
16217  return c;
16218 
16219  case '{':
16220  ++p->lex.brace_nest;
16221  if (lambda_beginning_p())
16222  c = tLAMBEG;
16223  else if (IS_lex_state(EXPR_LABELED))
16224  c = tLBRACE; /* hash */
16225  else if (IS_lex_state(EXPR_ARG_ANY | EXPR_END | EXPR_ENDFN))
16226  c = '{'; /* block (primary) */
16227  else if (IS_lex_state(EXPR_ENDARG))
16228  c = tLBRACE_ARG; /* block (expr) */
16229  else
16230  c = tLBRACE; /* hash */
16231  if (c != tLBRACE) {
16232  p->command_start = TRUE;
16233  SET_LEX_STATE(EXPR_BEG);
16234  }
16235  else {
16236  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
16237  }
16238  ++p->lex.paren_nest; /* after lambda_beginning_p() */
16239  COND_PUSH(0);
16240  CMDARG_PUSH(0);
16241  return c;
16242 
16243  case '\\':
16244  c = nextc(p);
16245  if (c == '\n') {
16246  space_seen = 1;
16248  goto retry; /* skip \\n */
16249  }
16250  if (c == ' ') return tSP;
16251  if (ISSPACE(c)) return c;
16252  pushback(p, c);
16253  return '\\';
16254 
16255  case '%':
16256  return parse_percent(p, space_seen, last_state);
16257 
16258  case '$':
16259  return parse_gvar(p, last_state);
16260 
16261  case '@':
16262  return parse_atmark(p, last_state);
16263 
16264  case '_':
16265  if (was_bol(p) && whole_match_p(p, "__END__", 7, 0)) {
16266  p->ruby__end__seen = 1;
16267  p->eofp = 1;
16268 #ifndef RIPPER
16269  return -1;
16270 #else
16271  lex_goto_eol(p);
16273  return 0;
16274 #endif
16275  }
16276  newtok(p);
16277  break;
16278 
16279  default:
16280  if (!parser_is_identchar(p)) {
16281  compile_error(p, "Invalid char `\\x%02X' in expression", c);
16282  token_flush(p);
16283  goto retry;
16284  }
16285 
16286  newtok(p);
16287  break;
16288  }
16289 
16290  return parse_ident(p, c, cmd_state);
16291 }
16292 
16293 static enum yytokentype
16294 yylex(YYSTYPE *lval, YYLTYPE *yylloc, struct parser_params *p)
16295 {
16296  enum yytokentype t;
16297 
16298  p->lval = lval;
16299  lval->val = Qundef;
16300  t = parser_yylex(p);
16301  if (has_delayed_token(p))
16302  dispatch_delayed_token(p, t);
16303  else if (t != 0)
16304  dispatch_scan_event(p, t);
16305 
16306  if (p->lex.strterm && (p->lex.strterm->flags & STRTERM_HEREDOC))
16308  else
16309  RUBY_SET_YYLLOC(*yylloc);
16310 
16311  return t;
16312 }
16313 
16314 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
16315 
16316 static NODE*
16317 node_newnode(struct parser_params *p, enum node_type type, VALUE a0, VALUE a1, VALUE a2, const rb_code_location_t *loc)
16318 {
16319  NODE *n = rb_ast_newnode(p->ast, type);
16320 
16321  rb_node_init(n, type, a0, a1, a2);
16322 
16323  nd_set_loc(n, loc);
16324  nd_set_node_id(n, parser_get_node_id(p));
16325  return n;
16326 }
16327 
16328 static NODE *
16329 nd_set_loc(NODE *nd, const YYLTYPE *loc)
16330 {
16331  nd->nd_loc = *loc;
16332  nd_set_line(nd, loc->beg_pos.lineno);
16333  return nd;
16334 }
16335 
16336 #ifndef RIPPER
16337 static enum node_type
16338 nodetype(NODE *node) /* for debug */
16339 {
16340  return (enum node_type)nd_type(node);
16341 }
16342 
16343 static int
16344 nodeline(NODE *node)
16345 {
16346  return nd_line(node);
16347 }
16348 
16349 static NODE*
16350 newline_node(NODE *node)
16351 {
16352  if (node) {
16353  node = remove_begin(node);
16354  node->flags |= NODE_FL_NEWLINE;
16355  }
16356  return node;
16357 }
16358 
16359 static void
16360 fixpos(NODE *node, NODE *orig)
16361 {
16362  if (!node) return;
16363  if (!orig) return;
16364  nd_set_line(node, nd_line(orig));
16365 }
16366 
16367 static void
16368 parser_warning(struct parser_params *p, NODE *node, const char *mesg)
16369 {
16370  rb_compile_warning(p->ruby_sourcefile, nd_line(node), "%s", mesg);
16371 }
16372 
16373 static void
16374 parser_warn(struct parser_params *p, NODE *node, const char *mesg)
16375 {
16376  rb_compile_warn(p->ruby_sourcefile, nd_line(node), "%s", mesg);
16377 }
16378 
16379 static NODE*
16380 block_append(struct parser_params *p, NODE *head, NODE *tail)
16381 {
16382  NODE *end, *h = head, *nd;
16383 
16384  if (tail == 0) return head;
16385 
16386  if (h == 0) return tail;
16387  switch (nd_type(h)) {
16388  case NODE_LIT:
16389  case NODE_STR:
16390  case NODE_SELF:
16391  case NODE_TRUE:
16392  case NODE_FALSE:
16393  case NODE_NIL:
16394  parser_warning(p, h, "unused literal ignored");
16395  return tail;
16396  default:
16397  h = end = NEW_BLOCK(head, &head->nd_loc);
16398  end->nd_end = end;
16399  head = end;
16400  break;
16401  case NODE_BLOCK:
16402  end = h->nd_end;
16403  break;
16404  }
16405 
16406  nd = end->nd_head;
16407  switch (nd_type(nd)) {
16408  case NODE_RETURN:
16409  case NODE_BREAK:
16410  case NODE_NEXT:
16411  case NODE_REDO:
16412  case NODE_RETRY:
16413  if (RTEST(ruby_verbose)) {
16414  parser_warning(p, tail, "statement not reached");
16415  }
16416  break;
16417 
16418  default:
16419  break;
16420  }
16421 
16422  if (nd_type(tail) != NODE_BLOCK) {
16423  tail = NEW_BLOCK(tail, &tail->nd_loc);
16424  tail->nd_end = tail;
16425  }
16426  end->nd_next = tail;
16427  h->nd_end = tail->nd_end;
16428  nd_set_last_loc(head, nd_last_loc(tail));
16429  return head;
16430 }
16431 
16432 /* append item to the list */
16433 static NODE*
16434 list_append(struct parser_params *p, NODE *list, NODE *item)
16435 {
16436  NODE *last;
16437 
16438  if (list == 0) return NEW_LIST(item, &item->nd_loc);
16439  if (list->nd_next) {
16440  last = list->nd_next->nd_end;
16441  }
16442  else {
16443  last = list;
16444  }
16445 
16446  list->nd_alen += 1;
16447  last->nd_next = NEW_LIST(item, &item->nd_loc);
16448  list->nd_next->nd_end = last->nd_next;
16449 
16451 
16452  return list;
16453 }
16454 
16455 /* concat two lists */
16456 static NODE*
16457 list_concat(NODE *head, NODE *tail)
16458 {
16459  NODE *last;
16460 
16461  if (head->nd_next) {
16462  last = head->nd_next->nd_end;
16463  }
16464  else {
16465  last = head;
16466  }
16467 
16468  head->nd_alen += tail->nd_alen;
16469  last->nd_next = tail;
16470  if (tail->nd_next) {
16471  head->nd_next->nd_end = tail->nd_next->nd_end;
16472  }
16473  else {
16474  head->nd_next->nd_end = tail;
16475  }
16476 
16477  nd_set_last_loc(head, nd_last_loc(tail));
16478 
16479  return head;
16480 }
16481 
16482 static int
16483 literal_concat0(struct parser_params *p, VALUE head, VALUE tail)
16484 {
16485  if (NIL_P(tail)) return 1;
16486  if (!rb_enc_compatible(head, tail)) {
16487  compile_error(p, "string literal encodings differ (%s / %s)",
16488  rb_enc_name(rb_enc_get(head)),
16489  rb_enc_name(rb_enc_get(tail)));
16490  rb_str_resize(head, 0);
16491  rb_str_resize(tail, 0);
16492  return 0;
16493  }
16494  rb_str_buf_append(head, tail);
16495  return 1;
16496 }
16497 
16498 /* concat two string literals */
16499 static NODE *
16500 literal_concat(struct parser_params *p, NODE *head, NODE *tail, const YYLTYPE *loc)
16501 {
16502  enum node_type htype;
16503  NODE *headlast;
16504  VALUE lit;
16505 
16506  if (!head) return tail;
16507  if (!tail) return head;
16508 
16509  htype = nd_type(head);
16510  if (htype == NODE_EVSTR) {
16511  NODE *node = NEW_DSTR(STR_NEW0(), loc);
16512  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit);
16513  head = list_append(p, node, head);
16514  htype = NODE_DSTR;
16515  }
16516  if (p->heredoc_indent > 0) {
16517  switch (htype) {
16518  case NODE_STR:
16519  nd_set_type(head, NODE_DSTR);
16520  case NODE_DSTR:
16521  return list_append(p, head, tail);
16522  default:
16523  break;
16524  }
16525  }
16526  switch (nd_type(tail)) {
16527  case NODE_STR:
16528  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
16529  nd_type(headlast) == NODE_STR) {
16530  htype = NODE_STR;
16531  lit = headlast->nd_lit;
16532  }
16533  else {
16534  lit = head->nd_lit;
16535  }
16536  if (htype == NODE_STR) {
16537  if (!literal_concat0(p, lit, tail->nd_lit)) {
16538  error:
16539  rb_discard_node(p, head);
16540  rb_discard_node(p, tail);
16541  return 0;
16542  }
16543  rb_discard_node(p, tail);
16544  }
16545  else {
16546  list_append(p, head, tail);
16547  }
16548  break;
16549 
16550  case NODE_DSTR:
16551  if (htype == NODE_STR) {
16552  if (!literal_concat0(p, head->nd_lit, tail->nd_lit))
16553  goto error;
16554  tail->nd_lit = head->nd_lit;
16555  rb_discard_node(p, head);
16556  head = tail;
16557  }
16558  else if (NIL_P(tail->nd_lit)) {
16559  append:
16560  head->nd_alen += tail->nd_alen - 1;
16561  head->nd_next->nd_end->nd_next = tail->nd_next;
16562  head->nd_next->nd_end = tail->nd_next->nd_end;
16563  rb_discard_node(p, tail);
16564  }
16565  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
16566  nd_type(headlast) == NODE_STR) {
16567  lit = headlast->nd_lit;
16568  if (!literal_concat0(p, lit, tail->nd_lit))
16569  goto error;
16570  tail->nd_lit = Qnil;
16571  goto append;
16572  }
16573  else {
16574  list_concat(head, NEW_NODE(NODE_LIST, NEW_STR(tail->nd_lit, loc), tail->nd_alen, tail->nd_next, loc));
16575  }
16576  break;
16577 
16578  case NODE_EVSTR:
16579  if (htype == NODE_STR) {
16580  nd_set_type(head, NODE_DSTR);
16581  head->nd_alen = 1;
16582  }
16583  list_append(p, head, tail);
16584  break;
16585  }
16586  return head;
16587 }
16588 
16589 static NODE *
16590 evstr2dstr(struct parser_params *p, NODE *node)
16591 {
16592  if (nd_type(node) == NODE_EVSTR) {
16593  NODE * dstr = NEW_DSTR(STR_NEW0(), &node->nd_loc);
16594  RB_OBJ_WRITTEN(p->ast, Qnil, dstr->nd_lit);
16595  node = list_append(p, dstr, node);
16596  }
16597  return node;
16598 }
16599 
16600 static NODE *
16601 new_evstr(struct parser_params *p, NODE *node, const YYLTYPE *loc)
16602 {
16603  NODE *head = node;
16604 
16605  if (node) {
16606  switch (nd_type(node)) {
16607  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
16608  return node;
16609  }
16610  }
16611  return NEW_EVSTR(head, loc);
16612 }
16613 
16614 static NODE *
16615 call_bin_op(struct parser_params *p, NODE *recv, ID id, NODE *arg1,
16616  const YYLTYPE *op_loc, const YYLTYPE *loc)
16617 {
16618  NODE *expr;
16619  value_expr(recv);
16620  value_expr(arg1);
16621  expr = NEW_OPCALL(recv, id, NEW_LIST(arg1, &arg1->nd_loc), loc);
16622  nd_set_line(expr, op_loc->beg_pos.lineno);
16623  return expr;
16624 }
16625 
16626 static NODE *
16627 call_uni_op(struct parser_params *p, NODE *recv, ID id, const YYLTYPE *op_loc, const YYLTYPE *loc)
16628 {
16629  NODE *opcall;
16630  value_expr(recv);
16631  opcall = NEW_OPCALL(recv, id, 0, loc);
16632  nd_set_line(opcall, op_loc->beg_pos.lineno);
16633  return opcall;
16634 }
16635 
16636 static NODE *
16637 new_qcall(struct parser_params* p, ID atype, NODE *recv, ID mid, NODE *args, const YYLTYPE *op_loc, const YYLTYPE *loc)
16638 {
16639  NODE *qcall = NEW_QCALL(atype, recv, mid, args, loc);
16640  nd_set_line(qcall, op_loc->beg_pos.lineno);
16641  return qcall;
16642 }
16643 
16644 static NODE*
16645 new_command_qcall(struct parser_params* p, ID atype, NODE *recv, ID mid, NODE *args, NODE *block, const YYLTYPE *op_loc, const YYLTYPE *loc)
16646 {
16647  NODE *ret;
16648  if (block) block_dup_check(p, args, block);
16649  ret = new_qcall(p, atype, recv, mid, args, op_loc, loc);
16650  if (block) ret = method_add_block(p, ret, block, loc);
16651  fixpos(ret, recv);
16652  return ret;
16653 }
16654 
16655 #define nd_once_body(node) (nd_type(node) == NODE_ONCE ? (node)->nd_body : node)
16656 static NODE*
16657 match_op(struct parser_params *p, NODE *node1, NODE *node2, const YYLTYPE *op_loc, const YYLTYPE *loc)
16658 {
16659  NODE *n;
16660  int line = op_loc->beg_pos.lineno;
16661 
16662  value_expr(node1);
16663  value_expr(node2);
16664  if (node1 && (n = nd_once_body(node1)) != 0) {
16665  switch (nd_type(n)) {
16666  case NODE_DREGX:
16667  {
16668  NODE *match = NEW_MATCH2(node1, node2, loc);
16669  nd_set_line(match, line);
16670  return match;
16671  }
16672 
16673  case NODE_LIT:
16674  if (RB_TYPE_P(n->nd_lit, T_REGEXP)) {
16675  const VALUE lit = n->nd_lit;
16676  NODE *match = NEW_MATCH2(node1, node2, loc);
16677  match->nd_args = reg_named_capture_assign(p, lit, loc);
16678  nd_set_line(match, line);
16679  return match;
16680  }
16681  }
16682  }
16683 
16684  if (node2 && (n = nd_once_body(node2)) != 0) {
16685  NODE *match3;
16686 
16687  switch (nd_type(n)) {
16688  case NODE_LIT:
16689  if (!RB_TYPE_P(n->nd_lit, T_REGEXP)) break;
16690  /* fallthru */
16691  case NODE_DREGX:
16692  match3 = NEW_MATCH3(node2, node1, loc);
16693  return match3;
16694  }
16695  }
16696 
16697  n = NEW_CALL(node1, tMATCH, NEW_LIST(node2, &node2->nd_loc), loc);
16698  nd_set_line(n, line);
16699  return n;
16700 }
16701 
16702 # if WARN_PAST_SCOPE
16703 static int
16704 past_dvar_p(struct parser_params *p, ID id)
16705 {
16706  struct vtable *past = p->lvtbl->past;
16707  while (past) {
16708  if (vtable_included(past, id)) return 1;
16709  past = past->prev;
16710  }
16711  return 0;
16712 }
16713 # endif
16714 
16715 /* As Ripper#warn does not have arguments for the location, so the
16716  * following messages cannot be separated */
16717 #define WARN_LOCATION(type) do { \
16718  if (p->warn_location) { \
16719  int line; \
16720  VALUE file = rb_source_location(&line); \
16721  rb_warn3(type" in eval may not return location in binding;" \
16722  " use Binding#source_location instead\n" \
16723  "%"PRIsWARN":%d: warning: in `%"PRIsWARN"'", \
16724  file, WARN_I(line), rb_id2str(rb_frame_this_func())); \
16725  } \
16726 } while (0)
16727 
16728 static int
16729 numparam_nested_p(struct parser_params *p)
16730 {
16731  struct local_vars *local = p->lvtbl;
16732  NODE *outer = local->numparam.outer;
16733  NODE *inner = local->numparam.inner;
16734  if (outer || inner) {
16735  NODE *used = outer ? outer : inner;
16736  compile_error(p, "numbered parameter is already used in\n"
16737  "%s:%d: %s block here",
16739  outer ? "outer" : "inner");
16740  parser_show_error_line(p, &used->nd_loc);
16741  return 1;
16742  }
16743  return 0;
16744 }
16745 
16746 static NODE*
16747 gettable(struct parser_params *p, ID id, const YYLTYPE *loc)
16748 {
16749  ID *vidp = NULL;
16750  NODE *node;
16751  switch (id) {
16752  case keyword_self:
16753  return NEW_SELF(loc);
16754  case keyword_nil:
16755  return NEW_NIL(loc);
16756  case keyword_true:
16757  return NEW_TRUE(loc);
16758  case keyword_false:
16759  return NEW_FALSE(loc);
16760  case keyword__FILE__:
16761  WARN_LOCATION("__FILE__");
16762  {
16763  VALUE file = p->ruby_sourcefile_string;
16764  if (NIL_P(file))
16765  file = rb_str_new(0, 0);
16766  else
16767  file = rb_str_dup(file);
16768  node = NEW_STR(file, loc);
16769  RB_OBJ_WRITTEN(p->ast, Qnil, file);
16770  }
16771  return node;
16772  case keyword__LINE__:
16773  WARN_LOCATION("__LINE__");
16774  return NEW_LIT(INT2FIX(p->tokline), loc);
16775  case keyword__ENCODING__:
16776  node = NEW_LIT(rb_enc_from_encoding(p->enc), loc);
16777  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit);
16778  return node;
16779 
16780  }
16781  switch (id_type(id)) {
16782  case ID_LOCAL:
16783  if (dyna_in_block(p) && dvar_defined_ref(p, id, &vidp)) {
16784  if (NUMPARAM_ID_P(id) && numparam_nested_p(p)) return 0;
16785  if (id == p->cur_arg) {
16786  compile_error(p, "circular argument reference - %"PRIsWARN, rb_id2str(id));
16787  return 0;
16788  }
16789  if (vidp) *vidp |= LVAR_USED;
16790  node = NEW_DVAR(id, loc);
16791  return node;
16792  }
16793  if (local_id_ref(p, id, &vidp)) {
16794  if (id == p->cur_arg) {
16795  compile_error(p, "circular argument reference - %"PRIsWARN, rb_id2str(id));
16796  return 0;
16797  }
16798  if (vidp) *vidp |= LVAR_USED;
16799  node = NEW_LVAR(id, loc);
16800  return node;
16801  }
16802  if (dyna_in_block(p) && NUMPARAM_ID_P(id) &&
16803  parser_numbered_param(p, NUMPARAM_ID_TO_IDX(id))) {
16804  if (numparam_nested_p(p)) return 0;
16805  node = NEW_DVAR(id, loc);
16806  struct local_vars *local = p->lvtbl;
16807  if (!local->numparam.current) local->numparam.current = node;
16808  return node;
16809  }
16810 # if WARN_PAST_SCOPE
16811  if (!p->in_defined && RTEST(ruby_verbose) && past_dvar_p(p, id)) {
16812  rb_warning1("possible reference to past scope - %"PRIsWARN, rb_id2str(id));
16813  }
16814 # endif
16815  /* method call without arguments */
16816  return NEW_VCALL(id, loc);
16817  case ID_GLOBAL:
16818  return NEW_GVAR(id, loc);
16819  case ID_INSTANCE:
16820  return NEW_IVAR(id, loc);
16821  case ID_CONST:
16822  return NEW_CONST(id, loc);
16823  case ID_CLASS:
16824  return NEW_CVAR(id, loc);
16825  }
16826  compile_error(p, "identifier %"PRIsVALUE" is not valid to get", rb_id2str(id));
16827  return 0;
16828 }
16829 
16830 static NODE *
16831 opt_arg_append(NODE *opt_list, NODE *opt)
16832 {
16833  NODE *opts = opt_list;
16834  opts->nd_loc.end_pos = opt->nd_loc.end_pos;
16835 
16836  while (opts->nd_next) {
16837  opts = opts->nd_next;
16838  opts->nd_loc.end_pos = opt->nd_loc.end_pos;
16839  }
16840  opts->nd_next = opt;
16841 
16842  return opt_list;
16843 }
16844 
16845 static NODE *
16846 kwd_append(NODE *kwlist, NODE *kw)
16847 {
16848  if (kwlist) {
16849  NODE *kws = kwlist;
16850  kws->nd_loc.end_pos = kw->nd_loc.end_pos;
16851  while (kws->nd_next) {
16852  kws = kws->nd_next;
16853  kws->nd_loc.end_pos = kw->nd_loc.end_pos;
16854  }
16855  kws->nd_next = kw;
16856  }
16857  return kwlist;
16858 }
16859 
16860 static NODE *
16861 new_defined(struct parser_params *p, NODE *expr, const YYLTYPE *loc)
16862 {
16863  return NEW_DEFINED(remove_begin_all(expr), loc);
16864 }
16865 
16866 static NODE*
16867 symbol_append(struct parser_params *p, NODE *symbols, NODE *symbol)
16868 {
16869  if (nd_type(symbol) == NODE_DSTR) {
16870  nd_set_type(symbol, NODE_DSYM);
16871  }
16872  else {
16873  nd_set_type(symbol, NODE_LIT);
16874  RB_OBJ_WRITTEN(p->ast, Qnil, symbol->nd_lit = rb_str_intern(symbol->nd_lit));
16875  }
16876  return list_append(p, symbols, symbol);
16877 }
16878 
16879 static NODE *
16880 new_regexp(struct parser_params *p, NODE *node, int options, const YYLTYPE *loc)
16881 {
16882  NODE *list, *prev;
16883  VALUE lit;
16884 
16885  if (!node) {
16886  node = NEW_LIT(reg_compile(p, STR_NEW0(), options), loc);
16887  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit);
16888  return node;
16889  }
16890  switch (nd_type(node)) {
16891  case NODE_STR:
16892  {
16893  VALUE src = node->nd_lit;
16894  nd_set_type(node, NODE_LIT);
16895  nd_set_loc(node, loc);
16896  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit = reg_compile(p, src, options));
16897  }
16898  break;
16899  default:
16900  lit = STR_NEW0();
16901  node = NEW_NODE(NODE_DSTR, lit, 1, NEW_LIST(node, loc), loc);
16902  RB_OBJ_WRITTEN(p->ast, Qnil, lit);
16903  /* fall through */
16904  case NODE_DSTR:
16905  nd_set_type(node, NODE_DREGX);
16906  nd_set_loc(node, loc);
16907  node->nd_cflag = options & RE_OPTION_MASK;
16908  if (!NIL_P(node->nd_lit)) reg_fragment_check(p, node->nd_lit, options);
16909  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
16910  if (nd_type(list->nd_head) == NODE_STR) {
16911  VALUE tail = list->nd_head->nd_lit;
16912  if (reg_fragment_check(p, tail, options) && prev && !NIL_P(prev->nd_lit)) {
16913  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
16914  if (!literal_concat0(p, lit, tail)) {
16915  return NEW_NIL(loc); /* dummy node on error */
16916  }
16917  rb_str_resize(tail, 0);
16918  prev->nd_next = list->nd_next;
16919  rb_discard_node(p, list->nd_head);
16920  rb_discard_node(p, list);
16921  list = prev;
16922  }
16923  else {
16924  prev = list;
16925  }
16926  }
16927  else {
16928  prev = 0;
16929  }
16930  }
16931  if (!node->nd_next) {
16932  VALUE src = node->nd_lit;
16933  nd_set_type(node, NODE_LIT);
16934  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit = reg_compile(p, src, options));
16935  }
16936  if (options & RE_OPTION_ONCE) {
16937  node = NEW_NODE(NODE_ONCE, 0, node, 0, loc);
16938  }
16939  break;
16940  }
16941  return node;
16942 }
16943 
16944 static NODE *
16945 new_kw_arg(struct parser_params *p, NODE *k, const YYLTYPE *loc)
16946 {
16947  if (!k) return 0;
16948  return NEW_KW_ARG(0, (k), loc);
16949 }
16950 
16951 static NODE *
16952 new_xstring(struct parser_params *p, NODE *node, const YYLTYPE *loc)
16953 {
16954  if (!node) {
16955  VALUE lit = STR_NEW0();
16956  NODE *xstr = NEW_XSTR(lit, loc);
16957  RB_OBJ_WRITTEN(p->ast, Qnil, lit);
16958  return xstr;
16959  }
16960  switch (nd_type(node)) {
16961  case NODE_STR:
16962  nd_set_type(node, NODE_XSTR);
16963  nd_set_loc(node, loc);
16964  break;
16965  case NODE_DSTR:
16966  nd_set_type(node, NODE_DXSTR);
16967  nd_set_loc(node, loc);
16968  break;
16969  default:
16970  node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node, loc), loc);
16971  break;
16972  }
16973  return node;
16974 }
16975 
16976 static void
16977 check_literal_when(struct parser_params *p, NODE *arg, const YYLTYPE *loc)
16978 {
16979  VALUE lit;
16980 
16981  if (!arg || !p->case_labels) return;
16982 
16984  if (lit == Qundef) return;
16985  if (nd_type(arg) == NODE_STR) {
16986  RB_OBJ_WRITTEN(p->ast, Qnil, arg->nd_lit = lit);
16987  }
16988 
16989  if (NIL_P(p->case_labels)) {
16991  }
16992  else {
16993  VALUE line = rb_hash_lookup(p->case_labels, lit);
16994  if (!NIL_P(line)) {
16995  rb_warning1("duplicated `when' clause with line %d is ignored",
16996  WARN_IVAL(line));
16997  return;
16998  }
16999  }
17001 }
17002 
17003 #else /* !RIPPER */
17004 static int
17005 id_is_var(struct parser_params *p, ID id)
17006 {
17007  if (is_notop_id(id)) {
17008  switch (id & ID_SCOPE_MASK) {
17009  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
17010  return 1;
17011  case ID_LOCAL:
17012  if (dyna_in_block(p)) {
17013  if (NUMPARAM_ID_P(id) || dvar_defined(p, id)) return 1;
17014  }
17015  if (local_id(p, id)) return 1;
17016  /* method call without arguments */
17017  return 0;
17018  }
17019  }
17020  compile_error(p, "identifier %"PRIsVALUE" is not valid to get", rb_id2str(id));
17021  return 0;
17022 }
17023 
17024 static VALUE
17025 new_regexp(struct parser_params *p, VALUE re, VALUE opt, const YYLTYPE *loc)
17026 {
17027  VALUE src = 0, err;
17028  int options = 0;
17029  if (ripper_is_node_yylval(re)) {
17030  src = RNODE(re)->nd_cval;
17031  re = RNODE(re)->nd_rval;
17032  }
17033  if (ripper_is_node_yylval(opt)) {
17034  options = (int)RNODE(opt)->nd_tag;
17035  opt = RNODE(opt)->nd_rval;
17036  }
17037  if (src && NIL_P(parser_reg_compile(p, src, options, &err))) {
17038  compile_error(p, "%"PRIsVALUE, err);
17039  }
17040  return dispatch2(regexp_literal, re, opt);
17041 }
17042 #endif /* !RIPPER */
17043 
17044 
17045 #ifndef RIPPER
17046 static const char rb_parser_lex_state_names[][8] = {
17047  "BEG", "END", "ENDARG", "ENDFN", "ARG",
17048  "CMDARG", "MID", "FNAME", "DOT", "CLASS",
17049  "LABEL", "LABELED","FITEM",
17050 };
17051 
17052 static VALUE
17053 append_lex_state_name(enum lex_state_e state, VALUE buf)
17054 {
17055  int i, sep = 0;
17056  unsigned int mask = 1;
17057  static const char none[] = "NONE";
17058 
17059  for (i = 0; i < EXPR_MAX_STATE; ++i, mask <<= 1) {
17060  if ((unsigned)state & mask) {
17061  if (sep) {
17062  rb_str_cat(buf, "|", 1);
17063  }
17064  sep = 1;
17065  rb_str_cat_cstr(buf, rb_parser_lex_state_names[i]);
17066  }
17067  }
17068  if (!sep) {
17069  rb_str_cat(buf, none, sizeof(none)-1);
17070  }
17071  return buf;
17072 }
17073 
17074 static void
17075 flush_debug_buffer(struct parser_params *p, VALUE out, VALUE str)
17076 {
17077  VALUE mesg = p->debug_buffer;
17078 
17079  if (!NIL_P(mesg) && RSTRING_LEN(mesg)) {
17080  p->debug_buffer = Qnil;
17081  rb_io_puts(1, &mesg, out);
17082  }
17083  if (!NIL_P(str) && RSTRING_LEN(str)) {
17085  }
17086 }
17087 
17088 enum lex_state_e
17090  enum lex_state_e to, int line)
17091 {
17092  VALUE mesg;
17093  mesg = rb_str_new_cstr("lex_state: ");
17094  append_lex_state_name(from, mesg);
17095  rb_str_cat_cstr(mesg, " -> ");
17096  append_lex_state_name(to, mesg);
17097  rb_str_catf(mesg, " at line %d\n", line);
17098  flush_debug_buffer(p, p->debug_output, mesg);
17099  return to;
17100 }
17101 
17102 VALUE
17104 {
17105  return rb_fstring(append_lex_state_name(state, rb_str_new(0, 0)));
17106 }
17107 
17108 static void
17109 append_bitstack_value(stack_type stack, VALUE mesg)
17110 {
17111  if (stack == 0) {
17112  rb_str_cat_cstr(mesg, "0");
17113  }
17114  else {
17115  stack_type mask = (stack_type)1U << (CHAR_BIT * sizeof(stack_type) - 1);
17116  for (; mask && !(stack & mask); mask >>= 1) continue;
17117  for (; mask; mask >>= 1) rb_str_cat(mesg, stack & mask ? "1" : "0", 1);
17118  }
17119 }
17120 
17121 void
17123  const char *name, int line)
17124 {
17125  VALUE mesg = rb_sprintf("%s: ", name);
17126  append_bitstack_value(stack, mesg);
17127  rb_str_catf(mesg, " at line %d\n", line);
17128  flush_debug_buffer(p, p->debug_output, mesg);
17129 }
17130 
17131 void
17132 rb_parser_fatal(struct parser_params *p, const char *fmt, ...)
17133 {
17134  va_list ap;
17135  VALUE mesg = rb_str_new_cstr("internal parser error: ");
17136 
17137  va_start(ap, fmt);
17138  rb_str_vcatf(mesg, fmt, ap);
17139  va_end(ap);
17140  parser_yyerror(p, NULL, RSTRING_PTR(mesg));
17141  RB_GC_GUARD(mesg);
17142 
17143  mesg = rb_str_new(0, 0);
17144  append_lex_state_name(p->lex.state, mesg);
17145  compile_error(p, "lex.state: %"PRIsVALUE, mesg);
17146  rb_str_resize(mesg, 0);
17147  append_bitstack_value(p->cond_stack, mesg);
17148  compile_error(p, "cond_stack: %"PRIsVALUE, mesg);
17149  rb_str_resize(mesg, 0);
17150  append_bitstack_value(p->cmdarg_stack, mesg);
17151  compile_error(p, "cmdarg_stack: %"PRIsVALUE, mesg);
17152  if (p->debug_output == rb_stdout)
17153  p->debug_output = rb_stderr;
17154  p->debug = TRUE;
17155 }
17156 
17157 YYLTYPE *
17159 {
17160  int sourceline = here->sourceline;
17161  int beg_pos = (int)here->offset - here->quote
17162  - (rb_strlen_lit("<<-") - !(here->func & STR_FUNC_INDENT));
17163  int end_pos = (int)here->offset + here->length + here->quote;
17164 
17165  yylloc->beg_pos.lineno = sourceline;
17166  yylloc->beg_pos.column = beg_pos;
17167  yylloc->end_pos.lineno = sourceline;
17168  yylloc->end_pos.column = end_pos;
17169  return yylloc;
17170 }
17171 
17172 YYLTYPE *
17174 {
17175  yylloc->beg_pos.lineno = p->ruby_sourceline;
17176  yylloc->beg_pos.column = (int)(p->lex.ptok - p->lex.pbeg);
17177  yylloc->end_pos.lineno = p->ruby_sourceline;
17178  yylloc->end_pos.column = (int)(p->lex.ptok - p->lex.pbeg);
17179  return yylloc;
17180 }
17181 
17182 YYLTYPE *
17184 {
17185  yylloc->beg_pos.lineno = p->ruby_sourceline;
17186  yylloc->beg_pos.column = (int)(p->lex.ptok - p->lex.pbeg);
17187  yylloc->end_pos.lineno = p->ruby_sourceline;
17188  yylloc->end_pos.column = (int)(p->lex.pcur - p->lex.pbeg);
17189  return yylloc;
17190 }
17191 #endif /* !RIPPER */
17192 
17193 static void
17194 parser_token_value_print(struct parser_params *p, enum yytokentype type, const YYSTYPE *valp)
17195 {
17196  VALUE v;
17197 
17198  switch (type) {
17199  case tIDENTIFIER: case tFID: case tGVAR: case tIVAR:
17200  case tCONSTANT: case tCVAR: case tLABEL: case tOP_ASGN:
17201 #ifndef RIPPER
17202  v = rb_id2str(valp->id);
17203 #else
17204  v = valp->node->nd_rval;
17205 #endif
17206  rb_parser_printf(p, "%"PRIsVALUE, v);
17207  break;
17208  case tINTEGER: case tFLOAT: case tRATIONAL: case tIMAGINARY:
17209  case tSTRING_CONTENT: case tCHAR:
17210 #ifndef RIPPER
17211  v = valp->node->nd_lit;
17212 #else
17213  v = valp->val;
17214 #endif
17215  rb_parser_printf(p, "%+"PRIsVALUE, v);
17216  break;
17217  case tNTH_REF:
17218 #ifndef RIPPER
17219  rb_parser_printf(p, "$%ld", valp->node->nd_nth);
17220 #else
17221  rb_parser_printf(p, "%"PRIsVALUE, valp->val);
17222 #endif
17223  break;
17224  case tBACK_REF:
17225 #ifndef RIPPER
17226  rb_parser_printf(p, "$%c", (int)valp->node->nd_nth);
17227 #else
17228  rb_parser_printf(p, "%"PRIsVALUE, valp->val);
17229 #endif
17230  break;
17231  default:
17232  break;
17233  }
17234 }
17235 
17236 static int
17237 assignable0(struct parser_params *p, ID id, const char **err)
17238 {
17239  if (!id) return -1;
17240  switch (id) {
17241  case keyword_self:
17242  *err = "Can't change the value of self";
17243  return -1;
17244  case keyword_nil:
17245  *err = "Can't assign to nil";
17246  return -1;
17247  case keyword_true:
17248  *err = "Can't assign to true";
17249  return -1;
17250  case keyword_false:
17251  *err = "Can't assign to false";
17252  return -1;
17253  case keyword__FILE__:
17254  *err = "Can't assign to __FILE__";
17255  return -1;
17256  case keyword__LINE__:
17257  *err = "Can't assign to __LINE__";
17258  return -1;
17259  case keyword__ENCODING__:
17260  *err = "Can't assign to __ENCODING__";
17261  return -1;
17262  }
17263  switch (id_type(id)) {
17264  case ID_LOCAL:
17265  if (dyna_in_block(p)) {
17266  if (p->max_numparam > NO_PARAM && NUMPARAM_ID_P(id)) {
17267  compile_error(p, "Can't assign to numbered parameter _%d",
17268  NUMPARAM_ID_TO_IDX(id));
17269  return -1;
17270  }
17271  if (dvar_curr(p, id)) return NODE_DASGN_CURR;
17272  if (dvar_defined(p, id)) return NODE_DASGN;
17273  if (local_id(p, id)) return NODE_LASGN;
17274  dyna_var(p, id);
17275  return NODE_DASGN_CURR;
17276  }
17277  else {
17278  if (!local_id(p, id)) local_var(p, id);
17279  return NODE_LASGN;
17280  }
17281  break;
17282  case ID_GLOBAL: return NODE_GASGN;
17283  case ID_INSTANCE: return NODE_IASGN;
17284  case ID_CONST:
17285  if (!p->in_def) return NODE_CDECL;
17286  *err = "dynamic constant assignment";
17287  return -1;
17288  case ID_CLASS: return NODE_CVASGN;
17289  default:
17290  compile_error(p, "identifier %"PRIsVALUE" is not valid to set", rb_id2str(id));
17291  }
17292  return -1;
17293 }
17294 
17295 #ifndef RIPPER
17296 static NODE*
17297 assignable(struct parser_params *p, ID id, NODE *val, const YYLTYPE *loc)
17298 {
17299  const char *err = 0;
17300  int node_type = assignable0(p, id, &err);
17301  switch (node_type) {
17302  case NODE_DASGN_CURR: return NEW_DASGN_CURR(id, val, loc);
17303  case NODE_DASGN: return NEW_DASGN(id, val, loc);
17304  case NODE_LASGN: return NEW_LASGN(id, val, loc);
17305  case NODE_GASGN: return NEW_GASGN(id, val, loc);
17306  case NODE_IASGN: return NEW_IASGN(id, val, loc);
17307  case NODE_CDECL: return NEW_CDECL(id, val, 0, loc);
17308  case NODE_CVASGN: return NEW_CVASGN(id, val, loc);
17309  }
17310  if (err) yyerror1(loc, err);
17311  return NEW_BEGIN(0, loc);
17312 }
17313 #else
17314 static VALUE
17315 assignable(struct parser_params *p, VALUE lhs)
17316 {
17317  const char *err = 0;
17318  assignable0(p, get_id(lhs), &err);
17319  if (err) lhs = assign_error(p, lhs);
17320  return lhs;
17321 }
17322 #endif
17323 
17324 static int
17325 is_private_local_id(ID name)
17326 {
17327  VALUE s;
17328  if (name == idUScore) return 1;
17329  if (!is_local_id(name)) return 0;
17330  s = rb_id2str(name);
17331  if (!s) return 0;
17332  return RSTRING_PTR(s)[0] == '_';
17333 }
17334 
17335 static int
17336 shadowing_lvar_0(struct parser_params *p, ID name)
17337 {
17338  if (is_private_local_id(name)) return 1;
17339  if (dyna_in_block(p)) {
17340  if (dvar_curr(p, name)) {
17341  yyerror0("duplicated argument name");
17342  }
17343  else if (dvar_defined(p, name) || local_id(p, name)) {
17344  vtable_add(p->lvtbl->vars, name);
17345  if (p->lvtbl->used) {
17347  }
17348  return 0;
17349  }
17350  }
17351  else {
17352  if (local_id(p, name)) {
17353  yyerror0("duplicated argument name");
17354  }
17355  }
17356  return 1;
17357 }
17358 
17359 static ID
17360 shadowing_lvar(struct parser_params *p, ID name)
17361 {
17362  shadowing_lvar_0(p, name);
17363  return name;
17364 }
17365 
17366 static void
17367 new_bv(struct parser_params *p, ID name)
17368 {
17369  if (!name) return;
17370  if (!is_local_id(name)) {
17371  compile_error(p, "invalid local variable - %"PRIsVALUE,
17372  rb_id2str(name));
17373  return;
17374  }
17375  if (!shadowing_lvar_0(p, name)) return;
17376  dyna_var(p, name);
17377 }
17378 
17379 #ifndef RIPPER
17380 static NODE *
17381 aryset(struct parser_params *p, NODE *recv, NODE *idx, const YYLTYPE *loc)
17382 {
17383  return NEW_ATTRASGN(recv, tASET, idx, loc);
17384 }
17385 
17386 static void
17387 block_dup_check(struct parser_params *p, NODE *node1, NODE *node2)
17388 {
17389  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
17390  compile_error(p, "both block arg and actual block given");
17391  }
17392 }
17393 
17394 static NODE *
17395 attrset(struct parser_params *p, NODE *recv, ID atype, ID id, const YYLTYPE *loc)
17396 {
17397  if (!CALL_Q_P(atype)) id = rb_id_attrset(id);
17398  return NEW_ATTRASGN(recv, id, 0, loc);
17399 }
17400 
17401 static void
17402 rb_backref_error(struct parser_params *p, NODE *node)
17403 {
17404  switch (nd_type(node)) {
17405  case NODE_NTH_REF:
17406  compile_error(p, "Can't set variable $%ld", node->nd_nth);
17407  break;
17408  case NODE_BACK_REF:
17409  compile_error(p, "Can't set variable $%c", (int)node->nd_nth);
17410  break;
17411  }
17412 }
17413 
17414 static NODE *
17415 arg_append(struct parser_params *p, NODE *node1, NODE *node2, const YYLTYPE *loc)
17416 {
17417  if (!node1) return NEW_LIST(node2, &node2->nd_loc);
17418  switch (nd_type(node1)) {
17419  case NODE_LIST:
17420  return list_append(p, node1, node2);
17421  case NODE_BLOCK_PASS:
17422  node1->nd_head = arg_append(p, node1->nd_head, node2, loc);
17423  node1->nd_loc.end_pos = node1->nd_head->nd_loc.end_pos;
17424  return node1;
17425  case NODE_ARGSPUSH:
17426  node1->nd_body = list_append(p, NEW_LIST(node1->nd_body, &node1->nd_body->nd_loc), node2);
17427  node1->nd_loc.end_pos = node1->nd_body->nd_loc.end_pos;
17428  nd_set_type(node1, NODE_ARGSCAT);
17429  return node1;
17430  case NODE_ARGSCAT:
17431  if (nd_type(node1->nd_body) != NODE_LIST) break;
17432  node1->nd_body = list_append(p, node1->nd_body, node2);
17433  node1->nd_loc.end_pos = node1->nd_body->nd_loc.end_pos;
17434  return node1;
17435  }
17436  return NEW_ARGSPUSH(node1, node2, loc);
17437 }
17438 
17439 static NODE *
17440 arg_concat(struct parser_params *p, NODE *node1, NODE *node2, const YYLTYPE *loc)
17441 {
17442  if (!node2) return node1;
17443  switch (nd_type(node1)) {
17444  case NODE_BLOCK_PASS:
17445  if (node1->nd_head)
17446  node1->nd_head = arg_concat(p, node1->nd_head, node2, loc);
17447  else
17448  node1->nd_head = NEW_LIST(node2, loc);
17449  return node1;
17450  case NODE_ARGSPUSH:
17451  if (nd_type(node2) != NODE_LIST) break;
17452  node1->nd_body = list_concat(NEW_LIST(node1->nd_body, loc), node2);
17453  nd_set_type(node1, NODE_ARGSCAT);
17454  return node1;
17455  case NODE_ARGSCAT:
17456  if (nd_type(node2) != NODE_LIST ||
17457  nd_type(node1->nd_body) != NODE_LIST) break;
17458  node1->nd_body = list_concat(node1->nd_body, node2);
17459  return node1;
17460  }
17461  return NEW_ARGSCAT(node1, node2, loc);
17462 }
17463 
17464 static NODE *
17465 last_arg_append(struct parser_params *p, NODE *args, NODE *last_arg, const YYLTYPE *loc)
17466 {
17467  NODE *n1;
17468  if ((n1 = splat_array(args)) != 0) {
17469  return list_append(p, n1, last_arg);
17470  }
17471  return arg_append(p, args, last_arg, loc);
17472 }
17473 
17474 static NODE *
17475 rest_arg_append(struct parser_params *p, NODE *args, NODE *rest_arg, const YYLTYPE *loc)
17476 {
17477  NODE *n1;
17478  if ((nd_type(rest_arg) == NODE_LIST) && (n1 = splat_array(args)) != 0) {
17479  return list_concat(n1, rest_arg);
17480  }
17481  return arg_concat(p, args, rest_arg, loc);
17482 }
17483 
17484 static NODE *
17485 splat_array(NODE* node)
17486 {
17487  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
17488  if (nd_type(node) == NODE_LIST) return node;
17489  return 0;
17490 }
17491 
17492 static void
17493 mark_lvar_used(struct parser_params *p, NODE *rhs)
17494 {
17495  ID *vidp = NULL;
17496  if (!rhs) return;
17497  switch (nd_type(rhs)) {
17498  case NODE_LASGN:
17499  if (local_id_ref(p, rhs->nd_vid, &vidp)) {
17500  if (vidp) *vidp |= LVAR_USED;
17501  }
17502  break;
17503  case NODE_DASGN:
17504  case NODE_DASGN_CURR:
17505  if (dvar_defined_ref(p, rhs->nd_vid, &vidp)) {
17506  if (vidp) *vidp |= LVAR_USED;
17507  }
17508  break;
17509 #if 0
17510  case NODE_MASGN:
17511  for (rhs = rhs->nd_head; rhs; rhs = rhs->nd_next) {
17512  mark_lvar_used(p, rhs->nd_head);
17513  }
17514  break;
17515 #endif
17516  }
17517 }
17518 
17519 static NODE *
17520 node_assign(struct parser_params *p, NODE *lhs, NODE *rhs, const YYLTYPE *loc)
17521 {
17522  if (!lhs) return 0;
17523 
17524  switch (nd_type(lhs)) {
17525  case NODE_GASGN:
17526  case NODE_IASGN:
17527  case NODE_LASGN:
17528  case NODE_DASGN:
17529  case NODE_DASGN_CURR:
17530  case NODE_MASGN:
17531  case NODE_CDECL:
17532  case NODE_CVASGN:
17533  lhs->nd_value = rhs;
17534  nd_set_loc(lhs, loc);
17535  break;
17536 
17537  case NODE_ATTRASGN:
17538  lhs->nd_args = arg_append(p, lhs->nd_args, rhs, loc);
17539  nd_set_loc(lhs, loc);
17540  break;
17541 
17542  default:
17543  /* should not happen */
17544  break;
17545  }
17546 
17547  return lhs;
17548 }
17549 
17550 static NODE *
17551 value_expr_check(struct parser_params *p, NODE *node)
17552 {
17553  NODE *void_node = 0, *vn;
17554 
17555  if (!node) {
17556  rb_warning0("empty expression");
17557  }
17558  while (node) {
17559  switch (nd_type(node)) {
17560  case NODE_RETURN:
17561  case NODE_BREAK:
17562  case NODE_NEXT:
17563  case NODE_REDO:
17564  case NODE_RETRY:
17565  return void_node ? void_node : node;
17566 
17567  case NODE_CASE3:
17568  if (!node->nd_body || nd_type(node->nd_body) != NODE_IN) {
17569  compile_error(p, "unexpected node");
17570  return NULL;
17571  }
17572  if (node->nd_body->nd_body) {
17573  return NULL;
17574  }
17575  /* single line pattern matching */
17576  return void_node ? void_node : node;
17577 
17578  case NODE_BLOCK:
17579  while (node->nd_next) {
17580  node = node->nd_next;
17581  }
17582  node = node->nd_head;
17583  break;
17584 
17585  case NODE_BEGIN:
17586  node = node->nd_body;
17587  break;
17588 
17589  case NODE_IF:
17590  case NODE_UNLESS:
17591  if (!node->nd_body) {
17592  return NULL;
17593  }
17594  else if (!node->nd_else) {
17595  return NULL;
17596  }
17597  vn = value_expr_check(p, node->nd_body);
17598  if (!vn) return NULL;
17599  if (!void_node) void_node = vn;
17600  node = node->nd_else;
17601  break;
17602 
17603  case NODE_AND:
17604  case NODE_OR:
17605  node = node->nd_1st;
17606  break;
17607 
17608  case NODE_LASGN:
17609  case NODE_DASGN:
17610  case NODE_DASGN_CURR:
17611  case NODE_MASGN:
17612  mark_lvar_used(p, node);
17613  return NULL;
17614 
17615  default:
17616  return NULL;
17617  }
17618  }
17619 
17620  return NULL;
17621 }
17622 
17623 static int
17624 value_expr_gen(struct parser_params *p, NODE *node)
17625 {
17626  NODE *void_node = value_expr_check(p, node);
17627  if (void_node) {
17628  yyerror1(&void_node->nd_loc, "void value expression");
17629  /* or "control never reach"? */
17630  return FALSE;
17631  }
17632  return TRUE;
17633 }
17634 static void
17635 void_expr(struct parser_params *p, NODE *node)
17636 {
17637  const char *useless = 0;
17638 
17639  if (!RTEST(ruby_verbose)) return;
17640 
17641  if (!node || !(node = nd_once_body(node))) return;
17642  switch (nd_type(node)) {
17643  case NODE_OPCALL:
17644  switch (node->nd_mid) {
17645  case '+':
17646  case '-':
17647  case '*':
17648  case '/':
17649  case '%':
17650  case tPOW:
17651  case tUPLUS:
17652  case tUMINUS:
17653  case '|':
17654  case '^':
17655  case '&':
17656  case tCMP:
17657  case '>':
17658  case tGEQ:
17659  case '<':
17660  case tLEQ:
17661  case tEQ:
17662  case tNEQ:
17663  useless = rb_id2name(node->nd_mid);
17664  break;
17665  }
17666  break;
17667 
17668  case NODE_LVAR:
17669  case NODE_DVAR:
17670  case NODE_GVAR:
17671  case NODE_IVAR:
17672  case NODE_CVAR:
17673  case NODE_NTH_REF:
17674  case NODE_BACK_REF:
17675  useless = "a variable";
17676  break;
17677  case NODE_CONST:
17678  useless = "a constant";
17679  break;
17680  case NODE_LIT:
17681  case NODE_STR:
17682  case NODE_DSTR:
17683  case NODE_DREGX:
17684  useless = "a literal";
17685  break;
17686  case NODE_COLON2:
17687  case NODE_COLON3:
17688  useless = "::";
17689  break;
17690  case NODE_DOT2:
17691  useless = "..";
17692  break;
17693  case NODE_DOT3:
17694  useless = "...";
17695  break;
17696  case NODE_SELF:
17697  useless = "self";
17698  break;
17699  case NODE_NIL:
17700  useless = "nil";
17701  break;
17702  case NODE_TRUE:
17703  useless = "true";
17704  break;
17705  case NODE_FALSE:
17706  useless = "false";
17707  break;
17708  case NODE_DEFINED:
17709  useless = "defined?";
17710  break;
17711  }
17712 
17713  if (useless) {
17714  rb_warn1L(nd_line(node), "possibly useless use of %s in void context", WARN_S(useless));
17715  }
17716 }
17717 
17718 static NODE *
17719 void_stmts(struct parser_params *p, NODE *node)
17720 {
17721  NODE *const n = node;
17722  if (!RTEST(ruby_verbose)) return n;
17723  if (!node) return n;
17724  if (nd_type(node) != NODE_BLOCK) return n;
17725 
17726  while (node->nd_next) {
17727  void_expr(p, node->nd_head);
17728  node = node->nd_next;
17729  }
17730  return n;
17731 }
17732 
17733 static NODE *
17734 remove_begin(NODE *node)
17735 {
17736  NODE **n = &node, *n1 = node;
17737  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
17738  *n = n1 = n1->nd_body;
17739  }
17740  return node;
17741 }
17742 
17743 static NODE *
17744 remove_begin_all(NODE *node)
17745 {
17746  NODE **n = &node, *n1 = node;
17747  while (n1 && nd_type(n1) == NODE_BEGIN) {
17748  *n = n1 = n1->nd_body;
17749  }
17750  return node;
17751 }
17752 
17753 static void
17754 reduce_nodes(struct parser_params *p, NODE **body)
17755 {
17756  NODE *node = *body;
17757 
17758  if (!node) {
17759  *body = NEW_NIL(&NULL_LOC);
17760  return;
17761  }
17762 #define subnodes(n1, n2) \
17763  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
17764  (!node->n2) ? (body = &node->n1, 1) : \
17765  (reduce_nodes(p, &node->n1), body = &node->n2, 1))
17766 
17767  while (node) {
17768  int newline = (int)(node->flags & NODE_FL_NEWLINE);
17769  switch (nd_type(node)) {
17770  end:
17771  case NODE_NIL:
17772  *body = 0;
17773  return;
17774  case NODE_RETURN:
17775  *body = node = node->nd_stts;
17776  if (newline && node) node->flags |= NODE_FL_NEWLINE;
17777  continue;
17778  case NODE_BEGIN:
17779  *body = node = node->nd_body;
17780  if (newline && node) node->flags |= NODE_FL_NEWLINE;
17781  continue;
17782  case NODE_BLOCK:
17783  body = &node->nd_end->nd_head;
17784  break;
17785  case NODE_IF:
17786  case NODE_UNLESS:
17787  if (subnodes(nd_body, nd_else)) break;
17788  return;
17789  case NODE_CASE:
17790  body = &node->nd_body;
17791  break;
17792  case NODE_WHEN:
17793  if (!subnodes(nd_body, nd_next)) goto end;
17794  break;
17795  case NODE_ENSURE:
17796  if (!subnodes(nd_head, nd_resq)) goto end;
17797  break;
17798  case NODE_RESCUE:
17799  if (node->nd_else) {
17800  body = &node->nd_resq;
17801  break;
17802  }
17803  if (!subnodes(nd_head, nd_resq)) goto end;
17804  break;
17805  default:
17806  return;
17807  }
17808  node = *body;
17809  if (newline && node) node->flags |= NODE_FL_NEWLINE;
17810  }
17811 
17812 #undef subnodes
17813 }
17814 
17815 static int
17816 is_static_content(NODE *node)
17817 {
17818  if (!node) return 1;
17819  switch (nd_type(node)) {
17820  case NODE_HASH:
17821  if (!(node = node->nd_head)) break;
17822  case NODE_LIST:
17823  do {
17824  if (!is_static_content(node->nd_head)) return 0;
17825  } while ((node = node->nd_next) != 0);
17826  case NODE_LIT:
17827  case NODE_STR:
17828  case NODE_NIL:
17829  case NODE_TRUE:
17830  case NODE_FALSE:
17831  case NODE_ZLIST:
17832  break;
17833  default:
17834  return 0;
17835  }
17836  return 1;
17837 }
17838 
17839 static int
17840 assign_in_cond(struct parser_params *p, NODE *node)
17841 {
17842  switch (nd_type(node)) {
17843  case NODE_MASGN:
17844  case NODE_LASGN:
17845  case NODE_DASGN:
17846  case NODE_DASGN_CURR:
17847  case NODE_GASGN:
17848  case NODE_IASGN:
17849  break;
17850 
17851  default:
17852  return 0;
17853  }
17854 
17855  if (!node->nd_value) return 1;
17856  if (is_static_content(node->nd_value)) {
17857  /* reports always */
17858  parser_warn(p, node->nd_value, "found `= literal' in conditional, should be ==");
17859  }
17860  return 1;
17861 }
17862 
17867 };
17868 
17869 #define SWITCH_BY_COND_TYPE(t, w, arg) \
17870  switch (t) { \
17871  case COND_IN_OP: break; \
17872  case COND_IN_COND: rb_##w##0(arg "literal in condition"); break; \
17873  case COND_IN_FF: rb_##w##0(arg "literal in flip-flop"); break; \
17874  }
17875 
17876 static NODE *cond0(struct parser_params*,NODE*,enum cond_type,const YYLTYPE*);
17877 
17878 static NODE*
17879 range_op(struct parser_params *p, NODE *node, const YYLTYPE *loc)
17880 {
17881  enum node_type type;
17882 
17883  if (node == 0) return 0;
17884 
17885  type = nd_type(node);
17886  value_expr(node);
17887  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
17888  if (!e_option_supplied(p)) parser_warn(p, node, "integer literal in flip-flop");
17889  return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."), loc), loc), loc);
17890  }
17891  return cond0(p, node, COND_IN_FF, loc);
17892 }
17893 
17894 static NODE*
17895 cond0(struct parser_params *p, NODE *node, enum cond_type type, const YYLTYPE *loc)
17896 {
17897  if (node == 0) return 0;
17898  if (!(node = nd_once_body(node))) return 0;
17899  assign_in_cond(p, node);
17900 
17901  switch (nd_type(node)) {
17902  case NODE_DSTR:
17903  case NODE_EVSTR:
17904  case NODE_STR:
17905  SWITCH_BY_COND_TYPE(type, warn, "string ")
17906  break;
17907 
17908  case NODE_DREGX:
17909  if (!e_option_supplied(p)) SWITCH_BY_COND_TYPE(type, warning, "regex ")
17910 
17911  return NEW_MATCH2(node, NEW_GVAR(idLASTLINE, loc), loc);
17912 
17913  case NODE_AND:
17914  case NODE_OR:
17915  node->nd_1st = cond0(p, node->nd_1st, COND_IN_COND, loc);
17916  node->nd_2nd = cond0(p, node->nd_2nd, COND_IN_COND, loc);
17917  break;
17918 
17919  case NODE_DOT2:
17920  case NODE_DOT3:
17921  node->nd_beg = range_op(p, node->nd_beg, loc);
17922  node->nd_end = range_op(p, node->nd_end, loc);
17923  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
17924  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
17925  break;
17926 
17927  case NODE_DSYM:
17928  SWITCH_BY_COND_TYPE(type, warning, "string ")
17929  break;
17930 
17931  case NODE_LIT:
17932  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
17933  if (!e_option_supplied(p)) SWITCH_BY_COND_TYPE(type, warn, "regex ")
17934  nd_set_type(node, NODE_MATCH);
17935  }
17936  else if (node->nd_lit == Qtrue ||
17937  node->nd_lit == Qfalse) {
17938  /* booleans are OK, e.g., while true */
17939  }
17940  else {
17941  SWITCH_BY_COND_TYPE(type, warning, "")
17942  }
17943  default:
17944  break;
17945  }
17946  return node;
17947 }
17948 
17949 static NODE*
17950 cond(struct parser_params *p, NODE *node, const YYLTYPE *loc)
17951 {
17952  if (node == 0) return 0;
17953  return cond0(p, node, COND_IN_COND, loc);
17954 }
17955 
17956 static NODE*
17957 method_cond(struct parser_params *p, NODE *node, const YYLTYPE *loc)
17958 {
17959  if (node == 0) return 0;
17960  return cond0(p, node, COND_IN_OP, loc);
17961 }
17962 
17963 static NODE*
17964 new_if(struct parser_params *p, NODE *cc, NODE *left, NODE *right, const YYLTYPE *loc)
17965 {
17966  if (!cc) return right;
17967  cc = cond0(p, cc, COND_IN_COND, loc);
17968  return newline_node(NEW_IF(cc, left, right, loc));
17969 }
17970 
17971 static NODE*
17972 new_unless(struct parser_params *p, NODE *cc, NODE *left, NODE *right, const YYLTYPE *loc)
17973 {
17974  if (!cc) return right;
17975  cc = cond0(p, cc, COND_IN_COND, loc);
17976  return newline_node(NEW_UNLESS(cc, left, right, loc));
17977 }
17978 
17979 static NODE*
17980 logop(struct parser_params *p, ID id, NODE *left, NODE *right,
17981  const YYLTYPE *op_loc, const YYLTYPE *loc)
17982 {
17983  enum node_type type = id == idAND || id == idANDOP ? NODE_AND : NODE_OR;
17984  NODE *op;
17985  value_expr(left);
17986  if (left && (enum node_type)nd_type(left) == type) {
17987  NODE *node = left, *second;
17988  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
17989  node = second;
17990  }
17991  node->nd_2nd = NEW_NODE(type, second, right, 0, loc);
17992  nd_set_line(node->nd_2nd, op_loc->beg_pos.lineno);
17993  left->nd_loc.end_pos = loc->end_pos;
17994  return left;
17995  }
17996  op = NEW_NODE(type, left, right, 0, loc);
17997  nd_set_line(op, op_loc->beg_pos.lineno);
17998  return op;
17999 }
18000 
18001 static void
18002 no_blockarg(struct parser_params *p, NODE *node)
18003 {
18004  if (node && nd_type(node) == NODE_BLOCK_PASS) {
18005  compile_error(p, "block argument should not be given");
18006  }
18007 }
18008 
18009 static NODE *
18010 ret_args(struct parser_params *p, NODE *node)
18011 {
18012  if (node) {
18013  no_blockarg(p, node);
18014  if (nd_type(node) == NODE_LIST) {
18015  if (node->nd_next == 0) {
18016  node = node->nd_head;
18017  }
18018  else {
18019  nd_set_type(node, NODE_VALUES);
18020  }
18021  }
18022  }
18023  return node;
18024 }
18025 
18026 static NODE *
18027 new_yield(struct parser_params *p, NODE *node, const YYLTYPE *loc)
18028 {
18029  if (node) no_blockarg(p, node);
18030 
18031  return NEW_YIELD(node, loc);
18032 }
18033 
18034 static VALUE
18035 negate_lit(struct parser_params *p, VALUE lit)
18036 {
18037  if (FIXNUM_P(lit)) {
18038  return LONG2FIX(-FIX2LONG(lit));
18039  }
18040  if (SPECIAL_CONST_P(lit)) {
18041 #if USE_FLONUM
18042  if (FLONUM_P(lit)) {
18043  return DBL2NUM(-RFLOAT_VALUE(lit));
18044  }
18045 #endif
18046  goto unknown;
18047  }
18048  switch (BUILTIN_TYPE(lit)) {
18049  case T_BIGNUM:
18050  BIGNUM_NEGATE(lit);
18051  lit = rb_big_norm(lit);
18052  break;
18053  case T_RATIONAL:
18054  RRATIONAL_SET_NUM(lit, negate_lit(p, RRATIONAL(lit)->num));
18055  break;
18056  case T_COMPLEX:
18057  RCOMPLEX_SET_REAL(lit, negate_lit(p, RCOMPLEX(lit)->real));
18058  RCOMPLEX_SET_IMAG(lit, negate_lit(p, RCOMPLEX(lit)->imag));
18059  break;
18060  case T_FLOAT:
18061  RFLOAT(lit)->float_value = -RFLOAT_VALUE(lit);
18062  break;
18063  unknown:
18064  default:
18065  rb_parser_fatal(p, "unknown literal type (%s) passed to negate_lit",
18066  rb_builtin_class_name(lit));
18067  break;
18068  }
18069  return lit;
18070 }
18071 
18072 static NODE *
18073 arg_blk_pass(NODE *node1, NODE *node2)
18074 {
18075  if (node2) {
18076  if (!node1) return node2;
18077  node2->nd_head = node1;
18078  nd_set_first_lineno(node2, nd_first_lineno(node1));
18079  nd_set_first_column(node2, nd_first_column(node1));
18080  return node2;
18081  }
18082  return node1;
18083 }
18084 
18085 static bool
18086 args_info_empty_p(struct rb_args_info *args)
18087 {
18088  if (args->pre_args_num) return false;
18089  if (args->post_args_num) return false;
18090  if (args->rest_arg) return false;
18091  if (args->opt_args) return false;
18092  if (args->block_arg) return false;
18093  if (args->kw_args) return false;
18094  if (args->kw_rest_arg) return false;
18095  return true;
18096 }
18097 
18098 static NODE*
18099 new_args(struct parser_params *p, NODE *pre_args, NODE *opt_args, ID rest_arg, NODE *post_args, NODE *tail, const YYLTYPE *loc)
18100 {
18101  int saved_line = p->ruby_sourceline;
18102  struct rb_args_info *args = tail->nd_ainfo;
18103 
18104  args->pre_args_num = pre_args ? rb_long2int(pre_args->nd_plen) : 0;
18105  args->pre_init = pre_args ? pre_args->nd_next : 0;
18106 
18107  args->post_args_num = post_args ? rb_long2int(post_args->nd_plen) : 0;
18108  args->post_init = post_args ? post_args->nd_next : 0;
18109  args->first_post_arg = post_args ? post_args->nd_pid : 0;
18110 
18111  args->rest_arg = rest_arg;
18112 
18113  args->opt_args = opt_args;
18114 
18115  args->ruby2_keywords = rest_arg == idFWD_REST;
18116 
18117  p->ruby_sourceline = saved_line;
18118  nd_set_loc(tail, loc);
18119 
18120  return tail;
18121 }
18122 
18123 static NODE*
18124 new_args_tail(struct parser_params *p, NODE *kw_args, ID kw_rest_arg, ID block, const YYLTYPE *loc)
18125 {
18126  int saved_line = p->ruby_sourceline;
18127  NODE *node;
18129  struct rb_args_info *args = ZALLOC(struct rb_args_info);
18130  rb_imemo_tmpbuf_set_ptr(tmpbuf, args);
18131  args->imemo = tmpbuf;
18132  node = NEW_NODE(NODE_ARGS, 0, 0, args, &NULL_LOC);
18133  RB_OBJ_WRITTEN(p->ast, Qnil, tmpbuf);
18134  if (p->error_p) return node;
18135 
18136  args->block_arg = block;
18137  args->kw_args = kw_args;
18138 
18139  if (kw_args) {
18140  /*
18141  * def foo(k1: 1, kr1:, k2: 2, **krest, &b)
18142  * variable order: k1, kr1, k2, &b, internal_id, krest
18143  * #=> <reorder>
18144  * variable order: kr1, k1, k2, internal_id, krest, &b
18145  */
18146  ID kw_bits = internal_id(p), *required_kw_vars, *kw_vars;
18147  struct vtable *vtargs = p->lvtbl->args;
18148  NODE *kwn = kw_args;
18149 
18150  vtable_pop(vtargs, !!block + !!kw_rest_arg);
18151  required_kw_vars = kw_vars = &vtargs->tbl[vtargs->pos];
18152  while (kwn) {
18153  if (!NODE_REQUIRED_KEYWORD_P(kwn->nd_body))
18154  --kw_vars;
18155  --required_kw_vars;
18156  kwn = kwn->nd_next;
18157  }
18158 
18159  for (kwn = kw_args; kwn; kwn = kwn->nd_next) {
18160  ID vid = kwn->nd_body->nd_vid;
18161  if (NODE_REQUIRED_KEYWORD_P(kwn->nd_body)) {
18162  *required_kw_vars++ = vid;
18163  }
18164  else {
18165  *kw_vars++ = vid;
18166  }
18167  }
18168 
18169  arg_var(p, kw_bits);
18170  if (kw_rest_arg) arg_var(p, kw_rest_arg);
18171  if (block) arg_var(p, block);
18172 
18173  args->kw_rest_arg = NEW_DVAR(kw_rest_arg, loc);
18174  args->kw_rest_arg->nd_cflag = kw_bits;
18175  }
18176  else if (kw_rest_arg == idNil) {
18177  args->no_kwarg = 1;
18178  }
18179  else if (kw_rest_arg) {
18180  args->kw_rest_arg = NEW_DVAR(kw_rest_arg, loc);
18181  }
18182 
18183  p->ruby_sourceline = saved_line;
18184  return node;
18185 }
18186 
18187 static NODE *
18188 args_with_numbered(struct parser_params *p, NODE *args, int max_numparam)
18189 {
18190  if (max_numparam > NO_PARAM) {
18191  if (!args) args = new_args_tail(p, 0, 0, 0, 0);
18192  args->nd_ainfo->pre_args_num = max_numparam;
18193  }
18194  return args;
18195 }
18196 
18197 static NODE*
18198 new_array_pattern(struct parser_params *p, NODE *constant, NODE *pre_arg, NODE *aryptn, const YYLTYPE *loc)
18199 {
18200  struct rb_ary_pattern_info *apinfo = aryptn->nd_apinfo;
18201 
18202  aryptn->nd_pconst = constant;
18203 
18204  if (pre_arg) {
18205  NODE *pre_args = NEW_LIST(pre_arg, loc);
18206  if (apinfo->pre_args) {
18207  apinfo->pre_args = list_concat(pre_args, apinfo->pre_args);
18208  }
18209  else {
18210  apinfo->pre_args = pre_args;
18211  }
18212  }
18213  return aryptn;
18214 }
18215 
18216 static NODE*
18217 new_array_pattern_tail(struct parser_params *p, NODE *pre_args, int has_rest, ID rest_arg, NODE *post_args, const YYLTYPE *loc)
18218 {
18219  int saved_line = p->ruby_sourceline;
18220  NODE *node;
18222  struct rb_ary_pattern_info *apinfo = ZALLOC(struct rb_ary_pattern_info);
18223  rb_imemo_tmpbuf_set_ptr(tmpbuf, apinfo);
18224  node = NEW_NODE(NODE_ARYPTN, 0, 0, apinfo, loc);
18225  apinfo->imemo = tmpbuf;
18226  RB_OBJ_WRITTEN(p->ast, Qnil, tmpbuf);
18227 
18228  apinfo->pre_args = pre_args;
18229 
18230  if (has_rest) {
18231  if (rest_arg) {
18232  apinfo->rest_arg = assignable(p, rest_arg, 0, loc);
18233  }
18234  else {
18236  }
18237  }
18238  else {
18239  apinfo->rest_arg = NULL;
18240  }
18241 
18242  apinfo->post_args = post_args;
18243 
18244  p->ruby_sourceline = saved_line;
18245  return node;
18246 }
18247 
18248 static NODE*
18249 new_hash_pattern(struct parser_params *p, NODE *constant, NODE *hshptn, const YYLTYPE *loc)
18250 {
18251  hshptn->nd_pconst = constant;
18252  return hshptn;
18253 }
18254 
18255 static NODE*
18256 new_hash_pattern_tail(struct parser_params *p, NODE *kw_args, ID kw_rest_arg, const YYLTYPE *loc)
18257 {
18258  int saved_line = p->ruby_sourceline;
18259  NODE *node, *kw_rest_arg_node;
18260 
18261  if (kw_rest_arg == idNil) {
18262  kw_rest_arg_node = NODE_SPECIAL_NO_REST_KEYWORD;
18263  }
18264  else if (kw_rest_arg) {
18265  kw_rest_arg_node = assignable(p, kw_rest_arg, 0, loc);
18266  }
18267  else {
18268  kw_rest_arg_node = NULL;
18269  }
18270 
18271  node = NEW_NODE(NODE_HSHPTN, 0, kw_args, kw_rest_arg_node, loc);
18272 
18273  p->ruby_sourceline = saved_line;
18274  return node;
18275 }
18276 
18277 static NODE *
18278 new_case3(struct parser_params *p, NODE *val, NODE *pat, const YYLTYPE *loc)
18279 {
18280  NODE *node = NEW_CASE3(val, pat, loc);
18281 
18283  rb_warn0L(nd_line(node), "Pattern matching is experimental, and the behavior may change in future versions of Ruby!");
18284  return node;
18285 }
18286 
18287 static NODE*
18288 dsym_node(struct parser_params *p, NODE *node, const YYLTYPE *loc)
18289 {
18290  VALUE lit;
18291 
18292  if (!node) {
18293  return NEW_LIT(ID2SYM(idNULL), loc);
18294  }
18295 
18296  switch (nd_type(node)) {
18297  case NODE_DSTR:
18298  nd_set_type(node, NODE_DSYM);
18299  nd_set_loc(node, loc);
18300  break;
18301  case NODE_STR:
18302  lit = node->nd_lit;
18303  RB_OBJ_WRITTEN(p->ast, Qnil, node->nd_lit = ID2SYM(rb_intern_str(lit)));
18304  nd_set_type(node, NODE_LIT);
18305  nd_set_loc(node, loc);
18306  break;
18307  default:
18308  node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node, loc), loc);
18309  break;
18310  }
18311  return node;
18312 }
18313 
18314 static int
18315 append_literal_keys(st_data_t k, st_data_t v, st_data_t h)
18316 {
18317  NODE *node = (NODE *)v;
18318  NODE **result = (NODE **)h;
18319  node->nd_alen = 2;
18320  node->nd_next->nd_end = node->nd_next;
18321  node->nd_next->nd_next = 0;
18322  if (*result)
18323  list_concat(*result, node);
18324  else
18325  *result = node;
18326  return ST_CONTINUE;
18327 }
18328 
18329 static NODE *
18330 remove_duplicate_keys(struct parser_params *p, NODE *hash)
18331 {
18332  st_table *literal_keys = st_init_numtable_with_size(hash->nd_alen / 2);
18333  NODE *result = 0;
18334  rb_code_location_t loc = hash->nd_loc;
18335  while (hash && hash->nd_head && hash->nd_next) {
18336  NODE *head = hash->nd_head;
18337  NODE *value = hash->nd_next;
18338  NODE *next = value->nd_next;
18339  VALUE key = (VALUE)head;
18340  st_data_t data;
18341  if (nd_type(head) == NODE_LIT &&
18342  st_lookup(literal_keys, (key = head->nd_lit), &data)) {
18344  "key %+"PRIsVALUE" is duplicated and overwritten on line %d",
18345  head->nd_lit, nd_line(head));
18346  head = ((NODE *)data)->nd_next;
18347  head->nd_head = block_append(p, head->nd_head, value->nd_head);
18348  }
18349  else {
18350  st_insert(literal_keys, (st_data_t)key, (st_data_t)hash);
18351  }
18352  hash = next;
18353  }
18354  st_foreach(literal_keys, append_literal_keys, (st_data_t)&result);
18355  st_free_table(literal_keys);
18356  if (hash) {
18357  if (!result) result = hash;
18358  else list_concat(result, hash);
18359  }
18360  result->nd_loc = loc;
18361  return result;
18362 }
18363 
18364 static NODE *
18365 new_hash(struct parser_params *p, NODE *hash, const YYLTYPE *loc)
18366 {
18367  if (hash) hash = remove_duplicate_keys(p, hash);
18368  return NEW_HASH(hash, loc);
18369 }
18370 #endif
18371 
18372 static void
18373 error_duplicate_pattern_variable(struct parser_params *p, ID id, const YYLTYPE *loc)
18374 {
18375  if (is_private_local_id(id)) {
18376  return;
18377  }
18378  if (st_is_member(p->pvtbl, id)) {
18379  yyerror1(loc, "duplicated variable name");
18380  }
18381  else {
18382  st_insert(p->pvtbl, (st_data_t)id, 0);
18383  }
18384 }
18385 
18386 static void
18387 error_duplicate_pattern_key(struct parser_params *p, VALUE key, const YYLTYPE *loc)
18388 {
18389  if (!p->pktbl) {
18390  p->pktbl = st_init_numtable();
18391  }
18392  else if (st_is_member(p->pktbl, key)) {
18393  yyerror1(loc, "duplicated key name");
18394  return;
18395  }
18396  st_insert(p->pktbl, (st_data_t)key, 0);
18397 }
18398 
18399 #ifndef RIPPER
18400 static NODE *
18401 new_unique_key_hash(struct parser_params *p, NODE *hash, const YYLTYPE *loc)
18402 {
18403  return NEW_HASH(hash, loc);
18404 }
18405 #endif /* !RIPPER */
18406 
18407 #ifndef RIPPER
18408 static NODE *
18409 new_op_assign(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *loc)
18410 {
18411  NODE *asgn;
18412 
18413  if (lhs) {
18414  ID vid = lhs->nd_vid;
18415  YYLTYPE lhs_loc = lhs->nd_loc;
18416  if (op == tOROP) {
18417  lhs->nd_value = rhs;
18418  nd_set_loc(lhs, loc);
18419  asgn = NEW_OP_ASGN_OR(gettable(p, vid, &lhs_loc), lhs, loc);
18420  if (is_notop_id(vid)) {
18421  switch (id_type(vid)) {
18422  case ID_GLOBAL:
18423  case ID_INSTANCE:
18424  case ID_CLASS:
18425  asgn->nd_aid = vid;
18426  }
18427  }
18428  }
18429  else if (op == tANDOP) {
18430  lhs->nd_value = rhs;
18431  nd_set_loc(lhs, loc);
18432  asgn = NEW_OP_ASGN_AND(gettable(p, vid, &lhs_loc), lhs, loc);
18433  }
18434  else {
18435  asgn = lhs;
18436  asgn->nd_value = NEW_CALL(gettable(p, vid, &lhs_loc), op, NEW_LIST(rhs, &rhs->nd_loc), loc);
18437  nd_set_loc(asgn, loc);
18438  }
18439  }
18440  else {
18441  asgn = NEW_BEGIN(0, loc);
18442  }
18443  return asgn;
18444 }
18445 
18446 static NODE *
18447 new_ary_op_assign(struct parser_params *p, NODE *ary,
18448  NODE *args, ID op, NODE *rhs, const YYLTYPE *args_loc, const YYLTYPE *loc)
18449 {
18450  NODE *asgn;
18451 
18452  args = make_list(args, args_loc);
18453  if (nd_type(args) == NODE_BLOCK_PASS) {
18454  args = NEW_ARGSCAT(args, rhs, loc);
18455  }
18456  else {
18457  args = arg_concat(p, args, rhs, loc);
18458  }
18459  asgn = NEW_OP_ASGN1(ary, op, args, loc);
18460  fixpos(asgn, ary);
18461  return asgn;
18462 }
18463 
18464 static NODE *
18465 new_attr_op_assign(struct parser_params *p, NODE *lhs,
18466  ID atype, ID attr, ID op, NODE *rhs, const YYLTYPE *loc)
18467 {
18468  NODE *asgn;
18469 
18470  asgn = NEW_OP_ASGN2(lhs, CALL_Q_P(atype), attr, op, rhs, loc);
18471  fixpos(asgn, lhs);
18472  return asgn;
18473 }
18474 
18475 static NODE *
18476 new_const_op_assign(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *loc)
18477 {
18478  NODE *asgn;
18479 
18480  if (lhs) {
18481  asgn = NEW_OP_CDECL(lhs, op, rhs, loc);
18482  }
18483  else {
18484  asgn = NEW_BEGIN(0, loc);
18485  }
18486  fixpos(asgn, lhs);
18487  return asgn;
18488 }
18489 
18490 static NODE *
18491 const_decl(struct parser_params *p, NODE *path, const YYLTYPE *loc)
18492 {
18493  if (p->in_def) {
18494  yyerror1(loc, "dynamic constant assignment");
18495  }
18496  return NEW_CDECL(0, 0, (path), loc);
18497 }
18498 #else
18499 static VALUE
18500 const_decl(struct parser_params *p, VALUE path)
18501 {
18502  if (p->in_def) {
18503  path = dispatch1(assign_error, path);
18504  ripper_error(p);
18505  }
18506  return path;
18507 }
18508 
18509 static VALUE
18510 assign_error(struct parser_params *p, VALUE a)
18511 {
18512  a = dispatch1(assign_error, a);
18513  ripper_error(p);
18514  return a;
18515 }
18516 
18517 static VALUE
18518 var_field(struct parser_params *p, VALUE a)
18519 {
18520  return ripper_new_yylval(p, get_id(a), dispatch1(var_field, a), 0);
18521 }
18522 #endif
18523 
18524 #ifndef RIPPER
18525 static NODE *
18526 new_bodystmt(struct parser_params *p, NODE *head, NODE *rescue, NODE *rescue_else, NODE *ensure, const YYLTYPE *loc)
18527 {
18528  NODE *result = head;
18529  if (rescue) {
18530  NODE *tmp = rescue_else ? rescue_else : rescue;
18531  YYLTYPE rescue_loc = code_loc_gen(&head->nd_loc, &tmp->nd_loc);
18532 
18533  result = NEW_RESCUE(head, rescue, rescue_else, &rescue_loc);
18534  nd_set_line(result, rescue->nd_loc.beg_pos.lineno);
18535  }
18536  else if (rescue_else) {
18537  result = block_append(p, result, rescue_else);
18538  }
18539  if (ensure) {
18540  result = NEW_ENSURE(result, ensure, loc);
18541  }
18542  fixpos(result, head);
18543  return result;
18544 }
18545 #endif
18546 
18547 static void
18548 warn_unused_var(struct parser_params *p, struct local_vars *local)
18549 {
18550  int cnt;
18551 
18552  if (!local->used) return;
18553  cnt = local->used->pos;
18554  if (cnt != local->vars->pos) {
18555  rb_parser_fatal(p, "local->used->pos != local->vars->pos");
18556  }
18557 #ifndef RIPPER
18558  ID *v = local->vars->tbl;
18559  ID *u = local->used->tbl;
18560  for (int i = 0; i < cnt; ++i) {
18561  if (!v[i] || (u[i] & LVAR_USED)) continue;
18562  if (is_private_local_id(v[i])) continue;
18563  rb_warn1L((int)u[i], "assigned but unused variable - %"PRIsWARN, rb_id2str(v[i]));
18564  }
18565 #endif
18566 }
18567 
18568 static void
18569 local_push(struct parser_params *p, int toplevel_scope)
18570 {
18571  struct local_vars *local;
18572  int inherits_dvars = toplevel_scope && compile_for_eval;
18573  int warn_unused_vars = RTEST(ruby_verbose);
18574 
18575  local = ALLOC(struct local_vars);
18576  local->prev = p->lvtbl;
18577  local->args = vtable_alloc(0);
18578  local->vars = vtable_alloc(inherits_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
18579 #ifndef RIPPER
18580  if (toplevel_scope && compile_for_eval) warn_unused_vars = 0;
18581  if (toplevel_scope && e_option_supplied(p)) warn_unused_vars = 0;
18582  local->numparam.outer = 0;
18583  local->numparam.inner = 0;
18584  local->numparam.current = 0;
18585 #endif
18586  local->used = warn_unused_vars ? vtable_alloc(0) : 0;
18587 
18588 # if WARN_PAST_SCOPE
18589  local->past = 0;
18590 # endif
18591  CMDARG_PUSH(0);
18592  COND_PUSH(0);
18593  p->lvtbl = local;
18594 }
18595 
18596 static void
18597 local_pop(struct parser_params *p)
18598 {
18599  struct local_vars *local = p->lvtbl->prev;
18600  if (p->lvtbl->used) {
18601  warn_unused_var(p, p->lvtbl);
18602  vtable_free(p->lvtbl->used);
18603  }
18604 # if WARN_PAST_SCOPE
18605  while (p->lvtbl->past) {
18606  struct vtable *past = p->lvtbl->past;
18607  p->lvtbl->past = past->prev;
18608  vtable_free(past);
18609  }
18610 # endif
18611  vtable_free(p->lvtbl->args);
18612  vtable_free(p->lvtbl->vars);
18613  CMDARG_POP();
18614  COND_POP();
18615  ruby_sized_xfree(p->lvtbl, sizeof(*p->lvtbl));
18616  p->lvtbl = local;
18617 }
18618 
18619 #ifndef RIPPER
18620 static ID*
18621 local_tbl(struct parser_params *p)
18622 {
18623  int cnt_args = vtable_size(p->lvtbl->args);
18624  int cnt_vars = vtable_size(p->lvtbl->vars);
18625  int cnt = cnt_args + cnt_vars;
18626  int i, j;
18627  ID *buf;
18628  VALUE tbl = 0;
18629 
18630  if (cnt <= 0) return 0;
18632  buf = ALLOC_N(ID, cnt + 2);
18633  rb_imemo_tmpbuf_set_ptr(tbl, buf);
18634  MEMCPY(buf+1, p->lvtbl->args->tbl, ID, cnt_args);
18635  /* remove IDs duplicated to warn shadowing */
18636  for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
18637  ID id = p->lvtbl->vars->tbl[i];
18638  if (!vtable_included(p->lvtbl->args, id)) {
18639  buf[j++] = id;
18640  }
18641  }
18642  if (--j < cnt) {
18643  REALLOC_N(buf, ID, (cnt = j) + 2);
18644  rb_imemo_tmpbuf_set_ptr(tbl, buf);
18645  }
18646  buf[0] = cnt;
18647  buf[cnt + 1] = (ID)tbl;
18648  RB_OBJ_WRITTEN(p->ast, Qnil, tbl);
18649 
18650  return buf;
18651 }
18652 
18653 static NODE*
18654 node_newnode_with_locals(struct parser_params *p, enum node_type type, VALUE a1, VALUE a2, const rb_code_location_t *loc)
18655 {
18656  ID *a0;
18657  NODE *n;
18658 
18659  a0 = local_tbl(p);
18660  n = NEW_NODE(type, a0, a1, a2, loc);
18661  return n;
18662 }
18663 
18664 #endif
18665 
18666 static void
18667 numparam_name(struct parser_params *p, ID id)
18668 {
18669  if (!NUMPARAM_ID_P(id)) return;
18670  rb_warn1("`_%d' is reserved for numbered parameter; consider another name",
18671  WARN_I(NUMPARAM_ID_TO_IDX(id)));
18672 }
18673 
18674 static void
18675 arg_var(struct parser_params *p, ID id)
18676 {
18677  numparam_name(p, id);
18678  vtable_add(p->lvtbl->args, id);
18679 }
18680 
18681 static void
18682 local_var(struct parser_params *p, ID id)
18683 {
18684  numparam_name(p, id);
18685  vtable_add(p->lvtbl->vars, id);
18686  if (p->lvtbl->used) {
18688  }
18689 }
18690 
18691 static int
18692 local_id_ref(struct parser_params *p, ID id, ID **vidrefp)
18693 {
18694  struct vtable *vars, *args, *used;
18695 
18696  vars = p->lvtbl->vars;
18697  args = p->lvtbl->args;
18698  used = p->lvtbl->used;
18699 
18700  while (vars && !DVARS_TERMINAL_P(vars->prev)) {
18701  vars = vars->prev;
18702  args = args->prev;
18703  if (used) used = used->prev;
18704  }
18705 
18706  if (vars && vars->prev == DVARS_INHERIT) {
18707  return rb_local_defined(id, p->parent_iseq);
18708  }
18709  else if (vtable_included(args, id)) {
18710  return 1;
18711  }
18712  else {
18713  int i = vtable_included(vars, id);
18714  if (i && used && vidrefp) *vidrefp = &used->tbl[i-1];
18715  return i != 0;
18716  }
18717 }
18718 
18719 static int
18720 local_id(struct parser_params *p, ID id)
18721 {
18722  return local_id_ref(p, id, NULL);
18723 }
18724 
18725 static NODE *
18726 numparam_push(struct parser_params *p)
18727 {
18728 #ifndef RIPPER
18729  struct local_vars *local = p->lvtbl;
18730  NODE *inner = local->numparam.inner;
18731  if (!local->numparam.outer) {
18732  local->numparam.outer = local->numparam.current;
18733  }
18734  local->numparam.inner = 0;
18735  local->numparam.current = 0;
18736  return inner;
18737 #else
18738  return 0;
18739 #endif
18740 }
18741 
18742 static void
18743 numparam_pop(struct parser_params *p, NODE *prev_inner)
18744 {
18745 #ifndef RIPPER
18746  struct local_vars *local = p->lvtbl;
18747  if (prev_inner) {
18748  /* prefer first one */
18749  local->numparam.inner = prev_inner;
18750  }
18751  else if (local->numparam.current) {
18752  /* current and inner are exclusive */
18753  local->numparam.inner = local->numparam.current;
18754  }
18755  if (p->max_numparam > NO_PARAM) {
18756  /* current and outer are exclusive */
18757  local->numparam.current = local->numparam.outer;
18758  local->numparam.outer = 0;
18759  }
18760  else {
18761  /* no numbered parameter */
18762  local->numparam.current = 0;
18763  }
18764 #endif
18765 }
18766 
18767 static const struct vtable *
18768 dyna_push(struct parser_params *p)
18769 {
18770  p->lvtbl->args = vtable_alloc(p->lvtbl->args);
18771  p->lvtbl->vars = vtable_alloc(p->lvtbl->vars);
18772  if (p->lvtbl->used) {
18773  p->lvtbl->used = vtable_alloc(p->lvtbl->used);
18774  }
18775  return p->lvtbl->args;
18776 }
18777 
18778 static void
18779 dyna_pop_vtable(struct parser_params *p, struct vtable **vtblp)
18780 {
18781  struct vtable *tmp = *vtblp;
18782  *vtblp = tmp->prev;
18783 # if WARN_PAST_SCOPE
18784  if (p->past_scope_enabled) {
18785  tmp->prev = p->lvtbl->past;
18786  p->lvtbl->past = tmp;
18787  return;
18788  }
18789 # endif
18790  vtable_free(tmp);
18791 }
18792 
18793 static void
18794 dyna_pop_1(struct parser_params *p)
18795 {
18796  struct vtable *tmp;
18797 
18798  if ((tmp = p->lvtbl->used) != 0) {
18799  warn_unused_var(p, p->lvtbl);
18800  p->lvtbl->used = p->lvtbl->used->prev;
18801  vtable_free(tmp);
18802  }
18803  dyna_pop_vtable(p, &p->lvtbl->args);
18804  dyna_pop_vtable(p, &p->lvtbl->vars);
18805 }
18806 
18807 static void
18808 dyna_pop(struct parser_params *p, const struct vtable *lvargs)
18809 {
18810  while (p->lvtbl->args != lvargs) {
18811  dyna_pop_1(p);
18812  if (!p->lvtbl->args) {
18813  struct local_vars *local = p->lvtbl->prev;
18814  ruby_sized_xfree(p->lvtbl, sizeof(*p->lvtbl));
18815  p->lvtbl = local;
18816  }
18817  }
18818  dyna_pop_1(p);
18819 }
18820 
18821 static int
18822 dyna_in_block(struct parser_params *p)
18823 {
18824  return !DVARS_TERMINAL_P(p->lvtbl->vars) && p->lvtbl->vars->prev != DVARS_TOPSCOPE;
18825 }
18826 
18827 static int
18828 dvar_defined_ref(struct parser_params *p, ID id, ID **vidrefp)
18829 {
18830  struct vtable *vars, *args, *used;
18831  int i;
18832 
18833  args = p->lvtbl->args;
18834  vars = p->lvtbl->vars;
18835  used = p->lvtbl->used;
18836 
18837  while (!DVARS_TERMINAL_P(vars)) {
18838  if (vtable_included(args, id)) {
18839  return 1;
18840  }
18841  if ((i = vtable_included(vars, id)) != 0) {
18842  if (used && vidrefp) *vidrefp = &used->tbl[i-1];
18843  return 1;
18844  }
18845  args = args->prev;
18846  vars = vars->prev;
18847  if (!vidrefp) used = 0;
18848  if (used) used = used->prev;
18849  }
18850 
18851  if (vars == DVARS_INHERIT) {
18852  return rb_dvar_defined(id, p->parent_iseq);
18853  }
18854 
18855  return 0;
18856 }
18857 
18858 static int
18859 dvar_defined(struct parser_params *p, ID id)
18860 {
18861  return dvar_defined_ref(p, id, NULL);
18862 }
18863 
18864 static int
18865 dvar_curr(struct parser_params *p, ID id)
18866 {
18867  return (vtable_included(p->lvtbl->args, id) ||
18868  vtable_included(p->lvtbl->vars, id));
18869 }
18870 
18871 static void
18872 reg_fragment_enc_error(struct parser_params* p, VALUE str, int c)
18873 {
18874  compile_error(p,
18875  "regexp encoding option '%c' differs from source encoding '%s'",
18876  c, rb_enc_name(rb_enc_get(str)));
18877 }
18878 
18879 #ifndef RIPPER
18880 int
18882 {
18883  int c = RE_OPTION_ENCODING_IDX(options);
18884 
18885  if (c) {
18886  int opt, idx;
18887  rb_char_to_option_kcode(c, &opt, &idx);
18888  if (idx != ENCODING_GET(str) &&
18890  goto error;
18891  }
18892  ENCODING_SET(str, idx);
18893  }
18894  else if (RE_OPTION_ENCODING_NONE(options)) {
18895  if (!ENCODING_IS_ASCII8BIT(str) &&
18897  c = 'n';
18898  goto error;
18899  }
18901  }
18902  else if (p->enc == rb_usascii_encoding()) {
18904  /* raise in re.c */
18906  }
18907  else {
18909  }
18910  }
18911  return 0;
18912 
18913  error:
18914  return c;
18915 }
18916 
18917 static void
18918 reg_fragment_setenc(struct parser_params* p, VALUE str, int options)
18919 {
18920  int c = rb_reg_fragment_setenc(p, str, options);
18921  if (c) reg_fragment_enc_error(p, str, c);
18922 }
18923 
18924 static int
18925 reg_fragment_check(struct parser_params* p, VALUE str, int options)
18926 {
18927  VALUE err;
18928  reg_fragment_setenc(p, str, options);
18930  if (err != Qnil) {
18932  compile_error(p, "%"PRIsVALUE, err);
18933  return 0;
18934  }
18935  return 1;
18936 }
18937 
18938 typedef struct {
18942  const YYLTYPE *loc;
18944 
18945 static int
18946 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
18947  int back_num, int *back_refs, OnigRegex regex, void *arg0)
18948 {
18950  struct parser_params* p = arg->parser;
18951  rb_encoding *enc = arg->enc;
18952  long len = name_end - name;
18953  const char *s = (const char *)name;
18954  ID var;
18955  NODE *node, *succ;
18956 
18957  if (!len) return ST_CONTINUE;
18958  if (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len))
18959  return ST_CONTINUE;
18960  if (rb_enc_symname_type(s, len, enc, (1U<<ID_LOCAL)) != ID_LOCAL)
18961  return ST_CONTINUE;
18962 
18963  var = intern_cstr(s, len, enc);
18964  node = node_assign(p, assignable(p, var, 0, arg->loc), NEW_LIT(ID2SYM(var), arg->loc), arg->loc);
18965  succ = arg->succ_block;
18966  if (!succ) succ = NEW_BEGIN(0, arg->loc);
18967  succ = block_append(p, succ, node);
18968  arg->succ_block = succ;
18969  return ST_CONTINUE;
18970 }
18971 
18972 static NODE *
18973 reg_named_capture_assign(struct parser_params* p, VALUE regexp, const YYLTYPE *loc)
18974 {
18976 
18977  arg.parser = p;
18978  arg.enc = rb_enc_get(regexp);
18979  arg.succ_block = 0;
18980  arg.loc = loc;
18981  onig_foreach_name(RREGEXP_PTR(regexp), reg_named_capture_assign_iter, &arg);
18982 
18983  if (!arg.succ_block) return 0;
18984  return arg.succ_block->nd_next;
18985 }
18986 
18987 static VALUE
18988 parser_reg_compile(struct parser_params* p, VALUE str, int options)
18989 {
18990  reg_fragment_setenc(p, str, options);
18991  return rb_parser_reg_compile(p, str, options);
18992 }
18993 
18994 VALUE
18996 {
18998 }
18999 
19000 static VALUE
19001 reg_compile(struct parser_params* p, VALUE str, int options)
19002 {
19003  VALUE re;
19004  VALUE err;
19005 
19006  err = rb_errinfo();
19007  re = parser_reg_compile(p, str, options);
19008  if (NIL_P(re)) {
19011  compile_error(p, "%"PRIsVALUE, m);
19012  return Qnil;
19013  }
19014  return re;
19015 }
19016 #else
19017 static VALUE
19018 parser_reg_compile(struct parser_params* p, VALUE str, int options, VALUE *errmsg)
19019 {
19020  VALUE err = rb_errinfo();
19021  VALUE re;
19022  str = ripper_is_node_yylval(str) ? RNODE(str)->nd_cval : str;
19023  int c = rb_reg_fragment_setenc(p, str, options);
19024  if (c) reg_fragment_enc_error(p, str, c);
19025  re = rb_parser_reg_compile(p, str, options);
19026  if (NIL_P(re)) {
19027  *errmsg = rb_attr_get(rb_errinfo(), idMesg);
19029  }
19030  return re;
19031 }
19032 #endif
19033 
19034 #ifndef RIPPER
19035 void
19036 rb_parser_set_options(VALUE vparser, int print, int loop, int chomp, int split)
19037 {
19038  struct parser_params *p;
19039  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19040  p->do_print = print;
19041  p->do_loop = loop;
19042  p->do_chomp = chomp;
19043  p->do_split = split;
19044 }
19045 
19046 void
19047 rb_parser_warn_location(VALUE vparser, int warn)
19048 {
19049  struct parser_params *p;
19050  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19051  p->warn_location = warn;
19052 }
19053 
19054 static NODE *
19055 parser_append_options(struct parser_params *p, NODE *node)
19056 {
19057  static const YYLTYPE default_location = {{1, 0}, {1, 0}};
19058  const YYLTYPE *const LOC = &default_location;
19059 
19060  if (p->do_print) {
19061  NODE *print = NEW_FCALL(rb_intern("print"),
19062  NEW_LIST(NEW_GVAR(idLASTLINE, LOC), LOC),
19063  LOC);
19064  node = block_append(p, node, print);
19065  }
19066 
19067  if (p->do_loop) {
19068  if (p->do_split) {
19069  NODE *args = NEW_LIST(NEW_GVAR(rb_intern("$;"), LOC), LOC);
19070  NODE *split = NEW_GASGN(rb_intern("$F"),
19072  rb_intern("split"), args, LOC),
19073  LOC);
19074  node = block_append(p, split, node);
19075  }
19076  if (p->do_chomp) {
19077  NODE *chomp = NEW_CALL(NEW_GVAR(idLASTLINE, LOC),
19078  rb_intern("chomp!"), 0, LOC);
19079  node = block_append(p, chomp, node);
19080  }
19081 
19082  node = NEW_WHILE(NEW_VCALL(idGets, LOC), node, 1, LOC);
19083  }
19084 
19085  return node;
19086 }
19087 
19088 void
19090 {
19091  /* just to suppress unused-function warnings */
19092  (void)nodetype;
19093  (void)nodeline;
19094 }
19095 
19096 static ID
19097 internal_id(struct parser_params *p)
19098 {
19099  const ID max_id = RB_ID_SERIAL_MAX & ~0xffff;
19100  ID id = (ID)vtable_size(p->lvtbl->args) + (ID)vtable_size(p->lvtbl->vars);
19101  id = max_id - id;
19102  return ID_STATIC_SYM | ID_INTERNAL | (id << ID_SCOPE_SHIFT);
19103 }
19104 #endif /* !RIPPER */
19105 
19106 static void
19107 parser_initialize(struct parser_params *p)
19108 {
19109  /* note: we rely on TypedData_Make_Struct to set most fields to 0 */
19110  p->command_start = TRUE;
19112  p->lex.lpar_beg = -1; /* make lambda_beginning_p() == FALSE at first */
19113  p->node_id = 0;
19114 #ifdef RIPPER
19115  p->delayed.token = Qnil;
19116  p->result = Qnil;
19117  p->parsing_thread = Qnil;
19118 #else
19119  p->error_buffer = Qfalse;
19120 #endif
19121  p->debug_buffer = Qnil;
19122  p->debug_output = rb_stdout;
19123  p->enc = rb_utf8_encoding();
19124 }
19125 
19126 #ifdef RIPPER
19127 #define parser_mark ripper_parser_mark
19128 #define parser_free ripper_parser_free
19129 #endif
19130 
19131 static void
19132 parser_mark(void *ptr)
19133 {
19134  struct parser_params *p = (struct parser_params*)ptr;
19135 
19136  rb_gc_mark(p->lex.input);
19137  rb_gc_mark(p->lex.prevline);
19138  rb_gc_mark(p->lex.lastline);
19139  rb_gc_mark(p->lex.nextline);
19141  rb_gc_mark((VALUE)p->lex.strterm);
19142  rb_gc_mark((VALUE)p->ast);
19143  rb_gc_mark(p->case_labels);
19144 #ifndef RIPPER
19145  rb_gc_mark(p->debug_lines);
19148 #else
19149  rb_gc_mark(p->delayed.token);
19150  rb_gc_mark(p->value);
19151  rb_gc_mark(p->result);
19152  rb_gc_mark(p->parsing_thread);
19153 #endif
19156 #ifdef YYMALLOC
19157  rb_gc_mark((VALUE)p->heap);
19158 #endif
19159 }
19160 
19161 static void
19162 parser_free(void *ptr)
19163 {
19164  struct parser_params *p = (struct parser_params*)ptr;
19165  struct local_vars *local, *prev;
19166 
19167  if (p->tokenbuf) {
19169  }
19170  for (local = p->lvtbl; local; local = prev) {
19171  if (local->vars) xfree(local->vars);
19172  prev = local->prev;
19173  xfree(local);
19174  }
19175  {
19176  token_info *ptinfo;
19177  while ((ptinfo = p->token_info) != 0) {
19178  p->token_info = ptinfo->next;
19179  xfree(ptinfo);
19180  }
19181  }
19182  xfree(ptr);
19183 }
19184 
19185 static size_t
19186 parser_memsize(const void *ptr)
19187 {
19188  struct parser_params *p = (struct parser_params*)ptr;
19189  struct local_vars *local;
19190  size_t size = sizeof(*p);
19191 
19192  size += p->toksiz;
19193  for (local = p->lvtbl; local; local = local->prev) {
19194  size += sizeof(*local);
19195  if (local->vars) size += local->vars->capa * sizeof(ID);
19196  }
19197  return size;
19198 }
19199 
19200 static const rb_data_type_t parser_data_type = {
19201 #ifndef RIPPER
19202  "parser",
19203 #else
19204  "ripper",
19205 #endif
19206  {
19207  parser_mark,
19208  parser_free,
19209  parser_memsize,
19210  },
19212 };
19213 
19214 #ifndef RIPPER
19215 #undef rb_reserved_word
19216 
19217 const struct kwtable *
19218 rb_reserved_word(const char *str, unsigned int len)
19219 {
19220  return reserved_word(str, len);
19221 }
19222 
19223 VALUE
19225 {
19226  struct parser_params *p;
19227  VALUE parser = TypedData_Make_Struct(0, struct parser_params,
19228  &parser_data_type, p);
19229  parser_initialize(p);
19230  return parser;
19231 }
19232 
19233 VALUE
19234 rb_parser_set_context(VALUE vparser, const struct rb_iseq_struct *base, int main)
19235 {
19236  struct parser_params *p;
19237 
19238  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19239  p->error_buffer = main ? Qfalse : Qnil;
19240  p->parent_iseq = base;
19241  return vparser;
19242 }
19243 #endif
19244 
19245 #ifdef RIPPER
19246 #define rb_parser_end_seen_p ripper_parser_end_seen_p
19247 #define rb_parser_encoding ripper_parser_encoding
19248 #define rb_parser_get_yydebug ripper_parser_get_yydebug
19249 #define rb_parser_set_yydebug ripper_parser_set_yydebug
19250 #define rb_parser_get_debug_output ripper_parser_get_debug_output
19251 #define rb_parser_set_debug_output ripper_parser_set_debug_output
19252 static VALUE ripper_parser_end_seen_p(VALUE vparser);
19253 static VALUE ripper_parser_encoding(VALUE vparser);
19254 static VALUE ripper_parser_get_yydebug(VALUE self);
19255 static VALUE ripper_parser_set_yydebug(VALUE self, VALUE flag);
19256 static VALUE ripper_parser_get_debug_output(VALUE self);
19257 static VALUE ripper_parser_set_debug_output(VALUE self, VALUE output);
19258 
19259 /*
19260  * call-seq:
19261  * ripper.error? -> Boolean
19262  *
19263  * Return true if parsed source has errors.
19264  */
19265 static VALUE
19266 ripper_error_p(VALUE vparser)
19267 {
19268  struct parser_params *p;
19269 
19270  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19271  return p->error_p ? Qtrue : Qfalse;
19272 }
19273 #endif
19274 
19275 /*
19276  * call-seq:
19277  * ripper.end_seen? -> Boolean
19278  *
19279  * Return true if parsed source ended by +\_\_END\_\_+.
19280  */
19281 VALUE
19283 {
19284  struct parser_params *p;
19285 
19286  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19287  return p->ruby__end__seen ? Qtrue : Qfalse;
19288 }
19289 
19290 /*
19291  * call-seq:
19292  * ripper.encoding -> encoding
19293  *
19294  * Return encoding of the source.
19295  */
19296 VALUE
19298 {
19299  struct parser_params *p;
19300 
19301  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, p);
19302  return rb_enc_from_encoding(p->enc);
19303 }
19304 
19305 #ifdef RIPPER
19306 /*
19307  * call-seq:
19308  * ripper.yydebug -> true or false
19309  *
19310  * Get yydebug.
19311  */
19312 VALUE
19313 rb_parser_get_yydebug(VALUE self)
19314 {
19315  struct parser_params *p;
19316 
19317  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19318  return p->debug ? Qtrue : Qfalse;
19319 }
19320 #endif
19321 
19322 /*
19323  * call-seq:
19324  * ripper.yydebug = flag
19325  *
19326  * Set yydebug.
19327  */
19328 VALUE
19330 {
19331  struct parser_params *p;
19332 
19333  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19334  p->debug = RTEST(flag);
19335  return flag;
19336 }
19337 
19338 /*
19339  * call-seq:
19340  * ripper.debug_output -> obj
19341  *
19342  * Get debug output.
19343  */
19344 VALUE
19346 {
19347  struct parser_params *p;
19348 
19349  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19350  return p->debug_output;
19351 }
19352 
19353 /*
19354  * call-seq:
19355  * ripper.debug_output = obj
19356  *
19357  * Set debug output.
19358  */
19359 VALUE
19361 {
19362  struct parser_params *p;
19363 
19364  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19365  return p->debug_output = output;
19366 }
19367 
19368 #ifndef RIPPER
19369 #ifdef YYMALLOC
19370 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
19371 /* Keep the order; NEWHEAP then xmalloc and ADD2HEAP to get rid of
19372  * potential memory leak */
19373 #define NEWHEAP() rb_imemo_tmpbuf_parser_heap(0, p->heap, 0)
19374 #define ADD2HEAP(new, cnt, ptr) ((p->heap = (new))->ptr = (ptr), \
19375  (new)->cnt = (cnt), (ptr))
19376 
19377 void *
19379 {
19380  size_t cnt = HEAPCNT(1, size);
19382  void *ptr = xmalloc(size);
19383 
19384  return ADD2HEAP(n, cnt, ptr);
19385 }
19386 
19387 void *
19388 rb_parser_calloc(struct parser_params *p, size_t nelem, size_t size)
19389 {
19390  size_t cnt = HEAPCNT(nelem, size);
19392  void *ptr = xcalloc(nelem, size);
19393 
19394  return ADD2HEAP(n, cnt, ptr);
19395 }
19396 
19397 void *
19398 rb_parser_realloc(struct parser_params *p, void *ptr, size_t size)
19399 {
19401  size_t cnt = HEAPCNT(1, size);
19402 
19403  if (ptr && (n = p->heap) != NULL) {
19404  do {
19405  if (n->ptr == ptr) {
19406  n->ptr = ptr = xrealloc(ptr, size);
19407  if (n->cnt) n->cnt = cnt;
19408  return ptr;
19409  }
19410  } while ((n = n->next) != NULL);
19411  }
19412  n = NEWHEAP();
19413  ptr = xrealloc(ptr, size);
19414  return ADD2HEAP(n, cnt, ptr);
19415 }
19416 
19417 void
19419 {
19420  rb_imemo_tmpbuf_t **prev = &p->heap, *n;
19421 
19422  while ((n = *prev) != NULL) {
19423  if (n->ptr == ptr) {
19424  *prev = n->next;
19426  break;
19427  }
19428  prev = &n->next;
19429  }
19430  xfree(ptr);
19431 }
19432 #endif
19433 
19434 void
19435 rb_parser_printf(struct parser_params *p, const char *fmt, ...)
19436 {
19437  va_list ap;
19438  VALUE mesg = p->debug_buffer;
19439 
19440  if (NIL_P(mesg)) p->debug_buffer = mesg = rb_str_new(0, 0);
19441  va_start(ap, fmt);
19442  rb_str_vcatf(mesg, fmt, ap);
19443  va_end(ap);
19444  if (RSTRING_END(mesg)[-1] == '\n') {
19445  rb_io_write(p->debug_output, mesg);
19446  p->debug_buffer = Qnil;
19447  }
19448 }
19449 
19450 static void
19451 parser_compile_error(struct parser_params *p, const char *fmt, ...)
19452 {
19453  va_list ap;
19454 
19456  p->error_p = 1;
19457  va_start(ap, fmt);
19458  p->error_buffer =
19461  p->ruby_sourceline,
19462  rb_long2int(p->lex.pcur - p->lex.pbeg),
19463  p->enc, fmt, ap);
19464  va_end(ap);
19465 }
19466 
19467 static size_t
19468 count_char(const char *str, int c)
19469 {
19470  int n = 0;
19471  while (str[n] == c) ++n;
19472  return n;
19473 }
19474 
19475 /*
19476  * strip enclosing double-quotes, same as the default yytnamerr except
19477  * for that single-quotes matching back-quotes do not stop stripping.
19478  *
19479  * "\"`class' keyword\"" => "`class' keyword"
19480  */
19481 RUBY_FUNC_EXPORTED size_t
19482 rb_yytnamerr(struct parser_params *p, char *yyres, const char *yystr)
19483 {
19484  YYUSE(p);
19485  if (*yystr == '"') {
19486  size_t yyn = 0, bquote = 0;
19487  const char *yyp = yystr;
19488 
19489  while (*++yyp) {
19490  switch (*yyp) {
19491  case '`':
19492  if (!bquote) {
19493  bquote = count_char(yyp+1, '`') + 1;
19494  if (yyres) memcpy(&yyres[yyn], yyp, bquote);
19495  yyn += bquote;
19496  yyp += bquote - 1;
19497  break;
19498  }
19499  goto default_char;
19500 
19501  case '\'':
19502  if (bquote && count_char(yyp+1, '\'') + 1 == bquote) {
19503  if (yyres) memcpy(yyres + yyn, yyp, bquote);
19504  yyn += bquote;
19505  yyp += bquote - 1;
19506  bquote = 0;
19507  break;
19508  }
19509  if (yyp[1] && yyp[1] != '\'' && yyp[2] == '\'') {
19510  if (yyres) memcpy(yyres + yyn, yyp, 3);
19511  yyn += 3;
19512  yyp += 2;
19513  break;
19514  }
19515  goto do_not_strip_quotes;
19516 
19517  case ',':
19518  goto do_not_strip_quotes;
19519 
19520  case '\\':
19521  if (*++yyp != '\\')
19522  goto do_not_strip_quotes;
19523  /* Fall through. */
19524  default_char:
19525  default:
19526  if (yyres)
19527  yyres[yyn] = *yyp;
19528  yyn++;
19529  break;
19530 
19531  case '"':
19532  case '\0':
19533  if (yyres)
19534  yyres[yyn] = '\0';
19535  return yyn;
19536  }
19537  }
19538  do_not_strip_quotes: ;
19539  }
19540 
19541  if (!yyres) return strlen(yystr);
19542 
19543  return (YYSIZE_T)(yystpcpy(yyres, yystr) - yyres);
19544 }
19545 #endif
19546 
19547 #ifdef RIPPER
19548 #ifdef RIPPER_DEBUG
19549 /* :nodoc: */
19550 static VALUE
19551 ripper_validate_object(VALUE self, VALUE x)
19552 {
19553  if (x == Qfalse) return x;
19554  if (x == Qtrue) return x;
19555  if (x == Qnil) return x;
19556  if (x == Qundef)
19557  rb_raise(rb_eArgError, "Qundef given");
19558  if (FIXNUM_P(x)) return x;
19559  if (SYMBOL_P(x)) return x;
19560  switch (BUILTIN_TYPE(x)) {
19561  case T_STRING:
19562  case T_OBJECT:
19563  case T_ARRAY:
19564  case T_BIGNUM:
19565  case T_FLOAT:
19566  case T_COMPLEX:
19567  case T_RATIONAL:
19568  break;
19569  case T_NODE:
19570  if (nd_type((NODE *)x) != NODE_RIPPER) {
19571  rb_raise(rb_eArgError, "NODE given: %p", (void *)x);
19572  }
19573  x = ((NODE *)x)->nd_rval;
19574  break;
19575  default:
19576  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
19577  (void *)x, rb_obj_classname(x));
19578  }
19579  if (!RBASIC_CLASS(x)) {
19580  rb_raise(rb_eArgError, "hidden ruby object: %p (%s)",
19581  (void *)x, rb_builtin_type_name(TYPE(x)));
19582  }
19583  return x;
19584 }
19585 #endif
19586 
19587 #define validate(x) ((x) = get_value(x))
19588 
19589 static VALUE
19590 ripper_dispatch0(struct parser_params *p, ID mid)
19591 {
19592  return rb_funcall(p->value, mid, 0);
19593 }
19594 
19595 static VALUE
19596 ripper_dispatch1(struct parser_params *p, ID mid, VALUE a)
19597 {
19598  validate(a);
19599  return rb_funcall(p->value, mid, 1, a);
19600 }
19601 
19602 static VALUE
19603 ripper_dispatch2(struct parser_params *p, ID mid, VALUE a, VALUE b)
19604 {
19605  validate(a);
19606  validate(b);
19607  return rb_funcall(p->value, mid, 2, a, b);
19608 }
19609 
19610 static VALUE
19611 ripper_dispatch3(struct parser_params *p, ID mid, VALUE a, VALUE b, VALUE c)
19612 {
19613  validate(a);
19614  validate(b);
19615  validate(c);
19616  return rb_funcall(p->value, mid, 3, a, b, c);
19617 }
19618 
19619 static VALUE
19620 ripper_dispatch4(struct parser_params *p, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
19621 {
19622  validate(a);
19623  validate(b);
19624  validate(c);
19625  validate(d);
19626  return rb_funcall(p->value, mid, 4, a, b, c, d);
19627 }
19628 
19629 static VALUE
19630 ripper_dispatch5(struct parser_params *p, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
19631 {
19632  validate(a);
19633  validate(b);
19634  validate(c);
19635  validate(d);
19636  validate(e);
19637  return rb_funcall(p->value, mid, 5, a, b, c, d, e);
19638 }
19639 
19640 static VALUE
19641 ripper_dispatch7(struct parser_params *p, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
19642 {
19643  validate(a);
19644  validate(b);
19645  validate(c);
19646  validate(d);
19647  validate(e);
19648  validate(f);
19649  validate(g);
19650  return rb_funcall(p->value, mid, 7, a, b, c, d, e, f, g);
19651 }
19652 
19653 static ID
19654 ripper_get_id(VALUE v)
19655 {
19656  NODE *nd;
19657  if (!RB_TYPE_P(v, T_NODE)) return 0;
19658  nd = (NODE *)v;
19659  if (nd_type(nd) != NODE_RIPPER) return 0;
19660  return nd->nd_vid;
19661 }
19662 
19663 static VALUE
19664 ripper_get_value(VALUE v)
19665 {
19666  NODE *nd;
19667  if (v == Qundef) return Qnil;
19668  if (!RB_TYPE_P(v, T_NODE)) return v;
19669  nd = (NODE *)v;
19670  if (nd_type(nd) != NODE_RIPPER) return Qnil;
19671  return nd->nd_rval;
19672 }
19673 
19674 static void
19675 ripper_error(struct parser_params *p)
19676 {
19677  p->error_p = TRUE;
19678 }
19679 
19680 static void
19681 ripper_compile_error(struct parser_params *p, const char *fmt, ...)
19682 {
19683  VALUE str;
19684  va_list args;
19685 
19686  va_start(args, fmt);
19687  str = rb_vsprintf(fmt, args);
19688  va_end(args);
19689  rb_funcall(p->value, rb_intern("compile_error"), 1, str);
19690  ripper_error(p);
19691 }
19692 
19693 static VALUE
19694 ripper_lex_get_generic(struct parser_params *p, VALUE src)
19695 {
19696  VALUE line = rb_funcallv_public(src, id_gets, 0, 0);
19697  if (!NIL_P(line) && !RB_TYPE_P(line, T_STRING)) {
19699  "gets returned %"PRIsVALUE" (expected String or nil)",
19700  rb_obj_class(line));
19701  }
19702  return line;
19703 }
19704 
19705 static VALUE
19706 ripper_lex_io_get(struct parser_params *p, VALUE src)
19707 {
19708  return rb_io_gets(src);
19709 }
19710 
19711 static VALUE
19712 ripper_s_allocate(VALUE klass)
19713 {
19714  struct parser_params *p;
19716  &parser_data_type, p);
19717  p->value = self;
19718  return self;
19719 }
19720 
19721 #define ripper_initialized_p(r) ((r)->lex.input != 0)
19722 
19723 /*
19724  * call-seq:
19725  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
19726  *
19727  * Create a new Ripper object.
19728  * _src_ must be a String, an IO, or an Object which has #gets method.
19729  *
19730  * This method does not starts parsing.
19731  * See also Ripper#parse and Ripper.parse.
19732  */
19733 static VALUE
19734 ripper_initialize(int argc, VALUE *argv, VALUE self)
19735 {
19736  struct parser_params *p;
19737  VALUE src, fname, lineno;
19738 
19739  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19740  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
19741  if (RB_TYPE_P(src, T_FILE)) {
19742  p->lex.gets = ripper_lex_io_get;
19743  }
19744  else if (rb_respond_to(src, id_gets)) {
19745  p->lex.gets = ripper_lex_get_generic;
19746  }
19747  else {
19748  StringValue(src);
19749  p->lex.gets = lex_get_str;
19750  }
19751  p->lex.input = src;
19752  p->eofp = 0;
19753  if (NIL_P(fname)) {
19754  fname = STR_NEW2("(ripper)");
19755  OBJ_FREEZE(fname);
19756  }
19757  else {
19758  StringValueCStr(fname);
19759  fname = rb_str_new_frozen(fname);
19760  }
19761  parser_initialize(p);
19762 
19763  p->ruby_sourcefile_string = fname;
19764  p->ruby_sourcefile = RSTRING_PTR(fname);
19765  p->ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
19766 
19767  return Qnil;
19768 }
19769 
19770 static VALUE
19771 ripper_parse0(VALUE parser_v)
19772 {
19773  struct parser_params *p;
19774 
19775  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, p);
19776  parser_prepare(p);
19777  p->ast = rb_ast_new();
19778  ripper_yyparse((void*)p);
19779  rb_ast_dispose(p->ast);
19780  p->ast = 0;
19781  return p->result;
19782 }
19783 
19784 static VALUE
19785 ripper_ensure(VALUE parser_v)
19786 {
19787  struct parser_params *p;
19788 
19789  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, p);
19790  p->parsing_thread = Qnil;
19791  return Qnil;
19792 }
19793 
19794 /*
19795  * call-seq:
19796  * ripper.parse
19797  *
19798  * Start parsing and returns the value of the root action.
19799  */
19800 static VALUE
19801 ripper_parse(VALUE self)
19802 {
19803  struct parser_params *p;
19804 
19805  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19806  if (!ripper_initialized_p(p)) {
19807  rb_raise(rb_eArgError, "method called for uninitialized object");
19808  }
19809  if (!NIL_P(p->parsing_thread)) {
19810  if (p->parsing_thread == rb_thread_current())
19811  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
19812  else
19813  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
19814  }
19815  p->parsing_thread = rb_thread_current();
19816  rb_ensure(ripper_parse0, self, ripper_ensure, self);
19817 
19818  return p->result;
19819 }
19820 
19821 /*
19822  * call-seq:
19823  * ripper.column -> Integer
19824  *
19825  * Return column number of current parsing line.
19826  * This number starts from 0.
19827  */
19828 static VALUE
19829 ripper_column(VALUE self)
19830 {
19831  struct parser_params *p;
19832  long col;
19833 
19834  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19835  if (!ripper_initialized_p(p)) {
19836  rb_raise(rb_eArgError, "method called for uninitialized object");
19837  }
19838  if (NIL_P(p->parsing_thread)) return Qnil;
19839  col = p->lex.ptok - p->lex.pbeg;
19840  return LONG2NUM(col);
19841 }
19842 
19843 /*
19844  * call-seq:
19845  * ripper.filename -> String
19846  *
19847  * Return current parsing filename.
19848  */
19849 static VALUE
19850 ripper_filename(VALUE self)
19851 {
19852  struct parser_params *p;
19853 
19854  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19855  if (!ripper_initialized_p(p)) {
19856  rb_raise(rb_eArgError, "method called for uninitialized object");
19857  }
19858  return p->ruby_sourcefile_string;
19859 }
19860 
19861 /*
19862  * call-seq:
19863  * ripper.lineno -> Integer
19864  *
19865  * Return line number of current parsing line.
19866  * This number starts from 1.
19867  */
19868 static VALUE
19869 ripper_lineno(VALUE self)
19870 {
19871  struct parser_params *p;
19872 
19873  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19874  if (!ripper_initialized_p(p)) {
19875  rb_raise(rb_eArgError, "method called for uninitialized object");
19876  }
19877  if (NIL_P(p->parsing_thread)) return Qnil;
19878  return INT2NUM(p->ruby_sourceline);
19879 }
19880 
19881 /*
19882  * call-seq:
19883  * ripper.state -> Integer
19884  *
19885  * Return scanner state of current token.
19886  */
19887 static VALUE
19888 ripper_state(VALUE self)
19889 {
19890  struct parser_params *p;
19891 
19892  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19893  if (!ripper_initialized_p(p)) {
19894  rb_raise(rb_eArgError, "method called for uninitialized object");
19895  }
19896  if (NIL_P(p->parsing_thread)) return Qnil;
19897  return INT2NUM(p->lex.state);
19898 }
19899 
19900 /*
19901  * call-seq:
19902  * ripper.token -> String
19903  *
19904  * Return the current token string.
19905  */
19906 static VALUE
19907 ripper_token(VALUE self)
19908 {
19909  struct parser_params *p;
19910  long pos, len;
19911 
19912  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, p);
19913  if (!ripper_initialized_p(p)) {
19914  rb_raise(rb_eArgError, "method called for uninitialized object");
19915  }
19916  if (NIL_P(p->parsing_thread)) return Qnil;
19917  pos = p->lex.ptok - p->lex.pbeg;
19918  len = p->lex.pcur - p->lex.ptok;
19919  return rb_str_subseq(p->lex.lastline, pos, len);
19920 }
19921 
19922 #ifdef RIPPER_DEBUG
19923 /* :nodoc: */
19924 static VALUE
19925 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
19926 {
19927  StringValue(msg);
19928  if (obj == Qundef) {
19929  rb_raise(rb_eArgError, "%"PRIsVALUE, msg);
19930  }
19931  return Qnil;
19932 }
19933 
19934 /* :nodoc: */
19935 static VALUE
19936 ripper_value(VALUE self, VALUE obj)
19937 {
19938  return ULONG2NUM(obj);
19939 }
19940 #endif
19941 
19942 /*
19943  * call-seq:
19944  * Ripper.lex_state_name(integer) -> string
19945  *
19946  * Returns a string representation of lex_state.
19947  */
19948 static VALUE
19949 ripper_lex_state_name(VALUE self, VALUE state)
19950 {
19952 }
19953 
19954 void
19955 Init_ripper(void)
19956 {
19957  ripper_init_eventids1();
19958  ripper_init_eventids2();
19959  id_warn = rb_intern_const("warn");
19960  id_warning = rb_intern_const("warning");
19961  id_gets = rb_intern_const("gets");
19962  id_assoc = rb_intern_const("=>");
19963 
19964  (void)yystpcpy; /* may not used in newer bison */
19965 
19966  InitVM(ripper);
19967 }
19968 
19969 void
19970 InitVM_ripper(void)
19971 {
19972  VALUE Ripper;
19973 
19974  Ripper = rb_define_class("Ripper", rb_cObject);
19975  /* version of Ripper */
19976  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
19977  rb_define_alloc_func(Ripper, ripper_s_allocate);
19978  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
19979  rb_define_method(Ripper, "parse", ripper_parse, 0);
19980  rb_define_method(Ripper, "column", ripper_column, 0);
19981  rb_define_method(Ripper, "filename", ripper_filename, 0);
19982  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
19983  rb_define_method(Ripper, "state", ripper_state, 0);
19984  rb_define_method(Ripper, "token", ripper_token, 0);
19985  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
19986  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
19987  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
19988  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
19989  rb_define_method(Ripper, "debug_output", rb_parser_get_debug_output, 0);
19990  rb_define_method(Ripper, "debug_output=", rb_parser_set_debug_output, 1);
19991  rb_define_method(Ripper, "error?", ripper_error_p, 0);
19992 #ifdef RIPPER_DEBUG
19993  rb_define_method(Ripper, "assert_Qundef", ripper_assert_Qundef, 2);
19994  rb_define_method(Ripper, "rawVALUE", ripper_value, 1);
19995  rb_define_method(Ripper, "validate_object", ripper_validate_object, 1);
19996 #endif
19997 
19998  rb_define_singleton_method(Ripper, "dedent_string", parser_dedent_string, 2);
19999  rb_define_private_method(Ripper, "dedent_string", parser_dedent_string, 2);
20000 
20001  rb_define_singleton_method(Ripper, "lex_state_name", ripper_lex_state_name, 1);
20002 
20003  /* ignore newline, +/- is a sign. */
20004  rb_define_const(Ripper, "EXPR_BEG", INT2NUM(EXPR_BEG));
20005  /* newline significant, +/- is an operator. */
20006  rb_define_const(Ripper, "EXPR_END", INT2NUM(EXPR_END));
20007  /* ditto, and unbound braces. */
20008  rb_define_const(Ripper, "EXPR_ENDARG", INT2NUM(EXPR_ENDARG));
20009  /* ditto, and unbound braces. */
20010  rb_define_const(Ripper, "EXPR_ENDFN", INT2NUM(EXPR_ENDFN));
20011  /* newline significant, +/- is an operator. */
20012  rb_define_const(Ripper, "EXPR_ARG", INT2NUM(EXPR_ARG));
20013  /* newline significant, +/- is an operator. */
20014  rb_define_const(Ripper, "EXPR_CMDARG", INT2NUM(EXPR_CMDARG));
20015  /* newline significant, +/- is an operator. */
20016  rb_define_const(Ripper, "EXPR_MID", INT2NUM(EXPR_MID));
20017  /* ignore newline, no reserved words. */
20018  rb_define_const(Ripper, "EXPR_FNAME", INT2NUM(EXPR_FNAME));
20019  /* right after `.' or `::', no reserved words. */
20020  rb_define_const(Ripper, "EXPR_DOT", INT2NUM(EXPR_DOT));
20021  /* immediate after `class', no here document. */
20022  rb_define_const(Ripper, "EXPR_CLASS", INT2NUM(EXPR_CLASS));
20023  /* flag bit, label is allowed. */
20024  rb_define_const(Ripper, "EXPR_LABEL", INT2NUM(EXPR_LABEL));
20025  /* flag bit, just after a label. */
20026  rb_define_const(Ripper, "EXPR_LABELED", INT2NUM(EXPR_LABELED));
20027  /* symbol literal as FNAME. */
20028  rb_define_const(Ripper, "EXPR_FITEM", INT2NUM(EXPR_FITEM));
20029  /* equals to +EXPR_BEG+ */
20030  rb_define_const(Ripper, "EXPR_VALUE", INT2NUM(EXPR_VALUE));
20031  /* equals to <tt>(EXPR_BEG | EXPR_MID | EXPR_CLASS)</tt> */
20032  rb_define_const(Ripper, "EXPR_BEG_ANY", INT2NUM(EXPR_BEG_ANY));
20033  /* equals to <tt>(EXPR_ARG | EXPR_CMDARG)</tt> */
20034  rb_define_const(Ripper, "EXPR_ARG_ANY", INT2NUM(EXPR_ARG_ANY));
20035  /* equals to <tt>(EXPR_END | EXPR_ENDARG | EXPR_ENDFN)</tt> */
20036  rb_define_const(Ripper, "EXPR_END_ANY", INT2NUM(EXPR_END_ANY));
20037  /* equals to +0+ */
20038  rb_define_const(Ripper, "EXPR_NONE", INT2NUM(EXPR_NONE));
20039 
20040  ripper_init_eventids1_table(Ripper);
20041  ripper_init_eventids2_table(Ripper);
20042 
20043 # if 0
20044  /* Hack to let RDoc document SCRIPT_LINES__ */
20045 
20046  /*
20047  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
20048  * after the assignment will be added as an Array of lines with the file
20049  * name as the key.
20050  */
20051  rb_define_global_const("SCRIPT_LINES__", Qnil);
20052 #endif
20053 
20054 }
20055 #endif /* RIPPER */
20056 
20057 /*
20058  * Local variables:
20059  * mode: c
20060  * c-file-style: "ruby"
20061  * End:
20062  */
rb_parser_printf
void rb_parser_printf(struct parser_params *p, const char *fmt,...)
Definition: ripper.c:19435
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
IS_LABEL_POSSIBLE
#define IS_LABEL_POSSIBLE()
Definition: ripper.c:13841
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:12958
WARN_S_L
#define WARN_S_L(s, l)
Definition: ripper.c:995
rb_parser_new
VALUE rb_parser_new(void)
Definition: ripper.c:19224
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:18940
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
RUBY_SYMBOL_EXPORT_END
#define RUBY_SYMBOL_EXPORT_END
Definition: missing.h:49
STATIC_ASSERT
STATIC_ASSERT(rb_strterm_heredoc_t, sizeof(rb_strterm_heredoc_t)<=4 *SIZEOF_VALUE)
NEW_FOR_MASGN
#define NEW_FOR_MASGN(v, loc)
Definition: node.h:299
rb_define_class
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:649
keyword_defined
@ keyword_defined
Definition: parse.h:92
parser_params::call
VALUE(* call)(VALUE, int)
Definition: ripper.c:288
Qnull
#define Qnull
Definition: ripper.c:942
void
void
Definition: rb_mjit_min_header-2.7.0.h:13273
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:5133
set_yylval_noname
#define set_yylval_noname()
Definition: ripper.c:12284
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:14621
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:5135
RSTRING_GETMEM
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Definition: ruby.h:1018
WARN_LOCATION
#define WARN_LOCATION(type)
Definition: ripper.c:16717
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:19218
keyword_class
@ keyword_class
Definition: parse.h:49
rb_parser_warn_location
void rb_parser_warn_location(VALUE vparser, int warn)
Definition: ripper.c:19047
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:12955
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:409
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:14198
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
vars
const VALUE int int int int int int VALUE * vars[]
Definition: rb_mjit_min_header-2.7.0.h:6462
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
rb_ast_struct::body
rb_ast_body_t body
Definition: node.h:402
local_vars
Definition: ripper.c:214
nd_state
#define nd_state
Definition: node.h:263
id
const int id
Definition: nkf.c:209
ID_INTERNAL
#define ID_INTERNAL
Definition: id.h:40
NEW_NODE
#define NEW_NODE(t, a0, a1, a2, loc)
Definition: node.h:282
KWD2EID
#define KWD2EID(t, v)
Definition: ripper.c:937
yytype_uint8
unsigned char yytype_uint8
Definition: ripper.c:1233
rb_ary_pattern_info::pre_args
NODE * pre_args
Definition: node.h: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:4203
rb_hash_new
VALUE rb_hash_new(void)
Definition: hash.c:1501
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:7063
tLAMBEG
@ tLAMBEG
Definition: parse.h:163
eventids1.c
path
VALUE path
Definition: rb_mjit_min_header-2.7.0.h:7351
NODE_TRUE
@ NODE_TRUE
Definition: node.h:126
string_type
string_type
Definition: ripper.c:12957
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:12950
memset
void * memset(void *, int, size_t)
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:13095
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_ary_new_from_args
#define rb_ary_new_from_args(n,...)
Definition: rb_mjit_min_header-2.7.0.h:7214
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:12960
rb_scan_args
#define rb_scan_args(argc, argvp, fmt,...)
Definition: rb_mjit_min_header-2.7.0.h:6372
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_gc_force_recycle
void rb_gc_force_recycle(VALUE obj)
Definition: gc.c:7011
tLPAREN
@ tLPAREN
Definition: parse.h:141
EXPR_LABEL_bit
@ EXPR_LABEL_bit
Definition: ripper.c:145
IS_lex_state_for
#define IS_lex_state_for(x, ls)
Definition: ripper.c:172
INT2FIX
#define INT2FIX(i)
Definition: ruby.h:263
rb_hash_clear
VALUE rb_hash_clear(VALUE hash)
Definition: hash.c:2696
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:12678
toklen
#define toklen(p)
Definition: ripper.c:13097
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:18995
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:13837
rb_attr_get
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1084
parser_params::pend
const char * pend
Definition: ripper.c:284
keyword_not
@ keyword_not
Definition: parse.h:85
parser_params::debug_buffer
VALUE debug_buffer
Definition: ripper.c:319
keyword_alias
@ keyword_alias
Definition: parse.h:91
rb_strterm_mark
void rb_strterm_mark(VALUE obj)
Definition: ripper.c:765
parser_params::debug_lines
VALUE debug_lines
Definition: ripper.c:358
parser_params::heredoc_indent
int heredoc_indent
Definition: ripper.c:304
str_squote
@ str_squote
Definition: ripper.c:12959
ESCAPE_META
#define ESCAPE_META
Definition: ripper.c:13303
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
token_info::next
struct token_info * next
Definition: ripper.c:256
YYACCEPT
#define YYACCEPT
Definition: ripper.c:5138
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:12266
encoding.h
NEW_REDO
#define NEW_REDO(loc)
Definition: node.h:304
STR_FUNC_SYMBOL
#define STR_FUNC_SYMBOL
Definition: ripper.c:12951
ruby_verbose
#define ruby_verbose
Definition: ruby.h:1925
ZALLOC
#define ZALLOC(type)
Definition: ruby.h:1666
rb_intern
#define rb_intern(str)
malloc
void * malloc(size_t) __attribute__((__malloc__)) __attribute__((__warn_unused_result__)) __attribute__((__alloc_size__(1)))
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
set_yylval_id
#define set_yylval_id(x)
Definition: ripper.c:12265
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
ERANGE
#define ERANGE
Definition: rb_mjit_min_header-2.7.0.h:10971
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
int
__inline__ int
Definition: rb_mjit_min_header-2.7.0.h:2839
magic_comment::length
rb_magic_comment_length_t length
Definition: ripper.c:14623
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:17122
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
idGets
@ idGets
Definition: rb_mjit_min_header-2.7.0.h:8701
rb_rational_raw1
#define rb_rational_raw1(x)
Definition: intern.h:176
rb_args_info::post_init
NODE * post_init
Definition: node.h:433
idAND
@ idAND
Definition: rb_mjit_min_header-2.7.0.h:8732
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:17103
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
StringValue
use StringValue() instead")))
rb_parser_compile_file_path
rb_ast_t * rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE file, int start)
Definition: ripper.c:12912
nd_once_body
#define nd_once_body(node)
Definition: ripper.c:16655
tIVAR
@ tIVAR
Definition: parse.h:101
else
else
Definition: rb_mjit_min_header-2.7.0.h:13246
tASET
@ tASET
Definition: parse.h:133
rb_parser_malloc
void * rb_parser_malloc(struct parser_params *p, size_t size)
Definition: ripper.c:19378
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:12964
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:12932
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:850
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
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:13780
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
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
idCall
@ idCall
Definition: rb_mjit_min_header-2.7.0.h:8727
ruby_sized_xfree
#define ruby_sized_xfree(ptr, size)
Definition: rb_mjit_min_header-2.7.0.h:7367
modifier_while
@ modifier_while
Definition: parse.h:88
literal_flush
#define literal_flush(p, ptr)
Definition: ripper.c:12287
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:13844
tSYMBOLS_BEG
@ tSYMBOLS_BEG
Definition: parse.h:157
tSYMBEG
@ tSYMBEG
Definition: parse.h:151
rb_id2str
#define rb_id2str(id)
Definition: vm_backtrace.c:30
YY_ATTRIBUTE_UNUSED
#define YY_ATTRIBUTE_UNUSED
Definition: ripper.c:1296
T_NODE
#define T_NODE
Definition: ruby.h:545
parser_params::do_loop
unsigned int do_loop
Definition: ripper.c:350
tXSTRING_BEG
@ tXSTRING_BEG
Definition: parse.h:153
NODE_DASGN
@ NODE_DASGN
Definition: node.h: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
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
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:12254
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:12990
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
error
const rb_iseq_t const char * error
Definition: rb_mjit_min_header-2.7.0.h:13506
strlen
size_t strlen(const char *)
tBDOT2
@ tBDOT2
Definition: parse.h:130
yytable_value_is_error
#define yytable_value_is_error(Yytable_value)
Definition: ripper.c:1730
OBJ_FREEZE
#define OBJ_FREEZE(x)
Definition: ruby.h:1377
T_OBJECT
#define T_OBJECT
Definition: ruby.h:523
yyalloc::yyss_alloc
yytype_int16 yyss_alloc
Definition: ripper.c:1411
NODE_SPLAT
@ NODE_SPLAT
Definition: node.h:108
EXPR_FITEM_bit
@ EXPR_FITEM_bit
Definition: ripper.c:147
RB_WARN_CATEGORY_EXPERIMENTAL
@ RB_WARN_CATEGORY_EXPERIMENTAL
Definition: internal.h:1561
rb_ascii8bit_encindex
int rb_ascii8bit_encindex(void)
Definition: encoding.c:1322
NODE_CDECL
@ NODE_CDECL
Definition: node.h:62
strncmp
int strncmp(const char *, const char *, size_t)
rb_args_info::kw_args
NODE * kw_args
Definition: node.h:443
rb_init_parse
void rb_init_parse(void)
Definition: ripper.c:19089
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:12989
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:2306
YYEOF
#define YYEOF
Definition: ripper.c:5136
tCMP
@ tCMP
Definition: parse.h:118
warn_balanced
#define warn_balanced(tok, op, syn)
Definition: ripper.c:14850
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:12987
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:19370
parse.h
v
int VALUE v
Definition: rb_mjit_min_header-2.7.0.h:12332
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
cc
const struct rb_call_cache * cc
Definition: rb_mjit_min_header-2.7.0.h:13228
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:13166
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:12638
idMesg
@ idMesg
Definition: rb_mjit_min_header-2.7.0.h:8728
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:2952
YYABORT
#define YYABORT
Definition: ripper.c:5139
COND_IN_FF
@ COND_IN_FF
Definition: ripper.c:17866
ESCAPE_CONTROL
#define ESCAPE_CONTROL
Definition: ripper.c:13302
rb_ary_entry
VALUE rb_ary_entry(VALUE ary, long offset)
Definition: array.c:1512
onig_foreach_name
ONIG_EXTERN int onig_foreach_name(OnigRegex reg, int(*func)(const OnigUChar *, const OnigUChar *, int, int *, OnigRegex, void *), void *arg)
T_FILE
#define T_FILE
Definition: ruby.h:534
tGVAR
@ tGVAR
Definition: parse.h:100
tCOLON3
@ tCOLON3
Definition: parse.h:138
NEW_IF
#define NEW_IF(c, t, e, loc)
Definition: node.h:289
YYSTYPE::val
VALUE val
Definition: parse.h:177
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:18942
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
obj
const VALUE VALUE obj
Definition: rb_mjit_min_header-2.7.0.h:5742
idNil
@ idNil
Definition: rb_mjit_min_header-2.7.0.h:8739
tEMBDOC_BEG
@ tEMBDOC_BEG
Definition: eventids2.c:4
NODE_UNLESS
@ NODE_UNLESS
Definition: node.h:35
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:19388
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:12249
memcpy
void * memcpy(void *__restrict, const void *__restrict, size_t)
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:19418
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:14555
ADD2HEAP
#define ADD2HEAP(new, cnt, ptr)
Definition: ripper.c:19374
keyword_true
@ keyword_true
Definition: parse.h:81
dispatch_delayed_token
#define dispatch_delayed_token(p, t)
Definition: ripper.c:12289
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
token
unsigned short token
Definition: id.c:36
rb_ary_pattern_info::rest_arg
NODE * rest_arg
Definition: node.h:455
memmove
#define memmove(dst, src, len)
Definition: rb_mjit_min_header-2.7.0.h:2848
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
vtable_pop
#define vtable_pop(tbl, n)
Definition: ripper.c:12695
EXPR_NONE
@ EXPR_NONE
Definition: ripper.c:170
i
uint32_t i
Definition: rb_mjit_min_header-2.7.0.h:5464
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:13093
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:19329
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:5253
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:13010
INT_MAX
#define INT_MAX
Definition: rb_mjit_min_header-2.7.0.h:4052
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:19036
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
long
#define long
Definition: rb_mjit_min_header-2.7.0.h:2880
nd_set_type
#define nd_set_type(n, t)
Definition: node.h:189
parser_params::ruby_sourcefile
const char * ruby_sourcefile
Definition: ripper.c:312
NEW_NEXT
#define NEW_NEXT(s, loc)
Definition: node.h:303
rb_memcicmp
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:80
tCHAR
@ tCHAR
Definition: parse.h:109
ISALNUM
#define ISALNUM(c)
Definition: ruby.h:2310
IS_BEG
#define IS_BEG()
Definition: ripper.c:13839
parser_params::case_labels
VALUE case_labels
Definition: ripper.c:316
SPECIAL_PUNCT
#define SPECIAL_PUNCT(idx)
Definition: ripper.c:13785
rb_hash_lookup
VALUE rb_hash_lookup(VALUE hash, VALUE key)
Definition: hash.c:1990
rb_errinfo
VALUE rb_errinfo(void)
The current exception in the current thread.
Definition: eval.c:1881
parser_params::cr_seen
unsigned int cr_seen
Definition: ripper.c:344
rb_ary_push
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:1195
rb_code_position_struct::column
int column
Definition: node.h:132
NEW_YIELD
#define NEW_YIELD(a, loc)
Definition: node.h:311
YY_LOCATION_PRINT
#define YY_LOCATION_PRINT(File, loc)
Definition: ripper.c:104
NEW_DEFS
#define NEW_DEFS(r, i, a, d, loc)
Definition: node.h:286
nd_body
#define nd_body
Definition: node.h:219
tPOW
@ tPOW
Definition: parse.h:117
DVARS_TERMINAL_P
#define DVARS_TERMINAL_P(tbl)
Definition: ripper.c:249
NODE_CASE3
@ NODE_CASE3
Definition: node.h:38
nd_end
#define nd_end
Definition: node.h:262
va_end
#define va_end(v)
Definition: rb_mjit_min_header-2.7.0.h:3979
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
idOR
@ idOR
Definition: rb_mjit_min_header-2.7.0.h:8733
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:18941
has_delayed_token
#define has_delayed_token(p)
Definition: ripper.c:12290
stderr
#define stderr
Definition: rb_mjit_min_header-2.7.0.h:1485
tLSHFT
@ tLSHFT
Definition: parse.h:134
YYINITDEPTH
#define YYINITDEPTH
Definition: ripper.c:5372
YYPRINT
#define YYPRINT(out, tok, val)
Definition: ripper.c:103
YYSTACK_FREE
#define YYSTACK_FREE
Definition: ripper.c:1375
magic_comment
Definition: ripper.c:14620
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:1657
SWITCH_BY_COND_TYPE
#define SWITCH_BY_COND_TYPE(t, w, arg)
Definition: ripper.c:17869
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:18938
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:16314
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
idUScore
@ idUScore
Definition: rb_mjit_min_header-2.7.0.h:8740
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:12897
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:13096
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:17089
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
rb_str_new_cstr
#define rb_str_new_cstr(str)
Definition: rb_mjit_min_header-2.7.0.h:6117
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:19282
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: ripper.c:5320
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:14196
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:12954
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:17158
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
COND_IN_OP
@ COND_IN_OP
Definition: ripper.c:17864
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:5202
STR_NEW3
#define STR_NEW3(ptr, len, e, func)
Definition: ripper.c:380
NODE_STR
@ NODE_STR
Definition: node.h:94
src
__inline__ const void *__restrict src
Definition: rb_mjit_min_header-2.7.0.h:2836
rb_str_buf_append
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2950
fmt
const VALUE int int int int int int VALUE char * fmt
Definition: rb_mjit_min_header-2.7.0.h:6462
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
strcmp
int strcmp(const char *, const char *)
rb_parser_get_debug_output
VALUE rb_parser_get_debug_output(VALUE self)
Definition: ripper.c:19345
ISCNTRL
#define ISCNTRL(c)
Definition: ruby.h:2315
str_xquote
@ str_xquote
Definition: ripper.c:12961
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
idFWD_KWREST
#define idFWD_KWREST
Definition: ripper.c:697
rb_sym_intern_ascii_cstr
#define rb_sym_intern_ascii_cstr(ptr)
Definition: rb_mjit_min_header-2.7.0.h:7758
NODE_IVAR
@ NODE_IVAR
Definition: node.h:85
char
#define char
Definition: rb_mjit_min_header-2.7.0.h:2876
COND_IN_COND
@ COND_IN_COND
Definition: ripper.c:17865
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
n
const char size_t n
Definition: rb_mjit_min_header-2.7.0.h:5456
rb_str_cat_cstr
#define rb_str_cat_cstr(str, ptr)
Definition: rb_mjit_min_header-2.7.0.h:6126
rb_exc_raise
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
Definition: eval.c:667
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
rb_funcall
#define rb_funcall(recv, mid, argc,...)
Definition: rb_mjit_min_header-2.7.0.h:6585
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:12966
rb_enc_str_coderange
int rb_enc_str_coderange(VALUE)
Definition: string.c:657
NEW_ARGSCAT
#define NEW_ARGSCAT(a, b, loc)
Definition: node.h:357
NODE_RETURN
@ NODE_RETURN
Definition: node.h: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:12891
rb_parser_encoding
VALUE rb_parser_encoding(VALUE vparser)
Definition: ripper.c:19297
rb_magic_comment_length_t
long(* rb_magic_comment_length_t)(struct parser_params *p, const char *name, long len)
Definition: ripper.c:14554
NODE_FALSE
@ NODE_FALSE
Definition: node.h:127
T_ARRAY
#define T_ARRAY
Definition: ruby.h:530
arg
VALUE arg
Definition: rb_mjit_min_header-2.7.0.h:5601
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:13752
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:1895
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:12953
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:12264
str_sword
@ str_sword
Definition: ripper.c:12963
NEW_VCALL
#define NEW_VCALL(m, loc)
Definition: node.h:350
dispatch_heredoc_end
#define dispatch_heredoc_end(p)
Definition: ripper.c:14268
ENCODING_GET
#define ENCODING_GET(obj)
Definition: encoding.h:62
tSP
@ tSP
Definition: parse.h:114
NEWHEAP
#define NEWHEAP()
Definition: ripper.c:19373
rb_sprintf
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1197
keyword_do
@ keyword_do
Definition: parse.h:72
klass
VALUE klass
Definition: rb_mjit_min_header-2.7.0.h:13254
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
st_data_t
unsigned long st_data_t
Definition: rb_mjit_min_header-2.7.0.h:5363
idDot3
@ idDot3
Definition: id.h:80
vtable_free
#define vtable_free(tbl)
Definition: ripper.c:12656
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:19360
NEW_ARGS_AUX
#define NEW_ARGS_AUX(r, b, loc)
Definition: node.h:353
parser_params::line_count
int line_count
Definition: ripper.c:310
str
char str[HTML_ESCAPE_MAX_LEN+1]
Definition: escape.c:18
NEW_BACK_REF
#define NEW_BACK_REF(n, loc)
Definition: node.h:336
NEW_IASGN
#define NEW_IASGN(v, val, loc)
Definition: node.h:320
nd_first_lineno
#define nd_first_lineno(n)
Definition: node.h:200
keyword_undef
@ keyword_undef
Definition: parse.h:52
parser_params::lex
struct parser_params::@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:13845
rb_usascii_str_new
#define rb_usascii_str_new(str, len)
Definition: rb_mjit_min_header-2.7.0.h:6118
RFLOAT
#define RFLOAT(obj)
Definition: internal.h:803
NODE_WHEN
@ NODE_WHEN
Definition: node.h:39
YYTERROR
#define YYTERROR
Definition: ripper.c:5163
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:12259
RUBY_TYPED_FREE_IMMEDIATELY
#define RUBY_TYPED_FREE_IMMEDIATELY
Definition: ruby.h:1207
STATIC_ID2SYM
#define STATIC_ID2SYM(id)
Definition: symbol.h:18
idLASTLINE
@ idLASTLINE
Definition: rb_mjit_min_header-2.7.0.h:8752
YYMAXDEPTH
#define YYMAXDEPTH
Definition: ripper.c:5383
nd_1st
#define nd_1st
Definition: node.h:225
ENC_CODERANGE_7BIT
#define ENC_CODERANGE_7BIT
Definition: encoding.h:104
call
return cc call
Definition: rb_mjit_min_header-2.7.0.h:13249
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:19234
rb_hash_aset
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
Definition: hash.c:2779
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
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:12952
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:17183
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:14197
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:5351
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:12949
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:12992
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:18939
IS_END
#define IS_END()
Definition: ripper.c:13838
tNEQ
@ tNEQ
Definition: parse.h:121
rb_io_write
VALUE rb_io_write(VALUE, VALUE)
Definition: io.c:1804
tDOT2
@ tDOT2
Definition: parse.h:128
rb_data_type_struct
Definition: ruby.h:1148
BUILTIN_TYPE
#define BUILTIN_TYPE(x)
Definition: ruby.h:551
rb_big_norm
VALUE rb_big_norm(VALUE x)
Definition: bignum.c:3152
RFLOAT_VALUE
#define RFLOAT_VALUE(v)
Definition: ruby.h:966
parser_params::cond_stack
stack_type cond_stack
Definition: ripper.c:298
yyalloc
Definition: ripper.c: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
s2
const char * s2
Definition: rb_mjit_min_header-2.7.0.h:5454
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:17132
stack_type
VALUE stack_type
Definition: ripper.c:183
RBASIC
#define RBASIC(obj)
Definition: ruby.h:1267
rb_ary_pattern_info::imemo
VALUE imemo
Definition: node.h:457
rb_str_new
#define rb_str_new(str, len)
Definition: rb_mjit_min_header-2.7.0.h:6116
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:5212
rb_reg_fragment_setenc
int rb_reg_fragment_setenc(struct parser_params *, VALUE, int)
Definition: ripper.c:18881
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:12986
is_notop_id
#define is_notop_id(id)
Definition: symbol.h:35
strcasecmp
int strcasecmp(const char *, const char *) __attribute__((__pure__))
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:19398
WARN_SPACE_CHAR
#define WARN_SPACE_CHAR(c, prefix)
Definition: ripper.c:13195
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:17173
modifier_until
@ modifier_until
Definition: parse.h:89
cond_type
cond_type
Definition: ripper.c:17863
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:14622
NODE_SPECIAL_NO_NAME_REST
#define NODE_SPECIAL_NO_NAME_REST
Definition: node.h:383
LONG2FIX
#define LONG2FIX(i)
Definition: ruby.h:265
va_start
#define va_start(v, l)
Definition: rb_mjit_min_header-2.7.0.h:3978
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
MAYBE_UNUSED
#define MAYBE_UNUSED
Definition: ffi_common.h:32
SET_LEX_STATE
#define SET_LEX_STATE(ls)
Definition: ripper.c:177
STRTERM_HEREDOC
#define STRTERM_HEREDOC
Definition: ripper.c:753
parser_params
Definition: ripper.c:270
parser_params::eval_tree
NODE * eval_tree
Definition: ripper.c:356
rb_yytnamerr
size_t rb_yytnamerr(struct parser_params *p, char *yyres, const char *yystr)
Definition: ripper.c:19482
tSTAR
@ tSTAR
Definition: parse.h:147
va_list
__gnuc_va_list va_list
Definition: rb_mjit_min_header-2.7.0.h:836
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
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:13777
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:1114
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
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:12947
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
h
size_t st_index_t h
Definition: rb_mjit_min_header-2.7.0.h:5462
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:12948
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:12962
rb_strterm_struct::heredoc
rb_strterm_heredoc_t heredoc
Definition: ripper.c:759
ptrdiff_t
long int ptrdiff_t
Definition: rb_mjit_min_header-2.7.0.h:802
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
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:12240
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:2706
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:13840
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
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:12965
STR_NEW
#define STR_NEW(ptr, len)
Definition: ripper.c:377
tLOWEST
@ tLOWEST
Definition: parse.h:165
rb_warning1
#define rb_warning1(fmt, a)
Definition: ripper.c:956
memchr
void * memchr(const void *, int, size_t)
name
const char * name
Definition: nkf.c:208
dispatch_scan_event
#define dispatch_scan_event(p, t)
Definition: ripper.c:12288
NODE_GASGN
@ NODE_GASGN
Definition: node.h:60
COND_POP
#define COND_POP()
Definition: ripper.c:196