Ruby  2.5.0dev(2017-10-22revision60238)
ripper.c
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 2.3. */
2 
3 /* Skeleton implementation for Bison's Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6  Free Software Foundation, Inc.
7 
8  This program is free software; you can redistribute it and/or modify
9  it under the terms of the GNU General Public License as published by
10  the Free Software Foundation; either version 2, or (at your option)
11  any later version.
12 
13  This program is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  GNU General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with this program; if not, write to the Free Software
20  Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  Boston, MA 02110-1301, USA. */
22 
23 /* As a special exception, you may create a larger work that contains
24  part or all of the Bison parser skeleton and distribute that work
25  under terms of your choice, so long as that work isn't itself a
26  parser generator using the skeleton or a modified version thereof
27  as a parser skeleton. Alternatively, if you modify or redistribute
28  the parser skeleton itself, you may (at your option) remove this
29  special exception, which will cause the skeleton and the resulting
30  Bison output files to be licensed under the GNU General Public
31  License without this special exception.
32 
33  This special exception was added by the Free Software Foundation in
34  version 2.2 of Bison. */
35 
36 /* C LALR(1) parser skeleton written by Richard Stallman, by
37  simplifying the original so-called "semantic" parser. */
38 
39 /* All symbols defined below should begin with yy or YY, to avoid
40  infringing on user name space. This should be done even for local
41  variables, as they might otherwise be expanded by user macros.
42  There are some unavoidable exceptions within include files to
43  define necessary library symbols; they are noted "INFRINGES ON
44  USER NAME SPACE" below. */
45 
46 /* Identify Bison output. */
47 #define YYBISON 1
48 
49 /* Bison version. */
50 #define YYBISON_VERSION "2.3"
51 
52 /* Skeleton name. */
53 #define YYSKELETON_NAME "yacc.c"
54 
55 /* Pure parsers. */
56 #define YYPURE 1
57 
58 /* Using locations. */
59 #define YYLSP_NEEDED 1
60 
61 
62 
63 /* Tokens. */
64 #ifndef YYTOKENTYPE
65 # define YYTOKENTYPE
66  /* Put the tokens into the symbol table, so that GDB and other debuggers
67  know about them. */
68  enum yytokentype {
69  END_OF_INPUT = 0,
70  keyword_class = 258,
71  keyword_module = 259,
72  keyword_def = 260,
73  keyword_undef = 261,
74  keyword_begin = 262,
75  keyword_rescue = 263,
76  keyword_ensure = 264,
77  keyword_end = 265,
78  keyword_if = 266,
79  keyword_unless = 267,
80  keyword_then = 268,
81  keyword_elsif = 269,
82  keyword_else = 270,
83  keyword_case = 271,
84  keyword_when = 272,
85  keyword_while = 273,
86  keyword_until = 274,
87  keyword_for = 275,
88  keyword_break = 276,
89  keyword_next = 277,
90  keyword_redo = 278,
91  keyword_retry = 279,
92  keyword_in = 280,
93  keyword_do = 281,
94  keyword_do_cond = 282,
95  keyword_do_block = 283,
96  keyword_do_LAMBDA = 284,
97  keyword_return = 285,
98  keyword_yield = 286,
99  keyword_super = 287,
100  keyword_self = 288,
101  keyword_nil = 289,
102  keyword_true = 290,
103  keyword_false = 291,
104  keyword_and = 292,
105  keyword_or = 293,
106  keyword_not = 294,
107  modifier_if = 295,
108  modifier_unless = 296,
109  modifier_while = 297,
110  modifier_until = 298,
111  modifier_rescue = 299,
112  keyword_alias = 300,
113  keyword_defined = 301,
114  keyword_BEGIN = 302,
115  keyword_END = 303,
116  keyword__LINE__ = 304,
117  keyword__FILE__ = 305,
118  keyword__ENCODING__ = 306,
119  tIDENTIFIER = 307,
120  tFID = 308,
121  tGVAR = 309,
122  tIVAR = 310,
123  tCONSTANT = 311,
124  tCVAR = 312,
125  tLABEL = 313,
126  tINTEGER = 314,
127  tFLOAT = 315,
128  tRATIONAL = 316,
129  tIMAGINARY = 317,
130  tSTRING_CONTENT = 318,
131  tCHAR = 319,
132  tNTH_REF = 320,
133  tBACK_REF = 321,
134  tREGEXP_END = 322,
135  tUPLUS = 130,
136  tUMINUS = 131,
137  tPOW = 132,
138  tCMP = 133,
139  tEQ = 138,
140  tEQQ = 139,
141  tNEQ = 140,
142  tGEQ = 137,
143  tLEQ = 136,
144  tANDOP = 146,
145  tOROP = 147,
146  tMATCH = 141,
147  tNMATCH = 142,
148  tDOT2 = 128,
149  tDOT3 = 129,
150  tAREF = 143,
151  tASET = 144,
152  tLSHFT = 134,
153  tRSHFT = 135,
154  tANDDOT = 148,
155  tCOLON2 = 145,
156  tCOLON3 = 323,
157  tOP_ASGN = 324,
158  tASSOC = 325,
159  tLPAREN = 326,
160  tLPAREN_ARG = 327,
161  tRPAREN = 328,
162  tLBRACK = 329,
163  tLBRACE = 330,
164  tLBRACE_ARG = 331,
165  tSTAR = 332,
166  tDSTAR = 333,
167  tAMPER = 334,
168  tLAMBDA = 335,
169  tSYMBEG = 336,
170  tSTRING_BEG = 337,
171  tXSTRING_BEG = 338,
172  tREGEXP_BEG = 339,
173  tWORDS_BEG = 340,
174  tQWORDS_BEG = 341,
175  tSYMBOLS_BEG = 342,
176  tQSYMBOLS_BEG = 343,
177  tSTRING_DBEG = 344,
178  tSTRING_DEND = 345,
179  tSTRING_DVAR = 346,
180  tSTRING_END = 347,
181  tLAMBEG = 348,
182  tLABEL_END = 349,
183  tLOWEST = 350,
184  tUMINUS_NUM = 351,
185  tLAST_TOKEN = 352
186  };
187 #endif
188 /* Tokens. */
189 #define END_OF_INPUT 0
190 #define keyword_class 258
191 #define keyword_module 259
192 #define keyword_def 260
193 #define keyword_undef 261
194 #define keyword_begin 262
195 #define keyword_rescue 263
196 #define keyword_ensure 264
197 #define keyword_end 265
198 #define keyword_if 266
199 #define keyword_unless 267
200 #define keyword_then 268
201 #define keyword_elsif 269
202 #define keyword_else 270
203 #define keyword_case 271
204 #define keyword_when 272
205 #define keyword_while 273
206 #define keyword_until 274
207 #define keyword_for 275
208 #define keyword_break 276
209 #define keyword_next 277
210 #define keyword_redo 278
211 #define keyword_retry 279
212 #define keyword_in 280
213 #define keyword_do 281
214 #define keyword_do_cond 282
215 #define keyword_do_block 283
216 #define keyword_do_LAMBDA 284
217 #define keyword_return 285
218 #define keyword_yield 286
219 #define keyword_super 287
220 #define keyword_self 288
221 #define keyword_nil 289
222 #define keyword_true 290
223 #define keyword_false 291
224 #define keyword_and 292
225 #define keyword_or 293
226 #define keyword_not 294
227 #define modifier_if 295
228 #define modifier_unless 296
229 #define modifier_while 297
230 #define modifier_until 298
231 #define modifier_rescue 299
232 #define keyword_alias 300
233 #define keyword_defined 301
234 #define keyword_BEGIN 302
235 #define keyword_END 303
236 #define keyword__LINE__ 304
237 #define keyword__FILE__ 305
238 #define keyword__ENCODING__ 306
239 #define tIDENTIFIER 307
240 #define tFID 308
241 #define tGVAR 309
242 #define tIVAR 310
243 #define tCONSTANT 311
244 #define tCVAR 312
245 #define tLABEL 313
246 #define tINTEGER 314
247 #define tFLOAT 315
248 #define tRATIONAL 316
249 #define tIMAGINARY 317
250 #define tSTRING_CONTENT 318
251 #define tCHAR 319
252 #define tNTH_REF 320
253 #define tBACK_REF 321
254 #define tREGEXP_END 322
255 #define tUPLUS 130
256 #define tUMINUS 131
257 #define tPOW 132
258 #define tCMP 133
259 #define tEQ 138
260 #define tEQQ 139
261 #define tNEQ 140
262 #define tGEQ 137
263 #define tLEQ 136
264 #define tANDOP 146
265 #define tOROP 147
266 #define tMATCH 141
267 #define tNMATCH 142
268 #define tDOT2 128
269 #define tDOT3 129
270 #define tAREF 143
271 #define tASET 144
272 #define tLSHFT 134
273 #define tRSHFT 135
274 #define tANDDOT 148
275 #define tCOLON2 145
276 #define tCOLON3 323
277 #define tOP_ASGN 324
278 #define tASSOC 325
279 #define tLPAREN 326
280 #define tLPAREN_ARG 327
281 #define tRPAREN 328
282 #define tLBRACK 329
283 #define tLBRACE 330
284 #define tLBRACE_ARG 331
285 #define tSTAR 332
286 #define tDSTAR 333
287 #define tAMPER 334
288 #define tLAMBDA 335
289 #define tSYMBEG 336
290 #define tSTRING_BEG 337
291 #define tXSTRING_BEG 338
292 #define tREGEXP_BEG 339
293 #define tWORDS_BEG 340
294 #define tQWORDS_BEG 341
295 #define tSYMBOLS_BEG 342
296 #define tQSYMBOLS_BEG 343
297 #define tSTRING_DBEG 344
298 #define tSTRING_DEND 345
299 #define tSTRING_DVAR 346
300 #define tSTRING_END 347
301 #define tLAMBEG 348
302 #define tLABEL_END 349
303 #define tLOWEST 350
304 #define tUMINUS_NUM 351
305 #define tLAST_TOKEN 352
306 
307 
308 
309 
310 /* Copy the first part of user declarations. */
311 #line 12 "ripper.y"
312 
313 
314 #if !YYPURE
315 # error needs pure parser
316 #endif
317 #ifndef PARSER_DEBUG
318 #define PARSER_DEBUG 0
319 #endif
320 #define YYDEBUG 1
321 #define YYERROR_VERBOSE 1
322 #define YYSTACK_USE_ALLOCA 0
323 
324 #include "ruby/ruby.h"
325 #include "ruby/st.h"
326 #include "ruby/encoding.h"
327 #include "internal.h"
328 #include "node.h"
329 #include "parse.h"
330 #include "symbol.h"
331 #include "regenc.h"
332 #include <stdio.h>
333 #include <errno.h>
334 #include <ctype.h>
335 #include "probes.h"
336 
337 #ifndef WARN_PAST_SCOPE
338 # define WARN_PAST_SCOPE 0
339 #endif
340 
341 #define TAB_WIDTH 8
342 
343 #define YYMALLOC(size) rb_parser_malloc(parser, (size))
344 #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
345 #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
346 #define YYFREE(ptr) rb_parser_free(parser, (ptr))
347 #define YYFPRINTF rb_parser_printf
348 #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
349 # define YY_LOCATION_PRINT(File, Loc) \
350  rb_parser_printf(parser, "%d.%d-%d.%d", \
351  (Loc).first_line, (Loc).first_column, \
352  (Loc).last_line, (Loc).last_column)
353 #endif
354 #undef malloc
355 #undef realloc
356 #undef calloc
357 #undef free
358 #define malloc YYMALLOC
359 #define realloc YYREALLOC
360 #define calloc YYCALLOC
361 #define free YYFREE
362 
363 enum lex_state_bits {
364  EXPR_BEG_bit, /* ignore newline, +/- is a sign. */
365  EXPR_END_bit, /* newline significant, +/- is an operator. */
366  EXPR_ENDARG_bit, /* ditto, and unbound braces. */
367  EXPR_ENDFN_bit, /* ditto, and unbound braces. */
368  EXPR_ARG_bit, /* newline significant, +/- is an operator. */
369  EXPR_CMDARG_bit, /* newline significant, +/- is an operator. */
370  EXPR_MID_bit, /* newline significant, +/- is an operator. */
371  EXPR_FNAME_bit, /* ignore newline, no reserved words. */
372  EXPR_DOT_bit, /* right after `.' or `::', no reserved words. */
373  EXPR_CLASS_bit, /* immediate after `class', no here document. */
374  EXPR_LABEL_bit, /* flag bit, label is allowed. */
375  EXPR_LABELED_bit, /* flag bit, just after a label. */
376  EXPR_FITEM_bit, /* symbol literal as FNAME. */
377  EXPR_MAX_STATE
378 };
379 /* examine combinations */
380 enum lex_state_e {
381 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
382  DEF_EXPR(BEG),
383  DEF_EXPR(END),
384  DEF_EXPR(ENDARG),
385  DEF_EXPR(ENDFN),
386  DEF_EXPR(ARG),
387  DEF_EXPR(CMDARG),
388  DEF_EXPR(MID),
389  DEF_EXPR(FNAME),
390  DEF_EXPR(DOT),
391  DEF_EXPR(CLASS),
392  DEF_EXPR(LABEL),
393  DEF_EXPR(LABELED),
394  DEF_EXPR(FITEM),
395  EXPR_VALUE = EXPR_BEG,
396  EXPR_BEG_ANY = (EXPR_BEG | EXPR_MID | EXPR_CLASS),
397  EXPR_ARG_ANY = (EXPR_ARG | EXPR_CMDARG),
398  EXPR_END_ANY = (EXPR_END | EXPR_ENDARG | EXPR_ENDFN)
399 };
400 #define IS_lex_state_for(x, ls) ((x) & (ls))
401 #define IS_lex_state_all_for(x, ls) (((x) & (ls)) == (ls))
402 #define IS_lex_state(ls) IS_lex_state_for(lex_state, (ls))
403 #define IS_lex_state_all(ls) IS_lex_state_all_for(lex_state, (ls))
404 
405 # define SET_LEX_STATE(ls) \
406  (lex_state = \
407  (yydebug ? \
408  rb_parser_trace_lex_state(parser, lex_state, (ls), __LINE__) : \
409  (enum lex_state_e)(ls)))
410 
411 typedef VALUE stack_type;
412 
413 # define SHOW_BITSTACK(stack, name) (yydebug ? rb_parser_show_bitstack(parser, stack, name, __LINE__) : (void)0)
414 # define BITSTACK_PUSH(stack, n) (((stack) = ((stack)<<1)|((n)&1)), SHOW_BITSTACK(stack, #stack"(push)"))
415 # define BITSTACK_POP(stack) (((stack) = (stack) >> 1), SHOW_BITSTACK(stack, #stack"(pop)"))
416 # define BITSTACK_LEXPOP(stack) (((stack) = ((stack) >> 1) | ((stack) & 1)), SHOW_BITSTACK(stack, #stack"(lexpop)"))
417 # define BITSTACK_SET_P(stack) (SHOW_BITSTACK(stack, #stack), (stack)&1)
418 # define BITSTACK_SET(stack, n) ((stack)=(n), SHOW_BITSTACK(stack, #stack"(set)"))
419 
420 #define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n))
421 #define COND_POP() BITSTACK_POP(cond_stack)
422 #define COND_LEXPOP() BITSTACK_LEXPOP(cond_stack)
423 #define COND_P() BITSTACK_SET_P(cond_stack)
424 #define COND_SET(n) BITSTACK_SET(cond_stack, (n))
425 
426 #define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n))
427 #define CMDARG_POP() BITSTACK_POP(cmdarg_stack)
428 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
429 #define CMDARG_P() BITSTACK_SET_P(cmdarg_stack)
430 #define CMDARG_SET(n) BITSTACK_SET(cmdarg_stack, (n))
431 
432 struct vtable {
433  ID *tbl;
434  int pos;
435  int capa;
436  struct vtable *prev;
437 };
438 
439 struct local_vars {
440  struct vtable *args;
441  struct vtable *vars;
442  struct vtable *used;
443 # if WARN_PAST_SCOPE
444  struct vtable *past;
445 # endif
446  struct local_vars *prev;
447  stack_type cmdargs;
448 };
449 
450 #define DVARS_INHERIT ((void*)1)
451 #define DVARS_TOPSCOPE NULL
452 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
453 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
454 
455 typedef struct token_info {
456  const char *token;
457  int linenum;
458  int column;
459  int nonspc;
460  struct token_info *next;
461 } token_info;
462 
463 /*
464  Structure of Lexer Buffer:
465 
466  lex_pbeg tokp lex_p lex_pend
467  | | | |
468  |-----------+--------------+------------|
469  |<------------>|
470  token
471 */
472 struct parser_params {
473  rb_imemo_alloc_t *heap;
474 
475  YYSTYPE *lval;
476 
477  struct {
478  NODE *strterm;
479  VALUE (*gets)(struct parser_params*,VALUE);
480  VALUE input;
481  VALUE lastline;
482  VALUE nextline;
483  const char *pbeg;
484  const char *pcur;
485  const char *pend;
486  const char *ptok;
487  long gets_ptr;
488  enum lex_state_e state;
489  int paren_nest;
490  int lpar_beg;
491  int brace_nest;
492  } lex;
493  stack_type cond_stack;
494  stack_type cmdarg_stack;
495  int tokidx;
496  int toksiz;
497  int tokline;
498  int heredoc_end;
499  int heredoc_indent;
500  int heredoc_line_indent;
501  char *tokenbuf;
502  struct local_vars *lvtbl;
503  int line_count;
504  int ruby_sourceline; /* current line no. */
505  char *ruby_sourcefile; /* current source file */
506  VALUE ruby_sourcefile_string;
507  rb_encoding *enc;
508  token_info *token_info;
509  VALUE compile_option;
510 
511  VALUE debug_buffer;
512  VALUE debug_output;
513 
514  ID cur_arg;
515 
516  unsigned int command_start:1;
517  unsigned int eofp: 1;
518  unsigned int ruby__end__seen: 1;
519  unsigned int yydebug: 1;
520  unsigned int has_shebang: 1;
521  unsigned int in_defined: 1;
522  unsigned int in_main: 1;
523  unsigned int in_kwarg: 1;
524  unsigned int in_single: 1;
525  unsigned int in_def: 1;
526  unsigned int token_seen: 1;
527  unsigned int token_info_enabled: 1;
528 # if WARN_PAST_SCOPE
529  unsigned int past_scope_enabled: 1;
530 # endif
531  unsigned int error_p: 1;
532  unsigned int cr_seen: 1;
533 
534 #ifndef RIPPER
535  /* Ruby core only */
536 
537  NODE *eval_tree_begin;
538  NODE *eval_tree;
539  VALUE error_buffer;
540  VALUE debug_lines;
541  VALUE coverage;
542  const struct rb_block *base_block;
543 #else
544  /* Ripper only */
545 
546  VALUE delayed;
547  int delayed_line;
548  int delayed_col;
549 
550  VALUE value;
551  VALUE result;
552  VALUE parsing_thread;
553 #endif
554 };
555 
556 #ifdef RIPPER
557 #define intern_cstr(n,l,en) rb_intern3(n,l,en)
558 #else
559 #define intern_cstr(n,l,en) rb_intern3(n,l,en)
560 #endif
561 
562 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)
563 #define STR_NEW0() rb_enc_str_new(0,0,current_enc)
564 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)
565 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)
566 #define TOK_INTERN() intern_cstr(tok(), toklen(), current_enc)
567 
568 static int parser_yyerror(struct parser_params*, const char*);
569 #define yyerror0(msg) parser_yyerror(parser, (msg))
570 #define yyerror(yylloc, parser, msg) yyerror0(msg)
571 #define token_flush(p) ((p)->lex.ptok = (p)->lex.pcur)
572 
573 #define lex_strterm (parser->lex.strterm)
574 #define lex_state (parser->lex.state)
575 #define cond_stack (parser->cond_stack)
576 #define cmdarg_stack (parser->cmdarg_stack)
577 #define paren_nest (parser->lex.paren_nest)
578 #define lpar_beg (parser->lex.lpar_beg)
579 #define brace_nest (parser->lex.brace_nest)
580 #define in_single (parser->in_single)
581 #define in_def (parser->in_def)
582 #define in_main (parser->in_main)
583 #define in_defined (parser->in_defined)
584 #define tokenbuf (parser->tokenbuf)
585 #define tokidx (parser->tokidx)
586 #define toksiz (parser->toksiz)
587 #define tokline (parser->tokline)
588 #define lex_input (parser->lex.input)
589 #define lex_lastline (parser->lex.lastline)
590 #define lex_nextline (parser->lex.nextline)
591 #define lex_pbeg (parser->lex.pbeg)
592 #define lex_p (parser->lex.pcur)
593 #define lex_pend (parser->lex.pend)
594 #define heredoc_end (parser->heredoc_end)
595 #define heredoc_indent (parser->heredoc_indent)
596 #define heredoc_line_indent (parser->heredoc_line_indent)
597 #define command_start (parser->command_start)
598 #define lex_gets_ptr (parser->lex.gets_ptr)
599 #define lex_gets (parser->lex.gets)
600 #define lvtbl (parser->lvtbl)
601 #define ruby__end__seen (parser->ruby__end__seen)
602 #define ruby_sourceline (parser->ruby_sourceline)
603 #define ruby_sourcefile (parser->ruby_sourcefile)
604 #define ruby_sourcefile_string (parser->ruby_sourcefile_string)
605 #define current_enc (parser->enc)
606 #define current_arg (parser->cur_arg)
607 #define yydebug (parser->yydebug)
608 #ifdef RIPPER
609 #define compile_for_eval (0)
610 #else
611 #define compile_for_eval (parser->base_block != 0 && !in_main)
612 #define ruby_eval_tree (parser->eval_tree)
613 #define ruby_eval_tree_begin (parser->eval_tree_begin)
614 #define ruby_debug_lines (parser->debug_lines)
615 #define ruby_coverage (parser->coverage)
616 #endif
617 #define tokp lex.ptok
618 
619 #define token_column ((int)(parser->tokp - lex_pbeg))
620 
621 #define CALL_Q_P(q) ((q) == TOKEN2VAL(tANDDOT))
622 #define NODE_CALL_Q(q) (CALL_Q_P(q) ? NODE_QCALL : NODE_CALL)
623 #define NEW_QCALL(q,r,m,a) NEW_NODE(NODE_CALL_Q(q),r,m,a)
624 
625 #define lambda_beginning_p() (lpar_beg && lpar_beg == paren_nest)
626 
627 static enum yytokentype yylex(YYSTYPE*, YYLTYPE*, struct parser_params*);
628 
629 static inline void
630 parser_set_line(NODE *n, int l)
631 {
632  nd_set_line(n, l);
633 }
634 
635 #ifndef RIPPER
636 static inline void
637 set_line_body(NODE *body, int line)
638 {
639  if (!body) return;
640  switch (nd_type(body)) {
641  case NODE_RESCUE:
642  case NODE_ENSURE:
643  nd_set_line(body, line);
644  }
645 }
646 
647 #define yyparse ruby_yyparse
648 
649 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
650 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
651 
652 static NODE *cond_gen(struct parser_params*,NODE*,int,int);
653 #define cond(node,column) cond_gen(parser, (node), FALSE, column)
654 #define method_cond(node,column) cond_gen(parser, (node), TRUE, column)
655 #define new_nil() NEW_NIL()
656 static NODE *new_if_gen(struct parser_params*,NODE*,NODE*,NODE*,int);
657 #define new_if(cc,left,right,column) new_if_gen(parser, (cc), (left), (right), (column))
658 static NODE *new_unless_gen(struct parser_params*,NODE*,NODE*,NODE*,int);
659 #define new_unless(cc,left,right,column) new_unless_gen(parser, (cc), (left), (right), (column))
660 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*,int);
661 #define logop(id,node1,node2,column) \
662  logop_gen(parser, ((id)==idAND||(id)==idANDOP)?NODE_AND:NODE_OR, \
663  (node1), (node2), (column))
664 
665 static NODE *newline_node(NODE*);
666 static void fixpos(NODE*,NODE*);
667 
668 static int value_expr_gen(struct parser_params*,NODE*);
669 static void void_expr_gen(struct parser_params*,NODE*);
670 static NODE *remove_begin(NODE*);
671 static NODE *remove_begin_all(NODE*);
672 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
673 #define void_expr0(node) void_expr_gen(parser, (node))
674 #define void_expr(node) void_expr0((node) = remove_begin(node))
675 static void void_stmts_gen(struct parser_params*,NODE*);
676 #define void_stmts(node) void_stmts_gen(parser, (node))
677 static void reduce_nodes_gen(struct parser_params*,NODE**);
678 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
679 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
680 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
681 
682 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*,int);
683 #define block_append(h,t,column) block_append_gen(parser,(h),(t),(column))
684 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*,int);
685 #define list_append(l,i,column) list_append_gen(parser,(l),(i),(column))
686 static NODE *list_concat(NODE*,NODE*);
687 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*,int);
688 #define arg_append(h,t,column) arg_append_gen(parser,(h),(t),(column))
689 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*,int);
690 #define arg_concat(h,t,column) arg_concat_gen(parser,(h),(t),(column))
691 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*,int);
692 #define literal_concat(h,t,column) literal_concat_gen(parser,(h),(t),(column))
693 static int literal_concat0(struct parser_params *, VALUE, VALUE);
694 static NODE *new_evstr_gen(struct parser_params*,NODE*,int);
695 #define new_evstr(n, column) new_evstr_gen(parser,(n),(column))
696 static NODE *evstr2dstr_gen(struct parser_params*,NODE*,int);
697 #define evstr2dstr(n,column) evstr2dstr_gen(parser,(n),(column))
698 static NODE *splat_array(NODE*);
699 
700 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*,int);
701 #define call_bin_op(recv,id,arg1,column) call_bin_op_gen(parser, (recv),(id),(arg1),(column))
702 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID,int);
703 #define call_uni_op(recv,id,column) call_uni_op_gen(parser, (recv),(id),(column))
704 static NODE *new_qcall_gen(struct parser_params* parser, ID atype, NODE *recv, ID mid, NODE *args, int column);
705 #define new_qcall(q,r,m,a,column) new_qcall_gen(parser,q,r,m,a,column)
706 #define new_command_qcall(q,r,m,a,column) new_qcall_gen(parser,q,r,m,a,column)
707 static NODE *new_command_gen(struct parser_params*parser, NODE *m, NODE *a) {m->nd_args = a; return m;}
708 #define new_command(m,a) new_command_gen(parser, m, a)
709 static NODE *method_add_block_gen(struct parser_params*parser, NODE *m, NODE *b) {b->nd_iter = m; return b;}
710 #define method_add_block(m,b) method_add_block_gen(parser, m, b)
711 
712 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
713 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
714 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID,int);
715 #define new_args_tail(k,kr,b,column) new_args_tail_gen(parser, (k),(kr),(b),(column))
716 static NODE *new_kw_arg_gen(struct parser_params *parser, NODE *k, int column);
717 #define new_kw_arg(k,column) new_kw_arg_gen(parser, k, column)
718 
719 static VALUE negate_lit_gen(struct parser_params*, VALUE);
720 #define negate_lit(lit) negate_lit_gen(parser, lit)
721 static NODE *ret_args_gen(struct parser_params*,NODE*);
722 #define ret_args(node) ret_args_gen(parser, (node))
723 static NODE *arg_blk_pass(NODE*,NODE*);
724 static NODE *new_yield_gen(struct parser_params*,NODE*,int);
725 #define new_yield(node,column) new_yield_gen(parser, (node), (column))
726 static NODE *dsym_node_gen(struct parser_params*,NODE*,int);
727 #define dsym_node(node,column) dsym_node_gen(parser, (node), (column))
728 
729 static NODE *gettable_gen(struct parser_params*,ID,int);
730 #define gettable(id,column) gettable_gen(parser,(id),(column))
731 static NODE *assignable_gen(struct parser_params*,ID,NODE*,int);
732 #define assignable(id,node,column) assignable_gen(parser, (id), (node), (column))
733 
734 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*,int);
735 #define aryset(node1,node2,column) aryset_gen(parser, (node1), (node2), (column))
736 static NODE *attrset_gen(struct parser_params*,NODE*,ID,ID,int);
737 #define attrset(node,q,id,column) attrset_gen(parser, (node), (q), (id), (column))
738 
739 static void rb_backref_error_gen(struct parser_params*,NODE*);
740 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
741 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*,int);
742 #define node_assign(node1, node2, column) node_assign_gen(parser, (node1), (node2), (column))
743 
744 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs, int column);
745 #define new_op_assign(lhs, op, rhs, column) new_op_assign_gen(parser, (lhs), (op), (rhs), (column))
746 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID atype, ID attr, ID op, NODE *rhs, int column);
747 #define new_attr_op_assign(lhs, type, attr, op, rhs, column) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs), (column))
748 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs, int column);
749 #define new_const_op_assign(lhs, op, rhs, column) new_const_op_assign_gen(parser, (lhs), (op), (rhs), (column))
750 
751 static NODE *const_path_field_gen(struct parser_params *parser, NODE *head, ID mid, int column);
752 #define const_path_field(w, n, column) const_path_field_gen(parser, w, n, column)
753 #define top_const_field(n) NEW_COLON3(n)
754 static NODE *const_decl_gen(struct parser_params *parser, NODE* path, int column);
755 #define const_decl(path, column) const_decl_gen(parser, path, column)
756 
757 #define var_field(n) (n)
758 #define backref_assign_error(n, a, column) (rb_backref_error(n), new_begin(0, column))
759 
760 static NODE *kwd_append(NODE*, NODE*);
761 
762 static NODE *new_hash_gen(struct parser_params *parser, NODE *hash, int column);
763 #define new_hash(hash, column) new_hash_gen(parser, (hash), column)
764 
765 static NODE *new_defined_gen(struct parser_params *parser, NODE *expr, int column);
766 #define new_defined(expr, column) new_defined_gen(parser, expr, column)
767 
768 static NODE *new_regexp_gen(struct parser_params *, NODE *, int, int);
769 #define new_regexp(node, opt, column) new_regexp_gen(parser, node, opt, column)
770 
771 static NODE *new_lit_gen(struct parser_params *parser, VALUE sym, int column);
772 #define new_lit(sym, column) new_lit_gen(parser, sym, column)
773 
774 static NODE *new_list_gen(struct parser_params *parser, NODE *item, int column);
775 #define new_list(item, column) new_list_gen(parser, item, column)
776 
777 static NODE *new_str_gen(struct parser_params *parser, VALUE str, int column);
778 #define new_str(s,column) new_str_gen(parser, s, column)
779 
780 static NODE *new_dvar_gen(struct parser_params *parser, ID id, int column);
781 #define new_dvar(id, column) new_dvar_gen(parser, id, column)
782 
783 static NODE *new_resbody_gen(struct parser_params *parser, NODE *exc_list, NODE *stmt, NODE *rescue, int column);
784 #define new_resbody(e,s,r,column) new_resbody_gen(parser, (e),(s),(r),(column))
785 
786 static NODE *new_errinfo_gen(struct parser_params *parser, int column);
787 #define new_errinfo(column) new_errinfo_gen(parser, column)
788 
789 static NODE *new_call_gen(struct parser_params *parser, NODE *recv, ID mid, NODE *args, int column);
790 #define new_call(recv,mid,args,column) new_call_gen(parser, recv,mid,args,column)
791 
792 static NODE *new_fcall_gen(struct parser_params *parser, ID mid, NODE *args, int column);
793 #define new_fcall(mid,args,column) new_fcall_gen(parser, mid, args, column)
794 
795 static NODE *new_for_gen(struct parser_params *parser, NODE *var, NODE *iter, NODE *body, int column);
796 #define new_for(var,iter,body,column) new_for_gen(parser, var, iter, body, column)
797 
798 static NODE *new_gvar_gen(struct parser_params *parser, ID id, int column);
799 #define new_gvar(id, column) new_gvar_gen(parser, id, column)
800 
801 static NODE *new_lvar_gen(struct parser_params *parser, ID id, int column);
802 #define new_lvar(id, column) new_lvar_gen(parser, id, column)
803 
804 static NODE *new_dstr_gen(struct parser_params *parser, VALUE str, int column);
805 #define new_dstr(s, column) new_dstr_gen(parser, s, column)
806 
807 static NODE *new_rescue_gen(struct parser_params *parser, NODE *b, NODE *res, NODE *e, int column);
808 #define new_rescue(b,res,e,column) new_rescue_gen(parser,b,res,e,column)
809 
810 static NODE *new_undef_gen(struct parser_params *parser, NODE *i, int column);
811 #define new_undef(i, column) new_undef_gen(parser, i, column)
812 
813 static NODE *new_zarray_gen(struct parser_params *parser, int column);
814 #define new_zarray(column) new_zarray_gen(parser, column)
815 
816 static NODE *new_ivar_gen(struct parser_params *parser, ID id, int column);
817 #define new_ivar(id, column) new_ivar_gen(parser,id,column)
818 
819 static NODE *new_postarg_gen(struct parser_params *parser, NODE *i, NODE *v, int column);
820 #define new_postarg(i,v,column) new_postarg_gen(parser,i,v,column)
821 
822 static NODE *new_cdecl_gen(struct parser_params *parser, ID v, NODE *val, NODE *path, int column);
823 #define new_cdecl(v,val,path,column) new_cdecl_gen(parser,v,val,path,column)
824 
825 static NODE *new_scope_gen(struct parser_params *parser, NODE *a, NODE *b, int column);
826 #define new_scope(a,b,column) new_scope_gen(parser,a,b,column)
827 
828 static NODE *new_begin_gen(struct parser_params *parser, NODE *b, int column);
829 #define new_begin(b,column) new_begin_gen(parser,b,column)
830 
831 static NODE *new_masgn_gen(struct parser_params *parser, NODE *l, NODE *r, int column);
832 #define new_masgn(l,r,column) new_masgn_gen(parser,l,r,column)
833 
834 static NODE *new_xstring_gen(struct parser_params *, NODE *, int column);
835 #define new_xstring(node, column) new_xstring_gen(parser, node, column)
836 #define new_string1(str) (str)
837 
838 static NODE *new_body_gen(struct parser_params *parser, NODE *param, NODE *stmt, int column);
839 #define new_brace_body(param, stmt, column) new_body_gen(parser, param, stmt, column)
840 #define new_do_body(param, stmt, column) new_body_gen(parser, param, stmt, column)
841 
842 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*,int);
843 #define match_op(node1,node2,column) match_op_gen(parser, (node1), (node2), (column))
844 
845 static ID *local_tbl_gen(struct parser_params*);
846 #define local_tbl() local_tbl_gen(parser)
847 
848 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
849 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
850 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
851 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
852 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
853 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
854 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, int column);
855 #define reg_named_capture_assign(regexp,column) reg_named_capture_assign_gen(parser,(regexp),column)
856 
857 static NODE *parser_heredoc_dedent(struct parser_params*,NODE*);
858 # define heredoc_dedent(str) parser_heredoc_dedent(parser, (str))
859 
860 #define get_id(id) (id)
861 #define get_value(val) (val)
862 #else /* RIPPER */
863 #define NODE_RIPPER NODE_CDECL
864 
865 static inline VALUE
866 ripper_new_yylval(ID a, VALUE b, VALUE c)
867 {
868  return (VALUE)NEW_CDECL(a, b, c);
869 }
870 
871 static inline int
872 ripper_is_node_yylval(VALUE n)
873 {
874  return RB_TYPE_P(n, T_NODE) && nd_type(RNODE(n)) == NODE_RIPPER;
875 }
876 
877 #define value_expr(node) ((void)(node))
878 #define remove_begin(node) (node)
879 #define rb_dvar_defined(id, base) 0
880 #define rb_local_defined(id, base) 0
881 static ID ripper_get_id(VALUE);
882 #define get_id(id) ripper_get_id(id)
883 static VALUE ripper_get_value(VALUE);
884 #define get_value(val) ripper_get_value(val)
885 static VALUE assignable_gen(struct parser_params*,VALUE);
886 #define assignable(lhs,node,column) assignable_gen(parser, (lhs))
887 static int id_is_var_gen(struct parser_params *parser, ID id);
888 #define id_is_var(id) id_is_var_gen(parser, (id))
889 
890 #define method_cond(node,column) (node)
891 #define call_bin_op(recv,id,arg1,column) dispatch3(binary, (recv), STATIC_ID2SYM(id), (arg1))
892 #define match_op(node1,node2,column) call_bin_op((node1), idEqTilde, (node2), -1)
893 #define call_uni_op(recv,id,column) dispatch2(unary, STATIC_ID2SYM(id), (recv))
894 #define logop(id,node1,node2,column) call_bin_op((node1), (id), (node2), -1)
895 #define node_assign(node1, node2, column) dispatch2(assign, (node1), (node2))
896 static VALUE new_qcall_gen(struct parser_params *parser, VALUE q, VALUE r, VALUE m, VALUE a);
897 #define new_qcall(q,r,m,a,column) new_qcall_gen(parser, (r), (q), (m), (a))
898 #define new_command_qcall(q,r,m,a,column) dispatch4(command_call, (r), (q), (m), (a))
899 #define new_command_call(q,r,m,a) dispatch4(command_call, (r), (q), (m), (a))
900 #define new_command(m,a) dispatch2(command, (m), (a));
901 
902 #define new_nil() Qnil
903 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs, int column);
904 #define new_op_assign(lhs, op, rhs, column) new_op_assign_gen(parser, (lhs), (op), (rhs), (column))
905 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);
906 #define new_attr_op_assign(lhs, type, attr, op, rhs, column) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
907 #define new_const_op_assign(lhs, op, rhs, column) new_op_assign(lhs, op, rhs, column)
908 
909 static VALUE new_regexp_gen(struct parser_params *, VALUE, VALUE);
910 #define new_regexp(node, opt, column) new_regexp_gen(parser, node, opt)
911 
912 static VALUE new_xstring_gen(struct parser_params *, VALUE);
913 #define new_xstring(str, column) new_xstring_gen(parser, str)
914 #define new_string1(str) dispatch1(string_literal, str)
915 
916 #define new_brace_body(param, stmt, column) dispatch2(brace_block, escape_Qundef(param), stmt)
917 #define new_do_body(param, stmt, column) dispatch2(do_block, escape_Qundef(param), stmt)
918 
919 #define const_path_field(w, n, column) dispatch2(const_path_field, (w), (n))
920 #define top_const_field(n) dispatch1(top_const_field, (n))
921 static VALUE const_decl_gen(struct parser_params *parser, VALUE path);
922 #define const_decl(path, column) const_decl_gen(parser, path)
923 
924 static VALUE var_field_gen(struct parser_params *parser, VALUE a);
925 #define var_field(a) var_field_gen(parser, (a))
926 static VALUE assign_error_gen(struct parser_params *parser, VALUE a);
927 #define assign_error(a) assign_error_gen(parser, (a))
928 #define backref_assign_error(n, a, column) assign_error(a)
929 
930 #define block_dup_check(n1,n2) ((void)(n1), (void)(n2))
931 #define fixpos(n1,n2) ((void)(n1), (void)(n2))
932 #undef nd_set_line
933 #define nd_set_line(n,l) ((void)(n))
934 
935 static VALUE parser_reg_compile(struct parser_params*, VALUE, int, VALUE *);
936 
937 #endif /* !RIPPER */
938 
939 RUBY_SYMBOL_EXPORT_BEGIN
940 VALUE rb_parser_reg_compile(struct parser_params* parser, VALUE str, int options);
941 int rb_reg_fragment_setenc(struct parser_params*, VALUE, int);
942 enum lex_state_e rb_parser_trace_lex_state(struct parser_params *, enum lex_state_e, enum lex_state_e, int);
943 VALUE rb_parser_lex_state_name(enum lex_state_e state);
944 void rb_parser_show_bitstack(struct parser_params *, stack_type, const char *, int);
945 PRINTF_ARGS(void rb_parser_fatal(struct parser_params *parser, const char *fmt, ...), 2, 3);
946 RUBY_SYMBOL_EXPORT_END
947 
948 static ID formal_argument_gen(struct parser_params*, ID);
949 #define formal_argument(id) formal_argument_gen(parser, (id))
950 static ID shadowing_lvar_gen(struct parser_params*,ID);
951 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
952 static void new_bv_gen(struct parser_params*,ID);
953 #define new_bv(id) new_bv_gen(parser, (id))
954 
955 static void local_push_gen(struct parser_params*,int);
956 #define local_push(top) local_push_gen(parser,(top))
957 static void local_pop_gen(struct parser_params*);
958 #define local_pop() local_pop_gen(parser)
959 static void local_var_gen(struct parser_params*, ID);
960 #define local_var(id) local_var_gen(parser, (id))
961 static void arg_var_gen(struct parser_params*, ID);
962 #define arg_var(id) arg_var_gen(parser, (id))
963 static int local_id_gen(struct parser_params*, ID, ID **);
964 #define local_id_ref(id, vidp) local_id_gen(parser, (id), &(vidp))
965 #define local_id(id) local_id_gen(parser, (id), NULL)
966 static ID internal_id_gen(struct parser_params*);
967 #define internal_id() internal_id_gen(parser)
968 
969 static const struct vtable *dyna_push_gen(struct parser_params *);
970 #define dyna_push() dyna_push_gen(parser)
971 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
972 #define dyna_pop(node) dyna_pop_gen(parser, (node))
973 static int dyna_in_block_gen(struct parser_params*);
974 #define dyna_in_block() dyna_in_block_gen(parser)
975 #define dyna_var(id) local_var(id)
976 static int dvar_defined_gen(struct parser_params*, ID, ID**);
977 #define dvar_defined_ref(id, vidp) dvar_defined_gen(parser, (id), &(vidp))
978 #define dvar_defined(id) dvar_defined_gen(parser, (id), NULL)
979 static int dvar_curr_gen(struct parser_params*,ID);
980 #define dvar_curr(id) dvar_curr_gen(parser, (id))
981 
982 static int lvar_defined_gen(struct parser_params*, ID);
983 #define lvar_defined(id) lvar_defined_gen(parser, (id))
984 
985 #ifdef RIPPER
986 # define METHOD_NOT idNOT
987 #else
988 # define METHOD_NOT '!'
989 #endif
990 
991 #define RE_OPTION_ONCE (1<<16)
992 #define RE_OPTION_ENCODING_SHIFT 8
993 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
994 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
995 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
996 #define RE_OPTION_MASK 0xff
997 #define RE_OPTION_ARG_ENCODING_NONE 32
998 
999 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
1000 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
1001 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
1002 #define nd_func u1.id
1003 #if SIZEOF_SHORT == 2
1004 #define nd_term(node) ((signed short)(node)->u2.id)
1005 #else
1006 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
1007 #endif
1008 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
1009 #define nd_nest u3.cnt
1010 
1011 #define TOKEN2ID(tok) ( \
1012  tTOKEN_LOCAL_BEGIN<(tok)&&(tok)<tTOKEN_LOCAL_END ? TOKEN2LOCALID(tok) : \
1013  tTOKEN_INSTANCE_BEGIN<(tok)&&(tok)<tTOKEN_INSTANCE_END ? TOKEN2INSTANCEID(tok) : \
1014  tTOKEN_GLOBAL_BEGIN<(tok)&&(tok)<tTOKEN_GLOBAL_END ? TOKEN2GLOBALID(tok) : \
1015  tTOKEN_CONST_BEGIN<(tok)&&(tok)<tTOKEN_CONST_END ? TOKEN2CONSTID(tok) : \
1016  tTOKEN_CLASS_BEGIN<(tok)&&(tok)<tTOKEN_CLASS_END ? TOKEN2CLASSID(tok) : \
1017  tTOKEN_ATTRSET_BEGIN<(tok)&&(tok)<tTOKEN_ATTRSET_END ? TOKEN2ATTRSETID(tok) : \
1018  ((tok) / ((tok)<tPRESERVED_ID_END && ((tok)>=128 || rb_ispunct(tok)))))
1019 
1020 /****** Ripper *******/
1021 
1022 #ifdef RIPPER
1023 #define RIPPER_VERSION "0.1.0"
1024 
1025 static inline VALUE intern_sym(const char *name);
1026 
1027 #include "eventids1.c"
1028 #include "eventids2.c"
1029 
1030 static VALUE ripper_dispatch0(struct parser_params*,ID);
1031 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
1032 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
1033 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
1034 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
1035 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
1036 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
1037 static void ripper_error_gen(struct parser_params *parser);
1038 #define ripper_error() ripper_error_gen(parser)
1039 
1040 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
1041 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
1042 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
1043 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
1044 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
1045 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
1046 #define dispatch7(n,a,b,c,d,e,f,g) ripper_dispatch7(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e), (f), (g))
1047 
1048 #define yyparse ripper_yyparse
1049 
1050 #define ID2VAL(id) STATIC_ID2SYM(id)
1051 #define TOKEN2VAL(t) ID2VAL(TOKEN2ID(t))
1052 #define KWD2EID(t, v) ripper_new_yylval(keyword_##t, get_value(v), 0)
1053 
1054 #define arg_new() dispatch0(args_new)
1055 #define arg_add(l,a) dispatch2(args_add, (l), (a))
1056 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
1057 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
1058 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
1059 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
1060 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
1061 
1062 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
1063 #define mrhs_new() dispatch0(mrhs_new)
1064 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
1065 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
1066 
1067 #define mlhs_new() dispatch0(mlhs_new)
1068 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
1069 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
1070 #define mlhs_add_post(l,a) dispatch2(mlhs_add_post, (l), (a))
1071 
1072 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
1073  dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
1074 
1075 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
1076 
1077 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
1078 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
1079 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
1080 
1081 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
1082 
1083 static inline VALUE
1084 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
1085 {
1086  NODE *t = (NODE *)tail;
1087  VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
1088  return params_new(f, o, r, p, k, kr, escape_Qundef(b));
1089 }
1090 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
1091 
1092 static inline VALUE
1093 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
1094 {
1095  return (VALUE)MEMO_NEW(k, kr, b);
1096 }
1097 #define new_args_tail(k,kr,b,column) new_args_tail_gen(parser, (k),(kr),(b))
1098 
1099 #define new_defined(expr,column) dispatch1(defined, (expr))
1100 
1101 static VALUE parser_heredoc_dedent(struct parser_params*,VALUE);
1102 # define heredoc_dedent(str) parser_heredoc_dedent(parser, (str))
1103 
1104 #define FIXME 0
1105 
1106 #else
1107 #define ID2VAL(id) ((VALUE)(id))
1108 #define TOKEN2VAL(t) ID2VAL(t)
1109 #define KWD2EID(t, v) keyword_##t
1110 #endif /* RIPPER */
1111 
1112 #ifndef RIPPER
1113 # define Qnone 0
1114 # define Qnull 0
1115 # define ifndef_ripper(x) (x)
1116 #else
1117 # define Qnone Qnil
1118 # define Qnull Qundef
1119 # define ifndef_ripper(x)
1120 #endif
1121 
1122 # define rb_warn0(fmt) WARN_CALL(WARN_ARGS(fmt, 1))
1123 # define rb_warn1(fmt,a) WARN_CALL(WARN_ARGS(fmt, 2), (a))
1124 # define rb_warn2(fmt,a,b) WARN_CALL(WARN_ARGS(fmt, 3), (a), (b))
1125 # define rb_warn3(fmt,a,b,c) WARN_CALL(WARN_ARGS(fmt, 4), (a), (b), (c))
1126 # define rb_warn4(fmt,a,b,c,d) WARN_CALL(WARN_ARGS(fmt, 5), (a), (b), (c), (d))
1127 # define rb_warning0(fmt) WARNING_CALL(WARNING_ARGS(fmt, 1))
1128 # define rb_warning1(fmt,a) WARNING_CALL(WARNING_ARGS(fmt, 2), (a))
1129 # define rb_warning2(fmt,a,b) WARNING_CALL(WARNING_ARGS(fmt, 3), (a), (b))
1130 # define rb_warning3(fmt,a,b,c) WARNING_CALL(WARNING_ARGS(fmt, 4), (a), (b), (c))
1131 # define rb_warning4(fmt,a,b,c,d) WARNING_CALL(WARNING_ARGS(fmt, 5), (a), (b), (c), (d))
1132 # define rb_warn0L(l,fmt) WARN_CALL(WARN_ARGS_L(l, fmt, 1))
1133 # define rb_warn1L(l,fmt,a) WARN_CALL(WARN_ARGS_L(l, fmt, 2), (a))
1134 # define rb_warn2L(l,fmt,a,b) WARN_CALL(WARN_ARGS_L(l, fmt, 3), (a), (b))
1135 # define rb_warn3L(l,fmt,a,b,c) WARN_CALL(WARN_ARGS_L(l, fmt, 4), (a), (b), (c))
1136 # define rb_warn4L(l,fmt,a,b,c,d) WARN_CALL(WARN_ARGS_L(l, fmt, 5), (a), (b), (c), (d))
1137 # define rb_warning0L(l,fmt) WARNING_CALL(WARNING_ARGS_L(l, fmt, 1))
1138 # define rb_warning1L(l,fmt,a) WARNING_CALL(WARNING_ARGS_L(l, fmt, 2), (a))
1139 # define rb_warning2L(l,fmt,a,b) WARNING_CALL(WARNING_ARGS_L(l, fmt, 3), (a), (b))
1140 # define rb_warning3L(l,fmt,a,b,c) WARNING_CALL(WARNING_ARGS_L(l, fmt, 4), (a), (b), (c))
1141 # define rb_warning4L(l,fmt,a,b,c,d) WARNING_CALL(WARNING_ARGS_L(l, fmt, 5), (a), (b), (c), (d))
1142 #ifdef RIPPER
1143 static ID id_warn, id_warning, id_gets;
1144 # define WARN_S_L(s,l) STR_NEW(s,l)
1145 # define WARN_S(s) STR_NEW2(s)
1146 # define WARN_I(i) INT2NUM(i)
1147 # define WARN_ID(i) rb_id2str(i)
1148 # define PRIsWARN "s"
1149 # define WARN_ARGS(fmt,n) parser->value, id_warn, n, rb_usascii_str_new_lit(fmt)
1150 # define WARN_ARGS_L(l,fmt,n) WARN_ARGS(fmt,n)
1151 # ifdef HAVE_VA_ARGS_MACRO
1152 # define WARN_CALL(...) rb_funcall(__VA_ARGS__)
1153 # else
1154 # define WARN_CALL rb_funcall
1155 # endif
1156 # define WARNING_ARGS(fmt,n) parser->value, id_warning, n, rb_usascii_str_new_lit(fmt)
1157 # define WARNING_ARGS_L(l, fmt,n) WARNING_ARGS(fmt,n)
1158 # ifdef HAVE_VA_ARGS_MACRO
1159 # define WARNING_CALL(...) rb_funcall(__VA_ARGS__)
1160 # else
1161 # define WARNING_CALL rb_funcall
1162 # endif
1163 PRINTF_ARGS(static void ripper_compile_error(struct parser_params*, const char *fmt, ...), 2, 3);
1164 # define compile_error ripper_compile_error
1165 # define PARSER_ARG parser,
1166 #else
1167 # define WARN_S_L(s,l) s
1168 # define WARN_S(s) s
1169 # define WARN_I(i) i
1170 # define WARN_ID(i) rb_id2name(i)
1171 # define PRIsWARN PRIsVALUE
1172 # define WARN_ARGS(fmt,n) WARN_ARGS_L(ruby_sourceline,fmt,n)
1173 # define WARN_ARGS_L(l,fmt,n) ruby_sourcefile, (l), (fmt)
1174 # define WARN_CALL rb_compile_warn
1175 # define WARNING_ARGS(fmt,n) WARN_ARGS(fmt,n)
1176 # define WARNING_ARGS_L(l,fmt,n) WARN_ARGS_L(l,fmt,n)
1177 # define WARNING_CALL rb_compile_warning
1178 PRINTF_ARGS(static void parser_compile_error(struct parser_params*, const char *fmt, ...), 2, 3);
1179 # define compile_error parser_compile_error
1180 # define PARSER_ARG parser,
1181 #endif
1182 
1183 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
1184  for instance). This is too low for Ruby to parse some files, such as
1185  date/format.rb, therefore bump the value up to at least Bison's default. */
1186 #ifdef OLD_YACC
1187 #ifndef YYMAXDEPTH
1188 #define YYMAXDEPTH 10000
1189 #endif
1190 #endif
1191 
1192 static void token_info_push_gen(struct parser_params*, const char *token, size_t len);
1193 static void token_info_pop_gen(struct parser_params*, const char *token, size_t len);
1194 #define token_info_push(token) token_info_push_gen(parser, (token), rb_strlen_lit(token))
1195 #define token_info_pop(token) token_info_pop_gen(parser, (token), rb_strlen_lit(token))
1196 
1197 
1198 /* Enabling traces. */
1199 #ifndef YYDEBUG
1200 # define YYDEBUG 1
1201 #endif
1202 
1203 /* Enabling verbose error messages. */
1204 #ifdef YYERROR_VERBOSE
1205 # undef YYERROR_VERBOSE
1206 # define YYERROR_VERBOSE 1
1207 #else
1208 # define YYERROR_VERBOSE 0
1209 #endif
1210 
1211 /* Enabling the token table. */
1212 #ifndef YYTOKEN_TABLE
1213 # define YYTOKEN_TABLE 0
1214 #endif
1215 
1216 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1217 typedef union YYSTYPE
1218 #line 902 "ripper.y"
1219 {
1220  VALUE val;
1221  NODE *node;
1222  ID id;
1223  int num;
1224  const struct vtable *vars;
1225 }
1226 /* Line 193 of yacc.c. */
1227 #line 1228 "ripper.c"
1228  YYSTYPE;
1229 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1230 # define YYSTYPE_IS_DECLARED 1
1231 # define YYSTYPE_IS_TRIVIAL 1
1232 #endif
1233 
1234 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
1235 typedef struct YYLTYPE
1236 {
1237  int first_line;
1238  int first_column;
1239  int last_line;
1240  int last_column;
1241 } YYLTYPE;
1242 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1243 # define YYLTYPE_IS_DECLARED 1
1244 # define YYLTYPE_IS_TRIVIAL 1
1245 #endif
1246 
1247 
1248 /* Copy the second part of user declarations. */
1249 
1250 
1251 /* Line 216 of yacc.c. */
1252 #line 1253 "ripper.c"
1253 
1254 #ifdef short
1255 # undef short
1256 #endif
1257 
1258 #ifdef YYTYPE_UINT8
1259 typedef YYTYPE_UINT8 yytype_uint8;
1260 #else
1261 typedef unsigned char yytype_uint8;
1262 #endif
1263 
1264 #ifdef YYTYPE_INT8
1265 typedef YYTYPE_INT8 yytype_int8;
1266 #elif (defined __STDC__ || defined __C99__FUNC__ \
1267  || defined __cplusplus || defined _MSC_VER)
1268 typedef signed char yytype_int8;
1269 #else
1270 typedef short int yytype_int8;
1271 #endif
1272 
1273 #ifdef YYTYPE_UINT16
1274 typedef YYTYPE_UINT16 yytype_uint16;
1275 #else
1276 typedef unsigned short int yytype_uint16;
1277 #endif
1278 
1279 #ifdef YYTYPE_INT16
1280 typedef YYTYPE_INT16 yytype_int16;
1281 #else
1282 typedef short int yytype_int16;
1283 #endif
1284 
1285 #ifndef YYSIZE_T
1286 # ifdef __SIZE_TYPE__
1287 # define YYSIZE_T __SIZE_TYPE__
1288 # elif defined size_t
1289 # define YYSIZE_T size_t
1290 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
1291  || defined __cplusplus || defined _MSC_VER)
1292 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1293 # define YYSIZE_T size_t
1294 # else
1295 # define YYSIZE_T unsigned int
1296 # endif
1297 #endif
1298 
1299 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
1300 
1301 #ifndef YY_
1302 # if defined YYENABLE_NLS && YYENABLE_NLS
1303 # if ENABLE_NLS
1304 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
1305 # define YY_(msgid) dgettext ("bison-runtime", msgid)
1306 # endif
1307 # endif
1308 # ifndef YY_
1309 # define YY_(msgid) msgid
1310 # endif
1311 #endif
1312 
1313 /* Suppress unused-variable warnings by "using" E. */
1314 #if ! defined lint || defined __GNUC__
1315 # define YYUSE(e) ((void) (e))
1316 #else
1317 # define YYUSE(e) /* empty */
1318 #endif
1319 
1320 /* Identity function, used to suppress warnings about constant conditions. */
1321 #ifndef lint
1322 # define YYID(n) (n)
1323 #else
1324 #if (defined __STDC__ || defined __C99__FUNC__ \
1325  || defined __cplusplus || defined _MSC_VER)
1326 static int
1327 YYID (int i)
1328 #else
1329 static int
1330 YYID (i)
1331  int i;
1332 #endif
1333 {
1334  return i;
1335 }
1336 #endif
1337 
1338 #if ! defined yyoverflow || YYERROR_VERBOSE
1339 
1340 /* The parser invokes alloca or malloc; define the necessary symbols. */
1341 
1342 # ifdef YYSTACK_USE_ALLOCA
1343 # if YYSTACK_USE_ALLOCA
1344 # ifdef __GNUC__
1345 # define YYSTACK_ALLOC __builtin_alloca
1346 # elif defined __BUILTIN_VA_ARG_INCR
1347 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1348 # elif defined _AIX
1349 # define YYSTACK_ALLOC __alloca
1350 # elif defined _MSC_VER
1351 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1352 # define alloca _alloca
1353 # else
1354 # define YYSTACK_ALLOC alloca
1355 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1356  || defined __cplusplus || defined _MSC_VER)
1357 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1358 # ifndef _STDLIB_H
1359 # define _STDLIB_H 1
1360 # endif
1361 # endif
1362 # endif
1363 # endif
1364 # endif
1365 
1366 # ifdef YYSTACK_ALLOC
1367  /* Pacify GCC's `empty if-body' warning. */
1368 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1369 # ifndef YYSTACK_ALLOC_MAXIMUM
1370  /* The OS might guarantee only one guard page at the bottom of the stack,
1371  and a page size can be as small as 4096 bytes. So we cannot safely
1372  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1373  to allow for a few compiler-allocated temporary stack slots. */
1374 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1375 # endif
1376 # else
1377 # define YYSTACK_ALLOC YYMALLOC
1378 # define YYSTACK_FREE YYFREE
1379 # ifndef YYSTACK_ALLOC_MAXIMUM
1380 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1381 # endif
1382 # if (defined __cplusplus && ! defined _STDLIB_H \
1383  && ! ((defined YYMALLOC || defined malloc) \
1384  && (defined YYFREE || defined free)))
1385 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1386 # ifndef _STDLIB_H
1387 # define _STDLIB_H 1
1388 # endif
1389 # endif
1390 # ifndef YYMALLOC
1391 # define YYMALLOC malloc
1392 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1393  || defined __cplusplus || defined _MSC_VER)
1394 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1395 # endif
1396 # endif
1397 # ifndef YYFREE
1398 # define YYFREE free
1399 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1400  || defined __cplusplus || defined _MSC_VER)
1401 void free (void *); /* INFRINGES ON USER NAME SPACE */
1402 # endif
1403 # endif
1404 # endif
1405 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1406 
1407 
1408 #if (! defined yyoverflow \
1409  && (! defined __cplusplus \
1410  || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
1411  && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1412 
1413 /* A type that is properly aligned for any stack member. */
1414 union yyalloc
1415 {
1416  yytype_int16 yyss;
1417  YYSTYPE yyvs;
1418  YYLTYPE yyls;
1419 };
1420 
1421 /* The size of the maximum gap between one aligned stack and the next. */
1422 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1423 
1424 /* The size of an array large to enough to hold all stacks, each with
1425  N elements. */
1426 # define YYSTACK_BYTES(N) \
1427  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
1428  + 2 * YYSTACK_GAP_MAXIMUM)
1429 
1430 /* Copy COUNT objects from FROM to TO. The source and destination do
1431  not overlap. */
1432 # ifndef YYCOPY
1433 # if defined __GNUC__ && 1 < __GNUC__
1434 # define YYCOPY(To, From, Count) \
1435  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1436 # else
1437 # define YYCOPY(To, From, Count) \
1438  do \
1439  { \
1440  YYSIZE_T yyi; \
1441  for (yyi = 0; yyi < (Count); yyi++) \
1442  (To)[yyi] = (From)[yyi]; \
1443  } \
1444  while (YYID (0))
1445 # endif
1446 # endif
1447 
1448 /* Relocate STACK from its old location to the new one. The
1449  local variables YYSIZE and YYSTACKSIZE give the old and new number of
1450  elements in the stack, and YYPTR gives the new location of the
1451  stack. Advance YYPTR to a properly aligned location for the next
1452  stack. */
1453 # define YYSTACK_RELOCATE(Stack) \
1454  do \
1455  { \
1456  YYSIZE_T yynewbytes; \
1457  YYCOPY (&yyptr->Stack, Stack, yysize); \
1458  Stack = &yyptr->Stack; \
1459  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1460  yyptr += yynewbytes / sizeof (*yyptr); \
1461  } \
1462  while (YYID (0))
1463 
1464 #endif
1465 
1466 /* YYFINAL -- State number of the termination state. */
1467 #define YYFINAL 3
1468 /* YYLAST -- Last index in YYTABLE. */
1469 #define YYLAST 11649
1470 
1471 /* YYNTOKENS -- Number of terminals. */
1472 #define YYNTOKENS 146
1473 /* YYNNTS -- Number of nonterminals. */
1474 #define YYNNTS 219
1475 /* YYNRULES -- Number of rules. */
1476 #define YYNRULES 645
1477 /* YYNRULES -- Number of states. */
1478 #define YYNSTATES 1086
1479 
1480 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1481 #define YYUNDEFTOK 2
1482 #define YYMAXUTOK 352
1483 
1484 #define YYTRANSLATE(YYX) \
1485  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1486 
1487 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1488 static const yytype_uint8 yytranslate[] =
1489 {
1490  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1491  145, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1492  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1493  2, 2, 143, 131, 2, 2, 2, 129, 124, 2,
1494  139, 140, 127, 125, 137, 126, 144, 128, 2, 2,
1495  2, 2, 2, 2, 2, 2, 2, 2, 119, 142,
1496  121, 117, 120, 118, 2, 2, 2, 2, 2, 2,
1497  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1498  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1499  2, 136, 2, 141, 123, 2, 138, 2, 2, 2,
1500  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1501  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1502  2, 2, 2, 134, 122, 135, 132, 2, 81, 82,
1503  68, 69, 70, 71, 85, 86, 76, 75, 72, 73,
1504  74, 79, 80, 83, 84, 88, 77, 78, 87, 2,
1505  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1506  2, 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, 1, 2, 3, 4,
1516  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1517  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1518  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1519  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1520  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1521  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1522  65, 66, 67, 89, 90, 91, 92, 93, 94, 95,
1523  96, 97, 98, 99, 100, 101, 102, 103, 104, 105,
1524  106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
1525  116, 130, 133
1526 };
1527 
1528 #if YYDEBUG
1529 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1530  YYRHS. */
1531 static const yytype_uint16 yyprhs[] =
1532 {
1533  0, 0, 3, 4, 7, 10, 12, 14, 18, 21,
1534  23, 24, 30, 35, 38, 40, 42, 46, 49, 51,
1535  52, 58, 59, 64, 68, 72, 76, 79, 83, 87,
1536  91, 95, 99, 104, 106, 110, 114, 118, 120, 124,
1537  128, 135, 141, 147, 153, 159, 163, 165, 169, 171,
1538  173, 177, 181, 185, 188, 190, 192, 194, 196, 198,
1539  203, 204, 209, 211, 214, 218, 223, 229, 234, 240,
1540  243, 246, 249, 252, 255, 257, 261, 263, 267, 269,
1541  272, 276, 282, 285, 290, 293, 298, 300, 304, 306,
1542  310, 313, 317, 319, 323, 325, 327, 332, 336, 340,
1543  344, 348, 351, 353, 355, 357, 362, 366, 370, 374,
1544  378, 381, 383, 385, 387, 390, 392, 396, 398, 400,
1545  402, 404, 406, 408, 410, 412, 414, 416, 417, 422,
1546  424, 426, 428, 430, 432, 434, 436, 438, 440, 442,
1547  444, 446, 448, 450, 452, 454, 456, 458, 460, 462,
1548  464, 466, 468, 470, 472, 474, 476, 478, 480, 482,
1549  484, 486, 488, 490, 492, 494, 496, 498, 500, 502,
1550  504, 506, 508, 510, 512, 514, 516, 518, 520, 522,
1551  524, 526, 528, 530, 532, 534, 536, 538, 540, 542,
1552  544, 546, 548, 550, 552, 554, 556, 558, 560, 562,
1553  564, 568, 572, 579, 585, 591, 597, 603, 608, 612,
1554  616, 620, 624, 628, 632, 636, 640, 644, 649, 652,
1555  655, 659, 663, 667, 671, 673, 677, 681, 685, 689,
1556  693, 696, 699, 703, 707, 711, 715, 716, 721, 728,
1557  730, 732, 734, 736, 738, 742, 746, 748, 750, 753,
1558  758, 761, 763, 767, 771, 773, 775, 777, 779, 782,
1559  787, 790, 792, 795, 798, 803, 805, 806, 809, 812,
1560  815, 817, 819, 822, 826, 831, 833, 835, 839, 844,
1561  847, 849, 851, 853, 855, 857, 859, 861, 863, 865,
1562  867, 869, 870, 875, 876, 880, 881, 882, 888, 892,
1563  896, 899, 903, 907, 909, 914, 918, 920, 921, 928,
1564  933, 937, 940, 942, 945, 948, 955, 962, 963, 964,
1565  972, 973, 974, 982, 988, 993, 994, 995, 1005, 1006,
1566  1013, 1014, 1022, 1023, 1029, 1030, 1031, 1039, 1040, 1041,
1567  1051, 1053, 1055, 1057, 1059, 1061, 1063, 1065, 1067, 1069,
1568  1071, 1073, 1075, 1077, 1079, 1081, 1083, 1085, 1087, 1090,
1569  1092, 1094, 1096, 1102, 1104, 1107, 1109, 1111, 1113, 1117,
1570  1119, 1123, 1125, 1130, 1137, 1141, 1147, 1150, 1155, 1157,
1571  1161, 1166, 1169, 1172, 1174, 1177, 1178, 1185, 1194, 1199,
1572  1206, 1211, 1214, 1221, 1224, 1229, 1236, 1239, 1244, 1247,
1573  1252, 1254, 1256, 1258, 1262, 1264, 1269, 1271, 1276, 1278,
1574  1282, 1284, 1286, 1287, 1288, 1289, 1290, 1297, 1302, 1304,
1575  1308, 1312, 1313, 1318, 1321, 1326, 1332, 1338, 1341, 1342,
1576  1348, 1349, 1355, 1359, 1360, 1365, 1366, 1371, 1374, 1376,
1577  1381, 1382, 1387, 1388, 1393, 1394, 1395, 1400, 1401, 1402,
1578  1407, 1413, 1415, 1417, 1424, 1426, 1428, 1430, 1432, 1435,
1579  1437, 1440, 1442, 1444, 1446, 1448, 1450, 1452, 1454, 1457,
1580  1461, 1465, 1469, 1473, 1477, 1478, 1482, 1484, 1487, 1491,
1581  1495, 1496, 1500, 1504, 1508, 1512, 1516, 1517, 1521, 1522,
1582  1526, 1527, 1530, 1531, 1534, 1535, 1538, 1540, 1541, 1545,
1583  1546, 1547, 1548, 1549, 1550, 1559, 1561, 1563, 1565, 1567,
1584  1570, 1572, 1574, 1576, 1578, 1582, 1584, 1587, 1589, 1591,
1585  1593, 1595, 1597, 1599, 1601, 1603, 1605, 1607, 1609, 1611,
1586  1613, 1615, 1617, 1619, 1621, 1623, 1625, 1627, 1629, 1631,
1587  1632, 1637, 1638, 1642, 1643, 1647, 1652, 1655, 1658, 1660,
1588  1663, 1664, 1671, 1680, 1685, 1692, 1697, 1704, 1707, 1712,
1589  1719, 1722, 1727, 1730, 1735, 1737, 1738, 1740, 1742, 1744,
1590  1746, 1748, 1750, 1752, 1754, 1758, 1760, 1764, 1766, 1769,
1591  1771, 1774, 1776, 1778, 1782, 1784, 1788, 1790, 1792, 1795,
1592  1797, 1801, 1805, 1807, 1811, 1813, 1817, 1819, 1821, 1824,
1593  1826, 1828, 1830, 1833, 1836, 1838, 1840, 1841, 1846, 1848,
1594  1851, 1853, 1857, 1861, 1864, 1869, 1872, 1874, 1876, 1878,
1595  1880, 1882, 1884, 1886, 1888, 1890, 1892, 1894, 1896, 1898,
1596  1900, 1902, 1904, 1905, 1907, 1908, 1910, 1913, 1916, 1917,
1597  1919, 1921, 1923, 1925, 1927, 1930
1598 };
1599 
1600 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1601 static const yytype_int16 yyrhs[] =
1602 {
1603  147, 0, -1, -1, 148, 149, -1, 150, 357, -1,
1604  364, -1, 151, -1, 150, 363, 151, -1, 1, 151,
1605  -1, 158, -1, -1, 47, 152, 134, 149, 135, -1,
1606  154, 278, 239, 281, -1, 155, 357, -1, 364, -1,
1607  156, -1, 155, 363, 156, -1, 1, 158, -1, 158,
1608  -1, -1, 47, 157, 134, 149, 135, -1, -1, 45,
1609  182, 159, 182, -1, 45, 54, 54, -1, 45, 54,
1610  66, -1, 45, 54, 65, -1, 6, 183, -1, 158,
1611  40, 163, -1, 158, 41, 163, -1, 158, 42, 163,
1612  -1, 158, 43, 163, -1, 158, 44, 158, -1, 48,
1613  134, 154, 135, -1, 160, -1, 170, 117, 164, -1,
1614  177, 117, 204, -1, 170, 117, 203, -1, 162, -1,
1615  177, 117, 161, -1, 316, 90, 161, -1, 224, 136,
1616  196, 360, 90, 161, -1, 224, 355, 52, 90, 161,
1617  -1, 224, 355, 56, 90, 161, -1, 224, 88, 56,
1618  90, 161, -1, 224, 88, 52, 90, 161, -1, 317,
1619  90, 161, -1, 164, -1, 164, 44, 158, -1, 160,
1620  -1, 164, -1, 162, 37, 162, -1, 162, 38, 162,
1621  -1, 39, 358, 162, -1, 131, 164, -1, 187, -1,
1622  162, -1, 169, -1, 165, -1, 261, -1, 261, 356,
1623  352, 198, -1, -1, 97, 167, 270, 135, -1, 351,
1624  -1, 168, 198, -1, 168, 198, 166, -1, 224, 355,
1625  352, 198, -1, 224, 355, 352, 198, 166, -1, 224,
1626  88, 352, 198, -1, 224, 88, 352, 198, 166, -1,
1627  32, 198, -1, 31, 198, -1, 30, 197, -1, 21,
1628  197, -1, 22, 197, -1, 172, -1, 92, 171, 359,
1629  -1, 172, -1, 92, 171, 359, -1, 174, -1, 174,
1630  173, -1, 174, 98, 176, -1, 174, 98, 176, 137,
1631  175, -1, 174, 98, -1, 174, 98, 137, 175, -1,
1632  98, 176, -1, 98, 176, 137, 175, -1, 98, -1,
1633  98, 137, 175, -1, 176, -1, 92, 171, 359, -1,
1634  173, 137, -1, 174, 173, 137, -1, 173, -1, 175,
1635  137, 173, -1, 313, -1, 314, -1, 224, 136, 196,
1636  360, -1, 224, 355, 52, -1, 224, 88, 52, -1,
1637  224, 355, 56, -1, 224, 88, 56, -1, 89, 56,
1638  -1, 317, -1, 313, -1, 314, -1, 224, 136, 196,
1639  360, -1, 224, 355, 52, -1, 224, 88, 52, -1,
1640  224, 355, 56, -1, 224, 88, 56, -1, 89, 56,
1641  -1, 317, -1, 52, -1, 56, -1, 89, 178, -1,
1642  178, -1, 224, 88, 178, -1, 52, -1, 56, -1,
1643  53, -1, 185, -1, 186, -1, 180, -1, 308, -1,
1644  181, -1, 310, -1, 182, -1, -1, 183, 137, 184,
1645  182, -1, 122, -1, 123, -1, 124, -1, 71, -1,
1646  72, -1, 73, -1, 79, -1, 80, -1, 120, -1,
1647  75, -1, 121, -1, 76, -1, 74, -1, 85, -1,
1648  86, -1, 125, -1, 126, -1, 127, -1, 98, -1,
1649  128, -1, 129, -1, 70, -1, 99, -1, 131, -1,
1650  132, -1, 68, -1, 69, -1, 83, -1, 84, -1,
1651  138, -1, 49, -1, 50, -1, 51, -1, 47, -1,
1652  48, -1, 45, -1, 37, -1, 7, -1, 21, -1,
1653  16, -1, 3, -1, 5, -1, 46, -1, 26, -1,
1654  15, -1, 14, -1, 10, -1, 9, -1, 36, -1,
1655  20, -1, 25, -1, 4, -1, 22, -1, 34, -1,
1656  39, -1, 38, -1, 23, -1, 8, -1, 24, -1,
1657  30, -1, 33, -1, 32, -1, 13, -1, 35, -1,
1658  6, -1, 17, -1, 31, -1, 11, -1, 12, -1,
1659  18, -1, 19, -1, 177, 117, 193, -1, 316, 90,
1660  193, -1, 224, 136, 196, 360, 90, 193, -1, 224,
1661  355, 52, 90, 193, -1, 224, 355, 56, 90, 193,
1662  -1, 224, 88, 52, 90, 193, -1, 224, 88, 56,
1663  90, 193, -1, 89, 56, 90, 193, -1, 317, 90,
1664  193, -1, 187, 81, 187, -1, 187, 82, 187, -1,
1665  187, 125, 187, -1, 187, 126, 187, -1, 187, 127,
1666  187, -1, 187, 128, 187, -1, 187, 129, 187, -1,
1667  187, 70, 187, -1, 130, 312, 70, 187, -1, 68,
1668  187, -1, 69, 187, -1, 187, 122, 187, -1, 187,
1669  123, 187, -1, 187, 124, 187, -1, 187, 71, 187,
1670  -1, 190, -1, 187, 72, 187, -1, 187, 73, 187,
1671  -1, 187, 74, 187, -1, 187, 79, 187, -1, 187,
1672  80, 187, -1, 131, 187, -1, 132, 187, -1, 187,
1673  85, 187, -1, 187, 86, 187, -1, 187, 77, 187,
1674  -1, 187, 78, 187, -1, -1, 46, 358, 188, 187,
1675  -1, 187, 118, 187, 358, 119, 187, -1, 205, -1,
1676  120, -1, 121, -1, 75, -1, 76, -1, 187, 189,
1677  187, -1, 190, 189, 187, -1, 187, -1, 364, -1,
1678  202, 361, -1, 202, 137, 349, 361, -1, 349, 361,
1679  -1, 187, -1, 187, 44, 187, -1, 139, 196, 359,
1680  -1, 364, -1, 194, -1, 364, -1, 197, -1, 202,
1681  137, -1, 202, 137, 349, 137, -1, 349, 137, -1,
1682  169, -1, 202, 201, -1, 349, 201, -1, 202, 137,
1683  349, 201, -1, 200, -1, -1, 199, 197, -1, 100,
1684  191, -1, 137, 200, -1, 364, -1, 191, -1, 98,
1685  191, -1, 202, 137, 191, -1, 202, 137, 98, 191,
1686  -1, 204, -1, 191, -1, 202, 137, 191, -1, 202,
1687  137, 98, 191, -1, 98, 191, -1, 282, -1, 283,
1688  -1, 286, -1, 287, -1, 288, -1, 293, -1, 291,
1689  -1, 294, -1, 315, -1, 317, -1, 53, -1, -1,
1690  225, 206, 153, 235, -1, -1, 93, 207, 359, -1,
1691  -1, -1, 93, 208, 158, 209, 359, -1, 92, 154,
1692  140, -1, 224, 88, 56, -1, 89, 56, -1, 95,
1693  192, 141, -1, 96, 348, 135, -1, 30, -1, 31,
1694  139, 197, 359, -1, 31, 139, 359, -1, 31, -1,
1695  -1, 46, 358, 139, 210, 162, 359, -1, 39, 139,
1696  162, 359, -1, 39, 139, 359, -1, 168, 267, -1,
1697  262, -1, 262, 267, -1, 101, 252, -1, 226, 163,
1698  236, 154, 238, 235, -1, 227, 163, 236, 154, 239,
1699  235, -1, -1, -1, 228, 211, 163, 237, 212, 154,
1700  235, -1, -1, -1, 229, 213, 163, 237, 214, 154,
1701  235, -1, 230, 163, 357, 276, 235, -1, 230, 357,
1702  276, 235, -1, -1, -1, 231, 240, 25, 215, 163,
1703  237, 216, 154, 235, -1, -1, 232, 179, 318, 217,
1704  153, 235, -1, -1, 232, 85, 162, 218, 362, 153,
1705  235, -1, -1, 233, 179, 219, 153, 235, -1, -1,
1706  -1, 234, 180, 220, 221, 320, 153, 235, -1, -1,
1707  -1, 234, 346, 354, 222, 180, 223, 320, 153, 235,
1708  -1, 21, -1, 22, -1, 23, -1, 24, -1, 205,
1709  -1, 7, -1, 11, -1, 12, -1, 18, -1, 19,
1710  -1, 16, -1, 20, -1, 3, -1, 4, -1, 5,
1711  -1, 10, -1, 362, -1, 13, -1, 362, 13, -1,
1712  362, -1, 27, -1, 239, -1, 14, 163, 236, 154,
1713  238, -1, 364, -1, 15, 154, -1, 177, -1, 170,
1714  -1, 326, -1, 92, 243, 359, -1, 241, -1, 242,
1715  137, 241, -1, 242, -1, 242, 137, 98, 326, -1,
1716  242, 137, 98, 326, 137, 242, -1, 242, 137, 98,
1717  -1, 242, 137, 98, 137, 242, -1, 98, 326, -1,
1718  98, 326, 137, 242, -1, 98, -1, 98, 137, 242,
1719  -1, 333, 137, 336, 345, -1, 333, 345, -1, 336,
1720  345, -1, 344, -1, 137, 244, -1, -1, 329, 137,
1721  339, 137, 342, 245, -1, 329, 137, 339, 137, 342,
1722  137, 329, 245, -1, 329, 137, 339, 245, -1, 329,
1723  137, 339, 137, 329, 245, -1, 329, 137, 342, 245,
1724  -1, 329, 137, -1, 329, 137, 342, 137, 329, 245,
1725  -1, 329, 245, -1, 339, 137, 342, 245, -1, 339,
1726  137, 342, 137, 329, 245, -1, 339, 245, -1, 339,
1727  137, 329, 245, -1, 342, 245, -1, 342, 137, 329,
1728  245, -1, 244, -1, 364, -1, 248, -1, 122, 249,
1729  122, -1, 78, -1, 122, 246, 249, 122, -1, 358,
1730  -1, 358, 142, 250, 358, -1, 251, -1, 250, 137,
1731  251, -1, 52, -1, 325, -1, -1, -1, -1, -1,
1732  253, 254, 257, 255, 256, 258, -1, 139, 324, 249,
1733  140, -1, 324, -1, 114, 154, 135, -1, 29, 154,
1734  235, -1, -1, 28, 260, 273, 10, -1, 169, 259,
1735  -1, 261, 356, 352, 195, -1, 261, 356, 352, 195,
1736  267, -1, 261, 356, 352, 198, 259, -1, 168, 194,
1737  -1, -1, 224, 355, 352, 263, 195, -1, -1, 224,
1738  88, 352, 264, 194, -1, 224, 88, 353, -1, -1,
1739  224, 355, 265, 194, -1, -1, 224, 88, 266, 194,
1740  -1, 32, 194, -1, 32, -1, 224, 136, 196, 360,
1741  -1, -1, 134, 268, 270, 135, -1, -1, 26, 269,
1742  273, 10, -1, -1, -1, 271, 272, 247, 154, -1,
1743  -1, -1, 274, 275, 247, 153, -1, 17, 202, 236,
1744  154, 277, -1, 239, -1, 276, -1, 8, 279, 280,
1745  236, 154, 278, -1, 364, -1, 191, -1, 204, -1,
1746  364, -1, 91, 177, -1, 364, -1, 9, 154, -1,
1747  364, -1, 311, -1, 308, -1, 310, -1, 284, -1,
1748  64, -1, 285, -1, 284, 285, -1, 103, 297, 113,
1749  -1, 104, 298, 113, -1, 105, 299, 67, -1, 106,
1750  143, 113, -1, 106, 289, 113, -1, -1, 289, 290,
1751  143, -1, 300, -1, 290, 300, -1, 108, 143, 113,
1752  -1, 108, 292, 113, -1, -1, 292, 290, 143, -1,
1753  107, 143, 113, -1, 107, 295, 113, -1, 109, 143,
1754  113, -1, 109, 296, 113, -1, -1, 295, 63, 143,
1755  -1, -1, 296, 63, 143, -1, -1, 297, 300, -1,
1756  -1, 298, 300, -1, -1, 299, 300, -1, 63, -1,
1757  -1, 112, 301, 307, -1, -1, -1, -1, -1, -1,
1758  110, 302, 303, 304, 305, 306, 154, 111, -1, 54,
1759  -1, 55, -1, 57, -1, 317, -1, 102, 309, -1,
1760  180, -1, 55, -1, 54, -1, 57, -1, 102, 298,
1761  113, -1, 312, -1, 130, 312, -1, 59, -1, 60,
1762  -1, 61, -1, 62, -1, 52, -1, 55, -1, 54,
1763  -1, 56, -1, 57, -1, 34, -1, 33, -1, 35,
1764  -1, 36, -1, 50, -1, 49, -1, 51, -1, 313,
1765  -1, 314, -1, 313, -1, 314, -1, 65, -1, 66,
1766  -1, -1, 121, 319, 163, 362, -1, -1, 139, 324,
1767  359, -1, -1, 321, 324, 362, -1, 334, 137, 336,
1768  345, -1, 334, 345, -1, 336, 345, -1, 344, -1,
1769  137, 322, -1, -1, 329, 137, 340, 137, 342, 323,
1770  -1, 329, 137, 340, 137, 342, 137, 329, 323, -1,
1771  329, 137, 340, 323, -1, 329, 137, 340, 137, 329,
1772  323, -1, 329, 137, 342, 323, -1, 329, 137, 342,
1773  137, 329, 323, -1, 329, 323, -1, 340, 137, 342,
1774  323, -1, 340, 137, 342, 137, 329, 323, -1, 340,
1775  323, -1, 340, 137, 329, 323, -1, 342, 323, -1,
1776  342, 137, 329, 323, -1, 322, -1, -1, 56, -1,
1777  55, -1, 54, -1, 57, -1, 325, -1, 52, -1,
1778  326, -1, 327, -1, 92, 243, 359, -1, 328, -1,
1779  329, 137, 328, -1, 58, -1, 330, 191, -1, 330,
1780  -1, 330, 224, -1, 330, -1, 332, -1, 333, 137,
1781  332, -1, 331, -1, 334, 137, 331, -1, 70, -1,
1782  99, -1, 335, 52, -1, 335, -1, 327, 117, 191,
1783  -1, 327, 117, 224, -1, 338, -1, 339, 137, 338,
1784  -1, 337, -1, 340, 137, 337, -1, 127, -1, 98,
1785  -1, 341, 52, -1, 341, -1, 124, -1, 100, -1,
1786  343, 52, -1, 137, 344, -1, 364, -1, 315, -1,
1787  -1, 139, 347, 162, 359, -1, 364, -1, 349, 361,
1788  -1, 350, -1, 349, 137, 350, -1, 191, 91, 191,
1789  -1, 58, 191, -1, 103, 297, 115, 191, -1, 99,
1790  191, -1, 52, -1, 56, -1, 53, -1, 52, -1,
1791  56, -1, 53, -1, 185, -1, 52, -1, 53, -1,
1792  185, -1, 144, -1, 88, -1, 144, -1, 87, -1,
1793  355, -1, 88, -1, -1, 363, -1, -1, 145, -1,
1794  358, 140, -1, 358, 141, -1, -1, 145, -1, 137,
1795  -1, 142, -1, 145, -1, 362, -1, 363, 142, -1,
1796  -1
1797 };
1798 
1799 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1800 static const yytype_uint16 yyrline[] =
1801 {
1802  0, 1064, 1064, 1064, 1095, 1105, 1114, 1122, 1130, 1136,
1803  1138, 1137, 1158, 1194, 1204, 1213, 1221, 1229, 1235, 1240,
1804  1239, 1261, 1261, 1270, 1279, 1291, 1302, 1310, 1319, 1328,
1805  1342, 1356, 1366, 1383, 1384, 1394, 1399, 1408, 1411, 1416,
1806  1421, 1443, 1448, 1453, 1458, 1463, 1470, 1478, 1487, 1490,
1807  1491, 1495, 1499, 1503, 1507, 1510, 1522, 1523, 1526, 1527,
1808  1534, 1533, 1549, 1559, 1568, 1575, 1580, 1587, 1592, 1599,
1809  1609, 1618, 1627, 1636, 1647, 1648, 1658, 1659, 1669, 1677,
1810  1685, 1693, 1702, 1710, 1719, 1727, 1736, 1744, 1755, 1756,
1811  1766, 1774, 1784, 1792, 1802, 1806, 1810, 1818, 1826, 1834,
1812  1842, 1846, 1850, 1857, 1865, 1873, 1881, 1889, 1897, 1905,
1813  1909, 1913, 1920, 1929, 1932, 1940, 1949, 1960, 1961, 1962,
1814  1963, 1968, 1975, 1976, 1979, 1987, 1990, 1998, 1998, 2009,
1815  2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
1816  2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029,
1817  2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2041,
1818  2041, 2041, 2042, 2042, 2043, 2043, 2043, 2044, 2044, 2044,
1819  2044, 2045, 2045, 2045, 2045, 2046, 2046, 2046, 2047, 2047,
1820  2047, 2047, 2048, 2048, 2048, 2048, 2049, 2049, 2049, 2049,
1821  2050, 2050, 2050, 2050, 2051, 2051, 2051, 2051, 2052, 2052,
1822  2055, 2059, 2063, 2091, 2096, 2101, 2106, 2111, 2116, 2121,
1823  2132, 2143, 2147, 2151, 2155, 2159, 2163, 2167, 2171, 2175,
1824  2179, 2183, 2187, 2191, 2195, 2196, 2200, 2204, 2208, 2212,
1825  2216, 2220, 2224, 2228, 2232, 2236, 2240, 2240, 2245, 2255,
1826  2261, 2262, 2263, 2264, 2267, 2271, 2278, 2290, 2291, 2295,
1827  2303, 2313, 2321, 2332, 2342, 2343, 2346, 2347, 2348, 2352,
1828  2360, 2370, 2379, 2387, 2397, 2406, 2415, 2415, 2427, 2438,
1829  2442, 2448, 2456, 2465, 2479, 2495, 2496, 2499, 2513, 2528,
1830  2539, 2540, 2541, 2542, 2543, 2544, 2545, 2546, 2547, 2548,
1831  2549, 2558, 2557, 2584, 2584, 2593, 2597, 2592, 2606, 2614,
1832  2623, 2632, 2645, 2654, 2663, 2671, 2680, 2689, 2689, 2694,
1833  2698, 2702, 2712, 2713, 2723, 2727, 2739, 2751, 2751, 2751,
1834  2763, 2763, 2763, 2775, 2787, 2798, 2800, 2797, 2850, 2849,
1835  2874, 2873, 2898, 2897, 2922, 2927, 2921, 2950, 2951, 2950,
1836  2978, 2987, 2996, 3005, 3016, 3028, 3034, 3040, 3046, 3052,
1837  3058, 3068, 3074, 3080, 3086, 3096, 3102, 3107, 3108, 3115,
1838  3120, 3123, 3124, 3137, 3138, 3148, 3149, 3152, 3159, 3169,
1839  3177, 3187, 3195, 3204, 3214, 3222, 3231, 3240, 3250, 3258,
1840  3270, 3274, 3278, 3282, 3288, 3293, 3298, 3302, 3306, 3310,
1841  3314, 3318, 3326, 3330, 3334, 3338, 3342, 3346, 3350, 3354,
1842  3358, 3364, 3365, 3371, 3381, 3390, 3402, 3406, 3416, 3423,
1843  3432, 3440, 3446, 3449, 3454, 3457, 3446, 3478, 3486, 3492,
1844  3497, 3504, 3503, 3518, 3534, 3538, 3550, 3564, 3574, 3573,
1845  3585, 3584, 3595, 3600, 3599, 3611, 3610, 3621, 3630, 3639,
1846  3654, 3653, 3667, 3666, 3681, 3682, 3681, 3691, 3692, 3691,
1847  3701, 3714, 3715, 3718, 3737, 3740, 3748, 3756, 3759, 3763,
1848  3766, 3774, 3777, 3778, 3786, 3789, 3806, 3813, 3814, 3824,
1849  3830, 3836, 3842, 3851, 3862, 3869, 3879, 3887, 3897, 3906,
1850  3917, 3924, 3942, 3951, 3961, 3970, 3981, 3988, 4000, 4007,
1851  4023, 4030, 4041, 4048, 4059, 4066, 4107, 4115, 4114, 4131,
1852  4137, 4141, 4145, 4149, 4130, 4171, 4179, 4187, 4196, 4199,
1853  4210, 4211, 4212, 4213, 4216, 4227, 4228, 4239, 4246, 4253,
1854  4260, 4269, 4270, 4271, 4272, 4273, 4276, 4277, 4278, 4279,
1855  4280, 4281, 4282, 4285, 4298, 4308, 4312, 4318, 4325, 4335,
1856  4334, 4344, 4353, 4363, 4363, 4377, 4381, 4385, 4389, 4395,
1857  4400, 4405, 4409, 4413, 4417, 4421, 4425, 4429, 4433, 4437,
1858  4441, 4445, 4449, 4453, 4457, 4462, 4468, 4478, 4488, 4498,
1859  4510, 4511, 4518, 4527, 4536, 4555, 4562, 4576, 4585, 4595,
1860  4607, 4616, 4627, 4635, 4646, 4654, 4664, 4665, 4668, 4677,
1861  4688, 4701, 4714, 4722, 4738, 4746, 4762, 4763, 4766, 4779,
1862  4790, 4791, 4794, 4811, 4815, 4825, 4835, 4835, 4865, 4866,
1863  4876, 4883, 4907, 4919, 4927, 4935, 4949, 4950, 4951, 4954,
1864  4955, 4956, 4957, 4960, 4961, 4962, 4965, 4966, 4969, 4973,
1865  4979, 4980, 4986, 4987, 4990, 4991, 4994, 4997, 5000, 5001,
1866  5002, 5005, 5006, 5009, 5010, 5014
1867 };
1868 #endif
1869 
1870 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1871 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1872  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1873 static const char *const yytname[] =
1874 {
1875  "\"end-of-input\"", "error", "$undefined", "keyword_class",
1876  "keyword_module", "keyword_def", "keyword_undef", "keyword_begin",
1877  "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_if",
1878  "keyword_unless", "keyword_then", "keyword_elsif", "keyword_else",
1879  "keyword_case", "keyword_when", "keyword_while", "keyword_until",
1880  "keyword_for", "keyword_break", "keyword_next", "keyword_redo",
1881  "keyword_retry", "keyword_in", "keyword_do", "keyword_do_cond",
1882  "keyword_do_block", "keyword_do_LAMBDA", "keyword_return",
1883  "keyword_yield", "keyword_super", "keyword_self", "keyword_nil",
1884  "keyword_true", "keyword_false", "keyword_and", "keyword_or",
1885  "keyword_not", "modifier_if", "modifier_unless", "modifier_while",
1886  "modifier_until", "modifier_rescue", "keyword_alias", "keyword_defined",
1887  "keyword_BEGIN", "keyword_END", "keyword__LINE__", "keyword__FILE__",
1888  "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR", "tIVAR",
1889  "tCONSTANT", "tCVAR", "tLABEL", "tINTEGER", "tFLOAT", "tRATIONAL",
1890  "tIMAGINARY", "tSTRING_CONTENT", "tCHAR", "tNTH_REF", "tBACK_REF",
1891  "tREGEXP_END", "\"unary+\"", "\"unary-\"", "\"**\"", "\"<=>\"", "\"==\"",
1892  "\"===\"", "\"!=\"", "\">=\"", "\"<=\"", "\"&&\"", "\"||\"", "\"=~\"",
1893  "\"!~\"", "\"..\"", "\"...\"", "\"[]\"", "\"[]=\"", "\"<<\"", "\">>\"",
1894  "\"&.\"", "\"::\"", "\":: at EXPR_BEG\"", "tOP_ASGN", "\"=>\"", "\"(\"",
1895  "\"( arg\"", "\")\"", "\"[\"", "\"{\"", "\"{ arg\"", "\"*\"",
1896  "\"**arg\"", "\"&\"", "\"->\"", "tSYMBEG", "tSTRING_BEG", "tXSTRING_BEG",
1897  "tREGEXP_BEG", "tWORDS_BEG", "tQWORDS_BEG", "tSYMBOLS_BEG",
1898  "tQSYMBOLS_BEG", "tSTRING_DBEG", "tSTRING_DEND", "tSTRING_DVAR",
1899  "tSTRING_END", "tLAMBEG", "tLABEL_END", "tLOWEST", "'='", "'?'", "':'",
1900  "'>'", "'<'", "'|'", "'^'", "'&'", "'+'", "'-'", "'*'", "'/'", "'%'",
1901  "tUMINUS_NUM", "'!'", "'~'", "tLAST_TOKEN", "'{'", "'}'", "'['", "','",
1902  "'`'", "'('", "')'", "']'", "';'", "' '", "'.'", "'\\n'", "$accept",
1903  "program", "@1", "top_compstmt", "top_stmts", "top_stmt", "@2",
1904  "bodystmt", "compstmt", "stmts", "stmt_or_begin", "@3", "stmt", "@4",
1905  "command_asgn", "command_rhs", "expr", "expr_value", "command_call",
1906  "block_command", "cmd_brace_block", "@5", "fcall", "command", "mlhs",
1907  "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_head", "mlhs_post",
1908  "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym", "fitem",
1909  "undef_list", "@6", "op", "reswords", "arg", "@7", "relop", "rel_expr",
1910  "arg_value", "aref_args", "arg_rhs", "paren_args", "opt_paren_args",
1911  "opt_call_args", "call_args", "command_args", "@8", "block_arg",
1912  "opt_block_arg", "args", "mrhs_arg", "mrhs", "primary", "@9", "@10",
1913  "@11", "@12", "@13", "@14", "@15", "@16", "@17", "@18", "@19", "@20",
1914  "@21", "@22", "@23", "@24", "@25", "@26", "primary_value", "k_begin",
1915  "k_if", "k_unless", "k_while", "k_until", "k_case", "k_for", "k_class",
1916  "k_module", "k_def", "k_end", "then", "do", "if_tail", "opt_else",
1917  "for_var", "f_marg", "f_marg_list", "f_margs", "block_args_tail",
1918  "opt_block_args_tail", "block_param", "opt_block_param",
1919  "block_param_def", "opt_bv_decl", "bv_decls", "bvar", "lambda", "@27",
1920  "@28", "@29", "@30", "f_larglist", "lambda_body", "do_block", "@31",
1921  "block_call", "method_call", "@32", "@33", "@34", "@35", "brace_block",
1922  "@36", "@37", "brace_body", "@38", "@39", "do_body", "@40", "@41",
1923  "case_body", "cases", "opt_rescue", "exc_list", "exc_var", "opt_ensure",
1924  "literal", "strings", "string", "string1", "xstring", "regexp", "words",
1925  "word_list", "word", "symbols", "symbol_list", "qwords", "qsymbols",
1926  "qword_list", "qsym_list", "string_contents", "xstring_contents",
1927  "regexp_contents", "string_content", "@42", "@43", "@44", "@45", "@46",
1928  "@47", "string_dvar", "symbol", "sym", "dsym", "numeric",
1929  "simple_numeric", "user_variable", "keyword_variable", "var_ref",
1930  "var_lhs", "backref", "superclass", "@48", "f_arglist", "@49",
1931  "args_tail", "opt_args_tail", "f_args", "f_bad_arg", "f_norm_arg",
1932  "f_arg_asgn", "f_arg_item", "f_arg", "f_label", "f_kw", "f_block_kw",
1933  "f_block_kwarg", "f_kwarg", "kwrest_mark", "f_kwrest", "f_opt",
1934  "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
1935  "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
1936  "singleton", "@50", "assoc_list", "assocs", "assoc", "operation",
1937  "operation2", "operation3", "dot_or_colon", "call_op", "call_op2",
1938  "opt_terms", "opt_nl", "rparen", "rbracket", "trailer", "term", "terms",
1939  "none", 0
1940 };
1941 #endif
1942 
1943 # ifdef YYPRINT
1944 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1945  token YYLEX-NUM. */
1946 static const yytype_uint16 yytoknum[] =
1947 {
1948  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1949  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1950  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1951  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1952  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1953  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1954  315, 316, 317, 318, 319, 320, 321, 322, 130, 131,
1955  132, 133, 138, 139, 140, 137, 136, 146, 147, 141,
1956  142, 128, 129, 143, 144, 134, 135, 148, 145, 323,
1957  324, 325, 326, 327, 328, 329, 330, 331, 332, 333,
1958  334, 335, 336, 337, 338, 339, 340, 341, 342, 343,
1959  344, 345, 346, 347, 348, 349, 350, 61, 63, 58,
1960  62, 60, 124, 94, 38, 43, 45, 42, 47, 37,
1961  351, 33, 126, 352, 123, 125, 91, 44, 96, 40,
1962  41, 93, 59, 32, 46, 10
1963 };
1964 # endif
1965 
1966 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1967 static const yytype_uint16 yyr1[] =
1968 {
1969  0, 146, 148, 147, 149, 150, 150, 150, 150, 151,
1970  152, 151, 153, 154, 155, 155, 155, 155, 156, 157,
1971  156, 159, 158, 158, 158, 158, 158, 158, 158, 158,
1972  158, 158, 158, 158, 158, 158, 158, 158, 160, 160,
1973  160, 160, 160, 160, 160, 160, 161, 161, 161, 162,
1974  162, 162, 162, 162, 162, 163, 164, 164, 165, 165,
1975  167, 166, 168, 169, 169, 169, 169, 169, 169, 169,
1976  169, 169, 169, 169, 170, 170, 171, 171, 172, 172,
1977  172, 172, 172, 172, 172, 172, 172, 172, 173, 173,
1978  174, 174, 175, 175, 176, 176, 176, 176, 176, 176,
1979  176, 176, 176, 177, 177, 177, 177, 177, 177, 177,
1980  177, 177, 178, 178, 179, 179, 179, 180, 180, 180,
1981  180, 180, 181, 181, 182, 182, 183, 184, 183, 185,
1982  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
1983  185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
1984  185, 185, 185, 185, 185, 185, 185, 185, 185, 186,
1985  186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
1986  186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
1987  186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
1988  186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
1989  187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
1990  187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
1991  187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
1992  187, 187, 187, 187, 187, 187, 188, 187, 187, 187,
1993  189, 189, 189, 189, 190, 190, 191, 192, 192, 192,
1994  192, 193, 193, 194, 195, 195, 196, 196, 196, 196,
1995  196, 197, 197, 197, 197, 197, 199, 198, 200, 201,
1996  201, 202, 202, 202, 202, 203, 203, 204, 204, 204,
1997  205, 205, 205, 205, 205, 205, 205, 205, 205, 205,
1998  205, 206, 205, 207, 205, 208, 209, 205, 205, 205,
1999  205, 205, 205, 205, 205, 205, 205, 210, 205, 205,
2000  205, 205, 205, 205, 205, 205, 205, 211, 212, 205,
2001  213, 214, 205, 205, 205, 215, 216, 205, 217, 205,
2002  218, 205, 219, 205, 220, 221, 205, 222, 223, 205,
2003  205, 205, 205, 205, 224, 225, 226, 227, 228, 229,
2004  230, 231, 232, 233, 234, 235, 236, 236, 236, 237,
2005  237, 238, 238, 239, 239, 240, 240, 241, 241, 242,
2006  242, 243, 243, 243, 243, 243, 243, 243, 243, 243,
2007  244, 244, 244, 244, 245, 245, 246, 246, 246, 246,
2008  246, 246, 246, 246, 246, 246, 246, 246, 246, 246,
2009  246, 247, 247, 248, 248, 248, 249, 249, 250, 250,
2010  251, 251, 253, 254, 255, 256, 252, 257, 257, 258,
2011  258, 260, 259, 261, 261, 261, 261, 262, 263, 262,
2012  264, 262, 262, 265, 262, 266, 262, 262, 262, 262,
2013  268, 267, 269, 267, 271, 272, 270, 274, 275, 273,
2014  276, 277, 277, 278, 278, 279, 279, 279, 280, 280,
2015  281, 281, 282, 282, 282, 283, 284, 284, 284, 285,
2016  286, 287, 288, 288, 289, 289, 290, 290, 291, 291,
2017  292, 292, 293, 293, 294, 294, 295, 295, 296, 296,
2018  297, 297, 298, 298, 299, 299, 300, 301, 300, 302,
2019  303, 304, 305, 306, 300, 307, 307, 307, 307, 308,
2020  309, 309, 309, 309, 310, 311, 311, 312, 312, 312,
2021  312, 313, 313, 313, 313, 313, 314, 314, 314, 314,
2022  314, 314, 314, 315, 315, 316, 316, 317, 317, 319,
2023  318, 318, 320, 321, 320, 322, 322, 322, 322, 323,
2024  323, 324, 324, 324, 324, 324, 324, 324, 324, 324,
2025  324, 324, 324, 324, 324, 324, 325, 325, 325, 325,
2026  326, 326, 327, 328, 328, 329, 329, 330, 331, 331,
2027  332, 332, 333, 333, 334, 334, 335, 335, 336, 336,
2028  337, 338, 339, 339, 340, 340, 341, 341, 342, 342,
2029  343, 343, 344, 345, 345, 346, 347, 346, 348, 348,
2030  349, 349, 350, 350, 350, 350, 351, 351, 351, 352,
2031  352, 352, 352, 353, 353, 353, 354, 354, 355, 355,
2032  356, 356, 357, 357, 358, 358, 359, 360, 361, 361,
2033  361, 362, 362, 363, 363, 364
2034 };
2035 
2036 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
2037 static const yytype_uint8 yyr2[] =
2038 {
2039  0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
2040  0, 5, 4, 2, 1, 1, 3, 2, 1, 0,
2041  5, 0, 4, 3, 3, 3, 2, 3, 3, 3,
2042  3, 3, 4, 1, 3, 3, 3, 1, 3, 3,
2043  6, 5, 5, 5, 5, 3, 1, 3, 1, 1,
2044  3, 3, 3, 2, 1, 1, 1, 1, 1, 4,
2045  0, 4, 1, 2, 3, 4, 5, 4, 5, 2,
2046  2, 2, 2, 2, 1, 3, 1, 3, 1, 2,
2047  3, 5, 2, 4, 2, 4, 1, 3, 1, 3,
2048  2, 3, 1, 3, 1, 1, 4, 3, 3, 3,
2049  3, 2, 1, 1, 1, 4, 3, 3, 3, 3,
2050  2, 1, 1, 1, 2, 1, 3, 1, 1, 1,
2051  1, 1, 1, 1, 1, 1, 1, 0, 4, 1,
2052  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2053  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2054  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2055  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2056  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2057  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2058  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2059  3, 3, 6, 5, 5, 5, 5, 4, 3, 3,
2060  3, 3, 3, 3, 3, 3, 3, 4, 2, 2,
2061  3, 3, 3, 3, 1, 3, 3, 3, 3, 3,
2062  2, 2, 3, 3, 3, 3, 0, 4, 6, 1,
2063  1, 1, 1, 1, 3, 3, 1, 1, 2, 4,
2064  2, 1, 3, 3, 1, 1, 1, 1, 2, 4,
2065  2, 1, 2, 2, 4, 1, 0, 2, 2, 2,
2066  1, 1, 2, 3, 4, 1, 1, 3, 4, 2,
2067  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2068  1, 0, 4, 0, 3, 0, 0, 5, 3, 3,
2069  2, 3, 3, 1, 4, 3, 1, 0, 6, 4,
2070  3, 2, 1, 2, 2, 6, 6, 0, 0, 7,
2071  0, 0, 7, 5, 4, 0, 0, 9, 0, 6,
2072  0, 7, 0, 5, 0, 0, 7, 0, 0, 9,
2073  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2074  1, 1, 1, 1, 1, 1, 1, 1, 2, 1,
2075  1, 1, 5, 1, 2, 1, 1, 1, 3, 1,
2076  3, 1, 4, 6, 3, 5, 2, 4, 1, 3,
2077  4, 2, 2, 1, 2, 0, 6, 8, 4, 6,
2078  4, 2, 6, 2, 4, 6, 2, 4, 2, 4,
2079  1, 1, 1, 3, 1, 4, 1, 4, 1, 3,
2080  1, 1, 0, 0, 0, 0, 6, 4, 1, 3,
2081  3, 0, 4, 2, 4, 5, 5, 2, 0, 5,
2082  0, 5, 3, 0, 4, 0, 4, 2, 1, 4,
2083  0, 4, 0, 4, 0, 0, 4, 0, 0, 4,
2084  5, 1, 1, 6, 1, 1, 1, 1, 2, 1,
2085  2, 1, 1, 1, 1, 1, 1, 1, 2, 3,
2086  3, 3, 3, 3, 0, 3, 1, 2, 3, 3,
2087  0, 3, 3, 3, 3, 3, 0, 3, 0, 3,
2088  0, 2, 0, 2, 0, 2, 1, 0, 3, 0,
2089  0, 0, 0, 0, 8, 1, 1, 1, 1, 2,
2090  1, 1, 1, 1, 3, 1, 2, 1, 1, 1,
2091  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2092  1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
2093  4, 0, 3, 0, 3, 4, 2, 2, 1, 2,
2094  0, 6, 8, 4, 6, 4, 6, 2, 4, 6,
2095  2, 4, 2, 4, 1, 0, 1, 1, 1, 1,
2096  1, 1, 1, 1, 3, 1, 3, 1, 2, 1,
2097  2, 1, 1, 3, 1, 3, 1, 1, 2, 1,
2098  3, 3, 1, 3, 1, 3, 1, 1, 2, 1,
2099  1, 1, 2, 2, 1, 1, 0, 4, 1, 2,
2100  1, 3, 3, 2, 4, 2, 1, 1, 1, 1,
2101  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2102  1, 1, 0, 1, 0, 1, 2, 2, 0, 1,
2103  1, 1, 1, 1, 2, 0
2104 };
2105 
2106 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
2107  STATE-NUM when YYTABLE doesn't specify something else to do. Zero
2108  means the default is an error. */
2109 static const yytype_uint16 yydefact[] =
2110 {
2111  2, 0, 0, 1, 0, 352, 353, 354, 0, 345,
2112  346, 347, 350, 348, 349, 351, 340, 341, 342, 343,
2113  303, 266, 266, 527, 526, 528, 529, 634, 0, 634,
2114  10, 0, 531, 530, 532, 616, 618, 523, 522, 617,
2115  525, 517, 518, 519, 520, 466, 537, 538, 0, 0,
2116  0, 0, 295, 645, 645, 86, 412, 492, 490, 492,
2117  494, 474, 486, 480, 488, 0, 0, 0, 3, 632,
2118  6, 9, 33, 37, 49, 57, 266, 56, 0, 74,
2119  0, 78, 88, 0, 54, 224, 239, 0, 291, 0,
2120  0, 317, 320, 632, 0, 0, 0, 0, 58, 312,
2121  280, 281, 465, 467, 282, 283, 284, 286, 285, 287,
2122  463, 464, 462, 515, 533, 534, 288, 0, 289, 62,
2123  5, 8, 169, 180, 170, 193, 166, 186, 176, 175,
2124  196, 197, 191, 174, 173, 168, 194, 198, 199, 178,
2125  167, 181, 185, 187, 179, 172, 188, 195, 190, 189,
2126  182, 192, 177, 165, 184, 183, 164, 171, 162, 163,
2127  159, 160, 161, 117, 119, 118, 154, 155, 150, 132,
2128  133, 134, 141, 138, 140, 135, 136, 156, 157, 142,
2129  143, 147, 151, 137, 139, 129, 130, 131, 144, 145,
2130  146, 148, 149, 152, 153, 158, 122, 124, 126, 26,
2131  120, 121, 123, 125, 0, 0, 0, 0, 0, 0,
2132  0, 490, 0, 261, 0, 246, 271, 72, 265, 645,
2133  0, 533, 534, 0, 289, 645, 610, 73, 71, 634,
2134  70, 0, 645, 437, 69, 634, 635, 0, 0, 21,
2135  236, 0, 0, 340, 341, 303, 306, 438, 0, 218,
2136  0, 219, 300, 0, 19, 0, 0, 632, 15, 18,
2137  634, 76, 14, 634, 0, 0, 638, 638, 247, 0,
2138  0, 638, 608, 634, 0, 0, 0, 84, 344, 0,
2139  94, 95, 102, 314, 413, 512, 511, 513, 510, 0,
2140  509, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2141  0, 0, 516, 53, 230, 231, 641, 642, 4, 643,
2142  633, 0, 0, 0, 0, 0, 0, 0, 442, 440,
2143  427, 63, 311, 421, 423, 0, 90, 0, 82, 79,
2144  0, 0, 0, 0, 0, 0, 242, 243, 0, 0,
2145  0, 0, 0, 0, 0, 0, 0, 240, 241, 0,
2146  0, 0, 0, 0, 0, 0, 0, 0, 0, 629,
2147  435, 645, 628, 433, 0, 55, 0, 0, 0, 0,
2148  632, 0, 633, 0, 366, 365, 0, 0, 533, 534,
2149  289, 112, 113, 0, 0, 115, 541, 0, 533, 534,
2150  289, 332, 189, 182, 192, 177, 159, 160, 161, 117,
2151  118, 606, 334, 605, 0, 631, 630, 0, 313, 468,
2152  0, 0, 127, 613, 300, 272, 615, 268, 0, 0,
2153  0, 0, 262, 270, 435, 645, 433, 0, 0, 0,
2154  263, 634, 0, 305, 267, 634, 257, 645, 645, 256,
2155  634, 310, 52, 23, 25, 24, 0, 307, 0, 0,
2156  0, 435, 433, 0, 17, 0, 634, 298, 13, 633,
2157  75, 294, 296, 301, 640, 639, 248, 640, 250, 302,
2158  609, 0, 101, 516, 92, 87, 0, 435, 645, 433,
2159  565, 496, 499, 497, 514, 493, 469, 491, 470, 471,
2160  495, 472, 473, 0, 476, 482, 0, 483, 478, 479,
2161  0, 484, 0, 485, 0, 644, 7, 27, 28, 29,
2162  30, 31, 50, 51, 447, 444, 60, 64, 447, 0,
2163  34, 276, 0, 36, 275, 634, 0, 80, 91, 48,
2164  38, 46, 0, 251, 271, 200, 35, 0, 289, 216,
2165  223, 225, 226, 227, 234, 235, 228, 229, 209, 210,
2166  232, 233, 634, 220, 221, 222, 211, 212, 213, 214,
2167  215, 244, 245, 619, 621, 620, 622, 0, 266, 432,
2168  634, 619, 621, 620, 622, 0, 266, 0, 645, 357,
2169  0, 356, 0, 0, 0, 0, 0, 0, 300, 435,
2170  645, 433, 325, 330, 112, 113, 114, 539, 328, 435,
2171  645, 433, 0, 0, 335, 627, 626, 337, 619, 620,
2172  266, 39, 251, 201, 45, 208, 0, 0, 612, 0,
2173  273, 269, 645, 619, 620, 634, 619, 620, 611, 304,
2174  636, 253, 258, 260, 309, 22, 0, 237, 0, 32,
2175  430, 428, 207, 0, 77, 16, 634, 638, 0, 85,
2176  623, 100, 634, 619, 620, 571, 568, 567, 566, 569,
2177  577, 586, 0, 597, 587, 601, 600, 596, 565, 414,
2178  564, 418, 570, 572, 573, 575, 550, 579, 584, 645,
2179  589, 645, 594, 550, 599, 550, 0, 548, 500, 0,
2180  475, 477, 487, 481, 489, 217, 0, 448, 0, 445,
2181  444, 0, 279, 0, 89, 83, 0, 0, 0, 0,
2182  435, 645, 433, 0, 0, 0, 436, 67, 0, 0,
2183  439, 0, 0, 434, 65, 645, 355, 292, 645, 645,
2184  454, 645, 358, 645, 360, 318, 359, 321, 0, 0,
2185  324, 623, 299, 634, 619, 620, 0, 0, 0, 0,
2186  112, 113, 116, 634, 0, 634, 543, 0, 255, 424,
2187  59, 254, 128, 614, 274, 264, 0, 0, 439, 0,
2188  0, 645, 634, 11, 0, 297, 249, 93, 439, 0,
2189  378, 369, 371, 634, 367, 634, 415, 0, 0, 557,
2190  578, 0, 546, 604, 588, 0, 547, 0, 560, 598,
2191  0, 562, 602, 501, 505, 506, 507, 498, 508, 443,
2192  645, 441, 645, 0, 422, 0, 277, 81, 47, 252,
2193  619, 620, 634, 619, 620, 0, 44, 205, 43, 206,
2194  68, 431, 637, 0, 41, 203, 42, 204, 66, 429,
2195  455, 456, 645, 457, 0, 645, 363, 0, 0, 361,
2196  0, 0, 0, 323, 0, 0, 439, 0, 0, 0,
2197  0, 439, 333, 607, 565, 0, 565, 338, 425, 426,
2198  0, 259, 308, 20, 634, 0, 376, 0, 574, 0,
2199  406, 0, 590, 549, 576, 550, 550, 585, 645, 603,
2200  550, 595, 550, 573, 550, 502, 404, 634, 0, 402,
2201  401, 0, 61, 278, 439, 238, 40, 202, 0, 0,
2202  459, 364, 0, 12, 461, 0, 315, 316, 0, 0,
2203  273, 645, 326, 0, 540, 329, 634, 0, 0, 543,
2204  368, 379, 0, 374, 370, 417, 0, 0, 0, 416,
2205  0, 553, 0, 555, 545, 0, 561, 0, 558, 563,
2206  503, 400, 634, 0, 573, 385, 581, 582, 645, 645,
2207  592, 385, 385, 383, 449, 446, 0, 458, 0, 533,
2208  534, 289, 0, 460, 0, 319, 322, 451, 452, 450,
2209  0, 331, 542, 336, 544, 0, 0, 377, 0, 372,
2210  410, 634, 408, 411, 0, 0, 550, 550, 550, 550,
2211  0, 0, 403, 0, 391, 393, 0, 580, 0, 381,
2212  382, 0, 396, 0, 398, 300, 435, 645, 433, 645,
2213  645, 0, 0, 375, 0, 0, 407, 420, 419, 554,
2214  0, 551, 556, 559, 0, 405, 591, 384, 385, 385,
2215  300, 435, 583, 645, 385, 593, 385, 385, 623, 299,
2216  634, 619, 620, 453, 362, 327, 339, 373, 409, 550,
2217  504, 0, 388, 0, 390, 623, 299, 380, 0, 397,
2218  0, 394, 399, 439, 552, 385, 385, 385, 385, 389,
2219  0, 386, 392, 395, 385, 387
2220 };
2221 
2222 /* YYDEFGOTO[NTERM-NUM]. */
2223 static const yytype_int16 yydefgoto[] =
2224 {
2225  -1, 1, 2, 68, 69, 70, 241, 577, 578, 257,
2226  258, 455, 259, 446, 72, 530, 73, 366, 74, 75,
2227  517, 700, 76, 77, 78, 260, 79, 80, 81, 475,
2228  82, 214, 385, 386, 196, 197, 198, 199, 616, 566,
2229  201, 84, 448, 357, 85, 216, 265, 535, 233, 759,
2230  435, 436, 230, 231, 218, 422, 437, 523, 524, 86,
2231  364, 263, 264, 646, 636, 368, 851, 369, 852, 746,
2232  980, 749, 747, 602, 604, 756, 757, 929, 250, 88,
2233  89, 90, 91, 92, 93, 94, 95, 96, 97, 727,
2234  580, 735, 848, 849, 377, 781, 782, 783, 1037, 1005,
2235  952, 898, 899, 879, 991, 992, 283, 284, 480, 786,
2236  881, 669, 939, 324, 518, 98, 99, 725, 718, 575,
2237  567, 322, 515, 514, 698, 699, 812, 696, 697, 810,
2238  587, 979, 729, 842, 909, 913, 100, 101, 102, 103,
2239  104, 105, 106, 295, 493, 107, 299, 108, 109, 297,
2240  301, 291, 289, 293, 485, 689, 688, 803, 895, 950,
2241  1000, 807, 110, 290, 111, 112, 113, 221, 222, 116,
2242  223, 224, 598, 748, 865, 866, 883, 789, 671, 672,
2243  673, 893, 675, 676, 677, 678, 957, 958, 679, 680,
2244  681, 682, 960, 961, 683, 684, 685, 686, 687, 792,
2245  404, 603, 270, 438, 226, 119, 640, 569, 607, 601,
2246  407, 308, 432, 433, 720, 466, 581, 372, 262
2247 };
2248 
2249 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2250  STATE-NUM. */
2251 #define YYPACT_NINF -884
2252 static const yytype_int16 yypact[] =
2253 {
2254  -884, 88, 2724, -884, 7808, -884, -884, -884, 7302, -884,
2255  -884, -884, -884, -884, -884, -884, 7925, 7925, -884, -884,
2256  7925, 4141, 3727, -884, -884, -884, -884, 47, 7166, -14,
2257  -884, 76, -884, -884, -884, 3037, 3865, -884, -884, 3175,
2258  -884, -884, -884, -884, -884, -884, -884, -884, 9329, 9329,
2259  64, 5501, 198, 8276, 8627, 7568, -884, 7030, -884, -884,
2260  -884, 19, 77, 111, 162, 796, 9446, 9329, -884, 383,
2261  -884, 1130, -884, 400, -884, -884, 106, 121, 99, -884,
2262  187, 9680, -884, 108, 3291, 472, 378, 566, -884, 9563,
2263  9563, -884, -884, 6402, 9793, 9906, 10019, 6893, 305, 84,
2264  -884, -884, 241, -884, -884, -884, -884, -884, -884, -884,
2265  -884, -884, -884, -884, 415, 621, -884, 285, 653, -884,
2266  -884, -884, -884, -884, -884, -884, -884, -884, -884, -884,
2267  -884, -884, -884, -884, -884, -884, -884, -884, -884, -884,
2268  -884, -884, -884, -884, -884, -884, -884, -884, -884, -884,
2269  -884, -884, -884, -884, -884, -884, -884, -884, -884, -884,
2270  -884, -884, -884, -884, -884, -884, -884, -884, -884, -884,
2271  -884, -884, -884, -884, -884, -884, -884, -884, -884, -884,
2272  -884, -884, -884, -884, -884, -884, -884, -884, -884, -884,
2273  -884, -884, -884, -884, -884, -884, -884, -884, -884, 240,
2274  -884, -884, -884, -884, 244, 9329, 332, 5633, 9329, 9329,
2275  9329, -884, 9329, -884, 280, 3291, 312, -884, -884, 276,
2276  610, 51, 355, 371, 387, 292, -884, -884, -884, 6285,
2277  -884, 7925, 7925, -884, -884, 6519, -884, 9563, 647, -884,
2278  278, 361, 5765, -884, -884, -884, 358, 401, 106, -884,
2279  693, 456, 714, 8042, -884, 5501, 404, 383, -884, 1130,
2280  -14, 424, -884, -14, 8042, 408, -21, -11, -884, 312,
2281  422, -11, -884, -14, 524, 796, 10132, 478, -884, 731,
2282  735, 758, 762, -884, -884, -884, -884, -884, -884, 729,
2283  -884, 891, 911, 452, 496, 957, 518, 80, 532, 977,
2284  539, 252, 564, -884, -884, -884, -884, -884, -884, -884,
2285  6636, 9563, 9563, 9563, 9563, 8042, 9563, 9563, -884, -884,
2286  -884, 568, -884, -884, -884, 8744, -884, 5501, 7688, 530,
2287  8744, 9329, 9329, 9329, 9329, 9329, -884, -884, 9329, 9329,
2288  9329, 9329, 9329, 9329, 9329, 9329, 9329, -884, -884, 9329,
2289  9329, 9329, 9329, 9329, 9329, 9329, 9329, 9329, 9329, -884,
2290  2448, 7925, -884, 10421, 4838, 400, 148, 148, 9563, 9563,
2291  383, 658, 536, 630, -884, -884, 790, 663, 59, 75,
2292  92, 67, 463, 9563, 356, -884, 578, 795, -884, -884,
2293  -884, -884, 4, 27, 31, 97, 266, 327, 339, 344,
2294  414, -884, -884, -884, 443, -884, -884, 10502, -884, -884,
2295  9446, 9446, -884, -884, 473, -884, -884, -884, 699, 9329,
2296  9329, 8159, -884, -884, 10583, 7925, 10664, 9329, 9329, 8393,
2297  -884, -14, 577, -884, -884, -14, -884, 567, 582, -884,
2298  157, -884, -884, -884, -884, -884, 7302, -884, 9329, 5908,
2299  585, 10583, 10664, 9329, 1130, 591, -14, -884, -884, 6753,
2300  593, -884, 1130, -884, 8510, -884, -884, 8627, -884, -884,
2301  -884, 278, 805, -884, -884, 604, 10132, 10745, 7925, 10826,
2302  1469, -884, -884, -884, -884, -884, -884, -884, -884, -884,
2303  -884, -884, -884, 331, -884, -884, 602, -884, -884, -884,
2304  493, -884, 605, -884, 9329, -884, -884, -884, -884, -884,
2305  -884, -884, -884, -884, -884, -884, -884, -884, -884, 9329,
2306  -884, 612, 616, -884, -884, -14, 10132, 619, -884, -884,
2307  -884, 713, 644, 1889, -884, -884, -884, 808, 489, 456,
2308  2576, 2576, 2576, 2576, 3705, 3567, 2576, 2576, 3429, 3429,
2309  544, 544, 11504, 835, 835, 1112, 352, 352, 456, 456,
2310  456, 1188, 1188, 4279, 3313, 4555, 3451, 401, 627, -884,
2311  -14, 780, -884, 893, -884, 401, 4003, 763, 768, -884,
2312  4981, 769, 5267, 140, 140, 658, 8861, 763, 96, 10907,
2313  7925, 10988, -884, 400, -884, 805, -884, -884, -884, 11069,
2314  7925, 10502, 4838, 9563, -884, -884, -884, -884, -884, -884,
2315  2107, -884, 3153, -884, -884, -884, 7302, 9329, -884, 9329,
2316  312, -884, 292, 2899, 3589, -14, 504, 521, -884, -884,
2317  -884, -884, 8159, 8393, -884, -884, 9563, 3291, 650, -884,
2318  -884, -884, -884, 5908, 28, -884, -14, -11, 10132, 604,
2319  384, 596, -14, 437, 444, -884, -884, -884, -884, -884,
2320  -884, -884, 1169, -884, -884, -884, -884, -884, 1619, -884,
2321  -884, -884, -884, -884, 685, -884, 670, 9329, -884, 690,
2322  778, 695, -884, 698, 792, 710, 800, -884, -884, 1153,
2323  -884, -884, -884, -884, -884, 456, 838, -884, 725, -884,
2324  -884, 851, 727, 8978, -884, 604, 10132, 8042, 9446, 9329,
2325  11150, 7925, 11231, 746, 9446, 9446, -884, 568, 401, 728,
2326  959, 9446, 9446, -884, 568, 401, -884, -884, 9095, 858,
2327  -884, 440, -884, 858, -884, -884, -884, -884, 763, 101,
2328  -884, 65, 164, -14, 112, 147, 9563, 383, 9563, 4838,
2329  603, 596, -884, -14, 763, 157, 741, 7438, -884, 84,
2330  121, -884, -884, -884, -884, -884, 9329, 9329, 527, 9329,
2331  9329, 747, 157, -884, 753, -884, -884, -884, 495, 1169,
2332  482, -884, 752, -14, -884, -14, -884, 9329, 1619, -884,
2333  -884, 60, -884, -884, -884, 33, -884, 1619, -884, -884,
2334  1227, -884, -884, -884, -884, -884, -884, -884, -884, -884,
2335  18, -884, 18, 756, -884, 9329, 766, 604, -884, 3291,
2336  4417, 4693, -14, 586, 599, 9329, -884, -884, -884, -884,
2337  -884, -884, -884, 9446, -884, -884, -884, -884, -884, -884,
2338  612, -884, 816, -884, 5384, 890, -884, 9563, 763, -884,
2339  763, 6051, 6051, -884, 9212, 5124, 154, 140, 4838, 383,
2340  763, -884, -884, -884, 1619, 4838, 1619, -884, -884, -884,
2341  9329, 8393, -884, -884, -14, 1108, 776, 1314, -884, 774,
2342  786, 68, -884, -884, -884, 801, 806, -884, 695, -884,
2343  809, -884, 811, -884, 809, -884, -884, 1236, 4838, -884,
2344  -884, 5765, -884, 813, 617, 3291, -884, -884, 10245, 148,
2345  -884, -884, 6051, -884, -884, 148, -884, -884, 763, 763,
2346  -884, 308, -884, 763, -884, -884, -14, 763, 383, 741,
2347  -884, 814, 1108, 744, -884, -884, 1195, 6051, 5765, -884,
2348  1619, -884, 1227, -884, -884, 1227, -884, 1227, -884, -884,
2349  -884, -884, -14, 810, 850, 831, 10358, -884, 841, 695,
2350  -884, 843, 849, -884, -884, -884, 877, -884, 900, 208,
2351  218, 234, 4838, -884, 4981, -884, -884, -884, -884, -884,
2352  6051, -884, -884, -884, -884, 4838, 1108, 814, 1108, 853,
2353  -884, 169, -884, -884, 763, 856, 809, 855, 809, 809,
2354  6168, 875, -884, 10358, 1619, -884, 944, 918, 60, -884,
2355  -884, 1619, -884, 1227, -884, 256, 11312, 7925, 11393, 768,
2356  440, 763, 763, 814, 1108, 1195, -884, -884, -884, -884,
2357  1227, -884, -884, -884, 897, -884, 918, -884, 865, 872,
2358  -884, 11474, -884, 695, 885, -884, 889, 885, 260, 318,
2359  -14, 348, 367, -884, -884, -884, -884, 814, -884, 809,
2360  -884, 1619, -884, 1227, -884, 888, 896, -884, 1227, -884,
2361  1227, -884, -884, 368, -884, 885, 909, 885, 885, -884,
2362  1227, -884, -884, -884, 885, -884
2363 };
2364 
2365 /* YYPGOTO[NTERM-NUM]. */
2366 static const yytype_int16 yypgoto[] =
2367 {
2368  -884, -884, -884, -380, -884, 39, -884, -412, -27, -884,
2369  569, -884, 81, -884, -223, -374, -61, -52, -59, -884,
2370  -378, -884, 2134, -5, 961, -169, 15, -76, -884, -432,
2371  0, 1449, -319, 955, -49, -884, -12, -884, -884, 32,
2372  -884, 767, -884, 973, -884, 1135, -884, 215, -67, 336,
2373  -322, 89, -9, -884, -375, -206, 5, -884, -304, -32,
2374  -884, -884, -884, -884, -884, -884, -884, -884, -884, -884,
2375  -884, -884, -884, -884, -884, -884, -884, -884, 57, -884,
2376  -884, -884, -884, -884, -884, -884, -884, -884, -884, -168,
2377  -349, -531, 43, -642, -884, -809, -805, 286, 171, 91,
2378  -884, 263, -884, -786, -884, 53, -884, -884, -884, -884,
2379  -884, -884, -884, 319, -884, -884, -884, -884, -884, -884,
2380  -884, -98, -884, -884, 372, -884, -884, 562, -884, -884,
2381  -543, -884, 63, -884, -884, -884, -884, -884, -884, 986,
2382  -884, -884, -884, -884, 794, -884, -884, -884, -884, -884,
2383  -884, 880, 1035, -884, -86, -884, -884, -884, -884, -884,
2384  -884, -884, 2, -884, 6, -884, -8, 1181, 1352, 998,
2385  1693, 938, -884, -884, 174, -884, -460, 153, -589, -861,
2386  -211, -433, -706, 259, 73, 313, 107, -884, -884, -884,
2387  3, -741, -883, 110, 338, -884, -675, -884, -145, -601,
2388  -884, -884, -884, 82, -396, -884, -282, -884, -884, -81,
2389  -884, -43, -25, -159, -580, -236, -66, 26, -2
2390 };
2391 
2392 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
2393  positive, shift that token. If negative, reduce the rule which
2394  number is the opposite. If zero, do what YYDEFACT says.
2395  If YYTABLE_NINF, syntax error. */
2396 #define YYTABLE_NINF -646
2397 static const yytype_int16 yytable[] =
2398 {
2399  120, 408, 237, 309, 240, 329, 363, 303, 288, 320,
2400  202, 213, 213, 234, 203, 213, 239, 406, 582, 430,
2401  670, 219, 219, 278, 256, 219, 536, 309, 365, 365,
2402  202, 468, 365, 628, 203, 470, 611, 614, 367, 570,
2403  200, 370, 738, 121, 649, 768, 621, 674, 402, 278,
2404  371, 268, 272, 737, 621, 277, 891, 302, 266, 87,
2405  200, 87, 278, 278, 278, 596, 261, 321, 934, 638,
2406  931, 628, 778, 220, 220, 993, 441, 220, 568, 785,
2407  796, 576, 884, 71, -103, 71, 456, 845, 3, 200,
2408  -107, 850, -527, -616, 705, 310, 896, 937, 225, 225,
2409  -104, 460, 225, 625, 461, 217, 227, 529, 87, 228,
2410  318, 953, 279, 886, 579, -526, 464, -111, 660, -528,
2411  252, -110, 892, 220, 465, 610, 467, 987, 1045, 200,
2412  661, 236, 318, 665, 465, 267, 271, -106, 279, 426,
2413  897, -535, 568, 496, 576, -75, 220, 220, -527, 323,
2414  220, 376, 387, 387, -521, -521, 652, 666, 525, 664,
2415  665, 579, 294, 856, 993, -89, 1001, 734, -103, 452,
2416  641, -526, -108, 861, 440, -528, 442, 934, 1045, -105,
2417  256, 320, 938, 1023, 666, -529, 235, 529, 529, -109,
2418  754, 309, 236, 497, 316, 317, -94, 641, 479, 891,
2419  474, -616, -98, -521, -619, 487, -616, 490, 670, 494,
2420  242, -521, -95, 494, 458, 450, 325, 423, 319, 1057,
2421  296, -103, 962, 423, 213, 330, 213, 213, 256, -102,
2422  439, -104, 430, -101, 219, 674, 219, 628, 854, 884,
2423  319, -529, 904, 306, 278, 232, 307, -111, 471, -97,
2424  365, 365, 365, 365, 298, 512, 513, 621, 621, 507,
2425  508, 509, 510, 774, 87, 997, 520, 473, 743, -110,
2426  261, 531, 629, -107, 817, 926, 631, 928, 753, 977,
2427  752, 634, 306, 459, -99, 307, 220, 944, 220, 220,
2428  306, -96, 220, 307, 220, 591, 278, 644, 884, 87,
2429  256, -100, 236, -620, 309, 300, 1025, 365, 365, 641,
2430  87, 225, 87, 225, 236, 502, 583, 584, 431, 641,
2431  434, 87, 593, 844, 326, 586, 922, 585, 527, 1039,
2432  522, -109, 487, 279, 454, 522, 1046, 860, -293, 830,
2433  826, 828, 261, -293, 58, 462, 838, 834, 836, 506,
2434  -103, 531, 531, -103, -531, 674, 213, 1009, 1010, 439,
2435  -104, -106, 884, -104, 674, 503, 704, 87, 220, 220,
2436  220, 220, 87, 220, 220, 410, -111, 412, 978, -111,
2437  -108, -105, 220, 235, 87, 279, 1076, 537, 414, 822,
2438  855, 71, 359, 405, 481, 574, 511, 419, -110, -619,
2439  474, -110, -107, 420, 670, -107, 670, 691, 594, -98,
2440  -531, 776, 595, 421, 691, -530, 765, 447, 220, 740,
2441  213, 87, 331, 439, 841, 220, 220, -532, 568, 429,
2442  576, 674, -521, 674, 635, 423, 423, 316, 317, 574,
2443  220, 482, 1067, 483, 278, -536, 923, 120, 202, 362,
2444  474, 784, 203, 927, 847, 844, 712, -620, 574, 906,
2445  -109, 427, -97, -109, 954, -344, -344, 537, 537, -99,
2446  1073, -530, -104, 213, 690, 628, 439, 428, 200, 354,
2447  355, 356, 220, -532, 574, 529, 964, 775, -521, -617,
2448  -106, 529, 529, -106, 278, 449, 621, 229, 529, 529,
2449  716, -98, -524, 622, -111, -535, 87, 674, 723, -108,
2450  -105, 574, -108, -105, -344, 481, 87, 736, 736, 489,
2451  -96, -98, -344, -619, -98, 306, 331, 713, 307, -98,
2452  71, 605, -103, 279, 655, 220, 656, 657, 658, 659,
2453  232, -74, 755, 758, 457, 719, 647, 336, 337, 463,
2454  -524, -524, -94, 731, -97, 733, 481, 469, -524, 717,
2455  972, -99, 482, 453, 483, 765, 974, 724, 784, 876,
2456  853, 954, 777, 1022, -97, 772, 730, -97, 954, 411,
2457  472, -99, -97, 279, -99, 213, 862, 606, 439, -99,
2458  -110, 739, 347, 348, 769, 213, 863, -617, 439, -524,
2459  719, 760, -617, 482, 762, 483, -111, -524, 761, 491,
2460  529, 770, -96, 872, 331, 476, 278, 870, 202, 875,
2461  423, -106, 203, 574, 878, 613, 615, 719, 954, -623,
2462  474, 495, -96, 574, 504, -96, 693, 87, -108, 87,
2463  -96, 120, 613, 615, -105, 498, 889, 220, 200, 531,
2464  889, 831, 501, 359, 360, 531, 531, 220, 758, 87,
2465  220, 868, 531, 531, 784, 516, 784, 528, 642, 352,
2466  353, 354, 355, 356, 278, 586, 721, 793, 505, 793,
2467  916, 858, 917, -299, -299, 365, 588, 365, 592, 722,
2468  -623, -623, 925, 220, 857, 1050, 859, 359, 424, 597,
2469  87, 443, 361, -106, 632, 279, 213, 833, 867, 439,
2470  362, -536, 444, 445, 771, 930, -108, 630, 719, 633,
2471  639, 784, 989, 761, 71, 643, 843, 846, 719, 846,
2472  -89, 846, -299, 522, -105, -620, 641, -623, -104, -623,
2473  -299, 648, -619, 411, 574, 692, 425, -623, 694, -271,
2474  975, 976, 963, 703, 362, 981, 706, 707, -95, 983,
2475  880, 708, 481, 279, 87, 537, -430, 982, 220, 423,
2476  -111, 537, 537, 726, 531, 784, 728, 784, 537, 537,
2477  359, 451, 732, 215, 215, 773, 365, 215, 818, 200,
2478  -102, 736, 481, 924, 888, 915, 655, 719, 656, 657,
2479  658, 659, 787, 220, 453, 220, 87, 788, 900, 482,
2480  900, 483, 486, 784, 617, 249, 251, 911, 359, 477,
2481  215, 215, -533, -533, 918, 919, 1027, 791, 921, 425,
2482  794, -110, 795, 304, 305, 797, 798, 362, 801, 482,
2483  910, 483, 484, 914, 799, -534, -534, 800, 809, -289,
2484  -289, -101, 802, 1055, 1056, 41, 42, 43, 44, 963,
2485  811, 814, 984, 889, -272, 825, 963, 478, 963, 832,
2486  721, -533, 880, 844, 965, 362, 278, 359, 589, -533,
2487  864, 988, 359, 599, 871, 973, 793, 1018, 873, 877,
2488  537, 902, -300, -300, -534, 359, 710, -106, -289, 912,
2489  959, 87, -534, -273, 220, 331, -289, 908, 87, 87,
2490  994, 995, 87, 932, 935, 87, 963, -97, 963, 846,
2491  344, 345, 87, 963, 278, 963, 590, 880, 936, 827,
2492  829, 600, 1002, 1015, 362, 963, 835, 837, 940, 362,
2493  118, -300, 118, 942, 711, 1019, 945, 1020, 947, -300,
2494  -274, 986, 362, 1021, 481, 87, 793, 793, 87, 351,
2495  352, 353, 354, 355, 356, 968, 1026, 1003, 1004, 87,
2496  956, 278, 215, 1034, 481, 215, 215, 215, 1008, 304,
2497  1011, 827, 829, 722, 835, 837, 1013, 359, 1016, 118,
2498  1024, 1028, 1030, 282, 87, 87, 215, 1035, 215, 215,
2499  1040, 482, 1061, 483, 486, 359, 1041, 959, 1060, 1063,
2500  -108, 1043, 213, 1007, 959, 439, 959, 730, 846, 282,
2501  481, 482, 1068, 483, 488, 719, 1070, -619, 645, 87,
2502  -99, 87, 380, 390, 390, -620, 1017, 87, 941, 943,
2503  481, 793, 87, 946, 362, 948, 1080, 949, 907, 833,
2504  574, 391, 1012, 1014, 600, 374, 890, 87, 358, 894,
2505  1036, 839, 362, 1054, 959, 874, 959, 482, 951, 483,
2506  492, 959, 813, 959, 220, 901, -105, 956, 1058, 869,
2507  701, 956, 1053, 959, 956, 907, 956, 482, 409, 483,
2508  499, 418, 215, 500, 292, 403, -96, 533, 539, 540,
2509  541, 542, 543, 985, 887, 544, 545, 546, 547, 548,
2510  549, 550, 551, 552, 1038, 1042, 553, 554, 555, 556,
2511  557, 558, 559, 560, 561, 562, 885, 0, 215, 1062,
2512  1064, 0, 0, 0, 956, 1069, 956, 1071, 1072, 0,
2513  0, 956, 0, 956, 0, 118, 0, 0, 0, 1029,
2514  1031, 1032, 1033, 956, 0, 0, 955, 0, 0, 0,
2515  655, 0, 656, 657, 658, 659, 1079, 1081, 1082, 1083,
2516  311, 312, 313, 314, 315, 1085, 0, 612, 612, 0,
2517  118, 0, 331, 114, 0, 114, 612, 215, 215, 269,
2518  0, 118, 215, 118, 612, 612, 215, 344, 345, 996,
2519  779, 998, 118, 0, 0, 0, 999, 804, 805, 0,
2520  806, 0, 1074, 0, 282, 637, 0, 0, 46, 47,
2521  612, 655, 0, 656, 657, 658, 659, 0, 0, 0,
2522  0, 215, 114, 0, 215, 0, 280, 352, 353, 354,
2523  355, 356, 0, 0, 0, 215, 0, 990, 118, 656,
2524  657, 658, 659, 118, 0, 0, 0, 0, 331, 0,
2525  0, 779, 280, 0, 0, 118, 282, 780, 538, 0,
2526  1044, 695, 1047, 344, 345, 378, 388, 388, 388, 655,
2527  0, 656, 657, 658, 659, 660, 215, 0, 655, 1059,
2528  656, 657, 658, 659, 660, 0, 0, 661, 0, 0,
2529  0, 0, 118, 0, 0, 0, 661, 0, 0, 0,
2530  349, 350, 351, 352, 353, 354, 355, 356, 0, 662,
2531  1075, 0, 1077, 0, 0, 0, 664, 665, 662, 1078,
2532  0, 0, 0, 0, 663, 664, 665, 0, 0, 1084,
2533  413, 0, 0, 415, 416, 417, 0, 0, 538, 538,
2534  0, 666, 0, 215, 115, 0, 115, 215, 0, 0,
2535  666, 0, 0, 667, 0, 0, 655, 215, 656, 657,
2536  658, 659, 0, 0, 0, 0, 0, 0, 0, 0,
2537  0, 236, 0, 0, 215, 0, 215, 118, 114, 0,
2538  0, 0, 0, 0, 0, 0, 0, 118, 0, 215,
2539  215, 0, 0, 115, 0, 0, 779, 281, 0, 0,
2540  0, 0, 933, 0, 282, 0, 0, 0, 0, 0,
2541  0, 0, 0, 114, 0, 0, 0, 0, 0, 0,
2542  0, 0, 0, 281, 114, 0, 114, 0, 0, 0,
2543  0, 0, 0, 0, 215, 114, 379, 389, 389, 389,
2544  0, 83, 0, 83, 0, 0, 0, 280, 0, 0,
2545  521, 0, 0, 0, 282, 534, 0, 0, 0, 0,
2546  215, 0, 0, 0, 0, 612, 819, 0, 215, 0,
2547  0, 612, 612, 0, 0, 0, 0, 0, 612, 612,
2548  0, 114, 0, 0, 0, 215, 114, 0, 0, 0,
2549  83, 0, 0, 0, 0, 0, 0, 0, 114, 280,
2550  0, 0, 0, 0, 0, 0, 0, 0, 118, 0,
2551  118, 655, 0, 656, 657, 658, 659, 660, 0, 0,
2552  0, 0, 0, 612, 612, 0, 612, 612, 0, 661,
2553  118, 0, 0, 375, 0, 114, 0, 0, 0, 0,
2554  0, 0, 0, 0, 215, 618, 620, 0, 0, 115,
2555  0, 662, 0, 0, 269, 0, 0, 663, 664, 665,
2556  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2557  0, 118, 215, 0, 0, 0, 282, 0, 0, 0,
2558  0, 0, 905, 666, 115, 0, 667, 0, 0, 620,
2559  612, 0, 269, 0, 0, 115, 0, 115, 668, 0,
2560  0, 0, 0, 0, 0, 0, 115, 0, 0, 0,
2561  0, 215, 0, 0, 0, 0, 0, 808, 281, 0,
2562  114, 0, 0, 0, 0, 0, 0, 612, 215, 0,
2563  114, 0, 0, 0, 282, 118, 538, 0, 0, 0,
2564  0, 0, 538, 538, 702, 0, 83, 280, 0, 538,
2565  538, 0, 115, 0, 0, 0, 0, 115, 0, 0,
2566  0, 655, 0, 656, 657, 658, 659, 660, 0, 115,
2567  281, 0, 0, 0, 0, 0, 0, 118, 0, 661,
2568  0, 83, 0, 0, 0, 117, 0, 117, 0, 0,
2569  0, 0, 83, 0, 83, 0, 0, 280, 0, 0,
2570  0, 662, 0, 83, 0, 0, 115, 663, 664, 665,
2571  0, 534, 0, 0, 0, 0, 0, 0, 0, 0,
2572  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2573  0, 0, 0, 666, 117, 0, 667, 0, 0, 0,
2574  0, 0, 763, 0, 764, 0, 0, 0, 0, 83,
2575  0, 114, 0, 114, 83, 0, 0, 620, 269, 0,
2576  0, 538, 0, 0, 0, 0, 83, 0, 0, 532,
2577  0, 0, 118, 114, 215, 0, 0, 0, 0, 118,
2578  118, 0, 0, 118, 0, 0, 118, 0, 0, 0,
2579  0, 115, 0, 118, 0, 0, 0, 0, 0, 0,
2580  0, 115, 790, 83, 0, 0, 0, 0, 0, 0,
2581  0, 0, 0, 0, 114, 0, 0, 0, 281, 280,
2582  0, 0, 0, 0, 0, 0, 118, 0, 816, 118,
2583  0, 0, 0, 0, 0, 0, 971, 0, 0, 0,
2584  118, 0, 0, 0, 0, 0, 0, 0, 0, 532,
2585  532, 0, 0, 840, 0, 0, 0, 0, 0, 0,
2586  0, 0, 0, 0, 0, 118, 118, 0, 281, 0,
2587  0, 0, 0, 0, 0, 0, 0, 280, 114, 0,
2588  0, 0, 0, 0, 390, 0, 0, 0, 83, 0,
2589  117, 0, 0, 0, 0, 0, 0, 0, 83, 0,
2590  118, 0, 118, 0, 0, 0, 0, 0, 118, 0,
2591  0, 0, 882, 118, 0, 0, 0, 0, 0, 0,
2592  114, 0, 115, 709, 115, 117, 0, 0, 118, 0,
2593  0, 390, 0, 0, 0, 0, 117, 0, 117, 0,
2594  903, 0, 0, 0, 115, 0, 0, 117, 0, 331,
2595  332, 333, 334, 335, 336, 337, 338, 339, 340, 341,
2596  342, 343, 0, 0, 344, 345, 0, 0, 0, 0,
2597  0, 0, 0, 0, 0, 0, 0, 0, 0, 920,
2598  0, 0, 0, 0, 0, 115, 0, 0, 0, 0,
2599  281, 0, 0, 117, 0, 0, 269, 346, 117, 347,
2600  348, 349, 350, 351, 352, 353, 354, 355, 356, 0,
2601  117, 0, 0, 117, 0, 114, -246, 0, 0, 83,
2602  0, 83, 114, 114, 0, 0, 114, 0, 0, 114,
2603  0, 0, 0, 0, 0, 0, 114, 0, 0, 0,
2604  0, 83, 0, 0, 0, 0, 0, 117, 281, 115,
2605  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2606  0, 0, 0, 0, 0, 0, 0, 0, 0, 114,
2607  0, 0, 114, 0, 0, 0, 0, 0, 0, 969,
2608  0, 0, 83, 114, 0, 0, 0, 0, 0, 0,
2609  0, 115, 0, 117, 117, 0, 0, -645, 0, 0,
2610  0, 0, 0, 0, 0, -645, -645, -645, 114, 114,
2611  -645, -645, -645, 0, -645, 0, 0, 0, 0, 0,
2612  0, 0, 0, -645, -645, 0, 0, 388, 0, 0,
2613  0, 0, 117, 0, -645, -645, 0, -645, -645, -645,
2614  -645, -645, 117, 114, 0, 114, 83, 532, 0, 0,
2615  0, 114, 0, 532, 532, 0, 114, 0, 0, 0,
2616  532, 532, 0, 0, 0, 0, 0, 0, 0, 0,
2617  0, 114, 248, 248, 388, 0, 0, 248, 248, 248,
2618  0, 0, 0, 0, -645, -645, 115, 0, 83, 0,
2619  0, 248, 0, 115, 115, 0, 0, 115, 0, 0,
2620  115, 0, 0, 0, 0, 248, 0, 115, -645, 0,
2621  0, 0, 0, 0, 0, 0, 0, 0, 248, 248,
2622  248, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2623  0, -645, -645, 0, 0, 0, 232, -645, 0, -645,
2624  115, -645, -645, 115, 0, 0, 0, 0, 0, 0,
2625  970, 0, 0, 0, 115, 0, 0, 0, 0, 0,
2626  0, 0, 0, 117, 0, 117, 0, 0, 0, 0,
2627  0, 0, 532, 0, 0, 0, 0, 0, 0, 115,
2628  115, 0, 0, 83, 0, 117, 0, 0, 0, 0,
2629  83, 83, 0, 0, 83, 0, 0, 83, 389, 0,
2630  0, 0, 0, 0, 83, 0, 0, 0, 0, 0,
2631  0, 0, 0, 0, 115, 0, 115, 0, 0, 0,
2632  0, 0, 115, 0, 0, 0, 117, 115, 0, 248,
2633  0, 0, 248, 248, 248, 0, 248, 83, 0, 0,
2634  83, 0, 115, 0, 0, 389, 0, 967, 0, 0,
2635  0, 83, 0, 0, 0, 0, 0, 0, 0, 0,
2636  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2637  0, 0, 0, 0, 0, 0, 83, 83, 0, 0,
2638  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2639  117, 117, 0, 0, 0, 0, 0, 117, 117, 0,
2640  248, 0, 0, 0, 117, 117, 0, 0, 0, 0,
2641  0, 83, 0, 83, 0, 0, 0, 0, 0, 83,
2642  0, 0, 0, 0, 83, 0, 0, 0, 0, 0,
2643  0, 0, 117, 0, 0, 0, 0, 0, 0, 83,
2644  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2645  0, 0, 248, 0, 0, 248, 248, 248, 248, 248,
2646  0, 0, 248, 248, 248, 248, 248, 248, 248, 248,
2647  248, 0, 0, 248, 248, 248, 248, 248, 248, 248,
2648  248, 248, 248, 0, 0, 0, 0, 0, 0, 0,
2649  563, 564, 0, 0, 565, 0, 0, 0, 0, 0,
2650  0, 0, 0, 0, 0, 0, 166, 167, 168, 169,
2651  170, 171, 172, 173, 174, 0, 117, 175, 176, 0,
2652  0, 177, 178, 179, 180, 0, 0, 117, 0, 0,
2653  0, 0, 0, 0, 117, 117, 181, 182, 117, 0,
2654  0, 117, 0, 248, 248, 248, 0, 0, 117, 0,
2655  0, 248, 248, 248, 0, 0, 0, 0, 183, 184,
2656  185, 186, 187, 188, 189, 190, 191, 192, 0, 193,
2657  194, 0, 248, 0, 0, 0, 195, 248, 0, 0,
2658  0, 117, 0, 0, 117, 0, 0, 0, 248, 0,
2659  0, 248, 0, 0, 0, 117, 0, 0, 0, 0,
2660  248, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2661  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2662  117, 117, 0, 0, 0, 0, 0, 0, 248, 0,
2663  0, 0, 0, 0, 0, 0, 331, -646, -646, -646,
2664  -646, 336, 337, 248, 0, -646, -646, 0, 0, 0,
2665  248, 344, 345, 0, 0, 117, 0, 117, 0, 0,
2666  0, 0, 0, 117, 0, 0, 0, 0, 117, 0,
2667  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2668  0, 0, 0, 117, 0, 0, 347, 348, 349, 350,
2669  351, 352, 353, 354, 355, 356, 0, 0, 0, 0,
2670  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2671  248, 0, 0, 0, -645, 4, 0, 5, 6, 7,
2672  8, 9, 0, 0, 0, 10, 11, 0, 0, 0,
2673  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
2674  0, 248, 0, 248, 20, 21, 22, 23, 24, 25,
2675  26, 0, 0, 27, 0, 0, 248, 248, 0, 28,
2676  29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
2677  39, 40, 248, 41, 42, 43, 44, 0, 45, 46,
2678  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2679  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2680  0, 248, 0, 50, 0, 0, 51, 52, 0, 53,
2681  54, 0, 55, 0, 0, 56, 57, 58, 59, 60,
2682  61, 62, 63, 64, 0, 0, 0, 248, 0, 0,
2683  248, 0, 0, 248, 0, 0, 0, 0, 0, 0,
2684  0, 0, 0, 0, 65, 66, 67, 0, 0, 0,
2685  0, 0, 248, 0, 0, 0, -645, 0, 0, -645,
2686  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2687  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2688  0, 0, 0, 0, 0, 0, 0, 0, 0, -623,
2689  248, 248, 0, 248, 248, 0, 0, -623, -623, -623,
2690  0, 0, -623, -623, -623, 0, -623, 0, 0, 0,
2691  0, 248, 0, 0, 0, -623, -623, -623, -623, 0,
2692  0, 0, 0, 0, 0, 0, -623, -623, 0, -623,
2693  -623, -623, -623, -623, 0, 0, 0, 0, 0, 248,
2694  0, 0, 0, 0, 0, 0, 0, 0, 0, 248,
2695  0, 0, 0, 0, 0, 0, 0, 0, 0, -623,
2696  -623, -623, -623, -623, -623, -623, -623, -623, -623, -623,
2697  -623, -623, 0, 0, -623, -623, -623, -623, 248, 766,
2698  -623, 0, 0, 0, 0, 0, -623, 0, 0, 0,
2699  0, 0, 0, 0, 248, 248, 0, 0, 0, 0,
2700  -623, 0, 0, -623, 0, 0, -107, -623, -623, -623,
2701  -623, -623, -623, -623, -623, -623, -623, -623, -623, 0,
2702  0, 0, 0, -623, -623, -623, -623, -521, 0, -623,
2703  -623, -623, 248, -623, -623, -521, -521, -521, 0, 0,
2704  -521, -521, -521, 0, -521, 0, 0, 0, 0, 0,
2705  0, 0, -521, 0, -521, -521, -521, 0, 0, 0,
2706  0, 0, 0, 0, -521, -521, 0, -521, -521, -521,
2707  -521, -521, 0, 0, 0, 0, 0, 0, 0, 0,
2708  248, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2709  0, 0, 0, 0, 0, 0, 0, -521, -521, -521,
2710  -521, -521, -521, -521, -521, -521, -521, -521, -521, -521,
2711  0, 0, -521, -521, -521, -521, 0, -521, -521, 0,
2712  0, 0, 0, 0, -521, 0, 0, 248, 0, 0,
2713  0, 0, 0, 0, 0, 0, 0, 0, -521, 0,
2714  0, -521, 0, 0, -521, -521, -521, -521, -521, -521,
2715  -521, -521, -521, -521, -521, -521, -521, 0, 0, 0,
2716  0, 0, -521, -521, -521, -524, 0, -521, -521, -521,
2717  0, -521, -521, -524, -524, -524, 0, 0, -524, -524,
2718  -524, 0, -524, 0, 0, 0, 0, 709, 0, 0,
2719  -524, 0, -524, -524, -524, 0, 0, 0, 0, 0,
2720  0, 0, -524, -524, 0, -524, -524, -524, -524, -524,
2721  0, 0, 0, 331, 332, 333, 334, 335, 336, 337,
2722  338, 339, 340, 341, 342, 343, 0, 0, 344, 345,
2723  0, 0, 0, 0, 0, -524, -524, -524, -524, -524,
2724  -524, -524, -524, -524, -524, -524, -524, -524, 0, 0,
2725  -524, -524, -524, -524, 0, -524, -524, 0, 0, 0,
2726  0, 346, -524, 347, 348, 349, 350, 351, 352, 353,
2727  354, 355, 356, 0, 0, 0, -524, 0, 0, -524,
2728  0, 0, -524, -524, -524, -524, -524, -524, -524, -524,
2729  -524, -524, -524, -524, -524, 0, 0, 0, 0, 0,
2730  -524, -524, -524, -624, 0, -524, -524, -524, 0, -524,
2731  -524, -624, -624, -624, 0, 0, -624, -624, -624, 0,
2732  -624, 0, 0, 0, 0, 0, 0, 0, 0, -624,
2733  -624, -624, -624, 0, 0, 0, 0, 0, 0, 0,
2734  -624, -624, 0, -624, -624, -624, -624, -624, 0, 0,
2735  0, 331, 332, 333, 334, 335, 336, 337, 338, 339,
2736  340, 341, 342, 343, 0, 0, 344, 345, 0, 0,
2737  0, 0, 0, -624, -624, -624, -624, -624, -624, -624,
2738  -624, -624, -624, -624, -624, -624, 0, 0, -624, -624,
2739  -624, -624, 0, 0, -624, 0, 0, 0, 0, 346,
2740  -624, 347, 348, 349, 350, 351, 352, 353, 354, 355,
2741  356, 0, 0, 0, -624, 0, 0, -624, 0, 0,
2742  0, -624, -624, -624, -624, -624, -624, -624, -624, -624,
2743  -624, -624, -624, 0, 0, 0, 0, -624, -624, -624,
2744  -624, -625, 0, -624, -624, -624, 0, -624, -624, -625,
2745  -625, -625, 0, 0, -625, -625, -625, 0, -625, 0,
2746  0, 0, 0, 0, 0, 0, 0, -625, -625, -625,
2747  -625, 0, 0, 0, 0, 0, 0, 0, -625, -625,
2748  0, -625, -625, -625, -625, -625, 0, 0, 0, 331,
2749  332, 333, 334, 335, 336, 337, 338, 339, 340, 341,
2750  -646, -646, 0, 0, 344, 345, 0, 0, 0, 0,
2751  0, -625, -625, -625, -625, -625, -625, -625, -625, -625,
2752  -625, -625, -625, -625, 0, 0, -625, -625, -625, -625,
2753  0, 0, -625, 0, 0, 0, 0, 0, -625, 347,
2754  348, 349, 350, 351, 352, 353, 354, 355, 356, 0,
2755  0, 0, -625, 0, 0, -625, 0, 0, 0, -625,
2756  -625, -625, -625, -625, -625, -625, -625, -625, -625, -625,
2757  -625, 0, 0, 0, 0, -625, -625, -625, -625, -299,
2758  0, -625, -625, -625, 0, -625, -625, -299, -299, -299,
2759  0, 0, -299, -299, -299, 0, -299, 0, 0, 0,
2760  0, 0, 0, 0, 0, 0, -299, -299, -299, 0,
2761  0, 0, 0, 0, 0, 0, -299, -299, 0, -299,
2762  -299, -299, -299, -299, 0, 0, 0, 331, 332, 333,
2763  334, 335, 336, 337, 338, 0, 340, 341, 0, 0,
2764  0, 0, 344, 345, 0, 0, 0, 0, 0, -299,
2765  -299, -299, -299, -299, -299, -299, -299, -299, -299, -299,
2766  -299, -299, 0, 0, -299, -299, -299, -299, 0, 767,
2767  -299, 0, 0, 0, 0, 0, -299, 347, 348, 349,
2768  350, 351, 352, 353, 354, 355, 356, 0, 0, 0,
2769  -299, 0, 0, -299, 0, 0, -109, -299, -299, -299,
2770  -299, -299, -299, -299, -299, -299, -299, -299, -299, 0,
2771  0, 0, 0, 0, -299, -299, -299, -438, 0, -299,
2772  -299, -299, 0, -299, -299, -438, -438, -438, 0, 0,
2773  -438, -438, -438, 0, -438, 0, 0, 0, 0, 0,
2774  0, 0, 0, -438, -438, -438, 0, 0, 0, 0,
2775  0, 0, 0, 0, -438, -438, 0, -438, -438, -438,
2776  -438, -438, 0, 0, 0, 331, 332, 333, 334, 335,
2777  336, 337, 0, 0, 340, 341, 0, 0, 0, 0,
2778  344, 345, 0, 0, 0, 0, 0, -438, -438, -438,
2779  -438, -438, -438, -438, -438, -438, -438, -438, -438, -438,
2780  0, 0, -438, -438, -438, -438, 0, 0, -438, 0,
2781  0, 0, 0, 0, -438, 347, 348, 349, 350, 351,
2782  352, 353, 354, 355, 356, 0, 0, 0, -438, 0,
2783  0, 0, 0, 0, 0, -438, 0, -438, -438, -438,
2784  -438, -438, -438, -438, -438, -438, -438, 0, 0, 0,
2785  0, -438, -438, -438, -438, -290, 232, -438, -438, -438,
2786  0, -438, -438, -290, -290, -290, 0, 0, -290, -290,
2787  -290, 0, -290, 0, 0, 0, 0, 0, 0, 0,
2788  0, 0, -290, -290, -290, 0, 0, 0, 0, 0,
2789  0, 0, -290, -290, 0, -290, -290, -290, -290, -290,
2790  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2791  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2792  0, 0, 0, 0, 0, -290, -290, -290, -290, -290,
2793  -290, -290, -290, -290, -290, -290, -290, -290, 0, 0,
2794  -290, -290, -290, -290, 0, 0, -290, 0, 0, 0,
2795  0, 0, -290, 0, 0, 0, 0, 0, 0, 0,
2796  0, 0, 0, 0, 0, 0, -290, 0, 0, -290,
2797  0, 0, 0, -290, -290, -290, -290, -290, -290, -290,
2798  -290, -290, -290, -290, -290, 0, 0, 0, 0, 0,
2799  -290, -290, -290, -428, 0, -290, -290, -290, 0, -290,
2800  -290, -428, -428, -428, 0, 0, -428, -428, -428, 0,
2801  -428, 0, 0, 0, 0, 0, 0, 0, 0, -428,
2802  -428, -428, 0, 0, 0, 0, 0, 0, 0, 0,
2803  -428, -428, 0, -428, -428, -428, -428, -428, 0, 0,
2804  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2805  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2806  0, 0, 0, -428, -428, -428, -428, -428, -428, -428,
2807  -428, -428, -428, -428, -428, -428, 0, 0, -428, -428,
2808  -428, -428, 0, 0, -428, 0, 0, 0, 0, 0,
2809  -428, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2810  0, 0, 0, 0, -428, 0, 0, 0, 0, 0,
2811  0, -428, 0, -428, -428, -428, -428, -428, -428, -428,
2812  -428, -428, -428, 0, 0, 0, 0, -428, -428, -428,
2813  -428, -306, -428, -428, -428, -428, 0, -428, -428, -306,
2814  -306, -306, 0, 0, -306, -306, -306, 0, -306, 0,
2815  0, 0, 0, 0, 0, 0, 0, 0, -306, -306,
2816  0, 0, 0, 0, 0, 0, 0, 0, -306, -306,
2817  0, -306, -306, -306, -306, -306, 0, 0, 0, 0,
2818  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2819  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2820  0, -306, -306, -306, -306, -306, -306, -306, -306, -306,
2821  -306, -306, -306, -306, 0, 0, -306, -306, -306, -306,
2822  0, 0, -306, 0, 0, 0, 0, 0, -306, 0,
2823  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2824  0, 0, -306, 0, 0, 0, 0, 0, 0, -306,
2825  0, -306, -306, -306, -306, -306, -306, -306, -306, -306,
2826  -306, 0, 0, 0, 0, 0, -306, -306, -306, -623,
2827  229, -306, -306, -306, 0, -306, -306, -623, -623, -623,
2828  0, 0, 0, -623, -623, 0, -623, 0, 0, 0,
2829  0, 0, 0, 0, 0, -623, 0, 0, 0, 0,
2830  0, 0, 0, 0, 0, 0, -623, -623, 0, -623,
2831  -623, -623, -623, -623, 0, 0, 0, 0, 0, 0,
2832  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2833  0, 0, 0, 0, 0, 0, 0, 0, 0, -623,
2834  -623, -623, -623, -623, -623, -623, -623, -623, -623, -623,
2835  -623, -623, 0, 0, -623, -623, -623, -623, 0, 714,
2836  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2837  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2838  -623, 0, 0, 0, 0, 0, -107, -623, 0, -623,
2839  -623, -623, -623, -623, -623, -623, -623, -623, -623, 0,
2840  0, 0, 0, -623, -623, -623, -98, -623, 0, -623,
2841  0, -623, 0, -623, -623, -623, -623, -623, 0, 0,
2842  0, -623, -623, 0, -623, 0, 0, 0, 0, 0,
2843  0, 0, 0, -623, 0, 0, 0, 0, 0, 0,
2844  0, 0, 0, 0, -623, -623, 0, -623, -623, -623,
2845  -623, -623, 0, 0, 0, 0, 0, 0, 0, 0,
2846  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2847  0, 0, 0, 0, 0, 0, 0, -623, -623, -623,
2848  -623, -623, -623, -623, -623, -623, -623, -623, -623, -623,
2849  0, 0, -623, -623, -623, -623, 0, 714, 0, 0,
2850  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2851  0, 0, 0, 0, 0, 0, 0, 0, -623, 0,
2852  0, 0, 0, 0, -107, -623, 0, -623, -623, -623,
2853  -623, -623, -623, -623, -623, -623, -623, 0, 0, 0,
2854  0, -623, -623, -623, -623, -299, 0, -623, 0, -623,
2855  0, -623, -623, -299, -299, -299, 0, 0, 0, -299,
2856  -299, 0, -299, 0, 0, 0, 0, 0, 0, 0,
2857  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2858  0, 0, -299, -299, 0, -299, -299, -299, -299, -299,
2859  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2860  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2861  0, 0, 0, 0, 0, -299, -299, -299, -299, -299,
2862  -299, -299, -299, -299, -299, -299, -299, -299, 0, 0,
2863  -299, -299, -299, -299, 0, 715, 0, 0, 0, 0,
2864  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2865  0, 0, 0, 0, 0, 0, -299, 0, 0, 0,
2866  0, 0, -109, -299, 0, -299, -299, -299, -299, -299,
2867  -299, -299, -299, -299, -299, 0, 0, 0, 0, 0,
2868  -299, -299, -100, -299, 0, -299, 0, -299, 0, -299,
2869  -299, -299, -299, -299, 0, 0, 0, -299, -299, 0,
2870  -299, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2871  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2872  -299, -299, 0, -299, -299, -299, -299, -299, 0, 0,
2873  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2874  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2875  0, 0, 0, -299, -299, -299, -299, -299, -299, -299,
2876  -299, -299, -299, -299, -299, -299, 0, 0, -299, -299,
2877  -299, -299, 0, 715, 0, 0, 0, 0, 0, 0,
2878  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2879  0, 0, 0, 0, -299, 0, 0, 0, 0, 0,
2880  -109, -299, 0, -299, -299, -299, -299, -299, -299, -299,
2881  -299, -299, -299, 0, 0, 0, 0, 0, -299, -299,
2882  -299, 0, 0, -299, 0, -299, 0, -299, -299, 253,
2883  0, 5, 6, 7, 8, 9, -645, -645, -645, 10,
2884  11, 0, 0, -645, 12, 0, 13, 14, 15, 16,
2885  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2886  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2887  0, 0, 0, 28, 29, 254, 31, 32, 33, 34,
2888  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
2889  44, 0, 45, 46, 47, 0, 48, 49, 0, 0,
2890  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2891  0, 0, 0, 0, 0, 0, 0, 50, 0, 0,
2892  51, 52, 0, 53, 54, 0, 55, 0, 0, 56,
2893  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
2894  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2895  0, 0, 0, 0, 0, 0, 0, 0, 65, 66,
2896  67, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2897  -645, 0, 253, -645, 5, 6, 7, 8, 9, 0,
2898  0, -645, 10, 11, 0, -645, -645, 12, 0, 13,
2899  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
2900  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2901  27, 0, 0, 0, 0, 0, 28, 29, 254, 31,
2902  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2903  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2904  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2905  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2906  50, 0, 0, 51, 52, 0, 53, 54, 0, 55,
2907  0, 0, 56, 57, 58, 59, 60, 61, 62, 63,
2908  64, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2909  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2910  0, 65, 66, 67, 0, 0, 0, 0, 0, 0,
2911  0, 0, 0, -645, 0, 253, -645, 5, 6, 7,
2912  8, 9, 0, 0, -645, 10, 11, 0, 0, -645,
2913  12, -645, 13, 14, 15, 16, 17, 18, 19, 0,
2914  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
2915  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2916  29, 254, 31, 32, 33, 34, 35, 36, 37, 38,
2917  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2918  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2919  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2920  0, 0, 0, 50, 0, 0, 51, 52, 0, 53,
2921  54, 0, 55, 0, 0, 56, 57, 58, 59, 60,
2922  61, 62, 63, 64, 0, 0, 0, 0, 0, 0,
2923  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2924  0, 0, 0, 0, 65, 66, 67, 0, 0, 0,
2925  0, 0, 0, 0, 0, 0, -645, 0, 253, -645,
2926  5, 6, 7, 8, 9, 0, 0, -645, 10, 11,
2927  0, 0, -645, 12, 0, 13, 14, 15, 16, 17,
2928  18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2929  23, 24, 25, 26, 0, 0, 27, 0, 0, 0,
2930  0, 0, 28, 29, 254, 31, 32, 33, 34, 35,
2931  36, 37, 38, 39, 40, 0, 41, 42, 43, 44,
2932  0, 45, 46, 47, 0, 48, 49, 0, 0, 0,
2933  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2934  0, 0, 0, 0, 0, 0, 50, 0, 0, 51,
2935  52, 0, 53, 54, 0, 55, 0, 0, 56, 57,
2936  58, 59, 60, 61, 62, 63, 64, 0, 0, 0,
2937  0, 0, 0, 0, 0, 253, 0, 5, 6, 7,
2938  8, 9, 0, -645, -645, 10, 11, 65, 66, 67,
2939  12, 0, 13, 14, 15, 16, 17, 18, 19, -645,
2940  0, 0, -645, 0, 20, 21, 22, 23, 24, 25,
2941  26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2942  29, 254, 31, 32, 33, 34, 35, 36, 37, 38,
2943  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
2944  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
2945  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2946  0, 0, 0, 50, 0, 0, 51, 52, 0, 53,
2947  54, 0, 55, 0, 0, 56, 57, 58, 59, 60,
2948  61, 62, 63, 64, 0, 0, 0, 0, 0, 0,
2949  0, 0, 253, 0, 5, 6, 7, 8, 9, 0,
2950  0, 0, 10, 11, 65, 66, 67, 12, 0, 13,
2951  14, 15, 16, 17, 18, 19, -645, 0, 0, -645,
2952  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2953  27, 0, 0, 0, 0, 0, 28, 29, 254, 31,
2954  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
2955  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
2956  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2957  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2958  50, 0, 0, 255, 52, 0, 53, 54, 0, 55,
2959  0, 0, 56, 57, 58, 59, 60, 61, 62, 63,
2960  64, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2961  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2962  0, 65, 66, 67, 253, 0, 5, 6, 7, 8,
2963  9, -645, 0, -645, 10, 11, -645, 0, 0, 12,
2964  0, 13, 14, 15, 16, 17, 18, 19, 0, 0,
2965  0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
2966  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
2967  254, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2968  40, 0, 41, 42, 43, 44, 0, 45, 46, 47,
2969  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
2970  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2971  0, 0, 50, 0, 0, 51, 52, 0, 53, 54,
2972  0, 55, 0, 0, 56, 57, 58, 59, 60, 61,
2973  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
2974  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2975  0, 0, 0, 65, 66, 67, 253, 0, 5, 6,
2976  7, 8, 9, -645, 0, -645, 10, 11, -645, 0,
2977  0, 12, 0, 13, 14, 15, 16, 17, 18, 19,
2978  0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2979  25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2980  28, 29, 254, 31, 32, 33, 34, 35, 36, 37,
2981  38, 39, 40, 0, 41, 42, 43, 44, 0, 45,
2982  46, 47, 0, 48, 49, 0, 0, 0, 0, 0,
2983  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2984  0, 0, 0, 0, 50, 0, 0, 51, 52, 0,
2985  53, 54, 0, 55, 0, 0, 56, 57, 58, 59,
2986  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
2987  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2988  0, 0, 0, 0, 0, 65, 66, 67, 0, 0,
2989  -645, 0, 0, 0, 0, 0, 0, -645, 0, 4,
2990  -645, 5, 6, 7, 8, 9, 0, 0, 0, 10,
2991  11, 0, 0, 0, 12, 0, 13, 14, 15, 16,
2992  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
2993  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
2994  0, 0, 0, 28, 29, 30, 31, 32, 33, 34,
2995  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
2996  44, 0, 45, 46, 47, 0, 48, 49, 0, 0,
2997  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2998  0, 0, 0, 0, 0, 0, 0, 50, 0, 0,
2999  51, 52, 0, 53, 54, 0, 55, 0, 0, 56,
3000  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
3001  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3002  0, 0, 0, 0, 0, 0, 0, 0, 65, 66,
3003  67, 0, 0, -645, 0, 0, 0, 0, 0, 0,
3004  -645, 0, 253, -645, 5, 6, 7, 8, 9, 0,
3005  0, -645, 10, 11, 0, 0, 0, 12, 0, 13,
3006  14, 15, 16, 17, 18, 19, 0, 0, 0, 0,
3007  0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
3008  27, 0, 0, 0, 0, 0, 28, 29, 254, 31,
3009  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
3010  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
3011  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3012  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3013  50, 0, 0, 51, 52, 0, 53, 54, 0, 55,
3014  0, 0, 56, 57, 58, 59, 60, 61, 62, 63,
3015  64, 0, 0, 0, 0, 0, 0, 0, 0, 253,
3016  0, 5, 6, 7, 8, 9, 0, 0, 0, 10,
3017  11, 65, 66, 67, 12, 0, 13, 14, 15, 16,
3018  17, 18, 19, -645, 0, 0, -645, 0, 20, 21,
3019  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
3020  0, 0, 0, 28, 29, 254, 31, 32, 33, 34,
3021  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
3022  44, 0, 45, 46, 47, 0, 48, 49, 0, 0,
3023  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3024  0, 0, 0, 0, 0, 0, 0, 50, 0, 0,
3025  51, 52, 0, 53, 54, 0, 55, 0, 0, 56,
3026  57, 58, 59, 60, 61, 62, 63, 64, 0, -645,
3027  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
3028  7, 0, 9, 0, 0, 0, 10, 11, 65, 66,
3029  67, 12, 0, 13, 14, 15, 16, 17, 18, 19,
3030  -645, 0, 0, -645, 0, 20, 21, 22, 23, 24,
3031  25, 26, 0, 0, 204, 0, 0, 0, 0, 0,
3032  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
3033  38, 39, 40, 205, 41, 42, 43, 44, 0, 45,
3034  46, 47, 0, 48, 49, 0, 0, 0, 0, 0,
3035  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3036  0, 0, 0, 0, 206, 0, 0, 207, 52, 0,
3037  53, 54, 0, 208, 209, 210, 56, 57, 211, 59,
3038  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
3039  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
3040  0, 0, 0, 10, 11, 65, 212, 67, 12, 0,
3041  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
3042  236, 0, 20, 21, 22, 23, 24, 25, 26, 0,
3043  0, 27, 0, 0, 0, 0, 0, 0, 29, 0,
3044  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3045  0, 41, 42, 43, 44, 0, 45, 46, 47, 0,
3046  48, 49, 0, 0, 0, 0, 0, 0, 0, 0,
3047  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3048  0, 206, 0, 0, 207, 52, 0, 53, 54, 0,
3049  0, 0, 0, 56, 57, 58, 59, 60, 61, 62,
3050  63, 64, 0, 0, 0, 0, 0, 0, 0, 0,
3051  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
3052  10, 11, 65, 66, 67, 12, 0, 13, 14, 15,
3053  16, 17, 18, 19, 306, 0, 0, 307, 0, 20,
3054  21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
3055  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
3056  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
3057  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
3058  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3059  0, 0, 0, 0, 0, 0, 0, 0, 206, 0,
3060  0, 207, 52, 0, 53, 54, 0, 0, 0, 0,
3061  56, 57, 58, 59, 60, 61, 62, 63, 64, 0,
3062  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
3063  6, 7, 8, 9, 0, 0, 0, 10, 11, 65,
3064  66, 67, 12, 0, 13, 14, 15, 16, 17, 18,
3065  19, 0, 0, 0, 236, 0, 20, 21, 22, 23,
3066  24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
3067  0, 28, 29, 30, 31, 32, 33, 34, 35, 36,
3068  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
3069  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
3070  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3071  0, 0, 0, 0, 0, 50, 0, 0, 51, 52,
3072  0, 53, 54, 0, 55, 0, 0, 56, 57, 58,
3073  59, 60, 61, 62, 63, 64, 0, 0, 0, 0,
3074  0, 0, 0, 0, 0, 0, 5, 6, 7, 8,
3075  9, 0, 0, 0, 10, 11, 65, 66, 67, 12,
3076  0, 13, 14, 15, 16, 17, 18, 19, 505, 0,
3077  0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
3078  0, 0, 27, 0, 0, 0, 0, 0, 28, 29,
3079  254, 31, 32, 33, 34, 35, 36, 37, 38, 39,
3080  40, 0, 41, 42, 43, 44, 0, 45, 46, 47,
3081  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
3082  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3083  0, 0, 50, 0, 0, 51, 52, 0, 53, 54,
3084  0, 55, 0, 0, 56, 57, 58, 59, 60, 61,
3085  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
3086  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3087  0, 0, 0, 65, 66, 67, 0, 0, 0, 0,
3088  0, 0, 0, 0, 0, 505, 122, 123, 124, 125,
3089  126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
3090  136, 137, 138, 139, 140, 141, 142, 143, 144, 145,
3091  0, 0, 0, 146, 147, 148, 392, 393, 394, 395,
3092  153, 154, 155, 0, 0, 0, 0, 0, 156, 157,
3093  158, 159, 396, 397, 398, 399, 164, 37, 38, 400,
3094  40, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3095  0, 166, 167, 168, 169, 170, 171, 172, 173, 174,
3096  0, 0, 175, 176, 0, 0, 177, 178, 179, 180,
3097  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3098  0, 181, 182, 0, 0, 0, 0, 0, 0, 0,
3099  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3100  0, 0, 0, 183, 184, 185, 186, 187, 188, 189,
3101  190, 191, 192, 0, 193, 194, 0, 0, 0, 0,
3102  0, 195, 401, 122, 123, 124, 125, 126, 127, 128,
3103  129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
3104  139, 140, 141, 142, 143, 144, 145, 0, 0, 0,
3105  146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
3106  0, 0, 0, 0, 0, 156, 157, 158, 159, 160,
3107  161, 162, 163, 164, 285, 286, 165, 287, 0, 0,
3108  0, 0, 0, 0, 0, 0, 0, 0, 166, 167,
3109  168, 169, 170, 171, 172, 173, 174, 0, 0, 175,
3110  176, 0, 0, 177, 178, 179, 180, 0, 0, 0,
3111  0, 0, 0, 0, 0, 0, 0, 0, 181, 182,
3112  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3113  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3114  183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
3115  0, 193, 194, 0, 0, 0, 0, 0, 195, 122,
3116  123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
3117  133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
3118  143, 144, 145, 0, 0, 0, 146, 147, 148, 149,
3119  150, 151, 152, 153, 154, 155, 0, 0, 0, 0,
3120  0, 156, 157, 158, 159, 160, 161, 162, 163, 164,
3121  238, 0, 165, 0, 0, 0, 0, 0, 0, 0,
3122  0, 0, 0, 0, 166, 167, 168, 169, 170, 171,
3123  172, 173, 174, 0, 0, 175, 176, 0, 0, 177,
3124  178, 179, 180, 0, 0, 0, 0, 0, 0, 0,
3125  0, 0, 0, 0, 181, 182, 0, 0, 57, 0,
3126  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3127  0, 0, 0, 0, 0, 0, 183, 184, 185, 186,
3128  187, 188, 189, 190, 191, 192, 0, 193, 194, 0,
3129  0, 0, 0, 0, 195, 122, 123, 124, 125, 126,
3130  127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
3131  137, 138, 139, 140, 141, 142, 143, 144, 145, 0,
3132  0, 0, 146, 147, 148, 149, 150, 151, 152, 153,
3133  154, 155, 0, 0, 0, 0, 0, 156, 157, 158,
3134  159, 160, 161, 162, 163, 164, 0, 0, 165, 0,
3135  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3136  166, 167, 168, 169, 170, 171, 172, 173, 174, 0,
3137  0, 175, 176, 0, 0, 177, 178, 179, 180, 0,
3138  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3139  181, 182, 0, 0, 57, 0, 0, 0, 0, 0,
3140  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3141  0, 0, 183, 184, 185, 186, 187, 188, 189, 190,
3142  191, 192, 0, 193, 194, 0, 0, 0, 0, 0,
3143  195, 122, 123, 124, 125, 126, 127, 128, 129, 130,
3144  131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
3145  141, 142, 143, 144, 145, 0, 0, 0, 146, 147,
3146  148, 149, 150, 151, 152, 153, 154, 155, 0, 0,
3147  0, 0, 0, 156, 157, 158, 159, 160, 161, 162,
3148  163, 164, 0, 0, 165, 0, 0, 0, 0, 0,
3149  0, 0, 0, 0, 0, 0, 166, 167, 168, 169,
3150  170, 171, 172, 173, 174, 0, 0, 175, 176, 0,
3151  0, 177, 178, 179, 180, 0, 0, 0, 0, 0,
3152  0, 0, 0, 0, 0, 0, 181, 182, 0, 0,
3153  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3154  0, 0, 0, 0, 0, 0, 0, 0, 183, 184,
3155  185, 186, 187, 188, 189, 190, 191, 192, 0, 193,
3156  194, 5, 6, 7, 0, 9, 195, 0, 0, 10,
3157  11, 0, 0, 0, 12, 0, 13, 14, 15, 243,
3158  244, 18, 19, 0, 0, 0, 0, 0, 245, 246,
3159  247, 23, 24, 25, 26, 0, 0, 204, 0, 0,
3160  0, 0, 0, 0, 273, 0, 0, 32, 33, 34,
3161  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
3162  44, 0, 45, 46, 47, 0, 0, 0, 0, 0,
3163  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3164  0, 0, 0, 0, 0, 0, 0, 274, 0, 0,
3165  207, 52, 0, 53, 54, 0, 0, 0, 0, 56,
3166  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
3167  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3168  0, 5, 6, 7, 0, 9, 0, 0, 275, 10,
3169  11, 0, 0, 0, 12, 276, 13, 14, 15, 243,
3170  244, 18, 19, 0, 0, 0, 0, 0, 245, 246,
3171  247, 23, 24, 25, 26, 0, 0, 204, 0, 0,
3172  0, 0, 0, 0, 273, 0, 0, 32, 33, 34,
3173  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
3174  44, 0, 45, 46, 47, 0, 0, 0, 0, 0,
3175  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3176  0, 0, 0, 0, 0, 0, 0, 274, 0, 0,
3177  207, 52, 0, 53, 54, 0, 0, 0, 0, 56,
3178  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
3179  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3180  0, 5, 6, 7, 8, 9, 0, 0, 275, 10,
3181  11, 0, 0, 0, 12, 526, 13, 14, 15, 16,
3182  17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
3183  22, 23, 24, 25, 26, 0, 0, 27, 0, 0,
3184  0, 0, 0, 28, 29, 30, 31, 32, 33, 34,
3185  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
3186  44, 0, 45, 46, 47, 0, 48, 49, 0, 0,
3187  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3188  0, 0, 0, 0, 0, 0, 0, 50, 0, 0,
3189  51, 52, 0, 53, 54, 0, 55, 0, 0, 56,
3190  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
3191  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
3192  7, 0, 9, 0, 0, 0, 10, 11, 65, 66,
3193  67, 12, 0, 13, 14, 15, 16, 17, 18, 19,
3194  0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
3195  25, 26, 0, 0, 204, 0, 0, 0, 0, 0,
3196  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
3197  38, 39, 40, 205, 41, 42, 43, 44, 0, 45,
3198  46, 47, 0, 48, 49, 0, 0, 0, 0, 0,
3199  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3200  0, 0, 0, 0, 206, 0, 0, 207, 52, 0,
3201  53, 54, 0, 208, 209, 210, 56, 57, 211, 59,
3202  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
3203  0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
3204  0, 0, 0, 10, 11, 65, 212, 67, 12, 0,
3205  13, 14, 15, 16, 17, 18, 19, 0, 0, 0,
3206  0, 0, 20, 21, 22, 23, 24, 25, 26, 0,
3207  0, 27, 0, 0, 0, 0, 0, 28, 29, 0,
3208  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3209  0, 41, 42, 43, 44, 0, 45, 46, 47, 0,
3210  48, 49, 0, 0, 0, 0, 0, 0, 0, 0,
3211  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3212  0, 50, 0, 0, 51, 52, 0, 53, 54, 0,
3213  55, 0, 0, 56, 57, 58, 59, 60, 61, 62,
3214  63, 64, 0, 0, 0, 0, 0, 0, 0, 0,
3215  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
3216  10, 11, 65, 66, 67, 12, 0, 13, 14, 15,
3217  243, 244, 18, 19, 0, 0, 0, 0, 0, 245,
3218  246, 247, 23, 24, 25, 26, 0, 0, 204, 0,
3219  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
3220  34, 35, 36, 37, 38, 39, 40, 205, 41, 42,
3221  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
3222  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3223  0, 0, 0, 0, 0, 0, 0, 0, 206, 0,
3224  0, 207, 52, 0, 53, 54, 0, 619, 209, 210,
3225  56, 57, 211, 59, 60, 61, 62, 63, 64, 0,
3226  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
3227  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
3228  212, 67, 12, 0, 13, 14, 15, 243, 244, 18,
3229  19, 0, 0, 0, 0, 0, 245, 246, 247, 23,
3230  24, 25, 26, 0, 0, 204, 0, 0, 0, 0,
3231  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
3232  37, 38, 39, 40, 205, 41, 42, 43, 44, 0,
3233  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
3234  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3235  0, 0, 0, 0, 0, 206, 0, 0, 207, 52,
3236  0, 53, 54, 0, 208, 209, 0, 56, 57, 211,
3237  59, 60, 61, 62, 63, 64, 0, 0, 0, 0,
3238  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
3239  9, 0, 0, 0, 10, 11, 65, 212, 67, 12,
3240  0, 13, 14, 15, 243, 244, 18, 19, 0, 0,
3241  0, 0, 0, 245, 246, 247, 23, 24, 25, 26,
3242  0, 0, 204, 0, 0, 0, 0, 0, 0, 29,
3243  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
3244  40, 205, 41, 42, 43, 44, 0, 45, 46, 47,
3245  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
3246  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3247  0, 0, 206, 0, 0, 207, 52, 0, 53, 54,
3248  0, 0, 209, 210, 56, 57, 211, 59, 60, 61,
3249  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
3250  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3251  0, 10, 11, 65, 212, 67, 12, 0, 13, 14,
3252  15, 243, 244, 18, 19, 0, 0, 0, 0, 0,
3253  245, 246, 247, 23, 24, 25, 26, 0, 0, 204,
3254  0, 0, 0, 0, 0, 0, 29, 0, 0, 32,
3255  33, 34, 35, 36, 37, 38, 39, 40, 205, 41,
3256  42, 43, 44, 0, 45, 46, 47, 0, 48, 49,
3257  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3258  0, 0, 0, 0, 0, 0, 0, 0, 0, 206,
3259  0, 0, 207, 52, 0, 53, 54, 0, 619, 209,
3260  0, 56, 57, 211, 59, 60, 61, 62, 63, 64,
3261  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3262  5, 6, 7, 0, 9, 0, 0, 0, 10, 11,
3263  65, 212, 67, 12, 0, 13, 14, 15, 243, 244,
3264  18, 19, 0, 0, 0, 0, 0, 245, 246, 247,
3265  23, 24, 25, 26, 0, 0, 204, 0, 0, 0,
3266  0, 0, 0, 29, 0, 0, 32, 33, 34, 35,
3267  36, 37, 38, 39, 40, 205, 41, 42, 43, 44,
3268  0, 45, 46, 47, 0, 48, 49, 0, 0, 0,
3269  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3270  0, 0, 0, 0, 0, 0, 206, 0, 0, 207,
3271  52, 0, 53, 54, 0, 0, 209, 0, 56, 57,
3272  211, 59, 60, 61, 62, 63, 64, 0, 0, 0,
3273  0, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3274  0, 9, 0, 0, 0, 10, 11, 65, 212, 67,
3275  12, 0, 13, 14, 15, 16, 17, 18, 19, 0,
3276  0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
3277  26, 0, 0, 204, 0, 0, 0, 0, 0, 0,
3278  29, 0, 0, 32, 33, 34, 35, 36, 37, 38,
3279  39, 40, 0, 41, 42, 43, 44, 0, 45, 46,
3280  47, 0, 48, 49, 0, 0, 0, 0, 0, 0,
3281  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3282  0, 0, 0, 206, 0, 0, 207, 52, 0, 53,
3283  54, 0, 519, 0, 0, 56, 57, 58, 59, 60,
3284  61, 62, 63, 64, 0, 0, 0, 0, 0, 0,
3285  0, 0, 0, 0, 5, 6, 7, 0, 9, 0,
3286  0, 0, 10, 11, 65, 212, 67, 12, 0, 13,
3287  14, 15, 243, 244, 18, 19, 0, 0, 0, 0,
3288  0, 245, 246, 247, 23, 24, 25, 26, 0, 0,
3289  204, 0, 0, 0, 0, 0, 0, 29, 0, 0,
3290  32, 33, 34, 35, 36, 37, 38, 39, 40, 0,
3291  41, 42, 43, 44, 0, 45, 46, 47, 0, 48,
3292  49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3293  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3294  206, 0, 0, 207, 52, 0, 53, 54, 0, 208,
3295  0, 0, 56, 57, 58, 59, 60, 61, 62, 63,
3296  64, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3297  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
3298  11, 65, 212, 67, 12, 0, 13, 14, 15, 243,
3299  244, 18, 19, 0, 0, 0, 0, 0, 245, 246,
3300  247, 23, 24, 25, 26, 0, 0, 204, 0, 0,
3301  0, 0, 0, 0, 29, 0, 0, 32, 33, 34,
3302  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
3303  44, 0, 45, 46, 47, 0, 48, 49, 0, 0,
3304  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3305  0, 0, 0, 0, 0, 0, 0, 206, 0, 0,
3306  207, 52, 0, 53, 54, 0, 815, 0, 0, 56,
3307  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
3308  0, 0, 0, 0, 0, 0, 0, 0, 5, 6,
3309  7, 0, 9, 0, 0, 0, 10, 11, 65, 212,
3310  67, 12, 0, 13, 14, 15, 243, 244, 18, 19,
3311  0, 0, 0, 0, 0, 245, 246, 247, 23, 24,
3312  25, 26, 0, 0, 204, 0, 0, 0, 0, 0,
3313  0, 29, 0, 0, 32, 33, 34, 35, 36, 37,
3314  38, 39, 40, 0, 41, 42, 43, 44, 0, 45,
3315  46, 47, 0, 48, 49, 0, 0, 0, 0, 0,
3316  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3317  0, 0, 0, 0, 206, 0, 0, 207, 52, 0,
3318  53, 54, 0, 519, 0, 0, 56, 57, 58, 59,
3319  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
3320  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
3321  0, 0, 0, 10, 11, 65, 212, 67, 12, 0,
3322  13, 14, 15, 243, 244, 18, 19, 0, 0, 0,
3323  0, 0, 245, 246, 247, 23, 24, 25, 26, 0,
3324  0, 204, 0, 0, 0, 0, 0, 0, 29, 0,
3325  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3326  0, 41, 42, 43, 44, 0, 45, 46, 47, 0,
3327  48, 49, 0, 0, 0, 0, 0, 0, 0, 0,
3328  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3329  0, 206, 0, 0, 207, 52, 0, 53, 54, 0,
3330  619, 0, 0, 56, 57, 58, 59, 60, 61, 62,
3331  63, 64, 0, 0, 0, 0, 0, 0, 0, 0,
3332  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
3333  10, 11, 65, 212, 67, 12, 0, 13, 14, 15,
3334  243, 244, 18, 19, 0, 0, 0, 0, 0, 245,
3335  246, 247, 23, 24, 25, 26, 0, 0, 204, 0,
3336  0, 0, 0, 0, 0, 29, 0, 0, 32, 33,
3337  34, 35, 36, 37, 38, 39, 40, 0, 41, 42,
3338  43, 44, 0, 45, 46, 47, 0, 48, 49, 0,
3339  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3340  0, 0, 0, 0, 0, 0, 0, 0, 206, 0,
3341  0, 207, 52, 0, 53, 54, 0, 0, 0, 0,
3342  56, 57, 58, 59, 60, 61, 62, 63, 64, 0,
3343  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
3344  6, 7, 0, 9, 0, 0, 0, 10, 11, 65,
3345  212, 67, 12, 0, 13, 14, 15, 16, 17, 18,
3346  19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
3347  24, 25, 26, 0, 0, 204, 0, 0, 0, 0,
3348  0, 0, 29, 0, 0, 32, 33, 34, 35, 36,
3349  37, 38, 39, 40, 0, 41, 42, 43, 44, 0,
3350  45, 46, 47, 0, 48, 49, 0, 0, 0, 0,
3351  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3352  0, 0, 0, 0, 0, 206, 0, 0, 207, 52,
3353  0, 53, 54, 0, 0, 0, 0, 56, 57, 58,
3354  59, 60, 61, 62, 63, 64, 0, 0, 0, 0,
3355  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
3356  9, 0, 0, 0, 10, 11, 65, 212, 67, 12,
3357  0, 13, 14, 15, 16, 17, 18, 19, 0, 0,
3358  0, 0, 0, 20, 21, 22, 23, 24, 25, 26,
3359  0, 0, 27, 0, 0, 0, 0, 0, 0, 29,
3360  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
3361  40, 0, 41, 42, 43, 44, 0, 45, 46, 47,
3362  0, 48, 49, 0, 0, 0, 0, 0, 0, 0,
3363  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3364  0, 0, 206, 0, 0, 207, 52, 0, 53, 54,
3365  0, 0, 0, 0, 56, 57, 58, 59, 60, 61,
3366  62, 63, 64, 0, 0, 0, 0, 0, 0, 0,
3367  0, 0, 0, 5, 6, 7, 0, 9, 0, 0,
3368  0, 10, 11, 65, 66, 67, 12, 0, 13, 14,
3369  15, 243, 244, 18, 19, 0, 0, 0, 0, 0,
3370  245, 246, 247, 23, 24, 25, 26, 0, 0, 204,
3371  0, 0, 0, 0, 0, 0, 273, 0, 0, 32,
3372  33, 34, 35, 36, 37, 38, 39, 40, 0, 41,
3373  42, 43, 44, 0, 45, 46, 47, 0, 0, 0,
3374  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3375  0, 0, 0, 0, 0, 0, 0, 0, 0, 274,
3376  0, 0, 327, 52, 0, 53, 54, 0, 328, 0,
3377  0, 56, 57, 58, 59, 60, 61, 62, 63, 64,
3378  0, 0, 0, 0, 0, 0, 5, 6, 7, 0,
3379  9, 0, 0, 0, 10, 11, 0, 0, 0, 12,
3380  275, 13, 14, 15, 243, 244, 18, 19, 0, 0,
3381  0, 0, 0, 245, 246, 247, 23, 24, 25, 26,
3382  0, 0, 204, 0, 0, 0, 0, 0, 0, 273,
3383  0, 0, 32, 33, 34, 35, 36, 37, 38, 39,
3384  40, 0, 41, 42, 43, 44, 0, 45, 46, 47,
3385  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3386  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3387  0, 0, 373, 0, 0, 51, 52, 0, 53, 54,
3388  0, 55, 0, 0, 56, 57, 58, 59, 60, 61,
3389  62, 63, 64, 0, 0, 0, 0, 0, 0, 5,
3390  6, 7, 0, 9, 0, 0, 0, 10, 11, 0,
3391  0, 0, 12, 275, 13, 14, 15, 243, 244, 18,
3392  19, 0, 0, 0, 0, 0, 245, 246, 247, 23,
3393  24, 25, 26, 0, 0, 204, 0, 0, 0, 0,
3394  0, 0, 273, 0, 0, 32, 33, 34, 381, 36,
3395  37, 38, 382, 40, 0, 41, 42, 43, 44, 0,
3396  45, 46, 47, 0, 0, 0, 0, 0, 0, 0,
3397  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3398  0, 383, 0, 0, 0, 384, 0, 0, 207, 52,
3399  0, 53, 54, 0, 0, 0, 0, 56, 57, 58,
3400  59, 60, 61, 62, 63, 64, 0, 0, 0, 0,
3401  0, 0, 5, 6, 7, 0, 9, 0, 0, 0,
3402  10, 11, 0, 0, 0, 12, 275, 13, 14, 15,
3403  243, 244, 18, 19, 0, 0, 0, 0, 0, 245,
3404  246, 247, 23, 24, 25, 26, 0, 0, 204, 0,
3405  0, 0, 0, 0, 0, 273, 0, 0, 32, 33,
3406  34, 381, 36, 37, 38, 382, 40, 0, 41, 42,
3407  43, 44, 0, 45, 46, 47, 0, 0, 0, 0,
3408  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3409  0, 0, 0, 0, 0, 0, 0, 0, 384, 0,
3410  0, 207, 52, 0, 53, 54, 0, 0, 0, 0,
3411  56, 57, 58, 59, 60, 61, 62, 63, 64, 0,
3412  0, 0, 0, 0, 0, 5, 6, 7, 0, 9,
3413  0, 0, 0, 10, 11, 0, 0, 0, 12, 275,
3414  13, 14, 15, 243, 244, 18, 19, 0, 0, 0,
3415  0, 0, 245, 246, 247, 23, 24, 25, 26, 0,
3416  0, 204, 0, 0, 0, 0, 0, 0, 273, 0,
3417  0, 32, 33, 34, 35, 36, 37, 38, 39, 40,
3418  0, 41, 42, 43, 44, 0, 45, 46, 47, 0,
3419  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3420  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3421  0, 274, 0, 0, 327, 52, 0, 53, 54, 0,
3422  0, 0, 0, 56, 57, 58, 59, 60, 61, 62,
3423  63, 64, 0, 0, 0, 0, 0, 0, 5, 6,
3424  7, 0, 9, 0, 0, 0, 10, 11, 0, 0,
3425  0, 12, 275, 13, 14, 15, 243, 244, 18, 19,
3426  0, 0, 0, 0, 0, 245, 246, 247, 23, 24,
3427  25, 26, 0, 0, 204, 0, 0, 0, 0, 0,
3428  0, 273, 0, 0, 32, 33, 34, 35, 36, 37,
3429  38, 39, 40, 0, 41, 42, 43, 44, 0, 45,
3430  46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
3431  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3432  0, 0, 0, 0, 966, 0, 0, 207, 52, 0,
3433  53, 54, 0, 0, 0, 0, 56, 57, 58, 59,
3434  60, 61, 62, 63, 64, 0, 0, 0, 0, 0,
3435  0, 5, 6, 7, 0, 9, 0, 0, 0, 10,
3436  11, 0, 0, 0, 12, 275, 13, 14, 15, 243,
3437  244, 18, 19, 0, 0, 0, 0, 0, 245, 246,
3438  247, 23, 24, 25, 26, 0, 0, 204, 0, 0,
3439  0, 0, 0, 0, 273, 0, 0, 32, 33, 34,
3440  35, 36, 37, 38, 39, 40, 0, 41, 42, 43,
3441  44, 0, 45, 46, 47, 0, 0, 0, 0, 0,
3442  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3443  0, 0, 0, 0, 0, 0, 0, 1006, 0, 0,
3444  207, 52, 0, 53, 54, 0, 0, 0, 0, 56,
3445  57, 58, 59, 60, 61, 62, 63, 64, 0, 0,
3446  0, 0, 0, 571, 572, 0, 0, 573, 0, 0,
3447  0, 0, 0, 0, 0, 0, 0, 0, 275, 166,
3448  167, 168, 169, 170, 171, 172, 173, 174, 0, 0,
3449  175, 176, 0, 0, 177, 178, 179, 180, 0, 0,
3450  0, 0, 0, 0, 0, 0, 0, 0, 0, 181,
3451  182, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3452  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3453  0, 183, 184, 185, 186, 187, 188, 189, 190, 191,
3454  192, 0, 193, 194, 608, 572, 0, 0, 609, 195,
3455  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3456  166, 167, 168, 169, 170, 171, 172, 173, 174, 0,
3457  0, 175, 176, 0, 0, 177, 178, 179, 180, 0,
3458  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3459  181, 182, 0, 0, 0, 0, 0, 0, 0, 0,
3460  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3461  0, 0, 183, 184, 185, 186, 187, 188, 189, 190,
3462  191, 192, 0, 193, 194, 623, 564, 0, 0, 624,
3463  195, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3464  0, 166, 167, 168, 169, 170, 171, 172, 173, 174,
3465  0, 0, 175, 176, 0, 0, 177, 178, 179, 180,
3466  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3467  0, 181, 182, 0, 0, 0, 0, 0, 0, 0,
3468  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3469  0, 0, 0, 183, 184, 185, 186, 187, 188, 189,
3470  190, 191, 192, 0, 193, 194, 626, 572, 0, 0,
3471  627, 195, 0, 0, 0, 0, 0, 0, 0, 0,
3472  0, 0, 166, 167, 168, 169, 170, 171, 172, 173,
3473  174, 0, 0, 175, 176, 0, 0, 177, 178, 179,
3474  180, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3475  0, 0, 181, 182, 0, 0, 0, 0, 0, 0,
3476  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3477  0, 0, 0, 0, 183, 184, 185, 186, 187, 188,
3478  189, 190, 191, 192, 0, 193, 194, 650, 564, 0,
3479  0, 651, 195, 0, 0, 0, 0, 0, 0, 0,
3480  0, 0, 0, 166, 167, 168, 169, 170, 171, 172,
3481  173, 174, 0, 0, 175, 176, 0, 0, 177, 178,
3482  179, 180, 0, 0, 0, 0, 0, 0, 0, 0,
3483  0, 0, 0, 181, 182, 0, 0, 0, 0, 0,
3484  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3485  0, 0, 0, 0, 0, 183, 184, 185, 186, 187,
3486  188, 189, 190, 191, 192, 0, 193, 194, 653, 572,
3487  0, 0, 654, 195, 0, 0, 0, 0, 0, 0,
3488  0, 0, 0, 0, 166, 167, 168, 169, 170, 171,
3489  172, 173, 174, 0, 0, 175, 176, 0, 0, 177,
3490  178, 179, 180, 0, 0, 0, 0, 0, 0, 0,
3491  0, 0, 0, 0, 181, 182, 0, 0, 0, 0,
3492  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3493  0, 0, 0, 0, 0, 0, 183, 184, 185, 186,
3494  187, 188, 189, 190, 191, 192, 0, 193, 194, 741,
3495  564, 0, 0, 742, 195, 0, 0, 0, 0, 0,
3496  0, 0, 0, 0, 0, 166, 167, 168, 169, 170,
3497  171, 172, 173, 174, 0, 0, 175, 176, 0, 0,
3498  177, 178, 179, 180, 0, 0, 0, 0, 0, 0,
3499  0, 0, 0, 0, 0, 181, 182, 0, 0, 0,
3500  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3501  0, 0, 0, 0, 0, 0, 0, 183, 184, 185,
3502  186, 187, 188, 189, 190, 191, 192, 0, 193, 194,
3503  744, 572, 0, 0, 745, 195, 0, 0, 0, 0,
3504  0, 0, 0, 0, 0, 0, 166, 167, 168, 169,
3505  170, 171, 172, 173, 174, 0, 0, 175, 176, 0,
3506  0, 177, 178, 179, 180, 0, 0, 0, 0, 0,
3507  0, 0, 0, 0, 0, 0, 181, 182, 0, 0,
3508  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3509  0, 0, 0, 0, 0, 0, 0, 0, 183, 184,
3510  185, 186, 187, 188, 189, 190, 191, 192, 0, 193,
3511  194, 750, 564, 0, 0, 751, 195, 0, 0, 0,
3512  0, 0, 0, 0, 0, 0, 0, 166, 167, 168,
3513  169, 170, 171, 172, 173, 174, 0, 0, 175, 176,
3514  0, 0, 177, 178, 179, 180, 0, 0, 0, 0,
3515  0, 0, 0, 0, 0, 0, 0, 181, 182, 0,
3516  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3517  0, 0, 0, 0, 0, 0, 0, 0, 0, 183,
3518  184, 185, 186, 187, 188, 189, 190, 191, 192, 0,
3519  193, 194, 820, 564, 0, 0, 821, 195, 0, 0,
3520  0, 0, 0, 0, 0, 0, 0, 0, 166, 167,
3521  168, 169, 170, 171, 172, 173, 174, 0, 0, 175,
3522  176, 0, 0, 177, 178, 179, 180, 0, 0, 0,
3523  0, 0, 0, 0, 0, 0, 0, 0, 181, 182,
3524  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3525  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3526  183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
3527  0, 193, 194, 823, 572, 0, 0, 824, 195, 0,
3528  0, 0, 0, 0, 0, 0, 0, 0, 0, 166,
3529  167, 168, 169, 170, 171, 172, 173, 174, 0, 0,
3530  175, 176, 0, 0, 177, 178, 179, 180, 0, 0,
3531  0, 0, 0, 0, 0, 0, 0, 0, 0, 181,
3532  182, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3533  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3534  0, 183, 184, 185, 186, 187, 188, 189, 190, 191,
3535  192, 0, 193, 194, 1048, 564, 0, 0, 1049, 195,
3536  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3537  166, 167, 168, 169, 170, 171, 172, 173, 174, 0,
3538  0, 175, 176, 0, 0, 177, 178, 179, 180, 0,
3539  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3540  181, 182, 0, 0, 0, 0, 0, 0, 0, 0,
3541  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3542  0, 0, 183, 184, 185, 186, 187, 188, 189, 190,
3543  191, 192, 0, 193, 194, 1051, 572, 0, 0, 1052,
3544  195, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3545  0, 166, 167, 168, 169, 170, 171, 172, 173, 174,
3546  0, 0, 175, 176, 0, 0, 177, 178, 179, 180,
3547  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3548  0, 181, 182, 0, 0, 0, 0, 0, 0, 0,
3549  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3550  0, 0, 0, 183, 184, 185, 186, 187, 188, 189,
3551  190, 191, 192, 0, 193, 194, 1065, 564, 0, 0,
3552  1066, 195, 0, 0, 0, 0, 0, 0, 0, 0,
3553  0, 0, 166, 167, 168, 169, 170, 171, 172, 173,
3554  174, 0, 0, 175, 176, 0, 0, 177, 178, 179,
3555  180, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3556  0, 0, 181, 182, 331, 332, 333, 334, 335, 336,
3557  337, 338, 339, 340, 341, 342, 343, 0, 0, 344,
3558  345, 0, 0, 0, 183, 184, 185, 186, 187, 188,
3559  189, 190, 191, 192, 0, 193, 194, 0, 0, 0,
3560  0, 0, 195, 0, 0, 0, 0, 0, 0, 0,
3561  0, 0, 346, 0, 347, 348, 349, 350, 351, 352,
3562  353, 354, 355, 356, 0, 0, 0, 0, 0, 0,
3563  0, 0, 0, 0, 0, 0, 0, 0, 0, 236
3564 };
3565 
3566 static const yytype_int16 yycheck[] =
3567 {
3568  2, 99, 27, 69, 29, 81, 87, 66, 57, 76,
3569  8, 16, 17, 22, 8, 20, 28, 98, 367, 225,
3570  480, 16, 17, 55, 51, 20, 330, 93, 89, 90,
3571  28, 267, 93, 429, 28, 271, 410, 411, 90, 361,
3572  8, 93, 585, 4, 476, 625, 421, 480, 97, 81,
3573  93, 53, 54, 584, 429, 55, 797, 65, 53, 2,
3574  28, 4, 94, 95, 96, 384, 51, 76, 877, 449,
3575  875, 467, 652, 16, 17, 936, 235, 20, 360, 668,
3576  681, 363, 788, 2, 25, 4, 255, 729, 0, 57,
3577  25, 733, 88, 26, 526, 69, 78, 29, 16, 17,
3578  25, 260, 20, 425, 263, 16, 17, 330, 51, 20,
3579  26, 897, 55, 788, 13, 88, 137, 25, 58, 88,
3580  56, 25, 797, 66, 145, 407, 137, 932, 1011, 97,
3581  70, 145, 26, 100, 145, 53, 54, 25, 81, 220,
3582  122, 90, 424, 63, 426, 117, 89, 90, 144, 28,
3583  93, 94, 95, 96, 87, 88, 478, 124, 327, 99,
3584  100, 13, 143, 743, 1025, 137, 952, 27, 117, 250,
3585  452, 144, 25, 753, 235, 144, 237, 986, 1061, 25,
3586  207, 248, 114, 988, 124, 88, 139, 410, 411, 25,
3587  602, 257, 145, 113, 37, 38, 137, 479, 279, 940,
3588  276, 134, 137, 136, 139, 291, 139, 293, 668, 295,
3589  134, 144, 137, 299, 257, 242, 117, 219, 134, 1024,
3590  143, 13, 897, 225, 229, 117, 231, 232, 255, 137,
3591  232, 13, 438, 137, 229, 668, 231, 633, 137, 945,
3592  134, 144, 822, 142, 276, 139, 145, 13, 273, 137,
3593  311, 312, 313, 314, 143, 316, 317, 632, 633, 311,
3594  312, 313, 314, 643, 207, 940, 325, 275, 590, 13,
3595  255, 330, 431, 13, 706, 864, 435, 866, 600, 921,
3596  599, 440, 142, 257, 137, 145, 229, 888, 231, 232,
3597  142, 137, 235, 145, 237, 376, 328, 456, 1004, 242,
3598  327, 137, 145, 139, 370, 143, 137, 368, 369, 591,
3599  253, 229, 255, 231, 145, 63, 368, 369, 229, 601,
3600  231, 264, 383, 15, 137, 17, 857, 370, 328, 1004,
3601  325, 13, 418, 276, 253, 330, 1011, 749, 140, 717,
3602  714, 715, 327, 145, 103, 264, 724, 721, 722, 310,
3603  142, 410, 411, 145, 88, 788, 361, 958, 959, 361,
3604  142, 13, 1068, 145, 797, 113, 525, 310, 311, 312,
3605  313, 314, 315, 316, 317, 90, 142, 137, 921, 145,
3606  13, 13, 325, 139, 327, 328, 1061, 330, 56, 711,
3607  739, 310, 87, 88, 63, 363, 315, 117, 142, 139,
3608  476, 145, 142, 91, 864, 145, 866, 493, 52, 25,
3609  144, 647, 56, 137, 500, 88, 622, 139, 361, 587,
3610  425, 364, 70, 425, 728, 368, 369, 88, 710, 137,
3611  712, 864, 88, 866, 446, 437, 438, 37, 38, 407,
3612  383, 110, 1043, 112, 476, 90, 858, 449, 446, 144,
3613  526, 662, 446, 865, 14, 15, 537, 139, 426, 833,
3614  142, 90, 25, 145, 897, 87, 88, 410, 411, 25,
3615  1050, 144, 117, 478, 143, 871, 478, 90, 446, 127,
3616  128, 129, 425, 144, 452, 708, 898, 646, 144, 26,
3617  142, 714, 715, 145, 526, 134, 871, 139, 721, 722,
3618  567, 117, 88, 421, 117, 90, 449, 940, 575, 142,
3619  142, 479, 145, 145, 136, 63, 459, 583, 584, 67,
3620  25, 137, 144, 139, 140, 142, 70, 552, 145, 145,
3621  449, 88, 117, 476, 52, 478, 54, 55, 56, 57,
3622  139, 117, 603, 610, 140, 570, 464, 75, 76, 141,
3623  87, 88, 137, 580, 117, 582, 63, 135, 144, 568,
3624  909, 117, 110, 90, 112, 771, 915, 576, 779, 780,
3625  738, 1004, 648, 985, 137, 636, 578, 140, 1011, 90,
3626  56, 137, 145, 526, 140, 590, 754, 144, 590, 145,
3627  117, 586, 120, 121, 90, 600, 755, 134, 600, 136,
3628  625, 610, 139, 110, 616, 112, 117, 144, 610, 113,
3629  833, 90, 117, 772, 70, 137, 648, 90, 616, 137,
3630  622, 117, 616, 591, 783, 410, 411, 652, 1061, 26,
3631  706, 113, 137, 601, 70, 140, 143, 580, 117, 582,
3632  145, 643, 427, 428, 117, 113, 791, 590, 616, 708,
3633  795, 718, 113, 87, 88, 714, 715, 600, 725, 602,
3634  603, 759, 721, 722, 875, 97, 877, 137, 453, 125,
3635  126, 127, 128, 129, 706, 17, 90, 679, 142, 681,
3636  848, 747, 850, 87, 88, 746, 56, 748, 25, 90,
3637  87, 88, 860, 636, 746, 1017, 748, 87, 88, 121,
3638  643, 54, 136, 117, 137, 648, 711, 90, 757, 711,
3639  144, 90, 65, 66, 632, 874, 117, 140, 743, 137,
3640  135, 932, 933, 725, 643, 134, 728, 729, 753, 731,
3641  137, 733, 136, 728, 117, 139, 1018, 134, 117, 136,
3642  144, 137, 139, 90, 712, 143, 136, 144, 143, 137,
3643  918, 919, 897, 137, 144, 923, 137, 44, 137, 927,
3644  785, 117, 63, 706, 707, 708, 139, 926, 711, 771,
3645  117, 714, 715, 10, 833, 986, 8, 988, 721, 722,
3646  87, 88, 13, 16, 17, 135, 847, 20, 707, 757,
3647  137, 857, 63, 859, 791, 847, 52, 822, 54, 55,
3648  56, 57, 117, 746, 90, 748, 749, 137, 810, 110,
3649  812, 112, 113, 1024, 115, 48, 49, 844, 87, 88,
3650  53, 54, 87, 88, 851, 852, 994, 137, 855, 136,
3651  52, 117, 137, 66, 67, 137, 683, 144, 685, 110,
3652  842, 112, 113, 845, 52, 87, 88, 137, 10, 87,
3653  88, 137, 52, 1021, 1022, 59, 60, 61, 62, 1004,
3654  135, 10, 928, 1008, 137, 119, 1011, 136, 1013, 141,
3655  90, 136, 897, 15, 901, 144, 908, 87, 88, 144,
3656  139, 137, 87, 88, 137, 912, 888, 968, 135, 137,
3657  833, 135, 87, 88, 136, 87, 88, 117, 136, 9,
3658  897, 844, 144, 137, 847, 70, 144, 91, 851, 852,
3659  937, 938, 855, 137, 140, 858, 1061, 137, 1063, 921,
3660  85, 86, 865, 1068, 956, 1070, 136, 952, 142, 714,
3661  715, 136, 122, 56, 144, 1080, 721, 722, 137, 144,
3662  2, 136, 4, 137, 136, 972, 137, 974, 137, 144,
3663  137, 137, 144, 980, 63, 898, 958, 959, 901, 124,
3664  125, 126, 127, 128, 129, 908, 991, 117, 137, 912,
3665  897, 1003, 205, 1000, 63, 208, 209, 210, 137, 212,
3666  137, 766, 767, 90, 769, 770, 137, 87, 88, 51,
3667  137, 135, 137, 55, 937, 938, 229, 122, 231, 232,
3668  56, 110, 137, 112, 113, 87, 88, 1004, 111, 137,
3669  117, 1008, 1017, 956, 1011, 1017, 1013, 1019, 1020, 81,
3670  63, 110, 137, 112, 113, 1050, 137, 139, 459, 972,
3671  137, 974, 94, 95, 96, 139, 136, 980, 885, 886,
3672  63, 1043, 985, 890, 144, 892, 137, 894, 833, 90,
3673  1018, 96, 961, 962, 136, 94, 797, 1000, 85, 800,
3674  1003, 725, 144, 1020, 1061, 779, 1063, 110, 897, 112,
3675  113, 1068, 700, 1070, 1017, 812, 117, 1004, 1025, 760,
3676  518, 1008, 1019, 1080, 1011, 870, 1013, 110, 102, 112,
3677  113, 211, 325, 299, 59, 97, 137, 330, 331, 332,
3678  333, 334, 335, 929, 791, 338, 339, 340, 341, 342,
3679  343, 344, 345, 346, 1004, 1008, 349, 350, 351, 352,
3680  353, 354, 355, 356, 357, 358, 788, -1, 361, 1038,
3681  1039, -1, -1, -1, 1061, 1044, 1063, 1046, 1047, -1,
3682  -1, 1068, -1, 1070, -1, 207, -1, -1, -1, 996,
3683  997, 998, 999, 1080, -1, -1, 897, -1, -1, -1,
3684  52, -1, 54, 55, 56, 57, 1075, 1076, 1077, 1078,
3685  40, 41, 42, 43, 44, 1084, -1, 410, 411, -1,
3686  242, -1, 70, 2, -1, 4, 419, 420, 421, 54,
3687  -1, 253, 425, 255, 427, 428, 429, 85, 86, 940,
3688  92, 942, 264, -1, -1, -1, 947, 54, 55, -1,
3689  57, -1, 1059, -1, 276, 448, -1, -1, 65, 66,
3690  453, 52, -1, 54, 55, 56, 57, -1, -1, -1,
3691  -1, 464, 51, -1, 467, -1, 55, 125, 126, 127,
3692  128, 129, -1, -1, -1, 478, -1, 52, 310, 54,
3693  55, 56, 57, 315, -1, -1, -1, -1, 70, -1,
3694  -1, 92, 81, -1, -1, 327, 328, 98, 330, -1,
3695  1011, 504, 1013, 85, 86, 94, 95, 96, 97, 52,
3696  -1, 54, 55, 56, 57, 58, 519, -1, 52, 1030,
3697  54, 55, 56, 57, 58, -1, -1, 70, -1, -1,
3698  -1, -1, 364, -1, -1, -1, 70, -1, -1, -1,
3699  122, 123, 124, 125, 126, 127, 128, 129, -1, 92,
3700  1061, -1, 1063, -1, -1, -1, 99, 100, 92, 1070,
3701  -1, -1, -1, -1, 98, 99, 100, -1, -1, 1080,
3702  205, -1, -1, 208, 209, 210, -1, -1, 410, 411,
3703  -1, 124, -1, 586, 2, -1, 4, 590, -1, -1,
3704  124, -1, -1, 127, -1, -1, 52, 600, 54, 55,
3705  56, 57, -1, -1, -1, -1, -1, -1, -1, -1,
3706  -1, 145, -1, -1, 617, -1, 619, 449, 207, -1,
3707  -1, -1, -1, -1, -1, -1, -1, 459, -1, 632,
3708  633, -1, -1, 51, -1, -1, 92, 55, -1, -1,
3709  -1, -1, 98, -1, 476, -1, -1, -1, -1, -1,
3710  -1, -1, -1, 242, -1, -1, -1, -1, -1, -1,
3711  -1, -1, -1, 81, 253, -1, 255, -1, -1, -1,
3712  -1, -1, -1, -1, 677, 264, 94, 95, 96, 97,
3713  -1, 2, -1, 4, -1, -1, -1, 276, -1, -1,
3714  325, -1, -1, -1, 526, 330, -1, -1, -1, -1,
3715  703, -1, -1, -1, -1, 708, 709, -1, 711, -1,
3716  -1, 714, 715, -1, -1, -1, -1, -1, 721, 722,
3717  -1, 310, -1, -1, -1, 728, 315, -1, -1, -1,
3718  51, -1, -1, -1, -1, -1, -1, -1, 327, 328,
3719  -1, -1, -1, -1, -1, -1, -1, -1, 580, -1,
3720  582, 52, -1, 54, 55, 56, 57, 58, -1, -1,
3721  -1, -1, -1, 766, 767, -1, 769, 770, -1, 70,
3722  602, -1, -1, 94, -1, 364, -1, -1, -1, -1,
3723  -1, -1, -1, -1, 787, 420, 421, -1, -1, 207,
3724  -1, 92, -1, -1, 429, -1, -1, 98, 99, 100,
3725  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3726  -1, 643, 815, -1, -1, -1, 648, -1, -1, -1,
3727  -1, -1, 825, 124, 242, -1, 127, -1, -1, 464,
3728  833, -1, 467, -1, -1, 253, -1, 255, 139, -1,
3729  -1, -1, -1, -1, -1, -1, 264, -1, -1, -1,
3730  -1, 854, -1, -1, -1, -1, -1, 689, 276, -1,
3731  449, -1, -1, -1, -1, -1, -1, 870, 871, -1,
3732  459, -1, -1, -1, 706, 707, 708, -1, -1, -1,
3733  -1, -1, 714, 715, 519, -1, 207, 476, -1, 721,
3734  722, -1, 310, -1, -1, -1, -1, 315, -1, -1,
3735  -1, 52, -1, 54, 55, 56, 57, 58, -1, 327,
3736  328, -1, -1, -1, -1, -1, -1, 749, -1, 70,
3737  -1, 242, -1, -1, -1, 2, -1, 4, -1, -1,
3738  -1, -1, 253, -1, 255, -1, -1, 526, -1, -1,
3739  -1, 92, -1, 264, -1, -1, 364, 98, 99, 100,
3740  -1, 586, -1, -1, -1, -1, -1, -1, -1, -1,
3741  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3742  -1, -1, -1, 124, 51, -1, 127, -1, -1, -1,
3743  -1, -1, 617, -1, 619, -1, -1, -1, -1, 310,
3744  -1, 580, -1, 582, 315, -1, -1, 632, 633, -1,
3745  -1, 833, -1, -1, -1, -1, 327, -1, -1, 330,
3746  -1, -1, 844, 602, 1017, -1, -1, -1, -1, 851,
3747  852, -1, -1, 855, -1, -1, 858, -1, -1, -1,
3748  -1, 449, -1, 865, -1, -1, -1, -1, -1, -1,
3749  -1, 459, 677, 364, -1, -1, -1, -1, -1, -1,
3750  -1, -1, -1, -1, 643, -1, -1, -1, 476, 648,
3751  -1, -1, -1, -1, -1, -1, 898, -1, 703, 901,
3752  -1, -1, -1, -1, -1, -1, 908, -1, -1, -1,
3753  912, -1, -1, -1, -1, -1, -1, -1, -1, 410,
3754  411, -1, -1, 728, -1, -1, -1, -1, -1, -1,
3755  -1, -1, -1, -1, -1, 937, 938, -1, 526, -1,
3756  -1, -1, -1, -1, -1, -1, -1, 706, 707, -1,
3757  -1, -1, -1, -1, 956, -1, -1, -1, 449, -1,
3758  207, -1, -1, -1, -1, -1, -1, -1, 459, -1,
3759  972, -1, 974, -1, -1, -1, -1, -1, 980, -1,
3760  -1, -1, 787, 985, -1, -1, -1, -1, -1, -1,
3761  749, -1, 580, 44, 582, 242, -1, -1, 1000, -1,
3762  -1, 1003, -1, -1, -1, -1, 253, -1, 255, -1,
3763  815, -1, -1, -1, 602, -1, -1, 264, -1, 70,
3764  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3765  81, 82, -1, -1, 85, 86, -1, -1, -1, -1,
3766  -1, -1, -1, -1, -1, -1, -1, -1, -1, 854,
3767  -1, -1, -1, -1, -1, 643, -1, -1, -1, -1,
3768  648, -1, -1, 310, -1, -1, 871, 118, 315, 120,
3769  121, 122, 123, 124, 125, 126, 127, 128, 129, -1,
3770  327, -1, -1, 330, -1, 844, 137, -1, -1, 580,
3771  -1, 582, 851, 852, -1, -1, 855, -1, -1, 858,
3772  -1, -1, -1, -1, -1, -1, 865, -1, -1, -1,
3773  -1, 602, -1, -1, -1, -1, -1, 364, 706, 707,
3774  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3775  -1, -1, -1, -1, -1, -1, -1, -1, -1, 898,
3776  -1, -1, 901, -1, -1, -1, -1, -1, -1, 908,
3777  -1, -1, 643, 912, -1, -1, -1, -1, -1, -1,
3778  -1, 749, -1, 410, 411, -1, -1, 0, -1, -1,
3779  -1, -1, -1, -1, -1, 8, 9, 10, 937, 938,
3780  13, 14, 15, -1, 17, -1, -1, -1, -1, -1,
3781  -1, -1, -1, 26, 27, -1, -1, 956, -1, -1,
3782  -1, -1, 449, -1, 37, 38, -1, 40, 41, 42,
3783  43, 44, 459, 972, -1, 974, 707, 708, -1, -1,
3784  -1, 980, -1, 714, 715, -1, 985, -1, -1, -1,
3785  721, 722, -1, -1, -1, -1, -1, -1, -1, -1,
3786  -1, 1000, 48, 49, 1003, -1, -1, 53, 54, 55,
3787  -1, -1, -1, -1, 87, 88, 844, -1, 749, -1,
3788  -1, 67, -1, 851, 852, -1, -1, 855, -1, -1,
3789  858, -1, -1, -1, -1, 81, -1, 865, 111, -1,
3790  -1, -1, -1, -1, -1, -1, -1, -1, 94, 95,
3791  96, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3792  -1, 134, 135, -1, -1, -1, 139, 140, -1, 142,
3793  898, 144, 145, 901, -1, -1, -1, -1, -1, -1,
3794  908, -1, -1, -1, 912, -1, -1, -1, -1, -1,
3795  -1, -1, -1, 580, -1, 582, -1, -1, -1, -1,
3796  -1, -1, 833, -1, -1, -1, -1, -1, -1, 937,
3797  938, -1, -1, 844, -1, 602, -1, -1, -1, -1,
3798  851, 852, -1, -1, 855, -1, -1, 858, 956, -1,
3799  -1, -1, -1, -1, 865, -1, -1, -1, -1, -1,
3800  -1, -1, -1, -1, 972, -1, 974, -1, -1, -1,
3801  -1, -1, 980, -1, -1, -1, 643, 985, -1, 205,
3802  -1, -1, 208, 209, 210, -1, 212, 898, -1, -1,
3803  901, -1, 1000, -1, -1, 1003, -1, 908, -1, -1,
3804  -1, 912, -1, -1, -1, -1, -1, -1, -1, -1,
3805  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3806  -1, -1, -1, -1, -1, -1, 937, 938, -1, -1,
3807  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3808  707, 708, -1, -1, -1, -1, -1, 714, 715, -1,
3809  276, -1, -1, -1, 721, 722, -1, -1, -1, -1,
3810  -1, 972, -1, 974, -1, -1, -1, -1, -1, 980,
3811  -1, -1, -1, -1, 985, -1, -1, -1, -1, -1,
3812  -1, -1, 749, -1, -1, -1, -1, -1, -1, 1000,
3813  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3814  -1, -1, 328, -1, -1, 331, 332, 333, 334, 335,
3815  -1, -1, 338, 339, 340, 341, 342, 343, 344, 345,
3816  346, -1, -1, 349, 350, 351, 352, 353, 354, 355,
3817  356, 357, 358, -1, -1, -1, -1, -1, -1, -1,
3818  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
3819  -1, -1, -1, -1, -1, -1, 68, 69, 70, 71,
3820  72, 73, 74, 75, 76, -1, 833, 79, 80, -1,
3821  -1, 83, 84, 85, 86, -1, -1, 844, -1, -1,
3822  -1, -1, -1, -1, 851, 852, 98, 99, 855, -1,
3823  -1, 858, -1, 419, 420, 421, -1, -1, 865, -1,
3824  -1, 427, 428, 429, -1, -1, -1, -1, 120, 121,
3825  122, 123, 124, 125, 126, 127, 128, 129, -1, 131,
3826  132, -1, 448, -1, -1, -1, 138, 453, -1, -1,
3827  -1, 898, -1, -1, 901, -1, -1, -1, 464, -1,
3828  -1, 467, -1, -1, -1, 912, -1, -1, -1, -1,
3829  476, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3830  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3831  937, 938, -1, -1, -1, -1, -1, -1, 504, -1,
3832  -1, -1, -1, -1, -1, -1, 70, 71, 72, 73,
3833  74, 75, 76, 519, -1, 79, 80, -1, -1, -1,
3834  526, 85, 86, -1, -1, 972, -1, 974, -1, -1,
3835  -1, -1, -1, 980, -1, -1, -1, -1, 985, -1,
3836  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3837  -1, -1, -1, 1000, -1, -1, 120, 121, 122, 123,
3838  124, 125, 126, 127, 128, 129, -1, -1, -1, -1,
3839  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3840  586, -1, -1, -1, 0, 1, -1, 3, 4, 5,
3841  6, 7, -1, -1, -1, 11, 12, -1, -1, -1,
3842  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
3843  -1, 617, -1, 619, 30, 31, 32, 33, 34, 35,
3844  36, -1, -1, 39, -1, -1, 632, 633, -1, 45,
3845  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
3846  56, 57, 648, 59, 60, 61, 62, -1, 64, 65,
3847  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
3848  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3849  -1, 677, -1, 89, -1, -1, 92, 93, -1, 95,
3850  96, -1, 98, -1, -1, 101, 102, 103, 104, 105,
3851  106, 107, 108, 109, -1, -1, -1, 703, -1, -1,
3852  706, -1, -1, 709, -1, -1, -1, -1, -1, -1,
3853  -1, -1, -1, -1, 130, 131, 132, -1, -1, -1,
3854  -1, -1, 728, -1, -1, -1, 142, -1, -1, 145,
3855  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3856  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3857  -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,
3858  766, 767, -1, 769, 770, -1, -1, 8, 9, 10,
3859  -1, -1, 13, 14, 15, -1, 17, -1, -1, -1,
3860  -1, 787, -1, -1, -1, 26, 27, 28, 29, -1,
3861  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3862  41, 42, 43, 44, -1, -1, -1, -1, -1, 815,
3863  -1, -1, -1, -1, -1, -1, -1, -1, -1, 825,
3864  -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
3865  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3866  81, 82, -1, -1, 85, 86, 87, 88, 854, 90,
3867  91, -1, -1, -1, -1, -1, 97, -1, -1, -1,
3868  -1, -1, -1, -1, 870, 871, -1, -1, -1, -1,
3869  111, -1, -1, 114, -1, -1, 117, 118, 119, 120,
3870  121, 122, 123, 124, 125, 126, 127, 128, 129, -1,
3871  -1, -1, -1, 134, 135, 136, 137, 0, -1, 140,
3872  141, 142, 908, 144, 145, 8, 9, 10, -1, -1,
3873  13, 14, 15, -1, 17, -1, -1, -1, -1, -1,
3874  -1, -1, 25, -1, 27, 28, 29, -1, -1, -1,
3875  -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
3876  43, 44, -1, -1, -1, -1, -1, -1, -1, -1,
3877  956, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3878  -1, -1, -1, -1, -1, -1, -1, 70, 71, 72,
3879  73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
3880  -1, -1, 85, 86, 87, 88, -1, 90, 91, -1,
3881  -1, -1, -1, -1, 97, -1, -1, 1003, -1, -1,
3882  -1, -1, -1, -1, -1, -1, -1, -1, 111, -1,
3883  -1, 114, -1, -1, 117, 118, 119, 120, 121, 122,
3884  123, 124, 125, 126, 127, 128, 129, -1, -1, -1,
3885  -1, -1, 135, 136, 137, 0, -1, 140, 141, 142,
3886  -1, 144, 145, 8, 9, 10, -1, -1, 13, 14,
3887  15, -1, 17, -1, -1, -1, -1, 44, -1, -1,
3888  25, -1, 27, 28, 29, -1, -1, -1, -1, -1,
3889  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3890  -1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
3891  77, 78, 79, 80, 81, 82, -1, -1, 85, 86,
3892  -1, -1, -1, -1, -1, 70, 71, 72, 73, 74,
3893  75, 76, 77, 78, 79, 80, 81, 82, -1, -1,
3894  85, 86, 87, 88, -1, 90, 91, -1, -1, -1,
3895  -1, 118, 97, 120, 121, 122, 123, 124, 125, 126,
3896  127, 128, 129, -1, -1, -1, 111, -1, -1, 114,
3897  -1, -1, 117, 118, 119, 120, 121, 122, 123, 124,
3898  125, 126, 127, 128, 129, -1, -1, -1, -1, -1,
3899  135, 136, 137, 0, -1, 140, 141, 142, -1, 144,
3900  145, 8, 9, 10, -1, -1, 13, 14, 15, -1,
3901  17, -1, -1, -1, -1, -1, -1, -1, -1, 26,
3902  27, 28, 29, -1, -1, -1, -1, -1, -1, -1,
3903  37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
3904  -1, 70, 71, 72, 73, 74, 75, 76, 77, 78,
3905  79, 80, 81, 82, -1, -1, 85, 86, -1, -1,
3906  -1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
3907  77, 78, 79, 80, 81, 82, -1, -1, 85, 86,
3908  87, 88, -1, -1, 91, -1, -1, -1, -1, 118,
3909  97, 120, 121, 122, 123, 124, 125, 126, 127, 128,
3910  129, -1, -1, -1, 111, -1, -1, 114, -1, -1,
3911  -1, 118, 119, 120, 121, 122, 123, 124, 125, 126,
3912  127, 128, 129, -1, -1, -1, -1, 134, 135, 136,
3913  137, 0, -1, 140, 141, 142, -1, 144, 145, 8,
3914  9, 10, -1, -1, 13, 14, 15, -1, 17, -1,
3915  -1, -1, -1, -1, -1, -1, -1, 26, 27, 28,
3916  29, -1, -1, -1, -1, -1, -1, -1, 37, 38,
3917  -1, 40, 41, 42, 43, 44, -1, -1, -1, 70,
3918  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3919  81, 82, -1, -1, 85, 86, -1, -1, -1, -1,
3920  -1, 70, 71, 72, 73, 74, 75, 76, 77, 78,
3921  79, 80, 81, 82, -1, -1, 85, 86, 87, 88,
3922  -1, -1, 91, -1, -1, -1, -1, -1, 97, 120,
3923  121, 122, 123, 124, 125, 126, 127, 128, 129, -1,
3924  -1, -1, 111, -1, -1, 114, -1, -1, -1, 118,
3925  119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
3926  129, -1, -1, -1, -1, 134, 135, 136, 137, 0,
3927  -1, 140, 141, 142, -1, 144, 145, 8, 9, 10,
3928  -1, -1, 13, 14, 15, -1, 17, -1, -1, -1,
3929  -1, -1, -1, -1, -1, -1, 27, 28, 29, -1,
3930  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3931  41, 42, 43, 44, -1, -1, -1, 70, 71, 72,
3932  73, 74, 75, 76, 77, -1, 79, 80, -1, -1,
3933  -1, -1, 85, 86, -1, -1, -1, -1, -1, 70,
3934  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3935  81, 82, -1, -1, 85, 86, 87, 88, -1, 90,
3936  91, -1, -1, -1, -1, -1, 97, 120, 121, 122,
3937  123, 124, 125, 126, 127, 128, 129, -1, -1, -1,
3938  111, -1, -1, 114, -1, -1, 117, 118, 119, 120,
3939  121, 122, 123, 124, 125, 126, 127, 128, 129, -1,
3940  -1, -1, -1, -1, 135, 136, 137, 0, -1, 140,
3941  141, 142, -1, 144, 145, 8, 9, 10, -1, -1,
3942  13, 14, 15, -1, 17, -1, -1, -1, -1, -1,
3943  -1, -1, -1, 26, 27, 28, -1, -1, -1, -1,
3944  -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
3945  43, 44, -1, -1, -1, 70, 71, 72, 73, 74,
3946  75, 76, -1, -1, 79, 80, -1, -1, -1, -1,
3947  85, 86, -1, -1, -1, -1, -1, 70, 71, 72,
3948  73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
3949  -1, -1, 85, 86, 87, 88, -1, -1, 91, -1,
3950  -1, -1, -1, -1, 97, 120, 121, 122, 123, 124,
3951  125, 126, 127, 128, 129, -1, -1, -1, 111, -1,
3952  -1, -1, -1, -1, -1, 118, -1, 120, 121, 122,
3953  123, 124, 125, 126, 127, 128, 129, -1, -1, -1,
3954  -1, 134, 135, 136, 137, 0, 139, 140, 141, 142,
3955  -1, 144, 145, 8, 9, 10, -1, -1, 13, 14,
3956  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
3957  -1, -1, 27, 28, 29, -1, -1, -1, -1, -1,
3958  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3959  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3960  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3961  -1, -1, -1, -1, -1, 70, 71, 72, 73, 74,
3962  75, 76, 77, 78, 79, 80, 81, 82, -1, -1,
3963  85, 86, 87, 88, -1, -1, 91, -1, -1, -1,
3964  -1, -1, 97, -1, -1, -1, -1, -1, -1, -1,
3965  -1, -1, -1, -1, -1, -1, 111, -1, -1, 114,
3966  -1, -1, -1, 118, 119, 120, 121, 122, 123, 124,
3967  125, 126, 127, 128, 129, -1, -1, -1, -1, -1,
3968  135, 136, 137, 0, -1, 140, 141, 142, -1, 144,
3969  145, 8, 9, 10, -1, -1, 13, 14, 15, -1,
3970  17, -1, -1, -1, -1, -1, -1, -1, -1, 26,
3971  27, 28, -1, -1, -1, -1, -1, -1, -1, -1,
3972  37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
3973  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3974  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3975  -1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
3976  77, 78, 79, 80, 81, 82, -1, -1, 85, 86,
3977  87, 88, -1, -1, 91, -1, -1, -1, -1, -1,
3978  97, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3979  -1, -1, -1, -1, 111, -1, -1, -1, -1, -1,
3980  -1, 118, -1, 120, 121, 122, 123, 124, 125, 126,
3981  127, 128, 129, -1, -1, -1, -1, 134, 135, 136,
3982  137, 0, 139, 140, 141, 142, -1, 144, 145, 8,
3983  9, 10, -1, -1, 13, 14, 15, -1, 17, -1,
3984  -1, -1, -1, -1, -1, -1, -1, -1, 27, 28,
3985  -1, -1, -1, -1, -1, -1, -1, -1, 37, 38,
3986  -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
3987  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3988  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3989  -1, 70, 71, 72, 73, 74, 75, 76, 77, 78,
3990  79, 80, 81, 82, -1, -1, 85, 86, 87, 88,
3991  -1, -1, 91, -1, -1, -1, -1, -1, 97, -1,
3992  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3993  -1, -1, 111, -1, -1, -1, -1, -1, -1, 118,
3994  -1, 120, 121, 122, 123, 124, 125, 126, 127, 128,
3995  129, -1, -1, -1, -1, -1, 135, 136, 137, 0,
3996  139, 140, 141, 142, -1, 144, 145, 8, 9, 10,
3997  -1, -1, -1, 14, 15, -1, 17, -1, -1, -1,
3998  -1, -1, -1, -1, -1, 26, -1, -1, -1, -1,
3999  -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
4000  41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
4001  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4002  -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
4003  71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
4004  81, 82, -1, -1, 85, 86, 87, 88, -1, 90,
4005  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4006  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4007  111, -1, -1, -1, -1, -1, 117, 118, -1, 120,
4008  121, 122, 123, 124, 125, 126, 127, 128, 129, -1,
4009  -1, -1, -1, 134, 135, 136, 137, 0, -1, 140,
4010  -1, 142, -1, 144, 145, 8, 9, 10, -1, -1,
4011  -1, 14, 15, -1, 17, -1, -1, -1, -1, -1,
4012  -1, -1, -1, 26, -1, -1, -1, -1, -1, -1,
4013  -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
4014  43, 44, -1, -1, -1, -1, -1, -1, -1, -1,
4015  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4016  -1, -1, -1, -1, -1, -1, -1, 70, 71, 72,
4017  73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
4018  -1, -1, 85, 86, 87, 88, -1, 90, -1, -1,
4019  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4020  -1, -1, -1, -1, -1, -1, -1, -1, 111, -1,
4021  -1, -1, -1, -1, 117, 118, -1, 120, 121, 122,
4022  123, 124, 125, 126, 127, 128, 129, -1, -1, -1,
4023  -1, 134, 135, 136, 137, 0, -1, 140, -1, 142,
4024  -1, 144, 145, 8, 9, 10, -1, -1, -1, 14,
4025  15, -1, 17, -1, -1, -1, -1, -1, -1, -1,
4026  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4027  -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
4028  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4029  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4030  -1, -1, -1, -1, -1, 70, 71, 72, 73, 74,
4031  75, 76, 77, 78, 79, 80, 81, 82, -1, -1,
4032  85, 86, 87, 88, -1, 90, -1, -1, -1, -1,
4033  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4034  -1, -1, -1, -1, -1, -1, 111, -1, -1, -1,
4035  -1, -1, 117, 118, -1, 120, 121, 122, 123, 124,
4036  125, 126, 127, 128, 129, -1, -1, -1, -1, -1,
4037  135, 136, 137, 0, -1, 140, -1, 142, -1, 144,
4038  145, 8, 9, 10, -1, -1, -1, 14, 15, -1,
4039  17, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4040  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4041  37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
4042  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4043  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4044  -1, -1, -1, 70, 71, 72, 73, 74, 75, 76,
4045  77, 78, 79, 80, 81, 82, -1, -1, 85, 86,
4046  87, 88, -1, 90, -1, -1, -1, -1, -1, -1,
4047  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4048  -1, -1, -1, -1, 111, -1, -1, -1, -1, -1,
4049  117, 118, -1, 120, 121, 122, 123, 124, 125, 126,
4050  127, 128, 129, -1, -1, -1, -1, -1, 135, 136,
4051  137, -1, -1, 140, -1, 142, -1, 144, 145, 1,
4052  -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
4053  12, -1, -1, 15, 16, -1, 18, 19, 20, 21,
4054  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4055  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4056  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
4057  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4058  62, -1, 64, 65, 66, -1, 68, 69, -1, -1,
4059  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4060  -1, -1, -1, -1, -1, -1, -1, 89, -1, -1,
4061  92, 93, -1, 95, 96, -1, 98, -1, -1, 101,
4062  102, 103, 104, 105, 106, 107, 108, 109, -1, -1,
4063  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4064  -1, -1, -1, -1, -1, -1, -1, -1, 130, 131,
4065  132, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4066  142, -1, 1, 145, 3, 4, 5, 6, 7, -1,
4067  -1, 10, 11, 12, -1, 14, 15, 16, -1, 18,
4068  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4069  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4070  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
4071  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4072  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4073  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4074  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4075  89, -1, -1, 92, 93, -1, 95, 96, -1, 98,
4076  -1, -1, 101, 102, 103, 104, 105, 106, 107, 108,
4077  109, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4078  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4079  -1, 130, 131, 132, -1, -1, -1, -1, -1, -1,
4080  -1, -1, -1, 142, -1, 1, 145, 3, 4, 5,
4081  6, 7, -1, -1, 10, 11, 12, -1, -1, 15,
4082  16, 17, 18, 19, 20, 21, 22, 23, 24, -1,
4083  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4084  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
4085  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
4086  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
4087  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
4088  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4089  -1, -1, -1, 89, -1, -1, 92, 93, -1, 95,
4090  96, -1, 98, -1, -1, 101, 102, 103, 104, 105,
4091  106, 107, 108, 109, -1, -1, -1, -1, -1, -1,
4092  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4093  -1, -1, -1, -1, 130, 131, 132, -1, -1, -1,
4094  -1, -1, -1, -1, -1, -1, 142, -1, 1, 145,
4095  3, 4, 5, 6, 7, -1, -1, 10, 11, 12,
4096  -1, -1, 15, 16, -1, 18, 19, 20, 21, 22,
4097  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4098  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4099  -1, -1, 45, 46, 47, 48, 49, 50, 51, 52,
4100  53, 54, 55, 56, 57, -1, 59, 60, 61, 62,
4101  -1, 64, 65, 66, -1, 68, 69, -1, -1, -1,
4102  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4103  -1, -1, -1, -1, -1, -1, 89, -1, -1, 92,
4104  93, -1, 95, 96, -1, 98, -1, -1, 101, 102,
4105  103, 104, 105, 106, 107, 108, 109, -1, -1, -1,
4106  -1, -1, -1, -1, -1, 1, -1, 3, 4, 5,
4107  6, 7, -1, 9, 10, 11, 12, 130, 131, 132,
4108  16, -1, 18, 19, 20, 21, 22, 23, 24, 142,
4109  -1, -1, 145, -1, 30, 31, 32, 33, 34, 35,
4110  36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
4111  46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
4112  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
4113  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
4114  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4115  -1, -1, -1, 89, -1, -1, 92, 93, -1, 95,
4116  96, -1, 98, -1, -1, 101, 102, 103, 104, 105,
4117  106, 107, 108, 109, -1, -1, -1, -1, -1, -1,
4118  -1, -1, 1, -1, 3, 4, 5, 6, 7, -1,
4119  -1, -1, 11, 12, 130, 131, 132, 16, -1, 18,
4120  19, 20, 21, 22, 23, 24, 142, -1, -1, 145,
4121  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4122  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
4123  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4124  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4125  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4126  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4127  89, -1, -1, 92, 93, -1, 95, 96, -1, 98,
4128  -1, -1, 101, 102, 103, 104, 105, 106, 107, 108,
4129  109, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4130  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4131  -1, 130, 131, 132, 1, -1, 3, 4, 5, 6,
4132  7, 140, -1, 142, 11, 12, 145, -1, -1, 16,
4133  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
4134  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4135  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
4136  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4137  57, -1, 59, 60, 61, 62, -1, 64, 65, 66,
4138  -1, 68, 69, -1, -1, -1, -1, -1, -1, -1,
4139  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4140  -1, -1, 89, -1, -1, 92, 93, -1, 95, 96,
4141  -1, 98, -1, -1, 101, 102, 103, 104, 105, 106,
4142  107, 108, 109, -1, -1, -1, -1, -1, -1, -1,
4143  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4144  -1, -1, -1, 130, 131, 132, 1, -1, 3, 4,
4145  5, 6, 7, 140, -1, 142, 11, 12, 145, -1,
4146  -1, 16, -1, 18, 19, 20, 21, 22, 23, 24,
4147  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4148  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4149  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
4150  55, 56, 57, -1, 59, 60, 61, 62, -1, 64,
4151  65, 66, -1, 68, 69, -1, -1, -1, -1, -1,
4152  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4153  -1, -1, -1, -1, 89, -1, -1, 92, 93, -1,
4154  95, 96, -1, 98, -1, -1, 101, 102, 103, 104,
4155  105, 106, 107, 108, 109, -1, -1, -1, -1, -1,
4156  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4157  -1, -1, -1, -1, -1, 130, 131, 132, -1, -1,
4158  135, -1, -1, -1, -1, -1, -1, 142, -1, 1,
4159  145, 3, 4, 5, 6, 7, -1, -1, -1, 11,
4160  12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
4161  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4162  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4163  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
4164  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4165  62, -1, 64, 65, 66, -1, 68, 69, -1, -1,
4166  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4167  -1, -1, -1, -1, -1, -1, -1, 89, -1, -1,
4168  92, 93, -1, 95, 96, -1, 98, -1, -1, 101,
4169  102, 103, 104, 105, 106, 107, 108, 109, -1, -1,
4170  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4171  -1, -1, -1, -1, -1, -1, -1, -1, 130, 131,
4172  132, -1, -1, 135, -1, -1, -1, -1, -1, -1,
4173  142, -1, 1, 145, 3, 4, 5, 6, 7, -1,
4174  -1, 10, 11, 12, -1, -1, -1, 16, -1, 18,
4175  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4176  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4177  39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
4178  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4179  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4180  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4181  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4182  89, -1, -1, 92, 93, -1, 95, 96, -1, 98,
4183  -1, -1, 101, 102, 103, 104, 105, 106, 107, 108,
4184  109, -1, -1, -1, -1, -1, -1, -1, -1, 1,
4185  -1, 3, 4, 5, 6, 7, -1, -1, -1, 11,
4186  12, 130, 131, 132, 16, -1, 18, 19, 20, 21,
4187  22, 23, 24, 142, -1, -1, 145, -1, 30, 31,
4188  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4189  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
4190  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4191  62, -1, 64, 65, 66, -1, 68, 69, -1, -1,
4192  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4193  -1, -1, -1, -1, -1, -1, -1, 89, -1, -1,
4194  92, 93, -1, 95, 96, -1, 98, -1, -1, 101,
4195  102, 103, 104, 105, 106, 107, 108, 109, -1, 111,
4196  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
4197  5, -1, 7, -1, -1, -1, 11, 12, 130, 131,
4198  132, 16, -1, 18, 19, 20, 21, 22, 23, 24,
4199  142, -1, -1, 145, -1, 30, 31, 32, 33, 34,
4200  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4201  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
4202  55, 56, 57, 58, 59, 60, 61, 62, -1, 64,
4203  65, 66, -1, 68, 69, -1, -1, -1, -1, -1,
4204  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4205  -1, -1, -1, -1, 89, -1, -1, 92, 93, -1,
4206  95, 96, -1, 98, 99, 100, 101, 102, 103, 104,
4207  105, 106, 107, 108, 109, -1, -1, -1, -1, -1,
4208  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4209  -1, -1, -1, 11, 12, 130, 131, 132, 16, -1,
4210  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4211  145, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4212  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4213  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4214  -1, 59, 60, 61, 62, -1, 64, 65, 66, -1,
4215  68, 69, -1, -1, -1, -1, -1, -1, -1, -1,
4216  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4217  -1, 89, -1, -1, 92, 93, -1, 95, 96, -1,
4218  -1, -1, -1, 101, 102, 103, 104, 105, 106, 107,
4219  108, 109, -1, -1, -1, -1, -1, -1, -1, -1,
4220  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4221  11, 12, 130, 131, 132, 16, -1, 18, 19, 20,
4222  21, 22, 23, 24, 142, -1, -1, 145, -1, 30,
4223  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4224  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4225  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4226  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
4227  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4228  -1, -1, -1, -1, -1, -1, -1, -1, 89, -1,
4229  -1, 92, 93, -1, 95, 96, -1, -1, -1, -1,
4230  101, 102, 103, 104, 105, 106, 107, 108, 109, -1,
4231  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4232  4, 5, 6, 7, -1, -1, -1, 11, 12, 130,
4233  131, 132, 16, -1, 18, 19, 20, 21, 22, 23,
4234  24, -1, -1, -1, 145, -1, 30, 31, 32, 33,
4235  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4236  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
4237  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4238  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
4239  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4240  -1, -1, -1, -1, -1, 89, -1, -1, 92, 93,
4241  -1, 95, 96, -1, 98, -1, -1, 101, 102, 103,
4242  104, 105, 106, 107, 108, 109, -1, -1, -1, -1,
4243  -1, -1, -1, -1, -1, -1, 3, 4, 5, 6,
4244  7, -1, -1, -1, 11, 12, 130, 131, 132, 16,
4245  -1, 18, 19, 20, 21, 22, 23, 24, 142, -1,
4246  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4247  -1, -1, 39, -1, -1, -1, -1, -1, 45, 46,
4248  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4249  57, -1, 59, 60, 61, 62, -1, 64, 65, 66,
4250  -1, 68, 69, -1, -1, -1, -1, -1, -1, -1,
4251  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4252  -1, -1, 89, -1, -1, 92, 93, -1, 95, 96,
4253  -1, 98, -1, -1, 101, 102, 103, 104, 105, 106,
4254  107, 108, 109, -1, -1, -1, -1, -1, -1, -1,
4255  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4256  -1, -1, -1, 130, 131, 132, -1, -1, -1, -1,
4257  -1, -1, -1, -1, -1, 142, 3, 4, 5, 6,
4258  7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
4259  17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
4260  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4261  37, 38, 39, -1, -1, -1, -1, -1, 45, 46,
4262  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4263  57, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4264  -1, 68, 69, 70, 71, 72, 73, 74, 75, 76,
4265  -1, -1, 79, 80, -1, -1, 83, 84, 85, 86,
4266  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4267  -1, 98, 99, -1, -1, -1, -1, -1, -1, -1,
4268  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4269  -1, -1, -1, 120, 121, 122, 123, 124, 125, 126,
4270  127, 128, 129, -1, 131, 132, -1, -1, -1, -1,
4271  -1, 138, 139, 3, 4, 5, 6, 7, 8, 9,
4272  10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
4273  20, 21, 22, 23, 24, 25, 26, -1, -1, -1,
4274  30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
4275  -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
4276  50, 51, 52, 53, 54, 55, 56, 57, -1, -1,
4277  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
4278  70, 71, 72, 73, 74, 75, 76, -1, -1, 79,
4279  80, -1, -1, 83, 84, 85, 86, -1, -1, -1,
4280  -1, -1, -1, -1, -1, -1, -1, -1, 98, 99,
4281  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4282  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4283  120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
4284  -1, 131, 132, -1, -1, -1, -1, -1, 138, 3,
4285  4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
4286  14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
4287  24, 25, 26, -1, -1, -1, 30, 31, 32, 33,
4288  34, 35, 36, 37, 38, 39, -1, -1, -1, -1,
4289  -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
4290  54, -1, 56, -1, -1, -1, -1, -1, -1, -1,
4291  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
4292  74, 75, 76, -1, -1, 79, 80, -1, -1, 83,
4293  84, 85, 86, -1, -1, -1, -1, -1, -1, -1,
4294  -1, -1, -1, -1, 98, 99, -1, -1, 102, -1,
4295  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4296  -1, -1, -1, -1, -1, -1, 120, 121, 122, 123,
4297  124, 125, 126, 127, 128, 129, -1, 131, 132, -1,
4298  -1, -1, -1, -1, 138, 3, 4, 5, 6, 7,
4299  8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
4300  18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
4301  -1, -1, 30, 31, 32, 33, 34, 35, 36, 37,
4302  38, 39, -1, -1, -1, -1, -1, 45, 46, 47,
4303  48, 49, 50, 51, 52, 53, -1, -1, 56, -1,
4304  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4305  68, 69, 70, 71, 72, 73, 74, 75, 76, -1,
4306  -1, 79, 80, -1, -1, 83, 84, 85, 86, -1,
4307  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4308  98, 99, -1, -1, 102, -1, -1, -1, -1, -1,
4309  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4310  -1, -1, 120, 121, 122, 123, 124, 125, 126, 127,
4311  128, 129, -1, 131, 132, -1, -1, -1, -1, -1,
4312  138, 3, 4, 5, 6, 7, 8, 9, 10, 11,
4313  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
4314  22, 23, 24, 25, 26, -1, -1, -1, 30, 31,
4315  32, 33, 34, 35, 36, 37, 38, 39, -1, -1,
4316  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
4317  52, 53, -1, -1, 56, -1, -1, -1, -1, -1,
4318  -1, -1, -1, -1, -1, -1, 68, 69, 70, 71,
4319  72, 73, 74, 75, 76, -1, -1, 79, 80, -1,
4320  -1, 83, 84, 85, 86, -1, -1, -1, -1, -1,
4321  -1, -1, -1, -1, -1, -1, 98, 99, -1, -1,
4322  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4323  -1, -1, -1, -1, -1, -1, -1, -1, 120, 121,
4324  122, 123, 124, 125, 126, 127, 128, 129, -1, 131,
4325  132, 3, 4, 5, -1, 7, 138, -1, -1, 11,
4326  12, -1, -1, -1, 16, -1, 18, 19, 20, 21,
4327  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4328  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4329  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4330  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4331  62, -1, 64, 65, 66, -1, -1, -1, -1, -1,
4332  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4333  -1, -1, -1, -1, -1, -1, -1, 89, -1, -1,
4334  92, 93, -1, 95, 96, -1, -1, -1, -1, 101,
4335  102, 103, 104, 105, 106, 107, 108, 109, -1, -1,
4336  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4337  -1, 3, 4, 5, -1, 7, -1, -1, 130, 11,
4338  12, -1, -1, -1, 16, 137, 18, 19, 20, 21,
4339  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4340  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4341  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4342  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4343  62, -1, 64, 65, 66, -1, -1, -1, -1, -1,
4344  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4345  -1, -1, -1, -1, -1, -1, -1, 89, -1, -1,
4346  92, 93, -1, 95, 96, -1, -1, -1, -1, 101,
4347  102, 103, 104, 105, 106, 107, 108, 109, -1, -1,
4348  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4349  -1, 3, 4, 5, 6, 7, -1, -1, 130, 11,
4350  12, -1, -1, -1, 16, 137, 18, 19, 20, 21,
4351  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4352  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4353  -1, -1, -1, 45, 46, 47, 48, 49, 50, 51,
4354  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4355  62, -1, 64, 65, 66, -1, 68, 69, -1, -1,
4356  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4357  -1, -1, -1, -1, -1, -1, -1, 89, -1, -1,
4358  92, 93, -1, 95, 96, -1, 98, -1, -1, 101,
4359  102, 103, 104, 105, 106, 107, 108, 109, -1, -1,
4360  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
4361  5, -1, 7, -1, -1, -1, 11, 12, 130, 131,
4362  132, 16, -1, 18, 19, 20, 21, 22, 23, 24,
4363  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4364  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4365  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
4366  55, 56, 57, 58, 59, 60, 61, 62, -1, 64,
4367  65, 66, -1, 68, 69, -1, -1, -1, -1, -1,
4368  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4369  -1, -1, -1, -1, 89, -1, -1, 92, 93, -1,
4370  95, 96, -1, 98, 99, 100, 101, 102, 103, 104,
4371  105, 106, 107, 108, 109, -1, -1, -1, -1, -1,
4372  -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
4373  -1, -1, -1, 11, 12, 130, 131, 132, 16, -1,
4374  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4375  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4376  -1, 39, -1, -1, -1, -1, -1, 45, 46, -1,
4377  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4378  -1, 59, 60, 61, 62, -1, 64, 65, 66, -1,
4379  68, 69, -1, -1, -1, -1, -1, -1, -1, -1,
4380  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4381  -1, 89, -1, -1, 92, 93, -1, 95, 96, -1,
4382  98, -1, -1, 101, 102, 103, 104, 105, 106, 107,
4383  108, 109, -1, -1, -1, -1, -1, -1, -1, -1,
4384  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4385  11, 12, 130, 131, 132, 16, -1, 18, 19, 20,
4386  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4387  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4388  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4389  51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
4390  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
4391  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4392  -1, -1, -1, -1, -1, -1, -1, -1, 89, -1,
4393  -1, 92, 93, -1, 95, 96, -1, 98, 99, 100,
4394  101, 102, 103, 104, 105, 106, 107, 108, 109, -1,
4395  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4396  4, 5, -1, 7, -1, -1, -1, 11, 12, 130,
4397  131, 132, 16, -1, 18, 19, 20, 21, 22, 23,
4398  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4399  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4400  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4401  54, 55, 56, 57, 58, 59, 60, 61, 62, -1,
4402  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
4403  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4404  -1, -1, -1, -1, -1, 89, -1, -1, 92, 93,
4405  -1, 95, 96, -1, 98, 99, -1, 101, 102, 103,
4406  104, 105, 106, 107, 108, 109, -1, -1, -1, -1,
4407  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
4408  7, -1, -1, -1, 11, 12, 130, 131, 132, 16,
4409  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
4410  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4411  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
4412  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
4413  57, 58, 59, 60, 61, 62, -1, 64, 65, 66,
4414  -1, 68, 69, -1, -1, -1, -1, -1, -1, -1,
4415  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4416  -1, -1, 89, -1, -1, 92, 93, -1, 95, 96,
4417  -1, -1, 99, 100, 101, 102, 103, 104, 105, 106,
4418  107, 108, 109, -1, -1, -1, -1, -1, -1, -1,
4419  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4420  -1, 11, 12, 130, 131, 132, 16, -1, 18, 19,
4421  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4422  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4423  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4424  50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
4425  60, 61, 62, -1, 64, 65, 66, -1, 68, 69,
4426  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4427  -1, -1, -1, -1, -1, -1, -1, -1, -1, 89,
4428  -1, -1, 92, 93, -1, 95, 96, -1, 98, 99,
4429  -1, 101, 102, 103, 104, 105, 106, 107, 108, 109,
4430  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4431  3, 4, 5, -1, 7, -1, -1, -1, 11, 12,
4432  130, 131, 132, 16, -1, 18, 19, 20, 21, 22,
4433  23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
4434  33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
4435  -1, -1, -1, 46, -1, -1, 49, 50, 51, 52,
4436  53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
4437  -1, 64, 65, 66, -1, 68, 69, -1, -1, -1,
4438  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4439  -1, -1, -1, -1, -1, -1, 89, -1, -1, 92,
4440  93, -1, 95, 96, -1, -1, 99, -1, 101, 102,
4441  103, 104, 105, 106, 107, 108, 109, -1, -1, -1,
4442  -1, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4443  -1, 7, -1, -1, -1, 11, 12, 130, 131, 132,
4444  16, -1, 18, 19, 20, 21, 22, 23, 24, -1,
4445  -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4446  36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4447  46, -1, -1, 49, 50, 51, 52, 53, 54, 55,
4448  56, 57, -1, 59, 60, 61, 62, -1, 64, 65,
4449  66, -1, 68, 69, -1, -1, -1, -1, -1, -1,
4450  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4451  -1, -1, -1, 89, -1, -1, 92, 93, -1, 95,
4452  96, -1, 98, -1, -1, 101, 102, 103, 104, 105,
4453  106, 107, 108, 109, -1, -1, -1, -1, -1, -1,
4454  -1, -1, -1, -1, 3, 4, 5, -1, 7, -1,
4455  -1, -1, 11, 12, 130, 131, 132, 16, -1, 18,
4456  19, 20, 21, 22, 23, 24, -1, -1, -1, -1,
4457  -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4458  39, -1, -1, -1, -1, -1, -1, 46, -1, -1,
4459  49, 50, 51, 52, 53, 54, 55, 56, 57, -1,
4460  59, 60, 61, 62, -1, 64, 65, 66, -1, 68,
4461  69, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4462  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4463  89, -1, -1, 92, 93, -1, 95, 96, -1, 98,
4464  -1, -1, 101, 102, 103, 104, 105, 106, 107, 108,
4465  109, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4466  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4467  12, 130, 131, 132, 16, -1, 18, 19, 20, 21,
4468  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4469  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4470  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4471  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4472  62, -1, 64, 65, 66, -1, 68, 69, -1, -1,
4473  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4474  -1, -1, -1, -1, -1, -1, -1, 89, -1, -1,
4475  92, 93, -1, 95, 96, -1, 98, -1, -1, 101,
4476  102, 103, 104, 105, 106, 107, 108, 109, -1, -1,
4477  -1, -1, -1, -1, -1, -1, -1, -1, 3, 4,
4478  5, -1, 7, -1, -1, -1, 11, 12, 130, 131,
4479  132, 16, -1, 18, 19, 20, 21, 22, 23, 24,
4480  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4481  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4482  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
4483  55, 56, 57, -1, 59, 60, 61, 62, -1, 64,
4484  65, 66, -1, 68, 69, -1, -1, -1, -1, -1,
4485  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4486  -1, -1, -1, -1, 89, -1, -1, 92, 93, -1,
4487  95, 96, -1, 98, -1, -1, 101, 102, 103, 104,
4488  105, 106, 107, 108, 109, -1, -1, -1, -1, -1,
4489  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4490  -1, -1, -1, 11, 12, 130, 131, 132, 16, -1,
4491  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4492  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4493  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4494  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4495  -1, 59, 60, 61, 62, -1, 64, 65, 66, -1,
4496  68, 69, -1, -1, -1, -1, -1, -1, -1, -1,
4497  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4498  -1, 89, -1, -1, 92, 93, -1, 95, 96, -1,
4499  98, -1, -1, 101, 102, 103, 104, 105, 106, 107,
4500  108, 109, -1, -1, -1, -1, -1, -1, -1, -1,
4501  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4502  11, 12, 130, 131, 132, 16, -1, 18, 19, 20,
4503  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4504  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4505  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4506  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4507  61, 62, -1, 64, 65, 66, -1, 68, 69, -1,
4508  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4509  -1, -1, -1, -1, -1, -1, -1, -1, 89, -1,
4510  -1, 92, 93, -1, 95, 96, -1, -1, -1, -1,
4511  101, 102, 103, 104, 105, 106, 107, 108, 109, -1,
4512  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3,
4513  4, 5, -1, 7, -1, -1, -1, 11, 12, 130,
4514  131, 132, 16, -1, 18, 19, 20, 21, 22, 23,
4515  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4516  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4517  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4518  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4519  64, 65, 66, -1, 68, 69, -1, -1, -1, -1,
4520  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4521  -1, -1, -1, -1, -1, 89, -1, -1, 92, 93,
4522  -1, 95, 96, -1, -1, -1, -1, 101, 102, 103,
4523  104, 105, 106, 107, 108, 109, -1, -1, -1, -1,
4524  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
4525  7, -1, -1, -1, 11, 12, 130, 131, 132, 16,
4526  -1, 18, 19, 20, 21, 22, 23, 24, -1, -1,
4527  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4528  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
4529  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
4530  57, -1, 59, 60, 61, 62, -1, 64, 65, 66,
4531  -1, 68, 69, -1, -1, -1, -1, -1, -1, -1,
4532  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4533  -1, -1, 89, -1, -1, 92, 93, -1, 95, 96,
4534  -1, -1, -1, -1, 101, 102, 103, 104, 105, 106,
4535  107, 108, 109, -1, -1, -1, -1, -1, -1, -1,
4536  -1, -1, -1, 3, 4, 5, -1, 7, -1, -1,
4537  -1, 11, 12, 130, 131, 132, 16, -1, 18, 19,
4538  20, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4539  30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4540  -1, -1, -1, -1, -1, -1, 46, -1, -1, 49,
4541  50, 51, 52, 53, 54, 55, 56, 57, -1, 59,
4542  60, 61, 62, -1, 64, 65, 66, -1, -1, -1,
4543  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4544  -1, -1, -1, -1, -1, -1, -1, -1, -1, 89,
4545  -1, -1, 92, 93, -1, 95, 96, -1, 98, -1,
4546  -1, 101, 102, 103, 104, 105, 106, 107, 108, 109,
4547  -1, -1, -1, -1, -1, -1, 3, 4, 5, -1,
4548  7, -1, -1, -1, 11, 12, -1, -1, -1, 16,
4549  130, 18, 19, 20, 21, 22, 23, 24, -1, -1,
4550  -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4551  -1, -1, 39, -1, -1, -1, -1, -1, -1, 46,
4552  -1, -1, 49, 50, 51, 52, 53, 54, 55, 56,
4553  57, -1, 59, 60, 61, 62, -1, 64, 65, 66,
4554  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4555  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4556  -1, -1, 89, -1, -1, 92, 93, -1, 95, 96,
4557  -1, 98, -1, -1, 101, 102, 103, 104, 105, 106,
4558  107, 108, 109, -1, -1, -1, -1, -1, -1, 3,
4559  4, 5, -1, 7, -1, -1, -1, 11, 12, -1,
4560  -1, -1, 16, 130, 18, 19, 20, 21, 22, 23,
4561  24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4562  34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4563  -1, -1, 46, -1, -1, 49, 50, 51, 52, 53,
4564  54, 55, 56, 57, -1, 59, 60, 61, 62, -1,
4565  64, 65, 66, -1, -1, -1, -1, -1, -1, -1,
4566  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4567  -1, 85, -1, -1, -1, 89, -1, -1, 92, 93,
4568  -1, 95, 96, -1, -1, -1, -1, 101, 102, 103,
4569  104, 105, 106, 107, 108, 109, -1, -1, -1, -1,
4570  -1, -1, 3, 4, 5, -1, 7, -1, -1, -1,
4571  11, 12, -1, -1, -1, 16, 130, 18, 19, 20,
4572  21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
4573  31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4574  -1, -1, -1, -1, -1, 46, -1, -1, 49, 50,
4575  51, 52, 53, 54, 55, 56, 57, -1, 59, 60,
4576  61, 62, -1, 64, 65, 66, -1, -1, -1, -1,
4577  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4578  -1, -1, -1, -1, -1, -1, -1, -1, 89, -1,
4579  -1, 92, 93, -1, 95, 96, -1, -1, -1, -1,
4580  101, 102, 103, 104, 105, 106, 107, 108, 109, -1,
4581  -1, -1, -1, -1, -1, 3, 4, 5, -1, 7,
4582  -1, -1, -1, 11, 12, -1, -1, -1, 16, 130,
4583  18, 19, 20, 21, 22, 23, 24, -1, -1, -1,
4584  -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4585  -1, 39, -1, -1, -1, -1, -1, -1, 46, -1,
4586  -1, 49, 50, 51, 52, 53, 54, 55, 56, 57,
4587  -1, 59, 60, 61, 62, -1, 64, 65, 66, -1,
4588  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4589  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4590  -1, 89, -1, -1, 92, 93, -1, 95, 96, -1,
4591  -1, -1, -1, 101, 102, 103, 104, 105, 106, 107,
4592  108, 109, -1, -1, -1, -1, -1, -1, 3, 4,
4593  5, -1, 7, -1, -1, -1, 11, 12, -1, -1,
4594  -1, 16, 130, 18, 19, 20, 21, 22, 23, 24,
4595  -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4596  35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4597  -1, 46, -1, -1, 49, 50, 51, 52, 53, 54,
4598  55, 56, 57, -1, 59, 60, 61, 62, -1, 64,
4599  65, 66, -1, -1, -1, -1, -1, -1, -1, -1,
4600  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4601  -1, -1, -1, -1, 89, -1, -1, 92, 93, -1,
4602  95, 96, -1, -1, -1, -1, 101, 102, 103, 104,
4603  105, 106, 107, 108, 109, -1, -1, -1, -1, -1,
4604  -1, 3, 4, 5, -1, 7, -1, -1, -1, 11,
4605  12, -1, -1, -1, 16, 130, 18, 19, 20, 21,
4606  22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4607  32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4608  -1, -1, -1, -1, 46, -1, -1, 49, 50, 51,
4609  52, 53, 54, 55, 56, 57, -1, 59, 60, 61,
4610  62, -1, 64, 65, 66, -1, -1, -1, -1, -1,
4611  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4612  -1, -1, -1, -1, -1, -1, -1, 89, -1, -1,
4613  92, 93, -1, 95, 96, -1, -1, -1, -1, 101,
4614  102, 103, 104, 105, 106, 107, 108, 109, -1, -1,
4615  -1, -1, -1, 52, 53, -1, -1, 56, -1, -1,
4616  -1, -1, -1, -1, -1, -1, -1, -1, 130, 68,
4617  69, 70, 71, 72, 73, 74, 75, 76, -1, -1,
4618  79, 80, -1, -1, 83, 84, 85, 86, -1, -1,
4619  -1, -1, -1, -1, -1, -1, -1, -1, -1, 98,
4620  99, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4621  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4622  -1, 120, 121, 122, 123, 124, 125, 126, 127, 128,
4623  129, -1, 131, 132, 52, 53, -1, -1, 56, 138,
4624  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4625  68, 69, 70, 71, 72, 73, 74, 75, 76, -1,
4626  -1, 79, 80, -1, -1, 83, 84, 85, 86, -1,
4627  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4628  98, 99, -1, -1, -1, -1, -1, -1, -1, -1,
4629  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4630  -1, -1, 120, 121, 122, 123, 124, 125, 126, 127,
4631  128, 129, -1, 131, 132, 52, 53, -1, -1, 56,
4632  138, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4633  -1, 68, 69, 70, 71, 72, 73, 74, 75, 76,
4634  -1, -1, 79, 80, -1, -1, 83, 84, 85, 86,
4635  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4636  -1, 98, 99, -1, -1, -1, -1, -1, -1, -1,
4637  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4638  -1, -1, -1, 120, 121, 122, 123, 124, 125, 126,
4639  127, 128, 129, -1, 131, 132, 52, 53, -1, -1,
4640  56, 138, -1, -1, -1, -1, -1, -1, -1, -1,
4641  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
4642  76, -1, -1, 79, 80, -1, -1, 83, 84, 85,
4643  86, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4644  -1, -1, 98, 99, -1, -1, -1, -1, -1, -1,
4645  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4646  -1, -1, -1, -1, 120, 121, 122, 123, 124, 125,
4647  126, 127, 128, 129, -1, 131, 132, 52, 53, -1,
4648  -1, 56, 138, -1, -1, -1, -1, -1, -1, -1,
4649  -1, -1, -1, 68, 69, 70, 71, 72, 73, 74,
4650  75, 76, -1, -1, 79, 80, -1, -1, 83, 84,
4651  85, 86, -1, -1, -1, -1, -1, -1, -1, -1,
4652  -1, -1, -1, 98, 99, -1, -1, -1, -1, -1,
4653  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4654  -1, -1, -1, -1, -1, 120, 121, 122, 123, 124,
4655  125, 126, 127, 128, 129, -1, 131, 132, 52, 53,
4656  -1, -1, 56, 138, -1, -1, -1, -1, -1, -1,
4657  -1, -1, -1, -1, 68, 69, 70, 71, 72, 73,
4658  74, 75, 76, -1, -1, 79, 80, -1, -1, 83,
4659  84, 85, 86, -1, -1, -1, -1, -1, -1, -1,
4660  -1, -1, -1, -1, 98, 99, -1, -1, -1, -1,
4661  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4662  -1, -1, -1, -1, -1, -1, 120, 121, 122, 123,
4663  124, 125, 126, 127, 128, 129, -1, 131, 132, 52,
4664  53, -1, -1, 56, 138, -1, -1, -1, -1, -1,
4665  -1, -1, -1, -1, -1, 68, 69, 70, 71, 72,
4666  73, 74, 75, 76, -1, -1, 79, 80, -1, -1,
4667  83, 84, 85, 86, -1, -1, -1, -1, -1, -1,
4668  -1, -1, -1, -1, -1, 98, 99, -1, -1, -1,
4669  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4670  -1, -1, -1, -1, -1, -1, -1, 120, 121, 122,
4671  123, 124, 125, 126, 127, 128, 129, -1, 131, 132,
4672  52, 53, -1, -1, 56, 138, -1, -1, -1, -1,
4673  -1, -1, -1, -1, -1, -1, 68, 69, 70, 71,
4674  72, 73, 74, 75, 76, -1, -1, 79, 80, -1,
4675  -1, 83, 84, 85, 86, -1, -1, -1, -1, -1,
4676  -1, -1, -1, -1, -1, -1, 98, 99, -1, -1,
4677  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4678  -1, -1, -1, -1, -1, -1, -1, -1, 120, 121,
4679  122, 123, 124, 125, 126, 127, 128, 129, -1, 131,
4680  132, 52, 53, -1, -1, 56, 138, -1, -1, -1,
4681  -1, -1, -1, -1, -1, -1, -1, 68, 69, 70,
4682  71, 72, 73, 74, 75, 76, -1, -1, 79, 80,
4683  -1, -1, 83, 84, 85, 86, -1, -1, -1, -1,
4684  -1, -1, -1, -1, -1, -1, -1, 98, 99, -1,
4685  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4686  -1, -1, -1, -1, -1, -1, -1, -1, -1, 120,
4687  121, 122, 123, 124, 125, 126, 127, 128, 129, -1,
4688  131, 132, 52, 53, -1, -1, 56, 138, -1, -1,
4689  -1, -1, -1, -1, -1, -1, -1, -1, 68, 69,
4690  70, 71, 72, 73, 74, 75, 76, -1, -1, 79,
4691  80, -1, -1, 83, 84, 85, 86, -1, -1, -1,
4692  -1, -1, -1, -1, -1, -1, -1, -1, 98, 99,
4693  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4694  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4695  120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
4696  -1, 131, 132, 52, 53, -1, -1, 56, 138, -1,
4697  -1, -1, -1, -1, -1, -1, -1, -1, -1, 68,
4698  69, 70, 71, 72, 73, 74, 75, 76, -1, -1,
4699  79, 80, -1, -1, 83, 84, 85, 86, -1, -1,
4700  -1, -1, -1, -1, -1, -1, -1, -1, -1, 98,
4701  99, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4702  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4703  -1, 120, 121, 122, 123, 124, 125, 126, 127, 128,
4704  129, -1, 131, 132, 52, 53, -1, -1, 56, 138,
4705  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4706  68, 69, 70, 71, 72, 73, 74, 75, 76, -1,
4707  -1, 79, 80, -1, -1, 83, 84, 85, 86, -1,
4708  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4709  98, 99, -1, -1, -1, -1, -1, -1, -1, -1,
4710  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4711  -1, -1, 120, 121, 122, 123, 124, 125, 126, 127,
4712  128, 129, -1, 131, 132, 52, 53, -1, -1, 56,
4713  138, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4714  -1, 68, 69, 70, 71, 72, 73, 74, 75, 76,
4715  -1, -1, 79, 80, -1, -1, 83, 84, 85, 86,
4716  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4717  -1, 98, 99, -1, -1, -1, -1, -1, -1, -1,
4718  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4719  -1, -1, -1, 120, 121, 122, 123, 124, 125, 126,
4720  127, 128, 129, -1, 131, 132, 52, 53, -1, -1,
4721  56, 138, -1, -1, -1, -1, -1, -1, -1, -1,
4722  -1, -1, 68, 69, 70, 71, 72, 73, 74, 75,
4723  76, -1, -1, 79, 80, -1, -1, 83, 84, 85,
4724  86, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4725  -1, -1, 98, 99, 70, 71, 72, 73, 74, 75,
4726  76, 77, 78, 79, 80, 81, 82, -1, -1, 85,
4727  86, -1, -1, -1, 120, 121, 122, 123, 124, 125,
4728  126, 127, 128, 129, -1, 131, 132, -1, -1, -1,
4729  -1, -1, 138, -1, -1, -1, -1, -1, -1, -1,
4730  -1, -1, 118, -1, 120, 121, 122, 123, 124, 125,
4731  126, 127, 128, 129, -1, -1, -1, -1, -1, -1,
4732  -1, -1, -1, -1, -1, -1, -1, -1, -1, 145
4733 };
4734 
4735 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4736  symbol of state STATE-NUM. */
4737 static const yytype_uint16 yystos[] =
4738 {
4739  0, 147, 148, 0, 1, 3, 4, 5, 6, 7,
4740  11, 12, 16, 18, 19, 20, 21, 22, 23, 24,
4741  30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4742  47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4743  57, 59, 60, 61, 62, 64, 65, 66, 68, 69,
4744  89, 92, 93, 95, 96, 98, 101, 102, 103, 104,
4745  105, 106, 107, 108, 109, 130, 131, 132, 149, 150,
4746  151, 158, 160, 162, 164, 165, 168, 169, 170, 172,
4747  173, 174, 176, 177, 187, 190, 205, 224, 225, 226,
4748  227, 228, 229, 230, 231, 232, 233, 234, 261, 262,
4749  282, 283, 284, 285, 286, 287, 288, 291, 293, 294,
4750  308, 310, 311, 312, 313, 314, 315, 316, 317, 351,
4751  364, 151, 3, 4, 5, 6, 7, 8, 9, 10,
4752  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
4753  21, 22, 23, 24, 25, 26, 30, 31, 32, 33,
4754  34, 35, 36, 37, 38, 39, 45, 46, 47, 48,
4755  49, 50, 51, 52, 53, 56, 68, 69, 70, 71,
4756  72, 73, 74, 75, 76, 79, 80, 83, 84, 85,
4757  86, 98, 99, 120, 121, 122, 123, 124, 125, 126,
4758  127, 128, 129, 131, 132, 138, 180, 181, 182, 183,
4759  185, 186, 308, 310, 39, 58, 89, 92, 98, 99,
4760  100, 103, 131, 169, 177, 187, 191, 197, 200, 202,
4761  224, 313, 314, 316, 317, 349, 350, 197, 197, 139,
4762  198, 199, 139, 194, 198, 139, 145, 358, 54, 182,
4763  358, 152, 134, 21, 22, 30, 31, 32, 168, 187,
4764  224, 187, 56, 1, 47, 92, 154, 155, 156, 158,
4765  171, 172, 364, 207, 208, 192, 202, 349, 364, 191,
4766  348, 349, 364, 46, 89, 130, 137, 176, 205, 224,
4767  313, 314, 317, 252, 253, 54, 55, 57, 180, 298,
4768  309, 297, 298, 299, 143, 289, 143, 295, 143, 292,
4769  143, 296, 312, 164, 187, 187, 142, 145, 357, 362,
4770  363, 40, 41, 42, 43, 44, 37, 38, 26, 134,
4771  194, 198, 267, 28, 259, 117, 137, 92, 98, 173,
4772  117, 70, 71, 72, 73, 74, 75, 76, 77, 78,
4773  79, 80, 81, 82, 85, 86, 118, 120, 121, 122,
4774  123, 124, 125, 126, 127, 128, 129, 189, 189, 87,
4775  88, 136, 144, 355, 206, 162, 163, 163, 211, 213,
4776  163, 357, 363, 89, 170, 177, 224, 240, 313, 314,
4777  317, 52, 56, 85, 89, 178, 179, 224, 313, 314,
4778  317, 179, 33, 34, 35, 36, 49, 50, 51, 52,
4779  56, 139, 180, 315, 346, 88, 355, 356, 267, 285,
4780  90, 90, 137, 191, 56, 191, 191, 191, 297, 117,
4781  91, 137, 201, 364, 88, 136, 355, 90, 90, 137,
4782  201, 197, 358, 359, 197, 196, 197, 202, 349, 364,
4783  162, 359, 162, 54, 65, 66, 159, 139, 188, 134,
4784  154, 88, 355, 90, 158, 157, 171, 140, 357, 363,
4785  359, 359, 158, 141, 137, 145, 361, 137, 361, 135,
4786  361, 358, 56, 312, 173, 175, 137, 88, 136, 355,
4787  254, 63, 110, 112, 113, 300, 113, 300, 113, 67,
4788  300, 113, 113, 290, 300, 113, 63, 113, 113, 113,
4789  290, 113, 63, 113, 70, 142, 151, 163, 163, 163,
4790  163, 158, 162, 162, 269, 268, 97, 166, 260, 98,
4791  164, 191, 202, 203, 204, 171, 137, 176, 137, 160,
4792  161, 164, 177, 187, 191, 193, 204, 224, 317, 187,
4793  187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
4794  187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
4795  187, 187, 187, 52, 53, 56, 185, 266, 352, 353,
4796  196, 52, 53, 56, 185, 265, 352, 153, 154, 13,
4797  236, 362, 236, 163, 163, 357, 17, 276, 56, 88,
4798  136, 355, 25, 162, 52, 56, 178, 121, 318, 88,
4799  136, 355, 219, 347, 220, 88, 144, 354, 52, 56,
4800  352, 161, 187, 193, 161, 193, 184, 115, 191, 98,
4801  191, 200, 349, 52, 56, 196, 52, 56, 350, 359,
4802  140, 359, 137, 137, 359, 182, 210, 187, 149, 135,
4803  352, 352, 193, 134, 359, 156, 209, 349, 137, 175,
4804  52, 56, 196, 52, 56, 52, 54, 55, 56, 57,
4805  58, 70, 92, 98, 99, 100, 124, 127, 139, 257,
4806  322, 324, 325, 326, 327, 328, 329, 330, 331, 334,
4807  335, 336, 337, 340, 341, 342, 343, 344, 302, 301,
4808  143, 300, 143, 143, 143, 187, 273, 274, 270, 271,
4809  167, 273, 191, 137, 359, 175, 137, 44, 117, 44,
4810  88, 136, 355, 358, 90, 90, 194, 198, 264, 358,
4811  360, 90, 90, 194, 198, 263, 10, 235, 8, 278,
4812  364, 154, 13, 154, 27, 237, 362, 237, 276, 202,
4813  235, 52, 56, 196, 52, 56, 215, 218, 319, 217,
4814  52, 56, 178, 196, 153, 162, 221, 222, 194, 195,
4815  198, 364, 182, 191, 191, 201, 90, 90, 360, 90,
4816  90, 349, 162, 135, 149, 359, 361, 173, 360, 92,
4817  98, 241, 242, 243, 326, 324, 255, 117, 137, 323,
4818  191, 137, 345, 364, 52, 137, 345, 137, 323, 52,
4819  137, 323, 52, 303, 54, 55, 57, 307, 317, 10,
4820  275, 135, 272, 270, 10, 98, 191, 175, 158, 187,
4821  52, 56, 196, 52, 56, 119, 161, 193, 161, 193,
4822  166, 194, 141, 90, 161, 193, 161, 193, 166, 195,
4823  191, 204, 279, 364, 15, 239, 364, 14, 238, 239,
4824  239, 212, 214, 235, 137, 236, 360, 163, 362, 163,
4825  153, 360, 235, 359, 139, 320, 321, 180, 267, 259,
4826  90, 137, 359, 135, 243, 137, 326, 137, 359, 249,
4827  358, 256, 191, 322, 328, 340, 342, 331, 336, 344,
4828  329, 337, 342, 327, 329, 304, 78, 122, 247, 248,
4829  364, 247, 135, 191, 360, 187, 161, 193, 91, 280,
4830  364, 154, 9, 281, 364, 163, 235, 235, 154, 154,
4831  191, 154, 237, 153, 362, 235, 324, 153, 324, 223,
4832  359, 242, 137, 98, 241, 140, 142, 29, 114, 258,
4833  137, 323, 137, 323, 345, 137, 323, 137, 323, 323,
4834  305, 244, 246, 249, 327, 329, 330, 332, 333, 336,
4835  338, 339, 342, 344, 153, 154, 89, 177, 224, 313,
4836  314, 317, 236, 154, 236, 235, 235, 239, 276, 277,
4837  216, 235, 359, 235, 362, 320, 137, 242, 137, 326,
4838  52, 250, 251, 325, 154, 154, 329, 342, 329, 329,
4839  306, 249, 122, 117, 137, 245, 89, 224, 137, 345,
4840  345, 137, 245, 137, 245, 56, 88, 136, 355, 154,
4841  154, 154, 153, 242, 137, 137, 358, 235, 135, 323,
4842  137, 323, 323, 323, 154, 122, 224, 244, 339, 342,
4843  56, 88, 332, 336, 329, 338, 342, 329, 52, 56,
4844  196, 52, 56, 278, 238, 235, 235, 242, 251, 329,
4845  111, 137, 245, 137, 245, 52, 56, 345, 137, 245,
4846  137, 245, 245, 360, 323, 329, 342, 329, 329, 245,
4847  137, 245, 245, 245, 329, 245
4848 };
4849 
4850 #define yyerrok (yyerrstatus = 0)
4851 #define yyclearin (yychar = YYEMPTY)
4852 #define YYEMPTY (-2)
4853 #define YYEOF 0
4854 
4855 #define YYACCEPT goto yyacceptlab
4856 #define YYABORT goto yyabortlab
4857 #define YYERROR goto yyerrorlab
4858 
4859 
4860 /* Like YYERROR except do call yyerror. This remains here temporarily
4861  to ease the transition to the new meaning of YYERROR, for GCC.
4862  Once GCC version 2 has supplanted version 1, this can go. */
4863 
4864 #define YYFAIL goto yyerrlab
4865 
4866 #define YYRECOVERING() (!!yyerrstatus)
4867 
4868 #define YYBACKUP(Token, Value) \
4869 do \
4870  if (yychar == YYEMPTY && yylen == 1) \
4871  { \
4872  yychar = (Token); \
4873  yylval = (Value); \
4874  yytoken = YYTRANSLATE (yychar); \
4875  YYPOPSTACK (1); \
4876  goto yybackup; \
4877  } \
4878  else \
4879  { \
4880  yyerror (&yylloc, parser, YY_("syntax error: cannot back up")); \
4881  YYERROR; \
4882  } \
4883 while (YYID (0))
4884 
4885 
4886 #define YYTERROR 1
4887 #define YYERRCODE 256
4888 
4889 
4890 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
4891  If N is 0, then set CURRENT to the empty location which ends
4892  the previous symbol: RHS[0] (always defined). */
4893 
4894 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
4895 #ifndef YYLLOC_DEFAULT
4896 # define YYLLOC_DEFAULT(Current, Rhs, N) \
4897  do \
4898  if (YYID (N)) \
4899  { \
4900  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
4901  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
4902  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
4903  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
4904  } \
4905  else \
4906  { \
4907  (Current).first_line = (Current).last_line = \
4908  YYRHSLOC (Rhs, 0).last_line; \
4909  (Current).first_column = (Current).last_column = \
4910  YYRHSLOC (Rhs, 0).last_column; \
4911  } \
4912  while (YYID (0))
4913 #endif
4914 
4915 
4916 /* YY_LOCATION_PRINT -- Print the location on the stream.
4917  This macro was not mandated originally: define only if we know
4918  we won't break user code: when these are the locations we know. */
4919 
4920 #ifndef YY_LOCATION_PRINT
4921 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
4922 # define YY_LOCATION_PRINT(File, Loc) \
4923  fprintf (File, "%d.%d-%d.%d", \
4924  (Loc).first_line, (Loc).first_column, \
4925  (Loc).last_line, (Loc).last_column)
4926 # else
4927 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
4928 # endif
4929 #endif
4930 
4931 
4932 /* YYLEX -- calling `yylex' with the right arguments. */
4933 
4934 #ifdef YYLEX_PARAM
4935 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
4936 #else
4937 # define YYLEX yylex (&yylval, &yylloc, parser)
4938 #endif
4939 
4940 /* Enable debugging if requested. */
4941 #if YYDEBUG
4942 
4943 # ifndef YYFPRINTF
4944 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
4945 # define YYFPRINTF fprintf
4946 # endif
4947 
4948 # define YYDPRINTF(Args) \
4949 do { \
4950  if (yydebug) \
4951  YYFPRINTF Args; \
4952 } while (YYID (0))
4953 
4954 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
4955 do { \
4956  if (yydebug) \
4957  { \
4958  YYFPRINTF (parser, "%s ", Title); \
4959  yy_symbol_print (stderr, \
4960  Type, Value, Location, parser); \
4961  YYFPRINTF (parser, "\n"); \
4962  } \
4963 } while (YYID (0))
4964 
4965 
4966 /*--------------------------------.
4967 | Print this symbol on YYOUTPUT. |
4968 `--------------------------------*/
4969 
4970 /*ARGSUSED*/
4971 #if (defined __STDC__ || defined __C99__FUNC__ \
4972  || defined __cplusplus || defined _MSC_VER)
4973 static void
4974 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parser_params *parser)
4975 #else
4976 static void
4977 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, parser)
4978  FILE *yyoutput;
4979  int yytype;
4980  YYSTYPE const * const yyvaluep;
4981  YYLTYPE const * const yylocationp;
4982  struct parser_params *parser;
4983 #endif
4984 {
4985  if (!yyvaluep)
4986  return;
4987  YYUSE (yylocationp);
4988  YYUSE (parser);
4989 # ifdef YYPRINT
4990  if (yytype < YYNTOKENS)
4991  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
4992 # else
4993  YYUSE (yyoutput);
4994 # endif
4995  switch (yytype)
4996  {
4997  default:
4998  break;
4999  }
5000 }
5001 
5002 
5003 /*--------------------------------.
5004 | Print this symbol on YYOUTPUT. |
5005 `--------------------------------*/
5006 
5007 #if (defined __STDC__ || defined __C99__FUNC__ \
5008  || defined __cplusplus || defined _MSC_VER)
5009 static void
5010 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, struct parser_params *parser)
5011 #else
5012 static void
5013 yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, parser)
5014  FILE *yyoutput;
5015  int yytype;
5016  YYSTYPE const * const yyvaluep;
5017  YYLTYPE const * const yylocationp;
5018  struct parser_params *parser;
5019 #endif
5020 {
5021  if (yytype < YYNTOKENS)
5022  YYFPRINTF (parser, "token %s (", yytname[yytype]);
5023  else
5024  YYFPRINTF (parser, "nterm %s (", yytname[yytype]);
5025 
5026  YY_LOCATION_PRINT (yyoutput, *yylocationp);
5027  YYFPRINTF (parser, ": ");
5028  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, parser);
5029  YYFPRINTF (parser, ")");
5030 }
5031 
5032 /*------------------------------------------------------------------.
5033 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
5034 | TOP (included). |
5035 `------------------------------------------------------------------*/
5036 
5037 #if (defined __STDC__ || defined __C99__FUNC__ \
5038  || defined __cplusplus || defined _MSC_VER)
5039 static void
5040 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top, struct parser_params *parser)
5041 #else
5042 static void
5043 yy_stack_print (bottom, top, parser)
5044  yytype_int16 *bottom;
5045  yytype_int16 *top;
5046 #endif
5047 {
5048  YYFPRINTF (parser, "Stack now");
5049  for (; bottom <= top; ++bottom)
5050  YYFPRINTF (parser, " %d", *bottom);
5051  YYFPRINTF (parser, "\n");
5052 }
5053 
5054 # define YY_STACK_PRINT(Bottom, Top) \
5055 do { \
5056  if (yydebug) \
5057  yy_stack_print ((Bottom), (Top), parser); \
5058 } while (YYID (0))
5059 
5060 
5061 /*------------------------------------------------.
5062 | Report that the YYRULE is going to be reduced. |
5063 `------------------------------------------------*/
5064 
5065 #if (defined __STDC__ || defined __C99__FUNC__ \
5066  || defined __cplusplus || defined _MSC_VER)
5067 static void
5068 yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, struct parser_params *parser)
5069 #else
5070 static void
5071 yy_reduce_print (yyvsp, yylsp, yyrule, parser)
5072  YYSTYPE *yyvsp;
5073  YYLTYPE *yylsp;
5074  int yyrule;
5075  struct parser_params *parser;
5076 #endif
5077 {
5078  int yynrhs = yyr2[yyrule];
5079  int yyi;
5080  unsigned long int yylno = yyrline[yyrule];
5081  YYFPRINTF (parser, "Reducing stack by rule %d (line %lu):\n",
5082  yyrule - 1, yylno);
5083  /* The symbols being reduced. */
5084  for (yyi = 0; yyi < yynrhs; yyi++)
5085  {
5086  YYFPRINTF (parser, " $%d = ", yyi + 1);
5087  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
5088  &(yyvsp[(yyi + 1) - (yynrhs)])
5089  , &(yylsp[(yyi + 1) - (yynrhs)]) , parser);
5090  YYFPRINTF (parser, "\n");
5091  }
5092 }
5093 
5094 # define YY_REDUCE_PRINT(Rule) \
5095 do { \
5096  if (yydebug) \
5097  yy_reduce_print (yyvsp, yylsp, Rule, parser); \
5098 } while (YYID (0))
5099 
5100 /* Nonzero means print parse trace. It is left uninitialized so that
5101  multiple parsers can coexist. */
5102 #ifndef yydebug
5103 int yydebug;
5104 #endif
5105 #else /* !YYDEBUG */
5106 # define YYDPRINTF(Args)
5107 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
5108 # define YY_STACK_PRINT(Bottom, Top)
5109 # define YY_REDUCE_PRINT(Rule)
5110 #endif /* !YYDEBUG */
5111 
5112 
5113 /* YYINITDEPTH -- initial size of the parser's stacks. */
5114 #ifndef YYINITDEPTH
5115 # define YYINITDEPTH 200
5116 #endif
5117 
5118 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
5119  if the built-in stack extension method is used).
5120 
5121  Do not make this value too large; the results are undefined if
5122  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
5123  evaluated with infinite-precision integer arithmetic. */
5124 
5125 #ifndef YYMAXDEPTH
5126 # define YYMAXDEPTH 10000
5127 #endif
5128 
5129 
5130 
5131 #if YYERROR_VERBOSE
5132 
5133 # ifndef yystrlen
5134 # if defined __GLIBC__ && defined _STRING_H
5135 # define yystrlen strlen
5136 # else
5137 /* Return the length of YYSTR. */
5138 #if (defined __STDC__ || defined __C99__FUNC__ \
5139  || defined __cplusplus || defined _MSC_VER)
5140 static YYSIZE_T
5141 yystrlen (const char *yystr)
5142 #else
5143 static YYSIZE_T
5144 yystrlen (yystr)
5145  const char *yystr;
5146 #endif
5147 {
5148  YYSIZE_T yylen;
5149  for (yylen = 0; yystr[yylen]; yylen++)
5150  continue;
5151  return yylen;
5152 }
5153 # endif
5154 # endif
5155 
5156 # ifndef yystpcpy
5157 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
5158 # define yystpcpy stpcpy
5159 # else
5160 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
5161  YYDEST. */
5162 #if (defined __STDC__ || defined __C99__FUNC__ \
5163  || defined __cplusplus || defined _MSC_VER)
5164 static char *
5165 yystpcpy (char *yydest, const char *yysrc)
5166 #else
5167 static char *
5168 yystpcpy (yydest, yysrc)
5169  char *yydest;
5170  const char *yysrc;
5171 #endif
5172 {
5173  char *yyd = yydest;
5174  const char *yys = yysrc;
5175 
5176  while ((*yyd++ = *yys++) != '\0')
5177  continue;
5178 
5179  return yyd - 1;
5180 }
5181 # endif
5182 # endif
5183 
5184 # ifndef yytnamerr
5185 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
5186  quotes and backslashes, so that it's suitable for yyerror. The
5187  heuristic is that double-quoting is unnecessary unless the string
5188  contains an apostrophe, a comma, or backslash (other than
5189  backslash-backslash). YYSTR is taken from yytname. If YYRES is
5190  null, do not copy; instead, return the length of what the result
5191  would have been. */
5192 static YYSIZE_T
5193 yytnamerr (char *yyres, const char *yystr)
5194 {
5195  if (*yystr == '"')
5196  {
5197  YYSIZE_T yyn = 0;
5198  char const *yyp = yystr;
5199 
5200  for (;;)
5201  switch (*++yyp)
5202  {
5203  case '\'':
5204  case ',':
5205  goto do_not_strip_quotes;
5206 
5207  case '\\':
5208  if (*++yyp != '\\')
5209  goto do_not_strip_quotes;
5210  /* Fall through. */
5211  default:
5212  if (yyres)
5213  yyres[yyn] = *yyp;
5214  yyn++;
5215  break;
5216 
5217  case '"':
5218  if (yyres)
5219  yyres[yyn] = '\0';
5220  return yyn;
5221  }
5222  do_not_strip_quotes: ;
5223  }
5224 
5225  if (! yyres)
5226  return yystrlen (yystr);
5227 
5228  return yystpcpy (yyres, yystr) - yyres;
5229 }
5230 # endif
5231 
5232 /* Copy into YYRESULT an error message about the unexpected token
5233  YYCHAR while in state YYSTATE. Return the number of bytes copied,
5234  including the terminating null byte. If YYRESULT is null, do not
5235  copy anything; just return the number of bytes that would be
5236  copied. As a special case, return 0 if an ordinary "syntax error"
5237  message will do. Return YYSIZE_MAXIMUM if overflow occurs during
5238  size calculation. */
5239 static YYSIZE_T
5240 yysyntax_error (char *yyresult, int yystate, int yychar)
5241 {
5242  int yyn = yypact[yystate];
5243 
5244  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
5245  return 0;
5246  else
5247  {
5248  int yytype = YYTRANSLATE (yychar);
5249  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
5250  YYSIZE_T yysize = yysize0;
5251  YYSIZE_T yysize1;
5252  int yysize_overflow = 0;
5253  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
5254  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
5255  int yyx;
5256 
5257 # if 0
5258  /* This is so xgettext sees the translatable formats that are
5259  constructed on the fly. */
5260  YY_("syntax error, unexpected %s");
5261  YY_("syntax error, unexpected %s, expecting %s");
5262  YY_("syntax error, unexpected %s, expecting %s or %s");
5263  YY_("syntax error, unexpected %s, expecting %s or %s or %s");
5264  YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
5265 # endif
5266  char *yyfmt;
5267  char const *yyf;
5268  static char const yyunexpected[] = "syntax error, unexpected %s";
5269  static char const yyexpecting[] = ", expecting %s";
5270  static char const yyor[] = " or %s";
5271  char yyformat[sizeof yyunexpected
5272  + sizeof yyexpecting - 1
5273  + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
5274  * (sizeof yyor - 1))];
5275  char const *yyprefix = yyexpecting;
5276 
5277  /* Start YYX at -YYN if negative to avoid negative indexes in
5278  YYCHECK. */
5279  int yyxbegin = yyn < 0 ? -yyn : 0;
5280 
5281  /* Stay within bounds of both yycheck and yytname. */
5282  int yychecklim = YYLAST - yyn + 1;
5283  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
5284  int yycount = 1;
5285 
5286  yyarg[0] = yytname[yytype];
5287  yyfmt = yystpcpy (yyformat, yyunexpected);
5288 
5289  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
5290  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
5291  {
5292  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
5293  {
5294  yycount = 1;
5295  yysize = yysize0;
5296  yyformat[sizeof yyunexpected - 1] = '\0';
5297  break;
5298  }
5299  yyarg[yycount++] = yytname[yyx];
5300  yysize1 = yysize + yytnamerr (0, yytname[yyx]);
5301  yysize_overflow |= (yysize1 < yysize);
5302  yysize = yysize1;
5303  yyfmt = yystpcpy (yyfmt, yyprefix);
5304  yyprefix = yyor;
5305  }
5306 
5307  yyf = YY_(yyformat);
5308  yysize1 = yysize + yystrlen (yyf);
5309  yysize_overflow |= (yysize1 < yysize);
5310  yysize = yysize1;
5311 
5312  if (yysize_overflow)
5313  return YYSIZE_MAXIMUM;
5314 
5315  if (yyresult)
5316  {
5317  /* Avoid sprintf, as that infringes on the user's name space.
5318  Don't have undefined behavior even if the translation
5319  produced a string with the wrong number of "%s"s. */
5320  char *yyp = yyresult;
5321  int yyi = 0;
5322  while ((*yyp = *yyf) != '\0')
5323  {
5324  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
5325  {
5326  yyp += yytnamerr (yyp, yyarg[yyi++]);
5327  yyf += 2;
5328  }
5329  else
5330  {
5331  yyp++;
5332  yyf++;
5333  }
5334  }
5335  }
5336  return yysize;
5337  }
5338 }
5339 #endif /* YYERROR_VERBOSE */
5340 
5341 
5342 /*-----------------------------------------------.
5343 | Release the memory associated to this symbol. |
5344 `-----------------------------------------------*/
5345 
5346 /*ARGSUSED*/
5347 #if (defined __STDC__ || defined __C99__FUNC__ \
5348  || defined __cplusplus || defined _MSC_VER)
5349 static void
5350 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, struct parser_params *parser)
5351 #else
5352 static void
5353 yydestruct (yymsg, yytype, yyvaluep, yylocationp, parser)
5354  const char *yymsg;
5355  int yytype;
5356  YYSTYPE *yyvaluep;
5357  YYLTYPE *yylocationp;
5358  struct parser_params *parser;
5359 #endif
5360 {
5361  YYUSE (yyvaluep);
5362  YYUSE (yylocationp);
5363  YYUSE (parser);
5364 
5365  if (!yymsg)
5366  yymsg = "Deleting";
5367  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
5368 
5369  switch (yytype)
5370  {
5371 
5372  default:
5373  break;
5374  }
5375 }
5376 
5377 
5378 /* Prevent warnings from -Wmissing-prototypes. */
5379 
5380 #ifdef YYPARSE_PARAM
5381 #if defined __STDC__ || defined __cplusplus
5382 int yyparse (void *YYPARSE_PARAM);
5383 #else
5384 int yyparse ();
5385 #endif
5386 #else /* ! YYPARSE_PARAM */
5387 #if defined __STDC__ || defined __cplusplus
5388 int yyparse (struct parser_params *parser);
5389 #else
5390 int yyparse ();
5391 #endif
5392 #endif /* ! YYPARSE_PARAM */
5393 
5394 
5395 
5396 
5397 
5398 
5399 /*----------.
5400 | yyparse. |
5401 `----------*/
5402 
5403 #ifdef YYPARSE_PARAM
5404 #if (defined __STDC__ || defined __C99__FUNC__ \
5405  || defined __cplusplus || defined _MSC_VER)
5406 int
5407 yyparse (void *YYPARSE_PARAM)
5408 #else
5409 int
5410 yyparse (YYPARSE_PARAM)
5411  void *YYPARSE_PARAM;
5412 #endif
5413 #else /* ! YYPARSE_PARAM */
5414 #if (defined __STDC__ || defined __C99__FUNC__ \
5415  || defined __cplusplus || defined _MSC_VER)
5416 int
5417 yyparse (struct parser_params *parser)
5418 #else
5419 int
5420 yyparse (parser)
5421  struct parser_params *parser;
5422 #endif
5423 #endif
5424 {
5425  /* The look-ahead symbol. */
5426 int yychar;
5427 
5428 /* The semantic value of the look-ahead symbol. */
5429 YYSTYPE yylval;
5430 
5431 /* Number of syntax errors so far. */
5432 int yynerrs;
5433 /* Location data for the look-ahead symbol. */
5434 YYLTYPE yylloc;
5435 
5436  int yystate;
5437  int yyn;
5438  int yyresult;
5439  /* Number of tokens to shift before error messages enabled. */
5440  int yyerrstatus;
5441  /* Look-ahead token as an internal (translated) token number. */
5442  int yytoken = 0;
5443 #if YYERROR_VERBOSE
5444  /* Buffer for error messages, and its allocated size. */
5445  char yymsgbuf[128];
5446  char *yymsg = yymsgbuf;
5447  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
5448 #endif
5449 
5450  /* Three stacks and their tools:
5451  `yyss': related to states,
5452  `yyvs': related to semantic values,
5453  `yyls': related to locations.
5454 
5455  Refer to the stacks thru separate pointers, to allow yyoverflow
5456  to reallocate them elsewhere. */
5457 
5458  /* The state stack. */
5459  yytype_int16 yyssa[YYINITDEPTH];
5460  yytype_int16 *yyss = yyssa;
5461  yytype_int16 *yyssp;
5462 
5463  /* The semantic value stack. */
5464  YYSTYPE yyvsa[YYINITDEPTH];
5465  YYSTYPE *yyvs = yyvsa;
5466  YYSTYPE *yyvsp;
5467 
5468  /* The location stack. */
5469  YYLTYPE yylsa[YYINITDEPTH];
5470  YYLTYPE *yyls = yylsa;
5471  YYLTYPE *yylsp;
5472  /* The locations where the error started and ended. */
5473  YYLTYPE yyerror_range[2];
5474 
5475 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
5476 
5477  YYSIZE_T yystacksize = YYINITDEPTH;
5478 
5479  /* The variables used to return semantic value and location from the
5480  action routines. */
5481  YYSTYPE yyval;
5482  YYLTYPE yyloc;
5483 
5484  /* The number of symbols on the RHS of the reduced rule.
5485  Keep to zero when no symbol should be popped. */
5486  int yylen = 0;
5487 
5488  YYDPRINTF ((parser, "Starting parse\n"));
5489 
5490  yystate = 0;
5491  yyerrstatus = 0;
5492  yynerrs = 0;
5493  yychar = YYEMPTY; /* Cause a token to be read. */
5494 
5495  /* Initialize stack pointers.
5496  Waste one element of value and location stack
5497  so that they stay on the same level as the state stack.
5498  The wasted elements are never initialized. */
5499 
5500  yyssp = yyss;
5501  yyvsp = yyvs;
5502  yylsp = yyls;
5503 #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
5504  /* Initialize the default location before parsing starts. */
5505  yylloc.first_line = yylloc.last_line = 1;
5506  yylloc.first_column = yylloc.last_column = 0;
5507 #endif
5508 
5509  goto yysetstate;
5510 
5511 /*------------------------------------------------------------.
5512 | yynewstate -- Push a new state, which is found in yystate. |
5513 `------------------------------------------------------------*/
5514  yynewstate:
5515  /* In all cases, when you get here, the value and location stacks
5516  have just been pushed. So pushing a state here evens the stacks. */
5517  yyssp++;
5518 
5519  yysetstate:
5520  *yyssp = yystate;
5521 
5522  if (yyss + yystacksize - 1 <= yyssp)
5523  {
5524  /* Get the current used size of the three stacks, in elements. */
5525  YYSIZE_T yysize = yyssp - yyss + 1;
5526 
5527 #ifdef yyoverflow
5528  {
5529  /* Give user a chance to reallocate the stack. Use copies of
5530  these so that the &'s don't force the real ones into
5531  memory. */
5532  YYSTYPE *yyvs1 = yyvs;
5533  yytype_int16 *yyss1 = yyss;
5534  YYLTYPE *yyls1 = yyls;
5535 
5536  /* Each stack pointer address is followed by the size of the
5537  data in use in that stack, in bytes. This used to be a
5538  conditional around just the two extra args, but that might
5539  be undefined if yyoverflow is a macro. */
5540  yyoverflow (YY_("memory exhausted"),
5541  &yyss1, yysize * sizeof (*yyssp),
5542  &yyvs1, yysize * sizeof (*yyvsp),
5543  &yyls1, yysize * sizeof (*yylsp),
5544  &yystacksize);
5545  yyls = yyls1;
5546  yyss = yyss1;
5547  yyvs = yyvs1;
5548  }
5549 #else /* no yyoverflow */
5550 # ifndef YYSTACK_RELOCATE
5551  goto yyexhaustedlab;
5552 # else
5553  /* Extend the stack our own way. */
5554  if (YYMAXDEPTH <= yystacksize)
5555  goto yyexhaustedlab;
5556  yystacksize *= 2;
5557  if (YYMAXDEPTH < yystacksize)
5558  yystacksize = YYMAXDEPTH;
5559 
5560  {
5561  yytype_int16 *yyss1 = yyss;
5562  union yyalloc *yyptr =
5563  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
5564  if (! yyptr)
5565  goto yyexhaustedlab;
5566  YYSTACK_RELOCATE (yyss);
5567  YYSTACK_RELOCATE (yyvs);
5568  YYSTACK_RELOCATE (yyls);
5569 # undef YYSTACK_RELOCATE
5570  if (yyss1 != yyssa)
5571  YYSTACK_FREE (yyss1);
5572  }
5573 # endif
5574 #endif /* no yyoverflow */
5575 
5576  yyssp = yyss + yysize - 1;
5577  yyvsp = yyvs + yysize - 1;
5578  yylsp = yyls + yysize - 1;
5579 
5580  YYDPRINTF ((parser, "Stack size increased to %lu\n",
5581  (unsigned long int) yystacksize));
5582 
5583  if (yyss + yystacksize - 1 <= yyssp)
5584  YYABORT;
5585  }
5586 
5587  YYDPRINTF ((parser, "Entering state %d\n", yystate));
5588 
5589  goto yybackup;
5590 
5591 /*-----------.
5592 | yybackup. |
5593 `-----------*/
5594 yybackup:
5595 
5596  /* Do appropriate processing given the current state. Read a
5597  look-ahead token if we need one and don't already have one. */
5598 
5599  /* First try to decide what to do without reference to look-ahead token. */
5600  yyn = yypact[yystate];
5601  if (yyn == YYPACT_NINF)
5602  goto yydefault;
5603 
5604  /* Not known => get a look-ahead token if don't already have one. */
5605 
5606  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
5607  if (yychar == YYEMPTY)
5608  {
5609  YYDPRINTF ((parser, "Reading a token: "));
5610  yychar = YYLEX;
5611  }
5612 
5613  if (yychar <= YYEOF)
5614  {
5615  yychar = yytoken = YYEOF;
5616  YYDPRINTF ((parser, "Now at end of input.\n"));
5617  }
5618  else
5619  {
5620  yytoken = YYTRANSLATE (yychar);
5621  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
5622  }
5623 
5624  /* If the proper action on seeing token YYTOKEN is to reduce or to
5625  detect an error, take that action. */
5626  yyn += yytoken;
5627  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
5628  goto yydefault;
5629  yyn = yytable[yyn];
5630  if (yyn <= 0)
5631  {
5632  if (yyn == 0 || yyn == YYTABLE_NINF)
5633  goto yyerrlab;
5634  yyn = -yyn;
5635  goto yyreduce;
5636  }
5637 
5638  if (yyn == YYFINAL)
5639  YYACCEPT;
5640 
5641  /* Count tokens shifted since error; after three, turn off error
5642  status. */
5643  if (yyerrstatus)
5644  yyerrstatus--;
5645 
5646  /* Shift the look-ahead token. */
5647  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
5648 
5649  /* Discard the shifted token unless it is eof. */
5650  if (yychar != YYEOF)
5651  yychar = YYEMPTY;
5652 
5653  yystate = yyn;
5654  *++yyvsp = yylval;
5655  *++yylsp = yylloc;
5656  goto yynewstate;
5657 
5658 
5659 /*-----------------------------------------------------------.
5660 | yydefault -- do the default action for the current state. |
5661 `-----------------------------------------------------------*/
5662 yydefault:
5663  yyn = yydefact[yystate];
5664  if (yyn == 0)
5665  goto yyerrlab;
5666  goto yyreduce;
5667 
5668 
5669 /*-----------------------------.
5670 | yyreduce -- Do a reduction. |
5671 `-----------------------------*/
5672 yyreduce:
5673  /* yyn is the number of a rule to reduce with. */
5674  yylen = yyr2[yyn];
5675 
5676  /* If YYLEN is nonzero, implement the default value of the action:
5677  `$$ = $1'.
5678 
5679  Otherwise, the following line sets YYVAL to garbage.
5680  This behavior is undocumented and Bison
5681  users should not rely upon it. Assigning to YYVAL
5682  unconditionally makes the parser a bit smaller, and it avoids a
5683  GCC warning that YYVAL may be used uninitialized. */
5684  yyval = yyvsp[1-yylen];
5685 
5686  /* Default location. */
5687  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
5688  YY_REDUCE_PRINT (yyn);
5689  switch (yyn)
5690  {
5691  case 2:
5692 #line 1064 "ripper.y"
5693  {
5694  SET_LEX_STATE(EXPR_BEG);
5695 #if 0
5696  local_push(compile_for_eval || in_main);
5697 #endif
5698  local_push(0);
5699 
5700  ;}
5701  break;
5702 
5703  case 3:
5704 #line 1073 "ripper.y"
5705  {
5706 #if 0
5707  if ((yyvsp[(2) - (2)].val) && !compile_for_eval) {
5708  /* last expression should not be void */
5709  if (nd_type((yyvsp[(2) - (2)].val)) != NODE_BLOCK) void_expr((yyvsp[(2) - (2)].val));
5710  else {
5711  NODE *node = (yyvsp[(2) - (2)].val);
5712  while (node->nd_next) {
5713  node = node->nd_next;
5714  }
5715  void_expr(node->nd_head);
5716  }
5717  }
5718  ruby_eval_tree = new_scope(0, block_append(ruby_eval_tree, (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column), (yylsp[(1) - (2)]).first_column);
5719 #endif
5720  (yyval.val) = (yyvsp[(2) - (2)].val);
5721  parser->result = dispatch1(program, (yyval.val));
5722 
5723  local_pop();
5724  ;}
5725  break;
5726 
5727  case 4:
5728 #line 1096 "ripper.y"
5729  {
5730 #if 0
5731  void_stmts((yyvsp[(1) - (2)].val));
5732 #endif
5733 
5734  (yyval.val) = (yyvsp[(1) - (2)].val);
5735  ;}
5736  break;
5737 
5738  case 5:
5739 #line 1106 "ripper.y"
5740  {
5741 #if 0
5742  (yyval.val) = new_begin(0, (yylsp[(1) - (1)]).first_column);
5743 #endif
5744  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5745  dispatch0(void_stmt));
5746 
5747  ;}
5748  break;
5749 
5750  case 6:
5751 #line 1115 "ripper.y"
5752  {
5753 #if 0
5754  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5755 #endif
5756  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5757 
5758  ;}
5759  break;
5760 
5761  case 7:
5762 #line 1123 "ripper.y"
5763  {
5764 #if 0
5765  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)), (yylsp[(1) - (3)]).first_column);
5766 #endif
5767  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5768 
5769  ;}
5770  break;
5771 
5772  case 8:
5773 #line 1131 "ripper.y"
5774  {
5775  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5776  ;}
5777  break;
5778 
5779  case 10:
5780 #line 1138 "ripper.y"
5781  {
5782 #if 0
5783  /* local_push(0); */
5784 #endif
5785 
5786  ;}
5787  break;
5788 
5789  case 11:
5790 #line 1145 "ripper.y"
5791  {
5792 #if 0
5793  ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
5794  (yyvsp[(4) - (5)].val), (yylsp[(1) - (5)]).first_column);
5795  /* NEW_PREEXE($4)); */
5796  /* local_pop(); */
5797  (yyval.val) = new_begin(0, (yylsp[(1) - (5)]).first_column);
5798 #endif
5799  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5800 
5801  ;}
5802  break;
5803 
5804  case 12:
5805 #line 1162 "ripper.y"
5806  {
5807 #if 0
5808  (yyval.val) = (yyvsp[(1) - (4)].val);
5809  if ((yyvsp[(2) - (4)].val)) {
5810  (yyval.val) = new_rescue((yyvsp[(1) - (4)].val), (yyvsp[(2) - (4)].val), (yyvsp[(3) - (4)].val), (yylsp[(1) - (4)]).first_column);
5811  }
5812  else if ((yyvsp[(3) - (4)].val)) {
5813  rb_warn0("else without rescue is useless");
5814  (yyval.val) = block_append((yyval.val), (yyvsp[(3) - (4)].val), (yylsp[(1) - (4)]).first_column);
5815  }
5816  if ((yyvsp[(4) - (4)].val)) {
5817  if ((yyval.val)) {
5818  (yyval.val) = NEW_ENSURE((yyval.val), (yyvsp[(4) - (4)].val));
5819  nd_set_column((yyval.val), (yylsp[(1) - (4)]).first_column);
5820  }
5821  else {
5822  NODE *nil = NEW_NIL();
5823  nd_set_column(nil, (yylsp[(1) - (4)]).first_column);
5824  (yyval.val) = block_append((yyvsp[(4) - (4)].val), nil, (yylsp[(1) - (4)]).first_column);
5825  }
5826  }
5827  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
5828 #endif
5829  (yyval.val) = dispatch4(bodystmt,
5830  escape_Qundef((yyvsp[(1) - (4)].val)),
5831  escape_Qundef((yyvsp[(2) - (4)].val)),
5832  escape_Qundef((yyvsp[(3) - (4)].val)),
5833  escape_Qundef((yyvsp[(4) - (4)].val)));
5834 
5835  ;}
5836  break;
5837 
5838  case 13:
5839 #line 1195 "ripper.y"
5840  {
5841 #if 0
5842  void_stmts((yyvsp[(1) - (2)].val));
5843 #endif
5844 
5845  (yyval.val) = (yyvsp[(1) - (2)].val);
5846  ;}
5847  break;
5848 
5849  case 14:
5850 #line 1205 "ripper.y"
5851  {
5852 #if 0
5853  (yyval.val) = new_begin(0, (yylsp[(1) - (1)]).first_column);
5854 #endif
5855  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new),
5856  dispatch0(void_stmt));
5857 
5858  ;}
5859  break;
5860 
5861  case 15:
5862 #line 1214 "ripper.y"
5863  {
5864 #if 0
5865  (yyval.val) = newline_node((yyvsp[(1) - (1)].val));
5866 #endif
5867  (yyval.val) = dispatch2(stmts_add, dispatch0(stmts_new), (yyvsp[(1) - (1)].val));
5868 
5869  ;}
5870  break;
5871 
5872  case 16:
5873 #line 1222 "ripper.y"
5874  {
5875 #if 0
5876  (yyval.val) = block_append((yyvsp[(1) - (3)].val), newline_node((yyvsp[(3) - (3)].val)), (yylsp[(1) - (3)]).first_column);
5877 #endif
5878  (yyval.val) = dispatch2(stmts_add, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
5879 
5880  ;}
5881  break;
5882 
5883  case 17:
5884 #line 1230 "ripper.y"
5885  {
5886  (yyval.val) = remove_begin((yyvsp[(2) - (2)].val));
5887  ;}
5888  break;
5889 
5890  case 18:
5891 #line 1236 "ripper.y"
5892  {
5893  (yyval.val) = (yyvsp[(1) - (1)].val);
5894  ;}
5895  break;
5896 
5897  case 19:
5898 #line 1240 "ripper.y"
5899  {
5900  yyerror0("BEGIN is permitted only at toplevel");
5901 #if 0
5902  /* local_push(0); */
5903 #endif
5904 
5905  ;}
5906  break;
5907 
5908  case 20:
5909 #line 1248 "ripper.y"
5910  {
5911 #if 0
5912  ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
5913  (yyvsp[(4) - (5)].val), (yylsp[(1) - (5)]).first_column);
5914  /* NEW_PREEXE($4)); */
5915  /* local_pop(); */
5916  (yyval.val) = new_begin(0, (yylsp[(1) - (5)]).first_column);
5917 #endif
5918  (yyval.val) = dispatch1(BEGIN, (yyvsp[(4) - (5)].val));
5919 
5920  ;}
5921  break;
5922 
5923  case 21:
5924 #line 1261 "ripper.y"
5925  {SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);;}
5926  break;
5927 
5928  case 22:
5929 #line 1262 "ripper.y"
5930  {
5931 #if 0
5932  (yyval.val) = NEW_ALIAS((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5933  nd_set_column((yyval.val), (yylsp[(1) - (4)]).first_column);
5934 #endif
5935  (yyval.val) = dispatch2(alias, (yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5936 
5937  ;}
5938  break;
5939 
5940  case 23:
5941 #line 1271 "ripper.y"
5942  {
5943 #if 0
5944  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5945  nd_set_column((yyval.val), (yylsp[(1) - (3)]).first_column);
5946 #endif
5947  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5948 
5949  ;}
5950  break;
5951 
5952  case 24:
5953 #line 1280 "ripper.y"
5954  {
5955 #if 0
5956  char buf[2];
5957  buf[0] = '$';
5958  buf[1] = (char)(yyvsp[(3) - (3)].val)->nd_nth;
5959  (yyval.val) = NEW_VALIAS((yyvsp[(2) - (3)].val), rb_intern2(buf, 2));
5960  nd_set_column((yyval.val), (yylsp[(1) - (3)]).first_column);
5961 #endif
5962  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5963 
5964  ;}
5965  break;
5966 
5967  case 25:
5968 #line 1292 "ripper.y"
5969  {
5970 #if 0
5971  yyerror0("can't make alias for the number variables");
5972  (yyval.val) = new_begin(0, (yylsp[(1) - (3)]).first_column);
5973 #endif
5974  (yyval.val) = dispatch2(var_alias, (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
5975  (yyval.val) = dispatch1(alias_error, (yyval.val));
5976  ripper_error();
5977 
5978  ;}
5979  break;
5980 
5981  case 26:
5982 #line 1303 "ripper.y"
5983  {
5984 #if 0
5985  (yyval.val) = (yyvsp[(2) - (2)].val);
5986 #endif
5987  (yyval.val) = dispatch1(undef, (yyvsp[(2) - (2)].val));
5988 
5989  ;}
5990  break;
5991 
5992  case 27:
5993 #line 1311 "ripper.y"
5994  {
5995 #if 0
5996  (yyval.val) = new_if((yyvsp[(3) - (3)].val), remove_begin((yyvsp[(1) - (3)].val)), 0, (yylsp[(1) - (3)]).first_column);
5997  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
5998 #endif
5999  (yyval.val) = dispatch2(if_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
6000 
6001  ;}
6002  break;
6003 
6004  case 28:
6005 #line 1320 "ripper.y"
6006  {
6007 #if 0
6008  (yyval.val) = new_unless((yyvsp[(3) - (3)].val), remove_begin((yyvsp[(1) - (3)].val)), 0, (yylsp[(1) - (3)]).first_column);
6009  fixpos((yyval.val), (yyvsp[(3) - (3)].val));
6010 #endif
6011  (yyval.val) = dispatch2(unless_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
6012 
6013  ;}
6014  break;
6015 
6016  case 29:
6017 #line 1329 "ripper.y"
6018  {
6019 #if 0
6020  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
6021  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column), (yyvsp[(1) - (3)].val)->nd_body, 0);
6022  }
6023  else {
6024  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column), (yyvsp[(1) - (3)].val), 1);
6025  }
6026  nd_set_column((yyval.val), (yylsp[(1) - (3)]).first_column);
6027 #endif
6028  (yyval.val) = dispatch2(while_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
6029 
6030  ;}
6031  break;
6032 
6033  case 30:
6034 #line 1343 "ripper.y"
6035  {
6036 #if 0
6037  if ((yyvsp[(1) - (3)].val) && nd_type((yyvsp[(1) - (3)].val)) == NODE_BEGIN) {
6038  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column), (yyvsp[(1) - (3)].val)->nd_body, 0);
6039  }
6040  else {
6041  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column), (yyvsp[(1) - (3)].val), 1);
6042  }
6043  nd_set_column((yyval.val), (yylsp[(1) - (3)]).first_column);
6044 #endif
6045  (yyval.val) = dispatch2(until_mod, (yyvsp[(3) - (3)].val), (yyvsp[(1) - (3)].val));
6046 
6047  ;}
6048  break;
6049 
6050  case 31:
6051 #line 1357 "ripper.y"
6052  {
6053 #if 0
6054  NODE *resq = new_resbody(0, remove_begin((yyvsp[(3) - (3)].val)), 0, (yylsp[(1) - (3)]).first_column);
6055  (yyval.val) = new_rescue(remove_begin((yyvsp[(1) - (3)].val)), resq, 0, (yylsp[(1) - (3)]).first_column);
6056  nd_set_column(resq, (yylsp[(1) - (3)]).first_column);
6057 #endif
6058  (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6059 
6060  ;}
6061  break;
6062 
6063  case 32:
6064 #line 1367 "ripper.y"
6065  {
6066  if (in_def || in_single) {
6067  rb_warn0("END in method; use at_exit");
6068  }
6069 #if 0
6070  {
6071  NODE *scope = NEW_NODE(
6072  NODE_SCOPE, 0 /* tbl */, (yyvsp[(3) - (4)].val) /* body */, 0 /* args */);
6073  (yyval.val) = NEW_POSTEXE(scope);
6074  nd_set_column(scope, (yylsp[(1) - (4)]).first_column);
6075  nd_set_column((yyval.val), (yylsp[(1) - (4)]).first_column);
6076  }
6077 #endif
6078  (yyval.val) = dispatch1(END, (yyvsp[(3) - (4)].val));
6079 
6080  ;}
6081  break;
6082 
6083  case 34:
6084 #line 1385 "ripper.y"
6085  {
6086 #if 0
6087  value_expr((yyvsp[(3) - (3)].val));
6088  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
6089  (yyval.val) = (yyvsp[(1) - (3)].val);
6090 #endif
6091  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6092 
6093  ;}
6094  break;
6095 
6096  case 35:
6097 #line 1395 "ripper.y"
6098  {
6099  value_expr((yyvsp[(3) - (3)].val));
6100  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
6101  ;}
6102  break;
6103 
6104  case 36:
6105 #line 1400 "ripper.y"
6106  {
6107 #if 0
6108  (yyvsp[(1) - (3)].val)->nd_value = (yyvsp[(3) - (3)].val);
6109  (yyval.val) = (yyvsp[(1) - (3)].val);
6110 #endif
6111  (yyval.val) = dispatch2(massign, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6112 
6113  ;}
6114  break;
6115 
6116  case 38:
6117 #line 1412 "ripper.y"
6118  {
6119  value_expr((yyvsp[(3) - (3)].val));
6120  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
6121  ;}
6122  break;
6123 
6124  case 39:
6125 #line 1417 "ripper.y"
6126  {
6127  value_expr((yyvsp[(3) - (3)].val));
6128  (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
6129  ;}
6130  break;
6131 
6132  case 40:
6133 #line 1422 "ripper.y"
6134  {
6135 #if 0
6136  NODE *args;
6137 
6138  value_expr((yyvsp[(6) - (6)].val));
6139  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = new_zarray((yylsp[(1) - (6)]).first_column);
6140  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val), (yylsp[(1) - (6)]).first_column);
6141  if ((yyvsp[(5) - (6)].val) == tOROP) {
6142  (yyvsp[(5) - (6)].val) = 0;
6143  }
6144  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
6145  (yyvsp[(5) - (6)].val) = 1;
6146  }
6147  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
6148  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
6149  nd_set_column((yyval.val), (yylsp[(1) - (6)]).first_column);
6150 #endif
6151  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
6152  (yyval.val) = dispatch3(opassign, (yyval.val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
6153 
6154  ;}
6155  break;
6156 
6157  case 41:
6158 #line 1444 "ripper.y"
6159  {
6160  value_expr((yyvsp[(5) - (5)].val));
6161  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val), (yylsp[(1) - (5)]).first_column);
6162  ;}
6163  break;
6164 
6165  case 42:
6166 #line 1449 "ripper.y"
6167  {
6168  value_expr((yyvsp[(5) - (5)].val));
6169  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val), (yylsp[(1) - (5)]).first_column);
6170  ;}
6171  break;
6172 
6173  case 43:
6174 #line 1454 "ripper.y"
6175  {
6176  (yyval.val) = const_path_field((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yylsp[(1) - (5)]).first_column);
6177  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val), (yylsp[(1) - (5)]).first_column);
6178  ;}
6179  break;
6180 
6181  case 44:
6182 #line 1459 "ripper.y"
6183  {
6184  value_expr((yyvsp[(5) - (5)].val));
6185  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ID2VAL(idCOLON2), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val), (yylsp[(1) - (5)]).first_column);
6186  ;}
6187  break;
6188 
6189  case 45:
6190 #line 1464 "ripper.y"
6191  {
6192  (yyvsp[(1) - (3)].val) = var_field((yyvsp[(1) - (3)].val));
6193  (yyval.val) = backref_assign_error((yyvsp[(1) - (3)].val), node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column), (yylsp[(1) - (3)]).first_column);
6194  ;}
6195  break;
6196 
6197  case 46:
6198 #line 1471 "ripper.y"
6199  {
6200 #if 0
6201  value_expr((yyvsp[(1) - (1)].val));
6202  (yyval.val) = (yyvsp[(1) - (1)].val);
6203 #endif
6204 
6205  ;}
6206  break;
6207 
6208  case 47:
6209 #line 1479 "ripper.y"
6210  {
6211 #if 0
6212  value_expr((yyvsp[(1) - (3)].val));
6213  (yyval.val) = new_rescue((yyvsp[(1) - (3)].val), new_resbody(0, remove_begin((yyvsp[(3) - (3)].val)), 0, (yylsp[(1) - (3)]).first_column), 0, (yylsp[(1) - (3)]).first_column);
6214 #endif
6215  (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6216 
6217  ;}
6218  break;
6219 
6220  case 50:
6221 #line 1492 "ripper.y"
6222  {
6223  (yyval.val) = logop(idAND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
6224  ;}
6225  break;
6226 
6227  case 51:
6228 #line 1496 "ripper.y"
6229  {
6230  (yyval.val) = logop(idOR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
6231  ;}
6232  break;
6233 
6234  case 52:
6235 #line 1500 "ripper.y"
6236  {
6237  (yyval.val) = call_uni_op(method_cond((yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column), METHOD_NOT, (yylsp[(1) - (3)]).first_column);
6238  ;}
6239  break;
6240 
6241  case 53:
6242 #line 1504 "ripper.y"
6243  {
6244  (yyval.val) = call_uni_op(method_cond((yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column), '!', (yylsp[(1) - (2)]).first_column);
6245  ;}
6246  break;
6247 
6248  case 55:
6249 #line 1511 "ripper.y"
6250  {
6251 #if 0
6252  value_expr((yyvsp[(1) - (1)].val));
6253  (yyval.val) = (yyvsp[(1) - (1)].val);
6254  if (!(yyval.val)) (yyval.val) = NEW_NIL();
6255 #endif
6256  (yyval.val) = (yyvsp[(1) - (1)].val);
6257 
6258  ;}
6259  break;
6260 
6261  case 59:
6262 #line 1528 "ripper.y"
6263  {
6264  (yyval.val) = new_qcall((yyvsp[(2) - (4)].val), (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
6265  ;}
6266  break;
6267 
6268  case 60:
6269 #line 1534 "ripper.y"
6270  {
6271 #if 0
6272  (yyval.num) = ruby_sourceline;
6273 #endif
6274 
6275  ;}
6276  break;
6277 
6278  case 61:
6279 #line 1541 "ripper.y"
6280  {
6281  (yyval.val) = (yyvsp[(3) - (4)].val);
6282 #if 0
6283  nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
6284 #endif
6285  ;}
6286  break;
6287 
6288  case 62:
6289 #line 1550 "ripper.y"
6290  {
6291 #if 0
6292  (yyval.val) = new_fcall((yyvsp[(1) - (1)].val), 0, (yylsp[(1) - (1)]).first_column);
6293  nd_set_line((yyval.val), tokline);
6294 #endif
6295 
6296  ;}
6297  break;
6298 
6299  case 63:
6300 #line 1560 "ripper.y"
6301  {
6302 #if 0
6303  (yyval.val) = (yyvsp[(1) - (2)].val);
6304  (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
6305 #endif
6306  (yyval.val) = dispatch2(command, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
6307 
6308  ;}
6309  break;
6310 
6311  case 64:
6312 #line 1569 "ripper.y"
6313  {
6314  block_dup_check((yyvsp[(2) - (3)].val),(yyvsp[(3) - (3)].val));
6315  (yyval.val) = new_command((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6316  (yyval.val) = method_add_block((yyval.val), (yyvsp[(3) - (3)].val));
6317  fixpos((yyval.val), (yyvsp[(1) - (3)].val));
6318  ;}
6319  break;
6320 
6321  case 65:
6322 #line 1576 "ripper.y"
6323  {
6324  (yyval.val) = new_command_qcall((yyvsp[(2) - (4)].val), (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
6325  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
6326  ;}
6327  break;
6328 
6329  case 66:
6330 #line 1581 "ripper.y"
6331  {
6332  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
6333  (yyval.val) = new_command_qcall((yyvsp[(2) - (5)].val), (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yylsp[(1) - (5)]).first_column);
6334  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
6335  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6336  ;}
6337  break;
6338 
6339  case 67:
6340 #line 1588 "ripper.y"
6341  {
6342  (yyval.val) = new_command_qcall(ID2VAL(idCOLON2), (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
6343  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
6344  ;}
6345  break;
6346 
6347  case 68:
6348 #line 1593 "ripper.y"
6349  {
6350  block_dup_check((yyvsp[(4) - (5)].val),(yyvsp[(5) - (5)].val));
6351  (yyval.val) = new_command_qcall(ID2VAL(idCOLON2), (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yylsp[(1) - (5)]).first_column);
6352  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
6353  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
6354  ;}
6355  break;
6356 
6357  case 69:
6358 #line 1600 "ripper.y"
6359  {
6360 #if 0
6361  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
6362  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
6363  nd_set_column((yyval.val), (yylsp[(1) - (2)]).first_column);
6364 #endif
6365  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
6366 
6367  ;}
6368  break;
6369 
6370  case 70:
6371 #line 1610 "ripper.y"
6372  {
6373 #if 0
6374  (yyval.val) = new_yield((yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
6375  fixpos((yyval.val), (yyvsp[(2) - (2)].val));
6376 #endif
6377  (yyval.val) = dispatch1(yield, (yyvsp[(2) - (2)].val));
6378 
6379  ;}
6380  break;
6381 
6382  case 71:
6383 #line 1619 "ripper.y"
6384  {
6385 #if 0
6386  (yyval.val) = NEW_RETURN(ret_args((yyvsp[(2) - (2)].val)));
6387  nd_set_column((yyval.val), (yylsp[(1) - (2)]).first_column);
6388 #endif
6389  (yyval.val) = dispatch1(return, (yyvsp[(2) - (2)].val));
6390 
6391  ;}
6392  break;
6393 
6394  case 72:
6395 #line 1628 "ripper.y"
6396  {
6397 #if 0
6398  (yyval.val) = NEW_BREAK(ret_args((yyvsp[(2) - (2)].val)));
6399  nd_set_column((yyval.val), (yylsp[(1) - (2)]).first_column);
6400 #endif
6401  (yyval.val) = dispatch1(break, (yyvsp[(2) - (2)].val));
6402 
6403  ;}
6404  break;
6405 
6406  case 73:
6407 #line 1637 "ripper.y"
6408  {
6409 #if 0
6410  (yyval.val) = NEW_NEXT(ret_args((yyvsp[(2) - (2)].val)));
6411  nd_set_column((yyval.val), (yylsp[(1) - (2)]).first_column);
6412 #endif
6413  (yyval.val) = dispatch1(next, (yyvsp[(2) - (2)].val));
6414 
6415  ;}
6416  break;
6417 
6418  case 75:
6419 #line 1649 "ripper.y"
6420  {
6421 #if 0
6422  (yyval.val) = (yyvsp[(2) - (3)].val);
6423 #endif
6424  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6425 
6426  ;}
6427  break;
6428 
6429  case 77:
6430 #line 1660 "ripper.y"
6431  {
6432 #if 0
6433  (yyval.val) = new_masgn(new_list((yyvsp[(2) - (3)].val), (yylsp[(1) - (3)]).first_column), 0, (yylsp[(1) - (3)]).first_column);
6434 #endif
6435  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6436 
6437  ;}
6438  break;
6439 
6440  case 78:
6441 #line 1670 "ripper.y"
6442  {
6443 #if 0
6444  (yyval.val) = new_masgn((yyvsp[(1) - (1)].val), 0, (yylsp[(1) - (1)]).first_column);
6445 #endif
6446  (yyval.val) = (yyvsp[(1) - (1)].val);
6447 
6448  ;}
6449  break;
6450 
6451  case 79:
6452 #line 1678 "ripper.y"
6453  {
6454 #if 0
6455  (yyval.val) = new_masgn(list_append((yyvsp[(1) - (2)].val),(yyvsp[(2) - (2)].val),(yylsp[(1) - (2)]).first_column), 0, (yylsp[(1) - (2)]).first_column);
6456 #endif
6457  (yyval.val) = mlhs_add((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
6458 
6459  ;}
6460  break;
6461 
6462  case 80:
6463 #line 1686 "ripper.y"
6464  {
6465 #if 0
6466  (yyval.val) = new_masgn((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
6467 #endif
6468  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6469 
6470  ;}
6471  break;
6472 
6473  case 81:
6474 #line 1694 "ripper.y"
6475  {
6476 #if 0
6477  (yyval.val) = new_masgn((yyvsp[(1) - (5)].val), new_postarg((yyvsp[(3) - (5)].val),(yyvsp[(5) - (5)].val),(yylsp[(1) - (5)]).first_column), (yylsp[(1) - (5)]).first_column);
6478 #endif
6479  (yyvsp[(1) - (5)].val) = mlhs_add_star((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val));
6480  (yyval.val) = mlhs_add_post((yyvsp[(1) - (5)].val), (yyvsp[(5) - (5)].val));
6481 
6482  ;}
6483  break;
6484 
6485  case 82:
6486 #line 1703 "ripper.y"
6487  {
6488 #if 0
6489  (yyval.val) = new_masgn((yyvsp[(1) - (2)].val), (NODE *)-1, (yylsp[(1) - (2)]).first_column);
6490 #endif
6491  (yyval.val) = mlhs_add_star((yyvsp[(1) - (2)].val), Qnil);
6492 
6493  ;}
6494  break;
6495 
6496  case 83:
6497 #line 1711 "ripper.y"
6498  {
6499 #if 0
6500  (yyval.val) = new_masgn((yyvsp[(1) - (4)].val), new_postarg((NODE *)-1, (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column), (yylsp[(1) - (4)]).first_column);
6501 #endif
6502  (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
6503  (yyval.val) = mlhs_add_post((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
6504 
6505  ;}
6506  break;
6507 
6508  case 84:
6509 #line 1720 "ripper.y"
6510  {
6511 #if 0
6512  (yyval.val) = new_masgn(0, (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
6513 #endif
6514  (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (2)].val));
6515 
6516  ;}
6517  break;
6518 
6519  case 85:
6520 #line 1728 "ripper.y"
6521  {
6522 #if 0
6523  (yyval.val) = new_masgn(0, new_postarg((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val),(yylsp[(1) - (4)]).first_column), (yylsp[(1) - (4)]).first_column);
6524 #endif
6525  (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
6526  (yyval.val) = mlhs_add_post((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
6527 
6528  ;}
6529  break;
6530 
6531  case 86:
6532 #line 1737 "ripper.y"
6533  {
6534 #if 0
6535  (yyval.val) = new_masgn(0, (NODE *)-1, (yylsp[(1) - (1)]).first_column);
6536 #endif
6537  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6538 
6539  ;}
6540  break;
6541 
6542  case 87:
6543 #line 1745 "ripper.y"
6544  {
6545 #if 0
6546  (yyval.val) = new_masgn(0, new_postarg((NODE *)-1, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column), (yylsp[(1) - (3)]).first_column);
6547 #endif
6548  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
6549  (yyval.val) = mlhs_add_post((yyval.val), (yyvsp[(3) - (3)].val));
6550 
6551  ;}
6552  break;
6553 
6554  case 89:
6555 #line 1757 "ripper.y"
6556  {
6557 #if 0
6558  (yyval.val) = (yyvsp[(2) - (3)].val);
6559 #endif
6560  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
6561 
6562  ;}
6563  break;
6564 
6565  case 90:
6566 #line 1767 "ripper.y"
6567  {
6568 #if 0
6569  (yyval.val) = new_list((yyvsp[(1) - (2)].val), (yylsp[(1) - (2)]).first_column);
6570 #endif
6571  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (2)].val));
6572 
6573  ;}
6574  break;
6575 
6576  case 91:
6577 #line 1775 "ripper.y"
6578  {
6579 #if 0
6580  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yylsp[(1) - (3)]).first_column);
6581 #endif
6582  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6583 
6584  ;}
6585  break;
6586 
6587  case 92:
6588 #line 1785 "ripper.y"
6589  {
6590 #if 0
6591  (yyval.val) = new_list((yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column);
6592 #endif
6593  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
6594 
6595  ;}
6596  break;
6597 
6598  case 93:
6599 #line 1793 "ripper.y"
6600  {
6601 #if 0
6602  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
6603 #endif
6604  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6605 
6606  ;}
6607  break;
6608 
6609  case 94:
6610 #line 1803 "ripper.y"
6611  {
6612  (yyval.val) = assignable(var_field((yyvsp[(1) - (1)].val)), 0, (yylsp[(1) - (1)]).first_column);
6613  ;}
6614  break;
6615 
6616  case 95:
6617 #line 1807 "ripper.y"
6618  {
6619  (yyval.val) = assignable(var_field((yyvsp[(1) - (1)].val)), 0, (yylsp[(1) - (1)]).first_column);
6620  ;}
6621  break;
6622 
6623  case 96:
6624 #line 1811 "ripper.y"
6625  {
6626 #if 0
6627  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yylsp[(1) - (4)]).first_column);
6628 #endif
6629  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6630 
6631  ;}
6632  break;
6633 
6634  case 97:
6635 #line 1819 "ripper.y"
6636  {
6637 #if 0
6638  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
6639 #endif
6640  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
6641 
6642  ;}
6643  break;
6644 
6645  case 98:
6646 #line 1827 "ripper.y"
6647  {
6648 #if 0
6649  (yyval.val) = attrset((yyvsp[(1) - (3)].val), idCOLON2, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
6650 #endif
6651  (yyval.val) = dispatch2(const_path_field, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6652 
6653  ;}
6654  break;
6655 
6656  case 99:
6657 #line 1835 "ripper.y"
6658  {
6659 #if 0
6660  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
6661 #endif
6662  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
6663 
6664  ;}
6665  break;
6666 
6667  case 100:
6668 #line 1843 "ripper.y"
6669  {
6670  (yyval.val) = const_decl(const_path_field((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column), (yylsp[(1) - (3)]).first_column);
6671  ;}
6672  break;
6673 
6674  case 101:
6675 #line 1847 "ripper.y"
6676  {
6677  (yyval.val) = const_decl(top_const_field((yyvsp[(2) - (2)].val)), (yylsp[(1) - (2)]).first_column);
6678  ;}
6679  break;
6680 
6681  case 102:
6682 #line 1851 "ripper.y"
6683  {
6684  (yyvsp[(1) - (1)].val) = var_field((yyvsp[(1) - (1)].val));
6685  (yyval.val) = backref_assign_error((yyvsp[(1) - (1)].val), (yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column);
6686  ;}
6687  break;
6688 
6689  case 103:
6690 #line 1858 "ripper.y"
6691  {
6692  (yyval.val) = assignable(var_field((yyvsp[(1) - (1)].val)), 0, (yylsp[(1) - (1)]).first_column);
6693 #if 0
6694  if (!(yyval.val)) (yyval.val) = new_begin(0, (yylsp[(1) - (1)]).first_column);
6695 #endif
6696 
6697  ;}
6698  break;
6699 
6700  case 104:
6701 #line 1866 "ripper.y"
6702  {
6703  (yyval.val) = assignable(var_field((yyvsp[(1) - (1)].val)), 0, (yylsp[(1) - (1)]).first_column);
6704 #if 0
6705  if (!(yyval.val)) (yyval.val) = new_begin(0, (yylsp[(1) - (1)]).first_column);
6706 #endif
6707 
6708  ;}
6709  break;
6710 
6711  case 105:
6712 #line 1874 "ripper.y"
6713  {
6714 #if 0
6715  (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yylsp[(1) - (4)]).first_column);
6716 #endif
6717  (yyval.val) = dispatch2(aref_field, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
6718 
6719  ;}
6720  break;
6721 
6722  case 106:
6723 #line 1882 "ripper.y"
6724  {
6725 #if 0
6726  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
6727 #endif
6728  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
6729 
6730  ;}
6731  break;
6732 
6733  case 107:
6734 #line 1890 "ripper.y"
6735  {
6736 #if 0
6737  (yyval.val) = attrset((yyvsp[(1) - (3)].val), idCOLON2, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
6738 #endif
6739  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), ID2VAL(idCOLON2), (yyvsp[(3) - (3)].val));
6740 
6741  ;}
6742  break;
6743 
6744  case 108:
6745 #line 1898 "ripper.y"
6746  {
6747 #if 0
6748  (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
6749 #endif
6750  (yyval.val) = dispatch3(field, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val));
6751 
6752  ;}
6753  break;
6754 
6755  case 109:
6756 #line 1906 "ripper.y"
6757  {
6758  (yyval.val) = const_decl(const_path_field((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column), (yylsp[(1) - (3)]).first_column);
6759  ;}
6760  break;
6761 
6762  case 110:
6763 #line 1910 "ripper.y"
6764  {
6765  (yyval.val) = const_decl(top_const_field((yyvsp[(2) - (2)].val)), (yylsp[(1) - (2)]).first_column);
6766  ;}
6767  break;
6768 
6769  case 111:
6770 #line 1914 "ripper.y"
6771  {
6772  (yyvsp[(1) - (1)].val) = var_field((yyvsp[(1) - (1)].val));
6773  (yyval.val) = backref_assign_error((yyvsp[(1) - (1)].val), (yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column);
6774  ;}
6775  break;
6776 
6777  case 112:
6778 #line 1921 "ripper.y"
6779  {
6780 #if 0
6781  yyerror0("class/module name must be CONSTANT");
6782 #endif
6783  (yyval.val) = dispatch1(class_name_error, (yyvsp[(1) - (1)].val));
6784  ripper_error();
6785 
6786  ;}
6787  break;
6788 
6789  case 114:
6790 #line 1933 "ripper.y"
6791  {
6792 #if 0
6793  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
6794 #endif
6795  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
6796 
6797  ;}
6798  break;
6799 
6800  case 115:
6801 #line 1941 "ripper.y"
6802  {
6803 #if 0
6804  (yyval.val) = NEW_COLON2(0, (yyval.val));
6805  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
6806 #endif
6807  (yyval.val) = dispatch1(const_ref, (yyvsp[(1) - (1)].val));
6808 
6809  ;}
6810  break;
6811 
6812  case 116:
6813 #line 1950 "ripper.y"
6814  {
6815 #if 0
6816  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6817  nd_set_column((yyval.val), (yylsp[(1) - (3)]).first_column);
6818 #endif
6819  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6820 
6821  ;}
6822  break;
6823 
6824  case 120:
6825 #line 1964 "ripper.y"
6826  {
6827  SET_LEX_STATE(EXPR_ENDFN);
6828  (yyval.val) = (yyvsp[(1) - (1)].val);
6829  ;}
6830  break;
6831 
6832  case 121:
6833 #line 1969 "ripper.y"
6834  {
6835  SET_LEX_STATE(EXPR_ENDFN);
6836  (yyval.val) = (yyvsp[(1) - (1)].val);
6837  ;}
6838  break;
6839 
6840  case 124:
6841 #line 1980 "ripper.y"
6842  {
6843 #if 0
6844  (yyval.val) = new_lit(ID2SYM((yyvsp[(1) - (1)].val)), (yylsp[(1) - (1)]).first_column);
6845 #endif
6846  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
6847 
6848  ;}
6849  break;
6850 
6851  case 126:
6852 #line 1991 "ripper.y"
6853  {
6854 #if 0
6855  (yyval.val) = new_undef((yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column);
6856 #endif
6857  (yyval.val) = rb_ary_new3(1, get_value((yyvsp[(1) - (1)].val)));
6858 
6859  ;}
6860  break;
6861 
6862  case 127:
6863 #line 1998 "ripper.y"
6864  {SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);;}
6865  break;
6866 
6867  case 128:
6868 #line 1999 "ripper.y"
6869  {
6870 #if 0
6871  NODE *undef = new_undef((yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
6872  (yyval.val) = block_append((yyvsp[(1) - (4)].val), undef, (yylsp[(1) - (4)]).first_column);
6873 #endif
6874  rb_ary_push((yyvsp[(1) - (4)].val), get_value((yyvsp[(4) - (4)].val)));
6875 
6876  ;}
6877  break;
6878 
6879  case 129:
6880 #line 2009 "ripper.y"
6881  { ifndef_ripper((yyval.val) = '|'); ;}
6882  break;
6883 
6884  case 130:
6885 #line 2010 "ripper.y"
6886  { ifndef_ripper((yyval.val) = '^'); ;}
6887  break;
6888 
6889  case 131:
6890 #line 2011 "ripper.y"
6891  { ifndef_ripper((yyval.val) = '&'); ;}
6892  break;
6893 
6894  case 132:
6895 #line 2012 "ripper.y"
6896  { ifndef_ripper((yyval.val) = tCMP); ;}
6897  break;
6898 
6899  case 133:
6900 #line 2013 "ripper.y"
6901  { ifndef_ripper((yyval.val) = tEQ); ;}
6902  break;
6903 
6904  case 134:
6905 #line 2014 "ripper.y"
6906  { ifndef_ripper((yyval.val) = tEQQ); ;}
6907  break;
6908 
6909  case 135:
6910 #line 2015 "ripper.y"
6911  { ifndef_ripper((yyval.val) = tMATCH); ;}
6912  break;
6913 
6914  case 136:
6915 #line 2016 "ripper.y"
6916  { ifndef_ripper((yyval.val) = tNMATCH); ;}
6917  break;
6918 
6919  case 137:
6920 #line 2017 "ripper.y"
6921  { ifndef_ripper((yyval.val) = '>'); ;}
6922  break;
6923 
6924  case 138:
6925 #line 2018 "ripper.y"
6926  { ifndef_ripper((yyval.val) = tGEQ); ;}
6927  break;
6928 
6929  case 139:
6930 #line 2019 "ripper.y"
6931  { ifndef_ripper((yyval.val) = '<'); ;}
6932  break;
6933 
6934  case 140:
6935 #line 2020 "ripper.y"
6936  { ifndef_ripper((yyval.val) = tLEQ); ;}
6937  break;
6938 
6939  case 141:
6940 #line 2021 "ripper.y"
6941  { ifndef_ripper((yyval.val) = tNEQ); ;}
6942  break;
6943 
6944  case 142:
6945 #line 2022 "ripper.y"
6946  { ifndef_ripper((yyval.val) = tLSHFT); ;}
6947  break;
6948 
6949  case 143:
6950 #line 2023 "ripper.y"
6951  { ifndef_ripper((yyval.val) = tRSHFT); ;}
6952  break;
6953 
6954  case 144:
6955 #line 2024 "ripper.y"
6956  { ifndef_ripper((yyval.val) = '+'); ;}
6957  break;
6958 
6959  case 145:
6960 #line 2025 "ripper.y"
6961  { ifndef_ripper((yyval.val) = '-'); ;}
6962  break;
6963 
6964  case 146:
6965 #line 2026 "ripper.y"
6966  { ifndef_ripper((yyval.val) = '*'); ;}
6967  break;
6968 
6969  case 147:
6970 #line 2027 "ripper.y"
6971  { ifndef_ripper((yyval.val) = '*'); ;}
6972  break;
6973 
6974  case 148:
6975 #line 2028 "ripper.y"
6976  { ifndef_ripper((yyval.val) = '/'); ;}
6977  break;
6978 
6979  case 149:
6980 #line 2029 "ripper.y"
6981  { ifndef_ripper((yyval.val) = '%'); ;}
6982  break;
6983 
6984  case 150:
6985 #line 2030 "ripper.y"
6986  { ifndef_ripper((yyval.val) = tPOW); ;}
6987  break;
6988 
6989  case 151:
6990 #line 2031 "ripper.y"
6991  { ifndef_ripper((yyval.val) = tDSTAR); ;}
6992  break;
6993 
6994  case 152:
6995 #line 2032 "ripper.y"
6996  { ifndef_ripper((yyval.val) = '!'); ;}
6997  break;
6998 
6999  case 153:
7000 #line 2033 "ripper.y"
7001  { ifndef_ripper((yyval.val) = '~'); ;}
7002  break;
7003 
7004  case 154:
7005 #line 2034 "ripper.y"
7006  { ifndef_ripper((yyval.val) = tUPLUS); ;}
7007  break;
7008 
7009  case 155:
7010 #line 2035 "ripper.y"
7011  { ifndef_ripper((yyval.val) = tUMINUS); ;}
7012  break;
7013 
7014  case 156:
7015 #line 2036 "ripper.y"
7016  { ifndef_ripper((yyval.val) = tAREF); ;}
7017  break;
7018 
7019  case 157:
7020 #line 2037 "ripper.y"
7021  { ifndef_ripper((yyval.val) = tASET); ;}
7022  break;
7023 
7024  case 158:
7025 #line 2038 "ripper.y"
7026  { ifndef_ripper((yyval.val) = '`'); ;}
7027  break;
7028 
7029  case 200:
7030 #line 2056 "ripper.y"
7031  {
7032  (yyval.val) = node_assign((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7033  ;}
7034  break;
7035 
7036  case 201:
7037 #line 2060 "ripper.y"
7038  {
7039  (yyval.val) = new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7040  ;}
7041  break;
7042 
7043  case 202:
7044 #line 2064 "ripper.y"
7045  {
7046 #if 0
7047  NODE *args;
7048 
7049  value_expr((yyvsp[(6) - (6)].val));
7050  if (!(yyvsp[(3) - (6)].val)) (yyvsp[(3) - (6)].val) = new_zarray((yylsp[(1) - (6)]).first_column);
7051  if (nd_type((yyvsp[(3) - (6)].val)) == NODE_BLOCK_PASS) {
7052  args = NEW_ARGSCAT((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7053  nd_set_column(args, (yylsp[(1) - (6)]).first_column);
7054  }
7055  else {
7056  args = arg_concat((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val), (yylsp[(1) - (6)]).first_column);
7057  }
7058  if ((yyvsp[(5) - (6)].val) == tOROP) {
7059  (yyvsp[(5) - (6)].val) = 0;
7060  }
7061  else if ((yyvsp[(5) - (6)].val) == tANDOP) {
7062  (yyvsp[(5) - (6)].val) = 1;
7063  }
7064  (yyval.val) = NEW_OP_ASGN1((yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), args);
7065  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
7066  nd_set_column((yyval.val), (yylsp[(1) - (6)]).first_column);
7067 #endif
7068  (yyvsp[(1) - (6)].val) = dispatch2(aref_field, (yyvsp[(1) - (6)].val), escape_Qundef((yyvsp[(3) - (6)].val)));
7069  (yyval.val) = dispatch3(opassign, (yyvsp[(1) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
7070 
7071  ;}
7072  break;
7073 
7074  case 203:
7075 #line 2092 "ripper.y"
7076  {
7077  value_expr((yyvsp[(5) - (5)].val));
7078  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val), (yylsp[(1) - (5)]).first_column);
7079  ;}
7080  break;
7081 
7082  case 204:
7083 #line 2097 "ripper.y"
7084  {
7085  value_expr((yyvsp[(5) - (5)].val));
7086  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val), (yylsp[(1) - (5)]).first_column);
7087  ;}
7088  break;
7089 
7090  case 205:
7091 #line 2102 "ripper.y"
7092  {
7093  value_expr((yyvsp[(5) - (5)].val));
7094  (yyval.val) = new_attr_op_assign((yyvsp[(1) - (5)].val), ID2VAL(idCOLON2), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val), (yylsp[(1) - (5)]).first_column);
7095  ;}
7096  break;
7097 
7098  case 206:
7099 #line 2107 "ripper.y"
7100  {
7101  (yyval.val) = const_path_field((yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yylsp[(1) - (5)]).first_column);
7102  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val), (yylsp[(1) - (5)]).first_column);
7103  ;}
7104  break;
7105 
7106  case 207:
7107 #line 2112 "ripper.y"
7108  {
7109  (yyval.val) = top_const_field((yyvsp[(2) - (4)].val));
7110  (yyval.val) = new_const_op_assign((yyval.val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
7111  ;}
7112  break;
7113 
7114  case 208:
7115 #line 2117 "ripper.y"
7116  {
7117  (yyvsp[(1) - (3)].val) = var_field((yyvsp[(1) - (3)].val));
7118  (yyval.val) = backref_assign_error((yyvsp[(1) - (3)].val), new_op_assign((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column), (yylsp[(1) - (3)]).first_column);
7119  ;}
7120  break;
7121 
7122  case 209:
7123 #line 2122 "ripper.y"
7124  {
7125 #if 0
7126  value_expr((yyvsp[(1) - (3)].val));
7127  value_expr((yyvsp[(3) - (3)].val));
7128  (yyval.val) = NEW_DOT2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7129  nd_set_column((yyval.val), (yylsp[(1) - (3)]).first_column);
7130 #endif
7131  (yyval.val) = dispatch2(dot2, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7132 
7133  ;}
7134  break;
7135 
7136  case 210:
7137 #line 2133 "ripper.y"
7138  {
7139 #if 0
7140  value_expr((yyvsp[(1) - (3)].val));
7141  value_expr((yyvsp[(3) - (3)].val));
7142  (yyval.val) = NEW_DOT3((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7143  nd_set_column((yyval.val), (yylsp[(1) - (3)]).first_column);
7144 #endif
7145  (yyval.val) = dispatch2(dot3, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7146 
7147  ;}
7148  break;
7149 
7150  case 211:
7151 #line 2144 "ripper.y"
7152  {
7153  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7154  ;}
7155  break;
7156 
7157  case 212:
7158 #line 2148 "ripper.y"
7159  {
7160  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7161  ;}
7162  break;
7163 
7164  case 213:
7165 #line 2152 "ripper.y"
7166  {
7167  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7168  ;}
7169  break;
7170 
7171  case 214:
7172 #line 2156 "ripper.y"
7173  {
7174  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7175  ;}
7176  break;
7177 
7178  case 215:
7179 #line 2160 "ripper.y"
7180  {
7181  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7182  ;}
7183  break;
7184 
7185  case 216:
7186 #line 2164 "ripper.y"
7187  {
7188  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), idPow, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7189  ;}
7190  break;
7191 
7192  case 217:
7193 #line 2168 "ripper.y"
7194  {
7195  (yyval.val) = call_uni_op(call_bin_op((yyvsp[(2) - (4)].val), idPow, (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column), idUMinus, (yylsp[(1) - (4)]).first_column);
7196  ;}
7197  break;
7198 
7199  case 218:
7200 #line 2172 "ripper.y"
7201  {
7202  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), idUPlus, (yylsp[(1) - (2)]).first_column);
7203  ;}
7204  break;
7205 
7206  case 219:
7207 #line 2176 "ripper.y"
7208  {
7209  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), idUMinus, (yylsp[(1) - (2)]).first_column);
7210  ;}
7211  break;
7212 
7213  case 220:
7214 #line 2180 "ripper.y"
7215  {
7216  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7217  ;}
7218  break;
7219 
7220  case 221:
7221 #line 2184 "ripper.y"
7222  {
7223  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7224  ;}
7225  break;
7226 
7227  case 222:
7228 #line 2188 "ripper.y"
7229  {
7230  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7231  ;}
7232  break;
7233 
7234  case 223:
7235 #line 2192 "ripper.y"
7236  {
7237  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), idCmp, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7238  ;}
7239  break;
7240 
7241  case 225:
7242 #line 2197 "ripper.y"
7243  {
7244  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), idEq, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7245  ;}
7246  break;
7247 
7248  case 226:
7249 #line 2201 "ripper.y"
7250  {
7251  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), idEqq, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7252  ;}
7253  break;
7254 
7255  case 227:
7256 #line 2205 "ripper.y"
7257  {
7258  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), idNeq, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7259  ;}
7260  break;
7261 
7262  case 228:
7263 #line 2209 "ripper.y"
7264  {
7265  (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7266  ;}
7267  break;
7268 
7269  case 229:
7270 #line 2213 "ripper.y"
7271  {
7272  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), idNeqTilde, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7273  ;}
7274  break;
7275 
7276  case 230:
7277 #line 2217 "ripper.y"
7278  {
7279  (yyval.val) = call_uni_op(method_cond((yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column), '!', (yylsp[(1) - (2)]).first_column);
7280  ;}
7281  break;
7282 
7283  case 231:
7284 #line 2221 "ripper.y"
7285  {
7286  (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~', (yylsp[(1) - (2)]).first_column);
7287  ;}
7288  break;
7289 
7290  case 232:
7291 #line 2225 "ripper.y"
7292  {
7293  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), idLTLT, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7294  ;}
7295  break;
7296 
7297  case 233:
7298 #line 2229 "ripper.y"
7299  {
7300  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), idGTGT, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7301  ;}
7302  break;
7303 
7304  case 234:
7305 #line 2233 "ripper.y"
7306  {
7307  (yyval.val) = logop(idANDOP, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7308  ;}
7309  break;
7310 
7311  case 235:
7312 #line 2237 "ripper.y"
7313  {
7314  (yyval.val) = logop(idOROP, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7315  ;}
7316  break;
7317 
7318  case 236:
7319 #line 2240 "ripper.y"
7320  {in_defined = 1;;}
7321  break;
7322 
7323  case 237:
7324 #line 2241 "ripper.y"
7325  {
7326  in_defined = 0;
7327  (yyval.val) = new_defined((yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
7328  ;}
7329  break;
7330 
7331  case 238:
7332 #line 2246 "ripper.y"
7333  {
7334 #if 0
7335  value_expr((yyvsp[(1) - (6)].val));
7336  (yyval.val) = new_if((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val), (yylsp[(1) - (6)]).first_column);
7337  fixpos((yyval.val), (yyvsp[(1) - (6)].val));
7338 #endif
7339  (yyval.val) = dispatch3(ifop, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
7340 
7341  ;}
7342  break;
7343 
7344  case 239:
7345 #line 2256 "ripper.y"
7346  {
7347  (yyval.val) = (yyvsp[(1) - (1)].val);
7348  ;}
7349  break;
7350 
7351  case 240:
7352 #line 2261 "ripper.y"
7353  {(yyval.val) = '>';;}
7354  break;
7355 
7356  case 241:
7357 #line 2262 "ripper.y"
7358  {(yyval.val) = '<';;}
7359  break;
7360 
7361  case 242:
7362 #line 2263 "ripper.y"
7363  {(yyval.val) = idGE;;}
7364  break;
7365 
7366  case 243:
7367 #line 2264 "ripper.y"
7368  {(yyval.val) = idLE;;}
7369  break;
7370 
7371  case 244:
7372 #line 2268 "ripper.y"
7373  {
7374  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7375  ;}
7376  break;
7377 
7378  case 245:
7379 #line 2272 "ripper.y"
7380  {
7381  rb_warning1("comparison '%s' after comparison", WARN_ID((yyvsp[(2) - (3)].val)));
7382  (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7383  ;}
7384  break;
7385 
7386  case 246:
7387 #line 2279 "ripper.y"
7388  {
7389 #if 0
7390  value_expr((yyvsp[(1) - (1)].val));
7391  (yyval.val) = (yyvsp[(1) - (1)].val);
7392  if (!(yyval.val)) (yyval.val) = NEW_NIL();
7393 #endif
7394  (yyval.val) = (yyvsp[(1) - (1)].val);
7395 
7396  ;}
7397  break;
7398 
7399  case 248:
7400 #line 2292 "ripper.y"
7401  {
7402  (yyval.val) = (yyvsp[(1) - (2)].val);
7403  ;}
7404  break;
7405 
7406  case 249:
7407 #line 2296 "ripper.y"
7408  {
7409 #if 0
7410  (yyval.val) = (yyvsp[(3) - (4)].val) ? arg_append((yyvsp[(1) - (4)].val), new_hash((yyvsp[(3) - (4)].val), (yylsp[(1) - (4)]).first_column), (yylsp[(1) - (4)]).first_column) : (yyvsp[(1) - (4)].val);
7411 #endif
7412  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7413 
7414  ;}
7415  break;
7416 
7417  case 250:
7418 #line 2304 "ripper.y"
7419  {
7420 #if 0
7421  (yyval.val) = (yyvsp[(1) - (2)].val) ? new_list(new_hash((yyvsp[(1) - (2)].val), (yylsp[(1) - (2)]).first_column), (yylsp[(1) - (2)]).first_column) : 0;
7422 #endif
7423  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7424 
7425  ;}
7426  break;
7427 
7428  case 251:
7429 #line 2314 "ripper.y"
7430  {
7431 #if 0
7432  value_expr((yyvsp[(1) - (1)].val));
7433  (yyval.val) = (yyvsp[(1) - (1)].val);
7434 #endif
7435 
7436  ;}
7437  break;
7438 
7439  case 252:
7440 #line 2322 "ripper.y"
7441  {
7442 #if 0
7443  value_expr((yyvsp[(1) - (3)].val));
7444  (yyval.val) = new_rescue((yyvsp[(1) - (3)].val), new_resbody(0, remove_begin((yyvsp[(3) - (3)].val)), 0, (yylsp[(1) - (3)]).first_column), 0, (yylsp[(1) - (3)]).first_column);
7445 #endif
7446  (yyval.val) = dispatch2(rescue_mod, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7447 
7448  ;}
7449  break;
7450 
7451  case 253:
7452 #line 2333 "ripper.y"
7453  {
7454 #if 0
7455  (yyval.val) = (yyvsp[(2) - (3)].val);
7456 #endif
7457  (yyval.val) = dispatch1(arg_paren, escape_Qundef((yyvsp[(2) - (3)].val)));
7458 
7459  ;}
7460  break;
7461 
7462  case 258:
7463 #line 2349 "ripper.y"
7464  {
7465  (yyval.val) = (yyvsp[(1) - (2)].val);
7466  ;}
7467  break;
7468 
7469  case 259:
7470 #line 2353 "ripper.y"
7471  {
7472 #if 0
7473  (yyval.val) = (yyvsp[(3) - (4)].val) ? arg_append((yyvsp[(1) - (4)].val), new_hash((yyvsp[(3) - (4)].val), (yylsp[(1) - (4)]).first_column), (yylsp[(1) - (4)]).first_column) : (yyvsp[(1) - (4)].val);
7474 #endif
7475  (yyval.val) = arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
7476 
7477  ;}
7478  break;
7479 
7480  case 260:
7481 #line 2361 "ripper.y"
7482  {
7483 #if 0
7484  (yyval.val) = (yyvsp[(1) - (2)].val) ? new_list(new_hash((yyvsp[(1) - (2)].val), (yylsp[(1) - (2)]).first_column), (yylsp[(1) - (2)]).first_column) : 0;
7485 #endif
7486  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7487 
7488  ;}
7489  break;
7490 
7491  case 261:
7492 #line 2371 "ripper.y"
7493  {
7494 #if 0
7495  value_expr((yyvsp[(1) - (1)].val));
7496  (yyval.val) = new_list((yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column);
7497 #endif
7498  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7499 
7500  ;}
7501  break;
7502 
7503  case 262:
7504 #line 2380 "ripper.y"
7505  {
7506 #if 0
7507  (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7508 #endif
7509  (yyval.val) = arg_add_optblock((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7510 
7511  ;}
7512  break;
7513 
7514  case 263:
7515 #line 2388 "ripper.y"
7516  {
7517 #if 0
7518  (yyval.val) = (yyvsp[(1) - (2)].val) ? new_list(new_hash((yyvsp[(1) - (2)].val), (yylsp[(1) - (2)]).first_column), (yylsp[(1) - (2)]).first_column) : 0;
7519  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(2) - (2)].val));
7520 #endif
7521  (yyval.val) = arg_add_assocs(arg_new(), (yyvsp[(1) - (2)].val));
7522  (yyval.val) = arg_add_optblock((yyval.val), (yyvsp[(2) - (2)].val));
7523 
7524  ;}
7525  break;
7526 
7527  case 264:
7528 #line 2398 "ripper.y"
7529  {
7530 #if 0
7531  (yyval.val) = (yyvsp[(3) - (4)].val) ? arg_append((yyvsp[(1) - (4)].val), new_hash((yyvsp[(3) - (4)].val), (yylsp[(1) - (4)]).first_column), (yylsp[(1) - (4)]).first_column) : (yyvsp[(1) - (4)].val);
7532  (yyval.val) = arg_blk_pass((yyval.val), (yyvsp[(4) - (4)].val));
7533 #endif
7534  (yyval.val) = arg_add_optblock(arg_add_assocs((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val)), (yyvsp[(4) - (4)].val));
7535 
7536  ;}
7537  break;
7538 
7539  case 265:
7540 #line 2409 "ripper.y"
7541  {
7542  (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
7543  ;}
7544  break;
7545 
7546  case 266:
7547 #line 2415 "ripper.y"
7548  {
7549  (yyval.val) = cmdarg_stack;
7550  CMDARG_PUSH(1);
7551  ;}
7552  break;
7553 
7554  case 267:
7555 #line 2420 "ripper.y"
7556  {
7557  /* CMDARG_POP() */
7558  CMDARG_SET((yyvsp[(1) - (2)].val));
7559  (yyval.val) = (yyvsp[(2) - (2)].val);
7560  ;}
7561  break;
7562 
7563  case 268:
7564 #line 2428 "ripper.y"
7565  {
7566 #if 0
7567  (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
7568  nd_set_column((yyval.val), (yylsp[(1) - (2)]).first_column);
7569 #endif
7570  (yyval.val) = (yyvsp[(2) - (2)].val);
7571 
7572  ;}
7573  break;
7574 
7575  case 269:
7576 #line 2439 "ripper.y"
7577  {
7578  (yyval.val) = (yyvsp[(2) - (2)].val);
7579  ;}
7580  break;
7581 
7582  case 270:
7583 #line 2443 "ripper.y"
7584  {
7585  (yyval.val) = 0;
7586  ;}
7587  break;
7588 
7589  case 271:
7590 #line 2449 "ripper.y"
7591  {
7592 #if 0
7593  (yyval.val) = new_list((yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column);
7594 #endif
7595  (yyval.val) = arg_add(arg_new(), (yyvsp[(1) - (1)].val));
7596 
7597  ;}
7598  break;
7599 
7600  case 272:
7601 #line 2457 "ripper.y"
7602  {
7603 #if 0
7604  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7605  nd_set_column((yyval.val), (yylsp[(1) - (2)]).first_column);
7606 #endif
7607  (yyval.val) = arg_add_star(arg_new(), (yyvsp[(2) - (2)].val));
7608 
7609  ;}
7610  break;
7611 
7612  case 273:
7613 #line 2466 "ripper.y"
7614  {
7615 #if 0
7616  NODE *n1;
7617  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7618  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7619  }
7620  else {
7621  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7622  }
7623 #endif
7624  (yyval.val) = arg_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7625 
7626  ;}
7627  break;
7628 
7629  case 274:
7630 #line 2480 "ripper.y"
7631  {
7632 #if 0
7633  NODE *n1;
7634  if ((nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY) && (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7635  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7636  }
7637  else {
7638  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
7639  }
7640 #endif
7641  (yyval.val) = arg_add_star((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
7642 
7643  ;}
7644  break;
7645 
7646  case 277:
7647 #line 2500 "ripper.y"
7648  {
7649 #if 0
7650  NODE *n1;
7651  if ((n1 = splat_array((yyvsp[(1) - (3)].val))) != 0) {
7652  (yyval.val) = list_append(n1, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7653  }
7654  else {
7655  (yyval.val) = arg_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
7656  }
7657 #endif
7658  (yyval.val) = mrhs_add(args2mrhs((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
7659 
7660  ;}
7661  break;
7662 
7663  case 278:
7664 #line 2514 "ripper.y"
7665  {
7666 #if 0
7667  NODE *n1;
7668  if (nd_type((yyvsp[(4) - (4)].val)) == NODE_ARRAY &&
7669  (n1 = splat_array((yyvsp[(1) - (4)].val))) != 0) {
7670  (yyval.val) = list_concat(n1, (yyvsp[(4) - (4)].val));
7671  }
7672  else {
7673  (yyval.val) = arg_concat((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
7674  }
7675 #endif
7676  (yyval.val) = mrhs_add_star(args2mrhs((yyvsp[(1) - (4)].val)), (yyvsp[(4) - (4)].val));
7677 
7678  ;}
7679  break;
7680 
7681  case 279:
7682 #line 2529 "ripper.y"
7683  {
7684 #if 0
7685  (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7686  nd_set_column((yyval.val), (yylsp[(1) - (2)]).first_column);
7687 #endif
7688  (yyval.val) = mrhs_add_star(mrhs_new(), (yyvsp[(2) - (2)].val));
7689 
7690  ;}
7691  break;
7692 
7693  case 290:
7694 #line 2550 "ripper.y"
7695  {
7696 #if 0
7697  (yyval.val) = new_fcall((yyvsp[(1) - (1)].val), 0, (yylsp[(1) - (1)]).first_column);
7698 #endif
7699  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (1)].val)), arg_new());
7700 
7701  ;}
7702  break;
7703 
7704  case 291:
7705 #line 2558 "ripper.y"
7706  {
7707  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7708  CMDARG_SET(0);
7709 #if 0
7710  (yyval.num) = ruby_sourceline;
7711 #endif
7712 
7713  ;}
7714  break;
7715 
7716  case 292:
7717 #line 2568 "ripper.y"
7718  {
7719  CMDARG_SET((yyvsp[(1) - (4)].val));
7720 #if 0
7721  if ((yyvsp[(3) - (4)].val) == NULL) {
7722  (yyval.val) = NEW_NIL();
7723  nd_set_column((yyval.val), (yylsp[(1) - (4)]).first_column);
7724  }
7725  else {
7726  set_line_body((yyvsp[(3) - (4)].val), (yyvsp[(2) - (4)].num));
7727  (yyval.val) = new_begin((yyvsp[(3) - (4)].val), (yylsp[(1) - (4)]).first_column);
7728  }
7729  nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
7730 #endif
7731  (yyval.val) = dispatch1(begin, (yyvsp[(3) - (4)].val));
7732 
7733  ;}
7734  break;
7735 
7736  case 293:
7737 #line 2584 "ripper.y"
7738  {SET_LEX_STATE(EXPR_ENDARG);;}
7739  break;
7740 
7741  case 294:
7742 #line 2585 "ripper.y"
7743  {
7744 #if 0
7745  (yyval.val) = new_begin(0, (yylsp[(1) - (3)]).first_column);
7746 #endif
7747  (yyval.val) = dispatch1(paren, 0);
7748 
7749  ;}
7750  break;
7751 
7752  case 295:
7753 #line 2593 "ripper.y"
7754  {
7755  (yyvsp[(1) - (1)].val) = cmdarg_stack;
7756  CMDARG_SET(0);
7757  ;}
7758  break;
7759 
7760  case 296:
7761 #line 2597 "ripper.y"
7762  {SET_LEX_STATE(EXPR_ENDARG);;}
7763  break;
7764 
7765  case 297:
7766 #line 2598 "ripper.y"
7767  {
7768  CMDARG_SET((yyvsp[(1) - (5)].val));
7769 #if 0
7770  (yyval.val) = (yyvsp[(3) - (5)].val);
7771 #endif
7772  (yyval.val) = dispatch1(paren, (yyvsp[(3) - (5)].val));
7773 
7774  ;}
7775  break;
7776 
7777  case 298:
7778 #line 2607 "ripper.y"
7779  {
7780 #if 0
7781  (yyval.val) = (yyvsp[(2) - (3)].val);
7782 #endif
7783  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
7784 
7785  ;}
7786  break;
7787 
7788  case 299:
7789 #line 2615 "ripper.y"
7790  {
7791 #if 0
7792  (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7793  nd_set_column((yyval.val), (yylsp[(1) - (3)]).first_column);
7794 #endif
7795  (yyval.val) = dispatch2(const_path_ref, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7796 
7797  ;}
7798  break;
7799 
7800  case 300:
7801 #line 2624 "ripper.y"
7802  {
7803 #if 0
7804  (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
7805  nd_set_column((yyval.val), (yylsp[(1) - (2)]).first_column);
7806 #endif
7807  (yyval.val) = dispatch1(top_const_ref, (yyvsp[(2) - (2)].val));
7808 
7809  ;}
7810  break;
7811 
7812  case 301:
7813 #line 2633 "ripper.y"
7814  {
7815 #if 0
7816  if ((yyvsp[(2) - (3)].val) == 0) {
7817  (yyval.val) = new_zarray((yylsp[(1) - (3)]).first_column); /* zero length array*/
7818  }
7819  else {
7820  (yyval.val) = (yyvsp[(2) - (3)].val);
7821  }
7822 #endif
7823  (yyval.val) = dispatch1(array, escape_Qundef((yyvsp[(2) - (3)].val)));
7824 
7825  ;}
7826  break;
7827 
7828  case 302:
7829 #line 2646 "ripper.y"
7830  {
7831 #if 0
7832  (yyval.val) = new_hash((yyvsp[(2) - (3)].val), (yylsp[(1) - (3)]).first_column);
7833  (yyval.val)->nd_alen = TRUE;
7834 #endif
7835  (yyval.val) = dispatch1(hash, escape_Qundef((yyvsp[(2) - (3)].val)));
7836 
7837  ;}
7838  break;
7839 
7840  case 303:
7841 #line 2655 "ripper.y"
7842  {
7843 #if 0
7844  (yyval.val) = NEW_RETURN(0);
7845  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
7846 #endif
7847  (yyval.val) = dispatch0(return0);
7848 
7849  ;}
7850  break;
7851 
7852  case 304:
7853 #line 2664 "ripper.y"
7854  {
7855 #if 0
7856  (yyval.val) = new_yield((yyvsp[(3) - (4)].val), (yylsp[(1) - (4)]).first_column);
7857 #endif
7858  (yyval.val) = dispatch1(yield, dispatch1(paren, (yyvsp[(3) - (4)].val)));
7859 
7860  ;}
7861  break;
7862 
7863  case 305:
7864 #line 2672 "ripper.y"
7865  {
7866 #if 0
7867  (yyval.val) = NEW_YIELD(0);
7868  nd_set_column((yyval.val), (yylsp[(1) - (3)]).first_column);
7869 #endif
7870  (yyval.val) = dispatch1(yield, dispatch1(paren, arg_new()));
7871 
7872  ;}
7873  break;
7874 
7875  case 306:
7876 #line 2681 "ripper.y"
7877  {
7878 #if 0
7879  (yyval.val) = NEW_YIELD(0);
7880  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
7881 #endif
7882  (yyval.val) = dispatch0(yield0);
7883 
7884  ;}
7885  break;
7886 
7887  case 307:
7888 #line 2689 "ripper.y"
7889  {in_defined = 1;;}
7890  break;
7891 
7892  case 308:
7893 #line 2690 "ripper.y"
7894  {
7895  in_defined = 0;
7896  (yyval.val) = new_defined((yyvsp[(5) - (6)].val), (yylsp[(1) - (6)]).first_column);
7897  ;}
7898  break;
7899 
7900  case 309:
7901 #line 2695 "ripper.y"
7902  {
7903  (yyval.val) = call_uni_op(method_cond((yyvsp[(3) - (4)].val), (yylsp[(1) - (4)]).first_column), METHOD_NOT, (yylsp[(1) - (4)]).first_column);
7904  ;}
7905  break;
7906 
7907  case 310:
7908 #line 2699 "ripper.y"
7909  {
7910  (yyval.val) = call_uni_op(method_cond(new_nil(), (yylsp[(1) - (3)]).first_column), METHOD_NOT, (yylsp[(1) - (3)]).first_column);
7911  ;}
7912  break;
7913 
7914  case 311:
7915 #line 2703 "ripper.y"
7916  {
7917 #if 0
7918  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
7919  (yyval.val) = (yyvsp[(2) - (2)].val);
7920 #endif
7921  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), arg_new());
7922  (yyval.val) = method_add_block((yyval.val), (yyvsp[(2) - (2)].val));
7923 
7924  ;}
7925  break;
7926 
7927  case 313:
7928 #line 2714 "ripper.y"
7929  {
7930 #if 0
7931  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
7932  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
7933  (yyval.val) = (yyvsp[(2) - (2)].val);
7934 #endif
7935  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7936 
7937  ;}
7938  break;
7939 
7940  case 314:
7941 #line 2724 "ripper.y"
7942  {
7943  (yyval.val) = (yyvsp[(2) - (2)].val);
7944  ;}
7945  break;
7946 
7947  case 315:
7948 #line 2731 "ripper.y"
7949  {
7950 #if 0
7951  (yyval.val) = new_if((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val), (yylsp[(1) - (6)]).first_column);
7952  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
7953 #endif
7954  (yyval.val) = dispatch3(if, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
7955 
7956  ;}
7957  break;
7958 
7959  case 316:
7960 #line 2743 "ripper.y"
7961  {
7962 #if 0
7963  (yyval.val) = new_unless((yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val), (yylsp[(1) - (6)]).first_column);
7964  fixpos((yyval.val), (yyvsp[(2) - (6)].val));
7965 #endif
7966  (yyval.val) = dispatch3(unless, (yyvsp[(2) - (6)].val), (yyvsp[(4) - (6)].val), escape_Qundef((yyvsp[(5) - (6)].val)));
7967 
7968  ;}
7969  break;
7970 
7971  case 317:
7972 #line 2751 "ripper.y"
7973  {COND_PUSH(1);;}
7974  break;
7975 
7976  case 318:
7977 #line 2751 "ripper.y"
7978  {COND_POP();;}
7979  break;
7980 
7981  case 319:
7982 #line 2754 "ripper.y"
7983  {
7984 #if 0
7985  (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val), (yylsp[(1) - (7)]).first_column), (yyvsp[(6) - (7)].val), 1);
7986  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
7987  nd_set_column((yyval.val), (yylsp[(1) - (7)]).first_column);
7988 #endif
7989  (yyval.val) = dispatch2(while, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
7990 
7991  ;}
7992  break;
7993 
7994  case 320:
7995 #line 2763 "ripper.y"
7996  {COND_PUSH(1);;}
7997  break;
7998 
7999  case 321:
8000 #line 2763 "ripper.y"
8001  {COND_POP();;}
8002  break;
8003 
8004  case 322:
8005 #line 2766 "ripper.y"
8006  {
8007 #if 0
8008  (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val), (yylsp[(1) - (7)]).first_column), (yyvsp[(6) - (7)].val), 1);
8009  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8010  nd_set_column((yyval.val), (yylsp[(1) - (7)]).first_column);
8011 #endif
8012  (yyval.val) = dispatch2(until, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8013 
8014  ;}
8015  break;
8016 
8017  case 323:
8018 #line 2778 "ripper.y"
8019  {
8020 #if 0
8021  (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8022  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8023  nd_set_column((yyval.val), (yylsp[(1) - (5)]).first_column);
8024 #endif
8025  (yyval.val) = dispatch2(case, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8026 
8027  ;}
8028  break;
8029 
8030  case 324:
8031 #line 2788 "ripper.y"
8032  {
8033 #if 0
8034  (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
8035  nd_set_line((yyvsp[(3) - (4)].val), (yyvsp[(1) - (4)].num));
8036  nd_set_column((yyval.val), (yylsp[(1) - (4)]).first_column);
8037 #endif
8038  (yyval.val) = dispatch2(case, Qnil, (yyvsp[(3) - (4)].val));
8039 
8040  ;}
8041  break;
8042 
8043  case 325:
8044 #line 2798 "ripper.y"
8045  {COND_PUSH(1);;}
8046  break;
8047 
8048  case 326:
8049 #line 2800 "ripper.y"
8050  {COND_POP();;}
8051  break;
8052 
8053  case 327:
8054 #line 2803 "ripper.y"
8055  {
8056 #if 0
8057  /*
8058  * for a, b, c in e
8059  * #=>
8060  * e.each{|*x| a, b, c = x}
8061  *
8062  * for a in e
8063  * #=>
8064  * e.each{|x| a, = x}
8065  */
8066  ID id = internal_id();
8067  ID *tbl = ALLOC_N(ID, 2);
8068  NODE *m = NEW_ARGS_AUX(0, 0);
8069  NODE *args, *scope;
8070 
8071  switch (nd_type((yyvsp[(2) - (9)].val))) {
8072  case NODE_MASGN:
8073  m->nd_next = node_assign((yyvsp[(2) - (9)].val), new_for(new_dvar(id, (yylsp[(1) - (9)]).first_column), 0, 0, (yylsp[(1) - (9)]).first_column), (yylsp[(1) - (9)]).first_column);
8074  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0, (yylsp[(1) - (9)]).first_column));
8075  break;
8076  case NODE_LASGN:
8077  case NODE_DASGN:
8078  case NODE_DASGN_CURR:
8079  (yyvsp[(2) - (9)].val)->nd_value = new_dvar(id, (yylsp[(1) - (9)]).first_column);
8080  m->nd_plen = 1;
8081  m->nd_next = (yyvsp[(2) - (9)].val);
8082  args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0, (yylsp[(1) - (9)]).first_column));
8083  break;
8084  default:
8085  {
8086  NODE *masgn = new_masgn(new_list((yyvsp[(2) - (9)].val), (yylsp[(1) - (9)]).first_column), 0, (yylsp[(1) - (9)]).first_column);
8087  m->nd_next = node_assign(masgn, new_dvar(id, (yylsp[(1) - (9)]).first_column), (yylsp[(1) - (9)]).first_column);
8088  args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0, (yylsp[(1) - (9)]).first_column));
8089  break;
8090  }
8091  }
8092  scope = NEW_NODE(NODE_SCOPE, tbl, (yyvsp[(8) - (9)].val), args);
8093  nd_set_column(scope, (yylsp[(1) - (9)]).first_column);
8094  tbl[0] = 1; tbl[1] = id;
8095  (yyval.val) = new_for(0, (yyvsp[(5) - (9)].val), scope, (yylsp[(1) - (9)]).first_column);
8096  fixpos((yyval.val), (yyvsp[(2) - (9)].val));
8097 #endif
8098  (yyval.val) = dispatch3(for, (yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(8) - (9)].val));
8099 
8100  ;}
8101  break;
8102 
8103  case 328:
8104 #line 2850 "ripper.y"
8105  {
8106  if (in_def || in_single)
8107  yyerror0("class definition in method body");
8108  local_push(0);
8109 #if 0
8110  (yyval.num) = ruby_sourceline;
8111 #endif
8112 
8113  ;}
8114  break;
8115 
8116  case 329:
8117 #line 2861 "ripper.y"
8118  {
8119 #if 0
8120  (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
8121  nd_set_column((yyval.val)->nd_body, (yylsp[(1) - (6)]).first_column);
8122  set_line_body((yyvsp[(5) - (6)].val), (yyvsp[(4) - (6)].num));
8123  nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
8124  nd_set_column((yyval.val), (yylsp[(1) - (6)]).first_column);
8125 #endif
8126  (yyval.val) = dispatch3(class, (yyvsp[(2) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val));
8127 
8128  local_pop();
8129  ;}
8130  break;
8131 
8132  case 330:
8133 #line 2874 "ripper.y"
8134  {
8135  (yyval.num) = (in_def << 1) | in_single;
8136  in_def = 0;
8137  in_single = 0;
8138  local_push(0);
8139  ;}
8140  break;
8141 
8142  case 331:
8143 #line 2883 "ripper.y"
8144  {
8145 #if 0
8146  (yyval.val) = NEW_SCLASS((yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8147  nd_set_column((yyval.val)->nd_body, (yylsp[(1) - (7)]).first_column);
8148  set_line_body((yyvsp[(6) - (7)].val), nd_line((yyvsp[(3) - (7)].val)));
8149  fixpos((yyval.val), (yyvsp[(3) - (7)].val));
8150  nd_set_column((yyval.val), (yylsp[(1) - (7)]).first_column);
8151 #endif
8152  (yyval.val) = dispatch2(sclass, (yyvsp[(3) - (7)].val), (yyvsp[(6) - (7)].val));
8153 
8154  local_pop();
8155  in_def = ((yyvsp[(4) - (7)].num) >> 1) & 1;
8156  in_single = (yyvsp[(4) - (7)].num) & 1;
8157  ;}
8158  break;
8159 
8160  case 332:
8161 #line 2898 "ripper.y"
8162  {
8163  if (in_def || in_single)
8164  yyerror0("module definition in method body");
8165  local_push(0);
8166 #if 0
8167  (yyval.num) = ruby_sourceline;
8168 #endif
8169 
8170  ;}
8171  break;
8172 
8173  case 333:
8174 #line 2909 "ripper.y"
8175  {
8176 #if 0
8177  (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8178  nd_set_column((yyval.val)->nd_body, (yylsp[(1) - (5)]).first_column);
8179  set_line_body((yyvsp[(4) - (5)].val), (yyvsp[(3) - (5)].num));
8180  nd_set_line((yyval.val), (yyvsp[(3) - (5)].num));
8181  nd_set_column((yyval.val), (yylsp[(1) - (5)]).first_column);
8182 #endif
8183  (yyval.val) = dispatch2(module, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8184 
8185  local_pop();
8186  ;}
8187  break;
8188 
8189  case 334:
8190 #line 2922 "ripper.y"
8191  {
8192  local_push(0);
8193  (yyval.id) = current_arg;
8194  current_arg = 0;
8195  ;}
8196  break;
8197 
8198  case 335:
8199 #line 2927 "ripper.y"
8200  {
8201  (yyval.num) = in_def;
8202  in_def = 1;
8203  ;}
8204  break;
8205 
8206  case 336:
8207 #line 2934 "ripper.y"
8208  {
8209 #if 0
8210  NODE *body = remove_begin((yyvsp[(6) - (7)].val));
8211  reduce_nodes(&body);
8212  (yyval.val) = NEW_DEFN((yyvsp[(2) - (7)].val), (yyvsp[(5) - (7)].val), body, METHOD_VISI_PRIVATE);
8213  nd_set_column((yyval.val)->nd_defn, (yylsp[(1) - (7)]).first_column);
8214  set_line_body(body, (yyvsp[(1) - (7)].num));
8215  nd_set_line((yyval.val), (yyvsp[(1) - (7)].num));
8216  nd_set_column((yyval.val), (yylsp[(1) - (7)]).first_column);
8217 #endif
8218  (yyval.val) = dispatch3(def, (yyvsp[(2) - (7)].val), (yyvsp[(5) - (7)].val), (yyvsp[(6) - (7)].val));
8219 
8220  local_pop();
8221  in_def = (yyvsp[(4) - (7)].num) & 1;
8222  current_arg = (yyvsp[(3) - (7)].id);
8223  ;}
8224  break;
8225 
8226  case 337:
8227 #line 2950 "ripper.y"
8228  {SET_LEX_STATE(EXPR_FNAME);;}
8229  break;
8230 
8231  case 338:
8232 #line 2951 "ripper.y"
8233  {
8234  (yyvsp[(4) - (5)].num) = in_single;
8235  in_single = 1;
8236  SET_LEX_STATE(EXPR_ENDFN|EXPR_LABEL); /* force for args */
8237  local_push(0);
8238  (yyval.id) = current_arg;
8239  current_arg = 0;
8240  ;}
8241  break;
8242 
8243  case 339:
8244 #line 2962 "ripper.y"
8245  {
8246 #if 0
8247  NODE *body = remove_begin((yyvsp[(8) - (9)].val));
8248  reduce_nodes(&body);
8249  (yyval.val) = NEW_DEFS((yyvsp[(2) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), body);
8250  nd_set_column((yyval.val)->nd_defn, (yylsp[(1) - (9)]).first_column);
8251  set_line_body(body, (yyvsp[(1) - (9)].num));
8252  nd_set_line((yyval.val), (yyvsp[(1) - (9)].num));
8253  nd_set_column((yyval.val), (yylsp[(1) - (9)]).first_column);
8254 #endif
8255  (yyval.val) = dispatch5(defs, (yyvsp[(2) - (9)].val), (yyvsp[(3) - (9)].val), (yyvsp[(5) - (9)].val), (yyvsp[(7) - (9)].val), (yyvsp[(8) - (9)].val));
8256 
8257  local_pop();
8258  in_single = (yyvsp[(4) - (9)].num) & 1;
8259  current_arg = (yyvsp[(6) - (9)].id);
8260  ;}
8261  break;
8262 
8263  case 340:
8264 #line 2979 "ripper.y"
8265  {
8266 #if 0
8267  (yyval.val) = NEW_BREAK(0);
8268  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
8269 #endif
8270  (yyval.val) = dispatch1(break, arg_new());
8271 
8272  ;}
8273  break;
8274 
8275  case 341:
8276 #line 2988 "ripper.y"
8277  {
8278 #if 0
8279  (yyval.val) = NEW_NEXT(0);
8280  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
8281 #endif
8282  (yyval.val) = dispatch1(next, arg_new());
8283 
8284  ;}
8285  break;
8286 
8287  case 342:
8288 #line 2997 "ripper.y"
8289  {
8290 #if 0
8291  (yyval.val) = NEW_REDO();
8292  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
8293 #endif
8294  (yyval.val) = dispatch0(redo);
8295 
8296  ;}
8297  break;
8298 
8299  case 343:
8300 #line 3006 "ripper.y"
8301  {
8302 #if 0
8303  (yyval.val) = NEW_RETRY();
8304  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
8305 #endif
8306  (yyval.val) = dispatch0(retry);
8307 
8308  ;}
8309  break;
8310 
8311  case 344:
8312 #line 3017 "ripper.y"
8313  {
8314 #if 0
8315  value_expr((yyvsp[(1) - (1)].val));
8316  (yyval.val) = (yyvsp[(1) - (1)].val);
8317  if (!(yyval.val)) (yyval.val) = NEW_NIL();
8318 #endif
8319  (yyval.val) = (yyvsp[(1) - (1)].val);
8320 
8321  ;}
8322  break;
8323 
8324  case 345:
8325 #line 3029 "ripper.y"
8326  {
8327  token_info_push("begin");
8328  ;}
8329  break;
8330 
8331  case 346:
8332 #line 3035 "ripper.y"
8333  {
8334  token_info_push("if");
8335  ;}
8336  break;
8337 
8338  case 347:
8339 #line 3041 "ripper.y"
8340  {
8341  token_info_push("unless");
8342  ;}
8343  break;
8344 
8345  case 348:
8346 #line 3047 "ripper.y"
8347  {
8348  token_info_push("while");
8349  ;}
8350  break;
8351 
8352  case 349:
8353 #line 3053 "ripper.y"
8354  {
8355  token_info_push("until");
8356  ;}
8357  break;
8358 
8359  case 350:
8360 #line 3059 "ripper.y"
8361  {
8362  token_info_push("case");
8363 #if 0
8364  (yyval.num) = ruby_sourceline;
8365 #endif
8366 
8367  ;}
8368  break;
8369 
8370  case 351:
8371 #line 3069 "ripper.y"
8372  {
8373  token_info_push("for");
8374  ;}
8375  break;
8376 
8377  case 352:
8378 #line 3075 "ripper.y"
8379  {
8380  token_info_push("class");
8381  ;}
8382  break;
8383 
8384  case 353:
8385 #line 3081 "ripper.y"
8386  {
8387  token_info_push("module");
8388  ;}
8389  break;
8390 
8391  case 354:
8392 #line 3087 "ripper.y"
8393  {
8394  token_info_push("def");
8395 #if 0
8396  (yyval.num) = ruby_sourceline;
8397 #endif
8398 
8399  ;}
8400  break;
8401 
8402  case 355:
8403 #line 3097 "ripper.y"
8404  {
8405  token_info_pop("end");
8406  ;}
8407  break;
8408 
8409  case 356:
8410 #line 3105 "ripper.y"
8411  { (yyval.val) = Qnil; ;}
8412  break;
8413 
8414  case 358:
8415 #line 3111 "ripper.y"
8416  { (yyval.val) = (yyvsp[(2) - (2)].val); ;}
8417  break;
8418 
8419  case 359:
8420 #line 3118 "ripper.y"
8421  { (yyval.val) = Qnil; ;}
8422  break;
8423 
8424  case 362:
8425 #line 3127 "ripper.y"
8426  {
8427 #if 0
8428  (yyval.val) = new_if((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val), (yylsp[(1) - (5)]).first_column);
8429  fixpos((yyval.val), (yyvsp[(2) - (5)].val));
8430 #endif
8431  (yyval.val) = dispatch3(elsif, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
8432 
8433  ;}
8434  break;
8435 
8436  case 364:
8437 #line 3139 "ripper.y"
8438  {
8439 #if 0
8440  (yyval.val) = (yyvsp[(2) - (2)].val);
8441 #endif
8442  (yyval.val) = dispatch1(else, (yyvsp[(2) - (2)].val));
8443 
8444  ;}
8445  break;
8446 
8447  case 367:
8448 #line 3153 "ripper.y"
8449  {
8450  (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0, (yylsp[(1) - (1)]).first_column);
8451 #if 0
8452 #endif
8453 
8454  ;}
8455  break;
8456 
8457  case 368:
8458 #line 3160 "ripper.y"
8459  {
8460 #if 0
8461  (yyval.val) = (yyvsp[(2) - (3)].val);
8462 #endif
8463  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
8464 
8465  ;}
8466  break;
8467 
8468  case 369:
8469 #line 3170 "ripper.y"
8470  {
8471 #if 0
8472  (yyval.val) = new_list((yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column);
8473 #endif
8474  (yyval.val) = mlhs_add(mlhs_new(), (yyvsp[(1) - (1)].val));
8475 
8476  ;}
8477  break;
8478 
8479  case 370:
8480 #line 3178 "ripper.y"
8481  {
8482 #if 0
8483  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
8484 #endif
8485  (yyval.val) = mlhs_add((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8486 
8487  ;}
8488  break;
8489 
8490  case 371:
8491 #line 3188 "ripper.y"
8492  {
8493 #if 0
8494  (yyval.val) = new_masgn((yyvsp[(1) - (1)].val), 0, (yylsp[(1) - (1)]).first_column);
8495 #endif
8496  (yyval.val) = (yyvsp[(1) - (1)].val);
8497 
8498  ;}
8499  break;
8500 
8501  case 372:
8502 #line 3196 "ripper.y"
8503  {
8504  (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0, (yylsp[(1) - (4)]).first_column);
8505 #if 0
8506  (yyval.val) = new_masgn((yyvsp[(1) - (4)].val), (yyval.val), (yylsp[(1) - (4)]).first_column);
8507 #endif
8508  (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), (yyval.val));
8509 
8510  ;}
8511  break;
8512 
8513  case 373:
8514 #line 3205 "ripper.y"
8515  {
8516  (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0, (yylsp[(1) - (6)]).first_column);
8517 #if 0
8518  (yyval.val) = new_masgn((yyvsp[(1) - (6)].val), new_postarg((yyval.val), (yyvsp[(6) - (6)].val), (yylsp[(1) - (6)]).first_column), (yylsp[(1) - (6)]).first_column);
8519 #endif
8520  (yyval.val) = mlhs_add_star((yyvsp[(1) - (6)].val), (yyval.val));
8521  (yyval.val) = mlhs_add_post((yyval.val), (yyvsp[(6) - (6)].val));
8522 
8523  ;}
8524  break;
8525 
8526  case 374:
8527 #line 3215 "ripper.y"
8528  {
8529 #if 0
8530  (yyval.val) = new_masgn((yyvsp[(1) - (3)].val), (NODE *)-1, (yylsp[(1) - (3)]).first_column);
8531 #endif
8532  (yyval.val) = mlhs_add_star((yyvsp[(1) - (3)].val), Qnil);
8533 
8534  ;}
8535  break;
8536 
8537  case 375:
8538 #line 3223 "ripper.y"
8539  {
8540 #if 0
8541  (yyval.val) = new_masgn((yyvsp[(1) - (5)].val), new_postarg((NODE *)-1, (yyvsp[(5) - (5)].val), (yylsp[(1) - (5)]).first_column), (yylsp[(1) - (5)]).first_column);
8542 #endif
8543  (yyval.val) = mlhs_add_star((yyvsp[(1) - (5)].val), Qnil);
8544  (yyval.val) = mlhs_add_post((yyval.val), (yyvsp[(5) - (5)].val));
8545 
8546  ;}
8547  break;
8548 
8549  case 376:
8550 #line 3232 "ripper.y"
8551  {
8552  (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0, (yylsp[(1) - (2)]).first_column);
8553 #if 0
8554  (yyval.val) = new_masgn(0, (yyval.val), (yylsp[(1) - (2)]).first_column);
8555 #endif
8556  (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
8557 
8558  ;}
8559  break;
8560 
8561  case 377:
8562 #line 3241 "ripper.y"
8563  {
8564  (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0, (yylsp[(1) - (4)]).first_column);
8565 #if 0
8566  (yyval.val) = new_masgn(0, new_postarg((yyval.val), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column), (yylsp[(1) - (4)]).first_column);
8567 #endif
8568  (yyval.val) = mlhs_add_star(mlhs_new(), (yyval.val));
8569  (yyval.val) = mlhs_add_post((yyval.val), (yyvsp[(4) - (4)].val));
8570 
8571  ;}
8572  break;
8573 
8574  case 378:
8575 #line 3251 "ripper.y"
8576  {
8577 #if 0
8578  (yyval.val) = new_masgn(0, (NODE *)-1, (yylsp[(1) - (1)]).first_column);
8579 #endif
8580  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8581 
8582  ;}
8583  break;
8584 
8585  case 379:
8586 #line 3259 "ripper.y"
8587  {
8588 #if 0
8589  (yyval.val) = new_masgn(0, new_postarg((NODE *)-1, (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column), (yylsp[(1) - (3)]).first_column);
8590 #endif
8591  (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
8592  (yyval.val) = mlhs_add_post((yyval.val), (yyvsp[(3) - (3)].val));
8593 
8594  ;}
8595  break;
8596 
8597  case 380:
8598 #line 3271 "ripper.y"
8599  {
8600  (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
8601  ;}
8602  break;
8603 
8604  case 381:
8605 #line 3275 "ripper.y"
8606  {
8607  (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
8608  ;}
8609  break;
8610 
8611  case 382:
8612 #line 3279 "ripper.y"
8613  {
8614  (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
8615  ;}
8616  break;
8617 
8618  case 383:
8619 #line 3283 "ripper.y"
8620  {
8621  (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column);
8622  ;}
8623  break;
8624 
8625  case 384:
8626 #line 3289 "ripper.y"
8627  {
8628  (yyval.val) = (yyvsp[(2) - (2)].val);
8629  ;}
8630  break;
8631 
8632  case 385:
8633 #line 3293 "ripper.y"
8634  {
8635  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone, (yylsp[(0) - (0)]).first_column);
8636  ;}
8637  break;
8638 
8639  case 386:
8640 #line 3299 "ripper.y"
8641  {
8642  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
8643  ;}
8644  break;
8645 
8646  case 387:
8647 #line 3303 "ripper.y"
8648  {
8649  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
8650  ;}
8651  break;
8652 
8653  case 388:
8654 #line 3307 "ripper.y"
8655  {
8656  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
8657  ;}
8658  break;
8659 
8660  case 389:
8661 #line 3311 "ripper.y"
8662  {
8663  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8664  ;}
8665  break;
8666 
8667  case 390:
8668 #line 3315 "ripper.y"
8669  {
8670  (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
8671  ;}
8672  break;
8673 
8674  case 391:
8675 #line 3319 "ripper.y"
8676  {
8677  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone, (yylsp[(1) - (2)]).first_column));
8678 #if 0
8679 #endif
8680  dispatch1(excessed_comma, (yyval.val));
8681 
8682  ;}
8683  break;
8684 
8685  case 392:
8686 #line 3327 "ripper.y"
8687  {
8688  (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8689  ;}
8690  break;
8691 
8692  case 393:
8693 #line 3331 "ripper.y"
8694  {
8695  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
8696  ;}
8697  break;
8698 
8699  case 394:
8700 #line 3335 "ripper.y"
8701  {
8702  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
8703  ;}
8704  break;
8705 
8706  case 395:
8707 #line 3339 "ripper.y"
8708  {
8709  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8710  ;}
8711  break;
8712 
8713  case 396:
8714 #line 3343 "ripper.y"
8715  {
8716  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
8717  ;}
8718  break;
8719 
8720  case 397:
8721 #line 3347 "ripper.y"
8722  {
8723  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
8724  ;}
8725  break;
8726 
8727  case 398:
8728 #line 3351 "ripper.y"
8729  {
8730  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
8731  ;}
8732  break;
8733 
8734  case 399:
8735 #line 3355 "ripper.y"
8736  {
8737  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
8738  ;}
8739  break;
8740 
8741  case 400:
8742 #line 3359 "ripper.y"
8743  {
8744  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
8745  ;}
8746  break;
8747 
8748  case 402:
8749 #line 3366 "ripper.y"
8750  {
8751  command_start = TRUE;
8752  ;}
8753  break;
8754 
8755  case 403:
8756 #line 3372 "ripper.y"
8757  {
8758  current_arg = 0;
8759 #if 0
8760  (yyval.val) = 0;
8761 #endif
8762  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
8763  escape_Qundef((yyvsp[(2) - (3)].val)));
8764 
8765  ;}
8766  break;
8767 
8768  case 404:
8769 #line 3382 "ripper.y"
8770  {
8771 #if 0
8772  (yyval.val) = 0;
8773 #endif
8774  (yyval.val) = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
8775  Qnil);
8776 
8777  ;}
8778  break;
8779 
8780  case 405:
8781 #line 3391 "ripper.y"
8782  {
8783  current_arg = 0;
8784 #if 0
8785  (yyval.val) = (yyvsp[(2) - (4)].val);
8786 #endif
8787  (yyval.val) = blockvar_new(escape_Qundef((yyvsp[(2) - (4)].val)), escape_Qundef((yyvsp[(3) - (4)].val)));
8788 
8789  ;}
8790  break;
8791 
8792  case 406:
8793 #line 3403 "ripper.y"
8794  {
8795  (yyval.val) = 0;
8796  ;}
8797  break;
8798 
8799  case 407:
8800 #line 3407 "ripper.y"
8801  {
8802 #if 0
8803  (yyval.val) = 0;
8804 #endif
8805  (yyval.val) = (yyvsp[(3) - (4)].val);
8806 
8807  ;}
8808  break;
8809 
8810  case 408:
8811 #line 3419 "ripper.y"
8812  {
8813  (yyval.val) = rb_ary_new3(1, get_value((yyvsp[(1) - (1)].val)));
8814  ;}
8815  break;
8816 
8817  case 409:
8818 #line 3426 "ripper.y"
8819  {
8820  rb_ary_push((yyvsp[(1) - (3)].val), get_value((yyvsp[(3) - (3)].val)));
8821  ;}
8822  break;
8823 
8824  case 410:
8825 #line 3433 "ripper.y"
8826  {
8827  new_bv(get_id((yyvsp[(1) - (1)].val)));
8828 #if 0
8829 #endif
8830  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
8831 
8832  ;}
8833  break;
8834 
8835  case 411:
8836 #line 3441 "ripper.y"
8837  {
8838  (yyval.val) = 0;
8839  ;}
8840  break;
8841 
8842  case 412:
8843 #line 3446 "ripper.y"
8844  {
8845  (yyval.vars) = dyna_push();
8846  ;}
8847  break;
8848 
8849  case 413:
8850 #line 3449 "ripper.y"
8851  {
8852  (yyval.num) = lpar_beg;
8853  lpar_beg = ++paren_nest;
8854  ;}
8855  break;
8856 
8857  case 414:
8858 #line 3454 "ripper.y"
8859  {
8860  (yyval.num) = ruby_sourceline;
8861  ;}
8862  break;
8863 
8864  case 415:
8865 #line 3457 "ripper.y"
8866  {
8867  (yyval.val) = cmdarg_stack;
8868  CMDARG_SET(0);
8869  ;}
8870  break;
8871 
8872  case 416:
8873 #line 3462 "ripper.y"
8874  {
8875  lpar_beg = (yyvsp[(2) - (6)].num);
8876  CMDARG_SET((yyvsp[(5) - (6)].val));
8877  CMDARG_LEXPOP();
8878 #if 0
8879  (yyval.val) = NEW_LAMBDA((yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
8880  nd_set_line((yyval.val), (yyvsp[(4) - (6)].num));
8881  nd_set_column((yyval.val), (yylsp[(1) - (6)]).first_column);
8882  nd_set_column((yyval.val)->nd_body, (yylsp[(1) - (6)]).first_column);
8883 #endif
8884  (yyval.val) = dispatch2(lambda, (yyvsp[(3) - (6)].val), (yyvsp[(6) - (6)].val));
8885 
8886  dyna_pop((yyvsp[(1) - (6)].vars));
8887  ;}
8888  break;
8889 
8890  case 417:
8891 #line 3479 "ripper.y"
8892  {
8893 #if 0
8894  (yyval.val) = (yyvsp[(2) - (4)].val);
8895 #endif
8896  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (4)].val));
8897 
8898  ;}
8899  break;
8900 
8901  case 418:
8902 #line 3487 "ripper.y"
8903  {
8904  (yyval.val) = (yyvsp[(1) - (1)].val);
8905  ;}
8906  break;
8907 
8908  case 419:
8909 #line 3493 "ripper.y"
8910  {
8911  token_info_pop("}");
8912  (yyval.val) = (yyvsp[(2) - (3)].val);
8913  ;}
8914  break;
8915 
8916  case 420:
8917 #line 3498 "ripper.y"
8918  {
8919  (yyval.val) = (yyvsp[(2) - (3)].val);
8920  ;}
8921  break;
8922 
8923  case 421:
8924 #line 3504 "ripper.y"
8925  {
8926 #if 0
8927  (yyval.num) = ruby_sourceline;
8928 #endif
8929  ;}
8930  break;
8931 
8932  case 422:
8933 #line 3510 "ripper.y"
8934  {
8935  (yyval.val) = (yyvsp[(3) - (4)].val);
8936 #if 0
8937  nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
8938 #endif
8939  ;}
8940  break;
8941 
8942  case 423:
8943 #line 3519 "ripper.y"
8944  {
8945 #if 0
8946  if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
8947  compile_error(PARSER_ARG "block given to yield");
8948  }
8949  else {
8950  block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
8951  }
8952  (yyvsp[(2) - (2)].val)->nd_iter = (yyvsp[(1) - (2)].val);
8953  (yyval.val) = (yyvsp[(2) - (2)].val);
8954  fixpos((yyval.val), (yyvsp[(1) - (2)].val));
8955 #endif
8956  (yyval.val) = method_add_block((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
8957 
8958  ;}
8959  break;
8960 
8961  case 424:
8962 #line 3535 "ripper.y"
8963  {
8964  (yyval.val) = new_qcall((yyvsp[(2) - (4)].val), (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
8965  ;}
8966  break;
8967 
8968  case 425:
8969 #line 3539 "ripper.y"
8970  {
8971 #if 0
8972  block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
8973  (yyvsp[(5) - (5)].val)->nd_iter = new_command_qcall((yyvsp[(2) - (5)].val), (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yylsp[(1) - (5)]).first_column);
8974  (yyval.val) = (yyvsp[(5) - (5)].val);
8975  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
8976 #endif
8977  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
8978  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
8979 
8980  ;}
8981  break;
8982 
8983  case 426:
8984 #line 3551 "ripper.y"
8985  {
8986 #if 0
8987  block_dup_check((yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
8988  (yyvsp[(5) - (5)].val)->nd_iter = new_command_qcall((yyvsp[(2) - (5)].val), (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val), (yylsp[(1) - (5)]).first_column);
8989  (yyval.val) = (yyvsp[(5) - (5)].val);
8990  fixpos((yyval.val), (yyvsp[(1) - (5)].val));
8991 #endif
8992  (yyval.val) = dispatch4(command_call, (yyvsp[(1) - (5)].val), (yyvsp[(2) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(4) - (5)].val));
8993  (yyval.val) = method_add_block((yyval.val), (yyvsp[(5) - (5)].val));
8994 
8995  ;}
8996  break;
8997 
8998  case 427:
8999 #line 3565 "ripper.y"
9000  {
9001 #if 0
9002  (yyval.val) = (yyvsp[(1) - (2)].val);
9003  (yyval.val)->nd_args = (yyvsp[(2) - (2)].val);
9004 #endif
9005  (yyval.val) = method_arg(dispatch1(fcall, (yyvsp[(1) - (2)].val)), (yyvsp[(2) - (2)].val));
9006 
9007  ;}
9008  break;
9009 
9010  case 428:
9011 #line 3574 "ripper.y"
9012  {
9013 #if 0
9014  (yyval.num) = ruby_sourceline;
9015 #endif
9016  ;}
9017  break;
9018 
9019  case 429:
9020 #line 3580 "ripper.y"
9021  {
9022  (yyval.val) = new_qcall((yyvsp[(2) - (5)].val), (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val), (yylsp[(1) - (5)]).first_column);
9023  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9024  ;}
9025  break;
9026 
9027  case 430:
9028 #line 3585 "ripper.y"
9029  {
9030 #if 0
9031  (yyval.num) = ruby_sourceline;
9032 #endif
9033  ;}
9034  break;
9035 
9036  case 431:
9037 #line 3591 "ripper.y"
9038  {
9039  (yyval.val) = new_qcall(ID2VAL(idCOLON2), (yyvsp[(1) - (5)].val), (yyvsp[(3) - (5)].val), (yyvsp[(5) - (5)].val), (yylsp[(1) - (5)]).first_column);
9040  nd_set_line((yyval.val), (yyvsp[(4) - (5)].num));
9041  ;}
9042  break;
9043 
9044  case 432:
9045 #line 3596 "ripper.y"
9046  {
9047  (yyval.val) = new_qcall(ID2VAL(idCOLON2), (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), Qnull, (yylsp[(1) - (3)]).first_column);
9048  ;}
9049  break;
9050 
9051  case 433:
9052 #line 3600 "ripper.y"
9053  {
9054 #if 0
9055  (yyval.num) = ruby_sourceline;
9056 #endif
9057  ;}
9058  break;
9059 
9060  case 434:
9061 #line 3606 "ripper.y"
9062  {
9063  (yyval.val) = new_qcall((yyvsp[(2) - (4)].val), (yyvsp[(1) - (4)].val), ID2VAL(idCall), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
9064  nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
9065  ;}
9066  break;
9067 
9068  case 435:
9069 #line 3611 "ripper.y"
9070  {
9071 #if 0
9072  (yyval.num) = ruby_sourceline;
9073 #endif
9074  ;}
9075  break;
9076 
9077  case 436:
9078 #line 3617 "ripper.y"
9079  {
9080  (yyval.val) = new_qcall(ID2VAL(idCOLON2), (yyvsp[(1) - (4)].val), ID2VAL(idCall), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
9081  nd_set_line((yyval.val), (yyvsp[(3) - (4)].num));
9082  ;}
9083  break;
9084 
9085  case 437:
9086 #line 3622 "ripper.y"
9087  {
9088 #if 0
9089  (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
9090  nd_set_column((yyval.val), (yylsp[(1) - (2)]).first_column);
9091 #endif
9092  (yyval.val) = dispatch1(super, (yyvsp[(2) - (2)].val));
9093 
9094  ;}
9095  break;
9096 
9097  case 438:
9098 #line 3631 "ripper.y"
9099  {
9100 #if 0
9101  (yyval.val) = NEW_ZSUPER();
9102  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
9103 #endif
9104  (yyval.val) = dispatch0(zsuper);
9105 
9106  ;}
9107  break;
9108 
9109  case 439:
9110 #line 3640 "ripper.y"
9111  {
9112 #if 0
9113  if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
9114  (yyval.val) = new_fcall(tAREF, (yyvsp[(3) - (4)].val), (yylsp[(1) - (4)]).first_column);
9115  else
9116  (yyval.val) = new_call((yyvsp[(1) - (4)].val), tAREF, (yyvsp[(3) - (4)].val), (yylsp[(1) - (4)]).first_column);
9117  fixpos((yyval.val), (yyvsp[(1) - (4)].val));
9118 #endif
9119  (yyval.val) = dispatch2(aref, (yyvsp[(1) - (4)].val), escape_Qundef((yyvsp[(3) - (4)].val)));
9120 
9121  ;}
9122  break;
9123 
9124  case 440:
9125 #line 3654 "ripper.y"
9126  {
9127 #if 0
9128  (yyval.num) = ruby_sourceline;
9129 #endif
9130  ;}
9131  break;
9132 
9133  case 441:
9134 #line 3660 "ripper.y"
9135  {
9136  (yyval.val) = (yyvsp[(3) - (4)].val);
9137 #if 0
9138  nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
9139 #endif
9140  ;}
9141  break;
9142 
9143  case 442:
9144 #line 3667 "ripper.y"
9145  {
9146 #if 0
9147  (yyval.num) = ruby_sourceline;
9148 #endif
9149  ;}
9150  break;
9151 
9152  case 443:
9153 #line 3673 "ripper.y"
9154  {
9155  (yyval.val) = (yyvsp[(3) - (4)].val);
9156 #if 0
9157  nd_set_line((yyval.val), (yyvsp[(2) - (4)].num));
9158 #endif
9159  ;}
9160  break;
9161 
9162  case 444:
9163 #line 3681 "ripper.y"
9164  {(yyval.vars) = dyna_push();;}
9165  break;
9166 
9167  case 445:
9168 #line 3682 "ripper.y"
9169  {(yyval.val) = cmdarg_stack >> 1; CMDARG_SET(0);;}
9170  break;
9171 
9172  case 446:
9173 #line 3684 "ripper.y"
9174  {
9175  (yyval.val) = new_brace_body((yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
9176  dyna_pop((yyvsp[(1) - (4)].vars));
9177  CMDARG_SET((yyvsp[(2) - (4)].val));
9178  ;}
9179  break;
9180 
9181  case 447:
9182 #line 3691 "ripper.y"
9183  {(yyval.vars) = dyna_push();;}
9184  break;
9185 
9186  case 448:
9187 #line 3692 "ripper.y"
9188  {(yyval.val) = cmdarg_stack; CMDARG_SET(0);;}
9189  break;
9190 
9191  case 449:
9192 #line 3694 "ripper.y"
9193  {
9194  (yyval.val) = new_do_body((yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
9195  dyna_pop((yyvsp[(1) - (4)].vars));
9196  CMDARG_SET((yyvsp[(2) - (4)].val));
9197  ;}
9198  break;
9199 
9200  case 450:
9201 #line 3704 "ripper.y"
9202  {
9203 #if 0
9204  (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9205  nd_set_column((yyval.val), (yylsp[(1) - (5)]).first_column);
9206 #endif
9207  (yyval.val) = dispatch3(when, (yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), escape_Qundef((yyvsp[(5) - (5)].val)));
9208 
9209  ;}
9210  break;
9211 
9212  case 453:
9213 #line 3721 "ripper.y"
9214  {
9215 #if 0
9216  if ((yyvsp[(3) - (6)].val)) {
9217  (yyvsp[(3) - (6)].val) = node_assign((yyvsp[(3) - (6)].val), new_errinfo((yylsp[(1) - (6)]).first_column), (yylsp[(1) - (6)]).first_column);
9218  (yyvsp[(5) - (6)].val) = block_append((yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yylsp[(1) - (6)]).first_column);
9219  }
9220  (yyval.val) = new_resbody((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val), (yylsp[(1) - (6)]).first_column);
9221  fixpos((yyval.val), (yyvsp[(2) - (6)].val)?(yyvsp[(2) - (6)].val):(yyvsp[(5) - (6)].val));
9222 #endif
9223  (yyval.val) = dispatch4(rescue,
9224  escape_Qundef((yyvsp[(2) - (6)].val)),
9225  escape_Qundef((yyvsp[(3) - (6)].val)),
9226  escape_Qundef((yyvsp[(5) - (6)].val)),
9227  escape_Qundef((yyvsp[(6) - (6)].val)));
9228 
9229  ;}
9230  break;
9231 
9232  case 455:
9233 #line 3741 "ripper.y"
9234  {
9235 #if 0
9236  (yyval.val) = new_list((yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column);
9237 #endif
9238  (yyval.val) = rb_ary_new3(1, get_value((yyvsp[(1) - (1)].val)));
9239 
9240  ;}
9241  break;
9242 
9243  case 456:
9244 #line 3749 "ripper.y"
9245  {
9246 #if 0
9247  if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
9248 #endif
9249  (yyval.val) = (yyvsp[(1) - (1)].val);
9250 
9251  ;}
9252  break;
9253 
9254  case 458:
9255 #line 3760 "ripper.y"
9256  {
9257  (yyval.val) = (yyvsp[(2) - (2)].val);
9258  ;}
9259  break;
9260 
9261  case 460:
9262 #line 3767 "ripper.y"
9263  {
9264 #if 0
9265  (yyval.val) = (yyvsp[(2) - (2)].val);
9266 #endif
9267  (yyval.val) = dispatch1(ensure, (yyvsp[(2) - (2)].val));
9268 
9269  ;}
9270  break;
9271 
9272  case 463:
9273 #line 3779 "ripper.y"
9274  {
9275 #if 0
9276  (yyval.val) = new_lit(ID2SYM((yyvsp[(1) - (1)].val)), (yylsp[(1) - (1)]).first_column);
9277 #endif
9278  (yyval.val) = dispatch1(symbol_literal, (yyvsp[(1) - (1)].val));
9279 
9280  ;}
9281  break;
9282 
9283  case 465:
9284 #line 3790 "ripper.y"
9285  {
9286 #if 0
9287  NODE *node = (yyvsp[(1) - (1)].val);
9288  if (!node) {
9289  node = new_str(STR_NEW0(), (yylsp[(1) - (1)]).first_column);
9290  }
9291  else {
9292  node = evstr2dstr(node, (yylsp[(1) - (1)]).first_column);
9293  }
9294  (yyval.val) = node;
9295 #endif
9296  (yyval.val) = (yyvsp[(1) - (1)].val);
9297 
9298  ;}
9299  break;
9300 
9301  case 466:
9302 #line 3807 "ripper.y"
9303  {
9304 #if 0
9305  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
9306 #endif
9307 
9308  ;}
9309  break;
9310 
9311  case 468:
9312 #line 3815 "ripper.y"
9313  {
9314 #if 0
9315  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
9316 #endif
9317  (yyval.val) = dispatch2(string_concat, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9318 
9319  ;}
9320  break;
9321 
9322  case 469:
9323 #line 3825 "ripper.y"
9324  {
9325  (yyval.val) = new_string1(heredoc_dedent((yyvsp[(2) - (3)].val)));
9326  ;}
9327  break;
9328 
9329  case 470:
9330 #line 3831 "ripper.y"
9331  {
9332  (yyval.val) = new_xstring(heredoc_dedent((yyvsp[(2) - (3)].val)), (yylsp[(1) - (3)]).first_column);
9333  ;}
9334  break;
9335 
9336  case 471:
9337 #line 3837 "ripper.y"
9338  {
9339  (yyval.val) = new_regexp((yyvsp[(2) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
9340  ;}
9341  break;
9342 
9343  case 472:
9344 #line 3843 "ripper.y"
9345  {
9346 #if 0
9347  (yyval.val) = new_zarray((yylsp[(1) - (3)]).first_column);
9348 #endif
9349  (yyval.val) = dispatch0(words_new);
9350  (yyval.val) = dispatch1(array, (yyval.val));
9351 
9352  ;}
9353  break;
9354 
9355  case 473:
9356 #line 3852 "ripper.y"
9357  {
9358 #if 0
9359  (yyval.val) = (yyvsp[(2) - (3)].val);
9360 #endif
9361  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9362 
9363  ;}
9364  break;
9365 
9366  case 474:
9367 #line 3862 "ripper.y"
9368  {
9369 #if 0
9370  (yyval.val) = 0;
9371 #endif
9372  (yyval.val) = dispatch0(words_new);
9373 
9374  ;}
9375  break;
9376 
9377  case 475:
9378 #line 3870 "ripper.y"
9379  {
9380 #if 0
9381  (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val), (yylsp[(1) - (3)]).first_column), (yylsp[(1) - (3)]).first_column);
9382 #endif
9383  (yyval.val) = dispatch2(words_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9384 
9385  ;}
9386  break;
9387 
9388  case 476:
9389 #line 3882 "ripper.y"
9390  {
9391  (yyval.val) = dispatch0(word_new);
9392  (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
9393  ;}
9394  break;
9395 
9396  case 477:
9397 #line 3888 "ripper.y"
9398  {
9399 #if 0
9400  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
9401 #endif
9402  (yyval.val) = dispatch2(word_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9403 
9404  ;}
9405  break;
9406 
9407  case 478:
9408 #line 3898 "ripper.y"
9409  {
9410 #if 0
9411  (yyval.val) = new_zarray((yylsp[(1) - (3)]).first_column);
9412 #endif
9413  (yyval.val) = dispatch0(symbols_new);
9414  (yyval.val) = dispatch1(array, (yyval.val));
9415 
9416  ;}
9417  break;
9418 
9419  case 479:
9420 #line 3907 "ripper.y"
9421  {
9422 #if 0
9423  (yyval.val) = (yyvsp[(2) - (3)].val);
9424 #endif
9425  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9426 
9427  ;}
9428  break;
9429 
9430  case 480:
9431 #line 3917 "ripper.y"
9432  {
9433 #if 0
9434  (yyval.val) = 0;
9435 #endif
9436  (yyval.val) = dispatch0(symbols_new);
9437 
9438  ;}
9439  break;
9440 
9441  case 481:
9442 #line 3925 "ripper.y"
9443  {
9444 #if 0
9445  (yyvsp[(2) - (3)].val) = evstr2dstr((yyvsp[(2) - (3)].val), (yylsp[(1) - (3)]).first_column);
9446  if (nd_type((yyvsp[(2) - (3)].val)) == NODE_DSTR) {
9447  nd_set_type((yyvsp[(2) - (3)].val), NODE_DSYM);
9448  }
9449  else {
9450  nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
9451  (yyvsp[(2) - (3)].val)->nd_lit = rb_str_intern((yyvsp[(2) - (3)].val)->nd_lit);
9452  }
9453  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yylsp[(1) - (3)]).first_column);
9454 #endif
9455  (yyval.val) = dispatch2(symbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9456 
9457  ;}
9458  break;
9459 
9460  case 482:
9461 #line 3943 "ripper.y"
9462  {
9463 #if 0
9464  (yyval.val) = new_zarray((yylsp[(1) - (3)]).first_column);
9465 #endif
9466  (yyval.val) = dispatch0(qwords_new);
9467  (yyval.val) = dispatch1(array, (yyval.val));
9468 
9469  ;}
9470  break;
9471 
9472  case 483:
9473 #line 3952 "ripper.y"
9474  {
9475 #if 0
9476  (yyval.val) = (yyvsp[(2) - (3)].val);
9477 #endif
9478  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9479 
9480  ;}
9481  break;
9482 
9483  case 484:
9484 #line 3962 "ripper.y"
9485  {
9486 #if 0
9487  (yyval.val) = new_zarray((yylsp[(1) - (3)]).first_column);
9488 #endif
9489  (yyval.val) = dispatch0(qsymbols_new);
9490  (yyval.val) = dispatch1(array, (yyval.val));
9491 
9492  ;}
9493  break;
9494 
9495  case 485:
9496 #line 3971 "ripper.y"
9497  {
9498 #if 0
9499  (yyval.val) = (yyvsp[(2) - (3)].val);
9500 #endif
9501  (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
9502 
9503  ;}
9504  break;
9505 
9506  case 486:
9507 #line 3981 "ripper.y"
9508  {
9509 #if 0
9510  (yyval.val) = 0;
9511 #endif
9512  (yyval.val) = dispatch0(qwords_new);
9513 
9514  ;}
9515  break;
9516 
9517  case 487:
9518 #line 3989 "ripper.y"
9519  {
9520 #if 0
9521  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yylsp[(1) - (3)]).first_column);
9522  nd_set_column((yyvsp[(2) - (3)].val), (yylsp[(1) - (3)]).first_column);
9523 #endif
9524  (yyval.val) = dispatch2(qwords_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9525 
9526  ;}
9527  break;
9528 
9529  case 488:
9530 #line 4000 "ripper.y"
9531  {
9532 #if 0
9533  (yyval.val) = 0;
9534 #endif
9535  (yyval.val) = dispatch0(qsymbols_new);
9536 
9537  ;}
9538  break;
9539 
9540  case 489:
9541 #line 4008 "ripper.y"
9542  {
9543 #if 0
9544  VALUE lit;
9545  lit = (yyvsp[(2) - (3)].val)->nd_lit;
9546  (yyvsp[(2) - (3)].val)->nd_lit = ID2SYM(rb_intern_str(lit));
9547  nd_set_type((yyvsp[(2) - (3)].val), NODE_LIT);
9548  (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val), (yylsp[(1) - (3)]).first_column);
9549  nd_set_column((yyvsp[(2) - (3)].val), (yylsp[(1) - (3)]).first_column);
9550 #endif
9551  (yyval.val) = dispatch2(qsymbols_add, (yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9552 
9553  ;}
9554  break;
9555 
9556  case 490:
9557 #line 4023 "ripper.y"
9558  {
9559 #if 0
9560  (yyval.val) = 0;
9561 #endif
9562  (yyval.val) = dispatch0(string_content);
9563 
9564  ;}
9565  break;
9566 
9567  case 491:
9568 #line 4031 "ripper.y"
9569  {
9570 #if 0
9571  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
9572 #endif
9573  (yyval.val) = dispatch2(string_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9574 
9575  ;}
9576  break;
9577 
9578  case 492:
9579 #line 4041 "ripper.y"
9580  {
9581 #if 0
9582  (yyval.val) = 0;
9583 #endif
9584  (yyval.val) = dispatch0(xstring_new);
9585 
9586  ;}
9587  break;
9588 
9589  case 493:
9590 #line 4049 "ripper.y"
9591  {
9592 #if 0
9593  (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
9594 #endif
9595  (yyval.val) = dispatch2(xstring_add, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9596 
9597  ;}
9598  break;
9599 
9600  case 494:
9601 #line 4059 "ripper.y"
9602  {
9603 #if 0
9604  (yyval.val) = 0;
9605 #endif
9606  (yyval.val) = ripper_new_yylval(0, dispatch0(regexp_new), 0);
9607 
9608  ;}
9609  break;
9610 
9611  case 495:
9612 #line 4067 "ripper.y"
9613  {
9614 #if 0
9615  NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
9616  if (!head) {
9617  (yyval.val) = tail;
9618  }
9619  else if (!tail) {
9620  (yyval.val) = head;
9621  }
9622  else {
9623  switch (nd_type(head)) {
9624  case NODE_STR:
9625  nd_set_type(head, NODE_DSTR);
9626  break;
9627  case NODE_DSTR:
9628  break;
9629  default:
9630  head = list_append(new_dstr(Qnil, (yylsp[(1) - (2)]).first_column), head, (yylsp[(1) - (2)]).first_column);
9631  break;
9632  }
9633  (yyval.val) = list_append(head, tail, (yylsp[(1) - (2)]).first_column);
9634  }
9635 #endif
9636  VALUE s1 = 1, s2 = 0, n1 = (yyvsp[(1) - (2)].val), n2 = (yyvsp[(2) - (2)].val);
9637  if (ripper_is_node_yylval(n1)) {
9638  s1 = RNODE(n1)->nd_cval;
9639  n1 = RNODE(n1)->nd_rval;
9640  }
9641  if (ripper_is_node_yylval(n2)) {
9642  s2 = RNODE(n2)->nd_cval;
9643  n2 = RNODE(n2)->nd_rval;
9644  }
9645  (yyval.val) = dispatch2(regexp_add, n1, n2);
9646  if (!s1 && s2) {
9647  (yyval.val) = ripper_new_yylval(0, (yyval.val), s2);
9648  }
9649 
9650  ;}
9651  break;
9652 
9653  case 496:
9654 #line 4108 "ripper.y"
9655  {
9656 #if 0
9657  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
9658 #endif
9659 
9660  ;}
9661  break;
9662 
9663  case 497:
9664 #line 4115 "ripper.y"
9665  {
9666  (yyval.node) = lex_strterm;
9667  lex_strterm = 0;
9668  SET_LEX_STATE(EXPR_BEG);
9669  ;}
9670  break;
9671 
9672  case 498:
9673 #line 4121 "ripper.y"
9674  {
9675  lex_strterm = (yyvsp[(2) - (3)].node);
9676 #if 0
9677  (yyval.val) = NEW_EVSTR((yyvsp[(3) - (3)].val));
9678  nd_set_column((yyval.val), (yylsp[(1) - (3)]).first_column);
9679 #endif
9680  (yyval.val) = dispatch1(string_dvar, (yyvsp[(3) - (3)].val));
9681 
9682  ;}
9683  break;
9684 
9685  case 499:
9686 #line 4131 "ripper.y"
9687  {
9688  (yyvsp[(1) - (1)].val) = cond_stack;
9689  (yyval.val) = cmdarg_stack;
9690  COND_SET(0);
9691  CMDARG_SET(0);
9692  ;}
9693  break;
9694 
9695  case 500:
9696 #line 4137 "ripper.y"
9697  {
9698  (yyval.node) = lex_strterm;
9699  lex_strterm = 0;
9700  ;}
9701  break;
9702 
9703  case 501:
9704 #line 4141 "ripper.y"
9705  {
9706  (yyval.num) = lex_state;
9707  SET_LEX_STATE(EXPR_BEG);
9708  ;}
9709  break;
9710 
9711  case 502:
9712 #line 4145 "ripper.y"
9713  {
9714  (yyval.num) = brace_nest;
9715  brace_nest = 0;
9716  ;}
9717  break;
9718 
9719  case 503:
9720 #line 4149 "ripper.y"
9721  {
9722  (yyval.num) = heredoc_indent;
9723  heredoc_indent = 0;
9724  ;}
9725  break;
9726 
9727  case 504:
9728 #line 4154 "ripper.y"
9729  {
9730  COND_SET((yyvsp[(1) - (8)].val));
9731  CMDARG_SET((yyvsp[(2) - (8)].val));
9732  lex_strterm = (yyvsp[(3) - (8)].node);
9733  SET_LEX_STATE((yyvsp[(4) - (8)].num));
9734  brace_nest = (yyvsp[(5) - (8)].num);
9735  heredoc_indent = (yyvsp[(6) - (8)].num);
9736  heredoc_line_indent = -1;
9737 #if 0
9738  if ((yyvsp[(7) - (8)].val)) (yyvsp[(7) - (8)].val)->flags &= ~NODE_FL_NEWLINE;
9739  (yyval.val) = new_evstr((yyvsp[(7) - (8)].val), (yylsp[(1) - (8)]).first_column);
9740 #endif
9741  (yyval.val) = dispatch1(string_embexpr, (yyvsp[(7) - (8)].val));
9742 
9743  ;}
9744  break;
9745 
9746  case 505:
9747 #line 4172 "ripper.y"
9748  {
9749 #if 0
9750  (yyval.val) = new_gvar((yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column);
9751 #endif
9752  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
9753 
9754  ;}
9755  break;
9756 
9757  case 506:
9758 #line 4180 "ripper.y"
9759  {
9760 #if 0
9761  (yyval.val) = new_ivar((yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column);
9762 #endif
9763  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
9764 
9765  ;}
9766  break;
9767 
9768  case 507:
9769 #line 4188 "ripper.y"
9770  {
9771 #if 0
9772  (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
9773  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
9774 #endif
9775  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
9776 
9777  ;}
9778  break;
9779 
9780  case 509:
9781 #line 4200 "ripper.y"
9782  {
9783  SET_LEX_STATE(EXPR_END|EXPR_ENDARG);
9784 #if 0
9785  (yyval.val) = (yyvsp[(2) - (2)].val);
9786 #endif
9787  (yyval.val) = dispatch1(symbol, (yyvsp[(2) - (2)].val));
9788 
9789  ;}
9790  break;
9791 
9792  case 514:
9793 #line 4217 "ripper.y"
9794  {
9795  SET_LEX_STATE(EXPR_END|EXPR_ENDARG);
9796 #if 0
9797  (yyval.val) = dsym_node((yyvsp[(2) - (3)].val), (yylsp[(1) - (3)]).first_column);
9798 #endif
9799  (yyval.val) = dispatch1(dyna_symbol, (yyvsp[(2) - (3)].val));
9800 
9801  ;}
9802  break;
9803 
9804  case 516:
9805 #line 4229 "ripper.y"
9806  {
9807 #if 0
9808  (yyval.val) = (yyvsp[(2) - (2)].val);
9809  (yyval.val)->nd_lit = negate_lit((yyval.val)->nd_lit);
9810 #endif
9811  (yyval.val) = dispatch2(unary, ID2VAL(idUMinus), (yyvsp[(2) - (2)].val));
9812 
9813  ;}
9814  break;
9815 
9816  case 517:
9817 #line 4240 "ripper.y"
9818  {
9819 #if 0
9820  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
9821 #endif
9822 
9823  ;}
9824  break;
9825 
9826  case 518:
9827 #line 4247 "ripper.y"
9828  {
9829 #if 0
9830  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
9831 #endif
9832 
9833  ;}
9834  break;
9835 
9836  case 519:
9837 #line 4254 "ripper.y"
9838  {
9839 #if 0
9840  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
9841 #endif
9842 
9843  ;}
9844  break;
9845 
9846  case 520:
9847 #line 4261 "ripper.y"
9848  {
9849 #if 0
9850  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
9851 #endif
9852 
9853  ;}
9854  break;
9855 
9856  case 526:
9857 #line 4276 "ripper.y"
9858  {(yyval.val) = KWD2EID(nil, (yyvsp[(1) - (1)].val));;}
9859  break;
9860 
9861  case 527:
9862 #line 4277 "ripper.y"
9863  {(yyval.val) = KWD2EID(self, (yyvsp[(1) - (1)].val));;}
9864  break;
9865 
9866  case 528:
9867 #line 4278 "ripper.y"
9868  {(yyval.val) = KWD2EID(true, (yyvsp[(1) - (1)].val));;}
9869  break;
9870 
9871  case 529:
9872 #line 4279 "ripper.y"
9873  {(yyval.val) = KWD2EID(false, (yyvsp[(1) - (1)].val));;}
9874  break;
9875 
9876  case 530:
9877 #line 4280 "ripper.y"
9878  {(yyval.val) = KWD2EID(_FILE__, (yyvsp[(1) - (1)].val));;}
9879  break;
9880 
9881  case 531:
9882 #line 4281 "ripper.y"
9883  {(yyval.val) = KWD2EID(_LINE__, (yyvsp[(1) - (1)].val));;}
9884  break;
9885 
9886  case 532:
9887 #line 4282 "ripper.y"
9888  {(yyval.val) = KWD2EID(_ENCODING__, (yyvsp[(1) - (1)].val));;}
9889  break;
9890 
9891  case 533:
9892 #line 4286 "ripper.y"
9893  {
9894 #if 0
9895  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column))) (yyval.val) = new_begin(0, (yylsp[(1) - (1)]).first_column);
9896 #endif
9897  if (id_is_var(get_id((yyvsp[(1) - (1)].val)))) {
9898  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
9899  }
9900  else {
9901  (yyval.val) = dispatch1(vcall, (yyvsp[(1) - (1)].val));
9902  }
9903 
9904  ;}
9905  break;
9906 
9907  case 534:
9908 #line 4299 "ripper.y"
9909  {
9910 #if 0
9911  if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column))) (yyval.val) = new_begin(0, (yylsp[(1) - (1)]).first_column);
9912 #endif
9913  (yyval.val) = dispatch1(var_ref, (yyvsp[(1) - (1)].val));
9914 
9915  ;}
9916  break;
9917 
9918  case 535:
9919 #line 4309 "ripper.y"
9920  {
9921  (yyval.val) = assignable(var_field((yyvsp[(1) - (1)].val)), 0, (yylsp[(1) - (1)]).first_column);
9922  ;}
9923  break;
9924 
9925  case 536:
9926 #line 4313 "ripper.y"
9927  {
9928  (yyval.val) = assignable(var_field((yyvsp[(1) - (1)].val)), 0, (yylsp[(1) - (1)]).first_column);
9929  ;}
9930  break;
9931 
9932  case 537:
9933 #line 4319 "ripper.y"
9934  {
9935 #if 0
9936  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
9937 #endif
9938 
9939  ;}
9940  break;
9941 
9942  case 538:
9943 #line 4326 "ripper.y"
9944  {
9945 #if 0
9946  nd_set_column((yyval.val), (yylsp[(1) - (1)]).first_column);
9947 #endif
9948 
9949  ;}
9950  break;
9951 
9952  case 539:
9953 #line 4335 "ripper.y"
9954  {
9955  SET_LEX_STATE(EXPR_BEG);
9956  command_start = TRUE;
9957  ;}
9958  break;
9959 
9960  case 540:
9961 #line 4340 "ripper.y"
9962  {
9963  (yyval.val) = (yyvsp[(3) - (4)].val);
9964  ;}
9965  break;
9966 
9967  case 541:
9968 #line 4344 "ripper.y"
9969  {
9970 #if 0
9971  (yyval.val) = 0;
9972 #endif
9973  (yyval.val) = Qnil;
9974 
9975  ;}
9976  break;
9977 
9978  case 542:
9979 #line 4354 "ripper.y"
9980  {
9981 #if 0
9982  (yyval.val) = (yyvsp[(2) - (3)].val);
9983 #endif
9984  (yyval.val) = dispatch1(paren, (yyvsp[(2) - (3)].val));
9985 
9986  SET_LEX_STATE(EXPR_BEG);
9987  command_start = TRUE;
9988  ;}
9989  break;
9990 
9991  case 543:
9992 #line 4363 "ripper.y"
9993  {
9994  (yyval.num) = parser->in_kwarg;
9995  parser->in_kwarg = 1;
9996  SET_LEX_STATE(lex_state|EXPR_LABEL); /* force for args */
9997  ;}
9998  break;
9999 
10000  case 544:
10001 #line 4369 "ripper.y"
10002  {
10003  parser->in_kwarg = !!(yyvsp[(1) - (3)].num);
10004  (yyval.val) = (yyvsp[(2) - (3)].val);
10005  SET_LEX_STATE(EXPR_BEG);
10006  command_start = TRUE;
10007  ;}
10008  break;
10009 
10010  case 545:
10011 #line 4378 "ripper.y"
10012  {
10013  (yyval.val) = new_args_tail((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
10014  ;}
10015  break;
10016 
10017  case 546:
10018 #line 4382 "ripper.y"
10019  {
10020  (yyval.val) = new_args_tail((yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
10021  ;}
10022  break;
10023 
10024  case 547:
10025 #line 4386 "ripper.y"
10026  {
10027  (yyval.val) = new_args_tail(Qnone, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
10028  ;}
10029  break;
10030 
10031  case 548:
10032 #line 4390 "ripper.y"
10033  {
10034  (yyval.val) = new_args_tail(Qnone, Qnone, (yyvsp[(1) - (1)].val), (yylsp[(1) - (1)]).first_column);
10035  ;}
10036  break;
10037 
10038  case 549:
10039 #line 4396 "ripper.y"
10040  {
10041  (yyval.val) = (yyvsp[(2) - (2)].val);
10042  ;}
10043  break;
10044 
10045  case 550:
10046 #line 4400 "ripper.y"
10047  {
10048  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone, (yylsp[(0) - (0)]).first_column);
10049  ;}
10050  break;
10051 
10052  case 551:
10053 #line 4406 "ripper.y"
10054  {
10055  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), Qnone, (yyvsp[(6) - (6)].val));
10056  ;}
10057  break;
10058 
10059  case 552:
10060 #line 4410 "ripper.y"
10061  {
10062  (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10063  ;}
10064  break;
10065 
10066  case 553:
10067 #line 4414 "ripper.y"
10068  {
10069  (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, Qnone, (yyvsp[(4) - (4)].val));
10070  ;}
10071  break;
10072 
10073  case 554:
10074 #line 4418 "ripper.y"
10075  {
10076  (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), Qnone, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10077  ;}
10078  break;
10079 
10080  case 555:
10081 #line 4422 "ripper.y"
10082  {
10083  (yyval.val) = new_args((yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10084  ;}
10085  break;
10086 
10087  case 556:
10088 #line 4426 "ripper.y"
10089  {
10090  (yyval.val) = new_args((yyvsp[(1) - (6)].val), Qnone, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10091  ;}
10092  break;
10093 
10094  case 557:
10095 #line 4430 "ripper.y"
10096  {
10097  (yyval.val) = new_args((yyvsp[(1) - (2)].val), Qnone, Qnone, Qnone, (yyvsp[(2) - (2)].val));
10098  ;}
10099  break;
10100 
10101  case 558:
10102 #line 4434 "ripper.y"
10103  {
10104  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), Qnone, (yyvsp[(4) - (4)].val));
10105  ;}
10106  break;
10107 
10108  case 559:
10109 #line 4438 "ripper.y"
10110  {
10111  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10112  ;}
10113  break;
10114 
10115  case 560:
10116 #line 4442 "ripper.y"
10117  {
10118  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (2)].val), Qnone, Qnone, (yyvsp[(2) - (2)].val));
10119  ;}
10120  break;
10121 
10122  case 561:
10123 #line 4446 "ripper.y"
10124  {
10125  (yyval.val) = new_args(Qnone, (yyvsp[(1) - (4)].val), Qnone, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10126  ;}
10127  break;
10128 
10129  case 562:
10130 #line 4450 "ripper.y"
10131  {
10132  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (2)].val), Qnone, (yyvsp[(2) - (2)].val));
10133  ;}
10134  break;
10135 
10136  case 563:
10137 #line 4454 "ripper.y"
10138  {
10139  (yyval.val) = new_args(Qnone, Qnone, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10140  ;}
10141  break;
10142 
10143  case 564:
10144 #line 4458 "ripper.y"
10145  {
10146  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyvsp[(1) - (1)].val));
10147  ;}
10148  break;
10149 
10150  case 565:
10151 #line 4462 "ripper.y"
10152  {
10153  (yyval.val) = new_args_tail(Qnone, Qnone, Qnone, (yylsp[(0) - (0)]).first_column);
10154  (yyval.val) = new_args(Qnone, Qnone, Qnone, Qnone, (yyval.val));
10155  ;}
10156  break;
10157 
10158  case 566:
10159 #line 4469 "ripper.y"
10160  {
10161 #if 0
10162  yyerror0("formal argument cannot be a constant");
10163  (yyval.val) = 0;
10164 #endif
10165  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10166  ripper_error();
10167 
10168  ;}
10169  break;
10170 
10171  case 567:
10172 #line 4479 "ripper.y"
10173  {
10174 #if 0
10175  yyerror0("formal argument cannot be an instance variable");
10176  (yyval.val) = 0;
10177 #endif
10178  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10179  ripper_error();
10180 
10181  ;}
10182  break;
10183 
10184  case 568:
10185 #line 4489 "ripper.y"
10186  {
10187 #if 0
10188  yyerror0("formal argument cannot be a global variable");
10189  (yyval.val) = 0;
10190 #endif
10191  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10192  ripper_error();
10193 
10194  ;}
10195  break;
10196 
10197  case 569:
10198 #line 4499 "ripper.y"
10199  {
10200 #if 0
10201  yyerror0("formal argument cannot be a class variable");
10202  (yyval.val) = 0;
10203 #endif
10204  (yyval.val) = dispatch1(param_error, (yyvsp[(1) - (1)].val));
10205  ripper_error();
10206 
10207  ;}
10208  break;
10209 
10210  case 571:
10211 #line 4512 "ripper.y"
10212  {
10213  formal_argument(get_id((yyvsp[(1) - (1)].val)));
10214  (yyval.val) = (yyvsp[(1) - (1)].val);
10215  ;}
10216  break;
10217 
10218  case 572:
10219 #line 4519 "ripper.y"
10220  {
10221  ID id = get_id((yyvsp[(1) - (1)].val));
10222  arg_var(id);
10223  current_arg = id;
10224  (yyval.val) = (yyvsp[(1) - (1)].val);
10225  ;}
10226  break;
10227 
10228  case 573:
10229 #line 4528 "ripper.y"
10230  {
10231  current_arg = 0;
10232 #if 0
10233  (yyval.val) = NEW_ARGS_AUX((yyvsp[(1) - (1)].val), 1);
10234 #endif
10235  (yyval.val) = get_value((yyvsp[(1) - (1)].val));
10236 
10237  ;}
10238  break;
10239 
10240  case 574:
10241 #line 4537 "ripper.y"
10242  {
10243  ID tid = internal_id();
10244  arg_var(tid);
10245 #if 0
10246  if (dyna_in_block()) {
10247  (yyvsp[(2) - (3)].val)->nd_value = new_dvar(tid, (yylsp[(1) - (3)]).first_column);
10248  }
10249  else {
10250  (yyvsp[(2) - (3)].val)->nd_value = new_lvar(tid, (yylsp[(1) - (3)]).first_column);
10251  }
10252  (yyval.val) = NEW_ARGS_AUX(tid, 1);
10253  (yyval.val)->nd_next = (yyvsp[(2) - (3)].val);
10254 #endif
10255  (yyval.val) = dispatch1(mlhs_paren, (yyvsp[(2) - (3)].val));
10256 
10257  ;}
10258  break;
10259 
10260  case 575:
10261 #line 4558 "ripper.y"
10262  {
10263  (yyval.val) = rb_ary_new3(1, get_value((yyvsp[(1) - (1)].val)));
10264  ;}
10265  break;
10266 
10267  case 576:
10268 #line 4563 "ripper.y"
10269  {
10270 #if 0
10271  (yyval.val) = (yyvsp[(1) - (3)].val);
10272  (yyval.val)->nd_plen++;
10273  (yyval.val)->nd_next = block_append((yyval.val)->nd_next, (yyvsp[(3) - (3)].val)->nd_next, (yylsp[(1) - (3)]).first_column);
10274  rb_gc_force_recycle((VALUE)(yyvsp[(3) - (3)].val));
10275 #endif
10276  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), get_value((yyvsp[(3) - (3)].val)));
10277 
10278  ;}
10279  break;
10280 
10281  case 577:
10282 #line 4577 "ripper.y"
10283  {
10284  ID id = get_id((yyvsp[(1) - (1)].val));
10285  arg_var(formal_argument(id));
10286  current_arg = id;
10287  (yyval.val) = (yyvsp[(1) - (1)].val);
10288  ;}
10289  break;
10290 
10291  case 578:
10292 #line 4586 "ripper.y"
10293  {
10294  current_arg = 0;
10295  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
10296 #if 0
10297  (yyval.val) = new_kw_arg((yyval.val), (yylsp[(1) - (2)]).first_column);
10298 #endif
10299  (yyval.val) = rb_assoc_new(get_value((yyval.val)), get_value((yyvsp[(2) - (2)].val)));
10300 
10301  ;}
10302  break;
10303 
10304  case 579:
10305 #line 4596 "ripper.y"
10306  {
10307  current_arg = 0;
10308  (yyval.val) = assignable((yyvsp[(1) - (1)].val), (NODE *)-1, (yylsp[(1) - (1)]).first_column);
10309 #if 0
10310  (yyval.val) = new_kw_arg((yyval.val), (yylsp[(1) - (1)]).first_column);
10311 #endif
10312  (yyval.val) = rb_assoc_new(get_value((yyval.val)), 0);
10313 
10314  ;}
10315  break;
10316 
10317  case 580:
10318 #line 4608 "ripper.y"
10319  {
10320  (yyval.val) = assignable((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
10321 #if 0
10322  (yyval.val) = new_kw_arg((yyval.val), (yylsp[(1) - (2)]).first_column);
10323 #endif
10324  (yyval.val) = rb_assoc_new(get_value((yyval.val)), get_value((yyvsp[(2) - (2)].val)));
10325 
10326  ;}
10327  break;
10328 
10329  case 581:
10330 #line 4617 "ripper.y"
10331  {
10332  (yyval.val) = assignable((yyvsp[(1) - (1)].val), (NODE *)-1, (yylsp[(1) - (1)]).first_column);
10333 #if 0
10334  (yyval.val) = new_kw_arg((yyval.val), (yylsp[(1) - (1)]).first_column);
10335 #endif
10336  (yyval.val) = rb_assoc_new(get_value((yyval.val)), 0);
10337 
10338  ;}
10339  break;
10340 
10341  case 582:
10342 #line 4628 "ripper.y"
10343  {
10344 #if 0
10345  (yyval.val) = (yyvsp[(1) - (1)].val);
10346 #endif
10347  (yyval.val) = rb_ary_new3(1, get_value((yyvsp[(1) - (1)].val)));
10348 
10349  ;}
10350  break;
10351 
10352  case 583:
10353 #line 4636 "ripper.y"
10354  {
10355 #if 0
10356  (yyval.val) = kwd_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10357 #endif
10358  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), get_value((yyvsp[(3) - (3)].val)));
10359 
10360  ;}
10361  break;
10362 
10363  case 584:
10364 #line 4647 "ripper.y"
10365  {
10366 #if 0
10367  (yyval.val) = (yyvsp[(1) - (1)].val);
10368 #endif
10369  (yyval.val) = rb_ary_new3(1, get_value((yyvsp[(1) - (1)].val)));
10370 
10371  ;}
10372  break;
10373 
10374  case 585:
10375 #line 4655 "ripper.y"
10376  {
10377 #if 0
10378  (yyval.val) = kwd_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10379 #endif
10380  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), get_value((yyvsp[(3) - (3)].val)));
10381 
10382  ;}
10383  break;
10384 
10385  case 588:
10386 #line 4669 "ripper.y"
10387  {
10388  shadowing_lvar(get_id((yyvsp[(2) - (2)].val)));
10389 #if 0
10390  (yyval.val) = (yyvsp[(2) - (2)].val);
10391 #endif
10392  (yyval.val) = dispatch1(kwrest_param, (yyvsp[(2) - (2)].val));
10393 
10394  ;}
10395  break;
10396 
10397  case 589:
10398 #line 4678 "ripper.y"
10399  {
10400 #if 0
10401  (yyval.val) = internal_id();
10402  arg_var((yyval.val));
10403 #endif
10404  (yyval.val) = dispatch1(kwrest_param, Qnil);
10405 
10406  ;}
10407  break;
10408 
10409  case 590:
10410 #line 4689 "ripper.y"
10411  {
10412  current_arg = 0;
10413  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
10414 #if 0
10415  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10416  nd_set_column((yyval.val), (yylsp[(1) - (3)]).first_column);
10417 #endif
10418  (yyval.val) = rb_assoc_new(get_value((yyval.val)), get_value((yyvsp[(3) - (3)].val)));
10419 
10420  ;}
10421  break;
10422 
10423  case 591:
10424 #line 4702 "ripper.y"
10425  {
10426  current_arg = 0;
10427  (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
10428 #if 0
10429  (yyval.val) = NEW_OPT_ARG(0, (yyval.val));
10430  nd_set_column((yyval.val), (yylsp[(1) - (3)]).first_column);
10431 #endif
10432  (yyval.val) = rb_assoc_new(get_value((yyval.val)), get_value((yyvsp[(3) - (3)].val)));
10433 
10434  ;}
10435  break;
10436 
10437  case 592:
10438 #line 4715 "ripper.y"
10439  {
10440 #if 0
10441  (yyval.val) = (yyvsp[(1) - (1)].val);
10442 #endif
10443  (yyval.val) = rb_ary_new3(1, get_value((yyvsp[(1) - (1)].val)));
10444 
10445  ;}
10446  break;
10447 
10448  case 593:
10449 #line 4723 "ripper.y"
10450  {
10451 #if 0
10452  NODE *opts = (yyvsp[(1) - (3)].val);
10453 
10454  while (opts->nd_next) {
10455  opts = opts->nd_next;
10456  }
10457  opts->nd_next = (yyvsp[(3) - (3)].val);
10458  (yyval.val) = (yyvsp[(1) - (3)].val);
10459 #endif
10460  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), get_value((yyvsp[(3) - (3)].val)));
10461 
10462  ;}
10463  break;
10464 
10465  case 594:
10466 #line 4739 "ripper.y"
10467  {
10468 #if 0
10469  (yyval.val) = (yyvsp[(1) - (1)].val);
10470 #endif
10471  (yyval.val) = rb_ary_new3(1, get_value((yyvsp[(1) - (1)].val)));
10472 
10473  ;}
10474  break;
10475 
10476  case 595:
10477 #line 4747 "ripper.y"
10478  {
10479 #if 0
10480  NODE *opts = (yyvsp[(1) - (3)].val);
10481 
10482  while (opts->nd_next) {
10483  opts = opts->nd_next;
10484  }
10485  opts->nd_next = (yyvsp[(3) - (3)].val);
10486  (yyval.val) = (yyvsp[(1) - (3)].val);
10487 #endif
10488  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), get_value((yyvsp[(3) - (3)].val)));
10489 
10490  ;}
10491  break;
10492 
10493  case 598:
10494 #line 4767 "ripper.y"
10495  {
10496 #if 0
10497  if (!is_local_id((yyvsp[(2) - (2)].val)))
10498  yyerror0("rest argument must be local variable");
10499 #endif
10500  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10501 #if 0
10502  (yyval.val) = (yyvsp[(2) - (2)].val);
10503 #endif
10504  (yyval.val) = dispatch1(rest_param, (yyvsp[(2) - (2)].val));
10505 
10506  ;}
10507  break;
10508 
10509  case 599:
10510 #line 4780 "ripper.y"
10511  {
10512 #if 0
10513  (yyval.val) = internal_id();
10514  arg_var((yyval.val));
10515 #endif
10516  (yyval.val) = dispatch1(rest_param, Qnil);
10517 
10518  ;}
10519  break;
10520 
10521  case 602:
10522 #line 4795 "ripper.y"
10523  {
10524 #if 0
10525  if (!is_local_id((yyvsp[(2) - (2)].val)))
10526  yyerror0("block argument must be local variable");
10527  else if (!dyna_in_block() && local_id((yyvsp[(2) - (2)].val)))
10528  yyerror0("duplicated block argument name");
10529 #endif
10530  arg_var(shadowing_lvar(get_id((yyvsp[(2) - (2)].val))));
10531 #if 0
10532  (yyval.val) = (yyvsp[(2) - (2)].val);
10533 #endif
10534  (yyval.val) = dispatch1(blockarg, (yyvsp[(2) - (2)].val));
10535 
10536  ;}
10537  break;
10538 
10539  case 603:
10540 #line 4812 "ripper.y"
10541  {
10542  (yyval.val) = (yyvsp[(2) - (2)].val);
10543  ;}
10544  break;
10545 
10546  case 604:
10547 #line 4816 "ripper.y"
10548  {
10549 #if 0
10550  (yyval.val) = 0;
10551 #endif
10552  (yyval.val) = Qundef;
10553 
10554  ;}
10555  break;
10556 
10557  case 605:
10558 #line 4826 "ripper.y"
10559  {
10560 #if 0
10561  value_expr((yyvsp[(1) - (1)].val));
10562  (yyval.val) = (yyvsp[(1) - (1)].val);
10563  if (!(yyval.val)) (yyval.val) = NEW_NIL();
10564 #endif
10565  (yyval.val) = (yyvsp[(1) - (1)].val);
10566 
10567  ;}
10568  break;
10569 
10570  case 606:
10571 #line 4835 "ripper.y"
10572  {SET_LEX_STATE(EXPR_BEG);;}
10573  break;
10574 
10575  case 607:
10576 #line 4836 "ripper.y"
10577  {
10578 #if 0
10579  if ((yyvsp[(3) - (4)].val) == 0) {
10580  yyerror0("can't define singleton method for ().");
10581  }
10582  else {
10583  switch (nd_type((yyvsp[(3) - (4)].val))) {
10584  case NODE_STR:
10585  case NODE_DSTR:
10586  case NODE_XSTR:
10587  case NODE_DXSTR:
10588  case NODE_DREGX:
10589  case NODE_LIT:
10590  case NODE_ARRAY:
10591  case NODE_ZARRAY:
10592  yyerror0("can't define singleton method for literals");
10593  break;
10594  default:
10595  value_expr((yyvsp[(3) - (4)].val));
10596  break;
10597  }
10598  }
10599  (yyval.val) = (yyvsp[(3) - (4)].val);
10600 #endif
10601  (yyval.val) = dispatch1(paren, (yyvsp[(3) - (4)].val));
10602 
10603  ;}
10604  break;
10605 
10606  case 609:
10607 #line 4867 "ripper.y"
10608  {
10609 #if 0
10610  (yyval.val) = (yyvsp[(1) - (2)].val);
10611 #endif
10612  (yyval.val) = dispatch1(assoclist_from_args, (yyvsp[(1) - (2)].val));
10613 
10614  ;}
10615  break;
10616 
10617  case 610:
10618 #line 4879 "ripper.y"
10619  {
10620  (yyval.val) = rb_ary_new3(1, get_value((yyvsp[(1) - (1)].val)));
10621  ;}
10622  break;
10623 
10624  case 611:
10625 #line 4884 "ripper.y"
10626  {
10627 #if 0
10628  NODE *assocs = (yyvsp[(1) - (3)].val);
10629  NODE *tail = (yyvsp[(3) - (3)].val);
10630  if (!assocs) {
10631  assocs = tail;
10632  }
10633  else if (tail) {
10634  if (assocs->nd_head &&
10635  !tail->nd_head && nd_type(tail->nd_next) == NODE_ARRAY &&
10636  nd_type(tail->nd_next->nd_head) == NODE_HASH) {
10637  /* DSTAR */
10638  tail = tail->nd_next->nd_head->nd_head;
10639  }
10640  assocs = list_concat(assocs, tail);
10641  }
10642  (yyval.val) = assocs;
10643 #endif
10644  (yyval.val) = rb_ary_push((yyvsp[(1) - (3)].val), get_value((yyvsp[(3) - (3)].val)));
10645 
10646  ;}
10647  break;
10648 
10649  case 612:
10650 #line 4908 "ripper.y"
10651  {
10652 #if 0
10653  if (nd_type((yyvsp[(1) - (3)].val)) == NODE_STR) {
10654  nd_set_type((yyvsp[(1) - (3)].val), NODE_LIT);
10655  (yyvsp[(1) - (3)].val)->nd_lit = rb_fstring((yyvsp[(1) - (3)].val)->nd_lit);
10656  }
10657  (yyval.val) = list_append(new_list((yyvsp[(1) - (3)].val), (yylsp[(1) - (3)]).first_column), (yyvsp[(3) - (3)].val), (yylsp[(1) - (3)]).first_column);
10658 #endif
10659  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10660 
10661  ;}
10662  break;
10663 
10664  case 613:
10665 #line 4920 "ripper.y"
10666  {
10667 #if 0
10668  (yyval.val) = list_append(new_list(new_lit(ID2SYM((yyvsp[(1) - (2)].val)), (yylsp[(1) - (2)]).first_column), (yylsp[(1) - (2)]).first_column), (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
10669 #endif
10670  (yyval.val) = dispatch2(assoc_new, (yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
10671 
10672  ;}
10673  break;
10674 
10675  case 614:
10676 #line 4928 "ripper.y"
10677  {
10678 #if 0
10679  (yyval.val) = list_append(new_list(dsym_node((yyvsp[(2) - (4)].val), (yylsp[(1) - (4)]).first_column), (yylsp[(1) - (4)]).first_column), (yyvsp[(4) - (4)].val), (yylsp[(1) - (4)]).first_column);
10680 #endif
10681  (yyval.val) = dispatch2(assoc_new, dispatch1(dyna_symbol, (yyvsp[(2) - (4)].val)), (yyvsp[(4) - (4)].val));
10682 
10683  ;}
10684  break;
10685 
10686  case 615:
10687 #line 4936 "ripper.y"
10688  {
10689 #if 0
10690  if (nd_type((yyvsp[(2) - (2)].val)) == NODE_HASH &&
10691  !((yyvsp[(2) - (2)].val)->nd_head && (yyvsp[(2) - (2)].val)->nd_head->nd_alen))
10692  (yyval.val) = 0;
10693  else
10694  (yyval.val) = list_append(new_list(0, (yylsp[(1) - (2)]).first_column), (yyvsp[(2) - (2)].val), (yylsp[(1) - (2)]).first_column);
10695 #endif
10696  (yyval.val) = dispatch1(assoc_splat, (yyvsp[(2) - (2)].val));
10697 
10698  ;}
10699  break;
10700 
10701  case 628:
10702 #line 4970 "ripper.y"
10703  {
10704  (yyval.val) = TOKEN2VAL('.');
10705  ;}
10706  break;
10707 
10708  case 629:
10709 #line 4974 "ripper.y"
10710  {
10711  (yyval.val) = ID2VAL(idANDDOT);
10712  ;}
10713  break;
10714 
10715  case 631:
10716 #line 4981 "ripper.y"
10717  {
10718  (yyval.val) = ID2VAL(idCOLON2);
10719  ;}
10720  break;
10721 
10722  case 641:
10723 #line 5005 "ripper.y"
10724  {yyerrok;token_flush(parser);;}
10725  break;
10726 
10727  case 642:
10728 #line 5006 "ripper.y"
10729  {token_flush(parser);;}
10730  break;
10731 
10732  case 644:
10733 #line 5010 "ripper.y"
10734  {yyerrok;;}
10735  break;
10736 
10737  case 645:
10738 #line 5014 "ripper.y"
10739  {
10740  (yyval.val) = Qnull;
10741  ;}
10742  break;
10743 
10744 
10745 /* Line 1267 of yacc.c. */
10746 #line 10745 "ripper.c"
10747  default: break;
10748  }
10749  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
10750 
10751  YYPOPSTACK (yylen);
10752  yylen = 0;
10753  YY_STACK_PRINT (yyss, yyssp);
10754 
10755  *++yyvsp = yyval;
10756  *++yylsp = yyloc;
10757 
10758  /* Now `shift' the result of the reduction. Determine what state
10759  that goes to, based on the state we popped back to and the rule
10760  number reduced by. */
10761 
10762  yyn = yyr1[yyn];
10763 
10764  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
10765  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
10766  yystate = yytable[yystate];
10767  else
10768  yystate = yydefgoto[yyn - YYNTOKENS];
10769 
10770  goto yynewstate;
10771 
10772 
10773 /*------------------------------------.
10774 | yyerrlab -- here on detecting error |
10775 `------------------------------------*/
10776 yyerrlab:
10777  /* If not already recovering from an error, report this error. */
10778  if (!yyerrstatus)
10779  {
10780  ++yynerrs;
10781 #if ! YYERROR_VERBOSE
10782  yyerror (&yylloc, parser, YY_("syntax error"));
10783 #else
10784  {
10785  YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
10786  if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
10787  {
10788  YYSIZE_T yyalloc = 2 * yysize;
10789  if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
10790  yyalloc = YYSTACK_ALLOC_MAXIMUM;
10791  if (yymsg != yymsgbuf)
10792  YYSTACK_FREE (yymsg);
10793  yymsg = (char *) YYSTACK_ALLOC (yyalloc);
10794  if (yymsg)
10795  yymsg_alloc = yyalloc;
10796  else
10797  {
10798  yymsg = yymsgbuf;
10799  yymsg_alloc = sizeof yymsgbuf;
10800  }
10801  }
10802 
10803  if (0 < yysize && yysize <= yymsg_alloc)
10804  {
10805  (void) yysyntax_error (yymsg, yystate, yychar);
10806  yyerror (&yylloc, parser, yymsg);
10807  }
10808  else
10809  {
10810  yyerror (&yylloc, parser, YY_("syntax error"));
10811  if (yysize != 0)
10812  goto yyexhaustedlab;
10813  }
10814  }
10815 #endif
10816  }
10817 
10818  yyerror_range[0] = yylloc;
10819 
10820  if (yyerrstatus == 3)
10821  {
10822  /* If just tried and failed to reuse look-ahead token after an
10823  error, discard it. */
10824 
10825  if (yychar <= YYEOF)
10826  {
10827  /* Return failure if at end of input. */
10828  if (yychar == YYEOF)
10829  YYABORT;
10830  }
10831  else
10832  {
10833  yydestruct ("Error: discarding",
10834  yytoken, &yylval, &yylloc, parser);
10835  yychar = YYEMPTY;
10836  }
10837  }
10838 
10839  /* Else will try to reuse look-ahead token after shifting the error
10840  token. */
10841  goto yyerrlab1;
10842 
10843 
10844 /*---------------------------------------------------.
10845 | yyerrorlab -- error raised explicitly by YYERROR. |
10846 `---------------------------------------------------*/
10847 yyerrorlab:
10848 
10849  /* Pacify compilers like GCC when the user code never invokes
10850  YYERROR and the label yyerrorlab therefore never appears in user
10851  code. */
10852  if (/*CONSTCOND*/ 0)
10853  goto yyerrorlab;
10854 
10855  yyerror_range[0] = yylsp[1-yylen];
10856  /* Do not reclaim the symbols of the rule which action triggered
10857  this YYERROR. */
10858  YYPOPSTACK (yylen);
10859  yylen = 0;
10860  YY_STACK_PRINT (yyss, yyssp);
10861  yystate = *yyssp;
10862  goto yyerrlab1;
10863 
10864 
10865 /*-------------------------------------------------------------.
10866 | yyerrlab1 -- common code for both syntax error and YYERROR. |
10867 `-------------------------------------------------------------*/
10868 yyerrlab1:
10869  yyerrstatus = 3; /* Each real token shifted decrements this. */
10870 
10871  for (;;)
10872  {
10873  yyn = yypact[yystate];
10874  if (yyn != YYPACT_NINF)
10875  {
10876  yyn += YYTERROR;
10877  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
10878  {
10879  yyn = yytable[yyn];
10880  if (0 < yyn)
10881  break;
10882  }
10883  }
10884 
10885  /* Pop the current state because it cannot handle the error token. */
10886  if (yyssp == yyss)
10887  YYABORT;
10888 
10889  yyerror_range[0] = *yylsp;
10890  yydestruct ("Error: popping",
10891  yystos[yystate], yyvsp, yylsp, parser);
10892  YYPOPSTACK (1);
10893  yystate = *yyssp;
10894  YY_STACK_PRINT (yyss, yyssp);
10895  }
10896 
10897  if (yyn == YYFINAL)
10898  YYACCEPT;
10899 
10900  *++yyvsp = yylval;
10901 
10902  yyerror_range[1] = yylloc;
10903  /* Using YYLLOC is tempting, but would change the location of
10904  the look-ahead. YYLOC is available though. */
10905  YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
10906  *++yylsp = yyloc;
10907 
10908  /* Shift the error token. */
10909  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
10910 
10911  yystate = yyn;
10912  goto yynewstate;
10913 
10914 
10915 /*-------------------------------------.
10916 | yyacceptlab -- YYACCEPT comes here. |
10917 `-------------------------------------*/
10918 yyacceptlab:
10919  yyresult = 0;
10920  goto yyreturn;
10921 
10922 /*-----------------------------------.
10923 | yyabortlab -- YYABORT comes here. |
10924 `-----------------------------------*/
10925 yyabortlab:
10926  yyresult = 1;
10927  goto yyreturn;
10928 
10929 #ifndef yyoverflow
10930 /*-------------------------------------------------.
10931 | yyexhaustedlab -- memory exhaustion comes here. |
10932 `-------------------------------------------------*/
10933 yyexhaustedlab:
10934  yyerror (&yylloc, parser, YY_("memory exhausted"));
10935  yyresult = 2;
10936  /* Fall through. */
10937 #endif
10938 
10939 yyreturn:
10940  if (yychar != YYEOF && yychar != YYEMPTY)
10941  yydestruct ("Cleanup: discarding lookahead",
10942  yytoken, &yylval, &yylloc, parser);
10943  /* Do not reclaim the symbols of the rule which action triggered
10944  this YYABORT or YYACCEPT. */
10945  YYPOPSTACK (yylen);
10946  YY_STACK_PRINT (yyss, yyssp);
10947  while (yyssp != yyss)
10948  {
10949  yydestruct ("Cleanup: popping",
10950  yystos[*yyssp], yyvsp, yylsp, parser);
10951  YYPOPSTACK (1);
10952  }
10953 #ifndef yyoverflow
10954  if (yyss != yyssa)
10955  YYSTACK_FREE (yyss);
10956 #endif
10957 #if YYERROR_VERBOSE
10958  if (yymsg != yymsgbuf)
10959  YYSTACK_FREE (yymsg);
10960 #endif
10961  /* Make sure YYID is used. */
10962  return YYID (yyresult);
10963 }
10964 
10965 
10966 #line 5018 "ripper.y"
10967 
10968 # undef parser
10969 # undef yylex
10970 # undef yylval
10971 # define yylval (*parser->lval)
10972 
10973 static int parser_regx_options(struct parser_params*);
10974 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
10975 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
10976 static enum yytokentype parser_parse_string(struct parser_params*,NODE*);
10977 static enum yytokentype parser_here_document(struct parser_params*,NODE*);
10978 
10979 
10980 # define nextc() parser_nextc(parser)
10981 # define pushback(c) parser_pushback(parser, (c))
10982 # define newtok() parser_newtok(parser)
10983 # define tokspace(n) parser_tokspace(parser, (n))
10984 # define tokadd(c) parser_tokadd(parser, (c))
10985 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
10986 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
10987 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
10988 # define regx_options() parser_regx_options(parser)
10989 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
10990 # define parse_string(n) parser_parse_string(parser,(n))
10991 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
10992 # define here_document(n) parser_here_document(parser,(n))
10993 # define heredoc_identifier() parser_heredoc_identifier(parser)
10994 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
10995 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
10996 # define number_literal_suffix(f) parser_number_literal_suffix(parser, (f))
10997 # define set_number_literal(v, t, f) parser_set_number_literal(parser, (v), (t), (f))
10998 # define set_integer_literal(v, f) parser_set_integer_literal(parser, (v), (f))
10999 
11000 #ifndef RIPPER
11001 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
11002 # define set_yylval_num(x) (yylval.num = (x))
11003 # define set_yylval_id(x) (yylval.id = (x))
11004 # define set_yylval_name(x) (yylval.id = (x))
11005 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
11006 # define set_yylval_node(x) (yylval.node = (x))
11007 # define yylval_id() (yylval.id)
11008 #else
11009 static inline VALUE
11010 ripper_yylval_id(ID x)
11011 {
11012  return ripper_new_yylval(x, ID2SYM(x), 0);
11013 }
11014 # define set_yylval_str(x) (yylval.val = (x))
11015 # define set_yylval_num(x) (yylval.val = ripper_new_yylval((x), 0, 0))
11016 # define set_yylval_id(x) (void)(x)
11017 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
11018 # define set_yylval_literal(x) (void)(x)
11019 # define set_yylval_node(x) (void)(x)
11020 # define yylval_id() yylval.id
11021 #endif
11022 
11023 #ifndef RIPPER
11024 #define literal_flush(p) (parser->tokp = (p))
11025 #define dispatch_scan_event(t) ((void)0)
11026 #define dispatch_delayed_token(t) ((void)0)
11027 #define has_delayed_token() (0)
11028 #else
11029 #define literal_flush(p) ((void)0)
11030 
11031 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
11032 
11033 static inline VALUE
11034 intern_sym(const char *name)
11035 {
11036  ID id = rb_intern_const(name);
11037  return ID2SYM(id);
11038 }
11039 
11040 static int
11041 ripper_has_scan_event(struct parser_params *parser)
11042 {
11043 
11044  if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
11045  return lex_p > parser->tokp;
11046 }
11047 
11048 static VALUE
11049 ripper_scan_event_val(struct parser_params *parser, int t)
11050 {
11051  VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
11052  VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
11053  token_flush(parser);
11054  return rval;
11055 }
11056 
11057 static void
11058 ripper_dispatch_scan_event(struct parser_params *parser, int t)
11059 {
11060  if (!ripper_has_scan_event(parser)) return;
11061  yylval_rval = ripper_scan_event_val(parser, t);
11062 }
11063 #define dispatch_scan_event(t) ripper_dispatch_scan_event(parser, t)
11064 
11065 static void
11066 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
11067 {
11068  int saved_line = ruby_sourceline;
11069  const char *saved_tokp = parser->tokp;
11070 
11071  ruby_sourceline = parser->delayed_line;
11072  parser->tokp = lex_pbeg + parser->delayed_col;
11073  yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
11074  parser->delayed = Qnil;
11075  ruby_sourceline = saved_line;
11076  parser->tokp = saved_tokp;
11077 }
11078 #define dispatch_delayed_token(t) ripper_dispatch_delayed_token(parser, t)
11079 #define has_delayed_token() (!NIL_P(parser->delayed))
11080 #endif /* RIPPER */
11081 
11082 #include "ruby/regex.h"
11083 #include "ruby/util.h"
11084 
11085 #define parser_encoding_name() (current_enc->name)
11086 #define parser_mbclen() mbclen((lex_p-1),lex_pend,current_enc)
11087 #define is_identchar(p,e,enc) (rb_enc_isalnum((unsigned char)(*(p)),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
11088 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
11089 
11090 #define parser_isascii() ISASCII(*(lex_p-1))
11091 
11092 static int
11093 token_info_get_column(struct parser_params *parser, const char *pend)
11094 {
11095  int column = 1;
11096  const char *p;
11097  for (p = lex_pbeg; p < pend; p++) {
11098  if (*p == '\t') {
11099  column = (((column - 1) / TAB_WIDTH) + 1) * TAB_WIDTH;
11100  }
11101  column++;
11102  }
11103  return column;
11104 }
11105 
11106 static int
11107 token_info_has_nonspaces(struct parser_params *parser, const char *pend)
11108 {
11109  const char *p;
11110  for (p = lex_pbeg; p < pend; p++) {
11111  if (*p != ' ' && *p != '\t') {
11112  return 1;
11113  }
11114  }
11115  return 0;
11116 }
11117 
11118 static void
11119 token_info_push_gen(struct parser_params *parser, const char *token, size_t len)
11120 {
11121  token_info *ptinfo;
11122  const char *t = lex_p - len;
11123 
11124  if (!parser->token_info_enabled) return;
11125  ptinfo = ALLOC(token_info);
11126  ptinfo->token = token;
11127  ptinfo->linenum = ruby_sourceline;
11128  ptinfo->column = token_info_get_column(parser, t);
11129  ptinfo->nonspc = token_info_has_nonspaces(parser, t);
11130  ptinfo->next = parser->token_info;
11131 
11132  parser->token_info = ptinfo;
11133 }
11134 
11135 static void
11136 token_info_pop_gen(struct parser_params *parser, const char *token, size_t len)
11137 {
11138  int linenum;
11139  token_info *ptinfo = parser->token_info;
11140  const char *t = lex_p - len;
11141 
11142  if (!ptinfo) return;
11143  parser->token_info = ptinfo->next;
11144  linenum = ruby_sourceline;
11145  if (parser->token_info_enabled &&
11146  linenum != ptinfo->linenum && !ptinfo->nonspc &&
11147  !token_info_has_nonspaces(parser, t) &&
11148  token_info_get_column(parser, t) != ptinfo->column) {
11149  rb_warn3L(linenum,
11150  "mismatched indentations at '%s' with '%s' at %d",
11151  WARN_S(token), WARN_S(ptinfo->token), WARN_I(ptinfo->linenum));
11152  }
11153 
11154  xfree(ptinfo);
11155 }
11156 
11157 static int
11158 parser_precise_mbclen(struct parser_params *parser, const char *p)
11159 {
11160  int len = rb_enc_precise_mbclen(p, lex_pend, current_enc);
11161  if (!MBCLEN_CHARFOUND_P(len)) {
11162  compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
11163  return -1;
11164  }
11165  return len;
11166 }
11167 
11168 static int
11169 parser_yyerror(struct parser_params *parser, const char *msg)
11170 {
11171 #ifndef RIPPER
11172  const int max_line_margin = 30;
11173  const char *p, *pe;
11174  const char *pre = "", *post = "", *pend;
11175  const char *code = "", *caret = "", *newline = "";
11176  const char *lim;
11177  char *buf;
11178  long len;
11179  int i;
11180 
11181  pend = lex_pend;
11182  if (pend > lex_pbeg && pend[-1] == '\n') {
11183  if (--pend > lex_pbeg && pend[-1] == '\r') --pend;
11184  }
11185 
11186  p = pe = lex_p < pend ? lex_p : pend;
11187  lim = p - lex_pbeg > max_line_margin ? p - max_line_margin : lex_pbeg;
11188  while ((lim < p) && (*(p-1) != '\n')) p--;
11189 
11190  lim = pend - pe > max_line_margin ? pe + max_line_margin : pend;
11191  while ((pe < lim) && (*pe != '\n')) pe++;
11192 
11193  len = pe - p;
11194  if (len > 4) {
11195  char *p2;
11196 
11197  if (p > lex_pbeg) {
11198  p = rb_enc_prev_char(lex_pbeg, p, lex_p, rb_enc_get(lex_lastline));
11199  if (p > lex_pbeg) pre = "...";
11200  }
11201  if (pe < pend) {
11202  pe = rb_enc_prev_char(lex_p, pe, pend, rb_enc_get(lex_lastline));
11203  if (pe < pend) post = "...";
11204  }
11205  len = pe - p;
11206  lim = lex_p < pend ? lex_p : pend;
11207  i = (int)(lim - p);
11208  buf = ALLOCA_N(char, i+2);
11209  code = p;
11210  caret = p2 = buf;
11211  pe = (parser->tokp < lim ? parser->tokp : lim);
11212  if (p <= pe) {
11213  while (p < pe) {
11214  *p2++ = *p++ == '\t' ? '\t' : ' ';
11215  }
11216  *p2++ = '^';
11217  p++;
11218  }
11219  if (lim > p) {
11220  memset(p2, '~', (lim - p));
11221  p2 += (lim - p);
11222  }
11223  *p2 = '\0';
11224  newline = "\n";
11225  }
11226  else {
11227  len = 0;
11228  }
11229  compile_error(PARSER_ARG "%s%s""%s%.*s%s%s""%s%s",
11230  msg, newline,
11231  pre, (int)len, code, post, newline,
11232  pre, caret);
11233 #else
11234  dispatch1(parse_error, STR_NEW2(msg));
11235  ripper_error();
11236 #endif /* !RIPPER */
11237  return 0;
11238 }
11239 
11240 static int
11241 vtable_size(const struct vtable *tbl)
11242 {
11243  if (POINTER_P(tbl)) {
11244  return tbl->pos;
11245  }
11246  else {
11247  return 0;
11248  }
11249 }
11250 
11251 static struct vtable *
11252 vtable_alloc_gen(struct parser_params *parser, int line, struct vtable *prev)
11253 {
11254  struct vtable *tbl = ALLOC(struct vtable);
11255  tbl->pos = 0;
11256  tbl->capa = 8;
11257  tbl->tbl = ALLOC_N(ID, tbl->capa);
11258  tbl->prev = prev;
11259 #ifndef RIPPER
11260  if (yydebug) {
11261  rb_parser_printf(parser, "vtable_alloc:%d: %p\n", line, tbl);
11262  }
11263 #endif
11264  return tbl;
11265 }
11266 #define vtable_alloc(prev) vtable_alloc_gen(parser, __LINE__, prev)
11267 
11268 static void
11269 vtable_free_gen(struct parser_params *parser, int line, const char *name,
11270  struct vtable *tbl)
11271 {
11272 #ifndef RIPPER
11273  if (yydebug) {
11274  rb_parser_printf(parser, "vtable_free:%d: %s(%p)\n", line, name, tbl);
11275  }
11276 #endif
11277  if (POINTER_P(tbl)) {
11278  if (tbl->tbl) {
11279  xfree(tbl->tbl);
11280  }
11281  xfree(tbl);
11282  }
11283 }
11284 #define vtable_free(tbl) vtable_free_gen(parser, __LINE__, #tbl, tbl)
11285 
11286 static void
11287 vtable_add_gen(struct parser_params *parser, int line, const char *name,
11288  struct vtable *tbl, ID id)
11289 {
11290 #ifndef RIPPER
11291  if (yydebug) {
11292  rb_parser_printf(parser, "vtable_add:%d: %s(%p), %s\n",
11293  line, name, tbl, rb_id2name(id));
11294  }
11295 #endif
11296  if (!POINTER_P(tbl)) {
11297  rb_parser_fatal(parser, "vtable_add: vtable is not allocated (%p)", (void *)tbl);
11298  return;
11299  }
11300  if (tbl->pos == tbl->capa) {
11301  tbl->capa = tbl->capa * 2;
11302  REALLOC_N(tbl->tbl, ID, tbl->capa);
11303  }
11304  tbl->tbl[tbl->pos++] = id;
11305 }
11306 #define vtable_add(tbl, id) vtable_add_gen(parser, __LINE__, #tbl, tbl, id)
11307 
11308 #ifndef RIPPER
11309 static void
11310 vtable_pop_gen(struct parser_params *parser, int line, const char *name,
11311  struct vtable *tbl, int n)
11312 {
11313  if (yydebug) {
11314  rb_parser_printf(parser, "vtable_pop:%d: %s(%p), %d\n",
11315  line, name, tbl, n);
11316  }
11317  if (tbl->pos < n) {
11318  rb_parser_fatal(parser, "vtable_pop: unreachable (%d < %d)", tbl->pos, n);
11319  return;
11320  }
11321  tbl->pos -= n;
11322 }
11323 #define vtable_pop(tbl, n) vtable_pop_gen(parser, __LINE__, #tbl, tbl, n)
11324 #endif
11325 
11326 static int
11327 vtable_included(const struct vtable * tbl, ID id)
11328 {
11329  int i;
11330 
11331  if (POINTER_P(tbl)) {
11332  for (i = 0; i < tbl->pos; i++) {
11333  if (tbl->tbl[i] == id) {
11334  return i+1;
11335  }
11336  }
11337  }
11338  return 0;
11339 }
11340 
11341 static void parser_prepare(struct parser_params *parser);
11342 
11343 #ifndef RIPPER
11344 static VALUE
11345 debug_lines(VALUE fname)
11346 {
11347  ID script_lines;
11348  CONST_ID(script_lines, "SCRIPT_LINES__");
11349  if (rb_const_defined_at(rb_cObject, script_lines)) {
11350  VALUE hash = rb_const_get_at(rb_cObject, script_lines);
11351  if (RB_TYPE_P(hash, T_HASH)) {
11352  VALUE lines = rb_ary_new();
11353  rb_hash_aset(hash, fname, lines);
11354  return lines;
11355  }
11356  }
11357  return 0;
11358 }
11359 
11360 static VALUE
11361 coverage(VALUE fname, int n)
11362 {
11363  VALUE coverages = rb_get_coverages();
11364  if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
11365  VALUE coverage = rb_default_coverage(n);
11366  VALUE lines = RARRAY_AREF(coverage, COVERAGE_INDEX_LINES);
11367 
11368  rb_hash_aset(coverages, fname, coverage);
11369 
11370  return lines == Qnil ? Qfalse : lines;
11371  }
11372  return 0;
11373 }
11374 
11375 static int
11376 e_option_supplied(struct parser_params *parser)
11377 {
11378  return strcmp(ruby_sourcefile, "-e") == 0;
11379 }
11380 
11381 static VALUE
11382 yycompile0(VALUE arg)
11383 {
11384  int n;
11385  NODE *tree;
11386  struct parser_params *parser = (struct parser_params *)arg;
11387  VALUE cov = Qfalse;
11388 
11389  if (!compile_for_eval && rb_safe_level() == 0) {
11390  ruby_debug_lines = debug_lines(ruby_sourcefile_string);
11391  if (ruby_debug_lines && ruby_sourceline > 0) {
11392  VALUE str = STR_NEW0();
11393  n = ruby_sourceline;
11394  do {
11395  rb_ary_push(ruby_debug_lines, str);
11396  } while (--n);
11397  }
11398 
11399  if (!e_option_supplied(parser)) {
11400  ruby_coverage = coverage(ruby_sourcefile_string, ruby_sourceline);
11401  cov = Qtrue;
11402  }
11403  }
11404 
11405  parser_prepare(parser);
11406 #ifndef RIPPER
11407 #define RUBY_DTRACE_PARSE_HOOK(name) \
11408  if (RUBY_DTRACE_PARSE_##name##_ENABLED()) { \
11409  RUBY_DTRACE_PARSE_##name(ruby_sourcefile, ruby_sourceline); \
11410  }
11411  RUBY_DTRACE_PARSE_HOOK(BEGIN);
11412 #endif
11413  n = yyparse((void*)parser);
11414 #ifndef RIPPER
11415  RUBY_DTRACE_PARSE_HOOK(END);
11416 #endif
11417  ruby_debug_lines = 0;
11418  ruby_coverage = 0;
11419 
11420  lex_strterm = 0;
11421  lex_p = lex_pbeg = lex_pend = 0;
11422  lex_lastline = lex_nextline = 0;
11423  if (parser->error_p) {
11424  VALUE mesg = parser->error_buffer;
11425  if (!mesg) {
11426  mesg = rb_class_new_instance(0, 0, rb_eSyntaxError);
11427  }
11428  rb_set_errinfo(mesg);
11429  return 0;
11430  }
11431  tree = ruby_eval_tree;
11432  if (!tree) {
11433  tree = NEW_NIL();
11434  }
11435  else {
11436  VALUE opt = parser->compile_option;
11437  NODE *prelude;
11438  if (!opt) opt = rb_obj_hide(rb_ident_hash_new());
11439  rb_hash_aset(opt, rb_sym_intern_ascii_cstr("coverage_enabled"), cov);
11440  prelude = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body, opt);
11441  nd_set_column(prelude, nd_column(tree->nd_body));
11442  tree->nd_body = prelude;
11443  }
11444  return (VALUE)tree;
11445 }
11446 
11447 static NODE*
11448 yycompile(struct parser_params *parser, VALUE fname, int line)
11449 {
11450  ruby_sourcefile_string = rb_str_new_frozen(fname);
11451  ruby_sourcefile = RSTRING_PTR(fname);
11452  ruby_sourceline = line - 1;
11453  return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
11454 }
11455 #endif /* !RIPPER */
11456 
11457 static rb_encoding *
11458 must_be_ascii_compatible(VALUE s)
11459 {
11460  rb_encoding *enc = rb_enc_get(s);
11461  if (!rb_enc_asciicompat(enc)) {
11462  rb_raise(rb_eArgError, "invalid source encoding");
11463  }
11464  return enc;
11465 }
11466 
11467 static VALUE
11468 lex_get_str(struct parser_params *parser, VALUE s)
11469 {
11470  char *beg, *end, *start;
11471  long len;
11472 
11473  beg = RSTRING_PTR(s);
11474  len = RSTRING_LEN(s);
11475  start = beg;
11476  if (lex_gets_ptr) {
11477  if (len == lex_gets_ptr) return Qnil;
11478  beg += lex_gets_ptr;
11479  len -= lex_gets_ptr;
11480  }
11481  end = memchr(beg, '\n', len);
11482  if (end) len = ++end - beg;
11483  lex_gets_ptr += len;
11484  return rb_str_subseq(s, beg - start, len);
11485 }
11486 
11487 static VALUE
11488 lex_getline(struct parser_params *parser)
11489 {
11490  VALUE line = (*lex_gets)(parser, lex_input);
11491  if (NIL_P(line)) return line;
11492  must_be_ascii_compatible(line);
11493 #ifndef RIPPER
11494  if (ruby_debug_lines) {
11495  rb_enc_associate(line, current_enc);
11496  rb_ary_push(ruby_debug_lines, line);
11497  }
11498  if (ruby_coverage) {
11499  rb_ary_push(ruby_coverage, Qnil);
11500  }
11501 #endif
11502  return line;
11503 }
11504 
11505 static const rb_data_type_t parser_data_type;
11506 
11507 #ifndef RIPPER
11508 static NODE*
11509 parser_compile_string(VALUE vparser, VALUE fname, VALUE s, int line)
11510 {
11511  struct parser_params *parser;
11512  NODE *node;
11513 
11514  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11515  lex_gets = lex_get_str;
11516  lex_gets_ptr = 0;
11517  lex_input = rb_str_new_frozen(s);
11518  lex_pbeg = lex_p = lex_pend = 0;
11519 
11520  node = yycompile(parser, fname, line);
11521  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11522 
11523  return node;
11524 }
11525 
11526 NODE*
11527 rb_compile_string(const char *f, VALUE s, int line)
11528 {
11529  must_be_ascii_compatible(s);
11530  return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), s, line);
11531 }
11532 
11533 NODE*
11534 rb_parser_compile_string(VALUE vparser, const char *f, VALUE s, int line)
11535 {
11536  return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
11537 }
11538 
11539 NODE*
11540 rb_parser_compile_string_path(VALUE vparser, VALUE f, VALUE s, int line)
11541 {
11542  must_be_ascii_compatible(s);
11543  return parser_compile_string(vparser, f, s, line);
11544 }
11545 
11546 NODE*
11547 rb_compile_cstr(const char *f, const char *s, int len, int line)
11548 {
11549  VALUE str = rb_str_new(s, len);
11550  return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), str, line);
11551 }
11552 
11553 NODE*
11554 rb_parser_compile_cstr(VALUE vparser, const char *f, const char *s, int len, int line)
11555 {
11556  VALUE str = rb_str_new(s, len);
11557  return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line);
11558 }
11559 
11560 VALUE rb_io_gets_internal(VALUE io);
11561 
11562 static VALUE
11563 lex_io_gets(struct parser_params *parser, VALUE io)
11564 {
11565  return rb_io_gets_internal(io);
11566 }
11567 
11568 NODE*
11569 rb_compile_file(const char *f, VALUE file, int start)
11570 {
11571  VALUE vparser = rb_parser_new();
11572 
11573  return rb_parser_compile_file(vparser, f, file, start);
11574 }
11575 
11576 NODE*
11577 rb_parser_compile_file(VALUE vparser, const char *f, VALUE file, int start)
11578 {
11579  return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start);
11580 }
11581 
11582 NODE*
11583 rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE file, int start)
11584 {
11585  struct parser_params *parser;
11586  NODE *node;
11587 
11588  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11589  lex_gets = lex_io_gets;
11590  lex_input = file;
11591  lex_pbeg = lex_p = lex_pend = 0;
11592 
11593  node = yycompile(parser, fname, start);
11594  RB_GC_GUARD(vparser); /* prohibit tail call optimization */
11595 
11596  return node;
11597 }
11598 #endif /* !RIPPER */
11599 
11600 #define STR_FUNC_ESCAPE 0x01
11601 #define STR_FUNC_EXPAND 0x02
11602 #define STR_FUNC_REGEXP 0x04
11603 #define STR_FUNC_QWORDS 0x08
11604 #define STR_FUNC_SYMBOL 0x10
11605 #define STR_FUNC_INDENT 0x20
11606 #define STR_FUNC_LABEL 0x40
11607 #define STR_FUNC_TERM 0x8000
11608 
11609 enum string_type {
11610  str_label = STR_FUNC_LABEL,
11611  str_squote = (0),
11612  str_dquote = (STR_FUNC_EXPAND),
11613  str_xquote = (STR_FUNC_EXPAND),
11614  str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
11615  str_sword = (STR_FUNC_QWORDS),
11616  str_dword = (STR_FUNC_QWORDS|STR_FUNC_EXPAND),
11617  str_ssym = (STR_FUNC_SYMBOL),
11618  str_dsym = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
11619 };
11620 
11621 static VALUE
11622 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
11623 {
11624  VALUE str;
11625 
11626  str = rb_enc_str_new(p, n, enc);
11627  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
11628  if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
11629  }
11630  else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
11631  rb_enc_associate(str, rb_ascii8bit_encoding());
11632  }
11633  }
11634 
11635  return str;
11636 }
11637 
11638 #define lex_goto_eol(parser) ((parser)->lex.pcur = (parser)->lex.pend)
11639 #define lex_eol_p() (lex_p >= lex_pend)
11640 #define peek(c) peek_n((c), 0)
11641 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
11642 #define peekc() peekc_n(0)
11643 #define peekc_n(n) (lex_p+(n) < lex_pend ? (unsigned char)lex_p[n] : -1)
11644 
11645 static int
11646 parser_nextline(struct parser_params *parser)
11647 {
11648  VALUE v = lex_nextline;
11649  lex_nextline = 0;
11650  if (!v) {
11651  if (parser->eofp)
11652  return -1;
11653 
11654  if (!lex_input || NIL_P(v = lex_getline(parser))) {
11655  parser->eofp = 1;
11656  lex_goto_eol(parser);
11657  return -1;
11658  }
11659  parser->cr_seen = FALSE;
11660  }
11661 #ifdef RIPPER
11662  if (parser->tokp < lex_pend) {
11663  if (!has_delayed_token()) {
11664  parser->delayed = rb_str_buf_new(1024);
11665  rb_enc_associate(parser->delayed, current_enc);
11666  rb_str_buf_cat(parser->delayed,
11667  parser->tokp, lex_pend - parser->tokp);
11668  parser->delayed_line = ruby_sourceline;
11669  parser->delayed_col = (int)(parser->tokp - lex_pbeg);
11670  }
11671  else {
11672  rb_str_buf_cat(parser->delayed,
11673  parser->tokp, lex_pend - parser->tokp);
11674  }
11675  }
11676 #endif
11677  if (heredoc_end > 0) {
11678  ruby_sourceline = heredoc_end;
11679  heredoc_end = 0;
11680  }
11681  ruby_sourceline++;
11682  parser->line_count++;
11683  lex_pbeg = lex_p = RSTRING_PTR(v);
11684  lex_pend = lex_p + RSTRING_LEN(v);
11685  token_flush(parser);
11686  lex_lastline = v;
11687  return 0;
11688 }
11689 
11690 static int
11691 parser_cr(struct parser_params *parser, int c)
11692 {
11693  if (peek('\n')) {
11694  lex_p++;
11695  c = '\n';
11696  }
11697  else if (!parser->cr_seen) {
11698  parser->cr_seen = TRUE;
11699  /* carried over with lex_nextline for nextc() */
11700  rb_warn0("encountered \\r in middle of line, treated as a mere space");
11701  }
11702  return c;
11703 }
11704 
11705 static inline int
11706 parser_nextc(struct parser_params *parser)
11707 {
11708  int c;
11709 
11710  if (UNLIKELY(lex_p == lex_pend)) {
11711  if (parser_nextline(parser)) return -1;
11712  }
11713  c = (unsigned char)*lex_p++;
11714  if (UNLIKELY(c == '\r')) {
11715  c = parser_cr(parser, c);
11716  }
11717 
11718  return c;
11719 }
11720 
11721 static void
11722 parser_pushback(struct parser_params *parser, int c)
11723 {
11724  if (c == -1) return;
11725  lex_p--;
11726  if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
11727  lex_p--;
11728  }
11729 }
11730 
11731 #define was_bol() (lex_p == lex_pbeg + 1)
11732 
11733 #define tokfix() (tokenbuf[tokidx]='\0')
11734 #define tok() tokenbuf
11735 #define toklen() tokidx
11736 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
11737 
11738 static char*
11739 parser_newtok(struct parser_params *parser)
11740 {
11741  tokidx = 0;
11742  tokline = ruby_sourceline;
11743  if (!tokenbuf) {
11744  toksiz = 60;
11745  tokenbuf = ALLOC_N(char, 60);
11746  }
11747  if (toksiz > 4096) {
11748  toksiz = 60;
11749  REALLOC_N(tokenbuf, char, 60);
11750  }
11751  return tokenbuf;
11752 }
11753 
11754 static char *
11755 parser_tokspace(struct parser_params *parser, int n)
11756 {
11757  tokidx += n;
11758 
11759  if (tokidx >= toksiz) {
11760  do {toksiz *= 2;} while (toksiz < tokidx);
11761  REALLOC_N(tokenbuf, char, toksiz);
11762  }
11763  return &tokenbuf[tokidx-n];
11764 }
11765 
11766 static void
11767 parser_tokadd(struct parser_params *parser, int c)
11768 {
11769  tokenbuf[tokidx++] = (char)c;
11770  if (tokidx >= toksiz) {
11771  toksiz *= 2;
11772  REALLOC_N(tokenbuf, char, toksiz);
11773  }
11774 }
11775 
11776 static int
11777 parser_tok_hex(struct parser_params *parser, size_t *numlen)
11778 {
11779  int c;
11780 
11781  c = scan_hex(lex_p, 2, numlen);
11782  if (!*numlen) {
11783  parser->tokp = lex_p;
11784  yyerror0("invalid hex escape");
11785  return 0;
11786  }
11787  lex_p += *numlen;
11788  return c;
11789 }
11790 
11791 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
11792 
11793 static int
11794 parser_tokadd_codepoint(struct parser_params *parser, rb_encoding **encp,
11795  int regexp_literal, int wide)
11796 {
11797  size_t numlen;
11798  int codepoint = scan_hex(lex_p, wide ? lex_pend - lex_p : 4, &numlen);
11799  literal_flush(lex_p);
11800  lex_p += numlen;
11801  if (wide ? (numlen == 0 || numlen > 6) : (numlen < 4)) {
11802  yyerror0("invalid Unicode escape");
11803  return wide && numlen > 0;
11804  }
11805  if (codepoint > 0x10ffff) {
11806  yyerror0("invalid Unicode codepoint (too large)");
11807  return wide;
11808  }
11809  if ((codepoint & 0xfffff800) == 0xd800) {
11810  yyerror0("invalid Unicode codepoint");
11811  return wide;
11812  }
11813  if (regexp_literal) {
11814  tokcopy((int)numlen);
11815  }
11816  else if (codepoint >= 0x80) {
11817  rb_encoding *utf8 = rb_utf8_encoding();
11818  if (*encp && utf8 != *encp) {
11819  static const char mixed_utf8[] = "UTF-8 mixed within %s source";
11820  size_t len = sizeof(mixed_utf8) - 2 + strlen(rb_enc_name(*encp));
11821  char *mesg = alloca(len);
11822  snprintf(mesg, len, mixed_utf8, rb_enc_name(*encp));
11823  yyerror0(mesg);
11824  return wide;
11825  }
11826  *encp = utf8;
11827  tokaddmbc(codepoint, *encp);
11828  }
11829  else {
11830  tokadd(codepoint);
11831  }
11832  return TRUE;
11833 }
11834 
11835 /* return value is for ?\u3042 */
11836 static int
11837 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
11838  int string_literal, int symbol_literal, int regexp_literal)
11839 {
11840  /*
11841  * If string_literal is true, then we allow multiple codepoints
11842  * in \u{}, and add the codepoints to the current token.
11843  * Otherwise we're parsing a character literal and return a single
11844  * codepoint without adding it
11845  */
11846 
11847  const int open_brace = '{', close_brace = '}';
11848 
11849  if (regexp_literal) { tokadd('\\'); tokadd('u'); }
11850 
11851  if (peek(open_brace)) { /* handle \u{...} form */
11852  int c, last = nextc();
11853  if (lex_p >= lex_pend) goto unterminated;
11854  while (ISSPACE(c = *lex_p) && ++lex_p < lex_pend);
11855  do {
11856  if (regexp_literal) tokadd(last);
11857  if (!parser_tokadd_codepoint(parser, encp, regexp_literal, TRUE)) {
11858  break;
11859  }
11860  while (ISSPACE(c = *lex_p)) {
11861  if (++lex_p >= lex_pend) goto unterminated;
11862  last = c;
11863  }
11864  } while (c != close_brace);
11865 
11866  if (c != close_brace) {
11867  unterminated:
11868  literal_flush(lex_p);
11869  yyerror0("unterminated Unicode escape");
11870  return 0;
11871  }
11872 
11873  if (regexp_literal) tokadd(close_brace);
11874  nextc();
11875  }
11876  else { /* handle \uxxxx form */
11877  if (!parser_tokadd_codepoint(parser, encp, regexp_literal, FALSE)) {
11878  return 0;
11879  }
11880  }
11881 
11882  return TRUE;
11883 }
11884 
11885 #define ESCAPE_CONTROL 1
11886 #define ESCAPE_META 2
11887 
11888 static int
11889 parser_read_escape(struct parser_params *parser, int flags,
11890  rb_encoding **encp)
11891 {
11892  int c;
11893  size_t numlen;
11894 
11895  switch (c = nextc()) {
11896  case '\\': /* Backslash */
11897  return c;
11898 
11899  case 'n': /* newline */
11900  return '\n';
11901 
11902  case 't': /* horizontal tab */
11903  return '\t';
11904 
11905  case 'r': /* carriage-return */
11906  return '\r';
11907 
11908  case 'f': /* form-feed */
11909  return '\f';
11910 
11911  case 'v': /* vertical tab */
11912  return '\13';
11913 
11914  case 'a': /* alarm(bell) */
11915  return '\007';
11916 
11917  case 'e': /* escape */
11918  return 033;
11919 
11920  case '0': case '1': case '2': case '3': /* octal constant */
11921  case '4': case '5': case '6': case '7':
11922  pushback(c);
11923  c = scan_oct(lex_p, 3, &numlen);
11924  lex_p += numlen;
11925  return c;
11926 
11927  case 'x': /* hex constant */
11928  c = tok_hex(&numlen);
11929  if (numlen == 0) return 0;
11930  return c;
11931 
11932  case 'b': /* backspace */
11933  return '\010';
11934 
11935  case 's': /* space */
11936  return ' ';
11937 
11938  case 'M':
11939  if (flags & ESCAPE_META) goto eof;
11940  if ((c = nextc()) != '-') {
11941  goto eof;
11942  }
11943  if ((c = nextc()) == '\\') {
11944  if (peek('u')) goto eof;
11945  return read_escape(flags|ESCAPE_META, encp) | 0x80;
11946  }
11947  else if (c == -1 || !ISASCII(c)) goto eof;
11948  else {
11949  return ((c & 0xff) | 0x80);
11950  }
11951 
11952  case 'C':
11953  if ((c = nextc()) != '-') {
11954  goto eof;
11955  }
11956  case 'c':
11957  if (flags & ESCAPE_CONTROL) goto eof;
11958  if ((c = nextc())== '\\') {
11959  if (peek('u')) goto eof;
11960  c = read_escape(flags|ESCAPE_CONTROL, encp);
11961  }
11962  else if (c == '?')
11963  return 0177;
11964  else if (c == -1 || !ISASCII(c)) goto eof;
11965  return c & 0x9f;
11966 
11967  eof:
11968  case -1:
11969  yyerror0("Invalid escape character syntax");
11970  pushback(c);
11971  return '\0';
11972 
11973  default:
11974  return c;
11975  }
11976 }
11977 
11978 static void
11979 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
11980 {
11981  int len = rb_enc_codelen(c, enc);
11982  rb_enc_mbcput(c, tokspace(len), enc);
11983 }
11984 
11985 static int
11986 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
11987 {
11988  int c;
11989  int flags = 0;
11990  size_t numlen;
11991 
11992  first:
11993  switch (c = nextc()) {
11994  case '\n':
11995  return 0; /* just ignore */
11996 
11997  case '0': case '1': case '2': case '3': /* octal constant */
11998  case '4': case '5': case '6': case '7':
11999  {
12000  ruby_scan_oct(--lex_p, 3, &numlen);
12001  if (numlen == 0) goto eof;
12002  lex_p += numlen;
12003  tokcopy((int)numlen + 1);
12004  }
12005  return 0;
12006 
12007  case 'x': /* hex constant */
12008  {
12009  tok_hex(&numlen);
12010  if (numlen == 0) return -1;
12011  tokcopy((int)numlen + 2);
12012  }
12013  return 0;
12014 
12015  case 'M':
12016  if (flags & ESCAPE_META) goto eof;
12017  if ((c = nextc()) != '-') {
12018  pushback(c);
12019  goto eof;
12020  }
12021  tokcopy(3);
12022  flags |= ESCAPE_META;
12023  goto escaped;
12024 
12025  case 'C':
12026  if (flags & ESCAPE_CONTROL) goto eof;
12027  if ((c = nextc()) != '-') {
12028  pushback(c);
12029  goto eof;
12030  }
12031  tokcopy(3);
12032  goto escaped;
12033 
12034  case 'c':
12035  if (flags & ESCAPE_CONTROL) goto eof;
12036  tokcopy(2);
12037  flags |= ESCAPE_CONTROL;
12038  escaped:
12039  if ((c = nextc()) == '\\') {
12040  goto first;
12041  }
12042  else if (c == -1) goto eof;
12043  tokadd(c);
12044  return 0;
12045 
12046  eof:
12047  case -1:
12048  yyerror0("Invalid escape character syntax");
12049  return -1;
12050 
12051  default:
12052  tokadd('\\');
12053  tokadd(c);
12054  }
12055  return 0;
12056 }
12057 
12058 static int
12059 parser_regx_options(struct parser_params *parser)
12060 {
12061  int kcode = 0;
12062  int kopt = 0;
12063  int options = 0;
12064  int c, opt, kc;
12065 
12066  newtok();
12067  while (c = nextc(), ISALPHA(c)) {
12068  if (c == 'o') {
12069  options |= RE_OPTION_ONCE;
12070  }
12071  else if (rb_char_to_option_kcode(c, &opt, &kc)) {
12072  if (kc >= 0) {
12073  if (kc != rb_ascii8bit_encindex()) kcode = c;
12074  kopt = opt;
12075  }
12076  else {
12077  options |= opt;
12078  }
12079  }
12080  else {
12081  tokadd(c);
12082  }
12083  }
12084  options |= kopt;
12085  pushback(c);
12086  if (toklen()) {
12087  tokfix();
12088  compile_error(PARSER_ARG "unknown regexp option%s - %s",
12089  toklen() > 1 ? "s" : "", tok());
12090  }
12091  return options | RE_OPTION_ENCODING(kcode);
12092 }
12093 
12094 static void
12095 dispose_string(VALUE str)
12096 {
12097  rb_str_free(str);
12098  rb_gc_force_recycle(str);
12099 }
12100 
12101 static int
12102 parser_tokadd_mbchar(struct parser_params *parser, int c)
12103 {
12104  int len = parser_precise_mbclen(parser, lex_p-1);
12105  if (len < 0) return -1;
12106  tokadd(c);
12107  lex_p += --len;
12108  if (len > 0) tokcopy(len);
12109  return c;
12110 }
12111 
12112 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
12113 
12114 static inline int
12115 simple_re_meta(int c)
12116 {
12117  switch (c) {
12118  case '$': case '*': case '+': case '.':
12119  case '?': case '^': case '|':
12120  case ')': case ']': case '}': case '>':
12121  return TRUE;
12122  default:
12123  return FALSE;
12124  }
12125 }
12126 
12127 static int
12128 parser_update_heredoc_indent(struct parser_params *parser, int c)
12129 {
12130  if (heredoc_line_indent == -1) {
12131  if (c == '\n') heredoc_line_indent = 0;
12132  }
12133  else {
12134  if (c == ' ') {
12135  heredoc_line_indent++;
12136  return TRUE;
12137  }
12138  else if (c == '\t') {
12139  int w = (heredoc_line_indent / TAB_WIDTH) + 1;
12140  heredoc_line_indent = w * TAB_WIDTH;
12141  return TRUE;
12142  }
12143  else if (c != '\n') {
12144  if (heredoc_indent > heredoc_line_indent) {
12145  heredoc_indent = heredoc_line_indent;
12146  }
12147  heredoc_line_indent = -1;
12148  }
12149  }
12150  return FALSE;
12151 }
12152 
12153 static int
12154 parser_tokadd_string(struct parser_params *parser,
12155  int func, int term, int paren, long *nest,
12156  rb_encoding **encp)
12157 {
12158  int c;
12159  rb_encoding *enc = 0;
12160  char *errbuf = 0;
12161  static const char mixed_msg[] = "%s mixed within %s source";
12162 
12163 #define mixed_error(enc1, enc2) if (!errbuf) { \
12164  size_t len = sizeof(mixed_msg) - 4; \
12165  len += strlen(rb_enc_name(enc1)); \
12166  len += strlen(rb_enc_name(enc2)); \
12167  errbuf = ALLOCA_N(char, len); \
12168  snprintf(errbuf, len, mixed_msg, \
12169  rb_enc_name(enc1), \
12170  rb_enc_name(enc2)); \
12171  yyerror0(errbuf); \
12172  }
12173 #define mixed_escape(beg, enc1, enc2) do { \
12174  const char *pos = lex_p; \
12175  lex_p = (beg); \
12176  mixed_error((enc1), (enc2)); \
12177  lex_p = pos; \
12178  } while (0)
12179 
12180  while ((c = nextc()) != -1) {
12181  if (heredoc_indent > 0) {
12182  parser_update_heredoc_indent(parser, c);
12183  }
12184 
12185  if (paren && c == paren) {
12186  ++*nest;
12187  }
12188  else if (c == term) {
12189  if (!nest || !*nest) {
12190  pushback(c);
12191  break;
12192  }
12193  --*nest;
12194  }
12195  else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
12196  int c2 = *lex_p;
12197  if (c2 == '$' || c2 == '@' || c2 == '{') {
12198  pushback(c);
12199  break;
12200  }
12201  }
12202  else if (c == '\\') {
12203  literal_flush(lex_p - 1);
12204  c = nextc();
12205  switch (c) {
12206  case '\n':
12207  if (func & STR_FUNC_QWORDS) break;
12208  if (func & STR_FUNC_EXPAND) continue;
12209  tokadd('\\');
12210  break;
12211 
12212  case '\\':
12213  if (func & STR_FUNC_ESCAPE) tokadd(c);
12214  break;
12215 
12216  case 'u':
12217  if ((func & STR_FUNC_EXPAND) == 0) {
12218  tokadd('\\');
12219  break;
12220  }
12221  if (!parser_tokadd_utf8(parser, &enc, term,
12222  func & STR_FUNC_SYMBOL,
12223  func & STR_FUNC_REGEXP)) {
12224  return -1;
12225  }
12226  continue;
12227 
12228  default:
12229  if (c == -1) return -1;
12230  if (!ISASCII(c)) {
12231  if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
12232  goto non_ascii;
12233  }
12234  if (func & STR_FUNC_REGEXP) {
12235  if (c == term && !simple_re_meta(c)) {
12236  tokadd(c);
12237  continue;
12238  }
12239  pushback(c);
12240  if ((c = tokadd_escape(&enc)) < 0)
12241  return -1;
12242  if (enc && enc != *encp) {
12243  mixed_escape(parser->tokp+2, enc, *encp);
12244  }
12245  continue;
12246  }
12247  else if (func & STR_FUNC_EXPAND) {
12248  pushback(c);
12249  if (func & STR_FUNC_ESCAPE) tokadd('\\');
12250  c = read_escape(0, &enc);
12251  }
12252  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12253  /* ignore backslashed spaces in %w */
12254  }
12255  else if (c != term && !(paren && c == paren)) {
12256  tokadd('\\');
12257  pushback(c);
12258  continue;
12259  }
12260  }
12261  }
12262  else if (!parser_isascii()) {
12263  non_ascii:
12264  if (!enc) {
12265  enc = *encp;
12266  }
12267  else if (enc != *encp) {
12268  mixed_error(enc, *encp);
12269  continue;
12270  }
12271  if (tokadd_mbchar(c) == -1) return -1;
12272  continue;
12273  }
12274  else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12275  pushback(c);
12276  break;
12277  }
12278  if (c & 0x80) {
12279  if (!enc) {
12280  enc = *encp;
12281  }
12282  else if (enc != *encp) {
12283  mixed_error(enc, *encp);
12284  continue;
12285  }
12286  }
12287  tokadd(c);
12288  }
12289  if (enc) *encp = enc;
12290  return c;
12291 }
12292 
12293 #define NEW_STRTERM(func, term, paren) \
12294  rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
12295 
12296 #ifdef RIPPER
12297 static void
12298 token_flush_string_content(struct parser_params *parser, rb_encoding *enc)
12299 {
12300  VALUE content = yylval.val;
12301  if (!ripper_is_node_yylval(content))
12302  content = ripper_new_yylval(0, 0, content);
12303  if (has_delayed_token()) {
12304  ptrdiff_t len = lex_p - parser->tokp;
12305  if (len > 0) {
12306  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12307  }
12308  dispatch_delayed_token(tSTRING_CONTENT);
12309  parser->tokp = lex_p;
12310  RNODE(content)->nd_rval = yylval.val;
12311  }
12312  dispatch_scan_event(tSTRING_CONTENT);
12313  if (yylval.val != content)
12314  RNODE(content)->nd_rval = yylval.val;
12315  yylval.val = content;
12316 }
12317 
12318 #define flush_string_content(enc) token_flush_string_content(parser, (enc))
12319 #else
12320 #define flush_string_content(enc) ((void)(enc))
12321 #endif
12322 
12323 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
12324 /* this can be shared with ripper, since it's independent from struct
12325  * parser_params. */
12326 #ifndef RIPPER
12327 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
12328 #define SPECIAL_PUNCT(idx) ( \
12329  BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
12330  BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
12331  BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
12332  BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
12333  BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
12334  BIT('0', idx))
12335 const unsigned int ruby_global_name_punct_bits[] = {
12336  SPECIAL_PUNCT(0),
12337  SPECIAL_PUNCT(1),
12338  SPECIAL_PUNCT(2),
12339 };
12340 #undef BIT
12341 #undef SPECIAL_PUNCT
12342 #endif
12343 
12344 static enum yytokentype
12345 parser_peek_variable_name(struct parser_params *parser)
12346 {
12347  int c;
12348  const char *p = lex_p;
12349 
12350  if (p + 1 >= lex_pend) return 0;
12351  c = *p++;
12352  switch (c) {
12353  case '$':
12354  if ((c = *p) == '-') {
12355  if (++p >= lex_pend) return 0;
12356  c = *p;
12357  }
12358  else if (is_global_name_punct(c) || ISDIGIT(c)) {
12359  return tSTRING_DVAR;
12360  }
12361  break;
12362  case '@':
12363  if ((c = *p) == '@') {
12364  if (++p >= lex_pend) return 0;
12365  c = *p;
12366  }
12367  break;
12368  case '{':
12369  lex_p = p;
12370  command_start = TRUE;
12371  return tSTRING_DBEG;
12372  default:
12373  return 0;
12374  }
12375  if (!ISASCII(c) || c == '_' || ISALPHA(c))
12376  return tSTRING_DVAR;
12377  return 0;
12378 }
12379 
12380 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
12381 #define IS_END() IS_lex_state(EXPR_END_ANY)
12382 #define IS_BEG() (IS_lex_state(EXPR_BEG_ANY) || IS_lex_state_all(EXPR_ARG|EXPR_LABELED))
12383 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
12384 #define IS_LABEL_POSSIBLE() (\
12385  (IS_lex_state(EXPR_LABEL|EXPR_ENDFN) && !cmd_state) || \
12386  IS_ARG())
12387 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
12388 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
12389 
12390 static inline enum yytokentype
12391 parser_string_term(struct parser_params *parser, int func)
12392 {
12393  rb_gc_force_recycle((VALUE)lex_strterm);
12394  lex_strterm = 0;
12395  if (func & STR_FUNC_REGEXP) {
12396  set_yylval_num(regx_options());
12397  dispatch_scan_event(tREGEXP_END);
12398  SET_LEX_STATE(EXPR_END|EXPR_ENDARG);
12399  return tREGEXP_END;
12400  }
12401  if ((func & STR_FUNC_LABEL) && IS_LABEL_SUFFIX(0)) {
12402  nextc();
12403  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
12404  return tLABEL_END;
12405  }
12406  SET_LEX_STATE(EXPR_END|EXPR_ENDARG);
12407  return tSTRING_END;
12408 }
12409 
12410 static enum yytokentype
12411 parser_parse_string(struct parser_params *parser, NODE *quote)
12412 {
12413  int func = (int)quote->nd_func;
12414  int term = nd_term(quote);
12415  int paren = nd_paren(quote);
12416  int c, space = 0;
12417  rb_encoding *enc = current_enc;
12418 
12419  if (func & STR_FUNC_TERM) {
12420  SET_LEX_STATE(EXPR_END|EXPR_ENDARG);
12421  lex_strterm = 0;
12422  return func & STR_FUNC_REGEXP ? tREGEXP_END : tSTRING_END;
12423  }
12424  c = nextc();
12425  if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
12426  do {c = nextc();} while (ISSPACE(c));
12427  space = 1;
12428  }
12429  if (c == term && !quote->nd_nest) {
12430  if (func & STR_FUNC_QWORDS) {
12431  quote->nd_func |= STR_FUNC_TERM;
12432  return ' ';
12433  }
12434  return parser_string_term(parser, func);
12435  }
12436  if (space) {
12437  pushback(c);
12438  return ' ';
12439  }
12440  newtok();
12441  if ((func & STR_FUNC_EXPAND) && c == '#') {
12442  int t = parser_peek_variable_name(parser);
12443  if (t) return t;
12444  tokadd('#');
12445  c = nextc();
12446  }
12447  pushback(c);
12448  if (tokadd_string(func, term, paren, &quote->nd_nest,
12449  &enc) == -1) {
12450  if (parser->eofp) {
12451 #ifndef RIPPER
12452 # define unterminated_literal(mesg) yyerror0(mesg)
12453 #else
12454 # define unterminated_literal(mesg) compile_error(PARSER_ARG mesg)
12455 #endif
12456  literal_flush(lex_p);
12457  if (func & STR_FUNC_REGEXP) {
12458  unterminated_literal("unterminated regexp meets end of file");
12459  }
12460  else {
12461  unterminated_literal("unterminated string meets end of file");
12462  }
12463  quote->nd_func |= STR_FUNC_TERM;
12464  }
12465  }
12466 
12467  tokfix();
12468  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12469  flush_string_content(enc);
12470 
12471  return tSTRING_CONTENT;
12472 }
12473 
12474 static enum yytokentype
12475 parser_heredoc_identifier(struct parser_params *parser)
12476 {
12477  int c = nextc(), term, func = 0;
12478  enum yytokentype token = tSTRING_BEG;
12479  long len;
12480  int newline = 0;
12481  int indent = 0;
12482 
12483  if (c == '-') {
12484  c = nextc();
12485  func = STR_FUNC_INDENT;
12486  }
12487  else if (c == '~') {
12488  c = nextc();
12489  func = STR_FUNC_INDENT;
12490  indent = INT_MAX;
12491  }
12492  switch (c) {
12493  case '\'':
12494  func |= str_squote; goto quoted;
12495  case '"':
12496  func |= str_dquote; goto quoted;
12497  case '`':
12498  token = tXSTRING_BEG;
12499  func |= str_xquote; goto quoted;
12500 
12501  quoted:
12502  newtok();
12503  tokadd(func);
12504  term = c;
12505  while ((c = nextc()) != -1 && c != term) {
12506  if (tokadd_mbchar(c) == -1) return 0;
12507  if (!newline && c == '\n') newline = 1;
12508  else if (newline) newline = 2;
12509  }
12510  if (c == -1) {
12511  compile_error(PARSER_ARG "unterminated here document identifier");
12512  return 0;
12513  }
12514  switch (newline) {
12515  case 1:
12516  rb_warn0("here document identifier ends with a newline");
12517  if (--tokidx > 0 && tokenbuf[tokidx] == '\r') --tokidx;
12518  break;
12519  case 2:
12520  compile_error(PARSER_ARG "here document identifier across newlines, never match");
12521  return -1;
12522  }
12523  break;
12524 
12525  default:
12526  if (!parser_is_identchar()) {
12527  pushback(c);
12528  if (func & STR_FUNC_INDENT) {
12529  pushback(indent > 0 ? '~' : '-');
12530  }
12531  return 0;
12532  }
12533  newtok();
12534  tokadd(func |= str_dquote);
12535  do {
12536  if (tokadd_mbchar(c) == -1) return 0;
12537  } while ((c = nextc()) != -1 && parser_is_identchar());
12538  pushback(c);
12539  break;
12540  }
12541 
12542  tokfix();
12543  dispatch_scan_event(tHEREDOC_BEG);
12544  len = lex_p - lex_pbeg;
12545  lex_goto_eol(parser);
12546  lex_strterm = rb_node_newnode(NODE_HEREDOC,
12547  STR_NEW(tok(), toklen()), /* nd_lit */
12548  len, /* nd_nth */
12549  lex_lastline); /* nd_orig */
12550  parser_set_line(lex_strterm, ruby_sourceline);
12551  token_flush(parser);
12552  heredoc_indent = indent;
12553  heredoc_line_indent = 0;
12554  return token;
12555 }
12556 
12557 static void
12558 parser_heredoc_restore(struct parser_params *parser, NODE *here)
12559 {
12560  VALUE line;
12561 
12562  lex_strterm = 0;
12563  line = here->nd_orig;
12564  lex_lastline = line;
12565  lex_pbeg = RSTRING_PTR(line);
12566  lex_pend = lex_pbeg + RSTRING_LEN(line);
12567  lex_p = lex_pbeg + here->nd_nth;
12568  heredoc_end = ruby_sourceline;
12569  ruby_sourceline = nd_line(here);
12570  dispose_string(here->nd_lit);
12571  rb_gc_force_recycle((VALUE)here);
12572  token_flush(parser);
12573 }
12574 
12575 static int
12576 dedent_string(VALUE string, int width)
12577 {
12578  char *str;
12579  long len;
12580  int i, col = 0;
12581 
12582  RSTRING_GETMEM(string, str, len);
12583  for (i = 0; i < len && col < width; i++) {
12584  if (str[i] == ' ') {
12585  col++;
12586  }
12587  else if (str[i] == '\t') {
12588  int n = TAB_WIDTH * (col / TAB_WIDTH + 1);
12589  if (n > width) break;
12590  col = n;
12591  }
12592  else {
12593  break;
12594  }
12595  }
12596  if (!i) return 0;
12597  rb_str_modify(string);
12598  str = RSTRING_PTR(string);
12599  if (RSTRING_LEN(string) != len)
12600  rb_fatal("literal string changed: %+"PRIsVALUE, string);
12601  MEMMOVE(str, str + i, char, len - i);
12602  rb_str_set_len(string, len - i);
12603  return i;
12604 }
12605 
12606 #ifndef RIPPER
12607 static NODE *
12608 parser_heredoc_dedent(struct parser_params *parser, NODE *root)
12609 {
12610  NODE *node, *str_node;
12611  int bol = TRUE;
12612  int indent = heredoc_indent;
12613 
12614  if (indent <= 0) return root;
12615  heredoc_indent = 0;
12616  if (!root) return root;
12617 
12618  node = str_node = root;
12619  if (nd_type(root) == NODE_ARRAY) str_node = root->nd_head;
12620 
12621  while (str_node) {
12622  VALUE lit = str_node->nd_lit;
12623  if (bol) dedent_string(lit, indent);
12624  bol = TRUE;
12625 
12626  str_node = 0;
12627  while ((node = node->nd_next) != 0 && nd_type(node) == NODE_ARRAY) {
12628  if ((str_node = node->nd_head) != 0) {
12629  enum node_type type = nd_type(str_node);
12630  if (type == NODE_STR || type == NODE_DSTR) break;
12631  bol = FALSE;
12632  str_node = 0;
12633  }
12634  }
12635  }
12636  return root;
12637 }
12638 #else /* RIPPER */
12639 static VALUE
12640 parser_heredoc_dedent(struct parser_params *parser, VALUE array)
12641 {
12642  int indent = heredoc_indent;
12643 
12644  if (indent <= 0) return array;
12645  heredoc_indent = 0;
12646  dispatch2(heredoc_dedent, array, INT2NUM(indent));
12647  return array;
12648 }
12649 
12650 static VALUE
12651 parser_dedent_string(VALUE self, VALUE input, VALUE width)
12652 {
12653  int wid, col;
12654 
12655  StringValue(input);
12656  wid = NUM2UINT(width);
12657  col = dedent_string(input, wid);
12658  return INT2NUM(col);
12659 }
12660 #endif
12661 
12662 static int
12663 parser_whole_match_p(struct parser_params *parser,
12664  const char *eos, long len, int indent)
12665 {
12666  const char *p = lex_pbeg;
12667  long n;
12668 
12669  if (indent) {
12670  while (*p && ISSPACE(*p)) p++;
12671  }
12672  n = lex_pend - (p + len);
12673  if (n < 0) return FALSE;
12674  if (n > 0 && p[len] != '\n') {
12675  if (p[len] != '\r') return FALSE;
12676  if (n <= 1 || p[len+1] != '\n') return FALSE;
12677  }
12678  return strncmp(eos, p, len) == 0;
12679 }
12680 
12681 #define NUM_SUFFIX_R (1<<0)
12682 #define NUM_SUFFIX_I (1<<1)
12683 #define NUM_SUFFIX_ALL 3
12684 
12685 static int
12686 parser_number_literal_suffix(struct parser_params *parser, int mask)
12687 {
12688  int c, result = 0;
12689  const char *lastp = lex_p;
12690 
12691  while ((c = nextc()) != -1) {
12692  if ((mask & NUM_SUFFIX_I) && c == 'i') {
12693  result |= (mask & NUM_SUFFIX_I);
12694  mask &= ~NUM_SUFFIX_I;
12695  /* r after i, rational of complex is disallowed */
12696  mask &= ~NUM_SUFFIX_R;
12697  continue;
12698  }
12699  if ((mask & NUM_SUFFIX_R) && c == 'r') {
12700  result |= (mask & NUM_SUFFIX_R);
12701  mask &= ~NUM_SUFFIX_R;
12702  continue;
12703  }
12704  if (!ISASCII(c) || ISALPHA(c) || c == '_') {
12705  lex_p = lastp;
12706  literal_flush(lex_p);
12707  return 0;
12708  }
12709  pushback(c);
12710  if (c == '.') {
12711  c = peekc_n(1);
12712  if (ISDIGIT(c)) {
12713  yyerror0("unexpected fraction part after numeric literal");
12714  lex_p += 2;
12715  while (parser_is_identchar()) nextc();
12716  }
12717  }
12718  break;
12719  }
12720  return result;
12721 }
12722 
12723 static enum yytokentype
12724 parser_set_number_literal(struct parser_params *parser, VALUE v,
12725  enum yytokentype type, int suffix)
12726 {
12727  if (suffix & NUM_SUFFIX_I) {
12728  v = rb_complex_raw(INT2FIX(0), v);
12729  type = tIMAGINARY;
12730  }
12731  set_yylval_literal(v);
12732  SET_LEX_STATE(EXPR_END|EXPR_ENDARG);
12733  return type;
12734 }
12735 
12736 static int
12737 parser_set_integer_literal(struct parser_params *parser, VALUE v, int suffix)
12738 {
12739  enum yytokentype type = tINTEGER;
12740  if (suffix & NUM_SUFFIX_R) {
12741  v = rb_rational_raw1(v);
12742  type = tRATIONAL;
12743  }
12744  return set_number_literal(v, type, suffix);
12745 }
12746 
12747 #ifdef RIPPER
12748 static void
12749 ripper_dispatch_heredoc_end(struct parser_params *parser)
12750 {
12751  VALUE str;
12752  if (has_delayed_token())
12753  dispatch_delayed_token(tSTRING_CONTENT);
12754  str = STR_NEW(parser->tokp, lex_pend - parser->tokp);
12755  ripper_dispatch1(parser, ripper_token2eventid(tHEREDOC_END), str);
12756  lex_goto_eol(parser);
12757  token_flush(parser);
12758 }
12759 
12760 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
12761 #else
12762 #define dispatch_heredoc_end() ((void)0)
12763 #endif
12764 
12765 static enum yytokentype
12766 parser_here_document(struct parser_params *parser, NODE *here)
12767 {
12768  int c, func, indent = 0;
12769  const char *eos, *p, *pend;
12770  long len;
12771  VALUE str = 0;
12772  rb_encoding *enc = current_enc;
12773 
12774  eos = RSTRING_PTR(here->nd_lit);
12775  len = RSTRING_LEN(here->nd_lit) - 1;
12776  indent = (func = *eos++) & STR_FUNC_INDENT;
12777 
12778  if ((c = nextc()) == -1) {
12779  error:
12780  compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
12781 #ifdef RIPPER
12782  if (!has_delayed_token()) {
12783  dispatch_scan_event(tSTRING_CONTENT);
12784  }
12785  else {
12786  if (str) {
12787  rb_str_append(parser->delayed, str);
12788  }
12789  else if ((len = lex_p - parser->tokp) > 0) {
12790  if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
12791  int cr = ENC_CODERANGE_UNKNOWN;
12792  rb_str_coderange_scan_restartable(parser->tokp, lex_p, enc, &cr);
12793  if (cr != ENC_CODERANGE_7BIT &&
12794  current_enc == rb_usascii_encoding() &&
12795  enc != rb_utf8_encoding()) {
12796  enc = rb_ascii8bit_encoding();
12797  }
12798  }
12799  rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
12800  }
12801  dispatch_delayed_token(tSTRING_CONTENT);
12802  }
12803  lex_goto_eol(parser);
12804 #endif
12805  restore:
12806  heredoc_restore(lex_strterm);
12807  lex_strterm = 0;
12808  return 0;
12809  }
12810  if (was_bol() && whole_match_p(eos, len, indent)) {
12811  dispatch_heredoc_end();
12812  heredoc_restore(lex_strterm);
12813  lex_strterm = 0;
12814  SET_LEX_STATE(EXPR_END);
12815  return tSTRING_END;
12816  }
12817 
12818  if (!(func & STR_FUNC_EXPAND)) {
12819  do {
12820  p = RSTRING_PTR(lex_lastline);
12821  pend = lex_pend;
12822  if (pend > p) {
12823  switch (pend[-1]) {
12824  case '\n':
12825  if (--pend == p || pend[-1] != '\r') {
12826  pend++;
12827  break;
12828  }
12829  case '\r':
12830  --pend;
12831  }
12832  }
12833 
12834  if (heredoc_indent > 0) {
12835  long i = 0;
12836  while (p + i < pend && parser_update_heredoc_indent(parser, p[i]))
12837  i++;
12838  heredoc_line_indent = 0;
12839  }
12840 
12841  if (str)
12842  rb_str_cat(str, p, pend - p);
12843  else
12844  str = STR_NEW(p, pend - p);
12845  if (pend < lex_pend) rb_str_cat(str, "\n", 1);
12846  lex_goto_eol(parser);
12847  if (heredoc_indent > 0) {
12848  set_yylval_str(str);
12849  flush_string_content(enc);
12850  return tSTRING_CONTENT;
12851  }
12852  if (nextc() == -1) {
12853  if (str) {
12854  dispose_string(str);
12855  str = 0;
12856  }
12857  goto error;
12858  }
12859  } while (!whole_match_p(eos, len, indent));
12860  }
12861  else {
12862  /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
12863  newtok();
12864  if (c == '#') {
12865  int t = parser_peek_variable_name(parser);
12866  if (heredoc_line_indent != -1) {
12867  if (heredoc_indent > heredoc_line_indent) {
12868  heredoc_indent = heredoc_line_indent;
12869  }
12870  heredoc_line_indent = -1;
12871  }
12872  if (t) return t;
12873  tokadd('#');
12874  c = nextc();
12875  }
12876  do {
12877  pushback(c);
12878  if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
12879  if (parser->eofp) goto error;
12880  goto restore;
12881  }
12882  if (c != '\n') {
12883  flush:
12884  set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
12885  flush_string_content(enc);
12886  return tSTRING_CONTENT;
12887  }
12888  tokadd(nextc());
12889  if (heredoc_indent > 0) {
12890  lex_goto_eol(parser);
12891  goto flush;
12892  }
12893  /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
12894  if ((c = nextc()) == -1) goto error;
12895  } while (!whole_match_p(eos, len, indent));
12896  str = STR_NEW3(tok(), toklen(), enc, func);
12897  }
12898  dispatch_heredoc_end();
12899 #ifdef RIPPER
12900  str = ripper_new_yylval(ripper_token2eventid(tSTRING_CONTENT),
12901  yylval.val, str);
12902 #endif
12903  heredoc_restore(lex_strterm);
12904  lex_strterm = NEW_STRTERM(func | STR_FUNC_TERM, 0, 0);
12905  set_yylval_str(str);
12906  return tSTRING_CONTENT;
12907 }
12908 
12909 #include "lex.c"
12910 
12911 static void
12912 arg_ambiguous_gen(struct parser_params *parser, char c)
12913 {
12914 #ifndef RIPPER
12915  rb_warning1("ambiguous first argument; put parentheses or a space even after `%c' operator", WARN_I(c));
12916 #else
12917  dispatch1(arg_ambiguous, rb_usascii_str_new(&c, 1));
12918 #endif
12919 }
12920 #define arg_ambiguous(c) (arg_ambiguous_gen(parser, (c)), 1)
12921 
12922 static ID
12923 formal_argument_gen(struct parser_params *parser, ID lhs)
12924 {
12925  switch (id_type(lhs)) {
12926  case ID_LOCAL:
12927  break;
12928 #ifndef RIPPER
12929  case ID_CONST:
12930  yyerror0("formal argument cannot be a constant");
12931  return 0;
12932  case ID_INSTANCE:
12933  yyerror0("formal argument cannot be an instance variable");
12934  return 0;
12935  case ID_GLOBAL:
12936  yyerror0("formal argument cannot be a global variable");
12937  return 0;
12938  case ID_CLASS:
12939  yyerror0("formal argument cannot be a class variable");
12940  return 0;
12941  default:
12942  yyerror0("formal argument must be local variable");
12943  return 0;
12944 #else
12945  default:
12946  lhs = dispatch1(param_error, lhs);
12947  ripper_error();
12948  return 0;
12949 #endif
12950  }
12951  shadowing_lvar(lhs);
12952  return lhs;
12953 }
12954 
12955 static int
12956 lvar_defined_gen(struct parser_params *parser, ID id)
12957 {
12958  return (dyna_in_block() && dvar_defined(id)) || local_id(id);
12959 }
12960 
12961 /* emacsen -*- hack */
12962 static long
12963 parser_encode_length(struct parser_params *parser, const char *name, long len)
12964 {
12965  long nlen;
12966 
12967  if (len > 5 && name[nlen = len - 5] == '-') {
12968  if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
12969  return nlen;
12970  }
12971  if (len > 4 && name[nlen = len - 4] == '-') {
12972  if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
12973  return nlen;
12974  if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
12975  !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
12976  /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
12977  return nlen;
12978  }
12979  return len;
12980 }
12981 
12982 static void
12983 parser_set_encode(struct parser_params *parser, const char *name)
12984 {
12985  int idx = rb_enc_find_index(name);
12986  rb_encoding *enc;
12987  VALUE excargs[3];
12988 
12989  if (idx < 0) {
12990  excargs[1] = rb_sprintf("unknown encoding name: %s", name);
12991  error:
12992  excargs[0] = rb_eArgError;
12993  excargs[2] = rb_make_backtrace();
12994  rb_ary_unshift(excargs[2], rb_sprintf("%"PRIsVALUE":%d", ruby_sourcefile_string, ruby_sourceline));
12995  rb_exc_raise(rb_make_exception(3, excargs));
12996  }
12997  enc = rb_enc_from_index(idx);
12998  if (!rb_enc_asciicompat(enc)) {
12999  excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
13000  goto error;
13001  }
13002  parser->enc = enc;
13003 #ifndef RIPPER
13004  if (ruby_debug_lines) {
13005  VALUE lines = ruby_debug_lines;
13006  long i, n = RARRAY_LEN(lines);
13007  for (i = 0; i < n; ++i) {
13008  rb_enc_associate_index(RARRAY_AREF(lines, i), idx);
13009  }
13010  }
13011 #endif
13012 }
13013 
13014 static int
13015 comment_at_top(struct parser_params *parser)
13016 {
13017  const char *p = lex_pbeg, *pend = lex_p - 1;
13018  if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
13019  while (p < pend) {
13020  if (!ISSPACE(*p)) return 0;
13021  p++;
13022  }
13023  return 1;
13024 }
13025 
13026 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
13027 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
13028 
13029 static void
13030 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
13031 {
13032  if (!comment_at_top(parser)) {
13033  return;
13034  }
13035  parser_set_encode(parser, val);
13036 }
13037 
13038 static int
13039 parser_get_bool(struct parser_params *parser, const char *name, const char *val)
13040 {
13041  switch (*val) {
13042  case 't': case 'T':
13043  if (strcasecmp(val, "true") == 0) {
13044  return TRUE;
13045  }
13046  break;
13047  case 'f': case 'F':
13048  if (strcasecmp(val, "false") == 0) {
13049  return FALSE;
13050  }
13051  break;
13052  }
13053  rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
13054  return -1;
13055 }
13056 
13057 static void
13058 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
13059 {
13060  int b = parser_get_bool(parser, name, val);
13061  if (b >= 0) parser->token_info_enabled = b;
13062 }
13063 
13064 static void
13065 parser_set_compile_option_flag(struct parser_params *parser, const char *name, const char *val)
13066 {
13067  int b;
13068 
13069  if (parser->token_seen) {
13070  rb_warning1("`%s' is ignored after any tokens", WARN_S(name));
13071  return;
13072  }
13073 
13074  b = parser_get_bool(parser, name, val);
13075  if (b < 0) return;
13076 
13077  if (!parser->compile_option)
13078  parser->compile_option = rb_obj_hide(rb_ident_hash_new());
13079  rb_hash_aset(parser->compile_option, ID2SYM(rb_intern(name)),
13080  (b ? Qtrue : Qfalse));
13081 }
13082 
13083 # if WARN_PAST_SCOPE
13084 static void
13085 parser_set_past_scope(struct parser_params *parser, const char *name, const char *val)
13086 {
13087  int b = parser_get_bool(parser, name, val);
13088  if (b >= 0) parser->past_scope_enabled = b;
13089 }
13090 # endif
13091 
13092 struct magic_comment {
13093  const char *name;
13094  rb_magic_comment_setter_t func;
13095  rb_magic_comment_length_t length;
13096 };
13097 
13098 static const struct magic_comment magic_comments[] = {
13099  {"coding", magic_comment_encoding, parser_encode_length},
13100  {"encoding", magic_comment_encoding, parser_encode_length},
13101  {"frozen_string_literal", parser_set_compile_option_flag},
13102  {"warn_indent", parser_set_token_info},
13103 # if WARN_PAST_SCOPE
13104  {"warn_past_scope", parser_set_past_scope},
13105 # endif
13106 };
13107 
13108 static const char *
13109 magic_comment_marker(const char *str, long len)
13110 {
13111  long i = 2;
13112 
13113  while (i < len) {
13114  switch (str[i]) {
13115  case '-':
13116  if (str[i-1] == '*' && str[i-2] == '-') {
13117  return str + i + 1;
13118  }
13119  i += 2;
13120  break;
13121  case '*':
13122  if (i + 1 >= len) return 0;
13123  if (str[i+1] != '-') {
13124  i += 4;
13125  }
13126  else if (str[i-1] != '-') {
13127  i += 2;
13128  }
13129  else {
13130  return str + i + 2;
13131  }
13132  break;
13133  default:
13134  i += 3;
13135  break;
13136  }
13137  }
13138  return 0;
13139 }
13140 
13141 static int
13142 parser_magic_comment(struct parser_params *parser, const char *str, long len)
13143 {
13144  int indicator = 0;
13145  VALUE name = 0, val = 0;
13146  const char *beg, *end, *vbeg, *vend;
13147 #define str_copy(_s, _p, _n) ((_s) \
13148  ? (void)(rb_str_resize((_s), (_n)), \
13149  MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
13150  : (void)((_s) = STR_NEW((_p), (_n))))
13151 
13152  if (len <= 7) return FALSE;
13153  if (!!(beg = magic_comment_marker(str, len))) {
13154  if (!(end = magic_comment_marker(beg, str + len - beg)))
13155  return FALSE;
13156  indicator = TRUE;
13157  str = beg;
13158  len = end - beg - 3;
13159  }
13160 
13161  /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
13162  while (len > 0) {
13163  const struct magic_comment *p = magic_comments;
13164  char *s;
13165  int i;
13166  long n = 0;
13167 
13168  for (; len > 0 && *str; str++, --len) {
13169  switch (*str) {
13170  case '\'': case '"': case ':': case ';':
13171  continue;
13172  }
13173  if (!ISSPACE(*str)) break;
13174  }
13175  for (beg = str; len > 0; str++, --len) {
13176  switch (*str) {
13177  case '\'': case '"': case ':': case ';':
13178  break;
13179  default:
13180  if (ISSPACE(*str)) break;
13181  continue;
13182  }
13183  break;
13184  }
13185  for (end = str; len > 0 && ISSPACE(*str); str++, --len);
13186  if (!len) break;
13187  if (*str != ':') {
13188  if (!indicator) return FALSE;
13189  continue;
13190  }
13191 
13192  do str++; while (--len > 0 && ISSPACE(*str));
13193  if (!len) break;
13194  if (*str == '"') {
13195  for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
13196  if (*str == '\\') {
13197  --len;
13198  ++str;
13199  }
13200  }
13201  vend = str;
13202  if (len) {
13203  --len;
13204  ++str;
13205  }
13206  }
13207  else {
13208  for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
13209  vend = str;
13210  }
13211  if (indicator) {
13212  while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
13213  }
13214  else {
13215  while (len > 0 && (ISSPACE(*str))) --len, str++;
13216  if (len) return FALSE;
13217  }
13218 
13219  n = end - beg;
13220  str_copy(name, beg, n);
13221  s = RSTRING_PTR(name);
13222  for (i = 0; i < n; ++i) {
13223  if (s[i] == '-') s[i] = '_';
13224  }
13225  do {
13226  if (STRNCASECMP(p->name, s, n) == 0 && !p->name[n]) {
13227  n = vend - vbeg;
13228  if (p->length) {
13229  n = (*p->length)(parser, vbeg, n);
13230  }
13231  str_copy(val, vbeg, n);
13232  (*p->func)(parser, p->name, RSTRING_PTR(val));
13233  break;
13234  }
13235  } while (++p < magic_comments + numberof(magic_comments));
13236 #ifdef RIPPER
13237  str_copy(val, vbeg, vend - vbeg);
13238  dispatch2(magic_comment, name, val);
13239 #endif
13240  }
13241 
13242  return TRUE;
13243 }
13244 
13245 static void
13246 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
13247 {
13248  int sep = 0;
13249  const char *beg = str;
13250  VALUE s;
13251 
13252  for (;;) {
13253  if (send - str <= 6) return;
13254  switch (str[6]) {
13255  case 'C': case 'c': str += 6; continue;
13256  case 'O': case 'o': str += 5; continue;
13257  case 'D': case 'd': str += 4; continue;
13258  case 'I': case 'i': str += 3; continue;
13259  case 'N': case 'n': str += 2; continue;
13260  case 'G': case 'g': str += 1; continue;
13261  case '=': case ':':
13262  sep = 1;
13263  str += 6;
13264  break;
13265  default:
13266  str += 6;
13267  if (ISSPACE(*str)) break;
13268  continue;
13269  }
13270  if (STRNCASECMP(str-6, "coding", 6) == 0) break;
13271  }
13272  for (;;) {
13273  do {
13274  if (++str >= send) return;
13275  } while (ISSPACE(*str));
13276  if (sep) break;
13277  if (*str != '=' && *str != ':') return;
13278  sep = 1;
13279  str++;
13280  }
13281  beg = str;
13282  while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
13283  s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
13284  parser_set_encode(parser, RSTRING_PTR(s));
13285  rb_str_resize(s, 0);
13286 }
13287 
13288 static void
13289 parser_prepare(struct parser_params *parser)
13290 {
13291  int c = nextc();
13292  parser->token_info_enabled = !compile_for_eval && RTEST(ruby_verbose);
13293  switch (c) {
13294  case '#':
13295  if (peek('!')) parser->has_shebang = 1;
13296  break;
13297  case 0xef: /* UTF-8 BOM marker */
13298  if (lex_pend - lex_p >= 2 &&
13299  (unsigned char)lex_p[0] == 0xbb &&
13300  (unsigned char)lex_p[1] == 0xbf) {
13301  parser->enc = rb_utf8_encoding();
13302  lex_p += 2;
13303  lex_pbeg = lex_p;
13304  return;
13305  }
13306  break;
13307  case EOF:
13308  return;
13309  }
13310  pushback(c);
13311  parser->enc = rb_enc_get(lex_lastline);
13312 }
13313 
13314 #ifndef RIPPER
13315 #define ambiguous_operator(tok, op, syn) ( \
13316  rb_warning0("`"op"' after local variable or literal is interpreted as binary operator"), \
13317  rb_warning0("even though it seems like "syn""))
13318 #else
13319 #define ambiguous_operator(tok, op, syn) \
13320  dispatch2(operator_ambiguous, TOKEN2VAL(tok), rb_str_new_cstr(syn))
13321 #endif
13322 #define warn_balanced(tok, op, syn) ((void) \
13323  (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN) && \
13324  space_seen && !ISSPACE(c) && \
13325  (ambiguous_operator(tok, op, syn), 0)), \
13326  (enum yytokentype)(tok))
13327 
13328 static VALUE
13329 parse_rational(struct parser_params *parser, char *str, int len, int seen_point)
13330 {
13331  VALUE v;
13332  char *point = &str[seen_point];
13333  size_t fraclen = len-seen_point-1;
13334  memmove(point, point+1, fraclen+1);
13335  v = rb_cstr_to_inum(str, 10, FALSE);
13336  return rb_rational_new(v, rb_int_positive_pow(10, fraclen));
13337 }
13338 
13339 static int
13340 parse_numeric(struct parser_params *parser, int c)
13341 {
13342  int is_float, seen_point, seen_e, nondigit;
13343  int suffix;
13344 
13345  is_float = seen_point = seen_e = nondigit = 0;
13346  SET_LEX_STATE(EXPR_END);
13347  newtok();
13348  if (c == '-' || c == '+') {
13349  tokadd(c);
13350  c = nextc();
13351  }
13352  if (c == '0') {
13353 #define no_digits() do {yyerror0("numeric literal without digits"); return 0;} while (0)
13354  int start = toklen();
13355  c = nextc();
13356  if (c == 'x' || c == 'X') {
13357  /* hexadecimal */
13358  c = nextc();
13359  if (c != -1 && ISXDIGIT(c)) {
13360  do {
13361  if (c == '_') {
13362  if (nondigit) break;
13363  nondigit = c;
13364  continue;
13365  }
13366  if (!ISXDIGIT(c)) break;
13367  nondigit = 0;
13368  tokadd(c);
13369  } while ((c = nextc()) != -1);
13370  }
13371  pushback(c);
13372  tokfix();
13373  if (toklen() == start) {
13374  no_digits();
13375  }
13376  else if (nondigit) goto trailing_uc;
13377  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
13378  return set_integer_literal(rb_cstr_to_inum(tok(), 16, FALSE), suffix);
13379  }
13380  if (c == 'b' || c == 'B') {
13381  /* binary */
13382  c = nextc();
13383  if (c == '0' || c == '1') {
13384  do {
13385  if (c == '_') {
13386  if (nondigit) break;
13387  nondigit = c;
13388  continue;
13389  }
13390  if (c != '0' && c != '1') break;
13391  nondigit = 0;
13392  tokadd(c);
13393  } while ((c = nextc()) != -1);
13394  }
13395  pushback(c);
13396  tokfix();
13397  if (toklen() == start) {
13398  no_digits();
13399  }
13400  else if (nondigit) goto trailing_uc;
13401  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
13402  return set_integer_literal(rb_cstr_to_inum(tok(), 2, FALSE), suffix);
13403  }
13404  if (c == 'd' || c == 'D') {
13405  /* decimal */
13406  c = nextc();
13407  if (c != -1 && ISDIGIT(c)) {
13408  do {
13409  if (c == '_') {
13410  if (nondigit) break;
13411  nondigit = c;
13412  continue;
13413  }
13414  if (!ISDIGIT(c)) break;
13415  nondigit = 0;
13416  tokadd(c);
13417  } while ((c = nextc()) != -1);
13418  }
13419  pushback(c);
13420  tokfix();
13421  if (toklen() == start) {
13422  no_digits();
13423  }
13424  else if (nondigit) goto trailing_uc;
13425  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
13426  return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
13427  }
13428  if (c == '_') {
13429  /* 0_0 */
13430  goto octal_number;
13431  }
13432  if (c == 'o' || c == 'O') {
13433  /* prefixed octal */
13434  c = nextc();
13435  if (c == -1 || c == '_' || !ISDIGIT(c)) {
13436  no_digits();
13437  }
13438  }
13439  if (c >= '0' && c <= '7') {
13440  /* octal */
13441  octal_number:
13442  do {
13443  if (c == '_') {
13444  if (nondigit) break;
13445  nondigit = c;
13446  continue;
13447  }
13448  if (c < '0' || c > '9') break;
13449  if (c > '7') goto invalid_octal;
13450  nondigit = 0;
13451  tokadd(c);
13452  } while ((c = nextc()) != -1);
13453  if (toklen() > start) {
13454  pushback(c);
13455  tokfix();
13456  if (nondigit) goto trailing_uc;
13457  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
13458  return set_integer_literal(rb_cstr_to_inum(tok(), 8, FALSE), suffix);
13459  }
13460  if (nondigit) {
13461  pushback(c);
13462  goto trailing_uc;
13463  }
13464  }
13465  if (c > '7' && c <= '9') {
13466  invalid_octal:
13467  yyerror0("Invalid octal digit");
13468  }
13469  else if (c == '.' || c == 'e' || c == 'E') {
13470  tokadd('0');
13471  }
13472  else {
13473  pushback(c);
13474  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
13475  return set_integer_literal(INT2FIX(0), suffix);
13476  }
13477  }
13478 
13479  for (;;) {
13480  switch (c) {
13481  case '0': case '1': case '2': case '3': case '4':
13482  case '5': case '6': case '7': case '8': case '9':
13483  nondigit = 0;
13484  tokadd(c);
13485  break;
13486 
13487  case '.':
13488  if (nondigit) goto trailing_uc;
13489  if (seen_point || seen_e) {
13490  goto decode_num;
13491  }
13492  else {
13493  int c0 = nextc();
13494  if (c0 == -1 || !ISDIGIT(c0)) {
13495  pushback(c0);
13496  goto decode_num;
13497  }
13498  c = c0;
13499  }
13500  seen_point = toklen();
13501  tokadd('.');
13502  tokadd(c);
13503  is_float++;
13504  nondigit = 0;
13505  break;
13506 
13507  case 'e':
13508  case 'E':
13509  if (nondigit) {
13510  pushback(c);
13511  c = nondigit;
13512  goto decode_num;
13513  }
13514  if (seen_e) {
13515  goto decode_num;
13516  }
13517  nondigit = c;
13518  c = nextc();
13519  if (c != '-' && c != '+' && !ISDIGIT(c)) {
13520  pushback(c);
13521  nondigit = 0;
13522  goto decode_num;
13523  }
13524  tokadd(nondigit);
13525  seen_e++;
13526  is_float++;
13527  tokadd(c);
13528  nondigit = (c == '-' || c == '+') ? c : 0;
13529  break;
13530 
13531  case '_': /* `_' in number just ignored */
13532  if (nondigit) goto decode_num;
13533  nondigit = c;
13534  break;
13535 
13536  default:
13537  goto decode_num;
13538  }
13539  c = nextc();
13540  }
13541 
13542  decode_num:
13543  pushback(c);
13544  if (nondigit) {
13545  char tmp[30];
13546  trailing_uc:
13547  literal_flush(lex_p - 1);
13548  snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
13549  yyerror0(tmp);
13550  }
13551  tokfix();
13552  if (is_float) {
13553  int type = tFLOAT;
13554  VALUE v;
13555 
13556  suffix = number_literal_suffix(seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
13557  if (suffix & NUM_SUFFIX_R) {
13558  type = tRATIONAL;
13559  v = parse_rational(parser, tok(), toklen(), seen_point);
13560  }
13561  else {
13562  double d = strtod(tok(), 0);
13563  if (errno == ERANGE) {
13564  rb_warning1("Float %s out of range", WARN_S(tok()));
13565  errno = 0;
13566  }
13567  v = DBL2NUM(d);
13568  }
13569  return set_number_literal(v, type, suffix);
13570  }
13571  suffix = number_literal_suffix(NUM_SUFFIX_ALL);
13572  return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
13573 }
13574 
13575 static enum yytokentype
13576 parse_qmark(struct parser_params *parser, int space_seen)
13577 {
13578  rb_encoding *enc;
13579  register int c;
13580 
13581  if (IS_END()) {
13582  SET_LEX_STATE(EXPR_VALUE);
13583  return '?';
13584  }
13585  c = nextc();
13586  if (c == -1) {
13587  compile_error(PARSER_ARG "incomplete character syntax");
13588  return 0;
13589  }
13590  if (rb_enc_isspace(c, current_enc)) {
13591  if (!IS_ARG()) {
13592  int c2 = 0;
13593  switch (c) {
13594  case ' ':
13595  c2 = 's';
13596  break;
13597  case '\n':
13598  c2 = 'n';
13599  break;
13600  case '\t':
13601  c2 = 't';
13602  break;
13603  case '\v':
13604  c2 = 'v';
13605  break;
13606  case '\r':
13607  c2 = 'r';
13608  break;
13609  case '\f':
13610  c2 = 'f';
13611  break;
13612  }
13613  if (c2) {
13614  rb_warn1("invalid character syntax; use ?\\%c", WARN_I(c2));
13615  }
13616  }
13617  ternary:
13618  pushback(c);
13619  SET_LEX_STATE(EXPR_VALUE);
13620  return '?';
13621  }
13622  newtok();
13623  enc = current_enc;
13624  if (!parser_isascii()) {
13625  if (tokadd_mbchar(c) == -1) return 0;
13626  }
13627  else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
13628  lex_p < lex_pend && is_identchar(lex_p, lex_pend, current_enc)) {
13629  if (space_seen) {
13630  const char *start = lex_p - 1, *p = start;
13631  do {
13632  int n = parser_precise_mbclen(parser, p);
13633  if (n < 0) return -1;
13634  p += n;
13635  } while (p < lex_pend && is_identchar(p, lex_pend, current_enc));
13636  rb_warn2("`?' just followed by `%.*s' is interpreted as" \
13637  " a conditional operator, put a space after `?'",
13638  WARN_I((int)(p - start)), WARN_S_L(start, (p - start)));
13639  }
13640  goto ternary;
13641  }
13642  else if (c == '\\') {
13643  if (peek('u')) {
13644  nextc();
13645  enc = rb_utf8_encoding();
13646  if (!parser_tokadd_utf8(parser, &enc, -1, 0, 0))
13647  return 0;
13648  }
13649  else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
13650  nextc();
13651  if (tokadd_mbchar(c) == -1) return 0;
13652  }
13653  else {
13654  c = read_escape(0, &enc);
13655  tokadd(c);
13656  }
13657  }
13658  else {
13659  tokadd(c);
13660  }
13661  tokfix();
13662  set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
13663  SET_LEX_STATE(EXPR_END);
13664  return tCHAR;
13665 }
13666 
13667 static enum yytokentype
13668 parse_percent(struct parser_params *parser, const int space_seen, const enum lex_state_e last_state)
13669 {
13670  register int c;
13671 
13672  if (IS_BEG()) {
13673  int term;
13674  int paren;
13675 
13676  c = nextc();
13677  quotation:
13678  if (c == -1 || !ISALNUM(c)) {
13679  term = c;
13680  c = 'Q';
13681  }
13682  else {
13683  term = nextc();
13684  if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
13685  yyerror0("unknown type of %string");
13686  return 0;
13687  }
13688  }
13689  if (c == -1 || term == -1) {
13690  compile_error(PARSER_ARG "unterminated quoted string meets end of file");
13691  return 0;
13692  }
13693  paren = term;
13694  if (term == '(') term = ')';
13695  else if (term == '[') term = ']';
13696  else if (term == '{') term = '}';
13697  else if (term == '<') term = '>';
13698  else paren = 0;
13699 
13700  switch (c) {
13701  case 'Q':
13702  lex_strterm = NEW_STRTERM(str_dquote, term, paren);
13703  return tSTRING_BEG;
13704 
13705  case 'q':
13706  lex_strterm = NEW_STRTERM(str_squote, term, paren);
13707  return tSTRING_BEG;
13708 
13709  case 'W':
13710  lex_strterm = NEW_STRTERM(str_dword, term, paren);
13711  do {c = nextc();} while (ISSPACE(c));
13712  pushback(c);
13713  return tWORDS_BEG;
13714 
13715  case 'w':
13716  lex_strterm = NEW_STRTERM(str_sword, term, paren);
13717  do {c = nextc();} while (ISSPACE(c));
13718  pushback(c);
13719  return tQWORDS_BEG;
13720 
13721  case 'I':
13722  lex_strterm = NEW_STRTERM(str_dword, term, paren);
13723  do {c = nextc();} while (ISSPACE(c));
13724  pushback(c);
13725  return tSYMBOLS_BEG;
13726 
13727  case 'i':
13728  lex_strterm = NEW_STRTERM(str_sword, term, paren);
13729  do {c = nextc();} while (ISSPACE(c));
13730  pushback(c);
13731  return tQSYMBOLS_BEG;
13732 
13733  case 'x':
13734  lex_strterm = NEW_STRTERM(str_xquote, term, paren);
13735  return tXSTRING_BEG;
13736 
13737  case 'r':
13738  lex_strterm = NEW_STRTERM(str_regexp, term, paren);
13739  return tREGEXP_BEG;
13740 
13741  case 's':
13742  lex_strterm = NEW_STRTERM(str_ssym, term, paren);
13743  SET_LEX_STATE(EXPR_FNAME|EXPR_FITEM);
13744  return tSYMBEG;
13745 
13746  default:
13747  yyerror0("unknown type of %string");
13748  return 0;
13749  }
13750  }
13751  if ((c = nextc()) == '=') {
13752  set_yylval_id('%');
13753  SET_LEX_STATE(EXPR_BEG);
13754  return tOP_ASGN;
13755  }
13756  if (IS_SPCARG(c) || (IS_lex_state(EXPR_FITEM) && c == 's')) {
13757  goto quotation;
13758  }
13759  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
13760  pushback(c);
13761  return warn_balanced('%', "%%", "string literal");
13762 }
13763 
13764 static int
13765 tokadd_ident(struct parser_params *parser, int c)
13766 {
13767  do {
13768  if (tokadd_mbchar(c) == -1) return -1;
13769  c = nextc();
13770  } while (parser_is_identchar());
13771  pushback(c);
13772  return 0;
13773 }
13774 
13775 static ID
13776 tokenize_ident(struct parser_params *parser, const enum lex_state_e last_state)
13777 {
13778  ID ident = TOK_INTERN();
13779 
13780  set_yylval_name(ident);
13781 
13782  return ident;
13783 }
13784 
13785 static int
13786 parse_numvar(struct parser_params *parser)
13787 {
13788  size_t len;
13789  int overflow;
13790  unsigned long n = ruby_scan_digits(tok()+1, toklen()-1, 10, &len, &overflow);
13791  const unsigned long nth_ref_max =
13792  ((FIXNUM_MAX < INT_MAX) ? FIXNUM_MAX : INT_MAX) >> 1;
13793  /* NTH_REF is left-shifted to be ORed with back-ref flag and
13794  * turned into a Fixnum, in compile.c */
13795 
13796  if (overflow || n > nth_ref_max) {
13797  /* compile_error()? */
13798  rb_warn1("`%s' is too big for a number variable, always nil", WARN_S(tok()));
13799  return 0; /* $0 is $PROGRAM_NAME, not NTH_REF */
13800  }
13801  else {
13802  return (int)n;
13803  }
13804 }
13805 
13806 static enum yytokentype
13807 parse_gvar(struct parser_params *parser, const enum lex_state_e last_state)
13808 {
13809  register int c;
13810 
13811  SET_LEX_STATE(EXPR_END);
13812  newtok();
13813  c = nextc();
13814  switch (c) {
13815  case '_': /* $_: last read line string */
13816  c = nextc();
13817  if (parser_is_identchar()) {
13818  tokadd('$');
13819  tokadd('_');
13820  break;
13821  }
13822  pushback(c);
13823  c = '_';
13824  /* fall through */
13825  case '~': /* $~: match-data */
13826  case '*': /* $*: argv */
13827  case '$': /* $$: pid */
13828  case '?': /* $?: last status */
13829  case '!': /* $!: error string */
13830  case '@': /* $@: error position */
13831  case '/': /* $/: input record separator */
13832  case '\\': /* $\: output record separator */
13833  case ';': /* $;: field separator */
13834  case ',': /* $,: output field separator */
13835  case '.': /* $.: last read line number */
13836  case '=': /* $=: ignorecase */
13837  case ':': /* $:: load path */
13838  case '<': /* $<: reading filename */
13839  case '>': /* $>: default output handle */
13840  case '\"': /* $": already loaded files */
13841  tokadd('$');
13842  tokadd(c);
13843  goto gvar;
13844 
13845  case '-':
13846  tokadd('$');
13847  tokadd(c);
13848  c = nextc();
13849  if (parser_is_identchar()) {
13850  if (tokadd_mbchar(c) == -1) return 0;
13851  }
13852  else {
13853  pushback(c);
13854  pushback('-');
13855  return '$';
13856  }
13857  gvar:
13858  set_yylval_name(TOK_INTERN());
13859  return tGVAR;
13860 
13861  case '&': /* $&: last match */
13862  case '`': /* $`: string before last match */
13863  case '\'': /* $': string after last match */
13864  case '+': /* $+: string matches last paren. */
13865  if (IS_lex_state_for(last_state, EXPR_FNAME)) {
13866  tokadd('$');
13867  tokadd(c);
13868  goto gvar;
13869  }
13870  set_yylval_node(NEW_BACK_REF(c));
13871  return tBACK_REF;
13872 
13873  case '1': case '2': case '3':
13874  case '4': case '5': case '6':
13875  case '7': case '8': case '9':
13876  tokadd('$');
13877  do {
13878  tokadd(c);
13879  c = nextc();
13880  } while (c != -1 && ISDIGIT(c));
13881  pushback(c);
13882  if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
13883  tokfix();
13884  set_yylval_node(NEW_NTH_REF(parse_numvar(parser)));
13885  return tNTH_REF;
13886 
13887  default:
13888  if (!parser_is_identchar()) {
13889  if (c == -1 || ISSPACE(c)) {
13890  compile_error(PARSER_ARG "`$' without identifiers is not allowed as a global variable name");
13891  }
13892  else {
13893  pushback(c);
13894  compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
13895  }
13896  return 0;
13897  }
13898  case '0':
13899  tokadd('$');
13900  }
13901 
13902  if (tokadd_ident(parser, c)) return 0;
13903  SET_LEX_STATE(EXPR_END);
13904  tokenize_ident(parser, last_state);
13905  return tGVAR;
13906 }
13907 
13908 static enum yytokentype
13909 parse_atmark(struct parser_params *parser, const enum lex_state_e last_state)
13910 {
13911  enum yytokentype result = tIVAR;
13912  register int c = nextc();
13913 
13914  newtok();
13915  tokadd('@');
13916  if (c == '@') {
13917  result = tCVAR;
13918  tokadd('@');
13919  c = nextc();
13920  }
13921  if (c == -1 || ISSPACE(c)) {
13922  if (result == tIVAR) {
13923  compile_error(PARSER_ARG "`@' without identifiers is not allowed as an instance variable name");
13924  }
13925  else {
13926  compile_error(PARSER_ARG "`@@' without identifiers is not allowed as a class variable name");
13927  }
13928  return 0;
13929  }
13930  else if (ISDIGIT(c) || !parser_is_identchar()) {
13931  pushback(c);
13932  if (result == tIVAR) {
13933  compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
13934  }
13935  else {
13936  compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
13937  }
13938  return 0;
13939  }
13940 
13941  if (tokadd_ident(parser, c)) return 0;
13942  SET_LEX_STATE(EXPR_END);
13943  tokenize_ident(parser, last_state);
13944  return result;
13945 }
13946 
13947 static enum yytokentype
13948 parse_ident(struct parser_params *parser, int c, int cmd_state)
13949 {
13950  enum yytokentype result;
13951  int mb = ENC_CODERANGE_7BIT;
13952  const enum lex_state_e last_state = lex_state;
13953  ID ident;
13954 
13955  do {
13956  if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
13957  if (tokadd_mbchar(c) == -1) return 0;
13958  c = nextc();
13959  } while (parser_is_identchar());
13960  if ((c == '!' || c == '?') && !peek('=')) {
13961  result = tFID;
13962  tokadd(c);
13963  }
13964  else if (c == '=' && IS_lex_state(EXPR_FNAME) &&
13965  (!peek('~') && !peek('>') && (!peek('=') || (peek_n('>', 1))))) {
13966  result = tIDENTIFIER;
13967  tokadd(c);
13968  }
13969  else {
13970  result = tCONSTANT; /* assume provisionally */
13971  pushback(c);
13972  }
13973  tokfix();
13974 
13975  if (IS_LABEL_POSSIBLE()) {
13976  if (IS_LABEL_SUFFIX(0)) {
13977  SET_LEX_STATE(EXPR_ARG|EXPR_LABELED);
13978  nextc();
13979  set_yylval_name(TOK_INTERN());
13980  return tLABEL;
13981  }
13982  }
13983  if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
13984  const struct kwtable *kw;
13985 
13986  /* See if it is a reserved word. */
13987  kw = rb_reserved_word(tok(), toklen());
13988  if (kw) {
13989  enum lex_state_e state = lex_state;
13990  SET_LEX_STATE(kw->state);
13991  if (IS_lex_state_for(state, EXPR_FNAME)) {
13992  set_yylval_name(rb_intern2(tok(), toklen()));
13993  return kw->id[0];
13994  }
13995  if (IS_lex_state(EXPR_BEG)) {
13996  command_start = TRUE;
13997  }
13998  if (kw->id[0] == keyword_do) {
13999  if (lambda_beginning_p()) {
14000  lpar_beg = 0;
14001  --paren_nest;
14002  return keyword_do_LAMBDA;
14003  }
14004  if (COND_P()) return keyword_do_cond;
14005  if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG))
14006  return keyword_do_block;
14007  if (IS_lex_state_for(state, (EXPR_BEG | EXPR_ENDARG)))
14008  return keyword_do_block;
14009  return keyword_do;
14010  }
14011  if (IS_lex_state_for(state, (EXPR_BEG | EXPR_LABELED)))
14012  return kw->id[0];
14013  else {
14014  if (kw->id[0] != kw->id[1])
14015  SET_LEX_STATE(EXPR_BEG | EXPR_LABEL);
14016  return kw->id[1];
14017  }
14018  }
14019  }
14020 
14021  if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
14022  if (cmd_state) {
14023  SET_LEX_STATE(EXPR_CMDARG);
14024  }
14025  else {
14026  SET_LEX_STATE(EXPR_ARG);
14027  }
14028  }
14029  else if (lex_state == EXPR_FNAME) {
14030  SET_LEX_STATE(EXPR_ENDFN);
14031  }
14032  else {
14033  SET_LEX_STATE(EXPR_END);
14034  }
14035 
14036  ident = tokenize_ident(parser, last_state);
14037  if (result == tCONSTANT && is_local_id(ident)) result = tIDENTIFIER;
14038  if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
14039  (result == tIDENTIFIER) && /* not EXPR_FNAME, not attrasgn */
14040  lvar_defined(ident)) {
14041  SET_LEX_STATE(EXPR_END|EXPR_LABEL);
14042  }
14043  return result;
14044 }
14045 
14046 static enum yytokentype
14047 parser_yylex(struct parser_params *parser)
14048 {
14049  register int c;
14050  int space_seen = 0;
14051  int cmd_state;
14052  int label;
14053  enum lex_state_e last_state;
14054  int fallthru = FALSE;
14055  int token_seen = parser->token_seen;
14056 
14057  if (lex_strterm) {
14058  if (nd_type(lex_strterm) == NODE_HEREDOC) {
14059  return here_document(lex_strterm);
14060  }
14061  else {
14062  return parse_string(lex_strterm);
14063  }
14064  }
14065  cmd_state = command_start;
14066  command_start = FALSE;
14067  parser->token_seen = TRUE;
14068  retry:
14069  last_state = lex_state;
14070 #ifndef RIPPER
14071  token_flush(parser);
14072 #endif
14073  switch (c = nextc()) {
14074  case '\0': /* NUL */
14075  case '\004': /* ^D */
14076  case '\032': /* ^Z */
14077  case -1: /* end of script. */
14078  return 0;
14079 
14080  /* white spaces */
14081  case ' ': case '\t': case '\f': case '\r':
14082  case '\13': /* '\v' */
14083  space_seen = 1;
14084 #ifdef RIPPER
14085  while ((c = nextc())) {
14086  switch (c) {
14087  case ' ': case '\t': case '\f': case '\r':
14088  case '\13': /* '\v' */
14089  break;
14090  default:
14091  goto outofloop;
14092  }
14093  }
14094  outofloop:
14095  pushback(c);
14096  dispatch_scan_event(tSP);
14097 #endif
14098  goto retry;
14099 
14100  case '#': /* it's a comment */
14101  parser->token_seen = token_seen;
14102  /* no magic_comment in shebang line */
14103  if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
14104  if (comment_at_top(parser)) {
14105  set_file_encoding(parser, lex_p, lex_pend);
14106  }
14107  }
14108  lex_p = lex_pend;
14109  dispatch_scan_event(tCOMMENT);
14110  fallthru = TRUE;
14111  /* fall through */
14112  case '\n':
14113  parser->token_seen = token_seen;
14114  c = (IS_lex_state(EXPR_BEG|EXPR_CLASS|EXPR_FNAME|EXPR_DOT) &&
14115  !IS_lex_state(EXPR_LABELED));
14116  if (c || IS_lex_state_all(EXPR_ARG|EXPR_LABELED)) {
14117  if (!fallthru) {
14118  dispatch_scan_event(tIGNORED_NL);
14119  }
14120  fallthru = FALSE;
14121  if (!c && parser->in_kwarg) {
14122  goto normal_newline;
14123  }
14124  goto retry;
14125  }
14126  while ((c = nextc())) {
14127  switch (c) {
14128  case ' ': case '\t': case '\f': case '\r':
14129  case '\13': /* '\v' */
14130  space_seen = 1;
14131  break;
14132  case '&':
14133  case '.': {
14134  dispatch_delayed_token(tIGNORED_NL);
14135  if (peek('.') == (c == '&')) {
14136  pushback(c);
14137  dispatch_scan_event(tSP);
14138  goto retry;
14139  }
14140  }
14141  default:
14142  --ruby_sourceline;
14143  lex_nextline = lex_lastline;
14144  case -1: /* EOF no decrement*/
14145  lex_goto_eol(parser);
14146 #ifdef RIPPER
14147  if (c != -1) {
14148  parser->tokp = lex_p;
14149  }
14150 #endif
14151  goto normal_newline;
14152  }
14153  }
14154  normal_newline:
14155  command_start = TRUE;
14156  SET_LEX_STATE(EXPR_BEG);
14157  return '\n';
14158 
14159  case '*':
14160  if ((c = nextc()) == '*') {
14161  if ((c = nextc()) == '=') {
14162  set_yylval_id(tPOW);
14163  SET_LEX_STATE(EXPR_BEG);
14164  return tOP_ASGN;
14165  }
14166  pushback(c);
14167  if (IS_SPCARG(c)) {
14168  rb_warning0("`**' interpreted as argument prefix");
14169  c = tDSTAR;
14170  }
14171  else if (IS_BEG()) {
14172  c = tDSTAR;
14173  }
14174  else {
14175  c = warn_balanced((enum ruby_method_ids)tPOW, "**", "argument prefix");
14176  }
14177  }
14178  else {
14179  if (c == '=') {
14180  set_yylval_id('*');
14181  SET_LEX_STATE(EXPR_BEG);
14182  return tOP_ASGN;
14183  }
14184  pushback(c);
14185  if (IS_SPCARG(c)) {
14186  rb_warning0("`*' interpreted as argument prefix");
14187  c = tSTAR;
14188  }
14189  else if (IS_BEG()) {
14190  c = tSTAR;
14191  }
14192  else {
14193  c = warn_balanced('*', "*", "argument prefix");
14194  }
14195  }
14196  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
14197  return c;
14198 
14199  case '!':
14200  c = nextc();
14201  if (IS_AFTER_OPERATOR()) {
14202  SET_LEX_STATE(EXPR_ARG);
14203  if (c == '@') {
14204  return '!';
14205  }
14206  }
14207  else {
14208  SET_LEX_STATE(EXPR_BEG);
14209  }
14210  if (c == '=') {
14211  return tNEQ;
14212  }
14213  if (c == '~') {
14214  return tNMATCH;
14215  }
14216  pushback(c);
14217  return '!';
14218 
14219  case '=':
14220  if (was_bol()) {
14221  /* skip embedded rd document */
14222  if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
14223  int first_p = TRUE;
14224 
14225  lex_goto_eol(parser);
14226  dispatch_scan_event(tEMBDOC_BEG);
14227  for (;;) {
14228  lex_goto_eol(parser);
14229  if (!first_p) {
14230  dispatch_scan_event(tEMBDOC);
14231  }
14232  first_p = FALSE;
14233  c = nextc();
14234  if (c == -1) {
14235  compile_error(PARSER_ARG "embedded document meets end of file");
14236  return 0;
14237  }
14238  if (c != '=') continue;
14239  if (c == '=' && strncmp(lex_p, "end", 3) == 0 &&
14240  (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
14241  break;
14242  }
14243  }
14244  lex_goto_eol(parser);
14245  dispatch_scan_event(tEMBDOC_END);
14246  goto retry;
14247  }
14248  }
14249 
14250  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
14251  if ((c = nextc()) == '=') {
14252  if ((c = nextc()) == '=') {
14253  return tEQQ;
14254  }
14255  pushback(c);
14256  return tEQ;
14257  }
14258  if (c == '~') {
14259  return tMATCH;
14260  }
14261  else if (c == '>') {
14262  return tASSOC;
14263  }
14264  pushback(c);
14265  return '=';
14266 
14267  case '<':
14268  last_state = lex_state;
14269  c = nextc();
14270  if (c == '<' &&
14271  !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
14272  !IS_END() &&
14273  (!IS_ARG() || IS_lex_state(EXPR_LABELED) || space_seen)) {
14274  int token = heredoc_identifier();
14275  if (token) return token;
14276  }
14277  if (IS_AFTER_OPERATOR()) {
14278  SET_LEX_STATE(EXPR_ARG);
14279  }
14280  else {
14281  if (IS_lex_state(EXPR_CLASS))
14282  command_start = TRUE;
14283  SET_LEX_STATE(EXPR_BEG);
14284  }
14285  if (c == '=') {
14286  if ((c = nextc()) == '>') {
14287  return tCMP;
14288  }
14289  pushback(c);
14290  return tLEQ;
14291  }
14292  if (c == '<') {
14293  if ((c = nextc()) == '=') {
14294  set_yylval_id(tLSHFT);
14295  SET_LEX_STATE(EXPR_BEG);
14296  return tOP_ASGN;
14297  }
14298  pushback(c);
14299  return warn_balanced((enum ruby_method_ids)tLSHFT, "<<", "here document");
14300  }
14301  pushback(c);
14302  return '<';
14303 
14304  case '>':
14305  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
14306  if ((c = nextc()) == '=') {
14307  return tGEQ;
14308  }
14309  if (c == '>') {
14310  if ((c = nextc()) == '=') {
14311  set_yylval_id(tRSHFT);
14312  SET_LEX_STATE(EXPR_BEG);
14313  return tOP_ASGN;
14314  }
14315  pushback(c);
14316  return tRSHFT;
14317  }
14318  pushback(c);
14319  return '>';
14320 
14321  case '"':
14322  label = (IS_LABEL_POSSIBLE() ? str_label : 0);
14323  lex_strterm = NEW_STRTERM(str_dquote | label, '"', 0);
14324  return tSTRING_BEG;
14325 
14326  case '`':
14327  if (IS_lex_state(EXPR_FNAME)) {
14328  SET_LEX_STATE(EXPR_ENDFN);
14329  return c;
14330  }
14331  if (IS_lex_state(EXPR_DOT)) {
14332  if (cmd_state)
14333  SET_LEX_STATE(EXPR_CMDARG);
14334  else
14335  SET_LEX_STATE(EXPR_ARG);
14336  return c;
14337  }
14338  lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
14339  return tXSTRING_BEG;
14340 
14341  case '\'':
14342  label = (IS_LABEL_POSSIBLE() ? str_label : 0);
14343  lex_strterm = NEW_STRTERM(str_squote | label, '\'', 0);
14344  return tSTRING_BEG;
14345 
14346  case '?':
14347  return parse_qmark(parser, space_seen);
14348 
14349  case '&':
14350  if ((c = nextc()) == '&') {
14351  SET_LEX_STATE(EXPR_BEG);
14352  if ((c = nextc()) == '=') {
14353  set_yylval_id(tANDOP);
14354  SET_LEX_STATE(EXPR_BEG);
14355  return tOP_ASGN;
14356  }
14357  pushback(c);
14358  return tANDOP;
14359  }
14360  else if (c == '=') {
14361  set_yylval_id('&');
14362  SET_LEX_STATE(EXPR_BEG);
14363  return tOP_ASGN;
14364  }
14365  else if (c == '.') {
14366  SET_LEX_STATE(EXPR_DOT);
14367  return tANDDOT;
14368  }
14369  pushback(c);
14370  if (IS_SPCARG(c)) {
14371  if ((c != ':') ||
14372  (c = peekc_n(1)) == -1 ||
14373  !(c == '\'' || c == '"' ||
14374  is_identchar((lex_p+1), lex_pend, current_enc))) {
14375  rb_warning0("`&' interpreted as argument prefix");
14376  }
14377  c = tAMPER;
14378  }
14379  else if (IS_BEG()) {
14380  c = tAMPER;
14381  }
14382  else {
14383  c = warn_balanced('&', "&", "argument prefix");
14384  }
14385  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
14386  return c;
14387 
14388  case '|':
14389  if ((c = nextc()) == '|') {
14390  SET_LEX_STATE(EXPR_BEG);
14391  if ((c = nextc()) == '=') {
14392  set_yylval_id(tOROP);
14393  SET_LEX_STATE(EXPR_BEG);
14394  return tOP_ASGN;
14395  }
14396  pushback(c);
14397  return tOROP;
14398  }
14399  if (c == '=') {
14400  set_yylval_id('|');
14401  SET_LEX_STATE(EXPR_BEG);
14402  return tOP_ASGN;
14403  }
14404  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG|EXPR_LABEL);
14405  pushback(c);
14406  return '|';
14407 
14408  case '+':
14409  c = nextc();
14410  if (IS_AFTER_OPERATOR()) {
14411  SET_LEX_STATE(EXPR_ARG);
14412  if (c == '@') {
14413  return tUPLUS;
14414  }
14415  pushback(c);
14416  return '+';
14417  }
14418  if (c == '=') {
14419  set_yylval_id('+');
14420  SET_LEX_STATE(EXPR_BEG);
14421  return tOP_ASGN;
14422  }
14423  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous('+'))) {
14424  SET_LEX_STATE(EXPR_BEG);
14425  pushback(c);
14426  if (c != -1 && ISDIGIT(c)) {
14427  return parse_numeric(parser, '+');
14428  }
14429  return tUPLUS;
14430  }
14431  SET_LEX_STATE(EXPR_BEG);
14432  pushback(c);
14433  return warn_balanced('+', "+", "unary operator");
14434 
14435  case '-':
14436  c = nextc();
14437  if (IS_AFTER_OPERATOR()) {
14438  SET_LEX_STATE(EXPR_ARG);
14439  if (c == '@') {
14440  return tUMINUS;
14441  }
14442  pushback(c);
14443  return '-';
14444  }
14445  if (c == '=') {
14446  set_yylval_id('-');
14447  SET_LEX_STATE(EXPR_BEG);
14448  return tOP_ASGN;
14449  }
14450  if (c == '>') {
14451  SET_LEX_STATE(EXPR_ENDFN);
14452  token_info_push("->");
14453  return tLAMBDA;
14454  }
14455  if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous('-'))) {
14456  SET_LEX_STATE(EXPR_BEG);
14457  pushback(c);
14458  if (c != -1 && ISDIGIT(c)) {
14459  return tUMINUS_NUM;
14460  }
14461  return tUMINUS;
14462  }
14463  SET_LEX_STATE(EXPR_BEG);
14464  pushback(c);
14465  return warn_balanced('-', "-", "unary operator");
14466 
14467  case '.':
14468  SET_LEX_STATE(EXPR_BEG);
14469  if ((c = nextc()) == '.') {
14470  if ((c = nextc()) == '.') {
14471  return tDOT3;
14472  }
14473  pushback(c);
14474  return tDOT2;
14475  }
14476  pushback(c);
14477  if (c != -1 && ISDIGIT(c)) {
14478  yyerror0("no .<digit> floating literal anymore; put 0 before dot");
14479  }
14480  SET_LEX_STATE(EXPR_DOT);
14481  return '.';
14482 
14483  case '0': case '1': case '2': case '3': case '4':
14484  case '5': case '6': case '7': case '8': case '9':
14485  return parse_numeric(parser, c);
14486 
14487  case ')':
14488  case ']':
14489  paren_nest--;
14490  case '}':
14491  COND_LEXPOP();
14492  CMDARG_LEXPOP();
14493  if (c == ')')
14494  SET_LEX_STATE(EXPR_ENDFN);
14495  else
14496  SET_LEX_STATE(EXPR_END);
14497  if (c == '}') {
14498  if (!brace_nest--) c = tSTRING_DEND;
14499  }
14500  return c;
14501 
14502  case ':':
14503  c = nextc();
14504  if (c == ':') {
14505  if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
14506  SET_LEX_STATE(EXPR_BEG);
14507  return tCOLON3;
14508  }
14509  SET_LEX_STATE(EXPR_DOT);
14510  return tCOLON2;
14511  }
14512  if (IS_END() || ISSPACE(c) || c == '#') {
14513  pushback(c);
14514  c = warn_balanced(':', ":", "symbol literal");
14515  SET_LEX_STATE(EXPR_BEG);
14516  return c;
14517  }
14518  switch (c) {
14519  case '\'':
14520  lex_strterm = NEW_STRTERM(str_ssym, c, 0);
14521  break;
14522  case '"':
14523  lex_strterm = NEW_STRTERM(str_dsym, c, 0);
14524  break;
14525  default:
14526  pushback(c);
14527  break;
14528  }
14529  SET_LEX_STATE(EXPR_FNAME);
14530  return tSYMBEG;
14531 
14532  case '/':
14533  if (IS_BEG()) {
14534  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14535  return tREGEXP_BEG;
14536  }
14537  if ((c = nextc()) == '=') {
14538  set_yylval_id('/');
14539  SET_LEX_STATE(EXPR_BEG);
14540  return tOP_ASGN;
14541  }
14542  pushback(c);
14543  if (IS_SPCARG(c)) {
14544  (void)arg_ambiguous('/');
14545  lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
14546  return tREGEXP_BEG;
14547  }
14548  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
14549  return warn_balanced('/', "/", "regexp literal");
14550 
14551  case '^':
14552  if ((c = nextc()) == '=') {
14553  set_yylval_id('^');
14554  SET_LEX_STATE(EXPR_BEG);
14555  return tOP_ASGN;
14556  }
14557  SET_LEX_STATE(IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG);
14558  pushback(c);
14559  return '^';
14560 
14561  case ';':
14562  SET_LEX_STATE(EXPR_BEG);
14563  command_start = TRUE;
14564  return ';';
14565 
14566  case ',':
14567  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
14568  return ',';
14569 
14570  case '~':
14571  if (IS_AFTER_OPERATOR()) {
14572  if ((c = nextc()) != '@') {
14573  pushback(c);
14574  }
14575  SET_LEX_STATE(EXPR_ARG);
14576  }
14577  else {
14578  SET_LEX_STATE(EXPR_BEG);
14579  }
14580  return '~';
14581 
14582  case '(':
14583  if (IS_BEG()) {
14584  c = tLPAREN;
14585  }
14586  else if (!space_seen) {
14587  /* foo( ... ) => method call, no ambiguity */
14588  }
14589  else if (IS_ARG() || IS_lex_state_all(EXPR_END|EXPR_LABEL)) {
14590  c = tLPAREN_ARG;
14591  }
14592  else if (IS_lex_state(EXPR_ENDFN) && !lambda_beginning_p()) {
14593  rb_warning0("parentheses after method name is interpreted as "
14594  "an argument list, not a decomposed argument");
14595  }
14596  paren_nest++;
14597  COND_PUSH(0);
14598  CMDARG_PUSH(0);
14599  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
14600  return c;
14601 
14602  case '[':
14603  paren_nest++;
14604  if (IS_AFTER_OPERATOR()) {
14605  if ((c = nextc()) == ']') {
14606  SET_LEX_STATE(EXPR_ARG);
14607  if ((c = nextc()) == '=') {
14608  return tASET;
14609  }
14610  pushback(c);
14611  return tAREF;
14612  }
14613  pushback(c);
14614  SET_LEX_STATE(EXPR_ARG|EXPR_LABEL);
14615  return '[';
14616  }
14617  else if (IS_BEG()) {
14618  c = tLBRACK;
14619  }
14620  else if (IS_ARG() && (space_seen || IS_lex_state(EXPR_LABELED))) {
14621  c = tLBRACK;
14622  }
14623  SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
14624  COND_PUSH(0);
14625  CMDARG_PUSH(0);
14626  return c;
14627 
14628  case '{':
14629  ++brace_nest;
14630  if (lambda_beginning_p()) {
14631  SET_LEX_STATE(EXPR_BEG);
14632  lpar_beg = 0;
14633  --paren_nest;
14634  COND_PUSH(0);
14635  CMDARG_PUSH(0);
14636  return tLAMBEG;
14637  }
14638  if (IS_lex_state(EXPR_LABELED))
14639  c = tLBRACE; /* hash */
14640  else if (IS_lex_state(EXPR_ARG_ANY | EXPR_END | EXPR_ENDFN))
14641  c = '{'; /* block (primary) */
14642  else if (IS_lex_state(EXPR_ENDARG))
14643  c = tLBRACE_ARG; /* block (expr) */
14644  else
14645  c = tLBRACE; /* hash */
14646  COND_PUSH(0);
14647  CMDARG_PUSH(0);
14648  SET_LEX_STATE(c == tLBRACE_ARG ? EXPR_BEG : EXPR_BEG|EXPR_LABEL);
14649  if (c != tLBRACE) command_start = TRUE;
14650  return c;
14651 
14652  case '\\':
14653  c = nextc();
14654  if (c == '\n') {
14655  space_seen = 1;
14656  dispatch_scan_event(tSP);
14657  goto retry; /* skip \\n */
14658  }
14659  pushback(c);
14660  return '\\';
14661 
14662  case '%':
14663  return parse_percent(parser, space_seen, last_state);
14664 
14665  case '$':
14666  return parse_gvar(parser, last_state);
14667 
14668  case '@':
14669  return parse_atmark(parser, last_state);
14670 
14671  case '_':
14672  if (was_bol() && whole_match_p("__END__", 7, 0)) {
14673  ruby__end__seen = 1;
14674  parser->eofp = 1;
14675 #ifndef RIPPER
14676  return -1;
14677 #else
14678  lex_goto_eol(parser);
14679  dispatch_scan_event(k__END__);
14680  return 0;
14681 #endif
14682  }
14683  newtok();
14684  break;
14685 
14686  default:
14687  if (!parser_is_identchar()) {
14688  compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
14689  goto retry;
14690  }
14691 
14692  newtok();
14693  break;
14694  }
14695 
14696  return parse_ident(parser, c, cmd_state);
14697 }
14698 
14699 static enum yytokentype
14700 yylex(YYSTYPE *lval, YYLTYPE *yylloc, struct parser_params *parser)
14701 {
14702  enum yytokentype t;
14703 
14704  parser->lval = lval;
14705  lval->val = Qundef;
14706  t = parser_yylex(parser);
14707  if (has_delayed_token())
14708  dispatch_delayed_token(t);
14709  else if (t != 0)
14710  dispatch_scan_event(t);
14711 
14712  yylloc->first_column = (int)(parser->tokp - lex_pbeg);
14713  yylloc->last_column = (int)(lex_p - lex_pbeg);
14714 
14715  return t;
14716 }
14717 
14718 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
14719 
14720 #ifndef RIPPER
14721 static NODE*
14722 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
14723 {
14724  NODE *n = (rb_node_newnode)(type, a0, a1, a2);
14725  nd_set_line(n, ruby_sourceline);
14726  /* mark not cared column to -1 */
14727  nd_set_column(n, -1);
14728  return n;
14729 }
14730 
14731 static enum node_type
14732 nodetype(NODE *node) /* for debug */
14733 {
14734  return (enum node_type)nd_type(node);
14735 }
14736 
14737 static int
14738 nodeline(NODE *node)
14739 {
14740  return nd_line(node);
14741 }
14742 
14743 static NODE*
14744 newline_node(NODE *node)
14745 {
14746  if (node) {
14747  node = remove_begin(node);
14748  node->flags |= NODE_FL_NEWLINE;
14749  }
14750  return node;
14751 }
14752 
14753 static void
14754 fixpos(NODE *node, NODE *orig)
14755 {
14756  if (!node) return;
14757  if (!orig) return;
14758  if (orig == (NODE*)1) return;
14759  nd_set_line(node, nd_line(orig));
14760 }
14761 
14762 static void
14763 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
14764 {
14765  rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
14766 }
14767 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
14768 
14769 static void
14770 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
14771 {
14772  rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
14773 }
14774 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
14775 
14776 static NODE*
14777 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail, int column)
14778 {
14779  NODE *end, *h = head, *nd;
14780 
14781  if (tail == 0) return head;
14782 
14783  if (h == 0) return tail;
14784  switch (nd_type(h)) {
14785  case NODE_LIT:
14786  case NODE_STR:
14787  case NODE_SELF:
14788  case NODE_TRUE:
14789  case NODE_FALSE:
14790  case NODE_NIL:
14791  parser_warning(h, "unused literal ignored");
14792  return tail;
14793  default:
14794  h = end = NEW_BLOCK(head);
14795  nd_set_column(end, column);
14796  end->nd_end = end;
14797  fixpos(end, head);
14798  head = end;
14799  break;
14800  case NODE_BLOCK:
14801  end = h->nd_end;
14802  break;
14803  }
14804 
14805  nd = end->nd_head;
14806  switch (nd_type(nd)) {
14807  case NODE_RETURN:
14808  case NODE_BREAK:
14809  case NODE_NEXT:
14810  case NODE_REDO:
14811  case NODE_RETRY:
14812  if (RTEST(ruby_verbose)) {
14813  parser_warning(tail, "statement not reached");
14814  }
14815  break;
14816 
14817  default:
14818  break;
14819  }
14820 
14821  if (nd_type(tail) != NODE_BLOCK) {
14822  tail = NEW_BLOCK(tail);
14823  nd_set_column(tail, column);
14824  tail->nd_end = tail;
14825  }
14826  end->nd_next = tail;
14827  h->nd_end = tail->nd_end;
14828  return head;
14829 }
14830 
14831 /* append item to the list */
14832 static NODE*
14833 list_append_gen(struct parser_params *parser, NODE *list, NODE *item, int column)
14834 {
14835  NODE *last;
14836 
14837  if (list == 0) return new_list(item, column);
14838  if (list->nd_next) {
14839  last = list->nd_next->nd_end;
14840  }
14841  else {
14842  last = list;
14843  }
14844 
14845  list->nd_alen += 1;
14846  last->nd_next = new_list(item, column);
14847  list->nd_next->nd_end = last->nd_next;
14848  return list;
14849 }
14850 
14851 /* concat two lists */
14852 static NODE*
14853 list_concat(NODE *head, NODE *tail)
14854 {
14855  NODE *last;
14856 
14857  if (head->nd_next) {
14858  last = head->nd_next->nd_end;
14859  }
14860  else {
14861  last = head;
14862  }
14863 
14864  head->nd_alen += tail->nd_alen;
14865  last->nd_next = tail;
14866  if (tail->nd_next) {
14867  head->nd_next->nd_end = tail->nd_next->nd_end;
14868  }
14869  else {
14870  head->nd_next->nd_end = tail;
14871  }
14872 
14873  return head;
14874 }
14875 
14876 static int
14877 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
14878 {
14879  if (NIL_P(tail)) return 1;
14880  if (!rb_enc_compatible(head, tail)) {
14881  compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
14882  rb_enc_name(rb_enc_get(head)),
14883  rb_enc_name(rb_enc_get(tail)));
14884  rb_str_resize(head, 0);
14885  rb_str_resize(tail, 0);
14886  return 0;
14887  }
14888  rb_str_buf_append(head, tail);
14889  return 1;
14890 }
14891 
14892 /* concat two string literals */
14893 static NODE *
14894 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail, int column)
14895 {
14896  enum node_type htype;
14897  NODE *headlast;
14898  VALUE lit;
14899 
14900  if (!head) return tail;
14901  if (!tail) return head;
14902 
14903  htype = nd_type(head);
14904  if (htype == NODE_EVSTR) {
14905  NODE *node = new_dstr(STR_NEW0(), column);
14906  head = list_append(node, head, column);
14907  htype = NODE_DSTR;
14908  }
14909  if (heredoc_indent > 0) {
14910  switch (htype) {
14911  case NODE_STR:
14912  nd_set_type(head, NODE_DSTR);
14913  case NODE_DSTR:
14914  return list_append(head, tail, column);
14915  default:
14916  break;
14917  }
14918  }
14919  switch (nd_type(tail)) {
14920  case NODE_STR:
14921  if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14922  nd_type(headlast) == NODE_STR) {
14923  htype = NODE_STR;
14924  lit = headlast->nd_lit;
14925  }
14926  else {
14927  lit = head->nd_lit;
14928  }
14929  if (htype == NODE_STR) {
14930  if (!literal_concat0(parser, lit, tail->nd_lit)) {
14931  error:
14932  rb_gc_force_recycle((VALUE)head);
14933  rb_gc_force_recycle((VALUE)tail);
14934  return 0;
14935  }
14936  rb_gc_force_recycle((VALUE)tail);
14937  }
14938  else {
14939  list_append(head, tail, column);
14940  }
14941  break;
14942 
14943  case NODE_DSTR:
14944  if (htype == NODE_STR) {
14945  if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
14946  goto error;
14947  tail->nd_lit = head->nd_lit;
14948  rb_gc_force_recycle((VALUE)head);
14949  head = tail;
14950  }
14951  else if (NIL_P(tail->nd_lit)) {
14952  append:
14953  head->nd_alen += tail->nd_alen - 1;
14954  head->nd_next->nd_end->nd_next = tail->nd_next;
14955  head->nd_next->nd_end = tail->nd_next->nd_end;
14956  rb_gc_force_recycle((VALUE)tail);
14957  }
14958  else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
14959  nd_type(headlast) == NODE_STR) {
14960  lit = headlast->nd_lit;
14961  if (!literal_concat0(parser, lit, tail->nd_lit))
14962  goto error;
14963  tail->nd_lit = Qnil;
14964  goto append;
14965  }
14966  else {
14967  nd_set_type(tail, NODE_ARRAY);
14968  tail->nd_head = new_str(tail->nd_lit, column);
14969  list_concat(head, tail);
14970  }
14971  break;
14972 
14973  case NODE_EVSTR:
14974  if (htype == NODE_STR) {
14975  nd_set_type(head, NODE_DSTR);
14976  head->nd_alen = 1;
14977  }
14978  list_append(head, tail, column);
14979  break;
14980  }
14981  return head;
14982 }
14983 
14984 static NODE *
14985 evstr2dstr_gen(struct parser_params *parser, NODE *node, int column)
14986 {
14987  if (nd_type(node) == NODE_EVSTR) {
14988  node = list_append(new_dstr(STR_NEW0(), column), node, column);
14989  }
14990  return node;
14991 }
14992 
14993 static NODE *
14994 new_evstr_gen(struct parser_params *parser, NODE *node, int column)
14995 {
14996  NODE *head = node;
14997  NODE *evstr;
14998 
14999  if (node) {
15000  switch (nd_type(node)) {
15001  case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
15002  return node;
15003  }
15004  }
15005  evstr = NEW_EVSTR(head);
15006  nd_set_column(evstr, column);
15007  return evstr;
15008 }
15009 
15010 static NODE *
15011 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1, int column)
15012 {
15013  NODE *expr;
15014  value_expr(recv);
15015  value_expr(arg1);
15016  expr = NEW_OPCALL(recv, id, new_list(arg1, column));
15017  fixpos(expr, recv);
15018  nd_set_column(expr, column);
15019  return expr;
15020 }
15021 
15022 static NODE *
15023 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id, int column)
15024 {
15025  NODE *opcall;
15026  value_expr(recv);
15027  opcall = NEW_OPCALL(recv, id, 0);
15028  nd_set_column(opcall, column);
15029  return opcall;
15030 }
15031 
15032 static NODE *
15033 new_qcall_gen(struct parser_params* parser, ID atype, NODE *recv, ID mid, NODE *args, int column)
15034 {
15035  NODE *qcall = NEW_QCALL(atype, recv, mid, args);
15036  nd_set_column(qcall, column);
15037  return qcall;
15038 }
15039 
15040 static NODE*
15041 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2, int column)
15042 {
15043  value_expr(node1);
15044  value_expr(node2);
15045  if (node1) {
15046  switch (nd_type(node1)) {
15047  case NODE_DREGX:
15048  case NODE_DREGX_ONCE:
15049  {
15050  NODE *match = NEW_MATCH2(node1, node2);
15051  nd_set_column(match, column);
15052  return match;
15053  }
15054 
15055  case NODE_LIT:
15056  if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
15057  const VALUE lit = node1->nd_lit;
15058  NODE *match = NEW_MATCH2(node1, node2);
15059  match->nd_args = reg_named_capture_assign(lit, column);
15060  nd_set_column(match, column);
15061  return match;
15062  }
15063  }
15064  }
15065 
15066  if (node2) {
15067  NODE *match3;
15068 
15069  switch (nd_type(node2)) {
15070  case NODE_DREGX:
15071  case NODE_DREGX_ONCE:
15072  match3 = NEW_MATCH3(node2, node1);
15073  nd_set_column(match3, column);
15074  return match3;
15075 
15076  case NODE_LIT:
15077  if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
15078  match3 = NEW_MATCH3(node2, node1);
15079  nd_set_column(match3, column);
15080  return match3;
15081  }
15082  }
15083  }
15084 
15085  return new_call(node1, tMATCH, new_list(node2, column), column);
15086 }
15087 
15088 # if WARN_PAST_SCOPE
15089 static int
15090 past_dvar_p(struct parser_params *parser, ID id)
15091 {
15092  struct vtable *past = lvtbl->past;
15093  while (past) {
15094  if (vtable_included(past, id)) return 1;
15095  past = past->prev;
15096  }
15097  return 0;
15098 }
15099 # endif
15100 
15101 static NODE*
15102 gettable_gen(struct parser_params *parser, ID id, int column)
15103 {
15104  ID *vidp = NULL;
15105  NODE *node;
15106  switch (id) {
15107  case keyword_self:
15108  node = NEW_SELF();
15109  nd_set_column(node, column);
15110  return node;
15111  case keyword_nil:
15112  node = NEW_NIL();
15113  nd_set_column(node, column);
15114  return node;
15115  case keyword_true:
15116  node = NEW_TRUE();
15117  nd_set_column(node, column);
15118  return node;
15119  case keyword_false:
15120  node = NEW_FALSE();
15121  nd_set_column(node, column);
15122  return node;
15123  case keyword__FILE__:
15124  node = new_str(rb_str_dup(ruby_sourcefile_string), column);
15125  return node;
15126  case keyword__LINE__:
15127  return new_lit(INT2FIX(tokline), column);
15128  case keyword__ENCODING__:
15129  return new_lit(rb_enc_from_encoding(current_enc), column);
15130  }
15131  switch (id_type(id)) {
15132  case ID_LOCAL:
15133  if (dyna_in_block() && dvar_defined_ref(id, vidp)) {
15134  if (id == current_arg) {
15135  rb_warn1("circular argument reference - %"PRIsWARN, rb_id2str(id));
15136  }
15137  if (vidp) *vidp |= LVAR_USED;
15138  node = new_dvar(id, column);
15139  return node;
15140  }
15141  if (local_id_ref(id, vidp)) {
15142  if (id == current_arg) {
15143  rb_warn1("circular argument reference - %"PRIsWARN, rb_id2str(id));
15144  }
15145  if (vidp) *vidp |= LVAR_USED;
15146  node = new_lvar(id, column);
15147  return node;
15148  }
15149 # if WARN_PAST_SCOPE
15150  if (!in_defined && RTEST(ruby_verbose) && past_dvar_p(parser, id)) {
15151  rb_warning1("possible reference to past scope - %"PRIsWARN, rb_id2str(id));
15152  }
15153 # endif
15154  /* method call without arguments */
15155  node = NEW_VCALL(id);
15156  nd_set_column(node, column);
15157  return node;
15158  case ID_GLOBAL:
15159  node = new_gvar(id, column);
15160  return node;
15161  case ID_INSTANCE:
15162  node = new_ivar(id, column);
15163  return node;
15164  case ID_CONST:
15165  node = NEW_CONST(id);
15166  nd_set_column(node, column);
15167  return node;
15168  case ID_CLASS:
15169  node = NEW_CVAR(id);
15170  nd_set_column(node, column);
15171  return node;
15172  }
15173  compile_error(PARSER_ARG "identifier %"PRIsVALUE" is not valid to get", rb_id2str(id));
15174  return 0;
15175 }
15176 
15177 static NODE *
15178 kwd_append(NODE *kwlist, NODE *kw)
15179 {
15180  if (kwlist) {
15181  NODE *kws = kwlist;
15182  while (kws->nd_next) {
15183  kws = kws->nd_next;
15184  }
15185  kws->nd_next = kw;
15186  }
15187  return kwlist;
15188 }
15189 
15190 static NODE *
15191 new_defined_gen(struct parser_params *parser, NODE *expr, int column)
15192 {
15193  NODE *defined = NEW_DEFINED(remove_begin_all(expr));
15194  nd_set_column(defined, column);
15195  return defined;
15196 }
15197 
15198 static NODE *
15199 new_regexp_gen(struct parser_params *parser, NODE *node, int options, int column)
15200 {
15201  NODE *list, *prev;
15202 
15203  if (!node) {
15204  return new_lit(reg_compile(STR_NEW0(), options), column);
15205  }
15206  switch (nd_type(node)) {
15207  case NODE_STR:
15208  {
15209  VALUE src = node->nd_lit;
15210  nd_set_type(node, NODE_LIT);
15211  node->nd_lit = reg_compile(src, options);
15212  }
15213  break;
15214  default:
15215  node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, new_list(node, column));
15216  nd_set_column(node, column);
15217  case NODE_DSTR:
15218  nd_set_type(node, NODE_DREGX);
15219  node->nd_cflag = options & RE_OPTION_MASK;
15220  if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
15221  for (list = (prev = node)->nd_next; list; list = list->nd_next) {
15222  if (nd_type(list->nd_head) == NODE_STR) {
15223  VALUE tail = list->nd_head->nd_lit;
15224  if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
15225  VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
15226  if (!literal_concat0(parser, lit, tail)) {
15227  node = 0;
15228  break;
15229  }
15230  rb_str_resize(tail, 0);
15231  prev->nd_next = list->nd_next;
15232  rb_gc_force_recycle((VALUE)list->nd_head);
15233  rb_gc_force_recycle((VALUE)list);
15234  list = prev;
15235  }
15236  else {
15237  prev = list;
15238  }
15239  }
15240  else {
15241  prev = 0;
15242  }
15243  }
15244  if (!node->nd_next) {
15245  VALUE src = node->nd_lit;
15246  nd_set_type(node, NODE_LIT);
15247  node->nd_lit = reg_compile(src, options);
15248  }
15249  if (options & RE_OPTION_ONCE) {
15250  node = NEW_NODE(NODE_SCOPE, 0, node, 0);
15251  }
15252  break;
15253  }
15254  return node;
15255 }
15256 
15257 static NODE *
15258 new_lit_gen(struct parser_params *parser, VALUE sym, int column)
15259 {
15260  NODE *lit = NEW_LIT(sym);
15261  nd_set_column(lit, column);
15262  return lit;
15263 }
15264 
15265 static NODE *
15266 new_list_gen(struct parser_params *parser, NODE *item, int column)
15267 {
15268  NODE *list = NEW_LIST(item);
15269  nd_set_column(list, column);
15270  return list;
15271 }
15272 
15273 static NODE *
15274 new_str_gen(struct parser_params *parser, VALUE str, int column)
15275 {
15276  NODE *nd_str = NEW_STR(str);
15277  nd_set_column(nd_str, column);
15278  return nd_str;
15279 }
15280 
15281 static NODE *
15282 new_dvar_gen(struct parser_params *parser, ID id, int column)
15283 {
15284  NODE *dvar = NEW_DVAR(id);
15285  nd_set_column(dvar, column);
15286  return dvar;
15287 }
15288 
15289 static NODE *
15290 new_resbody_gen(struct parser_params *parser, NODE *exc_list, NODE *stmt, NODE *rescue, int column)
15291 {
15292  NODE *resbody = NEW_RESBODY(exc_list, stmt, rescue);
15293  nd_set_column(resbody, column);
15294  return resbody;
15295 }
15296 
15297 static NODE *
15298 new_errinfo_gen(struct parser_params *parser, int column)
15299 {
15300  NODE *errinfo = NEW_ERRINFO();
15301  nd_set_column(errinfo, column);
15302  return errinfo;
15303 }
15304 
15305 static NODE *
15306 new_call_gen(struct parser_params *parser, NODE *recv, ID mid, NODE *args, int column)
15307 {
15308  NODE *call = NEW_CALL(recv, mid, args);
15309  nd_set_column(call, column);
15310  return call;
15311 }
15312 
15313 static NODE *
15314 new_fcall_gen(struct parser_params *parser, ID mid, NODE *args, int column)
15315 {
15316  NODE *fcall = NEW_FCALL(mid, args);
15317  nd_set_column(fcall, column);
15318  return fcall;
15319 }
15320 
15321 static NODE *
15322 new_for_gen(struct parser_params *parser, NODE *var, NODE *iter, NODE *body, int column)
15323 {
15324  NODE *nd_for = NEW_FOR(var, iter, body);
15325  nd_set_column(nd_for, column);
15326  return nd_for;
15327 }
15328 
15329 static NODE *
15330 new_gvar_gen(struct parser_params *parser, ID id, int column)
15331 {
15332  NODE *gvar = NEW_GVAR(id);
15333  nd_set_column(gvar, column);
15334  return gvar;
15335 }
15336 
15337 static NODE *
15338 new_lvar_gen(struct parser_params *parser, ID id, int column)
15339 {
15340  NODE *lvar = NEW_LVAR(id);
15341  nd_set_column(lvar, column);
15342  return lvar;
15343 }
15344 
15345 static NODE *
15346 new_dstr_gen(struct parser_params *parser, VALUE str, int column)
15347 {
15348  NODE *dstr = NEW_DSTR(str);
15349  nd_set_column(dstr, column);
15350  return dstr;
15351 }
15352 
15353 static NODE *
15354 new_rescue_gen(struct parser_params *parser, NODE *b, NODE *res, NODE *e, int column)
15355 {
15356  NODE *rescue = NEW_RESCUE(b, res, e);
15357  nd_set_column(rescue, column);
15358  return rescue;
15359 }
15360 
15361 static NODE *
15362 new_undef_gen(struct parser_params *parser, NODE *i, int column)
15363 {
15364  NODE *undef = NEW_UNDEF(i);
15365  nd_set_column(undef, column);
15366  return undef;
15367 }
15368 
15369 static NODE *
15370 new_zarray_gen(struct parser_params *parser, int column)
15371 {
15372  NODE *zarray = NEW_ZARRAY();
15373  nd_set_column(zarray, column);
15374  return zarray;
15375 }
15376 
15377 static NODE *
15378 new_ivar_gen(struct parser_params *parser, ID id, int column)
15379 {
15380  NODE *ivar = NEW_IVAR(id);
15381  nd_set_column(ivar, column);
15382  return ivar;
15383 }
15384 
15385 static NODE *
15386 new_postarg_gen(struct parser_params *parser, NODE *i, NODE *v, int column)
15387 {
15388  NODE *postarg = NEW_POSTARG(i, v);
15389  nd_set_column(postarg, column);
15390  return postarg;
15391 }
15392 
15393 static NODE *
15394 new_cdecl_gen(struct parser_params *parser, ID v, NODE *val, NODE *path, int column)
15395 {
15396  NODE *nd_cdecl = NEW_CDECL(v, val, path);
15397  nd_set_column(nd_cdecl, column);
15398  return nd_cdecl;
15399 }
15400 
15401 static NODE *
15402 new_scope_gen(struct parser_params *parser, NODE *a, NODE *b, int column)
15403 {
15404  NODE *scope = NEW_SCOPE(a, b);
15405  nd_set_column(scope, column);
15406  return scope;
15407 }
15408 
15409 static NODE *
15410 new_begin_gen(struct parser_params *parser, NODE *b, int column)
15411 {
15412  NODE *begin = NEW_BEGIN(b);
15413  nd_set_column(begin, column);
15414  return begin;
15415 }
15416 
15417 static NODE *
15418 new_masgn_gen(struct parser_params *parser, NODE *l, NODE *r, int column)
15419 {
15420  NODE *masgn = NEW_MASGN(l, r);
15421  nd_set_column(masgn, column);
15422  return masgn;
15423 }
15424 
15425 
15426 static NODE *
15427 new_kw_arg_gen(struct parser_params *parser, NODE *k, int column)
15428 {
15429  NODE *kw_arg;
15430  if (!k) return 0;
15431  kw_arg = NEW_KW_ARG(0, (k));
15432  nd_set_column(kw_arg, column);
15433  return kw_arg;
15434 }
15435 
15436 static NODE *
15437 new_xstring_gen(struct parser_params *parser, NODE *node, int column)
15438 {
15439  if (!node) {
15440  NODE *xstr = NEW_XSTR(STR_NEW0());
15441  nd_set_column(xstr, column);
15442  return xstr;
15443  }
15444  switch (nd_type(node)) {
15445  case NODE_STR:
15446  nd_set_type(node, NODE_XSTR);
15447  break;
15448  case NODE_DSTR:
15449  nd_set_type(node, NODE_DXSTR);
15450  break;
15451  default:
15452  node = NEW_NODE(NODE_DXSTR, Qnil, 1, new_list(node, column));
15453  nd_set_column(node, column);
15454  break;
15455  }
15456  return node;
15457 }
15458 
15459 static NODE *
15460 new_body_gen(struct parser_params *parser, NODE *param, NODE *stmt, int column)
15461 {
15462  NODE *iter = NEW_ITER(param, stmt);
15463  nd_set_column(iter->nd_body, column);
15464  nd_set_column(iter, column);
15465  return iter;
15466 
15467 }
15468 #else /* !RIPPER */
15469 static int
15470 id_is_var_gen(struct parser_params *parser, ID id)
15471 {
15472  if (is_notop_id(id)) {
15473  switch (id & ID_SCOPE_MASK) {
15474  case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
15475  return 1;
15476  case ID_LOCAL:
15477  if (dyna_in_block() && dvar_defined(id)) return 1;
15478  if (local_id(id)) return 1;
15479  /* method call without arguments */
15480  return 0;
15481  }
15482  }
15483  compile_error(PARSER_ARG "identifier %"PRIsVALUE" is not valid to get", rb_id2str(id));
15484  return 0;
15485 }
15486 
15487 static VALUE
15488 new_regexp_gen(struct parser_params *parser, VALUE re, VALUE opt)
15489 {
15490  VALUE src = 0, err;
15491  int options = 0;
15492  if (ripper_is_node_yylval(re)) {
15493  src = RNODE(re)->nd_cval;
15494  re = RNODE(re)->nd_rval;
15495  }
15496  if (ripper_is_node_yylval(opt)) {
15497  options = (int)RNODE(opt)->nd_tag;
15498  opt = RNODE(opt)->nd_rval;
15499  }
15500  if (src && NIL_P(parser_reg_compile(parser, src, options, &err))) {
15501  compile_error(PARSER_ARG "%"PRIsVALUE, err);
15502  }
15503  return dispatch2(regexp_literal, re, opt);
15504 }
15505 
15506 static VALUE
15507 new_xstring_gen(struct parser_params *parser, VALUE str)
15508 {
15509  return dispatch1(xstring_literal, str);
15510 }
15511 #endif /* !RIPPER */
15512 
15513 #ifndef RIPPER
15514 const char rb_parser_lex_state_names[][13] = {
15515  "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG",
15516  "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS",
15517  "EXPR_LABEL", "EXPR_LABELED","EXPR_FITEM",
15518 };
15519 
15520 static VALUE
15521 append_lex_state_name(enum lex_state_e state, VALUE buf)
15522 {
15523  int i, sep = 0;
15524  unsigned int mask = 1;
15525  static const char none[] = "EXPR_NONE";
15526 
15527  for (i = 0; i < EXPR_MAX_STATE; ++i, mask <<= 1) {
15528  if ((unsigned)state & mask) {
15529  if (sep) {
15530  rb_str_cat(buf, "|", 1);
15531  }
15532  sep = 1;
15533  rb_str_cat_cstr(buf, rb_parser_lex_state_names[i]);
15534  }
15535  }
15536  if (!sep) {
15537  rb_str_cat(buf, none, sizeof(none)-1);
15538  }
15539  return buf;
15540 }
15541 
15542 static void
15543 flush_debug_buffer(struct parser_params *parser, VALUE out, VALUE str)
15544 {
15545  VALUE mesg = parser->debug_buffer;
15546 
15547  if (!NIL_P(mesg) && RSTRING_LEN(mesg)) {
15548  parser->debug_buffer = Qnil;
15549  rb_io_puts(1, &mesg, out);
15550  }
15551  if (!NIL_P(str) && RSTRING_LEN(str)) {
15552  rb_io_write(parser->debug_output, str);
15553  }
15554 }
15555 
15556 enum lex_state_e
15557 rb_parser_trace_lex_state(struct parser_params *parser, enum lex_state_e from,
15558  enum lex_state_e to, int line)
15559 {
15560  VALUE mesg;
15561  mesg = rb_str_new_cstr("lex_state: ");
15562  append_lex_state_name(from, mesg);
15563  rb_str_cat_cstr(mesg, " -> ");
15564  append_lex_state_name(to, mesg);
15565  rb_str_catf(mesg, " at line %d\n", line);
15566  flush_debug_buffer(parser, parser->debug_output, mesg);
15567  return to;
15568 }
15569 
15570 VALUE
15571 rb_parser_lex_state_name(enum lex_state_e state)
15572 {
15573  return append_lex_state_name(state, rb_str_new(0, 0));
15574 }
15575 
15576 static void
15577 append_bitstack_value(stack_type stack, VALUE mesg)
15578 {
15579  if (stack == 0) {
15580  rb_str_cat_cstr(mesg, "0");
15581  }
15582  else {
15583  stack_type mask = (stack_type)1U << (CHAR_BIT * sizeof(stack_type) - 1);
15584  for (; mask && !(stack & mask); mask >>= 1) continue;
15585  for (; mask; mask >>= 1) rb_str_cat(mesg, stack & mask ? "1" : "0", 1);
15586  }
15587 }
15588 
15589 void
15590 rb_parser_show_bitstack(struct parser_params *parser, stack_type stack,
15591  const char *name, int line)
15592 {
15593  VALUE mesg = rb_sprintf("%s: ", name);
15594  append_bitstack_value(stack, mesg);
15595  rb_str_catf(mesg, " at line %d\n", line);
15596  flush_debug_buffer(parser, parser->debug_output, mesg);
15597 }
15598 
15599 void
15600 rb_parser_fatal(struct parser_params *parser, const char *fmt, ...)
15601 {
15602  va_list ap;
15603  VALUE mesg = rb_str_new_cstr("internal parser error: ");
15604 
15605  va_start(ap, fmt);
15606  rb_str_vcatf(mesg, fmt, ap);
15607  va_end(ap);
15608 #ifndef RIPPER
15609  parser_yyerror(parser, RSTRING_PTR(mesg));
15610  RB_GC_GUARD(mesg);
15611 #else
15612  dispatch1(parse_error, mesg);
15613  ripper_error();
15614 #endif /* !RIPPER */
15615 
15616  mesg = rb_str_new(0, 0);
15617  append_lex_state_name(lex_state, mesg);
15618  compile_error(PARSER_ARG "lex_state: %"PRIsVALUE, mesg);
15619  rb_str_resize(mesg, 0);
15620  append_bitstack_value(cond_stack, mesg);
15621  compile_error(PARSER_ARG "cond_stack: %"PRIsVALUE, mesg);
15622  rb_str_resize(mesg, 0);
15623  append_bitstack_value(cmdarg_stack, mesg);
15624  compile_error(PARSER_ARG "cmdarg_stack: %"PRIsVALUE, mesg);
15625  if (parser->debug_output == rb_stdout)
15626  parser->debug_output = rb_stderr;
15627  yydebug = TRUE;
15628 }
15629 #endif /* !RIPPER */
15630 
15631 #ifndef RIPPER
15632 static NODE*
15633 assignable_result0(NODE *node, int column)
15634 {
15635  if (node) nd_set_column(node, column);
15636  return node;
15637 }
15638 #endif /* !RIPPER */
15639 
15640 #ifdef RIPPER
15641 static VALUE
15642 assignable_gen(struct parser_params *parser, VALUE lhs)
15643 #else
15644 static NODE*
15645 assignable_gen(struct parser_params *parser, ID id, NODE *val, int column)
15646 #endif
15647 {
15648 #ifdef RIPPER
15649  ID id = get_id(lhs);
15650 # define assignable_result(x) (lhs)
15651 # define parser_yyerror(parser, x) (lhs = assign_error_gen(parser, lhs))
15652 #else
15653 # define assignable_result(x) assignable_result0(x, column)
15654 #endif
15655  if (!id) return assignable_result(0);
15656  switch (id) {
15657  case keyword_self:
15658  yyerror0("Can't change the value of self");
15659  goto error;
15660  case keyword_nil:
15661  yyerror0("Can't assign to nil");
15662  goto error;
15663  case keyword_true:
15664  yyerror0("Can't assign to true");
15665  goto error;
15666  case keyword_false:
15667  yyerror0("Can't assign to false");
15668  goto error;
15669  case keyword__FILE__:
15670  yyerror0("Can't assign to __FILE__");
15671  goto error;
15672  case keyword__LINE__:
15673  yyerror0("Can't assign to __LINE__");
15674  goto error;
15675  case keyword__ENCODING__:
15676  yyerror0("Can't assign to __ENCODING__");
15677  goto error;
15678  }
15679  switch (id_type(id)) {
15680  case ID_LOCAL:
15681  if (dyna_in_block()) {
15682  if (dvar_curr(id)) {
15683  return assignable_result(NEW_DASGN_CURR(id, val));
15684  }
15685  else if (dvar_defined(id)) {
15686  return assignable_result(NEW_DASGN(id, val));
15687  }
15688  else if (local_id(id)) {
15689  return assignable_result(NEW_LASGN(id, val));
15690  }
15691  else {
15692  dyna_var(id);
15693  return assignable_result(NEW_DASGN_CURR(id, val));
15694  }
15695  }
15696  else {
15697  if (!local_id(id)) {
15698  local_var(id);
15699  }
15700  return assignable_result(NEW_LASGN(id, val));
15701  }
15702  break;
15703  case ID_GLOBAL:
15704  return assignable_result(NEW_GASGN(id, val));
15705  case ID_INSTANCE:
15706  return assignable_result(NEW_IASGN(id, val));
15707  case ID_CONST:
15708  if (!in_def && !in_single)
15709  return assignable_result(new_cdecl(id, val, 0, column));
15710  yyerror0("dynamic constant assignment");
15711  break;
15712  case ID_CLASS:
15713  return assignable_result(NEW_CVASGN(id, val));
15714  default:
15715  compile_error(PARSER_ARG "identifier %"PRIsVALUE" is not valid to set", rb_id2str(id));
15716  }
15717  error:
15718  return assignable_result(0);
15719 #undef assignable_result
15720 #undef parser_yyerror
15721 }
15722 
15723 static int
15724 is_private_local_id(ID name)
15725 {
15726  VALUE s;
15727  if (name == idUScore) return 1;
15728  if (!is_local_id(name)) return 0;
15729  s = rb_id2str(name);
15730  if (!s) return 0;
15731  return RSTRING_PTR(s)[0] == '_';
15732 }
15733 
15734 static int
15735 shadowing_lvar_0(struct parser_params *parser, ID name)
15736 {
15737  if (is_private_local_id(name)) return 1;
15738  if (dyna_in_block()) {
15739  if (dvar_curr(name)) {
15740  yyerror0("duplicated argument name");
15741  }
15742  else if (dvar_defined(name) || local_id(name)) {
15743  rb_warning1("shadowing outer local variable - %"PRIsWARN, rb_id2str(name));
15744  vtable_add(lvtbl->vars, name);
15745  if (lvtbl->used) {
15746  vtable_add(lvtbl->used, (ID)ruby_sourceline | LVAR_USED);
15747  }
15748  return 0;
15749  }
15750  }
15751  else {
15752  if (local_id(name)) {
15753  yyerror0("duplicated argument name");
15754  }
15755  }
15756  return 1;
15757 }
15758 
15759 static ID
15760 shadowing_lvar_gen(struct parser_params *parser, ID name)
15761 {
15762  shadowing_lvar_0(parser, name);
15763  return name;
15764 }
15765 
15766 static void
15767 new_bv_gen(struct parser_params *parser, ID name)
15768 {
15769  if (!name) return;
15770  if (!is_local_id(name)) {
15771  compile_error(PARSER_ARG "invalid local variable - %"PRIsVALUE,
15772  rb_id2str(name));
15773  return;
15774  }
15775  if (!shadowing_lvar_0(parser, name)) return;
15776  dyna_var(name);
15777 }
15778 
15779 #ifndef RIPPER
15780 static NODE *
15781 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx, int column)
15782 {
15783  NODE *attrasgn = NEW_ATTRASGN(recv, tASET, idx);
15784  nd_set_column(attrasgn, column);
15785  return attrasgn;
15786 }
15787 
15788 static void
15789 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
15790 {
15791  if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
15792  compile_error(PARSER_ARG "both block arg and actual block given");
15793  }
15794 }
15795 
15796 static NODE *
15797 attrset_gen(struct parser_params *parser, NODE *recv, ID atype, ID id, int column)
15798 {
15799  NODE *attrasgn;
15800  if (!CALL_Q_P(atype)) id = rb_id_attrset(id);
15801  attrasgn = NEW_ATTRASGN(recv, id, 0);
15802  nd_set_column(attrasgn, column);
15803  return attrasgn;
15804 }
15805 
15806 static void
15807 rb_backref_error_gen(struct parser_params *parser, NODE *node)
15808 {
15809  switch (nd_type(node)) {
15810  case NODE_NTH_REF:
15811  compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
15812  break;
15813  case NODE_BACK_REF:
15814  compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
15815  break;
15816  }
15817 }
15818 
15819 static NODE *
15820 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2, int column)
15821 {
15822  NODE *argscat;
15823 
15824  if (!node2) return node1;
15825  switch (nd_type(node1)) {
15826  case NODE_BLOCK_PASS:
15827  if (node1->nd_head)
15828  node1->nd_head = arg_concat(node1->nd_head, node2, column);
15829  else
15830  node1->nd_head = new_list(node2, column);
15831  return node1;
15832  case NODE_ARGSPUSH:
15833  if (nd_type(node2) != NODE_ARRAY) break;
15834  node1->nd_body = list_concat(new_list(node1->nd_body, column), node2);
15835  nd_set_type(node1, NODE_ARGSCAT);
15836  return node1;
15837  case NODE_ARGSCAT:
15838  if (nd_type(node2) != NODE_ARRAY ||
15839  nd_type(node1->nd_body) != NODE_ARRAY) break;
15840  node1->nd_body = list_concat(node1->nd_body, node2);
15841  return node1;
15842  }
15843  argscat = NEW_ARGSCAT(node1, node2);
15844  nd_set_column(argscat, column);
15845  return argscat;
15846 }
15847 
15848 static NODE *
15849 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2, int column)
15850 {
15851  NODE *argspush;
15852 
15853  if (!node1) return new_list(node2, column);
15854  switch (nd_type(node1)) {
15855  case NODE_ARRAY:
15856  return list_append(node1, node2, column);
15857  case NODE_BLOCK_PASS:
15858  node1->nd_head = arg_append(node1->nd_head, node2, column);
15859  return node1;
15860  case NODE_ARGSPUSH:
15861  node1->nd_body = list_append(new_list(node1->nd_body, column), node2, column);
15862  nd_set_type(node1, NODE_ARGSCAT);
15863  return node1;
15864  }
15865  argspush = NEW_ARGSPUSH(node1, node2);
15866  nd_set_column(argspush, column);
15867  return argspush;
15868 }
15869 
15870 static NODE *
15871 splat_array(NODE* node)
15872 {
15873  if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
15874  if (nd_type(node) == NODE_ARRAY) return node;
15875  return 0;
15876 }
15877 
15878 static NODE *
15879 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs, int column)
15880 {
15881  if (!lhs) return 0;
15882 
15883  switch (nd_type(lhs)) {
15884  case NODE_GASGN:
15885  case NODE_IASGN:
15886  case NODE_IASGN2:
15887  case NODE_LASGN:
15888  case NODE_DASGN:
15889  case NODE_DASGN_CURR:
15890  case NODE_MASGN:
15891  case NODE_CDECL:
15892  case NODE_CVASGN:
15893  lhs->nd_value = rhs;
15894  break;
15895 
15896  case NODE_ATTRASGN:
15897  case NODE_CALL:
15898  lhs->nd_args = arg_append(lhs->nd_args, rhs, column);
15899  break;
15900 
15901  default:
15902  /* should not happen */
15903  break;
15904  }
15905 
15906  return lhs;
15907 }
15908 
15909 static int
15910 value_expr_gen(struct parser_params *parser, NODE *node)
15911 {
15912  int cond = 0;
15913 
15914  if (!node) {
15915  rb_warning0("empty expression");
15916  }
15917  while (node) {
15918  switch (nd_type(node)) {
15919  case NODE_RETURN:
15920  case NODE_BREAK:
15921  case NODE_NEXT:
15922  case NODE_REDO:
15923  case NODE_RETRY:
15924  if (!cond) yyerror0("void value expression");
15925  /* or "control never reach"? */
15926  return FALSE;
15927 
15928  case NODE_BLOCK:
15929  while (node->nd_next) {
15930  node = node->nd_next;
15931  }
15932  node = node->nd_head;
15933  break;
15934 
15935  case NODE_BEGIN:
15936  node = node->nd_body;
15937  break;
15938 
15939  case NODE_IF:
15940  case NODE_UNLESS:
15941  if (!node->nd_body) {
15942  node = node->nd_else;
15943  break;
15944  }
15945  else if (!node->nd_else) {
15946  node = node->nd_body;
15947  break;
15948  }
15949  if (!value_expr(node->nd_body)) return FALSE;
15950  node = node->nd_else;
15951  break;
15952 
15953  case NODE_AND:
15954  case NODE_OR:
15955  cond = 1;
15956  node = node->nd_2nd;
15957  break;
15958 
15959  default:
15960  return TRUE;
15961  }
15962  }
15963 
15964  return TRUE;
15965 }
15966 
15967 static void
15968 void_expr_gen(struct parser_params *parser, NODE *node)
15969 {
15970  const char *useless = 0;
15971 
15972  if (!RTEST(ruby_verbose)) return;
15973 
15974  if (!node) return;
15975  switch (nd_type(node)) {
15976  case NODE_OPCALL:
15977  switch (node->nd_mid) {
15978  case '+':
15979  case '-':
15980  case '*':
15981  case '/':
15982  case '%':
15983  case tPOW:
15984  case tUPLUS:
15985  case tUMINUS:
15986  case '|':
15987  case '^':
15988  case '&':
15989  case tCMP:
15990  case '>':
15991  case tGEQ:
15992  case '<':
15993  case tLEQ:
15994  case tEQ:
15995  case tNEQ:
15996  useless = rb_id2name(node->nd_mid);
15997  break;
15998  }
15999  break;
16000 
16001  case NODE_LVAR:
16002  case NODE_DVAR:
16003  case NODE_GVAR:
16004  case NODE_IVAR:
16005  case NODE_CVAR:
16006  case NODE_NTH_REF:
16007  case NODE_BACK_REF:
16008  useless = "a variable";
16009  break;
16010  case NODE_CONST:
16011  useless = "a constant";
16012  break;
16013  case NODE_LIT:
16014  case NODE_STR:
16015  case NODE_DSTR:
16016  case NODE_DREGX:
16017  case NODE_DREGX_ONCE:
16018  useless = "a literal";
16019  break;
16020  case NODE_COLON2:
16021  case NODE_COLON3:
16022  useless = "::";
16023  break;
16024  case NODE_DOT2:
16025  useless = "..";
16026  break;
16027  case NODE_DOT3:
16028  useless = "...";
16029  break;
16030  case NODE_SELF:
16031  useless = "self";
16032  break;
16033  case NODE_NIL:
16034  useless = "nil";
16035  break;
16036  case NODE_TRUE:
16037  useless = "true";
16038  break;
16039  case NODE_FALSE:
16040  useless = "false";
16041  break;
16042  case NODE_DEFINED:
16043  useless = "defined?";
16044  break;
16045  }
16046 
16047  if (useless) {
16048  rb_warn1L(nd_line(node), "possibly useless use of %s in void context", WARN_S(useless));
16049  }
16050 }
16051 
16052 static void
16053 void_stmts_gen(struct parser_params *parser, NODE *node)
16054 {
16055  if (!RTEST(ruby_verbose)) return;
16056  if (!node) return;
16057  if (nd_type(node) != NODE_BLOCK) return;
16058 
16059  for (;;) {
16060  if (!node->nd_next) return;
16061  void_expr0(node->nd_head);
16062  node = node->nd_next;
16063  }
16064 }
16065 
16066 static NODE *
16067 remove_begin(NODE *node)
16068 {
16069  NODE **n = &node, *n1 = node;
16070  while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
16071  *n = n1 = n1->nd_body;
16072  }
16073  return node;
16074 }
16075 
16076 static NODE *
16077 remove_begin_all(NODE *node)
16078 {
16079  NODE **n = &node, *n1 = node;
16080  while (n1 && nd_type(n1) == NODE_BEGIN) {
16081  *n = n1 = n1->nd_body;
16082  }
16083  return node;
16084 }
16085 
16086 static void
16087 reduce_nodes_gen(struct parser_params *parser, NODE **body)
16088 {
16089  NODE *node = *body;
16090 
16091  if (!node) {
16092  *body = NEW_NIL();
16093  return;
16094  }
16095 #define subnodes(n1, n2) \
16096  ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
16097  (!node->n2) ? (body = &node->n1, 1) : \
16098  (reduce_nodes(&node->n1), body = &node->n2, 1))
16099 
16100  while (node) {
16101  int newline = (int)(node->flags & NODE_FL_NEWLINE);
16102  switch (nd_type(node)) {
16103  end:
16104  case NODE_NIL:
16105  *body = 0;
16106  return;
16107  case NODE_RETURN:
16108  *body = node = node->nd_stts;
16109  if (newline && node) node->flags |= NODE_FL_NEWLINE;
16110  continue;
16111  case NODE_BEGIN:
16112  *body = node = node->nd_body;
16113  if (newline && node) node->flags |= NODE_FL_NEWLINE;
16114  continue;
16115  case NODE_BLOCK:
16116  body = &node->nd_end->nd_head;
16117  break;
16118  case NODE_IF:
16119  case NODE_UNLESS:
16120  if (subnodes(nd_body, nd_else)) break;
16121  return;
16122  case NODE_CASE:
16123  body = &node->nd_body;
16124  break;
16125  case NODE_WHEN:
16126  if (!subnodes(nd_body, nd_next)) goto end;
16127  break;
16128  case NODE_ENSURE:
16129  if (!subnodes(nd_head, nd_resq)) goto end;
16130  break;
16131  case NODE_RESCUE:
16132  if (node->nd_else) {
16133  body = &node->nd_resq;
16134  break;
16135  }
16136  if (!subnodes(nd_head, nd_resq)) goto end;
16137  break;
16138  default:
16139  return;
16140  }
16141  node = *body;
16142  if (newline && node) node->flags |= NODE_FL_NEWLINE;
16143  }
16144 
16145 #undef subnodes
16146 }
16147 
16148 static int
16149 is_static_content(NODE *node)
16150 {
16151  if (!node) return 1;
16152  switch (nd_type(node)) {
16153  case NODE_HASH:
16154  if (!(node = node->nd_head)) break;
16155  case NODE_ARRAY:
16156  do {
16157  if (!is_static_content(node->nd_head)) return 0;
16158  } while ((node = node->nd_next) != 0);
16159  case NODE_LIT:
16160  case NODE_STR:
16161  case NODE_NIL:
16162  case NODE_TRUE:
16163  case NODE_FALSE:
16164  case NODE_ZARRAY:
16165  break;
16166  default:
16167  return 0;
16168  }
16169  return 1;
16170 }
16171 
16172 static int
16173 assign_in_cond(struct parser_params *parser, NODE *node)
16174 {
16175  switch (nd_type(node)) {
16176  case NODE_MASGN:
16177  case NODE_LASGN:
16178  case NODE_DASGN:
16179  case NODE_DASGN_CURR:
16180  case NODE_GASGN:
16181  case NODE_IASGN:
16182  break;
16183 
16184  default:
16185  return 0;
16186  }
16187 
16188  if (!node->nd_value) return 1;
16189  if (is_static_content(node->nd_value)) {
16190  /* reports always */
16191  parser_warn(node->nd_value, "found = in conditional, should be ==");
16192  }
16193  return 1;
16194 }
16195 
16196 static void
16197 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
16198 {
16199  if (!e_option_supplied(parser)) parser_warn(node, str);
16200 }
16201 
16202 static void
16203 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
16204 {
16205  if (!e_option_supplied(parser)) parser_warning(node, str);
16206 }
16207 
16208 static NODE *cond0(struct parser_params*,NODE*,int,int);
16209 
16210 static NODE*
16211 range_op(struct parser_params *parser, NODE *node, int column)
16212 {
16213  enum node_type type;
16214 
16215  if (node == 0) return 0;
16216 
16217  type = nd_type(node);
16218  value_expr(node);
16219  if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
16220  warn_unless_e_option(parser, node, "integer literal in conditional range");
16221  return new_call(node, tEQ, new_list(new_gvar(rb_intern("$."), column), column), column);
16222  }
16223  return cond0(parser, node, FALSE, column);
16224 }
16225 
16226 static int
16227 literal_node(NODE *node)
16228 {
16229  if (!node) return 1; /* same as NODE_NIL */
16230  switch (nd_type(node)) {
16231  case NODE_LIT:
16232  case NODE_STR:
16233  case NODE_DSTR:
16234  case NODE_EVSTR:
16235  case NODE_DREGX:
16236  case NODE_DREGX_ONCE:
16237  case NODE_DSYM:
16238  return 2;
16239  case NODE_TRUE:
16240  case NODE_FALSE:
16241  case NODE_NIL:
16242  return 1;
16243  }
16244  return 0;
16245 }
16246 
16247 static NODE*
16248 cond0(struct parser_params *parser, NODE *node, int method_op, int column)
16249 {
16250  if (node == 0) return 0;
16251  assign_in_cond(parser, node);
16252 
16253  switch (nd_type(node)) {
16254  case NODE_DSTR:
16255  case NODE_EVSTR:
16256  case NODE_STR:
16257  if (!method_op) rb_warn0("string literal in condition");
16258  break;
16259 
16260  case NODE_DREGX:
16261  case NODE_DREGX_ONCE:
16262  {
16263  NODE *match;
16264  if (!method_op)
16265  warning_unless_e_option(parser, node, "regex literal in condition");
16266 
16267  match = NEW_MATCH2(node, new_gvar(idLASTLINE, column));
16268  nd_set_column(match, column);
16269  return match;
16270  }
16271 
16272  case NODE_AND:
16273  case NODE_OR:
16274  node->nd_1st = cond0(parser, node->nd_1st, FALSE, column);
16275  node->nd_2nd = cond0(parser, node->nd_2nd, FALSE, column);
16276  break;
16277 
16278  case NODE_DOT2:
16279  case NODE_DOT3:
16280  node->nd_beg = range_op(parser, node->nd_beg, column);
16281  node->nd_end = range_op(parser, node->nd_end, column);
16282  if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
16283  else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
16284  if (!method_op && !e_option_supplied(parser)) {
16285  int b = literal_node(node->nd_beg);
16286  int e = literal_node(node->nd_end);
16287  if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
16288  parser_warn(node, "range literal in condition");
16289  }
16290  }
16291  break;
16292 
16293  case NODE_DSYM:
16294  if (!method_op) parser_warning(node, "literal in condition");
16295  break;
16296 
16297  case NODE_LIT:
16298  if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
16299  if (!method_op)
16300  warn_unless_e_option(parser, node, "regex literal in condition");
16301  nd_set_type(node, NODE_MATCH);
16302  }
16303  else {
16304  if (!method_op)
16305  parser_warning(node, "literal in condition");
16306  }
16307  default:
16308  break;
16309  }
16310  return node;
16311 }
16312 
16313 static NODE*
16314 cond_gen(struct parser_params *parser, NODE *node, int method_op, int column)
16315 {
16316  if (node == 0) return 0;
16317  return cond0(parser, node, method_op, column);
16318 }
16319 
16320 static NODE*
16321 new_if_gen(struct parser_params *parser, NODE *cc, NODE *left, NODE *right, int column)
16322 {
16323  NODE *node_if;
16324 
16325  if (!cc) return right;
16326  cc = cond0(parser, cc, FALSE, column);
16327  node_if = NEW_IF(cc, left, right);
16328  nd_set_column(node_if, column);
16329  return newline_node(node_if);
16330 }
16331 
16332 static NODE*
16333 new_unless_gen(struct parser_params *parser, NODE *cc, NODE *left, NODE *right, int column)
16334 {
16335  NODE *node_unless;
16336 
16337  if (!cc) return right;
16338  cc = cond0(parser, cc, FALSE, column);
16339  node_unless = NEW_UNLESS(cc, left, right);
16340  nd_set_column(node_unless, column);
16341  return newline_node(node_unless);
16342 }
16343 
16344 static NODE*
16345 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right, int column)
16346 {
16347  NODE *op;
16348  value_expr(left);
16349  if (left && (enum node_type)nd_type(left) == type) {
16350  NODE *node = left, *second;
16351  while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
16352  node = second;
16353  }
16354  node->nd_2nd = NEW_NODE(type, second, right, 0);
16355  nd_set_column(node->nd_2nd, column);
16356  return left;
16357  }
16358  op = NEW_NODE(type, left, right, 0);
16359  nd_set_column(op, column);
16360  return op;
16361 }
16362 
16363 static void
16364 no_blockarg(struct parser_params *parser, NODE *node)
16365 {
16366  if (node && nd_type(node) == NODE_BLOCK_PASS) {
16367  compile_error(PARSER_ARG "block argument should not be given");
16368  }
16369 }
16370 
16371 static NODE *
16372 ret_args_gen(struct parser_params *parser, NODE *node)
16373 {
16374  if (node) {
16375  no_blockarg(parser, node);
16376  if (nd_type(node) == NODE_ARRAY) {
16377  if (node->nd_next == 0) {
16378  node = node->nd_head;
16379  }
16380  else {
16381  nd_set_type(node, NODE_VALUES);
16382  }
16383  }
16384  }
16385  return node;
16386 }
16387 
16388 static NODE *
16389 new_yield_gen(struct parser_params *parser, NODE *node, int column)
16390 {
16391  NODE *yield;
16392  if (node) no_blockarg(parser, node);
16393 
16394  yield = NEW_YIELD(node);
16395  nd_set_column(yield, column);
16396  return yield;
16397 }
16398 
16399 static VALUE
16400 negate_lit_gen(struct parser_params *parser, VALUE lit)
16401 {
16402  int type = TYPE(lit);
16403  switch (type) {
16404  case T_FIXNUM:
16405  lit = LONG2FIX(-FIX2LONG(lit));
16406  break;
16407  case T_BIGNUM:
16408  BIGNUM_NEGATE(lit);
16409  lit = rb_big_norm(lit);
16410  break;
16411  case T_RATIONAL:
16412  RRATIONAL_SET_NUM(lit, negate_lit(RRATIONAL(lit)->num));
16413  break;
16414  case T_COMPLEX:
16415  RCOMPLEX_SET_REAL(lit, negate_lit(RCOMPLEX(lit)->real));
16416  RCOMPLEX_SET_IMAG(lit, negate_lit(RCOMPLEX(lit)->imag));
16417  break;
16418  case T_FLOAT:
16419 #if USE_FLONUM
16420  if (FLONUM_P(lit)) {
16421  lit = DBL2NUM(-RFLOAT_VALUE(lit));
16422  break;
16423  }
16424 #endif
16425  RFLOAT(lit)->float_value = -RFLOAT_VALUE(lit);
16426  break;
16427  default:
16428  rb_parser_fatal(parser, "unknown literal type (%d) passed to negate_lit", type);
16429  break;
16430  }
16431  return lit;
16432 }
16433 
16434 static NODE *
16435 arg_blk_pass(NODE *node1, NODE *node2)
16436 {
16437  if (node2) {
16438  node2->nd_head = node1;
16439  return node2;
16440  }
16441  return node1;
16442 }
16443 
16444 
16445 static NODE*
16446 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
16447 {
16448  int saved_line = ruby_sourceline;
16449  struct rb_args_info *args = tail->nd_ainfo;
16450 
16451  args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0;
16452  args->pre_init = m ? m->nd_next : 0;
16453 
16454  args->post_args_num = p ? rb_long2int(p->nd_plen) : 0;
16455  args->post_init = p ? p->nd_next : 0;
16456  args->first_post_arg = p ? p->nd_pid : 0;
16457 
16458  args->rest_arg = r;
16459 
16460  args->opt_args = o;
16461 
16462  ruby_sourceline = saved_line;
16463 
16464  return tail;
16465 }
16466 
16467 static NODE*
16468 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b, int column)
16469 {
16470  int saved_line = ruby_sourceline;
16471  struct rb_args_info *args;
16472  NODE *node;
16473 
16474  args = ZALLOC(struct rb_args_info);
16475  node = NEW_NODE(NODE_ARGS, 0, 0, args);
16476  nd_set_column(node, column);
16477  if (parser->error_p) return node;
16478 
16479  args->block_arg = b;
16480  args->kw_args = k;
16481 
16482  if (k) {
16483  /*
16484  * def foo(k1: 1, kr1:, k2: 2, **krest, &b)
16485  * variable order: k1, kr1, k2, &b, internal_id, krest
16486  * #=> <reorder>
16487  * variable order: kr1, k1, k2, internal_id, krest, &b
16488  */
16489  ID kw_bits;
16490  NODE *kwn = k;
16491  struct vtable *required_kw_vars = vtable_alloc(NULL);
16492  struct vtable *kw_vars = vtable_alloc(NULL);
16493  int i;
16494 
16495  while (kwn) {
16496  NODE *val_node = kwn->nd_body->nd_value;
16497  ID vid = kwn->nd_body->nd_vid;
16498 
16499  if (val_node == (NODE *)-1) {
16500  vtable_add(required_kw_vars, vid);
16501  }
16502  else {
16503  vtable_add(kw_vars, vid);
16504  }
16505 
16506  kwn = kwn->nd_next;
16507  }
16508 
16509  kw_bits = internal_id();
16510  if (kr && is_junk_id(kr)) vtable_pop(lvtbl->args, 1);
16511  vtable_pop(lvtbl->args, vtable_size(required_kw_vars) + vtable_size(kw_vars) + (b != 0));
16512 
16513  for (i=0; i<vtable_size(required_kw_vars); i++) arg_var(required_kw_vars->tbl[i]);
16514  for (i=0; i<vtable_size(kw_vars); i++) arg_var(kw_vars->tbl[i]);
16515  vtable_free(required_kw_vars);
16516  vtable_free(kw_vars);
16517 
16518  arg_var(kw_bits);
16519  if (kr) arg_var(kr);
16520  if (b) arg_var(b);
16521 
16522  args->kw_rest_arg = new_dvar(kr, column);
16523  args->kw_rest_arg->nd_cflag = kw_bits;
16524  }
16525  else if (kr) {
16526  if (b) vtable_pop(lvtbl->args, 1); /* reorder */
16527  arg_var(kr);
16528  if (b) arg_var(b);
16529  args->kw_rest_arg = new_dvar(kr, column);
16530  }
16531 
16532  ruby_sourceline = saved_line;
16533  return node;
16534 }
16535 
16536 static NODE*
16537 dsym_node_gen(struct parser_params *parser, NODE *node, int column)
16538 {
16539  VALUE lit;
16540 
16541  if (!node) {
16542  return new_lit(ID2SYM(idNULL), column);
16543  }
16544 
16545  switch (nd_type(node)) {
16546  case NODE_DSTR:
16547  nd_set_type(node, NODE_DSYM);
16548  break;
16549  case NODE_STR:
16550  lit = node->nd_lit;
16551  node->nd_lit = ID2SYM(rb_intern_str(lit));
16552  nd_set_type(node, NODE_LIT);
16553  break;
16554  default:
16555  node = NEW_NODE(NODE_DSYM, Qnil, 1, new_list(node, column));
16556  nd_set_column(node, column);
16557  break;
16558  }
16559  return node;
16560 }
16561 
16562 static int
16563 append_literal_keys(st_data_t k, st_data_t v, st_data_t h)
16564 {
16565  NODE *node = (NODE *)v;
16566  NODE **result = (NODE **)h;
16567  node->nd_alen = 2;
16568  node->nd_next->nd_end = node->nd_next;
16569  node->nd_next->nd_next = 0;
16570  if (*result)
16571  list_concat(*result, node);
16572  else
16573  *result = node;
16574  return ST_CONTINUE;
16575 }
16576 
16577 static NODE *
16578 remove_duplicate_keys(struct parser_params *parser, NODE *hash, int column)
16579 {
16580  st_table *literal_keys = st_init_numtable_with_size(hash->nd_alen / 2);
16581  NODE *result = 0;
16582  while (hash && hash->nd_head && hash->nd_next) {
16583  NODE *head = hash->nd_head;
16584  NODE *value = hash->nd_next;
16585  NODE *next = value->nd_next;
16586  VALUE key = (VALUE)head;
16587  st_data_t data;
16588  if (nd_type(head) == NODE_LIT &&
16589  st_lookup(literal_keys, (key = head->nd_lit), &data)) {
16590  rb_compile_warn(ruby_sourcefile, nd_line((NODE *)data),
16591  "key %+"PRIsVALUE" is duplicated and overwritten on line %d",
16592  head->nd_lit, nd_line(head));
16593  head = ((NODE *)data)->nd_next;
16594  head->nd_head = block_append(head->nd_head, value->nd_head, column);
16595  }
16596  else {
16597  st_insert(literal_keys, (st_data_t)key, (st_data_t)hash);
16598  }
16599  hash = next;
16600  }
16601  st_foreach(literal_keys, append_literal_keys, (st_data_t)&result);
16602  st_free_table(literal_keys);
16603  if (hash) {
16604  if (!result) result = hash;
16605  else list_concat(result, hash);
16606  }
16607  return result;
16608 }
16609 
16610 static NODE *
16611 new_hash_gen(struct parser_params *parser, NODE *hash, int column)
16612 {
16613  NODE *nd_hash;
16614  if (hash) hash = remove_duplicate_keys(parser, hash, column);
16615  nd_hash = NEW_HASH(hash);
16616  nd_set_column(nd_hash, column);
16617  return nd_hash;
16618 }
16619 #endif /* !RIPPER */
16620 
16621 #ifndef RIPPER
16622 static NODE *
16623 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs, int column)
16624 {
16625  NODE *asgn;
16626 
16627  if (lhs) {
16628  ID vid = lhs->nd_vid;
16629  if (op == tOROP) {
16630  lhs->nd_value = rhs;
16631  asgn = NEW_OP_ASGN_OR(gettable(vid, column), lhs);
16632  nd_set_column(asgn, column);
16633  if (is_notop_id(vid)) {
16634  switch (id_type(vid)) {
16635  case ID_GLOBAL:
16636  case ID_INSTANCE:
16637  case ID_CLASS:
16638  asgn->nd_aid = vid;
16639  }
16640  }
16641  }
16642  else if (op == tANDOP) {
16643  lhs->nd_value = rhs;
16644  asgn = NEW_OP_ASGN_AND(gettable(vid, column), lhs);
16645  nd_set_column(asgn, column);
16646  }
16647  else {
16648  asgn = lhs;
16649  asgn->nd_value = new_call(gettable(vid, column), op, new_list(rhs, column), column);
16650  }
16651  }
16652  else {
16653  asgn = new_begin(0, column);
16654  }
16655  return asgn;
16656 }
16657 
16658 static NODE *
16659 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs,
16660  ID atype, ID attr, ID op, NODE *rhs, int column)
16661 {
16662  NODE *asgn;
16663 
16664  if (op == tOROP) {
16665  op = 0;
16666  }
16667  else if (op == tANDOP) {
16668  op = 1;
16669  }
16670  asgn = NEW_OP_ASGN2(lhs, CALL_Q_P(atype), attr, op, rhs);
16671  nd_set_column(asgn, column);
16672  fixpos(asgn, lhs);
16673  return asgn;
16674 }
16675 
16676 static NODE *
16677 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs, int column)
16678 {
16679  NODE *asgn;
16680 
16681  if (op == tOROP) {
16682  op = 0;
16683  }
16684  else if (op == tANDOP) {
16685  op = 1;
16686  }
16687  if (lhs) {
16688  asgn = NEW_OP_CDECL(lhs, op, rhs);
16689  }
16690  else {
16691  asgn = new_begin(0, column);
16692  }
16693  fixpos(asgn, lhs);
16694  nd_set_column(asgn, column);
16695  return asgn;
16696 }
16697 
16698 static NODE *
16699 const_path_field_gen(struct parser_params *parser, NODE *head, ID mid, int column)
16700 {
16701  NODE *colon2 = NEW_COLON2(head, mid);
16702  nd_set_column(colon2, column);
16703  return colon2;
16704 }
16705 
16706 static NODE *
16707 const_decl_gen(struct parser_params *parser, NODE *path, int column)
16708 {
16709  if (in_def || in_single) {
16710  yyerror0("dynamic constant assignment");
16711  }
16712  return new_cdecl(0, 0, (path), column);
16713 }
16714 #else
16715 static VALUE
16716 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs, int column)
16717 {
16718  return dispatch3(opassign, lhs, op, rhs);
16719 }
16720 
16721 static VALUE
16722 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
16723 {
16724  VALUE recv = dispatch3(field, lhs, type, attr);
16725  return dispatch3(opassign, recv, op, rhs);
16726 }
16727 
16728 static VALUE
16729 new_qcall_gen(struct parser_params *parser, VALUE r, VALUE q, VALUE m, VALUE a)
16730 {
16731  VALUE ret = dispatch3(call, (r), (q), (m));
16732  return method_optarg(ret, (a));
16733 }
16734 
16735 static VALUE
16736 const_decl_gen(struct parser_params *parser, VALUE path)
16737 {
16738  if (in_def || in_single) {
16739  path = dispatch1(assign_error, path);
16740  ripper_error();
16741  }
16742  return path;
16743 }
16744 
16745 static VALUE
16746 assign_error_gen(struct parser_params *parser, VALUE a)
16747 {
16748  a = dispatch1(assign_error, a);
16749  ripper_error();
16750  return a;
16751 }
16752 
16753 static VALUE
16754 var_field_gen(struct parser_params *parser, VALUE a)
16755 {
16756  return ripper_new_yylval(get_id(a), dispatch1(var_field, a), 0);
16757 }
16758 #endif
16759 
16760 static void
16761 warn_unused_var(struct parser_params *parser, struct local_vars *local)
16762 {
16763  int i, cnt;
16764  ID *v, *u;
16765 
16766  if (!local->used) return;
16767  v = local->vars->tbl;
16768  u = local->used->tbl;
16769  cnt = local->used->pos;
16770  if (cnt != local->vars->pos) {
16771  rb_parser_fatal(parser, "local->used->pos != local->vars->pos");
16772  }
16773  for (i = 0; i < cnt; ++i) {
16774  if (!v[i] || (u[i] & LVAR_USED)) continue;
16775  if (is_private_local_id(v[i])) continue;
16776  rb_warn1L((int)u[i], "assigned but unused variable - %"PRIsWARN, rb_id2str(v[i]));
16777  }
16778 }
16779 
16780 static void
16781 local_push_gen(struct parser_params *parser, int inherit_dvars)
16782 {
16783  struct local_vars *local;
16784 
16785  local = ALLOC(struct local_vars);
16786  local->prev = lvtbl;
16787  local->args = vtable_alloc(0);
16788  local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
16789  local->used = !(inherit_dvars &&
16790  (ifndef_ripper(compile_for_eval || e_option_supplied(parser))+0)) &&
16791  RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
16792 # if WARN_PAST_SCOPE
16793  local->past = 0;
16794 # endif
16795  local->cmdargs = cmdarg_stack;
16796  CMDARG_SET(0);
16797  lvtbl = local;
16798 }
16799 
16800 static void
16801 local_pop_gen(struct parser_params *parser)
16802 {
16803  struct local_vars *local = lvtbl->prev;
16804  if (lvtbl->used) {
16805  warn_unused_var(parser, lvtbl);
16806  vtable_free(lvtbl->used);
16807  }
16808 # if WARN_PAST_SCOPE
16809  while (lvtbl->past) {
16810  struct vtable *past = lvtbl->past;
16811  lvtbl->past = past->prev;
16812  vtable_free(past);
16813  }
16814 # endif
16815  vtable_free(lvtbl->args);
16816  vtable_free(lvtbl->vars);
16817  CMDARG_SET(lvtbl->cmdargs);
16818  xfree(lvtbl);
16819  lvtbl = local;
16820 }
16821 
16822 #ifndef RIPPER
16823 static ID*
16824 local_tbl_gen(struct parser_params *parser)
16825 {
16826  int cnt_args = vtable_size(lvtbl->args);
16827  int cnt_vars = vtable_size(lvtbl->vars);
16828  int cnt = cnt_args + cnt_vars;
16829  int i, j;
16830  ID *buf;
16831 
16832  if (cnt <= 0) return 0;
16833  buf = ALLOC_N(ID, cnt + 1);
16834  MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args);
16835  /* remove IDs duplicated to warn shadowing */
16836  for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
16837  ID id = lvtbl->vars->tbl[i];
16838  if (!vtable_included(lvtbl->args, id)) {
16839  buf[j++] = id;
16840  }
16841  }
16842  if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1);
16843  buf[0] = cnt;
16844  return buf;
16845 }
16846 #endif
16847 
16848 static void
16849 arg_var_gen(struct parser_params *parser, ID id)
16850 {
16851  vtable_add(lvtbl->args, id);
16852 }
16853 
16854 static void
16855 local_var_gen(struct parser_params *parser, ID id)
16856 {
16857  vtable_add(lvtbl->vars, id);
16858  if (lvtbl->used) {
16859  vtable_add(lvtbl->used, (ID)ruby_sourceline);
16860  }
16861 }
16862 
16863 static int
16864 local_id_gen(struct parser_params *parser, ID id, ID **vidrefp)
16865 {
16866  struct vtable *vars, *args, *used;
16867 
16868  vars = lvtbl->vars;
16869  args = lvtbl->args;
16870  used = lvtbl->used;
16871 
16872  while (vars && POINTER_P(vars->prev)) {
16873  vars = vars->prev;
16874  args = args->prev;
16875  if (used) used = used->prev;
16876  }
16877 
16878  if (vars && vars->prev == DVARS_INHERIT) {
16879  return rb_local_defined(id, parser->base_block);
16880  }
16881  else if (vtable_included(args, id)) {
16882  return 1;
16883  }
16884  else {
16885  int i = vtable_included(vars, id);
16886  if (i && used && vidrefp) *vidrefp = &used->tbl[i-1];
16887  return i != 0;
16888  }
16889 }
16890 
16891 static const struct vtable *
16892 dyna_push_gen(struct parser_params *parser)
16893 {
16894  lvtbl->args = vtable_alloc(lvtbl->args);
16895  lvtbl->vars = vtable_alloc(lvtbl->vars);
16896  if (lvtbl->used) {
16897  lvtbl->used = vtable_alloc(lvtbl->used);
16898  }
16899  return lvtbl->args;
16900 }
16901 
16902 static void
16903 dyna_pop_vtable(struct parser_params *parser, struct vtable **vtblp)
16904 {
16905  struct vtable *tmp = *vtblp;
16906  *vtblp = tmp->prev;
16907 # if WARN_PAST_SCOPE
16908  if (parser->past_scope_enabled) {
16909  tmp->prev = lvtbl->past;
16910  lvtbl->past = tmp;
16911  return;
16912  }
16913 # endif
16914  vtable_free(tmp);
16915 }
16916 
16917 static void
16918 dyna_pop_1(struct parser_params *parser)
16919 {
16920  struct vtable *tmp;
16921 
16922  if ((tmp = lvtbl->used) != 0) {
16923  warn_unused_var(parser, lvtbl);
16924  lvtbl->used = lvtbl->used->prev;
16925  vtable_free(tmp);
16926  }
16927  dyna_pop_vtable(parser, &lvtbl->args);
16928  dyna_pop_vtable(parser, &lvtbl->vars);
16929 }
16930 
16931 static void
16932 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
16933 {
16934  while (lvtbl->args != lvargs) {
16935  dyna_pop_1(parser);
16936  if (!lvtbl->args) {
16937  struct local_vars *local = lvtbl->prev;
16938  xfree(lvtbl);
16939  lvtbl = local;
16940  }
16941  }
16942  dyna_pop_1(parser);
16943 }
16944 
16945 static int
16946 dyna_in_block_gen(struct parser_params *parser)
16947 {
16948  return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
16949 }
16950 
16951 static int
16952 dvar_defined_gen(struct parser_params *parser, ID id, ID **vidrefp)
16953 {
16954  struct vtable *vars, *args, *used;
16955  int i;
16956 
16957  args = lvtbl->args;
16958  vars = lvtbl->vars;
16959  used = lvtbl->used;
16960 
16961  while (POINTER_P(vars)) {
16962  if (vtable_included(args, id)) {
16963  return 1;
16964  }
16965  if ((i = vtable_included(vars, id)) != 0) {
16966  if (used && vidrefp) *vidrefp = &used->tbl[i-1];
16967  return 1;
16968  }
16969  args = args->prev;
16970  vars = vars->prev;
16971  if (!vidrefp) used = 0;
16972  if (used) used = used->prev;
16973  }
16974 
16975  if (vars == DVARS_INHERIT) {
16976  return rb_dvar_defined(id, parser->base_block);
16977  }
16978 
16979  return 0;
16980 }
16981 
16982 static int
16983 dvar_curr_gen(struct parser_params *parser, ID id)
16984 {
16985  return (vtable_included(lvtbl->args, id) ||
16986  vtable_included(lvtbl->vars, id));
16987 }
16988 
16989 static void
16990 reg_fragment_enc_error(struct parser_params* parser, VALUE str, int c)
16991 {
16992  compile_error(PARSER_ARG
16993  "regexp encoding option '%c' differs from source encoding '%s'",
16994  c, rb_enc_name(rb_enc_get(str)));
16995 }
16996 
16997 #ifndef RIPPER
16998 int
16999 rb_reg_fragment_setenc(struct parser_params* parser, VALUE str, int options)
17000 {
17001  int c = RE_OPTION_ENCODING_IDX(options);
17002 
17003  if (c) {
17004  int opt, idx;
17005  rb_char_to_option_kcode(c, &opt, &idx);
17006  if (idx != ENCODING_GET(str) &&
17007  rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
17008  goto error;
17009  }
17010  ENCODING_SET(str, idx);
17011  }
17012  else if (RE_OPTION_ENCODING_NONE(options)) {
17013  if (!ENCODING_IS_ASCII8BIT(str) &&
17014  rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
17015  c = 'n';
17016  goto error;
17017  }
17018  rb_enc_associate(str, rb_ascii8bit_encoding());
17019  }
17020  else if (current_enc == rb_usascii_encoding()) {
17021  if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
17022  /* raise in re.c */
17023  rb_enc_associate(str, rb_usascii_encoding());
17024  }
17025  else {
17026  rb_enc_associate(str, rb_ascii8bit_encoding());
17027  }
17028  }
17029  return 0;
17030 
17031  error:
17032  return c;
17033 }
17034 
17035 static void
17036 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
17037 {
17038  int c = rb_reg_fragment_setenc(parser, str, options);
17039  if (c) reg_fragment_enc_error(parser, str, c);
17040 }
17041 
17042 static int
17043 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
17044 {
17045  VALUE err;
17046  reg_fragment_setenc(str, options);
17047  err = rb_reg_check_preprocess(str);
17048  if (err != Qnil) {
17049  err = rb_obj_as_string(err);
17050  compile_error(PARSER_ARG "%"PRIsVALUE, err);
17051  return 0;
17052  }
17053  return 1;
17054 }
17055 
17056 typedef struct {
17057  struct parser_params* parser;
17058  rb_encoding *enc;
17059  NODE *succ_block;
17060  int column;
17061 } reg_named_capture_assign_t;
17062 
17063 static int
17064 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
17065  int back_num, int *back_refs, OnigRegex regex, void *arg0)
17066 {
17067  reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
17068  struct parser_params* parser = arg->parser;
17069  rb_encoding *enc = arg->enc;
17070  long len = name_end - name;
17071  const char *s = (const char *)name;
17072  ID var;
17073  NODE *node, *succ;
17074 
17075  if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
17076  (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
17077  !rb_enc_symname2_p(s, len, enc)) {
17078  return ST_CONTINUE;
17079  }
17080  var = intern_cstr(s, len, enc);
17081  node = node_assign(assignable(var, 0, arg->column), new_lit(ID2SYM(var), arg->column), arg->column);
17082  succ = arg->succ_block;
17083  if (!succ) succ = new_begin(0, arg->column);
17084  succ = block_append(succ, node, arg->column);
17085  arg->succ_block = succ;
17086  return ST_CONTINUE;
17087 }
17088 
17089 static NODE *
17090 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, int column)
17091 {
17092  reg_named_capture_assign_t arg;
17093 
17094  arg.parser = parser;
17095  arg.enc = rb_enc_get(regexp);
17096  arg.succ_block = 0;
17097  arg.column = column;
17098  onig_foreach_name(RREGEXP_PTR(regexp), reg_named_capture_assign_iter, &arg);
17099 
17100  if (!arg.succ_block) return 0;
17101  return arg.succ_block->nd_next;
17102 }
17103 
17104 static VALUE
17105 parser_reg_compile(struct parser_params* parser, VALUE str, int options)
17106 {
17107  reg_fragment_setenc(str, options);
17108  return rb_parser_reg_compile(parser, str, options);
17109 }
17110 
17111 VALUE
17112 rb_parser_reg_compile(struct parser_params* parser, VALUE str, int options)
17113 {
17114  return rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
17115 }
17116 
17117 static VALUE
17118 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
17119 {
17120  VALUE re;
17121  VALUE err;
17122 
17123  err = rb_errinfo();
17124  re = parser_reg_compile(parser, str, options);
17125  if (NIL_P(re)) {
17126  VALUE m = rb_attr_get(rb_errinfo(), idMesg);
17127  rb_set_errinfo(err);
17128  compile_error(PARSER_ARG "%"PRIsVALUE, m);
17129  return Qnil;
17130  }
17131  return re;
17132 }
17133 #else
17134 static VALUE
17135 parser_reg_compile(struct parser_params* parser, VALUE str, int options, VALUE *errmsg)
17136 {
17137  VALUE err = rb_errinfo();
17138  VALUE re;
17139  int c = rb_reg_fragment_setenc(parser, str, options);
17140  if (c) reg_fragment_enc_error(parser, str, c);
17141  re = rb_parser_reg_compile(parser, str, options);
17142  if (NIL_P(re)) {
17143  *errmsg = rb_attr_get(rb_errinfo(), idMesg);
17144  rb_set_errinfo(err);
17145  }
17146  return re;
17147 }
17148 #endif
17149 
17150 #ifndef RIPPER
17151 NODE*
17152 rb_parser_append_print(VALUE vparser, NODE *node)
17153 {
17154  NODE *prelude = 0;
17155  NODE *scope = node;
17156  struct parser_params *parser;
17157 
17158  if (!node) return node;
17159 
17160  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17161 
17162  node = node->nd_body;
17163 
17164  if (nd_type(node) == NODE_PRELUDE) {
17165  prelude = node;
17166  node = node->nd_body;
17167  }
17168 
17169  node = block_append(node,
17170  new_fcall(rb_intern("print"),
17171  NEW_ARRAY(new_gvar(idLASTLINE, 0)), 0),
17172  0);
17173  if (prelude) {
17174  prelude->nd_body = node;
17175  scope->nd_body = prelude;
17176  }
17177  else {
17178  scope->nd_body = node;
17179  }
17180 
17181  return scope;
17182 }
17183 
17184 NODE *
17185 rb_parser_while_loop(VALUE vparser, NODE *node, int chomp, int split)
17186 {
17187  NODE *prelude = 0;
17188  NODE *scope = node;
17189  struct parser_params *parser;
17190 
17191  if (!node) return node;
17192 
17193  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17194 
17195  node = node->nd_body;
17196 
17197  if (nd_type(node) == NODE_PRELUDE) {
17198  prelude = node;
17199  node = node->nd_body;
17200  }
17201  if (split) {
17202  node = block_append(NEW_GASGN(rb_intern("$F"),
17203  new_call(new_gvar(idLASTLINE, 0),
17204  rb_intern("split"), 0, 0)),
17205  node, 0);
17206  }
17207  if (chomp) {
17208  node = block_append(new_call(new_gvar(idLASTLINE, 0),
17209  rb_intern("chomp!"), 0, 0), node, 0);
17210  }
17211 
17212  node = NEW_OPT_N(node);
17213 
17214  if (prelude) {
17215  prelude->nd_body = node;
17216  scope->nd_body = prelude;
17217  }
17218  else {
17219  scope->nd_body = node;
17220  }
17221 
17222  return scope;
17223 }
17224 
17225 void
17226 rb_init_parse(void)
17227 {
17228  /* just to suppress unused-function warnings */
17229  (void)nodetype;
17230  (void)nodeline;
17231 }
17232 #endif /* !RIPPER */
17233 
17234 static ID
17235 internal_id_gen(struct parser_params *parser)
17236 {
17237  ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
17238  id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
17239  return ID_STATIC_SYM | ID_INTERNAL | (id << ID_SCOPE_SHIFT);
17240 }
17241 
17242 static void
17243 parser_initialize(struct parser_params *parser)
17244 {
17245  /* note: we rely on TypedData_Make_Struct to set most fields to 0 */
17246  command_start = TRUE;
17247  ruby_sourcefile_string = Qnil;
17248 #ifdef RIPPER
17249  parser->delayed = Qnil;
17250  parser->result = Qnil;
17251  parser->parsing_thread = Qnil;
17252 #else
17253  parser->error_buffer = Qfalse;
17254 #endif
17255  parser->debug_buffer = Qnil;
17256  parser->debug_output = rb_stdout;
17257  parser->enc = rb_utf8_encoding();
17258 }
17259 
17260 #ifdef RIPPER
17261 #define parser_mark ripper_parser_mark
17262 #define parser_free ripper_parser_free
17263 #endif
17264 
17265 static void
17266 parser_mark(void *ptr)
17267 {
17268  struct parser_params *parser = (struct parser_params*)ptr;
17269 
17270  rb_gc_mark((VALUE)lex_strterm);
17271  rb_gc_mark(lex_input);
17272  rb_gc_mark(lex_lastline);
17273  rb_gc_mark(lex_nextline);
17274  rb_gc_mark(ruby_sourcefile_string);
17275 #ifndef RIPPER
17276  rb_gc_mark((VALUE)ruby_eval_tree_begin);
17277  rb_gc_mark((VALUE)ruby_eval_tree);
17278  rb_gc_mark(ruby_debug_lines);
17279  rb_gc_mark(parser->compile_option);
17280  rb_gc_mark(parser->error_buffer);
17281 #else
17282  rb_gc_mark(parser->delayed);
17283  rb_gc_mark(parser->value);
17284  rb_gc_mark(parser->result);
17285  rb_gc_mark(parser->parsing_thread);
17286 #endif
17287  rb_gc_mark(parser->debug_buffer);
17288  rb_gc_mark(parser->debug_output);
17289 #ifdef YYMALLOC
17290  rb_gc_mark((VALUE)parser->heap);
17291 #endif
17292 }
17293 
17294 static void
17295 parser_free(void *ptr)
17296 {
17297  struct parser_params *parser = (struct parser_params*)ptr;
17298  struct local_vars *local, *prev;
17299 
17300  if (tokenbuf) {
17301  xfree(tokenbuf);
17302  }
17303  for (local = lvtbl; local; local = prev) {
17304  if (local->vars) xfree(local->vars);
17305  prev = local->prev;
17306  xfree(local);
17307  }
17308  {
17309  token_info *ptinfo;
17310  while ((ptinfo = parser->token_info) != 0) {
17311  parser->token_info = ptinfo->next;
17312  xfree(ptinfo);
17313  }
17314  }
17315  xfree(ptr);
17316 }
17317 
17318 static size_t
17319 parser_memsize(const void *ptr)
17320 {
17321  struct parser_params *parser = (struct parser_params*)ptr;
17322  struct local_vars *local;
17323  size_t size = sizeof(*parser);
17324 
17325  size += toksiz;
17326  for (local = lvtbl; local; local = local->prev) {
17327  size += sizeof(*local);
17328  if (local->vars) size += local->vars->capa * sizeof(ID);
17329  }
17330  return size;
17331 }
17332 
17333 static const rb_data_type_t parser_data_type = {
17334 #ifndef RIPPER
17335  "parser",
17336 #else
17337  "ripper",
17338 #endif
17339  {
17340  parser_mark,
17341  parser_free,
17342  parser_memsize,
17343  },
17344  0, 0, RUBY_TYPED_FREE_IMMEDIATELY
17345 };
17346 
17347 #ifndef RIPPER
17348 #undef rb_reserved_word
17349 
17350 const struct kwtable *
17351 rb_reserved_word(const char *str, unsigned int len)
17352 {
17353  return reserved_word(str, len);
17354 }
17355 
17356 VALUE
17357 rb_parser_new(void)
17358 {
17359  struct parser_params *p;
17360  VALUE parser = TypedData_Make_Struct(0, struct parser_params,
17361  &parser_data_type, p);
17362  parser_initialize(p);
17363  return parser;
17364 }
17365 
17366 VALUE
17367 rb_parser_set_context(VALUE vparser, const struct rb_block *base, int main)
17368 {
17369  struct parser_params *parser;
17370 
17371  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17372  parser->error_buffer = main ? Qfalse : Qnil;
17373  parser->base_block = base;
17374  in_main = main;
17375  return vparser;
17376 }
17377 #endif
17378 
17379 #ifdef RIPPER
17380 #define rb_parser_end_seen_p ripper_parser_end_seen_p
17381 #define rb_parser_encoding ripper_parser_encoding
17382 #define rb_parser_get_yydebug ripper_parser_get_yydebug
17383 #define rb_parser_set_yydebug ripper_parser_set_yydebug
17384 static VALUE ripper_parser_end_seen_p(VALUE vparser);
17385 static VALUE ripper_parser_encoding(VALUE vparser);
17386 static VALUE ripper_parser_get_yydebug(VALUE self);
17387 static VALUE ripper_parser_set_yydebug(VALUE self, VALUE flag);
17388 
17389 /*
17390  * call-seq:
17391  * ripper.error? -> Boolean
17392  *
17393  * Return true if parsed source has errors.
17394  */
17395 static VALUE
17396 ripper_error_p(VALUE vparser)
17397 {
17398  struct parser_params *parser;
17399 
17400  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17401  return parser->error_p ? Qtrue : Qfalse;
17402 }
17403 #endif
17404 
17405 /*
17406  * call-seq:
17407  * ripper.end_seen? -> Boolean
17408  *
17409  * Return true if parsed source ended by +\_\_END\_\_+.
17410  */
17411 VALUE
17412 rb_parser_end_seen_p(VALUE vparser)
17413 {
17414  struct parser_params *parser;
17415 
17416  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17417  return ruby__end__seen ? Qtrue : Qfalse;
17418 }
17419 
17420 /*
17421  * call-seq:
17422  * ripper.encoding -> encoding
17423  *
17424  * Return encoding of the source.
17425  */
17426 VALUE
17427 rb_parser_encoding(VALUE vparser)
17428 {
17429  struct parser_params *parser;
17430 
17431  TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
17432  return rb_enc_from_encoding(current_enc);
17433 }
17434 
17435 /*
17436  * call-seq:
17437  * ripper.yydebug -> true or false
17438  *
17439  * Get yydebug.
17440  */
17441 VALUE
17442 rb_parser_get_yydebug(VALUE self)
17443 {
17444  struct parser_params *parser;
17445 
17446  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17447  return yydebug ? Qtrue : Qfalse;
17448 }
17449 
17450 /*
17451  * call-seq:
17452  * ripper.yydebug = flag
17453  *
17454  * Set yydebug.
17455  */
17456 VALUE
17457 rb_parser_set_yydebug(VALUE self, VALUE flag)
17458 {
17459  struct parser_params *parser;
17460 
17461  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17462  yydebug = RTEST(flag);
17463  return flag;
17464 }
17465 
17466 #ifndef RIPPER
17467 #ifdef YYMALLOC
17468 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
17469 #define NEWHEAP() (rb_imemo_alloc_t *)rb_imemo_new(imemo_alloc, 0, (VALUE)parser->heap, 0, 0)
17470 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->ptr = (p), \
17471  (n)->cnt = (c), (p))
17472 
17473 void *
17474 rb_parser_malloc(struct parser_params *parser, size_t size)
17475 {
17476  size_t cnt = HEAPCNT(1, size);
17477  rb_imemo_alloc_t *n = NEWHEAP();
17478  void *ptr = xmalloc(size);
17479 
17480  return ADD2HEAP(n, cnt, ptr);
17481 }
17482 
17483 void *
17484 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
17485 {
17486  size_t cnt = HEAPCNT(nelem, size);
17487  rb_imemo_alloc_t *n = NEWHEAP();
17488  void *ptr = xcalloc(nelem, size);
17489 
17490  return ADD2HEAP(n, cnt, ptr);
17491 }
17492 
17493 void *
17494 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
17495 {
17496  rb_imemo_alloc_t *n;
17497  size_t cnt = HEAPCNT(1, size);
17498 
17499  if (ptr && (n = parser->heap) != NULL) {
17500  do {
17501  if (n->ptr == ptr) {
17502  n->ptr = ptr = xrealloc(ptr, size);
17503  if (n->cnt) n->cnt = cnt;
17504  return ptr;
17505  }
17506  } while ((n = n->next) != NULL);
17507  }
17508  n = NEWHEAP();
17509  ptr = xrealloc(ptr, size);
17510  return ADD2HEAP(n, cnt, ptr);
17511 }
17512 
17513 void
17514 rb_parser_free(struct parser_params *parser, void *ptr)
17515 {
17516  rb_imemo_alloc_t **prev = &parser->heap, *n;
17517 
17518  while ((n = *prev) != NULL) {
17519  if (n->ptr == ptr) {
17520  *prev = n->next;
17521  rb_gc_force_recycle((VALUE)n);
17522  break;
17523  }
17524  prev = &n->next;
17525  }
17526  xfree(ptr);
17527 }
17528 #endif
17529 
17530 void
17531 rb_parser_printf(struct parser_params *parser, const char *fmt, ...)
17532 {
17533  va_list ap;
17534  VALUE mesg = parser->debug_buffer;
17535 
17536  if (NIL_P(mesg)) parser->debug_buffer = mesg = rb_str_new(0, 0);
17537  va_start(ap, fmt);
17538  rb_str_vcatf(mesg, fmt, ap);
17539  va_end(ap);
17540  if (RSTRING_END(mesg)[-1] == '\n') {
17541  rb_io_write(parser->debug_output, mesg);
17542  parser->debug_buffer = Qnil;
17543  }
17544 }
17545 
17546 static void
17547 parser_compile_error(struct parser_params *parser, const char *fmt, ...)
17548 {
17549  va_list ap;
17550 
17551  rb_io_flush(parser->debug_output);
17552  parser->error_p = 1;
17553  va_start(ap, fmt);
17554  parser->error_buffer =
17555  rb_syntax_error_append(parser->error_buffer,
17556  ruby_sourcefile_string,
17557  ruby_sourceline,
17558  rb_long2int(lex_p - lex_pbeg),
17559  current_enc, fmt, ap);
17560  va_end(ap);
17561 }
17562 #endif
17563 
17564 #ifdef RIPPER
17565 #ifdef RIPPER_DEBUG
17566 extern int rb_is_pointer_to_heap(VALUE);
17567 
17568 /* :nodoc: */
17569 static VALUE
17570 ripper_validate_object(VALUE self, VALUE x)
17571 {
17572  if (x == Qfalse) return x;
17573  if (x == Qtrue) return x;
17574  if (x == Qnil) return x;
17575  if (x == Qundef)
17576  rb_raise(rb_eArgError, "Qundef given");
17577  if (FIXNUM_P(x)) return x;
17578  if (SYMBOL_P(x)) return x;
17579  if (!rb_is_pointer_to_heap(x))
17580  rb_raise(rb_eArgError, "invalid pointer: %p", x);
17581  switch (BUILTIN_TYPE(x)) {
17582  case T_STRING:
17583  case T_OBJECT:
17584  case T_ARRAY:
17585  case T_BIGNUM:
17586  case T_FLOAT:
17587  case T_COMPLEX:
17588  case T_RATIONAL:
17589  return x;
17590  case T_NODE:
17591  if (nd_type(x) != NODE_RIPPER) {
17592  rb_raise(rb_eArgError, "NODE given: %p", x);
17593  }
17594  return ((NODE *)x)->nd_rval;
17595  default:
17596  rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
17597  x, rb_obj_classname(x));
17598  }
17599  return x;
17600 }
17601 #endif
17602 
17603 #define validate(x) ((x) = get_value(x))
17604 
17605 static VALUE
17606 ripper_dispatch0(struct parser_params *parser, ID mid)
17607 {
17608  return rb_funcall(parser->value, mid, 0);
17609 }
17610 
17611 static VALUE
17612 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
17613 {
17614  validate(a);
17615  return rb_funcall(parser->value, mid, 1, a);
17616 }
17617 
17618 static VALUE
17619 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
17620 {
17621  validate(a);
17622  validate(b);
17623  return rb_funcall(parser->value, mid, 2, a, b);
17624 }
17625 
17626 static VALUE
17627 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
17628 {
17629  validate(a);
17630  validate(b);
17631  validate(c);
17632  return rb_funcall(parser->value, mid, 3, a, b, c);
17633 }
17634 
17635 static VALUE
17636 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
17637 {
17638  validate(a);
17639  validate(b);
17640  validate(c);
17641  validate(d);
17642  return rb_funcall(parser->value, mid, 4, a, b, c, d);
17643 }
17644 
17645 static VALUE
17646 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
17647 {
17648  validate(a);
17649  validate(b);
17650  validate(c);
17651  validate(d);
17652  validate(e);
17653  return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
17654 }
17655 
17656 static VALUE
17657 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
17658 {
17659  validate(a);
17660  validate(b);
17661  validate(c);
17662  validate(d);
17663  validate(e);
17664  validate(f);
17665  validate(g);
17666  return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
17667 }
17668 
17669 static ID
17670 ripper_get_id(VALUE v)
17671 {
17672  NODE *nd;
17673  if (!RB_TYPE_P(v, T_NODE)) return 0;
17674  nd = (NODE *)v;
17675  if (nd_type(nd) != NODE_RIPPER) return 0;
17676  return nd->nd_vid;
17677 }
17678 
17679 static VALUE
17680 ripper_get_value(VALUE v)
17681 {
17682  NODE *nd;
17683  if (v == Qundef) return Qnil;
17684  if (!RB_TYPE_P(v, T_NODE)) return v;
17685  nd = (NODE *)v;
17686  if (nd_type(nd) != NODE_RIPPER) return Qnil;
17687  return nd->nd_rval;
17688 }
17689 
17690 static void
17691 ripper_error_gen(struct parser_params *parser)
17692 {
17693  parser->error_p = TRUE;
17694 }
17695 
17696 static void
17697 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
17698 {
17699  VALUE str;
17700  va_list args;
17701 
17702  va_start(args, fmt);
17703  str = rb_vsprintf(fmt, args);
17704  va_end(args);
17705  rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
17706  ripper_error_gen(parser);
17707 }
17708 
17709 static VALUE
17710 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
17711 {
17712  VALUE line = rb_funcallv_public(src, id_gets, 0, 0);
17713  if (!NIL_P(line) && !RB_TYPE_P(line, T_STRING)) {
17714  rb_raise(rb_eTypeError,
17715  "gets returned %"PRIsVALUE" (expected String or nil)",
17716  rb_obj_class(line));
17717  }
17718  return line;
17719 }
17720 
17721 static VALUE
17722 ripper_lex_io_get(struct parser_params *parser, VALUE src)
17723 {
17724  return rb_io_gets(src);
17725 }
17726 
17727 static VALUE
17728 ripper_s_allocate(VALUE klass)
17729 {
17730  struct parser_params *p;
17731  VALUE self = TypedData_Make_Struct(klass, struct parser_params,
17732  &parser_data_type, p);
17733  p->value = self;
17734  return self;
17735 }
17736 
17737 #define ripper_initialized_p(r) ((r)->lex.input != 0)
17738 
17739 /*
17740  * call-seq:
17741  * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
17742  *
17743  * Create a new Ripper object.
17744  * _src_ must be a String, an IO, or an Object which has #gets method.
17745  *
17746  * This method does not starts parsing.
17747  * See also Ripper#parse and Ripper.parse.
17748  */
17749 static VALUE
17750 ripper_initialize(int argc, VALUE *argv, VALUE self)
17751 {
17752  struct parser_params *parser;
17753  VALUE src, fname, lineno;
17754 
17755  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17756  rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
17757  if (RB_TYPE_P(src, T_FILE)) {
17758  lex_gets = ripper_lex_io_get;
17759  }
17760  else if (rb_respond_to(src, id_gets)) {
17761  lex_gets = ripper_lex_get_generic;
17762  }
17763  else {
17764  StringValue(src);
17765  lex_gets = lex_get_str;
17766  }
17767  lex_input = src;
17768  parser->eofp = 0;
17769  if (NIL_P(fname)) {
17770  fname = STR_NEW2("(ripper)");
17771  OBJ_FREEZE(fname);
17772  }
17773  else {
17774  StringValueCStr(fname);
17775  fname = rb_str_new_frozen(fname);
17776  }
17777  parser_initialize(parser);
17778 
17779  ruby_sourcefile_string = fname;
17780  ruby_sourcefile = RSTRING_PTR(fname);
17781  ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
17782 
17783  return Qnil;
17784 }
17785 
17786 struct ripper_args {
17787  struct parser_params *parser;
17788  int argc;
17789  VALUE *argv;
17790 };
17791 
17792 static VALUE
17793 ripper_parse0(VALUE parser_v)
17794 {
17795  struct parser_params *parser;
17796 
17797  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17798  parser_prepare(parser);
17799  ripper_yyparse((void*)parser);
17800  return parser->result;
17801 }
17802 
17803 static VALUE
17804 ripper_ensure(VALUE parser_v)
17805 {
17806  struct parser_params *parser;
17807 
17808  TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
17809  parser->parsing_thread = Qnil;
17810  return Qnil;
17811 }
17812 
17813 /*
17814  * call-seq:
17815  * ripper.parse
17816  *
17817  * Start parsing and returns the value of the root action.
17818  */
17819 static VALUE
17820 ripper_parse(VALUE self)
17821 {
17822  struct parser_params *parser;
17823 
17824  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17825  if (!ripper_initialized_p(parser)) {
17826  rb_raise(rb_eArgError, "method called for uninitialized object");
17827  }
17828  if (!NIL_P(parser->parsing_thread)) {
17829  if (parser->parsing_thread == rb_thread_current())
17830  rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
17831  else
17832  rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
17833  }
17834  parser->parsing_thread = rb_thread_current();
17835  rb_ensure(ripper_parse0, self, ripper_ensure, self);
17836 
17837  return parser->result;
17838 }
17839 
17840 /*
17841  * call-seq:
17842  * ripper.column -> Integer
17843  *
17844  * Return column number of current parsing line.
17845  * This number starts from 0.
17846  */
17847 static VALUE
17848 ripper_column(VALUE self)
17849 {
17850  struct parser_params *parser;
17851  long col;
17852 
17853  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17854  if (!ripper_initialized_p(parser)) {
17855  rb_raise(rb_eArgError, "method called for uninitialized object");
17856  }
17857  if (NIL_P(parser->parsing_thread)) return Qnil;
17858  col = parser->tokp - lex_pbeg;
17859  return LONG2NUM(col);
17860 }
17861 
17862 /*
17863  * call-seq:
17864  * ripper.filename -> String
17865  *
17866  * Return current parsing filename.
17867  */
17868 static VALUE
17869 ripper_filename(VALUE self)
17870 {
17871  struct parser_params *parser;
17872 
17873  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17874  if (!ripper_initialized_p(parser)) {
17875  rb_raise(rb_eArgError, "method called for uninitialized object");
17876  }
17877  return ruby_sourcefile_string;
17878 }
17879 
17880 /*
17881  * call-seq:
17882  * ripper.lineno -> Integer
17883  *
17884  * Return line number of current parsing line.
17885  * This number starts from 1.
17886  */
17887 static VALUE
17888 ripper_lineno(VALUE self)
17889 {
17890  struct parser_params *parser;
17891 
17892  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17893  if (!ripper_initialized_p(parser)) {
17894  rb_raise(rb_eArgError, "method called for uninitialized object");
17895  }
17896  if (NIL_P(parser->parsing_thread)) return Qnil;
17897  return INT2NUM(ruby_sourceline);
17898 }
17899 
17900 /*
17901  * call-seq:
17902  * ripper.state -> Integer
17903  *
17904  * Return scanner state of current token.
17905  */
17906 static VALUE
17907 ripper_state(VALUE self)
17908 {
17909  struct parser_params *parser;
17910 
17911  TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
17912  if (!ripper_initialized_p(parser)) {
17913  rb_raise(rb_eArgError, "method called for uninitialized object");
17914  }
17915  if (NIL_P(parser->parsing_thread)) return Qnil;
17916  return INT2NUM(lex_state);
17917 }
17918 
17919 #ifdef RIPPER_DEBUG
17920 /* :nodoc: */
17921 static VALUE
17922 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
17923 {
17924  StringValue(msg);
17925  if (obj == Qundef) {
17926  rb_raise(rb_eArgError, "%"PRIsVALUE, msg);
17927  }
17928  return Qnil;
17929 }
17930 
17931 /* :nodoc: */
17932 static VALUE
17933 ripper_value(VALUE self, VALUE obj)
17934 {
17935  return ULONG2NUM(obj);
17936 }
17937 #endif
17938 
17939 static VALUE
17940 ripper_lex_state_name(VALUE self, VALUE state)
17941 {
17942  return rb_parser_lex_state_name(NUM2INT(state));
17943 }
17944 
17945 void
17946 Init_ripper(void)
17947 {
17948  ripper_init_eventids1();
17949  ripper_init_eventids2();
17950  id_warn = rb_intern_const("warn");
17951  id_warning = rb_intern_const("warning");
17952  id_gets = rb_intern_const("gets");
17953 
17954  InitVM(ripper);
17955 }
17956 
17957 void
17958 InitVM_ripper(void)
17959 {
17960  VALUE Ripper;
17961 
17962  Ripper = rb_define_class("Ripper", rb_cObject);
17963  /* version of Ripper */
17964  rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
17965  rb_define_alloc_func(Ripper, ripper_s_allocate);
17966  rb_define_method(Ripper, "initialize", ripper_initialize, -1);
17967  rb_define_method(Ripper, "parse", ripper_parse, 0);
17968  rb_define_method(Ripper, "column", ripper_column, 0);
17969  rb_define_method(Ripper, "filename", ripper_filename, 0);
17970  rb_define_method(Ripper, "lineno", ripper_lineno, 0);
17971  rb_define_method(Ripper, "state", ripper_state, 0);
17972  rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
17973  rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
17974  rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
17975  rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
17976  rb_define_method(Ripper, "error?", ripper_error_p, 0);
17977 #ifdef RIPPER_DEBUG
17978  rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
17979  rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
17980  rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
17981 #endif
17982 
17983  rb_define_singleton_method(Ripper, "dedent_string", parser_dedent_string, 2);
17984  rb_define_private_method(Ripper, "dedent_string", parser_dedent_string, 2);
17985 
17986  rb_define_singleton_method(Ripper, "lex_state_name", ripper_lex_state_name, 1);
17987 
17988  /* ignore newline, +/- is a sign. */
17989  rb_define_const(Ripper, "EXPR_BEG", INT2NUM(EXPR_BEG));
17990  /* newline significant, +/- is an operator. */
17991  rb_define_const(Ripper, "EXPR_END", INT2NUM(EXPR_END));
17992  /* ditto, and unbound braces. */
17993  rb_define_const(Ripper, "EXPR_ENDARG", INT2NUM(EXPR_ENDARG));
17994  /* ditto, and unbound braces. */
17995  rb_define_const(Ripper, "EXPR_ENDFN", INT2NUM(EXPR_ENDFN));
17996  /* newline significant, +/- is an operator. */
17997  rb_define_const(Ripper, "EXPR_ARG", INT2NUM(EXPR_ARG));
17998  /* newline significant, +/- is an operator. */
17999  rb_define_const(Ripper, "EXPR_CMDARG", INT2NUM(EXPR_CMDARG));
18000  /* newline significant, +/- is an operator. */
18001  rb_define_const(Ripper, "EXPR_MID", INT2NUM(EXPR_MID));
18002  /* ignore newline, no reserved words. */
18003  rb_define_const(Ripper, "EXPR_FNAME", INT2NUM(EXPR_FNAME));
18004  /* right after `.' or `::', no reserved words. */
18005  rb_define_const(Ripper, "EXPR_DOT", INT2NUM(EXPR_DOT));
18006  /* immediate after `class', no here document. */
18007  rb_define_const(Ripper, "EXPR_CLASS", INT2NUM(EXPR_CLASS));
18008  /* flag bit, label is allowed. */
18009  rb_define_const(Ripper, "EXPR_LABEL", INT2NUM(EXPR_LABEL));
18010  /* flag bit, just after a label. */
18011  rb_define_const(Ripper, "EXPR_LABELED", INT2NUM(EXPR_LABELED));
18012  /* symbol literal as FNAME. */
18013  rb_define_const(Ripper, "EXPR_FITEM", INT2NUM(EXPR_FITEM));
18014  /* equals to +EXPR_BEG+ */
18015  rb_define_const(Ripper, "EXPR_VALUE", INT2NUM(EXPR_VALUE));
18016  /* equals to <tt>(EXPR_BEG | EXPR_MID | EXPR_CLASS)</tt> */
18017  rb_define_const(Ripper, "EXPR_BEG_ANY", INT2NUM(EXPR_BEG_ANY));
18018  /* equals to <tt>(EXPR_ARG | EXPR_CMDARG)</tt> */
18019  rb_define_const(Ripper, "EXPR_ARG_ANY", INT2NUM(EXPR_ARG_ANY));
18020  /* equals to <tt>(EXPR_END | EXPR_ENDARG | EXPR_ENDFN)</tt> */
18021  rb_define_const(Ripper, "EXPR_END_ANY", INT2NUM(EXPR_END_ANY));
18022 
18023  ripper_init_eventids1_table(Ripper);
18024  ripper_init_eventids2_table(Ripper);
18025 
18026 # if 0
18027  /* Hack to let RDoc document SCRIPT_LINES__ */
18028 
18029  /*
18030  * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
18031  * after the assignment will be added as an Array of lines with the file
18032  * name as the key.
18033  */
18034  rb_define_global_const("SCRIPT_LINES__", Qnil);
18035 #endif
18036 
18037 }
18038 #endif /* RIPPER */
18039 
STRNCASECMP
#define STRNCASECMP(s1, s2, n)
Definition: ruby.h:2159
in_defined
#define in_defined
Definition: ripper.c:583
rb_define_global_const
void rb_define_global_const(const char *, VALUE)
Definition: variable.c:2702
keyword_when
#define keyword_when
Definition: ripper.c:204
YYSTYPE::val
VALUE val
Definition: parse.h:286
local_var
#define local_var(id)
Definition: ripper.c:960
arg_var
#define arg_var(id)
Definition: ripper.c:962
rb_fatal
void rb_fatal(const char *fmt,...)
Definition: error.c:2338
ret_args
#define ret_args(node)
Definition: ripper.c:722
yyparse
#define yyparse
Definition: ripper.c:647
nd_column
#define nd_column(n)
Definition: node.h:281
T_OBJECT
#define T_OBJECT
Definition: ruby.h:491
NODE_CALL
Definition: node.h:91
NODE_CASE
Definition: node.h:31
local_vars::cmdargs
stack_type cmdargs
Definition: ripper.c:447
ISDIGIT
#define ISDIGIT(c)
Definition: ruby.h:2150
NEW_RETURN
#define NEW_RETURN(s)
Definition: node.h:378
onig_foreach_name
ONIG_EXTERN int onig_foreach_name(OnigRegex reg, int(*func)(const OnigUChar *, const OnigUChar *, int, int *, OnigRegex, void *), void *arg)
kwtable::state
int state
Definition: lex.c:33
rb_ary_unshift
VALUE rb_ary_unshift(VALUE ary, VALUE item)
Definition: array.c:1197
new_command
#define new_command(m, a)
Definition: ripper.c:708
kwtable
Definition: lex.c:33
IS_LABEL_SUFFIX
#define IS_LABEL_SUFFIX(n)
Definition: ripper.c:12387
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition: ripper.c:1377
nd_alen
#define nd_alen
Definition: node.h:285
rb_enc_codelen
int rb_enc_codelen(int c, rb_encoding *enc)
Definition: encoding.c:1077
new_args_tail
#define new_args_tail(k, kr, b, column)
Definition: ripper.c:715
NEW_OP_ASGN_AND
#define NEW_OP_ASGN_AND(i, val)
Definition: node.h:396
lex_input
#define lex_input
Definition: ripper.c:588
lex_state
#define lex_state
Definition: ripper.c:574
subnodes
#define subnodes(n1, n2)
MBCLEN_CHARFOUND_P
#define MBCLEN_CHARFOUND_P(ret)
Definition: encoding.h:185
yyalloc::yyvs
YYSTYPE yyvs
Definition: ripper.c:1417
NEW_STRTERM
#define NEW_STRTERM(func, term, paren)
Definition: ripper.c:12293
tLBRACE
#define tLBRACE
Definition: ripper.c:283
parser_params::in_kwarg
unsigned int in_kwarg
Definition: ripper.c:523
RRATIONAL_SET_NUM
#define RRATIONAL_SET_NUM(rat, n)
Definition: internal.h:631
NEW_OP_ASGN1
#define NEW_OP_ASGN1(p, id, a)
Definition: node.h:392
NEW_SCLASS
#define NEW_SCLASS(r, b)
Definition: node.h:436
yydebug
#define yydebug
Definition: ripper.c:607
RARRAY_LEN
#define RARRAY_LEN(a)
Definition: ruby.h:1019
YYSTYPE::num
int num
Definition: parse.h:289
IS_END
#define IS_END()
Definition: ripper.c:12381
token_info::next
struct token_info * next
Definition: ripper.c:460
local_vars
Definition: ripper.c:439
parser_params::brace_nest
int brace_nest
Definition: ripper.c:491
FALSE
#define FALSE
Definition: nkf.h:174
RUBY_TYPED_FREE_IMMEDIATELY
#define RUBY_TYPED_FREE_IMMEDIATELY
Definition: ruby.h:1138
heredoc_indent
#define heredoc_indent
Definition: ripper.c:595
modifier_if
#define modifier_if
Definition: ripper.c:227
rb_parser_compile_string_path
NODE * rb_parser_compile_string_path(VALUE vparser, VALUE f, VALUE s, int line)
Definition: ripper.c:11540
rb_str_coderange_scan_restartable
long rb_str_coderange_scan_restartable(const char *, const char *, rb_encoding *, int *)
Definition: string.c:531
NEW_LIST
#define NEW_LIST(a)
Definition: node.h:380
NEW_DEFINED
#define NEW_DEFINED(e)
Definition: node.h:447
local_vars::used
struct vtable * used
Definition: ripper.c:442
tHEREDOC_BEG
#define tHEREDOC_BEG
Definition: eventids2.c:7
RE_OPTION_ENCODING_IDX
#define RE_OPTION_ENCODING_IDX(o)
Definition: ripper.c:994
new_regexp
#define new_regexp(node, opt, column)
Definition: ripper.c:769
keyword_unless
#define keyword_unless
Definition: ripper.c:199
strlen
size_t strlen(const char *)
new_call
#define new_call(recv, mid, args, column)
Definition: ripper.c:790
INT2NUM
#define INT2NUM(x)
Definition: ruby.h:1538
rb_reg_compile
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2919
STR_FUNC_ESCAPE
#define STR_FUNC_ESCAPE
Definition: ripper.c:11600
scan_oct
#define scan_oct(s, l, e)
Definition: util.h:53
nd_plen
#define nd_plen
Definition: node.h:323
T_FIXNUM
#define T_FIXNUM
Definition: ruby.h:503
st_table
Definition: st.h:79
stack_type
VALUE stack_type
Definition: ripper.c:411
reg_compile
#define reg_compile(str, options)
Definition: ripper.c:849
NODE_REDO
Definition: node.h:49
NEW_XSTR
#define NEW_XSTR(s)
Definition: node.h:412
toksiz
#define toksiz
Definition: ripper.c:586
YY_
#define YY_(msgid)
Definition: ripper.c:1309
NUM2INT
#define NUM2INT(x)
Definition: ruby.h:684
YYSTACK_FREE
#define YYSTACK_FREE
Definition: ripper.c:1378
rb_intern2
ID rb_intern2(const char *, long)
Definition: symbol.c:604
NEW_DOT2
#define NEW_DOT2(b, e)
Definition: node.h:440
NUM2UINT
#define NUM2UINT(x)
Definition: ruby.h:685
value_expr
#define value_expr(node)
Definition: ripper.c:672
parser_params::heredoc_end
int heredoc_end
Definition: ripper.c:498
nd_paren
#define nd_paren(node)
Definition: ripper.c:1008
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:1716
keyword_do_LAMBDA
#define keyword_do_LAMBDA
Definition: ripper.c:216
parser_params::strterm
NODE * strterm
Definition: ripper.c:478
list_append
#define list_append(l, i, column)
Definition: ripper.c:685
tEMBDOC_BEG
#define tEMBDOC_BEG
Definition: eventids2.c:3
get_id
#define get_id(id)
Definition: ripper.c:860
rb_usascii_str_new2
#define rb_usascii_str_new2
Definition: intern.h:841
parser_params::heredoc_indent
int heredoc_indent
Definition: ripper.c:499
rb_raise
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:2284
keyword_yield
#define keyword_yield
Definition: ripper.c:218
YYLEX
#define YYLEX
Definition: ripper.c:4937
InitVM
#define InitVM(ext)
Definition: ruby.h:2164
rb_str_cat
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:2746
YYABORT
#define YYABORT
Definition: ripper.c:4856
st_foreach
#define st_foreach
Definition: regint.h:186
idNULL
Definition: id.h:108
reg_named_capture_assign_t::column
int column
Definition: ripper.c:17060
nd_line
#define nd_line(n)
Definition: node.h:278
lex_eol_p
#define lex_eol_p()
Definition: ripper.c:11639
idLTLT
Definition: id.h:88
Qtrue
#define Qtrue
Definition: ruby.h:437
rb_reg_check_preprocess
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2672
PRINTF_ARGS
PRINTF_ARGS(void rb_parser_fatal(struct parser_params *parser, const char *fmt,...), 2, 3)
new_errinfo
#define new_errinfo(column)
Definition: ripper.c:787
dyna_in_block
#define dyna_in_block()
Definition: ripper.c:974
CMDARG_LEXPOP
#define CMDARG_LEXPOP()
Definition: ripper.c:428
str_copy
#define str_copy(_s, _p, _n)
tEQ
#define tEQ
Definition: ripper.c:259
was_bol
#define was_bol()
Definition: ripper.c:11731
token_flush
#define token_flush(p)
Definition: ripper.c:571
rb_parser_compile_file_path
NODE * rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE file, int start)
Definition: ripper.c:11583
IS_SPCARG
#define IS_SPCARG(c)
Definition: ripper.c:12383
void_stmts
#define void_stmts(node)
Definition: ripper.c:676
rb_io_flush
VALUE rb_io_flush(VALUE)
Definition: io.c:1592
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:15557
reg_named_capture_assign_t
Definition: ripper.c:17056
keyword__ENCODING__
#define keyword__ENCODING__
Definition: ripper.c:238
rb_id2str
#define rb_id2str(id)
Definition: vm_backtrace.c:29
idLE
Definition: id.h:91
idUPlus
Definition: id.h:79
rb_warn1
#define rb_warn1(fmt, a)
Definition: ripper.c:1123
rb_parser_end_seen_p
VALUE rb_parser_end_seen_p(VALUE vparser)
Definition: ripper.c:17412
ST_CONTINUE
Definition: st.h:99
TypedData_Get_Struct
#define TypedData_Get_Struct(obj, type, data_type, sval)
Definition: ruby.h:1183
idNeq
Definition: id.h:96
OBJ_FREEZE
#define OBJ_FREEZE(x)
Definition: ruby.h:1306
intern_cstr
#define intern_cstr(n, l, en)
Definition: ripper.c:559
id
const int id
Definition: nkf.c:209
current_enc
#define current_enc
Definition: ripper.c:605
new_ivar
#define new_ivar(id, column)
Definition: ripper.c:817
parser_params::line_count
int line_count
Definition: ripper.c:503
YYNTOKENS
#define YYNTOKENS
Definition: ripper.c:1472
token_info
struct token_info token_info
tRPAREN
#define tRPAREN
Definition: ripper.c:281
node_type
node_type
Definition: node.h:22
keyword_return
#define keyword_return
Definition: ripper.c:217
new_args
#define new_args(f, o, r, p, t)
Definition: ripper.c:713
strcasecmp
#define strcasecmp
Definition: win32.h:191
ID_CONST
#define ID_CONST
Definition: id.h:37
rb_suppress_tracing
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:376
rb_define_private_method
void rb_define_private_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1527
nextc
#define nextc()
Definition: ripper.c:10980
rb_warning0
#define rb_warning0(fmt)
Definition: ripper.c:1127
rb_enc_from_encoding
VALUE rb_enc_from_encoding(rb_encoding *encoding)
Definition: encoding.c:117
parser_params::eofp
unsigned int eofp
Definition: ripper.c:517
token_info_push
#define token_info_push(token)
Definition: ripper.c:1194
NUM_SUFFIX_R
#define NUM_SUFFIX_R
Definition: ripper.c:12681
tAMPER
#define tAMPER
Definition: ripper.c:287
rb_enc_symname2_p
int rb_enc_symname2_p(const char *, long, rb_encoding *)
Definition: symbol.c:311
YYSTYPE
union YYSTYPE YYSTYPE
YYSTYPE::node
NODE * node
Definition: parse.h:287
T_RATIONAL
#define T_RATIONAL
Definition: ruby.h:509
rb_default_coverage
VALUE rb_default_coverage(int)
Definition: thread.c:5081
ULONG2NUM
#define ULONG2NUM(x)
Definition: ruby.h:1574
rb_ary_push
VALUE rb_ary_push(VALUE ary, VALUE item)
Definition: array.c:924
rb_long2int
#define rb_long2int(n)
Definition: ruby.h:319
RREGEXP_PTR
#define RREGEXP_PTR(r)
Definition: ruby.h:1049
NEW_CLASS
#define NEW_CLASS(n, b, s)
Definition: node.h:435
MAX_WORD_LENGTH
#define MAX_WORD_LENGTH
Definition: lex.c:43
parser_params::lvtbl
struct local_vars * lvtbl
Definition: ripper.c:502
new_fcall
#define new_fcall(mid, args, column)
Definition: ripper.c:793
keyword_do_block
#define keyword_do_block
Definition: ripper.c:215
yytype_uint16
unsigned short int yytype_uint16
Definition: ripper.c:1276
parse_string
#define parse_string(n)
Definition: ripper.c:10990
rb_enc_compatible
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:962
parser_params::command_start
unsigned int command_start
Definition: ripper.c:516
NEW_OPT_N
#define NEW_OPT_N(b)
Definition: node.h:364
rb_reserved_word
const struct kwtable * rb_reserved_word(const char *str, unsigned int len)
Definition: ripper.c:17351
nd_set_column
#define nd_set_column(n, v)
Definition: node.h:282
rb_local_defined
int rb_local_defined(ID id, const struct rb_block *base_block)
Definition: compile.c:7517
is_identchar
#define is_identchar(p, e, enc)
Definition: ripper.c:11087
COND_PUSH
#define COND_PUSH(n)
Definition: ripper.c:420
RNode::u3
union RNode::@90 u3
parser_params::debug_lines
VALUE debug_lines
Definition: ripper.c:540
tEQQ
#define tEQQ
Definition: ripper.c:260
YYTABLE_NINF
#define YYTABLE_NINF
Definition: ripper.c:2396
rb_funcall
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
Definition: vm_eval.c:774
rb_parser_compile_file
NODE * rb_parser_compile_file(VALUE vparser, const char *f, VALUE file, int start)
Definition: ripper.c:11577
parser_params::lval
YYSTYPE * lval
Definition: ripper.c:475
YYSTYPE::id
ID id
Definition: parse.h:288
CMDARG_P
#define CMDARG_P()
Definition: ripper.c:429
new_string1
#define new_string1(str)
Definition: ripper.c:836
dvar_defined
#define dvar_defined(id)
Definition: ripper.c:978
rb_str_set_len
void rb_str_set_len(VALUE, long)
Definition: string.c:2627
rb_io_gets_internal
VALUE rb_io_gets_internal(VALUE io)
Definition: io.c:3287
yyerrok
#define yyerrok
Definition: ripper.c:4850
YYEMPTY
#define YYEMPTY
Definition: ripper.c:4852
tok
#define tok()
Definition: ripper.c:11734
parser_params::token_seen
unsigned int token_seen
Definition: ripper.c:526
rb_enc_str_coderange
int rb_enc_str_coderange(VALUE)
Definition: string.c:621
tSYMBOLS_BEG
#define tSYMBOLS_BEG
Definition: ripper.c:295
parser_params::token_info
token_info * token_info
Definition: ripper.c:508
reg_fragment_setenc
#define reg_fragment_setenc(str, options)
Definition: ripper.c:851
new_hash
#define new_hash(hash, column)
Definition: ripper.c:763
literal_concat
#define literal_concat(h, t, column)
Definition: ripper.c:692
NEW_NIL
#define NEW_NIL()
Definition: node.h:443
RSTRING_GETMEM
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Definition: ruby.h:984
rb_enc_associate
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
Definition: encoding.c:854
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: ripper.c:4954
reg_named_capture_assign_t::succ_block
NODE * succ_block
Definition: ripper.c:17059
keyword__FILE__
#define keyword__FILE__
Definition: ripper.c:237
vtable::tbl
ID * tbl
Definition: ripper.c:433
dispatch_scan_event
#define dispatch_scan_event(t)
Definition: ripper.c:11025
newtok
#define newtok()
Definition: ripper.c:10982
reduce_nodes
#define reduce_nodes(n)
Definition: ripper.c:678
YYPOPSTACK
#define YYPOPSTACK(N)
NEW_OP_ASGN2
#define NEW_OP_ASGN2(r, t, i, o, val)
Definition: node.h:393
dyna_var
#define dyna_var(id)
Definition: ripper.c:975
rb_args_info::pre_args_num
int pre_args_num
Definition: node.h:486
RB_GC_GUARD
#define RB_GC_GUARD(v)
Definition: ruby.h:552
rb_define_alloc_func
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
NODE_HEREDOC
#define NODE_HEREDOC
Definition: ripper.c:1000
T_HASH
#define T_HASH
Definition: ruby.h:499
peekc_n
#define peekc_n(n)
Definition: ripper.c:11643
YYLTYPE::first_column
int first_column
Definition: parse.h:305
tASSOC
#define tASSOC
Definition: ripper.c:278
POINTER_P
#define POINTER_P(val)
Definition: ripper.c:453
parser_params::cur_arg
ID cur_arg
Definition: ripper.c:514
SET_LEX_STATE
#define SET_LEX_STATE(ls)
Definition: ripper.c:405
tSTRING_DVAR
#define tSTRING_DVAR
Definition: ripper.c:299
STR_FUNC_INDENT
#define STR_FUNC_INDENT
Definition: ripper.c:11605
local_id_ref
#define local_id_ref(id, vidp)
Definition: ripper.c:964
tLAST_TOKEN
#define tLAST_TOKEN
Definition: ripper.c:305
in_main
#define in_main
Definition: ripper.c:582
ID_LOCAL
#define ID_LOCAL
Definition: id.h:33
nd_args
#define nd_args
Definition: node.h:327
keyword_nil
#define keyword_nil
Definition: ripper.c:221
token
unsigned short token
Definition: id.c:36
keyword_END
#define keyword_END
Definition: ripper.c:235
nd_set_type
#define nd_set_type(n, t)
Definition: node.h:273
Qnone
#define Qnone
Definition: ripper.c:1113
cond
#define cond(node, column)
Definition: ripper.c:653
alias
const char * alias
Definition: nkf.c:1151
keyword_class
#define keyword_class
Definition: ripper.c:190
rb_gc_mark
void rb_gc_mark(VALUE ptr)
Definition: gc.c:4464
ruby__end__seen
#define ruby__end__seen
Definition: ripper.c:601
keyword_next
#define keyword_next
Definition: ripper.c:209
T_ARRAY
#define T_ARRAY
Definition: ruby.h:498
NEW_DOT3
#define NEW_DOT3(b, e)
Definition: node.h:441
ruby_debug_lines
#define ruby_debug_lines
Definition: ripper.c:614
parser_params::heredoc_line_indent
int heredoc_line_indent
Definition: ripper.c:500
st_lookup
#define st_lookup
Definition: regint.h:185
parser_is_identchar
#define parser_is_identchar()
Definition: ripper.c:11088
rb_enc_islower
#define rb_enc_islower(c, enc)
Definition: encoding.h:226
rb_io_write
VALUE rb_io_write(VALUE, VALUE)
Definition: io.c:1510
local_pop
#define local_pop()
Definition: ripper.c:958
tLPAREN_ARG
#define tLPAREN_ARG
Definition: ripper.c:280
tMATCH
#define tMATCH
Definition: ripper.c:266
re_pattern_buffer
Definition: onigmo.h:751
NEW_ITER
#define NEW_ITER(a, b)
Definition: node.h:368
idUMinus
Definition: id.h:80
RE_OPTION_ENCODING
#define RE_OPTION_ENCODING(e)
Definition: ripper.c:993
RCOMPLEX
#define RCOMPLEX(obj)
Definition: internal.h:647
rb_args_info::pre_init
NODE * pre_init
Definition: node.h:483
new_yield
#define new_yield(node, column)
Definition: ripper.c:725
NEW_IVAR
#define NEW_IVAR(v)
Definition: node.h:401
parser_params::tokidx
int tokidx
Definition: ripper.c:495
RCOMPLEX_SET_IMAG
#define RCOMPLEX_SET_IMAG(cmp, i)
Definition: ruby.h:1069
last
unsigned int last
Definition: nkf.c:4311
rb_args_info::block_arg
ID block_arg
Definition: node.h:492
rb_ensure
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
An equivalent to ensure clause.
Definition: eval.c:1035
rb_gc_force_recycle
void rb_gc_force_recycle(VALUE obj)
Definition: gc.c:6175
MEMO_NEW
#define MEMO_NEW(a, b, c)
Definition: internal.h:963
YYLTYPE
Definition: parse.h:302
NEW_IASGN
#define NEW_IASGN(v, val)
Definition: node.h:389
FIXNUM_P
#define FIXNUM_P(f)
Definition: ruby.h:365
tLAMBEG
#define tLAMBEG
Definition: ripper.c:301
lex_gets_ptr
#define lex_gets_ptr
Definition: ripper.c:598
rb_utf8_encoding
rb_encoding * rb_utf8_encoding(void)
Definition: encoding.c:1320
here_document
#define here_document(n)
Definition: ripper.c:10992
nd_type
#define nd_type(n)
Definition: node.h:272
parser_params::ptok
const char * ptok
Definition: ripper.c:486
parser_params::error_buffer
VALUE error_buffer
Definition: ripper.c:539
rb_str_buf_append
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2884
tSTRING_CONTENT
#define tSTRING_CONTENT
Definition: ripper.c:250
vtable::pos
int pos
Definition: ripper.c:434
new_str
#define new_str(s, column)
Definition: ripper.c:778
PRIsWARN
#define PRIsWARN
Definition: ripper.c:1171
tBACK_REF
#define tBACK_REF
Definition: ripper.c:253
YYLAST
#define YYLAST
Definition: ripper.c:1469
YYID
#define YYID(n)
Definition: ripper.c:1322
parser_params::paren_nest
int paren_nest
Definition: ripper.c:489
st_init_numtable_with_size
#define st_init_numtable_with_size
Definition: regint.h:179
rb_parser_set_yydebug
VALUE rb_parser_set_yydebug(VALUE self, VALUE flag)
Definition: ripper.c:17457
ENC_CODERANGE_7BIT
#define ENC_CODERANGE_7BIT
Definition: encoding.h:100
rb_obj_classname
const char * rb_obj_classname(VALUE)
Definition: variable.c:459
NEW_SCOPE
#define NEW_SCOPE(a, b)
Definition: node.h:358
new_postarg
#define new_postarg(i, v, column)
Definition: ripper.c:820
new_cdecl
#define new_cdecl(v, val, path, column)
Definition: ripper.c:823
ruby_sourcefile
#define ruby_sourcefile
Definition: ripper.c:603
term
const char term
Definition: id.c:37
memmove
RUBY_EXTERN void * memmove(void *, const void *, size_t)
Definition: memmove.c:7
rb_parser_reg_compile
RUBY_SYMBOL_EXPORT_BEGIN VALUE rb_parser_reg_compile(struct parser_params *parser, VALUE str, int options)
Definition: ripper.c:17112
NODE_IF
Definition: node.h:27
IS_lex_state_all
#define IS_lex_state_all(ls)
Definition: ripper.c:403
keyword_begin
#define keyword_begin
Definition: ripper.c:194
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:84
rb_eArgError
VALUE rb_eArgError
Definition: error.c:802
sym
#define sym(x)
Definition: date_core.c:3721
unterminated_literal
#define unterminated_literal(mesg)
parser_params::cond_stack
stack_type cond_stack
Definition: ripper.c:493
rb_str_buf_cat
VALUE rb_str_buf_cat(VALUE, const char *, long)
st_data_t
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
Definition: st.h:22
WARN_ID
#define WARN_ID(i)
Definition: ripper.c:1170
__sFILE
Definition: vsnprintf.c:169
parser_params::error_p
unsigned int error_p
Definition: ripper.c:531
STR_NEW0
#define STR_NEW0()
Definition: ripper.c:563
RNode
Definition: node.h:233
YYSTYPE
Definition: parse.h:284
NUM_SUFFIX_I
#define NUM_SUFFIX_I
Definition: ripper.c:12682
NEWHEAP
#define NEWHEAP()
Definition: ripper.c:17469
SPECIAL_PUNCT
#define SPECIAL_PUNCT(idx)
Definition: ripper.c:12328
parser_params::gets_ptr
long gets_ptr
Definition: ripper.c:487
negate_lit
#define negate_lit(lit)
Definition: ripper.c:720
STR_FUNC_LABEL
#define STR_FUNC_LABEL
Definition: ripper.c:11606
ISALPHA
#define ISALPHA(c)
Definition: ruby.h:2149
yyalloc::yyss
yytype_int16 yyss
Definition: ripper.c:1416
modifier_rescue
#define modifier_rescue
Definition: ripper.c:231
STR_FUNC_REGEXP
#define STR_FUNC_REGEXP
Definition: ripper.c:11602
parser_params::tokenbuf
char * tokenbuf
Definition: ripper.c:501
new_if
#define new_if(cc, left, right, column)
Definition: ripper.c:657
NEW_VCALL
#define NEW_VCALL(m)
Definition: node.h:419
parser_params::ruby__end__seen
unsigned int ruby__end__seen
Definition: ripper.c:518
parser_params::ruby_sourcefile_string
VALUE ruby_sourcefile_string
Definition: ripper.c:506
strtod
#define strtod(s, e)
Definition: util.h:77
ID_STATIC_SYM
#define ID_STATIC_SYM
Definition: id.h:30
vtable::prev
struct vtable * prev
Definition: ripper.c:436
rb_imemo_alloc_struct
Definition: internal.h:933
arg_concat
#define arg_concat(h, t, column)
Definition: ripper.c:690
NEW_VALIAS
#define NEW_VALIAS(n, o)
Definition: node.h:433
rb_parser_lex_state_names
const char rb_parser_lex_state_names[][13]
Definition: ripper.c:15514
rb_obj_class
VALUE rb_obj_class(VALUE)
call-seq: obj.class -> class
Definition: object.c:277
RB_TYPE_P
#define RB_TYPE_P(obj, type)
Definition: ruby.h:527
parser_params::pcur
const char * pcur
Definition: ripper.c:484
rb_args_info
Definition: node.h:482
new_list
#define new_list(item, column)
Definition: ripper.c:775
NEW_LVAR
#define NEW_LVAR(v)
Definition: node.h:399
yyerror
#define yyerror(yylloc, parser, msg)
Definition: ripper.c:570
idANDOP
Definition: id.h:104
assignable_result
#define assignable_result(x)
CMDARG_PUSH
#define CMDARG_PUSH(n)
Definition: ripper.c:426
NEW_ATTRASGN
#define NEW_ATTRASGN(r, m, a)
Definition: node.h:451
keyword_not
#define keyword_not
Definition: ripper.c:226
RE_OPTION_MASK
#define RE_OPTION_MASK
Definition: ripper.c:996
rb_parser_printf
void rb_parser_printf(struct parser_params *parser, const char *fmt,...)
Definition: ripper.c:17531
new_defined
#define new_defined(expr, column)
Definition: ripper.c:766
ID_SCOPE_MASK
#define ID_SCOPE_MASK
Definition: id.h:32
parser_params::enc
rb_encoding * enc
Definition: ripper.c:507
parser_warning
#define parser_warning(node, mesg)
Definition: ripper.c:14767
UNLIKELY
#define UNLIKELY(x)
Definition: internal.h:43
tCMP
#define tCMP
Definition: ripper.c:258
whole_match_p
#define whole_match_p(e, l, i)
Definition: ripper.c:10995
NEW_POSTEXE
#define NEW_POSTEXE(b)
Definition: node.h:449
heredoc_line_indent
#define heredoc_line_indent
Definition: ripper.c:596
vtable::capa
int capa
Definition: ripper.c:435
const_path_field
#define const_path_field(w, n, column)
Definition: ripper.c:752
lex_nextline
#define lex_nextline
Definition: ripper.c:590
YYTERROR
#define YYTERROR
Definition: ripper.c:4886
Qnull
#define Qnull
Definition: ripper.c:1114
tLBRACK
#define tLBRACK
Definition: ripper.c:282
tGEQ
#define tGEQ
Definition: ripper.c:262
tANDDOT
#define tANDDOT
Definition: ripper.c:274
tRSHFT
#define tRSHFT
Definition: ripper.c:273
set_yylval_literal
#define set_yylval_literal(x)
Definition: ripper.c:11005
YYLLOC_DEFAULT
#define YYLLOC_DEFAULT(Current, Rhs, N)
Definition: ripper.c:4896
input
unsigned int input
Definition: nkf.c:4312
scan_hex
#define scan_hex(s, l, e)
Definition: util.h:55
parser_params::in_main
unsigned int in_main
Definition: ripper.c:522
rb_intern_str
#define rb_intern_str(string)
Definition: generator.h:16
tNMATCH
#define tNMATCH
Definition: ripper.c:267
NEW_IF
#define NEW_IF(c, t, e)
Definition: node.h:360
rb_rational_raw1
#define rb_rational_raw1(x)
Definition: intern.h:163
tDOT2
#define tDOT2
Definition: ripper.c:268
tSTAR
#define tSTAR
Definition: ripper.c:285
ALLOC_N
#define ALLOC_N(type, n)
Definition: ruby.h:1587
rb_hash_aset
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
Definition: hash.c:1616
TAB_WIDTH
#define TAB_WIDTH
Definition: ripper.c:341
keyword_def
#define keyword_def
Definition: ripper.c:192
tCHAR
#define tCHAR
Definition: ripper.c:251
IS_ARG
#define IS_ARG()
Definition: ripper.c:12380
PARSER_ARG
#define PARSER_ARG
Definition: ripper.c:1180
heredoc_dedent
#define heredoc_dedent(str)
Definition: ripper.c:858
val
#define val
NEW_ARRAY
#define NEW_ARRAY(a)
Definition: node.h:381
rb_cObject
RUBY_EXTERN VALUE rb_cObject
Definition: ruby.h:1893
compile_error
#define compile_error
Definition: ripper.c:1179
ID_INSTANCE
#define ID_INSTANCE
Definition: id.h:34
yylval
#define yylval
Definition: ripper.c:10971
tFLOAT
#define tFLOAT
Definition: ripper.c:247
rb_parser_encoding
VALUE rb_parser_encoding(VALUE vparser)
Definition: ripper.c:17427
ifndef_ripper
#define ifndef_ripper(x)
Definition: ripper.c:1115
rb_str_free
void rb_str_free(VALUE)
Definition: string.c:1316
reg_named_capture_assign_t::parser
struct parser_params * parser
Definition: ripper.c:17057
RSTRING_END
#define RSTRING_END(str)
Definition: ruby.h:979
parser_params::state
enum lex_state_e state
Definition: ripper.c:488
tCVAR
#define tCVAR
Definition: ripper.c:244
NEW_HASH
#define NEW_HASH(a)
Definition: node.h:383
rb_get_coverages
VALUE rb_get_coverages(void)
Definition: thread.c:5044
keyword_rescue
#define keyword_rescue
Definition: ripper.c:195
NEW_ZARRAY
#define NEW_ZARRAY()
Definition: node.h:382
rb_compile_string
NODE * rb_compile_string(const char *f, VALUE s, int line)
Definition: ripper.c:11527
keyword_end
#define keyword_end
Definition: ripper.c:197
new_undef
#define new_undef(i, column)
Definition: ripper.c:811
NEW_FALSE
#define NEW_FALSE()
Definition: node.h:445
parser_params::base_block
const struct rb_block * base_block
Definition: ripper.c:542
keyword_super
#define keyword_super
Definition: ripper.c:219
rb_obj_as_string
VALUE rb_obj_as_string(VALUE)
Definition: string.c:1410
rb_set_errinfo
void rb_set_errinfo(VALUE err)
Sets the current exception ($!) to the given value.
Definition: eval.c:1792
rb_ary_new
VALUE rb_ary_new(void)
Definition: array.c:499
rb_magic_comment_length_t
long(* rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len)
Definition: ripper.c:13026
rb_ascii8bit_encindex
int rb_ascii8bit_encindex(void)
Definition: encoding.c:1314
NEW_ARGSPUSH
#define NEW_ARGSPUSH(a, b)
Definition: node.h:427
keyword_if
#define keyword_if
Definition: ripper.c:198
set_yylval_name
#define set_yylval_name(x)
Definition: ripper.c:11004
reg_named_capture_assign
#define reg_named_capture_assign(regexp, column)
Definition: ripper.c:855
NEW_REDO
#define NEW_REDO()
Definition: node.h:372
NEW_NTH_REF
#define NEW_NTH_REF(n)
Definition: node.h:404
new_command_qcall
#define new_command_qcall(q, r, m, a, column)
Definition: ripper.c:706
tokline
#define tokline
Definition: ripper.c:587
NEW_UNLESS
#define NEW_UNLESS(c, t, e)
Definition: node.h:361
rb_mKernel
RUBY_EXTERN VALUE rb_mKernel
Definition: ruby.h:1881
rb_warning1
#define rb_warning1(fmt, a)
Definition: ripper.c:1128
snprintf
#define snprintf
Definition: subst.h:6
rb_thread_current
VALUE rb_thread_current(void)
Definition: thread.c:2494
block_dup_check
#define block_dup_check(n1, n2)
Definition: ripper.c:680
RRATIONAL
#define RRATIONAL(obj)
Definition: internal.h:630
tokadd
#define tokadd(c)
Definition: ripper.c:10984
aryset
#define aryset(node1, node2, column)
Definition: ripper.c:735
parser_params::heap
rb_imemo_alloc_t * heap
Definition: ripper.c:473
parser_params::eval_tree
NODE * eval_tree
Definition: ripper.c:538
tLEQ
#define tLEQ
Definition: ripper.c:263
idGTGT
Definition: id.h:89
NIL_P
#define NIL_P(v)
Definition: ruby.h:451
ISASCII
#define ISASCII(c)
Definition: ruby.h:2142
tokenbuf
#define tokenbuf
Definition: ripper.c:584
rb_define_class
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition: class.c:646
COND_POP
#define COND_POP()
Definition: ripper.c:421
NEW_GVAR
#define NEW_GVAR(v)
Definition: node.h:398
heredoc_identifier
#define heredoc_identifier()
Definition: ripper.c:10993
rb_imemo_alloc_struct::next
struct rb_imemo_alloc_struct * next
Definition: internal.h:937
rb_args_info::opt_args
NODE * opt_args
Definition: node.h:497
gettable
#define gettable(id, column)
Definition: ripper.c:730
NEW_YIELD
#define NEW_YIELD(a)
Definition: node.h:379
new_evstr
#define new_evstr(n, column)
Definition: ripper.c:695
method_add_block
#define method_add_block(m, b)
Definition: ripper.c:710
TOK_INTERN
#define TOK_INTERN()
Definition: ripper.c:566
rb_define_const
void rb_define_const(VALUE, const char *, VALUE)
Definition: variable.c:2691
RNode::value
VALUE value
Definition: node.h:239
parser_params::lpar_beg
int lpar_beg
Definition: ripper.c:490
tSYMBEG
#define tSYMBEG
Definition: ripper.c:289
rb_compile_warn
void rb_compile_warn(const char *file, int line, const char *fmt,...)
Definition: error.c:200
ID_SCOPE_SHIFT
#define ID_SCOPE_SHIFT
Definition: id.h:31
k__END__
#define k__END__
Definition: eventids2.c:9
ISALNUM
#define ISALNUM(c)
Definition: ruby.h:2148
new_attr_op_assign
#define new_attr_op_assign(lhs, type, attr, op, rhs, column)
Definition: ripper.c:747
YYDPRINTF
#define YYDPRINTF(Args)
Definition: ripper.c:4948
NEW_CASE
#define NEW_CASE(h, b)
Definition: node.h:362
cnt
rb_atomic_t cnt[RUBY_NSIG]
Definition: signal.c:525
lex_goto_eol
#define lex_goto_eol(parser)
Definition: ripper.c:11638
keyword_defined
#define keyword_defined
Definition: ripper.c:233
magic_comment
Definition: ripper.c:13092
FLONUM_P
#define FLONUM_P(x)
Definition: ruby.h:399
parser_params::tokline
int tokline
Definition: ripper.c:497
local_id
#define local_id(id)
Definition: ripper.c:965
parser_params::has_shebang
unsigned int has_shebang
Definition: ripper.c:520
T_FLOAT
#define T_FLOAT
Definition: ruby.h:495
rb_parser_append_print
NODE * rb_parser_append_print(VALUE vparser, NODE *node)
Definition: ripper.c:17152
TYPE
#define TYPE(x)
Definition: ruby.h:521
argc
int argc
Definition: ruby.c:187
match_op
#define match_op(node1, node2, column)
Definition: ripper.c:843
NODE_AND
Definition: node.h:61
tSTRING_DBEG
#define tSTRING_DBEG
Definition: ripper.c:297
OnigUChar
unsigned char OnigUChar
Definition: onigmo.h:79
top_const_field
#define top_const_field(n)
Definition: ripper.c:753
idANDDOT
Definition: id.h:106
YYFINAL
#define YYFINAL
Definition: ripper.c:1467
rb_eSyntaxError
VALUE rb_eSyntaxError
Definition: error.c:816
Qfalse
#define Qfalse
Definition: ruby.h:436
dvar_curr
#define dvar_curr(id)
Definition: ripper.c:980
NEW_EVSTR
#define NEW_EVSTR(n)
Definition: node.h:415
keyword_undef
#define keyword_undef
Definition: ripper.c:193
rb_rational_new
VALUE rb_rational_new(VALUE, VALUE)
Definition: rational.c:1973
parser_params::nextline
VALUE nextline
Definition: ripper.c:482
dvar_defined_ref
#define dvar_defined_ref(id, vidp)
Definition: ripper.c:977
ALLOCA_N
#define ALLOCA_N(type, n)
Definition: ruby.h:1593
flush_string_content
#define flush_string_content(enc)
Definition: ripper.c:12320
NEW_OP_CDECL
#define NEW_OP_CDECL(v, op, val)
Definition: node.h:397
rb_parser_set_context
VALUE rb_parser_set_context(VALUE vparser, const struct rb_block *base, int main)
Definition: ripper.c:17367
WARN_I
#define WARN_I(i)
Definition: ripper.c:1169
T_BIGNUM
#define T_BIGNUM
Definition: ruby.h:501
ENC_CODERANGE_UNKNOWN
#define ENC_CODERANGE_UNKNOWN
Definition: encoding.h:99
tokadd_string
#define tokadd_string(f, t, p, n, e)
Definition: ripper.c:10989
RUBY_FUNC_EXPORTED
#define RUBY_FUNC_EXPORTED
Definition: defines.h:263
MEMCPY
#define MEMCPY(p1, p2, type, n)
Definition: ruby.h:1661
T_NODE
#define T_NODE
Definition: ruby.h:513
rb_enc_associate_index
VALUE rb_enc_associate_index(VALUE obj, int idx)
Definition: encoding.c:826
RNODE
#define RNODE(obj)
Definition: node.h:260
err
int err
Definition: win32.c:135
dyna_pop
#define dyna_pop(node)
Definition: ripper.c:972
parser_params::in_def
unsigned int in_def
Definition: ripper.c:525
tCONSTANT
#define tCONSTANT
Definition: ripper.c:243
tXSTRING_BEG
#define tXSTRING_BEG
Definition: ripper.c:291
YYACCEPT
#define YYACCEPT
Definition: ripper.c:4855
tSTRING_DEND
#define tSTRING_DEND
Definition: ripper.c:298
T_COMPLEX
#define T_COMPLEX
Definition: ruby.h:510
YYEOF
#define YYEOF
Definition: ripper.c:4853
nd_else
#define nd_else
Definition: node.h:290
set_integer_literal
#define set_integer_literal(v, f)
Definition: ripper.c:10998
NUM_SUFFIX_ALL
#define NUM_SUFFIX_ALL
Definition: ripper.c:12683
new_nil
#define new_nil()
Definition: ripper.c:655
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: ripper.c:5094
block_append
#define block_append(h, t, column)
Definition: ripper.c:683
parser_params::lastline
VALUE lastline
Definition: ripper.c:481
tLOWEST
#define tLOWEST
Definition: ripper.c:303
U
Definition: util.c:841
rb_compile_cstr
NODE * rb_compile_cstr(const char *f, const char *s, int len, int line)
Definition: ripper.c:11547
rb_int_positive_pow
RUBY_EXTERN VALUE rb_int_positive_pow(long x, unsigned long y)
Definition: numeric.c:3942
token_info::column
int column
Definition: ripper.c:458
numberof
#define numberof(array)
Definition: etc.c:618
IS_lex_state
#define IS_lex_state(ls)
Definition: ripper.c:402
tREGEXP_BEG
#define tREGEXP_BEG
Definition: ripper.c:292
rb_make_backtrace
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:813
ALLOC
#define ALLOC(type)
Definition: ruby.h:1588
END
#define END(no)
Definition: re.c:25
NEW_FOR
#define NEW_FOR(v, i, b)
Definition: node.h:367
EOF
#define EOF
Definition: vsnprintf.c:203
idCmp
Definition: id.h:82
keyword_self
#define keyword_self
Definition: ripper.c:220
rb_parser_malloc
void * rb_parser_malloc(struct parser_params *parser, size_t size)
Definition: ripper.c:17474
NEW_WHEN
#define NEW_WHEN(c, t, e)
Definition: node.h:363
peek_n
#define peek_n(c, n)
Definition: ripper.c:11641
rb_str_resize
VALUE rb_str_resize(VALUE, long)
Definition: string.c:2644
DEF_EXPR
#define DEF_EXPR(n)
Definition: ripper.c:381
tHEREDOC_END
#define tHEREDOC_END
Definition: eventids2.c:8
STR_NEW
#define STR_NEW(p, n)
Definition: ripper.c:562
NEW_DASGN
#define NEW_DASGN(v, val)
Definition: node.h:387
parser_params::pbeg
const char * pbeg
Definition: ripper.c:483
rb_magic_comment_setter_t
void(* rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val)
Definition: ripper.c:13027
tokcopy
#define tokcopy(n)
Definition: ripper.c:11791
STR_FUNC_SYMBOL
#define STR_FUNC_SYMBOL
Definition: ripper.c:11604
mixed_escape
#define mixed_escape(beg, enc1, enc2)
set_yylval_num
#define set_yylval_num(x)
Definition: ripper.c:11002
NEW_ERRINFO
#define NEW_ERRINFO()
Definition: node.h:446
NEW_BLOCK_PASS
#define NEW_BLOCK_PASS(b)
Definition: node.h:431
STR_FUNC_QWORDS
#define STR_FUNC_QWORDS
Definition: ripper.c:11603
rb_str_subseq
VALUE rb_str_subseq(VALUE, long, long)
Definition: string.c:2406
new_const_op_assign
#define new_const_op_assign(lhs, op, rhs, column)
Definition: ripper.c:749
dyna_push
#define dyna_push()
Definition: ripper.c:970
command_start
#define command_start
Definition: ripper.c:597
ZALLOC
#define ZALLOC(type)
Definition: ruby.h:1590
string_type
string_type
Definition: ripper.c:11609
RSTRING_LEN
#define RSTRING_LEN(str)
Definition: ruby.h:971
tCOLON3
#define tCOLON3
Definition: ripper.c:276
lex_state_bits
lex_state_bits
Definition: ripper.c:363
rb_funcallv_public
VALUE rb_funcallv_public(VALUE, ID, int, const VALUE *)
Calls a method.
Definition: vm_eval.c:820
tWORDS_BEG
#define tWORDS_BEG
Definition: ripper.c:293
parser_params::cr_seen
unsigned int cr_seen
Definition: ripper.c:532
set_number_literal
#define set_number_literal(v, t, f)
Definition: ripper.c:10997
rb_args_info::rest_arg
ID rest_arg
Definition: node.h:491
REALLOC_N
#define REALLOC_N(var, type, n)
Definition: ruby.h:1591
local_push
#define local_push(top)
Definition: ripper.c:956
errno
int errno
TRUE
#define TRUE
Definition: nkf.h:175
nd_next
#define nd_next
Definition: node.h:286
NEW_CONST
#define NEW_CONST(v)
Definition: node.h:402
modifier_until
#define modifier_until
Definition: ripper.c:230
NEW_LIT
#define NEW_LIT(l)
Definition: node.h:409
rb_io_gets
VALUE rb_io_gets(VALUE)
Definition: io.c:3281
rb_dvar_defined
int rb_dvar_defined(ID id, const struct rb_block *base_block)
Definition: compile.c:7492
paren_nest
#define paren_nest
Definition: ripper.c:577
has_delayed_token
#define has_delayed_token()
Definition: ripper.c:11027
new_unless
#define new_unless(cc, left, right, column)
Definition: ripper.c:659
token_info_pop
#define token_info_pop(token)
Definition: ripper.c:1195
rb_sprintf
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1452
new_dstr
#define new_dstr(s, column)
Definition: ripper.c:805
IS_lex_state_for
#define IS_lex_state_for(x, ls)
Definition: ripper.c:400
tokadd_mbchar
#define tokadd_mbchar(c)
Definition: ripper.c:12112
NEW_OP_ASGN_OR
#define NEW_OP_ASGN_OR(i, val)
Definition: node.h:395
rb_enc_isspace
#define rb_enc_isspace(c, enc)
Definition: encoding.h:231
rb_node_newnode
#define rb_node_newnode(type, a1, a2, a3)
Definition: ripper.c:650
YYMAXDEPTH
#define YYMAXDEPTH
Definition: ripper.c:5126
rb_enc_precise_mbclen
int rb_enc_precise_mbclen(const char *p, const char *e, rb_encoding *enc)
Definition: encoding.c:1020
new_scope
#define new_scope(a, b, column)
Definition: ripper.c:826
NEW_NEXT
#define NEW_NEXT(s)
Definition: node.h:371
rb_enc_name
#define rb_enc_name(enc)
Definition: encoding.h:171
var_field
#define var_field(n)
Definition: ripper.c:757
tOP_ASGN
#define tOP_ASGN
Definition: ripper.c:277
YYLTYPE::last_column
int last_column
Definition: parse.h:307
RE_OPTION_ONCE
#define RE_OPTION_ONCE
Definition: ripper.c:991
tokidx
#define tokidx
Definition: ripper.c:585
MEMMOVE
#define MEMMOVE(p1, p2, type, n)
Definition: ruby.h:1662
malloc
#define malloc
Definition: ripper.c:358
rb_str_vcatf
VALUE rb_str_vcatf(VALUE, const char *, va_list)
Definition: sprintf.c:1465
RUBY_SYMBOL_EXPORT_END
#define RUBY_SYMBOL_EXPORT_END
Definition: missing.h:49
nd_term
#define nd_term(node)
Definition: ripper.c:1006
arg_ambiguous
#define arg_ambiguous(c)
Definition: ripper.c:12920
rb_compile_warning
void rb_compile_warning(const char *file, int line, const char *fmt,...)
Definition: error.c:215
STR_FUNC_EXPAND
#define STR_FUNC_EXPAND
Definition: ripper.c:11601
NEW_RESCUE
#define NEW_RESCUE(b, res, e)
Definition: node.h:375
new_lit
#define new_lit(sym, column)
Definition: ripper.c:772
keyword_false
#define keyword_false
Definition: ripper.c:223
magic_comment::length
rb_magic_comment_length_t length
Definition: ripper.c:13095
rb_init_parse
void rb_init_parse(void)
Definition: ripper.c:17226
rb_scan_args
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Definition: class.c:1908
warn_balanced
#define warn_balanced(tok, op, syn)
Definition: ripper.c:13322
keyword_or
#define keyword_or
Definition: ripper.c:225
new_for
#define new_for(var, iter, body, column)
Definition: ripper.c:796
YYSIZE_T
#define YYSIZE_T
Definition: ripper.c:1295
ESCAPE_META
#define ESCAPE_META
Definition: ripper.c:11886
buf
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4309
rb_warn3L
#define rb_warn3L(l, fmt, a, b, c)
Definition: ripper.c:1135
key
key
Definition: openssl_missing.h:181
yytype_int16
short int yytype_int16
Definition: ripper.c:1282
rb_assoc_new
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Definition: array.c:639
PRIsVALUE
#define PRIsVALUE
Definition: ruby.h:135
rb_warn1L
#define rb_warn1L(l, fmt, a)
Definition: ripper.c:1133
method_cond
#define method_cond(node, column)
Definition: ripper.c:654
no_digits
#define no_digits()
ID
unsigned long ID
Definition: ruby.h:86
rb_usascii_encoding
rb_encoding * rb_usascii_encoding(void)
Definition: encoding.c:1335
rb_enc_isalnum
#define rb_enc_isalnum(c, enc)
Definition: encoding.h:229
yytype_uint8
unsigned char yytype_uint8
Definition: ripper.c:1261
nd_resq
#define nd_resq
Definition: node.h:294
NEW_PRELUDE
#define NEW_PRELUDE(p, b, o)
Definition: node.h:452
keyword_until
#define keyword_until
Definition: ripper.c:206
tokp
#define tokp
Definition: ripper.c:617
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:788
Qnil
#define Qnil
Definition: ruby.h:438
heredoc_restore
#define heredoc_restore(n)
Definition: ripper.c:10994
NEW_BACK_REF
#define NEW_BACK_REF(n)
Definition: node.h:405
rb_block
Definition: vm_core.h:653
rb_exc_raise
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
Definition: eval.c:615
lex_lastline
#define lex_lastline
Definition: ripper.c:589
kwtable::id
int id[2]
Definition: lex.c:33
NODE_FL_NEWLINE
#define NODE_FL_NEWLINE
Definition: node.h:267
NEW_MASGN
#define NEW_MASGN(l, r)
Definition: node.h:384
arg_append
#define arg_append(h, t, column)
Definition: ripper.c:688
KWD2EID
#define KWD2EID(t, v)
Definition: ripper.c:1109
BUILTIN_TYPE
#define BUILTIN_TYPE(x)
Definition: ruby.h:518
tANDOP
#define tANDOP
Definition: ripper.c:264
tPOW
#define tPOW
Definition: ripper.c:257
YYLTYPE::last_line
int last_line
Definition: parse.h:306
tLABEL_END
#define tLABEL_END
Definition: ripper.c:302
NEW_COLON2
#define NEW_COLON2(c, i)
Definition: node.h:438
VALUE
unsigned long VALUE
Definition: ruby.h:85
vtable_pop
#define vtable_pop(tbl, n)
Definition: ripper.c:11323
RFLOAT
#define RFLOAT(obj)
Definition: internal.h:639
new_do_body
#define new_do_body(param, stmt, column)
Definition: ripper.c:840
vtable_alloc
#define vtable_alloc(prev)
Definition: ripper.c:11266
rb_args_info::post_init
NODE * post_init
Definition: node.h:484
yyalloc::yyls
YYLTYPE yyls
Definition: ripper.c:1418
modifier_while
#define modifier_while
Definition: ripper.c:229
RBASIC
#define RBASIC(obj)
Definition: ruby.h:1197
ruby_sourceline
#define ruby_sourceline
Definition: ripper.c:602
rb_eTypeError
VALUE rb_eTypeError
Definition: error.c:801
NEW_KW_ARG
#define NEW_KW_ARG(i, v)
Definition: node.h:424
idGE
Definition: id.h:93
RUBY_SYMBOL_EXPORT_BEGIN
#define RUBY_SYMBOL_EXPORT_BEGIN
Definition: missing.h:48
COVERAGE_INDEX_LINES
#define COVERAGE_INDEX_LINES
Definition: internal.h:1694
logop
#define logop(id, node1, node2, column)
Definition: ripper.c:661
rb_io_puts
VALUE rb_io_puts(int, const VALUE *, VALUE)
Definition: io.c:7399
rb_args_info::post_args_num
int post_args_num
Definition: node.h:487
lex_pend
#define lex_pend
Definition: ripper.c:593
NEW_ENSURE
#define NEW_ENSURE(b, en)
Definition: node.h:377
rb_ary_new3
#define rb_ary_new3
Definition: intern.h:91
YYUSE
#define YYUSE(e)
Definition: ripper.c:1315
RUBY_DTRACE_PARSE_HOOK
#define RUBY_DTRACE_PARSE_HOOK(name)
tQSYMBOLS_BEG
#define tQSYMBOLS_BEG
Definition: ripper.c:296
lvtbl
#define lvtbl
Definition: ripper.c:600
lex_strterm
#define lex_strterm
Definition: ripper.c:573
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:111
NEW_ZSUPER
#define NEW_ZSUPER()
Definition: node.h:421
rb_id2name
const char * rb_id2name(ID)
Definition: symbol.c:751
rb_enc_asciicompat
#define rb_enc_asciicompat(enc)
Definition: encoding.h:239
free
#define free
Definition: ripper.c:361
rb_str_new_cstr
VALUE rb_str_new_cstr(const char *)
Definition: string.c:771
rb_reg_fragment_setenc
int rb_reg_fragment_setenc(struct parser_params *, VALUE, int)
Definition: ripper.c:16999
WARN_S_L
#define WARN_S_L(s, l)
Definition: ripper.c:1167
set_yylval_str
#define set_yylval_str(x)
Definition: ripper.c:11001
rb_char_to_option_kcode
int rb_char_to_option_kcode(int c, int *option, int *kcode)
Definition: re.c:324
METHOD_NOT
#define METHOD_NOT
Definition: ripper.c:988
NEW_COLON3
#define NEW_COLON3(i)
Definition: node.h:439
const_decl
#define const_decl(path, column)
Definition: ripper.c:755
NEW_BLOCK
#define NEW_BLOCK(a)
Definition: node.h:359
rb_parser_show_bitstack
void rb_parser_show_bitstack(struct parser_params *, stack_type, const char *, int)
Definition: ripper.c:15590
rb_obj_hide
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
Definition: object.c:72
cond_stack
#define cond_stack
Definition: ripper.c:575
yytype_int8
short int yytype_int8
Definition: ripper.c:1270
new_op_assign
#define new_op_assign(lhs, op, rhs, column)
Definition: ripper.c:745
nd_body
#define nd_body
Definition: node.h:289
tOROP
#define tOROP
Definition: ripper.c:265
RNode::flags
VALUE flags
Definition: node.h:234
parser_params::pend
const char * pend
Definition: ripper.c:485
rb_fstring
VALUE rb_fstring(VALUE)
Definition: string.c:306
tIVAR
#define tIVAR
Definition: ripper.c:242
token_info::token
const char * token
Definition: ripper.c:456
ENCODING_IS_ASCII8BIT
#define ENCODING_IS_ASCII8BIT(obj)
Definition: encoding.h:59
rb_str_dup
VALUE rb_str_dup(VALUE)
Definition: string.c:1488
parser_params::token_info_enabled
unsigned int token_info_enabled
Definition: ripper.c:527
CHAR_BIT
#define CHAR_BIT
Definition: ruby.h:196
vtable_add
#define vtable_add(tbl, id)
Definition: ripper.c:11306
attrset
#define attrset(node, q, id, column)
Definition: ripper.c:737
rb_sym_intern_ascii_cstr
VALUE rb_sym_intern_ascii_cstr(const char *ptr)
Definition: symbol.c:1042
node_assign
#define node_assign(node1, node2, column)
Definition: ripper.c:742
LONG2NUM
#define LONG2NUM(x)
Definition: ruby.h:1573
parser_params::ruby_sourcefile
char * ruby_sourcefile
Definition: ripper.c:505
brace_nest
#define brace_nest
Definition: ripper.c:579
rb_respond_to
int rb_respond_to(VALUE, ID)
Definition: vm_method.c:1994
reg_named_capture_assign_t::enc
rb_encoding * enc
Definition: ripper.c:17058
len
register unsigned int len
Definition: zonetab.h:51
StringValueCStr
#define StringValueCStr(v)
Definition: ruby.h:571
NEW_BEGIN
#define NEW_BEGIN(b)
Definition: node.h:374
tFID
#define tFID
Definition: ripper.c:240
HEAPCNT
#define HEAPCNT(n, size)
Definition: ripper.c:17468
keyword_in
#define keyword_in
Definition: ripper.c:212
RSTRING_PTR
#define RSTRING_PTR(str)
Definition: ruby.h:975
top
unsigned int top
Definition: nkf.c:4310
new_dvar
#define new_dvar(id, column)
Definition: ripper.c:781
parser_params::toksiz
int toksiz
Definition: ripper.c:496
ruby_global_name_punct_bits
RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20+31)/32]
Definition: ripper.c:12323
NEW_SPLAT
#define NEW_SPLAT(a)
Definition: node.h:428
rb_str_modify
void rb_str_modify(VALUE)
Definition: string.c:2046
YYSTYPE::vars
const struct vtable * vars
Definition: parse.h:290
rb_const_defined_at
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:2543
ENCODING_GET
#define ENCODING_GET(obj)
Definition: encoding.h:58
ESCAPE_CONTROL
#define ESCAPE_CONTROL
Definition: ripper.c:11885
YYLTYPE
struct YYLTYPE YYLTYPE
tNTH_REF
#define tNTH_REF
Definition: ripper.c:252
rb_enc_get
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:860
parser_params::debug_buffer
VALUE debug_buffer
Definition: ripper.c:511
parser_isascii
#define parser_isascii()
Definition: ripper.c:11090
END_OF_INPUT
#define END_OF_INPUT
Definition: ripper.c:189
call_bin_op
#define call_bin_op(recv, id, arg1, column)
Definition: ripper.c:701
RFLOAT_VALUE
#define RFLOAT_VALUE(v)
Definition: ruby.h:933
token_info::nonspc
int nonspc
Definition: ripper.c:459
size
int size
Definition: encoding.c:57
rb_stderr
RUBY_EXTERN VALUE rb_stderr
Definition: ruby.h:1971
rb_ident_hash_new
VALUE rb_ident_hash_new(void)
Definition: hash.c:2924
NEW_DSTR
#define NEW_DSTR(s)
Definition: node.h:411
ADD2HEAP
#define ADD2HEAP(n, c, p)
Definition: ripper.c:17470
TOKEN2VAL
#define TOKEN2VAL(t)
Definition: ripper.c:1108
new_rescue
#define new_rescue(b, res, e, column)
Definition: ripper.c:808
tokspace
#define tokspace(n)
Definition: ripper.c:10983
f
#define f
in_def
#define in_def
Definition: ripper.c:581
INT2FIX
#define INT2FIX(i)
Definition: ruby.h:232
is_local_id
#define is_local_id(id)
Definition: symbol.h:36
NEW_GASGN
#define NEW_GASGN(v, val)
Definition: node.h:385
tIDENTIFIER
#define tIDENTIFIER
Definition: ripper.c:239
keyword_then
#define keyword_then
Definition: ripper.c:200
NEW_BREAK
#define NEW_BREAK(s)
Definition: node.h:370
yytokentype
yytokentype
Definition: ripper.c:68
WARN_S
#define WARN_S(s)
Definition: ripper.c:1168
rb_safe_level
int rb_safe_level(void)
Definition: safe.c:35
rb_parser_free
void rb_parser_free(struct parser_params *parser, void *ptr)
Definition: ripper.c:17514
keyword_break
#define keyword_break
Definition: ripper.c:208
RARRAY_AREF
#define RARRAY_AREF(a, i)
Definition: ruby.h:1033
read_escape
#define read_escape(flags, e)
Definition: ripper.c:10986
tIMAGINARY
#define tIMAGINARY
Definition: ripper.c:249
dispatch_delayed_token
#define dispatch_delayed_token(t)
Definition: ripper.c:11026
new_resbody
#define new_resbody(e, s, r, column)
Definition: ripper.c:784
NODE_NEXT
Definition: node.h:47
tok_hex
#define tok_hex(numlen)
Definition: ripper.c:10985
keyword_do_cond
#define keyword_do_cond
Definition: ripper.c:214
xmalloc
#define xmalloc
Definition: defines.h:183
parser_warn
#define parser_warn(node, mesg)
Definition: ripper.c:14774
parser_params::coverage
VALUE coverage
Definition: ripper.c:541
tLBRACE_ARG
#define tLBRACE_ARG
Definition: ripper.c:284
tokfix
#define tokfix()
Definition: ripper.c:11733
tAREF
#define tAREF
Definition: ripper.c:270
NEW_TRUE
#define NEW_TRUE()
Definition: node.h:444
internal_id
#define internal_id()
Definition: ripper.c:967
yyerror0
#define yyerror0(msg)
Definition: ripper.c:569
magic_comment::name
const char * name
Definition: ripper.c:13093
COND_LEXPOP
#define COND_LEXPOP()
Definition: ripper.c:422
lex_p
#define lex_p
Definition: ripper.c:592
rb_eRuntimeError
VALUE rb_eRuntimeError
Definition: error.c:800
rb_data_type_struct
Definition: ruby.h:1080
tSP
#define tSP
Definition: eventids2.c:6
NEW_LAMBDA
#define NEW_LAMBDA(a, b)
Definition: node.h:369
rb_complex_raw
VALUE rb_complex_raw(VALUE x, VALUE y)
Definition: complex.c:1442
tGVAR
#define tGVAR
Definition: ripper.c:241
CALL_Q_P
#define CALL_Q_P(q)
Definition: ripper.c:621
NODE_NIL
Definition: node.h:207
NEW_UNTIL
#define NEW_UNTIL(c, b, n)
Definition: node.h:366
void_expr
#define void_expr(node)
Definition: ripper.c:674
tDOT3
#define tDOT3
Definition: ripper.c:269
void_expr0
#define void_expr0(node)
Definition: ripper.c:673
lex_pbeg
#define lex_pbeg
Definition: ripper.c:591
regx_options
#define regx_options()
Definition: ripper.c:10988
NEW_MODULE
#define NEW_MODULE(n, b)
Definition: node.h:437
rb_str_catf
VALUE rb_str_catf(VALUE str, const char *format,...)
Definition: sprintf.c:1492
BIGNUM_NEGATE
#define BIGNUM_NEGATE(b)
Definition: internal.h:605
YYSTACK_ALLOC_MAXIMUM
#define YYSTACK_ALLOC_MAXIMUM
Definition: ripper.c:1380
tLABEL
#define tLABEL
Definition: ripper.c:245
NEW_QCALL
#define NEW_QCALL(q, r, m, a)
Definition: ripper.c:623
rb_parser_lex_state_name
VALUE rb_parser_lex_state_name(enum lex_state_e state)
Definition: ripper.c:15571
magic_comment::func
rb_magic_comment_setter_t func
Definition: ripper.c:13094
is_junk_id
#define is_junk_id(id)
Definition: symbol.h:42
parser_params::yydebug
unsigned int yydebug
Definition: ripper.c:519
rb_big_norm
VALUE rb_big_norm(VALUE x)
Definition: bignum.c:3134
nd_head
#define nd_head
Definition: node.h:284
local_vars::prev
struct local_vars * prev
Definition: ripper.c:446
keyword_while
#define keyword_while
Definition: ripper.c:205
LONG2FIX
#define LONG2FIX(i)
Definition: ruby.h:234
parser_encoding_name
#define parser_encoding_name()
Definition: ripper.c:11085
tokadd_escape
#define tokadd_escape(e)
Definition: ripper.c:10987
NEW_WHILE
#define NEW_WHILE(c, b, n)
Definition: node.h:365
local_vars::vars
struct vtable * vars
Definition: ripper.c:441
RTEST
#define RTEST(v)
Definition: ruby.h:450
NODE_STR
Definition: node.h:141
T_STRING
#define T_STRING
Definition: ruby.h:496
parser_params::ruby_sourceline
int ruby_sourceline
Definition: ripper.c:504
lvar_defined
#define lvar_defined(id)
Definition: ripper.c:983
new_qcall
#define new_qcall(q, r, m, a, column)
Definition: ripper.c:705
NEW_POSTARG
#define NEW_POSTARG(i, v)
Definition: node.h:425
rb_class_new_instance
VALUE rb_class_new_instance(int, const VALUE *, VALUE)
Allocates and initializes an instance of klass.
Definition: object.c:2170
rb_parser_fatal
void rb_parser_fatal(struct parser_params *parser, const char *fmt,...)
Definition: ripper.c:15600
NEW_UNDEF
#define NEW_UNDEF(i)
Definition: node.h:434
list
struct rb_encoding_entry * list
Definition: encoding.c:55
lpar_beg
#define lpar_beg
Definition: ripper.c:578
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition: ripper.c:1484
RNode::u1
union RNode::@88 u1
tSTRING_END
#define tSTRING_END
Definition: ripper.c:300
rb_parser_calloc
void * rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
Definition: ripper.c:17484
idCOLON2
Definition: id.h:103
rb_str_cat_cstr
VALUE rb_str_cat_cstr(VALUE, const char *)
Definition: string.c:2756
keyword_BEGIN
#define keyword_BEGIN
Definition: ripper.c:234
idEqq
Definition: id.h:95
T_FILE
#define T_FILE
Definition: ruby.h:502
NEW_CVASGN
#define NEW_CVASGN(v, val)
Definition: node.h:391
idOROP
Definition: id.h:105
ruby_coverage
#define ruby_coverage
Definition: ripper.c:615
NEW_FCALL
#define NEW_FCALL(m, a)
Definition: node.h:418
token_info::linenum
int linenum
Definition: ripper.c:457
parser_params::compile_option
VALUE compile_option
Definition: ripper.c:509
rb_errinfo
VALUE rb_errinfo(void)
The current exception in the current thread.
Definition: eval.c:1777
keyword_for
#define keyword_for
Definition: ripper.c:207
TypedData_Make_Struct
#define TypedData_Make_Struct(klass, type, data_type, sval)
Definition: ruby.h:1175
tEMBDOC
#define tEMBDOC
Definition: eventids2.c:4
YYLTYPE::first_line
int first_line
Definition: parse.h:304
NEW_MATCH3
#define NEW_MATCH3(r, n2)
Definition: node.h:408
number_literal_suffix
#define number_literal_suffix(f)
Definition: ripper.c:10996
DVARS_INHERIT
#define DVARS_INHERIT
Definition: ripper.c:450
STR_NEW3
#define STR_NEW3(p, n, e, func)
Definition: ripper.c:565
ID2VAL
#define ID2VAL(id)
Definition: ripper.c:1107
NEW_OPT_ARG
#define NEW_OPT_ARG(i, v)
Definition: node.h:423
parser_params::in_single
unsigned int in_single
Definition: ripper.c:524
BEG
#define BEG(no)
Definition: re.c:24
keyword_do
#define keyword_do
Definition: ripper.c:213
new_brace_body
#define new_brace_body(param, stmt, column)
Definition: ripper.c:839
parser_params::lex
struct parser_params::@46 lex
parser_params::debug_output
VALUE debug_output
Definition: ripper.c:512
RNode::u2
union RNode::@89 u2
CMDARG_SET
#define CMDARG_SET(n)
Definition: ripper.c:430
IS_LABEL_POSSIBLE
#define IS_LABEL_POSSIBLE()
Definition: ripper.c:12384
st_insert
#define st_insert
Definition: regint.h:184
rb_filesystem_str_new_cstr
VALUE rb_filesystem_str_new_cstr(const char *)
Definition: string.c:1085
idPow
Definition: id.h:81
idNeqTilde
Definition: id.h:100
DVARS_TOPSCOPE
#define DVARS_TOPSCOPE
Definition: ripper.c:451
rb_enc_str_new
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
Definition: string.c:759
keyword_true
#define keyword_true
Definition: ripper.c:222
tUPLUS
#define tUPLUS
Definition: ripper.c:255
rb_parser_new
VALUE rb_parser_new(void)
Definition: ripper.c:17357
rb_imemo_alloc_struct::cnt
size_t cnt
Definition: internal.h:938
vtable
Definition: ripper.c:432
rb_const_get_at
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:2298
literal_flush
#define literal_flush(p)
Definition: ripper.c:11024
main
int main(int argc, char **argv)
Definition: nkf.c:6921
set_yylval_node
#define set_yylval_node(x)
Definition: ripper.c:11006
new_xstring
#define new_xstring(node, column)
Definition: ripper.c:835
YYSTACK_BYTES
#define YYSTACK_BYTES(N)
Definition: ripper.c:1426
IS_BEG
#define IS_BEG()
Definition: ripper.c:12382
name
const char * name
Definition: nkf.c:208
keyword_else
#define keyword_else
Definition: ripper.c:202
xrealloc
#define xrealloc
Definition: defines.h:186
RE_OPTION_ENCODING_NONE
#define RE_OPTION_ENCODING_NONE(o)
Definition: ripper.c:995
lex_state_e
lex_state_e
Definition: ripper.c:380
assignable
#define assignable(id, node, column)
Definition: ripper.c:732
ID2SYM
#define ID2SYM(x)
Definition: ruby.h:383
ruby_method_ids
ruby_method_ids
Definition: id.h:76
NODE_OR
Definition: node.h:63
tASET
#define tASET
Definition: ripper.c:271
NEW_RETRY
#define NEW_RETRY()
Definition: node.h:373
token_info
Definition: ripper.c:455
ruby_eval_tree_begin
#define ruby_eval_tree_begin
Definition: ripper.c:613
tNEQ
#define tNEQ
Definition: ripper.c:261
ruby_sourcefile_string
#define ruby_sourcefile_string
Definition: ripper.c:604
formal_argument
#define formal_argument(id)
Definition: ripper.c:949
tLPAREN
#define tLPAREN
Definition: ripper.c:279
nd_value
#define nd_value
Definition: node.h:314
ID_INTERNAL
#define ID_INTERNAL
Definition: id.h:40
alloca
RUBY_SYMBOL_EXPORT_BEGIN void * alloca()
rb_block::type
enum rb_block_type type
Definition: vm_core.h:659
keyword__LINE__
#define keyword__LINE__
Definition: ripper.c:236
modifier_unless
#define modifier_unless
Definition: ripper.c:228
dispatch_heredoc_end
#define dispatch_heredoc_end()
Definition: ripper.c:12762
ruby_eval_tree
#define ruby_eval_tree
Definition: ripper.c:612
rb_str_new_frozen
VALUE rb_str_new_frozen(VALUE)
Definition: string.c:1158
lex_gets
#define lex_gets
Definition: ripper.c:599
toklen
#define toklen()
Definition: ripper.c:11735
NEW_RESBODY
#define NEW_RESBODY(a, ex, n)
Definition: node.h:376
NEW_ARGSCAT
#define NEW_ARGSCAT(a, b)
Definition: node.h:426
st_free_table
#define st_free_table
Definition: regint.h:188
NEW_DASGN_CURR
#define NEW_DASGN_CURR(v, val)
Definition: node.h:388
cmdarg_stack
#define cmdarg_stack
Definition: ripper.c:576
in_single
#define in_single
Definition: ripper.c:580
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: ripper.c:5054
YYFPRINTF
#define YYFPRINTF
Definition: ripper.c:347
keyword_module
#define keyword_module
Definition: ripper.c:191
NEW_SUPER
#define NEW_SUPER(a)
Definition: node.h:420
NEW_CALL
#define NEW_CALL(r, m, a)
Definition: node.h:416
YYSTACK_RELOCATE
#define YYSTACK_RELOCATE(Stack)
Definition: ripper.c:1453
rb_ascii8bit_encoding
rb_encoding * rb_ascii8bit_encoding(void)
Definition: encoding.c:1305
lambda_beginning_p
#define lambda_beginning_p()
Definition: ripper.c:625
peek
#define peek(c)
Definition: ripper.c:11640
new_gvar
#define new_gvar(id, column)
Definition: ripper.c:799
rb_enc_find_index
int rb_enc_find_index(const char *name)
Definition: encoding.c:704
NODE_WHEN
Definition: node.h:33
RCOMPLEX_SET_REAL
#define RCOMPLEX_SET_REAL(cmp, r)
Definition: ruby.h:1068
YYSIZE_MAXIMUM
#define YYSIZE_MAXIMUM
Definition: ripper.c:1299
CONST_ID
#define CONST_ID(var, str)
Definition: ruby.h:1743
call_uni_op
#define call_uni_op(recv, id, column)
Definition: ripper.c:703
keyword_and
#define keyword_and
Definition: ripper.c:224
STR_FUNC_TERM
#define STR_FUNC_TERM
Definition: ripper.c:11607
rb_stdout
RUBY_EXTERN VALUE rb_stdout
Definition: ruby.h:1971
rb_str_intern
VALUE rb_str_intern(VALUE)
Definition: symbol.c:661
rb_intern_const
#define rb_intern_const(str)
Definition: ruby.h:1777
NEW_CVAR
#define NEW_CVAR(v)
Definition: node.h:403
keyword_retry
#define keyword_retry
Definition: ripper.c:211
COND_P
#define COND_P()
Definition: ripper.c:423
new_begin
#define new_begin(b, column)
Definition: ripper.c:829
rb_id_attrset
ID rb_id_attrset(ID)
Definition: symbol.c:100
mixed_error
#define mixed_error(enc1, enc2)
xfree
void void xfree(void *)
is_notop_id
#define is_notop_id(id)
Definition: symbol.h:35
tCOLON2
#define tCOLON2
Definition: ripper.c:275
NEW_MATCH2
#define NEW_MATCH2(n1, n2)
Definition: node.h:407
rb_parser_compile_cstr
NODE * rb_parser_compile_cstr(VALUE vparser, const char *f, const char *s, int len, int line)
Definition: ripper.c:11554
rb_args_info::first_post_arg
ID first_post_arg
Definition: node.h:489
YYPACT_NINF
#define YYPACT_NINF
Definition: ripper.c:2251
rb_parser_realloc
void * rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
Definition: ripper.c:17494
YY_LOCATION_PRINT
#define YY_LOCATION_PRINT(File, Loc)
Definition: ripper.c:349
shadowing_lvar
#define shadowing_lvar(name)
Definition: ripper.c:951
rb_cstr_to_inum
VALUE rb_cstr_to_inum(const char *str, int base, int badcheck)
Definition: bignum.c:3992
tLSHFT
#define tLSHFT
Definition: ripper.c:272
current_arg
#define current_arg
Definition: ripper.c:606
get_value
#define get_value(val)
Definition: ripper.c:861
idEq
Definition: id.h:94
tUMINUS_NUM
#define tUMINUS_NUM
Definition: ripper.c:304
tUMINUS
#define tUMINUS
Definition: ripper.c:256
rb_enc_mbcput
#define rb_enc_mbcput(c, buf, enc)
Definition: encoding.h:211
NEW_DVAR
#define NEW_DVAR(v)
Definition: node.h:400
rb_intern
#define rb_intern(str)
NEW_DEFN
#define NEW_DEFN(i, a, d, p)
Definition: node.h:356
reg_fragment_check
#define reg_fragment_check(str, options)
Definition: ripper.c:853
rb_str_buf_new
VALUE rb_str_buf_new(long)
Definition: string.c:1282
keyword_ensure
#define keyword_ensure
Definition: ripper.c:196
rb_usascii_str_new
VALUE rb_usascii_str_new(const char *, long)
Definition: string.c:743
compile_for_eval
#define compile_for_eval
Definition: ripper.c:611
SYMBOL_P
#define SYMBOL_P(x)
Definition: ruby.h:382
tCOMMENT
#define tCOMMENT
Definition: eventids2.c:2
rb_args_info::kw_args
NODE * kw_args
Definition: node.h:494
set_yylval_id
#define set_yylval_id(x)
Definition: ripper.c:11003
nd_iter
#define nd_iter
Definition: node.h:312
nd_set_line
#define nd_set_line(n, l)
Definition: node.h:279
tREGEXP_END
#define tREGEXP_END
Definition: ripper.c:254
keyword_redo
#define keyword_redo
Definition: ripper.c:210
rb_vsprintf
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1446
rb_compile_file
NODE * rb_compile_file(const char *f, VALUE file, int start)
Definition: ripper.c:11569
tRATIONAL
#define tRATIONAL
Definition: ripper.c:248
LVAR_USED
#define LVAR_USED
Definition: ripper.c:14718
tQWORDS_BEG
#define tQWORDS_BEG
Definition: ripper.c:294
rb_parser_get_yydebug
VALUE rb_parser_get_yydebug(VALUE self)
Definition: ripper.c:17442
NULL
#define NULL
Definition: _sdbm.c:102
NEW_LASGN
#define NEW_LASGN(v, val)
Definition: node.h:386
FIX2LONG
#define FIX2LONG(x)
Definition: ruby.h:363
Qundef
#define Qundef
Definition: ruby.h:439
tIGNORED_NL
#define tIGNORED_NL
Definition: eventids2.c:1
keyword_alias
#define keyword_alias
Definition: ripper.c:232
evstr2dstr
#define evstr2dstr(n, column)
Definition: ripper.c:697
NEW_STR
#define NEW_STR(s)
Definition: node.h:410
rb_args_info::kw_rest_arg
NODE * kw_rest_arg
Definition: node.h:495
ID_GLOBAL
#define ID_GLOBAL
Definition: id.h:35
parser_params::eval_tree_begin
NODE * eval_tree_begin
Definition: ripper.c:537
tINTEGER
#define tINTEGER
Definition: ripper.c:246
ISXDIGIT
#define ISXDIGIT(c)
Definition: ruby.h:2151
rb_warn0
#define rb_warn0(fmt)
Definition: ripper.c:1122
ENCODING_SET
#define ENCODING_SET(obj, i)
Definition: encoding.h:56
NEW_SELF
#define NEW_SELF()
Definition: node.h:442
rb_define_method
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Definition: class.c:1515
tDSTAR
#define tDSTAR
Definition: ripper.c:286
ruby_verbose
#define ruby_verbose
Definition: ruby.h:1813
rb_str_append
VALUE rb_str_append(VALUE, VALUE)
Definition: string.c:2900
new_bv
#define new_bv(id)
Definition: ripper.c:953
rb_parser_while_loop
NODE * rb_parser_while_loop(VALUE vparser, NODE *node, int chomp, int split)
Definition: ripper.c:17185
NEW_NODE
#define NEW_NODE(t, a0, a1, a2)
Definition: node.h:354
NEW_ARGS_AUX
#define NEW_ARGS_AUX(r, b)
Definition: node.h:422
parser_params
Definition: ripper.c:472
new_masgn
#define new_masgn(l, r, column)
Definition: ripper.c:832
parser_params::in_defined
unsigned int in_defined
Definition: ripper.c:521
rb_memcicmp
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:79
new_lvar
#define new_lvar(id, column)
Definition: ripper.c:802
NEW_ALIAS
#define NEW_ALIAS(n, o)
Definition: node.h:432
rb_parser_compile_string
NODE * rb_parser_compile_string(VALUE vparser, const char *f, VALUE s, int line)
Definition: ripper.c:11534
tSTRING_BEG
#define tSTRING_BEG
Definition: ripper.c:290
COND_SET
#define COND_SET(n)
Definition: ripper.c:424
nd_lit
#define nd_lit
Definition: node.h:317
rb_imemo_alloc_struct::ptr
VALUE * ptr
Definition: internal.h:936
rb_enc_prev_char
#define rb_enc_prev_char(s, p, e, enc)
Definition: encoding.h:214
dsym_node
#define dsym_node(node, column)
Definition: ripper.c:727
T_REGEXP
#define T_REGEXP
Definition: ruby.h:497
parser_params::input
VALUE input
Definition: ripper.c:480
NODE_LIT
Definition: node.h:139
parser_params::cmdarg_stack
stack_type cmdarg_stack
Definition: ripper.c:494
new_zarray
#define new_zarray(column)
Definition: ripper.c:814
vtable_free
#define vtable_free(tbl)
Definition: ripper.c:11284
keyword_case
#define keyword_case
Definition: ripper.c:203
ruby_scan_oct
unsigned long ruby_scan_oct(const char *, size_t, size_t *)
Definition: util.c:34
heredoc_end
#define heredoc_end
Definition: ripper.c:594
rb_attr_get
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1224
local_vars::args
struct vtable * args
Definition: ripper.c:440
tokaddmbc
#define tokaddmbc(c, enc)
Definition: ripper.c:10991
NEW_CDECL
#define NEW_CDECL(v, val, path)
Definition: node.h:390
NEW_OPCALL
#define NEW_OPCALL(r, m, a)
Definition: node.h:417
tLAMBDA
#define tLAMBDA
Definition: ripper.c:288
keyword_elsif
#define keyword_elsif
Definition: ripper.c:201
NEW_DEFS
#define NEW_DEFS(r, i, a, d)
Definition: node.h:357
argv
char ** argv
Definition: ruby.c:188
tEMBDOC_END
#define tEMBDOC_END
Definition: eventids2.c:5
backref_assign_error
#define backref_assign_error(n, a, column)
Definition: ripper.c:758
DBL2NUM
#define DBL2NUM(dbl)
Definition: ruby.h:934
new_kw_arg
#define new_kw_arg(k, column)
Definition: ripper.c:717
ISSPACE
#define ISSPACE(c)
Definition: ruby.h:2145
StringValue
#define StringValue(v)
Definition: ruby.h:569
rb_enc_str_buf_cat
VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:2853
pushback
#define pushback(c)
Definition: ripper.c:10981
STR_NEW2
#define STR_NEW2(p)
Definition: ripper.c:564
iseq_label_data
Definition: compile.c:60
YYINITDEPTH
#define YYINITDEPTH
Definition: ripper.c:5115
rb_enc_from_index
rb_encoding * rb_enc_from_index(int index)
Definition: encoding.c:616
IS_AFTER_OPERATOR
#define IS_AFTER_OPERATOR()
Definition: ripper.c:12388
rb_str_new
VALUE rb_str_new(const char *, long)
Definition: string.c:737
xcalloc
#define xcalloc
Definition: defines.h:185
ID_CLASS
#define ID_CLASS
Definition: id.h:38
rb_warn2
#define rb_warn2(fmt, a, b)
Definition: ripper.c:1124
Generated by   doxygen 1.8.13