csquare 0.1.0

data/lib/csquare/base.rb

@@ -0,0 +1,36 @@
+class CSquare::Base
+  EXTRA_TYPE_NAMES = %w{bool}
+
+  def initialize code, type_names
+    @parser = C::Parser.new
+    type_names = (type_names + EXTRA_TYPE_NAMES).uniq
+    type_names.each { |t| @parser.type_names << t }
+
+    tree = begin
+      @parser.parse(code)
+    rescue C::ParseError => e
+      if e.message.include?("parse error on ID (")
+        STDERR.puts "CSquare::Base: A parse error was encountered: #{e.message}"
+        STDERR.puts "This typically means you're using a special typename which CSquare does not know how to recognize."
+        STDERR.puts "It is recommended that you avoid doing so; however, if you must, try modifying CSquare::Base::EXTRA_TYPE_NAMES."
+      else
+        STDERR.puts "CSquare::Base: An unrecognized parse error was encountered."
+        STDERR.puts code.to_s
+      end
+
+      STDERR.puts "The currently defined types are: #{type_names.inspect}"
+
+      raise(e)
+    end
+
+    raise(ArgumentError, "multiple entities not supported") if tree.entities.size > 1
+
+    @entity     = tree.entities[0]
+  end
+
+  def code
+    entity.to_s
+  end
+
+  attr_reader :entity, :parser
+end

data/lib/csquare/cerb.rb

@@ -0,0 +1,82 @@
+# Loosely based on ERB by Masatoshi Seki.
+#
+# For handling Ruby code embedded in CSquare (C) sources.
+#
+#
+# int main() {
+# #RUBY if blueprint.id == :rational
+#   return 0;
+# #RUBY else
+#   return 1;
+# #RUBY end
+# }
+#
+# TODO: Rewrite this so it uses a grammar that can recognize comments.
+#
+# NOTE: DO NOT USE PRY IN HERE. Annoying to kill.
+
+
+class CERB
+  SPLIT_REGEXP = /^\s*#\s*RUBY\s+/
+
+  def initialize file, blueprint
+    @blueprint = blueprint
+
+    out = Buffer.new
+    eval_str = nil
+    @src = []
+
+    while line = file.gets
+      line.chomp!
+
+      c_code, eval_str = line.split(SPLIT_REGEXP, 2)
+
+      #binding.pry if line == "#RUBY if blueprint.id != :complex"
+
+      if eval_str.nil?
+        out.push c_code
+      else
+        unless out.empty?
+          @src << "puts #{out.result.dump}"
+          out.reset!
+        end
+
+        @src << "puts ''" # empty line in place of #RUBY statements (ensures line numbers match source files in debugging)
+        @src << eval_str
+      end
+    end
+
+    @src << "puts #{out.result.dump}" if eval_str.nil? && !out.empty?
+    @src << "puts ''" # prevent EOF errors
+
+    #binding.pry
+
+    eval @src.join("\n")
+  end
+  attr_reader :blueprint, :src
+
+
+
+  class Buffer
+    def initialize
+      @code = []
+    end
+
+    def push code
+      @code << code
+    end
+
+    def result
+      @code.join("\n")
+    end
+
+    def reset!
+      @code = []
+    end
+
+    def empty?
+      @code.size == 0
+    end
+  end
+
+end

data/lib/csquare/function.rb

@@ -0,0 +1,175 @@
+# Represents a C function template.
+class CSquare::Function < CSquare::Base
+  def initialize code, type_names
+    super code, type_names
+    @decorated_name = false
+    raise(SyntaxError, "expected function definition") unless entity.FunctionDef?
+  end
+
+  # Make a deep copy of this function.
+  def clone
+    CSquare::Function.new(self.code, @parser.type_names.to_a)
+  end
+
+  # Return the function declaration for the header file
+  def declaration
+    t = @entity.type
+    "#{t.type.to_s} #{name}(#{t.params.to_s});"
+  end
+
+  def rename! new_name
+    @entity.name = new_name
+  end
+
+  def decorate_name! type_symbol
+    @entity.name = decorated_name(type_symbol)
+    @decorated_name = true
+    self
+  end
+
+  def decorated_name type_symbol
+    @decorated_name ? @entity.name : "#{@entity.name}_#{type_symbol}"
+  end
+
+  def name
+    @entity.name
+  end
+
+  # Return a hash of function parameters => types. Passing the argument :string will return type strings instead of CAST types.
+  def params(as=nil)
+    @entity.params(as)
+  end
+
+  # Return a hash of function local variables => types. You may pass :string as the sole argument if you want
+  def locals(as=nil)
+    @entity.def.locals(as)
+  end
+
+  def definition
+    @entity.def
+  end
+
+  def return_type
+    @entity.type.type
+  end
+
+
+  # Get those parameters which we need to watch, based on the template typenames given (as an argument).
+  def template_params typenames
+    watch_params = {}
+
+    params.each_pair do |varname, fparam|
+      if typenames.include?(fparam.underlying_typename)
+        watch_params[varname] = fparam.underlying_typename
+      end
+    end
+    watch_params
+  end
+
+
+  # Get those local variables which we need to watch when applying templates, based on the template typenames given (only argument).
+  def template_locals typenames
+    watch_locals = {}
+
+    locals.each_pair do |varname, fdec|
+      if typenames.include?(fdec.underlying_typename)
+        watch_locals[varname] = fdec.underlying_typename
+      end
+    end
+    watch_locals
+  end
+
+
+  # Given some hash of typenames to replacement types, change all parameters and declarations.
+  #
+  # Hash should consist of string values only.
+  def replace_types! h
+    # STDERR.puts "parser typenames: #{@parser.type_names.inspect}"
+
+    h.each_value do |new_typename|
+      @parser.type_names << new_typename
+      C.default_parser.type_names << new_typename
+    end
+
+    # Replace the types in the function prototype
+    @entity.entries[0].replace_types! h
+
+    # Recurse down into function blocks
+    @entity.entries[1].replace_types! h
+
+    # Replace typecasts
+    @entity.recursively_replace_casts! h
+  end
+
+
+  # Given all function calls, figure out what they should instead be and change the tree as we go.
+  def decorate_calls! blueprint, type_symbol
+    @entity.recursively_decorate_calls! blueprint, type_symbol
+  end
+
+
+  # Return a list of local variables, function names, parameters, etc; hashed to type (string).
+  def locals_and_types blueprint
+    vars_and_types = blueprint.generator.externs.merge(blueprint.externs).
+                        merge(params).
+                        merge(locals)
+
+    # Go through and remove const indicators, as these will only get in the way
+    vars_and_types.each_pair do |var, type|
+      if type.is_a?(C::DirectType)
+        vars_and_types[var].const = false
+        vars_and_types[var] = vars_and_types[var].to_s
+      end
+    end
+
+    vars_and_types
+  end
+
+
+  # Is some local identifier in use?
+  def has_local? var, blueprint=nil
+    @entity.has_local? var, blueprint
+  end
+
+
+  # Return the type associated with some variable. Optionally can look for globals if blueprint is given.
+  def type_of var, blueprint=nil
+    @entity.type_of var, blueprint
+  end
+
+
+  def mutate! blueprint, new_type_symbol, params = nil
+
+    # Create a frozen duplicate of this function, that hasn't had its typenames changed.
+    f = self.clone
+
+    self.decorate_name! new_type_symbol
+
+    self.entity.recombine! f, blueprint, new_type_symbol
+
+    self.replace_types!(params || blueprint.params(new_type_symbol))
+
+    self
+  end
+
+
+  class << self
+    def find_broken_ast tree
+      begin
+        tree.to_s
+        return nil
+      rescue TypeError
+        tree.each do |e|
+          x = CSquare::Function.find_broken_ast(e)
+          unless x.nil?
+            require "pry"
+            binding.pry
+          end
+        end
+        return tree
+      end
+    end
+  end
+
+
+end

data/lib/csquare/generator.rb

@@ -0,0 +1,374 @@
+class CSquare::Generator
+  include CSquare::Indexable
+
+  DEFAULT_EXTERNS = {'fprintf' => 'int'}
+
+  acts_as_indexable
+
+  # To use for :inline index functions -- need to know return type
+  OP_RETURN_TYPES = {
+      :'<' => :boolean,
+      :'>' => :boolean,
+      :'<=' => :boolean,
+      :'>=' => :boolean,
+      :'==' => :boolean,
+      :'!=' => :boolean,
+      :'+' => :key,
+      :'-' => :key,
+      :'*' => :key,
+      :'/' => :key,
+      :'%' => :key
+  }
+
+  # To use for :inline index functions that should be automatically generated
+  OP_FUNCTION_NAMES = {
+      :'<' => 'lt',
+      :'>' => 'gt',
+      :'<=' => 'lte',
+      :'>=' => 'gte',
+      :'==' => 'eqeq',
+      :'!=' => 'neq',
+      :'+' => 'add',
+      :'-' => 'sub',
+      :'*' => 'mul',
+      :'/' => 'div',
+      :'%' => 'mod'
+  }
+
+  BOOL_CAST_TO_OP = {
+      C::Less => :'<',
+      C::More => :'>',
+      C::LessOrEqual => :'<=',
+      C::MoreOrEqual => :'>=',
+      C::Equal => :'==',
+      C::NotEqual => :'!=',
+      C::And => :'&&',
+      C::Or => :'||'
+  }
+
+  UNARY_CAST_TO_OP = {
+      C::Negative => :'-@',
+      C::Not => :'!@',
+      C::Arrow => :'->',
+      C::Dereference => :'*@'
+  }
+
+  ASSIGN_CAST_TO_OP = {
+      C::Assign => :'=',
+  }
+
+  BINARY_ASSIGN_CAST_TO_OP = {
+      C::AddAssign => :'+=',
+      C::SubtractAssign => :'-=',
+      C::MultiplyAssign => :'*=',
+      C::DivideAssign => :'/=',
+      C::ModAssign => :'%='
+  }
+
+  BINARY_CAST_TO_OP = {
+      C::Add => :'+',
+      C::Subtract => :'-',
+      C::Multiply => :'*',
+      C::Divide => :'/',
+      C::Mod => :'%',}
+
+  BIT_CAST_TO_OP = {
+      C::BitAnd => :'&',
+      C::BitOr => :'|',
+      C::BitXor => :'^',
+      C::ShiftLeft => :'<<',
+      C::ShiftRight => :'>>'
+  }
+
+  CAST_TO_OP = BOOL_CAST_TO_OP.
+      merge(UNARY_CAST_TO_OP).
+      merge(ASSIGN_CAST_TO_OP).
+      merge(BINARY_CAST_TO_OP).
+      merge(BIT_CAST_TO_OP).
+      merge(BINARY_ASSIGN_CAST_TO_OP)
+
+  def initialize path, c_output_basename, options = {}
+    options = {
+        :include_guards => true,
+        :header => true,
+        :include_header => true
+    }.merge(options)
+
+    @default_key  = 'TYPE'
+    @path         = path
+    @basename     = c_output_basename
+    @externs      = DEFAULT_EXTERNS
+    @blueprints   = {}
+    @enumerators  = {}
+
+    yield self
+
+    # STDERR.puts "GENERATOR EXTERNS: " + @externs.inspect
+
+    @blueprints.each_key do |id|
+      @blueprints[id].expand_ops!
+    end
+
+    mutant_functions = []
+    blueprints.each_value do |blueprint|
+      blueprint.types.each_pair do |type_symbol,type|
+        mutant_functions = mutant_functions.concat(blueprint.mutate_functions(type_symbol))
+      end
+    end
+
+    declarations = write_c_file(options[:include_guards], options[:include_header], mutant_functions)
+    write_h_file(options[:include_guards], declarations) if options[:header]
+  end
+
+  attr_reader :blueprints, :path, :basename, :enumerators
+
+  def inspect
+    obj_id = "0x#{(self.object_id << 1).to_s(16)}"
+    "#<#{self.class.to_s}:#{obj_id} basename=#{@basename.inspect} blueprint_ids=#{@blueprints.keys.inspect} path=#{@path.inspect}>"
+  end
+
+  def default_key k=nil
+    return @default_key if k.nil?
+    @default_key = k
+  end
+
+
+  def c_include_guard
+    "#{@basename.upcase}_C"
+  end
+
+  def h_include_guard
+    "#{@basename.upcase}_H"
+  end
+
+
+  def c_filename
+    "#{@basename}.c"
+  end
+
+  def h_filename
+    "#{@basename}.h"
+  end
+
+  # Shorthand for blueprints[id]
+  def [] blueprint_id
+    blueprints[blueprint_id]
+  end
+
+  # Register symbols available to all functions, and their types. Takes a hash as only argument.
+  #
+  # Example:
+  #
+  #    c.externs 'NM_MAX' => :integer, 'CblasNoTrans' => 'char', 'fprintf' => 'int'
+  #
+  #
+  def externs h=nil
+    return @externs if h.nil?
+    @externs.merge!(h)
+  end
+
+  # Create a blueprint for a set of types that all behave a certain way.
+  #
+  # At minimum, you should provide the name of the blueprint (e.g., <tt>blueprint(:integer)</tt>). You may also provide
+  # a template parameter name, which defaults to TYPE, and field parameters.
+  #
+  # Example (complex):
+  #
+  #    c.blueprint(:complex, 'TYPE', :r => 'FLOAT', :i => 'FLOAT') do |t|
+  #      # ...
+  #    end
+  #
+  def blueprint id, template_param = 'TYPE', field_params = {}, &block
+    raise(ArgumentError, "id #{id} already declared") if @blueprints.has_key?(id)
+
+    # Clear cache of blueprints by type_id
+    @blueprint_for = nil
+
+    @blueprints[id] = Blueprint.new(self, id, template_param, field_params, &block)
+
+    self
+  end
+
+
+  # Get all types stored in the various template types
+  def types
+    h = {}
+    @blueprints.each_value do |blueprint|
+      blueprint.types.each_pair do |id, type|
+        if h.has_key?(id)
+          raise(StandardError, "two types with same id: #{id}")
+        else
+          h[id] = type
+        end
+      end
+    end
+    h
+  end
+
+  # Returns the blueprint corresponding to some type_id. Caches types for faster lookup.
+  def blueprint_for type_id
+    @blueprint_for ||= types
+    @blueprint_for[type_id].blueprint
+  end
+
+
+  def enumerate name, opts = {}
+    @enumerators[name] = CSquare::Generator::Enum.new(name, opts)
+  end
+
+  # Get a list of ops used (just the symbols)
+  def op_symbols
+    ary = []
+    @blueprints.each_value do |blueprint|
+      ary = ary.concat blueprint.op_symbols
+    end
+    ary.sort.uniq
+  end
+
+  def indices_c_code
+    ary = []
+
+    # Blueprint-scoped indices
+    @blueprints.each_value do |blueprint|
+      blueprint.indices.values.flatten.each do |index|
+        blueprint.types.each_key do |type_id|
+          ary << index.to_c(type_id)
+        end
+      end
+    end
+
+    # Add generator-scoped indices
+    @indices.values.flatten.each do |index|
+      ary << index.to_c
+    end
+
+    ary
+  end
+
+
+  def read_source source_filename
+    begin
+      g = self.is_a?(CSquare::Generator) ? self : self.generator
+      Dir.chdir(g.path) do
+        if File.exists?(source_filename)
+          preprocess_source File.new(source_filename, "r")
+        else
+          raise IOError, "file '#{source_filename}' not found in '#{g.path}' or '#{File.join(g.path, self.id.to_s)}'"
+        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
+
+
+  # Return a hash giving mappings from template typenames (keys, e.g., 'TYPE') to ctypes.
+  def params type_symbol
+    types_ = types[type_symbol]
+    k = types_.ctype_keys # hash of typenames to type ids
+
+    begin
+      k[@default_key] = types_.ctype
+    rescue NoMethodError
+      STDERR.puts "NoMethodError: @default_key=#{@default_key}, type_symbol = #{type_symbol}"
+    end
+    k["LONG_#{@default_key}"] = (types_.long || types_).ctype
+    k
+  end
+
+
+  # Return all possible typenames for a given source
+  def keys_for f_name
+    ary = self.template_keys(f_name)
+    @blueprints.each_value do |blueprint|
+      next unless blueprint.has_source?(f_name)
+      ary << blueprint.template_keys(f_name)
+    end
+    ary.flatten.compact.uniq
+  end
+
+
+protected
+  def write_c_file with_guards = true, include_header = true, functions = []
+    declarations = []
+
+    out = File.new(c_filename, "w")
+
+    out.puts("#ifndef #{c_include_guard}\n# define #{c_include_guard}\n\n") if with_guards
+
+    h = include_header == true ? h_filename : include_header
+
+    out.puts("#include \"#{h}\"\n\n") if include_header
+
+    out.puts indices_c_code.join("\n\n")
+
+    functions.each do |f|
+      begin
+      out.puts f.entity.to_s + "\n"
+      rescue TypeError => e
+        STDERR.puts e.inspect
+        CSquare::Function.find_broken_ast(f.entity)
+      end
+      declarations << f.declaration
+    end
+
+    out.puts("#endif // #{c_include_guard}") if with_guards
+
+    out.close
+
+    declarations
+  end
+
+
+  def write_h_file with_guards = true, declarations = []
+    out = File.new(h_filename, "w")
+
+    out.puts("#ifndef #{h_include_guard}\n# define #{h_include_guard}\n\n") if with_guards
+
+    enumerators.each_value do |enum|
+      out.puts enum.to_c
+    end
+
+    declarations.each do |d|
+      out.puts d
+    end
+
+    out.puts("#endif // #{h_include_guard}") if with_guards
+
+    out.close
+  end
+
+
+  def keys
+    k = [@default_key, "LONG_#{@default_key}"]
+    types.each_pair do |type_symbol, type|
+      k = k.concat(type.keys.keys)
+    end
+    k
+  end
+
+  def extra_template_keys_for source
+    keys = []
+    blueprints.each_value do |blueprint|
+      new_keys = blueprint.extra_keys(source) if blueprint.extra_templates_by_source.has_key?(source)
+      keys = keys.concat(new_keys) unless new_keys.nil?
+    end
+    keys.compact.uniq
+  end
+end
+
+require_relative 'generator/blueprint'
+require_relative 'generator/index'
+require_relative 'generator/type'
+require_relative 'generator/op'
+require_relative 'generator/binary_op'
+require_relative 'generator/boolean_op'
+require_relative 'generator/assign_op'
+require_relative 'generator/enum'
+require_relative 'generator/enum/namer'
+require_relative 'generator/enum/op_namer'
+require_relative 'generator/enum/sparse_op_namer'