ParseTree 3.0.1-x86-mswin32-60

data/Rakefile

@@ -0,0 +1,35 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.add_include_dirs("../../RubyInline/dev/lib",
+                     "../../sexp_processor/dev/lib",
+                     "../../ZenTest/dev/lib",
+                     "lib")
+
+require './lib/parse_tree.rb'
+
+Hoe.new("ParseTree", ParseTree::VERSION) do |pt|
+  pt.rubyforge_name = "parsetree"
+
+  pt.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
+
+  pt.clean_globs << File.expand_path("~/.ruby_inline")
+  pt.extra_deps << ['RubyInline',     '>= 3.7.0']
+  pt.extra_deps << ['sexp_processor', '>= 3.0.0']
+  pt.spec_extras[:require_paths] = proc { |paths| paths << 'test' }
+
+  pt.multiruby_skip << "mri_rel_1_9" << "rubinius" << "mri_trunk"
+end
+
+desc 'Run in gdb'
+task :debug do
+  puts "RUN: r -d #{Hoe::RUBY_FLAGS} test/test_all.rb #{Hoe::FILTER}"
+  sh "gdb ~/.multiruby/install/19/bin/ruby"
+end
+
+desc 'Run a very basic demo'
+task :demo do
+  sh "echo 1+1 | ruby #{Hoe::RUBY_FLAGS} ./bin/parse_tree_show -f"
+end

data/bin/parse_tree_abc

@@ -0,0 +1,89 @@
+#!/usr/local/bin/ruby -ws
+
+# ABC metric
+#
+# Assignments, Branches, and Calls
+#
+# A simple way to measure the complexity of a function or method.
+
+if defined? $I and String === $I then
+  $I.split(/:/).each do |dir|
+    $: << dir
+  end
+end
+
+PARSE_TREE_ABC=true
+
+begin require 'rubygems' rescue LoadError end
+require 'sexp'
+require 'parse_tree'
+require 'sexp_processor'
+
+old_classes = []
+ObjectSpace.each_object(Module) do |klass|
+  old_classes << klass
+end
+
+ARGV.each do |name|
+  begin
+    require name
+  rescue NameError => err
+    $stderr.puts "ERROR requiring #{name}. Perhaps you need to add some -I's?\n\n#{err}"
+  end
+end
+
+new_classes = []
+ObjectSpace.each_object(Module) do |klass|
+  new_classes << klass
+end
+
+score = {}
+
+new_classes -= old_classes
+
+klasses = Sexp.from_array(ParseTree.new.parse_tree(*new_classes))
+klasses.each do |klass|
+  klass.shift # :class
+  klassname = klass.shift
+  klass.shift # superclass
+  methods = klass
+
+  methods.each do |defn|
+    a=b=c=0
+    defn.shift
+    methodname = defn.shift
+    tokens = defn.structure.flatten
+    tokens.each do |token|
+      case token
+      when :attrasgn, :attrset, :dasgn_curr, :iasgn, :lasgn, :masgn then
+        a += 1
+      when :and, :case, :else, :if, :iter, :or, :rescue, :until, :when, :while  then
+        b += 1
+      when :call, :fcall, :super, :vcall, :yield then
+        c += 1
+      when :args, :argscat, :array, :begin, :block, :block_arg, :block_pass, :bool, :cfunc, :colon2, :const, :cvar, :defined, :defn, :dregx, :dstr, :dvar, :dxstr, :ensure, :false, :fbody, :gvar, :hash, :ivar, :lit, :long, :lvar, :match2, :match3, :nil, :not, :nth_ref, :return, :scope, :self, :splat, :str, :to_ary, :true, :unknown, :value, :void, :zarray, :zarray, :zclass, :zsuper then
+        # ignore
+      else
+        puts "unhandled token #{token.inspect}" if $VERBOSE
+      end
+    end
+    key = ["#{klassname}.#{methodname}", a, b, c]
+    val = Math.sqrt(a*a+b*b+c*c)
+    score[key] = val
+  end
+end
+
+puts "|ABC| = Math.sqrt(assignments^2 + branches^2 + calls^2)"
+puts
+count = 1
+ta = tb = tc = tval = 0
+score.sort_by { |k,v| v }.reverse.each do |key,val|
+  name, a, b, c = *key
+  ta += a
+  tb += b
+  tc += c
+  tval += val
+  printf "%3d) %-50s = %2d + %2d + %2d = %6.2f\n", count, name, a, b, c, val
+  count += 1
+end rescue nil
+printf "%3d) %-50s = %2d + %2d + %2d = %6.2f\n", count, "Total", ta, tb, tc, tval

data/bin/parse_tree_audit

@@ -0,0 +1,28 @@
+#!/usr/local/bin/ruby -w
+
+require 'parse_tree'
+
+all_nodes = ParseTree::NODE_NAMES
+
+ARGV.each do |processor|
+  require processor
+end
+
+ObjectSpace.each_object(Class) do |klass| 
+  if klass < SexpProcessor then
+
+    processor = klass.new
+    processors = klass.public_instance_methods(true).grep(/process_/)
+
+    if processor.strict then
+      puts "#{klass.name}:"
+      puts
+
+      # TODO: check unsupported against supported
+      processors = processors.map { |m| m[8..-1].intern } + processor.unsupported
+      unsupported = all_nodes - processors 
+      p unsupported.sort_by { |sym| sym.to_s }
+      puts
+    end
+  end
+end

data/bin/parse_tree_deps

@@ -0,0 +1,62 @@
+#!/usr/local/bin/ruby -ws
+
+old_classes = []; new_classes = []
+
+ObjectSpace.each_object(Module) { |klass| old_classes << klass } if defined? $a
+
+require 'pp'
+
+begin require 'rubygems' rescue LoadError end
+require 'parse_tree'
+require 'sexp_processor'
+
+ObjectSpace.each_object(Module) { |klass| old_classes << klass } unless defined? $a
+
+class DependencyAnalyzer < SexpProcessor
+
+  attr_reader :dependencies
+  attr_accessor :current_class
+
+  def initialize
+    super
+    self.auto_shift_type = true
+    @dependencies = Hash.new { |h,k| h[k] = [] }
+    @current_method = nil
+    @current_class = nil
+  end
+
+  def self.process(*klasses)
+    analyzer = self.new
+    klasses.each do |start_klass|
+      analyzer.current_class = start_klass
+      analyzer.process(ParseTree.new.parse_tree(start_klass))
+    end
+
+    deps = analyzer.dependencies
+    deps.keys.sort_by {|k| k.to_s}.each do |dep_to|
+      dep_from = deps[dep_to]
+      puts "#{dep_to}: #{dep_from.uniq.sort.join(", ")}"
+    end
+  end
+
+  def process_defn(exp)
+    name = exp.shift
+    @current_method = name
+    return s(:defn, name, process(exp.shift), process(exp.shift))
+  end
+
+  def process_const(exp)
+    name = exp.shift
+    const = (defined?($c) ? @current_class.name : "#{@current_class}.#{@current_method}")
+    is_class = ! (Object.const_get(name) rescue nil).nil?
+    @dependencies[name] << const if is_class
+    return s(:const, name)
+  end
+end
+
+if __FILE__ == $0 then
+  ARGV.each { |name| require name }
+  ObjectSpace.each_object(Module) { |klass| new_classes << klass }
+  new_classes.delete DependencyAnalyzer unless defined? $a
+  DependencyAnalyzer.process(*(new_classes - old_classes))
+end

data/bin/parse_tree_show

@@ -0,0 +1,60 @@
+#!/usr/local/bin/ruby -ws
+
+require 'pp'
+begin require 'rubygems' rescue LoadError end
+require 'parse_tree'
+require 'sexp'
+
+$a ||= false
+$h ||= false
+$n ||= false
+$r ||= false
+$s ||= false
+$u ||= false
+$n = $n.intern if $n
+
+if $h then
+  puts "usage: #{File.basename $0} [options] [file...]"
+  puts "options:"
+  puts "-h      : display usage"
+  puts "-a      : all nodes, including newline"
+  puts "-n=node : only display matching nodes"
+  puts "-r      : raw arrays, no sexps"
+  puts "-s      : structural sexps, strip all content and show bare tree"
+  puts "-u      : unified sexps"
+
+  exit 1
+end
+
+ARGV.push "-" if ARGV.empty?
+
+if $u then
+  require 'sexp_processor'
+  require 'unified_ruby'
+
+  class Unifier < SexpProcessor
+    include UnifiedRuby
+  end
+end
+
+parse_tree = ParseTree.new($a)
+unifier = Unifier.new if $u
+
+ARGV.each do |file|
+  ruby = file == "-" ? $stdin.read : File.read(file)
+
+  sexp = parse_tree.parse_tree_for_string(ruby, file).first
+  sexp = Sexp.from_array sexp unless $r
+  sexp = unifier.process(sexp) if $u
+  sexp = sexp.structure if $s
+
+  if $n then
+    sexp.each_of_type $n do |node|
+      p node
+    end
+  elsif defined? $q then
+    p sexp
+  else
+    pp sexp
+  end
+end

data/demo/printer.rb

@@ -0,0 +1,20 @@
+#!/usr/local/bin/ruby -w
+require 'rubygems'
+require 'sexp_processor'
+
+class QuickPrinter < SexpProcessor
+  def initialize
+    super
+    self.strict = false
+    self.auto_shift_type = true
+  end
+  def process_defn(exp)
+    name = exp.shift
+    args = process exp.shift
+    body = process exp.shift
+    puts "  def #{name}"
+    return s(:defn, name, args, body)
+  end
+end
+
+QuickPrinter.new.process(*ParseTree.new.parse_tree(QuickPrinter))

data/lib/parse_tree.rb

@@ -0,0 +1,1153 @@
+#!/usr/local/bin/ruby -w
+
+raise LoadError, "ParseTree doesn't work with ruby #{RUBY_VERSION}" if
+  RUBY_VERSION >= "1.9"
+raise LoadError, "ParseTree isn't needed with rubinius" if
+  defined? RUBY_ENGINE and RUBY_ENGINE == "rbx"
+
+require 'rubygems'
+require 'inline'
+require 'unified_ruby'
+
+class Module
+  def modules
+    ancestors[1..-1]
+  end
+end
+
+class Class
+  def modules
+    a = self.ancestors
+    a[1..a.index(superclass)-1]
+  end
+end
+
+##
+# ParseTree is a RubyInline-style extension that accesses and
+# traverses the internal parse tree created by ruby.
+#
+#   class Example
+#     def blah
+#       return 1 + 1
+#     end
+#   end
+#
+#   ParseTree.new.parse_tree(Example)
+#   => [[:class, :Example, :Object,
+#          [:defn,
+#            "blah",
+#            [:scope,
+#              [:block,
+#                [:args],
+#                [:return, [:call, [:lit, 1], "+", [:array, [:lit, 1]]]]]]]]]
+
+class RawParseTree
+
+  VERSION = '3.0.1'
+
+  ##
+  # Front end translation method.
+
+  def self.translate(klass_or_str, method=nil)
+    pt = self.new(false)
+    case klass_or_str
+    when String then
+      sexp = pt.parse_tree_for_string(klass_or_str).first
+      if method then
+        # class, scope, block, *methods
+        sexp.last.last[1..-1].find do |defn|
+          defn[1] == method
+        end
+      else
+        sexp
+      end
+    else
+      unless method.nil? then
+        if method.to_s =~ /^self\./ then
+          method = method.to_s[5..-1].intern
+          pt.parse_tree_for_method(klass_or_str, method, true)
+        else
+          pt.parse_tree_for_method(klass_or_str, method)
+        end
+      else
+        pt.parse_tree(klass_or_str).first
+      end
+    end
+  end
+
+  ##
+  # 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
+  # the parse tree for +klasses+.
+  #
+  # Structure:
+  #
+  #   [[:class, classname, superclassname, [:defn :method1, ...], ...], ...]
+  #
+  # NOTE: v1.0 - v1.1 had the signature (klass, meth=nil). This wasn't
+  # used much at all and since parse_tree_for_method already existed,
+  # it was deemed more useful to expand this method to do multiple
+  # classes.
+
+  def parse_tree(*klasses)
+    result = []
+    klasses.each do |klass|
+      klassname = klass.name rescue '' # HACK klass.name should never be nil
+                                   # Tempfile's DelegateClass(File) seems to
+                                   # cause this
+      klassname = "UnnamedClass_#{klass.object_id}" if klassname.empty?
+      klassname = klassname.to_sym
+
+      code = if Class === klass then
+               sc = klass.superclass
+               sc_name = ((sc.nil? or sc.name.empty?) ? "nil" : sc.name).intern
+               [:class, klassname, [:const, sc_name]]
+             else
+               [:module, klassname]
+             end
+
+      method_names = []
+      method_names += klass.instance_methods false
+      method_names += klass.private_instance_methods false
+      # protected methods are included in instance_methods, go figure!
+
+      method_names.sort.each do |m|
+        r = parse_tree_for_method(klass, m.to_sym)
+        code << r
+      end
+
+      klass.modules.each do |mod| # TODO: add a test for this damnit
+        mod.instance_methods.each do |m|
+          r = parse_tree_for_method(mod, m.to_sym)
+          code << r
+        end
+      end
+
+      klass.singleton_methods(false).sort.each do |m|
+        code << parse_tree_for_method(klass, m.to_sym, true)
+      end
+
+      result << code
+    end
+    return result
+  end
+
+  ##
+  # Returns the parse tree for just one +method+ of a class +klass+.
+  #
+  # Format:
+  #
+  #   [:defn, :name, :body]
+
+  def parse_tree_for_method(klass, method, is_cls_meth=false, verbose = true)
+    $stderr.puts "** parse_tree_for_method(#{klass}, #{method}):" if $DEBUG
+    old_verbose, $VERBOSE = $VERBOSE, verbose
+    r = parse_tree_for_meth(klass, method.to_sym, is_cls_meth)
+    r
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  ##
+  # Returns the parse tree for a string +source+.
+  #
+  # Format:
+  #
+  #   [[sexps] ... ]
+
+  def parse_tree_for_string(source,
+                            filename = '(string)', line = 1, verbose = true)
+    old_verbose, $VERBOSE = $VERBOSE, verbose
+    return parse_tree_for_str0(source, filename, line)
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  def parse_tree_for_str0(*__1args2__) # :nodoc:
+    parse_tree_for_str(*__1args2__)    # just helps clean up the binding
+  end
+
+  if RUBY_VERSION < "1.8.4" then
+    inline do |builder|
+      builder.add_type_converter("bool", '', '')
+      builder.c_singleton "
+        bool has_alloca() {
+          (void)self;
+          #ifdef C_ALLOCA
+            return Qtrue;
+          #else
+            return Qfalse;
+          #endif
+          }"
+    end
+  else
+    def self.has_alloca
+      true
+    end
+  end
+
+
+  NODE_NAMES = [
+                #  00
+                :method, :fbody, :cfunc, :scope, :block,
+                :if, :case, :when, :opt_n, :while,
+                #  10
+                :until, :iter, :for, :break, :next,
+                :redo, :retry, :begin, :rescue, :resbody,
+                #  20
+                :ensure, :and, :or, :not, :masgn,
+                :lasgn, :dasgn, :dasgn_curr, :gasgn, :iasgn,
+                #  30
+                :cdecl, :cvasgn, :cvdecl, :op_asgn1, :op_asgn2,
+                :op_asgn_and, :op_asgn_or, :call, :fcall, :vcall,
+                #  40
+                :super, :zsuper, :array, :zarray, :hash,
+                :return, :yield, :lvar, :dvar, :gvar,
+                #  50
+                :ivar, :const, :cvar, :nth_ref, :back_ref,
+                :match, :match2, :match3, :lit, :str,
+                #  60
+                :dstr, :xstr, :dxstr, :evstr, :dregx,
+                :dregx_once, :args, :argscat, :argspush, :splat,
+                #  70
+                :to_ary, :svalue, :block_arg, :block_pass, :defn,
+                :defs, :alias, :valias, :undef, :class,
+                #  80
+                :module, :sclass, :colon2, :colon3, :cref,
+                :dot2, :dot3, :flip2, :flip3, :attrset,
+                #  90
+                :self, :nil, :true, :false, :defined,
+                #  95
+                :newline, :postexe, :alloca, :dmethod, :bmethod,
+                # 100
+                :memo, :ifunc, :dsym, :attrasgn,
+                :last
+               ]
+
+  if RUBY_VERSION < "1.8.4" then
+    NODE_NAMES.delete :alloca unless has_alloca
+  end
+
+  if RUBY_VERSION > "1.9" then
+    NODE_NAMES.insert NODE_NAMES.index(:hash), :values
+    NODE_NAMES.insert NODE_NAMES.index(:defined), :errinfo
+    NODE_NAMES.insert NODE_NAMES.index(:last), :prelude, :lambda
+    NODE_NAMES.delete :dmethod
+    NODE_NAMES[128] = NODE_NAMES.delete :newline
+  end
+
+  ############################################################
+  # END of rdoc methods
+  ############################################################
+
+  inline do |builder|
+    builder.add_type_converter("bool", '', '')
+    builder.add_type_converter("ID *", '', '')
+    builder.add_type_converter("NODE *", '(NODE *)', '(VALUE)')
+    builder.include '"intern.h"'
+    builder.include '"version.h"'
+    builder.include '"rubysig.h"'
+    builder.include '"node.h"'
+    builder.include '"st.h"'
+    builder.include '"env.h"'
+
+    if RUBY_VERSION < "1.8.6" then
+      builder.prefix '#define RARRAY_PTR(s) (RARRAY(s)->ptr)'
+      builder.prefix '#define RARRAY_LEN(s) (RARRAY(s)->len)'
+    end
+
+    if ENV['ANAL'] or ENV['DOMAIN'] =~ /zenspider/ then
+      builder.add_compile_flags "-Wall"
+      builder.add_compile_flags "-W"
+      builder.add_compile_flags "-Wpointer-arith"
+      builder.add_compile_flags "-Wcast-qual"
+      builder.add_compile_flags "-Wcast-align"
+      builder.add_compile_flags "-Wwrite-strings"
+      builder.add_compile_flags "-Wmissing-noreturn"
+      builder.add_compile_flags "-Wno-long-long"
+
+      # NOTE: this flag doesn't work w/ gcc 2.95.x - the FreeBSD default
+      # builder.add_compile_flags "-Wno-strict-aliasing"
+      # ruby.h screws these up hardcore:
+      # builder.add_compile_flags "-Wundef"
+      # builder.add_compile_flags "-Wconversion"
+      # builder.add_compile_flags "-Wstrict-prototypes"
+      # builder.add_compile_flags "-Wmissing-prototypes"
+      # builder.add_compile_flags "-Wsign-compare"
+    end
+
+    # NOTE: If you get weird compiler errors like:
+    #    dereferencing type-punned pointer will break strict-aliasing rules
+    # PLEASE do one of the following:
+    # 1) Get me a login on your box so I can repro this and get it fixed.
+    # 2) Fix it and send me the patch
+    # 3) (quick, but dirty and bad), comment out the following line:
+    builder.add_compile_flags "-Werror" unless RUBY_PLATFORM =~ /mswin/
+
+    builder.prefix %{
+        #define nd_3rd   u3.node
+        static unsigned case_level = 0;
+        static unsigned when_level = 0;
+        static unsigned inside_case_args = 0;
+    }
+
+    builder.prefix %{
+      static VALUE wrap_into_node(const char * name, VALUE val) {
+        VALUE n = rb_ary_new();
+        rb_ary_push(n, ID2SYM(rb_intern(name)));
+        if (val) rb_ary_push(n, val);
+        return n;
+      }
+    }
+
+    builder.prefix %{
+        struct METHOD {
+          VALUE klass, rklass;
+          VALUE recv;
+          ID id, oid;
+#if RUBY_VERSION_CODE > 182
+          int safe_level;
+#endif
+          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;
+        };
+    } unless RUBY_VERSION >= "1.9" # we got matz to add this to env.h
+
+  ##
+  # add_to_parse_tree(self, ary, node, local_variables)
+
+  builder.prefix %Q@
+void add_to_parse_tree(VALUE self, VALUE ary, NODE * n, ID * locals) {
+  NODE * volatile node = n;
+  VALUE current;
+  VALUE node_name;
+  static VALUE node_names = Qnil;
+  static int masgn_level = 0;
+
+  if (NIL_P(node_names)) {
+    node_names = rb_const_get_at(rb_path2class("RawParseTree"),rb_intern("NODE_NAMES"));
+  }
+
+  if (!node) return;
+
+again:
+
+  if (node) {
+    node_name = rb_ary_entry(node_names, nd_type(node));
+    if (RTEST(ruby_debug)) {
+      fprintf(stderr, "%15s: %s%s%s\\n",
+        rb_id2name(SYM2ID(node_name)),
+        (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"));
+  }
+
+  current = rb_ary_new();
+  rb_ary_push(ary, current);
+  rb_ary_push(current, node_name);
+
+  switch (nd_type(node)) {
+
+    case NODE_BLOCK:
+      {
+        while (node) {
+          add_to_parse_tree(self, current, node->nd_head, locals);
+          node = node->nd_next;
+        }
+        if (!masgn_level && RARRAY_LEN(current) == 2) {
+          rb_ary_pop(ary);
+          rb_ary_push(ary, rb_ary_pop(current));
+          return;
+        }
+      }
+      break;
+
+    case NODE_FBODY:
+    case NODE_DEFINED:
+      add_to_parse_tree(self, current, node->nd_head, locals);
+      break;
+
+    case NODE_COLON2:
+      add_to_parse_tree(self, current, node->nd_head, locals);
+      rb_ary_push(current, ID2SYM(node->nd_mid));
+      break;
+
+    case NODE_MATCH2:
+    case NODE_MATCH3:
+      add_to_parse_tree(self, current, node->nd_recv, locals);
+      add_to_parse_tree(self, current, node->nd_value, locals);
+      break;
+
+    case NODE_BEGIN:
+    case NODE_OPT_N:
+    case NODE_NOT:
+      add_to_parse_tree(self, current, node->nd_body, locals);
+      break;
+
+    case NODE_IF:
+      add_to_parse_tree(self, current, node->nd_cond, locals);
+      if (node->nd_body) {
+        add_to_parse_tree(self, current, node->nd_body, locals);
+      } else {
+        rb_ary_push(current, Qnil);
+      }
+      if (node->nd_else) {
+        add_to_parse_tree(self, current, node->nd_else, locals);
+      } else {
+        rb_ary_push(current, Qnil);
+      }
+      break;
+
+  case NODE_CASE:
+    case_level++;
+    if (node->nd_head != NULL) {
+      add_to_parse_tree(self, current, node->nd_head, locals); /* expr */
+    } else {
+      rb_ary_push(current, Qnil);
+    }
+    node = node->nd_body;
+    while (node) {
+      add_to_parse_tree(self, current, node, locals);
+      if (nd_type(node) == NODE_WHEN) {                 /* when */
+        node = node->nd_next;
+      } else {
+        break;                                          /* else */
+      }
+      if (! node) {
+        rb_ary_push(current, Qnil);                     /* no else */
+      }
+    }
+    case_level--;
+    break;
+
+  case NODE_WHEN:
+    when_level++;
+    if (!inside_case_args && case_level < when_level) { /* when without case, ie, no expr in case */
+      if (when_level > 0) when_level--;
+      rb_ary_pop(ary); /* reset what current is pointing at */
+      node = NEW_CASE(0, node);
+      goto again;
+    }
+    inside_case_args++;
+    add_to_parse_tree(self, current, node->nd_head, locals); /* args */
+    inside_case_args--;
+
+    if (node->nd_body) {
+      add_to_parse_tree(self, current, node->nd_body, locals); /* body */
+    } else {
+      rb_ary_push(current, Qnil);
+    }
+
+    if (when_level > 0) when_level--;
+    break;
+
+  case NODE_WHILE:
+  case NODE_UNTIL:
+    add_to_parse_tree(self, current,  node->nd_cond, locals);
+    if (node->nd_body) {
+      add_to_parse_tree(self, current,  node->nd_body, locals);
+    } else {
+      rb_ary_push(current, Qnil);
+    }
+    rb_ary_push(current, node->nd_3rd == 0 ? Qfalse : Qtrue);
+    break;
+
+  case NODE_BLOCK_PASS:
+    add_to_parse_tree(self, current, node->nd_body, locals);
+    add_to_parse_tree(self, current, node->nd_iter, locals);
+    break;
+
+  case NODE_ITER:
+  case NODE_FOR:
+    add_to_parse_tree(self, current, node->nd_iter, locals);
+    masgn_level++;
+    if (node->nd_var != (NODE *)1
+        && node->nd_var != (NODE *)2
+        && node->nd_var != NULL) {
+      add_to_parse_tree(self, current, node->nd_var, locals);
+    } else {
+      if (node->nd_var == NULL) {
+        // e.g. proc {}
+        rb_ary_push(current, Qnil);
+      } else {
+        // e.g. proc {||}
+        rb_ary_push(current, INT2FIX(0));
+      }
+    }
+    masgn_level--;
+    add_to_parse_tree(self, current, node->nd_body, locals);
+    break;
+
+  case NODE_BREAK:
+  case NODE_NEXT:
+    if (node->nd_stts)
+      add_to_parse_tree(self, current, node->nd_stts, locals);
+
+    break;
+
+  case NODE_YIELD:
+    if (node->nd_stts)
+      add_to_parse_tree(self, current, node->nd_stts, locals);
+
+    if (node->nd_stts
+        && (nd_type(node->nd_stts) == NODE_ARRAY
+            || nd_type(node->nd_stts) == NODE_ZARRAY)
+        && !node->nd_state)
+      rb_ary_push(current, Qtrue);
+
+    break;
+
+  case NODE_RESCUE:
+    add_to_parse_tree(self, current, node->nd_1st, locals);
+    add_to_parse_tree(self, current, node->nd_2nd, locals);
+    add_to_parse_tree(self, current, node->nd_3rd, locals);
+    break;
+
+  /*
+  // rescue body:
+  // begin stmt rescue exception => var; stmt; [rescue e2 => v2; s2;]* end
+  // stmt rescue stmt
+  // a = b rescue c
+  */
+
+  case NODE_RESBODY:
+      if (node->nd_3rd) {
+        add_to_parse_tree(self, current, node->nd_3rd, locals);
+      } else {
+        rb_ary_push(current, Qnil);
+      }
+      add_to_parse_tree(self, current, node->nd_2nd, locals);
+      add_to_parse_tree(self, current, node->nd_1st, locals);
+    break;
+
+  case NODE_ENSURE:
+    add_to_parse_tree(self, current, node->nd_head, locals);
+    if (node->nd_ensr) {
+      add_to_parse_tree(self, current, node->nd_ensr, locals);
+    }
+    break;
+
+  case NODE_AND:
+  case NODE_OR:
+    add_to_parse_tree(self, current, node->nd_1st, locals);
+    add_to_parse_tree(self, current, node->nd_2nd, locals);
+    break;
+
+  case NODE_DOT2:
+  case NODE_DOT3:
+  case NODE_FLIP2:
+  case NODE_FLIP3:
+    add_to_parse_tree(self, current, node->nd_beg, locals);
+    add_to_parse_tree(self, current, node->nd_end, locals);
+    break;
+
+  case NODE_RETURN:
+    if (node->nd_stts)
+      add_to_parse_tree(self, current, node->nd_stts, locals);
+    break;
+
+  case NODE_ARGSCAT:
+  case NODE_ARGSPUSH:
+    add_to_parse_tree(self, current, node->nd_head, locals);
+    add_to_parse_tree(self, current, node->nd_body, locals);
+    break;
+
+  case NODE_CALL:
+  case NODE_FCALL:
+  case NODE_VCALL:
+    if (nd_type(node) != NODE_FCALL)
+      add_to_parse_tree(self, current, node->nd_recv, locals);
+    rb_ary_push(current, ID2SYM(node->nd_mid));
+    if (node->nd_args || nd_type(node) != NODE_FCALL)
+      add_to_parse_tree(self, current, node->nd_args, locals);
+    break;
+
+  case NODE_SUPER:
+    add_to_parse_tree(self, current, node->nd_args, locals);
+    break;
+
+  case NODE_BMETHOD:
+    {
+      struct BLOCK *data;
+      Data_Get_Struct(node->nd_cval, struct BLOCK, data);
+      if (data->var == 0 || data->var == (NODE *)1 || data->var == (NODE *)2) {
+        rb_ary_push(current, Qnil);
+      } else {
+        masgn_level++;
+        add_to_parse_tree(self, current, data->var, locals);
+        masgn_level--;
+      }
+      add_to_parse_tree(self, current, data->body, locals);
+    }
+    break;
+
+#if RUBY_VERSION_CODE < 190
+  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(self, current, data->body, locals);
+      break;
+    }
+#endif
+
+  case NODE_METHOD:
+    add_to_parse_tree(self, current, node->nd_3rd, locals);
+    break;
+
+  case NODE_SCOPE:
+    add_to_parse_tree(self, current, node->nd_next, node->nd_tbl);
+    break;
+
+  case NODE_OP_ASGN1:
+    add_to_parse_tree(self, current, node->nd_recv, locals);
+#if RUBY_VERSION_CODE < 185
+    add_to_parse_tree(self, current, node->nd_args->nd_next, locals);
+    rb_ary_pop(rb_ary_entry(current, -1)); /* no idea why I need this */
+#else
+    add_to_parse_tree(self, current, node->nd_args->nd_2nd, locals);
+#endif
+    switch (node->nd_mid) {
+    case 0:
+      rb_ary_push(current, ID2SYM(rb_intern("||")));
+      break;
+    case 1:
+      rb_ary_push(current, ID2SYM(rb_intern("&&")));
+      break;
+    default:
+      rb_ary_push(current, ID2SYM(node->nd_mid));
+      break;
+    }
+    add_to_parse_tree(self, current, node->nd_args->nd_head, locals);
+    break;
+
+  case NODE_OP_ASGN2:
+    add_to_parse_tree(self, current, node->nd_recv, locals);
+    rb_ary_push(current, ID2SYM(node->nd_next->nd_aid));
+
+    switch (node->nd_next->nd_mid) {
+    case 0:
+      rb_ary_push(current, ID2SYM(rb_intern("||")));
+      break;
+    case 1:
+      rb_ary_push(current, ID2SYM(rb_intern("&&")));
+      break;
+    default:
+      rb_ary_push(current, ID2SYM(node->nd_next->nd_mid));
+      break;
+    }
+
+    add_to_parse_tree(self, current, node->nd_value, locals);
+    break;
+
+  case NODE_OP_ASGN_AND:
+  case NODE_OP_ASGN_OR:
+    add_to_parse_tree(self, current, node->nd_head, locals);
+    add_to_parse_tree(self, current, node->nd_value, locals);
+    break;
+
+  case NODE_MASGN:
+    masgn_level++;
+    if (node->nd_head) {
+      add_to_parse_tree(self, current, node->nd_head, locals);
+    } else {
+      rb_ary_push(current, Qnil);
+    }
+    if (node->nd_args) {
+      if (node->nd_args != (NODE *)-1) {
+        add_to_parse_tree(self, current, node->nd_args, locals);
+      } else {
+        rb_ary_push(current, wrap_into_node("splat", 0));
+      }
+    } else {
+      rb_ary_push(current, Qnil);
+    }
+    if (node->nd_value) {
+      add_to_parse_tree(self, current, node->nd_value, locals);
+    } else {
+      rb_ary_push(current, Qnil);
+    }
+    masgn_level--;
+    break;
+
+  case NODE_LASGN:
+  case NODE_IASGN:
+  case NODE_DASGN:
+  case NODE_CVASGN:
+  case NODE_CVDECL:
+  case NODE_GASGN:
+    rb_ary_push(current, ID2SYM(node->nd_vid));
+    add_to_parse_tree(self, current, node->nd_value, locals);
+    break;
+
+  case NODE_CDECL:
+    if (node->nd_vid) {
+      rb_ary_push(current, ID2SYM(node->nd_vid));
+    } else {
+      add_to_parse_tree(self, current, node->nd_else, locals);
+    }
+
+    add_to_parse_tree(self, current, node->nd_value, locals);
+    break;
+
+  case NODE_DASGN_CURR:
+    rb_ary_push(current, ID2SYM(node->nd_vid));
+    if (node->nd_value) {
+      add_to_parse_tree(self, current, node->nd_value, locals);
+      if (!masgn_level && RARRAY_LEN(current) == 2) {
+        rb_ary_pop(ary);
+        return;
+      }
+    } else {
+      if (!masgn_level) {
+        rb_ary_pop(ary);
+        return;
+      }
+    }
+    break;
+
+  case NODE_VALIAS:           /* u1 u2 (alias $global $global2) */
+#if RUBY_VERSION_CODE < 185
+    rb_ary_push(current, ID2SYM(node->u2.id));
+    rb_ary_push(current, ID2SYM(node->u1.id));
+#else
+    rb_ary_push(current, ID2SYM(node->u1.id));
+    rb_ary_push(current, ID2SYM(node->u2.id));
+#endif
+    break;
+  case NODE_ALIAS:            /* u1 u2 (alias :blah :blah2) */
+#if RUBY_VERSION_CODE < 185
+    rb_ary_push(current, wrap_into_node("lit", ID2SYM(node->u2.id)));
+    rb_ary_push(current, wrap_into_node("lit", ID2SYM(node->u1.id)));
+#else
+    add_to_parse_tree(self, current, node->nd_1st, locals);
+    add_to_parse_tree(self, current, node->nd_2nd, locals);
+#endif
+    break;
+
+  case NODE_UNDEF:            /* u2    (undef name, ...) */
+#if RUBY_VERSION_CODE < 185
+    rb_ary_push(current, wrap_into_node("lit", ID2SYM(node->u2.id)));
+#else
+    add_to_parse_tree(self, current, node->nd_value, locals);
+#endif
+    break;
+
+  case NODE_COLON3:           /* u2    (::OUTER_CONST) */
+    rb_ary_push(current, ID2SYM(node->u2.id));
+    break;
+
+  case NODE_HASH:
+    {
+      NODE *list;
+
+      list = node->nd_head;
+      while (list) {
+        add_to_parse_tree(self, current, list->nd_head, locals);
+        list = list->nd_next;
+        if (list == 0)
+          rb_bug("odd number list for Hash");
+        add_to_parse_tree(self, current, list->nd_head, locals);
+        list = list->nd_next;
+      }
+    }
+    break;
+
+  case NODE_ARRAY:
+      while (node) {
+        add_to_parse_tree(self, current, node->nd_head, locals);
+        node = node->nd_next;
+      }
+    break;
+
+  case NODE_DSTR:
+  case NODE_DSYM:
+  case NODE_DXSTR:
+  case NODE_DREGX:
+  case NODE_DREGX_ONCE:
+    {
+      NODE *list = node->nd_next;
+      rb_ary_push(current, rb_str_new3(node->nd_lit));
+      while (list) {
+        if (list->nd_head) {
+          switch (nd_type(list->nd_head)) {
+          case NODE_STR:
+            add_to_parse_tree(self, current, list->nd_head, locals);
+            break;
+          case NODE_EVSTR:
+            add_to_parse_tree(self, current, list->nd_head, locals);
+            break;
+          default:
+            add_to_parse_tree(self, current, list->nd_head, locals);
+            break;
+          }
+        }
+        list = list->nd_next;
+      }
+      switch (nd_type(node)) {
+      case NODE_DREGX:
+      case NODE_DREGX_ONCE:
+        if (node->nd_cflag) {
+          rb_ary_push(current, INT2FIX(node->nd_cflag));
+        }
+      }
+    }
+    break;
+
+  case NODE_DEFN:
+  case NODE_DEFS:
+    if (node->nd_defn) {
+      if (nd_type(node) == NODE_DEFS)
+        add_to_parse_tree(self, current, node->nd_recv, locals);
+      rb_ary_push(current, ID2SYM(node->nd_mid));
+      add_to_parse_tree(self, current, node->nd_defn, locals);
+    }
+    break;
+
+  case NODE_CLASS:
+  case NODE_MODULE:
+    if (nd_type(node->nd_cpath) == NODE_COLON2 && ! node->nd_cpath->nd_vid) {
+      rb_ary_push(current, ID2SYM((ID)node->nd_cpath->nd_mid));
+    } else {
+      add_to_parse_tree(self, current, node->nd_cpath, locals);
+    }
+
+    if (nd_type(node) == NODE_CLASS) {
+      if (node->nd_super) {
+        add_to_parse_tree(self, current, node->nd_super, locals);
+      } else {
+        rb_ary_push(current, Qnil);
+      }
+    }
+    add_to_parse_tree(self, current, node->nd_body, locals);
+    break;
+
+  case NODE_SCLASS:
+    add_to_parse_tree(self, current, node->nd_recv, locals);
+    add_to_parse_tree(self, current, node->nd_body, locals);
+    break;
+
+  case NODE_ARGS: {
+    NODE *optnode;
+    int i = 0, max_args = node->nd_cnt;
+
+    /* push regular argument names */
+    for (; i < max_args; i++) {
+      rb_ary_push(current, ID2SYM(locals[i + 3]));
+    }
+
+    /* look for optional arguments */
+    masgn_level++;
+    optnode = node->nd_opt;
+    while (optnode) {
+      rb_ary_push(current, ID2SYM(locals[i + 3]));
+      i++;
+      optnode = optnode->nd_next;
+    }
+
+    /* look for vargs */
+#if RUBY_VERSION_CODE > 184
+    if (node->nd_rest) {
+      VALUE sym = rb_str_new2("*");
+      if (locals[i + 3]) {
+        rb_str_concat(sym, rb_str_new2(rb_id2name(locals[i + 3])));
+      }
+      sym = rb_str_intern(sym);
+      rb_ary_push(current, sym);
+    }
+#else
+    {
+      long arg_count = (long)node->nd_rest;
+      if (arg_count > 0) {
+        /* *arg name */
+        VALUE sym = rb_str_new2("*");
+        if (locals[i + 3]) {
+          rb_str_concat(sym, rb_str_new2(rb_id2name(locals[i + 3])));
+        }
+        sym = rb_str_intern(sym);
+        rb_ary_push(current, sym);
+      } else if (arg_count == 0) {
+        /* nothing to do in this case, empty list */
+      } else if (arg_count == -1) {
+        /* nothing to do in this case, handled above */
+      } else if (arg_count == -2) {
+        /* nothing to do in this case, no name == no use */
+        rb_ary_push(current, rb_str_intern(rb_str_new2("*")));
+      } else {
+        rb_raise(rb_eArgError,
+                 "not a clue what this arg value is: %ld", arg_count);
+      }
+    }
+#endif
+
+    optnode = node->nd_opt;
+    if (optnode) {
+      add_to_parse_tree(self, current, node->nd_opt, locals);
+    }
+    masgn_level--;
+  }  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_XSTR:             /* u1    (%x{ls}) */
+  case NODE_STR:              /* u1 */
+  case NODE_LIT:
+    rb_ary_push(current, node->nd_lit);
+    if (node->nd_cflag) {
+      rb_ary_push(current, INT2FIX(node->nd_cflag));
+    }
+    break;
+
+  case NODE_MATCH:            /* u1 -> [:lit, u1] */
+    {
+      rb_ary_push(current, wrap_into_node("lit", 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));
+    if (! RTEST(rb_iv_get(self, "\@include_newlines"))) {
+      rb_ary_pop(ary); /* nuke it */
+      node = node->nd_next;
+      goto again;
+    } else {
+      add_to_parse_tree(self, current, node->nd_next, locals);
+    }
+    break;
+
+  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(self, current, node->nd_head, locals);
+    break;
+
+  case NODE_ATTRASGN:           /* literal.meth = y u1 u2 u3 */
+    /* node id node */
+    if (node->nd_1st == RNODE(1)) {
+      add_to_parse_tree(self, current, NEW_SELF(), locals);
+    } else {
+      add_to_parse_tree(self, current, node->nd_1st, locals);
+    }
+    rb_ary_push(current, ID2SYM(node->u2.id));
+    add_to_parse_tree(self, current, node->nd_3rd, locals);
+    break;
+
+  case NODE_EVSTR:
+    add_to_parse_tree(self, current, node->nd_2nd, locals);
+    break;
+
+  case NODE_POSTEXE:            /* END { ... } */
+    /* Nothing to do here... we are in an iter block */
+    break;
+
+  case NODE_CFUNC:
+  case NODE_IFUNC:
+    rb_ary_push(current, INT2NUM((long)node->nd_cfnc));
+    rb_ary_push(current, INT2NUM(node->nd_argc));
+    break;
+
+#if RUBY_VERSION_CODE >= 190
+  case NODE_ERRINFO:
+  case NODE_VALUES:
+  case NODE_PRELUDE:
+  case NODE_LAMBDA:
+    puts("no worky in 1.9 yet");
+    break;
+#endif
+
+  /* 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_CREF:
+  /* #defines: */
+  /* case NODE_LMASK: */
+  /* case NODE_LSHIFT: */
+  default:
+    rb_warn("Unhandled node #%d type '%s'", nd_type(node), rb_id2name(SYM2ID(rb_ary_entry(node_names, 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", (void*)node->nd_1st, (void*)node->nd_2nd, (void*)node->nd_3rd);
+    rb_ary_push(current, INT2FIX(-99));
+    rb_ary_push(current, INT2FIX(nd_type(node)));
+    break;
+  }
+}
+@ # end of add_to_parse_tree block
+
+    builder.c %Q{
+static VALUE parse_tree_for_meth(VALUE klass, VALUE method, VALUE is_cls_meth) {
+  VALUE n;
+  NODE *node = NULL;
+  ID id;
+  VALUE result = rb_ary_new();
+  VALUE version = rb_const_get_at(rb_cObject,rb_intern("RUBY_VERSION"));
+
+  (void) self; /* quell warnings */
+
+  if (strcmp(StringValuePtr(version), #{RUBY_VERSION.inspect})) {
+    rb_fatal("bad version, %s != #{RUBY_VERSION}\\n", StringValuePtr(version));
+  }
+
+  id = rb_to_id(method);
+  if (RTEST(is_cls_meth)) { /* singleton method */
+    klass = CLASS_OF(klass);
+  }
+  if (st_lookup(RCLASS(klass)->m_tbl, id, &n)) {
+    node = (NODE*)n;
+    rb_ary_push(result, ID2SYM(rb_intern(is_cls_meth ? "defs": "defn")));
+    if (is_cls_meth) {
+      rb_ary_push(result, rb_ary_new3(1, ID2SYM(rb_intern("self"))));
+    }
+    rb_ary_push(result, ID2SYM(id));
+    add_to_parse_tree(self, result, node->nd_body, NULL);
+  } else {
+    rb_ary_push(result, Qnil);
+  }
+
+  return result;
+}
+}
+
+    extern_mode = RUBY_PLATFORM =~ /mswin/ ? 'RUBY_EXTERN' : 'extern'
+    builder.prefix " #{extern_mode} NODE *ruby_eval_tree_begin; " \
+      if RUBY_VERSION < '1.9.0'
+
+    # FIXME: ruby_in_eval is not properly exported across platforms
+    # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/13558
+    builder.c %Q{
+static VALUE parse_tree_for_str(VALUE source, VALUE filename, VALUE line) {
+  VALUE tmp;
+  VALUE result = rb_ary_new();
+  NODE *node = NULL;
+  int critical;
+
+  tmp = rb_check_string_type(filename);
+  if (NIL_P(tmp)) {
+    filename = rb_str_new2("(string)");
+  }
+
+  if (NIL_P(line)) {
+    line = LONG2FIX(1);
+  }
+
+  ruby_nerrs = 0;
+  StringValue(source);
+  critical = rb_thread_critical;
+  rb_thread_critical = Qtrue;
+  ruby_in_eval++;
+  node = rb_compile_string(StringValuePtr(filename), source, NUM2INT(line));
+  ruby_in_eval--;
+  rb_thread_critical = critical;
+
+  if (ruby_nerrs > 0) {
+    ruby_nerrs = 0;
+#if RUBY_VERSION_CODE < 190
+    ruby_eval_tree_begin = 0;
+#endif
+    rb_exc_raise(ruby_errinfo);
+  }
+
+  add_to_parse_tree(self, result, node, NULL);
+
+  return result;
+}
+}
+
+  end # inline call
+end # RawParseTree class
+
+class ParseTree < RawParseTree
+  ##
+  # Initializes a ParseTree instance. Includes newline nodes if
+  # +include_newlines+ which defaults to +$DEBUG+.
+
+  def initialize(include_newlines=$DEBUG)
+    super
+    @unifier = Unifier.new
+  end
+
+  ##
+  # Main driver for ParseTree. Returns a Sexp instance containing the
+  # AST representing the input given. This is a UnifiedRuby sexp, not
+  # a raw sexp from ruby. If you want raw, use the old
+  # parse_tree_for_xxx methods... Please tell me if/why you want raw,
+  # I'd like to know so I can justify keeping the code around.
+
+  def process(input, verbose = nil, file = "(string)", line = -1)
+    case input
+    when Array then
+      @unifier.process(input)
+    when String then
+      pt = self.parse_tree_for_string(input, file, line, verbose).first
+      @unifier.process(pt)
+    else
+      raise ArgumentError, "Unknown input type #{input.inspect}"
+    end
+  end
+end