ParseTree 1.2.0 → 1.3.0

data/History.txt

@@ -1,3 +1,12 @@
+*** 1.3.0 / 2004-12-06
+
++ 3 minor enhancements
+	+ Finished supporting pretty much all nodes (that we can figger out).
+	+ If $DEBUG, or true passed to new, then we now output the :newline nodes.
+	+ We output much better extra debugging info if $DEBUG.
++ 1 bug fixes
+	+ Fixed README for new output style.
+
 *** 1.2.0 / 2004-11-29
 
 + 9 minor enhancements
@@ -27,7 +36,6 @@
 	+ Added super as a call in abc.rb's metrics
 	+ Commented out a compiler flag to work with GCC 2.95.
 
-
 *** 1.0.0 / 2004-11-06
 
 + 1 major enhancement

data/README.txt

@@ -21,12 +21,12 @@ As an example:
 becomes:
 
   [:defn,
-    "conditional1",
+    :conditional1,
     [:scope,
      [:block,
-      [:args, "arg1"],
+      [:args, :arg1],
       [:if,
-       [:call, [:lvar, "arg1"], "==", [:array, [:lit, 0]]],
+       [:call, [:lvar, :arg1], :==, [:array, [:lit, 0]]],
        [:return, [:lit, 1]],
        nil],
       [:return, [:lit, 0]]]]]

data/lib/parse_tree.rb

@@ -27,7 +27,15 @@ end
 
 class ParseTree
 
-  VERSION = '1.2.0'
+  VERSION = '1.3.0'
+
+  ##
+  # Initializes a ParseTree instance. Includes newline nodes if
+  # +include_newlines+ which defaults to +$DEBUG+.
+
+  def initialize(include_newlines=$DEBUG)
+    @include_newlines = include_newlines
+  end
 
   ##
   # Main driver for ParseTree. Returns an array of arrays containing
@@ -76,15 +84,17 @@ class ParseTree
   #   [:defn, :name, :body]
 
   def parse_tree_for_method(klass, method)
-    parse_tree_for_meth(klass, method.to_sym)
+    parse_tree_for_meth(klass, method.to_sym, @include_newlines)
   end
 
   inline do |builder|
     builder.add_type_converter("VALUE", '', '')
+    builder.add_type_converter("ID *", '', '')
     builder.add_type_converter("NODE *", '(NODE *)', '(VALUE)')
     builder.include '"intern.h"'
     builder.include '"node.h"'
     builder.include '"st.h"'
+    builder.include '"env.h"'
     builder.add_compile_flags "-Wall"
     builder.add_compile_flags "-W"
     builder.add_compile_flags "-Wpointer-arith"
@@ -103,6 +113,35 @@ class ParseTree
     # builder.add_compile_flags "-Wsign-compare", 
 
     builder.prefix %q{
+        #define nd_3rd   u3.node
+
+        struct METHOD {
+          VALUE klass, rklass;
+          VALUE recv;
+          ID id, oid;
+          NODE *body;
+        };
+
+        struct BLOCK {
+          NODE *var;
+          NODE *body;
+          VALUE self;
+          struct FRAME frame;
+          struct SCOPE *scope;
+          VALUE klass;
+          NODE *cref;
+          int iter;
+          int vmode;
+          int flags;
+          int uniq;
+          struct RVarmap *dyna_vars;
+          VALUE orig_thread;
+          VALUE wrapper;
+          VALUE block_obj;
+          struct BLOCK *outer;
+          struct BLOCK *prev;
+        };
+
         static char node_type_string[][60] = {
 	  //  00
 	  "method", "fbody", "cfunc", "scope", "block",
@@ -147,10 +186,10 @@ class ParseTree
   }
 
     builder.c_raw %q^
-// FIX!!!
-static ID *dump_local_tbl;
-
-static void add_to_parse_tree(VALUE ary, NODE * n) {
+static void add_to_parse_tree(VALUE ary,
+                              NODE * n,
+                              VALUE newlines,
+                              ID * locals) {
   NODE * volatile node = n;
   NODE * volatile contnode = NULL;
   VALUE old_ary = Qnil;
@@ -164,8 +203,11 @@ again:
   if (node) {
     node_name = ID2SYM(rb_intern(node_type_string[nd_type(node)]));
     if (RTEST(ruby_debug)) {
-      fputs(node_type_string[nd_type(node)], stderr);
-      fputs("\n", stderr);
+      fprintf(stderr, "%15s: %s%s%s\n",
+        node_type_string[nd_type(node)],
+        (RNODE(node)->u1.node != NULL ? "u1 " : "   "),
+        (RNODE(node)->u2.node != NULL ? "u2 " : "   "),
+        (RNODE(node)->u3.node != NULL ? "u3 " : "   "));
     }
   } else {
     node_name = ID2SYM(rb_intern("ICKY"));
@@ -181,7 +223,7 @@ again_no_block:
 
     case NODE_BLOCK:
       if (contnode) {
-        add_to_parse_tree(current, node);
+        add_to_parse_tree(current, node, newlines, locals);
         break;
       }
 
@@ -196,11 +238,11 @@ again_no_block:
 
     case NODE_FBODY:
     case NODE_DEFINED:
-      add_to_parse_tree(current, node->nd_head);
+      add_to_parse_tree(current, node->nd_head, newlines, locals);
       break;
 
     case NODE_COLON2:
-      add_to_parse_tree(current, node->nd_head);
+      add_to_parse_tree(current, node->nd_head, newlines, locals);
       rb_ary_push(current, ID2SYM(node->nd_mid));
       break;
 
@@ -210,33 +252,33 @@ again_no_block:
 
     case NODE_MATCH2:
     case NODE_MATCH3:
-      add_to_parse_tree(current, node->nd_recv);
-      add_to_parse_tree(current, node->nd_value);
+      add_to_parse_tree(current, node->nd_recv, newlines, locals);
+      add_to_parse_tree(current, node->nd_value, newlines, locals);
       break;
 
     case NODE_OPT_N:
-      add_to_parse_tree(current, node->nd_body);
+      add_to_parse_tree(current, node->nd_body, newlines, locals);
       break;
 
     case NODE_IF:
-      add_to_parse_tree(current, node->nd_cond);
+      add_to_parse_tree(current, node->nd_cond, newlines, locals);
       if (node->nd_body) {
-        add_to_parse_tree(current, node->nd_body);
+        add_to_parse_tree(current, node->nd_body, newlines, locals);
       } else {
         rb_ary_push(current, Qnil);
       }
       if (node->nd_else) {
-        add_to_parse_tree(current, node->nd_else);
+        add_to_parse_tree(current, node->nd_else, newlines, locals);
       } else {
         rb_ary_push(current, Qnil);
       }
       break;
 
   case NODE_CASE:
-    add_to_parse_tree(current, node->nd_head);          /* expr */
+    add_to_parse_tree(current, node->nd_head, newlines, locals); /* expr */
     node = node->nd_body;
     while (node) {
-      add_to_parse_tree(current, node);
+      add_to_parse_tree(current, node, newlines, locals);
       if (nd_type(node) == NODE_WHEN) {                 /* when */
         node = node->nd_next; 
       } else {
@@ -249,9 +291,9 @@ again_no_block:
     break;
 
   case NODE_WHEN:
-    add_to_parse_tree(current, node->nd_head);          /* args */
+    add_to_parse_tree(current, node->nd_head, newlines, locals); /* args */
     if (node->nd_body) {
-      add_to_parse_tree(current, node->nd_body);        /* body */
+      add_to_parse_tree(current, node->nd_body, newlines, locals); /* body */
     } else {
       rb_ary_push(current, Qnil);
     }
@@ -259,148 +301,149 @@ again_no_block:
 
   case NODE_WHILE:
   case NODE_UNTIL:
-    add_to_parse_tree(current,  node->nd_cond);
-    add_to_parse_tree(current,  node->nd_body); 
+    add_to_parse_tree(current,  node->nd_cond, newlines, locals);
+    add_to_parse_tree(current,  node->nd_body, newlines, locals); 
     break;
 
   case NODE_BLOCK_PASS:
-    add_to_parse_tree(current, node->nd_body);
-    add_to_parse_tree(current, node->nd_iter);
+    add_to_parse_tree(current, node->nd_body, newlines, locals);
+    add_to_parse_tree(current, node->nd_iter, newlines, locals);
     break;
 
   case NODE_ITER:
   case NODE_FOR:
-    add_to_parse_tree(current, node->nd_iter);
+    add_to_parse_tree(current, node->nd_iter, newlines, locals);
     if (node->nd_var != (NODE *)1
         && node->nd_var != (NODE *)2
         && node->nd_var != NULL) {
-      add_to_parse_tree(current, node->nd_var);
+      add_to_parse_tree(current, node->nd_var, newlines, locals);
     } else {
       rb_ary_push(current, Qnil);
     }
-    add_to_parse_tree(current, node->nd_body);
+    add_to_parse_tree(current, node->nd_body, newlines, locals);
     break;
 
   case NODE_BREAK:
   case NODE_NEXT:
   case NODE_YIELD:
     if (node->nd_stts)
-      add_to_parse_tree(current, node->nd_stts);
+      add_to_parse_tree(current, node->nd_stts, newlines, locals);
     break;
 
   case NODE_RESCUE:
-    {
-      NODE *resq, *n;
-      int i;
+      add_to_parse_tree(current, node->nd_1st, newlines, locals);
+      add_to_parse_tree(current, node->nd_2nd, newlines, locals);
+    break;
 
-      add_to_parse_tree(current, node->nd_head);
-      resq = node->nd_resq;
-      while (resq) {
-	if (nd_type(resq) == NODE_ARRAY) {
-	  n = resq;
-	  for (i = 0; i < resq->nd_alen; i++) {
-	    add_to_parse_tree(current, n->nd_head);
-	    n = n->nd_next;
-	  }
-	} else {
-	  add_to_parse_tree(current, resq->nd_args);
-	}
-	add_to_parse_tree(current, resq->nd_body);
-	resq = resq->nd_head;
-      }
-      if (node->nd_else) {
-	add_to_parse_tree(current, node->nd_else);
-      }
-    }
+  case NODE_RESBODY:            // stmt rescue stmt | a = b rescue c - no repro
+      add_to_parse_tree(current, node->nd_3rd, newlines, locals);
+      add_to_parse_tree(current, node->nd_2nd, newlines, locals);
+      add_to_parse_tree(current, node->nd_1st, newlines, locals);
     break;
 	
   case NODE_ENSURE:
-    add_to_parse_tree(current, node->nd_head);
+    add_to_parse_tree(current, node->nd_head, newlines, locals);
     if (node->nd_ensr) {
-      add_to_parse_tree(current, node->nd_ensr);
+      add_to_parse_tree(current, node->nd_ensr, newlines, locals);
     }
     break;
 
   case NODE_AND:
   case NODE_OR:
-    add_to_parse_tree(current, node->nd_1st);
-    add_to_parse_tree(current, node->nd_2nd);
+    add_to_parse_tree(current, node->nd_1st, newlines, locals);
+    add_to_parse_tree(current, node->nd_2nd, newlines, locals);
     break;
 
   case NODE_NOT:
-    add_to_parse_tree(current, node->nd_body);
+    add_to_parse_tree(current, node->nd_body, newlines, locals);
     break;
 
   case NODE_DOT2:
   case NODE_DOT3:
   case NODE_FLIP2:
   case NODE_FLIP3:
-    add_to_parse_tree(current, node->nd_beg);
-    add_to_parse_tree(current, node->nd_end);
+    add_to_parse_tree(current, node->nd_beg, newlines, locals);
+    add_to_parse_tree(current, node->nd_end, newlines, locals);
     break;
 
   case NODE_RETURN:
     if (node->nd_stts)
-      add_to_parse_tree(current, node->nd_stts);
+      add_to_parse_tree(current, node->nd_stts, newlines, locals);
     break;
 
   case NODE_ARGSCAT:
   case NODE_ARGSPUSH:
-    add_to_parse_tree(current, node->nd_head);
-    add_to_parse_tree(current, node->nd_body);
+    add_to_parse_tree(current, node->nd_head, newlines, locals);
+    add_to_parse_tree(current, node->nd_body, newlines, locals);
     break;
 
   case NODE_CALL:
   case NODE_FCALL:
   case NODE_VCALL:
     if (nd_type(node) != NODE_FCALL)
-      add_to_parse_tree(current, node->nd_recv);
+      add_to_parse_tree(current, node->nd_recv, newlines, locals);
     rb_ary_push(current, ID2SYM(node->nd_mid));
     if (node->nd_args || nd_type(node) != NODE_FCALL)
-      add_to_parse_tree(current, node->nd_args);
+      add_to_parse_tree(current, node->nd_args, newlines, locals);
     break;
 
   case NODE_SUPER:
-    add_to_parse_tree(current, node->nd_args);
+    add_to_parse_tree(current, node->nd_args, newlines, locals);
+    break;
+
+  case NODE_BMETHOD:
+    {
+      struct BLOCK *data;
+      Data_Get_Struct(node->nd_cval, struct BLOCK, data);
+      add_to_parse_tree(current, data->var, newlines, locals);
+      add_to_parse_tree(current, data->body, newlines, locals);
+      break;
+    }
     break;
 
   case NODE_DMETHOD:
     {
       struct METHOD *data;
       Data_Get_Struct(node->nd_cval, struct METHOD, data);
+      rb_ary_push(current, ID2SYM(data->id));
+      add_to_parse_tree(current, data->body, newlines, locals);
       break;
     }
 
+  case NODE_METHOD:
+    fprintf(stderr, "u1 = %p u2 = %p u3 = %p\n", node->nd_1st, node->nd_2nd, node->nd_3rd);
+    add_to_parse_tree(current, node->nd_3rd, newlines, locals);
+    break;
+
   case NODE_SCOPE:
-    dump_local_tbl = node->nd_tbl;
-    add_to_parse_tree(current, node->nd_next);
+    add_to_parse_tree(current, node->nd_next, newlines, node->nd_tbl);
     break;
 
   case NODE_OP_ASGN1:
-    add_to_parse_tree(current, node->nd_recv);
-    add_to_parse_tree(current, node->nd_args->nd_next);
-    add_to_parse_tree(current, node->nd_args->nd_head);
+    add_to_parse_tree(current, node->nd_recv, newlines, locals);
+    add_to_parse_tree(current, node->nd_args->nd_next, newlines, locals);
+    add_to_parse_tree(current, node->nd_args->nd_head, newlines, locals);
     break;
 
   case NODE_OP_ASGN2:
-    add_to_parse_tree(current, node->nd_recv);
-    add_to_parse_tree(current, node->nd_value);
+    add_to_parse_tree(current, node->nd_recv, newlines, locals);
+    add_to_parse_tree(current, node->nd_value, newlines, locals);
     break;
 
   case NODE_OP_ASGN_AND:
   case NODE_OP_ASGN_OR:
-    add_to_parse_tree(current, node->nd_head);
-    add_to_parse_tree(current, node->nd_value);
+    add_to_parse_tree(current, node->nd_head, newlines, locals);
+    add_to_parse_tree(current, node->nd_value, newlines, locals);
     break;
 
   case NODE_MASGN:
-    add_to_parse_tree(current, node->nd_head);
+    add_to_parse_tree(current, node->nd_head, newlines, locals);
     if (node->nd_args) {
       if (node->nd_args != (NODE *)-1) {
-	add_to_parse_tree(current, node->nd_args);
+	add_to_parse_tree(current, node->nd_args, newlines, locals);
       }
     }
-    add_to_parse_tree(current, node->nd_value);
+    add_to_parse_tree(current, node->nd_value, newlines, locals);
     break;
 
   case NODE_LASGN:
@@ -412,7 +455,18 @@ again_no_block:
   case NODE_CVDECL:
   case NODE_GASGN:
     rb_ary_push(current, ID2SYM(node->nd_vid));
-    add_to_parse_tree(current, node->nd_value);
+    add_to_parse_tree(current, node->nd_value, newlines, locals);
+    break;
+
+  case NODE_ALIAS:            // u1 u2 (alias :blah :blah2)
+  case NODE_VALIAS:           // u1 u2 (alias $global $global2)
+    rb_ary_push(current, ID2SYM(node->u1.id));
+    rb_ary_push(current, ID2SYM(node->u2.id));
+    break;
+
+  case NODE_COLON3:           // u2    (::OUTER_CONST)
+  case NODE_UNDEF:            // u2    (undef instvar)
+    rb_ary_push(current, ID2SYM(node->u2.id));
     break;
 
   case NODE_HASH:
@@ -421,11 +475,11 @@ again_no_block:
 	
       list = node->nd_head;
       while (list) {
-	add_to_parse_tree(current, list->nd_head);
+	add_to_parse_tree(current, list->nd_head, newlines, locals);
 	list = list->nd_next;
 	if (list == 0)
 	  rb_bug("odd number list for Hash");
-	add_to_parse_tree(current, list->nd_head);
+	add_to_parse_tree(current, list->nd_head, newlines, locals);
 	list = list->nd_next;
       }
     }
@@ -433,7 +487,7 @@ again_no_block:
 
   case NODE_ARRAY:
       while (node) {
-	add_to_parse_tree(current, node->nd_head);
+	add_to_parse_tree(current, node->nd_head, newlines, locals);
         node = node->nd_next;
       }
     break;
@@ -452,13 +506,13 @@ again_no_block:
 	if (list->nd_head) {
 	  switch (nd_type(list->nd_head)) {
 	  case NODE_STR:
-	    add_to_parse_tree(current, list->nd_head);
+	    add_to_parse_tree(current, list->nd_head, newlines, locals);
 	    break;
 	  case NODE_EVSTR:
-	    add_to_parse_tree(current, list->nd_head->nd_body);
+	    add_to_parse_tree(current, list->nd_head->nd_body, newlines, locals);
 	    break;
 	  default:
-	    add_to_parse_tree(current, list->nd_head);
+	    add_to_parse_tree(current, list->nd_head, newlines, locals);
 	    break;
 	  }
 	}
@@ -471,9 +525,9 @@ again_no_block:
   case NODE_DEFS:
     if (node->nd_defn) {
       if (nd_type(node) == NODE_DEFS)
-	add_to_parse_tree(current, node->nd_recv);
+	add_to_parse_tree(current, node->nd_recv, newlines, locals);
       rb_ary_push(current, ID2SYM(node->nd_mid));
-      add_to_parse_tree(current, node->nd_defn);
+      add_to_parse_tree(current, node->nd_defn, newlines, locals);
     }
     break;
 
@@ -481,18 +535,18 @@ again_no_block:
   case NODE_MODULE:
     rb_ary_push(current, ID2SYM((ID)node->nd_cpath->nd_mid));
     if (node->nd_super && nd_type(node) == NODE_CLASS) {
-      add_to_parse_tree(current, node->nd_super);
+      add_to_parse_tree(current, node->nd_super, newlines, locals);
     }
-    add_to_parse_tree(current, node->nd_body);
+    add_to_parse_tree(current, node->nd_body, newlines, locals);
     break;
 
   case NODE_SCLASS:
-    add_to_parse_tree(current, node->nd_recv);
-    add_to_parse_tree(current, node->nd_body);
+    add_to_parse_tree(current, node->nd_recv, newlines, locals);
+    add_to_parse_tree(current, node->nd_body, newlines, locals);
     break;
 
   case NODE_ARGS:
-    if (dump_local_tbl && 
+    if (locals && 
 	(node->nd_cnt || node->nd_opt || node->nd_rest != -1)) {
       int i;
       NODE *optnode;
@@ -500,13 +554,13 @@ again_no_block:
 
       for (i = 0; i < node->nd_cnt; i++) {
         // regular arg names
-        rb_ary_push(current, ID2SYM(dump_local_tbl[i + 3]));
+        rb_ary_push(current, ID2SYM(locals[i + 3]));
       }
 
       optnode = node->nd_opt;
       while (optnode) {
         // optional arg names
-        rb_ary_push(current, ID2SYM(dump_local_tbl[i + 3]));
+        rb_ary_push(current, ID2SYM(locals[i + 3]));
 	i++;
 	optnode = optnode->nd_next;
       }
@@ -514,7 +568,7 @@ again_no_block:
       arg_count = node->nd_rest;
       if (arg_count > 0) {
         // *arg name
-        rb_ary_push(current, ID2SYM(dump_local_tbl[node->nd_rest + 1]));
+        rb_ary_push(current, ID2SYM(locals[node->nd_rest + 1]));
       } else if (arg_count == -1) {
         // nothing to do in this case, handled above
       } else if (arg_count == -2) {
@@ -527,85 +581,135 @@ again_no_block:
       optnode = node->nd_opt;
       // block?
       if (optnode) {
-	add_to_parse_tree(current, node->nd_opt);
+	add_to_parse_tree(current, node->nd_opt, newlines, locals);
       }
     }
     break;
 	
-    case NODE_LVAR:
-    case NODE_DVAR:
-    case NODE_IVAR:
-    case NODE_CVAR:
-    case NODE_GVAR:
-    case NODE_CONST:
-    case NODE_ATTRSET:
-      rb_ary_push(current, ID2SYM(node->nd_vid));
-      break;
+  case NODE_LVAR:
+  case NODE_DVAR:
+  case NODE_IVAR:
+  case NODE_CVAR:
+  case NODE_GVAR:
+  case NODE_CONST:
+  case NODE_ATTRSET:
+    rb_ary_push(current, ID2SYM(node->nd_vid));
+    break;
 
-    case NODE_STR:
-    case NODE_LIT:
-      rb_ary_push(current, node->nd_lit);
-      break;
+  case NODE_XSTR:             // u1    (%x{ls})
+  case NODE_STR:              // u1
+  case NODE_LIT:
+  case NODE_MATCH:
+    rb_ary_push(current, node->nd_lit);
+    break;
 
-    case NODE_NEWLINE:
-      rb_ary_push(current, INT2FIX(nd_line(node)));
-      rb_ary_push(current, rb_str_new2(node->nd_file));
-      rb_ary_pop(ary); // nuke it for now
+  case NODE_NEWLINE:
+    rb_ary_push(current, INT2FIX(nd_line(node)));
+    rb_ary_push(current, rb_str_new2(node->nd_file));
 
-      node = node->nd_next;
-      goto again;
+    if (! RTEST(newlines)) rb_ary_pop(ary); // nuke it
 
-    // these are things we know we do not need to translate to C.
-    case NODE_BLOCK_ARG:
-    case NODE_SELF:
-    case NODE_NIL:
-    case NODE_TRUE:
-    case NODE_FALSE:
-    case NODE_ZSUPER:
-    case NODE_BMETHOD:
-    case NODE_REDO:
-    case NODE_RETRY:
-    case NODE_COLON3:
-    case NODE_NTH_REF:
-    case NODE_BACK_REF:
-    case NODE_ZARRAY:
-    case NODE_XSTR:
-    case NODE_UNDEF:
-    case NODE_ALIAS:
-    case NODE_VALIAS:
-    break;
-
-    default:
-      rb_ary_push(current, INT2FIX(-99));
-      rb_ary_push(current, INT2FIX(nd_type(node)));
-      break;
-    }
+    node = node->nd_next;
+    goto again;
+    break;
 
-//  finish:
-    if (contnode) {
-	node = contnode;
-	contnode = NULL;
-        current = ary;
-        ary = old_ary;
-        old_ary = Qnil;
-	goto again_no_block;
+  case NODE_NTH_REF:          // u2 u3 ($1) - u3 is local_cnt('~') ignorable?
+    rb_ary_push(current, INT2FIX(node->nd_nth));
+    break;
+
+  case NODE_BACK_REF:         // u2 u3 ($& etc)
+    {
+    char c = node->nd_nth;
+    rb_ary_push(current, rb_str_intern(rb_str_new(&c, 1)));
     }
+    break;
+
+  case NODE_BLOCK_ARG:        // u1 u3 (def x(&b)
+    rb_ary_push(current, ID2SYM(node->u1.id));
+    break;
+
+  // these nodes are empty and do not require extra work:
+  case NODE_RETRY:
+  case NODE_FALSE:
+  case NODE_NIL:
+  case NODE_SELF:
+  case NODE_TRUE:
+  case NODE_ZARRAY:
+  case NODE_ZSUPER:
+  case NODE_REDO:
+    break;
+
+  case NODE_SPLAT:
+  case NODE_TO_ARY:
+  case NODE_SVALUE:             // a = b, c
+    add_to_parse_tree(current, node->nd_head, newlines, locals);
+    break;
+
+  case NODE_ATTRASGN:           // literal.meth = y u1 u2 u3
+    // node id node
+    add_to_parse_tree(current, node->nd_1st, newlines, locals);
+    rb_ary_push(current, ID2SYM(node->u2.id));
+    add_to_parse_tree(current, node->nd_3rd, newlines, locals);
+    break;
+
+  case NODE_DSYM:               // :"#{foo}" u1 u2 u3
+    add_to_parse_tree(current, node->nd_3rd, newlines, locals);
+    break;
+
+  case NODE_EVSTR:
+    add_to_parse_tree(current, node->nd_2nd, newlines, locals);
+    break;
+
+  case NODE_POSTEXE:            // END { ... }
+    // Nothing to do here... we are in an iter block
+    break;
+
+  // Nodes we found but have yet to decypher
+  // I think these are all runtime only... not positive but...
+  case NODE_MEMO:               // enum.c zip
+  case NODE_CFUNC:
+  case NODE_CREF:
+  case NODE_IFUNC:
+  // #defines:
+  // case NODE_LMASK:
+  // case NODE_LSHIFT:
+  default:
+    rb_warn("Unhandled node #%d type '%s'", nd_type(node), node_type_string[nd_type(node)]);
+    if (RNODE(node)->u1.node != NULL) rb_warning("unhandled u1 value");
+    if (RNODE(node)->u2.node != NULL) rb_warning("unhandled u2 value");
+    if (RNODE(node)->u3.node != NULL) rb_warning("unhandled u3 value");
+    if (RTEST(ruby_debug)) fprintf(stderr, "u1 = %p u2 = %p u3 = %p\n", node->nd_1st, node->nd_2nd, node->nd_3rd);
+    rb_ary_push(current, INT2FIX(-99));
+    rb_ary_push(current, INT2FIX(nd_type(node)));
+    break;
   }
+
+ //  finish:
+  if (contnode) {
+      node = contnode;
+      contnode = NULL;
+      current = ary;
+      ary = old_ary;
+      old_ary = Qnil;
+      goto again_no_block;
+  }
+}
 ^ # end of add_to_parse_tree block
 
     builder.c %q{
-static VALUE parse_tree_for_meth(VALUE klass, VALUE method) {
+static VALUE parse_tree_for_meth(VALUE klass, VALUE method, VALUE newlines) {
   NODE *node = NULL;
   ID id;
   VALUE result = rb_ary_new();
 
   (void) self; // quell warnings
+  (void) argc; // quell warnings
 
   id = rb_to_id(method);
   if (st_lookup(RCLASS(klass)->m_tbl, id, (st_data_t *) &node)) {
     rb_ary_push(result, ID2SYM(rb_intern("defn")));
     rb_ary_push(result, ID2SYM(id));
-    add_to_parse_tree(result, node->nd_body);
+    add_to_parse_tree(result, node->nd_body, newlines, NULL);
   } else {
     rb_ary_push(result, Qnil);
   }

data/test/something.rb

@@ -159,4 +159,16 @@ class Something
     5 == unknown_args(4, "known")
   end
 
+  def self.bmethod_maker
+    define_method(:bmethod_added) do |x|
+      x + 1
+    end
+  end
+  
+  def self.dmethod_maker
+    define_method :dmethod_added, self.method(:bmethod_maker)
+  end
+  
+  bmethod_maker
+  dmethod_maker
 end

data/test/test_parse_tree.rb

@@ -2,7 +2,7 @@
 
 require 'test/unit'
 require 'parse_tree'
-require 'something'
+require 'test/something'
 
 class TestParseTree < Test::Unit::TestCase
 
@@ -244,10 +244,28 @@ class TestParseTree < Test::Unit::TestCase
                 :unknown_args,
                 [:array, [:lit, 4], [:str, "known"]]]]]]]]
 
+  @@bmethod_added = [:defn,
+    :bmethod_added,
+    [:bmethod,
+      [:dasgn_curr, :x],
+      [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]
+  
+  @@dmethod_added = [:defn,
+ :dmethod_added,
+ [:dmethod,
+  :bmethod_maker,
+  [:scope,
+   [:block,
+    [:args],
+    [:iter,
+     [:fcall, :define_method, [:array, [:lit, :bmethod_added]]],
+     [:dasgn_curr, :x],
+     [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]]]]
+
   @@__all = [:class, :Something, :Object]
 
   def setup
-    @thing = ParseTree.new
+    @thing = ParseTree.new(false)
   end
 
   Something.instance_methods(false).sort.each do |meth|

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.1
 specification_version: 1
 name: ParseTree
 version: !ruby/object:Gem::Version 
-  version: 1.2.0
-date: 2004-11-29
+  version: 1.3.0
+date: 2004-12-07
 summary: Extract and enumerate ruby parse trees.
 require_paths: 
   - lib