gecoder-with-gecode 0.7.1

data/vendor/rust/rust/cppifaceparser.rb

@@ -0,0 +1,129 @@
+
+
+module Rust
+
+module Cpp
+
+class IfaceParser
+  def initialize
+  end
+  
+  def parseFile(path)
+    lines = ""
+    File.open(path) { |f|
+      lines = f.readlines.join
+    }
+    
+    parse(lines)
+  end
+  
+  def parse(cpph)
+    classes = []
+    
+    ignore = true
+    
+    # FIXME: remove \n and split by ";" and "*/"
+    
+    cpph.to_s.split(/$/).each { |line|
+      line = line.split("//").first
+      if line =~ /\/\*/ # open comment
+        ignore = true
+      end
+      
+      if line =~ /\*\// # close comment
+        ignore = false
+      end
+      
+      if line =~ /public:/
+        ignore = false
+      elsif line =~ /private:|protected:/
+        ignore = true
+      elsif line =~ /class\s+(\w+\s+){0,1}(\w+)/ # function
+        if not classes.last.nil?
+          if classes.last[:name] == $2
+            next
+          end
+        end
+        
+        classes << {:name => $2, :methods => [], :constructors => [] }
+      elsif line =~ /namespace\s+(\w+)\s+\{{0,1}/
+        $stderr << "Warning: Namespace will be ignore.\n"
+      end
+      
+      if not ignore and classes.last
+        parseEntity(line, classes.last)
+      end
+    }
+    
+    classes.delete_if { |klass|
+      klass[:methods].empty?
+    }
+    
+    classes
+  end
+  
+  private
+  def parseEntity(line, klass)
+    if line =~ /((\w+::)*\w+)\s+(const\s+){0,1}(\*{0,3}|&){0,1}\s*(\w+)\s*\((.*)\)/
+      type = "#{$1}#{$4}"
+      fname = $5
+      params = []
+      
+      if not $6.nil?
+        $6.strip!
+        if not $6.empty?
+          params = parseParams($6)
+        end
+      end
+      
+      klass[:methods] << { :name => fname, :type => type, :params => params }
+    elsif line =~ /^\s*#{klass[:name]}\s*\((.*)\)/ #constructor
+      params = parseParams($1)
+      klass[:constructors] << { :params => params }
+    end
+  end
+  
+  def parseParams(params)
+    result = []
+    params.split(",").each { |param|
+      param = param.split("=").first
+      param.strip!
+      
+      if param =~ /((\w+::)*\w+)\s*(const){0,1}(\*{0,3}|&){0,1}(const\s+){0,1}\s*(\w*)\s*$/
+        type = "#{$1}#{$2}#{$4}"
+        
+        name = $6
+        if name.empty?
+          name = "par#{result.size}"
+        end
+        result << {:type => type, :name => name}
+      end
+    }
+    
+    result
+  end
+end
+
+end # Cpp
+
+end # Rust
+
+if __FILE__ == $0
+  parser = Rust::Cpp::IfaceParser.new
+  
+  classes = parser.parseFile(ARGV[0].to_s)
+  
+  classes.each { |klass|
+    puts "Class: #{klass[:name]}"
+    klass[:methods].each { |method|
+      params = "("
+      
+      method[:params].each { |par|
+        params += "#{par[:type]} #{par[:name]}, "
+      }
+      params += ")"
+      puts "Method: #{method[:type]} #{method[:name]} #{params};"
+    }
+  }
+end
+

data/vendor/rust/rust/cwrapper.rb

@@ -0,0 +1,72 @@
+# Copyright (c) 2005-2007 Diego Pettenò <flameeyes@gmail.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE
+# FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module Rust
+
+  # C class wrapper class, this is used to provide support for those
+  # wrappers around C libraries that are bound by Rust.
+  class ClassWrapper < Class
+    attr_reader :cleanup_functions
+
+    def initialize(name, type, namespace) # :notnew:
+      super(name, namespace)
+
+      @cname = type
+      @varcname = @cname.sub("*", "Ptr").gsub("::", "_").gsub(' ', '')
+      @cleanup_functions = ""
+
+      @definition_template = Templates["CWrapperClassDefinitions"]
+      @declaration_template << Templates["StandaloneClassDeclarations"]
+
+      add_expansion 'cleanup_functions', '@cleanup_functions'
+    end
+
+    def add_constructor(name)
+      constructor = super()
+
+      constructor.name = name
+
+      return constructor
+    end
+
+    def add_cleanup_function(call)
+      @cleanup_functions << call << "\n"
+    end
+
+    # This class is used to represente the constructor of a C++ class
+    # bound in a Ruby extension.
+    class Constructor < Class::Constructor
+      attr_writer :name
+
+      def raw_call(nparam = nil)
+        "tmp = #{super(nparam)}"
+      end
+    end
+
+    class Method < Class::Method
+      def add_instance_parameter
+        add_static_parameter 'tmp'
+      end
+    end
+  end
+
+end

data/vendor/rust/rust/cxxclass.rb

@@ -0,0 +1,98 @@
+# Copyright (c) 2005-2007 Diego Pettenò <flameeyes@gmail.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE
+# FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'rust/class'
+
+module Rust
+  class CxxClass < Class
+    # This function initializes the CxxClass instance by setting the
+    # values to the attributes defining its parent, namespace, name
+    # and a few other needed information.
+    #
+    # When a C++ Class is bound that is a child of another class, it
+    # shares its highest anchestor's pointer map (as that is the
+    # more general pointer type it can be referred to with), and
+    # function to call when free()'ing.
+    #
+    # Don't call this function directly, use Namespace.add_cxx_class
+    #
+    # *FIXME*: multiple inheritance can make Rust bail out, badly.
+    def initialize(name, namespace, parent = nil) # :notnew:
+      super(name, namespace)
+      @parent = parent
+
+      @children_classes = []
+
+      @definition_template = Templates["CxxClassDefinitions"]
+
+      @varname = "#{complete_name.gsub("::", "_")}"
+      
+      if @parent
+        @ptrmap = @parent.ptrmap
+        @function_free = @parent.function_free
+        @parent_varname = "r#{@parent.varname}"
+      else
+        @declaration_template << Templates["StandaloneClassDeclarations"]
+        @definition_template << Templates["CxxStandaloneClassDefinitions"]
+      end
+
+      add_expansion 'test_children'
+    end
+    
+    def custom_extends(parent)
+      @parent_varname = parent
+    end
+
+    # This function is used during ruby to C/C++ conversion of the
+    # types, and test for the deepest class the pointer is valid for.
+    def test_children
+      return unless @children_classes
+      
+      ret = ""
+      
+      @children_classes.each do |klass|
+        ret << %@
+     if ( dynamic_cast< #{klass.namespace.cname}::#{klass.name}* >(instance) != NULL )
+     {
+       klass = c#{klass.varname};
+       #{klass.test_children}
+     }
+     @
+      end
+
+      return ret
+    end
+
+    class Method < Class::Method
+      def raw_call(nparam = nil)
+        "tmp->#{super(nparam)}"
+      end
+    end
+
+    class Constructor < Class::Constructor
+      def raw_call(nparam = nil)
+        "tmp = new #{@parent.namespace.cname}::#{super(nparam)}"
+      end
+    end
+
+  end
+end

data/vendor/rust/rust/element.rb

@@ -0,0 +1,81 @@
+# Copyright (c) 2005-2007 Diego Pettenò <flameeyes@gmail.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE
+# FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module Rust
+
+  # This class represents a generic element for Rust, that responds to
+  # the three generic methods: Element.declaration, Element.definition
+  # and Element.initialization that form a Ruby extension generated by
+  # Rust.
+  # An element can also have children element, which methods are
+  # called as a pyramid.
+  class Element
+    def initialize
+      @children = []
+      @expansions = []
+
+      @declaration_template = "#error Element #{self.inspect} missing declaration template"
+      @definition_template = "#error Element #{self.inspect} missing definition template"
+      @initializatio_template = "#error Element #{self.inspect} missing initialization template"
+    end
+
+    def add_expansion(key, value = key)
+      throw "missing @expansions array -- did you call Element.initialize?" unless @expansions
+      @expansions << [key, value]
+    end
+
+    def expand(str)
+      @expansions.each do |key, expression|
+        begin
+          str.gsub!("!#{key}!", eval(expression).to_s)
+        rescue
+          $stderr.puts "Exception during substitution of '#{key}' into '#{expression}' for #{self.inspect}"
+          raise
+        end
+      end
+
+      return str
+    end
+
+    def declaration
+      ret = @declaration_template +
+        @children.collect { |child| child.declaration }.join("\n")
+
+      expand(ret)
+    end
+
+    def definition
+      ret = @definition_template +
+        @children.collect { |child| child.definition }.join("\n")
+
+      expand(ret)
+    end
+
+    def initialization
+      ret = @initialization_template +
+        @children.collect { |child| child.initialization }.join("\n")
+
+      expand(ret)
+    end
+  end
+
+end

data/vendor/rust/rust/enum.rb

@@ -0,0 +1,63 @@
+# Copyright (c) 2007 Diego Pettenò <flameeyes@gmail.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE
+# FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module Rust
+  # This class represent an enumeration type. The only reason to bind
+  # an enumeration in Ruby with something more than than an integer
+  # conversion is so that you can actually validate the parameter
+  # passed so that an exception is thrown if the value is out of scope.
+  class Enum < Element
+    def initialize(name, parent, ctype = nil) # :notnew
+      super()
+
+      @name = name
+      @parent = parent
+
+      @cprefix = "#{@parent.cname}::" if @parent
+      @cname = "#{@cprefix}#{@name}"
+      
+      @varname = "#{@cname.gsub("::", "_")}"
+      @cname = ctype if ctype
+  
+      @values = []
+
+      @declaration_template = Templates["EnumDeclarations"]
+      @definition_template = Templates["EnumDefinitions"]
+      @initialization_template = "!enum_values_init!"
+
+      add_expansion 'enum_values_init',
+        '@values.collect { |name, value| "rb_define_const(!parent_varname!, \"#{name}\", cxx2ruby(#{value}));" }.join("\n")'
+      add_expansion 'enum_cases',
+        '@values.collect { |name, value| "case #{value}:" }.join("\n")'
+      add_expansion 'enum_name', '@name'
+      add_expansion 'enum_cname', '@cname'
+      add_expansion 'enum_cprefix', '@cprefix'
+      add_expansion 'enum_varname', '@varname'
+      add_expansion 'parent_varname', '"r#{@parent.varname}"'
+    end
+
+    def add_value(name, value="#{@cprefix}#{name}")
+      @values << [name, value]
+    end 
+  end
+
+end