trepanning 0.0.9 → 0.1.0

data/app/client.rb

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'default'                # default debugger settings
+require_relative '../interface/comcodes'  # communication codes
+
+module Trepanning
+  include Trepanning::RemoteCommunication
+  def start_client(options)
+    puts "Client option given"
+    dbgr = Trepan.new(:client      => true,
+                      :cmdfiles    => [],
+                      :initial_dir => options[:chdir],
+                      :nx          => true,
+                      :host        => options[:host],
+                      :port        => options[:port]
+                      )
+    intf = dbgr.intf[-1]
+    while true
+      begin
+        control_code, line = intf.read_remote
+      rescue EOFError, Errno::EPIPE
+        puts "Remote debugged process closed connection"
+        break
+      end
+      # p [control_code, line]
+      case control_code
+      when PRINT
+        print line
+      when CONFIRM_TRUE
+        response = intf.confirm(line, true)
+        intf.write_remote(CONFIRM_REPLY, response ? 'Y' : 'N')
+      when CONFIRM_FALSE
+        response = intf.confirm(line, true)
+        intf.write_remote(CONFIRM_REPLY, response ? 'Y' : 'N')
+      when PROMPT
+        # require 'trepanning'
+        # debugger
+        begin
+          command = intf.read_command(line)
+        rescue EOFError
+          puts "user-side EOF. Quitting..."
+          break
+        end
+        begin 
+          intf.write_remote(COMMAND, command)
+        rescue Errno::EPIPE
+          puts "Remote debugged process died"
+          break
+        end
+      when QUIT
+        break
+      when RESTART
+        break
+      else
+        $stderr.puts "** Unknown control code: #{control_code}"
+      end
+    end
+  end
+  module_function :start_client
+end

data/app/core.rb-consider

@@ -0,0 +1,198 @@
+# -*- coding: utf-8 -*-
+require 'thread_frame'
+require 'trace'
+# require_relative '../../rb-trace/app/trace'
+require_relative '../processor/main'
+class Debugger
+  # This class contains the Debugger 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 Debugger 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         # Debugger 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    # Debugger::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").
+          th = Thread.current
+          exec_event_tracing_old = th.exec_event_tracing
+          th.exec_event_tracing  = true
+          
+          # 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
+          th.exec_event_tracing  = exec_event_tracing_old
+        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/trepan'
+  dbg = Debugger.new()
+  if ARGV.size > 0
+    def foo(dbg)
+      p 'foo here'
+      dbg.debugger(:immediate=>true)
+    end
+    foo(dbg)
+  end
+end

data/app/default.rb

@@ -1,8 +1,6 @@
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2011 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
+class Trepan
 
   # I am not sure if we need to sets of hashes, but we'll start out
   # that way.
@@ -14,16 +12,28 @@ module Trepanning
     :delete_restore  => true,  # Delete restore profile after reading? 
     :initial_dir     => nil,   # If --cd option was given, we save it here.
     :nx              => false, # Don't run user startup file (e.g. .trepanrc)
+
+    # Default values used only when 'server' or 'client'
+    # (out-of-process debugging)
+    :port            => 1955,
+    :host            => 'localhost', 
+
     :restart_argv    => RubyVM::OS_ARGV,
                                # Command run when "restart" is given.
-    :restore_profile => nil    # Profile used to set/restore debugger state
+    :restore_profile => nil,   # Profile used to set/restore debugger state
+    :server          => false, # Out-of-process debugging?
   } unless defined?(DEFAULT_SETTINGS)
 
   # Default settings for Trepan run from the command line.
   DEFAULT_CMDLINE_SETTINGS = {
     :cmdfiles => [],  # Initialization command files to run
+    :client   => false, # Attach to out-of-process program?
     :nx       => false, # Don't run user startup file (e.g. .trepanrc)
     :output   => nil,
+    :port     => DEFAULT_SETTINGS[:port],
+    :host     => DEFAULT_SETTINGS[:host], 
+    :server   => false, # Out-of-process debugging?
+    # Note that at most one of :server or :client can be true.
   } unless defined?(DEFAULT_CMDLINE_SETTINGS)
 
   DEFAULT_DEBUG_STR_SETTINGS = {
@@ -49,7 +59,7 @@ end
 if __FILE__ == $0
   # Show it:
   require 'pp'
-  PP.pp(Trepanning::DEFAULT_SETTINGS)
+  PP.pp(Trepan::DEFAULT_SETTINGS)
   puts '=' * 30
-  PP.pp(Trepanning::DEFAULT_CMDLINE_SETTINGS)
+  PP.pp(Trepan::DEFAULT_CMDLINE_SETTINGS)
 end

data/app/disassemble.rb

@@ -7,7 +7,13 @@
 class Trepan
   module Disassemble
     def mark_disassembly(disassembly_str, iseq_equal, pc_offset,
-                         brkpt_offsets=[], max_width=80)
+                         brkpt_offsets=[], max_width=80, highlight=nil)
+
+      if highlight
+        require_relative '../app/yarv'
+        highlighter = CodeRay::Duo[:yarv, :term]
+      end
+
       dis_array = disassembly_str.split(/\n/)
       dis_array.map do |line|
         if line =~ /^(.*?)(\s+)(\(\s+\d+\))?$/
@@ -37,7 +43,11 @@ class Trepan
         if (shrink_amount > 0) && line_padding.size > shrink_amount
           line_padding = ' ' * (line_padding.size - shrink_amount)
         end
-        prefix + line_begin + line_padding + line_end
+        if highlight && prefix != ''
+          prefix + highlighter.encode(line_begin + line_padding + line_end)
+        else
+          prefix + line_begin + line_padding + line_end
+        end
       end
     end
     module_function :mark_disassembly

data/app/options.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 # -*- coding: utf-8 -*-
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 #=== Summary
 # Parses command-line options. 
 #=== Options
@@ -26,17 +26,17 @@
 #      Show invocation help and exit.
 
 require 'optparse'
-module Trepanning
+class Trepan
   require_relative 'default'
 
-  Trepanning::VERSION = '0.0.4.git' unless defined?(Trepanning::VERSION)
-  Trepanning::PROGRAM = 'trepan' unless defined?(Rbdbgr::PROGRAM)
+  Trepan::VERSION = '0.1.0'
+  Trepan::PROGRAM = 'trepan'
 
-  def show_version
-    "#{PROGRAM} version #{VERSION}"
+  def self.show_version
+    "#{PROGRAM}, version #{VERSION}"
   end
 
-  def copy_default_options
+  def self.copy_default_options
     options = {}
     DEFAULT_CMDLINE_SETTINGS.each do |key, value|
       begin 
@@ -48,18 +48,26 @@ module Trepanning
     options
   end
 
-  def setup_options(options, stdout=$stdout, stderr=$stderr)
+  def self.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| 
+      opts.on('--client',
+              "Connect to out-of-process program") do
+        if options[:server]
+          stderr.puts "--server option previously given. --client option ignored."
+        else
+          options[:client] = true
+        end
+      end
+      opts.on('-c', '--command FILE', String, 
+              "Execute debugger commands from FILE") do |cmdfile| 
         if File.readable?(cmdfile)
           options[:cmdfiles] << cmdfile
         elsif File.exists?(cmdfile)
-            stderr.puts "Command file '#{cmdfile}' is not readable."
+            stderr.puts "Command file '#{cmdfile}' is not readable. Option ignored."
         else
           stderr.puts "Command file '#{cmdfile}' does not exist."
         end
@@ -82,6 +90,18 @@ EOB
           stderr.puts "\"#{dir}\" is not a directory. Option --cd ignored."
         end
       end
+      opts.on("-h", "--host NAME", String, 
+              "Host or IP used in TCP connections for --server or --client. " + 
+              "Default is #{DEFAULT_SETTINGS[:host].inspect}.") do 
+        |name_or_ip| 
+        options[:host] = name_or_ip
+      end
+      opts.on("-p", "--port NUMBER", Integer, 
+              "Port number used in TCP connections for --server or --client. " + 
+              "Default is #{DEFAULT_SETTINGS[:port]}.") do 
+        |num| 
+        options[:port] = num
+      end
       opts.on("--restore PROFILE", String, 
               "Restore debugger state using PROFILE") do |profile|
         if File.readable?(profile)
@@ -89,11 +109,23 @@ EOB
           stderr.puts "Debugger command file #{profile} is not readable. --restore option ignored."
         end
       end
-      opts.on_tail("--help", "Show this message") do
+      opts.on('--server',
+              "Set up for out-of-process debugging") do
+        if options[:client]
+          stderr.puts "--client option previously given. --server option ignored."
+        else
+          options[:server] = true
+        end
+      end
+      opts.on('--[no-]highlight',
+              "Set output for terminal highlighting") do |v|
+        options[:highlight] = ((v) ? :term : nil)
+      end
+      opts.on_tail("-?", "--help", "Show this message") do
         options[:help] = true
         stdout.puts opts
       end
-      opts.on_tail("--version", 
+      opts.on_tail("-v", "--version", 
                    "print the version") do
         options[:version] = true
         stdout.puts show_version
@@ -103,20 +135,19 @@ EOB
 end
 
 if __FILE__ == $0
-  include Rbdbgr
   opts = {}
   options ={}
   [%w(--help), %w(--version)].each do |o|
-    options = copy_default_options
-    opts    = setup_options(options)
+    options = Trepan::copy_default_options
+    opts    = Trepan::setup_options(options)
     rest    = opts.parse o
-    puts options
+    p options
     puts '=' * 10
   end
   rest = opts.parse! ARGV
-  puts opts.to_s
+  puts opts
   puts '=' * 10
-  puts options
+  p options
   puts '=' * 10
-  puts Rbdbgr::DEFAULT_CMDLINE_SETTINGS
+  p Trepan::DEFAULT_CMDLINE_SETTINGS
 end