Ruby 1.9.3p327(2012-11-10revision37606)
|
00001 /********************************************************************** 00002 00003 node.c - ruby node tree 00004 00005 $Author: mame $ 00006 created at: 09/12/06 21:23:44 JST 00007 00008 Copyright (C) 2009 Yusuke Endoh 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(str); 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] = (char)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