trepanning 1.93.35 → 2.15.33

data/app/markdown.rb

@@ -14,11 +14,6 @@ module Redcarpet
             attr_accessor :width
             attr_accessor :try_ansi
 
-            def strip_term_sequence(text)
-                # to be completed...
-                text
-            end
-
             # reflow text so lines are not
             # longer than @width. prefix
             # is used only after the first line
@@ -29,7 +24,7 @@ module Redcarpet
                 line = ''
                 width = @width - prefix.size
                 text.split.each do |word|
-                    word_size = strip_term_sequence(word).size
+                    word_size = Term::ANSIColor::uncolor(word).size
                     if (line_len + word_size) >= width
                         lines << line
                         line = prefix + word + ' '
@@ -58,7 +53,7 @@ module Redcarpet
 
             def codespan(text)
                 if ansi?
-                    Term::ANSIColor.underline + text + Term::ANSIColor.reset
+                    Term::ANSIColor.underline + text + Term::ANSIColor.reset + "\n"
                 else
                     "'" + text + "'"
                 end
@@ -162,8 +157,6 @@ if __FILE__ == $0
 # HI
 This is a paragraph
 
-A `b`, `c`, d
-
 **This** is another *paragraph*.
 EOF
     [[80, true],

data/app/options.rb

@@ -8,7 +8,7 @@ require 'optparse'
 class Trepan
   require_relative 'default'
 
-  VERSION = '1.93.35'
+  VERSION = '2.15.33'
   PROGRAM = 'trepan'
 
   def self.show_version

data/app/run.rb

@@ -1,9 +1,32 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2010-2013 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010-2013, 2015 Rocky Bernstein <rockyb@rubyforge.net>
 require 'rbconfig'
 module Trepanning
 
-  module_function # All functions below are easily publically accessible
+    class Termination < RuntimeError
+    end
+
+    module_function # All functions below are easily publically accessible
+
+    def run_program(dbgr, program_to_debug)
+        RubyVM::Frame::get.trace_off =  false
+        RubyVM::Frame::get.trace_off1 = true
+        dbgr.core.processor.hidelevels[Thread.current] =
+            RubyVM::Frame.stack_size
+        dbgr.trace_point.enable
+
+        # FIXME: the magic skip count 4 below is to skip over
+        # the following calls triggered by Kernel::load
+        #   c_call   - IO#set_encoding(1)
+        #   c_return - IO#set_encoding -> *debugged program*
+        #   call     - IO#set_encoding(1)
+        #   c_return - IO#set_encoding -> *debugged program*
+        # This is  not very robust. Figure out how to
+        # address this.
+        dbgr.core.step_count = 4
+        Kernel::load program_to_debug
+    end
+
 
   # Given a Ruby interpreter and program we are to debug, debug it.
   # The caller must ensure that ARGV is set up to remove any debugger
@@ -11,50 +34,61 @@ module Trepanning
   # see.  FIXME: Should we make ARGV an explicit parameter?
   def debug_program(dbgr, program_to_debug)
 
-    # Make sure Ruby script syntax checks okay.
-    # Otherwise we get a load message that looks like trepanning has 
-    # a problem. 
-    output = ruby_syntax_errors(program_to_debug)
-    if output
-      puts output
-      exit $?.exitstatus 
-    end
+      # Make sure Ruby script syntax checks okay.
+      # Otherwise we get a load message that looks like trepanning has
+      # a problem.
+      output = ruby_syntax_errors(program_to_debug)
+      if output
+          puts output
+          exit $?.exitstatus
+      end
 
-    dbgr.trace_filter << self.method(:debug_program)
-    dbgr.trace_filter << Kernel.method(:load)
+      # dbgr.trace_filter << self.method(:debug_program)
+      # dbgr.trace_filter << Kernel.method(:load)
+      dbgr.trace_filter << 'debug_program'
+      dbgr.trace_filter << 'load'
 
-    old_dollar_0 = $0
+      old_dollar_0 = $0
 
-    # Without the dance below to set $0, setting it to a signifcantly
-    # longer value will truncate it in some OS's. See
-    # http://www.ruby-forum.com/topic/187083
-    $progname = program_to_debug
-    alias $0 $progname
-    dollar_0_tracker = lambda {|val| $program_name = val} 
-    trace_var(:$0, dollar_0_tracker)
+      # Without the dance below to set $0, setting it to a signifcantly
+      # longer value will truncate it in some OS's. See
+      # http://www.ruby-forum.com/topic/187083
+      $progname = program_to_debug
+      alias $0 $progname
+      dollar_0_tracker = lambda {|val| $program_name = val}
+      trace_var(:$0, dollar_0_tracker)
 
-    dbgr.debugger(:hide_stack=>true) do
-      dbgr.core.processor.hidelevels[Thread.current] = 
-        RubyVM::Frame.current.stack_size + 1
       begin
-        Kernel::load program_to_debug
+          dbgr.start(false)
+          frame = RubyVM::Frame.get
+          while frame do
+              frame.trace_off = true
+              frame = frame.prev
+          end
+          run_program(dbgr, program_to_debug)
+          raise Termination
+      rescue Termination
+          if dbgr.settings[:cmdloop_on_exit]
+              dbgr.stop
+              puts "Program terminated, type q to quit"
+              dbgr.core.processor.process_commands(nil, 0)
+          end
       rescue Interrupt
       end
-    end
 
-    # The dance we have to undo to restore $0 and undo the mess created
-    # above.
-    $0 = old_dollar_0
-    untrace_var(:$0, dollar_0_tracker)
+      # The dance we have to undo to restore $0 and undo the mess created
+      # above.
+      $0 = old_dollar_0
+      untrace_var(:$0, dollar_0_tracker)
   rescue
-    if dbgr.settings[:post_mortem]
-      frame = RubyVM::Frame.current.prev(0)
-      dbgr.core.step_count = 0  # Make event processor stop
-      dbgr.core.processor.settings[:debugstack] = 0  # Make event processor stop
-      dbgr.core.event_processor('post-mortem', frame, $!)
-    else
+      if dbgr.settings[:post_mortem]
+          frame = RubyVM::Frame.get
+          dbgr.core.step_count = 0  # Make event processor stop
+          dbgr.core.processor.settings[:debugstack] = 0  # Make event processor stop
+          dbgr.core.event_processor('post-mortem', frame, $!)
+      else
       raise
-    end
+      end
   end
 
   # Do a shell-like path lookup for prog_script and return the results.
@@ -97,7 +131,7 @@ if __FILE__ == $0
   puts whence_file('irb')
   puts whence_file('probably-does-not-exist')
   puts RbConfig.ruby
-  puts "#{__FILE__} is syntactically correct" unless 
+  puts "#{__FILE__} is syntactically correct" unless
     ruby_syntax_errors(__FILE__)
   readme = File.join(File.dirname(__FILE__), '..', 'README.textile')
   puts "#{readme} is not syntactically correct" if

data/interface/script.rb

@@ -16,7 +16,7 @@ class Trepan::ScriptInterface < Trepan::Interface
     :confirm_val    => false,
     :verbose        => false
   } unless defined?(DEFAULT_OPTS)
-  
+
   def initialize(script_name, out=nil, opts={})
 
     @opts = DEFAULT_OPTS.merge(opts)
@@ -24,7 +24,7 @@ class Trepan::ScriptInterface < Trepan::Interface
     at_exit { finalize }
     @script_name     = script_name
     @input_lineno    = 0
-    @input           = opts[:input] || 
+    @input           = opts[:input] ||
       Trepan::UserInput.open(script_name, :line_edit => false)
     @buffer_output   = []
     unless @opts[:verbose] or out
@@ -35,7 +35,7 @@ class Trepan::ScriptInterface < Trepan::Interface
 
   # Closes input only.
   def close
-    @input.close
+    # @input.close unless @input.closed?
   end
 
   # Called when a dangerous action is about to be done, to make
@@ -48,7 +48,7 @@ class Trepan::ScriptInterface < Trepan::Interface
   end
 
   # Common routine for reporting debugger error messages.
-  # 
+  #
   def errmsg(msg, prefix="*** ")
     #  self.verbose shows lines so we don't have to duplicate info
     #  here. Perhaps there should be a 'terse' mode to never show
@@ -67,8 +67,8 @@ class Trepan::ScriptInterface < Trepan::Interface
   end
 
   def interactive? ; false end
-    
-  # Script interface to read a command. `prompt' is a parameter for 
+
+  # Script interface to read a command. `prompt' is a parameter for
   # compatibilty and is ignored.
   def read_command(prompt='')
     @input_lineno += 1
@@ -81,12 +81,12 @@ class Trepan::ScriptInterface < Trepan::Interface
     return line
   end
 
-  # Script interface to read a line. `prompt' is a parameter for 
+  # Script interface to read a line. `prompt' is a parameter for
   # compatibilty and is ignored.
   #
   # Could decide make this look for interactive input?
   def readline(prompt='')
-    begin 
+    begin
       return input.readline().chomp
     rescue EOFError
       @eof = true

data/io.rb

@@ -2,11 +2,11 @@
 # classes to support communication to and from the debugger.  This
 # communcation might be to/from another process or another computer.
 # And reading may be from a debugger command script.
-# 
+#
 # For example, we'd like to support Sockets, and serial lines and file
 # reading, as well a readline-type input. Encryption and Authentication
 # methods might decorate some of the communication channels.
-# 
+#
 # Some ideas originiated as part of Matt Fleming's 2006 Google Summer of
 # Code project.
 
@@ -14,7 +14,7 @@ class Trepan
 
   NotImplementedMessage = 'This method must be overriden in a subclass' unless
     defined?(NotImplementedMessage)
-  
+
   class InputBase
     attr_reader   :input
     attr_reader   :line_edit
@@ -30,10 +30,10 @@ class Trepan
     end
 
     def close
-      @input.close unless @input.closed?
+        @input.close unless @input.closed?
     end
 
-    def eof? 
+    def eof?
       begin
         @input.eof?
       rescue IOError
@@ -41,7 +41,7 @@ class Trepan
       end
     end
 
-    # Read a line of input. EOFError will be raised on EOF.  
+    # Read a line of input. EOFError will be raised on EOF.
     #
     #   Note that we don't support prompting first. Instead, arrange
     #  to call Trepan::Output.write() first with the prompt. If
@@ -69,7 +69,7 @@ class Trepan
       @eof = true
     end
 
-    def eof? 
+    def eof?
       @eof
     end
 
@@ -77,7 +77,7 @@ class Trepan
       @output.flush
     end
 
-    # Use this to set where to write to. output can be a 
+    # Use this to set where to write to. output can be a
     # file object or a string. This code raises IOError on error.
     def write(*args)
       @output.print(*args)
@@ -95,17 +95,17 @@ class Trepan
   # handled by the same channel, e.g. a socket or tty.
   #
   class InOutBase
-    
+
     def initialize(inout, opts={})
       @opts = DEFAULT_OPTS.merge(opts)
       @inout = inout
     end
-    
+
     def close
       @inout.close() if @inout
     end
-    
-    def eof? 
+
+    def eof?
       begin
         @input.eof?
       rescue IOError
@@ -116,9 +116,9 @@ class Trepan
     def flush
       @inout.flush
     end
-    
-    # Read a line of input. EOFError will be raised on EOF.  
-    # 
+
+    # Read a line of input. EOFError will be raised on EOF.
+    #
     # Note that we don't support prompting first. Instead, arrange to
     # call DebuggerOutput.write() first with the prompt. If `use_raw'
     # is set raw_input() will be used in that is supported by the
@@ -128,15 +128,15 @@ class Trepan
       @input.readline
     end
 
-    # Use this to set where to write to. output can be a 
+    # Use this to set where to write to. output can be a
     # file object or a string. This code raises IOError on error.
-    # 
-    # Use this to set where to write to. output can be a 
+    #
+    # Use this to set where to write to. output can be a
     # file object or a string. This code raises IOError on error.
     def write(*args)
       @inout.write(*args)
     end
-    
+
     # used to write to a debugger that is connected to this
     # server; `str' written will have a newline added to it
     def writeline( msg)
@@ -145,4 +145,3 @@ class Trepan
   end
 
 end
-

data/lib/trepanning.rb

@@ -1,8 +1,7 @@
 #!/usr/bin/env ruby
 # -*- coding: utf-8 -*-
-# Copyright (C) 2010-2012 Rocky Bernstein <rockyb@rubyforge.net>
-require 'trace'                          # Trace filtering
-require 'thread_frame'                   # Stack frame introspection and more.
+# Copyright (C) 2010-2012, 2015 Rocky Bernstein <rockyb@rubyforge.net>
+require 'set'
 require_relative '../app/complete'       # command completion
 require_relative '../app/core'           # core event-handling mechanism
 require_relative '../app/default'        # default debugger settings
@@ -11,13 +10,13 @@ require_relative '../interface/script'   # --command interface (includes I/O)
 require_relative '../interface/client'   # client interface (remote debugging)
 require_relative '../interface/server'   # server interface (remote debugging)
 
-# SCRIPT_ISEQS__ is like SCRIPT_LINES__ in a patched Ruby 1.9. Setting
-# this variable to a hash causes instruction sequences to be added in
-# this has under their "filename" as a key. More accurately though,
-# the "filename" is instruction sequence name that was given as in the
-# "filename" parameter when the instruction sequence was
-# generated. Each value is an array of instruction sequences that
-# share that name.
+# SCRIPT_ISEQS__ is like SCRIPT_LINES__ in a patched Ruby
+# 1.9/2.1. Setting this variable to a hash causes instruction
+# sequences to be added in this has under their "filename" as a
+# key. More accurately though, the "filename" is instruction sequence
+# name that was given as in the "filename" parameter when the
+# instruction sequence was generated. Each value is an array of
+# instruction sequences that share that name.
 SCRIPT_ISEQS__ = {} unless
     defined?(SCRIPT_ISEQS__) && SCRIPT_ISEQS__.is_a?(Hash)
 ISEQS__        = {} unless
@@ -25,318 +24,314 @@ ISEQS__        = {} unless
 
 class Trepan
 
-  attr_reader   :completion_proc # GNU Readline completion proc
-  attr_accessor :core         # access to Trepan::Core instance
-  attr_accessor :intf         # Array. The way the outside world
-                              # interfaces with us.  An array, so that
-                              # interfaces can be stacked.
-  attr_accessor :restart_argv # How to restart us, empty or nil.
-                              # Note: restart_argv is typically C's
-                              # **argv, not Ruby's ARGV. So
-                              # restart_argv[0] is $0.
-  attr_reader   :settings     # Hash[:symbol] of things you can configure
-  attr_accessor :trace_filter # Procs/Methods we ignore.
-
-  def initialize(settings={})
-
-    # FIXME: Tracing through intialization code is slow. Need to figure
-    # out better ways to do this.
-    th = Thread.current
-    th.exec_event_tracing = true
-
-    @settings = Trepan::DEFAULT_SETTINGS.merge(settings)
-    @input  = @settings[:input] || STDIN
-    @output = @settings[:output] || STDOUT
-
-    @completion_proc = method(:completion_method)
-
-    @intf =
-      if @settings[:server]
-        @completion_proc = nil
-        opts = Trepan::ServerInterface::DEFAULT_INIT_CONNECTION_OPTS.dup
-        opts[:port] = @settings[:port] if @settings[:port]
-        opts[:host] = @settings[:host] if @settings[:host]
+    attr_reader   :completion_proc # GNU Readline completion proc
+    attr_accessor :core         # access to Trepan::Core instance
+    attr_accessor :intf         # Array. The way the outside world
+                                # interfaces with us.  An array, so that
+                                # interfaces can be stacked.
+    attr_accessor :restart_argv # How to restart us, empty or nil.
+                                # Note: restart_argv is typically C's
+                                # **argv, not Ruby's ARGV. So
+                                # restart_argv[0] is $0.
+    attr_reader   :settings     # Hash[:symbol] of things you can configure
+    attr_accessor :trace_filter # Procs/Methods we ignore.
+    attr_accessor :trace_point  # Trace point object
+
+    def initialize(settings={})
+        @trace_point = nil
+        @trace_filter = Set.new()
+        @settings = Trepan::DEFAULT_SETTINGS.merge(settings)
+        @input  = @settings[:input] || STDIN
+        @output = @settings[:output] || STDOUT
+
+        @completion_proc = method(:completion_method)
+
+        @intf =
+            if @settings[:server]
+                @completion_proc = nil
+                opts = Trepan::ServerInterface::DEFAULT_INIT_CONNECTION_OPTS.dup
+                opts[:port] = @settings[:port] if @settings[:port]
+                opts[:host] = @settings[:host] if @settings[:host]
         opts[:readline] = false
-        puts("starting debugger in out-of-process mode port at " +
-             "#{opts[:host]}:#{opts[:port]}")
-        [Trepan::ServerInterface.new(nil, nil, opts)]
-      elsif @settings[:client]
-        opts = Trepan::ClientInterface::DEFAULT_INIT_CONNECTION_OPTS.dup
-        opts[:port] = @settings[:port] if @settings[:port]
-        opts[:host] = @settings[:host] if @settings[:host]
-        opts[:complete] = @completion_proc
-        user_opts = @settings[:user_opts] || {}
-        [Trepan::ClientInterface.new(nil, nil, nil, user_opts, opts)]
-      else
-        opts = {:complete => @completion_proc,
+                puts("starting debugger in out-of-process mode port at " +
+                     "#{opts[:host]}:#{opts[:port]}")
+                [Trepan::ServerInterface.new(nil, nil, opts)]
+            elsif @settings[:client]
+                opts = Trepan::ClientInterface::DEFAULT_INIT_CONNECTION_OPTS.dup
+                opts[:port] = @settings[:port] if @settings[:port]
+                opts[:host] = @settings[:host] if @settings[:host]
+                opts[:complete] = @completion_proc
+                user_opts = @settings[:user_opts] || {}
+                [Trepan::ClientInterface.new(nil, nil, nil, user_opts, opts)]
+            else
+                opts = {:complete => @completion_proc,
                 :readline => @settings[:readline]}
-        [Trepan::UserInterface.new(@input, @output, opts)]
-      end
+                [Trepan::UserInterface.new(@input, @output, opts)]
+            end
 
-    process_cmdfile_setting(@settings)
+        process_cmdfile_setting(@settings)
 
-    # FIXME: The below option settings is a big crock.
-    @settings[:core_opts][:cmdproc_opts] ||= {}
-    @settings[:core_opts][:cmdproc_opts][:highlight] ||= settings[:highlight]
-    @settings[:core_opts][:cmdproc_opts][:traceprint] = settings[:traceprint]
-    @settings[:core_opts][:cmdproc_opts][:basename] = settings[:basename]
+        # FIXME: The below option settings is a big crock.
+        @settings[:core_opts][:cmdproc_opts] ||= {}
+        @settings[:core_opts][:cmdproc_opts][:basename] = settings[:basename]
+        @settings[:core_opts][:cmdproc_opts][:highlight] ||= settings[:highlight]
+        @settings[:core_opts][:cmdproc_opts][:traceprint] = settings[:traceprint]
 
-    @core = Core.new(self, @settings[:core_opts])
+        if settings[:traceprint]
+            @settings[:cmdloop_on_exit] = false
+        end
 
-    if @settings[:initial_dir]
-      Dir.chdir(@settings[:initial_dir])
-    else
-      @settings[:initial_dir] = Dir.pwd
-    end
-    @initial_dir  = @settings[:initial_dir]
-    @restart_argv = @settings[:restart_argv]
-
-    unless @settings[:client]
-      @trace_filter = Trace::Filter.new
-      %w(debugger start stop).each do |m|
-        @trace_filter << self.method(m.to_sym)
-      end
-      %w(debugger event_processor trace_var_processor).each do
-        |m|
-        @trace_filter << @core.method(m)
-      end
-      @trace_filter << @trace_filter.method(:add_trace_func)
-      @trace_filter << @trace_filter.method(:remove_trace_func)
-      @trace_filter << Kernel.method(:add_trace_func)
-    end
+        @core = Core.new(self, @settings[:core_opts])
+
+        if @settings[:initial_dir]
+            Dir.chdir(@settings[:initial_dir])
+        else
+            @settings[:initial_dir] = Dir.pwd
+        end
+        @initial_dir  = @settings[:initial_dir]
+        @restart_argv = @settings[:restart_argv]
+
+        unless @settings[:client]
+            %w(debugger stop).each do |m|
+                @trace_filter << self.method(m.to_sym)
+            end
+            %w(debugger event_processor trace_var_processor).each do
+                |m|
+                # FIXME
+                # @trace_filter << @core.method(m)
+                @trace_filter << m
+            end
+        end
+
+        # Run user debugger command startup files.
+        add_startup_files unless @settings[:nx]
 
-    # Run user debugger command startup files.
-    add_startup_files unless @settings[:nx]
 
-    at_exit do
-      clear_trace_func
-      @intf[-1].close
+        at_exit do
+            RubyVM::Frame::get.trace_off = true
+            stop
+            @intf[-1].close
+        end
     end
-    th.exec_event_tracing = false
-  end
-
-  # The method is called when we want to do debugger command completion
-  # such as called from GNU Readline with <TAB>.
-  def completion_method(last_token, leading=Readline.line_buffer)
-    completion = @core.processor.complete(leading, last_token)
-    if 1 == completion.size
-      completion_token = completion[0]
-      if last_token.end_with?(' ')
-        if last_token.rstrip == completion_token
-          # There is nothing more to complete
-          []
+
+    # The method is called when we want to do debugger command completion
+    # such as called from GNU Readline with <TAB>.
+    def completion_method(last_token, leading=Readline.line_buffer)
+        completion = @core.processor.complete(leading, last_token)
+        if 1 == completion.size
+            completion_token = completion[0]
+            if last_token.end_with?(' ')
+                if last_token.rstrip == completion_token
+                    # There is nothing more to complete
+                    []
+                else
+                    []
+                end
+            else
+                [completion_token]
+            end
+        else
+            # We have multiple completions. Get the last token so that will
+            # be presented as a list of completions.
+            completion
+        end
+    end
+
+    # To call from inside a Ruby program, there is one-time setup that
+    # needs to be done first:
+    #    require 'trepanning'
+    #    mydbg = Trepan.new()
+    # which will tell the debugger how to "restart" the program.
+    #
+    # If you want a synchronous stop in your program call to the
+    # debugger at the point of the call, set opts[:immediate]
+    # true. Example:
+    #
+    #    ... work, work, work
+    #    mydbg.debugger(:immediate=>true)   # enter debugger here
+    #    ... work, work, work
+    #
+    # However to enter the debugger on the next event after the
+    # debugger() call:
+    #
+    #    ... work, work, work
+    #    mydbg.debugger  # Don't stop here...
+    #    work            # but stop here.
+    #
+    # And finally, if you want to debug just a block:
+    #   mydbg.debugger {
+    #     ... code you want to debug.
+    #   }
+    #
+    # Some options
+
+    #   :immediate -  boolean. If true, immediate stop rather than wait
+    #                          for an event
+    #
+    #   :hide_stack - boolean. If true, omit stack frames before the
+    #                          debugger call
+    #
+    #   :debugme    - boolean. Allow tracing into this routine. You
+    #                          generally won't want this. It slows things
+    #                          down horribly.
+
+    def debugger(opts={}, &block)
+        # FIXME: one option we may want to pass is the initial trace
+        # filter.
+        if opts[:hide_stack]
+            @core.processor.hidelevels[Thread.current] =
+                RubyVM::Frame.get.stack_size
+        end
+        # unless defined?(PROG_UNRESOLVED_SCRIPT)
+        #  # We may later do more sophisticated things...
+        #  Trepan.const_set('PROG_UNRESOLVED_SCRIPT', RubyVM::OS_ARGV.index($0) ? $0 : nil)
+        # end
+        th = Thread.current
+        if block
+            @trace_point = TracePoint.new() do |tp|
+                @core.event_processor_tp(tp)
+            end
+            RubyVM::Frame::get.trace_off1 = true
+            @trace_point.enable
+            yield block
+            RubyVM::Frame::get.trace_off = true
+            @trace_point.disable
+            @trace_point = nil
         else
-          []
+            @trace_point = TracePoint.new() do |tp|
+                @core.event_processor_tp(tp)
+            end
+            RubyVM::Frame::get.trace_off1 = true
+            @trace_point.enable
         end
-      else
-        [completion_token]
-      end
-    else
-      # We have multiple completions. Get the last token so that will
-      # be presented as a list of completions.
-      completion
     end
-  end
-
-  # To call from inside a Ruby program, there is one-time setup that
-  # needs to be done first:
-  #    require 'trepanning'
-  #    mydbg = Trepan.new()
-  # which will tell the debugger how to "restart" the program.
-  #
-  # If you want a synchronous stop in your program call to the
-  # debugger at the point of the call, set opts[:immediate]
-  # true. Example:
-  #
-  #    ... work, work, work
-  #    mydbg.debugger(:immediate=>true)   # enter debugger here
-  #    ... work, work, work
-  #
-  # However to enter the debugger on the next event after the
-  # debugger() call:
-  #
-  #    ... work, work, work
-  #    mydbg.debugger  # Don't stop here...
-  #    work            # but stop here.
-  #
-  # And finally, if you want to debug just a block:
-  #   mydbg.debugger {
-  #     ... code you want to debug.
-  #   }
-  #
-  # Some options
-
-  #   :immediate -  boolean. If true, immediate stop rather than wait
-  #                          for an event
-  #
-  #   :hide_stack - boolean. If true, omit stack frames before the
-  #                          debugger call
-  #
-  #   :debugme    - boolean. Allow tracing into this routine. You
-  #                          generally won't want this. It slows things
-  #                          down horribly.
-
-  def debugger(opts={}, &block)
-    # FIXME: one option we may want to pass is the initial trace filter.
-    if opts[:hide_stack]
-      @core.processor.hidelevels[Thread.current] =
-        RubyVM::Frame.current.stack_size
+
+    # Set core's trace-event processor to run
+    def start(enable = false)
+        @trace_point = TracePoint.new() do |tp|
+            @core.event_processor_tp(tp)
+        end
+        RubyVM::Frame::get.trace_off1 = true
+        @trace_point.enable if enable
     end
-    # unless defined?(PROG_UNRESOLVED_SCRIPT)
-    #  # We may later do more sophisticated things...
-    #  Trepan.const_set('PROG_UNRESOLVED_SCRIPT', RubyVM::OS_ARGV.index($0) ? $0 : nil)
-    # end
-    th = Thread.current
-    if block
-      start
-      ret = block.call
-      stop
-      return ret
-    elsif opts[:immediate]
-      # Stop immediately after this method returns. But if opts[:debugme]
-      # is set, we can stop in this method.
-      RubyVM::Frame::current.trace_off = true unless opts[:debugme]
-      @trace_filter.set_trace_func(@core.event_proc)
-      Trace.event_masks[0] |= @core.step_events
-      @core.debugger(1)
-    else
-      RubyVM::Frame::current.trace_off = true unless opts[:debugme]
-
-      @trace_filter.set_trace_func(@core.event_proc)
-      Trace.event_masks[0] |= @core.step_events
-
-      # Set to stop on the next event after this returns.
-      @core.step_count = opts[:step_count] || 0
+
+    def stop
+        RubyVM::Frame::get.trace_off = true
+        @trace_point.disable if @trace_point and
+            @trace_point.respond_to?(:disable)
     end
-  end
-
-  # Set core's trace-event processor to run
-  def start
-    @trace_filter.add_trace_func(@core.event_proc)
-  end
-
-  # Remove all of our trace events
-  def stop(opts={})
-    # FIXME: should do something in the middle when
-    # we have the ability to remove *our* specific hook
-    # @trace_filter.set_trace_func(nil)
-    # @trace_filter.remove_trace_func
-    clear_trace_func
-  end
-
-  def add_command_file(cmdfile, stderr=$stderr)
-    unless File.readable?(cmdfile)
-      if File.exists?(cmdfile)
-        stderr.puts "Command file '#{cmdfile}' is not readable."
-        return
-      else
-        stderr.puts "Command file '#{cmdfile}' does not exist."
-        return
-      end
+
+    def add_command_file(cmdfile, opts={}, stderr=$stderr)
+        unless File.readable?(cmdfile)
+            if File.exists?(cmdfile)
+                stderr.puts "Command file '#{cmdfile}' is not readable."
+                return
+            else
+                stderr.puts "Command file '#{cmdfile}' does not exist."
+                return
+            end
+        end
+        @intf << Trepan::ScriptInterface.new(cmdfile, opts[:out])
     end
-    @intf << Trepan::ScriptInterface.new(cmdfile)
-  end
-
-  def add_startup_files()
-    seen = {}
-    cwd_initfile = File.join('.', Trepan::CMD_INITFILE_BASE)
-    [cwd_initfile, Trepan::CMD_INITFILE].each do |initfile|
-      full_initfile_path = File.expand_path(initfile)
-      next if seen[full_initfile_path]
-      add_command_file(full_initfile_path) if File.readable?(full_initfile_path)
-      seen[full_initfile_path] = true
+
+    def add_startup_files()
+        seen = {}
+        cwd_initfile = File.join('.', Trepan::CMD_INITFILE_BASE)
+        [cwd_initfile, Trepan::CMD_INITFILE].each do |initfile|
+            full_initfile_path = File.expand_path(initfile)
+            next if seen[full_initfile_path]
+            add_command_file(full_initfile_path) if File.readable?(full_initfile_path)
+            seen[full_initfile_path] = true
+        end
     end
-  end
 
-  def process_cmdfile_setting(settings)
-    settings[:cmdfiles].each do |item|
-      cmdfile, opts =
-        if item.kind_of?(Array)
-          item
-        else
-          [item, {}]
+    def process_cmdfile_setting(settings)
+        settings[:cmdfiles].each do |item|
+            cmdfile, opts =
+                if item.kind_of?(Array)
+                    item
+                else
+                    [item, {:out => @output}]
+                end
+            add_command_file(cmdfile, opts)
+        end if settings.member?(:cmdfiles)
+    end
+
+    # As a simplification for creating a debugger object, and then
+    # calling using the object to invoke the debugger, we allow this
+    # two-step process in one step. That is, instead of
+    #
+    #  require 'trepanning'
+    #  mydbg = Trepan.new()
+    #  ...
+    #  mydbg.debugger
+
+    # You can run:
+    #  require 'trepanning'
+    # ...
+    #  Trepan.debug
+    #
+    # See debugger for options that can be passed. By default :hide_stack is
+    # set.
+    #
+    # Likewise for mydbg.debugger{ ... }
+
+    def self.debug(opts={}, &block)
+        opts = {:hide_stack => false}.merge(opts)
+        unless defined?($trepanning) && $trepanning.is_a?(Trepan)
+            $trepanning = Trepan.new(opts)
         end
-      add_command_file(cmdfile, opts)
-    end if settings.member?(:cmdfiles)
-  end
-
-  # As a simplification for creating a debugger object, and then
-  # calling using the object to invoke the debugger, we allow this
-  # two-step process in one step. That is, instead of
-  #
-  #  require 'trepanning'
-  #  mydbg = Trepan.new()
-  #  ...
-  #  mydbg.debugger
-
-  # You can run:
-  #  require 'trepanning'
-  # ...
-  #  Trepan.debug
-  #
-  # See debugger for options that can be passed. By default :hide_stack is
-  # set.
-  #
-  # Likewise for mydbg.debugger{ ... }
-
-  def self.debug(opts={}, &block)
-    opts = {:hide_stack => false}.merge(opts)
-    unless defined?($trepanning) && $trepanning.is_a?(Trepan)
-      $trepanning = Trepan.new(opts)
+        $trepanning.debugger(opts, &block)
+    end
+
+    def self.debug_str(string, opts = DEFAULT_DEBUG_STR_SETTINGS)
+        $trepanning = Trepan.new(opts) unless
+            $trepanning && $trepanning.is_a?(Trepan)
+        $trepanning.core.processor.settings[:different] = false
+        # Perhaps we should do a remap file to string right here?
+        $trepanning.debugger(opts) { eval(string) }
     end
-    tf = $trepanning.trace_filter
-    tf << self.method(:debugger) unless tf.member? self.method(:debugger)
-    $trepanning.debugger(opts, &block)
-  end
-
-  def self.debug_str(string, opts = DEFAULT_DEBUG_STR_SETTINGS)
-    $trepanning = Trepan.new(opts) unless
-      $trepanning && $trepanning.is_a?(Trepan)
-    $trepanning.core.processor.settings[:different] = false
-    # Perhaps we should do a remap file to string right here?
-    $trepanning.debugger(opts) { eval(string) }
-  end
 end
 
 module Kernel
-  # Same as Trepan.debug.
-  # FIXME figure out a way to remove duplication.
-  def debugger(opts={}, &block)
-    opts = {:hide_stack => false}.merge(opts)
-    unless defined?($trepanning) && $trepanning.is_a?(Trepan)
-      $trepanning = Trepan.new(opts)
+    # Same as Trepan.debug.
+    # FIXME figure out a way to remove duplication.
+    def debugger(opts={}, &block)
+        opts = {:hide_stack => false}.merge(opts)
+        unless defined?($trepanning) && $trepanning.is_a?(Trepan)
+            $trepanning = Trepan.new(opts)
+        end
+        tf = $trepanning.trace_filter
+        tf << self.method(:debugger) unless tf.member? self.method(:debugger)
+        $trepanning.debugger(opts)
     end
-    tf = $trepanning.trace_filter
-    tf << self.method(:debugger) unless tf.member? self.method(:debugger)
-    $trepanning.debugger(opts)
-  end
 end
 
 if __FILE__ == $0
-  def square(x) # :nodoc
-    x * x
-  end
-  puts 'block debugging...'
-  # It is imagined that there are all sorts of command-line options here.
-  # (I have a good imagination.)
-  Trepan.debug {
-    a = 2
-    b = square(a)
-    p "square of #{a} is #{b}"
-  }
-
-  puts 'immediate debugging...'
-  $trepanning.debugger(:immediate => true)
-  puts 'line after immediate'
-  a = 3
-  square(a)
-
-  class MyClass
-    def initialize(x)
-      @x = x
+    def square(x) # :nodoc
+        x * x
+    end
+    puts 'block debugging...'
+    # It is imagined that there are all sorts of command-line options here.
+    # (I have a good imagination.)
+    Trepan.debug {
+        a = 2
+        b = square(a)
+        p "square of #{a} is #{b}"
+    }
+
+    puts 'immediate debugging (not)...'
+    $trepanning.debugger # (:immediate => true) # no immediate for now
+    puts 'line after immediate'
+    a = 3
+    square(a)
+
+    class MyClass
+        def initialize(x)
+            @x = x
+        end
     end
-  end
-  $trepanning.debugger
-  m = MyClass.new(5)
-  raise RuntimeError # To see how we handle post-mortem debugging.
+    $trepanning.debugger
+    m = MyClass.new(5)
+    raise RuntimeError # To see how we handle post-mortem debugging.
 end