diff options
Diffstat (limited to 'node_dump.c')
| -rw-r--r-- | node_dump.c | 187 |
1 files changed, 153 insertions, 34 deletions
diff --git a/node_dump.c b/node_dump.c index 37abea8441..82a7d78c28 100644 --- a/node_dump.c +++ b/node_dump.c @@ -27,6 +27,10 @@ #define A_INT(val) rb_str_catf(buf, "%d", (val)) #define A_LONG(val) rb_str_catf(buf, "%ld", (val)) #define A_LIT(lit) AR(rb_dump_literal(lit)) +#define A_LOC(loc) \ + rb_str_catf(buf, "(%d,%d)-(%d,%d)", \ + loc.beg_pos.lineno, loc.beg_pos.column, \ + loc.end_pos.lineno, loc.end_pos.column) #define A_NODE_HEADER(node, term) \ rb_str_catf(buf, "@ %s (id: %d, line: %d, location: (%d,%d)-(%d,%d))%s"term, \ ruby_node_name(nd_type(node)), nd_node_id(node), nd_line(node), \ @@ -84,6 +88,7 @@ #define F_LIT(name, type, ann) SIMPLE_FIELD1(#name, ann) A_LIT(type(node)->name) #define F_VALUE(name, val, ann) SIMPLE_FIELD1(#name, ann) A_LIT(val) #define F_MSG(name, ann, desc) SIMPLE_FIELD1(#name, ann) A(desc) +#define F_LOC(name, type) SIMPLE_FIELD1(#name, "") A_LOC(type(node)->name) #define F_SHAREABILITY(name, type, ann) SIMPLE_FIELD1(#name, ann) A_SHAREABILITY(type(node)->name) #define F_NODE(name, type, ann) \ @@ -92,6 +97,9 @@ #define F_NODE2(name, n, ann) \ COMPOUND_FIELD1(#name, ann) {dump_node(buf, indent, comment, n);} +#define F_ARRAY(name, type, ann) \ + COMPOUND_FIELD1(#name, ann) {dump_parser_array(buf, indent, comment, type(node)->name);} + #define ANN(ann) \ if (comment) { \ A_INDENT; A("| # " ann "\n"); \ @@ -165,6 +173,28 @@ dump_array(VALUE buf, VALUE indent, int comment, const NODE *node) } static void +dump_parser_array(VALUE buf, VALUE indent, int comment, const rb_parser_ary_t *ary) +{ + int field_flag; + const char *next_indent = default_indent; + + if (ary->data_type != PARSER_ARY_DATA_NODE) { + rb_bug("unexpected rb_parser_ary_data_type: %d", ary->data_type); + } + + F_CUSTOM1(length, "length") { A_LONG(ary->len); } + for (long i = 0; i < ary->len; i++) { + if (i == ary->len - 1) LAST_NODE; + A_INDENT; + rb_str_catf(buf, "+- element (%s%ld):\n", + comment ? "statement #" : "", i); + D_INDENT; + dump_node(buf, indent, comment, ary->data[i]); + D_DEDENT; + } +} + +static void dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) { int field_flag; @@ -209,8 +239,11 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("example: if x == 1 then foo else bar end"); F_NODE(nd_cond, RNODE_IF, "condition expr"); F_NODE(nd_body, RNODE_IF, "then clause"); - LAST_NODE; F_NODE(nd_else, RNODE_IF, "else clause"); + F_LOC(if_keyword_loc, RNODE_IF); + F_LOC(then_keyword_loc, RNODE_IF); + LAST_NODE; + F_LOC(end_keyword_loc, RNODE_IF); return; case NODE_UNLESS: @@ -219,8 +252,11 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("example: unless x == 1 then foo else bar end"); F_NODE(nd_cond, RNODE_UNLESS, "condition expr"); F_NODE(nd_body, RNODE_UNLESS, "then clause"); - LAST_NODE; F_NODE(nd_else, RNODE_UNLESS, "else clause"); + F_LOC(keyword_loc, RNODE_UNLESS); + F_LOC(then_keyword_loc, RNODE_UNLESS); + LAST_NODE; + F_LOC(end_keyword_loc, RNODE_UNLESS); return; case NODE_CASE: @@ -228,24 +264,30 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("format: case [nd_head]; [nd_body]; end"); ANN("example: case x; when 1; foo; when 2; bar; else baz; end"); F_NODE(nd_head, RNODE_CASE, "case expr"); - LAST_NODE; F_NODE(nd_body, RNODE_CASE, "when clauses"); + F_LOC(case_keyword_loc, RNODE_CASE); + LAST_NODE; + F_LOC(end_keyword_loc, RNODE_CASE); return; case NODE_CASE2: ANN("case statement with no head"); ANN("format: case; [nd_body]; end"); ANN("example: case; when 1; foo; when 2; bar; else baz; end"); F_NODE(nd_head, RNODE_CASE2, "case expr"); - LAST_NODE; F_NODE(nd_body, RNODE_CASE2, "when clauses"); + F_LOC(case_keyword_loc, RNODE_CASE2); + LAST_NODE; + F_LOC(end_keyword_loc, RNODE_CASE2); return; case NODE_CASE3: ANN("case statement (pattern matching)"); ANN("format: case [nd_head]; [nd_body]; end"); ANN("example: case x; in 1; foo; in 2; bar; else baz; end"); F_NODE(nd_head, RNODE_CASE3, "case expr"); - LAST_NODE; F_NODE(nd_body, RNODE_CASE3, "in clauses"); + F_LOC(case_keyword_loc, RNODE_CASE3); + LAST_NODE; + F_LOC(end_keyword_loc, RNODE_CASE3); return; case NODE_WHEN: @@ -256,6 +298,9 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) F_NODE(nd_body, RNODE_WHEN, "when body"); LAST_NODE; F_NODE(nd_next, RNODE_WHEN, "next when clause"); + F_LOC(keyword_loc, RNODE_WHEN); + LAST_NODE; + F_LOC(then_keyword_loc, RNODE_WHEN); return; case NODE_IN: @@ -264,8 +309,11 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("example: case x; in 1; foo; in 2; bar; else baz; end"); F_NODE(nd_head, RNODE_IN, "in pattern"); F_NODE(nd_body, RNODE_IN, "in body"); - LAST_NODE; F_NODE(nd_next, RNODE_IN, "next in clause"); + F_LOC(in_keyword_loc, RNODE_IN); + F_LOC(then_keyword_loc, RNODE_IN); + LAST_NODE; + F_LOC(operator_loc, RNODE_IN); return; case NODE_WHILE: @@ -283,23 +331,32 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) A((RNODE_WHILE(node)->nd_state == 1) ? " (while-end)" : " (begin-end-while)"); } F_NODE(nd_cond, RNODE_WHILE, "condition"); - LAST_NODE; F_NODE(nd_body, RNODE_WHILE, "body"); + F_LOC(keyword_loc, RNODE_WHILE); + LAST_NODE; + F_LOC(closing_loc, RNODE_WHILE); return; case NODE_ITER: ANN("method call with block"); ANN("format: [nd_iter] { [nd_body] }"); ANN("example: 3.times { foo }"); - goto iter; + F_NODE(nd_iter, RNODE_ITER, "iteration receiver"); + LAST_NODE; + F_NODE(nd_body, RNODE_ITER, "body"); + return; + case NODE_FOR: ANN("for statement"); ANN("format: for * in [nd_iter] do [nd_body] end"); ANN("example: for i in 1..3 do foo end"); - iter: - F_NODE(nd_iter, RNODE_ITER, "iteration receiver"); + F_NODE(nd_iter, RNODE_FOR, "iteration receiver"); + F_NODE(nd_body, RNODE_FOR, "body"); + F_LOC(for_keyword_loc, RNODE_FOR); + F_LOC(in_keyword_loc, RNODE_FOR); + F_LOC(do_keyword_loc, RNODE_FOR); LAST_NODE; - F_NODE(nd_body, RNODE_ITER, "body"); + F_LOC(end_keyword_loc, RNODE_FOR); return; case NODE_FOR_MASGN: @@ -314,28 +371,32 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("break statement"); ANN("format: break [nd_stts]"); ANN("example: break 1"); - LAST_NODE; F_NODE(nd_stts, RNODE_BREAK, "value"); + LAST_NODE; + F_LOC(keyword_loc, RNODE_BREAK); return; case NODE_NEXT: ANN("next statement"); ANN("format: next [nd_stts]"); ANN("example: next 1"); - LAST_NODE; F_NODE(nd_stts, RNODE_NEXT, "value"); + LAST_NODE; + F_LOC(keyword_loc, RNODE_NEXT); return; case NODE_RETURN: ANN("return statement"); ANN("format: return [nd_stts]"); ANN("example: return 1"); - LAST_NODE; F_NODE(nd_stts, RNODE_RETURN, "value"); + LAST_NODE; + F_LOC(keyword_loc, RNODE_RETURN); return; case NODE_REDO: ANN("redo statement"); ANN("format: redo"); ANN("example: redo"); + F_LOC(keyword_loc, RNODE_REDO); return; case NODE_RETRY: @@ -364,9 +425,10 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) case NODE_RESBODY: ANN("rescue clause (cont'd)"); - ANN("format: rescue [nd_args]; [nd_body]; (rescue) [nd_head]"); + ANN("format: rescue [nd_args] (=> [nd_exc_var]); [nd_body]; (rescue) [nd_next]"); ANN("example: begin; foo; rescue; bar; else; baz; end"); F_NODE(nd_args, RNODE_RESBODY, "rescue exceptions"); + F_NODE(nd_exc_var, RNODE_RESBODY, "exception variable"); F_NODE(nd_body, RNODE_RESBODY, "rescue clause"); LAST_NODE; F_NODE(nd_next, RNODE_RESBODY, "next rescue clause"); @@ -397,8 +459,9 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) break; node = RNODE_AND(node)->nd_2nd; } - LAST_NODE; F_NODE(nd_2nd, RNODE_AND, "right expr"); + LAST_NODE; + F_LOC(operator_loc, RNODE_AND); return; case NODE_MASGN: @@ -492,8 +555,12 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) F_NODE(nd_recv, RNODE_OP_ASGN1, "receiver"); F_ID(nd_mid, RNODE_OP_ASGN1, "operator"); F_NODE(nd_index, RNODE_OP_ASGN1, "index"); - LAST_NODE; F_NODE(nd_rvalue, RNODE_OP_ASGN1, "rvalue"); + F_LOC(call_operator_loc, RNODE_OP_ASGN1); + F_LOC(opening_loc, RNODE_OP_ASGN1); + F_LOC(closing_loc, RNODE_OP_ASGN1); + LAST_NODE; + F_LOC(binary_operator_loc, RNODE_OP_ASGN1); return; case NODE_OP_ASGN2: @@ -506,8 +573,11 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) A_ID(RNODE_OP_ASGN2(node)->nd_vid); } F_ID(nd_mid, RNODE_OP_ASGN2, "operator"); - LAST_NODE; F_NODE(nd_value, RNODE_OP_ASGN2, "rvalue"); + F_LOC(call_operator_loc, RNODE_OP_ASGN2); + F_LOC(message_loc, RNODE_OP_ASGN2); + LAST_NODE; + F_LOC(binary_operator_loc, RNODE_OP_ASGN2); return; case NODE_OP_ASGN_AND: @@ -586,8 +656,11 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("super invocation"); ANN("format: super [nd_args]"); ANN("example: super 1"); - LAST_NODE; F_NODE(nd_args, RNODE_SUPER, "arguments"); + F_LOC(keyword_loc, RNODE_SUPER); + F_LOC(lparen_loc, RNODE_SUPER); + LAST_NODE; + F_LOC(rparen_loc, RNODE_SUPER); return; case NODE_ZSUPER: @@ -634,8 +707,11 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("yield invocation"); ANN("format: yield [nd_head]"); ANN("example: yield 1"); - LAST_NODE; F_NODE(nd_head, RNODE_YIELD, "arguments"); + F_LOC(keyword_loc, RNODE_YIELD); + F_LOC(lparen_loc, RNODE_YIELD); + LAST_NODE; + F_LOC(rparen_loc, RNODE_YIELD); return; case NODE_LVAR: @@ -769,8 +845,11 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("regexp literal"); ANN("format: [string]"); ANN("example: /foo/"); - LAST_NODE; F_VALUE(string, rb_node_regx_string_val(node), "string"); + F_LOC(opening_loc, RNODE_REGX); + F_LOC(content_loc, RNODE_REGX); + LAST_NODE; + F_LOC(closing_loc, RNODE_REGX); return; case NODE_ONCE: @@ -819,8 +898,10 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("interpolation expression"); ANN("format: \"..#{ [nd_body] }..\""); ANN("example: \"foo#{ bar }baz\""); - LAST_NODE; F_NODE(nd_body, RNODE_EVSTR, "body"); + F_LOC(opening_loc, RNODE_EVSTR); + LAST_NODE; + F_LOC(closing_loc, RNODE_EVSTR); return; case NODE_ARGSCAT: @@ -845,17 +926,25 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("splat argument"); ANN("format: *[nd_head]"); ANN("example: foo(*ary)"); - LAST_NODE; F_NODE(nd_head, RNODE_SPLAT, "splat'ed array"); + LAST_NODE; + F_LOC(operator_loc, RNODE_SPLAT); return; case NODE_BLOCK_PASS: ANN("arguments with block argument"); ANN("format: ..([nd_head], &[nd_body])"); ANN("example: foo(x, &blk)"); + F_CUSTOM1(forwarding, "arguments forwarding or not") { + switch (RNODE_BLOCK_PASS(node)->forwarding) { + case 0: A("0 (no forwarding)"); break; + case 1: A("1 (forwarding)"); break; + } + } F_NODE(nd_head, RNODE_BLOCK_PASS, "other arguments"); - LAST_NODE; F_NODE(nd_body, RNODE_BLOCK_PASS, "block argument"); + LAST_NODE; + F_LOC(operator_loc, RNODE_BLOCK_PASS); return; case NODE_DEFN: @@ -882,8 +971,9 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("format: alias [nd_1st] [nd_2nd]"); ANN("example: alias bar foo"); F_NODE(nd_1st, RNODE_ALIAS, "new name"); - LAST_NODE; F_NODE(nd_2nd, RNODE_ALIAS, "old name"); + LAST_NODE; + F_LOC(keyword_loc, RNODE_ALIAS); return; case NODE_VALIAS: @@ -892,14 +982,16 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("example: alias $y $x"); F_ID(nd_alias, RNODE_VALIAS, "new name"); F_ID(nd_orig, RNODE_VALIAS, "old name"); + F_LOC(keyword_loc, RNODE_VALIAS); return; case NODE_UNDEF: ANN("method undef statement"); - ANN("format: undef [nd_undef]"); + ANN("format: undef [nd_undefs]"); ANN("example: undef foo"); LAST_NODE; - F_NODE(nd_undef, RNODE_UNDEF, "old name"); + F_ARRAY(nd_undefs, RNODE_UNDEF, "nd_undefs"); + F_LOC(keyword_loc, RNODE_UNDEF); return; case NODE_CLASS: @@ -908,8 +1000,11 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("example: class C2 < C; ..; end"); F_NODE(nd_cpath, RNODE_CLASS, "class path"); F_NODE(nd_super, RNODE_CLASS, "superclass"); - LAST_NODE; F_NODE(nd_body, RNODE_CLASS, "class definition"); + F_LOC(class_keyword_loc, RNODE_CLASS); + F_LOC(inheritance_operator_loc, RNODE_CLASS); + LAST_NODE; + F_LOC(end_keyword_loc, RNODE_CLASS); return; case NODE_MODULE: @@ -917,8 +1012,10 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("format: module [nd_cpath]; [nd_body]; end"); ANN("example: module M; ..; end"); F_NODE(nd_cpath, RNODE_MODULE, "module path"); - LAST_NODE; F_NODE(nd_body, RNODE_MODULE, "module definition"); + F_LOC(module_keyword_loc, RNODE_MODULE); + LAST_NODE; + F_LOC(end_keyword_loc, RNODE_MODULE); return; case NODE_SCLASS: @@ -926,8 +1023,11 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("format: class << [nd_recv]; [nd_body]; end"); ANN("example: class << obj; ..; end"); F_NODE(nd_recv, RNODE_SCLASS, "receiver"); - LAST_NODE; F_NODE(nd_body, RNODE_SCLASS, "singleton class definition"); + F_LOC(class_keyword_loc, RNODE_SCLASS); + F_LOC(operator_loc, RNODE_SCLASS); + LAST_NODE; + F_LOC(end_keyword_loc, RNODE_SCLASS); return; case NODE_COLON2: @@ -935,8 +1035,10 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("format: [nd_head]::[nd_mid]"); ANN("example: M::C"); F_ID(nd_mid, RNODE_COLON2, "constant name"); - LAST_NODE; F_NODE(nd_head, RNODE_COLON2, "receiver"); + F_LOC(delimiter_loc, RNODE_COLON2); + LAST_NODE; + F_LOC(name_loc, RNODE_COLON2); return; case NODE_COLON3: @@ -944,6 +1046,8 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("format: ::[nd_mid]"); ANN("example: ::Object"); F_ID(nd_mid, RNODE_COLON3, "constant name"); + F_LOC(delimiter_loc, RNODE_COLON3); + F_LOC(name_loc, RNODE_COLON3); return; case NODE_DOT2: @@ -967,8 +1071,9 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("example: if (x==1)...(x==5); foo; end"); dot: F_NODE(nd_beg, RNODE_DOT2, "begin"); - LAST_NODE; F_NODE(nd_end, RNODE_DOT2, "end"); + LAST_NODE; + F_LOC(operator_loc, RNODE_DOT2); return; case NODE_SELF: @@ -1009,14 +1114,19 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("format: defined?([nd_head])"); ANN("example: defined?(foo)"); F_NODE(nd_head, RNODE_DEFINED, "expr"); + LAST_NODE; + F_LOC(keyword_loc, RNODE_DEFINED); return; case NODE_POSTEXE: ANN("post-execution"); ANN("format: END { [nd_body] }"); ANN("example: END { foo }"); - LAST_NODE; F_NODE(nd_body, RNODE_POSTEXE, "END clause"); + F_LOC(keyword_loc, RNODE_POSTEXE); + F_LOC(opening_loc, RNODE_POSTEXE); + LAST_NODE; + F_LOC(closing_loc, RNODE_POSTEXE); return; case NODE_ATTRASGN: @@ -1033,8 +1143,11 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("lambda expression"); ANN("format: -> [nd_body]"); ANN("example: -> { foo }"); - LAST_NODE; F_NODE(nd_body, RNODE_LAMBDA, "lambda clause"); + F_LOC(operator_loc, RNODE_LAMBDA); + F_LOC(opening_loc, RNODE_LAMBDA); + LAST_NODE; + F_LOC(closing_loc, RNODE_LAMBDA); return; case NODE_OPT_ARG: @@ -1073,6 +1186,12 @@ dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) ANN("method parameters"); ANN("format: def method_name(.., [nd_ainfo.nd_optargs], *[nd_ainfo.rest_arg], [nd_ainfo.first_post_arg], .., [nd_ainfo.kw_args], **[nd_ainfo.kw_rest_arg], &[nd_ainfo.block_arg])"); ANN("example: def foo(a, b, opt1=1, opt2=2, *rest, y, z, kw: 1, **kwrest, &blk); end"); + F_CUSTOM1(nd_ainfo.forwarding, "arguments forwarding or not") { + switch (RNODE_ARGS(node)->nd_ainfo.forwarding) { + case 0: A("0 (no forwarding)"); break; + case 1: A("1 (forwarding)"); break; + } + } F_INT(nd_ainfo.pre_args_num, RNODE_ARGS, "count of mandatory (pre-)arguments"); F_NODE(nd_ainfo.pre_init, RNODE_ARGS, "initialization of (pre-)arguments"); F_INT(nd_ainfo.post_args_num, RNODE_ARGS, "count of mandatory post-arguments"); |