trepanning 0.1.0 → 0.1.1

data/processor/location.rb

@@ -1,5 +1,6 @@
 # Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 require 'linecache'
+require 'pathname'  # For cleanpath
 require_relative 'msg'
 require_relative '../app/frame'
 class Trepan
@@ -19,7 +20,18 @@ class Trepan
       # For now we want resolved filenames 
       @settings[:basename] ? File.basename(filename) : 
         # Cache this?
-        Pathname.new(filename).cleanpath.to_s
+        File.expand_path(Pathname.new(filename).cleanpath.to_s)
+    end
+
+    # Return the text to the current source line.
+    # FIXME: loc_and_text should call this rather than the other
+    # way around.
+    def current_source_text
+      opts = {:reload_on_change => @reload_on_change}
+      junk1, junk2, text, found_line = 
+        loc_and_text('', frame, frame.source_location[0], 
+                     frame.source_container, opts)
+      text
     end
 
     def resolve_file_with_dir(path_suffix)
@@ -41,11 +53,11 @@ class Trepan
 
     # Get line +line_number+ from file named +filename+. Return ''
     # if there was a problem. Leading blanks are stripped off.
-    def line_at(filename, line_number) # :nodoc:
-      opts = {
-        :reload_on_change => @reload_on_change,
-        :output => @settings[:highlight]
-      }
+    def line_at(filename, line_number,
+                opts = {
+                  :reload_on_change => @reload_on_change,
+                  :output => @settings[:highlight]
+                })
       line = LineCache::getline(filename, line_number, opts)
 
       unless line
@@ -61,12 +73,16 @@ class Trepan
       line ? line.lstrip.chomp : line
     end
 
-    def loc_and_text(loc, frame, line_no, source_container)
+    def loc_and_text(loc, frame, line_no, source_container,
+                     opts = {
+                       :reload_on_change => @reload_on_change,
+                       :output => @settings[:highlight]
+                     })
       found_line = true
       ## FIXME: condition is too long.
       if source_container[0] == 'string' && frame.iseq && frame.iseq.eval_source
         file = LineCache::map_iseq(frame.iseq)
-        text = LineCache::getline(frame.iseq, line_no)
+        text = LineCache::getline(frame.iseq, line_no, opts)
         loc += " remapped #{canonic_file(file)}:#{line_no}"
       elsif source_container[0] != 'file'
         via = loc
@@ -78,7 +94,7 @@ class Trepan
           line_no      = frame.source_location[0]
           filename     = source_container[1]
           loc         += " via #{canonic_file(filename)}:#{line_no}"
-          text         = line_at(filename, line_no)
+          text         = line_at(filename, line_no, opts)
           found_line   = false
         end
       else
@@ -88,7 +104,7 @@ class Trepan
           loc += " remapped #{canonic_file(map_file)}:#{map_line}"
         end
         
-        text  = line_at(container, line_no)
+        text  = line_at(container, line_no, opts)
       end
       [loc, line_no, text, found_line]
     end
@@ -154,3 +170,38 @@ class Trepan
 
   end
 end
+
+if __FILE__ == $0 && caller.size == 0 && ARGV.size > 0
+  # Demo it.
+  require 'thread_frame'
+  require_relative 'frame'
+  require_relative '../app/mock'
+  require_relative 'main'   # Have to include before defining CmdProcessor!
+                            # FIXME
+  class Trepan::CmdProcessor
+    def errmsg(msg)
+      puts msg
+    end
+    def print_location
+      puts "#{@frame.source_container} #{frame.source_location[0]}"
+    end
+  end
+
+  proc = Trepan::CmdProcessor.new(Trepan::MockCore.new())
+  proc.instance_variable_set('@settings', {})
+  proc.frame_initialize
+  proc.frame_setup(RubyVM::ThreadFrame.current)
+  proc.frame_initialize
+
+  proc.location_initialize
+  puts proc.canonic_file(__FILE__)
+  proc.instance_variable_set('@settings', {:basename => true})
+  puts proc.canonic_file(__FILE__)
+  puts proc.current_source_text
+  xx = eval <<-END
+     proc.frame_initialize
+     proc.frame_setup(RubyVM::ThreadFrame.current)
+     proc.location_initialize
+     proc.current_source_text
+  END
+end

data/processor/main.rb

@@ -3,7 +3,6 @@
 # command class and debugger command objects are pulled in from here.
 
 require 'set'
-require 'pathname'  # For cleanpath
 
 %w(default breakpoint display eventbuf eval load_cmds location frame hook msg 
    running validate).each do
@@ -33,6 +32,8 @@ class Trepan
                                    # next stop while settings is the default
                                    # value to use.
     attr_accessor :event           # Stop event. Same as @core.event
+    attr_reader   :intf            # Current interface
+                                   # Trepan::Core instance)
     attr_accessor :leave_cmd_loop  # Commands set this to signal to leave
                                    # the command loop (which often continues to 
                                    # run the debugged program). 
@@ -63,6 +64,8 @@ class Trepan
         'c-call'         => 'C>',
         'c-return'       => '<C',
         'call'           => '->',
+        'send'           => '=>',
+        'leave'          => '<=',
         'class'          => '::',
         'coverage'       => '[]',
         'debugger-call'  => ':o',
@@ -75,6 +78,7 @@ class Trepan
         'unknown'        => '?!',
         'vm'             => 'VM',
         'vm-insn'        => '..',
+        'yield'          => '<>',
       } 
       # These events are important enough event that we always want to
       # stop on them.
@@ -138,6 +142,10 @@ class Trepan
       
     end
 
+    def finalize
+      breakpoint_finalize
+    end
+
     # Check that we meed the criteria that cmd specifies it needs
     def ok_for_running(cmd, name, nargs)
       # TODO check execution_set against execution status.
@@ -170,13 +178,14 @@ class Trepan
     # Run one debugger command. True is returned if we want to quit.
     def process_command_and_quit?()
       intf_size = @dbgr.intf.size
-      intf  = @dbgr.intf[-1]
-      return true if intf.input_eof? && intf_size == 1
-      while intf_size > 1 || !intf.input_eof?
+      @intf  = @dbgr.intf[-1]
+      return true if @intf.input_eof? && intf_size == 1
+      while intf_size > 1 || !@intf.input_eof?
         begin
           @current_command = 
             if @cmd_queue.empty?
-              read_command.strip
+              # Leave trailing blanks on for the "complete" command
+              read_command.chomp 
             else
               @cmd_queue.shift
             end
@@ -193,7 +202,7 @@ class Trepan
           if intf_size > 1
             @dbgr.intf.pop
             intf_size = @dbgr.intf.size
-            intf = @dbgr.intf[-1]
+            @intf = @dbgr.intf[-1]
             @last_command = nil
             print_location
           else
@@ -205,6 +214,9 @@ class Trepan
         end
       end
       run_command(@current_command)
+
+      # Save it to the history.
+      @intf.history_io.puts @last_command if @last_command && @intf.history_io
     end
 
     # This is the main entry point.
@@ -240,7 +252,12 @@ class Trepan
           @dbgr.stop
           raise
         rescue Exception => exc
-          errmsg("Internal debugger error: #{exc.inspect}")
+          # If we are inside the script interface errmsg may fail.
+          begin
+            errmsg("Internal debugger error: #{exc.inspect}")
+          rescue
+            $stderr.puts "Internal debugger error: #{exc.inspect}"
+          end
           exception_dump(exc, @settings[:debugexcept], $!.backtrace)
         end
       end
@@ -269,12 +286,13 @@ class Trepan
           macro_cmd_name = args[0]
           return false if args.size == 0
           break unless @macros.member?(macro_cmd_name)
-          current_command = @macros[macro_cmd_name].call(*args[1..-1])
-          msg current_command if settings[:debugmacro]
-          # FIXME: should handle nested Array as a new command.
+          current_command = @macros[macro_cmd_name][0].call(*args[1..-1])
+          msg current_command.inspect if settings[:debugmacro]
           if current_command.is_a?(Array) && 
               current_command.all? {|val| val.is_a?(String)}
-            args = current_command
+            args = (first=current_command.shift).split
+            @cmd_queue += current_command
+            current_command = first
           elsif current_command.is_a?(String)
             args = current_command.split
           else
@@ -337,6 +355,7 @@ if __FILE__ == $0
   cmdproc.errmsg('Whoa!')
   cmds = cmdproc.commands
   p cmdproc.aliases
+  p cmdproc.commands.keys.sort
   cmd_name, cmd_obj = cmds.first
   puts cmd_obj.class.const_get(:HELP)
   puts cmd_obj.class.const_get(:SHORT_HELP)

data/processor/mock.rb

@@ -70,13 +70,13 @@ module MockDebugger
     def cmd.confirm(prompt, default)
       true
     end
-    def cmd.errmsg(message)
+    def cmd.errmsg(message, opts={})
       puts "Error: #{message}"
     end
-    def cmd.msg(message)
+    def cmd.msg(message, opts={})
       puts message
     end
-    def cmd.msg_nocr(message)
+    def cmd.msg_nocr(message, opts={})
       print message
     end
     def cmd.section(message, opts={})
@@ -91,6 +91,7 @@ module MockDebugger
     sub_name = sub_class.const_get('PREFIX')
     dbgr, cmd = setup(sub_name[0], false)
     cmd.proc.frame_setup(RubyVM::ThreadFrame::current.prev)
+    cmd.proc.event = 'debugger-call'
     sub_cmd = sub_class.new(cmd)
     sub_cmd.summary_help(sub_cmd.name)
     puts
@@ -103,6 +104,7 @@ module MockDebugger
     subsub_name = subsub_class.const_get('PREFIX')
     dbgr, cmd = setup(subsub_name[0], false)
     cmd.proc.frame_setup(RubyVM::ThreadFrame::current.prev)
+    cmd.proc.event = 'debugger-call'
     sub_cmd = sub_class.new(dbgr.core.processor, cmd)
     subsub_cmd = subsub_class.new(cmd.proc, sub_cmd, subsub_name.join(''))
     subsub_cmd.summary_help(subsub_cmd.name)

data/processor/msg.rb

@@ -3,6 +3,8 @@
 require_relative '../app/util'
 class Trepan
   class CmdProcessor
+    attr_accessor :ruby_highlighter
+
     def errmsg(message, opts={})
       message = safe_rep(message) unless opts[:unlimited]
       if @settings[:highlight] && defined?(Term::ANSIColor)
@@ -26,6 +28,20 @@ class Trepan
       @dbgr.intf[-1].read_command(@prompt)
     end
 
+    def ruby_format(text)
+      return text unless settings[:highlight]
+      unless @ruby_highlighter
+        begin
+          require 'coderay'
+          require 'term/ansicolor'
+          @ruby_highlighter = CodeRay::Duo[:ruby, :term]
+        rescue LoadError
+          return text
+        end
+      end
+      return @ruby_highlighter.encode(text)
+    end
+
     def safe_rep(str)
       Util::safe_repr(str, @settings[:maxstring])
     end
@@ -38,5 +54,6 @@ class Trepan
       end
       @dbgr.intf[-1].msg(message)
     end
+
   end
 end

data/processor/running.rb

@@ -33,7 +33,7 @@ class Trepan
       step(0, opts)
       @next_level        = @frame.stack_size - level_count
       @next_thread       = Thread.current
-      @stop_events       = Set.new(%w(return))
+      @stop_events       = Set.new(%w(return leave yield))
 
       # Try high-speed (run-time-assisted) method
       @frame.trace_off   = true  # No more tracing in this frame

data/processor/subcmd.rb

@@ -1,10 +1,11 @@
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 # gdb-like subcommand processing.
 
 class Trepan
   class Subcmd
 
-    attr_reader :subcmds
+    attr_reader :subcmds  # Hash of subcommands. Key is the subcommand name.
+                          # the value is the subcommand object to run.
     def initialize(cmd)
       @cmd     = cmd
       @subcmds = {}

data/processor/validate.rb

@@ -1,10 +1,11 @@
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 
 # Trepan command input validation routines.  A String type is
 # usually passed in as the argument to validation routines.
 
 require_relative '../app/condition'
 require_relative '../app/file'
+require_relative '../app/cmd_parse'
 require_relative '../app/thread'
 
 require_relative 'location' # for resolve_file_with_dir
@@ -21,7 +22,7 @@ class Trepan
     include Trepan::Condition
 
     def confirm(msg, default)
-      @dbgr.intf[-1].confirm(msg, default)
+      @settings[:confirm] ? @dbgr.intf[-1].confirm(msg, default) : true
     end
 
     # Like cmdfns.get_an_int(), but if there's a stack frame use that
@@ -74,10 +75,10 @@ class Trepan
       end
       
       if val < opts[:min_value]
-        if cmdname
+        if opts[:cmdname]
           errmsg(("Command '%s' expects an integer at least" +
                   ' %d; got: %d.') %
-                 [cmdname, opts[:min_value], opts[:default]])
+                 [opts[:cmdname], opts[:min_value], opts[:default]])
         else
           errmsg(("Expecting a positive integer at least" +
                   ' %d; got: %d') %
@@ -135,92 +136,101 @@ class Trepan
       # FIXME: do something if there is more than one.
       if iseqs.size == 1
          iseqs[-1]
-      elsif debug_eval_no_errmsg("#{object_string}.respond_to?('iseq')")
-        debug_eval_no_errmsg("#{object_string}.iseq")
+      elsif meth = method?(object_string)
+        meth.iseq
       else
-        parts = object_string.split(/[.]/)
-        string = 
-          if parts.size < 2 
-            "method(\"#{object_string}\").iseq"
-          else
-            parts[0..-2].join('.')+".method(\"#{parts[-1]}\").iseq"
-          end
-        debug_eval_no_errmsg(string)
+        nil
       end
     rescue
       nil
     end
 
-    def parse_num_or_offset(position_str)
-      opts = {
-        :msg_on_error => 
-        "argument '%s' does not seem to eval to a method or an integer." % 
-        position_str,
-        :min_value => 0 
-      }
-      use_offset = 
-        if position_str.size > 0 && position_str[0].downcase == 'o'
-          position_str[0] = ''
-          true
+    def position_to_line_and_offset(iseq, filename, position, offset_type)
+      case offset_type
+      when :line
+        if ary = iseq.lineoffsets[position]
+          # Normally the first offset is a trace instruction and doesn't
+          # register as the given line, so we need to take the next instruction
+          # after the first one, when available.
+          vm_offset = ary.size > 1 ? ary[1] : ary[0]
+          line_no   = position
+        elsif found_iseq = find_iseqs_with_lineno(filename, position)
+          return position_to_line_and_offset(found_iseq, filename, position, 
+                                             offset_type)
+        elsif found_iseq = find_iseq_with_line_from_iseq(iseq, position)
+          return position_to_line_and_offset(found_iseq, filename, position, 
+                                             offset_type)
         else
-          false
+          errmsg("Unable to find offset for line #{position}\n\t" + 
+                 "in #{iseq.name} of file #{filename}")
+          return [nil, nil]
         end
-      position = get_an_int(position_str, opts)
-      [position, use_offset]
+      when :offset
+        if ary=iseq.offset2lines(position)
+          line_no   = ary.first
+          vm_offset = position
+        else
+          errmsg "Unable to find line for offset #{position} in #{iseq}"
+          return [nil, nil]
+        end
+      when nil
+        vm_offset = 0
+        line_no   = iseq.offset2lines(vm_offset).first
+      else
+        errmsg "Bad parse offset_type: #{offset_type.inspect}"
+        return [nil, nil]
+      end
+      return [iseq, line_no, vm_offset]
     end
 
-    # Parse a breakpoint position. Return
-    # - the position - a Fixnum
-    # - the instruction sequence to use
-    # - whether the position is an offset or a line number
-    # - the condition (by default 'true') to use for this breakpoint
-    def breakpoint_position(args)
-      first = args.shift
-      name, container, position = parse_position(first, nil, true)
-      if container && position
-        iseq = find_iseqs_with_lineno(container[1], position) || object_iseq(first)
-        unless iseq
-          if @frame.iseq && 
-              File.basename(@frame.iseq.source_container[1]) == 
-              File.basename(container[1])
-            iseq = @frame.iseq
-          else
-            errmsg("Unable to find instruction sequence for" + 
-                   " position #{position} in #{container[1]}")
-            return [nil, nil, nil, true]
+    # Parse a breakpoint position. On success return:
+    #   - the instruction sequence to use
+    #   - the line number - a Fixnum
+    #   - vm_offset       - a Fixnum
+    #   - the condition (by default 'true') to use for this breakpoint
+    #   - true condition should be negated. Used in *condition* if/unless
+    def breakpoint_position(position_str, allow_condition)
+      break_cmd_parse = if allow_condition
+                          parse_breakpoint(position_str)
+                        else
+                          parse_breakpoint_no_condition(position_str)
+                        end
+      return [nil] * 5 unless break_cmd_parse
+      tail = [break_cmd_parse.condition, break_cmd_parse.negate]
+      meth_or_frame, file, position, offset_type = 
+        parse_position(break_cmd_parse.position)
+      if meth_or_frame
+        if iseq = meth_or_frame.iseq
+          iseq, line_no, vm_offset = 
+            position_to_line_and_offset(iseq, file, position, offset_type)
+          if vm_offset && line_no
+            return [iseq, line_no, vm_offset] + tail
           end
-        end
-        if args.empty? || 'if' == args[0]
-          use_offset = false 
         else
-          position, use_offset = parse_num_or_offset(args[0])
+          errmsg("Unable to set breakpoint in #{meth_or_frame}")
         end
-      else
-        iseq = object_iseq(first)
-        position_str = 
+      elsif file && position
+        if :line == offset_type
+          iseq = find_iseqs_with_lineno(file, position)
           if iseq
-            # Got name and possibly position
-            name = first
-            if args.empty? 
-              # FIXME: *Still* have a bug stopping at offset 0.
-              # So stop at next offset after 0.
-              # 'o0' 
-              "o#{@frame.iseq.offsetlines.keys.sort[1]}"
-            else
-              args.shift
-            end
+            junk, line_no, vm_offset = 
+              position_to_line_and_offset(iseq, file, position, offset_type)
+            return [@frame.iseq, line_no, vm_offset] + tail
           else
-            iseq = @frame.iseq unless container
-            first
+            errmsg("Unable to find instruction sequence for" + 
+                   " position #{position} in #{file}")
           end
-        position, use_offset = parse_num_or_offset(position_str)
-      end
-      condition = 'true'
-      if args.size > 0 && 'if' == args[0] 
-        condition_try = args[1..-1].join(' ')
-        condition = condition_try if valid_condition?(condition_try)
+        else
+          errmsg "Come back later..."
+        end
+      elsif @frame.iseq.source_container[1] == file 
+        line_no, vm_offset = position_to_line_and_offset(@frame.iseq, position, 
+                                                         offset_type)
+        return [@frame.iseq, line_no, vm_offset] + tail
+      else
+        errmsg("Unable to parse breakpoint position #{position_str}")
       end
-      return [position, iseq, use_offset, condition, name]
+      return [nil] * 5
     end
 
     # Return true if arg is 'on' or 1 and false arg is 'off' or 0.
@@ -244,101 +254,76 @@ class Trepan
       raise TypeError
     end
 
-    def method?(method_string)
-      obj, type, meth = 
-        if method_string =~ /(.+)(#|::|\.)(.+)/
-          [$1, $2, $3]
-        else
-          ['self', '.', method_string]
-        end
-      ret = debug_eval_no_errmsg("#{obj}.method(#{meth.inspect})")
-      return true if ret 
-      return debug_eval_no_errmsg("#{obj}.is_a?(Class)") &&
-        debug_eval_no_errmsg("#{obj}.method_defined?(#{meth.inspect})")
-    end
+    include CmdParser
 
-    # parse_position(self, arg)->(fn, container, lineno)
-    # 
-    # Parse arg as [filename:]lineno | function | module
-    # Make sure it works for C:\foo\bar.py:12
-    def parse_position(arg, old_mod=nil, allow_offset = false)
-      colon = arg.rindex(':') 
-      if colon
-        # First handle part before the colon
-        arg1 = arg[0...colon].rstrip
-          lineno_str = arg[colon+1..-1].lstrip
-        mf, container, lineno = parse_position_one_arg(arg1, old_mod, false, allow_offset)
-        return nil, nil, nil unless container
-        filename = canonic_file(arg1) 
-        # Next handle part after the colon
-        val = get_an_int(lineno_str)
-        lineno = val if val
+    def get_method(meth)
+      start_binding = 
+        begin
+          @frame.binding
+        rescue
+          binding
+        end
+      if meth.kind_of?(String)
+        meth_for_string(meth, start_binding)
       else
-        mf, container, lineno = parse_position_one_arg(arg, old_mod, true, allow_offset)
+        begin
+          meth_for_parse_struct(meth, start_binding)
+        rescue NameError
+          errmsg("Can't evalute #{meth.name} to get a method")
+          return nil
+        end
       end
-      
-      return mf, container, lineno
     end
 
-    # parse_position_one_arg(self,arg)->(module/function, container, lineno)
-    #
-    # See if arg is a line number, function name, or module name.
-    # Return what we've found. nil can be returned as a value in
-    # the triple.
-    def parse_position_one_arg(arg, old_mod=nil, show_errmsg=true, allow_offset=false)
-      name, filename = nil, nil, nil
-      begin
-        # First see if argument is an integer
-        lineno    = Integer(arg)
-      rescue
-      else
-        container = frame_container(@frame, false)
-        filename  = container[1] unless old_mod
-        return nil, [container[0], canonic_file(filename)], lineno
-      end
+    # FIXME: this is a ? method but we return 
+    # the method value. 
+    def method?(meth)
+      get_method(meth)
+    end
 
-      # Next see if argument is a file name 
-      found = 
-        if arg[0..0] == File::SEPARATOR
-          LineCache::cached?(arg)
+    # parse_position(self, arg)->(meth, filename, offset, offset_type)
+    # See app/cmd_parser.kpeg for the syntax of a position which
+    # should include things like:
+    # Parse arg as [filename:]lineno | function | module
+    # Make sure it works for C:\foo\bar.py:12
+    def parse_position(info)
+      info = parse_location(info) if info.kind_of?(String)
+      case info.container_type
+      when :fn
+        if meth = method?(info.container)
+          return [meth, meth.iseq.source_container[1], info.position, 
+                  info.position_type]
         else
-          resolve_file_with_dir(arg)
+          return [nil] * 4
         end
-      if found
-        return nil, [container && container[0], canonic_file(arg)], 1 
-      else
-        matches = find_scripts(arg)
-        if matches.size > 1
-          if show_errmsg
-            errmsg "#{arg} is matches several files:"
-            errmsg Columnize::columnize(matches.sort, 
-                                        @settings[:width], ' ' * 4, 
-                                        true, true, ' ' * 2).chomp
-          end
-          return nil, nil, nil
-        elsif matches.size == 1
-          LineCache::cache(matches[0])
-          return nil, ['file', matches[0]], 1
-        end
-      end
-
-      # How about a method name with an instruction sequence?
-      iseq = object_iseq(arg)
-      if iseq && iseq.source_container[0] == 'file'
-        filename = iseq.source_container[1]
-        line_no = iseq.offsetlines.values.flatten.min
-        return arg, ['file', canonic_file(filename)], line_no
-      end
-
-      if show_errmsg
-        unless (allow_offset && arg.size > 0 && arg[0].downcase == 'o')
-          errmsg("#{arg} is not a line number, read-in filename or method " +
-                 "we can get location information about")
+      when :file
+        filename = canonic_file(info.container)
+        # ?? Try to look up method here? 
+        container = frame_container(@frame, false)
+        try_filename  = container[1]
+        frame = (canonic_file(try_filename) == filename) ? @frame : nil
+        # else 
+        #   LineCache.compiled_method(filename)
+        # end
+        return frame, filename,  info.position, info.position_type
+      when nil
+        if [:line, :offset].member?(info.position_type)
+          container = frame_container(@frame, false)
+          filename  = container[1]
+          return @frame, canonic_file(filename), info.position, info.position_type
+        elsif !info.position_type
+          errmsg "Can't parse #{arg} as a position"
+          return [nil] * 4
+        else
+          errmsg "Unknown position type #{info.position_type} for location #{arg}"
+          return [nil]  * 4
         end
+      else
+        errmsg "Unknown container type #{info.container_type} for location #{arg}"
+        return [nil] * 4
       end
-      return nil, nil, nil
     end
-    
+
     def validate_initialize
       ## top_srcdir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
       ## @dbgr_script_iseqs, @dbgr_iseqs = filter_scripts(top_srcdir)
@@ -359,52 +344,55 @@ if __FILE__ == $0
     require_relative 'main' # Have to include before defining CmdProcessor!
                             # FIXME
 
-    proc = Trepan::CmdProcessor.new(Trepan::MockCore.new())
-    proc.frame_initialize
-    proc.instance_variable_set('@settings', 
+    cmdproc = Trepan::CmdProcessor.new(Trepan::MockCore.new())
+    cmdproc.frame_initialize
+    cmdproc.instance_variable_set('@settings', 
                                Trepan::CmdProcessor::DEFAULT_SETTINGS)
-    proc.frame_setup(RubyVM::ThreadFrame.current)
+    cmdproc.frame_setup(RubyVM::ThreadFrame.current)
     onoff = %w(1 0 on off)
-    onoff.each { |val| puts "onoff(#{val}) = #{proc.get_onoff(val)}" }
+    onoff.each { |val| puts "onoff(#{val}) = #{cmdproc.get_onoff(val)}" }
     %w(1 1E bad 1+1 -5).each do |val| 
-      puts "get_int_noerr(#{val}) = #{proc.get_int_noerr(val).inspect}" 
+      puts "get_int_noerr(#{val}) = #{cmdproc.get_int_noerr(val).inspect}" 
     end
     def foo; 5 end
-    def proc.errmsg(msg)
+    def cmdproc.errmsg(msg)
       puts msg
     end
-    puts proc.object_iseq('food').inspect
-    puts proc.object_iseq('foo').inspect
+    # puts cmdproc.object_iseq('food').inspect
+    # puts cmdproc.object_iseq('foo').inspect
 
-    puts proc.object_iseq('foo@validate.rb').inspect
-    puts proc.object_iseq('proc.object_iseq').inspect
+    # puts cmdproc.object_iseq('foo@validate.rb').inspect
+    # puts cmdproc.object_iseq('cmdproc.object_iseq').inspect
     
-    puts proc.parse_position_one_arg('tmpdir.rb').inspect
+    puts cmdproc.parse_position(__FILE__).inspect
+    puts cmdproc.parse_position('@8').inspect
+    puts cmdproc.parse_position('8').inspect
+    puts cmdproc.parse_position("#{__FILE__} #{__LINE__}").inspect
 
     puts '=' * 40
-    ['Array#map', 'Trepan::CmdProcessor.new',
-     'foo', 'proc.errmsg'].each do |str|
-      puts "#{str} should be true: #{proc.method?(str).inspect}"
+    ['Array.map', 'Trepan::CmdProcessor.new',
+     'foo', 'cmdproc.errmsg'].each do |str|
+      puts "#{str} should be method: #{!!cmdproc.method?(str)}"
     end
     puts '=' * 40
-    # require_relative '../lib/trepanning'
-    # dbgr = Trepan.new
-    # dbgr.debugger
 
     # FIXME:
-    # Array#foo should be false: true
-    # Trepan::CmdProcessor.allocate should be false: true
+    puts "Trepan::CmdProcessor.allocate is: #{cmdproc.get_method('Trepan::CmdProcessor.allocate')}"
 
     ['food', '.errmsg'].each do |str|
-      puts "#{str} should be false: #{proc.method?(str).inspect}"
+      puts "#{str} should be false: #{cmdproc.method?(str).to_s}"
     end
     puts '-' * 20
-    p proc.breakpoint_position(%w(O0))
-    p proc.breakpoint_position(%w(1))
-    p proc.breakpoint_position(%w(2 if a > b))
-    p proc.get_int_list(%w(1+0 3-1 3))
-    require 'trepanning'
-    debugger
-    p proc.get_int_list(%w(a 2 3))
+    p cmdproc.breakpoint_position('foo', true)
+    p cmdproc.breakpoint_position('@0', true)
+    p cmdproc.breakpoint_position("#{__LINE__}", true)
+    p cmdproc.breakpoint_position("#{__FILE__}   @0", false)
+    p cmdproc.breakpoint_position("#{__FILE__}:#{__LINE__}", true)
+    p cmdproc.breakpoint_position("#{__FILE__} #{__LINE__} if 1 == a", true)
+    p cmdproc.breakpoint_position("cmdproc.errmsg", false)
+    p cmdproc.breakpoint_position("cmdproc.errmsg:@0", false)
+    ### p cmdproc.breakpoint_position(%w(2 if a > b))
+    p cmdproc.get_int_list(%w(1+0 3-1 3))
+    p cmdproc.get_int_list(%w(a 2 3))
   end
 end