csquare 0.1.0

data/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+gemspec
+
+gem 'cast'
+
+#group :test do
+  gem 'rspec'
+#end

data/History.txt

@@ -0,0 +1,12 @@
+=== 0.1.0 / 2012-06-25
+
+* Complete refactoring of initial release (which didn't actually work).
+* Function pointer array and enumerator support (1D and 2D).
+* Uses the original author's cast gem instead of our fork.
+* Handles #RUBY "precompiler" directives.
+  * Note: These work on the Blueprint level, not the Type level.
+  * These allow processing of Ruby code within C templates.
+
+=== 0.0.1 / not released
+
+* Hello, world!

data/Manifest.txt

@@ -0,0 +1,21 @@
+Rakefile
+Gemfile
+README.rdoc
+Manifest.txt
+History.txt
+lib/csquare.rb
+lib/csquare/base.rb
+lib/csquare/cerb.rb
+lib/csquare/function.rb
+lib/csquare/generator.rb
+lib/csquare/generator/type.rb
+lib/csquare/generator/blueprint.rb
+lib/csquare/generator/op.rb
+lib/csquare/generator/assign_op.rb
+lib/csquare/generator/binary_op.rb
+lib/csquare/generator/boolean_op.rb
+lib/csquare/generator/enum.rb
+lib/csquare/generator/enum/namer.rb
+lib/csquare/generator/enum/op_namer.rb
+lib/csquare/generator/enum/sparse_op_namer.rb
+lib/csquare/generator/index.rb

data/README.rdoc

@@ -0,0 +1,63 @@
+= CSquare
+
+http://github.com/mohawkjohn/csquare
+
+== Description
+
+C, then D, C++, C# -- now C^2, simple C templates using Ruby.
+
+Consider this to be a sort of carpenter's square. We call it C^2, or csquare. It's a simple tool for simple jobs.
+
+This gem was developed for use in NMatrix (part of the SciRuby Project). We wanted to be able to write a single function
+and have it be modified to produce C sources for each datatype (rational, complex, integer, float, Ruby object, etc).
+
+It also produces some rudimentary function pointer arrays if you so desire, so that these functions can be accessed using
+array notation.
+
+Experimental! Use at your own risk. Actually, don't use this at all! It's extremely buggy and probably won't be useful
+for your purposes. It's really custom-designed to handle a specific use case: NMatrix dtype templates.
+
+== Example
+
+A full example is available in NMatrix starting at line 696: https://github.com/mohawkjohn/nmatrix/blob/csquare/ext/nmatrix/generator.rb
+
+Full examples of templates are available here: https://github.com/mohawkjohn/nmatrix/tree/csquare/ext/nmatrix/templates
+
+(Note that those templates and example are licensed as part of SciRuby.)
+
+Here's a simple CSquare source for complex numbers:
+
+    # looks in templates/ directory, outputs "test.c" and "test.h"
+    g = CSquare::Generator.new("templates", "test") do |c|
+      # Do this to register abbreviations for basic types
+      c.template_type(:float, 'TYPE') do |t|
+        t.type :f32, 'float'
+        t.type :f64, 'double'
+      end
+
+      c.template_type(:complex, 'TYPE', :r => 'FLOAT', :i => 'FLOAT') do |t|
+
+        t.type :c64, 'complex64', :long => :c128, 'FLOAT' => :f32
+        t.type :c128, 'complex128', 'FLOAT' => :f64
+
+        t.sources %w{div2 div4 mul2 mul4}
+
+        t.op :'==', 'TYPE' => '$0.r == $1.r && $0.i == $1.i', [:integer, :float] => '$0.r == $1 && $0.i == 0'
+
+        assign_str =
+        t.op :'=', [:integer, :boolean, :float] => '$0 = (struct $t) { $1, 0 }'
+
+        t.op :'*', 'TYPE' => 'mul2($0, $1)', :integer => 'mul4($0.r, $0.i, $1, 0)', :float => 'mul4($0.r, $0.i, $1, 0)'
+        t.op :'/', 'TYPE' => 'div2($0, $1)', :integer => 'div4($0.r, $0.i, $1, 0)', :float => 'div4($0.r, $0.i, $1, 0)'
+        t.op :'+', 'TYPE' => 'add2($0, $1)'
+        t.op :'-', 'TYPE' => 'sub2($0, $1)'
+      end
+    end
+
+== Installation
+
+    gem install cast csquare
+
+== License
+
+BSD 2-clause. Copyright John Woods (mohawkjohn on github), 2012.

data/Rakefile

@@ -0,0 +1,39 @@
+# -*- mode: ruby -*-
+
+module Gem
+  Deprecate = Module.new do
+    include Deprecate
+  end
+end
+
+require 'hoe'
+
+Hoe.plugin :bundler
+Hoe.plugin :git
+Hoe.plugin :gemspec
+
+h = Hoe.spec 'csquare' do
+  self.developer('John Woods', 'john.woods@marcottelab.org')
+  self.readme_file = 'README.rdoc'
+  self.extra_dev_deps += [
+    ["rspec", ">= 2.6"]
+  ]
+  self.extra_deps += [
+    ["hoe", ">= 3.0.3"],
+    ["cast", ">= 0.2.0"]
+  ]
+end
+
+def run *cmd
+  sh(cmd.join(" "))
+end
+
+task :console do |task|
+  cmd = [ 'irb', "-Ilib", "-r 'csquare.rb'" ]
+  run *cmd
+end
+
+task :pry do |task|
+  cmd = [ 'pry', "-Ilib", "-r 'csquare.rb'"]
+  run *cmd
+end

data/lib/csquare.rb

@@ -0,0 +1,1089 @@
+require "rubygems"
+require "cast"
+
+module CSquare
+  VERSION = "0.1.0"
+
+  module Indexable
+    def self.included(base)
+      base.send :extend, SingletonMethods
+    end
+
+    module InstanceMethods
+
+      # TODO: Unify caches between Generator and Blueprint
+      def read_and_parse_source source
+        code = read_source "#{source}.c"
+
+        begin
+          CSquare::Function.new(code, self.template_keys(source) + keys_for(source))
+        rescue C::ParseError => e
+          STDERR.puts "Error parsing source #{source.inspect}."
+          STDERR.puts "custom type names were #{self.template_keys(source).inspect}"
+          STDERR.puts e.inspect
+          STDERR.puts code.size
+
+          raise e
+        end
+      end
+
+
+      def preprocess_source file
+        r, w = IO.pipe
+        source = nil
+        pid = fork do
+          $stdout.reopen(w)
+          r.close
+          cerb = CERB.new(file, self)
+          w.close
+        end
+
+        w.close
+        source = r.read
+        Process.wait2(pid)
+
+        source
+      end
+
+
+      def get_binding
+        binding
+      end
+
+
+      # TODO: Change the 2 to be the number of arguments it takes or something more indicative
+      def inline_op_function_name op
+        "#{CSquare::Generator::OP_FUNCTION_NAMES[op]}2"
+      end
+
+
+      def template_keys(source)
+        k = self.keys
+        k = k.concat(extra_keys(source)) if respond_to?(:extra_keys)
+        k = k.concat(extra_template_keys_for(source)) if respond_to?(:extra_template_keys_for)
+        k
+      end
+
+
+      # Given some function call, see if it needs to be decorated. If so, return the decorated version; if not, return
+      # the original.
+      #
+      # You should make sure your function is listed in sources if calls to it aren't being decorated when it should be.
+      #
+      # Returns a String.
+      def decorated_call name, type_symbol
+
+        if @externs.has_key?(name)
+          return_typename = @externs[name]
+
+          return force_decorated_call(name, type_symbol) if return_typename == C::CustomType.new(@key)
+        end
+
+        # If all else fails, return as-is
+        name
+      end
+
+
+      def force_decorated_call name, type_symbol
+        [name.to_s, type_symbol.to_s].compact.join('_')
+      end
+
+
+      def expand_options options
+        expanded_opts = {}
+        options.each_pair do |opt, val|
+          if opt.is_a?(Array)
+            opt.each do |o|
+              expanded_opts[o] = val
+            end
+          else
+            expanded_opts[opt] = val
+          end
+        end
+        expanded_opts
+      end
+
+
+      def declare_inline_source enumeree
+        @inline_sources[enumeree] = begin
+          if self.respond_to?(:parsed_inline_op_function)
+            parsed_inline_op_function(enumeree)
+          else
+            blueprint_for(enumeree).parsed_inline_op_function(enumeree)
+          end
+        end
+      end
+
+
+      def index basename, options_and_mappings = {}
+        @indices ||= Hash.new { |h,k| h[k] = [] }
+        on        = options_and_mappings[:on]
+        new_index = CSquare::Generator::Index.new(self, basename, expand_options(options_and_mappings))
+
+        @externs[basename] = new_index.return_typename
+
+        # Save the index by its enumerator id
+        @indices[on || basename] << new_index
+      end
+
+
+
+
+      # Like Blueprint#sources, but builds a function pointer array for names given as an argument.
+      #
+      # May also supply a hash of options:
+      #
+      # * :on :: How to hash the second-dimension of the function pointer array -- give an array of
+      #          operator symbols or an Enum object.
+=begin
+      def index basename, signatures = {}
+        @indices        = Hash.new{ |h,k| h[k] = [] }
+
+        init_opts       = {}
+        sigs_for_index  = {}
+
+        g = self.is_a?(Generator) ? self : self.generator
+
+        # :on may be 1) an array of operators or types, 2) the name of an enumerator, or 3) undefined.
+        # If it's undefined, defaults to #2, and uses basename as the name of the enumerator.
+        init_opts[:on] = signatures.delete(:on)
+        init_opts[:with] = signatures.delete(:with)
+
+        enumerees  =
+        if !init_opts[:on].nil?
+          init_opts[:on].is_a?(String) ? g.enumerators[init_opts[:on]].enumerees : init_opts[:on]
+        else
+          g.enumerators[basename].enumerees
+        end
+
+        STDERR.puts("enumerees = " + enumerees.inspect)
+
+        STDERR.puts "A) signatures = " + signatures.inspect
+
+        # Expand out those keys that are actually arrays of keys, and generate signatures
+        # for enumerations on types.
+        signatures = begin
+          singles = {}
+
+          if !init_opts[:with].nil?
+            enumerees.each do |enumeree|
+              next if enumeree.nil?
+              singles[enumeree] = decorated_call(init_opts[:with], enumeree)
+            end
+          else
+            signatures.each_pair do |enumerees, name|
+              enumerees.each do |enumeree|
+                singles[enumeree] = name
+              end if enumerees.is_a?(Array)
+            end
+          end
+
+          # Remove arrays from signatures and add in the singles
+          signatures.delete_if{ |k,v| k.is_a?(Array) }.merge(singles)
+        end
+
+        STDERR.puts "B) signatures = " + signatures.inspect
+
+        signatures = begin # Handle inlines, load functions
+          new_signatures = {}
+
+          signatures.each_pair do |enumeree, name|
+
+            if name == :inline # concoct a function, a name, and act as if we loaded it
+              real_name = new_signatures[enumeree] = inline_op_function_name(enumeree)
+              f = @inline_sources[enumeree] = parsed_inline_op_function(enumeree)
+              g.externs[real_name]          = f.return_type
+              sigs_for_index[real_name]     = f.entity.type
+
+            else # load a function from source and figure out return type and such
+              new_signatures[enumeree] = name
+              @sources << name if self.is_a?(::CSquare::Generator::Blueprint)
+              f = read_and_parse_source(name) # go ahead and load the source to get the return type
+              @externs[name]       = f.return_type
+              sigs_for_index[name] = f.entity.type
+
+            end
+          end
+
+          new_signatures
+        end
+
+        STDERR.puts "C) signatures = " + signatures.inspect
+
+        new_index = CSquare::Generator::Index.new(self, basename, sigs_for_index, signatures, init_opts)
+        @externs[basename] = new_index.return_typename
+
+        # Save the index by its enumerator id
+        @indices[init_opts[:on] || basename] << new_index
+      end
+=end
+    end
+
+    module SingletonMethods
+      def acts_as_indexable
+        unless self.is_a?(ClassMethods)
+          include InstanceMethods
+        end
+      end
+    end
+
+    module ClassMethods
+    end
+  end
+
+  module Hashable
+    def self.included(base)
+      base.send :extend, SingletonMethods
+    end
+
+    module SingletonMethods
+      def acts_as_hashable(array_name)
+        unless self.is_a?(ClassMethods)
+          #include InstanceMethods
+          # extend ClassMethods
+
+          # Add a to_h function which returns a hash of variables and their types.
+          module_eval <<-"end_eval", __FILE__, __LINE__
+            def to_h(as=nil)
+              h = {}
+              self.#{array_name}.each do |obj|
+                if as == :string
+                  h[obj.name] = obj.type.CustomType? || obj.type.Struct? ? obj.type.name : obj.type.to_s
+                else
+                  h[obj.name] = obj.type
+                end
+              end
+              h
+            end
+          end_eval
+
+        end
+      end
+    end
+
+    module ClassMethods
+    end
+  end
+end
+
+
+# Add helper functions to CAST's C module.
+
+class C::FunctionDef
+
+  # Get function parameters.
+  def params(as=nil)
+    self.type.to_h(as)
+  end
+
+  # Does some local exist at the base scope?
+  def has_local? var, blueprint=nil
+    h = params.has_key?(var) || self.def.locals.has_key?(var)
+    h = blueprint.externs.has_key?(var) || blueprint.generator.externs.has_key?(var) if !h && !blueprint.nil?
+    h
+  end
+
+  # Determine the type of some variable declared in this scope.
+  def type_of var, blueprint=nil
+    t = params[var] || self.def.locals[var]
+    t = blueprint.externs[var] || blueprint.generator.externs[var] if t.nil? && !blueprint.nil?
+    return nil if t.nil?
+
+    if t.is_a?(C::Type)
+      t = t.clone      # return a copy, which should be marked as non-const
+      t.const = false
+    end
+
+    t
+  end
+end
+
+
+class C::Node
+  include CSquare::Hashable # enables acts_as_hashable class method
+
+  def op
+    CSquare::Generator::CAST_TO_OP[self.class]
+  end
+
+  # Recursively replace typenames with actual types.
+  def recursively_replace_casts! typenames_and_types
+    each do |n|
+      n.recursively_replace_casts! typenames_and_types
+    end
+  end
+
+  def replace_types! typenames_and_types
+    each do |n|
+      n.replace_types! typenames_and_types
+    end
+  end
+
+
+  def decorate_calls! type_symbol, blueprint_obj
+    each do |n|
+      n.decorate_calls! type_symbol, blueprint_obj
+    end
+  end
+
+
+  def new_temp_local type
+    parent_block.new_temp_local(type)
+  end
+
+  def new_temp_statement statement, before_statement
+    parent_block.new_temp_statement(statement, before_statement)
+  end
+
+
+  # Find the parent block
+  def parent_block
+    p = self.parent
+    while !p.Block?
+      p = p.parent
+    end
+    p
+  end
+
+
+  def parent_stmt
+    p = self.parent
+    while !p.Statement?
+      p = p.parent
+    end
+    p
+  end
+
+
+  # Find the parent FunctionDef
+  def parent_function_def
+    p = self.parent
+    while !p.FunctionDef?
+      p = p.parent
+    end
+    p
+  end
+
+
+  # Replace some expression with the pattern from Blueprint.
+  def recombine! function, blueprint, type_symbol, return_type=nil
+
+    args_types = {}
+
+    if respond_to?(:recombine_recursive!)
+      self.recombine_recursive! function, blueprint, type_symbol, return_type
+    else
+
+      self.fields.each_with_index do |f,i|
+        n = self.send(f.reader)
+
+        if n.respond_to?(:recombine!)
+          n = expand_node(n) if blueprint.has_op?(n.op)
+          result = n.recombine! function, blueprint, type_symbol, return_type
+          replace_node(n, result[0]) unless result.nil? || result[0].nil? || result[0] == n
+        end
+      end
+    end
+
+    if respond_to?(:return_typename)
+      [self, self.return_typename(function, blueprint)]
+    else
+      [self, nil]
+    end
+  end
+
+
+  # Takes some assignment expression node and turns it into a regular assign.
+  #
+  # e.g., x += y  --->   x = x + y
+  def expand_node node
+    return node unless node.AssignmentExpression? && !node.Assign?
+
+    # Figure out the new class
+    begin
+      klass    = C.const_get(node.class.to_s[3...-6])
+      new_node = C::Assign.new(:lval => node.lval.clone, :rval => klass.send(:new, :expr1 => node.lval, :expr2 => node.rval))
+
+      node.replace_with(new_node)
+      new_node
+    rescue NameError => e
+      STDERR.puts "Invalid CAST class #{node.class.to_s[3...-6].inspect}"
+      raise e
+    end
+  end
+
+
+  # Is some local 'var' declared anywhere in this scope or below? (Is it unsafe to declare it in this scope?)
+  def has_local_below? var
+    return true if self.respond_to?(:locals) && locals.has_key?(var)
+
+    self.each do |n|
+      return true if has_local_below?(var)
+    end
+
+    false
+  end
+
+  def csquare_key
+    self.to_s
+  end
+
+end
+
+
+class C::Block
+  attr_reader :temp_statements, :temp_locals
+
+  def recombine_recursive! function, blueprint, type_symbol, outside_return_type
+    result = self.stmts.map do |n|
+      replacement, return_type = n.recombine! function, blueprint, type_symbol, outside_return_type
+      n.replace_with(replacement) unless replacement.nil? || replacement == n
+      return_type # return an array of return types
+    end
+
+    before_offset = Hash.new { |h,k| h[k] = 0 }
+
+    # Add temp statements to the beginning of the block
+    if defined?(@temp_statements)
+      @temp_statements.reverse.each do |statement, before|
+
+        # Figure out the index of the statement that we want to insert before
+        before_index = self.stmts.index(before)
+
+        # Account for statements already inserted
+        self.stmts.insert(before_index - before_offset[before], statement)
+        before_offset[before] += 1 # increment every time a statement is added before some 'before' statement.
+      end
+    end
+
+    # Add the declarations to the beginning of the block, before the statements
+    temp_local_declarations.each do |dec|
+      self.stmts.unshift dec
+    end
+
+    result
+  end
+
+  # Create declarations for locals
+  def temp_local_declarations
+    by_type = {}
+
+    return [] unless defined?(@temp_locals)
+
+    @temp_locals.each_pair do |name, type|
+      by_type[type] ||= C::NodeArray.new
+      by_type[type] << C::Declarator.new(:name => name)
+    end
+
+    ary = []
+    by_type.each_pair do |type, declarators|
+      ary << C::Declaration.new(:type => type, :declarators => declarators)
+    end
+    ary
+  end
+
+  # Create a new temporary variable
+  def new_temp_local type
+    raise(ArgumentError, "type needs to be a string: #{type.inspect}") unless type.is_a?(String)
+
+    @temp_count ||= 0
+    @temp_locals ||= {}
+
+    name = "temp#{@temp_count}"
+    @temp_count += 1
+
+    parent_fd = parent_function_def
+
+    while parent_fd.has_local?(name) #|| has_local_below?(name) # check for conflicts just in case the programmer put in temp0 or something
+      name = "temp#{@temp_count}"
+      @temp_count += 1
+    end
+
+    @temp_locals[name] = C::CustomType.new(type).clone
+
+    name
+  end
+
+  # Queue a statement for addition before some existing statement.
+  def new_temp_statement statement, before_statement
+    @temp_statements ||= []
+    begin
+      @temp_statements << [C::Statement.parse("#{statement};"), before_statement]
+    rescue C::ParseError => e
+      STDERR.puts "Exception in new_temp_statement: #{e.inspect}"
+      STDERR.puts "statement = #{statement.inspect}"
+      raise e
+    end
+  end
+
+  # Return a hash of function local variables => types. You may pass :string as the sole argument if you want
+  #
+  # Note: only returns local variables at root scope in the function.
+  def locals(as=nil)
+    h = {}
+    self.stmts.each do |statement|
+      h.merge!(statement.to_h(as)) if statement.Declaration?
+    end
+    h
+  end
+
+  # Does some local exist at the base scope?
+  def has_local? var, blueprint=nil
+    return true if defined?(@temp_locals) && temp_locals.has_key?(var)
+    return true if locals.has_key?(var)
+    return true if self.parent_function_def.params.has_key?(var)
+    return true if self.parent_function_def.has_local?(var)
+    return true if !blueprint.nil? && (blueprint.externs.has_key?(var) || blueprint.generator.externs.has_key?(var))
+    false
+  end
+
+
+  def replace_types! typenames_and_types
+    super typenames_and_types
+
+    self.stmts.each_with_index do |stmt, i|
+      next unless stmt.Declaration?
+      next unless typenames_and_types.has_key?(stmt.type.underlying_typename)
+      stmt.type.underlying_typename = typenames_and_types[stmt.type.underlying_typename]
+    end
+  end
+
+end
+
+
+
+class C::Sizeof
+  def replace_types! typenames_and_types
+    self.expr.name = typenames_and_types[self.expr.name] if self.expr.CustomType? && typenames_and_types.has_key?(self.expr.name)
+  end
+end
+
+
+class C::PrefixExpression
+  def prefixed_literal?
+    self.expr.Literal? || self.expr.prefixed_literal?
+  end
+
+  def prefixed_variable?
+    self.expr.Variable? || self.expr.prefixed_variable?
+  end
+
+  def return_typename function, blueprint
+    return :boolean if self.Not?
+    self.expr.return_typename function, blueprint
+  end
+end
+
+
+class C::Negative
+  def underlying_value
+    self.prefixed_literal? ? -self.expr.underlying_value : self.expr.underlying_value
+  end
+end
+
+
+class C::Literal
+  def involves? literal_or_variables
+    literal_or_variables.is_a?(Array) ? literal_or_variables.include?(self.val) : literal_or_variables == self.val
+  end
+
+  def underlying_value
+    self.val
+  end
+
+  def return_typename function, blueprint
+    return :integer if val.is_a?(Fixnum)
+    return :float   if val.is_a?(Float)
+    return :string  if val.is_a?(String)
+    raise(NotImplementedError, "unhandled literal type: #{self.inspect}")
+  end
+
+  def depth
+    0
+  end
+
+  def csquare_key
+    self.val
+  end
+end
+
+
+class C::CompoundLiteral # e.g., (struct TYPE) { -x.n, x.d }
+  def return_typename function, blueprint
+    return self.type.name
+  end
+
+  def underlying_typename
+    self.type.name
+  end
+
+  # Recursively replace typenames with actual types.
+  def recursively_replace_casts! typenames_and_types
+    each do |n|
+      n.recursively_replace_casts! typenames_and_types
+    end
+
+    self.type.name = typenames_and_types[self.type.name] if (self.type.CustomType? || self.type.Struct?) && typenames_and_types.has_key?(self.type.name)
+  end
+end
+
+
+class C::Variable
+  def involves? literal_or_variables
+    literal_or_variables.is_a?(Array) ? literal_or_variables.include?(self.name) : literal_or_variables == self.name
+  end
+
+  def underlying_value
+    self.name
+  end
+
+  def return_typename function, blueprint=nil
+    return :boolean if %w{true false}.include?(self.name)
+
+    if parent_block.has_local?(self.name, blueprint)
+      t = function.type_of(self.name, blueprint)
+      return t.to_s if t.is_a?(C::PrimitiveType) # int, float, double, etc
+      return t.is_a?(C::DirectType) ? t.name : t
+    end
+
+    # This is kind of a hack. To do it the real way, we really need to know the type symbol
+    if self.name =~ /_(MIN|MAX)$/
+      return blueprint.externs[self.name] if blueprint.externs.has_key?(self.name)
+      name_without_minmax = self.name[0...-4]
+      if blueprint.extra_templates_by_source.has_key?(function.name) && blueprint.extra_templates_by_source[function.name].has_key?(name_without_minmax)
+        return blueprint.extra_templates_by_source[function.name][name_without_minmax]
+      end
+    end
+
+    require 'pry'
+    binding.pry
+
+    raise(NotImplementedError, "undeclared variable #{self.name.inspect}")
+  end
+
+  def depth
+    0
+  end
+
+  # Replace some expression with the pattern from Blueprint.
+  def recombine! function, blueprint, type_symbol, return_type=nil
+
+    args_types = {}
+
+    replace_vars = blueprint.vars(type_symbol)
+    return_node =
+    if replace_vars.has_key?(self.name)
+      n = self.clone
+      n.name = replace_vars[self.name]
+      n
+    else
+      self
+    end
+
+    [return_node, self.return_typename(function, blueprint)]
+  end
+
+end
+
+
+class C::Return
+  # This is not what you think it is. This function gives the typename that the statement would return if
+  # you set some variable equal to it. e.g., here, x = return false;
+  #
+  # This is an invalid statement, so the return_typename for a return statement is nil.
+  def return_typename function, blueprint=nil
+    nil
+  end
+end
+
+
+# These add to_h functions for figuring out what the parameters and their types are, and the local variables and their types, respectively.
+# See csquare/function.rb to see how these to_h functions are used.
+
+class C::Declaration
+  acts_as_hashable :declarators
+
+  # Replace some expression with the pattern from Blueprint.
+  def recombine! function, blueprint, type_symbol, return_type=nil
+    args_types = {}
+
+    declarators.each do |n|
+      result = n.recombine! function, blueprint, type_symbol
+    end
+
+    [self, nil]
+  end
+end
+
+class C::Declarator
+  # Replace some expression with the pattern from Blueprint.
+  def recombine! function, blueprint, type_symbol, return_type=nil
+    args_types = {}
+
+    result = init.recombine!(function, blueprint, type_symbol, return_type) unless init.nil?
+
+    [self, nil]
+  end
+end
+
+class C::Function
+  acts_as_hashable :params
+
+  def return_typename function, blueprint
+    self.type.to_s
+  end
+
+  def replace_types! h
+    # Replace return typename
+    type.name = h[type.name] if (type.CustomType? || type.Struct?) && h.has_key?(type.name)
+
+    # Replace params' typenames
+    params.each do |param|
+      if h.has_key?(param.type.underlying_typename)
+        param.replace_with C::Parameter.parse(param.to_s.gsub(param.type.underlying_typename, h[param.type.underlying_typename]))
+      end
+    end
+  end
+end
+
+
+class C::DirectType
+  def underlying_typename
+    self.name
+  end
+
+  def underlying_typename= new_typename
+    self.name = new_typename
+  end
+
+  def return_typename function, blueprint
+    self.underlying_typename
+  end
+end
+
+
+class C::PrimitiveType
+  def underlying_typename
+    self.class.to_s.split('::')[1].downcase
+  end
+end
+
+
+class C::IndirectType
+  def underlying_typename
+    self.type.underlying_typename
+  end
+end
+
+
+class C::Int
+  def return_typename function, blueprint
+    :integer
+  end
+end
+
+
+class C::Expression
+  def prefixed_literal?
+    false
+  end
+
+  def prefixed_variable?
+    false
+  end
+
+  def involves? literal_or_variables
+    involves_on_left?(literal_or_variables) || involves_on_right?(literal_or_variables)
+  end
+
+end
+
+
+class C::UnaryExpression
+  def involves? literal_or_variables
+    return expr.involves?(literal_or_variables) if expr.Expression?
+    false
+  end
+end
+
+
+
+class C::AssignmentExpression
+  def involves_on_left? literal_or_variables
+    return lval.involves?(literal_or_variables) if lval.Expression?
+    false
+  end
+
+  def involves_on_right? literal_or_variables
+    return rval.involves?(literal_or_variables) if rval.Expression?
+    false
+  end
+
+  def return_typename function, blueprint
+    self.lval.return_typename function, blueprint
+  end
+
+  # Replace some expression with the pattern from Blueprint.
+  def recombine! function, blueprint, type_symbol, return_type=nil
+    args_types = {}
+
+    # Determine the left-hand return type
+    return_type = self.lval.return_typename(function, blueprint)
+
+    # Recombine on the right-hand side
+    # r_result: ast, return type (or just nil)
+    r_result = self.rval.recombine! function, blueprint, type_symbol, return_type
+
+    args_types[self.lval.csquare_key]   = self.lval.return_typename(function, blueprint)
+    args_types[r_result[0].csquare_key] = r_result[1]
+
+    rval.replace_with(r_result[0]) unless r_result.nil? || rval == r_result[0]
+
+    if blueprint.has_op?(op) && blueprint.responds_to_typename?(return_type)
+      blueprint.decorated_expression(type_symbol, op, args_types, return_type)
+    end
+  end
+end
+
+
+class C::Cast
+  # Recursively replace typenames with actual types.
+  def recursively_replace_casts! typenames_and_types
+    each do |n|
+      n.recursively_replace_casts! typenames_and_types
+    end
+    self.type.name = typenames_and_types[self.type.name] if (self.type.CustomType? || self.type.Struct?) && typenames_and_types.has_key?(self.type.name)
+  end
+end
+
+
+class C::Call
+  def return_typename function, blueprint
+    function.type_of(self.expr.name, blueprint)
+  end
+
+  def decorate_calls! type_symbol, blueprint_obj
+    super(type_symbol, blueprint_obj)
+    self.expr.name = blueprint_obj.decorated_call(self.expr.name, type_symbol)
+  end
+
+  # Recursively decorate function calls as appropriate.
+  def recursively_decorate_calls! blueprint, type_symbol
+    each do |n|
+      n.recursively_decorate_calls! blueprint, type_symbol
+    end
+
+    if blueprint.externs.has_key?(self.expr.name)
+      # Let's figure out what to replace this call with. Ask the template type for the
+      # decorated function names corresponding to *this* function.
+      decorated_externs = blueprint.decorated_externs(type_symbol, self.expr.name)
+
+      self.expr.name = decorated_externs[self.expr.name].keys.first
+    else
+      blueprint.generator.externs[self.expr.name]
+    end
+
+  end
+
+  # Determine the depth of this tree of binary expressions. Only include BinaryExpression nodes.
+  def depth
+    left_depth = expr1.respond_to?(:depth) ? expr1.depth : 0
+    right_depth = expr2.respond_to?(:depth) ? expr2.depth : 0
+    (left_depth > right_depth ? left_depth : right_depth) + 1
+  end
+
+  # Replace some expression with the pattern from Blueprint.
+  def recombine! function, blueprint, type_symbol, return_type=nil
+
+    args_types = {}
+
+    call_returns = self.return_typename(function, blueprint)
+
+    expr_name = self.expr.Index? ? self.expr.expr.name : self.expr.name
+
+    #if expr_name == "ew_bool"
+    #  require 'pry'
+    #  binding.pry
+    #end
+
+    # Handle externs
+    if blueprint.externs.has_key?(expr_name)
+      field_key         = blueprint.externs[expr_name]
+      current_type      = blueprint.types[type_symbol]
+      if current_type.keys.has_key?(field_key)
+        field_type_symbol = current_type.keys[field_key]
+        new_expr_name     = blueprint.generator.types[field_type_symbol].blueprint.decorated_call(expr_name, field_type_symbol)
+
+        # Correctly update the expression name
+        if self.expr.Index?
+          self.expr.expr.name = new_expr_name
+        else
+          self.expr.name = new_expr_name
+        end
+
+      elsif self.expr.Index?
+        self.expr.expr.name = blueprint.decorated_call(expr_name, type_symbol)
+      elsif self.expr.Variable?
+        self.expr.name = blueprint.force_decorated_call(expr_name, type_symbol)
+      end
+    end
+
+    # Don't do fields -- do args instead. We don't want to recombine the expression name, as it won't have a return type.
+
+    self.args.each_with_index do |n,i|
+      if n.respond_to?(:recombine!)
+        n = expand_node(n) if blueprint.has_op?(n.op)
+        result = n.recombine! function, blueprint, type_symbol, return_type
+        replace_node(n, result[0]) unless result.nil? || result[0].nil? || result[0] == n
+      end
+    end
+
+    [self, call_returns]
+  end
+end
+
+
+class C::Index
+  def return_typename function, blueprint
+    t = function.type_of(self.expr.name, blueprint)
+    t.is_a?(C::Pointer) || t.is_a?(C::Array) ? t.type.name : t.name
+  end
+
+  # Replace some expression with the pattern from Blueprint.
+  def recombine! function, blueprint, type_symbol, return_type=nil
+
+    index_result = self.index.recombine! function, blueprint, type_symbol, :integer
+    self.index.replace_with(index_result[0]) unless index_result.nil?
+
+    # Recombine on the right-hand side
+    # r_result: ast, return type (or just nil)
+    expr_result = self.expr.recombine! function, blueprint, type_symbol, return_type
+    self.expr.replace_with(expr_result[0]) unless expr_result.nil?
+
+    # Mostly only need to figure out the return typename
+    [self, self.return_typename(function, blueprint)]
+  end
+
+  def depth
+    self.expr.depth
+  end
+end
+
+
+class C::Dereference
+  def return_typename function, blueprint
+    function.type_of(self.expr.name, blueprint).type.name # de-Pointerize
+  end
+
+  def depth
+    self.expr.depth
+  end
+end
+
+class C::Dot
+  def return_typename function, blueprint
+    raise("no field keys found for type #{function.type_of(self.expr.name, blueprint).inspect}") if blueprint.fields.nil?
+    blueprint.fields[self.member.name.to_sym]
+  end
+
+  def depth
+    0
+  end
+end
+
+
+class C::BinaryExpression
+
+  # Replace some expression with the pattern from Blueprint.
+  def recombine! function, blueprint, type_symbol, return_type
+
+    # Get depth before we recombine children
+    d = depth
+
+    local_return_type = self.return_typename(function, blueprint)
+    return_type ||= local_return_type
+    return_type = local_return_type if local_return_type == :boolean
+
+
+    # Upgrade the return type for expressions that aren't simple
+    final_return_type = (d > 1 && return_type == blueprint.key) ? blueprint.long_key : return_type
+
+    args_types = {}
+
+    first_field_type = nil # type which the templater recognizes for the right-hand argument
+
+    self.fields.each_with_index do |f,i|
+
+      # Get the node
+      n = self.send(f.reader)
+
+      # n_result: ast, return type (or just nil)
+      n_result = n.recombine! function, blueprint, type_symbol, final_return_type
+
+      first_field_type = n_result[1] if i == 0
+
+      # Basically this says: don't do it for boolean binary expressions
+      if blueprint.responds_to_typename?(first_field_type)
+
+        if blueprint.has_op?(self.op) && final_return_type.is_a?(String) && (d > 1 || final_return_type != n_result[1]) && n_result[0].depth > 0
+
+          # TODO: Reusable temp locals (e.g., temp0, temp1, temp2, ...) for better -O0 performance
+          #if blueprint.id == :rational && function.name =~ /^numbmm/
+          #  require 'pry'
+          #  binding.pry
+          #end
+
+          temp = self.new_temp_local(final_return_type)
+          self.new_temp_statement("#{temp} = #{n_result[0].csquare_key}", self.parent_stmt)
+
+          n_result[0] = C::Expression.parse(temp)
+        end
+
+        args_types[n_result[0].csquare_key] = n_result[1]
+
+      end
+
+      replace_node(n, n_result[0]) unless n == n_result[0]
+    end
+
+
+    result = if blueprint.has_op?(op) && blueprint.responds_to_typename?(first_field_type)
+      blueprint.decorated_expression(type_symbol, self.op, args_types, final_return_type)
+    end
+
+    result.nil? ? [self, local_return_type] : result
+  end
+
+  # Determine the depth of this tree of binary expressions. Only include BinaryExpression nodes.
+  def depth
+    left_depth = expr1.respond_to?(:depth) ? expr1.depth : 0
+    right_depth = expr2.respond_to?(:depth) ? expr2.depth : 0
+    (left_depth > right_depth ? left_depth : right_depth) + 1
+  end
+
+
+  def involves_on_left? literal_or_variables
+    return expr1.involves?(literal_or_variables) if expr1.Expression?
+    false
+  end
+
+  def involves_on_right? literal_or_variables
+    return expr2.involves?(literal_or_variables) if expr2.Expression?
+    false
+  end
+
+  # Which type should we expect this binary expression to return?
+  #
+  # Needed for determining template-based mutations.
+  def return_typename function, blueprint
+    return :boolean if CSquare::Generator::BOOL_CAST_TO_OP.has_key?(self.class)
+    self.expr1.return_typename(function, blueprint)
+  end
+
+end
+
+
+require 'csquare/cerb'
+require 'csquare/base'
+require 'csquare/function'
+require 'csquare/generator'