rbx-trepanning 0.2.0-universal-rubinius-2.0

data/processor/command/disassemble.rb

@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+require_relative '../../app/method'
+require_relative '../../app/iseq'
+
+class Trepan::Command::DisassembleCommand < Trepan::Command
+
+  include Trepanning::Method
+
+  NAME         = File.basename(__FILE__, '.rb')
+  ALIASES      = %w(disasm) # Note we have disable
+  CATEGORY     = 'data'
+  HELP         = <<-HELP
+#{NAME} [--all | -a]
+#{NAME} [method|LINE-NUM]...
+
+Disassembles Rubinius VM instructions. By default, the bytecode for the
+current line is disassembled only.
+
+If a method name is given, disassemble just that method. 
+
+If a line number given, then disassemble just that line number if it
+has bytecode assocated with that line. Note that if a line has
+discontinuous regions we will show just the first region associated
+with that line.
+
+If the argument is '--all', the entire method is shown as bytecode.
+
+Examples:
+   #{NAME}              # dissasemble VM for current line
+   #{NAME} --all        # disassemble entire current method
+   #{NAME} [1,2].max    # disassemble max method of Array
+   #{NAME} Object.is_a? # disassemble Object.is_a?
+   #{NAME} is_a?        # same as above (probably)
+   #{NAME} 6            # Disassemble line 6 if there is bytecode for it
+   #{NAME} 6 is_a?      # The above two commands combined into one
+    HELP
+
+  NEED_STACK   = true
+  SHORT_HELP   = 'Show the bytecode for the current method'
+  DEFAULT_OPTIONS = {
+      :all => false,
+  }
+
+  completion %w(-a --all)
+
+  def disassemble_method(cm)
+    frame_ip = (@proc.frame.method == cm) ? @proc.frame.next_ip : nil
+    lines = cm.lines
+    next_line_ip = 0
+    next_i = 1
+    prefixes = []
+    disasm = ''
+    cm.decode.each do |insn|
+      show_line = 
+        if insn.ip >= next_line_ip
+          next_line_ip = lines.at(next_i+1)
+          line_no = lines.at(next_i)
+          next_i += 2
+          true
+        else
+          false
+        end
+          
+      prefixes << Trepan::ISeq::disasm_prefix(insn.ip, frame_ip, cm)
+      str = insn.to_s
+      if show_line
+        str += 
+          if insn.instance_variable_get('@comment')
+            ' '
+          elsif str[-1..-1] !~/\s/
+            '    '
+          else
+            ''
+          end
+        str += "# line: #{line_no}"  
+      end
+      disasm += "#{str}\n"
+    end
+
+    # FIXME DRY with ../disassemble.rb
+    if settings[:highlight]
+      begin
+        require_relative '../../app/rbx-llvm'
+        @llvm_highlighter ||= CodeRay::Duo[:llvm, :term]
+        # llvm_scanner = CodeRay.scanner :llvm
+        # p llvm_scanner.tokenize(disasm)
+        disasm = @llvm_highlighter.encode(disasm)
+      rescue LoadError
+        errmsg 'Highlighting requested but CodeRay is not installed.'
+      end
+    end
+      
+    disasm.split("\n").each_with_index do |inst, i|
+      msg ("#{prefixes[i]} #{inst}", :unlimited => true)
+    end
+  end
+
+  def parse_options(options, args) # :nodoc
+    parser = OptionParser.new do |opts|
+      opts.on('-a', '--all', 
+              'show entire method') do
+        options[:all] = true
+      end
+    end
+    begin
+      parser.parse! args
+    rescue OptionParser::InvalidOption => e
+      errmsg e
+    end
+    return options
+
+  end
+
+  # Run command. 
+  def run(args)
+    my_args = args[1..-1]
+    options = parse_options(DEFAULT_OPTIONS.dup, my_args)
+    if my_args.empty?
+      if options[:all]
+        section "Bytecode for #{@proc.frame.vm_location.describe}"
+        disassemble_method(current_method)
+      else
+        @proc.show_bytecode
+      end
+    else
+      args[1..-1].each do |arg|
+        cm = @proc.parse_method(arg)
+        if cm
+          section "Bytecode for method #{arg}"
+          disassemble_method(cm.executable)
+        else
+          opts = {:msg_on_error => false }
+          line_num = @proc.get_an_int(arg, opts) 
+          if line_num
+            cm = find_method_with_line(current_method, line_num)
+            if cm
+              @proc.show_bytecode(line_num)
+            else
+              errmsg "Can't find that bytecode for line #{line_num}"
+            end
+          else
+            errmsg "Method #{arg} not found"
+          end
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  def five; 5 end
+  def foo(cmd)
+    puts "#{cmd.name}"
+    cmd.run([cmd.name])
+    puts '=' * 40
+    puts "#{cmd.name} --all"
+    # require_relative '../../lib/trepanning'; debugger
+    cmd.run([cmd.name, '--all'])
+    puts '=' * 40
+    cmd.run([cmd.name, '-a'])
+    puts '=' * 40
+    cmd.run([cmd.name, 'five'])
+    ## FIXME: someday handle:
+    # puts '=' * 40
+    # cmd.run([cmd.name, '-a', 'five'])
+    puts '=' * 40
+    cmd.run([cmd.name, 'MockDebugger::setup'])
+    puts '=' * 40
+    cmd.run([cmd.name, __LINE__.to_s])
+    require 'irb'
+    cmd.run([cmd.name, 'IRB.start'])
+  end
+  foo(cmd)
+end

data/processor/command/display.rb

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+
+class Trepan::Command::DisplayCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{name} [format] EXP
+ 
+Print value of expression EXP each time the program stops.  FMT may be
+used before EXP and may be one of 'c' for char, 'x' for hex, 'o' for
+octal, 'f' for float or 's' for string.
+
+For now, display expressions are only evaluated when in the same
+instruction sequence as the frame that was in effect when the display
+expression was set.  This is a departure from gdb and we may allow for
+more flexibility in the future to specify whether this should be the
+case or not.
+
+With no argument, evaluate and display all currently requested
+auto-display expressions.  Use "undisplay" to cancel display
+requests previously made.
+
+See also "undisplay", "enable", and "disable".
+    HELP
+    
+    CATEGORY      = 'data'
+    NEED_STACK    = false
+    SHORT_HELP    = 'Display expressions when entering debugger'
+  end
+  
+  def run(args)
+
+    if args.size == 1
+      # Display anything active
+      @proc.run_eval_display
+    else
+      if %w(/c /x /o /f /s).member?(args[1])
+        if 2 == args.size
+          errmsg("Expecting an expression after the format")
+          return
+        end
+        format = args[1]
+        expr   = args[2..-1].join(' ')
+      else
+        format = nil
+        expr = args[1..-1].join(' ')
+      end
+
+      dp = @proc.displays.add(@proc.frame, expr, format)
+      unless dp
+        errmsg('Error evaluating "%s" in the current frame' % expr)
+        return
+      end
+      msg(dp.to_s(@proc.frame))
+      @proc.cmdloop_prehooks.insert_if_new(5, *@proc.display_hook)
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+
+  def run_cmd(cmd, args)
+    cmd.run(args)
+    puts '==' * 10
+  end
+
+  # run_cmd(cmd, [cmd.name])
+  # run_cmd(cmd, [cmd.name, '/x', '10'])
+  # run_cmd(cmd, [cmd.name, 'd'])
+  # run_cmd(cmd, [cmd.name])
+  e = 5
+  vm_locations  = Rubinius::VM.backtrace(0, true)
+  cmd.proc.instance_variable_set('@frame ',
+                                 Trepan::Frame.new(self, 0, vm_locations[0]))
+
+  run_cmd(cmd, [cmd.name, 'e'])
+end

data/processor/command/down.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'up'
+
+# Debugger "down" command. Is the same as the "up" command with the 
+# direction (set by DIRECTION) reversed.
+class Trepan::Command::DownCommand < Trepan::Command::UpCommand
+
+  Trepan::Util.suppress_warnings {
+    old_verbose = $VERBOSE  
+    $VERBOSE    = nil
+    HELP = <<-HELP
+#{NAME} [count]
+
+Move the current frame down in the stack trace (to a newer frame). 0
+is the most recent frame. If no count is given, move down 1.
+
+See also 'up' and 'frame'.
+  HELP
+
+    ALIASES       = %w(d)
+    NAME          = File.basename(__FILE__, '.rb')
+    SHORT_HELP    = 'Move frame in the direction of the caller of the last-selected frame'
+  }
+
+  def initialize(proc)
+    super
+    @direction = -1 # +1 for up.
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+
+  # def sep ; puts '=' * 40 end
+  # cmd.run [cmd.name]
+  # %w(-1 0 1 -2).each do |count| 
+  #   puts "#{cmd.name} #{count}"
+  #   cmd.run([cmd.name, count])
+  #   sep 
+  # end
+  # def foo(cmd, cmd.name)
+  #   puts "#{cmd.name}"
+  #   cmd.run([cmd.name])
+  #   sep
+  #   puts "#{cmd.name} -1"
+  #   cmd.run([cmd.name, '-1'])
+  # end
+  # foo(cmd, cmd.name)
+end

data/processor/command/edit.rb

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+
+class Trepan::Command::EditCommand < Trepan::Command
+
+  old_verbose = $VERBOSE  
+  $VERBOSE    = nil
+  NAME        = File.basename(__FILE__, '.rb')
+  HELP    = <<-HELP
+#{NAME} [[FILE] [LINE]]
+
+With no argument, edits file containing most recent line listed.
+The value of the environment variable EDITOR is used for the
+editor to run. If no EDITOR environment variable is set /bin/ex
+is used. The editor should support line and file positioning via
+   editor-name +line file-name
+(Most editors do.)
+
+Examples:
+#{NAME}            # Edit current location
+#{NAME} 7          # Edit current file at line 7
+#{NAME} test.rb    # Edit test.rb, line 1
+#{NAME} test.rb 10 # Edit test.rb  line 10
+      HELP
+
+  ALIASES       = %w(e)
+  CATEGORY      = 'files'
+  NEED_STACK    = false
+  SHORT_HELP    = 'Invoke an editor on some source code'
+  MAX_ARGS      = 2
+  $VERBOSE      = old_verbose 
+
+  # FIXME: redo with locations and kparse.
+  def run(args)
+    case args.size
+    when 1
+      file = @proc.frame.file
+      line = @proc.frame.line
+    when 2
+      line = Integer(args[1]) rescue nil
+      if line 
+        file = @proc.frame.file
+      else 
+        file = args[1]
+        line = 1
+      end
+    when 3
+      line, file =  args[2], args[1]
+    else
+      errmsg "edit needs at most 2 args." 
+    end
+    editor = ENV['EDITOR'] || '/bin/ex'
+    if File.readable?(file)
+      file = File.basename(file) if settings[:basename]
+      edit_cmd = "#{editor} +#{line} \"#{file}\""
+      msg "Running #{edit_cmd}..."
+      system(edit_cmd)
+      msg "Warning: return code was #{$?.exitstatus}" if $?.exitstatus != 0
+    else
+      errmsg "File \"#{file}\" is not readable."
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  ENV['EDITOR'] = 'echo FAKE-EDITOR'
+  cmd.run [cmd.name] 
+  cmd.run [cmd.name, '7'] 
+  cmd.run [cmd.name, __FILE__, '10'] 
+end

data/processor/command/enable.rb

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'disable'
+
+# enable breakpoint command. Is like disable but the parameter
+# to @proc.en_disable_breakpoint_by_number is different (set as
+# ENABLE_PARM below).
+class Trepan::Command::EnableCommand < Trepan::Command::DisableCommand
+
+  Trepan::Util.suppress_warnings {
+    NAME        = File.basename(__FILE__, '.rb')
+    HELP        = <<-HELP
+#{NAME} [display] NUM1 [NUM2 ...]
+    
+Enables breakpoints or display NUM1. Breakpoints numbers are given as
+a space-separated list numbers.
+
+See also "disable" and "info break".
+  HELP
+    
+    ALIASES       = %w(en)
+    SHORT_HELP    = 'Enable some breakpoints'
+  }
+
+  def initialize(proc)
+    super
+    @enable_parm = true # true if enable 
+  end
+
+end
+        
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+  cmd.run([cmd.name, '1'])
+  cmdproc = cmd.proc
+  cmds = cmdproc.commands
+  break_cmd = cmds['break']
+  break_cmd.run(['break', cmdproc.frame.source_location[0].to_s])
+  cmd.run([cmd.name, '1'])
+end

data/processor/command/eval.rb

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+require_relative '../../app/util'
+
+class Trepan::Command::EvalCommand < Trepan::Command
+
+  old_verbose = $VERBOSE  
+  $VERBOSE    = nil
+  NAME          = File.basename(__FILE__, '.rb')
+  HELP    = <<-HELP
+#{NAME} [STRING]
+
+Run code in the context of the current frame.
+
+The value of the expression is stored into a global variable so it
+may be used again easily. The name of the global variable is printed
+next to the inspect output of the value.
+
+If no string is given, we run the string from the current source code
+about to be run. If the command ends ? (via an alias) and no string is
+given we will the following translations occur:
+
+   {if|elsif|unless} expr [then]  => expr
+   {until|while} expr [do]        => expr
+   return expr                    => expr
+   case expr                      => expr
+   def fn(params)                 => [params]
+   var = expr                     => expr
+
+The above is done via regular expression. No fancy parsing is done, say,
+to look to see if expr is split across a line or whether var an assigment
+might have multiple variables on the left-hand side.
+
+Examples:
+
+#{NAME} 1+2  # 3
+#{NAME} @v
+#{NAME}      # Run current source-code line
+#{NAME}?     # but strips off leading 'if', 'while', ..
+             # from command 
+
+See also 'set autoeval'. The command helps one predict future execution.
+See 'set buffer trace' for showing what may have already been run.
+      HELP
+
+  ALIASES       = %w(eval? ev? ev)
+  CATEGORY      = 'data'
+  NEED_STACK    = true
+  SHORT_HELP    = 'Run code in the current context'
+  $VERBOSE      = old_verbose 
+
+  def complete(prefix)
+    if prefix.empty? 
+      if @proc.leading_str.start_with?('eval?')
+        Trepan::Util.extract_expression @proc.current_source_text
+      else
+        @proc.current_source_text 
+      end
+    else
+      prefix
+    end
+  end
+
+  def run(args)
+    if args.size == 1
+      text  = @proc.current_source_text
+      ## FIXME turn into a subroutine and use in complete.
+      if  '?' == args[0][-1..-1] 
+        text = Trepan::Util::extract_expression(text)
+        msg "eval: #{text}"
+      end
+    else
+      text = @proc.cmd_argstr
+    end
+    @proc.eval_code(text, settings[:maxstring])
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  arg_str = '1 + 2'
+  cmd.proc.instance_variable_set('@cmd_argstr', arg_str)
+  puts "eval #{arg_str} is: #{cmd.run([cmd.name, arg_str])}"
+  arg_str = 'return "foo"'
+  # def cmd.proc.current_source_text
+  #   'return "foo"'
+  # end
+  # cmd.proc.instance_variable_set('@cmd_argstr', arg_str)
+  # puts "eval? #{arg_str} is: #{cmd.run([cmd.name + '?'])}"
+end

data/processor/command/exit.rb

@@ -0,0 +1,83 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+class Trepan::Command::ExitCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME         = File.basename(__FILE__, '.rb')
+    ALIASES      = %w(quit q q! quit! exit!)
+    HELP = <<-HELP
+#{NAME} [exitcode] [unconditionally] - hard exit of the debugged program.  
+
+The program being debugged is exited via exit!() which does not run
+the Kernel at_exit finalizers. If a return code is given, that is the
+return code passed to exit() - presumably the return code that will be
+passed back to the OS. If no exit code is given, 0 is used.
+
+If you are in interactive mode, and confirm is not set off, you are
+prompted to confirm quitting. However if you do not want to be
+prompted, add ! the end.  (vim/vi/ed users can use alias q!).
+
+Examples: 
+ #{NAME}                 # quit prompting if we are interactive
+ #{NAME} unconditionally # quit without prompting
+ #{NAME}!                # same as above
+ #{NAME} 0               # same as "quit"
+ #{NAME}! 1              # unconditional quit setting exit code 1
+
+See also "kill" and "set confirm".'
+    HELP
+
+    CATEGORY     = 'support'
+    MAX_ARGS     = 2  # Need at most this many
+    SHORT_HELP  = 'Exit program via "exit!()"'
+  end
+
+  # FIXME: Combine 'quit' and 'exit'. The only difference is
+  # whether exit! or exit is used.
+
+  # This method runs the command
+  def run(args) # :nodoc
+    unconditional = 
+      if args.size > 1 && args[-1] == 'unconditionally'
+        args.shift
+        true
+      elsif args[0][-1..-1] == '!'
+        true
+      else
+        false
+      end
+    unless unconditional || confirm('Really quit?', false)
+      msg('Quit not confirmed.')
+      return
+    end
+    
+    if (args.size > 1)
+      if  args[1] =~ /\d+/
+        exitrc = args[1].to_i;
+      else
+        errmsg "Bad an Integer return type \"#{args[1]}\"";
+        return;
+      end
+    else
+      exitrc = 0
+    end
+
+    # FIXME: Is this the best/most general way?
+    @proc.finalize
+    @proc.dbgr.intf[-1].finalize
+
+    # No graceful way to stop threads...
+    # A little harsh, but for now let's go with this.
+    exit! exitrc
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  Process.fork { cmd.run([cmd.name]) } if 
+    Process.respond_to?(:fork) 
+  cmd.run([cmd.name, 'foo'])
+  cmd.run([cmd.name, '10'])
+end

data/processor/command/finish.rb

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative '../command'
+
+class Trepan::Command::FinishCommand < Trepan::Command
+
+  unless defined?(HELP)
+    ALIASES      = %w(fin finish+ fin+)
+    CATEGORY     = 'running'
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME}
+#{NAME}+
+
+Continue execution until leaving the current method.  Sometimes this
+is called 'step out'.
+
+Normally, stopping occurs just before the return on or yield out of a
+method. However sometimes one wants go to the calling method or place
+just beyond the current method.For this, suffix the command or an
+alias of it with a plus sign. The disadvantange of this is that you
+will no longer be in the scope of the method and so you won't be able
+to see variables of that method.
+
+Examples:
+  #{NAME}
+  #{NAME}+ 
+
+See also commands:
+'continue', 'break', 'next', 'nexti', 'step' for other ways to continue.
+    HELP
+    NEED_RUNNING = true
+    MAX_ARGS     = 1   # Need at most this many. 
+    NEED_STACK   = true
+    SHORT_HELP   = 'Step to end of current method (step out)'
+  end
+
+  # This method runs the command
+  def run(args) # :nodoc
+    opts = @proc.parse_next_step_suffix(args[0])
+    if args.size == 1
+      # Form is: "finish" which means "finish 1"
+      level_count = 0
+    else
+      count_str = args[1]
+      count_opts = {
+        :msg_on_error => 
+        "The '#{NAME}' command argument must eval to an integer. Got: %s" % 
+        count_str,
+        :min_value => 1
+      }
+      count = @proc.get_an_int(count_str, count_opts)
+      return unless count
+      # step 1 is core.level_count = 0 or "stop next event"
+      level_count = count - 1  
+    end
+    if 0 == level_count and %w(return c-return).member?(@proc.event)
+      errmsg "You are already at the requested return event."
+    else
+      @proc.finish(level_count, opts)
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  [%W(#{cmd.name}), %w(fin 2-1), %w(n foo)].each do |c|
+    cmd.proc.instance_variable_set('@return_to_program', false)
+    cmd.run(c)
+    puts 'return_to_program: %s' % cmd.proc.instance_variable_get('@return_to_program')
+    puts 'step_count: %s' % cmd.proc.instance_variable_get('@step_count')
+  end
+  [%w(fin), [cmd.name]].each do |c|
+    cmd.proc.leave_cmd_loop = false
+    result = cmd.run(c)
+    puts cmd.proc.different_pos
+  end
+end