byebug 0.0.1

data/lib/byebug/context.rb

@@ -0,0 +1,58 @@
+module Byebug
+
+  class << self
+
+    # interface modules provide +handler+ object
+    attr_accessor :handler
+
+  end
+
+  class Context
+
+    def frame_locals(frame_no=0)
+      result = {}
+      binding = frame_binding(frame_no)
+      locals = eval("local_variables", binding)
+      locals.each {|local| result[local.to_s] = eval(local.to_s, binding)}
+      result
+    end
+
+    def frame_class(frame_no=0)
+      frame_self(frame_no).class
+    end
+
+    def frame_args_info(frame_no=0)
+      nil
+    end
+
+    def interrupt
+      self.stop_next = 1
+    end
+
+    def handler
+      Byebug.handler or raise 'No interface loaded'
+    end
+
+    def at_breakpoint(breakpoint)
+      handler.at_breakpoint(self, breakpoint)
+    end
+
+    def at_catchpoint(excpt)
+      handler.at_catchpoint(self, excpt)
+    end
+
+    def at_tracing(file, line)
+      @tracing_started = File.identical?(file, Byebug::PROG_SCRIPT)
+      handler.at_tracing(self, file, line) if @tracing_started
+    end
+
+    def at_line(file, line)
+      handler.at_line(self, file, line)
+    end
+
+    def at_return(file, line)
+      handler.at_return(self, file, line)
+    end
+
+  end
+end

data/lib/byebug/helper.rb

@@ -0,0 +1,69 @@
+module Byebug
+
+  module ParseFunctions
+    Position_regexp = '(?:(\d+)|(.+?)[:.#]([^.:\s]+))'
+
+    # Parse 'str' of command 'cmd' as an integer between
+    # min and max. If either min or max is nil, that
+    # value has no bound.
+    def get_int(str, cmd, min=nil, max=nil, default=1)
+      return default unless str
+      begin
+        int = Integer(str)
+        if min and int < min
+          print "%s argument '%s' needs to at least %s.\n" % [cmd, str, min]
+          return nil
+        elsif max and int > max
+          print "%s argument '%s' needs to at most %s.\n" % [cmd, str, max]
+          return nil
+        end
+        return int
+      rescue
+        print "%s argument '%s' needs to be a number.\n" % [cmd, str]
+        return nil
+      end
+    end
+
+    # Return true if arg is 'on' or 1 and false arg is 'off' or 0.
+    # Any other value raises RuntimeError.
+    def get_onoff(arg, default=nil, print_error=true)
+      if arg.nil? or arg == ''
+        if default.nil?
+          if print_error
+            print "Expecting 'on', 1, 'off', or 0. Got nothing.\n"
+            raise RuntimeError
+          end
+          return default
+        end
+      end
+      case arg.downcase
+      when '1', 'on'
+        return true
+      when '0', 'off'
+        return false
+      else
+        if print_error
+          print "Expecting 'on', 1, 'off', or 0. Got: %s.\n" % arg.to_s
+          raise RuntimeError
+        end
+      end
+    end
+
+    # Return 'on' or 'off' for supplied parameter. The parmeter should
+    # be true, false or nil.
+    def show_onoff(bool)
+      if not [TrueClass, FalseClass, NilClass].member?(bool.class)
+        return "??"
+      end
+      return bool ? 'on' : 'off'
+    end
+
+    # Return true if code is syntactically correct for Ruby.
+    def syntax_valid?(code)
+      eval("BEGIN {return true}\n#{code}", nil, "", 0)
+    rescue Exception
+      false
+    end 
+
+  end
+end

data/lib/byebug/interface.rb

@@ -0,0 +1,223 @@
+module Byebug
+
+  class Interface # :nodoc:
+    attr_writer :have_readline
+
+    def initialize
+      @have_readline = false
+    end
+
+    # Common routine for reporting byebug error messages.
+    # Derived classed may want to override this to capture output.
+    def errmsg(*args)
+      if Byebug.annotate.to_i > 2
+        aprint 'error-begin'
+        print(*args)
+        aprint ''
+      else
+        print '*** '
+        print(*args)
+      end
+    end
+
+    # Format msg with gdb-style annotation header
+    def afmt(msg, newline="\n")
+      "\032\032#{msg}#{newline}"
+    end
+
+    def aprint(msg)
+      print afmt(msg)
+    end
+
+  end
+
+  class LocalInterface < Interface # :nodoc:
+    attr_accessor :command_queue, :history_length, :history_save, :histfile
+    attr_accessor :restart_file
+
+    unless defined?(FILE_HISTORY)
+      FILE_HISTORY = ".rdebug_hist"
+    end
+    def initialize()
+      super
+      @command_queue = []
+      @have_readline = false
+      @history_save = true
+      # take gdb's default
+      @history_length = ENV["HISTSIZE"] ? ENV["HISTSIZE"].to_i : 256
+      @histfile = File.join(ENV["HOME"]||ENV["HOMEPATH"]||".",
+                            FILE_HISTORY)
+      open(@histfile, 'r') do |file|
+        file.each do |line|
+          line.chomp!
+          Readline::HISTORY << line
+        end
+      end if File.exist?(@histfile)
+      @restart_file = nil
+    end
+
+    def read_command(prompt)
+      readline(prompt, true)
+    end
+
+    def confirm(prompt)
+      readline(prompt, false)
+    end
+
+    def print(*args)
+      STDOUT.printf(*args)
+    end
+
+    def close
+    end
+
+    # Things to do before quitting
+    def finalize
+      if Byebug.method_defined?("annotate") and Byebug.annotate.to_i > 2
+        print "\032\032exited\n\n"
+      end
+      if Byebug.respond_to?(:save_history)
+        Byebug.save_history
+      end
+    end
+
+    def readline_support?
+      @have_readline
+    end
+
+    private
+
+      begin
+        require 'readline'
+        class << Byebug
+          @have_readline = true
+          define_method(:save_history) do
+            iface = self.handler.interface
+            iface.histfile ||= File.join(ENV["HOME"]||ENV["HOMEPATH"]||".",
+                                    FILE_HISTORY)
+            open(iface.histfile, 'w') do |file|
+              Readline::HISTORY.to_a.last(iface.history_length).each do |line|
+                file.puts line unless line.strip.empty?
+              end if defined?(iface.history_save) and iface.history_save
+            end rescue nil
+          end
+          public :save_history
+        end
+
+        def readline(prompt, hist)
+          Readline::readline(prompt, hist)
+        end
+      rescue LoadError
+        def readline(prompt, hist)
+          @histfile = ''
+          @hist_save = false
+          STDOUT.print prompt
+          STDOUT.flush
+          line = STDIN.gets
+          exit unless line
+          line.chomp!
+          line
+        end
+      end
+  end
+
+  class RemoteInterface < Interface # :nodoc:
+    attr_accessor :command_queue, :history_length, :history_save, :histfile
+    attr_accessor :restart_file
+
+    def initialize(socket)
+      @command_queue = []
+      @socket = socket
+      @history_save = false
+      @history_length = 256
+      @histfile = ''
+      # Do we read the histfile?
+#       open(@histfile, 'r') do |file|
+#         file.each do |line|
+#           line.chomp!
+#           Readline::HISTORY << line
+#         end
+#       end if File.exist?(@histfile)
+      @restart_file = nil
+    end
+
+    def close
+      @socket.close
+    rescue Exception
+    end
+
+    def confirm(prompt)
+      send_command "CONFIRM #{prompt}"
+    end
+
+    def finalize
+    end
+
+    def read_command(prompt)
+      send_command "PROMPT #{prompt}"
+    end
+
+    def readline_support?
+      false
+    end
+
+    def print(*args)
+      @socket.printf(*args)
+    end
+
+    private
+
+      def send_command(msg)
+        @socket.puts msg
+        result = @socket.gets
+        raise IOError unless result
+        result.chomp
+      end
+  end
+
+  class ScriptInterface < Interface # :nodoc:
+    attr_accessor :command_queue, :history_length, :history_save, :histfile
+    attr_accessor :restart_file
+
+    def initialize(file, out, verbose=false)
+      super()
+      @command_queue = []
+      @file = file.respond_to?(:gets) ? file : open(file)
+      @out = out
+      @verbose = verbose
+      @history_save = false
+      @history_length = 256  # take gdb default
+      @histfile = ''
+    end
+
+    def finalize
+    end
+
+    def read_command(prompt)
+      while result = @file.gets
+        puts "# #{result}" if @verbose
+        next if result =~ /^\s*#/
+        next if result.strip.empty?
+        break
+      end
+      raise IOError unless result
+      result.chomp!
+    end
+
+    def readline_support?
+      false
+    end
+
+    def confirm(prompt)
+      'y'
+    end
+
+    def print(*args)
+      @out.printf(*args)
+    end
+
+    def close
+      @file.close
+    end
+  end
+end

data/lib/byebug/processor.rb

@@ -0,0 +1,468 @@
+require_relative 'interface'
+require_relative 'command'
+
+module Byebug
+
+  # Should this be a mixin?
+  class Processor # :nodoc
+    attr_accessor :interface
+
+    # Format msg with gdb-style annotation header
+    def afmt(msg, newline="\n")
+      "\032\032#{msg}#{newline}"
+    end
+
+    def aprint(msg)
+      print afmt(msg) if Byebug.annotate.to_i > 2
+    end
+
+    # FIXME: use delegate?
+    def errmsg(*args)
+      @interface.errmsg(*args)
+    end
+
+    # Callers of this routine should make sure to use comma to separate format
+    # argments rather than %. Otherwise it seems that if the string you want to
+    # print has format specifier, which could happen if you are trying to show
+    # say a source-code line with "puts" or "print" in it, this print routine
+    # will give an error saying it is looking for more arguments.
+    def print(*args)
+      @interface.print(*args)
+    end
+
+  end
+
+  class CommandProcessor < Processor # :nodoc:
+    attr_reader   :display
+
+    # FIXME: get from Command regexp method.
+    @@Show_breakpoints_postcmd = [
+                                  /^\s*b(?:reak)?/,
+                                  /^\s* cond(?:ition)? (?:\s+(\d+)\s*(.*))?$/ix,
+                                  /^\s*del(?:ete)?(?:\s+(.*))?$/ix,
+                                  /^\s* dis(?:able)? (?:\s+(.*))?$/ix,
+                                  /^\s* en(?:able)? (?:\s+(.*))?$/ix
+                                  # "tbreak", "clear",
+                                 ]
+    @@Show_annotations_run = [
+                              /^\s*c(?:ont(?:inue)?)?(?:\s+(.*))?$/,
+                              /^\s*fin(?:ish)?$/,
+                              /^\s*n(?:ext)?([+-])?(?:\s+(.*))?$/,
+                              /^\s*s(?:tep)?([+-])?(?:\s+(.*))?$/
+                            ]
+
+    @@Show_annotations_postcmd = [
+                                  /^\s* down (?:\s+(.*))? .*$/x,
+                                  /^\s* f(?:rame)? (?:\s+ (.*))? \s*$/x,
+                                  /^\s* u(?:p)? (?:\s+(.*))?$/x
+                                 ]
+
+    def initialize(interface = LocalInterface.new)
+      @interface = interface
+      @display = []
+
+      @mutex = Mutex.new
+      @last_cmd = nil
+      @last_file = nil   # Filename the last time we stopped
+      @last_line = nil   # line number the last time we stopped
+      @byebug_breakpoints_were_empty = false # Show breakpoints 1st time
+      @byebug_displays_were_empty = true # No display 1st time
+      @byebug_context_was_dead = true # Assume we haven't started.
+    end
+
+    def interface=(interface)
+      @mutex.synchronize do
+        @interface.close if @interface
+        @interface = interface
+      end
+    end
+
+    require 'pathname'  # For cleanpath
+
+    # Regularize file name.
+    # This is also used as a common funnel place if basename is
+    # desired or if we are working remotely and want to change the
+    # basename. Or we are eliding filenames.
+    def self.canonic_file(filename)
+      # For now we want resolved filenames
+      if Command.settings[:basename]
+        File.basename(filename)
+      else
+        # Cache this?
+        Pathname.new(filename).cleanpath.to_s
+      end
+    end
+
+    def self.print_location_and_text(file, line)
+      file_line = "%s:%s\n%s" % [canonic_file(file), line,
+                                 Byebug.line_at(file, line)]
+      # FIXME: use annotations routines
+      if Byebug.annotate.to_i > 2
+        file_line = "\032\032source #{file_line}"
+      elsif ENV['EMACS']
+        file_line = "\032\032#{file_line}"
+      end
+      print file_line
+    end
+
+    def self.protect(mname)
+      alias_method "__#{mname}", mname
+      module_eval %{
+        def #{mname}(*args)
+          @mutex.synchronize do
+            return unless @interface
+            __#{mname}(*args)
+          end
+        rescue IOError, Errno::EPIPE
+          self.interface = nil
+        rescue SignalException
+          raise
+        rescue Exception
+          print "INTERNAL ERROR!!! #\{$!\}\n" rescue nil
+          print $!.backtrace.map{|l| "\t#\{l\}"}.join("\n") rescue nil
+        end
+      }
+    end
+
+    def at_breakpoint(context, breakpoint)
+      aprint 'stopped' if Byebug.annotate.to_i > 2
+      n = Byebug.breakpoints.index(breakpoint) + 1
+      file = CommandProcessor.canonic_file(breakpoint.source)
+      line = breakpoint.pos
+      if Byebug.annotate.to_i > 2
+        print afmt("source #{file}:#{line}")
+      end
+      print "Breakpoint %d at %s:%s\n", n, file, line
+    end
+    protect :at_breakpoint
+
+    def at_catchpoint(context, excpt)
+      aprint 'stopped' if Byebug.annotate.to_i > 2
+      file = CommandProcessor.canonic_file(context.frame_file(0))
+      line = context.frame_line(0)
+      print afmt("%s:%d" % [file, line]) if ENV['EMACS']
+      print "Catchpoint at %s:%d: `%s' (%s)\n", file, line, excpt, excpt.class
+      fs = context.stack_size
+      tb = caller(0)[-fs..-1]
+      if tb
+        for i in tb
+          print "\tfrom %s\n", i
+        end
+      end
+    end
+    protect :at_catchpoint
+
+    def at_tracing(context, file, line)
+      return if defined?(Byebug::RDEBUG_FILE) &&
+        Byebug::RDEBUG_FILE == file # Don't trace ourself
+      @last_file = CommandProcessor.canonic_file(file)
+      file = CommandProcessor.canonic_file(file)
+      unless file == @last_file and @last_line == line and
+          Command.settings[:tracing_plus]
+        print "Tracing:%s:%s %s", file, line, Byebug.line_at(file, line)
+        @last_file = file
+        @last_line = line
+      end
+      always_run(context, file, line, 2)
+    end
+    protect :at_tracing
+
+    def at_line(context, file, line)
+      process_commands(context, file, line)
+    end
+    protect :at_line
+
+    def at_return(context, file, line)
+      context.stop_frame = -1
+      process_commands(context, file, line)
+    end
+
+    private
+
+      # The prompt shown before reading a command.
+      def prompt(context)
+        p = '(rdb:%s) ' % (context.dead?  ? 'post-mortem' : context.thnum)
+        p = afmt("pre-prompt")+p+"\n"+afmt("prompt") if Byebug.annotate.to_i > 2
+        return p
+      end
+
+      # Run these commands, for example display commands or possibly the list or
+      # irb in an "autolist" or "autoirb". We return a list of commands that are
+      # acceptable to run bound to the current state.
+      def always_run(context, file, line, run_level)
+        event_cmds = Command.commands.select{|cmd| cmd.event }
+
+        # Remove some commands in post-mortem
+        event_cmds = event_cmds.find_all do |cmd|
+          cmd.allow_in_post_mortem
+        end if context.dead?
+
+        state = State.new do |s|
+          s.context = context
+          s.file    = file
+          s.line    = line
+          s.binding = context.frame_binding(0)
+          s.display = display
+          s.interface = interface
+          s.commands = event_cmds
+        end
+        @interface.state = state if @interface.respond_to?('state=')
+
+        # Bind commands to the current state.
+        commands = event_cmds.map{|cmd| cmd.new(state)}
+
+        commands.select do |cmd|
+          cmd.class.always_run >= run_level
+        end.each {|cmd| cmd.execute}
+        return state, commands
+      end
+
+      # Handle byebug commands
+      def process_commands(context, file, line)
+        state, commands = always_run(context, file, line, 1)
+        $rdebug_state = state if Command.settings[:byebugtesting]
+        splitter = lambda do |str|
+          str.split(/;/).inject([]) do |m, v|
+            if m.empty?
+              m << v
+            else
+              if m.last[-1] == ?\\
+                m.last[-1,1] = ''
+                m.last << ';' << v
+              else
+                m << v
+              end
+            end
+            m
+          end
+        end
+
+        preloop(commands, context)
+        CommandProcessor.print_location_and_text(file, line)
+        while !state.proceed?
+          input = if @interface.command_queue.empty?
+                    @interface.read_command(prompt(context))
+                  else
+                    @interface.command_queue.shift
+                  end
+          break unless input
+          catch(:debug_error) do
+            if input == ""
+              next unless @last_cmd
+              input = @last_cmd
+            else
+              @last_cmd = input
+            end
+            splitter[input].each do |cmd|
+              one_cmd(commands, context, cmd)
+              postcmd(commands, context, cmd)
+            end
+          end
+        end
+        postloop(commands, context)
+      end # process_commands
+
+      def one_cmd(commands, context, input)
+        if cmd = commands.find{ |c| c.match(input) }
+          if context.dead? && cmd.class.need_context
+            p cmd
+            print "Command is unavailable\n"
+          else
+            cmd.execute
+          end
+        else
+          unknown_cmd = commands.find{ |c| c.class.unknown }
+          if unknown_cmd
+            unknown_cmd.execute
+          else
+            errmsg "Unknown command: \"#{input}\".  Try \"help\".\n"
+          end
+        end
+      end
+
+      def preloop(commands, context)
+        aprint('stopped') if Byebug.annotate.to_i > 2
+        if context.dead?
+          unless @byebug_context_was_dead
+            if Byebug.annotate.to_i > 2
+              aprint('exited')
+              print "The program finished.\n"
+            end
+            @byebug_context_was_dead = true
+          end
+        end
+
+        if Byebug.annotate.to_i > 2
+          # if we are here, the stack frames have changed outside the command
+          # loop (e.g. after a "continue" command), so we show the annotations
+          # again
+          breakpoint_annotations(commands, context)
+          display_annotations(commands, context)
+          annotation('stack', commands, context, "where")
+          annotation('variables', commands, context, "info variables") unless
+            context.dead?
+        end
+      end
+
+      def postcmd(commands, context, cmd)
+        if Byebug.annotate.to_i > 2
+          cmd = @last_cmd unless cmd
+          breakpoint_annotations(commands, context) if
+            @@Show_breakpoints_postcmd.find{|pat| cmd =~ pat}
+          display_annotations(commands, context)
+          if @@Show_annotations_postcmd.find{|pat| cmd =~ pat}
+            annotation('stack', commands, context, "where") if
+              context.stack_size > 0
+            annotation('variables', commands, context, "info variables") unless
+              context.dead?
+          end
+          if not context.dead? and @@Show_annotations_run.find{|pat| cmd =~ pat}
+            aprint 'starting'  if Byebug.annotate.to_i > 2
+
+            @byebug_context_was_dead = false
+          end
+        end
+      end
+
+      def postloop(commands, context)
+      end
+
+      def annotation(label, commands, context, cmd)
+        print afmt(label)
+        one_cmd(commands, context, cmd)
+      end
+
+      def breakpoint_annotations(commands, context)
+        unless Byebug.breakpoints.empty? and @byebug_breakpoints_were_empty
+          annotation('breakpoints', commands, context, "info breakpoints")
+          @byebug_breakpoints_were_empty = Byebug.breakpoints.empty?
+        end
+      end
+
+      def display_annotations(commands, context)
+        return if display.empty?
+#         have_display = display.find{|d| d[0]}
+#         return unless have_display and @byebug_displays_were_empty
+#         @byebug_displays_were_empty = have_display
+        annotation('display', commands, context, "display")
+      end
+
+      class State # :nodoc:
+        attr_accessor :binding, :commands, :context, :display, :file, :frame_pos
+        attr_accessor :interface, :line, :previous_line
+
+        def initialize
+          super()
+          @frame_pos = 0
+          @previous_line = nil
+          @proceed = false
+          yield self
+        end
+
+        # FIXME: use delegate?
+        def errmsg(*args)
+          @interface.errmsg(*args)
+        end
+
+        def print(*args)
+          @interface.print(*args)
+        end
+
+        def confirm(*args)
+          @interface.confirm(*args)
+        end
+
+        def proceed?
+          @proceed
+        end
+
+        def proceed
+          @proceed = true
+        end
+      end
+
+  end # end class CommandProcessor
+
+  class ControlCommandProcessor < Processor # :nodoc:
+    def initialize(interface)
+      super()
+      @interface = interface
+      @byebug_context_was_dead = true # Assume we haven't started.
+    end
+
+    def process_commands(verbose=false)
+      control_cmds = Command.commands.select do |cmd|
+        cmd.allow_in_control
+      end
+      state = State.new(@interface, control_cmds)
+      commands = control_cmds.map{|cmd| cmd.new(state) }
+
+      unless @byebug_context_was_dead
+        if Byebug.annotate.to_i > 2
+          aprint 'exited'
+          print "The program finished.\n"
+        end
+        @byebug_context_was_dead = true
+      end
+
+      while input = @interface.read_command(prompt(nil))
+        print "+#{input}" if verbose
+        catch(:debug_error) do
+          if cmd = commands.find{|c| c.match(input) }
+            cmd.execute
+          else
+            errmsg "Unknown command\n"
+          end
+        end
+      end
+    rescue IOError, Errno::EPIPE
+    rescue Exception
+      print "INTERNAL ERROR!!! #{$!}\n" rescue nil
+      print $!.backtrace.map{|l| "\t#{l}"}.join("\n") rescue nil
+    ensure
+      @interface.close
+    end
+
+    # The prompt shown before reading a command.
+    # Note: have an unused 'context' parameter to match the local interface.
+    def prompt(context)
+      p = '(rdb:ctrl) '
+      p = afmt("pre-prompt")+p+"\n"+afmt("prompt") if
+        Byebug.annotate.to_i > 2
+      return p
+    end
+
+    class State # :nodoc:
+      attr_reader :commands, :interface
+
+      def initialize(interface, commands)
+        @interface = interface
+        @commands = commands
+      end
+
+      def proceed
+      end
+
+      def errmsg(*args)
+        @interface.print(*args)
+      end
+
+      def print(*args)
+        @interface.print(*args)
+      end
+
+      def confirm(*args)
+        'y'
+      end
+
+      def context
+        nil
+      end
+
+      def file
+        errmsg "No filename given.\n"
+        throw :debug_error
+      end
+    end # State
+  end
+end