debug 1.0.0.alpha1 → 1.0.0.beta1

data/lib/debug/source_repository.rb

@@ -1,20 +1,27 @@
-module DEBUGGER__
-  class SourceRepository
-    def initialize
-      @files = {} # filename => [src, iseq]
-    end
-
-    def add iseq, src
-      begin
-        src = File.read(iseq.path)
-      rescue
-        src = nil
-      end unless src
-      @files[iseq.path] = [src, iseq]
-    end
-
-    def get path
-      @files[path]
-    end
-  end
-end
+module DEBUGGER__
+  class SourceRepository
+    def initialize
+      @files = {} # filename => [src, iseq]
+    end
+
+    def add iseq, src
+      path = iseq.absolute_path
+      path = '-e' if iseq.path == '-e'
+
+      case
+      when path = iseq.absolute_path
+        src = File.read(path)
+      when iseq.path == '-e'
+        path = '-e'
+      else
+        src = nil
+      end
+
+      @files[path] = src.lines if src
+    end
+
+    def get path
+      @files[path]
+    end
+  end
+end

data/lib/debug/thread_client.rb

@@ -1,25 +1,31 @@
+require 'objspace'
+require 'pp'
+
 module DEBUGGER__
   class ThreadClient
     def self.current
       Thread.current[:DEBUGGER__ThreadClient] || begin
-        tc = SESSION.thread_client
+        tc = ::DEBUGGER__::SESSION.thread_client
         Thread.current[:DEBUGGER__ThreadClient] = tc
       end
     end
 
-    attr_reader :location, :thread
+    attr_reader :location, :thread, :mode, :id
 
-    def initialize q_evt, q_cmd, thr = Thread.current
+    def initialize id, q_evt, q_cmd, thr = Thread.current
+      @id = id
       @thread = thr
       @q_evt = q_evt
       @q_cmd = q_cmd
       @step_tp = nil
       @output = []
-      @mode = nil
+      @src_lines_on_stop = (DEBUGGER__::CONFIG[:show_src_lines]   || 10).to_i
+      @show_frames_on_stop = (DEBUGGER__::CONFIG[:show_frames] || 2).to_i
+      set_mode nil
     end
 
     def inspect
-      "#<DEBUGGER__ThreadClient #{@thread}>"
+      "#<DBG:TC #{self.id}:#{self.mode}@#{@thread.backtrace[-1]}>"
     end
 
     def puts str = ''
@@ -44,11 +50,11 @@ module DEBUGGER__
 
     ## events
 
-    def on_trap
-      if @mode == :wait_next_action
-        raise Interrupt
+    def on_trap sig
+      if self.mode == :wait_next_action
+        # raise Interrupt
       else
-        on_suspend :trap
+        on_suspend :trap, sig: sig
       end
     end
 
@@ -56,18 +62,24 @@ module DEBUGGER__
       on_suspend :pause
     end
 
+    def on_thread_begin th
+      event! :thread_begin, th
+      wait_next_action
+    end
+
     def on_load iseq, eval_src
       event! :load, iseq, eval_src
       wait_next_action
     end
 
-    def on_breakpoint tp
-      on_suspend tp.event, tp
+    def on_breakpoint tp, bp
+      on_suspend tp.event, tp, bp: bp
     end
 
-    def on_suspend event, tp = nil
+    def on_suspend event, tp = nil, bp: nil, sig: nil
       @current_frame_index = 0
-      @target_frames = target_frames
+      @target_frames = DEBUGGER__.capture_frames __dir__
+
       cf = @target_frames.first
       if cf
         @location = cf.location
@@ -79,85 +91,140 @@ module DEBUGGER__
       end
 
       if event != :pause
-        show_src
-        print_frames 3
-        event! :suspend, :breakpoint
+        show_src max_lines: @src_lines_on_stop
+        show_frames @show_frames_on_stop
+
+        if bp
+          event! :suspend, :breakpoint, bp.key
+        elsif sig
+          event! :suspend, :trap, sig
+        else
+          event! :suspend, event
+        end
       end
 
       wait_next_action
     end
-    
+
     ## control all
 
+    begin
+      TracePoint.new(:raise){}.enable(target_thread: Thread.current)
+      SUPPORT_TARGET_THREAD = true
+    rescue ArgumentError
+      SUPPORT_TARGET_THREAD = false
+    end
+
     def step_tp
       @step_tp.disable if @step_tp
-      @step_tp = TracePoint.new(:line, :b_return, :return){|tp|
-        next if SESSION.break? tp.path, tp.lineno
-        next if !yield
-        tp.disable
-        on_suspend tp.event, tp
-      }
-
-      @step_tp.enable(target_thread: Thread.current)
-    end
-
-    FrameInfo = Struct.new(:location, :self, :binding, :iseq, :class, :has_return_value, :return_value)
-
-    def target_frames
-      RubyVM::DebugInspector.open{|dc|
-        locs = dc.backtrace_locations
-        locs.map.with_index{|e, i|
-          unless File.dirname(e.path) == File.dirname(__FILE__)
-            FrameInfo.new(
-              e,
-              dc.frame_self(i),
-              dc.frame_binding(i),
-              dc.frame_iseq(i),
-              dc.frame_class(i))
-          end
-        }.compact
-      }
-    end
 
-    def target_frames_count
-      RubyVM::DebugInspector.open{|dc|
-        locs = dc.backtrace_locations
-        locs.count{|e|
-          e.path != __FILE__
+      thread = Thread.current
+
+      if SUPPORT_TARGET_THREAD
+        @step_tp = TracePoint.new(:line, :b_return, :return){|tp|
+          next if SESSION.break? tp.path, tp.lineno
+          next if !yield
+          next if tp.path.start_with?(__dir__)
+          tp.disable
+          on_suspend tp.event, tp
+        }
+        @step_tp.enable(target_thread: thread)
+      else
+        @step_tp = TracePoint.new(:line, :b_return, :return){|tp|
+          next if thread != Thread.current
+          next if SESSION.break? tp.path, tp.lineno
+          next if !yield
+          tp.disable
+          on_suspend tp.event, tp
         }
-      }
+        @step_tp.enable
+      end
     end
 
     def current_frame
-      @target_frames[@current_frame_index]
+      if @target_frames
+        @target_frames[@current_frame_index]
+      else
+        nil
+      end
     end
 
     def file_lines path
-      if (src = SESSION.source(path)) && src[0]
-        src[0].lines
+      if (src_lines = SESSION.source(path))
+        src_lines
       elsif File.exist?(path)
         File.readlines(path)
       end
     end
 
-    def show_src frame_index = @current_frame_index, max_lines: 10
-      if current_line = @target_frames[frame_index]&.location
-        puts
-        path, line = current_line.path, current_line.lineno - 1
-        if file_lines = file_lines(path)
-          lines = file_lines.map.with_index{|e, i|
-            if i == line
+    def show_src(frame_index: @current_frame_index,
+                 update_line: false,
+                 max_lines: 10,
+                 start_line: nil,
+                 end_line: nil,
+                 dir: +1)
+      #
+      if @target_frames && frame = @target_frames[frame_index]
+        if file_lines = file_lines(path = frame.location.path)
+          frame_line = frame.location.lineno - 1
+
+          lines = file_lines.map.with_index do |e, i|
+            if i == frame_line
               "=> #{'%4d' % (i+1)}| #{e}"
             else
               "   #{'%4d' % (i+1)}| #{e}"
             end
-          }
-          min = [0, line - max_lines/2].max
-          max = [min+max_lines, lines.size].min
-          puts "[#{min+1}, #{max}] in #{path}"
-          puts lines[min ... max]
+          end
+
+          unless start_line
+            if frame.show_line
+              if dir > 0
+                start_line = frame.show_line
+              else
+                end_line = frame.show_line - max_lines
+                start_line = [end_line - max_lines, 0].max
+              end
+            else
+              start_line = [frame_line - max_lines/2, 0].max
+            end
+          end
+
+          unless end_line
+            end_line = [start_line + max_lines, lines.size].min
+          end
+
+          if update_line
+            frame.show_line = end_line
+          end
+
+          if start_line != end_line
+            puts "[#{start_line+1}, #{end_line}] in #{path}" unless update_line
+            puts lines[start_line ... end_line]
+          end
+        end
+      end
+    end
+
+    def show_by_editor path = nil
+      unless path
+        if @target_frames && frame = @target_frames[@current_frame_index]
+          path = frame.location.path
+        else
+          return # can't get path
         end
       end
+
+      if File.exist?(path)
+        if editor = (ENV['RUBY_DEBUG_EDITOR'] || ENV['EDITOR'])
+          puts "command: #{editor}"
+          puts "   path: #{path}"
+          system(editor, path)
+        else
+          puts "can not find editor setting: ENV['RUBY_DEBUG_EDITOR'] or ENV['EDITOR']"
+        end
+      else
+        puts "Can not find file: #{path}"
+      end
     end
 
     def show_locals
@@ -176,39 +243,48 @@ module DEBUGGER__
 
     def show_ivars
       if s = current_frame&.self
-        puts " self => #{s}"
-        s.instance_variables.eaach{|iv|
+        s.instance_variables.each{|iv|
           puts " #{iv} => #{s.instance_variable_get(iv)}"
         }
       end
     end
 
-    def frame_eval src, failed_value: nil
+    def frame_eval src, re_raise: false
       begin
+        @success_last_eval = false
+
         b = current_frame.binding
-        if b
-          b.eval(src)
-        else
-          frame_self = current_frame.self
-          frame_self.instance_eval(src)
-          # puts "eval is not supported on this frame."
-        end
+        result = if b
+                   f, l = b.source_location
+                   b.eval(src, "(rdbg)/#{f}")
+                 else
+                   frame_self = current_frame.self
+                   frame_self.instance_eval(src)
+                 end
+        @success_last_eval = true
+        result
+
       rescue Exception => e
-        return failed_value if failed_value
+        return yield(e) if block_given?
+
+        puts "eval error: #{e}"
 
-        puts "Error: #{e}"
         e.backtrace_locations.each do |loc|
           break if loc.path == __FILE__
           puts "  #{loc}"
         end
-        nil
+        raise if re_raise
       end
     end
 
     def parameters_info b, vars
       vars.map{|var|
-        "#{var}=#{short_inspect(b.eval(var.to_s))}"
-      }.join(', ')
+        begin
+          "#{var}=#{short_inspect(b.local_variable_get(var))}"
+        rescue NameError, TypeError
+          nil
+        end
+      }.compact.join(', ')
     end
 
     def klass_sig frame
@@ -246,13 +322,12 @@ module DEBUGGER__
       if b && (iseq = frame.iseq)
         if iseq.type == :block
           if (argc = iseq.argc) > 0
-            args = parameters_info b, iseq.locals[0...iseq.argc]
+            args = parameters_info b, iseq.locals[0...argc]
             buff << " {|#{args}|}"
           end
         else
-          callee = b.eval('__callee__')
-          if callee && (m = frame.self.method(callee))
-            args = parameters_info b, m.parameters.map{|type, v| v}
+          if (callee = b.eval('__callee__', __FILE__, __LINE__)) && (argc = iseq.argc) > 0
+            args = parameters_info b, iseq.locals[0...argc]
             ksig = klass_sig frame
             buff << " #{ksig}#{callee}(#{args})"
           end
@@ -268,30 +343,67 @@ module DEBUGGER__
       buff
     end
 
-    def show_frame_all
-      @target_frames.size.times{|i|
-        puts frame_str(i)
-      }
+    def show_frames max = (@target_frames || []).size
+      if max > 0 && frames = @target_frames
+        size = @target_frames.size
+        max += 1 if size == max + 1
+        max.times{|i|
+          break if i >= size
+          puts frame_str(i)
+        }
+        puts "    # and #{size - max} frames (use `bt' command for all frames)" if max < size
+      end
     end
 
-    def print_frame i
+    def show_frame i=0
       puts frame_str(i)
     end
 
-    def print_frames n
-      size = @target_frames.size
-      ([size, n].min).times{|i|
-        print_frame i
-      }
-      if n < size
-        puts "    # and #{size - n} frames (use `bt' command for all frames)"
+    def show_object_info expr
+      begin
+        result = frame_eval(expr, re_raise: true)
+      rescue Exception
+        # ignore
+      else
+        klass = ObjectSpace.internal_class_of(result)
+        exists = []
+        klass.ancestors.each{|k|
+          puts "= #{k}"
+          if (ms = (k.instance_methods(false) - exists)).size > 0
+            puts ms.sort.join("\t")
+            exists |= ms
+          end
+        }
       end
     end
 
+    def add_breakpoint args
+      case args.first
+      when :method
+        klass_name, op, method_name, cond = args[1..]
+        bp = MethodBreakpoint.new(current_frame.binding, klass_name, op, method_name, cond)
+        begin
+          bp.enable
+        rescue Exception => e
+          puts e.message
+          ::DEBUGGER__::METHOD_ADDED_TRACKER.enable
+        end
+        event! :result, :method_breakpoint, bp
+      else
+        raise "unknown breakpoint: #{args}"
+      end
+    end
+
+    def set_mode mode
+      @mode = mode
+    end
+
     def wait_next_action
-      @mode = :wait_next_action
+      set_mode :wait_next_action
 
       while cmds = @q_cmd.pop
+        # pp [self, cmds: cmds]
+
         cmd, *args = *cmds
 
         case cmd
@@ -303,20 +415,43 @@ module DEBUGGER__
           when :in
             step_tp{true}
           when :next
-            size = @target_frames.size
+            frame = @target_frames.first
+            path = frame.location.absolute_path || "!eval:#{frame.location.path}"
+            line = frame.location.lineno
+            frame.iseq.traceable_lines_norec(lines = {})
+            next_line = lines.keys.bsearch{|e| e > line}
+            if !next_line && (last_line = frame.iseq.last_line) > line
+              next_line = last_line
+            end
+            depth = @target_frames.first.frame_depth
+
             step_tp{
-              target_frames_count() <= size
+              loc = caller_locations(2, 1).first
+              loc_path = loc.absolute_path || "!eval:#{loc.path}"
+
+              (next_line && loc_path == path &&
+                (loc_lineno = loc.lineno) > line && loc_lineno <= next_line) ||
+              (DEBUGGER__.frame_depth - 3 < depth)
             }
           when :finish
-            size = @target_frames.size
-            step_tp{target_frames_count() < size}
+            depth = @target_frames.first.frame_depth
+            step_tp{
+              # 3 is debugger's frame count
+              DEBUGGER__.frame_depth - 3 < depth
+            }
           else
             raise
           end
           break
         when :eval
           eval_type, eval_src = *args
-          result = frame_eval(eval_src)
+
+          case eval_type
+          when :display, :try_display
+          else
+            result = frame_eval(eval_src)
+          end
+          result_type = nil
 
           case eval_type
           when :p
@@ -327,15 +462,31 @@ module DEBUGGER__
             puts out
           when :call
             result = frame_eval(eval_src)
-          when :display
+          when :display, :try_display
+            failed_results = []
             eval_src.each_with_index{|src, i|
-              puts "#{i}: #{src} = #{frame_eval(src, failed_value: :error).inspect}"
+              result = frame_eval(src){|e|
+                failed_results << [i, e.message]
+                "<error: #{e.message}>"
+              }
+              puts "#{i}: #{src} = #{result}"
             }
-            result = :ok
+
+            result_type = eval_type
+            result = failed_results
+          when :watch
+            if @success_last_eval
+              puts "#{eval_src} = #{result}"
+              result = WatchExprBreakpoint.new(eval_src, result)
+              result_type = :watch
+            else
+              result = nil
+            end
           else
-            raise "unknown error option: #{args.inspec}"
+            raise "unknown error option: #{args.inspect}"
           end
-          event! :result, result
+
+          event! :result, result_type, result
         when :frame
           type, arg = *args
           case type
@@ -343,13 +494,13 @@ module DEBUGGER__
             if @current_frame_index + 1 < @target_frames.size
               @current_frame_index += 1 
               show_src max_lines: 1
-              print_frame(@current_frame_index)
+              show_frame(@current_frame_index)
             end
           when :down
             if @current_frame_index > 0
               @current_frame_index -= 1
               show_src max_lines: 1
-              print_frame(@current_frame_index)
+              show_frame(@current_frame_index)
             end
           when :set
             if arg
@@ -361,28 +512,43 @@ module DEBUGGER__
               end
             end
             show_src max_lines: 1
-            print_frame(@current_frame_index)
+            show_frame(@current_frame_index)
           else
             raise "unsupported frame operation: #{arg.inspect}"
           end
           event! :result, nil
         when :show
-          type, = *args
+          type = args.shift
+
           case type
           when :backtrace
-            show_frame_all
+            show_frames
+
           when :list
-            show_src
-          when :locals
+            show_src(update_line: true, **(args.first || {}))
+
+          when :edit
+            show_by_editor(args.first)
+
+          when :local
+            show_frame
             show_locals
-          when :ivars
             show_ivars
+
+          when :object_info
+            expr = args.shift
+            show_object_info expr
+
           else
-            raise "unknown show param: " + args.inspect
+            raise "unknown show param: " + [type, *args].inspect
           end
+
           event! :result, nil
+
+        when :breakpoint
+          add_breakpoint args
         else
-          raise [ev, *args].inspect
+          raise [cmd, *args].inspect
         end
       end
 
@@ -392,11 +558,20 @@ module DEBUGGER__
       pp [__FILE__, __LINE__, e, e.backtrace]
       raise
     ensure
-      @mode = nil
+      set_mode nil
     end
 
     def to_s
-      "(#{@thread.name || @thread.status})@#{current_frame&.location}"
+      loc = current_frame&.location
+
+      if loc
+        str = "(#{@thread.name || @thread.status})@#{loc}"
+      else
+        str = "(#{@thread.name || @thread.status})@#{@thread.to_s}"
+      end
+
+      str += " (not under control)" unless self.mode
+      str
     end
   end
 end