ruby-internal 0.6.0

data/lib/internal/node/dump.rb

@@ -0,0 +1,53 @@
+# This is a script similar to the Pragmatic Programmers' NodeDump.so.
+# You can use it similarly, e.g.:
+#
+#   $ cat test.rb
+#   def foo
+#     1+1
+#   end
+#
+#   $ ruby -rinternal/node/dump test.rb
+#   NODE_NEWLINE at test.rb:1
+#   |-nth = 1
+#   +-next = NODE_DEFN at test.rb:1
+#     |-defn = NODE_SCOPE at test.rb:3
+#     | |-rval = false
+#     | |-tbl = nil
+#     | +-next = NODE_BLOCK at test.rb:1
+#     |   |-next = NODE_BLOCK at test.rb:3
+#     |   | |-next = false
+#     |   | +-head = NODE_NEWLINE at test.rb:2
+#     |   |   |-nth = 2
+#     |   |   +-next = NODE_CALL at test.rb:2
+#     |   |     |-recv = NODE_LIT at test.rb:2
+#     |   |     | +-lit = 1
+#     |   |     |-args = NODE_ARRAY at test.rb:2
+#     |   |     | |-alen = 1
+#     |   |     | |-head = NODE_LIT at test.rb:2
+#     |   |     | | +-lit = 1
+#     |   |     | +-next = false
+#     |   |     +-mid = :+
+#     |   +-head = NODE_ARGS at test.rb:1
+#     |     |-cnt = 0
+#     |     |-rest = -1
+#     |     +-opt = false
+#     |-mid = :foo
+#     +-noex = PRIVATE
+
+require 'internal/node/pp'
+
+set_trace_func proc {
+  begin
+    n = $ruby_eval_tree
+    if defined?($ruby_eval_tree_begin) and $ruby_eval_tree_begin then
+      pp $ruby_eval_tree_begin, $stderr
+    end
+    if n then
+      PP.pp n, $stderr
+      exit!
+    end
+  rescue Exception
+    p $!, $!.backtrace
+  end
+}
+

data/lib/internal/node/pp.rb

@@ -0,0 +1,72 @@
+# Require this file to get a node pretty-printer.
+#
+
+require 'internal/node'
+require 'internal/vm'
+require 'pp'
+
+module Noex
+  # Return a string representing the given integer as a noex value.
+  #
+  def stringify(noex)
+    Noex.constants.each do |constant|
+      return constant.to_s if const_get(constant) == noex
+    end
+    return noex.to_s
+  end
+  module_function :stringify
+end
+
+class Node
+  # Return a string containing an ascii-art tree of the node's
+  # structure.
+  #
+  def tree(s = '', prefix = '')
+    s << "NODE_#{self.nd_type.to_s} at #{self.nd_file}:#{self.nd_line}\n"
+    self.members.each_with_index do |member, idx|
+      last = (idx == self.members.size-1)
+      s << "#{prefix}#{(last ? '+-' : '|-')}#{member} = "
+      value = self[member]
+      if Node === value then
+        value.tree(s, prefix + (last ? '  ' : '| '))
+      elsif defined?(RubyVM) and
+            defined?(RubyVM::InstructionSequence) and
+            RubyVM::InstructionSequence === value then
+        s << "<ISeq:#{value.self.name}@#{value.self.filename}>\n"
+        d = value.disasm
+        lines = d.split("\n")
+        lines.each_with_index do |line, line_idx|
+          if line =~ /^== disasm: (.*?)=/ then line = $1; end
+          if line =~ /(.*)\s+\(\s*\d+\)/ then line = $1; end
+          next if line =~ /^\|-----/
+          last_line = (line_idx == lines.size-1)
+          s << "#{prefix}#{last ? '  ' : '| '}#{(last_line ? '+-' : '|-')}#{line}\n"
+        end
+        # p value.local_table
+      elsif member == 'noex' then
+        s << Noex.stringify(value) + "\n"
+      else
+        s << value.inspect + "\n"
+      end
+    end
+    return s
+  end
+
+  # Pretty-print node using Node#tree onto s, which can be a String or
+  # IO.
+  #
+  def pretty_print(pp)
+    pp.text(tree())
+  end
+end
+
+if __FILE__ == $0 then
+  def foo # :nodoc:
+    1 + 1
+  end
+
+  m = method(:foo)
+  n = m.body
+  puts n.pretty_print
+end
+

data/lib/internal/node/to_a.rb

@@ -0,0 +1,52 @@
+class Node
+
+  class ARRAY < Node
+    def to_a
+      a = []
+      e = self
+      while e do
+        a << e.head
+        e = e.next
+      end
+      a
+    end
+  end
+
+  class ZARRAY < Node
+    def to_a
+      []
+    end
+  end
+
+  class BLOCK < Node
+    def to_a
+      a = []
+      e = self
+      while e do
+        a << e.head
+        e = e.next
+      end
+      a
+    end
+  end
+
+  class LIT < Node
+    def to_a
+      return [ self ]
+    end
+  end
+
+  if defined?(TO_ARY) then
+    class TO_ARY < Node
+      def to_a
+        return [ self.head ]
+      end
+    end
+  end
+
+  def to_a
+    raise NotImplementedError, "#to_a not defined for #{self.class}"
+  end
+
+end
+

data/lib/internal/noex.rb

@@ -0,0 +1 @@
+require 'internal/noex/noex'

data/lib/internal/obfusc.rb

@@ -0,0 +1,57 @@
+# A code obfuscator for Ruby.  It works by getting a dump of the node
+# tree, then wrapping it with a lightweight loader.
+#
+# NOTE: This code is for demonstration purposes only!  It has not been
+# extensively tested, and I cannot guarantee that it works in all cases
+# (I don't even know what the corner cases are).  If you wish to use
+# this in a commercial product, please verify that the code is correctly
+# loaded.
+#
+# Usage:
+#
+#   $ cat test.rb
+#   def foo
+#     1+1
+#   end
+#   
+#   puts foo()
+#
+#   $ ruby -rinternal/obfusc test.rb > test2.rb
+#   $ ruby test2.rb
+#   2
+
+require 'internal/node'
+
+def obfusc(begin_nodes, n)
+  # The outputted code must do the following:
+  #   1. Evaluate each of the begin nodes (BEGIN {...}).
+  #   2. Evaluate the main node.
+  puts <<-END
+require 'internal/node'
+if RUBY_VERSION != "#{RUBY_VERSION}" then
+  $stderr.puts "Wrong Ruby version; please use #{RUBY_VERSION}"
+  exit 1
+end
+begin_nodes = Marshal.load(#{Marshal.dump(begin_nodes).inspect})
+n = Marshal.load(#{Marshal.dump(n).inspect})
+begin_nodes.each do |node|
+  node.eval(self)
+end
+n.eval(self)
+  END
+end
+
+begin_nodes = []
+set_trace_func proc {
+  n = $ruby_eval_tree
+  if defined?($ruby_eval_tree_begin) and $ruby_eval_tree_begin then
+    n.pretty_print($stderr)
+    begin_nodes << $ruby_eval_tree_begin
+  end
+  if n then
+    # TODO: Do I need to include ruby_dyna_vars?
+    obfusc(begin_nodes, n)
+    exit
+  end
+}
+

data/lib/internal/object.rb

@@ -0,0 +1 @@
+require 'internal/object/object'

data/lib/internal/object/as_code.rb

@@ -0,0 +1,10 @@
+require 'internal/node/as_code'
+require 'internal/object'
+
+class Object
+  def as_code(indent=0)
+    # TODO: this won't work for many objects
+    "#{'  '*indent}#{self.inspect}"
+  end
+end
+

data/lib/internal/proc.rb

@@ -0,0 +1 @@
+require 'internal/proc/proc'

data/lib/internal/proc/as_code.rb

@@ -0,0 +1,21 @@
+require 'internal/node/as_code'
+require 'internal/proc'
+require 'internal/proc/signature'
+
+class Proc
+  def as_code(indent=0)
+    sig = self.signature
+    body_expression = self.body ? self.body.as_code(indent+1) : nil
+    s = "#{'  '*indent}proc do"
+    if not sig.args.unspecified then
+      s += " #{sig}"
+    end
+    s += "\n"
+    if body_expression then
+      s += "#{body_expression}\n"
+    end
+    s += "#{'  '*indent}end"
+    return s
+  end
+end
+

data/lib/internal/proc/as_expression.rb

@@ -0,0 +1,14 @@
+require 'internal/node/as_expression'
+require 'internal/proc/signature'
+require 'internal/proc'
+
+class Proc
+  def as_expression
+    sig = self.signature
+    body_expression = self.body ? self.body.as_expression : nil
+    s = sig.args.unspecified ? "" : sig.to_s + ' '
+    b = body_expression ? body_expression + ' ' : ''
+    return "proc { #{s}#{b}}"
+  end
+end
+

data/lib/internal/proc/signature.rb

@@ -0,0 +1,184 @@
+require 'internal/node'
+require 'internal/proc'
+require 'internal/vm'
+
+class Proc
+  class Arguments
+    include Enumerable
+
+    def initialize(names, multiple_assignment, rest_arg)
+      @names = names
+      @multiple_assignment = multiple_assignment
+      @rest_arg = rest_arg
+    end
+
+    def unspecified
+      if defined?(RubyVM) and defined?(RubyVM::InstructionSequence) then
+        # YARV
+        return @names.length == 0
+      else
+        # pre-YARV
+        @names.nil?
+      end
+    end
+
+    def single_assignment
+      !@multiple_assignment
+    end
+
+    def multiple_assignment
+      @multiple_assignment
+    end
+
+    def names
+      @names
+    end
+
+    def [](idx)
+      @names[idx]
+    end
+
+    def each(&block)
+      (@names || []).each(&block)
+    end
+
+    def size
+      @names.size
+    end
+
+    def rest_arg
+      @rest_arg
+    end
+
+    def empty_last_arg
+      if defined?(VM) and defined?(VM::InstructionSequence) then
+        # YARV
+        return (@rest_arg and @names[-1] == nil)
+      else
+        # pre-YARV
+        return (@names.size == 1 and not @rest_arg)
+      end
+    end
+  end
+
+  # Return an Arguments object representing the arguments in the order
+  # in which they appear in the argument list.
+  def arguments
+    has_rest_arg = self.has_rest_arg
+
+    if self.respond_to?(:var) then
+      # pre-YARV
+      case self.var
+      when Node::DASGN_CURR
+        return Arguments.new([ self.var.vid ], false, has_rest_arg ? 0 : nil)
+      when Node::MASGN
+        if self.var.head then
+          a = self.var.head.to_a
+          args = a.map { |n| n.vid }
+        else
+          args = []
+        end
+        if self.var.args then
+          args.push(self.var.args.vid)
+        end
+        return Arguments.new(args, true, has_rest_arg ? args.size - 1: nil)
+      when nil
+        return Arguments.new(nil, false, has_rest_arg ? 0 : nil)
+      when Fixnum
+        return Arguments.new([], false, has_rest_arg ? 0 : nil)
+      else
+        raise "Unexpected node type: #{self.var.class}"
+      end
+    elsif
+      # YARV
+      iseq = self.body
+      local_vars = iseq.local_table
+      has_rest_arg = iseq.arg_rest != -1
+      has_block_arg = iseq.arg_block != -1
+      num_args = \
+        iseq.argc + \
+        iseq.arg_opt_table.size + \
+        (has_rest_arg ? 1 : 0) + \
+        (has_block_arg ? 1 : 0)
+      names = local_vars[0...num_args]
+      # TODO: masgn
+      return Arguments.new(names, true, has_rest_arg ? -1 : nil)
+    else
+      return Arguments.new(nil, false, nil)
+    end
+  end
+
+  # Return true if the proc has a rest arg
+  def has_rest_arg
+    if self.respond_to?(:var) then
+      # pre-YARV
+      has_rest_arg = false
+      if self.var then
+        if self.var.class == Node::MASGN then
+          if self.var.args then
+            has_rest_arg = true
+          end
+        end
+      end
+    else
+      # YARV
+      rest = self.body.arg_rest
+      has_rest_arg = (rest >= 0 ? rest - 1 : nil)
+    end
+    return has_rest_arg
+  end
+
+  # Return a hash mapping each argument name to a description of that
+  # argument.
+  def argument_info
+    args = self.arguments()
+
+    info = {}
+    args.each do |name|
+      info[name] = name.to_s
+    end
+
+    # Rest arg
+    if args.rest_arg then
+      rest_name = args[args.rest_arg]
+      if rest_name then
+        info[rest_name] = "*#{rest_name}"
+      end
+    end
+
+    return info
+  end
+
+  class Signature
+    attr_reader :args, :arg_info
+
+    def initialize(args, arg_info)
+      @args = args
+      @arg_info = arg_info
+    end
+
+    def to_s
+      if @args.unspecified then
+        return ""
+      elsif @args.multiple_assignment then
+        if @args.empty_last_arg then
+          params = @args.map{ |n| arg_info[n] }
+          return "|#{@arg_info[@args[0]]},|"
+        else
+          params = @args.map{ |n| arg_info[n] }
+          return "|#{params.join(', ')}|"
+        end
+      else
+        return "|#{@arg_info[@args[0]]}|"
+      end
+    end
+  end
+
+  # Return a String representing the method's signature.
+  def signature
+    return Signature.new(
+        arguments(),
+        argument_info)
+  end
+end
+