rbx-trepanning 0.2.0-universal-rubinius-2.0

data/app/rbx-llvm.rb

@@ -0,0 +1,163 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# A CodeRay Scanner for Rubinius' LLVM.
+# FIXME: add unit test.
+require 'rubygems'
+require 'coderay'
+module CodeRay
+  module Scanners
+    
+    class LLVM < Scanner
+      
+      register_for :llvm
+      file_extension 'llvm'
+
+      def string_parse(tokens)
+        if match = scan(/^"[^"]*"/)
+          string = match.dup
+          while  "\\" == match[-2..-2]
+            match = scan(/^.*"/)
+            break unless match 
+            string << match 
+          end
+          tokens << [string, :string]
+          true
+        else
+          false
+        end
+      end
+
+      def space_parse(tokens)
+        if match = scan(/^[ \t]*/)
+          tokens << [match, :space] if match
+        end
+      end
+
+      def scan_tokens(tokens, options)
+        
+        state = :initial
+        number_expected = true
+
+        until eos?
+
+          kind = nil
+          match = nil
+          
+          case state
+
+          when :initial
+            if match = scan(/^\s*/)
+              tokens << [match, :space]  unless match.empty?
+            end
+            state = 
+              if match = scan(/^$/)
+                :initial
+              else
+                :expect_label
+              end
+
+          when :expect_label
+            state = 
+              if match = scan(/\d+:/x)
+                tokens << [match, :label]
+                :expect_opcode
+              else 
+                match = scan(/^.*$/)
+                tokens << [match, :error]
+                :initial
+            end
+            
+          when :expect_opcode
+            state = 
+              if scan(/(\s+)(\S+)/)
+                tokens << [@match[1], :space]
+                opcode = @match[2]
+                tokens << [opcode, :reserved]
+                if %w(push_literal create_block set_literal).member?(opcode)
+                  :expect_literal
+                else
+                  :expect_operand
+                end
+              else
+                match = scan(/^(.*)$/)
+                tokens << [match, :error]
+                :initial
+              end
+
+          when :expect_literal
+            space_parse(tokens)
+            if match = scan(/^#<.+>/)
+              tokens << [match, :content]
+            elsif scan(/^(\d+)/)
+              tokens << [@match[0], :integer]
+            elsif scan(/^([:][^: ,\n]+)/)
+              tokens << [@match[0], :symbol]
+            elsif string_parse(tokens)
+              # 
+            elsif match = scan(/nil|true|false/)
+              tokens << [match, :pre_constant]
+            elsif match = scan(/\/.*\//)
+              tokens << [match, :entity]
+            else
+              match = scan(/^.*$/)              
+              tokens << [match, :error] unless match.empty?
+              end
+            state = :expect_opt_comment
+            
+          when :expect_operand
+            space_parse(tokens)
+            state = 
+              if scan(/^(\d+)/)
+                tokens << [@match[0], :integer]
+                :expect_another_operand
+              elsif scan(/^([:][^: ,\n]+)/)
+                tokens << [@match[0], :symbol]
+                :expect_another_operand
+              elsif string_parse(tokens)
+                :expect_another_operand
+              else
+                :expect_opt_comment
+              end
+            
+          when :expect_another_operand
+            state = 
+              if match = scan(/^,/)
+                tokens << [@match[0], :operator]
+                :expect_operand
+              else
+                :expect_opt_comment
+              end
+          when :expect_opt_comment
+            space_parse(tokens)
+            if match = scan(/^#.*$/)
+              tokens << [match, :comment] 
+            else
+              match = scan(/^.*$/)              
+              tokens << [match, :error] unless match.empty?
+            end
+            state = :initial
+          end
+        end
+        tokens
+      end
+    end
+  end
+end
+if __FILE__ == $0
+  require 'term/ansicolor'
+  ruby_scanner = CodeRay.scanner :llvm
+string='
+     0003:  push_literal               #<Rubinius::CompiledMethod gcd file=/x>
+     0028:  create_block               #<Rubinius::CompiledMethod __block__ file=/y>
+     0007:  send_stack                 :method_visibility, 0
+     0046:  push_literal               "The GCD of %d and %d is %d"
+     0000:  passed_arg                 1    # line: 679
+     0002:  goto_if_true               8
+     0004:  push_false                 
+     0080:  push_literal               "\n     0003:  push_literal               #<Rubinius::CompiledMethod gcd file=/x>\n     0028:  create_block               #<Rubinius::CompiledMethod __block__ file=/y>\n     0007:  send_stack                 :method_visibility, 0\n     0046:  push_literal               \"    # line: 147
+'  
+  llvm_scanner = CodeRay.scanner :llvm
+  tokens = llvm_scanner.tokenize(string)
+  p tokens
+  llvm_highlighter = CodeRay::Duo[:llvm, :term]
+  puts llvm_highlighter.encode(string)
+end

data/app/run.rb

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rbconfig'
+require 'rubygems'; require 'require_relative'
+module Trepanning
+
+  module_function # All functions below are easily publically accessible
+
+  # 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
+  # arguments or things that the debugged program isn't supposed to
+  # see.  FIXME: Should we make ARGV an explicit parameter?
+  def debug_program(dbgr, ruby_path, program_to_debug, start_opts={})
+
+    # Make sure Ruby script syntax checks okay.
+    # Otherwise we get a load message that looks like trepanning has 
+    # a problem. 
+    output = `#{ruby_path} -c #{program_to_debug.inspect} 2>&1`
+    if $?.exitstatus != 0 and RUBY_PLATFORM !~ /mswin/
+      puts output
+      exit $?.exitstatus 
+    end
+    # print "\032\032starting\n" if Trepan.annotate and Trepan.annotate > 2
+
+    ## FIXME: put in fn.
+    m = self.method(:debug_program).executable
+    dbgr.processor.ignore_methods[m]='step'
+
+    # m = Kernel.method(:load).executable
+    # dbgr.processor.ignore_methods[m]='step'
+
+    # Any frame from us or below should be hidden by default.
+    hide_level = Rubinius::VM.backtrace(0, true).size+1
+
+    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)
+
+    ## FIXME: we gets lots of crap before we get to the real stuff.
+    start_opts = {
+      :skip_loader => true
+    }.merge(start_opts)
+    dbgr.start(start_opts)
+    begin
+      Kernel::load program_to_debug
+    rescue Interrupt
+    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)
+  end
+
+  # Do a shell-like path lookup for prog_script and return the results.
+  # If we can't find anything return prog_script.
+  def whence_file(prog_script)
+    if prog_script.start_with?(File::SEPARATOR) || prog_script.start_with?('.')
+      # Don't search since this name has path is explicitly absolute or
+      # relative.
+      return prog_script
+    end
+    for dirname in ENV['PATH'].split(File::PATH_SEPARATOR) do
+      prog_script_try = File.join(dirname, prog_script)
+      return prog_script_try if File.readable?(prog_script_try)
+    end
+    # Failure
+    return prog_script
+  end
+end
+
+# Path name of Ruby interpreter we were invoked with. Is part of 
+# 1.9 but not necessarily 1.8.
+def RbConfig.ruby
+  File.join(RbConfig::CONFIG['bindir'],  
+            RbConfig::CONFIG['RUBY_INSTALL_NAME'] + 
+            RbConfig::CONFIG['EXEEXT'])
+end unless defined? RbConfig.ruby
+
+if __FILE__ == $0
+  # Demo it.
+  include  Trepanning
+  puts whence_file('irb')
+  puts whence_file('probably-does-not-exist')
+  puts RbConfig.ruby
+end

data/app/util.rb

@@ -0,0 +1,99 @@
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+class Trepan
+  module Util
+
+    module_function 
+    def safe_repr(str, max, elipsis='... ')
+      if str.is_a?(String) && max > 0 && str.size > max && !str.index("\n")
+        "%s%s%s" % [ str[0...max/2], elipsis,  str[str.size-max/2..str.size]]
+      else
+        str
+      end
+    end
+
+    # name is String and list is an Array of String.
+    # If name is a unique leading prefix of one of the entries of list,
+    # then return that. Otherwise return name.
+    def uniq_abbrev(list, name)
+      candidates = list.select do |try_name| 
+        try_name.start_with?(name)
+      end
+      candidates.size == 1 ? candidates.first : name
+    end
+
+    # extract the "expression" part of a line of source code.
+    # 
+    def extract_expression(text)
+      if text =~ /^\s*(?:if|elsif|unless)\s+/
+        text.gsub!(/^\s*(?:if|elsif|unless)\s+/,'') 
+        text.gsub!(/\s+then\s*$/, '')
+      elsif text =~ /^\s*(?:until|while)\s+/
+        text.gsub!(/^\s*(?:until|while)\s+/,'') 
+        text.gsub!(/\s+do\s*$/, '')
+      elsif text =~ /^\s*return\s+/
+        # EXPRESION in: return EXPRESSION
+        text.gsub!(/^\s*return\s+/,'')
+      elsif text =~ /^\s*case\s+/
+        # EXPRESSION in: case EXPESSION
+        text.gsub!(/^\s*case\s*/,'')
+      elsif text =~ /^\s*def\s*.*\(.+\)/
+        text.gsub!(/^\s*def\s*.*\((.*)\)/,'[\1]')
+      elsif text =~ /^\s*[A-Za-z_][A-Za-z0-9_\[\]]*\s*=[^=>]/
+        # RHS of an assignment statement.
+        text.gsub!(/^\s*[A-Za-z_][A-Za-z0-9_\[\]]*\s*=/,'')
+      end
+      return text
+    end
+
+    # Find user portion of script skipping over Rubinius code loading.
+    # Unless hidestack is off, we don't show parts of the frame below this.
+    def find_main_script(locs)
+      candidate = nil
+      (locs.size-1).downto(0) do |i|
+        loc = locs[i]
+        if 'Object#' == loc.describe_receiver &&
+            :__script__ == loc.name
+          if loc.method.active_path =~ /\/trepanx$/ ||
+            loc.method.active_path == 'kernel/loader.rb'
+            # Might have been run from standalone trepanx.
+            candidate = i
+          else
+            return locs.size - i
+          end
+        end
+      end
+      candidate ? locs.size - candidate - 1 : nil
+    end
+
+    # Suppress warnings. The main one we encounter is "already initialized
+    # constant" because perhaps another version readline has done that already.
+    def suppress_warnings
+      original_verbosity = $VERBOSE
+      $VERBOSE = nil
+      result = yield
+      $VERBOSE = original_verbosity
+      return result
+    end  
+  end
+end
+
+if __FILE__ == $0
+  include Trepan::Util
+  string = 'The time has come to talk of many things.'
+  puts safe_repr(string, 50)
+  puts safe_repr(string, 17)
+  puts safe_repr(string.inspect, 17)
+  puts safe_repr(string.inspect, 17, '')
+  locs = Rubinius::VM.backtrace(0)
+  locs.each_with_index do |l, i| 
+    puts "#{i}: #{l.describe}"
+  end
+  ## puts "main script in above is #{locs.size() - 1 - find_main_script(locs)}"
+
+  list = %w(disassemble disable distance up)
+  p list
+  %w(dis disa u upper foo).each do |name|
+    puts "uniq_abbrev of #{name} is #{uniq_abbrev(list, name)}"
+  end
+end

data/app/validate.rb

@@ -0,0 +1,30 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+
+class Trepan
+  module Validate
+    def line_or_ip(arg_str)
+      arg=arg_str.dup
+      is_ip = 
+        if '@' == arg[0..0]
+          arg[0] = ''
+          true
+        else
+          false
+        end
+      line_or_ip = Integer(arg) rescue nil
+      if is_ip 
+        return line_or_ip, nil
+      else
+        return nil, line_or_ip
+      end
+    end
+    module_function :line_or_ip
+  end
+end
+
+if __FILE__ == $0
+  include Trepan::Validate
+  %w(@1 oink 1 12 -12).each do |arg|
+    puts "line_or_ip(#{arg})=#{line_or_ip(arg).inspect}"
+  end
+end

data/bin/.gitignore

@@ -0,0 +1,2 @@
+/*~
+/*.rbc

data/bin/trepanx

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Invoke debugger from the command line. 
+require 'rubygems'; require 'require_relative'
+require 'rbconfig' # For RbConfig.ruby
+require_relative '../app/run'
+require_relative '../app/options'
+require_relative '../app/client'
+require_relative '../lib/trepanning'
+
+# FIXME: the figure out how to run via gem installation.
+if File.basename(__FILE__) == File.basename($0)
+  include Trepanning
+
+  # One way to get local variables is to create a block which is run
+  # once.  
+  # 
+  # Note however that since there are constants below, we can't
+  # wrap all of this in a procedure as that would be defining
+  # constants dynamically.
+  1.times do 
+    trepan_path = program_to_debug = nil
+
+    # options = DEFAULT_CMDLINE_SETTINGS.merge({}) seems to change up
+    # DEFAULT_CMDLINE_SETTINGS when options[:key] is changed. The
+    # below is the simplest thing I can come up with so far.
+    options = Trepan.copy_default_options
+    opts    = Trepan.setup_options(options)
+    Trepan::ARGV = ARGV.clone
+    rest = opts.parse! ARGV
+
+    trepan_path = File.expand_path($0)
+    if RUBY_PLATFORM =~ /mswin/
+      trepan_path += '.cmd' unless trepan_path =~ /\.cmd$/i
+    end
+
+    # FIXME: do we need to test defined? 
+    # FIXME: Should (some of) these be instance variables?
+    Trepan::TREPAN_PATH  = trepan_path
+
+    if ARGV.empty?
+      if options[:version] || options[:help]
+        exit 100
+      elsif options[:client]
+        start_client(options)
+        exit
+      else
+        STDERR.puts 'Sorry - for now you must specify a Ruby script to debug or use the --client option.'
+        exit(1)
+      end
+    end
+
+    program_to_debug = (Trepan::PROG_UNRESOLVED_SCRIPT = ARGV.shift).dup
+    program_to_debug = whence_file(Trepan::PROG_UNRESOLVED_SCRIPT) unless 
+      File.exist?(Trepan::PROG_UNRESOLVED_SCRIPT)
+    Trepan::PROG_SCRIPT = program_to_debug
+
+    opts = {}
+    %w(cmdfiles highlight initial_dir host nx port readline server traceprint
+       ).each do |opt|
+      opts[opt.to_sym] = options[opt.to_sym]
+    end
+
+    # Set global so others may use this debugger.
+    $trepan = Trepan.new(opts)
+    debug_program($trepan, RbConfig.ruby,
+                  File.expand_path(program_to_debug))
+  end
+end

data/data/.gitignore

@@ -0,0 +1,2 @@
+/*~
+/*.rbc

data/data/irbrc

@@ -0,0 +1,41 @@
+# -*- Ruby -*-
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# We use this as the default startup file for irb inside trepan
+# Down the line we will have a way for folks to add/override this
+# with their own file.
+IRB.conf[:PROMPT_MODE] = :SIMPLE
+IRB.conf[:PROMPT][:SIMPLE] = 
+    {:PROMPT_C=>"trepan ?> ",
+     :PROMPT_I=>"trepan >> ",
+     :PROMPT_N=>"trepan >> ",
+     :PROMPT_S=>nil,
+     :RETURN=>"=> %s\n"}
+
+# Using dbgr to issue a debugger statement inside irb:
+#  dbgr %w(info program)
+#  dbgr 'info program'  # also works
+# But...
+#  dbgr info program    # wrong!
+# 
+puts "You are in a trepan session. You should have access to program scope."
+puts "'dbgr', 'step', 'ne', 'q', 'cont' commands have been added."
+
+if defined?($trepan) && $trepan
+   puts 'You should have access to debugger state via global variable $trepan'
+end
+if defined?($trepan_frame) && $trepan_frame
+   puts 'You should have access to the program frame via global variable $trepan_frame'
+end
+if defined?($trepan_cmdproc) && $trepan_cmdproc
+   puts 'You should have access to the command processor via global variable $trepan_cmdproc'
+end
+
+# Monkeypatch to save the current IRB statement to be run.
+class IRB::Context
+  alias_method :_trepan_original_evaluate, :evaluate
+  def evaluate(line, line_no)
+    $trepan_irb_statements = line
+    _trepan_original_evaluate(line, line_no)
+  end
+end
+

data/interface/.gitignore

@@ -0,0 +1,2 @@
+/*.rbc
+/*~

data/interface/client.rb

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Interface for client (i.e. user to communication-device) interaction.
+# The debugged program is at the other end of the communcation.
+
+require 'rubygems'; require 'require_relative'
+require_relative 'user'
+require_relative '../io/tcpclient'
+require_relative 'comcodes'
+
+# Mfifoclient = import_relative('fifoclient', '..io', 'pydbgr')
+
+# Interface for a user which is attached to a debugged process via
+# some sort of communication medium (e.g. socket, tty, FIFOs).  This
+# could be on the same computer in a different process or on a remote
+# computer.
+class Trepan::ClientInterface < Trepan::Interface
+
+  DEFAULT_INIT_CONNECTION_OPTS = {
+    :open => true,
+    :io   => :tcp
+  }
+
+  def initialize(inp=nil, out=nil, inout=nil, user_opts={}, 
+                 connection_opts={})
+
+    @connection_opts = DEFAULT_INIT_CONNECTION_OPTS.merge(connection_opts)
+
+    @user = Trepan::UserInterface.new(inp, out, user_opts)
+    
+    @inout = 
+      if inout
+        inout 
+      else
+        # @server_type = @connection_opts[:io]
+        # if 'FIFO' == self.server_type
+        #   Mfifoclient.FIFOClient(opts=@connection_opts)
+        # elsif :tcp == self.server_type
+        Trepan::TCPDbgClient.new(@connection_opts)
+        # else
+        #   errmsg("Expecting server type TCP or FIFO. Got: %s." %
+        #          self.server_type)
+        #   return
+        # end
+      end
+  end
+
+  def closed?
+    @inout.closed?
+  end
+
+  def confirm(prompt, default)
+    @user.confirm(prompt, default)
+  end
+
+  def read_command(prompt='')
+    @user.read_command(prompt)
+  end
+
+  # Send a message back to the server (in contrast to the local user
+  # output channel).
+  def read_remote
+    coded_line = nil
+    until coded_line
+      coded_line = @inout.read_msg
+    end
+    control = coded_line[0..0]
+    remote_line = coded_line[1..-1]
+    [control, remote_line]
+  end
+
+  # Send a message back to the server (in contrast to the local user
+  # output channel).
+  def write_remote(code, msg)
+    # FIXME change into write_xxx
+    @inout.writeline(code + msg)
+  end
+end
+  
+# Demo
+if __FILE__ == $0
+    intf = Trepan::ClientInterface.new
+end

data/interface/comcodes.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+
+# Communication status codes
+module Trepanning
+  # Most of these go from debugged process to front-end
+  # client interface. COMMAND goes the other way.
+  module RemoteCommunication
+    unless defined?(PRINT)
+      PRINT         = '.'
+      COMMAND       = 'C'
+      CONFIRM_TRUE  = 'Y'
+      CONFIRM_FALSE = 'N'
+      CONFIRM_REPLY = '?'
+      QUIT          = 'q'
+      PROMPT        = 'p'
+      RESTART       = 'r'
+    end
+  end
+end