ruby-decompiler 0.0.1

data/README.rdoc

@@ -0,0 +1,38 @@
+Ruby-decompiler is a decompiler for ruby code.  With it you can...
+
+View method signatures:
+
+  irb(main):015:0> def foo(a, b, *rest, &block); end; method(:foo).signature
+  => #<MethodSig::Signature:0x4037093c @origin_class=Object, @arg_info={:b=>"b",
+  :block=>"&block", :a=>"a", :rest=>"*rest"}, @name="foo", @arg_names=[:a,
+  :b, :rest, :block]>
+  irb(main):016:0> proc { |x, y, *rest| }.signature
+  => #<Proc::Signature:0x4036cf30 @args=#<Proc::Arguments:0x4036d020 @rest_arg=2,
+  @multiple_assignment=true, @names=[:x, :y, :rest]>, @arg_info={:x=>"x", :y=>"y",
+  :rest=>"*rest"}>
+
+And reconstruct compiled methods:
+
+  irb(main):001:0> def foo(a, b, *rest, &block)
+  irb(main):002:1>   begin
+  irb(main):003:2*     if not a and not b then
+  irb(main):004:3*       raise "Need more input!"
+  irb(main):005:3>     end
+  irb(main):006:2>     return a + b
+  irb(main):007:2>   ensure
+  irb(main):008:2*     puts "In ensure block"
+  irb(main):009:2>   end
+  irb(main):010:1> end
+  => nil
+  irb(main):011:0> m = method(:foo)
+  => #<Method: Object#foo>
+  irb(main):012:0> puts m.as_code
+  def foo(a, b, *rest, &block)
+    begin
+      (raise("Need more input!")) if (not a and not b)
+      return a + b
+    ensure
+      puts("In ensure block")
+    end
+  end
+  => nil

data/lib/decompiler/method/as_code.rb

@@ -0,0 +1,58 @@
+require 'internal/node/as_code'
+require 'internal/vm/iseq/as_code'
+require 'internal/method'
+require 'internal/method/signature'
+
+module MethodAsCode
+  # Returns a string representation of the method definition/body.
+  #
+  #   irb(main):001:0> def foo(a, b, *rest, &block)
+  #   irb(main):002:1>   begin
+  #   irb(main):003:2*     if not a and not b then
+  #   irb(main):004:3*       raise "Need more input!"
+  #   irb(main):005:3>     end
+  #   irb(main):006:2>     return a + b
+  #   irb(main):007:2>   ensure
+  #   irb(main):008:2*     puts "In ensure block"
+  #   irb(main):009:2>   end
+  #   irb(main):010:1> end
+  #   => nil
+  #   irb(main):011:0> m = method(:foo)
+  #   => #<Method: Object#foo>
+  #   irb(main):012:0> puts m.as_code
+  #   def foo(a, b, *rest, &block)
+  #     begin
+  #       (raise("Need more input!")) if (not a and not b)
+  #       return a + b
+  #     ensure
+  #       puts("In ensure block")
+  #     end
+  #   end
+  #
+  def as_code(indent=0, name=nil)
+    sig = self.signature
+    if self.body.respond_to?(:body) then
+      # YARV
+      body_expression = self.body.body.as_code(indent+1)
+    else
+      # pre-YARV
+      body_expression = self.body ? self.body.as_code(indent+1) : ''
+    end
+    name ||= sig.name
+    s = "#{'  '*indent}def #{name}(#{sig.param_list})\n"
+    if body_expression then
+      s += "#{body_expression}\n"
+    end
+    s += "#{'  '*indent}end"
+    return s
+  end
+end
+
+class Method
+  include MethodAsCode
+end
+
+class UnboundMethod
+  include MethodAsCode
+end
+

data/lib/decompiler/method/as_expression.rb

@@ -0,0 +1,33 @@
+require 'internal/node/as_expression'
+require 'internal/vm/iseq/as_expression'
+require 'internal/method/signature'
+require 'internal/method'
+
+module MethodAsExpression
+  # Return a single-line string representation of a method
+  # TODO: this method would be more aptly named "as_expression_string".
+  def as_expression
+    sig = self.signature
+    if self.body.respond_to?(:body) then
+      # YARV
+      body_expression = self.body.body.as_expression
+    else
+      # pre-YARV
+      body_expression = self.body.as_expression
+    end
+    if body_expression then
+      return "def #{sig.name}(#{sig.param_list}); #{body_expression}; end"
+    else
+      return "def #{sig.name}(#{sig.param_list}); end"
+    end
+  end
+end
+
+class Method
+  include MethodAsExpression
+end
+
+class UnboundMethod
+  include MethodAsExpression
+end
+

data/lib/decompiler/method/origin.rb

@@ -0,0 +1,29 @@
+module MethodOrigin
+  # An abstraction for a method origin.
+  class Origin
+    attr_reader :file, :line
+
+    def initialize(file, line)
+      @file = file
+      @line = line
+    end
+
+    def to_s
+      return "#{file}:#{line}"
+    end
+  end
+
+  # Return a Method::Origin representing where the method was defined.
+  def origin
+    block = body().next
+    return Origin.new(block.nd_file, block.nd_line)
+  end
+end
+
+class Method
+  include MethodOrigin
+end
+
+class UnboundMethod
+  include MethodOrigin
+end

data/lib/decompiler/method/signature.rb

@@ -0,0 +1,147 @@
+require 'internal/method'
+require 'internal/node'
+require 'internal/node/as_expression'
+require 'internal/method/signature/argument'
+require 'internal/method/signature/node'
+require 'internal/method/signature/signature'
+
+if defined?(RubyVM) then
+require 'internal/vm/bytedecoder'
+require 'internal/method/signature/iseq'
+end
+
+module MethodSig
+  # Return the names of the local variables of this method.
+  def local_vars
+    return self.body.local_vars
+  end
+
+  # Return the names of the arguments this method takes, in the order in
+  # which they appear in the argument list.
+  def argument_names
+    return self.body.argument_names
+  end
+
+  def args_node
+    return self.body.args_node
+  end
+  private :args_node
+
+  # If this method has a "rest" argument, that is, it has an argument
+  # that is preceded by an asterisk (*) in the argument list, then
+  # return its index, otherwise return nil.
+  def rest_arg
+    return self.body.rest_arg
+  end
+
+  # If this method has a "block" argument, that is, it has an argument
+  # that is preceded by an ampersand (&) in the argument list, then
+  # return its index, otherwise return nil.
+  def block_arg
+    return self.body.block_arg
+  end
+
+  def set_optional_args(args, args_node, names)
+    self.body.set_optional_args(args, args_node, names)
+  end
+  private :set_optional_args
+
+  # Return a hash mapping each argument name to a description of that
+  # argument.
+  def arguments
+    names = self.argument_names()
+    block_arg = self.block_arg()
+
+    args = {}
+    names.each do |name|
+      args[name] = Argument.new(name, false, false)
+    end
+
+    # Optional args
+    args_node = args_node()
+    set_optional_args(args, args_node, names)
+
+    # Rest arg
+    if self.rest_arg then
+      rest_name = names[rest_arg]
+      args[rest_name] = Argument.new(rest_name, true, false)
+    end
+
+    # Block arg
+    if block_arg then
+      block_name = names[block_arg]
+      args[block_name] = Argument.new(block_name, false, true)
+    end
+
+    return args
+  end
+end
+
+class Method
+  include MethodSig
+
+  # Return a String representing the method's signature.
+  def signature
+    return Signature.new(
+        attached_class(),
+        method_oid().to_s,
+        argument_names(),
+        arguments())
+  end
+end
+
+class UnboundMethod
+  include MethodSig
+
+  # Return a String representing the method's signature.
+  def signature
+    return Signature.new(
+        origin_class(),
+        method_oid().to_s,
+        argument_names(),
+        arguments())
+  end
+end
+
+if __FILE__ == $0 then
+  def foo(); end
+  puts method(:foo).signature
+
+  def foo(foo); end
+  puts method(:foo).signature
+
+  def foo(foo, bar); end
+  puts method(:foo).signature
+
+  def foo(foo=42, bar=10); end
+  puts method(:foo).signature
+
+  def foo(*args); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=42, *args, &block); end
+  puts method(:foo).signature
+  puts method(:foo).origin
+
+  def foo(foo, bar=obj.foo(1, 2, foo(10)), *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=obj.foo(1 + 1), *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=true ? false : 0, *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=true, *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=nil, *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar={1=>2}, *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=[1,2], *args, &block); end
+  puts method(:foo).signature
+end
+

data/lib/decompiler/method/signature/argument.rb

@@ -0,0 +1,102 @@
+
+module MethodSig
+  class Argument
+    attr_reader :name
+
+    def required?
+      return !optional?
+    end
+
+    def optional?
+      return rest? || block?
+    end
+
+    def rest?
+      return @is_rest
+    end
+
+    def block?
+      return @is_block
+    end
+
+    def default
+      return nil
+    end
+
+    def initialize(name, is_rest, is_block)
+      @name = name
+      @is_rest = is_rest
+      @is_block = is_block
+    end
+
+    def to_s
+      if @is_rest then
+        prefix = "*"
+      elsif @is_block then
+        prefix = "&"
+      end
+
+      if self.default then
+        suffix = "=#{default()}"
+      end
+
+      return "#{prefix}#{@name}#{suffix}"
+    end
+  end
+
+  class OptionalArgument < Argument
+    def optional?
+      return true
+    end
+  end
+
+  class NodeOptionalArgument < OptionalArgument
+    attr_reader :node_for_default
+    attr_reader :default
+
+    def initialize(name, default, node_for_default, is_rest, is_block)
+      super(name, is_rest, is_block)
+      @default = default
+      @node_for_default = node_for_default
+    end
+  end
+
+  class YarvOptionalArgument < OptionalArgument
+    attr_reader :iseq
+    attr_reader :pc_start
+    attr_reader :local_idx
+
+    def initialize(name, iseq, pc_start, local_idx, is_rest, is_block)
+      super(name, is_rest, is_block)
+      @iseq = iseq
+      @pc_start = pc_start
+      @local_idx = local_idx
+      @default = nil
+    end
+
+    def inspect
+      default()
+      super
+    end
+
+    def default
+      return @default if @default
+
+      env = Internal::ByteDecoder::Environment.new(@iseq.local_table())
+      local_table_idx = local_table_idx()
+      @iseq.bytedecode(env, @pc_start) do |instr|
+        RubyVM::Instruction::SETLOCAL === instr &&
+        instr.operands[0] == local_table_idx
+      end
+      expressions = env.expressions + env.stack
+
+      @default = expressions[0].rhs.to_s
+      return @default
+    end
+
+    def local_table_idx
+      return @iseq.local_table.size - @local_idx + 1
+    end
+  end
+end
+

data/lib/decompiler/method/signature/iseq.rb

@@ -0,0 +1,52 @@
+class RubyVM
+  # YARV 1.9.2 and later
+  class InstructionSequence
+    include MethodSig
+
+    def local_vars
+      local_vars = self.local_table
+      return local_vars
+    end
+
+    def argument_names
+      local_vars = self.local_vars
+      opt_args = self.arg_opt_table
+      opt_args.pop # last arg is a pointer to the start of the code
+      num_args = \
+        self.argc + \
+        opt_args.size + \
+        (rest_arg ? 1 : 0) + \
+        (block_arg ? 1 : 0)
+      return local_vars[0...num_args]
+    end
+
+    def args_node
+      return nil
+    end
+
+    def rest_arg
+      arg_rest = self.arg_rest
+      return arg_rest >= 0 ? arg_rest : nil
+    end
+
+    def block_arg
+      arg_block = self.arg_block
+      return arg_block >= 0 ? arg_block : nil
+    end
+
+    def set_optional_args(args, args_node, names)
+      opt_table = self.arg_opt_table
+      opt_table.pop
+      first_opt_idx =
+        names.size -
+        opt_table.size -
+        (self.rest_arg ? 1 : 0) -
+        (self.block_arg ? 1 : 0)
+      opt_table.each_with_index do |pc, idx|
+        name = names[first_opt_idx + idx]
+        args[name] = YarvOptionalArgument.new(name, self, pc, idx, false, false)
+      end
+    end
+  end
+end
+