Lines Matching refs:parser
36 #define YYMALLOC(size) rb_parser_malloc(parser, (size))
37 #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
38 #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
39 #define YYFREE(ptr) rb_parser_free(parser, (ptr))
308 #define yyerror(msg) parser_yyerror(parser, (msg))
310 #define lex_strterm (parser->parser_lex_strterm)
311 #define lex_state (parser->parser_lex_state)
312 #define cond_stack (parser->parser_cond_stack)
313 #define cmdarg_stack (parser->parser_cmdarg_stack)
314 #define class_nest (parser->parser_class_nest)
315 #define paren_nest (parser->parser_paren_nest)
316 #define lpar_beg (parser->parser_lpar_beg)
317 #define brace_nest (parser->parser_brace_nest)
318 #define in_single (parser->parser_in_single)
319 #define in_def (parser->parser_in_def)
320 #define compile_for_eval (parser->parser_compile_for_eval)
321 #define cur_mid (parser->parser_cur_mid)
322 #define in_defined (parser->parser_in_defined)
323 #define tokenbuf (parser->parser_tokenbuf)
324 #define tokidx (parser->parser_tokidx)
325 #define toksiz (parser->parser_toksiz)
326 #define tokline (parser->parser_tokline)
327 #define lex_input (parser->parser_lex_input)
328 #define lex_lastline (parser->parser_lex_lastline)
329 #define lex_nextline (parser->parser_lex_nextline)
330 #define lex_pbeg (parser->parser_lex_pbeg)
331 #define lex_p (parser->parser_lex_p)
332 #define lex_pend (parser->parser_lex_pend)
333 #define heredoc_end (parser->parser_heredoc_end)
334 #define command_start (parser->parser_command_start)
335 #define deferred_nodes (parser->parser_deferred_nodes)
336 #define lex_gets_ptr (parser->parser_lex_gets_ptr)
337 #define lex_gets (parser->parser_lex_gets)
338 #define lvtbl (parser->parser_lvtbl)
339 #define ruby__end__seen (parser->parser_ruby__end__seen)
340 #define ruby_sourceline (parser->parser_ruby_sourceline)
341 #define ruby_sourcefile (parser->parser_ruby_sourcefile)
342 #define ruby_sourcefile_string (parser->parser_ruby_sourcefile_string)
343 #define current_enc (parser->enc)
344 #define yydebug (parser->parser_yydebug)
347 #define ruby_eval_tree (parser->parser_eval_tree)
348 #define ruby_eval_tree_begin (parser->parser_eval_tree_begin)
349 #define ruby_debug_lines (parser->debug_lines)
350 #define ruby_coverage (parser->coverage)
363 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
366 #define cond(node) cond_gen(parser, (node))
368 #define logop(type,node1,node2) logop_gen(parser, (type), (node1), (node2))
376 #define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node))
377 #define void_expr0(node) void_expr_gen(parser, (node))
380 #define void_stmts(node) void_stmts_gen(parser, (node))
382 #define reduce_nodes(n) reduce_nodes_gen(parser,(n))
384 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
387 #define block_append(h,t) block_append_gen(parser,(h),(t))
389 #define list_append(l,i) list_append_gen(parser,(l),(i))
391 #define list_concat(h,t) list_concat_gen(parser,(h),(t))
393 #define arg_append(h,t) arg_append_gen(parser,(h),(t))
395 #define arg_concat(h,t) arg_concat_gen(parser,(h),(t))
397 #define literal_concat(h,t) literal_concat_gen(parser,(h),(t))
400 #define new_evstr(n) new_evstr_gen(parser,(n))
402 #define evstr2dstr(n) evstr2dstr_gen(parser,(n))
406 #define call_bin_op(recv,id,arg1) call_bin_op_gen(parser, (recv),(id),(arg1))
408 #define call_uni_op(recv,id) call_uni_op_gen(parser, (recv),(id))
411 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
413 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
417 #define ret_args(node) ret_args_gen(parser, (node))
420 #define new_yield(node) new_yield_gen(parser, (node))
422 #define dsym_node(node) dsym_node_gen(parser, (node))
425 #define gettable(id) gettable_gen(parser,(id))
427 #define assignable(id,node) assignable_gen(parser, (id), (node))
430 #define aryset(node1,node2) aryset_gen(parser, (node1), (node2))
432 #define attrset(node,id) attrset_gen(parser, (node), (id))
435 #define rb_backref_error(n) rb_backref_error_gen(parser,(n))
437 #define node_assign(node1, node2) node_assign_gen(parser, (node1), (node2))
439 static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
440 static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs);
441 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (attr), (op), (rhs))
442 static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs);
443 #define new_const_op_assign(lhs, op, rhs) new_const_op_assign_gen(parser, (lhs), (op), (rhs))
446 #define match_op(node1,node2) match_op_gen(parser, (node1), (node2))
449 #define local_tbl() local_tbl_gen(parser)
454 #define reg_compile(str,options) reg_compile_gen(parser, (str), (options))
456 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options))
458 #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options))
459 static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match);
460 #define reg_named_capture_assign(regexp,match) reg_named_capture_assign_gen(parser,(regexp),(match))
474 #define assignable(lhs,node) assignable_gen(parser, (lhs))
475 static int id_is_var_gen(struct parser_params *parser, ID id);
476 #define id_is_var(id) id_is_var_gen(parser, (id))
480 static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs);
481 static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs);
482 #define new_attr_op_assign(lhs, type, attr, op, rhs) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs))
486 #define new_op_assign(lhs, op, rhs) new_op_assign_gen(parser, (lhs), (op), (rhs))
489 #define formal_argument(id) formal_argument_gen(parser, (id))
491 #define shadowing_lvar(name) shadowing_lvar_gen(parser, (name))
493 #define new_bv(id) new_bv_gen(parser, (id))
496 #define local_push(top) local_push_gen(parser,(top))
498 #define local_pop() local_pop_gen(parser)
500 #define local_var(id) local_var_gen(parser, (id))
502 #define arg_var(id) arg_var_gen(parser, (id))
504 #define local_id(id) local_id_gen(parser, (id))
506 #define internal_id() internal_id_gen(parser)
509 #define dyna_push() dyna_push_gen(parser)
511 #define dyna_pop(node) dyna_pop_gen(parser, (node))
513 #define dyna_in_block() dyna_in_block_gen(parser)
516 #define dvar_defined(id) dvar_defined_gen(parser, (id), 0)
517 #define dvar_defined_get(id) dvar_defined_gen(parser, (id), 1)
519 #define dvar_curr(id) dvar_curr_gen(parser, (id))
522 #define lvar_defined(id) lvar_defined_gen(parser, (id))
560 #define dispatch0(n) ripper_dispatch0(parser, TOKEN_PASTE(ripper_id_, n))
561 #define dispatch1(n,a) ripper_dispatch1(parser, TOKEN_PASTE(ripper_id_, n), (a))
562 #define dispatch2(n,a,b) ripper_dispatch2(parser, TOKEN_PASTE(ripper_id_, n), (a), (b))
563 #define dispatch3(n,a,b,c) ripper_dispatch3(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c))
564 #define dispatch4(n,a,b,c,d) ripper_dispatch4(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d))
565 #define dispatch5(n,a,b,c,d,e) ripper_dispatch5(parser, TOKEN_PASTE(ripper_id_, n), (a), (b), (c), (d), (e))
566 #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))
608 new_args_gen(struct parser_params *parser, VALUE f, VALUE o, VALUE r, VALUE p, VALUE tail)
614 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
617 new_args_tail_gen(struct parser_params *parser, VALUE k, VALUE kr, VALUE b)
621 #define new_args_tail(k,kr,b) new_args_tail_gen(parser, (k),(kr),(b))
643 # define rb_warn0(fmt) ripper_warn0(parser, (fmt))
644 # define rb_warnI(fmt,a) ripper_warnI(parser, (fmt), (a))
645 # define rb_warnS(fmt,a) ripper_warnS(parser, (fmt), (a))
646 # define rb_warn4S(file,line,fmt,a) ripper_warnS(parser, (fmt), (a))
647 # define rb_warning0(fmt) ripper_warning0(parser, (fmt))
648 # define rb_warningS(fmt,a) ripper_warningS(parser, (fmt), (a))
660 # define PARSER_ARG parser,
663 # define compile_error parser->nerr++,rb_compile_error_with_enc
679 #define token_info_push(token) (RTEST(ruby_verbose) ? token_info_push(parser, (token)) : (void)0)
680 #define token_info_pop(token) (RTEST(ruby_verbose) ? token_info_pop(parser, (token)) : (void)0)
687 %pure-parser
688 %lex-param {struct parser_params *parser}
689 %parse-param {struct parser_params *parser}
880 parser->result = dispatch1(program, $$);
3922 if (!literal_concat0(parser, lit, tail)) {
4998 # undef parser
5001 # define yylval (*((YYSTYPE*)(parser->parser_yylval)))
5005 static void parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc);
5010 # define nextc() parser_nextc(parser)
5011 # define pushback(c) parser_pushback(parser, (c))
5012 # define newtok() parser_newtok(parser)
5013 # define tokspace(n) parser_tokspace(parser, (n))
5014 # define tokadd(c) parser_tokadd(parser, (c))
5015 # define tok_hex(numlen) parser_tok_hex(parser, (numlen))
5016 # define read_escape(flags,e) parser_read_escape(parser, (flags), (e))
5017 # define tokadd_escape(e) parser_tokadd_escape(parser, (e))
5018 # define regx_options() parser_regx_options(parser)
5019 # define tokadd_string(f,t,p,n,e) parser_tokadd_string(parser,(f),(t),(p),(n),(e))
5020 # define parse_string(n) parser_parse_string(parser,(n))
5021 # define tokaddmbc(c, enc) parser_tokaddmbc(parser, (c), (enc))
5022 # define here_document(n) parser_here_document(parser,(n))
5023 # define heredoc_identifier() parser_heredoc_identifier(parser)
5024 # define heredoc_restore(n) parser_heredoc_restore(parser,(n))
5025 # define whole_match_p(e,l,i) parser_whole_match_p(parser,(e),(l),(i))
5058 ripper_has_scan_event(struct parser_params *parser)
5061 if (lex_p < parser->tokp) rb_raise(rb_eRuntimeError, "lex_p < tokp");
5062 return lex_p > parser->tokp;
5066 ripper_scan_event_val(struct parser_params *parser, int t)
5068 VALUE str = STR_NEW(parser->tokp, lex_p - parser->tokp);
5069 VALUE rval = ripper_dispatch1(parser, ripper_token2eventid(t), str);
5070 ripper_flush(parser);
5075 ripper_dispatch_scan_event(struct parser_params *parser, int t)
5077 if (!ripper_has_scan_event(parser)) return;
5078 yylval_rval = ripper_scan_event_val(parser, t);
5082 ripper_dispatch_ignored_scan_event(struct parser_params *parser, int t)
5084 if (!ripper_has_scan_event(parser)) return;
5085 (void)ripper_scan_event_val(parser, t);
5089 ripper_dispatch_delayed_token(struct parser_params *parser, int t)
5092 const char *saved_tokp = parser->tokp;
5094 ruby_sourceline = parser->delayed_line;
5095 parser->tokp = lex_pbeg + parser->delayed_col;
5096 yylval_rval = ripper_dispatch1(parser, ripper_token2eventid(t), parser->delayed);
5097 parser->delayed = Qnil;
5099 parser->tokp = saved_tokp;
5122 #define parser_is_identchar() (!parser->eofp && is_identchar((lex_p-1),lex_pend,current_enc))
5128 token_info_get_column(struct parser_params *parser, const char *token)
5142 token_info_has_nonspaces(struct parser_params *parser, const char *token)
5155 token_info_push(struct parser_params *parser, const char *token)
5159 if (!parser->parser_token_info_enabled) return;
5163 ptinfo->column = token_info_get_column(parser, token);
5164 ptinfo->nonspc = token_info_has_nonspaces(parser, token);
5165 ptinfo->next = parser->parser_token_info;
5167 parser->parser_token_info = ptinfo;
5172 token_info_pop(struct parser_params *parser, const char *token)
5175 token_info *ptinfo = parser->parser_token_info;
5178 parser->parser_token_info = ptinfo->next;
5179 if (token_info_get_column(parser, token) == ptinfo->column) { /* OK */
5186 if (token_info_has_nonspaces(parser, token) || ptinfo->nonspc) { /* SKIP */
5189 if (parser->parser_token_info_enabled) {
5201 parser_yyerror(struct parser_params *parser, const char *msg)
5262 static void parser_prepare(struct parser_params *parser);
5298 e_option_supplied(struct parser_params *parser)
5308 struct parser_params *parser = (struct parser_params *)arg;
5320 if (!e_option_supplied(parser)) {
5325 parser_prepare(parser);
5328 parser->parser_token_info_enabled = !compile_for_eval && RTEST(ruby_verbose);
5332 RUBY_DTRACE_PARSE_BEGIN(parser->parser_ruby_sourcefile,
5333 parser->parser_ruby_sourceline);
5336 n = yyparse((void*)parser);
5339 RUBY_DTRACE_PARSE_END(parser->parser_ruby_sourcefile,
5340 parser->parser_ruby_sourceline);
5350 if (parser->nerr) {
5364 yycompile(struct parser_params *parser, VALUE fname, int line)
5369 return (NODE *)rb_suppress_tracing(yycompile0, (VALUE)parser);
5384 lex_get_str(struct parser_params *parser, VALUE s)
5404 lex_getline(struct parser_params *parser)
5406 VALUE line = (*parser->parser_lex_gets)(parser, parser->parser_lex_input);
5429 struct parser_params *parser;
5432 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
5439 node = yycompile(parser, fname, line);
5480 lex_io_gets(struct parser_params *parser, VALUE io)
5502 struct parser_params *parser;
5505 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
5511 node = yycompile(parser, fname, start);
5553 #define lex_goto_eol(parser) ((parser)->parser_lex_p = (parser)->parser_lex_pend)
5559 parser_nextc(struct parser_params *parser)
5567 if (parser->eofp)
5570 if (!lex_input || NIL_P(v = lex_getline(parser))) {
5571 parser->eofp = Qtrue;
5572 lex_goto_eol(parser);
5578 if (parser->tokp < lex_pend) {
5579 if (NIL_P(parser->delayed)) {
5580 parser->delayed = rb_str_buf_new(1024);
5581 rb_enc_associate(parser->delayed, current_enc);
5582 rb_str_buf_cat(parser->delayed,
5583 parser->tokp, lex_pend - parser->tokp);
5584 parser->delayed_line = ruby_sourceline;
5585 parser->delayed_col = (int)(parser->tokp - lex_pbeg);
5588 rb_str_buf_cat(parser->delayed,
5589 parser->tokp, lex_pend - parser->tokp);
5598 parser->line_count++;
5601 ripper_flush(parser);
5615 parser_pushback(struct parser_params *parser, int c)
5632 parser_newtok(struct parser_params *parser)
5648 parser_tokspace(struct parser_params *parser, int n)
5660 parser_tokadd(struct parser_params *parser, int c)
5670 parser_tok_hex(struct parser_params *parser, size_t *numlen)
5687 parser_tokadd_utf8(struct parser_params *parser, rb_encoding **encp,
5762 parser_read_escape(struct parser_params *parser, int flags,
5853 parser_tokaddmbc(struct parser_params *parser, int c, rb_encoding *enc)
5860 parser_tokadd_escape(struct parser_params *parser, rb_encoding **encp)
5933 parser_regx_options(struct parser_params *parser)
5976 parser_tokadd_mbchar(struct parser_params *parser, int c)
5989 #define tokadd_mbchar(c) parser_tokadd_mbchar(parser, (c))
6005 parser_tokadd_string(struct parser_params *parser,
6069 parser_tokadd_utf8(parser, &enc, 1,
6143 ripper_flush_string_content(struct parser_params *parser, rb_encoding *enc)
6145 if (!NIL_P(parser->delayed)) {
6146 ptrdiff_t len = lex_p - parser->tokp;
6148 rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
6150 ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
6151 parser->tokp = lex_p;
6155 #define flush_string_content(enc) ripper_flush_string_content(parser, (enc))
6189 parser_peek_variable_name(struct parser_params *parser)
6225 parser_parse_string(struct parser_params *parser, NODE *quote)
6254 int t = parser_peek_variable_name(parser);
6264 if (parser->eofp)
6269 if (parser->eofp)
6283 parser_heredoc_identifier(struct parser_params *parser)
6332 ripper_dispatch_scan_event(parser, tHEREDOC_BEG);
6335 lex_goto_eol(parser);
6341 ripper_flush(parser);
6346 parser_heredoc_restore(struct parser_params *parser, NODE *here)
6359 ripper_flush(parser);
6363 parser_whole_match_p(struct parser_params *parser,
6379 ripper_dispatch_heredoc_end(struct parser_params *parser)
6381 if (!NIL_P(parser->delayed))
6382 ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
6383 lex_goto_eol(parser);
6384 ripper_dispatch_ignored_scan_event(parser, tHEREDOC_END);
6387 #define dispatch_heredoc_end() ripper_dispatch_heredoc_end(parser)
6393 parser_here_document(struct parser_params *parser, NODE *here)
6409 if (NIL_P(parser->delayed)) {
6410 ripper_dispatch_scan_event(parser, tSTRING_CONTENT);
6414 ((len = lex_p - parser->tokp) > 0 &&
6415 (str = STR_NEW3(parser->tokp, len, enc, func), 1))) {
6416 rb_str_append(parser->delayed, str);
6418 ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
6420 lex_goto_eol(parser);
6453 lex_goto_eol(parser);
6464 int t = parser_peek_variable_name(parser);
6472 if (parser->eofp) goto error;
6496 arg_ambiguous_gen(struct parser_params *parser)
6504 #define arg_ambiguous() (arg_ambiguous_gen(parser), 1)
6507 formal_argument_gen(struct parser_params *parser, ID lhs)
6518 lvar_defined_gen(struct parser_params *parser, ID id)
6525 parser_encode_length(struct parser_params *parser, const char *name, long len)
6545 parser_set_encode(struct parser_params *parser, const char *name)
6564 parser->enc = enc;
6577 comment_at_top(struct parser_params *parser)
6580 if (parser->line_count != (parser->has_shebang ? 2 : 1)) return 0;
6589 typedef long (*rb_magic_comment_length_t)(struct parser_params *parser, const char *name, long len);
6590 typedef void (*rb_magic_comment_setter_t)(struct parser_params *parser, const char *name, const char *val);
6593 magic_comment_encoding(struct parser_params *parser, const char *name, const char *val)
6595 if (!comment_at_top(parser)) {
6598 parser_set_encode(parser, val);
6602 parser_set_token_info(struct parser_params *parser, const char *name, const char *val)
6604 int *p = &parser->parser_token_info_enabled;
6670 parser_magic_comment(struct parser_params *parser, const char *str, long len)
6747 n = (*p->length)(parser, vbeg, n);
6750 (*p->func)(parser, s, RSTRING_PTR(val));
6764 set_file_encoding(struct parser_params *parser, const char *str, const char *send)
6801 s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
6802 parser_set_encode(parser, RSTRING_PTR(s));
6807 parser_prepare(struct parser_params *parser)
6812 if (peek('!')) parser->has_shebang = 1;
6818 parser->enc = rb_utf8_encoding();
6828 parser->enc = rb_enc_get(lex_lastline);
6852 parser_yylex(struct parser_params *parser)
6910 ripper_dispatch_scan_event(parser, tSP);
6916 if (!parser_magic_comment(parser, lex_p, lex_pend - lex_p)) {
6917 if (comment_at_top(parser)) {
6918 set_file_encoding(parser, lex_p, lex_pend);
6923 ripper_dispatch_scan_event(parser, tCOMMENT);
6931 ripper_dispatch_scan_event(parser, tIGNORED_NL);
6954 lex_goto_eol(parser);
6957 parser->tokp = lex_p;
7037 lex_goto_eol(parser);
7038 ripper_dispatch_scan_event(parser, tEMBDOC_BEG);
7041 lex_goto_eol(parser);
7044 ripper_dispatch_scan_event(parser, tEMBDOC);
7059 lex_goto_eol(parser);
7061 ripper_dispatch_scan_event(parser, tEMBDOC_END);
7216 c = parser_tokadd_utf8(parser, &enc, 0, 0, 0);
7751 ripper_dispatch_scan_event(parser, tSP);
7963 parser->eofp = Qtrue;
7967 lex_goto_eol(parser);
7968 ripper_dispatch_scan_event(parser, k__END__);
8127 struct parser_params *parser = (struct parser_params*)p;
8131 parser->parser_yylval = lval;
8132 parser->parser_yylval->val = Qundef;
8134 t = parser_yylex(parser);
8136 if (!NIL_P(parser->delayed)) {
8137 ripper_dispatch_delayed_token(parser, t);
8141 ripper_dispatch_scan_event(parser, t);
8149 node_newnode(struct parser_params *parser, enum node_type type, VALUE a0, VALUE a1, VALUE a2)
8188 parser_warning(struct parser_params *parser, NODE *node, const char *mesg)
8192 #define parser_warning(node, mesg) parser_warning(parser, (node), (mesg))
8195 parser_warn(struct parser_params *parser, NODE *node, const char *mesg)
8199 #define parser_warn(node, mesg) parser_warn(parser, (node), (mesg))
8202 block_append_gen(struct parser_params *parser, NODE *head, NODE *tail)
8256 list_append_gen(struct parser_params *parser, NODE *list, NODE *item)
8276 list_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
8300 literal_concat0(struct parser_params *parser, VALUE head, VALUE tail)
8317 literal_concat_gen(struct parser_params *parser, NODE *head, NODE *tail)
8343 if (!literal_concat0(parser, lit, tail->nd_lit)) {
8358 if (!literal_concat0(parser, head->nd_lit, tail->nd_lit))
8374 if (!literal_concat0(parser, lit, tail->nd_lit))
8398 evstr2dstr_gen(struct parser_params *parser, NODE *node)
8407 new_evstr_gen(struct parser_params *parser, NODE *node)
8421 call_bin_op_gen(struct parser_params *parser, NODE *recv, ID id, NODE *arg1)
8429 call_uni_op_gen(struct parser_params *parser, NODE *recv, ID id)
8436 match_op_gen(struct parser_params *parser, NODE *node1, NODE *node2)
8470 gettable_gen(struct parser_params *parser, ID id)
8508 id_is_var_gen(struct parser_params *parser, ID id)
8544 assignable_gen(struct parser_params *parser, VALUE lhs)
8547 assignable_gen(struct parser_params *parser, ID id, NODE *val)
8553 # define parser_yyerror(parser, x) dispatch1(assign_error, lhs)
8639 shadowing_lvar_gen(struct parser_params *parser, ID name)
8663 new_bv_gen(struct parser_params *parser, ID name)
8677 aryset_gen(struct parser_params *parser, NODE *recv, NODE *idx)
8685 block_dup_check_gen(struct parser_params *parser, NODE *node1, NODE *node2)
8733 attrset_gen(struct parser_params *parser, NODE *recv, ID id)
8741 rb_backref_error_gen(struct parser_params *parser, NODE *node)
8754 arg_concat_gen(struct parser_params *parser, NODE *node1, NODE *node2)
8779 arg_append_gen(struct parser_params *parser, NODE *node1, NODE *node2)
8805 node_assign_gen(struct parser_params *parser, NODE *lhs, NODE *rhs)
8836 value_expr_gen(struct parser_params *parser, NODE *node)
8898 void_expr_gen(struct parser_params *parser, NODE *node)
8987 void_stmts_gen(struct parser_params *parser, NODE *node)
9011 reduce_nodes_gen(struct parser_params *parser, NODE **body)
9096 assign_in_cond(struct parser_params *parser, NODE *node)
9123 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
9125 if (!e_option_supplied(parser)) parser_warn(node, str);
9129 warning_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
9131 if (!e_option_supplied(parser)) parser_warning(node, str);
9166 range_op(struct parser_params *parser, NODE *node)
9175 warn_unless_e_option(parser, node, "integer literal in conditional range");
9178 return cond0(parser, node);
9203 cond0(struct parser_params *parser, NODE *node)
9206 assign_in_cond(parser, node);
9217 warning_unless_e_option(parser, node, "regex literal in condition");
9222 node->nd_1st = cond0(parser, node->nd_1st);
9223 node->nd_2nd = cond0(parser, node->nd_2nd);
9228 node->nd_beg = range_op(parser, node->nd_beg);
9229 node->nd_end = range_op(parser, node->nd_end);
9232 if (!e_option_supplied(parser)) {
9247 warn_unless_e_option(parser, node, "regex literal in condition");
9260 cond_gen(struct parser_params *parser, NODE *node)
9263 return cond0(parser, node);
9267 logop_gen(struct parser_params *parser, enum node_type type, NODE *left, NODE *right)
9282 no_blockarg(struct parser_params *parser, NODE *node)
9290 ret_args_gen(struct parser_params *parser, NODE *node)
9293 no_blockarg(parser, node);
9307 new_yield_gen(struct parser_params *parser, NODE *node)
9309 if (node) no_blockarg(parser, node);
9354 new_args_gen(struct parser_params *parser, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
9376 new_args_tail_gen(struct parser_params *parser, NODE *k, ID kr, ID b)
9401 dsym_node_gen(struct parser_params *parser, NODE *node)
9428 new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
9457 new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID attr, ID op, NODE *rhs)
9473 new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs)
9494 new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs)
9500 new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs)
9508 warn_unused_var(struct parser_params *parser, struct local_vars *local)
9528 local_push_gen(struct parser_params *parser, int inherit_dvars)
9537 (ifndef_ripper(compile_for_eval || e_option_supplied(parser))+0)) &&
9545 local_pop_gen(struct parser_params *parser)
9549 warn_unused_var(parser, lvtbl);
9576 local_tbl_gen(struct parser_params *parser)
9591 arg_var_gen(struct parser_params *parser, ID id)
9598 local_var_gen(struct parser_params *parser, ID id)
9608 local_id_gen(struct parser_params *parser, ID id)
9636 dyna_push_gen(struct parser_params *parser)
9647 dyna_pop_1(struct parser_params *parser)
9652 warn_unused_var(parser, lvtbl);
9665 dyna_pop_gen(struct parser_params *parser, const struct vtable *lvargs)
9668 dyna_pop_1(parser);
9675 dyna_pop_1(parser);
9679 dyna_in_block_gen(struct parser_params *parser)
9685 dvar_defined_gen(struct parser_params *parser, ID id, int get)
9716 dvar_curr_gen(struct parser_params *parser, ID id)
9724 reg_fragment_setenc_gen(struct parser_params* parser, VALUE str, int options)
9763 reg_fragment_check_gen(struct parser_params* parser, VALUE str, int options)
9778 struct parser_params* parser;
9790 struct parser_params* parser = arg->parser;
9826 reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, NODE *match)
9830 arg.parser = parser;
9858 reg_compile_gen(struct parser_params* parser, VALUE str, int options)
9891 struct parser_params *parser;
9895 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
9923 struct parser_params *parser;
9927 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
10062 internal_id_gen(struct parser_params *parser)
10708 parser_initialize(struct parser_params *parser)
10710 parser->eofp = Qfalse;
10712 parser->parser_lex_strterm = 0;
10713 parser->parser_cond_stack = 0;
10714 parser->parser_cmdarg_stack = 0;
10715 parser->parser_class_nest = 0;
10716 parser->parser_paren_nest = 0;
10717 parser->parser_lpar_beg = 0;
10718 parser->parser_brace_nest = 0;
10719 parser->parser_in_single = 0;
10720 parser->parser_in_def = 0;
10721 parser->parser_in_defined = 0;
10722 parser->parser_compile_for_eval = 0;
10723 parser->parser_cur_mid = 0;
10724 parser->parser_tokenbuf = NULL;
10725 parser->parser_tokidx = 0;
10726 parser->parser_toksiz = 0;
10727 parser->parser_heredoc_end = 0;
10728 parser->parser_command_start = TRUE;
10729 parser->parser_deferred_nodes = 0;
10730 parser->parser_lex_pbeg = 0;
10731 parser->parser_lex_p = 0;
10732 parser->parser_lex_pend = 0;
10733 parser->parser_lvtbl = 0;
10734 parser->parser_ruby__end__seen = 0;
10735 parser->parser_ruby_sourcefile = 0;
10736 parser->parser_ruby_sourcefile_string = Qnil;
10738 parser->is_ripper = 0;
10739 parser->parser_eval_tree_begin = 0;
10740 parser->parser_eval_tree = 0;
10742 parser->is_ripper = 1;
10743 parser->delayed = Qnil;
10745 parser->result = Qnil;
10746 parser->parsing_thread = Qnil;
10747 parser->toplevel_p = TRUE;
10750 parser->heap = NULL;
10752 parser->enc = rb_utf8_encoding();
10824 "parser",
10869 struct parser_params *parser;
10871 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
10884 struct parser_params *parser;
10886 TypedData_Get_Struct(vparser, struct parser_params, &parser_data_type, parser);
10899 struct parser_params *parser;
10901 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
10914 struct parser_params *parser;
10916 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
10923 #define NEWHEAP() rb_node_newnode(NODE_ALLOCA, 0, (VALUE)parser->heap, 0)
10924 #define ADD2HEAP(n, c, p) ((parser->heap = (n))->u1.node = (p), \
10928 rb_parser_malloc(struct parser_params *parser, size_t size)
10938 rb_parser_calloc(struct parser_params *parser, size_t nelem, size_t size)
10948 rb_parser_realloc(struct parser_params *parser, void *ptr, size_t size)
10953 if (ptr && (n = parser->heap) != NULL) {
10968 rb_parser_free(struct parser_params *parser, void *ptr)
10970 NODE **prev = &parser->heap, *n;
11025 ripper_dispatch0(struct parser_params *parser, ID mid)
11027 return rb_funcall(parser->value, mid, 0);
11031 ripper_dispatch1(struct parser_params *parser, ID mid, VALUE a)
11034 return rb_funcall(parser->value, mid, 1, a);
11038 ripper_dispatch2(struct parser_params *parser, ID mid, VALUE a, VALUE b)
11042 return rb_funcall(parser->value, mid, 2, a, b);
11046 ripper_dispatch3(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c)
11051 return rb_funcall(parser->value, mid, 3, a, b, c);
11055 ripper_dispatch4(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d)
11061 return rb_funcall(parser->value, mid, 4, a, b, c, d);
11065 ripper_dispatch5(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e)
11072 return rb_funcall(parser->value, mid, 5, a, b, c, d, e);
11076 ripper_dispatch7(struct parser_params *parser, ID mid, VALUE a, VALUE b, VALUE c, VALUE d, VALUE e, VALUE f, VALUE g)
11085 return rb_funcall(parser->value, mid, 7, a, b, c, d, e, f, g);
11209 ripper_compile_error(struct parser_params *parser, const char *fmt, ...)
11217 rb_funcall(parser->value, rb_intern("compile_error"), 1, str);
11221 ripper_warn0(struct parser_params *parser, const char *fmt)
11223 rb_funcall(parser->value, rb_intern("warn"), 1, STR_NEW2(fmt));
11227 ripper_warnI(struct parser_params *parser, const char *fmt, int a)
11229 rb_funcall(parser->value, rb_intern("warn"), 2,
11234 ripper_warnS(struct parser_params *parser, const char *fmt, const char *str)
11236 rb_funcall(parser->value, rb_intern("warn"), 2,
11241 ripper_warning0(struct parser_params *parser, const char *fmt)
11243 rb_funcall(parser->value, rb_intern("warning"), 1, STR_NEW2(fmt));
11247 ripper_warningS(struct parser_params *parser, const char *fmt, const char *str)
11249 rb_funcall(parser->value, rb_intern("warning"), 2,
11254 ripper_lex_get_generic(struct parser_params *parser, VALUE src)
11287 struct parser_params *parser;
11290 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
11293 parser->parser_lex_gets = ripper_lex_get_generic;
11297 parser->parser_lex_gets = lex_get_str;
11299 parser->parser_lex_input = src;
11300 parser->eofp = Qfalse;
11307 parser_initialize(parser);
11309 parser->parser_ruby_sourcefile_string = fname;
11310 parser->parser_ruby_sourcefile = RSTRING_PTR(fname);
11311 parser->parser_ruby_sourceline = NIL_P(lineno) ? 0 : NUM2INT(lineno) - 1;
11317 struct parser_params *parser;
11325 struct parser_params *parser;
11327 TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
11328 parser_prepare(parser);
11329 ripper_yyparse((void*)parser);
11330 return parser->result;
11336 struct parser_params *parser;
11338 TypedData_Get_Struct(parser_v, struct parser_params, &parser_data_type, parser);
11339 parser->parsing_thread = Qnil;
11352 struct parser_params *parser;
11354 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
11355 if (!ripper_initialized_p(parser)) {
11358 if (!NIL_P(parser->parsing_thread)) {
11359 if (parser->parsing_thread == rb_thread_current())
11364 parser->parsing_thread = rb_thread_current();
11367 return parser->result;
11380 struct parser_params *parser;
11383 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
11384 if (!ripper_initialized_p(parser)) {
11387 if (NIL_P(parser->parsing_thread)) return Qnil;
11388 col = parser->tokp - parser->parser_lex_pbeg;
11401 struct parser_params *parser;
11403 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
11404 if (!ripper_initialized_p(parser)) {
11407 return parser->parser_ruby_sourcefile_string;
11420 struct parser_params *parser;
11422 TypedData_Get_Struct(self, struct parser_params, &parser_data_type, parser);
11423 if (!ripper_initialized_p(parser)) {
11426 if (NIL_P(parser->parsing_thread)) return Qnil;
11427 return INT2NUM(parser->parser_ruby_sourceline);