debug 1.0.0.beta2 → 1.0.0.beta7

data/lib/debug/console.rb

@@ -1,14 +1,38 @@
+# frozen_string_literal: true
+
 require_relative 'session'
+return unless defined?(DEBUGGER__)
+
+require 'io/console/size'
 
 module DEBUGGER__
-  class UI_Console
+  class UI_Console < UI_Base
     def initialize
+      unless CONFIG[:no_sigint_hook]
+        @prev_handler = trap(:SIGINT){
+          ThreadClient.current.on_trap :SIGINT
+        }
+      end
+    end
+
+    def close
+      if @prev_handler
+        trap(:SIGINT, @prev_handler)
+      end
     end
 
     def remote?
       false
     end
 
+    def width
+      if (w = IO.console_size[1]) == 0 # for tests PTY
+        80
+      else
+        w
+      end
+    end
+
     def quit n
       exit n
     end
@@ -16,7 +40,7 @@ module DEBUGGER__
     def ask prompt
       setup_interrupt do
         print prompt
-        (gets || '').strip
+        ($stdin.gets || '').strip
       end
     end
 

data/lib/debug/frame_info.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module DEBUGGER__
+  FrameInfo = Struct.new(:location, :self, :binding, :iseq, :class, :frame_depth,
+                          :has_return_value, :return_value,
+                          :has_raised_exception, :raised_exception,
+                          :show_line)
+
+  # extend FrameInfo with debug.so
+  if File.exist? File.join(__dir__, 'debug.so')
+    require_relative 'debug.so'
+  else
+    require_relative 'debug'
+  end
+
+  class FrameInfo
+    HOME = ENV['HOME'] ? (ENV['HOME'] + '/') : nil
+
+    def path
+      location.path
+    end
+
+    def realpath
+      location.absolute_path
+    end
+
+    def pretty_path
+      use_short_path = ::DEBUGGER__::CONFIG[:use_short_path]
+
+      case
+      when use_short_path && path.start_with?(dir = ::DEBUGGER__::CONFIG["rubylibdir"] + '/')
+        path.sub(dir, '$(rubylibdir)/')
+      when use_short_path && Gem.path.any? do |gp|
+          path.start_with?(dir = gp + '/gems/')
+        end
+        path.sub(dir, '$(Gem)/')
+      when HOME && path.start_with?(HOME)
+        path.sub(HOME, '~/')
+      else
+        path
+      end
+    end
+
+    def name
+      # p frame_type: frame_type, self: self
+      case frame_type
+      when :block
+        level, block_loc, _args = block_identifier
+        "block in #{block_loc}#{level}"
+      when :method
+        ci, _args = method_identifier
+        "#{ci}"
+      when :c
+        c_identifier
+      when :other
+        other_identifier
+      end
+    end
+
+    def file_lines
+      SESSION.source(self.iseq)
+    end
+
+    def frame_type
+      if binding && iseq
+        if iseq.type == :block
+          :block
+        elsif callee
+          :method
+        else
+          :other
+        end
+      else
+        :c
+      end
+    end
+
+    BLOCK_LABL_REGEXP = /\Ablock( \(\d+ levels\))* in (.+)\z/
+
+    def block_identifier
+      return unless frame_type == :block
+      args = parameters_info(iseq.argc)
+      _, level, block_loc = location.label.match(BLOCK_LABL_REGEXP).to_a
+      [level || "", block_loc, args]
+    end
+
+    def method_identifier
+      return unless frame_type == :method
+      args = parameters_info(iseq.argc)
+      ci = "#{klass_sig}#{callee}"
+      [ci, args]
+    end
+
+    def c_identifier
+      return unless frame_type == :c
+      "[C] #{klass_sig}#{location.base_label}"
+    end
+
+    def other_identifier
+      return unless frame_type == :other
+      location.label
+    end
+
+    def callee
+      @callee ||= binding&.eval('__callee__', __FILE__, __LINE__)
+    end
+
+    def return_str
+      if binding && iseq && has_return_value
+        DEBUGGER__.short_inspect(return_value)
+      end
+    end
+
+    def location_str
+      "#{pretty_path}:#{location.lineno}"
+    end
+
+    private
+
+    def get_singleton_class obj
+      obj.singleton_class # TODO: don't use it
+    rescue TypeError
+      nil
+    end
+
+    def parameters_info(argc)
+      vars = iseq.locals[0...argc]
+      vars.map{|var|
+        begin
+          { name: var, value: DEBUGGER__.short_inspect(binding.local_variable_get(var)) }
+        rescue NameError, TypeError
+          nil
+        end
+      }.compact
+    end
+
+    def klass_sig
+      if self.class == get_singleton_class(self.self)
+        "#{self.self}."
+      else
+        "#{self.class}#"
+      end
+    end
+  end
+end

data/lib/debug/open.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 #
 # Open the door for the debugger to connect.
 # Users can connect to debuggee program with "rdbg --attach" option.
@@ -7,4 +8,6 @@
 #
 
 require_relative 'server'
+return unless defined?(DEBUGGER__)
+
 DEBUGGER__.open

data/lib/debug/run.rb

@@ -1,2 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'console'
-DEBUGGER__.console
+return unless defined?(DEBUGGER__)
+DEBUGGER__.start

data/lib/debug/server.rb

@@ -1,24 +1,36 @@
+# frozen_string_literal: true
+
 require 'socket'
+
 require_relative 'session'
+return unless defined?(DEBUGGER__)
+
 require_relative 'config'
+require_relative 'version'
 
 module DEBUGGER__
-  class UI_ServerBase
+  class UI_ServerBase < UI_Base
     def initialize
       @sock = nil
       @accept_m = Mutex.new
       @accept_cv = ConditionVariable.new
       @client_addr = nil
-      @q_msg = Queue.new
-      @q_ans = Queue.new
+      @q_msg = nil
+      @q_ans = nil
       @unsent_messages = []
+      @width = 80
 
       @reader_thread = Thread.new do
+        # An error on this thread should break the system.
+        Thread.current.abort_on_exception = true
+
         accept do |server|
-          DEBUGGER__.message "Connected."
+          DEBUGGER__.warn "Connected."
 
           @accept_m.synchronize{
             @sock = server
+            greeting
+
             @accept_cv.signal
 
             # flush unsent messages
@@ -26,32 +38,71 @@ module DEBUGGER__
               @sock.puts m
             }
             @unsent_messages.clear
+
+            @q_msg = Queue.new
+            @q_ans = Queue.new
           }
-          @q_msg = Queue.new
-          @q_ans = Queue.new
 
           setup_interrupt do
-            pause
-
-            while line = @sock.gets
-              case line
-              when /\Apause/
-                pause
-              when /\Acommand ?(.+)/
-                @q_msg << $1
-              when /\Aanswer (.*)/
-                @q_ans << $1
-              else
-                STDERR.puts "unsupported: #{line}"
-                exit!
-              end
-            end
+            process
           end
+
+        rescue => e
+          DEBUGGER__.warn "ReaderThreadError: #{e}", :error
         ensure
-          DEBUGGER__.message "Disconnected."
+          DEBUGGER__.warn "Disconnected."
           @sock = nil
           @q_msg.close
+          @q_msg = nil
           @q_ans.close
+          @q_ans = nil
+        end
+      end
+    end
+
+    def greeting
+      case g = @sock.gets
+      when /^version:\s+(.+)\s+width: (\d+) cookie:\s+(.*)$/
+        v, w, c = $1, $2, $3
+        # TODO: protocol version
+        if v != VERSION
+          raise "Incompatible version (#{VERSION} client:#{$1})"
+        end
+
+        cookie = CONFIG[:cookie]
+        if cookie && cookie != c
+          raise "Cookie mismatch (#{$2.inspect} was sent)"
+        end
+
+        @width = w.to_i
+
+      when /^Content-Length: (\d+)/
+        require_relative 'server_dap'
+
+        raise unless @sock.read(2) == "\r\n"
+        self.extend(UI_DAP)
+        dap_setup @sock.read($1.to_i)
+      else
+        raise "Greeting message error: #{g}"
+      end
+    end
+
+    def process
+      pause
+
+      while line = @sock.gets
+        case line
+        when /\Apause/
+          pause
+        when /\Acommand ?(.+)/
+          @q_msg << $1
+        when /\Aanswer (.*)/
+          @q_ans << $1
+        when /\Awidth (.+)/
+          @width = $1.to_i
+        else
+          STDERR.puts "unsupported: #{line}"
+          exit!
         end
       end
     end
@@ -60,6 +111,10 @@ module DEBUGGER__
       true
     end
 
+    def width
+      @width
+    end
+
     def setup_interrupt
       prev_handler = trap(:SIGINT) do
         # $stderr.puts "trapped SIGINT"
@@ -90,12 +145,20 @@ module DEBUGGER__
       if s = @sock         # already connection
         # ok
       elsif skip == true   # skip process
-        return yield nil
+        no_sock = true
+        r = @accept_m.synchronize do
+          if @sock
+            no_sock = false
+          else
+            yield nil
+          end
+        end
+        return r if no_sock
       else                 # wait for connection
         until s = @sock
           @accept_m.synchronize{
             unless @sock
-              DEBUGGER__.message "wait for debuger connection..."
+              DEBUGGER__.warn "wait for debuger connection..."
               @accept_cv.wait(@accept_m)
             end
           }
@@ -139,6 +202,7 @@ module DEBUGGER__
     def readline
       (sock do |s|
         s.puts "input"
+        sleep 0.01 until @q_msg
         @q_msg.pop
       end || 'continue').strip
     end
@@ -158,7 +222,7 @@ module DEBUGGER__
 
   class UI_TcpServer < UI_ServerBase
     def initialize host: nil, port: nil
-      @host = host || ::DEBUGGER__::CONFIG[:host] || 'localhost'
+      @host = host || ::DEBUGGER__::CONFIG[:host] || '127.0.0.1'
       @port = port || begin
         port_str = ::DEBUGGER__::CONFIG[:port] || raise("Specify listening port by RUBY_DEBUG_PORT environment variable.")
         if /\A\d+\z/ !~ port_str
@@ -173,7 +237,7 @@ module DEBUGGER__
 
     def accept
       Socket.tcp_server_sockets @host, @port do |socks|
-        ::DEBUGGER__.message "Debugger can attach via TCP/IP (#{socks.map{|e| e.local_address.inspect}})"
+        ::DEBUGGER__.warn "Debugger can attach via TCP/IP (#{socks.map{|e| e.local_address.inspect}})"
         Socket.accept_loop(socks) do |sock, client|
           @client_addr = client
           yield sock
@@ -187,40 +251,29 @@ module DEBUGGER__
   end
 
   class UI_UnixDomainServer < UI_ServerBase
-    def initialize sock_dir: nil
+    def initialize sock_dir: nil, sock_path: nil
+      @sock_path = sock_path
       @sock_dir = sock_dir || DEBUGGER__.unix_domain_socket_dir
 
       super()
     end
 
     def accept
-      @file = DEBUGGER__.create_unix_domain_socket_name(@sock_dir)
+      case
+      when @sock_path
+      when sp = ::DEBUGGER__::CONFIG[:sock_path]
+        @sock_path = sp
+      else
+        @sock_path = DEBUGGER__.create_unix_domain_socket_name(@sock_dir)
+      end
 
-      ::DEBUGGER__.message "Debugger can attach via UNIX domain socket (#{@file})"
-      Socket.unix_server_loop @file do |sock, client|
+      ::DEBUGGER__.warn "Debugger can attach via UNIX domain socket (#{@sock_path})"
+      Socket.unix_server_loop @sock_path do |sock, client|
         @client_addr = client
         yield sock
+      ensure
+        sock.close
       end
     end
   end
-
-  def self.open host: nil, port: ::DEBUGGER__::CONFIG[:port], sock_dir: nil
-    if port
-      open_tcp host: host, port: port
-    else
-      open_unix sock_dir: sock_dir
-    end
-  end
-
-  def self.open_tcp(host: nil, port:)
-    initialize_session UI_TcpServer.new(host: host, port: port)
-  end
-
-  def self.open_unix sock_dir: nil
-    initialize_session UI_UnixDomainServer.new(sock_dir: sock_dir)
-  end
-
-  def self.message msg
-    $stderr.puts "DEBUGGER: #{msg}"
-  end
 end