ruby-debug 0.2-mswin32 → 0.3-mswin32

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

@@ -0,0 +1,25 @@
+module Debugger
+  if RUBY_PLATFORM =~ /darwin/
+    class TextMateCommand < Command
+      def regexp
+        /^\s*tm(?:ate)?$/
+      end
+
+      def execute
+        %x|open 'txmt://open?url=file://#{File.expand_path(@state.file)}&line=#{@state.line}'|
+      end
+
+      class << self
+        def help_command
+          'tmate'
+        end
+
+        def help(cmd)
+          %{
+            tm[ate]\topens a current file in TextMate
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Debugger
+  class TraceCommand < Command
+    def regexp
+      /^\s*tr(?:ace)?(?:\s+(on|off))?(?:\s+(all))?$/
+    end
+
+    def execute
+      if @match[2]
+        Debugger.tracing = @match[1] == 'on'
+      elsif @match[1]
+        @state.context.tracing = @match[1] == 'on'
+      end
+      if Debugger.tracing || @state.context.tracing
+        print "Trace on.\n"
+      else
+        print "Trace off.\n"
+      end
+    end
+
+    class << self
+      def help_command
+        'trace'
+      end
+
+      def help(cmd)
+        %{
+          tr[ace] (on|off)\tset trace mode of current thread
+          tr[ace] (on|off) all\tset trace mode of all threads
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+module Debugger
+  module VarFunctions
+    def var_list(ary, bind = nil)
+      bind ||= @state.binding
+      ary.sort!
+      for v in ary
+        print "  %s => %s\n", v, eval(v, bind).inspect
+      end
+    end
+  end
+
+  class VarConstantCommand < Command
+    include VarFunctions
+
+    def regexp
+      /^\s*v(?:ar)?\s+c(?:onst(?:ant)?)?\s+/
+    end
+
+    def execute
+      obj = debug_eval(@match.post_match)
+      unless obj.kind_of? Module
+        print "Should be Class/Module: %s\n", @match.post_match
+      else
+        var_list(obj.constants, obj.module_eval{binding()})
+      end
+    end
+
+    class << self
+      def help_command
+        'var'
+      end
+
+      def help(cmd)
+        %{
+          v[ar] c[onst] <object>\t\tshow constants of object
+        }
+      end
+    end
+  end
+
+  class VarGlobalCommand < Command
+    include VarFunctions
+
+    def regexp
+      /^\s*v(?:ar)?\s+g(?:lobal)?\s*$/
+    end
+
+    def execute
+      var_list(global_variables)
+    end
+
+    class << self
+      def help_command
+        'var'
+      end
+
+      def help(cmd)
+        %{
+          v[ar] g[lobal]\t\t\tshow global variables
+        }
+      end
+    end
+  end
+
+  class VarInstanceCommand < Command
+    include VarFunctions
+
+    def regexp
+      /^\s*v(?:ar)?\s+i(?:nstance)?\s+/
+    end
+
+    def execute
+      obj = debug_eval(@match.post_match)
+      var_list(obj.instance_variables, obj.instance_eval{binding()})
+    end
+
+    class << self
+      def help_command
+        'var'
+      end
+
+      def help(cmd)
+        %{
+          v[ar] i[nstance] <object>\tshow instance variables of object
+        }
+      end
+    end
+  end
+
+  class VarLocalCommand < Command
+    include VarFunctions
+
+    def regexp
+      /^\s*v(?:ar)?\s+l(?:ocal)?\s*$/
+    end
+
+    def execute
+      var_list(eval("local_variables", @state.binding))
+    end
+
+    class << self
+      def help_command
+        'var'
+      end
+
+      def help(cmd)
+        %{
+          v[ar] l[ocal]\t\t\tshow local variables
+        }
+      end
+    end
+  end
+end

data/lib/ruby-debug/lock.rb

@@ -0,0 +1,41 @@
+module Debugger
+  class Lock
+    def initialize
+      @locker = nil
+      @waiting = []
+      @locked = false;
+    end
+
+    def locked?
+      @locked
+    end
+
+    def lock
+      return if Thread.critical
+      return if @locker == Thread.current
+      while (Thread.critical = true; @locked)
+        @waiting.push Thread.current
+        Thread.stop
+      end
+      @locked = true
+      @locker = Thread.current
+      Thread.critical = false
+      self
+    end
+
+    def unlock
+      return if Thread.critical
+      return unless @locked
+      unless @locker == Thread.current
+        raise RuntimeError, "unlocked by other"
+      end
+      Thread.critical = true
+      t = @waiting.shift
+      @locked = false
+      @locker = nil
+      Thread.critical = false
+      t.run if t
+      self
+    end
+  end
+end

data/lib/ruby-debug/processor.rb

@@ -1,66 +1,71 @@
 require 'ruby-debug/interface'
+require 'ruby-debug/command'
 
 module Debugger
   class CommandProcessor
-    DEBUG_LAST_CMD = []
-    
     attr_accessor :interface
+    attr_reader   :display
     
     def initialize(interface = LocalInterface.new)
       @interface = interface
       @display = []
       @mutex = Mutex.new
+      @last_cmd = nil
     end
     
     def interface=(interface)
       @mutex.synchronize do
-        @interface.close
-        @interface = interface        
+        @interface.close if @interface
+        @interface = interface
       end
     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
+          self.interface = nil
+        rescue Exception
+          print "INTERNAL ERROR!!! #\{$!\}\n"
+          print $!.backtrace.map{|l| "\t#\{l\}"}.join("\n")
+        end
+      }
+    end
+    
     def at_breakpoint(context, breakpoint)
-      @mutex.synchronize do
-        return unless @interface
-        n = Debugger.breakpoints.index(breakpoint) + 1
-        print "Breakpoint %d at %s:%s\n", n, breakpoint.source, breakpoint.pos
-      end
-    rescue IOError
-      self.interface = nil
+      n = Debugger.breakpoints.index(breakpoint) + 1
+      print "Breakpoint %d at %s:%s\n", n, breakpoint.source, breakpoint.pos
     end
+    protect :at_breakpoint
     
     def at_catchpoint(context, excpt)
-      @mutex.synchronize do
-        frames = Debugger.current_context.frames
-        print "%s:%d: `%s' (%s)\n", frames[0].file, frames[0].line, excpt, excpt.class
-        fs = frames.size
-        tb = caller(0)[-fs..-1]
-        if tb
-          for i in tb
-            print "\tfrom %s\n", i
-          end
+      frames = context.frames
+      print "Catchpoint at %s:%d: `%s' (%s)\n", frames[0].file, frames[0].line, excpt, excpt.class
+      fs = frames.size
+      tb = caller(0)[-fs..-1]
+      if tb
+        for i in tb
+          print "\tfrom %s\n", i
         end
       end
-    rescue IOError
-      self.interface = nil
     end
+    protect :at_catchpoint
     
     def at_tracing(context, file, line)
-      @mutex.synchronize do
-        print "Tracing(%d):%s:%s %s", context.thnum, file, line, line_at(file, line)
-      end
-    rescue IOError
-      self.interface = nil
+      print "Tracing(%d):%s:%s %s", context.thnum, file, line, Debugger.line_at(file, line)
     end
+    protect :at_tracing
 
-    def at_line(*args)
-      @mutex.synchronize do
-        process_commands(*args)
-      end
-    rescue IOError
-      puts 'error'
-      self.interface = nil
+    def at_line(context, file, line, binding)
+      print "%s:%d: %s", file, line, Debugger.line_at(file, line)
+      process_commands(context, file, line, binding)
     end
+    protect :at_line
 
     private
     
@@ -69,559 +74,117 @@ module Debugger
     end
     
     def process_commands(context, file, line, binding)
-      frame_pos = 0
-      binding_file = file
-      binding_line = line
-      previous_line = nil
-      print "%s:%d: %s", binding_file, binding_line, line_at(binding_file, binding_line)
-      display_expressions(binding)
-      prompt = true
-      while prompt and input = @interface.read_command("(rdb:%d) " % context.thnum)
+      event_cmds = Command.commands.select{|cmd| cmd.event }
+      state = State.new do |s|
+        s.context = context
+        s.file    = file
+        s.line    = line
+        s.binding = binding
+        s.display = display
+        s.interface = interface
+        s.commands = event_cmds
+      end
+      commands = event_cmds.map{|cmd| cmd.new(state) }
+      commands.find{ |cmd| cmd.kind_of?(DisplayCommand) }.execute
+      
+      while !state.proceed? and input = @interface.read_command("(rdb:%d) " % context.thnum)
         catch(:debug_error) do
           if input == ""
-            next unless DEBUG_LAST_CMD[0]
-            input = DEBUG_LAST_CMD[0]
+            next unless @last_cmd
+            input = @last_cmd
           else
-            DEBUG_LAST_CMD[0] = input
+            @last_cmd = input
           end
-
-          case input
-          when /^\s*s(?:tep)?(?:\s+(\d+))?$/
-            context.stop_next = $1 ? $1.to_i : 1
-            prompt = false
-
-          when /^\s*c(?:ont)?$|^\s*r(?:un)?$/
-            prompt = false
-
-          when /^\s*v(?:ar)?\s+/
-            debug_variable_info($', binding)
-
-          when /^\s*w(?:here)?$/, /^\s*f(?:rame)?$/
-            display_frames(context, frame_pos)
-
-          when /^\s*l(?:ist)?(?:\s+(.+))?$/
-            if not $1
-              b = previous_line ? previous_line + 10 : binding_line - 5
-              e = b + 9
-            elsif $1 == '-'
-              b = previous_line ? previous_line - 10 : binding_line - 5
-              e = b + 9
-            else
-              b, e = $1.split(/[-,]/)
-              if e
-                b = b.to_i
-                e = e.to_i
-              else
-                b = b.to_i - 5
-                e = b + 9
-              end
-            end
-            previous_line = b
-            display_list(b, e, binding_file, binding_line)
-
-          when /^\s*n(?:ext)?(?:\s+(\d+))?$/
-            steps = $1 ? $1.to_i : 1
-            context.step_over steps, context.frames.size - frame_pos
-            prompt = false
-
-          when /^\s*up(?:\s+(\d+))?$/
-            previous_line = nil
-            frame_pos += $1 ? $1.to_i : 1
-            if frame_pos >= context.frames.size
-              frame_pos = context.frames.size - 1
-              print "At toplevel"
-            end
-            frame = context.frames[frame_pos]
-            binding, binding_file, binding_line = frame.binding, frame.file, frame.line
-            print format_frame(frame, frame_pos)
-
-          when /^\s*down(?:\s+(\d+))?$/
-            previous_line = nil
-            frame_pos -= $1 ? $1.to_i : 1
-            if frame_pos < 0
-              frame_pos = 0
-              print "At stack bottom\n"
-            end
-            frame = context.frames[frame_pos]
-            binding, binding_file, binding_line = frame.binding, frame.file, frame.line
-            print format_frame(frame, frame_pos)
-
-          when /^\s*fin(?:ish)?$/
-            if frame_pos == context.frames.size
-              print "\"finish\" not meaningful in the outermost frame.\n"
-            else
-              context.stop_frame = context.frames.size - frame_pos
-              frame_pos = 0
-              prompt = false
-            end
-
-          when /^\s*b(?:reak)?\s+(?:(.+):)?([^.:\s]+)\s*(?:\sif\s+(.+))?$/
-            pos = $2
-            expr = $3
-            b_file = file
-            if $1
-              klass = debug_silent_eval($1, binding)
-              if klass && !klass.kind_of?(Module)
-                print "Unknown class #$1\n"
-                throw :debug_error
-              end
-              klass = klass.name if klass
-              b_file = $1
-            end
-            if pos =~ /^\d+$/
-              pname = pos
-              pos = pos.to_i
-            else
-              pname = pos = pos.intern.id2name
-            end
-            b_file = File.basename(b_file)
-            Debugger.add_breakpoint klass || b_file, pos, expr
-            print "Set breakpoint %d at %s:%s\n", Debugger.breakpoints.size, klass || b_file, pname
-
-          when /^\s*b(?:reak)?\s+(.+)[#.]([^.:\s]+)(?:\s+if\s+(.+))?$/
-            pos = $2.intern.id2name
-            expr = $3
-            klass = debug_eval($1, binding)
-            if klass.nil? || !klass.kind_of?(Module)
-              print "Unknown class #$1\n"
-              throw :debug_error
-            end
-            Debugger.add_breakpoint klass.name, pos, expr
-            print "Set breakpoint %d at %s.%s\n", Debugger.breakpoints.size, klass, pos
-
-          when /^\s*b(?:reak)?$/
-            unless Debugger.breakpoints.empty?
-              print "Breakpoints:\n"
-              Debugger.breakpoints.each_with_index do |b, n|
-                if b.expr.nil?
-                  print "  %d %s:%s\n", n+1, b.source, b.pos
-                else
-                  print "  %d %s:%s if %s\n", n+1, b.source, b.pos, b.expr
-                end
-              end
-              print "\n"
-            else
-              print "No breakpoints\n"
-            end
-          when /^\s*del(?:ete)?(?:\s+(\d+))?$/
-            pos = $1
-            unless pos
-              input = @interface.confirm("Clear all breakpoints? (y/n) ")
-              if input == "y"
-                Debugger.breakpoints.clear
-              end
-            else
-              pos = pos.to_i
-              unless Debugger.breakpoints.delete_at(pos-1)
-                print "Breakpoint %d is not defined\n", pos
-              end
-            end
-
-          when /^\s*th(?:read)?\s+/
-            if debug_thread_info($') == :cont
-              prompt = false
-            end
-
-          when /^\s*m(?:ethod)?\s+/
-            debug_method_info($', binding)
-
-          when /^\s*pp\s+/
-            out = StringIO.new
-            PP.pp(debug_eval($', binding), out) rescue out.puts $!.message
-            print out.string
-
-          when /^\s*(\s*p|e(?:val)?)\s+/
-            print "%s\n", debug_eval($', binding).inspect
-
-          when /^\s*h(?:elp)?(?:\s+(.+))?$/
-            debug_print_help($1)
-
-          when /^\s*q(?:uit)?$/
-            input = @interface.confirm("Really quit? (y/n) ")
-            if input == "y"
-              exit! # exit -> exit!: No graceful way to stop threads...
-            end
-
-          when /^\s*disp(?:lay)?\s+(.+)$/
-            exp = $1
-            @display.push [true, exp]
-            print "%d: ", @display.size
-            display_expression(exp, binding)
-
-          when /^\s*disp(?:lay)?$/
-            display_expressions(binding)
-
-          when /^\s*undisp(?:lay)?(?:\s+(\d+))?$/
-            pos = $1
-            unless pos
-              input = @interface.confirm("Clear all expressions? (y/n) ")
-              if input == "y"
-                for d in @display
-                  d[0] = false
-                end
-              end
-            else
-              pos = pos.to_i
-              if @display[pos-1]
-                @display[pos-1][0] = false
-              else
-                print "Display expression %d is not defined\n", pos
-              end
-            end
-
-          when /^\s*cat(?:ch)?(?:\s+(.+))?$/
-            if $1
-              excn = $1
-              if excn == 'off'
-                Debugger.catchpoint = nil
-                print "Clear catchpoint.\n"
-              else
-                Debugger.catchpoint = excn
-                print "Set catchpoint %s.\n", excn
-              end
-            else
-              if Debugger.catchpoint
-                print "Catchpoint %s.\n", Debugger.catchpoint
-              else
-                print "No catchpoint.\n"
-              end
-            end
-
-          when /^\s*tr(?:ace)?(?:\s+(on|off))?(?:\s+(all))?$/
-            if defined?( $2 )
-              Debugger.tracing = $1 == 'on'
-            elsif defined?( $1 )
-              context.tracing = $1 == 'on'
-            end
-            if Debugger.tracing || context.tracing
-              print "Trace on.\n"
-            else
-              print "Trace off.\n"
-            end
-
+          
+          if cmd = commands.find{ |c| c.match(input) }
+            cmd.execute
           else
             print "Unknown command\n"
           end
         end
       end
     end
-    
-    def display_expressions(binding)
-      n = 1
-      for d in @display
-        if d[0]
-          print "%d: ", n
-          display_expression(d[1], binding)
-        end
-        n += 1
-      end
-    end
 
-    def display_expression(exp, binding)
-      print "%s = %s\n", exp, debug_silent_eval(exp, binding).to_s
-    end
+    class State
+      attr_accessor :context, :file, :line, :binding
+      attr_accessor :frame_pos, :previous_line, :display
+      attr_accessor :interface, :commands
 
-    def debug_eval(str, binding)
-      begin
-        val = eval(str, binding)
-      rescue StandardError, ScriptError => e
-        at = eval("caller(1)", binding)
-        print "%s:%s\n", at.shift, e.to_s.sub(/\(eval\):1:(in `.*?':)?/, '')
-        for i in at
-          print "\tfrom %s\n", i
-        end
-        throw :debug_error
+      def initialize
+        @frame_pos = 0
+        @previous_line = nil
+        yield self
       end
-    end
 
-    def debug_silent_eval(str, binding)
-      begin
-        eval(str, binding)
-      rescue StandardError, ScriptError
-        nil
+      def print(*args)
+        @interface.print(*args)
       end
-    end
-
-    def debug_variable_info(input, binding)
-      case input
-      when /^\s*g(?:lobal)?\s*$/
-        var_list(global_variables, binding)
-
-      when /^\s*l(?:ocal)?\s*$/
-        var_list(eval("local_variables", binding), binding)
-
-      when /^\s*i(?:nstance)?\s+/
-        obj = debug_eval($', binding)
-        var_list(obj.instance_variables, obj.instance_eval{binding()})
 
-      when /^\s*c(?:onst(?:ant)?)?\s+/
-        obj = debug_eval($', binding)
-        unless obj.kind_of? Module
-          print "Should be Class/Module: %s\n", $'
-        else
-          var_list(obj.constants, obj.module_eval{binding()})
-        end
+      def confirm(*args)
+        @interface.confirm(*args)
       end
-    end
 
-    def display_frames(context, pos)
-      context.frames.each_with_index do |frame, idx|
-        if idx == pos
-          print "--> "
-        else
-          print "    "
-        end
-        print format_frame(frame, idx)
+      def proceed?
+        @proceed
       end
-    end
-
-    def format_frame(frame, pos)
-      file, line, id = frame.file, frame.line, frame.id
-      "#%d %s:%s%s\n" % [pos + 1, file, line, (id ? ":in `#{id.id2name}'" : "")]
-    end
 
-    def var_list(ary, binding)
-      ary.sort!
-      for v in ary
-        print "  %s => %s\n", v, eval(v, binding).inspect
+      def proceed
+        @proceed = true
       end
     end
-
-    def display_list(b, e, file, line)
-      print "[%d, %d] in %s\n", b, e, file
-      if lines = SCRIPT_LINES__[file] and lines != true
-        n = 0
-        b.upto(e) do |n|
-          if n > 0 && lines[n-1]
-            if n == line
-              print "=> %d  %s\n", n, lines[n-1].chomp
-            else
-              print "   %d  %s\n", n, lines[n-1].chomp
-            end
-          end
-        end
-      else
-        print "No sourcefile available for %s\n", file
-      end
+  end
+  
+  class ControlCommandProcessor
+    def initialize(interface)
+      @interface = interface
     end
-
-    def debug_method_info(input, binding)
-      case input
-      when /^i(:?nstance)?\s+/
-        obj = debug_eval($', binding)
-
-        len = 0
-        for v in obj.methods.sort
-          len += v.size + 1
-          if len > 70
-            len = v.size + 1
-            print "\n"
-          end
-          print "%s ", v
-        end
-        print "\n"
-
-      else
-        obj = debug_eval(input, binding)
-        unless obj.kind_of? Module
-          print "Should be Class/Module: %s\n", input
-        else
-          len = 0
-          for v in obj.instance_methods(false).sort
-            len += v.size + 1
-            if len > 70
-              len = v.size + 1
-              print "\n"
-            end
-            print "%s ", v
+    
+    def print(*args)
+      @interface.print(*args)
+    end
+    
+    def process_commands
+      control_cmds = Command.commands.select{|cmd| cmd.control }
+      state = State.new(@interface, control_cmds)
+      commands = control_cmds.map{|cmd| cmd.new(state) }
+      
+      while input = @interface.read_command("(rdb:ctrl) ")
+        catch(:debug_error) do
+          if cmd = commands.find{|c| c.match(input) }
+            cmd.execute
+          else
+            print "Unknown command\n"
           end
-          print "\n"
         end
       end
+    rescue IOError
+    rescue Exception
+      print "INTERNAL ERROR!!! #{$!}\n"
+      print $!.backtrace.map{|l| "\t#{l}"}.join("\n")
     end
-
-    def display_context(c)
-      if c.thread == Thread.current
-        print "+"
-      else
-        print " "
+    
+    class State
+      attr_reader :commands
+      def initialize(interface, commands)
+        @interface = interface
+        @commands = commands
       end
-      print "%d ", c.thnum
-      print "%s\t", c.thread.inspect
-      last_frame = c.frames.first
-      if last_frame
-        print "%s:%d", last_frame.file, last_frame.line
+      
+      def proceed
       end
-      print "\n"
-    end
-
-    def display_all_contexts
-      threads = Debugger.contexts.sort_by{|c| c.thnum}.each do |c|
-        display_context(c)
+      
+      def print(*args)
+        @interface.print(*args)
       end
-    end
-
-    def get_context(thnum)
-      Debugger.contexts.find{|c| c.thnum == thnum}
-    end
-
-    def debug_thread_info(input)
-      case input
-      when /^l(?:ist)?/
-        display_all_contexts
-
-      when /^c(?:ur(?:rent)?)?$/
-        display_context(Debugger.current_context)
-
-      when /^(?:sw(?:itch)?\s+)?(\d+)/
-        c = get_context($1.to_i)
-        if c == Debugger.current_context
-          print "It's the current thread.\n"
-        else
-          display_context(c)
-          c.stop_next = 1
-          c.thread.run
-          return :cont
-        end
-
-      when /^stop\s+(\d+)/
-        c = get_context($1.to_i)
-        if c == Debugger.current_context
-          print "It's the current thread.\n"
-        elsif c.thread.stop?
-          print "Already stopped.\n"
-        else
-          display_context(c)
-          c.set_suspend
-        end
-
-      when /^resume\s+(\d+)/
-        c = get_context($1.to_i)
-        if c == Debugger.current_context
-          print "It's the current thread.\n"
-        elsif !c.thread.stop?
-          print "Already running."
-        else
-          display_context(c)
-          c.thread.run
-        end
+      
+      def confirm(*args)
+        'y'
       end
-    end
 
-    def line_at(file, line)
-      lines = SCRIPT_LINES__[file]
-      if lines
-        return "\n" if lines == true
-        line = lines[line-1]
-        return "\n" unless line
-        return line.gsub(/^\s+/, '')
-      end
-      return "\n"
-    end
-    
-    COMMANDS = {
-      'break' => %{
-        b[reak]\tlist breakpoints
-        b[reak] [file|class(:|.)]<line|method> [if expr] -
-        set breakpoint to some position, (optionally) if expr == true
-      },
-      'delete' => %{
-        del[ete][ nnn]\tdelete some or all breakpoints
-      },
-      'catch' => %{
-        cat[ch]\t\t\tshow catchpoint
-        cat[ch] <an Exception>\tset catchpoint to an exception
-      },
-      'display' => %{
-        disp[lay] <expression>\tadd expression into display expression list
-      },
-      'undisplay' => %{
-        undisp[lay][ nnn]\tdelete one particular or all display expressions
-      },
-      'cont' => %{
-        c[ont]\trun until program ends or hit breakpoint
-      },
-      'run' => %{
-        r[un]\talias for cont
-      },
-      'step' => %{
-        s[tep][ nnn]\tstep (into methods) one line or till line nnn
-      },
-      'next' => %{
-        n[ext][ nnn]\tgo over one line or till line nnn
-      },
-      'where' => %{
-        w[here]\tdisplay frames
-      },
-      'frame' => %{
-        f[rame]\talias for where
-      },
-      'list' => %{
-        l[ist][ (-|nn-mm)]\tlist program, '-' list backwards, nn-mm list given lines
-      },
-      'up' => %{
-        up[ nn]\tmove to higher frame
-      },
-      'down' => %{
-        down[ nn]\tmove to lower frame
-      },
-      'finish' => %{
-        fin[ish]\treturn to outer frame
-      },
-      'quit' => %{
-        q[uit]\texit from debugger
-      },
-      'trace' => %{
-        tr[ace] (on|off)\tset trace mode of current thread
-        tr[ace] (on|off) all\tset trace mode of all threads
-      },
-      'var' => %{
-        v[ar] g[lobal]\t\t\tshow global variables
-        v[ar] l[ocal]\t\t\tshow local variables
-        v[ar] i[nstance] <object>\tshow instance variables of object
-        v[ar] c[onst] <object>\t\tshow constants of object
-      },
-      'method' => %{
-        m[ethod] i[nstance] <obj>\tshow methods of object
-        m[ethod] <class|module>\t\tshow instance methods of class or module
-      },
-      'thread' => %{
-        th[read] l[ist]\t\t\tlist all threads
-        th[read] c[ur[rent]]\t\tshow current thread
-        th[read] [sw[itch]] <nnn>\tswitch thread context to nnn
-        th[read] stop <nnn>\t\tstop thread nnn
-        th[read] resume <nnn>\t\tresume thread nnn
-      },
-      'p' => %{
-        p expression\tevaluate expression and print its value
-      },
-      'eval' => %{
-        e[val] expression\tevaluate expression and print its value,
-        \t\t\talias for p
-      },
-      'pp' => %{
-        pp expression\tevaluate expression and print its value
-      },
-      'help' => %{
-        h[elp]\tprint this help
-      }
-    }
-
-    def debug_print_help(command)
-      print "ruby-debug help v.#{Debugger::VERSION}\n"
-      help = COMMANDS[command]
-      if help
-        print help.split("\n").map{|l| l.gsub(/^ +/, '')}.join("\n")
-      else
-        print "Available commands:\n"
-        require 'enumerator'
-        COMMANDS.keys.sort.enum_slice(12).each do |slice|
-          print slice.join(' ')
-          print "\n"
-        end
+      def file
+        print "No filename given.\n"
+        throw :debug_error
       end
-      print "\n"
     end
-
   end
 end