furnace 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rbx/

data/.rvmrc

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
+environment_id="rbx-head@furnace"
+
+#
+# Uncomment following line if you want options to be set only for given project.
+#
+# PROJECT_JRUBY_OPTS=( --1.9 )
+
+#
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+#
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+
+  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
+  then
+    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  if ! rvm --create  "$environment_id"
+  then
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  fi
+fi
+
+#
+# If you use an RVM gemset file to install a list of gems (*.gems), you can have
+# it be automatically loaded. Uncomment the following and adjust the filename if
+# necessary.
+#
+# filename=".gems"
+# if [[ -s "$filename" ]]
+# then
+#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
+# fi
+
+# If you use bundler, this might be useful to you:
+# if command -v bundle && [[ -s Gemfile ]]
+# then
+#   bundle install
+# fi
+
+if [[ $- == *i* ]] # check for interactive shells
+then
+    echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
+else 
+	echo "Using: $GEM_HOME" # don't use colors in interactive shells
+fi
+

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in furnace.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/furnace

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'furnace'
+
+load ARGV[0]
+
+pipeline = Furnace::Transform::Pipeline.new(*[
+  Furnace::Transform::Rubinius::ASTBuild.new,
+  Furnace::Transform::Rubinius::ASTNormalize.new,
+
+  Furnace::Transform::Generic::LabelNormalize.new,
+  Furnace::Transform::Generic::CFGBuild.new,
+  Furnace::Transform::Generic::CFGNormalize.new,
+
+  Furnace::Transform::Generic::ANFBuild.new,
+
+  Furnace::Transform::Optimizing::FoldConstants.new,
+])
+
+cfg, = pipeline.run(method(:main).executable)
+
+puts cfg.to_graphviz

data/furnace.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "furnace/version"
+
+Gem::Specification.new do |s|
+  s.name        = "furnace"
+  s.version     = Furnace::VERSION
+  s.authors     = ["Peter Zotov"]
+  s.email       = ["whitequark@whitequark.org"]
+  s.homepage    = "http://github.com/whitequark/furnace"
+  s.summary     = %q{A static Ruby compiler}
+  s.description = %q{Furnace aims to compile Ruby code into small static } <<
+                  %q{executables by restricting its metaprogramming features.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/furnace/anf/edge.rb

@@ -0,0 +1,6 @@
+module Furnace
+  module ANF
+    class Edge < Struct.new(:source, :target, :param)
+    end
+  end
+end

data/lib/furnace/anf/graph.rb

@@ -0,0 +1,60 @@
+module Furnace
+  module ANF
+    class Graph
+      attr_reader   :nodes, :edges
+      attr_accessor :root
+
+      def initialize
+        @root  = nil
+        @nodes = Set.new
+        @edges = Set.new
+      end
+
+      def find(label)
+        @nodes.find { |node| node.label == label }
+      end
+
+      def eliminate_dead_code
+        live_set = search
+        @nodes  &= live_set
+      end
+
+      def search
+        seen_set = Set.new
+        work_set = Set.new
+
+        work_set.add @root
+
+        while work_set.any?
+          node = work_set.first
+          work_set.delete node
+          seen_set.add node
+
+          yield node if block_given?
+
+          node.leaving_edges.map(&:target).each do |target|
+            work_set.add target unless seen_set.include? target
+          end
+        end
+
+        seen_set
+      end
+
+      def to_graphviz
+        Graphviz.new do |graph|
+          @nodes.each do |node|
+            graph.node node.object_id, node.to_human_readable
+
+            case node
+            when ANF::IfNode
+              graph.edge node.object_id, node.leaving_edge(true).target.object_id, "true"
+              graph.edge node.object_id, node.leaving_edge(false).target.object_id, "false"
+            when ANF::LetNode, ANF::InNode
+              graph.edge node.object_id, node.leaving_edge.target.object_id
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/furnace/anf/if_node.rb

@@ -0,0 +1,17 @@
+module Furnace
+  module ANF
+    class IfNode < Node
+      attr_reader :condition
+
+      def initialize(graph, condition)
+        super(graph)
+
+        @condition = condition
+      end
+
+      def to_human_readable
+        "if\n#{humanize @condition}"
+      end
+    end
+  end
+end

data/lib/furnace/anf/in_node.rb

@@ -0,0 +1,17 @@
+module Furnace
+  module ANF
+    class InNode < Node
+      attr_reader :expressions
+
+      def initialize(graph, expressions)
+        super(graph)
+
+        @expressions = expressions
+      end
+
+      def to_human_readable
+        "in\n#{@expressions.map { |e| "#{e.to_sexp(1)}" }.join "\n"}"
+      end
+    end
+  end
+end

data/lib/furnace/anf/let_node.rb

@@ -0,0 +1,37 @@
+module Furnace
+  module ANF
+    class LetNode < Node
+      attr_reader :arguments
+
+      def initialize(graph, arguments)
+        super(graph)
+
+        @arguments = arguments
+      end
+
+      def try_eliminate
+        if identity?
+          entering_edges.each do |edge|
+            edge.target = leaving_edge.target
+          end
+        end
+      end
+
+      def identity?
+        @arguments.reduce(true) { |r, (k, v)| r && (v === k) }
+      end
+
+      def try_propagate
+      end
+
+      def static?(node)
+        [ NilClass, TrueClass, FalseClass, Fixnum, Symbol,
+          AST::LocalVariable, AST::InstanceVariable ].include? node.class
+      end
+
+      def to_human_readable
+        "let\n#{@arguments.map { |k, v| "  #{k} = #{humanize v}" }.join "\n"}"
+      end
+    end
+  end
+end

data/lib/furnace/anf/node.rb

@@ -0,0 +1,31 @@
+module Furnace
+  module ANF
+    class Node
+      attr_reader :graph
+
+      def initialize(graph)
+        @graph = graph
+      end
+
+      def leaving_edges
+        @graph.edges.select { |edge| edge.source == self }
+      end
+
+      def leaving_edge(param=nil)
+        @graph.edges.find   { |edge| edge.source == self && edge.param == param }
+      end
+
+      def entering_edges
+        @graph.edges.select { |edge| edge.target == self }
+      end
+
+      def humanize(node)
+        if node.is_a? AST::Node
+          node.to_sexp
+        else
+          node.inspect
+        end
+      end
+    end
+  end
+end

data/lib/furnace/anf/return_node.rb

@@ -0,0 +1,17 @@
+module Furnace
+  module ANF
+    class ReturnNode < Node
+      attr_reader :result
+
+      def initialize(graph, result)
+        super(graph)
+
+        @result = result
+      end
+
+      def to_human_readable
+        "return\n#{humanize @result}"
+      end
+    end
+  end
+end

data/lib/furnace/ast/node.rb

@@ -0,0 +1,70 @@
+module Furnace
+  module AST
+    class Node
+      attr_accessor :type, :parent, :children, :metadata
+
+      def initialize(type, children=[], metadata={})
+        @type, @children, @metadata = type.to_sym, children, metadata
+      end
+
+      def update(type, children=nil, metadata={})
+        @type     = type
+        @children = children || @children
+
+        # If something non-nil is passed, including default value, then merge.
+        # Else, clear metadata store.
+        if metadata
+          @metadata.merge!(metadata)
+        else
+          @metadata = {}
+        end
+
+        self
+      end
+
+      def index
+        parent.children.find_index(self)
+      end
+
+      def next
+        parent.children[index + 1]
+      end
+
+      def prev
+        parent.children[index - 1]
+      end
+
+      def to_s
+        "(#{fancy_type} ...)"
+      end
+
+      def to_sexp(indent=0)
+        str = "#{"  " * indent}(#{fancy_type}"
+
+        children.each do |child|
+          if child.is_a? Node
+            str << "\n#{child.to_sexp(indent + 1)}"
+          else
+            str << " #{child.inspect}"
+          end
+        end
+
+        str << ")"
+
+        str
+      end
+      alias :inspect :to_sexp
+
+      protected
+
+      def fancy_type
+        dasherized = @type.to_s.gsub('_', '-')
+        if @metadata[:label]
+          "#{@metadata[:label]}:#{dasherized}"
+        else
+          dasherized
+        end
+      end
+    end
+  end
+end

data/lib/furnace/ast/symbolic_node.rb

@@ -0,0 +1,36 @@
+module Furnace
+  module AST
+    class SymbolicNode
+      def initialize(name)
+        @name = name.to_sym
+      end
+
+      def to_sym
+        @name
+      end
+
+      def ===(name)
+        @name == name.to_sym
+      end
+
+      def inspect
+        @name.to_s
+      end
+    end
+
+    class MethodName < SymbolicNode
+      def inspect
+        ".#{@name}"
+      end
+    end
+
+    class LocalVariable < SymbolicNode
+      def inspect
+        "%#{@name}"
+      end
+    end
+
+    class Constant < SymbolicNode
+    end
+  end
+end

data/lib/furnace/ast/visitor.rb

@@ -0,0 +1,42 @@
+module Furnace
+  module AST
+    module Visitor
+      def visit(node)
+        node.children.map! do |child|
+          if child.is_a? Node
+            visit child
+
+            if child.type == :expand
+              child = child.children
+            end
+          end
+
+          child
+        end
+
+        node.children.flatten!
+
+        node.children.delete_if do |child|
+          if child.is_a? Node
+            child.parent = node
+
+            child.type == :remove
+          end
+        end
+
+        # Invoke a specific handler
+        on_handler = :"on_#{node.type}"
+        if respond_to? on_handler
+          send on_handler, node
+        end
+
+        # Invoke a generic handler
+        if respond_to? :on_any
+          send :on_any, node
+        end
+
+        node
+      end
+    end
+  end
+end

data/lib/furnace/cfg/edge.rb

@@ -0,0 +1,36 @@
+module Furnace
+  module CFG
+    class Edge
+      attr_accessor :source_operation, :source_label, :target_label
+
+      def initialize(cfg, source_operation, source_label, target_label)
+        @cfg, @source_operation, @source_label, @target_label =
+            cfg, source_operation, source_label, target_label
+      end
+
+      def source
+        @cfg.find_node(@source_label)
+      end
+
+      def target
+        @cfg.find_node(@target_label) if @target_label
+      end
+
+      def source=(node)
+        @source_label = node.label
+      end
+
+      def target=(node)
+        if node
+          @target_label = node.label
+        else
+          @target_label = nil
+        end
+      end
+
+      def inspect
+        "<#{@source_label.inspect} -> #{@target_label.inspect}>"
+      end
+    end
+  end
+end

data/lib/furnace/cfg/graph.rb

@@ -0,0 +1,59 @@
+module Furnace
+  module CFG
+    class Graph
+      attr_reader :nodes, :edges
+
+      def initialize
+        @nodes = Set.new
+        @edges = Set.new
+
+        @pending_label      = nil
+        @pending_operations = []
+      end
+
+      def find_node(label)
+        if node = @nodes.find { |n| n.label == label }
+          node
+        else
+          raise "Cannot find CFG node #{label}"
+        end
+      end
+
+      def expand(label, operation)
+        @pending_label ||= label
+        @pending_operations << operation
+      end
+
+      def transfer(targets)
+        return unless @pending_label
+
+        @nodes << CFG::Node.new(self, @pending_label, @pending_operations)
+
+        targets.each do |operation, target|
+          @edges << CFG::Edge.new(self, operation, @pending_label, target)
+        end
+
+        @pending_label      = nil
+        @pending_operations = []
+      end
+
+      def to_graphviz
+        Graphviz.new do |graph|
+          @nodes.each do |node|
+            graph.node node.label, node.operations.map(&:inspect).join("\n")
+          end
+
+          @edges.each do |edge|
+            if edge.source_operation.nil?
+              label = "~"
+            else
+              label = edge.source_operation
+            end
+
+            graph.edge edge.source_label, edge.target_label, label
+          end
+        end
+      end
+    end
+  end
+end

data/lib/furnace/cfg/node.rb

@@ -0,0 +1,39 @@
+module Furnace
+  module CFG
+    class Node
+      attr_reader :label, :operations
+
+      def initialize(cfg, label, operations)
+        @cfg, @label, @operations = cfg, label, operations
+      end
+
+      def entering_edges
+        @cfg.edges.select { |e| e.target == self }
+      end
+
+      def leaving_edges
+        @cfg.edges.select { |e| e.source == self }
+      end
+
+      def leaving_edge(source)
+        leaving_edges.find { |e| e.source_operation == source }
+      end
+
+      def default_leaving_edge
+        leaving_edge(nil)
+      end
+
+      def ==(other)
+        self.label == other.label
+      end
+
+      def inspect
+        if @label
+          "<#{@label}:#{@operations.map(&:inspect).join ", "}>"
+        else
+          "<!exit>"
+        end
+      end
+    end
+  end
+end

data/lib/furnace/graphviz.rb

@@ -0,0 +1,30 @@
+module Furnace
+  class Graphviz
+    def initialize
+      @code = "digraph {\n"
+      @code << "node [labeljust=l,nojustify=true,fontname=monospace];"
+      @code << "rankdir=TB;"
+
+      yield self
+
+      @code << "}"
+    end
+
+    def node(name, content)
+      content.gsub!("&", "&amp;")
+      content.gsub!(">", "&gt;")
+      content.gsub!("<", "&lt;")
+      content = content.lines.map { |l| %Q{<tr><td align="left">#{l}</td></tr>} }.join
+
+      @code << %Q{#{name.inspect} [shape=box,label=<<table border="0">#{content}</table>>];\n}
+    end
+
+    def edge(from, to, label="")
+      @code << %Q{#{from.inspect} -> #{to.inspect} [label=#{label.inspect}];\n}
+    end
+
+    def to_s
+      @code
+    end
+  end
+end