trepanning 0.0.4

data/app/frame.rb

@@ -0,0 +1,275 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'util'
+
+class Trepan
+
+  module Frame
+
+    DEFAULT_STACK_TRACE_SETTINGS = {
+      :basename     => false,   # Basename only for files?
+      :maxstack     => 16,      # How many entries to show? nil means all
+      :count        => nil,     # How many entries to show? nil means all
+      :current_pos  => 0,       # Where are we in the stack?
+      :show_pc      => false,   # Show PC offset?
+    } unless defined?(DEFAULT_STACK_TRACE_SETTINGS)
+
+    include Trepan::Util
+
+    def all_param_names(iseq, delineate=true)
+      return '' unless iseq
+      params = param_names(iseq, 0, iseq.argc-1, '')
+      if iseq.arg_opts > 0
+        opt_params = param_names(iseq, iseq.argc, 
+                                 iseq.argc + iseq.arg_opts-2, '')
+        opt_params[0] = "optional: #{opt_params[0]}" if delineate
+        params += opt_params
+      end
+      params += param_names(iseq, iseq.arg_rest, iseq.arg_rest, '*') if 
+        iseq.arg_rest != -1
+      if iseq.arg_post_len > 0
+        # Manditory arguments after optional ones - new in Ruby 1.9
+        post_params = param_names(iseq, iseq.arg_post_start, 
+                                  iseq.post_start + iseq.arg_post_len, '')
+        post_params[0] = "post: #{post_params[0]}" if delineate
+        params += post_params
+      end
+      params += param_names(iseq, iseq.arg_block, iseq.arg_block, '&') if 
+        iseq.arg_block != -1
+
+      return params
+    end
+
+    def c_params(frame, maxstring=20)
+      argc = frame.argc
+      # FIXME should figure out why exception is raised.
+      begin
+        args = 
+          if 0 == argc
+            ''
+          elsif frame 
+            1.upto(argc).map do 
+            |i| 
+            safe_repr(frame.sp(argc-i+3).inspect, 10)
+          end.join(', ')
+          else
+            '??'
+          end
+        safe_repr(args, maxstring)
+      rescue NotImplementedError
+        '??'
+      end
+    end
+
+    # Return the eval string. We get this as the 
+    # parameter to the eval C call. A bit of checking is done
+    # to make sure everything is okay:
+    #  - we have to be in an EVAL type frame which has an iseq
+    #  - we have to have a prev frame which is a CFUNC
+    #  - the prev method name has to be 'eval'
+    def eval_string(frame)
+      return nil unless 'EVAL' == frame.type && frame.iseq
+      prev = frame.prev
+      return nil unless prev && 'CFUNC' == prev.type && 'eval' == prev.method
+      retval = prev.sp 3 
+      retval = $1 if retval =~ /^\(eval "(.+)"\)/
+      retval
+    end
+    module_function :eval_string
+
+    def format_stack_call(frame, opts)
+      # FIXME: prettify 
+      s = "#{frame.type}"
+      s += if opts[:class]
+             " #{opts[:class]}#"
+           else
+             begin 
+               obj = eval('self', frame.binding)
+             rescue
+               ''
+             else
+               if obj
+                 " #{obj.class}#" 
+               else
+                 ''
+               end
+             end
+           end
+      meth = frame.method
+      if meth and frame.type != 'IFUNC'
+        iseq = frame.iseq
+        args = if 'CFUNC' == frame.type
+                 c_params(frame)
+               elsif iseq
+                 all_param_names(iseq).join(', ')
+               end
+        s += meth
+        if %w(CFUNC METHOD).member?(frame.type)
+          s += "(#{args})"
+        elsif %w(BLOCK LAMBDA TOP EVAL).member?(frame.type)
+          s += " |#{args}|" unless args.nil? || args.empty?
+        else
+          s += "(#{all_param_names(iseq)})" 
+        end
+      end
+      s
+    rescue ThreadFrameError
+      'invalid frame'
+    end
+
+    def format_stack_entry(frame, opts={})
+      return 'invalid frame' if frame.invalid?
+      s  = format_stack_call(frame, opts)
+      s += " in #{frame.source_container[0]} "
+      s += 
+        if (eval_str = eval_string(frame))
+          safe_repr(eval_str.inspect, 15)
+        else
+          if 'file' == frame.source_container[0] &&
+              opts[:basename]
+            File.basename(frame.source_container[1])
+          else
+            frame.source_container[1]
+          end
+        end
+      if frame.source_location
+        s += 
+          if opts[:maxwidth] && s.size > opts[:maxwidth]
+            "\n\t"
+          else
+            ' '
+          end
+        if frame.source_location.size == 1
+          s += "at line #{frame.source_location[0]}" if 
+            frame.source_location[0] != 0
+        else
+          s += " at lines #{frame.source_location}"
+        end
+      end
+      s += ", pc: #{frame.pc_offset}" if 
+        frame.pc_offset > 0 && opts[:show_pc]
+      return s
+    end
+
+    def offset_for_return(event)
+      raise RuntimeError unless %w(return c-return).member?(event)
+      'return' == event ? 1 : 2
+    end
+    module_function :offset_for_return
+
+    def param_names(iseq, start, stop, prefix='')
+      start.upto(stop).map do |i| 
+        begin
+          prefix + iseq.local_name(i)
+        rescue
+          nil
+        end
+      end.compact
+    end
+
+    def print_stack_entry(frame, i, prefix='    ', opts={})
+      opts[:class] = nil unless i == 0
+      msg "%s%s" % [prefix, format_stack_entry(frame, opts)]
+    end
+
+    def print_stack_trace_from_to(from, to, frame, opts)
+      from.upto(to) do |i|
+        prefix = (i == opts[:current_pos]) ? '-->' : '   '
+        prefix += ' #%d ' % [i]
+        print_stack_entry(frame, i, prefix, opts)
+        frame = frame.prev
+      end
+    end
+
+    # Print `count' frame entries
+    def print_stack_trace(frame, opts={})
+      opts    = DEFAULT_STACK_TRACE_SETTINGS.merge(opts)
+      halfstack = opts[:maxstack] / 2
+      n       = frame.stack_size
+      n       = [n, opts[:count]].min if opts[:count]
+      if n > (halfstack * 2)
+        print_stack_trace_from_to(0, halfstack-1, frame, opts)
+        msg "... %d levels ..." % (n - halfstack*2)
+        print_stack_trace_from_to(n - halfstack, n-1, frame, opts)
+      else
+        print_stack_trace_from_to(0, n-1, frame, opts)
+      end
+    end
+
+    def set_return_value(frame, event, value)
+      offset = offset_for_return(event)
+      frame.sp_set(offset, value)
+    end
+    module_function :set_return_value
+
+    def value_returned(frame, event)
+      frame.sp(offset_for_return(event))
+    end
+    module_function :value_returned
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require 'thread_frame'
+  include Trepan::Frame
+  def msg(msg)
+    puts msg
+  end
+  print_stack_trace(RubyVM::ThreadFrame.current, :basename => true)
+  def foo
+    puts '=' * 10
+    print_stack_trace(RubyVM::ThreadFrame.current, :show_pc => true)
+  end
+  foo
+
+  def bar(a, b, c)
+    puts '=' * 10
+    print_stack_trace(RubyVM::ThreadFrame.current,
+                      )
+  end
+  bar(1, 2, 3)
+
+  def baz(a, b, c=5)
+    puts '=' * 10
+    print_stack_trace(RubyVM::ThreadFrame.current)
+  end
+  baz(1, 2)
+
+  def bat(a, b, &block)
+    puts '=' * 10
+    print_stack_trace(RubyVM::ThreadFrame.current)
+  end
+  bat(1, 2)
+
+  def babe(a, b, *rest)
+    puts '=' * 10
+    print_stack_trace(RubyVM::ThreadFrame.current)
+  end
+  babe(1, 2)
+
+  puts '=' * 10
+  x  = lambda { |a,b|  print_stack_trace(RubyVM::ThreadFrame::current) }
+  x.call(1,2)
+  puts '=' * 10
+  x  = Proc.new do |a| 
+    print_stack_trace(RubyVM::ThreadFrame::current)
+  end
+  x.call(1,2)
+  class C
+    def initialize(a)
+      print_stack_trace(RubyVM::ThreadFrame::current)
+    end
+  end
+  puts '=' * 30
+  C.new('Hi')
+  puts '=' * 30
+  eval("print_stack_trace(RubyVM::ThreadFrame.current)")
+  puts '=' * 30
+  eval("eval('print_stack_trace(RubyVM::ThreadFrame.current)')")
+  puts '=' * 30
+  eval("eval('print_stack_trace(RubyVM::ThreadFrame.current, :maxstack => 2)')")
+  puts '=' * 30
+  1.times do |a; b|
+    print_stack_trace(RubyVM::ThreadFrame::current)
+  end
+end

data/app/irb.rb

@@ -0,0 +1,112 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# This code comes more or less from ruby-debug.
+require 'irb'
+module IRB # :nodoc:
+  module ExtendCommand # :nodoc:
+    # FIXME: should we read these out of a directory to 
+    #        make this more user-customizable? 
+
+    # A base command class that resume execution
+    class DebuggerResumeCommand
+      def self.execute(conf, *opts)
+        name = 
+          if self.name =~ /IRB::ExtendCommand::(\S+)/
+            $1.downcase
+          else
+            'unknown'
+          end
+        $trepan_args = opts
+        $trepan_command = 
+          if $trepan_irb_statements 
+            $trepan_irb_statements
+          else
+            ([name] + opts).join(' ')
+          end
+
+        throw :IRB_EXIT, name.to_sym
+      end
+    end
+
+    class Continue < DebuggerResumeCommand ; end
+    class Finish   < DebuggerResumeCommand ; end
+    class Next     < DebuggerResumeCommand ; end
+    class Quit     < DebuggerResumeCommand ; end
+    class Step     < DebuggerResumeCommand ; end
+
+    # Issues a comamnd to the debugger without continuing
+    # execution. 
+    class Dbgr
+      def self.execute(conf, *opts)
+        $trepan_command = 
+          if opts.size == 1 && opts[0].is_a?(String)
+            $trepan_args = opts[0]
+          else
+            opts.join(' ')
+          end
+        dbg_cmdproc = conf.workspace.instance_variable_get('@dbg_cmdproc')
+        dbg_cmdproc.run_command($trepan_command)
+      end
+    end
+
+  end
+  if defined?(ExtendCommandBundle)
+    # New irb Commands which are the same name as their debugger
+    # counterpart
+    %w(Dbgr Finish Step).each do |name|
+      command = name.downcase
+      sym     = name.to_sym
+      ExtendCommandBundle.def_extend_command command, sym
+    end
+    # New irb Commands which are the slightly different from their
+    # debugger counterpart
+    [['cont',   :Continue],
+     ['n',      :Next],
+     ['q',      :Quit]].each do |command, sym|
+      ExtendCommandBundle.def_extend_command command, sym
+    end
+  end
+  
+  def self.start_session(binding, dbg_cmdproc, conf={})
+    unless @__initialized
+
+      # Set to run the standard rbdbgr IRB profile
+      irbrc = File.expand_path(File.join(File.dirname(__FILE__), 
+                                         %w(.. data irbrc)))
+      ENV['IRBRC'] = irbrc
+
+      args = ARGV.dup
+      ARGV.replace([])
+      IRB.setup(nil)
+      ARGV.replace(args)
+      
+      # If the user has a IRB profile, run that now.
+      if ENV['RBDBGR_IRB']
+        ENV['IRBRC'] = ENV['RBDBGR_IRB']
+        @CONF[:RC_NAME_GENERATOR]=nil
+        IRB.run_config
+      end
+
+      @__initialized = true
+    end
+    
+    workspace = WorkSpace.new(binding)
+    workspace.instance_variable_set('@dbg_cmdproc', dbg_cmdproc)
+
+    irb = Irb.new(workspace)
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+    conf.each {|k, v| @CONF[k] = v}
+    # A copy of this back_trace_limit is already active. How? 
+    IRB.CurrentContext.back_trace_limit = @CONF[:BACK_TRACE_LIMIT]
+
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  IRB.start_session(binding, nil) if ARGV.size > 0
+end

data/app/mock.rb

@@ -0,0 +1,22 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+class Trepan
+  attr_accessor :trace_filter # Procs/Methods we ignore.
+  def initialize(opts={})
+    @trace_filter = []
+  end
+  class MockDebugger
+    attr_reader :initial_dir
+    def initialize(settings={})
+      @initial_dir = '.'
+    end
+  end
+  class MockCore
+    attr_accessor :dbgr
+    attr_reader   :core
+    def initialize
+      @dbgr = MockDebugger.new
+    end
+    def event; 'line' end
+  end 
+end
+

data/app/options.rb

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+#=== Summary
+# Parses command-line options. 
+#=== Options
+#
+#<tt>--cd=DIR</tt>
+#      Change current directory to DIR.
+#
+#<tt>--command</tt> <i>file</i>::
+#      Run debugger command file <i>file</i>
+#
+#<tt>--nx</tt>::
+#      Don’t execute commands  found in any initialization
+#      files, e.g. <tt>.rdebugrc</tt>.
+#
+#<tt>--restore=PROFILE</tt>::
+#      Debugger command file which restores debugger settings,
+#      resumably saved before a 'restart' debugger command.
+#
+#<tt>--version</tt>::
+#      Show the version number.
+#
+#<tt>--help</tt>::
+#      Show invocation help and exit.
+
+require 'optparse'
+module Trepanning
+  require_relative 'default'
+
+  Trepanning::VERSION = '0.0.4.git' unless defined?(Trepanning::VERSION)
+  Trepanning::PROGRAM = 'trepan' unless defined?(Rbdbgr::PROGRAM)
+
+  def show_version
+    "#{PROGRAM} version #{VERSION}"
+  end
+
+  def copy_default_options
+    options = {}
+    DEFAULT_CMDLINE_SETTINGS.each do |key, value|
+      begin 
+        options[key] = value.clone
+      rescue TypeError
+        options[key] = value
+      end
+    end
+    options
+  end
+
+  def setup_options(options, stdout=$stdout, stderr=$stderr)
+    OptionParser.new do |opts|
+      opts.banner = <<EOB
+#{show_version}
+Usage: #{PROGRAM} [options] <script.rb> -- <script.rb parameters>
+EOB
+      opts.on('--command FILE', String, 
+              "Execute debugger commnds from FILE") do |cmdfile| 
+        if File.readable?(cmdfile)
+          options[:cmdfiles] << cmdfile
+        elsif File.exists?(cmdfile)
+            stderr.puts "Command file '#{cmdfile}' is not readable."
+        else
+          stderr.puts "Command file '#{cmdfile}' does not exist."
+        end
+      end
+      opts.on('--nx',
+              "Do not run debugger initialization files (e.g. #{CMD_INITFILE}") do
+        options[:nx] = true
+      end
+      # opts.on('--output FILE', String, "Name of file to record output") do |outfile| 
+      #   options[:outfile] = outfile
+      # end
+      opts.on("--cd DIR", String, "Change current directory to DIR") do |dir| 
+        if File.directory?(dir)
+          if File.executable?(dir)
+            options[:chdir] = dir
+          else
+            stderr.puts "Can't cd to #{dir}. Option --cd ignored."
+          end
+        else
+          stderr.puts "\"#{dir}\" is not a directory. Option --cd ignored."
+        end
+      end
+      opts.on("--restore PROFILE", String, 
+              "Restore debugger state using PROFILE") do |profile|
+        if File.readable?(profile)
+          options[:restore_profile] = profile
+          stderr.puts "Debugger command file #{profile} is not readable. --restore option ignored."
+        end
+      end
+      opts.on_tail("--help", "Show this message") do
+        options[:help] = true
+        stdout.puts opts
+      end
+      opts.on_tail("--version", 
+                   "print the version") do
+        options[:version] = true
+        stdout.puts show_version
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  include Rbdbgr
+  opts = {}
+  options ={}
+  [%w(--help), %w(--version)].each do |o|
+    options = copy_default_options
+    opts    = setup_options(options)
+    rest    = opts.parse o
+    puts options
+    puts '=' * 10
+  end
+  rest = opts.parse! ARGV
+  puts opts.to_s
+  puts '=' * 10
+  puts options
+  puts '=' * 10
+  puts Rbdbgr::DEFAULT_CMDLINE_SETTINGS
+end

data/app/run.rb

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rbconfig'
+module Trepanning
+
+  :module_function # All functions below are easily publically accessible
+
+  # Given a Ruby interpreter and program we are to debug, debug it.
+  # The caller must ensure that ARGV is set up to remove any debugger
+  # arguments or things that the debugged program isn't supposed to
+  # see.  FIXME: Should we make ARGV an explicit parameter?
+  def debug_program(dbgr, ruby_path, program_to_debug)
+
+    # Make sure Ruby script syntax checks okay.
+    # Otherwise we get a load message that looks like trepanning has 
+    # a problem. 
+    output = `#{ruby_path} -c #{program_to_debug.inspect} 2>&1`
+    if $?.exitstatus != 0 and RUBY_PLATFORM !~ /mswin/
+      puts output
+      exit $?.exitstatus 
+    end
+    # print "\032\032starting\n" if Trepan.annotate and Trepan.annotate > 2
+
+    dbgr.trace_filter << self.method(:debug_program)
+    dbgr.trace_filter << Kernel.method(:load)
+
+    old_dollar_0 = $0
+
+    # Without the dance below to set $0, setting it to a signifcantly
+    # longer value will truncate it in some OS's. See
+    # http://www.ruby-forum.com/topic/187083
+    $progname = program_to_debug
+    alias $0 $progname
+    dollar_0_tracker = lambda {|val| $program_name = val} 
+    trace_var(:$0, dollar_0_tracker)
+
+    dbgr.debugger(:hide_stack=>true) do
+      dbgr.core.processor.hidelevels[Thread.current] = 
+        RubyVM::ThreadFrame.current.stack_size + 1
+      Kernel::load program_to_debug
+    end
+
+    # The dance we have to undo to restore $0 and undo the mess created
+    # above.
+    $0 = old_dollar_0
+    untrace_var(:$0, dollar_0_tracker)
+  end
+
+  # Return an ARRAY which makes explicit what array is needed to pass
+  # to system() to reinvoke this debugger using the same Ruby
+  # interpreter.  Therefore, We want to the full path of both the Ruby
+  # interpreter and the debugger file ($0). We do this so as not to
+  # rely on an OS search lookup and/or the current working directory
+  # not getting changed from the initial invocation.
+  #
+  #    Hmmm, perhaps it is better to also save the initial working
+  #    directory? Yes, but on the other hand we can't assume that it 
+  #    still exists so we might still need to have the full paths.
+  # 
+  # It is the caller's responsibility to ensure that argv is the same
+  # as ARGV when the debugger was invokes.
+  def explicit_restart_argv(argv)
+    [ruby_path, File.expand_path($0)] + argv
+  end
+
+  # Path name of Ruby interpreter we were invoked with.
+  def ruby_path
+    File.join(%w(bindir RUBY_INSTALL_NAME).map{|k| RbConfig::CONFIG[k]})
+  end
+  module_function :ruby_path
+
+  # Do a shell-like path lookup for prog_script and return the results.
+  # If we can't find anything return prog_script.
+  def whence_file(prog_script)
+    if prog_script.index(File::SEPARATOR)
+      # Don't search since this name has path separator components
+      return prog_script
+    end
+    for dirname in ENV['PATH'].split(File::PATH_SEPARATOR) do
+      prog_script_try = File.join(dirname, prog_script)
+      return prog_script_try if File.readable?(prog_script_try)
+    end
+    # Failure
+    return prog_script
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  include  Trepanning
+  puts whence_file('irb')
+  puts whence_file('probably-does-not-exist')
+  puts ruby_path
+  p explicit_restart_argv(ARGV)
+end

data/app/thread.rb

@@ -0,0 +1,24 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+class Trepan
+  module ThreadHelper
+    # Return the thread at position num or object_id num.
+    def get_thread(num)
+      Thread.list.at(num) || 
+        Thread.list.detect {|t| t.object_id == num}
+    end
+    module_function :get_thread
+  end
+end
+
+# Demo it.
+if __FILE__ == $0
+  include Trepan::ThreadHelper
+  Object::Thread.new do 
+    [2, -2, 0, 1, -1,
+     Thread.main.object_id, 
+     Thread.current.object_id].each do |th_num|
+      puts "get_thread(#{th_num}) = #{get_thread(th_num).inspect}"
+    end
+  end.join
+    
+end

data/app/util.rb

@@ -0,0 +1,32 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+class Trepan
+  module Util
+
+    def safe_repr(str, max, suffix='...')
+      if str.is_a?(String) && str.size > max && !str.index("\n")
+        char = str[0..0]
+        opt_quote = 
+          if '"' == char || "'" == char
+            max -= 1
+            char
+          else
+            ''
+          end
+        "%s%s%s" % [ str[0...max], opt_quote, suffix ]
+      else
+        str
+      end
+    end
+    module_function :safe_repr
+    
+  end
+end
+
+if __FILE__ == $0
+  include Trepan::Util
+  string = 'The time has come to talk of many things.'
+  puts safe_repr(string, 50)
+  puts safe_repr(string, 17)
+  puts safe_repr(string.inspect, 17)
+  puts safe_repr(string.inspect, 17, '')
+end