BOAST 0.9994 → 0.9995

data/lib/BOAST/Operators.rb

@@ -1,6 +1,10 @@
 module BOAST
 
   class Operator
+    def Operator.inspect
+      return "#{self.name}"
+    end
+
     def Operator.get_vector_name(type)
       case BOAST::get_architecture
       when X86
@@ -401,6 +405,7 @@ module BOAST
 
   class Ternary
     include BOAST::Arithmetic
+    include BOAST::Inspectable
 
     def self.parens(*args,&block)
       return self::new(*args,&block)
@@ -417,24 +422,22 @@ module BOAST
     end
 
     def to_s
-      self.to_str
-    end
-
-    def to_str
       raise "Ternary operator unsupported in FORTRAN!" if BOAST::get_lang == BOAST::FORTRAN
-      return self.to_str_c if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
+      return self.to_s_c if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
     end
-    def to_str_c
+
+    def to_s_c
       s = ""
       s += "(#{@operand1} ? #{@operand2} : #{@operand3})"
     end
-    def print(final=true)
+
+    def print
       s=""
-      s += " "*BOAST::get_indent_level if final
-      s += self.to_str
-      s += ";" if final and [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
-      BOAST::get_output.puts s if final
-      return s
+      s += BOAST::indent
+      s += self.to_s
+      s += ";" if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
+      BOAST::get_output.puts s
+      return self
     end
   end
 end

data/lib/BOAST/Parens.rb

@@ -23,9 +23,9 @@ end
 
 module BOAST
 
-  def BOAST.register_funccall(name)
+  def self.register_funccall(name)
     s =<<EOF
-    def BOAST.#{name}(*args)
+    def self.#{name}(*args)
       return BOAST::FuncCall("#{name}", *args)
     end
 EOF

data/lib/BOAST/Pragma.rb

@@ -1,9 +1,8 @@
 module BOAST
 
   class Pragma
-    def self.parens(*args,&block)
-      return self::new(*args,&block)
-    end
+    include BOAST::Inspectable
+    extend BOAST::Functor
 
     attr_reader :name
     attr_reader :options
@@ -14,10 +13,6 @@ module BOAST
     end
 
     def to_s
-      self.to_str
-    end
-
-    def to_str
       s = ""
       if BOAST::get_lang == FORTRAN then
         s += "$!"
@@ -30,11 +25,11 @@ module BOAST
       return s
     end
 
-    def print(final = true)
+    def print
       s=""
-      s += self.to_str
-      BOAST::get_output.puts s if final
-      return s
+      s += self.to_s
+      BOAST::get_output.puts s
+      return self
     end
   end
 

data/lib/BOAST/Procedure.rb

@@ -1,14 +1,15 @@
 module BOAST
+
   class Procedure
-    def self.parens(*args,&block)
-      return self::new(*args,&block)
-    end
+    include BOAST::Inspectable
+    extend BOAST::Functor
 
     attr_reader :name
     attr_reader :parameters
     attr_reader :constants
     attr_reader :properties
     attr_reader :headers
+
     def initialize(name, parameters=[], constants=[], properties={}, &block)
       @name = name
       @parameters = parameters
@@ -19,7 +20,7 @@ module BOAST
       @headers = [] if not @headers
     end
 
-    def header(lang=C,final=true)
+    def boast_header_s( lang=C )
       s = ""
       headers.each { |h|
         s += "#include <#{h}>\n"
@@ -43,10 +44,10 @@ module BOAST
       end
       s += "#{@name}#{trailer}("
       if parameters.first then
-        s += parameters.first.header(lang,false)
+        s += parameters.first.boast_header(lang)
         parameters[1..-1].each { |p|
           s += ", "
-          s += p.header(lang,false)
+          s += p.boast_header(lang)
         }
       end
       if lang == CUDA then
@@ -54,11 +55,16 @@ module BOAST
         s += "size_t *block_number, size_t *block_size"
       end
       s += ")"
-      s += ";\n" if final
-      BOAST::get_output.print s if final
       return s
     end
 
+    def boast_header(lang=C)
+      s = boast_header_s(lang)
+      s += ";\n"
+      BOAST::get_output.print s
+      return self
+    end
+
     def call(*parameters)
       prefix = ""
       prefix += "call " if BOAST::get_lang==FORTRAN
@@ -66,23 +72,22 @@ module BOAST
       f.prefix = prefix
       return f
     end
-    def decl(final=true)
-      return self.decl_fortran(final) if BOAST::get_lang==FORTRAN
-      return self.decl_c(final) if [C, CL, CUDA].include?( BOAST::get_lang )
-    end
-    def close(final=true)
-      return self.close_fortran(final) if BOAST::get_lang==FORTRAN
-      return self.close_c(final) if [C, CL, CUDA].include?( BOAST::get_lang )
+
+    def close
+      return self.close_fortran if BOAST::get_lang==FORTRAN
+      return self.close_c if [C, CL, CUDA].include?( BOAST::get_lang )
     end
-    def close_c(final=true)
+
+    def close_c
       BOAST::decrement_indent_level
       s = ""
       s += "  return #{@properties[:return]};\n" if @properties[:return]
       s += "}"
-      BOAST::get_output.puts s if final
-      return s
+      BOAST::get_output.puts s
+      return self
     end
-    def close_fortran(final=true)
+
+    def close_fortran
       BOAST::decrement_indent_level
       s = ""
       if @properties[:return] then
@@ -91,23 +96,30 @@ module BOAST
       else
         s += "END SUBROUTINE #{@name}"
       end
-      BOAST::get_output.puts s if final
-      return s
+      BOAST::get_output.puts s
+      return self
     end
 
-    def print(final=true)
-      s = self.decl
+    def print
+      self.open
       if @block then
         @block.call
-        s += self.close
+        self.close
       end
-      return s
+      return self
+    end
+
+    def decl
+      return self.decl_fortran if BOAST::get_lang==FORTRAN
+      return self.decl_c if [C, CL, CUDA].include?( BOAST::get_lang )
+    end
+
+    def decl_fortran
+      raise "Interfaces are not implemented in FORTRAN yet!"
     end
 
-    def decl_c(final=true)
+    def decl_c_s
       s = ""
-#      s += self.header(BOAST::get_lang,false)
-#      s += ";\n"
       if BOAST::get_lang == CL then
         if @properties[:local] then
           s += "static "
@@ -139,22 +151,37 @@ module BOAST
       end
       s += "#{@name}("
       if parameters.first then
-        s += parameters.first.decl(false, @properties[:local])
+        s += parameters.first.decl_c_s(@properties[:local])
         parameters[1..-1].each { |p|
-          s += ", "+p.decl(false, @properties[:local])
+          s += ", "+p.decl_c_s(@properties[:local])
         }
       end
-      s += "){\n"
+      s += ")"
+      return s
+    end
+
+    def decl_c
+      s = decl_c_s + ";"
+      BOAST::get_output.puts s
+      return self
+    end
+
+    def open
+      return self.open_fortran if BOAST::get_lang==FORTRAN
+      return self.open_c if [C, CL, CUDA].include?( BOAST::get_lang )
+    end
+
+    def open_c
+      s = decl_c_s + "{"
+      BOAST::get_output.puts s
       BOAST::increment_indent_level
       constants.each { |c|
-        s += " "*BOAST::get_indent_level
-        s += c.decl(false)
-        s += ";\n"
+        c.decl
       }
-      BOAST::get_output.print s if final
-      return s
+      return self
     end
-    def decl_fortran(final=true)
+
+    def open_fortran
       s = ""
       if @properties[:return] then
         s += "#{@properties[:return].type.decl} FUNCTION "
@@ -162,27 +189,18 @@ module BOAST
         s += "SUBROUTINE "
       end
       s += "#{@name}("
-      if parameters.first then
-        s += parameters.first
-        parameters[1..-1].each { |p|
-          s += ", "+p
-        }
-      end
+      s += parameters.join(", ")
       s += ")\n"
       BOAST::increment_indent_level
-      s += " "*BOAST::get_indent_level + "integer, parameter :: wp=kind(1.0d0)\n"
+      s += BOAST::indent + "integer, parameter :: wp=kind(1.0d0)"
+      BOAST::get_output.puts s
       constants.each { |c|
-        s += " "*BOAST::get_indent_level
-        s += c.decl(false)
-        s += "\n"
+        c.decl
       }
       parameters.each { |p|
-        s += " "*BOAST::get_indent_level
-        s += p.decl(false)
-        s += "\n"
+        p.decl
       }
-      BOAST::get_output.print s if final
-      return s
+      return self
     end
   end
 

data/lib/BOAST/Variable.rb

@@ -1,13 +1,13 @@
 module BOAST
 
   class Dimension
-    def self.parens(*args,&block)
-      return self::new(*args,&block)
-    end
+    include BOAST::Inspectable
+    extend BOAST::Functor
 
     attr_reader :val1
     attr_reader :val2
     attr_reader :size
+
     def initialize(v1=nil,v2=nil)
       @size = nil
       @val1 = nil
@@ -22,7 +22,7 @@ module BOAST
       end
     end
 
-    def to_str
+    def to_s
       s = ""
       if @val2 then
         if BOAST::get_lang == BOAST::FORTRAN then
@@ -39,24 +39,22 @@ module BOAST
       end
       return s
     end
-    def to_s
-      self.to_str
-    end
   end
 
   class ConstArray < Array
+    include BOAST::Inspectable
+
     def initialize(array,type = nil)
       super(array)
       @type = type::new if type
     end
+
     def to_s
-      self.to_str
-    end
-    def to_str
-      return self.to_str_fortran if BOAST::get_lang == BOAST::FORTRAN
-      return self.to_str_c if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
+      return self.to_s_fortran if BOAST::get_lang == BOAST::FORTRAN
+      return self.to_s_c if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
     end
-    def to_str_fortran
+
+    def to_s_fortran
       s = ""
       return s if self.first.nil?
       s += "(/ &\n"
@@ -68,7 +66,8 @@ module BOAST
       }
       s += " /)"
     end
-    def to_str_c
+
+    def to_s_c
       s = ""
       return s if self.first.nil?
       s += "{\n"
@@ -82,6 +81,8 @@ module BOAST
 
   class Variable
     include BOAST::Arithmetic
+    include BOAST::Inspectable
+    extend BOAST::Functor
 
     alias_method :orig_method_missing, :method_missing
 
@@ -92,10 +93,6 @@ module BOAST
       return self.orig_method_missing(m, *a, &b)
     end
 
-    def self.parens(*args,&block)
-      return self::new(*args,&block)
-    end
-
     attr_reader :name
     attr_accessor :direction
     attr_accessor :constant
@@ -130,17 +127,18 @@ module BOAST
         @sampler = nil
       end
       @type = type::new(hash)
-      @hash = hash
+      @options = hash
       if (@direction == :out or @direction == :inout) and not @dimension then
         @scalar_output = true
       else
         @scalar_output = false
       end
+      @dimension = [@dimension].flatten if @dimension
     end
 
     def copy(name=nil,options={})
       name = @name if not name
-      h = @hash.clone
+      h = @options.clone
       options.each { |k,v|
         h[k] = v
       }
@@ -158,10 +156,6 @@ module BOAST
     end
   
     def to_s
-      self.to_str
-    end    
-
-    def to_str
       if @force_replace_constant or ( @replace_constant and @constant and BOAST::get_replace_constants and not @dimension ) then
         s = @constant.to_s 
         s += "_wp" if BOAST::get_lang == BOAST::FORTRAN and @type and @type.size == 8
@@ -200,10 +194,6 @@ module BOAST
       return Index::new(self,args)
     end
  
-    def indent
-       return " "*BOAST::get_indent_level
-    end
-
     def finalize
        s = ""
        s += ";" if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
@@ -211,12 +201,31 @@ module BOAST
        return s
     end
 
-    def decl_c(final=true, device=false)
-      return decl_texture(final) if @texture
+    def boast_header(lang=C)
+      return decl_texture_s if @texture
+      s = ""
+      s += "const " if @constant or @direction == :in
+      s += @type.decl
+      if @dimension then
+        s += " *"
+      end
+      if not @dimension and ( lang == BOAST::FORTRAN or @direction == :out or @direction == :inout ) then
+        s += " *"
+      end
+      s += " #{@name}"
+      return s
+    end
+
+    def decl
+      return self.decl_fortran if BOAST::get_lang == BOAST::FORTRAN
+      return self.decl_c if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
+    end
+
+    def decl_c_s(device = false)
+      return decl_texture_s if @texture
       s = ""
-      s += self.indent if final
       s += "const " if @constant or @direction == :in
-      s += "__global " if @direction and @dimension and not (@hash[:register] or @hash[:private] or @local) and BOAST::get_lang == BOAST::CL
+      s += "__global " if @direction and @dimension and not (@options[:register] or @options[:private] or @local) and BOAST::get_lang == BOAST::CL
       s += "__local " if @local and BOAST::get_lang == BOAST::CL
       s += "__shared__ " if @local and not device and BOAST::get_lang == BOAST::CUDA
       s += @type.decl
@@ -243,47 +252,10 @@ module BOAST
          s +="]"
       end 
       s += " = #{@constant}" if @constant
-      s += self.finalize if final
-      BOAST::get_output.print s if final
       return s
     end
 
-    def header(lang=C,final=true)
-      return decl_texture(final) if @texture
-      s = ""
-      s += self.indent if final
-      s += "const " if @constant or @direction == :in
-      s += "__global " if @direction and @dimension and BOAST::get_lang == BOAST::CL
-      s += "__local " if @local and BOAST::get_lang == BOAST::CL
-      s += "__shared__ " if @local and BOAST::get_lang == BOAST::CUDA
-      s += @type.decl
-      if(@dimension and not @constant and not @local) then
-        s += " *"
-      end
-      if not @dimension and ( lang == BOAST::FORTRAN or @direction == :out or @direction == :inout ) then
-        s += " *"
-      end
-      s += " #{@name}"
-      if(@dimension and @constant) then
-        s += "[]"
-      end
-      if(@dimension and @local) then
-         s +="["
-         s += @dimension.reverse.join("*")
-         s +="]"
-      end 
-      s += " = #{@constant}" if @constant
-      s += self.finalize if final
-      BOAST::get_output.print s if final
-      return s
-    end
-
-    def decl(final=true,device=false)
-      return self.decl_fortran(final) if BOAST::get_lang == BOAST::FORTRAN
-      return self.decl_c(final, device) if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
-    end
-
-    def decl_texture(final=true)
+    def decl_texture_s
       raise "Unsupported language #{BOAST::get_lang} for texture!" if not [BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
       raise "Write is unsupported for textures!" if not (@constant or @direction == :in)
       dim_number = 1
@@ -292,7 +264,6 @@ module BOAST
       end
       raise "Unsupported number of dimension: #{dim_number}!" if dim_number > 3
       s = ""
-      s += self.indent if final
       if BOAST::get_lang == BOAST::CL then
         s += "__read_only "
         if dim_number < 3 then
@@ -304,26 +275,32 @@ module BOAST
         s += "texture<#{@type.decl}, cudaTextureType#{dim_number}D, cudaReadModeElementType> "
       end
       s += @name
-      s += self.finalize if final
-      BOAST::get_output.print s if final
       return s
     end
 
+    def decl_c
+      s = ""
+      s += BOAST::indent
+      s += self.decl_c_s
+      s += self.finalize
+      BOAST::get_output.print s
+      return self
+    end
 
-    def decl_fortran(final=true)
+
+    def decl_fortran
       s = ""
-      s += self.indent if final
+      s += BOAST::indent
       s += @type.decl
       s += ", intent(#{@direction})" if @direction 
       s += ", parameter" if @constant
       if(@dimension) then
         s += ", dimension("
-        dim = @dimension[0].to_str
+        dim = @dimension[0].to_s
         if dim then
           s += dim
           @dimension[1..-1].each { |d|
-             s += ", "
-             s += d
+             s += ", #{d}"
           }
         else
           s += "*"
@@ -335,9 +312,9 @@ module BOAST
         s += " = #{@constant}"
         s += "_wp" if not @dimension and @type and @type.size == 8
       end
-      s += self.finalize if final
-      BOAST::get_output.print s if final
-      return s
+      s += self.finalize
+      BOAST::get_output.print s
+      return self
     end
 
   end

data/lib/BOAST/While.rb

@@ -1,65 +1,65 @@
 module BOAST
 
-  class While
-    def self.parens(*args,&block)
-      return self::new(*args,&block)
-    end
+  class While < BOAST::ControlStructure
+    include BOAST::Inspectable
+    extend BOAST::Functor
 
     attr_reader :condition
+
     def initialize(condition, &block)
       @condition = condition
       @block = block
     end
+
+    @@c_strings = {
+      :while => '"while (#{cond}) {"',
+      :end => '"}"'
+    }
+
+    @@f_strings = {
+      :while => '"do while (#{cond})"',
+      :end => '"end do"'
+    }
+
+    @@strings = {
+      BOAST::C => @@c_strings,
+      BOAST::CL => @@c_strings,
+      BOAST::CUDA => @@c_strings,
+      BOAST::FORTRAN => @@f_strings
+    }
+
+    eval token_string_generator( * %w{while cond} )
+    eval token_string_generator( * %w{end} )
+
     def to_s
-      self.to_str
-    end
-    def to_str
-      return self.to_str_fortran if BOAST::get_lang == FORTRAN
-      return self.to_str_c if [C, CL, CUDA].include?( BOAST::get_lang )
-    end
-    def to_str_fortran
-      s = ""
-      s += "do while( #{@condition} )"
-      return s
+      return while_string(@condition)
     end
-    def to_str_c
-      s = ""
-      s += "while(#{@condition}){"
-      return s
+
+    def open
+      s=""
+      s += BOAST::indent
+      s += self.to_s
+      BOAST::get_output.puts s
+      BOAST::increment_indent_level
+      return self
     end
+
     def print(*args)
-      final = true
-      s=""
-      s += " "*BOAST::get_indent_level if final
-      s += self.to_str
-      BOAST::increment_indent_level      
-      BOAST::get_output.puts s if final
+      self.open
       if @block then
-        s += "\n"
         @block.call(*args)
-        s += self.close
+        self.close
       end
-      return s
+      return self
     end
-    def close(final=true)
-      return self.close_fortran(final) if BOAST::get_lang == FORTRAN
-      return self.close_c(final) if [C, CL, CUDA].include?( BOAST::get_lang )
-    end
-    def close_c(final=true)
-      s = ""
+
+    def close
       BOAST::decrement_indent_level      
-      s += " "*BOAST::get_indent_level if final
-      s += "}"
-      BOAST::get_output.puts s if final
-      return s
-    end
-    def close_fortran(final=true)
       s = ""
-      BOAST::decrement_indent_level      
-      s += " "*BOAST::get_indent_level if final
-      s += "end do"
-      BOAST::get_output.puts s if final
-      return s
+      s += BOAST::indent
+      s += end_string
+      BOAST::get_output.puts s
+      return self
     end
 
   end