trepanning 0.0.9 → 0.1.0

data/app/yarv.rb

@@ -0,0 +1,183 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+# A CodeRay Scanner for YARV
+# FIXME: add unit test.
+require 'rubygems'
+require 'coderay'
+module CodeRay
+  module Scanners
+    
+    class YARV < Scanner
+      
+      include Streamable
+      
+      register_for :yarv
+      file_extension 'yarv'
+
+      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 match = scan(/(\s+)(\S+)/)
+                match =~ /(\s+)(\S+)/                
+                tokens << [$1, :space]
+                opcode = $2
+                tokens << [opcode, :reserved]
+                :expect_operand
+              else
+                match = scan(/^(.*)$/)
+                tokens << [match, :error]
+                :initial
+              end
+
+          when :expect_literal
+            space_parse(tokens)
+            if match = scan(/^#<.+>/)
+              tokens << [match, :content]
+            elsif match = scan(/^(\d+)/)
+              tokens << [match, :integer]
+            elsif match = scan(/^([:][^: ,\n]+)/)
+              tokens << [match, :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_lineno
+            
+          when :expect_operand
+            space_parse(tokens)
+            state = :expect_another_operand
+            if match = scan(/^(\d+)/)
+              tokens << [match, :integer]
+            elsif match = scan(/\/.*\//)
+              # Really a regular expression
+              tokens << [match, :entity]
+            elsif match = scan(/^([:][^: ,\n]+)/)
+              tokens << [match, :symbol]
+            elsif match = scan(/^([$][^ ,\n]+)/)
+              tokens << [match, :global_variable]
+            elsif match = scan(/nil|true|false/)
+              tokens << [match, :pre_constant]
+            elsif match = scan(/nil|true|false/)
+              tokens << [match, :pre_constant]
+            elsif match = scan(/[A-Za-z_][_A-Za-z0-9?!]*/)
+              tokens << [match, :variable]
+            elsif match = scan(/^#[^, \n]*/)
+              tokens << [match, :content]
+            elsif match = scan(/^<.+>/)
+              tokens << [match, :content]
+            elsif string_parse(tokens)
+            else
+              state = :expect_opt_lineno
+            end
+            
+          when :expect_another_operand
+            state = 
+              if match = scan(/^,/)
+                tokens << [match, :operator]
+                :expect_operand
+              else
+                :expect_opt_lineno
+              end
+          when :expect_opt_lineno
+            space_parse(tokens)
+            if match = scan(/^\(\s+\d+\)$/)
+              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 :yarv
+string='
+     0045 opt_regexpmatch1 /^-e$/
+     0000 trace            1                                              (   9)
+     0002 putnil           
+     0003 putstring        "irb"
+     0005 send             :require, 1, nil, 8, <ic:0>
+     0011 pop              
+     0012 trace            1                                              (  11)
+     0014 putstring        "/usr/local/bin/irb"
+     0016 getglobal        $0
+     0018 opt_eq           <ic:8>
+     0020 branchunless     41
+     0022 trace            1                                              (  12)
+     0024 getinlinecache   31, <ic:2>
+     0027 getconstant      :IRB
+     0029 setinlinecache   <ic:2>
+     0031 putstring        "/usr/local/bin/irb"
+     0033 send             :start, 1, nil, 0, <ic:3>
+'  
+  yarv_scanner = CodeRay.scanner :yarv
+  tokens = yarv_scanner.tokenize(string)
+  p tokens
+  yarv_highlighter = CodeRay::Duo[:yarv, :term]
+  puts yarv_highlighter.encode(string)
+end

data/bin/trepan

@@ -1,8 +1,9 @@
 #!/usr/bin/env ruby
-# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# Copyright (C) 2010, 2011 Rocky Bernstein <rockyb@rubyforge.net>
 # Invoke debugger from the command line. 
 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.
@@ -20,8 +21,8 @@ if File.basename(__FILE__) == File.basename($0)
     # 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 = copy_default_options
-    opts    = setup_options(options)
+    options = Trepan.copy_default_options
+    opts    = Trepan.setup_options(options)
     Trepan::ARGV = ARGV.clone
     rest = opts.parse! ARGV
 
@@ -34,13 +35,15 @@ if File.basename(__FILE__) == File.basename($0)
     # FIXME: Should (some of) these be instance variables?
     Trepan::RUBY_PATH    = ruby_path
     Trepan::TREPAN_PATH  = trepan_path
-    Trepan::RBDBGR_FILE  = __FILE__
 
     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.'
+        STDERR.puts 'Sorry - for now you must specify a Ruby script to debug or use the --client option.'
         exit(1)
       end
     end
@@ -51,10 +54,13 @@ if File.basename(__FILE__) == File.basename($0)
     Trepan::PROG_SCRIPT = program_to_debug
 
     # Set global so others may use this debugger.
-    $trepan = Trepan.new(:cmdfiles    => options[:cmdfiles],
-                         :initial_dir => options[:chdir],
-                         :nx          => options[:nx]
-                         )
+    
+    opts = {}
+    %w(cmdfiles initial_dir host nx port server highlight).each do |opt|
+      opts[opt.to_sym] = options[opt.to_sym]
+    end
+
+    $trepan = Trepan.new(opts)
     debug_program($trepan, Trepan::RUBY_PATH, 
                   File.expand_path(program_to_debug))
   end

data/data/custom_require.rb

@@ -0,0 +1,44 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+module Kernel
+
+  ##
+  # The Kernel#require from before RubyGems was loaded.
+
+  alias gem_original_require require
+
+  ##
+  # When RubyGems is required, Kernel#require is replaced with our own which
+  # is capable of loading gems on demand.
+  #
+  # When you call <tt>require 'x'</tt>, this is what happens:
+  # * If the file can be loaded from the existing Ruby loadpath, it
+  #   is.
+  # * Otherwise, installed gems are searched for a file that matches.
+  #   If it's found in gem 'y', that gem is activated (added to the
+  #   loadpath).
+  #
+  # The normal <tt>require</tt> functionality of returning false if
+  # that file has already been loaded is preserved.
+
+  def require(path) # :doc:
+    gem_original_require path
+  rescue LoadError => load_error
+    if load_error.message.end_with?(path)
+      if Gem.try_activate(path)
+        return gem_original_require(path)
+      end
+    end
+
+    raise load_error
+  end
+
+  private :require
+  private :gem_original_require
+
+end unless Kernel.private_method_defined?(:gem_original_require)
+

data/data/irbrc

@@ -0,0 +1,41 @@
+# -*- Ruby -*-
+# Copyright (C) 2010 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/data/prelude.rb

@@ -0,0 +1,38 @@
+
+# Mutex
+
+class Mutex
+  def synchronize
+    self.lock
+    begin
+      yield
+    ensure
+      self.unlock rescue nil
+    end
+  end
+end
+
+# Thread
+
+class Thread
+  MUTEX_FOR_THREAD_EXCLUSIVE = Mutex.new
+  def self.exclusive
+    MUTEX_FOR_THREAD_EXCLUSIVE.synchronize{
+      yield
+    }
+  end
+end
+
+module Kernel
+  module_function
+  def require_relative(relative_feature)
+    c = caller.first
+    e = c.rindex(/:\d+:in /)
+    file = $`
+    if /\A\((.*)\)/ =~ file # eval, etc.
+      raise LoadError, "require_relative is called in #{$1}"
+    end
+    absolute_feature = File.expand_path(File.join(File.dirname(file), relative_feature))
+    require absolute_feature
+  end
+end

data/interface/base_intf.rb

@@ -33,8 +33,8 @@ class Trepan
 
     # Closes all input and/or output.
     def close
-      @input.close  unless @input.closed?
-      @output.close unless @output.closed?
+      @input.close  unless !@input || @input.closed?
+      @output.close unless !@output || @output.closed?
     end
 
     # Called when a dangerous action is about to be done to make sure
@@ -58,6 +58,10 @@ class Trepan
       close
     end
 
+    def input_eof?
+      @input.eof?
+    end
+
     # Return true if interface is interactive.
     def interactive?
       # Default false and making subclasses figure out how to determine
@@ -82,8 +86,10 @@ class Trepan
       @output.write(msg)
     end
 
-    def read_command( prompt)
-      raise RuntimeError, Trepan::NotImplementedMessage
+    def read_command(prompt='')
+      line = readline(prompt)
+      # FIXME: Do something with history?
+      return line
     end
 
     def readline(prompt='')

data/interface/client.rb

@@ -0,0 +1,79 @@
+# -*- 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_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 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