rbx-trepanning 0.0.8-universal-rubinius-1.2 → 0.1.0-universal-rubinius-1.2

data/processor/command/info_subcmd/variables_subcmd/constant.rb

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'locals'
+
+class Trepan::Subcommand::InfoVariablesConstant < 
+    Trepan::Subcommand::InfoVariablesLocals
+  Trepan::Util.suppress_warnings {
+    Trepanning::Subcommand.set_name_prefix(__FILE__, self)
+    HELP         = <<-EOH
+#{CMD}
+#{CMD} [names]
+
+Show class constants of the current stack frame.
+Normally for each which show both the name and value. If you just
+want a list of names add parameter 'names'.
+EOH
+    SHORT_HELP   = 'Show class constants via the current stack frame'
+    MIN_ABBREV   = 'co'.size
+    MIN_ARGS     = 0
+    MAX_ARGS     = 1
+    NEED_STACK   = true
+  }
+
+  def get_names
+    @proc.debug_eval_no_errmsg('self.class.constants.sort') || []
+  end
+
+  def run(args)
+    run_for_type(args, 'constant', @proc.debug_eval('self'))
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  cmd = 
+    MockDebugger::subsub_setup(Trepan::Subcommand::InfoVariables,
+                               Trepan::Subcommand::InfoVariablesConstant)
+  cmd.run(cmd.prefix)
+  cmd.run(cmd.prefix + ['name'])
+end

data/processor/command/info_subcmd/variables_subcmd/globals.rb

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'locals'
+
+class Trepan::SubSubcommand::InfoVariablesGlobals < Trepan::SubSubcommand
+  Trepan::Util.suppress_warnings {
+    Trepanning::Subcommand.set_name_prefix(__FILE__, self)
+    HELP         = <<-EOH
+#{CMD}
+#{CMD} [names]
+
+Show global variables.
+Normally for each which show both the name and value. If you just
+want a list of names add parameter 'names'.
+EOH
+    SHORT_HELP   = 'Show global variables'
+    MIN_ARGS     = 0
+    MAX_ARGS     = 1
+    NEED_STACK   = true
+  }
+
+  def get_names
+    global_variables.sort
+  end
+
+  def run(args)
+    if args.size == 2
+      if 0 == 'names'.index(args[-1].downcase)
+        names = get_names()
+        if names.empty?
+            msg "No global variables defined."
+        else
+          section "Global variable names:"
+          width = settings[:maxwidth]
+          mess = Columnize::columnize(names, 
+                                      @proc.settings[:maxwidth], '  ',
+                                      false, true, ' ' * 2).chomp
+          msg mess
+        end
+      else
+        errmsg("unrecognized argument: #{args[-1]}")
+      end
+    elsif args.size == 1
+      names = get_names
+      if names.empty?
+        msg "No global variables defined."
+      else
+        section "Global variables:"
+        names.each do |var_name| 
+          s = @proc.debug_eval(var_name.to_s)
+          msg("#{var_name} = #{s.inspect}", :code=>true)
+        end
+      end
+    else
+      errmsg("Wrong number of arguments #{args.size}")
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../../mock'
+  require_relative '../variables'
+  cmd = MockDebugger::subsub_setup(Trepan::Subcommand::InfoVariables, 
+                                   Trepan::SubSubcommand::InfoVariablesGlobals)
+  cmd.run(cmd.prefix)
+  cmd.run(cmd.prefix + ['name'])
+end

data/processor/command/info_subcmd/variables_subcmd/instance.rb

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'locals'
+
+class Trepan::Subcommand::InfoVariablesInstance < 
+    Trepan::Subcommand::InfoVariablesLocals
+  Trepan::Util.suppress_warnings {
+    Trepanning::Subcommand.set_name_prefix(__FILE__, self)
+    HELP         = <<-EOH
+#{CMD}
+#{CMD} [names]
+
+Show instance variables of the current stack frame.
+Normally for each which show both the name and value. If you just
+want a list of names add parameter 'names'.
+EOH
+    SHORT_HELP   = 'Show instance variables of the current stack frame'
+    MIN_ARGS     = 0
+    MAX_ARGS     = 1
+    MIN_ABBREV   = 'iv'.size 
+    NEED_STACK   = true
+  }
+
+  def get_names
+    @proc.debug_eval('self.instance_variables')
+  end
+
+  def run(args)
+    run_for_type(args, 'instance', @proc.debug_eval('self'))
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  cmd = 
+    MockDebugger::subsub_setup(Trepan::Subcommand::InfoVariables,
+                               Trepan::Subcommand::InfoVariablesInstance)
+  cmd.run(cmd.prefix)
+  cmd.run(cmd.prefix + ['name'])
+end

data/processor/command/info_subcmd/variables_subcmd/locals.rb

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require 'columnize'
+require_relative '../../base/subsubcmd'
+require_relative '../../../../app/frame'
+require_relative '../../../../app/util'
+
+class Trepan::Subcommand::InfoVariablesLocals < Trepan::SubSubcommand
+  Trepan::Util.suppress_warnings {
+    Trepanning::Subcommand.set_name_prefix(__FILE__, self)
+    HELP         = <<-EOH
+#{CMD}
+#{CMD} [names]
+
+Show local variables including parameters of the current stack frame.
+Normally for each which show both the name and value. If you just
+want a list of names add parameter 'names'.
+EOH
+    SHORT_HELP   = 'Show local variables of the current stack frame'
+    MIN_ARGS     = 0
+    MAX_ARGS     = 1
+    MIN_ABBREV   = 'lo'.size 
+    NEED_STACK   = true
+  }
+
+  def get_names
+    @proc.frame.local_variables
+  end
+
+  def run_for_type(args, type, klass=nil)
+    suffix = klass ? " for #{klass.to_s}" : '' rescue ''
+    names = get_names()
+    if args.size == 2
+      if 0 == 'names'.index(args[-1].downcase)
+        names = get_names()
+        if names.empty?
+          msg "No #{type} variables defined."
+        else
+          section "#{type.capitalize} variable names#{suffix}:"
+
+          width = settings[:maxwidth]
+          mess = Columnize::columnize(names, 
+                                      @proc.settings[:maxwidth], '  ',
+                                      false, true, ' ' * 2).chomp
+          msg mess
+        end
+      else
+        errmsg("unrecognized argument: #{args[-1]}")
+      end
+    elsif args.size == 1
+      if names.empty?
+        msg "No #{type} variables defined#{suffix}."
+      else
+        section "#{type.capitalize} variables#{suffix}:"
+        names.each do |var_name| 
+          var_value = 
+            @proc.safe_rep(@proc.debug_eval_no_errmsg(var_name).inspect)
+          msg("#{var_name} = #{var_value}", :code =>true)
+        end
+      end
+    else
+      errmsg("Wrong number of arguments #{args.size}")
+    end
+  end
+  def run(args)
+    run_for_type(args, 'local', @proc.debug_eval('self'))
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../../mock'
+  require_relative '../variables'
+  cmd = MockDebugger::subsub_setup(Trepan::SubSubcommand::InfoVariables,
+                                   Trepan::SubSubcommand::InfoVariablesLocals
+                                   )
+  cmd.run([])
+  cmd.run(['name'])
+end

data/processor/command/kill.rb

@@ -1,6 +1,6 @@
 # Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 require 'rubygems'; require 'require_relative'
-require_relative 'base/cmd'
+require_relative '../command'
 class Trepan::Command::KillCommand < Trepan::Command
 
   unless defined?(HELP)
@@ -35,9 +35,10 @@ Examples:
   end
   
   def complete(prefix)
-    completions = Signal.list.keys + 
+    completions = Signal.list.keys + Signal.list.keys.map{|k| k.downcase} +
       Signal.list.values.map{|i| i.to_s} + 
-      Signal.list.values.map{|i| (-i).to_s} 
+      Signal.list.values.map{|i| (-i).to_s} + 
+      ['unconditionally']
     Trepan::Complete.complete_token(completions, prefix)
   end
     
@@ -50,9 +51,6 @@ Examples:
         errmsg("Signal name '#{sig}' is not a signal I know about.\n")
         return false
       end
-      if 'KILL' == sig || Signal['KILL'] == sig
-        @proc.intf.finalize
-      end
     else
       if not (unconditional || confirm('Really quit?', false))
         msg('Kill not confirmed.')
@@ -62,9 +60,10 @@ Examples:
       end
     end
     begin
+      @proc.intf.finalize if 'KILL' == sig || Signal.list['KILL'] == sig
       Process.kill(sig, Process.pid)
-    rescue Errno::ESRCH
-      errmsg "Unable to send kill #{sig} to process #{Process.pid}"
+    rescue Errno::ESRCH, Errno::EINVAL, Errno::EPERM, RangeError
+      errmsg "Unable to send kill #{sig} to process #{Process.pid}: #{$!}"
     end
   end
 end
@@ -72,7 +71,7 @@ end
 if __FILE__ == $0
   require_relative '../mock'
   dbgr, cmd = MockDebugger::setup
-  %w(fooo 1 -1 HUP -9).each do |arg| 
+  %w(fooo 100 1 -1 HUP -9).each do |arg| 
     puts "#{cmd.name} #{arg}"
     cmd.run([cmd.name, arg])
     puts '=' * 40

data/processor/command/list.rb

@@ -3,13 +3,14 @@
 require 'rubygems'
 require 'require_relative'
 require 'linecache'
-require_relative 'base/cmd'
+require_relative '../command'
+require_relative '../list'
 
 class Trepan::Command::ListCommand < Trepan::Command
   unless defined?(HELP)
     NAME = File.basename(__FILE__, '.rb')
     HELP = <<-HELP
-#{NAME}[>] [FIRST [NUM]]
+#{NAME}[>] [MODULE] [FIRST [NUM]]
 #{NAME}[>] LOCATION [NUM]
 
 #{NAME} source code. 
@@ -24,7 +25,7 @@ previously shown.
 If the command has a '>' suffix, then line centering is disabled and
 listing begins at the specificed location.
 
-The number of lines to show is controlled by the debugger "list size"
+The number of lines to show is controlled by the debugger "listsize"
 setting. Use 'set max list' or 'show max list' to see or set the
 value.
 
@@ -42,8 +43,9 @@ A LOCATION is a either
 If the location form is used with a subsequent parameter, the
 parameter is the starting line number.  When there two numbers are
 given, the last number value is treated as a stopping line unless it
-is less than the start line, in which case it is taken to mean the
-number of lines to list instead.
+is positive and less than the start line. In this case, it is taken to
+mean the number of lines to list instead. If last is negative, we start
+that many lines back from first and list to first.
 
 Wherever a number is expected, it does not need to be a constant --
 just something that evaluates to a positive integer.
@@ -51,131 +53,49 @@ just something that evaluates to a positive integer.
 Some examples:
 
 #{NAME} 5            # List centered around line 5
-#{NAME} 4+1          # Same as above.
+#{NAME} @5           # List lines centered around bytecode offset 5.
 #{NAME} 5>           # List starting at line 5
 #{NAME} foo.rb:5     # List centered around line 5 of foo.rb
 #{NAME} foo.rb 5     # Same as above.
-#{NAME} foo.rb:5>    # List starting around line 5 of foo.rb
+#{NAME}> foo.rb:5    # List starting around line 5 of foo.rb
 #{NAME} foo.rb  5 6  # list lines 5 and 6 of foo.rb
 #{NAME} foo.rb  5 2  # Same as above, since 2 < 5.
 #{NAME} foo.rb:5 2   # Same as above
+#{NAME} foo.rb 15 -5 # List lines 10..15 of foo
 #{NAME} FileUtils.cp # List lines around the FileUtils.cp function.
 #{NAME} .            # List lines centered from where we currently are stopped
 #{NAME} . 3          # List 3 lines starting from where we currently are stopped
                      # if . > 3. Otherwise we list from . to 3.
 #{NAME} -            # List lines previous to those just shown
 
+The output of the #{NAME} command gives a line number, and some status
+information about the line and the text of the line. Here is some 
+hypothetical #{NAME} output modeled roughly around line 251 of one
+version of this code:
+
+  251    	  cmd.proc.frame_setup(tf)
+  252  ->	  brkpt_cmd.run(['break'])
+  253 B01   	  line = __LINE__
+  254 b02   	  cmd.run(['list', __LINE__.to_s])
+  255 t03   	  puts '--' * 10
+
+Line 251 has nothing special about it. Line 252 is where we are
+currently stopped. On line 253 there is a breakpoint 1 which is
+enabled, while at line 255 there is an breakpoint 2 which is
+disabled.
     HELP
 
-    ALIASES       = %W(l #{NAME}> l>)
+    ALIASES       = %W(l #{NAME}> l> cat)
     CATEGORY      = 'files'
     MAX_ARGS      = 3
     SHORT_HELP    = 'List source code'
   end
 
-  # If last is less than first, assume last is a count rather than an
-  # end line number.
-  def adjust_last(first, last)
-    last < first ? first + last - 1 : last
-  end
-
-  # What a f*cking mess. Necessitated I suppose because we want to 
-  # allow somewhat flexible parsing with either module names, files or none
-  # and optional line counts or end-line numbers.
-  
-  # Parses arguments for the "list" command and returns the tuple:
-  # filename, start, last
-  # or sets these to nil if there was some problem.
-  def parse_list_cmd(args, listsize, center_correction)
-    
-    last = nil
-    
-    if args.size > 0
-      if args[0] == '-'
-        return no_frame_msg unless @proc.line_no
-        first = [1, @proc.line_no - 2*listsize - 1].max
-        file  = @proc.frame.file
-      elsif args[0] == '.'
-        return no_frame_msg unless @proc.line_no
-        if args.size == 2
-          opts = {
-            :msg_on_error => 
-            "#{NAME} command last or count parameter expected, " +
-            'got: %s.' % args[2]
-          }
-          second = @proc.get_an_int(args[1], opts)
-          return nil, nil, nil unless second
-          first = @proc.frame.line 
-          last = adjust_last(first, second)
-        else
-          first = [1, @proc.frame.line - center_correction].max
-        end
-
-        file  = @proc.frame.file
-      else
-        modfunc, file, first = @proc.parse_position(args[0])
-        if first == nil and modfunc == nil
-          # error should have been shown previously
-          return nil, nil, nil
-        end
-        if args.size == 1
-          first = 1 if !first and modfunc
-          first = [1, first - center_correction].max
-        elsif args.size == 2 or (args.size == 3 and modfunc)
-          opts = {
-            :msg_on_error => 
-            "#{NAME} command starting line expected, got %s." % args[-1]
-          }
-          last = @proc.get_an_int(args[1], opts)
-          return nil, nil, nil unless last
-          if modfunc
-            if first
-              first = last
-              if args.size == 3 and modfunc
-                opts[:msg_on_error] = 
-                  ("#{NAME} command last or count parameter expected, " +
-                   'got: %s.' % args[2])
-                last = @proc.get_an_int(args[2], opts)
-                return nil, nil, nil unless last
-              end
-            end
-          end
-          last = adjust_last(first, last)
-        elsif not modfunc
-          errmsg('At most 2 parameters allowed when no module' +
-                  ' name is found/given. Saw: %d parameters' % args.size)
-          return nil, nil, nil
-        else
-          errmsg(('At most 3 parameters allowed when a module' +
-                  ' name is given. Saw: %d parameters') % args.size)
-          return nil, nil, nil
-        end
-      end
-    elsif !@proc.line_no and @proc.frame
-      first = [1, @proc.frame.line - center_correction].max
-      file  = @proc.frame.file
-    else
-      first = [1, @proc.line_no - center_correction].max 
-      file  = @proc.frame.file
-    end
-    last = first + listsize - 1 unless last
-
-    if @proc.frame.eval?
-      script = @proc.frame.vm_location.static_scope.script 
-      LineCache::cache(script)
-    else
-      LineCache::cache(file)
-      script = nil
-    end
-    return file, script, first, last
-  end
-
-  def no_frame_msg
-    errmsg("No Ruby program loaded.")
-    return nil, nil, nil
-  end
-    
   def run(args)
+    if args.empty? and not frame
+      errmsg("No Ruby program loaded.")
+      return
+    end
     listsize = settings[:maxlist]
     center_correction = 
       if args[0][-1..-1] == '>'
@@ -184,36 +104,21 @@ Some examples:
         (listsize-1) / 2
       end
 
-    file, script, first, last = 
-      parse_list_cmd(args[1..-1], listsize, center_correction)
-    frame = @proc.frame
-    return unless file
-
-    cached_item = script || file
+    cm, filename, first, last = 
+      @proc.parse_list_cmd(@proc.cmd_argstr, listsize, center_correction)
+    return unless filename
+    breaklist = @proc.brkpts.line_breaks(cm)
 
     # We now have range information. Do the listing.
-    max_line = LineCache::size(cached_item)
-
-    # FIXME: join with line_at of location.rb
-    unless max_line && file
-      # Try using search directories (set with command "directory")
-      if file[0..0] != File::SEPARATOR
-        try_filename = @proc.resolve_file_with_dir(file) 
-        if try_filename && 
-            max_line = LineCache::size(try_filename)
-          LineCache::remap_file(file, try_filename)
-        end
-      end
-    end
-
+    max_line = LineCache::size(filename)
     unless max_line 
-      errmsg('File "%s" not found.' % file)
+      errmsg('File "%s" not found.' % filename)
       return
     end
 
     if first > max_line
       errmsg('Bad line range [%d...%d]; file "%s" has only %d lines' %
-             [first, last, file, max_line])
+             [first, last, filename, max_line])
       return
     end
 
@@ -224,11 +129,12 @@ Some examples:
 
     begin
       opts = {
-        :reload_on_change => @proc.reload_on_change,
+        :reload_on_change => settings[:reload],
         :output => settings[:highlight]
       }
+      frame = @proc.frame
       first.upto(last).each do |lineno|
-        line = LineCache::getline(cached_item, lineno, opts)
+        line = LineCache::getline(filename, lineno, opts)
         unless line
           msg('[EOF]')
           break
@@ -236,8 +142,16 @@ Some examples:
         line.chomp!
         s = '%3d' % lineno
         s = s + ' ' if s.size < 4 
-        s += (@proc.frame && lineno == @proc.frame.vm_location.line) ? '->' : '  '
-        # && container == frame.source_container) 
+        s += if breaklist.member?(lineno)
+               bp = breaklist[lineno]
+               a_pad = '%02d' % bp.id
+               bp.icon_char
+             else 
+               a_pad = '  '
+               ' ' 
+             end
+        s += (frame && lineno == @proc.frame.line &&
+              filename == @proc.frame.file) ? '->' : a_pad
         msg(s + "\t" + line, {:unlimited => true})
         @proc.line_no = lineno
       end
@@ -248,53 +162,73 @@ Some examples:
 end
 
 if __FILE__ == $0
+  # require_relative '../../lib/trepanning'; debugger
   require_relative '../location'
   require_relative '../mock'
   require_relative '../frame'
   dbgr, cmd = MockDebugger::setup
   cmd.proc.send('frame_initialize')
-  LineCache::cache(__FILE__)
-  require 'trepanning'
-  cmd.run([cmd.name])
-  cmd.run([cmd.name, __FILE__ + ':10'])
   
   def run_cmd(cmd, args)
-    seps = '--' * 10
-    puts "%s %s %s" % [seps, args.join(' '), seps]
+    cmd.proc.instance_variable_set('@cmd_argstr', args[1..-1].join(' '))
     cmd.run(args)
   end
   
-  
-  load 'tmpdir.rb'
-  run_cmd(cmd, %W(#{cmd.name} tmpdir.rb 10))
-  run_cmd(cmd, %W(#{cmd.name} tmpdir.rb))
-  
-  run_cmd(cmd, %W(cmd.name .))
-  run_cmd(cmd, %W(cmd.name 30))
-  
-  # cmd.run(['list', '9+1'])
-  
-  run_cmd(cmd, %W(cmd.name> 10))
-  run_cmd(cmd, %W(cmd.name 3000))
-  run_cmd(cmd, %W(cmd.name run_cmd))
-  
+  LineCache::cache(__FILE__)
+  run_cmd(cmd, [cmd.name])
+  run_cmd(cmd, [cmd.name, __FILE__ + ':10'])
+
+  def run_cmd2(cmd, args)
+    seps = '--' * 10
+    puts "%s %s %s" % [seps, args.join(' '), seps]
+    run_cmd(cmd,args)
+  end
+
+  require 'tmpdir.rb'
+  run_cmd2(cmd, %w(list tmpdir.rb 10))
+  run_cmd2(cmd, %w(list tmpdir.rb))
+
+  # cmd.proc.frame = sys._getframe()
+  # cmd.proc.setup()
+  # run_cmd2(['list'])
+
+  run_cmd2(cmd, %w(list .))
+  run_cmd2(cmd, %w(list 30))
+
+  # run_cmd2(['list', '9+1'])
+
+  run_cmd2(cmd, %w(list> 10))
+  run_cmd2(cmd, %w(list 3000))
+  run_cmd2(cmd, %w(list run_cmd2))
+
   p = Proc.new do 
     |x,y| x + y
   end
-  run_cmd(cmd, %W(#{cmd.name} p))
-  
+  run_cmd2(cmd, %w(list p))
+
   # Function from a file found via an instruction sequence
-  run_cmd(cmd, %W(#{cmd.name} Columnize.columnize))
-  
+  run_cmd2(cmd, %w(list Columnize.columnize))
+
   # Use Class/method name. 15 isn't in the function - should this be okay?
-  run_cmd(cmd, %W(#{cmd.name} Columnize.columnize 15))
-  
+  run_cmd2(cmd, %W(#{cmd.name} Columnize.columnize 15))
+
   # Start line and count, since 3 < 30
-  run_cmd(cmd, %W(#{cmd.name} Columnize.columnize 30 3))
-  
+  run_cmd2(cmd, %W(#{cmd.name} Columnize.columnize 30 3))
+
   # Start line finish line 
-  run_cmd(cmd, %W(#{cmd.name} Columnize.columnize 40 50))
+  run_cmd2(cmd, %W(#{cmd.name} Columnize.columnize 40 50))
+
+  line = __LINE__
+  brkpt_cmd = cmd.proc.instance_variable_get('@commands')['break']
+  cmd.proc.instance_variable_set('@cmd_argstr', "#{__FILE__} #{line}")
+  brkpt_cmd.run(['break', __FILE__, line.to_s])
+  run_cmd2(cmd, [cmd.name, line.to_s])
+
+  # disable_cmd = cmd.proc.instance_variable_get('@commands')['disable']
+  # disable_cmd.run(['disable', '1'])
 
-  # Method name
-  run_cmd(cmd, %W(#{cmd.name} cmd.run))
+  # run_cmd2(cmd, [cmd.name, line.to_s])
+  run_cmd2(cmd, %W(#{cmd.name} run_cmd2))
+  run_cmd2(cmd, %W(#{cmd.name} run_cmd2))
+  run_cmd2(cmd, %W(#{cmd.name} @713))
 end