ruby-debug193 0.0.1

data/cli/ruby-debug/commands/reload.rb

@@ -0,0 +1,40 @@
+module Debugger
+  # Implements debugger "reload" command.
+  class ReloadCommand < Command
+    self.allow_in_control = true
+
+    register_setting_get(:reload_source_on_change) do 
+      Debugger.reload_source_on_change
+    end
+    register_setting_set(:reload_source_on_change) do |value|
+      Debugger.reload_source_on_change = value
+    end
+    
+    def regexp
+      /^\s*r(?:eload)?$/
+    end
+    
+    def execute
+      Debugger.source_reload
+      print "Source code is reloaded. Automatic reloading is #{source_reloading}.\n"
+    end
+    
+    private
+    
+    def source_reloading
+      Debugger.reload_source_on_change ? 'on' : 'off'
+    end
+    
+    class << self
+      def help_command
+        'reload'
+      end
+
+      def help(cmd)
+        %{
+          r[eload]\tforces source code reloading
+        }
+      end
+    end
+  end
+end

data/cli/ruby-debug/commands/save.rb

@@ -0,0 +1,90 @@
+module Debugger
+  module SaveFunctions # :nodoc:
+
+    # Create a temporary file to write in if file is nil
+    def open_save
+      require "tempfile"
+      file = Tempfile.new("rdebug-save")
+      # We want close to not unlink, so redefine.
+      def file.close
+        @tmpfile.close if @tmpfile
+      end
+      return file
+    end
+  end
+
+  class SaveCommand < Command # :nodoc:
+    self.allow_in_control = true
+    
+    def save_breakpoints(file)
+      Debugger.breakpoints.each do |b|
+        file.puts "break #{b.source}:#{b.pos}#{" if #{b.expr}" if b.expr}"
+      end
+    end
+
+    def save_catchpoints(file)
+      Debugger.catchpoints.keys.each do |c|
+        file.puts "catch #{c}" 
+      end
+    end
+    
+    def save_displays(file)
+      for d in @state.display
+        if d[0]
+          file.puts "display #{d[1]}"
+        end
+      end
+    end
+    
+    def save_settings(file)
+      # FIXME put routine in set
+      %w(autoeval basename debuggertesting).each do |setting|
+        on_off = show_onoff(Command.settings[setting.to_sym])
+        file.puts "set #{setting} #{on_off}"
+      end
+      %w(autolist autoirb).each do |setting|
+        on_off = show_onoff(Command.settings[setting.to_sym] > 0)
+        file.puts "set #{setting} #{on_off}"
+      end
+    end
+    
+    def regexp
+      /^\s* sa(?:ve)?
+        (?:\s+(.+))? 
+        \s*$/ix
+    end
+    
+    def execute
+      if not @match[1] or @match[1].strip.empty?
+        file = open_save()
+      else
+        file = open(@match[1], 'w')
+      end
+      save_breakpoints(file)
+      save_catchpoints(file)
+      # save_displays(file)
+      save_settings(file)
+      print "Saved to '#{file.path}'\n"
+      if @state and @state.interface
+        @state.interface.restart_file = file.path
+      end
+      file.close
+    end
+
+    class << self
+      def help_command
+        'save'
+      end
+      
+      def help(cmd)
+        %{
+save [FILE]
+Saves current debugger state to FILE as a script file.
+This includes breakpoints, catchpoints, display expressions and some settings.
+If no filename is given, we will fabricate one.
+
+Use the 'source' command in another debug session to restore them.}
+      end
+    end
+  end
+end

data/cli/ruby-debug/commands/set.rb

@@ -0,0 +1,237 @@
+module Debugger
+  # Implements debugger "set" command.
+  class SetCommand < Command
+    SubcmdStruct2=Struct.new(:name, :min, :is_bool, :short_help, 
+                             :long_help) unless defined?(SubcmdStruct2)
+    Subcommands = 
+      [
+       ['annotate', 2, false,
+       "Set annotation level",
+"0 == normal;
+2 == output annotated suitably for use by programs that control 
+ruby-debug."],
+       ['args', 2, false,
+       "Set argument list to give program being debugged when it is started",
+"Follow this command with any number of args, to be passed to the program."],
+       ['autoeval', 4, true,
+        "Evaluate every unrecognized command"],
+       ['autolist', 4, true,
+        "Execute 'list' command on every breakpoint"],
+       ['autoirb', 4, true,
+        "Invoke IRB on every stop"],
+       ['autoreload', 4, true,
+        "Reload source code when changed"],
+       ['basename', 1, true,
+        "Report file basename only showing file names"],
+       ['callstyle', 2, false,
+        "Set how you want call parameters displayed"],
+       ['debuggertesting', 8, false,
+        "Used when testing the debugger"],
+       ['forcestep', 2, true,
+        "Make sure 'next/step' commands always move to a new line"],
+       ['fullpath', 2, true,
+        "Display full file names in frames"],
+       ['history', 2, false,
+        "Generic command for setting command history parameters",
+"set history filename -- Set the filename in which to record the command history
+set history save -- Set saving of the history record on exit
+set history size -- Set the size of the command history"],
+       ['keep-frame-bindings', 1, true,
+        "Save frame binding on each call"],
+       ['linetrace+', 10, true,
+       "Set line execution tracing to show different lines"],
+       ['linetrace', 3, true,
+       "Set line execution tracing"],
+       ['listsize', 3, false,
+       "Set number of source lines to list by default"],
+#        ['post-mortem', 3, true,
+#        "Set whether we do post-mortem handling on an uncaught exception"],
+       ['trace', 1, true,
+        "Display stack trace when 'eval' raises exception"],
+       ['width', 1, false,
+        "Number of characters the debugger thinks are in a line"],
+      ].map do |name, min, is_bool, short_help, long_help| 
+      SubcmdStruct2.new(name, min, is_bool, short_help, long_help)
+    end unless defined?(Subcommands)
+    
+    self.allow_in_control = true
+
+    def regexp
+      /^set (?: \s+ (.*) )?$/ix
+    end
+
+    def execute
+      if not @match[1]
+        print "\"set\" must be followed by the name of an set command:\n"
+        print "List of set subcommands:\n\n"
+        for subcmd in Subcommands do
+          print "set #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+      else
+        args = @match[1].split(/[ \t]+/)
+        subcmd = args.shift
+        subcmd.downcase!
+        if subcmd =~ /^no/i
+          set_on = false
+          subcmd = subcmd[2..-1]
+        else
+          set_on = true
+        end
+        for try_subcmd in Subcommands do
+          if (subcmd.size >= try_subcmd.min) and
+              (try_subcmd.name[0..subcmd.size-1] == subcmd)
+            begin
+              if try_subcmd.is_bool
+                if args.size > 0 
+                  set_on = get_onoff(args[0]) 
+                end
+              end
+              case try_subcmd.name
+              when /^annotate$/
+                level = get_int(args[0], "Set annotate", 0, 3, 0)
+                if level
+                  Debugger.annotate = level
+                else
+                  return
+                end
+                if defined?(Debugger::RDEBUG_SCRIPT)
+                  # rdebug was called initially. 1st arg is script name.
+                  Command.settings[:argv][1..-1] = args
+                else
+                  # rdebug wasn't called initially. 1st arg is not script name.
+                  Command.settings[:argv] = args
+                end
+              when /^args$/
+                Command.settings[:argv][1..-1] = args
+              when /^autolist$/
+                Command.settings[:autolist] = (set_on ? 1 : 0)
+              when /^autoeval$/
+                Command.settings[:autoeval] = set_on
+              when /^basename$/
+                Command.settings[:basename] = set_on
+              when /^callstyle$/
+                if args[0]
+                  arg = args[0].downcase.to_sym
+                  case arg
+                  when :short, :last, :tracked
+                    Command.settings[:callstyle] = arg
+                    Debugger.track_frame_args = arg == :tracked ? true : false
+                    print "%s\n" % show_setting(try_subcmd.name)
+                    return
+                  end
+                end
+                print "Invalid call style #{arg}. Should be one of: " +
+                  "'short', 'last', or 'tracked'.\n"
+              when /^trace$/
+                Command.settings[:stack_trace_on_error] = set_on
+              when /^fullpath$/
+                Command.settings[:full_path] = set_on
+              when /^autoreload$/
+                Command.settings[:reload_source_on_change] = set_on
+              when /^autoirb$/
+                Command.settings[:autoirb] = (set_on ? 1 : 0)
+              when /^debuggertesting$/
+                Command.settings[:debuggertesting] = set_on
+                if set_on
+                  Command.settings[:basename] = true
+                end
+              when /^forcestep$/
+                self.class.settings[:force_stepping] = set_on
+              when /^history$/
+                if 2 == args.size
+                  interface = @state.interface
+                  case args[0]
+                  when /^save$/
+                    interface.history_save = get_onoff(args[1])
+                  when /^size$/
+                    interface.history_length = get_int(args[1],
+                                                       "Set history size")
+                  else
+                    print "Invalid history parameter #{args[0]}. Should be 'save' or 'size'.\n" 
+                  end
+                else
+                  print "Need two parameters for 'set history'; got #{args.size}.\n" 
+                  return
+                end
+              when /^keep-frame-bindings$/
+                Debugger.keep_frame_binding = set_on
+              when /^linetrace\+$/
+                self.class.settings[:tracing_plus] = set_on
+              when /^linetrace$/
+                Debugger.tracing = set_on
+              when /^listsize$/
+                listsize = get_int(args[0], "Set listsize", 1, nil, 10)
+                if listsize
+                  self.class.settings[:listsize] = listsize
+                else
+                  return
+                end
+#               when /^post-mortem$/
+#                 unless Debugger.post_mortem? == set_on
+#                   if set_on
+#                     Debugger.post_mortem
+#                   else
+#                     errmsg "Can't turn off post-mortem once it is on.\n"
+#                     return
+#                   end
+#                 end
+              when /^width$/
+                width = get_int(args[0], "Set width", 10, nil, 80)
+                if width
+                  self.class.settings[:width] = width
+                  ENV['COLUMNS'] = width.to_s
+                else
+                  return
+                end
+              else
+                print "Unknown setting #{@match[1]}.\n"
+                return
+              end
+              print "%s\n" % show_setting(try_subcmd.name)
+              return
+            rescue RuntimeError
+              return
+            end
+          end
+        end
+        print "Unknown set command #{subcmd}\n"
+      end
+    end
+
+    class << self
+      def help_command
+        "set"
+      end
+
+      def help(args)
+        if args[1] 
+          s = args[1]
+          subcmd = Subcommands.find do |try_subcmd| 
+            (s.size >= try_subcmd.min) and
+              (try_subcmd.name[0..s.size-1] == s)
+          end
+          if subcmd
+            str = subcmd.short_help + '.'
+            str += "\n" + subcmd.long_help if subcmd.long_help
+            return str
+          else
+            return "Invalid 'set' subcommand '#{args[1]}'."
+          end
+        end
+        s = %{
+          Modifies parts of the ruby-debug environment. Boolean values take
+          on, off, 1 or 0.
+          You can see these environment settings with the \"show\" command.
+
+          -- 
+          List of set subcommands:
+          --  
+        }
+        for subcmd in Subcommands do
+          s += "set #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+end

data/cli/ruby-debug/commands/show.rb

@@ -0,0 +1,253 @@
+module Debugger
+  # Mix-in module to showing settings
+  module ShowFunctions # :nodoc:
+    def show_setting(setting_name)
+      case setting_name
+      when /^annotate$/
+        Debugger.annotate ||= 0
+        return ("Annotation level is #{Debugger.annotate}")
+      when /^args$/
+        if Command.settings[:argv] and Command.settings[:argv].size > 0
+          if defined?(Debugger::RDEBUG_SCRIPT)
+            # rdebug was called initially. 1st arg is script name.
+            args = Command.settings[:argv][1..-1].join(' ')
+          else
+            # rdebug wasn't called initially. 1st arg is not script name.
+            args = Command.settings[:argv].join(' ')
+          end
+        else
+          args = ''
+        end
+        return "Argument list to give program being debugged when it is started is \"#{args}\"."
+      when /^autolist$/
+        on_off = Command.settings[:autolist] > 0
+        return "autolist is #{show_onoff(on_off)}."
+      when /^autoeval$/
+        on_off = Command.settings[:autoeval]
+        return "autoeval is #{show_onoff(on_off)}."
+      when /^autoreload$/
+        on_off = Command.settings[:reload_source_on_change]
+        return "autoreload is #{show_onoff(on_off)}."
+      when /^autoirb$/
+        on_off = Command.settings[:autoirb] > 0
+        return "autoirb is #{show_onoff(on_off)}."
+      when /^basename$/
+        on_off = Command.settings[:basename]
+        return "basename is #{show_onoff(on_off)}."
+      when /^callstyle$/
+        style = Command.settings[:callstyle]
+        return "Frame call-display style is #{style}."
+      when /^commands(:?\s+(\d+))?$/
+        if @state.interface.readline_support?
+          s = '';
+          args = @match[1].split
+          if args[1]
+            first_line = args[1].to_i - 4
+            last_line  = first_line + 10 - 1
+            if first_line > Readline::HISTORY.length
+              first_line = last_line = Readline::HISTORY.length
+            elsif first_line <= 0
+              first_line = 1
+            end
+            if last_line > Readline::HISTORY.length
+              last_line = Readline::HISTORY.length
+            end
+            i = first_line
+            commands = Readline::HISTORY.to_a[first_line..last_line]
+          else
+            if Readline::HISTORY.length > 10
+              commands = Readline::HISTORY.to_a[-10..-1]
+              i = Readline::HISTORY.length - 10
+            else
+              commands = Readline::HISTORY.to_a
+              i = 1
+            end
+          end
+          commands.each do |cmd|
+            s += ("%5d  %s\n" % [i, cmd])
+            i += 1
+          end
+        else
+          s='No readline suport'
+        end
+        return s
+      when /^debuggertesting$/
+        on_off = Command.settings[:debuggertesting]
+        return "Currently testing the debugger is #{show_onoff(on_off)}."
+      when /^forcestep$/
+        on_off = self.class.settings[:force_stepping]
+        return "force-stepping is #{show_onoff(on_off)}."
+      when /^fullpath$/
+        on_off = Command.settings[:full_path]
+        return "Displaying frame's full file names is #{show_onoff(on_off)}."
+      when /^history(:?\s+(filename|save|size))?$/
+        args = @match[1].split
+        interface = @state.interface
+        if args[1] 
+          show_save = show_size = show_filename = false
+          prefix = false
+          if args[1] == "save"
+            show_save = true
+          elsif args[1] == "size"
+            show_size = true
+          elsif args[1] == "filename"
+            show_filename = true
+          end
+        else
+          show_save = show_size = show_filename = true
+          prefix = true
+        end
+        s = []
+        if show_filename
+          msg = (prefix ? "filename: " : "") + 
+            "The filename in which to record the command history is " +
+                      "#{interface.histfile.inspect}"
+          s << msg
+        end
+        if show_save
+          msg = (prefix ? "save: " : "") + 
+            "Saving of history save is #{show_onoff(interface.history_save)}."
+          s << msg
+        end
+        if show_size
+          msg = (prefix ? "size: " : "") + 
+            "Debugger history size is #{interface.history_length}"
+          s << msg
+        end
+        return s.join("\n")
+      when /^keep-frame-bindings$/
+        on_off = Debugger.keep_frame_binding?
+        return "keep-frame-bindings is #{show_onoff(on_off)}."
+      when /^linetrace$/
+        on_off = Debugger.tracing
+        return "line tracing is #{show_onoff(on_off)}."
+      when /^linetrace\+$/
+        on_off = Command.settings[:tracing_plus]
+        if on_off
+          return "line tracing style is different consecutive lines."
+        else
+          return "line tracing style is every line."
+        end
+      when /^listsize$/
+        listlines = Command.settings[:listsize]
+        return "Number of source lines to list by default is #{listlines}."
+      when /^port$/
+        return "server port is #{Debugger::PORT}."
+      when /^post-mortem$/
+        on_off = Debugger.post_mortem?
+        return "post-mortem handling is #{show_onoff(on_off)}."
+      when /^trace$/
+        on_off = Command.settings[:stack_trace_on_error]
+        return "Displaying stack trace is #{show_onoff(on_off)}."
+      when /^version$/
+        return "ruby-debug #{Debugger::VERSION}"
+      when /^width$/
+        return "width is #{self.class.settings[:width]}."
+      else
+        return "Unknown show subcommand #{setting_name}."
+      end
+    end
+  end
+
+  # Implements debugger "show" command.
+  class ShowCommand < Command
+    
+    Subcommands = 
+      [
+       ['annotate', 2, "Show annotation level",
+"0 == normal; 2 == output annotated suitably for use by programs that control 
+ruby-debug."],
+       ['args', 2, 
+        "Show argument list to give program being debugged when it is started",
+"Follow this command with any number of args, to be passed to the program."],
+       ['autoeval',  4, "Show if unrecognized command are evaluated"],
+       ['autolist',  4, "Show if 'list' commands is run on breakpoints"],
+       ['autoirb',   4, "Show if IRB is invoked on debugger stops"],
+       ['autoreload', 4, "Show if source code is reloaded when changed"],
+       ['basename',  1, "Show if basename used in reporting files"],
+       ['callstyle', 2, "Show paramater style used showing call frames"],
+       ['commands',  2, "Show the history of commands you typed",
+"You can supply a command number to start with."],
+       ['forcestep', 1, "Show if sure 'next/step' forces move to a new line"],
+       ['fullpath',  2, "Show if full file names are displayed in frames"],
+       ['history', 2, "Generic command for showing command history parameters",
+"show history filename -- Show the filename in which to record the command history
+show history save -- Show saving of the history record on exit
+show history size -- Show the size of the command history"],
+       ['keep-frame-bindings', 1, "Save frame binding on each call"],
+       ['linetrace', 3, "Show line execution tracing"],
+       ['linetrace+', 10, 
+        "Show if consecutive lines should be different are shown in tracing"],
+       ['listsize', 3, "Show number of source lines to list by default"],
+       ['port', 3, "Show server port"],
+       ['post-mortem', 3, "Show whether we go into post-mortem debugging on an uncaught exception"],
+       ['trace', 1, 
+        "Show if a stack trace is displayed when 'eval' raises exception"],
+       ['version', 1, 
+        "Show what version of the debugger this is"],
+       ['width', 1, 
+        "Show the number of characters the debugger thinks are in a line"],
+      ].map do |name, min, short_help, long_help| 
+      SubcmdStruct.new(name, min, short_help, long_help)
+    end unless defined?(Subcommands)
+    
+    self.allow_in_control = true
+
+    def regexp
+      /^show (?: \s+ (.+) )?$/xi
+    end
+
+    def execute
+      if not @match[1]
+        print "\"show\" must be followed by the name of an show command:\n"
+        print "List of show subcommands:\n\n"
+        for subcmd in Subcommands do
+          print "show #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+      else
+        args = @match[1].split(/[ \t]+/)
+        param = args.shift
+        subcmd = find(Subcommands, param)
+        if subcmd
+          print "%s\n" % show_setting(subcmd.name)
+        else
+          print "Unknown show command #{param}\n"
+        end
+      end
+    end
+
+    class << self
+      def help_command
+        "show"
+      end
+
+      def help(args)
+        if args[1] 
+          s = args[1]
+          subcmd = Subcommands.find do |try_subcmd| 
+            (s.size >= try_subcmd.min) and
+              (try_subcmd.name[0..s.size-1] == s)
+          end
+          if subcmd
+            str = subcmd.short_help + '.'
+            str += "\n" + subcmd.long_help if subcmd.long_help
+            return str
+          else
+            return "Invalid 'show' subcommand '#{args[1]}'."
+          end
+        end
+        s = "
+          Generic command for showing things about the debugger.
+
+          -- 
+          List of show subcommands:
+          --  
+        "
+        for subcmd in Subcommands do
+          s += "show #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+end