ruby-decompiler 0.0.1

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

@@ -0,0 +1,160 @@
+class Node
+  # pre-YARV
+  class SCOPE
+    include MethodSig
+
+    def local_vars
+      return self.tbl || []
+    end
+
+    def argument_names
+      local_vars = self.local_vars
+      args = self.args_node
+      num_required_args = args.cnt
+      num_optional_args = 0
+      opt = args.opt
+      while opt do
+        num_optional_args += 1
+        opt = opt.next
+      end
+      num_args = \
+        num_required_args + \
+        num_optional_args + \
+        (rest_arg ? 1 : 0) + \
+        (block_arg ? 1 : 0)
+      return local_vars[0...num_args]
+    end
+
+    def args_node
+      if self.next.class == Node::ARGS then
+        return self.next
+      elsif self.next.head.class == Node::ARGS then
+        return self.next.head
+      else
+        raise "Could not find method arguments"
+      end
+    end
+
+    def rest_arg
+      args_node = args_node()
+      rest = args_node.rest()
+      if rest.class == Node::LASGN then
+        # subtract 2 to account for implicit vars
+        return rest.cnt - 2
+      elsif not rest
+        return nil
+      else
+        return rest > 0 ? rest - 2 : nil
+      end
+    end
+
+    def block_arg
+      block = self.next
+      if block.class == Node::BLOCK and
+         block.next.head.class == Node::BLOCK_ARG then
+        # subtract 2 to account for implicit vars
+        return block.next.head.cnt - 2
+      else
+        return nil
+      end
+    end
+
+    def set_optional_args(args, args_node, names)
+      opt = args_node.opt
+      while opt do
+        head = opt.head
+        if head.class == Node::LASGN then
+          args[head.vid] = NodeOptionalArgument.new(
+              head.vid, head.value.as_expression, head.value, false, false)
+        else
+          raise "Unexpected node type: #{opt.class}"
+        end
+        opt = opt.next
+      end
+    end
+  end
+
+  # Pre-YARV, I think
+  class BMETHOD
+    def local_vars
+      raise "TODO: Not implemented yet"
+    end
+
+    def argument_names
+      return self.cval.arguments.names
+    end
+
+    def arguments
+      return self.cval.arguments
+    end
+
+    def args_node
+      raise "TODO: Not implemented yet"
+    end
+
+    def rest_arg
+      raise "TODO: Not implemented yet"
+    end
+
+    def block_arg
+      raise "TODO: Not implemented yet"
+    end
+
+    def set_optional_args(args, args_node, names)
+      raise "TODO: Not implemented yet"
+    end
+  end
+
+  # YARV up to 1.9.1
+  class METHOD
+    include MethodSig
+
+    def local_vars
+      iseq = self.body
+      local_vars = iseq.local_table
+      return local_vars
+    end
+
+    def argument_names
+      local_vars = self.local_vars
+      iseq = self.body
+      opt_args = iseq.arg_opt_table
+      opt_args.pop # last arg is a pointer to the start of the code
+      num_args = \
+        iseq.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.body.arg_rest
+      return arg_rest >= 0 ? arg_rest : nil
+    end
+
+    def block_arg
+      arg_block = self.body.arg_block
+      return arg_block >= 0 ? arg_block : nil
+    end
+
+    def set_optional_args(args, args_node, names)
+      opt_table = self.body.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.body, pc, idx, false, false)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,23 @@
+module MethodSig
+  # An abstraction for a method signature.
+  class Signature
+    attr_reader :origin_class, :name, :arg_names, :args
+
+    def initialize(origin_class, name, arg_names, args)
+      @origin_class = origin_class
+      @name = name
+      @arg_names = arg_names
+      @args = args
+    end
+
+    def to_s
+      return "#{@origin_class}\##{@name}(#{param_list})"
+    end
+
+    def param_list
+      params = @arg_names.map{ |n| args[n].to_s }
+      return params.join(', ')
+    end
+  end
+end
+

data/lib/decompiler/module/as_code.rb

@@ -0,0 +1,45 @@
+require 'internal/node/as_code'
+require 'internal/module'
+
+class Module
+  # TODO: it would be nice if we could go back and find the AST
+  # for the class instead of recreating the code from the class's
+  # current state.
+  def as_code(indent=0)
+    imethods = self.instance_methods - self.superclass.instance_methods
+    cmethods = self.instance_methods - self.superclass.instance_methods
+    constants = self.constants - self.superclass.constants
+    name = self.name.gsub(/.*::/, '')
+
+    # TODO: included modules?
+    if self.class == Class then
+      s = "#{'  '*indent}class #{name} < #{self.superclass}\n"
+    else
+      s = "#{'  '*indent}module #{name}\n"
+    end
+
+    constants.each do |constant|
+      s += "#{'  '*indent} #{constant}=#{self.const_get(constant).as_code}\n"
+    end
+
+    # TODO: protected/private
+    imethods.each do |method|
+      s += self.instance_method(method).as_code(indent+1)
+      s += "\n"
+    end
+
+    cmethods.each do |method|
+      s += self.instance_method(method).as_code(indent+1, "self.#{method}")
+      s += "\n"
+    end
+
+    # TODO: singleton class constants
+    # TODO: class variables
+    # TODO: singleton instance variables
+
+    s += "#{'  '*indent}end"
+
+    return s
+  end
+end
+

data/lib/decompiler/node/as_code.rb

@@ -0,0 +1,233 @@
+require 'internal/node'
+require 'internal/node/as_expression'
+require 'internal/object/as_code'
+require 'rbconfig'
+
+class Node
+  public
+
+  def as_code(indent=0, *args)
+    return as_code_impl(self, indent, *args)
+  end
+
+  private
+
+  def as_code_impl(node, indent, *args)
+    # default -- most code is just an expression
+    expression = node.as_expression(*args)
+    if not expression.nil? then
+      return "#{'  '*indent}#{expression}"
+    else
+      return nil
+    end
+  end
+
+  class << self
+    def define_code(klass, &block)
+      if const_defined?(klass) then
+        const_get(klass).instance_eval { define_method(:as_code_impl, &block) }
+      end
+    end
+  end
+
+  define_code(:IF) do |node, indent|
+    if node.body.class == Node::BLOCK or
+       node.else.class == Node::BLOCK then
+      s = "#{'  '*indent}if #{node.cond.as_expression} then\n"
+      s << "#{'  '*indent}#{node.body.as_code(indent+1)}\n"
+      if node.else then
+        s << "#{'  '*indent}else\n"
+        s << "#{'  '*indent}#{node.else.as_code(indent+1)}\n"
+      end
+      s << "#{'  '*indent}end"
+      s
+    else
+      "#{'  '*indent}#{node.as_expression}"
+    end
+  end
+
+  define_code(:BLOCK) do |node, indent|
+    a = node.to_a
+    if a[0].class == Node::DASGN_CURR then
+      vardefs = a[0]
+      while vardefs.class == Node::DASGN_CURR do
+        vardefs = vardefs.value
+      end
+      if not vardefs then
+        # ignore variable definitions
+        a.shift
+      end
+    end
+    lines = a.map { |n| n.as_code(indent) }
+    lines.reject! { |e| e.nil? }
+    if lines.size == 0 then
+      "#{'  '*indent}nil"
+    else
+      lines.join("\n")
+    end
+  end
+
+  define_code(:ITER) do |node, indent|
+    "#{'  '*indent}#{node.iter.as_expression} {\n" +
+    "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+    "#{'  '*indent}}"
+  end
+
+  define_code(:WHILE) do |node, indent|
+    if node.state == 1 then
+      "#{'  '*indent}while #{node.cond.as_expression} do\n" +
+      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+      "#{'  '*indent}end"
+    else
+      "#{'  '*indent}begin\n" +
+      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+      "#{'  '*indent}end while #{node.cond.as_expression}"
+    end
+  end
+
+  define_code(:UNTIL) do |node, indent|
+    if node.state == 1 then
+      "#{'  '*indent}until #{node.cond.as_expression} do\n" +
+      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+      "#{'  '*indent}end"
+    else
+      "#{'  '*indent}begin\n" +
+      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+      "#{'  '*indent}end until #{node.cond.as_expression}"
+    end
+  end
+
+  define_code(:BEGIN) do |node, indent|
+    if node.body.class == Node::RESCUE or
+       node.body.class == Node::ENSURE then
+      s = "#{'  '*indent}begin\n" +
+      "#{node.body.as_code(indent+1, true)}\n" +
+      "#{'  '*indent}end"
+    elsif node.body then
+      "#{'  '*indent}begin\n" +
+      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+      "#{'  '*indent}end"
+    else
+      "#{'  '*indent}begin\n" +
+      "#{'  '*indent}end\n"
+    end
+  end
+
+  def self.begin_end(indent, have_begin)
+    s = ''
+    if not have_begin then
+      s << "#{'  '*indent}begin\n"
+      indent += 1
+    end
+    yield s, indent, true
+    if not have_begin then
+      indent -= 1
+      s << "\n#{'  '*indent}end"
+    end
+    return s
+  end
+
+  define_code(:ENSURE) do |node, indent, *args|
+    begin_ensure = args[0] || false
+    Node.begin_end(indent, begin_ensure) do |s, indent_, begin_ensure|
+      if node.head then
+        s << "#{node.head.as_code(indent_)}\n"
+      end
+      s << "#{'  '*(indent_-1)}ensure\n"
+      s << "#{node.ensr.as_code(indent_)}"
+    end
+  end
+
+  define_code(:RESCUE) do |node, indent, *args|
+    begin_rescue = args[0] || false
+    Node.begin_end(indent, begin_rescue) do |s, indent_, begin_rescue|
+      if node.head then
+        if begin_rescue then
+          s << "#{node.head.as_code(indent_)}\n"
+          s << "#{'  '*(indent_-1)}rescue #{node.resq.as_code(indent_+1, begin_rescue)}"
+        else
+          s << "#{node.head.as_expression} rescue #{node.resq.as_expression(begin_rescue)}"
+        end
+      else
+        s << "rescue #{node.resq.as_expression(begin_rescue)}"
+      end
+    end
+  end
+
+  define_code(:RESBODY) do |node, indent, *args|
+    begin_rescue = args[0] || false
+    if begin_rescue then
+      if node.args then
+        a = node.args.to_a.map { |n| n.as_expression }
+        "#{a.join(', ')}\n" +
+        "#{'  '*indent}#{node.body.as_code(indent+1)}"
+      else
+        node.body ? "\n#{'  '*indent}#{node.body.as_code(indent+1)}" : ''
+      end
+    else
+      # TODO: assuming node.args is false...
+      node.body ? node.body.as_code : ''
+    end
+  end
+
+  define_code(:NEWLINE) do |node, indent|
+    node.next.as_code(indent)
+  end
+
+  define_code(:CASE) do |node, indent|
+    "#{'  '*indent}case #{node.head.as_expression}\n" +
+    "#{node.body.as_code(indent)}end"
+  end
+
+  define_code(:WHEN) do |node, indent|
+    args = node.head.to_a.map { |n| n.as_expression }
+    s = "#{'  '*indent}when #{args.join(', ')}\n"
+    if node.body then
+      s << "#{'  '*indent}#{node.body.as_code(indent+1)}; "
+    end
+    if node.next then
+      s << node.next.as_code
+    end
+    s
+  end
+
+  define_code(:CLASS) do |node, indent|
+    s_super = node.super ? " < #{node.super.as_expression}" : ''
+    if node.respond_to?(:cpath) then
+      path = node.cpath.as_expression
+    else
+      path = node.cname
+    end
+    "#{'  '*indent}class #{path}#{s_super}\n" +
+    "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+    "#{'  '*indent}end"
+  end
+
+  define_code(:SCLASS) do |node, indent|
+    "#{'  '*indent}class << #{node.recv.as_expression}\n" +
+    "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+    "#{'  '*indent}end"
+  end
+
+  define_code(:DEFN) do |node, indent|
+    # TODO: what to do about noex?
+    "#{'  '*indent}def #{node.mid}\n" +
+    "#{'  '*indent}#{node.next.as_code(indent+1)}\n" +
+    "#{'  '*indent}end"
+  end
+
+  define_code(:DEFS) do |node, indent|
+    "#{'  '*indent}def #{node.recv.as_expression}.#{node.mid}\n" +
+    "#{'  '*indent}#{node.next.as_code(indent+1)}\n" +
+    "#{'  '*indent}end"
+  end
+
+  define_code(:SCOPE) do |node, indent|
+    case node.next
+    when nil then ''
+    when Node::ARGS then "#{'  '*indent}nil"
+    when Node::BLOCK_ARG then "#{'  '*indent}nil"
+    else node.next.as_code(indent)
+    end
+  end
+end