gettc 1.10 → 2.0

data/dist/include/go/engine.rb

@@ -1,70 +1,62 @@
-require "gettc/types" 
+require "gettc/types"
 
 module Gettc
-    class Type
-        def to_go
-            if is_a? TArray
-                return "[]#{subtype.to_go}"
-            end
+  class Type
+    def to_go
+      return "[]#{subtype.to_go}" if self.is_a?(TArray)
 
-            case self 
-            when TInt
-                return "int"
-            when TLong
-                return "int64"        
-            when TFloat
-                return "float32"
-            when TDouble
-                return "float64"
-            when TChar
-                return "byte"
-            when TString
-                return "string"
-            when TBoolean
-                return "bool"
-            end 
-
-            return "unknown"
-        end
-        def dumb_go
-            if is_a? TArray
-                return to_go + " {}"
-            end
+      case self
+      when TInt
+        "int"
+      when TLong
+        "int64"
+      when TFloat
+        "float32"
+      when TDouble
+        "float64"
+      when TChar
+        "byte"
+      when TString
+        "string"
+      when TBoolean
+        "bool"
+      else
+        "unknown"
+      end
+    end
 
-            case self
-            when TInt, TLong, TDouble, TFloat
-                return "0"
-            when TChar
-                return "'$'"
-            when TString
-                return '"$"'
-            when TBoolean
-                return "true"
-            end
+    def dumb_go
+      return "#{self.to_go} {}" if self.is_a?(TArray)
 
-            return "nil"
-        end
+      case self
+      when TInt, TLong, TDouble, TFloat
+        "0"
+      when TChar
+        "'$'"
+      when TString
+        '"$"'
+      when TBoolean
+        "true"
+      else
+        "nil"
+      end
     end
-    class Signature
-        def to_go
-            return @name + " " + @type.to_go
-        end
+  end
+
+  class Signature
+    def to_go
+      "#{@name} #{@type.to_go}"
     end
-    class GoEngine
-        attr_reader :declare, :input, :output, :func_name
-        def initialize func, vars
-            @declare = vars.map do |var| 
-                var.to_go 
-            end
-            temp = vars.map do |var| 
-                var.name 
-            end
-            @output = temp.join ", "
-            temp = temp.map do |name|
-                "&" + name
-            end
-            @input = temp.join ", "
-            @func_name = func.name[0, 1].upcase + func.name[1..-1]
-        end
+  end
+
+  class GoEngine
+    attr_reader :declare, :input, :output, :func_name
+
+    def initialize(func, vars)
+      @declare = vars.map(&:to_go)
+      @output = vars.map(&:name).join(", ")
+      @input = vars.map { |var| "&#{var.name}" }.join(", ")
+      @func_name = func.name[0, 1].upcase + func.name[1..-1]
     end
+  end
 end

data/dist/include/haskell/engine.rb

@@ -1,128 +1,118 @@
-require "gettc/types" 
+require "gettc/types"
 
 module Gettc
-    class Type
-        def to_haskell
-            if is_a? TArray then
-                return "[" + subtype.to_haskell + "]"
-            end
-
-            case self
-            when TInt
-                return "Int"
-            when TLong
-                return "Integer"        
-            when TFloat
-                return "Float"
-            when TDouble
-                return "Double"
-            when TChar
-                return "Char"
-            when TString
-                return "String"
-            when TBoolean
-                return "Bool"
-            end 
-
-            return "Unknown"
-        end
-        def get_haskell_parser
-            if is_a? TArray then
-                return "(TC.parseList " + subtype.get_haskell_parser + ")"
-            end
-            
-            case self
-            when TInt
-                return "TC.parseInt"
-            when TLong
-                return "TC.parseLong"        
-            when TFloat
-                return "TC.parseFloat"
-            when TDouble
-                return "TC.parseDouble"
-            when TChar
-                return "TC.parseChar"
-            when TString
-                return "TC.parseString"
-            when TBoolean
-                return "TC.parseBool"
-            end
-
-            return "unknown"
-        end
-        def dumb_haskell
-            if is_a? TArray
-                return "[]"
-            end
-
-            case self
-            when TInt, TLong, TFloat, TDouble
-                return "0"
-            when TChar
-                return "'$'"
-            when TString
-                return '"$"'
-            when TBoolean
-                return "True"
-            end
-
-            return "Nil"
-        end
+  class Type
+    def to_haskell
+      return "[#{subtype.to_haskell}]" if self.is_a?(TArray)
+
+      case self
+      when TInt
+        "Int"
+      when TLong
+        "Integer"
+      when TFloat
+        "Float"
+      when TDouble
+        "Double"
+      when TChar
+        "Char"
+      when TString
+        "String"
+      when TBoolean
+        "Bool"
+      else
+        "Unknown"
+      end
+    end
+
+    def get_haskell_parser
+      return "(TC.parseList #{subtype.get_haskell_parser})" if self.is_a?(TArray)
+
+      case self
+      when TInt
+        "TC.parseInt"
+      when TLong
+        "TC.parseLong"
+      when TFloat
+        "TC.parseFloat"
+      when TDouble
+        "TC.parseDouble"
+      when TChar
+        "TC.parseChar"
+      when TString
+        "TC.parseString"
+      when TBoolean
+        "TC.parseBool"
+      else
+        "unknown"
+      end
     end
-    class HaskellEngine
-        attr_reader :func, :vars, :declare, :input, :output
-        def initialize func, vars
-            @func = Signature.new func.type, uncapitalize(func.name)
-            @vars = vars.map do |var|
-                Signature.new var.type, uncapitalize(var.name)
-            end
-            compute_declare
-            compute_input
-            compute_output
-        end
+
+    def dumb_haskell
+      return "[]" if self.is_a?(TArray)
+
+      case self
+      when TInt, TLong, TFloat, TDouble
+        "0"
+      when TChar
+        "'$'"
+      when TString
+        '"$"'
+      when TBoolean
+        "True"
+      else
+        "Nil"
+      end
+    end
+  end
+
+  class HaskellEngine
+    attr_reader :func, :vars
+
+    def initialize(func, vars)
+      @func = Signature.new(func.type, uncapitalize(func.name))
+      @vars = vars.map { |var| Signature.new(var.type, uncapitalize(var.name)) }
+    end
+
+    def declare
+      ret = ""
+      ret << @func.name << " :: "
+      ret << @vars.map { |var| var.type.to_haskell }.join(" -> ")
+      ret << " -> " << @func.type.to_haskell << "\n"
+      ret << @func.name << " "
+      ret << @vars.map(&:name).join(" ")
+      ret << " = " << @func.type.dumb_haskell
+    end
+
+    def input
+      ret = "getVars :: TC.Parser ("
+      ret << @vars.map { |var| var.type.to_haskell }.join(", ") << ")\n"
+
+      temp = "getVars = do "
+      indent = " " * temp.size
+      ret << temp
+
+      ret << @vars.map do |var|
+        x = ""
+        x << var.name
+        x << " <- TC.spaces >> "
+        x << var.type.get_haskell_parser
+      end.join(" ; TC.spaces >> TC.next\n#{indent}")
+
+      ret << "\n"
+      ret << indent << "return ("
+      ret << @vars.map(&:name).join(", ")
+      ret << ")"
+    end
+
+    def output
+      @func.name + " " + @vars.map(&:name).join(" ")
+    end
+
     private
-        def uncapitalize str
-            return str[0, 1].downcase + str[1..-1]
-        end
-        def compute_declare
-            ret = ""
-            ret << func.name << " :: "
-
-            temp = vars.map do |var| var.type.to_haskell end
-            ret << temp.join(" -> ") << " -> " << func.type.to_haskell << "\n"
-
-            ret << func.name << " "
-            temp = vars.map do |var| var.name end
-            ret << temp.join(" ") << " = " << func.type.dumb_haskell
-
-            @declare = ret
-        end
-        def compute_input
-            ret = "getVars :: TC.Parser ("
-            temp = @vars.map do |var| var.type.to_haskell end
-            ret << temp.join(", ") << ")\n"
-            temp = "getVars = do "
-            ret << temp
-                indent = " " * temp.size
-                temp = @vars.map do |var|
-                    x = ""
-                    x << var.name
-                    x << " <- TC.spaces >> " 
-                    x << var.type.get_haskell_parser
-                end
-            ret << temp.join(" ; TC.spaces >> TC.next\n#{indent}") << "\n"
-            ret << indent << "return ("
-                temp = @vars.map do |var| var.name end
-                ret << temp.join(", ")
-            ret << ")"
-            @input = ret
-        end
-        def compute_output
-            ret = ""
-            ret << @func.name << " "
-            temp = vars.map do |var| var.name end
-            ret << temp.join(" ")
-            @output = ret
-        end
+
+    def uncapitalize str
+      str[0, 1].downcase + str[1..-1]
     end
+  end
 end

data/dist/include/java/engine.rb

@@ -1,193 +1,196 @@
-require "gettc/types" 
+require "gettc/types"
 
 module Gettc
-    class Type
-        def to_java
-            return to_s
-        end
-        def to_java_boxed
-            if is_a? TArray then
-                return "List<#{subtype.to_java_boxed}>"
-            end
-
-            case self
-            when TInt
-                return "Integer"
-            when TLong
-                return "Long"        
-            when TFloat
-                return "Float"
-            when TDouble
-                return "Double"
-            when TChar
-                return "Character"
-            when TString
-                return "String"
-            when TBoolean
-                return "Boolean"
-            end 
-
-            return "Unknown"
-        end
-        def dumb_java
-            if self.is_a? TArray then
-                return "new #{subtype.to_java}[1]"
-            end
-
-            case self
-            when TInt, TLong, TFloat, TDouble
-                return "0"
-            when TChar
-                return "'$'"
-            when TString
-                return '"$"'
-            when TBoolean
-                return "true"
-            end
-
-            return "Nil"
-        end
+  class Type
+    def to_java
+      to_s
     end
-    class Signature
-        def to_java
-            return "#{type.to_java} #{name}"
-        end
+
+    def to_java_boxed
+      return "List<#{subtype.to_java_boxed}>" if self.is_a?(TArray)
+
+      case self
+      when TInt
+        "Integer"
+      when TLong
+        "Long"
+      when TFloat
+        "Float"
+      when TDouble
+        "Double"
+      when TChar
+        "Character"
+      when TString
+        "String"
+      when TBoolean
+        "Boolean"
+      else
+        "Unknown"
+      end
     end
-    class JavaArray
-        def self.get_depth type
-            return 0 unless type.is_a? TArray
-            return 1 + get_depth(type.subtype)
-        end
-        def self.get_elem_type type
-            return type unless type.is_a? TArray
-            return get_elem_type type.subtype
-        end
-        attr_reader :name, :boxed_name, :type, :boxed_type
-        def initialize sig
-            @sig = sig
-            @name = sig.name
-            @boxed_name = "#{@name}Boxed"
-            @type = sig.type.to_java
-            @boxed_type = sig.type.to_java_boxed
-            @depth = self.class.get_depth sig.type
-            @elem_type = self.class.get_elem_type(sig.type).to_java
-        end
-        def unbox_code
-            counters = @depth.times.map do |i| "_" + ("i"[0].ord + i).chr end
-            indents = 0.upto(@depth).map do |i| " " * 4 * i end
-            sizes = @depth.times.map do |i|
-                @boxed_name + (".get(0)" * i) + ".size()"
-            end
-            ret = ""
-
-            ret << @type << " " << @name << " = new " << @elem_type;
-            @depth.times do |i| ret << "[" << sizes[i] << "]" end
-            ret << ";\n"
-        
-            @depth.times do |i|
-                ret << indents[i] << "for (int " << counters[i] << " = 0; "
-                ret << counters[i] << " < " << sizes[i]
-                ret << "; ++" << counters[i] << ")\n"
-            end
-
-            ret << indents[@depth] << @name
-            @depth.times do |i| ret << "[" << counters[i] << "]" end            
-            ret << " = "
-            ret << @boxed_name
-            @depth.times do |i| ret << ".get(" << counters[i] << ")" end            
-            ret << ";"
-
-            return ret
-        end
-        def box_code_recurse boxed_type, parent, boxed_name, depth, counters
-            ret = ""
-            index = counters.map do |counter| "[" + counter + "]" end
-            index = index.join
-            if depth == 0
-                ret << parent << ".add(" << @name << index << ");\n"
-            else
-                type_str = boxed_type.to_java_boxed
-                ret << type_str << " " << boxed_name 
-                ret << " = new Array" << type_str << "();" << "\n"
-
-                counter = "_" + ("i"[0].ord + counters.size).chr
-                ret << "for (int " << counter << " = 0; "
-                ret << counter << " < " << @name << index << ".length; "
-                ret << "++" << counter << ") {\n"
-
-                ret << box_code_recurse(boxed_type.subtype, 
-                                        boxed_name, 
-                                        boxed_name + counter, 
-                                        depth - 1, counters << counter)
-                ret << "}\n"
-
-                unless parent.nil?
-                    ret << parent << ".add(" 
-                    ret << boxed_name  << ");\n"
-                end
-            end
-            ret.gsub! /^/, " " * 4 unless parent.nil? 
-            return ret
-        end
-        def box_code
-            box_code_recurse @sig.type, nil, @boxed_name, @depth, []
-        end 
+
+    def dumb_java
+      return "new #{subtype.to_java}[1]" if self.is_a?(TArray)
+
+      case self
+      when TInt, TLong, TFloat, TDouble
+        "0"
+      when TChar
+        "'$'"
+      when TString
+        '"$"'
+      when TBoolean
+        "true"
+      else
+        "Nil"
+      end
     end
-    class JavaEngine
-        attr_accessor :declare, :input, :output
-        def initialize func, vars
-            @func = func
-            @vars = vars
-            compute_declare
-            compute_input
-            compute_output
-        end
-    private
-        def compute_declare 
-            ret = "public "
-            ret << @func.to_java << "("
-                indent = " " * ret.size
-                temp = @vars.map do |var| var.to_java end
-                ret << temp.join(",\n#{indent}")
-            ret << ")"
-            @declare = ret
-        end
-        def compute_input
-            temp = @vars.map do |var| 
-                ret = ""
-                if var.type.is_a? TArray
-                    arr = JavaArray.new var
-                    ret << arr.boxed_type
-                    ret << " " << arr.boxed_name
-                    ret << " = (" << arr.boxed_type << ") "
-                    ret << "reader.next(new TypeRef<" << arr.boxed_type << ">"
-                    ret << "(){}.getType());\n"
-                    ret << arr.unbox_code
-                else
-                    ret << var.to_java
-                    ret << " = (" << var.type.to_java_boxed << ") "
-                    ret << "reader.next(" 
-                    ret << var.type.to_java_boxed 
-                    ret << ".class);"
-                end
-                ret
-            end
-            @input = temp.join "\nreader.next();\n\n"
+  end
+
+  class Signature
+    def to_java
+      "#{type.to_java} #{name}"
+    end
+  end
+
+  class JavaArray
+    attr_reader :name, :boxed_name, :type, :boxed_type
+
+    def self.get_depth(type)
+      type.is_a?(TArray) ? 1 + get_depth(type.subtype) : 0
+    end
+
+    def self.get_elem_type(type)
+      type.is_a?(TArray) ? get_elem_type(type.subtype) : type
+    end
+
+    def initialize(sig)
+      @sig = sig
+      @name = sig.name
+      @boxed_name = "#{@name}Boxed"
+      @type = sig.type.to_java
+      @boxed_type = sig.type.to_java_boxed
+      @depth = self.class.get_depth(sig.type)
+      @elem_type = self.class.get_elem_type(sig.type).to_java
+    end
+
+    def unbox_code
+      ret = ""
+
+      counters = @depth.times.map { |i| "_" + ("i"[0].ord + i).chr }
+      indents = 0.upto(@depth).map { |i| " " * 4 * i }
+      sizes = @depth.times.map { |i| @boxed_name + (".get(0)" * i) + ".size()" }
+
+      ret << @type << " " << @name << " = new " << @elem_type
+      @depth.times { |i| ret << "[" << sizes[i] << "]" }
+      ret << ";\n"
+
+      @depth.times do |i|
+        ret << indents[i] << "for (int " << counters[i] << " = 0; "
+        ret << counters[i] << " < " << sizes[i]
+        ret << "; ++" << counters[i] << ")\n"
+      end
+
+      ret << indents[@depth] << @name
+      @depth.times { |i| ret << "[" << counters[i] << "]" }
+      ret << " = "
+
+      ret << @boxed_name
+      @depth.times { |i| ret << ".get(" << counters[i] << ")" }
+      ret << ";"
+
+      ret
+    end
+
+    def box_code_recurse(boxed_type, parent, boxed_name, depth, counters)
+      ret = ""
+
+      index = counters.map { |counter| "[#{counter}]" }.join
+
+      if depth == 0
+        ret << parent << ".add(" << @name << index << ");\n"
+      else
+        type_str = boxed_type.to_java_boxed
+        ret << type_str << " " << boxed_name
+        ret << " = new Array" << type_str << "();" << "\n"
+
+        counter = "_" + ("i"[0].ord + counters.size).chr
+        ret << "for (int " << counter << " = 0; "
+        ret << counter << " < " << @name << index << ".length; "
+        ret << "++" << counter << ") {\n"
+
+        ret << box_code_recurse(boxed_type.subtype,
+                                boxed_name,
+                                boxed_name + counter,
+                                depth - 1, counters << counter)
+        ret << "}\n"
+
+        unless parent.nil?
+          ret << parent << ".add("
+          ret << boxed_name  << ");\n"
         end
-        def compute_output
-            ret = ""
-            caller = "solver." + @func.name + "("
-            temp = @vars.map do |var| var.name end
-            caller << temp.join(", ") << ")"
-            if @func.type.is_a? TArray
-                ret << @func.type.to_java << " result = " << caller << ";\n"
-                arr = JavaArray.new(Signature.new @func.type, "result")
-                ret << arr.box_code
-                ret << "writer.write(resultBoxed);"
-            else
-                ret << "writer.write(" << caller << ");"
-            end
-            @output = ret
+      end
+
+      parent.nil? ? ret : ret.gsub(/^/, " " * 4)
+    end
+
+    def box_code
+      box_code_recurse(@sig.type, nil, @boxed_name, @depth, [])
+    end
+  end
+
+  class JavaEngine
+    def initialize func, vars
+      @func = func
+      @vars = vars
+    end
+
+    def declare
+      ret = "public "
+      ret << @func.to_java << "("
+      indent = " " * ret.size
+      ret << @vars.map(&:to_java).join(",\n#{indent}")
+      ret << ")"
+    end
+
+    def input
+      @vars.map do |var|
+        ret = ""
+        if var.type.is_a?(TArray)
+          arr = JavaArray.new(var)
+          ret << arr.boxed_type
+          ret << " " << arr.boxed_name
+          ret << " = (" << arr.boxed_type << ") "
+          ret << "reader.next(new TypeRef<" << arr.boxed_type << ">"
+          ret << "(){}.getType());\n"
+          ret << arr.unbox_code
+        else
+          ret << var.to_java
+          ret << " = (" << var.type.to_java_boxed << ") "
+          ret << "reader.next("
+          ret << var.type.to_java_boxed
+          ret << ".class);"
         end
+        ret
+      end.join("\nreader.next();\n\n")
+    end
+
+    def output
+      ret = ""
+
+      solver = "solver." + @func.name + "("
+      solver << @vars.map(&:name).join(", ") << ")"
+
+      if @func.type.is_a?(TArray)
+        ret << @func.type.to_java << " result = " << solver << ";\n"
+        arr = JavaArray.new(Signature.new(@func.type, "result"))
+        ret << arr.box_code
+        ret << "writer.write(resultBoxed);"
+      else
+        ret << "writer.write(" << solver << ");"
+      end
+
+      ret
     end
+  end
 end