furnace 0.0.8 → 0.1.0

data/lib/furnace/cfg/graph.rb

@@ -1,13 +1,10 @@
 module Furnace::CFG
   class Graph
-    attr_reader :nodes, :edges
+    attr_reader   :nodes
+    attr_accessor :entry, :exit
 
     def initialize
       @nodes = Set.new
-      @edges = Set.new
-
-      @pending_label      = nil
-      @pending_operations = []
     end
 
     def find_node(label)
@@ -18,38 +15,183 @@ module Furnace::CFG
       end
     end
 
-    def expand(label, operation)
-      @pending_label ||= label
-      @pending_operations << operation
+    def eliminate_unreachable!
+      worklist = @nodes.dup
+      while worklist.any?
+        node = worklist.first
+        worklist.delete node
+
+        next if node == @entry
+
+        if node.sources.count == 0 ||
+              node.sources == [node]
+          @nodes.delete node
+          flush
+        end
+      end
     end
 
-    def transfer(targets)
-      return unless @pending_label
+    def merge_redundant!
+      worklist = @nodes.dup
+      while worklist.any?
+        node = worklist.first
+        worklist.delete node
+
+        target = node.targets[0]
+        next if target == @exit
+
+        if node.targets.count == 1 &&
+            target.sources.count == 1
+          node.insns.delete node.cti
+          @nodes.delete node
+          @nodes.delete target
 
-      @nodes << Node.new(self, @pending_label, @pending_operations)
+          new_node = Node.new(self,
+              node.label,
+              node.insns + target.insns,
+              target.cti,
+              target.target_labels)
+          @nodes.add new_node
+          worklist.add new_node
 
-      targets.each do |operation, target|
-        @edges << Edge.new(self, operation, @pending_label, target)
+          if @entry == node
+            @entry = new_node
+          end
+
+          flush
+        elsif node.targets.count == 1 &&
+            node.insns.empty?
+          target = node.targets.first
+
+          node.sources.each do |source|
+            index = source.targets.index(node)
+            source.target_labels[index] = target.label
+          end
+
+          @nodes.delete node
+
+          flush
+        end
       end
+    end
+
+    # Shamelessly stolen from
+    # http://www.cs.colostate.edu/~mstrout/CS553/slides/lecture04.pdf
+    def dominators
+      unless @dominators
+        # values of β will give rise to dom!
+        dom = { @entry => Set[@entry] }
+
+        @nodes.each do |node|
+          next if node == @entry
+          dom[node] = @nodes.dup
+        end
+
+        change = true
+        while change
+          change = false
+          @nodes.each do |node|
+            next if node == @entry
+
+            #   Key Idea
+            # If a node dominates all
+            # predecessors of node n, then it
+            # also dominates node n.
+            pred = node.sources.map do |source|
+              dom[source]
+            end.reduce(:&)
 
-      @pending_label      = nil
-      @pending_operations = []
+            current = Set[node].merge(pred)
+            if current != dom[node]
+              dom[node] = current
+              change = true
+            end
+          end
+        end
+
+        @dominators = dom
+      end
+
+      @dominators
     end
 
-    def to_graphviz
-      Furnace::Graphviz.new do |graph|
+    # 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
+    end
+
+    def source_map
+      unless @source_map
+        @source_map = Hash.new { |h, k| h[k] = [] }
+
         @nodes.each do |node|
-          graph.node node.label, node.operations.map(&:inspect).join("\n")
+          node.targets.each do |target|
+            @source_map[target] << node
+          end
         end
+      end
+
+      @source_map
+    end
 
-        @edges.each do |edge|
-          if edge.source_operation.nil?
-            label = "~"
+    def flush
+      @source_map = nil
+    end
+
+    def to_graphviz
+      Furnace::Graphviz.new do |graph|
+        @nodes.each do |node|
+          if node.label == nil
+            contents = "<exit>"
           else
-            label = edge.source_operation
+            contents = "<#{node.label.inspect}>\n#{node.insns.map(&:inspect).join("\n")}"
+          end
+
+          options = {}
+          if @entry == node
+            options.merge! color: 'green'
+          elsif @exit == node
+            options.merge! color: 'red'
           end
 
-          graph.edge edge.source_label, edge.target_label, label
+          graph.node node.label, contents, options
+
+          node.target_labels.each_with_index do |label, idx|
+            graph.edge node.label, label, "#{idx}"
+          end
         end
       end
     end

data/lib/furnace/cfg/node.rb

@@ -1,34 +1,53 @@
 module Furnace::CFG
   class Node
-    attr_reader :label, :operations
+    attr_reader   :cfg, :label
 
-    def initialize(cfg, label, operations)
-      @cfg, @label, @operations = cfg, label, operations
+    attr_reader   :instructions, :control_transfer_instruction
+    alias :insns :instructions
+    alias :cti   :control_transfer_instruction
+
+    def initialize(cfg, label=nil, insns=[], cti=nil, target_labels=[])
+      @cfg, @label  = cfg, label
+
+      @instructions = insns
+      @control_transfer_instruction = cti
+
+      @target_labels = target_labels
     end
 
-    def entering_edges
-      @cfg.edges.select { |e| e.target == self }
+    def target_labels
+      @target_labels
+    end
+
+    def targets
+      @target_labels.map do |label|
+        @cfg.find_node label
+      end
     end
 
-    def leaving_edges
-      @cfg.edges.select { |e| e.source == self }
+    def source_labels
+      sources.map &:label
     end
 
-    def leaving_edge(source)
-      leaving_edges.find { |e| e.source_operation == source }
+    def sources
+      @cfg.source_map[self]
     end
 
-    def default_leaving_edge
-      leaving_edge(nil)
+    def exits?
+      targets == [@cfg.exit]
     end
 
     def ==(other)
-      self.label == other.label
+      other.is_a?(Node) && self.label == other.label
     end
 
     def inspect
-      if @label
-        "<#{@label}:#{@operations.map(&:inspect).join ", "}>"
+      if @label && @instructions
+        "<#{@label}:#{@instructions.join ", "}>"
+      elsif @label
+        "<#{@label}>"
+      elsif @insns
+        "<!unlabeled>"
       else
         "<!exit>"
       end

data/lib/furnace/cfg.rb

@@ -2,6 +2,5 @@ require "set"
 
 require "furnace/base"
 
-require "furnace/cfg/edge"
 require "furnace/cfg/graph"
 require "furnace/cfg/node"

data/lib/furnace/code/separated_token.rb

@@ -1,6 +1,6 @@
 module Furnace
   module Code
-    class SeparatedToken < NonterminalToken
+    class SeparatedToken < SurroundedToken
       def text_between
         ""
       end

data/lib/furnace/code/token.rb

@@ -34,7 +34,7 @@ module Furnace
 
       protected
 
-      def indent(code, options)
+      def indent(code, options=@options)
         unless code.empty?
           code.to_s.gsub(/^/, (options[:indent_with] || '  ') * (options[:level] || 1))
         else

data/lib/furnace/graphviz.rb

@@ -1,23 +1,35 @@
 require 'furnace/base'
 
-module Furnace::Graphviz
+class Furnace::Graphviz
   def initialize
     @code = "digraph {\n"
     @code << "node [labeljust=l,nojustify=true,fontname=monospace];"
-    @code << "rankdir=TB;"
+    @code << "rankdir=TB;\n"
 
     yield self
 
     @code << "}"
   end
 
-  def node(name, content)
+  def node(name, content, options={})
     content.gsub!("&", "&amp;")
     content.gsub!(">", "&gt;")
     content.gsub!("<", "&lt;")
+    content.gsub!(/\*\*(.+?)\*\*/, '<b>\1</b>')
     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}
+    if content.empty?
+      label = "<&lt;empty&gt;>"
+    else
+      label = "<<table border=\"0\">#{content}</table>>"
+    end
+
+    options = options.merge({
+      shape: 'box',
+      label: label
+    })
+
+    @code << %Q{#{name.inspect} [#{options.map { |k,v| "#{k}=#{v}" }.join(",")}];\n}
   end
 
   def edge(from, to, label="")

data/lib/furnace/version.rb

@@ -1,3 +1,3 @@
 module Furnace
-  VERSION = "0.0.8"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: furnace
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-06 00:00:00.000000000 Z
+date: 2012-04-11 00:00:00.000000000 Z
 dependencies: []
 description: Furnace is a static code analysis framework for dynamic languages, aimed
   at efficient type and behavior inference.
@@ -44,7 +44,6 @@ files:
 - lib/furnace/ast/visitor.rb
 - lib/furnace/base.rb
 - lib/furnace/cfg.rb
-- lib/furnace/cfg/edge.rb
 - lib/furnace/cfg/graph.rb
 - lib/furnace/cfg/node.rb
 - lib/furnace/code.rb
@@ -90,3 +89,4 @@ signing_key:
 specification_version: 3
 summary: A static code analysis framework
 test_files: []
+has_rdoc: 

data/lib/furnace/cfg/edge.rb

@@ -1,34 +0,0 @@
-module Furnace::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