furnace 0.2.6 → 0.3.1

data/lib/furnace/cfg/algorithms.rb

@@ -0,0 +1,193 @@
+module Furnace::CFG
+  module Algorithms
+    def eliminate_unreachable!
+      worklist  = Set[ entry, exit ]
+      reachable = Set[]
+
+      while worklist.any?
+        node = worklist.first
+        worklist.delete node
+        reachable.add node
+
+        node.targets.each do |target|
+          unless reachable.include? target
+            worklist.add target
+          end
+        end
+
+        if node.exception
+          unless reachable.include? node.exception
+            worklist.add node.exception
+          end
+        end
+      end
+
+      @nodes.each do |node|
+        unless reachable.include? node
+          @nodes.delete node
+          yield node if block_given?
+        end
+      end
+
+      flush
+    end
+
+    def merge_redundant!
+      worklist = @nodes.dup
+      while worklist.any?
+        node = worklist.first
+        worklist.delete node
+
+        target = node.targets[0]
+        next if target == @exit
+
+        # Skip explicitly non-redundant nodes
+        if node.metadata[:keep]
+          next
+        end
+
+        if node.targets.uniq == [target] &&
+            target.sources.uniq == [node] &&
+            node.exception == target.exception
+
+          yield node, target if block_given?
+
+          node.insns.delete node.cti
+          @nodes.delete target
+          worklist.delete target
+
+          node.insns.concat target.insns
+          node.cti           = target.cti
+          node.target_labels = target.target_labels
+
+          worklist.add node
+
+          flush
+        elsif node.targets.count == 1 &&
+            node.insns.empty?
+
+          target = node.targets.first
+
+          yield target, node if block_given?
+
+          node.sources.each do |source|
+            index = source.targets.index(node)
+            source.target_labels[index] = target.label
+          end
+
+          @nodes.delete node
+          worklist.delete node
+
+          if @entry == node
+            @entry = target
+          end
+
+          flush
+        end
+      end
+    end
+
+    # Shamelessly stolen from
+    # http://www.cs.colostate.edu/~mstrout/CS553/slides/lecture04.pdf
+    def compute_generic_domination(start, forward)
+      # values of β will give rise to dom!
+      dom = { start => Set[start] }
+
+      @nodes.each do |node|
+        next if node == start
+        dom[node] = @nodes.dup
+      end
+
+      change = true
+      while change
+        change = false
+        @nodes.each do |node|
+          next if node == start
+
+          # Are we computing dominators or postdominators?
+          if forward
+            edges = node.sources + node.exception_sources
+          elsif node.exception.nil?
+            edges = node.targets
+          else
+            edges = node.targets + [ node.exception ]
+          end
+
+          #   Key Idea [for dominators]
+          # If a node dominates all
+          # predecessors of node n, then it
+          # also dominates node n.
+          pred = edges.map do |source|
+            dom[source]
+          end.reduce(:&)
+
+          # An exception handler header node has no regular sources.
+          pred = [] if pred.nil?
+
+          current = Set[node].merge(pred)
+          if current != dom[node]
+            dom[node] = current
+            change = true
+          end
+        end
+      end
+
+      dom
+    end
+
+    def dominators
+      @dominators ||= compute_generic_domination(@entry, true)
+    end
+
+    def postdominators
+      @postdominators ||= compute_generic_domination(@exit, false)
+    end
+
+    # See also {#dominators} for references.
+    def identify_loops
+      loops = Hash.new { |h,k| h[k] = Set.new }
+
+      dom = dominators
+
+      @nodes.each do |node|
+        node.targets.each do |target|
+          #   Back edges
+          # A back edge of a natural loop is one whose
+          # target dominates its source.
+          if dom[node].include? target
+            loops[target].add node
+          end
+        end
+      end
+
+      # At this point, +loops+ contains a list of all nodes
+      # which have a back edge to the loop header. Expand
+      # it to the list of all nodes in the loop.
+      loops.each do |header, nodes|
+        #   Natural loop
+        # The natural loop of a back edge (m→n), where
+        # n dominates m, is the set of nodes x such that n
+        # dominates x and there is a path from x to m not
+        # containing n.
+        pre_header = dom[header]
+        all_nodes  = Set[header]
+
+        nodes.each do |node|
+          all_nodes.merge(dom[node] - pre_header)
+        end
+
+        nodes.replace all_nodes
+      end
+
+      loops.default = nil
+      loops
+    end
+
+    def flush
+      @dominators = nil
+      @postdominators = nil
+
+      super if defined?(super)
+    end
+  end
+end

data/lib/furnace/cfg/graph.rb

@@ -1,5 +1,7 @@
 module Furnace::CFG
   class Graph
+    include Algorithms
+
     attr_reader   :nodes
     attr_accessor :entry, :exit
 
@@ -21,188 +23,7 @@ module Furnace::CFG
       end
     end
 
-    def eliminate_unreachable!
-      worklist  = Set[ entry, exit ]
-      reachable = Set[]
-
-      while worklist.any?
-        node = worklist.first
-        worklist.delete node
-        reachable.add node
-
-        node.targets.each do |target|
-          unless reachable.include? target
-            worklist.add target
-          end
-        end
-
-        if node.exception
-          unless reachable.include? node.exception
-            worklist.add node.exception
-          end
-        end
-      end
-
-      @nodes.each do |node|
-        unless reachable.include? node
-          @nodes.delete node
-          yield node if block_given?
-        end
-      end
-
-      flush
-    end
-
-    def merge_redundant!
-      worklist = @nodes.dup
-      while worklist.any?
-        node = worklist.first
-        worklist.delete node
-
-        target = node.targets[0]
-        next if target == @exit
-
-        # Skip explicitly non-redundant nodes
-        if node.metadata[:keep]
-          next
-        end
-
-        if node.targets.uniq == [target] &&
-            target.sources.uniq == [node] &&
-            node.exception == target.exception
-
-          yield node, target if block_given?
-
-          node.insns.delete node.cti
-          @nodes.delete target
-          worklist.delete target
-
-          node.insns.concat target.insns
-          node.cti           = target.cti
-          node.target_labels = target.target_labels
-
-          worklist.add node
-
-          flush
-        elsif node.targets.count == 1 &&
-            node.insns.empty?
-
-          target = node.targets.first
-
-          yield target, node if block_given?
-
-          node.sources.each do |source|
-            index = source.targets.index(node)
-            source.target_labels[index] = target.label
-          end
-
-          @nodes.delete node
-          worklist.delete node
-
-          if @entry == node
-            @entry = target
-          end
-
-          flush
-        end
-      end
-    end
-
-    # Shamelessly stolen from
-    # http://www.cs.colostate.edu/~mstrout/CS553/slides/lecture04.pdf
-    def compute_generic_domination(start, forward)
-      # values of β will give rise to dom!
-      dom = { start => Set[start] }
-
-      @nodes.each do |node|
-        next if node == start
-        dom[node] = @nodes.dup
-      end
-
-      change = true
-      while change
-        change = false
-        @nodes.each do |node|
-          next if node == start
-
-          # Are we computing dominators or postdominators?
-          if forward
-            edges = node.sources + node.exception_sources
-          else
-            edges = node.targets + [ node.exception ]
-          end
-
-          #   Key Idea [for dominators]
-          # If a node dominates all
-          # predecessors of node n, then it
-          # also dominates node n.
-          pred = edges.map do |source|
-            dom[source]
-          end.reduce(:&)
-
-          # An exception handler header node has no regular sources.
-          pred = [] if pred.nil?
-
-          current = Set[node].merge(pred)
-          if current != dom[node]
-            dom[node] = current
-            change = true
-          end
-        end
-      end
-
-      dom
-    end
-
-    def dominators
-      @dominators ||= compute_generic_domination(@entry, true)
-    end
-
-    def postdominators
-      @postdominators ||= compute_generic_domination(@exit, false)
-    end
-
-    # See also {#dominators} for references.
-    def identify_loops
-      loops = Hash.new { |h,k| h[k] = Set.new }
-
-      dom = dominators
-
-      @nodes.each do |node|
-        node.targets.each do |target|
-          #   Back edges
-          # A back edge of a natural loop is one whose
-          # target dominates its source.
-          if dom[node].include? target
-            loops[target].add node
-          end
-        end
-      end
-
-      # At this point, +loops+ contains a list of all nodes
-      # which have a back edge to the loop header. Expand
-      # it to the list of all nodes in the loop.
-      loops.each do |header, nodes|
-        #   Natural loop
-        # The natural loop of a back edge (m→n), where
-        # n dominates m, is the set of nodes x such that n
-        # dominates x and there is a path from x to m not
-        # containing n.
-        pre_header = dom[header]
-        all_nodes  = Set[header]
-
-        nodes.each do |node|
-          all_nodes.merge(dom[node] - pre_header)
-        end
-
-        nodes.replace all_nodes
-      end
-
-      loops.default = nil
-      loops
-    end
-
-    def sources_for(node, exceptions=false)
+    def sources_for(node, find_exceptions=false)
       unless @source_map
         @source_map = Hash.new { |h, k| h[k] = [] }
         @exception_source_map = Hash.new { |h, k| h[k] = [] }
@@ -224,7 +45,7 @@ module Furnace::CFG
         end
       end
 
-      if exceptions
+      if find_exceptions
         @exception_source_map[node]
       else
         @source_map[node]
@@ -235,8 +56,7 @@ module Furnace::CFG
       @source_map = nil
       @label_map.clear
 
-      @dominators = nil
-      @postdominators = nil
+      super if defined?(super)
     end
 
     def to_graphviz

data/lib/furnace/cfg.rb

@@ -1,6 +1,7 @@
 require "set"
 
-require "furnace"
-
-require "furnace/cfg/graph"
-require "furnace/cfg/node"
+module Furnace
+  require_relative "cfg/node"
+  require_relative "cfg/algorithms"
+  require_relative "cfg/graph"
+end

data/lib/furnace/version.rb

@@ -1,3 +1,3 @@
 module Furnace
-  VERSION = "0.2.6"
+  VERSION = "0.3.1"
 end

data/lib/furnace.rb

@@ -1,13 +1,23 @@
+# Furnace is a set of tools for writing compilers, translators or
+# static analyzers--any programs which read, manipulate or transform
+# other programs.
+#
+# Currently it provides three independent modules, grouped by the main
+# data structure being used:
+#
+#  * Abstract syntax trees: {AST}
+#  * Control flow graphs: {CFG}
+#  * Transformations: {Transform}
+#
+# Additionally, a simple {Graphviz} adapter is provided.
 module Furnace
-end
+  require "furnace/version"
 
-require "furnace/version"
+  require "furnace/ast"
+  require "furnace/cfg"
 
-require "furnace/ast"
-require "furnace/cfg"
-require "furnace/code"
+  require "furnace/transform/pipeline"
+  require "furnace/transform/iterative_process"
 
-require "furnace/transform/pipeline"
-require "furnace/transform/iterative_process"
-
-require "furnace/graphviz"
+  require "furnace/graphviz"
+end

data/test/ast_test.rb

@@ -0,0 +1,185 @@
+require_relative 'test_helper'
+
+describe AST::Node do
+  class MetaNode < AST::Node
+    attr_reader :meta
+  end
+
+  before do
+    @node = AST::Node.new(:node, [ 0, 1 ])
+    @metanode = MetaNode.new(:node, [ 0, 1 ], meta: 'value')
+  end
+
+  it 'should have accessors for type and children' do
+    @node.type.should.equal :node
+    @node.children.should.equal [0, 1]
+  end
+
+  it 'should set metadata' do
+    @metanode.meta.should.equal 'value'
+  end
+
+  it 'should be frozen' do
+    @node.frozen?.should.be.true
+    @node.children.frozen?.should.be.true
+  end
+
+  it 'should not allow duping' do
+    -> { @node.dup }.should.raise NoMethodError
+  end
+
+  it 'should return an updated node, but only if needed' do
+    @node.updated().should.be.identical_to @node
+    @node.updated(:node).should.be.identical_to @node
+    @node.updated(nil, [0, 1]).should.be.identical_to @node
+
+    updated = @node.updated(:other_node)
+    updated.should.not.be.identical_to @node
+    updated.type.should.equal :other_node
+    updated.children.should.equal @node.children
+
+    updated.frozen?.should.be.true
+
+    updated = @node.updated(nil, [1, 1])
+    updated.should.not.be.identical_to @node
+    updated.type.should.equal @node.type
+    updated.children.should.equal [1, 1]
+
+    updated = @metanode.updated(nil, nil, meta: 'other_value')
+    updated.meta.should.equal 'other_value'
+  end
+
+  it 'should use fancy type in to_s' do
+    node = AST::Node.new(:ast_node)
+    node.to_s.should.equal '(ast-node ...)'
+  end
+
+  it 'should format to_sexp correctly' do
+    AST::Node.new(:a, [ :sym, [ 1, 2 ] ]).to_sexp.should.equal '(a :sym [1, 2])'
+    AST::Node.new(:a, [ :sym, @node ]).to_sexp.should.equal "(a :sym\n  (node 0 1))"
+    AST::Node.new(:a, [ :sym,
+      AST::Node.new(:b, [ @node, @node ])
+    ]).to_sexp.should.equal "(a :sym\n  (b\n    (node 0 1)\n    (node 0 1)))"
+  end
+
+  it 'should return self in to_ast' do
+    @node.to_ast.should.be.identical_to @node
+  end
+
+  it 'should only use type and children in comparisons' do
+    @node.should.equal @node
+    @node.should.equal @metanode
+    @node.should.not.equal :foo
+
+    mock_node = Object.new.tap do |obj|
+      def obj.to_ast
+        self
+      end
+
+      def obj.type
+        :node
+      end
+
+      def obj.children
+        [ 0, 1 ]
+      end
+    end
+    @node.should.equal mock_node
+  end
+end
+
+describe AST::Processor do
+  def have_sexp(text)
+    text = text.lines.map { |line| line.sub /^ +\|(.+)/, '\1' }.join.rstrip
+    lambda { |ast| ast.to_sexp == text }
+  end
+
+  class MockProcessor < AST::Processor
+    attr_reader :counts
+
+    def initialize
+      @counts = Hash.new(0)
+    end
+
+    def on_root(node)
+      count_node(node)
+      node.updated(nil, process_all(node.children))
+    end
+    alias on_body on_root
+
+    def on_def(node)
+      count_node(node)
+      name, arglist, body = node.children
+      node.updated(:def, [ name, process(arglist), process(body) ])
+    end
+
+    def handler_missing(node)
+      count_node(node)
+    end
+
+    def count_node(node)
+      @counts[node.type] += 1; nil
+    end
+  end
+
+  before do
+    @ast = AST::Node.new(:root, [
+      AST::Node.new(:def, [ :func,
+        AST::Node.new(:arglist, [ :foo, :bar ]),
+        AST::Node.new(:body, [
+          AST::Node.new(:invoke, [ :puts, "Hello world" ])
+        ])
+      ]),
+      AST::Node.new(:invoke, [ :func ])
+    ])
+
+    @processor = MockProcessor.new
+  end
+
+  it 'should visit every node' do
+    @processor.process(@ast).should.equal @ast
+    @processor.counts.should.equal({
+      root:    1,
+      def:     1,
+      arglist: 1,
+      body:    1,
+      invoke:  2
+    })
+  end
+
+  it 'should be able to replace inner nodes' do
+    def @processor.on_arglist(node)
+      node.updated(:new_fancy_arglist)
+    end
+
+    @processor.process(@ast).should have_sexp(<<-SEXP)
+    |(root
+    |  (def :func
+    |    (new-fancy-arglist :foo :bar)
+    |    (body
+    |      (invoke :puts "Hello world")))
+    |  (invoke :func))
+    SEXP
+  end
+
+  extend Furnace::AST::Sexp
+
+  it 'should build sexps' do
+    s(:add,
+      s(:integer, 1),
+      s(:multiply,
+        s(:integer, 2),
+        s(:integer, 3))).should have_sexp(<<-SEXP)
+    |(add
+    |  (integer 1)
+    |  (multiply
+    |    (integer 2)
+    |    (integer 3)))
+    SEXP
+  end
+
+  it 'should refuse to process non-nodes' do
+    -> { @processor.process(nil) }.should.raise NoMethodError, %r|to_ast|
+    -> { @processor.process([]) }.should.raise NoMethodError, %r|to_ast|
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,36 @@
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+require 'furnace'
+include Furnace
+
+module Bacon
+  module ColoredOutput
+    def handle_specification(name)
+      puts spaces + name
+      yield
+      puts if Counter[:context_depth] == 1
+    end
+
+    def handle_requirement(description)
+      print spaces
+
+      error = yield
+
+      print error.empty? ? "\e[32m" : "\e[1;31m"
+      print "  - #{description}"
+      puts error.empty? ? "\e[0m" : " [#{error}]\e[0m"
+    end
+
+    def handle_summary
+      print ErrorLog  if Backtraces
+      puts "%d specifications (%d requirements), %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+
+    def spaces
+      "  " * (Counter[:context_depth] - 1)
+    end
+  end
+
+  extend ColoredOutput
+end