rbx-trepanning 0.0.1-universal-rubinius

data/processor/breakpoint.rb

@@ -0,0 +1,161 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../app/brkptmgr'
+class Trepan
+
+  class CmdProcessor
+
+    attr_reader   :brkpts          # BreakpointManager. 
+
+    attr_reader   :brkpt           # Breakpoint. If we are stopped at a
+                                   # breakpoint this is the one we
+                                   # found.  (There may be other
+                                   # breakpoints that would have caused a stop
+                                   # as well; this is just one of them).
+                                   # If no breakpoint stop this is nil.
+
+    def breakpoint_initialize
+      @brkpts = BreakpointMgr.new
+      @brkpt  = nil
+    end
+
+    def breakpoint?
+      @brkpt = @dbgr.breakpoint
+      return !!@brkpt && %w(tbrkpt brkpt).member?(@brkpt.event)
+    end
+
+    def breakpoint_find(bpnum, show_errmsg = true)
+      if 0 == @brkpts.size 
+        errmsg('No breakpoints set.') if show_errmsg
+        return nil
+      elsif bpnum > brkpts.size || bpnum < 1
+        errmsg('Breakpoint number %d is out of range 1..%d' %
+               [bpnum, brkpts.size]) if show_errmsg
+        return nil
+      end
+      bp = @brkpts[bpnum]
+      unless bp
+        errmsg "Unknown breakpoint '#{bpnum}'" if show_errmsg
+        return nil
+      end
+      bp
+    end
+    
+    def set_breakpoint_method(descriptor, meth, line=nil, ip=nil,
+                              opts={:event => 'brkpt',:temp => false})
+      cm =  
+        if meth.kind_of?(Method) || meth.kind_of?(UnboundMethod)
+          meth.executable 
+        else
+          meth
+        end
+        
+      unless cm.kind_of?(Rubinius::CompiledMethod)
+        errmsg "Unsupported method type: #{cm.class}"
+        return nil
+      end
+
+      if line
+        ip = cm.first_ip_on_line(line)
+        
+        if ip == -1
+          errmsg "Unknown line '#{line}' in method '#{cm.name}'"
+          return nil
+        end
+      elsif !ip
+        line = cm.first_line
+        ip = 0
+      end
+
+      bp = @brkpts.add(descriptor, cm, ip, line, @brkpts.max+1, opts)
+      bp.activate
+      msg("Set %sbreakpoint #{bp.id}: #{meth.name}() at #{bp.location}" % 
+          (opts[:temp] ? 'temporary ' : ''))
+      return bp
+    end
+
+    # MRI 1.9.2 code
+    # def breakpoint_find(bpnum, show_errmsg = true)
+    #   if 0 == @brkpts.size 
+    #     errmsg('No breakpoints set.') if show_errmsg
+    #     return nil
+    #   elsif bpnum > @brkpts.max || bpnum < 1
+    #     errmsg('Breakpoint number %d is out of range 1..%d' %
+    #            [bpnum, @brkpts.max]) if show_errmsg
+    #     return nil
+    #   end
+    #   bp = @brkpts[bpnum]
+    #   if bp
+    #     return bp
+    #   else
+    #     errmsg('Breakpoint number %d previously deleted.' %
+    #            bpnum) if show_errmsg
+    #     return nil
+    #   end
+    # end
+
+    # # Does whatever needs to be done to set a breakpoint
+    # def breakpoint_line(line_number, iseq, temp=false)
+    #   # FIXME: handle breakpoint conditions.
+    #   iseq = iseq.child_iseqs.detect do |iseq|
+    #     iseq.lineoffsets.keys.member?(line_number) 
+    #   end
+    #   offset = 
+    #     if iseq 
+    #       # FIXME
+    #       iseq.line2offsets(line_number)[1] || iseq.line2offsets(line_number)[0]
+    #     else
+    #       nil
+    #     end
+    #   unless offset
+    #     place = "in #{iseq.source_container.join(' ')} " if iseq 
+    #     errmsg("No line #{line_number} found #{place}for breakpoint.")
+    #     return nil
+    #   end
+    #   @brkpts.add(iseq, offset, :temp => temp)
+    # end
+
+    # def breakpoint_offset(offset, iseq, temp=false)
+    #   # FIXME: handle breakpoint conditions.
+    #   unless iseq.offsetlines.keys.member?(offset)
+    #     errmsg("Offset #{offset} not found in #{iseq.name} for breakpoint.")
+    #     return nil
+    #   end
+    #   @brkpts.add(iseq, offset, :temp => temp, :type => 'offset')
+    # end
+
+    # Delete a breakpoint given its breakpoint number.
+    # FIXME: use do_enable 
+    def delete_breakpoint_by_number(bpnum, do_enable=true)
+      bp = breakpoint_find(bpnum)
+      return false unless bp
+      delete_breakpoint(bp)
+    end
+
+    def delete_breakpoint(bp)
+      @brkpts.delete_by_brkpt(bp)
+      return true
+    end
+
+    # MRI 1.9.2 code
+    # # Enable or disable a breakpoint given its breakpoint number.
+    # def en_disable_breakpoint_by_number(bpnum, do_enable=true)
+    #   bp = breakpoint_find(bpnum)
+    #   return false unless bp
+          
+    #   enable_disable = do_enable ? 'en' : 'dis'
+    #   if bp.enabled? == do_enable
+    #     errmsg('Breakpoint %d previously %sabled.' % 
+    #            [bpnum, enable_disable])
+    #     return false
+    #   end
+    #   bp.enabled = do_enable
+    #   return true
+    # end
+  end
+end
+
+if __FILE__ == $0
+  cmdproc = Trepan::CmdProcessor.new
+  cmdproc.breakpoint_initialize
+end

data/processor/command/alias.rb

@@ -0,0 +1,55 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+
+class Trepan::Command::AliasCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} ALIAS COMMAND
+
+Add an alias for a COMMAND
+
+See also 'unalias'.
+    HELP
+
+    CATEGORY      = 'support'
+    MAX_ARGS      = 2  # Need at most this many
+    NAME          = File.basename(__FILE__, '.rb')
+    NEED_STACK    = true
+    SHORT_HELP    = 'Add an alias for a debugger command'
+  end
+  
+  # Run command. 
+  def run(args)
+    if args.size == 1
+      @proc.commands['show'].run(%w(show alias))
+    elsif args.size == 2
+      @proc.commands['show'].run(%W(show alias #{args[1]}))
+    else
+      junk, al, command = args
+      old_command = @proc.aliases[al]
+      if @proc.commands.member?(command)
+        @proc.aliases[al] = command
+        if old_command
+          msg("Alias '#{al}' for command '#{command}' replaced old " + 
+              "alias for '#{old_command}'.")
+        else
+          msg "New alias '#{al}' for command '#{command}' created."
+        end
+      else
+        errmsg "You must alias to a command name, and '#{command}' isn't one."
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run %W(#{cmd.name} yy foo)
+  cmd.run [cmd.name]
+  cmd.run %W(cmd.name yy next)
+end

data/processor/command/backtrace.rb

@@ -0,0 +1,46 @@
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+
+class Trepan::Command::BacktraceCommand < Trepan::Command
+  ALIASES      = %w(bt where)
+  CATEGORY     = 'stack'
+  NAME         = File.basename(__FILE__, '.rb')
+  HELP = <<-HELP
+Show the call stack as a simple list.
+
+Passing "-v" will also show the values of all locals variables
+in each frame.
+      HELP
+  NEED_STACK   = true
+  SHORT_HELP   =  'Show the current call stack'
+  
+  def run(args)
+    arg_str = args[1..-1].join(' ')
+    verbose = (arg_str =~ /-v/)
+
+    count = 
+      if m = /(\d+)/.match(arg_str)
+        m[1].to_i
+      else
+        proc.stack_size
+    end
+    
+    msg "Backtrace:"
+    
+    @proc.dbgr.each_frame(@proc.top_frame) do |frame|
+      return if count and frame.number >= count
+
+
+      prefix = (frame == @proc.frame) ? '-->' : '   '
+      msg "%s #%d %s" % [prefix, frame.number, 
+                         frame.describe(:show_ip => verbose)]
+      
+      if verbose
+        frame.local_variables.each do |local|
+          msg "       #{local} = #{frame.run(local.to_s).inspect}"
+        end
+      end
+    end
+  end
+end
+

data/processor/command/base/cmd.rb

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Base class of all commands. Code common to all commands is here.
+# Note: don't end classname with Command (capital C) since main
+# will think this a command name like QuitCommand 
+require 'rubygems'
+require 'columnize'
+
+class Trepan
+  class Command
+    attr_accessor :core, :proc
+
+    unless defined?(MIN_ARGS)
+      MIN_ARGS      = 0      # run()'s args array must be at least this many
+      MAX_ARGS      = nil    # run()'s args array must be at least this many
+      NEED_STACK    = false  # We'll say that commands which need a stack
+                             # to run have to declare that and those that
+                             # don't don't have to mention it.
+    end
+
+    def initialize(proc)
+      @name = my_const(:NAME)
+      @proc = proc
+    end
+
+    def category
+      my_const(:CATEGORY)
+    end
+
+    # List commands arranged in an aligned columns
+    def columnize_commands(commands)
+      width = settings[:maxwidth]
+      Columnize::columnize(commands, width, ' ' * 4, 
+                           true, true, ' ' * 2).chomp
+    end
+
+    def columnize_numbers(commands)
+      width = settings[:maxwidth]
+      Columnize::columnize(commands, width, ', ',
+                           false, false, ' ' * 2).chomp
+    end
+
+    # FIXME: probably there is a way to do the delegation to proc methods
+    # without having type it all out.
+
+    def confirm(message, default)
+      @proc.confirm(message, default)
+    end
+
+    def errmsg(message)
+      @proc.errmsg(message)
+    end
+
+    def obj_const(obj, name)
+      obj.class.const_get(name) 
+    end
+
+    def msg(message)
+      @proc.msg(message)
+    end
+
+    # Convenience short-hand for @dbgr.intf[-1].msg_nocr
+    def msg_nocr(msg)
+      @proc.msg_nocr(msg)
+    end
+
+    def my_const(name)
+      # Set class constant SHORT_HELP to be the first line of HELP
+      # unless it has been defined in the class already.
+      # The below was the simplest way I could find to do this since
+      # we are the super class but want to set the subclass's constant.
+      # defined? didn't seem to work here.
+      c = self.class.constants
+      if c.member?('HELP') and !c.member?('SHORT_HELP')
+        short_help = self.class.const_get(:HELP).split("\n")[0].chomp('.')
+        self.class.const_set(:SHORT_HELP, short_help)
+      end
+      self.class.const_get(name)
+    end
+
+    def name
+      self.class.const_get(:NAME)
+    end
+
+    # The method that implements the debugger command.
+    def run(*args)
+      raise RuntimeError, 'You need to define this method elsewhere'
+    end
+
+    def settings
+      @proc.settings
+    end
+
+    def short_help
+      help_constant_sym = if self.class.constants.member?('SHORT_HELP') 
+                            :SHORT_HELP 
+                          else :HELP
+                          end
+      my_const(help_constant_sym)
+    end
+
+    # From reference debugger
+    def run_code(str)
+      @proc.dbgr.current_frame.run(str)
+    end
+
+    def current_method
+      @proc.frame.method
+    end
+
+    def current_frame
+      @proc.frame
+    end
+
+    def variables
+      @proc.variables
+    end
+
+    def listen(step=false)
+      @proc.listen(step)
+    end
+
+  end
+end

data/processor/command/base/subcmd.rb

@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# A base class for debugger subcommands.
+#
+# Note: don't end classname with Command (capital C) since main
+# will think this a command name like QuitCommand 
+#                                         ^
+
+# Base Class for Trepan subcommands. We pull in some helper
+# functions for command from module cmdfns.
+
+require 'rubygems'; require 'require_relative'
+require_relative 'cmd'
+
+class Trepan
+
+  class Subcommand  < Command
+
+    NotImplementedMessage = 
+      "This method must be overridden in a subclass" unless 
+      defined?(NotImplementedMessage)
+
+    attr_reader :name
+
+    unless defined?(IN_LIST)
+      IN_LIST    = true  # Show item in help list of commands
+      RUN_CMD    = true  # Run subcommand for those subcommands like "show"
+      # which append current settings to list output.
+      MIN_ABBREV = 1
+      NEED_STACK = false
+      NAME       = 'your_command_name'
+    end
+
+
+    # cmd contains the command object that this
+    # command is invoked through.  A debugger field gives access to
+    # the stack frame and I/O.
+    def initialize(cmd)
+      @cmd = cmd
+
+      # Convenience class access. We don't expect that any of these
+      # will change over the course of the program execution like
+      # errmsg(), msg(), and msg_nocr() might. (See the note below
+      # on these latter 3 methods.)
+      # 
+      @core     = cmd.core
+      @proc     = cmd.proc
+      # @dbgr = cmd.dbgr
+
+      # By default the name of the subcommand will be the name of the
+      # last part of module (e.g. "args" in "info.args" or "basename"
+      # in "shows.basename"). However it *is* possible for one to change
+      # that -- perhaps one may want to put several subcommands into 
+      # a single file. So in those cases, one will have to set @name
+      # accordingly by other means.
+      @name  = my_const(:NAME).to_sym
+
+    end
+
+    # Convenience short-hand for @proc.confirm
+    def confirm(msg, default=false)
+      return(@proc.confirm(msg, default))
+    end
+
+    def prefix
+      my_const('PREFIX')
+    end
+
+    # Set a Boolean-valued debugger setting. 
+    def run_set_bool(args, default=true)
+      onoff_arg = args.size < 3 ? 'on' : args[2]
+      begin
+        settings[subcmd_setting_key] = @proc.get_onoff(onoff_arg)
+        run_show_bool
+      rescue NameError, TypeError
+      end
+    end
+
+    # set an Integer-valued debugger setting. 
+    def run_set_int(arg, msg_on_error, min_value=nil, max_value=nil)
+      if arg.strip.empty?
+        errmsg('You need to supply a number.')
+        return
+      end
+      val = @proc.get_an_int(arg, 
+                             :max_value => max_value,
+                             :min_value => min_value, 
+                             :msg_on_error => msg_on_error
+                             )
+      if val
+        settings[subcmd_setting_key] = val
+        run_show_int
+      end
+    end
+
+    # Generic subcommand showing a boolean-valued debugger setting.
+    def run_show_bool(what=nil)
+      val = show_onoff(settings[subcmd_setting_key])
+      what = @name unless what
+      msg("%s is %s." % [what, val])
+    end
+
+    # Generic subcommand integer value display
+    def run_show_int(what=nil)
+      val = settings[subcmd_setting_key]
+      what = self.class.const_get(:PREFIX)[1..-1].join(' ') unless what
+      msg("%s is %d." % [what, val])
+    end
+
+    # Generic subcommand value display. Pass in a hash which may
+    # which optionally contain:
+    #
+    #   :name - the String name of key in settings to use. If :value
+    #           (described below) is set, then setting :name does
+    #           nothing.
+    #
+    #   :what - the String name of what we are showing. If none is
+    #           given, then we use the part of the SHORT_HELP string.
+    # 
+    #   :value - a String value associated with "what" above. If none
+    #            is given, then we pick up the value from settings.
+    # 
+    def run_show_val(opts={})
+      what = opts.member?(:what)  ? opts[:what]  : string_in_show
+      name = opts.member?(:name)  ? opts[:name]  : @name
+      val  = opts.member?(:value) ? opts[:value] : settings[name] 
+      msg("%s is %s." % [what, val])
+    end
+
+    def save_command_from_settings
+      ["#{subcmd_prefix_string} #{settings[subcmd_setting_key]}"]
+    end
+
+    def settings
+      @proc.settings
+    end
+        
+    def subcmd_prefix_string
+      self.class.const_get(:PREFIX).join(' ')
+    end
+
+    def subcmd_setting_key
+      self.class.const_get(:PREFIX)[1..-1].join('').to_sym
+    end
+
+    # Return 'on' for true and 'off' for false, and ?? for anything else.
+    def show_onoff(bool)
+      case(bool)
+      when true;  return 'on'
+      when false; return 'off'
+      when nil;   return 'unset'
+      else        return '??'
+      end
+    end
+
+    def string_in_show
+      my_const(:SHORT_HELP)['Show '.size .. -1].capitalize
+    end
+
+    def summary_help(subcmd_name)
+      msg_nocr("%-12s: %s" % [subcmd_name, my_const(:SHORT_HELP)])
+    end
+    
+  end
+
+  class SetBoolSubcommand < Subcommand
+    def run(args)
+      run_set_bool(args)
+    end
+
+    def save_command
+      val     = settings[subcmd_setting_key] ? 'on' : 'off'
+      ["#{subcmd_prefix_string} #{val}"]
+    end
+  end
+
+  class ShowBoolSubcommand < Subcommand
+    def run(args)
+      run_show_bool(string_in_show)
+    end
+  end
+
+  class ShowIntSubcommand < Subcommand
+    def run(args)
+      doc = 
+        if self.respond_to?(:short_help)
+          short_help
+        else
+          my_const(:HELP)[5..-2].capitalize
+        end
+      run_show_int(doc)
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  dbgr = MockDebugger::MockDebugger.new
+  # cmds = dbgr.core.processor.commands
+  # p cmds.keys
+  # subcmd = Trepan::Subcommand.new(cmds['exit'])
+  # def subcmd.msg(message)
+  #   puts message
+  # end
+  # def subcmd.errmsg(message)
+  #   puts message
+  # end
+  # p subcmd.settings
+  # p subcmd.show_onoff(subcmd.settings[:autoeval])
+  # subcmd.run_set_int('', 'Just a test')
+end