BOAST 2.0.2 → 2.1.0

data/lib/BOAST/Language/FuncCall.rb

@@ -47,23 +47,23 @@ module BOAST
 
     def to_s_fortran
       s = ""
-      s += @prefix if @prefix
-      s += "#{func_name}(#{@args.collect(&:to_s).join(", ")})"
+      s << @prefix if @prefix
+      s << "#{func_name}(#{@args.collect(&:to_s).join(", ")})"
     end
 
     def to_s_c
       s = ""
-      s += @prefix if @prefix
-      s += "#{func_name}(#{@args.collect(&:to_s).join(", ")})"
+      s << @prefix if @prefix
+      s << "#{func_name}(#{@args.collect(&:to_s).join(", ")})"
     end
 
     private :to_s_fortran, :to_s_c
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end

data/lib/BOAST/Language/HighLevelOperators.rb

@@ -68,9 +68,9 @@ module BOAST
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end
@@ -126,9 +126,9 @@ module BOAST
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end

data/lib/BOAST/Language/If.rb

@@ -61,12 +61,12 @@ module BOAST
     def to_s(condition_number = 0)
       s = ""
       if condition_number == 0 then
-        s += if_string(@conditions.first)
+        s << if_string(@conditions.first)
       else
         if @conditions[condition_number] then
-          s += elsif_string(@conditions[condition_number])
+          s << elsif_string(@conditions[condition_number])
         else
-          s += else_string
+          s << else_string
         end
       end
       return s
@@ -78,8 +78,8 @@ module BOAST
     def open(condition_number = 0)
       decrement_indent_level if condition_number > 0
       s = ""
-      s += indent
-      s += to_s(condition_number)
+      s << indent
+      s << to_s(condition_number)
       output.puts s
       increment_indent_level
       return self
@@ -108,8 +108,8 @@ module BOAST
     def close
       decrement_indent_level
       s = ""
-      s += indent
-      s += end_string
+      s << indent
+      s << end_string
       output.puts s
       return self
     end

data/lib/BOAST/Language/Index.rb

@@ -8,7 +8,7 @@ module BOAST
 
     def method_missing(m, *a, &b)
       var = to_var
-      if var.type.methods.include?(:members) and var.type.members[m.to_s] then
+      if var.type.kind_of?(CStruct) and var.type.members[m.to_s] then
         return struct_reference(type.members[m.to_s])
       elsif var.vector? and m.to_s[0] == 's' and lang != CUDA then
         required_set = m.to_s[1..-1].chars.to_a
@@ -32,7 +32,7 @@ module BOAST
     end
 
     def align?
-      return !!@alignment
+      return @alignment
     end
 
     def set_align(align)
@@ -68,7 +68,7 @@ module BOAST
           (0...dims.length).each { |indx|
             dim = dims[indx]
             s = "#{indxs[indx]}"
-            s += " - (#{dim.start})" unless 0.equal?(dim.start)
+            s << " - (#{dim.start})" unless 0.equal?(dim.start)
             ind = Empty.empty_binding.eval(s)
             ind = ind.to_i
             const = const[ind]
@@ -83,9 +83,9 @@ module BOAST
 
     def pr
       s=""
-      s += indent
-      s += to_s
-      s += ";" if [C, CL, CUDA].include?( lang )
+      s << indent
+      s << to_s
+      s << ";" if [C, CL, CUDA].include?( lang )
       output.puts s
       return self
     end
@@ -102,13 +102,13 @@ module BOAST
         end
       }
       s = ""
-      s += "#{@source}(#{@source.vector? ? (@vector_index ? "#{@vector_index+1}, " : ":, ") : "" }#{indexes_dup.join(", ")})"
+      s << "#{@source}(#{@source.vector? ? (@vector_index ? "#{@vector_index+1}, " : ":, ") : "" }#{indexes_dup.join(", ")})"
       return s
     end
 
     def to_s_texture
-      raise LanguageError, "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 )
+      raise LanguageError, "Unsupported language #{lang} for texture!" unless [CL, CUDA].include?( lang )
+      raise "Write is unsupported for textures!" unless ( @source.constant or @source.direction == :in )
       dim_number = 1
       if @source.dimension then
         dim_number == @source.dimension.size
@@ -116,38 +116,38 @@ module BOAST
       raise "Unsupported number of dimension: #{dim_number}!" if dim_number > 3
       s = ""
       if lang == CL then
-        s += "as_#{@source.type.decl}("
-        s += "read_imageui(#{@source}, #{@source.sampler}, "
+        s << "as_#{@source.type.decl}("
+        s << "read_imageui(#{@source}, #{@source.sampler}, "
         if dim_number == 1 then
-          s += "int2(#{@indexes[0]},0)"
+          s << "int2(#{@indexes[0]},0)"
         else
           if dim_number == 2 then
-            s += "int2("
+            s << "int2("
           else
-            s += "int3("
+            s << "int3("
           end
-          s += "#{@indexes.join(", ")})"
+          s << "#{@indexes.join(", ")})"
         end
-        s += ")"
+        s << ")"
         if @source.type.size == 4 then
-          s += ".x"
+          s << ".x"
         elsif @source.type.size == 8 then
-          s += ".xy"
+          s << ".xy"
         end
-        s += ")"
+        s << ")"
       else
-        s += "tex#{dim_number}Dfetch(#{@source},"
+        s << "tex#{dim_number}Dfetch(#{@source},"
         if dim_number == 1 then
-          s += "#{@indexes[0]}"
+          s << "#{@indexes[0]}"
         else
           if dim_number == 2 then
-            s += "int2("
+            s << "int2("
           else
-            s += "int3("
+            s << "int3("
           end
-          s += "#{@indexes.join(", ")})"
+          s << "#{@indexes.join(", ")})"
         end
-        s += ")"
+        s << ")"
       end
       return s
     end
@@ -158,7 +158,7 @@ module BOAST
       t = (0...dims.length).collect { |indx|
         s = "#{indxs[indx]}"
         dim = dims[indx]
-        s += " - (#{dim.start})" unless 0.equal?(dim.start)
+        s << " - (#{dim.start})" unless 0.equal?(dim.start)
         s
       }
       return t.join("][")
@@ -171,15 +171,15 @@ module BOAST
       (0...dims.length).each { |indx|
         s = ""
         dim = dims[indx]
-        s += "#{indxs[indx]}"
-        s += " - (#{dim.start})" unless 0.equal?(dim.start)
+        s << "#{indxs[indx]}"
+        s << " - (#{dim.start})" unless 0.equal?(dim.start)
         if ss then
           if dim.size then
-            s += " + (#{dim.size}) * "
+            s << " + (#{dim.size}) * "
           else
             raise "Unkwown dimension size!"
           end
-          s += "(#{ss})"
+          s << "(#{ss})"
         end
         ss = s
       }
@@ -195,7 +195,7 @@ module BOAST
       end
       s = "#{@source}[" + sub + "]"
       if @vector_index then
-        s += "[#{@vector_index}]"
+        s << "[#{@vector_index}]"
       end
       return s
     end

data/lib/BOAST/Language/Intrinsics.rb

@@ -79,14 +79,14 @@ module BOAST
         end
       }
 #      supported = (INSTRUCTIONS[instruction.to_s] & MODELS[get_model.to_s]).size > 0
-      if not supported then
+      unless supported then
         required = ""
         INSTRUCTIONS[get_architecture][instruction.to_s].each { |cpuid|
-          required += " or " if required != ""
+          required << " or " if required != ""
           if cpuid.kind_of?( Array ) then
-            required += "( #{cpuid.join(" and ")} )"
+            required << "( #{cpuid.join(" and ")} )"
           else
-            required += "#{cpuid}"
+            required << "#{cpuid}"
           end
         }
         raise IntrinsicsError, "Unsupported operation #{intr_symbol} for #{type}#{type2 ? " and #{type2}" : ""} on #{get_model}! (requires #{required})"
@@ -116,10 +116,10 @@ module BOAST
       case data_type
       when Int
         raise IntrinsicsError, "Unsupported data size for int vector on X86: #{data_type.size*8}!" unless [1,2,4,8].include?( data_type.size )
-        return s+= "#{data_type.total_size*8>64 ? "i" : ""}"
+        return s << "#{data_type.total_size*8>64 ? "i" : ""}"
       when Real
         return s if data_type.size == 4
-        return s += "d" if data_type.size == 8
+        return s << "d" if data_type.size == 8
         raise IntrinsicsError, "Unsupported data size for real vector on X86: #{data_type.size*8}!"
       else
         raise IntrinsicsError, "Unsupported data type #{data_type} for vector on X86!"
@@ -161,15 +161,15 @@ module BOAST
       s = ""
       case type
       when Int
-        s += "u" unless type.signed?
-        s += "int"
+        s << "u" unless type.signed?
+        s << "int"
       when Real
-        s += "float"
+        s << "float"
       else
         raise InternalIntrinsicsError, "Undefined vector type!"
       end
-      s += "#{type.size*8}"
-      s += "x#{type.vector_length}_t"
+      s << "#{type.size*8}"
+      s << "x#{type.vector_length}_t"
       return s.to_sym
     end
 
@@ -181,19 +181,19 @@ module BOAST
       when :int
         case sign
         when :signed
-          s += "int"
+          s << "int"
         when :unsigned
-          s += "uint"
+          s << "uint"
         else
           raise InternalIntrinsicsError, "Invalid sign!"
         end
       when :float
-        s += "float"
+        s << "float"
       else
         raise InternalIntrinsicsError, "Invalid type!"
       end
-      s += "#{size}"
-      s += "x#{vector_size/size}_t"
+      s << "#{size}"
+      s << "x#{vector_size/size}_t"
       return s.to_sym
     end
 
@@ -205,18 +205,18 @@ module BOAST
       when :int
         case sign
         when :signed
-          s += "s"
+          s << "s"
         when :unsigned
-          s += "u"
+          s << "u"
         else
           raise InternalIntrinsicsError, "Invalid sign!"
         end
       when :float
-        s += "f"
+        s << "f"
       else
         raise InternalIntrinsicsError, "Invalid type!"
       end
-      s += "#{size}"
+      s << "#{size}"
       return s
     end
 
@@ -227,23 +227,23 @@ module BOAST
       case type
       when :int
         e = ( vector_size > 64 ? "e" : "" )
-        s += "#{e}p"
+        s << "#{e}p"
         case sign
         when :signed
-          s += "i"
+          s << "i"
         when :unsigned
-          s += "u"
+          s << "u"
         else
           raise InternalIntrinsicsError, "Invalid sign!"
         end
-        s += "#{size}"
+        s << "#{size}"
       when :float
-        s += "p"
+        s << "p"
         case size
         when 32
-          s += "s"
+          s << "s"
         when 64
-          s += "d"
+          s << "d"
         else
           raise InternalIntrinsicsError, "Invalid size!"
         end

data/lib/BOAST/Language/OpenMP.rb

@@ -7,9 +7,9 @@ module BOAST
       def openmp_pragma_to_s
         s = ""
         if lang == FORTRAN then
-          s += "!$omp"
+          s << "!$omp"
         elsif lang == C then
-          s += "#pragma omp"
+          s << "#pragma omp"
         else
           raise LanguageError, "Language does not support OpenMP!"
         end
@@ -23,37 +23,37 @@ module BOAST
 EOF
         case arg_type
         when :none
-          s += <<EOF
+          s << <<EOF
         return " #{name}"
 EOF
         when :option
-          s += <<EOF
+          s << <<EOF
         return " \#{c}"
 EOF
         when :option_list
-          s += <<EOF
+          s << <<EOF
         return " (\#{[c].flatten.collect(&:to_s).join(", ")})"
 EOF
         when :simple
-          s += <<EOF
+          s << <<EOF
         return " #{name}(\#{c})"
 EOF
         when :list
-s += <<EOF
+s << <<EOF
         return " #{name}(\#{[c].flatten.collect(&:to_s).join(", ")})"
 EOF
         when :multilist
-s += <<EOF
+s << <<EOF
         s = ""
         c.each { |id, list|
-          s += " #{name}(\#{id}: \#{[list].flatten.collect(&:to_s).join(", ")})"
+          s << " #{name}(\#{id}: \#{[list].flatten.collect(&:to_s).join(", ")})"
         }
         return s
 EOF
         else
           raise "Unknown argument type!"
         end
-        s += <<EOF
+        s << <<EOF
       end
 EOF
         eval s
@@ -96,11 +96,11 @@ EOF
       def openmp_open_clauses_to_s
         s = ""
         get_open_clauses.each { |c|
-          s += self.send( "openmp_clause_#{c}", @openmp_clauses[c] ) if @openmp_clauses[c]
+          s << self.send( "openmp_clause_#{c}", @openmp_clauses[c] ) if @openmp_clauses[c]
         }
         if lang == C then
           get_end_clauses.each { |c|
-            s += self.send( c, @openmp_clauses[c] ) if @openmp_clauses[c]
+            s << self.send( c, @openmp_clauses[c] ) if @openmp_clauses[c]
           }
         end
         return s
@@ -110,7 +110,7 @@ EOF
         s = ""
         if lang == FORTRAN then
           get_end_clauses.each { |c|
-            s += self.send( c, @openmp_clauses[c] ) if @openmp_clauses[c]
+            s << self.send( c, @openmp_clauses[c] ) if @openmp_clauses[c]
           }
         end
         return s
@@ -206,30 +206,30 @@ EOF
         return { :begin => '"#pragma omp #{c_name} #{ open_clauses.length + end_clauses.length > 0 ? "\#{c}" : "" }#{ options[:block] ? "\\n{" : "" }"',
 EOF
       if options[:c_end] then
-        s += <<EOF
+        s << <<EOF
                  :end => '"#pragma omp end #{c_name}"' }
 EOF
       else
-        s += <<EOF
+        s << <<EOF
                  :end => '"#{ options[:block] ? "}" : "" }"' }
 EOF
       end
-        s += <<EOF
+        s << <<EOF
       end
 
       def get_fortran_strings
         return { :begin => '"!$omp #{fortran_name}#{ open_clauses.length > 0 ? " \#{c}" : "" }#{ options[:fortran_block] ? "(" : "" }"',
 EOF
       if options[:fortran_no_end] then
-        s += <<EOF
+        s << <<EOF
                  :end => '"#{ options[:fortran_block] ? ")" : "" }"' }
 EOF
       else
-        s += <<EOF
+        s << <<EOF
                  :end => '"!$omp end #{fortran_name} #{ end_clauses.length > 0 ? "\#{c}" : "" }"' }
 EOF
       end
-        s += <<EOF
+        s << <<EOF
       end
 
       def self.get_open_clauses