rbx-tracer 0.0.2-universal-rubinius-1.2

data/ChangeLog

@@ -0,0 +1,37 @@
+2010-12-23  rocky <rockyb@rubyforge.org>
+
+	* breakpoint.rb, frame.rb, set_trace.rb: runtime_context ->
+	vm_location
+
+2010-12-22  rocky <rockyb@rubyforge.org>
+
+	* breakpoint.rb, commands.rb, frame.rb, set_trace.rb: Remove more
+	(but not all) of the "command"-ness for step/continue that is not
+	needed in set_trace_func. location -> runtime_context.
+
+2010-12-21  rocky <rockyb@rubyforge.org>
+
+	* commands.rb, set_trace.rb: Handle set_trace_func nil.
+
+2010-12-21  rocky <rockyb@rubyforge.org>
+
+	* breakpoint.rb, commands.rb, frame.rb, set_trace.rb: Set call and
+	return events
+
+2010-12-21  rocky <rockyb@rubyforge.org>
+
+	* set_trace.rb: Closer to having all of the set_trace_func
+	parameters filled in.
+
+2010-12-21  rocky <rockyb@rubyforge.org>
+
+	* README: See above
+
+2010-12-21  rocky <rockyb@rubyforge.org>
+
+	* README: What we're about. github suggests this.
+
+2010-12-20  rvm <rocky-rvm@static-71-183-236-17.nycmny.fios.verizon.net>
+
+	* First Hope (of sometine useful).
+

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2010, Rocky Bernstein
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+* Neither the name of the Evan Phoenix nor the names of its contributors 
+  may be used to endorse or promote products derived from this software 
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/NEWS

@@ -0,0 +1,2 @@
+2010-12-25, 12-26 0.0.1, 0.0.2
+* First public release

data/README

@@ -0,0 +1 @@
+Simulate Ruby 1.8, 1.9, JRuby's set_trace_func in Rubinius.

data/Rakefile

@@ -0,0 +1,109 @@
+#!/usr/bin/env rake
+# Are we Rubinius? We'll test by checking the specific function we need.
+raise RuntimeError, 'This package is for Rubinius 1.2 or 1.2.1dev only!' unless
+  Object.constants.include?('Rubinius') && 
+  Rubinius.constants.include?('VM') && 
+  %w(1.2 1.2.1dev).member?(Rubinius::VERSION)
+
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+ROOT_DIR = File.dirname(__FILE__)
+
+def gemspec
+  @gemspec ||= eval(File.read('.gemspec'), binding, '.gemspec')
+end
+
+desc "Build the gem"
+task :package=>:gem
+task :gem=>:gemspec do
+  Dir.chdir(ROOT_DIR) do
+    sh "gem build .gemspec"
+    FileUtils.mkdir_p 'pkg'
+    FileUtils.mv("#{gemspec.name}-#{gemspec.version}-universal-rubinius-1.2.gem", 
+                 "pkg/#{gemspec.name}-#{gemspec.version}-universal-rubinius-1.2.")
+  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}}
+  end
+end
+
+require 'rbconfig'
+RUBY_PATH = File.join(RbConfig::CONFIG['bindir'],  
+                      RbConfig::CONFIG['RUBY_INSTALL_NAME'])
+
+def run_standalone_ruby_files(list)
+  puts '*' * 40
+  list.each do |ruby_file|
+    system(RUBY_PATH, ruby_file)
+  end
+end
+
+def run_standalone_ruby_file(directory)
+  puts ('*' * 10) + ' ' + directory + ' ' + ('*' * 10)
+  Dir.chdir(directory) do
+    Dir.glob('*.rb').each do |ruby_file|
+      puts(('-' * 20) + ' ' + ruby_file + ' ' + ('-' * 20))
+      system(RUBY_PATH, ruby_file)
+    end
+  end
+end
+
+desc 'Create a GNU-style ChangeLog via git2cl'
+task :ChangeLog do
+  system('git log --pretty --numstat --summary | git2cl > ChangeLog')
+end
+
+desc 'the tests'
+Rake::TestTask.new(:'test') do |t|
+  t.test_files = FileList['test/test-*.rb']
+  # t.pattern = 'test/**/*test-*.rb' # instead of above
+  t.verbose = true
+end
+
+desc 'Test everything - unit tests for now.'
+task :default => :test
+
+desc "Run each Ruby app file in standalone mode."
+task :'check:app' do
+  run_standalone_ruby_file(File.join(%W(#{ROOT_DIR} app)))
+end
+
+desc "Generate the gemspec"
+task :generate do
+  puts gemspec.to_ruby
+end
+
+desc "Validate the gemspec"
+task :gemspec do
+  gemspec.validate
+end
+
+# ---------  RDoc Documentation ------
+desc "Generate rdoc documentation"
+Rake::RDocTask.new("rdoc") do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  # rdoc.title    = "rbx-trepaning #{Rubinius::SetTrace::VERSION} Documentation"
+
+  rdoc.rdoc_files.include(%w(lib/set_trace.rb app/*.rb))
+end
+
+desc "Same as rdoc"
+task :doc => :rdoc
+
+task :clobber_package do
+  FileUtils.rm_rf File.join(ROOT_DIR, 'pkg')
+end
+
+task :clobber_rdoc do
+  FileUtils.rm_rf File.join(ROOT_DIR, 'doc')
+end
+
+desc "Remove built files"
+task :clean => [:clobber_package, :clobber_rdoc]

data/THANKS

@@ -0,0 +1,2 @@
+This code is a distillation of the stepping code in the Rubinius
+reference debugger written by Evan Phoenix and Brian Ford. 

data/lib/set_trace.rb

@@ -0,0 +1,324 @@
+require 'rubygems'; require 'require_relative'
+require_relative '../app/frame'
+require_relative '../app/stepping'
+require_relative '../app/breakpoint'
+require 'compiler/iseq'
+
+#
+# A Rubinius implementation of set_trace_func.
+#
+# This code is wired into the debugging APIs provided by Rubinius.
+# It tries to isolate the complicated stepping logic as well as simulate
+# Ruby's set_trace_func.
+#
+
+class Rubinius::SetTrace
+  VERSION = '0.0.2'
+
+  DEFAULT_SET_TRACE_FUNC_OPTS = {
+    :callback_style => :classic,
+    :step_to_parent => :true
+  }
+
+  # Create a new object. Stepping starts up a thread which is where
+  # the callback executes from. Other threads are told that their
+  # debugging thread is the stepping thread, and this control of execution
+  # is handled.
+  #
+  def initialize()
+    @file_lines = Hash.new do |hash, path|
+      if File.exists? path
+        hash[path] = File.readlines(path)
+      else
+        ab_path = File.join(@root_dir, path)
+        if File.exists? ab_path
+          hash[path] = File.readlines(ab_path)
+        else
+          hash[path] = []
+        end
+      end
+    end
+
+    @thread = nil
+    @frames = []
+    @user_variables = 0
+    @breakpoints = []
+  end
+
+  attr_reader :variables, :current_frame, :breakpoints, :user_variables
+  attr_reader :vm_locations
+
+  def self.global(opts={})
+    @global ||= new
+  end
+
+  def self.set_trace_func(callback_method, opts={})
+    opts = Rubinius::SetTrace::DEFAULT_SET_TRACE_FUNC_OPTS.merge(opts)
+    opts[:call_offset] ||= 1
+    global.set_trace_func(callback_method, opts)
+  end
+
+  # Startup the stepping, skipping back +opts[:call_offset]+
+  # frames. This lets you start stepping straight into caller's
+  # method.
+  #
+  def set_trace_func(callback_method, opts={})
+    if callback_method
+      @opts = opts
+      call_offset = @opts[:call_offset] || 0
+      @callback_method = callback_method
+      @tracing  = true
+      spinup_thread
+      
+      # Feed info to the stepping call-back thread!
+      @vm_locations = Rubinius::VM.backtrace(call_offset + 1, true)
+      
+      method = Rubinius::CompiledMethod.of_sender
+      
+      bp = BreakPoint.new "<start>", method, 0, 0
+      channel = Rubinius::Channel.new
+      
+      @local_channel.send Rubinius::Tuple[bp, Thread.current, channel, 
+                                          @vm_locations]
+      
+      # wait for the callback to release us
+      channel.receive
+      
+      Thread.current.set_debugger_thread @thread
+      self
+    else
+      @tracing = false
+    end
+  end
+
+  # Stop and wait for a debuggee thread to send us info about
+  # stopping at a breakpoint.
+  #
+  def listen(step_into=false)
+    while true
+      if @channel
+        if step_into
+          @channel << :step
+        else
+          @channel << true
+        end
+      end
+
+      # Wait for someone to stop
+      @breakpoint, @debugee_thread, @channel, @vm_locations = 
+        @local_channel.receive
+
+      # Uncache all frames since we stopped at a new place
+      @frames = []
+
+      @current_frame = frame(0)
+
+      if @breakpoint
+        @event = @breakpoint.event
+        # Only break out if the hit was valid
+        break if @breakpoint.hit!(@vm_locations.first)
+      else
+        @event = 'call'
+        break
+      end
+    end
+
+    # puts
+    # puts "Breakpoint: #{@current_frame.describe}"
+    # show_code
+
+  end
+
+  # call callback
+  def call_callback
+    case @opts[:callback_style]
+    when :classic
+      line = @current_frame.line
+      file = @current_frame.file
+      meth = @current_frame.method
+      binding = @current_frame.binding
+      id = nil
+      classname = nil
+      @callback_method.call(@event, file, line, id, binding, classname)
+    else
+      @callback_method.call(@event, @vm_locations)
+    end
+    if @tracing
+      if @opts[:step_to_parent] 
+        @opts[:step_to_parent] = false
+        step_to_parent 
+      else 
+        step_over_by(1)
+      end
+    end
+    listen
+  end
+
+  def frame(num)
+    @frames[num] ||= Frame.new(self, num, @vm_locations[num])
+  end
+
+  def delete_breakpoint(i)
+    bp = @breakpoints[i-1]
+
+    unless bp
+      STDERR.puts "Unknown breakpoint '#{i}'"
+      return
+    end
+
+    bp.delete!
+
+    @breakpoints[i-1] = nil
+  end
+
+  def send_between(exec, start, fin)
+    ss = Rubinius::InstructionSet.opcodes_map[:send_stack]
+    sm = Rubinius::InstructionSet.opcodes_map[:send_method]
+    sb = Rubinius::InstructionSet.opcodes_map[:send_stack_with_block]
+
+    iseq = exec.iseq
+
+    fin = iseq.size if fin < 0
+
+    i = start
+    while i < fin
+      op = iseq[i]
+      case op
+      when ss, sm, sb
+        return exec.literals[iseq[i + 1]]
+      else
+        op = Rubinius::InstructionSet[op]
+        i += (op.arg_count + 1)
+      end
+    end
+
+    return nil
+  end
+
+  def show_code(line=@current_frame.line)
+    path = @current_frame.method.active_path
+
+    if str = @file_lines[path][line - 1]
+      puts "#{line}: #{str}"
+    else
+      show_bytecode(line)
+    end
+  end
+
+  def decode_one
+    ip = @current_frame.ip
+
+    meth = @current_frame.method
+    decoder = Rubinius::InstructionDecoder.new(meth.iseq)
+    partial = decoder.decode_between(ip, ip+1)
+
+    partial.each do |ins|
+      op = ins.shift
+
+      ins.each_index do |i|
+        case op.args[i]
+        when :literal
+          ins[i] = meth.literals[ins[i]].inspect
+        when :local
+          if meth.local_names
+            ins[i] = meth.local_names[ins[i]]
+          end
+        end
+      end
+
+      display "ip #{ip} = #{op.opcode} #{ins.join(', ')}"
+    end
+  end
+
+  def show_bytecode(line=@current_frame.line)
+    meth = @current_frame.method
+    start = meth.first_ip_on_line(line)
+    fin = meth.first_ip_on_line(line+1)
+
+    if fin == -1
+      fin = meth.iseq.size
+    end
+
+    puts "Bytecode between #{start} and #{fin-1} for line #{line}"
+
+    decoder = Rubinius::InstructionDecoder.new(meth.iseq)
+    partial = decoder.decode_between(start, fin)
+
+    ip = start
+
+    partial.each do |ins|
+      op = ins.shift
+
+      ins.each_index do |i|
+        case op.args[i]
+        when :literal
+          ins[i] = meth.literals[ins[i]].inspect
+        when :local
+          if meth.local_names
+            ins[i] = meth.local_names[ins[i]]
+          end
+        end
+      end
+
+      puts " %4d: #{op.opcode} #{ins.join(', ')}" % ip
+
+      ip += (ins.size + 1)
+    end
+  end
+
+  def spinup_thread
+    return if @thread
+
+    @local_channel = Rubinius::Channel.new
+
+    @thread = Thread.new do
+      begin
+        listen
+      rescue Exception => e
+        e.render("Listening")
+        break
+      end
+
+      while true
+        begin
+          call_callback
+        rescue Exception => e
+          begin
+            e.render "Error in debugger"
+          rescue Exception => e2
+            STDERR.puts "Error rendering backtrace in debugger!"
+          end
+        end
+      end
+    end
+
+    @thread.setup_control!(@local_channel)
+  end
+
+  private :spinup_thread
+
+end
+
+module Kernel
+  def set_trace_func(callback_method, opts={})
+    opts = Rubinius::SetTrace::DEFAULT_SET_TRACE_FUNC_OPTS.merge(opts)
+    Rubinius::SetTrace.set_trace_func(callback_method, opts)
+  end
+end
+
+if __FILE__ == $0
+  if ARGV[0] == 'classic'
+    meth = lambda { |event, file, line, id, binding, classname|
+      puts "tracer: #{event} #{file}:#{line}"
+    }
+    set_trace_func meth
+  else
+    meth = lambda { |event, vm_locs|
+      puts "tracer: #{event} #{vm_locs[0].file}:#{vm_locs[0].line}"
+    }
+    set_trace_func(meth, {:callback_style => :new})
+  end
+  x = 1
+  y = 2
+  set_trace_func nil
+end