rb-threadframe 0.32

data/test/unit/test-sp-size.rb

@@ -0,0 +1,45 @@
+require 'test/unit'
+
+# require 'thread_frame'  # To compare with previous version
+require_relative '../../ext/thread_frame'
+
+# Test source_location and source_container.
+class TestSpSize < Test::Unit::TestCase
+
+  def sizes
+    tf = RubyVM::ThreadFrame::current
+    ary = []
+    0.upto(2) do |i|
+      ary << tf.sp_size
+      tf = tf.prev
+    end
+    # Swap first two items. The item that generally 
+    # will vary is the a[0].
+    ary[0], ary[1] = ary[1], ary[0]
+    # p ary
+    return ary
+  end
+
+  def f0; return sizes end
+  def f1; a=1; return sizes end
+  def f1a(a) return sizes end
+  def f2(a,b) return sizes end
+
+  def test_sp_size
+    f0_s   = f0
+    f1_s   = f1
+    f1a_s  = f1a(1)
+    f2_s   = f2(1,2)
+    assert_equal(f0_s[0]+1,   f1_s[0])
+    assert_equal(f0_s[1..-1], f1_s[1..-1])
+    assert_equal(f1_s, f1a_s)
+    assert_equal(f1_s[0]+1,   f2_s[0])
+    assert_equal(f1_s[1..-1], f2_s[1..-1])
+
+    assert_raises ArgumentError do 
+      tf = RubyVM::ThreadFrame.current
+      tf.sp_set(tf.sp_size, "Should not be able to set this.")
+    end
+  end
+
+end

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

@@ -0,0 +1,90 @@
+# Test of additional tracing flag use to selectively turn on off tracing
+require 'test/unit'
+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,
+  }
+
+  def something_to_test(n)
+    def sqr(x)
+      x * x 
+    end
+    begin
+      n += sqr(5)
+      raise TypeError, 'error'
+    rescue TypeError => $e
+    end
+    return [1,2,3].all? {|n| n}
+  end
+
+  def chunk(list, char='-')
+    sep = char * 30 + "\n"
+    sep + list.map{|e| e.join(' ')}.join("\n") + "\n"
+  end
+
+  def checkit(event_name)
+    chunk(@events) if $DEBUG
+    assert @events.all?{|e| e[1] == event_name}, chunk(@events)  
+    assert @events.size > 0, "Expecting at least one #{event_name}"
+    @counts[event_name] = @events.size if @keep_count
+  end  
+
+  def test_thread_trace_mask
+    def trace_hook(event, file, line, id, binding, klass)
+      @events << [line, event, id, klass]
+    end
+
+    @keep_count = true
+    @counts = {}
+    @@EVENT2MASK.each do |event_name, mask|
+      @events = []
+      Thread.current.set_trace_func(method(:trace_hook).to_proc, mask)
+      something_to_test(5)
+      Thread.current.set_trace_func(nil)
+      checkit(event_name)
+    end
+    [%w(call return),
+     %w(c-call c-return)].each do |c, r|
+      assert_equal(@counts[c], @counts[r], 
+                   "Expecting # of #{c}'s to equal # of #{r}'s")
+    end
+
+    @keep_count = false
+
+    [%w(line call),
+     %w(raise c-return return),
+    ].each do |event_names|
+      @events = []
+      mask = event_names.map{|name| 
+        @@EVENT2MASK[name]
+      }.inject do 
+        |mask, bit| 
+        mask |= bit
+      end
+      Thread.current.set_trace_func(method(:trace_hook).to_proc, mask)
+      something_to_test(5)
+      Thread.current.set_trace_func(nil)
+      total = event_names.map{|name| @counts[name]}.inject do 
+        |sum, n| 
+        sum += n
+      end
+      assert_equal(total, @events.size, chunk(@events))
+    end
+
+    # Try without a mask and see that we get the sum of all events
+    @events = []
+    Thread.current.set_trace_func(method(:trace_hook).to_proc)
+    something_to_test(5)
+    Thread.current.set_trace_func(nil)
+    total = @counts.values.inject {|sum, n| sum += n}
+    assert_equal(total, @events.size, chunk(@events))
+  end
+
+end

data/test/unit/test-thread.rb

@@ -0,0 +1,168 @@
+require 'test/unit'
+require_relative '../../ext/thread_frame'
+
+class TestThread < Test::Unit::TestCase
+  def test_basic
+    assert_equal(RubyVM::ThreadFrame.new(Thread::current).thread, 
+                 RubyVM::ThreadFrame::current.thread)
+    assert_equal(RubyVM::ThreadFrame.new(Thread::current).thread, 
+                 Thread::current)
+    assert_equal(Thread::current.threadframe.thread, Thread::current)
+  end
+
+  def test_pc_offset
+    tf = RubyVM::ThreadFrame::current
+    offset_1 = tf.pc_offset
+    assert_equal(true, offset_1 > 0,
+                 "Expecting a positive integer pc offset, got %s" % offset_1)
+    offset_2 = tf.pc_offset
+    assert_equal(true, offset_2 > 0,
+                 "Expecting a positive integer pc offset, got %s" % offset_2)
+    assert_equal(true, offset_2 > offset_1,
+                 "Expecting second pc offset %s to be larger than the first %s" % 
+                 [offset_2, offset_1])
+  end
+
+  def test_sp
+    tf = RubyVM::ThreadFrame::current.prev
+    assert tf.sp(1)
+    tf.sp_set(1, 5)
+    assert_equal(5, tf.sp(1),
+                 'chcking value of recently-set sp(1)')
+  end
+
+  def test_source_container
+    cfunc_filebase = 'cfunc-use'
+    load File.join(File.dirname(__FILE__), cfunc_filebase + '.rb')
+    type, loc = cfunc_loc
+    assert_equal(['CFUNC',  cfunc_filebase], [type, File.basename(loc, '.rb')],
+                 'CFUNCs should get their file location from frame.prev*')
+    cont = 'file'
+    eval '1.times{cont = RubyVM::ThreadFrame.current.source_container[0]}'
+    assert_equal('string',  cont, 
+                 'source container[0] of an eval(...) should be "string"')
+  end
+    
+
+  def test_source_location
+    line = __LINE__
+    # There is a bug in Ruby 1.9.2 and before in reporting the source
+    # location when the PC is 0. Probably never reported before
+    # because the location is reported on a traceback
+    # and that probably can't happen at PC 0.
+    def bug_when_zero_pc
+      @not_first = true
+      tf = RubyVM::ThreadFrame::current.prev
+      pc_save = tf.pc_offset
+      tf.pc_offset = 0
+      loc = tf.source_location
+      tf.pc_offset = pc_save
+      loc
+    end
+    loc = bug_when_zero_pc unless @not_first
+    assert_equal([line - 1], loc)
+  end
+    
+
+  def test_thread_tracing
+    assert_equal(false, Thread.current.tracing)
+    Thread.current.tracing = true
+    assert_equal(true, Thread.current.tracing)
+    Thread.current.tracing = false
+    assert_equal(false, Thread.current.tracing)
+  end    
+    
+  def test_thread_exec_event_tracing
+    assert_equal(false, Thread.current.exec_event_tracing)
+    Thread.current.exec_event_tracing = true
+    assert_equal(true, Thread.current.exec_event_tracing)
+    Thread.current.exec_event_tracing = false
+    assert_equal(false, Thread.current.exec_event_tracing)
+  end    
+    
+  def test_fields(notused=nil)
+    tf = RubyVM::ThreadFrame::current
+    pc1 = tf.pc_offset
+    assert(pc1 > 0, 'Should be able to get a valid PC offset')
+    # pc_offset is dynamic - it changes constantly
+    pc2 = tf.pc_offset 
+    assert(pc2 > pc1, 'PC offset should have changed (for the greater)')
+    assert_equal('test_fields', tf.method)
+    assert_equal(self, tf.self)
+    assert_equal(0, tf.arity)
+    assert_equal(0, tf.argc)
+    assert tf.dfp(0)
+    assert tf.lfp(0)
+
+    assert_raises IndexError do
+      x = tf.lfp(tf.iseq.local_size+1)
+    end
+
+
+    tf_prev = tf.prev
+    assert(tf_prev.pc_offset > 0, "Should be valid PC offset for prev")
+  
+    # Is this too specific to test/unit.rb implementation details? 
+    assert_equal('run', tf_prev.method)
+
+    # 1.times creates a C frame.
+    1.times do 
+      tf = RubyVM::ThreadFrame::current
+      tup = tf.source_container
+      tup[1] = File.basename(tup[1])
+      assert_equal(['file', 'test-thread.rb'], tup)
+      assert_equal('block in test_fields', tf.method)
+      assert_equal('CFUNC', tf.prev.type)
+      assert_equal('times', tf.prev.method) 
+      assert_equal(self, tf.self)
+      assert_equal(0, tf.prev.arity, 'C arity should work nowadays' )
+      assert_equal(0, tf.prev.argc, 'C args is the same as arity')
+      assert_equal('test_fields', tf.prev.prev.method) 
+      assert_equal(0, tf.arity)
+      assert_equal(0, tf.argc)
+    end
+
+    # 1.upto also creates a C frame.
+    1.upto(1) do 
+      tf = RubyVM::ThreadFrame::current.prev
+      assert_equal('CFUNC', tf.type)
+      assert_equal(1, tf.arity, 'C arity should work nowadays' )
+      assert_equal(1, tf.argc)
+    end
+
+    x  = lambda do |x,y| 
+      frame = RubyVM::ThreadFrame::current
+      assert_equal('block in test_fields', frame.method)
+      assert_equal('LAMBDA', frame.type)
+      assert_equal(x, tf.self)
+    assert_equal(2, frame.arity)
+    assert_equal(2, frame.argc)
+    end
+    x.call(x,2)
+
+    x  = Proc.new do |x, y|
+      frame = RubyVM::ThreadFrame::current
+      assert_equal('block in test_fields', frame.method)
+      assert_equal(x, tf.self)
+    assert_equal('BLOCK', frame.type)
+    end
+    x.call(x,2)
+
+  end
+
+  def test_threadframe_equal
+    tf = RubyVM::ThreadFrame.current
+    tf2 = RubyVM::ThreadFrame.current
+    assert_equal(true,  tf.equal?(tf))
+    assert_equal(true,  tf.equal?(tf2))
+    tf2 = tf2.prev 
+    assert_equal(false, tf.equal?(tf2))
+    assert_raises TypeError do
+      tf.equal?(tf.iseq)
+    end
+  end
+end
+
+# We want to double-check we didn't mess up any pointers somewhere along
+# the line.
+at_exit { GC.start  }

data/test/unit/test-trace.rb

@@ -0,0 +1,55 @@
+# Test of additional tracing flag use to selectively turn on off tracing
+require 'test/unit'
+require_relative '../../ext/thread_frame'
+
+class TestTracing < Test::Unit::TestCase
+  def test_basic_query_set_unset
+    tf = RubyVM::ThreadFrame::current
+    # Test default values
+    assert_equal(false, tf.trace_off?)
+    assert_equal(false, tf.return_stop?)
+
+    # Test set true
+    tf.trace_off = true
+    assert_equal(true, tf.trace_off?)
+    tf.return_stop = true
+    assert_equal(true, tf.return_stop?)
+
+    # Test setting off when on
+    tf.trace_off = nil
+    assert_equal(false, tf.trace_off?)
+    tf.return_stop = false
+    assert_equal(false, tf.return_stop?)
+  end
+
+  def test_trace_off
+    @levels = []
+    def trace_hook(event, file, line, id, binding, klass)
+      @levels << RubyVM::ThreadFrame::current.stack_size
+    end
+
+    def baz
+      6
+    end
+    def bar(set_off)
+      RubyVM::ThreadFrame::current.trace_off = true if set_off
+      baz
+      5
+    end
+    def foo(set_off)
+      bar(set_off)
+    end
+    # 0x10 is the mask for tracing return events
+    Thread.current.set_trace_func(method(:trace_hook).to_proc, 0x10)
+    foo(false)
+    assert_equal(3,  @levels.size)
+
+    @levels = []
+    Thread.current.set_trace_func(method(:trace_hook).to_proc, 0x10)
+    foo(true)
+    Thread.current.set_trace_func(nil)
+    assert_equal(1,  @levels.size)
+
+  end
+
+end

data/threadframe.rd

@@ -0,0 +1,163 @@
+# = NAME  
+# +RubyVM+::+ThreadFrame+
+#
+# = SYNOPSES 
+#
+# The +RubyVM+::+ThreadFrame+ class gives call-stack frame information
+# (controlled access to +rb_control_frame_t+)
+#
+#
+# It is possible that a The +Thread+::+Frame+ may be proposed for
+# all Ruby 1.9 implementations.  +RubyVM+::+ThreadFrame+
+# contains routines in the YARV 1.9 implementation.
+#
+# Should there be a +Thread+::+Frame+ +RubyVM+::+ThreadFrame+ would be
+# a subclass of +Thread+::+Frame+. In code:
+#
+#   class Thread
+#     class Frame  # In all 1.9 implementations
+#        # ...
+#     end
+#     def threadframe        
+#        RubyVM::ThreadFrame.new(self) # or possibly Thread::Frame.new(self)
+#     end
+#   end
+#           
+#   class RubyVM::ThreadFrame < Thread::Frame # In YARV 
+#     def initialize(thread_object)
+#       # implementation-specific code
+#     end    
+#     def iseq
+#       # implementation of iseq
+#     end 
+#     # ...  
+#   end
+#
+# A +RubyVM+::Thread+Frame+ contains information from a frame running +Thread+
+# object, and the information may change or disappear in the course of
+# running that thread. Therefore, it is advisable ensure that the
+# threads of the ThreadFrame objects are blocked.
+#
+#
+# === RubyVM::ThreadFrame::new(thread_object)
+# Creates a thread-frame object for the given thread object.
+#
+# === RubyVM::ThreadFrame::current
+# Shorthand for RubyVM::ThreadFrame.new(Thread::current)
+#
+# === Thread#threadframe
+#   tf = Thread::current.threadframe() 
+#
+# Creates a thread-frame object for the given thread object.
+# Note:
+#  Thread::current.threadframe() == RubyVM::ThreadFrame.new(Thread::current)
+#
+# == RubyVM::ThreadFrame Instance Methods
+# 
+# === RubyVM::ThreadFrame#prev
+#   tf.prev(n) -> tf or nil
+#   tf.prev() -> tf or nil  # same as tf.prev(1)
+#
+# Returns the previous control frame. If tail recursion has removed
+# frames as seen in the source, deal with it. ;-) +nil+ can be
+# returned if there is no previous frame or if tf is no longer exists.
+# If a number is passed go back that many frames. The value 0 gives back
+# tf. A negative number of a number greater than the number of frames
+# returns nil. 
+#
+# === RubyVM::ThreadFrame#invalid?
+#   tf.invalid?() -> boolean
+#
+# Returns true if the frame is no longer valid. On the other hand,
+# since the test we use is weak, returning false might not mean the
+# frame is valid, just that we can't disprove that it is not invalid.
+# 
+# It is suggested that frames are used in a way that ensures they will
+# be valid. In particular frames should have local scope and frames to 
+# threads other than the running one should be stopped while the frame 
+# variable is active.
+# 
+#
+# === RubyVM::ThreadFrame#thread
+#   tf.thread() -> Thread
+#   RubyVM::ThreadFrame.current().thread == Thread.current
+#
+# === RubyVM::ThreadFrame#type
+#   tf.type() -> 'C' or 'Ruby'
+#
+# Indicates whether the frame is implemented in C or Ruby.
+#
+# === RubyVM::ThreadFrame#source_container
+#  RubyVM::Threadframe#source_container() -> [Type, String]
+#
+# Returns a tuple representing kind of container, e.g. file
+# eval'd string object, and the name of the container. If file,
+# it would be a file name. If an eval'd string it might be the string.
+# 
+# === RubyVM::ThreadFrame#source_location
+#  RubyVM::ThreadFrame#.source_location() -> Array 
+#
+# Returns an array of source location positions that match
+# +tf.instruction_offset+. A source location position is left
+# implementation dependent. It could be line number, a line number
+# and start and end column, or a start line number, start column, end
+# line number, end column.
+#
+# === RubyVM::ThreadFrame#stack_size
+#  RubyVM::ThreadFrame#.stack_size -> Fixnum
+#
+#  Returns the number of entries 
+#
+# === RubyVM::ThreadFrame#binding
+#  tf.binding() -> binding
+#
+#
+# If the frame is still valid, a binding that is in effect for the
+# scope of the frame is created. As with all bindings, over the
+# execution of the program, variables may spring into existence and
+# values may change.
+
+# == RubyVM::ThreadFrame 
+#
+# === RubyVM::new(thread_object)
+
+# Like RubyVM::ThreadFrame.new(thread_object), but has additional information
+# available.
+#
+# === RubyVM::ThreadFrame#iseq
+#   tf.iseq() -> ISeq
+#
+# Returns an instruction sequence object from the instruction sequence
+# found inside the +ThreadFrame+ object or +nil+ if there is none.
+# But if iseq is +nil+ and tf.type is not C, +binding+, and
+# +instruction_offset+, and +source_location+ are probably meaningless
+# and will be +nil+ as well.
+#
+#
+# === RubyVM::ThreadFrame#instruction_offset
+#  tf.instruction_offset -> Fixnum
+# Offset inside ISeq of instruction that the frame is currently on.
+#
+# === RubyVM::ThreadFrame#instruction_offset=
+#
+#  tf.instruction_offset=(Fixnum)
+# Sets the threadframe to a new offset. Some restrictions may apply, e.g.
+# the offset will have to refer to a valid offset location and the scope
+# and block level has to be the same.
+#
+# <em>Don't need to implement initially.</em>
+#
+# === RubyVM::ThreadFrame#return_changed?
+#   tf.return_changed?() -> boolean
+#
+# Returns true if tf _may_ be part of tail recursion removal so when
+# the code in frame returns it may not be to the immediate caller as
+# seen in the source code. Koichi says this is too difficult to do in
+# YARV.
+#
+# <em>Don't need to implement initially.</em>
+#
+# = THANKS
+#
+# Martin Davis for suggesting 
+# RubyVM::ThreadFrame#new == Thread::current.threadframe