cumo 0.1.0

data/lib/erbpp.rb

@@ -0,0 +1,294 @@
+require "erb"
+
+class ErbPP
+  ATTRS = []
+
+  class ParamNotSetError < StandardError; end
+
+  def self.define_attrs(attrs)
+    attrs.each do |attr|
+      ivar = ("@"+attr).to_sym
+      define_method(attr){|*a| attr_method(ivar,*a)}
+    end
+  end
+
+  def attr_method(ivar,arg=nil)
+    if arg.nil?
+      instance_variable_get(ivar)
+    else
+      instance_variable_set(ivar,arg)
+    end
+  end
+
+  def initialize(parent,erb_path,opts={})
+    parents.push(parent) if parent
+    @erb_path = erb_path
+    @tmpl = @erb_path
+
+    @opts = opts
+    if @opts.class != Hash
+      raise ArgumentError, "option is not Hash"
+    end
+
+    @opts.each do |k,v|
+      ivar = ("@"+k.to_s).to_sym
+      instance_variable_set(ivar,v)
+    end
+  end
+
+  def load_erb
+    safe_level = nil
+    trim_mode = '%<>'
+    @erb = ERB.new(File.read(@erb_path),safe_level,trim_mode)
+    @erb.filename = @erb_path
+  end
+
+  def parents
+    @parents ||= []
+  end
+
+  def search_method_in_parents(_meth_id)
+    parents.each do |x|
+      if x.has_attr? _meth_id
+        return x
+      end
+    end
+    parents.each do |x|
+      if f = x.search_method_in_parents(_meth_id)
+        return f
+      end
+    end
+    nil
+  end
+
+  def attrs
+    self.class::ATTRS
+  end
+
+  def has_attr?(_meth_id)
+    respond_to?(_meth_id) or attrs.include?(_meth_id.to_s)
+  end
+
+  def check_params(*params)
+    params.each do |x|
+      val = send(x)
+      if !val # || val.empty?
+        raise ParamNotSetError,"parameter #{x.to_s} is not set"
+      end
+    end
+  end
+
+  alias method_missing_alias method_missing
+
+  def method_missing(_meth_id, *args, &block)
+    ivar = "@"+_meth_id.to_s
+    if args.empty? and instance_variable_defined?(ivar)
+      parm = instance_variable_get(ivar)
+      if parm.nil?
+        raise ParamNotSetError,"parameter #{_meth_id.to_s} is not set"
+      end
+      parm
+    elsif args.size == 1 and attrs.include?(_meth_id.to_s)
+      instance_variable_set(ivar,args.first)
+    elsif x = search_method_in_parents(_meth_id)
+      x.send(_meth_id, *args, &block)
+    else
+      method_missing_alias(_meth_id, *args)
+    end
+  end
+
+  def run
+    load_erb unless @erb
+    @erb.run(binding)
+  end
+
+  def result
+    load_erb unless @erb
+    @erb.result(binding)
+  end
+end
+
+# ----------------------------------------------------------------------
+
+class IdVar
+  DEFS = []
+
+  def id_decl
+    "static ID #{@id_var};"
+  end
+
+  def id_assign
+    "#{@id_var} = rb_intern(\"#{@name}\");"
+  end
+
+  def initialize(parent,name,var=nil)
+    @name = name
+    var = name if var.nil?
+    @id_var = "id_"+var.gsub(/\?/,"_p").gsub(/\!/,"_bang")
+    DEFS.push(self)
+  end
+
+  def self.declaration
+    DEFS.map do |x|
+      x.id_decl
+    end
+  end
+
+  def self.assignment
+    DEFS.map do |x|
+      x.id_assign
+    end
+  end
+end
+
+# ----------------------------------------------------------------------
+
+class Function < ErbPP
+  DEFS = []
+
+  attrs = %w[
+    singleton
+    meth
+    n_arg
+  ]
+  define_attrs attrs
+
+  def id_op
+    if op.size == 1
+      "'#{op}'"
+    else
+      "id_#{method}"
+    end
+  end
+
+  def method
+    meth.gsub(/\?/,"_p").gsub(/\!/,"_bang")
+  end
+
+  def initialize(parent,tmpl,**opts)
+    super
+    @aliases = opts[:aliases] || []
+    parent.tmpl_dirs.each do |d|
+      @erb_path = File.join(d, tmpl+".c")
+      break if File.exist?(@erb_path)
+    end
+    DEFS.push(self)
+  end
+
+  def c_method
+    "#{m_prefix}#{method}"
+  end
+
+  def c_iter
+    begin
+      t = "_"+type_name
+    rescue
+      t = ""
+    end
+    "iter#{t}_#{method}"
+  end
+  alias c_iterator c_iter
+
+  def c_func
+    s = singleton ? "_s" : ""
+    begin
+      t = "_"+type_name
+    rescue
+      t = ""
+    end
+    "cumo#{t}#{s}_#{method}"
+  end
+  alias c_function c_func
+  alias c_instance_method c_func
+
+  def op_map
+    @op || meth
+  end
+
+  def code
+    result + "\n\n"
+  end
+
+  def definition
+    return nil if n_arg <= -9
+    s = singleton ? "_singleton" : ""
+    check_params(:mod_var, :op_map, :c_func, :n_arg)
+    m = op_map
+    a = ["rb_define#{s}_method(#{mod_var}, \"#{m}\", #{c_func}, #{n_arg});"]
+    @aliases.map{|x| a << "rb_define_alias(#{mod_var}, \"#{x}\", \"#{m}\");"}
+    a
+  end
+
+  def self.codes
+    a = []
+    DEFS.each do |i|
+      x = i.code
+      a.push(x) if x
+    end
+    a
+  end
+
+  def self.definitions
+    a = []
+    DEFS.each do |i|
+      case x = i.definition
+      when Array
+        a.concat(x)
+      when String
+        a.push(x)
+      else
+        raise "unknown definition: #{x}" if x
+      end
+    end
+    a
+  end
+end
+
+class ModuleFunction < Function
+  def definition
+    m = op_map
+    "rb_define_module_function(#{mod_var}, \"#{m}\", #{c_func}, #{n_arg});"
+  end
+end
+
+class NodefFunction < Function
+  def definition
+    nil
+  end
+end
+
+class Alias < ErbPP
+  def initialize(parent, dst, src)
+    super(parent,nil)
+    @dst = dst
+    @src = src
+    Function::DEFS.push(self)
+  end
+
+  def code
+    nil
+  end
+
+  def definition
+    "rb_define_alias(#{mod_var}, \"#{dst}\", \"#{src}\");"
+  end
+end
+
+class Const < ErbPP
+  def initialize(parent,name,value,desc)
+    super(parent,nil)
+    @name = name
+    @value = value
+    @desc = desc
+    Function::DEFS.push(self)
+  end
+
+  def code
+    nil
+  end
+
+  def definition
+    "/*"+desc+"*/\n    "+
+      "rb_define_const(#{mod_var},\"#{name}\",#{value});"
+  end
+end

data/lib/erbpp/line_number.rb

@@ -0,0 +1,137 @@
+class CountLnString < String
+
+  def initialize(filename)
+    @filename = filename
+    @lnchar = "\n"
+    @buf = ""
+    @str = ""
+    @countln = 1
+    @current = 1
+    super("\n"+report_line)
+  end
+
+  def report_line
+    "#line #{@current} \"#{@filename}\"\n"
+  end
+
+  def concat0(s)
+    ln(caller[0])
+    @buf.concat(s)
+    @str.concat(s)
+  end
+
+  def concat1(s)
+    ln(caller[0])
+    @buf.concat(s)
+  end
+
+  def ln(status=nil)
+    case status
+    when /:(\d+):/
+      n = $1.to_i
+    else
+      n = status.to_i
+    end
+    return if n == @current
+    if @current != @countln || @postpone
+      if /\A\s*\z/ =~ @str || /\A#line / =~ @buf
+        @postpone = true
+      elsif @in_comment
+        @postpone = false
+      else
+        if self[-1] != "\n"
+          concat("\n")
+        end
+        concat(report_line)
+        @postpone = false
+      end
+    end
+    concat(@buf)
+
+    b = @buf.gsub(/".*?(?<!\\)"/,'""')
+    /^.*(\/\*)(.*?)$/ =~ b
+    x = $2
+    /^.*(\*\/)(.*?)$/ =~ b
+    y = $2
+    if x
+      if y
+        if x.size < y.size
+          #:in_comment
+          @in_comment = true
+        else
+          #:out_comment
+          @in_comment = false
+        end
+      else
+        #:in_comment
+        @in_comment = true
+      end
+    else
+      if y
+        #:out_comment
+        @in_comment = false
+      else
+        #:keep
+      end
+    end
+
+    @countln = @current + @buf.count(@lnchar)
+    @current = n
+    @buf = ""
+    @str = ""
+  end
+
+  def d(s)
+    p [s, [x,y], r]
+    r
+  end
+
+  def final
+    concat(@buf)
+  end
+
+end
+
+class ERB
+  alias result_orig result
+
+  def result(b=new_toplevel)
+    src = src_with_cpp_line
+    if @safe_level
+      proc {
+        $SAFE = @safe_level
+        eval(src, b, (@filename || '(erb)'), 0)
+      }.call
+    else
+      #open("tmpout","w"){|f| f.write src} if /dtype/=~@filename
+      eval(src, b, (@filename || '(erb)'), 0)
+    end
+  end
+
+  alias src_orig src
+
+  def src
+    src_with_cpp_line
+  end
+
+  def src_with_cpp_line
+    @src.each_line.with_index.map do |line, num|
+      # ruby ver 2.4 or earlier
+      line.gsub!(/_erbout.concat "/,'_erbout.concat0 "')
+      line.gsub!(/_erbout.concat\(/,'_erbout.concat1(')
+      # ruby ver 2.5
+      line.gsub!(/_erbout\.<<\(-/,'_erbout.concat0(-')
+      line.gsub!(/_erbout\.<<\(\(/, '_erbout.concat1((')
+      if num==0
+        # skip
+      elsif num==1
+        f = @filename.dump
+        line.sub!(/_erbout = (\+?''|String\.new);/, "_erbout = CountLnString.new(#{f});")
+      elsif /^; _erbout\.force_encoding/ =~ line
+        line.sub!(/^;/,";_erbout.ln(#{num});")
+      end
+      line
+    end.join+";_erbout.final;"
+  end
+
+end

data/lib/erbpp/narray_def.rb

@@ -0,0 +1,381 @@
+require 'erbpp'
+
+module DefMethod
+
+  def def_id(meth,var=nil)
+    IdVar.new(self, meth, var)
+  end
+
+  def def_method(meth, n_arg, tmpl=nil, opts={})
+    h = {:meth => meth, :n_arg => n_arg}
+    h.merge!(opts)
+    tmpl ||= meth
+    Function.new(self, tmpl, h)
+  end
+
+  def def_singleton(meth, n_arg, tmpl=nil, opts={})
+    def_method(meth, n_arg, tmpl, :singleton => true)
+  end
+
+  def def_alias(dst, src)
+    Alias.new(self, dst, src)
+  end
+
+  def def_allocate(tmpl)
+    h = {:meth => "allocate", :singleton => true}
+    Allocate.new(self, tmpl, h)
+  end
+
+  def binary(meth, ope=nil)
+    ope = meth if ope.nil?
+    def_method(meth, 1, "binary", :op => ope)
+  end
+
+  def binary2(meth, ope=nil)
+    ope = meth if ope.nil?
+    def_method(meth, 1, "binary2", :op =>ope)
+  end
+
+  def unary(meth, ope=nil)
+    def_method(meth, 0, "unary", :op => ope)
+  end
+
+  def pow
+    def_method("pow", 1, "pow", :op => "**")
+  end
+
+  def unary2(meth, dtype, tpclass)
+    h = {:dtype => dtype, :tpclass => tpclass}
+    def_method(meth, 0, "unary2", h)
+  end
+
+  def set2(meth, dtype, tpclass)
+    h = {:dtype => dtype, :tpclass => tpclass}
+    def_method(meth, 1, "set2", h)
+  end
+
+  def cond_binary(meth,op=nil)
+    op = meth unless op
+    def_method(meth, 1, "cond_binary", :op => op)
+  end
+
+  def cond_unary(meth)
+    def_method(meth, 0, "cond_unary")
+  end
+
+  def bit_count(meth)
+    def_method(meth, -1, "bit_count")
+  end
+
+  def bit_reduce(meth, init_bit)
+    h = {:init_bit=>init_bit}
+    def_method(meth, -1, "bit_reduce", h)
+  end
+
+  def accum(meth, dtype, tpclass)
+    h = {:dtype => dtype, :tpclass => tpclass}
+    def_method(meth, -1, "accum", h)
+  end
+
+  def accum_index(meth)
+    def_method(meth, -1, "accum_index")
+  end
+
+  def cum(meth, cmacro)
+    def_method(meth, -1, "cum", cmacro:cmacro)
+  end
+
+  def accum_binary(meth, ope=nil)
+    ope = meth if ope.nil?
+    def_method(meth, -1, "accum_binary", :op => ope)
+  end
+
+  def qsort(tp, dtype, dcast, suffix="")
+    h = {:tp => tp, :dtype => dtype, :dcast => dcast, :suffix => suffix}
+    NodefFunction.new(self, "qsort", h)
+  end
+
+  def def_mod_func(meth, n_arg, tmpl=nil, opts={})
+    h = {:meth => meth, :n_arg => n_arg}
+    h.merge!(opts)
+    tmpl ||= meth
+    ModuleFunction.new(self, tmpl, h)
+  end
+
+  def math(meth, n=1, tmpl=nil)
+    h = {:mod_var => 'mTM'}
+    if tmpl.nil?
+      case n
+      when 1
+        tmpl = "unary_s"
+      when 2
+        tmpl = "binary_s"
+      when 3
+        tmpl = "ternary_s"
+      else
+        raise "invalid n=#{n}"
+      end
+    end
+    def_mod_func(meth, n, tmpl, h)
+  end
+
+  def store_numeric
+    StoreNum.new(self,"store_numeric")
+  end
+
+  def store_array
+    StoreArray.new(self,"store_array")
+  end
+
+  def cast_array
+    CastArray.new(self,"cast_array")
+  end
+
+  def store_from(cname,dtype,macro)
+    Store.new(self,"store_from",cname.downcase,dtype,"cumo_c"+cname,macro)
+  end
+
+  def store_bit(cname)
+    Store.new(self,"store_bit",cname.downcase,nil,"cumo_c"+cname,nil)
+  end
+
+  def store
+    Function.new(self,"store","store")
+  end
+
+  def find_method(meth)
+    Function::DEFS.find{|x| x.kind_of?(Function) and meth == x.meth }
+  end
+
+  def find_tmpl(meth)
+    Function::DEFS.find{|x| x.kind_of?(Function) and meth == x.tmpl }
+  end
+
+  def cast_func
+    "cumo_#{tp}_s_cast"
+  end
+end
+
+# ----------------------------------------------------------------------
+
+class DataType < ErbPP
+  include DefMethod
+
+  def initialize(erb_path, type_file)
+    super(nil, erb_path)
+    @class_alias = []
+    @upcast = []
+    @mod_var = "cT"
+    load_type(type_file) if type_file
+    dirs = template_dir || ["tmpl"]
+    @tmpl_dirs = dirs.map{|d| File.join(File.dirname(erb_path),d)}
+  end
+
+  attr_reader :tmpl_dirs
+
+  def load_type(file)
+    eval File.read(file)
+  end
+
+  attrs = %w[
+    class_name
+    ctype
+    template_dir
+    blas_char
+    complex_class_name
+    complex_type
+    real_class_name
+    real_ctype
+    has_math
+    is_bit
+    is_int
+    is_unsigned
+    is_float
+    is_real
+    is_complex
+    is_object
+    is_comparable
+    is_double_precision
+    mod_var
+  ]
+  define_attrs attrs
+
+  def type_name
+    @type_name ||= class_name.downcase
+  end
+  alias tp type_name
+
+  def type_var
+    @type_var ||= "cumo_c"+class_name
+  end
+
+  def math_var
+    @math_var ||= "cumo_m"+class_name+"Math"
+  end
+
+  def real_class_name(arg=nil)
+    if arg.nil?
+      @real_class_name ||= class_name
+    else
+      @real_class_name = arg
+    end
+  end
+
+  def real_ctype(arg=nil)
+    if arg.nil?
+      @real_ctype ||= ctype
+    else
+      @real_ctype = arg
+    end
+  end
+
+  def real_type_var
+    @real_type_var ||= "cumo_c"+real_class_name
+  end
+
+  def real_type_name
+    @real_type_name ||= real_class_name.downcase
+  end
+
+  def class_alias(*args)
+    @class_alias.concat(args)
+  end
+
+  def upcast(c=nil,t=nil)
+    if c
+      if t
+        t = "cumo_c#{t}"
+      else
+        t = "cT"
+      end
+      @upcast << "rb_hash_aset(hCast, cumo_c#{c}, #{t});"
+    else
+      @upcast
+    end
+  end
+
+  def upcast_rb(c,t=nil)
+    if t
+      t = "cumo_c#{t}"
+    else
+      t = "cT"
+    end
+    if c=="Integer"
+      @upcast << "#ifdef RUBY_INTEGER_UNIFICATION"
+      @upcast << "rb_hash_aset(hCast, rb_cInteger, #{t});"
+      @upcast << "#else"
+      @upcast << "rb_hash_aset(hCast, rb_cFixnum, #{t});"
+      @upcast << "rb_hash_aset(hCast, rb_cBignum, #{t});"
+      @upcast << "#endif"
+    else
+      @upcast << "rb_hash_aset(hCast, rb_c#{c}, #{t});"
+    end
+  end
+end
+
+
+# ----------------------------------------------------------------------
+
+
+class Allocate < Function
+  def definition
+    "rb_define_alloc_func(#{mod_var}, #{c_func});"
+  end
+end
+
+# ----------------------------------------------------------------------
+
+class Store < Function
+  DEFS = []
+
+  def initialize(parent,tmpl,tpname,dtype,tpclass,macro)
+    super(parent,tmpl)
+    @tpname=tpname
+    @dtype=dtype
+    @tpclass=tpclass
+    @macro=macro
+    DEFS.push(self)
+  end
+  attr_reader :tmpl, :tpname, :dtype, :tpclass, :macro
+
+  def c_func
+    "cumo_#{tp}_store_#{tpname}"
+  end
+
+  def c_iter
+    "iter_#{tp}_store_#{tpname}"
+  end
+
+  def definition
+    nil
+  end
+
+  def condition(klass)
+    "#{klass}==#{tpclass}"
+  end
+
+  def extract_data(ptr,pos,x)
+    case tpname
+    when "bit"
+      "{BIT_DIGIT b; LOAD_BIT(#{ptr},#{pos},b); x = m_from_real(b);}"
+    when "robject"
+      "#{x} = m_num_to_data(*(#{dtype}*)(#{ptr}+#{pos}))"
+    when /complex/
+      "{#{dtype} *p = (#{dtype}*)(#{ptr}+#{pos}); #{x} = c_new(REAL(*p),IMAG(*p));}"
+    else
+      "#{x} = m_from_real(*(#{dtype}*)(#{ptr}+#{pos}))"
+    end
+  end
+
+  def self.definitions
+    a = []
+    DEFS.each do |x|
+      if x.condition("")
+        if x.tpname == x.parents[0].class_name.downcase
+          a.unshift(x)
+        else
+          a.push(x)
+        end
+      end
+    end
+    a
+  end
+end
+
+class StoreNum < Store
+  def initialize(parent,tmpl)
+    super(parent,tmpl,"numeric",nil,nil,nil)
+  end
+
+  def condition(klass)
+    "IS_INTEGER_CLASS(#{klass}) || #{klass}==rb_cFloat || #{klass}==rb_cComplex"
+  end
+end
+
+class StoreArray < Store
+  def initialize(parent,tmpl)
+    super(parent,tmpl,"array",nil,nil,nil)
+  end
+
+  def c_func
+    "cumo_#{tp}_#{tmpl}"
+  end
+
+  def condition(klass)
+    "#{klass}==rb_cArray"
+  end
+end
+
+class CastArray < StoreArray
+  def condition(klass)
+    nil
+  end
+
+  def c_func
+    "cumo_#{tp}_cast_#{tpname}"
+  end
+
+  def c_iter
+    "iter_#{tp}_cast_#{tpname}"
+  end
+end