csquare 0.1.0

data/lib/csquare/generator/assign_op.rb

@@ -0,0 +1,53 @@
+class CSquare::Generator::AssignOp < CSquare::Generator::Op
+
+  def decorated args_types, return_type, default_type_symbol
+    raise(ArgumentError, "expected 1-2 args, found #{args_types.size}") unless args_types.size == 1 || args_types.size == 2
+
+    super(args_types, return_type, default_type_symbol)
+  end
+
+  # Determine which pattern to apply
+  def select_pattern args_types, return_type
+
+    arg = args_types.keys[1] || args_types.keys[0] # assign || unary
+    type = args_types[arg]
+
+    pat = begin
+      if self.has_key?(arg)
+        self[arg]
+      elsif type.is_a?(Symbol)
+        self[type]
+      elsif type == return_type # homogeneous
+        self[blueprint.key]
+      else                      # heterogeneous
+
+        if type == blueprint.long_key
+          self[type]
+        else
+          self[:cast]
+        end
+
+      end
+    end
+
+    # If we have TYPE on the right, we need to change it to LONG_TYPE if the return type is also LONG_TYPE
+    if pat =~ /\(struct\s([A-Z]+)\)/
+      orig_struct_type = $1
+      if return_type == "LONG_#{orig_struct_type}"
+        return pat.gsub("(struct #{orig_struct_type})", "(struct LONG_#{orig_struct_type})")
+      end
+    end
+
+    pat
+  end
+
+  # Determine a type symbol to apply to function calls based on argument and return types.
+  def select_type_symbol types, return_type, default_symbol
+
+    if return_type == blueprint.long_key
+      blueprint.types[default_symbol].long_id
+    else
+      default_symbol
+    end
+  end
+end

data/lib/csquare/generator/binary_op.rb

@@ -0,0 +1,72 @@
+class CSquare::Generator::BinaryOp < CSquare::Generator::Op
+  #def initialize blueprint, id, patterns
+  #  @blueprint = blueprint
+  #  @id        = id
+  #  @patterns   = patterns
+  #end
+
+
+  def decorated args_types, return_type, default_type_symbol
+    unless args_types.size == 2
+      binding.pry
+      raise(ArgumentError, "expected two args, found #{args_types.size}")
+    end
+
+    super(args_types, return_type, default_type_symbol)
+  end
+
+
+  # Determine which pattern to apply
+  def select_pattern args_types, return_type
+    args = args_types.keys
+    types = args_types.values
+
+    # If the exact arg has a pattern, prefer to use that
+    if self.has_key?(args[1]) # look for exact arg
+      self[args[1]]
+    elsif types[1].is_a?(Symbol) # look for type symbol
+      self[types[1]]
+    else # look for TYPE or LONG_TYPE or :cast
+      types = args_types.values
+
+      reduced_types = (types + [return_type]).uniq
+
+
+      if reduced_types.size == 1 # homogeneous
+
+        if blueprint.long_key == reduced_types[0]
+          self[blueprint.long_key] || self[:cast] || self[blueprint.key]
+        else
+          self[reduced_types[0]]
+        end
+
+      elsif reduced_types.size == 2
+
+        self[:cast] || begin
+          if types[0] == types[1] # homogeneous
+            self[blueprint.key]
+          else                    # heterogeneous
+            self[blueprint.long_key]
+          end
+        end
+
+      else
+
+        # This should not happen
+        raise(ArgumentError, "Error: three types were supplied: #{args_types.inspect}, #{return_type.inspect}")
+
+      end
+    end
+  end
+
+  # Determine a type symbol to apply to function calls based on argument and return types.
+  def select_type_symbol types, return_type, default_symbol
+    reduced_types = (types + [return_type]).uniq
+
+    if reduced_types.include?(blueprint.long_key)
+      blueprint.types[default_symbol].long_id
+    else
+      default_symbol
+    end
+  end
+end

data/lib/csquare/generator/blueprint.rb

@@ -0,0 +1,357 @@
+class CSquare::Generator::Blueprint
+  include CSquare::Indexable
+  acts_as_indexable
+
+  alias_method :keys_for, :template_keys
+
+  def initialize generator_obj, id, template_param, field_params
+    @id       = id
+    @key      = template_param
+    @fields   = field_params
+    @types    = {}
+    @externs  = {
+         "#{@key}_MAX" => @id,
+         "#{@key}_MIN" => @id,
+         "LONG_#{@key}_MAX" => @id,
+         "LONG_#{@key}_MIN" => @id
+    }
+    @ops      = {}
+    @sources  = []
+    @generator= generator_obj
+    @inline_sources = {}
+    @extra_templates_by_source = Hash.new { |h,k| h[k] = {} }
+
+    yield self if block_given?
+
+    # STDERR.puts "#{@key.inspect} EXTERNS: " + @externs.inspect
+  end
+
+
+  attr_reader :generator, :id, :key, :fields, :types, :externs, :extra_templates_by_source
+
+  def indices
+    defined?(@indices) ? @indices : {}
+  end
+
+  def inspect
+    obj_id = "0x#{(self.object_id << 1).to_s(16)}"
+    "#<#{self.class.to_s}:#{obj_id} #{@id.inspect}=>#{@key.inspect}=>#{@fields.inspect} type_ids=#{@types.keys.inspect} ops=#{@ops.keys.inspect} sources=#{@sources.inspect}>"
+  end
+
+  def long_key
+    "LONG_#{@key}"
+  end
+
+  # Declare a type within this blueprint. It will be used to transform the blueprint and create a set of functions.
+  #
+  # Must provide at least an id (a shorthand symbol, such as :i64) and a ctype String (e.g., "int64_t").
+  # Optionally, may also provide a hash of options
+  #
+  # * :long :: Gives the id for another type in this blueprint which is the long version of this type
+  # * template params which correspond to the field parameters in the blueprint.
+  #
+  # Example:
+  #
+  #   c.blueprint(:complex, 'TYPE', :r => 'FLOAT', :i => 'FLOAT') do |t|
+  #     t.type :c64, 'complex64', :long => :c128, 'FLOAT' => :f32        # f32 and f64 are declared in a separate blueprint
+  #     t.type :c128, 'complex128', 'FLOAT' => :f64
+  #  end
+  #
+  def type id, ctype, options = {}
+    raise(ArgumentError, "id #{id} already declared") if @types.has_key?(id) || @generator.blueprints.has_key?(id)
+
+    @types[id] = CSquare::Generator::Type.new(self, id, ctype, options)
+
+    @externs[@types[id].max] = self.id unless @types[id].max.nil?
+    @externs[@types[id].min] = self.id unless @types[id].min.nil?
+
+    self
+  end
+
+  # Does this blueprint contain instructions for dealing with some key (e.g., 'TYPE')?
+  def responds_to_typename? k
+    return true if k == @key || k == "LONG_#{@key}"
+    false
+  end
+
+  def recognizes? id, k
+    if has_op?(id)
+      return true if responds_to_typename?(k)
+      return true if @ops[id].has_key?(k)
+    end
+    false
+  end
+
+
+  def has_op? id
+    @ops.has_key?(id)
+  end
+
+
+  # Return a hash giving mappings from template typenames (keys, e.g., 'TYPE') to ctypes.
+  def params type_symbol
+    k = @types[type_symbol].ctype_keys # hash of typenames to type ids
+
+    begin
+      k[@key] = @generator.types[type_symbol].ctype
+    rescue NoMethodError
+      STDERR.puts "NoMethodError: @key=#{@key}, type_symbol = #{type_symbol}"
+    end
+    k["LONG_#{@key}"] = (generator.types[type_symbol].long || generator.types[type_symbol]).ctype
+    k
+  end
+
+
+  # Return a hash giving mappings from template variables (e.g., UINT_MAX, LONG_UINT_MAX) to actual variables.
+  def vars type_symbol
+    @vars ||= {}
+    @vars[type_symbol] = begin
+      h = {}
+
+      type = @types[type_symbol]
+      h["#{@key}_MIN"] = type.min unless type.min.nil?
+      h["#{@key}_MAX"] = type.max unless type.max.nil?
+
+      long_type = type.long
+      if long_type
+        h["LONG_#{@key}_MIN"] = long_type.min unless long_type.min.nil?
+        h["LONG_#{@key}_MAX"] = long_type.max unless long_type.max.nil?
+      end
+
+      h
+    end
+  end
+
+
+  # Register symbols available to functions in this blueprint, and their template parameters. Note that this is only used
+  # to register symbols from other blueprints. Takes a hash as only argument.
+  #
+  # Example:
+  #
+  #    c.blueprint(:int, 'TYPE') do |t|
+  #      t.type :i16, 'int16_t', :long => :i32
+  #      t.type :i32, 'int32_t'
+  #      t.sources %w{gcf} # gcf is a templated function for :i16 and :i32
+  #    end
+  #
+  #    c.blueprint(:rational, 'TYPE', :n => 'INT', :d => 'INT') do |t|
+  #      t.type :r32, 'rational32', :long => :r64, 'INT' => :i16
+  #      t.type :r64, 'rational64', 'INT' => :i32
+  #      t.externs 'gcf' => 'INT' # lets us know that gcf is a templated function returning :i16 or :i32 depending
+  #    end
+  #
+  def externs h=nil
+    return @externs if h.nil?
+    @externs.merge!(h)
+  end
+
+  # Declare source files containing functions for types within this blueprint.
+  #
+  # Example:
+  #
+  #    t.sources %w{gemm div2 div4 mul2 mul4}
+  #
+  # These will frequently be referenced by the op method.
+  def sources ary = [], extra_typenames_and_blueprint_ids = {}
+    ary.each do |str|
+      # Do this first so that the extra typenames are registered
+      @extra_templates_by_source[str] = extra_typenames_and_blueprint_ids
+
+      # go ahead and load the source to get the return type
+      f = read_and_parse_source(str)
+
+      # Add this to our list of externs
+      STDERR.puts("Warning: overriding extern '#{str}' (value='#{@externs[str]}') --> '#{f.return_type}'") if @externs.has_key?(str)
+      @externs[str] = f.return_type
+
+      @sources << str
+    end
+
+    @sources
+  end
+
+
+  def has_source? f_name
+    @sources.include?(f_name)
+  end
+
+
+
+  # Declare an operation that this blueprint should manage. First argument is a symbol, e.g., :'*' (for C::Multiply).
+  # Second argument is a hash: keys are template parameters (e.g., 'TYPE'), C basic types (e.g., 'int'), values (e.g.,
+  # 0, 1), or blueprint IDs (e.g., :integer). Values of this hash are patterns to substitute the operations for.
+  #
+  # Expect boolean operations in C to return a blueprint ID of :boolean. This is declared implicitly, as are :integer
+  # and :float. All can be overridden.
+  #
+  # Example:
+  #
+  #    t,sources %w{mul2 mul4}
+  #    t.op :'*', 'TYPE' => 'mul2($0, $1)', :integer => 'mul4($0.r, $0.i, $1, 0)', :float => 'mul4($0.r, $0.i, $1, 0)' # for complex multiplication
+  #
+  def op id, types_and_patterns = {}
+    raise(ArgumentError, "op id #{id} already declared") if @ops.has_key?(id)
+
+    op_class =
+    if CSquare::Generator::BOOL_CAST_TO_OP.has_value?(id)
+      CSquare::Generator::BooleanOp
+    elsif CSquare::Generator::BINARY_ASSIGN_CAST_TO_OP.has_value?(id) || CSquare::Generator::BINARY_CAST_TO_OP.has_value?(id)
+      CSquare::Generator::BinaryOp
+    elsif id == :'='
+      CSquare::Generator::AssignOp
+    else # UNARY #TODO: This may need its own class
+      CSquare::Generator::AssignOp
+    end
+
+    @ops[id] ||= op_class.send(:new, self, id)
+
+    types_and_patterns.each_pair do |type_id, pattern|
+      @ops[id][type_id] = pattern
+    end
+
+    self
+  end
+
+
+  # To be called by Generator only after everything is setup.
+  def mutate_functions type_symbol
+    functions = []
+
+    local_template_params = self.params(type_symbol)
+
+    # Handle templates added by the index method.
+    @inline_sources.each_pair do |op, f|
+      functions << f.clone.mutate!(self, type_symbol, local_template_params)
+    end
+
+    # Handle templates added by the sources method.
+    @sources.each do |source|
+
+      # First, mutate on the current blueprint
+      function = read_and_parse_source(source).mutate!(self, type_symbol, local_template_params)
+
+      if @extra_templates_by_source[source].size > 1
+        raise NotImplementedError, "only two templates supported at a time"
+
+      elsif @extra_templates_by_source[source].size == 1
+        @extra_templates_by_source[source].each_pair do |typename,blueprint_id|
+
+          other_blueprint = generator.blueprints[blueprint_id]
+          other_blueprint.types.each_pair do |type_id, type_obj|
+            functions << function.clone.mutate!(other_blueprint, type_id, {typename => @generator.types[type_id].ctype})
+          end
+        end
+      else
+        functions << function
+      end
+
+    end
+
+    functions
+  end
+
+
+
+  # Helper function called by Generator after all blueprints are declared. Goes back and replaces blueprint IDs with ctypes.
+  def expand_ops!
+    @ops.clone.each_pair do |id, types_and_patterns|
+      h = {}
+      types_and_patterns.patterns.each_pair do |arg1,pattern|
+        if arg1.is_a?(Symbol) && @generator.blueprints.has_key?(arg1)
+          @generator[arg1].types.each_pair do |type_id, type|
+            next if types_and_patterns.patterns.has_key?(type.ctype) # Don't override a user op
+            h[type.ctype] = pattern
+          end
+        end
+      end
+      @ops[id].patterns.merge!(h)
+    end
+  end
+
+
+  # Generate a C Abstract Syntax Tree based on a pattern given to generator/blueprint in
+  # configuration.
+  #
+  # Returns the return type of the final expression and the expression AST.
+  def decorated_expression type_symbol, op_id, args_and_types, should_return
+    return nil unless @ops.has_key?(op_id)
+    @ops[op_id].decorated(args_and_types, should_return, type_symbol)
+  end
+
+
+
+  #
+  # These functions are all for indices which have the :inline symbol.
+  #
+
+
+  def inline_op_return_type op
+    CSquare::Generator::OP_RETURN_TYPES[op] == :key ? @key : CSquare::Generator::OP_RETURN_TYPES[op]
+  end
+
+
+  def inline_op_return_typename op
+    type = inline_op_return_type(op)
+    return 'bool' if type == :boolean
+    type
+  end
+
+
+  def inline_op_function_def op
+    "inline #{inline_op_return_typename(op)} #{inline_op_function_name(op)}(const #{@key} x, const #{@key} y) { return (x #{op.to_s} y); }"
+  end
+
+
+  def parsed_inline_op_function op
+    code = inline_op_function_def(op)
+    CSquare::Function.new(code, self.keys)
+  end
+
+
+  # Get a list of op symbols used in this blueprint
+  def op_symbols
+    @ops.values.map { |o| o.id }
+  end
+
+  def read_source source_filename
+    begin
+      g = self.generator
+      Dir.chdir(g.path) do
+        # First check type's own directory, then check for global if type doesn't have it.
+        if File.exists?(File.join(self.id.to_s, source_filename))
+          Dir.chdir(self.id.to_s) do
+            preprocess_source File.new(source_filename, "r")
+          end
+        elsif File.exists?(source_filename)
+          preprocess_source File.new(source_filename, "r")
+        else
+          raise("source file not found: #{source_filename.inspect}")
+        end
+      end
+    rescue Errno::ENOENT => e
+      # This is really helpful for people who are using rake compile and don't know what
+      # the template directory should be, since they don't know their current location.
+      STDERR.puts "CSquare: Exception thrown: #{e.inspect}"
+      STDERR.puts "CSquare: Current directory: #{Dir.pwd.inspect}"
+      raise e
+    end
+  end
+
+
+  def extra_keys source
+    @extra_templates_by_source[source].keys
+  end
+
+
+protected
+
+  def keys
+    k = []
+    @types.each_value do |type|
+      k = k.concat(type.keys.keys)
+    end
+    k << @key << "LONG_#{@key}"
+    k
+  end
+
+end