1 /**********************************************************************
6 created at: Fri May 28 18:02:42 JST 1993
8 Copyright (C) 1993-2007 Yukihiro Matsumoto
10 **********************************************************************/
15 #define PARSER_DEBUG 0
18 #define YYERROR_VERBOSE 1
19 #define YYSTACK_USE_ALLOCA 0
21 #include "ruby/ruby.h"
23 #include "ruby/encoding.h"
34 #define YYMALLOC(size) rb_parser_malloc(parser, (size))
35 #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
36 #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
37 #define YYFREE(ptr) rb_parser_free(parser, (ptr))
38 #define malloc YYMALLOC
39 #define realloc YYREALLOC
40 #define calloc YYCALLOC
44 static ID register_symid(ID, const char *, long, rb_encoding *);
45 static ID register_symid_str(ID, VALUE);
46 #define REGISTER_SYMID(id, name) register_symid((id), (name), strlen(name), enc)
50 #define is_notop_id(id) ((id)>tLAST_OP_ID)
51 #define is_local_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_LOCAL)
52 #define is_global_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_GLOBAL)
53 #define is_instance_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_INSTANCE)
54 #define is_attrset_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_ATTRSET)
55 #define is_const_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CONST)
56 #define is_class_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_CLASS)
57 #define is_junk_id(id) (is_notop_id(id)&&((id)&ID_SCOPE_MASK)==ID_JUNK)
58 #define id_type(id) (is_notop_id(id) ? (int)((id)&ID_SCOPE_MASK) : -1)
60 #define is_asgn_or_id(id) ((is_notop_id(id)) && \
61 (((id)&ID_SCOPE_MASK) == ID_GLOBAL || \
62 ((id)&ID_SCOPE_MASK) == ID_INSTANCE || \
63 ((id)&ID_SCOPE_MASK) == ID_CLASS))
66 EXPR_BEG_bit, /* ignore newline, +/- is a sign. */
67 EXPR_END_bit, /* newline significant, +/- is an operator. */
68 EXPR_ENDARG_bit, /* ditto, and unbound braces. */
69 EXPR_ENDFN_bit, /* ditto, and unbound braces. */
70 EXPR_ARG_bit, /* newline significant, +/- is an operator. */
71 EXPR_CMDARG_bit, /* newline significant, +/- is an operator. */
72 EXPR_MID_bit, /* newline significant, +/- is an operator. */
73 EXPR_FNAME_bit, /* ignore newline, no reserved words. */
74 EXPR_DOT_bit, /* right after `.' or `::', no reserved words. */
75 EXPR_CLASS_bit, /* immediate after `class', no here document. */
76 EXPR_VALUE_bit, /* alike EXPR_BEG but label is disallowed. */
77 EXPR_LABELARG_bit, /* ignore significant, +/- is a sign. */
80 /* examine combinations */
82 #define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
95 EXPR_BEG_ANY = (EXPR_BEG | EXPR_VALUE | EXPR_MID | EXPR_CLASS | EXPR_LABELARG),
96 EXPR_ARG_ANY = (EXPR_ARG | EXPR_CMDARG),
97 EXPR_END_ANY = (EXPR_END | EXPR_ENDARG | EXPR_ENDFN)
99 #define IS_lex_state_for(x, ls) ((x) & (ls))
100 #define IS_lex_state(ls) IS_lex_state_for(lex_state, (ls))
103 static const char *lex_state_name(enum lex_state_e state);
106 typedef VALUE stack_type;
108 # define BITSTACK_PUSH(stack, n) ((stack) = ((stack)<<1)|((n)&1))
109 # define BITSTACK_POP(stack) ((stack) = (stack) >> 1)
110 # define BITSTACK_LEXPOP(stack) ((stack) = ((stack) >> 1) | ((stack) & 1))
111 # define BITSTACK_SET_P(stack) ((stack)&1)
113 #define COND_PUSH(n) BITSTACK_PUSH(cond_stack, (n))
114 #define COND_POP() BITSTACK_POP(cond_stack)
115 #define COND_LEXPOP() BITSTACK_LEXPOP(cond_stack)
116 #define COND_P() BITSTACK_SET_P(cond_stack)
118 #define CMDARG_PUSH(n) BITSTACK_PUSH(cmdarg_stack, (n))
119 #define CMDARG_POP() BITSTACK_POP(cmdarg_stack)
120 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
121 #define CMDARG_P() BITSTACK_SET_P(cmdarg_stack)
134 struct local_vars *prev;
138 #define DVARS_INHERIT ((void*)1)
139 #define DVARS_TOPSCOPE NULL
140 #define DVARS_SPECIAL_P(tbl) (!POINTER_P(tbl))
141 #define POINTER_P(val) ((VALUE)(val) & ~(VALUE)3)
144 vtable_size(const struct vtable *tbl)
146 if (POINTER_P(tbl)) {
156 static struct vtable *
157 vtable_alloc(struct vtable *prev)
159 struct vtable *tbl = ALLOC(struct vtable);
162 tbl->tbl = ALLOC_N(ID, tbl->capa);
164 if (VTBL_DEBUG) printf("vtable_alloc: %p\n", (void *)tbl);
169 vtable_free(struct vtable *tbl)
171 if (VTBL_DEBUG)printf("vtable_free: %p\n", (void *)tbl);
172 if (POINTER_P(tbl)) {
181 vtable_add(struct vtable *tbl, ID id)
183 if (!POINTER_P(tbl)) {
184 rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
186 if (VTBL_DEBUG) printf("vtable_add: %p, %s\n", (void *)tbl, rb_id2name(id));
188 if (tbl->pos == tbl->capa) {
189 tbl->capa = tbl->capa * 2;
190 REALLOC_N(tbl->tbl, ID, tbl->capa);
192 tbl->tbl[tbl->pos++] = id;
196 vtable_included(const struct vtable * tbl, ID id)
200 if (POINTER_P(tbl)) {
201 for (i = 0; i < tbl->pos; i++) {
202 if (tbl->tbl[i] == id) {
212 typedef struct token_info {
217 struct token_info *next;
222 Structure of Lexer Buffer:
224 lex_pbeg tokp lex_p lex_pend
226 |-----------+--------------+------------|
230 struct parser_params {
234 YYSTYPE *parser_yylval;
237 NODE *parser_lex_strterm;
238 enum lex_state_e parser_lex_state;
239 stack_type parser_cond_stack;
240 stack_type parser_cmdarg_stack;
241 int parser_class_nest;
242 int parser_paren_nest;
244 int parser_in_single;
246 int parser_brace_nest;
247 int parser_compile_for_eval;
248 VALUE parser_cur_mid;
250 int parser_in_defined;
251 char *parser_tokenbuf;
255 VALUE parser_lex_input;
256 VALUE parser_lex_lastline;
257 VALUE parser_lex_nextline;
258 const char *parser_lex_pbeg;
259 const char *parser_lex_p;
260 const char *parser_lex_pend;
261 int parser_heredoc_end;
262 int parser_command_start;
263 NODE *parser_deferred_nodes;
264 long parser_lex_gets_ptr;
265 VALUE (*parser_lex_gets)(struct parser_params*,VALUE);
266 struct local_vars *parser_lvtbl;
267 int parser_ruby__end__seen;
270 char *parser_ruby_sourcefile; /* current source file */
271 int parser_ruby_sourceline; /* current line no. */
272 VALUE parser_ruby_sourcefile_string;
281 NODE *parser_eval_tree_begin;
282 NODE *parser_eval_tree;
287 int parser_token_info_enabled;
288 token_info *parser_token_info;
298 VALUE parsing_thread;
303 #define STR_NEW(p,n) rb_enc_str_new((p),(n),current_enc)
304 #define STR_NEW0() rb_enc_str_new(0,0,current_enc)
305 #define STR_NEW2(p) rb_enc_str_new((p),strlen(p),current_enc)
306 #define STR_NEW3(p,n,e,func) parser_str_new((p),(n),(e),(func),current_enc)
307 #define ENC_SINGLE(cr) ((cr)==ENC_CODERANGE_7BIT)
308 #define TOK_INTERN(mb) rb_intern3(tok(), toklen(), current_enc)
310 static int parser_yyerror(struct parser_params*, const char*);
311 #define yyerror(msg) parser_yyerror(parser, (msg))
313 #define lex_strterm (parser->parser_lex_strterm)
314 #define lex_state (parser->parser_lex_state)
315 #define cond_stack (parser->parser_cond_stack)
316 #define cmdarg_stack (parser->parser_cmdarg_stack)
317 #define class_nest (parser->parser_class_nest)
318 #define paren_nest (parser->parser_paren_nest)
319 #define lpar_beg (parser->parser_lpar_beg)
320 #define brace_nest (parser->parser_brace_nest)
321 #define in_single (parser->parser_in_single)
322 #define in_def (parser->parser_in_def)
323 #define compile_for_eval (parser->parser_compile_for_eval)
324 #define cur_mid (parser->parser_cur_mid)
325 #define in_defined (parser->parser_in_defined)
326 #define tokenbuf (parser->parser_tokenbuf)
327 #define tokidx (parser->parser_tokidx)
328 #define toksiz (parser->parser_toksiz)
329 #define tokline (parser->parser_tokline)
330 #define lex_input (parser->parser_lex_input)
331 #define lex_lastline (parser->parser_lex_lastline)
332 #define lex_nextline (parser->parser_lex_nextline)
333 #define lex_pbeg (parser->parser_lex_pbeg)
334 #define lex_p (parser->parser_lex_p)
335 #define lex_pend (parser->parser_lex_pend)
336 #define heredoc_end (parser->parser_heredoc_end)
337 #define command_start (parser->parser_command_start)
338 #define deferred_nodes (parser->parser_deferred_nodes)
339 #define lex_gets_ptr (parser->parser_lex_gets_ptr)
340 #define lex_gets (parser->parser_lex_gets)
341 #define lvtbl (parser->parser_lvtbl)
342 #define ruby__end__seen (parser->parser_ruby__end__seen)
343 #define ruby_sourceline (parser->parser_ruby_sourceline)
344 #define ruby_sourcefile (parser->parser_ruby_sourcefile)
345 #define ruby_sourcefile_string (parser->parser_ruby_sourcefile_string)
346 #define current_enc (parser->enc)
347 #define yydebug (parser->parser_yydebug)
350 #define ruby_eval_tree (parser->parser_eval_tree)
351 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin)
352 #define ruby_debug_lines (parser->debug_lines)
353 #define ruby_coverage (parser->coverage)
357 static int yylex(void*, void*);
359 static int yylex(void*);
363 #define yyparse ruby_yyparse
365 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
366 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
368 static NODE *cond_gen(struct parser_params*,NODE*);
369 #define cond(node) cond_gen(parser, (node))
370 static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*);
371 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
373 static NODE *newline_node(NODE*);
374 static void fixpos(NODE*,NODE*);
376 static int value_expr_gen(struct parser_params*,NODE*);
377 static void void_expr_gen(struct parser_params*,NODE*);
378 static NODE *remove_begin(NODE*);
379 static NODE *remove_begin_all(NODE*);
380 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
381 #define void_expr0(node) void_expr_gen(parser, (node))
382 #define void_expr(node) void_expr0((node) = remove_begin(node))
383 static void void_stmts_gen(struct parser_params*,NODE*);
384 #define void_stmts(node) void_stmts_gen(parser, (node))
385 static void reduce_nodes_gen(struct parser_params*,NODE**);
386 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
387 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
388 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
390 static NODE *block_append_gen(struct parser_params*,NODE*,NODE*);
391 #define block_append(h,t) block_append_gen(parser,(h),(t))
392 static NODE *list_append_gen(struct parser_params*,NODE*,NODE*);
393 #define list_append(l,i) list_append_gen(parser,(l),(i))
394 static NODE *list_concat_gen(struct parser_params*,NODE*,NODE*);
395 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
396 static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*);
397 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
398 static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*);
399 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
400 static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*);
401 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
402 static int literal_concat0(struct parser_params *, VALUE, VALUE);
403 static NODE *new_evstr_gen(struct parser_params*,NODE*);
404 #define new_evstr(n) new_evstr_gen(parser,(n))
405 static NODE *evstr2dstr_gen(struct parser_params*,NODE*);
406 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
407 static NODE *splat_array(NODE*);
409 static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*);
410 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
411 static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID);
412 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
414 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
415 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
416 static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID);
417 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
419 static NODE *negate_lit(NODE*);
420 static NODE *ret_args_gen(struct parser_params*,NODE*);
421 #define ret_args(node) ret_args_gen(parser, (node))
422 static NODE *arg_blk_pass(NODE*,NODE*);
423 static NODE *new_yield_gen(struct parser_params*,NODE*);
424 #define new_yield(node) new_yield_gen(parser, (node))
425 static NODE *dsym_node_gen(struct parser_params*,NODE*);
426 #define dsym_node(node) dsym_node_gen(parser, (node))
428 static NODE *gettable_gen(struct parser_params*,ID);
429 #define gettable(id) gettable_gen(parser,(id))
430 static NODE *assignable_gen(struct parser_params*,ID,NODE*);
431 #define assignable(id,node) assignable_gen(parser, (id), (node))
433 static NODE *aryset_gen(struct parser_params*,NODE*,NODE*);
434 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
435 static NODE *attrset_gen(struct parser_params*,NODE*,ID);
436 #define attrset(node,id) attrset_gen(parser, (node), (id))
438 static void rb_backref_error_gen(struct parser_params*,NODE*);
439 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
440 static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*);
441 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
443 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
444 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
445 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
446 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
447 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
449 #define new_defined(expr) NEW_DEFINED(remove_begin_all(expr))
451 static NODE *match_op_gen(struct parser_params*,NODE*,NODE*);
452 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
454 static ID *local_tbl_gen(struct parser_params*);
455 #define local_tbl() local_tbl_gen(parser)
457 static void fixup_nodes(NODE **);
459 static VALUE reg_compile_gen(struct parser_params*, VALUE, int);
460 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
461 static void reg_fragment_setenc_gen(struct parser_params*, VALUE, int);
462 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
463 static int reg_fragment_check_gen(struct parser_params*, VALUE, int);
464 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
465 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
466 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
468 #define get_id(id) (id)
469 #define get_value(val) (val)
471 #define value_expr(node) ((void)(node))
472 #define remove_begin(node) (node)
473 #define rb_dvar_defined(id) 0
474 #define rb_local_defined(id) 0
475 static ID ripper_get_id(VALUE);
476 #define get_id(id) ripper_get_id(id)
477 static VALUE ripper_get_value(VALUE);
478 #define get_value(val) ripper_get_value(val)
479 static VALUE assignable_gen(struct parser_params*,VALUE);
480 #define assignable(lhs,node) assignable_gen(parser, (lhs))
481 static int id_is_var_gen(struct parser_params *parser, ID id);
482 #define id_is_var(id) id_is_var_gen(parser, (id))
484 #define node_assign(node1, node2) dispatch2(assign, (node1), (node2))
486 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
487 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);
488 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
492 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
494 static ID formal_argument_gen(struct parser_params*, ID);
495 #define formal_argument(id) formal_argument_gen(parser, (id))
496 static ID shadowing_lvar_gen(struct parser_params*,ID);
497 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
498 static void new_bv_gen(struct parser_params*,ID);
499 #define new_bv(id) new_bv_gen(parser, (id))
501 static void local_push_gen(struct parser_params*,int);
502 #define local_push(top) local_push_gen(parser,(top))
503 static void local_pop_gen(struct parser_params*);
504 #define local_pop() local_pop_gen(parser)
505 static int local_var_gen(struct parser_params*, ID);
506 #define local_var(id) local_var_gen(parser, (id))
507 static int arg_var_gen(struct parser_params*, ID);
508 #define arg_var(id) arg_var_gen(parser, (id))
509 static int local_id_gen(struct parser_params*, ID);
510 #define local_id(id) local_id_gen(parser, (id))
511 static ID internal_id_gen(struct parser_params*);
512 #define internal_id() internal_id_gen(parser)
514 static const struct vtable *dyna_push_gen(struct parser_params *);
515 #define dyna_push() dyna_push_gen(parser)
516 static void dyna_pop_gen(struct parser_params*, const struct vtable *);
517 #define dyna_pop(node) dyna_pop_gen(parser, (node))
518 static int dyna_in_block_gen(struct parser_params*);
519 #define dyna_in_block() dyna_in_block_gen(parser)
520 #define dyna_var(id) local_var(id)
521 static int dvar_defined_gen(struct parser_params*,ID,int);
522 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
523 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
524 static int dvar_curr_gen(struct parser_params*,ID);
525 #define dvar_curr(id) dvar_curr_gen(parser, (id))
527 static int lvar_defined_gen(struct parser_params*, ID);
528 #define lvar_defined(id) lvar_defined_gen(parser, (id))
530 #define RE_OPTION_ONCE (1<<16)
531 #define RE_OPTION_ENCODING_SHIFT 8
532 #define RE_OPTION_ENCODING(e) (((e)&0xff)<<RE_OPTION_ENCODING_SHIFT)
533 #define RE_OPTION_ENCODING_IDX(o) (((o)>>RE_OPTION_ENCODING_SHIFT)&0xff)
534 #define RE_OPTION_ENCODING_NONE(o) ((o)&RE_OPTION_ARG_ENCODING_NONE)
535 #define RE_OPTION_MASK 0xff
536 #define RE_OPTION_ARG_ENCODING_NONE 32
538 #define NODE_STRTERM NODE_ZARRAY /* nothing to gc */
539 #define NODE_HEREDOC NODE_ARRAY /* 1, 3 to gc */
540 #define SIGN_EXTEND(x,n) (((1<<(n)-1)^((x)&~(~0<<(n))))-(1<<(n)-1))
541 #define nd_func u1.id
542 #if SIZEOF_SHORT == 2
543 #define nd_term(node) ((signed short)(node)->u2.id)
545 #define nd_term(node) SIGN_EXTEND((node)->u2.id, CHAR_BIT*2)
547 #define nd_paren(node) (char)((node)->u2.id >> CHAR_BIT*2)
548 #define nd_nest u3.cnt
550 /****** Ripper *******/
553 #define RIPPER_VERSION "0.1.0"
555 #include "eventids1.c"
556 #include "eventids2.c"
558 static VALUE ripper_dispatch0(struct parser_params*,ID);
559 static VALUE ripper_dispatch1(struct parser_params*,ID,VALUE);
560 static VALUE ripper_dispatch2(struct parser_params*,ID,VALUE,VALUE);
561 static VALUE ripper_dispatch3(struct parser_params*,ID,VALUE,VALUE,VALUE);
562 static VALUE ripper_dispatch4(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE);
563 static VALUE ripper_dispatch5(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE);
564 static VALUE ripper_dispatch7(struct parser_params*,ID,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE);
566 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
567 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
568 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
569 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
570 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
571 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
572 #define dispatch7(n,a,b,c,d,e,f,g) ripper_dispatch7(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e), (f), (g))
574 #define yyparse ripper_yyparse
576 #define ripper_intern(s) ID2SYM(rb_intern(s))
577 static VALUE ripper_id2sym(ID);
579 #define ripper_id2sym(id) ((id) < 256 && rb_ispunct(id) ? \
580 ID2SYM(id) : ripper_id2sym(id))
583 #define arg_new() dispatch0(args_new)
584 #define arg_add(l,a) dispatch2(args_add, (l), (a))
585 #define arg_add_star(l,a) dispatch2(args_add_star, (l), (a))
586 #define arg_add_block(l,b) dispatch2(args_add_block, (l), (b))
587 #define arg_add_optblock(l,b) ((b)==Qundef? (l) : dispatch2(args_add_block, (l), (b)))
588 #define bare_assoc(v) dispatch1(bare_assoc_hash, (v))
589 #define arg_add_assocs(l,b) arg_add((l), bare_assoc(b))
591 #define args2mrhs(a) dispatch1(mrhs_new_from_args, (a))
592 #define mrhs_new() dispatch0(mrhs_new)
593 #define mrhs_add(l,a) dispatch2(mrhs_add, (l), (a))
594 #define mrhs_add_star(l,a) dispatch2(mrhs_add_star, (l), (a))
596 #define mlhs_new() dispatch0(mlhs_new)
597 #define mlhs_add(l,a) dispatch2(mlhs_add, (l), (a))
598 #define mlhs_add_star(l,a) dispatch2(mlhs_add_star, (l), (a))
600 #define params_new(pars, opts, rest, pars2, kws, kwrest, blk) \
601 dispatch7(params, (pars), (opts), (rest), (pars2), (kws), (kwrest), (blk))
603 #define blockvar_new(p,v) dispatch2(block_var, (p), (v))
604 #define blockvar_add_star(l,a) dispatch2(block_var_add_star, (l), (a))
605 #define blockvar_add_block(l,a) dispatch2(block_var_add_block, (l), (a))
607 #define method_optarg(m,a) ((a)==Qundef ? (m) : dispatch2(method_add_arg,(m),(a)))
608 #define method_arg(m,a) dispatch2(method_add_arg,(m),(a))
609 #define method_add_block(m,b) dispatch2(method_add_block, (m), (b))
611 #define escape_Qundef(x) ((x)==Qundef ? Qnil : (x))
614 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
616 NODE *t = (NODE *)tail;
617 VALUE k = t->u1.value, kr = t->u2.value, b = t->u3.value;
618 return params_new(f, o, r, p, k, kr, escape_Qundef(b));
620 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
623 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
625 return (VALUE)rb_node_newnode(NODE_MEMO, k, kr, b);
627 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
629 #define new_defined(expr) dispatch1(defined, (expr))
637 # define ifndef_ripper(x) (x)
640 # define ifndef_ripper(x)
644 # define rb_warn0(fmt) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt))
645 # define rb_warnI(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
646 # define rb_warnS(fmt,a) rb_compile_warn(ruby_sourcefile, ruby_sourceline, (fmt), (a))
647 # define rb_warn4S(file,line,fmt,a) rb_compile_warn((file), (line), (fmt), (a))
648 # define rb_warning0(fmt) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt))
649 # define rb_warningS(fmt,a) rb_compile_warning(ruby_sourcefile, ruby_sourceline, (fmt), (a))
651 # define rb_warn0(fmt) ripper_warn0(parser, (fmt))
652 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))
653 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))
654 # define rb_warn4S(file,line,fmt,a) ripper_warnS(parser, (fmt), (a))
655 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
656 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
657 static void ripper_warn0(struct parser_params*, const char*);
658 static void ripper_warnI(struct parser_params*, const char*, int);
659 static void ripper_warnS(struct parser_params*, const char*, const char*);
660 static void ripper_warning0(struct parser_params*, const char*);
661 static void ripper_warningS(struct parser_params*, const char*, const char*);
665 static void ripper_compile_error(struct parser_params*, const char *fmt, ...);
666 # define rb_compile_error ripper_compile_error
667 # define compile_error ripper_compile_error
668 # define PARSER_ARG parser,
670 # define rb_compile_error rb_compile_error_with_enc
671 # define compile_error parser->nerr++,rb_compile_error_with_enc
672 # define PARSER_ARG ruby_sourcefile, ruby_sourceline, current_enc,
675 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
676 for instance). This is too low for Ruby to parse some files, such as
677 date/format.rb, therefore bump the value up to at least Bison's default. */
680 #define YYMAXDEPTH 10000
685 static void token_info_push(struct parser_params*, const char *token);
686 static void token_info_pop(struct parser_params*, const char *token);
687 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
688 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
690 #define token_info_push(token) /* nothing */
691 #define token_info_pop(token) /* nothing */
696 %lex-param {struct parser_params *parser}
697 %parse-param {struct parser_params *parser}
704 const struct vtable *vars;
762 %token <val> tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tCVAR tLABEL
763 %token <val> tINTEGER tFLOAT tRATIONAL tIMAGINARY tSTRING_CONTENT tCHAR
764 %token <val> tNTH_REF tBACK_REF
765 %token <val> tREGEXP_END
767 %type <val> singleton strings string string1 xstring regexp
768 %type <val> string_contents xstring_contents regexp_contents string_content
769 %type <val> words symbols symbol_list qwords qsymbols word_list qword_list qsym_list word
770 %type <val> literal numeric simple_numeric dsym cpath
771 %type <val> top_compstmt top_stmts top_stmt
772 %type <val> bodystmt compstmt stmts stmt_or_begin stmt expr arg primary command command_call method_call
773 %type <val> expr_value arg_value primary_value fcall
774 %type <val> if_tail opt_else case_body cases opt_rescue exc_list exc_var opt_ensure
775 %type <val> args call_args opt_call_args
776 %type <val> paren_args opt_paren_args args_tail opt_args_tail block_args_tail opt_block_args_tail
777 %type <val> command_args aref_args opt_block_arg block_arg var_ref var_lhs
778 %type <val> command_asgn mrhs mrhs_arg superclass block_call block_command
779 %type <val> f_block_optarg f_block_opt
780 %type <val> f_arglist f_args f_arg f_arg_item f_optarg f_marg f_marg_list f_margs
781 %type <val> assoc_list assocs assoc undef_list backref string_dvar for_var
782 %type <val> block_param opt_block_param block_param_def f_opt
783 %type <val> f_kwarg f_kw f_block_kwarg f_block_kw
784 %type <val> bv_decls opt_bv_decl bvar
785 %type <val> lambda f_larglist lambda_body
786 %type <val> brace_block cmd_brace_block do_block lhs none fitem
787 %type <val> mlhs mlhs_head mlhs_basic mlhs_item mlhs_node mlhs_post mlhs_inner
788 %type <val> fsym keyword_variable user_variable sym symbol operation operation2 operation3
789 %type <val> cname fname op f_rest_arg f_block_arg opt_f_block_arg f_norm_arg f_bad_arg
790 %type <val> f_kwrest f_label
793 %type <val> program reswords then do dot_or_colon
795 %token END_OF_INPUT 0 "end-of-input"
796 %token tUPLUS 130 "unary+"
797 %token tUMINUS 131 "unary-"
799 %token tCMP 134 "<=>"
801 %token tEQQ 140 "==="
807 %token tMATCH 142 "=~"
808 %token tNMATCH 143 "!~"
809 %token tDOT2 128 ".."
810 %token tDOT3 129 "..."
811 %token tAREF 144 "[]"
812 %token tASET 145 "[]="
813 %token tLSHFT 135 "<<"
814 %token tRSHFT 136 ">>"
816 %token tCOLON3 ":: at EXPR_BEG"
817 %token <val> tOP_ASGN /* +=, -= etc. */
820 %token tLPAREN_ARG "( arg"
824 %token tLBRACE_ARG "{ arg"
826 %token tDSTAR "**arg"
829 %token tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG tWORDS_BEG tQWORDS_BEG tSYMBOLS_BEG tQSYMBOLS_BEG
830 %token tSTRING_DBEG tSTRING_DEND tSTRING_DVAR tSTRING_END tLAMBEG
837 %nonassoc tLBRACE_ARG
839 %nonassoc modifier_if modifier_unless modifier_while modifier_until
840 %left keyword_or keyword_and
842 %nonassoc keyword_defined
844 %left modifier_rescue
846 %nonassoc tDOT2 tDOT3
849 %nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
850 %left '>' tGEQ '<' tLEQ
856 %right tUMINUS_NUM tUMINUS
858 %right '!' '~' tUPLUS
864 lex_state = EXPR_BEG;
866 local_push(compile_for_eval || rb_parse_in_main());
874 if ($2 && !compile_for_eval) {
875 /* last expression should not be void */
876 if (nd_type($2) != NODE_BLOCK) void_expr($2);
879 while (node->nd_next) {
880 node = node->nd_next;
882 void_expr(node->nd_head);
885 ruby_eval_tree = NEW_SCOPE(0, block_append(ruby_eval_tree, $2));
888 parser->result = dispatch1(program, $$);
894 top_compstmt : top_stmts opt_terms
898 fixup_nodes(&deferred_nodes);
910 $$ = dispatch2(stmts_add, dispatch0(stmts_new),
911 dispatch0(void_stmt));
917 $$ = newline_node($1);
919 $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
922 | top_stmts terms top_stmt
925 $$ = block_append($1, newline_node($3));
927 $$ = dispatch2(stmts_add, $1, $3);
932 $$ = remove_begin($2);
947 ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
949 /* NEW_PREEXE($4)); */
953 $$ = dispatch1(BEGIN, $4);
966 $$ = NEW_RESCUE($1, $2, $3);
969 rb_warn0("else without rescue is useless");
970 $$ = block_append($$, $3);
974 $$ = NEW_ENSURE($$, $4);
977 $$ = block_append($4, NEW_NIL());
982 $$ = dispatch4(bodystmt,
991 compstmt : stmts opt_terms
995 fixup_nodes(&deferred_nodes);
1007 $$ = dispatch2(stmts_add, dispatch0(stmts_new),
1008 dispatch0(void_stmt));
1014 $$ = newline_node($1);
1016 $$ = dispatch2(stmts_add, dispatch0(stmts_new), $1);
1019 | stmts terms stmt_or_begin
1022 $$ = block_append($1, newline_node($3));
1024 $$ = dispatch2(stmts_add, $1, $3);
1029 $$ = remove_begin($2);
1033 stmt_or_begin : stmt
1039 yyerror("BEGIN is permitted only at toplevel");
1041 /* local_push(0); */
1045 '{' top_compstmt '}'
1048 ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
1050 /* NEW_PREEXE($4)); */
1054 $$ = dispatch1(BEGIN, $4);
1058 stmt : keyword_alias fitem {lex_state = EXPR_FNAME;} fitem
1061 $$ = NEW_ALIAS($2, $4);
1063 $$ = dispatch2(alias, $2, $4);
1066 | keyword_alias tGVAR tGVAR
1069 $$ = NEW_VALIAS($2, $3);
1071 $$ = dispatch2(var_alias, $2, $3);
1074 | keyword_alias tGVAR tBACK_REF
1079 buf[1] = (char)$3->nd_nth;
1080 $$ = NEW_VALIAS($2, rb_intern2(buf, 2));
1082 $$ = dispatch2(var_alias, $2, $3);
1085 | keyword_alias tGVAR tNTH_REF
1088 yyerror("can't make alias for the number variables");
1091 $$ = dispatch2(var_alias, $2, $3);
1092 $$ = dispatch1(alias_error, $$);
1095 | keyword_undef undef_list
1100 $$ = dispatch1(undef, $2);
1103 | stmt modifier_if expr_value
1106 $$ = NEW_IF(cond($3), remove_begin($1), 0);
1109 $$ = dispatch2(if_mod, $3, $1);
1112 | stmt modifier_unless expr_value
1115 $$ = NEW_UNLESS(cond($3), remove_begin($1), 0);
1118 $$ = dispatch2(unless_mod, $3, $1);
1121 | stmt modifier_while expr_value
1124 if ($1 && nd_type($1) == NODE_BEGIN) {
1125 $$ = NEW_WHILE(cond($3), $1->nd_body, 0);
1128 $$ = NEW_WHILE(cond($3), $1, 1);
1131 $$ = dispatch2(while_mod, $3, $1);
1134 | stmt modifier_until expr_value
1137 if ($1 && nd_type($1) == NODE_BEGIN) {
1138 $$ = NEW_UNTIL(cond($3), $1->nd_body, 0);
1141 $$ = NEW_UNTIL(cond($3), $1, 1);
1144 $$ = dispatch2(until_mod, $3, $1);
1147 | stmt modifier_rescue stmt
1150 NODE *resq = NEW_RESBODY(0, remove_begin($3), 0);
1151 $$ = NEW_RESCUE(remove_begin($1), resq, 0);
1153 $$ = dispatch2(rescue_mod, $1, $3);
1156 | keyword_END '{' compstmt '}'
1158 if (in_def || in_single) {
1159 rb_warn0("END in method; use at_exit");
1162 $$ = NEW_POSTEXE(NEW_NODE(
1163 NODE_SCOPE, 0 /* tbl */, $3 /* body */, 0 /* args */));
1165 $$ = dispatch1(END, $3);
1169 | mlhs '=' command_call
1176 $$ = dispatch2(massign, $1, $3);
1179 | var_lhs tOP_ASGN command_call
1182 $$ = new_op_assign($1, $2, $3);
1184 | primary_value '[' opt_call_args rbracket tOP_ASGN command_call
1190 if (!$3) $3 = NEW_ZARRAY();
1191 args = arg_concat($3, $6);
1195 else if ($5 == tANDOP) {
1198 $$ = NEW_OP_ASGN1($1, $5, args);
1201 $$ = dispatch2(aref_field, $1, escape_Qundef($3));
1202 $$ = dispatch3(opassign, $$, $5, $6);
1205 | primary_value '.' tIDENTIFIER tOP_ASGN command_call
1208 $$ = new_attr_op_assign($1, ripper_id2sym('.'), $3, $4, $5);
1210 | primary_value '.' tCONSTANT tOP_ASGN command_call
1213 $$ = new_attr_op_assign($1, ripper_id2sym('.'), $3, $4, $5);
1215 | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
1218 $$ = NEW_COLON2($1, $3);
1219 $$ = new_const_op_assign($$, $4, $5);
1221 $$ = dispatch2(const_path_field, $1, $3);
1222 $$ = dispatch3(opassign, $$, $4, $5);
1225 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
1228 $$ = new_attr_op_assign($1, ripper_intern("::"), $3, $4, $5);
1230 | backref tOP_ASGN command_call
1233 rb_backref_error($1);
1236 $$ = dispatch2(assign, dispatch1(var_field, $1), $3);
1237 $$ = dispatch1(assign_error, $$);
1244 $$ = node_assign($1, $3);
1246 $$ = dispatch2(assign, $1, $3);
1255 $$ = dispatch2(massign, $1, $3);
1261 command_asgn : lhs '=' command_call
1265 $$ = node_assign($1, $3);
1267 $$ = dispatch2(assign, $1, $3);
1270 | lhs '=' command_asgn
1274 $$ = node_assign($1, $3);
1276 $$ = dispatch2(assign, $1, $3);
1283 | expr keyword_and expr
1286 $$ = logop(NODE_AND, $1, $3);
1288 $$ = dispatch3(binary, $1, ripper_intern("and"), $3);
1291 | expr keyword_or expr
1294 $$ = logop(NODE_OR, $1, $3);
1296 $$ = dispatch3(binary, $1, ripper_intern("or"), $3);
1299 | keyword_not opt_nl expr
1302 $$ = call_uni_op(cond($3), '!');
1304 $$ = dispatch2(unary, ripper_intern("not"), $3);
1310 $$ = call_uni_op(cond($2), '!');
1312 $$ = dispatch2(unary, ripper_id2sym('!'), $2);
1323 if (!$$) $$ = NEW_NIL();
1330 command_call : command
1334 block_command : block_call
1335 | block_call dot_or_colon operation2 command_args
1338 $$ = NEW_CALL($1, $3, $4);
1340 $$ = dispatch3(call, $1, $2, $3);
1341 $$ = method_arg($$, $4);
1346 cmd_brace_block : tLBRACE_ARG
1348 $<vars>1 = dyna_push();
1350 $<num>$ = ruby_sourceline;
1359 $$ = NEW_ITER($3,$4);
1360 nd_set_line($$, $<num>2);
1362 $$ = dispatch2(brace_block, escape_Qundef($3), $4);
1371 $$ = NEW_FCALL($1, 0);
1372 nd_set_line($$, tokline);
1378 command : fcall command_args %prec tLOWEST
1384 $$ = dispatch2(command, $1, $2);
1387 | fcall command_args cmd_brace_block
1390 block_dup_check($2,$3);
1396 $$ = dispatch2(command, $1, $2);
1397 $$ = method_add_block($$, $3);
1400 | primary_value '.' operation2 command_args %prec tLOWEST
1403 $$ = NEW_CALL($1, $3, $4);
1406 $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
1409 | primary_value '.' operation2 command_args cmd_brace_block
1412 block_dup_check($4,$5);
1413 $5->nd_iter = NEW_CALL($1, $3, $4);
1417 $$ = dispatch4(command_call, $1, ripper_id2sym('.'), $3, $4);
1418 $$ = method_add_block($$, $5);
1421 | primary_value tCOLON2 operation2 command_args %prec tLOWEST
1424 $$ = NEW_CALL($1, $3, $4);
1427 $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
1430 | primary_value tCOLON2 operation2 command_args cmd_brace_block
1433 block_dup_check($4,$5);
1434 $5->nd_iter = NEW_CALL($1, $3, $4);
1438 $$ = dispatch4(command_call, $1, ripper_intern("::"), $3, $4);
1439 $$ = method_add_block($$, $5);
1442 | keyword_super command_args
1448 $$ = dispatch1(super, $2);
1451 | keyword_yield command_args
1457 $$ = dispatch1(yield, $2);
1460 | keyword_return call_args
1463 $$ = NEW_RETURN(ret_args($2));
1465 $$ = dispatch1(return, $2);
1468 | keyword_break call_args
1471 $$ = NEW_BREAK(ret_args($2));
1473 $$ = dispatch1(break, $2);
1476 | keyword_next call_args
1479 $$ = NEW_NEXT(ret_args($2));
1481 $$ = dispatch1(next, $2);
1487 | tLPAREN mlhs_inner rparen
1492 $$ = dispatch1(mlhs_paren, $2);
1497 mlhs_inner : mlhs_basic
1498 | tLPAREN mlhs_inner rparen
1501 $$ = NEW_MASGN(NEW_LIST($2), 0);
1503 $$ = dispatch1(mlhs_paren, $2);
1508 mlhs_basic : mlhs_head
1511 $$ = NEW_MASGN($1, 0);
1516 | mlhs_head mlhs_item
1519 $$ = NEW_MASGN(list_append($1,$2), 0);
1521 $$ = mlhs_add($1, $2);
1524 | mlhs_head tSTAR mlhs_node
1527 $$ = NEW_MASGN($1, $3);
1529 $$ = mlhs_add_star($1, $3);
1532 | mlhs_head tSTAR mlhs_node ',' mlhs_post
1535 $$ = NEW_MASGN($1, NEW_POSTARG($3,$5));
1537 $1 = mlhs_add_star($1, $3);
1538 $$ = mlhs_add($1, $5);
1544 $$ = NEW_MASGN($1, -1);
1546 $$ = mlhs_add_star($1, Qnil);
1549 | mlhs_head tSTAR ',' mlhs_post
1552 $$ = NEW_MASGN($1, NEW_POSTARG(-1, $4));
1554 $1 = mlhs_add_star($1, Qnil);
1555 $$ = mlhs_add($1, $4);
1561 $$ = NEW_MASGN(0, $2);
1563 $$ = mlhs_add_star(mlhs_new(), $2);
1566 | tSTAR mlhs_node ',' mlhs_post
1569 $$ = NEW_MASGN(0, NEW_POSTARG($2,$4));
1571 $2 = mlhs_add_star(mlhs_new(), $2);
1572 $$ = mlhs_add($2, $4);
1578 $$ = NEW_MASGN(0, -1);
1580 $$ = mlhs_add_star(mlhs_new(), Qnil);
1583 | tSTAR ',' mlhs_post
1586 $$ = NEW_MASGN(0, NEW_POSTARG(-1, $3));
1588 $$ = mlhs_add_star(mlhs_new(), Qnil);
1589 $$ = mlhs_add($$, $3);
1594 mlhs_item : mlhs_node
1595 | tLPAREN mlhs_inner rparen
1600 $$ = dispatch1(mlhs_paren, $2);
1605 mlhs_head : mlhs_item ','
1610 $$ = mlhs_add(mlhs_new(), $1);
1613 | mlhs_head mlhs_item ','
1616 $$ = list_append($1, $2);
1618 $$ = mlhs_add($1, $2);
1623 mlhs_post : mlhs_item
1628 $$ = mlhs_add(mlhs_new(), $1);
1631 | mlhs_post ',' mlhs_item
1634 $$ = list_append($1, $3);
1636 $$ = mlhs_add($1, $3);
1641 mlhs_node : user_variable
1643 $$ = assignable($1, 0);
1647 $$ = assignable($1, 0);
1649 | primary_value '[' opt_call_args rbracket
1652 $$ = aryset($1, $3);
1654 $$ = dispatch2(aref_field, $1, escape_Qundef($3));
1657 | primary_value '.' tIDENTIFIER
1660 $$ = attrset($1, $3);
1662 $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
1665 | primary_value tCOLON2 tIDENTIFIER
1668 $$ = attrset($1, $3);
1670 $$ = dispatch2(const_path_field, $1, $3);
1673 | primary_value '.' tCONSTANT
1676 $$ = attrset($1, $3);
1678 $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
1681 | primary_value tCOLON2 tCONSTANT
1684 if (in_def || in_single)
1685 yyerror("dynamic constant assignment");
1686 $$ = NEW_CDECL(0, 0, NEW_COLON2($1, $3));
1688 if (in_def || in_single)
1689 yyerror("dynamic constant assignment");
1690 $$ = dispatch2(const_path_field, $1, $3);
1696 if (in_def || in_single)
1697 yyerror("dynamic constant assignment");
1698 $$ = NEW_CDECL(0, 0, NEW_COLON3($2));
1700 $$ = dispatch1(top_const_field, $2);
1706 rb_backref_error($1);
1709 $$ = dispatch1(var_field, $1);
1710 $$ = dispatch1(assign_error, $$);
1717 $$ = assignable($1, 0);
1719 if (!$$) $$ = NEW_BEGIN(0);
1721 $$ = dispatch1(var_field, $$);
1726 $$ = assignable($1, 0);
1728 if (!$$) $$ = NEW_BEGIN(0);
1730 $$ = dispatch1(var_field, $$);
1733 | primary_value '[' opt_call_args rbracket
1736 $$ = aryset($1, $3);
1738 $$ = dispatch2(aref_field, $1, escape_Qundef($3));
1741 | primary_value '.' tIDENTIFIER
1744 $$ = attrset($1, $3);
1746 $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
1749 | primary_value tCOLON2 tIDENTIFIER
1752 $$ = attrset($1, $3);
1754 $$ = dispatch3(field, $1, ripper_intern("::"), $3);
1757 | primary_value '.' tCONSTANT
1760 $$ = attrset($1, $3);
1762 $$ = dispatch3(field, $1, ripper_id2sym('.'), $3);
1765 | primary_value tCOLON2 tCONSTANT
1768 if (in_def || in_single)
1769 yyerror("dynamic constant assignment");
1770 $$ = NEW_CDECL(0, 0, NEW_COLON2($1, $3));
1772 $$ = dispatch2(const_path_field, $1, $3);
1773 if (in_def || in_single) {
1774 $$ = dispatch1(assign_error, $$);
1781 if (in_def || in_single)
1782 yyerror("dynamic constant assignment");
1783 $$ = NEW_CDECL(0, 0, NEW_COLON3($2));
1785 $$ = dispatch1(top_const_field, $2);
1786 if (in_def || in_single) {
1787 $$ = dispatch1(assign_error, $$);
1794 rb_backref_error($1);
1797 $$ = dispatch1(assign_error, $1);
1805 yyerror("class/module name must be CONSTANT");
1807 $$ = dispatch1(class_name_error, $1);
1813 cpath : tCOLON3 cname
1816 $$ = NEW_COLON3($2);
1818 $$ = dispatch1(top_const_ref, $2);
1824 $$ = NEW_COLON2(0, $$);
1826 $$ = dispatch1(const_ref, $1);
1829 | primary_value tCOLON2 cname
1832 $$ = NEW_COLON2($1, $3);
1834 $$ = dispatch2(const_path_ref, $1, $3);
1844 lex_state = EXPR_ENDFN;
1849 lex_state = EXPR_ENDFN;
1865 $$ = NEW_LIT(ID2SYM($1));
1867 $$ = dispatch1(symbol_literal, $1);
1878 $$ = rb_ary_new3(1, $1);
1881 | undef_list ',' {lex_state = EXPR_FNAME;} fitem
1884 $$ = block_append($1, NEW_UNDEF($4));
1886 rb_ary_push($1, $4);
1891 op : '|' { ifndef_ripper($$ = '|'); }
1892 | '^' { ifndef_ripper($$ = '^'); }
1893 | '&' { ifndef_ripper($$ = '&'); }
1894 | tCMP { ifndef_ripper($$ = tCMP); }
1895 | tEQ { ifndef_ripper($$ = tEQ); }
1896 | tEQQ { ifndef_ripper($$ = tEQQ); }
1897 | tMATCH { ifndef_ripper($$ = tMATCH); }
1898 | tNMATCH { ifndef_ripper($$ = tNMATCH); }
1899 | '>' { ifndef_ripper($$ = '>'); }
1900 | tGEQ { ifndef_ripper($$ = tGEQ); }
1901 | '<' { ifndef_ripper($$ = '<'); }
1902 | tLEQ { ifndef_ripper($$ = tLEQ); }
1903 | tNEQ { ifndef_ripper($$ = tNEQ); }
1904 | tLSHFT { ifndef_ripper($$ = tLSHFT); }
1905 | tRSHFT { ifndef_ripper($$ = tRSHFT); }
1906 | '+' { ifndef_ripper($$ = '+'); }
1907 | '-' { ifndef_ripper($$ = '-'); }
1908 | '*' { ifndef_ripper($$ = '*'); }
1909 | tSTAR { ifndef_ripper($$ = '*'); }
1910 | '/' { ifndef_ripper($$ = '/'); }
1911 | '%' { ifndef_ripper($$ = '%'); }
1912 | tPOW { ifndef_ripper($$ = tPOW); }
1913 | tDSTAR { ifndef_ripper($$ = tDSTAR); }
1914 | '!' { ifndef_ripper($$ = '!'); }
1915 | '~' { ifndef_ripper($$ = '~'); }
1916 | tUPLUS { ifndef_ripper($$ = tUPLUS); }
1917 | tUMINUS { ifndef_ripper($$ = tUMINUS); }
1918 | tAREF { ifndef_ripper($$ = tAREF); }
1919 | tASET { ifndef_ripper($$ = tASET); }
1920 | '`' { ifndef_ripper($$ = '`'); }
1923 reswords : keyword__LINE__ | keyword__FILE__ | keyword__ENCODING__
1924 | keyword_BEGIN | keyword_END
1925 | keyword_alias | keyword_and | keyword_begin
1926 | keyword_break | keyword_case | keyword_class | keyword_def
1927 | keyword_defined | keyword_do | keyword_else | keyword_elsif
1928 | keyword_end | keyword_ensure | keyword_false
1929 | keyword_for | keyword_in | keyword_module | keyword_next
1930 | keyword_nil | keyword_not | keyword_or | keyword_redo
1931 | keyword_rescue | keyword_retry | keyword_return | keyword_self
1932 | keyword_super | keyword_then | keyword_true | keyword_undef
1933 | keyword_when | keyword_yield | keyword_if | keyword_unless
1934 | keyword_while | keyword_until
1941 $$ = node_assign($1, $3);
1943 $$ = dispatch2(assign, $1, $3);
1946 | lhs '=' arg modifier_rescue arg
1950 $3 = NEW_RESCUE($3, NEW_RESBODY(0,$5,0), 0);
1951 $$ = node_assign($1, $3);
1953 $$ = dispatch2(assign, $1, dispatch2(rescue_mod, $3, $5));
1956 | var_lhs tOP_ASGN arg
1959 $$ = new_op_assign($1, $2, $3);
1961 | var_lhs tOP_ASGN arg modifier_rescue arg
1965 $3 = NEW_RESCUE($3, NEW_RESBODY(0,$5,0), 0);
1967 $3 = dispatch2(rescue_mod, $3, $5);
1969 $$ = new_op_assign($1, $2, $3);
1971 | primary_value '[' opt_call_args rbracket tOP_ASGN arg
1977 if (!$3) $3 = NEW_ZARRAY();
1978 if (nd_type($3) == NODE_BLOCK_PASS) {
1979 args = NEW_ARGSCAT($3, $6);
1982 args = arg_concat($3, $6);
1987 else if ($5 == tANDOP) {
1990 $$ = NEW_OP_ASGN1($1, $5, args);
1993 $1 = dispatch2(aref_field, $1, escape_Qundef($3));
1994 $$ = dispatch3(opassign, $1, $5, $6);
1997 | primary_value '.' tIDENTIFIER tOP_ASGN arg
2000 $$ = new_attr_op_assign($1, ripper_id2sym('.'), $3, $4, $5);
2002 | primary_value '.' tCONSTANT tOP_ASGN arg
2005 $$ = new_attr_op_assign($1, ripper_id2sym('.'), $3, $4, $5);
2007 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
2010 $$ = new_attr_op_assign($1, ripper_intern("::"), $3, $4, $5);
2012 | primary_value tCOLON2 tCONSTANT tOP_ASGN arg
2015 $$ = NEW_COLON2($1, $3);
2016 $$ = new_const_op_assign($$, $4, $5);
2018 $$ = dispatch2(const_path_field, $1, $3);
2019 $$ = dispatch3(opassign, $$, $4, $5);
2022 | tCOLON3 tCONSTANT tOP_ASGN arg
2025 $$ = NEW_COLON3($2);
2026 $$ = new_const_op_assign($$, $3, $4);
2028 $$ = dispatch1(top_const_field, $2);
2029 $$ = dispatch3(opassign, $$, $3, $4);
2032 | backref tOP_ASGN arg
2035 rb_backref_error($1);
2038 $$ = dispatch1(var_field, $1);
2039 $$ = dispatch3(opassign, $$, $2, $3);
2040 $$ = dispatch1(assign_error, $$);
2048 $$ = NEW_DOT2($1, $3);
2049 if ($1 && nd_type($1) == NODE_LIT && FIXNUM_P($1->nd_lit) &&
2050 $3 && nd_type($3) == NODE_LIT && FIXNUM_P($3->nd_lit)) {
2051 deferred_nodes = list_append(deferred_nodes, $$);
2054 $$ = dispatch2(dot2, $1, $3);
2062 $$ = NEW_DOT3($1, $3);
2063 if ($1 && nd_type($1) == NODE_LIT && FIXNUM_P($1->nd_lit) &&
2064 $3 && nd_type($3) == NODE_LIT && FIXNUM_P($3->nd_lit)) {
2065 deferred_nodes = list_append(deferred_nodes, $$);
2068 $$ = dispatch2(dot3, $1, $3);
2074 $$ = call_bin_op($1, '+', $3);
2076 $$ = dispatch3(binary, $1, ID2SYM('+'), $3);
2082 $$ = call_bin_op($1, '-', $3);
2084 $$ = dispatch3(binary, $1, ID2SYM('-'), $3);
2090 $$ = call_bin_op($1, '*', $3);
2092 $$ = dispatch3(binary, $1, ID2SYM('*'), $3);
2098 $$ = call_bin_op($1, '/', $3);
2100 $$ = dispatch3(binary, $1, ID2SYM('/'), $3);
2106 $$ = call_bin_op($1, '%', $3);
2108 $$ = dispatch3(binary, $1, ID2SYM('%'), $3);
2114 $$ = call_bin_op($1, tPOW, $3);
2116 $$ = dispatch3(binary, $1, ripper_intern("**"), $3);
2119 | tUMINUS_NUM simple_numeric tPOW arg
2122 $$ = NEW_CALL(call_bin_op($2, tPOW, $4), tUMINUS, 0);
2124 $$ = dispatch3(binary, $2, ripper_intern("**"), $4);
2125 $$ = dispatch2(unary, ripper_intern("-@"), $$);
2131 $$ = call_uni_op($2, tUPLUS);
2133 $$ = dispatch2(unary, ripper_intern("+@"), $2);
2139 $$ = call_uni_op($2, tUMINUS);
2141 $$ = dispatch2(unary, ripper_intern("-@"), $2);
2147 $$ = call_bin_op($1, '|', $3);
2149 $$ = dispatch3(binary, $1, ID2SYM('|'), $3);
2155 $$ = call_bin_op($1, '^', $3);
2157 $$ = dispatch3(binary, $1, ID2SYM('^'), $3);
2163 $$ = call_bin_op($1, '&', $3);
2165 $$ = dispatch3(binary, $1, ID2SYM('&'), $3);
2171 $$ = call_bin_op($1, tCMP, $3);
2173 $$ = dispatch3(binary, $1, ripper_intern("<=>"), $3);
2179 $$ = call_bin_op($1, '>', $3);
2181 $$ = dispatch3(binary, $1, ID2SYM('>'), $3);
2187 $$ = call_bin_op($1, tGEQ, $3);
2189 $$ = dispatch3(binary, $1, ripper_intern(">="), $3);
2195 $$ = call_bin_op($1, '<', $3);
2197 $$ = dispatch3(binary, $1, ID2SYM('<'), $3);
2203 $$ = call_bin_op($1, tLEQ, $3);
2205 $$ = dispatch3(binary, $1, ripper_intern("<="), $3);
2211 $$ = call_bin_op($1, tEQ, $3);
2213 $$ = dispatch3(binary, $1, ripper_intern("=="), $3);
2219 $$ = call_bin_op($1, tEQQ, $3);
2221 $$ = dispatch3(binary, $1, ripper_intern("==="), $3);
2227 $$ = call_bin_op($1, tNEQ, $3);
2229 $$ = dispatch3(binary, $1, ripper_intern("!="), $3);
2235 $$ = match_op($1, $3);
2236 if (nd_type($1) == NODE_LIT && RB_TYPE_P($1->nd_lit, T_REGEXP)) {
2237 $$ = reg_named_capture_assign($1->nd_lit, $$);
2240 $$ = dispatch3(binary, $1, ripper_intern("=~"), $3);
2246 $$ = call_bin_op($1, tNMATCH, $3);
2248 $$ = dispatch3(binary, $1, ripper_intern("!~"), $3);
2254 $$ = call_uni_op(cond($2), '!');
2256 $$ = dispatch2(unary, ID2SYM('!'), $2);
2262 $$ = call_uni_op($2, '~');
2264 $$ = dispatch2(unary, ID2SYM('~'), $2);
2270 $$ = call_bin_op($1, tLSHFT, $3);
2272 $$ = dispatch3(binary, $1, ripper_intern("<<"), $3);
2278 $$ = call_bin_op($1, tRSHFT, $3);
2280 $$ = dispatch3(binary, $1, ripper_intern(">>"), $3);
2286 $$ = logop(NODE_AND, $1, $3);
2288 $$ = dispatch3(binary, $1, ripper_intern("&&"), $3);
2294 $$ = logop(NODE_OR, $1, $3);
2296 $$ = dispatch3(binary, $1, ripper_intern("||"), $3);
2299 | keyword_defined opt_nl {in_defined = 1;} arg
2303 $$ = new_defined($4);
2306 $$ = dispatch1(defined, $4);
2309 | arg '?' arg opt_nl ':' arg
2313 $$ = NEW_IF(cond($1), $3, $6);
2316 $$ = dispatch3(ifop, $1, $3, $6);
2330 if (!$$) $$ = NEW_NIL();
2342 | args ',' assocs trailer
2345 $$ = arg_append($1, NEW_HASH($3));
2347 $$ = arg_add_assocs($1, $3);
2353 $$ = NEW_LIST(NEW_HASH($1));
2355 $$ = arg_add_assocs(arg_new(), $1);
2360 paren_args : '(' opt_call_args rparen
2365 $$ = dispatch1(arg_paren, escape_Qundef($2));
2370 opt_paren_args : none
2374 opt_call_args : none
2380 | args ',' assocs ','
2383 $$ = arg_append($1, NEW_HASH($3));
2385 $$ = arg_add_assocs($1, $3);
2391 $$ = NEW_LIST(NEW_HASH($1));
2393 $$ = arg_add_assocs(arg_new(), $1);
2404 $$ = arg_add(arg_new(), $1);
2407 | args opt_block_arg
2410 $$ = arg_blk_pass($1, $2);
2412 $$ = arg_add_optblock($1, $2);
2415 | assocs opt_block_arg
2418 $$ = NEW_LIST(NEW_HASH($1));
2419 $$ = arg_blk_pass($$, $2);
2421 $$ = arg_add_assocs(arg_new(), $1);
2422 $$ = arg_add_optblock($$, $2);
2425 | args ',' assocs opt_block_arg
2428 $$ = arg_append($1, NEW_HASH($3));
2429 $$ = arg_blk_pass($$, $4);
2431 $$ = arg_add_optblock(arg_add_assocs($1, $3), $4);
2438 $$ = arg_add_block(arg_new(), $1);
2444 $<val>$ = cmdarg_stack;
2450 cmdarg_stack = $<val>1;
2455 block_arg : tAMPER arg_value
2458 $$ = NEW_BLOCK_PASS($2);
2465 opt_block_arg : ',' block_arg
2480 $$ = arg_add(arg_new(), $1);
2488 $$ = arg_add_star(arg_new(), $2);
2491 | args ',' arg_value
2495 if ((n1 = splat_array($1)) != 0) {
2496 $$ = list_append(n1, $3);
2499 $$ = arg_append($1, $3);
2502 $$ = arg_add($1, $3);
2505 | args ',' tSTAR arg_value
2509 if ((nd_type($4) == NODE_ARRAY) && (n1 = splat_array($1)) != 0) {
2510 $$ = list_concat(n1, $4);
2513 $$ = arg_concat($1, $4);
2516 $$ = arg_add_star($1, $4);
2525 mrhs : args ',' arg_value
2529 if ((n1 = splat_array($1)) != 0) {
2530 $$ = list_append(n1, $3);
2533 $$ = arg_append($1, $3);
2536 $$ = mrhs_add(args2mrhs($1), $3);
2539 | args ',' tSTAR arg_value
2543 if (nd_type($4) == NODE_ARRAY &&
2544 (n1 = splat_array($1)) != 0) {
2545 $$ = list_concat(n1, $4);
2548 $$ = arg_concat($1, $4);
2551 $$ = mrhs_add_star(args2mrhs($1), $4);
2559 $$ = mrhs_add_star(mrhs_new(), $2);
2577 $$ = NEW_FCALL($1, 0);
2579 $$ = method_arg(dispatch1(fcall, $1), arg_new());
2584 $<val>1 = cmdarg_stack;
2587 $<num>$ = ruby_sourceline;
2594 cmdarg_stack = $<val>1;
2600 if (nd_type($3) == NODE_RESCUE ||
2601 nd_type($3) == NODE_ENSURE)
2602 nd_set_line($3, $<num>2);
2605 nd_set_line($$, $<num>2);
2607 $$ = dispatch1(begin, $3);
2610 | tLPAREN_ARG {lex_state = EXPR_ENDARG;} rparen
2615 $$ = dispatch1(paren, 0);
2620 $<val>1 = cmdarg_stack;
2623 expr {lex_state = EXPR_ENDARG;} rparen
2625 cmdarg_stack = $<val>1;
2629 $$ = dispatch1(paren, $3);
2632 | tLPAREN compstmt ')'
2637 $$ = dispatch1(paren, $2);
2640 | primary_value tCOLON2 tCONSTANT
2643 $$ = NEW_COLON2($1, $3);
2645 $$ = dispatch2(const_path_ref, $1, $3);
2651 $$ = NEW_COLON3($2);
2653 $$ = dispatch1(top_const_ref, $2);
2656 | tLBRACK aref_args ']'
2660 $$ = NEW_ZARRAY(); /* zero length array*/
2666 $$ = dispatch1(array, escape_Qundef($2));
2669 | tLBRACE assoc_list '}'
2674 $$ = dispatch1(hash, escape_Qundef($2));
2682 $$ = dispatch0(return0);
2685 | keyword_yield '(' call_args rparen
2690 $$ = dispatch1(yield, dispatch1(paren, $3));
2693 | keyword_yield '(' rparen
2698 $$ = dispatch1(yield, dispatch1(paren, arg_new()));
2706 $$ = dispatch0(yield0);
2709 | keyword_defined opt_nl '(' {in_defined = 1;} expr rparen
2713 $$ = new_defined($5);
2716 $$ = dispatch1(defined, $5);
2719 | keyword_not '(' expr rparen
2722 $$ = call_uni_op(cond($3), '!');
2724 $$ = dispatch2(unary, ripper_intern("not"), $3);
2727 | keyword_not '(' rparen
2730 $$ = call_uni_op(cond(NEW_NIL()), '!');
2732 $$ = dispatch2(unary, ripper_intern("not"), Qnil);
2741 $$ = method_arg(dispatch1(fcall, $1), arg_new());
2742 $$ = method_add_block($$, $2);
2746 | method_call brace_block
2749 block_dup_check($1->nd_args, $2);
2753 $$ = method_add_block($1, $2);
2760 | k_if expr_value then
2766 $$ = NEW_IF(cond($2), $4, $5);
2769 $$ = dispatch3(if, $2, $4, escape_Qundef($5));
2772 | k_unless expr_value then
2778 $$ = NEW_UNLESS(cond($2), $4, $5);
2781 $$ = dispatch3(unless, $2, $4, escape_Qundef($5));
2784 | k_while {COND_PUSH(1);} expr_value do {COND_POP();}
2789 $$ = NEW_WHILE(cond($3), $6, 1);
2792 $$ = dispatch2(while, $3, $6);
2795 | k_until {COND_PUSH(1);} expr_value do {COND_POP();}
2800 $$ = NEW_UNTIL(cond($3), $6, 1);
2803 $$ = dispatch2(until, $3, $6);
2806 | k_case expr_value opt_terms
2811 $$ = NEW_CASE($2, $4);
2814 $$ = dispatch2(case, $2, $4);
2817 | k_case opt_terms case_body k_end
2820 $$ = NEW_CASE(0, $3);
2822 $$ = dispatch2(case, Qnil, $3);
2825 | k_for for_var keyword_in
2836 * e.each{|*x| a, b, c = x
2840 * e.each{|x| a, = x}
2842 ID id = internal_id();
2843 ID *tbl = ALLOC_N(ID, 2);
2844 NODE *m = NEW_ARGS_AUX(0, 0);
2847 if (nd_type($2) == NODE_MASGN) {
2848 /* if args.length == 1 && args[0].kind_of?(Array)
2852 NODE *one = NEW_LIST(NEW_LIT(INT2FIX(1)));
2853 NODE *zero = NEW_LIST(NEW_LIT(INT2FIX(0)));
2854 m->nd_next = block_append(
2857 NEW_CALL(NEW_CALL(NEW_DVAR(id), idLength, 0),
2859 NEW_CALL(NEW_CALL(NEW_DVAR(id), idAREF, zero),
2860 rb_intern("kind_of?"), NEW_LIST(NEW_LIT(rb_cArray))),
2863 NEW_CALL(NEW_DVAR(id), idAREF, zero)),
2865 node_assign($2, NEW_DVAR(id)));
2867 args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
2870 if (nd_type($2) == NODE_LASGN ||
2871 nd_type($2) == NODE_DASGN ||
2872 nd_type($2) == NODE_DASGN_CURR) {
2873 $2->nd_value = NEW_DVAR(id);
2876 args = new_args(m, 0, 0, 0, new_args_tail(0, 0, 0));
2879 m->nd_next = node_assign(NEW_MASGN(NEW_LIST($2), 0), NEW_DVAR(id));
2880 args = new_args(m, 0, id, 0, new_args_tail(0, 0, 0));
2883 scope = NEW_NODE(NODE_SCOPE, tbl, $8, args);
2884 tbl[0] = 1; tbl[1] = id;
2885 $$ = NEW_FOR(0, $5, scope);
2888 $$ = dispatch3(for, $2, $5, $8);
2891 | k_class cpath superclass
2893 if (in_def || in_single)
2894 yyerror("class definition in method body");
2897 $<num>$ = ruby_sourceline;
2905 $$ = NEW_CLASS($2, $5, $3);
2906 nd_set_line($$, $<num>4);
2908 $$ = dispatch3(class, $2, $3, $5);
2912 | k_class tLSHFT expr
2919 $<num>$ = in_single;
2927 $$ = NEW_SCLASS($3, $7);
2930 $$ = dispatch2(sclass, $3, $7);
2934 in_single = $<num>6;
2938 if (in_def || in_single)
2939 yyerror("module definition in method body");
2942 $<num>$ = ruby_sourceline;
2950 $$ = NEW_MODULE($2, $4);
2951 nd_set_line($$, $<num>3);
2953 $$ = dispatch2(module, $2, $4);
2969 NODE *body = remove_begin($5);
2970 reduce_nodes(&body);
2971 $$ = NEW_DEFN($2, $4, body, NOEX_PRIVATE);
2972 nd_set_line($$, $<num>1);
2974 $$ = dispatch3(def, $2, $4, $5);
2980 | k_def singleton dot_or_colon {lex_state = EXPR_FNAME;} fname
2983 lex_state = EXPR_ENDFN; /* force for args */
2991 NODE *body = remove_begin($8);
2992 reduce_nodes(&body);
2993 $$ = NEW_DEFS($2, $5, $7, body);
2994 nd_set_line($$, $<num>1);
2996 $$ = dispatch5(defs, $2, $3, $5, $7, $8);
3006 $$ = dispatch1(break, arg_new());
3014 $$ = dispatch1(next, arg_new());
3022 $$ = dispatch0(redo);
3030 $$ = dispatch0(retry);
3035 primary_value : primary
3040 if (!$$) $$ = NEW_NIL();
3047 k_begin : keyword_begin
3049 token_info_push("begin");
3055 token_info_push("if");
3059 k_unless : keyword_unless
3061 token_info_push("unless");
3065 k_while : keyword_while
3067 token_info_push("while");
3071 k_until : keyword_until
3073 token_info_push("until");
3077 k_case : keyword_case
3079 token_info_push("case");
3085 token_info_push("for");
3089 k_class : keyword_class
3091 token_info_push("class");
3095 k_module : keyword_module
3097 token_info_push("module");
3103 token_info_push("def");
3105 $<num>$ = ruby_sourceline;
3113 token_info_pop("end");
3139 | keyword_elsif expr_value then
3144 $$ = NEW_IF(cond($2), $4, $5);
3147 $$ = dispatch3(elsif, $2, $4, escape_Qundef($5));
3153 | keyword_else compstmt
3158 $$ = dispatch1(else, $2);
3169 $$ = assignable($1, 0);
3172 $$ = dispatch1(mlhs_paren, $$);
3175 | tLPAREN f_margs rparen
3180 $$ = dispatch1(mlhs_paren, $2);
3185 f_marg_list : f_marg
3190 $$ = mlhs_add(mlhs_new(), $1);
3193 | f_marg_list ',' f_marg
3196 $$ = list_append($1, $3);
3198 $$ = mlhs_add($1, $3);
3203 f_margs : f_marg_list
3206 $$ = NEW_MASGN($1, 0);
3211 | f_marg_list ',' tSTAR f_norm_arg
3213 $$ = assignable($4, 0);
3215 $$ = NEW_MASGN($1, $$);
3217 $$ = mlhs_add_star($1, $$);
3220 | f_marg_list ',' tSTAR f_norm_arg ',' f_marg_list
3222 $$ = assignable($4, 0);
3224 $$ = NEW_MASGN($1, NEW_POSTARG($$, $6));
3226 $$ = mlhs_add_star($1, $$);
3229 | f_marg_list ',' tSTAR
3232 $$ = NEW_MASGN($1, -1);
3234 $$ = mlhs_add_star($1, Qnil);
3237 | f_marg_list ',' tSTAR ',' f_marg_list
3240 $$ = NEW_MASGN($1, NEW_POSTARG(-1, $5));
3242 $$ = mlhs_add_star($1, $5);
3247 $$ = assignable($2, 0);
3249 $$ = NEW_MASGN(0, $$);
3251 $$ = mlhs_add_star(mlhs_new(), $$);
3254 | tSTAR f_norm_arg ',' f_marg_list
3256 $$ = assignable($2, 0);
3258 $$ = NEW_MASGN(0, NEW_POSTARG($$, $4));
3263 $$ = mlhs_add_star($$, $4);
3269 $$ = NEW_MASGN(0, -1);
3271 $$ = mlhs_add_star(mlhs_new(), Qnil);
3274 | tSTAR ',' f_marg_list
3277 $$ = NEW_MASGN(0, NEW_POSTARG(-1, $3));
3279 $$ = mlhs_add_star(mlhs_new(), Qnil);
3285 block_args_tail : f_block_kwarg ',' f_kwrest opt_f_block_arg
3287 $$ = new_args_tail($1, $3, $4);
3289 | f_block_kwarg opt_f_block_arg
3291 $$ = new_args_tail($1, Qnone, $2);
3293 | f_kwrest opt_f_block_arg
3295 $$ = new_args_tail(Qnone, $1, $2);
3299 $$ = new_args_tail(Qnone, Qnone, $1);
3303 opt_block_args_tail : ',' block_args_tail
3309 $$ = new_args_tail(Qnone, Qnone, Qnone);
3313 block_param : f_arg ',' f_block_optarg ',' f_rest_arg opt_block_args_tail
3315 $$ = new_args($1, $3, $5, Qnone, $6);
3317 | f_arg ',' f_block_optarg ',' f_rest_arg ',' f_arg opt_block_args_tail
3319 $$ = new_args($1, $3, $5, $7, $8);
3321 | f_arg ',' f_block_optarg opt_block_args_tail
3323 $$ = new_args($1, $3, Qnone, Qnone, $4);
3325 | f_arg ',' f_block_optarg ',' f_arg opt_block_args_tail
3327 $$ = new_args($1, $3, Qnone, $5, $6);
3329 | f_arg ',' f_rest_arg opt_block_args_tail
3331 $$ = new_args($1, Qnone, $3, Qnone, $4);
3335 $$ = new_args($1, Qnone, 1, Qnone, new_args_tail(Qnone, Qnone, Qnone));
3338 dispatch1(excessed_comma, $$);
3341 | f_arg ',' f_rest_arg ',' f_arg opt_block_args_tail
3343 $$ = new_args($1, Qnone, $3, $5, $6);
3345 | f_arg opt_block_args_tail
3347 $$ = new_args($1, Qnone, Qnone, Qnone, $2);
3349 | f_block_optarg ',' f_rest_arg opt_block_args_tail
3351 $$ = new_args(Qnone, $1, $3, Qnone, $4);
3353 | f_block_optarg ',' f_rest_arg ',' f_arg opt_block_args_tail
3355 $$ = new_args(Qnone, $1, $3, $5, $6);
3357 | f_block_optarg opt_block_args_tail
3359 $$ = new_args(Qnone, $1, Qnone, Qnone, $2);
3361 | f_block_optarg ',' f_arg opt_block_args_tail
3363 $$ = new_args(Qnone, $1, Qnone, $3, $4);
3365 | f_rest_arg opt_block_args_tail
3367 $$ = new_args(Qnone, Qnone, $1, Qnone, $2);
3369 | f_rest_arg ',' f_arg opt_block_args_tail
3371 $$ = new_args(Qnone, Qnone, $1, $3, $4);
3375 $$ = new_args(Qnone, Qnone, Qnone, Qnone, $1);
3379 opt_block_param : none
3382 command_start = TRUE;
3386 block_param_def : '|' opt_bv_decl '|'
3391 $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
3400 $$ = blockvar_new(params_new(Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil),
3404 | '|' block_param opt_bv_decl '|'
3409 $$ = blockvar_new(escape_Qundef($2), escape_Qundef($3));
3415 opt_bv_decl : opt_nl
3419 | opt_nl ';' bv_decls opt_nl
3433 $$ = rb_ary_new3(1, $1);
3440 rb_ary_push($1, $3);
3460 $<vars>$ = dyna_push();
3464 lpar_beg = ++paren_nest;
3468 $<num>$ = ruby_sourceline;
3471 $<val>$ = cmdarg_stack;
3477 cmdarg_stack = $<val>5;
3480 $$ = NEW_LAMBDA($3, $6);
3481 nd_set_line($$, $<num>4);
3483 $$ = dispatch2(lambda, $3, $6);
3489 f_larglist : '(' f_args opt_bv_decl ')'
3494 $$ = dispatch1(paren, $2);
3503 lambda_body : tLAMBEG compstmt '}'
3507 | keyword_do_LAMBDA compstmt keyword_end
3513 do_block : keyword_do_block
3515 $<vars>1 = dyna_push();
3517 $<num>$ = ruby_sourceline;
3525 $$ = NEW_ITER($3,$4);
3526 nd_set_line($$, $<num>2);
3528 $$ = dispatch2(do_block, escape_Qundef($3), $4);
3534 block_call : command do_block
3537 if (nd_type($1) == NODE_YIELD) {
3538 compile_error(PARSER_ARG "block given to yield");
3541 block_dup_check($1->nd_args, $2);
3547 $$ = method_add_block($1, $2);
3550 | block_call dot_or_colon operation2 opt_paren_args
3553 $$ = NEW_CALL($1, $3, $4);
3555 $$ = dispatch3(call, $1, $2, $3);
3556 $$ = method_optarg($$, $4);
3559 | block_call dot_or_colon operation2 opt_paren_args brace_block
3562 block_dup_check($4, $5);
3563 $5->nd_iter = NEW_CALL($1, $3, $4);
3567 $$ = dispatch4(command_call, $1, $2, $3, $4);
3568 $$ = method_add_block($$, $5);
3571 | block_call dot_or_colon operation2 command_args do_block
3574 block_dup_check($4, $5);
3575 $5->nd_iter = NEW_CALL($1, $3, $4);
3579 $$ = dispatch4(command_call, $1, $2, $3, $4);
3580 $$ = method_add_block($$, $5);
3585 method_call : fcall paren_args
3591 $$ = method_arg(dispatch1(fcall, $1), $2);
3594 | primary_value '.' operation2
3597 $<num>$ = ruby_sourceline;
3603 $$ = NEW_CALL($1, $3, $5);
3604 nd_set_line($$, $<num>4);
3606 $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
3607 $$ = method_optarg($$, $5);
3610 | primary_value tCOLON2 operation2
3613 $<num>$ = ruby_sourceline;
3619 $$ = NEW_CALL($1, $3, $5);
3620 nd_set_line($$, $<num>4);
3622 $$ = dispatch3(call, $1, ripper_id2sym('.'), $3);
3623 $$ = method_optarg($$, $5);
3626 | primary_value tCOLON2 operation3
3629 $$ = NEW_CALL($1, $3, 0);
3631 $$ = dispatch3(call, $1, ripper_intern("::"), $3);
3637 $<num>$ = ruby_sourceline;
3643 $$ = NEW_CALL($1, rb_intern("call"), $4);
3644 nd_set_line($$, $<num>3);
3646 $$ = dispatch3(call, $1, ripper_id2sym('.'),
3647 ripper_intern("call"));
3648 $$ = method_optarg($$, $4);
3651 | primary_value tCOLON2
3654 $<num>$ = ruby_sourceline;
3660 $$ = NEW_CALL($1, rb_intern("call"), $4);
3661 nd_set_line($$, $<num>3);
3663 $$ = dispatch3(call, $1, ripper_intern("::"),
3664 ripper_intern("call"));
3665 $$ = method_optarg($$, $4);
3668 | keyword_super paren_args
3673 $$ = dispatch1(super, $2);
3681 $$ = dispatch0(zsuper);
3684 | primary_value '[' opt_call_args rbracket
3687 if ($1 && nd_type($1) == NODE_SELF)
3688 $$ = NEW_FCALL(tAREF, $3);
3690 $$ = NEW_CALL($1, tAREF, $3);
3693 $$ = dispatch2(aref, $1, escape_Qundef($3));
3700 $<vars>1 = dyna_push();
3702 $<num>$ = ruby_sourceline;
3710 $$ = NEW_ITER($3,$4);
3711 nd_set_line($$, $<num>2);
3713 $$ = dispatch2(brace_block, escape_Qundef($3), $4);
3719 $<vars>1 = dyna_push();
3721 $<num>$ = ruby_sourceline;
3726 compstmt keyword_end
3729 $$ = NEW_ITER($3,$4);
3730 nd_set_line($$, $<num>2);
3732 $$ = dispatch2(do_block, escape_Qundef($3), $4);
3738 case_body : keyword_when args then
3743 $$ = NEW_WHEN($2, $4, $5);
3745 $$ = dispatch3(when, $2, $4, escape_Qundef($5));
3754 opt_rescue : keyword_rescue exc_list exc_var then
3760 $3 = node_assign($3, NEW_ERRINFO());
3761 $5 = block_append($3, $5);
3763 $$ = NEW_RESBODY($2, $5, $6);
3764 fixpos($$, $2?$2:$5);
3766 $$ = dispatch4(rescue,
3776 exc_list : arg_value
3781 $$ = rb_ary_new3(1, $1);
3787 if (!($$ = splat_array($1))) $$ = $1;
3795 exc_var : tASSOC lhs
3802 opt_ensure : keyword_ensure compstmt
3807 $$ = dispatch1(ensure, $2);
3817 $$ = NEW_LIT(ID2SYM($1));
3819 $$ = dispatch1(symbol_literal, $1);
3830 node = NEW_STR(STR_NEW0());
3833 node = evstr2dstr(node);
3847 $$ = literal_concat($1, $2);
3849 $$ = dispatch2(string_concat, $1, $2);
3854 string1 : tSTRING_BEG string_contents tSTRING_END
3859 $$ = dispatch1(string_literal, $2);
3864 xstring : tXSTRING_BEG xstring_contents tSTRING_END
3869 node = NEW_XSTR(STR_NEW0());
3872 switch (nd_type(node)) {
3874 nd_set_type(node, NODE_XSTR);
3877 nd_set_type(node, NODE_DXSTR);
3880 node = NEW_NODE(NODE_DXSTR, Qnil, 1, NEW_LIST(node));
3886 $$ = dispatch1(xstring_literal, $2);
3891 regexp : tREGEXP_BEG regexp_contents tREGEXP_END
3898 node = NEW_LIT(reg_compile(STR_NEW0(), options));
3900 else switch (nd_type(node)) {
3903 VALUE src = node->nd_lit;
3904 nd_set_type(node, NODE_LIT);
3905 node->nd_lit = reg_compile(src, options);
3909 node = NEW_NODE(NODE_DSTR, STR_NEW0(), 1, NEW_LIST(node));
3911 if (options & RE_OPTION_ONCE) {
3912 nd_set_type(node, NODE_DREGX_ONCE);
3915 nd_set_type(node, NODE_DREGX);
3917 node->nd_cflag = options & RE_OPTION_MASK;
3918 if (!NIL_P(node->nd_lit)) reg_fragment_check(node->nd_lit, options);
3919 for (list = (prev = node)->nd_next; list; list = list->nd_next) {
3920 if (nd_type(list->nd_head) == NODE_STR) {
3921 VALUE tail = list->nd_head->nd_lit;
3922 if (reg_fragment_check(tail, options) && prev && !NIL_P(prev->nd_lit)) {
3923 VALUE lit = prev == node ? prev->nd_lit : prev->nd_head->nd_lit;
3924 if (!literal_concat0(parser, lit, tail)) {
3928 rb_str_resize(tail, 0);
3929 prev->nd_next = list->nd_next;
3930 rb_gc_force_recycle((VALUE)list->nd_head);
3931 rb_gc_force_recycle((VALUE)list);
3942 if (!node->nd_next) {
3943 VALUE src = node->nd_lit;
3944 nd_set_type(node, NODE_LIT);
3945 node->nd_lit = reg_compile(src, options);
3951 $$ = dispatch2(regexp_literal, $2, $3);
3956 words : tWORDS_BEG ' ' tSTRING_END
3961 $$ = dispatch0(words_new);
3962 $$ = dispatch1(array, $$);
3965 | tWORDS_BEG word_list tSTRING_END
3970 $$ = dispatch1(array, $2);
3975 word_list : /* none */
3980 $$ = dispatch0(words_new);
3983 | word_list word ' '
3986 $$ = list_append($1, evstr2dstr($2));
3988 $$ = dispatch2(words_add, $1, $2);
3993 word : string_content
3997 $$ = dispatch0(word_new);
3998 $$ = dispatch2(word_add, $$, $1);
4001 | word string_content
4004 $$ = literal_concat($1, $2);
4006 $$ = dispatch2(word_add, $1, $2);
4011 symbols : tSYMBOLS_BEG ' ' tSTRING_END
4016 $$ = dispatch0(symbols_new);
4017 $$ = dispatch1(array, $$);
4020 | tSYMBOLS_BEG symbol_list tSTRING_END
4025 $$ = dispatch1(array, $2);
4030 symbol_list : /* none */
4035 $$ = dispatch0(symbols_new);
4038 | symbol_list word ' '
4041 $2 = evstr2dstr($2);
4042 if (nd_type($2) == NODE_DSTR) {
4043 nd_set_type($2, NODE_DSYM);
4046 nd_set_type($2, NODE_LIT);
4047 $2->nd_lit = rb_str_intern($2->nd_lit);
4049 $$ = list_append($1, $2);
4051 $$ = dispatch2(symbols_add, $1, $2);
4056 qwords : tQWORDS_BEG ' ' tSTRING_END
4061 $$ = dispatch0(qwords_new);
4062 $$ = dispatch1(array, $$);
4065 | tQWORDS_BEG qword_list tSTRING_END
4070 $$ = dispatch1(array, $2);
4075 qsymbols : tQSYMBOLS_BEG ' ' tSTRING_END
4080 $$ = dispatch0(qsymbols_new);
4081 $$ = dispatch1(array, $$);
4084 | tQSYMBOLS_BEG qsym_list tSTRING_END
4089 $$ = dispatch1(array, $2);
4094 qword_list : /* none */
4099 $$ = dispatch0(qwords_new);
4102 | qword_list tSTRING_CONTENT ' '
4105 $$ = list_append($1, $2);
4107 $$ = dispatch2(qwords_add, $1, $2);
4112 qsym_list : /* none */
4117 $$ = dispatch0(qsymbols_new);
4120 | qsym_list tSTRING_CONTENT ' '
4125 $2->nd_lit = ID2SYM(rb_intern_str(lit));
4126 nd_set_type($2, NODE_LIT);
4127 $$ = list_append($1, $2);
4129 $$ = dispatch2(qsymbols_add, $1, $2);
4134 string_contents : /* none */
4139 $$ = dispatch0(string_content);
4142 | string_contents string_content
4145 $$ = literal_concat($1, $2);
4147 $$ = dispatch2(string_add, $1, $2);
4152 xstring_contents: /* none */
4157 $$ = dispatch0(xstring_new);
4160 | xstring_contents string_content
4163 $$ = literal_concat($1, $2);
4165 $$ = dispatch2(xstring_add, $1, $2);
4170 regexp_contents: /* none */
4175 $$ = dispatch0(regexp_new);
4178 | regexp_contents string_content
4181 NODE *head = $1, *tail = $2;
4189 switch (nd_type(head)) {
4191 nd_set_type(head, NODE_DSTR);
4196 head = list_append(NEW_DSTR(Qnil), head);
4199 $$ = list_append(head, tail);
4202 $$ = dispatch2(regexp_add, $1, $2);
4207 string_content : tSTRING_CONTENT
4210 $<node>$ = lex_strterm;
4212 lex_state = EXPR_BEG;
4217 lex_strterm = $<node>2;
4220 lex_strterm = $<node>2;
4221 $$ = dispatch1(string_dvar, $3);
4226 $<val>1 = cond_stack;
4227 $<val>$ = cmdarg_stack;
4232 $<node>$ = lex_strterm;
4234 lex_state = EXPR_BEG;
4237 $<num>$ = brace_nest;
4240 compstmt tSTRING_DEND
4242 cond_stack = $<val>1;
4243 cmdarg_stack = $<val>2;
4244 lex_strterm = $<node>3;
4245 brace_nest = $<num>4;
4247 if ($5) $5->flags &= ~NODE_FL_NEWLINE;
4250 $$ = dispatch1(string_embexpr, $5);
4260 $$ = dispatch1(var_ref, $1);
4268 $$ = dispatch1(var_ref, $1);
4276 $$ = dispatch1(var_ref, $1);
4282 symbol : tSYMBEG sym
4284 lex_state = EXPR_END;
4288 $$ = dispatch1(symbol, $2);
4299 dsym : tSYMBEG xstring_contents tSTRING_END
4301 lex_state = EXPR_END;
4305 $$ = dispatch1(dyna_symbol, $2);
4310 numeric : simple_numeric
4311 | tUMINUS_NUM simple_numeric %prec tLOWEST
4314 $$ = negate_lit($2);
4316 $$ = dispatch2(unary, ripper_intern("-@"), $2);
4321 simple_numeric : tINTEGER
4327 user_variable : tIDENTIFIER
4334 keyword_variable: keyword_nil {ifndef_ripper($$ = keyword_nil);}
4335 | keyword_self {ifndef_ripper($$ = keyword_self);}
4336 | keyword_true {ifndef_ripper($$ = keyword_true);}
4337 | keyword_false {ifndef_ripper($$ = keyword_false);}
4338 | keyword__FILE__ {ifndef_ripper($$ = keyword__FILE__);}
4339 | keyword__LINE__ {ifndef_ripper($$ = keyword__LINE__);}
4340 | keyword__ENCODING__ {ifndef_ripper($$ = keyword__ENCODING__);}
4343 var_ref : user_variable
4346 if (!($$ = gettable($1))) $$ = NEW_BEGIN(0);
4348 if (id_is_var(get_id($1))) {
4349 $$ = dispatch1(var_ref, $1);
4352 $$ = dispatch1(vcall, $1);
4359 if (!($$ = gettable($1))) $$ = NEW_BEGIN(0);
4361 $$ = dispatch1(var_ref, $1);
4366 var_lhs : user_variable
4368 $$ = assignable($1, 0);
4371 $$ = dispatch1(var_field, $$);
4376 $$ = assignable($1, 0);
4379 $$ = dispatch1(var_field, $$);
4398 lex_state = EXPR_BEG;
4399 command_start = TRUE;
4417 f_arglist : '(' f_args rparen
4422 $$ = dispatch1(paren, $2);
4424 lex_state = EXPR_BEG;
4425 command_start = TRUE;
4428 $<num>$ = parser->parser_in_kwarg;
4429 parser->parser_in_kwarg = 1;
4433 parser->parser_in_kwarg = $<num>1;
4435 lex_state = EXPR_BEG;
4436 command_start = TRUE;
4440 args_tail : f_kwarg ',' f_kwrest opt_f_block_arg
4442 $$ = new_args_tail($1, $3, $4);
4444 | f_kwarg opt_f_block_arg
4446 $$ = new_args_tail($1, Qnone, $2);
4448 | f_kwrest opt_f_block_arg
4450 $$ = new_args_tail(Qnone, $1, $2);
4454 $$ = new_args_tail(Qnone, Qnone, $1);
4458 opt_args_tail : ',' args_tail
4464 $$ = new_args_tail(Qnone, Qnone, Qnone);
4468 f_args : f_arg ',' f_optarg ',' f_rest_arg opt_args_tail
4470 $$ = new_args($1, $3, $5, Qnone, $6);
4472 | f_arg ',' f_optarg ',' f_rest_arg ',' f_arg opt_args_tail
4474 $$ = new_args($1, $3, $5, $7, $8);
4476 | f_arg ',' f_optarg opt_args_tail
4478 $$ = new_args($1, $3, Qnone, Qnone, $4);
4480 | f_arg ',' f_optarg ',' f_arg opt_args_tail
4482 $$ = new_args($1, $3, Qnone, $5, $6);
4484 | f_arg ',' f_rest_arg opt_args_tail
4486 $$ = new_args($1, Qnone, $3, Qnone, $4);
4488 | f_arg ',' f_rest_arg ',' f_arg opt_args_tail
4490 $$ = new_args($1, Qnone, $3, $5, $6);
4492 | f_arg opt_args_tail
4494 $$ = new_args($1, Qnone, Qnone, Qnone, $2);
4496 | f_optarg ',' f_rest_arg opt_args_tail
4498 $$ = new_args(Qnone, $1, $3, Qnone, $4);
4500 | f_optarg ',' f_rest_arg ',' f_arg opt_args_tail
4502 $$ = new_args(Qnone, $1, $3, $5, $6);
4504 | f_optarg opt_args_tail
4506 $$ = new_args(Qnone, $1, Qnone, Qnone, $2);
4508 | f_optarg ',' f_arg opt_args_tail
4510 $$ = new_args(Qnone, $1, Qnone, $3, $4);
4512 | f_rest_arg opt_args_tail
4514 $$ = new_args(Qnone, Qnone, $1, Qnone, $2);
4516 | f_rest_arg ',' f_arg opt_args_tail
4518 $$ = new_args(Qnone, Qnone, $1, $3, $4);
4522 $$ = new_args(Qnone, Qnone, Qnone, Qnone, $1);
4526 $$ = new_args_tail(Qnone, Qnone, Qnone);
4527 $$ = new_args(Qnone, Qnone, Qnone, Qnone, $$);
4531 f_bad_arg : tCONSTANT
4534 yyerror("formal argument cannot be a constant");
4537 $$ = dispatch1(param_error, $1);
4543 yyerror("formal argument cannot be an instance variable");
4546 $$ = dispatch1(param_error, $1);
4552 yyerror("formal argument cannot be a global variable");
4555 $$ = dispatch1(param_error, $1);
4561 yyerror("formal argument cannot be a class variable");
4564 $$ = dispatch1(param_error, $1);
4569 f_norm_arg : f_bad_arg
4572 formal_argument(get_id($1));
4577 f_arg_item : f_norm_arg
4579 arg_var(get_id($1));
4581 $$ = NEW_ARGS_AUX($1, 1);
4586 | tLPAREN f_margs rparen
4588 ID tid = internal_id();
4591 if (dyna_in_block()) {
4592 $2->nd_value = NEW_DVAR(tid);
4595 $2->nd_value = NEW_LVAR(tid);
4597 $$ = NEW_ARGS_AUX(tid, 1);
4600 $$ = dispatch1(mlhs_paren, $2);
4609 $$ = rb_ary_new3(1, $1);
4612 | f_arg ',' f_arg_item
4617 $$->nd_next = block_append($$->nd_next, $3->nd_next);
4618 rb_gc_force_recycle((VALUE)$3);
4620 $$ = rb_ary_push($1, $3);
4628 arg_var(formal_argument(get_id($1)));
4633 f_kw : f_label arg_value
4635 $$ = assignable($1, $2);
4637 $$ = NEW_KW_ARG(0, $$);
4639 $$ = rb_assoc_new($$, $2);
4644 $$ = assignable($1, (NODE *)-1);
4646 $$ = NEW_KW_ARG(0, $$);
4648 $$ = rb_assoc_new($$, 0);
4653 f_block_kw : f_label primary_value
4655 $$ = assignable($1, $2);
4657 $$ = NEW_KW_ARG(0, $$);
4659 $$ = rb_assoc_new($$, $2);
4664 $$ = assignable($1, (NODE *)-1);
4666 $$ = NEW_KW_ARG(0, $$);
4668 $$ = rb_assoc_new($$, 0);
4673 f_block_kwarg : f_block_kw
4678 $$ = rb_ary_new3(1, $1);
4681 | f_block_kwarg ',' f_block_kw
4686 while (kws->nd_next) {
4692 $$ = rb_ary_push($1, $3);
4703 $$ = rb_ary_new3(1, $1);
4711 while (kws->nd_next) {
4717 $$ = rb_ary_push($1, $3);
4726 f_kwrest : kwrest_mark tIDENTIFIER
4728 shadowing_lvar(get_id($2));
4737 f_opt : f_norm_arg '=' arg_value
4739 arg_var(get_id($1));
4740 $$ = assignable($1, $3);
4742 $$ = NEW_OPT_ARG(0, $$);
4744 $$ = rb_assoc_new($$, $3);
4749 f_block_opt : f_norm_arg '=' primary_value
4751 arg_var(get_id($1));
4752 $$ = assignable($1, $3);
4754 $$ = NEW_OPT_ARG(0, $$);
4756 $$ = rb_assoc_new($$, $3);
4761 f_block_optarg : f_block_opt
4766 $$ = rb_ary_new3(1, $1);
4769 | f_block_optarg ',' f_block_opt
4774 while (opts->nd_next) {
4775 opts = opts->nd_next;
4780 $$ = rb_ary_push($1, $3);
4790 $$ = rb_ary_new3(1, $1);
4793 | f_optarg ',' f_opt
4798 while (opts->nd_next) {
4799 opts = opts->nd_next;
4804 $$ = rb_ary_push($1, $3);
4813 f_rest_arg : restarg_mark tIDENTIFIER
4816 if (!is_local_id($2))
4817 yyerror("rest argument must be local variable");
4819 arg_var(shadowing_lvar(get_id($2)));
4823 $$ = dispatch1(rest_param, $2);
4832 $$ = dispatch1(rest_param, Qnil);
4841 f_block_arg : blkarg_mark tIDENTIFIER
4844 if (!is_local_id($2))
4845 yyerror("block argument must be local variable");
4846 else if (!dyna_in_block() && local_id($2))
4847 yyerror("duplicated block argument name");
4849 arg_var(shadowing_lvar(get_id($2)));
4853 $$ = dispatch1(blockarg, $2);
4858 opt_f_block_arg : ',' f_block_arg
4877 if (!$$) $$ = NEW_NIL();
4882 | '(' {lex_state = EXPR_BEG;} expr rparen
4886 yyerror("can't define singleton method for ().");
4889 switch (nd_type($3)) {
4898 yyerror("can't define singleton method for literals");
4906 $$ = dispatch1(paren, $3);
4917 $$ = dispatch1(assoclist_from_args, $1);
4926 $$ = rb_ary_new3(1, $1);
4932 $$ = list_concat($1, $3);
4934 $$ = rb_ary_push($1, $3);
4939 assoc : arg_value tASSOC arg_value
4942 if (nd_type($1) == NODE_STR) {
4943 nd_set_type($1, NODE_LIT);
4944 $1->nd_lit = rb_fstring($1->nd_lit);
4946 $$ = list_append(NEW_LIST($1), $3);
4948 $$ = dispatch2(assoc_new, $1, $3);
4954 $$ = list_append(NEW_LIST(NEW_LIT(ID2SYM($1))), $2);
4956 $$ = dispatch2(assoc_new, $1, $2);
4962 $$ = list_append(NEW_LIST(0), $2);
4964 $$ = dispatch1(assoc_splat, $2);
4971 operation : tIDENTIFIER
4976 operation2 : tIDENTIFIER
4982 operation3 : tIDENTIFIER
4999 opt_terms : /* none */
5010 rbracket : opt_nl ']'
5013 trailer : /* none */
5018 term : ';' {yyerrok;}
5023 | terms ';' {yyerrok;}
5039 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
5041 static int parser_regx_options(struct parser_params*);
5042 static int parser_tokadd_string(struct parser_params*,int,int,int,long*,rb_encoding**);
5043 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
5044 static int parser_parse_string(struct parser_params*,NODE*);
5045 static int parser_here_document(struct parser_params*,NODE*);
5048 # define nextc() parser_nextc(parser)
5049 # define pushback(c) parser_pushback(parser, (c))
5050 # define newtok() parser_newtok(parser)
5051 # define tokspace(n) parser_tokspace(parser, (n))
5052 # define tokadd(c) parser_tokadd(parser, (c))
5053 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
5054 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
5055 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
5056 # define regx_options() parser_regx_options(parser)
5057 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
5058 # define parse_string(n) parser_parse_string(parser,(n))
5059 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
5060 # define here_document(n) parser_here_document(parser,(n))
5061 # define heredoc_identifier() parser_heredoc_identifier(parser)
5062 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
5063 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
5064 # define number_literal_suffix(f) parser_number_literal_suffix(parser, (f))
5065 # define set_number_literal(v, t, f) parser_set_number_literal(parser, (v), (t), (f))
5066 # define set_integer_literal(v, f) parser_set_integer_literal(parser, (v), (f))
5069 # define set_yylval_str(x) (yylval.node = NEW_STR(x))
5070 # define set_yylval_num(x) (yylval.num = (x))
5071 # define set_yylval_id(x) (yylval.id = (x))
5072 # define set_yylval_name(x) (yylval.id = (x))
5073 # define set_yylval_literal(x) (yylval.node = NEW_LIT(x))
5074 # define set_yylval_node(x) (yylval.node = (x))
5075 # define yylval_id() (yylval.id)
5078 ripper_yylval_id(ID x)
5080 return (VALUE)NEW_LASGN(x, ID2SYM(x));
5082 # define set_yylval_str(x) (void)(x)
5083 # define set_yylval_num(x) (void)(x)
5084 # define set_yylval_id(x) (void)(x)
5085 # define set_yylval_name(x) (void)(yylval.val = ripper_yylval_id(x))
5086 # define set_yylval_literal(x) (void)(x)
5087 # define set_yylval_node(x) (void)(x)
5088 # define yylval_id() yylval.id
5092 #define ripper_flush(p) (void)(p)
5094 #define ripper_flush(p) ((p)->tokp = (p)->parser_lex_p)
5096 #define yylval_rval (*(RB_TYPE_P(yylval.val, T_NODE) ? &yylval.node->nd_rval : &yylval.val))
5099 ripper_has_scan_event(struct parser_params *parser)
5102 if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
5103 return lex_p > parser->tokp;
5107 ripper_scan_event_val(struct parser_params *parser, int t)
5109 VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
5110 VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
5111 ripper_flush(parser);
5116 ripper_dispatch_scan_event(struct parser_params *parser, int t)
5118 if (!ripper_has_scan_event(parser)) return;
5119 yylval_rval = ripper_scan_event_val(parser, t);
5123 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
5125 if (!ripper_has_scan_event(parser)) return;
5126 (void)ripper_scan_event_val(parser, t);
5130 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
5132 int saved_line = ruby_sourceline;
5133 const char *saved_tokp = parser->tokp;
5135 ruby_sourceline = parser->delayed_line;
5136 parser->tokp = lex_pbeg + parser->delayed_col;
5137 yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
5138 parser->delayed = Qnil;
5139 ruby_sourceline = saved_line;
5140 parser->tokp = saved_tokp;
5144 #include "ruby/regex.h"
5145 #include "ruby/util.h"
5147 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
5148 since ours (we hope) works properly with all combinations of
5149 machines, compilers, `char' and `unsigned char' argument types.
5150 (Per Bothner suggested the basic approach.) */
5151 #undef SIGN_EXTEND_CHAR
5153 # define SIGN_EXTEND_CHAR(c) ((signed char)(c))
5154 #else /* not __STDC__ */
5155 /* As in Harbison and Steele. */
5156 # define SIGN_EXTEND_CHAR(c) ((((unsigned char)(c)) ^ 128) - 128)
5159 #define parser_encoding_name() (current_enc->name)
5160 #define parser_mbclen() mbclen((lex_p-1),lex_pend,current_enc)
5161 #define parser_precise_mbclen() rb_enc_precise_mbclen((lex_p-1),lex_pend,current_enc)
5162 #define is_identchar(p,e,enc) (rb_enc_isalnum((unsigned char)(*(p)),(enc)) || (*(p)) == '_' || !ISASCII(*(p)))
5163 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
5165 #define parser_isascii() ISASCII(*(lex_p-1))
5169 token_info_get_column(struct parser_params *parser, const char *token)
5172 const char *p, *pend = lex_p - strlen(token);
5173 for (p = lex_pbeg; p < pend; p++) {
5175 column = (((column - 1) / 8) + 1) * 8;
5183 token_info_has_nonspaces(struct parser_params *parser, const char *token)
5185 const char *p, *pend = lex_p - strlen(token);
5186 for (p = lex_pbeg; p < pend; p++) {
5187 if (*p != ' ' && *p != '\t') {
5194 #undef token_info_push
5196 token_info_push(struct parser_params *parser, const char *token)
5200 if (!parser->parser_token_info_enabled) return;
5201 ptinfo = ALLOC(token_info);
5202 ptinfo->token = token;
5203 ptinfo->linenum = ruby_sourceline;
5204 ptinfo->column = token_info_get_column(parser, token);
5205 ptinfo->nonspc = token_info_has_nonspaces(parser, token);
5206 ptinfo->next = parser->parser_token_info;
5208 parser->parser_token_info = ptinfo;
5211 #undef token_info_pop
5213 token_info_pop(struct parser_params *parser, const char *token)
5216 token_info *ptinfo = parser->parser_token_info;
5218 if (!ptinfo) return;
5219 parser->parser_token_info = ptinfo->next;
5220 if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
5223 linenum = ruby_sourceline;
5224 if (linenum == ptinfo->linenum) { /* SKIP */
5227 if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
5230 if (parser->parser_token_info_enabled) {
5231 rb_compile_warn(ruby_sourcefile, linenum,
5232 "mismatched indentations at '%s' with '%s' at %d",
5233 token, ptinfo->token, ptinfo->linenum);
5242 parser_yyerror(struct parser_params *parser, const char *msg)
5245 const int max_line_margin = 30;
5251 compile_error(PARSER_ARG "%s", msg);
5253 while (lex_pbeg <= p) {
5254 if (*p == '\n') break;
5260 while (pe < lex_pend) {
5261 if (*pe == '\n') break;
5268 const char *pre = "", *post = "";
5270 if (len > max_line_margin * 2 + 10) {
5271 if (lex_p - p > max_line_margin) {
5272 p = rb_enc_prev_char(p, lex_p - max_line_margin, pe, rb_enc_get(lex_lastline));
5275 if (pe - lex_p > max_line_margin) {
5276 pe = rb_enc_prev_char(lex_p, lex_p + max_line_margin, pe, rb_enc_get(lex_lastline));
5281 buf = ALLOCA_N(char, len+2);
5282 MEMCPY(buf, p, char, len);
5284 rb_compile_error_with_enc(NULL, 0, (void *)current_enc, "%s%s%s", pre, buf, post);
5286 i = (int)(lex_p - p);
5287 p2 = buf; pe = buf + len;
5290 if (*p2 != '\t') *p2 = ' ';
5295 rb_compile_error_append("%s%s", pre, buf);
5298 dispatch1(parse_error, STR_NEW2(msg));
5299 #endif /* !RIPPER */
5303 static void parser_prepare(struct parser_params *parser);
5307 debug_lines(VALUE fname)
5310 CONST_ID(script_lines, "SCRIPT_LINES__");
5311 if (rb_const_defined_at(rb_cObject, script_lines)) {
5312 VALUE hash = rb_const_get_at(rb_cObject, script_lines);
5313 if (RB_TYPE_P(hash, T_HASH)) {
5314 VALUE lines = rb_ary_new();
5315 rb_hash_aset(hash, fname, lines);
5323 coverage(VALUE fname, int n)
5325 VALUE coverages = rb_get_coverages();
5326 if (RTEST(coverages) && RBASIC(coverages)->klass == 0) {
5327 VALUE lines = rb_ary_new2(n);
5329 RBASIC_CLEAR_CLASS(lines);
5330 for (i = 0; i < n; i++) RARRAY_ASET(lines, i, Qnil);
5331 RARRAY(lines)->as.heap.len = n;
5332 rb_hash_aset(coverages, fname, lines);
5339 e_option_supplied(struct parser_params *parser)
5341 return strcmp(ruby_sourcefile, "-e") == 0;
5345 yycompile0(VALUE arg)
5349 struct parser_params *parser = (struct parser_params *)arg;
5351 if (!compile_for_eval && rb_safe_level() == 0) {
5352 ruby_debug_lines = debug_lines(ruby_sourcefile_string);
5353 if (ruby_debug_lines && ruby_sourceline > 0) {
5354 VALUE str = STR_NEW0();
5355 n = ruby_sourceline;
5357 rb_ary_push(ruby_debug_lines, str);
5361 if (!e_option_supplied(parser)) {
5362 ruby_coverage = coverage(ruby_sourcefile_string, ruby_sourceline);
5365 parser->last_cr_line = ruby_sourceline - 1;
5367 parser_prepare(parser);
5370 parser->parser_token_info_enabled = !compile_for_eval && RTEST(ruby_verbose);
5373 if (RUBY_DTRACE_PARSE_BEGIN_ENABLED()) {
5374 RUBY_DTRACE_PARSE_BEGIN(parser->parser_ruby_sourcefile,
5375 parser->parser_ruby_sourceline);
5378 n = yyparse((void*)parser);
5380 if (RUBY_DTRACE_PARSE_END_ENABLED()) {
5381 RUBY_DTRACE_PARSE_END(parser->parser_ruby_sourcefile,
5382 parser->parser_ruby_sourceline);
5385 ruby_debug_lines = 0;
5387 compile_for_eval = 0;
5390 lex_p = lex_pbeg = lex_pend = 0;
5391 lex_lastline = lex_nextline = 0;
5395 tree = ruby_eval_tree;
5399 else if (ruby_eval_tree_begin) {
5400 tree->nd_body = NEW_PRELUDE(ruby_eval_tree_begin, tree->nd_body);
5406 yycompile(struct parser_params *parser, VALUE fname, int line)
5408 ruby_sourcefile_string = rb_str_new_frozen(fname);
5409 ruby_sourcefile = RSTRING_PTR(fname);
5410 ruby_sourceline = line - 1;
5411 return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
5413 #endif /* !RIPPER */
5415 static rb_encoding *
5416 must_be_ascii_compatible(VALUE s)
5418 rb_encoding *enc = rb_enc_get(s);
5419 if (!rb_enc_asciicompat(enc)) {
5420 rb_raise(rb_eArgError, "invalid source encoding");
5426 lex_get_str(struct parser_params *parser, VALUE s)
5428 char *beg, *end, *pend;
5429 rb_encoding *enc = must_be_ascii_compatible(s);
5431 beg = RSTRING_PTR(s);
5433 if (RSTRING_LEN(s) == lex_gets_ptr) return Qnil;
5434 beg += lex_gets_ptr;
5436 pend = RSTRING_PTR(s) + RSTRING_LEN(s);
5438 while (end < pend) {
5439 if (*end++ == '\n') break;
5441 lex_gets_ptr = end - RSTRING_PTR(s);
5442 return rb_enc_str_new(beg, end - beg, enc);
5446 lex_getline(struct parser_params *parser)
5448 VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
5449 if (NIL_P(line)) return line;
5450 must_be_ascii_compatible(line);
5452 if (ruby_debug_lines) {
5453 rb_enc_associate(line, current_enc);
5454 rb_ary_push(ruby_debug_lines, line);
5456 if (ruby_coverage) {
5457 rb_ary_push(ruby_coverage, Qnil);
5464 static rb_data_type_t parser_data_type;
5466 static const rb_data_type_t parser_data_type;
5469 parser_compile_string(volatile VALUE vparser, VALUE fname, VALUE s, int line)
5471 struct parser_params *parser;
5474 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
5475 lex_gets = lex_get_str;
5478 lex_pbeg = lex_p = lex_pend = 0;
5479 compile_for_eval = rb_parse_in_eval();
5481 node = yycompile(parser, fname, line);
5482 RB_GC_GUARD(vparser); /* prohibit tail call optimization */
5488 rb_compile_string(const char *f, VALUE s, int line)
5490 must_be_ascii_compatible(s);
5491 return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), s, line);
5495 rb_parser_compile_string(volatile VALUE vparser, const char *f, VALUE s, int line)
5497 return rb_parser_compile_string_path(vparser, rb_filesystem_str_new_cstr(f), s, line);
5501 rb_parser_compile_string_path(volatile VALUE vparser, VALUE f, VALUE s, int line)
5503 must_be_ascii_compatible(s);
5504 return parser_compile_string(vparser, f, s, line);
5508 rb_compile_cstr(const char *f, const char *s, int len, int line)
5510 VALUE str = rb_str_new(s, len);
5511 return parser_compile_string(rb_parser_new(), rb_filesystem_str_new_cstr(f), str, line);
5515 rb_parser_compile_cstr(volatile VALUE vparser, const char *f, const char *s, int len, int line)
5517 VALUE str = rb_str_new(s, len);
5518 return parser_compile_string(vparser, rb_filesystem_str_new_cstr(f), str, line);
5522 lex_io_gets(struct parser_params *parser, VALUE io)
5524 return rb_io_gets(io);
5528 rb_compile_file(const char *f, VALUE file, int start)
5530 VALUE volatile vparser = rb_parser_new();
5532 return rb_parser_compile_file(vparser, f, file, start);
5536 rb_parser_compile_file(volatile VALUE vparser, const char *f, VALUE file, int start)
5538 return rb_parser_compile_file_path(vparser, rb_filesystem_str_new_cstr(f), file, start);
5542 rb_parser_compile_file_path(volatile VALUE vparser, VALUE fname, VALUE file, int start)
5544 struct parser_params *parser;
5547 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
5548 lex_gets = lex_io_gets;
5550 lex_pbeg = lex_p = lex_pend = 0;
5551 compile_for_eval = rb_parse_in_eval();
5553 node = yycompile(parser, fname, start);
5554 RB_GC_GUARD(vparser); /* prohibit tail call optimization */
5558 #endif /* !RIPPER */
5560 #define STR_FUNC_ESCAPE 0x01
5561 #define STR_FUNC_EXPAND 0x02
5562 #define STR_FUNC_REGEXP 0x04
5563 #define STR_FUNC_QWORDS 0x08
5564 #define STR_FUNC_SYMBOL 0x10
5565 #define STR_FUNC_INDENT 0x20
5569 str_dquote = (STR_FUNC_EXPAND),
5570 str_xquote = (STR_FUNC_EXPAND),
5571 str_regexp = (STR_FUNC_REGEXP|STR_FUNC_ESCAPE|STR_FUNC_EXPAND),
5572 str_sword = (STR_FUNC_QWORDS),
5573 str_dword = (STR_FUNC_QWORDS|STR_FUNC_EXPAND),
5574 str_ssym = (STR_FUNC_SYMBOL),
5575 str_dsym = (STR_FUNC_SYMBOL|STR_FUNC_EXPAND)
5579 parser_str_new(const char *p, long n, rb_encoding *enc, int func, rb_encoding *enc0)
5583 str = rb_enc_str_new(p, n, enc);
5584 if (!(func & STR_FUNC_REGEXP) && rb_enc_asciicompat(enc)) {
5585 if (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT) {
5587 else if (enc0 == rb_usascii_encoding() && enc != rb_utf8_encoding()) {
5588 rb_enc_associate(str, rb_ascii8bit_encoding());
5595 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
5596 #define lex_eol_p() (lex_p >= lex_pend)
5597 #define peek(c) peek_n((c), 0)
5598 #define peek_n(c,n) (lex_p+(n) < lex_pend && (c) == (unsigned char)lex_p[n])
5601 parser_nextc(struct parser_params *parser)
5605 if (lex_p == lex_pend) {
5606 VALUE v = lex_nextline;
5612 if (!lex_input || NIL_P(v = lex_getline(parser))) {
5613 parser->eofp = Qtrue;
5614 lex_goto_eol(parser);
5620 if (parser->tokp < lex_pend) {
5621 if (NIL_P(parser->delayed)) {
5622 parser->delayed = rb_str_buf_new(1024);
5623 rb_enc_associate(parser->delayed, current_enc);
5624 rb_str_buf_cat(parser->delayed,
5625 parser->tokp, lex_pend - parser->tokp);
5626 parser->delayed_line = ruby_sourceline;
5627 parser->delayed_col = (int)(parser->tokp - lex_pbeg);
5630 rb_str_buf_cat(parser->delayed,
5631 parser->tokp, lex_pend - parser->tokp);
5635 if (heredoc_end > 0) {
5636 ruby_sourceline = heredoc_end;
5640 parser->line_count++;
5641 lex_pbeg = lex_p = RSTRING_PTR(v);
5642 lex_pend = lex_p + RSTRING_LEN(v);
5643 ripper_flush(parser);
5647 c = (unsigned char)*lex_p++;
5653 else if (ruby_sourceline > parser->last_cr_line) {
5654 parser->last_cr_line = ruby_sourceline;
5655 rb_compile_warn(ruby_sourcefile, ruby_sourceline, "encountered \\r in middle of line, treated as a mere space");
5663 parser_pushback(struct parser_params *parser, int c)
5665 if (c == -1) return;
5667 if (lex_p > lex_pbeg && lex_p[0] == '\n' && lex_p[-1] == '\r') {
5672 #define was_bol() (lex_p == lex_pbeg + 1)
5674 #define tokfix() (tokenbuf[tokidx]='\0')
5675 #define tok() tokenbuf
5676 #define toklen() tokidx
5677 #define toklast() (tokidx>0?tokenbuf[tokidx-1]:0)
5680 parser_newtok(struct parser_params *parser)
5683 tokline = ruby_sourceline;
5686 tokenbuf = ALLOC_N(char, 60);
5688 if (toksiz > 4096) {
5690 REALLOC_N(tokenbuf, char, 60);
5696 parser_tokspace(struct parser_params *parser, int n)
5700 if (tokidx >= toksiz) {
5701 do {toksiz *= 2;} while (toksiz < tokidx);
5702 REALLOC_N(tokenbuf, char, toksiz);
5704 return &tokenbuf[tokidx-n];
5708 parser_tokadd(struct parser_params *parser, int c)
5710 tokenbuf[tokidx++] = (char)c;
5711 if (tokidx >= toksiz) {
5713 REALLOC_N(tokenbuf, char, toksiz);
5718 parser_tok_hex(struct parser_params *parser, size_t *numlen)
5722 c = scan_hex(lex_p, 2, numlen);
5724 yyerror("invalid hex escape");
5731 #define tokcopy(n) memcpy(tokspace(n), lex_p - (n), (n))
5733 /* return value is for ?\u3042 */
5735 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
5736 int string_literal, int symbol_literal, int regexp_literal)
5739 * If string_literal is true, then we allow multiple codepoints
5740 * in \u{}, and add the codepoints to the current token.
5741 * Otherwise we're parsing a character literal and return a single
5742 * codepoint without adding it
5748 if (regexp_literal) { tokadd('\\'); tokadd('u'); }
5750 if (peek('{')) { /* handle \u{...} form */
5752 if (regexp_literal) { tokadd(*lex_p); }
5754 codepoint = scan_hex(lex_p, 6, &numlen);
5756 yyerror("invalid Unicode escape");
5759 if (codepoint > 0x10ffff) {
5760 yyerror("invalid Unicode codepoint (too large)");
5764 if (regexp_literal) {
5765 tokcopy((int)numlen);
5767 else if (codepoint >= 0x80) {
5768 *encp = rb_utf8_encoding();
5769 if (string_literal) tokaddmbc(codepoint, *encp);
5771 else if (string_literal) {
5774 } while (string_literal && (peek(' ') || peek('\t')));
5777 yyerror("unterminated Unicode escape");
5781 if (regexp_literal) { tokadd('}'); }
5784 else { /* handle \uxxxx form */
5785 codepoint = scan_hex(lex_p, 4, &numlen);
5787 yyerror("invalid Unicode escape");
5791 if (regexp_literal) {
5794 else if (codepoint >= 0x80) {
5795 *encp = rb_utf8_encoding();
5796 if (string_literal) tokaddmbc(codepoint, *encp);
5798 else if (string_literal) {
5806 #define ESCAPE_CONTROL 1
5807 #define ESCAPE_META 2
5810 parser_read_escape(struct parser_params *parser, int flags,
5816 switch (c = nextc()) {
5817 case '\\': /* Backslash */
5820 case 'n': /* newline */
5823 case 't': /* horizontal tab */
5826 case 'r': /* carriage-return */
5829 case 'f': /* form-feed */
5832 case 'v': /* vertical tab */
5835 case 'a': /* alarm(bell) */
5838 case 'e': /* escape */
5841 case '0': case '1': case '2': case '3': /* octal constant */
5842 case '4': case '5': case '6': case '7':
5844 c = scan_oct(lex_p, 3, &numlen);
5848 case 'x': /* hex constant */
5849 c = tok_hex(&numlen);
5850 if (numlen == 0) return 0;
5853 case 'b': /* backspace */
5856 case 's': /* space */
5860 if (flags & ESCAPE_META) goto eof;
5861 if ((c = nextc()) != '-') {
5865 if ((c = nextc()) == '\\') {
5866 if (peek('u')) goto eof;
5867 return read_escape(flags|ESCAPE_META, encp) | 0x80;
5869 else if (c == -1 || !ISASCII(c)) goto eof;
5871 return ((c & 0xff) | 0x80);
5875 if ((c = nextc()) != '-') {
5880 if (flags & ESCAPE_CONTROL) goto eof;
5881 if ((c = nextc())== '\\') {
5882 if (peek('u')) goto eof;
5883 c = read_escape(flags|ESCAPE_CONTROL, encp);
5887 else if (c == -1 || !ISASCII(c)) goto eof;
5892 yyerror("Invalid escape character syntax");
5901 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
5903 int len = rb_enc_codelen(c, enc);
5904 rb_enc_mbcput(c, tokspace(len), enc);
5908 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
5915 switch (c = nextc()) {
5917 return 0; /* just ignore */
5919 case '0': case '1': case '2': case '3': /* octal constant */
5920 case '4': case '5': case '6': case '7':
5922 ruby_scan_oct(--lex_p, 3, &numlen);
5923 if (numlen == 0) goto eof;
5925 tokcopy((int)numlen + 1);
5929 case 'x': /* hex constant */
5932 if (numlen == 0) return -1;
5933 tokcopy((int)numlen + 2);
5938 if (flags & ESCAPE_META) goto eof;
5939 if ((c = nextc()) != '-') {
5944 flags |= ESCAPE_META;
5948 if (flags & ESCAPE_CONTROL) goto eof;
5949 if ((c = nextc()) != '-') {
5957 if (flags & ESCAPE_CONTROL) goto eof;
5959 flags |= ESCAPE_CONTROL;
5961 if ((c = nextc()) == '\\') {
5964 else if (c == -1) goto eof;
5970 yyerror("Invalid escape character syntax");
5981 parser_regx_options(struct parser_params *parser)
5989 while (c = nextc(), ISALPHA(c)) {
5991 options |= RE_OPTION_ONCE;
5993 else if (rb_char_to_option_kcode(c, &opt, &kc)) {
5995 if (kc != rb_ascii8bit_encindex()) kcode = c;
6010 compile_error(PARSER_ARG "unknown regexp option%s - %s",
6011 toklen() > 1 ? "s" : "", tok());
6013 return options | RE_OPTION_ENCODING(kcode);
6017 dispose_string(VALUE str)
6020 rb_gc_force_recycle(str);
6024 parser_tokadd_mbchar(struct parser_params *parser, int c)
6026 int len = parser_precise_mbclen();
6027 if (!MBCLEN_CHARFOUND_P(len)) {
6028 compile_error(PARSER_ARG "invalid multibyte char (%s)", parser_encoding_name());
6033 if (len > 0) tokcopy(len);
6037 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
6040 simple_re_meta(int c)
6043 case '$': case '*': case '+': case '.':
6044 case '?': case '^': case '|':
6045 case ')': case ']': case '}': case '>':
6053 parser_tokadd_string(struct parser_params *parser,
6054 int func, int term, int paren, long *nest,
6058 int has_nonascii = 0;
6059 rb_encoding *enc = *encp;
6061 static const char mixed_msg[] = "%s mixed within %s source";
6063 #define mixed_error(enc1, enc2) if (!errbuf) { \
6064 size_t len = sizeof(mixed_msg) - 4; \
6065 len += strlen(rb_enc_name(enc1)); \
6066 len += strlen(rb_enc_name(enc2)); \
6067 errbuf = ALLOCA_N(char, len); \
6068 snprintf(errbuf, len, mixed_msg, \
6069 rb_enc_name(enc1), \
6070 rb_enc_name(enc2)); \
6073 #define mixed_escape(beg, enc1, enc2) do { \
6074 const char *pos = lex_p; \
6076 mixed_error((enc1), (enc2)); \
6080 while ((c = nextc()) != -1) {
6081 if (paren && c == paren) {
6084 else if (c == term) {
6085 if (!nest || !*nest) {
6091 else if ((func & STR_FUNC_EXPAND) && c == '#' && lex_p < lex_pend) {
6093 if (c2 == '$' || c2 == '@' || c2 == '{') {
6098 else if (c == '\\') {
6099 const char *beg = lex_p - 1;
6103 if (func & STR_FUNC_QWORDS) break;
6104 if (func & STR_FUNC_EXPAND) continue;
6109 if (func & STR_FUNC_ESCAPE) tokadd(c);
6113 if ((func & STR_FUNC_EXPAND) == 0) {
6117 parser_tokadd_utf8(parser, &enc, 1,
6118 func & STR_FUNC_SYMBOL,
6119 func & STR_FUNC_REGEXP);
6120 if (has_nonascii && enc != *encp) {
6121 mixed_escape(beg, enc, *encp);
6126 if (c == -1) return -1;
6128 if ((func & STR_FUNC_EXPAND) == 0) tokadd('\\');
6131 if (func & STR_FUNC_REGEXP) {
6132 if (c == term && !simple_re_meta(c)) {
6137 if ((c = tokadd_escape(&enc)) < 0)
6139 if (has_nonascii && enc != *encp) {
6140 mixed_escape(beg, enc, *encp);
6144 else if (func & STR_FUNC_EXPAND) {
6146 if (func & STR_FUNC_ESCAPE) tokadd('\\');
6147 c = read_escape(0, &enc);
6149 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
6150 /* ignore backslashed spaces in %w */
6152 else if (c != term && !(paren && c == paren)) {
6159 else if (!parser_isascii()) {
6163 mixed_error(enc, *encp);
6166 if (tokadd_mbchar(c) == -1) return -1;
6169 else if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
6176 mixed_error(enc, *encp);
6186 #define NEW_STRTERM(func, term, paren) \
6187 rb_node_newnode(NODE_STRTERM, (func), (term) | ((paren) << (CHAR_BIT * 2)), 0)
6191 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
6193 if (!NIL_P(parser->delayed)) {
6194 ptrdiff_t len = lex_p - parser->tokp;
6196 rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
6198 ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
6199 parser->tokp = lex_p;
6203 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
6205 #define flush_string_content(enc) ((void)(enc))
6208 RUBY_FUNC_EXPORTED const unsigned int ruby_global_name_punct_bits[(0x7e - 0x20 + 31) / 32];
6209 /* this can be shared with ripper, since it's independent from struct
6212 #define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
6213 #define SPECIAL_PUNCT(idx) ( \
6214 BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
6215 BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
6216 BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
6217 BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
6218 BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
6220 const unsigned int ruby_global_name_punct_bits[] = {
6226 #undef SPECIAL_PUNCT
6230 is_global_name_punct(const int c)
6232 if (c <= 0x20 || 0x7e < c) return 0;
6233 return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
6237 parser_peek_variable_name(struct parser_params *parser)
6240 const char *p = lex_p;
6242 if (p + 1 >= lex_pend) return 0;
6246 if ((c = *p) == '-') {
6247 if (++p >= lex_pend) return 0;
6250 else if (is_global_name_punct(c) || ISDIGIT(c)) {
6251 return tSTRING_DVAR;
6255 if ((c = *p) == '@') {
6256 if (++p >= lex_pend) return 0;
6262 command_start = TRUE;
6263 return tSTRING_DBEG;
6267 if (!ISASCII(c) || c == '_' || ISALPHA(c))
6268 return tSTRING_DVAR;
6273 parser_parse_string(struct parser_params *parser, NODE *quote)
6275 int func = (int)quote->nd_func;
6276 int term = nd_term(quote);
6277 int paren = nd_paren(quote);
6279 rb_encoding *enc = current_enc;
6281 if (func == -1) return tSTRING_END;
6283 if ((func & STR_FUNC_QWORDS) && ISSPACE(c)) {
6284 do {c = nextc();} while (ISSPACE(c));
6287 if (c == term && !quote->nd_nest) {
6288 if (func & STR_FUNC_QWORDS) {
6289 quote->nd_func = -1;
6292 if (!(func & STR_FUNC_REGEXP)) return tSTRING_END;
6293 set_yylval_num(regx_options());
6301 if ((func & STR_FUNC_EXPAND) && c == '#') {
6302 int t = parser_peek_variable_name(parser);
6308 if (tokadd_string(func, term, paren, "e->nd_nest,
6310 ruby_sourceline = nd_line(quote);
6311 if (func & STR_FUNC_REGEXP) {
6313 compile_error(PARSER_ARG "unterminated regexp meets end of file");
6318 compile_error(PARSER_ARG "unterminated string meets end of file");
6324 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
6325 flush_string_content(enc);
6327 return tSTRING_CONTENT;
6331 parser_heredoc_identifier(struct parser_params *parser)
6333 int c = nextc(), term, func = 0;
6338 func = STR_FUNC_INDENT;
6342 func |= str_squote; goto quoted;
6344 func |= str_dquote; goto quoted;
6351 while ((c = nextc()) != -1 && c != term) {
6352 if (tokadd_mbchar(c) == -1) return 0;
6355 compile_error(PARSER_ARG "unterminated here document identifier");
6361 if (!parser_is_identchar()) {
6363 if (func & STR_FUNC_INDENT) {
6370 tokadd(func |= str_dquote);
6372 if (tokadd_mbchar(c) == -1) return 0;
6373 } while ((c = nextc()) != -1 && parser_is_identchar());
6380 ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
6382 len = lex_p - lex_pbeg;
6383 lex_goto_eol(parser);
6384 lex_strterm = rb_node_newnode(NODE_HEREDOC,
6385 STR_NEW(tok(), toklen()), /* nd_lit */
6387 lex_lastline); /* nd_orig */
6388 nd_set_line(lex_strterm, ruby_sourceline);
6389 ripper_flush(parser);
6390 return term == '`' ? tXSTRING_BEG : tSTRING_BEG;
6394 parser_heredoc_restore(struct parser_params *parser, NODE *here)
6399 line = here->nd_orig;
6400 lex_lastline = line;
6401 lex_pbeg = RSTRING_PTR(line);
6402 lex_pend = lex_pbeg + RSTRING_LEN(line);
6403 lex_p = lex_pbeg + here->nd_nth;
6404 heredoc_end = ruby_sourceline;
6405 ruby_sourceline = nd_line(here);
6406 dispose_string(here->nd_lit);
6407 rb_gc_force_recycle((VALUE)here);
6408 ripper_flush(parser);
6412 parser_whole_match_p(struct parser_params *parser,
6413 const char *eos, long len, int indent)
6415 const char *p = lex_pbeg;
6419 while (*p && ISSPACE(*p)) p++;
6421 n = lex_pend - (p + len);
6422 if (n < 0) return FALSE;
6423 if (n > 0 && p[len] != '\n') {
6424 if (p[len] != '\r') return FALSE;
6425 if (n <= 1 || p[len+1] != '\n') return FALSE;
6427 return strncmp(eos, p, len) == 0;
6430 #define NUM_SUFFIX_R (1<<0)
6431 #define NUM_SUFFIX_I (1<<1)
6432 #define NUM_SUFFIX_ALL 3
6435 parser_number_literal_suffix(struct parser_params *parser, int mask)
6438 const char *lastp = lex_p;
6440 while ((c = nextc()) != -1) {
6441 if ((mask & NUM_SUFFIX_I) && c == 'i') {
6442 result |= (mask & NUM_SUFFIX_I);
6443 mask &= ~NUM_SUFFIX_I;
6444 /* r after i, rational of complex is disallowed */
6445 mask &= ~NUM_SUFFIX_R;
6448 if ((mask & NUM_SUFFIX_R) && c == 'r') {
6449 result |= (mask & NUM_SUFFIX_R);
6450 mask &= ~NUM_SUFFIX_R;
6453 if (!ISASCII(c) || ISALPHA(c) || c == '_') {
6464 parser_set_number_literal(struct parser_params *parser, VALUE v, int type, int suffix)
6466 if (suffix & NUM_SUFFIX_I) {
6467 v = rb_complex_raw(INT2FIX(0), v);
6470 set_yylval_literal(v);
6475 parser_set_integer_literal(struct parser_params *parser, VALUE v, int suffix)
6477 int type = tINTEGER;
6478 if (suffix & NUM_SUFFIX_R) {
6479 v = rb_rational_raw1(v);
6482 return set_number_literal(v, type, suffix);
6487 ripper_dispatch_heredoc_end(struct parser_params *parser)
6489 if (!NIL_P(parser->delayed))
6490 ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
6491 lex_goto_eol(parser);
6492 ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
6495 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
6497 #define dispatch_heredoc_end() ((void)0)
6501 parser_here_document(struct parser_params *parser, NODE *here)
6503 int c, func, indent = 0;
6504 const char *eos, *p, *pend;
6507 rb_encoding *enc = current_enc;
6509 eos = RSTRING_PTR(here->nd_lit);
6510 len = RSTRING_LEN(here->nd_lit) - 1;
6511 indent = (func = *eos++) & STR_FUNC_INDENT;
6513 if ((c = nextc()) == -1) {
6515 compile_error(PARSER_ARG "can't find string \"%s\" anywhere before EOF", eos);
6517 if (NIL_P(parser->delayed)) {
6518 ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
6522 ((len = lex_p - parser->tokp) > 0 &&
6523 (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
6524 rb_str_append(parser->delayed, str);
6526 ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
6528 lex_goto_eol(parser);
6531 heredoc_restore(lex_strterm);
6534 if (was_bol() && whole_match_p(eos, len, indent)) {
6535 dispatch_heredoc_end();
6536 heredoc_restore(lex_strterm);
6540 if (!(func & STR_FUNC_EXPAND)) {
6542 p = RSTRING_PTR(lex_lastline);
6547 if (--pend == p || pend[-1] != '\r') {
6556 rb_str_cat(str, p, pend - p);
6558 str = STR_NEW(p, pend - p);
6559 if (pend < lex_pend) rb_str_cat(str, "\n", 1);
6560 lex_goto_eol(parser);
6561 if (nextc() == -1) {
6563 dispose_string(str);
6568 } while (!whole_match_p(eos, len, indent));
6571 /* int mb = ENC_CODERANGE_7BIT, *mbp = &mb;*/
6574 int t = parser_peek_variable_name(parser);
6581 if ((c = tokadd_string(func, '\n', 0, NULL, &enc)) == -1) {
6582 if (parser->eofp) goto error;
6586 set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
6587 flush_string_content(enc);
6588 return tSTRING_CONTENT;
6591 /* if (mbp && mb == ENC_CODERANGE_UNKNOWN) mbp = 0;*/
6592 if ((c = nextc()) == -1) goto error;
6593 } while (!whole_match_p(eos, len, indent));
6594 str = STR_NEW3(tok(), toklen(), enc, func);
6596 dispatch_heredoc_end();
6597 heredoc_restore(lex_strterm);
6598 lex_strterm = NEW_STRTERM(-1, 0, 0);
6599 set_yylval_str(str);
6600 return tSTRING_CONTENT;
6606 arg_ambiguous_gen(struct parser_params *parser)
6609 rb_warning0("ambiguous first argument; put parentheses or even spaces");
6611 dispatch0(arg_ambiguous);
6614 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
6617 formal_argument_gen(struct parser_params *parser, ID lhs)
6620 if (!is_local_id(lhs))
6621 yyerror("formal argument must be local variable");
6623 shadowing_lvar(lhs);
6628 lvar_defined_gen(struct parser_params *parser, ID id)
6630 return (dyna_in_block() && dvar_defined_get(id)) || local_id(id);
6633 /* emacsen -*- hack */
6635 parser_encode_length(struct parser_params *parser, const char *name, long len)
6639 if (len > 5 && name[nlen = len - 5] == '-') {
6640 if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
6643 if (len > 4 && name[nlen = len - 4] == '-') {
6644 if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
6646 if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
6647 !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
6648 /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
6655 parser_set_encode(struct parser_params *parser, const char *name)
6657 int idx = rb_enc_find_index(name);
6662 excargs[1] = rb_sprintf("unknown encoding name: %s", name);
6664 excargs[0] = rb_eArgError;
6665 excargs[2] = rb_make_backtrace();
6666 rb_ary_unshift(excargs[2], rb_sprintf("%s:%d", ruby_sourcefile, ruby_sourceline));
6667 rb_exc_raise(rb_make_exception(3, excargs));
6669 enc = rb_enc_from_index(idx);
6670 if (!rb_enc_asciicompat(enc)) {
6671 excargs[1] = rb_sprintf("%s is not ASCII compatible", rb_enc_name(enc));
6676 if (ruby_debug_lines) {
6677 VALUE lines = ruby_debug_lines;
6678 long i, n = RARRAY_LEN(lines);
6679 for (i = 0; i < n; ++i) {
6680 rb_enc_associate_index(RARRAY_AREF(lines, i), idx);
6687 comment_at_top(struct parser_params *parser)
6689 const char *p = lex_pbeg, *pend = lex_p - 1;
6690 if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
6692 if (!ISSPACE(*p)) return 0;
6699 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
6700 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
6703 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
6705 if (!comment_at_top(parser)) {
6708 parser_set_encode(parser, val);
6712 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
6714 int *p = &parser->parser_token_info_enabled;
6718 if (strcasecmp(val, "true") == 0) {
6724 if (strcasecmp(val, "false") == 0) {
6730 rb_compile_warning(ruby_sourcefile, ruby_sourceline, "invalid value for %s: %s", name, val);
6733 struct magic_comment {
6735 rb_magic_comment_setter_t func;
6736 rb_magic_comment_length_t length;
6739 static const struct magic_comment magic_comments[] = {
6740 {"coding", magic_comment_encoding, parser_encode_length},
6741 {"encoding", magic_comment_encoding, parser_encode_length},
6742 {"warn_indent", parser_set_token_info},
6747 magic_comment_marker(const char *str, long len)
6754 if (str[i-1] == '*' && str[i-2] == '-') {
6760 if (i + 1 >= len) return 0;
6761 if (str[i+1] != '-') {
6764 else if (str[i-1] != '-') {
6780 parser_magic_comment(struct parser_params *parser, const char *str, long len)
6782 VALUE name = 0, val = 0;
6783 const char *beg, *end, *vbeg, *vend;
6784 #define str_copy(_s, _p, _n) ((_s) \
6785 ? (void)(rb_str_resize((_s), (_n)), \
6786 MEMCPY(RSTRING_PTR(_s), (_p), char, (_n)), (_s)) \
6787 : (void)((_s) = STR_NEW((_p), (_n))))
6789 if (len <= 7) return FALSE;
6790 if (!(beg = magic_comment_marker(str, len))) return FALSE;
6791 if (!(end = magic_comment_marker(beg, str + len - beg))) return FALSE;
6793 len = end - beg - 3;
6795 /* %r"([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*" */
6798 const struct magic_comment *p = magic_comments;
6804 for (; len > 0 && *str; str++, --len) {
6806 case '\'': case '"': case ':': case ';':
6809 if (!ISSPACE(*str)) break;
6811 for (beg = str; len > 0; str++, --len) {
6813 case '\'': case '"': case ':': case ';':
6816 if (ISSPACE(*str)) break;
6821 for (end = str; len > 0 && ISSPACE(*str); str++, --len);
6823 if (*str != ':') continue;
6825 do str++; while (--len > 0 && ISSPACE(*str));
6828 for (vbeg = ++str; --len > 0 && *str != '"'; str++) {
6841 for (vbeg = str; len > 0 && *str != '"' && *str != ';' && !ISSPACE(*str); --len, str++);
6844 while (len > 0 && (*str == ';' || ISSPACE(*str))) --len, str++;
6847 str_copy(name, beg, n);
6848 s = RSTRING_PTR(name);
6849 for (i = 0; i < n; ++i) {
6850 if (s[i] == '-') s[i] = '_';
6854 if (STRNCASECMP(p->name, s, n) == 0) {
6857 n = (*p->length)(parser, vbeg, n);
6859 str_copy(val, vbeg, n);
6860 (*p->func)(parser, s, RSTRING_PTR(val));
6863 } while (++p < magic_comments + numberof(magic_comments));
6865 str_copy(val, vbeg, vend - vbeg);
6866 dispatch2(magic_comment, name, val);
6874 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
6877 const char *beg = str;
6881 if (send - str <= 6) return;
6883 case 'C': case 'c': str += 6; continue;
6884 case 'O': case 'o': str += 5; continue;
6885 case 'D': case 'd': str += 4; continue;
6886 case 'I': case 'i': str += 3; continue;
6887 case 'N': case 'n': str += 2; continue;
6888 case 'G': case 'g': str += 1; continue;
6895 if (ISSPACE(*str)) break;
6898 if (STRNCASECMP(str-6, "coding", 6) == 0) break;
6902 if (++str >= send) return;
6903 } while (ISSPACE(*str));
6905 if (*str != '=' && *str != ':') return;
6910 while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
6911 s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
6912 parser_set_encode(parser, RSTRING_PTR(s));
6913 rb_str_resize(s, 0);
6917 parser_prepare(struct parser_params *parser)
6922 if (peek('!')) parser->has_shebang = 1;
6924 case 0xef: /* UTF-8 BOM marker */
6925 if (lex_pend - lex_p >= 2 &&
6926 (unsigned char)lex_p[0] == 0xbb &&
6927 (unsigned char)lex_p[1] == 0xbf) {
6928 parser->enc = rb_utf8_encoding();
6938 parser->enc = rb_enc_get(lex_lastline);
6941 #define IS_ARG() IS_lex_state(EXPR_ARG_ANY)
6942 #define IS_END() IS_lex_state(EXPR_END_ANY)
6943 #define IS_BEG() IS_lex_state(EXPR_BEG_ANY)
6944 #define IS_SPCARG(c) (IS_ARG() && space_seen && !ISSPACE(c))
6945 #define IS_LABEL_POSSIBLE() ((IS_lex_state(EXPR_BEG | EXPR_ENDFN) && !cmd_state) || IS_ARG())
6946 #define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
6947 #define IS_AFTER_OPERATOR() IS_lex_state(EXPR_FNAME | EXPR_DOT)
6950 #define ambiguous_operator(op, syn) ( \
6951 rb_warning0("`"op"' after local variable or literal is interpreted as binary operator"), \
6952 rb_warning0("even though it seems like "syn""))
6954 #define ambiguous_operator(op, syn) dispatch2(operator_ambiguous, ripper_intern(op), rb_str_new_cstr(syn))
6956 #define warn_balanced(op, syn) ((void) \
6957 (!IS_lex_state_for(last_state, EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
6958 space_seen && !ISSPACE(c) && \
6959 (ambiguous_operator(op, syn), 0)))
6962 parse_numvar(struct parser_params *parser)
6966 unsigned long n = ruby_scan_digits(tok()+1, toklen()-1, 10, &len, &overflow);
6967 const unsigned long nth_ref_max =
6968 ((FIXNUM_MAX < INT_MAX) ? FIXNUM_MAX : INT_MAX) >> 1;
6969 /* NTH_REF is left-shifted to be ORed with back-ref flag and
6970 * turned into a Fixnum, in compile.c */
6972 if (overflow || n > nth_ref_max) {
6973 /* compile_error()? */
6974 rb_warnS("`%s' is too big for a number variable, always nil", tok());
6975 return 0; /* $0 is $PROGRAM_NAME, not NTH_REF */
6983 parser_yylex(struct parser_params *parser)
6988 enum lex_state_e last_state;
6992 int fallthru = FALSE;
6997 if (nd_type(lex_strterm) == NODE_HEREDOC) {
6998 token = here_document(lex_strterm);
6999 if (token == tSTRING_END) {
7001 lex_state = EXPR_END;
7005 token = parse_string(lex_strterm);
7006 if (token == tSTRING_END || token == tREGEXP_END) {
7007 rb_gc_force_recycle((VALUE)lex_strterm);
7009 lex_state = EXPR_END;
7014 cmd_state = command_start;
7015 command_start = FALSE;
7017 last_state = lex_state;
7018 switch (c = nextc()) {
7019 case '\0': /* NUL */
7020 case '\004': /* ^D */
7021 case '\032': /* ^Z */
7022 case -1: /* end of script. */
7026 case ' ': case '\t': case '\f': case '\r':
7027 case '\13': /* '\v' */
7030 while ((c = nextc())) {
7032 case ' ': case '\t': case '\f': case '\r':
7033 case '\13': /* '\v' */
7041 ripper_dispatch_scan_event(parser, tSP);
7045 case '#': /* it's a comment */
7046 /* no magic_comment in shebang line */
7047 if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
7048 if (comment_at_top(parser)) {
7049 set_file_encoding(parser, lex_p, lex_pend);
7054 ripper_dispatch_scan_event(parser, tCOMMENT);
7059 if (IS_lex_state(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT | EXPR_LABELARG)) {
7062 ripper_dispatch_scan_event(parser, tIGNORED_NL);
7066 if (IS_lex_state(EXPR_LABELARG) && parser->parser_in_kwarg) {
7067 goto normal_newline;
7071 while ((c = nextc())) {
7073 case ' ': case '\t': case '\f': case '\r':
7074 case '\13': /* '\v' */
7078 if ((c = nextc()) != '.') {
7086 lex_nextline = lex_lastline;
7087 case -1: /* EOF no decrement*/
7088 lex_goto_eol(parser);
7091 parser->tokp = lex_p;
7094 goto normal_newline;
7098 command_start = TRUE;
7099 lex_state = EXPR_BEG;
7103 if ((c = nextc()) == '*') {
7104 if ((c = nextc()) == '=') {
7105 set_yylval_id(tPOW);
7106 lex_state = EXPR_BEG;
7111 rb_warning0("`**' interpreted as argument prefix");
7114 else if (IS_BEG()) {
7118 warn_balanced("**", "argument prefix");
7125 lex_state = EXPR_BEG;
7130 rb_warning0("`*' interpreted as argument prefix");
7133 else if (IS_BEG()) {
7137 warn_balanced("*", "argument prefix");
7141 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
7146 if (IS_AFTER_OPERATOR()) {
7147 lex_state = EXPR_ARG;
7153 lex_state = EXPR_BEG;
7166 /* skip embedded rd document */
7167 if (strncmp(lex_p, "begin", 5) == 0 && ISSPACE(lex_p[5])) {
7171 lex_goto_eol(parser);
7172 ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
7175 lex_goto_eol(parser);
7178 ripper_dispatch_scan_event(parser, tEMBDOC);
7184 compile_error(PARSER_ARG "embedded document meets end of file");
7187 if (c != '=') continue;
7188 if (strncmp(lex_p, "end", 3) == 0 &&
7189 (lex_p + 3 == lex_pend || ISSPACE(lex_p[3]))) {
7193 lex_goto_eol(parser);
7195 ripper_dispatch_scan_event(parser, tEMBDOC_END);
7201 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
7202 if ((c = nextc()) == '=') {
7203 if ((c = nextc()) == '=') {
7212 else if (c == '>') {
7219 last_state = lex_state;
7222 !IS_lex_state(EXPR_DOT | EXPR_CLASS) &&
7224 (!IS_ARG() || space_seen)) {
7225 int token = heredoc_identifier();
7226 if (token) return token;
7228 if (IS_AFTER_OPERATOR()) {
7229 lex_state = EXPR_ARG;
7232 if (IS_lex_state(EXPR_CLASS))
7233 command_start = TRUE;
7234 lex_state = EXPR_BEG;
7237 if ((c = nextc()) == '>') {
7244 if ((c = nextc()) == '=') {
7245 set_yylval_id(tLSHFT);
7246 lex_state = EXPR_BEG;
7250 warn_balanced("<<", "here document");
7257 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
7258 if ((c = nextc()) == '=') {
7262 if ((c = nextc()) == '=') {
7263 set_yylval_id(tRSHFT);
7264 lex_state = EXPR_BEG;
7274 lex_strterm = NEW_STRTERM(str_dquote, '"', 0);
7278 if (IS_lex_state(EXPR_FNAME)) {
7279 lex_state = EXPR_ENDFN;
7282 if (IS_lex_state(EXPR_DOT)) {
7284 lex_state = EXPR_CMDARG;
7286 lex_state = EXPR_ARG;
7289 lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
7290 return tXSTRING_BEG;
7293 lex_strterm = NEW_STRTERM(str_squote, '\'', 0);
7298 lex_state = EXPR_VALUE;
7303 compile_error(PARSER_ARG "incomplete character syntax");
7306 if (rb_enc_isspace(c, current_enc)) {
7330 rb_warnI("invalid character syntax; use ?\\%c", c2);
7335 lex_state = EXPR_VALUE;
7340 if (!parser_isascii()) {
7341 if (tokadd_mbchar(c) == -1) return 0;
7343 else if ((rb_enc_isalnum(c, current_enc) || c == '_') &&
7344 lex_p < lex_pend && is_identchar(lex_p, lex_pend, current_enc)) {
7347 else if (c == '\\') {
7350 c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
7358 else if (!lex_eol_p() && !(c = *lex_p, ISASCII(c))) {
7360 if (tokadd_mbchar(c) == -1) return 0;
7363 c = read_escape(0, &enc);
7371 set_yylval_str(STR_NEW3(tok(), toklen(), enc, 0));
7372 lex_state = EXPR_END;
7376 if ((c = nextc()) == '&') {
7377 lex_state = EXPR_BEG;
7378 if ((c = nextc()) == '=') {
7379 set_yylval_id(tANDOP);
7380 lex_state = EXPR_BEG;
7386 else if (c == '=') {
7388 lex_state = EXPR_BEG;
7393 rb_warning0("`&' interpreted as argument prefix");
7396 else if (IS_BEG()) {
7400 warn_balanced("&", "argument prefix");
7403 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
7407 if ((c = nextc()) == '|') {
7408 lex_state = EXPR_BEG;
7409 if ((c = nextc()) == '=') {
7410 set_yylval_id(tOROP);
7411 lex_state = EXPR_BEG;
7419 lex_state = EXPR_BEG;
7422 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
7428 if (IS_AFTER_OPERATOR()) {
7429 lex_state = EXPR_ARG;
7438 lex_state = EXPR_BEG;
7441 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
7442 lex_state = EXPR_BEG;
7444 if (c != -1 && ISDIGIT(c)) {
7450 lex_state = EXPR_BEG;
7452 warn_balanced("+", "unary operator");
7457 if (IS_AFTER_OPERATOR()) {
7458 lex_state = EXPR_ARG;
7467 lex_state = EXPR_BEG;
7471 lex_state = EXPR_ENDFN;
7474 if (IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
7475 lex_state = EXPR_BEG;
7477 if (c != -1 && ISDIGIT(c)) {
7482 lex_state = EXPR_BEG;
7484 warn_balanced("-", "unary operator");
7488 lex_state = EXPR_BEG;
7489 if ((c = nextc()) == '.') {
7490 if ((c = nextc()) == '.') {
7497 if (c != -1 && ISDIGIT(c)) {
7498 yyerror("no .<digit> floating literal anymore; put 0 before dot");
7500 lex_state = EXPR_DOT;
7504 case '0': case '1': case '2': case '3': case '4':
7505 case '5': case '6': case '7': case '8': case '9':
7507 int is_float, seen_point, seen_e, nondigit;
7510 is_float = seen_point = seen_e = nondigit = 0;
7511 lex_state = EXPR_END;
7513 if (c == '-' || c == '+') {
7518 #define no_digits() do {yyerror("numeric literal without digits"); return 0;} while (0)
7519 int start = toklen();
7521 if (c == 'x' || c == 'X') {
7524 if (c != -1 && ISXDIGIT(c)) {
7527 if (nondigit) break;
7531 if (!ISXDIGIT(c)) break;
7534 } while ((c = nextc()) != -1);
7538 if (toklen() == start) {
7541 else if (nondigit) goto trailing_uc;
7542 suffix = number_literal_suffix(NUM_SUFFIX_ALL);
7543 return set_integer_literal(rb_cstr_to_inum(tok(), 16, FALSE), suffix);
7545 if (c == 'b' || c == 'B') {
7548 if (c == '0' || c == '1') {
7551 if (nondigit) break;
7555 if (c != '0' && c != '1') break;
7558 } while ((c = nextc()) != -1);
7562 if (toklen() == start) {
7565 else if (nondigit) goto trailing_uc;
7566 suffix = number_literal_suffix(NUM_SUFFIX_ALL);
7567 return set_integer_literal(rb_cstr_to_inum(tok(), 2, FALSE), suffix);
7569 if (c == 'd' || c == 'D') {
7572 if (c != -1 && ISDIGIT(c)) {
7575 if (nondigit) break;
7579 if (!ISDIGIT(c)) break;
7582 } while ((c = nextc()) != -1);
7586 if (toklen() == start) {
7589 else if (nondigit) goto trailing_uc;
7590 suffix = number_literal_suffix(NUM_SUFFIX_ALL);
7591 return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
7597 if (c == 'o' || c == 'O') {
7598 /* prefixed octal */
7600 if (c == -1 || c == '_' || !ISDIGIT(c)) {
7604 if (c >= '0' && c <= '7') {
7609 if (nondigit) break;
7613 if (c < '0' || c > '9') break;
7614 if (c > '7') goto invalid_octal;
7617 } while ((c = nextc()) != -1);
7618 if (toklen() > start) {
7621 if (nondigit) goto trailing_uc;
7622 suffix = number_literal_suffix(NUM_SUFFIX_ALL);
7623 return set_integer_literal(rb_cstr_to_inum(tok(), 8, FALSE), suffix);
7630 if (c > '7' && c <= '9') {
7632 yyerror("Invalid octal digit");
7634 else if (c == '.' || c == 'e' || c == 'E') {
7639 suffix = number_literal_suffix(NUM_SUFFIX_ALL);
7640 return set_integer_literal(INT2FIX(0), suffix);
7646 case '0': case '1': case '2': case '3': case '4':
7647 case '5': case '6': case '7': case '8': case '9':
7653 if (nondigit) goto trailing_uc;
7654 if (seen_point || seen_e) {
7659 if (c0 == -1 || !ISDIGIT(c0)) {
7665 seen_point = toklen();
7684 if (c != '-' && c != '+' && !ISDIGIT(c)) {
7693 nondigit = (c == '-' || c == '+') ? c : 0;
7696 case '_': /* `_' in number just ignored */
7697 if (nondigit) goto decode_num;
7712 snprintf(tmp, sizeof(tmp), "trailing `%c' in number", nondigit);
7720 suffix = number_literal_suffix(seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
7721 if (suffix & NUM_SUFFIX_R) {
7722 char *point = &tok()[seen_point];
7723 size_t fraclen = toklen()-seen_point-1;
7725 memmove(point, point+1, fraclen+1);
7726 v = rb_cstr_to_inum(tok(), 10, FALSE);
7727 v = rb_rational_new(v, rb_int_positive_pow(10, fraclen));
7730 double d = strtod(tok(), 0);
7731 if (errno == ERANGE) {
7732 rb_warningS("Float %s out of range", tok());
7737 return set_number_literal(v, type, suffix);
7739 suffix = number_literal_suffix(NUM_SUFFIX_ALL);
7740 return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
7750 lex_state = EXPR_ENDFN;
7752 lex_state = EXPR_ENDARG;
7754 if (!brace_nest--) c = tSTRING_DEND;
7761 if (IS_BEG() || IS_lex_state(EXPR_CLASS) || IS_SPCARG(-1)) {
7762 lex_state = EXPR_BEG;
7765 lex_state = EXPR_DOT;
7768 if (IS_END() || ISSPACE(c)) {
7770 warn_balanced(":", "symbol literal");
7771 lex_state = EXPR_BEG;
7776 lex_strterm = NEW_STRTERM(str_ssym, c, 0);
7779 lex_strterm = NEW_STRTERM(str_dsym, c, 0);
7785 lex_state = EXPR_FNAME;
7789 if (IS_lex_state(EXPR_BEG_ANY)) {
7790 lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
7793 if ((c = nextc()) == '=') {
7795 lex_state = EXPR_BEG;
7800 (void)arg_ambiguous();
7801 lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
7804 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
7805 warn_balanced("/", "regexp literal");
7809 if ((c = nextc()) == '=') {
7811 lex_state = EXPR_BEG;
7814 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
7819 lex_state = EXPR_BEG;
7820 command_start = TRUE;
7824 lex_state = EXPR_BEG;
7828 if (IS_AFTER_OPERATOR()) {
7829 if ((c = nextc()) != '@') {
7832 lex_state = EXPR_ARG;
7835 lex_state = EXPR_BEG;
7843 else if (IS_SPCARG(-1)) {
7849 lex_state = EXPR_BEG;
7854 if (IS_AFTER_OPERATOR()) {
7855 lex_state = EXPR_ARG;
7856 if ((c = nextc()) == ']') {
7857 if ((c = nextc()) == '=') {
7866 else if (IS_BEG()) {
7869 else if (IS_ARG() && space_seen) {
7872 lex_state = EXPR_BEG;
7879 if (lpar_beg && lpar_beg == paren_nest) {
7880 lex_state = EXPR_BEG;
7887 if (IS_ARG() || IS_lex_state(EXPR_END | EXPR_ENDFN))
7888 c = '{'; /* block (primary) */
7889 else if (IS_lex_state(EXPR_ENDARG))
7890 c = tLBRACE_ARG; /* block (expr) */
7892 c = tLBRACE; /* hash */
7895 lex_state = EXPR_BEG;
7896 if (c != tLBRACE) command_start = TRUE;
7904 ripper_dispatch_scan_event(parser, tSP);
7906 goto retry; /* skip \\n */
7912 if (IS_lex_state(EXPR_BEG_ANY)) {
7918 if (c == -1 || !ISALNUM(c)) {
7924 if (rb_enc_isalnum(term, current_enc) || !parser_isascii()) {
7925 yyerror("unknown type of %string");
7929 if (c == -1 || term == -1) {
7930 compile_error(PARSER_ARG "unterminated quoted string meets end of file");
7934 if (term == '(') term = ')';
7935 else if (term == '[') term = ']';
7936 else if (term == '{') term = '}';
7937 else if (term == '<') term = '>';
7942 lex_strterm = NEW_STRTERM(str_dquote, term, paren);
7946 lex_strterm = NEW_STRTERM(str_squote, term, paren);
7950 lex_strterm = NEW_STRTERM(str_dword, term, paren);
7951 do {c = nextc();} while (ISSPACE(c));
7956 lex_strterm = NEW_STRTERM(str_sword, term, paren);
7957 do {c = nextc();} while (ISSPACE(c));
7962 lex_strterm = NEW_STRTERM(str_dword, term, paren);
7963 do {c = nextc();} while (ISSPACE(c));
7965 return tSYMBOLS_BEG;
7968 lex_strterm = NEW_STRTERM(str_sword, term, paren);
7969 do {c = nextc();} while (ISSPACE(c));
7971 return tQSYMBOLS_BEG;
7974 lex_strterm = NEW_STRTERM(str_xquote, term, paren);
7975 return tXSTRING_BEG;
7978 lex_strterm = NEW_STRTERM(str_regexp, term, paren);
7982 lex_strterm = NEW_STRTERM(str_ssym, term, paren);
7983 lex_state = EXPR_FNAME;
7987 yyerror("unknown type of %string");
7991 if ((c = nextc()) == '=') {
7993 lex_state = EXPR_BEG;
7999 lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
8001 warn_balanced("%%", "string literal");
8005 lex_state = EXPR_END;
8009 case '_': /* $_: last read line string */
8011 if (parser_is_identchar()) {
8019 case '~': /* $~: match-data */
8020 case '*': /* $*: argv */
8021 case '$': /* $$: pid */
8022 case '?': /* $?: last status */
8023 case '!': /* $!: error string */
8024 case '@': /* $@: error position */
8025 case '/': /* $/: input record separator */
8026 case '\\': /* $\: output record separator */
8027 case ';': /* $;: field separator */
8028 case ',': /* $,: output field separator */
8029 case '.': /* $.: last read line number */
8030 case '=': /* $=: ignorecase */
8031 case ':': /* $:: load path */
8032 case '<': /* $<: reading filename */
8033 case '>': /* $>: default output handle */
8034 case '\"': /* $": already loaded files */
8043 if (parser_is_identchar()) {
8044 if (tokadd_mbchar(c) == -1) return 0;
8052 set_yylval_name(rb_intern3(tok(), tokidx, current_enc));
8055 case '&': /* $&: last match */
8056 case '`': /* $`: string before last match */
8057 case '\'': /* $': string after last match */
8058 case '+': /* $+: string matches last paren. */
8059 if (IS_lex_state_for(last_state, EXPR_FNAME)) {
8064 set_yylval_node(NEW_BACK_REF(c));
8067 case '1': case '2': case '3':
8068 case '4': case '5': case '6':
8069 case '7': case '8': case '9':
8074 } while (c != -1 && ISDIGIT(c));
8076 if (IS_lex_state_for(last_state, EXPR_FNAME)) goto gvar;
8078 set_yylval_node(NEW_NTH_REF(parse_numvar(parser)));
8082 if (!parser_is_identchar()) {
8084 compile_error(PARSER_ARG "`$%c' is not allowed as a global variable name", c);
8100 if (c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
8103 compile_error(PARSER_ARG "`@%c' is not allowed as an instance variable name", c);
8106 compile_error(PARSER_ARG "`@@%c' is not allowed as a class variable name", c);
8113 if (was_bol() && whole_match_p("__END__", 7, 0)) {
8114 ruby__end__seen = 1;
8115 parser->eofp = Qtrue;
8119 lex_goto_eol(parser);
8120 ripper_dispatch_scan_event(parser, k__END__);
8128 if (!parser_is_identchar()) {
8129 compile_error(PARSER_ARG "Invalid char `\\x%02X' in expression", c);
8137 mb = ENC_CODERANGE_7BIT;
8139 if (!ISASCII(c)) mb = ENC_CODERANGE_UNKNOWN;
8140 if (tokadd_mbchar(c) == -1) return 0;
8142 } while (parser_is_identchar());
8148 if ((c == '!' || c == '?') && !peek('=')) {
8160 last_state = lex_state;
8163 lex_state = EXPR_END;
8167 lex_state = EXPR_END;
8168 if (tok()[1] == '@')
8175 if (toklast() == '!' || toklast() == '?') {
8179 if (IS_lex_state(EXPR_FNAME)) {
8180 if ((c = nextc()) == '=' && !peek('~') && !peek('>') &&
8181 (!peek('=') || (peek_n('>', 1)))) {
8182 result = tIDENTIFIER;
8190 if (result == 0 && ISUPPER(tok()[0])) {
8194 result = tIDENTIFIER;
8198 if (IS_LABEL_POSSIBLE()) {
8199 if (IS_LABEL_SUFFIX(0)) {
8200 lex_state = EXPR_LABELARG;
8202 set_yylval_name(TOK_INTERN(!ENC_SINGLE(mb)));
8206 if (mb == ENC_CODERANGE_7BIT && !IS_lex_state(EXPR_DOT)) {
8207 const struct kwtable *kw;
8209 /* See if it is a reserved word. */
8210 kw = rb_reserved_word(tok(), toklen());
8212 enum lex_state_e state = lex_state;
8213 lex_state = kw->state;
8214 if (IS_lex_state_for(state, EXPR_FNAME)) {
8215 set_yylval_name(rb_intern(kw->name));
8218 if (IS_lex_state(EXPR_BEG)) {
8219 command_start = TRUE;
8221 if (kw->id[0] == keyword_do) {
8222 if (lpar_beg && lpar_beg == paren_nest) {
8225 return keyword_do_LAMBDA;
8227 if (COND_P()) return keyword_do_cond;
8228 if (CMDARG_P() && !IS_lex_state_for(state, EXPR_CMDARG))
8229 return keyword_do_block;
8230 if (IS_lex_state_for(state, (EXPR_BEG | EXPR_ENDARG)))
8231 return keyword_do_block;
8234 if (IS_lex_state_for(state, (EXPR_BEG | EXPR_VALUE | EXPR_LABELARG)))
8237 if (kw->id[0] != kw->id[1])
8238 lex_state = EXPR_BEG;
8244 if (IS_lex_state(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
8246 lex_state = EXPR_CMDARG;
8249 lex_state = EXPR_ARG;
8252 else if (lex_state == EXPR_FNAME) {
8253 lex_state = EXPR_ENDFN;
8256 lex_state = EXPR_END;
8260 ID ident = TOK_INTERN(!ENC_SINGLE(mb));
8262 set_yylval_name(ident);
8263 if (!IS_lex_state_for(last_state, EXPR_DOT|EXPR_FNAME) &&
8264 is_local_id(ident) && lvar_defined(ident)) {
8265 lex_state = EXPR_END;
8274 yylex(void *lval, void *p)
8279 struct parser_params *parser = (struct parser_params*)p;
8283 parser->parser_yylval = lval;
8284 parser->parser_yylval->val = Qundef;
8286 t = parser_yylex(parser);
8288 if (!NIL_P(parser->delayed)) {
8289 ripper_dispatch_delayed_token(parser, t);
8293 ripper_dispatch_scan_event(parser, t);
8301 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
8303 NODE *n = (rb_node_newnode)(type, a0, a1, a2);
8304 nd_set_line(n, ruby_sourceline);
8308 static enum node_type
8309 nodetype(NODE *node) /* for debug */
8311 return (enum node_type)nd_type(node);
8315 nodeline(NODE *node)
8317 return nd_line(node);
8321 newline_node(NODE *node)
8324 node = remove_begin(node);
8325 node->flags |= NODE_FL_NEWLINE;
8331 fixpos(NODE *node, NODE *orig)
8335 if (orig == (NODE*)1) return;
8336 nd_set_line(node, nd_line(orig));
8340 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
8342 rb_compile_warning(ruby_sourcefile, nd_line(node), "%s", mesg);
8344 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
8347 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
8349 rb_compile_warn(ruby_sourcefile, nd_line(node), "%s", mesg);
8351 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
8354 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
8356 NODE *end, *h = head, *nd;
8358 if (tail == 0) return head;
8360 if (h == 0) return tail;
8361 switch (nd_type(h)) {
8368 parser_warning(h, "unused literal ignored");
8371 h = end = NEW_BLOCK(head);
8382 switch (nd_type(nd)) {
8388 if (RTEST(ruby_verbose)) {
8389 parser_warning(tail, "statement not reached");
8397 if (nd_type(tail) != NODE_BLOCK) {
8398 tail = NEW_BLOCK(tail);
8399 tail->nd_end = tail;
8401 end->nd_next = tail;
8402 h->nd_end = tail->nd_end;
8406 /* append item to the list */
8408 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
8412 if (list == 0) return NEW_LIST(item);
8413 if (list->nd_next) {
8414 last = list->nd_next->nd_end;
8421 last->nd_next = NEW_LIST(item);
8422 list->nd_next->nd_end = last->nd_next;
8426 /* concat two lists */
8428 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
8432 if (head->nd_next) {
8433 last = head->nd_next->nd_end;
8439 head->nd_alen += tail->nd_alen;
8440 last->nd_next = tail;
8441 if (tail->nd_next) {
8442 head->nd_next->nd_end = tail->nd_next->nd_end;
8445 head->nd_next->nd_end = tail;
8452 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
8454 if (NIL_P(tail)) return 1;
8455 if (!rb_enc_compatible(head, tail)) {
8456 compile_error(PARSER_ARG "string literal encodings differ (%s / %s)",
8457 rb_enc_name(rb_enc_get(head)),
8458 rb_enc_name(rb_enc_get(tail)));
8459 rb_str_resize(head, 0);
8460 rb_str_resize(tail, 0);
8463 rb_str_buf_append(head, tail);
8467 /* concat two string literals */
8469 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
8471 enum node_type htype;
8475 if (!head) return tail;
8476 if (!tail) return head;
8478 htype = nd_type(head);
8479 if (htype == NODE_EVSTR) {
8480 NODE *node = NEW_DSTR(STR_NEW0());
8481 head = list_append(node, head);
8484 switch (nd_type(tail)) {
8486 if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
8487 nd_type(headlast) == NODE_STR) {
8489 lit = headlast->nd_lit;
8494 if (htype == NODE_STR) {
8495 if (!literal_concat0(parser, lit, tail->nd_lit)) {
8497 rb_gc_force_recycle((VALUE)head);
8498 rb_gc_force_recycle((VALUE)tail);
8501 rb_gc_force_recycle((VALUE)tail);
8504 list_append(head, tail);
8509 if (htype == NODE_STR) {
8510 if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
8512 tail->nd_lit = head->nd_lit;
8513 rb_gc_force_recycle((VALUE)head);
8516 else if (NIL_P(tail->nd_lit)) {
8518 head->nd_alen += tail->nd_alen - 1;
8519 head->nd_next->nd_end->nd_next = tail->nd_next;
8520 head->nd_next->nd_end = tail->nd_next->nd_end;
8521 rb_gc_force_recycle((VALUE)tail);
8523 else if (htype == NODE_DSTR && (headlast = head->nd_next->nd_end->nd_head) &&
8524 nd_type(headlast) == NODE_STR) {
8525 lit = headlast->nd_lit;
8526 if (!literal_concat0(parser, lit, tail->nd_lit))
8528 tail->nd_lit = Qnil;
8532 nd_set_type(tail, NODE_ARRAY);
8533 tail->nd_head = NEW_STR(tail->nd_lit);
8534 list_concat(head, tail);
8539 if (htype == NODE_STR) {
8540 nd_set_type(head, NODE_DSTR);
8543 list_append(head, tail);
8550 evstr2dstr_gen(struct parser_params *parser, NODE *node)
8552 if (nd_type(node) == NODE_EVSTR) {
8553 node = list_append(NEW_DSTR(STR_NEW0()), node);
8559 new_evstr_gen(struct parser_params *parser, NODE *node)
8564 switch (nd_type(node)) {
8565 case NODE_STR: case NODE_DSTR: case NODE_EVSTR:
8569 return NEW_EVSTR(head);
8573 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
8577 return NEW_CALL(recv, id, NEW_LIST(arg1));
8581 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
8584 return NEW_CALL(recv, id, 0);
8588 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
8593 switch (nd_type(node1)) {
8595 case NODE_DREGX_ONCE:
8596 return NEW_MATCH2(node1, node2);
8599 if (RB_TYPE_P(node1->nd_lit, T_REGEXP)) {
8600 return NEW_MATCH2(node1, node2);
8606 switch (nd_type(node2)) {
8608 case NODE_DREGX_ONCE:
8609 return NEW_MATCH3(node2, node1);
8612 if (RB_TYPE_P(node2->nd_lit, T_REGEXP)) {
8613 return NEW_MATCH3(node2, node1);
8618 return NEW_CALL(node1, tMATCH, NEW_LIST(node2));
8622 gettable_gen(struct parser_params *parser, ID id)
8633 case keyword__FILE__:
8634 return NEW_STR(rb_str_dup(ruby_sourcefile_string));
8635 case keyword__LINE__:
8636 return NEW_LIT(INT2FIX(tokline));
8637 case keyword__ENCODING__:
8638 return NEW_LIT(rb_enc_from_encoding(current_enc));
8640 switch (id_type(id)) {
8642 if (dyna_in_block() && dvar_defined(id)) return NEW_DVAR(id);
8643 if (local_id(id)) return NEW_LVAR(id);
8644 /* method call without arguments */
8645 return NEW_VCALL(id);
8647 return NEW_GVAR(id);
8649 return NEW_IVAR(id);
8651 return NEW_CONST(id);
8653 return NEW_CVAR(id);
8655 compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
8660 id_is_var_gen(struct parser_params *parser, ID id)
8662 if (is_notop_id(id)) {
8663 switch (id & ID_SCOPE_MASK) {
8664 case ID_GLOBAL: case ID_INSTANCE: case ID_CONST: case ID_CLASS:
8667 if (dyna_in_block() && dvar_defined(id)) return 1;
8668 if (local_id(id)) return 1;
8669 /* method call without arguments */
8673 compile_error(PARSER_ARG "identifier %s is not valid to get", rb_id2name(id));
8676 #endif /* !RIPPER */
8680 lex_state_name(enum lex_state_e state)
8682 static const char names[][12] = {
8683 "EXPR_BEG", "EXPR_END", "EXPR_ENDARG", "EXPR_ENDFN", "EXPR_ARG",
8684 "EXPR_CMDARG", "EXPR_MID", "EXPR_FNAME", "EXPR_DOT", "EXPR_CLASS",
8688 if ((unsigned)state & ~(~0u << EXPR_MAX_STATE))
8689 return names[ffs(state)];
8696 assignable_gen(struct parser_params *parser, VALUE lhs)
8699 assignable_gen(struct parser_params *parser, ID id, NODE *val)
8703 ID id = get_id(lhs);
8704 # define assignable_result(x) get_value(lhs)
8705 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
8707 # define assignable_result(x) (x)
8709 if (!id) return assignable_result(0);
8712 yyerror("Can't change the value of self");
8715 yyerror("Can't assign to nil");
8718 yyerror("Can't assign to true");
8721 yyerror("Can't assign to false");
8723 case keyword__FILE__:
8724 yyerror("Can't assign to __FILE__");
8726 case keyword__LINE__:
8727 yyerror("Can't assign to __LINE__");
8729 case keyword__ENCODING__:
8730 yyerror("Can't assign to __ENCODING__");
8733 switch (id_type(id)) {
8735 if (dyna_in_block()) {
8736 if (dvar_curr(id)) {
8737 return assignable_result(NEW_DASGN_CURR(id, val));
8739 else if (dvar_defined(id)) {
8740 return assignable_result(NEW_DASGN(id, val));
8742 else if (local_id(id)) {
8743 return assignable_result(NEW_LASGN(id, val));
8747 return assignable_result(NEW_DASGN_CURR(id, val));
8751 if (!local_id(id)) {
8754 return assignable_result(NEW_LASGN(id, val));
8758 return assignable_result(NEW_GASGN(id, val));
8760 return assignable_result(NEW_IASGN(id, val));
8762 if (!in_def && !in_single)
8763 return assignable_result(NEW_CDECL(id, val, 0));
8764 yyerror("dynamic constant assignment");
8767 return assignable_result(NEW_CVASGN(id, val));
8769 compile_error(PARSER_ARG "identifier %s is not valid to set", rb_id2name(id));
8772 return assignable_result(0);
8773 #undef assignable_result
8774 #undef parser_yyerror
8778 is_private_local_id(ID name)
8781 if (name == idUScore) return 1;
8782 if (!is_local_id(name)) return 0;
8783 s = rb_id2str(name);
8785 return RSTRING_PTR(s)[0] == '_';
8788 #define LVAR_USED ((ID)1 << (sizeof(ID) * CHAR_BIT - 1))
8791 shadowing_lvar_0(struct parser_params *parser, ID name)
8793 if (is_private_local_id(name)) return 1;
8794 if (dyna_in_block()) {
8795 if (dvar_curr(name)) {
8796 yyerror("duplicated argument name");
8798 else if (dvar_defined_get(name) || local_id(name)) {
8799 rb_warningS("shadowing outer local variable - %s", rb_id2name(name));
8800 vtable_add(lvtbl->vars, name);
8802 vtable_add(lvtbl->used, (ID)ruby_sourceline | LVAR_USED);
8808 if (local_id(name)) {
8809 yyerror("duplicated argument name");
8816 shadowing_lvar_gen(struct parser_params *parser, ID name)
8818 shadowing_lvar_0(parser, name);
8823 new_bv_gen(struct parser_params *parser, ID name)
8826 if (!is_local_id(name)) {
8827 compile_error(PARSER_ARG "invalid local variable - %s",
8831 if (!shadowing_lvar_0(parser, name)) return;
8837 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
8839 if (recv && nd_type(recv) == NODE_SELF)
8841 return NEW_ATTRASGN(recv, tASET, idx);
8845 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
8847 if (node2 && node1 && nd_type(node1) == NODE_BLOCK_PASS) {
8848 compile_error(PARSER_ARG "both block arg and actual block given");
8852 static const char id_type_names[][9] = {
8864 rb_id_attrset(ID id)
8866 if (!is_notop_id(id)) {
8868 case tAREF: case tASET:
8869 return tASET; /* only exception */
8871 rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
8874 int scope = (int)(id & ID_SCOPE_MASK);
8876 case ID_LOCAL: case ID_INSTANCE: case ID_GLOBAL:
8877 case ID_CONST: case ID_CLASS: case ID_JUNK:
8882 rb_name_error(id, "cannot make %s ID %+"PRIsVALUE" attrset",
8883 id_type_names[scope], ID2SYM(id));
8887 id &= ~ID_SCOPE_MASK;
8893 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
8895 if (recv && nd_type(recv) == NODE_SELF)
8897 return NEW_ATTRASGN(recv, rb_id_attrset(id), 0);
8901 rb_backref_error_gen(struct parser_params *parser, NODE *node)
8903 switch (nd_type(node)) {
8905 compile_error(PARSER_ARG "Can't set variable $%ld", node->nd_nth);
8908 compile_error(PARSER_ARG "Can't set variable $%c", (int)node->nd_nth);
8914 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
8916 if (!node2) return node1;
8917 switch (nd_type(node1)) {
8918 case NODE_BLOCK_PASS:
8920 node1->nd_head = arg_concat(node1->nd_head, node2);
8922 node1->nd_head = NEW_LIST(node2);
8925 if (nd_type(node2) != NODE_ARRAY) break;
8926 node1->nd_body = list_concat(NEW_LIST(node1->nd_body), node2);
8927 nd_set_type(node1, NODE_ARGSCAT);
8930 if (nd_type(node2) != NODE_ARRAY ||
8931 nd_type(node1->nd_body) != NODE_ARRAY) break;
8932 node1->nd_body = list_concat(node1->nd_body, node2);
8935 return NEW_ARGSCAT(node1, node2);
8939 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
8941 if (!node1) return NEW_LIST(node2);
8942 switch (nd_type(node1)) {
8944 return list_append(node1, node2);
8945 case NODE_BLOCK_PASS:
8946 node1->nd_head = arg_append(node1->nd_head, node2);
8949 node1->nd_body = list_append(NEW_LIST(node1->nd_body), node2);
8950 nd_set_type(node1, NODE_ARGSCAT);
8953 return NEW_ARGSPUSH(node1, node2);
8957 splat_array(NODE* node)
8959 if (nd_type(node) == NODE_SPLAT) node = node->nd_head;
8960 if (nd_type(node) == NODE_ARRAY) return node;
8965 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
8969 switch (nd_type(lhs)) {
8975 case NODE_DASGN_CURR:
8979 lhs->nd_value = rhs;
8984 lhs->nd_args = arg_append(lhs->nd_args, rhs);
8988 /* should not happen */
8996 value_expr_gen(struct parser_params *parser, NODE *node)
9001 rb_warning0("empty expression");
9004 switch (nd_type(node)) {
9010 if (!cond) yyerror("void value expression");
9011 /* or "control never reach"? */
9015 while (node->nd_next) {
9016 node = node->nd_next;
9018 node = node->nd_head;
9022 node = node->nd_body;
9026 if (!node->nd_body) {
9027 node = node->nd_else;
9030 else if (!node->nd_else) {
9031 node = node->nd_body;
9034 if (!value_expr(node->nd_body)) return FALSE;
9035 node = node->nd_else;
9041 node = node->nd_2nd;
9053 void_expr_gen(struct parser_params *parser, NODE *node)
9055 const char *useless = 0;
9057 if (!RTEST(ruby_verbose)) return;
9060 switch (nd_type(node)) {
9062 switch (node->nd_mid) {
9081 useless = rb_id2name(node->nd_mid);
9093 useless = "a variable";
9096 useless = "a constant";
9102 case NODE_DREGX_ONCE:
9103 useless = "a literal";
9128 useless = "defined?";
9133 int line = ruby_sourceline;
9135 ruby_sourceline = nd_line(node);
9136 rb_warnS("possibly useless use of %s in void context", useless);
9137 ruby_sourceline = line;
9142 void_stmts_gen(struct parser_params *parser, NODE *node)
9144 if (!RTEST(ruby_verbose)) return;
9146 if (nd_type(node) != NODE_BLOCK) return;
9149 if (!node->nd_next) return;
9150 void_expr0(node->nd_head);
9151 node = node->nd_next;
9156 remove_begin(NODE *node)
9158 NODE **n = &node, *n1 = node;
9159 while (n1 && nd_type(n1) == NODE_BEGIN && n1->nd_body) {
9160 *n = n1 = n1->nd_body;
9166 remove_begin_all(NODE *node)
9168 NODE **n = &node, *n1 = node;
9169 while (n1 && nd_type(n1) == NODE_BEGIN) {
9170 *n = n1 = n1->nd_body;
9176 reduce_nodes_gen(struct parser_params *parser, NODE **body)
9184 #define subnodes(n1, n2) \
9185 ((!node->n1) ? (node->n2 ? (body = &node->n2, 1) : 0) : \
9186 (!node->n2) ? (body = &node->n1, 1) : \
9187 (reduce_nodes(&node->n1), body = &node->n2, 1))
9190 int newline = (int)(node->flags & NODE_FL_NEWLINE);
9191 switch (nd_type(node)) {
9197 *body = node = node->nd_stts;
9198 if (newline && node) node->flags |= NODE_FL_NEWLINE;
9201 *body = node = node->nd_body;
9202 if (newline && node) node->flags |= NODE_FL_NEWLINE;
9205 body = &node->nd_end->nd_head;
9208 if (subnodes(nd_body, nd_else)) break;
9211 body = &node->nd_body;
9214 if (!subnodes(nd_body, nd_next)) goto end;
9217 if (!subnodes(nd_head, nd_resq)) goto end;
9220 if (node->nd_else) {
9221 body = &node->nd_resq;
9224 if (!subnodes(nd_head, nd_resq)) goto end;
9230 if (newline && node) node->flags |= NODE_FL_NEWLINE;
9237 is_static_content(NODE *node)
9239 if (!node) return 1;
9240 switch (nd_type(node)) {
9242 if (!(node = node->nd_head)) break;
9245 if (!is_static_content(node->nd_head)) return 0;
9246 } while ((node = node->nd_next) != 0);
9261 assign_in_cond(struct parser_params *parser, NODE *node)
9263 switch (nd_type(node)) {
9265 yyerror("multiple assignment in conditional");
9270 case NODE_DASGN_CURR:
9279 if (!node->nd_value) return 1;
9280 if (is_static_content(node->nd_value)) {
9281 /* reports always */
9282 parser_warn(node->nd_value, "found = in conditional, should be ==");
9288 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
9290 if (!e_option_supplied(parser)) parser_warn(node, str);
9294 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
9296 if (!e_option_supplied(parser)) parser_warning(node, str);
9300 fixup_nodes(NODE **rootnode)
9302 NODE *node, *next, *head;
9304 for (node = *rootnode; node; node = next) {
9305 enum node_type type;
9308 next = node->nd_next;
9309 head = node->nd_head;
9310 rb_gc_force_recycle((VALUE)node);
9312 switch (type = nd_type(head)) {
9315 val = rb_range_new(head->nd_beg->nd_lit, head->nd_end->nd_lit,
9317 rb_gc_force_recycle((VALUE)head->nd_beg);
9318 rb_gc_force_recycle((VALUE)head->nd_end);
9319 nd_set_type(head, NODE_LIT);
9328 static NODE *cond0(struct parser_params*,NODE*);
9331 range_op(struct parser_params *parser, NODE *node)
9333 enum node_type type;
9335 if (node == 0) return 0;
9337 type = nd_type(node);
9339 if (type == NODE_LIT && FIXNUM_P(node->nd_lit)) {
9340 warn_unless_e_option(parser, node, "integer literal in conditional range");
9341 return NEW_CALL(node, tEQ, NEW_LIST(NEW_GVAR(rb_intern("$."))));
9343 return cond0(parser, node);
9347 literal_node(NODE *node)
9349 if (!node) return 1; /* same as NODE_NIL */
9350 switch (nd_type(node)) {
9356 case NODE_DREGX_ONCE:
9368 cond0(struct parser_params *parser, NODE *node)
9370 if (node == 0) return 0;
9371 assign_in_cond(parser, node);
9373 switch (nd_type(node)) {
9377 rb_warn0("string literal in condition");
9381 case NODE_DREGX_ONCE:
9382 warning_unless_e_option(parser, node, "regex literal in condition");
9383 return NEW_MATCH2(node, NEW_GVAR(rb_intern("$_")));
9387 node->nd_1st = cond0(parser, node->nd_1st);
9388 node->nd_2nd = cond0(parser, node->nd_2nd);
9393 node->nd_beg = range_op(parser, node->nd_beg);
9394 node->nd_end = range_op(parser, node->nd_end);
9395 if (nd_type(node) == NODE_DOT2) nd_set_type(node,NODE_FLIP2);
9396 else if (nd_type(node) == NODE_DOT3) nd_set_type(node, NODE_FLIP3);
9397 if (!e_option_supplied(parser)) {
9398 int b = literal_node(node->nd_beg);
9399 int e = literal_node(node->nd_end);
9400 if ((b == 1 && e == 1) || (b + e >= 2 && RTEST(ruby_verbose))) {
9401 parser_warn(node, "range literal in condition");
9407 parser_warning(node, "literal in condition");
9411 if (RB_TYPE_P(node->nd_lit, T_REGEXP)) {
9412 warn_unless_e_option(parser, node, "regex literal in condition");
9413 nd_set_type(node, NODE_MATCH);
9416 parser_warning(node, "literal in condition");
9425 cond_gen(struct parser_params *parser, NODE *node)
9427 if (node == 0) return 0;
9428 return cond0(parser, node);
9432 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
9435 if (left && (enum node_type)nd_type(left) == type) {
9436 NODE *node = left, *second;
9437 while ((second = node->nd_2nd) != 0 && (enum node_type)nd_type(second) == type) {
9440 node->nd_2nd = NEW_NODE(type, second, right, 0);
9443 return NEW_NODE(type, left, right, 0);
9447 no_blockarg(struct parser_params *parser, NODE *node)
9449 if (node && nd_type(node) == NODE_BLOCK_PASS) {
9450 compile_error(PARSER_ARG "block argument should not be given");
9455 ret_args_gen(struct parser_params *parser, NODE *node)
9458 no_blockarg(parser, node);
9459 if (nd_type(node) == NODE_ARRAY) {
9460 if (node->nd_next == 0) {
9461 node = node->nd_head;
9464 nd_set_type(node, NODE_VALUES);
9472 new_yield_gen(struct parser_params *parser, NODE *node)
9474 if (node) no_blockarg(parser, node);
9476 return NEW_YIELD(node);
9480 negate_lit(NODE *node)
9482 switch (TYPE(node->nd_lit)) {
9484 node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
9489 node->nd_lit = rb_funcall(node->nd_lit,tUMINUS,0,0);
9493 if (FLONUM_P(node->nd_lit)) {
9494 node->nd_lit = DBL2NUM(-RFLOAT_VALUE(node->nd_lit));
9497 RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
9500 RFLOAT(node->nd_lit)->float_value = -RFLOAT_VALUE(node->nd_lit);
9504 rb_bug("unknown literal type passed to negate_lit");
9511 arg_blk_pass(NODE *node1, NODE *node2)
9514 node2->nd_head = node1;
9522 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
9524 int saved_line = ruby_sourceline;
9525 struct rb_args_info *args = tail->nd_ainfo;
9527 args->pre_args_num = m ? rb_long2int(m->nd_plen) : 0;
9528 args->pre_init = m ? m->nd_next : 0;
9530 args->post_args_num = p ? rb_long2int(p->nd_plen) : 0;
9531 args->post_init = p ? p->nd_next : 0;
9532 args->first_post_arg = p ? p->nd_pid : 0;
9538 ruby_sourceline = saved_line;
9544 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
9546 int saved_line = ruby_sourceline;
9547 struct rb_args_info *args;
9548 NODE *kw_rest_arg = 0;
9552 args = ALLOC(struct rb_args_info);
9553 MEMZERO(args, struct rb_args_info, 1);
9554 node = NEW_NODE(NODE_ARGS, 0, 0, args);
9556 args->block_arg = b;
9564 kw_rest_arg = NEW_DVAR(kr);
9565 kw_rest_arg->nd_cflag = check;
9567 args->kw_rest_arg = kw_rest_arg;
9569 ruby_sourceline = saved_line;
9574 dsym_node_gen(struct parser_params *parser, NODE *node)
9579 return NEW_LIT(ID2SYM(idNULL));
9582 switch (nd_type(node)) {
9584 nd_set_type(node, NODE_DSYM);
9588 node->nd_lit = ID2SYM(rb_intern_str(lit));
9589 nd_set_type(node, NODE_LIT);
9592 node = NEW_NODE(NODE_DSYM, Qnil, 1, NEW_LIST(node));
9597 #endif /* !RIPPER */
9601 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
9606 ID vid = lhs->nd_vid;
9608 lhs->nd_value = rhs;
9609 asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
9610 if (is_asgn_or_id(vid)) {
9614 else if (op == tANDOP) {
9615 lhs->nd_value = rhs;
9616 asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
9620 asgn->nd_value = NEW_CALL(gettable(vid), op, NEW_LIST(rhs));
9624 asgn = NEW_BEGIN(0);
9630 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
9637 else if (op == tANDOP) {
9640 asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
9646 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
9653 else if (op == tANDOP) {
9657 asgn = NEW_OP_CDECL(lhs, op, rhs);
9660 asgn = NEW_BEGIN(0);
9667 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
9669 return dispatch3(opassign, lhs, op, rhs);
9673 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
9675 VALUE recv = dispatch3(field, lhs, type, attr);
9676 return dispatch3(opassign, recv, op, rhs);
9681 warn_unused_var(struct parser_params *parser, struct local_vars *local)
9686 if (!local->used) return;
9687 v = local->vars->tbl;
9688 u = local->used->tbl;
9689 cnt = local->used->pos;
9690 if (cnt != local->vars->pos) {
9691 rb_bug("local->used->pos != local->vars->pos");
9693 for (i = 0; i < cnt; ++i) {
9694 if (!v[i] || (u[i] & LVAR_USED)) continue;
9695 if (is_private_local_id(v[i])) continue;
9696 rb_warn4S(ruby_sourcefile, (int)u[i], "assigned but unused variable - %s", rb_id2name(v[i]));
9701 local_push_gen(struct parser_params *parser, int inherit_dvars)
9703 struct local_vars *local;
9705 local = ALLOC(struct local_vars);
9706 local->prev = lvtbl;
9707 local->args = vtable_alloc(0);
9708 local->vars = vtable_alloc(inherit_dvars ? DVARS_INHERIT : DVARS_TOPSCOPE);
9709 local->used = !(inherit_dvars &&
9710 (ifndef_ripper(compile_for_eval || e_option_supplied(parser))+0)) &&
9711 RTEST(ruby_verbose) ? vtable_alloc(0) : 0;
9712 local->cmdargs = cmdarg_stack;
9718 local_pop_gen(struct parser_params *parser)
9720 struct local_vars *local = lvtbl->prev;
9722 warn_unused_var(parser, lvtbl);
9723 vtable_free(lvtbl->used);
9725 vtable_free(lvtbl->args);
9726 vtable_free(lvtbl->vars);
9727 cmdarg_stack = lvtbl->cmdargs;
9734 local_tbl_gen(struct parser_params *parser)
9736 int cnt_args = vtable_size(lvtbl->args);
9737 int cnt_vars = vtable_size(lvtbl->vars);
9738 int cnt = cnt_args + cnt_vars;
9742 if (cnt <= 0) return 0;
9743 buf = ALLOC_N(ID, cnt + 1);
9744 MEMCPY(buf+1, lvtbl->args->tbl, ID, cnt_args);
9745 /* remove IDs duplicated to warn shadowing */
9746 for (i = 0, j = cnt_args+1; i < cnt_vars; ++i) {
9747 ID id = lvtbl->vars->tbl[i];
9748 if (!vtable_included(lvtbl->args, id)) {
9752 if (--j < cnt) REALLOC_N(buf, ID, (cnt = j) + 1);
9759 arg_var_gen(struct parser_params *parser, ID id)
9761 vtable_add(lvtbl->args, id);
9762 return vtable_size(lvtbl->args) - 1;
9766 local_var_gen(struct parser_params *parser, ID id)
9768 vtable_add(lvtbl->vars, id);
9770 vtable_add(lvtbl->used, (ID)ruby_sourceline);
9772 return vtable_size(lvtbl->vars) - 1;
9776 local_id_gen(struct parser_params *parser, ID id)
9778 struct vtable *vars, *args, *used;
9784 while (vars && POINTER_P(vars->prev)) {
9787 if (used) used = used->prev;
9790 if (vars && vars->prev == DVARS_INHERIT) {
9791 return rb_local_defined(id);
9793 else if (vtable_included(args, id)) {
9797 int i = vtable_included(vars, id);
9798 if (i && used) used->tbl[i-1] |= LVAR_USED;
9803 static const struct vtable *
9804 dyna_push_gen(struct parser_params *parser)
9806 lvtbl->args = vtable_alloc(lvtbl->args);
9807 lvtbl->vars = vtable_alloc(lvtbl->vars);
9809 lvtbl->used = vtable_alloc(lvtbl->used);
9815 dyna_pop_1(struct parser_params *parser)
9819 if ((tmp = lvtbl->used) != 0) {
9820 warn_unused_var(parser, lvtbl);
9821 lvtbl->used = lvtbl->used->prev;
9825 lvtbl->args = lvtbl->args->prev;
9828 lvtbl->vars = lvtbl->vars->prev;
9833 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
9835 while (lvtbl->args != lvargs) {
9838 struct local_vars *local = lvtbl->prev;
9847 dyna_in_block_gen(struct parser_params *parser)
9849 return POINTER_P(lvtbl->vars) && lvtbl->vars->prev != DVARS_TOPSCOPE;
9853 dvar_defined_gen(struct parser_params *parser, ID id, int get)
9855 struct vtable *vars, *args, *used;
9862 while (POINTER_P(vars)) {
9863 if (vtable_included(args, id)) {
9866 if ((i = vtable_included(vars, id)) != 0) {
9867 if (used) used->tbl[i-1] |= LVAR_USED;
9873 if (used) used = used->prev;
9876 if (vars == DVARS_INHERIT) {
9877 return rb_dvar_defined(id);
9884 dvar_curr_gen(struct parser_params *parser, ID id)
9886 return (vtable_included(lvtbl->args, id) ||
9887 vtable_included(lvtbl->vars, id));
9892 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
9894 int c = RE_OPTION_ENCODING_IDX(options);
9898 rb_char_to_option_kcode(c, &opt, &idx);
9899 if (idx != ENCODING_GET(str) &&
9900 rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
9903 ENCODING_SET(str, idx);
9905 else if (RE_OPTION_ENCODING_NONE(options)) {
9906 if (!ENCODING_IS_ASCII8BIT(str) &&
9907 rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
9911 rb_enc_associate(str, rb_ascii8bit_encoding());
9913 else if (current_enc == rb_usascii_encoding()) {
9914 if (rb_enc_str_coderange(str) != ENC_CODERANGE_7BIT) {
9916 rb_enc_associate(str, rb_usascii_encoding());
9919 rb_enc_associate(str, rb_ascii8bit_encoding());
9925 compile_error(PARSER_ARG
9926 "regexp encoding option '%c' differs from source encoding '%s'",
9927 c, rb_enc_name(rb_enc_get(str)));
9931 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
9934 reg_fragment_setenc(str, options);
9935 err = rb_reg_check_preprocess(str);
9937 err = rb_obj_as_string(err);
9938 compile_error(PARSER_ARG "%"PRIsVALUE, err);
9945 struct parser_params* parser;
9950 } reg_named_capture_assign_t;
9953 reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
9954 int back_num, int *back_refs, OnigRegex regex, void *arg0)
9956 reg_named_capture_assign_t *arg = (reg_named_capture_assign_t*)arg0;
9957 struct parser_params* parser = arg->parser;
9958 rb_encoding *enc = arg->enc;
9959 long len = name_end - name;
9960 const char *s = (const char *)name;
9965 if (arg->succ_block == 0) {
9966 arg->succ_block = NEW_BEGIN(0);
9967 arg->fail_block = NEW_BEGIN(0);
9970 if (!len || (*name != '_' && ISASCII(*name) && !rb_enc_islower(*name, enc)) ||
9971 (len < MAX_WORD_LENGTH && rb_reserved_word(s, (int)len)) ||
9972 !rb_enc_symname2_p(s, len, enc)) {
9975 var = rb_intern3(s, len, enc);
9976 if (dvar_defined(var) || local_id(var)) {
9977 rb_warningS("named capture conflicts a local variable - %s",
9980 arg->succ_block = block_append(arg->succ_block,
9981 newline_node(node_assign(assignable(var,0),
9983 gettable(rb_intern("$~")),
9985 NEW_LIST(NEW_LIT(ID2SYM(var))))
9987 arg->fail_block = block_append(arg->fail_block,
9988 newline_node(node_assign(assignable(var,0), NEW_LIT(Qnil))));
9993 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match)
9995 reg_named_capture_assign_t arg;
9997 arg.parser = parser;
9998 arg.enc = rb_enc_get(regexp);
10000 arg.fail_block = 0;
10002 onig_foreach_name(RREGEXP(regexp)->ptr, reg_named_capture_assign_iter, (void*)&arg);
10009 newline_node(match),
10010 NEW_IF(gettable(rb_intern("$~")),
10012 newline_node(arg.succ_block),
10015 gettable(rb_intern("$~")),
10016 rb_intern("begin"),
10017 NEW_LIST(NEW_LIT(INT2FIX(0)))))),
10019 newline_node(arg.fail_block),
10025 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
10030 reg_fragment_setenc(str, options);
10031 err = rb_errinfo();
10032 re = rb_reg_compile(str, options & RE_OPTION_MASK, ruby_sourcefile, ruby_sourceline);
10034 ID mesg = rb_intern("mesg");
10035 VALUE m = rb_attr_get(rb_errinfo(), mesg);
10036 rb_set_errinfo(err);
10038 rb_str_append(rb_str_cat(rb_attr_get(err, mesg), "\n", 1), m);
10041 compile_error(PARSER_ARG "%"PRIsVALUE, m);
10049 rb_gc_mark_parser(void)
10054 rb_parser_append_print(VALUE vparser, NODE *node)
10057 NODE *scope = node;
10058 struct parser_params *parser;
10060 if (!node) return node;
10062 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
10064 node = node->nd_body;
10066 if (nd_type(node) == NODE_PRELUDE) {
10068 node = node->nd_body;
10071 node = block_append(node,
10072 NEW_FCALL(rb_intern("print"),
10073 NEW_ARRAY(NEW_GVAR(rb_intern("$_")))));
10075 prelude->nd_body = node;
10076 scope->nd_body = prelude;
10079 scope->nd_body = node;
10086 rb_parser_while_loop(VALUE vparser, NODE *node, int chop, int split)
10089 NODE *scope = node;
10090 struct parser_params *parser;
10092 if (!node) return node;
10094 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
10096 node = node->nd_body;
10098 if (nd_type(node) == NODE_PRELUDE) {
10100 node = node->nd_body;
10103 node = block_append(NEW_GASGN(rb_intern("$F"),
10104 NEW_CALL(NEW_GVAR(rb_intern("$_")),
10105 rb_intern("split"), 0)),
10109 node = block_append(NEW_CALL(NEW_GVAR(rb_intern("$_")),
10110 rb_intern("chop!"), 0), node);
10113 node = NEW_OPT_N(node);
10116 prelude->nd_body = node;
10117 scope->nd_body = prelude;
10120 scope->nd_body = node;
10126 static const struct {
10151 #define op_tbl_count numberof(op_tbl)
10153 #ifndef ENABLE_SELECTOR_NAMESPACE
10154 #define ENABLE_SELECTOR_NAMESPACE 0
10157 static struct symbols {
10161 #if ENABLE_SELECTOR_NAMESPACE
10162 st_table *ivar2_id;
10163 st_table *id_ivar2;
10165 VALUE op_sym[tLAST_OP_ID];
10167 } global_symbols = {tLAST_TOKEN};
10169 static const struct st_hash_type symhash = {
10174 #if ENABLE_SELECTOR_NAMESPACE
10181 ivar2_cmp(struct ivar2_key *key1, struct ivar2_key *key2)
10183 if (key1->id == key2->id && key1->klass == key2->klass) {
10190 ivar2_hash(struct ivar2_key *key)
10192 return (key->id << 8) ^ (key->klass >> 2);
10195 static const struct st_hash_type ivar2_hash_type = {
10204 global_symbols.sym_id = st_init_table_with_size(&symhash, 1000);
10205 global_symbols.id_str = st_init_numtable_with_size(1000);
10206 #if ENABLE_SELECTOR_NAMESPACE
10207 global_symbols.ivar2_id = st_init_table_with_size(&ivar2_hash_type, 1000);
10208 global_symbols.id_ivar2 = st_init_numtable_with_size(1000);
10214 (void)lex_state_name(-1);
10221 rb_gc_mark_symbols(int full_mark)
10223 if (full_mark || global_symbols.minor_marked == 0) {
10224 rb_mark_tbl(global_symbols.id_str);
10225 rb_gc_mark_locations(global_symbols.op_sym,
10226 global_symbols.op_sym + numberof(global_symbols.op_sym));
10228 if (!full_mark) global_symbols.minor_marked = 1;
10231 #endif /* !RIPPER */
10234 internal_id_gen(struct parser_params *parser)
10236 ID id = (ID)vtable_size(lvtbl->args) + (ID)vtable_size(lvtbl->vars);
10237 id += ((tLAST_TOKEN - ID_INTERNAL) >> ID_SCOPE_SHIFT) + 1;
10238 return ID_INTERNAL | (id << ID_SCOPE_SHIFT);
10243 is_special_global_name(const char *m, const char *e, rb_encoding *enc)
10247 if (m >= e) return 0;
10248 if (is_global_name_punct(*m)) {
10251 else if (*m == '-') {
10252 if (++m >= e) return 0;
10253 if (is_identchar(m, e, enc)) {
10254 if (!ISASCII(*m)) mb = 1;
10255 m += rb_enc_mbclen(m, e, enc);
10259 if (!rb_enc_isdigit(*m, enc)) return 0;
10261 if (!ISASCII(*m)) mb = 1;
10263 } while (m < e && rb_enc_isdigit(*m, enc));
10265 return m == e ? mb + 1 : 0;
10269 rb_symname_p(const char *name)
10271 return rb_enc_symname_p(name, rb_ascii8bit_encoding());
10275 rb_enc_symname_p(const char *name, rb_encoding *enc)
10277 return rb_enc_symname2_p(name, strlen(name), enc);
10280 #define IDSET_ATTRSET_FOR_SYNTAX ((1U<<ID_LOCAL)|(1U<<ID_CONST))
10281 #define IDSET_ATTRSET_FOR_INTERN (~(~0U<<ID_SCOPE_MASK) & ~(1U<<ID_ATTRSET))
10284 rb_enc_symname_type(const char *name, long len, rb_encoding *enc, unsigned int allowed_attrset)
10286 const char *m = name;
10287 const char *e = m + len;
10288 int type = ID_JUNK;
10290 if (!m || len <= 0) return -1;
10297 if (is_special_global_name(++m, e, enc)) return type;
10301 type = ID_INSTANCE;
10310 case '<': ++m; break;
10311 case '=': if (*++m == '>') ++m; break;
10318 case '>': case '=': ++m; break;
10324 case '~': ++m; break;
10325 case '=': if (*++m == '=') ++m; break;
10326 default: return -1;
10331 if (*++m == '*') ++m;
10334 case '+': case '-':
10335 if (*++m == '@') ++m;
10338 case '|': case '^': case '&': case '/': case '%': case '~': case '`':
10343 if (*++m != ']') return -1;
10344 if (*++m == '=') ++m;
10348 if (len == 1) return ID_JUNK;
10350 case '=': case '~': ++m; break;
10351 default: return -1;
10356 type = rb_enc_isupper(*m, enc) ? ID_CONST : ID_LOCAL;
10358 if (m >= e || (*m != '_' && !rb_enc_isalpha(*m, enc) && ISASCII(*m)))
10360 while (m < e && is_identchar(m, e, enc)) m += rb_enc_mbclen(m, e, enc);
10363 case '!': case '?':
10364 if (type == ID_GLOBAL || type == ID_CLASS || type == ID_INSTANCE) return -1;
10369 if (!(allowed_attrset & (1U << type))) return -1;
10376 return m == e ? type : -1;
10380 rb_enc_symname2_p(const char *name, long len, rb_encoding *enc)
10382 return rb_enc_symname_type(name, len, enc, IDSET_ATTRSET_FOR_SYNTAX) != -1;
10386 rb_str_symname_type(VALUE name, unsigned int allowed_attrset)
10388 const char *ptr = StringValuePtr(name);
10389 long len = RSTRING_LEN(name);
10390 int type = rb_enc_symname_type(ptr, len, rb_enc_get(name), allowed_attrset);
10396 register_symid(ID id, const char *name, long len, rb_encoding *enc)
10398 VALUE str = rb_enc_str_new(name, len, enc);
10399 return register_symid_str(id, str);
10403 register_symid_str(ID id, VALUE str)
10406 str = rb_fstring(str);
10408 if (RUBY_DTRACE_SYMBOL_CREATE_ENABLED()) {
10409 RUBY_DTRACE_SYMBOL_CREATE(RSTRING_PTR(str), rb_sourcefile(), rb_sourceline());
10412 st_add_direct(global_symbols.sym_id, (st_data_t)str, id);
10413 st_add_direct(global_symbols.id_str, id, (st_data_t)str);
10414 global_symbols.minor_marked = 0;
10419 sym_check_asciionly(VALUE str)
10421 if (!rb_enc_asciicompat(rb_enc_get(str))) return FALSE;
10422 switch (rb_enc_str_coderange(str)) {
10423 case ENC_CODERANGE_BROKEN:
10424 rb_raise(rb_eEncodingError, "invalid encoding symbol");
10425 case ENC_CODERANGE_7BIT:
10432 * _str_ itself will be registered at the global symbol table. _str_
10433 * can be modified before the registration, since the encoding will be
10434 * set to ASCII-8BIT if it is a special global name.
10436 static ID intern_str(VALUE str);
10439 setup_fake_str(struct RString *fake_str, const char *name, long len)
10441 fake_str->basic.flags = T_STRING|RSTRING_NOEMBED;
10442 RBASIC_SET_CLASS_RAW((VALUE)fake_str, rb_cString);
10443 fake_str->as.heap.len = len;
10444 fake_str->as.heap.ptr = (char *)name;
10445 fake_str->as.heap.aux.capa = len;
10446 return (VALUE)fake_str;
10450 rb_intern3(const char *name, long len, rb_encoding *enc)
10453 struct RString fake_str;
10454 VALUE str = setup_fake_str(&fake_str, name, len);
10455 rb_enc_associate(str, enc);
10458 if (st_lookup(global_symbols.sym_id, str, &data))
10461 str = rb_enc_str_new(name, len, enc); /* make true string */
10462 return intern_str(str);
10466 intern_str(VALUE str)
10468 const char *name, *m, *e;
10470 rb_encoding *enc, *symenc;
10475 RSTRING_GETMEM(str, name, len);
10478 enc = rb_enc_get(str);
10481 if (!len || (rb_cString && !rb_enc_asciicompat(enc))) {
10490 if (len < 2) goto junk;
10492 if ((mb = is_special_global_name(++m, e, enc)) != 0) {
10493 if (!--mb) symenc = rb_usascii_encoding();
10499 if (len < 3) goto junk;
10504 if (len < 2) goto junk;
10511 if (c != '_' && rb_enc_isascii(c, enc) && rb_enc_ispunct(c, enc)) {
10519 for (i = 0; i < op_tbl_count; i++) {
10520 if (*op_tbl[i].name == *m &&
10521 strcmp(op_tbl[i].name, m) == 0) {
10522 id = op_tbl[i].token;
10529 if (name[last] == '=') {
10530 /* attribute assignment */
10531 if (last > 1 && name[last-1] == '=')
10533 id = rb_intern3(name, last, enc);
10534 if (id > tLAST_OP_ID && !is_attrset_id(id)) {
10535 enc = rb_enc_get(rb_id2str(id));
10536 id = rb_id_attrset(id);
10541 else if (id == 0) {
10542 if (rb_enc_isupper(m[0], enc)) {
10549 if (!rb_enc_isdigit(*m, enc)) {
10550 while (m <= name + last && is_identchar(m, e, enc)) {
10555 m += rb_enc_mbclen(m, e, enc);
10559 if (id != ID_ATTRSET && m - name < len) id = ID_JUNK;
10560 if (sym_check_asciionly(str)) symenc = rb_usascii_encoding();
10562 if (symenc != enc) rb_enc_associate(str, symenc);
10563 if (global_symbols.last_id >= ~(ID)0 >> (ID_SCOPE_SHIFT+RUBY_SPECIAL_SHIFT)) {
10565 rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.20s...)",
10569 rb_raise(rb_eRuntimeError, "symbol table overflow (symbol %.*s)",
10573 id |= ++global_symbols.last_id << ID_SCOPE_SHIFT;
10575 return register_symid_str(id, str);
10579 rb_intern2(const char *name, long len)
10581 return rb_intern3(name, len, rb_usascii_encoding());
10586 rb_intern(const char *name)
10588 return rb_intern2(name, strlen(name));
10592 rb_intern_str(VALUE str)
10596 if (st_lookup(global_symbols.sym_id, str, &id))
10598 return intern_str(rb_str_dup(str));
10606 if (id < tLAST_TOKEN) {
10609 if (id < INT_MAX && rb_ispunct((int)id)) {
10610 VALUE str = global_symbols.op_sym[i = (int)id];
10613 name[0] = (char)id;
10615 str = rb_usascii_str_new(name, 1);
10617 str = rb_fstring(str);
10618 global_symbols.op_sym[i] = str;
10619 global_symbols.minor_marked = 0;
10623 for (i = 0; i < op_tbl_count; i++) {
10624 if (op_tbl[i].token == id) {
10625 VALUE str = global_symbols.op_sym[i];
10627 str = rb_usascii_str_new2(op_tbl[i].name);
10629 str = rb_fstring(str);
10630 global_symbols.op_sym[i] = str;
10631 global_symbols.minor_marked = 0;
10638 if (st_lookup(global_symbols.id_str, id, &data)) {
10639 VALUE str = (VALUE)data;
10640 if (RBASIC(str)->klass == 0)
10641 RBASIC_SET_CLASS_RAW(str, rb_cString);
10645 if (is_attrset_id(id)) {
10646 ID id_stem = (id & ~ID_SCOPE_MASK);
10650 if (!!(str = rb_id2str(id_stem | ID_LOCAL))) break;
10651 if (!!(str = rb_id2str(id_stem | ID_CONST))) break;
10652 if (!!(str = rb_id2str(id_stem | ID_INSTANCE))) break;
10653 if (!!(str = rb_id2str(id_stem | ID_GLOBAL))) break;
10654 if (!!(str = rb_id2str(id_stem | ID_CLASS))) break;
10655 if (!!(str = rb_id2str(id_stem | ID_JUNK))) break;
10658 str = rb_str_dup(str);
10659 rb_str_cat(str, "=", 1);
10660 register_symid_str(id, str);
10661 if (st_lookup(global_symbols.id_str, id, &data)) {
10662 VALUE str = (VALUE)data;
10663 if (RBASIC(str)->klass == 0)
10664 RBASIC_SET_CLASS_RAW(str, rb_cString);
10674 VALUE str = rb_id2str(id);
10676 if (!str) return 0;
10677 return RSTRING_PTR(str);
10681 symbols_i(VALUE sym, ID value, VALUE ary)
10683 rb_ary_push(ary, ID2SYM(value));
10684 return ST_CONTINUE;
10689 * Symbol.all_symbols => array
10691 * Returns an array of all the symbols currently in Ruby's symbol
10694 * Symbol.all_symbols.size #=> 903
10695 * Symbol.all_symbols[1,20] #=> [:floor, :ARGV, :Binding, :symlink,
10696 * :chown, :EOFError, :$;, :String,
10697 * :LOCK_SH, :"setuid?", :$<,
10698 * :default_proc, :compact, :extend,
10699 * :Tms, :getwd, :$=, :ThreadGroup,
10704 rb_sym_all_symbols(void)
10706 VALUE ary = rb_ary_new2(global_symbols.sym_id->num_entries);
10708 st_foreach(global_symbols.sym_id, symbols_i, ary);
10713 rb_is_const_id(ID id)
10715 return is_const_id(id);
10719 rb_is_class_id(ID id)
10721 return is_class_id(id);
10725 rb_is_global_id(ID id)
10727 return is_global_id(id);
10731 rb_is_instance_id(ID id)
10733 return is_instance_id(id);
10737 rb_is_attrset_id(ID id)
10739 return is_attrset_id(id);
10743 rb_is_local_id(ID id)
10745 return is_local_id(id);
10749 rb_is_junk_id(ID id)
10751 return is_junk_id(id);
10755 * Returns ID for the given name if it is interned already, or 0.
10757 * \param namep the pointer to the name object
10758 * \return the ID for *namep
10759 * \pre the object referred by \p namep must be a Symbol or
10760 * a String, or possible to convert with to_str method.
10761 * \post the object referred by \p namep is a Symbol or a
10762 * String if non-zero value is returned, or is a String
10763 * if 0 is returned.
10766 rb_check_id(volatile VALUE *namep)
10770 VALUE name = *namep;
10772 if (SYMBOL_P(name)) {
10773 return SYM2ID(name);
10775 else if (!RB_TYPE_P(name, T_STRING)) {
10776 tmp = rb_check_string_type(name);
10778 tmp = rb_inspect(name);
10779 rb_raise(rb_eTypeError, "%s is not a symbol",
10786 sym_check_asciionly(name);
10788 if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
10791 if (rb_is_attrset_name(name)) {
10792 struct RString fake_str;
10793 /* make local name by chopping '=' */
10794 const VALUE localname = setup_fake_str(&fake_str, RSTRING_PTR(name), RSTRING_LEN(name) - 1);
10795 rb_enc_copy(localname, name);
10796 OBJ_FREEZE(localname);
10798 if (st_lookup(global_symbols.sym_id, (st_data_t)localname, &id)) {
10799 return rb_id_attrset((ID)id);
10808 rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
10811 struct RString fake_str;
10812 const VALUE name = setup_fake_str(&fake_str, ptr, len);
10813 rb_enc_associate(name, enc);
10815 sym_check_asciionly(name);
10817 if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id))
10820 if (rb_is_attrset_name(name)) {
10821 fake_str.as.heap.len = len - 1;
10822 if (st_lookup(global_symbols.sym_id, (st_data_t)name, &id)) {
10823 return rb_id_attrset((ID)id);
10831 rb_is_const_name(VALUE name)
10833 return rb_str_symname_type(name, 0) == ID_CONST;
10837 rb_is_class_name(VALUE name)
10839 return rb_str_symname_type(name, 0) == ID_CLASS;
10843 rb_is_global_name(VALUE name)
10845 return rb_str_symname_type(name, 0) == ID_GLOBAL;
10849 rb_is_instance_name(VALUE name)
10851 return rb_str_symname_type(name, 0) == ID_INSTANCE;
10855 rb_is_attrset_name(VALUE name)
10857 return rb_str_symname_type(name, IDSET_ATTRSET_FOR_INTERN) == ID_ATTRSET;
10861 rb_is_local_name(VALUE name)
10863 return rb_str_symname_type(name, 0) == ID_LOCAL;
10867 rb_is_method_name(VALUE name)
10869 switch (rb_str_symname_type(name, 0)) {
10870 case ID_LOCAL: case ID_ATTRSET: case ID_JUNK:
10877 rb_is_junk_name(VALUE name)
10879 return rb_str_symname_type(name, IDSET_ATTRSET_FOR_SYNTAX) == -1;
10882 #endif /* !RIPPER */
10885 parser_initialize(struct parser_params *parser)
10887 parser->eofp = Qfalse;
10889 parser->parser_lex_strterm = 0;
10890 parser->parser_cond_stack = 0;
10891 parser->parser_cmdarg_stack = 0;
10892 parser->parser_class_nest = 0;
10893 parser->parser_paren_nest = 0;
10894 parser->parser_lpar_beg = 0;
10895 parser->parser_brace_nest = 0;
10896 parser->parser_in_single = 0;
10897 parser->parser_in_def = 0;
10898 parser->parser_in_defined = 0;
10899 parser->parser_in_kwarg = 0;
10900 parser->parser_compile_for_eval = 0;
10901 parser->parser_cur_mid = 0;
10902 parser->parser_tokenbuf = NULL;
10903 parser->parser_tokidx = 0;
10904 parser->parser_toksiz = 0;
10905 parser->parser_heredoc_end = 0;
10906 parser->parser_command_start = TRUE;
10907 parser->parser_deferred_nodes = 0;
10908 parser->parser_lex_pbeg = 0;
10909 parser->parser_lex_p = 0;
10910 parser->parser_lex_pend = 0;
10911 parser->parser_lvtbl = 0;
10912 parser->parser_ruby__end__seen = 0;
10913 parser->parser_ruby_sourcefile = 0;
10914 parser->parser_ruby_sourcefile_string = Qnil;
10916 parser->is_ripper = 0;
10917 parser->parser_eval_tree_begin = 0;
10918 parser->parser_eval_tree = 0;
10920 parser->is_ripper = 1;
10921 parser->delayed = Qnil;
10923 parser->result = Qnil;
10924 parser->parsing_thread = Qnil;
10925 parser->toplevel_p = TRUE;
10928 parser->heap = NULL;
10930 parser->enc = rb_utf8_encoding();
10934 #define parser_mark ripper_parser_mark
10935 #define parser_free ripper_parser_free
10939 parser_mark(void *ptr)
10941 struct parser_params *p = (struct parser_params*)ptr;
10943 rb_gc_mark((VALUE)p->parser_lex_strterm);
10944 rb_gc_mark((VALUE)p->parser_deferred_nodes);
10945 rb_gc_mark(p->parser_lex_input);
10946 rb_gc_mark(p->parser_lex_lastline);
10947 rb_gc_mark(p->parser_lex_nextline);
10948 rb_gc_mark(p->parser_ruby_sourcefile_string);
10950 rb_gc_mark((VALUE)p->parser_eval_tree_begin) ;
10951 rb_gc_mark((VALUE)p->parser_eval_tree) ;
10952 rb_gc_mark(p->debug_lines);
10954 rb_gc_mark(p->delayed);
10955 rb_gc_mark(p->value);
10956 rb_gc_mark(p->result);
10957 rb_gc_mark(p->parsing_thread);
10960 rb_gc_mark((VALUE)p->heap);
10965 parser_free(void *ptr)
10967 struct parser_params *p = (struct parser_params*)ptr;
10968 struct local_vars *local, *prev;
10970 if (p->parser_tokenbuf) {
10971 xfree(p->parser_tokenbuf);
10973 for (local = p->parser_lvtbl; local; local = prev) {
10974 if (local->vars) xfree(local->vars);
10975 prev = local->prev;
10982 parser_memsize(const void *ptr)
10984 struct parser_params *p = (struct parser_params*)ptr;
10985 struct local_vars *local;
10986 size_t size = sizeof(*p);
10988 if (!ptr) return 0;
10989 size += p->parser_toksiz;
10990 for (local = p->parser_lvtbl; local; local = local->prev) {
10991 size += sizeof(*local);
10992 if (local->vars) size += local->vars->capa * sizeof(ID);
11001 rb_data_type_t parser_data_type = {
11008 NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
11012 #undef rb_reserved_word
11014 const struct kwtable *
11015 rb_reserved_word(const char *str, unsigned int len)
11017 return reserved_word(str, len);
11020 static struct parser_params *
11023 struct parser_params *p;
11025 p = ALLOC_N(struct parser_params, 1);
11026 MEMZERO(p, struct parser_params, 1);
11027 parser_initialize(p);
11032 rb_parser_new(void)
11034 struct parser_params *p = parser_new();
11036 return TypedData_Wrap_Struct(0, &parser_data_type, p);
11041 * ripper#end_seen? -> Boolean
11043 * Return true if parsed source ended by +\_\_END\_\_+.
11046 rb_parser_end_seen_p(VALUE vparser)
11048 struct parser_params *parser;
11050 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11051 return ruby__end__seen ? Qtrue : Qfalse;
11056 * ripper#encoding -> encoding
11058 * Return encoding of the source.
11061 rb_parser_encoding(VALUE vparser)
11063 struct parser_params *parser;
11065 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
11066 return rb_enc_from_encoding(current_enc);
11071 * ripper.yydebug -> true or false
11076 rb_parser_get_yydebug(VALUE self)
11078 struct parser_params *parser;
11080 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
11081 return yydebug ? Qtrue : Qfalse;
11086 * ripper.yydebug = flag
11091 rb_parser_set_yydebug(VALUE self, VALUE flag)
11093 struct parser_params *parser;
11095 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
11096 yydebug = RTEST(flag);
11101 #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
11102 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
11103 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
11104 (n)->u3.cnt = (c), (p))
11107 rb_parser_malloc(struct parser_params *parser, size_t size)
11109 size_t cnt = HEAPCNT(1, size);
11110 NODE *n = NEWHEAP();
11111 void *ptr = xmalloc(size);
11113 return ADD2HEAP(n, cnt, ptr);
11117 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
11119 size_t cnt = HEAPCNT(nelem, size);
11120 NODE *n = NEWHEAP();
11121 void *ptr = xcalloc(nelem, size);
11123 return ADD2HEAP(n, cnt, ptr);
11127 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
11130 size_t cnt = HEAPCNT(1, size);
11132 if (ptr && (n = parser->heap) != NULL) {
11134 if (n->u1.node == ptr) {
11135 n->u1.node = ptr = xrealloc(ptr, size);
11136 if (n->u3.cnt) n->u3.cnt = cnt;
11139 } while ((n = n->u2.node) != NULL);
11142 ptr = xrealloc(ptr, size);
11143 return ADD2HEAP(n, cnt, ptr);
11147 rb_parser_free(struct parser_params *parser, void *ptr)
11149 NODE **prev = &parser->heap, *n;
11151 while ((n = *prev) != NULL) {
11152 if (n->u1.node == ptr) {
11153 *prev = n->u2.node;
11154 rb_gc_force_recycle((VALUE)n);
11157 prev = &n->u2.node;
11165 #ifdef RIPPER_DEBUG
11166 extern int rb_is_pointer_to_heap(VALUE);
11170 ripper_validate_object(VALUE self, VALUE x)
11172 if (x == Qfalse) return x;
11173 if (x == Qtrue) return x;
11174 if (x == Qnil) return x;
11176 rb_raise(rb_eArgError, "Qundef given");
11177 if (FIXNUM_P(x)) return x;
11178 if (SYMBOL_P(x)) return x;
11179 if (!rb_is_pointer_to_heap(x))
11180 rb_raise(rb_eArgError, "invalid pointer: %p", x);
11181 switch (BUILTIN_TYPE(x)) {
11191 if (nd_type(x) != NODE_LASGN) {
11192 rb_raise(rb_eArgError, "NODE given: %p", x);
11194 return ((NODE *)x)->nd_rval;
11196 rb_raise(rb_eArgError, "wrong type of ruby object: %p (%s)",
11197 x, rb_obj_classname(x));
11203 #define validate(x) ((x) = get_value(x))
11206 ripper_dispatch0(struct parser_params *parser, ID mid)
11208 return rb_funcall(parser->value, mid, 0);
11212 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
11215 return rb_funcall(parser->value, mid, 1, a);
11219 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
11223 return rb_funcall(parser->value, mid, 2, a, b);
11227 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
11232 return rb_funcall(parser->value, mid, 3, a, b, c);
11236 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
11242 return rb_funcall(parser->value, mid, 4, a, b, c, d);
11246 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
11253 return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
11257 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
11266 return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
11269 static const struct kw_assoc {
11272 } keyword_to_name[] = {
11273 {keyword_class, "class"},
11274 {keyword_module, "module"},
11275 {keyword_def, "def"},
11276 {keyword_undef, "undef"},
11277 {keyword_begin, "begin"},
11278 {keyword_rescue, "rescue"},
11279 {keyword_ensure, "ensure"},
11280 {keyword_end, "end"},
11281 {keyword_if, "if"},
11282 {keyword_unless, "unless"},
11283 {keyword_then, "then"},
11284 {keyword_elsif, "elsif"},
11285 {keyword_else, "else"},
11286 {keyword_case, "case"},
11287 {keyword_when, "when"},
11288 {keyword_while, "while"},
11289 {keyword_until, "until"},
11290 {keyword_for, "for"},
11291 {keyword_break, "break"},
11292 {keyword_next, "next"},
11293 {keyword_redo, "redo"},
11294 {keyword_retry, "retry"},
11295 {keyword_in, "in"},
11296 {keyword_do, "do"},
11297 {keyword_do_cond, "do"},
11298 {keyword_do_block, "do"},
11299 {keyword_return, "return"},
11300 {keyword_yield, "yield"},
11301 {keyword_super, "super"},
11302 {keyword_self, "self"},
11303 {keyword_nil, "nil"},
11304 {keyword_true, "true"},
11305 {keyword_false, "false"},
11306 {keyword_and, "and"},
11307 {keyword_or, "or"},
11308 {keyword_not, "not"},
11309 {modifier_if, "if"},
11310 {modifier_unless, "unless"},
11311 {modifier_while, "while"},
11312 {modifier_until, "until"},
11313 {modifier_rescue, "rescue"},
11314 {keyword_alias, "alias"},
11315 {keyword_defined, "defined?"},
11316 {keyword_BEGIN, "BEGIN"},
11317 {keyword_END, "END"},
11318 {keyword__LINE__, "__LINE__"},
11319 {keyword__FILE__, "__FILE__"},
11320 {keyword__ENCODING__, "__ENCODING__"},
11325 keyword_id_to_str(ID id)
11327 const struct kw_assoc *a;
11329 for (a = keyword_to_name; a->id; a++) {
11336 #undef ripper_id2sym
11338 ripper_id2sym(ID id)
11346 return ID2SYM(rb_intern2(buf, 1));
11348 if ((name = keyword_id_to_str(id))) {
11349 return ID2SYM(rb_intern(name));
11359 name = rb_id2name(id);
11361 rb_bug("cannot convert ID to string: %ld", (unsigned long)id);
11365 return ID2SYM(rb_intern(name));
11369 ripper_get_id(VALUE v)
11372 if (!RB_TYPE_P(v, T_NODE)) return 0;
11374 if (nd_type(nd) != NODE_LASGN) return 0;
11379 ripper_get_value(VALUE v)
11382 if (v == Qundef) return Qnil;
11383 if (!RB_TYPE_P(v, T_NODE)) return v;
11385 if (nd_type(nd) != NODE_LASGN) return Qnil;
11386 return nd->nd_rval;
11390 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
11395 va_start(args, fmt);
11396 str = rb_vsprintf(fmt, args);
11398 rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
11402 ripper_warn0(struct parser_params *parser, const char *fmt)
11404 rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
11408 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
11410 rb_funcall(parser->value, rb_intern("warn"), 2,
11411 STR_NEW2(fmt), INT2NUM(a));
11415 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
11417 rb_funcall(parser->value, rb_intern("warn"), 2,
11418 STR_NEW2(fmt), STR_NEW2(str));
11422 ripper_warning0(struct parser_params *parser, const char *fmt)
11424 rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
11428 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
11430 rb_funcall(parser->value, rb_intern("warning"), 2,
11431 STR_NEW2(fmt), STR_NEW2(str));
11435 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
11437 return rb_io_gets(src);
11441 ripper_s_allocate(VALUE klass)
11443 struct parser_params *p;
11446 p = ALLOC_N(struct parser_params, 1);
11447 MEMZERO(p, struct parser_params, 1);
11448 self = TypedData_Wrap_Struct(klass, &parser_data_type, p);
11453 #define ripper_initialized_p(r) ((r)->parser_lex_input != 0)
11457 * Ripper.new(src, filename="(ripper)", lineno=1) -> ripper
11459 * Create a new Ripper object.
11460 * _src_ must be a String, an IO, or an Object which has #gets method.
11462 * This method does not starts parsing.
11463 * See also Ripper#parse and Ripper.parse.
11466 ripper_initialize(int argc, VALUE *argv, VALUE self)
11468 struct parser_params *parser;
11469 VALUE src, fname, lineno;
11471 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
11472 rb_scan_args(argc, argv, "12", &src, &fname, &lineno);
11473 if (RB_TYPE_P(src, T_FILE)) {
11474 parser->parser_lex_gets = ripper_lex_get_generic;
11478 parser->parser_lex_gets = lex_get_str;
11480 parser->parser_lex_input = src;
11481 parser->eofp = Qfalse;
11482 if (NIL_P(fname)) {
11483 fname = STR_NEW2("(ripper)");
11486 StringValue(fname);
11488 parser_initialize(parser);
11490 parser->parser_ruby_sourcefile_string = fname;
11491 parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
11492 parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
11497 struct ripper_args {
11498 struct parser_params *parser;
11504 ripper_parse0(VALUE parser_v)
11506 struct parser_params *parser;
11508 TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
11509 parser_prepare(parser);
11510 ripper_yyparse((void*)parser);
11511 return parser->result;
11515 ripper_ensure(VALUE parser_v)
11517 struct parser_params *parser;
11519 TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
11520 parser->parsing_thread = Qnil;
11528 * Start parsing and returns the value of the root action.
11531 ripper_parse(VALUE self)
11533 struct parser_params *parser;
11535 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
11536 if (!ripper_initialized_p(parser)) {
11537 rb_raise(rb_eArgError, "method called for uninitialized object");
11539 if (!NIL_P(parser->parsing_thread)) {
11540 if (parser->parsing_thread == rb_thread_current())
11541 rb_raise(rb_eArgError, "Ripper#parse is not reentrant");
11543 rb_raise(rb_eArgError, "Ripper#parse is not multithread-safe");
11545 parser->parsing_thread = rb_thread_current();
11546 rb_ensure(ripper_parse0, self, ripper_ensure, self);
11548 return parser->result;
11553 * ripper#column -> Integer
11555 * Return column number of current parsing line.
11556 * This number starts from 0.
11559 ripper_column(VALUE self)
11561 struct parser_params *parser;
11564 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
11565 if (!ripper_initialized_p(parser)) {
11566 rb_raise(rb_eArgError, "method called for uninitialized object");
11568 if (NIL_P(parser->parsing_thread)) return Qnil;
11569 col = parser->tokp - parser->parser_lex_pbeg;
11570 return LONG2NUM(col);
11575 * ripper#filename -> String
11577 * Return current parsing filename.
11580 ripper_filename(VALUE self)
11582 struct parser_params *parser;
11584 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
11585 if (!ripper_initialized_p(parser)) {
11586 rb_raise(rb_eArgError, "method called for uninitialized object");
11588 return parser->parser_ruby_sourcefile_string;
11593 * ripper#lineno -> Integer
11595 * Return line number of current parsing line.
11596 * This number starts from 1.
11599 ripper_lineno(VALUE self)
11601 struct parser_params *parser;
11603 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
11604 if (!ripper_initialized_p(parser)) {
11605 rb_raise(rb_eArgError, "method called for uninitialized object");
11607 if (NIL_P(parser->parsing_thread)) return Qnil;
11608 return INT2NUM(parser->parser_ruby_sourceline);
11611 #ifdef RIPPER_DEBUG
11614 ripper_assert_Qundef(VALUE self, VALUE obj, VALUE msg)
11617 if (obj == Qundef) {
11618 rb_raise(rb_eArgError, "%"PRIsVALUE, msg);
11625 ripper_value(VALUE self, VALUE obj)
11627 return ULONG2NUM(obj);
11635 parser_data_type.parent = RTYPEDDATA_TYPE(rb_parser_new());
11637 ripper_init_eventids1();
11638 ripper_init_eventids2();
11639 /* ensure existing in symbol table */
11640 (void)rb_intern("||");
11641 (void)rb_intern("&&");
11647 InitVM_ripper(void)
11651 Ripper = rb_define_class("Ripper", rb_cObject);
11652 /* version of Ripper */
11653 rb_define_const(Ripper, "Version", rb_usascii_str_new2(RIPPER_VERSION));
11654 rb_define_alloc_func(Ripper, ripper_s_allocate);
11655 rb_define_method(Ripper, "initialize", ripper_initialize, -1);
11656 rb_define_method(Ripper, "parse", ripper_parse, 0);
11657 rb_define_method(Ripper, "column", ripper_column, 0);
11658 rb_define_method(Ripper, "filename", ripper_filename, 0);
11659 rb_define_method(Ripper, "lineno", ripper_lineno, 0);
11660 rb_define_method(Ripper, "end_seen?", rb_parser_end_seen_p, 0);
11661 rb_define_method(Ripper, "encoding", rb_parser_encoding, 0);
11662 rb_define_method(Ripper, "yydebug", rb_parser_get_yydebug, 0);
11663 rb_define_method(Ripper, "yydebug=", rb_parser_set_yydebug, 1);
11664 #ifdef RIPPER_DEBUG
11665 rb_define_method(rb_mKernel, "assert_Qundef", ripper_assert_Qundef, 2);
11666 rb_define_method(rb_mKernel, "rawVALUE", ripper_value, 1);
11667 rb_define_method(rb_mKernel, "validate_object", ripper_validate_object, 1);
11670 ripper_init_eventids1_table(Ripper);
11671 ripper_init_eventids2_table(Ripper);
11674 /* Hack to let RDoc document SCRIPT_LINES__ */
11677 * When a Hash is assigned to +SCRIPT_LINES__+ the contents of files loaded
11678 * after the assignment will be added as an Array of lines with the file
11681 rb_define_global_const("SCRIPT_LINES__", Qnil);
11685 #endif /* RIPPER */