?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge pull request #1039 from crimsonwoods/fix_the_type_of_opcode
[mruby.git] / src / parse.y
blob29ea34c59e32dca8fd4208048a025c5b0c64eff9
1 /*
2 ** parse.y - mruby parser
3 **
4 ** See Copyright Notice in mruby.h
5 */
6
7 %{
8 #undef PARSER_DEBUG
9
10 #define YYDEBUG 1
11 #define YYERROR_VERBOSE 1
12 /*
13 * Force yacc to use our memory management. This is a little evil because
14 * the macros assume that "parser_state *p" is in scope
15 */
16 #define YYMALLOC(n) mrb_malloc(p->mrb, (n))
17 #define YYFREE(o) mrb_free(p->mrb, (o))
18 #define YYSTACK_USE_ALLOCA 0
19
20 #include "mruby.h"
21 #include "mruby/compile.h"
22 #include "mruby/proc.h"
23 #include "node.h"
24
25 #include <errno.h>
26 #include <ctype.h>
27 #include <string.h>
28 #include <stdlib.h>
29
30 #define YYLEX_PARAM p
31
32 typedef mrb_ast_node node;
33 typedef struct mrb_parser_state parser_state;
34 typedef struct mrb_parser_heredoc_info parser_heredoc_info;
35
36 static int yylex(void *lval, parser_state *p);
37 static void yyerror(parser_state *p, const char *s);
38 static void yywarn(parser_state *p, const char *s);
39 static void yywarning(parser_state *p, const char *s);
40 static void backref_error(parser_state *p, node *n);
41
42 #define identchar(c) (isalnum(c) || (c) == '_' || !isascii(c))
43
44 typedef unsigned int stack_type;
45
46 #define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
47 #define BITSTACK_POP(stack) ((stack) = (stack) >> 1)
48 #define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
49 #define BITSTACK_SET_P(stack) ((stack)&1)
50
51 #define COND_PUSH(n) BITSTACK_PUSH(p->cond_stack, (n))
52 #define COND_POP() BITSTACK_POP(p->cond_stack)
53 #define COND_LEXPOP() BITSTACK_LEXPOP(p->cond_stack)
54 #define COND_P() BITSTACK_SET_P(p->cond_stack)
55
56 #define CMDARG_PUSH(n) BITSTACK_PUSH(p->cmdarg_stack, (n))
57 #define CMDARG_POP() BITSTACK_POP(p->cmdarg_stack)
58 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(p->cmdarg_stack)
59 #define CMDARG_P() BITSTACK_SET_P(p->cmdarg_stack)
60
61 #define sym(x) ((mrb_sym)(intptr_t)(x))
62 #define nsym(x) ((node*)(intptr_t)(x))
63
64 static inline mrb_sym
65 intern_gen(parser_state *p, const char *s)
66 {
67 return mrb_intern(p->mrb, s);
68 }
69 #define intern(s) intern_gen(p,(s))
70
71 static inline mrb_sym
72 intern_gen2(parser_state *p, const char *s, size_t len)
73 {
74 return mrb_intern2(p->mrb, s, len);
75 }
76 #define intern2(s,len) intern_gen2(p,(s),(len))
77
78 static inline mrb_sym
79 intern_gen_c(parser_state *p, const char c)
80 {
81 return mrb_intern2(p->mrb, &c, 1);
82 }
83 #define intern_c(c) intern_gen_c(p,(c))
84
85 static void
86 cons_free_gen(parser_state *p, node *cons)
87 {
88 cons->cdr = p->cells;
89 p->cells = cons;
90 }
91 #define cons_free(c) cons_free_gen(p, (c))
92
93 static void*
94 parser_palloc(parser_state *p, size_t size)
95 {
96 void *m = mrb_pool_alloc(p->pool, size);
97
98 if (!m) {
99 longjmp(p->jmp, 1);
100 }
101 return m;
102 }
103
104 static node*
105 cons_gen(parser_state *p, node *car, node *cdr)
106 {
107 node *c;
108
109 if (p->cells) {
110 c = p->cells;
111 p->cells = p->cells->cdr;
112 }
113 else {
114 c = (node *)parser_palloc(p, sizeof(mrb_ast_node));
115 }
116
117 c->car = car;
118 c->cdr = cdr;
119 c->lineno = p->lineno;
120 return c;
121 }
122 #define cons(a,b) cons_gen(p,(a),(b))
123
124 static node*
125 list1_gen(parser_state *p, node *a)
126 {
127 return cons(a, 0);
128 }
129 #define list1(a) list1_gen(p, (a))
130
131 static node*
132 list2_gen(parser_state *p, node *a, node *b)
133 {
134 return cons(a, cons(b,0));
135 }
136 #define list2(a,b) list2_gen(p, (a),(b))
137
138 static node*
139 list3_gen(parser_state *p, node *a, node *b, node *c)
140 {
141 return cons(a, cons(b, cons(c,0)));
142 }
143 #define list3(a,b,c) list3_gen(p, (a),(b),(c))
144
145 static node*
146 list4_gen(parser_state *p, node *a, node *b, node *c, node *d)
147 {
148 return cons(a, cons(b, cons(c, cons(d, 0))));
149 }
150 #define list4(a,b,c,d) list4_gen(p, (a),(b),(c),(d))
151
152 static node*
153 list5_gen(parser_state *p, node *a, node *b, node *c, node *d, node *e)
154 {
155 return cons(a, cons(b, cons(c, cons(d, cons(e, 0)))));
156 }
157 #define list5(a,b,c,d,e) list5_gen(p, (a),(b),(c),(d),(e))
158
159 static node*
160 list6_gen(parser_state *p, node *a, node *b, node *c, node *d, node *e, node *f)
161 {
162 return cons(a, cons(b, cons(c, cons(d, cons(e, cons(f, 0))))));
163 }
164 #define list6(a,b,c,d,e,f) list6_gen(p, (a),(b),(c),(d),(e),(f))
165
166 static node*
167 append_gen(parser_state *p, node *a, node *b)
168 {
169 node *c = a;
170
171 if (!a) return b;
172 while (c->cdr) {
173 c = c->cdr;
174 }
175 if (b) {
176 c->cdr = b;
177 }
178 return a;
179 }
180 #define append(a,b) append_gen(p,(a),(b))
181 #define push(a,b) append_gen(p,(a),list1(b))
182
183 static char*
184 parser_strndup(parser_state *p, const char *s, size_t len)
185 {
186 char *b = (char *)parser_palloc(p, len+1);
187
188 memcpy(b, s, len);
189 b[len] = '\0';
190 return b;
191 }
192 #define strndup(s,len) parser_strndup(p, s, len)
193
194 static char*
195 parser_strdup(parser_state *p, const char *s)
196 {
197 return parser_strndup(p, s, strlen(s));
198 }
199 #undef strdup
200 #define strdup(s) parser_strdup(p, s)
201
202 // xxx -----------------------------
203
204 static node*
205 local_switch(parser_state *p)
206 {
207 node *prev = p->locals;
208
209 p->locals = cons(0, 0);
210 return prev;
211 }
212
213 static void
214 local_resume(parser_state *p, node *prev)
215 {
216 p->locals = prev;
217 }
218
219 static void
220 local_nest(parser_state *p)
221 {
222 p->locals = cons(0, p->locals);
223 }
224
225 static void
226 local_unnest(parser_state *p)
227 {
228 p->locals = p->locals->cdr;
229 }
230
231 static int
232 local_var_p(parser_state *p, mrb_sym sym)
233 {
234 node *l = p->locals;
235
236 while (l) {
237 node *n = l->car;
238 while (n) {
239 if (sym(n->car) == sym) return 1;
240 n = n->cdr;
241 }
242 l = l->cdr;
243 }
244 return 0;
245 }
246
247 static void
248 local_add_f(parser_state *p, mrb_sym sym)
249 {
250 p->locals->car = push(p->locals->car, nsym(sym));
251 }
252
253 static void
254 local_add(parser_state *p, mrb_sym sym)
255 {
256 if (!local_var_p(p, sym)) {
257 local_add_f(p, sym);
258 }
259 }
260
261 // (:scope (vars..) (prog...))
262 static node*
263 new_scope(parser_state *p, node *body)
264 {
265 return cons((node*)NODE_SCOPE, cons(p->locals->car, body));
266 }
267
268 // (:begin prog...)
269 static node*
270 new_begin(parser_state *p, node *body)
271 {
272 if (body)
273 return list2((node*)NODE_BEGIN, body);
274 return cons((node*)NODE_BEGIN, 0);
275 }
276
277 #define newline_node(n) (n)
278
279 // (:rescue body rescue else)
280 static node*
281 new_rescue(parser_state *p, node *body, node *resq, node *els)
282 {
283 return list4((node*)NODE_RESCUE, body, resq, els);
284 }
285
286 // (:ensure body ensure)
287 static node*
288 new_ensure(parser_state *p, node *a, node *b)
289 {
290 return cons((node*)NODE_ENSURE, cons(a, cons(0, b)));
291 }
292
293 // (:nil)
294 static node*
295 new_nil(parser_state *p)
296 {
297 return list1((node*)NODE_NIL);
298 }
299
300 // (:true)
301 static node*
302 new_true(parser_state *p)
303 {
304 return list1((node*)NODE_TRUE);
305 }
306
307 // (:false)
308 static node*
309 new_false(parser_state *p)
310 {
311 return list1((node*)NODE_FALSE);
312 }
313
314 // (:alias new old)
315 static node*
316 new_alias(parser_state *p, mrb_sym a, mrb_sym b)
317 {
318 return cons((node*)NODE_ALIAS, cons(nsym(a), nsym(b)));
319 }
320
321 // (:if cond then else)
322 static node*
323 new_if(parser_state *p, node *a, node *b, node *c)
324 {
325 return list4((node*)NODE_IF, a, b, c);
326 }
327
328 // (:unless cond then else)
329 static node*
330 new_unless(parser_state *p, node *a, node *b, node *c)
331 {
332 return list4((node*)NODE_IF, a, c, b);
333 }
334
335 // (:while cond body)
336 static node*
337 new_while(parser_state *p, node *a, node *b)
338 {
339 return cons((node*)NODE_WHILE, cons(a, b));
340 }
341
342 // (:until cond body)
343 static node*
344 new_until(parser_state *p, node *a, node *b)
345 {
346 return cons((node*)NODE_UNTIL, cons(a, b));
347 }
348
349 // (:for var obj body)
350 static node*
351 new_for(parser_state *p, node *v, node *o, node *b)
352 {
353 return list4((node*)NODE_FOR, v, o, b);
354 }
355
356 // (:case a ((when ...) body) ((when...) body))
357 static node*
358 new_case(parser_state *p, node *a, node *b)
359 {
360 node *n = list2((node*)NODE_CASE, a);
361 node *n2 = n;
362
363 while (n2->cdr) {
364 n2 = n2->cdr;
365 }
366 n2->cdr = b;
367 return n;
368 }
369
370 // (:postexe a)
371 static node*
372 new_postexe(parser_state *p, node *a)
373 {
374 return cons((node*)NODE_POSTEXE, a);
375 }
376
377 // (:self)
378 static node*
379 new_self(parser_state *p)
380 {
381 return list1((node*)NODE_SELF);
382 }
383
384 // (:call a b c)
385 static node*
386 new_call(parser_state *p, node *a, mrb_sym b, node *c)
387 {
388 return list4((node*)NODE_CALL, a, nsym(b), c);
389 }
390
391 // (:fcall self mid args)
392 static node*
393 new_fcall(parser_state *p, mrb_sym b, node *c)
394 {
395 return list4((node*)NODE_FCALL, new_self(p), nsym(b), c);
396 }
397
398 #if 0
399 // (:vcall self mid)
400 static node*
401 new_vcall(parser_state *p, mrb_sym b)
402 {
403 return list3((node*)NODE_VCALL, new_self(p), (node*)b);
404 }
405 #endif
406
407 // (:super . c)
408 static node*
409 new_super(parser_state *p, node *c)
410 {
411 return cons((node*)NODE_SUPER, c);
412 }
413
414 // (:zsuper)
415 static node*
416 new_zsuper(parser_state *p)
417 {
418 return list1((node*)NODE_ZSUPER);
419 }
420
421 // (:yield . c)
422 static node*
423 new_yield(parser_state *p, node *c)
424 {
425 if (c) {
426 if (c->cdr) {
427 yyerror(p, "both block arg and actual block given");
428 }
429 return cons((node*)NODE_YIELD, c->car);
430 }
431 return cons((node*)NODE_YIELD, 0);
432 }
433
434 // (:return . c)
435 static node*
436 new_return(parser_state *p, node *c)
437 {
438 return cons((node*)NODE_RETURN, c);
439 }
440
441 // (:break . c)
442 static node*
443 new_break(parser_state *p, node *c)
444 {
445 return cons((node*)NODE_BREAK, c);
446 }
447
448 // (:next . c)
449 static node*
450 new_next(parser_state *p, node *c)
451 {
452 return cons((node*)NODE_NEXT, c);
453 }
454
455 // (:redo)
456 static node*
457 new_redo(parser_state *p)
458 {
459 return list1((node*)NODE_REDO);
460 }
461
462 // (:retry)
463 static node*
464 new_retry(parser_state *p)
465 {
466 return list1((node*)NODE_RETRY);
467 }
468
469 // (:dot2 a b)
470 static node*
471 new_dot2(parser_state *p, node *a, node *b)
472 {
473 return cons((node*)NODE_DOT2, cons(a, b));
474 }
475
476 // (:dot3 a b)
477 static node*
478 new_dot3(parser_state *p, node *a, node *b)
479 {
480 return cons((node*)NODE_DOT3, cons(a, b));
481 }
482
483 // (:colon2 b c)
484 static node*
485 new_colon2(parser_state *p, node *b, mrb_sym c)
486 {
487 return cons((node*)NODE_COLON2, cons(b, nsym(c)));
488 }
489
490 // (:colon3 . c)
491 static node*
492 new_colon3(parser_state *p, mrb_sym c)
493 {
494 return cons((node*)NODE_COLON3, nsym(c));
495 }
496
497 // (:and a b)
498 static node*
499 new_and(parser_state *p, node *a, node *b)
500 {
501 return cons((node*)NODE_AND, cons(a, b));
502 }
503
504 // (:or a b)
505 static node*
506 new_or(parser_state *p, node *a, node *b)
507 {
508 return cons((node*)NODE_OR, cons(a, b));
509 }
510
511 // (:array a...)
512 static node*
513 new_array(parser_state *p, node *a)
514 {
515 return cons((node*)NODE_ARRAY, a);
516 }
517
518 // (:splat . a)
519 static node*
520 new_splat(parser_state *p, node *a)
521 {
522 return cons((node*)NODE_SPLAT, a);
523 }
524
525 // (:hash (k . v) (k . v)...)
526 static node*
527 new_hash(parser_state *p, node *a)
528 {
529 return cons((node*)NODE_HASH, a);
530 }
531
532 // (:sym . a)
533 static node*
534 new_sym(parser_state *p, mrb_sym sym)
535 {
536 return cons((node*)NODE_SYM, nsym(sym));
537 }
538
539 static mrb_sym
540 new_strsym(parser_state *p, node* str)
541 {
542 const char *s = (const char*)str->cdr->car;
543 size_t len = (size_t)str->cdr->cdr;
544
545 return mrb_intern2(p->mrb, s, len);
546 }
547
548 // (:lvar . a)
549 static node*
550 new_lvar(parser_state *p, mrb_sym sym)
551 {
552 return cons((node*)NODE_LVAR, nsym(sym));
553 }
554
555 // (:gvar . a)
556 static node*
557 new_gvar(parser_state *p, mrb_sym sym)
558 {
559 return cons((node*)NODE_GVAR, nsym(sym));
560 }
561
562 // (:ivar . a)
563 static node*
564 new_ivar(parser_state *p, mrb_sym sym)
565 {
566 return cons((node*)NODE_IVAR, nsym(sym));
567 }
568
569 // (:cvar . a)
570 static node*
571 new_cvar(parser_state *p, mrb_sym sym)
572 {
573 return cons((node*)NODE_CVAR, nsym(sym));
574 }
575
576 // (:const . a)
577 static node*
578 new_const(parser_state *p, mrb_sym sym)
579 {
580 return cons((node*)NODE_CONST, nsym(sym));
581 }
582
583 // (:undef a...)
584 static node*
585 new_undef(parser_state *p, mrb_sym sym)
586 {
587 return list2((node*)NODE_UNDEF, nsym(sym));
588 }
589
590 // (:class class super body)
591 static node*
592 new_class(parser_state *p, node *c, node *s, node *b)
593 {
594 return list4((node*)NODE_CLASS, c, s, cons(p->locals->car, b));
595 }
596
597 // (:sclass obj body)
598 static node*
599 new_sclass(parser_state *p, node *o, node *b)
600 {
601 return list3((node*)NODE_SCLASS, o, cons(p->locals->car, b));
602 }
603
604 // (:module module body)
605 static node*
606 new_module(parser_state *p, node *m, node *b)
607 {
608 return list3((node*)NODE_MODULE, m, cons(p->locals->car, b));
609 }
610
611 // (:def m lv (arg . body))
612 static node*
613 new_def(parser_state *p, mrb_sym m, node *a, node *b)
614 {
615 return list5((node*)NODE_DEF, nsym(m), p->locals->car, a, b);
616 }
617
618 // (:sdef obj m lv (arg . body))
619 static node*
620 new_sdef(parser_state *p, node *o, mrb_sym m, node *a, node *b)
621 {
622 return list6((node*)NODE_SDEF, o, nsym(m), p->locals->car, a, b);
623 }
624
625 // (:arg . sym)
626 static node*
627 new_arg(parser_state *p, mrb_sym sym)
628 {
629 return cons((node*)NODE_ARG, nsym(sym));
630 }
631
632 // (m o r m2 b)
633 // m: (a b c)
634 // o: ((a . e1) (b . e2))
635 // r: a
636 // m2: (a b c)
637 // b: a
638 static node*
639 new_args(parser_state *p, node *m, node *opt, mrb_sym rest, node *m2, mrb_sym blk)
640 {
641 node *n;
642
643 n = cons(m2, nsym(blk));
644 n = cons(nsym(rest), n);
645 n = cons(opt, n);
646 return cons(m, n);
647 }
648
649 // (:block_arg . a)
650 static node*
651 new_block_arg(parser_state *p, node *a)
652 {
653 return cons((node*)NODE_BLOCK_ARG, a);
654 }
655
656 // (:block arg body)
657 static node*
658 new_block(parser_state *p, node *a, node *b)
659 {
660 return list4((node*)NODE_BLOCK, p->locals->car, a, b);
661 }
662
663 // (:lambda arg body)
664 static node*
665 new_lambda(parser_state *p, node *a, node *b)
666 {
667 return list4((node*)NODE_LAMBDA, p->locals->car, a, b);
668 }
669
670 // (:asgn lhs rhs)
671 static node*
672 new_asgn(parser_state *p, node *a, node *b)
673 {
674 return cons((node*)NODE_ASGN, cons(a, b));
675 }
676
677 // (:masgn mlhs=(pre rest post) mrhs)
678 static node*
679 new_masgn(parser_state *p, node *a, node *b)
680 {
681 return cons((node*)NODE_MASGN, cons(a, b));
682 }
683
684 // (:asgn lhs rhs)
685 static node*
686 new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b)
687 {
688 return list4((node*)NODE_OP_ASGN, a, nsym(op), b);
689 }
690
691 // (:int . i)
692 static node*
693 new_int(parser_state *p, const char *s, int base)
694 {
695 return list3((node*)NODE_INT, (node*)strdup(s), (node*)(intptr_t)base);
696 }
697
698 // (:float . i)
699 static node*
700 new_float(parser_state *p, const char *s)
701 {
702 return cons((node*)NODE_FLOAT, (node*)strdup(s));
703 }
704
705 // (:str . (s . len))
706 static node*
707 new_str(parser_state *p, const char *s, int len)
708 {
709 return cons((node*)NODE_STR, cons((node*)strndup(s, len), (node*)(intptr_t)len));
710 }
711
712 // (:dstr . a)
713 static node*
714 new_dstr(parser_state *p, node *a)
715 {
716 return cons((node*)NODE_DSTR, a);
717 }
718
719 // (:str . (s . len))
720 static node*
721 new_xstr(parser_state *p, const char *s, int len)
722 {
723 return cons((node*)NODE_XSTR, cons((node*)strndup(s, len), (node*)(intptr_t)len));
724 }
725
726 // (:xstr . a)
727 static node*
728 new_dxstr(parser_state *p, node *a)
729 {
730 return cons((node*)NODE_DXSTR, a);
731 }
732
733 // (:dsym . a)
734 static node*
735 new_dsym(parser_state *p, node *a)
736 {
737 return cons((node*)NODE_DSYM, new_dstr(p, a));
738 }
739
740 // (:str . (a . a))
741 static node*
742 new_regx(parser_state *p, const char *p1, const char* p2)
743 {
744 return cons((node*)NODE_REGX, cons((node*)p1, (node*)p2));
745 }
746
747 // (:dregx . a)
748 static node*
749 new_dregx(parser_state *p, node *a, node *b)
750 {
751 return cons((node*)NODE_DREGX, cons(a, b));
752 }
753
754 // (:backref . n)
755 static node*
756 new_back_ref(parser_state *p, int n)
757 {
758 return cons((node*)NODE_BACK_REF, (node*)(intptr_t)n);
759 }
760
761 // (:nthref . n)
762 static node*
763 new_nth_ref(parser_state *p, int n)
764 {
765 return cons((node*)NODE_NTH_REF, (node*)(intptr_t)n);
766 }
767
768 // (:heredoc . a)
769 static node*
770 new_heredoc(parser_state *p)
771 {
772 parser_heredoc_info *inf = parser_palloc(p, sizeof(parser_heredoc_info));
773 return cons((node*)NODE_HEREDOC, (node*)inf);
774 }
775
776 static void
777 new_bv(parser_state *p, mrb_sym id)
778 {
779 }
780
781 static node*
782 new_literal_delim(parser_state *p)
783 {
784 return cons((node*)NODE_LITERAL_DELIM, 0);
785 }
786
787 // (:words . a)
788 static node*
789 new_words(parser_state *p, node *a)
790 {
791 return cons((node*)NODE_WORDS, a);
792 }
793
794 // (:symbols . a)
795 static node*
796 new_symbols(parser_state *p, node *a)
797 {
798 return cons((node*)NODE_SYMBOLS, a);
799 }
800
801 // xxx -----------------------------
802
803 // (:call a op)
804 static node*
805 call_uni_op(parser_state *p, node *recv, char *m)
806 {
807 return new_call(p, recv, intern(m), 0);
808 }
809
810 // (:call a op b)
811 static node*
812 call_bin_op(parser_state *p, node *recv, char *m, node *arg1)
813 {
814 return new_call(p, recv, intern(m), list1(list1(arg1)));
815 }
816
817 static void
818 args_with_block(parser_state *p, node *a, node *b)
819 {
820 if (b) {
821 if (a->cdr) {
822 yyerror(p, "both block arg and actual block given");
823 }
824 a->cdr = b;
825 }
826 }
827
828 static void
829 call_with_block(parser_state *p, node *a, node *b)
830 {
831 node *n;
832
833 if (a->car == (node*)NODE_SUPER ||
834 a->car == (node*)NODE_ZSUPER) {
835 if (!a->cdr) a->cdr = cons(0, b);
836 else {
837 args_with_block(p, a->cdr, b);
838 }
839 }
840 else {
841 n = a->cdr->cdr->cdr;
842 if (!n->car) n->car = cons(0, b);
843 else {
844 args_with_block(p, n->car, b);
845 }
846 }
847 }
848
849 static node*
850 negate_lit(parser_state *p, node *n)
851 {
852 return cons((node*)NODE_NEGATE, n);
853 }
854
855 static node*
856 cond(node *n)
857 {
858 return n;
859 }
860
861 static node*
862 ret_args(parser_state *p, node *n)
863 {
864 if (n->cdr) {
865 yyerror(p, "block argument should not be given");
866 }
867 if (!n->car->cdr) return n->car->car;
868 return new_array(p, n->car);
869 }
870
871 static void
872 assignable(parser_state *p, node *lhs)
873 {
874 if ((int)(intptr_t)lhs->car == NODE_LVAR) {
875 local_add(p, sym(lhs->cdr));
876 }
877 }
878
879 static node*
880 var_reference(parser_state *p, node *lhs)
881 {
882 node *n;
883
884 if ((int)(intptr_t)lhs->car == NODE_LVAR) {
885 if (!local_var_p(p, sym(lhs->cdr))) {
886 n = new_fcall(p, sym(lhs->cdr), 0);
887 cons_free(lhs);
888 return n;
889 }
890 }
891
892 return lhs;
893 }
894
895 typedef enum mrb_string_type string_type;
896
897 static node*
898 new_strterm(parser_state *p, string_type type, int term, int paren)
899 {
900 return cons((node*)(intptr_t)type, cons((node*)0, cons((node*)(intptr_t)paren, (node*)(intptr_t)term)));
901 }
902
903 static void
904 end_strterm(parser_state *p)
905 {
906 cons_free(p->lex_strterm->cdr->cdr);
907 cons_free(p->lex_strterm->cdr);
908 cons_free(p->lex_strterm);
909 p->lex_strterm = NULL;
910 }
911
912 parser_heredoc_info *
913 parsing_heredoc_inf(parser_state *p)
914 {
915 node *nd = p->parsing_heredoc;
916 if (nd == NULL)
917 return NULL;
918 /* assert(nd->car->car == NODE_HEREDOC); */
919 return (parser_heredoc_info*)nd->car->cdr;
920 }
921
922 static void
923 heredoc_end(parser_state *p)
924 {
925 p->parsing_heredoc = p->parsing_heredoc->cdr;
926 if (p->parsing_heredoc == NULL) {
927 p->lstate = EXPR_BEG;
928 p->cmd_start = TRUE;
929 end_strterm(p);
930 p->heredoc_end_now = TRUE;
931 } else {
932 /* next heredoc */
933 p->lex_strterm->car = (node*)(intptr_t)parsing_heredoc_inf(p)->type;
934 }
935 }
936 #define is_strterm_type(p,str_func) ((int)(intptr_t)((p)->lex_strterm->car) & (str_func))
937
938 // xxx -----------------------------
939
940 %}
941
942 %pure_parser
943 %parse-param {parser_state *p}
944 %lex-param {parser_state *p}
945
946 %union {
947 node *nd;
948 mrb_sym id;
949 int num;
950 unsigned int stack;
951 const struct vtable *vars;
952 }
953
954 %token
955 keyword_class
956 keyword_module
957 keyword_def
958 keyword_undef
959 keyword_begin
960 keyword_rescue
961 keyword_ensure
962 keyword_end
963 keyword_if
964 keyword_unless
965 keyword_then
966 keyword_elsif
967 keyword_else
968 keyword_case
969 keyword_when
970 keyword_while
971 keyword_until
972 keyword_for
973 keyword_break
974 keyword_next
975 keyword_redo
976 keyword_retry
977 keyword_in
978 keyword_do
979 keyword_do_cond
980 keyword_do_block
981 keyword_do_LAMBDA
982 keyword_return
983 keyword_yield
984 keyword_super
985 keyword_self
986 keyword_nil
987 keyword_true
988 keyword_false
989 keyword_and
990 keyword_or
991 keyword_not
992 modifier_if
993 modifier_unless
994 modifier_while
995 modifier_until
996 modifier_rescue
997 keyword_alias
998 keyword_BEGIN
999 keyword_END
1000 keyword__LINE__
1001 keyword__FILE__
1002 keyword__ENCODING__
1003
1004 %token <id> tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tCVAR tLABEL
1005 %token <nd> tINTEGER tFLOAT tCHAR tXSTRING tREGEXP
1006 %token <nd> tSTRING tSTRING_PART tSTRING_MID
1007 %token <nd> tNTH_REF tBACK_REF
1008 %token <num> tREGEXP_END
1009
1010 %type <nd> singleton string string_rep string_interp xstring regexp
1011 %type <nd> literal numeric cpath symbol
1012 %type <nd> top_compstmt top_stmts top_stmt
1013 %type <nd> bodystmt compstmt stmts stmt expr arg primary command command_call method_call
1014 %type <nd> expr_value arg_value primary_value
1015 %type <nd> if_tail opt_else case_body cases opt_rescue exc_list exc_var opt_ensure
1016 %type <nd> args call_args opt_call_args
1017 %type <nd> paren_args opt_paren_args variable
1018 %type <nd> command_args aref_args opt_block_arg block_arg var_ref var_lhs
1019 %type <nd> command_asgn mrhs superclass block_call block_command
1020 %type <nd> f_block_optarg f_block_opt
1021 %type <nd> f_arglist f_args f_arg f_arg_item f_optarg f_marg f_marg_list f_margs
1022 %type <nd> assoc_list assocs assoc undef_list backref for_var
1023 %type <nd> block_param opt_block_param block_param_def f_opt
1024 %type <nd> bv_decls opt_bv_decl bvar f_larglist lambda_body
1025 %type <nd> brace_block cmd_brace_block do_block lhs none f_bad_arg
1026 %type <nd> mlhs mlhs_list mlhs_post mlhs_basic mlhs_item mlhs_node mlhs_inner
1027 %type <id> fsym sym basic_symbol operation operation2 operation3
1028 %type <id> cname fname op f_rest_arg f_block_arg opt_f_block_arg f_norm_arg
1029 %type <nd> heredoc words symbols
1030
1031 %token tUPLUS /* unary+ */
1032 %token tUMINUS /* unary- */
1033 %token tPOW /* ** */
1034 %token tCMP /* <=> */
1035 %token tEQ /* == */
1036 %token tEQQ /* === */
1037 %token tNEQ /* != */
1038 %token tGEQ /* >= */
1039 %token tLEQ /* <= */
1040 %token tANDOP tOROP /* && and || */
1041 %token tMATCH tNMATCH /* =~ and !~ */
1042 %token tDOT2 tDOT3 /* .. and ... */
1043 %token tAREF tASET /* [] and []= */
1044 %token tLSHFT tRSHFT /* << and >> */
1045 %token tCOLON2 /* :: */
1046 %token tCOLON3 /* :: at EXPR_BEG */
1047 %token <id> tOP_ASGN /* +=, -= etc. */
1048 %token tASSOC /* => */
1049 %token tLPAREN /* ( */
1050 %token tLPAREN_ARG /* ( */
1051 %token tRPAREN /* ) */
1052 %token tLBRACK /* [ */
1053 %token tLBRACE /* { */
1054 %token tLBRACE_ARG /* { */
1055 %token tSTAR /* * */
1056 %token tAMPER /* & */
1057 %token tLAMBDA /* -> */
1058 %token tSYMBEG tREGEXP_BEG tWORDS_BEG tSYMBOLS_BEG
1059 %token tSTRING_BEG tXSTRING_BEG tSTRING_DVAR tLAMBEG
1060 %token <nd> tHEREDOC_BEG /* <<, <<- */
1061 %token tHEREDOC_END tLITERAL_DELIM
1062
1063 /*
1064 * precedence table
1065 */
1066
1067 %nonassoc tLOWEST
1068 %nonassoc tLBRACE_ARG
1069
1070 %nonassoc modifier_if modifier_unless modifier_while modifier_until
1071 %left keyword_or keyword_and
1072 %right keyword_not
1073 %right '=' tOP_ASGN
1074 %left modifier_rescue
1075 %right '?' ':'
1076 %nonassoc tDOT2 tDOT3
1077 %left tOROP
1078 %left tANDOP
1079 %nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
1080 %left '>' tGEQ '<' tLEQ
1081 %left '|' '^'
1082 %left '&'
1083 %left tLSHFT tRSHFT
1084 %left '+' '-'
1085 %left '*' '/' '%'
1086 %right tUMINUS_NUM tUMINUS
1087 %right tPOW
1088 %right '!' '~' tUPLUS
1089
1090 %nonassoc idNULL
1091 %nonassoc idRespond_to
1092 %nonassoc idIFUNC
1093 %nonassoc idCFUNC
1094 %nonassoc id_core_set_method_alias
1095 %nonassoc id_core_set_variable_alias
1096 %nonassoc id_core_undef_method
1097 %nonassoc id_core_define_method
1098 %nonassoc id_core_define_singleton_method
1099 %nonassoc id_core_set_postexe
1100
1101 %token tLAST_TOKEN
1102
1103 %%
1104 program : {
1105 p->lstate = EXPR_BEG;
1106 if (!p->locals) p->locals = cons(0,0);
1107 }
1108 top_compstmt
1109 {
1110 p->tree = new_scope(p, $2);
1111 }
1112 ;
1113
1114 top_compstmt : top_stmts opt_terms
1115 {
1116 $$ = $1;
1117 }
1118 ;
1119
1120 top_stmts : none
1121 {
1122 $$ = new_begin(p, 0);
1123 }
1124 | top_stmt
1125 {
1126 $$ = new_begin(p, $1);
1127 }
1128 | top_stmts terms top_stmt
1129 {
1130 $$ = push($1, newline_node($3));
1131 }
1132 | error top_stmt
1133 {
1134 $$ = new_begin(p, 0);
1135 }
1136 ;
1137
1138 top_stmt : stmt
1139 | keyword_BEGIN
1140 {
1141 $<nd>$ = local_switch(p);
1142 }
1143 '{' top_compstmt '}'
1144 {
1145 yyerror(p, "BEGIN not supported");
1146 local_resume(p, $<nd>2);
1147 $$ = 0;
1148 }
1149 ;
1150
1151 bodystmt : compstmt
1152 opt_rescue
1153 opt_else
1154 opt_ensure
1155 {
1156 if ($2) {
1157 $$ = new_rescue(p, $1, $2, $3);
1158 }
1159 else if ($3) {
1160 yywarn(p, "else without rescue is useless");
1161 $$ = push($1, $3);
1162 }
1163 else {
1164 $$ = $1;
1165 }
1166 if ($4) {
1167 if ($$) {
1168 $$ = new_ensure(p, $$, $4);
1169 }
1170 else {
1171 $$ = push($4, new_nil(p));
1172 }
1173 }
1174 }
1175 ;
1176
1177 compstmt : stmts opt_terms
1178 {
1179 $$ = $1;
1180 }
1181 ;
1182
1183 stmts : none
1184 {
1185 $$ = new_begin(p, 0);
1186 }
1187 | stmt
1188 {
1189 $$ = new_begin(p, $1);
1190 }
1191 | stmts terms stmt
1192 {
1193 $$ = push($1, newline_node($3));
1194 }
1195 | error stmt
1196 {
1197 $$ = new_begin(p, $2);
1198 }
1199 ;
1200
1201 stmt : keyword_alias fsym {p->lstate = EXPR_FNAME;} fsym
1202 {
1203 $$ = new_alias(p, $2, $4);
1204 }
1205 | keyword_undef undef_list
1206 {
1207 $$ = $2;
1208 }
1209 | stmt modifier_if expr_value
1210 {
1211 $$ = new_if(p, cond($3), $1, 0);
1212 }
1213 | stmt modifier_unless expr_value
1214 {
1215 $$ = new_unless(p, cond($3), $1, 0);
1216 }
1217 | stmt modifier_while expr_value
1218 {
1219 $$ = new_while(p, cond($3), $1);
1220 }
1221 | stmt modifier_until expr_value
1222 {
1223 $$ = new_until(p, cond($3), $1);
1224 }
1225 | stmt modifier_rescue stmt
1226 {
1227 $$ = new_rescue(p, $1, list1(list3(0, 0, $3)), 0);
1228 }
1229 | keyword_END '{' compstmt '}'
1230 {
1231 yyerror(p, "END not suported");
1232 $$ = new_postexe(p, $3);
1233 }
1234 | command_asgn
1235 | mlhs '=' command_call
1236 {
1237 $$ = new_masgn(p, $1, $3);
1238 }
1239 | var_lhs tOP_ASGN command_call
1240 {
1241 $$ = new_op_asgn(p, $1, $2, $3);
1242 }
1243 | primary_value '[' opt_call_args rbracket tOP_ASGN command_call
1244 {
1245 $$ = new_op_asgn(p, new_call(p, $1, intern2("[]",2), $3), $5, $6);
1246 }
1247 | primary_value '.' tIDENTIFIER tOP_ASGN command_call
1248 {
1249 $$ = new_op_asgn(p, new_call(p, $1, $3, 0), $4, $5);
1250 }
1251 | primary_value '.' tCONSTANT tOP_ASGN command_call
1252 {
1253 $$ = new_op_asgn(p, new_call(p, $1, $3, 0), $4, $5);
1254 }
1255 | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
1256 {
1257 yyerror(p, "constant re-assignment");
1258 $$ = 0;
1259 }
1260 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
1261 {
1262 $$ = new_op_asgn(p, new_call(p, $1, $3, 0), $4, $5);
1263 }
1264 | backref tOP_ASGN command_call
1265 {
1266 backref_error(p, $1);
1267 $$ = new_begin(p, 0);
1268 }
1269 | lhs '=' mrhs
1270 {
1271 $$ = new_asgn(p, $1, new_array(p, $3));
1272 }
1273 | mlhs '=' arg_value
1274 {
1275 $$ = new_masgn(p, $1, $3);
1276 }
1277 | mlhs '=' mrhs
1278 {
1279 $$ = new_masgn(p, $1, new_array(p, $3));
1280 }
1281 | expr
1282 ;
1283
1284 command_asgn : lhs '=' command_call
1285 {
1286 $$ = new_asgn(p, $1, $3);
1287 }
1288 | lhs '=' command_asgn
1289 {
1290 $$ = new_asgn(p, $1, $3);
1291 }
1292 ;
1293
1294
1295 expr : command_call
1296 | expr keyword_and expr
1297 {
1298 $$ = new_and(p, $1, $3);
1299 }
1300 | expr keyword_or expr
1301 {
1302 $$ = new_or(p, $1, $3);
1303 }
1304 | keyword_not opt_nl expr
1305 {
1306 $$ = call_uni_op(p, cond($3), "!");
1307 }
1308 | '!' command_call
1309 {
1310 $$ = call_uni_op(p, cond($2), "!");
1311 }
1312 | arg
1313 ;
1314
1315 expr_value : expr
1316 {
1317 if (!$1) $$ = new_nil(p);
1318 else $$ = $1;
1319 }
1320 ;
1321
1322 command_call : command
1323 | block_command
1324 ;
1325
1326 block_command : block_call
1327 | block_call dot_or_colon operation2 command_args
1328 ;
1329
1330 cmd_brace_block : tLBRACE_ARG
1331 {
1332 local_nest(p);
1333 }
1334 opt_block_param
1335 compstmt
1336 '}'
1337 {
1338 $$ = new_block(p, $3, $4);
1339 local_unnest(p);
1340 }
1341 ;
1342
1343 command : operation command_args %prec tLOWEST
1344 {
1345 $$ = new_fcall(p, $1, $2);
1346 }
1347 | operation command_args cmd_brace_block
1348 {
1349 args_with_block(p, $2, $3);
1350 $$ = new_fcall(p, $1, $2);
1351 }
1352 | primary_value '.' operation2 command_args %prec tLOWEST
1353 {
1354 $$ = new_call(p, $1, $3, $4);
1355 }
1356 | primary_value '.' operation2 command_args cmd_brace_block
1357 {
1358 args_with_block(p, $4, $5);
1359 $$ = new_call(p, $1, $3, $4);
1360 }
1361 | primary_value tCOLON2 operation2 command_args %prec tLOWEST
1362 {
1363 $$ = new_call(p, $1, $3, $4);
1364 }
1365 | primary_value tCOLON2 operation2 command_args cmd_brace_block
1366 {
1367 args_with_block(p, $4, $5);
1368 $$ = new_call(p, $1, $3, $4);
1369 }
1370 | keyword_super command_args
1371 {
1372 $$ = new_super(p, $2);
1373 }
1374 | keyword_yield command_args
1375 {
1376 $$ = new_yield(p, $2);
1377 }
1378 | keyword_return call_args
1379 {
1380 $$ = new_return(p, ret_args(p, $2));
1381 }
1382 | keyword_break call_args
1383 {
1384 $$ = new_break(p, ret_args(p, $2));
1385 }
1386 | keyword_next call_args
1387 {
1388 $$ = new_next(p, ret_args(p, $2));
1389 }
1390 ;
1391
1392 mlhs : mlhs_basic
1393 {
1394 $$ = $1;
1395 }
1396 | tLPAREN mlhs_inner rparen
1397 {
1398 $$ = $2;
1399 }
1400 ;
1401
1402 mlhs_inner : mlhs_basic
1403 | tLPAREN mlhs_inner rparen
1404 {
1405 $$ = list1($2);
1406 }
1407 ;
1408
1409 mlhs_basic : mlhs_list
1410 {
1411 $$ = list1($1);
1412 }
1413 | mlhs_list mlhs_item
1414 {
1415 $$ = list1(push($1,$2));
1416 }
1417 | mlhs_list tSTAR mlhs_node
1418 {
1419 $$ = list2($1, $3);
1420 }
1421 | mlhs_list tSTAR mlhs_node ',' mlhs_post
1422 {
1423 $$ = list3($1, $3, $5);
1424 }
1425 | mlhs_list tSTAR
1426 {
1427 $$ = list2($1, new_nil(p));
1428 }
1429 | mlhs_list tSTAR ',' mlhs_post
1430 {
1431 $$ = list3($1, new_nil(p), $4);
1432 }
1433 | tSTAR mlhs_node
1434 {
1435 $$ = list2(0, $2);
1436 }
1437 | tSTAR mlhs_node ',' mlhs_post
1438 {
1439 $$ = list3(0, $2, $4);
1440 }
1441 | tSTAR
1442 {
1443 $$ = list2(0, new_nil(p));
1444 }
1445 | tSTAR ',' mlhs_post
1446 {
1447 $$ = list3(0, new_nil(p), $3);
1448 }
1449 ;
1450
1451 mlhs_item : mlhs_node
1452 | tLPAREN mlhs_inner rparen
1453 {
1454 $$ = $2;
1455 }
1456 ;
1457
1458 mlhs_list : mlhs_item ','
1459 {
1460 $$ = list1($1);
1461 }
1462 | mlhs_list mlhs_item ','
1463 {
1464 $$ = push($1, $2);
1465 }
1466 ;
1467
1468 mlhs_post : mlhs_item
1469 {
1470 $$ = list1($1);
1471 }
1472 | mlhs_list mlhs_item
1473 {
1474 $$ = push($1, $2);
1475 }
1476 ;
1477
1478 mlhs_node : variable
1479 {
1480 assignable(p, $1);
1481 }
1482 | primary_value '[' opt_call_args rbracket
1483 {
1484 $$ = new_call(p, $1, intern2("[]",2), $3);
1485 }
1486 | primary_value '.' tIDENTIFIER
1487 {
1488 $$ = new_call(p, $1, $3, 0);
1489 }
1490 | primary_value tCOLON2 tIDENTIFIER
1491 {
1492 $$ = new_call(p, $1, $3, 0);
1493 }
1494 | primary_value '.' tCONSTANT
1495 {
1496 $$ = new_call(p, $1, $3, 0);
1497 }
1498 | primary_value tCOLON2 tCONSTANT
1499 {
1500 if (p->in_def || p->in_single)
1501 yyerror(p, "dynamic constant assignment");
1502 $$ = new_colon2(p, $1, $3);
1503 }
1504 | tCOLON3 tCONSTANT
1505 {
1506 if (p->in_def || p->in_single)
1507 yyerror(p, "dynamic constant assignment");
1508 $$ = new_colon3(p, $2);
1509 }
1510 | backref
1511 {
1512 backref_error(p, $1);
1513 $$ = 0;
1514 }
1515 ;
1516
1517 lhs : variable
1518 {
1519 assignable(p, $1);
1520 }
1521 | primary_value '[' opt_call_args rbracket
1522 {
1523 $$ = new_call(p, $1, intern2("[]",2), $3);
1524 }
1525 | primary_value '.' tIDENTIFIER
1526 {
1527 $$ = new_call(p, $1, $3, 0);
1528 }
1529 | primary_value tCOLON2 tIDENTIFIER
1530 {
1531 $$ = new_call(p, $1, $3, 0);
1532 }
1533 | primary_value '.' tCONSTANT
1534 {
1535 $$ = new_call(p, $1, $3, 0);
1536 }
1537 | primary_value tCOLON2 tCONSTANT
1538 {
1539 if (p->in_def || p->in_single)
1540 yyerror(p, "dynamic constant assignment");
1541 $$ = new_colon2(p, $1, $3);
1542 }
1543 | tCOLON3 tCONSTANT
1544 {
1545 if (p->in_def || p->in_single)
1546 yyerror(p, "dynamic constant assignment");
1547 $$ = new_colon3(p, $2);
1548 }
1549 | backref
1550 {
1551 backref_error(p, $1);
1552 $$ = 0;
1553 }
1554 ;
1555
1556 cname : tIDENTIFIER
1557 {
1558 yyerror(p, "class/module name must be CONSTANT");
1559 }
1560 | tCONSTANT
1561 ;
1562
1563 cpath : tCOLON3 cname
1564 {
1565 $$ = cons((node*)1, nsym($2));
1566 }
1567 | cname
1568 {
1569 $$ = cons((node*)0, nsym($1));
1570 }
1571 | primary_value tCOLON2 cname
1572 {
1573 $$ = cons($1, nsym($3));
1574 }
1575 ;
1576
1577 fname : tIDENTIFIER
1578 | tCONSTANT
1579 | tFID
1580 | op
1581 {
1582 p->lstate = EXPR_ENDFN;
1583 $$ = $1;
1584 }
1585 | reswords
1586 {
1587 p->lstate = EXPR_ENDFN;
1588 $$ = $<id>1;
1589 }
1590 ;
1591
1592 fsym : fname
1593 | basic_symbol
1594 ;
1595
1596 undef_list : fsym
1597 {
1598 $$ = new_undef(p, $1);
1599 }
1600 | undef_list ',' {p->lstate = EXPR_FNAME;} fsym
1601 {
1602 $$ = push($1, nsym($4));
1603 }
1604 ;
1605
1606 op : '|' { $$ = intern_c('|'); }
1607 | '^' { $$ = intern_c('^'); }
1608 | '&' { $$ = intern_c('&'); }
1609 | tCMP { $$ = intern2("<=>",3); }
1610 | tEQ { $$ = intern2("==",2); }
1611 | tEQQ { $$ = intern2("===",3); }
1612 | tMATCH { $$ = intern2("=~",2); }
1613 | tNMATCH { $$ = intern2("!~",2); }
1614 | '>' { $$ = intern_c('>'); }
1615 | tGEQ { $$ = intern2(">=",2); }
1616 | '<' { $$ = intern_c('<'); }
1617 | tLEQ { $$ = intern2("<=",2); }
1618 | tNEQ { $$ = intern2("!=",2); }
1619 | tLSHFT { $$ = intern2("<<",2); }
1620 | tRSHFT { $$ = intern2(">>",2); }
1621 | '+' { $$ = intern_c('+'); }
1622 | '-' { $$ = intern_c('-'); }
1623 | '*' { $$ = intern_c('*'); }
1624 | tSTAR { $$ = intern_c('*'); }
1625 | '/' { $$ = intern_c('/'); }
1626 | '%' { $$ = intern_c('%'); }
1627 | tPOW { $$ = intern2("**",2); }
1628 | '!' { $$ = intern_c('!'); }
1629 | '~' { $$ = intern_c('~'); }
1630 | tUPLUS { $$ = intern2("+@",2); }
1631 | tUMINUS { $$ = intern2("-@",2); }
1632 | tAREF { $$ = intern2("[]",2); }
1633 | tASET { $$ = intern2("[]=",3); }
1634 | '`' { $$ = intern_c('`'); }
1635 ;
1636
1637 reswords : keyword__LINE__ | keyword__FILE__ | keyword__ENCODING__
1638 | keyword_BEGIN | keyword_END
1639 | keyword_alias | keyword_and | keyword_begin
1640 | keyword_break | keyword_case | keyword_class | keyword_def
1641 | keyword_do | keyword_else | keyword_elsif
1642 | keyword_end | keyword_ensure | keyword_false
1643 | keyword_for | keyword_in | keyword_module | keyword_next
1644 | keyword_nil | keyword_not | keyword_or | keyword_redo
1645 | keyword_rescue | keyword_retry | keyword_return | keyword_self
1646 | keyword_super | keyword_then | keyword_true | keyword_undef
1647 | keyword_when | keyword_yield | keyword_if | keyword_unless
1648 | keyword_while | keyword_until
1649 ;
1650
1651 arg : lhs '=' arg
1652 {
1653 $$ = new_asgn(p, $1, $3);
1654 }
1655 | lhs '=' arg modifier_rescue arg
1656 {
1657 $$ = new_asgn(p, $1, new_rescue(p, $3, list1(list3(0, 0, $5)), 0));
1658 }
1659 | var_lhs tOP_ASGN arg
1660 {
1661 $$ = new_op_asgn(p, $1, $2, $3);
1662 }
1663 | var_lhs tOP_ASGN arg modifier_rescue arg
1664 {
1665 $$ = new_op_asgn(p, $1, $2, new_rescue(p, $3, list1(list3(0, 0, $5)), 0));
1666 }
1667 | primary_value '[' opt_call_args rbracket tOP_ASGN arg
1668 {
1669 $$ = new_op_asgn(p, new_call(p, $1, intern2("[]",2), $3), $5, $6);
1670 }
1671 | primary_value '.' tIDENTIFIER tOP_ASGN arg
1672 {
1673 $$ = new_op_asgn(p, new_call(p, $1, $3, 0), $4, $5);
1674 }
1675 | primary_value '.' tCONSTANT tOP_ASGN arg
1676 {
1677 $$ = new_op_asgn(p, new_call(p, $1, $3, 0), $4, $5);
1678 }
1679 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
1680 {
1681 $$ = new_op_asgn(p, new_call(p, $1, $3, 0), $4, $5);
1682 }
1683 | primary_value tCOLON2 tCONSTANT tOP_ASGN arg
1684 {
1685 yyerror(p, "constant re-assignment");
1686 $$ = new_begin(p, 0);
1687 }
1688 | tCOLON3 tCONSTANT tOP_ASGN arg
1689 {
1690 yyerror(p, "constant re-assignment");
1691 $$ = new_begin(p, 0);
1692 }
1693 | backref tOP_ASGN arg
1694 {
1695 backref_error(p, $1);
1696 $$ = new_begin(p, 0);
1697 }
1698 | arg tDOT2 arg
1699 {
1700 $$ = new_dot2(p, $1, $3);
1701 }
1702 | arg tDOT3 arg
1703 {
1704 $$ = new_dot3(p, $1, $3);
1705 }
1706 | arg '+' arg
1707 {
1708 $$ = call_bin_op(p, $1, "+", $3);
1709 }
1710 | arg '-' arg
1711 {
1712 $$ = call_bin_op(p, $1, "-", $3);
1713 }
1714 | arg '*' arg
1715 {
1716 $$ = call_bin_op(p, $1, "*", $3);
1717 }
1718 | arg '/' arg
1719 {
1720 $$ = call_bin_op(p, $1, "/", $3);
1721 }
1722 | arg '%' arg
1723 {
1724 $$ = call_bin_op(p, $1, "%", $3);
1725 }
1726 | arg tPOW arg
1727 {
1728 $$ = call_bin_op(p, $1, "**", $3);
1729 }
1730 | tUMINUS_NUM tINTEGER tPOW arg
1731 {
1732 $$ = call_uni_op(p, call_bin_op(p, $2, "**", $4), "-@");
1733 }
1734 | tUMINUS_NUM tFLOAT tPOW arg
1735 {
1736 $$ = call_uni_op(p, call_bin_op(p, $2, "**", $4), "-@");
1737 }
1738 | tUPLUS arg
1739 {
1740 $$ = call_uni_op(p, $2, "+@");
1741 }
1742 | tUMINUS arg
1743 {
1744 $$ = call_uni_op(p, $2, "-@");
1745 }
1746 | arg '|' arg
1747 {
1748 $$ = call_bin_op(p, $1, "|", $3);
1749 }
1750 | arg '^' arg
1751 {
1752 $$ = call_bin_op(p, $1, "^", $3);
1753 }
1754 | arg '&' arg
1755 {
1756 $$ = call_bin_op(p, $1, "&", $3);
1757 }
1758 | arg tCMP arg
1759 {
1760 $$ = call_bin_op(p, $1, "<=>", $3);
1761 }
1762 | arg '>' arg
1763 {
1764 $$ = call_bin_op(p, $1, ">", $3);
1765 }
1766 | arg tGEQ arg
1767 {
1768 $$ = call_bin_op(p, $1, ">=", $3);
1769 }
1770 | arg '<' arg
1771 {
1772 $$ = call_bin_op(p, $1, "<", $3);
1773 }
1774 | arg tLEQ arg
1775 {
1776 $$ = call_bin_op(p, $1, "<=", $3);
1777 }
1778 | arg tEQ arg
1779 {
1780 $$ = call_bin_op(p, $1, "==", $3);
1781 }
1782 | arg tEQQ arg
1783 {
1784 $$ = call_bin_op(p, $1, "===", $3);
1785 }
1786 | arg tNEQ arg
1787 {
1788 $$ = call_bin_op(p, $1, "!=", $3);
1789 }
1790 | arg tMATCH arg
1791 {
1792 $$ = call_bin_op(p, $1, "=~", $3);
1793 #if 0
1794 if (nd_type($1) == NODE_LIT && TYPE($1->nd_lit) == T_REGEXP) {
1795 $$ = reg_named_capture_assign($1->nd_lit, $$);
1796 }
1797 #endif
1798 }
1799 | arg tNMATCH arg
1800 {
1801 $$ = call_bin_op(p, $1, "!~", $3);
1802 }
1803 | '!' arg
1804 {
1805 $$ = call_uni_op(p, cond($2), "!");
1806 }
1807 | '~' arg
1808 {
1809 $$ = call_uni_op(p, cond($2), "~");
1810 }
1811 | arg tLSHFT arg
1812 {
1813 $$ = call_bin_op(p, $1, "<<", $3);
1814 }
1815 | arg tRSHFT arg
1816 {
1817 $$ = call_bin_op(p, $1, ">>", $3);
1818 }
1819 | arg tANDOP arg
1820 {
1821 $$ = new_and(p, $1, $3);
1822 }
1823 | arg tOROP arg
1824 {
1825 $$ = new_or(p, $1, $3);
1826 }
1827 | arg '?' arg opt_nl ':' arg
1828 {
1829 $$ = new_if(p, cond($1), $3, $6);
1830 }
1831 | primary
1832 {
1833 $$ = $1;
1834 }
1835 ;
1836
1837 arg_value : arg
1838 {
1839 $$ = $1;
1840 if (!$$) $$ = new_nil(p);
1841 }
1842 ;
1843
1844 aref_args : none
1845 | args trailer
1846 {
1847 $$ = $1;
1848 }
1849 | args ',' assocs trailer
1850 {
1851 $$ = push($1, new_hash(p, $3));
1852 }
1853 | assocs trailer
1854 {
1855 $$ = cons(new_hash(p, $1), 0);
1856 }
1857 ;
1858
1859 paren_args : '(' opt_call_args rparen
1860 {
1861 $$ = $2;
1862 }
1863 ;
1864
1865 opt_paren_args : none
1866 | paren_args
1867 ;
1868
1869 opt_call_args : none
1870 | call_args
1871 | args ','
1872 {
1873 $$ = cons($1,0);
1874 }
1875 | args ',' assocs ','
1876 {
1877 $$ = cons(push($1, new_hash(p, $3)), 0);
1878 }
1879 | assocs ','
1880 {
1881 $$ = cons(list1(new_hash(p, $1)), 0);
1882 }
1883 ;
1884
1885 call_args : command
1886 {
1887 $$ = cons(list1($1), 0);
1888 }
1889 | args opt_block_arg
1890 {
1891 $$ = cons($1, $2);
1892 }
1893 | assocs opt_block_arg
1894 {
1895 $$ = cons(list1(new_hash(p, $1)), $2);
1896 }
1897 | args ',' assocs opt_block_arg
1898 {
1899 $$ = cons(push($1, new_hash(p, $3)), $4);
1900 }
1901 | block_arg
1902 {
1903 $$ = cons(0, $1);
1904 }
1905 ;
1906
1907 command_args : {
1908 $<stack>$ = p->cmdarg_stack;
1909 CMDARG_PUSH(1);
1910 }
1911 call_args
1912 {
1913 p->cmdarg_stack = $<stack>1;
1914 $$ = $2;
1915 }
1916 ;
1917
1918 block_arg : tAMPER arg_value
1919 {
1920 $$ = new_block_arg(p, $2);
1921 }
1922 ;
1923
1924 opt_block_arg : ',' block_arg
1925 {
1926 $$ = $2;
1927 }
1928 | none
1929 {
1930 $$ = 0;
1931 }
1932 ;
1933
1934 args : arg_value
1935 {
1936 $$ = cons($1, 0);
1937 }
1938 | tSTAR arg_value
1939 {
1940 $$ = cons(new_splat(p, $2), 0);
1941 }
1942 | args ',' arg_value
1943 {
1944 $$ = push($1, $3);
1945 }
1946 | args ',' tSTAR arg_value
1947 {
1948 $$ = push($1, new_splat(p, $4));
1949 }
1950 ;
1951
1952 mrhs : args ',' arg_value
1953 {
1954 $$ = push($1, $3);
1955 }
1956 | args ',' tSTAR arg_value
1957 {
1958 $$ = push($1, new_splat(p, $4));
1959 }
1960 | tSTAR arg_value
1961 {
1962 $$ = list1(new_splat(p, $2));
1963 }
1964 ;
1965
1966 primary : literal
1967 | string
1968 | xstring
1969 | regexp
1970 | heredoc
1971 | var_ref
1972 | backref
1973 | tFID
1974 {
1975 $$ = new_fcall(p, $1, 0);
1976 }
1977 | keyword_begin
1978 {
1979 $<stack>1 = p->cmdarg_stack;
1980 p->cmdarg_stack = 0;
1981 }
1982 bodystmt
1983 keyword_end
1984 {
1985 p->cmdarg_stack = $<stack>1;
1986 $$ = $3;
1987 }
1988 | tLPAREN_ARG expr {p->lstate = EXPR_ENDARG;} rparen
1989 {
1990 $$ = $2;
1991 }
1992 | tLPAREN_ARG {p->lstate = EXPR_ENDARG;} rparen
1993 {
1994 $$ = 0;
1995 }
1996 | tLPAREN compstmt ')'
1997 {
1998 $$ = $2;
1999 }
2000 | primary_value tCOLON2 tCONSTANT
2001 {
2002 $$ = new_colon2(p, $1, $3);
2003 }
2004 | tCOLON3 tCONSTANT
2005 {
2006 $$ = new_colon3(p, $2);
2007 }
2008 | tLBRACK aref_args ']'
2009 {
2010 $$ = new_array(p, $2);
2011 }
2012 | tLBRACE assoc_list '}'
2013 {
2014 $$ = new_hash(p, $2);
2015 }
2016 | keyword_return
2017 {
2018 $$ = new_return(p, 0);
2019 }
2020 | keyword_yield '(' call_args rparen
2021 {
2022 $$ = new_yield(p, $3);
2023 }
2024 | keyword_yield '(' rparen
2025 {
2026 $$ = new_yield(p, 0);
2027 }
2028 | keyword_yield
2029 {
2030 $$ = new_yield(p, 0);
2031 }
2032 | keyword_not '(' expr rparen
2033 {
2034 $$ = call_uni_op(p, cond($3), "!");
2035 }
2036 | keyword_not '(' rparen
2037 {
2038 $$ = call_uni_op(p, new_nil(p), "!");
2039 }
2040 | operation brace_block
2041 {
2042 $$ = new_fcall(p, $1, cons(0, $2));
2043 }
2044 | method_call
2045 | method_call brace_block
2046 {
2047 call_with_block(p, $1, $2);
2048 $$ = $1;
2049 }
2050 | tLAMBDA
2051 {
2052 local_nest(p);
2053 $<num>$ = p->lpar_beg;
2054 p->lpar_beg = ++p->paren_nest;
2055 }
2056 f_larglist
2057 lambda_body
2058 {
2059 p->lpar_beg = $<num>2;
2060 $$ = new_lambda(p, $3, $4);
2061 local_unnest(p);
2062 }
2063 | keyword_if expr_value then
2064 compstmt
2065 if_tail
2066 keyword_end
2067 {
2068 $$ = new_if(p, cond($2), $4, $5);
2069 }
2070 | keyword_unless expr_value then
2071 compstmt
2072 opt_else
2073 keyword_end
2074 {
2075 $$ = new_unless(p, cond($2), $4, $5);
2076 }
2077 | keyword_while {COND_PUSH(1);} expr_value do {COND_POP();}
2078 compstmt
2079 keyword_end
2080 {
2081 $$ = new_while(p, cond($3), $6);
2082 }
2083 | keyword_until {COND_PUSH(1);} expr_value do {COND_POP();}
2084 compstmt
2085 keyword_end
2086 {
2087 $$ = new_until(p, cond($3), $6);
2088 }
2089 | keyword_case expr_value opt_terms
2090 case_body
2091 keyword_end
2092 {
2093 $$ = new_case(p, $2, $4);
2094 }
2095 | keyword_case opt_terms case_body keyword_end
2096 {
2097 $$ = new_case(p, 0, $3);
2098 }
2099 | keyword_for for_var keyword_in
2100 {COND_PUSH(1);}
2101 expr_value do
2102 {COND_POP();}
2103 compstmt
2104 keyword_end
2105 {
2106 $$ = new_for(p, $2, $5, $8);
2107 }
2108 | keyword_class cpath superclass
2109 {
2110 if (p->in_def || p->in_single)
2111 yyerror(p, "class definition in method body");
2112 $<nd>$ = local_switch(p);
2113 }
2114 bodystmt
2115 keyword_end
2116 {
2117 $$ = new_class(p, $2, $3, $5);
2118 local_resume(p, $<nd>4);
2119 }
2120 | keyword_class tLSHFT expr
2121 {
2122 $<num>$ = p->in_def;
2123 p->in_def = 0;
2124 }
2125 term
2126 {
2127 $<nd>$ = cons(local_switch(p), (node*)(intptr_t)p->in_single);
2128 p->in_single = 0;
2129 }
2130 bodystmt
2131 keyword_end
2132 {
2133 $$ = new_sclass(p, $3, $7);
2134 local_resume(p, $<nd>6->car);
2135 p->in_def = $<num>4;
2136 p->in_single = (int)(intptr_t)$<nd>6->cdr;
2137 }
2138 | keyword_module cpath
2139 {
2140 if (p->in_def || p->in_single)
2141 yyerror(p, "module definition in method body");
2142 $<nd>$ = local_switch(p);
2143 }
2144 bodystmt
2145 keyword_end
2146 {
2147 $$ = new_module(p, $2, $4);
2148 local_resume(p, $<nd>3);
2149 }
2150 | keyword_def fname
2151 {
2152 p->in_def++;
2153 $<nd>$ = local_switch(p);
2154 }
2155 f_arglist
2156 bodystmt
2157 keyword_end
2158 {
2159 $$ = new_def(p, $2, $4, $5);
2160 local_resume(p, $<nd>3);
2161 p->in_def--;
2162 }
2163 | keyword_def singleton dot_or_colon {p->lstate = EXPR_FNAME;} fname
2164 {
2165 p->in_single++;
2166 p->lstate = EXPR_ENDFN; /* force for args */
2167 $<nd>$ = local_switch(p);
2168 }
2169 f_arglist
2170 bodystmt
2171 keyword_end
2172 {
2173 $$ = new_sdef(p, $2, $5, $7, $8);
2174 local_resume(p, $<nd>6);
2175 p->in_single--;
2176 }
2177 | keyword_break
2178 {
2179 $$ = new_break(p, 0);
2180 }
2181 | keyword_next
2182 {
2183 $$ = new_next(p, 0);
2184 }
2185 | keyword_redo
2186 {
2187 $$ = new_redo(p);
2188 }
2189 | keyword_retry
2190 {
2191 $$ = new_retry(p);
2192 }
2193 ;
2194
2195 primary_value : primary
2196 {
2197 $$ = $1;
2198 if (!$$) $$ = new_nil(p);
2199 }
2200 ;
2201
2202 then : term
2203 | keyword_then
2204 | term keyword_then
2205 ;
2206
2207 do : term
2208 | keyword_do_cond
2209 ;
2210
2211 if_tail : opt_else
2212 | keyword_elsif expr_value then
2213 compstmt
2214 if_tail
2215 {
2216 $$ = new_if(p, cond($2), $4, $5);
2217 }
2218 ;
2219
2220 opt_else : none
2221 | keyword_else compstmt
2222 {
2223 $$ = $2;
2224 }
2225 ;
2226
2227 for_var : lhs
2228 {
2229 $$ = list1(list1($1));
2230 }
2231 | mlhs
2232 ;
2233
2234 f_marg : f_norm_arg
2235 {
2236 $$ = new_arg(p, $1);
2237 }
2238 | tLPAREN f_margs rparen
2239 {
2240 $$ = new_masgn(p, $2, 0);
2241 }
2242 ;
2243
2244 f_marg_list : f_marg
2245 {
2246 $$ = list1($1);
2247 }
2248 | f_marg_list ',' f_marg
2249 {
2250 $$ = push($1, $3);
2251 }
2252 ;
2253
2254 f_margs : f_marg_list
2255 {
2256 $$ = list3($1,0,0);
2257 }
2258 | f_marg_list ',' tSTAR f_norm_arg
2259 {
2260 $$ = list3($1, new_arg(p, $4), 0);
2261 }
2262 | f_marg_list ',' tSTAR f_norm_arg ',' f_marg_list
2263 {
2264 $$ = list3($1, new_arg(p, $4), $6);
2265 }
2266 | f_marg_list ',' tSTAR
2267 {
2268 $$ = list3($1, (node*)-1, 0);
2269 }
2270 | f_marg_list ',' tSTAR ',' f_marg_list
2271 {
2272 $$ = list3($1, (node*)-1, $5);
2273 }
2274 | tSTAR f_norm_arg
2275 {
2276 $$ = list3(0, new_arg(p, $2), 0);
2277 }
2278 | tSTAR f_norm_arg ',' f_marg_list
2279 {
2280 $$ = list3(0, new_arg(p, $2), $4);
2281 }
2282 | tSTAR
2283 {
2284 $$ = list3(0, (node*)-1, 0);
2285 }
2286 | tSTAR ',' f_marg_list
2287 {
2288 $$ = list3(0, (node*)-1, $3);
2289 }
2290 ;
2291
2292 block_param : f_arg ',' f_block_optarg ',' f_rest_arg opt_f_block_arg
2293 {
2294 $$ = new_args(p, $1, $3, $5, 0, $6);
2295 }
2296 | f_arg ',' f_block_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
2297 {
2298 $$ = new_args(p, $1, $3, $5, $7, $8);
2299 }
2300 | f_arg ',' f_block_optarg opt_f_block_arg
2301 {
2302 $$ = new_args(p, $1, $3, 0, 0, $4);
2303 }
2304 | f_arg ',' f_block_optarg ',' f_arg opt_f_block_arg
2305 {
2306 $$ = new_args(p, $1, $3, 0, $5, $6);
2307 }
2308 | f_arg ',' f_rest_arg opt_f_block_arg
2309 {
2310 $$ = new_args(p, $1, 0, $3, 0, $4);
2311 }
2312 | f_arg ','
2313 {
2314 $$ = new_args(p, $1, 0, 1, 0, 0);
2315 }
2316 | f_arg ',' f_rest_arg ',' f_arg opt_f_block_arg
2317 {
2318 $$ = new_args(p, $1, 0, $3, $5, $6);
2319 }
2320 | f_arg opt_f_block_arg
2321 {
2322 $$ = new_args(p, $1, 0, 0, 0, $2);
2323 }
2324 | f_block_optarg ',' f_rest_arg opt_f_block_arg
2325 {
2326 $$ = new_args(p, 0, $1, $3, 0, $4);
2327 }
2328 | f_block_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
2329 {
2330 $$ = new_args(p, 0, $1, $3, $5, $6);
2331 }
2332 | f_block_optarg opt_f_block_arg
2333 {
2334 $$ = new_args(p, 0, $1, 0, 0, $2);
2335 }
2336 | f_block_optarg ',' f_arg opt_f_block_arg
2337 {
2338 $$ = new_args(p, 0, $1, 0, $3, $4);
2339 }
2340 | f_rest_arg opt_f_block_arg
2341 {
2342 $$ = new_args(p, 0, 0, $1, 0, $2);
2343 }
2344 | f_rest_arg ',' f_arg opt_f_block_arg
2345 {
2346 $$ = new_args(p, 0, 0, $1, $3, $4);
2347 }
2348 | f_block_arg
2349 {
2350 $$ = new_args(p, 0, 0, 0, 0, $1);
2351 }
2352 ;
2353
2354 opt_block_param : none
2355 | block_param_def
2356 {
2357 p->cmd_start = TRUE;
2358 $$ = $1;
2359 }
2360 ;
2361
2362 block_param_def : '|' opt_bv_decl '|'
2363 {
2364 local_add_f(p, 0);
2365 $$ = 0;
2366 }
2367 | tOROP
2368 {
2369 local_add_f(p, 0);
2370 $$ = 0;
2371 }
2372 | '|' block_param opt_bv_decl '|'
2373 {
2374 $$ = $2;
2375 }
2376 ;
2377
2378
2379 opt_bv_decl : opt_nl
2380 {
2381 $$ = 0;
2382 }
2383 | opt_nl ';' bv_decls opt_nl
2384 {
2385 $$ = 0;
2386 }
2387 ;
2388
2389 bv_decls : bvar
2390 | bv_decls ',' bvar
2391 ;
2392
2393 bvar : tIDENTIFIER
2394 {
2395 local_add_f(p, $1);
2396 new_bv(p, $1);
2397 }
2398 | f_bad_arg
2399 ;
2400
2401 f_larglist : '(' f_args opt_bv_decl ')'
2402 {
2403 $$ = $2;
2404 }
2405 | f_args
2406 {
2407 $$ = $1;
2408 }
2409 ;
2410
2411 lambda_body : tLAMBEG compstmt '}'
2412 {
2413 $$ = $2;
2414 }
2415 | keyword_do_LAMBDA compstmt keyword_end
2416 {
2417 $$ = $2;
2418 }
2419 ;
2420
2421 do_block : keyword_do_block
2422 {
2423 local_nest(p);
2424 }
2425 opt_block_param
2426 compstmt
2427 keyword_end
2428 {
2429 $$ = new_block(p,$3,$4);
2430 local_unnest(p);
2431 }
2432 ;
2433
2434 block_call : command do_block
2435 {
2436 if ($1->car == (node*)NODE_YIELD) {
2437 yyerror(p, "block given to yield");
2438 }
2439 else {
2440 call_with_block(p, $1, $2);
2441 }
2442 $$ = $1;
2443 }
2444 | block_call dot_or_colon operation2 opt_paren_args
2445 {
2446 $$ = new_call(p, $1, $3, $4);
2447 }
2448 | block_call dot_or_colon operation2 opt_paren_args brace_block
2449 {
2450 $$ = new_call(p, $1, $3, $4);
2451 call_with_block(p, $$, $5);
2452 }
2453 | block_call dot_or_colon operation2 command_args do_block
2454 {
2455 $$ = new_call(p, $1, $3, $4);
2456 call_with_block(p, $$, $5);
2457 }
2458 ;
2459
2460 method_call : operation paren_args
2461 {
2462 $$ = new_fcall(p, $1, $2);
2463 }
2464 | primary_value '.' operation2 opt_paren_args
2465 {
2466 $$ = new_call(p, $1, $3, $4);
2467 }
2468 | primary_value tCOLON2 operation2 paren_args
2469 {
2470 $$ = new_call(p, $1, $3, $4);
2471 }
2472 | primary_value tCOLON2 operation3
2473 {
2474 $$ = new_call(p, $1, $3, 0);
2475 }
2476 | primary_value '.' paren_args
2477 {
2478 $$ = new_call(p, $1, intern2("call",4), $3);
2479 }
2480 | primary_value tCOLON2 paren_args
2481 {
2482 $$ = new_call(p, $1, intern2("call",4), $3);
2483 }
2484 | keyword_super paren_args
2485 {
2486 $$ = new_super(p, $2);
2487 }
2488 | keyword_super
2489 {
2490 $$ = new_zsuper(p);
2491 }
2492 | primary_value '[' opt_call_args rbracket
2493 {
2494 $$ = new_call(p, $1, intern2("[]",2), $3);
2495 }
2496 ;
2497
2498 brace_block : '{'
2499 {
2500 local_nest(p);
2501 }
2502 opt_block_param
2503 compstmt '}'
2504 {
2505 $$ = new_block(p,$3,$4);
2506 local_unnest(p);
2507 }
2508 | keyword_do
2509 {
2510 local_nest(p);
2511 }
2512 opt_block_param
2513 compstmt keyword_end
2514 {
2515 $$ = new_block(p,$3,$4);
2516 local_unnest(p);
2517 }
2518 ;
2519
2520 case_body : keyword_when args then
2521 compstmt
2522 cases
2523 {
2524 $$ = cons(cons($2, $4), $5);
2525 }
2526 ;
2527
2528 cases : opt_else
2529 {
2530 if ($1) {
2531 $$ = cons(cons(0, $1), 0);
2532 }
2533 else {
2534 $$ = 0;
2535 }
2536 }
2537 | case_body
2538 ;
2539
2540 opt_rescue : keyword_rescue exc_list exc_var then
2541 compstmt
2542 opt_rescue
2543 {
2544 $$ = list1(list3($2, $3, $5));
2545 if ($6) $$ = append($$, $6);
2546 }
2547 | none
2548 ;
2549
2550 exc_list : arg_value
2551 {
2552 $$ = list1($1);
2553 }
2554 | mrhs
2555 | none
2556 ;
2557
2558 exc_var : tASSOC lhs
2559 {
2560 $$ = $2;
2561 }
2562 | none
2563 ;
2564
2565 opt_ensure : keyword_ensure compstmt
2566 {
2567 $$ = $2;
2568 }
2569 | none
2570 ;
2571
2572 literal : numeric
2573 | symbol
2574 | words
2575 | symbols
2576 ;
2577
2578 string : tCHAR
2579 | tSTRING
2580 | tSTRING_BEG tSTRING
2581 {
2582 $$ = $2;
2583 }
2584 | tSTRING_BEG string_rep tSTRING
2585 {
2586 $$ = new_dstr(p, push($2, $3));
2587 }
2588 ;
2589
2590 string_rep : string_interp
2591 | string_rep string_interp
2592 {
2593 $$ = append($1, $2);
2594 }
2595 ;
2596
2597 string_interp : tSTRING_MID
2598 {
2599 $$ = list1($1);
2600 }
2601 | tSTRING_PART
2602 {
2603 $<nd>$ = p->lex_strterm;
2604 p->lex_strterm = NULL;
2605 }
2606 compstmt
2607 '}'
2608 {
2609 p->lex_strterm = $<nd>2;
2610 $$ = list2($1, $3);
2611 }
2612 | tLITERAL_DELIM
2613 {
2614 $$ = list1(new_literal_delim(p));
2615 }
2616 ;
2617
2618 xstring : tXSTRING_BEG tXSTRING
2619 {
2620 $$ = $2;
2621 }
2622 | tXSTRING_BEG string_rep tXSTRING
2623 {
2624 $$ = new_dxstr(p, push($2, $3));
2625 }
2626 ;
2627
2628 regexp : tREGEXP_BEG tREGEXP
2629 {
2630 $$ = $2;
2631 }
2632 | tREGEXP_BEG string_rep tREGEXP
2633 {
2634 $$ = new_dregx(p, $2, $3);
2635 }
2636 ;
2637
2638 heredoc : tHEREDOC_BEG
2639 ;
2640
2641 opt_heredoc_bodies : none
2642 | heredoc_bodies
2643 ;
2644
2645 heredoc_bodies : heredoc_body
2646 | heredoc_bodies heredoc_body
2647 ;
2648
2649 heredoc_body : tHEREDOC_END
2650 {
2651 parsing_heredoc_inf(p)->doc = list1(new_str(p, "", 0));
2652 heredoc_end(p);
2653 }
2654 | string_rep tHEREDOC_END
2655 {
2656 parsing_heredoc_inf(p)->doc = $1;
2657 heredoc_end(p);
2658 }
2659 ;
2660
2661 words : tWORDS_BEG tSTRING
2662 {
2663 $$ = new_words(p, list1($2));
2664 }
2665 | tWORDS_BEG string_rep tSTRING
2666 {
2667 $$ = new_words(p, push($2, $3));
2668 }
2669 ;
2670
2671
2672 symbol : basic_symbol
2673 {
2674 $$ = new_sym(p, $1);
2675 }
2676 | tSYMBEG tSTRING_BEG string_interp tSTRING
2677 {
2678 p->lstate = EXPR_END;
2679 $$ = new_dsym(p, push($3, $4));
2680 }
2681 ;
2682
2683 basic_symbol : tSYMBEG sym
2684 {
2685 p->lstate = EXPR_END;
2686 $$ = $2;
2687 }
2688 ;
2689
2690 sym : fname
2691 | tIVAR
2692 | tGVAR
2693 | tCVAR
2694 | tSTRING
2695 {
2696 $$ = new_strsym(p, $1);
2697 }
2698 | tSTRING_BEG tSTRING
2699 {
2700 $$ = new_strsym(p, $2);
2701 }
2702 ;
2703
2704 symbols : tSYMBOLS_BEG tSTRING
2705 {
2706 $$ = new_symbols(p, list1($2));
2707 }
2708 | tSYMBOLS_BEG string_rep tSTRING
2709 {
2710 $$ = new_symbols(p, push($2, $3));
2711 }
2712 ;
2713
2714 numeric : tINTEGER
2715 | tFLOAT
2716 | tUMINUS_NUM tINTEGER %prec tLOWEST
2717 {
2718 $$ = negate_lit(p, $2);
2719 }
2720 | tUMINUS_NUM tFLOAT %prec tLOWEST
2721 {
2722 $$ = negate_lit(p, $2);
2723 }
2724 ;
2725
2726 variable : tIDENTIFIER
2727 {
2728 $$ = new_lvar(p, $1);
2729 }
2730 | tIVAR
2731 {
2732 $$ = new_ivar(p, $1);
2733 }
2734 | tGVAR
2735 {
2736 $$ = new_gvar(p, $1);
2737 }
2738 | tCVAR
2739 {
2740 $$ = new_cvar(p, $1);
2741 }
2742 | tCONSTANT
2743 {
2744 $$ = new_const(p, $1);
2745 }
2746 ;
2747
2748 var_lhs : variable
2749 {
2750 assignable(p, $1);
2751 }
2752 ;
2753
2754 var_ref : variable
2755 {
2756 $$ = var_reference(p, $1);
2757 }
2758 | keyword_nil
2759 {
2760 $$ = new_nil(p);
2761 }
2762 | keyword_self
2763 {
2764 $$ = new_self(p);
2765 }
2766 | keyword_true
2767 {
2768 $$ = new_true(p);
2769 }
2770 | keyword_false
2771 {
2772 $$ = new_false(p);
2773 }
2774 | keyword__FILE__
2775 {
2776 if (!p->filename) {
2777 p->filename = "(null)";
2778 }
2779 $$ = new_str(p, p->filename, strlen(p->filename));
2780 }
2781 | keyword__LINE__
2782 {
2783 char buf[16];
2784
2785 snprintf(buf, sizeof(buf), "%d", p->lineno);
2786 $$ = new_int(p, buf, 10);
2787 }
2788 ;
2789
2790 backref : tNTH_REF
2791 | tBACK_REF
2792 ;
2793
2794 superclass : term
2795 {
2796 $$ = 0;
2797 }
2798 | '<'
2799 {
2800 p->lstate = EXPR_BEG;
2801 p->cmd_start = TRUE;
2802 }
2803 expr_value term
2804 {
2805 $$ = $3;
2806 }
2807 | error term
2808 {
2809 yyerrok;
2810 $$ = 0;
2811 }
2812 ;
2813
2814 f_arglist : '(' f_args rparen
2815 {
2816 $$ = $2;
2817 p->lstate = EXPR_BEG;
2818 p->cmd_start = TRUE;
2819 }
2820 | f_args term
2821 {
2822 $$ = $1;
2823 }
2824 ;
2825
2826 f_args : f_arg ',' f_optarg ',' f_rest_arg opt_f_block_arg
2827 {
2828 $$ = new_args(p, $1, $3, $5, 0, $6);
2829 }
2830 | f_arg ',' f_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
2831 {
2832 $$ = new_args(p, $1, $3, $5, $7, $8);
2833 }
2834 | f_arg ',' f_optarg opt_f_block_arg
2835 {
2836 $$ = new_args(p, $1, $3, 0, 0, $4);
2837 }
2838 | f_arg ',' f_optarg ',' f_arg opt_f_block_arg
2839 {
2840 $$ = new_args(p, $1, $3, 0, $5, $6);
2841 }
2842 | f_arg ',' f_rest_arg opt_f_block_arg
2843 {
2844 $$ = new_args(p, $1, 0, $3, 0, $4);
2845 }
2846 | f_arg ',' f_rest_arg ',' f_arg opt_f_block_arg
2847 {
2848 $$ = new_args(p, $1, 0, $3, $5, $6);
2849 }
2850 | f_arg opt_f_block_arg
2851 {
2852 $$ = new_args(p, $1, 0, 0, 0, $2);
2853 }
2854 | f_optarg ',' f_rest_arg opt_f_block_arg
2855 {
2856 $$ = new_args(p, 0, $1, $3, 0, $4);
2857 }
2858 | f_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
2859 {
2860 $$ = new_args(p, 0, $1, $3, $5, $6);
2861 }
2862 | f_optarg opt_f_block_arg
2863 {
2864 $$ = new_args(p, 0, $1, 0, 0, $2);
2865 }
2866 | f_optarg ',' f_arg opt_f_block_arg
2867 {
2868 $$ = new_args(p, 0, $1, 0, $3, $4);
2869 }
2870 | f_rest_arg opt_f_block_arg
2871 {
2872 $$ = new_args(p, 0, 0, $1, 0, $2);
2873 }
2874 | f_rest_arg ',' f_arg opt_f_block_arg
2875 {
2876 $$ = new_args(p, 0, 0, $1, $3, $4);
2877 }
2878 | f_block_arg
2879 {
2880 $$ = new_args(p, 0, 0, 0, 0, $1);
2881 }
2882 | /* none */
2883 {
2884 local_add_f(p, 0);
2885 $$ = new_args(p, 0, 0, 0, 0, 0);
2886 }
2887 ;
2888
2889 f_bad_arg : tCONSTANT
2890 {
2891 yyerror(p, "formal argument cannot be a constant");
2892 $$ = 0;
2893 }
2894 | tIVAR
2895 {
2896 yyerror(p, "formal argument cannot be an instance variable");
2897 $$ = 0;
2898 }
2899 | tGVAR
2900 {
2901 yyerror(p, "formal argument cannot be a global variable");
2902 $$ = 0;
2903 }
2904 | tCVAR
2905 {
2906 yyerror(p, "formal argument cannot be a class variable");
2907 $$ = 0;
2908 }
2909 ;
2910
2911 f_norm_arg : f_bad_arg
2912 {
2913 $$ = 0;
2914 }
2915 | tIDENTIFIER
2916 {
2917 local_add_f(p, $1);
2918 $$ = $1;
2919 }
2920 ;
2921
2922 f_arg_item : f_norm_arg
2923 {
2924 $$ = new_arg(p, $1);
2925 }
2926 | tLPAREN f_margs rparen
2927 {
2928 $$ = new_masgn(p, $2, 0);
2929 }
2930 ;
2931
2932 f_arg : f_arg_item
2933 {
2934 $$ = list1($1);
2935 }
2936 | f_arg ',' f_arg_item
2937 {
2938 $$ = push($1, $3);
2939 }
2940 ;
2941
2942 f_opt : tIDENTIFIER '=' arg_value
2943 {
2944 local_add_f(p, $1);
2945 $$ = cons(nsym($1), $3);
2946 }
2947 ;
2948
2949 f_block_opt : tIDENTIFIER '=' primary_value
2950 {
2951 local_add_f(p, $1);
2952 $$ = cons(nsym($1), $3);
2953 }
2954 ;
2955
2956 f_block_optarg : f_block_opt
2957 {
2958 $$ = list1($1);
2959 }
2960 | f_block_optarg ',' f_block_opt
2961 {
2962 $$ = push($1, $3);
2963 }
2964 ;
2965
2966 f_optarg : f_opt
2967 {
2968 $$ = list1($1);
2969 }
2970 | f_optarg ',' f_opt
2971 {
2972 $$ = push($1, $3);
2973 }
2974 ;
2975
2976 restarg_mark : '*'
2977 | tSTAR
2978 ;
2979
2980 f_rest_arg : restarg_mark tIDENTIFIER
2981 {
2982 local_add_f(p, $2);
2983 $$ = $2;
2984 }
2985 | restarg_mark
2986 {
2987 local_add_f(p, 0);
2988 $$ = -1;
2989 }
2990 ;
2991
2992 blkarg_mark : '&'
2993 | tAMPER
2994 ;
2995
2996 f_block_arg : blkarg_mark tIDENTIFIER
2997 {
2998 local_add_f(p, $2);
2999 $$ = $2;
3000 }
3001 ;
3002
3003 opt_f_block_arg : ',' f_block_arg
3004 {
3005 $$ = $2;
3006 }
3007 | none
3008 {
3009 local_add_f(p, 0);
3010 $$ = 0;
3011 }
3012 ;
3013
3014 singleton : var_ref
3015 {
3016 $$ = $1;
3017 if (!$$) $$ = new_nil(p);
3018 }
3019 | '(' {p->lstate = EXPR_BEG;} expr rparen
3020 {
3021 if ($3 == 0) {
3022 yyerror(p, "can't define singleton method for ().");
3023 }
3024 else {
3025 switch ((enum node_type)(int)(intptr_t)$3->car) {
3026 case NODE_STR:
3027 case NODE_DSTR:
3028 case NODE_XSTR:
3029 case NODE_DXSTR:
3030 case NODE_DREGX:
3031 case NODE_MATCH:
3032 case NODE_FLOAT:
3033 case NODE_ARRAY:
3034 case NODE_HEREDOC:
3035 yyerror(p, "can't define singleton method for literals");
3036 default:
3037 break;
3038 }
3039 }
3040 $$ = $3;
3041 }
3042 ;
3043
3044 assoc_list : none
3045 | assocs trailer
3046 {
3047 $$ = $1;
3048 }
3049 ;
3050
3051 assocs : assoc
3052 {
3053 $$ = list1($1);
3054 }
3055 | assocs ',' assoc
3056 {
3057 $$ = push($1, $3);
3058 }
3059 ;
3060
3061 assoc : arg_value tASSOC arg_value
3062 {
3063 $$ = cons($1, $3);
3064 }
3065 | tLABEL arg_value
3066 {
3067 $$ = cons(new_sym(p, $1), $2);
3068 }
3069 ;
3070
3071 operation : tIDENTIFIER
3072 | tCONSTANT
3073 | tFID
3074 ;
3075
3076 operation2 : tIDENTIFIER
3077 | tCONSTANT
3078 | tFID
3079 | op
3080 ;
3081
3082 operation3 : tIDENTIFIER
3083 | tFID
3084 | op
3085 ;
3086
3087 dot_or_colon : '.'
3088 | tCOLON2
3089 ;
3090
3091 opt_terms : /* none */
3092 | terms
3093 ;
3094
3095 opt_nl : /* none */
3096 | nl
3097 ;
3098
3099 rparen : opt_nl ')'
3100 ;
3101
3102 rbracket : opt_nl ']'
3103 ;
3104
3105 trailer : /* none */
3106 | nl
3107 | ','
3108 ;
3109
3110 term : ';' {yyerrok;}
3111 | nl
3112 ;
3113
3114 nl : '\n'
3115 {
3116 p->lineno++;
3117 p->column = 0;
3118 }
3119 opt_heredoc_bodies
3120
3121 terms : term
3122 | terms ';' {yyerrok;}
3123 ;
3124
3125 none : /* none */
3126 {
3127 $$ = 0;
3128 }
3129 ;
3130 %%
3131 #define yylval (*((YYSTYPE*)(p->ylval)))
3132
3133 static void
3134 yyerror(parser_state *p, const char *s)
3135 {
3136 char* c;
3137 int n;
3138
3139 if (! p->capture_errors) {
3140 #ifdef ENABLE_STDIO
3141 if (p->filename) {
3142 fprintf(stderr, "%s:%d:%d: %s\n", p->filename, p->lineno, p->column, s);
3143 }
3144 else {
3145 fprintf(stderr, "line %d:%d: %s\n", p->lineno, p->column, s);
3146 }
3147 #endif
3148 }
3149 else if (p->nerr < sizeof(p->error_buffer) / sizeof(p->error_buffer[0])) {
3150 n = strlen(s);
3151 c = (char *)parser_palloc(p, n + 1);
3152 memcpy(c, s, n + 1);
3153 p->error_buffer[p->nerr].message = c;
3154 p->error_buffer[p->nerr].lineno = p->lineno;
3155 p->error_buffer[p->nerr].column = p->column;
3156 }
3157 p->nerr++;
3158 }
3159
3160 static void
3161 yyerror_i(parser_state *p, const char *fmt, int i)
3162 {
3163 char buf[256];
3164
3165 snprintf(buf, sizeof(buf), fmt, i);
3166 yyerror(p, buf);
3167 }
3168
3169 static void
3170 yywarn(parser_state *p, const char *s)
3171 {
3172 char* c;
3173 int n;
3174
3175 if (! p->capture_errors) {
3176 #ifdef ENABLE_STDIO
3177 if (p->filename) {
3178 fprintf(stderr, "%s:%d:%d: %s\n", p->filename, p->lineno, p->column, s);
3179 }
3180 else {
3181 fprintf(stderr, "line %d:%d: %s\n", p->lineno, p->column, s);
3182 }
3183 #endif
3184 }
3185 else if (p->nwarn < sizeof(p->warn_buffer) / sizeof(p->warn_buffer[0])) {
3186 n = strlen(s);
3187 c = (char *)parser_palloc(p, n + 1);
3188 memcpy(c, s, n + 1);
3189 p->warn_buffer[p->nwarn].message = c;
3190 p->warn_buffer[p->nwarn].lineno = p->lineno;
3191 p->warn_buffer[p->nwarn].column = p->column;
3192 }
3193 p->nwarn++;
3194 }
3195
3196 static void
3197 yywarning(parser_state *p, const char *s)
3198 {
3199 yywarn(p, s);
3200 }
3201
3202 static void
3203 yywarning_s(parser_state *p, const char *fmt, const char *s)
3204 {
3205 char buf[256];
3206
3207 snprintf(buf, sizeof(buf), fmt, s);
3208 yywarning(p, buf);
3209 }
3210
3211 static void
3212 backref_error(parser_state *p, node *n)
3213 {
3214 int c;
3215
3216 c = (int)(intptr_t)n->car;
3217
3218 if (c == NODE_NTH_REF) {
3219 yyerror_i(p, "can't set variable $%d", (int)(intptr_t)n->cdr);
3220 } else if (c == NODE_BACK_REF) {
3221 yyerror_i(p, "can't set variable $%c", (int)(intptr_t)n->cdr);
3222 } else {
3223 mrb_bug("Internal error in backref_error() : n=>car == %d", c);
3224 }
3225 }
3226
3227 static int peeks(parser_state *p, const char *s);
3228 static int skips(parser_state *p, const char *s);
3229
3230 static inline int
3231 nextc(parser_state *p)
3232 {
3233 int c;
3234
3235 if (p->pb) {
3236 node *tmp;
3237
3238 c = (int)(intptr_t)p->pb->car;
3239 tmp = p->pb;
3240 p->pb = p->pb->cdr;
3241 cons_free(tmp);
3242 }
3243 else {
3244 if (p->f) {
3245 if (feof(p->f)) return -1;
3246 c = fgetc(p->f);
3247 if (c == EOF) return -1;
3248 }
3249 else if (!p->s || p->s >= p->send) {
3250 return -1;
3251 }
3252 else {
3253 c = (unsigned char)*p->s++;
3254 }
3255 }
3256 p->column++;
3257 return c;
3258 }
3259
3260 static void
3261 pushback(parser_state *p, int c)
3262 {
3263 if (c < 0) return;
3264 p->column--;
3265 p->pb = cons((node*)(intptr_t)c, p->pb);
3266 }
3267
3268 static void
3269 skip(parser_state *p, char term)
3270 {
3271 int c;
3272
3273 for (;;) {
3274 c = nextc(p);
3275 if (c < 0) break;
3276 if (c == term) break;
3277 }
3278 }
3279
3280 static int
3281 peek_n(parser_state *p, int c, int n)
3282 {
3283 node *list = 0;
3284 int c0;
3285
3286 do {
3287 c0 = nextc(p);
3288 if (c0 < 0) return FALSE;
3289 list = push(list, (node*)(intptr_t)c0);
3290 } while(n--);
3291 if (p->pb) {
3292 p->pb = push(p->pb, (node*)list);
3293 }
3294 else {
3295 p->pb = list;
3296 }
3297 if (c0 == c) return TRUE;
3298 return FALSE;
3299 }
3300 #define peek(p,c) peek_n((p), (c), 0)
3301
3302 static int
3303 peeks(parser_state *p, const char *s)
3304 {
3305 int len = strlen(s);
3306
3307 if (p->f) {
3308 int n = 0;
3309 while (*s) {
3310 if (!peek_n(p, *s++, n++)) return FALSE;
3311 }
3312 return TRUE;
3313 }
3314 else if (p->s && p->s + len >= p->send) {
3315 if (memcmp(p->s, s, len) == 0) return TRUE;
3316 }
3317 return FALSE;
3318 }
3319
3320 static int
3321 skips(parser_state *p, const char *s)
3322 {
3323 int c;
3324
3325 for (;;) {
3326 // skip until first char
3327 for (;;) {
3328 c = nextc(p);
3329 if (c < 0) return c;
3330 if (c == *s) break;
3331 }
3332 s++;
3333 if (peeks(p, s)) {
3334 int len = strlen(s);
3335
3336 while (len--) {
3337 nextc(p);
3338 }
3339 return TRUE;
3340 }
3341 else{
3342 s--;
3343 }
3344 }
3345 return FALSE;
3346 }
3347
3348
3349 static int
3350 newtok(parser_state *p)
3351 {
3352 p->bidx = 0;
3353 return p->column - 1;
3354 }
3355
3356 static void
3357 tokadd(parser_state *p, int c)
3358 {
3359 if (p->bidx < MRB_PARSER_BUF_SIZE) {
3360 p->buf[p->bidx++] = c;
3361 }
3362 }
3363
3364 static int
3365 toklast(parser_state *p)
3366 {
3367 return p->buf[p->bidx-1];
3368 }
3369
3370 static void
3371 tokfix(parser_state *p)
3372 {
3373 if (p->bidx >= MRB_PARSER_BUF_SIZE) {
3374 yyerror(p, "string too long (truncated)");
3375 }
3376 p->buf[p->bidx] = '\0';
3377 }
3378
3379 static const char*
3380 tok(parser_state *p)
3381 {
3382 return p->buf;
3383 }
3384
3385 static int
3386 toklen(parser_state *p)
3387 {
3388 return p->bidx;
3389 }
3390
3391 #define IS_ARG() (p->lstate == EXPR_ARG || p->lstate == EXPR_CMDARG)
3392 #define IS_END() (p->lstate == EXPR_END || p->lstate == EXPR_ENDARG || p->lstate == EXPR_ENDFN)
3393 #define IS_BEG() (p->lstate == EXPR_BEG || p->lstate == EXPR_MID || p->lstate == EXPR_VALUE || p->lstate == EXPR_CLASS)
3394 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
3395 #define IS_LABEL_POSSIBLE() ((p->lstate == EXPR_BEG && !cmd_state) || IS_ARG())
3396 #define IS_LABEL_SUFFIX(n) (peek_n(p, ':',(n)) && !peek_n(p, ':', (n)+1))
3397
3398 static int
3399 scan_oct(const int *start, int len, int *retlen)
3400 {
3401 const int *s = start;
3402 int retval = 0;
3403
3404 /* assert(len <= 3) */
3405 while (len-- && *s >= '0' && *s <= '7') {
3406 retval <<= 3;
3407 retval |= *s++ - '0';
3408 }
3409 *retlen = s - start;
3410
3411 return retval;
3412 }
3413
3414 static int
3415 scan_hex(const int *start, int len, int *retlen)
3416 {
3417 static const char hexdigit[] = "0123456789abcdef0123456789ABCDEF";
3418 register const int *s = start;
3419 register int retval = 0;
3420 char *tmp;
3421
3422 /* assert(len <= 2) */
3423 while (len-- && *s && (tmp = strchr(hexdigit, *s))) {
3424 retval <<= 4;
3425 retval |= (tmp - hexdigit) & 15;
3426 s++;
3427 }
3428 *retlen = s - start;
3429
3430 return retval;
3431 }
3432
3433 static int
3434 read_escape(parser_state *p)
3435 {
3436 int c;
3437
3438 switch (c = nextc(p)) {
3439 case '\\': /* Backslash */
3440 return c;
3441
3442 case 'n': /* newline */
3443 return '\n';
3444
3445 case 't': /* horizontal tab */
3446 return '\t';
3447
3448 case 'r': /* carriage-return */
3449 return '\r';
3450
3451 case 'f': /* form-feed */
3452 return '\f';
3453
3454 case 'v': /* vertical tab */
3455 return '\13';
3456
3457 case 'a': /* alarm(bell) */
3458 return '\007';
3459
3460 case 'e': /* escape */
3461 return 033;
3462
3463 case '0': case '1': case '2': case '3': /* octal constant */
3464 case '4': case '5': case '6': case '7':
3465 {
3466 int buf[3];
3467 int i;
3468
3469 buf[0] = c;
3470 for (i=1; i<3; i++) {
3471 buf[i] = nextc(p);
3472 if (buf[i] == -1) goto eof;
3473 if (buf[i] < '0' || '7' < buf[i]) {
3474 pushback(p, buf[i]);
3475 break;
3476 }
3477 }
3478 c = scan_oct(buf, i, &i);
3479 }
3480 return c;
3481
3482 case 'x': /* hex constant */
3483 {
3484 int buf[2];
3485 int i;
3486
3487 for (i=0; i<2; i++) {
3488 buf[i] = nextc(p);
3489 if (buf[i] == -1) goto eof;
3490 if (!isxdigit(buf[i])) {
3491 pushback(p, buf[i]);
3492 break;
3493 }
3494 }
3495 c = scan_hex(buf, i, &i);
3496 if (i == 0) {
3497 yyerror(p, "Invalid escape character syntax");
3498 return 0;
3499 }
3500 }
3501 return c;
3502
3503 case 'b': /* backspace */
3504 return '\010';
3505
3506 case 's': /* space */
3507 return ' ';
3508
3509 case 'M':
3510 if ((c = nextc(p)) != '-') {
3511 yyerror(p, "Invalid escape character syntax");
3512 pushback(p, c);
3513 return '\0';
3514 }
3515 if ((c = nextc(p)) == '\\') {
3516 return read_escape(p) | 0x80;
3517 }
3518 else if (c == -1) goto eof;
3519 else {
3520 return ((c & 0xff) | 0x80);
3521 }
3522
3523 case 'C':
3524 if ((c = nextc(p)) != '-') {
3525 yyerror(p, "Invalid escape character syntax");
3526 pushback(p, c);
3527 return '\0';
3528 }
3529 case 'c':
3530 if ((c = nextc(p))== '\\') {
3531 c = read_escape(p);
3532 }
3533 else if (c == '?')
3534 return 0177;
3535 else if (c == -1) goto eof;
3536 return c & 0x9f;
3537
3538 eof:
3539 case -1:
3540 yyerror(p, "Invalid escape character syntax");
3541 return '\0';
3542
3543 default:
3544 return c;
3545 }
3546 }
3547
3548
3549 static int
3550 parse_string(parser_state *p)
3551 {
3552 int c;
3553 string_type type = (string_type)(intptr_t)p->lex_strterm->car;
3554 int nest_level = (intptr_t)p->lex_strterm->cdr->car;
3555 int beg = (intptr_t)p->lex_strterm->cdr->cdr->car;
3556 int end = (intptr_t)p->lex_strterm->cdr->cdr->cdr;
3557 parser_heredoc_info *hinf = (type & STR_FUNC_HEREDOC) ? parsing_heredoc_inf(p) : NULL;
3558
3559 newtok(p);
3560 while ((c = nextc(p)) != end || nest_level != 0) {
3561 if (hinf && (c == '\n' || c == -1)) {
3562 int line_head;
3563 tokadd(p, '\n');
3564 tokfix(p);
3565 p->lineno++;
3566 p->column = 0;
3567 line_head = hinf->line_head;
3568 hinf->line_head = TRUE;
3569 if (line_head) {
3570 /* check whether end of heredoc */
3571 const char *s = tok(p);
3572 int len = toklen(p);
3573 if (hinf->allow_indent) {
3574 while (ISSPACE(*s) && len > 0) {
3575 ++s;
3576 --len;
3577 }
3578 }
3579 if ((len-1 == hinf->term_len) && (strncmp(s, hinf->term, len-1) == 0)) {
3580 return tHEREDOC_END;
3581 }
3582 }
3583 if (c == -1) {
3584 char buf[256];
3585 snprintf(buf, sizeof(buf), "can't find string \"%s\" anywhere before EOF", hinf->term);
3586 yyerror(p, buf);
3587 return 0;
3588 }
3589 yylval.nd = new_str(p, tok(p), toklen(p));
3590 return tSTRING_MID;
3591 }
3592 if (c == -1) {
3593 yyerror(p, "unterminated string meets end of file");
3594 return 0;
3595 }
3596 else if (c == beg) {
3597 nest_level++;
3598 p->lex_strterm->cdr->car = (node*)(intptr_t)nest_level;
3599 }
3600 else if (c == end) {
3601 nest_level--;
3602 p->lex_strterm->cdr->car = (node*)(intptr_t)nest_level;
3603 }
3604 else if (c == '\\') {
3605 c = nextc(p);
3606 if (type & STR_FUNC_EXPAND) {
3607 if (c == end || c == beg) {
3608 tokadd(p, c);
3609 }
3610 else if ((c == '\n') && (type & STR_FUNC_ARRAY)) {
3611 p->lineno++;
3612 p->column = 0;
3613 tokadd(p, '\n');
3614 }
3615 else {
3616 pushback(p, c);
3617
3618 if(type & STR_FUNC_REGEXP)
3619 tokadd(p, '\\');
3620
3621 tokadd(p, read_escape(p));
3622 if (hinf)
3623 hinf->line_head = FALSE;
3624 }
3625 } else {
3626 if (c != beg && c != end) {
3627 switch (c) {
3628 case '\n':
3629 p->lineno++;
3630 p->column = 0;
3631 break;
3632
3633 case '\\':
3634 break;
3635
3636 default:
3637 if (! ISSPACE(c))
3638 tokadd(p, '\\');
3639 }
3640 }
3641 tokadd(p, c);
3642 }
3643 continue;
3644 }
3645 else if ((c == '#') && (type & STR_FUNC_EXPAND)) {
3646 c = nextc(p);
3647 if (c == '{') {
3648 tokfix(p);
3649 p->lstate = EXPR_BEG;
3650 p->cmd_start = TRUE;
3651 yylval.nd = new_str(p, tok(p), toklen(p));
3652 if (hinf)
3653 hinf->line_head = FALSE;
3654 return tSTRING_PART;
3655 }
3656 tokadd(p, '#');
3657 pushback(p, c);
3658 continue;
3659 }
3660 if ((type & STR_FUNC_ARRAY) && ISSPACE(c)) {
3661 if (toklen(p) == 0) {
3662 do {
3663 if (c == '\n') {
3664 p->lineno++;
3665 p->column = 0;
3666 }
3667 } while (ISSPACE(c = nextc(p)));
3668 pushback(p, c);
3669 return tLITERAL_DELIM;
3670 } else {
3671 pushback(p, c);
3672 tokfix(p);
3673 yylval.nd = new_str(p, tok(p), toklen(p));
3674 return tSTRING_MID;
3675 }
3676 }
3677
3678 tokadd(p, c);
3679
3680 }
3681
3682 tokfix(p);
3683 p->lstate = EXPR_END;
3684 end_strterm(p);
3685
3686 if (type & STR_FUNC_XQUOTE) {
3687 yylval.nd = new_xstr(p, tok(p), toklen(p));
3688 return tXSTRING;
3689 }
3690
3691 if (type & STR_FUNC_REGEXP) {
3692 int f = 0;
3693 int c;
3694 char *s = strndup(tok(p), toklen(p));
3695 char flag[4] = { '\0' };
3696
3697 newtok(p);
3698 while (c = nextc(p), ISALPHA(c)) {
3699 switch (c) {
3700 case 'i': f |= 1; break;
3701 case 'x': f |= 2; break;
3702 case 'm': f |= 4; break;
3703 default: tokadd(p, c); break;
3704 }
3705 }
3706 pushback(p, c);
3707 if (toklen(p)) {
3708 char msg[128];
3709 tokfix(p);
3710 snprintf(msg, sizeof(msg), "unknown regexp option%s - %s",
3711 toklen(p) > 1 ? "s" : "", tok(p));
3712 yyerror(p, msg);
3713 }
3714 if (f & 1) strcat(flag, "i");
3715 if (f & 2) strcat(flag, "x");
3716 if (f & 4) strcat(flag, "m");
3717 yylval.nd = new_regx(p, s, strdup(flag));
3718
3719 return tREGEXP;
3720 }
3721
3722 yylval.nd = new_str(p, tok(p), toklen(p));
3723 return tSTRING;
3724 }
3725
3726
3727 static int
3728 heredoc_identifier(parser_state *p)
3729 {
3730 int c;
3731 int type = str_heredoc;
3732 int indent = FALSE;
3733 int quote = FALSE;
3734 node *newnode;
3735 parser_heredoc_info *info;
3736
3737 c = nextc(p);
3738 if (ISSPACE(c) || c == '=') {
3739 pushback(p, c);
3740 return 0;
3741 }
3742 if (c == '-') {
3743 indent = TRUE;
3744 c = nextc(p);
3745 }
3746 if (c == '\'' || c == '"') {
3747 int term = c;
3748 if (c == '\'')
3749 quote = TRUE;
3750 newtok(p);
3751 while ((c = nextc(p)) != -1 && c != term) {
3752 if (c == '\n') {
3753 c = -1;
3754 break;
3755 }
3756 tokadd(p, c);
3757 }
3758 if (c == -1) {
3759 yyerror(p, "unterminated here document identifier");
3760 return 0;
3761 }
3762 } else {
3763 if (! identchar(c)) {
3764 pushback(p, c);
3765 if (indent) pushback(p, '-');
3766 return 0;
3767 }
3768 newtok(p);
3769 do {
3770 tokadd(p, c);
3771 } while ((c = nextc(p)) != -1 && identchar(c));
3772 pushback(p, c);
3773 }
3774 tokfix(p);
3775 newnode = new_heredoc(p);
3776 info = (parser_heredoc_info*)newnode->cdr;
3777 info->term = strndup(tok(p), toklen(p));
3778 info->term_len = toklen(p);
3779 if (! quote)
3780 type |= STR_FUNC_EXPAND;
3781 info->type = type;
3782 info->allow_indent = indent;
3783 info->line_head = TRUE;
3784 info->doc = NULL;
3785 p->heredocs = push(p->heredocs, newnode);
3786 if (p->parsing_heredoc == NULL) {
3787 node *n = p->heredocs;
3788 while (n->cdr)
3789 n = n->cdr;
3790 p->parsing_heredoc = n;
3791 }
3792 p->heredoc_starts_nextline = TRUE;
3793 p->lstate = EXPR_END;
3794
3795 yylval.nd = newnode;
3796 return tHEREDOC_BEG;
3797 }
3798
3799 static int
3800 arg_ambiguous(parser_state *p)
3801 {
3802 yywarning(p, "ambiguous first argument; put parentheses or even spaces");
3803 return 1;
3804 }
3805
3806 #include "lex.def"
3807
3808 static int
3809 parser_yylex(parser_state *p)
3810 {
3811 register int c;
3812 int space_seen = 0;
3813 int cmd_state;
3814 enum mrb_lex_state_enum last_state;
3815 int token_column;
3816
3817 if (p->lex_strterm) {
3818 if (is_strterm_type(p, STR_FUNC_HEREDOC)) {
3819 if ((p->parsing_heredoc != NULL) && (! p->heredoc_starts_nextline))
3820 return parse_string(p);
3821 }
3822 else
3823 return parse_string(p);
3824 }
3825 cmd_state = p->cmd_start;
3826 p->cmd_start = FALSE;
3827 retry:
3828 last_state = p->lstate;
3829 switch (c = nextc(p)) {
3830 case '\0': /* NUL */
3831 case '\004': /* ^D */
3832 case '\032': /* ^Z */
3833 case -1: /* end of script. */
3834 return 0;
3835
3836 /* white spaces */
3837 case ' ': case '\t': case '\f': case '\r':
3838 case '\13': /* '\v' */
3839 space_seen = 1;
3840 goto retry;
3841
3842 case '#': /* it's a comment */
3843 skip(p, '\n');
3844 /* fall through */
3845 case '\n':
3846 p->heredoc_starts_nextline = FALSE;
3847 if (p->parsing_heredoc != NULL) {
3848 p->lex_strterm = new_strterm(p, parsing_heredoc_inf(p)->type, 0, 0);
3849 goto normal_newline;
3850 }
3851 switch (p->lstate) {
3852 case EXPR_BEG:
3853 case EXPR_FNAME:
3854 case EXPR_DOT:
3855 case EXPR_CLASS:
3856 case EXPR_VALUE:
3857 p->lineno++;
3858 p->column = 0;
3859 goto retry;
3860 default:
3861 break;
3862 }
3863 while ((c = nextc(p))) {
3864 switch (c) {
3865 case ' ': case '\t': case '\f': case '\r':
3866 case '\13': /* '\v' */
3867 space_seen = 1;
3868 break;
3869 case '.':
3870 if ((c = nextc(p)) != '.') {
3871 pushback(p, c);
3872 pushback(p, '.');
3873 goto retry;
3874 }
3875 case -1: /* EOF */
3876 goto normal_newline;
3877 default:
3878 pushback(p, c);
3879 goto normal_newline;
3880 }
3881 }
3882 normal_newline:
3883 p->cmd_start = TRUE;
3884 p->lstate = EXPR_BEG;
3885 return '\n';
3886
3887 case '*':
3888 if ((c = nextc(p)) == '*') {
3889 if ((c = nextc(p)) == '=') {
3890 yylval.id = intern2("**",2);
3891 p->lstate = EXPR_BEG;
3892 return tOP_ASGN;
3893 }
3894 pushback(p, c);
3895 c = tPOW;
3896 }
3897 else {
3898 if (c == '=') {
3899 yylval.id = intern_c('*');
3900 p->lstate = EXPR_BEG;
3901 return tOP_ASGN;
3902 }
3903 pushback(p, c);
3904 if (IS_SPCARG(c)) {
3905 yywarning(p, "`*' interpreted as argument prefix");
3906 c = tSTAR;
3907 }
3908 else if (IS_BEG()) {
3909 c = tSTAR;
3910 }
3911 else {
3912 c = '*';
3913 }
3914 }
3915 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
3916 p->lstate = EXPR_ARG;
3917 } else {
3918 p->lstate = EXPR_BEG;
3919 }
3920 return c;
3921
3922 case '!':
3923 c = nextc(p);
3924 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
3925 p->lstate = EXPR_ARG;
3926 if (c == '@') {
3927 return '!';
3928 }
3929 }
3930 else {
3931 p->lstate = EXPR_BEG;
3932 }
3933 if (c == '=') {
3934 return tNEQ;
3935 }
3936 if (c == '~') {
3937 return tNMATCH;
3938 }
3939 pushback(p, c);
3940 return '!';
3941
3942 case '=':
3943 if (p->column == 1) {
3944 if (peeks(p, "begin\n")) {
3945 skips(p, "\n=end\n");
3946 goto retry;
3947 }
3948 }
3949 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
3950 p->lstate = EXPR_ARG;
3951 } else {
3952 p->lstate = EXPR_BEG;
3953 }
3954 if ((c = nextc(p)) == '=') {
3955 if ((c = nextc(p)) == '=') {
3956 return tEQQ;
3957 }
3958 pushback(p, c);
3959 return tEQ;
3960 }
3961 if (c == '~') {
3962 return tMATCH;
3963 }
3964 else if (c == '>') {
3965 return tASSOC;
3966 }
3967 pushback(p, c);
3968 return '=';
3969
3970 case '<':
3971 last_state = p->lstate;
3972 c = nextc(p);
3973 if (c == '<' &&
3974 p->lstate != EXPR_DOT &&
3975 p->lstate != EXPR_CLASS &&
3976 !IS_END() &&
3977 (!IS_ARG() || space_seen)) {
3978 int token = heredoc_identifier(p);
3979 if (token)
3980 return token;
3981 }
3982 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
3983 p->lstate = EXPR_ARG;
3984 } else {
3985 p->lstate = EXPR_BEG;
3986 if (p->lstate == EXPR_CLASS) {
3987 p->cmd_start = TRUE;
3988 }
3989 }
3990 if (c == '=') {
3991 if ((c = nextc(p)) == '>') {
3992 return tCMP;
3993 }
3994 pushback(p, c);
3995 return tLEQ;
3996 }
3997 if (c == '<') {
3998 if ((c = nextc(p)) == '=') {
3999 yylval.id = intern2("<<",2);
4000 p->lstate = EXPR_BEG;
4001 return tOP_ASGN;
4002 }
4003 pushback(p, c);
4004 return tLSHFT;
4005 }
4006 pushback(p, c);
4007 return '<';
4008
4009 case '>':
4010 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
4011 p->lstate = EXPR_ARG;
4012 } else {
4013 p->lstate = EXPR_BEG;
4014 }
4015 if ((c = nextc(p)) == '=') {
4016 return tGEQ;
4017 }
4018 if (c == '>') {
4019 if ((c = nextc(p)) == '=') {
4020 yylval.id = intern2(">>",2);
4021 p->lstate = EXPR_BEG;
4022 return tOP_ASGN;
4023 }
4024 pushback(p, c);
4025 return tRSHFT;
4026 }
4027 pushback(p, c);
4028 return '>';
4029
4030 case '"':
4031 p->lex_strterm = new_strterm(p, str_dquote, '"', 0);
4032 return tSTRING_BEG;
4033
4034 case '\'':
4035 p->lex_strterm = new_strterm(p, str_squote, '\'', 0);
4036 return parse_string(p);
4037
4038 case '`':
4039 if (p->lstate == EXPR_FNAME) {
4040 p->lstate = EXPR_ENDFN;
4041 return '`';
4042 }
4043 if (p->lstate == EXPR_DOT) {
4044 if (cmd_state)
4045 p->lstate = EXPR_CMDARG;
4046 else
4047 p->lstate = EXPR_ARG;
4048 return '`';
4049 }
4050 p->lex_strterm = new_strterm(p, str_xquote, '`', 0);
4051 return tXSTRING_BEG;
4052
4053 case '?':
4054 if (IS_END()) {
4055 p->lstate = EXPR_VALUE;
4056 return '?';
4057 }
4058 c = nextc(p);
4059 if (c == -1) {
4060 yyerror(p, "incomplete character syntax");
4061 return 0;
4062 }
4063 if (isspace(c)) {
4064 if (!IS_ARG()) {
4065 int c2;
4066 switch (c) {
4067 case ' ':
4068 c2 = 's';
4069 break;
4070 case '\n':
4071 c2 = 'n';
4072 break;
4073 case '\t':
4074 c2 = 't';
4075 break;
4076 case '\v':
4077 c2 = 'v';
4078 break;
4079 case '\r':
4080 c2 = 'r';
4081 break;
4082 case '\f':
4083 c2 = 'f';
4084 break;
4085 default:
4086 c2 = 0;
4087 break;
4088 }
4089 if (c2) {
4090 char buf[256];
4091 snprintf(buf, sizeof(buf), "invalid character syntax; use ?\\%c", c2);
4092 yyerror(p, buf);
4093 }
4094 }
4095 ternary:
4096 pushback(p, c);
4097 p->lstate = EXPR_VALUE;
4098 return '?';
4099 }
4100 token_column = newtok(p);
4101 // need support UTF-8 if configured
4102 if ((isalnum(c) || c == '_')) {
4103 int c2 = nextc(p);
4104 pushback(p, c2);
4105 if ((isalnum(c2) || c2 == '_')) {
4106 goto ternary;
4107 }
4108 }
4109 if (c == '\\') {
4110 c = nextc(p);
4111 if (c == 'u') {
4112 #if 0
4113 tokadd_utf8(p);
4114 #endif
4115 }
4116 else {
4117 pushback(p, c);
4118 c = read_escape(p);
4119 tokadd(p, c);
4120 }
4121 }
4122 else {
4123 tokadd(p, c);
4124 }
4125 tokfix(p);
4126 yylval.nd = new_str(p, tok(p), toklen(p));
4127 p->lstate = EXPR_END;
4128 return tCHAR;
4129
4130 case '&':
4131 if ((c = nextc(p)) == '&') {
4132 p->lstate = EXPR_BEG;
4133 if ((c = nextc(p)) == '=') {
4134 yylval.id = intern2("&&",2);
4135 p->lstate = EXPR_BEG;
4136 return tOP_ASGN;
4137 }
4138 pushback(p, c);
4139 return tANDOP;
4140 }
4141 else if (c == '=') {
4142 yylval.id = intern_c('&');
4143 p->lstate = EXPR_BEG;
4144 return tOP_ASGN;
4145 }
4146 pushback(p, c);
4147 if (IS_SPCARG(c)) {
4148 yywarning(p, "`&' interpreted as argument prefix");
4149 c = tAMPER;
4150 }
4151 else if (IS_BEG()) {
4152 c = tAMPER;
4153 }
4154 else {
4155 c = '&';
4156 }
4157 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
4158 p->lstate = EXPR_ARG;
4159 } else {
4160 p->lstate = EXPR_BEG;
4161 }
4162 return c;
4163
4164 case '|':
4165 if ((c = nextc(p)) == '|') {
4166 p->lstate = EXPR_BEG;
4167 if ((c = nextc(p)) == '=') {
4168 yylval.id = intern2("||",2);
4169 p->lstate = EXPR_BEG;
4170 return tOP_ASGN;
4171 }
4172 pushback(p, c);
4173 return tOROP;
4174 }
4175 if (c == '=') {
4176 yylval.id = intern_c('|');
4177 p->lstate = EXPR_BEG;
4178 return tOP_ASGN;
4179 }
4180 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
4181 p->lstate = EXPR_ARG;
4182 }
4183 else {
4184 p->lstate = EXPR_BEG;
4185 }
4186 pushback(p, c);
4187 return '|';
4188
4189 case '+':
4190 c = nextc(p);
4191 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
4192 p->lstate = EXPR_ARG;
4193 if (c == '@') {
4194 return tUPLUS;
4195 }
4196 pushback(p, c);
4197 return '+';
4198 }
4199 if (c == '=') {
4200 yylval.id = intern_c('+');
4201 p->lstate = EXPR_BEG;
4202 return tOP_ASGN;
4203 }
4204 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p))) {
4205 p->lstate = EXPR_BEG;
4206 pushback(p, c);
4207 if (c != -1 && ISDIGIT(c)) {
4208 c = '+';
4209 goto start_num;
4210 }
4211 return tUPLUS;
4212 }
4213 p->lstate = EXPR_BEG;
4214 pushback(p, c);
4215 return '+';
4216
4217 case '-':
4218 c = nextc(p);
4219 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
4220 p->lstate = EXPR_ARG;
4221 if (c == '@') {
4222 return tUMINUS;
4223 }
4224 pushback(p, c);
4225 return '-';
4226 }
4227 if (c == '=') {
4228 yylval.id = intern_c('-');
4229 p->lstate = EXPR_BEG;
4230 return tOP_ASGN;
4231 }
4232 if (c == '>') {
4233 p->lstate = EXPR_ENDFN;
4234 return tLAMBDA;
4235 }
4236 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous(p))) {
4237 p->lstate = EXPR_BEG;
4238 pushback(p, c);
4239 if (c != -1 && ISDIGIT(c)) {
4240 return tUMINUS_NUM;
4241 }
4242 return tUMINUS;
4243 }
4244 p->lstate = EXPR_BEG;
4245 pushback(p, c);
4246 return '-';
4247
4248 case '.':
4249 p->lstate = EXPR_BEG;
4250 if ((c = nextc(p)) == '.') {
4251 if ((c = nextc(p)) == '.') {
4252 return tDOT3;
4253 }
4254 pushback(p, c);
4255 return tDOT2;
4256 }
4257 pushback(p, c);
4258 if (c != -1 && ISDIGIT(c)) {
4259 yyerror(p, "no .<digit> floating literal anymore; put 0 before dot");
4260 }
4261 p->lstate = EXPR_DOT;
4262 return '.';
4263
4264 start_num:
4265 case '0': case '1': case '2': case '3': case '4':
4266 case '5': case '6': case '7': case '8': case '9':
4267 {
4268 int is_float, seen_point, seen_e, nondigit;
4269
4270 is_float = seen_point = seen_e = nondigit = 0;
4271 p->lstate = EXPR_END;
4272 token_column = newtok(p);
4273 if (c == '-' || c == '+') {
4274 tokadd(p, c);
4275 c = nextc(p);
4276 }
4277 if (c == '0') {
4278 #define no_digits() do {yyerror(p,"numeric literal without digits"); return 0;} while (0)
4279 int start = toklen(p);
4280 c = nextc(p);
4281 if (c == 'x' || c == 'X') {
4282 /* hexadecimal */
4283 c = nextc(p);
4284 if (c != -1 && ISXDIGIT(c)) {
4285 do {
4286 if (c == '_') {
4287 if (nondigit) break;
4288 nondigit = c;
4289 continue;
4290 }
4291 if (!ISXDIGIT(c)) break;
4292 nondigit = 0;
4293 tokadd(p, tolower(c));
4294 } while ((c = nextc(p)) != -1);
4295 }
4296 pushback(p, c);
4297 tokfix(p);
4298 if (toklen(p) == start) {
4299 no_digits();
4300 }
4301 else if (nondigit) goto trailing_uc;
4302 yylval.nd = new_int(p, tok(p), 16);
4303 return tINTEGER;
4304 }
4305 if (c == 'b' || c == 'B') {
4306 /* binary */
4307 c = nextc(p);
4308 if (c == '0' || c == '1') {
4309 do {
4310 if (c == '_') {
4311 if (nondigit) break;
4312 nondigit = c;
4313 continue;
4314 }
4315 if (c != '0' && c != '1') break;
4316 nondigit = 0;
4317 tokadd(p, c);
4318 } while ((c = nextc(p)) != -1);
4319 }
4320 pushback(p, c);
4321 tokfix(p);
4322 if (toklen(p) == start) {
4323 no_digits();
4324 }
4325 else if (nondigit) goto trailing_uc;
4326 yylval.nd = new_int(p, tok(p), 2);
4327 return tINTEGER;
4328 }
4329 if (c == 'd' || c == 'D') {
4330 /* decimal */
4331 c = nextc(p);
4332 if (c != -1 && ISDIGIT(c)) {
4333 do {
4334 if (c == '_') {
4335 if (nondigit) break;
4336 nondigit = c;
4337 continue;
4338 }
4339 if (!ISDIGIT(c)) break;
4340 nondigit = 0;
4341 tokadd(p, c);
4342 } while ((c = nextc(p)) != -1);
4343 }
4344 pushback(p, c);
4345 tokfix(p);
4346 if (toklen(p) == start) {
4347 no_digits();
4348 }
4349 else if (nondigit) goto trailing_uc;
4350 yylval.nd = new_int(p, tok(p), 10);
4351 return tINTEGER;
4352 }
4353 if (c == '_') {
4354 /* 0_0 */
4355 goto octal_number;
4356 }
4357 if (c == 'o' || c == 'O') {
4358 /* prefixed octal */
4359 c = nextc(p);
4360 if (c == -1 || c == '_' || !ISDIGIT(c)) {
4361 no_digits();
4362 }
4363 }
4364 if (c >= '0' && c <= '7') {
4365 /* octal */
4366 octal_number:
4367 do {
4368 if (c == '_') {
4369 if (nondigit) break;
4370 nondigit = c;
4371 continue;
4372 }
4373 if (c < '0' || c > '9') break;
4374 if (c > '7') goto invalid_octal;
4375 nondigit = 0;
4376 tokadd(p, c);
4377 } while ((c = nextc(p)) != -1);
4378
4379 if (toklen(p) > start) {
4380 pushback(p, c);
4381 tokfix(p);
4382 if (nondigit) goto trailing_uc;
4383 yylval.nd = new_int(p, tok(p), 8);
4384 return tINTEGER;
4385 }
4386 if (nondigit) {
4387 pushback(p, c);
4388 goto trailing_uc;
4389 }
4390 }
4391 if (c > '7' && c <= '9') {
4392 invalid_octal:
4393 yyerror(p, "Invalid octal digit");
4394 }
4395 else if (c == '.' || c == 'e' || c == 'E') {
4396 tokadd(p, '0');
4397 }
4398 else {
4399 pushback(p, c);
4400 yylval.nd = new_int(p, "0", 10);
4401 return tINTEGER;
4402 }
4403 }
4404
4405 for (;;) {
4406 switch (c) {
4407 case '0': case '1': case '2': case '3': case '4':
4408 case '5': case '6': case '7': case '8': case '9':
4409 nondigit = 0;
4410 tokadd(p, c);
4411 break;
4412
4413 case '.':
4414 if (nondigit) goto trailing_uc;
4415 if (seen_point || seen_e) {
4416 goto decode_num;
4417 }
4418 else {
4419 int c0 = nextc(p);
4420 if (c0 == -1 || !ISDIGIT(c0)) {
4421 pushback(p, c0);
4422 goto decode_num;
4423 }
4424 c = c0;
4425 }
4426 tokadd(p, '.');
4427 tokadd(p, c);
4428 is_float++;
4429 seen_point++;
4430 nondigit = 0;
4431 break;
4432
4433 case 'e':
4434 case 'E':
4435 if (nondigit) {
4436 pushback(p, c);
4437 c = nondigit;
4438 goto decode_num;
4439 }
4440 if (seen_e) {
4441 goto decode_num;
4442 }
4443 tokadd(p, c);
4444 seen_e++;
4445 is_float++;
4446 nondigit = c;
4447 c = nextc(p);
4448 if (c != '-' && c != '+') continue;
4449 tokadd(p, c);
4450 nondigit = c;
4451 break;
4452
4453 case '_': /* `_' in number just ignored */
4454 if (nondigit) goto decode_num;
4455 nondigit = c;
4456 break;
4457
4458 default:
4459 goto decode_num;
4460 }
4461 c = nextc(p);
4462 }
4463
4464 decode_num:
4465 pushback(p, c);
4466 if (nondigit) {
4467 trailing_uc:
4468 yyerror_i(p, "trailing `%c' in number", nondigit);
4469 }
4470 tokfix(p);
4471 if (is_float) {
4472 double d;
4473 char *endp;
4474
4475 errno = 0;
4476 d = strtod(tok(p), &endp);
4477 if (d == 0 && endp == tok(p)) {
4478 yywarning_s(p, "corrupted float value %s", tok(p));
4479 }
4480 else if (errno == ERANGE) {
4481 yywarning_s(p, "float %s out of range", tok(p));
4482 errno = 0;
4483 }
4484 yylval.nd = new_float(p, tok(p));
4485 return tFLOAT;
4486 }
4487 yylval.nd = new_int(p, tok(p), 10);
4488 return tINTEGER;
4489 }
4490
4491 case ')':
4492 case ']':
4493 p->paren_nest--;
4494 case '}':
4495 COND_LEXPOP();
4496 CMDARG_LEXPOP();
4497 if (c == ')')
4498 p->lstate = EXPR_ENDFN;
4499 else
4500 p->lstate = EXPR_ENDARG;
4501 return c;
4502
4503 case ':':
4504 c = nextc(p);
4505 if (c == ':') {
4506 if (IS_BEG() || p->lstate == EXPR_CLASS || IS_SPCARG(-1)) {
4507 p->lstate = EXPR_BEG;
4508 return tCOLON3;
4509 }
4510 p->lstate = EXPR_DOT;
4511 return tCOLON2;
4512 }
4513 if (IS_END() || ISSPACE(c)) {
4514 pushback(p, c);
4515 p->lstate = EXPR_BEG;
4516 return ':';
4517 }
4518 pushback(p, c);
4519 p->lstate = EXPR_FNAME;
4520 return tSYMBEG;
4521
4522 case '/':
4523 if (IS_BEG()) {
4524 p->lex_strterm = new_strterm(p, str_regexp, '/', 0);
4525 return tREGEXP_BEG;
4526 }
4527 if ((c = nextc(p)) == '=') {
4528 yylval.id = intern_c('/');
4529 p->lstate = EXPR_BEG;
4530 return tOP_ASGN;
4531 }
4532 pushback(p, c);
4533 if (IS_SPCARG(c)) {
4534 p->lex_strterm = new_strterm(p, str_regexp, '/', 0);
4535 return tREGEXP_BEG;
4536 }
4537 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
4538 p->lstate = EXPR_ARG;
4539 } else {
4540 p->lstate = EXPR_BEG;
4541 }
4542 return '/';
4543
4544 case '^':
4545 if ((c = nextc(p)) == '=') {
4546 yylval.id = intern_c('^');
4547 p->lstate = EXPR_BEG;
4548 return tOP_ASGN;
4549 }
4550 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
4551 p->lstate = EXPR_ARG;
4552 } else {
4553 p->lstate = EXPR_BEG;
4554 }
4555 pushback(p, c);
4556 return '^';
4557
4558 case ';':
4559 p->lstate = EXPR_BEG;
4560 return ';';
4561
4562 case ',':
4563 p->lstate = EXPR_BEG;
4564 return ',';
4565
4566 case '~':
4567 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
4568 if ((c = nextc(p)) != '@') {
4569 pushback(p, c);
4570 }
4571 p->lstate = EXPR_ARG;
4572 }
4573 else {
4574 p->lstate = EXPR_BEG;
4575 }
4576 return '~';
4577
4578 case '(':
4579 if (IS_BEG()) {
4580 c = tLPAREN;
4581 }
4582 else if (IS_SPCARG(-1)) {
4583 c = tLPAREN_ARG;
4584 }
4585 p->paren_nest++;
4586 COND_PUSH(0);
4587 CMDARG_PUSH(0);
4588 p->lstate = EXPR_BEG;
4589 return c;
4590
4591 case '[':
4592 p->paren_nest++;
4593 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
4594 p->lstate = EXPR_ARG;
4595 if ((c = nextc(p)) == ']') {
4596 if ((c = nextc(p)) == '=') {
4597 return tASET;
4598 }
4599 pushback(p, c);
4600 return tAREF;
4601 }
4602 pushback(p, c);
4603 return '[';
4604 }
4605 else if (IS_BEG()) {
4606 c = tLBRACK;
4607 }
4608 else if (IS_ARG() && space_seen) {
4609 c = tLBRACK;
4610 }
4611 p->lstate = EXPR_BEG;
4612 COND_PUSH(0);
4613 CMDARG_PUSH(0);
4614 return c;
4615
4616 case '{':
4617 if (p->lpar_beg && p->lpar_beg == p->paren_nest) {
4618 p->lstate = EXPR_BEG;
4619 p->lpar_beg = 0;
4620 p->paren_nest--;
4621 COND_PUSH(0);
4622 CMDARG_PUSH(0);
4623 return tLAMBEG;
4624 }
4625 if (IS_ARG() || p->lstate == EXPR_END || p->lstate == EXPR_ENDFN)
4626 c = '{'; /* block (primary) */
4627 else if (p->lstate == EXPR_ENDARG)
4628 c = tLBRACE_ARG; /* block (expr) */
4629 else
4630 c = tLBRACE; /* hash */
4631 COND_PUSH(0);
4632 CMDARG_PUSH(0);
4633 p->lstate = EXPR_BEG;
4634 return c;
4635
4636 case '\\':
4637 c = nextc(p);
4638 if (c == '\n') {
4639 p->lineno++;
4640 p->column = 0;
4641 space_seen = 1;
4642 goto retry; /* skip \\n */
4643 }
4644 pushback(p, c);
4645 return '\\';
4646
4647 case '%':
4648 if (IS_BEG()) {
4649 int term;
4650 int paren;
4651
4652 c = nextc(p);
4653 quotation:
4654 if (c == -1 || !ISALNUM(c)) {
4655 term = c;
4656 c = 'Q';
4657 }
4658 else {
4659 term = nextc(p);
4660 if (isalnum(term)) {
4661 yyerror(p, "unknown type of %string");
4662 return 0;
4663 }
4664 }
4665 if (c == -1 || term == -1) {
4666 yyerror(p, "unterminated quoted string meets end of file");
4667 return 0;
4668 }
4669 paren = term;
4670 if (term == '(') term = ')';
4671 else if (term == '[') term = ']';
4672 else if (term == '{') term = '}';
4673 else if (term == '<') term = '>';
4674 else paren = 0;
4675
4676 switch (c) {
4677 case 'Q':
4678 p->lex_strterm = new_strterm(p, str_dquote, term, paren);
4679 return tSTRING_BEG;
4680
4681 case 'q':
4682 p->lex_strterm = new_strterm(p, str_squote, term, paren);
4683 return parse_string(p);
4684
4685 case 'W':
4686 p->lex_strterm = new_strterm(p, str_dword, term, paren);
4687 return tWORDS_BEG;
4688
4689 case 'w':
4690 p->lex_strterm = new_strterm(p, str_sword, term, paren);
4691 return tWORDS_BEG;
4692
4693 case 'x':
4694 p->lex_strterm = new_strterm(p, str_xquote, term, paren);
4695 return tXSTRING_BEG;
4696
4697 case 'r':
4698 p->lex_strterm = new_strterm(p, str_regexp, term, paren);
4699 return tREGEXP_BEG;
4700
4701 case 's':
4702 p->lex_strterm = new_strterm(p, str_ssym, term, paren);
4703 return tSYMBEG;
4704
4705 case 'I':
4706 p->lex_strterm = new_strterm(p, str_dsymbols, term, paren);
4707 return tSYMBOLS_BEG;
4708
4709 case 'i':
4710 p->lex_strterm = new_strterm(p, str_ssymbols, term, paren);
4711 return tSYMBOLS_BEG;
4712
4713 default:
4714 yyerror(p, "unknown type of %string");
4715 return 0;
4716 }
4717 }
4718 if ((c = nextc(p)) == '=') {
4719 yylval.id = intern_c('%');
4720 p->lstate = EXPR_BEG;
4721 return tOP_ASGN;
4722 }
4723 if (IS_SPCARG(c)) {
4724 goto quotation;
4725 }
4726 if (p->lstate == EXPR_FNAME || p->lstate == EXPR_DOT) {
4727 p->lstate = EXPR_ARG;
4728 } else {
4729 p->lstate = EXPR_BEG;
4730 }
4731 pushback(p, c);
4732 return '%';
4733
4734 case '$':
4735 p->lstate = EXPR_END;
4736 token_column = newtok(p);
4737 c = nextc(p);
4738 switch (c) {
4739 case '_': /* $_: last read line string */
4740 c = nextc(p);
4741 pushback(p, c);
4742 c = '_';
4743 /* fall through */
4744 case '~': /* $~: match-data */
4745 case '*': /* $*: argv */
4746 case '$': /* $$: pid */
4747 case '?': /* $?: last status */
4748 case '!': /* $!: error string */
4749 case '@': /* $@: error position */
4750 case '/': /* $/: input record separator */
4751 case '\\': /* $\: output record separator */
4752 case ';': /* $;: field separator */
4753 case ',': /* $,: output field separator */
4754 case '.': /* $.: last read line number */
4755 case '=': /* $=: ignorecase */
4756 case ':': /* $:: load path */
4757 case '<': /* $<: reading filename */
4758 case '>': /* $>: default output handle */
4759 case '\"': /* $": already loaded files */
4760 tokadd(p, '$');
4761 tokadd(p, c);
4762 tokfix(p);
4763 yylval.id = intern(tok(p));
4764 return tGVAR;
4765
4766 case '-':
4767 tokadd(p, '$');
4768 tokadd(p, c);
4769 c = nextc(p);
4770 pushback(p, c);
4771 gvar:
4772 tokfix(p);
4773 yylval.id = intern(tok(p));
4774 return tGVAR;
4775
4776 case '&': /* $&: last match */
4777 case '`': /* $`: string before last match */
4778 case '\'': /* $': string after last match */
4779 case '+': /* $+: string matches last pattern */
4780 if (last_state == EXPR_FNAME) {
4781 tokadd(p, '$');
4782 tokadd(p, c);
4783 goto gvar;
4784 }
4785 yylval.nd = new_back_ref(p, c);
4786 return tBACK_REF;
4787
4788 case '1': case '2': case '3':
4789 case '4': case '5': case '6':
4790 case '7': case '8': case '9':
4791 do {
4792 tokadd(p, c);
4793 c = nextc(p);
4794 } while (c != -1 && isdigit(c));
4795 pushback(p, c);
4796 if (last_state == EXPR_FNAME) goto gvar;
4797 tokfix(p);
4798 yylval.nd = new_nth_ref(p, atoi(tok(p)));
4799 return tNTH_REF;
4800
4801 default:
4802 if (!identchar(c)) {
4803 pushback(p, c);
4804 return '$';
4805 }
4806 case '0':
4807 tokadd(p, '$');
4808 }
4809 break;
4810
4811 case '@':
4812 c = nextc(p);
4813 token_column = newtok(p);
4814 tokadd(p, '@');
4815 if (c == '@') {
4816 tokadd(p, '@');
4817 c = nextc(p);
4818 }
4819 if (c != -1 && isdigit(c)) {
4820 if (p->bidx == 1) {
4821 yyerror_i(p, "`@%c' is not allowed as an instance variable name", c);
4822 }
4823 else {
4824 yyerror_i(p, "`@@%c' is not allowed as a class variable name", c);
4825 }
4826 return 0;
4827 }
4828 if (!identchar(c)) {
4829 pushback(p, c);
4830 return '@';
4831 }
4832 break;
4833
4834 case '_':
4835 token_column = newtok(p);
4836 break;
4837
4838 default:
4839 if (!identchar(c)) {
4840 yyerror_i(p, "Invalid char `\\x%02X' in expression", c);
4841 goto retry;
4842 }
4843
4844 token_column = newtok(p);
4845 break;
4846 }
4847
4848 do {
4849 tokadd(p, c);
4850 c = nextc(p);
4851 if (c < 0) break;
4852 } while (identchar(c));
4853 if (token_column == 0 && toklen(p) == 7 && (c < 0 || c == '\n') &&
4854 strncmp(tok(p), "__END__", toklen(p)) == 0)
4855 return -1;
4856
4857 switch (tok(p)[0]) {
4858 case '@': case '$':
4859 pushback(p, c);
4860 break;
4861 default:
4862 if ((c == '!' || c == '?') && !peek(p, '=')) {
4863 tokadd(p, c);
4864 }
4865 else {
4866 pushback(p, c);
4867 }
4868 }
4869 tokfix(p);
4870 {
4871 int result = 0;
4872
4873 last_state = p->lstate;
4874 switch (tok(p)[0]) {
4875 case '$':
4876 p->lstate = EXPR_END;
4877 result = tGVAR;
4878 break;
4879 case '@':
4880 p->lstate = EXPR_END;
4881 if (tok(p)[1] == '@')
4882 result = tCVAR;
4883 else
4884 result = tIVAR;
4885 break;
4886
4887 default:
4888 if (toklast(p) == '!' || toklast(p) == '?') {
4889 result = tFID;
4890 }
4891 else {
4892 if (p->lstate == EXPR_FNAME) {
4893 if ((c = nextc(p)) == '=' && !peek(p, '~') && !peek(p, '>') &&
4894 (!peek(p, '=') || (peek_n(p, '>', 1)))) {
4895 result = tIDENTIFIER;
4896 tokadd(p, c);
4897 tokfix(p);
4898 }
4899 else {
4900 pushback(p, c);
4901 }
4902 }
4903 if (result == 0 && isupper((int)tok(p)[0])) {
4904 result = tCONSTANT;
4905 }
4906 else {
4907 result = tIDENTIFIER;
4908 }
4909 }
4910
4911 if (IS_LABEL_POSSIBLE()) {
4912 if (IS_LABEL_SUFFIX(0)) {
4913 p->lstate = EXPR_BEG;
4914 nextc(p);
4915 tokfix(p);
4916 yylval.id = intern(tok(p));
4917 return tLABEL;
4918 }
4919 }
4920 if (p->lstate != EXPR_DOT) {
4921 const struct kwtable *kw;
4922
4923 /* See if it is a reserved word. */
4924 kw = mrb_reserved_word(tok(p), toklen(p));
4925 if (kw) {
4926 enum mrb_lex_state_enum state = p->lstate;
4927 p->lstate = kw->state;
4928 if (state == EXPR_FNAME) {
4929 yylval.id = intern(kw->name);
4930 return kw->id[0];
4931 }
4932 if (p->lstate == EXPR_BEG) {
4933 p->cmd_start = TRUE;
4934 }
4935 if (kw->id[0] == keyword_do) {
4936 if (p->lpar_beg && p->lpar_beg == p->paren_nest) {
4937 p->lpar_beg = 0;
4938 p->paren_nest--;
4939 return keyword_do_LAMBDA;
4940 }
4941 if (COND_P()) return keyword_do_cond;
4942 if (CMDARG_P() && state != EXPR_CMDARG)
4943 return keyword_do_block;
4944 if (state == EXPR_ENDARG || state == EXPR_BEG)
4945 return keyword_do_block;
4946 return keyword_do;
4947 }
4948 if (state == EXPR_BEG || state == EXPR_VALUE)
4949 return kw->id[0];
4950 else {
4951 if (kw->id[0] != kw->id[1])
4952 p->lstate = EXPR_BEG;
4953 return kw->id[1];
4954 }
4955 }
4956 }
4957
4958 if (IS_BEG() || p->lstate == EXPR_DOT || IS_ARG()) {
4959 if (cmd_state) {
4960 p->lstate = EXPR_CMDARG;
4961 }
4962 else {
4963 p->lstate = EXPR_ARG;
4964 }
4965 }
4966 else if (p->lstate == EXPR_FNAME) {
4967 p->lstate = EXPR_ENDFN;
4968 }
4969 else {
4970 p->lstate = EXPR_END;
4971 }
4972 }
4973 {
4974 mrb_sym ident = intern(tok(p));
4975
4976 yylval.id = ident;
4977 #if 0
4978 if (last_state != EXPR_DOT && islower(tok(p)[0]) && lvar_defined(ident)) {
4979 p->lstate = EXPR_END;
4980 }
4981 #endif
4982 }
4983 return result;
4984 }
4985 }
4986
4987 static int
4988 yylex(void *lval, parser_state *p)
4989 {
4990 int t;
4991
4992 p->ylval = lval;
4993 t = parser_yylex(p);
4994
4995 return t;
4996 }
4997
4998 static void
4999 parser_init_cxt(parser_state *p, mrbc_context *cxt)
5000 {
5001 if (!cxt) return;
5002 if (cxt->lineno) p->lineno = cxt->lineno;
5003 if (cxt->filename) p->filename = cxt->filename;
5004 if (cxt->syms) {
5005 int i;
5006
5007 p->locals = cons(0,0);
5008 for (i=0; i<cxt->slen; i++) {
5009 local_add_f(p, cxt->syms[i]);
5010 }
5011 }
5012 p->capture_errors = cxt->capture_errors;
5013 }
5014
5015 static void
5016 parser_update_cxt(parser_state *p, mrbc_context *cxt)
5017 {
5018 node *n, *n0;
5019 int i = 0;
5020
5021 if (!cxt) return;
5022 if ((int)(intptr_t)p->tree->car != NODE_SCOPE) return;
5023 n0 = n = p->tree->cdr->car;
5024 while (n) {
5025 i++;
5026 n = n->cdr;
5027 }
5028 cxt->syms = (mrb_sym *)mrb_realloc(p->mrb, cxt->syms, i*sizeof(mrb_sym));
5029 cxt->slen = i;
5030 for (i=0, n=n0; n; i++,n=n->cdr) {
5031 cxt->syms[i] = sym(n->car);
5032 }
5033 }
5034
5035 void codedump_all(mrb_state*, int);
5036 void parser_dump(mrb_state *mrb, node *tree, int offset);
5037
5038 void
5039 mrb_parser_parse(parser_state *p, mrbc_context *c)
5040 {
5041 if (setjmp(p->jmp) != 0) {
5042 yyerror(p, "memory allocation error");
5043 p->nerr++;
5044 p->tree = 0;
5045 return;
5046 }
5047
5048 p->cmd_start = TRUE;
5049 p->in_def = p->in_single = FALSE;
5050 p->nerr = p->nwarn = 0;
5051 p->lex_strterm = NULL;
5052
5053 parser_init_cxt(p, c);
5054 yyparse(p);
5055 if (!p->tree) {
5056 p->tree = new_nil(p);
5057 }
5058 parser_update_cxt(p, c);
5059 if (c && c->dump_result) {
5060 parser_dump(p->mrb, p->tree, 0);
5061 }
5062 }
5063
5064 parser_state*
5065 mrb_parser_new(mrb_state *mrb)
5066 {
5067 mrb_pool *pool;
5068 parser_state *p;
5069 static const parser_state parser_state_zero = { 0 };
5070
5071 pool = mrb_pool_open(mrb);
5072 if (!pool) return 0;
5073 p = (parser_state *)mrb_pool_alloc(pool, sizeof(parser_state));
5074 if (!p) return 0;
5075
5076 *p = parser_state_zero;
5077 p->mrb = mrb;
5078 p->pool = pool;
5079 p->in_def = p->in_single = 0;
5080
5081 p->s = p->send = NULL;
5082 p->f = NULL;
5083
5084 p->cmd_start = TRUE;
5085 p->in_def = p->in_single = FALSE;
5086
5087 p->capture_errors = 0;
5088 p->lineno = 1;
5089 p->column = 0;
5090 #if defined(PARSER_TEST) || defined(PARSER_DEBUG)
5091 yydebug = 1;
5092 #endif
5093
5094 p->lex_strterm = NULL;
5095 p->heredocs = p->parsing_heredoc = NULL;
5096
5097 return p;
5098 }
5099
5100 void
5101 mrb_parser_free(parser_state *p) {
5102 mrb_pool_close(p->pool);
5103 }
5104
5105 mrbc_context*
5106 mrbc_context_new(mrb_state *mrb)
5107 {
5108 mrbc_context *c;
5109
5110 c = (mrbc_context *)mrb_calloc(mrb, 1, sizeof(mrbc_context));
5111 return c;
5112 }
5113
5114 void
5115 mrbc_context_free(mrb_state *mrb, mrbc_context *cxt)
5116 {
5117 mrb_free(mrb, cxt->syms);
5118 mrb_free(mrb, cxt);
5119 }
5120
5121 const char*
5122 mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s)
5123 {
5124 if (s) {
5125 int len = strlen(s);
5126 char *p = (char *)mrb_alloca(mrb, len + 1);
5127
5128 memcpy(p, s, len + 1);
5129 c->filename = p;
5130 c->lineno = 1;
5131 }
5132 return c->filename;
5133 }
5134
5135 parser_state*
5136 mrb_parse_file(mrb_state *mrb, FILE *f, mrbc_context *c)
5137 {
5138 parser_state *p;
5139
5140 p = mrb_parser_new(mrb);
5141 if (!p) return 0;
5142 p->s = p->send = NULL;
5143 p->f = f;
5144
5145 mrb_parser_parse(p, c);
5146 return p;
5147 }
5148
5149 parser_state*
5150 mrb_parse_nstring(mrb_state *mrb, const char *s, int len, mrbc_context *c)
5151 {
5152 parser_state *p;
5153
5154 p = mrb_parser_new(mrb);
5155 if (!p) return 0;
5156 p->s = s;
5157 p->send = s + len;
5158
5159 mrb_parser_parse(p, c);
5160 return p;
5161 }
5162
5163 parser_state*
5164 mrb_parse_string(mrb_state *mrb, const char *s, mrbc_context *c)
5165 {
5166 return mrb_parse_nstring(mrb, s, strlen(s), c);
5167 }
5168
5169 static mrb_value
5170 load_exec(mrb_state *mrb, parser_state *p, mrbc_context *c)
5171 {
5172 int n;
5173 mrb_value v;
5174
5175 if (!p) {
5176 return mrb_undef_value();
5177 }
5178 if (!p->tree || p->nerr) {
5179 if (p->capture_errors) {
5180 char buf[256];
5181
5182 n = snprintf(buf, sizeof(buf), "line %d: %s\n",
5183 p->error_buffer[0].lineno, p->error_buffer[0].message);
5184 mrb->exc = mrb_obj_ptr(mrb_exc_new(mrb, E_SYNTAX_ERROR, buf, n));
5185 mrb_parser_free(p);
5186 return mrb_undef_value();
5187 }
5188 else {
5189 static const char msg[] = "syntax error";
5190 mrb->exc = mrb_obj_ptr(mrb_exc_new(mrb, E_SYNTAX_ERROR, msg, sizeof(msg) - 1));
5191 mrb_parser_free(p);
5192 return mrb_undef_value();
5193 }
5194 }
5195 n = mrb_generate_code(mrb, p);
5196 mrb_parser_free(p);
5197 if (n < 0) {
5198 static const char msg[] = "codegen error";
5199 mrb->exc = mrb_obj_ptr(mrb_exc_new(mrb, E_SCRIPT_ERROR, msg, sizeof(msg) - 1));
5200 return mrb_nil_value();
5201 }
5202 if (c) {
5203 if (c->dump_result) codedump_all(mrb, n);
5204 if (c->no_exec) return mrb_fixnum_value(n);
5205 }
5206 v = mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
5207 if (mrb->exc) return mrb_nil_value();
5208 return v;
5209 }
5210
5211 mrb_value
5212 mrb_load_file_cxt(mrb_state *mrb, FILE *f, mrbc_context *c)
5213 {
5214 return load_exec(mrb, mrb_parse_file(mrb, f, c), c);
5215 }
5216
5217 mrb_value
5218 mrb_load_file(mrb_state *mrb, FILE *f)
5219 {
5220 return mrb_load_file_cxt(mrb, f, NULL);
5221 }
5222
5223 mrb_value
5224 mrb_load_nstring_cxt(mrb_state *mrb, const char *s, int len, mrbc_context *c)
5225 {
5226 return load_exec(mrb, mrb_parse_nstring(mrb, s, len, c), c);
5227 }
5228
5229 mrb_value
5230 mrb_load_nstring(mrb_state *mrb, const char *s, int len)
5231 {
5232 return mrb_load_nstring_cxt(mrb, s, len, NULL);
5233 }
5234
5235 mrb_value
5236 mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *c)
5237 {
5238 return mrb_load_nstring_cxt(mrb, s, strlen(s), c);
5239 }
5240
5241 mrb_value
5242 mrb_load_string(mrb_state *mrb, const char *s)
5243 {
5244 return mrb_load_string_cxt(mrb, s, NULL);
5245 }
5246
5247 #ifdef ENABLE_STDIO
5248
5249 static void
5250 dump_prefix(int offset)
5251 {
5252 while (offset--) {
5253 putc(' ', stdout);
5254 putc(' ', stdout);
5255 }
5256 }
5257
5258 static void
5259 dump_recur(mrb_state *mrb, node *tree, int offset)
5260 {
5261 while (tree) {
5262 parser_dump(mrb, tree->car, offset);
5263 tree = tree->cdr;
5264 }
5265 }
5266
5267 #endif
5268
5269 void
5270 parser_dump(mrb_state *mrb, node *tree, int offset)
5271 {
5272 #ifdef ENABLE_STDIO
5273 int n;
5274
5275 if (!tree) return;
5276 again:
5277 dump_prefix(offset);
5278 n = (int)(intptr_t)tree->car;
5279 tree = tree->cdr;
5280 switch (n) {
5281 case NODE_BEGIN:
5282 printf("NODE_BEGIN:\n");
5283 dump_recur(mrb, tree, offset+1);
5284 break;
5285
5286 case NODE_RESCUE:
5287 printf("NODE_RESCUE:\n");
5288 if (tree->car) {
5289 dump_prefix(offset+1);
5290 printf("body:\n");
5291 parser_dump(mrb, tree->car, offset+2);
5292 }
5293 tree = tree->cdr;
5294 if (tree->car) {
5295 node *n2 = tree->car;
5296
5297 dump_prefix(offset+1);
5298 printf("rescue:\n");
5299 while (n2) {
5300 node *n3 = n2->car;
5301 if (n3->car) {
5302 dump_prefix(offset+2);
5303 printf("handle classes:\n");
5304 dump_recur(mrb, n3->car, offset+3);
5305 }
5306 if (n3->cdr->car) {
5307 dump_prefix(offset+2);
5308 printf("exc_var:\n");
5309 parser_dump(mrb, n3->cdr->car, offset+3);
5310 }
5311 if (n3->cdr->cdr->car) {
5312 dump_prefix(offset+2);
5313 printf("rescue body:\n");
5314 parser_dump(mrb, n3->cdr->cdr->car, offset+3);
5315 }
5316 n2 = n2->cdr;
5317 }
5318 }
5319 tree = tree->cdr;
5320 if (tree->car) {
5321 dump_prefix(offset+1);
5322 printf("else:\n");
5323 parser_dump(mrb, tree->car, offset+2);
5324 }
5325 break;
5326
5327 case NODE_ENSURE:
5328 printf("NODE_ENSURE:\n");
5329 dump_prefix(offset+1);
5330 printf("body:\n");
5331 parser_dump(mrb, tree->car, offset+2);
5332 dump_prefix(offset+1);
5333 printf("ensure:\n");
5334 parser_dump(mrb, tree->cdr->cdr, offset+2);
5335 break;
5336
5337 case NODE_LAMBDA:
5338 printf("NODE_BLOCK:\n");
5339 goto block;
5340
5341 case NODE_BLOCK:
5342 block:
5343 printf("NODE_BLOCK:\n");
5344 tree = tree->cdr;
5345 if (tree->car) {
5346 node *n = tree->car;
5347
5348 if (n->car) {
5349 dump_prefix(offset+1);
5350 printf("mandatory args:\n");
5351 dump_recur(mrb, n->car, offset+2);
5352 }
5353 n = n->cdr;
5354 if (n->car) {
5355 dump_prefix(offset+1);
5356 printf("optional args:\n");
5357 {
5358 node *n2 = n->car;
5359
5360 while (n2) {
5361 dump_prefix(offset+2);
5362 printf("%s=", mrb_sym2name(mrb, sym(n2->car->car)));
5363 parser_dump(mrb, n2->car->cdr, 0);
5364 n2 = n2->cdr;
5365 }
5366 }
5367 }
5368 n = n->cdr;
5369 if (n->car) {
5370 dump_prefix(offset+1);
5371 printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car)));
5372 }
5373 n = n->cdr;
5374 if (n->car) {
5375 dump_prefix(offset+1);
5376 printf("post mandatory args:\n");
5377 dump_recur(mrb, n->car, offset+2);
5378 }
5379 n = n->cdr;
5380 if (n) {
5381 dump_prefix(offset+1);
5382 printf("blk=&%s\n", mrb_sym2name(mrb, sym(n)));
5383 }
5384 }
5385 dump_prefix(offset+1);
5386 printf("body:\n");
5387 parser_dump(mrb, tree->cdr->car, offset+2);
5388 break;
5389
5390 case NODE_IF:
5391 printf("NODE_IF:\n");
5392 dump_prefix(offset+1);
5393 printf("cond:\n");
5394 parser_dump(mrb, tree->car, offset+2);
5395 dump_prefix(offset+1);
5396 printf("then:\n");
5397 parser_dump(mrb, tree->cdr->car, offset+2);
5398 if (tree->cdr->cdr->car) {
5399 dump_prefix(offset+1);
5400 printf("else:\n");
5401 parser_dump(mrb, tree->cdr->cdr->car, offset+2);
5402 }
5403 break;
5404
5405 case NODE_AND:
5406 printf("NODE_AND:\n");
5407 parser_dump(mrb, tree->car, offset+1);
5408 parser_dump(mrb, tree->cdr, offset+1);
5409 break;
5410
5411 case NODE_OR:
5412 printf("NODE_OR:\n");
5413 parser_dump(mrb, tree->car, offset+1);
5414 parser_dump(mrb, tree->cdr, offset+1);
5415 break;
5416
5417 case NODE_CASE:
5418 printf("NODE_CASE:\n");
5419 if (tree->car) {
5420 parser_dump(mrb, tree->car, offset+1);
5421 }
5422 tree = tree->cdr;
5423 while (tree) {
5424 dump_prefix(offset+1);
5425 printf("case:\n");
5426 dump_recur(mrb, tree->car->car, offset+2);
5427 dump_prefix(offset+1);
5428 printf("body:\n");
5429 parser_dump(mrb, tree->car->cdr, offset+2);
5430 tree = tree->cdr;
5431 }
5432 break;
5433
5434 case NODE_WHILE:
5435 printf("NODE_WHILE:\n");
5436 dump_prefix(offset+1);
5437 printf("cond:\n");
5438 parser_dump(mrb, tree->car, offset+2);
5439 dump_prefix(offset+1);
5440 printf("body:\n");
5441 parser_dump(mrb, tree->cdr, offset+2);
5442 break;
5443
5444 case NODE_UNTIL:
5445 printf("NODE_UNTIL:\n");
5446 dump_prefix(offset+1);
5447 printf("cond:\n");
5448 parser_dump(mrb, tree->car, offset+2);
5449 dump_prefix(offset+1);
5450 printf("body:\n");
5451 parser_dump(mrb, tree->cdr, offset+2);
5452 break;
5453
5454 case NODE_FOR:
5455 printf("NODE_FOR:\n");
5456 dump_prefix(offset+1);
5457 printf("var:\n");
5458 {
5459 node *n2 = tree->car;
5460
5461 if (n2->car) {
5462 dump_prefix(offset+2);
5463 printf("pre:\n");
5464 dump_recur(mrb, n2->car, offset+3);
5465 }
5466 n2 = n2->cdr;
5467 if (n2) {
5468 if (n2->car) {
5469 dump_prefix(offset+2);
5470 printf("rest:\n");
5471 parser_dump(mrb, n2->car, offset+3);
5472 }
5473 n2 = n2->cdr;
5474 if (n2) {
5475 if (n2->car) {
5476 dump_prefix(offset+2);
5477 printf("post:\n");
5478 dump_recur(mrb, n2->car, offset+3);
5479 }
5480 }
5481 }
5482 }
5483 tree = tree->cdr;
5484 dump_prefix(offset+1);
5485 printf("in:\n");
5486 parser_dump(mrb, tree->car, offset+2);
5487 tree = tree->cdr;
5488 dump_prefix(offset+1);
5489 printf("do:\n");
5490 parser_dump(mrb, tree->car, offset+2);
5491 break;
5492
5493 case NODE_SCOPE:
5494 printf("NODE_SCOPE:\n");
5495 {
5496 node *n2 = tree->car;
5497
5498 if (n2 && (n2->car || n2->cdr)) {
5499 dump_prefix(offset+1);
5500 printf("local variables:\n");
5501 dump_prefix(offset+2);
5502 while (n2) {
5503 if (n2->car) {
5504 if (n2 != tree->car) printf(", ");
5505 printf("%s", mrb_sym2name(mrb, sym(n2->car)));
5506 }
5507 n2 = n2->cdr;
5508 }
5509 printf("\n");
5510 }
5511 }
5512 tree = tree->cdr;
5513 offset++;
5514 goto again;
5515
5516 case NODE_FCALL:
5517 case NODE_CALL:
5518 printf("NODE_CALL:\n");
5519 parser_dump(mrb, tree->car, offset+1);
5520 dump_prefix(offset+1);
5521 printf("method='%s' (%d)\n",
5522 mrb_sym2name(mrb, sym(tree->cdr->car)),
5523 (int)(intptr_t)tree->cdr->car);
5524 tree = tree->cdr->cdr->car;
5525 if (tree) {
5526 dump_prefix(offset+1);
5527 printf("args:\n");
5528 dump_recur(mrb, tree->car, offset+2);
5529 if (tree->cdr) {
5530 dump_prefix(offset+1);
5531 printf("block:\n");
5532 parser_dump(mrb, tree->cdr, offset+2);
5533 }
5534 }
5535 break;
5536
5537 case NODE_DOT2:
5538 printf("NODE_DOT2:\n");
5539 parser_dump(mrb, tree->car, offset+1);
5540 parser_dump(mrb, tree->cdr, offset+1);
5541 break;
5542
5543 case NODE_DOT3:
5544 printf("NODE_DOT3:\n");
5545 parser_dump(mrb, tree->car, offset+1);
5546 parser_dump(mrb, tree->cdr, offset+1);
5547 break;
5548
5549 case NODE_COLON2:
5550 printf("NODE_COLON2:\n");
5551 parser_dump(mrb, tree->car, offset+1);
5552 dump_prefix(offset+1);
5553 printf("::%s\n", mrb_sym2name(mrb, sym(tree->cdr)));
5554 break;
5555
5556 case NODE_COLON3:
5557 printf("NODE_COLON3:\n");
5558 dump_prefix(offset+1);
5559 printf("::%s\n", mrb_sym2name(mrb, sym(tree)));
5560 break;
5561
5562 case NODE_ARRAY:
5563 printf("NODE_ARRAY:\n");
5564 dump_recur(mrb, tree, offset+1);
5565 break;
5566
5567 case NODE_HASH:
5568 printf("NODE_HASH:\n");
5569 while (tree) {
5570 dump_prefix(offset+1);
5571 printf("key:\n");
5572 parser_dump(mrb, tree->car->car, offset+2);
5573 dump_prefix(offset+1);
5574 printf("value:\n");
5575 parser_dump(mrb, tree->car->cdr, offset+2);
5576 tree = tree->cdr;
5577 }
5578 break;
5579
5580 case NODE_SPLAT:
5581 printf("NODE_SPLAT:\n");
5582 parser_dump(mrb, tree, offset+1);
5583 break;
5584
5585 case NODE_ASGN:
5586 printf("NODE_ASGN:\n");
5587 dump_prefix(offset+1);
5588 printf("lhs:\n");
5589 parser_dump(mrb, tree->car, offset+2);
5590 dump_prefix(offset+1);
5591 printf("rhs:\n");
5592 parser_dump(mrb, tree->cdr, offset+2);
5593 break;
5594
5595 case NODE_MASGN:
5596 printf("NODE_MASGN:\n");
5597 dump_prefix(offset+1);
5598 printf("mlhs:\n");
5599 {
5600 node *n2 = tree->car;
5601
5602 if (n2->car) {
5603 dump_prefix(offset+2);
5604 printf("pre:\n");
5605 dump_recur(mrb, n2->car, offset+3);
5606 }
5607 n2 = n2->cdr;
5608 if (n2) {
5609 if (n2->car) {
5610 dump_prefix(offset+2);
5611 printf("rest:\n");
5612 if (n2->car == (node*)-1) {
5613 dump_prefix(offset+2);
5614 printf("(empty)\n");
5615 }
5616 else {
5617 parser_dump(mrb, n2->car, offset+3);
5618 }
5619 }
5620 n2 = n2->cdr;
5621 if (n2) {
5622 if (n2->car) {
5623 dump_prefix(offset+2);
5624 printf("post:\n");
5625 dump_recur(mrb, n2->car, offset+3);
5626 }
5627 }
5628 }
5629 }
5630 dump_prefix(offset+1);
5631 printf("rhs:\n");
5632 parser_dump(mrb, tree->cdr, offset+2);
5633 break;
5634
5635 case NODE_OP_ASGN:
5636 printf("NODE_OP_ASGN:\n");
5637 dump_prefix(offset+1);
5638 printf("lhs:\n");
5639 parser_dump(mrb, tree->car, offset+2);
5640 tree = tree->cdr;
5641 dump_prefix(offset+1);
5642 printf("op='%s' (%d)\n", mrb_sym2name(mrb, sym(tree->car)), (int)(intptr_t)tree->car);
5643 tree = tree->cdr;
5644 parser_dump(mrb, tree->car, offset+1);
5645 break;
5646
5647 case NODE_SUPER:
5648 printf("NODE_SUPER:\n");
5649 if (tree) {
5650 dump_prefix(offset+1);
5651 printf("args:\n");
5652 dump_recur(mrb, tree->car, offset+2);
5653 if (tree->cdr) {
5654 dump_prefix(offset+1);
5655 printf("block:\n");
5656 parser_dump(mrb, tree->cdr, offset+2);
5657 }
5658 }
5659 break;
5660
5661 case NODE_ZSUPER:
5662 printf("NODE_ZSUPER\n");
5663 break;
5664
5665 case NODE_RETURN:
5666 printf("NODE_RETURN:\n");
5667 parser_dump(mrb, tree, offset+1);
5668 break;
5669
5670 case NODE_YIELD:
5671 printf("NODE_YIELD:\n");
5672 dump_recur(mrb, tree, offset+1);
5673 break;
5674
5675 case NODE_BREAK:
5676 printf("NODE_BREAK:\n");
5677 parser_dump(mrb, tree, offset+1);
5678 break;
5679
5680 case NODE_NEXT:
5681 printf("NODE_NEXT:\n");
5682 parser_dump(mrb, tree, offset+1);
5683 break;
5684
5685 case NODE_REDO:
5686 printf("NODE_REDO\n");
5687 break;
5688
5689 case NODE_RETRY:
5690 printf("NODE_RETRY\n");
5691 break;
5692
5693 case NODE_LVAR:
5694 printf("NODE_LVAR %s\n", mrb_sym2name(mrb, sym(tree)));
5695 break;
5696
5697 case NODE_GVAR:
5698 printf("NODE_GVAR %s\n", mrb_sym2name(mrb, sym(tree)));
5699 break;
5700
5701 case NODE_IVAR:
5702 printf("NODE_IVAR %s\n", mrb_sym2name(mrb, sym(tree)));
5703 break;
5704
5705 case NODE_CVAR:
5706 printf("NODE_CVAR %s\n", mrb_sym2name(mrb, sym(tree)));
5707 break;
5708
5709 case NODE_CONST:
5710 printf("NODE_CONST %s\n", mrb_sym2name(mrb, sym(tree)));
5711 break;
5712
5713 case NODE_MATCH:
5714 printf("NODE_MATCH:\n");
5715 dump_prefix(offset + 1);
5716 printf("lhs:\n");
5717 parser_dump(mrb, tree->car, offset + 2);
5718 dump_prefix(offset + 1);
5719 printf("rhs:\n");
5720 parser_dump(mrb, tree->cdr, offset + 2);
5721 break;
5722
5723 case NODE_BACK_REF:
5724 printf("NODE_BACK_REF: $%c\n", (int)(intptr_t)tree);
5725 break;
5726
5727 case NODE_NTH_REF:
5728 printf("NODE_NTH_REF: $%d\n", (int)(intptr_t)tree);
5729 break;
5730
5731 case NODE_ARG:
5732 printf("NODE_ARG %s\n", mrb_sym2name(mrb, sym(tree)));
5733 break;
5734
5735 case NODE_BLOCK_ARG:
5736 printf("NODE_BLOCK_ARG:\n");
5737 parser_dump(mrb, tree, offset+1);
5738 break;
5739
5740 case NODE_INT:
5741 printf("NODE_INT %s base %d\n", (char*)tree->car, (int)(intptr_t)tree->cdr->car);
5742 break;
5743
5744 case NODE_FLOAT:
5745 printf("NODE_FLOAT %s\n", (char*)tree);
5746 break;
5747
5748 case NODE_NEGATE:
5749 printf("NODE_NEGATE\n");
5750 parser_dump(mrb, tree, offset+1);
5751 break;
5752
5753 case NODE_STR:
5754 printf("NODE_STR \"%s\" len %d\n", (char*)tree->car, (int)(intptr_t)tree->cdr);
5755 break;
5756
5757 case NODE_DSTR:
5758 printf("NODE_DSTR\n");
5759 dump_recur(mrb, tree, offset+1);
5760 break;
5761
5762 case NODE_XSTR:
5763 printf("NODE_XSTR \"%s\" len %d\n", (char*)tree->car, (int)(intptr_t)tree->cdr);
5764 break;
5765
5766 case NODE_DXSTR:
5767 printf("NODE_DXSTR\n");
5768 dump_recur(mrb, tree, offset+1);
5769 break;
5770
5771 case NODE_REGX:
5772 printf("NODE_REGX /%s/%s\n", (char*)tree->car, (char*)tree->cdr);
5773 break;
5774
5775 case NODE_DREGX:
5776 printf("NODE_DREGX\n");
5777 dump_recur(mrb, tree->car, offset+1);
5778 dump_prefix(offset);
5779 printf("tail: %s\n", (char*)tree->cdr->cdr->car);
5780 dump_prefix(offset);
5781 printf("opt: %s\n", (char*)tree->cdr->cdr->cdr);
5782 break;
5783
5784 case NODE_SYM:
5785 printf("NODE_SYM :%s\n", mrb_sym2name(mrb, sym(tree)));
5786 break;
5787
5788 case NODE_SELF:
5789 printf("NODE_SELF\n");
5790 break;
5791
5792 case NODE_NIL:
5793 printf("NODE_NIL\n");
5794 break;
5795
5796 case NODE_TRUE:
5797 printf("NODE_TRUE\n");
5798 break;
5799
5800 case NODE_FALSE:
5801 printf("NODE_FALSE\n");
5802 break;
5803
5804 case NODE_ALIAS:
5805 printf("NODE_ALIAS %s %s:\n",
5806 mrb_sym2name(mrb, sym(tree->car)),
5807 mrb_sym2name(mrb, sym(tree->cdr)));
5808 break;
5809
5810 case NODE_UNDEF:
5811 printf("NODE_UNDEF");
5812 {
5813 node *t = tree;
5814 while (t) {
5815 printf(" %s", mrb_sym2name(mrb, sym(t->car)));
5816 t = t->cdr;
5817 }
5818 }
5819 printf(":\n");
5820 break;
5821
5822 case NODE_CLASS:
5823 printf("NODE_CLASS:\n");
5824 if (tree->car->car == (node*)0) {
5825 dump_prefix(offset+1);
5826 printf(":%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
5827 }
5828 else if (tree->car->car == (node*)1) {
5829 dump_prefix(offset+1);
5830 printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
5831 }
5832 else {
5833 parser_dump(mrb, tree->car->car, offset+1);
5834 dump_prefix(offset+1);
5835 printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
5836 }
5837 if (tree->cdr->car) {
5838 dump_prefix(offset+1);
5839 printf("super:\n");
5840 parser_dump(mrb, tree->cdr->car, offset+2);
5841 }
5842 dump_prefix(offset+1);
5843 printf("body:\n");
5844 parser_dump(mrb, tree->cdr->cdr->car->cdr, offset+2);
5845 break;
5846
5847 case NODE_MODULE:
5848 printf("NODE_MODULE:\n");
5849 if (tree->car->car == (node*)0) {
5850 dump_prefix(offset+1);
5851 printf(":%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
5852 }
5853 else if (tree->car->car == (node*)1) {
5854 dump_prefix(offset+1);
5855 printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
5856 }
5857 else {
5858 parser_dump(mrb, tree->car->car, offset+1);
5859 dump_prefix(offset+1);
5860 printf("::%s\n", mrb_sym2name(mrb, sym(tree->car->cdr)));
5861 }
5862 dump_prefix(offset+1);
5863 printf("body:\n");
5864 parser_dump(mrb, tree->cdr->car->cdr, offset+2);
5865 break;
5866
5867 case NODE_SCLASS:
5868 printf("NODE_SCLASS:\n");
5869 parser_dump(mrb, tree->car, offset+1);
5870 dump_prefix(offset+1);
5871 printf("body:\n");
5872 parser_dump(mrb, tree->cdr->car->cdr, offset+2);
5873 break;
5874
5875 case NODE_DEF:
5876 printf("NODE_DEF:\n");
5877 dump_prefix(offset+1);
5878 printf("%s\n", mrb_sym2name(mrb, sym(tree->car)));
5879 tree = tree->cdr;
5880 {
5881 node *n2 = tree->car;
5882
5883 if (n2 && (n2->car || n2->cdr)) {
5884 dump_prefix(offset+1);
5885 printf("local variables:\n");
5886 dump_prefix(offset+2);
5887 while (n2) {
5888 if (n2->car) {
5889 if (n2 != tree->car) printf(", ");
5890 printf("%s", mrb_sym2name(mrb, sym(n2->car)));
5891 }
5892 n2 = n2->cdr;
5893 }
5894 printf("\n");
5895 }
5896 }
5897 tree = tree->cdr;
5898 if (tree->car) {
5899 node *n = tree->car;
5900
5901 if (n->car) {
5902 dump_prefix(offset+1);
5903 printf("mandatory args:\n");
5904 dump_recur(mrb, n->car, offset+2);
5905 }
5906 n = n->cdr;
5907 if (n->car) {
5908 dump_prefix(offset+1);
5909 printf("optional args:\n");
5910 {
5911 node *n2 = n->car;
5912
5913 while (n2) {
5914 dump_prefix(offset+2);
5915 printf("%s=", mrb_sym2name(mrb, sym(n2->car->car)));
5916 parser_dump(mrb, n2->car->cdr, 0);
5917 n2 = n2->cdr;
5918 }
5919 }
5920 }
5921 n = n->cdr;
5922 if (n->car) {
5923 dump_prefix(offset+1);
5924 printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car)));
5925 }
5926 n = n->cdr;
5927 if (n->car) {
5928 dump_prefix(offset+1);
5929 printf("post mandatory args:\n");
5930 dump_recur(mrb, n->car, offset+2);
5931 }
5932 n = n->cdr;
5933 if (n) {
5934 dump_prefix(offset+1);
5935 printf("blk=&%s\n", mrb_sym2name(mrb, sym(n)));
5936 }
5937 }
5938 parser_dump(mrb, tree->cdr->car, offset+1);
5939 break;
5940
5941 case NODE_SDEF:
5942 printf("NODE_SDEF:\n");
5943 parser_dump(mrb, tree->car, offset+1);
5944 tree = tree->cdr;
5945 dump_prefix(offset+1);
5946 printf(":%s\n", mrb_sym2name(mrb, sym(tree->car)));
5947 tree = tree->cdr->cdr;
5948 if (tree->car) {
5949 node *n = tree->car;
5950
5951 if (n->car) {
5952 dump_prefix(offset+1);
5953 printf("mandatory args:\n");
5954 dump_recur(mrb, n->car, offset+2);
5955 }
5956 n = n->cdr;
5957 if (n->car) {
5958 dump_prefix(offset+1);
5959 printf("optional args:\n");
5960 {
5961 node *n2 = n->car;
5962
5963 while (n2) {
5964 dump_prefix(offset+2);
5965 printf("%s=", mrb_sym2name(mrb, sym(n2->car->car)));
5966 parser_dump(mrb, n2->car->cdr, 0);
5967 n2 = n2->cdr;
5968 }
5969 }
5970 }
5971 n = n->cdr;
5972 if (n->car) {
5973 dump_prefix(offset+1);
5974 printf("rest=*%s\n", mrb_sym2name(mrb, sym(n->car)));
5975 }
5976 n = n->cdr;
5977 if (n->car) {
5978 dump_prefix(offset+1);
5979 printf("post mandatory args:\n");
5980 dump_recur(mrb, n->car, offset+2);
5981 }
5982 n = n->cdr;
5983 if (n) {
5984 dump_prefix(offset+1);
5985 printf("blk=&%s\n", mrb_sym2name(mrb, sym(n)));
5986 }
5987 }
5988 tree = tree->cdr;
5989 parser_dump(mrb, tree->car, offset+1);
5990 break;
5991
5992 case NODE_POSTEXE:
5993 printf("NODE_POSTEXE:\n");
5994 parser_dump(mrb, tree, offset+1);
5995 break;
5996
5997 case NODE_HEREDOC:
5998 printf("NODE_HEREDOC:\n");
5999 parser_dump(mrb, ((parser_heredoc_info*)tree)->doc, offset+1);
6000 break;
6001
6002 default:
6003 printf("node type: %d (0x%x)\n", (int)n, (int)n);
6004 break;
6005 }
6006 #endif
6007 }
lightweight implementation of the Ruby language