00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #include "ruby/ruby.h"
00013 #include "vm_core.h"
00014
00015 #define A(str) rb_str_cat2(buf, (str))
00016 #define AR(str) rb_str_concat(buf, (str))
00017
00018 #define A_INDENT add_indent(buf, indent)
00019 #define A_ID(id) add_id(buf, id)
00020 #define A_INT(val) rb_str_catf(buf, "%d", (val));
00021 #define A_LONG(val) rb_str_catf(buf, "%ld", (val));
00022 #define A_LIT(lit) AR(rb_inspect(lit))
00023 #define A_NODE_HEADER(node) \
00024 rb_str_catf(buf, "@ %s (line: %d)", ruby_node_name(nd_type(node)), nd_line(node))
00025 #define A_FIELD_HEADER(name) \
00026 rb_str_catf(buf, "+- %s:", name)
00027
00028 #define D_NULL_NODE A_INDENT; A("(null node)"); A("\n");
00029 #define D_NODE_HEADER(node) A_INDENT; A_NODE_HEADER(node); A("\n");
00030
00031 #define COMPOUND_FIELD(name, name2, block) \
00032 do { \
00033 A_INDENT; A_FIELD_HEADER(comment ? name2 : name); A("\n"); \
00034 rb_str_cat2(indent, next_indent); \
00035 block; \
00036 rb_str_resize(indent, RSTRING_LEN(indent) - 4); \
00037 } while (0)
00038
00039 #define SIMPLE_FIELD(name, name2, block) \
00040 do { \
00041 A_INDENT; A_FIELD_HEADER(comment ? name2 : name); A(" "); block; A("\n"); \
00042 } while (0)
00043
00044 #define F_CUSTOM1(name, ann, block) SIMPLE_FIELD(#name, #name " (" ann ")", block)
00045 #define F_ID(name, ann) SIMPLE_FIELD(#name, #name " (" ann ")", A_ID(node->name))
00046 #define F_GENTRY(name, ann) SIMPLE_FIELD(#name, #name " (" ann ")", A_ID((node->name)->id))
00047 #define F_INT(name, ann) SIMPLE_FIELD(#name, #name " (" ann ")", A_INT(node->name))
00048 #define F_LONG(name, ann) SIMPLE_FIELD(#name, #name " (" ann ")", A_LONG(node->name))
00049 #define F_LIT(name, ann) SIMPLE_FIELD(#name, #name " (" ann ")", A_LIT(node->name))
00050 #define F_MSG(name, ann, desc) SIMPLE_FIELD(#name, #name " (" ann ")", A(desc))
00051
00052 #define F_CUSTOM2(name, ann, block) \
00053 COMPOUND_FIELD(#name, #name " (" ann ")", block)
00054
00055 #define F_NODE(name, ann) \
00056 COMPOUND_FIELD(#name, #name " (" ann ")", dump_node(buf, indent, comment, node->name))
00057
00058 #define ANN(ann) \
00059 if (comment) { \
00060 A_INDENT; A("| # "); A(ann); A("\n"); \
00061 }
00062
00063 #define LAST_NODE (next_indent = " ")
00064
00065 static void
00066 add_indent(VALUE buf, VALUE indent)
00067 {
00068 AR(indent);
00069 }
00070
00071 static void
00072 add_id(VALUE buf, ID id)
00073 {
00074 if (id == 0) {
00075 A("(null)");
00076 }
00077 else {
00078 VALUE str = rb_id2str(id);
00079 if (str) {
00080 A(":"); AR(rb_id2str(id));
00081 }
00082 else {
00083 A("(internal variable)");
00084 }
00085 }
00086 }
00087
00088 static void
00089 dump_node(VALUE buf, VALUE indent, int comment, NODE *node)
00090 {
00091 const char *next_indent = "| ";
00092
00093 if (!node) {
00094 D_NULL_NODE;
00095 return;
00096 }
00097
00098 D_NODE_HEADER(node);
00099
00100 switch (nd_type(node)) {
00101 case NODE_BLOCK:
00102 ANN("statement sequence");
00103 ANN("format: [nd_head]; [nd_next]");
00104 ANN("example: foo; bar");
00105 F_NODE(nd_head, "current statement");
00106 LAST_NODE;
00107 F_NODE(nd_next, "next block");
00108 break;
00109
00110 case NODE_IF:
00111 ANN("if statement");
00112 ANN("format: if [nd_cond] then [nd_body] else [nd_else] end");
00113 ANN("example: if x == 1 then foo else bar end");
00114 F_NODE(nd_cond, "condition expr");
00115 F_NODE(nd_body, "then clause");
00116 LAST_NODE;
00117 F_NODE(nd_else, "else clause");
00118 break;
00119
00120 case NODE_CASE:
00121 ANN("case statement");
00122 ANN("format: case [nd_head]; [nd_body]; end");
00123 ANN("example: case x; when 1; foo; when 2; bar; else baz; end");
00124 F_NODE(nd_head, "case expr");
00125 LAST_NODE;
00126 F_NODE(nd_body, "when clauses");
00127 break;
00128
00129 case NODE_WHEN:
00130 ANN("if statement");
00131 ANN("format: when [nd_head]; [nd_body]; (when or else) [nd_next]");
00132 ANN("example: case x; when 1; foo; when 2; bar; else baz; end");
00133 F_NODE(nd_head, "when value");
00134 F_NODE(nd_body, "when clause");
00135 LAST_NODE;
00136 F_NODE(nd_next, "next when clause");
00137 break;
00138
00139 case NODE_OPT_N:
00140 ANN("wrapper for -n option");
00141 ANN("format: ruby -ne '[nd_body]' (nd_cond is `gets')");
00142 ANN("example: ruby -ne 'p $_'");
00143 goto loop;
00144 case NODE_WHILE:
00145 ANN("while statement");
00146 ANN("format: while [nd_cond]; [nd_body]; end");
00147 ANN("example: while x == 1; foo; end");
00148 goto loop;
00149 case NODE_UNTIL:
00150 ANN("until statement");
00151 ANN("format: until [nd_cond]; [nd_body]; end");
00152 ANN("example: until x == 1; foo; end");
00153 loop:
00154 F_CUSTOM1(nd_state, "begin-end-while?", {
00155 A_INT((int)node->nd_state);
00156 A((node->nd_state == 1) ? " (while-end)" : " (begin-end-while)");
00157 });
00158 F_NODE(nd_cond, "condition");
00159 LAST_NODE;
00160 F_NODE(nd_body, "body");
00161 break;
00162
00163 case NODE_ITER:
00164 ANN("method call with block");
00165 ANN("format: [nd_iter] { [nd_body] }");
00166 ANN("example: 3.times { foo }");
00167 goto iter;
00168 case NODE_FOR:
00169 ANN("for statement");
00170 ANN("format: for * in [nd_iter] do [nd_body] end");
00171 ANN("example: for i in 1..3 do foo end");
00172 iter:
00173 F_NODE(nd_iter, "iteration receiver");
00174 LAST_NODE;
00175 F_NODE(nd_body, "body");
00176 break;
00177
00178 case NODE_BREAK:
00179 ANN("for statement");
00180 ANN("format: break [nd_stts]");
00181 ANN("example: break 1");
00182 goto jump;
00183 case NODE_NEXT:
00184 ANN("next statement");
00185 ANN("format: next [nd_stts]");
00186 ANN("example: next 1");
00187 goto jump;
00188 case NODE_RETURN:
00189 ANN("return statement");
00190 ANN("format: return [nd_stts]");
00191 ANN("example: return 1");
00192 jump:
00193 LAST_NODE;
00194 F_NODE(nd_stts, "value");
00195 break;
00196
00197 case NODE_REDO:
00198 ANN("redo statement");
00199 ANN("format: redo");
00200 ANN("example: redo");
00201 break;
00202
00203 case NODE_RETRY:
00204 ANN("retry statement");
00205 ANN("format: retry");
00206 ANN("example: retry");
00207 break;
00208
00209 case NODE_BEGIN:
00210 ANN("begin statement");
00211 ANN("format: begin; [nd_body]; end");
00212 ANN("example: begin; 1; end");
00213 LAST_NODE;
00214 F_NODE(nd_body, "body");
00215 break;
00216
00217 case NODE_RESCUE:
00218 ANN("rescue clause");
00219 ANN("format: begin; [nd_body]; (rescue) [nd_resq]; else [nd_else]; end");
00220 ANN("example: begin; foo; rescue; bar; else; baz; end");
00221 F_NODE(nd_head, "body");
00222 F_NODE(nd_resq, "rescue clause list");
00223 LAST_NODE;
00224 F_NODE(nd_else, "rescue else clause");
00225 break;
00226
00227 case NODE_RESBODY:
00228 ANN("rescue clause (cont'd)");
00229 ANN("format: rescue [nd_args]; [nd_body]; (rescue) [nd_head]");
00230 ANN("example: begin; foo; rescue; bar; else; baz; end");
00231 F_NODE(nd_args, "rescue exceptions");
00232 F_NODE(nd_body, "rescue clause");
00233 LAST_NODE;
00234 F_NODE(nd_head, "next rescue clause");
00235 break;
00236
00237 case NODE_ENSURE:
00238 ANN("ensure clause");
00239 ANN("format: begin; [nd_head]; ensure; [nd_ensr]; end");
00240 ANN("example: begin; foo; ensure; bar; end");
00241 F_NODE(nd_head, "body");
00242 LAST_NODE;
00243 F_NODE(nd_ensr, "ensure clause");
00244 break;
00245
00246 case NODE_AND:
00247 ANN("&& operator");
00248 ANN("format: [nd_1st] && [nd_2nd]");
00249 ANN("example: foo && bar");
00250 goto andor;
00251 case NODE_OR:
00252 ANN("|| operator");
00253 ANN("format: [nd_1st] || [nd_2nd]");
00254 ANN("example: foo && bar");
00255 andor:
00256 F_NODE(nd_1st, "left expr");
00257 LAST_NODE;
00258 F_NODE(nd_2nd, "right expr");
00259 break;
00260
00261 case NODE_MASGN:
00262 ANN("multiple assignment");
00263 ANN("format: [nd_head], [nd_args] = [nd_value]");
00264 ANN("example: a, b = foo");
00265 F_NODE(nd_value, "rhsn");
00266 F_NODE(nd_head, "lhsn");
00267 if ((VALUE)node->nd_args != (VALUE)-1) {
00268 LAST_NODE;
00269 F_NODE(nd_args, "splatn");
00270 }
00271 else {
00272 F_MSG(nd_args, "splatn", "-1 (rest argument without name)");
00273 }
00274 break;
00275
00276 case NODE_LASGN:
00277 ANN("local variable assignment");
00278 ANN("format: [nd_vid](lvar) = [nd_value]");
00279 ANN("example: x = foo");
00280 goto asgn;
00281 case NODE_DASGN:
00282 ANN("dynamic variable assignment (out of current scope)");
00283 ANN("format: [nd_vid](dvar) = [nd_value]");
00284 ANN("example: x = nil; 1.times { x = foo }");
00285 goto asgn;
00286 case NODE_DASGN_CURR:
00287 ANN("dynamic variable assignment (in current scope)");
00288 ANN("format: [nd_vid](current dvar) = [nd_value]");
00289 ANN("example: 1.times { x = foo }");
00290 goto asgn;
00291 case NODE_IASGN:
00292 ANN("instance variable assignment");
00293 ANN("format: [nd_vid](ivar) = [nd_value]");
00294 ANN("example: @x = foo");
00295 goto asgn;
00296 case NODE_CVASGN:
00297 ANN("class variable assignment");
00298 ANN("format: [nd_vid](cvar) = [nd_value]");
00299 ANN("example: @@x = foo");
00300 asgn:
00301 F_ID(nd_vid, "variable");
00302 LAST_NODE;
00303 F_NODE(nd_value, "rvalue");
00304 break;
00305
00306 case NODE_GASGN:
00307 ANN("global variable assignment");
00308 ANN("format: [nd_entry](gvar) = [nd_value]");
00309 ANN("example: $x = foo");
00310 F_GENTRY(nd_entry, "global variable");
00311 LAST_NODE;
00312 F_NODE(nd_value, "rvalue");
00313 break;
00314
00315 case NODE_CDECL:
00316 ANN("constant declaration");
00317 ANN("format: [nd_else]::[nd_vid](constant) = [nd_value]");
00318 ANN("example: X = foo");
00319 if (node->nd_vid) {
00320 F_ID(nd_vid, "variable");
00321 F_MSG(nd_else, "extension", "not used");
00322 }
00323 else {
00324 F_MSG(nd_vid, "variable", "0 (see extension field)");
00325 F_NODE(nd_else, "extension");
00326 }
00327 LAST_NODE;
00328 F_NODE(nd_value, "rvalue");
00329 break;
00330
00331 case NODE_OP_ASGN1:
00332 ANN("array assignment with operator");
00333 ANN("format: [nd_value] [ [nd_args->nd_body] ] [nd_vid]= [nd_args->nd_head]");
00334 ANN("example: ary[1] += foo");
00335 F_NODE(nd_recv, "receiver");
00336 F_ID(nd_vid, "operator");
00337 F_NODE(nd_args->nd_body, "index");
00338 LAST_NODE;
00339 F_NODE(nd_args->nd_head, "rvalue");
00340 break;
00341
00342 case NODE_OP_ASGN2:
00343 ANN("attr assignment with operator");
00344 ANN("format: [nd_value].[attr] [nd_next->nd_mid]= [nd_value]");
00345 ANN(" where [attr] reader: [nd_next->nd_vid]");
00346 ANN(" [attr] writer: [nd_next->nd_aid]");
00347 ANN("example: struct.field += foo");
00348 F_NODE(nd_recv, "receiver");
00349 F_ID(nd_next->nd_vid, "reader");
00350 F_ID(nd_next->nd_aid, "writer");
00351 F_CUSTOM1(nd_next->nd_mid, "operator", {
00352 switch (node->nd_next->nd_mid) {
00353 case 0: A("0 (||)"); break;
00354 case 1: A("1 (&&)"); break;
00355 default: A_ID(node->nd_next->nd_mid);
00356 }
00357 });
00358 LAST_NODE;
00359 F_NODE(nd_value, "rvalue");
00360 break;
00361
00362 case NODE_OP_ASGN_AND:
00363 ANN("assignment with && operator");
00364 ANN("format: [nd_head] &&= [nd_value]");
00365 ANN("example: foo &&= bar");
00366 goto asgn_andor;
00367 case NODE_OP_ASGN_OR:
00368 ANN("assignment with || operator");
00369 ANN("format: [nd_head] ||= [nd_value]");
00370 ANN("example: foo ||= bar");
00371 asgn_andor:
00372 F_NODE(nd_head, "variable");
00373 LAST_NODE;
00374 F_NODE(nd_value, "rvalue");
00375 break;
00376
00377 case NODE_CALL:
00378 ANN("method invocation");
00379 ANN("format: [nd_recv].[nd_mid]([nd_args])");
00380 ANN("example: obj.foo(1)");
00381 F_ID(nd_mid, "method id");
00382 F_NODE(nd_recv, "receiver");
00383 LAST_NODE;
00384 F_NODE(nd_args, "arguments");
00385 break;
00386
00387 case NODE_FCALL:
00388 ANN("function call");
00389 ANN("format: [nd_mid]([nd_args])");
00390 ANN("example: foo(1)");
00391 F_ID(nd_mid, "method id");
00392 LAST_NODE;
00393 F_NODE(nd_args, "arguments");
00394 break;
00395
00396 case NODE_VCALL:
00397 ANN("function call with no argument");
00398 ANN("format: [nd_mid]");
00399 ANN("example: foo");
00400 F_ID(nd_mid, "method id");
00401 break;
00402
00403 case NODE_SUPER:
00404 ANN("super invocation");
00405 ANN("format: super [nd_args]");
00406 ANN("example: super 1");
00407 LAST_NODE;
00408 F_NODE(nd_args, "arguments");
00409 break;
00410
00411 case NODE_ZSUPER:
00412 ANN("super invocation with no argument");
00413 ANN("format: super");
00414 ANN("example: super");
00415 break;
00416
00417 case NODE_ARRAY:
00418 ANN("array constructor");
00419 ANN("format: [ [nd_head], [nd_next].. ] (length: [nd_alen])");
00420 ANN("example: [1, 2, 3]");
00421 goto ary;
00422 case NODE_VALUES:
00423 ANN("return arguments");
00424 ANN("format: [ [nd_head], [nd_next].. ] (length: [nd_alen])");
00425 ANN("example: return 1, 2, 3");
00426 ary:
00427 F_LONG(nd_alen, "length");
00428 F_NODE(nd_head, "element");
00429 LAST_NODE;
00430 F_NODE(nd_next, "next element");
00431 break;
00432
00433 case NODE_ZARRAY:
00434 ANN("empty array constructor");
00435 ANN("format: []");
00436 ANN("example: []");
00437 break;
00438
00439 case NODE_HASH:
00440 ANN("hash constructor");
00441 ANN("format: { [nd_head] }");
00442 ANN("example: { 1 => 2, 3 => 4 }");
00443 LAST_NODE;
00444 F_NODE(nd_head, "contents");
00445 break;
00446
00447 case NODE_YIELD:
00448 ANN("yield invocation");
00449 ANN("format: yield [nd_head]");
00450 ANN("example: yield 1");
00451 LAST_NODE;
00452 F_NODE(nd_head, "arguments");
00453 break;
00454
00455 case NODE_LVAR:
00456 ANN("local variable reference");
00457 ANN("format: [nd_vid](lvar)");
00458 ANN("example: x");
00459 goto var;
00460 case NODE_DVAR:
00461 ANN("dynamic variable reference");
00462 ANN("format: [nd_vid](dvar)");
00463 ANN("example: 1.times { x = 1; x }");
00464 goto var;
00465 case NODE_IVAR:
00466 ANN("instance variable reference");
00467 ANN("format: [nd_vid](ivar)");
00468 ANN("example: @x");
00469 goto var;
00470 case NODE_CONST:
00471 ANN("constant reference");
00472 ANN("format: [nd_vid](constant)");
00473 ANN("example: X");
00474 goto var;
00475 case NODE_CVAR:
00476 ANN("class variable reference");
00477 ANN("format: [nd_vid](cvar)");
00478 ANN("example: @@x");
00479 var:
00480 F_ID(nd_vid, "local variable");
00481 break;
00482
00483 case NODE_GVAR:
00484 ANN("global variable reference");
00485 ANN("format: [nd_entry](gvar)");
00486 ANN("example: $x");
00487 F_GENTRY(nd_entry, "global variable");
00488 break;
00489
00490 case NODE_NTH_REF:
00491 ANN("nth special variable reference");
00492 ANN("format: $[nd_nth]");
00493 ANN("example: $1, $2, ..");
00494 F_CUSTOM1(nd_nth, "variable", { A("$"); A_LONG(node->nd_nth); });
00495 break;
00496
00497 case NODE_BACK_REF:
00498 ANN("back special variable reference");
00499 ANN("format: $[nd_nth]");
00500 ANN("example: $&, $`, $', $+");
00501 F_CUSTOM1(nd_nth, "variable", {
00502 char name[3];
00503 name[0] = '$';
00504 name[1] = node->nd_nth;
00505 name[2] = '\0';
00506 A(name);
00507 });
00508 break;
00509
00510 case NODE_MATCH:
00511 ANN("match expression (against $_ implicitly)");
00512 ANN("format: [nd_lit] (in condition)");
00513 ANN("example: if /foo/; foo; end");
00514 F_LIT(nd_lit, "regexp");
00515 break;
00516
00517 case NODE_MATCH2:
00518 ANN("match expression (regexp first)");
00519 ANN("format: [nd_recv] =~ [nd_value]");
00520 ANN("example: /foo/ =~ 'foo'");
00521 F_NODE(nd_recv, "regexp (receiver)");
00522 LAST_NODE;
00523 F_NODE(nd_value, "string (argument)");
00524 break;
00525
00526 case NODE_MATCH3:
00527 ANN("match expression (regexp second)");
00528 ANN("format: [nd_recv] =~ [nd_value]");
00529 ANN("example: 'foo' =~ /foo/");
00530 F_NODE(nd_recv, "string (receiver)");
00531 LAST_NODE;
00532 F_NODE(nd_value, "regexp (argument)");
00533 break;
00534
00535 case NODE_LIT:
00536 ANN("literal");
00537 ANN("format: [nd_lit]");
00538 ANN("example: 1, /foo/");
00539 goto lit;
00540 case NODE_STR:
00541 ANN("string literal");
00542 ANN("format: [nd_lit]");
00543 ANN("example: 'foo'");
00544 goto lit;
00545 case NODE_XSTR:
00546 ANN("xstring literal");
00547 ANN("format: [nd_lit]");
00548 ANN("example: `foo`");
00549 lit:
00550 F_LIT(nd_lit, "literal");
00551 break;
00552
00553 case NODE_DSTR:
00554 ANN("string literal with interpolation");
00555 ANN("format: [nd_lit]");
00556 ANN("example: \"foo#{ bar }baz\"");
00557 goto dlit;
00558 case NODE_DXSTR:
00559 ANN("xstring literal with interpolation");
00560 ANN("format: [nd_lit]");
00561 ANN("example: `foo#{ bar }baz`");
00562 goto dlit;
00563 case NODE_DREGX:
00564 ANN("regexp literal with interpolation");
00565 ANN("format: [nd_lit]");
00566 ANN("example: /foo#{ bar }baz/");
00567 goto dlit;
00568 case NODE_DREGX_ONCE:
00569 ANN("regexp literal with interpolation and once flag");
00570 ANN("format: [nd_lit]");
00571 ANN("example: /foo#{ bar }baz/o");
00572 goto dlit;
00573 case NODE_DSYM:
00574 ANN("symbol literal with interpolation");
00575 ANN("format: [nd_lit]");
00576 ANN("example: :\"foo#{ bar }baz\"");
00577 dlit:
00578 F_LIT(nd_lit, "literal");
00579 F_NODE(nd_next->nd_head, "preceding string");
00580 LAST_NODE;
00581 F_NODE(nd_next->nd_next, "interpolation");
00582 break;
00583
00584 case NODE_EVSTR:
00585 ANN("interpolation expression");
00586 ANN("format: \"..#{ [nd_lit] }..\"");
00587 ANN("example: \"foo#{ bar }baz\"");
00588 LAST_NODE;
00589 F_NODE(nd_body, "body");
00590 break;
00591
00592 case NODE_ARGSCAT:
00593 ANN("splat argument following arguments");
00594 ANN("format: ..(*[nd_head], [nd_body..])");
00595 ANN("example: foo(*ary, post_arg1, post_arg2)");
00596 F_NODE(nd_head, "preceding array");
00597 LAST_NODE;
00598 F_NODE(nd_body, "following array");
00599 break;
00600
00601 case NODE_ARGSPUSH:
00602 ANN("splat argument following one argument");
00603 ANN("format: ..(*[nd_head], [nd_body])");
00604 ANN("example: foo(*ary, post_arg)");
00605 F_NODE(nd_head, "preceding array");
00606 LAST_NODE;
00607 F_NODE(nd_body, "following element");
00608 break;
00609
00610 case NODE_SPLAT:
00611 ANN("splat argument");
00612 ANN("format: *[nd_head]");
00613 ANN("example: foo(*ary)");
00614 LAST_NODE;
00615 F_NODE(nd_head, "splat'ed array");
00616 break;
00617
00618 case NODE_BLOCK_PASS:
00619 ANN("arguments with block argument");
00620 ANN("format: ..([nd_head], &[nd_body])");
00621 ANN("example: foo(x, &blk)");
00622 F_NODE(nd_head, "other arguments");
00623 LAST_NODE;
00624 F_NODE(nd_body, "block argument");
00625 break;
00626
00627 case NODE_DEFN:
00628 ANN("method definition");
00629 ANN("format: def [nd_mid] [nd_defn]; end");
00630 ANN("example; def foo; bar; end");
00631 F_ID(nd_mid, "method name");
00632 LAST_NODE;
00633 F_NODE(nd_defn, "method definition");
00634 break;
00635
00636 case NODE_DEFS:
00637 ANN("singleton method definition");
00638 ANN("format: def [nd_recv].[nd_mid] [nd_defn]; end");
00639 ANN("example; def obj.foo; bar; end");
00640 F_NODE(nd_recv, "receiver");
00641 F_ID(nd_mid, "method name");
00642 LAST_NODE;
00643 F_NODE(nd_defn, "method definition");
00644 break;
00645
00646 case NODE_ALIAS:
00647 ANN("method alias statement");
00648 ANN("format: alias [u1.node] [u2.node]");
00649 ANN("example: alias bar foo");
00650 F_NODE(u1.node, "new name");
00651 LAST_NODE;
00652 F_NODE(u2.node, "old name");
00653 break;
00654
00655 case NODE_VALIAS:
00656 ANN("global variable alias statement");
00657 ANN("format: alias [u1.id](gvar) [u2.id](gvar)");
00658 ANN("example: alias $y $x");
00659 F_ID(u1.id, "new name");
00660 F_ID(u2.id, "old name");
00661 break;
00662
00663 case NODE_UNDEF:
00664 ANN("method alias statement");
00665 ANN("format: undef [u2.node]");
00666 ANN("example: undef foo");
00667 LAST_NODE;
00668 F_NODE(u2.node, "old name");
00669 break;
00670
00671 case NODE_CLASS:
00672 ANN("class definition");
00673 ANN("format: class [nd_cpath] < [nd_super]; [nd_body]; end");
00674 ANN("example: class C2 < C; ..; end");
00675 F_NODE(nd_cpath, "class path");
00676 F_NODE(nd_super, "superclass");
00677 LAST_NODE;
00678 F_NODE(nd_body, "class definition");
00679 break;
00680
00681 case NODE_MODULE:
00682 ANN("module definition");
00683 ANN("format: module [nd_cpath]; [nd_body]; end");
00684 ANN("example: module M; ..; end");
00685 F_NODE(nd_cpath, "module path");
00686 LAST_NODE;
00687 F_NODE(nd_body, "module definition");
00688 break;
00689
00690 case NODE_SCLASS:
00691 ANN("singleton class definition");
00692 ANN("format: class << [nd_recv]; [nd_body]; end");
00693 ANN("example: class << obj; ..; end");
00694 F_NODE(nd_recv, "receiver");
00695 LAST_NODE;
00696 F_NODE(nd_body, "singleton class definition");
00697 break;
00698
00699 case NODE_COLON2:
00700 ANN("scoped constant reference");
00701 ANN("format: [nd_head]::[nd_mid]");
00702 ANN("example: M::C");
00703 F_ID(nd_mid, "constant name");
00704 LAST_NODE;
00705 F_NODE(nd_head, "receiver");
00706 break;
00707
00708 case NODE_COLON3:
00709 ANN("top-level constant reference");
00710 ANN("format: ::[nd_mid]");
00711 ANN("example: ::Object");
00712 F_ID(nd_mid, "constant name");
00713 break;
00714
00715 case NODE_DOT2:
00716 ANN("range constructor (incl.)");
00717 ANN("format: [nd_beg]..[nd_end]");
00718 ANN("example: 1..5");
00719 goto dot;
00720 case NODE_DOT3:
00721 ANN("range constructor (excl.)");
00722 ANN("format: [nd_beg]...[nd_end]");
00723 ANN("example: 1...5");
00724 goto dot;
00725 case NODE_FLIP2:
00726 ANN("flip-flop condition (incl.)");
00727 ANN("format: [nd_beg]..[nd_end]");
00728 ANN("example: if (x==1)..(x==5); foo; end");
00729 goto dot;
00730 case NODE_FLIP3:
00731 ANN("flip-flop condition (excl.)");
00732 ANN("format: [nd_beg]...[nd_end]");
00733 ANN("example: if (x==1)...(x==5); foo; end");
00734 dot:
00735 F_NODE(nd_beg, "begin");
00736 LAST_NODE;
00737 F_NODE(nd_end, "end");
00738 break;
00739
00740 case NODE_SELF:
00741 ANN("self");
00742 ANN("format: self");
00743 ANN("example: self");
00744 break;
00745
00746 case NODE_NIL:
00747 ANN("nil");
00748 ANN("format: nil");
00749 ANN("example: nil");
00750 break;
00751
00752 case NODE_TRUE:
00753 ANN("true");
00754 ANN("format: true");
00755 ANN("example: true");
00756 break;
00757
00758 case NODE_FALSE:
00759 ANN("false");
00760 ANN("format: false");
00761 ANN("example: false");
00762 break;
00763
00764 case NODE_ERRINFO:
00765 ANN("virtual reference to $!");
00766 ANN("format: rescue => id");
00767 ANN("example: rescue => id");
00768 break;
00769
00770 case NODE_DEFINED:
00771 ANN("defined? expression");
00772 ANN("format: defined?([nd_head])");
00773 ANN("example: defined?(foo)");
00774 F_NODE(nd_head, "expr");
00775 break;
00776
00777 case NODE_POSTEXE:
00778 ANN("post-execution");
00779 ANN("format: END { [nd_body] }");
00780 ANN("example: END { foo }");
00781 LAST_NODE;
00782 F_NODE(nd_body, "END clause");
00783 break;
00784
00785 case NODE_ATTRASGN:
00786 ANN("attr assignment");
00787 ANN("format: [nd_recv].[nd_mid] = [nd_args]");
00788 ANN("example: struct.field = foo");
00789 if (node->nd_recv == (NODE *) 1) {
00790 F_MSG(nd_recv, "receiver", "1 (self)");
00791 }
00792 else {
00793 F_NODE(nd_recv, "receiver");
00794 }
00795 F_ID(nd_mid, "method name");
00796 LAST_NODE;
00797 F_NODE(nd_args, "arguments");
00798 break;
00799
00800 case NODE_PRELUDE:
00801 ANN("pre-execution");
00802 ANN("format: BEGIN { [nd_head] }; [nd_body]");
00803 ANN("example: bar; BEGIN { foo }");
00804 F_NODE(nd_head, "prelude");
00805 LAST_NODE;
00806 F_NODE(nd_body, "body");
00807 break;
00808
00809 case NODE_LAMBDA:
00810 ANN("lambda expression");
00811 ANN("format: -> [nd_body]");
00812 ANN("example: -> { foo }");
00813 LAST_NODE;
00814 F_NODE(nd_body, "lambda clause");
00815 break;
00816
00817 case NODE_OPT_ARG:
00818 ANN("optional arguments");
00819 ANN("format: def method_name([nd_body=some], [nd_next..])");
00820 ANN("example: def foo(a, b=1, c); end");
00821 F_NODE(nd_body, "body");
00822 LAST_NODE;
00823 F_NODE(nd_next, "next");
00824 break;
00825
00826 case NODE_POSTARG:
00827 ANN("post arguments");
00828 ANN("format: *[nd_1st], [nd_2nd..] = ..");
00829 ANN("example: a, *rest, z = foo");
00830 if ((VALUE)node->nd_1st != (VALUE)-1) {
00831 F_NODE(nd_1st, "rest argument");
00832 }
00833 else {
00834 F_MSG(nd_1st, "rest argument", "-1 (rest argument without name)");
00835 }
00836 LAST_NODE;
00837 F_NODE(nd_2nd, "post arguments");
00838 break;
00839
00840 case NODE_ARGS_AUX:
00841 ANN("method parameters (cont'd)");
00842 F_CUSTOM1(nd_rest, "rest argument", {
00843 if (node->nd_rest == 1) A("nil (with last comma)");
00844 else A_ID(node->nd_rest);
00845 });
00846 F_CUSTOM1(nd_body, "block argument", { A_ID((ID)node->nd_body); });
00847 LAST_NODE;
00848 F_CUSTOM2(nd_next, "aux info 2", {
00849 node = node->nd_next;
00850 next_indent = "| ";
00851 if (!node) {
00852 D_NULL_NODE;
00853 }
00854 else {
00855 D_NODE_HEADER(node);
00856 ANN("method parameters (cont'd)");
00857 F_ID(nd_pid, "first post argument");
00858 F_LONG(nd_plen, "post argument length");
00859 LAST_NODE;
00860 F_CUSTOM2(nd_next, "aux info 3", {
00861 node = node->nd_next;
00862 next_indent = "| ";
00863 if (!node) {
00864 D_NULL_NODE;
00865 }
00866 else {
00867 D_NODE_HEADER(node);
00868 ANN("method parameters (cont'd)");
00869 F_NODE(nd_1st, "init arguments (m)");
00870 LAST_NODE;
00871 F_NODE(nd_2nd, "init arguments (p)");
00872 }
00873 });
00874 }
00875 });
00876 break;
00877
00878 case NODE_ARGS:
00879 ANN("method parameters");
00880 ANN("format: def method_name(.., [nd_opt=some], *[nd_rest], [nd_pid], .., &[nd_body])");
00881 ANN("example: def foo(a, b, opt1=1, opt2=2, *rest, y, z, &blk); end");
00882 F_LONG(nd_frml, "argc");
00883 F_NODE(nd_next, "aux info 1");
00884 LAST_NODE;
00885 F_NODE(nd_opt, "optional arguments");
00886 break;
00887
00888 case NODE_SCOPE:
00889 ANN("new scope");
00890 ANN("format: [nd_tbl]: local table, [nd_args]: arguments, [nd_body]: body");
00891 F_CUSTOM1(nd_tbl, "local table", {
00892 ID *tbl = node->nd_tbl;
00893 int i;
00894 int size = tbl ? (int)*tbl++ : 0;
00895 if (size == 0) A("(empty)");
00896 for (i = 0; i < size; i++) {
00897 A_ID(tbl[i]); if (i < size - 1) A(",");
00898 }
00899 });
00900 F_NODE(nd_args, "arguments");
00901 LAST_NODE;
00902 F_NODE(nd_body, "body");
00903 break;
00904
00905 default:
00906 rb_bug("dump_node: unknown node: %s", ruby_node_name(nd_type(node)));
00907 }
00908 }
00909
00910 VALUE
00911 rb_parser_dump_tree(NODE *node, int comment)
00912 {
00913 VALUE buf = rb_str_new_cstr(
00914 "###########################################################\n"
00915 "## Do NOT use this node dump for any purpose other than ##\n"
00916 "## debug and research. Compatibility is not guaranteed. ##\n"
00917 "###########################################################\n\n"
00918 );
00919 dump_node(buf, rb_str_new_cstr("# "), comment, node);
00920 return buf;
00921 }
00922
