diff options
Diffstat (limited to 'node.c')
| -rw-r--r-- | node.c | 713 |
1 files changed, 481 insertions, 232 deletions
@@ -16,48 +16,60 @@ #define AR(str) rb_str_concat(buf, (str)) #define A_INDENT add_indent(buf, indent) +#define D_INDENT rb_str_cat2(indent, next_indent) +#define D_DEDENT rb_str_resize(indent, RSTRING_LEN(indent) - 4) #define A_ID(id) add_id(buf, (id)) -#define A_INT(val) rb_str_catf(buf, "%d", (val)); -#define A_LONG(val) rb_str_catf(buf, "%ld", (val)); +#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_inspect(lit)) -#define A_NODE_HEADER(node) \ - rb_str_catf(buf, "@ %s (line: %d)", ruby_node_name(nd_type(node)), nd_line(node)) -#define A_FIELD_HEADER(name) \ - rb_str_catf(buf, "+- %s:", (name)) - -#define D_NULL_NODE A_INDENT; A("(null node)"); A("\n"); -#define D_NODE_HEADER(node) A_INDENT; A_NODE_HEADER(node); A("\n"); - -#define COMPOUND_FIELD(name, name2, block) \ - do { \ - A_INDENT; A_FIELD_HEADER(comment ? (name2) : (name)); A("\n"); \ - rb_str_cat2(indent, next_indent); \ - block; \ - rb_str_resize(indent, RSTRING_LEN(indent) - 4); \ - } while (0) - -#define SIMPLE_FIELD(name, name2, block) \ - do { \ - A_INDENT; A_FIELD_HEADER(comment ? (name2) : (name)); A(" "); block; A("\n"); \ - } while (0) - -#define F_CUSTOM1(name, ann, block) SIMPLE_FIELD(#name, #name " (" ann ")", block) -#define F_ID(name, ann) SIMPLE_FIELD(#name, #name " (" ann ")", A_ID(node->name)) -#define F_GENTRY(name, ann) SIMPLE_FIELD(#name, #name " (" ann ")", A_ID((node->name)->id)) -#define F_INT(name, ann) SIMPLE_FIELD(#name, #name " (" ann ")", A_INT(node->name)) -#define F_LONG(name, ann) SIMPLE_FIELD(#name, #name " (" ann ")", A_LONG(node->name)) -#define F_LIT(name, ann) SIMPLE_FIELD(#name, #name " (" ann ")", A_LIT(node->name)) -#define F_MSG(name, ann, desc) SIMPLE_FIELD(#name, #name " (" ann ")", A(desc)) - -#define F_CUSTOM2(name, ann, block) \ - COMPOUND_FIELD(#name, #name " (" ann ")", block) +#define A_NODE_HEADER(node, term) \ + rb_str_catf(buf, "@ %s (line: %d, location: (%d,%d)-(%d,%d))%s"term, \ + ruby_node_name(nd_type(node)), nd_line(node), \ + nd_first_lineno(node), nd_first_column(node), \ + nd_last_lineno(node), nd_last_column(node), \ + (node->flags & NODE_FL_NEWLINE ? "*" : "")) +#define A_FIELD_HEADER(len, name, term) \ + rb_str_catf(buf, "+- %.*s:"term, (len), (name)) +#define D_FIELD_HEADER(len, name, term) (A_INDENT, A_FIELD_HEADER(len, name, term)) + +#define D_NULL_NODE (A_INDENT, A("(null node)\n")) +#define D_NODE_HEADER(node) (A_INDENT, A_NODE_HEADER(node, "\n")) + +#define COMPOUND_FIELD(len, name) \ + FIELD_BLOCK((D_FIELD_HEADER((len), (name), "\n"), D_INDENT), D_DEDENT) + +#define COMPOUND_FIELD1(name, ann) \ + COMPOUND_FIELD(FIELD_NAME_LEN(name, ann), \ + FIELD_NAME_DESC(name, ann)) + +#define FIELD_NAME_DESC(name, ann) name " (" ann ")" +#define FIELD_NAME_LEN(name, ann) (int)( \ + comment ? \ + rb_strlen_lit(FIELD_NAME_DESC(name, ann)) : \ + rb_strlen_lit(name)) +#define SIMPLE_FIELD(len, name) \ + FIELD_BLOCK(D_FIELD_HEADER((len), (name), " "), A("\n")) + +#define FIELD_BLOCK(init, reset) \ + for (init, field_flag = 1; \ + field_flag; /* should be optimized away */ \ + reset, field_flag = 0) + +#define SIMPLE_FIELD1(name, ann) SIMPLE_FIELD(FIELD_NAME_LEN(name, ann), FIELD_NAME_DESC(name, ann)) +#define F_CUSTOM1(name, ann) SIMPLE_FIELD1(#name, ann) +#define F_ID(name, ann) SIMPLE_FIELD1(#name, ann) A_ID(node->name) +#define F_GENTRY(name, ann) SIMPLE_FIELD1(#name, ann) A_ID((node->name)->id) +#define F_INT(name, ann) SIMPLE_FIELD1(#name, ann) A_INT(node->name) +#define F_LONG(name, ann) SIMPLE_FIELD1(#name, ann) A_LONG(node->name) +#define F_LIT(name, ann) SIMPLE_FIELD1(#name, ann) A_LIT(node->name) +#define F_MSG(name, ann, desc) SIMPLE_FIELD1(#name, ann) A(desc) #define F_NODE(name, ann) \ - COMPOUND_FIELD(#name, #name " (" ann ")", dump_node(buf, indent, comment, node->name)) + COMPOUND_FIELD1(#name, ann) {dump_node(buf, indent, comment, node->name);} #define ANN(ann) \ if (comment) { \ - A_INDENT; A("| # "); A(ann); A("\n"); \ + A_INDENT; A("| # " ann "\n"); \ } #define LAST_NODE (next_indent = " ") @@ -85,10 +97,36 @@ add_id(VALUE buf, ID id) } } +struct add_option_arg { + VALUE buf, indent; + st_index_t count; +}; + +static void dump_node(VALUE, VALUE, int, const NODE *); +static const char default_indent[] = "| "; + static void -dump_node(VALUE buf, VALUE indent, int comment, NODE *node) +dump_array(VALUE buf, VALUE indent, int comment, const NODE *node) { - const char *next_indent = "| "; + int field_flag; + const char *next_indent = default_indent; + F_LONG(nd_alen, "length"); + F_NODE(nd_head, "element"); + while (node->nd_next && nd_type(node->nd_next) == NODE_ARRAY) { + node = node->nd_next; + F_NODE(nd_head, "element"); + } + LAST_NODE; + F_NODE(nd_next, "next element"); +} + +static void +dump_node(VALUE buf, VALUE indent, int comment, const NODE * node) +{ + int field_flag; + int i; + const char *next_indent = default_indent; + enum node_type type; if (!node) { D_NULL_NODE; @@ -97,15 +135,29 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) D_NODE_HEADER(node); - switch (nd_type(node)) { + type = nd_type(node); + switch (type) { case NODE_BLOCK: ANN("statement sequence"); - ANN("format: [nd_head]; [nd_next]"); + ANN("format: [nd_head]; ...; [nd_next]"); ANN("example: foo; bar"); - F_NODE(nd_head, "current statement"); - LAST_NODE; - F_NODE(nd_next, "next block"); - break; + i = 0; + do { + A_INDENT; + rb_str_catf(buf, "+- nd_head (%s%d):\n", + comment ? "statement #" : "", ++i); + if (!node->nd_next) LAST_NODE; + D_INDENT; + dump_node(buf, indent, comment, node->nd_head); + D_DEDENT; + } while (node->nd_next && + nd_type(node->nd_next) == NODE_BLOCK && + (node = node->nd_next, 1)); + if (node->nd_next) { + LAST_NODE; + F_NODE(nd_next, "next block"); + } + return; case NODE_IF: ANN("if statement"); @@ -115,7 +167,17 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_body, "then clause"); LAST_NODE; F_NODE(nd_else, "else clause"); - break; + return; + + case NODE_UNLESS: + ANN("unless statement"); + ANN("format: unless [nd_cond] then [nd_body] else [nd_else] end"); + ANN("example: unless x == 1 then foo else bar end"); + F_NODE(nd_cond, "condition expr"); + F_NODE(nd_body, "then clause"); + LAST_NODE; + F_NODE(nd_else, "else clause"); + return; case NODE_CASE: ANN("case statement"); @@ -124,23 +186,26 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_head, "case expr"); LAST_NODE; F_NODE(nd_body, "when clauses"); - break; + 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, "case expr"); + LAST_NODE; + F_NODE(nd_body, "when clauses"); + return; case NODE_WHEN: - ANN("if statement"); + ANN("when clause"); ANN("format: when [nd_head]; [nd_body]; (when or else) [nd_next]"); ANN("example: case x; when 1; foo; when 2; bar; else baz; end"); F_NODE(nd_head, "when value"); - F_NODE(nd_body, "when clause"); + F_NODE(nd_body, "when body"); LAST_NODE; F_NODE(nd_next, "next when clause"); - break; + return; - case NODE_OPT_N: - ANN("wrapper for -n option"); - ANN("format: ruby -ne '[nd_body]' (nd_cond is `gets')"); - ANN("example: ruby -ne 'p $_'"); - goto loop; case NODE_WHILE: ANN("while statement"); ANN("format: while [nd_cond]; [nd_body]; end"); @@ -151,14 +216,14 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("format: until [nd_cond]; [nd_body]; end"); ANN("example: until x == 1; foo; end"); loop: - F_CUSTOM1(nd_state, "begin-end-while?", { - A_INT((int)node->nd_state); - A((node->nd_state == 1) ? " (while-end)" : " (begin-end-while)"); - }); + F_CUSTOM1(nd_state, "begin-end-while?") { + A_INT((int)node->nd_state); + A((node->nd_state == 1) ? " (while-end)" : " (begin-end-while)"); + } F_NODE(nd_cond, "condition"); LAST_NODE; F_NODE(nd_body, "body"); - break; + return; case NODE_ITER: ANN("method call with block"); @@ -169,14 +234,22 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("for statement"); ANN("format: for * in [nd_iter] do [nd_body] end"); ANN("example: for i in 1..3 do foo end"); - iter: + iter: F_NODE(nd_iter, "iteration receiver"); LAST_NODE; F_NODE(nd_body, "body"); - break; + return; + + case NODE_FOR_MASGN: + ANN("vars of for statement with masgn"); + ANN("format: for [nd_var] in ... do ... end"); + ANN("example: for x, y in 1..3 do foo end"); + LAST_NODE; + F_NODE(nd_var, "var"); + return; case NODE_BREAK: - ANN("for statement"); + ANN("break statement"); ANN("format: break [nd_stts]"); ANN("example: break 1"); goto jump; @@ -189,22 +262,22 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("return statement"); ANN("format: return [nd_stts]"); ANN("example: return 1"); - jump: + jump: LAST_NODE; F_NODE(nd_stts, "value"); - break; + return; case NODE_REDO: ANN("redo statement"); ANN("format: redo"); ANN("example: redo"); - break; + return; case NODE_RETRY: ANN("retry statement"); ANN("format: retry"); ANN("example: retry"); - break; + return; case NODE_BEGIN: ANN("begin statement"); @@ -212,7 +285,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("example: begin; 1; end"); LAST_NODE; F_NODE(nd_body, "body"); - break; + return; case NODE_RESCUE: ANN("rescue clause"); @@ -222,7 +295,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_resq, "rescue clause list"); LAST_NODE; F_NODE(nd_else, "rescue else clause"); - break; + return; case NODE_RESBODY: ANN("rescue clause (cont'd)"); @@ -232,7 +305,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_body, "rescue clause"); LAST_NODE; F_NODE(nd_head, "next rescue clause"); - break; + return; case NODE_ENSURE: ANN("ensure clause"); @@ -241,7 +314,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_head, "body"); LAST_NODE; F_NODE(nd_ensr, "ensure clause"); - break; + return; case NODE_AND: ANN("&& operator"); @@ -251,12 +324,17 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) case NODE_OR: ANN("|| operator"); ANN("format: [nd_1st] || [nd_2nd]"); - ANN("example: foo && bar"); - andor: - F_NODE(nd_1st, "left expr"); + ANN("example: foo || bar"); + andor: + while (1) { + F_NODE(nd_1st, "left expr"); + if (!node->nd_2nd || nd_type(node->nd_2nd) != (int)type) + break; + node = node->nd_2nd; + } LAST_NODE; F_NODE(nd_2nd, "right expr"); - break; + return; case NODE_MASGN: ANN("multiple assignment"); @@ -264,45 +342,65 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("example: a, b = foo"); F_NODE(nd_value, "rhsn"); F_NODE(nd_head, "lhsn"); - if ((VALUE)node->nd_args != (VALUE)-1) { + if (NODE_NAMED_REST_P(node->nd_args)) { LAST_NODE; F_NODE(nd_args, "splatn"); } else { - F_MSG(nd_args, "splatn", "-1 (rest argument without name)"); + F_MSG(nd_args, "splatn", "NODE_SPECIAL_NO_NAME_REST (rest argument without name)"); } - break; + return; case NODE_LASGN: ANN("local variable assignment"); ANN("format: [nd_vid](lvar) = [nd_value]"); ANN("example: x = foo"); - goto asgn; + F_ID(nd_vid, "local variable"); + if (NODE_REQUIRED_KEYWORD_P(node)) { + F_MSG(nd_value, "rvalue", "NODE_SPECIAL_REQUIRED_KEYWORD (required keyword argument)"); + } + else { + LAST_NODE; + F_NODE(nd_value, "rvalue"); + } + return; case NODE_DASGN: ANN("dynamic variable assignment (out of current scope)"); ANN("format: [nd_vid](dvar) = [nd_value]"); ANN("example: x = nil; 1.times { x = foo }"); - goto asgn; + F_ID(nd_vid, "local variable"); + LAST_NODE; + F_NODE(nd_value, "rvalue"); + return; case NODE_DASGN_CURR: ANN("dynamic variable assignment (in current scope)"); ANN("format: [nd_vid](current dvar) = [nd_value]"); ANN("example: 1.times { x = foo }"); - goto asgn; + F_ID(nd_vid, "local variable"); + if (NODE_REQUIRED_KEYWORD_P(node)) { + F_MSG(nd_value, "rvalue", "NODE_SPECIAL_REQUIRED_KEYWORD (required keyword argument)"); + } + else { + LAST_NODE; + F_NODE(nd_value, "rvalue"); + } + return; case NODE_IASGN: ANN("instance variable assignment"); ANN("format: [nd_vid](ivar) = [nd_value]"); ANN("example: @x = foo"); - goto asgn; + F_ID(nd_vid, "instance variable"); + LAST_NODE; + F_NODE(nd_value, "rvalue"); + return; case NODE_CVASGN: ANN("class variable assignment"); ANN("format: [nd_vid](cvar) = [nd_value]"); ANN("example: @@x = foo"); - asgn: - F_ID(nd_vid, "variable"); + F_ID(nd_vid, "class variable"); LAST_NODE; F_NODE(nd_value, "rvalue"); - break; - + return; case NODE_GASGN: ANN("global variable assignment"); ANN("format: [nd_entry](gvar) = [nd_value]"); @@ -310,54 +408,49 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_GENTRY(nd_entry, "global variable"); LAST_NODE; F_NODE(nd_value, "rvalue"); - break; + return; case NODE_CDECL: ANN("constant declaration"); ANN("format: [nd_else]::[nd_vid](constant) = [nd_value]"); ANN("example: X = foo"); if (node->nd_vid) { - F_ID(nd_vid, "variable"); - F_MSG(nd_else, "extension", "not used"); + F_ID(nd_vid, "constant"); + F_MSG(nd_else, "extension", "not used"); } else { - F_MSG(nd_vid, "variable", "0 (see extension field)"); - F_NODE(nd_else, "extension"); + F_MSG(nd_vid, "constant", "0 (see extension field)"); + F_NODE(nd_else, "extension"); } LAST_NODE; F_NODE(nd_value, "rvalue"); - break; + return; case NODE_OP_ASGN1: ANN("array assignment with operator"); - ANN("format: [nd_value] [ [nd_args->nd_body] ] [nd_vid]= [nd_args->nd_head]"); + ANN("format: [nd_recv] [ [nd_args->nd_head] ] [nd_mid]= [nd_args->nd_body]"); ANN("example: ary[1] += foo"); F_NODE(nd_recv, "receiver"); - F_ID(nd_vid, "operator"); - F_NODE(nd_args->nd_body, "index"); + F_ID(nd_mid, "operator"); + F_NODE(nd_args->nd_head, "index"); LAST_NODE; - F_NODE(nd_args->nd_head, "rvalue"); - break; + F_NODE(nd_args->nd_body, "rvalue"); + return; case NODE_OP_ASGN2: ANN("attr assignment with operator"); - ANN("format: [nd_value].[attr] [nd_next->nd_mid]= [nd_value]"); - ANN(" where [attr] reader: [nd_next->nd_vid]"); - ANN(" [attr] writer: [nd_next->nd_aid]"); + ANN("format: [nd_recv].[attr] [nd_next->nd_mid]= [nd_value]"); + ANN(" where [attr]: [nd_next->nd_vid]"); ANN("example: struct.field += foo"); F_NODE(nd_recv, "receiver"); - F_ID(nd_next->nd_vid, "reader"); - F_ID(nd_next->nd_aid, "writer"); - F_CUSTOM1(nd_next->nd_mid, "operator", { - switch (node->nd_next->nd_mid) { - case 0: A("0 (||)"); break; - case 1: A("1 (&&)"); break; - default: A_ID(node->nd_next->nd_mid); - } - }); + F_CUSTOM1(nd_next->nd_vid, "attr") { + if (node->nd_next->nd_aid) A("? "); + A_ID(node->nd_next->nd_vid); + } + F_ID(nd_next->nd_mid, "operator"); LAST_NODE; F_NODE(nd_value, "rvalue"); - break; + return; case NODE_OP_ASGN_AND: ANN("assignment with && operator"); @@ -368,11 +461,21 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("assignment with || operator"); ANN("format: [nd_head] ||= [nd_value]"); ANN("example: foo ||= bar"); - asgn_andor: + asgn_andor: F_NODE(nd_head, "variable"); LAST_NODE; F_NODE(nd_value, "rvalue"); - break; + return; + + case NODE_OP_CDECL: + ANN("constant declaration with operator"); + ANN("format: [nd_head](constant) [nd_aid]= [nd_value]"); + ANN("example: A::B ||= 1"); + F_NODE(nd_head, "constant"); + F_ID(nd_aid, "operator"); + LAST_NODE; + F_NODE(nd_value, "rvalue"); + return; case NODE_CALL: ANN("method invocation"); @@ -382,7 +485,17 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_recv, "receiver"); LAST_NODE; F_NODE(nd_args, "arguments"); - break; + return; + + case NODE_OPCALL: + ANN("method invocation"); + ANN("format: [nd_recv] [nd_mid] [nd_args]"); + ANN("example: foo + bar"); + F_ID(nd_mid, "method id"); + F_NODE(nd_recv, "receiver"); + LAST_NODE; + F_NODE(nd_args, "arguments"); + return; case NODE_FCALL: ANN("function call"); @@ -391,14 +504,24 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_ID(nd_mid, "method id"); LAST_NODE; F_NODE(nd_args, "arguments"); - break; + return; case NODE_VCALL: ANN("function call with no argument"); ANN("format: [nd_mid]"); ANN("example: foo"); F_ID(nd_mid, "method id"); - break; + return; + + case NODE_QCALL: + ANN("safe method invocation"); + ANN("format: [nd_recv]&.[nd_mid]([nd_args])"); + ANN("example: obj&.foo(1)"); + F_ID(nd_mid, "method id"); + F_NODE(nd_recv, "receiver"); + LAST_NODE; + F_NODE(nd_args, "arguments"); + return; case NODE_SUPER: ANN("super invocation"); @@ -406,13 +529,13 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("example: super 1"); LAST_NODE; F_NODE(nd_args, "arguments"); - break; + return; case NODE_ZSUPER: ANN("super invocation with no argument"); ANN("format: super"); ANN("example: super"); - break; + return; case NODE_ARRAY: ANN("array constructor"); @@ -423,26 +546,36 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("return arguments"); ANN("format: [ [nd_head], [nd_next].. ] (length: [nd_alen])"); ANN("example: return 1, 2, 3"); - ary: - F_LONG(nd_alen, "length"); - F_NODE(nd_head, "element"); - LAST_NODE; - F_NODE(nd_next, "next element"); - break; + ary: + dump_array(buf, indent, comment, node); + return; case NODE_ZARRAY: ANN("empty array constructor"); ANN("format: []"); ANN("example: []"); - break; + return; case NODE_HASH: - ANN("hash constructor"); - ANN("format: { [nd_head] }"); - ANN("example: { 1 => 2, 3 => 4 }"); + if (!node->nd_alen) { + ANN("keyword arguments"); + ANN("format: nd_head"); + ANN("example: a: 1, b: 2"); + } + else { + ANN("hash constructor"); + ANN("format: { [nd_head] }"); + ANN("example: { 1 => 2, 3 => 4 }"); + } + F_CUSTOM1(nd_alen, "keyword arguments or hash literal") { + switch (node->nd_alen) { + case 0: A("0 (keyword argument)"); break; + case 1: A("1 (hash literal)"); break; + } + } LAST_NODE; F_NODE(nd_head, "contents"); - break; + return; case NODE_YIELD: ANN("yield invocation"); @@ -450,78 +583,85 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("example: yield 1"); LAST_NODE; F_NODE(nd_head, "arguments"); - break; + return; case NODE_LVAR: ANN("local variable reference"); ANN("format: [nd_vid](lvar)"); ANN("example: x"); - goto var; + F_ID(nd_vid, "local variable"); + return; case NODE_DVAR: ANN("dynamic variable reference"); ANN("format: [nd_vid](dvar)"); ANN("example: 1.times { x = 1; x }"); - goto var; + F_ID(nd_vid, "local variable"); + return; case NODE_IVAR: ANN("instance variable reference"); ANN("format: [nd_vid](ivar)"); ANN("example: @x"); - goto var; + F_ID(nd_vid, "instance variable"); + return; case NODE_CONST: ANN("constant reference"); ANN("format: [nd_vid](constant)"); ANN("example: X"); - goto var; + F_ID(nd_vid, "constant"); + return; case NODE_CVAR: ANN("class variable reference"); ANN("format: [nd_vid](cvar)"); ANN("example: @@x"); - var: - F_ID(nd_vid, "local variable"); - break; + F_ID(nd_vid, "class variable"); + return; case NODE_GVAR: ANN("global variable reference"); ANN("format: [nd_entry](gvar)"); ANN("example: $x"); F_GENTRY(nd_entry, "global variable"); - break; + return; case NODE_NTH_REF: ANN("nth special variable reference"); ANN("format: $[nd_nth]"); ANN("example: $1, $2, .."); - F_CUSTOM1(nd_nth, "variable", { A("$"); A_LONG(node->nd_nth); }); - break; + F_CUSTOM1(nd_nth, "variable") { A("$"); A_LONG(node->nd_nth); } + return; case NODE_BACK_REF: ANN("back special variable reference"); ANN("format: $[nd_nth]"); ANN("example: $&, $`, $', $+"); - F_CUSTOM1(nd_nth, "variable", { - char name[3]; - name[0] = '$'; - name[1] = (char)node->nd_nth; - name[2] = '\0'; - A(name); - }); - break; + F_CUSTOM1(nd_nth, "variable") { + char name[3]; + name[0] = '$'; + name[1] = (char)node->nd_nth; + name[2] = '\0'; + A(name); + } + return; case NODE_MATCH: ANN("match expression (against $_ implicitly)"); ANN("format: [nd_lit] (in condition)"); ANN("example: if /foo/; foo; end"); F_LIT(nd_lit, "regexp"); - break; + return; case NODE_MATCH2: ANN("match expression (regexp first)"); ANN("format: [nd_recv] =~ [nd_value]"); ANN("example: /foo/ =~ 'foo'"); F_NODE(nd_recv, "regexp (receiver)"); - LAST_NODE; + if (!node->nd_args) LAST_NODE; F_NODE(nd_value, "string (argument)"); - break; + if (node->nd_args) { + LAST_NODE; + F_NODE(nd_args, "named captures"); + } + return; case NODE_MATCH3: ANN("match expression (regexp second)"); @@ -530,7 +670,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_recv, "string (receiver)"); LAST_NODE; F_NODE(nd_value, "regexp (argument)"); - break; + return; case NODE_LIT: ANN("literal"); @@ -546,10 +686,17 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("xstring literal"); ANN("format: [nd_lit]"); ANN("example: `foo`"); - lit: + lit: F_LIT(nd_lit, "literal"); - break; + return; + case NODE_ONCE: + ANN("once evaluation"); + ANN("format: [nd_body]"); + ANN("example: /foo#{ bar }baz/o"); + LAST_NODE; + F_NODE(nd_body, "body"); + return; case NODE_DSTR: ANN("string literal with interpolation"); ANN("format: [nd_lit]"); @@ -565,21 +712,16 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("format: [nd_lit]"); ANN("example: /foo#{ bar }baz/"); goto dlit; - case NODE_DREGX_ONCE: - ANN("regexp literal with interpolation and once flag"); - ANN("format: [nd_lit]"); - ANN("example: /foo#{ bar }baz/o"); - goto dlit; case NODE_DSYM: ANN("symbol literal with interpolation"); ANN("format: [nd_lit]"); ANN("example: :\"foo#{ bar }baz\""); - dlit: - F_LIT(nd_lit, "literal"); - F_NODE(nd_next->nd_head, "preceding string"); + dlit: + F_LIT(nd_lit, "preceding string"); + F_NODE(nd_next->nd_head, "interpolation"); LAST_NODE; - F_NODE(nd_next->nd_next, "interpolation"); - break; + F_NODE(nd_next->nd_next, "tailing strings"); + return; case NODE_EVSTR: ANN("interpolation expression"); @@ -587,7 +729,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("example: \"foo#{ bar }baz\""); LAST_NODE; F_NODE(nd_body, "body"); - break; + return; case NODE_ARGSCAT: ANN("splat argument following arguments"); @@ -596,7 +738,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_head, "preceding array"); LAST_NODE; F_NODE(nd_body, "following array"); - break; + return; case NODE_ARGSPUSH: ANN("splat argument following one argument"); @@ -605,7 +747,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_head, "preceding array"); LAST_NODE; F_NODE(nd_body, "following element"); - break; + return; case NODE_SPLAT: ANN("splat argument"); @@ -613,7 +755,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("example: foo(*ary)"); LAST_NODE; F_NODE(nd_head, "splat'ed array"); - break; + return; case NODE_BLOCK_PASS: ANN("arguments with block argument"); @@ -622,51 +764,51 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_head, "other arguments"); LAST_NODE; F_NODE(nd_body, "block argument"); - break; + return; case NODE_DEFN: ANN("method definition"); ANN("format: def [nd_mid] [nd_defn]; end"); - ANN("example; def foo; bar; end"); + ANN("example: def foo; bar; end"); F_ID(nd_mid, "method name"); LAST_NODE; F_NODE(nd_defn, "method definition"); - break; + return; case NODE_DEFS: ANN("singleton method definition"); ANN("format: def [nd_recv].[nd_mid] [nd_defn]; end"); - ANN("example; def obj.foo; bar; end"); + ANN("example: def obj.foo; bar; end"); F_NODE(nd_recv, "receiver"); F_ID(nd_mid, "method name"); LAST_NODE; F_NODE(nd_defn, "method definition"); - break; + return; case NODE_ALIAS: ANN("method alias statement"); - ANN("format: alias [u1.node] [u2.node]"); + ANN("format: alias [nd_1st] [nd_2nd]"); ANN("example: alias bar foo"); - F_NODE(u1.node, "new name"); + F_NODE(nd_1st, "new name"); LAST_NODE; - F_NODE(u2.node, "old name"); - break; + F_NODE(nd_2nd, "old name"); + return; case NODE_VALIAS: ANN("global variable alias statement"); - ANN("format: alias [u1.id](gvar) [u2.id](gvar)"); + ANN("format: alias [nd_alias](gvar) [nd_orig](gvar)"); ANN("example: alias $y $x"); - F_ID(u1.id, "new name"); - F_ID(u2.id, "old name"); - break; + F_ID(nd_alias, "new name"); + F_ID(nd_orig, "old name"); + return; case NODE_UNDEF: - ANN("method alias statement"); - ANN("format: undef [u2.node]"); + ANN("method undef statement"); + ANN("format: undef [nd_undef]"); ANN("example: undef foo"); LAST_NODE; - F_NODE(u2.node, "old name"); - break; + F_NODE(nd_undef, "old name"); + return; case NODE_CLASS: ANN("class definition"); @@ -676,7 +818,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_super, "superclass"); LAST_NODE; F_NODE(nd_body, "class definition"); - break; + return; case NODE_MODULE: ANN("module definition"); @@ -685,7 +827,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_cpath, "module path"); LAST_NODE; F_NODE(nd_body, "module definition"); - break; + return; case NODE_SCLASS: ANN("singleton class definition"); @@ -694,7 +836,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_recv, "receiver"); LAST_NODE; F_NODE(nd_body, "singleton class definition"); - break; + return; case NODE_COLON2: ANN("scoped constant reference"); @@ -703,14 +845,14 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_ID(nd_mid, "constant name"); LAST_NODE; F_NODE(nd_head, "receiver"); - break; + return; case NODE_COLON3: ANN("top-level constant reference"); ANN("format: ::[nd_mid]"); ANN("example: ::Object"); F_ID(nd_mid, "constant name"); - break; + return; case NODE_DOT2: ANN("range constructor (incl.)"); @@ -731,48 +873,48 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("flip-flop condition (excl.)"); ANN("format: [nd_beg]...[nd_end]"); ANN("example: if (x==1)...(x==5); foo; end"); - dot: + dot: F_NODE(nd_beg, "begin"); LAST_NODE; F_NODE(nd_end, "end"); - break; + return; case NODE_SELF: ANN("self"); ANN("format: self"); ANN("example: self"); - break; + return; case NODE_NIL: ANN("nil"); ANN("format: nil"); ANN("example: nil"); - break; + return; case NODE_TRUE: ANN("true"); ANN("format: true"); ANN("example: true"); - break; + return; case NODE_FALSE: ANN("false"); ANN("format: false"); ANN("example: false"); - break; + return; case NODE_ERRINFO: ANN("virtual reference to $!"); ANN("format: rescue => id"); ANN("example: rescue => id"); - break; + return; case NODE_DEFINED: ANN("defined? expression"); ANN("format: defined?([nd_head])"); ANN("example: defined?(foo)"); F_NODE(nd_head, "expr"); - break; + return; case NODE_POSTEXE: ANN("post-execution"); @@ -780,31 +922,17 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("example: END { foo }"); LAST_NODE; F_NODE(nd_body, "END clause"); - break; + return; case NODE_ATTRASGN: ANN("attr assignment"); ANN("format: [nd_recv].[nd_mid] = [nd_args]"); ANN("example: struct.field = foo"); - if (node->nd_recv == (NODE *) 1) { - F_MSG(nd_recv, "receiver", "1 (self)"); - } - else { - F_NODE(nd_recv, "receiver"); - } + F_NODE(nd_recv, "receiver"); F_ID(nd_mid, "method name"); LAST_NODE; F_NODE(nd_args, "arguments"); - break; - - case NODE_PRELUDE: - ANN("pre-execution"); - ANN("format: BEGIN { [nd_head] }; [nd_body]"); - ANN("example: bar; BEGIN { foo }"); - F_NODE(nd_head, "prelude"); - LAST_NODE; - F_NODE(nd_body, "body"); - break; + return; case NODE_LAMBDA: ANN("lambda expression"); @@ -812,7 +940,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) ANN("example: -> { foo }"); LAST_NODE; F_NODE(nd_body, "lambda clause"); - break; + return; case NODE_OPT_ARG: ANN("optional arguments"); @@ -821,7 +949,7 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_body, "body"); LAST_NODE; F_NODE(nd_next, "next"); - break; + return; case NODE_KW_ARG: ANN("keyword arguments"); @@ -830,21 +958,21 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_NODE(nd_body, "body"); LAST_NODE; F_NODE(nd_next, "next"); - break; + return; case NODE_POSTARG: ANN("post arguments"); ANN("format: *[nd_1st], [nd_2nd..] = .."); ANN("example: a, *rest, z = foo"); - if ((VALUE)node->nd_1st != (VALUE)-1) { + if (NODE_NAMED_REST_P(node->nd_1st)) { F_NODE(nd_1st, "rest argument"); } else { - F_MSG(nd_1st, "rest argument", "-1 (rest argument without name)"); + F_MSG(nd_1st, "rest argument", "NODE_SPECIAL_NO_NAME_REST (rest argument without name)"); } LAST_NODE; F_NODE(nd_2nd, "post arguments"); - break; + return; case NODE_ARGS: ANN("method parameters"); @@ -858,35 +986,38 @@ dump_node(VALUE buf, VALUE indent, int comment, NODE *node) F_ID(nd_ainfo->rest_arg, "rest argument"); F_ID(nd_ainfo->block_arg, "block argument"); F_NODE(nd_ainfo->opt_args, "optional arguments"); - LAST_NODE; F_NODE(nd_ainfo->kw_args, "keyword arguments"); + LAST_NODE; F_NODE(nd_ainfo->kw_rest_arg, "keyword rest argument"); - break; + return; case NODE_SCOPE: ANN("new scope"); ANN("format: [nd_tbl]: local table, [nd_args]: arguments, [nd_body]: body"); - F_CUSTOM1(nd_tbl, "local table", { - ID *tbl = node->nd_tbl; - int i; - int size = tbl ? (int)*tbl++ : 0; - if (size == 0) A("(empty)"); - for (i = 0; i < size; i++) { + F_CUSTOM1(nd_tbl, "local table") { + ID *tbl = node->nd_tbl; + int i; + int size = tbl ? (int)*tbl++ : 0; + if (size == 0) A("(empty)"); + for (i = 0; i < size; i++) { A_ID(tbl[i]); if (i < size - 1) A(","); - } - }); + } + } F_NODE(nd_args, "arguments"); LAST_NODE; F_NODE(nd_body, "body"); - break; + return; - default: - rb_bug("dump_node: unknown node: %s", ruby_node_name(nd_type(node))); + case NODE_ARGS_AUX: + case NODE_LAST: + break; } + + rb_bug("dump_node: unknown node: %s", ruby_node_name(nd_type(node))); } VALUE -rb_parser_dump_tree(NODE *node, int comment) +rb_parser_dump_tree(const NODE *node, int comment) { VALUE buf = rb_str_new_cstr( "###########################################################\n" @@ -897,3 +1028,121 @@ rb_parser_dump_tree(NODE *node, int comment) dump_node(buf, rb_str_new_cstr("# "), comment, node); return buf; } + +/* Setup NODE structure. + * NODE is not an object managed by GC, but it imitates an object + * so that it can work with `RB_TYPE_P(obj, T_NODE)`. + * This dirty hack is needed because Ripper jumbles NODEs and other type + * objects. + */ +void +rb_node_init(NODE *n, enum node_type type, VALUE a0, VALUE a1, VALUE a2) +{ + n->flags = T_NODE; + nd_set_type(n, type); + n->u1.value = a0; + n->u2.value = a1; + n->u3.value = a2; + n->nd_loc.beg_pos.lineno = 0; + n->nd_loc.beg_pos.column = 0; + n->nd_loc.end_pos.lineno = 0; + n->nd_loc.end_pos.column = 0; +} + +typedef struct node_buffer_elem_struct { + struct node_buffer_elem_struct *next; + NODE buf[FLEX_ARY_LEN]; +} node_buffer_elem_t; + +struct node_buffer_struct { + long idx, len; + node_buffer_elem_t *head; + node_buffer_elem_t *last; + VALUE mark_ary; +}; + +static node_buffer_t * +rb_node_buffer_new(void) +{ + node_buffer_t *nb = xmalloc(sizeof(node_buffer_t) + offsetof(node_buffer_elem_t, buf) + 16 * sizeof(NODE)); + nb->idx = 0; + nb->len = 16; + nb->head = nb->last = (node_buffer_elem_t*) &nb[1]; + nb->head->next = NULL; + nb->mark_ary = rb_ary_tmp_new(0); + return nb; +} + +static void +rb_node_buffer_free(node_buffer_t *nb) +{ + node_buffer_elem_t *nbe = nb->head; + + while (nbe != nb->last) { + void *buf = nbe; + nbe = nbe->next; + xfree(buf); + } + xfree(nb); +} + +NODE * +rb_ast_newnode(rb_ast_t *ast) +{ + node_buffer_t *nb = ast->node_buffer; + if (nb->idx >= nb->len) { + long n = nb->len * 2; + node_buffer_elem_t *nbe; + nbe = xmalloc(offsetof(node_buffer_elem_t, buf) + n * sizeof(NODE)); + nb->idx = 0; + nb->len = n; + nbe->next = nb->head; + nb->head = nbe; + } + return &nb->head->buf[nb->idx++]; +} + +void +rb_ast_delete_node(rb_ast_t *ast, NODE *n) +{ + (void)ast; + (void)n; + /* should we implement freelist? */ +} + +rb_ast_t * +rb_ast_new(void) +{ + node_buffer_t *nb = rb_node_buffer_new(); + VALUE mark_ary = nb->mark_ary; + rb_ast_t *ast = (rb_ast_t *)rb_imemo_new(imemo_ast, 0, 0, 0, (VALUE)nb); + RB_OBJ_WRITTEN(ast, Qnil, mark_ary); + return ast; +} + +void +rb_ast_mark(rb_ast_t *ast) +{ + if (ast->node_buffer) rb_gc_mark(ast->node_buffer->mark_ary); +} + +void +rb_ast_free(rb_ast_t *ast) +{ + if (ast->node_buffer) { + rb_node_buffer_free(ast->node_buffer); + ast->node_buffer = 0; + } +} + +void +rb_ast_dispose(rb_ast_t *ast) +{ + rb_ast_free(ast); +} + +void +rb_ast_add_mark_object(rb_ast_t *ast, VALUE obj) +{ + rb_ary_push(ast->node_buffer->mark_ary, obj); +} |