trepanning 0.0.4

data/app/core.rb

@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'thread_frame'
+require 'trace'
+# require_relative '../../rb-trace/app/trace'
+require_relative '../processor/main'
+class Trepan
+  # This class contains the Trepan core routines, such as an event
+  # processor which is responsible of handling what to do when an event is
+  # triggered.
+  # 
+  # See also 'rdbgr' the top-level Trepan class and command-line routine
+  # which ultimately will call this.
+
+  class Core
+    attr_accessor :async_events # bitmask of asyncronous events - used all
+                                # the time
+    attr_reader   :dbgr         # Trepan instance
+    attr_reader   :event        # String - event which triggering event
+                                # processor
+    attr_reader   :event_proc   # Proc of method event_processor
+    attr_accessor :exception    # Return exception to pass back. A 'raise'
+                                # command can set this.
+    attr_reader   :frame        # ThreadFrame instance
+    attr_reader   :hook_arg     # 'arg' passed from trace hook
+    attr_accessor :mutex        # mutex to lock out other threads from
+                                # entering debugger while we are in it.
+    attr_accessor :processor    # Trepan::CmdProc instance
+    attr_reader   :settings     # Hash of things you can configure
+    attr_accessor :step_count   # Fixnum. Negative means no tracing,
+                                # 0 means stop on next event, 1 means 
+                                # ignore one event. Step events gives the
+                                # kind of things to count as a step.
+    attr_accessor :step_events  # bitmask of events - used only when 
+                                # we are stepping
+    attr_accessor :unmaskable_events 
+
+    include Trace
+
+    unless defined?(CORE_DEFAULT_SETTINGS)
+      # Synchronous events
+      STEPPING_EVENT_MASK = 
+        LINE_EVENT_MASK     | CLASS_EVENT_MASK    | CALL_EVENT_MASK     |
+        RETURN_EVENT_MASK   | C_CALL_EVENT_MASK   | C_RETURN_EVENT_MASK |
+        INSN_EVENT_MASK     | BRKPT_EVENT_MASK
+
+      ASYNC_EVENT_MASK = 
+        RAISE_EVENT_MASK    | VM_EVENT_MASK       | SWITCH_EVENT_MASK
+
+      CORE_DEFAULT_SETTINGS = {
+        :cmdproc_opts      => {},
+        :debug_core_events => false,
+        :hook_name         => :event_processor, # or :old_event_processor
+        :step_count        => 0,                # Stop at next event
+        :async_events      => ASYNC_EVENT_MASK,
+
+        # FIXME:
+        # Somewhere inside the VM we allow I guess nested tracing which is messing
+        # up ThreadFrame pointers and information. When this is fixed we can do the below.
+        # Until then we need to at least remove C calls and returns and possibly other
+        # events as well.
+        # :step_events       =>  
+	# (DEFAULT_EVENT_MASK | INSN_EVENT_MASK)
+
+        :step_events       =>  
+	(DEFAULT_EVENT_MASK | INSN_EVENT_MASK) &
+	~(C_CALL_EVENT_MASK | C_RETURN_EVENT_MASK)
+      } 
+
+    end
+
+    def initialize(debugger, settings={})
+      @dbgr         = debugger
+      @exception    = nil
+      @mutex        = Mutex.new
+      @settings     = CORE_DEFAULT_SETTINGS.merge(settings)
+
+      @step_count   = @settings[:step_count]
+      @step_events  = @settings[:step_events]
+      @async_events = @settings[:async_events]
+      @debug_events = @settings[:debug_core_events]
+
+      hook_name     = @settings[:hook_name]
+      @event_proc   = self.method(hook_name).to_proc
+      @processor    = CmdProcessor.new(self, @settings[:cmdproc_opts])
+      @unmaskable_events = %w(brkpt raise switch vm)
+    end
+
+    def step_events_list
+      if 0 == @step_events
+        return nil
+      else
+        Trace.bitmask2events(@step_events).join(', ')
+      end
+    end
+
+    # A trace-hook processor with the interface a trace hook should have.
+    def event_processor(event, frame, arg=nil)
+
+      return_exception = nil
+      # FIXME: check for breakpoints or other unmaskable events. 
+      # For now there are none.
+
+      @mutex.synchronize do
+        @frame = frame
+        while @frame.type == 'IFUNC'
+          @frame = @frame.prev
+        end
+        
+        if @step_count > 0
+          @step_count -= 1
+          break
+        elsif @step_count < 0 && ! @unmaskable_events.member?(event)
+          break
+        end
+
+        @event    = event
+        @hook_arg = arg
+        
+        ### debug:
+        ### puts "#{frame.source_container[1]}:#{frame.source_location[0]}:in `#{frame.method}' #{event}" # if %w(line).member?(event)
+        @processor.process_commands(@frame)
+                
+        # FIXME: There should be a Trace.event_mask which should return the first
+        # mask that matches the given trace hook.
+        if @step_count < 0
+          # If we are continuing, no need to stop at stepping events.
+          Trace.event_masks[0] &= ~STEPPING_EVENT_MASK 
+        else
+          # Set to trace only those events we are interested in.  
+          
+          # Don't step/trace into Ruby routines called from here in the code
+          # below (e.g. "trace_hooks").
+          step_count_save = step_count
+          @step_count     = -1 
+          
+          unless @event_proc == dbgr.trace_filter.hook_proc
+            dbgr.trace_filter.add_trace_func(@event_proc) 
+            ## debug: p '+++1', @event_proc, dbgr.trace_filter.hook_proc
+          end
+          
+          # FIXME: this doesn't work. Bug in rb-trace? 
+          # Trace.event_masks[0] = @step_events | @async_events
+          RubyVM::TraceHook::trace_hooks[0].event_mask = 
+            @step_events | @async_events
+          @step_count = step_count_save
+        end
+        
+        # Nil out variables just in case...
+        
+        return_exception = @exception
+        @frame = @event = @arg = @exception = nil
+
+      end
+      return return_exception 
+    end
+
+    # A Ruby 1.8-style event processor. We don't use file, line, id, bind. 
+    def old_event_processor(event, file, line, id, bind, klass)
+      event_processor(event, RubyVM::ThreadFrame.current.prev)
+    end
+
+    # Call this from inside the program you want to get a synchronous
+    # call to the debugger. set prev_count to the number of levels 
+    # *before* the caller you want to skip.
+    def debugger(prev_count=0)
+      while @frame && @frame.type == 'IFUNC'
+        @frame = @frame.prev
+      end
+      frame = RubyVM::ThreadFrame.current.prev(prev_count+1)
+      @step_count = 0  # Make event processor stop
+      event_processor('debugger-call', frame)
+    end
+    
+    # A trace-hook processor for 'trace var'
+    def trace_var_processor(val)
+      frame = RubyVM::ThreadFrame.current.prev
+      if 'CFUNC' == frame.type
+        # Don't need the C call that got us here.
+        prev = frame.prev
+        frame = frame.prev if prev
+      end
+
+      # Stop future tracing into the debugger
+      Thread.current.tracing = true  
+      
+      @step_count = 0  # Make event processor stop
+      event_processor('trace-var', frame)
+    end
+
+  end
+end
+if __FILE__ == $0
+  require_relative '../lib/trepanning'
+  dbg = Trepan.new()
+  if ARGV.size > 0
+    def foo(dbg)
+      p 'foo here'
+      dbg.debugger(:immediate=>true)
+    end
+    foo(dbg)
+  end
+end

data/app/default.rb

@@ -0,0 +1,54 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# A place for the default settings
+# This could be put elsewhere but it is expected that this will grow
+# get quite large.
+module Trepanning
+
+  # I am not sure if we need to sets of hashes, but we'll start out
+  # that way.
+
+  # Default settings for a Trepan class object
+  DEFAULT_SETTINGS = {
+    :cmdproc_opts    => {},    # Default Trepan::CmdProcessor settings
+    :core_opts       => {},    # Default Trepan::Core settings
+    :delete_restore  => true,  # Delete restore profile after reading? 
+    :initial_dir     => nil,   # Current directory run when "restart" is given
+    :nx              => false, # Don't run user startup file (e.g. .rbdbgrc)
+    :restart_argv    => [],    # Command run when "restart" is given
+    :restore_profile => nil    # Profile used to set/restore debugger state
+  } unless defined?(DEFAULT_SETTINGS)
+
+  # Default settings for Trepan run from the command line.
+  DEFAULT_CMDLINE_SETTINGS = {
+    :cmdfiles => [],  # Initialization command files to run
+    :nx       => false, # Don't run user startup file (e.g. .rbdbgrc)
+    :output   => nil,
+  } unless defined?(DEFAULT_CMDLINE_SETTINGS)
+
+  DEFAULT_DEBUG_STR_SETTINGS = {
+    :core_opts => {
+      :cmdproc_opts => {:different => false}},
+    :hide_stack => true,
+  } unless defined?(DEFAULT_DEBUG_STR_SETTINGS)
+
+  CMD_INITFILE_BASE = 
+    if RUBY_PLATFORM =~ /mswin/
+      # Of course MS Windows has to be different
+      HOME_DIR     =  (ENV['HOME'] || 
+                       ENV['HOMEDRIVE'].to_s + ENV['HOMEPATH'].to_s).to_s
+      'trepan.ini'
+    else
+      HOME_DIR = ENV['HOME'].to_s
+      '.trepanrc'
+    end unless defined?(CMD_INITFILE_BASE)
+  CMD_INITFILE = File.join(HOME_DIR, CMD_INITFILE_BASE) unless
+    defined?(CMD_INITFILE)
+end
+
+if __FILE__ == $0
+  # Show it:
+  require 'pp'
+  PP.pp(Trepanning::DEFAULT_SETTINGS)
+  puts '=' * 30
+  PP.pp(Trepanning::DEFAULT_CMDLINE_SETTINGS)
+end

data/app/disassemble.rb

@@ -0,0 +1,61 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Splits String dissasemble_str into an array for for each
+# line. Line(s) that Fixnum pc_offset matches at the beginning of the
+# line will have prefix "--> " added, otherwise the line will have " "
+# added to the beginning.  This array is returned.
+
+class Trepan
+  module Disassemble
+    def mark_disassembly(disassembly_str, iseq_equal, pc_offset,
+                         brkpt_offsets=[])
+      dis_array = disassembly_str.split(/\n/)
+      dis_array.map do |line|
+        prefix = 
+          if line =~ /^(\d{4}) /
+            offset = $1.to_i
+            bp = brkpt_offsets && brkpt_offsets.member?(offset) ? 'B' : ' '
+            bp + if offset == pc_offset && iseq_equal
+              '--> '
+            else
+              '    '
+            end
+          else
+            ''
+          end
+        prefix + line
+      end
+    end
+    module_function :mark_disassembly
+
+    def disassemble_split(disassembly_str)
+      dis_array = disassembly_str.split(/\n/)
+      dis_hash  = {}
+      dis_array.each do |line|
+        dis_hash[$1.to_i] = line if line =~ /^(\d{4}) /
+      end
+      dis_hash
+    end
+    module_function :disassemble_split
+
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  include Trepan::Disassemble
+  dis_string='
+local table (size: 6, argc: 1 [opts: 0, rest: -1, post: 0, block: -1] s1)
+[ 6] relative_feature<Arg>[ 5] c          [ 4] e          [ 3] file       [ 2] absolute_feature
+0000 trace            8                                               (  26)
+0002 trace            1                                               (  27)
+0004 putnil           
+'
+  [[-1, []], [2, [2]], [10, [0, 4]]].each do |pc_offset, brkpts|
+    puts '-' * 40
+    puts mark_disassembly(dis_string, true, pc_offset, brkpts).join("\n")
+  end
+  puts mark_disassembly(dis_string, false, 2).join("\n")
+  puts '-' * 40
+  require 'pp'
+  PP.pp(disassemble_split(dis_string), $stdout)
+end

data/app/display.rb

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Classes to support gdb-like display/undisplay.
+
+require_relative 'frame'
+
+# return suitable frame signature to key display expressions off of.
+def display_signature(frame)
+  return nil unless frame
+  frame.iseq.object_id
+end
+
+# Manage a list of display expressions.
+class DisplayMgr
+  
+  def initialize
+    @next = 0
+    @list = []
+  end
+  
+  def add(frame, arg, fmt=nil)
+    return nil unless frame
+    begin
+      eval(arg, frame.binding)
+    rescue
+      return nil
+    end
+    @next += 1
+    d = Display.new(frame, arg, fmt, @next)
+    @list << d
+    d
+  end
+
+  # List all display items; return 0 if none
+  def all
+    s = []
+    unless @list.empty?
+      s << "Auto-display expressions now in effect:
+Num Enb Expression"
+      @list.each do |display|
+        s << display.format
+      end
+    end
+    s
+  end
+
+  # Delete all display expressions"""
+  def clear
+    @list = []
+  end
+
+  # Delete display expression i
+  def delete_index(display_number)
+    @list.each_with_index do |display, i|
+      if display_number == display.number
+        @list[i..i] = []
+        return true
+      end
+    end
+    false
+  end
+
+  # display any items that are active'''
+  def display(frame)
+    return unless frame
+    s = []
+    sig = display_signature(frame)
+    @list.each do |display|
+      if display.enabled # && display.signature == sig
+        s << display.to_s(frame)
+      end
+    end
+    return s
+  end
+
+  def enable_disable(display_number, b_enable_disable)
+    @list.each do |display|
+      if display_number == display.number
+        display.enabled = b_enable_disable
+        return true
+      end
+    end
+    false
+  end
+end
+
+class Display
+  attr_reader   :number
+  attr_reader   :signature
+  attr_accessor :enabled
+  
+  def initialize(frame, arg, fmt, number)
+    @signature = display_signature(frame)
+    @fmt       = fmt
+    @arg       = arg
+    @enabled   = true
+    @number    = number
+  end
+
+  def to_s(frame)
+    return 'No symbol "' + @arg + '" in current context.' unless frame
+    
+    begin
+      val = eval(@arg, frame.binding)
+    rescue
+      return "No symbol \"#{@arg}\" in current context."
+    end
+    s = "#{self.format(false)} = #{val}"
+    return s
+  end
+
+  # format display item
+  def format(show_enabled=true)
+    what = ''
+    what += @enabled ? ' y ' : ' n ' if 
+      show_enabled
+    what += (@fmt + ' ') if @fmt
+    what += @arg if @arg
+    '%3d: %s' % [@number, what]
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  mgr = DisplayMgr.new
+
+  def print_display(mgr)
+    mgr.all.each {|line| puts line}
+    puts '=' * 40
+  end
+    
+  require 'thread_frame'
+  frame = RubyVM::ThreadFrame::current
+
+  x = 1
+  mgr.add(frame, 'x > 1')
+  print_display(mgr)
+
+  mgr.enable_disable(1, false)
+  print_display(mgr)
+
+  mgr.enable_disable(1, true)
+  print_display(mgr)
+
+  mgr.clear()
+  print_display(mgr)
+
+end

data/app/file.rb

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Things related to file/module status
+require 'thread_frame'
+
+SCRIPT_ISEQS__ = {} unless 
+  defined?(SCRIPT_ISEQS__) && SCRIPT_ISEQS__.is_a?(Hash)
+ISEQS__        = {} unless 
+  defined?(ISEQS__) && ISEQS__.is_a?(Hash)
+
+module Trepanning
+  def file_match_pat(filename)
+    prefix = 
+      if filename[0..0] == File::SEPARATOR
+        # An absolute filename has to match at the beginning and
+        # the end.
+        '^'
+      else
+        # An nonabsolute filename has to match either at the
+        # beginning of the file name or have a path separator before
+        # the supplied part, e.g. "file.rb" does not match "myfile.rb"
+        # but matches "my/file.rb"
+        '(?:^|[/])'
+      end
+    "#{prefix}#{Regexp.escape(filename)}$"
+  end
+
+  def filter_scripts(dirname)
+    match_block = Proc.new{|filename, iseq| filename =~ /^#{dirname}/}
+    scripts = SCRIPT_ISEQS__.select(&match_block)
+    SCRIPT_ISEQS__.delete_if(&match_block)
+    match_block = Proc.new{|iseq| 
+      iseq.source_container[1] =~ /^#{dirname}/
+    }
+    rejected = {}
+    # SCRIPT_ISEQS__ is updated automatically.  Dup copy is to make
+    # sure we we aren't iterating over something that some other
+    # process, thread or hook is filling.
+    script_iseqs = SCRIPT_ISEQS__.dup
+    script_iseqs.each do |name, iseqs|
+      ary = iseqs.select(&match_block)
+      rejected[name] = ary unless ary.empty?
+      iseqs.delete_if(&match_block)
+    end
+    return [scripts, rejected]
+  end
+
+  def find_scripts(filename)
+    filename_pat = file_match_pat(filename)
+    return SCRIPT_ISEQS__.keys.grep(/#{filename_pat}/)
+  end
+
+  def find_iseqs(iseqs_hash, name)
+    iseq_name, filename = name.split(/@/)
+    return [] unless iseqs_hash.member?(iseq_name)
+    iseqs = iseqs_hash[iseq_name]
+    # FIXME: filter out debugger iseqs
+    if filename
+      filename_pat = file_match_pat(filename)
+      iseqs.select{|iseq| iseq.source_container[1] =~ /#{filename_pat}/}
+    else
+      return iseqs 
+    end
+  end
+
+  def find_iseqs_with_lineno(filename, lineno)
+    files = find_scripts(filename)
+    files.each do |file|
+      found = 
+        SCRIPT_ISEQS__[file].detect do |iseq|
+        iseq.offsetlines.values.flatten.uniq.member?(lineno)
+      end
+      return found if found
+    end
+    return nil
+  end
+
+  # parse_position(errmsg, arg)->(fn, name, lineno)
+  #    
+  #  Parse arg as [filename|module:]lineno
+  #  Make sure it works for C:\foo\bar.rb:12
+  def parse_position(errmsg, arg)
+    colon = arg.rindex(':') 
+    if colon
+      # FIXME: Handle double colons, e.g. File::open
+      filename = arg[0..colon-1].rstrip
+      m, f = lookupmodule(filename)
+      if not f
+        errmsg.call("'%s' not found using sys.path" % filename)
+        return nil, nil, nil
+      else
+        filename = f
+        arg = arg[colon+1..-1].lstrip
+      end
+      begin
+        lineno = Integer(arg)
+      rescue 
+        errmsg.call("Bad line number: %s", arg)
+        return nil, filename, nil
+      end
+      return nil, filename, lineno
+    end
+    return nil, nil, nil
+  end
+end
+# Demo it
+if __FILE__ == $0
+  include Trepanning
+  if !(ARGV.size == 1 && ARGV[0] == 'noload')
+    ISEQS__        = {}
+    SCRIPT_ISEQS__ = {}
+    ARGV[0..-1]    = ['noload']
+    load(__FILE__)
+  else    
+    load 'tmpdir.rb'
+    tmpdir_dir = File.dirname(find_scripts('tmpdir.rb')[0])
+    p tmpdir_dir
+    %w(tmpdir.rb /tmpdir.rb sometmpdir.rb).each do |filename|
+      p find_scripts(filename)
+    end
+    p find_scripts(__FILE__)
+    def tmpdir
+      'to conflict with the other tmpdir'
+    end
+    p find_iseqs(ISEQS__, "tmpdir@#{__FILE__}")
+    puts '-' * 20
+    p SCRIPT_ISEQS__.keys
+    puts '-' * 20
+    scripts, rejected = filter_scripts(tmpdir_dir)
+    p scripts.keys
+    p rejected.keys
+    puts '-' * 20
+    p SCRIPT_ISEQS__.keys
+  end
+end