debugger-ide 0.0.1 → 0.0.2

data/lib/ruby-debug/commands/eval.rb

@@ -0,0 +1,64 @@
+module Debugger
+  class EvalCommand < Command # :nodoc:
+    #self.control = true
+
+    def match(input)
+      @input = input
+      super
+    end
+    
+    def regexp
+      /^\s*(p|e(?:val)?)\s+/
+    end
+
+    def execute
+      expr = @match ? @match.post_match : @input
+      binding = @state.context ? get_binding : TOPLEVEL_BINDING
+      print_eval expr, debug_eval(expr, binding).inspect
+    end
+
+    class << self
+      def help_command
+        %w|p eval|
+      end
+
+      def help(cmd)
+        if cmd == 'p'
+          %{
+            p expression\tevaluate expression and print its value
+          }
+        else
+          %{
+            e[val] expression\tevaluate expression and print its value,
+            \t\t\talias for p.
+          }
+        end
+      end
+    end
+  end
+
+  class PPCommand < Command # :nodoc:
+    def regexp
+      /^\s*pp\s+/
+    end
+
+    def execute
+      exp = @match.post_match
+      out = StringIO.new
+      PP.pp(debug_eval(exp), out) rescue out.puts $!.message
+      print_pp out.string
+    end
+
+    class << self
+      def help_command
+        'pp'
+      end
+
+      def help(cmd)
+        %{
+          pp expression\tevaluate expression and print its value
+        }
+      end
+    end
+  end
+end

data/lib/ruby-debug/commands/frame.rb

@@ -0,0 +1,155 @@
+module Debugger
+
+  module FrameFunctions # :nodoc:
+
+    def adjust_frame(frame_pos, absolute)
+      if absolute
+        if frame_pos < 0
+          abs_frame_pos = @state.context.stack_size + frame_pos
+        else
+          abs_frame_pos = frame_pos - 1
+        end
+      else
+        abs_frame_pos = @state.frame_pos + frame_pos
+      end
+
+      if abs_frame_pos >= @state.context.stack_size then
+        print_error "Adjusting would put us beyond the oldest (initial) frame.\n"
+        return
+      elsif abs_frame_pos < 0 then
+        print_error "Adjusting would put us beyond the newest (innermost) frame.\n"
+        return
+      end
+      if @state.frame_pos != abs_frame_pos then
+        @state.previous_line = nil
+        @state.frame_pos = abs_frame_pos
+      end
+      @state.file = @state.context.frame_file(@state.frame_pos)
+      @state.line = @state.context.frame_line(@state.frame_pos)
+      
+      print_current_frame(@state.frame_pos)
+    end
+
+  end
+
+  class WhereCommand < Command # :nodoc:
+    def regexp
+      /^\s*(?:w(?:here)?|bt|backtrace)$/
+    end
+
+    def execute
+      print_frames(@state.context, @state.frame_pos)
+    end
+
+    class << self
+      def help_command
+        %w|where backtrace|
+      end
+
+      def help(cmd)
+        if cmd == 'where'
+          %{
+            w[here]\tdisplay frames
+          }
+        else
+          %{
+            bt|backtrace\t\talias for where
+          }
+        end
+      end
+    end
+  end
+
+  class UpCommand < Command # :nodoc:
+    include FrameFunctions
+    def regexp
+      /^\s* u(?:p)? (?:\s+(.*))? .*$/x
+    end
+
+    def execute
+      unless @match[1]
+        pos = 1
+      else
+        pos = get_int(@match[1], "Up")
+        return unless pos
+      end
+      adjust_frame(pos, false)
+    end
+
+    class << self
+      def help_command
+        'up'
+      end
+
+      def help(cmd)
+        %{
+          up[count]\tmove to higher frame
+        }
+      end
+    end
+  end
+
+  class DownCommand < Command # :nodoc:
+    include FrameFunctions
+    def regexp
+      /^\s* down (?:\s+(.*))? .*$/x
+    end
+
+    def execute
+      if not @match[1]
+        pos = 1
+      else
+        pos = get_int(@match[1], "Down")
+        return unless pos
+      end
+      adjust_frame(-pos, false)
+    end
+
+    class << self
+      def help_command
+        'down'
+      end
+
+      def help(cmd)
+        %{
+          down[count]\tmove to lower frame
+        }
+      end
+    end
+  end
+  
+  class FrameCommand < Command # :nodoc:
+    include FrameFunctions
+    def regexp
+      /^\s* f(?:rame)? (?:\s+ (.*))? \s*$/x
+    end
+
+    def execute
+      if not @match[1]
+        print "Missing a frame number argument.\n"
+        return
+      else
+        pos = get_int(@match[1], "Frame")
+        return unless pos
+      end
+      adjust_frame(pos, true)
+    end
+
+    class << self
+      def help_command
+        'frame'
+      end
+
+      def help(cmd)
+        %{
+          f[rame] frame-number
+          Move the current frame to the specified frame number.
+
+          A negative number indicates position from the other end.  So
+          'frame -1' moves to the oldest frame, and 'frame 0' moves to
+          the newest frame.
+        }
+      end
+    end
+  end
+end

data/lib/ruby-debug/commands/inspect.rb

@@ -0,0 +1,24 @@
+module Debugger
+
+  class InspectCommand < Command
+    # reference inspection results in order to save them from the GC
+    @@references = []
+    def self.reference_result(result)
+      @@references << result
+    end
+    def self.clear_references
+      @@references = []
+    end
+    
+    def regexp
+      /^\s*v(?:ar)?\s+inspect\s+/
+    end
+    #    
+    def execute
+      obj = debug_eval(@match.post_match)
+      InspectCommand.reference_result(obj)
+      @printer.print_inspect(obj)
+    end
+  end
+
+end

data/lib/ruby-debug/commands/jump.rb

@@ -0,0 +1,73 @@
+module Debugger
+
+  # Implements debugger "jump" command
+  class JumpCommand < Command
+    self.need_context = true
+
+    def numeric?(object)
+      true if Float(object) rescue false
+    end
+
+    def regexp
+      / ^\s*
+         j(?:ump)? \s*
+         (?:\s+(\S+))?\s*
+         (?:\s+(\S+))?\s*
+         $
+      /ix
+    end
+
+    def execute
+      unless @state.context.respond_to?(:jump)
+        print_msg "Not implemented"
+        return
+      end
+      if !@match[1]
+        print_msg "\"jump\" must be followed by a line number"
+        return
+      end
+      if !numeric?(@match[1])
+        print_msg "Bad line number: " + @match[1]
+        return
+      end
+      line = @match[1].to_i
+      line = @state.context.frame_line(0) + line if @match[1][0] == '+' or @match[1][0] == '-'
+      if line == @state.context.frame_line(0)
+        return
+      end
+      file = @match[2]
+      file = @state.context.frame_file(file.to_i) if numeric?(file)
+      file = @state.context.frame_file(0) if !file
+      case @state.context.jump(line, file)
+      when 0
+        @state.proceed
+        return
+      when 1
+        print_msg "Not possible to jump from here"
+      when 2
+        print_msg "Couldn't find debugged frame"
+      when 3
+        print_msg "Couldn't find active code at " + file + ":" + line.to_s
+      else
+        print_msg "Unknown error occurred"
+      end
+      @printer.print_at_line(@state.context, @state.context.frame_file, @state.context.frame_line)
+    end
+
+    class << self
+      def help_command
+        %w[jump]
+      end
+
+      def help(cmd)
+        %{
+          j[ump] line\tjump to line number (absolute)
+          j[ump] -line\tjump back to line (relative)
+          j[ump] +line\tjump ahead to line (relative)
+
+          Change the next line of code to be executed.
+         }
+     end
+    end
+  end
+end

data/lib/ruby-debug/commands/load.rb

@@ -0,0 +1,18 @@
+module Debugger
+  class LoadCommand < Command  
+    def regexp
+      /^\s*load\s+/
+    end
+    
+    def execute
+      fileName = @match.post_match
+      @printer.print_debug("loading file: %s", fileName)
+      begin
+        load fileName
+        @printer.print_load_result(fileName)
+      rescue Exception => error
+        @printer.print_load_result(fileName, error)
+      end
+    end
+  end
+end

data/lib/ruby-debug/commands/pause.rb

@@ -0,0 +1,32 @@
+module Debugger
+
+  # Implements debugger "pause" command
+  class PauseCommand < Command
+    self.control = true
+
+    def regexp
+      /^\s*pause\s*(?:\s+(\S+))?\s*$/
+    end
+
+    def execute
+      c = get_context(@match[1].to_i)
+      unless c.respond_to?(:pause)
+        print_msg "Not implemented"
+        return
+      end
+      c.pause
+    end
+
+    class << self
+      def help_command
+        %w[pause]
+      end
+
+      def help(cmd)
+        %{
+          pause <nnn>\tpause a running thread
+         }
+     end
+    end
+  end
+end

data/lib/ruby-debug/commands/set_type.rb

@@ -0,0 +1,47 @@
+module Debugger
+
+  # Implements debugger "set_type" command
+  class SetTypeCommand < Command
+    self.need_context = true
+
+    def regexp
+      / ^\s*
+         set_type? \s*
+         (?:\s+(\S+))?\s*
+         (?:\s+(\S+))?\s*
+         $
+      /ix
+    end
+
+    def execute
+      if RUBY_VERSION < "1.9"
+        print_msg "Not implemented"
+        return
+      end
+      begin
+        expr = @match[1] + " = " + @match[2] + "(" + @match[1] + ".inspect)"
+        eval(expr)
+      rescue
+        begin
+          expr = @match[1] + " = " + @match[2] + ".new(" + @match[1] + ".inspect)"
+          eval(expr)
+        rescue nil
+        end
+      end
+    end
+
+    class << self
+      def help_command
+        %w[set_type]
+      end
+
+      def help(cmd)
+        %{
+          set_type <var> <type>
+
+          Change the type of <var> to <type>
+         }
+     end
+    end
+  end
+end

data/lib/ruby-debug/commands/stepping.rb

@@ -0,0 +1,108 @@
+module Debugger
+  class NextCommand < Command # :nodoc:
+    self.need_context = true
+    
+    def regexp
+      /^\s*n(?:ext)?([+-])?(?:\s+(\d+))?$/
+    end
+
+    def execute
+      force = @match[1] == '+'
+      steps = @match[2] ? @match[2].to_i : 1
+      @state.context.step_over steps, @state.frame_pos, force
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'next'
+      end
+
+      def help(cmd)
+        %{
+          n[ext][+][ nnn]\tstep over once or nnn times, 
+          \t\t'+' forces to move to another line
+        }
+      end
+    end
+  end
+
+  class StepCommand < Command # :nodoc:
+    self.need_context = true
+    
+    def regexp
+      /^\s*s(?:tep)?([+-])?(?:\s+(\d+))?$/
+    end
+
+    def execute
+      force = @match[1] == '+'
+      steps = @match[2] ? @match[2].to_i : 1
+      @state.context.step(steps, force)
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'step'
+      end
+
+      def help(cmd)
+        %{
+          s[tep][ nnn]\tstep (into methods) once or nnn times
+        }
+      end
+    end
+  end
+
+  class FinishCommand < Command # :nodoc:
+    self.need_context = true
+    
+    def regexp
+      /^\s*fin(?:ish)?$/
+    end
+
+    def execute
+      if @state.frame_pos == @state.context.stack_size - 1
+        print_msg "\"finish\" not meaningful in the outermost frame."
+      else
+        @state.context.stop_frame = @state.frame_pos
+        @state.frame_pos = 0
+        @state.proceed
+      end
+    end
+
+    class << self
+      def help_command
+        'finish'
+      end
+
+      def help(cmd)
+        %{
+          fin[ish]\treturn to outer frame
+        }
+      end
+    end
+  end
+
+  class ContinueCommand < Command # :nodoc:
+    def regexp
+      /^\s*c(?:ont)?$/
+    end
+
+    def execute
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'cont'
+      end
+
+      def help(cmd)
+        %{
+          c[ont]\trun until program ends or hit breakpoint
+        }
+      end
+    end
+  end
+end