csquare 0.1.0

data/lib/csquare/generator/op.rb

@@ -0,0 +1,102 @@
+class CSquare::Generator::Op
+  def initialize blueprint, id
+    @blueprint = blueprint
+    @id        = id
+    @patterns  = {}
+  end
+
+  attr_reader :blueprint, :id, :patterns
+
+  def inspect
+    obj_id = "0x#{(self.object_id << 1).to_s(16)}"
+    "#<#{self.class.to_s}:#{obj_id} id=#{@id.inspect} blueprint=#{@blueprint.id.inspect} keys=#{patterns.keys.inspect}>"
+  end
+
+  def decorated args_and_types, return_type, default_type_symbol
+
+    # If we're dealing with a blueprint containing only one type, convert all LONG typenames to regular typenames
+    args_types =
+    if blueprint.types.size == 1
+      h = {}
+      args_and_types.each_pair do |arg, type|
+        h[arg] = type == blueprint.long_key ? blueprint.key : type
+      end
+
+      # Also update the return_type if applicable
+      return_type = blueprint.key if return_type == blueprint.long_key
+      h
+    else
+      args_and_types
+    end
+
+    # Determine pattern and type symbol
+    pattern     = select_pattern_clone(args_types, return_type)
+
+    return nil if pattern.nil? # no match, no need to deal with this expression
+
+    type_symbol = select_type_symbol(args_types.values, return_type, default_type_symbol)
+
+    # Replace $0, $1, ...
+    args_types.keys.each_with_index do |arg, i|
+      if arg =~ /^\*/ && pattern =~ /\$#{i}\./ # Flip *x.y to x->y
+        deref_arg = "#{arg[1...arg.size]}->"
+        pattern.gsub!(/\$#{i}\./, deref_arg)
+      else
+        pattern.gsub!(/\$#{i}/, arg.to_s)
+      end
+    end
+
+
+    #if self.is_a?(CSquare::Generator::AssignOp)
+    #  STDERR.puts args_types
+    #  if args_types.has_key?(0) && args_types[0] == :integer && return_type == "LONG_TYPE"
+    #    require 'pry'
+    #    binding.pry
+    #  end
+    #end
+
+
+    begin
+      # Build an AST for the completed expression
+      ast = C::Expression.parse(pattern)
+    rescue C::ParseError => e
+      STDERR.puts "\nParseError:"
+      STDERR.puts pattern.inspect
+      raise(e)
+    end
+
+    ast.decorate_calls!(type_symbol, blueprint)
+
+    # Return type and AST get returned
+    if default_type_symbol == type_symbol
+      [ast, blueprint.key]
+    else
+      [ast, blueprint.long_key]
+    end
+  end
+
+  def [] t
+    @patterns[t]
+  end
+
+  def []= t_or_ary, pattern
+    if t_or_ary.is_a?(Array)
+      t_or_ary.each do |t|
+        @patterns[t] = pattern
+      end
+    else
+      @patterns[t_or_ary] = pattern
+    end
+  end
+
+  def has_key? t
+    @patterns.has_key?(t)
+  end
+
+protected
+  def select_pattern_clone args_types, return_type
+    p = select_pattern(args_types, return_type)
+    return p if p.nil?
+    p.clone
+  end
+end

data/lib/csquare/generator/type.rb

@@ -0,0 +1,62 @@
+class CSquare::Generator::Type
+  def initialize blueprint_obj, id, ctype, options
+    @blueprint  = blueprint_obj
+    @id         = id
+    @ctype      = ctype
+    @long_id    = options.delete(:long)
+    @min        = options.delete(:min)
+    @max        = options.delete(:max)
+
+    @keys       = begin
+      k = {}
+      all_types = @blueprint.generator.types
+      options.each_pair do |typename, type_id|
+        k[typename]           = type_id
+        k["LONG_#{typename}"] = all_types[type_id].long_id
+      end
+      k
+    end
+  end
+
+  attr_reader :id, :long_id, :ctype, :blueprint, :min, :max, :keys
+
+  def inspect
+    obj_id = "0x#{(self.object_id << 1).to_s(16)}"
+    min_part = " min=#{@min.inspect}" unless @min.nil?
+    max_part = " max=#{@max.inspect}" unless @max.nil?
+    "#<#{self.class.to_s}:#{obj_id} #{@id.inspect}=>#{@blueprint.id.inspect} ctype=#{@ctype.inspect} long_id=#{@long_id.inspect} keys=#{@keys.inspect}#{min_part.to_s}#{max_part.to_s}>"
+  end
+
+  def generator
+    @blueprint.generator
+  end
+
+  def long_id
+    @long_id || @id
+  end
+
+  def long
+    @blueprint.types[long_id]
+  end
+
+  # Returns the @keys hash but with a Type in the value instead of a Type id
+  def type_keys
+    h = {}
+    @keys.each_pair do |typename, type_id|
+      h[typename] = generator.types[type_id]
+      h["LONG_#{typename}"] = h[typename].long unless h[typename].long.nil?
+    end
+    h
+  end
+
+  # Same as type_keys but returns just the ctype field
+  def ctype_keys
+    h = {}
+    type_keys.each_pair do |typename, type|
+      h[typename] = type.ctype
+      h["LONG_#{typename}"] = type.long.ctype unless type.long.nil?
+    end
+    h
+  end
+
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: csquare
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- John Woods
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: &77989090 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *77989090
+- !ruby/object:Gem::Dependency
+  name: cast
+  requirement: &77988870 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *77988870
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &77988630 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: *77988630
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &77988410 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *77988410
+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.'
+email:
+- john.woods@marcottelab.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- Manifest.txt
+- History.txt
+files:
+- 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
+- .gemtest
+homepage: http://github.com/mohawkjohn/csquare
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: csquare
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: C, then D, C++, C# -- now C^2, simple C templates using Ruby
+test_files: []