debug 1.0.0.beta2 → 1.0.0.beta7

data/lib/debug/session.rb

@@ -1,15 +1,14 @@
-module DEBUGGER__
-  # used in thread_client.c
-  FrameInfo = Struct.new(:location, :self, :binding, :iseq, :class, :frame_depth,
-                         :has_return_value, :return_value, :show_line)
-end
+# frozen_string_literal: true
 
-require "debug/debug"
+# skip to load debugger for bundle exec
+return if $0.end_with?('bin/bundle') && ARGV.first == 'exec'
 
+require_relative 'config'
+require_relative 'thread_client'
 require_relative 'source_repository'
 require_relative 'breakpoint'
-require_relative 'thread_client'
-require_relative 'config'
+
+require 'json' if ENV['RUBY_DEBUG_TEST_MODE']
 
 class RubyVM::InstructionSequence
   def traceable_lines_norec lines
@@ -47,9 +46,15 @@ class RubyVM::InstructionSequence
   def last_line
     self.to_a[4][:code_location][2]
   end
+
+  def first_line
+    self.to_a[4][:code_location][0]
+  end
 end
 
 module DEBUGGER__
+  PresetCommand = Struct.new(:commands, :source, :auto_continue)
+
   class Session
     def initialize ui
       @ui = ui
@@ -57,103 +62,149 @@ module DEBUGGER__
       @bps = {} # bp.key => bp
                 #   [file, line] => LineBreakpoint
                 #   "Error" => CatchBreakpoint
-                #   Method => MethodBreakpoint
-                #   [:watch, expr] => WatchExprBreakpoint
+                #   "Foo#bar" => MethodBreakpoint
+                #   [:watch, ivar] => WatchIVarBreakpoint
                 #   [:check, expr] => CheckBreakpoint
       @th_clients = {} # {Thread => ThreadClient}
       @q_evt = Queue.new
       @displays = []
       @tc = nil
       @tc_id = 0
-      @initial_commands = []
+      @preset_command = nil
+
+      @frame_map = {} # {id => [threadId, frame_depth]} for DAP
+      @var_map   = {1 => [:globals], } # {id => ...} for DAP
+      @src_map   = {} # {id => src}
 
       @tp_load_script = TracePoint.new(:script_compiled){|tp|
-        ThreadClient.current.on_load tp.instruction_sequence, tp.eval_script
-      }.enable
+        unless @management_threads.include? Thread.current
+          ThreadClient.current.on_load tp.instruction_sequence, tp.eval_script
+        end
+      }
+      @tp_load_script.enable
 
       @session_server = Thread.new do
         Thread.current.abort_on_exception = true
+        session_server_main
+      end
 
-        while evt = @q_evt.pop
-          tc, output, ev, *ev_args = evt
-          output.each{|str| @ui.puts str}
-
-          case ev
-          when :load
-            iseq, src = ev_args
-            on_load iseq, src
-            tc << :continue
-          when :thread_begin
-            th = ev_args.shift
-            on_thread_begin th
-            tc << :continue
-          when :suspend
-            case ev_args.first
-            when :breakpoint
-              bp, i = bp_index ev_args[1]
-              if bp
-                @ui.puts "\nStop by \##{i} #{bp}"
-              end
-            when :trap
-              @ui.puts ''
-              @ui.puts "\nStop by #{ev_args[1]}"
-            end
+      @management_threads = [@session_server]
+      @management_threads << @ui.reader_thread if @ui.respond_to? :reader_thread
 
-            if @displays.empty?
-              wait_command_loop tc
-            else
-              tc << [:eval, :display, @displays]
+      setup_threads
+
+      @tp_thread_begin = TracePoint.new(:thread_begin){|tp|
+        unless @management_threads.include?(th = Thread.current)
+          ThreadClient.current.on_thread_begin th
+        end
+      }
+      @tp_thread_begin.enable
+    end
+
+    def active?
+      @ui ? true : false
+    end
+
+    def reset_ui ui
+      @ui.close
+      @ui = ui
+      @management_threads << @ui.reader_thread if @ui.respond_to? :reader_thread
+    end
+
+    def session_server_main
+      while evt = @q_evt.pop
+        # varible `@internal_info` is only used for test
+        tc, output, ev, @internal_info, *ev_args = evt
+        output.each{|str| @ui.puts str}
+
+        case ev
+        when :init
+          wait_command_loop tc
+        when :load
+          iseq, src = ev_args
+          on_load iseq, src
+          @ui.event :load
+          tc << :continue
+        when :thread_begin
+          th = ev_args.shift
+          on_thread_begin th
+          @ui.event :thread_begin, th
+          tc << :continue
+        when :suspend
+          case ev_args.first
+          when :breakpoint
+            bp, i = bp_index ev_args[1]
+            @ui.event :suspend_bp, i, bp
+          when :trap
+            @ui.event :suspend_trap, ev_args[1]
+          else
+            @ui.event :suspended
+          end
+
+          if @displays.empty?
+            wait_command_loop tc
+          else
+            tc << [:eval, :display, @displays]
+          end
+        when :result
+          case ev_args.first
+          when :try_display
+            failed_results = ev_args[1]
+            if failed_results.size > 0
+              i, _msg = failed_results.last
+              if i+1 == @displays.size
+                @ui.puts "canceled: #{@displays.pop}"
+              end
             end
-          when :result
-            case ev_args.first
-            when :watch
-              bp = ev_args[1]
-              @bps[bp.key] = bp
+          when :method_breakpoint, :watch_breakpoint
+            bp = ev_args[1]
+            if bp
+              add_breakpoint(bp)
               show_bps bp
-            when :try_display
-              failed_results = ev_args[1]
-              if failed_results.size > 0
-                i, msg = failed_results.last
-                if i+1 == @displays.size
-                  @ui.puts "canceled: #{@displays.pop}"
-                end
-              end
-            when :method_breakpoint
-              bp = ev_args[1]
-              if bp
-                @bps[bp.key] = bp
-                show_bps bp
-              else
-                # can't make a bp
-              end
             else
-              # ignore
+              # can't make a bp
             end
-
-            wait_command_loop tc
+          else
+            # ignore
           end
-        end
-      end
 
-      @management_threads = [@session_server]
-      @management_threads << @ui.reader_thread if @ui.respond_to? :reader_thread
+          wait_command_loop tc
 
-      setup_threads
-
-      @tp_thread_begin = TracePoint.new(:thread_begin){|tp|
-        ThreadClient.current.on_thread_begin Thread.current
-      }.enable
+        when :dap_result
+          dap_event ev_args # server.rb
+          wait_command_loop tc
+        end
+      end
+    ensure
+      @tp_load_script.disable
+      @tp_thread_begin.disable
+      @bps.each{|k, bp| bp.disable}
+      @th_clients.each{|th, thc| thc.close}
+      @ui = nil
     end
 
-    def add_initial_commands cmds
-      cmds.each{|c|
-        c.gsub('#.*', '').strip!
-        @initial_commands << c unless c.empty?
-      }
+    def add_preset_commands name, cmds, kick: true, continue: true
+      cs = cmds.map{|c|
+        c = c.strip.gsub(/\A\s*\#.*/, '').strip
+        c unless c.empty?
+      }.compact
+
+      unless cs.empty?
+        if @preset_command
+          @preset_command.commands += cs
+        else
+          @preset_command = PresetCommand.new(cs, name, continue)
+        end
+        ThreadClient.current.on_init name if kick
+      end
     end
 
-    def source path
-      @sr.get(path)
+    def source iseq
+      if !CONFIG[:no_color]
+        @sr.get_colored(iseq)
+      else
+        @sr.get(iseq)
+      end
     end
 
     def inspect
@@ -179,13 +230,36 @@ module DEBUGGER__
     end
 
     def wait_command
-      if @initial_commands.empty?
+      if @preset_command
+        if @preset_command.commands.empty?
+          if @preset_command.auto_continue
+            @preset_command = nil
+            @tc << :continue
+            return
+          else
+            @preset_command = nil
+            return :retry
+          end
+        else
+          line = @preset_command.commands.shift
+          @ui.puts "(rdbg:#{@preset_command.source}) #{line}"
+        end
+      else
+        @ui.puts "INTERNAL_INFO: #{JSON.generate(@internal_info)}" if ENV['RUBY_DEBUG_TEST_MODE']
         line = @ui.readline
+      end
+
+      case line
+      when String
+        process_command line
+      when Hash
+        process_dap_request line # defined in server.rb
       else
-        line = @initial_commands.shift.strip
-        @ui.puts "(rdbg:init) #{line}"
+        raise "unexpected input: #{line.inspect}"
       end
+    end
 
+    def process_command line
       if line.empty?
         if @repl_prev_line
           line = @repl_prev_line
@@ -207,26 +281,30 @@ module DEBUGGER__
       # * `s[tep]`
       #   * Step in. Resume the program until next breakable point.
       when 's', 'step'
+        cancel_auto_continue
         @tc << [:step, :in]
 
       # * `n[ext]`
       #   * Step over. Resume the program until next line.
       when 'n', 'next'
+        cancel_auto_continue
         @tc << [:step, :next]
 
       # * `fin[ish]`
       #   * Finish this frame. Resume the program until the current frame is finished.
       when 'fin', 'finish'
+        cancel_auto_continue
         @tc << [:step, :finish]
 
       # * `c[ontinue]`
       #   * Resume the program.
       when 'c', 'continue'
+        cancel_auto_continue
         @tc << :continue
 
-      # * `q[uit]` or exit or `Ctrl-D`
+      # * `q[uit]` or `Ctrl-D`
       #   * Finish debugger (with the debuggee process on non-remote debugging).
-      when 'q', 'quit', 'exit'
+      when 'q', 'quit'
         if ask 'Really quit?'
           @ui.quit arg.to_i
           @tc << :continue
@@ -234,15 +312,26 @@ module DEBUGGER__
           return :retry
         end
 
-      # * `kill` or `q[uit]!`
-      #   * Stop the debuggee process.
-      when 'kill', 'quit!', 'q!'
+      # * `q[uit]!`
+      #   * Same as q[uit] but without the confirmation prompt.
+      when 'q!', 'quit!'
+        @ui.quit arg.to_i
+        @tc << :continue
+
+      # * `kill`
+      #   * Stop the debuggee process with `Kernal#exit!`.
+      when 'kill'
         if ask 'Really kill?'
           exit! (arg || 1).to_i
         else
           return :retry
         end
 
+      # * `kill!`
+      #   * Same as kill but without the confirmation prompt.
+      when 'kill!'
+        exit! (arg || 1).to_i
+
       ### Breakpoint
 
       # * `b[reak]`
@@ -255,10 +344,14 @@ module DEBUGGER__
       #    * Set breakpoint on the method `<class>#<name>`.
       # * `b[reak] <expr>.<name>`
       #    * Set breakpoint on the method `<expr>.<name>`.
-      # * `b[reak] ... if <expr>`
+      # * `b[reak] ... if: <expr>`
       #   * break if `<expr>` is true at specified location.
-      # * `b[reak] if <expr>`
-      #   * break if `<expr>` is true at any lines.
+      # * `b[reak] ... pre: <command>`
+      #   * break and run `<command>` before stopping.
+      # * `b[reak] ... do: <command>`
+      #   * break and run `<command>`, and continue.
+      # * `b[reak] if: <expr>`
+      #   * break if: `<expr>` is true at any lines.
       #   * Note that this feature is super slow.
       when 'b', 'break'
         if arg == nil
@@ -311,12 +404,12 @@ module DEBUGGER__
         end
         return :retry
 
-      # * `watch <expr>`
-      #   * Stop the execution when the result of <expr> is changed.
+      # * `watch @ivar`
+      #   * Stop the execution when the result of current scope's `@ivar` is changed.
       #   * Note that this feature is super slow.
       when 'wat', 'watch'
-        if arg
-          @tc << [:eval, :watch, arg]
+        if arg && arg.match?(/\A@\w+/)
+          @tc << [:breakpoint, :watch, arg]
         else
           show_bps
           return :retry
@@ -346,8 +439,25 @@ module DEBUGGER__
 
       # * `bt` or `backtrace`
       #   * Show backtrace (frame) information.
+      # * `bt <num>` or `backtrace <num>`
+      #   * Only shows first `<num>` frames.
+      # * `bt /regexp/` or `backtrace /regexp/`
+      #   * Only shows frames with method name or location info that matches `/regexp/`.
+      # * `bt <num> /regexp/` or `backtrace <num> /regexp/`
+      #   * Only shows first `<num>` frames with method name or location info that matches `/regexp/`.
       when 'bt', 'backtrace'
-        @tc << [:show, :backtrace]
+        case arg
+        when /\A(\d+)\z/
+          @tc << [:show, :backtrace, arg.to_i, nil]
+        when /\A\/(.*)\/\z/
+          pattern = $1
+          @tc << [:show, :backtrace, nil, Regexp.compile(pattern)]
+        when /\A(\d+)\s+\/(.*)\/\z/
+          max, pattern = $1, $2
+          @tc << [:show, :backtrace, max.to_i, Regexp.compile(pattern)]
+        else
+          @tc << [:show, :backtrace, nil, nil]
+        end
 
       # * `l[ist]`
       #   * Show current frame's source code.
@@ -391,17 +501,23 @@ module DEBUGGER__
 
         @tc << [:show, :edit, arg]
 
-      # * `i[nfo]`
+      # * `i[nfo]`, `i[nfo] l[ocal[s]]`
       #   * Show information about the current frame (local variables)
       #   * It includes `self` as `%self` and a return value as `%return`.
-      # * `i[nfo] <expr>`
-      #   * Show information about the result of <expr>.
+      # * `i[nfo] th[read[s]]`
+      #   * Show all threads (same as `th[read]`).
       when 'i', 'info'
         case arg
         when nil
           @tc << [:show, :local]
+        when 'l', /locals?/
+          @tc << [:show, :local]
+        when 'th', /threads?/
+          thread_list
+          return :retry
         else
-          @tc << [:show, :object_info, arg]
+          show_help 'info'
+          return :retry
         end
 
       # * `display`
@@ -410,7 +526,7 @@ module DEBUGGER__
       #   * Show the result of `<expr>` at every suspended timing.
       when 'display'
         if arg && !arg.empty?
-          @displays << arg 
+          @displays << arg
           @tc << [:eval, :try_display, @displays]
         else
           @tc << [:eval, :display, @displays]
@@ -424,9 +540,7 @@ module DEBUGGER__
         case arg
         when /(\d+)/
           if @displays[n = $1.to_i]
-            if ask "clear \##{n} #{@displays[n]}?"
-              @displays.delete_at n
-            end
+            @displays.delete_at n
           end
           @tc << [:eval, :display, @displays]
         when nil
@@ -442,9 +556,11 @@ module DEBUGGER__
         case arg
         when 'on'
           dir = __dir__
-          @tracer ||= TracePoint.new(){|tp|
+          @tracer ||= TracePoint.new(:call, :return, :b_call, :b_return, :line, :class, :end){|tp|
             next if File.dirname(tp.path) == dir
             next if tp.path == '<internal:trace_point>'
+            # Skip when `JSON.generate` is called during tests
+            next if tp.binding.eval('self').to_s == 'JSON' and ENV['RUBY_DEBUG_TEST_MODE']
             # next if tp.event != :line
             @ui.puts pretty_tp(tp)
           }
@@ -459,19 +575,19 @@ module DEBUGGER__
       ### Frame control
 
       # * `f[rame]`
-      #   * Show current frame.
+      #   * Show the current frame.
       # * `f[rame] <framenum>`
-      #   * Specify frame. Evaluation are run on this frame environment.
+      #   * Specify a current frame. Evaluation are run on specified frame.
       when 'frame', 'f'
         @tc << [:frame, :set, arg]
 
       # * `up`
-      #   * Specify upper frame.
+      #   * Specify the upper frame.
       when 'up'
         @tc << [:frame, :up]
 
       # * `down`
-      #   * Specify down frame.
+      #   * Specify the lower frame.
       when 'down'
         @tc << [:frame, :down]
 
@@ -501,6 +617,9 @@ module DEBUGGER__
         end
         @tc << [:eval, :call, 'binding.irb']
 
+        # don't repeat irb command
+        @repl_prev_line = nil
+
       ### Thread control
 
       # * `th[read]`
@@ -518,6 +637,21 @@ module DEBUGGER__
         end
         return :retry
 
+      ### Configuration
+      # * `config`
+      #   * Show all configuration with description.
+      # * `config <name>`
+      #   * Show current configuration of <name>.
+      # * `config set <name> <val>` or `config <name> = <val>`
+      #   * Set <name> to <val>.
+      # * `config append <name> <val>` or `config <name> << <val>`
+      #   * Append `<val>` to `<name>` if it is an array.
+      # * `config unset <name>`
+      #   * Set <name> to default.
+      when 'config'
+        config_command arg
+        return :retry
+
       ### Help
 
       # * `h[elp]`
@@ -549,6 +683,79 @@ module DEBUGGER__
       return :retry
     end
 
+    def config_show key
+      key = key.to_sym
+      if CONFIG_SET[key]
+        v = CONFIG[key]
+        kv = "#{key} = #{v.nil? ? '(default)' : v.inspect}"
+        desc = CONFIG_SET[key][1]
+        line = "%-30s \# %s" % [kv, desc]
+        if line.size > SESSION.width
+          @ui.puts "\# #{desc}\n#{kv}"
+        else
+          @ui.puts line
+        end
+      else
+        @ui.puts "Unknown configuration: #{key}. 'config' shows all configurations."
+      end
+    end
+
+    def config_set key, val, append: false
+      if CONFIG_SET[key = key.to_sym]
+        begin
+          if append
+            DEBUGGER__.append_config(key, val)
+          else
+            DEBUGGER__.set_config({key => val})
+          end
+        rescue => e
+          @ui.puts e.message
+        end
+      end
+
+      config_show key
+    end
+
+    def config_command arg
+      case arg
+      when nil
+        CONFIG_SET.each do |k, _|
+          config_show k
+        end
+
+      when /\Aunset\s+(.+)\z/
+        if CONFIG_SET[key = $1.to_sym]
+          DEBUGGER__.set_config({key => nil})
+        end
+        config_show key
+
+      when /\A(\w+)\s*=\s*(.+)\z/
+        config_set $1, $2
+
+      when /\A\s*set\s+(\w+)\s+(.+)\z/
+        config_set $1, $2
+
+      when /\A(\w+)\s*<<\s*(.+)\z/
+        config_set $1, $2, append: true
+
+      when /\A\s*append\s+(\w+)\s+(.+)\z/
+        config_set $1, $2
+
+      when /\A(\w+)\z/
+        config_show $1
+
+      else
+        @ui.puts "Can not parse parameters: #{arg}"
+      end
+    end
+
+
+    def cancel_auto_continue
+      if @preset_command&.auto_continue
+        @preset_command.auto_continue = false
+      end
+    end
+
     def show_help arg
       DEBUGGER__.helps.each{|cat, cs|
         cs.each{|ws, desc|
@@ -665,29 +872,37 @@ module DEBUGGER__
       end
     end
 
-    def repl_add_breakpoint arg
-      arg.strip!
+    BREAK_KEYWORDS = %w(if: do: pre:).freeze
 
-      case arg
-      when /\Aif\s+(.+)\z/
-        cond = $1
-      when /(.+?)\s+if\s+(.+)\z/
-        sig = $1
-        cond = $2
-      else
-        sig = arg
-      end
+    def parse_break arg
+      mode = :sig
+      expr = Hash.new{|h, k| h[k] = []}
+      arg.split(' ').each{|w|
+        if BREAK_KEYWORDS.any?{|pat| w == pat}
+          mode = w[0..-2].to_sym
+        else
+          expr[mode] << w
+        end
+      }
+      expr.default_proc = nil
+      expr.transform_values{|v| v.join(' ')}
+    end
+
+    def repl_add_breakpoint arg
+      expr = parse_break arg.strip
+      cond = expr[:if]
+      cmd = ['break', expr[:pre], expr[:do]] if expr[:pre] || expr[:do]
 
-      case sig
+      case expr[:sig]
       when /\A(\d+)\z/
-        add_line_breakpoint @tc.location.path, $1.to_i, cond: cond
+        add_line_breakpoint @tc.location.path, $1.to_i, cond: expr[:if], command: cmd
       when /\A(.+)[:\s+](\d+)\z/
-        add_line_breakpoint $1, $2.to_i, cond: cond
+        add_line_breakpoint $1, $2.to_i, cond: expr[:if], command: cmd
       when /\A(.+)([\.\#])(.+)\z/
-        @tc << [:breakpoint, :method, $1, $2, $3, cond]
+        @tc << [:breakpoint, :method, $1, $2, $3, expr[:if], cmd]
         return :noretry
       when nil
-        add_check_breakpoint cond
+        add_check_breakpoint expr[:if]
       else
         @ui.puts "Unknown breakpoint format: #{arg}"
         @ui.puts
@@ -706,6 +921,8 @@ module DEBUGGER__
         case
         when th == Thread.current
           # ignore
+        when @management_threads.include?(th)
+          # ignore
         when @th_clients.has_key?(th)
           thcs << @th_clients[th]
         else
@@ -729,8 +946,13 @@ module DEBUGGER__
       end
     end
 
+    def managed_thread_clients
+      thcs, _unmanaged_ths = update_thread_list
+      thcs
+    end
+
     def thread_switch n
-      thcs, unmanaged_ths = update_thread_list
+      thcs, _unmanaged_ths = update_thread_list
 
       if tc = thcs[n]
         if tc.mode
@@ -801,9 +1023,10 @@ module DEBUGGER__
       end
     end
 
-    ## event 
+    ## event
 
     def on_load iseq, src
+      DEBUGGER__.info "Load #{iseq.absolute_path || iseq.path}"
       @sr.add iseq, src
 
       pending_line_breakpoints do |bp|
@@ -816,8 +1039,14 @@ module DEBUGGER__
     # breakpoint management
 
     def add_breakpoint bp
+      # don't repeat commands that add breakpoints
+      @repl_prev_line = nil
+
       if @bps.has_key? bp.key
-        @ui.puts "duplicated breakpoint: #{bp}"
+        unless bp.duplicable?
+          @ui.puts "duplicated breakpoint: #{bp}"
+          bp.disable
+        end
       else
         @bps[bp.key] = bp
       end
@@ -837,7 +1066,7 @@ module DEBUGGER__
 
     def add_catch_breakpoint arg
       bp = CatchBreakpoint.new(arg)
-      add_braekpoint bp
+      add_breakpoint bp
     end
 
     def add_check_breakpoint expr
@@ -848,13 +1077,25 @@ module DEBUGGER__
     def resolve_path file
       File.realpath(File.expand_path(file))
     rescue Errno::ENOENT
-      return file if file == '-e'
+      case file
+      when '-e', '-'
+        return file
+      else
+        $LOAD_PATH.each do |lp|
+          libpath = File.join(lp, file)
+          return File.realpath(libpath)
+        rescue Errno::ENOENT
+          # next
+        end
+      end
+
       raise
     end
 
     def add_line_breakpoint file, line, **kw
       file = resolve_path(file)
       bp = LineBreakpoint.new(file, line, **kw)
+
       add_breakpoint bp
     rescue Errno::ENOENT => e
       @ui.puts e.message
@@ -872,24 +1113,58 @@ module DEBUGGER__
       b = tp.binding
       if var_name = b.local_variables.first
         mid = b.local_variable_get(var_name)
-        found = false
+        unresolved = false
 
         @bps.each{|k, bp|
           case bp
           when MethodBreakpoint
             if bp.method.nil?
-              found = true
               if bp.sig_method_name == mid.to_s
-                bp.enable(quiet: true)
+                bp.try_enable(added: true)
               end
             end
+
+            unresolved = true unless bp.enabled?
           end
         }
-        unless found
+        unless unresolved
           METHOD_ADDED_TRACKER.disable
         end
       end
     end
+
+    def width
+      @ui.width
+    end
+
+    def check_forked
+      unless @session_server.status
+        # TODO: Support it
+        raise 'DEBUGGER: stop at forked process is not supported yet.'
+      end
+    end
+  end
+
+  class UI_Base
+    def event type, *args
+      case type
+      when :suspend_bp
+        i, bp = *args
+        puts "\nStop by \##{i} #{bp}" if bp
+      when :suspend_trap
+        puts "\nStop by #{args.first}"
+      end
+    end
+  end
+
+  # manual configuration methods
+
+  def self.add_line_breakpoint file, line, **kw
+    ::DEBUGGER__::SESSION.add_line_breakpoint file, line, **kw
+  end
+
+  def self.add_catch_breakpoint pat
+    ::DEBUGGER__::SESSION.add_catch_breakpoint pat
   end
 
   # String for requring location
@@ -903,30 +1178,79 @@ module DEBUGGER__
       when dir_prefix
       when %r{rubygems/core_ext/kernel_require\.rb}
       else
-        return loc
+        return loc if loc.absolute_path
       end
     end
     nil
   end
 
-  def self.console
-    initialize_session UI_Console.new
+  # start methods
 
-    @prev_handler = trap(:SIGINT){
-      ThreadClient.current.on_trap :SIGINT
-    }
+  def self.start nonstop: false, **kw
+    set_config(kw)
+
+    unless defined? SESSION
+      require_relative 'console'
+      initialize_session UI_Console.new
+    end
+
+    setup_initial_suspend unless nonstop
   end
 
-  def self.add_line_breakpoint file, line, **kw
-    ::DEBUGGER__::SESSION.add_line_breakpoint file, line, **kw
+  def self.open host: nil, port: ::DEBUGGER__::CONFIG[:port], sock_path: nil, sock_dir: nil, nonstop: false, **kw
+    set_config(kw)
+
+    if port
+      open_tcp host: host, port: port, nonstop: nonstop
+    else
+      open_unix sock_path: sock_path, sock_dir: sock_dir, nonstop: nonstop
+    end
   end
 
-  def self.add_catch_breakpoint pat
-    ::DEBUGGER__::SESSION.add_catch_breakpoint pat
+  def self.open_tcp host: nil, port:, nonstop: false, **kw
+    set_config(kw)
+    require_relative 'server'
+
+    if defined? SESSION
+      SESSION.reset_ui UI_TcpServer.new(host: host, port: port)
+    else
+      initialize_session UI_TcpServer.new(host: host, port: port)
+    end
+
+    setup_initial_suspend unless nonstop
+  end
+
+  def self.open_unix sock_path: nil, sock_dir: nil, nonstop: false, **kw
+    set_config(kw)
+    require_relative 'server'
+
+    if defined? SESSION
+      SESSION.reset_ui UI_UnixDomainServer.new(sock_dir: sock_dir, sock_path: sock_path)
+    else
+      initialize_session UI_UnixDomainServer.new(sock_dir: sock_dir, sock_path: sock_path)
+    end
+
+    setup_initial_suspend unless nonstop
+  end
+
+  # boot utilities
+
+  def self.setup_initial_suspend
+    if !::DEBUGGER__::CONFIG[:nonstop]
+      if loc = ::DEBUGGER__.require_location
+        # require 'debug/console' or 'debug'
+        add_line_breakpoint loc.absolute_path, loc.lineno + 1, oneshot: true, hook_call: false
+      else
+        # -r
+        add_line_breakpoint $0, 1, oneshot: true, hook_call: false
+      end
+    end
   end
 
   class << self
     define_method :initialize_session do |ui|
+      DEBUGGER__.warn "Session start (pid: #{Process.pid})"
+
       ::DEBUGGER__.const_set(:SESSION, Session.new(ui))
 
       # default breakpoints
@@ -934,18 +1258,18 @@ module DEBUGGER__
       # ::DEBUGGER__.add_catch_breakpoint 'RuntimeError'
 
       Binding.module_eval do
-        ::DEBUGGER__.add_line_breakpoint __FILE__, __LINE__ + 1
-        def bp; nil; end
-      end
+        def break pre: nil, do: nil
+          return unless SESSION.active?
 
-      if ::DEBUGGER__::CONFIG[:nonstop] != '1'
-        if loc = ::DEBUGGER__.require_location
-          # require 'debug/console' or 'debug'
-          add_line_breakpoint loc.absolute_path, loc.lineno + 1, oneshot: true, hook_call: false
-        else
-          # -r
-          add_line_breakpoint $0, 1, oneshot: true, hook_call: false
+          if pre || (do_expr = binding.local_variable_get(:do))
+            cmds = ['binding.break', pre, do_expr]
+          end
+
+          ::DEBUGGER__.add_line_breakpoint __FILE__, __LINE__ + 1, oneshot: true, command: cmds
+          true
         end
+        alias b break
+        # alias bp break
       end
 
       load_rc
@@ -953,27 +1277,29 @@ module DEBUGGER__
   end
 
   def self.load_rc
-    ['./rdbgrc.rb', File.expand_path('~/.rdbgrc.rb')].each{|path|
-      if File.file? path
-        load path
-      end
-    }
-
-    # debug commands file
-    [::DEBUGGER__::CONFIG[:init_script],
-     './.rdbgrc',
-     File.expand_path('~/.rdbgrc')].each{|path|
+    [[File.expand_path('~/.rdbgrc'), true],
+     [File.expand_path('~/.rdbgrc.rb'), true],
+     # ['./.rdbgrc', true], # disable because of security concern
+     [::DEBUGGER__::CONFIG[:init_script], false],
+     ].each{|(path, rc)|
       next unless path
+      next if rc && ::DEBUGGER__::CONFIG[:no_rc] # ignore rc
 
       if File.file? path
-        ::DEBUGGER__::SESSION.add_initial_commands File.readlines(path)
+        if path.end_with?('.rb')
+          load path
+        else
+          ::DEBUGGER__::SESSION.add_preset_commands path, File.readlines(path)
+        end
+      elsif !rc
+        warn "Not found: #{path}"
       end
     }
 
     # given debug commands
     if ::DEBUGGER__::CONFIG[:commands]
       cmds = ::DEBUGGER__::CONFIG[:commands].split(';;')
-      ::DEBUGGER__::SESSION.add_initial_commands cmds
+      ::DEBUGGER__::SESSION.add_preset_commands "commands", cmds, kick: false, continue: false
     end
   end
 
@@ -1027,9 +1353,8 @@ module DEBUGGER__
     r.join("\n")
   end
 
-  CONFIG = ::DEBUGGER__.parse_argv(ENV['RUBY_DEBUG_OPT'])
-
   class ::Module
+    undef method_added
     def method_added mid; end
     def singleton_method_added mid; end
   end
@@ -1043,4 +1368,44 @@ module DEBUGGER__
   end
 
   METHOD_ADDED_TRACKER = self.create_method_added_tracker
+
+  SHORT_INSPECT_LENGTH = 40
+  def self.short_inspect obj, use_short = true
+    str = obj.inspect
+    if use_short && str.length > SHORT_INSPECT_LENGTH
+      str[0...SHORT_INSPECT_LENGTH] + '...'
+    else
+      str
+    end
+  end
+
+  LOG_LEVELS = {
+    UNKNOWN: 0,
+    FATAL:   1,
+    ERROR:   2,
+    WARN:    3,
+    INFO:    4,
+  }.freeze
+
+  def self.warn msg
+    log :WARN, msg
+  end
+
+  def self.info msg
+    log :INFO, msg
+  end
+
+  def self.log level, msg
+    lv = LOG_LEVELS[level]
+    config_lv = LOG_LEVELS[CONFIG[:log_level] || :WARN]
+
+    if lv <= config_lv
+      if level == :WARN
+        # :WARN on debugger is general information
+        STDERR.puts "DEBUGGER: #{msg}"
+      else
+        STDERR.puts "DEBUGGER (#{level}): #{msg}"
+      end
+    end
+  end
 end