ruby-debug-ide 0.1.10 → 0.2.0

data/lib/ruby-debug.rb

@@ -46,6 +46,10 @@ module Debugger
     def at_line(file, line)
       event_processor.at_line(self, file, line)
     end
+ 
+    def at_return(file, line)
+      event_processor.at_return(self, file, line)
+    end
   end
   
   class << self
@@ -79,13 +83,15 @@ module Debugger
       
       start_control(host, port)
       
+      raise "Control thread did not start (#{@control_thread}}" unless @control_thread && @control_thread.alive?
+      
       @mutex = Mutex.new
       @proceed = ConditionVariable.new
       
-      # wait for start command
+      # wait for 'start' command
       @mutex.synchronize do
         @proceed.wait(@mutex)
-      end 
+      end
       
       debug_load Debugger::PROG_SCRIPT
     end
@@ -100,7 +106,9 @@ module Debugger
       raise "Debugger is not started" unless started?
       return if @control_thread
       @control_thread = DebugThread.new do
+        host ||= 'localhost' # nil does not seem to work for IPv6, localhost does
         Debugger.print_debug("Waiting for connection on '#{host}:#{port}'")
+        $stderr.puts "Fast Debugger (ruby-debug-ide 0.2.0) listens on #{host}:#{port}"
         server = TCPServer.new(host, port)
         while (session = server.accept)
           begin

data/lib/ruby-debug/command.rb

@@ -3,6 +3,22 @@ require 'ruby-debug/helper'
 module Debugger
 
   class Command # :nodoc:
+    SubcmdStruct=Struct.new(:name, :min, :short_help, :long_help) unless
+      defined?(SubcmdStruct)
+
+    # Find param in subcmds. param id downcased and can be abbreviated
+    # to the minimum length listed in the subcommands
+    def find(subcmds, param)
+      param.downcase!
+      for try_subcmd in subcmds do
+        if (param.size >= try_subcmd.min) and
+            (try_subcmd.name[0..param.size-1] == param)
+          return try_subcmd
+        end
+      end
+      return nil
+    end
+
     class << self
       def commands
         @commands ||= []
@@ -67,6 +83,11 @@ module Debugger
       end
     end
     
+    # FIXME: use delegate? 
+    def errmsg(*args)
+      @printer.print_error(*args)
+    end
+
     def print(*args)
       @state.print(*args)
     end

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

@@ -3,24 +3,20 @@ module Debugger
     self.control = true
 
     def regexp
-      /^\s*cat(?:ch)?(?:\s+(.+))?$/
+      /^\s* cat(?:ch)? (?:\s+(.+))? $/x
     end
 
     def execute
-      if excn = @match[1]
-        if excn == 'off'
-          Debugger.catchpoint = nil
-          print_msg "Clear catchpoint."
-        else
-          Debugger.catchpoint = excn
-          print_msg "Set catchpoint %s.", excn
-        end
+      excn = @match[1]
+      unless excn
+        errmsg "Exception class must be specified for 'catch' command"
       else
-        if Debugger.catchpoint
-          print_msg "Catchpoint %s.", Debugger.catchpoint
-        else
-          print_msg "No catchpoint."
+        binding = @state.context ? get_binding : TOPLEVEL_BINDING
+        unless debug_eval("#{excn}.is_a?(Class)", binding)
+          print_msg "Warning #{excn} is not known to be a Class"
         end
+        Debugger.add_catchpoint(excn)
+        print_msg "Set catchpoint %s.", excn
       end
     end
 
@@ -37,4 +33,4 @@ module Debugger
       end
     end
   end
-end
+end

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

@@ -0,0 +1,51 @@
+module Debugger
+
+  class ConditionCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s* cond(?:ition)? (?:\s+(\d+)\s*(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        errmsg "\"condition\" must be followed a breakpoint number and expression\n"
+      else
+        breakpoints = Debugger.breakpoints.sort_by{|b| b.id }
+        largest = breakpoints.inject(0) do |largest, b| 
+          largest = b.id if b.id > largest
+        end
+        if 0 == largest
+          print "No breakpoints have been set.\n"
+          return
+        end
+        pos = get_int(@match[1], "Condition", 1, largest)
+        return unless pos
+        breakpoints.each do |b|
+          if b.id == pos 
+            b.expr = @match[2].empty? ? nil : @match[2]
+            print_contdition_set(b.id)
+            break
+          end
+        end
+
+      end
+    end
+    
+    class << self
+      def help_command
+        'condition'
+      end
+
+      def help(cmd)
+        %{
+          Condition breakpoint-number expression
+Specify breakpoint number N to break only if COND is true.
+N is an integer and COND is an expression to be evaluated whenever 
+breakpoint N is reached. If the empty string is used, the condition is removed.
+        }
+      end
+    end
+  end
+
+end # module Debugger

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

@@ -0,0 +1,203 @@
+module Debugger
+  # Mix-in module to assist in command parsing.
+  module EnableDisableFunctions # :nodoc:
+    def enable_disable_breakpoints(is_enable, args)
+      breakpoints = Debugger.breakpoints.sort_by{|b| b.id }
+      largest = breakpoints.inject(0) do |largest, b| 
+        largest = b.id if b.id > largest
+      end
+      if 0 == largest
+        errmsg "No breakpoints have been set.\n"
+        return
+      end
+      args.each do |pos|
+        pos = get_int(pos, "#{is_enable} breakpoints", 1, largest)
+        return nil unless pos
+        breakpoints.each do |b|
+          if b.id == pos 
+            enabled = ("Enable" == is_enable)
+            if enabled
+              unless syntax_valid?(b.expr)
+                errmsg("Expression \"#{b.expr}\" syntactically incorrect; breakpoint remains disabled.\n")
+                break
+              end
+            end
+            b.enabled = enabled
+            enabled ? print_breakpoint_enabled(b) : print_breakpoint_disabled(b)
+            break
+          end
+        end
+      end
+    end
+
+    def enable_disable_display(is_enable, args)
+      if 0 == @state.display.size 
+        errmsg "No display expressions have been set.\n"
+        return
+      end
+      args.each do |pos|
+        pos = get_int(pos, "#{is_enable} display", 1, @state.display.size)
+        return nil unless pos
+        @state.display[pos-1][0] = ("Enable" == is_enable)
+      end
+    end
+
+  end
+
+  class EnableCommand < Command # :nodoc:
+    Subcommands = 
+      [
+       ['breakpoints', 2, "Enable specified breakpoints",
+"Give breakpoint numbers (separated by spaces) as arguments.
+This is used to cancel the effect of the \"disable\" command."
+       ],
+       ['display', 2, 
+        "Enable some expressions to be displayed when program stops",
+"Arguments are the code numbers of the expressions to resume displaying.
+Do \"info display\" to see current list of code numbers."],
+      ].map do |name, min, short_help, long_help| 
+      SubcmdStruct.new(name, min, short_help, long_help)
+    end unless defined?(Subcommands)
+
+    def regexp
+      /^\s* en(?:able)? (?:\s+(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        errmsg "\"enable\" must be followed \"display\", \"breakpoints\"" +
+          " or breakpoint numbers.\n"
+      else
+        args = @match[1].split(/[ \t]+/)
+        param = args.shift
+        subcmd = find(Subcommands, param)
+        if subcmd
+          send("enable_#{subcmd.name}", args)
+        else
+          send("enable_breakpoints", args.unshift(param))
+        end
+      end
+    end
+    
+    def enable_breakpoints(args)
+      enable_disable_breakpoints("Enable", args)
+    end
+    
+    def enable_display(args)
+      enable_disable_display("Enable", args)
+    end
+    
+    class << self
+      def help_command
+        'enable'
+      end
+
+      def help(args)
+        if args[1] 
+          s = args[1]
+          subcmd = Subcommands.find do |try_subcmd| 
+            (s.size >= try_subcmd.min) and
+              (try_subcmd.name[0..s.size-1] == s)
+          end
+          if subcmd
+            str = subcmd.short_help + '.'
+            str += "\n" + subcmd.long_help if subcmd.long_help
+            return str
+          else
+            return "Invalid 'enable' subcommand '#{args[1]}'."
+          end
+        end
+        s = %{
+          Enable some things.
+          This is used to cancel the effect of the "disable" command.
+          -- 
+          List of enable subcommands:
+          --  
+        }
+        for subcmd in Subcommands do
+          s += "enable #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+
+  class DisableCommand < Command # :nodoc:
+    Subcommands = 
+      [
+       ['breakpoints', 1, "Disable some breakpoints",
+"Arguments are breakpoint numbers with spaces in between.
+A disabled breakpoint is not forgotten, but has no effect until reenabled."],
+       ['display', 1, "Disable some display expressions when program stops",
+"Arguments are the code numbers of the expressions to stop displaying.
+Do \"info display\" to see current list of code numbers."],
+      ].map do |name, min, short_help, long_help| 
+      SubcmdStruct.new(name, min, short_help, long_help)
+    end unless defined?(Subcommands)
+
+    def regexp
+      /^\s* dis(?:able)? (?:\s+(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        errmsg "\"disable\" must be followed \"display\", \"breakpoints\"" +
+          " or breakpoint numbers.\n"
+      else
+        args = @match[1].split(/[ \t]+/)
+        param = args.shift
+        subcmd = find(Subcommands, param)
+        if subcmd
+          send("disable_#{subcmd.name}", args)
+        else
+          send("disable_breakpoints", args.unshift(param))
+        end
+      end
+    end
+    
+    def disable_breakpoints(args)
+      enable_disable_breakpoints("Disable", args)
+    end
+    
+    def disable_display(args)
+      enable_disable_display("Disable", args)
+    end
+    
+    class << self
+      def help_command
+        'disable'
+      end
+
+      def help(args)
+        if args[1] 
+          s = args[1]
+          subcmd = Subcommands.find do |try_subcmd| 
+            (s.size >= try_subcmd.min) and
+              (try_subcmd.name[0..s.size-1] == s)
+          end
+          if subcmd
+            str = subcmd.short_help + '.'
+            str += "\n" + subcmd.long_help if subcmd.long_help
+            return str
+          else
+            return "Invalid 'disable' subcommand '#{args[1]}'."
+          end
+        end
+        s = %{
+          Disable some things.
+
+          A disabled item is not forgotten, but has no effect until reenabled.
+          Use the "enable" command to have it take effect again.
+          -- 
+          List of disable subcommands:
+          --  
+        }
+        for subcmd in Subcommands do
+          s += "disable #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+
+end # module Debugger

data/lib/ruby-debug/commands/tags

@@ -0,0 +1,168 @@
+!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_PROGRAM_AUTHOR	Darren Hiebert	/dhiebert@users.sourceforge.net/
+!_TAG_PROGRAM_NAME	Exuberant Ctags	//
+!_TAG_PROGRAM_URL	http://ctags.sourceforge.net	/official site/
+!_TAG_PROGRAM_VERSION	5.7	//
+AddBreakpoint	breakpoints.rb	/^  class AddBreakpoint < Command # :nodoc:$/;"	c	class:Debugger
+BreakpointsCommand	breakpoints.rb	/^  class BreakpointsCommand < Command # :nodoc:$/;"	c
+CatchCommand	catchpoint.rb	/^  class CatchCommand < Command # :nodoc:$/;"	c	class:Debugger
+ConditionCommand	condition.rb	/^  class ConditionCommand < Command # :nodoc:$/;"	c	class:Debugger
+ContinueCommand	stepping.rb	/^  class ContinueCommand < Command # :nodoc:$/;"	c
+Debugger	breakpoints.rb	/^module Debugger$/;"	m
+Debugger	catchpoint.rb	/^module Debugger$/;"	m
+Debugger	condition.rb	/^module Debugger$/;"	m
+Debugger	control.rb	/^module Debugger$/;"	m
+Debugger	eval.rb	/^module Debugger$/;"	m
+Debugger	frame.rb	/^module Debugger$/;"	m
+Debugger	inspect.rb	/^module Debugger$/;"	m
+Debugger	load.rb	/^module Debugger$/;"	m
+Debugger	stepping.rb	/^module Debugger$/;"	m
+Debugger	threads.rb	/^module Debugger$/;"	m
+Debugger	variables.rb	/^module Debugger$/;"	m
+DeleteBreakpointCommand	breakpoints.rb	/^  class DeleteBreakpointCommand < Command # :nodoc:$/;"	c
+DownCommand	frame.rb	/^  class DownCommand < Command # :nodoc:$/;"	c
+EvalCommand	eval.rb	/^  class EvalCommand < Command # :nodoc:$/;"	c	class:Debugger
+FinishCommand	stepping.rb	/^  class FinishCommand < Command # :nodoc:$/;"	c
+FrameCommand	frame.rb	/^  class FrameCommand < Command # :nodoc:$/;"	c
+FrameFunctions	frame.rb	/^  module FrameFunctions # :nodoc:$/;"	m	class:Debugger
+InspectCommand	inspect.rb	/^  class InspectCommand < Command$/;"	c	class:Debugger
+InterruptCommand	control.rb	/^  class InterruptCommand < Command # :nodoc:$/;"	c
+LoadCommand	load.rb	/^  class LoadCommand < Command  $/;"	c	class:Debugger
+NextCommand	stepping.rb	/^  class NextCommand < Command # :nodoc:$/;"	c	class:Debugger
+PPCommand	eval.rb	/^  class PPCommand < Command # :nodoc:$/;"	c
+QuitCommand	control.rb	/^  class QuitCommand < Command # :nodoc:$/;"	c	class:Debugger
+RestartCommand	control.rb	/^  class RestartCommand < Command # :nodoc:$/;"	c
+StartCommand	control.rb	/^  class StartCommand < Command # :nodoc:$/;"	c
+StepCommand	stepping.rb	/^  class StepCommand < Command # :nodoc:$/;"	c
+ThreadCurrentCommand	threads.rb	/^  class ThreadCurrentCommand < Command # :nodoc:$/;"	c
+ThreadListCommand	threads.rb	/^  class ThreadListCommand < Command # :nodoc:$/;"	c	class:Debugger
+ThreadResumeCommand	threads.rb	/^  class ThreadResumeCommand < Command # :nodoc:$/;"	c
+ThreadStopCommand	threads.rb	/^  class ThreadStopCommand < Command # :nodoc:$/;"	c
+ThreadSwitchCommand	threads.rb	/^  class ThreadSwitchCommand < Command # :nodoc:$/;"	c
+UpCommand	frame.rb	/^  class UpCommand < Command # :nodoc:$/;"	c
+VarConstantCommand	variables.rb	/^  class VarConstantCommand < Command # :nodoc:$/;"	c	class:Debugger
+VarGlobalCommand	variables.rb	/^  class VarGlobalCommand < Command # :nodoc:$/;"	c
+VarInstanceCommand	variables.rb	/^  class VarInstanceCommand < Command # :nodoc:$/;"	c
+VarLocalCommand	variables.rb	/^  class VarLocalCommand < Command # :nodoc:$/;"	c
+WhereCommand	frame.rb	/^  class WhereCommand < Command # :nodoc:$/;"	c	class:Debugger
+adjust_frame	frame.rb	/^    def adjust_frame(frame_pos, absolute)$/;"	f	class:Debugger.FrameFunctions
+clear_references	inspect.rb	/^    def self.clear_references$/;"	F	class:Debugger.InspectCommand
+execute	breakpoints.rb	/^    def execute$/;"	f	class:BreakpointsCommand
+execute	breakpoints.rb	/^    def execute$/;"	f	class:Debugger.AddBreakpoint
+execute	breakpoints.rb	/^    def execute$/;"	f	class:DeleteBreakpointCommand
+execute	catchpoint.rb	/^    def execute$/;"	f	class:Debugger.CatchCommand
+execute	condition.rb	/^    def execute$/;"	f	class:Debugger.ConditionCommand
+execute	control.rb	/^    def execute$/;"	f	class:Debugger.QuitCommand
+execute	control.rb	/^    def execute$/;"	f	class:InterruptCommand
+execute	control.rb	/^    def execute$/;"	f	class:RestartCommand
+execute	control.rb	/^    def execute$/;"	f	class:StartCommand
+execute	eval.rb	/^    def execute$/;"	f	class:Debugger.EvalCommand
+execute	eval.rb	/^    def execute$/;"	f	class:PPCommand
+execute	frame.rb	/^    def execute$/;"	f	class:Debugger.WhereCommand
+execute	frame.rb	/^    def execute$/;"	f	class:DownCommand
+execute	frame.rb	/^    def execute$/;"	f	class:FrameCommand
+execute	frame.rb	/^    def execute$/;"	f	class:UpCommand
+execute	inspect.rb	/^    def execute$/;"	f	class:Debugger.InspectCommand
+execute	load.rb	/^    def execute$/;"	f	class:Debugger.LoadCommand
+execute	stepping.rb	/^    def execute$/;"	f	class:ContinueCommand
+execute	stepping.rb	/^    def execute$/;"	f	class:Debugger.NextCommand
+execute	stepping.rb	/^    def execute$/;"	f	class:FinishCommand
+execute	stepping.rb	/^    def execute$/;"	f	class:StepCommand
+execute	threads.rb	/^    def execute$/;"	f	class:Debugger.ThreadListCommand
+execute	threads.rb	/^    def execute$/;"	f	class:ThreadCurrentCommand
+execute	threads.rb	/^    def execute$/;"	f	class:ThreadResumeCommand
+execute	threads.rb	/^    def execute$/;"	f	class:ThreadStopCommand
+execute	threads.rb	/^    def execute$/;"	f	class:ThreadSwitchCommand
+execute	variables.rb	/^    def execute$/;"	f	class:Debugger.VarConstantCommand
+execute	variables.rb	/^    def execute$/;"	f	class:VarGlobalCommand
+execute	variables.rb	/^    def execute$/;"	f	class:VarInstanceCommand
+execute	variables.rb	/^    def execute$/;"	f	class:VarLocalCommand
+help	breakpoints.rb	/^      def help(cmd)$/;"	f	class:BreakpointsCommand
+help	breakpoints.rb	/^      def help(cmd)$/;"	f	class:Debugger.AddBreakpoint
+help	breakpoints.rb	/^      def help(cmd)$/;"	f	class:DeleteBreakpointCommand
+help	catchpoint.rb	/^      def help(cmd)$/;"	f	class:Debugger.CatchCommand
+help	condition.rb	/^      def help(cmd)$/;"	f	class:Debugger.ConditionCommand
+help	control.rb	/^      def help(cmd)$/;"	f	class:Debugger.QuitCommand
+help	control.rb	/^      def help(cmd)$/;"	f	class:InterruptCommand
+help	control.rb	/^      def help(cmd)$/;"	f	class:RestartCommand
+help	control.rb	/^      def help(cmd)$/;"	f	class:StartCommand
+help	eval.rb	/^      def help(cmd)$/;"	f	class:Debugger.EvalCommand
+help	eval.rb	/^      def help(cmd)$/;"	f	class:PPCommand
+help	frame.rb	/^      def help(cmd)$/;"	f	class:Debugger.WhereCommand
+help	frame.rb	/^      def help(cmd)$/;"	f	class:DownCommand
+help	frame.rb	/^      def help(cmd)$/;"	f	class:FrameCommand
+help	frame.rb	/^      def help(cmd)$/;"	f	class:UpCommand
+help	stepping.rb	/^      def help(cmd)$/;"	f	class:ContinueCommand
+help	stepping.rb	/^      def help(cmd)$/;"	f	class:Debugger.NextCommand
+help	stepping.rb	/^      def help(cmd)$/;"	f	class:FinishCommand
+help	stepping.rb	/^      def help(cmd)$/;"	f	class:StepCommand
+help	threads.rb	/^      def help(cmd)$/;"	f	class:Debugger.ThreadListCommand
+help	threads.rb	/^      def help(cmd)$/;"	f	class:ThreadCurrentCommand
+help	threads.rb	/^      def help(cmd)$/;"	f	class:ThreadResumeCommand
+help	threads.rb	/^      def help(cmd)$/;"	f	class:ThreadStopCommand
+help	threads.rb	/^      def help(cmd)$/;"	f	class:ThreadSwitchCommand
+help	variables.rb	/^      def help(cmd)$/;"	f
+help	variables.rb	/^      def help(cmd)$/;"	f	class:Debugger
+help	variables.rb	/^      def help(cmd)$/;"	f	class:VarGlobalCommand
+help	variables.rb	/^      def help(cmd)$/;"	f	class:VarLocalCommand
+help_command	breakpoints.rb	/^      def help_command$/;"	f	class:BreakpointsCommand
+help_command	breakpoints.rb	/^      def help_command$/;"	f	class:Debugger.AddBreakpoint
+help_command	breakpoints.rb	/^      def help_command$/;"	f	class:DeleteBreakpointCommand
+help_command	catchpoint.rb	/^      def help_command$/;"	f	class:Debugger.CatchCommand
+help_command	condition.rb	/^      def help_command$/;"	f	class:Debugger.ConditionCommand
+help_command	control.rb	/^      def help_command$/;"	f	class:Debugger.QuitCommand
+help_command	control.rb	/^      def help_command$/;"	f	class:InterruptCommand
+help_command	control.rb	/^      def help_command$/;"	f	class:RestartCommand
+help_command	control.rb	/^      def help_command$/;"	f	class:StartCommand
+help_command	eval.rb	/^      def help_command$/;"	f	class:Debugger.EvalCommand
+help_command	eval.rb	/^      def help_command$/;"	f	class:PPCommand
+help_command	frame.rb	/^      def help_command$/;"	f	class:Debugger.WhereCommand
+help_command	frame.rb	/^      def help_command$/;"	f	class:DownCommand
+help_command	frame.rb	/^      def help_command$/;"	f	class:FrameCommand
+help_command	frame.rb	/^      def help_command$/;"	f	class:UpCommand
+help_command	stepping.rb	/^      def help_command$/;"	f	class:ContinueCommand
+help_command	stepping.rb	/^      def help_command$/;"	f	class:Debugger.NextCommand
+help_command	stepping.rb	/^      def help_command$/;"	f	class:FinishCommand
+help_command	stepping.rb	/^      def help_command$/;"	f	class:StepCommand
+help_command	threads.rb	/^      def help_command$/;"	f	class:Debugger.ThreadListCommand
+help_command	threads.rb	/^      def help_command$/;"	f	class:ThreadCurrentCommand
+help_command	threads.rb	/^      def help_command$/;"	f	class:ThreadResumeCommand
+help_command	threads.rb	/^      def help_command$/;"	f	class:ThreadStopCommand
+help_command	threads.rb	/^      def help_command$/;"	f	class:ThreadSwitchCommand
+help_command	variables.rb	/^      def help_command$/;"	f
+help_command	variables.rb	/^      def help_command$/;"	f	class:Debugger
+help_command	variables.rb	/^      def help_command$/;"	f	class:VarGlobalCommand
+help_command	variables.rb	/^      def help_command$/;"	f	class:VarLocalCommand
+match	eval.rb	/^    def match(input)$/;"	f	class:Debugger.EvalCommand
+reference_result	inspect.rb	/^    def self.reference_result(result)$/;"	F	class:Debugger.InspectCommand
+regexp	breakpoints.rb	/^    def regexp$/;"	f	class:BreakpointsCommand
+regexp	breakpoints.rb	/^    def regexp$/;"	f	class:Debugger.AddBreakpoint
+regexp	breakpoints.rb	/^    def regexp$/;"	f	class:DeleteBreakpointCommand
+regexp	catchpoint.rb	/^    def regexp$/;"	f	class:Debugger.CatchCommand
+regexp	condition.rb	/^    def regexp$/;"	f	class:Debugger.ConditionCommand
+regexp	control.rb	/^    def regexp$/;"	f	class:Debugger.QuitCommand
+regexp	control.rb	/^    def regexp$/;"	f	class:InterruptCommand
+regexp	control.rb	/^    def regexp$/;"	f	class:RestartCommand
+regexp	control.rb	/^    def regexp$/;"	f	class:StartCommand
+regexp	eval.rb	/^    def regexp$/;"	f	class:Debugger.EvalCommand
+regexp	eval.rb	/^    def regexp$/;"	f	class:PPCommand
+regexp	frame.rb	/^    def regexp$/;"	f	class:Debugger.WhereCommand
+regexp	frame.rb	/^    def regexp$/;"	f	class:DownCommand
+regexp	frame.rb	/^    def regexp$/;"	f	class:FrameCommand
+regexp	frame.rb	/^    def regexp$/;"	f	class:UpCommand
+regexp	inspect.rb	/^    def regexp$/;"	f	class:Debugger.InspectCommand
+regexp	load.rb	/^    def regexp$/;"	f	class:Debugger.LoadCommand
+regexp	stepping.rb	/^    def regexp$/;"	f	class:ContinueCommand
+regexp	stepping.rb	/^    def regexp$/;"	f	class:Debugger.NextCommand
+regexp	stepping.rb	/^    def regexp$/;"	f	class:FinishCommand
+regexp	stepping.rb	/^    def regexp$/;"	f	class:StepCommand
+regexp	threads.rb	/^    def regexp$/;"	f	class:Debugger.ThreadListCommand
+regexp	threads.rb	/^    def regexp$/;"	f	class:ThreadCurrentCommand
+regexp	threads.rb	/^    def regexp$/;"	f	class:ThreadResumeCommand
+regexp	threads.rb	/^    def regexp$/;"	f	class:ThreadStopCommand
+regexp	threads.rb	/^    def regexp$/;"	f	class:ThreadSwitchCommand
+regexp	variables.rb	/^    def regexp$/;"	f	class:Debugger.VarConstantCommand
+regexp	variables.rb	/^    def regexp$/;"	f	class:VarGlobalCommand
+regexp	variables.rb	/^    def regexp$/;"	f	class:VarInstanceCommand
+regexp	variables.rb	/^    def regexp$/;"	f	class:VarLocalCommand

data/lib/ruby-debug/event_processor.rb

@@ -9,11 +9,14 @@
        @printer = XmlPrinter.new(interface)
        @line = nil
        @file = nil
+       @last_breakpoint = nil
      end
     
      def at_breakpoint(context, breakpoint)
-       n = Debugger.breakpoints.index(breakpoint) + 1
-       @printer.print_breakpoint n, breakpoint
+       raise "@last_breakpoint supposed to be nil. is #{@last_breakpoint}" if @last_breakpoint
+       # at_breakpoint is immediately followed by #at_line event in
+       # ruby-debug-base. So postpone breakpoint printing until #at_line.
+       @last_breakpoint = breakpoint
      end
      
      def at_catchpoint(context, excpt)
@@ -26,14 +29,35 @@
      
      def at_line(context, file, line)
        @printer.print_at_line(file, line) if context.nil? || context.stop_reason == :step
-       @line=line
-       @file =file
+       line_event(context, file, line)
+     end
+
+     def at_return(context, file, line)
+       @printer.print_at_line(file, line)
+       context.stop_frame = -1
+       line_event(context, file, line)
+     end
+
+     def line_event(context, file, line)
+       @line = line
+       @file = file
        @context = context
+       if @last_breakpoint
+         # followed after #at_breakpoint in the same thread. Print breakpoint
+         # now when @line, @file and @context are correctly set to prevent race
+         # condition with `control thread'.
+         n = Debugger.breakpoints.index(@last_breakpoint) + 1
+         @printer.print_breakpoint n, @last_breakpoint
+         @last_breakpoint = nil
+       end
+       raise "DebuggerThread are not supposed to be traced (#{context.thread})" if context.thread.is_a?(Debugger::DebugThread)
        @printer.print_debug("Stopping Thread %s", context.thread.to_s)
        @printer.print_debug("Threads equal: %s", Thread.current == context.thread)
+       # will be resumed by commands like `step', `next', `continue', `finish'
+       # from `control thread'
        Thread.stop
        @printer.print_debug("Resumed Thread %s", context.thread.to_s)
-       @line=nil
+       @line = nil
        @file = nil
        @context = nil
      end
@@ -41,5 +65,6 @@
      def at_line?
         @line
      end     
+    
    end
- end
+ end

data/lib/ruby-debug/helper.rb

@@ -22,5 +22,12 @@ module Debugger
       end
     end
 
+    # Return true if code is syntactically correct for Ruby.
+    def syntax_valid?(code)
+      eval("BEGIN {return true}\n#{code}", nil, "", 0)
+    rescue Exception
+      false
+    end 
+
   end
 end

data/lib/ruby-debug/processor.rb

@@ -15,15 +15,15 @@ module Debugger
     
     def process_commands
       @printer.print_debug("Starting command read loop")
-      control_cmds = Command.commands.select{|cmd| cmd.control }
-      state = ControlState.new(@interface, control_cmds)
-      commands = control_cmds.map{|cmd| cmd.new(state, @printer) }
+      ctrl_cmd_classes = Command.commands.select{|cmd| cmd.control}
+      state = ControlState.new(@interface)
+      ctrl_cmds = ctrl_cmd_classes.map{|cmd| cmd.new(state, @printer)}
       
       while input = @interface.read_command
         # escape % since print_debug might use printf
         @printer.print_debug "Processing: #{input.gsub('%', '%%')}"
         catch(:debug_error) do
-          if cmd = commands.find{|c| c.match(input) }
+          if cmd = ctrl_cmds.find{|c| c.match(input) }
             cmd.execute
           else
             process_context_commands(input)
@@ -33,35 +33,33 @@ module Debugger
     rescue IOError, Errno::EPIPE
     rescue Exception
       @printer.print_error "INTERNAL ERROR!!! #{$!}\n" rescue nil
-    @printer.print_error $!.backtrace.map{|l| "\t#{l}"}.join("\n") rescue nil
+      @printer.print_error $!.backtrace.map{|l| "\t#{l}"}.join("\n") rescue nil
     ensure
       @interface.close
     end
     
     def process_context_commands(input)
       unless Debugger.event_processor.at_line?
-        @printer.print_error "There is no thread suspended at the time and therefore no context to execute '#{input.gsub('%', '%%')}'"    
+        @printer.print_error "There is no thread suspended at the time and therefore no context to execute '#{input.gsub('%', '%%')}'"
         return
       end
       context = Debugger.event_processor.context
       file = Debugger.event_processor.file
-      line = Debugger.event_processor.line 
-      event_cmds = Command.commands.select{|cmd| cmd.event }
+      line = Debugger.event_processor.line
+      event_cmds_classes = Command.commands.select{|cmd| cmd.event}
       state = State.new do |s|
         s.context = context
         s.file    = file
         s.line    = line
         s.binding = context.frame_binding(0)
         s.interface = @interface
-        s.commands = event_cmds
       end
-      commands = event_cmds.map{|cmd| cmd.new(state, @printer) }
+      event_cmds = event_cmds_classes.map{|cmd| cmd.new(state, @printer) }
       catch(:debug_error) do
-        
         splitter[input].each do |input|
           # escape % since print_debug might use printf
           @printer.print_debug "Processing context: #{input.gsub('%', '%%')}"
-          if cmd = commands.find{ |c| c.match(input) }
+          if cmd = event_cmds.find{ |c| c.match(input) }
             if context.dead? && cmd.class.need_context
               @printer.print_msg "Command is unavailable\n"
             else
@@ -93,11 +91,13 @@ module Debugger
         end
       end
     end
-  end    
+  end
+
   class State # :nodoc:
+
     attr_accessor :context, :file, :line, :binding
     attr_accessor :frame_pos, :previous_line
-    attr_accessor :interface, :commands
+    attr_accessor :interface
     
     def initialize
       @frame_pos = 0
@@ -120,10 +120,9 @@ module Debugger
   end
   
   class ControlState # :nodoc:
-    attr_reader :commands
-    def initialize(interface, commands)
+
+    def initialize(interface)
       @interface = interface
-      @commands = commands
     end
     
     def proceed

data/lib/ruby-debug/tags

@@ -0,0 +1,260 @@
+!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_PROGRAM_AUTHOR	Darren Hiebert	/dhiebert@users.sourceforge.net/
+!_TAG_PROGRAM_NAME	Exuberant Ctags	//
+!_TAG_PROGRAM_URL	http://ctags.sourceforge.net	/official site/
+!_TAG_PROGRAM_VERSION	5.7	//
+AddBreakpoint	commands/breakpoints.rb	/^  class AddBreakpoint < Command # :nodoc:$/;"	c	class:Debugger
+BreakpointsCommand	commands/breakpoints.rb	/^  class BreakpointsCommand < Command # :nodoc:$/;"	c
+CatchCommand	commands/catchpoint.rb	/^  class CatchCommand < Command # :nodoc:$/;"	c	class:Debugger
+Command	command.rb	/^  class Command # :nodoc:$/;"	c	class:Debugger
+ConditionCommand	commands/condition.rb	/^  class ConditionCommand < Command # :nodoc:$/;"	c	class:Debugger
+ContinueCommand	commands/stepping.rb	/^  class ContinueCommand < Command # :nodoc:$/;"	c
+ControlCommandProcessor	processor.rb	/^  class ControlCommandProcessor # :nodoc:$/;"	c	class:Debugger
+ControlState	processor.rb	/^  class ControlState # :nodoc:$/;"	c	class:Debugger
+Debugger	command.rb	/^module Debugger$/;"	m
+Debugger	commands/breakpoints.rb	/^module Debugger$/;"	m
+Debugger	commands/catchpoint.rb	/^module Debugger$/;"	m
+Debugger	commands/condition.rb	/^module Debugger$/;"	m
+Debugger	commands/control.rb	/^module Debugger$/;"	m
+Debugger	commands/eval.rb	/^module Debugger$/;"	m
+Debugger	commands/frame.rb	/^module Debugger$/;"	m
+Debugger	commands/inspect.rb	/^module Debugger$/;"	m
+Debugger	commands/load.rb	/^module Debugger$/;"	m
+Debugger	commands/stepping.rb	/^module Debugger$/;"	m
+Debugger	commands/threads.rb	/^module Debugger$/;"	m
+Debugger	commands/variables.rb	/^module Debugger$/;"	m
+Debugger	event_processor.rb	/^ module Debugger$/;"	m
+Debugger	helper.rb	/^module Debugger$/;"	m
+Debugger	interface.rb	/^module Debugger  $/;"	m
+Debugger	processor.rb	/^module Debugger$/;"	m
+Debugger	xml_printer.rb	/^module Debugger$/;"	m
+DeleteBreakpointCommand	commands/breakpoints.rb	/^  class DeleteBreakpointCommand < Command # :nodoc:$/;"	c
+DownCommand	commands/frame.rb	/^  class DownCommand < Command # :nodoc:$/;"	c
+EvalCommand	commands/eval.rb	/^  class EvalCommand < Command # :nodoc:$/;"	c	class:Debugger
+EventProcessor	event_processor.rb	/^   class EventProcessor$/;"	c	class:Debugger
+FinishCommand	commands/stepping.rb	/^  class FinishCommand < Command # :nodoc:$/;"	c
+FrameCommand	commands/frame.rb	/^  class FrameCommand < Command # :nodoc:$/;"	c
+FrameFunctions	commands/frame.rb	/^  module FrameFunctions # :nodoc:$/;"	m	class:Debugger
+InspectCommand	commands/inspect.rb	/^  class InspectCommand < Command$/;"	c	class:Debugger
+InterruptCommand	commands/control.rb	/^  class InterruptCommand < Command # :nodoc:$/;"	c
+LoadCommand	commands/load.rb	/^  class LoadCommand < Command  $/;"	c	class:Debugger
+NextCommand	commands/stepping.rb	/^  class NextCommand < Command # :nodoc:$/;"	c	class:Debugger
+PPCommand	commands/eval.rb	/^  class PPCommand < Command # :nodoc:$/;"	c
+ParseFunctions	helper.rb	/^  module ParseFunctions$/;"	m	class:Debugger
+QuitCommand	commands/control.rb	/^  class QuitCommand < Command # :nodoc:$/;"	c	class:Debugger
+RemoteInterface	interface.rb	/^  class RemoteInterface # :nodoc:$/;"	c	class:Debugger
+RestartCommand	commands/control.rb	/^  class RestartCommand < Command # :nodoc:$/;"	c
+StartCommand	commands/control.rb	/^  class StartCommand < Command # :nodoc:$/;"	c
+State	processor.rb	/^  class State # :nodoc:$/;"	c	class:Debugger
+StepCommand	commands/stepping.rb	/^  class StepCommand < Command # :nodoc:$/;"	c
+TCPSocket	interface.rb	/^class TCPSocket$/;"	c
+ThreadCurrentCommand	commands/threads.rb	/^  class ThreadCurrentCommand < Command # :nodoc:$/;"	c
+ThreadListCommand	commands/threads.rb	/^  class ThreadListCommand < Command # :nodoc:$/;"	c	class:Debugger
+ThreadResumeCommand	commands/threads.rb	/^  class ThreadResumeCommand < Command # :nodoc:$/;"	c
+ThreadStopCommand	commands/threads.rb	/^  class ThreadStopCommand < Command # :nodoc:$/;"	c
+ThreadSwitchCommand	commands/threads.rb	/^  class ThreadSwitchCommand < Command # :nodoc:$/;"	c
+UpCommand	commands/frame.rb	/^  class UpCommand < Command # :nodoc:$/;"	c
+VarConstantCommand	commands/variables.rb	/^  class VarConstantCommand < Command # :nodoc:$/;"	c	class:Debugger
+VarGlobalCommand	commands/variables.rb	/^  class VarGlobalCommand < Command # :nodoc:$/;"	c
+VarInstanceCommand	commands/variables.rb	/^  class VarInstanceCommand < Command # :nodoc:$/;"	c
+VarLocalCommand	commands/variables.rb	/^  class VarLocalCommand < Command # :nodoc:$/;"	c
+WhereCommand	commands/frame.rb	/^  class WhereCommand < Command # :nodoc:$/;"	c	class:Debugger
+XmlPrinter	xml_printer.rb	/^  class XmlPrinter # :nodoc:$/;"	c	class:Debugger
+adjust_frame	commands/frame.rb	/^    def adjust_frame(frame_pos, absolute)$/;"	f	class:Debugger.FrameFunctions
+at_breakpoint	event_processor.rb	/^     def at_breakpoint(context, breakpoint)$/;"	f	class:Debugger.EventProcessor
+at_catchpoint	event_processor.rb	/^     def at_catchpoint(context, excpt)$/;"	f	class:Debugger.EventProcessor
+at_line	event_processor.rb	/^     def at_line(context, file, line)$/;"	f	class:Debugger.EventProcessor
+at_line?	event_processor.rb	/^     def at_line?$/;"	f	class:Debugger.EventProcessor
+at_return	event_processor.rb	/^     def at_return(context, file, line)$/;"	f	class:Debugger.EventProcessor
+at_tracing	event_processor.rb	/^     def at_tracing(context, file, line)$/;"	f	class:Debugger.EventProcessor
+clear_references	commands/inspect.rb	/^    def self.clear_references$/;"	F	class:Debugger.InspectCommand
+close	interface.rb	/^    def close$/;"	f	class:Debugger.RemoteInterface
+commands	command.rb	/^      def commands$/;"	f	class:Debugger.Command
+context	processor.rb	/^    def context$/;"	f	class:Debugger.ControlState
+debug_eval	command.rb	/^    def debug_eval(str, b = get_binding)$/;"	f	class:Debugger
+debug_silent_eval	command.rb	/^    def debug_silent_eval(str)$/;"	f	class:Debugger
+errmsg	command.rb	/^    def errmsg(*args)$/;"	f	class:Debugger
+execute	commands/breakpoints.rb	/^    def execute$/;"	f	class:BreakpointsCommand
+execute	commands/breakpoints.rb	/^    def execute$/;"	f	class:Debugger.AddBreakpoint
+execute	commands/breakpoints.rb	/^    def execute$/;"	f	class:DeleteBreakpointCommand
+execute	commands/catchpoint.rb	/^    def execute$/;"	f	class:Debugger.CatchCommand
+execute	commands/condition.rb	/^    def execute$/;"	f	class:Debugger.ConditionCommand
+execute	commands/control.rb	/^    def execute$/;"	f	class:Debugger.QuitCommand
+execute	commands/control.rb	/^    def execute$/;"	f	class:InterruptCommand
+execute	commands/control.rb	/^    def execute$/;"	f	class:RestartCommand
+execute	commands/control.rb	/^    def execute$/;"	f	class:StartCommand
+execute	commands/eval.rb	/^    def execute$/;"	f	class:Debugger.EvalCommand
+execute	commands/eval.rb	/^    def execute$/;"	f	class:PPCommand
+execute	commands/frame.rb	/^    def execute$/;"	f	class:Debugger.WhereCommand
+execute	commands/frame.rb	/^    def execute$/;"	f	class:DownCommand
+execute	commands/frame.rb	/^    def execute$/;"	f	class:FrameCommand
+execute	commands/frame.rb	/^    def execute$/;"	f	class:UpCommand
+execute	commands/inspect.rb	/^    def execute$/;"	f	class:Debugger.InspectCommand
+execute	commands/load.rb	/^    def execute$/;"	f	class:Debugger.LoadCommand
+execute	commands/stepping.rb	/^    def execute$/;"	f	class:ContinueCommand
+execute	commands/stepping.rb	/^    def execute$/;"	f	class:Debugger.NextCommand
+execute	commands/stepping.rb	/^    def execute$/;"	f	class:FinishCommand
+execute	commands/stepping.rb	/^    def execute$/;"	f	class:StepCommand
+execute	commands/threads.rb	/^    def execute$/;"	f	class:Debugger.ThreadListCommand
+execute	commands/threads.rb	/^    def execute$/;"	f	class:ThreadCurrentCommand
+execute	commands/threads.rb	/^    def execute$/;"	f	class:ThreadResumeCommand
+execute	commands/threads.rb	/^    def execute$/;"	f	class:ThreadStopCommand
+execute	commands/threads.rb	/^    def execute$/;"	f	class:ThreadSwitchCommand
+execute	commands/variables.rb	/^    def execute$/;"	f	class:Debugger.VarConstantCommand
+execute	commands/variables.rb	/^    def execute$/;"	f	class:VarGlobalCommand
+execute	commands/variables.rb	/^    def execute$/;"	f	class:VarInstanceCommand
+execute	commands/variables.rb	/^    def execute$/;"	f	class:VarLocalCommand
+file	processor.rb	/^    def file$/;"	f	class:Debugger.ControlState
+get_binding	command.rb	/^    def get_binding$/;"	f	class:Debugger
+get_context	command.rb	/^    def get_context(thnum)$/;"	f	class:Debugger
+get_int	helper.rb	/^    def get_int(str, cmd, min=nil, max=nil, default=1)$/;"	f	class:Debugger.ParseFunctions
+hbinding	command.rb	/^    def hbinding(hash)$/;"	f	class:Debugger
+help	commands/breakpoints.rb	/^      def help(cmd)$/;"	f	class:BreakpointsCommand
+help	commands/breakpoints.rb	/^      def help(cmd)$/;"	f	class:Debugger.AddBreakpoint
+help	commands/breakpoints.rb	/^      def help(cmd)$/;"	f	class:DeleteBreakpointCommand
+help	commands/catchpoint.rb	/^      def help(cmd)$/;"	f	class:Debugger.CatchCommand
+help	commands/condition.rb	/^      def help(cmd)$/;"	f	class:Debugger.ConditionCommand
+help	commands/control.rb	/^      def help(cmd)$/;"	f	class:Debugger.QuitCommand
+help	commands/control.rb	/^      def help(cmd)$/;"	f	class:InterruptCommand
+help	commands/control.rb	/^      def help(cmd)$/;"	f	class:RestartCommand
+help	commands/control.rb	/^      def help(cmd)$/;"	f	class:StartCommand
+help	commands/eval.rb	/^      def help(cmd)$/;"	f	class:Debugger.EvalCommand
+help	commands/eval.rb	/^      def help(cmd)$/;"	f	class:PPCommand
+help	commands/frame.rb	/^      def help(cmd)$/;"	f	class:Debugger.WhereCommand
+help	commands/frame.rb	/^      def help(cmd)$/;"	f	class:DownCommand
+help	commands/frame.rb	/^      def help(cmd)$/;"	f	class:FrameCommand
+help	commands/frame.rb	/^      def help(cmd)$/;"	f	class:UpCommand
+help	commands/stepping.rb	/^      def help(cmd)$/;"	f	class:ContinueCommand
+help	commands/stepping.rb	/^      def help(cmd)$/;"	f	class:Debugger.NextCommand
+help	commands/stepping.rb	/^      def help(cmd)$/;"	f	class:FinishCommand
+help	commands/stepping.rb	/^      def help(cmd)$/;"	f	class:StepCommand
+help	commands/threads.rb	/^      def help(cmd)$/;"	f	class:Debugger.ThreadListCommand
+help	commands/threads.rb	/^      def help(cmd)$/;"	f	class:ThreadCurrentCommand
+help	commands/threads.rb	/^      def help(cmd)$/;"	f	class:ThreadResumeCommand
+help	commands/threads.rb	/^      def help(cmd)$/;"	f	class:ThreadStopCommand
+help	commands/threads.rb	/^      def help(cmd)$/;"	f	class:ThreadSwitchCommand
+help	commands/variables.rb	/^      def help(cmd)$/;"	f
+help	commands/variables.rb	/^      def help(cmd)$/;"	f	class:Debugger
+help	commands/variables.rb	/^      def help(cmd)$/;"	f	class:VarGlobalCommand
+help	commands/variables.rb	/^      def help(cmd)$/;"	f	class:VarLocalCommand
+help_command	commands/breakpoints.rb	/^      def help_command$/;"	f	class:BreakpointsCommand
+help_command	commands/breakpoints.rb	/^      def help_command$/;"	f	class:Debugger.AddBreakpoint
+help_command	commands/breakpoints.rb	/^      def help_command$/;"	f	class:DeleteBreakpointCommand
+help_command	commands/catchpoint.rb	/^      def help_command$/;"	f	class:Debugger.CatchCommand
+help_command	commands/condition.rb	/^      def help_command$/;"	f	class:Debugger.ConditionCommand
+help_command	commands/control.rb	/^      def help_command$/;"	f	class:Debugger.QuitCommand
+help_command	commands/control.rb	/^      def help_command$/;"	f	class:InterruptCommand
+help_command	commands/control.rb	/^      def help_command$/;"	f	class:RestartCommand
+help_command	commands/control.rb	/^      def help_command$/;"	f	class:StartCommand
+help_command	commands/eval.rb	/^      def help_command$/;"	f	class:Debugger.EvalCommand
+help_command	commands/eval.rb	/^      def help_command$/;"	f	class:PPCommand
+help_command	commands/frame.rb	/^      def help_command$/;"	f	class:Debugger.WhereCommand
+help_command	commands/frame.rb	/^      def help_command$/;"	f	class:DownCommand
+help_command	commands/frame.rb	/^      def help_command$/;"	f	class:FrameCommand
+help_command	commands/frame.rb	/^      def help_command$/;"	f	class:UpCommand
+help_command	commands/stepping.rb	/^      def help_command$/;"	f	class:ContinueCommand
+help_command	commands/stepping.rb	/^      def help_command$/;"	f	class:Debugger.NextCommand
+help_command	commands/stepping.rb	/^      def help_command$/;"	f	class:FinishCommand
+help_command	commands/stepping.rb	/^      def help_command$/;"	f	class:StepCommand
+help_command	commands/threads.rb	/^      def help_command$/;"	f	class:Debugger.ThreadListCommand
+help_command	commands/threads.rb	/^      def help_command$/;"	f	class:ThreadCurrentCommand
+help_command	commands/threads.rb	/^      def help_command$/;"	f	class:ThreadResumeCommand
+help_command	commands/threads.rb	/^      def help_command$/;"	f	class:ThreadStopCommand
+help_command	commands/threads.rb	/^      def help_command$/;"	f	class:ThreadSwitchCommand
+help_command	commands/variables.rb	/^      def help_command$/;"	f
+help_command	commands/variables.rb	/^      def help_command$/;"	f	class:Debugger
+help_command	commands/variables.rb	/^      def help_command$/;"	f	class:VarGlobalCommand
+help_command	commands/variables.rb	/^      def help_command$/;"	f	class:VarLocalCommand
+inherited	command.rb	/^      def inherited(klass)$/;"	f	class:Debugger.Command
+initialize	command.rb	/^    def initialize(state, printer)$/;"	f	class:Debugger
+initialize	event_processor.rb	/^     def initialize(interface)$/;"	f	class:Debugger.EventProcessor
+initialize	interface.rb	/^    def initialize(socket)$/;"	f	class:Debugger.RemoteInterface
+initialize	processor.rb	/^    def initialize$/;"	f	class:Debugger.State
+initialize	processor.rb	/^    def initialize(interface)$/;"	f	class:Debugger.ControlCommandProcessor
+initialize	processor.rb	/^    def initialize(interface)$/;"	f	class:Debugger.ControlState
+initialize	xml_printer.rb	/^    def initialize(interface)$/;"	f	class:Debugger.XmlPrinter
+line_at	command.rb	/^    def line_at(file, line)$/;"	f	class:Debugger
+line_event	event_processor.rb	/^     def line_event(context, file, line)$/;"	f	class:Debugger.EventProcessor
+load_commands	command.rb	/^      def load_commands$/;"	f	class:Debugger.Command
+match	command.rb	/^    def match(input)$/;"	f	class:Debugger
+match	commands/eval.rb	/^    def match(input)$/;"	f	class:Debugger.EvalCommand
+method_missing	command.rb	/^      def method_missing(meth, *args, &block)$/;"	f	class:Debugger.Command
+method_missing	command.rb	/^    def method_missing(meth, *args, &block)$/;"	f	class:Debugger
+non_blocking_gets	interface.rb	/^  def non_blocking_gets$/;"	f	class:TCPSocket
+options	command.rb	/^      def options$/;"	f	class:Debugger.Command
+print	command.rb	/^    def print(*args)$/;"	f	class:Debugger
+print	interface.rb	/^    def print(*args)$/;"	f	class:Debugger.RemoteInterface
+print	processor.rb	/^    def print(*args)$/;"	f	class:Debugger.ControlCommandProcessor
+print	processor.rb	/^    def print(*args)$/;"	f	class:Debugger.ControlState
+print	processor.rb	/^    def print(*args)$/;"	f	class:Debugger.State
+print	xml_printer.rb	/^    def print(*params)$/;"	f
+print_array	xml_printer.rb	/^    def print_array(array)$/;"	f
+print_at_line	xml_printer.rb	/^    def print_at_line(file, line)$/;"	f
+print_breakpoint	xml_printer.rb	/^    def print_breakpoint(n, breakpoint)$/;"	f
+print_breakpoint_added	xml_printer.rb	/^    def print_breakpoint_added(b)$/;"	f
+print_breakpoint_deleted	xml_printer.rb	/^    def print_breakpoint_deleted(b)$/;"	f
+print_breakpoints	xml_printer.rb	/^    def print_breakpoints(breakpoints)$/;"	f
+print_catchpoint	xml_printer.rb	/^    def print_catchpoint(exception)$/;"	f
+print_contdition_set	xml_printer.rb	/^    def print_contdition_set(bp_id)$/;"	f
+print_context	xml_printer.rb	/^    def print_context(context)$/;"	f
+print_contexts	xml_printer.rb	/^    def print_contexts(contexts)$/;"	f
+print_current_frame	xml_printer.rb	/^    def print_current_frame(context, frame_pos)$/;"	f
+print_debug	xml_printer.rb	/^    def print_debug(*args)$/;"	f	class:Debugger
+print_element	xml_printer.rb	/^    def print_element(name)$/;"	f
+print_error	xml_printer.rb	/^    def print_error(*args)$/;"	f	class:Debugger.XmlPrinter
+print_eval	xml_printer.rb	/^    def print_eval(exp, value)$/;"	f
+print_exception	xml_printer.rb	/^    def print_exception(exception, binding)$/;"	f
+print_expression	xml_printer.rb	/^    def print_expression(exp, value, idx)$/;"	f
+print_expressions	xml_printer.rb	/^    def print_expressions(exps)$/;"	f
+print_frame	xml_printer.rb	/^    def print_frame(context, idx, cur_idx)$/;"	f
+print_frames	xml_printer.rb	/^    def print_frames(context, cur_idx)$/;"	f	class:Debugger
+print_hash	xml_printer.rb	/^    def print_hash(hash)$/;"	f
+print_inspect	xml_printer.rb	/^    def print_inspect(eval_result)$/;"	f
+print_list	xml_printer.rb	/^    def print_list(b, e, file, line)$/;"	f
+print_load_result	xml_printer.rb	/^    def print_load_result(file, exception=nil)$/;"	f
+print_methods	xml_printer.rb	/^    def print_methods(methods)$/;"	f
+print_msg	xml_printer.rb	/^    def print_msg(*args)$/;"	f	class:Debugger.XmlPrinter
+print_pp	xml_printer.rb	/^    def print_pp(exp, value)$/;"	f
+print_trace	xml_printer.rb	/^    def print_trace(context, file, line)$/;"	f
+print_variable	xml_printer.rb	/^    def print_variable(name, value, kind)$/;"	f
+print_variables	xml_printer.rb	/^    def print_variables(vars, kind)$/;"	f
+proceed	processor.rb	/^    def proceed$/;"	f	class:Debugger.ControlState
+proceed	processor.rb	/^    def proceed$/;"	f	class:Debugger.State
+proceed?	processor.rb	/^    def proceed?$/;"	f	class:Debugger.State
+process_commands	processor.rb	/^    def process_commands$/;"	f	class:Debugger.ControlCommandProcessor
+process_context_commands	processor.rb	/^    def process_context_commands(input)$/;"	f	class:Debugger.ControlCommandProcessor
+read_command	interface.rb	/^    def read_command$/;"	f	class:Debugger.RemoteInterface
+reference_result	commands/inspect.rb	/^    def self.reference_result(result)$/;"	F	class:Debugger.InspectCommand
+regexp	commands/breakpoints.rb	/^    def regexp$/;"	f	class:BreakpointsCommand
+regexp	commands/breakpoints.rb	/^    def regexp$/;"	f	class:Debugger.AddBreakpoint
+regexp	commands/breakpoints.rb	/^    def regexp$/;"	f	class:DeleteBreakpointCommand
+regexp	commands/catchpoint.rb	/^    def regexp$/;"	f	class:Debugger.CatchCommand
+regexp	commands/condition.rb	/^    def regexp$/;"	f	class:Debugger.ConditionCommand
+regexp	commands/control.rb	/^    def regexp$/;"	f	class:Debugger.QuitCommand
+regexp	commands/control.rb	/^    def regexp$/;"	f	class:InterruptCommand
+regexp	commands/control.rb	/^    def regexp$/;"	f	class:RestartCommand
+regexp	commands/control.rb	/^    def regexp$/;"	f	class:StartCommand
+regexp	commands/eval.rb	/^    def regexp$/;"	f	class:Debugger.EvalCommand
+regexp	commands/eval.rb	/^    def regexp$/;"	f	class:PPCommand
+regexp	commands/frame.rb	/^    def regexp$/;"	f	class:Debugger.WhereCommand
+regexp	commands/frame.rb	/^    def regexp$/;"	f	class:DownCommand
+regexp	commands/frame.rb	/^    def regexp$/;"	f	class:FrameCommand
+regexp	commands/frame.rb	/^    def regexp$/;"	f	class:UpCommand
+regexp	commands/inspect.rb	/^    def regexp$/;"	f	class:Debugger.InspectCommand
+regexp	commands/load.rb	/^    def regexp$/;"	f	class:Debugger.LoadCommand
+regexp	commands/stepping.rb	/^    def regexp$/;"	f	class:ContinueCommand
+regexp	commands/stepping.rb	/^    def regexp$/;"	f	class:Debugger.NextCommand
+regexp	commands/stepping.rb	/^    def regexp$/;"	f	class:FinishCommand
+regexp	commands/stepping.rb	/^    def regexp$/;"	f	class:StepCommand
+regexp	commands/threads.rb	/^    def regexp$/;"	f	class:Debugger.ThreadListCommand
+regexp	commands/threads.rb	/^    def regexp$/;"	f	class:ThreadCurrentCommand
+regexp	commands/threads.rb	/^    def regexp$/;"	f	class:ThreadResumeCommand
+regexp	commands/threads.rb	/^    def regexp$/;"	f	class:ThreadStopCommand
+regexp	commands/threads.rb	/^    def regexp$/;"	f	class:ThreadSwitchCommand
+regexp	commands/variables.rb	/^    def regexp$/;"	f	class:Debugger.VarConstantCommand
+regexp	commands/variables.rb	/^    def regexp$/;"	f	class:VarGlobalCommand
+regexp	commands/variables.rb	/^    def regexp$/;"	f	class:VarInstanceCommand
+regexp	commands/variables.rb	/^    def regexp$/;"	f	class:VarLocalCommand
+splitter	processor.rb	/^    def splitter$/;"	f	class:Debugger.ControlCommandProcessor
+timeout	command.rb	/^    def timeout(sec)$/;"	f	class:Debugger

data/lib/ruby-debug/xml_printer.rb

@@ -136,6 +136,18 @@ module Debugger
       print "<breakpointDeleted no=\"%s\"/>", b.id
     end
     
+    def print_breakpoint_enabled(b)
+      print "<breakpointEnabled bp_id=\"%s\"/>", b.id
+    end
+    
+    def print_breakpoint_disabled(b)
+      print "<breakpointDisabled bp_id=\"%s\"/>", b.id
+    end
+    
+    def print_contdition_set(bp_id)
+      print "<conditionSet bp_id=\"%d\"/>", bp_id
+    end
+    
     def print_expressions(exps)
       print_element "expressions" do
         exps.each_with_index do |(exp, value), idx|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-debug-ide
 version: !ruby/object:Gem::Version 
-  version: 0.1.10
+  version: 0.2.0
 platform: ruby
 authors: 
 - Markus Barchfeld, Martin Krauskopf
@@ -9,7 +9,7 @@ autorequire: ruby-debug-base
 bindir: bin
 cert_chain: []
 
-date: 2008-02-04 00:00:00 +01:00
+date: 2008-06-17 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -19,7 +19,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.10.0
+        version: 0.10.1
     version: 
 description: An interface which glues ruby-debug to IDEs like Eclipse (RDT) and NetBeans.
 email: rubyeclipse-dev-list@sourceforge.net
@@ -30,21 +30,24 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- README
 - bin/rdebug-ide
 - lib/ruby-debug
+- lib/ruby-debug/tags
 - lib/ruby-debug/xml_printer.rb
 - lib/ruby-debug/command.rb
 - lib/ruby-debug/processor.rb
 - lib/ruby-debug/commands
 - lib/ruby-debug/commands/load.rb
 - lib/ruby-debug/commands/breakpoints.rb
+- lib/ruby-debug/commands/tags
 - lib/ruby-debug/commands/variables.rb
 - lib/ruby-debug/commands/control.rb
+- lib/ruby-debug/commands/enable.rb
 - lib/ruby-debug/commands/threads.rb
 - lib/ruby-debug/commands/stepping.rb
 - lib/ruby-debug/commands/eval.rb
 - lib/ruby-debug/commands/catchpoint.rb
+- lib/ruby-debug/commands/condition.rb
 - lib/ruby-debug/commands/frame.rb
 - lib/ruby-debug/commands/inspect.rb
 - lib/ruby-debug/interface.rb
@@ -74,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: debug-commons
-rubygems_version: 1.0.1
+rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
 summary: IDE interface for ruby-debug.