BOAST 0.9994 → 0.9995

data/lib/BOAST/DataTypes.rb

@@ -1,9 +1,7 @@
 module BOAST
 
   class Sizet
-    def self.parens(*args,&block)
-      return Variable::new(args[0], self, *args[1..-1], &block)
-    end
+    extend BOAST::VarFunctor
 
     attr_reader :signed
     attr_reader :size
@@ -39,9 +37,7 @@ module BOAST
   end
  
   class Real
-    def self.parens(*args,&block)
-      return Variable::new(args[0], self, *args[1..-1], &block)
-    end
+    extend BOAST::VarFunctor
 
     attr_reader :size
     attr_reader :signed
@@ -112,9 +108,7 @@ module BOAST
   end
 
   class Int
-    def self.parens(*args,&block)
-      return Variable::new(args[0], self, *args[1..-1], &block)
-    end
+    extend BOAST::VarFunctor
 
     attr_reader :size
     attr_reader :signed
@@ -234,10 +228,9 @@ module BOAST
   end
 
   class CStruct
+    extend BOAST::VarFunctor
+
     attr_reader :name, :members, :members_array
-    def self.parens(*args,&block)
-      return Variable::new(args[0], self, *args[1..-1], &block)
-    end
 
     def initialize(hash={})
       @name = hash[:type_name]
@@ -250,11 +243,19 @@ module BOAST
       }
     end
 
-    def decl
+    def decl_c
       return "struct #{@name}" if [C, CL, CUDA].include?( BOAST::get_lang )
+    end
+
+    def decl_fortran
       return "TYPE(#{@name})" if BOAST::get_lang == FORTRAN
     end
 
+    def decl
+      return self.decl_c if [C, CL, CUDA].include?( BOAST::get_lang )
+      return self.decl_fortran if BOAST::get_lang == FORTRAN
+    end
+
     def finalize
        s = ""
        s += ";" if [C, CL, CUDA].include?( BOAST::get_lang )
@@ -262,44 +263,37 @@ module BOAST
        return s
     end
 
-    def indent
-       return " "*BOAST::get_indent_level
+    def define
+      return define_c if [C, CL, CUDA].include?( BOAST::get_lang )
+      return define_fortran if BOAST::get_lang == FORTRAN
     end
 
-    def header
-      return header_c if [C, CL, CUDA].include?( BOAST::get_lang )
-      return header_fortran if BOAST::get_lang == FORTRAN
-      raise "Unsupported language!"
-    end
-
-    def header_c(final = true)
-      s = ""
-      s += self.indent if final
-      s += self.decl + " {\n"
+    def define_c
+      s = BOAST::indent
+      s += self.decl_c + " {"
+      BOAST::get_output.puts s
       @members_array.each { |value|
-         s+= self.indent if final
-         s+= " "*BOAST::get_indent_increment + value.decl(false)+";\n"
+         value.decl
       }
-      s += self.indent if final
+      s = BOAST::indent
       s += "}"
-      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
     
-    def header_fortran(final = true)
-      s = ""
-      s += self.indent if final
+    def define_fortran
+      s = BOAST::indent
       s += "TYPE :: #{@name}\n"
-      members_array.each { |value|
-         s+= self.indent if final
-         s+= " "*BOAST::get_indent_increment + value.decl(false)+"\n"
+      BOAST::get_output.puts s
+      @members_array.each { |value|
+         value.decl
       }
-      s += self.indent if final
+      s = BOAST::indent
       s += "END TYPE #{@name}"
-      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/Expression.rb

@@ -1,14 +1,13 @@
 module BOAST
-  def BOAST::Return(value)
+
+  def self.Return(value)
     return Expression("return",nil, value)
   end
 
   class Expression
     include BOAST::Arithmetic
-
-    def self.parens(*args,&block)
-      return self::new(*args,&block)
-    end
+    include BOAST::Inspectable
+    extend BOAST::Functor
 
     attr_reader :operator
     attr_reader :operand1
@@ -18,11 +17,8 @@ module BOAST
       @operand1 = operand1
       @operand2 = operand2
     end
-    def to_s
-      self.to_str
-    end
 
-    def Expression.to_str_base(op1, op2, oper, return_type = nil)
+    def Expression.to_s_base(op1, op2, oper, return_type = nil)
       return oper.to_s(op1, op2, return_type) if not oper.kind_of?(String)
       s = ""
       if op1 then
@@ -48,13 +44,13 @@ module BOAST
       op2 = @operand2.to_var if @operand2.respond_to?(:to_var)
       if op1 and op2 then
         r_t, oper = BOAST::transition(op1, op2, @operator)
-        res_exp = BOAST::Expression::to_str_base(op1, op2, oper, r_t)
+        res_exp = BOAST::Expression::to_s_base(op1, op2, oper, r_t)
         return r_t.copy(res_exp, :const => nil, :constant => nil, :direction => nil, :dir => nil)
       elsif op2
-        res_exp = BOAST::Expression::to_str_base(@operand1, op2, @operator)
+        res_exp = BOAST::Expression::to_s_base(@operand1, op2, @operator)
         return op2.copy(res_exp, :const => nil, :constant => nil, :direction => nil, :dir => nil)
       elsif op1
-        res_exp = BOAST::Expression::to_str_base(op1, @operand2, @operator)
+        res_exp = BOAST::Expression::to_s_base(op1, @operand2, @operator)
         return op1.copy(res_exp, :const => nil, :constant => nil, :direction => nil, :dir => nil)
       else
         STDERR.puts "#{@operand1} #{@operand2}"
@@ -62,7 +58,7 @@ module BOAST
       end
     end
  
-    def to_str
+    def to_s
       op1 = nil
       op1 = @operand1.to_var if @operand1.respond_to?(:to_var)
       op2 = nil
@@ -77,16 +73,16 @@ module BOAST
       op1 = @operand1 if op1.nil?
       op2 = @operand2 if op2.nil?
 
-      return BOAST::Expression::to_str_base(op1, op2, oper, r_t)
+      return BOAST::Expression::to_s_base(op1, op2, oper, r_t)
     end
 
-    def print(final=true)
+    def print
       s=""
-      s += " "*BOAST::get_indent_level if final
-      s += self.to_str
-      s += ";" if final and [C, CL, CUDA].include?( BOAST::get_lang ) 
-      BOAST::get_output.puts s if final
-      return s
+      s += BOAST::indent
+      s += self.to_s
+      s += ";" if [C, CL, CUDA].include?( BOAST::get_lang ) 
+      BOAST::get_output.puts s
+      return self
     end
   end
 

data/lib/BOAST/For.rb

@@ -1,14 +1,14 @@
 module BOAST
-  class For
+
+  class For < ControlStructure
+    include BOAST::Inspectable
+    extend BOAST::Functor
+
     attr_reader :iterator
     attr_reader :begin
     attr_reader :end
     attr_reader :step
 
-    def self.parens(*args,&block)
-      return self::new(*args,&block)
-    end
-
     def initialize(i, b, e, s=1, &block)
       @iterator = i
       @begin = b
@@ -16,22 +16,29 @@ module BOAST
       @step = s
       @block = block
     end
+
+    @@c_strings = {
+      :for => '"for (#{i} = #{b}; #{i} <= #{e}; #{i} += #{s}) {"',
+      :end => '"}"'
+    }
+
+    @@f_strings = {
+      :for => '"do #{i} = #{b}, #{e}, #{s}"',
+      :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{for i b e s})
+    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 #{@iterator}=#{@begin}, #{@end}"
-      s += ", #{@step}" if 1 != @step
-      return s
-    end
-    def to_str_c
-      s = ""
-      s += "for(#{@iterator}=#{@begin}; #{@iterator}<=#{@end}; #{@iterator}+=#{@step}){"
+      s = for_string(@iterator, @begin, @end, @step)
       return s
     end
 
@@ -78,41 +85,33 @@ module BOAST
       @iterator.constant = nil
     end
 
-    def print(*args)
-      final = true
+    def open
       s=""
-      s += " "*BOAST::get_indent_level if final
-      s += self.to_str
+      s += BOAST::indent
+      s += self.to_s
+      BOAST::get_output.puts s
       BOAST::increment_indent_level      
-      BOAST::get_output.puts s if final
+      return self
+    end 
+
+    def print(*args)
+      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 += "enddo"
-      BOAST::get_output.puts s if final
-      return s
+      s += BOAST::indent
+      s += end_string
+      BOAST::get_output.puts s
+      return self
     end
+
   end
 
 end

data/lib/BOAST/FuncCall.rb

@@ -2,12 +2,11 @@ module BOAST
 
   class FuncCall
     include BOAST::Arithmetic
+    include BOAST::Inspectable
+    extend BOAST::Functor
 
     @return_type
     @options
-    def self.parens(*args,&block)
-      return self::new(*args,&block)
-    end
 
     attr_reader :func_name
     attr_reader :args
@@ -36,30 +35,29 @@ module BOAST
     end
       
     def to_s
-      self.to_str
+      return self.to_s_fortran if BOAST::get_lang == FORTRAN
+      return self.to_s_c if [C, CL, CUDA].include?( BOAST::get_lang )
     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
+    def to_s_fortran
       s = ""
       s += @prefix if @prefix
       s += "#{func_name}(#{@args.join(", ")})"
     end
-    def to_str_c
+
+    def to_s_c
       s = ""
       s += @prefix if @prefix
       s += "#{func_name}(#{@args.join(", ")})"
     end
-    def print(final=true)
+
+    def print
       s=""
-      s += " "*BOAST::get_indent_level if final
-      s += self.to_str
-      s += ";" if final and [C, CL, CUDA].include?( BOAST::get_lang )
-      BOAST::get_output.puts s if final
-      return s
+      s += BOAST::indent
+      s += self.to_s
+      s += ";" if [C, CL, CUDA].include?( BOAST::get_lang )
+      BOAST::get_output.puts s
+      return self
     end
   end
 

data/lib/BOAST/Functors.rb

@@ -0,0 +1,19 @@
+module BOAST
+
+  module Functor
+
+    def parens(*args,&block)
+      return self::new(*args,&block)
+    end
+
+  end
+
+  module VarFunctor
+
+    def parens(*args,&block)
+      return Variable::new(args[0], self, *args[1..-1], &block)
+    end
+
+  end
+
+end

data/lib/BOAST/If.rb

@@ -1,11 +1,11 @@
 module BOAST
 
-  class If
-    def self.parens(*args,&block)
-      return self::new(*args,&block)
-    end
+  class If < BOAST::ControlStructure
+    include BOAST::Inspectable
+    extend BOAST::Functor
 
     attr_reader :conditions
+
     def initialize(*conditions, &block)
       @conditions = []
       @blocks = []
@@ -27,83 +27,84 @@ module BOAST
         @blocks.push(conditions.last)
       end
     end
-    def to_s(*args)
-      self.to_str(*args)
-    end
-    def to_str(condition, first= true)
-      return self.to_str_fortran(condition, first) if BOAST::get_lang == FORTRAN
-      return self.to_str_c(condition, first) if [C, CL, CUDA].include?( BOAST::get_lang )
-    end
-    def to_str_fortran(condition, first)
-      s = ""
-      if first then
-        s += "if ( #{condition} ) then"
-      else
-        if condition then
-          s += "else if ( #{condition} ) then"
-        else
-          s += "else"
-        end
-      end
-      return s
-    end
-    def to_str_c(condition, first)
+
+    @@c_strings = {
+      :if => '"if (#{cond}) {"',
+      :else_if => '"} else if (#{cond}) {"',
+      :else => '"} else {"',
+      :end => '"}"'
+    }
+
+    @@f_strings = {
+      :if => '"if (#{cond}) then"',
+      :elsif => '"else if (#{cond}) then"',
+      :else => '"else"',
+      :end => '"end if"'
+    }
+
+    @@strings = {
+      BOAST::C => @@c_strings,
+      BOAST::CL => @@c_strings,
+      BOAST::CUDA => @@c_strings,
+      BOAST::FORTRAN => @@f_strings
+    }
+
+    eval token_string_generator( * %w{if cond} )
+    eval token_string_generator( * %w{elsif cond} )
+    eval token_string_generator( * %w{else} )
+    eval token_string_generator( * %w{end} )
+
+    def to_s(condition_number = 0)
       s = ""
-      if first then
-        s += "if(#{condition}){"
+      if condition_number == 0 then
+        s += if_string(@conditions.first)
       else
-        if condition then
-          s += "} else if(#{condition}){"
+        if @conditions[condition_number] then
+          s += elsif_string(@conditions[condition_number])
         else
-          s += "} else {"
+          s += else_string
         end
       end
       return s
     end
-    def print(*args)
+
+    def open
       s=""
-      s += " "*BOAST::get_indent_level
-      s += self.to_str(@conditions.first)
-      BOAST::increment_indent_level      
+      s += BOAST::indent
+      s += self.to_s
       BOAST::get_output.puts s
+      BOAST::increment_indent_level
+      return self
+    end
+
+    def print(*args)
       if @blocks.size > 0 then
-        if @blocks[0] then
-          @blocks[0].call(*args)
-        end
-        @blocks[1..-1].each_index { |indx|
-          BOAST::decrement_indent_level      
+        BOAST::increment_indent_level
+        @blocks.each_index { |indx|
+          BOAST::decrement_indent_level
           s=""
-          s += " "*BOAST::get_indent_level 
-          s += self.to_str(@conditions[1..-1][indx],false)
-          BOAST::increment_indent_level
+          s += BOAST::indent
+          s += self.to_s(indx)
           BOAST::get_output.puts s
-          @blocks[1..-1][indx].call(*args)
+          BOAST::increment_indent_level
+          @blocks[indx].call(*args)
         }
         self.close
+      else
+        self.open
       end
       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 = ""
-      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)
+
+    def close
+      BOAST::decrement_indent_level
       s = ""
-      BOAST::decrement_indent_level      
-      s += " "*BOAST::get_indent_level if final
-      s += "end if"
-      BOAST::get_output.puts s if final
-      return s
+      s += BOAST::indent
+      s += end_string
+      BOAST::get_output.puts s
+      return self
     end
 
   end
 
-end 
+end

data/lib/BOAST/Index.rb

@@ -1,5 +1,6 @@
 module BOAST
   class Index < Expression
+    include BOAST::Inspectable
     attr_reader :source
     attr_reader :indexes
     def initialize(source, indexes)
@@ -13,18 +14,17 @@ module BOAST
     end
 
     def to_s
-      self.to_str
+      return self.to_s_fortran if BOAST::get_lang == FORTRAN
+      return self.to_s_c if [C, CL, CUDA].include?( BOAST::get_lang )
     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
+
+    def to_s_fortran
       s = ""
       s += "#{@source}(#{@indexes.join(", ")})"
       return s
     end
-    def to_str_texture
+
+    def to_s_texture
       raise "Unsupported language #{BOAST::get_lang} for texture!" if not [CL, CUDA].include?( BOAST::get_lang )
       raise "Write is unsupported for textures!" if not ( @source.constant or @source.direction == :in )
       dim_number = 1
@@ -69,8 +69,9 @@ module BOAST
       end
       return s
     end
-    def to_str_c
-      return to_str_texture if @source.texture
+
+    def to_s_c
+      return to_s_texture if @source.texture
       dim = @source.dimension.first
       if dim.val2 then
         start = dim.val1
@@ -110,14 +111,16 @@ module BOAST
       s = "#{@source}[" + sub + "]"
       return s
     end
-    def print(final=true)
+
+    def print
       s=""
-      s += " "*BOAST::get_indent_level if final
-      s += self.to_str
-      s += ";" if final and [C, CL, CUDA].include?( BOAST::get_lang )
-      BOAST::get_output.puts s if final
-      return s
+      s += BOAST::indent
+      s += self.to_s
+      s += ";" if [C, CL, CUDA].include?( BOAST::get_lang )
+      BOAST::get_output.puts s
+      return self
     end
+
   end
 
 end

data/lib/BOAST/Inspectable.rb

@@ -0,0 +1,28 @@
+module BOAST
+
+  @@inspect = false
+
+  def self.inspect?
+    return @@inspect
+  end
+
+  def self.inspect=(val)
+    @@inspect = val
+  end
+
+  module Inspectable
+
+    def inspect
+      if BOAST::inspect? then
+        variables = self.instance_variables.map{ |v|
+          instance_variable_get(v) ? "#{v}=#{instance_variable_get(v).inspect}" : nil
+        }.reject{ |v| v.nil? }.join(", ")
+        "#<#{self.class}:#{(self.object_id<<1).to_s(16)}#{variables == "" ? "" : " #{variables}" }>" 
+      else
+        self.to_s
+      end
+    end
+
+  end
+
+end