linecache 0.41-mswin32

data/NEWS

@@ -0,0 +1,25 @@
+0.41 
+- add test/data/* to gem.
+
+0.4
+- Credit Ryan Davis and ParseTree.
+
+0.3
+- Add tracelines: get line numbers that can be stopped at.
+
+- Add routines to allow line-number 
+  remapping and filename remapping. 
+
+- Add access methods to get the number of lines in a file.
+
+0.2
+- Make this work with ruby-debug-base. Add reload-on-change parameters.
+  add checkcache, cache, cached? sha1, and stat methods. 
+  
+- Use SCRIPT_LINES__.
+
+0.1
+
+- Initial release of LineCache, a module for reading and caching lines.
+
+$Id: NEWS 119 2008-04-10 20:06:39Z rockyb $

data/README

@@ -0,0 +1,38 @@
+= LineCache - Module to read and cache lines of a file
+
+== Summary
+
+  require 'linecache'
+  lines = LineCache::getlines('/tmp/myruby.rb')
+  # The following lines have same effect as the above.
+  $: << '/tmp'
+  Dir.chdir('/tmp') {lines = LineCache::getlines('myruby.rb')
+
+  line = LineCache::getline('/tmp/myruby.rb', 6)
+  # Note lines[6] == line (if /tmp/myruby.rb has 6 lines)
+
+  LineCache::clear_file_cache
+  LineCache::clear_file_cache('/tmp/myruby.rb')
+  LineCache::update_cache   # Check for modifications of all cached files.
+
+== Credits
+
+  This is a port of the module of the same name from the Python distribution.
+
+  The idea for how TraceLineNumbers works, and some code was taken
+  from ParseTree by Ryan Davis.
+
+== Other stuff
+
+Author::   Rocky Bernstein <rockyb@rubyforge.net>
+License::  Copyright (c) 2007, 2008 Rocky Bernstein
+           Released under the GNU GPL 2 license
+
+== Warranty
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+$Id: README 63 2008-03-04 22:47:26Z rockyb $

data/Rakefile

@@ -0,0 +1,162 @@
+#!/usr/bin/env rake
+# -*- Ruby -*-
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+SO_NAME = "trace_nums.so"
+
+# ------- Default Package ----------
+PKG_VERSION = open(File.join(File.dirname(__FILE__), 'VERSION')) do 
+  |f| f.readlines[0].chomp
+end
+PKG_NAME           = 'linecache'
+PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
+RUBY_FORGE_PROJECT = 'rocky-hacks'
+RUBY_FORGE_USER    = 'rockyb'
+
+FILES = FileList[
+  'AUTHORS',
+  'COPYING',
+  'ChangeLog',
+  'NEWS',
+  'README',
+  'Rakefile',
+  'VERSION',
+  'ext/trace_nums.*',
+  'ext/extconf.rb',
+  'lib/*.rb',
+  'test/*.rb',
+  'test/data/*.rb',
+  'test/short-file'
+]                        
+
+desc "Test everything."
+test_task = task :test => :lib do 
+  Rake::TestTask.new(:test) do |t|
+    t.pattern = 'test/test-*.rb'
+    t.verbose = true
+  end
+end
+
+desc "Create the core ruby-debug shared library extension"
+task :lib do
+  Dir.chdir("ext") do
+    system("#{Gem.ruby} extconf.rb && make")
+  end
+end
+
+
+desc "Test everything - same as test."
+task :check => :test
+
+desc "Create a GNU-style ChangeLog via svn2cl"
+task :ChangeLog do
+  system("svn2cl --authors=svn2cl_usermap")
+end
+
+# Base GEM Specification
+default_spec = Gem::Specification.new do |spec|
+  spec.name = "linecache"
+  
+  spec.homepage = "http://rubyforge.org/projects/rocky-hacks/linecache"
+  spec.summary = "Read file with caching"
+  spec.description = <<-EOF
+LineCache is a module for reading and caching lines. This may be useful for
+example in a debugger where the same lines are shown many times.
+EOF
+
+  spec.version = PKG_VERSION
+
+  spec.author = "R. Bernstein"
+  spec.email = "rockyb@rubyforge.net"
+  spec.platform = Gem::Platform::RUBY
+  spec.require_path = "lib"
+  spec.files = FILES.to_a  
+
+  spec.required_ruby_version = '>= 1.8.2'
+  spec.date = Time.now
+  spec.rubyforge_project = 'rocky-hacks'
+  
+  # rdoc
+  spec.has_rdoc = true
+  spec.extra_rdoc_files = ['README', 'lib/linecache.rb', 'lib/tracelines.rb']
+end
+
+# Rake task to build the default package
+  Rake::GemPackageTask.new(default_spec) do |pkg|
+  pkg.need_tar = true
+end
+
+task :default => [:test]
+
+# Windows specification
+win_spec = default_spec.clone
+win_spec.extensions = []
+## win_spec.platform = Gem::Platform::WIN32 # deprecated
+win_spec.platform = 'mswin32'
+win_spec.files += ["lib/#{SO_NAME}"]
+
+desc "Create Windows Gem"
+task :win32_gem do
+  # Copy the win32 extension the top level directory.
+  current_dir = File.expand_path(File.dirname(__FILE__))
+  source = File.join(current_dir, "ext", "win32", SO_NAME)
+  target = File.join(current_dir, "lib", SO_NAME)
+  cp(source, target)
+
+  # Create the gem, then move it to pkg.
+  Gem::Builder.new(win_spec).build
+  gem_file = "#{win_spec.name}-#{win_spec.version}-#{win_spec.platform}.gem"
+  mv(gem_file, "pkg/#{gem_file}")
+
+  # Remove win extension from top level directory.
+  rm(target)
+end
+
+desc "Publish linecache to RubyForge."
+task :publish do 
+  require 'rake/contrib/sshpublisher'
+  
+  # Get ruby-debug path.
+  ruby_debug_path = File.expand_path(File.dirname(__FILE__))
+
+  publisher = Rake::SshDirPublisher.new("rockyb@rubyforge.org",
+        "/var/www/gforge-projects/rocky-hacks/linecache", ruby_debug_path)
+end
+
+desc "Remove built files"
+task :clean => [:clobber_package, :clobber_rdoc] do
+  cd "ext" do
+    if File.exists?("Makefile")
+      sh "make clean"
+      rm  "Makefile"
+    end
+    derived_files = Dir.glob(".o") + Dir.glob("*.so")
+    rm derived_files unless derived_files.empty?
+  end
+end
+
+# ---------  RDoc Documentation ------
+desc "Generate rdoc documentation"
+Rake::RDocTask.new("rdoc") do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "linecache"
+  # Show source inline with line numbers
+  rdoc.options << "--inline-source" << "--line-numbers"
+  # Make the readme file the start page for the generated html
+  rdoc.options << '--main' << 'README'
+  rdoc.rdoc_files.include('ext/**/*.c',
+                          'lib/*.rb', 
+                          'README', 
+                          'COPYING')
+end
+
+desc "Publish the release files to RubyForge."
+task :rubyforge_upload do
+  `rubyforge login`
+  release_command = "rubyforge add_release #{PKG_NAME} #{PKG_NAME} '#{PKG_NAME}-#{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.gem"
+  puts release_command
+  system(release_command)
+end

data/VERSION

@@ -0,0 +1 @@
+0.41

data/ext/extconf.rb

@@ -0,0 +1,16 @@
+require "mkmf"
+
+if RUBY_VERSION >= "1.9"
+  STDERR.print("Can't handle 1.9.x yet\n")
+  exit(1)
+elsif RUBY_VERSION >= "1.8"
+  if RUBY_RELEASE_DATE < "2005-03-22"
+    STDERR.print("Ruby version is too old\n")
+    exit(1)
+  end
+else
+  STDERR.print("Ruby version is too old\n")
+  exit(1)
+end
+
+create_makefile("trace_nums")

data/ext/trace_nums.c

@@ -0,0 +1,716 @@
+/*
+   This code creates module TraceLineNumbers with one method
+   lnums_for_str.  lnums_for_str returns an array lines for which
+   RUBY_EVENT_LINE can be called on. In other words, the line numbers
+   that can be traced (such as via Tracer) or stopped at in a
+   debugger (such as ruby-debug).
+
+   This code has been tested on Ruby 1.8.6; it does not work on Ruby
+   1.9.x.  The code was created via culling from various sources. 
+
+   Ruby 1.8's eval.c, and rb_eval() in particular, is the definitive
+   source of how the tree is evaluated. However we don't want to
+   actually evaluate the code, which simplifies things. In contrast,
+   we need lines for all branches, and not just the ones that get
+   executed on a given run.  For example in an "if" node the "then"
+   part may or may not get executed, but we want to get the trace line
+   numbers for the "then" part regardless. 
+
+   Code enclosed in the ***'s contains code from eval.c which is
+   included for comparison.
+
+   Also parse.y from Ruby 1.8 can shed light on how the nodes get
+   created.
+
+   Some legacy code in ParseTree is similar and necessarily more
+   complex. We would have used that gem from the outside and lived
+   with the additional bloat were it not broken for our purposes and
+   were it not for the author's lack of interest in extending it to
+   handle what's needed here.
+
+   Finally, node_help.txt from nodewrap contains descriptions of many
+   of the node types.
+*/
+#include <ruby.h>
+#include <version.h>
+#include <node.h>
+#include <env.h>
+#include <rubysig.h>
+#include "trace_nums.h"
+
+VALUE mTraceLineNumbers;
+extern NODE *ruby_eval_tree_begin;
+
+#define nd_3rd   u3.node
+
+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;
+};
+
+#define RETURN					\
+  goto finish
+
+#define EVENT_LINE(node)			\
+  rb_ary_push(ary, INT2NUM(nd_line(node)))
+
+#ifdef FINISHED
+#define EVENT_CALL(node)			\
+  rb_ary_push(ary, INT2NUM(nd_line(node)))
+#else
+#define EVENT_CALL(node)
+#endif
+
+/* Used just in debugging. */
+static indent_level = 0;
+
+static
+void ln_eval(VALUE self, NODE * n, VALUE ary) {
+  NODE * volatile contnode = 0;
+  NODE * volatile node = n;
+
+  if (RTEST(ruby_debug)) {
+    char fmt[30] = { '\0', };
+    snprintf(fmt, sizeof(fmt), "%%%ds", indent_level+1);
+    fprintf(stderr, fmt, "[");
+    indent_level += 2;
+  }
+
+ again:
+  if (!node) RETURN;
+
+  if (RTEST(ruby_debug)) {
+    NODE *r = RNODE(node); /* For debugging */
+    fprintf(stderr, "%s ", NODE2NAME[nd_type(node)]);
+  }
+
+  switch (nd_type(node)) {
+  case NODE_BLOCK:
+    while (node) {
+      ln_eval(self, node->nd_head, ary);
+      node = node->nd_next;
+    }
+
+  case NODE_POSTEXE: /* END { ... } */
+    /* Nothing to do here... we are in an iter block */
+    /*** 
+	rb_f_END();
+	nd_set_type(node, NODE_NIL); /+ exec just once +/
+	result = Qnil;
+    ***/
+    break;
+
+    /* begin .. end without clauses */
+  case NODE_BEGIN:
+    /* node for speed-up(top-level loop for -n/-p) */
+    node = node->nd_body;
+    goto again;
+
+    /* nodes for speed-up(default match) */
+  case NODE_MATCH:
+    /* result = rb_reg_match2(node->nd_lit); */
+    break;
+
+    /* nodes for speed-up(literal match) */
+  case NODE_MATCH2:
+    /* l = */ ln_eval(self, node->nd_recv, ary); 
+    /* r = */ ln_eval(self, node->nd_value, ary); 
+    /*** result = rb_reg_match(l, r); ***/
+    break;
+
+    /* nodes for speed-up(literal match) */
+  case NODE_MATCH3: /* z =~ /"#{var}"/ for example */
+    /* r = */ ln_eval(self, node->nd_recv, ary);
+    /* l = */ ln_eval(self, node->nd_value, ary); 
+    /***
+	if (TYPE(l) == T_STRING) {
+	result = rb_reg_match(r, l);
+	}
+	else {
+	// It is possible that value can be a function call which
+	// can trigger an call event. So to be conservative, 
+	// we have to add a line number here.
+	result = rb_funcall(l, match, 1, r);
+	}
+    ****/
+    EVENT_CALL(node);
+    break;
+
+    /* node for speed-up(top-level loop for -n/-p) */
+  case NODE_OPT_N:
+    /* Lots of ugliness in eval.c.  */
+    ln_eval(self, node->nd_body, ary); 
+    break;
+
+  /* These nodes are empty. */
+  case NODE_SELF:
+  case NODE_NIL:
+  case NODE_TRUE:
+  case NODE_FALSE:
+    RETURN /* (something) */;
+
+  case NODE_IF:
+    EVENT_LINE(node);
+    ln_eval(self, node->nd_cond, ary);
+    if (node->nd_body) {
+      if (!node->nd_else) {
+	node = node->nd_body;
+	goto again;
+      }
+      ln_eval(self, node->nd_body, ary);
+    }
+    if (node->nd_else) {
+      node = node->nd_else;
+      goto again;
+    }
+    break;
+
+  case NODE_WHEN: 
+    {
+      NODE *orig_node = node;
+      while (node) {
+	NODE *tag;
+	
+	if (nd_type(node) != NODE_WHEN) goto again;
+	tag = node->nd_head;
+	while (tag) {
+	  EVENT_LINE(tag);
+	  if (tag->nd_head && nd_type(tag->nd_head) == NODE_WHEN) {
+	    ln_eval(self, tag->nd_head->nd_head, ary);
+	  }
+	  tag = tag->nd_next;
+	}
+	node = node->nd_next;
+      }
+      if (orig_node->nd_body) {
+	ln_eval(self, orig_node->nd_body, ary); /* body */
+      }
+      RETURN /***(Qnil)***/ ;
+    }
+
+  case NODE_CASE:
+    ln_eval(self, node->nd_head, ary); /* expr */
+    node = node->nd_body;
+    while (node) {
+      NODE *tag;
+      if (nd_type(node) != NODE_WHEN) {
+	goto again;
+      }
+      tag = node->nd_head;
+      while (tag) {
+	EVENT_LINE(tag);
+	if (tag->nd_head && nd_type(tag->nd_head) == NODE_WHEN) {
+	  ln_eval(self, tag->nd_head->nd_head, ary);
+	  tag = tag->nd_next;
+	  continue;
+	}
+	ln_eval(self, tag->nd_head, ary);
+	tag = tag->nd_next;
+      }
+      ln_eval(self, node->nd_body, ary);
+      node = node->nd_next;
+    }
+    RETURN /***(Qnil)***/;
+
+  case NODE_WHILE:
+  case NODE_UNTIL:
+    /* Doesn't follow eval.c */
+    ln_eval(self, node->nd_cond, ary);
+    if (node->nd_body) {
+      ln_eval(self, node->nd_body, ary);
+    }
+    break;
+
+  case NODE_BLOCK_PASS:
+    /*** result = block_pass(self, node); ***/
+    ln_eval(self, node->nd_body, ary);
+    ln_eval(self, node->nd_iter, ary);
+    break;
+
+  case NODE_ITER:
+  case NODE_FOR:
+    ln_eval(self, node->nd_iter, ary);
+    if (node->nd_var != (NODE *)1
+        && node->nd_var != (NODE *)2
+        && node->nd_var != NULL) {
+      ln_eval(self, node->nd_var, ary);
+    } 
+    node = node->nd_body;
+    goto again;
+
+  case NODE_BREAK:
+    /* break_jump(rb_eval(self, node->nd_stts)); */
+    ln_eval(self, node->nd_stts, ary);
+    break;
+    
+  case NODE_NEXT:
+    /*** CHECK_INTS;
+	 next_jump(rb_eval(self, node->nd_stts)); ***/
+    ln_eval(self, node->nd_stts, ary);
+    break;
+
+  case NODE_REDO:
+    /*** CHECK_INTS;
+	 JUMP_TAG(TAG_REDO); ***/
+    break;
+
+  case NODE_RETRY:
+    /*** CHECK_INTS;
+	 JUMP_TAG(TAG_RETRY); ***/
+    break;
+
+  case NODE_SPLAT:
+    /*** result = splat_value(rb_eval(self, node->nd_head)); ***/
+    ln_eval(self, node->nd_head, ary);
+    break;
+
+  case NODE_TO_ARY:
+    /*** result = rb_ary_to_ary(rb_eval(self, node->nd_head)); ***/
+    ln_eval(self, node->nd_head, ary);
+    break;
+
+  case NODE_SVALUE:             /* a = b, c */
+    /***
+	result = avalue_splat(rb_eval(self, node->nd_head));
+	if (result == Qundef) result = Qnil; ***/
+    ln_eval(self, node->nd_head, ary);
+    break;
+
+  case NODE_YIELD:
+    if (node->nd_head) {
+      /*** result = rb_eval(self, node->nd_head);
+	   ruby_current_node = node; else ... ***/
+      ln_eval(self, node->nd_head, ary);
+    }
+    break;
+
+  case NODE_RESCUE:
+    /* Follow ruby_parse.rb and pray for the best. */
+    ln_eval(self, node->nd_1st, ary);
+    ln_eval(self, node->nd_2nd, ary);
+    ln_eval(self, node->nd_3rd, ary);
+    break;
+
+  case NODE_ENSURE:
+    ln_eval(self, node->nd_head, ary);
+    if (node->nd_ensr) {
+      ln_eval(self, node->nd_ensr, ary);
+    }
+    break;
+
+  case NODE_AND:
+  case NODE_OR:
+    ln_eval(self, node->nd_1st, ary);
+    ln_eval(self, node->nd_2nd, ary);
+    break;
+
+  case NODE_NOT:
+    /*** if (RTEST(rb_eval(self, node->nd_body))) result = Qfalse;
+       else result = Qtrue; ***/
+    ln_eval(self, node->nd_body, ary); 
+    break;
+
+  case NODE_DOT2:
+  case NODE_DOT3:
+  case NODE_FLIP2:
+  case NODE_FLIP3:
+    ln_eval(self, node->nd_beg, ary);
+    ln_eval(self, node->nd_end, ary);
+    break;
+
+  case NODE_RETURN:
+    if (node->nd_stts)
+      ln_eval(self, node->nd_stts, ary);
+    break;
+
+  case NODE_ARGSCAT:
+  case NODE_ARGSPUSH:
+    ln_eval(self, node->nd_head, ary);
+    ln_eval(self, node->nd_body, ary);
+    break;
+
+  case NODE_ATTRASGN:           /* literal.meth = y u1 u2 u3 */
+    /* node id node */
+    if (node->nd_recv == (NODE *)1) {
+      ln_eval(self, NEW_SELF(), ary);
+    } else {
+      ln_eval(self, node->nd_recv, ary);
+    }
+    ln_eval(self, node->nd_3rd, ary);
+    break;
+  case NODE_CALL:
+  case NODE_FCALL:
+  case NODE_VCALL:
+    if (nd_type(node) != NODE_FCALL)
+      ln_eval(self, node->nd_recv, ary);
+    if (node->nd_args || nd_type(node) != NODE_FCALL)
+      ln_eval(self, node->nd_args, ary);
+    break;
+
+  case NODE_SUPER:
+    ln_eval(self, node->nd_args, ary);
+    break;
+
+  case NODE_ZSUPER:
+    break;
+
+  case NODE_SCOPE:
+    ln_eval(self, node->nd_next, ary);
+    break;
+
+  case NODE_OP_ASGN1:
+    ln_eval(self, node->nd_recv, ary);
+#if RUBY_VERSION_CODE < 185
+    ln_eval(self, node->nd_args->nd_next, ary);
+#else
+    ln_eval(self, node->nd_args->nd_2nd, ary);
+#endif
+    ln_eval(self, node->nd_args->nd_head, ary);
+    break;
+
+  case NODE_OP_ASGN2:
+    ln_eval(self, node->nd_recv, ary);
+    ln_eval(self, node->nd_value, ary);
+    break;
+
+  case NODE_OP_ASGN_AND:
+  case NODE_OP_ASGN_OR:
+    ln_eval(self, node->nd_head, ary);
+    ln_eval(self, node->nd_value, ary);
+    break;
+
+  case NODE_MASGN:
+    ln_eval(self, node->nd_head, ary);
+    if (node->nd_args) {
+      if (node->nd_args != (NODE *)-1) {
+        ln_eval(self, node->nd_args, ary);
+      }
+    }
+    ln_eval(self, node->nd_value, ary);
+    break;
+
+  case NODE_LASGN:
+  case NODE_DASGN:
+  case NODE_DASGN_CURR:
+  case NODE_GASGN:
+  case NODE_IASGN:
+  case NODE_CDECL:
+  case NODE_CVDECL:
+  case NODE_CVASGN:
+    ln_eval(self, node->nd_value, ary);
+    break;
+
+  case NODE_LVAR:
+  case NODE_DVAR:
+  case NODE_GVAR:
+  case NODE_IVAR:
+  case NODE_CONST:
+  case NODE_CVAR:
+    break;
+    
+  case NODE_BLOCK_ARG:        /* u1 u3 (def x(&b) */
+    break;
+
+  case NODE_COLON2:
+    ln_eval(self, node->nd_head, ary);
+    break;
+
+  case NODE_COLON3:           /* u2    (::OUTER_CONST) */
+    break;
+
+  case NODE_NTH_REF:          /* u2 u3 ($1) - u3 is local_cnt('~') ignorable? */
+    break;
+
+  case NODE_BACK_REF:         /* u2 u3 ($& etc) */
+    break;
+
+  case NODE_HASH:
+    {
+      NODE *list;
+      list = node->nd_head;
+      while (list) {
+        ln_eval(self, list->nd_head, ary);
+        list = list->nd_next;
+        if (list == 0)
+          rb_bug("odd number list for Hash");
+        ln_eval(self, list->nd_head, ary);
+        list = list->nd_next;
+      }
+    }
+    break;
+
+  case NODE_ZARRAY:
+    break;
+
+  case NODE_ARRAY:
+    {
+      long int i = node->nd_alen;
+      for (i=0; node; node=node->nd_next) {
+        ln_eval(self, node->nd_head, ary);
+      }
+    }
+    break;
+
+  case NODE_STR:              /* u1 */
+    break;
+
+  case NODE_EVSTR: /* eval of a string */
+    ln_eval(self, node->nd_2nd, ary);
+    break;
+
+  case NODE_DSTR:
+  case NODE_DXSTR:
+  case NODE_DREGX:
+  case NODE_DREGX_ONCE:
+  case NODE_DSYM:
+    {
+      NODE *list = node->nd_next;
+      while (list) {
+        if (list->nd_head) {
+          switch (nd_type(list->nd_head)) {
+          case NODE_STR:
+            ln_eval(self, list->nd_head, ary);
+            break;
+          case NODE_EVSTR:
+            ln_eval(self, list->nd_head, ary);
+            break;
+          default:
+            ln_eval(self, list->nd_head, ary);
+            break;
+          }
+        }
+        list = list->nd_next;
+      }
+    }
+    break;
+
+  case NODE_XSTR:             /* u1    (%x{ls}) */
+    /* Issues rb_funcall(self, '`'...). So I think we have to 
+     register a call event. */
+    EVENT_CALL(node);
+    break;
+    
+  case NODE_LIT:
+    break;
+
+  case NODE_DEFN:
+    ln_eval(self, node->nd_defn, ary);
+    break;
+
+  case NODE_DEFS:
+    if (node->nd_defn) {
+      ln_eval(self, node->nd_recv, ary);
+    }
+    ln_eval(self, node->nd_defn, ary);
+    break;
+
+  case NODE_UNDEF:            /* u2    (undef name, ...) */
+#if RUBY_VERSION_CODE >= 185
+    /*** ... 
+	 rb_undef(ruby_class, rb_to_id(rb_eval(self, node->u2.node))); 
+	 ...
+    ***/
+    ln_eval(self, node->u2.node, ary);
+#endif
+    break;
+
+  case NODE_ALIAS:            /* u1 u2 (alias :blah :blah2) */
+#if RUBY_VERSION_CODE >= 185
+    ln_eval(self, node->nd_1st, ary);
+    ln_eval(self, node->nd_2nd, ary);
+#endif
+    break;
+  case NODE_VALIAS:           /* u1 u2 (alias $global $global2) */
+    break;
+
+  case NODE_CLASS:
+    if (node->nd_super) {
+      ln_eval(self, node->nd_super, ary);
+    }
+    ln_eval(self, node->nd_body, ary);
+    break;
+
+  case NODE_MODULE:
+    ln_eval(self, node->nd_body, ary);
+    break;
+
+  case NODE_SCLASS:
+    ln_eval(self, node->nd_recv, ary);
+    ln_eval(self, node->nd_body, ary);
+    break;
+
+  case NODE_DEFINED:
+    ln_eval(self, node->nd_head, ary);
+    break;
+
+  case NODE_NEWLINE:
+    EVENT_LINE(node);
+    node = node->nd_next;
+    goto again;
+
+  case NODE_CFUNC:
+  case NODE_IFUNC:
+    break;
+
+#if RUBY_VERSION_CODE >= 190
+  case NODE_ERRINFO:
+  case NODE_VALUES:
+  case NODE_PRELUDE:
+  case NODE_LAMBDA:
+    rb_warn("Ruby 1.9 is very different. You shouldn't have gotten here.");
+    break;
+#endif
+
+  case NODE_BMETHOD: /* define_method (or rb_mod_define_method) with a block */
+    {
+      struct BLOCK *data;
+      Data_Get_Struct(node->nd_cval, struct BLOCK, data);
+      if (!(data->var == 0 || data->var == (NODE *)1 || 
+	    data->var == (NODE *)2)) {
+	/* block doesn't have args. */
+        ln_eval(self, data->var, ary);
+      }
+      ln_eval(self, data->body, ary);
+      break;
+    }
+    break;
+
+#if RUBY_VERSION_CODE < 190
+  case NODE_DMETHOD:
+    {
+      struct METHOD *data;
+      Data_Get_Struct(node->nd_cval, struct METHOD, data);
+      ln_eval(self, data->body, ary);
+      break;
+    }
+#endif
+
+  case NODE_METHOD:
+    ln_eval(self, node->nd_3rd, ary);
+    break;
+
+
+  case NODE_ARGS: {
+    if (node->nd_opt) {
+      ln_eval(self, node->nd_opt, ary);
+    }
+  }  break;
+
+  case NODE_ATTRSET:
+    break;
+
+  /*
+  // rescue body:
+  // begin stmt rescue exception => var; stmt; [rescue e2 => v2; s2;]* end
+  // stmt rescue stmt
+  // a = b rescue c
+  // NODE_RESBODY doesn't appear in 1.8.6's rb_eval
+  */
+  case NODE_RESBODY:
+      if (node->nd_3rd) {
+        ln_eval(self, node->nd_3rd, ary);
+      }
+      ln_eval(self, node->nd_2nd, ary);
+      ln_eval(self, node->nd_1st, ary);
+    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_CREF:
+  /* #defines: */
+  /* case NODE_LMASK: */
+  /* case NODE_LSHIFT: */
+
+  default:
+    rb_warn("Unhandled node '%s'", NODE2NAME[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);
+    break;
+  }
+  finish:
+    if (contnode) {
+	node = contnode;
+	contnode = 0;
+	goto again;
+    }
+    if (RTEST(ruby_debug)) {
+      char fmt[30] = { '\0', };
+      indent_level -= 2;
+      snprintf(fmt, sizeof(fmt), "%%%ds", indent_level+1);
+      fprintf(stderr, fmt, "]\n");
+    }
+
+} /* ln_eval */
+
+/* Return a list of trace hook line numbers for the string in Ruby source src*/
+static VALUE 
+lnums_for_str(VALUE self, VALUE src) {
+  VALUE result = rb_ary_new(); /* The returned array of line numbers. */
+  NODE *node = NULL;
+  int critical;
+
+  ruby_nerrs = 0;
+  StringValue(src); /* Check that src is a string. */
+
+  critical = rb_thread_critical;
+  rb_thread_critical = Qtrue;
+
+  /* Making ruby_in_eval nonzero signals rb_compile_string not to save
+     source in SCRIPT_LINES__. */
+  ruby_in_eval++; 
+  node = rb_compile_string("(numbers_for_str)", src, 1);
+  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);
+  }
+
+  if (RTEST(ruby_debug)) {
+    indent_level = 0;
+  }
+  ln_eval(self, node, result);
+  return result;
+}
+
+void Init_trace_nums(void)
+{
+    mTraceLineNumbers = rb_define_module("TraceLineNumbers");
+    rb_define_module_function(mTraceLineNumbers, "lnums_for_str", 
+			      lnums_for_str, 1);
+}