1 /**********************************************************************
6 created at: Fri May 28 18:02:42 JST 1993
8 Copyright (C) 1993-2007 Yukihiro Matsumoto
10 **********************************************************************/
15 #define YYERROR_VERBOSE 1
16 #define YYSTACK_USE_ALLOCA 0
18 #include "ruby/ruby.h"
20 #include "ruby/encoding.h"
30 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
32 #define YYMALLOC(size) rb_parser_malloc(parser, (size))
33 #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
34 #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
35 #define YYFREE(ptr) rb_parser_free(parser, (ptr))
36 #define malloc YYMALLOC
37 #define realloc YYREALLOC
38 #define calloc YYCALLOC
42 static ID register_symid(ID, const char *, long, rb_encoding *);
43 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
47 #define is_notop_id(id) ((id)>tLAST_TOKEN)
48 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
49 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
50 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
51 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
52 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
53 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
54 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
56 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
57 (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
58 ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
59 ((id)&ID_SCOPE_MASK) == ID_CLASS))
62 EXPR_BEG, /* ignore newline, +/- is a sign. */
63 EXPR_END, /* newline significant, +/- is an operator. */
64 EXPR_ENDARG, /* ditto, and unbound braces. */
65 EXPR_ENDFN, /* ditto, and unbound braces. */
66 EXPR_ARG, /* newline significant, +/- is an operator. */
67 EXPR_CMDARG, /* newline significant, +/- is an operator. */
68 EXPR_MID, /* newline significant, +/- is an operator. */
69 EXPR_FNAME, /* ignore newline, no reserved words. */
70 EXPR_DOT, /* right after `.' or `::', no reserved words. */
71 EXPR_CLASS, /* immediate after `class', no here document. */
72 EXPR_VALUE, /* alike EXPR_BEG but label is disallowed. */
76 typedef VALUE stack_type;
78 # define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
79 # define BITSTACK_POP(stack) ((stack) = (stack) >> 1)
80 # define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
81 # define BITSTACK_SET_P(stack) ((stack)&1)
83 #define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n))
84 #define COND_POP() BITSTACK_POP(cond_stack)
85 #define COND_LEXPOP() BITSTACK_LEXPOP(cond_stack)
86 #define COND_P() BITSTACK_SET_P(cond_stack)
88 #define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n))
89 #define CMDARG_POP() BITSTACK_POP(cmdarg_stack)
90 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
91 #define CMDARG_P() BITSTACK_SET_P(cmdarg_stack)
104 struct local_vars *prev;
108 #define DVARS_INHERIT ((void*)1)
109 #define DVARS_TOPSCOPE NULL
110 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
111 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
114 vtable_size(const struct vtable *tbl)
116 if (POINTER_P(tbl)) {
126 static struct vtable *
127 vtable_alloc(struct vtable *prev)
129 struct vtable *tbl = ALLOC(struct vtable);
132 tbl->tbl = ALLOC_N(ID, tbl->capa);
134 if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
139 vtable_free(struct vtable *tbl)
141 if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
142 if (POINTER_P(tbl)) {
151 vtable_add(struct vtable *tbl, ID id)
153 if (!POINTER_P(tbl)) {
154 rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
156 if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
158 if (tbl->pos == tbl->capa) {
159 tbl->capa = tbl->capa * 2;
160 REALLOC_N(tbl->tbl, ID, tbl->capa);
162 tbl->tbl[tbl->pos++] = id;
166 vtable_included(const struct vtable * tbl, ID id)
170 if (POINTER_P(tbl)) {
171 for (i = 0; i < tbl->pos; i++) {
172 if (tbl->tbl[i] == id) {
182 typedef struct token_info {
187 struct token_info *next;
192 Structure of Lexer Buffer:
194 lex_pbeg tokp lex_p lex_pend
196 |-----------+--------------+------------|
200 struct parser_params {
204 YYSTYPE *parser_yylval;
207 NODE *parser_lex_strterm;
208 enum lex_state_e parser_lex_state;
209 stack_type parser_cond_stack;
210 stack_type parser_cmdarg_stack;
211 int parser_class_nest;
212 int parser_paren_nest;
214 int parser_in_single;
216 int parser_compile_for_eval;
217 VALUE parser_cur_mid;
218 int parser_in_defined;
219 char *parser_tokenbuf;
222 VALUE parser_lex_input;
223 VALUE parser_lex_lastline;
224 VALUE parser_lex_nextline;
225 const char *parser_lex_pbeg;
226 const char *parser_lex_p;
227 const char *parser_lex_pend;
228 int parser_heredoc_end;
229 int parser_command_start;
230 NODE *parser_deferred_nodes;
231 long parser_lex_gets_ptr;
232 VALUE (*parser_lex_gets)(struct parser_params*,VALUE);
233 struct local_vars *parser_lvtbl;
234 int parser_ruby__end__seen;
237 char *parser_ruby_sourcefile; /* current source file */
238 int parser_ruby_sourceline; /* current line no. */
246 NODE *parser_eval_tree_begin;
247 NODE *parser_eval_tree;
252 int parser_token_info_enabled;
253 token_info *parser_token_info;
256 VALUE parser_ruby_sourcefile_string;
264 VALUE parsing_thread;
269 #define UTF8_ENC() (parser->utf8 ? parser->utf8 : \
270 (parser->utf8 = rb_utf8_encoding()))
271 #define STR_NEW(p,n) rb_enc_str_new((p),(n),parser->enc)
272 #define STR_NEW0() rb_enc_str_new(0,0,parser->enc)
273 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),parser->enc)
274 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),parser->enc)
275 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
276 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), parser->enc)
278 static int parser_yyerror(struct parser_params*, const char*);
279 #define yyerror(msg) parser_yyerror(parser, (msg))
281 #define lex_strterm (parser->parser_lex_strterm)
282 #define lex_state (parser->parser_lex_state)
283 #define cond_stack (parser->parser_cond_stack)
284 #define cmdarg_stack (parser->parser_cmdarg_stack)
285 #define class_nest (parser->parser_class_nest)
286 #define paren_nest (parser->parser_paren_nest)
287 #define lpar_beg (parser->parser_lpar_beg)
288 #define in_single (parser->parser_in_single)
289 #define in_def (parser->parser_in_def)
290 #define compile_for_eval (parser->parser_compile_for_eval)
291 #define cur_mid (parser->parser_cur_mid)
292 #define in_defined (parser->parser_in_defined)
293 #define tokenbuf (parser->parser_tokenbuf)
294 #define tokidx (parser->parser_tokidx)
295 #define toksiz (parser->parser_toksiz)
296 #define lex_input (parser->parser_lex_input)
297 #define lex_lastline (parser->parser_lex_lastline)
298 #define lex_nextline (parser->parser_lex_nextline)
299 #define lex_pbeg (parser->parser_lex_pbeg)
300 #define lex_p (parser->parser_lex_p)
301 #define lex_pend (parser->parser_lex_pend)
302 #define heredoc_end (parser->parser_heredoc_end)
303 #define command_start (parser->parser_command_start)
304 #define deferred_nodes (parser->parser_deferred_nodes)
305 #define lex_gets_ptr (parser->parser_lex_gets_ptr)
306 #define lex_gets (parser->parser_lex_gets)
307 #define lvtbl (parser->parser_lvtbl)
308 #define ruby__end__seen (parser->parser_ruby__end__seen)
309 #define ruby_sourceline (parser->parser_ruby_sourceline)
310 #define ruby_sourcefile (parser->parser_ruby_sourcefile)
311 #define current_enc (parser->enc)
312 #define yydebug (parser->parser_yydebug)
315 #define ruby_eval_tree (parser->parser_eval_tree)
316 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin)
317 #define ruby_debug_lines (parser->debug_lines)
318 #define ruby_coverage (parser->coverage)
322 static int yylex(void*, void*);
324 static int yylex(void*);
328 #define yyparse ruby_yyparse
330 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
331 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
333 static NODE *cond_gen(struct parser_params*,NODE*);
334 #define cond(node) cond_gen(parser, (node))
335 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
336 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
338 static NODE *newline_node(NODE*);
339 static void fixpos(NODE*,NODE*);
341 static int value_expr_gen(struct parser_params*,NODE*);
342 static void void_expr_gen(struct parser_params*,NODE*);
343 static NODE *remove_begin(NODE*);
344 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
345 #define void_expr0(node) void_expr_gen(parser, (node))
346 #define void_expr(node) void_expr0((node) = remove_begin(node))
347 static void void_stmts_gen(struct parser_params*,NODE*);
348 #define void_stmts(node) void_stmts_gen(parser, (node))
349 static void reduce_nodes_gen(struct parser_params*,NODE**);
350 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
351 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
352 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
354 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
355 #define block_append(h,t) block_append_gen(parser,(h),(t))
356 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
357 #define list_append(l,i) list_append_gen(parser,(l),(i))
358 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
359 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
360 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
361 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
362 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
363 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
364 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
365 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
366 static int literal_concat0(struct parser_params *, VALUE, VALUE);
367 static NODE *new_evstr_gen(struct parser_params*,NODE*);
368 #define new_evstr(n) new_evstr_gen(parser,(n))
369 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
370 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
371 static NODE *splat_array(NODE*);
373 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
374 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
375 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
376 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
378 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,ID);
379 #define new_args(f,o,r,p,b) new_args_gen(parser, (f),(o),(r),(p),(b))
381 static NODE *negate_lit(NODE*);
382 static NODE *ret_args_gen(struct parser_params*,NODE*);
383 #define ret_args(node) ret_args_gen(parser, (node))
384 static NODE *arg_blk_pass(NODE*,NODE*);
385 static NODE *new_yield_gen(struct parser_params*,NODE*);
386 #define new_yield(node) new_yield_gen(parser, (node))
388 static NODE *gettable_gen(struct parser_params*,ID);
389 #define gettable(id) gettable_gen(parser,(id))
390 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
391 #define assignable(id,node) assignable_gen(parser, (id), (node))
393 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
394 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
395 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
396 #define attrset(node,id) attrset_gen(parser, (node), (id))
398 static void rb_backref_error_gen(struct parser_params*,NODE*);
399 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
400 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
401 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
403 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
404 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
406 static ID *local_tbl_gen(struct parser_params*);
407 #define local_tbl() local_tbl_gen(parser)
409 static void fixup_nodes(NODE **);
411 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
412 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
413 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
414 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
415 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
416 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
417 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
418 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
420 #define get_id(id) (id)
421 #define get_value(val) (val)
423 #define remove_begin(node) (node)
424 #define rb_dvar_defined(id) 0
425 #define rb_local_defined(id) 0
426 static ID ripper_get_id(VALUE);
427 #define get_id(id) ripper_get_id(id)
428 static VALUE ripper_get_value(VALUE);
429 #define get_value(val) ripper_get_value(val)
430 static VALUE assignable_gen(struct parser_params*,VALUE);
431 #define assignable(lhs,node) assignable_gen(parser, (lhs))
432 static int id_is_var_gen(struct parser_params *parser, ID id);
433 #define id_is_var(id) id_is_var_gen(parser, (id))
436 static ID formal_argument_gen(struct parser_params*, ID);
437 #define formal_argument(id) formal_argument_gen(parser, (id))
438 static ID shadowing_lvar_gen(struct parser_params*,ID);
439 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
440 static void new_bv_gen(struct parser_params*,ID);
441 #define new_bv(id) new_bv_gen(parser, (id))
443 static void local_push_gen(struct parser_params*,int);
444 #define local_push(top) local_push_gen(parser,(top))
445 static void local_pop_gen(struct parser_params*);
446 #define local_pop() local_pop_gen(parser)
447 static int local_var_gen(struct parser_params*, ID);
448 #define local_var(id) local_var_gen(parser, (id));
449 static int arg_var_gen(struct parser_params*, ID);
450 #define arg_var(id) arg_var_gen(parser, (id))
451 static int local_id_gen(struct parser_params*, ID);
452 #define local_id(id) local_id_gen(parser, (id))
453 static ID internal_id_gen(struct parser_params*);
454 #define internal_id() internal_id_gen(parser)
456 static const struct vtable *dyna_push_gen(struct parser_params *);
457 #define dyna_push() dyna_push_gen(parser)
458 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
459 #define dyna_pop(node) dyna_pop_gen(parser, (node))
460 static int dyna_in_block_gen(struct parser_params*);
461 #define dyna_in_block() dyna_in_block_gen(parser)
462 #define dyna_var(id) local_var(id)
463 static int dvar_defined_gen(struct parser_params*,ID,int);
464 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
465 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
466 static int dvar_curr_gen(struct parser_params*,ID);
467 #define dvar_curr(id) dvar_curr_gen(parser, (id))
469 static int lvar_defined_gen(struct parser_params*, ID);
470 #define lvar_defined(id) lvar_defined_gen(parser, (id))
472 #define RE_OPTION_ONCE (1<<16)
473 #define RE_OPTION_ENCODING_SHIFT 8
474 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
475 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
476 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
477 #define RE_OPTION_MASK 0xff
478 #define RE_OPTION_ARG_ENCODING_NONE 32
480 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
481 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
482 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
483 #define nd_func u1.id
484 #if SIZEOF_SHORT == 2
485 #define nd_term(node) ((signed short)(node)->u2.id)
487 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
489 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
490 #define nd_nest u3.cnt
492 /****** Ripper *******/
495 #define RIPPER_VERSION "0.1.0"
497 #include "eventids1.c"
498 #include "eventids2.c"
499 static ID ripper_id_gets;
501 static VALUE ripper_dispatch0(struct parser_params*,ID);
502 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
503 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
504 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
505 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
506 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
508 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
509 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
510 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
511 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
512 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
513 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
515 #define yyparse ripper_yyparse
517 #define ripper_intern(s) ID2SYM(rb_intern(s))
518 static VALUE ripper_id2sym(ID);
520 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
521 ID2SYM(id) : ripper_id2sym(id))
524 #define arg_new() dispatch0(args_new)
525 #define arg_add(l,a) dispatch2(args_add, (l), (a))
526 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
527 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
528 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
529 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
530 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
532 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
533 #define mrhs_new() dispatch0(mrhs_new)
534 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
535 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
537 #define mlhs_new() dispatch0(mlhs_new)
538 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
539 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
541 #define params_new(pars, opts, rest, pars2, blk) \
542 dispatch5(params, (pars), (opts), (rest), (pars2), (blk))
544 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
545 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
546 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
548 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
549 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
550 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
552 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
559 # define ifndef_ripper(x) (x)
561 # define ifndef_ripper(x)
565 # define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
566 # define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
567 # define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
568 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
569 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
571 # define rb_warn0(fmt) ripper_warn0(parser, (fmt))
572 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))
573 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))
574 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
575 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
576 static void ripper_warn0(struct parser_params*, const char*);
577 static void ripper_warnI(struct parser_params*, const char*, int);
579 static void ripper_warnS(struct parser_params*, const char*, const char*);
581 static void ripper_warning0(struct parser_params*, const char*);
582 static void ripper_warningS(struct parser_params*, const char*, const char*);
586 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
587 # define rb_compile_error ripper_compile_error
588 # define compile_error ripper_compile_error
589 # define PARSER_ARG parser,
591 # define rb_compile_error rb_compile_error_with_enc
592 # define compile_error parser->nerr++,rb_compile_error_with_enc
593 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
596 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
597 for instance). This is too low for Ruby to parse some files, such as
598 date/format.rb, therefore bump the value up to at least Bison's default. */
601 #define YYMAXDEPTH 10000
606 static void token_info_push(struct parser_params*, const char *token);
607 static void token_info_pop(struct parser_params*, const char *token);
608 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
609 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
611 #define token_info_push(token) /* nothing */
612 #define token_info_pop(token) /* nothing */
617 %lex-param {struct parser_params *parser}
618 %parse-param {struct parser_params *parser}
625 const struct vtable *vars;
683 %token <val> tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tCVAR tLABEL
684 %token <val> tINTEGER tFLOAT tSTRING_CONTENT tCHAR
685 %token <val> tNTH_REF tBACK_REF
686 %token <val> tREGEXP_END
688 %type <val> singleton strings string string1 xstring regexp
689 %type <val> string_contents xstring_contents regexp_contents string_content
690 %type <val> words qwords word_list qword_list word
691 %type <val> literal numeric dsym cpath
692 %type <val> top_compstmt top_stmts top_stmt
693 %type <val> bodystmt compstmt stmts stmt expr arg primary command command_call method_call
694 %type <val> expr_value arg_value primary_value
695 %type <val> if_tail opt_else case_body cases opt_rescue exc_list exc_var opt_ensure
696 %type <val> args call_args opt_call_args
697 %type <val> paren_args opt_paren_args
698 %type <val> command_args aref_args opt_block_arg block_arg var_ref var_lhs
699 %type <val> command_asgn mrhs superclass block_call block_command
700 %type <val> f_block_optarg f_block_opt
701 %type <val> f_arglist f_args f_arg f_arg_item f_optarg f_marg f_marg_list f_margs
702 %type <val> assoc_list assocs assoc undef_list backref string_dvar for_var
703 %type <val> block_param opt_block_param block_param_def f_opt
704 %type <val> bv_decls opt_bv_decl bvar
705 %type <val> lambda f_larglist lambda_body
706 %type <val> brace_block cmd_brace_block do_block lhs none fitem
707 %type <val> mlhs mlhs_head mlhs_basic mlhs_item mlhs_node mlhs_post mlhs_inner
708 %type <val> fsym keyword_variable user_variable sym symbol operation operation2 operation3
709 %type <val> cname fname op f_rest_arg f_block_arg opt_f_block_arg f_norm_arg f_bad_arg
712 %type <val> program reswords then do dot_or_colon
714 %token tUPLUS /* unary+ */
715 %token tUMINUS /* unary- */
717 %token tCMP /* <=> */
719 %token tEQQ /* === */
723 %token tANDOP tOROP /* && and || */
724 %token tMATCH tNMATCH /* =~ and !~ */
725 %token tDOT2 tDOT3 /* .. and ... */
726 %token tAREF tASET /* [] and []= */
727 %token tLSHFT tRSHFT /* << and >> */
728 %token tCOLON2 /* :: */
729 %token tCOLON3 /* :: at EXPR_BEG */
730 %token <val> tOP_ASGN /* +=, -= etc. */
731 %token tASSOC /* => */
732 %token tLPAREN /* ( */
733 %token tLPAREN_ARG /* ( */
734 %token tRPAREN /* ) */
735 %token tLBRACK /* [ */
736 %token tLBRACE /* { */
737 %token tLBRACE_ARG /* { */
739 %token tAMPER /* & */
740 %token tLAMBDA /* -> */
741 %token tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG tWORDS_BEG tQWORDS_BEG
742 %token tSTRING_DBEG tSTRING_DVAR tSTRING_END tLAMBEG
749 %nonassoc tLBRACE_ARG
751 %nonassoc modifier_if modifier_unless modifier_while modifier_until
752 %left keyword_or keyword_and
754 %nonassoc keyword_defined
756 %left modifier_rescue
758 %nonassoc tDOT2 tDOT3
761 %nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
762 %left '>' tGEQ '<' tLEQ
768 %right tUMINUS_NUM tUMINUS
770 %right '!' '~' tUPLUS
773 %nonassoc idRespond_to
776 %nonassoc id_core_set_method_alias
777 %nonassoc id_core_set_variable_alias
778 %nonassoc id_core_undef_method
779 %nonassoc id_core_define_method
780 %nonassoc id_core_define_singleton_method
781 %nonassoc id_core_set_postexe
787 lex_state = EXPR_BEG;
789 local_push(compile_for_eval || rb_parse_in_main());
797 if ($2 && !compile_for_eval) {
798 /* last expression should not be void */
799 if (nd_type($2) != NODE_BLOCK) void_expr($2);
802 while (node->nd_next) {
803 node = node->nd_next;
805 void_expr(node->nd_head);
808 ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, $2));
811 parser->result = dispatch1(program, $$);
817 top_compstmt : top_stmts opt_terms
821 fixup_nodes(&deferred_nodes);
833 $$ = dispatch2(stmts_add, dispatch0(stmts_new),
834 dispatch0(void_stmt));
840 $$ = newline_node($1);
842 $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
845 | top_stmts terms top_stmt
848 $$ = block_append($1, newline_node($3));
850 $$ = dispatch2(stmts_add, $1, $3);
855 $$ = remove_begin($2);
862 if (in_def || in_single) {
863 yyerror("BEGIN in method");
873 ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
875 /* NEW_PREEXE($4)); */
879 $$ = dispatch1(BEGIN, $4);
892 $$ = NEW_RESCUE($1, $2, $3);
895 rb_warn0("else without rescue is useless");
896 $$ = block_append($$, $3);
900 $$ = NEW_ENSURE($$, $4);
903 $$ = block_append($4, NEW_NIL());
908 $$ = dispatch4(bodystmt,
917 compstmt : stmts opt_terms
921 fixup_nodes(&deferred_nodes);
933 $$ = dispatch2(stmts_add, dispatch0(stmts_new),
934 dispatch0(void_stmt));
940 $$ = newline_node($1);
942 $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
948 $$ = block_append($1, newline_node($3));
950 $$ = dispatch2(stmts_add, $1, $3);
955 $$ = remove_begin($2);
959 stmt : keyword_alias fitem {lex_state = EXPR_FNAME;} fitem
962 $$ = NEW_ALIAS($2, $4);
964 $$ = dispatch2(alias, $2, $4);
967 | keyword_alias tGVAR tGVAR
970 $$ = NEW_VALIAS($2, $3);
972 $$ = dispatch2(var_alias, $2, $3);
975 | keyword_alias tGVAR tBACK_REF
980 buf[1] = (char)$3->nd_nth;
981 $$ = NEW_VALIAS($2, rb_intern2(buf, 2));
983 $$ = dispatch2(var_alias, $2, $3);
986 | keyword_alias tGVAR tNTH_REF
989 yyerror("can't make alias for the number variables");
992 $$ = dispatch2(var_alias, $2, $3);
993 $$ = dispatch1(alias_error, $$);
996 | keyword_undef undef_list
1001 $$ = dispatch1(undef, $2);
1004 | stmt modifier_if expr_value
1007 $$ = NEW_IF(cond($3), remove_begin($1), 0);
1010 $$ = dispatch2(if_mod, $3, $1);
1013 | stmt modifier_unless expr_value
1016 $$ = NEW_UNLESS(cond($3), remove_begin($1), 0);
1019 $$ = dispatch2(unless_mod, $3, $1);
1022 | stmt modifier_while expr_value
1025 if ($1 && nd_type($1) == NODE_BEGIN) {
1026 $$ = NEW_WHILE(cond($3), $1->nd_body, 0);
1029 $$ = NEW_WHILE(cond($3), $1, 1);
1032 $$ = dispatch2(while_mod, $3, $1);
1035 | stmt modifier_until expr_value
1038 if ($1 && nd_type($1) == NODE_BEGIN) {
1039 $$ = NEW_UNTIL(cond($3), $1->nd_body, 0);
1042 $$ = NEW_UNTIL(cond($3), $1, 1);
1045 $$ = dispatch2(until_mod, $3, $1);
1048 | stmt modifier_rescue stmt
1051 NODE *resq = NEW_RESBODY(0, remove_begin($3), 0);
1052 $$ = NEW_RESCUE(remove_begin($1), resq, 0);
1054 $$ = dispatch2(rescue_mod, $1, $3);
1057 | keyword_END '{' compstmt '}'
1059 if (in_def || in_single) {
1060 rb_warn0("END in method; use at_exit");
1063 $$ = NEW_POSTEXE(NEW_NODE(
1064 NODE_SCOPE, 0 /* tbl */, $3 /* body */, 0 /* args */));
1066 $$ = dispatch1(END, $3);
1070 | mlhs '=' command_call
1077 $$ = dispatch2(massign, $1, $3);
1080 | var_lhs tOP_ASGN command_call
1085 ID vid = $1->nd_vid;
1088 $$ = NEW_OP_ASGN_OR(gettable(vid), $1);
1089 if (is_asgn_or_id(vid)) {
1093 else if ($2 == tANDOP) {
1095 $$ = NEW_OP_ASGN_AND(gettable(vid), $1);
1099 $$->nd_value = NEW_CALL(gettable(vid), $2, NEW_LIST($3));
1106 $$ = dispatch3(opassign, $1, $2, $3);
1109 | primary_value '[' opt_call_args rbracket tOP_ASGN command_call
1115 if (!$3) $3 = NEW_ZARRAY();
1116 args = arg_concat($3, $6);
1120 else if ($5 == tANDOP) {
1123 $$ = NEW_OP_ASGN1($1, $5, args);
1126 $$ = dispatch2(aref_field, $1, escape_Qundef($3));
1127 $$ = dispatch3(opassign, $$, $5, $6);
1130 | primary_value '.' tIDENTIFIER tOP_ASGN command_call
1137 else if ($4 == tANDOP) {
1140 $$ = NEW_OP_ASGN2($1, $3, $4, $5);
1143 $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
1144 $$ = dispatch3(opassign, $$, $4, $5);
1147 | primary_value '.' tCONSTANT tOP_ASGN command_call
1154 else if ($4 == tANDOP) {
1157 $$ = NEW_OP_ASGN2($1, $3, $4, $5);
1160 $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
1161 $$ = dispatch3(opassign, $$, $4, $5);
1164 | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
1167 yyerror("constant re-assignment");
1170 $$ = dispatch2(const_path_field, $1, $3);
1171 $$ = dispatch3(opassign, $$, $4, $5);
1172 $$ = dispatch1(assign_error, $$);
1175 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
1182 else if ($4 == tANDOP) {
1185 $$ = NEW_OP_ASGN2($1, $3, $4, $5);
1188 $$ = dispatch3(field, $1, ripper_intern("::"), $3);
1189 $$ = dispatch3(opassign, $$, $4, $5);
1192 | backref tOP_ASGN command_call
1195 rb_backref_error($1);
1198 $$ = dispatch2(assign, dispatch1(var_field, $1), $3);
1199 $$ = dispatch1(assign_error, $$);
1206 $$ = node_assign($1, $3);
1208 $$ = dispatch2(assign, $1, $3);
1211 | mlhs '=' arg_value
1217 $$ = dispatch2(massign, $1, $3);
1226 $$ = dispatch2(massign, $1, $3);
1232 command_asgn : lhs '=' command_call
1236 $$ = node_assign($1, $3);
1238 $$ = dispatch2(assign, $1, $3);
1241 | lhs '=' command_asgn
1245 $$ = node_assign($1, $3);
1247 $$ = dispatch2(assign, $1, $3);
1254 | expr keyword_and expr
1257 $$ = logop(NODE_AND, $1, $3);
1259 $$ = dispatch3(binary, $1, ripper_intern("and"), $3);
1262 | expr keyword_or expr
1265 $$ = logop(NODE_OR, $1, $3);
1267 $$ = dispatch3(binary, $1, ripper_intern("or"), $3);
1270 | keyword_not opt_nl expr
1273 $$ = call_uni_op(cond($3), '!');
1275 $$ = dispatch2(unary, ripper_intern("not"), $3);
1281 $$ = call_uni_op(cond($2), '!');
1283 $$ = dispatch2(unary, ripper_id2sym('!'), $2);
1294 if (!$$) $$ = NEW_NIL();
1301 command_call : command
1305 block_command : block_call
1306 | block_call '.' operation2 command_args
1309 $$ = NEW_CALL($1, $3, $4);
1311 $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
1312 $$ = method_arg($$, $4);
1315 | block_call tCOLON2 operation2 command_args
1318 $$ = NEW_CALL($1, $3, $4);
1320 $$ = dispatch3(call, $1, ripper_intern("::"), $3);
1321 $$ = method_arg($$, $4);
1326 cmd_brace_block : tLBRACE_ARG
1328 $<vars>1 = dyna_push();
1330 $<num>$ = ruby_sourceline;
1339 $$ = NEW_ITER($3,$4);
1340 nd_set_line($$, $<num>2);
1342 $$ = dispatch2(brace_block, escape_Qundef($3), $4);
1348 command : operation command_args %prec tLOWEST
1351 $$ = NEW_FCALL($1, $2);
1354 $$ = dispatch2(command, $1, $2);
1357 | operation command_args cmd_brace_block
1360 block_dup_check($2,$3);
1361 $3->nd_iter = NEW_FCALL($1, $2);
1365 $$ = dispatch2(command, $1, $2);
1366 $$ = method_add_block($$, $3);
1369 | primary_value '.' operation2 command_args %prec tLOWEST
1372 $$ = NEW_CALL($1, $3, $4);
1375 $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
1378 | primary_value '.' operation2 command_args cmd_brace_block
1381 block_dup_check($4,$5);
1382 $5->nd_iter = NEW_CALL($1, $3, $4);
1386 $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
1387 $$ = method_add_block($$, $5);
1390 | primary_value tCOLON2 operation2 command_args %prec tLOWEST
1393 $$ = NEW_CALL($1, $3, $4);
1396 $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
1399 | primary_value tCOLON2 operation2 command_args cmd_brace_block
1402 block_dup_check($4,$5);
1403 $5->nd_iter = NEW_CALL($1, $3, $4);
1407 $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
1408 $$ = method_add_block($$, $5);
1411 | keyword_super command_args
1417 $$ = dispatch1(super, $2);
1420 | keyword_yield command_args
1426 $$ = dispatch1(yield, $2);
1429 | keyword_return call_args
1432 $$ = NEW_RETURN(ret_args($2));
1434 $$ = dispatch1(return, $2);
1437 | keyword_break call_args
1440 $$ = NEW_BREAK(ret_args($2));
1442 $$ = dispatch1(break, $2);
1445 | keyword_next call_args
1448 $$ = NEW_NEXT(ret_args($2));
1450 $$ = dispatch1(next, $2);
1456 | tLPAREN mlhs_inner rparen
1461 $$ = dispatch1(mlhs_paren, $2);
1466 mlhs_inner : mlhs_basic
1467 | tLPAREN mlhs_inner rparen
1470 $$ = NEW_MASGN(NEW_LIST($2), 0);
1472 $$ = dispatch1(mlhs_paren, $2);
1477 mlhs_basic : mlhs_head
1480 $$ = NEW_MASGN($1, 0);
1485 | mlhs_head mlhs_item
1488 $$ = NEW_MASGN(list_append($1,$2), 0);
1490 $$ = mlhs_add($1, $2);
1493 | mlhs_head tSTAR mlhs_node
1496 $$ = NEW_MASGN($1, $3);
1498 $$ = mlhs_add_star($1, $3);
1501 | mlhs_head tSTAR mlhs_node ',' mlhs_post
1504 $$ = NEW_MASGN($1, NEW_POSTARG($3,$5));
1506 $1 = mlhs_add_star($1, $3);
1507 $$ = mlhs_add($1, $5);
1513 $$ = NEW_MASGN($1, -1);
1515 $$ = mlhs_add_star($1, Qnil);
1518 | mlhs_head tSTAR ',' mlhs_post
1521 $$ = NEW_MASGN($1, NEW_POSTARG(-1, $4));
1523 $1 = mlhs_add_star($1, Qnil);
1524 $$ = mlhs_add($1, $4);
1530 $$ = NEW_MASGN(0, $2);
1532 $$ = mlhs_add_star(mlhs_new(), $2);
1535 | tSTAR mlhs_node ',' mlhs_post
1538 $$ = NEW_MASGN(0, NEW_POSTARG($2,$4));
1540 $2 = mlhs_add_star(mlhs_new(), $2);
1541 $$ = mlhs_add($2, $4);
1547 $$ = NEW_MASGN(0, -1);
1549 $$ = mlhs_add_star(mlhs_new(), Qnil);
1552 | tSTAR ',' mlhs_post
1555 $$ = NEW_MASGN(0, NEW_POSTARG(-1, $3));
1557 $$ = mlhs_add_star(mlhs_new(), Qnil);
1558 $$ = mlhs_add($$, $3);
1563 mlhs_item : mlhs_node
1564 | tLPAREN mlhs_inner rparen
1569 $$ = dispatch1(mlhs_paren, $2);
1574 mlhs_head : mlhs_item ','
1579 $$ = mlhs_add(mlhs_new(), $1);
1582 | mlhs_head mlhs_item ','
1585 $$ = list_append($1, $2);
1587 $$ = mlhs_add($1, $2);
1592 mlhs_post : mlhs_item
1597 $$ = mlhs_add(mlhs_new(), $1);
1600 | mlhs_post ',' mlhs_item
1603 $$ = list_append($1, $3);
1605 $$ = mlhs_add($1, $3);
1610 mlhs_node : user_variable
1612 $$ = assignable($1, 0);
1616 $$ = assignable($1, 0);
1618 | primary_value '[' opt_call_args rbracket
1621 $$ = aryset($1, $3);
1623 $$ = dispatch2(aref_field, $1, escape_Qundef($3));
1626 | primary_value '.' tIDENTIFIER
1629 $$ = attrset($1, $3);
1631 $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
1634 | primary_value tCOLON2 tIDENTIFIER
1637 $$ = attrset($1, $3);
1639 $$ = dispatch2(const_path_field, $1, $3);
1642 | primary_value '.' tCONSTANT
1645 $$ = attrset($1, $3);
1647 $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
1650 | primary_value tCOLON2 tCONSTANT
1653 if (in_def || in_single)
1654 yyerror("dynamic constant assignment");
1655 $$ = NEW_CDECL(0, 0, NEW_COLON2($1, $3));
1657 if (in_def || in_single)
1658 yyerror("dynamic constant assignment");
1659 $$ = dispatch2(const_path_field, $1, $3);
1665 if (in_def || in_single)
1666 yyerror("dynamic constant assignment");
1667 $$ = NEW_CDECL(0, 0, NEW_COLON3($2));
1669 $$ = dispatch1(top_const_field, $2);
1675 rb_backref_error($1);
1678 $$ = dispatch1(var_field, $1);
1679 $$ = dispatch1(assign_error, $$);
1686 $$ = assignable($1, 0);
1688 if (!$$) $$ = NEW_BEGIN(0);
1690 $$ = dispatch1(var_field, $$);
1695 $$ = assignable($1, 0);
1697 if (!$$) $$ = NEW_BEGIN(0);
1699 $$ = dispatch1(var_field, $$);
1702 | primary_value '[' opt_call_args rbracket
1705 $$ = aryset($1, $3);
1707 $$ = dispatch2(aref_field, $1, escape_Qundef($3));
1710 | primary_value '.' tIDENTIFIER
1713 $$ = attrset($1, $3);
1715 $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
1718 | primary_value tCOLON2 tIDENTIFIER
1721 $$ = attrset($1, $3);
1723 $$ = dispatch3(field, $1, ripper_intern("::"), $3);
1726 | primary_value '.' tCONSTANT
1729 $$ = attrset($1, $3);
1731 $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
1734 | primary_value tCOLON2 tCONSTANT
1737 if (in_def || in_single)
1738 yyerror("dynamic constant assignment");
1739 $$ = NEW_CDECL(0, 0, NEW_COLON2($1, $3));
1741 $$ = dispatch2(const_path_field, $1, $3);
1742 if (in_def || in_single) {
1743 $$ = dispatch1(assign_error, $$);
1750 if (in_def || in_single)
1751 yyerror("dynamic constant assignment");
1752 $$ = NEW_CDECL(0, 0, NEW_COLON3($2));
1754 $$ = dispatch1(top_const_field, $2);
1755 if (in_def || in_single) {
1756 $$ = dispatch1(assign_error, $$);
1763 rb_backref_error($1);
1766 $$ = dispatch1(assign_error, $1);
1774 yyerror("class/module name must be CONSTANT");
1776 $$ = dispatch1(class_name_error, $1);
1782 cpath : tCOLON3 cname
1785 $$ = NEW_COLON3($2);
1787 $$ = dispatch1(top_const_ref, $2);
1793 $$ = NEW_COLON2(0, $$);
1795 $$ = dispatch1(const_ref, $1);
1798 | primary_value tCOLON2 cname
1801 $$ = NEW_COLON2($1, $3);
1803 $$ = dispatch2(const_path_ref, $1, $3);
1813 lex_state = EXPR_ENDFN;
1818 lex_state = EXPR_ENDFN;
1834 $$ = NEW_LIT(ID2SYM($1));
1836 $$ = dispatch1(symbol_literal, $1);
1847 $$ = rb_ary_new3(1, $1);
1850 | undef_list ',' {lex_state = EXPR_FNAME;} fitem
1853 $$ = block_append($1, NEW_UNDEF($4));
1855 rb_ary_push($1, $4);
1860 op : '|' { ifndef_ripper($$ = '|'); }
1861 | '^' { ifndef_ripper($$ = '^'); }
1862 | '&' { ifndef_ripper($$ = '&'); }
1863 | tCMP { ifndef_ripper($$ = tCMP); }
1864 | tEQ { ifndef_ripper($$ = tEQ); }
1865 | tEQQ { ifndef_ripper($$ = tEQQ); }
1866 | tMATCH { ifndef_ripper($$ = tMATCH); }
1867 | tNMATCH { ifndef_ripper($$ = tNMATCH); }
1868 | '>' { ifndef_ripper($$ = '>'); }
1869 | tGEQ { ifndef_ripper($$ = tGEQ); }
1870 | '<' { ifndef_ripper($$ = '<'); }
1871 | tLEQ { ifndef_ripper($$ = tLEQ); }
1872 | tNEQ { ifndef_ripper($$ = tNEQ); }
1873 | tLSHFT { ifndef_ripper($$ = tLSHFT); }
1874 | tRSHFT { ifndef_ripper($$ = tRSHFT); }
1875 | '+' { ifndef_ripper($$ = '+'); }
1876 | '-' { ifndef_ripper($$ = '-'); }
1877 | '*' { ifndef_ripper($$ = '*'); }
1878 | tSTAR { ifndef_ripper($$ = '*'); }
1879 | '/' { ifndef_ripper($$ = '/'); }
1880 | '%' { ifndef_ripper($$ = '%'); }
1881 | tPOW { ifndef_ripper($$ = tPOW); }
1882 | '!' { ifndef_ripper($$ = '!'); }
1883 | '~' { ifndef_ripper($$ = '~'); }
1884 | tUPLUS { ifndef_ripper($$ = tUPLUS); }
1885 | tUMINUS { ifndef_ripper($$ = tUMINUS); }
1886 | tAREF { ifndef_ripper($$ = tAREF); }
1887 | tASET { ifndef_ripper($$ = tASET); }
1888 | '`' { ifndef_ripper($$ = '`'); }
1891 reswords : keyword__LINE__ | keyword__FILE__ | keyword__ENCODING__
1892 | keyword_BEGIN | keyword_END
1893 | keyword_alias | keyword_and | keyword_begin
1894 | keyword_break | keyword_case | keyword_class | keyword_def
1895 | keyword_defined | keyword_do | keyword_else | keyword_elsif
1896 | keyword_end | keyword_ensure | keyword_false
1897 | keyword_for | keyword_in | keyword_module | keyword_next
1898 | keyword_nil | keyword_not | keyword_or | keyword_redo
1899 | keyword_rescue | keyword_retry | keyword_return | keyword_self
1900 | keyword_super | keyword_then | keyword_true | keyword_undef
1901 | keyword_when | keyword_yield | keyword_if | keyword_unless
1902 | keyword_while | keyword_until
1909 $$ = node_assign($1, $3);
1911 $$ = dispatch2(assign, $1, $3);
1914 | lhs '=' arg modifier_rescue arg
1918 $3 = NEW_RESCUE($3, NEW_RESBODY(0,$5,0), 0);
1919 $$ = node_assign($1, $3);
1921 $$ = dispatch2(assign, $1, dispatch2(rescue_mod, $3, $5));
1924 | var_lhs tOP_ASGN arg
1929 ID vid = $1->nd_vid;
1932 $$ = NEW_OP_ASGN_OR(gettable(vid), $1);
1933 if (is_asgn_or_id(vid)) {
1937 else if ($2 == tANDOP) {
1939 $$ = NEW_OP_ASGN_AND(gettable(vid), $1);
1943 $$->nd_value = NEW_CALL(gettable(vid), $2, NEW_LIST($3));
1950 $$ = dispatch3(opassign, $1, $2, $3);
1953 | var_lhs tOP_ASGN arg modifier_rescue arg
1957 $3 = NEW_RESCUE($3, NEW_RESBODY(0,$5,0), 0);
1959 ID vid = $1->nd_vid;
1962 $$ = NEW_OP_ASGN_OR(gettable(vid), $1);
1963 if (is_asgn_or_id(vid)) {
1967 else if ($2 == tANDOP) {
1969 $$ = NEW_OP_ASGN_AND(gettable(vid), $1);
1973 $$->nd_value = NEW_CALL(gettable(vid), $2, NEW_LIST($3));
1980 $3 = dispatch2(rescue_mod, $3, $5);
1981 $$ = dispatch3(opassign, $1, $2, $3);
1984 | primary_value '[' opt_call_args rbracket tOP_ASGN arg
1990 if (!$3) $3 = NEW_ZARRAY();
1991 if (nd_type($3) == NODE_BLOCK_PASS) {
1992 args = NEW_ARGSCAT($3, $6);
1995 args = arg_concat($3, $6);
2000 else if ($5 == tANDOP) {
2003 $$ = NEW_OP_ASGN1($1, $5, args);
2006 $1 = dispatch2(aref_field, $1, escape_Qundef($3));
2007 $$ = dispatch3(opassign, $1, $5, $6);
2010 | primary_value '.' tIDENTIFIER tOP_ASGN arg
2017 else if ($4 == tANDOP) {
2020 $$ = NEW_OP_ASGN2($1, $3, $4, $5);
2023 $1 = dispatch3(field, $1, ripper_id2sym('.'), $3);
2024 $$ = dispatch3(opassign, $1, $4, $5);
2027 | primary_value '.' tCONSTANT tOP_ASGN arg
2034 else if ($4 == tANDOP) {
2037 $$ = NEW_OP_ASGN2($1, $3, $4, $5);
2040 $1 = dispatch3(field, $1, ripper_id2sym('.'), $3);
2041 $$ = dispatch3(opassign, $1, $4, $5);
2044 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
2051 else if ($4 == tANDOP) {
2054 $$ = NEW_OP_ASGN2($1, $3, $4, $5);
2057 $1 = dispatch3(field, $1, ripper_intern("::"), $3);
2058 $$ = dispatch3(opassign, $1, $4, $5);
2061 | primary_value tCOLON2 tCONSTANT tOP_ASGN arg
2064 yyerror("constant re-assignment");
2067 $$ = dispatch2(const_path_field, $1, $3);
2068 $$ = dispatch3(opassign, $$, $4, $5);
2069 $$ = dispatch1(assign_error, $$);
2072 | tCOLON3 tCONSTANT tOP_ASGN arg
2075 yyerror("constant re-assignment");
2078 $$ = dispatch1(top_const_field, $2);
2079 $$ = dispatch3(opassign, $$, $3, $4);
2080 $$ = dispatch1(assign_error, $$);
2083 | backref tOP_ASGN arg
2086 rb_backref_error($1);
2089 $$ = dispatch1(var_field, $1);
2090 $$ = dispatch3(opassign, $$, $2, $3);
2091 $$ = dispatch1(assign_error, $$);
2099 $$ = NEW_DOT2($1, $3);
2100 if (nd_type($1) == NODE_LIT && FIXNUM_P($1->nd_lit) &&
2101 nd_type($3) == NODE_LIT && FIXNUM_P($3->nd_lit)) {
2102 deferred_nodes = list_append(deferred_nodes, $$);
2105 $$ = dispatch2(dot2, $1, $3);
2113 $$ = NEW_DOT3($1, $3);
2114 if (nd_type($1) == NODE_LIT && FIXNUM_P($1->nd_lit) &&
2115 nd_type($3) == NODE_LIT && FIXNUM_P($3->nd_lit)) {
2116 deferred_nodes = list_append(deferred_nodes, $$);
2119 $$ = dispatch2(dot3, $1, $3);
2125 $$ = call_bin_op($1, '+', $3);
2127 $$ = dispatch3(binary, $1, ID2SYM('+'), $3);
2133 $$ = call_bin_op($1, '-', $3);
2135 $$ = dispatch3(binary, $1, ID2SYM('-'), $3);
2141 $$ = call_bin_op($1, '*', $3);
2143 $$ = dispatch3(binary, $1, ID2SYM('*'), $3);
2149 $$ = call_bin_op($1, '/', $3);
2151 $$ = dispatch3(binary, $1, ID2SYM('/'), $3);
2157 $$ = call_bin_op($1, '%', $3);
2159 $$ = dispatch3(binary, $1, ID2SYM('%'), $3);
2165 $$ = call_bin_op($1, tPOW, $3);
2167 $$ = dispatch3(binary, $1, ripper_intern("**"), $3);
2170 | tUMINUS_NUM tINTEGER tPOW arg
2173 $$ = NEW_CALL(call_bin_op($2, tPOW, $4), tUMINUS, 0);
2175 $$ = dispatch3(binary, $2, ripper_intern("**"), $4);
2176 $$ = dispatch2(unary, ripper_intern("-@"), $$);
2179 | tUMINUS_NUM tFLOAT tPOW arg
2182 $$ = NEW_CALL(call_bin_op($2, tPOW, $4), tUMINUS, 0);
2184 $$ = dispatch3(binary, $2, ripper_intern("**"), $4);
2185 $$ = dispatch2(unary, ripper_intern("-@"), $$);
2191 $$ = call_uni_op($2, tUPLUS);
2193 $$ = dispatch2(unary, ripper_intern("+@"), $2);
2199 $$ = call_uni_op($2, tUMINUS);
2201 $$ = dispatch2(unary, ripper_intern("-@"), $2);
2207 $$ = call_bin_op($1, '|', $3);
2209 $$ = dispatch3(binary, $1, ID2SYM('|'), $3);
2215 $$ = call_bin_op($1, '^', $3);
2217 $$ = dispatch3(binary, $1, ID2SYM('^'), $3);
2223 $$ = call_bin_op($1, '&', $3);
2225 $$ = dispatch3(binary, $1, ID2SYM('&'), $3);
2231 $$ = call_bin_op($1, tCMP, $3);
2233 $$ = dispatch3(binary, $1, ripper_intern("<=>"), $3);
2239 $$ = call_bin_op($1, '>', $3);
2241 $$ = dispatch3(binary, $1, ID2SYM('>'), $3);
2247 $$ = call_bin_op($1, tGEQ, $3);
2249 $$ = dispatch3(binary, $1, ripper_intern(">="), $3);
2255 $$ = call_bin_op($1, '<', $3);
2257 $$ = dispatch3(binary, $1, ID2SYM('<'), $3);
2263 $$ = call_bin_op($1, tLEQ, $3);
2265 $$ = dispatch3(binary, $1, ripper_intern("<="), $3);
2271 $$ = call_bin_op($1, tEQ, $3);
2273 $$ = dispatch3(binary, $1, ripper_intern("=="), $3);
2279 $$ = call_bin_op($1, tEQQ, $3);
2281 $$ = dispatch3(binary, $1, ripper_intern("==="), $3);
2287 $$ = call_bin_op($1, tNEQ, $3);
2289 $$ = dispatch3(binary, $1, ripper_intern("!="), $3);
2295 $$ = match_op($1, $3);
2296 if (nd_type($1) == NODE_LIT && TYPE($1->nd_lit) == T_REGEXP) {
2297 $$ = reg_named_capture_assign($1->nd_lit, $$);
2300 $$ = dispatch3(binary, $1, ripper_intern("=~"), $3);
2306 $$ = call_bin_op($1, tNMATCH, $3);
2308 $$ = dispatch3(binary, $1, ripper_intern("!~"), $3);
2314 $$ = call_uni_op(cond($2), '!');
2316 $$ = dispatch2(unary, ID2SYM('!'), $2);
2322 $$ = call_uni_op($2, '~');
2324 $$ = dispatch2(unary, ID2SYM('~'), $2);
2330 $$ = call_bin_op($1, tLSHFT, $3);
2332 $$ = dispatch3(binary, $1, ripper_intern("<<"), $3);
2338 $$ = call_bin_op($1, tRSHFT, $3);
2340 $$ = dispatch3(binary, $1, ripper_intern(">>"), $3);
2346 $$ = logop(NODE_AND, $1, $3);
2348 $$ = dispatch3(binary, $1, ripper_intern("&&"), $3);
2354 $$ = logop(NODE_OR, $1, $3);
2356 $$ = dispatch3(binary, $1, ripper_intern("||"), $3);
2359 | keyword_defined opt_nl {in_defined = 1;} arg
2363 $$ = NEW_DEFINED($4);
2366 $$ = dispatch1(defined, $4);
2369 | arg '?' arg opt_nl ':' arg
2373 $$ = NEW_IF(cond($1), $3, $6);
2376 $$ = dispatch3(ifop, $1, $3, $6);
2390 if (!$$) $$ = NEW_NIL();
2402 | args ',' assocs trailer
2405 $$ = arg_append($1, NEW_HASH($3));
2407 $$ = arg_add_assocs($1, $3);
2413 $$ = NEW_LIST(NEW_HASH($1));
2415 $$ = arg_add_assocs(arg_new(), $1);
2420 paren_args : '(' opt_call_args rparen
2425 $$ = dispatch1(arg_paren, escape_Qundef($2));
2430 opt_paren_args : none
2434 opt_call_args : none
2440 | args ',' assocs ','
2443 $$ = arg_append($1, NEW_HASH($3));
2445 $$ = arg_add_assocs($1, $3);
2451 $$ = NEW_LIST(NEW_HASH($1));
2453 $$ = arg_add_assocs(arg_new(), $1);
2464 $$ = arg_add(arg_new(), $1);
2467 | args opt_block_arg
2470 $$ = arg_blk_pass($1, $2);
2472 $$ = arg_add_optblock($1, $2);
2475 | assocs opt_block_arg
2478 $$ = NEW_LIST(NEW_HASH($1));
2479 $$ = arg_blk_pass($$, $2);
2481 $$ = arg_add_assocs(arg_new(), $1);
2482 $$ = arg_add_optblock($$, $2);
2485 | args ',' assocs opt_block_arg
2488 $$ = arg_append($1, NEW_HASH($3));
2489 $$ = arg_blk_pass($$, $4);
2491 $$ = arg_add_optblock(arg_add_assocs($1, $3), $4);
2498 $$ = arg_add_block(arg_new(), $1);
2504 $<val>$ = cmdarg_stack;
2510 cmdarg_stack = $<val>1;
2515 block_arg : tAMPER arg_value
2518 $$ = NEW_BLOCK_PASS($2);
2525 opt_block_arg : ',' block_arg
2540 $$ = arg_add(arg_new(), $1);
2548 $$ = arg_add_star(arg_new(), $2);
2551 | args ',' arg_value
2555 if ((n1 = splat_array($1)) != 0) {
2556 $$ = list_append(n1, $3);
2559 $$ = arg_append($1, $3);
2562 $$ = arg_add($1, $3);
2565 | args ',' tSTAR arg_value
2569 if ((nd_type($4) == NODE_ARRAY) && (n1 = splat_array($1)) != 0) {
2570 $$ = list_concat(n1, $4);
2573 $$ = arg_concat($1, $4);
2576 $$ = arg_add_star($1, $4);
2581 mrhs : args ',' arg_value
2585 if ((n1 = splat_array($1)) != 0) {
2586 $$ = list_append(n1, $3);
2589 $$ = arg_append($1, $3);
2592 $$ = mrhs_add(args2mrhs($1), $3);
2595 | args ',' tSTAR arg_value
2599 if (nd_type($4) == NODE_ARRAY &&
2600 (n1 = splat_array($1)) != 0) {
2601 $$ = list_concat(n1, $4);
2604 $$ = arg_concat($1, $4);
2607 $$ = mrhs_add_star(args2mrhs($1), $4);
2615 $$ = mrhs_add_star(mrhs_new(), $2);
2631 $$ = NEW_FCALL($1, 0);
2633 $$ = method_arg(dispatch1(fcall, $1), arg_new());
2639 $<num>$ = ruby_sourceline;
2651 if (nd_type($3) == NODE_RESCUE ||
2652 nd_type($3) == NODE_ENSURE)
2653 nd_set_line($3, $<num>2);
2656 nd_set_line($$, $<num>2);
2658 $$ = dispatch1(begin, $3);
2661 | tLPAREN_ARG expr {lex_state = EXPR_ENDARG;} rparen
2663 rb_warning0("(...) interpreted as grouped expression");
2667 $$ = dispatch1(paren, $2);
2670 | tLPAREN compstmt ')'
2675 $$ = dispatch1(paren, $2);
2678 | primary_value tCOLON2 tCONSTANT
2681 $$ = NEW_COLON2($1, $3);
2683 $$ = dispatch2(const_path_ref, $1, $3);
2689 $$ = NEW_COLON3($2);
2691 $$ = dispatch1(top_const_ref, $2);
2694 | tLBRACK aref_args ']'
2698 $$ = NEW_ZARRAY(); /* zero length array*/
2704 $$ = dispatch1(array, escape_Qundef($2));
2707 | tLBRACE assoc_list '}'
2712 $$ = dispatch1(hash, escape_Qundef($2));
2720 $$ = dispatch0(return0);
2723 | keyword_yield '(' call_args rparen
2728 $$ = dispatch1(yield, dispatch1(paren, $3));
2731 | keyword_yield '(' rparen
2734 $$ = NEW_YIELD(0, Qfalse);
2736 $$ = dispatch1(yield, dispatch1(paren, arg_new()));
2742 $$ = NEW_YIELD(0, Qfalse);
2744 $$ = dispatch0(yield0);
2747 | keyword_defined opt_nl '(' {in_defined = 1;} expr rparen
2751 $$ = NEW_DEFINED($5);
2754 $$ = dispatch1(defined, $5);
2757 | keyword_not '(' expr rparen
2760 $$ = call_uni_op(cond($3), '!');
2762 $$ = dispatch2(unary, ripper_intern("not"), $3);
2765 | keyword_not '(' rparen
2768 $$ = call_uni_op(cond(NEW_NIL()), '!');
2770 $$ = dispatch2(unary, ripper_intern("not"), Qnil);
2773 | operation brace_block
2776 $2->nd_iter = NEW_FCALL($1, 0);
2778 fixpos($2->nd_iter, $2);
2780 $$ = method_arg(dispatch1(fcall, $1), arg_new());
2781 $$ = method_add_block($$, $2);
2785 | method_call brace_block
2788 block_dup_check($1->nd_args, $2);
2793 $$ = method_add_block($1, $2);
2800 | k_if expr_value then
2806 $$ = NEW_IF(cond($2), $4, $5);
2809 $$ = dispatch3(if, $2, $4, escape_Qundef($5));
2812 | k_unless expr_value then
2818 $$ = NEW_UNLESS(cond($2), $4, $5);
2821 $$ = dispatch3(unless, $2, $4, escape_Qundef($5));
2824 | k_while {COND_PUSH(1);} expr_value do {COND_POP();}
2829 $$ = NEW_WHILE(cond($3), $6, 1);
2832 $$ = dispatch2(while, $3, $6);
2835 | k_until {COND_PUSH(1);} expr_value do {COND_POP();}
2840 $$ = NEW_UNTIL(cond($3), $6, 1);
2843 $$ = dispatch2(until, $3, $6);
2846 | k_case expr_value opt_terms
2851 $$ = NEW_CASE($2, $4);
2854 $$ = dispatch2(case, $2, $4);
2857 | k_case opt_terms case_body k_end
2860 $$ = NEW_CASE(0, $3);
2862 $$ = dispatch2(case, Qnil, $3);
2865 | k_for for_var keyword_in
2876 * e.each{|*x| a, b, c = x
2880 * e.each{|x| a, = x}
2882 ID id = internal_id();
2883 ID *tbl = ALLOC_N(ID, 2);
2884 NODE *m = NEW_ARGS_AUX(0, 0);
2887 if (nd_type($2) == NODE_MASGN) {
2888 /* if args.length == 1 && args[0].kind_of?(Array)
2892 NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
2893 NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
2894 m->nd_next = block_append(
2897 NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("length"), 0),
2898 rb_intern("=="), one),
2899 NEW_CALL(NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero),
2900 rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
2903 NEW_CALL(NEW_DVAR(id), rb_intern("[]"), zero)),
2905 node_assign($2, NEW_DVAR(id)));
2907 args = new_args(m, 0, id, 0, 0);
2910 if (nd_type($2) == NODE_LASGN ||
2911 nd_type($2) == NODE_DASGN ||
2912 nd_type($2) == NODE_DASGN_CURR) {
2913 $2->nd_value = NEW_DVAR(id);
2916 args = new_args(m, 0, 0, 0, 0);
2919 m->nd_next = node_assign(NEW_MASGN(NEW_LIST($2), 0), NEW_DVAR(id));
2920 args = new_args(m, 0, id, 0, 0);
2923 scope = NEW_NODE(NODE_SCOPE, tbl, $8, args);
2924 tbl[0] = 1; tbl[1] = id;
2925 $$ = NEW_FOR(0, $5, scope);
2928 $$ = dispatch3(for, $2, $5, $8);
2931 | k_class cpath superclass
2933 if (in_def || in_single)
2934 yyerror("class definition in method body");
2937 $<num>$ = ruby_sourceline;
2945 $$ = NEW_CLASS($2, $5, $3);
2946 nd_set_line($$, $<num>4);
2948 $$ = dispatch3(class, $2, $3, $5);
2952 | k_class tLSHFT expr
2959 $<num>$ = in_single;
2967 $$ = NEW_SCLASS($3, $7);
2970 $$ = dispatch2(sclass, $3, $7);
2974 in_single = $<num>6;
2978 if (in_def || in_single)
2979 yyerror("module definition in method body");
2982 $<num>$ = ruby_sourceline;
2990 $$ = NEW_MODULE($2, $4);
2991 nd_set_line($$, $<num>3);
2993 $$ = dispatch2(module, $2, $4);
3009 NODE *body = remove_begin($5);
3010 reduce_nodes(&body);
3011 $$ = NEW_DEFN($2, $4, body, NOEX_PRIVATE);
3012 nd_set_line($$, $<num>1);
3014 $$ = dispatch3(def, $2, $4, $5);
3020 | k_def singleton dot_or_colon {lex_state = EXPR_FNAME;} fname
3023 lex_state = EXPR_ENDFN; /* force for args */
3031 NODE *body = remove_begin($8);
3032 reduce_nodes(&body);
3033 $$ = NEW_DEFS($2, $5, $7, body);
3034 nd_set_line($$, $<num>1);
3036 $$ = dispatch5(defs, $2, $3, $5, $7, $8);
3046 $$ = dispatch1(break, arg_new());
3054 $$ = dispatch1(next, arg_new());
3062 $$ = dispatch0(redo);
3070 $$ = dispatch0(retry);
3075 primary_value : primary
3080 if (!$$) $$ = NEW_NIL();
3087 k_begin : keyword_begin
3089 token_info_push("begin");
3095 token_info_push("if");
3099 k_unless : keyword_unless
3101 token_info_push("unless");
3105 k_while : keyword_while
3107 token_info_push("while");
3111 k_until : keyword_until
3113 token_info_push("until");
3117 k_case : keyword_case
3119 token_info_push("case");
3125 token_info_push("for");
3129 k_class : keyword_class
3131 token_info_push("class");
3135 k_module : keyword_module
3137 token_info_push("module");
3143 token_info_push("def");
3145 $<num>$ = ruby_sourceline;
3153 token_info_pop("end");
3179 | keyword_elsif expr_value then
3184 $$ = NEW_IF(cond($2), $4, $5);
3187 $$ = dispatch3(elsif, $2, $4, escape_Qundef($5));
3193 | keyword_else compstmt
3198 $$ = dispatch1(else, $2);
3209 $$ = assignable($1, 0);
3212 $$ = dispatch1(mlhs_paren, $$);
3215 | tLPAREN f_margs rparen
3220 $$ = dispatch1(mlhs_paren, $2);
3225 f_marg_list : f_marg
3230 $$ = mlhs_add(mlhs_new(), $1);
3233 | f_marg_list ',' f_marg
3236 $$ = list_append($1, $3);
3238 $$ = mlhs_add($1, $3);
3243 f_margs : f_marg_list
3246 $$ = NEW_MASGN($1, 0);
3251 | f_marg_list ',' tSTAR f_norm_arg
3253 $$ = assignable($4, 0);
3255 $$ = NEW_MASGN($1, $$);
3257 $$ = mlhs_add_star($1, $$);
3260 | f_marg_list ',' tSTAR f_norm_arg ',' f_marg_list
3262 $$ = assignable($4, 0);
3264 $$ = NEW_MASGN($1, NEW_POSTARG($$, $6));
3266 $$ = mlhs_add_star($1, $$);
3269 | f_marg_list ',' tSTAR
3272 $$ = NEW_MASGN($1, -1);
3274 $$ = mlhs_add_star($1, Qnil);
3277 | f_marg_list ',' tSTAR ',' f_marg_list
3280 $$ = NEW_MASGN($1, NEW_POSTARG(-1, $5));
3282 $$ = mlhs_add_star($1, $5);
3287 $$ = assignable($2, 0);
3289 $$ = NEW_MASGN(0, $$);
3291 $$ = mlhs_add_star(mlhs_new(), $$);
3294 | tSTAR f_norm_arg ',' f_marg_list
3296 $$ = assignable($2, 0);
3298 $$ = NEW_MASGN(0, NEW_POSTARG($$, $4));
3303 $$ = mlhs_add_star($$, $4);
3309 $$ = NEW_MASGN(0, -1);
3311 $$ = mlhs_add_star(mlhs_new(), Qnil);
3314 | tSTAR ',' f_marg_list
3317 $$ = NEW_MASGN(0, NEW_POSTARG(-1, $3));
3319 $$ = mlhs_add_star(mlhs_new(), Qnil);
3324 block_param : f_arg ',' f_block_optarg ',' f_rest_arg opt_f_block_arg
3327 $$ = new_args($1, $3, $5, 0, $6);
3329 $$ = params_new($1, $3, $5, Qnil, escape_Qundef($6));
3332 | f_arg ',' f_block_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
3335 $$ = new_args($1, $3, $5, $7, $8);
3337 $$ = params_new($1, $3, $5, $7, escape_Qundef($8));
3340 | f_arg ',' f_block_optarg opt_f_block_arg
3343 $$ = new_args($1, $3, 0, 0, $4);
3345 $$ = params_new($1, $3, Qnil, Qnil, escape_Qundef($4));
3348 | f_arg ',' f_block_optarg ',' f_arg opt_f_block_arg
3351 $$ = new_args($1, $3, 0, $5, $6);
3353 $$ = params_new($1, $3, Qnil, $5, escape_Qundef($6));
3356 | f_arg ',' f_rest_arg opt_f_block_arg
3359 $$ = new_args($1, 0, $3, 0, $4);
3361 $$ = params_new($1, Qnil, $3, Qnil, escape_Qundef($4));
3367 $$ = new_args($1, 0, 1, 0, 0);
3369 $$ = params_new($1, Qnil, Qnil, Qnil, Qnil);
3370 dispatch1(excessed_comma, $$);
3373 | f_arg ',' f_rest_arg ',' f_arg opt_f_block_arg
3376 $$ = new_args($1, 0, $3, $5, $6);
3378 $$ = params_new($1, Qnil, $3, $5, escape_Qundef($6));
3381 | f_arg opt_f_block_arg
3384 $$ = new_args($1, 0, 0, 0, $2);
3386 $$ = params_new($1, Qnil,Qnil, Qnil, escape_Qundef($2));
3389 | f_block_optarg ',' f_rest_arg opt_f_block_arg
3392 $$ = new_args(0, $1, $3, 0, $4);
3394 $$ = params_new(Qnil, $1, $3, Qnil, escape_Qundef($4));
3397 | f_block_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
3400 $$ = new_args(0, $1, $3, $5, $6);
3402 $$ = params_new(Qnil, $1, $3, $5, escape_Qundef($6));
3405 | f_block_optarg opt_f_block_arg
3408 $$ = new_args(0, $1, 0, 0, $2);
3410 $$ = params_new(Qnil, $1, Qnil, Qnil,escape_Qundef($2));
3413 | f_block_optarg ',' f_arg opt_f_block_arg
3416 $$ = new_args(0, $1, 0, $3, $4);
3418 $$ = params_new(Qnil, $1, Qnil, $3, escape_Qundef($4));
3421 | f_rest_arg opt_f_block_arg
3424 $$ = new_args(0, 0, $1, 0, $2);
3426 $$ = params_new(Qnil, Qnil, $1, Qnil, escape_Qundef($2));
3429 | f_rest_arg ',' f_arg opt_f_block_arg
3432 $$ = new_args(0, 0, $1, $3, $4);
3434 $$ = params_new(Qnil, Qnil, $1, $3, escape_Qundef($4));
3440 $$ = new_args(0, 0, 0, 0, $1);
3442 $$ = params_new(Qnil, Qnil, Qnil, Qnil, $1);
3447 opt_block_param : none
3450 command_start = TRUE;
3454 block_param_def : '|' opt_bv_decl '|'
3459 $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
3468 $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil),
3472 | '|' block_param opt_bv_decl '|'
3477 $$ = blockvar_new(escape_Qundef($2), escape_Qundef($3));
3498 $$ = rb_ary_new3(1, $1);
3505 rb_ary_push($$, $3);
3525 $<vars>$ = dyna_push();
3529 lpar_beg = ++paren_nest;
3537 $$->nd_body = NEW_SCOPE($3->nd_head, $4);
3539 $$ = dispatch2(lambda, $3, $4);
3545 f_larglist : '(' f_args opt_bv_decl rparen
3548 $$ = NEW_LAMBDA($2);
3550 $$ = dispatch1(paren, $2);
3556 $$ = NEW_LAMBDA($1);
3563 lambda_body : tLAMBEG compstmt '}'
3567 | keyword_do_LAMBDA compstmt keyword_end
3573 do_block : keyword_do_block
3575 $<vars>1 = dyna_push();
3577 $<num>$ = ruby_sourceline;
3585 $$ = NEW_ITER($3,$4);
3586 nd_set_line($$, $<num>2);
3588 $$ = dispatch2(do_block, escape_Qundef($3), $4);
3594 block_call : command do_block
3597 if (nd_type($1) == NODE_YIELD) {
3598 compile_error(PARSER_ARG "block given to yield");
3601 block_dup_check($1->nd_args, $2);
3607 $$ = method_add_block($1, $2);
3610 | block_call '.' operation2 opt_paren_args
3613 $$ = NEW_CALL($1, $3, $4);
3615 $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
3616 $$ = method_optarg($$, $4);
3619 | block_call tCOLON2 operation2 opt_paren_args
3622 $$ = NEW_CALL($1, $3, $4);
3624 $$ = dispatch3(call, $1, ripper_intern("::"), $3);
3625 $$ = method_optarg($$, $4);
3630 method_call : operation paren_args
3633 $$ = NEW_FCALL($1, $2);
3636 $$ = method_arg(dispatch1(fcall, $1), $2);
3639 | primary_value '.' operation2 opt_paren_args
3642 $$ = NEW_CALL($1, $3, $4);
3645 $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
3646 $$ = method_optarg($$, $4);
3649 | primary_value tCOLON2 operation2 paren_args
3652 $$ = NEW_CALL($1, $3, $4);
3655 $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
3656 $$ = method_optarg($$, $4);
3659 | primary_value tCOLON2 operation3
3662 $$ = NEW_CALL($1, $3, 0);
3664 $$ = dispatch3(call, $1, ripper_intern("::"), $3);
3667 | primary_value '.' paren_args
3670 $$ = NEW_CALL($1, rb_intern("call"), $3);
3673 $$ = dispatch3(call, $1, ripper_id2sym('.'),
3674 ripper_intern("call"));
3675 $$ = method_optarg($$, $3);
3678 | primary_value tCOLON2 paren_args
3681 $$ = NEW_CALL($1, rb_intern("call"), $3);
3684 $$ = dispatch3(call, $1, ripper_intern("::"),
3685 ripper_intern("call"));
3686 $$ = method_optarg($$, $3);
3689 | keyword_super paren_args
3694 $$ = dispatch1(super, $2);
3702 $$ = dispatch0(zsuper);
3705 | primary_value '[' opt_call_args rbracket
3708 if ($1 && nd_type($1) == NODE_SELF)
3709 $$ = NEW_FCALL(tAREF, $3);
3711 $$ = NEW_CALL($1, tAREF, $3);
3714 $$ = dispatch2(aref, $1, escape_Qundef($3));
3721 $<vars>1 = dyna_push();
3723 $<num>$ = ruby_sourceline;
3731 $$ = NEW_ITER($3,$4);
3732 nd_set_line($$, $<num>2);
3734 $$ = dispatch2(brace_block, escape_Qundef($3), $4);
3740 $<vars>1 = dyna_push();
3742 $<num>$ = ruby_sourceline;
3747 compstmt keyword_end
3750 $$ = NEW_ITER($3,$4);
3751 nd_set_line($$, $<num>2);
3753 $$ = dispatch2(do_block, escape_Qundef($3), $4);
3759 case_body : keyword_when args then
3764 $$ = NEW_WHEN($2, $4, $5);
3766 $$ = dispatch3(when, $2, $4, escape_Qundef($5));
3775 opt_rescue : keyword_rescue exc_list exc_var then
3781 $3 = node_assign($3, NEW_ERRINFO());
3782 $5 = block_append($3, $5);
3784 $$ = NEW_RESBODY($2, $5, $6);
3785 fixpos($$, $2?$2:$5);
3787 $$ = dispatch4(rescue,
3797 exc_list : arg_value
3802 $$ = rb_ary_new3(1, $1);
3808 if (!($$ = splat_array($1))) $$ = $1;
3816 exc_var : tASSOC lhs
3823 opt_ensure : keyword_ensure compstmt
3828 $$ = dispatch1(ensure, $2);
3838 $$ = NEW_LIT(ID2SYM($1));
3840 $$ = dispatch1(symbol_literal, $1);
3851 node = NEW_STR(STR_NEW0());
3854 node = evstr2dstr(node);
3868 $$ = literal_concat($1, $2);
3870 $$ = dispatch2(string_concat, $1, $2);
3875 string1 : tSTRING_BEG string_contents tSTRING_END
3880 $$ = dispatch1(string_literal, $2);
3885 xstring : tXSTRING_BEG xstring_contents tSTRING_END
3890 node = NEW_XSTR(STR_NEW0());
3893 switch (nd_type(node)) {
3895 nd_set_type(node, NODE_XSTR);
3898 nd_set_type(node, NODE_DXSTR);
3901 node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
3907 $$ = dispatch1(xstring_literal, $2);
3912 regexp : tREGEXP_BEG regexp_contents tREGEXP_END
3919 node = NEW_LIT(reg_compile(STR_NEW0(), options));
3921 else switch (nd_type(node)) {
3924 VALUE src = node->nd_lit;
3925 nd_set_type(node, NODE_LIT);
3926 node->nd_lit = reg_compile(src, options);
3930 node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
3932 if (options & RE_OPTION_ONCE) {
3933 nd_set_type(node, NODE_DREGX_ONCE);
3936 nd_set_type(node, NODE_DREGX);
3938 node->nd_cflag = options & RE_OPTION_MASK;
3939 if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
3940 for (list = (prev = node)->nd_next; list; list = list->nd_next) {
3941 if (nd_type(list->nd_head) == NODE_STR) {
3942 VALUE tail = list->nd_head->nd_lit;
3943 if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
3944 VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
3945 if (!literal_concat0(parser, lit, tail)) {
3949 rb_str_resize(tail, 0);
3950 prev->nd_next = list->nd_next;
3951 rb_gc_force_recycle((VALUE)list->nd_head);
3952 rb_gc_force_recycle((VALUE)list);
3963 if (!node->nd_next) {
3964 VALUE src = node->nd_lit;
3965 nd_set_type(node, NODE_LIT);
3966 node->nd_lit = reg_compile(src, options);
3972 $$ = dispatch2(regexp_literal, $2, $3);
3977 words : tWORDS_BEG ' ' tSTRING_END
3982 $$ = dispatch0(words_new);
3983 $$ = dispatch1(array, $$);
3986 | tWORDS_BEG word_list tSTRING_END
3991 $$ = dispatch1(array, $2);
3996 word_list : /* none */
4001 $$ = dispatch0(words_new);
4004 | word_list word ' '
4007 $$ = list_append($1, evstr2dstr($2));
4009 $$ = dispatch2(words_add, $1, $2);
4014 word : string_content
4018 $$ = dispatch0(word_new);
4019 $$ = dispatch2(word_add, $$, $1);
4022 | word string_content
4025 $$ = literal_concat($1, $2);
4027 $$ = dispatch2(word_add, $1, $2);
4032 qwords : tQWORDS_BEG ' ' tSTRING_END
4037 $$ = dispatch0(qwords_new);
4038 $$ = dispatch1(array, $$);
4041 | tQWORDS_BEG qword_list tSTRING_END
4046 $$ = dispatch1(array, $2);
4051 qword_list : /* none */
4056 $$ = dispatch0(qwords_new);
4059 | qword_list tSTRING_CONTENT ' '
4062 $$ = list_append($1, $2);
4064 $$ = dispatch2(qwords_add, $1, $2);
4069 string_contents : /* none */
4074 $$ = dispatch0(string_content);
4077 | string_contents string_content
4080 $$ = literal_concat($1, $2);
4082 $$ = dispatch2(string_add, $1, $2);
4087 xstring_contents: /* none */
4092 $$ = dispatch0(xstring_new);
4095 | xstring_contents string_content
4098 $$ = literal_concat($1, $2);
4100 $$ = dispatch2(xstring_add, $1, $2);
4105 regexp_contents: /* none */
4110 $$ = dispatch0(regexp_new);
4113 | regexp_contents string_content
4116 NODE *head = $1, *tail = $2;
4124 switch (nd_type(head)) {
4126 nd_set_type(head, NODE_DSTR);
4131 head = list_append(NEW_DSTR(Qnil), head);
4134 $$ = list_append(head, tail);
4137 $$ = dispatch2(regexp_add, $1, $2);
4142 string_content : tSTRING_CONTENT
4145 $<node>$ = lex_strterm;
4147 lex_state = EXPR_BEG;
4152 lex_strterm = $<node>2;
4155 lex_strterm = $<node>2;
4156 $$ = dispatch1(string_dvar, $3);
4161 $<val>1 = cond_stack;
4162 $<val>$ = cmdarg_stack;
4167 $<node>$ = lex_strterm;
4169 lex_state = EXPR_BEG;
4173 cond_stack = $<val>1;
4174 cmdarg_stack = $<val>2;
4175 lex_strterm = $<node>3;
4177 if ($4) $4->flags &= ~NODE_FL_NEWLINE;
4180 $$ = dispatch1(string_embexpr, $4);
4190 $$ = dispatch1(var_ref, $1);
4198 $$ = dispatch1(var_ref, $1);
4206 $$ = dispatch1(var_ref, $1);
4212 symbol : tSYMBEG sym
4214 lex_state = EXPR_END;
4218 $$ = dispatch1(symbol, $2);
4229 dsym : tSYMBEG xstring_contents tSTRING_END
4231 lex_state = EXPR_END;
4234 $$ = NEW_LIT(ID2SYM(rb_intern("")));
4239 switch (nd_type($$)) {
4241 nd_set_type($$, NODE_DSYM);
4245 $$->nd_lit = ID2SYM(rb_intern_str(lit));
4246 nd_set_type($$, NODE_LIT);
4249 $$ = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST($$));
4254 $$ = dispatch1(dyna_symbol, $2);
4261 | tUMINUS_NUM tINTEGER %prec tLOWEST
4264 $$ = negate_lit($2);
4266 $$ = dispatch2(unary, ripper_intern("-@"), $2);
4269 | tUMINUS_NUM tFLOAT %prec tLOWEST
4272 $$ = negate_lit($2);
4274 $$ = dispatch2(unary, ripper_intern("-@"), $2);
4279 user_variable : tIDENTIFIER
4286 keyword_variable: keyword_nil {ifndef_ripper($$ = keyword_nil);}
4287 | keyword_self {ifndef_ripper($$ = keyword_self);}
4288 | keyword_true {ifndef_ripper($$ = keyword_true);}
4289 | keyword_false {ifndef_ripper($$ = keyword_false);}
4290 | keyword__FILE__ {ifndef_ripper($$ = keyword__FILE__);}
4291 | keyword__LINE__ {ifndef_ripper($$ = keyword__LINE__);}
4292 | keyword__ENCODING__ {ifndef_ripper($$ = keyword__ENCODING__);}
4295 var_ref : user_variable
4298 if (!($$ = gettable($1))) $$ = NEW_BEGIN(0);
4300 if (id_is_var(get_id($1))) {
4301 $$ = dispatch1(var_ref, $1);
4304 $$ = dispatch1(vcall, $1);
4311 if (!($$ = gettable($1))) $$ = NEW_BEGIN(0);
4313 $$ = dispatch1(var_ref, $1);
4318 var_lhs : user_variable
4320 $$ = assignable($1, 0);
4323 $$ = dispatch1(var_field, $$);
4328 $$ = assignable($1, 0);
4331 $$ = dispatch1(var_field, $$);
4350 lex_state = EXPR_BEG;
4368 f_arglist : '(' f_args rparen
4373 $$ = dispatch1(paren, $2);
4375 lex_state = EXPR_BEG;
4376 command_start = TRUE;
4381 lex_state = EXPR_BEG;
4382 command_start = TRUE;
4386 f_args : f_arg ',' f_optarg ',' f_rest_arg opt_f_block_arg
4389 $$ = new_args($1, $3, $5, 0, $6);
4391 $$ = params_new($1, $3, $5, Qnil, escape_Qundef($6));
4394 | f_arg ',' f_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
4397 $$ = new_args($1, $3, $5, $7, $8);
4399 $$ = params_new($1, $3, $5, $7, escape_Qundef($8));
4402 | f_arg ',' f_optarg opt_f_block_arg
4405 $$ = new_args($1, $3, 0, 0, $4);
4407 $$ = params_new($1, $3, Qnil, Qnil, escape_Qundef($4));
4410 | f_arg ',' f_optarg ',' f_arg opt_f_block_arg
4413 $$ = new_args($1, $3, 0, $5, $6);
4415 $$ = params_new($1, $3, Qnil, $5, escape_Qundef($6));
4418 | f_arg ',' f_rest_arg opt_f_block_arg
4421 $$ = new_args($1, 0, $3, 0, $4);
4423 $$ = params_new($1, Qnil, $3, Qnil, escape_Qundef($4));
4426 | f_arg ',' f_rest_arg ',' f_arg opt_f_block_arg
4429 $$ = new_args($1, 0, $3, $5, $6);
4431 $$ = params_new($1, Qnil, $3, $5, escape_Qundef($6));
4434 | f_arg opt_f_block_arg
4437 $$ = new_args($1, 0, 0, 0, $2);
4439 $$ = params_new($1, Qnil, Qnil, Qnil,escape_Qundef($2));
4442 | f_optarg ',' f_rest_arg opt_f_block_arg
4445 $$ = new_args(0, $1, $3, 0, $4);
4447 $$ = params_new(Qnil, $1, $3, Qnil, escape_Qundef($4));
4450 | f_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
4453 $$ = new_args(0, $1, $3, $5, $6);
4455 $$ = params_new(Qnil, $1, $3, $5, escape_Qundef($6));
4458 | f_optarg opt_f_block_arg
4461 $$ = new_args(0, $1, 0, 0, $2);
4463 $$ = params_new(Qnil, $1, Qnil, Qnil,escape_Qundef($2));
4466 | f_optarg ',' f_arg opt_f_block_arg
4469 $$ = new_args(0, $1, 0, $3, $4);
4471 $$ = params_new(Qnil, $1, Qnil, $3, escape_Qundef($4));
4474 | f_rest_arg opt_f_block_arg
4477 $$ = new_args(0, 0, $1, 0, $2);
4479 $$ = params_new(Qnil, Qnil, $1, Qnil,escape_Qundef($2));
4482 | f_rest_arg ',' f_arg opt_f_block_arg
4485 $$ = new_args(0, 0, $1, $3, $4);
4487 $$ = params_new(Qnil, Qnil, $1, $3, escape_Qundef($4));
4493 $$ = new_args(0, 0, 0, 0, $1);
4495 $$ = params_new(Qnil, Qnil, Qnil, Qnil, $1);
4501 $$ = new_args(0, 0, 0, 0, 0);
4503 $$ = params_new(Qnil, Qnil, Qnil, Qnil, Qnil);
4508 f_bad_arg : tCONSTANT
4511 yyerror("formal argument cannot be a constant");
4514 $$ = dispatch1(param_error, $1);
4520 yyerror("formal argument cannot be an instance variable");
4523 $$ = dispatch1(param_error, $1);
4529 yyerror("formal argument cannot be a global variable");
4532 $$ = dispatch1(param_error, $1);
4538 yyerror("formal argument cannot be a class variable");
4541 $$ = dispatch1(param_error, $1);
4546 f_norm_arg : f_bad_arg
4549 formal_argument(get_id($1));
4554 f_arg_item : f_norm_arg
4556 arg_var(get_id($1));
4558 $$ = NEW_ARGS_AUX($1, 1);
4563 | tLPAREN f_margs rparen
4565 ID tid = internal_id();
4568 if (dyna_in_block()) {
4569 $2->nd_value = NEW_DVAR(tid);
4572 $2->nd_value = NEW_LVAR(tid);
4574 $$ = NEW_ARGS_AUX(tid, 1);
4577 $$ = dispatch1(mlhs_paren, $2);
4586 $$ = rb_ary_new3(1, $1);
4589 | f_arg ',' f_arg_item
4594 $$->nd_next = block_append($$->nd_next, $3->nd_next);
4595 rb_gc_force_recycle((VALUE)$3);
4597 $$ = rb_ary_push($1, $3);
4602 f_opt : tIDENTIFIER '=' arg_value
4604 arg_var(formal_argument(get_id($1)));
4605 $$ = assignable($1, $3);
4607 $$ = NEW_OPT_ARG(0, $$);
4609 $$ = rb_assoc_new($$, $3);
4614 f_block_opt : tIDENTIFIER '=' primary_value
4616 arg_var(formal_argument(get_id($1)));
4617 $$ = assignable($1, $3);
4619 $$ = NEW_OPT_ARG(0, $$);
4621 $$ = rb_assoc_new($$, $3);
4626 f_block_optarg : f_block_opt
4631 $$ = rb_ary_new3(1, $1);
4634 | f_block_optarg ',' f_block_opt
4639 while (opts->nd_next) {
4640 opts = opts->nd_next;
4645 $$ = rb_ary_push($1, $3);
4655 $$ = rb_ary_new3(1, $1);
4658 | f_optarg ',' f_opt
4663 while (opts->nd_next) {
4664 opts = opts->nd_next;
4669 $$ = rb_ary_push($1, $3);
4678 f_rest_arg : restarg_mark tIDENTIFIER
4681 if (!is_local_id($2))
4682 yyerror("rest argument must be local variable");
4684 arg_var(shadowing_lvar(get_id($2)));
4688 $$ = dispatch1(rest_param, $2);
4697 $$ = dispatch1(rest_param, Qnil);
4706 f_block_arg : blkarg_mark tIDENTIFIER
4709 if (!is_local_id($2))
4710 yyerror("block argument must be local variable");
4711 else if (!dyna_in_block() && local_id($2))
4712 yyerror("duplicated block argument name");
4714 arg_var(shadowing_lvar(get_id($2)));
4718 $$ = dispatch1(blockarg, $2);
4723 opt_f_block_arg : ',' f_block_arg
4742 if (!$$) $$ = NEW_NIL();
4747 | '(' {lex_state = EXPR_BEG;} expr rparen
4751 yyerror("can't define singleton method for ().");
4754 switch (nd_type($3)) {
4763 yyerror("can't define singleton method for literals");
4771 $$ = dispatch1(paren, $3);
4782 $$ = dispatch1(assoclist_from_args, $1);
4791 $$ = rb_ary_new3(1, $1);
4797 $$ = list_concat($1, $3);
4799 $$ = rb_ary_push($1, $3);
4804 assoc : arg_value tASSOC arg_value
4807 $$ = list_append(NEW_LIST($1), $3);
4809 $$ = dispatch2(assoc_new, $1, $3);
4815 $$ = list_append(NEW_LIST(NEW_LIT(ID2SYM($1))), $2);
4817 $$ = dispatch2(assoc_new, $1, $2);
4822 operation : tIDENTIFIER
4827 operation2 : tIDENTIFIER
4833 operation3 : tIDENTIFIER
4850 opt_terms : /* none */
4861 rbracket : opt_nl ']'
4864 trailer : /* none */
4869 term : ';' {yyerrok;}
4874 | terms ';' {yyerrok;}
4890 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
4892 static int parser_regx_options(struct parser_params*);
4893 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
4894 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
4895 static int parser_parse_string(struct parser_params*,NODE*);
4896 static int parser_here_document(struct parser_params*,NODE*);
4899 # define nextc() parser_nextc(parser)
4900 # define pushback(c) parser_pushback(parser, (c))
4901 # define newtok() parser_newtok(parser)
4902 # define tokspace(n) parser_tokspace(parser, (n))
4903 # define tokadd(c) parser_tokadd(parser, (c))
4904 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
4905 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
4906 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
4907 # define regx_options() parser_regx_options(parser)
4908 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
4909 # define parse_string(n) parser_parse_string(parser,(n))
4910 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
4911 # define here_document(n) parser_here_document(parser,(n))
4912 # define heredoc_identifier() parser_heredoc_identifier(parser)
4913 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
4914 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
4917 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
4918 # define set_yylval_num(x) (yylval.num = (x))
4919 # define set_yylval_id(x) (yylval.id = (x))
4920 # define set_yylval_name(x) (yylval.id = (x))
4921 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
4922 # define set_yylval_node(x) (yylval.node = (x))
4923 # define yylval_id() (yylval.id)
4926 ripper_yylval_id(ID x)
4928 return (VALUE)NEW_LASGN(x, ID2SYM(x));
4930 # define set_yylval_str(x) (void)(x)
4931 # define set_yylval_num(x) (void)(x)
4932 # define set_yylval_id(x) (void)(x)
4933 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
4934 # define set_yylval_literal(x) (void)(x)
4935 # define set_yylval_node(x) (void)(x)
4936 # define yylval_id() yylval.id
4940 #define ripper_flush(p) (void)(p)
4942 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
4944 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
4947 ripper_has_scan_event(struct parser_params *parser)
4950 if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
4951 return lex_p > parser->tokp;
4955 ripper_scan_event_val(struct parser_params *parser, int t)
4957 VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
4958 VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
4959 ripper_flush(parser);
4964 ripper_dispatch_scan_event(struct parser_params *parser, int t)
4966 if (!ripper_has_scan_event(parser)) return;
4967 yylval_rval = ripper_scan_event_val(parser, t);
4971 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
4973 if (!ripper_has_scan_event(parser)) return;
4974 (void)ripper_scan_event_val(parser, t);
4978 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
4980 int saved_line = ruby_sourceline;
4981 const char *saved_tokp = parser->tokp;
4983 ruby_sourceline = parser->delayed_line;
4984 parser->tokp = lex_pbeg + parser->delayed_col;
4985 yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
4986 parser->delayed = Qnil;
4987 ruby_sourceline = saved_line;
4988 parser->tokp = saved_tokp;
4992 #include "ruby/regex.h"
4993 #include "ruby/util.h"
4995 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
4996 since ours (we hope) works properly with all combinations of
4997 machines, compilers, `char' and `unsigned char' argument types.
4998 (Per Bothner suggested the basic approach.) */
4999 #undef SIGN_EXTEND_CHAR
5001 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
5002 #else /* not __STDC__ */
5003 /* As in Harbison and Steele. */
5004 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
5007 #define parser_encoding_name() (parser->enc->name)
5008 #define parser_mbclen() mbclen((lex_p-1),lex_pend,parser->enc)
5009 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,parser->enc)
5010 #define is_identchar(p,e,enc) (rb_enc_isalnum(*(p),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
5011 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,parser->enc))
5013 #define parser_isascii() ISASCII(*(lex_p-1))
5017 token_info_get_column(struct parser_params *parser, const char *token)
5020 const char *p, *pend = lex_p - strlen(token);
5021 for (p = lex_pbeg; p < pend; p++) {
5023 column = (((column - 1) / 8) + 1) * 8;
5031 token_info_has_nonspaces(struct parser_params *parser, const char *token)
5033 const char *p, *pend = lex_p - strlen(token);
5034 for (p = lex_pbeg; p < pend; p++) {
5035 if (*p != ' ' && *p != '\t') {
5042 #undef token_info_push
5044 token_info_push(struct parser_params *parser, const char *token)
5048 if (!parser->parser_token_info_enabled) return;
5049 ptinfo = ALLOC(token_info);
5050 ptinfo->token = token;
5051 ptinfo->linenum = ruby_sourceline;
5052 ptinfo->column = token_info_get_column(parser, token);
5053 ptinfo->nonspc = token_info_has_nonspaces(parser, token);
5054 ptinfo->next = parser->parser_token_info;
5056 parser->parser_token_info = ptinfo;
5059 #undef token_info_pop
5061 token_info_pop(struct parser_params *parser, const char *token)
5064 token_info *ptinfo = parser->parser_token_info;
5066 if (!ptinfo) return;
5067 parser->parser_token_info = ptinfo->next;
5068 if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
5071 linenum = ruby_sourceline;
5072 if (linenum == ptinfo->linenum) { /* SKIP */
5075 if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
5078 if (parser->parser_token_info_enabled) {
5079 rb_compile_warn(ruby_sourcefile, linenum,
5080 "mismatched indentations at '%s' with '%s' at %d",
5081 token, ptinfo->token, ptinfo->linenum);
5090 parser_yyerror(struct parser_params *parser, const char *msg)
5093 const int max_line_margin = 30;
5099 compile_error(PARSER_ARG "%s", msg);
5101 while (lex_pbeg <= p) {
5102 if (*p == '\n') break;
5108 while (pe < lex_pend) {
5109 if (*pe == '\n') break;
5116 const char *pre = "", *post = "";
5118 if (len > max_line_margin * 2 + 10) {
5119 if (lex_p - p > max_line_margin) {
5120 p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
5123 if (pe - lex_p > max_line_margin) {
5124 pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
5129 buf = ALLOCA_N(char, len+2);
5130 MEMCPY(buf, p, char, len);
5132 rb_compile_error_append("%s%s%s", pre, buf, post);
5134 i = (int)(lex_p - p);
5135 p2 = buf; pe = buf + len;
5138 if (*p2 != '\t') *p2 = ' ';
5143 rb_compile_error_append("%s%s", pre, buf);
5146 dispatch1(parse_error, STR_NEW2(msg));
5147 #endif /* !RIPPER */
5151 static void parser_prepare(struct parser_params *parser);
5155 debug_lines(const char *f)
5158 CONST_ID(script_lines, "SCRIPT_LINES__");
5159 if (rb_const_defined_at(rb_cObject, script_lines)) {
5160 VALUE hash = rb_const_get_at(rb_cObject, script_lines);
5161 if (TYPE(hash) == T_HASH) {
5162 VALUE fname = rb_external_str_new_with_enc(f, strlen(f), rb_filesystem_encoding());
5163 VALUE lines = rb_ary_new();
5164 rb_hash_aset(hash, fname, lines);
5172 coverage(const char *f, int n)
5174 VALUE coverages = rb_get_coverages();
5175 if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
5176 VALUE fname = rb_external_str_new_with_enc(f, strlen(f), rb_filesystem_encoding());
5177 VALUE lines = rb_ary_new2(n);
5179 RBASIC(lines)->klass = 0;
5180 for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
5181 RARRAY(lines)->as.heap.len = n;
5182 rb_hash_aset(coverages, fname, lines);
5189 e_option_supplied(struct parser_params *parser)
5191 return strcmp(ruby_sourcefile, "-e") == 0;
5195 yycompile0(VALUE arg, int tracing)
5199 struct parser_params *parser = (struct parser_params *)arg;
5201 if (!compile_for_eval && rb_safe_level() == 0) {
5202 ruby_debug_lines = debug_lines(ruby_sourcefile);
5203 if (ruby_debug_lines && ruby_sourceline > 0) {
5204 VALUE str = STR_NEW0();
5205 n = ruby_sourceline;
5207 rb_ary_push(ruby_debug_lines, str);
5211 if (!e_option_supplied(parser)) {
5212 ruby_coverage = coverage(ruby_sourcefile, ruby_sourceline);
5216 parser_prepare(parser);
5219 parser->parser_token_info_enabled = !compile_for_eval && RTEST(ruby_verbose);
5221 n = yyparse((void*)parser);
5222 ruby_debug_lines = 0;
5224 compile_for_eval = 0;
5227 lex_p = lex_pbeg = lex_pend = 0;
5228 lex_lastline = lex_nextline = 0;
5232 tree = ruby_eval_tree;
5236 else if (ruby_eval_tree_begin) {
5237 tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
5243 yycompile(struct parser_params *parser, const char *f, int line)
5245 ruby_sourcefile = ruby_strdup(f);
5246 ruby_sourceline = line - 1;
5247 return (NODE *)ruby_suppress_tracing(yycompile0, (VALUE)parser, TRUE);
5249 #endif /* !RIPPER */
5251 static rb_encoding *
5252 must_be_ascii_compatible(VALUE s)
5254 rb_encoding *enc = rb_enc_get(s);
5255 if (!rb_enc_asciicompat(enc)) {
5256 rb_raise(rb_eArgError, "invalid source encoding");
5262 lex_get_str(struct parser_params *parser, VALUE s)
5264 char *beg, *end, *pend;
5265 rb_encoding *enc = must_be_ascii_compatible(s);
5267 beg = RSTRING_PTR(s);
5269 if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
5270 beg += lex_gets_ptr;
5272 pend = RSTRING_PTR(s) + RSTRING_LEN(s);
5274 while (end < pend) {
5275 if (*end++ == '\n') break;
5277 lex_gets_ptr = end - RSTRING_PTR(s);
5278 return rb_enc_str_new(beg, end - beg, enc);
5282 lex_getline(struct parser_params *parser)
5284 VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
5285 if (NIL_P(line)) return line;
5286 must_be_ascii_compatible(line);
5288 if (ruby_debug_lines) {
5289 rb_enc_associate(line, parser->enc);
5290 rb_ary_push(ruby_debug_lines, line);
5292 if (ruby_coverage) {
5293 rb_ary_push(ruby_coverage, Qnil);
5300 static rb_data_type_t parser_data_type;
5302 static const rb_data_type_t parser_data_type;
5305 parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
5307 struct parser_params *parser;
5311 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
5312 lex_gets = lex_get_str;
5315 lex_pbeg = lex_p = lex_pend = 0;
5316 compile_for_eval = rb_parse_in_eval();
5318 node = yycompile(parser, f, line);
5319 tmp = vparser; /* prohibit tail call optimization */
5325 rb_compile_string(const char *f, VALUE s, int line)
5327 must_be_ascii_compatible(s);
5328 return parser_compile_string(rb_parser_new(), f, s, line);
5332 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
5334 must_be_ascii_compatible(s);
5335 return parser_compile_string(vparser, f, s, line);
5339 rb_compile_cstr(const char *f, const char *s, int len, int line)
5341 VALUE str = rb_str_new(s, len);
5342 return parser_compile_string(rb_parser_new(), f, str, line);
5346 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
5348 VALUE str = rb_str_new(s, len);
5349 return parser_compile_string(vparser, f, str, line);
5353 lex_io_gets(struct parser_params *parser, VALUE io)
5355 return rb_io_gets(io);
5359 rb_compile_file(const char *f, VALUE file, int start)
5361 VALUE volatile vparser = rb_parser_new();
5363 return rb_parser_compile_file(vparser, f, file, start);
5367 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
5369 struct parser_params *parser;
5373 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
5374 lex_gets = lex_io_gets;
5376 lex_pbeg = lex_p = lex_pend = 0;
5377 compile_for_eval = rb_parse_in_eval();
5379 node = yycompile(parser, f, start);
5380 tmp = vparser; /* prohibit tail call optimization */
5384 #endif /* !RIPPER */
5386 #define STR_FUNC_ESCAPE 0x01
5387 #define STR_FUNC_EXPAND 0x02
5388 #define STR_FUNC_REGEXP 0x04
5389 #define STR_FUNC_QWORDS 0x08
5390 #define STR_FUNC_SYMBOL 0x10
5391 #define STR_FUNC_INDENT 0x20
5395 str_dquote = (STR_FUNC_EXPAND),
5396 str_xquote = (STR_FUNC_EXPAND),
5397 str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
5398 str_sword = (STR_FUNC_QWORDS),
5399 str_dword = (STR_FUNC_QWORDS|STR_FUNC_EXPAND),
5400 str_ssym = (STR_FUNC_SYMBOL),
5401 str_dsym = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
5405 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
5409 str = rb_enc_str_new(p, n, enc);
5410 if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
5411 if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
5413 else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
5414 rb_enc_associate(str, rb_ascii8bit_encoding());
5421 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
5422 #define lex_eol_p() (lex_p >= lex_pend)
5423 #define peek(c) peek_n((c), 0)
5424 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
5427 parser_nextc(struct parser_params *parser)
5431 if (lex_p == lex_pend) {
5432 VALUE v = lex_nextline;
5438 if (!lex_input || NIL_P(v = lex_getline(parser))) {
5439 parser->eofp = Qtrue;
5440 lex_goto_eol(parser);
5446 if (parser->tokp < lex_pend) {
5447 if (NIL_P(parser->delayed)) {
5448 parser->delayed = rb_str_buf_new(1024);
5449 rb_enc_associate(parser->delayed, parser->enc);
5450 rb_str_buf_cat(parser->delayed,
5451 parser->tokp, lex_pend - parser->tokp);
5452 parser->delayed_line = ruby_sourceline;
5453 parser->delayed_col = (int)(parser->tokp - lex_pbeg);
5456 rb_str_buf_cat(parser->delayed,
5457 parser->tokp, lex_pend - parser->tokp);
5461 if (heredoc_end > 0) {
5462 ruby_sourceline = heredoc_end;
5466 parser->line_count++;
5467 lex_pbeg = lex_p = RSTRING_PTR(v);
5468 lex_pend = lex_p + RSTRING_LEN(v);
5469 ripper_flush(parser);
5473 c = (unsigned char)*lex_p++;
5474 if (c == '\r' && peek('\n')) {
5483 parser_pushback(struct parser_params *parser, int c)
5485 if (c == -1) return;
5487 if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
5492 #define was_bol() (lex_p == lex_pbeg + 1)
5494 #define tokfix() (tokenbuf[tokidx]='\0')
5495 #define tok() tokenbuf
5496 #define toklen() tokidx
5497 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
5500 parser_newtok(struct parser_params *parser)
5505 tokenbuf = ALLOC_N(char, 60);
5507 if (toksiz > 4096) {
5509 REALLOC_N(tokenbuf, char, 60);
5515 parser_tokspace(struct parser_params *parser, int n)
5519 if (tokidx >= toksiz) {
5520 do {toksiz *= 2;} while (toksiz < tokidx);
5521 REALLOC_N(tokenbuf, char, toksiz);
5523 return &tokenbuf[tokidx-n];
5527 parser_tokadd(struct parser_params *parser, int c)
5529 tokenbuf[tokidx++] = (char)c;
5530 if (tokidx >= toksiz) {
5532 REALLOC_N(tokenbuf, char, toksiz);
5537 parser_tok_hex(struct parser_params *parser, size_t *numlen)
5541 c = scan_hex(lex_p, 2, numlen);
5543 yyerror("invalid hex escape");
5550 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
5553 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
5554 int string_literal, int symbol_literal, int regexp_literal)
5557 * If string_literal is true, then we allow multiple codepoints
5558 * in \u{}, and add the codepoints to the current token.
5559 * Otherwise we're parsing a character literal and return a single
5560 * codepoint without adding it
5566 if (regexp_literal) { tokadd('\\'); tokadd('u'); }
5568 if (peek('{')) { /* handle \u{...} form */
5570 if (regexp_literal) { tokadd(*lex_p); }
5572 codepoint = scan_hex(lex_p, 6, &numlen);
5574 yyerror("invalid Unicode escape");
5577 if (codepoint > 0x10ffff) {
5578 yyerror("invalid Unicode codepoint (too large)");
5582 if (regexp_literal) {
5583 tokcopy((int)numlen);
5585 else if (codepoint >= 0x80) {
5587 if (string_literal) tokaddmbc(codepoint, *encp);
5589 else if (string_literal) {
5592 } while (string_literal && (peek(' ') || peek('\t')));
5595 yyerror("unterminated Unicode escape");
5599 if (regexp_literal) { tokadd('}'); }
5602 else { /* handle \uxxxx form */
5603 codepoint = scan_hex(lex_p, 4, &numlen);
5605 yyerror("invalid Unicode escape");
5609 if (regexp_literal) {
5612 else if (codepoint >= 0x80) {
5614 if (string_literal) tokaddmbc(codepoint, *encp);
5616 else if (string_literal) {
5624 #define ESCAPE_CONTROL 1
5625 #define ESCAPE_META 2
5628 parser_read_escape(struct parser_params *parser, int flags,
5634 switch (c = nextc()) {
5635 case '\\': /* Backslash */
5638 case 'n': /* newline */
5641 case 't': /* horizontal tab */
5644 case 'r': /* carriage-return */
5647 case 'f': /* form-feed */
5650 case 'v': /* vertical tab */
5653 case 'a': /* alarm(bell) */
5656 case 'e': /* escape */
5659 case '0': case '1': case '2': case '3': /* octal constant */
5660 case '4': case '5': case '6': case '7':
5662 c = scan_oct(lex_p, 3, &numlen);
5666 case 'x': /* hex constant */
5667 c = tok_hex(&numlen);
5668 if (numlen == 0) return 0;
5671 case 'b': /* backspace */
5674 case 's': /* space */
5678 if (flags & ESCAPE_META) goto eof;
5679 if ((c = nextc()) != '-') {
5683 if ((c = nextc()) == '\\') {
5684 if (peek('u')) goto eof;
5685 return read_escape(flags|ESCAPE_META, encp) | 0x80;
5687 else if (c == -1 || !ISASCII(c)) goto eof;
5689 return ((c & 0xff) | 0x80);
5693 if ((c = nextc()) != '-') {
5698 if (flags & ESCAPE_CONTROL) goto eof;
5699 if ((c = nextc())== '\\') {
5700 if (peek('u')) goto eof;
5701 c = read_escape(flags|ESCAPE_CONTROL, encp);
5705 else if (c == -1 || !ISASCII(c)) goto eof;
5710 yyerror("Invalid escape character syntax");
5719 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
5721 int len = rb_enc_codelen(c, enc);
5722 rb_enc_mbcput(c, tokspace(len), enc);
5726 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
5733 switch (c = nextc()) {
5735 return 0; /* just ignore */
5737 case '0': case '1': case '2': case '3': /* octal constant */
5738 case '4': case '5': case '6': case '7':
5740 ruby_scan_oct(--lex_p, 3, &numlen);
5741 if (numlen == 0) goto eof;
5743 tokcopy((int)numlen + 1);
5747 case 'x': /* hex constant */
5750 if (numlen == 0) return -1;
5751 tokcopy((int)numlen + 2);
5756 if (flags & ESCAPE_META) goto eof;
5757 if ((c = nextc()) != '-') {
5762 flags |= ESCAPE_META;
5766 if (flags & ESCAPE_CONTROL) goto eof;
5767 if ((c = nextc()) != '-') {
5775 if (flags & ESCAPE_CONTROL) goto eof;
5777 flags |= ESCAPE_CONTROL;
5779 if ((c = nextc()) == '\\') {
5782 else if (c == -1) goto eof;
5788 yyerror("Invalid escape character syntax");
5799 parser_regx_options(struct parser_params *parser)
5807 while (c = nextc(), ISALPHA(c)) {
5809 options |= RE_OPTION_ONCE;
5811 else if (rb_char_to_option_kcode(c, &opt, &kc)) {
5813 if (kc != rb_ascii8bit_encindex()) kcode = c;
5828 compile_error(PARSER_ARG "unknown regexp option%s - %s",
5829 toklen() > 1 ? "s" : "", tok());
5831 return options | RE_OPTION_ENCODING(kcode);
5835 dispose_string(VALUE str)
5837 /* TODO: should use another API? */
5838 if (RBASIC(str)->flags & RSTRING_NOEMBED)
5839 xfree(RSTRING_PTR(str));
5840 rb_gc_force_recycle(str);
5844 parser_tokadd_mbchar(struct parser_params *parser, int c)
5846 int len = parser_precise_mbclen();
5847 if (!MBCLEN_CHARFOUND_P(len)) {
5848 compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
5853 if (len > 0) tokcopy(len);
5857 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
5860 parser_tokadd_string(struct parser_params *parser,
5861 int func, int term, int paren, long *nest,
5865 int has_nonascii = 0;
5866 rb_encoding *enc = *encp;
5868 static const char mixed_msg[] = "%s mixed within %s source";
5870 #define mixed_error(enc1, enc2) if (!errbuf) { \
5871 size_t len = sizeof(mixed_msg) - 4; \
5872 len += strlen(rb_enc_name(enc1)); \
5873 len += strlen(rb_enc_name(enc2)); \
5874 errbuf = ALLOCA_N(char, len); \
5875 snprintf(errbuf, len, mixed_msg, \
5876 rb_enc_name(enc1), \
5877 rb_enc_name(enc2)); \
5880 #define mixed_escape(beg, enc1, enc2) do { \
5881 const char *pos = lex_p; \
5883 mixed_error((enc1), (enc2)); \
5887 while ((c = nextc()) != -1) {
5888 if (paren && c == paren) {
5891 else if (c == term) {
5892 if (!nest || !*nest) {
5898 else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
5900 if (c2 == '$' || c2 == '@' || c2 == '{') {
5905 else if (c == '\\') {
5906 const char *beg = lex_p - 1;
5910 if (func & STR_FUNC_QWORDS) break;
5911 if (func & STR_FUNC_EXPAND) continue;
5916 if (func & STR_FUNC_ESCAPE) tokadd(c);
5920 if ((func & STR_FUNC_EXPAND) == 0) {
5924 parser_tokadd_utf8(parser, &enc, 1,
5925 func & STR_FUNC_SYMBOL,
5926 func & STR_FUNC_REGEXP);
5927 if (has_nonascii && enc != *encp) {
5928 mixed_escape(beg, enc, *encp);
5933 if (c == -1) return -1;
5935 if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
5938 if (func & STR_FUNC_REGEXP) {
5940 if ((c = tokadd_escape(&enc)) < 0)
5942 if (has_nonascii && enc != *encp) {
5943 mixed_escape(beg, enc, *encp);
5947 else if (func & STR_FUNC_EXPAND) {
5949 if (func & STR_FUNC_ESCAPE) tokadd('\\');
5950 c = read_escape(0, &enc);
5952 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
5953 /* ignore backslashed spaces in %w */
5955 else if (c != term && !(paren && c == paren)) {
5962 else if (!parser_isascii()) {
5966 mixed_error(enc, *encp);
5969 if (tokadd_mbchar(c) == -1) return -1;
5972 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
5979 mixed_error(enc, *encp);
5989 #define NEW_STRTERM(func, term, paren) \
5990 rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
5994 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
5996 if (!NIL_P(parser->delayed)) {
5997 ptrdiff_t len = lex_p - parser->tokp;
5999 rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
6001 ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
6002 parser->tokp = lex_p;
6006 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
6008 #define flush_string_content(enc) ((void)(enc))
6011 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
6012 /* this can be shared with ripper, since it's independent from struct
6015 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
6016 #define SPECIAL_PUNCT(idx) ( \
6017 BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
6018 BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
6019 BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
6020 BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
6021 BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
6023 const unsigned int ruby_global_name_punct_bits[] = {
6029 #undef SPECIAL_PUNCT
6033 is_global_name_punct(const char c)
6035 if (c <= 0x20 || 0x7e < c) return 0;
6036 return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
6040 parser_peek_variable_name(struct parser_params *parser)
6043 const char *p = lex_p;
6045 if (p + 1 >= lex_pend) return 0;
6049 if ((c = *p) == '-') {
6050 if (++p >= lex_pend) return 0;
6053 else if (is_global_name_punct(c) || ISDIGIT(c)) {
6054 return tSTRING_DVAR;
6058 if ((c = *p) == '@') {
6059 if (++p >= lex_pend) return 0;
6065 command_start = TRUE;
6066 return tSTRING_DBEG;
6070 if (!ISASCII(c) || c == '_' || ISALPHA(c))
6071 return tSTRING_DVAR;
6076 parser_parse_string(struct parser_params *parser, NODE *quote)
6078 int func = (int)quote->nd_func;
6079 int term = nd_term(quote);
6080 int paren = nd_paren(quote);
6082 rb_encoding *enc = parser->enc;
6084 if (func == -1) return tSTRING_END;
6086 if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
6087 do {c = nextc();} while (ISSPACE(c));
6090 if (c == term && !quote->nd_nest) {
6091 if (func & STR_FUNC_QWORDS) {
6092 quote->nd_func = -1;
6095 if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
6096 set_yylval_num(regx_options());
6104 if ((func & STR_FUNC_EXPAND) && c == '#') {
6105 int t = parser_peek_variable_name(parser);
6111 if (tokadd_string(func, term, paren, "e->nd_nest,
6113 ruby_sourceline = nd_line(quote);
6114 if (func & STR_FUNC_REGEXP) {
6116 compile_error(PARSER_ARG "unterminated regexp meets end of file");
6121 compile_error(PARSER_ARG "unterminated string meets end of file");
6127 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
6128 flush_string_content(enc);
6130 return tSTRING_CONTENT;
6134 parser_heredoc_identifier(struct parser_params *parser)
6136 int c = nextc(), term, func = 0;
6141 func = STR_FUNC_INDENT;
6145 func |= str_squote; goto quoted;
6147 func |= str_dquote; goto quoted;
6154 while ((c = nextc()) != -1 && c != term) {
6155 if (tokadd_mbchar(c) == -1) return 0;
6158 compile_error(PARSER_ARG "unterminated here document identifier");
6164 if (!parser_is_identchar()) {
6166 if (func & STR_FUNC_INDENT) {
6173 tokadd(func |= str_dquote);
6175 if (tokadd_mbchar(c) == -1) return 0;
6176 } while ((c = nextc()) != -1 && parser_is_identchar());
6183 ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
6185 len = lex_p - lex_pbeg;
6186 lex_goto_eol(parser);
6187 lex_strterm = rb_node_newnode(NODE_HEREDOC,
6188 STR_NEW(tok(), toklen()), /* nd_lit */
6190 lex_lastline); /* nd_orig */
6191 nd_set_line(lex_strterm, ruby_sourceline);
6192 ripper_flush(parser);
6193 return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
6197 parser_heredoc_restore(struct parser_params *parser, NODE *here)
6201 line = here->nd_orig;
6202 lex_lastline = line;
6203 lex_pbeg = RSTRING_PTR(line);
6204 lex_pend = lex_pbeg + RSTRING_LEN(line);
6205 lex_p = lex_pbeg + here->nd_nth;
6206 heredoc_end = ruby_sourceline;
6207 ruby_sourceline = nd_line(here);
6208 dispose_string(here->nd_lit);
6209 rb_gc_force_recycle((VALUE)here);
6210 ripper_flush(parser);
6214 parser_whole_match_p(struct parser_params *parser,
6215 const char *eos, long len, int indent)
6217 const char *p = lex_pbeg;
6221 while (*p && ISSPACE(*p)) p++;
6223 n = lex_pend - (p + len);
6224 if (n < 0 || (n > 0 && p[len] != '\n' && p[len] != '\r')) return FALSE;
6225 return strncmp(eos, p, len) == 0;
6230 ripper_dispatch_heredoc_end(struct parser_params *parser)
6232 if (!NIL_P(parser->delayed))
6233 ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
6234 lex_goto_eol(parser);
6235 ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
6238 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
6240 #define dispatch_heredoc_end() ((void)0)
6244 parser_here_document(struct parser_params *parser, NODE *here)
6246 int c, func, indent = 0;
6247 const char *eos, *p, *pend;
6250 rb_encoding *enc = parser->enc;
6252 eos = RSTRING_PTR(here->nd_lit);
6253 len = RSTRING_LEN(here->nd_lit) - 1;
6254 indent = (func = *eos++) & STR_FUNC_INDENT;
6256 if ((c = nextc()) == -1) {
6258 compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
6260 if (NIL_P(parser->delayed)) {
6261 ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
6265 ((len = lex_p - parser->tokp) > 0 &&
6266 (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
6267 rb_str_append(parser->delayed, str);
6269 ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
6271 lex_goto_eol(parser);
6274 heredoc_restore(lex_strterm);
6278 if (was_bol() && whole_match_p(eos, len, indent)) {
6279 dispatch_heredoc_end();
6280 heredoc_restore(lex_strterm);
6284 if (!(func & STR_FUNC_EXPAND)) {
6286 p = RSTRING_PTR(lex_lastline);
6291 if (--pend == p || pend[-1] != '\r') {
6300 rb_str_cat(str, p, pend - p);
6302 str = STR_NEW(p, pend - p);
6303 if (pend < lex_pend) rb_str_cat(str, "\n", 1);
6304 lex_goto_eol(parser);
6305 if (nextc() == -1) {
6306 if (str) dispose_string(str);
6309 } while (!whole_match_p(eos, len, indent));
6312 /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
6315 int t = parser_peek_variable_name(parser);
6322 if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
6323 if (parser->eofp) goto error;
6327 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
6328 flush_string_content(enc);
6329 return tSTRING_CONTENT;
6332 /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
6333 if ((c = nextc()) == -1) goto error;
6334 } while (!whole_match_p(eos, len, indent));
6335 str = STR_NEW3(tok(), toklen(), enc, func);
6337 dispatch_heredoc_end();
6338 heredoc_restore(lex_strterm);
6339 lex_strterm = NEW_STRTERM(-1, 0, 0);
6340 set_yylval_str(str);
6341 return tSTRING_CONTENT;
6347 arg_ambiguous_gen(struct parser_params *parser)
6350 rb_warning0("ambiguous first argument; put parentheses or even spaces");
6352 dispatch0(arg_ambiguous);
6355 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
6358 formal_argument_gen(struct parser_params *parser, ID lhs)
6361 if (!is_local_id(lhs))
6362 yyerror("formal argument must be local variable");
6364 shadowing_lvar(lhs);
6369 lvar_defined_gen(struct parser_params *parser, ID id)
6371 return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
6374 /* emacsen -*- hack */
6376 parser_encode_length(struct parser_params *parser, const char *name, long len)
6380 if (len > 5 && name[nlen = len - 5] == '-') {
6381 if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
6384 if (len > 4 && name[nlen = len - 4] == '-') {
6385 if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
6387 if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
6388 !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
6389 /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
6396 parser_set_encode(struct parser_params *parser, const char *name)
6398 int idx = rb_enc_find_index(name);
6403 excargs[1] = rb_sprintf("unknown encoding name: %s", name);
6405 excargs[0] = rb_eArgError;
6406 excargs[2] = rb_make_backtrace();
6407 rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
6408 rb_exc_raise(rb_make_exception(3, excargs));
6410 enc = rb_enc_from_index(idx);
6411 if (!rb_enc_asciicompat(enc)) {
6412 excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
6417 if (ruby_debug_lines) {
6418 long i, n = RARRAY_LEN(ruby_debug_lines);
6419 const VALUE *p = RARRAY_PTR(ruby_debug_lines);
6420 for (i = 0; i < n; ++i) {
6421 rb_enc_associate_index(*p, idx);
6428 comment_at_top(struct parser_params *parser)
6430 const char *p = lex_pbeg, *pend = lex_p - 1;
6431 if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
6433 if (!ISSPACE(*p)) return 0;
6440 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
6441 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
6444 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
6446 if (!comment_at_top(parser)) {
6449 parser_set_encode(parser, val);
6453 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
6455 int *p = &parser->parser_token_info_enabled;
6459 if (strcasecmp(val, "true") == 0) {
6465 if (strcasecmp(val, "false") == 0) {
6471 rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
6474 struct magic_comment {
6476 rb_magic_comment_setter_t func;
6477 rb_magic_comment_length_t length;
6480 static const struct magic_comment magic_comments[] = {
6481 {"coding", magic_comment_encoding, parser_encode_length},
6482 {"encoding", magic_comment_encoding, parser_encode_length},
6483 {"warn_indent", parser_set_token_info},
6488 magic_comment_marker(const char *str, long len)
6495 if (str[i-1] == '*' && str[i-2] == '-') {
6501 if (i + 1 >= len) return 0;
6502 if (str[i+1] != '-') {
6505 else if (str[i-1] != '-') {
6521 parser_magic_comment(struct parser_params *parser, const char *str, long len)
6523 VALUE name = 0, val = 0;
6524 const char *beg, *end, *vbeg, *vend;
6525 #define str_copy(_s, _p, _n) ((_s) \
6526 ? (void)(rb_str_resize((_s), (_n)), \
6527 MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
6528 : (void)((_s) = STR_NEW((_p), (_n))))
6530 if (len <= 7) return FALSE;
6531 if (!(beg = magic_comment_marker(str, len))) return FALSE;
6532 if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
6534 len = end - beg - 3;
6536 /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
6539 const struct magic_comment *p = magic_comments;
6545 for (; len > 0 && *str; str++, --len) {
6547 case '\'': case '"': case ':': case ';':
6550 if (!ISSPACE(*str)) break;
6552 for (beg = str; len > 0; str++, --len) {
6554 case '\'': case '"': case ':': case ';':
6557 if (ISSPACE(*str)) break;
6562 for (end = str; len > 0 && ISSPACE(*str); str++, --len);
6564 if (*str != ':') continue;
6566 do str++; while (--len > 0 && ISSPACE(*str));
6569 for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
6582 for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
6585 while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
6588 str_copy(name, beg, n);
6589 s = RSTRING_PTR(name);
6590 for (i = 0; i < n; ++i) {
6591 if (s[i] == '-') s[i] = '_';
6595 if (STRNCASECMP(p->name, s, n) == 0) {
6598 n = (*p->length)(parser, vbeg, n);
6600 str_copy(val, vbeg, n);
6601 (*p->func)(parser, s, RSTRING_PTR(val));
6604 } while (++p < magic_comments + numberof(magic_comments));
6606 str_copy(val, vbeg, vend - vbeg);
6607 dispatch2(magic_comment, name, val);
6615 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
6618 const char *beg = str;
6622 if (send - str <= 6) return;
6624 case 'C': case 'c': str += 6; continue;
6625 case 'O': case 'o': str += 5; continue;
6626 case 'D': case 'd': str += 4; continue;
6627 case 'I': case 'i': str += 3; continue;
6628 case 'N': case 'n': str += 2; continue;
6629 case 'G': case 'g': str += 1; continue;
6636 if (ISSPACE(*str)) break;
6639 if (STRNCASECMP(str-6, "coding", 6) == 0) break;
6643 if (++str >= send) return;
6644 } while (ISSPACE(*str));
6646 if (*str != '=' && *str != ':') return;
6651 while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
6652 s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
6653 parser_set_encode(parser, RSTRING_PTR(s));
6654 rb_str_resize(s, 0);
6658 parser_prepare(struct parser_params *parser)
6663 if (peek('!')) parser->has_shebang = 1;
6665 case 0xef: /* UTF-8 BOM marker */
6666 if (lex_pend - lex_p >= 2 &&
6667 (unsigned char)lex_p[0] == 0xbb &&
6668 (unsigned char)lex_p[1] == 0xbf) {
6669 parser->enc = rb_utf8_encoding();
6679 parser->enc = rb_enc_get(lex_lastline);
6682 #define IS_ARG() (lex_state == EXPR_ARG || lex_state == EXPR_CMDARG)
6683 #define IS_END() (lex_state == EXPR_END || lex_state == EXPR_ENDARG || lex_state == EXPR_ENDFN)
6684 #define IS_BEG() (lex_state == EXPR_BEG || lex_state == EXPR_MID || lex_state == EXPR_VALUE || lex_state == EXPR_CLASS)
6685 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
6686 #define IS_LABEL_POSSIBLE() ((lex_state == EXPR_BEG && !cmd_state) || IS_ARG())
6687 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
6690 #define ambiguous_operator(op, syn) ( \
6691 rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
6692 rb_warning0("even though it seems like "syn""))
6694 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
6696 #define warn_balanced(op, syn) ((void) \
6697 (last_state != EXPR_CLASS && last_state != EXPR_DOT && \
6698 last_state != EXPR_FNAME && last_state != EXPR_ENDFN && \
6699 last_state != EXPR_ENDARG && \
6700 space_seen && !ISSPACE(c) && \
6701 (ambiguous_operator(op, syn), 0)))
6704 parser_yylex(struct parser_params *parser)
6709 enum lex_state_e last_state;
6713 int fallthru = FALSE;
6718 if (nd_type(lex_strterm) == NODE_HEREDOC) {
6719 token = here_document(lex_strterm);
6720 if (token == tSTRING_END) {
6722 lex_state = EXPR_END;
6726 token = parse_string(lex_strterm);
6727 if (token == tSTRING_END || token == tREGEXP_END) {
6728 rb_gc_force_recycle((VALUE)lex_strterm);
6730 lex_state = EXPR_END;
6735 cmd_state = command_start;
6736 command_start = FALSE;
6738 last_state = lex_state;
6739 switch (c = nextc()) {
6740 case '\0': /* NUL */
6741 case '\004': /* ^D */
6742 case '\032': /* ^Z */
6743 case -1: /* end of script. */
6747 case ' ': case '\t': case '\f': case '\r':
6748 case '\13': /* '\v' */
6751 while ((c = nextc())) {
6753 case ' ': case '\t': case '\f': case '\r':
6754 case '\13': /* '\v' */
6762 ripper_dispatch_scan_event(parser, tSP);
6766 case '#': /* it's a comment */
6767 /* no magic_comment in shebang line */
6768 if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
6769 if (comment_at_top(parser)) {
6770 set_file_encoding(parser, lex_p, lex_pend);
6775 ripper_dispatch_scan_event(parser, tCOMMENT);
6780 switch (lex_state) {
6788 ripper_dispatch_scan_event(parser, tIGNORED_NL);
6796 while ((c = nextc())) {
6798 case ' ': case '\t': case '\f': case '\r':
6799 case '\13': /* '\v' */
6803 if ((c = nextc()) != '.') {
6811 lex_nextline = lex_lastline;
6812 case -1: /* EOF no decrement*/
6813 lex_goto_eol(parser);
6816 parser->tokp = lex_p;
6819 goto normal_newline;
6823 command_start = TRUE;
6824 lex_state = EXPR_BEG;
6828 if ((c = nextc()) == '*') {
6829 if ((c = nextc()) == '=') {
6830 set_yylval_id(tPOW);
6831 lex_state = EXPR_BEG;
6840 lex_state = EXPR_BEG;
6845 rb_warning0("`*' interpreted as argument prefix");
6848 else if (IS_BEG()) {
6852 warn_balanced("*", "argument prefix");
6856 switch (lex_state) {
6857 case EXPR_FNAME: case EXPR_DOT:
6858 lex_state = EXPR_ARG; break;
6860 lex_state = EXPR_BEG; break;
6866 if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
6867 lex_state = EXPR_ARG;
6873 lex_state = EXPR_BEG;
6886 /* skip embedded rd document */
6887 if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
6891 lex_goto_eol(parser);
6892 ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
6895 lex_goto_eol(parser);
6898 ripper_dispatch_scan_event(parser, tEMBDOC);
6904 compile_error(PARSER_ARG "embedded document meets end of file");
6907 if (c != '=') continue;
6908 if (strncmp(lex_p, "end", 3) == 0 &&
6909 (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
6913 lex_goto_eol(parser);
6915 ripper_dispatch_scan_event(parser, tEMBDOC_END);
6921 switch (lex_state) {
6922 case EXPR_FNAME: case EXPR_DOT:
6923 lex_state = EXPR_ARG; break;
6925 lex_state = EXPR_BEG; break;
6927 if ((c = nextc()) == '=') {
6928 if ((c = nextc()) == '=') {
6937 else if (c == '>') {
6944 last_state = lex_state;
6947 lex_state != EXPR_DOT &&
6948 lex_state != EXPR_CLASS &&
6950 (!IS_ARG() || space_seen)) {
6951 int token = heredoc_identifier();
6952 if (token) return token;
6954 switch (lex_state) {
6955 case EXPR_FNAME: case EXPR_DOT:
6956 lex_state = EXPR_ARG; break;
6958 lex_state = EXPR_BEG; break;
6961 if ((c = nextc()) == '>') {
6968 if ((c = nextc()) == '=') {
6969 set_yylval_id(tLSHFT);
6970 lex_state = EXPR_BEG;
6974 warn_balanced("<<", "here document");
6981 switch (lex_state) {
6982 case EXPR_FNAME: case EXPR_DOT:
6983 lex_state = EXPR_ARG; break;
6985 lex_state = EXPR_BEG; break;
6987 if ((c = nextc()) == '=') {
6991 if ((c = nextc()) == '=') {
6992 set_yylval_id(tRSHFT);
6993 lex_state = EXPR_BEG;
7003 lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
7007 if (lex_state == EXPR_FNAME) {
7008 lex_state = EXPR_ENDFN;
7011 if (lex_state == EXPR_DOT) {
7013 lex_state = EXPR_CMDARG;
7015 lex_state = EXPR_ARG;
7018 lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
7019 return tXSTRING_BEG;
7022 lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
7027 lex_state = EXPR_VALUE;
7032 compile_error(PARSER_ARG "incomplete character syntax");
7035 if (rb_enc_isspace(c, parser->enc)) {
7059 rb_warnI("invalid character syntax; use ?\\%c", c2);
7064 lex_state = EXPR_VALUE;
7069 if (!parser_isascii()) {
7070 if (tokadd_mbchar(c) == -1) return 0;
7072 else if ((rb_enc_isalnum(c, parser->enc) || c == '_') &&
7073 lex_p < lex_pend && is_identchar(lex_p, lex_pend, parser->enc)) {
7076 else if (c == '\\') {
7079 c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
7087 else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
7089 if (tokadd_mbchar(c) == -1) return 0;
7092 c = read_escape(0, &enc);
7100 set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
7101 lex_state = EXPR_END;
7105 if ((c = nextc()) == '&') {
7106 lex_state = EXPR_BEG;
7107 if ((c = nextc()) == '=') {
7108 set_yylval_id(tANDOP);
7109 lex_state = EXPR_BEG;
7115 else if (c == '=') {
7117 lex_state = EXPR_BEG;
7122 rb_warning0("`&' interpreted as argument prefix");
7125 else if (IS_BEG()) {
7129 warn_balanced("&", "argument prefix");
7132 switch (lex_state) {
7133 case EXPR_FNAME: case EXPR_DOT:
7134 lex_state = EXPR_ARG; break;
7136 lex_state = EXPR_BEG;
7141 if ((c = nextc()) == '|') {
7142 lex_state = EXPR_BEG;
7143 if ((c = nextc()) == '=') {
7144 set_yylval_id(tOROP);
7145 lex_state = EXPR_BEG;
7153 lex_state = EXPR_BEG;
7156 if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
7157 lex_state = EXPR_ARG;
7160 lex_state = EXPR_BEG;
7167 if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
7168 lex_state = EXPR_ARG;
7177 lex_state = EXPR_BEG;
7180 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
7181 lex_state = EXPR_BEG;
7183 if (c != -1 && ISDIGIT(c)) {
7189 lex_state = EXPR_BEG;
7191 warn_balanced("+", "unary operator");
7196 if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
7197 lex_state = EXPR_ARG;
7206 lex_state = EXPR_BEG;
7210 lex_state = EXPR_ARG;
7213 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
7214 lex_state = EXPR_BEG;
7216 if (c != -1 && ISDIGIT(c)) {
7221 lex_state = EXPR_BEG;
7223 warn_balanced("-", "unary operator");
7227 lex_state = EXPR_BEG;
7228 if ((c = nextc()) == '.') {
7229 if ((c = nextc()) == '.') {
7236 if (c != -1 && ISDIGIT(c)) {
7237 yyerror("no .<digit> floating literal anymore; put 0 before dot");
7239 lex_state = EXPR_DOT;
7243 case '0': case '1': case '2': case '3': case '4':
7244 case '5': case '6': case '7': case '8': case '9':
7246 int is_float, seen_point, seen_e, nondigit;
7248 is_float = seen_point = seen_e = nondigit = 0;
7249 lex_state = EXPR_END;
7251 if (c == '-' || c == '+') {
7256 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
7257 int start = toklen();
7259 if (c == 'x' || c == 'X') {
7262 if (c != -1 && ISXDIGIT(c)) {
7265 if (nondigit) break;
7269 if (!ISXDIGIT(c)) break;
7272 } while ((c = nextc()) != -1);
7276 if (toklen() == start) {
7279 else if (nondigit) goto trailing_uc;
7280 set_yylval_literal(rb_cstr_to_inum(tok(), 16, FALSE));
7283 if (c == 'b' || c == 'B') {
7286 if (c == '0' || c == '1') {
7289 if (nondigit) break;
7293 if (c != '0' && c != '1') break;
7296 } while ((c = nextc()) != -1);
7300 if (toklen() == start) {
7303 else if (nondigit) goto trailing_uc;
7304 set_yylval_literal(rb_cstr_to_inum(tok(), 2, FALSE));
7307 if (c == 'd' || c == 'D') {
7310 if (c != -1 && ISDIGIT(c)) {
7313 if (nondigit) break;
7317 if (!ISDIGIT(c)) break;
7320 } while ((c = nextc()) != -1);
7324 if (toklen() == start) {
7327 else if (nondigit) goto trailing_uc;
7328 set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
7335 if (c == 'o' || c == 'O') {
7336 /* prefixed octal */
7338 if (c == -1 || c == '_' || !ISDIGIT(c)) {
7342 if (c >= '0' && c <= '7') {
7347 if (nondigit) break;
7351 if (c < '0' || c > '9') break;
7352 if (c > '7') goto invalid_octal;
7355 } while ((c = nextc()) != -1);
7356 if (toklen() > start) {
7359 if (nondigit) goto trailing_uc;
7360 set_yylval_literal(rb_cstr_to_inum(tok(), 8, FALSE));
7368 if (c > '7' && c <= '9') {
7370 yyerror("Invalid octal digit");
7372 else if (c == '.' || c == 'e' || c == 'E') {
7377 set_yylval_literal(INT2FIX(0));
7384 case '0': case '1': case '2': case '3': case '4':
7385 case '5': case '6': case '7': case '8': case '9':
7391 if (nondigit) goto trailing_uc;
7392 if (seen_point || seen_e) {
7397 if (c0 == -1 || !ISDIGIT(c0)) {
7425 if (c != '-' && c != '+') continue;
7430 case '_': /* `_' in number just ignored */
7431 if (nondigit) goto decode_num;
7446 snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
7451 double d = strtod(tok(), 0);
7452 if (errno == ERANGE) {
7453 rb_warningS("Float %s out of range", tok());
7456 set_yylval_literal(DBL2NUM(d));
7459 set_yylval_literal(rb_cstr_to_inum(tok(), 10, FALSE));
7470 lex_state = EXPR_ENDFN;
7472 lex_state = EXPR_ENDARG;
7478 if (IS_BEG() || lex_state == EXPR_CLASS || IS_SPCARG(-1)) {
7479 lex_state = EXPR_BEG;
7482 lex_state = EXPR_DOT;
7485 if (IS_END() || ISSPACE(c)) {
7487 warn_balanced(":", "symbol literal");
7488 lex_state = EXPR_BEG;
7493 lex_strterm = NEW_STRTERM(str_ssym, c, 0);
7496 lex_strterm = NEW_STRTERM(str_dsym, c, 0);
7502 lex_state = EXPR_FNAME;
7507 lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
7510 if ((c = nextc()) == '=') {
7512 lex_state = EXPR_BEG;
7517 (void)arg_ambiguous();
7518 lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
7521 switch (lex_state) {
7522 case EXPR_FNAME: case EXPR_DOT:
7523 lex_state = EXPR_ARG; break;
7525 lex_state = EXPR_BEG; break;
7527 warn_balanced("/", "regexp literal");
7531 if ((c = nextc()) == '=') {
7533 lex_state = EXPR_BEG;
7536 switch (lex_state) {
7537 case EXPR_FNAME: case EXPR_DOT:
7538 lex_state = EXPR_ARG; break;
7540 lex_state = EXPR_BEG; break;
7546 lex_state = EXPR_BEG;
7547 command_start = TRUE;
7551 lex_state = EXPR_BEG;
7555 if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
7556 if ((c = nextc()) != '@') {
7559 lex_state = EXPR_ARG;
7562 lex_state = EXPR_BEG;
7570 else if (IS_SPCARG(-1)) {
7576 lex_state = EXPR_BEG;
7581 if (lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
7582 lex_state = EXPR_ARG;
7583 if ((c = nextc()) == ']') {
7584 if ((c = nextc()) == '=') {
7593 else if (IS_BEG()) {
7596 else if (IS_ARG() && space_seen) {
7599 lex_state = EXPR_BEG;
7605 if (lpar_beg && lpar_beg == paren_nest) {
7606 lex_state = EXPR_BEG;
7613 if (IS_ARG() || lex_state == EXPR_END || lex_state == EXPR_ENDFN)
7614 c = '{'; /* block (primary) */
7615 else if (lex_state == EXPR_ENDARG)
7616 c = tLBRACE_ARG; /* block (expr) */
7618 c = tLBRACE; /* hash */
7621 lex_state = EXPR_BEG;
7622 if (c != tLBRACE) command_start = TRUE;
7630 ripper_dispatch_scan_event(parser, tSP);
7632 goto retry; /* skip \\n */
7644 if (c == -1 || !ISALNUM(c)) {
7650 if (rb_enc_isalnum(term, parser->enc) || !parser_isascii()) {
7651 yyerror("unknown type of %string");
7655 if (c == -1 || term == -1) {
7656 compile_error(PARSER_ARG "unterminated quoted string meets end of file");
7660 if (term == '(') term = ')';
7661 else if (term == '[') term = ']';
7662 else if (term == '{') term = '}';
7663 else if (term == '<') term = '>';
7668 lex_strterm = NEW_STRTERM(str_dquote, term, paren);
7672 lex_strterm = NEW_STRTERM(str_squote, term, paren);
7676 lex_strterm = NEW_STRTERM(str_dword, term, paren);
7677 do {c = nextc();} while (ISSPACE(c));
7682 lex_strterm = NEW_STRTERM(str_sword, term, paren);
7683 do {c = nextc();} while (ISSPACE(c));
7688 lex_strterm = NEW_STRTERM(str_xquote, term, paren);
7689 return tXSTRING_BEG;
7692 lex_strterm = NEW_STRTERM(str_regexp, term, paren);
7696 lex_strterm = NEW_STRTERM(str_ssym, term, paren);
7697 lex_state = EXPR_FNAME;
7701 yyerror("unknown type of %string");
7705 if ((c = nextc()) == '=') {
7707 lex_state = EXPR_BEG;
7713 switch (lex_state) {
7714 case EXPR_FNAME: case EXPR_DOT:
7715 lex_state = EXPR_ARG; break;
7717 lex_state = EXPR_BEG; break;
7720 warn_balanced("%%", "string literal");
7724 lex_state = EXPR_END;
7728 case '_': /* $_: last read line string */
7730 if (parser_is_identchar()) {
7738 case '~': /* $~: match-data */
7739 case '*': /* $*: argv */
7740 case '$': /* $$: pid */
7741 case '?': /* $?: last status */
7742 case '!': /* $!: error string */
7743 case '@': /* $@: error position */
7744 case '/': /* $/: input record separator */
7745 case '\\': /* $\: output record separator */
7746 case ';': /* $;: field separator */
7747 case ',': /* $,: output field separator */
7748 case '.': /* $.: last read line number */
7749 case '=': /* $=: ignorecase */
7750 case ':': /* $:: load path */
7751 case '<': /* $<: reading filename */
7752 case '>': /* $>: default output handle */
7753 case '\"': /* $": already loaded files */
7757 set_yylval_name(rb_intern(tok()));
7764 if (parser_is_identchar()) {
7765 if (tokadd_mbchar(c) == -1) return 0;
7772 set_yylval_name(rb_intern(tok()));
7775 case '&': /* $&: last match */
7776 case '`': /* $`: string before last match */
7777 case '\'': /* $': string after last match */
7778 case '+': /* $+: string matches last paren. */
7779 if (last_state == EXPR_FNAME) {
7784 set_yylval_node(NEW_BACK_REF(c));
7787 case '1': case '2': case '3':
7788 case '4': case '5': case '6':
7789 case '7': case '8': case '9':
7794 } while (c != -1 && ISDIGIT(c));
7796 if (last_state == EXPR_FNAME) goto gvar;
7798 set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
7802 if (!parser_is_identchar()) {
7804 compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
7820 if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
7823 compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
7826 compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
7833 if (was_bol() && whole_match_p("__END__", 7, 0)) {
7834 ruby__end__seen = 1;
7835 parser->eofp = Qtrue;
7839 lex_goto_eol(parser);
7840 ripper_dispatch_scan_event(parser, k__END__);
7848 if (!parser_is_identchar()) {
7849 rb_compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
7857 mb = ENC_CODERANGE_7BIT;
7859 if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
7860 if (tokadd_mbchar(c) == -1) return 0;
7862 } while (parser_is_identchar());
7868 if ((c == '!' || c == '?') && !peek('=')) {
7880 last_state = lex_state;
7883 lex_state = EXPR_END;
7887 lex_state = EXPR_END;
7888 if (tok()[1] == '@')
7895 if (toklast() == '!' || toklast() == '?') {
7899 if (lex_state == EXPR_FNAME) {
7900 if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
7901 (!peek('=') || (peek_n('>', 1)))) {
7902 result = tIDENTIFIER;
7910 if (result == 0 && ISUPPER(tok()[0])) {
7914 result = tIDENTIFIER;
7918 if (IS_LABEL_POSSIBLE()) {
7919 if (IS_LABEL_SUFFIX(0)) {
7920 lex_state = EXPR_BEG;
7922 set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb)));
7926 if (mb == ENC_CODERANGE_7BIT && lex_state != EXPR_DOT) {
7927 const struct kwtable *kw;
7929 /* See if it is a reserved word. */
7930 kw = rb_reserved_word(tok(), toklen());
7932 enum lex_state_e state = lex_state;
7933 lex_state = kw->state;
7934 if (state == EXPR_FNAME) {
7935 set_yylval_name(rb_intern(kw->name));
7938 if (kw->id[0] == keyword_do) {
7939 command_start = TRUE;
7940 if (lpar_beg && lpar_beg == paren_nest) {
7943 return keyword_do_LAMBDA;
7945 if (COND_P()) return keyword_do_cond;
7946 if (CMDARG_P() && state != EXPR_CMDARG)
7947 return keyword_do_block;
7948 if (state == EXPR_ENDARG || state == EXPR_BEG)
7949 return keyword_do_block;
7952 if (state == EXPR_BEG || state == EXPR_VALUE)
7955 if (kw->id[0] != kw->id[1])
7956 lex_state = EXPR_BEG;
7963 lex_state == EXPR_DOT ||
7966 lex_state = EXPR_CMDARG;
7969 lex_state = EXPR_ARG;
7972 else if (lex_state == EXPR_FNAME) {
7973 lex_state = EXPR_ENDFN;
7976 lex_state = EXPR_END;
7980 ID ident = TOK_INTERN(!ENC_SINGLE(mb));
7982 set_yylval_name(ident);
7983 if (last_state != EXPR_DOT && last_state != EXPR_FNAME &&
7984 is_local_id(ident) && lvar_defined(ident)) {
7985 lex_state = EXPR_END;
7994 yylex(void *lval, void *p)
7999 struct parser_params *parser = (struct parser_params*)p;
8003 parser->parser_yylval = lval;
8004 parser->parser_yylval->val = Qundef;
8006 t = parser_yylex(parser);
8008 if (!NIL_P(parser->delayed)) {
8009 ripper_dispatch_delayed_token(parser, t);
8013 ripper_dispatch_scan_event(parser, t);
8021 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
8023 NODE *n = (rb_node_newnode)(type, a0, a1, a2);
8024 nd_set_line(n, ruby_sourceline);
8029 nodetype(NODE *node) /* for debug */
8031 return (enum node_type)nd_type(node);
8035 nodeline(NODE *node)
8037 return nd_line(node);
8041 newline_node(NODE *node)
8044 node = remove_begin(node);
8045 node->flags |= NODE_FL_NEWLINE;
8051 fixpos(NODE *node, NODE *orig)
8055 if (orig == (NODE*)1) return;
8056 nd_set_line(node, nd_line(orig));
8060 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
8062 rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
8064 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
8067 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
8069 rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
8071 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
8074 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
8076 NODE *end, *h = head, *nd;
8078 if (tail == 0) return head;
8080 if (h == 0) return tail;
8081 switch (nd_type(h)) {
8088 parser_warning(h, "unused literal ignored");
8091 h = end = NEW_BLOCK(head);
8102 switch (nd_type(nd)) {
8108 if (RTEST(ruby_verbose)) {
8109 parser_warning(nd, "statement not reached");
8117 if (nd_type(tail) != NODE_BLOCK) {
8118 tail = NEW_BLOCK(tail);
8119 tail->nd_end = tail;
8121 end->nd_next = tail;
8122 h->nd_end = tail->nd_end;
8126 /* append item to the list */
8128 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
8132 if (list == 0) return NEW_LIST(item);
8133 if (list->nd_next) {
8134 last = list->nd_next->nd_end;
8141 last->nd_next = NEW_LIST(item);
8142 list->nd_next->nd_end = last->nd_next;
8146 /* concat two lists */
8148 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
8152 if (head->nd_next) {
8153 last = head->nd_next->nd_end;
8159 head->nd_alen += tail->nd_alen;
8160 last->nd_next = tail;
8161 if (tail->nd_next) {
8162 head->nd_next->nd_end = tail->nd_next->nd_end;
8165 head->nd_next->nd_end = tail;
8172 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
8174 if (NIL_P(tail)) return 1;
8175 if (!rb_enc_compatible(head, tail)) {
8176 compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
8177 rb_enc_name(rb_enc_get(head)),
8178 rb_enc_name(rb_enc_get(tail)));
8179 rb_str_resize(head, 0);
8180 rb_str_resize(tail, 0);
8183 rb_str_buf_append(head, tail);
8187 /* concat two string literals */
8189 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
8191 enum node_type htype;
8193 if (!head) return tail;
8194 if (!tail) return head;
8196 htype = nd_type(head);
8197 if (htype == NODE_EVSTR) {
8198 NODE *node = NEW_DSTR(Qnil);
8199 head = list_append(node, head);
8201 switch (nd_type(tail)) {
8203 if (htype == NODE_STR) {
8204 if (!literal_concat0(parser, head->nd_lit, tail->nd_lit)) {
8206 rb_gc_force_recycle((VALUE)head);
8207 rb_gc_force_recycle((VALUE)tail);
8210 rb_gc_force_recycle((VALUE)tail);
8213 list_append(head, tail);
8218 if (htype == NODE_STR) {
8219 if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
8221 tail->nd_lit = head->nd_lit;
8222 rb_gc_force_recycle((VALUE)head);
8225 else if (NIL_P(tail->nd_lit)) {
8226 head->nd_alen += tail->nd_alen - 1;
8227 head->nd_next->nd_end->nd_next = tail->nd_next;
8228 head->nd_next->nd_end = tail->nd_next->nd_end;
8229 rb_gc_force_recycle((VALUE)tail);
8232 nd_set_type(tail, NODE_ARRAY);
8233 tail->nd_head = NEW_STR(tail->nd_lit);
8234 list_concat(head, tail);
8239 if (htype == NODE_STR) {
8240 nd_set_type(head, NODE_DSTR);
8243 list_append(head, tail);
8250 evstr2dstr_gen(struct parser_params *parser, NODE *node)
8252 if (nd_type(node) == NODE_EVSTR) {
8253 node = list_append(NEW_DSTR(Qnil), node);
8259 new_evstr_gen(struct parser_params *parser, NODE *node)
8264 switch (nd_type(node)) {
8265 case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
8269 return NEW_EVSTR(head);
8273 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
8277 return NEW_CALL(recv, id, NEW_LIST(arg1));
8281 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
8284 return NEW_CALL(recv, id, 0);
8288 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
8293 switch (nd_type(node1)) {
8295 case NODE_DREGX_ONCE:
8296 return NEW_MATCH2(node1, node2);
8299 if (TYPE(node1->nd_lit) == T_REGEXP) {
8300 return NEW_MATCH2(node1, node2);
8306 switch (nd_type(node2)) {
8308 case NODE_DREGX_ONCE:
8309 return NEW_MATCH3(node2, node1);
8312 if (TYPE(node2->nd_lit) == T_REGEXP) {
8313 return NEW_MATCH3(node2, node1);
8318 return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
8322 gettable_gen(struct parser_params *parser, ID id)
8324 if (id == keyword_self) {
8327 else if (id == keyword_nil) {
8330 else if (id == keyword_true) {
8333 else if (id == keyword_false) {
8336 else if (id == keyword__FILE__) {
8337 return NEW_STR(rb_external_str_new_with_enc(ruby_sourcefile, strlen(ruby_sourcefile),
8338 rb_filesystem_encoding()));
8340 else if (id == keyword__LINE__) {
8341 return NEW_LIT(INT2FIX(ruby_sourceline));
8343 else if (id == keyword__ENCODING__) {
8344 return NEW_LIT(rb_enc_from_encoding(parser->enc));
8346 else if (is_local_id(id)) {
8347 if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
8348 if (local_id(id)) return NEW_LVAR(id);
8349 /* method call without arguments */
8350 return NEW_VCALL(id);
8352 else if (is_global_id(id)) {
8353 return NEW_GVAR(id);
8355 else if (is_instance_id(id)) {
8356 return NEW_IVAR(id);
8358 else if (is_const_id(id)) {
8359 return NEW_CONST(id);
8361 else if (is_class_id(id)) {
8362 return NEW_CVAR(id);
8364 compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
8369 id_is_var_gen(struct parser_params *parser, ID id)
8371 if (is_notop_id(id)) {
8372 switch (id & ID_SCOPE_MASK) {
8373 case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
8376 if (dyna_in_block() && dvar_defined(id)) return 1;
8377 if (local_id(id)) return 1;
8378 /* method call without arguments */
8382 compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
8385 #endif /* !RIPPER */
8389 assignable_gen(struct parser_params *parser, VALUE lhs)
8392 assignable_gen(struct parser_params *parser, ID id, NODE *val)
8396 ID id = get_id(lhs);
8397 # define assignable_result(x) get_value(lhs)
8398 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
8400 # define assignable_result(x) (x)
8402 if (!id) return assignable_result(0);
8403 if (id == keyword_self) {
8404 yyerror("Can't change the value of self");
8406 else if (id == keyword_nil) {
8407 yyerror("Can't assign to nil");
8409 else if (id == keyword_true) {
8410 yyerror("Can't assign to true");
8412 else if (id == keyword_false) {
8413 yyerror("Can't assign to false");
8415 else if (id == keyword__FILE__) {
8416 yyerror("Can't assign to __FILE__");
8418 else if (id == keyword__LINE__) {
8419 yyerror("Can't assign to __LINE__");
8421 else if (id == keyword__ENCODING__) {
8422 yyerror("Can't assign to __ENCODING__");
8424 else if (is_local_id(id)) {
8425 if (dyna_in_block()) {
8426 if (dvar_curr(id)) {
8427 return assignable_result(NEW_DASGN_CURR(id, val));
8429 else if (dvar_defined(id)) {
8430 return assignable_result(NEW_DASGN(id, val));
8432 else if (local_id(id)) {
8433 return assignable_result(NEW_LASGN(id, val));
8437 return assignable_result(NEW_DASGN_CURR(id, val));
8441 if (!local_id(id)) {
8444 return assignable_result(NEW_LASGN(id, val));
8447 else if (is_global_id(id)) {
8448 return assignable_result(NEW_GASGN(id, val));
8450 else if (is_instance_id(id)) {
8451 return assignable_result(NEW_IASGN(id, val));
8453 else if (is_const_id(id)) {
8454 if (!in_def && !in_single)
8455 return assignable_result(NEW_CDECL(id, val, 0));
8456 yyerror("dynamic constant assignment");
8458 else if (is_class_id(id)) {
8459 return assignable_result(NEW_CVASGN(id, val));
8462 compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
8464 return assignable_result(0);
8465 #undef assignable_result
8466 #undef parser_yyerror
8469 #define LVAR_USED ((int)1 << (sizeof(int) * CHAR_BIT - 1))
8472 shadowing_lvar_gen(struct parser_params *parser, ID name)
8474 if (idUScore == name) return name;
8475 if (dyna_in_block()) {
8476 if (dvar_curr(name)) {
8477 yyerror("duplicated argument name");
8479 else if (dvar_defined_get(name) || local_id(name)) {
8480 rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
8481 vtable_add(lvtbl->vars, name);
8483 vtable_add(lvtbl->used, (ID)ruby_sourceline | LVAR_USED);
8488 if (local_id(name)) {
8489 yyerror("duplicated argument name");
8496 new_bv_gen(struct parser_params *parser, ID name)
8499 if (!is_local_id(name)) {
8500 compile_error(PARSER_ARG "invalid local variable - %s",
8504 shadowing_lvar(name);
8510 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
8512 if (recv && nd_type(recv) == NODE_SELF)
8514 return NEW_ATTRASGN(recv, tASET, idx);
8518 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
8520 if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
8521 compile_error(PARSER_ARG "both block arg and actual block given");
8526 rb_id_attrset(ID id)
8528 id &= ~ID_SCOPE_MASK;
8534 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
8536 if (recv && nd_type(recv) == NODE_SELF)
8538 return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
8542 rb_backref_error_gen(struct parser_params *parser, NODE *node)
8544 switch (nd_type(node)) {
8546 compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
8549 compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
8555 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
8557 if (!node2) return node1;
8558 switch (nd_type(node1)) {
8559 case NODE_BLOCK_PASS:
8561 node1->nd_head = arg_concat(node1->nd_head, node2);
8563 node1->nd_head = NEW_LIST(node2);
8566 if (nd_type(node2) != NODE_ARRAY) break;
8567 node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
8568 nd_set_type(node1, NODE_ARGSCAT);
8571 if (nd_type(node2) != NODE_ARRAY ||
8572 nd_type(node1->nd_body) != NODE_ARRAY) break;
8573 node1->nd_body = list_concat(node1->nd_body, node2);
8576 return NEW_ARGSCAT(node1, node2);
8580 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
8582 if (!node1) return NEW_LIST(node2);
8583 switch (nd_type(node1)) {
8585 return list_append(node1, node2);
8586 case NODE_BLOCK_PASS:
8587 node1->nd_head = arg_append(node1->nd_head, node2);
8590 node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
8591 nd_set_type(node1, NODE_ARGSCAT);
8594 return NEW_ARGSPUSH(node1, node2);
8598 splat_array(NODE* node)
8600 if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
8601 if (nd_type(node) == NODE_ARRAY) return node;
8606 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
8610 switch (nd_type(lhs)) {
8616 case NODE_DASGN_CURR:
8620 lhs->nd_value = rhs;
8625 lhs->nd_args = arg_append(lhs->nd_args, rhs);
8629 /* should not happen */
8637 value_expr_gen(struct parser_params *parser, NODE *node)
8642 rb_warning0("empty expression");
8645 switch (nd_type(node)) {
8648 parser_warning(node, "void value expression");
8656 if (!cond) yyerror("void value expression");
8657 /* or "control never reach"? */
8661 while (node->nd_next) {
8662 node = node->nd_next;
8664 node = node->nd_head;
8668 node = node->nd_body;
8672 if (!node->nd_body) {
8673 node = node->nd_else;
8676 else if (!node->nd_else) {
8677 node = node->nd_body;
8680 if (!value_expr(node->nd_body)) return FALSE;
8681 node = node->nd_else;
8687 node = node->nd_2nd;
8699 void_expr_gen(struct parser_params *parser, NODE *node)
8701 const char *useless = 0;
8703 if (!RTEST(ruby_verbose)) return;
8706 switch (nd_type(node)) {
8708 switch (node->nd_mid) {
8727 useless = rb_id2name(node->nd_mid);
8739 useless = "a variable";
8742 useless = "a constant";
8748 case NODE_DREGX_ONCE:
8749 useless = "a literal";
8774 useless = "defined?";
8779 int line = ruby_sourceline;
8781 ruby_sourceline = nd_line(node);
8782 rb_warnS("possibly useless use of %s in void context", useless);
8783 ruby_sourceline = line;
8788 void_stmts_gen(struct parser_params *parser, NODE *node)
8790 if (!RTEST(ruby_verbose)) return;
8792 if (nd_type(node) != NODE_BLOCK) return;
8795 if (!node->nd_next) return;
8796 void_expr0(node->nd_head);
8797 node = node->nd_next;
8802 remove_begin(NODE *node)
8804 NODE **n = &node, *n1 = node;
8805 while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
8806 *n = n1 = n1->nd_body;
8812 reduce_nodes_gen(struct parser_params *parser, NODE **body)
8820 #define subnodes(n1, n2) \
8821 ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
8822 (!node->n2) ? (body = &node->n1, 1) : \
8823 (reduce_nodes(&node->n1), body = &node->n2, 1))
8826 int newline = (int)(node->flags & NODE_FL_NEWLINE);
8827 switch (nd_type(node)) {
8833 *body = node = node->nd_stts;
8834 if (newline && node) node->flags |= NODE_FL_NEWLINE;
8837 *body = node = node->nd_body;
8838 if (newline && node) node->flags |= NODE_FL_NEWLINE;
8841 body = &node->nd_end->nd_head;
8844 if (subnodes(nd_body, nd_else)) break;
8847 body = &node->nd_body;
8850 if (!subnodes(nd_body, nd_next)) goto end;
8853 if (!subnodes(nd_head, nd_resq)) goto end;
8856 if (node->nd_else) {
8857 body = &node->nd_resq;
8860 if (!subnodes(nd_head, nd_resq)) goto end;
8866 if (newline && node) node->flags |= NODE_FL_NEWLINE;
8873 assign_in_cond(struct parser_params *parser, NODE *node)
8875 switch (nd_type(node)) {
8877 yyerror("multiple assignment in conditional");
8882 case NODE_DASGN_CURR:
8891 if (!node->nd_value) return 1;
8892 switch (nd_type(node->nd_value)) {
8898 /* reports always */
8899 parser_warn(node->nd_value, "found = in conditional, should be ==");
8914 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
8916 if (!e_option_supplied(parser)) parser_warn(node, str);
8920 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
8922 if (!e_option_supplied(parser)) parser_warning(node, str);
8926 fixup_nodes(NODE **rootnode)
8928 NODE *node, *next, *head;
8930 for (node = *rootnode; node; node = next) {
8931 enum node_type type;
8934 next = node->nd_next;
8935 head = node->nd_head;
8936 rb_gc_force_recycle((VALUE)node);
8938 switch (type = nd_type(head)) {
8941 val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
8943 rb_gc_force_recycle((VALUE)head->nd_beg);
8944 rb_gc_force_recycle((VALUE)head->nd_end);
8945 nd_set_type(head, NODE_LIT);
8954 static NODE *cond0(struct parser_params*,NODE*);
8957 range_op(struct parser_params *parser, NODE *node)
8959 enum node_type type;
8961 if (node == 0) return 0;
8963 type = nd_type(node);
8965 if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
8966 warn_unless_e_option(parser, node, "integer literal in conditional range");
8967 return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
8969 return cond0(parser, node);
8973 literal_node(NODE *node)
8975 if (!node) return 1; /* same as NODE_NIL */
8976 switch (nd_type(node)) {
8982 case NODE_DREGX_ONCE:
8994 cond0(struct parser_params *parser, NODE *node)
8996 if (node == 0) return 0;
8997 assign_in_cond(parser, node);
8999 switch (nd_type(node)) {
9003 rb_warn0("string literal in condition");
9007 case NODE_DREGX_ONCE:
9008 warning_unless_e_option(parser, node, "regex literal in condition");
9009 return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
9013 node->nd_1st = cond0(parser, node->nd_1st);
9014 node->nd_2nd = cond0(parser, node->nd_2nd);
9019 node->nd_beg = range_op(parser, node->nd_beg);
9020 node->nd_end = range_op(parser, node->nd_end);
9021 if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
9022 else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
9023 if (!e_option_supplied(parser)) {
9024 int b = literal_node(node->nd_beg);
9025 int e = literal_node(node->nd_end);
9026 if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
9027 parser_warn(node, "range literal in condition");
9033 parser_warning(node, "literal in condition");
9037 if (TYPE(node->nd_lit) == T_REGEXP) {
9038 warn_unless_e_option(parser, node, "regex literal in condition");
9039 nd_set_type(node, NODE_MATCH);
9042 parser_warning(node, "literal in condition");
9051 cond_gen(struct parser_params *parser, NODE *node)
9053 if (node == 0) return 0;
9054 return cond0(parser, node);
9058 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
9061 if (left && (enum node_type)nd_type(left) == type) {
9062 NODE *node = left, *second;
9063 while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
9066 node->nd_2nd = NEW_NODE(type, second, right, 0);
9069 return NEW_NODE(type, left, right, 0);
9073 no_blockarg(struct parser_params *parser, NODE *node)
9075 if (node && nd_type(node) == NODE_BLOCK_PASS) {
9076 compile_error(PARSER_ARG "block argument should not be given");
9081 ret_args_gen(struct parser_params *parser, NODE *node)
9084 no_blockarg(parser, node);
9085 if (nd_type(node) == NODE_ARRAY) {
9086 if (node->nd_next == 0) {
9087 node = node->nd_head;
9090 nd_set_type(node, NODE_VALUES);
9098 new_yield_gen(struct parser_params *parser, NODE *node)
9103 no_blockarg(parser, node);
9104 if (node && nd_type(node) == NODE_SPLAT) {
9111 return NEW_YIELD(node, state);
9115 negate_lit(NODE *node)
9117 switch (TYPE(node->nd_lit)) {
9119 node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
9122 node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
9125 RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
9134 arg_blk_pass(NODE *node1, NODE *node2)
9137 node2->nd_head = node1;
9144 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, ID b)
9146 int saved_line = ruby_sourceline;
9150 node = NEW_ARGS(m ? m->nd_plen : 0, o);
9151 i1 = m ? m->nd_next : 0;
9152 node->nd_next = NEW_ARGS_AUX(r, b);
9156 node->nd_next->nd_next = NEW_ARGS_AUX(p->nd_pid, p->nd_plen);
9159 node->nd_next->nd_next = NEW_ARGS_AUX(0, 0);
9162 node->nd_next->nd_next->nd_next = NEW_NODE(NODE_AND, i1, i2, 0);
9164 ruby_sourceline = saved_line;
9167 #endif /* !RIPPER */
9170 warn_unused_var(struct parser_params *parser, struct local_vars *local)
9175 if (!local->used) return;
9176 v = local->vars->tbl;
9177 u = local->used->tbl;
9178 cnt = local->used->pos;
9179 if (cnt != local->vars->pos) {
9180 rb_bug("local->used->pos != local->vars->pos");
9182 for (i = 0; i < cnt; ++i) {
9183 if (!v[i] || (u[i] & LVAR_USED)) continue;
9184 if (idUScore == v[i]) continue;
9185 rb_compile_warn(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
9190 local_push_gen(struct parser_params *parser, int inherit_dvars)
9192 struct local_vars *local;
9194 local = ALLOC(struct local_vars);
9195 local->prev = lvtbl;
9196 local->args = vtable_alloc(0);
9197 local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
9198 local->used = !inherit_dvars && RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
9199 local->cmdargs = cmdarg_stack;
9205 local_pop_gen(struct parser_params *parser)
9207 struct local_vars *local = lvtbl->prev;
9209 warn_unused_var(parser, lvtbl);
9210 vtable_free(lvtbl->used);
9212 vtable_free(lvtbl->args);
9213 vtable_free(lvtbl->vars);
9214 cmdarg_stack = lvtbl->cmdargs;
9221 vtable_tblcpy(ID *buf, const struct vtable *src)
9223 int i, cnt = vtable_size(src);
9227 for (i = 0; i < cnt; i++) {
9228 buf[i] = src->tbl[i];
9236 local_tbl_gen(struct parser_params *parser)
9238 int cnt = vtable_size(lvtbl->args) + vtable_size(lvtbl->vars);
9241 if (cnt <= 0) return 0;
9242 buf = ALLOC_N(ID, cnt + 1);
9243 vtable_tblcpy(buf+1, lvtbl->args);
9244 vtable_tblcpy(buf+vtable_size(lvtbl->args)+1, lvtbl->vars);
9251 arg_var_gen(struct parser_params *parser, ID id)
9253 vtable_add(lvtbl->args, id);
9254 return vtable_size(lvtbl->args) - 1;
9258 local_var_gen(struct parser_params *parser, ID id)
9260 vtable_add(lvtbl->vars, id);
9262 vtable_add(lvtbl->used, (ID)ruby_sourceline);
9264 return vtable_size(lvtbl->vars) - 1;
9268 local_id_gen(struct parser_params *parser, ID id)
9270 struct vtable *vars, *args, *used;
9276 while (vars && POINTER_P(vars->prev)) {
9279 if (used) used = used->prev;
9282 if (vars && vars->prev == DVARS_INHERIT) {
9283 return rb_local_defined(id);
9285 else if (vtable_included(args, id)) {
9289 int i = vtable_included(vars, id);
9290 if (i && used) used->tbl[i-1] |= LVAR_USED;
9295 static const struct vtable *
9296 dyna_push_gen(struct parser_params *parser)
9298 lvtbl->args = vtable_alloc(lvtbl->args);
9299 lvtbl->vars = vtable_alloc(lvtbl->vars);
9301 lvtbl->used = vtable_alloc(lvtbl->used);
9307 dyna_pop_1(struct parser_params *parser)
9311 if ((tmp = lvtbl->used) != 0) {
9312 warn_unused_var(parser, lvtbl);
9313 lvtbl->used = lvtbl->used->prev;
9317 lvtbl->args = lvtbl->args->prev;
9320 lvtbl->vars = lvtbl->vars->prev;
9325 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
9327 while (lvtbl->args != lvargs) {
9330 struct local_vars *local = lvtbl->prev;
9339 dyna_in_block_gen(struct parser_params *parser)
9341 return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
9345 dvar_defined_gen(struct parser_params *parser, ID id, int get)
9347 struct vtable *vars, *args, *used;
9354 while (POINTER_P(vars)) {
9355 if (vtable_included(args, id)) {
9358 if ((i = vtable_included(vars, id)) != 0) {
9359 if (used) used->tbl[i-1] |= LVAR_USED;
9365 if (used) used = used->prev;
9368 if (vars == DVARS_INHERIT) {
9369 return rb_dvar_defined(id);
9376 dvar_curr_gen(struct parser_params *parser, ID id)
9378 return (vtable_included(lvtbl->args, id) ||
9379 vtable_included(lvtbl->vars, id));
9384 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
9386 int c = RE_OPTION_ENCODING_IDX(options);
9390 rb_char_to_option_kcode(c, &opt, &idx);
9391 if (idx != ENCODING_GET(str) &&
9392 rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
9395 ENCODING_SET(str, idx);
9397 else if (RE_OPTION_ENCODING_NONE(options)) {
9398 if (!ENCODING_IS_ASCII8BIT(str) &&
9399 rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
9403 rb_enc_associate(str, rb_ascii8bit_encoding());
9405 else if (parser->enc == rb_usascii_encoding()) {
9406 if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
9408 rb_enc_associate(str, rb_usascii_encoding());
9411 rb_enc_associate(str, rb_ascii8bit_encoding());
9417 compile_error(PARSER_ARG
9418 "regexp encoding option '%c' differs from source encoding '%s'",
9419 c, rb_enc_name(rb_enc_get(str)));
9423 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
9426 reg_fragment_setenc(str, options);
9427 err = rb_reg_check_preprocess(str);
9429 err = rb_obj_as_string(err);
9430 compile_error(PARSER_ARG "%s", RSTRING_PTR(err));
9438 struct parser_params* parser;
9443 } reg_named_capture_assign_t;
9446 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
9447 int back_num, int *back_refs, OnigRegex regex, void *arg0)
9449 reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
9450 struct parser_params* parser = arg->parser;
9451 rb_encoding *enc = arg->enc;
9452 long len = name_end - name;
9453 const char *s = (const char *)name;
9458 if (arg->succ_block == 0) {
9459 arg->succ_block = NEW_BEGIN(0);
9460 arg->fail_block = NEW_BEGIN(0);
9463 if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
9464 (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
9465 !rb_enc_symname2_p(s, len, enc)) {
9468 var = rb_intern3(s, len, enc);
9469 if (dvar_defined(var) || local_id(var)) {
9470 rb_warningS("named capture conflicts a local variable - %s",
9473 arg->succ_block = block_append(arg->succ_block,
9474 newline_node(node_assign(assignable(var,0),
9476 gettable(rb_intern("$~")),
9478 NEW_LIST(NEW_LIT(ID2SYM(var))))
9480 arg->fail_block = block_append(arg->fail_block,
9481 newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil))));
9486 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match)
9488 reg_named_capture_assign_t arg;
9490 arg.parser = parser;
9491 arg.enc = rb_enc_get(regexp);
9495 onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
9502 newline_node(match),
9503 NEW_IF(gettable(rb_intern("$~")),
9505 newline_node(arg.succ_block),
9508 gettable(rb_intern("$~")),
9510 NEW_LIST(NEW_LIT(INT2FIX(0)))))),
9512 newline_node(arg.fail_block),
9518 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
9523 reg_fragment_setenc(str, options);
9525 re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
9527 ID mesg = rb_intern("mesg");
9528 VALUE m = rb_attr_get(rb_errinfo(), mesg);
9529 rb_set_errinfo(err);
9531 rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
9534 compile_error(PARSER_ARG "%s", RSTRING_PTR(m));
9542 rb_gc_mark_parser(void)
9547 rb_parser_append_print(VALUE vparser, NODE *node)
9551 struct parser_params *parser;
9553 if (!node) return node;
9555 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
9557 node = node->nd_body;
9559 if (nd_type(node) == NODE_PRELUDE) {
9561 node = node->nd_body;
9564 node = block_append(node,
9565 NEW_FCALL(rb_intern("print"),
9566 NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
9568 prelude->nd_body = node;
9569 scope->nd_body = prelude;
9572 scope->nd_body = node;
9579 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
9583 struct parser_params *parser;
9585 if (!node) return node;
9587 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
9589 node = node->nd_body;
9591 if (nd_type(node) == NODE_PRELUDE) {
9593 node = node->nd_body;
9596 node = block_append(NEW_GASGN(rb_intern("$F"),
9597 NEW_CALL(NEW_GVAR(rb_intern("$_")),
9598 rb_intern("split"), 0)),
9602 node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
9603 rb_intern("chop!"), 0), node);
9606 node = NEW_OPT_N(node);
9609 prelude->nd_body = node;
9610 scope->nd_body = prelude;
9613 scope->nd_body = node;
9619 static const struct {
9643 #define op_tbl_count numberof(op_tbl)
9645 #ifndef ENABLE_SELECTOR_NAMESPACE
9646 #define ENABLE_SELECTOR_NAMESPACE 0
9649 static struct symbols {
9653 #if ENABLE_SELECTOR_NAMESPACE
9657 VALUE op_sym[tLAST_TOKEN];
9658 } global_symbols = {tLAST_ID};
9660 static const struct st_hash_type symhash = {
9665 #if ENABLE_SELECTOR_NAMESPACE
9672 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
9674 if (key1->id == key2->id && key1->klass == key2->klass) {
9681 ivar2_hash(struct ivar2_key *key)
9683 return (key->id << 8) ^ (key->klass >> 2);
9686 static const struct st_hash_type ivar2_hash_type = {
9695 global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
9696 global_symbols.id_str = st_init_numtable_with_size(1000);
9697 #if ENABLE_SELECTOR_NAMESPACE
9698 global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
9699 global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
9706 rb_gc_mark_symbols(void)
9708 rb_mark_tbl(global_symbols.id_str);
9709 rb_gc_mark_locations(global_symbols.op_sym,
9710 global_symbols.op_sym + tLAST_TOKEN);
9712 #endif /* !RIPPER */
9715 internal_id_gen(struct parser_params *parser)
9717 ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
9718 id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
9719 return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
9724 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
9728 if (m >= e) return 0;
9729 if (is_global_name_punct(*m)) {
9732 else if (*m == '-') {
9734 if (m < e && is_identchar(m, e, enc)) {
9735 if (!ISASCII(*m)) mb = 1;
9736 m += rb_enc_mbclen(m, e, enc);
9740 if (!rb_enc_isdigit(*m, enc)) return 0;
9742 if (!ISASCII(*m)) mb = 1;
9744 } while (m < e && rb_enc_isdigit(*m, enc));
9746 return m == e ? mb + 1 : 0;
9750 rb_symname_p(const char *name)
9752 return rb_enc_symname_p(name, rb_ascii8bit_encoding());
9756 rb_enc_symname_p(const char *name, rb_encoding *enc)
9758 return rb_enc_symname2_p(name, strlen(name), enc);
9762 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
9764 const char *m = name;
9765 const char *e = m + len;
9766 int localid = FALSE;
9768 if (!m || len <= 0) return FALSE;
9774 if (is_special_global_name(++m, e, enc)) return TRUE;
9778 if (*++m == '@') ++m;
9783 case '<': ++m; break;
9784 case '=': if (*++m == '>') ++m; break;
9791 case '>': case '=': ++m; break;
9797 case '~': ++m; break;
9798 case '=': if (*++m == '=') ++m; break;
9799 default: return FALSE;
9804 if (*++m == '*') ++m;
9808 if (*++m == '@') ++m;
9811 case '|': case '^': case '&': case '/': case '%': case '~': case '`':
9816 if (*++m != ']') return FALSE;
9817 if (*++m == '=') ++m;
9821 if (len == 1) return TRUE;
9823 case '=': case '~': ++m; break;
9824 default: return FALSE;
9829 localid = !rb_enc_isupper(*m, enc);
9831 if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
9833 while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
9836 case '!': case '?': case '=': ++m;
9845 register_symid(ID id, const char *name, long len, rb_encoding *enc)
9847 VALUE str = rb_enc_str_new(name, len, enc);
9849 st_add_direct(global_symbols.sym_id, (st_data_t)str, id);
9850 st_add_direct(global_symbols.id_str, id, (st_data_t)str);
9855 rb_intern3(const char *name, long len, rb_encoding *enc)
9857 const char *m = name;
9858 const char *e = m + len;
9865 struct RString fake_str;
9866 fake_str.basic.flags = T_STRING|RSTRING_NOEMBED;
9867 fake_str.basic.klass = rb_cString;
9868 fake_str.as.heap.len = len;
9869 fake_str.as.heap.ptr = (char *)name;
9870 fake_str.as.heap.aux.capa = len;
9871 str = (VALUE)&fake_str;
9872 rb_enc_associate(str, enc);
9875 if (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN) {
9876 rb_raise(rb_eEncodingError, "invalid encoding symbol");
9879 if (st_lookup(global_symbols.sym_id, str, &data))
9882 if (rb_cString && !rb_enc_asciicompat(enc)) {
9891 if ((mb = is_special_global_name(++m, e, enc)) != 0) {
9892 if (!--mb) enc = rb_ascii8bit_encoding();
9908 if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
9916 for (i = 0; i < op_tbl_count; i++) {
9917 if (*op_tbl[i].name == *m &&
9918 strcmp(op_tbl[i].name, m) == 0) {
9919 id = op_tbl[i].token;
9925 if (m[last] == '=') {
9926 /* attribute assignment */
9927 id = rb_intern3(name, last, enc);
9928 if (id > tLAST_TOKEN && !is_attrset_id(id)) {
9929 enc = rb_enc_get(rb_id2str(id));
9930 id = rb_id_attrset(id);
9935 else if (rb_enc_isupper(m[0], enc)) {
9944 if (!rb_enc_isdigit(*m, enc)) {
9945 while (m <= name + last && is_identchar(m, e, enc)) {
9951 m += rb_enc_mbclen(m, e, enc);
9955 if (m - name < len) id = ID_JUNK;
9956 if (enc != rb_usascii_encoding()) {
9958 * this clause makes sense only when called from other than
9959 * rb_intern_str() taking care of code-range.
9962 for (; m <= name + len; ++m) {
9963 if (!ISASCII(*m)) goto mbstr;
9965 enc = rb_usascii_encoding();
9970 if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) {
9972 rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
9976 rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
9980 id |= ++global_symbols.last_id << ID_SCOPE_SHIFT;
9982 return register_symid(id, name, len, enc);
9986 rb_intern2(const char *name, long len)
9988 return rb_intern3(name, len, rb_usascii_encoding());
9993 rb_intern(const char *name)
9995 return rb_intern2(name, strlen(name));
9999 rb_intern_str(VALUE str)
10004 if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
10005 enc = rb_usascii_encoding();
10008 enc = rb_enc_get(str);
10010 id = rb_intern3(RSTRING_PTR(str), RSTRING_LEN(str), enc);
10020 if (id < tLAST_TOKEN) {
10023 if (id < INT_MAX && rb_ispunct((int)id)) {
10024 VALUE str = global_symbols.op_sym[i = (int)id];
10027 name[0] = (char)id;
10029 str = rb_usascii_str_new(name, 1);
10031 global_symbols.op_sym[i] = str;
10035 for (i = 0; i < op_tbl_count; i++) {
10036 if (op_tbl[i].token == id) {
10037 VALUE str = global_symbols.op_sym[i];
10039 str = rb_usascii_str_new2(op_tbl[i].name);
10041 global_symbols.op_sym[i] = str;
10048 if (st_lookup(global_symbols.id_str, id, &data)) {
10049 VALUE str = (VALUE)data;
10050 if (RBASIC(str)->klass == 0)
10051 RBASIC(str)->klass = rb_cString;
10055 if (is_attrset_id(id)) {
10056 ID id2 = (id & ~ID_SCOPE_MASK) | ID_LOCAL;
10059 while (!(str = rb_id2str(id2))) {
10060 if (!is_local_id(id2)) return 0;
10061 id2 = (id & ~ID_SCOPE_MASK) | ID_CONST;
10063 str = rb_str_dup(str);
10064 rb_str_cat(str, "=", 1);
10065 rb_intern_str(str);
10066 if (st_lookup(global_symbols.id_str, id, &data)) {
10067 VALUE str = (VALUE)data;
10068 if (RBASIC(str)->klass == 0)
10069 RBASIC(str)->klass = rb_cString;
10079 VALUE str = rb_id2str(id);
10081 if (!str) return 0;
10082 return RSTRING_PTR(str);
10086 symbols_i(VALUE sym, ID value, VALUE ary)
10088 rb_ary_push(ary, ID2SYM(value));
10089 return ST_CONTINUE;
10094 * Symbol.all_symbols => array
10096 * Returns an array of all the symbols currently in Ruby's symbol
10099 * Symbol.all_symbols.size #=> 903
10100 * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
10101 * :chown, :EOFError, :$;, :String,
10102 * :LOCK_SH, :"setuid?", :$<,
10103 * :default_proc, :compact, :extend,
10104 * :Tms, :getwd, :$=, :ThreadGroup,
10109 rb_sym_all_symbols(void)
10111 VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries);
10113 st_foreach(global_symbols.sym_id, symbols_i, ary);
10118 rb_is_const_id(ID id)
10120 return is_const_id(id);
10124 rb_is_class_id(ID id)
10126 return is_class_id(id);
10130 rb_is_instance_id(ID id)
10132 return is_instance_id(id);
10136 rb_is_local_id(ID id)
10138 return is_local_id(id);
10142 rb_is_junk_id(ID id)
10144 return is_junk_id(id);
10147 #endif /* !RIPPER */
10150 parser_initialize(struct parser_params *parser)
10152 parser->eofp = Qfalse;
10154 parser->parser_lex_strterm = 0;
10155 parser->parser_cond_stack = 0;
10156 parser->parser_cmdarg_stack = 0;
10157 parser->parser_class_nest = 0;
10158 parser->parser_paren_nest = 0;
10159 parser->parser_lpar_beg = 0;
10160 parser->parser_in_single = 0;
10161 parser->parser_in_def = 0;
10162 parser->parser_in_defined = 0;
10163 parser->parser_compile_for_eval = 0;
10164 parser->parser_cur_mid = 0;
10165 parser->parser_tokenbuf = NULL;
10166 parser->parser_tokidx = 0;
10167 parser->parser_toksiz = 0;
10168 parser->parser_heredoc_end = 0;
10169 parser->parser_command_start = TRUE;
10170 parser->parser_deferred_nodes = 0;
10171 parser->parser_lex_pbeg = 0;
10172 parser->parser_lex_p = 0;
10173 parser->parser_lex_pend = 0;
10174 parser->parser_lvtbl = 0;
10175 parser->parser_ruby__end__seen = 0;
10176 parser->parser_ruby_sourcefile = 0;
10178 parser->is_ripper = 0;
10179 parser->parser_eval_tree_begin = 0;
10180 parser->parser_eval_tree = 0;
10182 parser->is_ripper = 1;
10183 parser->parser_ruby_sourcefile_string = Qnil;
10184 parser->delayed = Qnil;
10186 parser->result = Qnil;
10187 parser->parsing_thread = Qnil;
10188 parser->toplevel_p = TRUE;
10191 parser->heap = NULL;
10193 parser->enc = rb_usascii_encoding();
10197 #define parser_mark ripper_parser_mark
10198 #define parser_free ripper_parser_free
10202 parser_mark(void *ptr)
10204 struct parser_params *p = (struct parser_params*)ptr;
10206 rb_gc_mark((VALUE)p->parser_lex_strterm);
10207 rb_gc_mark((VALUE)p->parser_deferred_nodes);
10208 rb_gc_mark(p->parser_lex_input);
10209 rb_gc_mark(p->parser_lex_lastline);
10210 rb_gc_mark(p->parser_lex_nextline);
10212 rb_gc_mark((VALUE)p->parser_eval_tree_begin) ;
10213 rb_gc_mark((VALUE)p->parser_eval_tree) ;
10214 rb_gc_mark(p->debug_lines);
10216 rb_gc_mark(p->parser_ruby_sourcefile_string);
10217 rb_gc_mark(p->delayed);
10218 rb_gc_mark(p->value);
10219 rb_gc_mark(p->result);
10220 rb_gc_mark(p->parsing_thread);
10223 rb_gc_mark((VALUE)p->heap);
10228 parser_free(void *ptr)
10230 struct parser_params *p = (struct parser_params*)ptr;
10231 struct local_vars *local, *prev;
10233 if (p->parser_tokenbuf) {
10234 xfree(p->parser_tokenbuf);
10236 for (local = p->parser_lvtbl; local; local = prev) {
10237 if (local->vars) xfree(local->vars);
10238 prev = local->prev;
10242 xfree(p->parser_ruby_sourcefile);
10248 parser_memsize(const void *ptr)
10250 struct parser_params *p = (struct parser_params*)ptr;
10251 struct local_vars *local;
10252 size_t size = sizeof(*p);
10254 if (!ptr) return 0;
10255 size += p->parser_toksiz;
10256 for (local = p->parser_lvtbl; local; local = local->prev) {
10257 size += sizeof(*local);
10258 if (local->vars) size += local->vars->capa * sizeof(ID);
10261 if (p->parser_ruby_sourcefile) {
10262 size += strlen(p->parser_ruby_sourcefile) + 1;
10272 rb_data_type_t parser_data_type = {
10282 #undef rb_reserved_word
10284 const struct kwtable *
10285 rb_reserved_word(const char *str, unsigned int len)
10287 return reserved_word(str, len);
10290 static struct parser_params *
10293 struct parser_params *p;
10295 p = ALLOC_N(struct parser_params, 1);
10296 MEMZERO(p, struct parser_params, 1);
10297 parser_initialize(p);
10302 rb_parser_new(void)
10304 struct parser_params *p = parser_new();
10306 return TypedData_Wrap_Struct(0, &parser_data_type, p);
10311 * ripper#end_seen? -> Boolean
10313 * Return true if parsed source ended by +\_\_END\_\_+.
10316 rb_parser_end_seen_p(VALUE vparser)
10318 struct parser_params *parser;
10320 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
10321 return ruby__end__seen ? Qtrue : Qfalse;
10326 * ripper#encoding -> encoding
10328 * Return encoding of the source.
10331 rb_parser_encoding(VALUE vparser)
10333 struct parser_params *parser;
10335 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
10336 return rb_enc_from_encoding(parser->enc);
10341 * ripper.yydebug -> true or false
10346 rb_parser_get_yydebug(VALUE self)
10348 struct parser_params *parser;
10350 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
10351 return yydebug ? Qtrue : Qfalse;
10356 * ripper.yydebug = flag
10361 rb_parser_set_yydebug(VALUE self, VALUE flag)
10363 struct parser_params *parser;
10365 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
10366 yydebug = RTEST(flag);
10371 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
10372 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
10373 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
10374 (n)->u3.cnt = (c), (p))
10377 rb_parser_malloc(struct parser_params *parser, size_t size)
10379 size_t cnt = HEAPCNT(1, size);
10380 NODE *n = NEWHEAP();
10381 void *ptr = xmalloc(size);
10383 return ADD2HEAP(n, cnt, ptr);
10387 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
10389 size_t cnt = HEAPCNT(nelem, size);
10390 NODE *n = NEWHEAP();
10391 void *ptr = xcalloc(nelem, size);
10393 return ADD2HEAP(n, cnt, ptr);
10397 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
10400 size_t cnt = HEAPCNT(1, size);
10402 if (ptr && (n = parser->heap) != NULL) {
10404 if (n->u1.node == ptr) {
10405 n->u1.node = ptr = xrealloc(ptr, size);
10406 if (n->u3.cnt) n->u3.cnt = cnt;
10409 } while ((n = n->u2.node) != NULL);
10412 ptr = xrealloc(ptr, size);
10413 return ADD2HEAP(n, cnt, ptr);
10417 rb_parser_free(struct parser_params *parser, void *ptr)
10419 NODE **prev = &parser->heap, *n;
10421 while ((n = *prev) != NULL) {
10422 if (n->u1.node == ptr) {
10423 *prev = n->u2.node;
10424 rb_gc_force_recycle((VALUE)n);
10427 prev = &n->u2.node;
10435 #ifdef RIPPER_DEBUG
10436 extern int rb_is_pointer_to_heap(VALUE);
10440 ripper_validate_object(VALUE self, VALUE x)
10442 if (x == Qfalse) return x;
10443 if (x == Qtrue) return x;
10444 if (x == Qnil) return x;
10446 rb_raise(rb_eArgError, "Qundef given");
10447 if (FIXNUM_P(x)) return x;
10448 if (SYMBOL_P(x)) return x;
10449 if (!rb_is_pointer_to_heap(x))
10450 rb_raise(rb_eArgError, "invalid pointer: %p", x);
10459 if (nd_type(x) != NODE_LASGN) {
10460 rb_raise(rb_eArgError, "NODE given: %p", x);
10462 return ((NODE *)x)->nd_rval;
10464 rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
10465 x, rb_obj_classname(x));
10471 #define validate(x) ((x) = get_value(x))
10474 ripper_dispatch0(struct parser_params *parser, ID mid)
10476 return rb_funcall(parser->value, mid, 0);
10480 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
10483 return rb_funcall(parser->value, mid, 1, a);
10487 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
10491 return rb_funcall(parser->value, mid, 2, a, b);
10495 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
10500 return rb_funcall(parser->value, mid, 3, a, b, c);
10504 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
10510 return rb_funcall(parser->value, mid, 4, a, b, c, d);
10514 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
10521 return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
10524 static const struct kw_assoc {
10527 } keyword_to_name[] = {
10528 {keyword_class, "class"},
10529 {keyword_module, "module"},
10530 {keyword_def, "def"},
10531 {keyword_undef, "undef"},
10532 {keyword_begin, "begin"},
10533 {keyword_rescue, "rescue"},
10534 {keyword_ensure, "ensure"},
10535 {keyword_end, "end"},
10536 {keyword_if, "if"},
10537 {keyword_unless, "unless"},
10538 {keyword_then, "then"},
10539 {keyword_elsif, "elsif"},
10540 {keyword_else, "else"},
10541 {keyword_case, "case"},
10542 {keyword_when, "when"},
10543 {keyword_while, "while"},
10544 {keyword_until, "until"},
10545 {keyword_for, "for"},
10546 {keyword_break, "break"},
10547 {keyword_next, "next"},
10548 {keyword_redo, "redo"},
10549 {keyword_retry, "retry"},
10550 {keyword_in, "in"},
10551 {keyword_do, "do"},
10552 {keyword_do_cond, "do"},
10553 {keyword_do_block, "do"},
10554 {keyword_return, "return"},
10555 {keyword_yield, "yield"},
10556 {keyword_super, "super"},
10557 {keyword_self, "self"},
10558 {keyword_nil, "nil"},
10559 {keyword_true, "true"},
10560 {keyword_false, "false"},
10561 {keyword_and, "and"},
10562 {keyword_or, "or"},
10563 {keyword_not, "not"},
10564 {modifier_if, "if"},
10565 {modifier_unless, "unless"},
10566 {modifier_while, "while"},
10567 {modifier_until, "until"},
10568 {modifier_rescue, "rescue"},
10569 {keyword_alias, "alias"},
10570 {keyword_defined, "defined?"},
10571 {keyword_BEGIN, "BEGIN"},
10572 {keyword_END, "END"},
10573 {keyword__LINE__, "__LINE__"},
10574 {keyword__FILE__, "__FILE__"},
10575 {keyword__ENCODING__, "__ENCODING__"},
10580 keyword_id_to_str(ID id)
10582 const struct kw_assoc *a;
10584 for (a = keyword_to_name; a->id; a++) {
10591 #undef ripper_id2sym
10593 ripper_id2sym(ID id)
10601 return ID2SYM(rb_intern2(buf, 1));
10603 if ((name = keyword_id_to_str(id))) {
10604 return ID2SYM(rb_intern(name));
10614 name = rb_id2name(id);
10616 rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
10620 return ID2SYM(rb_intern(name));
10624 ripper_get_id(VALUE v)
10627 if (!RB_TYPE_P(v, T_NODE)) return 0;
10629 if (nd_type(nd) != NODE_LASGN) return 0;
10634 ripper_get_value(VALUE v)
10637 if (v == Qundef) return Qnil;
10638 if (!RB_TYPE_P(v, T_NODE)) return v;
10640 if (nd_type(nd) != NODE_LASGN) return Qnil;
10641 return nd->nd_rval;
10645 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
10650 va_start(args, fmt);
10651 str = rb_vsprintf(fmt, args);
10653 rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
10657 ripper_warn0(struct parser_params *parser, const char *fmt)
10659 rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
10663 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
10665 rb_funcall(parser->value, rb_intern("warn"), 2,
10666 STR_NEW2(fmt), INT2NUM(a));
10671 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
10673 rb_funcall(parser->value, rb_intern("warn"), 2,
10674 STR_NEW2(fmt), STR_NEW2(str));
10679 ripper_warning0(struct parser_params *parser, const char *fmt)
10681 rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
10685 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
10687 rb_funcall(parser->value, rb_intern("warning"), 2,
10688 STR_NEW2(fmt), STR_NEW2(str));
10692 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
10694 return rb_funcall(src, ripper_id_gets, 0);
10698 ripper_s_allocate(VALUE klass)
10700 struct parser_params *p;
10703 p = ALLOC_N(struct parser_params, 1);
10704 MEMZERO(p, struct parser_params, 1);
10705 self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
10710 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
10714 * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
10716 * Create a new Ripper object.
10717 * _src_ must be a String, an IO, or an Object which has #gets method.
10719 * This method does not starts parsing.
10720 * See also Ripper#parse and Ripper.parse.
10723 ripper_initialize(int argc, VALUE *argv, VALUE self)
10725 struct parser_params *parser;
10726 VALUE src, fname, lineno;
10728 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
10729 rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
10730 if (rb_obj_respond_to(src, ripper_id_gets, 0)) {
10731 parser->parser_lex_gets = ripper_lex_get_generic;
10735 parser->parser_lex_gets = lex_get_str;
10737 parser->parser_lex_input = src;
10738 parser->eofp = Qfalse;
10739 if (NIL_P(fname)) {
10740 fname = STR_NEW2("(ripper)");
10743 StringValue(fname);
10745 parser_initialize(parser);
10747 parser->parser_ruby_sourcefile_string = fname;
10748 parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
10749 parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
10754 struct ripper_args {
10755 struct parser_params *parser;
10761 ripper_parse0(VALUE parser_v)
10763 struct parser_params *parser;
10765 TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
10766 parser_prepare(parser);
10767 ripper_yyparse((void*)parser);
10768 return parser->result;
10772 ripper_ensure(VALUE parser_v)
10774 struct parser_params *parser;
10776 TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
10777 parser->parsing_thread = Qnil;
10785 * Start parsing and returns the value of the root action.
10788 ripper_parse(VALUE self)
10790 struct parser_params *parser;
10792 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
10793 if (!ripper_initialized_p(parser)) {
10794 rb_raise(rb_eArgError, "method called for uninitialized object");
10796 if (!NIL_P(parser->parsing_thread)) {
10797 if (parser->parsing_thread == rb_thread_current())
10798 rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
10800 rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
10802 parser->parsing_thread = rb_thread_current();
10803 rb_ensure(ripper_parse0, self, ripper_ensure, self);
10805 return parser->result;
10810 * ripper#column -> Integer
10812 * Return column number of current parsing line.
10813 * This number starts from 0.
10816 ripper_column(VALUE self)
10818 struct parser_params *parser;
10821 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
10822 if (!ripper_initialized_p(parser)) {
10823 rb_raise(rb_eArgError, "method called for uninitialized object");
10825 if (NIL_P(parser->parsing_thread)) return Qnil;
10826 col = parser->tokp - parser->parser_lex_pbeg;
10827 return LONG2NUM(col);
10832 * ripper#filename -> String
10834 * Return current parsing filename.
10837 ripper_filename(VALUE self)
10839 struct parser_params *parser;
10841 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
10842 if (!ripper_initialized_p(parser)) {
10843 rb_raise(rb_eArgError, "method called for uninitialized object");
10845 return parser->parser_ruby_sourcefile_string;
10850 * ripper#lineno -> Integer
10852 * Return line number of current parsing line.
10853 * This number starts from 1.
10856 ripper_lineno(VALUE self)
10858 struct parser_params *parser;
10860 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
10861 if (!ripper_initialized_p(parser)) {
10862 rb_raise(rb_eArgError, "method called for uninitialized object");
10864 if (NIL_P(parser->parsing_thread)) return Qnil;
10865 return INT2NUM(parser->parser_ruby_sourceline);
10868 #ifdef RIPPER_DEBUG
10871 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
10874 if (obj == Qundef) {
10875 rb_raise(rb_eArgError, "%s", RSTRING_PTR(msg));
10882 ripper_value(VALUE self, VALUE obj)
10884 return ULONG2NUM(obj);
10890 InitVM_ripper(void)
10892 parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
10901 Ripper = rb_define_class("Ripper", rb_cObject);
10902 rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
10903 rb_define_alloc_func(Ripper, ripper_s_allocate);
10904 rb_define_method(Ripper, "initialize", ripper_initialize, -1);
10905 rb_define_method(Ripper, "parse", ripper_parse, 0);
10906 rb_define_method(Ripper, "column", ripper_column, 0);
10907 rb_define_method(Ripper, "filename", ripper_filename, 0);
10908 rb_define_method(Ripper, "lineno", ripper_lineno, 0);
10909 rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
10910 rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
10911 rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
10912 rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
10913 #ifdef RIPPER_DEBUG
10914 rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
10915 rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
10916 rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
10919 ripper_id_gets = rb_intern("gets");
10920 ripper_init_eventids1(Ripper);
10921 ripper_init_eventids2(Ripper);
10922 /* ensure existing in symbol table */
10923 (void)rb_intern("||");
10924 (void)rb_intern("&&");
10927 /* Hack to let RDoc document SCRIPT_LINES__ */
10930 * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
10931 * after the assignment will be added as an Array of lines with the file
10934 rb_define_global_const("SCRIPT_LINES__", Qnil);
10938 #endif /* RIPPER */