csquare 0.1.0

data/lib/csquare/generator/boolean_op.rb

@@ -0,0 +1,32 @@
+class CSquare::Generator::BooleanOp < CSquare::Generator::BinaryOp
+
+  def decorated args_types, return_type, default_type_symbol
+    result = super(args_types, return_type, default_type_symbol)
+    return nil if result.nil?
+
+    # Boolean operations always return booleans
+    [result[0], :boolean]
+  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
+
+      if types[0] == types[1]
+        self[blueprint.key]
+      else
+        self[:cast] || self[blueprint.long_key]
+      end
+    end
+  end
+
+
+end

data/lib/csquare/generator/enum.rb

@@ -0,0 +1,99 @@
+class CSquare::Generator::Enum
+  def initialize name, opts = {}
+    @name      = name
+    @prefix    = opts[:prefix]
+
+    @on = opts.has_key?(:ops) ? :ops : :types
+
+    @selector = opts[@on]
+
+    # Don't need to use a namer if a hash was given; hash provides the names instead.
+    if @selector.is_a?(Array)
+      namer = opts[:with]
+      namer ||= @on == :ops ? :OpNamer : :Namer
+
+      namer_klass = begin
+        CSquare::Generator::Enum.const_get(namer)
+      rescue NameError
+        Kernel.const_get(namer)
+      end
+
+      # Create a namer object with the specified prefix (if any)
+      @namer     = namer_klass.send :new, @prefix
+    end
+  end
+
+  attr_reader :selector, :name, :on
+
+  # Local symbols upon which we should enumerate. If types, this will be the type symbols (e.g., i8, i16, i32).
+  # If ops, this will be operations, like :'+', :'-', etc. Returns an array.
+  def enumerees
+    @selector.is_a?(Hash) ? @selector.values : @selector
+  end
+
+
+  def enumerate_for_index
+    ary = []
+    enumerees_and_c_values = enumerate.values
+    enumerees_and_c_values.sort_by{ |ecv| ecv[1] }.each do |enumeree_and_c_value|
+      ary <<[enumeree_and_c_value[0], enumeree_and_c_value[1]]
+    end
+    ary
+  end
+
+
+  # Pre-set/retrieve all the enum values (e.g., OP_ADD => '+'.ord) for
+  # the specified ops or dtypes (an Array).
+  def enumerate
+    h = {}
+
+    nums_used = Set.new
+
+    autos = []
+
+    if @selector.is_a?(Hash)
+      @selector.each_pair do |name, enumeree|
+        prefixed_name    = [@prefix, name].compact.join('_')
+        autos <<  [enumeree, prefixed_name]
+      end
+    else
+      @selector.each do |enumeree|
+        num  = @namer.num(enumeree)
+        name = @namer.name(enumeree)
+
+        next if name.nil? # don't bother if we couldn't determine a name
+
+        if num == :auto
+          autos << [enumeree, name]
+        else
+          h[name] = [enumeree, num]
+          nums_used.add(num) unless num == :auto
+        end
+      end
+    end
+
+
+    count = 0
+    # Now go back and re-number everything marked :auto
+    autos.each do |enumeree_and_name|
+      enumeree, name = enumeree_and_name
+
+      # Find the next unused number
+      count += 1 while nums_used.include?(count)
+
+      nums_used.add(count)
+      h[name] = [enumeree, count]
+    end
+
+    h
+  end
+
+
+  def to_c
+    ary = []
+    enumerate.each_pair do |c_symbol, enumeree_and_c_value|
+      ary << "\t#{c_symbol} = #{enumeree_and_c_value[1]}"
+    end
+    "enum #{@name} {\n\t" + ary.join(",\n\t") + "\n};\n"
+  end
+end

data/lib/csquare/generator/enum/namer.rb

@@ -0,0 +1,13 @@
+class CSquare::Generator::Enum::Namer
+  def initialize prefix
+    @prefix = prefix
+  end
+
+  def name arg
+    @prefix.nil? ? arg.to_s.upcase : "#{@prefix.upcase}_#{arg.to_s.upcase}"
+  end
+
+  def num arg
+    :auto
+  end
+end

data/lib/csquare/generator/enum/op_namer.rb

@@ -0,0 +1,34 @@
+class CSquare::Generator::Enum::OpNamer < CSquare::Generator::Enum::Namer
+  OP_TO_SUFFIX = {
+      :'<' => 'LT',
+      :'<=' => 'LTE',
+      :'>=' => 'GTE',
+      :'>' => 'GT',
+      :'==' => 'EQEQ',
+      :'!=' => 'NEQ',
+      :'-@' => 'NEG',
+      :'!@' => 'BANG',
+      :'+' => 'ADD',
+      :'-' => 'SUB',
+      :'*' => 'MUL',
+      :'/' => 'DIV',
+      :'%' => 'MOD',
+      :'&' => 'AND',
+      :'|' => 'OR',
+      :'^' => 'XOR',
+      :'<<' => 'LSH',
+      :'>>' => 'RSH',
+      :'~'  => 'NOT'
+  }
+
+  def name op_symbol
+    OP_TO_SUFFIX.has_key?(op_symbol) ?  super(OP_TO_SUFFIX[op_symbol]) : nil
+  end
+
+  # Use the character values if operations are single-character
+  def num op_symbol
+    op_string = op_symbol.to_s
+    op_string.size == 1 ? op_string.ord : :auto
+  end
+
+end

data/lib/csquare/generator/enum/sparse_op_namer.rb

@@ -0,0 +1,7 @@
+class CSquare::Generator::Enum::SparseOpNamer < CSquare::Generator::Enum::OpNamer
+
+  def num op_symbol
+    :auto
+  end
+
+end

data/lib/csquare/generator/index.rb

@@ -0,0 +1,340 @@
+class CSquare::Generator::Index
+
+  def initialize parent, index_name, options_and_mappings = {}
+    @parent   = parent
+    @basename = index_name
+    @inline_sources = {}
+
+    on        = options_and_mappings.delete(:on) # which enums
+    @with     = options_and_mappings.delete(:with) # which function template to call
+    @default  = options_and_mappings.delete(:default) # error function to call
+    @on       = {}
+
+    # STDERR.puts "@with=#{@with.inspect}, name=#{name.inspect}"
+
+    # Find enumerators
+    if on.is_a?(Array)
+      on.each do |enum_id|
+        @on[enum_id]  = generator.enumerators[enum_id]
+      end
+    else
+      @on[on || @basename] = generator.enumerators[on || @basename]
+    end
+
+    @signatures = map_from_index_options(options_and_mappings).merge(map_from_enums(options_and_mappings))
+    @mappings   = options_and_mappings # save what remains
+  end
+
+
+  #def common_signature type_id=nil
+  #  common_sig = nil
+  #
+  #  # First pass: Find the longest, make that the common sig
+  #  @signatures.each_value do |sig|
+  #    common_sig = sig.clone if common_sig.nil? || sig.params.size > common_sig.params.size
+  #  end
+  #
+  #  # Second pass: walk through arguments of common sig and see if the current
+  #  # sig is simpler.
+  #  @signatures.each_value do |sig|
+  #    # Start with return type
+  #    common_sig.type = simplify_type common_sig.type, sig.type
+  #
+  #    # Now do params
+  #    sig.params.each_index do |i|
+  #      common_sig.params[i] = simplify_type common_sig.params[i], sig.params[i]
+  #    end
+  #  end
+  #
+  #  if @signatures.size == 1
+  #    common_sig.params.each_index do |i|
+  #      common_sig.params[i] = simplify_type common_sig.params[i], common_sig.params[i]
+  #    end
+  #  end
+  #
+  #  common_sig.replace_types!(@parent.params(type_id)) unless type_id.nil?
+  #
+  #  common_sig
+  #end
+
+  def decorated_signature type_id, enumeree_stack=[]
+    stack = [type_id].concat(enumeree_stack).compact
+    name  = @mappings[type_id || enumeree_stack.first]
+    sig   = @signatures[name].clone
+
+    blueprint = @parent.is_a?(CSquare::Generator::Blueprint) ? @parent : @parent.blueprint_for(stack.first)
+
+    require 'pry'
+    binding.pry if sig.nil? || blueprint.nil?
+
+    sig.replace_types!(blueprint.params(stack.first))
+
+    sig
+  end
+
+
+  def common_signature type_id=nil, enumeree_stack=[], on=nil
+    on ||= @on
+
+    ary = []
+
+    if on.values.first.on == :ops # index by ops instead of by type
+      ary = @signatures.values.compact
+    else
+
+      dim_enum_id, dim_enum = on.first
+      next_dim_on           = on.select { |k,v| k != dim_enum_id }
+      next_dim_enum         = next_dim_on.first.last unless next_dim_on.size == 0
+
+      if next_dim_on.size == 0
+
+        dim_enum.enumerees.each do |enumeree|
+          next if enumeree.nil?
+          curr_enumeree_stack = stacked_enumerees(enumeree_stack, enumeree)
+          ary << decorated_signature(type_id, curr_enumeree_stack)
+        end
+
+      else
+
+        dim_enum.enumerees.each do |enumeree|
+          next if enumeree.nil?
+          curr_enumeree_stack = stacked_enumerees(enumeree_stack, enumeree)
+          ary << common_signature(type_id, curr_enumeree_stack, next_dim_on)
+        end
+      end
+
+      ary = ary.compact
+    end
+
+    common_sig = nil
+
+    ary.each do |sig|
+      common_sig = sig.clone if common_sig.nil? || sig.params.size > common_sig.params.size
+    end
+
+    # Second pass: walk through arguments of common sig and see if the current
+    # sig is simpler.
+    ary.each do |sig|
+
+      # Start with return type
+      common_sig.type = simplify_type common_sig.type, sig.type
+
+      # Now do params
+      sig.params.each_index do |i|
+        common_sig.params[i] = simplify_type common_sig.params[i], sig.params[i]
+      end
+    end
+
+    common_sig.replace_types!(@parent.params(type_id)) unless type_id.nil?
+
+    common_sig
+  end
+
+
+
+  # Returns the template typename (e.g., TYPE) for this function pointer array.
+  def return_typename
+    common_rtn = nil
+
+    @signatures.each_value do |sig|
+      common_rtn ||= sig.type.clone
+      simplify_type common_rtn, sig.type
+    end
+
+    common_rtn
+  end
+
+
+  # Return the function pointer array declaration. Count is optional.
+  def declaration type_id=nil
+    # Figure out the function pointer type
+    sig            = common_signature(type_id)
+
+    unnamed_params = sig.params.map { |p| p.name = nil; p.to_s }.join(", ")
+
+    # Figure out how many [][][] to include and what values to enclose in them
+    array_portion = begin
+      str = ""
+      @on.each_pair do |enum_id, enum_obj|
+        str += "[#{enum_obj.enumerees.size}]"
+      end
+      str
+    end
+
+    "#{sig.type.to_s} (*#{decorated_basename(type_id)}#{array_portion})(#{unnamed_params.to_s})"
+  end
+
+
+  def default_name type_ids=[]
+    type_ids ||= []
+    type_ids   = [type_ids] unless type_ids.is_a?(Array)
+    return 'NULL' if @default.nil?
+    decorated_name(@default, type_ids)
+  end
+
+
+  def decorated_name type_ids=[]
+    type_ids = [type_ids] unless type_ids.is_a?(Array)
+    type_ids.empty? ? name : [name].concat(type_ids).compact.join('_')
+  end
+
+
+  def name
+    @with || @basename
+  end
+
+
+  def decorated_basename type_id=nil
+    type_id.nil? ? @basename : "#{@basename}_#{type_id}"
+  end
+
+
+  def stacked_enumerees stack, enumeree
+    @parent.is_a?(CSquare::Generator::Blueprint) ? stack : stack.clone.push(enumeree)
+  end
+
+
+  def use_decorated? stack, enumeree
+    return false if !@mappings.has_key?(enumeree) || enumeree.nil?
+    return false if stack.include?(nil)
+    true
+  end
+
+
+  def decorated_calls universal_type_id, enumeree_stack=[], on=nil
+    on ||= @on
+
+    ary = []
+    count = 0
+
+    dim_enum_id, dim_enum = on.first
+    next_dim_on           = on.select { |k,v| k != dim_enum_id }
+    next_dim_enum         = next_dim_on.first.last unless next_dim_on.size == 0
+
+    if next_dim_on.size == 0
+
+      dim_enum.enumerate_for_index.each do |enumeree, c_value|
+
+        while c_value > count
+          ary << default_name
+          count += 1
+        end
+
+        if use_decorated?(enumeree_stack, enumeree)
+          curr_enumeree_stack = stacked_enumerees(enumeree_stack, enumeree)
+          ary << [@mappings[enumeree], universal_type_id].concat(curr_enumeree_stack).compact.map{|i| i.to_s}.join('_')
+        else
+          ary << default_name
+        end
+
+        count += 1
+      end
+
+    else
+
+      dim_enum.enumerate_for_index.each do |enumeree, c_value|
+
+        while c_value > count
+          ary << (next_dim_enum.nil? ? default_name : "{ #{[default_name]*next_dim_enum.enumerate_for_index.size} }")
+          count += 1
+        end
+
+        curr_enumeree_stack = stacked_enumerees(enumeree_stack, enumeree)
+
+        ary << decorated_calls(universal_type_id, curr_enumeree_stack, next_dim_on)
+        count += 1
+      end
+    end
+
+    ary
+  end
+
+
+  def to_c type_id=nil # arg only gets used when type_ids are constant (not set by enum)
+    "#{declaration(type_id)} = {\n  #{to_c_internal(decorated_calls(type_id))}\n};\n"
+  end
+
+
+protected
+
+  def to_c_internal calls, level=0
+    calls.map do |call|
+      call.is_a?(Array) ? "{ #{to_c_internal(call, level+1)} }" : call
+    end.join(level == 0 ? ",\n  " : ', ')
+  end
+
+
+  def simplify_type common, other
+    common_type = common.Parameter? ? common.type : common
+    other_type  = other.Parameter?  ? other.type  : other
+
+    if common_type.Pointer? != other_type.Pointer?
+      raise(SyntaxError, "pointer mismatch between functions:\n = #{common.inspect}\n = #{other.inspect}")
+    end
+
+    if common_type.Pointer? # both are pointers
+      common_type.type = C::Void.new(:const => (common_type.type.const? || other_type.type.const?))
+    elsif common_type.name != other_type.name
+      raise(SyntaxError, "typename mismatch between functions:\n = #{common.inspect}\n = #{other.inspect}")
+    elsif common_type.longness != other_type.longness
+      raise(SyntaxError, "longness mismatch between functions:\n = #{common.inspect}\n = #{other.inspect}")
+    end
+
+    # De-constify
+    if common_type.const? != other_type.const?
+      common_type.const = false
+    end
+
+    # De-unsigned-ify
+    if common_type.unsigned? != other_type.unsigned?
+      common_type.unsigned = false
+    end
+
+    common.Parameter? ? C::Parameter.new(:type => common_type) : common_type
+  end
+
+  def map_from_enums mappings
+    return {} if @with.nil?
+
+    f = @parent.read_and_parse_source(@with)
+
+    signatures = {}
+
+    @on.each_pair do |enum_id, enum_obj|
+      enum_obj.enumerees.each do |enumeree|
+        with = @with.clone
+        mappings[enumeree]      ||= with unless enumeree.nil?
+        signatures[with]        ||= f.entity.type
+      end
+    end
+
+    signatures
+  end
+
+
+  def map_from_index_options mappings
+    signatures = {}
+
+    # First get function signatures for the user-supplied hash of enumerees-to-functions
+    mappings.each_pair do |enumeree, function_name|
+      if function_name == :inline
+        real_name                 = @parent.inline_op_function_name(enumeree)
+        f                         = @parent.declare_inline_source(enumeree)
+        signatures[real_name]     = f.entity.type
+        mappings[enumeree]        = real_name
+      else
+        signatures[function_name] = @parent.read_and_parse_source(function_name).entity.type
+      end
+    end
+
+    signatures
+  end
+
+  
+  def generator
+    @parent.is_a?(CSquare::Generator) ? @parent : @parent.generator
+  end
+
+
+
+end