furnace 0.4.0.beta.1 → 0.4.0.beta.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 09c880a785045b6520d037457d92d4c1fb5a5252
+  data.tar.gz: 95fe046fd5ae819eca7bc005230e688c7be97647
+SHA512:
+  metadata.gz: 432ac773720df277c3c0b8d834f9364176d5245cd84027c1d775a39d05f0107aff5b6bdfbd9fde5df8a2a886ef4db7c9a0a9e9a8f530ad9a3b3152b65317b801
+  data.tar.gz: fff823fe2cf09c881a6e827aa160ba8491e25e33d9dc38c4f8053975410290f293020b09d474c3bb9d76875056947e457fe7e886ae72af7b878a95463d336492

data/.travis.yml

@@ -1,4 +1,10 @@
 language: ruby
 rvm:
  - 1.9.3
+ - 2.0
  - jruby-19mode
+ - rbx-19mode
+
+matrix:
+  allow_failures:
+    - rvm: rbx-19mode

data/INSTRUMENT.md

@@ -0,0 +1,250 @@
+Insturmentation stream format
+=============================
+
+Instrumentation data is produced by Foundry as streams of events dumped
+as JSON. A stream corresponds to one function.
+
+Within a function, entities have names. Entity names are always unique.
+Entity names may change; in this case, all subsequent references are to be
+resolved via updated name.
+
+Entities may refer to types. Types are identified with a number, which is
+always unique and does not change.
+
+The root of the stream contains a Function.
+
+Type
+----
+
+There are several kinds of Types, disambiguated by the field "kind".
+
+### Void type
+
+{
+  "event":       "type",
+  "id":          <number>,
+  "kind":        "void",
+}
+
+Should render as:
+
+    void
+
+### Monotypes
+
+{
+  "event":       "type",
+  "id":          <number>,
+  "kind":        "monotype",
+  "name":        <string>
+}
+
+Should render as:
+
+    #{name}
+
+### Parametric types
+
+{
+  "event":       "type",
+  "id":          <number>,
+  "kind":        "parametric",
+  "name":        <string>,
+  "parameters":  <array of Type>
+}
+
+Should render as:
+
+    #{name}<#{parameters.map(&:render)}>
+
+Function
+--------
+
+{
+  "name":        <string>,
+  "present":     <Boolean>,
+  "events":      <array of Event>
+}
+
+### Set arguments
+
+{
+  "event":       "set_arguments",
+  "arguments":   <array of Argument>
+}
+
+### Set return type
+
+{
+  "event":       "set_return_type",
+  "return_type": <Type>
+}
+
+Argument
+--------
+
+{
+  "name":        <string>,
+  "type":        <Type>
+}
+
+Should render as:
+
+    #{type} %#{name}
+
+Basic block
+-----------
+
+Should render as:
+
+    #{name}:
+       #{instructions.map(&:render)}
+
+### Add basic block
+
+{
+  "event":       "add_basic_block",
+  "name":        <string>
+}
+
+### Remove basic block
+
+{
+  "event":       "remove_basic_block",
+  "name":        <string>
+}
+
+### Rename basic block
+
+{
+  "event":       "rename_basic_block",
+  "name":        <string>,
+  "new_name":    <string>
+}
+
+Operand
+-------
+
+### Constant operand
+
+{
+  "kind":        "constant",
+  "type":        <Type>,
+  "value":       <string>
+}
+
+Should render as:
+
+    #{type} #{value}
+
+### Argument operand
+
+{
+  "kind":        "argument",
+  "name":        <string>
+}
+
+Should render as:
+
+    %#{name}
+
+### Instruction operand
+
+{
+  "kind":        "instruction",
+  "name":        <string>
+}
+
+Should render as:
+
+    %#{name}
+
+### Basic block operand
+
+{
+  "kind":        "basic_block",
+  "name":        <string>
+}
+
+Should render as:
+
+    label %#{name}
+
+Presence of an operand of this type should create an edge in the graph.
+
+### Function operand
+
+{
+  "kind":        "function",
+  "name":        <string>
+}
+
+Should render as:
+
+    function "#{name}"
+
+Presence of an operand of this type should create a cross-reference link.
+
+Instruction
+-----------
+
+Should render as:
+
+1. If it has non-void type:
+
+    #{type} %#{name} = #{opcode} #{parameters} #{operands}
+
+2. If it has void type:
+
+    #{opcode} #{parameters} #{operands}
+
+If `opcode` is `phi`, render `operands` comma-separated with each operand as:
+
+    #{operand[0]} => #{operand[1]}
+
+Else, render `operands` as comma-separated operands.
+
+### Add instruction
+
+{
+  "event":       "add_instruction",
+  "name":        <string>,
+  "basic_block": <string>,
+  "position":    <number>
+}
+
+### Update instruction
+
+{
+  "event":       "update_instruction",
+  "opcode":      <string>,
+  "name":        <string>
+  "parameters":  <string>
+  "operands":    <array>
+  "type":        <Type>
+}
+
+### Remove instruction
+
+{
+  "event":       "remove_instruction",
+  "name":        <string>
+}
+
+### Rename instruction
+
+{
+  "event":       "rename_instruction",
+  "name":        <string>,
+  "new_name":    <string>
+}
+
+Miscellanea
+-----------
+
+### Transformation start
+
+{
+  "event":      "transform_start",
+  "name":        <string>
+}

data/Rakefile

@@ -5,7 +5,7 @@ task :default => :test
 
 desc "Run test suite"
 task :test do
-  sh "bacon test/*_test.rb"
+  sh "bacon -a"
 end
 
 PAGES_REPO = 'git@github.com:whitequark/furnace'

data/lib/furnace.rb

@@ -2,22 +2,26 @@
 # 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:
+# Currently it provides four loosely coupled modules, each operating
+# upon a single kind of entity:
 #
 #  * Abstract syntax trees: {AST}
+#  * Parametric types: {Type}
 #  * Static single assignment representation: {SSA}
 #  * Transformations: {Transform}
 #
-# Additionally, a simple {Graphviz} adapter is provided.
+# Additionally, a custom pretty printing module {AwesomePrinter} is
+# provided which has built-in knowledge of {Type}s.
+#
 module Furnace
   require "furnace/version"
 
+  require "furnace/awesome_printer"
+
   require "furnace/ast"
+  require "furnace/type"
   require "furnace/ssa"
 
   require "furnace/transform/pipeline"
   require "furnace/transform/iterative"
-
-  require "furnace/graphviz"
-end
+end

data/lib/furnace/ast/node.rb

@@ -123,6 +123,20 @@ module Furnace::AST
       end
     end
 
+    # Concatenates `array` with `children` and returns the resulting node.
+    #
+    # @return [AST::Node]
+    def +(array)
+      updated(nil, @children + array.to_a)
+    end
+
+    # Appends `element` to `children` and returns the resulting node.
+    #
+    # @return [AST::Node]
+    def <<(element)
+      updated(nil, @children + [element])
+    end
+
     # Converts `self` to a concise s-expression, omitting any children.
     #
     # @return [String]
@@ -198,4 +212,4 @@ module Furnace::AST
       @type.to_s.gsub('_', '-')
     end
   end
-end
+end

data/lib/furnace/awesome_printer.rb

@@ -0,0 +1,121 @@
+require 'ansi'
+
+module Furnace
+  class AwesomePrinter
+    @colorize = true
+
+    class << self
+      attr_accessor :colorize
+    end
+
+    def initialize(colorize=self.class.colorize,
+                      annotator=Type::Variable::Annotator.new)
+      @colorize   = colorize
+      @annotator  = annotator
+
+      @buffer     = ""
+      @need_space = false
+
+      yield self if block_given?
+    end
+
+    def to_s
+      @buffer
+    end
+
+    alias to_str to_s
+
+    def ==(other)
+      to_s == other
+    end
+
+    def =~(other)
+      to_s =~ other
+    end
+
+    def append(what)
+      @need_space = false
+      @buffer << what.to_s
+
+      self
+    end
+
+    def text(what)
+      ensure_space { append what }
+    end
+
+    def newline
+      append "\n"
+    end
+
+    def nest(what, &block)
+      if what
+        if what.respond_to? :awesome_print
+          what.awesome_print(self)
+        else
+          text what.to_s
+        end
+      end
+
+      self
+    end
+
+    def name(what)
+      text "%#{what}"
+    end
+
+    def type(what)
+      text with_ansi(:green) { what }
+    end
+
+    def type_variable(what)
+      text with_ansi(:bright, :magenta) { "~#{@annotator.annotate(what)}" }
+    end
+
+    def keyword(what)
+      text with_ansi(:bright, :white) { what }
+    end
+
+    def collection(left='', separator='', right='', what, &block)
+      return self if what.empty?
+
+      ensure_space do
+        append left
+
+        what.each.with_index do |element, index|
+          if index > 0
+            append separator
+          end
+
+          if block_given?
+            yield element
+          else
+            nest element
+          end
+        end
+
+        append right
+      end
+    end
+
+    protected
+
+    def with_ansi(*colors)
+      if @colorize
+        ANSI::Code.ansi(yield.to_s, *colors)
+      else
+        yield
+      end
+    end
+
+    def ensure_space
+      append " " if @need_space
+
+      yield
+
+      @need_space = true
+
+      self
+    end
+  end
+end