gecoder-with-gecode 0.7.1-mswin32

data/vendor/rust/rust/bindings.rb

@@ -0,0 +1,172 @@
+# 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/namespace'
+
+module Rust
+  # Base class to use to create bindings for ruby.
+  # You shouldn't instantiate this manually, but rather use the
+  # create_bindings function.
+  class Bindings
+    # Constant to use with Bindings.create_bindings to state that the
+    # bindings that are to be created are for a C library.
+    LangC = "c"
+
+    # Constant to use with Bindings.create_bindings to state that the
+    # bindings that are to be created are for a C++ library.
+    LangCxx = "cxx"
+
+    # Constant to use with include_header method to state that the
+    # included header is a system library header.
+    HeaderGlobal = "global"
+
+    # Constant to use with include_header method to state that the
+    # included header is a local header.
+    HeaderLocal = "local"
+
+    def initialize(name, lang) # :notnew:
+      @name = name
+      @lang = lang
+
+      @modules = Array.new
+      @custom_definition = Array.new
+      @custom_initialization = Array.new
+      
+      @cxx_includes = ""
+      @c_includes = ""
+    end
+
+    # This function is called when creating Ruby bindings for a
+    # library.
+    #
+    # The first parameter has to be one between Rust::Bindings::LangC
+    # or Rust::Bindings::LangCxx, and tells Rust which programming
+    # language the library to bind is written into.
+    #
+    # Please note that Rust always generates C++ code even when
+    # binding a library written in C, as STL templates are used all
+    # over the generics code.
+    def Bindings.create_bindings(lang, name)
+      bindings = 
+        case lang
+        when Bindings::LangCxx, Bindings::LangC
+          bindings = Bindings.new(name, lang)
+        else
+          raise ArgumentError, "#{lang} is not a valid value for type parameter"
+        end
+
+      yield bindings
+
+      header = File.new("#{name}.hh", File::CREAT|File::TRUNC|File::RDWR)
+      unit = File.new("#{name}.cc", File::CREAT|File::TRUNC|File::RDWR)
+      
+      header.puts bindings.header
+      unit.puts bindings.unit
+
+      header.close
+      unit.close
+    end
+
+    # Adds an include header with the specified name.
+    # This function adds to the list of header files to include the
+    # one with the specified name.
+    #
+    # If the scope paramether is set to Bindings.HeaderLocal, the name of
+    # the header file will be enclosed in double quotes ("") while
+    # including it, while it will be included it in angle quotes if
+    # the parameter is set to Bindings.HeaderGlobal (the default).
+    def include_header(name, scope = Bindings::HeaderGlobal, lang = @lang)
+      name = 
+        case scope
+        when HeaderLocal then "\"#{name}\""
+        when HeaderGlobal then "<#{name}>"
+        else
+          raise ArgumentError, "#{scope} not a valid value for scope parameter."
+        end
+
+      case lang
+      when Bindings::LangCxx
+        @cxx_includes << "\n#include #{name}"
+      when Bindings::LangC
+        @c_includes << "\n#include #{name}"
+      end
+    end
+
+    # Binds a new Namespace to a Ruby module; the name parameter is
+    # used as the name of the module, while the cxxname one (if not
+    # null) is used to indicate the actual C++ namespace to use; when
+    # binding a C library, you should rather use the add_module
+    # function, although that's just a partial wrapper around this one.
+    def add_namespace(name, cxxname = nil)
+      cxxname = name if cxxname == nil 
+
+      ns = Namespace.new(name, cxxname)
+
+      yield ns
+
+      @modules << ns
+    end
+
+    # Create a new Ruby module with the given name; this is used when
+    # binding C libraries, as they don't use namespace, so you have to
+    # create the modules from scratch.
+    def add_module(name)
+      add_namespace(name, "")
+    end
+
+    # Returns the content of the header for the bindings, recursively
+    # calling the proper functions to get the declarations for the
+    # modules bound and so on.
+    #
+    # This should *never* be used directly
+    def header
+      Templates["BindingsHeader"].
+        gsub("!bindings_name!", @name).
+        gsub("!modules_declaration!", @modules.collect { |ns| ns.declaration }.join("\n")).
+        gsub("!cxx_includes!", @cxx_includes).
+        gsub("!c_includes!", @c_includes)
+    end
+
+    # Returns the content of the unit for the bindings, recursively
+    # calling the proper functions to get the definitions and the
+    # initialisation function for the modules bound and so on.
+    #
+    # This should *never* be used directly
+    def unit
+      Templates["BindingsUnit"].
+        gsub("!bindings_name!", @name).
+        gsub("!modules_initialization!", @modules.collect { |ns| ns.initialization }.join("\n")).
+        gsub("!modules_definition!", @modules.collect { |ns| ns.definition }.join("\n")).
+        gsub("!custom_definition!", @custom_definition.join("\n")).
+        gsub("!custom_initialization!", @custom_initialization.join("\n"))
+    end
+    
+    def add_custom_definition(element)
+      @custom_definition << element
+    end
+    
+    def add_custom_initialization(initialization)
+      @custom_initialization << initialization
+    end
+  end
+
+end

data/vendor/rust/rust/class.rb

@@ -0,0 +1,339 @@
+# 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/container'
+require 'rust/function'
+require 'rust/attribute'
+require 'rust/type'
+
+module Rust
+  class Class < Container
+    attr_accessor :bindname
+    attr_accessor :function_mark
+    attr_reader :name, :cname
+    attr_reader :varname, :varcname, :ptrmap, :function_free, :function_map_free, :parent_varname
+
+    # Rust::Namespace object for the class, used to get the proper C++
+    # name.
+    attr_reader :namespace
+
+    # This function initializes the Class instance by setting the
+    # values to the attributes defining its namespace, name
+    # and a few other needed information.
+    #
+    # Don't call this function directly, use Namespace.add_cxx_class
+    def initialize(name, namespace, bindname = name.split("::").last ) # :notnew:
+      super()
+      
+      @name = name
+      @namespace = namespace
+      
+      type = Type.new(complete_name)
+      @varname = type.valid_name
+      @parent_varname = "rb_cObject"
+      
+      @ptrmap = "#{type.valid_name}Map"
+      @function_free = "#{varname}_free"
+      @function_map_free = "#{varname}_free_map_entry"
+      @function_mark = "#{varname}_mark"
+
+      @cname = @namespace.cname ? "#{@namespace.cname}::#{@name}" : @name
+      
+      type = Type.new(@cname)
+      @varcname = type.valid_name
+      @bindname = bindname
+
+      @declaration_template = Templates["ClassDeclarations"]
+      @initialization_template = Templates["ClassInitialize"]
+
+      add_expansion 'class_varname', 'varname'
+      add_expansion 'class_varcname', 'varcname'
+      add_expansion 'c_class_name', 'cname'
+#       add_expansion 'c_class_basename', '@name.split("::").last'
+      add_expansion 'bind_name', '@bindname'
+      add_expansion 'class_ptrmap', 'ptrmap'
+      add_expansion 'class_free_function', '@function_free'
+      add_expansion 'class_map_free_function', '@function_map_free'
+      add_expansion 'class_mark_function', '@function_mark'
+      add_expansion 'parent_varname', '@parent_varname'
+    end
+
+    # Adds a new constructor for the class.
+    # This function creates a new constructor method for the C/C++
+    # class to bind, and yields it so that parameters can be added
+    # afterward.
+    def add_constructor
+      constructor = self.class::Constructor.new(self)
+
+      begin
+        yield constructor
+      rescue LocalJumpError
+        # Ignore this, we can easily have methods without parameters
+        # or other extra informations.
+      end if block_given?
+
+      register_function(constructor)
+
+      return constructor
+    end
+
+    # Adds a new method for the class.
+    # This function adds a new generic method for the class. In the
+    # case of C++ classes, this is an actual method of the bound
+    # class, while in case of Class Wrappers, this is just a function
+    # that expects to find a static parameter that is the instance
+    # pointer itself.
+    def add_method(name, return_value = "void", bindname = name)
+      method = self.class::Method.new({ :name => name,
+                            :bindname => bindname,
+                            :return => return_value,
+                            :klass => self
+                          })
+
+      begin
+        yield method
+      rescue LocalJumpError
+        # Ignore this, we can easily have methods without parameters
+        # or other extra informations.
+      end if block_given?
+      
+      register_function(method)
+
+      method
+    end
+    
+    def add_attribute(name, type, bindname = name)
+      attribute = Attribute.new(name, type, { :parent => self })
+      
+      yield attribute if block_given?
+      
+      @children << attribute
+      
+      attribute
+    end
+    
+    def add_operator(name, return_value, bindname = name)
+      operator = Class::Operator.new({ :name => name,
+                            :bindname => bindname,
+                            :return => return_value,
+                            :klass => self
+                          })
+      begin
+        yield operator
+      rescue LocalJumpError
+      end if block_given?
+      
+      register_function(operator)
+      
+      
+      return operator
+    end
+    
+    def complete_name
+        name = @name
+        parent = @parent
+        namespace = @namespace
+        
+        if not parent.nil?
+          name = "#{parent.cname}::#{name}"
+        end
+        
+        if not namespace.nil?
+          name = "#{namespace.cname}::#{name}"
+        end
+        
+        return name if parent.nil?
+        
+        while not parent.parent.nil?
+          name = "#{parent.parent.cname}::#{name}"
+          parent = parent.parent
+        end
+        
+        return name if namespace.nil?
+        
+        while not namespace.parent.nil?
+          name = "#{namespace.parent.cname}::#{name}"
+          namespace = namespace.parent
+        end
+        
+        name
+      end
+
+    # Adds a new variable for the class. It's not an actual variable,
+    # as hopefully there aren't global or class public variables in
+    # any library.
+    # These virtual variables have setter and getter methods, usually
+    # called 'var' and 'setVar' in C++ (or 'getVar' and 'setVar'), and
+    # are mapped to 'var' and 'var=' in Ruby, so that setting the
+    # variable in Ruby will just call the setter method.
+    def add_variable(name, type, getter = nil, setter = nil)
+      getter = name unless getter
+      setter = "set" + name[0..0].capitalize + name[1..-1] unless
+        setter
+
+      method_get = add_method getter, type
+      method_get.add_alias name
+
+      method_set = add_method setter, "void"
+      method_set.add_alias "#{name}="
+
+      begin
+        yield method_get, method_set
+      rescue LocalJumpError
+        # Ignore this, we can easily have methods without parameters
+        # or other extra informations.
+      end if block_given?
+
+      method_set.add_parameter type, "value"
+
+      return [method_get, method_set]
+    end
+
+    # This class is used to represent a method for a C/C++ class bound
+    # in a Ruby extension. Through an object of this class you can add
+    # parameters and more to the method.
+    class Method < Function
+      
+      # Initialisation function, calls Function.initialize and sets
+      # the important parameters that differs from a generic function
+      def initialize(params) # :notnew:
+        params[:parent] = params[:klass]
+        super
+
+        @varname =
+        "f#{@parent.namespace.name.gsub("::","_")}_#{@parent.name}_#{@name}"
+
+        @definition_template = Templates["CxxMethodStub"]
+        @initialization_template = Templates["MethodInitBinding"]
+      end
+    end
+    
+    class Operator < Function
+      attr_reader :position # 1: pre 2: mid 3: post 4: mixed
+      
+      def initialize(params)
+        params[:parent] = params[:klass]
+        super
+        
+        type = Type.new(@parent.namespace.cname+"::"+@parent.cname)
+        
+        @varname = "f#{type.valid_name}_#{valid_name}"
+        
+        @definition_template = Templates["CxxMethodStub"]
+        @initialization_template = Templates["MethodInitBinding"]
+      end
+      
+      def bind_call(nparam = nil)
+        case @return
+          when nil
+            raise "nil return value is not supported for non-constructors."
+          when "void"
+            return "#{raw_call(nparam)}; return Qnil;\n"
+          else
+            type = Type.new(@return)
+            if not @return.include?("*") and not type.native?
+              "return cxx2ruby( new #{@return.gsub("&", "")}(#{raw_call(nparam)}), true );\n" # XXX: needs a copy constructor
+            else
+              "return cxx2ruby( static_cast<#{@return}>(#{raw_call(nparam)}) );\n"
+            end
+        end
+      end
+      
+      private
+      def raw_call(nparam = nil)
+        case @position
+          when 1 # pre
+            "#{@name} (*tmp)"
+          when 2 # mid
+            "(*tmp) #{@name[0].chr} #{params_conversion(nparam)} #{@name[@name.length-1].chr} "
+          when 4
+            "(*tmp) #{@name[0].chr} #{self.parameters[0].conversion} #{@name[1].chr} #{@name[@name.length-1].chr} #{self.parameters[1].conversion}" if self.parameters.size == 2
+          else
+            "(*tmp) #{@name} #{params_conversion(nparam)} "
+        end
+      end
+      
+      def valid_name
+        case @name
+          when "+"
+            @position = 3
+            "plusop"
+          when "-"
+            @position = 3
+            "minusop"
+          when "*"
+            @position = 3
+            "multop"
+          when "/"
+            @position = 3
+            "divop"
+          when /\[\s*\]=/
+            @position = 4
+            "ateqop"
+          when /\[\s*\]/
+            @position = 2
+            "atop"
+          when "=="
+            @position = 3
+            "equalop"
+          when "!="
+            @position = 3
+            "notequalop"
+          when "<<"
+            @position = 3
+            "outstream"
+          when ">>"
+            @position = 3
+            "intstream"
+          when "!"
+            @position = 1
+            "notop"
+          else
+            @position = 3
+            "undefop_#{@name[0].chr.to_i}#{rand(1024)}"
+        end
+      end
+    end
+
+    # This class is used to represente the constructor of a C++ class
+    # bound in a Ruby extension.
+    class Constructor < Function
+      
+      # Initialisation function, calls Function.initialise, but accepts
+      # only a single parameter, the class the constructor belong to.
+      def initialize(klass) # :notnew:
+        super({
+                :parent => klass,
+                :bindname => "initialize",
+                :name => klass.name
+              })
+
+        @definition_template = Templates["ConstructorStub"]
+      end
+
+      def bind_call(nparam = nil)
+        "#{raw_call(nparam)};\n"
+      end
+    end
+
+  end
+end