1 /* A Bison parser, made by GNU Bison 3.5.1. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
6 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 3 of the License, or
11 (at your option) 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, see <http://www.gnu.org/licenses/>. */
20
21 /* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
30
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
33
34 /* C LALR(1) parser skeleton written by Richard Stallman, by
35 simplifying the original so-called "semantic" parser. */
36
37 /* All symbols defined below should begin with yy or YY, to avoid
38 infringing on user name space. This should be done even for local
39 variables, as they might otherwise be expanded by user macros.
40 There are some unavoidable exceptions within include files to
41 define necessary library symbols; they are noted "INFRINGES ON
42 USER NAME SPACE" below. */
43
44 /* Undocumented macros, especially those whose name start with YY_,
45 are private implementation details. Do not rely on them. */
46
47 /* Identify Bison output. */
48 #define YYBISON 1
49
50 /* Bison version. */
51 #define YYBISON_VERSION "3.5.1"
52
53 /* Skeleton name. */
54 #define YYSKELETON_NAME "yacc.c"
55
56 /* Pure parsers. */
57 #define YYPURE 1
58
59 /* Push parsers. */
60 #define YYPUSH 0
61
62 /* Pull parsers. */
63 #define YYPULL 1
64
65
66
67
68 /* First part of user prologue. */
69 #line 7 "mrbgems/mruby-compiler/core/parse.y"
70
71 #undef PARSER_DEBUG
72 #ifdef PARSER_DEBUG
73 # define YYDEBUG 1
74 #endif
75 #define YYSTACK_USE_ALLOCA 1
76
77 #include <ctype.h>
78 #include <errno.h>
79 #include <stdlib.h>
80 #include <string.h>
81 #include <mruby.h>
82 #include <mruby/compile.h>
83 #include <mruby/proc.h>
84 #include <mruby/error.h>
85 #include <mruby/throw.h>
86 #include <mruby/string.h>
87 #include "node.h"
88
89 #define YYLEX_PARAM p
90
91 typedef mrb_ast_node node;
92 typedef struct mrb_parser_state parser_state;
93 typedef struct mrb_parser_heredoc_info parser_heredoc_info;
94
95 static int yyparse(parser_state *p);
96 static int yylex(void *lval, parser_state *p);
97 static void yyerror(parser_state *p, const char *s);
98 static void yywarn(parser_state *p, const char *s);
99 static void yywarning(parser_state *p, const char *s);
100 static void backref_error(parser_state *p, node *n);
101 static void void_expr_error(parser_state *p, node *n);
102 static void tokadd(parser_state *p, int32_t c);
103
104 #define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
105
106 typedef unsigned int stack_type;
107
108 #define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
109 #define BITSTACK_POP(stack) ((stack) = (stack) >> 1)
110 #define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
111 #define BITSTACK_SET_P(stack) ((stack)&1)
112
113 #define COND_PUSH(n) BITSTACK_PUSH(p->cond_stack, (n))
114 #define COND_POP() BITSTACK_POP(p->cond_stack)
115 #define COND_LEXPOP() BITSTACK_LEXPOP(p->cond_stack)
116 #define COND_P() BITSTACK_SET_P(p->cond_stack)
117
118 #define CMDARG_PUSH(n) BITSTACK_PUSH(p->cmdarg_stack, (n))
119 #define CMDARG_POP() BITSTACK_POP(p->cmdarg_stack)
120 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(p->cmdarg_stack)
121 #define CMDARG_P() BITSTACK_SET_P(p->cmdarg_stack)
122
123 #define SET_LINENO(c,n) ((c)->lineno = (n))
124 #define NODE_LINENO(c,n) do {\
125 if (n) {\
126 (c)->filename_index = (n)->filename_index;\
127 (c)->lineno = (n)->lineno;\
128 }\
129 } while (0)
130
131 #define sym(x) ((mrb_sym)(intptr_t)(x))
132 #define nsym(x) ((node*)(intptr_t)(x))
133 #define nint(x) ((node*)(intptr_t)(x))
134 #define intn(x) ((int)(intptr_t)(x))
135
136 #define NUM_SUFFIX_R (1<<0)
137 #define NUM_SUFFIX_I (1<<1)
138
139 static inline mrb_sym
intern_cstr_gen(parser_state * p,const char * s)140 intern_cstr_gen(parser_state *p, const char *s)
141 {
142 return mrb_intern_cstr(p->mrb, s);
143 }
144 #define intern_cstr(s) intern_cstr_gen(p,(s))
145
146 static inline mrb_sym
intern_gen(parser_state * p,const char * s,size_t len)147 intern_gen(parser_state *p, const char *s, size_t len)
148 {
149 return mrb_intern(p->mrb, s, len);
150 }
151 #define intern(s,len) intern_gen(p,(s),(len))
152
153 #define intern_lit(s) mrb_intern_lit(p->mrb, s)
154
155 static void
cons_free_gen(parser_state * p,node * cons)156 cons_free_gen(parser_state *p, node *cons)
157 {
158 cons->cdr = p->cells;
159 p->cells = cons;
160 }
161 #define cons_free(c) cons_free_gen(p, (c))
162
163 static void*
parser_palloc(parser_state * p,size_t size)164 parser_palloc(parser_state *p, size_t size)
165 {
166 void *m = mrb_pool_alloc(p->pool, size);
167
168 if (!m) {
169 MRB_THROW(p->jmp);
170 }
171 return m;
172 }
173
174 static node*
cons_gen(parser_state * p,node * car,node * cdr)175 cons_gen(parser_state *p, node *car, node *cdr)
176 {
177 node *c;
178
179 if (p->cells) {
180 c = p->cells;
181 p->cells = p->cells->cdr;
182 }
183 else {
184 c = (node *)parser_palloc(p, sizeof(mrb_ast_node));
185 }
186
187 c->car = car;
188 c->cdr = cdr;
189 c->lineno = p->lineno;
190 c->filename_index = p->current_filename_index;
191 /* beginning of next partial file; need to point the previous file */
192 if (p->lineno == 0 && p->current_filename_index > 0) {
193 c->filename_index-- ;
194 }
195 return c;
196 }
197 #define cons(a,b) cons_gen(p,(a),(b))
198
199 static node*
list1_gen(parser_state * p,node * a)200 list1_gen(parser_state *p, node *a)
201 {
202 return cons(a, 0);
203 }
204 #define list1(a) list1_gen(p, (a))
205
206 static node*
list2_gen(parser_state * p,node * a,node * b)207 list2_gen(parser_state *p, node *a, node *b)
208 {
209 return cons(a, cons(b,0));
210 }
211 #define list2(a,b) list2_gen(p, (a),(b))
212
213 static node*
list3_gen(parser_state * p,node * a,node * b,node * c)214 list3_gen(parser_state *p, node *a, node *b, node *c)
215 {
216 return cons(a, cons(b, cons(c,0)));
217 }
218 #define list3(a,b,c) list3_gen(p, (a),(b),(c))
219
220 static node*
list4_gen(parser_state * p,node * a,node * b,node * c,node * d)221 list4_gen(parser_state *p, node *a, node *b, node *c, node *d)
222 {
223 return cons(a, cons(b, cons(c, cons(d, 0))));
224 }
225 #define list4(a,b,c,d) list4_gen(p, (a),(b),(c),(d))
226
227 static node*
list5_gen(parser_state * p,node * a,node * b,node * c,node * d,node * e)228 list5_gen(parser_state *p, node *a, node *b, node *c, node *d, node *e)
229 {
230 return cons(a, cons(b, cons(c, cons(d, cons(e, 0)))));
231 }
232 #define list5(a,b,c,d,e) list5_gen(p, (a),(b),(c),(d),(e))
233
234 static node*
list6_gen(parser_state * p,node * a,node * b,node * c,node * d,node * e,node * f)235 list6_gen(parser_state *p, node *a, node *b, node *c, node *d, node *e, node *f)
236 {
237 return cons(a, cons(b, cons(c, cons(d, cons(e, cons(f, 0))))));
238 }
239 #define list6(a,b,c,d,e,f) list6_gen(p, (a),(b),(c),(d),(e),(f))
240
241 static node*
append_gen(parser_state * p,node * a,node * b)242 append_gen(parser_state *p, node *a, node *b)
243 {
244 node *c = a;
245
246 if (!a) return b;
247 if (!b) return a;
248 while (c->cdr) {
249 c = c->cdr;
250 }
251 c->cdr = b;
252 return a;
253 }
254 #define append(a,b) append_gen(p,(a),(b))
255 #define push(a,b) append_gen(p,(a),list1(b))
256
257 static char*
parser_strndup(parser_state * p,const char * s,size_t len)258 parser_strndup(parser_state *p, const char *s, size_t len)
259 {
260 char *b = (char *)parser_palloc(p, len+1);
261
262 memcpy(b, s, len);
263 b[len] = '\0';
264 return b;
265 }
266 #undef strndup
267 #define strndup(s,len) parser_strndup(p, s, len)
268
269 static char*
parser_strdup(parser_state * p,const char * s)270 parser_strdup(parser_state *p, const char *s)
271 {
272 return parser_strndup(p, s, strlen(s));
273 }
274 #undef strdup
275 #define strdup(s) parser_strdup(p, s)
276
277 static void
dump_int(uint16_t i,char * s)278 dump_int(uint16_t i, char *s)
279 {
280 char *p = s;
281 char *t = s;
282
283 while (i > 0) {
284 *p++ = (i % 10)+'0';
285 i /= 10;
286 }
287 if (p == s) *p++ = '0';
288 *p = 0;
289 p--; /* point the last char */
290 while (t < p) {
291 char c = *t;
292 *t++ = *p;
293 *p-- = c;
294 }
295 }
296
297 /* xxx ----------------------------- */
298
299 static node*
local_switch(parser_state * p)300 local_switch(parser_state *p)
301 {
302 node *prev = p->locals;
303
304 p->locals = cons(0, 0);
305 return prev;
306 }
307
308 static void
local_resume(parser_state * p,node * prev)309 local_resume(parser_state *p, node *prev)
310 {
311 p->locals = prev;
312 }
313
314 static void
local_nest(parser_state * p)315 local_nest(parser_state *p)
316 {
317 p->locals = cons(0, p->locals);
318 }
319
320 static void
local_unnest(parser_state * p)321 local_unnest(parser_state *p)
322 {
323 if (p->locals) {
324 p->locals = p->locals->cdr;
325 }
326 }
327
328 static mrb_bool
local_var_p(parser_state * p,mrb_sym sym)329 local_var_p(parser_state *p, mrb_sym sym)
330 {
331 struct RProc *u;
332 node *l = p->locals;
333
334 while (l) {
335 node *n = l->car;
336 while (n) {
337 if (sym(n->car) == sym) return TRUE;
338 n = n->cdr;
339 }
340 l = l->cdr;
341 }
342
343 u = p->upper;
344 while (u && !MRB_PROC_CFUNC_P(u)) {
345 struct mrb_irep *ir = u->body.irep;
346 uint_fast16_t n = ir->nlocals;
347 const struct mrb_locals *v = ir->lv;
348 for (; n > 1; n --, v ++) {
349 if (v->name == sym) return TRUE;
350 }
351 if (MRB_PROC_SCOPE_P(u)) break;
352 u = u->upper;
353 }
354 return FALSE;
355 }
356
357 static void
local_add_f(parser_state * p,mrb_sym sym)358 local_add_f(parser_state *p, mrb_sym sym)
359 {
360 if (p->locals) {
361 p->locals->car = push(p->locals->car, nsym(sym));
362 }
363 }
364
365 static void
local_add(parser_state * p,mrb_sym sym)366 local_add(parser_state *p, mrb_sym sym)
367 {
368 if (!local_var_p(p, sym)) {
369 local_add_f(p, sym);
370 }
371 }
372
373 static void
local_add_blk(parser_state * p,mrb_sym blk)374 local_add_blk(parser_state *p, mrb_sym blk)
375 {
376 /* allocate register for block */
377 local_add_f(p, blk ? blk : mrb_intern_lit(p->mrb, "&"));
378 }
379
380 static void
local_add_kw(parser_state * p,mrb_sym kwd)381 local_add_kw(parser_state *p, mrb_sym kwd)
382 {
383 /* allocate register for keywords hash */
384 local_add_f(p, kwd ? kwd : mrb_intern_lit(p->mrb, "**"));
385 }
386
387 static node*
locals_node(parser_state * p)388 locals_node(parser_state *p)
389 {
390 return p->locals ? p->locals->car : NULL;
391 }
392
393 static void
nvars_nest(parser_state * p)394 nvars_nest(parser_state *p)
395 {
396 p->nvars = cons(nint(0), p->nvars);
397 }
398
399 static void
nvars_block(parser_state * p)400 nvars_block(parser_state *p)
401 {
402 p->nvars = cons(nint(-2), p->nvars);
403 }
404
405 static void
nvars_unnest(parser_state * p)406 nvars_unnest(parser_state *p)
407 {
408 p->nvars = p->nvars->cdr;
409 }
410
411 /* (:scope (vars..) (prog...)) */
412 static node*
new_scope(parser_state * p,node * body)413 new_scope(parser_state *p, node *body)
414 {
415 return cons((node*)NODE_SCOPE, cons(locals_node(p), body));
416 }
417
418 /* (:begin prog...) */
419 static node*
new_begin(parser_state * p,node * body)420 new_begin(parser_state *p, node *body)
421 {
422 if (body) {
423 return list2((node*)NODE_BEGIN, body);
424 }
425 return cons((node*)NODE_BEGIN, 0);
426 }
427
428 #define newline_node(n) (n)
429
430 /* (:rescue body rescue else) */
431 static node*
new_rescue(parser_state * p,node * body,node * resq,node * els)432 new_rescue(parser_state *p, node *body, node *resq, node *els)
433 {
434 return list4((node*)NODE_RESCUE, body, resq, els);
435 }
436
437 static node*
new_mod_rescue(parser_state * p,node * body,node * resq)438 new_mod_rescue(parser_state *p, node *body, node *resq)
439 {
440 return new_rescue(p, body, list1(list3(0, 0, resq)), 0);
441 }
442
443 /* (:ensure body ensure) */
444 static node*
new_ensure(parser_state * p,node * a,node * b)445 new_ensure(parser_state *p, node *a, node *b)
446 {
447 return cons((node*)NODE_ENSURE, cons(a, cons(0, b)));
448 }
449
450 /* (:nil) */
451 static node*
new_nil(parser_state * p)452 new_nil(parser_state *p)
453 {
454 return list1((node*)NODE_NIL);
455 }
456
457 /* (:true) */
458 static node*
new_true(parser_state * p)459 new_true(parser_state *p)
460 {
461 return list1((node*)NODE_TRUE);
462 }
463
464 /* (:false) */
465 static node*
new_false(parser_state * p)466 new_false(parser_state *p)
467 {
468 return list1((node*)NODE_FALSE);
469 }
470
471 /* (:alias new old) */
472 static node*
new_alias(parser_state * p,mrb_sym a,mrb_sym b)473 new_alias(parser_state *p, mrb_sym a, mrb_sym b)
474 {
475 return cons((node*)NODE_ALIAS, cons(nsym(a), nsym(b)));
476 }
477
478 /* (:if cond then else) */
479 static node*
new_if(parser_state * p,node * a,node * b,node * c)480 new_if(parser_state *p, node *a, node *b, node *c)
481 {
482 void_expr_error(p, a);
483 return list4((node*)NODE_IF, a, b, c);
484 }
485
486 /* (:unless cond then else) */
487 static node*
new_unless(parser_state * p,node * a,node * b,node * c)488 new_unless(parser_state *p, node *a, node *b, node *c)
489 {
490 void_expr_error(p, a);
491 return list4((node*)NODE_IF, a, c, b);
492 }
493
494 /* (:while cond body) */
495 static node*
new_while(parser_state * p,node * a,node * b)496 new_while(parser_state *p, node *a, node *b)
497 {
498 void_expr_error(p, a);
499 return cons((node*)NODE_WHILE, cons(a, b));
500 }
501
502 /* (:until cond body) */
503 static node*
new_until(parser_state * p,node * a,node * b)504 new_until(parser_state *p, node *a, node *b)
505 {
506 void_expr_error(p, a);
507 return cons((node*)NODE_UNTIL, cons(a, b));
508 }
509
510 /* (:for var obj body) */
511 static node*
new_for(parser_state * p,node * v,node * o,node * b)512 new_for(parser_state *p, node *v, node *o, node *b)
513 {
514 void_expr_error(p, o);
515 return list4((node*)NODE_FOR, v, o, b);
516 }
517
518 /* (:case a ((when ...) body) ((when...) body)) */
519 static node*
new_case(parser_state * p,node * a,node * b)520 new_case(parser_state *p, node *a, node *b)
521 {
522 node *n = list2((node*)NODE_CASE, a);
523 node *n2 = n;
524
525 void_expr_error(p, a);
526 while (n2->cdr) {
527 n2 = n2->cdr;
528 }
529 n2->cdr = b;
530 return n;
531 }
532
533 /* (:postexe a) */
534 static node*
new_postexe(parser_state * p,node * a)535 new_postexe(parser_state *p, node *a)
536 {
537 return cons((node*)NODE_POSTEXE, a);
538 }
539
540 /* (:self) */
541 static node*
new_self(parser_state * p)542 new_self(parser_state *p)
543 {
544 return list1((node*)NODE_SELF);
545 }
546
547 /* (:call a b c) */
548 static node*
new_call(parser_state * p,node * a,mrb_sym b,node * c,int pass)549 new_call(parser_state *p, node *a, mrb_sym b, node *c, int pass)
550 {
551 node *n = list4(nint(pass?NODE_CALL:NODE_SCALL), a, nsym(b), c);
552 void_expr_error(p, a);
553 NODE_LINENO(n, a);
554 return n;
555 }
556
557 /* (:fcall self mid args) */
558 static node*
new_fcall(parser_state * p,mrb_sym b,node * c)559 new_fcall(parser_state *p, mrb_sym b, node *c)
560 {
561 node *n = new_self(p);
562 NODE_LINENO(n, c);
563 n = list4((node*)NODE_FCALL, n, nsym(b), c);
564 NODE_LINENO(n, c);
565 return n;
566 }
567
568 /* (:super . c) */
569 static node*
new_super(parser_state * p,node * c)570 new_super(parser_state *p, node *c)
571 {
572 return cons((node*)NODE_SUPER, c);
573 }
574
575 /* (:zsuper) */
576 static node*
new_zsuper(parser_state * p)577 new_zsuper(parser_state *p)
578 {
579 return list1((node*)NODE_ZSUPER);
580 }
581
582 /* (:yield . c) */
583 static node*
new_yield(parser_state * p,node * c)584 new_yield(parser_state *p, node *c)
585 {
586 if (c) {
587 if (c->cdr) {
588 yyerror(p, "both block arg and actual block given");
589 }
590 return cons((node*)NODE_YIELD, c->car);
591 }
592 return cons((node*)NODE_YIELD, 0);
593 }
594
595 /* (:return . c) */
596 static node*
new_return(parser_state * p,node * c)597 new_return(parser_state *p, node *c)
598 {
599 return cons((node*)NODE_RETURN, c);
600 }
601
602 /* (:break . c) */
603 static node*
new_break(parser_state * p,node * c)604 new_break(parser_state *p, node *c)
605 {
606 return cons((node*)NODE_BREAK, c);
607 }
608
609 /* (:next . c) */
610 static node*
new_next(parser_state * p,node * c)611 new_next(parser_state *p, node *c)
612 {
613 return cons((node*)NODE_NEXT, c);
614 }
615
616 /* (:redo) */
617 static node*
new_redo(parser_state * p)618 new_redo(parser_state *p)
619 {
620 return list1((node*)NODE_REDO);
621 }
622
623 /* (:retry) */
624 static node*
new_retry(parser_state * p)625 new_retry(parser_state *p)
626 {
627 return list1((node*)NODE_RETRY);
628 }
629
630 /* (:dot2 a b) */
631 static node*
new_dot2(parser_state * p,node * a,node * b)632 new_dot2(parser_state *p, node *a, node *b)
633 {
634 return cons((node*)NODE_DOT2, cons(a, b));
635 }
636
637 /* (:dot3 a b) */
638 static node*
new_dot3(parser_state * p,node * a,node * b)639 new_dot3(parser_state *p, node *a, node *b)
640 {
641 return cons((node*)NODE_DOT3, cons(a, b));
642 }
643
644 /* (:colon2 b c) */
645 static node*
new_colon2(parser_state * p,node * b,mrb_sym c)646 new_colon2(parser_state *p, node *b, mrb_sym c)
647 {
648 void_expr_error(p, b);
649 return cons((node*)NODE_COLON2, cons(b, nsym(c)));
650 }
651
652 /* (:colon3 . c) */
653 static node*
new_colon3(parser_state * p,mrb_sym c)654 new_colon3(parser_state *p, mrb_sym c)
655 {
656 return cons((node*)NODE_COLON3, nsym(c));
657 }
658
659 /* (:and a b) */
660 static node*
new_and(parser_state * p,node * a,node * b)661 new_and(parser_state *p, node *a, node *b)
662 {
663 return cons((node*)NODE_AND, cons(a, b));
664 }
665
666 /* (:or a b) */
667 static node*
new_or(parser_state * p,node * a,node * b)668 new_or(parser_state *p, node *a, node *b)
669 {
670 return cons((node*)NODE_OR, cons(a, b));
671 }
672
673 /* (:array a...) */
674 static node*
new_array(parser_state * p,node * a)675 new_array(parser_state *p, node *a)
676 {
677 return cons((node*)NODE_ARRAY, a);
678 }
679
680 /* (:splat . a) */
681 static node*
new_splat(parser_state * p,node * a)682 new_splat(parser_state *p, node *a)
683 {
684 return cons((node*)NODE_SPLAT, a);
685 }
686
687 /* (:hash (k . v) (k . v)...) */
688 static node*
new_hash(parser_state * p,node * a)689 new_hash(parser_state *p, node *a)
690 {
691 return cons((node*)NODE_HASH, a);
692 }
693
694 /* (:kw_hash (k . v) (k . v)...) */
695 static node*
new_kw_hash(parser_state * p,node * a)696 new_kw_hash(parser_state *p, node *a)
697 {
698 return cons((node*)NODE_KW_HASH, a);
699 }
700
701 /* (:sym . a) */
702 static node*
new_sym(parser_state * p,mrb_sym sym)703 new_sym(parser_state *p, mrb_sym sym)
704 {
705 return cons((node*)NODE_SYM, nsym(sym));
706 }
707
708 static mrb_sym
new_strsym(parser_state * p,node * str)709 new_strsym(parser_state *p, node* str)
710 {
711 const char *s = (const char*)str->cdr->car;
712 size_t len = (size_t)str->cdr->cdr;
713
714 return mrb_intern(p->mrb, s, len);
715 }
716
717 /* (:lvar . a) */
718 static node*
new_lvar(parser_state * p,mrb_sym sym)719 new_lvar(parser_state *p, mrb_sym sym)
720 {
721 return cons((node*)NODE_LVAR, nsym(sym));
722 }
723
724 /* (:gvar . a) */
725 static node*
new_gvar(parser_state * p,mrb_sym sym)726 new_gvar(parser_state *p, mrb_sym sym)
727 {
728 return cons((node*)NODE_GVAR, nsym(sym));
729 }
730
731 /* (:ivar . a) */
732 static node*
new_ivar(parser_state * p,mrb_sym sym)733 new_ivar(parser_state *p, mrb_sym sym)
734 {
735 return cons((node*)NODE_IVAR, nsym(sym));
736 }
737
738 /* (:cvar . a) */
739 static node*
new_cvar(parser_state * p,mrb_sym sym)740 new_cvar(parser_state *p, mrb_sym sym)
741 {
742 return cons((node*)NODE_CVAR, nsym(sym));
743 }
744
745 /* (:nvar . a) */
746 static node*
new_nvar(parser_state * p,int num)747 new_nvar(parser_state *p, int num)
748 {
749 int nvars = intn(p->nvars->car);
750
751 p->nvars->car = nint(nvars > num ? nvars : num);
752 return cons((node*)NODE_NVAR, nint(num));
753 }
754
755 /* (:const . a) */
756 static node*
new_const(parser_state * p,mrb_sym sym)757 new_const(parser_state *p, mrb_sym sym)
758 {
759 return cons((node*)NODE_CONST, nsym(sym));
760 }
761
762 /* (:undef a...) */
763 static node*
new_undef(parser_state * p,mrb_sym sym)764 new_undef(parser_state *p, mrb_sym sym)
765 {
766 return list2((node*)NODE_UNDEF, nsym(sym));
767 }
768
769 /* (:class class super body) */
770 static node*
new_class(parser_state * p,node * c,node * s,node * b)771 new_class(parser_state *p, node *c, node *s, node *b)
772 {
773 void_expr_error(p, s);
774 return list4((node*)NODE_CLASS, c, s, cons(locals_node(p), b));
775 }
776
777 /* (:sclass obj body) */
778 static node*
new_sclass(parser_state * p,node * o,node * b)779 new_sclass(parser_state *p, node *o, node *b)
780 {
781 void_expr_error(p, o);
782 return list3((node*)NODE_SCLASS, o, cons(locals_node(p), b));
783 }
784
785 /* (:module module body) */
786 static node*
new_module(parser_state * p,node * m,node * b)787 new_module(parser_state *p, node *m, node *b)
788 {
789 return list3((node*)NODE_MODULE, m, cons(locals_node(p), b));
790 }
791
792 /* (:def m lv (arg . body)) */
793 static node*
new_def(parser_state * p,mrb_sym m,node * a,node * b)794 new_def(parser_state *p, mrb_sym m, node *a, node *b)
795 {
796 return list5((node*)NODE_DEF, nsym(m), locals_node(p), a, b);
797 }
798
799 /* (:sdef obj m lv (arg . body)) */
800 static node*
new_sdef(parser_state * p,node * o,mrb_sym m,node * a,node * b)801 new_sdef(parser_state *p, node *o, mrb_sym m, node *a, node *b)
802 {
803 void_expr_error(p, o);
804 return list6((node*)NODE_SDEF, o, nsym(m), locals_node(p), a, b);
805 }
806
807 /* (:arg . sym) */
808 static node*
new_arg(parser_state * p,mrb_sym sym)809 new_arg(parser_state *p, mrb_sym sym)
810 {
811 return cons((node*)NODE_ARG, nsym(sym));
812 }
813
814 static void
local_add_margs(parser_state * p,node * n)815 local_add_margs(parser_state *p, node *n)
816 {
817 while (n) {
818 if (n->car->car == (node*)NODE_MASGN) {
819 node *t = n->car->cdr->cdr;
820
821 n->car->cdr->cdr = NULL;
822 while (t) {
823 local_add_f(p, sym(t->car));
824 t = t->cdr;
825 }
826 local_add_margs(p, n->car->cdr->car->car);
827 local_add_margs(p, n->car->cdr->car->cdr->cdr->car);
828 }
829 n = n->cdr;
830 }
831 }
832
833 static void
local_add_lv(parser_state * p,node * lv)834 local_add_lv(parser_state *p, node *lv)
835 {
836 while (lv) {
837 local_add_f(p, sym(lv->car));
838 lv = lv->cdr;
839 }
840 }
841
842 /* (m o r m2 tail) */
843 /* m: (a b c) */
844 /* o: ((a . e1) (b . e2)) */
845 /* r: a */
846 /* m2: (a b c) */
847 /* b: a */
848 static node*
new_args(parser_state * p,node * m,node * opt,mrb_sym rest,node * m2,node * tail)849 new_args(parser_state *p, node *m, node *opt, mrb_sym rest, node *m2, node *tail)
850 {
851 node *n;
852
853 local_add_margs(p, m);
854 local_add_margs(p, m2);
855 n = cons(m2, tail);
856 n = cons(nsym(rest), n);
857 n = cons(opt, n);
858 while (opt) {
859 /* opt: (sym . (opt . lv)) -> (sym . opt) */
860 local_add_lv(p, opt->car->cdr->cdr);
861 opt->car->cdr = opt->car->cdr->car;
862 opt = opt->cdr;
863 }
864 return cons(m, n);
865 }
866
867 /* (:args_tail keywords rest_keywords_sym block_sym) */
868 static node*
new_args_tail(parser_state * p,node * kws,node * kwrest,mrb_sym blk)869 new_args_tail(parser_state *p, node *kws, node *kwrest, mrb_sym blk)
870 {
871 node *k;
872
873 if (kws || kwrest) {
874 local_add_kw(p, (kwrest && kwrest->cdr)? sym(kwrest->cdr) : 0);
875 }
876
877 local_add_blk(p, blk);
878
879 /* allocate register for keywords arguments */
880 /* order is for Proc#parameters */
881 for (k = kws; k; k = k->cdr) {
882 if (!k->car->cdr->cdr->car) { /* allocate required keywords */
883 local_add_f(p, sym(k->car->cdr->car));
884 }
885 }
886 for (k = kws; k; k = k->cdr) {
887 if (k->car->cdr->cdr->car) { /* allocate keywords with default */
888 local_add_lv(p, k->car->cdr->cdr->car->cdr);
889 k->car->cdr->cdr->car = k->car->cdr->cdr->car->car;
890 local_add_f(p, sym(k->car->cdr->car));
891 }
892 }
893
894 return list4((node*)NODE_ARGS_TAIL, kws, kwrest, nsym(blk));
895 }
896
897 /* (:kw_arg kw_sym def_arg) */
898 static node*
new_kw_arg(parser_state * p,mrb_sym kw,node * def_arg)899 new_kw_arg(parser_state *p, mrb_sym kw, node *def_arg)
900 {
901 mrb_assert(kw);
902 return list3((node*)NODE_KW_ARG, nsym(kw), def_arg);
903 }
904
905 /* (:kw_rest_args . a) */
906 static node*
new_kw_rest_args(parser_state * p,node * a)907 new_kw_rest_args(parser_state *p, node *a)
908 {
909 return cons((node*)NODE_KW_REST_ARGS, a);
910 }
911
912 /* (:block_arg . a) */
913 static node*
new_block_arg(parser_state * p,node * a)914 new_block_arg(parser_state *p, node *a)
915 {
916 return cons((node*)NODE_BLOCK_ARG, a);
917 }
918
919 static node*
setup_numparams(parser_state * p,node * a)920 setup_numparams(parser_state *p, node *a)
921 {
922 int nvars = intn(p->nvars->car);
923 if (nvars > 0) {
924 int i;
925 mrb_sym sym;
926 // m || opt || rest || tail
927 if (a && (a->car || (a->cdr && a->cdr->car) || (a->cdr->cdr && a->cdr->cdr->car) || (a->cdr->cdr->cdr->cdr && a->cdr->cdr->cdr->cdr->car))) {
928 yyerror(p, "ordinary parameter is defined");
929 }
930 else if (p->locals) {
931 /* p->locals should not be NULL unless error happens before the point */
932 node* args = 0;
933 for (i = nvars; i > 0; i--) {
934 char buf[3];
935
936 buf[0] = '_';
937 buf[1] = i+'0';
938 buf[2] = '\0';
939 sym = intern_cstr(buf);
940 args = cons(new_arg(p, sym), args);
941 p->locals->car = cons(nsym(sym), p->locals->car);
942 }
943 a = new_args(p, args, 0, 0, 0, 0);
944 }
945 }
946 return a;
947 }
948
949 /* (:block arg body) */
950 static node*
new_block(parser_state * p,node * a,node * b)951 new_block(parser_state *p, node *a, node *b)
952 {
953 a = setup_numparams(p, a);
954 return list4((node*)NODE_BLOCK, locals_node(p), a, b);
955 }
956
957 /* (:lambda arg body) */
958 static node*
new_lambda(parser_state * p,node * a,node * b)959 new_lambda(parser_state *p, node *a, node *b)
960 {
961 return list4((node*)NODE_LAMBDA, locals_node(p), a, b);
962 }
963
964 /* (:asgn lhs rhs) */
965 static node*
new_asgn(parser_state * p,node * a,node * b)966 new_asgn(parser_state *p, node *a, node *b)
967 {
968 void_expr_error(p, b);
969 return cons((node*)NODE_ASGN, cons(a, b));
970 }
971
972 /* (:masgn mlhs=(pre rest post) mrhs) */
973 static node*
new_masgn(parser_state * p,node * a,node * b)974 new_masgn(parser_state *p, node *a, node *b)
975 {
976 void_expr_error(p, b);
977 return cons((node*)NODE_MASGN, cons(a, b));
978 }
979
980 /* (:masgn mlhs mrhs) no check */
981 static node*
new_masgn_param(parser_state * p,node * a,node * b)982 new_masgn_param(parser_state *p, node *a, node *b)
983 {
984 return cons((node*)NODE_MASGN, cons(a, b));
985 }
986
987 /* (:asgn lhs rhs) */
988 static node*
new_op_asgn(parser_state * p,node * a,mrb_sym op,node * b)989 new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b)
990 {
991 void_expr_error(p, b);
992 return list4((node*)NODE_OP_ASGN, a, nsym(op), b);
993 }
994
995 static node*
new_imaginary(parser_state * p,node * imaginary)996 new_imaginary(parser_state *p, node *imaginary)
997 {
998 return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Complex"), list1(list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary)), 1);
999 }
1000
1001 static node*
new_rational(parser_state * p,node * rational)1002 new_rational(parser_state *p, node *rational)
1003 {
1004 return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Rational"), list1(list1(rational)), 1);
1005 }
1006
1007 /* (:int . i) */
1008 static node*
new_int(parser_state * p,const char * s,int base,int suffix)1009 new_int(parser_state *p, const char *s, int base, int suffix)
1010 {
1011 node* result = list3((node*)NODE_INT, (node*)strdup(s), nint(base));
1012 if (suffix & NUM_SUFFIX_R) {
1013 result = new_rational(p, result);
1014 }
1015 if (suffix & NUM_SUFFIX_I) {
1016 result = new_imaginary(p, result);
1017 }
1018 return result;
1019 }
1020
1021 #ifndef MRB_WITHOUT_FLOAT
1022 /* (:float . i) */
1023 static node*
new_float(parser_state * p,const char * s,int suffix)1024 new_float(parser_state *p, const char *s, int suffix)
1025 {
1026 node* result = cons((node*)NODE_FLOAT, (node*)strdup(s));
1027 if (suffix & NUM_SUFFIX_R) {
1028 result = new_rational(p, result);
1029 }
1030 if (suffix & NUM_SUFFIX_I) {
1031 result = new_imaginary(p, result);
1032 }
1033 return result;
1034 }
1035 #endif
1036
1037 /* (:str . (s . len)) */
1038 static node*
new_str(parser_state * p,const char * s,size_t len)1039 new_str(parser_state *p, const char *s, size_t len)
1040 {
1041 return cons((node*)NODE_STR, cons((node*)strndup(s, len), nint(len)));
1042 }
1043
1044 /* (:dstr . a) */
1045 static node*
new_dstr(parser_state * p,node * a)1046 new_dstr(parser_state *p, node *a)
1047 {
1048 return cons((node*)NODE_DSTR, a);
1049 }
1050
1051 static int
string_node_p(node * n)1052 string_node_p(node *n)
1053 {
1054 return (int)((enum node_type)(intptr_t)n->car == NODE_STR);
1055 }
1056
1057 static node*
composite_string_node(parser_state * p,node * a,node * b)1058 composite_string_node(parser_state *p, node *a, node *b)
1059 {
1060 size_t newlen = (size_t)a->cdr + (size_t)b->cdr;
1061 char *str = (char*)mrb_pool_realloc(p->pool, a->car, (size_t)a->cdr + 1, newlen + 1);
1062 memcpy(str + (size_t)a->cdr, b->car, (size_t)b->cdr);
1063 str[newlen] = '\0';
1064 a->car = (node*)str;
1065 a->cdr = (node*)newlen;
1066 cons_free(b);
1067 return a;
1068 }
1069
1070 static node*
concat_string(parser_state * p,node * a,node * b)1071 concat_string(parser_state *p, node *a, node *b)
1072 {
1073 if (string_node_p(a)) {
1074 if (string_node_p(b)) {
1075 /* a == NODE_STR && b == NODE_STR */
1076 composite_string_node(p, a->cdr, b->cdr);
1077 cons_free(b);
1078 return a;
1079 }
1080 else {
1081 /* a == NODE_STR && b == NODE_DSTR */
1082
1083 if (string_node_p(b->cdr->car)) {
1084 /* a == NODE_STR && b->[NODE_STR, ...] */
1085 composite_string_node(p, a->cdr, b->cdr->car->cdr);
1086 cons_free(b->cdr->car);
1087 b->cdr->car = a;
1088 return b;
1089 }
1090 }
1091 }
1092 else {
1093 node *c; /* last node of a */
1094 for (c = a; c->cdr != NULL; c = c->cdr) ;
1095
1096 if (string_node_p(b)) {
1097 /* a == NODE_DSTR && b == NODE_STR */
1098 if (string_node_p(c->car)) {
1099 /* a->[..., NODE_STR] && b == NODE_STR */
1100 composite_string_node(p, c->car->cdr, b->cdr);
1101 cons_free(b);
1102 return a;
1103 }
1104
1105 push(a, b);
1106 return a;
1107 }
1108 else {
1109 /* a == NODE_DSTR && b == NODE_DSTR */
1110 if (string_node_p(c->car) && string_node_p(b->cdr->car)) {
1111 /* a->[..., NODE_STR] && b->[NODE_STR, ...] */
1112 node *d = b->cdr;
1113 cons_free(b);
1114 composite_string_node(p, c->car->cdr, d->car->cdr);
1115 cons_free(d->car);
1116 c->cdr = d->cdr;
1117 cons_free(d);
1118 return a;
1119 }
1120 else {
1121 c->cdr = b->cdr;
1122 cons_free(b);
1123 return a;
1124 }
1125 }
1126 }
1127
1128 return new_dstr(p, list2(a, b));
1129 }
1130
1131 /* (:str . (s . len)) */
1132 static node*
new_xstr(parser_state * p,const char * s,int len)1133 new_xstr(parser_state *p, const char *s, int len)
1134 {
1135 return cons((node*)NODE_XSTR, cons((node*)strndup(s, len), nint(len)));
1136 }
1137
1138 /* (:xstr . a) */
1139 static node*
new_dxstr(parser_state * p,node * a)1140 new_dxstr(parser_state *p, node *a)
1141 {
1142 return cons((node*)NODE_DXSTR, a);
1143 }
1144
1145 /* (:dsym . a) */
1146 static node*
new_dsym(parser_state * p,node * a)1147 new_dsym(parser_state *p, node *a)
1148 {
1149 return cons((node*)NODE_DSYM, a);
1150 }
1151
1152 /* (:regx . (s . (opt . enc))) */
1153 static node*
new_regx(parser_state * p,const char * p1,const char * p2,const char * p3)1154 new_regx(parser_state *p, const char *p1, const char* p2, const char* p3)
1155 {
1156 return cons((node*)NODE_REGX, cons((node*)p1, cons((node*)p2, (node*)p3)));
1157 }
1158
1159 /* (:dregx . (a . b)) */
1160 static node*
new_dregx(parser_state * p,node * a,node * b)1161 new_dregx(parser_state *p, node *a, node *b)
1162 {
1163 return cons((node*)NODE_DREGX, cons(a, b));
1164 }
1165
1166 /* (:backref . n) */
1167 static node*
new_back_ref(parser_state * p,int n)1168 new_back_ref(parser_state *p, int n)
1169 {
1170 return cons((node*)NODE_BACK_REF, nint(n));
1171 }
1172
1173 /* (:nthref . n) */
1174 static node*
new_nth_ref(parser_state * p,int n)1175 new_nth_ref(parser_state *p, int n)
1176 {
1177 return cons((node*)NODE_NTH_REF, nint(n));
1178 }
1179
1180 /* (:heredoc . a) */
1181 static node*
new_heredoc(parser_state * p)1182 new_heredoc(parser_state *p)
1183 {
1184 parser_heredoc_info *inf = (parser_heredoc_info *)parser_palloc(p, sizeof(parser_heredoc_info));
1185 return cons((node*)NODE_HEREDOC, (node*)inf);
1186 }
1187
1188 static void
new_bv(parser_state * p,mrb_sym id)1189 new_bv(parser_state *p, mrb_sym id)
1190 {
1191 }
1192
1193 static node*
new_literal_delim(parser_state * p)1194 new_literal_delim(parser_state *p)
1195 {
1196 return cons((node*)NODE_LITERAL_DELIM, 0);
1197 }
1198
1199 /* (:words . a) */
1200 static node*
new_words(parser_state * p,node * a)1201 new_words(parser_state *p, node *a)
1202 {
1203 return cons((node*)NODE_WORDS, a);
1204 }
1205
1206 /* (:symbols . a) */
1207 static node*
new_symbols(parser_state * p,node * a)1208 new_symbols(parser_state *p, node *a)
1209 {
1210 return cons((node*)NODE_SYMBOLS, a);
1211 }
1212
1213 /* xxx ----------------------------- */
1214
1215 /* (:call a op) */
1216 static node*
call_uni_op(parser_state * p,node * recv,const char * m)1217 call_uni_op(parser_state *p, node *recv, const char *m)
1218 {
1219 void_expr_error(p, recv);
1220 return new_call(p, recv, intern_cstr(m), 0, 1);
1221 }
1222
1223 /* (:call a op b) */
1224 static node*
call_bin_op(parser_state * p,node * recv,const char * m,node * arg1)1225 call_bin_op(parser_state *p, node *recv, const char *m, node *arg1)
1226 {
1227 return new_call(p, recv, intern_cstr(m), list1(list1(arg1)), 1);
1228 }
1229
1230 static void
args_with_block(parser_state * p,node * a,node * b)1231 args_with_block(parser_state *p, node *a, node *b)
1232 {
1233 if (b) {
1234 if (a->cdr) {
1235 yyerror(p, "both block arg and actual block given");
1236 }
1237 a->cdr = b;
1238 }
1239 }
1240
1241 static void
call_with_block(parser_state * p,node * a,node * b)1242 call_with_block(parser_state *p, node *a, node *b)
1243 {
1244 node *n;
1245
1246 switch ((enum node_type)intn(a->car)) {
1247 case NODE_SUPER:
1248 case NODE_ZSUPER:
1249 if (!a->cdr) a->cdr = cons(0, b);
1250 else {
1251 args_with_block(p, a->cdr, b);
1252 }
1253 break;
1254 case NODE_CALL:
1255 case NODE_FCALL:
1256 case NODE_SCALL:
1257 n = a->cdr->cdr->cdr;
1258 if (!n->car) n->car = cons(0, b);
1259 else {
1260 args_with_block(p, n->car, b);
1261 }
1262 break;
1263 default:
1264 break;
1265 }
1266 }
1267
1268 static node*
negate_lit(parser_state * p,node * n)1269 negate_lit(parser_state *p, node *n)
1270 {
1271 return cons((node*)NODE_NEGATE, n);
1272 }
1273
1274 static node*
cond(node * n)1275 cond(node *n)
1276 {
1277 return n;
1278 }
1279
1280 static node*
ret_args(parser_state * p,node * n)1281 ret_args(parser_state *p, node *n)
1282 {
1283 if (n->cdr) {
1284 yyerror(p, "block argument should not be given");
1285 return NULL;
1286 }
1287 if (!n->car->cdr) return n->car->car;
1288 return new_array(p, n->car);
1289 }
1290
1291 static void
assignable(parser_state * p,node * lhs)1292 assignable(parser_state *p, node *lhs)
1293 {
1294 if (intn(lhs->car) == NODE_LVAR) {
1295 local_add(p, sym(lhs->cdr));
1296 }
1297 }
1298
1299 static node*
var_reference(parser_state * p,node * lhs)1300 var_reference(parser_state *p, node *lhs)
1301 {
1302 node *n;
1303
1304 if (intn(lhs->car) == NODE_LVAR) {
1305 if (!local_var_p(p, sym(lhs->cdr))) {
1306 n = new_fcall(p, sym(lhs->cdr), 0);
1307 cons_free(lhs);
1308 return n;
1309 }
1310 }
1311
1312 return lhs;
1313 }
1314
1315 typedef enum mrb_string_type string_type;
1316
1317 static node*
new_strterm(parser_state * p,string_type type,int term,int paren)1318 new_strterm(parser_state *p, string_type type, int term, int paren)
1319 {
1320 return cons(nint(type), cons((node*)0, cons(nint(paren), nint(term))));
1321 }
1322
1323 static void
end_strterm(parser_state * p)1324 end_strterm(parser_state *p)
1325 {
1326 cons_free(p->lex_strterm->cdr->cdr);
1327 cons_free(p->lex_strterm->cdr);
1328 cons_free(p->lex_strterm);
1329 p->lex_strterm = NULL;
1330 }
1331
1332 static parser_heredoc_info *
parsing_heredoc_inf(parser_state * p)1333 parsing_heredoc_inf(parser_state *p)
1334 {
1335 node *nd = p->parsing_heredoc;
1336 if (nd == NULL)
1337 return NULL;
1338 /* mrb_assert(nd->car->car == NODE_HEREDOC); */
1339 return (parser_heredoc_info*)nd->car->cdr;
1340 }
1341
1342 static void
heredoc_treat_nextline(parser_state * p)1343 heredoc_treat_nextline(parser_state *p)
1344 {
1345 if (p->heredocs_from_nextline == NULL)
1346 return;
1347 if (p->parsing_heredoc == NULL) {
1348 node *n;
1349 p->parsing_heredoc = p->heredocs_from_nextline;
1350 p->lex_strterm_before_heredoc = p->lex_strterm;
1351 p->lex_strterm = new_strterm(p, parsing_heredoc_inf(p)->type, 0, 0);
1352 n = p->all_heredocs;
1353 if (n) {
1354 while (n->cdr)
1355 n = n->cdr;
1356 n->cdr = p->parsing_heredoc;
1357 }
1358 else {
1359 p->all_heredocs = p->parsing_heredoc;
1360 }
1361 }
1362 else {
1363 node *n, *m;
1364 m = p->heredocs_from_nextline;
1365 while (m->cdr)
1366 m = m->cdr;
1367 n = p->all_heredocs;
1368 mrb_assert(n != NULL);
1369 if (n == p->parsing_heredoc) {
1370 m->cdr = n;
1371 p->all_heredocs = p->heredocs_from_nextline;
1372 p->parsing_heredoc = p->heredocs_from_nextline;
1373 }
1374 else {
1375 while (n->cdr != p->parsing_heredoc) {
1376 n = n->cdr;
1377 mrb_assert(n != NULL);
1378 }
1379 m->cdr = n->cdr;
1380 n->cdr = p->heredocs_from_nextline;
1381 p->parsing_heredoc = p->heredocs_from_nextline;
1382 }
1383 }
1384 p->heredocs_from_nextline = NULL;
1385 }
1386
1387 static void
heredoc_end(parser_state * p)1388 heredoc_end(parser_state *p)
1389 {
1390 p->parsing_heredoc = p->parsing_heredoc->cdr;
1391 if (p->parsing_heredoc == NULL) {
1392 p->lstate = EXPR_BEG;
1393 end_strterm(p);
1394 p->lex_strterm = p->lex_strterm_before_heredoc;
1395 p->lex_strterm_before_heredoc = NULL;
1396 }
1397 else {
1398 /* next heredoc */
1399 p->lex_strterm->car = nint(parsing_heredoc_inf(p)->type);
1400 }
1401 }
1402 #define is_strterm_type(p,str_func) (intn((p)->lex_strterm->car) & (str_func))
1403
1404 /* xxx ----------------------------- */
1405
1406
1407 #line 1408 "mrbgems/mruby-compiler/core/y.tab.c"
1408
1409 # ifndef YY_CAST
1410 # ifdef __cplusplus
1411 # define YY_CAST(Type, Val) static_cast<Type> (Val)
1412 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
1413 # else
1414 # define YY_CAST(Type, Val) ((Type) (Val))
1415 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
1416 # endif
1417 # endif
1418 # ifndef YY_NULLPTR
1419 # if defined __cplusplus
1420 # if 201103L <= __cplusplus
1421 # define YY_NULLPTR nullptr
1422 # else
1423 # define YY_NULLPTR 0
1424 # endif
1425 # else
1426 # define YY_NULLPTR ((void*)0)
1427 # endif
1428 # endif
1429
1430 /* Enabling verbose error messages. */
1431 #ifdef YYERROR_VERBOSE
1432 # undef YYERROR_VERBOSE
1433 # define YYERROR_VERBOSE 1
1434 #else
1435 # define YYERROR_VERBOSE 1
1436 #endif
1437
1438
1439 /* Debug traces. */
1440 #ifndef YYDEBUG
1441 # define YYDEBUG 0
1442 #endif
1443 #if YYDEBUG
1444 extern int yydebug;
1445 #endif
1446
1447 /* Token type. */
1448 #ifndef YYTOKENTYPE
1449 # define YYTOKENTYPE
1450 enum yytokentype
1451 {
1452 keyword_class = 258,
1453 keyword_module = 259,
1454 keyword_def = 260,
1455 keyword_begin = 261,
1456 keyword_if = 262,
1457 keyword_unless = 263,
1458 keyword_while = 264,
1459 keyword_until = 265,
1460 keyword_for = 266,
1461 keyword_undef = 267,
1462 keyword_rescue = 268,
1463 keyword_ensure = 269,
1464 keyword_end = 270,
1465 keyword_then = 271,
1466 keyword_elsif = 272,
1467 keyword_else = 273,
1468 keyword_case = 274,
1469 keyword_when = 275,
1470 keyword_break = 276,
1471 keyword_next = 277,
1472 keyword_redo = 278,
1473 keyword_retry = 279,
1474 keyword_in = 280,
1475 keyword_do = 281,
1476 keyword_do_cond = 282,
1477 keyword_do_block = 283,
1478 keyword_do_LAMBDA = 284,
1479 keyword_return = 285,
1480 keyword_yield = 286,
1481 keyword_super = 287,
1482 keyword_self = 288,
1483 keyword_nil = 289,
1484 keyword_true = 290,
1485 keyword_false = 291,
1486 keyword_and = 292,
1487 keyword_or = 293,
1488 keyword_not = 294,
1489 modifier_if = 295,
1490 modifier_unless = 296,
1491 modifier_while = 297,
1492 modifier_until = 298,
1493 modifier_rescue = 299,
1494 keyword_alias = 300,
1495 keyword_BEGIN = 301,
1496 keyword_END = 302,
1497 keyword__LINE__ = 303,
1498 keyword__FILE__ = 304,
1499 keyword__ENCODING__ = 305,
1500 tIDENTIFIER = 306,
1501 tFID = 307,
1502 tGVAR = 308,
1503 tIVAR = 309,
1504 tCONSTANT = 310,
1505 tCVAR = 311,
1506 tLABEL_TAG = 312,
1507 tINTEGER = 313,
1508 tFLOAT = 314,
1509 tCHAR = 315,
1510 tXSTRING = 316,
1511 tREGEXP = 317,
1512 tSTRING = 318,
1513 tSTRING_PART = 319,
1514 tSTRING_MID = 320,
1515 tNTH_REF = 321,
1516 tBACK_REF = 322,
1517 tREGEXP_END = 323,
1518 tNUMPARAM = 324,
1519 tUPLUS = 325,
1520 tUMINUS = 326,
1521 tPOW = 327,
1522 tCMP = 328,
1523 tEQ = 329,
1524 tEQQ = 330,
1525 tNEQ = 331,
1526 tGEQ = 332,
1527 tLEQ = 333,
1528 tANDOP = 334,
1529 tOROP = 335,
1530 tMATCH = 336,
1531 tNMATCH = 337,
1532 tDOT2 = 338,
1533 tDOT3 = 339,
1534 tAREF = 340,
1535 tASET = 341,
1536 tLSHFT = 342,
1537 tRSHFT = 343,
1538 tCOLON2 = 344,
1539 tCOLON3 = 345,
1540 tOP_ASGN = 346,
1541 tASSOC = 347,
1542 tLPAREN = 348,
1543 tLPAREN_ARG = 349,
1544 tRPAREN = 350,
1545 tLBRACK = 351,
1546 tLBRACE = 352,
1547 tLBRACE_ARG = 353,
1548 tSTAR = 354,
1549 tDSTAR = 355,
1550 tAMPER = 356,
1551 tLAMBDA = 357,
1552 tANDDOT = 358,
1553 tSYMBEG = 359,
1554 tREGEXP_BEG = 360,
1555 tWORDS_BEG = 361,
1556 tSYMBOLS_BEG = 362,
1557 tSTRING_BEG = 363,
1558 tXSTRING_BEG = 364,
1559 tSTRING_DVAR = 365,
1560 tLAMBEG = 366,
1561 tHEREDOC_BEG = 367,
1562 tHEREDOC_END = 368,
1563 tLITERAL_DELIM = 369,
1564 tHD_LITERAL_DELIM = 370,
1565 tHD_STRING_PART = 371,
1566 tHD_STRING_MID = 372,
1567 tLOWEST = 373,
1568 tUMINUS_NUM = 374,
1569 tLAST_TOKEN = 375
1570 };
1571 #endif
1572
1573 /* Value type. */
1574 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1575 union YYSTYPE
1576 {
1577 #line 1350 "mrbgems/mruby-compiler/core/parse.y"
1578
1579 node *nd;
1580 mrb_sym id;
1581 int num;
1582 stack_type stack;
1583 const struct vtable *vars;
1584
1585 #line 1586 "mrbgems/mruby-compiler/core/y.tab.c"
1586
1587 };
1588 typedef union YYSTYPE YYSTYPE;
1589 # define YYSTYPE_IS_TRIVIAL 1
1590 # define YYSTYPE_IS_DECLARED 1
1591 #endif
1592
1593
1594
1595 int yyparse (parser_state *p);
1596
1597
1598
1599
1600
1601 #ifdef short
1602 # undef short
1603 #endif
1604
1605 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
1606 <limits.h> and (if available) <stdint.h> are included
1607 so that the code can choose integer types of a good width. */
1608
1609 #ifndef __PTRDIFF_MAX__
1610 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
1611 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
1612 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
1613 # define YY_STDINT_H
1614 # endif
1615 #endif
1616
1617 /* Narrow types that promote to a signed type and that can represent a
1618 signed or unsigned integer of at least N bits. In tables they can
1619 save space and decrease cache pressure. Promoting to a signed type
1620 helps avoid bugs in integer arithmetic. */
1621
1622 #ifdef __INT_LEAST8_MAX__
1623 typedef __INT_LEAST8_TYPE__ yytype_int8;
1624 #elif defined YY_STDINT_H
1625 typedef int_least8_t yytype_int8;
1626 #else
1627 typedef signed char yytype_int8;
1628 #endif
1629
1630 #ifdef __INT_LEAST16_MAX__
1631 typedef __INT_LEAST16_TYPE__ yytype_int16;
1632 #elif defined YY_STDINT_H
1633 typedef int_least16_t yytype_int16;
1634 #else
1635 typedef short yytype_int16;
1636 #endif
1637
1638 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
1639 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
1640 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
1641 && UINT_LEAST8_MAX <= INT_MAX)
1642 typedef uint_least8_t yytype_uint8;
1643 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
1644 typedef unsigned char yytype_uint8;
1645 #else
1646 typedef short yytype_uint8;
1647 #endif
1648
1649 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
1650 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
1651 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
1652 && UINT_LEAST16_MAX <= INT_MAX)
1653 typedef uint_least16_t yytype_uint16;
1654 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
1655 typedef unsigned short yytype_uint16;
1656 #else
1657 typedef int yytype_uint16;
1658 #endif
1659
1660 #ifndef YYPTRDIFF_T
1661 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
1662 # define YYPTRDIFF_T __PTRDIFF_TYPE__
1663 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
1664 # elif defined PTRDIFF_MAX
1665 # ifndef ptrdiff_t
1666 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1667 # endif
1668 # define YYPTRDIFF_T ptrdiff_t
1669 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
1670 # else
1671 # define YYPTRDIFF_T long
1672 # define YYPTRDIFF_MAXIMUM LONG_MAX
1673 # endif
1674 #endif
1675
1676 #ifndef YYSIZE_T
1677 # ifdef __SIZE_TYPE__
1678 # define YYSIZE_T __SIZE_TYPE__
1679 # elif defined size_t
1680 # define YYSIZE_T size_t
1681 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
1682 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
1683 # define YYSIZE_T size_t
1684 # else
1685 # define YYSIZE_T unsigned
1686 # endif
1687 #endif
1688
1689 #define YYSIZE_MAXIMUM \
1690 YY_CAST (YYPTRDIFF_T, \
1691 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
1692 ? YYPTRDIFF_MAXIMUM \
1693 : YY_CAST (YYSIZE_T, -1)))
1694
1695 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
1696
1697 /* Stored state numbers (used for stacks). */
1698 typedef yytype_int16 yy_state_t;
1699
1700 /* State numbers in computations. */
1701 typedef int yy_state_fast_t;
1702
1703 #ifndef YY_
1704 # if defined YYENABLE_NLS && YYENABLE_NLS
1705 # if ENABLE_NLS
1706 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
1707 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
1708 # endif
1709 # endif
1710 # ifndef YY_
1711 # define YY_(Msgid) Msgid
1712 # endif
1713 #endif
1714
1715 #ifndef YY_ATTRIBUTE_PURE
1716 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
1717 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
1718 # else
1719 # define YY_ATTRIBUTE_PURE
1720 # endif
1721 #endif
1722
1723 #ifndef YY_ATTRIBUTE_UNUSED
1724 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
1725 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
1726 # else
1727 # define YY_ATTRIBUTE_UNUSED
1728 # endif
1729 #endif
1730
1731 /* Suppress unused-variable warnings by "using" E. */
1732 #if ! defined lint || defined __GNUC__
1733 # define YYUSE(E) ((void) (E))
1734 #else
1735 # define YYUSE(E) /* empty */
1736 #endif
1737
1738 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
1739 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
1740 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
1741 _Pragma ("GCC diagnostic push") \
1742 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
1743 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
1744 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
1745 _Pragma ("GCC diagnostic pop")
1746 #else
1747 # define YY_INITIAL_VALUE(Value) Value
1748 #endif
1749 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1750 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1751 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
1752 #endif
1753 #ifndef YY_INITIAL_VALUE
1754 # define YY_INITIAL_VALUE(Value) /* Nothing. */
1755 #endif
1756
1757 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
1758 # define YY_IGNORE_USELESS_CAST_BEGIN \
1759 _Pragma ("GCC diagnostic push") \
1760 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
1761 # define YY_IGNORE_USELESS_CAST_END \
1762 _Pragma ("GCC diagnostic pop")
1763 #endif
1764 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
1765 # define YY_IGNORE_USELESS_CAST_BEGIN
1766 # define YY_IGNORE_USELESS_CAST_END
1767 #endif
1768
1769
1770 #define YY_ASSERT(E) ((void) (0 && (E)))
1771
1772 #if ! defined yyoverflow || YYERROR_VERBOSE
1773
1774 /* The parser invokes alloca or malloc; define the necessary symbols. */
1775
1776 # ifdef YYSTACK_USE_ALLOCA
1777 # if YYSTACK_USE_ALLOCA
1778 # ifdef __GNUC__
1779 # define YYSTACK_ALLOC __builtin_alloca
1780 # elif defined __BUILTIN_VA_ARG_INCR
1781 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1782 # elif defined _AIX
1783 # define YYSTACK_ALLOC __alloca
1784 # elif defined _MSC_VER
1785 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1786 # define alloca _alloca
1787 # else
1788 # define YYSTACK_ALLOC alloca
1789 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
1790 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1791 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
1792 # ifndef EXIT_SUCCESS
1793 # define EXIT_SUCCESS 0
1794 # endif
1795 # endif
1796 # endif
1797 # endif
1798 # endif
1799
1800 # ifdef YYSTACK_ALLOC
1801 /* Pacify GCC's 'empty if-body' warning. */
1802 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
1803 # ifndef YYSTACK_ALLOC_MAXIMUM
1804 /* The OS might guarantee only one guard page at the bottom of the stack,
1805 and a page size can be as small as 4096 bytes. So we cannot safely
1806 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1807 to allow for a few compiler-allocated temporary stack slots. */
1808 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1809 # endif
1810 # else
1811 # define YYSTACK_ALLOC YYMALLOC
1812 # define YYSTACK_FREE YYFREE
1813 # ifndef YYSTACK_ALLOC_MAXIMUM
1814 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1815 # endif
1816 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
1817 && ! ((defined YYMALLOC || defined malloc) \
1818 && (defined YYFREE || defined free)))
1819 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1820 # ifndef EXIT_SUCCESS
1821 # define EXIT_SUCCESS 0
1822 # endif
1823 # endif
1824 # ifndef YYMALLOC
1825 # define YYMALLOC malloc
1826 # if ! defined malloc && ! defined EXIT_SUCCESS
1827 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1828 # endif
1829 # endif
1830 # ifndef YYFREE
1831 # define YYFREE free
1832 # if ! defined free && ! defined EXIT_SUCCESS
1833 void free (void *); /* INFRINGES ON USER NAME SPACE */
1834 # endif
1835 # endif
1836 # endif
1837 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1838
1839
1840 #if (! defined yyoverflow \
1841 && (! defined __cplusplus \
1842 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1843
1844 /* A type that is properly aligned for any stack member. */
1845 union yyalloc
1846 {
1847 yy_state_t yyss_alloc;
1848 YYSTYPE yyvs_alloc;
1849 };
1850
1851 /* The size of the maximum gap between one aligned stack and the next. */
1852 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
1853
1854 /* The size of an array large to enough to hold all stacks, each with
1855 N elements. */
1856 # define YYSTACK_BYTES(N) \
1857 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
1858 + YYSTACK_GAP_MAXIMUM)
1859
1860 # define YYCOPY_NEEDED 1
1861
1862 /* Relocate STACK from its old location to the new one. The
1863 local variables YYSIZE and YYSTACKSIZE give the old and new number of
1864 elements in the stack, and YYPTR gives the new location of the
1865 stack. Advance YYPTR to a properly aligned location for the next
1866 stack. */
1867 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1868 do \
1869 { \
1870 YYPTRDIFF_T yynewbytes; \
1871 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1872 Stack = &yyptr->Stack_alloc; \
1873 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
1874 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
1875 } \
1876 while (0)
1877
1878 #endif
1879
1880 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1881 /* Copy COUNT objects from SRC to DST. The source and destination do
1882 not overlap. */
1883 # ifndef YYCOPY
1884 # if defined __GNUC__ && 1 < __GNUC__
1885 # define YYCOPY(Dst, Src, Count) \
1886 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
1887 # else
1888 # define YYCOPY(Dst, Src, Count) \
1889 do \
1890 { \
1891 YYPTRDIFF_T yyi; \
1892 for (yyi = 0; yyi < (Count); yyi++) \
1893 (Dst)[yyi] = (Src)[yyi]; \
1894 } \
1895 while (0)
1896 # endif
1897 # endif
1898 #endif /* !YYCOPY_NEEDED */
1899
1900 /* YYFINAL -- State number of the termination state. */
1901 #define YYFINAL 3
1902 /* YYLAST -- Last index in YYTABLE. */
1903 #define YYLAST 11586
1904
1905 /* YYNTOKENS -- Number of terminals. */
1906 #define YYNTOKENS 147
1907 /* YYNNTS -- Number of nonterminals. */
1908 #define YYNNTS 176
1909 /* YYNRULES -- Number of rules. */
1910 #define YYNRULES 594
1911 /* YYNSTATES -- Number of states. */
1912 #define YYNSTATES 1034
1913
1914 #define YYUNDEFTOK 2
1915 #define YYMAXUTOK 375
1916
1917
1918 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
1919 as returned by yylex, with out-of-bounds checking. */
1920 #define YYTRANSLATE(YYX) \
1921 (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1922
1923 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
1924 as returned by yylex. */
1925 static const yytype_uint8 yytranslate[] =
1926 {
1927 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1928 146, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1929 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1930 2, 2, 2, 133, 2, 2, 2, 131, 126, 2,
1931 142, 143, 129, 127, 140, 128, 145, 130, 2, 2,
1932 2, 2, 2, 2, 2, 2, 2, 2, 121, 144,
1933 123, 119, 122, 120, 2, 2, 2, 2, 2, 2,
1934 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1935 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1936 2, 138, 2, 139, 125, 2, 141, 2, 2, 2,
1937 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1938 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1939 2, 2, 2, 136, 124, 137, 134, 2, 2, 2,
1940 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1941 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1942 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1943 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1944 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1945 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1946 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1947 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1948 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1949 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1950 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1951 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1952 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1953 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1954 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1955 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1956 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1957 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1958 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1959 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1960 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
1961 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
1962 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
1963 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
1964 115, 116, 117, 118, 132, 135
1965 };
1966
1967 #if YYDEBUG
1968 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
1969 static const yytype_int16 yyrline[] =
1970 {
1971 0, 1508, 1508, 1508, 1519, 1525, 1529, 1534, 1538, 1544,
1972 1546, 1545, 1559, 1586, 1592, 1596, 1601, 1605, 1611, 1611,
1973 1615, 1619, 1623, 1627, 1631, 1635, 1639, 1644, 1645, 1649,
1974 1653, 1657, 1661, 1664, 1668, 1672, 1676, 1680, 1684, 1689,
1975 1693, 1700, 1701, 1705, 1709, 1710, 1714, 1718, 1722, 1726,
1976 1729, 1738, 1739, 1742, 1743, 1750, 1749, 1764, 1768, 1773,
1977 1777, 1782, 1786, 1791, 1795, 1799, 1803, 1807, 1813, 1817,
1978 1823, 1824, 1830, 1834, 1838, 1842, 1846, 1850, 1854, 1858,
1979 1862, 1866, 1872, 1873, 1879, 1883, 1889, 1893, 1899, 1903,
1980 1907, 1911, 1915, 1919, 1925, 1931, 1938, 1942, 1946, 1950,
1981 1954, 1958, 1964, 1970, 1975, 1981, 1985, 1988, 1992, 1996,
1982 2003, 2004, 2005, 2006, 2011, 2018, 2019, 2022, 2026, 2026,
1983 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041,
1984 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051,
1985 2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061,
1986 2064, 2064, 2064, 2065, 2065, 2066, 2066, 2066, 2067, 2067,
1987 2067, 2067, 2068, 2068, 2068, 2069, 2069, 2069, 2070, 2070,
1988 2070, 2070, 2071, 2071, 2071, 2071, 2072, 2072, 2072, 2072,
1989 2073, 2073, 2073, 2073, 2074, 2074, 2074, 2074, 2075, 2075,
1990 2078, 2082, 2086, 2090, 2094, 2098, 2102, 2107, 2112, 2117,
1991 2121, 2125, 2129, 2133, 2137, 2141, 2145, 2149, 2153, 2157,
1992 2161, 2165, 2169, 2173, 2177, 2181, 2185, 2189, 2193, 2197,
1993 2201, 2205, 2209, 2213, 2217, 2221, 2225, 2229, 2233, 2237,
1994 2241, 2245, 2249, 2255, 2256, 2261, 2265, 2272, 2276, 2284,
1995 2288, 2314, 2315, 2318, 2319, 2320, 2325, 2330, 2337, 2343,
1996 2348, 2353, 2358, 2365, 2365, 2376, 2382, 2386, 2392, 2393,
1997 2396, 2402, 2408, 2413, 2420, 2425, 2430, 2437, 2438, 2439,
1998 2440, 2441, 2442, 2443, 2444, 2448, 2453, 2452, 2464, 2468,
1999 2463, 2473, 2473, 2477, 2481, 2485, 2489, 2494, 2499, 2503,
2000 2507, 2511, 2515, 2519, 2520, 2526, 2532, 2525, 2544, 2552,
2001 2560, 2560, 2560, 2567, 2567, 2567, 2574, 2580, 2585, 2587,
2002 2584, 2596, 2594, 2612, 2617, 2610, 2634, 2632, 2649, 2653,
2003 2648, 2670, 2676, 2669, 2693, 2697, 2701, 2705, 2711, 2718,
2004 2719, 2720, 2723, 2724, 2727, 2728, 2736, 2737, 2743, 2747,
2005 2750, 2754, 2758, 2762, 2767, 2771, 2775, 2779, 2785, 2784,
2006 2794, 2798, 2802, 2806, 2812, 2817, 2822, 2826, 2830, 2834,
2007 2838, 2842, 2846, 2850, 2854, 2858, 2862, 2866, 2870, 2874,
2008 2878, 2884, 2889, 2896, 2896, 2900, 2905, 2912, 2916, 2922,
2009 2923, 2926, 2931, 2934, 2938, 2944, 2948, 2955, 2954, 2969,
2010 2979, 2983, 2988, 2995, 2999, 3003, 3007, 3011, 3015, 3019,
2011 3023, 3027, 3034, 3033, 3048, 3047, 3063, 3071, 3080, 3083,
2012 3090, 3093, 3097, 3098, 3101, 3105, 3108, 3112, 3115, 3116,
2013 3117, 3118, 3121, 3122, 3128, 3129, 3130, 3134, 3140, 3141,
2014 3147, 3152, 3151, 3162, 3166, 3172, 3176, 3182, 3186, 3192,
2015 3195, 3196, 3199, 3205, 3211, 3212, 3215, 3222, 3221, 3235,
2016 3239, 3246, 3251, 3258, 3264, 3265, 3266, 3267, 3268, 3272,
2017 3278, 3282, 3288, 3289, 3290, 3294, 3300, 3304, 3308, 3312,
2018 3316, 3322, 3326, 3332, 3336, 3340, 3344, 3348, 3352, 3360,
2019 3367, 3378, 3379, 3383, 3387, 3386, 3402, 3408, 3426, 3432,
2020 3438, 3444, 3451, 3456, 3463, 3467, 3473, 3477, 3483, 3484,
2021 3487, 3491, 3497, 3501, 3505, 3509, 3515, 3520, 3525, 3529,
2022 3533, 3537, 3541, 3545, 3549, 3553, 3557, 3561, 3565, 3569,
2023 3573, 3577, 3582, 3588, 3593, 3598, 3603, 3608, 3615, 3619,
2024 3626, 3631, 3630, 3642, 3646, 3652, 3660, 3668, 3676, 3680,
2025 3686, 3690, 3696, 3697, 3700, 3705, 3712, 3713, 3716, 3722,
2026 3726, 3732, 3737, 3737, 3762, 3763, 3769, 3774, 3780, 3781,
2027 3784, 3790, 3795, 3805, 3812, 3813, 3814, 3817, 3818, 3819,
2028 3820, 3823, 3824, 3825, 3828, 3829, 3832, 3836, 3842, 3843,
2029 3849, 3850, 3853, 3854, 3857, 3860, 3861, 3862, 3865, 3866,
2030 3867, 3870, 3877, 3878, 3882
2031 };
2032 #endif
2033
2034 #if YYDEBUG || YYERROR_VERBOSE || 1
2035 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
2036 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
2037 static const char *const yytname[] =
2038 {
2039 "$end", "error", "$undefined", "keyword_class", "keyword_module",
2040 "keyword_def", "keyword_begin", "keyword_if", "keyword_unless",
2041 "keyword_while", "keyword_until", "keyword_for", "keyword_undef",
2042 "keyword_rescue", "keyword_ensure", "keyword_end", "keyword_then",
2043 "keyword_elsif", "keyword_else", "keyword_case", "keyword_when",
2044 "keyword_break", "keyword_next", "keyword_redo", "keyword_retry",
2045 "keyword_in", "keyword_do", "keyword_do_cond", "keyword_do_block",
2046 "keyword_do_LAMBDA", "keyword_return", "keyword_yield", "keyword_super",
2047 "keyword_self", "keyword_nil", "keyword_true", "keyword_false",
2048 "keyword_and", "keyword_or", "keyword_not", "modifier_if",
2049 "modifier_unless", "modifier_while", "modifier_until", "modifier_rescue",
2050 "keyword_alias", "keyword_BEGIN", "keyword_END", "keyword__LINE__",
2051 "keyword__FILE__", "keyword__ENCODING__", "tIDENTIFIER", "tFID", "tGVAR",
2052 "tIVAR", "tCONSTANT", "tCVAR", "tLABEL_TAG", "tINTEGER", "tFLOAT",
2053 "tCHAR", "tXSTRING", "tREGEXP", "tSTRING", "tSTRING_PART", "tSTRING_MID",
2054 "tNTH_REF", "tBACK_REF", "tREGEXP_END", "tNUMPARAM", "tUPLUS", "tUMINUS",
2055 "tPOW", "tCMP", "tEQ", "tEQQ", "tNEQ", "tGEQ", "tLEQ", "tANDOP", "tOROP",
2056 "tMATCH", "tNMATCH", "tDOT2", "tDOT3", "tAREF", "tASET", "tLSHFT",
2057 "tRSHFT", "tCOLON2", "tCOLON3", "tOP_ASGN", "tASSOC", "tLPAREN",
2058 "tLPAREN_ARG", "tRPAREN", "tLBRACK", "tLBRACE", "tLBRACE_ARG", "tSTAR",
2059 "tDSTAR", "tAMPER", "tLAMBDA", "tANDDOT", "tSYMBEG", "tREGEXP_BEG",
2060 "tWORDS_BEG", "tSYMBOLS_BEG", "tSTRING_BEG", "tXSTRING_BEG",
2061 "tSTRING_DVAR", "tLAMBEG", "tHEREDOC_BEG", "tHEREDOC_END",
2062 "tLITERAL_DELIM", "tHD_LITERAL_DELIM", "tHD_STRING_PART",
2063 "tHD_STRING_MID", "tLOWEST", "'='", "'?'", "':'", "'>'", "'<'", "'|'",
2064 "'^'", "'&'", "'+'", "'-'", "'*'", "'/'", "'%'", "tUMINUS_NUM", "'!'",
2065 "'~'", "tLAST_TOKEN", "'{'", "'}'", "'['", "']'", "','", "'`'", "'('",
2066 "')'", "';'", "'.'", "'\\n'", "$accept", "program", "$@1",
2067 "top_compstmt", "top_stmts", "top_stmt", "@2", "bodystmt", "compstmt",
2068 "stmts", "stmt", "$@3", "command_asgn", "command_rhs", "expr",
2069 "expr_value", "command_call", "block_command", "cmd_brace_block", "$@4",
2070 "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_list",
2071 "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
2072 "undef_list", "$@5", "op", "reswords", "arg", "aref_args", "arg_rhs",
2073 "paren_args", "opt_paren_args", "opt_call_args", "call_args",
2074 "command_args", "@6", "block_arg", "opt_block_arg", "comma", "args",
2075 "mrhs", "primary", "@7", "@8", "$@9", "$@10", "@11", "@12", "$@13",
2076 "$@14", "$@15", "$@16", "$@17", "$@18", "@19", "@20", "@21", "@22",
2077 "@23", "@24", "@25", "@26", "primary_value", "then", "do", "if_tail",
2078 "opt_else", "for_var", "f_margs", "$@27", "block_args_tail",
2079 "opt_block_args_tail", "block_param", "opt_block_param",
2080 "block_param_def", "$@28", "opt_bv_decl", "bv_decls", "bvar",
2081 "f_larglist", "lambda_body", "do_block", "$@29", "block_call",
2082 "method_call", "brace_block", "@30", "@31", "case_body", "cases",
2083 "opt_rescue", "exc_list", "exc_var", "opt_ensure", "literal", "string",
2084 "string_fragment", "string_rep", "string_interp", "@32", "xstring",
2085 "regexp", "heredoc", "heredoc_bodies", "heredoc_body",
2086 "heredoc_string_rep", "heredoc_string_interp", "@33", "words", "symbol",
2087 "basic_symbol", "sym", "symbols", "numeric", "variable", "var_lhs",
2088 "var_ref", "backref", "superclass", "$@34", "f_arglist", "f_label",
2089 "f_kw", "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark",
2090 "f_kwrest", "args_tail", "opt_args_tail", "f_args", "f_bad_arg",
2091 "f_norm_arg", "f_arg_item", "@35", "f_arg", "f_opt_asgn", "f_opt",
2092 "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
2093 "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
2094 "singleton", "$@36", "assoc_list", "assocs", "label_tag", "assoc",
2095 "operation", "operation2", "operation3", "dot_or_colon", "call_op",
2096 "call_op2", "opt_terms", "opt_nl", "rparen", "trailer", "term", "nl",
2097 "terms", "none", YY_NULLPTR
2098 };
2099 #endif
2100
2101 # ifdef YYPRINT
2102 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
2103 (internal) symbol number NUM (which must be that of a token). */
2104 static const yytype_int16 yytoknum[] =
2105 {
2106 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
2107 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
2108 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
2109 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
2110 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
2111 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
2112 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
2113 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
2114 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
2115 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
2116 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
2117 365, 366, 367, 368, 369, 370, 371, 372, 373, 61,
2118 63, 58, 62, 60, 124, 94, 38, 43, 45, 42,
2119 47, 37, 374, 33, 126, 375, 123, 125, 91, 93,
2120 44, 96, 40, 41, 59, 46, 10
2121 };
2122 # endif
2123
2124 #define YYPACT_NINF (-829)
2125
2126 #define yypact_value_is_default(Yyn) \
2127 ((Yyn) == YYPACT_NINF)
2128
2129 #define YYTABLE_NINF (-595)
2130
2131 #define yytable_value_is_error(Yyn) \
2132 ((Yyn) == YYTABLE_NINF)
2133
2134 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
2135 STATE-NUM. */
2136 static const yytype_int16 yypact[] =
2137 {
2138 -829, 164, 2491, -829, 7022, 8994, 9330, 5100, -829, 8646,
2139 8646, -829, -829, 9106, 6520, 4956, 7370, 7370, -829, -829,
2140 7370, 2735, 5870, -829, -829, -829, -829, -39, 6520, -829,
2141 36, -829, -829, -829, 5240, 5380, -829, -829, 5520, -829,
2142 -829, -829, -829, -829, -829, -829, 20, 8762, 8762, 129,
2143 4227, 1481, 7602, 7950, 6798, -829, 6242, 614, 927, 1024,
2144 1126, 839, -829, 410, 8878, 8762, -829, 852, -829, 1251,
2145 -829, 448, -829, -829, 166, 171, -829, 80, 9218, -829,
2146 198, 11318, 299, 402, 21, 59, -829, 354, -829, -829,
2147 -829, -829, -829, -829, -829, -829, -829, 203, 165, -829,
2148 340, 137, -829, -829, -829, -829, -829, 159, 159, 177,
2149 72, 552, -829, 8646, 99, 4344, 607, -829, 200, -829,
2150 494, -829, -829, 137, -829, -829, -829, -829, -829, -829,
2151 -829, -829, -829, -829, -829, -829, -829, -829, -829, -829,
2152 -829, -829, -829, -829, -829, -829, -829, -829, -829, -829,
2153 -829, -829, 33, 44, 47, 101, -829, -829, -829, -829,
2154 -829, -829, 170, 218, 219, 227, -829, 229, -829, -829,
2155 -829, -829, -829, -829, -829, -829, -829, -829, -829, -829,
2156 -829, -829, -829, -829, -829, -829, -829, -829, -829, -829,
2157 -829, -829, -829, -829, -829, -829, -829, -829, -829, -829,
2158 -829, -829, -829, 240, 3417, 270, 448, 83, 225, 526,
2159 61, 247, 86, 83, 8646, 8646, 539, 306, -829, -829,
2160 609, 329, 95, 110, -829, -829, -829, -829, -829, -829,
2161 -829, -829, -829, 6381, -829, -829, 253, -829, -829, -829,
2162 -829, -829, -829, 852, -829, 264, -829, 386, -829, -829,
2163 852, 2601, 8762, 8762, 8762, 8762, -829, 11297, -829, -829,
2164 271, 361, 271, -829, -829, -829, 7138, -829, -829, -829,
2165 7370, -829, -829, -829, 4956, 8646, -829, -829, 286, 4461,
2166 -829, 796, 355, 398, 7254, 4227, 302, 852, 1251, 852,
2167 323, -829, 7254, 852, 325, 1517, 1517, -829, 11297, 316,
2168 1517, -829, 421, 9442, 370, 798, 826, 859, 1597, -829,
2169 -829, -829, -829, 1166, -829, -829, -829, -829, -829, -829,
2170 679, 749, -829, -829, 1186, -829, 1195, -829, 1257, -829,
2171 860, 444, 446, -829, -829, -829, -829, 4722, 8646, 8646,
2172 8646, 8646, 7254, 8646, 8646, -829, -829, 8066, -829, 4227,
2173 6910, 392, 8066, 8762, 8762, 8762, 8762, 8762, 8762, 8762,
2174 8762, 8762, 8762, 8762, 8762, 8762, 8762, 8762, 8762, 8762,
2175 8762, 8762, 8762, 8762, 8762, 8762, 8762, 8762, 8762, 9714,
2176 -829, 7370, -829, 9798, -829, -829, 10974, -829, -829, -829,
2177 -829, 8878, 8878, -829, 428, -829, 448, -829, 961, -829,
2178 -829, -829, -829, -829, 9882, 7370, 9966, 3417, 8646, -829,
2179 -829, -829, -829, 522, 528, 149, -829, 3561, 533, 8762,
2180 10050, 7370, 10134, 8762, 8762, 3849, 126, 126, 113, 10218,
2181 7370, 10302, -829, 501, -829, 4461, 386, -829, -829, 8182,
2182 542, -829, 679, 8762, 11318, 11318, 11318, 8762, 476, -829,
2183 7486, -829, 8762, -829, 7718, 852, 425, 852, 271, 271,
2184 -829, -829, 745, 431, -829, -829, 6520, 3966, 443, 10050,
2185 10134, 8762, 1251, 852, -829, -829, 4839, 445, 1251, -829,
2186 -829, 7834, -829, 852, 7950, -829, -829, -829, 961, 80,
2187 9442, -829, 9442, 10386, 7370, 10470, 30, -829, -829, -829,
2188 -829, -829, -829, -829, -829, -829, -829, -829, -829, 1719,
2189 -829, 8762, -829, 451, 554, 472, -829, -829, -829, -829,
2190 -829, 479, 8762, -829, 497, 596, 511, 608, -829, -829,
2191 1283, 4461, 679, -829, -829, -829, -829, -829, -829, -829,
2192 8762, 8762, -829, -829, -829, -829, -829, -829, -829, -829,
2193 153, 8762, -829, 11121, 271, -829, 852, 9442, 532, -829,
2194 -829, -829, 570, 572, 2302, -829, -829, 976, 180, 355,
2195 2331, 2331, 2331, 2331, 1479, 1479, 11455, 11395, 2331, 2331,
2196 11378, 11378, 671, 671, 11061, 1479, 1479, 1462, 1462, 1490,
2197 175, 175, 355, 355, 355, 2869, 5986, 3137, 6102, -829,
2198 159, -829, 550, 437, -829, 563, -829, -829, 5870, -829,
2199 -829, 2061, 153, 153, -829, 11044, -829, -829, -829, -829,
2200 -829, 852, 8646, 3417, 736, 813, -829, 159, 560, 159,
2201 699, 745, 1650, 6659, -829, 8298, 706, -829, 690, -829,
2202 5636, 5753, 605, 268, 276, 706, -829, -829, -829, -829,
2203 79, 88, 613, 121, 140, 8646, 6520, 616, 740, 11318,
2204 450, -829, 679, 11318, 11318, 679, 8762, 11297, -829, 271,
2205 11318, -829, -829, -829, -829, 7486, 7718, -829, -829, -829,
2206 623, -829, -829, 136, 1251, 852, 1517, 392, -829, 736,
2207 813, 626, 959, 1023, -829, -829, 1123, 622, 77, 11318,
2208 768, -829, -829, -829, 201, -829, 1719, -829, 11318, 1719,
2209 -829, -829, 1907, -829, -829, -829, 637, -829, 355, 355,
2210 -829, 1719, 3417, -829, -829, 11140, 8414, -829, -829, 9442,
2211 7254, 8878, 8762, 10554, 7370, 10638, 70, 8878, 8878, -829,
2212 428, 672, 8878, 8878, -829, 428, 59, 166, 3417, 4461,
2213 153, -829, 852, 762, -829, -829, -829, 1826, 3417, 852,
2214 -829, 11121, -829, 689, -829, 4110, 774, -829, 8646, 779,
2215 -829, 8762, 8762, 358, 8762, 8762, 800, 4605, 4605, 156,
2216 126, -829, -829, -829, 8530, 3705, 679, 11318, -829, 271,
2217 -829, -829, -829, 192, -829, 104, 852, 676, 674, 678,
2218 3417, 4461, -829, 766, -829, 472, -829, -829, -829, 684,
2219 686, 687, -829, 691, 766, 687, -829, -829, 622, 622,
2220 9554, -829, 694, 472, 695, 9554, -829, 698, 701, -829,
2221 835, 8762, 11209, -829, -829, 11318, 3003, 3271, 712, 408,
2222 432, 8762, 8762, -829, -829, -829, -829, -829, 8878, -829,
2223 -829, -829, -829, -829, -829, -829, 840, 722, 4461, 3417,
2224 -829, -829, 852, 852, 845, -829, 1650, 9666, 83, -829,
2225 -829, 4605, -829, -829, 83, -829, 8762, -829, 855, 856,
2226 -829, 11318, 193, 7718, -829, 733, -829, 1530, -829, 680,
2227 868, 753, -829, 1719, -829, 1907, -829, 1907, -829, 1907,
2228 -829, -829, 769, 771, 837, 995, 768, -829, -829, 1282,
2229 -829, 995, 1719, -829, 1907, -829, -829, 11228, 439, 11318,
2230 11318, -829, -829, -829, -829, 761, 896, -829, -829, -829,
2231 3417, 862, -829, 1028, 826, 859, 3417, -829, 3561, -829,
2232 -829, 4605, -829, -829, -829, 1585, 1585, 547, -829, 22,
2233 -829, -829, -829, -829, 687, 778, 687, 687, -829, -829,
2234 -829, 10722, -829, 472, 768, -829, -829, 780, 792, 793,
2235 -829, 799, 793, -829, -829, 913, 961, 10806, 7370, 10890,
2236 528, 690, 935, 812, 812, 1585, 823, 680, -829, -829,
2237 1907, -829, -829, -829, 824, 828, -829, 1719, -829, 1907,
2238 -829, 1907, -829, 1907, -829, -829, -829, 736, 813, 834,
2239 357, 579, -829, -829, -829, 1585, 812, 1585, -829, 687,
2240 793, 842, 793, 793, 192, 812, -829, -829, 1907, -829,
2241 -829, -829, 793, -829
2242 };
2243
2244 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
2245 Performed when YYTABLE does not specify something else to do. Zero
2246 means the default is an error. */
2247 static const yytype_int16 yydefact[] =
2248 {
2249 2, 0, 0, 1, 0, 0, 0, 0, 276, 0,
2250 0, 300, 303, 0, 0, 580, 324, 325, 326, 327,
2251 288, 253, 400, 475, 474, 476, 477, 582, 0, 10,
2252 0, 479, 478, 480, 466, 275, 468, 467, 470, 469,
2253 462, 463, 424, 425, 481, 482, 274, 0, 0, 0,
2254 0, 278, 594, 594, 80, 295, 0, 0, 0, 0,
2255 0, 0, 439, 0, 0, 0, 3, 580, 6, 9,
2256 27, 32, 44, 52, 51, 0, 68, 0, 72, 82,
2257 0, 49, 232, 0, 53, 293, 267, 268, 422, 269,
2258 270, 271, 420, 419, 451, 421, 418, 473, 0, 272,
2259 273, 253, 5, 8, 324, 325, 288, 594, 400, 0,
2260 105, 106, 274, 0, 0, 0, 0, 108, 483, 328,
2261 0, 473, 273, 0, 316, 160, 170, 161, 157, 186,
2262 187, 188, 189, 168, 183, 176, 166, 165, 181, 164,
2263 163, 159, 184, 158, 171, 175, 177, 169, 162, 178,
2264 185, 180, 179, 172, 182, 167, 156, 174, 173, 155,
2265 153, 154, 150, 151, 152, 110, 112, 111, 145, 146,
2266 141, 123, 124, 125, 132, 129, 131, 126, 127, 147,
2267 148, 133, 134, 138, 142, 128, 130, 120, 121, 122,
2268 135, 136, 137, 139, 140, 143, 144, 149, 552, 318,
2269 113, 114, 551, 0, 0, 0, 50, 0, 0, 0,
2270 473, 0, 273, 0, 0, 0, 104, 0, 339, 338,
2271 0, 0, 473, 273, 179, 172, 182, 167, 150, 151,
2272 152, 110, 111, 0, 115, 117, 20, 116, 442, 447,
2273 446, 588, 591, 580, 590, 0, 444, 0, 592, 589,
2274 581, 564, 0, 0, 0, 0, 248, 260, 66, 252,
2275 594, 422, 594, 556, 67, 65, 594, 242, 289, 64,
2276 0, 241, 399, 63, 580, 0, 583, 18, 0, 0,
2277 209, 0, 210, 285, 0, 0, 0, 580, 15, 580,
2278 70, 14, 0, 580, 0, 585, 585, 233, 0, 0,
2279 585, 554, 0, 0, 78, 0, 88, 95, 522, 456,
2280 455, 457, 458, 0, 454, 453, 437, 431, 430, 433,
2281 0, 0, 428, 449, 0, 460, 0, 426, 0, 435,
2282 0, 464, 465, 48, 224, 225, 4, 581, 0, 0,
2283 0, 0, 0, 0, 0, 387, 389, 0, 84, 0,
2284 76, 73, 0, 0, 0, 0, 0, 0, 0, 0,
2285 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2286 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2287 577, 594, 576, 0, 579, 578, 0, 404, 402, 294,
2288 423, 0, 0, 393, 57, 292, 313, 105, 106, 107,
2289 464, 465, 484, 311, 0, 594, 0, 0, 0, 319,
2290 575, 574, 321, 0, 594, 285, 330, 0, 329, 0,
2291 0, 594, 0, 0, 0, 0, 0, 0, 285, 0,
2292 594, 0, 308, 0, 118, 0, 0, 443, 445, 0,
2293 0, 593, 558, 0, 261, 563, 255, 0, 258, 249,
2294 0, 257, 0, 250, 0, 580, 0, 580, 594, 594,
2295 243, 254, 580, 0, 291, 47, 0, 0, 0, 0,
2296 0, 0, 17, 580, 283, 13, 581, 69, 279, 282,
2297 286, 587, 234, 586, 587, 236, 287, 555, 94, 86,
2298 0, 81, 0, 0, 594, 0, 529, 525, 524, 523,
2299 526, 527, 498, 531, 543, 499, 547, 546, 542, 522,
2300 296, 491, 496, 594, 501, 594, 521, 384, 528, 530,
2301 533, 507, 0, 540, 507, 545, 507, 0, 505, 459,
2302 0, 0, 434, 440, 438, 429, 450, 461, 427, 436,
2303 0, 0, 7, 21, 22, 23, 24, 25, 45, 46,
2304 594, 0, 28, 30, 0, 31, 580, 0, 74, 85,
2305 43, 33, 41, 0, 237, 190, 29, 0, 273, 206,
2306 214, 219, 220, 221, 216, 218, 228, 229, 222, 223,
2307 199, 200, 226, 227, 582, 215, 217, 211, 212, 213,
2308 201, 202, 203, 204, 205, 567, 572, 568, 573, 398,
2309 253, 396, 0, 567, 569, 568, 570, 397, 594, 567,
2310 568, 253, 594, 594, 34, 237, 191, 40, 198, 55,
2311 58, 0, 0, 0, 105, 106, 109, 0, 0, 594,
2312 0, 580, 522, 0, 277, 594, 594, 410, 594, 331,
2313 571, 284, 0, 567, 568, 594, 333, 301, 332, 304,
2314 571, 284, 0, 567, 568, 0, 0, 0, 0, 260,
2315 0, 307, 559, 561, 560, 0, 0, 262, 256, 594,
2316 562, 557, 240, 239, 244, 245, 247, 290, 584, 19,
2317 0, 26, 197, 71, 16, 580, 585, 87, 79, 91,
2318 93, 0, 90, 92, 489, 535, 0, 582, 0, 490,
2319 0, 503, 550, 500, 0, 504, 0, 514, 536, 0,
2320 517, 544, 0, 519, 548, 452, 0, 441, 207, 208,
2321 375, 373, 0, 372, 371, 266, 0, 83, 77, 0,
2322 0, 0, 0, 0, 594, 0, 0, 0, 0, 395,
2323 61, 401, 0, 0, 394, 59, 390, 54, 0, 0,
2324 594, 314, 0, 0, 401, 317, 553, 522, 0, 0,
2325 322, 411, 412, 594, 413, 0, 594, 336, 0, 0,
2326 334, 0, 0, 401, 0, 0, 0, 0, 0, 401,
2327 0, 119, 448, 306, 0, 0, 259, 263, 251, 594,
2328 11, 280, 235, 89, 529, 347, 580, 340, 0, 377,
2329 0, 0, 297, 0, 497, 594, 549, 506, 534, 507,
2330 507, 507, 541, 507, 529, 507, 432, 370, 582, 582,
2331 493, 494, 594, 594, 355, 0, 538, 355, 355, 353,
2332 0, 0, 264, 75, 42, 238, 567, 568, 0, 567,
2333 568, 0, 0, 39, 195, 38, 196, 62, 0, 36,
2334 193, 37, 194, 60, 391, 392, 0, 0, 0, 0,
2335 485, 312, 580, 580, 0, 488, 522, 0, 0, 415,
2336 337, 0, 12, 417, 0, 298, 0, 299, 0, 0,
2337 309, 262, 594, 246, 348, 345, 532, 0, 383, 0,
2338 0, 0, 502, 0, 510, 0, 512, 0, 518, 0,
2339 515, 520, 0, 0, 0, 492, 0, 351, 352, 355,
2340 363, 537, 0, 366, 0, 368, 388, 265, 401, 231,
2341 230, 35, 192, 405, 403, 0, 0, 487, 486, 320,
2342 0, 0, 414, 0, 96, 103, 0, 416, 0, 302,
2343 305, 0, 407, 408, 406, 0, 0, 343, 381, 582,
2344 379, 382, 386, 385, 507, 507, 507, 507, 376, 374,
2345 285, 0, 495, 594, 0, 354, 361, 355, 355, 355,
2346 539, 355, 355, 56, 315, 0, 102, 0, 594, 0,
2347 594, 594, 0, 349, 346, 0, 341, 0, 378, 511,
2348 0, 508, 513, 516, 571, 284, 350, 0, 358, 0,
2349 360, 0, 367, 0, 364, 369, 323, 99, 101, 0,
2350 567, 568, 409, 335, 310, 0, 344, 0, 380, 507,
2351 355, 355, 355, 355, 97, 342, 509, 359, 0, 356,
2352 362, 365, 355, 357
2353 };
2354
2355 /* YYPGOTO[NTERM-NUM]. */
2356 static const yytype_int16 yypgoto[] =
2357 {
2358 -829, -829, -829, 510, -829, 32, -829, -214, 182, -829,
2359 28, -829, -155, -302, 867, 1, -16, -829, -536, -829,
2360 131, 971, -170, 4, -69, -266, -431, -15, 1295, -48,
2361 981, 19, 5, -829, -829, 24, -829, 653, -829, 413,
2362 75, -58, -352, 54, 13, -829, -390, -235, -11, 39,
2363 -303, 89, -829, -829, -829, -829, -829, -829, -829, -829,
2364 -829, -829, -829, -829, -829, -829, -829, -829, -829, -829,
2365 -829, -829, 8, -206, -382, 7, -568, -829, -829, -829,
2366 272, 538, -829, -512, -829, -829, -78, -829, 2, -829,
2367 -829, 255, -829, -829, -829, -65, -829, -829, -430, -829,
2368 14, -829, -829, -829, -829, -829, 154, 58, -196, -829,
2369 -829, -829, -829, -377, -257, -829, 787, -829, -829, -829,
2370 -6, -829, -829, -829, 1461, 1552, 1026, 1065, -829, -829,
2371 173, 314, 343, 141, -829, -829, -829, 524, -306, 246,
2372 -307, -801, -716, -519, -829, 474, -664, -627, -828, 142,
2373 346, -829, 236, -829, 517, -439, -829, -829, -829, 92,
2374 785, -411, 505, -339, -829, -829, -80, -829, 26, -22,
2375 -152, -254, 788, -12, -33, -2
2376 };
2377
2378 /* YYDEFGOTO[NTERM-NUM]. */
2379 static const yytype_int16 yydefgoto[] =
2380 {
2381 -1, 1, 2, 66, 67, 68, 278, 413, 414, 287,
2382 288, 466, 70, 561, 71, 207, 72, 73, 620, 750,
2383 74, 75, 289, 76, 77, 78, 491, 79, 208, 117,
2384 118, 234, 235, 236, 656, 598, 201, 81, 294, 565,
2385 599, 268, 456, 457, 269, 270, 259, 449, 484, 458,
2386 555, 82, 204, 292, 685, 293, 308, 698, 214, 777,
2387 215, 778, 655, 941, 623, 621, 859, 407, 409, 632,
2388 633, 866, 281, 417, 647, 769, 770, 221, 796, 945,
2389 965, 910, 818, 722, 723, 819, 798, 949, 950, 510,
2390 802, 346, 550, 84, 85, 395, 613, 612, 440, 944,
2391 636, 763, 868, 872, 86, 87, 88, 321, 322, 531,
2392 89, 90, 91, 532, 244, 245, 246, 435, 92, 93,
2393 94, 315, 95, 96, 210, 211, 99, 212, 403, 622,
2394 758, 511, 512, 821, 822, 513, 514, 515, 807, 707,
2395 759, 518, 519, 520, 696, 521, 522, 523, 826, 827,
2396 524, 525, 526, 527, 528, 701, 203, 408, 299, 459,
2397 443, 263, 123, 627, 601, 412, 406, 386, 463, 799,
2398 464, 482, 248, 249, 250, 291
2399 };
2400
2401 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
2402 positive, shift that token. If negative, reduce the rule whose
2403 number is the opposite. If YYTABLE_NINF, syntax error. */
2404 static const yytype_int16 yytable[] =
2405 {
2406 102, 517, 516, 383, 385, 275, 658, 425, 237, 351,
2407 83, 213, 83, 120, 120, 276, 243, 209, 209, 271,
2408 389, 220, 237, 209, 209, 209, 199, 453, 209, 602,
2409 69, 200, 69, 277, 337, 273, 103, 490, 200, 304,
2410 600, 247, 485, 671, 608, 649, 487, 611, 333, 566,
2411 297, 301, 200, 628, 290, 260, 260, 825, 83, 260,
2412 668, 688, 305, 533, 668, 662, 399, 629, 766, 642,
2413 258, 264, 209, 671, 265, 314, 705, 776, 652, 885,
2414 200, 600, 812, 608, 970, 387, 305, 694, 951, 614,
2415 617, 295, 629, 336, 119, 119, 267, 272, -564, 416,
2416 748, 749, 119, 274, -99, 271, 800, 242, 262, 262,
2417 384, -472, 262, -101, 394, 473, 324, 326, 328, 330,
2418 -96, 209, -475, 83, 380, 535, 728, 841, 535, 422,
2419 535, 629, 535, -474, 535, -103, -476, 477, -102, -104,
2420 431, 479, 691, 119, 296, 300, -98, 256, 256, 695,
2421 397, 256, -471, 646, 398, 794, 629, 497, 498, 499,
2422 500, -466, 987, 387, 3, -100, 382, 119, 242, 970,
2423 261, 261, 279, 501, 261, -466, 393, 424, -475, 556,
2424 -96, -97, 267, 272, 283, 533, 951, 808, 801, -474,
2425 -477, 842, -476, 630, 345, 388, 238, 560, 393, 239,
2426 240, 470, 697, 516, 847, -103, 261, 261, -564, 853,
2427 -466, 765, 83, 439, -564, 426, 427, -466, -401, -91,
2428 348, -567, 209, 209, 453, 495, 490, 241, -93, 242,
2429 -568, 986, 286, 720, 489, -88, 560, 560, 858, 238,
2430 471, 390, 239, 240, 884, 825, -477, 353, 825, 450,
2431 -95, 454, 314, -94, 476, -69, 391, 200, 451, -479,
2432 451, -90, 483, 483, 460, 671, 812, 483, -102, 436,
2433 241, 392, 242, 388, 209, 717, -83, 721, 209, 266,
2434 -92, -401, 209, 209, 481, 668, 668, 83, 786, 290,
2435 347, 490, 83, 83, -471, -401, -89, 286, 833, -103,
2436 83, 266, 506, 672, 376, 377, 378, -478, -480, 260,
2437 677, 305, 472, 475, 942, -479, -466, 352, -470, 274,
2438 478, 683, -96, 402, 461, 415, 516, 507, -401, 410,
2439 -401, 552, 762, 825, 535, 558, 562, -401, 423, 543,
2440 544, 545, 546, -88, 419, 83, 209, 209, 209, 209,
2441 83, 209, 209, 290, 432, 209, 626, 83, 305, 774,
2442 567, 428, 262, -478, -480, 69, 892, 775, 808, 542,
2443 547, 530, -466, -98, -470, 562, 562, 437, 808, 460,
2444 239, 240, 838, 907, 908, 411, 554, -98, -328, 209,
2445 808, 554, 119, 434, 600, -100, 608, 256, 880, 567,
2446 567, 256, -328, 460, 727, 717, 439, 606, 533, 753,
2447 606, 448, 637, 209, 42, 83, 209, 43, 442, 460,
2448 261, 687, 467, 489, 261, 83, 665, 353, 460, 209,
2449 606, 392, 792, 83, 788, 843, 276, -328, 209, 119,
2450 849, 851, -68, 83, -328, 474, 606, 675, 676, 876,
2451 863, 516, 943, 486, 785, 606, 451, 451, 607, -103,
2452 237, 468, 60, 490, 480, 102, 416, 286, 331, 332,
2453 -98, 679, 671, -98, -98, 83, 488, -97, 660, 756,
2454 -95, 607, 808, 674, 83, 343, 344, 735, 489, 471,
2455 200, 379, 460, 668, 606, 69, 808, 607, 305, 742,
2456 305, -98, 209, -98, 684, 380, 607, 101, 830, 101,
2457 492, 702, 256, 702, 101, 101, 540, -102, 541, 606,
2458 101, 101, 101, 743, 996, 101, 619, -98, 742, 717,
2459 848, 286, 559, 791, 856, 261, 256, 634, -94, 83,
2460 381, 635, 669, 726, 864, 607, 921, 382, 724, 639,
2461 744, -100, 256, 746, 788, 101, -98, 661, -97, 261,
2462 516, 256, 736, 238, 529, 305, 239, 240, 673, 101,
2463 607, 744, 276, 686, 678, 261, 560, -90, -565, 119,
2464 681, 119, 560, 404, 261, -83, 890, 560, 560, -582,
2465 448, 700, -582, -582, 241, -100, 242, 380, 794, 638,
2466 497, 498, 499, 500, 261, 703, 271, 645, 261, 271,
2467 724, 724, 704, 740, 730, 420, 501, 657, 101, 706,
2468 101, 745, 242, 752, 747, 256, 1009, 271, -274, 380,
2469 209, 83, 405, 764, 767, 261, 767, 709, 261, 382,
2470 629, -470, -274, 767, 886, 926, 119, 711, 261, 784,
2471 237, 712, 760, 483, 743, -470, 780, 200, 454, 714,
2472 489, 781, 936, 209, 421, 400, 401, 451, 938, 257,
2473 257, 382, 729, 257, 554, 739, 316, -274, 317, 318,
2474 200, 854, -100, 267, -274, 276, 267, 985, -565, 741,
2475 -470, 731, -100, 560, -565, -100, -100, -470, 429, 754,
2476 280, 282, 739, -92, 267, 257, 298, 768, 765, 101,
2477 927, 928, 380, 716, 755, 562, 975, 334, 335, 101,
2478 101, 562, 845, -100, 765, -100, 562, 562, 319, 320,
2479 83, 948, 460, 497, 498, 499, 500, 305, 83, 567,
2480 902, 903, 209, 353, 773, 567, 209, 430, 724, 501,
2481 567, 567, 779, 782, 382, 783, 83, 83, 834, 606,
2482 790, 869, -571, 848, 873, 793, 83, 789, 242, 874,
2483 710, 101, 713, 83, 816, 101, 209, 861, 883, 101,
2484 101, 867, 343, 344, 101, 83, 83, 451, 871, 101,
2485 101, -97, 238, 83, 875, 239, 240, 101, 374, 375,
2486 376, 377, 378, 702, 616, 618, 276, 276, 83, 83,
2487 607, 534, -89, 317, 318, 877, 887, 888, 119, 803,
2488 702, 702, 889, 694, 893, -571, 895, 897, 905, 261,
2489 261, 899, 562, 911, 906, 909, 616, 618, 912, -571,
2490 502, 914, 101, 101, 101, 101, 101, 101, 101, 101,
2491 916, 918, 101, 979, 101, 923, 567, 101, 238, 924,
2492 929, 239, 240, 319, 320, 256, 83, 83, 505, 506,
2493 939, 940, -571, 946, -571, 933, 206, 206, -567, 83,
2494 767, -571, 206, 952, 682, 469, 101, 493, 261, 241,
2495 953, 242, 960, 958, 507, 959, 101, 101, 973, 380,
2496 329, 380, -284, 317, 318, 444, 445, 446, 334, 119,
2497 101, 974, 101, 101, 119, -473, -284, 976, 990, 257,
2498 997, 539, 101, 257, 317, 318, 101, 988, 1006, -473,
2499 101, 857, 999, 1001, 421, 101, 494, 276, 83, 1003,
2500 101, 382, 810, 382, 83, 813, 83, 870, -273, 83,
2501 1014, -284, 1015, 319, 320, -568, 119, 828, -284, 878,
2502 879, 702, -273, 1017, -473, 238, -567, 882, 239, 240,
2503 -568, -473, 101, 1024, 319, 320, 460, 680, 637, 767,
2504 396, 101, 1028, 891, 218, -567, 209, 124, 1013, 1018,
2505 323, 317, 318, 817, 1012, 418, 241, -273, 242, 101,
2506 553, 418, 855, 606, -273, 564, 569, 570, 571, 572,
2507 573, 574, 575, 576, 577, 578, 579, 580, 581, 582,
2508 583, 584, 585, 586, 587, 588, 589, 590, 591, 592,
2509 593, 594, 438, 202, 257, 820, 101, 261, 441, 930,
2510 925, 319, 320, 804, 615, 615, 452, 962, -567, -568,
2511 -285, 967, 809, 937, 607, 894, 896, 898, 257, 900,
2512 0, 901, -567, 0, -285, 733, 0, 100, 0, 100,
2513 122, 122, 615, 0, 257, 0, 615, 615, 223, 380,
2514 0, 206, 206, 257, 961, 0, 0, 325, 317, 318,
2515 0, 0, 659, 0, 0, -567, 663, -567, 380, -285,
2516 664, -567, 0, 667, -567, 670, -285, 298, 0, 256,
2517 0, 0, -568, 0, 734, 100, 0, 977, 980, 307,
2518 981, 382, 0, 982, 615, 441, -568, 101, 101, 955,
2519 0, 380, 261, 405, 667, 0, 0, 298, 319, 320,
2520 382, 462, 465, 307, 0, 968, 0, 257, 971, 0,
2521 844, 846, 0, 0, 0, 850, 852, 0, 0, -568,
2522 101, -568, 0, 0, 699, -568, 978, 0, -568, 0,
2523 797, 0, 0, 382, 794, 708, 497, 498, 499, 500,
2524 100, 0, 0, 811, 844, 846, 815, 850, 852, 327,
2525 317, 318, 501, 718, 719, 824, 0, 0, 0, 0,
2526 989, 991, 992, 993, 725, 206, 206, 206, 206, 0,
2527 548, 549, 0, 0, 648, 648, 503, 806, 0, 0,
2528 820, 806, 795, 820, 805, 0, 820, 101, 820, 529,
2529 317, 318, 0, 1021, 0, 101, 101, 0, 829, 101,
2530 319, 320, 101, 101, 0, 823, 0, 101, 101, 536,
2531 317, 318, 0, 101, 101, 0, 0, 0, 537, 317,
2532 318, 922, 0, 101, 441, 1026, 0, 0, 0, 100,
2533 101, 441, 0, 101, 0, 631, 0, 0, 820, 0,
2534 319, 320, 101, 101, 0, 0, 0, 0, 761, 922,
2535 101, 338, 339, 340, 341, 342, 0, 80, 0, 80,
2536 319, 320, 0, 0, 0, 101, 101, 0, 219, 319,
2537 320, 820, 0, 820, 0, 820, 0, 820, 0, 787,
2538 538, 317, 318, 0, 0, 0, 0, 0, 667, 298,
2539 0, 0, 0, 496, 0, 497, 498, 499, 500, 0,
2540 0, 0, 820, 0, 100, 80, 715, 317, 318, 100,
2541 100, 501, 0, 101, 502, 0, 0, 100, 0, 0,
2542 0, 0, 0, 101, 101, 913, 915, 954, 307, 956,
2543 0, 319, 320, 957, 0, 503, 101, 0, 0, 832,
2544 0, 504, 505, 506, 615, 835, 969, 257, 972, 0,
2545 615, 615, 0, 0, 0, 615, 615, 319, 320, 0,
2546 0, 0, 100, 0, 0, 0, 0, 100, 507, 751,
2547 80, 508, 0, 0, 100, 307, 0, 568, 0, 983,
2548 984, 0, 964, 806, 615, 615, 829, 615, 615, 829,
2549 963, 829, 0, 823, 0, 101, 823, 881, 823, 0,
2550 0, 101, 0, 101, 0, 0, 101, 966, 418, 0,
2551 0, 0, 0, 0, 0, 0, 568, 568, 0, 1016,
2552 0, 0, 0, 97, 1019, 97, 121, 121, 121, 0,
2553 0, 1020, 100, 1022, 222, 0, 0, 1023, 0, 0,
2554 0, 829, 100, 101, 917, 0, 0, 0, 823, 206,
2555 100, 1025, 0, 0, 919, 920, 0, 0, 0, 80,
2556 100, 615, 1032, 0, 0, 998, 1000, 1002, 0, 1004,
2557 1005, 97, 0, 0, 829, 306, 829, 0, 829, 0,
2558 829, 823, 206, 823, 0, 823, 0, 823, 0, 615,
2559 0, 0, 100, 0, 353, 0, 298, 0, 0, 306,
2560 860, 100, 0, 0, 0, 829, 0, 865, 0, 366,
2561 367, 353, 823, 0, 98, 307, 98, 307, 1027, 1029,
2562 1030, 1031, 353, 0, 0, 0, 366, 367, 648, 0,
2563 1033, 0, 0, 0, 80, 0, 97, 366, 367, 80,
2564 80, 794, 0, 497, 498, 499, 500, 80, 373, 374,
2565 375, 376, 377, 378, -281, 0, 100, -281, -281, 501,
2566 0, 0, 98, 371, 372, 373, 374, 375, 376, 377,
2567 378, 0, 0, 0, 0, 0, 0, 374, 375, 376,
2568 377, 378, 307, 503, -281, -281, 0, -281, 0, 947,
2569 238, 257, 80, 239, 240, 206, 794, 80, 497, 498,
2570 499, 500, 0, 0, 80, 0, 0, 563, 496, 0,
2571 497, 498, 499, 500, 501, 0, 418, 448, 0, 0,
2572 0, 241, 418, 242, 0, 97, 501, 98, 0, 502,
2573 0, 0, 0, 0, 0, 0, 0, 0, 503, 0,
2574 0, 0, 0, 0, 0, 0, 563, 563, 100, 0,
2575 503, 0, 0, 0, 0, 0, 504, 505, 506, 0,
2576 0, 496, 80, 497, 498, 499, 500, 0, 0, 0,
2577 0, 0, 80, 0, 0, 0, 0, 0, 0, 501,
2578 80, 0, 502, 507, 0, 0, 508, 0, 0, 0,
2579 80, 0, 0, 0, 0, 0, 0, 0, 0, 509,
2580 97, 0, 0, 503, 0, 97, 97, 0, 0, 504,
2581 505, 506, 0, 97, 0, 0, 98, 0, 0, 0,
2582 0, 0, 80, 0, 306, 0, 0, 0, 0, 0,
2583 496, 80, 497, 498, 499, 500, 507, 0, 0, 508,
2584 0, 0, 0, 0, 0, 0, 0, 100, 501, 0,
2585 0, 502, 757, 0, 307, 100, 568, 0, 97, 0,
2586 0, 0, 568, 97, 0, 0, 0, 568, 568, 0,
2587 97, 306, 503, 100, 100, 0, 0, 0, 504, 505,
2588 506, 0, 0, 100, 0, 0, 80, 0, 0, 0,
2589 100, 98, 0, 0, 0, 0, 98, 98, 0, 0,
2590 0, 0, 100, 100, 98, 507, 0, 0, 508, 0,
2591 100, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2592 0, 0, 0, 0, 0, 100, 100, 0, 97, 0,
2593 0, 0, 0, 0, 0, 0, 0, 496, 97, 497,
2594 498, 499, 500, 0, 0, 122, 97, 0, 0, 98,
2595 122, 0, 0, 0, 98, 501, 97, 0, 502, 0,
2596 0, 98, 0, 0, 98, 0, 0, 0, 0, 0,
2597 862, 0, 0, 568, 0, 0, 0, 0, 80, 503,
2598 0, 0, 0, 100, 100, 504, 505, 506, 97, 0,
2599 0, 0, 935, 0, 0, 0, 100, 97, 0, 0,
2600 0, 0, 0, 98, 98, 0, 0, 0, 0, 0,
2601 0, 306, 507, 306, 0, 508, 0, 0, 814, 98,
2602 497, 498, 499, 500, 0, 0, 0, 0, 0, 98,
2603 0, 0, 0, 0, 0, 0, 501, 98, 0, 502,
2604 0, 0, 0, 0, 0, 0, 0, 98, 0, 0,
2605 0, 0, 97, 0, 0, 100, 0, 0, 0, 0,
2606 503, 100, 0, 100, 0, 0, 100, 505, 506, 0,
2607 0, 0, 0, 0, 0, 0, 0, 80, 306, 98,
2608 0, 0, 0, 0, 0, 80, 563, 0, 98, 0,
2609 0, 0, 563, 507, 0, 0, 0, 563, 563, 0,
2610 0, 0, 0, 80, 80, 0, 0, 0, 0, 0,
2611 0, 0, 0, 80, 0, 0, 0, 0, 0, 0,
2612 80, -594, 0, 0, 0, 0, 0, 0, 0, 0,
2613 0, 0, 80, 80, -594, -594, -594, -594, -594, -594,
2614 80, -594, 0, 98, 97, 0, 0, -594, -594, 0,
2615 0, 0, 0, 0, 0, 80, 80, 0, -594, -594,
2616 0, -594, -594, -594, -594, -594, 0, 0, 0, 0,
2617 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2618 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2619 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2620 0, 0, 0, 563, 0, 0, 0, 0, 0, 0,
2621 -594, 0, 0, 80, 80, 0, 0, 0, 0, 0,
2622 0, 0, 932, 0, -594, 0, 80, 0, 0, 0,
2623 0, 0, 0, 0, -594, 98, 0, -594, -594, 0,
2624 0, 0, 0, 97, 0, 0, 0, 0, 0, 0,
2625 306, 97, 0, 0, 0, 0, 0, -594, -594, 0,
2626 0, 0, 0, 266, -594, -594, -594, -594, 0, 97,
2627 97, 0, 0, 0, 0, 0, 0, 0, 0, 97,
2628 0, 0, 0, 0, 0, 80, 97, 0, 0, 0,
2629 0, 80, 0, 80, 0, 0, 80, 0, 97, 97,
2630 0, 0, 0, 0, 0, 0, 97, 0, 0, 0,
2631 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2632 0, 97, 97, 0, 0, 0, 0, 0, 0, 0,
2633 0, 0, 0, 0, 98, 0, 0, 0, 0, 0,
2634 0, 121, 98, 98, 0, 0, 121, 0, 0, 98,
2635 0, 0, 0, 0, 98, 98, 0, 0, 0, 0,
2636 98, 98, 0, 0, 0, 0, 0, 0, 0, 0,
2637 98, 0, 0, 0, 0, 0, 0, 98, 0, 97,
2638 97, 0, 0, 0, 0, 0, 0, 0, 934, 98,
2639 98, 0, 97, 0, 0, 0, 0, 98, 0, 0,
2640 0, 0, 0, 0, 0, 0, 732, 0, 0, 0,
2641 0, 0, 98, 98, 0, 0, 0, 0, 0, 0,
2642 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2643 0, 0, 0, 0, 353, 354, 355, 356, 357, 358,
2644 359, 360, 361, 362, 363, 364, 365, 0, 0, 366,
2645 367, 97, 0, 0, 0, 0, 0, 97, 0, 97,
2646 98, 0, 97, 353, -595, -595, -595, -595, 358, 359,
2647 98, 98, -595, -595, 0, 0, 0, 0, 366, 367,
2648 0, 0, 368, 98, 369, 370, 371, 372, 373, 374,
2649 375, 376, 377, 378, 0, 0, 0, 0, 0, 0,
2650 0, 0, -260, 0, 0, 0, 0, 0, 0, 0,
2651 0, 0, 0, 369, 370, 371, 372, 373, 374, 375,
2652 376, 377, 378, 0, 0, 0, 0, 0, 0, 0,
2653 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2654 0, 0, 98, 0, 0, 0, 0, 0, 98, 0,
2655 98, -594, 4, 98, 5, 6, 7, 8, 9, 10,
2656 11, 12, 13, 14, 0, 0, 0, 0, 0, 0,
2657 15, 0, 16, 17, 18, 19, 0, 0, 0, 0,
2658 0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2659 27, 0, 0, 0, 0, 0, 28, 29, 30, 31,
2660 32, 33, 34, 35, 36, 37, 38, 39, 0, 40,
2661 41, 42, 0, 0, 43, 0, 0, 44, 45, 0,
2662 46, 47, 48, 0, 0, 0, 0, 0, 0, 0,
2663 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2664 0, 49, 0, 0, 50, 51, 0, 52, 53, 0,
2665 54, 0, 0, 55, 0, 56, 57, 58, 59, 60,
2666 61, -466, 0, 62, -594, 0, 0, -594, -594, 0,
2667 0, 0, 0, 0, -466, -466, -466, -466, -466, -466,
2668 0, -466, 0, 63, 64, 65, 0, 0, -466, -466,
2669 0, 0, 0, 0, 0, -594, 0, -594, -466, -466,
2670 0, -466, -466, -466, -466, -466, 0, 0, 0, 0,
2671 0, 0, 0, 0, 0, 0, 0, 0, 442, 0,
2672 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2673 0, 0, 0, -466, -466, -466, -466, -466, -466, -466,
2674 -466, -466, -466, -466, -466, -466, 0, 0, -466, -466,
2675 -466, 0, -466, -466, 0, 0, 0, 0, 0, -466,
2676 0, 0, 0, 0, -466, 0, 0, 0, 0, 0,
2677 0, 0, 0, 0, -466, 0, 0, -466, -466, 0,
2678 -466, -466, 0, -466, -466, -466, -466, -466, -466, -466,
2679 -466, -466, -466, 0, 0, -594, 0, 0, -466, -466,
2680 -466, -466, 0, 0, -466, -466, -466, -466, -594, -594,
2681 -594, -594, -594, -594, 0, -594, 0, 0, 0, 0,
2682 0, 0, -594, -594, 0, 0, 0, 0, 0, 0,
2683 0, 0, -594, -594, 0, -594, -594, -594, -594, -594,
2684 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2685 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2686 0, 0, 0, 0, 0, 0, 0, -594, -594, -594,
2687 -594, -594, -594, -594, -594, -594, -594, -594, -594, -594,
2688 0, 0, -594, -594, -594, 0, 0, -594, 0, 0,
2689 0, 0, 0, -594, 0, 0, 0, 0, -594, 0,
2690 0, 0, 0, 0, 0, 0, 0, 0, -594, 0,
2691 0, -594, -594, 0, 0, -594, 0, -594, -594, -594,
2692 -594, -594, -594, -594, -594, -594, -594, 0, 0, -571,
2693 0, 0, -594, -594, -594, -594, 0, 266, -594, -594,
2694 -594, -594, -571, -571, -571, 0, -571, -571, 0, -571,
2695 0, 0, 0, 0, 0, -571, 0, 0, 0, 0,
2696 0, 0, 0, 0, 0, 0, -571, -571, 0, -571,
2697 -571, -571, -571, -571, 0, 0, 0, 0, 0, 0,
2698 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2699 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2700 0, -571, -571, -571, -571, -571, -571, -571, -571, -571,
2701 -571, -571, -571, -571, 0, 0, -571, -571, -571, 0,
2702 737, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2703 0, 0, -571, 0, 0, 0, 0, 0, 0, 0,
2704 0, 0, -571, 0, 0, -571, -571, 0, -99, -571,
2705 0, -571, -571, -571, -571, -571, -571, -571, -571, -571,
2706 -571, 0, 0, -571, 0, -571, -571, -571, 0, -91,
2707 0, 0, -571, -571, -571, -571, -571, -571, -571, 0,
2708 -571, -571, 0, -571, 0, 0, 0, 0, 0, -571,
2709 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2710 -571, -571, 0, -571, -571, -571, -571, -571, 0, 0,
2711 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2712 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2713 0, 0, 0, 0, 0, -571, -571, -571, -571, -571,
2714 -571, -571, -571, -571, -571, -571, -571, -571, 0, 0,
2715 -571, -571, -571, 0, 737, 0, 0, 0, 0, 0,
2716 0, 0, 0, 0, 0, 0, -571, 0, 0, 0,
2717 0, 0, 0, 0, 0, 0, -571, 0, 0, -571,
2718 -571, 0, -99, -571, 0, -571, -571, -571, -571, -571,
2719 -571, -571, -571, -571, -571, 0, 0, -284, 0, -571,
2720 -571, -571, 0, -571, 0, 0, -571, -571, -571, -571,
2721 -284, -284, -284, 0, -284, -284, 0, -284, 0, 0,
2722 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2723 0, 0, 0, 0, -284, -284, 0, -284, -284, -284,
2724 -284, -284, 0, 0, 0, 0, 0, 0, 0, 0,
2725 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2726 0, 0, 0, 0, 0, 0, 0, 0, 0, -284,
2727 -284, -284, -284, -284, -284, -284, -284, -284, -284, -284,
2728 -284, -284, 0, 0, -284, -284, -284, 0, 738, 0,
2729 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2730 -284, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2731 -284, 0, 0, -284, -284, 0, -101, -284, 0, -284,
2732 -284, -284, -284, -284, -284, -284, -284, -284, -284, 0,
2733 0, -284, 0, 0, -284, -284, 0, -93, 0, 0,
2734 -284, -284, -284, -284, -284, -284, -284, 0, -284, -284,
2735 0, -284, 0, 0, 0, 0, 0, 0, 0, 0,
2736 0, 0, 0, 0, 0, 0, 0, 0, -284, -284,
2737 0, -284, -284, -284, -284, -284, 0, 0, 0, 0,
2738 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2739 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2740 0, 0, 0, -284, -284, -284, -284, -284, -284, -284,
2741 -284, -284, -284, -284, -284, -284, 0, 0, -284, -284,
2742 -284, 0, 738, 0, 0, 0, 0, 0, 0, 0,
2743 0, 0, 0, 0, -284, 0, 0, 0, 0, 0,
2744 0, 0, 0, 0, -284, 0, 0, -284, -284, 0,
2745 -101, -284, 0, -284, -284, -284, -284, -284, -284, -284,
2746 -284, -284, -284, 0, 0, 0, 0, 0, -284, -284,
2747 0, -284, 0, 0, -284, -284, -284, -284, 284, 0,
2748 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2749 -594, -594, -594, 0, 0, -594, 15, 0, 16, 17,
2750 18, 19, 0, 0, 0, 0, 0, 20, 21, 22,
2751 23, 24, 25, 26, 0, 0, 27, 0, 0, 0,
2752 0, 0, 28, 0, 30, 31, 32, 33, 34, 35,
2753 36, 37, 38, 39, 0, 40, 41, 42, 0, 0,
2754 43, 0, 0, 44, 45, 0, 46, 47, 48, 0,
2755 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2756 0, 0, 0, 0, 0, 0, 0, 49, 0, 0,
2757 50, 51, 0, 52, 53, 0, 54, 0, 0, 55,
2758 0, 56, 57, 58, 59, 60, 61, 0, 0, 62,
2759 -594, 0, 0, -594, -594, 0, 0, 0, 0, 0,
2760 0, 0, 0, 0, 0, 0, 0, 0, 0, 63,
2761 64, 65, 0, 0, 0, 0, 0, 0, 0, 0,
2762 0, -594, 284, -594, 5, 6, 7, 8, 9, 10,
2763 11, 12, 13, 14, 0, 0, -594, 0, -594, -594,
2764 15, 0, 16, 17, 18, 19, 0, 0, 0, 0,
2765 0, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2766 27, 0, 0, 0, 0, 0, 28, 0, 30, 31,
2767 32, 33, 34, 35, 36, 37, 38, 39, 0, 40,
2768 41, 42, 0, 0, 43, 0, 0, 44, 45, 0,
2769 46, 47, 48, 0, 0, 0, 0, 0, 0, 0,
2770 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2771 0, 49, 0, 0, 50, 51, 0, 52, 53, 0,
2772 54, 0, 0, 55, 0, 56, 57, 58, 59, 60,
2773 61, 0, 0, 62, -594, 0, 0, -594, -594, 0,
2774 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2775 0, 0, 0, 63, 64, 65, 0, 0, 0, 0,
2776 0, 0, 0, 0, 0, -594, 284, -594, 5, 6,
2777 7, 8, 9, 10, 11, 12, 13, 14, 0, 0,
2778 -594, 0, 0, -594, 15, -594, 16, 17, 18, 19,
2779 0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2780 25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2781 28, 0, 30, 31, 32, 33, 34, 35, 36, 37,
2782 38, 39, 0, 40, 41, 42, 0, 0, 43, 0,
2783 0, 44, 45, 0, 46, 47, 48, 0, 0, 0,
2784 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2785 0, 0, 0, 0, 0, 49, 0, 0, 50, 51,
2786 0, 52, 53, 0, 54, 0, 0, 55, 0, 56,
2787 57, 58, 59, 60, 61, 0, 0, 62, -594, 0,
2788 0, -594, -594, 0, 0, 0, 0, 0, 0, 0,
2789 0, 0, 0, 0, 0, 0, 0, 63, 64, 65,
2790 0, 0, 0, 0, 0, 0, 0, 0, 0, -594,
2791 284, -594, 5, 6, 7, 8, 9, 10, 11, 12,
2792 13, 14, 0, 0, -594, 0, 0, -594, 15, 0,
2793 16, 17, 18, 19, 0, 0, 0, 0, 0, 20,
2794 21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2795 0, 0, 0, 0, 28, 0, 30, 31, 32, 33,
2796 34, 35, 36, 37, 38, 39, 0, 40, 41, 42,
2797 0, 0, 43, 0, 0, 44, 45, 0, 46, 47,
2798 48, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2799 0, 0, 0, 0, 0, 0, 0, 0, 0, 49,
2800 0, 0, 50, 51, 0, 52, 53, 0, 54, 0,
2801 0, 55, 0, 56, 57, 58, 59, 60, 61, 0,
2802 0, 62, -594, 0, 0, -594, -594, 4, 0, 5,
2803 6, 7, 8, 9, 10, 11, 12, 13, 14, 0,
2804 0, 63, 64, 65, 0, 15, 0, 16, 17, 18,
2805 19, 0, 0, -594, 0, -594, 20, 21, 22, 23,
2806 24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2807 0, 28, 29, 30, 31, 32, 33, 34, 35, 36,
2808 37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
2809 0, 0, 44, 45, 0, 46, 47, 48, 0, 0,
2810 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2811 0, 0, 0, 0, 0, 0, 49, 0, 0, 50,
2812 51, 0, 52, 53, 0, 54, 0, 0, 55, 0,
2813 56, 57, 58, 59, 60, 61, 0, 0, 62, -594,
2814 0, 0, -594, -594, 0, 0, 0, 0, 0, 0,
2815 0, 0, 0, 0, 0, 0, 0, 0, 63, 64,
2816 65, 0, 0, -594, 0, 0, 0, 0, 0, 0,
2817 -594, 284, -594, 5, 6, 7, 8, 9, 10, 11,
2818 12, 13, 14, 0, -594, -594, 0, 0, 0, 15,
2819 0, 16, 17, 18, 19, 0, 0, 0, 0, 0,
2820 20, 21, 22, 23, 24, 25, 26, 0, 0, 27,
2821 0, 0, 0, 0, 0, 28, 0, 30, 31, 32,
2822 33, 34, 35, 36, 37, 38, 39, 0, 40, 41,
2823 42, 0, 0, 43, 0, 0, 44, 45, 0, 46,
2824 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
2825 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2826 49, 0, 0, 50, 51, 0, 52, 53, 0, 54,
2827 0, 0, 55, 0, 56, 57, 58, 59, 60, 61,
2828 0, 0, 62, -594, 0, 0, -594, -594, 284, 0,
2829 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
2830 0, 0, 63, 64, 65, 0, 15, 0, 16, 17,
2831 18, 19, 0, 0, -594, 0, -594, 20, 21, 22,
2832 23, 24, 25, 26, 0, 0, 27, 0, 0, 0,
2833 0, 0, 28, 0, 30, 31, 32, 33, 34, 35,
2834 36, 37, 38, 39, 0, 40, 41, 42, 0, 0,
2835 43, 0, 0, 44, 45, 0, 46, 47, 48, 0,
2836 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2837 0, 0, 0, 0, 0, 0, 0, 49, 0, 0,
2838 285, 51, 0, 52, 53, 0, 54, 0, 0, 55,
2839 0, 56, 57, 58, 59, 60, 61, 0, 0, 62,
2840 -594, 0, 0, -594, -594, 284, 0, 5, 6, 7,
2841 8, 9, 10, 11, 12, 13, 14, 0, 0, 63,
2842 64, 65, 0, 15, 0, 16, 17, 18, 19, 0,
2843 -594, -594, 0, -594, 20, 21, 22, 23, 24, 25,
2844 26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
2845 0, 30, 31, 32, 33, 34, 35, 36, 37, 38,
2846 39, 0, 40, 41, 42, 0, 0, 43, 0, 0,
2847 44, 45, 0, 46, 47, 48, 0, 0, 0, 0,
2848 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2849 0, 0, 0, 0, 49, 0, 0, 50, 51, 0,
2850 52, 53, 0, 54, 0, 0, 55, 0, 56, 57,
2851 58, 59, 60, 61, 0, 0, 62, -594, 0, 0,
2852 -594, -594, 284, 0, 5, 6, 7, 8, 9, 10,
2853 11, 12, 13, 14, 0, 0, 63, 64, 65, 0,
2854 15, 0, 16, 17, 18, 19, 0, -594, -594, 0,
2855 -594, 20, 21, 22, 23, 24, 25, 26, 0, 0,
2856 27, 0, 0, 0, 0, 0, 28, 0, 30, 31,
2857 32, 33, 34, 35, 36, 37, 38, 39, 0, 40,
2858 41, 42, 0, 0, 43, 0, 0, 44, 45, 0,
2859 46, 47, 48, 0, 0, 0, 0, 0, 0, 0,
2860 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2861 0, 49, 0, 0, 50, 51, 0, 52, 53, 0,
2862 54, 0, 0, 55, 0, 56, 57, 58, 59, 60,
2863 61, 0, 0, 62, -594, 0, 0, -594, -594, 0,
2864 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2865 0, 0, 0, 63, 64, 65, 0, 0, -594, 0,
2866 0, 0, 0, 0, 0, -594, 284, -594, 5, 6,
2867 7, 8, 9, 10, 11, 12, 13, 14, 0, 0,
2868 -594, 0, 0, 0, 15, 0, 16, 17, 18, 19,
2869 0, 0, 0, 0, 0, 20, 21, 22, 23, 24,
2870 25, 26, 0, 0, 27, 0, 0, 0, 0, 0,
2871 28, 0, 30, 31, 32, 33, 34, 35, 36, 37,
2872 38, 39, 0, 40, 41, 42, 0, 0, 43, 0,
2873 0, 44, 45, 0, 46, 47, 48, 0, 0, 0,
2874 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2875 0, 0, 0, 0, 0, 49, 0, 0, 50, 51,
2876 0, 52, 53, 0, 54, 0, 0, 55, 0, 56,
2877 57, 58, 59, 60, 61, 0, 0, 62, -594, 0,
2878 0, -594, -594, 0, 0, 5, 6, 7, 8, 9,
2879 10, 11, 12, 13, 14, 0, 0, 63, 64, 65,
2880 0, 15, 0, 16, 17, 18, 19, 0, 0, -594,
2881 0, -594, 20, 21, 22, 23, 24, 25, 26, 0,
2882 0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
2883 31, 32, 33, 34, 35, 36, 37, 38, 39, 0,
2884 40, 41, 42, 0, 0, 43, 0, 0, 44, 45,
2885 0, 46, 47, 48, 0, 0, 0, 0, 0, 0,
2886 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2887 0, 0, 49, 0, 0, 50, 51, 0, 52, 53,
2888 0, 54, 0, 0, 55, 0, 56, 57, 58, 59,
2889 60, 61, 0, 0, 62, 238, 0, 0, 239, 240,
2890 0, 0, 5, 6, 7, 8, 9, 10, 11, 12,
2891 13, 14, 0, 0, 63, 64, 65, 0, 15, 0,
2892 16, 17, 18, 19, 0, 0, 241, 0, 242, 20,
2893 21, 22, 23, 24, 25, 26, 0, 0, 27, 0,
2894 0, 0, 0, 0, 28, 0, 30, 31, 32, 33,
2895 34, 35, 36, 37, 38, 39, 0, 40, 41, 42,
2896 0, 0, 43, 0, 0, 44, 45, 0, 46, 47,
2897 48, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2898 0, 0, 0, 0, 0, 0, 0, 0, 0, 49,
2899 0, 0, 50, 51, 0, 52, 53, 0, 54, 0,
2900 0, 55, 0, 56, 57, 58, 59, 60, 61, 0,
2901 0, 62, 238, 0, 0, 239, 240, 0, 0, 5,
2902 6, 7, 8, 9, 10, 11, 12, 13, 0, 0,
2903 0, 63, 64, 65, 0, 15, 0, 16, 17, 18,
2904 19, 0, 0, 241, 0, 242, 20, 21, 22, 23,
2905 24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
2906 0, 0, 0, 0, 31, 32, 33, 34, 35, 36,
2907 37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
2908 0, 0, 44, 45, 0, 46, 47, 48, 0, 0,
2909 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2910 0, 0, 0, 0, 0, 0, 205, 0, 0, 115,
2911 51, 0, 52, 53, 0, 0, 0, 0, 55, 0,
2912 56, 57, 58, 59, 60, 61, 0, 0, 62, 238,
2913 0, 0, 239, 240, 0, 0, 0, 0, 0, 0,
2914 0, 0, 0, 0, 0, 0, 0, 0, 63, 64,
2915 65, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2916 241, 0, 242, 125, 126, 127, 128, 129, 130, 131,
2917 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
2918 142, 143, 144, 145, 146, 147, 148, 0, 0, 0,
2919 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
2920 0, 0, 0, 0, 0, 159, 160, 161, 162, 163,
2921 164, 165, 166, 36, 37, 167, 39, 0, 0, 0,
2922 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2923 168, 169, 170, 171, 172, 173, 174, 175, 176, 0,
2924 0, 177, 178, 0, 0, 179, 180, 181, 182, 0,
2925 0, 0, 0, 0, 0, 0, 0, 0, 0, 183,
2926 184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2927 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2928 0, 0, 185, 186, 187, 188, 189, 190, 191, 192,
2929 193, 194, 0, 195, 196, 0, 0, 0, 0, 0,
2930 0, 197, 198, -564, -564, -564, -564, -564, -564, -564,
2931 -564, -564, 0, 0, 0, 0, 0, 0, 0, -564,
2932 0, -564, -564, -564, -564, 0, -564, 0, 0, 0,
2933 -564, -564, -564, -564, -564, -564, -564, 0, 0, -564,
2934 0, 0, 0, 0, 0, 0, 0, 0, -564, -564,
2935 -564, -564, -564, -564, -564, -564, -564, 0, -564, -564,
2936 -564, 0, 0, -564, 0, 0, -564, -564, 0, -564,
2937 -564, -564, 0, 0, 0, 0, 0, 0, 0, 0,
2938 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2939 -564, 0, 0, -564, -564, 0, -564, -564, 0, -564,
2940 -564, -564, -564, 0, -564, -564, -564, -564, -564, -564,
2941 0, 0, -564, 0, 0, 0, 0, 0, 0, 0,
2942 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2943 0, 0, -564, -564, -564, 0, -564, 0, 0, 0,
2944 0, 0, -564, -566, -566, -566, -566, -566, -566, -566,
2945 -566, -566, 0, 0, 0, 0, 0, 0, 0, -566,
2946 0, -566, -566, -566, -566, 0, -566, 0, 0, 0,
2947 -566, -566, -566, -566, -566, -566, -566, 0, 0, -566,
2948 0, 0, 0, 0, 0, 0, 0, 0, -566, -566,
2949 -566, -566, -566, -566, -566, -566, -566, 0, -566, -566,
2950 -566, 0, 0, -566, 0, 0, -566, -566, 0, -566,
2951 -566, -566, 0, 0, 0, 0, 0, 0, 0, 0,
2952 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2953 -566, 0, 0, -566, -566, 0, -566, -566, 0, -566,
2954 -566, -566, -566, 0, -566, -566, -566, -566, -566, -566,
2955 0, 0, -566, 0, 0, 0, 0, 0, 0, 0,
2956 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2957 0, 0, -566, -566, -566, 0, -566, 0, 0, 0,
2958 0, 0, -566, -565, -565, -565, -565, -565, -565, -565,
2959 -565, -565, 0, 0, 0, 0, 0, 0, 0, -565,
2960 0, -565, -565, -565, -565, 0, -565, 0, 0, 0,
2961 -565, -565, -565, -565, -565, -565, -565, 0, 0, -565,
2962 0, 0, 0, 0, 0, 0, 0, 0, -565, -565,
2963 -565, -565, -565, -565, -565, -565, -565, 0, -565, -565,
2964 -565, 0, 0, -565, 0, 0, -565, -565, 0, -565,
2965 -565, -565, 0, 0, 0, 0, 0, 0, 0, 0,
2966 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2967 -565, 0, 0, -565, -565, 0, -565, -565, 0, -565,
2968 -565, -565, -565, 0, -565, -565, -565, -565, -565, -565,
2969 0, 0, -565, 0, 0, 0, 0, 0, 0, -567,
2970 -567, -567, -567, -567, -567, -567, -567, -567, 0, 0,
2971 0, 0, -565, -565, -565, -567, -565, -567, -567, -567,
2972 -567, 0, -565, 0, 0, 0, -567, -567, -567, -567,
2973 -567, -567, -567, 0, 0, -567, 0, 0, 0, 0,
2974 0, 0, 0, 0, -567, -567, -567, -567, -567, -567,
2975 -567, -567, -567, 0, -567, -567, -567, 0, 0, -567,
2976 0, 0, -567, -567, 0, -567, -567, -567, 0, 0,
2977 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2978 0, 0, 0, 0, 0, 0, -567, 771, 0, -567,
2979 -567, 0, -567, -567, 0, -567, -567, -567, -567, 0,
2980 -567, -567, -567, -567, -567, -567, 0, 0, -567, 0,
2981 0, 0, 0, 0, 0, -99, -568, -568, -568, -568,
2982 -568, -568, -568, -568, -568, 0, 0, 0, -567, -567,
2983 -567, 0, -568, 0, -568, -568, -568, -568, -567, 0,
2984 0, 0, 0, -568, -568, -568, -568, -568, -568, -568,
2985 0, 0, -568, 0, 0, 0, 0, 0, 0, 0,
2986 0, -568, -568, -568, -568, -568, -568, -568, -568, -568,
2987 0, -568, -568, -568, 0, 0, -568, 0, 0, -568,
2988 -568, 0, -568, -568, -568, 0, 0, 0, 0, 0,
2989 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2990 0, 0, 0, -568, 772, 0, -568, -568, 0, -568,
2991 -568, 0, -568, -568, -568, -568, 0, -568, -568, -568,
2992 -568, -568, -568, 0, 0, -568, 0, 0, 0, 0,
2993 0, 0, -101, -253, -253, -253, -253, -253, -253, -253,
2994 -253, -253, 0, 0, 0, -568, -568, -568, 0, -253,
2995 0, -253, -253, -253, -253, -568, 0, 0, 0, 0,
2996 -253, -253, -253, -253, -253, -253, -253, 0, 0, -253,
2997 0, 0, 0, 0, 0, 0, 0, 0, -253, -253,
2998 -253, -253, -253, -253, -253, -253, -253, 0, -253, -253,
2999 -253, 0, 0, -253, 0, 0, -253, -253, 0, -253,
3000 -253, -253, 0, 0, 0, 0, 0, 0, 0, 0,
3001 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3002 -253, 0, 0, -253, -253, 0, -253, -253, 0, -253,
3003 -253, -253, -253, 0, -253, -253, -253, -253, -253, -253,
3004 0, 0, -253, 0, 0, 0, 0, 0, 0, -569,
3005 -569, -569, -569, -569, -569, -569, -569, -569, 0, 0,
3006 0, 0, -253, -253, -253, -569, 0, -569, -569, -569,
3007 -569, 0, 266, 0, 0, 0, -569, -569, -569, -569,
3008 -569, -569, -569, 0, 0, -569, 0, 0, 0, 0,
3009 0, 0, 0, 0, -569, -569, -569, -569, -569, -569,
3010 -569, -569, -569, 0, -569, -569, -569, 0, 0, -569,
3011 0, 0, -569, -569, 0, -569, -569, -569, 0, 0,
3012 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3013 0, 0, 0, 0, 0, 0, -569, 0, 0, -569,
3014 -569, 0, -569, -569, 0, -569, -569, -569, -569, 0,
3015 -569, -569, -569, -569, -569, -569, 0, 0, -569, 0,
3016 0, 0, 0, 0, 0, -570, -570, -570, -570, -570,
3017 -570, -570, -570, -570, 0, 0, 0, 0, -569, -569,
3018 -569, -570, 0, -570, -570, -570, -570, 0, -569, 0,
3019 0, 0, -570, -570, -570, -570, -570, -570, -570, 0,
3020 0, -570, 0, 0, 0, 0, 0, 0, 0, 0,
3021 -570, -570, -570, -570, -570, -570, -570, -570, -570, 0,
3022 -570, -570, -570, 0, 0, -570, 0, 0, -570, -570,
3023 0, -570, -570, -570, 0, 0, 0, 0, 0, 0,
3024 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3025 0, 0, -570, 0, 0, -570, -570, 0, -570, -570,
3026 0, -570, -570, -570, -570, 0, -570, -570, -570, -570,
3027 -570, -570, 0, 0, -570, 0, 0, 0, 0, 0,
3028 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3029 0, 0, 0, 0, -570, -570, -570, 0, 0, 0,
3030 0, 0, 0, 0, -570, 125, 126, 127, 128, 129,
3031 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
3032 140, 141, 142, 143, 144, 145, 146, 147, 148, 0,
3033 0, 0, 149, 150, 151, 224, 225, 226, 227, 156,
3034 157, 158, 0, 0, 0, 0, 0, 159, 160, 161,
3035 228, 229, 230, 231, 166, 309, 310, 232, 311, 0,
3036 0, 0, 0, 0, 0, 312, 0, 0, 0, 0,
3037 0, 0, 168, 169, 170, 171, 172, 173, 174, 175,
3038 176, 0, 0, 177, 178, 0, 0, 179, 180, 181,
3039 182, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3040 0, 183, 184, 0, 0, 0, 0, 0, 0, 0,
3041 313, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3042 0, 0, 0, 0, 185, 186, 187, 188, 189, 190,
3043 191, 192, 193, 194, 0, 195, 196, 0, 0, 0,
3044 0, 0, 0, 197, 125, 126, 127, 128, 129, 130,
3045 131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
3046 141, 142, 143, 144, 145, 146, 147, 148, 0, 0,
3047 0, 149, 150, 151, 224, 225, 226, 227, 156, 157,
3048 158, 0, 0, 0, 0, 0, 159, 160, 161, 228,
3049 229, 230, 231, 166, 309, 310, 232, 311, 0, 0,
3050 0, 0, 0, 0, 312, 0, 0, 0, 0, 0,
3051 0, 168, 169, 170, 171, 172, 173, 174, 175, 176,
3052 0, 0, 177, 178, 0, 0, 179, 180, 181, 182,
3053 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3054 183, 184, 0, 0, 0, 0, 0, 0, 0, 433,
3055 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3056 0, 0, 0, 185, 186, 187, 188, 189, 190, 191,
3057 192, 193, 194, 0, 195, 196, 0, 0, 0, 0,
3058 0, 0, 197, 125, 126, 127, 128, 129, 130, 131,
3059 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
3060 142, 143, 144, 145, 146, 147, 148, 0, 0, 0,
3061 149, 150, 151, 224, 225, 226, 227, 156, 157, 158,
3062 0, 0, 0, 0, 0, 159, 160, 161, 228, 229,
3063 230, 231, 166, 0, 0, 232, 0, 0, 0, 0,
3064 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3065 168, 169, 170, 171, 172, 173, 174, 175, 176, 0,
3066 0, 177, 178, 0, 0, 179, 180, 181, 182, 0,
3067 0, 0, 0, 0, 0, 0, 0, 0, 0, 183,
3068 184, 0, 0, 0, 233, 0, 0, 0, 0, 0,
3069 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3070 0, 0, 185, 186, 187, 188, 189, 190, 191, 192,
3071 193, 194, 0, 195, 196, 0, 0, 0, 0, 0,
3072 0, 197, 125, 126, 127, 128, 129, 130, 131, 132,
3073 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
3074 143, 144, 145, 146, 147, 148, 0, 0, 0, 149,
3075 150, 151, 224, 225, 226, 227, 156, 157, 158, 0,
3076 0, 0, 0, 0, 159, 160, 161, 228, 229, 230,
3077 231, 166, 0, 0, 232, 0, 0, 0, 0, 0,
3078 0, 0, 0, 0, 0, 0, 0, 0, 0, 168,
3079 169, 170, 171, 172, 173, 174, 175, 176, 0, 0,
3080 177, 178, 0, 0, 179, 180, 181, 182, 0, 0,
3081 0, 0, 0, 0, 0, 0, 0, 0, 183, 184,
3082 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3083 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3084 0, 185, 186, 187, 188, 189, 190, 191, 192, 193,
3085 194, 0, 195, 196, 0, 0, 0, 0, 0, 0,
3086 197, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3087 0, 0, 0, 0, 0, 0, 0, 15, 0, 104,
3088 105, 18, 19, 0, 0, 0, 0, 0, 106, 107,
3089 108, 23, 24, 25, 26, 0, 0, 109, 0, 0,
3090 0, 0, 0, 0, 0, 0, 31, 32, 33, 34,
3091 35, 36, 37, 38, 39, 0, 40, 41, 42, 0,
3092 0, 43, 0, 0, 44, 45, 0, 112, 0, 0,
3093 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3094 0, 0, 0, 0, 0, 0, 0, 0, 302, 0,
3095 0, 115, 51, 0, 52, 53, 0, 0, 0, 0,
3096 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
3097 62, 0, 0, 5, 6, 7, 8, 9, 10, 11,
3098 12, 13, 0, 0, 0, 0, 0, 0, 0, 15,
3099 116, 104, 105, 18, 19, 0, 0, 0, 303, 0,
3100 106, 107, 108, 23, 24, 25, 26, 0, 0, 109,
3101 0, 0, 0, 0, 0, 0, 0, 0, 31, 32,
3102 33, 34, 35, 36, 37, 38, 39, 0, 40, 41,
3103 42, 0, 0, 43, 0, 0, 44, 45, 0, 112,
3104 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3105 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3106 302, 0, 0, 115, 51, 0, 52, 53, 0, 0,
3107 0, 0, 55, 0, 56, 57, 58, 59, 60, 61,
3108 0, 0, 62, 0, 0, 5, 6, 7, 8, 9,
3109 10, 11, 12, 13, 14, 0, 0, 0, 0, 0,
3110 0, 15, 116, 16, 17, 18, 19, 0, 0, 0,
3111 557, 0, 20, 21, 22, 23, 24, 25, 26, 0,
3112 0, 27, 0, 0, 0, 0, 0, 28, 29, 30,
3113 31, 32, 33, 34, 35, 36, 37, 38, 39, 0,
3114 40, 41, 42, 0, 0, 43, 0, 0, 44, 45,
3115 0, 46, 47, 48, 0, 0, 0, 0, 0, 0,
3116 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3117 0, 0, 49, 0, 0, 50, 51, 0, 52, 53,
3118 0, 54, 0, 0, 55, 0, 56, 57, 58, 59,
3119 60, 61, 0, 0, 62, 0, 0, 0, 0, 0,
3120 0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3121 0, 0, 0, 0, 63, 64, 65, 15, 0, 16,
3122 17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
3123 22, 23, 24, 25, 26, 0, 0, 109, 0, 0,
3124 0, 0, 0, 0, 0, 0, 31, 32, 33, 251,
3125 35, 36, 37, 38, 39, 0, 40, 41, 42, 0,
3126 0, 43, 0, 0, 44, 45, 0, 46, 47, 48,
3127 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3128 0, 0, 455, 0, 0, 0, 0, 0, 205, 0,
3129 0, 115, 51, 0, 52, 53, 0, 252, 253, 254,
3130 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
3131 62, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3132 8, 9, 10, 11, 12, 13, 14, 0, 0, 0,
3133 63, 255, 65, 15, 0, 16, 17, 18, 19, 0,
3134 0, 0, 0, 0, 20, 21, 22, 23, 24, 25,
3135 26, 0, 0, 27, 0, 0, 0, 0, 0, 28,
3136 0, 30, 31, 32, 33, 34, 35, 36, 37, 38,
3137 39, 0, 40, 41, 42, 0, 0, 43, 0, 0,
3138 44, 45, 0, 46, 47, 48, 0, 0, 0, 0,
3139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3140 0, 0, 0, 0, 49, 0, 0, 50, 51, 0,
3141 52, 53, 0, 54, 0, 0, 55, 0, 56, 57,
3142 58, 59, 60, 61, 0, 0, 62, 0, 0, 0,
3143 0, 0, 0, 5, 6, 7, 8, 9, 10, 11,
3144 12, 13, 0, 0, 0, 0, 63, 64, 65, 15,
3145 0, 16, 17, 18, 19, 0, 0, 0, 0, 0,
3146 20, 21, 22, 23, 24, 25, 26, 0, 0, 109,
3147 0, 0, 0, 0, 0, 0, 0, 0, 31, 32,
3148 33, 251, 35, 36, 37, 38, 39, 0, 40, 41,
3149 42, 0, 0, 43, 0, 0, 44, 45, 0, 46,
3150 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
3151 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3152 205, 0, 0, 115, 51, 0, 52, 53, 0, 252,
3153 253, 254, 55, 0, 56, 57, 58, 59, 60, 61,
3154 0, 0, 62, 0, 0, 0, 0, 0, 0, 5,
3155 6, 7, 8, 9, 10, 11, 12, 13, 0, 0,
3156 0, 0, 63, 255, 65, 15, 0, 104, 105, 18,
3157 19, 0, 0, 0, 0, 0, 106, 107, 108, 23,
3158 24, 25, 26, 0, 0, 109, 0, 0, 0, 0,
3159 0, 0, 0, 0, 31, 32, 33, 251, 35, 36,
3160 37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
3161 0, 0, 44, 45, 0, 46, 47, 48, 0, 0,
3162 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3163 0, 0, 0, 0, 0, 0, 205, 0, 0, 115,
3164 51, 0, 52, 53, 0, 666, 253, 254, 55, 0,
3165 56, 57, 58, 59, 60, 61, 0, 0, 62, 0,
3166 0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
3167 10, 11, 12, 13, 0, 0, 0, 0, 63, 255,
3168 65, 15, 0, 104, 105, 18, 19, 0, 0, 0,
3169 0, 0, 106, 107, 108, 23, 24, 25, 26, 0,
3170 0, 109, 0, 0, 0, 0, 0, 0, 0, 0,
3171 31, 32, 33, 251, 35, 36, 37, 38, 39, 0,
3172 40, 41, 42, 0, 0, 43, 0, 0, 44, 45,
3173 0, 46, 47, 48, 0, 0, 0, 0, 0, 0,
3174 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3175 0, 0, 205, 0, 0, 115, 51, 0, 52, 53,
3176 0, 252, 253, 0, 55, 0, 56, 57, 58, 59,
3177 60, 61, 0, 0, 62, 0, 0, 0, 0, 0,
3178 0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3179 0, 0, 0, 0, 63, 255, 65, 15, 0, 104,
3180 105, 18, 19, 0, 0, 0, 0, 0, 106, 107,
3181 108, 23, 24, 25, 26, 0, 0, 109, 0, 0,
3182 0, 0, 0, 0, 0, 0, 31, 32, 33, 251,
3183 35, 36, 37, 38, 39, 0, 40, 41, 42, 0,
3184 0, 43, 0, 0, 44, 45, 0, 46, 47, 48,
3185 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3186 0, 0, 0, 0, 0, 0, 0, 0, 205, 0,
3187 0, 115, 51, 0, 52, 53, 0, 0, 253, 254,
3188 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
3189 62, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3190 8, 9, 10, 11, 12, 13, 0, 0, 0, 0,
3191 63, 255, 65, 15, 0, 104, 105, 18, 19, 0,
3192 0, 0, 0, 0, 106, 107, 108, 23, 24, 25,
3193 26, 0, 0, 109, 0, 0, 0, 0, 0, 0,
3194 0, 0, 31, 32, 33, 251, 35, 36, 37, 38,
3195 39, 0, 40, 41, 42, 0, 0, 43, 0, 0,
3196 44, 45, 0, 46, 47, 48, 0, 0, 0, 0,
3197 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3198 0, 0, 0, 0, 205, 0, 0, 115, 51, 0,
3199 52, 53, 0, 666, 253, 0, 55, 0, 56, 57,
3200 58, 59, 60, 61, 0, 0, 62, 0, 0, 0,
3201 0, 0, 0, 5, 6, 7, 8, 9, 10, 11,
3202 12, 13, 0, 0, 0, 0, 63, 255, 65, 15,
3203 0, 104, 105, 18, 19, 0, 0, 0, 0, 0,
3204 106, 107, 108, 23, 24, 25, 26, 0, 0, 109,
3205 0, 0, 0, 0, 0, 0, 0, 0, 31, 32,
3206 33, 251, 35, 36, 37, 38, 39, 0, 40, 41,
3207 42, 0, 0, 43, 0, 0, 44, 45, 0, 46,
3208 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
3209 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3210 205, 0, 0, 115, 51, 0, 52, 53, 0, 0,
3211 253, 0, 55, 0, 56, 57, 58, 59, 60, 61,
3212 0, 0, 62, 0, 0, 0, 0, 0, 0, 5,
3213 6, 7, 8, 9, 10, 11, 12, 13, 0, 0,
3214 0, 0, 63, 255, 65, 15, 0, 16, 17, 18,
3215 19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
3216 24, 25, 26, 0, 0, 109, 0, 0, 0, 0,
3217 0, 0, 0, 0, 31, 32, 33, 34, 35, 36,
3218 37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
3219 0, 0, 44, 45, 0, 46, 47, 48, 0, 0,
3220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3221 0, 0, 0, 0, 0, 0, 205, 0, 0, 115,
3222 51, 0, 52, 53, 0, 551, 0, 0, 55, 0,
3223 56, 57, 58, 59, 60, 61, 0, 0, 62, 0,
3224 0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
3225 10, 11, 12, 13, 0, 0, 0, 0, 63, 255,
3226 65, 15, 0, 104, 105, 18, 19, 0, 0, 0,
3227 0, 0, 106, 107, 108, 23, 24, 25, 26, 0,
3228 0, 109, 0, 0, 0, 0, 0, 0, 0, 0,
3229 31, 32, 33, 34, 35, 36, 37, 38, 39, 0,
3230 40, 41, 42, 0, 0, 43, 0, 0, 44, 45,
3231 0, 46, 47, 48, 0, 0, 0, 0, 0, 0,
3232 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3233 0, 0, 205, 0, 0, 115, 51, 0, 52, 53,
3234 0, 252, 0, 0, 55, 0, 56, 57, 58, 59,
3235 60, 61, 0, 0, 62, 0, 0, 0, 0, 0,
3236 0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3237 0, 0, 0, 0, 63, 255, 65, 15, 0, 104,
3238 105, 18, 19, 0, 0, 0, 0, 0, 106, 107,
3239 108, 23, 24, 25, 26, 0, 0, 109, 0, 0,
3240 0, 0, 0, 0, 0, 0, 31, 32, 33, 34,
3241 35, 36, 37, 38, 39, 0, 40, 41, 42, 0,
3242 0, 43, 0, 0, 44, 45, 0, 46, 47, 48,
3243 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3244 0, 0, 0, 0, 0, 0, 0, 0, 205, 0,
3245 0, 115, 51, 0, 52, 53, 0, 551, 0, 0,
3246 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
3247 62, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3248 8, 9, 10, 11, 12, 13, 0, 0, 0, 0,
3249 63, 255, 65, 15, 0, 104, 105, 18, 19, 0,
3250 0, 0, 0, 0, 106, 107, 108, 23, 24, 25,
3251 26, 0, 0, 109, 0, 0, 0, 0, 0, 0,
3252 0, 0, 31, 32, 33, 34, 35, 36, 37, 38,
3253 39, 0, 40, 41, 42, 0, 0, 43, 0, 0,
3254 44, 45, 0, 46, 47, 48, 0, 0, 0, 0,
3255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3256 0, 0, 0, 0, 205, 0, 0, 115, 51, 0,
3257 52, 53, 0, 831, 0, 0, 55, 0, 56, 57,
3258 58, 59, 60, 61, 0, 0, 62, 0, 0, 0,
3259 0, 0, 0, 5, 6, 7, 8, 9, 10, 11,
3260 12, 13, 0, 0, 0, 0, 63, 255, 65, 15,
3261 0, 104, 105, 18, 19, 0, 0, 0, 0, 0,
3262 106, 107, 108, 23, 24, 25, 26, 0, 0, 109,
3263 0, 0, 0, 0, 0, 0, 0, 0, 31, 32,
3264 33, 34, 35, 36, 37, 38, 39, 0, 40, 41,
3265 42, 0, 0, 43, 0, 0, 44, 45, 0, 46,
3266 47, 48, 0, 0, 0, 0, 0, 0, 0, 0,
3267 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3268 205, 0, 0, 115, 51, 0, 52, 53, 0, 666,
3269 0, 0, 55, 0, 56, 57, 58, 59, 60, 61,
3270 0, 0, 62, 0, 0, 0, 0, 0, 0, 5,
3271 6, 7, 8, 9, 10, 11, 12, 13, 0, 0,
3272 0, 0, 63, 255, 65, 15, 0, 16, 17, 18,
3273 19, 0, 0, 0, 0, 0, 20, 21, 22, 23,
3274 24, 25, 26, 0, 0, 27, 0, 0, 0, 0,
3275 0, 0, 0, 0, 31, 32, 33, 34, 35, 36,
3276 37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
3277 0, 0, 44, 45, 0, 46, 47, 48, 0, 0,
3278 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3279 0, 0, 0, 0, 0, 0, 205, 0, 0, 115,
3280 51, 0, 52, 53, 0, 0, 0, 0, 55, 0,
3281 56, 57, 58, 59, 60, 61, 0, 0, 62, 0,
3282 0, 0, 0, 0, 0, 5, 6, 7, 8, 9,
3283 10, 11, 12, 13, 0, 0, 0, 0, 63, 64,
3284 65, 15, 0, 104, 105, 18, 19, 0, 0, 0,
3285 0, 0, 106, 107, 108, 23, 24, 25, 26, 0,
3286 0, 109, 0, 0, 0, 0, 0, 0, 0, 0,
3287 31, 32, 33, 34, 35, 36, 37, 38, 39, 0,
3288 40, 41, 42, 0, 0, 43, 0, 0, 44, 45,
3289 0, 46, 47, 48, 0, 0, 0, 0, 0, 0,
3290 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3291 0, 0, 205, 0, 0, 115, 51, 0, 52, 53,
3292 0, 0, 0, 0, 55, 0, 56, 57, 58, 59,
3293 60, 61, 0, 0, 62, 0, 0, 0, 0, 0,
3294 0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3295 0, 0, 0, 0, 63, 255, 65, 15, 0, 16,
3296 17, 18, 19, 0, 0, 0, 0, 0, 20, 21,
3297 22, 23, 24, 25, 26, 0, 0, 109, 0, 0,
3298 0, 0, 0, 0, 0, 0, 31, 32, 33, 34,
3299 35, 36, 37, 38, 39, 0, 40, 41, 42, 0,
3300 0, 43, 0, 0, 44, 45, 0, 46, 47, 48,
3301 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3302 0, 0, 0, 0, 0, 0, 0, 0, 205, 0,
3303 0, 115, 51, 0, 52, 53, 0, 0, 0, 0,
3304 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
3305 62, 0, 0, 0, 0, 0, 0, 5, 6, 7,
3306 8, 9, 10, 11, 12, 13, 0, 0, 0, 0,
3307 63, 255, 65, 15, 0, 104, 105, 18, 19, 0,
3308 0, 0, 0, 0, 106, 107, 108, 23, 24, 25,
3309 26, 0, 0, 109, 0, 0, 0, 0, 0, 0,
3310 0, 0, 31, 32, 33, 110, 35, 36, 37, 111,
3311 39, 0, 40, 41, 42, 0, 0, 43, 0, 0,
3312 44, 45, 0, 112, 0, 0, 0, 0, 0, 0,
3313 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3314 0, 113, 0, 0, 114, 0, 0, 115, 51, 0,
3315 52, 53, 0, 0, 0, 0, 55, 0, 56, 57,
3316 58, 59, 60, 61, 0, 0, 62, 0, 0, 5,
3317 6, 7, 8, 9, 10, 11, 12, 13, 0, 0,
3318 0, 0, 0, 0, 0, 15, 116, 104, 105, 18,
3319 19, 0, 0, 0, 0, 0, 106, 107, 108, 23,
3320 24, 25, 26, 0, 0, 109, 0, 0, 0, 0,
3321 0, 0, 0, 0, 31, 32, 33, 34, 35, 36,
3322 37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
3323 0, 0, 44, 45, 0, 216, 0, 0, 0, 0,
3324 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3325 0, 0, 0, 0, 0, 0, 217, 0, 0, 50,
3326 51, 0, 52, 53, 0, 54, 0, 0, 55, 0,
3327 56, 57, 58, 59, 60, 61, 0, 0, 62, 0,
3328 0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3329 0, 0, 0, 0, 0, 0, 0, 15, 116, 104,
3330 105, 18, 19, 0, 0, 0, 0, 0, 106, 107,
3331 108, 23, 24, 25, 26, 0, 0, 109, 0, 0,
3332 0, 0, 0, 0, 0, 0, 31, 32, 33, 34,
3333 35, 36, 37, 38, 39, 0, 40, 41, 42, 0,
3334 0, 43, 0, 0, 44, 45, 0, 112, 0, 0,
3335 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3336 0, 0, 0, 0, 0, 0, 0, 0, 302, 0,
3337 0, 349, 51, 0, 52, 53, 0, 350, 0, 0,
3338 55, 0, 56, 57, 58, 59, 60, 61, 0, 0,
3339 62, 0, 0, 5, 6, 7, 8, 9, 10, 11,
3340 12, 13, 0, 0, 0, 0, 0, 0, 0, 15,
3341 116, 104, 105, 18, 19, 0, 0, 0, 0, 0,
3342 106, 107, 108, 23, 24, 25, 26, 0, 0, 109,
3343 0, 0, 0, 0, 0, 0, 0, 0, 31, 32,
3344 33, 110, 35, 36, 37, 111, 39, 0, 40, 41,
3345 42, 0, 0, 43, 0, 0, 44, 45, 0, 112,
3346 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3347 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3348 114, 0, 0, 115, 51, 0, 52, 53, 0, 0,
3349 0, 0, 55, 0, 56, 57, 58, 59, 60, 61,
3350 0, 0, 62, 0, 0, 5, 6, 7, 8, 9,
3351 10, 11, 12, 13, 0, 0, 0, 0, 0, 0,
3352 0, 15, 116, 104, 105, 18, 19, 0, 0, 0,
3353 0, 0, 106, 107, 108, 23, 24, 25, 26, 0,
3354 0, 109, 0, 0, 0, 0, 0, 0, 0, 0,
3355 31, 32, 33, 34, 35, 36, 37, 38, 39, 0,
3356 40, 41, 42, 0, 0, 43, 0, 0, 44, 45,
3357 0, 112, 0, 0, 0, 0, 0, 0, 0, 0,
3358 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3359 0, 0, 302, 0, 0, 349, 51, 0, 52, 53,
3360 0, 0, 0, 0, 55, 0, 56, 57, 58, 59,
3361 60, 61, 0, 0, 62, 0, 0, 5, 6, 7,
3362 8, 9, 10, 11, 12, 13, 0, 0, 0, 0,
3363 0, 0, 0, 15, 116, 104, 105, 18, 19, 0,
3364 0, 0, 0, 0, 106, 107, 108, 23, 24, 25,
3365 26, 0, 0, 109, 0, 0, 0, 0, 0, 0,
3366 0, 0, 31, 32, 33, 34, 35, 36, 37, 38,
3367 39, 0, 40, 41, 42, 0, 0, 43, 0, 0,
3368 44, 45, 0, 112, 0, 0, 0, 0, 0, 0,
3369 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3370 0, 0, 0, 0, 904, 0, 0, 115, 51, 0,
3371 52, 53, 0, 0, 0, 0, 55, 0, 56, 57,
3372 58, 59, 60, 61, 0, 0, 62, 0, 0, 5,
3373 6, 7, 8, 9, 10, 11, 12, 13, 0, 0,
3374 0, 0, 0, 0, 0, 15, 116, 104, 105, 18,
3375 19, 0, 0, 0, 0, 0, 106, 107, 108, 23,
3376 24, 25, 26, 0, 0, 109, 0, 0, 0, 0,
3377 0, 0, 0, 0, 31, 32, 33, 34, 35, 36,
3378 37, 38, 39, 0, 40, 41, 42, 0, 0, 43,
3379 0, 0, 44, 45, 0, 216, 0, 0, 0, 0,
3380 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3381 0, 0, 0, 0, 0, 0, 931, 0, 0, 115,
3382 51, 0, 52, 53, 0, 595, 596, 0, 55, 597,
3383 56, 57, 58, 59, 60, 61, 0, 0, 62, 0,
3384 0, 0, 0, 0, 168, 169, 170, 171, 172, 173,
3385 174, 175, 176, 0, 0, 177, 178, 0, 116, 179,
3386 180, 181, 182, 0, 0, 0, 0, 0, 0, 0,
3387 0, 0, 0, 183, 184, 0, 0, 0, 0, 0,
3388 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3389 0, 0, 0, 0, 0, 0, 185, 186, 187, 188,
3390 189, 190, 191, 192, 193, 194, 0, 195, 196, 603,
3391 604, 0, 0, 605, 0, 197, 266, 0, 0, 0,
3392 0, 0, 0, 0, 0, 0, 0, 0, 168, 169,
3393 170, 171, 172, 173, 174, 175, 176, 0, 0, 177,
3394 178, 0, 0, 179, 180, 181, 182, 0, 0, 0,
3395 0, 0, 0, 0, 0, 0, 0, 183, 184, 0,
3396 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3397 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3398 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
3399 0, 195, 196, 624, 596, 0, 0, 625, 0, 197,
3400 266, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3401 0, 0, 168, 169, 170, 171, 172, 173, 174, 175,
3402 176, 0, 0, 177, 178, 0, 0, 179, 180, 181,
3403 182, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3404 0, 183, 184, 0, 0, 0, 0, 0, 0, 0,
3405 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3406 0, 0, 0, 0, 185, 186, 187, 188, 189, 190,
3407 191, 192, 193, 194, 0, 195, 196, 609, 604, 0,
3408 0, 610, 0, 197, 266, 0, 0, 0, 0, 0,
3409 0, 0, 0, 0, 0, 0, 168, 169, 170, 171,
3410 172, 173, 174, 175, 176, 0, 0, 177, 178, 0,
3411 0, 179, 180, 181, 182, 0, 0, 0, 0, 0,
3412 0, 0, 0, 0, 0, 183, 184, 0, 0, 0,
3413 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3414 0, 0, 0, 0, 0, 0, 0, 0, 185, 186,
3415 187, 188, 189, 190, 191, 192, 193, 194, 0, 195,
3416 196, 640, 596, 0, 0, 641, 0, 197, 266, 0,
3417 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3418 168, 169, 170, 171, 172, 173, 174, 175, 176, 0,
3419 0, 177, 178, 0, 0, 179, 180, 181, 182, 0,
3420 0, 0, 0, 0, 0, 0, 0, 0, 0, 183,
3421 184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3422 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3423 0, 0, 185, 186, 187, 188, 189, 190, 191, 192,
3424 193, 194, 0, 195, 196, 643, 604, 0, 0, 644,
3425 0, 197, 266, 0, 0, 0, 0, 0, 0, 0,
3426 0, 0, 0, 0, 168, 169, 170, 171, 172, 173,
3427 174, 175, 176, 0, 0, 177, 178, 0, 0, 179,
3428 180, 181, 182, 0, 0, 0, 0, 0, 0, 0,
3429 0, 0, 0, 183, 184, 0, 0, 0, 0, 0,
3430 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3431 0, 0, 0, 0, 0, 0, 185, 186, 187, 188,
3432 189, 190, 191, 192, 193, 194, 0, 195, 196, 650,
3433 596, 0, 0, 651, 0, 197, 266, 0, 0, 0,
3434 0, 0, 0, 0, 0, 0, 0, 0, 168, 169,
3435 170, 171, 172, 173, 174, 175, 176, 0, 0, 177,
3436 178, 0, 0, 179, 180, 181, 182, 0, 0, 0,
3437 0, 0, 0, 0, 0, 0, 0, 183, 184, 0,
3438 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3439 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3440 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
3441 0, 195, 196, 653, 604, 0, 0, 654, 0, 197,
3442 266, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3443 0, 0, 168, 169, 170, 171, 172, 173, 174, 175,
3444 176, 0, 0, 177, 178, 0, 0, 179, 180, 181,
3445 182, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3446 0, 183, 184, 0, 0, 0, 0, 0, 0, 0,
3447 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3448 0, 0, 0, 0, 185, 186, 187, 188, 189, 190,
3449 191, 192, 193, 194, 0, 195, 196, 689, 596, 0,
3450 0, 690, 0, 197, 266, 0, 0, 0, 0, 0,
3451 0, 0, 0, 0, 0, 0, 168, 169, 170, 171,
3452 172, 173, 174, 175, 176, 0, 0, 177, 178, 0,
3453 0, 179, 180, 181, 182, 0, 0, 0, 0, 0,
3454 0, 0, 0, 0, 0, 183, 184, 0, 0, 0,
3455 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3456 0, 0, 0, 0, 0, 0, 0, 0, 185, 186,
3457 187, 188, 189, 190, 191, 192, 193, 194, 0, 195,
3458 196, 692, 604, 0, 0, 693, 0, 197, 266, 0,
3459 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3460 168, 169, 170, 171, 172, 173, 174, 175, 176, 0,
3461 0, 177, 178, 0, 0, 179, 180, 181, 182, 0,
3462 0, 0, 0, 0, 0, 0, 0, 0, 0, 183,
3463 184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3464 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3465 0, 0, 185, 186, 187, 188, 189, 190, 191, 192,
3466 193, 194, 0, 195, 196, 836, 596, 0, 0, 837,
3467 0, 197, 266, 0, 0, 0, 0, 0, 0, 0,
3468 0, 0, 0, 0, 168, 169, 170, 171, 172, 173,
3469 174, 175, 176, 0, 0, 177, 178, 0, 0, 179,
3470 180, 181, 182, 0, 0, 0, 0, 0, 0, 0,
3471 0, 0, 0, 183, 184, 0, 0, 0, 0, 0,
3472 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3473 0, 0, 0, 0, 0, 0, 185, 186, 187, 188,
3474 189, 190, 191, 192, 193, 194, 0, 195, 196, 839,
3475 604, 0, 0, 840, 0, 197, 266, 0, 0, 0,
3476 0, 0, 0, 0, 0, 0, 0, 0, 168, 169,
3477 170, 171, 172, 173, 174, 175, 176, 0, 0, 177,
3478 178, 0, 0, 179, 180, 181, 182, 0, 0, 0,
3479 0, 0, 0, 0, 0, 0, 0, 183, 184, 0,
3480 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3481 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3482 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
3483 0, 195, 196, 994, 596, 0, 0, 995, 0, 197,
3484 266, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3485 0, 0, 168, 169, 170, 171, 172, 173, 174, 175,
3486 176, 0, 0, 177, 178, 0, 0, 179, 180, 181,
3487 182, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3488 0, 183, 184, 0, 0, 0, 0, 0, 0, 0,
3489 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3490 0, 0, 0, 0, 185, 186, 187, 188, 189, 190,
3491 191, 192, 193, 194, 0, 195, 196, 1007, 596, 0,
3492 0, 1008, 0, 197, 266, 0, 0, 0, 0, 0,
3493 0, 0, 0, 0, 0, 0, 168, 169, 170, 171,
3494 172, 173, 174, 175, 176, 0, 0, 177, 178, 0,
3495 0, 179, 180, 181, 182, 0, 0, 0, 0, 0,
3496 0, 0, 0, 0, 0, 183, 184, 0, 0, 0,
3497 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3498 0, 0, 0, 0, 0, 0, 0, 0, 185, 186,
3499 187, 188, 189, 190, 191, 192, 193, 194, 0, 195,
3500 196, 1010, 604, 0, 0, 1011, 0, 197, 266, 0,
3501 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3502 168, 169, 170, 171, 172, 173, 174, 175, 176, 0,
3503 0, 177, 178, 0, 0, 179, 180, 181, 182, 0,
3504 0, 0, 0, 0, 0, 0, 0, 0, 0, 183,
3505 184, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3506 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3507 0, 0, 185, 186, 187, 188, 189, 190, 191, 192,
3508 193, 194, 0, 195, 196, 609, 604, 0, 0, 610,
3509 0, 197, 266, 0, 0, 0, 0, 0, 0, 0,
3510 0, 0, 0, 0, 168, 169, 170, 171, 172, 173,
3511 174, 175, 176, 0, 0, 177, 178, 0, 0, 179,
3512 180, 181, 182, 0, 0, 0, 0, 0, 0, 0,
3513 0, 0, 0, 183, 184, 0, 0, 0, 0, 0,
3514 0, 0, 0, 0, 0, 0, 0, 0, 732, 0,
3515 0, 0, 0, 0, 0, 0, 185, 186, 187, 188,
3516 189, 190, 191, 192, 193, 194, 0, 195, 196, 0,
3517 0, 0, 0, 0, 0, 197, 353, 354, 355, 356,
3518 357, 358, 359, 360, 361, 362, 363, 364, 365, 0,
3519 0, 366, 367, 353, 354, 355, 356, 357, 358, 359,
3520 360, 361, 362, 363, 364, 365, 0, 0, 366, 367,
3521 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3522 0, 0, 0, 0, 368, 0, 369, 370, 371, 372,
3523 373, 374, 375, 376, 377, 378, 0, 0, 0, 0,
3524 0, 368, 0, 369, 370, 371, 372, 373, 374, 375,
3525 376, 377, 378, 353, 354, 355, 356, 357, 358, 359,
3526 360, 361, 362, 363, 364, 365, 0, 242, 366, 367,
3527 0, 0, 353, 354, 355, 356, 357, 358, 359, 360,
3528 361, 362, 363, 364, 365, 0, 0, 366, 367, 0,
3529 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3530 0, 368, 0, 369, 370, 371, 372, 373, 374, 375,
3531 376, 377, 378, 0, 0, 0, 0, 0, 0, 0,
3532 368, -260, 369, 370, 371, 372, 373, 374, 375, 376,
3533 377, 378, 0, 0, 0, 0, 0, 0, 0, 0,
3534 -261, 353, 354, 355, 356, 357, 358, 359, 360, 361,
3535 362, 363, 364, 365, 0, 0, 366, 367, 0, 0,
3536 353, 354, 355, 356, 357, 358, 359, 360, 361, 362,
3537 363, 364, 365, 0, 0, 366, 367, 0, 0, 0,
3538 0, 0, 0, 0, 0, 0, 0, 0, 0, 368,
3539 0, 369, 370, 371, 372, 373, 374, 375, 376, 377,
3540 378, 0, 0, 0, 0, 0, 0, 0, 368, -262,
3541 369, 370, 371, 372, 373, 374, 375, 376, 377, 378,
3542 0, 0, 0, 0, 0, 0, 0, 0, -263, 353,
3543 354, 355, 356, 357, 358, 359, 360, 361, 362, 363,
3544 364, 365, 0, 0, 366, 367, 0, 0, 0, 447,
3545 353, 354, 355, 356, 357, 358, 359, 360, 361, 362,
3546 363, 364, 365, 0, 0, 366, 367, 0, 0, 0,
3547 0, 0, 0, 0, 0, 0, 0, 368, 0, 369,
3548 370, 371, 372, 373, 374, 375, 376, 377, 378, 0,
3549 0, 0, 0, 0, 0, 0, 0, 0, 368, 0,
3550 369, 370, 371, 372, 373, 374, 375, 376, 377, 378,
3551 353, 354, 355, 356, 357, 358, 359, 360, 361, 362,
3552 363, -595, -595, 0, 0, 366, 367, 353, 354, 355,
3553 356, 357, 358, 359, 360, 0, 362, 363, 0, 0,
3554 0, 0, 366, 367, 0, 0, 0, 0, 0, 0,
3555 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3556 369, 370, 371, 372, 373, 374, 375, 376, 377, 378,
3557 0, 0, 0, 0, 0, 0, 0, 369, 370, 371,
3558 372, 373, 374, 375, 376, 377, 378, 353, 354, 355,
3559 356, 357, 358, 359, 0, 0, 362, 363, 0, 0,
3560 0, 0, 366, 367, 0, 0, 0, 0, 0, 0,
3561 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3562 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3563 0, 0, 0, 0, 0, 0, 0, 369, 370, 371,
3564 372, 373, 374, 375, 376, 377, 378
3565 };
3566
3567 static const yytype_int16 yycheck[] =
3568 {
3569 2, 308, 308, 83, 84, 27, 436, 213, 14, 78,
3570 2, 10, 4, 5, 6, 27, 15, 9, 10, 21,
3571 85, 13, 28, 15, 16, 17, 7, 262, 20, 381,
3572 2, 7, 4, 28, 67, 22, 4, 303, 14, 54,
3573 379, 15, 296, 454, 383, 427, 300, 386, 64, 352,
3574 52, 53, 28, 405, 50, 16, 17, 721, 50, 20,
3575 450, 492, 54, 320, 454, 442, 114, 406, 636, 421,
3576 16, 17, 64, 484, 20, 56, 515, 645, 430, 795,
3577 56, 420, 709, 422, 912, 26, 78, 57, 889, 391,
3578 392, 52, 431, 67, 5, 6, 21, 22, 26, 16,
3579 612, 613, 13, 142, 25, 107, 29, 146, 16, 17,
3580 89, 91, 20, 25, 101, 285, 58, 59, 60, 61,
3581 25, 113, 89, 115, 103, 321, 557, 57, 324, 209,
3582 326, 470, 328, 89, 330, 25, 89, 289, 25, 119,
3583 220, 293, 494, 54, 52, 53, 25, 16, 17, 119,
3584 51, 20, 91, 27, 55, 51, 495, 53, 54, 55,
3585 56, 89, 140, 26, 0, 25, 145, 78, 146, 997,
3586 16, 17, 136, 69, 20, 103, 101, 91, 145, 349,
3587 119, 25, 107, 108, 55, 442, 987, 706, 111, 145,
3588 89, 121, 145, 407, 28, 136, 113, 352, 123, 116,
3589 117, 281, 509, 509, 740, 119, 52, 53, 136, 745,
3590 138, 18, 204, 20, 142, 214, 215, 145, 26, 140,
3591 140, 142, 214, 215, 459, 305, 492, 144, 140, 146,
3592 142, 947, 50, 80, 303, 140, 391, 392, 750, 113,
3593 91, 87, 116, 117, 140, 909, 145, 72, 912, 260,
3594 140, 262, 233, 140, 287, 119, 91, 233, 260, 89,
3595 262, 140, 295, 296, 266, 676, 893, 300, 119, 243,
3596 144, 91, 146, 136, 266, 532, 140, 124, 270, 142,
3597 140, 89, 274, 275, 295, 675, 676, 279, 665, 285,
3598 119, 557, 284, 285, 91, 103, 140, 115, 729, 119,
3599 292, 142, 101, 455, 129, 130, 131, 89, 89, 270,
3600 462, 303, 284, 287, 882, 145, 89, 119, 89, 142,
3601 292, 473, 119, 123, 270, 55, 632, 126, 136, 89,
3602 138, 347, 635, 997, 530, 350, 352, 145, 91, 338,
3603 339, 340, 341, 140, 119, 337, 338, 339, 340, 341,
3604 342, 343, 344, 349, 25, 347, 404, 349, 350, 91,
3605 352, 55, 270, 145, 145, 337, 805, 91, 887, 337,
3606 342, 313, 145, 16, 145, 391, 392, 113, 897, 381,
3607 116, 117, 734, 822, 823, 145, 347, 119, 89, 381,
3608 909, 352, 303, 140, 733, 119, 735, 266, 780, 391,
3609 392, 270, 103, 405, 556, 662, 20, 383, 665, 623,
3610 386, 140, 414, 405, 60, 407, 408, 63, 57, 421,
3611 266, 490, 136, 492, 270, 417, 448, 72, 430, 421,
3612 406, 91, 686, 425, 669, 737, 448, 138, 430, 350,
3613 742, 743, 119, 435, 145, 143, 422, 458, 459, 91,
3614 757, 757, 882, 137, 660, 431, 458, 459, 383, 119,
3615 466, 279, 108, 729, 139, 467, 16, 285, 58, 59,
3616 113, 466, 883, 116, 117, 467, 55, 119, 439, 631,
3617 140, 406, 1001, 457, 476, 37, 38, 567, 557, 91,
3618 466, 89, 494, 883, 470, 467, 1015, 422, 490, 91,
3619 492, 144, 494, 146, 476, 103, 431, 2, 722, 4,
3620 140, 513, 381, 515, 9, 10, 72, 119, 72, 495,
3621 15, 16, 17, 91, 963, 20, 98, 119, 91, 786,
3622 91, 349, 140, 685, 748, 381, 405, 15, 140, 531,
3623 138, 13, 450, 554, 758, 470, 848, 145, 550, 16,
3624 608, 119, 421, 611, 789, 50, 119, 15, 119, 405,
3625 866, 430, 584, 113, 63, 557, 116, 117, 143, 64,
3626 495, 629, 584, 481, 143, 421, 731, 140, 26, 490,
3627 137, 492, 737, 89, 430, 140, 800, 742, 743, 113,
3628 140, 140, 116, 117, 144, 16, 146, 103, 51, 417,
3629 53, 54, 55, 56, 450, 51, 608, 425, 454, 611,
3630 612, 613, 140, 600, 44, 89, 69, 435, 113, 140,
3631 115, 608, 146, 622, 611, 494, 978, 629, 89, 103,
3632 622, 623, 138, 635, 636, 481, 638, 140, 484, 145,
3633 979, 89, 103, 645, 796, 859, 557, 51, 494, 660,
3634 656, 140, 633, 686, 91, 103, 655, 633, 669, 51,
3635 729, 656, 868, 655, 138, 58, 59, 669, 874, 16,
3636 17, 145, 140, 20, 635, 600, 62, 138, 64, 65,
3637 656, 746, 119, 608, 145, 697, 611, 140, 136, 139,
3638 138, 119, 113, 848, 142, 116, 117, 145, 89, 139,
3639 47, 48, 627, 140, 629, 52, 53, 17, 18, 204,
3640 862, 863, 103, 531, 15, 731, 930, 64, 65, 214,
3641 215, 737, 738, 144, 18, 146, 742, 743, 114, 115,
3642 722, 51, 734, 53, 54, 55, 56, 729, 730, 731,
3643 818, 819, 734, 72, 139, 737, 738, 138, 750, 69,
3644 742, 743, 139, 137, 145, 15, 748, 749, 730, 735,
3645 137, 763, 26, 91, 766, 139, 758, 675, 146, 768,
3646 524, 266, 526, 765, 137, 270, 768, 15, 789, 274,
3647 275, 92, 37, 38, 279, 777, 778, 789, 14, 284,
3648 285, 119, 113, 785, 15, 116, 117, 292, 127, 128,
3649 129, 130, 131, 805, 391, 392, 818, 819, 800, 801,
3650 735, 62, 140, 64, 65, 15, 140, 143, 729, 51,
3651 822, 823, 144, 57, 140, 89, 140, 140, 820, 675,
3652 676, 140, 848, 825, 140, 140, 423, 424, 140, 103,
3653 72, 140, 337, 338, 339, 340, 341, 342, 343, 344,
3654 15, 139, 347, 933, 349, 15, 848, 352, 113, 137,
3655 15, 116, 117, 114, 115, 734, 858, 859, 100, 101,
3656 15, 15, 136, 140, 138, 867, 9, 10, 142, 871,
3657 882, 145, 15, 15, 471, 89, 381, 89, 734, 144,
3658 137, 146, 55, 124, 126, 124, 391, 392, 137, 103,
3659 61, 103, 89, 64, 65, 252, 253, 254, 255, 820,
3660 405, 15, 407, 408, 825, 89, 103, 55, 140, 266,
3661 140, 61, 417, 270, 64, 65, 421, 949, 15, 103,
3662 425, 749, 140, 140, 138, 430, 138, 949, 930, 140,
3663 435, 145, 706, 145, 936, 709, 938, 765, 89, 941,
3664 15, 138, 140, 114, 115, 142, 867, 721, 145, 777,
3665 778, 963, 103, 140, 138, 113, 142, 785, 116, 117,
3666 142, 145, 467, 139, 114, 115, 978, 467, 980, 981,
3667 113, 476, 140, 801, 13, 26, 978, 6, 981, 987,
3668 63, 64, 65, 721, 980, 207, 144, 138, 146, 494,
3669 347, 213, 747, 979, 145, 352, 353, 354, 355, 356,
3670 357, 358, 359, 360, 361, 362, 363, 364, 365, 366,
3671 367, 368, 369, 370, 371, 372, 373, 374, 375, 376,
3672 377, 378, 245, 7, 381, 721, 531, 883, 250, 866,
3673 858, 114, 115, 700, 391, 392, 261, 906, 89, 26,
3674 89, 909, 706, 871, 979, 809, 810, 811, 405, 813,
3675 -1, 815, 103, -1, 103, 89, -1, 2, -1, 4,
3676 5, 6, 419, -1, 421, -1, 423, 424, 13, 103,
3677 -1, 214, 215, 430, 89, -1, -1, 63, 64, 65,
3678 -1, -1, 439, -1, -1, 136, 443, 138, 103, 138,
3679 447, 142, -1, 450, 145, 452, 145, 454, -1, 978,
3680 -1, -1, 89, -1, 138, 50, -1, 89, 936, 54,
3681 938, 145, -1, 941, 471, 337, 103, 622, 623, 893,
3682 -1, 103, 978, 138, 481, -1, -1, 484, 114, 115,
3683 145, 274, 275, 78, -1, 909, -1, 494, 912, -1,
3684 737, 738, -1, -1, -1, 742, 743, -1, -1, 136,
3685 655, 138, -1, -1, 511, 142, 138, -1, 145, -1,
3686 696, -1, -1, 145, 51, 522, 53, 54, 55, 56,
3687 115, -1, -1, 709, 771, 772, 712, 774, 775, 63,
3688 64, 65, 69, 540, 541, 721, -1, -1, -1, -1,
3689 954, 955, 956, 957, 551, 338, 339, 340, 341, -1,
3690 343, 344, -1, -1, 426, 427, 93, 700, -1, -1,
3691 906, 704, 99, 909, 700, -1, 912, 722, 914, 63,
3692 64, 65, -1, 997, -1, 730, 731, -1, 721, 734,
3693 114, 115, 737, 738, -1, 721, -1, 742, 743, 63,
3694 64, 65, -1, 748, 749, -1, -1, -1, 63, 64,
3695 65, 848, -1, 758, 476, 1019, -1, -1, -1, 204,
3696 765, 483, -1, 768, -1, 408, -1, -1, 964, -1,
3697 114, 115, 777, 778, -1, -1, -1, -1, 635, 876,
3698 785, 40, 41, 42, 43, 44, -1, 2, -1, 4,
3699 114, 115, -1, -1, -1, 800, 801, -1, 13, 114,
3700 115, 997, -1, 999, -1, 1001, -1, 1003, -1, 666,
3701 63, 64, 65, -1, -1, -1, -1, -1, 675, 676,
3702 -1, -1, -1, 51, -1, 53, 54, 55, 56, -1,
3703 -1, -1, 1028, -1, 279, 50, 63, 64, 65, 284,
3704 285, 69, -1, 848, 72, -1, -1, 292, -1, -1,
3705 -1, -1, -1, 858, 859, 827, 828, 893, 303, 895,
3706 -1, 114, 115, 899, -1, 93, 871, -1, -1, 726,
3707 -1, 99, 100, 101, 731, 732, 912, 734, 914, -1,
3708 737, 738, -1, -1, -1, 742, 743, 114, 115, -1,
3709 -1, -1, 337, -1, -1, -1, -1, 342, 126, 621,
3710 115, 129, -1, -1, 349, 350, -1, 352, -1, 945,
3711 946, -1, 140, 906, 771, 772, 909, 774, 775, 912,
3712 906, 914, -1, 909, -1, 930, 912, 784, 914, -1,
3713 -1, 936, -1, 938, -1, -1, 941, 909, 660, -1,
3714 -1, -1, -1, -1, -1, -1, 391, 392, -1, 985,
3715 -1, -1, -1, 2, 990, 4, 5, 6, 7, -1,
3716 -1, 997, 407, 999, 13, -1, -1, 1003, -1, -1,
3717 -1, 964, 417, 978, 831, -1, -1, -1, 964, 622,
3718 425, 1017, -1, -1, 841, 842, -1, -1, -1, 204,
3719 435, 848, 1028, -1, -1, 967, 968, 969, -1, 971,
3720 972, 50, -1, -1, 997, 54, 999, -1, 1001, -1,
3721 1003, 997, 655, 999, -1, 1001, -1, 1003, -1, 876,
3722 -1, -1, 467, -1, 72, -1, 883, -1, -1, 78,
3723 752, 476, -1, -1, -1, 1028, -1, 759, -1, 87,
3724 88, 72, 1028, -1, 2, 490, 4, 492, 1020, 1021,
3725 1022, 1023, 72, -1, -1, -1, 87, 88, 780, -1,
3726 1032, -1, -1, -1, 279, -1, 115, 87, 88, 284,
3727 285, 51, -1, 53, 54, 55, 56, 292, 126, 127,
3728 128, 129, 130, 131, 113, -1, 531, 116, 117, 69,
3729 -1, -1, 50, 124, 125, 126, 127, 128, 129, 130,
3730 131, -1, -1, -1, -1, -1, -1, 127, 128, 129,
3731 130, 131, 557, 93, 143, 144, -1, 146, -1, 99,
3732 113, 978, 337, 116, 117, 768, 51, 342, 53, 54,
3733 55, 56, -1, -1, 349, -1, -1, 352, 51, -1,
3734 53, 54, 55, 56, 69, -1, 868, 140, -1, -1,
3735 -1, 144, 874, 146, -1, 204, 69, 115, -1, 72,
3736 -1, -1, -1, -1, -1, -1, -1, -1, 93, -1,
3737 -1, -1, -1, -1, -1, -1, 391, 392, 623, -1,
3738 93, -1, -1, -1, -1, -1, 99, 100, 101, -1,
3739 -1, 51, 407, 53, 54, 55, 56, -1, -1, -1,
3740 -1, -1, 417, -1, -1, -1, -1, -1, -1, 69,
3741 425, -1, 72, 126, -1, -1, 129, -1, -1, -1,
3742 435, -1, -1, -1, -1, -1, -1, -1, -1, 142,
3743 279, -1, -1, 93, -1, 284, 285, -1, -1, 99,
3744 100, 101, -1, 292, -1, -1, 204, -1, -1, -1,
3745 -1, -1, 467, -1, 303, -1, -1, -1, -1, -1,
3746 51, 476, 53, 54, 55, 56, 126, -1, -1, 129,
3747 -1, -1, -1, -1, -1, -1, -1, 722, 69, -1,
3748 -1, 72, 142, -1, 729, 730, 731, -1, 337, -1,
3749 -1, -1, 737, 342, -1, -1, -1, 742, 743, -1,
3750 349, 350, 93, 748, 749, -1, -1, -1, 99, 100,
3751 101, -1, -1, 758, -1, -1, 531, -1, -1, -1,
3752 765, 279, -1, -1, -1, -1, 284, 285, -1, -1,
3753 -1, -1, 777, 778, 292, 126, -1, -1, 129, -1,
3754 785, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3755 -1, -1, -1, -1, -1, 800, 801, -1, 407, -1,
3756 -1, -1, -1, -1, -1, -1, -1, 51, 417, 53,
3757 54, 55, 56, -1, -1, 820, 425, -1, -1, 337,
3758 825, -1, -1, -1, 342, 69, 435, -1, 72, -1,
3759 -1, 349, -1, -1, 352, -1, -1, -1, -1, -1,
3760 84, -1, -1, 848, -1, -1, -1, -1, 623, 93,
3761 -1, -1, -1, 858, 859, 99, 100, 101, 467, -1,
3762 -1, -1, 867, -1, -1, -1, 871, 476, -1, -1,
3763 -1, -1, -1, 391, 392, -1, -1, -1, -1, -1,
3764 -1, 490, 126, 492, -1, 129, -1, -1, 51, 407,
3765 53, 54, 55, 56, -1, -1, -1, -1, -1, 417,
3766 -1, -1, -1, -1, -1, -1, 69, 425, -1, 72,
3767 -1, -1, -1, -1, -1, -1, -1, 435, -1, -1,
3768 -1, -1, 531, -1, -1, 930, -1, -1, -1, -1,
3769 93, 936, -1, 938, -1, -1, 941, 100, 101, -1,
3770 -1, -1, -1, -1, -1, -1, -1, 722, 557, 467,
3771 -1, -1, -1, -1, -1, 730, 731, -1, 476, -1,
3772 -1, -1, 737, 126, -1, -1, -1, 742, 743, -1,
3773 -1, -1, -1, 748, 749, -1, -1, -1, -1, -1,
3774 -1, -1, -1, 758, -1, -1, -1, -1, -1, -1,
3775 765, 0, -1, -1, -1, -1, -1, -1, -1, -1,
3776 -1, -1, 777, 778, 13, 14, 15, 16, 17, 18,
3777 785, 20, -1, 531, 623, -1, -1, 26, 27, -1,
3778 -1, -1, -1, -1, -1, 800, 801, -1, 37, 38,
3779 -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
3780 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3781 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3782 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3783 -1, -1, -1, 848, -1, -1, -1, -1, -1, -1,
3784 89, -1, -1, 858, 859, -1, -1, -1, -1, -1,
3785 -1, -1, 867, -1, 103, -1, 871, -1, -1, -1,
3786 -1, -1, -1, -1, 113, 623, -1, 116, 117, -1,
3787 -1, -1, -1, 722, -1, -1, -1, -1, -1, -1,
3788 729, 730, -1, -1, -1, -1, -1, 136, 137, -1,
3789 -1, -1, -1, 142, 143, 144, 145, 146, -1, 748,
3790 749, -1, -1, -1, -1, -1, -1, -1, -1, 758,
3791 -1, -1, -1, -1, -1, 930, 765, -1, -1, -1,
3792 -1, 936, -1, 938, -1, -1, 941, -1, 777, 778,
3793 -1, -1, -1, -1, -1, -1, 785, -1, -1, -1,
3794 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3795 -1, 800, 801, -1, -1, -1, -1, -1, -1, -1,
3796 -1, -1, -1, -1, 722, -1, -1, -1, -1, -1,
3797 -1, 820, 730, 731, -1, -1, 825, -1, -1, 737,
3798 -1, -1, -1, -1, 742, 743, -1, -1, -1, -1,
3799 748, 749, -1, -1, -1, -1, -1, -1, -1, -1,
3800 758, -1, -1, -1, -1, -1, -1, 765, -1, 858,
3801 859, -1, -1, -1, -1, -1, -1, -1, 867, 777,
3802 778, -1, 871, -1, -1, -1, -1, 785, -1, -1,
3803 -1, -1, -1, -1, -1, -1, 44, -1, -1, -1,
3804 -1, -1, 800, 801, -1, -1, -1, -1, -1, -1,
3805 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3806 -1, -1, -1, -1, 72, 73, 74, 75, 76, 77,
3807 78, 79, 80, 81, 82, 83, 84, -1, -1, 87,
3808 88, 930, -1, -1, -1, -1, -1, 936, -1, 938,
3809 848, -1, 941, 72, 73, 74, 75, 76, 77, 78,
3810 858, 859, 81, 82, -1, -1, -1, -1, 87, 88,
3811 -1, -1, 120, 871, 122, 123, 124, 125, 126, 127,
3812 128, 129, 130, 131, -1, -1, -1, -1, -1, -1,
3813 -1, -1, 140, -1, -1, -1, -1, -1, -1, -1,
3814 -1, -1, -1, 122, 123, 124, 125, 126, 127, 128,
3815 129, 130, 131, -1, -1, -1, -1, -1, -1, -1,
3816 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3817 -1, -1, 930, -1, -1, -1, -1, -1, 936, -1,
3818 938, 0, 1, 941, 3, 4, 5, 6, 7, 8,
3819 9, 10, 11, 12, -1, -1, -1, -1, -1, -1,
3820 19, -1, 21, 22, 23, 24, -1, -1, -1, -1,
3821 -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3822 39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
3823 49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
3824 59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
3825 69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
3826 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3827 -1, 90, -1, -1, 93, 94, -1, 96, 97, -1,
3828 99, -1, -1, 102, -1, 104, 105, 106, 107, 108,
3829 109, 0, -1, 112, 113, -1, -1, 116, 117, -1,
3830 -1, -1, -1, -1, 13, 14, 15, 16, 17, 18,
3831 -1, 20, -1, 132, 133, 134, -1, -1, 27, 28,
3832 -1, -1, -1, -1, -1, 144, -1, 146, 37, 38,
3833 -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
3834 -1, -1, -1, -1, -1, -1, -1, -1, 57, -1,
3835 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3836 -1, -1, -1, 72, 73, 74, 75, 76, 77, 78,
3837 79, 80, 81, 82, 83, 84, -1, -1, 87, 88,
3838 89, -1, 91, 92, -1, -1, -1, -1, -1, 98,
3839 -1, -1, -1, -1, 103, -1, -1, -1, -1, -1,
3840 -1, -1, -1, -1, 113, -1, -1, 116, 117, -1,
3841 119, 120, -1, 122, 123, 124, 125, 126, 127, 128,
3842 129, 130, 131, -1, -1, 0, -1, -1, 137, 138,
3843 139, 140, -1, -1, 143, 144, 145, 146, 13, 14,
3844 15, 16, 17, 18, -1, 20, -1, -1, -1, -1,
3845 -1, -1, 27, 28, -1, -1, -1, -1, -1, -1,
3846 -1, -1, 37, 38, -1, 40, 41, 42, 43, 44,
3847 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3848 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3849 -1, -1, -1, -1, -1, -1, -1, 72, 73, 74,
3850 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
3851 -1, -1, 87, 88, 89, -1, -1, 92, -1, -1,
3852 -1, -1, -1, 98, -1, -1, -1, -1, 103, -1,
3853 -1, -1, -1, -1, -1, -1, -1, -1, 113, -1,
3854 -1, 116, 117, -1, -1, 120, -1, 122, 123, 124,
3855 125, 126, 127, 128, 129, 130, 131, -1, -1, 0,
3856 -1, -1, 137, 138, 139, 140, -1, 142, 143, 144,
3857 145, 146, 13, 14, 15, -1, 17, 18, -1, 20,
3858 -1, -1, -1, -1, -1, 26, -1, -1, -1, -1,
3859 -1, -1, -1, -1, -1, -1, 37, 38, -1, 40,
3860 41, 42, 43, 44, -1, -1, -1, -1, -1, -1,
3861 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3862 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3863 -1, 72, 73, 74, 75, 76, 77, 78, 79, 80,
3864 81, 82, 83, 84, -1, -1, 87, 88, 89, -1,
3865 91, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3866 -1, -1, 103, -1, -1, -1, -1, -1, -1, -1,
3867 -1, -1, 113, -1, -1, 116, 117, -1, 119, 120,
3868 -1, 122, 123, 124, 125, 126, 127, 128, 129, 130,
3869 131, -1, -1, 0, -1, 136, 137, 138, -1, 140,
3870 -1, -1, 143, 144, 145, 146, 13, 14, 15, -1,
3871 17, 18, -1, 20, -1, -1, -1, -1, -1, 26,
3872 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3873 37, 38, -1, 40, 41, 42, 43, 44, -1, -1,
3874 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3875 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3876 -1, -1, -1, -1, -1, 72, 73, 74, 75, 76,
3877 77, 78, 79, 80, 81, 82, 83, 84, -1, -1,
3878 87, 88, 89, -1, 91, -1, -1, -1, -1, -1,
3879 -1, -1, -1, -1, -1, -1, 103, -1, -1, -1,
3880 -1, -1, -1, -1, -1, -1, 113, -1, -1, 116,
3881 117, -1, 119, 120, -1, 122, 123, 124, 125, 126,
3882 127, 128, 129, 130, 131, -1, -1, 0, -1, 136,
3883 137, 138, -1, 140, -1, -1, 143, 144, 145, 146,
3884 13, 14, 15, -1, 17, 18, -1, 20, -1, -1,
3885 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3886 -1, -1, -1, -1, 37, 38, -1, 40, 41, 42,
3887 43, 44, -1, -1, -1, -1, -1, -1, -1, -1,
3888 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3889 -1, -1, -1, -1, -1, -1, -1, -1, -1, 72,
3890 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
3891 83, 84, -1, -1, 87, 88, 89, -1, 91, -1,
3892 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3893 103, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3894 113, -1, -1, 116, 117, -1, 119, 120, -1, 122,
3895 123, 124, 125, 126, 127, 128, 129, 130, 131, -1,
3896 -1, 0, -1, -1, 137, 138, -1, 140, -1, -1,
3897 143, 144, 145, 146, 13, 14, 15, -1, 17, 18,
3898 -1, 20, -1, -1, -1, -1, -1, -1, -1, -1,
3899 -1, -1, -1, -1, -1, -1, -1, -1, 37, 38,
3900 -1, 40, 41, 42, 43, 44, -1, -1, -1, -1,
3901 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3902 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3903 -1, -1, -1, 72, 73, 74, 75, 76, 77, 78,
3904 79, 80, 81, 82, 83, 84, -1, -1, 87, 88,
3905 89, -1, 91, -1, -1, -1, -1, -1, -1, -1,
3906 -1, -1, -1, -1, 103, -1, -1, -1, -1, -1,
3907 -1, -1, -1, -1, 113, -1, -1, 116, 117, -1,
3908 119, 120, -1, 122, 123, 124, 125, 126, 127, 128,
3909 129, 130, 131, -1, -1, -1, -1, -1, 137, 138,
3910 -1, 140, -1, -1, 143, 144, 145, 146, 1, -1,
3911 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
3912 13, 14, 15, -1, -1, 18, 19, -1, 21, 22,
3913 23, 24, -1, -1, -1, -1, -1, 30, 31, 32,
3914 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3915 -1, -1, 45, -1, 47, 48, 49, 50, 51, 52,
3916 53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
3917 63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
3918 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3919 -1, -1, -1, -1, -1, -1, -1, 90, -1, -1,
3920 93, 94, -1, 96, 97, -1, 99, -1, -1, 102,
3921 -1, 104, 105, 106, 107, 108, 109, -1, -1, 112,
3922 113, -1, -1, 116, 117, -1, -1, -1, -1, -1,
3923 -1, -1, -1, -1, -1, -1, -1, -1, -1, 132,
3924 133, 134, -1, -1, -1, -1, -1, -1, -1, -1,
3925 -1, 144, 1, 146, 3, 4, 5, 6, 7, 8,
3926 9, 10, 11, 12, -1, -1, 15, -1, 17, 18,
3927 19, -1, 21, 22, 23, 24, -1, -1, -1, -1,
3928 -1, 30, 31, 32, 33, 34, 35, 36, -1, -1,
3929 39, -1, -1, -1, -1, -1, 45, -1, 47, 48,
3930 49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
3931 59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
3932 69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
3933 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3934 -1, 90, -1, -1, 93, 94, -1, 96, 97, -1,
3935 99, -1, -1, 102, -1, 104, 105, 106, 107, 108,
3936 109, -1, -1, 112, 113, -1, -1, 116, 117, -1,
3937 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3938 -1, -1, -1, 132, 133, 134, -1, -1, -1, -1,
3939 -1, -1, -1, -1, -1, 144, 1, 146, 3, 4,
3940 5, 6, 7, 8, 9, 10, 11, 12, -1, -1,
3941 15, -1, -1, 18, 19, 20, 21, 22, 23, 24,
3942 -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
3943 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
3944 45, -1, 47, 48, 49, 50, 51, 52, 53, 54,
3945 55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
3946 -1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
3947 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3948 -1, -1, -1, -1, -1, 90, -1, -1, 93, 94,
3949 -1, 96, 97, -1, 99, -1, -1, 102, -1, 104,
3950 105, 106, 107, 108, 109, -1, -1, 112, 113, -1,
3951 -1, 116, 117, -1, -1, -1, -1, -1, -1, -1,
3952 -1, -1, -1, -1, -1, -1, -1, 132, 133, 134,
3953 -1, -1, -1, -1, -1, -1, -1, -1, -1, 144,
3954 1, 146, 3, 4, 5, 6, 7, 8, 9, 10,
3955 11, 12, -1, -1, 15, -1, -1, 18, 19, -1,
3956 21, 22, 23, 24, -1, -1, -1, -1, -1, 30,
3957 31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
3958 -1, -1, -1, -1, 45, -1, 47, 48, 49, 50,
3959 51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
3960 -1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
3961 71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3962 -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
3963 -1, -1, 93, 94, -1, 96, 97, -1, 99, -1,
3964 -1, 102, -1, 104, 105, 106, 107, 108, 109, -1,
3965 -1, 112, 113, -1, -1, 116, 117, 1, -1, 3,
3966 4, 5, 6, 7, 8, 9, 10, 11, 12, -1,
3967 -1, 132, 133, 134, -1, 19, -1, 21, 22, 23,
3968 24, -1, -1, 144, -1, 146, 30, 31, 32, 33,
3969 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
3970 -1, 45, 46, 47, 48, 49, 50, 51, 52, 53,
3971 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
3972 -1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
3973 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3974 -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
3975 94, -1, 96, 97, -1, 99, -1, -1, 102, -1,
3976 104, 105, 106, 107, 108, 109, -1, -1, 112, 113,
3977 -1, -1, 116, 117, -1, -1, -1, -1, -1, -1,
3978 -1, -1, -1, -1, -1, -1, -1, -1, 132, 133,
3979 134, -1, -1, 137, -1, -1, -1, -1, -1, -1,
3980 144, 1, 146, 3, 4, 5, 6, 7, 8, 9,
3981 10, 11, 12, -1, 14, 15, -1, -1, -1, 19,
3982 -1, 21, 22, 23, 24, -1, -1, -1, -1, -1,
3983 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
3984 -1, -1, -1, -1, -1, 45, -1, 47, 48, 49,
3985 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
3986 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
3987 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
3988 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
3989 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
3990 -1, -1, 102, -1, 104, 105, 106, 107, 108, 109,
3991 -1, -1, 112, 113, -1, -1, 116, 117, 1, -1,
3992 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
3993 -1, -1, 132, 133, 134, -1, 19, -1, 21, 22,
3994 23, 24, -1, -1, 144, -1, 146, 30, 31, 32,
3995 33, 34, 35, 36, -1, -1, 39, -1, -1, -1,
3996 -1, -1, 45, -1, 47, 48, 49, 50, 51, 52,
3997 53, 54, 55, 56, -1, 58, 59, 60, -1, -1,
3998 63, -1, -1, 66, 67, -1, 69, 70, 71, -1,
3999 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4000 -1, -1, -1, -1, -1, -1, -1, 90, -1, -1,
4001 93, 94, -1, 96, 97, -1, 99, -1, -1, 102,
4002 -1, 104, 105, 106, 107, 108, 109, -1, -1, 112,
4003 113, -1, -1, 116, 117, 1, -1, 3, 4, 5,
4004 6, 7, 8, 9, 10, 11, 12, -1, -1, 132,
4005 133, 134, -1, 19, -1, 21, 22, 23, 24, -1,
4006 143, 144, -1, 146, 30, 31, 32, 33, 34, 35,
4007 36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
4008 -1, 47, 48, 49, 50, 51, 52, 53, 54, 55,
4009 56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
4010 66, 67, -1, 69, 70, 71, -1, -1, -1, -1,
4011 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4012 -1, -1, -1, -1, 90, -1, -1, 93, 94, -1,
4013 96, 97, -1, 99, -1, -1, 102, -1, 104, 105,
4014 106, 107, 108, 109, -1, -1, 112, 113, -1, -1,
4015 116, 117, 1, -1, 3, 4, 5, 6, 7, 8,
4016 9, 10, 11, 12, -1, -1, 132, 133, 134, -1,
4017 19, -1, 21, 22, 23, 24, -1, 143, 144, -1,
4018 146, 30, 31, 32, 33, 34, 35, 36, -1, -1,
4019 39, -1, -1, -1, -1, -1, 45, -1, 47, 48,
4020 49, 50, 51, 52, 53, 54, 55, 56, -1, 58,
4021 59, 60, -1, -1, 63, -1, -1, 66, 67, -1,
4022 69, 70, 71, -1, -1, -1, -1, -1, -1, -1,
4023 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4024 -1, 90, -1, -1, 93, 94, -1, 96, 97, -1,
4025 99, -1, -1, 102, -1, 104, 105, 106, 107, 108,
4026 109, -1, -1, 112, 113, -1, -1, 116, 117, -1,
4027 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4028 -1, -1, -1, 132, 133, 134, -1, -1, 137, -1,
4029 -1, -1, -1, -1, -1, 144, 1, 146, 3, 4,
4030 5, 6, 7, 8, 9, 10, 11, 12, -1, -1,
4031 15, -1, -1, -1, 19, -1, 21, 22, 23, 24,
4032 -1, -1, -1, -1, -1, 30, 31, 32, 33, 34,
4033 35, 36, -1, -1, 39, -1, -1, -1, -1, -1,
4034 45, -1, 47, 48, 49, 50, 51, 52, 53, 54,
4035 55, 56, -1, 58, 59, 60, -1, -1, 63, -1,
4036 -1, 66, 67, -1, 69, 70, 71, -1, -1, -1,
4037 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4038 -1, -1, -1, -1, -1, 90, -1, -1, 93, 94,
4039 -1, 96, 97, -1, 99, -1, -1, 102, -1, 104,
4040 105, 106, 107, 108, 109, -1, -1, 112, 113, -1,
4041 -1, 116, 117, -1, -1, 3, 4, 5, 6, 7,
4042 8, 9, 10, 11, 12, -1, -1, 132, 133, 134,
4043 -1, 19, -1, 21, 22, 23, 24, -1, -1, 144,
4044 -1, 146, 30, 31, 32, 33, 34, 35, 36, -1,
4045 -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
4046 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
4047 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
4048 -1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
4049 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4050 -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
4051 -1, 99, -1, -1, 102, -1, 104, 105, 106, 107,
4052 108, 109, -1, -1, 112, 113, -1, -1, 116, 117,
4053 -1, -1, 3, 4, 5, 6, 7, 8, 9, 10,
4054 11, 12, -1, -1, 132, 133, 134, -1, 19, -1,
4055 21, 22, 23, 24, -1, -1, 144, -1, 146, 30,
4056 31, 32, 33, 34, 35, 36, -1, -1, 39, -1,
4057 -1, -1, -1, -1, 45, -1, 47, 48, 49, 50,
4058 51, 52, 53, 54, 55, 56, -1, 58, 59, 60,
4059 -1, -1, 63, -1, -1, 66, 67, -1, 69, 70,
4060 71, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4061 -1, -1, -1, -1, -1, -1, -1, -1, -1, 90,
4062 -1, -1, 93, 94, -1, 96, 97, -1, 99, -1,
4063 -1, 102, -1, 104, 105, 106, 107, 108, 109, -1,
4064 -1, 112, 113, -1, -1, 116, 117, -1, -1, 3,
4065 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
4066 -1, 132, 133, 134, -1, 19, -1, 21, 22, 23,
4067 24, -1, -1, 144, -1, 146, 30, 31, 32, 33,
4068 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4069 -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
4070 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
4071 -1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
4072 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4073 -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
4074 94, -1, 96, 97, -1, -1, -1, -1, 102, -1,
4075 104, 105, 106, 107, 108, 109, -1, -1, 112, 113,
4076 -1, -1, 116, 117, -1, -1, -1, -1, -1, -1,
4077 -1, -1, -1, -1, -1, -1, -1, -1, 132, 133,
4078 134, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4079 144, -1, 146, 3, 4, 5, 6, 7, 8, 9,
4080 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
4081 20, 21, 22, 23, 24, 25, 26, -1, -1, -1,
4082 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
4083 -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
4084 50, 51, 52, 53, 54, 55, 56, -1, -1, -1,
4085 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4086 70, 71, 72, 73, 74, 75, 76, 77, 78, -1,
4087 -1, 81, 82, -1, -1, 85, 86, 87, 88, -1,
4088 -1, -1, -1, -1, -1, -1, -1, -1, -1, 99,
4089 100, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4090 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4091 -1, -1, 122, 123, 124, 125, 126, 127, 128, 129,
4092 130, 131, -1, 133, 134, -1, -1, -1, -1, -1,
4093 -1, 141, 142, 3, 4, 5, 6, 7, 8, 9,
4094 10, 11, -1, -1, -1, -1, -1, -1, -1, 19,
4095 -1, 21, 22, 23, 24, -1, 26, -1, -1, -1,
4096 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4097 -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
4098 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
4099 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
4100 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
4101 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4102 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
4103 100, 101, 102, -1, 104, 105, 106, 107, 108, 109,
4104 -1, -1, 112, -1, -1, -1, -1, -1, -1, -1,
4105 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4106 -1, -1, 132, 133, 134, -1, 136, -1, -1, -1,
4107 -1, -1, 142, 3, 4, 5, 6, 7, 8, 9,
4108 10, 11, -1, -1, -1, -1, -1, -1, -1, 19,
4109 -1, 21, 22, 23, 24, -1, 26, -1, -1, -1,
4110 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4111 -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
4112 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
4113 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
4114 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
4115 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4116 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
4117 100, 101, 102, -1, 104, 105, 106, 107, 108, 109,
4118 -1, -1, 112, -1, -1, -1, -1, -1, -1, -1,
4119 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4120 -1, -1, 132, 133, 134, -1, 136, -1, -1, -1,
4121 -1, -1, 142, 3, 4, 5, 6, 7, 8, 9,
4122 10, 11, -1, -1, -1, -1, -1, -1, -1, 19,
4123 -1, 21, 22, 23, 24, -1, 26, -1, -1, -1,
4124 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4125 -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
4126 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
4127 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
4128 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
4129 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4130 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
4131 100, 101, 102, -1, 104, 105, 106, 107, 108, 109,
4132 -1, -1, 112, -1, -1, -1, -1, -1, -1, 3,
4133 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
4134 -1, -1, 132, 133, 134, 19, 136, 21, 22, 23,
4135 24, -1, 142, -1, -1, -1, 30, 31, 32, 33,
4136 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4137 -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
4138 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
4139 -1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
4140 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4141 -1, -1, -1, -1, -1, -1, 90, 91, -1, 93,
4142 94, -1, 96, 97, -1, 99, 100, 101, 102, -1,
4143 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
4144 -1, -1, -1, -1, -1, 119, 3, 4, 5, 6,
4145 7, 8, 9, 10, 11, -1, -1, -1, 132, 133,
4146 134, -1, 19, -1, 21, 22, 23, 24, 142, -1,
4147 -1, -1, -1, 30, 31, 32, 33, 34, 35, 36,
4148 -1, -1, 39, -1, -1, -1, -1, -1, -1, -1,
4149 -1, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4150 -1, 58, 59, 60, -1, -1, 63, -1, -1, 66,
4151 67, -1, 69, 70, 71, -1, -1, -1, -1, -1,
4152 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4153 -1, -1, -1, 90, 91, -1, 93, 94, -1, 96,
4154 97, -1, 99, 100, 101, 102, -1, 104, 105, 106,
4155 107, 108, 109, -1, -1, 112, -1, -1, -1, -1,
4156 -1, -1, 119, 3, 4, 5, 6, 7, 8, 9,
4157 10, 11, -1, -1, -1, 132, 133, 134, -1, 19,
4158 -1, 21, 22, 23, 24, 142, -1, -1, -1, -1,
4159 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4160 -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
4161 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
4162 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
4163 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
4164 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4165 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
4166 100, 101, 102, -1, 104, 105, 106, 107, 108, 109,
4167 -1, -1, 112, -1, -1, -1, -1, -1, -1, 3,
4168 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
4169 -1, -1, 132, 133, 134, 19, -1, 21, 22, 23,
4170 24, -1, 142, -1, -1, -1, 30, 31, 32, 33,
4171 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4172 -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
4173 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
4174 -1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
4175 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4176 -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
4177 94, -1, 96, 97, -1, 99, 100, 101, 102, -1,
4178 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
4179 -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
4180 8, 9, 10, 11, -1, -1, -1, -1, 132, 133,
4181 134, 19, -1, 21, 22, 23, 24, -1, 142, -1,
4182 -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4183 -1, 39, -1, -1, -1, -1, -1, -1, -1, -1,
4184 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
4185 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
4186 -1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
4187 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4188 -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
4189 -1, 99, 100, 101, 102, -1, 104, 105, 106, 107,
4190 108, 109, -1, -1, 112, -1, -1, -1, -1, -1,
4191 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4192 -1, -1, -1, -1, 132, 133, 134, -1, -1, -1,
4193 -1, -1, -1, -1, 142, 3, 4, 5, 6, 7,
4194 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
4195 18, 19, 20, 21, 22, 23, 24, 25, 26, -1,
4196 -1, -1, 30, 31, 32, 33, 34, 35, 36, 37,
4197 38, 39, -1, -1, -1, -1, -1, 45, 46, 47,
4198 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
4199 -1, -1, -1, -1, -1, 63, -1, -1, -1, -1,
4200 -1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
4201 78, -1, -1, 81, 82, -1, -1, 85, 86, 87,
4202 88, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4203 -1, 99, 100, -1, -1, -1, -1, -1, -1, -1,
4204 108, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4205 -1, -1, -1, -1, 122, 123, 124, 125, 126, 127,
4206 128, 129, 130, 131, -1, 133, 134, -1, -1, -1,
4207 -1, -1, -1, 141, 3, 4, 5, 6, 7, 8,
4208 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
4209 19, 20, 21, 22, 23, 24, 25, 26, -1, -1,
4210 -1, 30, 31, 32, 33, 34, 35, 36, 37, 38,
4211 39, -1, -1, -1, -1, -1, 45, 46, 47, 48,
4212 49, 50, 51, 52, 53, 54, 55, 56, -1, -1,
4213 -1, -1, -1, -1, 63, -1, -1, -1, -1, -1,
4214 -1, 70, 71, 72, 73, 74, 75, 76, 77, 78,
4215 -1, -1, 81, 82, -1, -1, 85, 86, 87, 88,
4216 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4217 99, 100, -1, -1, -1, -1, -1, -1, -1, 108,
4218 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4219 -1, -1, -1, 122, 123, 124, 125, 126, 127, 128,
4220 129, 130, 131, -1, 133, 134, -1, -1, -1, -1,
4221 -1, -1, 141, 3, 4, 5, 6, 7, 8, 9,
4222 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
4223 20, 21, 22, 23, 24, 25, 26, -1, -1, -1,
4224 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
4225 -1, -1, -1, -1, -1, 45, 46, 47, 48, 49,
4226 50, 51, 52, -1, -1, 55, -1, -1, -1, -1,
4227 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4228 70, 71, 72, 73, 74, 75, 76, 77, 78, -1,
4229 -1, 81, 82, -1, -1, 85, 86, 87, 88, -1,
4230 -1, -1, -1, -1, -1, -1, -1, -1, -1, 99,
4231 100, -1, -1, -1, 104, -1, -1, -1, -1, -1,
4232 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4233 -1, -1, 122, 123, 124, 125, 126, 127, 128, 129,
4234 130, 131, -1, 133, 134, -1, -1, -1, -1, -1,
4235 -1, 141, 3, 4, 5, 6, 7, 8, 9, 10,
4236 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
4237 21, 22, 23, 24, 25, 26, -1, -1, -1, 30,
4238 31, 32, 33, 34, 35, 36, 37, 38, 39, -1,
4239 -1, -1, -1, -1, 45, 46, 47, 48, 49, 50,
4240 51, 52, -1, -1, 55, -1, -1, -1, -1, -1,
4241 -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
4242 71, 72, 73, 74, 75, 76, 77, 78, -1, -1,
4243 81, 82, -1, -1, 85, 86, 87, 88, -1, -1,
4244 -1, -1, -1, -1, -1, -1, -1, -1, 99, 100,
4245 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4246 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4247 -1, 122, 123, 124, 125, 126, 127, 128, 129, 130,
4248 131, -1, 133, 134, -1, -1, -1, -1, -1, -1,
4249 141, 3, 4, 5, 6, 7, 8, 9, 10, 11,
4250 -1, -1, -1, -1, -1, -1, -1, 19, -1, 21,
4251 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4252 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4253 -1, -1, -1, -1, -1, -1, 48, 49, 50, 51,
4254 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
4255 -1, 63, -1, -1, 66, 67, -1, 69, -1, -1,
4256 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4257 -1, -1, -1, -1, -1, -1, -1, -1, 90, -1,
4258 -1, 93, 94, -1, 96, 97, -1, -1, -1, -1,
4259 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
4260 112, -1, -1, 3, 4, 5, 6, 7, 8, 9,
4261 10, 11, -1, -1, -1, -1, -1, -1, -1, 19,
4262 132, 21, 22, 23, 24, -1, -1, -1, 140, -1,
4263 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4264 -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
4265 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
4266 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
4267 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4268 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4269 90, -1, -1, 93, 94, -1, 96, 97, -1, -1,
4270 -1, -1, 102, -1, 104, 105, 106, 107, 108, 109,
4271 -1, -1, 112, -1, -1, 3, 4, 5, 6, 7,
4272 8, 9, 10, 11, 12, -1, -1, -1, -1, -1,
4273 -1, 19, 132, 21, 22, 23, 24, -1, -1, -1,
4274 140, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4275 -1, 39, -1, -1, -1, -1, -1, 45, 46, 47,
4276 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
4277 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
4278 -1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
4279 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4280 -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
4281 -1, 99, -1, -1, 102, -1, 104, 105, 106, 107,
4282 108, 109, -1, -1, 112, -1, -1, -1, -1, -1,
4283 -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
4284 -1, -1, -1, -1, 132, 133, 134, 19, -1, 21,
4285 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4286 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4287 -1, -1, -1, -1, -1, -1, 48, 49, 50, 51,
4288 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
4289 -1, 63, -1, -1, 66, 67, -1, 69, 70, 71,
4290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4291 -1, -1, 84, -1, -1, -1, -1, -1, 90, -1,
4292 -1, 93, 94, -1, 96, 97, -1, 99, 100, 101,
4293 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
4294 112, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4295 6, 7, 8, 9, 10, 11, 12, -1, -1, -1,
4296 132, 133, 134, 19, -1, 21, 22, 23, 24, -1,
4297 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4298 36, -1, -1, 39, -1, -1, -1, -1, -1, 45,
4299 -1, 47, 48, 49, 50, 51, 52, 53, 54, 55,
4300 56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
4301 66, 67, -1, 69, 70, 71, -1, -1, -1, -1,
4302 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4303 -1, -1, -1, -1, 90, -1, -1, 93, 94, -1,
4304 96, 97, -1, 99, -1, -1, 102, -1, 104, 105,
4305 106, 107, 108, 109, -1, -1, 112, -1, -1, -1,
4306 -1, -1, -1, 3, 4, 5, 6, 7, 8, 9,
4307 10, 11, -1, -1, -1, -1, 132, 133, 134, 19,
4308 -1, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4309 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4310 -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
4311 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
4312 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
4313 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
4314 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4315 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
4316 100, 101, 102, -1, 104, 105, 106, 107, 108, 109,
4317 -1, -1, 112, -1, -1, -1, -1, -1, -1, 3,
4318 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
4319 -1, -1, 132, 133, 134, 19, -1, 21, 22, 23,
4320 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4321 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4322 -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
4323 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
4324 -1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
4325 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4326 -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
4327 94, -1, 96, 97, -1, 99, 100, 101, 102, -1,
4328 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
4329 -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
4330 8, 9, 10, 11, -1, -1, -1, -1, 132, 133,
4331 134, 19, -1, 21, 22, 23, 24, -1, -1, -1,
4332 -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4333 -1, 39, -1, -1, -1, -1, -1, -1, -1, -1,
4334 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
4335 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
4336 -1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
4337 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4338 -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
4339 -1, 99, 100, -1, 102, -1, 104, 105, 106, 107,
4340 108, 109, -1, -1, 112, -1, -1, -1, -1, -1,
4341 -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
4342 -1, -1, -1, -1, 132, 133, 134, 19, -1, 21,
4343 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4344 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4345 -1, -1, -1, -1, -1, -1, 48, 49, 50, 51,
4346 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
4347 -1, 63, -1, -1, 66, 67, -1, 69, 70, 71,
4348 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4349 -1, -1, -1, -1, -1, -1, -1, -1, 90, -1,
4350 -1, 93, 94, -1, 96, 97, -1, -1, 100, 101,
4351 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
4352 112, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4353 6, 7, 8, 9, 10, 11, -1, -1, -1, -1,
4354 132, 133, 134, 19, -1, 21, 22, 23, 24, -1,
4355 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4356 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4357 -1, -1, 48, 49, 50, 51, 52, 53, 54, 55,
4358 56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
4359 66, 67, -1, 69, 70, 71, -1, -1, -1, -1,
4360 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4361 -1, -1, -1, -1, 90, -1, -1, 93, 94, -1,
4362 96, 97, -1, 99, 100, -1, 102, -1, 104, 105,
4363 106, 107, 108, 109, -1, -1, 112, -1, -1, -1,
4364 -1, -1, -1, 3, 4, 5, 6, 7, 8, 9,
4365 10, 11, -1, -1, -1, -1, 132, 133, 134, 19,
4366 -1, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4367 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4368 -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
4369 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
4370 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
4371 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
4372 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4373 90, -1, -1, 93, 94, -1, 96, 97, -1, -1,
4374 100, -1, 102, -1, 104, 105, 106, 107, 108, 109,
4375 -1, -1, 112, -1, -1, -1, -1, -1, -1, 3,
4376 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
4377 -1, -1, 132, 133, 134, 19, -1, 21, 22, 23,
4378 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4379 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4380 -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
4381 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
4382 -1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
4383 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4384 -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
4385 94, -1, 96, 97, -1, 99, -1, -1, 102, -1,
4386 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
4387 -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
4388 8, 9, 10, 11, -1, -1, -1, -1, 132, 133,
4389 134, 19, -1, 21, 22, 23, 24, -1, -1, -1,
4390 -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4391 -1, 39, -1, -1, -1, -1, -1, -1, -1, -1,
4392 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
4393 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
4394 -1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
4395 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4396 -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
4397 -1, 99, -1, -1, 102, -1, 104, 105, 106, 107,
4398 108, 109, -1, -1, 112, -1, -1, -1, -1, -1,
4399 -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
4400 -1, -1, -1, -1, 132, 133, 134, 19, -1, 21,
4401 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4402 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4403 -1, -1, -1, -1, -1, -1, 48, 49, 50, 51,
4404 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
4405 -1, 63, -1, -1, 66, 67, -1, 69, 70, 71,
4406 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4407 -1, -1, -1, -1, -1, -1, -1, -1, 90, -1,
4408 -1, 93, 94, -1, 96, 97, -1, 99, -1, -1,
4409 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
4410 112, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4411 6, 7, 8, 9, 10, 11, -1, -1, -1, -1,
4412 132, 133, 134, 19, -1, 21, 22, 23, 24, -1,
4413 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4414 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4415 -1, -1, 48, 49, 50, 51, 52, 53, 54, 55,
4416 56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
4417 66, 67, -1, 69, 70, 71, -1, -1, -1, -1,
4418 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4419 -1, -1, -1, -1, 90, -1, -1, 93, 94, -1,
4420 96, 97, -1, 99, -1, -1, 102, -1, 104, 105,
4421 106, 107, 108, 109, -1, -1, 112, -1, -1, -1,
4422 -1, -1, -1, 3, 4, 5, 6, 7, 8, 9,
4423 10, 11, -1, -1, -1, -1, 132, 133, 134, 19,
4424 -1, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4425 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4426 -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
4427 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
4428 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
4429 70, 71, -1, -1, -1, -1, -1, -1, -1, -1,
4430 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4431 90, -1, -1, 93, 94, -1, 96, 97, -1, 99,
4432 -1, -1, 102, -1, 104, 105, 106, 107, 108, 109,
4433 -1, -1, 112, -1, -1, -1, -1, -1, -1, 3,
4434 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
4435 -1, -1, 132, 133, 134, 19, -1, 21, 22, 23,
4436 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4437 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4438 -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
4439 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
4440 -1, -1, 66, 67, -1, 69, 70, 71, -1, -1,
4441 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4442 -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
4443 94, -1, 96, 97, -1, -1, -1, -1, 102, -1,
4444 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
4445 -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
4446 8, 9, 10, 11, -1, -1, -1, -1, 132, 133,
4447 134, 19, -1, 21, 22, 23, 24, -1, -1, -1,
4448 -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4449 -1, 39, -1, -1, -1, -1, -1, -1, -1, -1,
4450 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
4451 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
4452 -1, 69, 70, 71, -1, -1, -1, -1, -1, -1,
4453 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4454 -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
4455 -1, -1, -1, -1, 102, -1, 104, 105, 106, 107,
4456 108, 109, -1, -1, 112, -1, -1, -1, -1, -1,
4457 -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
4458 -1, -1, -1, -1, 132, 133, 134, 19, -1, 21,
4459 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4460 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4461 -1, -1, -1, -1, -1, -1, 48, 49, 50, 51,
4462 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
4463 -1, 63, -1, -1, 66, 67, -1, 69, 70, 71,
4464 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4465 -1, -1, -1, -1, -1, -1, -1, -1, 90, -1,
4466 -1, 93, 94, -1, 96, 97, -1, -1, -1, -1,
4467 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
4468 112, -1, -1, -1, -1, -1, -1, 3, 4, 5,
4469 6, 7, 8, 9, 10, 11, -1, -1, -1, -1,
4470 132, 133, 134, 19, -1, 21, 22, 23, 24, -1,
4471 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4472 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4473 -1, -1, 48, 49, 50, 51, 52, 53, 54, 55,
4474 56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
4475 66, 67, -1, 69, -1, -1, -1, -1, -1, -1,
4476 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4477 -1, 87, -1, -1, 90, -1, -1, 93, 94, -1,
4478 96, 97, -1, -1, -1, -1, 102, -1, 104, 105,
4479 106, 107, 108, 109, -1, -1, 112, -1, -1, 3,
4480 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
4481 -1, -1, -1, -1, -1, 19, 132, 21, 22, 23,
4482 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4483 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4484 -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
4485 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
4486 -1, -1, 66, 67, -1, 69, -1, -1, -1, -1,
4487 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4488 -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
4489 94, -1, 96, 97, -1, 99, -1, -1, 102, -1,
4490 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
4491 -1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
4492 -1, -1, -1, -1, -1, -1, -1, 19, 132, 21,
4493 22, 23, 24, -1, -1, -1, -1, -1, 30, 31,
4494 32, 33, 34, 35, 36, -1, -1, 39, -1, -1,
4495 -1, -1, -1, -1, -1, -1, 48, 49, 50, 51,
4496 52, 53, 54, 55, 56, -1, 58, 59, 60, -1,
4497 -1, 63, -1, -1, 66, 67, -1, 69, -1, -1,
4498 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4499 -1, -1, -1, -1, -1, -1, -1, -1, 90, -1,
4500 -1, 93, 94, -1, 96, 97, -1, 99, -1, -1,
4501 102, -1, 104, 105, 106, 107, 108, 109, -1, -1,
4502 112, -1, -1, 3, 4, 5, 6, 7, 8, 9,
4503 10, 11, -1, -1, -1, -1, -1, -1, -1, 19,
4504 132, 21, 22, 23, 24, -1, -1, -1, -1, -1,
4505 30, 31, 32, 33, 34, 35, 36, -1, -1, 39,
4506 -1, -1, -1, -1, -1, -1, -1, -1, 48, 49,
4507 50, 51, 52, 53, 54, 55, 56, -1, 58, 59,
4508 60, -1, -1, 63, -1, -1, 66, 67, -1, 69,
4509 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4510 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4511 90, -1, -1, 93, 94, -1, 96, 97, -1, -1,
4512 -1, -1, 102, -1, 104, 105, 106, 107, 108, 109,
4513 -1, -1, 112, -1, -1, 3, 4, 5, 6, 7,
4514 8, 9, 10, 11, -1, -1, -1, -1, -1, -1,
4515 -1, 19, 132, 21, 22, 23, 24, -1, -1, -1,
4516 -1, -1, 30, 31, 32, 33, 34, 35, 36, -1,
4517 -1, 39, -1, -1, -1, -1, -1, -1, -1, -1,
4518 48, 49, 50, 51, 52, 53, 54, 55, 56, -1,
4519 58, 59, 60, -1, -1, 63, -1, -1, 66, 67,
4520 -1, 69, -1, -1, -1, -1, -1, -1, -1, -1,
4521 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4522 -1, -1, 90, -1, -1, 93, 94, -1, 96, 97,
4523 -1, -1, -1, -1, 102, -1, 104, 105, 106, 107,
4524 108, 109, -1, -1, 112, -1, -1, 3, 4, 5,
4525 6, 7, 8, 9, 10, 11, -1, -1, -1, -1,
4526 -1, -1, -1, 19, 132, 21, 22, 23, 24, -1,
4527 -1, -1, -1, -1, 30, 31, 32, 33, 34, 35,
4528 36, -1, -1, 39, -1, -1, -1, -1, -1, -1,
4529 -1, -1, 48, 49, 50, 51, 52, 53, 54, 55,
4530 56, -1, 58, 59, 60, -1, -1, 63, -1, -1,
4531 66, 67, -1, 69, -1, -1, -1, -1, -1, -1,
4532 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4533 -1, -1, -1, -1, 90, -1, -1, 93, 94, -1,
4534 96, 97, -1, -1, -1, -1, 102, -1, 104, 105,
4535 106, 107, 108, 109, -1, -1, 112, -1, -1, 3,
4536 4, 5, 6, 7, 8, 9, 10, 11, -1, -1,
4537 -1, -1, -1, -1, -1, 19, 132, 21, 22, 23,
4538 24, -1, -1, -1, -1, -1, 30, 31, 32, 33,
4539 34, 35, 36, -1, -1, 39, -1, -1, -1, -1,
4540 -1, -1, -1, -1, 48, 49, 50, 51, 52, 53,
4541 54, 55, 56, -1, 58, 59, 60, -1, -1, 63,
4542 -1, -1, 66, 67, -1, 69, -1, -1, -1, -1,
4543 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4544 -1, -1, -1, -1, -1, -1, 90, -1, -1, 93,
4545 94, -1, 96, 97, -1, 51, 52, -1, 102, 55,
4546 104, 105, 106, 107, 108, 109, -1, -1, 112, -1,
4547 -1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
4548 76, 77, 78, -1, -1, 81, 82, -1, 132, 85,
4549 86, 87, 88, -1, -1, -1, -1, -1, -1, -1,
4550 -1, -1, -1, 99, 100, -1, -1, -1, -1, -1,
4551 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4552 -1, -1, -1, -1, -1, -1, 122, 123, 124, 125,
4553 126, 127, 128, 129, 130, 131, -1, 133, 134, 51,
4554 52, -1, -1, 55, -1, 141, 142, -1, -1, -1,
4555 -1, -1, -1, -1, -1, -1, -1, -1, 70, 71,
4556 72, 73, 74, 75, 76, 77, 78, -1, -1, 81,
4557 82, -1, -1, 85, 86, 87, 88, -1, -1, -1,
4558 -1, -1, -1, -1, -1, -1, -1, 99, 100, -1,
4559 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4560 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4561 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
4562 -1, 133, 134, 51, 52, -1, -1, 55, -1, 141,
4563 142, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4564 -1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
4565 78, -1, -1, 81, 82, -1, -1, 85, 86, 87,
4566 88, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4567 -1, 99, 100, -1, -1, -1, -1, -1, -1, -1,
4568 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4569 -1, -1, -1, -1, 122, 123, 124, 125, 126, 127,
4570 128, 129, 130, 131, -1, 133, 134, 51, 52, -1,
4571 -1, 55, -1, 141, 142, -1, -1, -1, -1, -1,
4572 -1, -1, -1, -1, -1, -1, 70, 71, 72, 73,
4573 74, 75, 76, 77, 78, -1, -1, 81, 82, -1,
4574 -1, 85, 86, 87, 88, -1, -1, -1, -1, -1,
4575 -1, -1, -1, -1, -1, 99, 100, -1, -1, -1,
4576 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4577 -1, -1, -1, -1, -1, -1, -1, -1, 122, 123,
4578 124, 125, 126, 127, 128, 129, 130, 131, -1, 133,
4579 134, 51, 52, -1, -1, 55, -1, 141, 142, -1,
4580 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4581 70, 71, 72, 73, 74, 75, 76, 77, 78, -1,
4582 -1, 81, 82, -1, -1, 85, 86, 87, 88, -1,
4583 -1, -1, -1, -1, -1, -1, -1, -1, -1, 99,
4584 100, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4585 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4586 -1, -1, 122, 123, 124, 125, 126, 127, 128, 129,
4587 130, 131, -1, 133, 134, 51, 52, -1, -1, 55,
4588 -1, 141, 142, -1, -1, -1, -1, -1, -1, -1,
4589 -1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
4590 76, 77, 78, -1, -1, 81, 82, -1, -1, 85,
4591 86, 87, 88, -1, -1, -1, -1, -1, -1, -1,
4592 -1, -1, -1, 99, 100, -1, -1, -1, -1, -1,
4593 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4594 -1, -1, -1, -1, -1, -1, 122, 123, 124, 125,
4595 126, 127, 128, 129, 130, 131, -1, 133, 134, 51,
4596 52, -1, -1, 55, -1, 141, 142, -1, -1, -1,
4597 -1, -1, -1, -1, -1, -1, -1, -1, 70, 71,
4598 72, 73, 74, 75, 76, 77, 78, -1, -1, 81,
4599 82, -1, -1, 85, 86, 87, 88, -1, -1, -1,
4600 -1, -1, -1, -1, -1, -1, -1, 99, 100, -1,
4601 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4602 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4603 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
4604 -1, 133, 134, 51, 52, -1, -1, 55, -1, 141,
4605 142, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4606 -1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
4607 78, -1, -1, 81, 82, -1, -1, 85, 86, 87,
4608 88, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4609 -1, 99, 100, -1, -1, -1, -1, -1, -1, -1,
4610 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4611 -1, -1, -1, -1, 122, 123, 124, 125, 126, 127,
4612 128, 129, 130, 131, -1, 133, 134, 51, 52, -1,
4613 -1, 55, -1, 141, 142, -1, -1, -1, -1, -1,
4614 -1, -1, -1, -1, -1, -1, 70, 71, 72, 73,
4615 74, 75, 76, 77, 78, -1, -1, 81, 82, -1,
4616 -1, 85, 86, 87, 88, -1, -1, -1, -1, -1,
4617 -1, -1, -1, -1, -1, 99, 100, -1, -1, -1,
4618 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4619 -1, -1, -1, -1, -1, -1, -1, -1, 122, 123,
4620 124, 125, 126, 127, 128, 129, 130, 131, -1, 133,
4621 134, 51, 52, -1, -1, 55, -1, 141, 142, -1,
4622 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4623 70, 71, 72, 73, 74, 75, 76, 77, 78, -1,
4624 -1, 81, 82, -1, -1, 85, 86, 87, 88, -1,
4625 -1, -1, -1, -1, -1, -1, -1, -1, -1, 99,
4626 100, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4627 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4628 -1, -1, 122, 123, 124, 125, 126, 127, 128, 129,
4629 130, 131, -1, 133, 134, 51, 52, -1, -1, 55,
4630 -1, 141, 142, -1, -1, -1, -1, -1, -1, -1,
4631 -1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
4632 76, 77, 78, -1, -1, 81, 82, -1, -1, 85,
4633 86, 87, 88, -1, -1, -1, -1, -1, -1, -1,
4634 -1, -1, -1, 99, 100, -1, -1, -1, -1, -1,
4635 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4636 -1, -1, -1, -1, -1, -1, 122, 123, 124, 125,
4637 126, 127, 128, 129, 130, 131, -1, 133, 134, 51,
4638 52, -1, -1, 55, -1, 141, 142, -1, -1, -1,
4639 -1, -1, -1, -1, -1, -1, -1, -1, 70, 71,
4640 72, 73, 74, 75, 76, 77, 78, -1, -1, 81,
4641 82, -1, -1, 85, 86, 87, 88, -1, -1, -1,
4642 -1, -1, -1, -1, -1, -1, -1, 99, 100, -1,
4643 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4644 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4645 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
4646 -1, 133, 134, 51, 52, -1, -1, 55, -1, 141,
4647 142, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4648 -1, -1, 70, 71, 72, 73, 74, 75, 76, 77,
4649 78, -1, -1, 81, 82, -1, -1, 85, 86, 87,
4650 88, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4651 -1, 99, 100, -1, -1, -1, -1, -1, -1, -1,
4652 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4653 -1, -1, -1, -1, 122, 123, 124, 125, 126, 127,
4654 128, 129, 130, 131, -1, 133, 134, 51, 52, -1,
4655 -1, 55, -1, 141, 142, -1, -1, -1, -1, -1,
4656 -1, -1, -1, -1, -1, -1, 70, 71, 72, 73,
4657 74, 75, 76, 77, 78, -1, -1, 81, 82, -1,
4658 -1, 85, 86, 87, 88, -1, -1, -1, -1, -1,
4659 -1, -1, -1, -1, -1, 99, 100, -1, -1, -1,
4660 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4661 -1, -1, -1, -1, -1, -1, -1, -1, 122, 123,
4662 124, 125, 126, 127, 128, 129, 130, 131, -1, 133,
4663 134, 51, 52, -1, -1, 55, -1, 141, 142, -1,
4664 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4665 70, 71, 72, 73, 74, 75, 76, 77, 78, -1,
4666 -1, 81, 82, -1, -1, 85, 86, 87, 88, -1,
4667 -1, -1, -1, -1, -1, -1, -1, -1, -1, 99,
4668 100, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4669 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4670 -1, -1, 122, 123, 124, 125, 126, 127, 128, 129,
4671 130, 131, -1, 133, 134, 51, 52, -1, -1, 55,
4672 -1, 141, 142, -1, -1, -1, -1, -1, -1, -1,
4673 -1, -1, -1, -1, 70, 71, 72, 73, 74, 75,
4674 76, 77, 78, -1, -1, 81, 82, -1, -1, 85,
4675 86, 87, 88, -1, -1, -1, -1, -1, -1, -1,
4676 -1, -1, -1, 99, 100, -1, -1, -1, -1, -1,
4677 -1, -1, -1, -1, -1, -1, -1, -1, 44, -1,
4678 -1, -1, -1, -1, -1, -1, 122, 123, 124, 125,
4679 126, 127, 128, 129, 130, 131, -1, 133, 134, -1,
4680 -1, -1, -1, -1, -1, 141, 72, 73, 74, 75,
4681 76, 77, 78, 79, 80, 81, 82, 83, 84, -1,
4682 -1, 87, 88, 72, 73, 74, 75, 76, 77, 78,
4683 79, 80, 81, 82, 83, 84, -1, -1, 87, 88,
4684 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4685 -1, -1, -1, -1, 120, -1, 122, 123, 124, 125,
4686 126, 127, 128, 129, 130, 131, -1, -1, -1, -1,
4687 -1, 120, -1, 122, 123, 124, 125, 126, 127, 128,
4688 129, 130, 131, 72, 73, 74, 75, 76, 77, 78,
4689 79, 80, 81, 82, 83, 84, -1, 146, 87, 88,
4690 -1, -1, 72, 73, 74, 75, 76, 77, 78, 79,
4691 80, 81, 82, 83, 84, -1, -1, 87, 88, -1,
4692 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4693 -1, 120, -1, 122, 123, 124, 125, 126, 127, 128,
4694 129, 130, 131, -1, -1, -1, -1, -1, -1, -1,
4695 120, 140, 122, 123, 124, 125, 126, 127, 128, 129,
4696 130, 131, -1, -1, -1, -1, -1, -1, -1, -1,
4697 140, 72, 73, 74, 75, 76, 77, 78, 79, 80,
4698 81, 82, 83, 84, -1, -1, 87, 88, -1, -1,
4699 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
4700 82, 83, 84, -1, -1, 87, 88, -1, -1, -1,
4701 -1, -1, -1, -1, -1, -1, -1, -1, -1, 120,
4702 -1, 122, 123, 124, 125, 126, 127, 128, 129, 130,
4703 131, -1, -1, -1, -1, -1, -1, -1, 120, 140,
4704 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
4705 -1, -1, -1, -1, -1, -1, -1, -1, 140, 72,
4706 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
4707 83, 84, -1, -1, 87, 88, -1, -1, -1, 92,
4708 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
4709 82, 83, 84, -1, -1, 87, 88, -1, -1, -1,
4710 -1, -1, -1, -1, -1, -1, -1, 120, -1, 122,
4711 123, 124, 125, 126, 127, 128, 129, 130, 131, -1,
4712 -1, -1, -1, -1, -1, -1, -1, -1, 120, -1,
4713 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
4714 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
4715 82, 83, 84, -1, -1, 87, 88, 72, 73, 74,
4716 75, 76, 77, 78, 79, -1, 81, 82, -1, -1,
4717 -1, -1, 87, 88, -1, -1, -1, -1, -1, -1,
4718 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4719 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
4720 -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
4721 125, 126, 127, 128, 129, 130, 131, 72, 73, 74,
4722 75, 76, 77, 78, -1, -1, 81, 82, -1, -1,
4723 -1, -1, 87, 88, -1, -1, -1, -1, -1, -1,
4724 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4725 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4726 -1, -1, -1, -1, -1, -1, -1, 122, 123, 124,
4727 125, 126, 127, 128, 129, 130, 131
4728 };
4729
4730 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
4731 symbol of state STATE-NUM. */
4732 static const yytype_int16 yystos[] =
4733 {
4734 0, 148, 149, 0, 1, 3, 4, 5, 6, 7,
4735 8, 9, 10, 11, 12, 19, 21, 22, 23, 24,
4736 30, 31, 32, 33, 34, 35, 36, 39, 45, 46,
4737 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
4738 58, 59, 60, 63, 66, 67, 69, 70, 71, 90,
4739 93, 94, 96, 97, 99, 102, 104, 105, 106, 107,
4740 108, 109, 112, 132, 133, 134, 150, 151, 152, 157,
4741 159, 161, 163, 164, 167, 168, 170, 171, 172, 174,
4742 175, 184, 198, 219, 240, 241, 251, 252, 253, 257,
4743 258, 259, 265, 266, 267, 269, 270, 271, 272, 273,
4744 274, 309, 322, 152, 21, 22, 30, 31, 32, 39,
4745 51, 55, 69, 87, 90, 93, 132, 176, 177, 198,
4746 219, 271, 274, 309, 177, 3, 4, 5, 6, 7,
4747 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
4748 18, 19, 20, 21, 22, 23, 24, 25, 26, 30,
4749 31, 32, 33, 34, 35, 36, 37, 38, 39, 45,
4750 46, 47, 48, 49, 50, 51, 52, 55, 70, 71,
4751 72, 73, 74, 75, 76, 77, 78, 81, 82, 85,
4752 86, 87, 88, 99, 100, 122, 123, 124, 125, 126,
4753 127, 128, 129, 130, 131, 133, 134, 141, 142, 178,
4754 182, 183, 273, 303, 199, 90, 161, 162, 175, 219,
4755 271, 272, 274, 162, 205, 207, 69, 90, 168, 175,
4756 219, 224, 271, 274, 33, 34, 35, 36, 48, 49,
4757 50, 51, 55, 104, 178, 179, 180, 267, 113, 116,
4758 117, 144, 146, 162, 261, 262, 263, 315, 319, 320,
4759 321, 51, 99, 100, 101, 133, 167, 184, 190, 193,
4760 196, 253, 306, 308, 190, 190, 142, 187, 188, 191,
4761 192, 322, 187, 191, 142, 316, 320, 179, 153, 136,
4762 184, 219, 184, 55, 1, 93, 155, 156, 157, 169,
4763 170, 322, 200, 202, 185, 196, 306, 322, 184, 305,
4764 306, 322, 90, 140, 174, 219, 271, 274, 203, 53,
4765 54, 56, 63, 108, 178, 268, 62, 64, 65, 114,
4766 115, 254, 255, 63, 254, 63, 254, 63, 254, 61,
4767 254, 58, 59, 163, 184, 184, 315, 321, 40, 41,
4768 42, 43, 44, 37, 38, 28, 238, 119, 140, 93,
4769 99, 171, 119, 72, 73, 74, 75, 76, 77, 78,
4770 79, 80, 81, 82, 83, 84, 87, 88, 120, 122,
4771 123, 124, 125, 126, 127, 128, 129, 130, 131, 89,
4772 103, 138, 145, 313, 89, 313, 314, 26, 136, 242,
4773 253, 91, 91, 187, 191, 242, 161, 51, 55, 176,
4774 58, 59, 123, 275, 89, 138, 313, 214, 304, 215,
4775 89, 145, 312, 154, 155, 55, 16, 220, 319, 119,
4776 89, 138, 313, 91, 91, 220, 162, 162, 55, 89,
4777 138, 313, 25, 108, 140, 264, 315, 113, 263, 20,
4778 245, 319, 57, 307, 184, 184, 184, 92, 140, 194,
4779 195, 322, 307, 194, 195, 84, 189, 190, 196, 306,
4780 322, 190, 161, 315, 317, 161, 158, 136, 155, 89,
4781 313, 91, 157, 169, 143, 315, 321, 317, 157, 317,
4782 139, 195, 318, 321, 195, 318, 137, 318, 55, 171,
4783 172, 173, 140, 89, 138, 313, 51, 53, 54, 55,
4784 56, 69, 72, 93, 99, 100, 101, 126, 129, 142,
4785 236, 278, 279, 282, 283, 284, 285, 287, 288, 289,
4786 290, 292, 293, 294, 297, 298, 299, 300, 301, 63,
4787 254, 256, 260, 261, 62, 255, 63, 63, 63, 61,
4788 72, 72, 152, 162, 162, 162, 162, 157, 161, 161,
4789 239, 99, 163, 184, 196, 197, 169, 140, 174, 140,
4790 159, 160, 163, 175, 184, 186, 197, 219, 274, 184,
4791 184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
4792 184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
4793 184, 184, 184, 184, 184, 51, 52, 55, 182, 187,
4794 310, 311, 189, 51, 52, 55, 182, 187, 310, 51,
4795 55, 310, 244, 243, 160, 184, 186, 160, 186, 98,
4796 165, 212, 276, 211, 51, 55, 176, 310, 189, 310,
4797 154, 161, 216, 217, 15, 13, 247, 322, 155, 16,
4798 51, 55, 189, 51, 55, 155, 27, 221, 319, 221,
4799 51, 55, 189, 51, 55, 209, 181, 155, 245, 184,
4800 196, 15, 260, 184, 184, 316, 99, 184, 193, 306,
4801 184, 308, 317, 143, 315, 195, 195, 317, 143, 179,
4802 150, 137, 186, 317, 157, 201, 306, 171, 173, 51,
4803 55, 189, 51, 55, 57, 119, 291, 287, 204, 184,
4804 140, 302, 322, 51, 140, 302, 140, 286, 184, 140,
4805 286, 51, 140, 286, 51, 63, 155, 261, 184, 184,
4806 80, 124, 230, 231, 322, 184, 195, 317, 173, 140,
4807 44, 119, 44, 89, 138, 313, 316, 91, 91, 187,
4808 191, 139, 91, 91, 188, 191, 188, 191, 230, 230,
4809 166, 319, 162, 154, 139, 15, 317, 142, 277, 287,
4810 178, 184, 197, 248, 322, 18, 223, 322, 17, 222,
4811 223, 91, 91, 139, 91, 91, 223, 206, 208, 139,
4812 162, 179, 137, 15, 195, 220, 260, 184, 194, 306,
4813 137, 317, 318, 139, 51, 99, 225, 292, 233, 316,
4814 29, 111, 237, 51, 279, 284, 301, 285, 290, 297,
4815 299, 292, 294, 299, 51, 292, 137, 227, 229, 232,
4816 278, 280, 281, 284, 292, 293, 295, 296, 299, 301,
4817 154, 99, 184, 173, 157, 184, 51, 55, 189, 51,
4818 55, 57, 121, 160, 186, 163, 186, 165, 91, 160,
4819 186, 160, 186, 165, 242, 238, 154, 155, 230, 213,
4820 319, 15, 84, 287, 154, 319, 218, 92, 249, 322,
4821 155, 14, 250, 322, 162, 15, 91, 15, 155, 155,
4822 221, 184, 155, 195, 140, 289, 317, 140, 143, 144,
4823 154, 155, 302, 140, 286, 140, 286, 140, 286, 140,
4824 286, 286, 233, 233, 90, 219, 140, 302, 302, 140,
4825 228, 219, 140, 228, 140, 228, 15, 184, 139, 184,
4826 184, 160, 186, 15, 137, 155, 154, 317, 317, 15,
4827 277, 90, 175, 219, 271, 274, 220, 155, 220, 15,
4828 15, 210, 223, 245, 246, 226, 140, 99, 51, 234,
4829 235, 288, 15, 137, 292, 299, 292, 292, 124, 124,
4830 55, 89, 280, 284, 140, 227, 228, 296, 299, 292,
4831 295, 299, 292, 137, 15, 154, 55, 89, 138, 313,
4832 155, 155, 155, 292, 292, 140, 289, 140, 316, 286,
4833 140, 286, 286, 286, 51, 55, 302, 140, 228, 140,
4834 228, 140, 228, 140, 228, 228, 15, 51, 55, 189,
4835 51, 55, 247, 222, 15, 140, 292, 140, 235, 292,
4836 292, 299, 292, 292, 139, 292, 286, 228, 140, 228,
4837 228, 228, 292, 228
4838 };
4839
4840 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
4841 static const yytype_int16 yyr1[] =
4842 {
4843 0, 147, 149, 148, 150, 151, 151, 151, 151, 152,
4844 153, 152, 154, 155, 156, 156, 156, 156, 158, 157,
4845 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
4846 157, 157, 157, 159, 159, 159, 159, 159, 159, 159,
4847 159, 160, 160, 160, 161, 161, 161, 161, 161, 161,
4848 162, 163, 163, 164, 164, 166, 165, 167, 167, 167,
4849 167, 167, 167, 167, 167, 167, 167, 167, 168, 168,
4850 169, 169, 170, 170, 170, 170, 170, 170, 170, 170,
4851 170, 170, 171, 171, 172, 172, 173, 173, 174, 174,
4852 174, 174, 174, 174, 174, 174, 175, 175, 175, 175,
4853 175, 175, 175, 175, 175, 176, 176, 177, 177, 177,
4854 178, 178, 178, 178, 178, 179, 179, 180, 181, 180,
4855 182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
4856 182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
4857 182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
4858 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
4859 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
4860 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
4861 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
4862 184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
4863 184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
4864 184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
4865 184, 184, 184, 184, 184, 184, 184, 184, 184, 184,
4866 184, 184, 184, 185, 185, 185, 185, 186, 186, 187,
4867 187, 188, 188, 189, 189, 189, 189, 189, 190, 190,
4868 190, 190, 190, 192, 191, 193, 194, 194, 195, 195,
4869 196, 196, 196, 196, 197, 197, 197, 198, 198, 198,
4870 198, 198, 198, 198, 198, 198, 199, 198, 200, 201,
4871 198, 202, 198, 198, 198, 198, 198, 198, 198, 198,
4872 198, 198, 198, 198, 198, 203, 204, 198, 198, 198,
4873 205, 206, 198, 207, 208, 198, 198, 198, 209, 210,
4874 198, 211, 198, 212, 213, 198, 214, 198, 215, 216,
4875 198, 217, 218, 198, 198, 198, 198, 198, 219, 220,
4876 220, 220, 221, 221, 222, 222, 223, 223, 224, 224,
4877 225, 225, 225, 225, 225, 225, 225, 225, 226, 225,
4878 227, 227, 227, 227, 228, 228, 229, 229, 229, 229,
4879 229, 229, 229, 229, 229, 229, 229, 229, 229, 229,
4880 229, 230, 230, 232, 231, 231, 231, 233, 233, 234,
4881 234, 235, 235, 236, 236, 237, 237, 239, 238, 240,
4882 240, 240, 240, 241, 241, 241, 241, 241, 241, 241,
4883 241, 241, 243, 242, 244, 242, 245, 246, 246, 247,
4884 247, 248, 248, 248, 249, 249, 250, 250, 251, 251,
4885 251, 251, 252, 252, 253, 253, 253, 253, 254, 254,
4886 255, 256, 255, 255, 255, 257, 257, 258, 258, 259,
4887 260, 260, 261, 261, 262, 262, 263, 264, 263, 265,
4888 265, 266, 266, 267, 268, 268, 268, 268, 268, 268,
4889 269, 269, 270, 270, 270, 270, 271, 271, 271, 271,
4890 271, 272, 272, 273, 273, 273, 273, 273, 273, 273,
4891 273, 274, 274, 275, 276, 275, 277, 277, 277, 278,
4892 279, 279, 280, 280, 281, 281, 282, 282, 283, 283,
4893 284, 284, 285, 285, 285, 285, 286, 286, 287, 287,
4894 287, 287, 287, 287, 287, 287, 287, 287, 287, 287,
4895 287, 287, 287, 288, 288, 288, 288, 288, 289, 289,
4896 290, 291, 290, 292, 292, 293, 294, 295, 296, 296,
4897 297, 297, 298, 298, 299, 299, 300, 300, 301, 302,
4898 302, 303, 304, 303, 305, 305, 306, 306, 307, 307,
4899 308, 308, 308, 308, 309, 309, 309, 310, 310, 310,
4900 310, 311, 311, 311, 312, 312, 313, 313, 314, 314,
4901 315, 315, 316, 316, 317, 318, 318, 318, 319, 319,
4902 319, 320, 321, 321, 322
4903 };
4904
4905 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
4906 static const yytype_int8 yyr2[] =
4907 {
4908 0, 2, 0, 2, 2, 1, 1, 3, 2, 1,
4909 0, 5, 4, 2, 1, 1, 3, 2, 0, 4,
4910 2, 3, 3, 3, 3, 3, 4, 1, 3, 3,
4911 3, 3, 1, 3, 3, 6, 5, 5, 5, 5,
4912 3, 1, 3, 1, 1, 3, 3, 3, 2, 1,
4913 1, 1, 1, 1, 4, 0, 5, 2, 3, 4,
4914 5, 4, 5, 2, 2, 2, 2, 2, 1, 3,
4915 1, 3, 1, 2, 3, 5, 2, 4, 2, 4,
4916 1, 3, 1, 3, 2, 3, 1, 2, 1, 4,
4917 3, 3, 3, 3, 2, 1, 1, 4, 3, 3,
4918 3, 3, 2, 1, 1, 1, 1, 2, 1, 3,
4919 1, 1, 1, 1, 1, 1, 1, 1, 0, 4,
4920 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4921 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4922 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4923 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4924 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4925 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4926 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4927 3, 3, 6, 5, 5, 5, 5, 4, 3, 3,
4928 3, 3, 3, 3, 3, 3, 3, 4, 4, 2,
4929 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
4930 3, 3, 3, 3, 2, 2, 3, 3, 3, 3,
4931 6, 6, 1, 1, 2, 4, 2, 1, 3, 3,
4932 3, 1, 1, 1, 2, 2, 4, 2, 1, 2,
4933 2, 4, 1, 0, 2, 2, 2, 1, 1, 3,
4934 1, 2, 3, 4, 3, 4, 2, 1, 1, 1,
4935 1, 1, 1, 1, 1, 1, 0, 4, 0, 0,
4936 5, 0, 3, 3, 3, 2, 3, 3, 1, 2,
4937 4, 3, 2, 1, 2, 0, 0, 5, 6, 6,
4938 0, 0, 7, 0, 0, 7, 5, 4, 0, 0,
4939 9, 0, 6, 0, 0, 8, 0, 5, 0, 0,
4940 7, 0, 0, 9, 1, 1, 1, 1, 1, 1,
4941 1, 2, 1, 1, 1, 5, 1, 2, 1, 1,
4942 1, 4, 6, 3, 5, 2, 4, 1, 0, 4,
4943 4, 2, 2, 1, 2, 0, 6, 8, 4, 6,
4944 4, 3, 6, 2, 4, 6, 2, 4, 2, 4,
4945 1, 1, 1, 0, 4, 1, 4, 1, 4, 1,
4946 3, 1, 1, 4, 1, 3, 3, 0, 5, 2,
4947 4, 5, 5, 2, 4, 4, 3, 3, 3, 2,
4948 1, 4, 0, 5, 0, 5, 5, 1, 1, 6,
4949 1, 1, 1, 1, 2, 1, 2, 1, 1, 1,
4950 1, 1, 1, 2, 1, 1, 2, 3, 1, 2,
4951 1, 0, 4, 1, 2, 2, 3, 2, 3, 1,
4952 1, 2, 1, 2, 1, 2, 1, 0, 4, 2,
4953 3, 1, 4, 2, 1, 1, 1, 1, 1, 2,
4954 2, 3, 1, 1, 2, 2, 1, 1, 1, 1,
4955 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4956 1, 1, 1, 0, 0, 4, 3, 3, 2, 2,
4957 2, 1, 2, 1, 1, 3, 1, 3, 1, 1,
4958 2, 1, 4, 2, 2, 1, 2, 0, 6, 8,
4959 4, 6, 4, 6, 2, 4, 6, 2, 4, 2,
4960 4, 1, 0, 1, 1, 1, 1, 1, 1, 1,
4961 1, 0, 4, 1, 3, 2, 2, 2, 1, 3,
4962 1, 3, 1, 1, 2, 1, 1, 1, 2, 2,
4963 1, 1, 0, 4, 1, 2, 1, 3, 1, 2,
4964 3, 3, 3, 2, 1, 1, 1, 1, 1, 1,
4965 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
4966 0, 1, 0, 1, 2, 0, 1, 1, 1, 1,
4967 1, 1, 1, 2, 0
4968 };
4969
4970
4971 #define yyerrok (yyerrstatus = 0)
4972 #define yyclearin (yychar = YYEMPTY)
4973 #define YYEMPTY (-2)
4974 #define YYEOF 0
4975
4976 #define YYACCEPT goto yyacceptlab
4977 #define YYABORT goto yyabortlab
4978 #define YYERROR goto yyerrorlab
4979
4980
4981 #define YYRECOVERING() (!!yyerrstatus)
4982
4983 #define YYBACKUP(Token, Value) \
4984 do \
4985 if (yychar == YYEMPTY) \
4986 { \
4987 yychar = (Token); \
4988 yylval = (Value); \
4989 YYPOPSTACK (yylen); \
4990 yystate = *yyssp; \
4991 goto yybackup; \
4992 } \
4993 else \
4994 { \
4995 yyerror (p, YY_("syntax error: cannot back up")); \
4996 YYERROR; \
4997 } \
4998 while (0)
4999
5000 /* Error token number */
5001 #define YYTERROR 1
5002 #define YYERRCODE 256
5003
5004
5005
5006 /* Enable debugging if requested. */
5007 #if YYDEBUG
5008
5009 # ifndef YYFPRINTF
5010 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
5011 # define YYFPRINTF fprintf
5012 # endif
5013
5014 # define YYDPRINTF(Args) \
5015 do { \
5016 if (yydebug) \
5017 YYFPRINTF Args; \
5018 } while (0)
5019
5020 /* This macro is provided for backward compatibility. */
5021 #ifndef YY_LOCATION_PRINT
5022 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
5023 #endif
5024
5025
5026 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
5027 do { \
5028 if (yydebug) \
5029 { \
5030 YYFPRINTF (stderr, "%s ", Title); \
5031 yy_symbol_print (stderr, \
5032 Type, Value, p); \
5033 YYFPRINTF (stderr, "\n"); \
5034 } \
5035 } while (0)
5036
5037
5038 /*-----------------------------------.
5039 | Print this symbol's value on YYO. |
5040 `-----------------------------------*/
5041
5042 static void
yy_symbol_value_print(FILE * yyo,int yytype,YYSTYPE const * const yyvaluep,parser_state * p)5043 yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, parser_state *p)
5044 {
5045 FILE *yyoutput = yyo;
5046 YYUSE (yyoutput);
5047 YYUSE (p);
5048 if (!yyvaluep)
5049 return;
5050 # ifdef YYPRINT
5051 if (yytype < YYNTOKENS)
5052 YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
5053 # endif
5054 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
5055 YYUSE (yytype);
5056 YY_IGNORE_MAYBE_UNINITIALIZED_END
5057 }
5058
5059
5060 /*---------------------------.
5061 | Print this symbol on YYO. |
5062 `---------------------------*/
5063
5064 static void
yy_symbol_print(FILE * yyo,int yytype,YYSTYPE const * const yyvaluep,parser_state * p)5065 yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, parser_state *p)
5066 {
5067 YYFPRINTF (yyo, "%s %s (",
5068 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
5069
5070 yy_symbol_value_print (yyo, yytype, yyvaluep, p);
5071 YYFPRINTF (yyo, ")");
5072 }
5073
5074 /*------------------------------------------------------------------.
5075 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
5076 | TOP (included). |
5077 `------------------------------------------------------------------*/
5078
5079 static void
yy_stack_print(yy_state_t * yybottom,yy_state_t * yytop)5080 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
5081 {
5082 YYFPRINTF (stderr, "Stack now");
5083 for (; yybottom <= yytop; yybottom++)
5084 {
5085 int yybot = *yybottom;
5086 YYFPRINTF (stderr, " %d", yybot);
5087 }
5088 YYFPRINTF (stderr, "\n");
5089 }
5090
5091 # define YY_STACK_PRINT(Bottom, Top) \
5092 do { \
5093 if (yydebug) \
5094 yy_stack_print ((Bottom), (Top)); \
5095 } while (0)
5096
5097
5098 /*------------------------------------------------.
5099 | Report that the YYRULE is going to be reduced. |
5100 `------------------------------------------------*/
5101
5102 static void
yy_reduce_print(yy_state_t * yyssp,YYSTYPE * yyvsp,int yyrule,parser_state * p)5103 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule, parser_state *p)
5104 {
5105 int yylno = yyrline[yyrule];
5106 int yynrhs = yyr2[yyrule];
5107 int yyi;
5108 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
5109 yyrule - 1, yylno);
5110 /* The symbols being reduced. */
5111 for (yyi = 0; yyi < yynrhs; yyi++)
5112 {
5113 YYFPRINTF (stderr, " $%d = ", yyi + 1);
5114 yy_symbol_print (stderr,
5115 yystos[+yyssp[yyi + 1 - yynrhs]],
5116 &yyvsp[(yyi + 1) - (yynrhs)]
5117 , p);
5118 YYFPRINTF (stderr, "\n");
5119 }
5120 }
5121
5122 # define YY_REDUCE_PRINT(Rule) \
5123 do { \
5124 if (yydebug) \
5125 yy_reduce_print (yyssp, yyvsp, Rule, p); \
5126 } while (0)
5127
5128 /* Nonzero means print parse trace. It is left uninitialized so that
5129 multiple parsers can coexist. */
5130 int yydebug;
5131 #else /* !YYDEBUG */
5132 # define YYDPRINTF(Args)
5133 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
5134 # define YY_STACK_PRINT(Bottom, Top)
5135 # define YY_REDUCE_PRINT(Rule)
5136 #endif /* !YYDEBUG */
5137
5138
5139 /* YYINITDEPTH -- initial size of the parser's stacks. */
5140 #ifndef YYINITDEPTH
5141 # define YYINITDEPTH 200
5142 #endif
5143
5144 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
5145 if the built-in stack extension method is used).
5146
5147 Do not make this value too large; the results are undefined if
5148 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
5149 evaluated with infinite-precision integer arithmetic. */
5150
5151 #ifndef YYMAXDEPTH
5152 # define YYMAXDEPTH 10000
5153 #endif
5154
5155
5156 #if YYERROR_VERBOSE
5157
5158 # ifndef yystrlen
5159 # if defined __GLIBC__ && defined _STRING_H
5160 # define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
5161 # else
5162 /* Return the length of YYSTR. */
5163 static YYPTRDIFF_T
yystrlen(const char * yystr)5164 yystrlen (const char *yystr)
5165 {
5166 YYPTRDIFF_T yylen;
5167 for (yylen = 0; yystr[yylen]; yylen++)
5168 continue;
5169 return yylen;
5170 }
5171 # endif
5172 # endif
5173
5174 # ifndef yystpcpy
5175 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
5176 # define yystpcpy stpcpy
5177 # else
5178 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
5179 YYDEST. */
5180 static char *
yystpcpy(char * yydest,const char * yysrc)5181 yystpcpy (char *yydest, const char *yysrc)
5182 {
5183 char *yyd = yydest;
5184 const char *yys = yysrc;
5185
5186 while ((*yyd++ = *yys++) != '\0')
5187 continue;
5188
5189 return yyd - 1;
5190 }
5191 # endif
5192 # endif
5193
5194 # ifndef yytnamerr
5195 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
5196 quotes and backslashes, so that it's suitable for yyerror. The
5197 heuristic is that double-quoting is unnecessary unless the string
5198 contains an apostrophe, a comma, or backslash (other than
5199 backslash-backslash). YYSTR is taken from yytname. If YYRES is
5200 null, do not copy; instead, return the length of what the result
5201 would have been. */
5202 static YYPTRDIFF_T
yytnamerr(char * yyres,const char * yystr)5203 yytnamerr (char *yyres, const char *yystr)
5204 {
5205 if (*yystr == '"')
5206 {
5207 YYPTRDIFF_T yyn = 0;
5208 char const *yyp = yystr;
5209
5210 for (;;)
5211 switch (*++yyp)
5212 {
5213 case '\'':
5214 case ',':
5215 goto do_not_strip_quotes;
5216
5217 case '\\':
5218 if (*++yyp != '\\')
5219 goto do_not_strip_quotes;
5220 else
5221 goto append;
5222
5223 append:
5224 default:
5225 if (yyres)
5226 yyres[yyn] = *yyp;
5227 yyn++;
5228 break;
5229
5230 case '"':
5231 if (yyres)
5232 yyres[yyn] = '\0';
5233 return yyn;
5234 }
5235 do_not_strip_quotes: ;
5236 }
5237
5238 if (yyres)
5239 return yystpcpy (yyres, yystr) - yyres;
5240 else
5241 return yystrlen (yystr);
5242 }
5243 # endif
5244
5245 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
5246 about the unexpected token YYTOKEN for the state stack whose top is
5247 YYSSP.
5248
5249 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
5250 not large enough to hold the message. In that case, also set
5251 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
5252 required number of bytes is too large to store. */
5253 static int
yysyntax_error(YYPTRDIFF_T * yymsg_alloc,char ** yymsg,yy_state_t * yyssp,int yytoken)5254 yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
5255 yy_state_t *yyssp, int yytoken)
5256 {
5257 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
5258 /* Internationalized format string. */
5259 const char *yyformat = YY_NULLPTR;
5260 /* Arguments of yyformat: reported tokens (one for the "unexpected",
5261 one per "expected"). */
5262 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
5263 /* Actual size of YYARG. */
5264 int yycount = 0;
5265 /* Cumulated lengths of YYARG. */
5266 YYPTRDIFF_T yysize = 0;
5267
5268 /* There are many possibilities here to consider:
5269 - If this state is a consistent state with a default action, then
5270 the only way this function was invoked is if the default action
5271 is an error action. In that case, don't check for expected
5272 tokens because there are none.
5273 - The only way there can be no lookahead present (in yychar) is if
5274 this state is a consistent state with a default action. Thus,
5275 detecting the absence of a lookahead is sufficient to determine
5276 that there is no unexpected or expected token to report. In that
5277 case, just report a simple "syntax error".
5278 - Don't assume there isn't a lookahead just because this state is a
5279 consistent state with a default action. There might have been a
5280 previous inconsistent state, consistent state with a non-default
5281 action, or user semantic action that manipulated yychar.
5282 - Of course, the expected token list depends on states to have
5283 correct lookahead information, and it depends on the parser not
5284 to perform extra reductions after fetching a lookahead from the
5285 scanner and before detecting a syntax error. Thus, state merging
5286 (from LALR or IELR) and default reductions corrupt the expected
5287 token list. However, the list is correct for canonical LR with
5288 one exception: it will still contain any token that will not be
5289 accepted due to an error action in a later state.
5290 */
5291 if (yytoken != YYEMPTY)
5292 {
5293 int yyn = yypact[+*yyssp];
5294 YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
5295 yysize = yysize0;
5296 yyarg[yycount++] = yytname[yytoken];
5297 if (!yypact_value_is_default (yyn))
5298 {
5299 /* Start YYX at -YYN if negative to avoid negative indexes in
5300 YYCHECK. In other words, skip the first -YYN actions for
5301 this state because they are default actions. */
5302 int yyxbegin = yyn < 0 ? -yyn : 0;
5303 /* Stay within bounds of both yycheck and yytname. */
5304 int yychecklim = YYLAST - yyn + 1;
5305 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
5306 int yyx;
5307
5308 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
5309 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
5310 && !yytable_value_is_error (yytable[yyx + yyn]))
5311 {
5312 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
5313 {
5314 yycount = 1;
5315 yysize = yysize0;
5316 break;
5317 }
5318 yyarg[yycount++] = yytname[yyx];
5319 {
5320 YYPTRDIFF_T yysize1
5321 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
5322 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
5323 yysize = yysize1;
5324 else
5325 return 2;
5326 }
5327 }
5328 }
5329 }
5330
5331 switch (yycount)
5332 {
5333 # define YYCASE_(N, S) \
5334 case N: \
5335 yyformat = S; \
5336 break
5337 default: /* Avoid compiler warnings. */
5338 YYCASE_(0, YY_("syntax error"));
5339 YYCASE_(1, YY_("syntax error, unexpected %s"));
5340 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
5341 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
5342 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
5343 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
5344 # undef YYCASE_
5345 }
5346
5347 {
5348 /* Don't count the "%s"s in the final size, but reserve room for
5349 the terminator. */
5350 YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
5351 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
5352 yysize = yysize1;
5353 else
5354 return 2;
5355 }
5356
5357 if (*yymsg_alloc < yysize)
5358 {
5359 *yymsg_alloc = 2 * yysize;
5360 if (! (yysize <= *yymsg_alloc
5361 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
5362 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
5363 return 1;
5364 }
5365
5366 /* Avoid sprintf, as that infringes on the user's name space.
5367 Don't have undefined behavior even if the translation
5368 produced a string with the wrong number of "%s"s. */
5369 {
5370 char *yyp = *yymsg;
5371 int yyi = 0;
5372 while ((*yyp = *yyformat) != '\0')
5373 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
5374 {
5375 yyp += yytnamerr (yyp, yyarg[yyi++]);
5376 yyformat += 2;
5377 }
5378 else
5379 {
5380 ++yyp;
5381 ++yyformat;
5382 }
5383 }
5384 return 0;
5385 }
5386 #endif /* YYERROR_VERBOSE */
5387
5388 /*-----------------------------------------------.
5389 | Release the memory associated to this symbol. |
5390 `-----------------------------------------------*/
5391
5392 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep,parser_state * p)5393 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, parser_state *p)
5394 {
5395 YYUSE (yyvaluep);
5396 YYUSE (p);
5397 if (!yymsg)
5398 yymsg = "Deleting";
5399 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
5400
5401 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
5402 YYUSE (yytype);
5403 YY_IGNORE_MAYBE_UNINITIALIZED_END
5404 }
5405
5406
5407
5408
5409 /*----------.
5410 | yyparse. |
5411 `----------*/
5412
5413 int
yyparse(parser_state * p)5414 yyparse (parser_state *p)
5415 {
5416 /* The lookahead symbol. */
5417 int yychar;
5418
5419
5420 /* The semantic value of the lookahead symbol. */
5421 /* Default value used for initialization, for pacifying older GCCs
5422 or non-GCC compilers. */
5423 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
5424 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
5425
5426 /* Number of syntax errors so far. */
5427 int yynerrs;
5428
5429 yy_state_fast_t yystate;
5430 /* Number of tokens to shift before error messages enabled. */
5431 int yyerrstatus;
5432
5433 /* The stacks and their tools:
5434 'yyss': related to states.
5435 'yyvs': related to semantic values.
5436
5437 Refer to the stacks through separate pointers, to allow yyoverflow
5438 to reallocate them elsewhere. */
5439
5440 /* The state stack. */
5441 yy_state_t yyssa[YYINITDEPTH];
5442 yy_state_t *yyss;
5443 yy_state_t *yyssp;
5444
5445 /* The semantic value stack. */
5446 YYSTYPE yyvsa[YYINITDEPTH];
5447 YYSTYPE *yyvs;
5448 YYSTYPE *yyvsp;
5449
5450 YYPTRDIFF_T yystacksize;
5451
5452 int yyn;
5453 int yyresult;
5454 /* Lookahead token as an internal (translated) token number. */
5455 int yytoken = 0;
5456 /* The variables used to return semantic value and location from the
5457 action routines. */
5458 YYSTYPE yyval;
5459
5460 #if YYERROR_VERBOSE
5461 /* Buffer for error messages, and its allocated size. */
5462 char yymsgbuf[128];
5463 char *yymsg = yymsgbuf;
5464 YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
5465 #endif
5466
5467 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
5468
5469 /* The number of symbols on the RHS of the reduced rule.
5470 Keep to zero when no symbol should be popped. */
5471 int yylen = 0;
5472
5473 yyssp = yyss = yyssa;
5474 yyvsp = yyvs = yyvsa;
5475 yystacksize = YYINITDEPTH;
5476
5477 YYDPRINTF ((stderr, "Starting parse\n"));
5478
5479 yystate = 0;
5480 yyerrstatus = 0;
5481 yynerrs = 0;
5482 yychar = YYEMPTY; /* Cause a token to be read. */
5483 goto yysetstate;
5484
5485
5486 /*------------------------------------------------------------.
5487 | yynewstate -- push a new state, which is found in yystate. |
5488 `------------------------------------------------------------*/
5489 yynewstate:
5490 /* In all cases, when you get here, the value and location stacks
5491 have just been pushed. So pushing a state here evens the stacks. */
5492 yyssp++;
5493
5494
5495 /*--------------------------------------------------------------------.
5496 | yysetstate -- set current state (the top of the stack) to yystate. |
5497 `--------------------------------------------------------------------*/
5498 yysetstate:
5499 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
5500 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
5501 YY_IGNORE_USELESS_CAST_BEGIN
5502 *yyssp = YY_CAST (yy_state_t, yystate);
5503 YY_IGNORE_USELESS_CAST_END
5504
5505 if (yyss + yystacksize - 1 <= yyssp)
5506 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
5507 goto yyexhaustedlab;
5508 #else
5509 {
5510 /* Get the current used size of the three stacks, in elements. */
5511 YYPTRDIFF_T yysize = yyssp - yyss + 1;
5512
5513 # if defined yyoverflow
5514 {
5515 /* Give user a chance to reallocate the stack. Use copies of
5516 these so that the &'s don't force the real ones into
5517 memory. */
5518 yy_state_t *yyss1 = yyss;
5519 YYSTYPE *yyvs1 = yyvs;
5520
5521 /* Each stack pointer address is followed by the size of the
5522 data in use in that stack, in bytes. This used to be a
5523 conditional around just the two extra args, but that might
5524 be undefined if yyoverflow is a macro. */
5525 yyoverflow (YY_("memory exhausted"),
5526 &yyss1, yysize * YYSIZEOF (*yyssp),
5527 &yyvs1, yysize * YYSIZEOF (*yyvsp),
5528 &yystacksize);
5529 yyss = yyss1;
5530 yyvs = yyvs1;
5531 }
5532 # else /* defined YYSTACK_RELOCATE */
5533 /* Extend the stack our own way. */
5534 if (YYMAXDEPTH <= yystacksize)
5535 goto yyexhaustedlab;
5536 yystacksize *= 2;
5537 if (YYMAXDEPTH < yystacksize)
5538 yystacksize = YYMAXDEPTH;
5539
5540 {
5541 yy_state_t *yyss1 = yyss;
5542 union yyalloc *yyptr =
5543 YY_CAST (union yyalloc *,
5544 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
5545 if (! yyptr)
5546 goto yyexhaustedlab;
5547 YYSTACK_RELOCATE (yyss_alloc, yyss);
5548 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
5549 # undef YYSTACK_RELOCATE
5550 if (yyss1 != yyssa)
5551 YYSTACK_FREE (yyss1);
5552 }
5553 # endif
5554
5555 yyssp = yyss + yysize - 1;
5556 yyvsp = yyvs + yysize - 1;
5557
5558 YY_IGNORE_USELESS_CAST_BEGIN
5559 YYDPRINTF ((stderr, "Stack size increased to %ld\n",
5560 YY_CAST (long, yystacksize)));
5561 YY_IGNORE_USELESS_CAST_END
5562
5563 if (yyss + yystacksize - 1 <= yyssp)
5564 YYABORT;
5565 }
5566 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
5567
5568 if (yystate == YYFINAL)
5569 YYACCEPT;
5570
5571 goto yybackup;
5572
5573
5574 /*-----------.
5575 | yybackup. |
5576 `-----------*/
5577 yybackup:
5578 /* Do appropriate processing given the current state. Read a
5579 lookahead token if we need one and don't already have one. */
5580
5581 /* First try to decide what to do without reference to lookahead token. */
5582 yyn = yypact[yystate];
5583 if (yypact_value_is_default (yyn))
5584 goto yydefault;
5585
5586 /* Not known => get a lookahead token if don't already have one. */
5587
5588 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
5589 if (yychar == YYEMPTY)
5590 {
5591 YYDPRINTF ((stderr, "Reading a token: "));
5592 yychar = yylex (&yylval, p);
5593 }
5594
5595 if (yychar <= YYEOF)
5596 {
5597 yychar = yytoken = YYEOF;
5598 YYDPRINTF ((stderr, "Now at end of input.\n"));
5599 }
5600 else
5601 {
5602 yytoken = YYTRANSLATE (yychar);
5603 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
5604 }
5605
5606 /* If the proper action on seeing token YYTOKEN is to reduce or to
5607 detect an error, take that action. */
5608 yyn += yytoken;
5609 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
5610 goto yydefault;
5611 yyn = yytable[yyn];
5612 if (yyn <= 0)
5613 {
5614 if (yytable_value_is_error (yyn))
5615 goto yyerrlab;
5616 yyn = -yyn;
5617 goto yyreduce;
5618 }
5619
5620 /* Count tokens shifted since error; after three, turn off error
5621 status. */
5622 if (yyerrstatus)
5623 yyerrstatus--;
5624
5625 /* Shift the lookahead token. */
5626 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
5627 yystate = yyn;
5628 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
5629 *++yyvsp = yylval;
5630 YY_IGNORE_MAYBE_UNINITIALIZED_END
5631
5632 /* Discard the shifted token. */
5633 yychar = YYEMPTY;
5634 goto yynewstate;
5635
5636
5637 /*-----------------------------------------------------------.
5638 | yydefault -- do the default action for the current state. |
5639 `-----------------------------------------------------------*/
5640 yydefault:
5641 yyn = yydefact[yystate];
5642 if (yyn == 0)
5643 goto yyerrlab;
5644 goto yyreduce;
5645
5646
5647 /*-----------------------------.
5648 | yyreduce -- do a reduction. |
5649 `-----------------------------*/
5650 yyreduce:
5651 /* yyn is the number of a rule to reduce with. */
5652 yylen = yyr2[yyn];
5653
5654 /* If YYLEN is nonzero, implement the default value of the action:
5655 '$$ = $1'.
5656
5657 Otherwise, the following line sets YYVAL to garbage.
5658 This behavior is undocumented and Bison
5659 users should not rely upon it. Assigning to YYVAL
5660 unconditionally makes the parser a bit smaller, and it avoids a
5661 GCC warning that YYVAL may be used uninitialized. */
5662 yyval = yyvsp[1-yylen];
5663
5664
5665 YY_REDUCE_PRINT (yyn);
5666 switch (yyn)
5667 {
5668 case 2:
5669 #line 1508 "mrbgems/mruby-compiler/core/parse.y"
5670 {
5671 p->lstate = EXPR_BEG;
5672 if (!p->locals) p->locals = cons(0,0);
5673 }
5674 #line 5675 "mrbgems/mruby-compiler/core/y.tab.c"
5675 break;
5676
5677 case 3:
5678 #line 1513 "mrbgems/mruby-compiler/core/parse.y"
5679 {
5680 p->tree = new_scope(p, (yyvsp[0].nd));
5681 NODE_LINENO(p->tree, (yyvsp[0].nd));
5682 }
5683 #line 5684 "mrbgems/mruby-compiler/core/y.tab.c"
5684 break;
5685
5686 case 4:
5687 #line 1520 "mrbgems/mruby-compiler/core/parse.y"
5688 {
5689 (yyval.nd) = (yyvsp[-1].nd);
5690 }
5691 #line 5692 "mrbgems/mruby-compiler/core/y.tab.c"
5692 break;
5693
5694 case 5:
5695 #line 1526 "mrbgems/mruby-compiler/core/parse.y"
5696 {
5697 (yyval.nd) = new_begin(p, 0);
5698 }
5699 #line 5700 "mrbgems/mruby-compiler/core/y.tab.c"
5700 break;
5701
5702 case 6:
5703 #line 1530 "mrbgems/mruby-compiler/core/parse.y"
5704 {
5705 (yyval.nd) = new_begin(p, (yyvsp[0].nd));
5706 NODE_LINENO((yyval.nd), (yyvsp[0].nd));
5707 }
5708 #line 5709 "mrbgems/mruby-compiler/core/y.tab.c"
5709 break;
5710
5711 case 7:
5712 #line 1535 "mrbgems/mruby-compiler/core/parse.y"
5713 {
5714 (yyval.nd) = push((yyvsp[-2].nd), newline_node((yyvsp[0].nd)));
5715 }
5716 #line 5717 "mrbgems/mruby-compiler/core/y.tab.c"
5717 break;
5718
5719 case 8:
5720 #line 1539 "mrbgems/mruby-compiler/core/parse.y"
5721 {
5722 (yyval.nd) = new_begin(p, 0);
5723 }
5724 #line 5725 "mrbgems/mruby-compiler/core/y.tab.c"
5725 break;
5726
5727 case 10:
5728 #line 1546 "mrbgems/mruby-compiler/core/parse.y"
5729 {
5730 (yyval.nd) = local_switch(p);
5731 nvars_block(p);
5732 }
5733 #line 5734 "mrbgems/mruby-compiler/core/y.tab.c"
5734 break;
5735
5736 case 11:
5737 #line 1551 "mrbgems/mruby-compiler/core/parse.y"
5738 {
5739 yyerror(p, "BEGIN not supported");
5740 local_resume(p, (yyvsp[-3].nd));
5741 nvars_unnest(p);
5742 (yyval.nd) = 0;
5743 }
5744 #line 5745 "mrbgems/mruby-compiler/core/y.tab.c"
5745 break;
5746
5747 case 12:
5748 #line 1563 "mrbgems/mruby-compiler/core/parse.y"
5749 {
5750 if ((yyvsp[-2].nd)) {
5751 (yyval.nd) = new_rescue(p, (yyvsp[-3].nd), (yyvsp[-2].nd), (yyvsp[-1].nd));
5752 NODE_LINENO((yyval.nd), (yyvsp[-3].nd));
5753 }
5754 else if ((yyvsp[-1].nd)) {
5755 yywarn(p, "else without rescue is useless");
5756 (yyval.nd) = push((yyvsp[-3].nd), (yyvsp[-1].nd));
5757 }
5758 else {
5759 (yyval.nd) = (yyvsp[-3].nd);
5760 }
5761 if ((yyvsp[0].nd)) {
5762 if ((yyval.nd)) {
5763 (yyval.nd) = new_ensure(p, (yyval.nd), (yyvsp[0].nd));
5764 }
5765 else {
5766 (yyval.nd) = push((yyvsp[0].nd), new_nil(p));
5767 }
5768 }
5769 }
5770 #line 5771 "mrbgems/mruby-compiler/core/y.tab.c"
5771 break;
5772
5773 case 13:
5774 #line 1587 "mrbgems/mruby-compiler/core/parse.y"
5775 {
5776 (yyval.nd) = (yyvsp[-1].nd);
5777 }
5778 #line 5779 "mrbgems/mruby-compiler/core/y.tab.c"
5779 break;
5780
5781 case 14:
5782 #line 1593 "mrbgems/mruby-compiler/core/parse.y"
5783 {
5784 (yyval.nd) = new_begin(p, 0);
5785 }
5786 #line 5787 "mrbgems/mruby-compiler/core/y.tab.c"
5787 break;
5788
5789 case 15:
5790 #line 1597 "mrbgems/mruby-compiler/core/parse.y"
5791 {
5792 (yyval.nd) = new_begin(p, (yyvsp[0].nd));
5793 NODE_LINENO((yyval.nd), (yyvsp[0].nd));
5794 }
5795 #line 5796 "mrbgems/mruby-compiler/core/y.tab.c"
5796 break;
5797
5798 case 16:
5799 #line 1602 "mrbgems/mruby-compiler/core/parse.y"
5800 {
5801 (yyval.nd) = push((yyvsp[-2].nd), newline_node((yyvsp[0].nd)));
5802 }
5803 #line 5804 "mrbgems/mruby-compiler/core/y.tab.c"
5804 break;
5805
5806 case 17:
5807 #line 1606 "mrbgems/mruby-compiler/core/parse.y"
5808 {
5809 (yyval.nd) = new_begin(p, (yyvsp[0].nd));
5810 }
5811 #line 5812 "mrbgems/mruby-compiler/core/y.tab.c"
5812 break;
5813
5814 case 18:
5815 #line 1611 "mrbgems/mruby-compiler/core/parse.y"
5816 {p->lstate = EXPR_FNAME;}
5817 #line 5818 "mrbgems/mruby-compiler/core/y.tab.c"
5818 break;
5819
5820 case 19:
5821 #line 1612 "mrbgems/mruby-compiler/core/parse.y"
5822 {
5823 (yyval.nd) = new_alias(p, (yyvsp[-2].id), (yyvsp[0].id));
5824 }
5825 #line 5826 "mrbgems/mruby-compiler/core/y.tab.c"
5826 break;
5827
5828 case 20:
5829 #line 1616 "mrbgems/mruby-compiler/core/parse.y"
5830 {
5831 (yyval.nd) = (yyvsp[0].nd);
5832 }
5833 #line 5834 "mrbgems/mruby-compiler/core/y.tab.c"
5834 break;
5835
5836 case 21:
5837 #line 1620 "mrbgems/mruby-compiler/core/parse.y"
5838 {
5839 (yyval.nd) = new_if(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd), 0);
5840 }
5841 #line 5842 "mrbgems/mruby-compiler/core/y.tab.c"
5842 break;
5843
5844 case 22:
5845 #line 1624 "mrbgems/mruby-compiler/core/parse.y"
5846 {
5847 (yyval.nd) = new_unless(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd), 0);
5848 }
5849 #line 5850 "mrbgems/mruby-compiler/core/y.tab.c"
5850 break;
5851
5852 case 23:
5853 #line 1628 "mrbgems/mruby-compiler/core/parse.y"
5854 {
5855 (yyval.nd) = new_while(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd));
5856 }
5857 #line 5858 "mrbgems/mruby-compiler/core/y.tab.c"
5858 break;
5859
5860 case 24:
5861 #line 1632 "mrbgems/mruby-compiler/core/parse.y"
5862 {
5863 (yyval.nd) = new_until(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd));
5864 }
5865 #line 5866 "mrbgems/mruby-compiler/core/y.tab.c"
5866 break;
5867
5868 case 25:
5869 #line 1636 "mrbgems/mruby-compiler/core/parse.y"
5870 {
5871 (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
5872 }
5873 #line 5874 "mrbgems/mruby-compiler/core/y.tab.c"
5874 break;
5875
5876 case 26:
5877 #line 1640 "mrbgems/mruby-compiler/core/parse.y"
5878 {
5879 yyerror(p, "END not supported");
5880 (yyval.nd) = new_postexe(p, (yyvsp[-1].nd));
5881 }
5882 #line 5883 "mrbgems/mruby-compiler/core/y.tab.c"
5883 break;
5884
5885 case 28:
5886 #line 1646 "mrbgems/mruby-compiler/core/parse.y"
5887 {
5888 (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
5889 }
5890 #line 5891 "mrbgems/mruby-compiler/core/y.tab.c"
5891 break;
5892
5893 case 29:
5894 #line 1650 "mrbgems/mruby-compiler/core/parse.y"
5895 {
5896 (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd)));
5897 }
5898 #line 5899 "mrbgems/mruby-compiler/core/y.tab.c"
5899 break;
5900
5901 case 30:
5902 #line 1654 "mrbgems/mruby-compiler/core/parse.y"
5903 {
5904 (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
5905 }
5906 #line 5907 "mrbgems/mruby-compiler/core/y.tab.c"
5907 break;
5908
5909 case 31:
5910 #line 1658 "mrbgems/mruby-compiler/core/parse.y"
5911 {
5912 (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd)));
5913 }
5914 #line 5915 "mrbgems/mruby-compiler/core/y.tab.c"
5915 break;
5916
5917 case 33:
5918 #line 1665 "mrbgems/mruby-compiler/core/parse.y"
5919 {
5920 (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
5921 }
5922 #line 5923 "mrbgems/mruby-compiler/core/y.tab.c"
5923 break;
5924
5925 case 34:
5926 #line 1669 "mrbgems/mruby-compiler/core/parse.y"
5927 {
5928 (yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd));
5929 }
5930 #line 5931 "mrbgems/mruby-compiler/core/y.tab.c"
5931 break;
5932
5933 case 35:
5934 #line 1673 "mrbgems/mruby-compiler/core/parse.y"
5935 {
5936 (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_lit("[]"), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
5937 }
5938 #line 5939 "mrbgems/mruby-compiler/core/y.tab.c"
5939 break;
5940
5941 case 36:
5942 #line 1677 "mrbgems/mruby-compiler/core/parse.y"
5943 {
5944 (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
5945 }
5946 #line 5947 "mrbgems/mruby-compiler/core/y.tab.c"
5947 break;
5948
5949 case 37:
5950 #line 1681 "mrbgems/mruby-compiler/core/parse.y"
5951 {
5952 (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
5953 }
5954 #line 5955 "mrbgems/mruby-compiler/core/y.tab.c"
5955 break;
5956
5957 case 38:
5958 #line 1685 "mrbgems/mruby-compiler/core/parse.y"
5959 {
5960 yyerror(p, "constant re-assignment");
5961 (yyval.nd) = 0;
5962 }
5963 #line 5964 "mrbgems/mruby-compiler/core/y.tab.c"
5964 break;
5965
5966 case 39:
5967 #line 1690 "mrbgems/mruby-compiler/core/parse.y"
5968 {
5969 (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, tCOLON2), (yyvsp[-1].id), (yyvsp[0].nd));
5970 }
5971 #line 5972 "mrbgems/mruby-compiler/core/y.tab.c"
5972 break;
5973
5974 case 40:
5975 #line 1694 "mrbgems/mruby-compiler/core/parse.y"
5976 {
5977 backref_error(p, (yyvsp[-2].nd));
5978 (yyval.nd) = new_begin(p, 0);
5979 }
5980 #line 5981 "mrbgems/mruby-compiler/core/y.tab.c"
5981 break;
5982
5983 case 42:
5984 #line 1702 "mrbgems/mruby-compiler/core/parse.y"
5985 {
5986 (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
5987 }
5988 #line 5989 "mrbgems/mruby-compiler/core/y.tab.c"
5989 break;
5990
5991 case 45:
5992 #line 1711 "mrbgems/mruby-compiler/core/parse.y"
5993 {
5994 (yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd));
5995 }
5996 #line 5997 "mrbgems/mruby-compiler/core/y.tab.c"
5997 break;
5998
5999 case 46:
6000 #line 1715 "mrbgems/mruby-compiler/core/parse.y"
6001 {
6002 (yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd));
6003 }
6004 #line 6005 "mrbgems/mruby-compiler/core/y.tab.c"
6005 break;
6006
6007 case 47:
6008 #line 1719 "mrbgems/mruby-compiler/core/parse.y"
6009 {
6010 (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
6011 }
6012 #line 6013 "mrbgems/mruby-compiler/core/y.tab.c"
6013 break;
6014
6015 case 48:
6016 #line 1723 "mrbgems/mruby-compiler/core/parse.y"
6017 {
6018 (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
6019 }
6020 #line 6021 "mrbgems/mruby-compiler/core/y.tab.c"
6021 break;
6022
6023 case 50:
6024 #line 1730 "mrbgems/mruby-compiler/core/parse.y"
6025 {
6026 if (!(yyvsp[0].nd)) (yyval.nd) = new_nil(p);
6027 else {
6028 (yyval.nd) = (yyvsp[0].nd);
6029 }
6030 }
6031 #line 6032 "mrbgems/mruby-compiler/core/y.tab.c"
6032 break;
6033
6034 case 54:
6035 #line 1744 "mrbgems/mruby-compiler/core/parse.y"
6036 {
6037 (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
6038 }
6039 #line 6040 "mrbgems/mruby-compiler/core/y.tab.c"
6040 break;
6041
6042 case 55:
6043 #line 1750 "mrbgems/mruby-compiler/core/parse.y"
6044 {
6045 local_nest(p);
6046 nvars_nest(p);
6047 }
6048 #line 6049 "mrbgems/mruby-compiler/core/y.tab.c"
6049 break;
6050
6051 case 56:
6052 #line 1757 "mrbgems/mruby-compiler/core/parse.y"
6053 {
6054 (yyval.nd) = new_block(p, (yyvsp[-2].nd), (yyvsp[-1].nd));
6055 local_unnest(p);
6056 nvars_unnest(p);
6057 }
6058 #line 6059 "mrbgems/mruby-compiler/core/y.tab.c"
6059 break;
6060
6061 case 57:
6062 #line 1765 "mrbgems/mruby-compiler/core/parse.y"
6063 {
6064 (yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd));
6065 }
6066 #line 6067 "mrbgems/mruby-compiler/core/y.tab.c"
6067 break;
6068
6069 case 58:
6070 #line 1769 "mrbgems/mruby-compiler/core/parse.y"
6071 {
6072 args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
6073 (yyval.nd) = new_fcall(p, (yyvsp[-2].id), (yyvsp[-1].nd));
6074 }
6075 #line 6076 "mrbgems/mruby-compiler/core/y.tab.c"
6076 break;
6077
6078 case 59:
6079 #line 1774 "mrbgems/mruby-compiler/core/parse.y"
6080 {
6081 (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
6082 }
6083 #line 6084 "mrbgems/mruby-compiler/core/y.tab.c"
6084 break;
6085
6086 case 60:
6087 #line 1778 "mrbgems/mruby-compiler/core/parse.y"
6088 {
6089 args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
6090 (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num));
6091 }
6092 #line 6093 "mrbgems/mruby-compiler/core/y.tab.c"
6093 break;
6094
6095 case 61:
6096 #line 1783 "mrbgems/mruby-compiler/core/parse.y"
6097 {
6098 (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2);
6099 }
6100 #line 6101 "mrbgems/mruby-compiler/core/y.tab.c"
6101 break;
6102
6103 case 62:
6104 #line 1787 "mrbgems/mruby-compiler/core/parse.y"
6105 {
6106 args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
6107 (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), tCOLON2);
6108 }
6109 #line 6110 "mrbgems/mruby-compiler/core/y.tab.c"
6110 break;
6111
6112 case 63:
6113 #line 1792 "mrbgems/mruby-compiler/core/parse.y"
6114 {
6115 (yyval.nd) = new_super(p, (yyvsp[0].nd));
6116 }
6117 #line 6118 "mrbgems/mruby-compiler/core/y.tab.c"
6118 break;
6119
6120 case 64:
6121 #line 1796 "mrbgems/mruby-compiler/core/parse.y"
6122 {
6123 (yyval.nd) = new_yield(p, (yyvsp[0].nd));
6124 }
6125 #line 6126 "mrbgems/mruby-compiler/core/y.tab.c"
6126 break;
6127
6128 case 65:
6129 #line 1800 "mrbgems/mruby-compiler/core/parse.y"
6130 {
6131 (yyval.nd) = new_return(p, ret_args(p, (yyvsp[0].nd)));
6132 }
6133 #line 6134 "mrbgems/mruby-compiler/core/y.tab.c"
6134 break;
6135
6136 case 66:
6137 #line 1804 "mrbgems/mruby-compiler/core/parse.y"
6138 {
6139 (yyval.nd) = new_break(p, ret_args(p, (yyvsp[0].nd)));
6140 }
6141 #line 6142 "mrbgems/mruby-compiler/core/y.tab.c"
6142 break;
6143
6144 case 67:
6145 #line 1808 "mrbgems/mruby-compiler/core/parse.y"
6146 {
6147 (yyval.nd) = new_next(p, ret_args(p, (yyvsp[0].nd)));
6148 }
6149 #line 6150 "mrbgems/mruby-compiler/core/y.tab.c"
6150 break;
6151
6152 case 68:
6153 #line 1814 "mrbgems/mruby-compiler/core/parse.y"
6154 {
6155 (yyval.nd) = (yyvsp[0].nd);
6156 }
6157 #line 6158 "mrbgems/mruby-compiler/core/y.tab.c"
6158 break;
6159
6160 case 69:
6161 #line 1818 "mrbgems/mruby-compiler/core/parse.y"
6162 {
6163 (yyval.nd) = (yyvsp[-1].nd);
6164 }
6165 #line 6166 "mrbgems/mruby-compiler/core/y.tab.c"
6166 break;
6167
6168 case 71:
6169 #line 1825 "mrbgems/mruby-compiler/core/parse.y"
6170 {
6171 (yyval.nd) = (yyvsp[-1].nd);
6172 }
6173 #line 6174 "mrbgems/mruby-compiler/core/y.tab.c"
6174 break;
6175
6176 case 72:
6177 #line 1831 "mrbgems/mruby-compiler/core/parse.y"
6178 {
6179 (yyval.nd) = list1((yyvsp[0].nd));
6180 }
6181 #line 6182 "mrbgems/mruby-compiler/core/y.tab.c"
6182 break;
6183
6184 case 73:
6185 #line 1835 "mrbgems/mruby-compiler/core/parse.y"
6186 {
6187 (yyval.nd) = list1(push((yyvsp[-1].nd),(yyvsp[0].nd)));
6188 }
6189 #line 6190 "mrbgems/mruby-compiler/core/y.tab.c"
6190 break;
6191
6192 case 74:
6193 #line 1839 "mrbgems/mruby-compiler/core/parse.y"
6194 {
6195 (yyval.nd) = list2((yyvsp[-2].nd), (yyvsp[0].nd));
6196 }
6197 #line 6198 "mrbgems/mruby-compiler/core/y.tab.c"
6198 break;
6199
6200 case 75:
6201 #line 1843 "mrbgems/mruby-compiler/core/parse.y"
6202 {
6203 (yyval.nd) = list3((yyvsp[-4].nd), (yyvsp[-2].nd), (yyvsp[0].nd));
6204 }
6205 #line 6206 "mrbgems/mruby-compiler/core/y.tab.c"
6206 break;
6207
6208 case 76:
6209 #line 1847 "mrbgems/mruby-compiler/core/parse.y"
6210 {
6211 (yyval.nd) = list2((yyvsp[-1].nd), new_nil(p));
6212 }
6213 #line 6214 "mrbgems/mruby-compiler/core/y.tab.c"
6214 break;
6215
6216 case 77:
6217 #line 1851 "mrbgems/mruby-compiler/core/parse.y"
6218 {
6219 (yyval.nd) = list3((yyvsp[-3].nd), new_nil(p), (yyvsp[0].nd));
6220 }
6221 #line 6222 "mrbgems/mruby-compiler/core/y.tab.c"
6222 break;
6223
6224 case 78:
6225 #line 1855 "mrbgems/mruby-compiler/core/parse.y"
6226 {
6227 (yyval.nd) = list2(0, (yyvsp[0].nd));
6228 }
6229 #line 6230 "mrbgems/mruby-compiler/core/y.tab.c"
6230 break;
6231
6232 case 79:
6233 #line 1859 "mrbgems/mruby-compiler/core/parse.y"
6234 {
6235 (yyval.nd) = list3(0, (yyvsp[-2].nd), (yyvsp[0].nd));
6236 }
6237 #line 6238 "mrbgems/mruby-compiler/core/y.tab.c"
6238 break;
6239
6240 case 80:
6241 #line 1863 "mrbgems/mruby-compiler/core/parse.y"
6242 {
6243 (yyval.nd) = list2(0, new_nil(p));
6244 }
6245 #line 6246 "mrbgems/mruby-compiler/core/y.tab.c"
6246 break;
6247
6248 case 81:
6249 #line 1867 "mrbgems/mruby-compiler/core/parse.y"
6250 {
6251 (yyval.nd) = list3(0, new_nil(p), (yyvsp[0].nd));
6252 }
6253 #line 6254 "mrbgems/mruby-compiler/core/y.tab.c"
6254 break;
6255
6256 case 83:
6257 #line 1874 "mrbgems/mruby-compiler/core/parse.y"
6258 {
6259 (yyval.nd) = new_masgn(p, (yyvsp[-1].nd), NULL);
6260 }
6261 #line 6262 "mrbgems/mruby-compiler/core/y.tab.c"
6262 break;
6263
6264 case 84:
6265 #line 1880 "mrbgems/mruby-compiler/core/parse.y"
6266 {
6267 (yyval.nd) = list1((yyvsp[-1].nd));
6268 }
6269 #line 6270 "mrbgems/mruby-compiler/core/y.tab.c"
6270 break;
6271
6272 case 85:
6273 #line 1884 "mrbgems/mruby-compiler/core/parse.y"
6274 {
6275 (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[-1].nd));
6276 }
6277 #line 6278 "mrbgems/mruby-compiler/core/y.tab.c"
6278 break;
6279
6280 case 86:
6281 #line 1890 "mrbgems/mruby-compiler/core/parse.y"
6282 {
6283 (yyval.nd) = list1((yyvsp[0].nd));
6284 }
6285 #line 6286 "mrbgems/mruby-compiler/core/y.tab.c"
6286 break;
6287
6288 case 87:
6289 #line 1894 "mrbgems/mruby-compiler/core/parse.y"
6290 {
6291 (yyval.nd) = push((yyvsp[-1].nd), (yyvsp[0].nd));
6292 }
6293 #line 6294 "mrbgems/mruby-compiler/core/y.tab.c"
6294 break;
6295
6296 case 88:
6297 #line 1900 "mrbgems/mruby-compiler/core/parse.y"
6298 {
6299 assignable(p, (yyvsp[0].nd));
6300 }
6301 #line 6302 "mrbgems/mruby-compiler/core/y.tab.c"
6302 break;
6303
6304 case 89:
6305 #line 1904 "mrbgems/mruby-compiler/core/parse.y"
6306 {
6307 (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_lit("[]"), (yyvsp[-1].nd), '.');
6308 }
6309 #line 6310 "mrbgems/mruby-compiler/core/y.tab.c"
6310 break;
6311
6312 case 90:
6313 #line 1908 "mrbgems/mruby-compiler/core/parse.y"
6314 {
6315 (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
6316 }
6317 #line 6318 "mrbgems/mruby-compiler/core/y.tab.c"
6318 break;
6319
6320 case 91:
6321 #line 1912 "mrbgems/mruby-compiler/core/parse.y"
6322 {
6323 (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
6324 }
6325 #line 6326 "mrbgems/mruby-compiler/core/y.tab.c"
6326 break;
6327
6328 case 92:
6329 #line 1916 "mrbgems/mruby-compiler/core/parse.y"
6330 {
6331 (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
6332 }
6333 #line 6334 "mrbgems/mruby-compiler/core/y.tab.c"
6334 break;
6335
6336 case 93:
6337 #line 1920 "mrbgems/mruby-compiler/core/parse.y"
6338 {
6339 if (p->in_def || p->in_single)
6340 yyerror(p, "dynamic constant assignment");
6341 (yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id));
6342 }
6343 #line 6344 "mrbgems/mruby-compiler/core/y.tab.c"
6344 break;
6345
6346 case 94:
6347 #line 1926 "mrbgems/mruby-compiler/core/parse.y"
6348 {
6349 if (p->in_def || p->in_single)
6350 yyerror(p, "dynamic constant assignment");
6351 (yyval.nd) = new_colon3(p, (yyvsp[0].id));
6352 }
6353 #line 6354 "mrbgems/mruby-compiler/core/y.tab.c"
6354 break;
6355
6356 case 95:
6357 #line 1932 "mrbgems/mruby-compiler/core/parse.y"
6358 {
6359 backref_error(p, (yyvsp[0].nd));
6360 (yyval.nd) = 0;
6361 }
6362 #line 6363 "mrbgems/mruby-compiler/core/y.tab.c"
6363 break;
6364
6365 case 96:
6366 #line 1939 "mrbgems/mruby-compiler/core/parse.y"
6367 {
6368 assignable(p, (yyvsp[0].nd));
6369 }
6370 #line 6371 "mrbgems/mruby-compiler/core/y.tab.c"
6371 break;
6372
6373 case 97:
6374 #line 1943 "mrbgems/mruby-compiler/core/parse.y"
6375 {
6376 (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_lit("[]"), (yyvsp[-1].nd), '.');
6377 }
6378 #line 6379 "mrbgems/mruby-compiler/core/y.tab.c"
6379 break;
6380
6381 case 98:
6382 #line 1947 "mrbgems/mruby-compiler/core/parse.y"
6383 {
6384 (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
6385 }
6386 #line 6387 "mrbgems/mruby-compiler/core/y.tab.c"
6387 break;
6388
6389 case 99:
6390 #line 1951 "mrbgems/mruby-compiler/core/parse.y"
6391 {
6392 (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
6393 }
6394 #line 6395 "mrbgems/mruby-compiler/core/y.tab.c"
6395 break;
6396
6397 case 100:
6398 #line 1955 "mrbgems/mruby-compiler/core/parse.y"
6399 {
6400 (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
6401 }
6402 #line 6403 "mrbgems/mruby-compiler/core/y.tab.c"
6403 break;
6404
6405 case 101:
6406 #line 1959 "mrbgems/mruby-compiler/core/parse.y"
6407 {
6408 if (p->in_def || p->in_single)
6409 yyerror(p, "dynamic constant assignment");
6410 (yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id));
6411 }
6412 #line 6413 "mrbgems/mruby-compiler/core/y.tab.c"
6413 break;
6414
6415 case 102:
6416 #line 1965 "mrbgems/mruby-compiler/core/parse.y"
6417 {
6418 if (p->in_def || p->in_single)
6419 yyerror(p, "dynamic constant assignment");
6420 (yyval.nd) = new_colon3(p, (yyvsp[0].id));
6421 }
6422 #line 6423 "mrbgems/mruby-compiler/core/y.tab.c"
6423 break;
6424
6425 case 103:
6426 #line 1971 "mrbgems/mruby-compiler/core/parse.y"
6427 {
6428 backref_error(p, (yyvsp[0].nd));
6429 (yyval.nd) = 0;
6430 }
6431 #line 6432 "mrbgems/mruby-compiler/core/y.tab.c"
6432 break;
6433
6434 case 104:
6435 #line 1976 "mrbgems/mruby-compiler/core/parse.y"
6436 {
6437 yyerror(p, "can't assign to numbered parameter");
6438 }
6439 #line 6440 "mrbgems/mruby-compiler/core/y.tab.c"
6440 break;
6441
6442 case 105:
6443 #line 1982 "mrbgems/mruby-compiler/core/parse.y"
6444 {
6445 yyerror(p, "class/module name must be CONSTANT");
6446 }
6447 #line 6448 "mrbgems/mruby-compiler/core/y.tab.c"
6448 break;
6449
6450 case 107:
6451 #line 1989 "mrbgems/mruby-compiler/core/parse.y"
6452 {
6453 (yyval.nd) = cons((node*)1, nsym((yyvsp[0].id)));
6454 }
6455 #line 6456 "mrbgems/mruby-compiler/core/y.tab.c"
6456 break;
6457
6458 case 108:
6459 #line 1993 "mrbgems/mruby-compiler/core/parse.y"
6460 {
6461 (yyval.nd) = cons((node*)0, nsym((yyvsp[0].id)));
6462 }
6463 #line 6464 "mrbgems/mruby-compiler/core/y.tab.c"
6464 break;
6465
6466 case 109:
6467 #line 1997 "mrbgems/mruby-compiler/core/parse.y"
6468 {
6469 void_expr_error(p, (yyvsp[-2].nd));
6470 (yyval.nd) = cons((yyvsp[-2].nd), nsym((yyvsp[0].id)));
6471 }
6472 #line 6473 "mrbgems/mruby-compiler/core/y.tab.c"
6473 break;
6474
6475 case 113:
6476 #line 2007 "mrbgems/mruby-compiler/core/parse.y"
6477 {
6478 p->lstate = EXPR_ENDFN;
6479 (yyval.id) = (yyvsp[0].id);
6480 }
6481 #line 6482 "mrbgems/mruby-compiler/core/y.tab.c"
6482 break;
6483
6484 case 114:
6485 #line 2012 "mrbgems/mruby-compiler/core/parse.y"
6486 {
6487 p->lstate = EXPR_ENDFN;
6488 (yyval.id) = (yyvsp[0].id);
6489 }
6490 #line 6491 "mrbgems/mruby-compiler/core/y.tab.c"
6491 break;
6492
6493 case 117:
6494 #line 2023 "mrbgems/mruby-compiler/core/parse.y"
6495 {
6496 (yyval.nd) = new_undef(p, (yyvsp[0].id));
6497 }
6498 #line 6499 "mrbgems/mruby-compiler/core/y.tab.c"
6499 break;
6500
6501 case 118:
6502 #line 2026 "mrbgems/mruby-compiler/core/parse.y"
6503 {p->lstate = EXPR_FNAME;}
6504 #line 6505 "mrbgems/mruby-compiler/core/y.tab.c"
6505 break;
6506
6507 case 119:
6508 #line 2027 "mrbgems/mruby-compiler/core/parse.y"
6509 {
6510 (yyval.nd) = push((yyvsp[-3].nd), nsym((yyvsp[0].id)));
6511 }
6512 #line 6513 "mrbgems/mruby-compiler/core/y.tab.c"
6513 break;
6514
6515 case 120:
6516 #line 2032 "mrbgems/mruby-compiler/core/parse.y"
6517 { (yyval.id) = intern_lit("|"); }
6518 #line 6519 "mrbgems/mruby-compiler/core/y.tab.c"
6519 break;
6520
6521 case 121:
6522 #line 2033 "mrbgems/mruby-compiler/core/parse.y"
6523 { (yyval.id) = intern_lit("^"); }
6524 #line 6525 "mrbgems/mruby-compiler/core/y.tab.c"
6525 break;
6526
6527 case 122:
6528 #line 2034 "mrbgems/mruby-compiler/core/parse.y"
6529 { (yyval.id) = intern_lit("&"); }
6530 #line 6531 "mrbgems/mruby-compiler/core/y.tab.c"
6531 break;
6532
6533 case 123:
6534 #line 2035 "mrbgems/mruby-compiler/core/parse.y"
6535 { (yyval.id) = intern_lit("<=>"); }
6536 #line 6537 "mrbgems/mruby-compiler/core/y.tab.c"
6537 break;
6538
6539 case 124:
6540 #line 2036 "mrbgems/mruby-compiler/core/parse.y"
6541 { (yyval.id) = intern_lit("=="); }
6542 #line 6543 "mrbgems/mruby-compiler/core/y.tab.c"
6543 break;
6544
6545 case 125:
6546 #line 2037 "mrbgems/mruby-compiler/core/parse.y"
6547 { (yyval.id) = intern_lit("==="); }
6548 #line 6549 "mrbgems/mruby-compiler/core/y.tab.c"
6549 break;
6550
6551 case 126:
6552 #line 2038 "mrbgems/mruby-compiler/core/parse.y"
6553 { (yyval.id) = intern_lit("=~"); }
6554 #line 6555 "mrbgems/mruby-compiler/core/y.tab.c"
6555 break;
6556
6557 case 127:
6558 #line 2039 "mrbgems/mruby-compiler/core/parse.y"
6559 { (yyval.id) = intern_lit("!~"); }
6560 #line 6561 "mrbgems/mruby-compiler/core/y.tab.c"
6561 break;
6562
6563 case 128:
6564 #line 2040 "mrbgems/mruby-compiler/core/parse.y"
6565 { (yyval.id) = intern_lit(">"); }
6566 #line 6567 "mrbgems/mruby-compiler/core/y.tab.c"
6567 break;
6568
6569 case 129:
6570 #line 2041 "mrbgems/mruby-compiler/core/parse.y"
6571 { (yyval.id) = intern_lit(">="); }
6572 #line 6573 "mrbgems/mruby-compiler/core/y.tab.c"
6573 break;
6574
6575 case 130:
6576 #line 2042 "mrbgems/mruby-compiler/core/parse.y"
6577 { (yyval.id) = intern_lit("<"); }
6578 #line 6579 "mrbgems/mruby-compiler/core/y.tab.c"
6579 break;
6580
6581 case 131:
6582 #line 2043 "mrbgems/mruby-compiler/core/parse.y"
6583 { (yyval.id) = intern_lit("<="); }
6584 #line 6585 "mrbgems/mruby-compiler/core/y.tab.c"
6585 break;
6586
6587 case 132:
6588 #line 2044 "mrbgems/mruby-compiler/core/parse.y"
6589 { (yyval.id) = intern_lit("!="); }
6590 #line 6591 "mrbgems/mruby-compiler/core/y.tab.c"
6591 break;
6592
6593 case 133:
6594 #line 2045 "mrbgems/mruby-compiler/core/parse.y"
6595 { (yyval.id) = intern_lit("<<"); }
6596 #line 6597 "mrbgems/mruby-compiler/core/y.tab.c"
6597 break;
6598
6599 case 134:
6600 #line 2046 "mrbgems/mruby-compiler/core/parse.y"
6601 { (yyval.id) = intern_lit(">>"); }
6602 #line 6603 "mrbgems/mruby-compiler/core/y.tab.c"
6603 break;
6604
6605 case 135:
6606 #line 2047 "mrbgems/mruby-compiler/core/parse.y"
6607 { (yyval.id) = intern_lit("+"); }
6608 #line 6609 "mrbgems/mruby-compiler/core/y.tab.c"
6609 break;
6610
6611 case 136:
6612 #line 2048 "mrbgems/mruby-compiler/core/parse.y"
6613 { (yyval.id) = intern_lit("-"); }
6614 #line 6615 "mrbgems/mruby-compiler/core/y.tab.c"
6615 break;
6616
6617 case 137:
6618 #line 2049 "mrbgems/mruby-compiler/core/parse.y"
6619 { (yyval.id) = intern_lit("*"); }
6620 #line 6621 "mrbgems/mruby-compiler/core/y.tab.c"
6621 break;
6622
6623 case 138:
6624 #line 2050 "mrbgems/mruby-compiler/core/parse.y"
6625 { (yyval.id) = intern_lit("*"); }
6626 #line 6627 "mrbgems/mruby-compiler/core/y.tab.c"
6627 break;
6628
6629 case 139:
6630 #line 2051 "mrbgems/mruby-compiler/core/parse.y"
6631 { (yyval.id) = intern_lit("/"); }
6632 #line 6633 "mrbgems/mruby-compiler/core/y.tab.c"
6633 break;
6634
6635 case 140:
6636 #line 2052 "mrbgems/mruby-compiler/core/parse.y"
6637 { (yyval.id) = intern_lit("%"); }
6638 #line 6639 "mrbgems/mruby-compiler/core/y.tab.c"
6639 break;
6640
6641 case 141:
6642 #line 2053 "mrbgems/mruby-compiler/core/parse.y"
6643 { (yyval.id) = intern_lit("**"); }
6644 #line 6645 "mrbgems/mruby-compiler/core/y.tab.c"
6645 break;
6646
6647 case 142:
6648 #line 2054 "mrbgems/mruby-compiler/core/parse.y"
6649 { (yyval.id) = intern_lit("**"); }
6650 #line 6651 "mrbgems/mruby-compiler/core/y.tab.c"
6651 break;
6652
6653 case 143:
6654 #line 2055 "mrbgems/mruby-compiler/core/parse.y"
6655 { (yyval.id) = intern_lit("!"); }
6656 #line 6657 "mrbgems/mruby-compiler/core/y.tab.c"
6657 break;
6658
6659 case 144:
6660 #line 2056 "mrbgems/mruby-compiler/core/parse.y"
6661 { (yyval.id) = intern_lit("~"); }
6662 #line 6663 "mrbgems/mruby-compiler/core/y.tab.c"
6663 break;
6664
6665 case 145:
6666 #line 2057 "mrbgems/mruby-compiler/core/parse.y"
6667 { (yyval.id) = intern_lit("+@"); }
6668 #line 6669 "mrbgems/mruby-compiler/core/y.tab.c"
6669 break;
6670
6671 case 146:
6672 #line 2058 "mrbgems/mruby-compiler/core/parse.y"
6673 { (yyval.id) = intern_lit("-@"); }
6674 #line 6675 "mrbgems/mruby-compiler/core/y.tab.c"
6675 break;
6676
6677 case 147:
6678 #line 2059 "mrbgems/mruby-compiler/core/parse.y"
6679 { (yyval.id) = intern_lit("[]"); }
6680 #line 6681 "mrbgems/mruby-compiler/core/y.tab.c"
6681 break;
6682
6683 case 148:
6684 #line 2060 "mrbgems/mruby-compiler/core/parse.y"
6685 { (yyval.id) = intern_lit("[]="); }
6686 #line 6687 "mrbgems/mruby-compiler/core/y.tab.c"
6687 break;
6688
6689 case 149:
6690 #line 2061 "mrbgems/mruby-compiler/core/parse.y"
6691 { (yyval.id) = intern_lit("`"); }
6692 #line 6693 "mrbgems/mruby-compiler/core/y.tab.c"
6693 break;
6694
6695 case 190:
6696 #line 2079 "mrbgems/mruby-compiler/core/parse.y"
6697 {
6698 (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
6699 }
6700 #line 6701 "mrbgems/mruby-compiler/core/y.tab.c"
6701 break;
6702
6703 case 191:
6704 #line 2083 "mrbgems/mruby-compiler/core/parse.y"
6705 {
6706 (yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd));
6707 }
6708 #line 6709 "mrbgems/mruby-compiler/core/y.tab.c"
6709 break;
6710
6711 case 192:
6712 #line 2087 "mrbgems/mruby-compiler/core/parse.y"
6713 {
6714 (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_lit("[]"), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
6715 }
6716 #line 6717 "mrbgems/mruby-compiler/core/y.tab.c"
6717 break;
6718
6719 case 193:
6720 #line 2091 "mrbgems/mruby-compiler/core/parse.y"
6721 {
6722 (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
6723 }
6724 #line 6725 "mrbgems/mruby-compiler/core/y.tab.c"
6725 break;
6726
6727 case 194:
6728 #line 2095 "mrbgems/mruby-compiler/core/parse.y"
6729 {
6730 (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
6731 }
6732 #line 6733 "mrbgems/mruby-compiler/core/y.tab.c"
6733 break;
6734
6735 case 195:
6736 #line 2099 "mrbgems/mruby-compiler/core/parse.y"
6737 {
6738 (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, tCOLON2), (yyvsp[-1].id), (yyvsp[0].nd));
6739 }
6740 #line 6741 "mrbgems/mruby-compiler/core/y.tab.c"
6741 break;
6742
6743 case 196:
6744 #line 2103 "mrbgems/mruby-compiler/core/parse.y"
6745 {
6746 yyerror(p, "constant re-assignment");
6747 (yyval.nd) = new_begin(p, 0);
6748 }
6749 #line 6750 "mrbgems/mruby-compiler/core/y.tab.c"
6750 break;
6751
6752 case 197:
6753 #line 2108 "mrbgems/mruby-compiler/core/parse.y"
6754 {
6755 yyerror(p, "constant re-assignment");
6756 (yyval.nd) = new_begin(p, 0);
6757 }
6758 #line 6759 "mrbgems/mruby-compiler/core/y.tab.c"
6759 break;
6760
6761 case 198:
6762 #line 2113 "mrbgems/mruby-compiler/core/parse.y"
6763 {
6764 backref_error(p, (yyvsp[-2].nd));
6765 (yyval.nd) = new_begin(p, 0);
6766 }
6767 #line 6768 "mrbgems/mruby-compiler/core/y.tab.c"
6768 break;
6769
6770 case 199:
6771 #line 2118 "mrbgems/mruby-compiler/core/parse.y"
6772 {
6773 (yyval.nd) = new_dot2(p, (yyvsp[-2].nd), (yyvsp[0].nd));
6774 }
6775 #line 6776 "mrbgems/mruby-compiler/core/y.tab.c"
6776 break;
6777
6778 case 200:
6779 #line 2122 "mrbgems/mruby-compiler/core/parse.y"
6780 {
6781 (yyval.nd) = new_dot3(p, (yyvsp[-2].nd), (yyvsp[0].nd));
6782 }
6783 #line 6784 "mrbgems/mruby-compiler/core/y.tab.c"
6784 break;
6785
6786 case 201:
6787 #line 2126 "mrbgems/mruby-compiler/core/parse.y"
6788 {
6789 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "+", (yyvsp[0].nd));
6790 }
6791 #line 6792 "mrbgems/mruby-compiler/core/y.tab.c"
6792 break;
6793
6794 case 202:
6795 #line 2130 "mrbgems/mruby-compiler/core/parse.y"
6796 {
6797 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "-", (yyvsp[0].nd));
6798 }
6799 #line 6800 "mrbgems/mruby-compiler/core/y.tab.c"
6800 break;
6801
6802 case 203:
6803 #line 2134 "mrbgems/mruby-compiler/core/parse.y"
6804 {
6805 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "*", (yyvsp[0].nd));
6806 }
6807 #line 6808 "mrbgems/mruby-compiler/core/y.tab.c"
6808 break;
6809
6810 case 204:
6811 #line 2138 "mrbgems/mruby-compiler/core/parse.y"
6812 {
6813 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "/", (yyvsp[0].nd));
6814 }
6815 #line 6816 "mrbgems/mruby-compiler/core/y.tab.c"
6816 break;
6817
6818 case 205:
6819 #line 2142 "mrbgems/mruby-compiler/core/parse.y"
6820 {
6821 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "%", (yyvsp[0].nd));
6822 }
6823 #line 6824 "mrbgems/mruby-compiler/core/y.tab.c"
6824 break;
6825
6826 case 206:
6827 #line 2146 "mrbgems/mruby-compiler/core/parse.y"
6828 {
6829 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd));
6830 }
6831 #line 6832 "mrbgems/mruby-compiler/core/y.tab.c"
6832 break;
6833
6834 case 207:
6835 #line 2150 "mrbgems/mruby-compiler/core/parse.y"
6836 {
6837 (yyval.nd) = call_uni_op(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)), "-@");
6838 }
6839 #line 6840 "mrbgems/mruby-compiler/core/y.tab.c"
6840 break;
6841
6842 case 208:
6843 #line 2154 "mrbgems/mruby-compiler/core/parse.y"
6844 {
6845 (yyval.nd) = call_uni_op(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)), "-@");
6846 }
6847 #line 6848 "mrbgems/mruby-compiler/core/y.tab.c"
6848 break;
6849
6850 case 209:
6851 #line 2158 "mrbgems/mruby-compiler/core/parse.y"
6852 {
6853 (yyval.nd) = call_uni_op(p, (yyvsp[0].nd), "+@");
6854 }
6855 #line 6856 "mrbgems/mruby-compiler/core/y.tab.c"
6856 break;
6857
6858 case 210:
6859 #line 2162 "mrbgems/mruby-compiler/core/parse.y"
6860 {
6861 (yyval.nd) = call_uni_op(p, (yyvsp[0].nd), "-@");
6862 }
6863 #line 6864 "mrbgems/mruby-compiler/core/y.tab.c"
6864 break;
6865
6866 case 211:
6867 #line 2166 "mrbgems/mruby-compiler/core/parse.y"
6868 {
6869 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "|", (yyvsp[0].nd));
6870 }
6871 #line 6872 "mrbgems/mruby-compiler/core/y.tab.c"
6872 break;
6873
6874 case 212:
6875 #line 2170 "mrbgems/mruby-compiler/core/parse.y"
6876 {
6877 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "^", (yyvsp[0].nd));
6878 }
6879 #line 6880 "mrbgems/mruby-compiler/core/y.tab.c"
6880 break;
6881
6882 case 213:
6883 #line 2174 "mrbgems/mruby-compiler/core/parse.y"
6884 {
6885 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "&", (yyvsp[0].nd));
6886 }
6887 #line 6888 "mrbgems/mruby-compiler/core/y.tab.c"
6888 break;
6889
6890 case 214:
6891 #line 2178 "mrbgems/mruby-compiler/core/parse.y"
6892 {
6893 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=>", (yyvsp[0].nd));
6894 }
6895 #line 6896 "mrbgems/mruby-compiler/core/y.tab.c"
6896 break;
6897
6898 case 215:
6899 #line 2182 "mrbgems/mruby-compiler/core/parse.y"
6900 {
6901 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">", (yyvsp[0].nd));
6902 }
6903 #line 6904 "mrbgems/mruby-compiler/core/y.tab.c"
6904 break;
6905
6906 case 216:
6907 #line 2186 "mrbgems/mruby-compiler/core/parse.y"
6908 {
6909 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">=", (yyvsp[0].nd));
6910 }
6911 #line 6912 "mrbgems/mruby-compiler/core/y.tab.c"
6912 break;
6913
6914 case 217:
6915 #line 2190 "mrbgems/mruby-compiler/core/parse.y"
6916 {
6917 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<", (yyvsp[0].nd));
6918 }
6919 #line 6920 "mrbgems/mruby-compiler/core/y.tab.c"
6920 break;
6921
6922 case 218:
6923 #line 2194 "mrbgems/mruby-compiler/core/parse.y"
6924 {
6925 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=", (yyvsp[0].nd));
6926 }
6927 #line 6928 "mrbgems/mruby-compiler/core/y.tab.c"
6928 break;
6929
6930 case 219:
6931 #line 2198 "mrbgems/mruby-compiler/core/parse.y"
6932 {
6933 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "==", (yyvsp[0].nd));
6934 }
6935 #line 6936 "mrbgems/mruby-compiler/core/y.tab.c"
6936 break;
6937
6938 case 220:
6939 #line 2202 "mrbgems/mruby-compiler/core/parse.y"
6940 {
6941 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "===", (yyvsp[0].nd));
6942 }
6943 #line 6944 "mrbgems/mruby-compiler/core/y.tab.c"
6944 break;
6945
6946 case 221:
6947 #line 2206 "mrbgems/mruby-compiler/core/parse.y"
6948 {
6949 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!=", (yyvsp[0].nd));
6950 }
6951 #line 6952 "mrbgems/mruby-compiler/core/y.tab.c"
6952 break;
6953
6954 case 222:
6955 #line 2210 "mrbgems/mruby-compiler/core/parse.y"
6956 {
6957 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "=~", (yyvsp[0].nd));
6958 }
6959 #line 6960 "mrbgems/mruby-compiler/core/y.tab.c"
6960 break;
6961
6962 case 223:
6963 #line 2214 "mrbgems/mruby-compiler/core/parse.y"
6964 {
6965 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!~", (yyvsp[0].nd));
6966 }
6967 #line 6968 "mrbgems/mruby-compiler/core/y.tab.c"
6968 break;
6969
6970 case 224:
6971 #line 2218 "mrbgems/mruby-compiler/core/parse.y"
6972 {
6973 (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
6974 }
6975 #line 6976 "mrbgems/mruby-compiler/core/y.tab.c"
6976 break;
6977
6978 case 225:
6979 #line 2222 "mrbgems/mruby-compiler/core/parse.y"
6980 {
6981 (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "~");
6982 }
6983 #line 6984 "mrbgems/mruby-compiler/core/y.tab.c"
6984 break;
6985
6986 case 226:
6987 #line 2226 "mrbgems/mruby-compiler/core/parse.y"
6988 {
6989 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<<", (yyvsp[0].nd));
6990 }
6991 #line 6992 "mrbgems/mruby-compiler/core/y.tab.c"
6992 break;
6993
6994 case 227:
6995 #line 2230 "mrbgems/mruby-compiler/core/parse.y"
6996 {
6997 (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">>", (yyvsp[0].nd));
6998 }
6999 #line 7000 "mrbgems/mruby-compiler/core/y.tab.c"
7000 break;
7001
7002 case 228:
7003 #line 2234 "mrbgems/mruby-compiler/core/parse.y"
7004 {
7005 (yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd));
7006 }
7007 #line 7008 "mrbgems/mruby-compiler/core/y.tab.c"
7008 break;
7009
7010 case 229:
7011 #line 2238 "mrbgems/mruby-compiler/core/parse.y"
7012 {
7013 (yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd));
7014 }
7015 #line 7016 "mrbgems/mruby-compiler/core/y.tab.c"
7016 break;
7017
7018 case 230:
7019 #line 2242 "mrbgems/mruby-compiler/core/parse.y"
7020 {
7021 (yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd));
7022 }
7023 #line 7024 "mrbgems/mruby-compiler/core/y.tab.c"
7024 break;
7025
7026 case 231:
7027 #line 2246 "mrbgems/mruby-compiler/core/parse.y"
7028 {
7029 (yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd));
7030 }
7031 #line 7032 "mrbgems/mruby-compiler/core/y.tab.c"
7032 break;
7033
7034 case 232:
7035 #line 2250 "mrbgems/mruby-compiler/core/parse.y"
7036 {
7037 (yyval.nd) = (yyvsp[0].nd);
7038 }
7039 #line 7040 "mrbgems/mruby-compiler/core/y.tab.c"
7040 break;
7041
7042 case 234:
7043 #line 2257 "mrbgems/mruby-compiler/core/parse.y"
7044 {
7045 (yyval.nd) = (yyvsp[-1].nd);
7046 NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
7047 }
7048 #line 7049 "mrbgems/mruby-compiler/core/y.tab.c"
7049 break;
7050
7051 case 235:
7052 #line 2262 "mrbgems/mruby-compiler/core/parse.y"
7053 {
7054 (yyval.nd) = push((yyvsp[-3].nd), new_kw_hash(p, (yyvsp[-1].nd)));
7055 }
7056 #line 7057 "mrbgems/mruby-compiler/core/y.tab.c"
7057 break;
7058
7059 case 236:
7060 #line 2266 "mrbgems/mruby-compiler/core/parse.y"
7061 {
7062 (yyval.nd) = cons(new_kw_hash(p, (yyvsp[-1].nd)), 0);
7063 NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
7064 }
7065 #line 7066 "mrbgems/mruby-compiler/core/y.tab.c"
7066 break;
7067
7068 case 237:
7069 #line 2273 "mrbgems/mruby-compiler/core/parse.y"
7070 {
7071 (yyval.nd) = (yyvsp[0].nd);
7072 }
7073 #line 7074 "mrbgems/mruby-compiler/core/y.tab.c"
7074 break;
7075
7076 case 238:
7077 #line 2277 "mrbgems/mruby-compiler/core/parse.y"
7078 {
7079 void_expr_error(p, (yyvsp[-2].nd));
7080 void_expr_error(p, (yyvsp[0].nd));
7081 (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
7082 }
7083 #line 7084 "mrbgems/mruby-compiler/core/y.tab.c"
7084 break;
7085
7086 case 239:
7087 #line 2285 "mrbgems/mruby-compiler/core/parse.y"
7088 {
7089 (yyval.nd) = (yyvsp[-1].nd);
7090 }
7091 #line 7092 "mrbgems/mruby-compiler/core/y.tab.c"
7092 break;
7093
7094 case 240:
7095 #line 2289 "mrbgems/mruby-compiler/core/parse.y"
7096 {
7097 #if 1
7098 mrb_sym r = mrb_intern_lit(p->mrb, "*");
7099 mrb_sym b = mrb_intern_lit(p->mrb, "&");
7100 if (local_var_p(p, r) && local_var_p(p, b)) {
7101 (yyval.nd) = cons(list1(new_splat(p, new_lvar(p, r))),
7102 new_block_arg(p, new_lvar(p, b)));
7103 }
7104 #else
7105 mrb_sym r = mrb_intern_lit(p->mrb, "*");
7106 mrb_sym k = mrb_intern_lit(p->mrb, "**");
7107 mrb_sym b = mrb_intern_lit(p->mrb, "&");
7108 if (local_var_p(p, r) && local_var_p(p, k) && local_var_p(p, b)) {
7109 (yyval.nd) = cons(list2(new_splat(p, new_lvar(p, r)),
7110 new_kw_hash(p, list1(cons(new_kw_rest_args(p, 0), new_lvar(p, k))))),
7111 new_block_arg(p, new_lvar(p, b)));
7112 }
7113 #endif
7114 else {
7115 yyerror(p, "unexpected argument forwarding ...");
7116 (yyval.nd) = 0;
7117 }
7118 }
7119 #line 7120 "mrbgems/mruby-compiler/core/y.tab.c"
7120 break;
7121
7122 case 245:
7123 #line 2321 "mrbgems/mruby-compiler/core/parse.y"
7124 {
7125 (yyval.nd) = cons((yyvsp[-1].nd),0);
7126 NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
7127 }
7128 #line 7129 "mrbgems/mruby-compiler/core/y.tab.c"
7129 break;
7130
7131 case 246:
7132 #line 2326 "mrbgems/mruby-compiler/core/parse.y"
7133 {
7134 (yyval.nd) = cons(push((yyvsp[-3].nd), new_kw_hash(p, (yyvsp[-1].nd))), 0);
7135 NODE_LINENO((yyval.nd), (yyvsp[-3].nd));
7136 }
7137 #line 7138 "mrbgems/mruby-compiler/core/y.tab.c"
7138 break;
7139
7140 case 247:
7141 #line 2331 "mrbgems/mruby-compiler/core/parse.y"
7142 {
7143 (yyval.nd) = cons(list1(new_kw_hash(p, (yyvsp[-1].nd))), 0);
7144 NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
7145 }
7146 #line 7147 "mrbgems/mruby-compiler/core/y.tab.c"
7147 break;
7148
7149 case 248:
7150 #line 2338 "mrbgems/mruby-compiler/core/parse.y"
7151 {
7152 void_expr_error(p, (yyvsp[0].nd));
7153 (yyval.nd) = cons(list1((yyvsp[0].nd)), 0);
7154 NODE_LINENO((yyval.nd), (yyvsp[0].nd));
7155 }
7156 #line 7157 "mrbgems/mruby-compiler/core/y.tab.c"
7157 break;
7158
7159 case 249:
7160 #line 2344 "mrbgems/mruby-compiler/core/parse.y"
7161 {
7162 (yyval.nd) = cons((yyvsp[-1].nd), (yyvsp[0].nd));
7163 NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
7164 }
7165 #line 7166 "mrbgems/mruby-compiler/core/y.tab.c"
7166 break;
7167
7168 case 250:
7169 #line 2349 "mrbgems/mruby-compiler/core/parse.y"
7170 {
7171 (yyval.nd) = cons(list1(new_kw_hash(p, (yyvsp[-1].nd))), (yyvsp[0].nd));
7172 NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
7173 }
7174 #line 7175 "mrbgems/mruby-compiler/core/y.tab.c"
7175 break;
7176
7177 case 251:
7178 #line 2354 "mrbgems/mruby-compiler/core/parse.y"
7179 {
7180 (yyval.nd) = cons(push((yyvsp[-3].nd), new_kw_hash(p, (yyvsp[-1].nd))), (yyvsp[0].nd));
7181 NODE_LINENO((yyval.nd), (yyvsp[-3].nd));
7182 }
7183 #line 7184 "mrbgems/mruby-compiler/core/y.tab.c"
7184 break;
7185
7186 case 252:
7187 #line 2359 "mrbgems/mruby-compiler/core/parse.y"
7188 {
7189 (yyval.nd) = cons(0, (yyvsp[0].nd));
7190 NODE_LINENO((yyval.nd), (yyvsp[0].nd));
7191 }
7192 #line 7193 "mrbgems/mruby-compiler/core/y.tab.c"
7193 break;
7194
7195 case 253:
7196 #line 2365 "mrbgems/mruby-compiler/core/parse.y"
7197 {
7198 (yyval.stack) = p->cmdarg_stack;
7199 CMDARG_PUSH(1);
7200 }
7201 #line 7202 "mrbgems/mruby-compiler/core/y.tab.c"
7202 break;
7203
7204 case 254:
7205 #line 2370 "mrbgems/mruby-compiler/core/parse.y"
7206 {
7207 p->cmdarg_stack = (yyvsp[-1].stack);
7208 (yyval.nd) = (yyvsp[0].nd);
7209 }
7210 #line 7211 "mrbgems/mruby-compiler/core/y.tab.c"
7211 break;
7212
7213 case 255:
7214 #line 2377 "mrbgems/mruby-compiler/core/parse.y"
7215 {
7216 (yyval.nd) = new_block_arg(p, (yyvsp[0].nd));
7217 }
7218 #line 7219 "mrbgems/mruby-compiler/core/y.tab.c"
7219 break;
7220
7221 case 256:
7222 #line 2383 "mrbgems/mruby-compiler/core/parse.y"
7223 {
7224 (yyval.nd) = (yyvsp[0].nd);
7225 }
7226 #line 7227 "mrbgems/mruby-compiler/core/y.tab.c"
7227 break;
7228
7229 case 257:
7230 #line 2387 "mrbgems/mruby-compiler/core/parse.y"
7231 {
7232 (yyval.nd) = 0;
7233 }
7234 #line 7235 "mrbgems/mruby-compiler/core/y.tab.c"
7235 break;
7236
7237 case 260:
7238 #line 2397 "mrbgems/mruby-compiler/core/parse.y"
7239 {
7240 void_expr_error(p, (yyvsp[0].nd));
7241 (yyval.nd) = cons((yyvsp[0].nd), 0);
7242 NODE_LINENO((yyval.nd), (yyvsp[0].nd));
7243 }
7244 #line 7245 "mrbgems/mruby-compiler/core/y.tab.c"
7245 break;
7246
7247 case 261:
7248 #line 2403 "mrbgems/mruby-compiler/core/parse.y"
7249 {
7250 void_expr_error(p, (yyvsp[0].nd));
7251 (yyval.nd) = cons(new_splat(p, (yyvsp[0].nd)), 0);
7252 NODE_LINENO((yyval.nd), (yyvsp[0].nd));
7253 }
7254 #line 7255 "mrbgems/mruby-compiler/core/y.tab.c"
7255 break;
7256
7257 case 262:
7258 #line 2409 "mrbgems/mruby-compiler/core/parse.y"
7259 {
7260 void_expr_error(p, (yyvsp[0].nd));
7261 (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
7262 }
7263 #line 7264 "mrbgems/mruby-compiler/core/y.tab.c"
7264 break;
7265
7266 case 263:
7267 #line 2414 "mrbgems/mruby-compiler/core/parse.y"
7268 {
7269 void_expr_error(p, (yyvsp[0].nd));
7270 (yyval.nd) = push((yyvsp[-3].nd), new_splat(p, (yyvsp[0].nd)));
7271 }
7272 #line 7273 "mrbgems/mruby-compiler/core/y.tab.c"
7273 break;
7274
7275 case 264:
7276 #line 2421 "mrbgems/mruby-compiler/core/parse.y"
7277 {
7278 void_expr_error(p, (yyvsp[0].nd));
7279 (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
7280 }
7281 #line 7282 "mrbgems/mruby-compiler/core/y.tab.c"
7282 break;
7283
7284 case 265:
7285 #line 2426 "mrbgems/mruby-compiler/core/parse.y"
7286 {
7287 void_expr_error(p, (yyvsp[0].nd));
7288 (yyval.nd) = push((yyvsp[-3].nd), new_splat(p, (yyvsp[0].nd)));
7289 }
7290 #line 7291 "mrbgems/mruby-compiler/core/y.tab.c"
7291 break;
7292
7293 case 266:
7294 #line 2431 "mrbgems/mruby-compiler/core/parse.y"
7295 {
7296 void_expr_error(p, (yyvsp[0].nd));
7297 (yyval.nd) = list1(new_splat(p, (yyvsp[0].nd)));
7298 }
7299 #line 7300 "mrbgems/mruby-compiler/core/y.tab.c"
7300 break;
7301
7302 case 274:
7303 #line 2445 "mrbgems/mruby-compiler/core/parse.y"
7304 {
7305 (yyval.nd) = new_nvar(p, (yyvsp[0].num));
7306 }
7307 #line 7308 "mrbgems/mruby-compiler/core/y.tab.c"
7308 break;
7309
7310 case 275:
7311 #line 2449 "mrbgems/mruby-compiler/core/parse.y"
7312 {
7313 (yyval.nd) = new_fcall(p, (yyvsp[0].id), 0);
7314 }
7315 #line 7316 "mrbgems/mruby-compiler/core/y.tab.c"
7316 break;
7317
7318 case 276:
7319 #line 2453 "mrbgems/mruby-compiler/core/parse.y"
7320 {
7321 (yyval.stack) = p->cmdarg_stack;
7322 p->cmdarg_stack = 0;
7323 }
7324 #line 7325 "mrbgems/mruby-compiler/core/y.tab.c"
7325 break;
7326
7327 case 277:
7328 #line 2459 "mrbgems/mruby-compiler/core/parse.y"
7329 {
7330 p->cmdarg_stack = (yyvsp[-2].stack);
7331 (yyval.nd) = (yyvsp[-1].nd);
7332 }
7333 #line 7334 "mrbgems/mruby-compiler/core/y.tab.c"
7334 break;
7335
7336 case 278:
7337 #line 2464 "mrbgems/mruby-compiler/core/parse.y"
7338 {
7339 (yyval.stack) = p->cmdarg_stack;
7340 p->cmdarg_stack = 0;
7341 }
7342 #line 7343 "mrbgems/mruby-compiler/core/y.tab.c"
7343 break;
7344
7345 case 279:
7346 #line 2468 "mrbgems/mruby-compiler/core/parse.y"
7347 {p->lstate = EXPR_ENDARG;}
7348 #line 7349 "mrbgems/mruby-compiler/core/y.tab.c"
7349 break;
7350
7351 case 280:
7352 #line 2469 "mrbgems/mruby-compiler/core/parse.y"
7353 {
7354 p->cmdarg_stack = (yyvsp[-3].stack);
7355 (yyval.nd) = (yyvsp[-2].nd);
7356 }
7357 #line 7358 "mrbgems/mruby-compiler/core/y.tab.c"
7358 break;
7359
7360 case 281:
7361 #line 2473 "mrbgems/mruby-compiler/core/parse.y"
7362 {p->lstate = EXPR_ENDARG;}
7363 #line 7364 "mrbgems/mruby-compiler/core/y.tab.c"
7364 break;
7365
7366 case 282:
7367 #line 2474 "mrbgems/mruby-compiler/core/parse.y"
7368 {
7369 (yyval.nd) = new_nil(p);
7370 }
7371 #line 7372 "mrbgems/mruby-compiler/core/y.tab.c"
7372 break;
7373
7374 case 283:
7375 #line 2478 "mrbgems/mruby-compiler/core/parse.y"
7376 {
7377 (yyval.nd) = (yyvsp[-1].nd);
7378 }
7379 #line 7380 "mrbgems/mruby-compiler/core/y.tab.c"
7380 break;
7381
7382 case 284:
7383 #line 2482 "mrbgems/mruby-compiler/core/parse.y"
7384 {
7385 (yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id));
7386 }
7387 #line 7388 "mrbgems/mruby-compiler/core/y.tab.c"
7388 break;
7389
7390 case 285:
7391 #line 2486 "mrbgems/mruby-compiler/core/parse.y"
7392 {
7393 (yyval.nd) = new_colon3(p, (yyvsp[0].id));
7394 }
7395 #line 7396 "mrbgems/mruby-compiler/core/y.tab.c"
7396 break;
7397
7398 case 286:
7399 #line 2490 "mrbgems/mruby-compiler/core/parse.y"
7400 {
7401 (yyval.nd) = new_array(p, (yyvsp[-1].nd));
7402 NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
7403 }
7404 #line 7405 "mrbgems/mruby-compiler/core/y.tab.c"
7405 break;
7406
7407 case 287:
7408 #line 2495 "mrbgems/mruby-compiler/core/parse.y"
7409 {
7410 (yyval.nd) = new_hash(p, (yyvsp[-1].nd));
7411 NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
7412 }
7413 #line 7414 "mrbgems/mruby-compiler/core/y.tab.c"
7414 break;
7415
7416 case 288:
7417 #line 2500 "mrbgems/mruby-compiler/core/parse.y"
7418 {
7419 (yyval.nd) = new_return(p, 0);
7420 }
7421 #line 7422 "mrbgems/mruby-compiler/core/y.tab.c"
7422 break;
7423
7424 case 289:
7425 #line 2504 "mrbgems/mruby-compiler/core/parse.y"
7426 {
7427 (yyval.nd) = new_yield(p, (yyvsp[0].nd));
7428 }
7429 #line 7430 "mrbgems/mruby-compiler/core/y.tab.c"
7430 break;
7431
7432 case 290:
7433 #line 2508 "mrbgems/mruby-compiler/core/parse.y"
7434 {
7435 (yyval.nd) = call_uni_op(p, cond((yyvsp[-1].nd)), "!");
7436 }
7437 #line 7438 "mrbgems/mruby-compiler/core/y.tab.c"
7438 break;
7439
7440 case 291:
7441 #line 2512 "mrbgems/mruby-compiler/core/parse.y"
7442 {
7443 (yyval.nd) = call_uni_op(p, new_nil(p), "!");
7444 }
7445 #line 7446 "mrbgems/mruby-compiler/core/y.tab.c"
7446 break;
7447
7448 case 292:
7449 #line 2516 "mrbgems/mruby-compiler/core/parse.y"
7450 {
7451 (yyval.nd) = new_fcall(p, (yyvsp[-1].id), cons(0, (yyvsp[0].nd)));
7452 }
7453 #line 7454 "mrbgems/mruby-compiler/core/y.tab.c"
7454 break;
7455
7456 case 294:
7457 #line 2521 "mrbgems/mruby-compiler/core/parse.y"
7458 {
7459 call_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
7460 (yyval.nd) = (yyvsp[-1].nd);
7461 }
7462 #line 7463 "mrbgems/mruby-compiler/core/y.tab.c"
7463 break;
7464
7465 case 295:
7466 #line 2526 "mrbgems/mruby-compiler/core/parse.y"
7467 {
7468 local_nest(p);
7469 (yyval.num) = p->lpar_beg;
7470 p->lpar_beg = ++p->paren_nest;
7471 }
7472 #line 7473 "mrbgems/mruby-compiler/core/y.tab.c"
7473 break;
7474
7475 case 296:
7476 #line 2532 "mrbgems/mruby-compiler/core/parse.y"
7477 {
7478 (yyval.stack) = p->cmdarg_stack;
7479 p->cmdarg_stack = 0;
7480 }
7481 #line 7482 "mrbgems/mruby-compiler/core/y.tab.c"
7482 break;
7483
7484 case 297:
7485 #line 2537 "mrbgems/mruby-compiler/core/parse.y"
7486 {
7487 p->lpar_beg = (yyvsp[-3].num);
7488 (yyval.nd) = new_lambda(p, (yyvsp[-2].nd), (yyvsp[0].nd));
7489 local_unnest(p);
7490 p->cmdarg_stack = (yyvsp[-1].stack);
7491 CMDARG_LEXPOP();
7492 }
7493 #line 7494 "mrbgems/mruby-compiler/core/y.tab.c"
7494 break;
7495
7496 case 298:
7497 #line 2548 "mrbgems/mruby-compiler/core/parse.y"
7498 {
7499 (yyval.nd) = new_if(p, cond((yyvsp[-4].nd)), (yyvsp[-2].nd), (yyvsp[-1].nd));
7500 SET_LINENO((yyval.nd), (yyvsp[-5].num));
7501 }
7502 #line 7503 "mrbgems/mruby-compiler/core/y.tab.c"
7503 break;
7504
7505 case 299:
7506 #line 2556 "mrbgems/mruby-compiler/core/parse.y"
7507 {
7508 (yyval.nd) = new_unless(p, cond((yyvsp[-4].nd)), (yyvsp[-2].nd), (yyvsp[-1].nd));
7509 SET_LINENO((yyval.nd), (yyvsp[-5].num));
7510 }
7511 #line 7512 "mrbgems/mruby-compiler/core/y.tab.c"
7512 break;
7513
7514 case 300:
7515 #line 2560 "mrbgems/mruby-compiler/core/parse.y"
7516 {COND_PUSH(1);}
7517 #line 7518 "mrbgems/mruby-compiler/core/y.tab.c"
7518 break;
7519
7520 case 301:
7521 #line 2560 "mrbgems/mruby-compiler/core/parse.y"
7522 {COND_POP();}
7523 #line 7524 "mrbgems/mruby-compiler/core/y.tab.c"
7524 break;
7525
7526 case 302:
7527 #line 2563 "mrbgems/mruby-compiler/core/parse.y"
7528 {
7529 (yyval.nd) = new_while(p, cond((yyvsp[-4].nd)), (yyvsp[-1].nd));
7530 SET_LINENO((yyval.nd), (yyvsp[-6].num));
7531 }
7532 #line 7533 "mrbgems/mruby-compiler/core/y.tab.c"
7533 break;
7534
7535 case 303:
7536 #line 2567 "mrbgems/mruby-compiler/core/parse.y"
7537 {COND_PUSH(1);}
7538 #line 7539 "mrbgems/mruby-compiler/core/y.tab.c"
7539 break;
7540
7541 case 304:
7542 #line 2567 "mrbgems/mruby-compiler/core/parse.y"
7543 {COND_POP();}
7544 #line 7545 "mrbgems/mruby-compiler/core/y.tab.c"
7545 break;
7546
7547 case 305:
7548 #line 2570 "mrbgems/mruby-compiler/core/parse.y"
7549 {
7550 (yyval.nd) = new_until(p, cond((yyvsp[-4].nd)), (yyvsp[-1].nd));
7551 SET_LINENO((yyval.nd), (yyvsp[-6].num));
7552 }
7553 #line 7554 "mrbgems/mruby-compiler/core/y.tab.c"
7554 break;
7555
7556 case 306:
7557 #line 2577 "mrbgems/mruby-compiler/core/parse.y"
7558 {
7559 (yyval.nd) = new_case(p, (yyvsp[-3].nd), (yyvsp[-1].nd));
7560 }
7561 #line 7562 "mrbgems/mruby-compiler/core/y.tab.c"
7562 break;
7563
7564 case 307:
7565 #line 2581 "mrbgems/mruby-compiler/core/parse.y"
7566 {
7567 (yyval.nd) = new_case(p, 0, (yyvsp[-1].nd));
7568 }
7569 #line 7570 "mrbgems/mruby-compiler/core/y.tab.c"
7570 break;
7571
7572 case 308:
7573 #line 2585 "mrbgems/mruby-compiler/core/parse.y"
7574 {COND_PUSH(1);}
7575 #line 7576 "mrbgems/mruby-compiler/core/y.tab.c"
7576 break;
7577
7578 case 309:
7579 #line 2587 "mrbgems/mruby-compiler/core/parse.y"
7580 {COND_POP();}
7581 #line 7582 "mrbgems/mruby-compiler/core/y.tab.c"
7582 break;
7583
7584 case 310:
7585 #line 2590 "mrbgems/mruby-compiler/core/parse.y"
7586 {
7587 (yyval.nd) = new_for(p, (yyvsp[-7].nd), (yyvsp[-4].nd), (yyvsp[-1].nd));
7588 SET_LINENO((yyval.nd), (yyvsp[-8].num));
7589 }
7590 #line 7591 "mrbgems/mruby-compiler/core/y.tab.c"
7591 break;
7592
7593 case 311:
7594 #line 2596 "mrbgems/mruby-compiler/core/parse.y"
7595 {
7596 if (p->in_def || p->in_single)
7597 yyerror(p, "class definition in method body");
7598 (yyval.nd) = local_switch(p);
7599 nvars_block(p);
7600 }
7601 #line 7602 "mrbgems/mruby-compiler/core/y.tab.c"
7602 break;
7603
7604 case 312:
7605 #line 2604 "mrbgems/mruby-compiler/core/parse.y"
7606 {
7607 (yyval.nd) = new_class(p, (yyvsp[-4].nd), (yyvsp[-3].nd), (yyvsp[-1].nd));
7608 SET_LINENO((yyval.nd), (yyvsp[-5].num));
7609 local_resume(p, (yyvsp[-2].nd));
7610 nvars_unnest(p);
7611 }
7612 #line 7613 "mrbgems/mruby-compiler/core/y.tab.c"
7613 break;
7614
7615 case 313:
7616 #line 2612 "mrbgems/mruby-compiler/core/parse.y"
7617 {
7618 (yyval.num) = p->in_def;
7619 p->in_def = 0;
7620 }
7621 #line 7622 "mrbgems/mruby-compiler/core/y.tab.c"
7622 break;
7623
7624 case 314:
7625 #line 2617 "mrbgems/mruby-compiler/core/parse.y"
7626 {
7627 (yyval.nd) = cons(local_switch(p), nint(p->in_single));
7628 nvars_block(p);
7629 p->in_single = 0;
7630 }
7631 #line 7632 "mrbgems/mruby-compiler/core/y.tab.c"
7632 break;
7633
7634 case 315:
7635 #line 2624 "mrbgems/mruby-compiler/core/parse.y"
7636 {
7637 (yyval.nd) = new_sclass(p, (yyvsp[-5].nd), (yyvsp[-1].nd));
7638 SET_LINENO((yyval.nd), (yyvsp[-7].num));
7639 local_resume(p, (yyvsp[-2].nd)->car);
7640 nvars_unnest(p);
7641 p->in_def = (yyvsp[-4].num);
7642 p->in_single = intn((yyvsp[-2].nd)->cdr);
7643 }
7644 #line 7645 "mrbgems/mruby-compiler/core/y.tab.c"
7645 break;
7646
7647 case 316:
7648 #line 2634 "mrbgems/mruby-compiler/core/parse.y"
7649 {
7650 if (p->in_def || p->in_single)
7651 yyerror(p, "module definition in method body");
7652 (yyval.nd) = local_switch(p);
7653 nvars_block(p);
7654 }
7655 #line 7656 "mrbgems/mruby-compiler/core/y.tab.c"
7656 break;
7657
7658 case 317:
7659 #line 2642 "mrbgems/mruby-compiler/core/parse.y"
7660 {
7661 (yyval.nd) = new_module(p, (yyvsp[-3].nd), (yyvsp[-1].nd));
7662 SET_LINENO((yyval.nd), (yyvsp[-4].num));
7663 local_resume(p, (yyvsp[-2].nd));
7664 nvars_unnest(p);
7665 }
7666 #line 7667 "mrbgems/mruby-compiler/core/y.tab.c"
7667 break;
7668
7669 case 318:
7670 #line 2649 "mrbgems/mruby-compiler/core/parse.y"
7671 {
7672 (yyval.stack) = p->cmdarg_stack;
7673 p->cmdarg_stack = 0;
7674 }
7675 #line 7676 "mrbgems/mruby-compiler/core/y.tab.c"
7676 break;
7677
7678 case 319:
7679 #line 2653 "mrbgems/mruby-compiler/core/parse.y"
7680 {
7681 p->in_def++;
7682 (yyval.nd) = local_switch(p);
7683 nvars_block(p);
7684 }
7685 #line 7686 "mrbgems/mruby-compiler/core/y.tab.c"
7686 break;
7687
7688 case 320:
7689 #line 2661 "mrbgems/mruby-compiler/core/parse.y"
7690 {
7691 (yyval.nd) = new_def(p, (yyvsp[-5].id), (yyvsp[-2].nd), (yyvsp[-1].nd));
7692 SET_LINENO((yyval.nd), (yyvsp[-6].num));
7693 local_resume(p, (yyvsp[-3].nd));
7694 nvars_unnest(p);
7695 p->in_def--;
7696 p->cmdarg_stack = (yyvsp[-4].stack);
7697 }
7698 #line 7699 "mrbgems/mruby-compiler/core/y.tab.c"
7699 break;
7700
7701 case 321:
7702 #line 2670 "mrbgems/mruby-compiler/core/parse.y"
7703 {
7704 p->lstate = EXPR_FNAME;
7705 (yyval.stack) = p->cmdarg_stack;
7706 p->cmdarg_stack = 0;
7707 }
7708 #line 7709 "mrbgems/mruby-compiler/core/y.tab.c"
7709 break;
7710
7711 case 322:
7712 #line 2676 "mrbgems/mruby-compiler/core/parse.y"
7713 {
7714 p->in_single++;
7715 p->lstate = EXPR_ENDFN; /* force for args */
7716 (yyval.nd) = local_switch(p);
7717 nvars_block(p);
7718 }
7719 #line 7720 "mrbgems/mruby-compiler/core/y.tab.c"
7720 break;
7721
7722 case 323:
7723 #line 2685 "mrbgems/mruby-compiler/core/parse.y"
7724 {
7725 (yyval.nd) = new_sdef(p, (yyvsp[-7].nd), (yyvsp[-4].id), (yyvsp[-2].nd), (yyvsp[-1].nd));
7726 SET_LINENO((yyval.nd), (yyvsp[-8].num));
7727 local_resume(p, (yyvsp[-3].nd));
7728 nvars_unnest(p);
7729 p->in_single--;
7730 p->cmdarg_stack = (yyvsp[-5].stack);
7731 }
7732 #line 7733 "mrbgems/mruby-compiler/core/y.tab.c"
7733 break;
7734
7735 case 324:
7736 #line 2694 "mrbgems/mruby-compiler/core/parse.y"
7737 {
7738 (yyval.nd) = new_break(p, 0);
7739 }
7740 #line 7741 "mrbgems/mruby-compiler/core/y.tab.c"
7741 break;
7742
7743 case 325:
7744 #line 2698 "mrbgems/mruby-compiler/core/parse.y"
7745 {
7746 (yyval.nd) = new_next(p, 0);
7747 }
7748 #line 7749 "mrbgems/mruby-compiler/core/y.tab.c"
7749 break;
7750
7751 case 326:
7752 #line 2702 "mrbgems/mruby-compiler/core/parse.y"
7753 {
7754 (yyval.nd) = new_redo(p);
7755 }
7756 #line 7757 "mrbgems/mruby-compiler/core/y.tab.c"
7757 break;
7758
7759 case 327:
7760 #line 2706 "mrbgems/mruby-compiler/core/parse.y"
7761 {
7762 (yyval.nd) = new_retry(p);
7763 }
7764 #line 7765 "mrbgems/mruby-compiler/core/y.tab.c"
7765 break;
7766
7767 case 328:
7768 #line 2712 "mrbgems/mruby-compiler/core/parse.y"
7769 {
7770 (yyval.nd) = (yyvsp[0].nd);
7771 if (!(yyval.nd)) (yyval.nd) = new_nil(p);
7772 }
7773 #line 7774 "mrbgems/mruby-compiler/core/y.tab.c"
7774 break;
7775
7776 case 335:
7777 #line 2731 "mrbgems/mruby-compiler/core/parse.y"
7778 {
7779 (yyval.nd) = new_if(p, cond((yyvsp[-3].nd)), (yyvsp[-1].nd), (yyvsp[0].nd));
7780 }
7781 #line 7782 "mrbgems/mruby-compiler/core/y.tab.c"
7782 break;
7783
7784 case 337:
7785 #line 2738 "mrbgems/mruby-compiler/core/parse.y"
7786 {
7787 (yyval.nd) = (yyvsp[0].nd);
7788 }
7789 #line 7790 "mrbgems/mruby-compiler/core/y.tab.c"
7790 break;
7791
7792 case 338:
7793 #line 2744 "mrbgems/mruby-compiler/core/parse.y"
7794 {
7795 (yyval.nd) = list1(list1((yyvsp[0].nd)));
7796 }
7797 #line 7798 "mrbgems/mruby-compiler/core/y.tab.c"
7798 break;
7799
7800 case 340:
7801 #line 2751 "mrbgems/mruby-compiler/core/parse.y"
7802 {
7803 (yyval.nd) = list3((yyvsp[0].nd),0,0);
7804 }
7805 #line 7806 "mrbgems/mruby-compiler/core/y.tab.c"
7806 break;
7807
7808 case 341:
7809 #line 2755 "mrbgems/mruby-compiler/core/parse.y"
7810 {
7811 (yyval.nd) = list3((yyvsp[-3].nd), new_arg(p, (yyvsp[0].id)), 0);
7812 }
7813 #line 7814 "mrbgems/mruby-compiler/core/y.tab.c"
7814 break;
7815
7816 case 342:
7817 #line 2759 "mrbgems/mruby-compiler/core/parse.y"
7818 {
7819 (yyval.nd) = list3((yyvsp[-5].nd), new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd));
7820 }
7821 #line 7822 "mrbgems/mruby-compiler/core/y.tab.c"
7822 break;
7823
7824 case 343:
7825 #line 2763 "mrbgems/mruby-compiler/core/parse.y"
7826 {
7827 local_add_f(p, 0);
7828 (yyval.nd) = list3((yyvsp[-2].nd), (node*)-1, 0);
7829 }
7830 #line 7831 "mrbgems/mruby-compiler/core/y.tab.c"
7831 break;
7832
7833 case 344:
7834 #line 2768 "mrbgems/mruby-compiler/core/parse.y"
7835 {
7836 (yyval.nd) = list3((yyvsp[-4].nd), (node*)-1, (yyvsp[0].nd));
7837 }
7838 #line 7839 "mrbgems/mruby-compiler/core/y.tab.c"
7839 break;
7840
7841 case 345:
7842 #line 2772 "mrbgems/mruby-compiler/core/parse.y"
7843 {
7844 (yyval.nd) = list3(0, new_arg(p, (yyvsp[0].id)), 0);
7845 }
7846 #line 7847 "mrbgems/mruby-compiler/core/y.tab.c"
7847 break;
7848
7849 case 346:
7850 #line 2776 "mrbgems/mruby-compiler/core/parse.y"
7851 {
7852 (yyval.nd) = list3(0, new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd));
7853 }
7854 #line 7855 "mrbgems/mruby-compiler/core/y.tab.c"
7855 break;
7856
7857 case 347:
7858 #line 2780 "mrbgems/mruby-compiler/core/parse.y"
7859 {
7860 local_add_f(p, 0);
7861 (yyval.nd) = list3(0, (node*)-1, 0);
7862 }
7863 #line 7864 "mrbgems/mruby-compiler/core/y.tab.c"
7864 break;
7865
7866 case 348:
7867 #line 2785 "mrbgems/mruby-compiler/core/parse.y"
7868 {
7869 local_add_f(p, 0);
7870 }
7871 #line 7872 "mrbgems/mruby-compiler/core/y.tab.c"
7872 break;
7873
7874 case 349:
7875 #line 2789 "mrbgems/mruby-compiler/core/parse.y"
7876 {
7877 (yyval.nd) = list3(0, (node*)-1, (yyvsp[0].nd));
7878 }
7879 #line 7880 "mrbgems/mruby-compiler/core/y.tab.c"
7880 break;
7881
7882 case 350:
7883 #line 2795 "mrbgems/mruby-compiler/core/parse.y"
7884 {
7885 (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id));
7886 }
7887 #line 7888 "mrbgems/mruby-compiler/core/y.tab.c"
7888 break;
7889
7890 case 351:
7891 #line 2799 "mrbgems/mruby-compiler/core/parse.y"
7892 {
7893 (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id));
7894 }
7895 #line 7896 "mrbgems/mruby-compiler/core/y.tab.c"
7896 break;
7897
7898 case 352:
7899 #line 2803 "mrbgems/mruby-compiler/core/parse.y"
7900 {
7901 (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id));
7902 }
7903 #line 7904 "mrbgems/mruby-compiler/core/y.tab.c"
7904 break;
7905
7906 case 353:
7907 #line 2807 "mrbgems/mruby-compiler/core/parse.y"
7908 {
7909 (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id));
7910 }
7911 #line 7912 "mrbgems/mruby-compiler/core/y.tab.c"
7912 break;
7913
7914 case 354:
7915 #line 2813 "mrbgems/mruby-compiler/core/parse.y"
7916 {
7917 (yyval.nd) = (yyvsp[0].nd);
7918 }
7919 #line 7920 "mrbgems/mruby-compiler/core/y.tab.c"
7920 break;
7921
7922 case 355:
7923 #line 2817 "mrbgems/mruby-compiler/core/parse.y"
7924 {
7925 (yyval.nd) = new_args_tail(p, 0, 0, 0);
7926 }
7927 #line 7928 "mrbgems/mruby-compiler/core/y.tab.c"
7928 break;
7929
7930 case 356:
7931 #line 2823 "mrbgems/mruby-compiler/core/parse.y"
7932 {
7933 (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
7934 }
7935 #line 7936 "mrbgems/mruby-compiler/core/y.tab.c"
7936 break;
7937
7938 case 357:
7939 #line 2827 "mrbgems/mruby-compiler/core/parse.y"
7940 {
7941 (yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
7942 }
7943 #line 7944 "mrbgems/mruby-compiler/core/y.tab.c"
7944 break;
7945
7946 case 358:
7947 #line 2831 "mrbgems/mruby-compiler/core/parse.y"
7948 {
7949 (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
7950 }
7951 #line 7952 "mrbgems/mruby-compiler/core/y.tab.c"
7952 break;
7953
7954 case 359:
7955 #line 2835 "mrbgems/mruby-compiler/core/parse.y"
7956 {
7957 (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
7958 }
7959 #line 7960 "mrbgems/mruby-compiler/core/y.tab.c"
7960 break;
7961
7962 case 360:
7963 #line 2839 "mrbgems/mruby-compiler/core/parse.y"
7964 {
7965 (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
7966 }
7967 #line 7968 "mrbgems/mruby-compiler/core/y.tab.c"
7968 break;
7969
7970 case 361:
7971 #line 2843 "mrbgems/mruby-compiler/core/parse.y"
7972 {
7973 (yyval.nd) = new_args(p, (yyvsp[-2].nd), 0, 0, 0, (yyvsp[0].nd));
7974 }
7975 #line 7976 "mrbgems/mruby-compiler/core/y.tab.c"
7976 break;
7977
7978 case 362:
7979 #line 2847 "mrbgems/mruby-compiler/core/parse.y"
7980 {
7981 (yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
7982 }
7983 #line 7984 "mrbgems/mruby-compiler/core/y.tab.c"
7984 break;
7985
7986 case 363:
7987 #line 2851 "mrbgems/mruby-compiler/core/parse.y"
7988 {
7989 (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd));
7990 }
7991 #line 7992 "mrbgems/mruby-compiler/core/y.tab.c"
7992 break;
7993
7994 case 364:
7995 #line 2855 "mrbgems/mruby-compiler/core/parse.y"
7996 {
7997 (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
7998 }
7999 #line 8000 "mrbgems/mruby-compiler/core/y.tab.c"
8000 break;
8001
8002 case 365:
8003 #line 2859 "mrbgems/mruby-compiler/core/parse.y"
8004 {
8005 (yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
8006 }
8007 #line 8008 "mrbgems/mruby-compiler/core/y.tab.c"
8008 break;
8009
8010 case 366:
8011 #line 2863 "mrbgems/mruby-compiler/core/parse.y"
8012 {
8013 (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
8014 }
8015 #line 8016 "mrbgems/mruby-compiler/core/y.tab.c"
8016 break;
8017
8018 case 367:
8019 #line 2867 "mrbgems/mruby-compiler/core/parse.y"
8020 {
8021 (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
8022 }
8023 #line 8024 "mrbgems/mruby-compiler/core/y.tab.c"
8024 break;
8025
8026 case 368:
8027 #line 2871 "mrbgems/mruby-compiler/core/parse.y"
8028 {
8029 (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
8030 }
8031 #line 8032 "mrbgems/mruby-compiler/core/y.tab.c"
8032 break;
8033
8034 case 369:
8035 #line 2875 "mrbgems/mruby-compiler/core/parse.y"
8036 {
8037 (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
8038 }
8039 #line 8040 "mrbgems/mruby-compiler/core/y.tab.c"
8040 break;
8041
8042 case 370:
8043 #line 2879 "mrbgems/mruby-compiler/core/parse.y"
8044 {
8045 (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd));
8046 }
8047 #line 8048 "mrbgems/mruby-compiler/core/y.tab.c"
8048 break;
8049
8050 case 371:
8051 #line 2885 "mrbgems/mruby-compiler/core/parse.y"
8052 {
8053 local_add_blk(p, 0);
8054 (yyval.nd) = 0;
8055 }
8056 #line 8057 "mrbgems/mruby-compiler/core/y.tab.c"
8057 break;
8058
8059 case 372:
8060 #line 2890 "mrbgems/mruby-compiler/core/parse.y"
8061 {
8062 p->cmd_start = TRUE;
8063 (yyval.nd) = (yyvsp[0].nd);
8064 }
8065 #line 8066 "mrbgems/mruby-compiler/core/y.tab.c"
8066 break;
8067
8068 case 373:
8069 #line 2896 "mrbgems/mruby-compiler/core/parse.y"
8070 {local_add_blk(p, 0);}
8071 #line 8072 "mrbgems/mruby-compiler/core/y.tab.c"
8072 break;
8073
8074 case 374:
8075 #line 2897 "mrbgems/mruby-compiler/core/parse.y"
8076 {
8077 (yyval.nd) = 0;
8078 }
8079 #line 8080 "mrbgems/mruby-compiler/core/y.tab.c"
8080 break;
8081
8082 case 375:
8083 #line 2901 "mrbgems/mruby-compiler/core/parse.y"
8084 {
8085 local_add_blk(p, 0);
8086 (yyval.nd) = 0;
8087 }
8088 #line 8089 "mrbgems/mruby-compiler/core/y.tab.c"
8089 break;
8090
8091 case 376:
8092 #line 2906 "mrbgems/mruby-compiler/core/parse.y"
8093 {
8094 (yyval.nd) = (yyvsp[-2].nd);
8095 }
8096 #line 8097 "mrbgems/mruby-compiler/core/y.tab.c"
8097 break;
8098
8099 case 377:
8100 #line 2913 "mrbgems/mruby-compiler/core/parse.y"
8101 {
8102 (yyval.nd) = 0;
8103 }
8104 #line 8105 "mrbgems/mruby-compiler/core/y.tab.c"
8105 break;
8106
8107 case 378:
8108 #line 2917 "mrbgems/mruby-compiler/core/parse.y"
8109 {
8110 (yyval.nd) = 0;
8111 }
8112 #line 8113 "mrbgems/mruby-compiler/core/y.tab.c"
8113 break;
8114
8115 case 381:
8116 #line 2927 "mrbgems/mruby-compiler/core/parse.y"
8117 {
8118 local_add_f(p, (yyvsp[0].id));
8119 new_bv(p, (yyvsp[0].id));
8120 }
8121 #line 8122 "mrbgems/mruby-compiler/core/y.tab.c"
8122 break;
8123
8124 case 383:
8125 #line 2935 "mrbgems/mruby-compiler/core/parse.y"
8126 {
8127 (yyval.nd) = (yyvsp[-2].nd);
8128 }
8129 #line 8130 "mrbgems/mruby-compiler/core/y.tab.c"
8130 break;
8131
8132 case 384:
8133 #line 2939 "mrbgems/mruby-compiler/core/parse.y"
8134 {
8135 (yyval.nd) = (yyvsp[0].nd);
8136 }
8137 #line 8138 "mrbgems/mruby-compiler/core/y.tab.c"
8138 break;
8139
8140 case 385:
8141 #line 2945 "mrbgems/mruby-compiler/core/parse.y"
8142 {
8143 (yyval.nd) = (yyvsp[-1].nd);
8144 }
8145 #line 8146 "mrbgems/mruby-compiler/core/y.tab.c"
8146 break;
8147
8148 case 386:
8149 #line 2949 "mrbgems/mruby-compiler/core/parse.y"
8150 {
8151 (yyval.nd) = (yyvsp[-1].nd);
8152 }
8153 #line 8154 "mrbgems/mruby-compiler/core/y.tab.c"
8154 break;
8155
8156 case 387:
8157 #line 2955 "mrbgems/mruby-compiler/core/parse.y"
8158 {
8159 local_nest(p);
8160 nvars_nest(p);
8161 }
8162 #line 8163 "mrbgems/mruby-compiler/core/y.tab.c"
8163 break;
8164
8165 case 388:
8166 #line 2962 "mrbgems/mruby-compiler/core/parse.y"
8167 {
8168 (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd));
8169 local_unnest(p);
8170 nvars_unnest(p);
8171 }
8172 #line 8173 "mrbgems/mruby-compiler/core/y.tab.c"
8173 break;
8174
8175 case 389:
8176 #line 2970 "mrbgems/mruby-compiler/core/parse.y"
8177 {
8178 if ((yyvsp[-1].nd)->car == (node*)NODE_YIELD) {
8179 yyerror(p, "block given to yield");
8180 }
8181 else {
8182 call_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
8183 }
8184 (yyval.nd) = (yyvsp[-1].nd);
8185 }
8186 #line 8187 "mrbgems/mruby-compiler/core/y.tab.c"
8187 break;
8188
8189 case 390:
8190 #line 2980 "mrbgems/mruby-compiler/core/parse.y"
8191 {
8192 (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
8193 }
8194 #line 8195 "mrbgems/mruby-compiler/core/y.tab.c"
8195 break;
8196
8197 case 391:
8198 #line 2984 "mrbgems/mruby-compiler/core/parse.y"
8199 {
8200 (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num));
8201 call_with_block(p, (yyval.nd), (yyvsp[0].nd));
8202 }
8203 #line 8204 "mrbgems/mruby-compiler/core/y.tab.c"
8204 break;
8205
8206 case 392:
8207 #line 2989 "mrbgems/mruby-compiler/core/parse.y"
8208 {
8209 (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num));
8210 call_with_block(p, (yyval.nd), (yyvsp[0].nd));
8211 }
8212 #line 8213 "mrbgems/mruby-compiler/core/y.tab.c"
8213 break;
8214
8215 case 393:
8216 #line 2996 "mrbgems/mruby-compiler/core/parse.y"
8217 {
8218 (yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd));
8219 }
8220 #line 8221 "mrbgems/mruby-compiler/core/y.tab.c"
8221 break;
8222
8223 case 394:
8224 #line 3000 "mrbgems/mruby-compiler/core/parse.y"
8225 {
8226 (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
8227 }
8228 #line 8229 "mrbgems/mruby-compiler/core/y.tab.c"
8229 break;
8230
8231 case 395:
8232 #line 3004 "mrbgems/mruby-compiler/core/parse.y"
8233 {
8234 (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2);
8235 }
8236 #line 8237 "mrbgems/mruby-compiler/core/y.tab.c"
8237 break;
8238
8239 case 396:
8240 #line 3008 "mrbgems/mruby-compiler/core/parse.y"
8241 {
8242 (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
8243 }
8244 #line 8245 "mrbgems/mruby-compiler/core/y.tab.c"
8245 break;
8246
8247 case 397:
8248 #line 3012 "mrbgems/mruby-compiler/core/parse.y"
8249 {
8250 (yyval.nd) = new_call(p, (yyvsp[-2].nd), intern_lit("call"), (yyvsp[0].nd), (yyvsp[-1].num));
8251 }
8252 #line 8253 "mrbgems/mruby-compiler/core/y.tab.c"
8253 break;
8254
8255 case 398:
8256 #line 3016 "mrbgems/mruby-compiler/core/parse.y"
8257 {
8258 (yyval.nd) = new_call(p, (yyvsp[-2].nd), intern_lit("call"), (yyvsp[0].nd), tCOLON2);
8259 }
8260 #line 8261 "mrbgems/mruby-compiler/core/y.tab.c"
8261 break;
8262
8263 case 399:
8264 #line 3020 "mrbgems/mruby-compiler/core/parse.y"
8265 {
8266 (yyval.nd) = new_super(p, (yyvsp[0].nd));
8267 }
8268 #line 8269 "mrbgems/mruby-compiler/core/y.tab.c"
8269 break;
8270
8271 case 400:
8272 #line 3024 "mrbgems/mruby-compiler/core/parse.y"
8273 {
8274 (yyval.nd) = new_zsuper(p);
8275 }
8276 #line 8277 "mrbgems/mruby-compiler/core/y.tab.c"
8277 break;
8278
8279 case 401:
8280 #line 3028 "mrbgems/mruby-compiler/core/parse.y"
8281 {
8282 (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_lit("[]"), (yyvsp[-1].nd), '.');
8283 }
8284 #line 8285 "mrbgems/mruby-compiler/core/y.tab.c"
8285 break;
8286
8287 case 402:
8288 #line 3034 "mrbgems/mruby-compiler/core/parse.y"
8289 {
8290 local_nest(p);
8291 nvars_nest(p);
8292 (yyval.num) = p->lineno;
8293 }
8294 #line 8295 "mrbgems/mruby-compiler/core/y.tab.c"
8295 break;
8296
8297 case 403:
8298 #line 3041 "mrbgems/mruby-compiler/core/parse.y"
8299 {
8300 (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd));
8301 SET_LINENO((yyval.nd), (yyvsp[-3].num));
8302 local_unnest(p);
8303 nvars_unnest(p);
8304 }
8305 #line 8306 "mrbgems/mruby-compiler/core/y.tab.c"
8306 break;
8307
8308 case 404:
8309 #line 3048 "mrbgems/mruby-compiler/core/parse.y"
8310 {
8311 local_nest(p);
8312 nvars_nest(p);
8313 (yyval.num) = p->lineno;
8314 }
8315 #line 8316 "mrbgems/mruby-compiler/core/y.tab.c"
8316 break;
8317
8318 case 405:
8319 #line 3055 "mrbgems/mruby-compiler/core/parse.y"
8320 {
8321 (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd));
8322 SET_LINENO((yyval.nd), (yyvsp[-3].num));
8323 local_unnest(p);
8324 nvars_unnest(p);
8325 }
8326 #line 8327 "mrbgems/mruby-compiler/core/y.tab.c"
8327 break;
8328
8329 case 406:
8330 #line 3066 "mrbgems/mruby-compiler/core/parse.y"
8331 {
8332 (yyval.nd) = cons(cons((yyvsp[-3].nd), (yyvsp[-1].nd)), (yyvsp[0].nd));
8333 }
8334 #line 8335 "mrbgems/mruby-compiler/core/y.tab.c"
8335 break;
8336
8337 case 407:
8338 #line 3072 "mrbgems/mruby-compiler/core/parse.y"
8339 {
8340 if ((yyvsp[0].nd)) {
8341 (yyval.nd) = cons(cons(0, (yyvsp[0].nd)), 0);
8342 }
8343 else {
8344 (yyval.nd) = 0;
8345 }
8346 }
8347 #line 8348 "mrbgems/mruby-compiler/core/y.tab.c"
8348 break;
8349
8350 case 409:
8351 #line 3086 "mrbgems/mruby-compiler/core/parse.y"
8352 {
8353 (yyval.nd) = list1(list3((yyvsp[-4].nd), (yyvsp[-3].nd), (yyvsp[-1].nd)));
8354 if ((yyvsp[0].nd)) (yyval.nd) = append((yyval.nd), (yyvsp[0].nd));
8355 }
8356 #line 8357 "mrbgems/mruby-compiler/core/y.tab.c"
8357 break;
8358
8359 case 411:
8360 #line 3094 "mrbgems/mruby-compiler/core/parse.y"
8361 {
8362 (yyval.nd) = list1((yyvsp[0].nd));
8363 }
8364 #line 8365 "mrbgems/mruby-compiler/core/y.tab.c"
8365 break;
8366
8367 case 414:
8368 #line 3102 "mrbgems/mruby-compiler/core/parse.y"
8369 {
8370 (yyval.nd) = (yyvsp[0].nd);
8371 }
8372 #line 8373 "mrbgems/mruby-compiler/core/y.tab.c"
8373 break;
8374
8375 case 416:
8376 #line 3109 "mrbgems/mruby-compiler/core/parse.y"
8377 {
8378 (yyval.nd) = (yyvsp[0].nd);
8379 }
8380 #line 8381 "mrbgems/mruby-compiler/core/y.tab.c"
8381 break;
8382
8383 case 423:
8384 #line 3123 "mrbgems/mruby-compiler/core/parse.y"
8385 {
8386 (yyval.nd) = concat_string(p, (yyvsp[-1].nd), (yyvsp[0].nd));
8387 }
8388 #line 8389 "mrbgems/mruby-compiler/core/y.tab.c"
8389 break;
8390
8391 case 426:
8392 #line 3131 "mrbgems/mruby-compiler/core/parse.y"
8393 {
8394 (yyval.nd) = (yyvsp[0].nd);
8395 }
8396 #line 8397 "mrbgems/mruby-compiler/core/y.tab.c"
8397 break;
8398
8399 case 427:
8400 #line 3135 "mrbgems/mruby-compiler/core/parse.y"
8401 {
8402 (yyval.nd) = new_dstr(p, push((yyvsp[-1].nd), (yyvsp[0].nd)));
8403 }
8404 #line 8405 "mrbgems/mruby-compiler/core/y.tab.c"
8405 break;
8406
8407 case 429:
8408 #line 3142 "mrbgems/mruby-compiler/core/parse.y"
8409 {
8410 (yyval.nd) = append((yyvsp[-1].nd), (yyvsp[0].nd));
8411 }
8412 #line 8413 "mrbgems/mruby-compiler/core/y.tab.c"
8413 break;
8414
8415 case 430:
8416 #line 3148 "mrbgems/mruby-compiler/core/parse.y"
8417 {
8418 (yyval.nd) = list1((yyvsp[0].nd));
8419 }
8420 #line 8421 "mrbgems/mruby-compiler/core/y.tab.c"
8421 break;
8422
8423 case 431:
8424 #line 3152 "mrbgems/mruby-compiler/core/parse.y"
8425 {
8426 (yyval.nd) = p->lex_strterm;
8427 p->lex_strterm = NULL;
8428 }
8429 #line 8430 "mrbgems/mruby-compiler/core/y.tab.c"
8430 break;
8431
8432 case 432:
8433 #line 3158 "mrbgems/mruby-compiler/core/parse.y"
8434 {
8435 p->lex_strterm = (yyvsp[-2].nd);
8436 (yyval.nd) = list2((yyvsp[-3].nd), (yyvsp[-1].nd));
8437 }
8438 #line 8439 "mrbgems/mruby-compiler/core/y.tab.c"
8439 break;
8440
8441 case 433:
8442 #line 3163 "mrbgems/mruby-compiler/core/parse.y"
8443 {
8444 (yyval.nd) = list1(new_literal_delim(p));
8445 }
8446 #line 8447 "mrbgems/mruby-compiler/core/y.tab.c"
8447 break;
8448
8449 case 434:
8450 #line 3167 "mrbgems/mruby-compiler/core/parse.y"
8451 {
8452 (yyval.nd) = list1(new_literal_delim(p));
8453 }
8454 #line 8455 "mrbgems/mruby-compiler/core/y.tab.c"
8455 break;
8456
8457 case 435:
8458 #line 3173 "mrbgems/mruby-compiler/core/parse.y"
8459 {
8460 (yyval.nd) = (yyvsp[0].nd);
8461 }
8462 #line 8463 "mrbgems/mruby-compiler/core/y.tab.c"
8463 break;
8464
8465 case 436:
8466 #line 3177 "mrbgems/mruby-compiler/core/parse.y"
8467 {
8468 (yyval.nd) = new_dxstr(p, push((yyvsp[-1].nd), (yyvsp[0].nd)));
8469 }
8470 #line 8471 "mrbgems/mruby-compiler/core/y.tab.c"
8471 break;
8472
8473 case 437:
8474 #line 3183 "mrbgems/mruby-compiler/core/parse.y"
8475 {
8476 (yyval.nd) = (yyvsp[0].nd);
8477 }
8478 #line 8479 "mrbgems/mruby-compiler/core/y.tab.c"
8479 break;
8480
8481 case 438:
8482 #line 3187 "mrbgems/mruby-compiler/core/parse.y"
8483 {
8484 (yyval.nd) = new_dregx(p, (yyvsp[-1].nd), (yyvsp[0].nd));
8485 }
8486 #line 8487 "mrbgems/mruby-compiler/core/y.tab.c"
8487 break;
8488
8489 case 442:
8490 #line 3200 "mrbgems/mruby-compiler/core/parse.y"
8491 {
8492 parser_heredoc_info * inf = parsing_heredoc_inf(p);
8493 inf->doc = push(inf->doc, new_str(p, "", 0));
8494 heredoc_end(p);
8495 }
8496 #line 8497 "mrbgems/mruby-compiler/core/y.tab.c"
8497 break;
8498
8499 case 443:
8500 #line 3206 "mrbgems/mruby-compiler/core/parse.y"
8501 {
8502 heredoc_end(p);
8503 }
8504 #line 8505 "mrbgems/mruby-compiler/core/y.tab.c"
8505 break;
8506
8507 case 446:
8508 #line 3216 "mrbgems/mruby-compiler/core/parse.y"
8509 {
8510 parser_heredoc_info * inf = parsing_heredoc_inf(p);
8511 inf->doc = push(inf->doc, (yyvsp[0].nd));
8512 heredoc_treat_nextline(p);
8513 }
8514 #line 8515 "mrbgems/mruby-compiler/core/y.tab.c"
8515 break;
8516
8517 case 447:
8518 #line 3222 "mrbgems/mruby-compiler/core/parse.y"
8519 {
8520 (yyval.nd) = p->lex_strterm;
8521 p->lex_strterm = NULL;
8522 }
8523 #line 8524 "mrbgems/mruby-compiler/core/y.tab.c"
8524 break;
8525
8526 case 448:
8527 #line 3228 "mrbgems/mruby-compiler/core/parse.y"
8528 {
8529 parser_heredoc_info * inf = parsing_heredoc_inf(p);
8530 p->lex_strterm = (yyvsp[-2].nd);
8531 inf->doc = push(push(inf->doc, (yyvsp[-3].nd)), (yyvsp[-1].nd));
8532 }
8533 #line 8534 "mrbgems/mruby-compiler/core/y.tab.c"
8534 break;
8535
8536 case 449:
8537 #line 3236 "mrbgems/mruby-compiler/core/parse.y"
8538 {
8539 (yyval.nd) = new_words(p, list1((yyvsp[0].nd)));
8540 }
8541 #line 8542 "mrbgems/mruby-compiler/core/y.tab.c"
8542 break;
8543
8544 case 450:
8545 #line 3240 "mrbgems/mruby-compiler/core/parse.y"
8546 {
8547 (yyval.nd) = new_words(p, push((yyvsp[-1].nd), (yyvsp[0].nd)));
8548 }
8549 #line 8550 "mrbgems/mruby-compiler/core/y.tab.c"
8550 break;
8551
8552 case 451:
8553 #line 3247 "mrbgems/mruby-compiler/core/parse.y"
8554 {
8555 p->lstate = EXPR_ENDARG;
8556 (yyval.nd) = new_sym(p, (yyvsp[0].id));
8557 }
8558 #line 8559 "mrbgems/mruby-compiler/core/y.tab.c"
8559 break;
8560
8561 case 452:
8562 #line 3252 "mrbgems/mruby-compiler/core/parse.y"
8563 {
8564 p->lstate = EXPR_ENDARG;
8565 (yyval.nd) = new_dsym(p, new_dstr(p, push((yyvsp[-1].nd), (yyvsp[0].nd))));
8566 }
8567 #line 8568 "mrbgems/mruby-compiler/core/y.tab.c"
8568 break;
8569
8570 case 453:
8571 #line 3259 "mrbgems/mruby-compiler/core/parse.y"
8572 {
8573 (yyval.id) = (yyvsp[0].id);
8574 }
8575 #line 8576 "mrbgems/mruby-compiler/core/y.tab.c"
8576 break;
8577
8578 case 458:
8579 #line 3269 "mrbgems/mruby-compiler/core/parse.y"
8580 {
8581 (yyval.id) = new_strsym(p, (yyvsp[0].nd));
8582 }
8583 #line 8584 "mrbgems/mruby-compiler/core/y.tab.c"
8584 break;
8585
8586 case 459:
8587 #line 3273 "mrbgems/mruby-compiler/core/parse.y"
8588 {
8589 (yyval.id) = new_strsym(p, (yyvsp[0].nd));
8590 }
8591 #line 8592 "mrbgems/mruby-compiler/core/y.tab.c"
8592 break;
8593
8594 case 460:
8595 #line 3279 "mrbgems/mruby-compiler/core/parse.y"
8596 {
8597 (yyval.nd) = new_symbols(p, list1((yyvsp[0].nd)));
8598 }
8599 #line 8600 "mrbgems/mruby-compiler/core/y.tab.c"
8600 break;
8601
8602 case 461:
8603 #line 3283 "mrbgems/mruby-compiler/core/parse.y"
8604 {
8605 (yyval.nd) = new_symbols(p, push((yyvsp[-1].nd), (yyvsp[0].nd)));
8606 }
8607 #line 8608 "mrbgems/mruby-compiler/core/y.tab.c"
8608 break;
8609
8610 case 464:
8611 #line 3291 "mrbgems/mruby-compiler/core/parse.y"
8612 {
8613 (yyval.nd) = negate_lit(p, (yyvsp[0].nd));
8614 }
8615 #line 8616 "mrbgems/mruby-compiler/core/y.tab.c"
8616 break;
8617
8618 case 465:
8619 #line 3295 "mrbgems/mruby-compiler/core/parse.y"
8620 {
8621 (yyval.nd) = negate_lit(p, (yyvsp[0].nd));
8622 }
8623 #line 8624 "mrbgems/mruby-compiler/core/y.tab.c"
8624 break;
8625
8626 case 466:
8627 #line 3301 "mrbgems/mruby-compiler/core/parse.y"
8628 {
8629 (yyval.nd) = new_lvar(p, (yyvsp[0].id));
8630 }
8631 #line 8632 "mrbgems/mruby-compiler/core/y.tab.c"
8632 break;
8633
8634 case 467:
8635 #line 3305 "mrbgems/mruby-compiler/core/parse.y"
8636 {
8637 (yyval.nd) = new_ivar(p, (yyvsp[0].id));
8638 }
8639 #line 8640 "mrbgems/mruby-compiler/core/y.tab.c"
8640 break;
8641
8642 case 468:
8643 #line 3309 "mrbgems/mruby-compiler/core/parse.y"
8644 {
8645 (yyval.nd) = new_gvar(p, (yyvsp[0].id));
8646 }
8647 #line 8648 "mrbgems/mruby-compiler/core/y.tab.c"
8648 break;
8649
8650 case 469:
8651 #line 3313 "mrbgems/mruby-compiler/core/parse.y"
8652 {
8653 (yyval.nd) = new_cvar(p, (yyvsp[0].id));
8654 }
8655 #line 8656 "mrbgems/mruby-compiler/core/y.tab.c"
8656 break;
8657
8658 case 470:
8659 #line 3317 "mrbgems/mruby-compiler/core/parse.y"
8660 {
8661 (yyval.nd) = new_const(p, (yyvsp[0].id));
8662 }
8663 #line 8664 "mrbgems/mruby-compiler/core/y.tab.c"
8664 break;
8665
8666 case 471:
8667 #line 3323 "mrbgems/mruby-compiler/core/parse.y"
8668 {
8669 assignable(p, (yyvsp[0].nd));
8670 }
8671 #line 8672 "mrbgems/mruby-compiler/core/y.tab.c"
8672 break;
8673
8674 case 472:
8675 #line 3327 "mrbgems/mruby-compiler/core/parse.y"
8676 {
8677 yyerror(p, "can't assign to numbered parameter");
8678 }
8679 #line 8680 "mrbgems/mruby-compiler/core/y.tab.c"
8680 break;
8681
8682 case 473:
8683 #line 3333 "mrbgems/mruby-compiler/core/parse.y"
8684 {
8685 (yyval.nd) = var_reference(p, (yyvsp[0].nd));
8686 }
8687 #line 8688 "mrbgems/mruby-compiler/core/y.tab.c"
8688 break;
8689
8690 case 474:
8691 #line 3337 "mrbgems/mruby-compiler/core/parse.y"
8692 {
8693 (yyval.nd) = new_nil(p);
8694 }
8695 #line 8696 "mrbgems/mruby-compiler/core/y.tab.c"
8696 break;
8697
8698 case 475:
8699 #line 3341 "mrbgems/mruby-compiler/core/parse.y"
8700 {
8701 (yyval.nd) = new_self(p);
8702 }
8703 #line 8704 "mrbgems/mruby-compiler/core/y.tab.c"
8704 break;
8705
8706 case 476:
8707 #line 3345 "mrbgems/mruby-compiler/core/parse.y"
8708 {
8709 (yyval.nd) = new_true(p);
8710 }
8711 #line 8712 "mrbgems/mruby-compiler/core/y.tab.c"
8712 break;
8713
8714 case 477:
8715 #line 3349 "mrbgems/mruby-compiler/core/parse.y"
8716 {
8717 (yyval.nd) = new_false(p);
8718 }
8719 #line 8720 "mrbgems/mruby-compiler/core/y.tab.c"
8720 break;
8721
8722 case 478:
8723 #line 3353 "mrbgems/mruby-compiler/core/parse.y"
8724 {
8725 const char *fn = mrb_sym_name_len(p->mrb, p->filename_sym, NULL);
8726 if (!fn) {
8727 fn = "(null)";
8728 }
8729 (yyval.nd) = new_str(p, fn, strlen(fn));
8730 }
8731 #line 8732 "mrbgems/mruby-compiler/core/y.tab.c"
8732 break;
8733
8734 case 479:
8735 #line 3361 "mrbgems/mruby-compiler/core/parse.y"
8736 {
8737 char buf[16];
8738
8739 dump_int(p->lineno, buf);
8740 (yyval.nd) = new_int(p, buf, 10, 0);
8741 }
8742 #line 8743 "mrbgems/mruby-compiler/core/y.tab.c"
8743 break;
8744
8745 case 480:
8746 #line 3368 "mrbgems/mruby-compiler/core/parse.y"
8747 {
8748 #ifdef MRB_UTF8_STRING
8749 const char *enc = "UTF-8";
8750 #else
8751 const char *enc = "ASCII-8BIT";
8752 #endif
8753 (yyval.nd) = new_str(p, enc, strlen(enc));
8754 }
8755 #line 8756 "mrbgems/mruby-compiler/core/y.tab.c"
8756 break;
8757
8758 case 483:
8759 #line 3383 "mrbgems/mruby-compiler/core/parse.y"
8760 {
8761 (yyval.nd) = 0;
8762 }
8763 #line 8764 "mrbgems/mruby-compiler/core/y.tab.c"
8764 break;
8765
8766 case 484:
8767 #line 3387 "mrbgems/mruby-compiler/core/parse.y"
8768 {
8769 p->lstate = EXPR_BEG;
8770 p->cmd_start = TRUE;
8771 }
8772 #line 8773 "mrbgems/mruby-compiler/core/y.tab.c"
8773 break;
8774
8775 case 485:
8776 #line 3392 "mrbgems/mruby-compiler/core/parse.y"
8777 {
8778 (yyval.nd) = (yyvsp[-1].nd);
8779 }
8780 #line 8781 "mrbgems/mruby-compiler/core/y.tab.c"
8781 break;
8782
8783 case 486:
8784 #line 3403 "mrbgems/mruby-compiler/core/parse.y"
8785 {
8786 (yyval.nd) = (yyvsp[-1].nd);
8787 p->lstate = EXPR_BEG;
8788 p->cmd_start = TRUE;
8789 }
8790 #line 8791 "mrbgems/mruby-compiler/core/y.tab.c"
8791 break;
8792
8793 case 487:
8794 #line 3409 "mrbgems/mruby-compiler/core/parse.y"
8795 {
8796 #if 1
8797 /* til real keyword args implemented */
8798 mrb_sym r = mrb_intern_lit(p->mrb, "*");
8799 mrb_sym b = mrb_intern_lit(p->mrb, "&");
8800 local_add_f(p, r);
8801 (yyval.nd) = new_args(p, 0, 0, r, 0,
8802 new_args_tail(p, 0, 0, b));
8803 #else
8804 mrb_sym r = mrb_intern_lit(p->mrb, "*");
8805 mrb_sym k = mrb_intern_lit(p->mrb, "**");
8806 mrb_sym b = mrb_intern_lit(p->mrb, "&");
8807 local_add_f(p, r); local_add_f(p, k);
8808 (yyval.nd) = new_args(p, 0, 0, r, 0,
8809 new_args_tail(p, 0, new_kw_rest_args(p, nsym(k)), b));
8810 #endif
8811 }
8812 #line 8813 "mrbgems/mruby-compiler/core/y.tab.c"
8813 break;
8814
8815 case 488:
8816 #line 3427 "mrbgems/mruby-compiler/core/parse.y"
8817 {
8818 (yyval.nd) = (yyvsp[-1].nd);
8819 }
8820 #line 8821 "mrbgems/mruby-compiler/core/y.tab.c"
8821 break;
8822
8823 case 489:
8824 #line 3433 "mrbgems/mruby-compiler/core/parse.y"
8825 {
8826 local_nest(p);
8827 }
8828 #line 8829 "mrbgems/mruby-compiler/core/y.tab.c"
8829 break;
8830
8831 case 490:
8832 #line 3439 "mrbgems/mruby-compiler/core/parse.y"
8833 {
8834 void_expr_error(p, (yyvsp[0].nd));
8835 (yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p)));
8836 local_unnest(p);
8837 }
8838 #line 8839 "mrbgems/mruby-compiler/core/y.tab.c"
8839 break;
8840
8841 case 491:
8842 #line 3445 "mrbgems/mruby-compiler/core/parse.y"
8843 {
8844 (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0);
8845 local_unnest(p);
8846 }
8847 #line 8848 "mrbgems/mruby-compiler/core/y.tab.c"
8848 break;
8849
8850 case 492:
8851 #line 3452 "mrbgems/mruby-compiler/core/parse.y"
8852 {
8853 (yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p)));
8854 local_unnest(p);
8855 }
8856 #line 8857 "mrbgems/mruby-compiler/core/y.tab.c"
8857 break;
8858
8859 case 493:
8860 #line 3457 "mrbgems/mruby-compiler/core/parse.y"
8861 {
8862 (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0);
8863 local_unnest(p);
8864 }
8865 #line 8866 "mrbgems/mruby-compiler/core/y.tab.c"
8866 break;
8867
8868 case 494:
8869 #line 3464 "mrbgems/mruby-compiler/core/parse.y"
8870 {
8871 (yyval.nd) = list1((yyvsp[0].nd));
8872 }
8873 #line 8874 "mrbgems/mruby-compiler/core/y.tab.c"
8874 break;
8875
8876 case 495:
8877 #line 3468 "mrbgems/mruby-compiler/core/parse.y"
8878 {
8879 (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
8880 }
8881 #line 8882 "mrbgems/mruby-compiler/core/y.tab.c"
8882 break;
8883
8884 case 496:
8885 #line 3474 "mrbgems/mruby-compiler/core/parse.y"
8886 {
8887 (yyval.nd) = list1((yyvsp[0].nd));
8888 }
8889 #line 8890 "mrbgems/mruby-compiler/core/y.tab.c"
8890 break;
8891
8892 case 497:
8893 #line 3478 "mrbgems/mruby-compiler/core/parse.y"
8894 {
8895 (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
8896 }
8897 #line 8898 "mrbgems/mruby-compiler/core/y.tab.c"
8898 break;
8899
8900 case 500:
8901 #line 3488 "mrbgems/mruby-compiler/core/parse.y"
8902 {
8903 (yyval.nd) = new_kw_rest_args(p, nsym((yyvsp[0].id)));
8904 }
8905 #line 8906 "mrbgems/mruby-compiler/core/y.tab.c"
8906 break;
8907
8908 case 501:
8909 #line 3492 "mrbgems/mruby-compiler/core/parse.y"
8910 {
8911 (yyval.nd) = new_kw_rest_args(p, 0);
8912 }
8913 #line 8914 "mrbgems/mruby-compiler/core/y.tab.c"
8914 break;
8915
8916 case 502:
8917 #line 3498 "mrbgems/mruby-compiler/core/parse.y"
8918 {
8919 (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id));
8920 }
8921 #line 8922 "mrbgems/mruby-compiler/core/y.tab.c"
8922 break;
8923
8924 case 503:
8925 #line 3502 "mrbgems/mruby-compiler/core/parse.y"
8926 {
8927 (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id));
8928 }
8929 #line 8930 "mrbgems/mruby-compiler/core/y.tab.c"
8930 break;
8931
8932 case 504:
8933 #line 3506 "mrbgems/mruby-compiler/core/parse.y"
8934 {
8935 (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id));
8936 }
8937 #line 8938 "mrbgems/mruby-compiler/core/y.tab.c"
8938 break;
8939
8940 case 505:
8941 #line 3510 "mrbgems/mruby-compiler/core/parse.y"
8942 {
8943 (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id));
8944 }
8945 #line 8946 "mrbgems/mruby-compiler/core/y.tab.c"
8946 break;
8947
8948 case 506:
8949 #line 3516 "mrbgems/mruby-compiler/core/parse.y"
8950 {
8951 (yyval.nd) = (yyvsp[0].nd);
8952 }
8953 #line 8954 "mrbgems/mruby-compiler/core/y.tab.c"
8954 break;
8955
8956 case 507:
8957 #line 3520 "mrbgems/mruby-compiler/core/parse.y"
8958 {
8959 (yyval.nd) = new_args_tail(p, 0, 0, 0);
8960 }
8961 #line 8962 "mrbgems/mruby-compiler/core/y.tab.c"
8962 break;
8963
8964 case 508:
8965 #line 3526 "mrbgems/mruby-compiler/core/parse.y"
8966 {
8967 (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
8968 }
8969 #line 8970 "mrbgems/mruby-compiler/core/y.tab.c"
8970 break;
8971
8972 case 509:
8973 #line 3530 "mrbgems/mruby-compiler/core/parse.y"
8974 {
8975 (yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
8976 }
8977 #line 8978 "mrbgems/mruby-compiler/core/y.tab.c"
8978 break;
8979
8980 case 510:
8981 #line 3534 "mrbgems/mruby-compiler/core/parse.y"
8982 {
8983 (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
8984 }
8985 #line 8986 "mrbgems/mruby-compiler/core/y.tab.c"
8986 break;
8987
8988 case 511:
8989 #line 3538 "mrbgems/mruby-compiler/core/parse.y"
8990 {
8991 (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
8992 }
8993 #line 8994 "mrbgems/mruby-compiler/core/y.tab.c"
8994 break;
8995
8996 case 512:
8997 #line 3542 "mrbgems/mruby-compiler/core/parse.y"
8998 {
8999 (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
9000 }
9001 #line 9002 "mrbgems/mruby-compiler/core/y.tab.c"
9002 break;
9003
9004 case 513:
9005 #line 3546 "mrbgems/mruby-compiler/core/parse.y"
9006 {
9007 (yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
9008 }
9009 #line 9010 "mrbgems/mruby-compiler/core/y.tab.c"
9010 break;
9011
9012 case 514:
9013 #line 3550 "mrbgems/mruby-compiler/core/parse.y"
9014 {
9015 (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd));
9016 }
9017 #line 9018 "mrbgems/mruby-compiler/core/y.tab.c"
9018 break;
9019
9020 case 515:
9021 #line 3554 "mrbgems/mruby-compiler/core/parse.y"
9022 {
9023 (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
9024 }
9025 #line 9026 "mrbgems/mruby-compiler/core/y.tab.c"
9026 break;
9027
9028 case 516:
9029 #line 3558 "mrbgems/mruby-compiler/core/parse.y"
9030 {
9031 (yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
9032 }
9033 #line 9034 "mrbgems/mruby-compiler/core/y.tab.c"
9034 break;
9035
9036 case 517:
9037 #line 3562 "mrbgems/mruby-compiler/core/parse.y"
9038 {
9039 (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
9040 }
9041 #line 9042 "mrbgems/mruby-compiler/core/y.tab.c"
9042 break;
9043
9044 case 518:
9045 #line 3566 "mrbgems/mruby-compiler/core/parse.y"
9046 {
9047 (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
9048 }
9049 #line 9050 "mrbgems/mruby-compiler/core/y.tab.c"
9050 break;
9051
9052 case 519:
9053 #line 3570 "mrbgems/mruby-compiler/core/parse.y"
9054 {
9055 (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
9056 }
9057 #line 9058 "mrbgems/mruby-compiler/core/y.tab.c"
9058 break;
9059
9060 case 520:
9061 #line 3574 "mrbgems/mruby-compiler/core/parse.y"
9062 {
9063 (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
9064 }
9065 #line 9066 "mrbgems/mruby-compiler/core/y.tab.c"
9066 break;
9067
9068 case 521:
9069 #line 3578 "mrbgems/mruby-compiler/core/parse.y"
9070 {
9071 (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd));
9072 }
9073 #line 9074 "mrbgems/mruby-compiler/core/y.tab.c"
9074 break;
9075
9076 case 522:
9077 #line 3582 "mrbgems/mruby-compiler/core/parse.y"
9078 {
9079 local_add_f(p, mrb_intern_lit(p->mrb, "&"));
9080 (yyval.nd) = new_args(p, 0, 0, 0, 0, 0);
9081 }
9082 #line 9083 "mrbgems/mruby-compiler/core/y.tab.c"
9083 break;
9084
9085 case 523:
9086 #line 3589 "mrbgems/mruby-compiler/core/parse.y"
9087 {
9088 yyerror(p, "formal argument cannot be a constant");
9089 (yyval.nd) = 0;
9090 }
9091 #line 9092 "mrbgems/mruby-compiler/core/y.tab.c"
9092 break;
9093
9094 case 524:
9095 #line 3594 "mrbgems/mruby-compiler/core/parse.y"
9096 {
9097 yyerror(p, "formal argument cannot be an instance variable");
9098 (yyval.nd) = 0;
9099 }
9100 #line 9101 "mrbgems/mruby-compiler/core/y.tab.c"
9101 break;
9102
9103 case 525:
9104 #line 3599 "mrbgems/mruby-compiler/core/parse.y"
9105 {
9106 yyerror(p, "formal argument cannot be a global variable");
9107 (yyval.nd) = 0;
9108 }
9109 #line 9110 "mrbgems/mruby-compiler/core/y.tab.c"
9110 break;
9111
9112 case 526:
9113 #line 3604 "mrbgems/mruby-compiler/core/parse.y"
9114 {
9115 yyerror(p, "formal argument cannot be a class variable");
9116 (yyval.nd) = 0;
9117 }
9118 #line 9119 "mrbgems/mruby-compiler/core/y.tab.c"
9119 break;
9120
9121 case 527:
9122 #line 3609 "mrbgems/mruby-compiler/core/parse.y"
9123 {
9124 yyerror(p, "formal argument cannot be a numbered parameter");
9125 (yyval.nd) = 0;
9126 }
9127 #line 9128 "mrbgems/mruby-compiler/core/y.tab.c"
9128 break;
9129
9130 case 528:
9131 #line 3616 "mrbgems/mruby-compiler/core/parse.y"
9132 {
9133 (yyval.id) = 0;
9134 }
9135 #line 9136 "mrbgems/mruby-compiler/core/y.tab.c"
9136 break;
9137
9138 case 529:
9139 #line 3620 "mrbgems/mruby-compiler/core/parse.y"
9140 {
9141 local_add_f(p, (yyvsp[0].id));
9142 (yyval.id) = (yyvsp[0].id);
9143 }
9144 #line 9145 "mrbgems/mruby-compiler/core/y.tab.c"
9145 break;
9146
9147 case 530:
9148 #line 3627 "mrbgems/mruby-compiler/core/parse.y"
9149 {
9150 (yyval.nd) = new_arg(p, (yyvsp[0].id));
9151 }
9152 #line 9153 "mrbgems/mruby-compiler/core/y.tab.c"
9153 break;
9154
9155 case 531:
9156 #line 3631 "mrbgems/mruby-compiler/core/parse.y"
9157 {
9158 (yyval.nd) = local_switch(p);
9159 }
9160 #line 9161 "mrbgems/mruby-compiler/core/y.tab.c"
9161 break;
9162
9163 case 532:
9164 #line 3635 "mrbgems/mruby-compiler/core/parse.y"
9165 {
9166 (yyval.nd) = new_masgn_param(p, (yyvsp[-1].nd), p->locals->car);
9167 local_resume(p, (yyvsp[-2].nd));
9168 local_add_f(p, 0);
9169 }
9170 #line 9171 "mrbgems/mruby-compiler/core/y.tab.c"
9171 break;
9172
9173 case 533:
9174 #line 3643 "mrbgems/mruby-compiler/core/parse.y"
9175 {
9176 (yyval.nd) = list1((yyvsp[0].nd));
9177 }
9178 #line 9179 "mrbgems/mruby-compiler/core/y.tab.c"
9179 break;
9180
9181 case 534:
9182 #line 3647 "mrbgems/mruby-compiler/core/parse.y"
9183 {
9184 (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
9185 }
9186 #line 9187 "mrbgems/mruby-compiler/core/y.tab.c"
9187 break;
9188
9189 case 535:
9190 #line 3653 "mrbgems/mruby-compiler/core/parse.y"
9191 {
9192 local_add_f(p, (yyvsp[-1].id));
9193 local_nest(p);
9194 (yyval.id) = (yyvsp[-1].id);
9195 }
9196 #line 9197 "mrbgems/mruby-compiler/core/y.tab.c"
9197 break;
9198
9199 case 536:
9200 #line 3661 "mrbgems/mruby-compiler/core/parse.y"
9201 {
9202 void_expr_error(p, (yyvsp[0].nd));
9203 (yyval.nd) = cons(nsym((yyvsp[-1].id)), cons((yyvsp[0].nd), locals_node(p)));
9204 local_unnest(p);
9205 }
9206 #line 9207 "mrbgems/mruby-compiler/core/y.tab.c"
9207 break;
9208
9209 case 537:
9210 #line 3669 "mrbgems/mruby-compiler/core/parse.y"
9211 {
9212 void_expr_error(p, (yyvsp[0].nd));
9213 (yyval.nd) = cons(nsym((yyvsp[-1].id)), cons((yyvsp[0].nd), locals_node(p)));
9214 local_unnest(p);
9215 }
9216 #line 9217 "mrbgems/mruby-compiler/core/y.tab.c"
9217 break;
9218
9219 case 538:
9220 #line 3677 "mrbgems/mruby-compiler/core/parse.y"
9221 {
9222 (yyval.nd) = list1((yyvsp[0].nd));
9223 }
9224 #line 9225 "mrbgems/mruby-compiler/core/y.tab.c"
9225 break;
9226
9227 case 539:
9228 #line 3681 "mrbgems/mruby-compiler/core/parse.y"
9229 {
9230 (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
9231 }
9232 #line 9233 "mrbgems/mruby-compiler/core/y.tab.c"
9233 break;
9234
9235 case 540:
9236 #line 3687 "mrbgems/mruby-compiler/core/parse.y"
9237 {
9238 (yyval.nd) = list1((yyvsp[0].nd));
9239 }
9240 #line 9241 "mrbgems/mruby-compiler/core/y.tab.c"
9241 break;
9242
9243 case 541:
9244 #line 3691 "mrbgems/mruby-compiler/core/parse.y"
9245 {
9246 (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
9247 }
9248 #line 9249 "mrbgems/mruby-compiler/core/y.tab.c"
9249 break;
9250
9251 case 544:
9252 #line 3701 "mrbgems/mruby-compiler/core/parse.y"
9253 {
9254 local_add_f(p, (yyvsp[0].id));
9255 (yyval.id) = (yyvsp[0].id);
9256 }
9257 #line 9258 "mrbgems/mruby-compiler/core/y.tab.c"
9258 break;
9259
9260 case 545:
9261 #line 3706 "mrbgems/mruby-compiler/core/parse.y"
9262 {
9263 local_add_f(p, mrb_intern_lit(p->mrb, "*"));
9264 (yyval.id) = -1;
9265 }
9266 #line 9267 "mrbgems/mruby-compiler/core/y.tab.c"
9267 break;
9268
9269 case 548:
9270 #line 3717 "mrbgems/mruby-compiler/core/parse.y"
9271 {
9272 (yyval.id) = (yyvsp[0].id);
9273 }
9274 #line 9275 "mrbgems/mruby-compiler/core/y.tab.c"
9275 break;
9276
9277 case 549:
9278 #line 3723 "mrbgems/mruby-compiler/core/parse.y"
9279 {
9280 (yyval.id) = (yyvsp[0].id);
9281 }
9282 #line 9283 "mrbgems/mruby-compiler/core/y.tab.c"
9283 break;
9284
9285 case 550:
9286 #line 3727 "mrbgems/mruby-compiler/core/parse.y"
9287 {
9288 (yyval.id) = 0;
9289 }
9290 #line 9291 "mrbgems/mruby-compiler/core/y.tab.c"
9291 break;
9292
9293 case 551:
9294 #line 3733 "mrbgems/mruby-compiler/core/parse.y"
9295 {
9296 (yyval.nd) = (yyvsp[0].nd);
9297 if (!(yyval.nd)) (yyval.nd) = new_nil(p);
9298 }
9299 #line 9300 "mrbgems/mruby-compiler/core/y.tab.c"
9300 break;
9301
9302 case 552:
9303 #line 3737 "mrbgems/mruby-compiler/core/parse.y"
9304 {p->lstate = EXPR_BEG;}
9305 #line 9306 "mrbgems/mruby-compiler/core/y.tab.c"
9306 break;
9307
9308 case 553:
9309 #line 3738 "mrbgems/mruby-compiler/core/parse.y"
9310 {
9311 if ((yyvsp[-1].nd) == 0) {
9312 yyerror(p, "can't define singleton method for ().");
9313 }
9314 else {
9315 switch ((enum node_type)intn((yyvsp[-1].nd)->car)) {
9316 case NODE_STR:
9317 case NODE_DSTR:
9318 case NODE_XSTR:
9319 case NODE_DXSTR:
9320 case NODE_DREGX:
9321 case NODE_MATCH:
9322 case NODE_FLOAT:
9323 case NODE_ARRAY:
9324 case NODE_HEREDOC:
9325 yyerror(p, "can't define singleton method for literals");
9326 default:
9327 break;
9328 }
9329 }
9330 (yyval.nd) = (yyvsp[-1].nd);
9331 }
9332 #line 9333 "mrbgems/mruby-compiler/core/y.tab.c"
9333 break;
9334
9335 case 555:
9336 #line 3764 "mrbgems/mruby-compiler/core/parse.y"
9337 {
9338 (yyval.nd) = (yyvsp[-1].nd);
9339 }
9340 #line 9341 "mrbgems/mruby-compiler/core/y.tab.c"
9341 break;
9342
9343 case 556:
9344 #line 3770 "mrbgems/mruby-compiler/core/parse.y"
9345 {
9346 (yyval.nd) = list1((yyvsp[0].nd));
9347 NODE_LINENO((yyval.nd), (yyvsp[0].nd));
9348 }
9349 #line 9350 "mrbgems/mruby-compiler/core/y.tab.c"
9350 break;
9351
9352 case 557:
9353 #line 3775 "mrbgems/mruby-compiler/core/parse.y"
9354 {
9355 (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
9356 }
9357 #line 9358 "mrbgems/mruby-compiler/core/y.tab.c"
9358 break;
9359
9360 case 560:
9361 #line 3785 "mrbgems/mruby-compiler/core/parse.y"
9362 {
9363 void_expr_error(p, (yyvsp[-2].nd));
9364 void_expr_error(p, (yyvsp[0].nd));
9365 (yyval.nd) = cons((yyvsp[-2].nd), (yyvsp[0].nd));
9366 }
9367 #line 9368 "mrbgems/mruby-compiler/core/y.tab.c"
9368 break;
9369
9370 case 561:
9371 #line 3791 "mrbgems/mruby-compiler/core/parse.y"
9372 {
9373 void_expr_error(p, (yyvsp[0].nd));
9374 (yyval.nd) = cons(new_sym(p, (yyvsp[-2].id)), (yyvsp[0].nd));
9375 }
9376 #line 9377 "mrbgems/mruby-compiler/core/y.tab.c"
9377 break;
9378
9379 case 562:
9380 #line 3796 "mrbgems/mruby-compiler/core/parse.y"
9381 {
9382 void_expr_error(p, (yyvsp[0].nd));
9383 if ((yyvsp[-2].nd)->car == (node*)NODE_DSTR) {
9384 (yyval.nd) = cons(new_dsym(p, (yyvsp[-2].nd)), (yyvsp[0].nd));
9385 }
9386 else {
9387 (yyval.nd) = cons(new_sym(p, new_strsym(p, (yyvsp[-2].nd))), (yyvsp[0].nd));
9388 }
9389 }
9390 #line 9391 "mrbgems/mruby-compiler/core/y.tab.c"
9391 break;
9392
9393 case 563:
9394 #line 3806 "mrbgems/mruby-compiler/core/parse.y"
9395 {
9396 void_expr_error(p, (yyvsp[0].nd));
9397 (yyval.nd) = cons(new_kw_rest_args(p, 0), (yyvsp[0].nd));
9398 }
9399 #line 9400 "mrbgems/mruby-compiler/core/y.tab.c"
9400 break;
9401
9402 case 576:
9403 #line 3833 "mrbgems/mruby-compiler/core/parse.y"
9404 {
9405 (yyval.num) = '.';
9406 }
9407 #line 9408 "mrbgems/mruby-compiler/core/y.tab.c"
9408 break;
9409
9410 case 577:
9411 #line 3837 "mrbgems/mruby-compiler/core/parse.y"
9412 {
9413 (yyval.num) = 0;
9414 }
9415 #line 9416 "mrbgems/mruby-compiler/core/y.tab.c"
9416 break;
9417
9418 case 579:
9419 #line 3844 "mrbgems/mruby-compiler/core/parse.y"
9420 {
9421 (yyval.num) = tCOLON2;
9422 }
9423 #line 9424 "mrbgems/mruby-compiler/core/y.tab.c"
9424 break;
9425
9426 case 588:
9427 #line 3865 "mrbgems/mruby-compiler/core/parse.y"
9428 {yyerrok;}
9429 #line 9430 "mrbgems/mruby-compiler/core/y.tab.c"
9430 break;
9431
9432 case 591:
9433 #line 3871 "mrbgems/mruby-compiler/core/parse.y"
9434 {
9435 p->lineno += (yyvsp[0].num);
9436 p->column = 0;
9437 }
9438 #line 9439 "mrbgems/mruby-compiler/core/y.tab.c"
9439 break;
9440
9441 case 594:
9442 #line 3882 "mrbgems/mruby-compiler/core/parse.y"
9443 {
9444 (yyval.nd) = 0;
9445 }
9446 #line 9447 "mrbgems/mruby-compiler/core/y.tab.c"
9447 break;
9448
9449
9450 #line 9451 "mrbgems/mruby-compiler/core/y.tab.c"
9451
9452 default: break;
9453 }
9454 /* User semantic actions sometimes alter yychar, and that requires
9455 that yytoken be updated with the new translation. We take the
9456 approach of translating immediately before every use of yytoken.
9457 One alternative is translating here after every semantic action,
9458 but that translation would be missed if the semantic action invokes
9459 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
9460 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
9461 incorrect destructor might then be invoked immediately. In the
9462 case of YYERROR or YYBACKUP, subsequent parser actions might lead
9463 to an incorrect destructor call or verbose syntax error message
9464 before the lookahead is translated. */
9465 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
9466
9467 YYPOPSTACK (yylen);
9468 yylen = 0;
9469 YY_STACK_PRINT (yyss, yyssp);
9470
9471 *++yyvsp = yyval;
9472
9473 /* Now 'shift' the result of the reduction. Determine what state
9474 that goes to, based on the state we popped back to and the rule
9475 number reduced by. */
9476 {
9477 const int yylhs = yyr1[yyn] - YYNTOKENS;
9478 const int yyi = yypgoto[yylhs] + *yyssp;
9479 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
9480 ? yytable[yyi]
9481 : yydefgoto[yylhs]);
9482 }
9483
9484 goto yynewstate;
9485
9486
9487 /*--------------------------------------.
9488 | yyerrlab -- here on detecting error. |
9489 `--------------------------------------*/
9490 yyerrlab:
9491 /* Make sure we have latest lookahead translation. See comments at
9492 user semantic actions for why this is necessary. */
9493 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
9494
9495 /* If not already recovering from an error, report this error. */
9496 if (!yyerrstatus)
9497 {
9498 ++yynerrs;
9499 #if ! YYERROR_VERBOSE
9500 yyerror (p, YY_("syntax error"));
9501 #else
9502 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
9503 yyssp, yytoken)
9504 {
9505 char const *yymsgp = YY_("syntax error");
9506 int yysyntax_error_status;
9507 yysyntax_error_status = YYSYNTAX_ERROR;
9508 if (yysyntax_error_status == 0)
9509 yymsgp = yymsg;
9510 else if (yysyntax_error_status == 1)
9511 {
9512 if (yymsg != yymsgbuf)
9513 YYSTACK_FREE (yymsg);
9514 yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
9515 if (!yymsg)
9516 {
9517 yymsg = yymsgbuf;
9518 yymsg_alloc = sizeof yymsgbuf;
9519 yysyntax_error_status = 2;
9520 }
9521 else
9522 {
9523 yysyntax_error_status = YYSYNTAX_ERROR;
9524 yymsgp = yymsg;
9525 }
9526 }
9527 yyerror (p, yymsgp);
9528 if (yysyntax_error_status == 2)
9529 goto yyexhaustedlab;
9530 }
9531 # undef YYSYNTAX_ERROR
9532 #endif
9533 }
9534
9535
9536
9537 if (yyerrstatus == 3)
9538 {
9539 /* If just tried and failed to reuse lookahead token after an
9540 error, discard it. */
9541
9542 if (yychar <= YYEOF)
9543 {
9544 /* Return failure if at end of input. */
9545 if (yychar == YYEOF)
9546 YYABORT;
9547 }
9548 else
9549 {
9550 yydestruct ("Error: discarding",
9551 yytoken, &yylval, p);
9552 yychar = YYEMPTY;
9553 }
9554 }
9555
9556 /* Else will try to reuse lookahead token after shifting the error
9557 token. */
9558 goto yyerrlab1;
9559
9560
9561 /*---------------------------------------------------.
9562 | yyerrorlab -- error raised explicitly by YYERROR. |
9563 `---------------------------------------------------*/
9564 yyerrorlab:
9565 /* Pacify compilers when the user code never invokes YYERROR and the
9566 label yyerrorlab therefore never appears in user code. */
9567 if (0)
9568 YYERROR;
9569
9570 /* Do not reclaim the symbols of the rule whose action triggered
9571 this YYERROR. */
9572 YYPOPSTACK (yylen);
9573 yylen = 0;
9574 YY_STACK_PRINT (yyss, yyssp);
9575 yystate = *yyssp;
9576 goto yyerrlab1;
9577
9578
9579 /*-------------------------------------------------------------.
9580 | yyerrlab1 -- common code for both syntax error and YYERROR. |
9581 `-------------------------------------------------------------*/
9582 yyerrlab1:
9583 yyerrstatus = 3; /* Each real token shifted decrements this. */
9584
9585 for (;;)
9586 {
9587 yyn = yypact[yystate];
9588 if (!yypact_value_is_default (yyn))
9589 {
9590 yyn += YYTERROR;
9591 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
9592 {
9593 yyn = yytable[yyn];
9594 if (0 < yyn)
9595 break;
9596 }
9597 }
9598
9599 /* Pop the current state because it cannot handle the error token. */
9600 if (yyssp == yyss)
9601 YYABORT;
9602
9603
9604 yydestruct ("Error: popping",
9605 yystos[yystate], yyvsp, p);
9606 YYPOPSTACK (1);
9607 yystate = *yyssp;
9608 YY_STACK_PRINT (yyss, yyssp);
9609 }
9610
9611 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
9612 *++yyvsp = yylval;
9613 YY_IGNORE_MAYBE_UNINITIALIZED_END
9614
9615
9616 /* Shift the error token. */
9617 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
9618
9619 yystate = yyn;
9620 goto yynewstate;
9621
9622
9623 /*-------------------------------------.
9624 | yyacceptlab -- YYACCEPT comes here. |
9625 `-------------------------------------*/
9626 yyacceptlab:
9627 yyresult = 0;
9628 goto yyreturn;
9629
9630
9631 /*-----------------------------------.
9632 | yyabortlab -- YYABORT comes here. |
9633 `-----------------------------------*/
9634 yyabortlab:
9635 yyresult = 1;
9636 goto yyreturn;
9637
9638
9639 #if !defined yyoverflow || YYERROR_VERBOSE
9640 /*-------------------------------------------------.
9641 | yyexhaustedlab -- memory exhaustion comes here. |
9642 `-------------------------------------------------*/
9643 yyexhaustedlab:
9644 yyerror (p, YY_("memory exhausted"));
9645 yyresult = 2;
9646 /* Fall through. */
9647 #endif
9648
9649
9650 /*-----------------------------------------------------.
9651 | yyreturn -- parsing is finished, return the result. |
9652 `-----------------------------------------------------*/
9653 yyreturn:
9654 if (yychar != YYEMPTY)
9655 {
9656 /* Make sure we have latest lookahead translation. See comments at
9657 user semantic actions for why this is necessary. */
9658 yytoken = YYTRANSLATE (yychar);
9659 yydestruct ("Cleanup: discarding lookahead",
9660 yytoken, &yylval, p);
9661 }
9662 /* Do not reclaim the symbols of the rule whose action triggered
9663 this YYABORT or YYACCEPT. */
9664 YYPOPSTACK (yylen);
9665 YY_STACK_PRINT (yyss, yyssp);
9666 while (yyssp != yyss)
9667 {
9668 yydestruct ("Cleanup: popping",
9669 yystos[+*yyssp], yyvsp, p);
9670 YYPOPSTACK (1);
9671 }
9672 #ifndef yyoverflow
9673 if (yyss != yyssa)
9674 YYSTACK_FREE (yyss);
9675 #endif
9676 #if YYERROR_VERBOSE
9677 if (yymsg != yymsgbuf)
9678 YYSTACK_FREE (yymsg);
9679 #endif
9680 return yyresult;
9681 }
9682 #line 3886 "mrbgems/mruby-compiler/core/parse.y"
9683
9684 #define pylval (*((YYSTYPE*)(p->ylval)))
9685
9686 static void
yyerror(parser_state * p,const char * s)9687 yyerror(parser_state *p, const char *s)
9688 {
9689 char* c;
9690 size_t n;
9691
9692 if (! p->capture_errors) {
9693 #ifndef MRB_DISABLE_STDIO
9694 if (p->filename_sym) {
9695 const char *filename = mrb_sym_name_len(p->mrb, p->filename_sym, NULL);
9696 fprintf(stderr, "%s:%d:%d: %s\n", filename, p->lineno, p->column, s);
9697 }
9698 else {
9699 fprintf(stderr, "line %d:%d: %s\n", p->lineno, p->column, s);
9700 }
9701 #endif
9702 }
9703 else if (p->nerr < sizeof(p->error_buffer) / sizeof(p->error_buffer[0])) {
9704 n = strlen(s);
9705 c = (char *)parser_palloc(p, n + 1);
9706 memcpy(c, s, n + 1);
9707 p->error_buffer[p->nerr].message = c;
9708 p->error_buffer[p->nerr].lineno = p->lineno;
9709 p->error_buffer[p->nerr].column = p->column;
9710 }
9711 p->nerr++;
9712 }
9713
9714 static void
yyerror_c(parser_state * p,const char * msg,char c)9715 yyerror_c(parser_state *p, const char *msg, char c)
9716 {
9717 char buf[256];
9718
9719 strncpy(buf, msg, sizeof(buf) - 2);
9720 buf[sizeof(buf) - 2] = '\0';
9721 strncat(buf, &c, 1);
9722 yyerror(p, buf);
9723 }
9724
9725 static void
yywarn(parser_state * p,const char * s)9726 yywarn(parser_state *p, const char *s)
9727 {
9728 char* c;
9729 size_t n;
9730
9731 if (! p->capture_errors) {
9732 #ifndef MRB_DISABLE_STDIO
9733 if (p->filename_sym) {
9734 const char *filename = mrb_sym_name_len(p->mrb, p->filename_sym, NULL);
9735 fprintf(stderr, "%s:%d:%d: warning: %s\n", filename, p->lineno, p->column, s);
9736 }
9737 else {
9738 fprintf(stderr, "line %d:%d: warning: %s\n", p->lineno, p->column, s);
9739 }
9740 #endif
9741 }
9742 else if (p->nwarn < sizeof(p->warn_buffer) / sizeof(p->warn_buffer[0])) {
9743 n = strlen(s);
9744 c = (char *)parser_palloc(p, n + 1);
9745 memcpy(c, s, n + 1);
9746 p->warn_buffer[p->nwarn].message = c;
9747 p->warn_buffer[p->nwarn].lineno = p->lineno;
9748 p->warn_buffer[p->nwarn].column = p->column;
9749 }
9750 p->nwarn++;
9751 }
9752
9753 static void
yywarning(parser_state * p,const char * s)9754 yywarning(parser_state *p, const char *s)
9755 {
9756 yywarn(p, s);
9757 }
9758
9759 static void
yywarning_s(parser_state * p,const char * msg,const char * s)9760 yywarning_s(parser_state *p, const char *msg, const char *s)
9761 {
9762 char buf[256];
9763
9764 strncpy(buf, msg, sizeof(buf) - 1);
9765 buf[sizeof(buf) - 1] = '\0';
9766 strncat(buf, ": ", sizeof(buf) - strlen(buf) - 1);
9767 strncat(buf, s, sizeof(buf) - strlen(buf) - 1);
9768 yywarning(p, buf);
9769 }
9770
9771 static void
backref_error(parser_state * p,node * n)9772 backref_error(parser_state *p, node *n)
9773 {
9774 int c;
9775
9776 c = intn(n->car);
9777
9778 if (c == NODE_NTH_REF) {
9779 yyerror_c(p, "can't set variable $", (char)intn(n->cdr)+'0');
9780 }
9781 else if (c == NODE_BACK_REF) {
9782 yyerror_c(p, "can't set variable $", (char)intn(n->cdr));
9783 }
9784 else {
9785 mrb_bug(p->mrb, "Internal error in backref_error() : n=>car == %d", c);
9786 }
9787 }
9788
9789 static void
void_expr_error(parser_state * p,node * n)9790 void_expr_error(parser_state *p, node *n)
9791 {
9792 int c;
9793
9794 if (n == NULL) return;
9795 c = intn(n->car);
9796 switch (c) {
9797 case NODE_BREAK:
9798 case NODE_RETURN:
9799 case NODE_NEXT:
9800 case NODE_REDO:
9801 case NODE_RETRY:
9802 yyerror(p, "void value expression");
9803 break;
9804 case NODE_AND:
9805 case NODE_OR:
9806 if (n->cdr) {
9807 void_expr_error(p, n->cdr->car);
9808 void_expr_error(p, n->cdr->cdr);
9809 }
9810 break;
9811 case NODE_BEGIN:
9812 if (n->cdr) {
9813 while (n->cdr) {
9814 n = n->cdr;
9815 }
9816 void_expr_error(p, n->car);
9817 }
9818 break;
9819 default:
9820 break;
9821 }
9822 }
9823
9824 static void pushback(parser_state *p, int c);
9825 static mrb_bool peeks(parser_state *p, const char *s);
9826 static mrb_bool skips(parser_state *p, const char *s);
9827
9828 static inline int
nextc0(parser_state * p)9829 nextc0(parser_state *p)
9830 {
9831 int c;
9832 #ifndef MRB_DISABLE_STDIO
9833 if (p->f) {
9834 if (feof(p->f)) return -1;
9835 c = fgetc(p->f);
9836 if (c == EOF) return -1;
9837 }
9838 else
9839 #endif
9840 if (!p->s || p->s >= p->send) {
9841 return -1;
9842 }
9843 else {
9844 c = (unsigned char)*p->s++;
9845 }
9846 return c;
9847 }
9848
9849 static inline int
nextc(parser_state * p)9850 nextc(parser_state *p)
9851 {
9852 int c;
9853
9854 if (p->pb) {
9855 node *tmp;
9856
9857 c = intn(p->pb->car);
9858 tmp = p->pb;
9859 p->pb = p->pb->cdr;
9860 cons_free(tmp);
9861 }
9862 else {
9863 c = nextc0(p);
9864 if (c < 0) goto eof;
9865 }
9866 if (c >= 0) {
9867 p->column++;
9868 }
9869 if (c == '\r') {
9870 const int lf = nextc0(p);
9871 if (lf == '\n') {
9872 return '\n';
9873 }
9874 if (lf > 0) pushback(p, lf);
9875 }
9876 return c;
9877
9878 eof:
9879 if (!p->cxt) return -1;
9880 else {
9881 if (p->cxt->partial_hook(p) < 0)
9882 return -1; /* end of program(s) */
9883 return -2; /* end of a file in the program files */
9884 }
9885 }
9886
9887 static void
pushback(parser_state * p,int c)9888 pushback(parser_state *p, int c)
9889 {
9890 if (c >= 0) {
9891 p->column--;
9892 }
9893 p->pb = cons(nint(c), p->pb);
9894 }
9895
9896 static void
skip(parser_state * p,char term)9897 skip(parser_state *p, char term)
9898 {
9899 int c;
9900
9901 for (;;) {
9902 c = nextc(p);
9903 if (c < 0) break;
9904 if (c == term) break;
9905 }
9906 }
9907
9908 static int
peekc_n(parser_state * p,int n)9909 peekc_n(parser_state *p, int n)
9910 {
9911 node *list = 0;
9912 int c0;
9913
9914 do {
9915 c0 = nextc(p);
9916 if (c0 == -1) return c0; /* do not skip partial EOF */
9917 if (c0 >= 0) --p->column;
9918 list = push(list, nint(c0));
9919 } while(n--);
9920 if (p->pb) {
9921 p->pb = append((node*)list, p->pb);
9922 }
9923 else {
9924 p->pb = list;
9925 }
9926 return c0;
9927 }
9928
9929 static mrb_bool
peek_n(parser_state * p,int c,int n)9930 peek_n(parser_state *p, int c, int n)
9931 {
9932 return peekc_n(p, n) == c && c >= 0;
9933 }
9934 #define peek(p,c) peek_n((p), (c), 0)
9935
9936 static mrb_bool
peeks(parser_state * p,const char * s)9937 peeks(parser_state *p, const char *s)
9938 {
9939 size_t len = strlen(s);
9940
9941 #ifndef MRB_DISABLE_STDIO
9942 if (p->f) {
9943 int n = 0;
9944 while (*s) {
9945 if (!peek_n(p, *s++, n++)) return FALSE;
9946 }
9947 return TRUE;
9948 }
9949 else
9950 #endif
9951 if (p->s && p->s + len <= p->send) {
9952 if (memcmp(p->s, s, len) == 0) return TRUE;
9953 }
9954 return FALSE;
9955 }
9956
9957 static mrb_bool
skips(parser_state * p,const char * s)9958 skips(parser_state *p, const char *s)
9959 {
9960 int c;
9961
9962 for (;;) {
9963 /* skip until first char */
9964 for (;;) {
9965 c = nextc(p);
9966 if (c < 0) return FALSE;
9967 if (c == '\n') {
9968 p->lineno++;
9969 p->column = 0;
9970 }
9971 if (c == *s) break;
9972 }
9973 s++;
9974 if (peeks(p, s)) {
9975 size_t len = strlen(s);
9976
9977 while (len--) {
9978 if (nextc(p) == '\n') {
9979 p->lineno++;
9980 p->column = 0;
9981 }
9982 }
9983 return TRUE;
9984 }
9985 else{
9986 s--;
9987 }
9988 }
9989 return FALSE;
9990 }
9991
9992
9993 static int
newtok(parser_state * p)9994 newtok(parser_state *p)
9995 {
9996 if (p->tokbuf != p->buf) {
9997 mrb_free(p->mrb, p->tokbuf);
9998 p->tokbuf = p->buf;
9999 p->tsiz = MRB_PARSER_TOKBUF_SIZE;
10000 }
10001 p->tidx = 0;
10002 return p->column - 1;
10003 }
10004
10005 static void
tokadd(parser_state * p,int32_t c)10006 tokadd(parser_state *p, int32_t c)
10007 {
10008 char utf8[4];
10009 int i, len;
10010
10011 /* mrb_assert(-0x10FFFF <= c && c <= 0xFF); */
10012 if (c >= 0) {
10013 /* Single byte from source or non-Unicode escape */
10014 utf8[0] = (char)c;
10015 len = 1;
10016 }
10017 else {
10018 /* Unicode character */
10019 c = -c;
10020 if (c < 0x80) {
10021 utf8[0] = (char)c;
10022 len = 1;
10023 }
10024 else if (c < 0x800) {
10025 utf8[0] = (char)(0xC0 | (c >> 6));
10026 utf8[1] = (char)(0x80 | (c & 0x3F));
10027 len = 2;
10028 }
10029 else if (c < 0x10000) {
10030 utf8[0] = (char)(0xE0 | (c >> 12) );
10031 utf8[1] = (char)(0x80 | ((c >> 6) & 0x3F));
10032 utf8[2] = (char)(0x80 | ( c & 0x3F));
10033 len = 3;
10034 }
10035 else {
10036 utf8[0] = (char)(0xF0 | (c >> 18) );
10037 utf8[1] = (char)(0x80 | ((c >> 12) & 0x3F));
10038 utf8[2] = (char)(0x80 | ((c >> 6) & 0x3F));
10039 utf8[3] = (char)(0x80 | ( c & 0x3F));
10040 len = 4;
10041 }
10042 }
10043 if (p->tidx+len >= p->tsiz) {
10044 if (p->tsiz >= MRB_PARSER_TOKBUF_MAX) {
10045 p->tidx += len;
10046 return;
10047 }
10048 p->tsiz *= 2;
10049 if (p->tokbuf == p->buf) {
10050 p->tokbuf = (char*)mrb_malloc(p->mrb, p->tsiz);
10051 memcpy(p->tokbuf, p->buf, MRB_PARSER_TOKBUF_SIZE);
10052 }
10053 else {
10054 p->tokbuf = (char*)mrb_realloc(p->mrb, p->tokbuf, p->tsiz);
10055 }
10056 }
10057 for (i = 0; i < len; i++) {
10058 p->tokbuf[p->tidx++] = utf8[i];
10059 }
10060 }
10061
10062 static int
toklast(parser_state * p)10063 toklast(parser_state *p)
10064 {
10065 return p->tokbuf[p->tidx-1];
10066 }
10067
10068 static void
tokfix(parser_state * p)10069 tokfix(parser_state *p)
10070 {
10071 if (p->tidx >= MRB_PARSER_TOKBUF_MAX) {
10072 p->tidx = MRB_PARSER_TOKBUF_MAX-1;
10073 yyerror(p, "string too long (truncated)");
10074 }
10075 p->tokbuf[p->tidx] = '\0';
10076 }
10077
10078 static const char*
tok(parser_state * p)10079 tok(parser_state *p)
10080 {
10081 return p->tokbuf;
10082 }
10083
10084 static int
toklen(parser_state * p)10085 toklen(parser_state *p)
10086 {
10087 return p->tidx;
10088 }
10089
10090 #define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
10091 #define IS_END() (p->lstate == EXPR_END || p->lstate == EXPR_ENDARG || p->lstate == EXPR_ENDFN)
10092 #define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
10093 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
10094 #define IS_LABEL_POSSIBLE() ((p->lstate == EXPR_BEG && !cmd_state) || IS_ARG())
10095 #define IS_LABEL_SUFFIX(n) (peek_n(p, ':',(n)) && !peek_n(p, ':', (n)+1))
10096
10097 static int32_t
scan_oct(const int * start,int len,int * retlen)10098 scan_oct(const int *start, int len, int *retlen)
10099 {
10100 const int *s = start;
10101 int32_t retval = 0;
10102
10103 /* mrb_assert(len <= 3) */
10104 while (len-- && *s >= '0' && *s <= '7') {
10105 retval <<= 3;
10106 retval |= *s++ - '0';
10107 }
10108 *retlen = (int)(s - start);
10109
10110 return retval;
10111 }
10112
10113 static int32_t
scan_hex(parser_state * p,const int * start,int len,int * retlen)10114 scan_hex(parser_state *p, const int *start, int len, int *retlen)
10115 {
10116 static const char hexdigit[] = "0123456789abcdef0123456789ABCDEF";
10117 const int *s = start;
10118 uint32_t retval = 0;
10119 char *tmp;
10120
10121 /* mrb_assert(len <= 8) */
10122 while (len-- && *s && (tmp = (char*)strchr(hexdigit, *s))) {
10123 retval <<= 4;
10124 retval |= (tmp - hexdigit) & 15;
10125 s++;
10126 }
10127 *retlen = (int)(s - start);
10128
10129 return (int32_t)retval;
10130 }
10131
10132 static int32_t
read_escape_unicode(parser_state * p,int limit)10133 read_escape_unicode(parser_state *p, int limit)
10134 {
10135 int buf[9];
10136 int i;
10137 int32_t hex;
10138
10139 /* Look for opening brace */
10140 i = 0;
10141 buf[0] = nextc(p);
10142 if (buf[0] < 0) {
10143 eof:
10144 yyerror(p, "invalid escape character syntax");
10145 return -1;
10146 }
10147 if (ISXDIGIT(buf[0])) {
10148 /* \uxxxx form */
10149 for (i=1; i<limit; i++) {
10150 buf[i] = nextc(p);
10151 if (buf[i] < 0) goto eof;
10152 if (!ISXDIGIT(buf[i])) {
10153 pushback(p, buf[i]);
10154 break;
10155 }
10156 }
10157 }
10158 else {
10159 pushback(p, buf[0]);
10160 }
10161 hex = scan_hex(p, buf, i, &i);
10162 if (i == 0 || hex > 0x10FFFF || (hex & 0xFFFFF800) == 0xD800) {
10163 yyerror(p, "invalid Unicode code point");
10164 return -1;
10165 }
10166 return hex;
10167 }
10168
10169 /* Return negative to indicate Unicode code point */
10170 static int32_t
read_escape(parser_state * p)10171 read_escape(parser_state *p)
10172 {
10173 int32_t c;
10174
10175 switch (c = nextc(p)) {
10176 case '\\':/* Backslash */
10177 return c;
10178
10179 case 'n':/* newline */
10180 return '\n';
10181
10182 case 't':/* horizontal tab */
10183 return '\t';
10184
10185 case 'r':/* carriage-return */
10186 return '\r';
10187
10188 case 'f':/* form-feed */
10189 return '\f';
10190
10191 case 'v':/* vertical tab */
10192 return '\13';
10193
10194 case 'a':/* alarm(bell) */
10195 return '\007';
10196
10197 case 'e':/* escape */
10198 return 033;
10199
10200 case '0': case '1': case '2': case '3': /* octal constant */
10201 case '4': case '5': case '6': case '7':
10202 {
10203 int buf[3];
10204 int i;
10205
10206 buf[0] = c;
10207 for (i=1; i<3; i++) {
10208 buf[i] = nextc(p);
10209 if (buf[i] < 0) goto eof;
10210 if (buf[i] < '0' || '7' < buf[i]) {
10211 pushback(p, buf[i]);
10212 break;
10213 }
10214 }
10215 c = scan_oct(buf, i, &i);
10216 }
10217 return c;
10218
10219 case 'x': /* hex constant */
10220 {
10221 int buf[2];
10222 int i;
10223
10224 for (i=0; i<2; i++) {
10225 buf[i] = nextc(p);
10226 if (buf[i] < 0) goto eof;
10227 if (!ISXDIGIT(buf[i])) {
10228 pushback(p, buf[i]);
10229 break;
10230 }
10231 }
10232 if (i == 0) {
10233 yyerror(p, "invalid hex escape");
10234 return -1;
10235 }
10236 return scan_hex(p, buf, i, &i);
10237 }
10238
10239 case 'u': /* Unicode */
10240 if (peek(p, '{')) {
10241 /* \u{xxxxxxxx} form */
10242 nextc(p);
10243 c = read_escape_unicode(p, 8);
10244 if (c < 0) return 0;
10245 if (nextc(p) != '}') goto eof;
10246 }
10247 else {
10248 c = read_escape_unicode(p, 4);
10249 if (c < 0) return 0;
10250 }
10251 return -c;
10252
10253 case 'b':/* backspace */
10254 return '\010';
10255
10256 case 's':/* space */
10257 return ' ';
10258
10259 case 'M':
10260 if ((c = nextc(p)) != '-') {
10261 yyerror(p, "Invalid escape character syntax");
10262 pushback(p, c);
10263 return '\0';
10264 }
10265 if ((c = nextc(p)) == '\\') {
10266 return read_escape(p) | 0x80;
10267 }
10268 else if (c < 0) goto eof;
10269 else {
10270 return ((c & 0xff) | 0x80);
10271 }
10272
10273 case 'C':
10274 if ((c = nextc(p)) != '-') {
10275 yyerror(p, "Invalid escape character syntax");
10276 pushback(p, c);
10277 return '\0';
10278 }
10279 case 'c':
10280 if ((c = nextc(p))== '\\') {
10281 c = read_escape(p);
10282 }
10283 else if (c == '?')
10284 return 0177;
10285 else if (c < 0) goto eof;
10286 return c & 0x9f;
10287
10288 eof:
10289 case -1:
10290 case -2: /* end of a file */
10291 yyerror(p, "Invalid escape character syntax");
10292 return '\0';
10293
10294 default:
10295 return c;
10296 }
10297 }
10298
10299 static int
parse_string(parser_state * p)10300 parse_string(parser_state *p)
10301 {
10302 int c;
10303 string_type type = (string_type)(intptr_t)p->lex_strterm->car;
10304 int nest_level = intn(p->lex_strterm->cdr->car);
10305 int beg = intn(p->lex_strterm->cdr->cdr->car);
10306 int end = intn(p->lex_strterm->cdr->cdr->cdr);
10307 parser_heredoc_info *hinf = (type & STR_FUNC_HEREDOC) ? parsing_heredoc_inf(p) : NULL;
10308
10309 if (beg == 0) beg = -3; /* should never happen */
10310 if (end == 0) end = -3;
10311 newtok(p);
10312 while ((c = nextc(p)) != end || nest_level != 0) {
10313 if (hinf && (c == '\n' || c < 0)) {
10314 mrb_bool line_head;
10315 tokadd(p, '\n');
10316 tokfix(p);
10317 p->lineno++;
10318 p->column = 0;
10319 line_head = hinf->line_head;
10320 hinf->line_head = TRUE;
10321 if (line_head) {
10322 /* check whether end of heredoc */
10323 const char *s = tok(p);
10324 int len = toklen(p);
10325 if (hinf->allow_indent) {
10326 while (ISSPACE(*s) && len > 0) {
10327 ++s;
10328 --len;
10329 }
10330 }
10331 if ((len-1 == hinf->term_len) && (strncmp(s, hinf->term, len-1) == 0)) {
10332 return tHEREDOC_END;
10333 }
10334 }
10335 if (c < 0) {
10336 char buf[256];
10337 const char s1[] = "can't find heredoc delimiter \"";
10338 const char s2[] = "\" anywhere before EOF";
10339
10340 if (sizeof(s1)+sizeof(s2)+strlen(hinf->term)+1 >= sizeof(buf)) {
10341 yyerror(p, "can't find heredoc delimiter anywhere before EOF");
10342 } else {
10343 strcpy(buf, s1);
10344 strcat(buf, hinf->term);
10345 strcat(buf, s2);
10346 yyerror(p, buf);
10347 }
10348 return 0;
10349 }
10350 pylval.nd = new_str(p, tok(p), toklen(p));
10351 return tHD_STRING_MID;
10352 }
10353 if (c < 0) {
10354 yyerror(p, "unterminated string meets end of file");
10355 return 0;
10356 }
10357 else if (c == beg) {
10358 nest_level++;
10359 p->lex_strterm->cdr->car = nint(nest_level);
10360 }
10361 else if (c == end) {
10362 nest_level--;
10363 p->lex_strterm->cdr->car = nint(nest_level);
10364 }
10365 else if (c == '\\') {
10366 c = nextc(p);
10367 if (type & STR_FUNC_EXPAND) {
10368 if (c == end || c == beg) {
10369 tokadd(p, c);
10370 }
10371 else if (c == '\n') {
10372 p->lineno++;
10373 p->column = 0;
10374 if (type & STR_FUNC_ARRAY) {
10375 tokadd(p, '\n');
10376 }
10377 }
10378 else if (type & STR_FUNC_REGEXP) {
10379 tokadd(p, '\\');
10380 tokadd(p, c);
10381 }
10382 else if (c == 'u' && peek(p, '{')) {
10383 /* \u{xxxx xxxx xxxx} form */
10384 nextc(p);
10385 while (1) {
10386 do c = nextc(p); while (ISSPACE(c));
10387 if (c == '}') break;
10388 pushback(p, c);
10389 c = read_escape_unicode(p, 8);
10390 if (c < 0) break;
10391 tokadd(p, -c);
10392 }
10393 if (hinf)
10394 hinf->line_head = FALSE;
10395 }
10396 else {
10397 pushback(p, c);
10398 tokadd(p, read_escape(p));
10399 if (hinf)
10400 hinf->line_head = FALSE;
10401 }
10402 }
10403 else {
10404 if (c != beg && c != end) {
10405 if (c == '\n') {
10406 p->lineno++;
10407 p->column = 0;
10408 }
10409 if (!(c == '\\' || ((type & STR_FUNC_ARRAY) && ISSPACE(c)))) {
10410 tokadd(p, '\\');
10411 }
10412 }
10413 tokadd(p, c);
10414 }
10415 continue;
10416 }
10417 else if ((c == '#') && (type & STR_FUNC_EXPAND)) {
10418 c = nextc(p);
10419 if (c == '{') {
10420 tokfix(p);
10421 p->lstate = EXPR_BEG;
10422 p->cmd_start = TRUE;
10423 pylval.nd = new_str(p, tok(p), toklen(p));
10424 if (hinf) {
10425 hinf->line_head = FALSE;
10426 return tHD_STRING_PART;
10427 }
10428 return tSTRING_PART;
10429 }
10430 tokadd(p, '#');
10431 pushback(p, c);
10432 continue;
10433 }
10434 if ((type & STR_FUNC_ARRAY) && ISSPACE(c)) {
10435 if (toklen(p) == 0) {
10436 do {
10437 if (c == '\n') {
10438 p->lineno++;
10439 p->column = 0;
10440 heredoc_treat_nextline(p);
10441 if (p->parsing_heredoc != NULL) {
10442 return tHD_LITERAL_DELIM;
10443 }
10444 }
10445 c = nextc(p);
10446 } while (ISSPACE(c));
10447 pushback(p, c);
10448 return tLITERAL_DELIM;
10449 }
10450 else {
10451 pushback(p, c);
10452 tokfix(p);
10453 pylval.nd = new_str(p, tok(p), toklen(p));
10454 return tSTRING_MID;
10455 }
10456 }
10457 if (c == '\n') {
10458 p->lineno++;
10459 p->column = 0;
10460 }
10461 tokadd(p, c);
10462 }
10463
10464 tokfix(p);
10465 p->lstate = EXPR_ENDARG;
10466 end_strterm(p);
10467
10468 if (type & STR_FUNC_XQUOTE) {
10469 pylval.nd = new_xstr(p, tok(p), toklen(p));
10470 return tXSTRING;
10471 }
10472
10473 if (type & STR_FUNC_REGEXP) {
10474 int f = 0;
10475 int re_opt;
10476 char *s = strndup(tok(p), toklen(p));
10477 char flags[3];
10478 char *flag = flags;
10479 char enc = '\0';
10480 char *encp;
10481 char *dup;
10482
10483 newtok(p);
10484 while (re_opt = nextc(p), re_opt >= 0 && ISALPHA(re_opt)) {
10485 switch (re_opt) {
10486 case 'i': f |= 1; break;
10487 case 'x': f |= 2; break;
10488 case 'm': f |= 4; break;
10489 case 'u': f |= 16; break;
10490 case 'n': f |= 32; break;
10491 case 'o': break;
10492 default: tokadd(p, re_opt); break;
10493 }
10494 }
10495 pushback(p, re_opt);
10496 if (toklen(p)) {
10497 char msg[128];
10498
10499 strcpy(msg, "unknown regexp option");
10500 tokfix(p);
10501 if (toklen(p) > 1) {
10502 strcat(msg, "s");
10503 }
10504 strcat(msg, " - ");
10505 strncat(msg, tok(p), sizeof(msg) - strlen(msg) - 1);
10506 yyerror(p, msg);
10507 }
10508 if (f != 0) {
10509 if (f & 1) *flag++ = 'i';
10510 if (f & 2) *flag++ = 'x';
10511 if (f & 4) *flag++ = 'm';
10512 if (f & 16) enc = 'u';
10513 if (f & 32) enc = 'n';
10514 }
10515 if (flag > flags) {
10516 dup = strndup(flags, (size_t)(flag - flags));
10517 }
10518 else {
10519 dup = NULL;
10520 }
10521 if (enc) {
10522 encp = strndup(&enc, 1);
10523 }
10524 else {
10525 encp = NULL;
10526 }
10527 pylval.nd = new_regx(p, s, dup, encp);
10528
10529 return tREGEXP;
10530 }
10531 pylval.nd = new_str(p, tok(p), toklen(p));
10532
10533 return tSTRING;
10534 }
10535
10536 static int
number_literal_suffix(parser_state * p)10537 number_literal_suffix(parser_state *p)
10538 {
10539 int c, result = 0;
10540 node *list = 0;
10541 int column = p->column;
10542 int mask = NUM_SUFFIX_R|NUM_SUFFIX_I;
10543
10544 while ((c = nextc(p)) != -1) {
10545 list = push(list, (node*)(intptr_t)c);
10546
10547 if ((mask & NUM_SUFFIX_I) && c == 'i') {
10548 result |= (mask & NUM_SUFFIX_I);
10549 mask &= ~NUM_SUFFIX_I;
10550 /* r after i, rational of complex is disallowed */
10551 mask &= ~NUM_SUFFIX_R;
10552 continue;
10553 }
10554 if ((mask & NUM_SUFFIX_R) && c == 'r') {
10555 result |= (mask & NUM_SUFFIX_R);
10556 mask &= ~NUM_SUFFIX_R;
10557 continue;
10558 }
10559 if (!ISASCII(c) || ISALPHA(c) || c == '_') {
10560 p->column = column;
10561 if (p->pb) {
10562 p->pb = append((node*)list, p->pb);
10563 }
10564 else {
10565 p->pb = list;
10566 }
10567 return 0;
10568 }
10569 pushback(p, c);
10570 break;
10571 }
10572 return result;
10573 }
10574
10575 static int
heredoc_identifier(parser_state * p)10576 heredoc_identifier(parser_state *p)
10577 {
10578 int c;
10579 int type = str_heredoc;
10580 mrb_bool indent = FALSE;
10581 mrb_bool quote = FALSE;
10582 node *newnode;
10583 parser_heredoc_info *info;
10584
10585 c = nextc(p);
10586 if (ISSPACE(c) || c == '=') {
10587 pushback(p, c);
10588 return 0;
10589 }
10590 if (c == '-') {
10591 indent = TRUE;
10592 c = nextc(p);
10593 }
10594 if (c == '\'' || c == '"') {
10595 int term = c;
10596 if (c == '\'')
10597 quote = TRUE;
10598 newtok(p);
10599 while ((c = nextc(p)) >= 0 && c != term) {
10600 if (c == '\n') {
10601 c = -1;
10602 break;
10603 }
10604 tokadd(p, c);
10605 }
10606 if (c < 0) {
10607 yyerror(p, "unterminated here document identifier");
10608 return 0;
10609 }
10610 }
10611 else {
10612 if (c < 0) {
10613 return 0; /* missing here document identifier */
10614 }
10615 if (! identchar(c)) {
10616 pushback(p, c);
10617 if (indent) pushback(p, '-');
10618 return 0;
10619 }
10620 newtok(p);
10621 do {
10622 tokadd(p, c);
10623 } while ((c = nextc(p)) >= 0 && identchar(c));
10624 pushback(p, c);
10625 }
10626 tokfix(p);
10627 newnode = new_heredoc(p);
10628 info = (parser_heredoc_info*)newnode->cdr;
10629 info->term = strndup(tok(p), toklen(p));
10630 info->term_len = toklen(p);
10631 if (! quote)
10632 type |= STR_FUNC_EXPAND;
10633 info->type = (string_type)type;
10634 info->allow_indent = indent;
10635 info->line_head = TRUE;
10636 info->doc = NULL;
10637 p->heredocs_from_nextline = push(p->heredocs_from_nextline, newnode);
10638 p->lstate = EXPR_END;
10639
10640 pylval.nd = newnode;
10641 return tHEREDOC_BEG;
10642 }
10643
10644 static int
arg_ambiguous(parser_state * p)10645 arg_ambiguous(parser_state *p)
10646 {
10647 yywarning(p, "ambiguous first argument; put parentheses or even spaces");
10648 return 1;
10649 }
10650
10651 #include "lex.def"
10652
10653 static int
parser_yylex(parser_state * p)10654 parser_yylex(parser_state *p)
10655 {
10656 int32_t c;
10657 int nlines = 1;
10658 int space_seen = 0;
10659 int cmd_state;
10660 enum mrb_lex_state_enum last_state;
10661 int token_column;
10662
10663 if (p->lex_strterm) {
10664 if (is_strterm_type(p, STR_FUNC_HEREDOC)) {
10665 if (p->parsing_heredoc != NULL)
10666 return parse_string(p);
10667 }
10668 else
10669 return parse_string(p);
10670 }
10671 cmd_state = p->cmd_start;
10672 p->cmd_start = FALSE;
10673 retry:
10674 last_state = p->lstate;
10675 switch (c = nextc(p)) {
10676 case '\004': /* ^D */
10677 case '\032': /* ^Z */
10678 case '\0': /* NUL */
10679 case -1: /* end of script. */
10680 if (p->heredocs_from_nextline)
10681 goto maybe_heredoc;
10682 return 0;
10683
10684 /* white spaces */
10685 case ' ': case '\t': case '\f': case '\r':
10686 case '\13': /* '\v' */
10687 space_seen = 1;
10688 goto retry;
10689
10690 case '#': /* it's a comment */
10691 skip(p, '\n');
10692 /* fall through */
10693 case -2: /* end of a file */
10694 case '\n':
10695 maybe_heredoc:
10696 heredoc_treat_nextline(p);
10697 p->column = 0;
10698 switch (p->lstate) {
10699 case EXPR_BEG:
10700 case EXPR_FNAME:
10701 case EXPR_DOT:
10702 case EXPR_CLASS:
10703 case EXPR_VALUE:
10704 p->lineno++;
10705 if (p->parsing_heredoc != NULL) {
10706 if (p->lex_strterm) {
10707 return parse_string(p);
10708 }
10709 }
10710 goto retry;
10711 default:
10712 break;
10713 }
10714 if (p->parsing_heredoc != NULL) {
10715 pylval.num = nlines;
10716 return '\n';
10717 }
10718 while ((c = nextc(p))) {
10719 switch (c) {
10720 case ' ': case '\t': case '\f': case '\r':
10721 case '\13': /* '\v' */
10722 space_seen = 1;
10723 break;
10724 case '#': /* comment as a whitespace */
10725 skip(p, '\n');
10726 nlines++;
10727 break;
10728 case '.':
10729 if (!peek(p, '.')) {
10730 pushback(p, '.');
10731 p->lineno+=nlines; nlines=1;
10732 goto retry;
10733 }
10734 pushback(p, c);
10735 goto normal_newline;
10736 case '&':
10737 if (peek(p, '.')) {
10738 pushback(p, '&');
10739 p->lineno+=nlines; nlines=1;
10740 goto retry;
10741 }
10742 pushback(p, c);
10743 goto normal_newline;
10744 case -1: /* EOF */
10745 case -2: /* end of a file */
10746 goto normal_newline;
10747 default:
10748 pushback(p, c);
10749 goto normal_newline;
10750 }
10751 }
10752 normal_newline:
10753 p->cmd_start = TRUE;
10754 p->lstate = EXPR_BEG;
10755 pylval.num = nlines;
10756 return '\n';
10757
10758 case '*':
10759 if ((c = nextc(p)) == '*') {
10760 if ((c = nextc(p)) == '=') {
10761 pylval.id = intern_lit("**");
10762 p->lstate = EXPR_BEG;
10763 return tOP_ASGN;
10764 }
10765 pushback(p, c);
10766 if (IS_SPCARG(c)) {
10767 yywarning(p, "'**' interpreted as argument prefix");
10768 c = tDSTAR;
10769 }
10770 else if (IS_BEG()) {
10771 c = tDSTAR;
10772 }
10773 else {
10774 c = tPOW; /* "**", "argument prefix" */
10775 }
10776 }
10777 else {
10778 if (c == '=') {
10779 pylval.id = intern_lit("*");
10780 p->lstate = EXPR_BEG;
10781 return tOP_ASGN;
10782 }
10783 pushback(p, c);
10784 if (IS_SPCARG(c)) {
10785 yywarning(p, "'*' interpreted as argument prefix");
10786 c = tSTAR;
10787 }
10788 else if (IS_BEG()) {
10789 c = tSTAR;
10790 }
10791 else {
10792 c = '*';
10793 }
10794 }
10795 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
10796 p->lstate = EXPR_ARG;
10797 }
10798 else {
10799 p->lstate = EXPR_BEG;
10800 }
10801 return c;
10802
10803 case '!':
10804 c = nextc(p);
10805 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
10806 p->lstate = EXPR_ARG;
10807 if (c == '@') {
10808 return '!';
10809 }
10810 }
10811 else {
10812 p->lstate = EXPR_BEG;
10813 }
10814 if (c == '=') {
10815 return tNEQ;
10816 }
10817 if (c == '~') {
10818 return tNMATCH;
10819 }
10820 pushback(p, c);
10821 return '!';
10822
10823 case '=':
10824 if (p->column == 1) {
10825 static const char begin[] = "begin";
10826 static const char end[] = "\n=end";
10827 if (peeks(p, begin)) {
10828 c = peekc_n(p, sizeof(begin)-1);
10829 if (c < 0 || ISSPACE(c)) {
10830 do {
10831 if (!skips(p, end)) {
10832 yyerror(p, "embedded document meets end of file");
10833 return 0;
10834 }
10835 c = nextc(p);
10836 } while (!(c < 0 || ISSPACE(c)));
10837 if (c != '\n') skip(p, '\n');
10838 p->lineno+=nlines; nlines=1;
10839 p->column = 0;
10840 goto retry;
10841 }
10842 }
10843 }
10844 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
10845 p->lstate = EXPR_ARG;
10846 }
10847 else {
10848 p->lstate = EXPR_BEG;
10849 }
10850 if ((c = nextc(p)) == '=') {
10851 if ((c = nextc(p)) == '=') {
10852 return tEQQ;
10853 }
10854 pushback(p, c);
10855 return tEQ;
10856 }
10857 if (c == '~') {
10858 return tMATCH;
10859 }
10860 else if (c == '>') {
10861 return tASSOC;
10862 }
10863 pushback(p, c);
10864 return '=';
10865
10866 case '<':
10867 c = nextc(p);
10868 if (c == '<' &&
10869 p->lstate != EXPR_DOT &&
10870 p->lstate != EXPR_CLASS &&
10871 !IS_END() &&
10872 (!IS_ARG() || space_seen)) {
10873 int token = heredoc_identifier(p);
10874 if (token)
10875 return token;
10876 }
10877 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
10878 p->lstate = EXPR_ARG;
10879 }
10880 else {
10881 p->lstate = EXPR_BEG;
10882 if (p->lstate == EXPR_CLASS) {
10883 p->cmd_start = TRUE;
10884 }
10885 }
10886 if (c == '=') {
10887 if ((c = nextc(p)) == '>') {
10888 return tCMP;
10889 }
10890 pushback(p, c);
10891 return tLEQ;
10892 }
10893 if (c == '<') {
10894 if ((c = nextc(p)) == '=') {
10895 pylval.id = intern_lit("<<");
10896 p->lstate = EXPR_BEG;
10897 return tOP_ASGN;
10898 }
10899 pushback(p, c);
10900 return tLSHFT;
10901 }
10902 pushback(p, c);
10903 return '<';
10904
10905 case '>':
10906 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
10907 p->lstate = EXPR_ARG;
10908 }
10909 else {
10910 p->lstate = EXPR_BEG;
10911 }
10912 if ((c = nextc(p)) == '=') {
10913 return tGEQ;
10914 }
10915 if (c == '>') {
10916 if ((c = nextc(p)) == '=') {
10917 pylval.id = intern_lit(">>");
10918 p->lstate = EXPR_BEG;
10919 return tOP_ASGN;
10920 }
10921 pushback(p, c);
10922 return tRSHFT;
10923 }
10924 pushback(p, c);
10925 return '>';
10926
10927 case '"':
10928 p->lex_strterm = new_strterm(p, str_dquote, '"', 0);
10929 return tSTRING_BEG;
10930
10931 case '\'':
10932 p->lex_strterm = new_strterm(p, str_squote, '\'', 0);
10933 return parse_string(p);
10934
10935 case '`':
10936 if (p->lstate == EXPR_FNAME) {
10937 p->lstate = EXPR_ENDFN;
10938 return '`';
10939 }
10940 if (p->lstate == EXPR_DOT) {
10941 if (cmd_state)
10942 p->lstate = EXPR_CMDARG;
10943 else
10944 p->lstate = EXPR_ARG;
10945 return '`';
10946 }
10947 p->lex_strterm = new_strterm(p, str_xquote, '`', 0);
10948 return tXSTRING_BEG;
10949
10950 case '?':
10951 if (IS_END()) {
10952 p->lstate = EXPR_VALUE;
10953 return '?';
10954 }
10955 c = nextc(p);
10956 if (c < 0) {
10957 yyerror(p, "incomplete character syntax");
10958 return 0;
10959 }
10960 if (ISSPACE(c)) {
10961 if (!IS_ARG()) {
10962 int c2;
10963 switch (c) {
10964 case ' ':
10965 c2 = 's';
10966 break;
10967 case '\n':
10968 c2 = 'n';
10969 break;
10970 case '\t':
10971 c2 = 't';
10972 break;
10973 case '\v':
10974 c2 = 'v';
10975 break;
10976 case '\r':
10977 c2 = 'r';
10978 break;
10979 case '\f':
10980 c2 = 'f';
10981 break;
10982 default:
10983 c2 = 0;
10984 break;
10985 }
10986 if (c2) {
10987 char buf[256];
10988 char cc[] = { (char)c2, '\0' };
10989
10990 strcpy(buf, "invalid character syntax; use ?\\");
10991 strncat(buf, cc, 2);
10992 yyerror(p, buf);
10993 }
10994 }
10995 ternary:
10996 pushback(p, c);
10997 p->lstate = EXPR_VALUE;
10998 return '?';
10999 }
11000 newtok(p);
11001 /* need support UTF-8 if configured */
11002 if ((ISALNUM(c) || c == '_')) {
11003 int c2 = nextc(p);
11004 pushback(p, c2);
11005 if ((ISALNUM(c2) || c2 == '_')) {
11006 goto ternary;
11007 }
11008 }
11009 if (c == '\\') {
11010 c = read_escape(p);
11011 tokadd(p, c);
11012 }
11013 else {
11014 tokadd(p, c);
11015 }
11016 tokfix(p);
11017 pylval.nd = new_str(p, tok(p), toklen(p));
11018 p->lstate = EXPR_ENDARG;
11019 return tCHAR;
11020
11021 case '&':
11022 if ((c = nextc(p)) == '&') {
11023 p->lstate = EXPR_BEG;
11024 if ((c = nextc(p)) == '=') {
11025 pylval.id = intern_lit("&&");
11026 p->lstate = EXPR_BEG;
11027 return tOP_ASGN;
11028 }
11029 pushback(p, c);
11030 return tANDOP;
11031 }
11032 else if (c == '.') {
11033 p->lstate = EXPR_DOT;
11034 return tANDDOT;
11035 }
11036 else if (c == '=') {
11037 pylval.id = intern_lit("&");
11038 p->lstate = EXPR_BEG;
11039 return tOP_ASGN;
11040 }
11041 pushback(p, c);
11042 if (IS_SPCARG(c)) {
11043 yywarning(p, "'&' interpreted as argument prefix");
11044 c = tAMPER;
11045 }
11046 else if (IS_BEG()) {
11047 c = tAMPER;
11048 }
11049 else {
11050 c = '&';
11051 }
11052 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
11053 p->lstate = EXPR_ARG;
11054 }
11055 else {
11056 p->lstate = EXPR_BEG;
11057 }
11058 return c;
11059
11060 case '|':
11061 if ((c = nextc(p)) == '|') {
11062 p->lstate = EXPR_BEG;
11063 if ((c = nextc(p)) == '=') {
11064 pylval.id = intern_lit("||");
11065 p->lstate = EXPR_BEG;
11066 return tOP_ASGN;
11067 }
11068 pushback(p, c);
11069 return tOROP;
11070 }
11071 if (c == '=') {
11072 pylval.id = intern_lit("|");
11073 p->lstate = EXPR_BEG;
11074 return tOP_ASGN;
11075 }
11076 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
11077 p->lstate = EXPR_ARG;
11078 }
11079 else {
11080 p->lstate = EXPR_BEG;
11081 }
11082 pushback(p, c);
11083 return '|';
11084
11085 case '+':
11086 c = nextc(p);
11087 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
11088 p->lstate = EXPR_ARG;
11089 if (c == '@') {
11090 return tUPLUS;
11091 }
11092 pushback(p, c);
11093 return '+';
11094 }
11095 if (c == '=') {
11096 pylval.id = intern_lit("+");
11097 p->lstate = EXPR_BEG;
11098 return tOP_ASGN;
11099 }
11100 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p))) {
11101 p->lstate = EXPR_BEG;
11102 pushback(p, c);
11103 if (c >= 0 && ISDIGIT(c)) {
11104 c = '+';
11105 goto start_num;
11106 }
11107 return tUPLUS;
11108 }
11109 p->lstate = EXPR_BEG;
11110 pushback(p, c);
11111 return '+';
11112
11113 case '-':
11114 c = nextc(p);
11115 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
11116 p->lstate = EXPR_ARG;
11117 if (c == '@') {
11118 return tUMINUS;
11119 }
11120 pushback(p, c);
11121 return '-';
11122 }
11123 if (c == '=') {
11124 pylval.id = intern_lit("-");
11125 p->lstate = EXPR_BEG;
11126 return tOP_ASGN;
11127 }
11128 if (c == '>') {
11129 p->lstate = EXPR_ENDFN;
11130 return tLAMBDA;
11131 }
11132 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p))) {
11133 p->lstate = EXPR_BEG;
11134 pushback(p, c);
11135 if (c >= 0 && ISDIGIT(c)) {
11136 return tUMINUS_NUM;
11137 }
11138 return tUMINUS;
11139 }
11140 p->lstate = EXPR_BEG;
11141 pushback(p, c);
11142 return '-';
11143
11144 case '.':
11145 p->lstate = EXPR_BEG;
11146 if ((c = nextc(p)) == '.') {
11147 if ((c = nextc(p)) == '.') {
11148 return tDOT3;
11149 }
11150 pushback(p, c);
11151 return tDOT2;
11152 }
11153 pushback(p, c);
11154 if (c >= 0 && ISDIGIT(c)) {
11155 yyerror(p, "no .<digit> floating literal anymore; put 0 before dot");
11156 }
11157 p->lstate = EXPR_DOT;
11158 return '.';
11159
11160 start_num:
11161 case '0': case '1': case '2': case '3': case '4':
11162 case '5': case '6': case '7': case '8': case '9':
11163 {
11164 int is_float, seen_point, seen_e, nondigit;
11165 int suffix = 0;
11166
11167 is_float = seen_point = seen_e = nondigit = 0;
11168 p->lstate = EXPR_ENDARG;
11169 newtok(p);
11170 if (c == '-' || c == '+') {
11171 tokadd(p, c);
11172 c = nextc(p);
11173 }
11174 if (c == '0') {
11175 #define no_digits() do {yyerror(p,"numeric literal without digits"); return 0;} while (0)
11176 int start = toklen(p);
11177 c = nextc(p);
11178 if (c == 'x' || c == 'X') {
11179 /* hexadecimal */
11180 c = nextc(p);
11181 if (c >= 0 && ISXDIGIT(c)) {
11182 do {
11183 if (c == '_') {
11184 if (nondigit) break;
11185 nondigit = c;
11186 continue;
11187 }
11188 if (!ISXDIGIT(c)) break;
11189 nondigit = 0;
11190 tokadd(p, tolower(c));
11191 } while ((c = nextc(p)) >= 0);
11192 }
11193 pushback(p, c);
11194 tokfix(p);
11195 if (toklen(p) == start) {
11196 no_digits();
11197 }
11198 else if (nondigit) goto trailing_uc;
11199 suffix = number_literal_suffix(p);
11200 pylval.nd = new_int(p, tok(p), 16, suffix);
11201 return tINTEGER;
11202 }
11203 if (c == 'b' || c == 'B') {
11204 /* binary */
11205 c = nextc(p);
11206 if (c == '0' || c == '1') {
11207 do {
11208 if (c == '_') {
11209 if (nondigit) break;
11210 nondigit = c;
11211 continue;
11212 }
11213 if (c != '0' && c != '1') break;
11214 nondigit = 0;
11215 tokadd(p, c);
11216 } while ((c = nextc(p)) >= 0);
11217 }
11218 pushback(p, c);
11219 tokfix(p);
11220 if (toklen(p) == start) {
11221 no_digits();
11222 }
11223 else if (nondigit) goto trailing_uc;
11224 suffix = number_literal_suffix(p);
11225 pylval.nd = new_int(p, tok(p), 2, suffix);
11226 return tINTEGER;
11227 }
11228 if (c == 'd' || c == 'D') {
11229 /* decimal */
11230 c = nextc(p);
11231 if (c >= 0 && ISDIGIT(c)) {
11232 do {
11233 if (c == '_') {
11234 if (nondigit) break;
11235 nondigit = c;
11236 continue;
11237 }
11238 if (!ISDIGIT(c)) break;
11239 nondigit = 0;
11240 tokadd(p, c);
11241 } while ((c = nextc(p)) >= 0);
11242 }
11243 pushback(p, c);
11244 tokfix(p);
11245 if (toklen(p) == start) {
11246 no_digits();
11247 }
11248 else if (nondigit) goto trailing_uc;
11249 suffix = number_literal_suffix(p);
11250 pylval.nd = new_int(p, tok(p), 10, suffix);
11251 return tINTEGER;
11252 }
11253 if (c == '_') {
11254 /* 0_0 */
11255 goto octal_number;
11256 }
11257 if (c == 'o' || c == 'O') {
11258 /* prefixed octal */
11259 c = nextc(p);
11260 if (c < 0 || c == '_' || !ISDIGIT(c)) {
11261 no_digits();
11262 }
11263 }
11264 if (c >= '0' && c <= '7') {
11265 /* octal */
11266 octal_number:
11267 do {
11268 if (c == '_') {
11269 if (nondigit) break;
11270 nondigit = c;
11271 continue;
11272 }
11273 if (c < '0' || c > '9') break;
11274 if (c > '7') goto invalid_octal;
11275 nondigit = 0;
11276 tokadd(p, c);
11277 } while ((c = nextc(p)) >= 0);
11278
11279 if (toklen(p) > start) {
11280 pushback(p, c);
11281 tokfix(p);
11282 if (nondigit) goto trailing_uc;
11283 suffix = number_literal_suffix(p);
11284 pylval.nd = new_int(p, tok(p), 8, suffix);
11285 return tINTEGER;
11286 }
11287 if (nondigit) {
11288 pushback(p, c);
11289 goto trailing_uc;
11290 }
11291 }
11292 if (c > '7' && c <= '9') {
11293 invalid_octal:
11294 yyerror(p, "Invalid octal digit");
11295 }
11296 else if (c == '.' || c == 'e' || c == 'E') {
11297 tokadd(p, '0');
11298 }
11299 else {
11300 pushback(p, c);
11301 suffix = number_literal_suffix(p);
11302 pylval.nd = new_int(p, "0", 10, suffix);
11303 return tINTEGER;
11304 }
11305 }
11306
11307 for (;;) {
11308 switch (c) {
11309 case '0': case '1': case '2': case '3': case '4':
11310 case '5': case '6': case '7': case '8': case '9':
11311 nondigit = 0;
11312 tokadd(p, c);
11313 break;
11314
11315 case '.':
11316 if (nondigit) goto trailing_uc;
11317 if (seen_point || seen_e) {
11318 goto decode_num;
11319 }
11320 else {
11321 int c0 = nextc(p);
11322 if (c0 < 0 || !ISDIGIT(c0)) {
11323 pushback(p, c0);
11324 goto decode_num;
11325 }
11326 c = c0;
11327 }
11328 tokadd(p, '.');
11329 tokadd(p, c);
11330 is_float++;
11331 seen_point++;
11332 nondigit = 0;
11333 break;
11334
11335 case 'e':
11336 case 'E':
11337 if (nondigit) {
11338 pushback(p, c);
11339 c = nondigit;
11340 goto decode_num;
11341 }
11342 if (seen_e) {
11343 goto decode_num;
11344 }
11345 tokadd(p, c);
11346 seen_e++;
11347 is_float++;
11348 nondigit = c;
11349 c = nextc(p);
11350 if (c != '-' && c != '+') continue;
11351 tokadd(p, c);
11352 nondigit = c;
11353 break;
11354
11355 case '_': /* '_' in number just ignored */
11356 if (nondigit) goto decode_num;
11357 nondigit = c;
11358 break;
11359
11360 default:
11361 goto decode_num;
11362 }
11363 c = nextc(p);
11364 }
11365
11366 decode_num:
11367 pushback(p, c);
11368 if (nondigit) {
11369 trailing_uc:
11370 yyerror_c(p, "trailing non digit in number: ", (char)nondigit);
11371 }
11372 tokfix(p);
11373 if (is_float) {
11374 #ifdef MRB_WITHOUT_FLOAT
11375 yywarning_s(p, "floating point numbers are not supported", tok(p));
11376 pylval.nd = new_int(p, "0", 10, 0);
11377 return tINTEGER;
11378 #else
11379 double d;
11380 char *endp;
11381
11382 errno = 0;
11383 d = mrb_float_read(tok(p), &endp);
11384 if (d == 0 && endp == tok(p)) {
11385 yywarning_s(p, "corrupted float value", tok(p));
11386 }
11387 else if (errno == ERANGE) {
11388 yywarning_s(p, "float out of range", tok(p));
11389 errno = 0;
11390 }
11391 suffix = number_literal_suffix(p);
11392 pylval.nd = new_float(p, tok(p), suffix);
11393 return tFLOAT;
11394 #endif
11395 }
11396 suffix = number_literal_suffix(p);
11397 pylval.nd = new_int(p, tok(p), 10, suffix);
11398 return tINTEGER;
11399 }
11400
11401 case ')':
11402 case ']':
11403 p->paren_nest--;
11404 /* fall through */
11405 case '}':
11406 COND_LEXPOP();
11407 CMDARG_LEXPOP();
11408 if (c == ')')
11409 p->lstate = EXPR_ENDFN;
11410 else
11411 p->lstate = EXPR_END;
11412 return c;
11413
11414 case ':':
11415 c = nextc(p);
11416 if (c == ':') {
11417 if (IS_BEG() || p->lstate == EXPR_CLASS || IS_SPCARG(-1)) {
11418 p->lstate = EXPR_BEG;
11419 return tCOLON3;
11420 }
11421 p->lstate = EXPR_DOT;
11422 return tCOLON2;
11423 }
11424 if (!space_seen && IS_END()) {
11425 pushback(p, c);
11426 p->lstate = EXPR_BEG;
11427 return tLABEL_TAG;
11428 }
11429 if (!ISSPACE(c) || IS_BEG()) {
11430 pushback(p, c);
11431 p->lstate = EXPR_FNAME;
11432 return tSYMBEG;
11433 }
11434 pushback(p, c);
11435 p->lstate = EXPR_BEG;
11436 return ':';
11437
11438 case '/':
11439 if (IS_BEG()) {
11440 p->lex_strterm = new_strterm(p, str_regexp, '/', 0);
11441 return tREGEXP_BEG;
11442 }
11443 if ((c = nextc(p)) == '=') {
11444 pylval.id = intern_lit("/");
11445 p->lstate = EXPR_BEG;
11446 return tOP_ASGN;
11447 }
11448 pushback(p, c);
11449 if (IS_SPCARG(c)) {
11450 p->lex_strterm = new_strterm(p, str_regexp, '/', 0);
11451 return tREGEXP_BEG;
11452 }
11453 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
11454 p->lstate = EXPR_ARG;
11455 }
11456 else {
11457 p->lstate = EXPR_BEG;
11458 }
11459 return '/';
11460
11461 case '^':
11462 if ((c = nextc(p)) == '=') {
11463 pylval.id = intern_lit("^");
11464 p->lstate = EXPR_BEG;
11465 return tOP_ASGN;
11466 }
11467 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
11468 p->lstate = EXPR_ARG;
11469 }
11470 else {
11471 p->lstate = EXPR_BEG;
11472 }
11473 pushback(p, c);
11474 return '^';
11475
11476 case ';':
11477 p->lstate = EXPR_BEG;
11478 return ';';
11479
11480 case ',':
11481 p->lstate = EXPR_BEG;
11482 return ',';
11483
11484 case '~':
11485 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
11486 if ((c = nextc(p)) != '@') {
11487 pushback(p, c);
11488 }
11489 p->lstate = EXPR_ARG;
11490 }
11491 else {
11492 p->lstate = EXPR_BEG;
11493 }
11494 return '~';
11495
11496 case '(':
11497 if (IS_BEG()) {
11498 c = tLPAREN;
11499 }
11500 else if (IS_SPCARG(-1)) {
11501 c = tLPAREN_ARG;
11502 }
11503 else if (p->lstate == EXPR_END && space_seen) {
11504 c = tLPAREN_ARG;
11505 }
11506 p->paren_nest++;
11507 COND_PUSH(0);
11508 CMDARG_PUSH(0);
11509 p->lstate = EXPR_BEG;
11510 return c;
11511
11512 case '[':
11513 p->paren_nest++;
11514 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
11515 p->lstate = EXPR_ARG;
11516 if ((c = nextc(p)) == ']') {
11517 if ((c = nextc(p)) == '=') {
11518 return tASET;
11519 }
11520 pushback(p, c);
11521 return tAREF;
11522 }
11523 pushback(p, c);
11524 return '[';
11525 }
11526 else if (IS_BEG()) {
11527 c = tLBRACK;
11528 }
11529 else if (IS_ARG() && space_seen) {
11530 c = tLBRACK;
11531 }
11532 p->lstate = EXPR_BEG;
11533 COND_PUSH(0);
11534 CMDARG_PUSH(0);
11535 return c;
11536
11537 case '{':
11538 if (p->lpar_beg && p->lpar_beg == p->paren_nest) {
11539 p->lstate = EXPR_BEG;
11540 p->lpar_beg = 0;
11541 p->paren_nest--;
11542 COND_PUSH(0);
11543 CMDARG_PUSH(0);
11544 return tLAMBEG;
11545 }
11546 if (IS_ARG() || p->lstate == EXPR_END || p->lstate == EXPR_ENDFN)
11547 c = '{'; /* block (primary) */
11548 else if (p->lstate == EXPR_ENDARG)
11549 c = tLBRACE_ARG; /* block (expr) */
11550 else
11551 c = tLBRACE; /* hash */
11552 COND_PUSH(0);
11553 CMDARG_PUSH(0);
11554 p->lstate = EXPR_BEG;
11555 return c;
11556
11557 case '\\':
11558 c = nextc(p);
11559 if (c == '\n') {
11560 p->lineno+=nlines; nlines=1;
11561 p->column = 0;
11562 space_seen = 1;
11563 goto retry; /* skip \\n */
11564 }
11565 pushback(p, c);
11566 return '\\';
11567
11568 case '%':
11569 if (IS_BEG()) {
11570 int term;
11571 int paren;
11572
11573 c = nextc(p);
11574 quotation:
11575 if (c < 0 || !ISALNUM(c)) {
11576 term = c;
11577 c = 'Q';
11578 }
11579 else {
11580 term = nextc(p);
11581 if (ISALNUM(term)) {
11582 yyerror(p, "unknown type of %string");
11583 return 0;
11584 }
11585 }
11586 if (c < 0 || term < 0) {
11587 yyerror(p, "unterminated quoted string meets end of file");
11588 return 0;
11589 }
11590 paren = term;
11591 if (term == '(') term = ')';
11592 else if (term == '[') term = ']';
11593 else if (term == '{') term = '}';
11594 else if (term == '<') term = '>';
11595 else paren = 0;
11596
11597 switch (c) {
11598 case 'Q':
11599 p->lex_strterm = new_strterm(p, str_dquote, term, paren);
11600 return tSTRING_BEG;
11601
11602 case 'q':
11603 p->lex_strterm = new_strterm(p, str_squote, term, paren);
11604 return parse_string(p);
11605
11606 case 'W':
11607 p->lex_strterm = new_strterm(p, str_dword, term, paren);
11608 return tWORDS_BEG;
11609
11610 case 'w':
11611 p->lex_strterm = new_strterm(p, str_sword, term, paren);
11612 return tWORDS_BEG;
11613
11614 case 'x':
11615 p->lex_strterm = new_strterm(p, str_xquote, term, paren);
11616 return tXSTRING_BEG;
11617
11618 case 'r':
11619 p->lex_strterm = new_strterm(p, str_regexp, term, paren);
11620 return tREGEXP_BEG;
11621
11622 case 's':
11623 p->lex_strterm = new_strterm(p, str_ssym, term, paren);
11624 return tSYMBEG;
11625
11626 case 'I':
11627 p->lex_strterm = new_strterm(p, str_dsymbols, term, paren);
11628 return tSYMBOLS_BEG;
11629
11630 case 'i':
11631 p->lex_strterm = new_strterm(p, str_ssymbols, term, paren);
11632 return tSYMBOLS_BEG;
11633
11634 default:
11635 yyerror(p, "unknown type of %string");
11636 return 0;
11637 }
11638 }
11639 if ((c = nextc(p)) == '=') {
11640 pylval.id = intern_lit("%");
11641 p->lstate = EXPR_BEG;
11642 return tOP_ASGN;
11643 }
11644 if (IS_SPCARG(c)) {
11645 goto quotation;
11646 }
11647 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
11648 p->lstate = EXPR_ARG;
11649 }
11650 else {
11651 p->lstate = EXPR_BEG;
11652 }
11653 pushback(p, c);
11654 return '%';
11655
11656 case '$':
11657 p->lstate = EXPR_END;
11658 token_column = newtok(p);
11659 c = nextc(p);
11660 if (c < 0) {
11661 yyerror(p, "incomplete global variable syntax");
11662 return 0;
11663 }
11664 switch (c) {
11665 case '_': /* $_: last read line string */
11666 c = nextc(p);
11667 if (c >= 0 && identchar(c)) { /* if there is more after _ it is a variable */
11668 tokadd(p, '$');
11669 tokadd(p, c);
11670 break;
11671 }
11672 pushback(p, c);
11673 c = '_';
11674 /* fall through */
11675 case '~': /* $~: match-data */
11676 case '*': /* $*: argv */
11677 case '$': /* $$: pid */
11678 case '?': /* $?: last status */
11679 case '!': /* $!: error string */
11680 case '@': /* $@: error position */
11681 case '/': /* $/: input record separator */
11682 case '\\': /* $\: output record separator */
11683 case ';': /* $;: field separator */
11684 case ',': /* $,: output field separator */
11685 case '.': /* $.: last read line number */
11686 case '=': /* $=: ignorecase */
11687 case ':': /* $:: load path */
11688 case '<': /* $<: reading filename */
11689 case '>': /* $>: default output handle */
11690 case '\"': /* $": already loaded files */
11691 tokadd(p, '$');
11692 tokadd(p, c);
11693 tokfix(p);
11694 pylval.id = intern(tok(p), toklen(p));
11695 return tGVAR;
11696
11697 case '-':
11698 tokadd(p, '$');
11699 tokadd(p, c);
11700 c = nextc(p);
11701 pushback(p, c);
11702 gvar:
11703 tokfix(p);
11704 pylval.id = intern(tok(p), toklen(p));
11705 return tGVAR;
11706
11707 case '&': /* $&: last match */
11708 case '`': /* $`: string before last match */
11709 case '\'': /* $': string after last match */
11710 case '+': /* $+: string matches last pattern */
11711 if (last_state == EXPR_FNAME) {
11712 tokadd(p, '$');
11713 tokadd(p, c);
11714 goto gvar;
11715 }
11716 pylval.nd = new_back_ref(p, c);
11717 return tBACK_REF;
11718
11719 case '1': case '2': case '3':
11720 case '4': case '5': case '6':
11721 case '7': case '8': case '9':
11722 do {
11723 tokadd(p, c);
11724 c = nextc(p);
11725 } while (c >= 0 && ISDIGIT(c));
11726 pushback(p, c);
11727 if (last_state == EXPR_FNAME) goto gvar;
11728 tokfix(p);
11729 {
11730 unsigned long n = strtoul(tok(p), NULL, 10);
11731 if (n > INT_MAX) {
11732 yyerror(p, "capture group index must be <= " MRB_STRINGIZE(INT_MAX));
11733 return 0;
11734 }
11735 pylval.nd = new_nth_ref(p, (int)n);
11736 }
11737 return tNTH_REF;
11738
11739 default:
11740 if (!identchar(c)) {
11741 pushback(p, c);
11742 return '$';
11743 }
11744 /* fall through */
11745 case '0':
11746 tokadd(p, '$');
11747 }
11748 break;
11749
11750 case '@':
11751 c = nextc(p);
11752 token_column = newtok(p);
11753 tokadd(p, '@');
11754 if (c == '@') {
11755 tokadd(p, '@');
11756 c = nextc(p);
11757 }
11758 if (c < 0) {
11759 if (p->tidx == 1) {
11760 yyerror(p, "incomplete instance variable syntax");
11761 }
11762 else {
11763 yyerror(p, "incomplete class variable syntax");
11764 }
11765 return 0;
11766 }
11767 else if (ISDIGIT(c)) {
11768 if (p->tidx == 1) {
11769 yyerror_c(p, "wrong instance variable name: @", c);
11770 }
11771 else {
11772 yyerror_c(p, "wrong class variable name: @@", c);
11773 }
11774 return 0;
11775 }
11776 if (!identchar(c)) {
11777 pushback(p, c);
11778 return '@';
11779 }
11780 break;
11781
11782 case '_':
11783 token_column = newtok(p);
11784 break;
11785
11786 default:
11787 if (!identchar(c)) {
11788 char buf[36];
11789 const char s[] = "Invalid char in expression: 0x";
11790 const char hexdigits[] = "0123456789ABCDEF";
11791
11792 strcpy(buf, s);
11793 buf[sizeof(s)-1] = hexdigits[(c & 0xf0) >> 4];
11794 buf[sizeof(s)] = hexdigits[(c & 0x0f)];
11795 buf[sizeof(s)+1] = 0;
11796 yyerror(p, buf);
11797 goto retry;
11798 }
11799
11800 token_column = newtok(p);
11801 break;
11802 }
11803
11804 do {
11805 tokadd(p, c);
11806 c = nextc(p);
11807 if (c < 0) break;
11808 } while (identchar(c));
11809 if (token_column == 0 && toklen(p) == 7 && (c < 0 || c == '\n') &&
11810 strncmp(tok(p), "__END__", toklen(p)) == 0)
11811 return -1;
11812
11813 switch (tok(p)[0]) {
11814 case '@': case '$':
11815 pushback(p, c);
11816 break;
11817 default:
11818 if ((c == '!' || c == '?') && !peek(p, '=')) {
11819 tokadd(p, c);
11820 }
11821 else {
11822 pushback(p, c);
11823 }
11824 }
11825 tokfix(p);
11826 {
11827 int result = 0;
11828
11829 switch (tok(p)[0]) {
11830 case '$':
11831 p->lstate = EXPR_END;
11832 result = tGVAR;
11833 break;
11834 case '@':
11835 p->lstate = EXPR_END;
11836 if (tok(p)[1] == '@')
11837 result = tCVAR;
11838 else
11839 result = tIVAR;
11840 break;
11841
11842 case '_':
11843 if (toklen(p) == 2 && ISDIGIT(tok(p)[1]) && p->nvars) {
11844 int n = tok(p)[1] - '0';
11845 int nvar;
11846
11847 if (n > 0) {
11848 node *nvars = p->nvars->cdr;
11849
11850 while (nvars) {
11851 nvar = intn(nvars->car);
11852 if (nvar == -2) break; /* top of the scope */
11853 if (nvar > 0) {
11854 yywarning(p, "numbered parameter used in outer block");
11855 break;
11856 }
11857 nvars->car = nint(-1);
11858 nvars = nvars->cdr;
11859 }
11860 nvar = intn(p->nvars->car);
11861 if (nvar == -1) {
11862 yywarning(p, "numbered parameter used in inner block");
11863 }
11864 if (nvar >= -1) {
11865 pylval.num = n;
11866 p->lstate = EXPR_END;
11867 return tNUMPARAM;
11868 }
11869 else {
11870 yywarning(p, "identifier for numbered parameter; consider another name");
11871 }
11872 }
11873 }
11874 /* fall through */
11875 default:
11876 if (toklast(p) == '!' || toklast(p) == '?') {
11877 result = tFID;
11878 }
11879 else {
11880 if (p->lstate == EXPR_FNAME) {
11881 if ((c = nextc(p)) == '=' && !peek(p, '~') && !peek(p, '>') &&
11882 (!peek(p, '=') || (peek_n(p, '>', 1)))) {
11883 result = tIDENTIFIER;
11884 tokadd(p, c);
11885 tokfix(p);
11886 }
11887 else {
11888 pushback(p, c);
11889 }
11890 if ((c = nextc(p)) == '=' && !peek(p, '~') && !peek(p, '>') &&
11891 (!peek(p, '=') || (peek_n(p, '>', 1)))) {
11892 result = tIDENTIFIER;
11893 tokadd(p, c);
11894 tokfix(p);
11895 }
11896 else {
11897 pushback(p, c);
11898 }
11899 }
11900 if (result == 0 && ISUPPER(tok(p)[0])) {
11901 result = tCONSTANT;
11902 }
11903 else {
11904 result = tIDENTIFIER;
11905 }
11906 }
11907
11908 if (IS_LABEL_POSSIBLE()) {
11909 if (IS_LABEL_SUFFIX(0)) {
11910 p->lstate = EXPR_END;
11911 tokfix(p);
11912 pylval.id = intern(tok(p), toklen(p));
11913 return tIDENTIFIER;
11914 }
11915 }
11916 if (p->lstate != EXPR_DOT) {
11917 const struct kwtable *kw;
11918
11919 /* See if it is a reserved word. */
11920 kw = mrb_reserved_word(tok(p), toklen(p));
11921 if (kw) {
11922 enum mrb_lex_state_enum state = p->lstate;
11923 pylval.num = p->lineno;
11924 p->lstate = kw->state;
11925 if (state == EXPR_FNAME) {
11926 pylval.id = intern_cstr(kw->name);
11927 return kw->id[0];
11928 }
11929 if (p->lstate == EXPR_BEG) {
11930 p->cmd_start = TRUE;
11931 }
11932 if (kw->id[0] == keyword_do) {
11933 if (p->lpar_beg && p->lpar_beg == p->paren_nest) {
11934 p->lpar_beg = 0;
11935 p->paren_nest--;
11936 return keyword_do_LAMBDA;
11937 }
11938 if (COND_P()) return keyword_do_cond;
11939 if (CMDARG_P() && state != EXPR_CMDARG)
11940 return keyword_do_block;
11941 if (state == EXPR_ENDARG || state == EXPR_BEG)
11942 return keyword_do_block;
11943 return keyword_do;
11944 }
11945 if (state == EXPR_BEG || state == EXPR_VALUE)
11946 return kw->id[0];
11947 else {
11948 if (kw->id[0] != kw->id[1])
11949 p->lstate = EXPR_BEG;
11950 return kw->id[1];
11951 }
11952 }
11953 }
11954
11955 if (IS_BEG() || p->lstate == EXPR_DOT || IS_ARG()) {
11956 if (cmd_state) {
11957 p->lstate = EXPR_CMDARG;
11958 }
11959 else {
11960 p->lstate = EXPR_ARG;
11961 }
11962 }
11963 else if (p->lstate == EXPR_FNAME) {
11964 p->lstate = EXPR_ENDFN;
11965 }
11966 else {
11967 p->lstate = EXPR_END;
11968 }
11969 }
11970 {
11971 mrb_sym ident = intern(tok(p), toklen(p));
11972
11973 pylval.id = ident;
11974 if (last_state != EXPR_DOT && ISLOWER(tok(p)[0]) && local_var_p(p, ident)) {
11975 p->lstate = EXPR_END;
11976 }
11977 }
11978 return result;
11979 }
11980 }
11981
11982 static int
yylex(void * lval,parser_state * p)11983 yylex(void *lval, parser_state *p)
11984 {
11985 p->ylval = lval;
11986 return parser_yylex(p);
11987 }
11988
11989 static void
parser_init_cxt(parser_state * p,mrbc_context * cxt)11990 parser_init_cxt(parser_state *p, mrbc_context *cxt)
11991 {
11992 if (!cxt) return;
11993 if (cxt->filename) mrb_parser_set_filename(p, cxt->filename);
11994 if (cxt->lineno) p->lineno = cxt->lineno;
11995 if (cxt->syms) {
11996 int i;
11997
11998 p->locals = cons(0,0);
11999 for (i=0; i<cxt->slen; i++) {
12000 local_add_f(p, cxt->syms[i]);
12001 }
12002 }
12003 p->capture_errors = cxt->capture_errors;
12004 p->no_optimize = cxt->no_optimize;
12005 p->upper = cxt->upper;
12006 if (cxt->partial_hook) {
12007 p->cxt = cxt;
12008 }
12009 }
12010
12011 static void
parser_update_cxt(parser_state * p,mrbc_context * cxt)12012 parser_update_cxt(parser_state *p, mrbc_context *cxt)
12013 {
12014 node *n, *n0;
12015 int i = 0;
12016
12017 if (!cxt) return;
12018 if (intn(p->tree->car) != NODE_SCOPE) return;
12019 n0 = n = p->tree->cdr->car;
12020 while (n) {
12021 i++;
12022 n = n->cdr;
12023 }
12024 cxt->syms = (mrb_sym *)mrb_realloc(p->mrb, cxt->syms, i*sizeof(mrb_sym));
12025 cxt->slen = i;
12026 for (i=0, n=n0; n; i++,n=n->cdr) {
12027 cxt->syms[i] = sym(n->car);
12028 }
12029 }
12030
12031 void mrb_codedump_all(mrb_state*, struct RProc*);
12032 void mrb_parser_dump(mrb_state *mrb, node *tree, int offset);
12033
12034 MRB_API void
mrb_parser_parse(parser_state * p,mrbc_context * c)12035 mrb_parser_parse(parser_state *p, mrbc_context *c)
12036 {
12037 struct mrb_jmpbuf buf1;
12038 p->jmp = &buf1;
12039
12040 MRB_TRY(p->jmp) {
12041 int n = 1;
12042
12043 p->cmd_start = TRUE;
12044 p->in_def = p->in_single = 0;
12045 p->nerr = p->nwarn = 0;
12046 p->lex_strterm = NULL;
12047
12048 parser_init_cxt(p, c);
12049
12050 if (p->mrb->jmp) {
12051 n = yyparse(p);
12052 }
12053 else {
12054 struct mrb_jmpbuf buf2;
12055
12056 p->mrb->jmp = &buf2;
12057 MRB_TRY(p->mrb->jmp) {
12058 n = yyparse(p);
12059 }
12060 MRB_CATCH(p->mrb->jmp) {
12061 p->nerr++;
12062 }
12063 MRB_END_EXC(p->mrb->jmp);
12064 p->mrb->jmp = 0;
12065 }
12066 if (n != 0 || p->nerr > 0) {
12067 p->tree = 0;
12068 return;
12069 }
12070 if (!p->tree) {
12071 p->tree = new_nil(p);
12072 }
12073 parser_update_cxt(p, c);
12074 if (c && c->dump_result) {
12075 mrb_parser_dump(p->mrb, p->tree, 0);
12076 }
12077 }
12078 MRB_CATCH(p->jmp) {
12079 yyerror(p, "memory allocation error");
12080 p->nerr++;
12081 p->tree = 0;
12082 return;
12083 }
12084 MRB_END_EXC(p->jmp);
12085 }
12086
12087 MRB_API parser_state*
mrb_parser_new(mrb_state * mrb)12088 mrb_parser_new(mrb_state *mrb)
12089 {
12090 mrb_pool *pool;
12091 parser_state *p;
12092 static const parser_state parser_state_zero = { 0 };
12093
12094 pool = mrb_pool_open(mrb);
12095 if (!pool) return NULL;
12096 p = (parser_state *)mrb_pool_alloc(pool, sizeof(parser_state));
12097 if (!p) return NULL;
12098
12099 *p = parser_state_zero;
12100 p->mrb = mrb;
12101 p->pool = pool;
12102
12103 p->s = p->send = NULL;
12104 #ifndef MRB_DISABLE_STDIO
12105 p->f = NULL;
12106 #endif
12107
12108 p->cmd_start = TRUE;
12109 p->in_def = p->in_single = 0;
12110
12111 p->capture_errors = FALSE;
12112 p->lineno = 1;
12113 p->column = 0;
12114 #if defined(PARSER_TEST) || defined(PARSER_DEBUG)
12115 yydebug = 1;
12116 #endif
12117 p->tsiz = MRB_PARSER_TOKBUF_SIZE;
12118 p->tokbuf = p->buf;
12119
12120 p->lex_strterm = NULL;
12121 p->all_heredocs = p->parsing_heredoc = NULL;
12122 p->lex_strterm_before_heredoc = NULL;
12123
12124 p->current_filename_index = -1;
12125 p->filename_table = NULL;
12126 p->filename_table_length = 0;
12127
12128 return p;
12129 }
12130
12131 MRB_API void
mrb_parser_free(parser_state * p)12132 mrb_parser_free(parser_state *p) {
12133 if (p->tokbuf != p->buf) {
12134 mrb_free(p->mrb, p->tokbuf);
12135 }
12136 mrb_pool_close(p->pool);
12137 }
12138
12139 MRB_API mrbc_context*
mrbc_context_new(mrb_state * mrb)12140 mrbc_context_new(mrb_state *mrb)
12141 {
12142 return (mrbc_context *)mrb_calloc(mrb, 1, sizeof(mrbc_context));
12143 }
12144
12145 MRB_API void
mrbc_context_free(mrb_state * mrb,mrbc_context * cxt)12146 mrbc_context_free(mrb_state *mrb, mrbc_context *cxt)
12147 {
12148 mrb_free(mrb, cxt->filename);
12149 mrb_free(mrb, cxt->syms);
12150 mrb_free(mrb, cxt);
12151 }
12152
12153 MRB_API const char*
mrbc_filename(mrb_state * mrb,mrbc_context * c,const char * s)12154 mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s)
12155 {
12156 if (s) {
12157 size_t len = strlen(s);
12158 char *p = (char *)mrb_malloc(mrb, len + 1);
12159
12160 memcpy(p, s, len + 1);
12161 if (c->filename) {
12162 mrb_free(mrb, c->filename);
12163 }
12164 c->filename = p;
12165 }
12166 return c->filename;
12167 }
12168
12169 MRB_API void
mrbc_partial_hook(mrb_state * mrb,mrbc_context * c,int (* func)(struct mrb_parser_state *),void * data)12170 mrbc_partial_hook(mrb_state *mrb, mrbc_context *c, int (*func)(struct mrb_parser_state*), void *data)
12171 {
12172 c->partial_hook = func;
12173 c->partial_data = data;
12174 }
12175
12176 MRB_API void
mrb_parser_set_filename(struct mrb_parser_state * p,const char * f)12177 mrb_parser_set_filename(struct mrb_parser_state *p, const char *f)
12178 {
12179 mrb_sym sym;
12180 size_t i;
12181 mrb_sym* new_table;
12182
12183 sym = mrb_intern_cstr(p->mrb, f);
12184 p->filename_sym = sym;
12185 p->lineno = (p->filename_table_length > 0)? 0 : 1;
12186
12187 for (i = 0; i < p->filename_table_length; ++i) {
12188 if (p->filename_table[i] == sym) {
12189 p->current_filename_index = (int)i;
12190 return;
12191 }
12192 }
12193
12194 if (p->filename_table_length == UINT16_MAX) {
12195 yyerror(p, "too many files to compile");
12196 return;
12197 }
12198 p->current_filename_index = p->filename_table_length++;
12199
12200 new_table = (mrb_sym*)parser_palloc(p, sizeof(mrb_sym) * p->filename_table_length);
12201 if (p->filename_table) {
12202 memmove(new_table, p->filename_table, sizeof(mrb_sym) * p->current_filename_index);
12203 }
12204 p->filename_table = new_table;
12205 p->filename_table[p->filename_table_length - 1] = sym;
12206 }
12207
12208 MRB_API mrb_sym
mrb_parser_get_filename(struct mrb_parser_state * p,uint16_t idx)12209 mrb_parser_get_filename(struct mrb_parser_state* p, uint16_t idx) {
12210 if (idx >= p->filename_table_length) return 0;
12211 else {
12212 return p->filename_table[idx];
12213 }
12214 }
12215
12216 #ifndef MRB_DISABLE_STDIO
12217 MRB_API parser_state*
mrb_parse_file(mrb_state * mrb,FILE * f,mrbc_context * c)12218 mrb_parse_file(mrb_state *mrb, FILE *f, mrbc_context *c)
12219 {
12220 parser_state *p;
12221
12222 p = mrb_parser_new(mrb);
12223 if (!p) return NULL;
12224 p->s = p->send = NULL;
12225 p->f = f;
12226
12227 mrb_parser_parse(p, c);
12228 return p;
12229 }
12230 #endif
12231
12232 MRB_API parser_state*
mrb_parse_nstring(mrb_state * mrb,const char * s,size_t len,mrbc_context * c)12233 mrb_parse_nstring(mrb_state *mrb, const char *s, size_t len, mrbc_context *c)
12234 {
12235 parser_state *p;
12236
12237 p = mrb_parser_new(mrb);
12238 if (!p) return NULL;
12239 p->s = s;
12240 p->send = s + len;
12241
12242 mrb_parser_parse(p, c);
12243 return p;
12244 }
12245
12246 MRB_API parser_state*
mrb_parse_string(mrb_state * mrb,const char * s,mrbc_context * c)12247 mrb_parse_string(mrb_state *mrb, const char *s, mrbc_context *c)
12248 {
12249 return mrb_parse_nstring(mrb, s, strlen(s), c);
12250 }
12251
12252 MRB_API mrb_value
mrb_load_exec(mrb_state * mrb,struct mrb_parser_state * p,mrbc_context * c)12253 mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c)
12254 {
12255 struct RClass *target = mrb->object_class;
12256 struct RProc *proc;
12257 mrb_value v;
12258 unsigned int keep = 0;
12259
12260 if (!p) {
12261 return mrb_undef_value();
12262 }
12263 if (!p->tree || p->nerr) {
12264 if (c) c->parser_nerr = p->nerr;
12265 if (p->capture_errors) {
12266 char buf[256];
12267
12268 strcpy(buf, "line ");
12269 dump_int(p->error_buffer[0].lineno, buf+5);
12270 strcat(buf, ": ");
12271 strncat(buf, p->error_buffer[0].message, sizeof(buf) - strlen(buf) - 1);
12272 mrb->exc = mrb_obj_ptr(mrb_exc_new(mrb, E_SYNTAX_ERROR, buf, strlen(buf)));
12273 mrb_parser_free(p);
12274 return mrb_undef_value();
12275 }
12276 else {
12277 if (mrb->exc == NULL) {
12278 mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SYNTAX_ERROR, "syntax error"));
12279 }
12280 mrb_parser_free(p);
12281 return mrb_undef_value();
12282 }
12283 }
12284 proc = mrb_generate_code(mrb, p);
12285 mrb_parser_free(p);
12286 if (proc == NULL) {
12287 if (mrb->exc == NULL) {
12288 mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "codegen error"));
12289 }
12290 return mrb_undef_value();
12291 }
12292 if (c) {
12293 if (c->dump_result) mrb_codedump_all(mrb, proc);
12294 if (c->no_exec) return mrb_obj_value(proc);
12295 if (c->target_class) {
12296 target = c->target_class;
12297 }
12298 if (c->keep_lv) {
12299 keep = c->slen + 1;
12300 }
12301 else {
12302 c->keep_lv = TRUE;
12303 }
12304 }
12305 MRB_PROC_SET_TARGET_CLASS(proc, target);
12306 if (mrb->c->ci) {
12307 mrb->c->ci->target_class = target;
12308 }
12309 v = mrb_top_run(mrb, proc, mrb_top_self(mrb), keep);
12310 if (mrb->exc) return mrb_nil_value();
12311 return v;
12312 }
12313
12314 #ifndef MRB_DISABLE_STDIO
12315 MRB_API mrb_value
mrb_load_file_cxt(mrb_state * mrb,FILE * f,mrbc_context * c)12316 mrb_load_file_cxt(mrb_state *mrb, FILE *f, mrbc_context *c)
12317 {
12318 return mrb_load_exec(mrb, mrb_parse_file(mrb, f, c), c);
12319 }
12320
12321 MRB_API mrb_value
mrb_load_file(mrb_state * mrb,FILE * f)12322 mrb_load_file(mrb_state *mrb, FILE *f)
12323 {
12324 return mrb_load_file_cxt(mrb, f, NULL);
12325 }
12326 #endif
12327
12328 MRB_API mrb_value
mrb_load_nstring_cxt(mrb_state * mrb,const char * s,size_t len,mrbc_context * c)12329 mrb_load_nstring_cxt(mrb_state *mrb, const char *s, size_t len, mrbc_context *c)
12330 {
12331 return mrb_load_exec(mrb, mrb_parse_nstring(mrb, s, len, c), c);
12332 }
12333
12334 MRB_API mrb_value
mrb_load_nstring(mrb_state * mrb,const char * s,size_t len)12335 mrb_load_nstring(mrb_state *mrb, const char *s, size_t len)
12336 {
12337 return mrb_load_nstring_cxt(mrb, s, len, NULL);
12338 }
12339
12340 MRB_API mrb_value
mrb_load_string_cxt(mrb_state * mrb,const char * s,mrbc_context * c)12341 mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *c)
12342 {
12343 return mrb_load_nstring_cxt(mrb, s, strlen(s), c);
12344 }
12345
12346 MRB_API mrb_value
mrb_load_string(mrb_state * mrb,const char * s)12347 mrb_load_string(mrb_state *mrb, const char *s)
12348 {
12349 return mrb_load_string_cxt(mrb, s, NULL);
12350 }
12351
12352 #ifndef MRB_DISABLE_STDIO
12353
12354 static void
dump_prefix(node * tree,int offset)12355 dump_prefix(node *tree, int offset)
12356 {
12357 printf("%05d ", tree->lineno);
12358 while (offset--) {
12359 putc(' ', stdout);
12360 putc(' ', stdout);
12361 }
12362 }
12363
12364 static void
dump_recur(mrb_state * mrb,node * tree,int offset)12365 dump_recur(mrb_state *mrb, node *tree, int offset)
12366 {
12367 while (tree) {
12368 mrb_parser_dump(mrb, tree->car, offset);
12369 tree = tree->cdr;
12370 }
12371 }
12372
12373 static void
dump_args(mrb_state * mrb,node * n,int offset)12374 dump_args(mrb_state *mrb, node *n, int offset)
12375 {
12376 if (n->car) {
12377 dump_prefix(n, offset+1);
12378 printf("mandatory args:\n");
12379 dump_recur(mrb, n->car, offset+2);
12380 }
12381 n = n->cdr;
12382 if (n->car) {
12383 dump_prefix(n, offset+1);
12384 printf("optional args:\n");
12385 {
12386 node *n2 = n->car;
12387
12388 while (n2) {
12389 dump_prefix(n2, offset+2);
12390 printf("%s=\n", mrb_sym_name(mrb, sym(n2->car->car)));
12391 mrb_parser_dump(mrb, n2->car->cdr, offset+3);
12392 n2 = n2->cdr;
12393 }
12394 }
12395 }
12396 n = n->cdr;
12397 if (n->car) {
12398 dump_prefix(n, offset+1);
12399 printf("rest=*%s\n", mrb_sym_name(mrb, sym(n->car)));
12400 }
12401 n = n->cdr;
12402 if (n->car) {
12403 dump_prefix(n, offset+1);
12404 printf("post mandatory args:\n");
12405 dump_recur(mrb, n->car, offset+2);
12406 }
12407
12408 n = n->cdr;
12409 if (n) {
12410 mrb_assert(intn(n->car) == NODE_ARGS_TAIL);
12411 mrb_parser_dump(mrb, n, offset);
12412 }
12413 }
12414
12415 /*
12416 * This function restores the GC arena on return.
12417 * For this reason, if a process that further generates an object is
12418 * performed at the caller, the string pointer returned as the return
12419 * value may become invalid.
12420 */
12421 static const char*
str_dump(mrb_state * mrb,const char * str,int len)12422 str_dump(mrb_state *mrb, const char *str, int len)
12423 {
12424 int ai = mrb_gc_arena_save(mrb);
12425 mrb_value s;
12426 # if INT_MAX > MRB_INT_MAX / 4
12427 /* check maximum length with "\xNN" charactor */
12428 if (len > MRB_INT_MAX / 4) {
12429 len = MRB_INT_MAX / 4;
12430 }
12431 # endif
12432 s = mrb_str_new(mrb, str, (mrb_int)len);
12433 s = mrb_str_dump(mrb, s);
12434 mrb_gc_arena_restore(mrb, ai);
12435 return RSTRING_PTR(s);
12436 }
12437 #endif
12438
12439 void
mrb_parser_dump(mrb_state * mrb,node * tree,int offset)12440 mrb_parser_dump(mrb_state *mrb, node *tree, int offset)
12441 {
12442 #ifndef MRB_DISABLE_STDIO
12443 int nodetype;
12444
12445 if (!tree) return;
12446 again:
12447 dump_prefix(tree, offset);
12448 nodetype = intn(tree->car);
12449 tree = tree->cdr;
12450 switch (nodetype) {
12451 case NODE_BEGIN:
12452 printf("NODE_BEGIN:\n");
12453 dump_recur(mrb, tree, offset+1);
12454 break;
12455
12456 case NODE_RESCUE:
12457 printf("NODE_RESCUE:\n");
12458 if (tree->car) {
12459 dump_prefix(tree, offset+1);
12460 printf("body:\n");
12461 mrb_parser_dump(mrb, tree->car, offset+2);
12462 }
12463 tree = tree->cdr;
12464 if (tree->car) {
12465 node *n2 = tree->car;
12466
12467 dump_prefix(n2, offset+1);
12468 printf("rescue:\n");
12469 while (n2) {
12470 node *n3 = n2->car;
12471 if (n3->car) {
12472 dump_prefix(n2, offset+2);
12473 printf("handle classes:\n");
12474 dump_recur(mrb, n3->car, offset+3);
12475 }
12476 if (n3->cdr->car) {
12477 dump_prefix(n3, offset+2);
12478 printf("exc_var:\n");
12479 mrb_parser_dump(mrb, n3->cdr->car, offset+3);
12480 }
12481 if (n3->cdr->cdr->car) {
12482 dump_prefix(n3, offset+2);
12483 printf("rescue body:\n");
12484 mrb_parser_dump(mrb, n3->cdr->cdr->car, offset+3);
12485 }
12486 n2 = n2->cdr;
12487 }
12488 }
12489 tree = tree->cdr;
12490 if (tree->car) {
12491 dump_prefix(tree, offset+1);
12492 printf("else:\n");
12493 mrb_parser_dump(mrb, tree->car, offset+2);
12494 }
12495 break;
12496
12497 case NODE_ENSURE:
12498 printf("NODE_ENSURE:\n");
12499 dump_prefix(tree, offset+1);
12500 printf("body:\n");
12501 mrb_parser_dump(mrb, tree->car, offset+2);
12502 dump_prefix(tree, offset+1);
12503 printf("ensure:\n");
12504 mrb_parser_dump(mrb, tree->cdr->cdr, offset+2);
12505 break;
12506
12507 case NODE_LAMBDA:
12508 printf("NODE_LAMBDA:\n");
12509 dump_prefix(tree, offset);
12510 goto block;
12511
12512 case NODE_BLOCK:
12513 block:
12514 printf("NODE_BLOCK:\n");
12515 tree = tree->cdr;
12516 if (tree->car) {
12517 dump_args(mrb, tree->car, offset+1);
12518 }
12519 dump_prefix(tree, offset+1);
12520 printf("body:\n");
12521 mrb_parser_dump(mrb, tree->cdr->car, offset+2);
12522 break;
12523
12524 case NODE_IF:
12525 printf("NODE_IF:\n");
12526 dump_prefix(tree, offset+1);
12527 printf("cond:\n");
12528 mrb_parser_dump(mrb, tree->car, offset+2);
12529 dump_prefix(tree, offset+1);
12530 printf("then:\n");
12531 mrb_parser_dump(mrb, tree->cdr->car, offset+2);
12532 if (tree->cdr->cdr->car) {
12533 dump_prefix(tree, offset+1);
12534 printf("else:\n");
12535 mrb_parser_dump(mrb, tree->cdr->cdr->car, offset+2);
12536 }
12537 break;
12538
12539 case NODE_AND:
12540 printf("NODE_AND:\n");
12541 mrb_parser_dump(mrb, tree->car, offset+1);
12542 mrb_parser_dump(mrb, tree->cdr, offset+1);
12543 break;
12544
12545 case NODE_OR:
12546 printf("NODE_OR:\n");
12547 mrb_parser_dump(mrb, tree->car, offset+1);
12548 mrb_parser_dump(mrb, tree->cdr, offset+1);
12549 break;
12550
12551 case NODE_CASE:
12552 printf("NODE_CASE:\n");
12553 if (tree->car) {
12554 mrb_parser_dump(mrb, tree->car, offset+1);
12555 }
12556 tree = tree->cdr;
12557 while (tree) {
12558 dump_prefix(tree, offset+1);
12559 printf("case:\n");
12560 dump_recur(mrb, tree->car->car, offset+2);
12561 dump_prefix(tree, offset+1);
12562 printf("body:\n");
12563 mrb_parser_dump(mrb, tree->car->cdr, offset+2);
12564 tree = tree->cdr;
12565 }
12566 break;
12567
12568 case NODE_WHILE:
12569 printf("NODE_WHILE:\n");
12570 dump_prefix(tree, offset+1);
12571 printf("cond:\n");
12572 mrb_parser_dump(mrb, tree->car, offset+2);
12573 dump_prefix(tree, offset+1);
12574 printf("body:\n");
12575 mrb_parser_dump(mrb, tree->cdr, offset+2);
12576 break;
12577
12578 case NODE_UNTIL:
12579 printf("NODE_UNTIL:\n");
12580 dump_prefix(tree, offset+1);
12581 printf("cond:\n");
12582 mrb_parser_dump(mrb, tree->car, offset+2);
12583 dump_prefix(tree, offset+1);
12584 printf("body:\n");
12585 mrb_parser_dump(mrb, tree->cdr, offset+2);
12586 break;
12587
12588 case NODE_FOR:
12589 printf("NODE_FOR:\n");
12590 dump_prefix(tree, offset+1);
12591 printf("var:\n");
12592 {
12593 node *n2 = tree->car;
12594
12595 if (n2->car) {
12596 dump_prefix(n2, offset+2);
12597 printf("pre:\n");
12598 dump_recur(mrb, n2->car, offset+3);
12599 }
12600 n2 = n2->cdr;
12601 if (n2) {
12602 if (n2->car) {
12603 dump_prefix(n2, offset+2);
12604 printf("rest:\n");
12605 mrb_parser_dump(mrb, n2->car, offset+3);
12606 }
12607 n2 = n2->cdr;
12608 if (n2) {
12609 if (n2->car) {
12610 dump_prefix(n2, offset+2);
12611 printf("post:\n");
12612 dump_recur(mrb, n2->car, offset+3);
12613 }
12614 }
12615 }
12616 }
12617 tree = tree->cdr;
12618 dump_prefix(tree, offset+1);
12619 printf("in:\n");
12620 mrb_parser_dump(mrb, tree->car, offset+2);
12621 tree = tree->cdr;
12622 dump_prefix(tree, offset+1);
12623 printf("do:\n");
12624 mrb_parser_dump(mrb, tree->car, offset+2);
12625 break;
12626
12627 case NODE_SCOPE:
12628 printf("NODE_SCOPE:\n");
12629 {
12630 node *n2 = tree->car;
12631 mrb_bool first_lval = TRUE;
12632
12633 if (n2 && (n2->car || n2->cdr)) {
12634 dump_prefix(n2, offset+1);
12635 printf("local variables:\n");
12636 dump_prefix(n2, offset+2);
12637 while (n2) {
12638 if (n2->car) {
12639 if (!first_lval) printf(", ");
12640 printf("%s", mrb_sym_name(mrb, sym(n2->car)));
12641 first_lval = FALSE;
12642 }
12643 n2 = n2->cdr;
12644 }
12645 printf("\n");
12646 }
12647 }
12648 tree = tree->cdr;
12649 offset++;
12650 goto again;
12651
12652 case NODE_FCALL:
12653 case NODE_CALL:
12654 case NODE_SCALL:
12655 switch (nodetype) {
12656 case NODE_FCALL:
12657 printf("NODE_FCALL:\n"); break;
12658 case NODE_CALL:
12659 printf("NODE_CALL(.):\n"); break;
12660 case NODE_SCALL:
12661 printf("NODE_SCALL(&.):\n"); break;
12662 default:
12663 break;
12664 }
12665 mrb_parser_dump(mrb, tree->car, offset+1);
12666 dump_prefix(tree, offset+1);
12667 printf("method='%s' (%d)\n",
12668 mrb_sym_dump(mrb, sym(tree->cdr->car)),
12669 intn(tree->cdr->car));
12670 tree = tree->cdr->cdr->car;
12671 if (tree) {
12672 dump_prefix(tree, offset+1);
12673 printf("args:\n");
12674 dump_recur(mrb, tree->car, offset+2);
12675 if (tree->cdr) {
12676 dump_prefix(tree, offset+1);
12677 printf("block:\n");
12678 mrb_parser_dump(mrb, tree->cdr, offset+2);
12679 }
12680 }
12681 break;
12682
12683 case NODE_DOT2:
12684 printf("NODE_DOT2:\n");
12685 mrb_parser_dump(mrb, tree->car, offset+1);
12686 mrb_parser_dump(mrb, tree->cdr, offset+1);
12687 break;
12688
12689 case NODE_DOT3:
12690 printf("NODE_DOT3:\n");
12691 mrb_parser_dump(mrb, tree->car, offset+1);
12692 mrb_parser_dump(mrb, tree->cdr, offset+1);
12693 break;
12694
12695 case NODE_COLON2:
12696 printf("NODE_COLON2:\n");
12697 mrb_parser_dump(mrb, tree->car, offset+1);
12698 dump_prefix(tree, offset+1);
12699 printf("::%s\n", mrb_sym_name(mrb, sym(tree->cdr)));
12700 break;
12701
12702 case NODE_COLON3:
12703 printf("NODE_COLON3: ::%s\n", mrb_sym_name(mrb, sym(tree)));
12704 break;
12705
12706 case NODE_ARRAY:
12707 printf("NODE_ARRAY:\n");
12708 dump_recur(mrb, tree, offset+1);
12709 break;
12710
12711 case NODE_HASH:
12712 printf("NODE_HASH:\n");
12713 while (tree) {
12714 dump_prefix(tree, offset+1);
12715 printf("key:\n");
12716 mrb_parser_dump(mrb, tree->car->car, offset+2);
12717 dump_prefix(tree, offset+1);
12718 printf("value:\n");
12719 mrb_parser_dump(mrb, tree->car->cdr, offset+2);
12720 tree = tree->cdr;
12721 }
12722 break;
12723
12724 case NODE_KW_HASH:
12725 printf("NODE_KW_HASH:\n");
12726 while (tree) {
12727 dump_prefix(tree, offset+1);
12728 printf("key:\n");
12729 mrb_parser_dump(mrb, tree->car->car, offset+2);
12730 dump_prefix(tree, offset+1);
12731 printf("value:\n");
12732 mrb_parser_dump(mrb, tree->car->cdr, offset+2);
12733 tree = tree->cdr;
12734 }
12735 break;
12736
12737 case NODE_SPLAT:
12738 printf("NODE_SPLAT:\n");
12739 mrb_parser_dump(mrb, tree, offset+1);
12740 break;
12741
12742 case NODE_ASGN:
12743 printf("NODE_ASGN:\n");
12744 dump_prefix(tree, offset+1);
12745 printf("lhs:\n");
12746 mrb_parser_dump(mrb, tree->car, offset+2);
12747 dump_prefix(tree, offset+1);
12748 printf("rhs:\n");
12749 mrb_parser_dump(mrb, tree->cdr, offset+2);
12750 break;
12751
12752 case NODE_MASGN:
12753 printf("NODE_MASGN:\n");
12754 dump_prefix(tree, offset+1);
12755 printf("mlhs:\n");
12756 {
12757 node *n2 = tree->car;
12758
12759 if (n2->car) {
12760 dump_prefix(tree, offset+2);
12761 printf("pre:\n");
12762 dump_recur(mrb, n2->car, offset+3);
12763 }
12764 n2 = n2->cdr;
12765 if (n2) {
12766 if (n2->car) {
12767 dump_prefix(n2, offset+2);
12768 printf("rest:\n");
12769 if (n2->car == (node*)-1) {
12770 dump_prefix(n2, offset+2);
12771 printf("(empty)\n");
12772 }
12773 else {
12774 mrb_parser_dump(mrb, n2->car, offset+3);
12775 }
12776 }
12777 n2 = n2->cdr;
12778 if (n2) {
12779 if (n2->car) {
12780 dump_prefix(n2, offset+2);
12781 printf("post:\n");
12782 dump_recur(mrb, n2->car, offset+3);
12783 }
12784 }
12785 }
12786 }
12787 dump_prefix(tree, offset+1);
12788 printf("rhs:\n");
12789 mrb_parser_dump(mrb, tree->cdr, offset+2);
12790 break;
12791
12792 case NODE_OP_ASGN:
12793 printf("NODE_OP_ASGN:\n");
12794 dump_prefix(tree, offset+1);
12795 printf("lhs:\n");
12796 mrb_parser_dump(mrb, tree->car, offset+2);
12797 tree = tree->cdr;
12798 dump_prefix(tree, offset+1);
12799 printf("op='%s' (%d)\n", mrb_sym_name(mrb, sym(tree->car)), intn(tree->car));
12800 tree = tree->cdr;
12801 mrb_parser_dump(mrb, tree->car, offset+1);
12802 break;
12803
12804 case NODE_SUPER:
12805 printf("NODE_SUPER:\n");
12806 if (tree) {
12807 dump_prefix(tree, offset+1);
12808 printf("args:\n");
12809 dump_recur(mrb, tree->car, offset+2);
12810 if (tree->cdr) {
12811 dump_prefix(tree, offset+1);
12812 printf("block:\n");
12813 mrb_parser_dump(mrb, tree->cdr, offset+2);
12814 }
12815 }
12816 break;
12817
12818 case NODE_ZSUPER:
12819 printf("NODE_ZSUPER\n");
12820 break;
12821
12822 case NODE_RETURN:
12823 printf("NODE_RETURN:\n");
12824 mrb_parser_dump(mrb, tree, offset+1);
12825 break;
12826
12827 case NODE_YIELD:
12828 printf("NODE_YIELD:\n");
12829 dump_recur(mrb, tree, offset+1);
12830 break;
12831
12832 case NODE_BREAK:
12833 printf("NODE_BREAK:\n");
12834 mrb_parser_dump(mrb, tree, offset+1);
12835 break;
12836
12837 case NODE_NEXT:
12838 printf("NODE_NEXT:\n");
12839 mrb_parser_dump(mrb, tree, offset+1);
12840 break;
12841
12842 case NODE_REDO:
12843 printf("NODE_REDO\n");
12844 break;
12845
12846 case NODE_RETRY:
12847 printf("NODE_RETRY\n");
12848 break;
12849
12850 case NODE_LVAR:
12851 printf("NODE_LVAR %s\n", mrb_sym_name(mrb, sym(tree)));
12852 break;
12853
12854 case NODE_GVAR:
12855 printf("NODE_GVAR %s\n", mrb_sym_name(mrb, sym(tree)));
12856 break;
12857
12858 case NODE_IVAR:
12859 printf("NODE_IVAR %s\n", mrb_sym_name(mrb, sym(tree)));
12860 break;
12861
12862 case NODE_CVAR:
12863 printf("NODE_CVAR %s\n", mrb_sym_name(mrb, sym(tree)));
12864 break;
12865
12866 case NODE_NVAR:
12867 printf("NODE_NVAR %d\n", intn(tree));
12868 break;
12869
12870 case NODE_CONST:
12871 printf("NODE_CONST %s\n", mrb_sym_name(mrb, sym(tree)));
12872 break;
12873
12874 case NODE_MATCH:
12875 printf("NODE_MATCH:\n");
12876 dump_prefix(tree, offset + 1);
12877 printf("lhs:\n");
12878 mrb_parser_dump(mrb, tree->car, offset + 2);
12879 dump_prefix(tree, offset + 1);
12880 printf("rhs:\n");
12881 mrb_parser_dump(mrb, tree->cdr, offset + 2);
12882 break;
12883
12884 case NODE_BACK_REF:
12885 printf("NODE_BACK_REF: $%c\n", intn(tree));
12886 break;
12887
12888 case NODE_NTH_REF:
12889 printf("NODE_NTH_REF: $%d\n", intn(tree));
12890 break;
12891
12892 case NODE_ARG:
12893 printf("NODE_ARG %s\n", mrb_sym_name(mrb, sym(tree)));
12894 break;
12895
12896 case NODE_BLOCK_ARG:
12897 printf("NODE_BLOCK_ARG:\n");
12898 mrb_parser_dump(mrb, tree, offset+1);
12899 break;
12900
12901 case NODE_INT:
12902 printf("NODE_INT %s base %d\n", (char*)tree->car, intn(tree->cdr->car));
12903 break;
12904
12905 case NODE_FLOAT:
12906 printf("NODE_FLOAT %s\n", (char*)tree);
12907 break;
12908
12909 case NODE_NEGATE:
12910 printf("NODE_NEGATE:\n");
12911 mrb_parser_dump(mrb, tree, offset+1);
12912 break;
12913
12914 case NODE_STR:
12915 printf("NODE_STR %s len %d\n", str_dump(mrb, (char*)tree->car, intn(tree->cdr)), intn(tree->cdr));
12916 break;
12917
12918 case NODE_DSTR:
12919 printf("NODE_DSTR:\n");
12920 dump_recur(mrb, tree, offset+1);
12921 break;
12922
12923 case NODE_XSTR:
12924 printf("NODE_XSTR %s len %d\n", str_dump(mrb, (char*)tree->car, intn(tree->cdr)), intn(tree->cdr));
12925 break;
12926
12927 case NODE_DXSTR:
12928 printf("NODE_DXSTR:\n");
12929 dump_recur(mrb, tree, offset+1);
12930 break;
12931
12932 case NODE_REGX:
12933 printf("NODE_REGX /%s/%s\n", (char*)tree->car, (char*)tree->cdr);
12934 break;
12935
12936 case NODE_DREGX:
12937 printf("NODE_DREGX:\n");
12938 dump_recur(mrb, tree->car, offset+1);
12939 dump_prefix(tree, offset);
12940 printf("tail: %s\n", (char*)tree->cdr->cdr->car);
12941 if (tree->cdr->cdr->cdr->car) {
12942 dump_prefix(tree, offset);
12943 printf("opt: %s\n", (char*)tree->cdr->cdr->cdr->car);
12944 }
12945 if (tree->cdr->cdr->cdr->cdr) {
12946 dump_prefix(tree, offset);
12947 printf("enc: %s\n", (char*)tree->cdr->cdr->cdr->cdr);
12948 }
12949 break;
12950
12951 case NODE_SYM:
12952 printf("NODE_SYM :%s (%d)\n", mrb_sym_dump(mrb, sym(tree)),
12953 intn(tree));
12954 break;
12955
12956 case NODE_DSYM:
12957 printf("NODE_DSYM:\n");
12958 mrb_parser_dump(mrb, tree, offset+1);
12959 break;
12960
12961 case NODE_WORDS:
12962 printf("NODE_WORDS:\n");
12963 dump_recur(mrb, tree, offset+1);
12964 break;
12965
12966 case NODE_SYMBOLS:
12967 printf("NODE_SYMBOLS:\n");
12968 dump_recur(mrb, tree, offset+1);
12969 break;
12970
12971 case NODE_LITERAL_DELIM:
12972 printf("NODE_LITERAL_DELIM\n");
12973 break;
12974
12975 case NODE_SELF:
12976 printf("NODE_SELF\n");
12977 break;
12978
12979 case NODE_NIL:
12980 printf("NODE_NIL\n");
12981 break;
12982
12983 case NODE_TRUE:
12984 printf("NODE_TRUE\n");
12985 break;
12986
12987 case NODE_FALSE:
12988 printf("NODE_FALSE\n");
12989 break;
12990
12991 case NODE_ALIAS:
12992 printf("NODE_ALIAS %s %s:\n",
12993 mrb_sym_dump(mrb, sym(tree->car)),
12994 mrb_sym_dump(mrb, sym(tree->cdr)));
12995 break;
12996
12997 case NODE_UNDEF:
12998 printf("NODE_UNDEF");
12999 {
13000 node *t = tree;
13001 while (t) {
13002 printf(" %s", mrb_sym_dump(mrb, sym(t->car)));
13003 t = t->cdr;
13004 }
13005 }
13006 printf(":\n");
13007 break;
13008
13009 case NODE_CLASS:
13010 printf("NODE_CLASS:\n");
13011 if (tree->car->car == (node*)0) {
13012 dump_prefix(tree, offset+1);
13013 printf(":%s\n", mrb_sym_name(mrb, sym(tree->car->cdr)));
13014 }
13015 else if (tree->car->car == (node*)1) {
13016 dump_prefix(tree, offset+1);
13017 printf("::%s\n", mrb_sym_name(mrb, sym(tree->car->cdr)));
13018 }
13019 else {
13020 mrb_parser_dump(mrb, tree->car->car, offset+1);
13021 dump_prefix(tree, offset+1);
13022 printf("::%s\n", mrb_sym_name(mrb, sym(tree->car->cdr)));
13023 }
13024 if (tree->cdr->car) {
13025 dump_prefix(tree, offset+1);
13026 printf("super:\n");
13027 mrb_parser_dump(mrb, tree->cdr->car, offset+2);
13028 }
13029 dump_prefix(tree, offset+1);
13030 printf("body:\n");
13031 mrb_parser_dump(mrb, tree->cdr->cdr->car->cdr, offset+2);
13032 break;
13033
13034 case NODE_MODULE:
13035 printf("NODE_MODULE:\n");
13036 if (tree->car->car == (node*)0) {
13037 dump_prefix(tree, offset+1);
13038 printf(":%s\n", mrb_sym_name(mrb, sym(tree->car->cdr)));
13039 }
13040 else if (tree->car->car == (node*)1) {
13041 dump_prefix(tree, offset+1);
13042 printf("::%s\n", mrb_sym_name(mrb, sym(tree->car->cdr)));
13043 }
13044 else {
13045 mrb_parser_dump(mrb, tree->car->car, offset+1);
13046 dump_prefix(tree, offset+1);
13047 printf("::%s\n", mrb_sym_name(mrb, sym(tree->car->cdr)));
13048 }
13049 dump_prefix(tree, offset+1);
13050 printf("body:\n");
13051 mrb_parser_dump(mrb, tree->cdr->car->cdr, offset+2);
13052 break;
13053
13054 case NODE_SCLASS:
13055 printf("NODE_SCLASS:\n");
13056 mrb_parser_dump(mrb, tree->car, offset+1);
13057 dump_prefix(tree, offset+1);
13058 printf("body:\n");
13059 mrb_parser_dump(mrb, tree->cdr->car->cdr, offset+2);
13060 break;
13061
13062 case NODE_DEF:
13063 printf("NODE_DEF:\n");
13064 dump_prefix(tree, offset+1);
13065 printf("%s\n", mrb_sym_dump(mrb, sym(tree->car)));
13066 tree = tree->cdr;
13067 {
13068 node *n2 = tree->car;
13069 mrb_bool first_lval = TRUE;
13070
13071 if (n2 && (n2->car || n2->cdr)) {
13072 dump_prefix(n2, offset+1);
13073 printf("local variables:\n");
13074 dump_prefix(n2, offset+2);
13075 while (n2) {
13076 if (n2->car) {
13077 if (!first_lval) printf(", ");
13078 printf("%s", mrb_sym_name(mrb, sym(n2->car)));
13079 first_lval = FALSE;
13080 }
13081 n2 = n2->cdr;
13082 }
13083 printf("\n");
13084 }
13085 }
13086 tree = tree->cdr;
13087 if (tree->car) {
13088 dump_args(mrb, tree->car, offset);
13089 }
13090 mrb_parser_dump(mrb, tree->cdr->car, offset+1);
13091 break;
13092
13093 case NODE_SDEF:
13094 printf("NODE_SDEF:\n");
13095 mrb_parser_dump(mrb, tree->car, offset+1);
13096 tree = tree->cdr;
13097 dump_prefix(tree, offset+1);
13098 printf(":%s\n", mrb_sym_dump(mrb, sym(tree->car)));
13099 tree = tree->cdr->cdr;
13100 if (tree->car) {
13101 dump_args(mrb, tree->car, offset+1);
13102 }
13103 tree = tree->cdr;
13104 mrb_parser_dump(mrb, tree->car, offset+1);
13105 break;
13106
13107 case NODE_POSTEXE:
13108 printf("NODE_POSTEXE:\n");
13109 mrb_parser_dump(mrb, tree, offset+1);
13110 break;
13111
13112 case NODE_HEREDOC:
13113 printf("NODE_HEREDOC (<<%s):\n", ((parser_heredoc_info*)tree)->term);
13114 dump_recur(mrb, ((parser_heredoc_info*)tree)->doc, offset+1);
13115 break;
13116
13117 case NODE_ARGS_TAIL:
13118 printf("NODE_ARGS_TAIL:\n");
13119 {
13120 node *kws = tree->car;
13121
13122 while (kws) {
13123 mrb_parser_dump(mrb, kws->car, offset+1);
13124 kws = kws->cdr;
13125 }
13126 }
13127 tree = tree->cdr;
13128 if (tree->car) {
13129 mrb_assert(intn(tree->car->car) == NODE_KW_REST_ARGS);
13130 mrb_parser_dump(mrb, tree->car, offset+1);
13131 }
13132 tree = tree->cdr;
13133 if (tree->car) {
13134 dump_prefix(tree, offset+1);
13135 printf("block='%s'\n", mrb_sym_name(mrb, sym(tree->car)));
13136 }
13137 break;
13138
13139 case NODE_KW_ARG:
13140 printf("NODE_KW_ARG %s:\n", mrb_sym_name(mrb, sym(tree->car)));
13141 mrb_parser_dump(mrb, tree->cdr->car, offset + 1);
13142 break;
13143
13144 case NODE_KW_REST_ARGS:
13145 printf("NODE_KW_REST_ARGS %s\n", mrb_sym_name(mrb, sym(tree)));
13146 break;
13147
13148 default:
13149 printf("node type: %d (0x%x)\n", nodetype, (unsigned)nodetype);
13150 break;
13151 }
13152 #endif
13153 }
13154