trepanning 1.93.35 → 2.15.33

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (C) 2010  Rocky Bernstein <rockyb@rubyforge.org>
+Copyright (C) 2010, 2015  Rocky Bernstein <rockyb@rubyforge.org>
 All rights reserved.
  *
 Redistribution and use in source and binary forms, with or without

data/NEWS

@@ -1,22 +1,26 @@
-(1.93.40) Mar 12, 2015
-- remove stray space after backtick in markdown
-- list command continues where it last left off
-- empty debugger command repeats last command
-- Use markdown in Gem description
+(2.15.33) Mar 8, 2015
 
-(1.93.32) Mar 8, 2015
-- Remove reference to threadframe
-
-(1.93.31) Mar 8, 2015
-
-- Remove threadframe dependency - it's built into patched Ruby
+- Remove threadframe dependency - it's built into patched Ruby, replace with
+  rubyvm-frame.rb
 - add dependencies for coderay and ansi-termcolor
 - More subcommand help converted to markdown format.
 
-(1.93.30) Mar 5, 2015
-- Make it work on a patched Ruby 1.9.3 p551
-- include columnize and linecache-tf gems
+(2.15.30) Mar 5, 2015
+- Make it work on a patched Ruby 2.1.5 with runtime debugger support
+  This means:
+    * high-speed breakpoints, "step over" (next), and "step out" (finish)
+    * when stopped in a C function, we can get parameter values
+    * the source location of C functions is memory address (gdb can
+      use this)
+    * VM inspection, including sp, pc, instruction sequences,
+      and local table
+    * can change return values in Ruby code, often
+    * can see/set the runtime event masks debugger triggers on
+    * can get the eval string when stopped in an eval()
 - Help text is rendered via redcloth/markdown
+- When we are in a raise event which is non-local, indicate that
+- Remove aliases 'd' and 'u' for "down" and "up"; gdb has different meanings for
+  these letters
 
 (0.1.6) Nov 25, 2012
 - Make it work on Ruby 1.9.3 p327

data/README.md

@@ -1,4 +1,4 @@
-The trepanning debugger gdb-like debugger. As such, it is both a high-level and low-level debugger. It is a also a rewrite of *ruby-debug*. But to provide all of the functionality that it has, it requires a patched version of MRI Ruby 1.9.3 or 1.9.2 found the [rb-threadframe project](https://rocky/rb-threadframe). The additional run-time support in the MRI is what gives this some debugger power that you won't find in other MRI 1.9 debuggers.
+The trepanning debugger gdb-like debugger. As such, it is both a high-level and low-level debugger. It is a also a rewrite of *ruby-debug*. But to provide all of the functionality that it has, it requires a patched version of MRI Ruby 2.1.5, 1.9.3 or 1.9.2 found the [ruby-debugger-runtime project](https://sourceforge.net/projects/ruby-debugger-runtime/). The additional run-time support in the MRI is what gives this [powerful features](https://github.com/rocky/rb-trepanning/wiki/Cool-things) that you won't find in other MRI 2.1 or 1.9 debuggers that don't use this runtime.
 
 See the [installation instructions](https://github.com/rocky/rb-trepanning/wiki/How-to-Install-rb-trepanning).
 
@@ -36,27 +36,10 @@ The return value from Trepan is the return value of the block, i.e. the final va
 You can run the same thing inside your Ruby program, but probably you don't want to give a block. Instead, you may want to have debugging start on the next statement in the code:
 
 ```ruby
- require 'trepan'
- Trepan.debug # Don't stop here...
- work # but stop here.
+require 'trepanning'
+...
+debugger # stop here
 ```
 
-The above is really shorthand for something like:
 
-```ruby
-  $trepan = Trepan.new
-  $trepan.debugger
-```
-
-The global variable *$trepan* set holds debugger settings, such as `autolist` or `autoeval` settings and breakpoint information.
-
-Due to the line-event orientation in ruby-debug, it occasionally was convenient to add a synchronous stop in your program. I don't think that will be necessary here, but if you do call to the debugger at the point of the call rather than the subsequent stopping point, set opts[:immediate] to true. Example:
-
-```ruby
-
- # ... work, work, work
- mydbg.debugger(:immediate=>true) # enter debugger here
- # ... work, work, work
-```
-
-There is extensive on-line help. Run `help` inside the debugger.
+There is extensive on-line help, much in markdown format that displays nicely in a terminal. Run `help` inside the debugger.

data/Rakefile

@@ -1,12 +1,33 @@
 #!/usr/bin/env rake
 # -*- Ruby -*-
 require 'rubygems'
+require 'rbconfig'
 
-ROOT_DIR = File.dirname(__FILE__)
 GEM_PROG = ENV['GEM_PROG'] || 'gem'
+ROOT_DIR = File.dirname(__FILE__)
 Gemspec_filename='trepanning.gemspec'
 require_relative './app/options'
 
+unless defined? RubyVM::Frame and RbConfig::CONFIG.member?('rb-threadframe')
+    raise RuntimeError,
+    'This package is for MRI Ruby 2.1.5 with debugger runtime support!\nDownload from ' +
+        'http://downloads.sourceforge.net/project/ruby-debugger-runtime/ruby-2.1/'
+end
+
+ruby_version = RbConfig::CONFIG['RUBY_PROGRAM_VERSION']
+if ruby_version == '1.9.3'
+    raise RuntimeError,
+    "This is version trepanning #{Trepan::VERSION}. " +
+    "Ruby #{ruby_version} you want version 1.93..."
+elsif ruby_version == '1.9.2'
+    raise RuntimeError,
+    "This is version trepanning #{Trepan::VERSION}. " +
+    "Ruby #{ruby_version} you want version 1.92..."
+elsif ruby_version != '2.1.5'
+    raise RuntimeError,
+    "This package only works on version Ruby version 2.1.5. You have #{ruby_version}."
+end
+
 def gemspec
   @gemspec ||= eval(File.read(Gemspec_filename), binding, Gemspec_filename)
 end

data/app/breakpoint.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2010-2011, 2013, 2015 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010-2011, 2013,2015 Rocky Bernstein <rockyb@rubyforge.net>
 
 # Breakpoint objects
 class Trepan
@@ -11,7 +11,8 @@ class Trepan
                              # we want to (also) record hits independent
                              # of the condition?
     attr_reader   :id        # Fixnum. Name of breakpoint
-    attr_reader   :ignore    # Fixnum. Number of times encountered to ignore
+    attr_reader   :ignore    # Fixnum. Number of times to ignore
+                             # before triggering
     attr_reader   :iseq      # Instruction sequence associated with this
                              # breakpoint. From this we can derive
                              # information such as source location.
@@ -62,8 +63,9 @@ class Trepan
         @id = @@next_id
         @@next_id += 1
       end
+
       raise RuntimeError,
-      "Unable to set breakpoint in #{iseq.name} at offset #{offset}" unless set
+      "Unable to set breakpoint in #{iseq.name} at offset #{@offset}" unless set
     end
 
     def condition?(bind)

data/app/core.rb

@@ -1,203 +1,171 @@
 # -*- coding: utf-8 -*-
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
-require 'thread_frame'
-require 'trace'
-# require_relative '../../rb-trace/app/trace'
+# Copyright (C) 2010, 2014-2015 Rocky Bernstein <rockyb@rubyforge.net>
+
+require 'set'
 require_relative '../processor'
-class Trepan
-  # This class contains the Trepan core routines, such as an event
-  # processor which is responsible of handling what to do when an event is
-  # triggered.
-  #
-  # See also 'rdbgr' the top-level Trepan class and command-line routine
-  # which ultimately will call this.
-
-  class Core
-    attr_accessor :async_events # bitmask of asyncronous events - used all
-                                # the time
-    attr_reader   :dbgr         # Trepan instance
-    attr_reader   :event        # String - event which triggering event
-                                # processor
-    attr_reader   :event_proc   # Proc of method event_processor
-    attr_accessor :exception    # Return exception to pass back. A 'raise'
-                                # command can set this.
-    attr_reader   :frame        # ThreadFrame instance
-    attr_reader   :hook_arg     # 'arg' passed from trace hook
-    attr_accessor :mutex        # mutex to lock out other threads from
-                                # entering debugger while we are in it.
-    attr_accessor :processor    # Trepan::CmdProc instance
-    attr_reader   :settings     # Hash of things you can configure
-    attr_accessor :step_count   # Fixnum. Negative means no tracing,
-                                # 0 means stop on next event, 1 means
-                                # ignore one event. Step events gives the
-                                # kind of things to count as a step.
-    attr_accessor :step_events  # bitmask of events - used only when
-                                # we are stepping
-    attr_accessor :unmaskable_events
-
-    include Trace
-
-    unless defined?(CORE_DEFAULT_SETTINGS)
-      # Synchronous events
-      STEPPING_EVENT_MASK =
-        LINE_EVENT_MASK     | CLASS_EVENT_MASK    | CALL_EVENT_MASK     |
-        RETURN_EVENT_MASK   | C_CALL_EVENT_MASK   | C_RETURN_EVENT_MASK |
-        INSN_EVENT_MASK     | BRKPT_EVENT_MASK    | YIELD_EVENT_MASK    |
-        LEAVE_EVENT_MASK    | SEND_EVENT_MASK
-
-      ASYNC_EVENT_MASK =
-        RAISE_EVENT_MASK    | VM_EVENT_MASK       | SWITCH_EVENT_MASK
-
-      CORE_DEFAULT_SETTINGS = {
-        :cmdproc_opts      => {},
-        :debug_core_events => false,
-        :hook_name         => :event_processor, # or :old_event_processor
-        :step_count        => 0,                # Stop at next event
-        :async_events      => ASYNC_EVENT_MASK,
-
-        # Not sure what the "right" set really is. The below is just
-        # a guess. Use "set events" or customize in ~/.trepanrc
-        :step_events       =>
-#	(DEFAULT_EVENT_MASK | INSN_EVENT_MASK) &
-	(DEFAULT_EVENT_MASK ) &
-	~(C_CALL_EVENT_MASK | C_RETURN_EVENT_MASK | SEND_EVENT_MASK)
-      }
 
-    end
+class Trepan
+    # This class contains the Trepan core routines, such as an event
+    # processor which is responsible of handling what to do when an event is
+    # triggered.
+    #
+    # See also lib/trepanning.rb, the top-level Trepan class, and command-line routine
+    # bin/trepan which ultimately will call this.
+
+    class Core
+        attr_accessor :async_events # bitmask of asyncronous events - used all
+                                    # the time
+        attr_reader   :dbgr         # Trepan instance
+        attr_reader   :event        # String - event which triggering event
+                                    # processor
+        attr_reader   :event_proc   # Proc of method event_processor
+        attr_accessor :exception    # Return exception to pass back. A 'raise'
+                                    # command can set this.
+        attr_reader   :frame        # ThreadFrame instance
+        attr_reader   :hook_arg     # 'arg' passed from trace hook
+        attr_accessor :mutex        # mutex to lock out other threads from
+                                    # entering debugger while we are in it.
+        attr_accessor :processor    # Trepan::CmdProc instance
+        attr_reader   :settings     # Hash of things you can configure
+        attr_accessor :step_count   # Fixnum. Negative means no tracing,
+                                    # 0 means stop on next event, 1 means
+                                    # ignore one event. Step events gives the
+                                    # kind of things to count as a step.
+        attr_accessor :top_skip     # Number of top frames to ignore
+        attr_accessor :step_events  # bitmask of events - used only when
+                                    # we are stepping
+        attr_accessor :unmaskable_events
+        attr_reader :trace_point
+
+        unless defined?(CORE_DEFAULT_SETTINGS)
+            # Synchronous events
+            STEPPING_EVENTS = Set.new([:line, :class, :call, :return, :c_call,
+                                       :c_return, :raise, :b_call, :b_return,
+                                       :thread_begin, :thread_end, :brkpt])
+            ASYNC_EVENTS = Set.new([:raise])
+
+            CORE_DEFAULT_SETTINGS = {
+                :cmdproc_opts      => {},
+                :debug_core_events => false,
+                :hook_name         => :event_processor,
+                :step_count        => 0,                # Stop at next event
+                :async_events      => ASYNC_EVENTS,
+
+                # Not sure what the "right" set really is. The below is just
+                # a guess. Use "set events" or customize in ~/.trepanrc
+                :step_events       => STEPPING_EVENTS - [:c_call, :c_return]
+            }
 
-    def initialize(debugger, settings={})
-      @dbgr         = debugger
-      @exception    = nil
-      @mutex        = Mutex.new
-      @settings     = CORE_DEFAULT_SETTINGS.merge(settings)
-
-      @step_count   = @settings[:step_count]
-      @step_events  = @settings[:step_events]
-      @async_events = @settings[:async_events]
-      @debug_events = @settings[:debug_core_events]
-
-      hook_name     = @settings[:hook_name]
-      @event_proc   = self.method(hook_name).to_proc
-      @processor    = CmdProcessor.new(self, @settings[:cmdproc_opts])
-      @unmaskable_events = %w(brkpt raise switch vm)
-      @current_thread = nil
-    end
+        end
 
-    def step_events_list
-      if 0 == @step_events
-        return nil
-      else
-        Trace.bitmask2events(@step_events).join(', ')
-      end
-    end
+        def initialize(debugger, settings={})
+            @dbgr         = debugger
+            @exception    = nil
+            @mutex        = Mutex.new
+            @settings     = CORE_DEFAULT_SETTINGS.merge(settings)
+
+            @step_count   = @settings[:step_count]
+            @step_events  = @settings[:step_events]
+            @async_events = @settings[:async_events]
+            @debug_events = @settings[:debug_core_events]
+
+            hook_name     = @settings[:hook_name]
+            @event_proc   = self.method(hook_name).to_proc
+            @processor    = CmdProcessor.new(self, @settings[:cmdproc_opts])
+            @unmaskable_events = %w(brkpt raise switch vm)
+            @current_thread = nil
+            @top_skip    = 0
+            @trace_point = nil
+        end
 
-    # A trace-hook processor with the interface a trace hook should have.
-    def event_processor(event, frame, arg=nil)
+        def step_events_list
+            if @trace_point
+                @trace_point.event_mask
+            else
+                nil
+            end
+        end
 
-      return_exception = nil
-      # FIXME: check for breakpoints or other unmaskable events.
-      # For now there are none.
+        # A trace-hook processor for tracepoints
+        def event_processor_tp(tp)
+            ## FIXME: tracepoint has an arg param. Figure out how to use it.
+            @trace_point = tp
+            # RubyVM::Frame.get.frame.trace_off = true
+            # p @trace_point
+            # p @trace_point.event, @trace_point.frame.source_location
+            retval = event_processor(tp.frame, tp.event)
+            @trace_point = nil
+            return retval
+        end
 
-      return if @mutex.locked? and Thread.current == @current_thread
+        # A trace-hook processor with the interface a trace hook should have.
+        def event_processor(frame, event, hook_arg=nil)
 
-      @mutex.synchronize do
-        @current_thread = Thread.current
-        @frame = frame
-        while @frame.type == 'IFUNC'
-          @frame = @frame.prev
-        end
+            return_exception = nil
+            # FIXME: check for breakpoints or other unmaskable events.
+            # For now there are none.
 
-        if @step_count > 0
-          @step_count -= 1
-          break
-        elsif @step_count < 0 && ! @unmaskable_events.member?(event)
-          break
-        end
+            return if @mutex.locked? and Thread.current == @current_thread
 
-        @event    = event
-        @hook_arg = arg
-
-        ### debug:
-        ### puts "#{frame.file[1]}:#{frame.source_location[0]}:in `#{frame.method}' #{event}" # if %w(line).member?(event)
-        @processor.process_commands(@frame)
-
-        # FIXME: There should be a Trace.event_mask which should return the first
-        # mask that matches the given trace hook.
-        if @step_count < 0
-          # If we are continuing, no need to stop at stepping events.
-          Trace.event_masks[0] &= ~STEPPING_EVENT_MASK
-        else
-          # Set to trace only those events we are interested in.
-
-          # Don't step/trace into Ruby routines called from here in the code
-          # below (e.g. "trace_hooks").
-          step_count_save = step_count
-          @step_count     = -1
-
-          unless @event_proc == dbgr.trace_filter.hook_proc
-            dbgr.trace_filter.add_trace_func(@event_proc)
-            ## debug: p '+++1', @event_proc, dbgr.trace_filter.hook_proc
-          end
-
-          # FIXME: this doesn't work. Bug in rb-trace?
-          # Trace.event_masks[0] = @step_events | @async_events
-          RubyVM::TraceHook::trace_hooks[0].event_mask =
-            @step_events | @async_events
-          @step_count = step_count_save
-        end
+            @mutex.synchronize do
+                @current_thread = Thread.current
+                @frame = frame
 
-        # Nil out variables just in case...
+                if dbgr.trace_filter.member?(@frame.method)
+                    # puts "Not tracing #{@frame.method}"
+                    return
+                 end
 
-        return_exception = @exception
-        @frame = @event = @arg = @exception = nil
+                if @step_count > 0
+                    @step_count -= 1
+                    break
+                elsif @step_count < 0 && ! @unmaskable_events.member?(event.to_s)
+                    break
+                end
 
-      end
-      return return_exception
-    end
+                @event    = event
+                @hook_arg = hook_arg
 
-    # A Ruby 1.8-style event processor. We don't use file, line, id, bind.
-    def old_event_processor(event, file, line, id, bind, klass)
-      event_processor(event, RubyVM::Frame.current.prev)
-    end
+                ### debug:
+                ### puts "#{frame.file[1]}:#{frame.source_location[0]}:in `#{frame.method}' #{event}"
+                # if %w(line).member?(event)
+                @processor.process_commands(@frame, top_skip)
 
-    # Call this from inside the program you want to get a synchronous
-    # call to the debugger. set prev_count to the number of levels
-    # *before* the caller you want to skip.
-    def debugger(prev_count=0)
-      while @frame && @frame.type == 'IFUNC'
-        @frame = @frame.prev
-      end
-      frame = RubyVM::Frame.current.prev(prev_count+1)
-      @step_count = 0  # Make event processor stop
-      event_processor('debugger-call', frame)
-    end
+                # Nil out variables just in case...
 
-    # A trace-hook processor for 'trace var'
-    def trace_var_processor(var_name, value)
-      frame = RubyVM::Frame.current.prev(2)
-      if 'CFUNC' == frame.type
-        # Don't need the C call that got us here.
-        prev = frame.prev
-        frame = frame.prev if prev
-      end
+                return_exception = @exception
+                @frame = @event = @arg = @exception = nil
+                @top_skip = 0
+            end
+            return return_exception
+        end
 
-      # Stop future tracing into the debugger
-      Thread.current.tracing = true
+        # A trace-hook processor for 'trace var'
+        def trace_var_processor(var_name, value)
+            frame = RubyVM::Frame.get
+            frame.trace_off = true
+            frame.prev.trace_off = true
+            # We need to skip this frame and the lamdba that in trace_var()
+            # and a C call() in that lambda. See command/watchg.rb
+            frame = RubyVM::Frame.get(3)
+
+            @step_count = 0  # Make event processor stop
+            event_processor(frame,  'trace-var', [var_name, value])
+        end
 
-      @step_count = 0  # Make event processor stop
-      event_processor('trace-var', frame, [var_name, value])
     end
-
-  end
 end
 if __FILE__ == $0
-  require_relative '../lib/trepanning'
-  dbg = Trepan.new()
-  if ARGV.size > 0
-    def foo(dbg)
-      p 'foo here'
-      dbg.debugger(:immediate=>true)
+    require_relative '../lib/trepanning'
+    dbg = Trepan.new()
+    if ARGV.size > 0
+        def foo(dbg)
+            p 'foo here'
+            dbg.debugger
+        end
+        foo(dbg)
+        x = 5
+        y = File.basename("foo.rb", ".rb")
+        puts "yeah"
     end
-    foo(dbg)
-  end
 end