BOAST 0.9995 → 0.9996

data/lib/BOAST/Functors.rb

@@ -1,17 +1,42 @@
 module BOAST
+  
+  module_function
+  def functorize(klass)
+    name = klass.name.split('::').last
+    s = <<EOF
+  def #{name}(*args,&block)
+     #{name}::new(*args,&block)
+  end
+
+  module_function :#{name}
+EOF
+    eval s
+  end
+
+  def var_functorize(klass)
+    name = klass.name.split('::').last
+    s = <<EOF
+  def #{name}(*args,&block)
+     Variable::new(args[0],#{name},*args[1..-1], &block)
+  end
+
+  module_function :#{name}
+EOF
+    eval s
+  end
 
   module Functor
 
-    def parens(*args,&block)
-      return self::new(*args,&block)
+    def self.extended(mod)
+      BOAST::functorize(mod)
     end
 
   end
 
   module VarFunctor
 
-    def parens(*args,&block)
-      return Variable::new(args[0], self, *args[1..-1], &block)
+    def self.extended(mod)
+      BOAST::var_functorize(mod)
     end
 
   end

data/lib/BOAST/If.rb

@@ -1,8 +1,6 @@
 module BOAST
 
-  class If < BOAST::ControlStructure
-    include BOAST::Inspectable
-    extend BOAST::Functor
+  class If < ControlStructure
 
     attr_reader :conditions
 
@@ -43,10 +41,10 @@ module BOAST
     }
 
     @@strings = {
-      BOAST::C => @@c_strings,
-      BOAST::CL => @@c_strings,
-      BOAST::CUDA => @@c_strings,
-      BOAST::FORTRAN => @@f_strings
+      C => @@c_strings,
+      CL => @@c_strings,
+      CUDA => @@c_strings,
+      FORTRAN => @@f_strings
     }
 
     eval token_string_generator( * %w{if cond} )
@@ -70,38 +68,38 @@ module BOAST
 
     def open
       s=""
-      s += BOAST::indent
-      s += self.to_s
-      BOAST::get_output.puts s
-      BOAST::increment_indent_level
+      s += indent
+      s += to_s
+      output.puts s
+      increment_indent_level
       return self
     end
 
-    def print(*args)
+    def pr(*args)
       if @blocks.size > 0 then
-        BOAST::increment_indent_level
+        increment_indent_level
         @blocks.each_index { |indx|
-          BOAST::decrement_indent_level
+          decrement_indent_level
           s=""
-          s += BOAST::indent
-          s += self.to_s(indx)
-          BOAST::get_output.puts s
-          BOAST::increment_indent_level
+          s += indent
+          s += to_s(indx)
+          output.puts s
+          increment_indent_level
           @blocks[indx].call(*args)
         }
-        self.close
+        close
       else
-        self.open
+        open
       end
       return self
     end
 
     def close
-      BOAST::decrement_indent_level
+      decrement_indent_level
       s = ""
-      s += BOAST::indent
+      s += indent
       s += end_string
-      BOAST::get_output.puts s
+      output.puts s
       return self
     end
 

data/lib/BOAST/Index.rb

@@ -1,8 +1,9 @@
 module BOAST
+
   class Index < Expression
-    include BOAST::Inspectable
     attr_reader :source
     attr_reader :indexes
+
     def initialize(source, indexes)
       @source = source
       @indexes = indexes
@@ -14,8 +15,8 @@ module BOAST
     end
 
     def to_s
-      return self.to_s_fortran if BOAST::get_lang == FORTRAN
-      return self.to_s_c if [C, CL, CUDA].include?( BOAST::get_lang )
+      return to_s_fortran if lang == FORTRAN
+      return to_s_c if [C, CL, CUDA].include?( lang )
     end
 
     def to_s_fortran
@@ -25,7 +26,7 @@ module BOAST
     end
 
     def to_s_texture
-      raise "Unsupported language #{BOAST::get_lang} for texture!" if not [CL, CUDA].include?( BOAST::get_lang )
+      raise "Unsupported language #{lang} for texture!" if not [CL, CUDA].include?( lang )
       raise "Write is unsupported for textures!" if not ( @source.constant or @source.direction == :in )
       dim_number = 1
       if @source.dimension then
@@ -33,7 +34,7 @@ module BOAST
       end
       raise "Unsupported number of dimension: #{dim_number}!" if dim_number > 3
       s = ""
-      if BOAST::get_lang == CL then
+      if lang == CL then
         s += "as_#{@source.type.decl}("
         s += "read_imageui(#{@source}, #{@source.sampler}, "
         if dim_number == 1 then
@@ -76,7 +77,7 @@ module BOAST
       if dim.val2 then
         start = dim.val1
       else
-        start = BOAST::get_array_start
+        start = get_array_start
       end
       sub = "#{@indexes.first} - (#{start})"
       i=1
@@ -93,12 +94,12 @@ module BOAST
         if dim.val2 then
           start = dim.val1
         else
-          start = BOAST::get_array_start
+          start = get_array_start
         end
         sub += " + (#{@indexes[i]} - (#{start}))"+ss
         i+=1
       }
-      if BOAST::get_replace_constants then
+      if get_replace_constants then
         begin
 #         puts sub
          indx = eval(sub)
@@ -112,12 +113,12 @@ module BOAST
       return s
     end
 
-    def print
+    def pr
       s=""
-      s += BOAST::indent
-      s += self.to_s
-      s += ";" if [C, CL, CUDA].include?( BOAST::get_lang )
-      BOAST::get_output.puts s
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
       return self
     end
 

data/lib/BOAST/Inspectable.rb

@@ -1,25 +1,18 @@
 module BOAST
 
-  @@inspect = false
-
-  def self.inspect?
-    return @@inspect
-  end
-
-  def self.inspect=(val)
-    @@inspect = val
-  end
+  boolean_state_accessor :boast_inspect
+  @@boast_inspect = false
 
   module Inspectable
 
     def inspect
-      if BOAST::inspect? then
-        variables = self.instance_variables.map{ |v|
+      if BOAST::boast_inspect? then
+        variables = 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}" }>" 
+        "#<#{self.class}:0x#{(self.object_id<<1).to_s(16)}#{variables == "" ? "" : " #{variables}" }>" 
       else
-        self.to_s
+        to_s
       end
     end
 

data/lib/BOAST/Operators.rb

@@ -1,15 +1,17 @@
 module BOAST
 
   class Operator
+    extend PrivateStateAccessor
+
     def Operator.inspect
-      return "#{self.name}"
+      return "#{name}"
     end
 
     def Operator.get_vector_name(type)
-      case BOAST::get_architecture
+      case get_architecture
       when X86
         case type
-        when BOAST::Int
+        when Int
           size = "#{type.size*8}"
           name = ""
           if type.total_size*8 > 64
@@ -26,7 +28,7 @@ module BOAST
             name += "u"
           end
           return name += size
-        when BOAST::Real
+        when Real
           case type.size
           when 4
             return "ps" if type.vector_length > 1
@@ -38,13 +40,13 @@ module BOAST
         else
           raise "Undefined vector type!"
         end
-      when BOAST::ARM
+      when ARM
         case type
-        when BOAST::Int
+        when Int
           name = "#{ type.signed ? "s" : "u" }"
           name += "#{ type.size * 8}"
           return name
-        when BOAST::Real
+        when Real
           return "f#{type.size*8}"
         else
           raise "Undefined vector type!"
@@ -55,8 +57,8 @@ module BOAST
     end
 
     def Operator.convert(arg, type)
-      case BOAST::get_architecture
-      when BOAST::X86
+      case get_architecture
+      when X86
         s1 = arg.type.total_size*8
         s2 = type.total_size*8
         n1 = get_vector_name(arg.type)
@@ -68,14 +70,14 @@ module BOAST
         elsif [s1, s2].max <= 512 then
           return "_mm512_cvt#{n1}_#{n2}( #{arg} )"
         end
-      when BOAST::ARM
+      when ARM
         if type.class != arg.type.class then
           if type.size == arg.type.size then
             s = type.total_size*8
             n1 = get_vector_name(arg.type)
             n2 = get_vector_name(type)
             return "vcvt#{ s == 128 ? "q" : "" }_#{n2}_#{n1}( #{arg} )"
-          elsif type.class == BOAST::Real then
+          elsif type.class == Real then
             intr = convert(arg, arg.type.copy(:size=>type.size))
             return convert(arg.copy(intr, :size => type.size ), type)
           else
@@ -84,9 +86,9 @@ module BOAST
             t2 = type.copy(:size => arg.type.size)
             n2 = get_vector_name( t2 )
             intr = "vcvt#{ s == 128 ? "q" : "" }_#{n2}_#{n1}( #{arg} )"
-            return convert(BOAST::Variable::from_type(intr, t2), type)
+            return convert(Variable::from_type(intr, t2), type)
           end
-        elsif type.class != BOAST::Real then
+        elsif type.class != Real then
           n = get_vector_name(arg.type)
           if type.size == arg.type.size then
             if type.signed == arg.type.signed then
@@ -108,19 +110,20 @@ module BOAST
         raise "Unsupported architecture!"
       end
     end
+
   end
 
-  class BasicBinaryOperator < BOAST::Operator
+  class BasicBinaryOperator < Operator
 
     def BasicBinaryOperator.to_s(arg1, arg2, return_type)
       #puts "#{arg1.class} * #{arg2.class} : #{arg1} * #{arg2}"
-      if BOAST::get_lang == BOAST::C and (arg1.class == BOAST::Variable and arg2.class == BOAST::Variable) and (arg1.type.vector_length > 1 or arg2.type.vector_length > 1) then
+      if lang == C and (arg1.class == Variable and arg2.class == Variable) and (arg1.type.vector_length > 1 or arg2.type.vector_length > 1) then
         raise "Vectors have different length: #{arg1} #{arg1.type.vector_length}, #{arg2} #{arg2.type.vector_length}" if arg1.type.vector_length != arg2.type.vector_length
         #puts "#{arg1.type.signed} #{arg2.type.signed} #{return_type.type.signed}"
 	return_name = get_vector_name(return_type.type)
         size = return_type.type.total_size * 8
-        case BOAST::get_architecture
-        when BOAST::X86
+        case get_architecture
+        when X86
           if arg1.type != return_type.type
             a1 = convert(arg1, return_type.type)
           else
@@ -137,7 +140,7 @@ module BOAST
           end
           intr_name += "_#{intr_name_X86}_#{return_name}"
           return "#{intr_name}( #{a1}, #{a2} )"
-        when BOAST::ARM
+        when ARM
           if arg1.type.class != return_type.type.class then
             a1 = convert(arg1, return_type.type)
           else
@@ -159,32 +162,33 @@ module BOAST
         return basic_usage( arg1, arg2 )
       end
     end
+
   end
 
-  class Set < BOAST::Operator
+  class Set < Operator
 
     def Set.to_s(arg1, arg2, return_type)
-      if BOAST::get_lang == BOAST::C then
-        if arg1.class == BOAST::Variable and arg1.type.vector_length > 1 then
+      if lang == C then
+        if arg1.class == Variable and arg1.type.vector_length > 1 then
           if arg1.type == arg2.type then
             return basic_usage(arg1, arg2)
           elsif arg1.type.vector_length == arg2.type.vector_length then
             return "(#{arg1} = #{convert(arg2, arg1.type)})"
           elsif arg2.type.vector_length == 1 then
             size = arg1.type.total_size*8
-            case BOAST::get_architecture
-            when BOAST::ARM
+            case get_architecture
+            when ARM
               intr_name = "vmov"
               intr_name += "q" if size == 128
               intr_name += "_n_#{get_vector_name(arg1.type)}"
-            when BOAST::X86
-              return "(#{arg1} = _m_from_int64( #{a2} ))" if arg1.type.class == BOAST::Int and arg1.type.size == 8 and size == 64
+            when X86
+              return "(#{arg1} = _m_from_int64( #{a2} ))" if arg1.type.class == Int and arg1.type.size == 8 and size == 64
               intr_name = "_mm"
               if size > 128 then
                 intr_name += "#{size}"
               end
               intr_name += "_set1_#{get_vector_name(arg1.type).gsub("u","")}"
-              intr_name += "x" if arg1.type.class == BOAST::Int and arg1.type.size == 8
+              intr_name += "x" if arg1.type.class == Int and arg1.type.size == 8
             else
               raise "Unsupported architecture!"
             end
@@ -203,23 +207,27 @@ module BOAST
     def Set.basic_usage(arg1, arg2)
       return "(#{arg1} = #{arg2})"
     end
+
   end
 
-  class Different < BOAST::Operator
+  class Different < Operator
+
     def Different.to_s(arg1, arg2, return_type)
       return basic_usage(arg1, arg2)
     end
 
     def Different.basic_usage(arg1, arg2)
-      return "#{arg1} /= #{arg2}" if BOAST::get_lang == BOAST::FORTRAN
+      return "#{arg1} /= #{arg2}" if lang == FORTRAN
       return "#{arg1} != #{arg2}"
     end
+
   end
 
-  class Affectation < BOAST::Operator
+  class Affectation < Operator
+
     def Affectation.to_s(arg1, arg2, return_type)
-      if BOAST::get_lang == BOAST::C then
-        if arg1.class == BOAST::Variable and arg1.type.vector_length > 1 then
+      if lang == C then
+        if arg1.class == Variable and arg1.type.vector_length > 1 then
           #puts "#{arg1.type.vector_length} #{arg2.type.vector_length}"
           if arg1.type == arg2.type then
             return basic_usage(arg1, arg2)
@@ -233,13 +241,13 @@ module BOAST
             else
               a2 = a2[1..-1]
             end
-            case BOAST::get_architecture
-            when BOAST::ARM
+            case get_architecture
+            when ARM
               intr_name = "vldl"
               intr_name += "q" if size == 128
               intr_name += "_#{get_vector_name(arg1.type)}"
-            when BOAST::X86
-              if arg1.type.class == BOAST::Int and size == 64 then
+            when X86
+              if arg1.type.class == Int and size == 64 then
                 return "#{arg1} = _m_from_int64( *((int64_t * ) #{a2} ) )"
               end
               intr_name = "_mm"
@@ -247,7 +255,7 @@ module BOAST
                 intr_name += "#{size}"
               end
               intr_name += "_load_"
-              if arg1.type.class == BOAST::Int then
+              if arg1.type.class == Int then
                 intr_name += "si#{size}"
               else
                 intr_name += "#{get_vector_name(arg1.type)}"
@@ -259,7 +267,7 @@ module BOAST
           else
             raise "Unknown convertion between vectors of different length!"
           end
-        elsif arg2.class == BOAST::Variable and arg2.type.vector_length > 1 then
+        elsif arg2.class == Variable and arg2.type.vector_length > 1 then
           size = arg2.type.total_size*8
           a1 = "#{arg1}"
           if a1[0] != "*" then
@@ -267,13 +275,13 @@ module BOAST
           else
             a1 = a1[1..-1]
           end
-          case BOAST::get_architecture
-          when BOAST::ARM
+          case get_architecture
+          when ARM
             intr_name = "vstl"
             intr_name += "q" if size == 128
             intr_name += "_#{get_vector_name(arg2.type)}"
-          when BOAST::X86
-            if arg2.type.class == BOAST::Int and size == 64 then
+          when X86
+            if arg2.type.class == Int and size == 64 then
               return " *((int64_t * ) #{a1}) = _m_to_int64( #{arg2} )"
             end
             intr_name = "_mm"
@@ -281,7 +289,7 @@ module BOAST
               intr_name += "#{size}"
             end
             intr_name += "_store_"
-            if arg2.type.class == BOAST::Int then
+            if arg2.type.class == Int then
               intr_name += "si#{size}"
             else
               intr_name += "#{get_vector_name(arg2.type)}"
@@ -301,9 +309,11 @@ module BOAST
     def Affectation.basic_usage(arg1, arg2)
       return "#{arg1} = #{arg2}"
     end
+
   end
 
-  class Multiplication < BOAST::BasicBinaryOperator
+  class Multiplication < BasicBinaryOperator
+
     class << self
 
       def symbol
@@ -323,9 +333,11 @@ module BOAST
       end
   
     end
+
   end
 
-  class Addition < BOAST::BasicBinaryOperator
+  class Addition < BasicBinaryOperator
+
     class << self
 
       def symbol
@@ -345,9 +357,11 @@ module BOAST
       end
   
     end
+
   end
 
-  class Substraction < BOAST::BasicBinaryOperator
+  class Substraction < BasicBinaryOperator
+
     class << self
 
       def symbol
@@ -367,9 +381,11 @@ module BOAST
       end
   
     end
+
   end
 
-  class Division < BOAST::BasicBinaryOperator
+  class Division < BasicBinaryOperator
+
     class << self
 
       def symbol
@@ -389,27 +405,30 @@ module BOAST
       end
   
     end
+
   end
 
-  class Minus < BOAST::Operator
+  class Minus < Operator
+
     def Minus.to_s(arg1, arg2, return_type)
       return " -(#{arg2})"
     end
+
   end
 
-  class Not < BOAST::Operator
+  class Not < Operator
+
     def Not.to_s(arg1, arg2, return_type)
       return " ! #{arg2}"
     end
+
   end
 
   class Ternary
-    include BOAST::Arithmetic
-    include BOAST::Inspectable
-
-    def self.parens(*args,&block)
-      return self::new(*args,&block)
-    end
+    extend Functor
+    include Arithmetic
+    include Inspectable
+    include PrivateStateAccessor
 
     attr_reader :operand1
     attr_reader :operand2
@@ -422,8 +441,8 @@ module BOAST
     end
 
     def to_s
-      raise "Ternary operator unsupported in FORTRAN!" if BOAST::get_lang == BOAST::FORTRAN
-      return self.to_s_c if [BOAST::C, BOAST::CL, BOAST::CUDA].include?( BOAST::get_lang )
+      raise "Ternary operator unsupported in FORTRAN!" if lang == FORTRAN
+      return to_s_c if [C, CL, CUDA].include?( lang )
     end
 
     def to_s_c
@@ -431,13 +450,15 @@ module BOAST
       s += "(#{@operand1} ? #{@operand2} : #{@operand3})"
     end
 
-    def print
+    def pr
       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
+      s += indent
+      s += to_s
+      s += ";" if [C, CL, CUDA].include?( lang )
+      output.puts s
       return self
     end
+
   end
+
 end

data/lib/BOAST/Parens.rb

@@ -1,32 +1,11 @@
-class Object
-  alias_method :orig_method_missing, :method_missing
-  
-  def method_missing(m, *a, &b)
-    #puts "WARNING: unknown #{m}"
-    s=nil
-    klass = begin
-      s = (self.is_a?(Module) ? self : self.class)
-      s.const_get(m)
-    rescue NameError
-    end
-    
-    return klass.send(:parens, *a, &b)  if klass.respond_to? :parens
-
-    if s == BOAST then
-      STDERR.puts "Warning unkwown function #{m} generated as BOAST::FuncCall!" if BOAST::debug
-      return BOAST::FuncCall::new(m,*a,&b)
-    end
-
-    orig_method_missing m, *a, &b
-  end
-end
-
 module BOAST
 
-  def self.register_funccall(name)
+  module_function
+
+  def register_funccall(name)
     s =<<EOF
     def self.#{name}(*args)
-      return BOAST::FuncCall("#{name}", *args)
+      return FuncCall("#{name}", *args)
     end
 EOF
     eval s

data/lib/BOAST/Pragma.rb

@@ -1,8 +1,9 @@
 module BOAST
 
   class Pragma
-    include BOAST::Inspectable
-    extend BOAST::Functor
+    include PrivateStateAccessor
+    include Inspectable
+    extend Functor
 
     attr_reader :name
     attr_reader :options
@@ -14,7 +15,7 @@ module BOAST
 
     def to_s
       s = ""
-      if BOAST::get_lang == FORTRAN then
+      if lang == FORTRAN then
         s += "$!"
       else
         s += "#pragma"
@@ -25,10 +26,10 @@ module BOAST
       return s
     end
 
-    def print
+    def pr
       s=""
-      s += self.to_s
-      BOAST::get_output.puts s
+      s += to_s
+      output.puts s
       return self
     end
   end

data/lib/BOAST/Print.rb

@@ -0,0 +1,7 @@
+module BOAST
+
+   def self.print(a)
+     a.pr
+   end
+
+end