rb-threadframe 0.37 → 0.38

data/NEWS

@@ -1,3 +1,8 @@
+March 15, 2011 (0.38) Ron Frankel Release
+ - Add RubyVM::ThreadFrame.prev (same as RubyVM::ThreadFrame.current.prev)
+ - Allow access to a C method type
+ - Method extensions now included on UnboundMethods as well
+
 Feb 1, 2011 (0.37)
  - 1.9.2 patches:
    * Mark VM Instruction sequences for no garbage collection if they are

data/Rakefile

@@ -20,14 +20,14 @@ task :gem=>:gemspec do
   Dir.chdir(ROOT_DIR) do
     sh "gem build .gemspec"
     FileUtils.mkdir_p 'pkg'
-    FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", 'pkg'
+    FileUtils.mv("#{gemspec.file_name}", "pkg/")
   end
 end
 
 desc "Install the gem locally"
 task :install => :gem do
   Dir.chdir(ROOT_DIR) do
-    sh %{gem install --local pkg/#{gemspec.name}-#{gemspec.version}}
+    sh %{gem install --local pkg/#{gemspec.file_name}}
   end
 end
 
@@ -73,7 +73,7 @@ Rake::TestTask.new(:'test:unit') do |t|
   t.libs << './ext'
   t.test_files = FileList['test/unit/**/*.rb']
   # t.pattern = 'test/**/*test-*.rb' # instead of above
-  t.verbose = true
+  t.options = '--verbose' if $VERBOSE
 end
 task :'test:unit' => [:ext]
 

data/ext/proc_extra.c

@@ -49,9 +49,10 @@ extern rb_iseq_t *rb_method_get_iseq(VALUE method);
 
 #if 0  /* The following is to fake out rdoc, until I find a better fix. */
 /* 
- *  Additions to the RubyVM::Method class
+ *  Additions to the RubyVM::Method and RubyVM::UnboundMethod class
  */
 VALUE rb_cIseq = rb_define_class("Method", ...)
+VALUE rb_cIseq = rb_define_class("UnboundMethod", ...)
 #endif
 /* 
  *  call-seq:
@@ -70,6 +71,78 @@ method_iseq(VALUE self)
     return rb_iseq;
 }
 
+static void null_gc_proc(void *ptr) { }
+
+static size_t null_gc_memsize(const void *ptr) { }
+
+
+static const rb_data_type_t method_data_type = {
+    "method",
+    null_gc_proc,
+    null_gc_proc,
+    null_gc_memsize,
+};
+
+static inline rb_method_definition_t *
+method_get_def(VALUE method)
+{
+    /* FIXME: use
+       struct METHOD *data;
+       TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
+    */
+    struct METHOD *data = (struct METHOD *)DATA_PTR(method);
+    return data->me.def;
+}
+
+/* 
+ *  call-seq:
+ *  Method#type -> String
+ * 
+ *  Returns the Method object.
+ */
+VALUE
+method_type(VALUE self)
+{
+    rb_method_definition_t *def = method_get_def(self);
+    const char *type_str;
+    switch (def->type) {
+      case VM_METHOD_TYPE_ISEQ: 
+	type_str = "instruction sequence";
+	break;
+      case VM_METHOD_TYPE_CFUNC: 
+	type_str = "C function";
+	break;
+      case VM_METHOD_TYPE_ATTRSET:
+	type_str = "attrset";
+	break;
+      case VM_METHOD_TYPE_IVAR:
+	type_str = "ivar";
+	break;
+      case VM_METHOD_TYPE_BMETHOD:
+	type_str = "bmethod";
+	break;
+      case VM_METHOD_TYPE_ZSUPER:
+	type_str = "zsuper";
+	break;
+      case VM_METHOD_TYPE_UNDEF:
+	type_str = "undefined";
+	break;
+      case VM_METHOD_TYPE_NOTIMPLEMENTED:
+	type_str = "not implemented";
+	break;
+      case VM_METHOD_TYPE_OPTIMIZED: /* Kernel#send, Proc#call, etc */
+	type_str = "optimized";
+	break;
+      case VM_METHOD_TYPE_MISSING: /* wrapper for method_missing(id) */
+	type_str = "type missing";
+	break;
+      default:
+	type_str = "unknown";
+	break;
+    }
+    return rb_str_new2(type_str);
+}
+
 /* 
  *  call-seq:
  *  Method#alias_count -> Fixnum
@@ -102,7 +175,12 @@ Init_proc_extra(void)
     rb_define_method(rb_cProc,   "iseq",  proc_iseq, 0);
 
     /* Additions to Method */
-    rb_define_method(rb_cMethod, "iseq",  method_iseq, 0);
     rb_define_method(rb_cMethod, "alias_count",  method_alias_count, 0);
+    rb_define_method(rb_cMethod, "iseq",         method_iseq, 0);
     rb_define_method(rb_cMethod, "original_id",  method_original_id, 0);
+    rb_define_method(rb_cMethod, "type",         method_type, 0);
+
+    rb_define_method(rb_cUnboundMethod, "alias_count",  method_alias_count, 0);
+    rb_define_method(rb_cUnboundMethod, "original_id",  method_original_id, 0);
+    rb_define_method(rb_cUnboundMethod, "type",         method_type, 0);
 }

data/ext/thread_frame.c

@@ -6,7 +6,7 @@
  */
 
 /* What release we got? */
-#define THREADFRAME_VERSION "0.37"
+#define THREADFRAME_VERSION "0.38"
 
 #include <string.h>
 #include "../include/vm_core_mini.h"   /* Pulls in ruby.h and node.h */
@@ -114,7 +114,11 @@ tf_free(void *ptr)
     thread_frame_t *tf;
     if (ptr) {
 	tf = ptr;
-	if (RUBY_VM_NORMAL_ISEQ_P(tf->cfp->iseq)) 
+	/* All valid frame types have 0x1 set so we will use this.
+	   Warning: this is an undocumented assumption which may someday
+	   be wrong. */
+	if (tf->cfp && ((tf->cfp->flag & 0x1) == 0) && 
+	    RUBY_VM_NORMAL_ISEQ_P(tf->cfp->iseq)) 
 	    tf->cfp->iseq->in_use--;
 	xfree(ptr);
     }
@@ -812,44 +816,93 @@ thread_frame_s_current(VALUE klass)
 /*
  *  call-seq:
  *     RubyVM::ThreadFrame::prev(thread)     -> threadframe_object
- *     RubyVM::ThreadFrame::prev(thread, n)   -> threadframe_object
+ *     RubyVM::ThreadFrame::prev(thread, n)  -> threadframe_object
+ *     RubyVM::ThreadFrame::prev             -> threadframe_object
+ *     RubyVM::ThreadFrame::prev(n)          -> threadframe_object
+ *
+ *  In the first form, we return a RubyVM::ThreadFrame prior to the
+ *  Thread object passed. That is we go back one frame from the
+ *  current frfame.
+ *
+ *  In the second form we try to go back that many thread frames. 
+ *
+ *  In the the third form, the current thread is assumed, and like the
+ *  first form we go back one frame.
+ * 
+ *  The fourth form, like the third form, we assume the current
+ *  thread.  And like the first form we go back we try to back a
+ *  FixNum number of entries.
+ *
+ *  When count +n+ is given 1 is synonymous with the previous frame
+ *  and 0 is invalid. If the +n+ is negative, we count from the bottom
+ *  of the frame stack.
+ *
+ *  In all cases we return a RubyVM::ThreadFrame or nil if we can't 
+ *  go back (or forward for a negative +n+) that many frames. 
  *
- *  Returns a RubyVM::ThreadFrame for the frame prior to the
- *  Thread object passed or nil if there is none. The default value for n
- *  is 1. 0 just returns the object passed.
- *  Negative counts or counts exceeding the stack will return nil.
  */
 static VALUE
 thread_frame_s_prev(int argc, VALUE *argv, VALUE klass)
 {
-    VALUE thval;
-    VALUE nv;
-    int n;
-  
-    rb_scan_args(argc, argv, "11", &thval, &nv);
-
-    if (Qfalse == rb_obj_is_kind_of(thval, rb_cThread))
-	rb_raise(rb_eTypeError, 
-		 "ThreadFrame object needed for first argument");
-
-    GET_THREAD_PTR ;
+    VALUE first_val;
+    VALUE second_val;
+    VALUE thval = Qnil;
+    int   prev_count = 0;
+    rb_thread_t *th = NULL;
+
+    /* Such complicated options processing. But we do want this
+       routine to be convenient. */
+    rb_scan_args(argc, argv, "02", &first_val, &second_val);
+    switch (argc) {
+      case 0:
+	th = ruby_current_thread;
+        /* Do'nt count the RubyVM::ThreadFrame.prev call */
+	prev_count = 2; 
+	break;
+      case 1:
+	if (FIXNUM_P(first_val)) {
+	    prev_count = FIX2INT(first_val);
+	    if (prev_count > 0) prev_count++ ;
+	    th = ruby_current_thread;
+	} else 
+	    if (Qtrue == rb_obj_is_kind_of(first_val, rb_cThread)) {
+		GetThreadPtr(first_val, th);
+               /* Don't count the RubyVM::ThreadFrame.prev call */
+		prev_count = 1; 
+	    } else {
+		rb_raise(rb_eTypeError, 
+			 "FixNum or ThreadFrame object expected for first argument");
+	    }
+	break;
+      case 2: 
+	if (Qtrue == rb_obj_is_kind_of(first_val, rb_cThread)) {
+	    GetThreadPtr(first_val, th);
+	} else {
+	    rb_raise(rb_eTypeError, 
+		     "ThreadFrame object expected for first argument");
+	}
+	if (FIXNUM_P(second_val)) {
+	    prev_count = FIX2INT(second_val);
+	} else 
+	    rb_raise(rb_eTypeError, 
+		     "FixNum previous count expected for second argument");
+	break;
+      default:
+	rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
+    }
     
-    if (Qnil == nv)
-	n = 1;
-    else if (!FIXNUM_P(nv)) {
-	rb_raise(rb_eTypeError, "Fixnum needed for second argument");
-    } else
-	n = FIX2INT(nv);
+    if (0 == prev_count) {
+	rb_raise(rb_eArgError, 
+		 "previous count can not be 0. Use current instead of prev");
+    }
 
-    if (n == 0) { 
-	return thread_frame_s_current(klass);
-    } else if (n < 0) {
+    if (0 > prev_count) {
       int stack_size = thread_frame_stack_size_internal(th->cfp, th);
-      if (-n > stack_size) return Qnil;
-      n = stack_size + n;
+      if (-prev_count > stack_size) return Qnil;
+      prev_count = stack_size + prev_count;
     }
 
-    return thread_frame_prev_internal(th->cfp, th, n);
+    return thread_frame_prev_internal(th->cfp, th, prev_count);
 }
 
 /*

data/ext/thread_frame.h

@@ -0,0 +1,4 @@
+VALUE thread_frame_sp(VALUE klass, VALUE index) ;
+VALUE thread_frame_prev(int argc, VALUE *argv, VALUE klass);
+
+

data/test/unit/test-argc.rb

@@ -23,7 +23,7 @@ class TestARGC < Test::Unit::TestCase
     all_events = []
     eval <<-EOF.gsub(/^.*?: /, "")
      1: set_trace_func(Proc.new { |event, file, lineno, mid, binding, klass|
-     2:   tf = RubyVM::ThreadFrame.current.prev(1)
+     2:   tf = RubyVM::ThreadFrame.prev
      3:   all_events << [tf.argc, tf.arity, tf.type, mid]
      4:   if :basename == mid 
      5:     events << [tf.argc, tf.arity, tf.type, mid]

data/test/unit/test-prev.rb

@@ -21,18 +21,26 @@ class TestThread < Test::Unit::TestCase
 
   def test_prev
 
-    assert RubyVM::ThreadFrame::prev(Thread::current, 0)
-    assert(RubyVM::ThreadFrame::prev(Thread::current, 2),
-           'There should be at least two prior frames')
+    assert RubyVM::ThreadFrame::prev(Thread::current, 1),
+                                     'should allow 2-arg prev'
+    assert RubyVM::ThreadFrame::prev(Thread::current),
+                                     'should allow 1-arg thread prev'
+    assert(RubyVM::ThreadFrame::prev(2),
+           'There should be at least two prior frames in single Fixnum prev')
 
     top_frame = RubyVM::ThreadFrame::prev(Thread::current, -1)
-    assert(top_frame, 'Should give back the top frame')
+    assert(top_frame, 'Should give back the top frame for two arg and -1')
+    assert_equal('TOP', top_frame.type,
+                 'The type of the top frame should be "TOP"')
+
+    top_frame = RubyVM::ThreadFrame::prev(-1)
+    assert(top_frame, 'Should give back the top frame for one arg and -1')
     assert_equal('TOP', top_frame.type,
                  'The type of the top frame should be "TOP"')
 
     assert_equal(nil, RubyVM::ThreadFrame::prev(Thread::current, 1000))
 
-    tf = RubyVM::ThreadFrame::current.prev
+    tf = RubyVM::ThreadFrame.prev
 
     assert tf.prev(2)
     assert_equal(tf,  tf.prev(0), 
@@ -43,6 +51,9 @@ class TestThread < Test::Unit::TestCase
     assert_raises TypeError do
       tf.prev('a')
     end
+    assert_raises ArgumentError do
+      tf.prev(RubyVM::ThreadFrame::current, 1, 'bad_arg')
+    end
     assert_raises TypeError do
       RubyVM::ThreadFrame::prev([1])
     end

data/test/unit/test-proc.rb

@@ -19,5 +19,9 @@ class TestProcAndMethod < Test::Unit::TestCase
     assert_equal(3, m.alias_count)
     assert_equal(4, self.method(:two).alias_count)
     assert_equal(:test_method_extra, self.method(:two).original_id)
+    assert_equal("instruction sequence", method(:test_method_extra).type)
+    assert_equal("C function", File.method(:basename).type)
+    # Array.map is an unbound method
+    assert_equal("C function", Array.instance_method(:map).type)
   end
 end

data/test/unit/test-settracefunc.rb

@@ -45,10 +45,13 @@ class TestSetTraceFunc < Test::Unit::TestCase
      5: set_trace_func(nil)
     EOF
 
-    expected = [[4, 'line',     __method__, self.class],
+    expected = [
+                [4, 'line',     __method__, self.class],
+                [4, 'send',     __method__, self.class],
                 [4, "c-call",   :+,         Fixnum],
                 [4, "c-return", :+,         Fixnum],
                 [5, "line",     __method__, self.class],
+                [5, "send",     __method__, self.class],
                 [5, "c-call",   :set_trace_func, Kernel]]
     checkit(@events, expected)
   end
@@ -65,17 +68,25 @@ class TestSetTraceFunc < Test::Unit::TestCase
      8: set_trace_func(nil)
     EOF
 
-    expected = [[4, 'line',     __method__,    self.class],
-                [4, 'c-call',   :method_added, Module],
-                [4, 'c-return', :method_added, Module],
-                [7, 'line',     __method__,    self.class],
-                [4, 'call',     :add,          self.class],
-                [5, 'line',     :add,          self.class],
-                [5, 'c-call',   :+,            Fixnum],
-                [5, 'c-return', :+,            Fixnum],
-                [6, 'return',   :add,          self.class],
-                [8, 'line',      __method__,   self.class],
-                [8, 'c-call',   :set_trace_func, Kernel]]
+    expected = 
+      [
+       [4, 'line',     __method__,    self.class],
+       [4, 'send',     __method__,    self.class],
+       [4, 'c-call',   :method_added, Module],
+       [4, 'c-return', :method_added, Module],
+       [7, 'line',     __method__,    self.class],
+       [7, 'send',     __method__,    self.class],
+       [4, 'call',     :add,          self.class],
+       [5, 'line',     :add,          self.class],
+       [5, 'send',     :add,          self.class],
+       [5, 'c-call',   :+,            Fixnum],
+       [5, 'c-return', :+,            Fixnum],
+       [6, 'return',   :add,          self.class],
+       [6, 'leave',    :add,          self.class],
+       [8, 'line',      __method__,   self.class],
+       [8, 'send',      __method__,   self.class],
+       [8, 'c-call',   :set_trace_func, Kernel]
+      ]
     checkit(@events, expected)
   end
 
@@ -96,17 +107,23 @@ class TestSetTraceFunc < Test::Unit::TestCase
                 [4, 'c-return', :inherited,   Class],
                 [4, 'class',    nil,           nil],
                 [5, 'line',     nil,           nil],
+                [5, 'send',     nil,           nil],
                 [5, 'c-call',   :method_added, Module],
                 [5, 'c-return', :method_added, Module],
                 [7, 'end',      nil,           nil],
+                [7, 'leave',    nil,           nil],
                 [8, 'line',     __method__,    self.class],
+                [8, 'send',     __method__,    self.class],
                 [8, 'c-call',   :new,          Class],
                 [8, 'c-call',   :initialize,   BasicObject],
                 [8, 'c-return', :initialize,   BasicObject],
                 [8, 'c-return', :new,          Class],
+                [8, 'send',     __method__,          Class],
                 [5, 'call',     :bar,          Foo],
                 [6, 'return',   :bar,          Foo],
+                [6, 'leave',    :bar,          Foo],
                 [9, 'line',     __method__,    self.class],
+                [9, 'send',     __method__,    self.class],
                 [9, 'c-call',   :clear_trace_func, Kernel]]
     checkit(@events, expected)
   end
@@ -124,19 +141,27 @@ class TestSetTraceFunc < Test::Unit::TestCase
      9: foo(false)
     10: set_trace_func(nil)
     EOF
-    expected = [[ 4, 'line',     __method__,   self.class],
-                [ 4, 'c-call',   :method_added, Module],
-                [ 4, 'c-return', :method_added, Module],
-                [ 8, 'line',     __method__,   self.class],
-                [ 4, 'call',     :foo,         self.class],
-                [ 5, 'line',     :foo,         self.class],
-                [ 5, 'return',   :foo,         self.class],
-                [ 9, 'line',     :test_return, self.class],
-                [ 4, 'call',     :foo,         self.class],
-                [ 5, 'line',     :foo,         self.class],
-                [ 7, 'return',   :foo,         self.class],
-                [10, 'line',     :test_return, self.class],
-                [10, 'c-call',   :set_trace_func, Kernel]]
+    expected = 
+      [
+       [ 4, 'line',     __method__,   self.class],
+       [ 4, 'send',     __method__,   self.class],
+       [ 4, 'c-call',   :method_added, Module],
+       [ 4, 'c-return', :method_added, Module],
+       [ 8, 'line',     __method__,   self.class],
+       [ 8, 'send',     __method__,   self.class],
+       [ 4, 'call',     :foo,         self.class],
+       [ 5, 'line',     :foo,         self.class],
+       [ 5, 'return',   :foo,         self.class],
+       [ 5, 'leave',    :foo,         self.class],
+       [ 9, 'line',     :test_return, self.class],
+       [ 9, 'send',     :test_return, self.class],
+       [ 4, 'call',     :foo,         self.class],
+       [ 5, 'line',     :foo,         self.class],
+       [ 7, 'return',   :foo,         self.class],
+       [10, 'line',     :test_return, self.class],
+       [10, 'leave',    :test_return, self.class],
+       [10, 'send',     :test_return, self.class],
+       [10, 'c-call',   :set_trace_func, Kernel]]
     checkit(@events, expected)
   end
 
@@ -153,16 +178,22 @@ class TestSetTraceFunc < Test::Unit::TestCase
      9: set_trace_func(nil)
     EOF
 
-    expected = [[4, 'line',     __method__, self.class],
-                [4, 'c-call',   :method_added, Module],
-                [4, 'c-return', :method_added, Module],
-                [8, 'line',     __method__, self.class],
-                [4, 'call',     :foo, self.class],
-                [5, 'line',     :foo, self.class],
-                [6, 'line',     :foo, self.class],
-                [7, 'return',   :foo, self.class],
-                [9, 'line',     :test_return2, self.class],
-                [9, 'c-call',   :set_trace_func, Kernel]]
+    expected = 
+      [
+       [4, 'line',     __method__, self.class],
+       [4, 'send',     __method__, self.class],
+       [4, 'c-call',   :method_added, Module],
+       [4, 'c-return', :method_added, Module],
+       [8, 'line',     __method__, self.class],
+       [8, 'send',     __method__, self.class],
+       [4, 'call',     :foo, self.class],
+       [5, 'line',     :foo, self.class],
+       [6, 'line',     :foo, self.class],
+       [7, 'return',   :foo, self.class],
+       [7, 'leave',    :foo, self.class],
+       [9, 'line',     :test_return2, self.class],
+       [9, 'send',     :test_return2, self.class],
+       [9, 'c-call',   :set_trace_func, Kernel]]
     @events.each_with_index{|e, i|
       assert_equal(e, @events[i], showit(@events, expected))}
     assert_equal(expected.size, @events.size, showit(@events, expected))
@@ -181,23 +212,30 @@ class TestSetTraceFunc < Test::Unit::TestCase
      8: set_trace_func(nil)
     EOF
     
-    expected = [[4, 'line',     __method__,     self.class],
-                [5, 'line',     __method__,     self.class],
-                [5, 'c-call',   :raise,         Kernel],
-                [5, 'c-call',   :exception,     Exception],
-                [5, 'c-call',   :initialize,    Exception],
-                [5, 'c-return', :initialize,    Exception],
-                [5, 'c-return', :exception,     Exception],
-                [5, 'c-call',   :backtrace,     Exception],
-                [5, 'c-return', :backtrace,     Exception],
-                [5, 'c-call',   :set_backtrace, Exception],
-                [5, 'c-return', :set_backtrace, Exception],
-                [5, 'raise',    :test_raise,    $e], 
-                [5, 'c-return', :raise,         Kernel],
-                [6, 'c-call',   :===,           Module],
-                [6, 'c-return', :===,           Module],
-                [8, 'line',     __method__,     self.class],
-                [8, 'c-call',   :set_trace_func, Kernel]]
+    expected = 
+      [
+       [4, 'line',     __method__,     self.class],
+       [5, 'line',     __method__,     self.class],
+       [5, 'send',     __method__,     Kernel],
+       [5, 'c-call',   :raise,         Kernel],
+       [5, 'c-call',   :exception,     Exception],
+       [5, 'c-call',   :initialize,    Exception],
+       [5, 'c-return', :initialize,    Exception],
+       [5, 'c-return', :exception,     Exception],
+       [5, 'c-call',   :backtrace,     Exception],
+       [5, 'c-return', :backtrace,     Exception],
+       [5, 'c-call',   :set_backtrace, Exception],
+       [5, 'c-return', :set_backtrace, Exception],
+       [5, 'raise',    :test_raise,    $e], 
+       [5, 'c-return', :raise,         Kernel],
+       [5, 'send',     __method__,     Kernel],
+       [6, 'c-call',   :===,           Module],
+       [6, 'c-return', :===,           Module],
+       [7, 'leave',    __method__,     Module],
+       [8, 'line',     __method__,     self.class],
+       [8, 'send',     __method__,     self.class],
+       [8, 'c-call',   :set_trace_func, Kernel]
+      ]
     checkit(events, expected)
   end
 
@@ -211,13 +249,17 @@ class TestSetTraceFunc < Test::Unit::TestCase
      8: set_trace_func(nil)
     EOF
 
-    expected = [[4, 'line',     __method__, self.class],
+    expected = [
+                [4, 'line',     __method__, self.class],
+                [4, 'send',     __method__, self.class],
                 [4, 'c-call',   :any?,      Enumerable],
                 [4, 'c-call',   :each,      Array],
                 [4, 'line',     __method__, self.class],
+                [4, 'leave',    __method__, self.class],
                 [4, 'c-return', :each,      Array],
                 [4, 'c-return', :any?,      Enumerable],
                 [5, 'line',     __method__, self.class],
+                [5, 'send',     __method__, self.class],
                 [5, 'c-call',   :set_trace_func, Kernel]]
     checkit(events, expected)
   end
@@ -258,7 +300,9 @@ class TestSetTraceFunc < Test::Unit::TestCase
 
     expected = [[1, 'c-return', :set_trace_func, Thread, :set],
                 [2, 'line',     __method__, self.class, :set],
-                [2, 'c-call',   :add_trace_func, Thread, :set]]
+                [2, 'send',     :test_thread_trace, TestSetTraceFunc, :set],
+                [2, 'c-call',   :add_trace_func, Thread, :set],
+               ]
     expected.each do |e|
       assert_equal(e, events[:set].shift, showit(events, expected))
     end
@@ -269,21 +313,29 @@ class TestSetTraceFunc < Test::Unit::TestCase
      [3, 'c-return', :inherited, Class],
      [3, 'class',    nil, nil],
      [4, 'line',     nil, nil],
+     [4, 'send',     nil, nil],
      [4, 'c-call',   :method_added, Module],
      [4, 'c-return', :method_added, Module],
      [7, 'end',      nil, nil],
+     [7, 'leave',    nil, nil],
      [8, 'line',     __method__, self.class],
+     [8, 'send',     __method__, self.class],
      [8, 'c-call',   :new, Class],
      [8, 'c-call',   :initialize, BasicObject],
      [8, 'c-return', :initialize, BasicObject],
      [8, 'c-return', :new, Class],
+     [8, 'send',     :test_thread_trace, TestSetTraceFunc],
      [4, 'call',     :foo, ThreadTraceInnerClass],
      [5, 'line',     :foo, ThreadTraceInnerClass],
+     [5, 'send',     :foo, ThreadTraceInnerClass],
      [5, 'c-call',   :+, Fixnum],
      [5, 'c-return', :+, Fixnum],
      [6, 'return',   :foo, ThreadTraceInnerClass],
+     [6, 'leave',    :foo, ThreadTraceInnerClass],
      [9, 'line',     __method__, self.class],
-     [9, 'c-call',   :set_trace_func, Thread]].each do |e|
+     [9, 'send',     __method__, self.class],
+     [9, 'c-call',   :set_trace_func, Thread]
+    ].each do |e|
       [:set, :add].each do |type|
         assert_equal(e + [type], events[type].shift)
       end

data/test/unit/test-thread-trace-masks.rb

@@ -4,12 +4,14 @@ require_relative '../../ext/thread_frame'
 
 class TestTracingMasks < Test::Unit::TestCase
   @@EVENT2MASK = {
-    'line'     => 0x01,
-    'call'     => 0x08,
-    'return'   => 0x10,
-    'c-call'   => 0x20,
-    'c-return' => 0x40,
-    'raise'    => 0x80,
+    'line'     => 0x0001,
+    'call'     => 0x0008,
+    'return'   => 0x0010,
+    'c-call'   => 0x0020,
+    'c-return' => 0x0040,
+    'raise'    => 0x0080,
+    'send'     => 0x0400,
+    'leave'    => 0x0800,
   }
 
   def something_to_test(n)

metadata

@@ -4,8 +4,8 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 37
-  version: "0.37"
+  - 38
+  version: "0.38"
 platform: ruby
 authors: 
 - R. Bernstein
@@ -13,7 +13,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-01 00:00:00 -05:00
+date: 2011-03-15 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -33,46 +33,42 @@ files:
 - Makefile
 - LICENSE
 - NEWS
+- include/thread_pthread.h
 - include/node.h
-- include/ruby19_externs.h
 - include/method_mini.h
-- include/thread_pthread.h
+- include/ruby19_externs.h
 - include/vm_core_mini.h
-- lib/thread_frame.rb
 - lib/iseq_extra.rb
+- lib/thread_frame.rb
 - ext/iseq_extra.c
 - ext/thread_frame.c
-- ext/thread_extra.c
 - ext/proc_extra.c
+- ext/thread_extra.c
+- ext/thread_frame.h
+- ext/proc_extra.h
+- ext/thread_pthread.h
+- ext/node.h
 - ext/thread_extra.h
-- ext/iseq_mini.h
 - ext/iseq_extra.h
-- ext/node.h
-- ext/thread_pthread.h
-- ext/proc_extra.h
-- test/ruby/test_tracefunc_adds.rb
-- test/ruby/test_brkpt.rb
-- test/ruby/test_disasm.rb
-- test/ruby/test_iseq.rb
-- test/ruby/test_tracefunc_raise.rb
-- test/unit/test-sp-size.rb
-- test/unit/test-iseq-brkpt.rb
+- ext/iseq_mini.h
+- test/unit/test-trace.rb
 - test/unit/test-iseq-save.rb
-- test/unit/test-binding.rb
 - test/unit/test-prev.rb
+- test/unit/test-source.rb
 - test/unit/test-lib-iseq.rb
 - test/unit/test-return-stop.rb
-- test/unit/test-iseq.rb
-- test/unit/cfunc-use.rb
-- test/unit/test-argc.rb
+- test/unit/test-proc.rb
 - test/unit/test-invalid.rb
+- test/unit/test-argc.rb
+- test/unit/cfunc-use.rb
+- test/unit/test-binding.rb
 - test/unit/test-lib-iseq-extra.rb
-- test/unit/test-thread-trace-masks.rb
-- test/unit/test-proc.rb
 - test/unit/test-thread.rb
+- test/unit/test-iseq-brkpt.rb
+- test/unit/test-iseq.rb
+- test/unit/test-thread-trace-masks.rb
 - test/unit/test-settracefunc.rb
-- test/unit/test-trace.rb
-- test/unit/test-source.rb
+- test/unit/test-sp-size.rb
 - threadframe.rd
 - ext/extconf.rb
 has_rdoc: true
@@ -84,7 +80,7 @@ rdoc_options:
 - --main
 - README.md
 - --title
-- ThreadFrame 0.37 Documentation
+- ThreadFrame 0.38 Documentation
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 

data/test/ruby/test_brkpt.rb

@@ -1,60 +0,0 @@
-require 'test/unit'
-
-class TestISeqBrkpt < Test::Unit::TestCase
-
-  def setup
-    @original_compile_option = RubyVM::InstructionSequence.compile_option
-    RubyVM::InstructionSequence.compile_option = {
-      :trace_instruction => false,
-      :specialized_instruction => false
-    }
-  end
-
-  def teardown
-    set_trace_func(nil)
-    RubyVM::InstructionSequence.compile_option = @original_compile_option
-  end
-
-  def test_iseq_brkpt
-    iseq = RubyVM::InstructionSequence.compile('x=1; y=2')
-    assert iseq
-    assert_equal(nil, iseq.brkpts)
-    assert_equal(true, iseq.brkpt_alloc)
-    assert_equal([], iseq.brkpts)
-    assert_equal(false, iseq.brkpt_alloc)
-    
-    assert_equal(true, iseq.brkpt_set(0))
-    assert_equal(1,    iseq.brkpts.size)
-    assert_equal(true, iseq.brkpt_get(0), 'Offset 0 should be set')
-    assert_equal(true, iseq.brkpt_unset(0),'Offset 0 should be unset')
-    assert_equal(false, iseq.brkpt_get(0), 'Offset 0 should be unset now')
-    assert_equal(true, iseq.brkpt_unset(0), 
-                 'Offset 0 should be unset again')
-    assert_raises TypeError do iseq.brkpt_get(100) end
-    assert_equal(true, iseq.brkpt_dealloc)
-    assert_equal(false, iseq.brkpt_dealloc)
-    assert_equal(true, iseq.brkpt_unset(0),
-                 'Offset 0 should be unset even when deallocated')
-
-    assert_raises TypeError do iseq.brkpt_set('a') end
-
-    iseq.brkpt_set(2)    
-    iseq.brkpt_set(4)    
-    events = []
-    eval <<-EOF.gsub(/^.*?: /, "")
-     1: set_trace_func(Proc.new { |event, file, lineno, mid, binding, klass|
-     2:   events << [event, lineno, mid, klass]
-     3: })
-     4: iseq.eval
-     5: set_trace_func(nil)
-    EOF
-    # puts iseq.disassemble
-    brkpt_events = events.select{|item| item[0] == 'brkpt'}
-    assert_equal(2, brkpt_events.size, 
-                 "Expecting to see 2 brkpts in #{events}.inspect")
-    assert_equal(true, iseq.brkpt_dealloc)
-  end
-end
-
-# We want to double-check we didn't mess up any pointers somewhere.
-at_exit { GC.start  }

data/test/ruby/test_disasm.rb

@@ -1,17 +0,0 @@
-# Some simple tests of RubyVM::InstructionSequence#disasm, and
-# #disasm_nochildren
-require 'test/unit'
-
-class TestDisasmClass < Test::Unit::TestCase
-
-  def test_basic
-    assert_equal(RubyVM::InstructionSequence.compile('1+2').disassemble,
-                 RubyVM::InstructionSequence.compile('1+2').disasm)
-
-    p='def five; 5 end; five'
-    s1=RubyVM::InstructionSequence.compile(p).disasm
-    assert_equal String, s1.class, 'disasm output should be a string'
-    s2=RubyVM::InstructionSequence.compile(p).disasm_nochildren
-    assert_equal true, s1.size > s2.size
-  end
-end

data/test/ruby/test_iseq.rb

@@ -1,50 +0,0 @@
-# See that setting ISEQS__ and SCRIPT_ISEQS__ saves 
-# RubyVM::Instruction_sequenses
-require 'test/unit'
-
-class TestIseqAccess < Test::Unit::TestCase
-  def setup
-    old_verbosity = $VERBOSE
-    $VERBOSE = nil
-    Kernel.const_set(:ISEQS__, {})
-    Kernel.const_set(:SCRIPT_ISEQS__, {})
-    $VERBOSE = old_verbosity
-  end
-
-  def teardown
-    old_verbosity = $VERBOSE
-    $VERBOSE = nil
-    Kernel.const_set(:ISEQS__, nil)
-    Kernel.const_set(:SCRIPT_ISEQS__, nil)
-    $VERBOSE = old_verbosity
-  end
-
-  def test_basic
-    sizes=[]
-    [ISEQS__, SCRIPT_ISEQS__].each do |iseq_hash|
-      sizes << iseq_hash.size
-    end
-    # defining five should trigger five instruction sequence additions
-    # to ISEQS__ and SCRIPT_ISEQS__
-    # 
-    eval 'def five; 5 end'
-    assert_equal sizes[0], sizes[1]
-    [SCRIPT_ISEQS__, ISEQS__].each do |iseq_hash|
-      assert_equal true, iseq_hash.size > sizes.pop
-      assert_equal Hash, iseq_hash.class
-      a = iseq_hash.first
-      assert_equal Array, a.class
-      assert_equal RubyVM::InstructionSequence, iseq_hash.values[0][0].class
-    end
-  end
-
-  # Check RubyVM::InstructionSequence#arity
-  def test_arity
-    eval 'def five; 5 end'
-    eval 'def add(a,b); a+b end'
-    eval 'def splat(*a); 5 end'
-    [['five', 0,], ['add', 2], ['splat', -1]].each do |meth, expect|
-      assert_equal(expect, ISEQS__[meth][0].arity)
-    end
-  end
-end

data/test/ruby/test_tracefunc_adds.rb

@@ -1,145 +0,0 @@
-require 'test/unit'
-
-# tests set_trace_func with event bitmasks, clear_trace_func, 
-# Newer changes
-class TestSetTraceFuncAdds < Test::Unit::TestCase
-
-  # Some of the below setup is similar to what is in lib/trace_mod.rb of 
-  # rb-trace
-  @@NO_EVENT_MASK        = 0x0000
-  @@LINE_EVENT_MASK      = 0x0001
-  @@CLASS_EVENT_MASK     = 0x0002
-  @@END_EVENT_MASK       = 0x0004
-  @@CALL_EVENT_MASK      = 0x0008
-  @@RETURN_EVENT_MASK    = 0x0010
-  @@C_CALL_EVENT_MASK    = 0x0020
-  @@C_RETURN_EVENT_MASK  = 0x0040
-  @@RAISE_EVENT_MASK     = 0x0080
-  @@INSN_EVENT_MASK      = 0x0100
-  @@ALL_EVENTS_MASK      = (0xffff & ~@@INSN_EVENT_MASK)
-  
-  @@EVENT2MASK = {
-    'line'     => @@LINE_EVENT_MASK,
-    'call'     => @@CALL_EVENT_MASK,
-    'return'   => @@RETURN_EVENT_MASK,
-    'c-call'   => @@C_CALL_EVENT_MASK,
-    'c-return' => @@C_RETURN_EVENT_MASK,
-    'c-raise'  => @@RAISE_EVENT_MASK
-  }
-
-  # Convert +events+ into a Fixnum bitmask used internally by Ruby.
-  # Parameter +events+ should be Enumerable and each element should
-  # either be a Fixnum mask value or something that can be converted
-  # to a symbol. If the latter, the case is not important as we'll
-  # downcase the string representation.
-  def events2bitmask(event_list)
-    bitmask = @@NO_EVENT_MASK
-    event_list.each do |event|
-      bitmask |= @@EVENT2MASK[event]
-    end
-    return bitmask
-  end
-
-  def setup
-    @original_compile_option = RubyVM::InstructionSequence.compile_option
-    RubyVM::InstructionSequence.compile_option = {
-      :trace_instruction => true,
-      :specialized_instruction => false
-    }
-    @proc_template = 'Proc.new { |event, file, lineno, mid, binding, klass|
-      %s << [event, lineno, mid, klass]}'
-  end
-
-  def teardown
-    clear_trace_func
-    RubyVM::InstructionSequence.compile_option = @original_compile_option
-  end
-
-  def test_eventmask
-    returned_tuples = 
-      [['line', 5, :test_eventmask, self.class],
-       ['class', 5, nil, nil],
-       ['end', 5, nil, nil],
-       ['line', 6, :test_eventmask, self.class],
-       ['call', 1, :five, self.class],
-       ['line', 1, :five, self.class],
-       ['return', 1, :five, self.class],
-       ['c-call', 6, :any?, Enumerable],
-       ['c-call', 6, :each, Array],
-       ['line', 6, :test_eventmask, self.class],
-       ['c-return', 6, :each, Array],
-       ['c-return', 6, :any?, Enumerable],
-       ['line', 7, :test_eventmask, self.class],
-       ['c-call', 7, :clear_trace_func, Kernel]]
-
-    [[], nil, 
-     %w(line),
-     %w(call line),
-     %w(c-call c-return line),
-    ].each do |event_list|
-      tuples = []
-      event_mask = if event_list
-                     events2bitmask(event_list)
-                   else
-                     @@ALL_EVENTS_MASK
-                   end
-      cmd = <<-EOF.gsub(/^.*?: /, '')
-        1: def five; 5 end
-        2: p1 = #{@proc_template}
-        3: set_trace_func(p1, #{event_mask})
-        4: class Foo; end
-        5: [1,2,five].any? {|n| n}
-        6: clear_trace_func
-      EOF
-      eval(cmd % 'tuples')
-      expected = if event_list
-                   returned_tuples.select{|x| !([x[0]] & event_list).empty?}
-                 else
-                   returned_tuples
-                 end
-      assert_equal(expected, tuples, 
-                   "Error filtering #{event_list}")
-     # p tuples
-    end
-  end
-
-  def test_chained_hook
-    tuples1 = []
-    tuples2 = []
-    cmd = <<-EOF.gsub(/^.*?: /, '')
-        1: def five; 5 end
-        2: p1 = #{@proc_template}
-        3: p2 = #{@proc_template}
-        4: add_trace_func(p1, @@LINE_EVENT_MASK)
-        5: add_trace_func(p2, @@CALL_EVENT_MASK)
-        6: class Foo; end
-        7: [1,2,five].any? {|n| n}
-      EOF
-    eval(cmd % %w(tuples1 tuples2))
-    clear_trace_func
-    assert_equal([
-                  ["line", 7, :test_chained_hook, self.class], 
-                  ["line", 8, :test_chained_hook, self.class], 
-                  ["line", 9, :test_chained_hook, self.class], 
-                  ["line", 1, :five, self.class], 
-                  ["line", 9, :test_chained_hook, self.class], 
-                 ], tuples1[0..-2],
-                 'line filtering')
-    assert_equal([["call", 1, :five, self.class]], tuples2, 
-                 'call filtering')
-  end
-
-  def test_trace_insn
-    tuples = []
-    cmd = <<-EOF.gsub(/^.*?: /, '')
-        1: p = #{@proc_template}
-        2: add_trace_func(p, @@INSN_EVENT_MASK)
-        4: x = 1
-        3: y = 2
-      EOF
-    eval cmd % 'tuples'
-    clear_trace_func
-    assert_equal true, !tuples.empty?, 'triggered instruction events'
-    assert_equal true, tuples.all?{|t| 'vm-insn' == t[0]}, 'instruction events'
-  end
-end

data/test/ruby/test_tracefunc_raise.rb

@@ -1,26 +0,0 @@
-require 'test/unit'
-
-# tests that we a trace hook has access to the runtime exception Object
-# when it is called through a raise event
-
-class TestTracefuncRaise < Test::Unit::TestCase
-
-  def test_basic
-    tuples = []
-    p = Proc.new { 
-      |event, file, lineno, mid, binding, klass|
-      tuples << klass
-    }
-    msg = 'this is a message'
-    set_trace_func(p, 0x0080)
-    begin ; x = 1/0; rescue; end
-    begin ; raise RuntimeError, msg; rescue; end
-    clear_trace_func
-    assert_equal(2, tuples.size, 
-                 "Wrong number of tuples captured #{tuples.inspect}")
-    assert_equal msg, tuples[1].message
-    assert_equal([ZeroDivisionError, RuntimeError], tuples.map{|t| t.class},
-                 "Mismatched tuples classes in #{tuples.inspect}")
-    
-  end
-end