gecoder-with-gecode 0.7.1

data/vendor/rust/rust/function.rb

@@ -0,0 +1,407 @@
+# 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 'set'
+require 'rust/element'
+require 'rust/type'
+
+module Rust
+  # This class represent an abstracted bound function; it is not
+  # supposed to be used directly, instead its subclass should be used,
+  # like CxxClass::Method.
+  class Function < Element
+    # Class representing a function or method parameter
+    class Parameter < Type
+
+      attr_reader :argname, :optional
+      attr_accessor :custom_conversion
+      attr_accessor :index
+
+      def initialize(type, argname, optional) #:notnew:
+        super(type)
+        @argname = argname
+        @optional = optional
+        @index = -1
+      end
+
+      # Returns the C/C++ call to convert the (named) parameter from its
+      # ruby value to the C/C++ corresponding variable
+      def conversion
+        return internal_conversion(@argname)
+      end
+
+      # Returns the C/C++ call to convert the (indexed) parameter from
+      # its ruby value to the C/C++ corresponding variable, for
+      # variable-argument function calls.
+      def index_conversion(index)
+        raise TypeError, "index not an integer" if index.class != Fixnum
+        return internal_conversion("argv[#{index}]")
+      end
+
+      # Internal conversion funciton used by Parameter.conversion
+      # and Parameter.index_conversion public functions.
+      def internal_conversion(variable)
+         return @custom_conversion.to_s if not @custom_conversion.to_s.empty?
+         if ruby_type?
+           variable
+         else
+           "ruby2#{valid_name}(#{variable}, #{@index})"
+         end
+      end
+      private :internal_conversion
+
+    end
+    
+    # This class describes a parameter with a default value: this
+    # creates a variable-argument function, where this parameter can
+    # be skipped. If missing, the default value will be used.
+    class DefaultParameter < Parameter
+      attr_reader :default
+
+      def initialize(type, name, value)
+        super(type, name, false)
+        
+        @default = value
+      end
+    end
+
+    # This class describe a parameter that is given a static value:
+    # such a parameter won't be available on the Ruby side of the
+    # interface, instead it will be replaced during call with a
+    # static value, that can be a constant value or the name of a
+    # variable that is visible in the scope of the function call, like
+    # the tmp variable (the instance pointer) or another parameter of
+    # the same function, or a function call to transform the value of
+    # another parameter of the function.
+    class StaticParameter < Parameter
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      private :conversion, :index_conversion, :argname, :type
+    end
+
+    attr_reader :varname, :name, :parameters, :optional_count
+    attr_writer :parameters
+
+    # Initialisation function, sets the important parameters from the
+    # params hash provided, and the derived information that are needed.
+    def initialize(params) # :notnew:
+      super()
+
+      @overloads = {}
+      @return = params[:return]
+      @name = params[:name]
+      @bindname = params[:bindname]
+      @parent = params[:parent]
+      @optional_count = 0
+
+      @varname = "f#{@parent.varname}#{@name}"
+
+      @aliases = Set.new
+      @variable = false # Variable arguments function
+
+      @parameters = Array.new
+      nocamel_bindname = @bindname.gsub(/([^A-Z])([A-Z])([^A-Z])/) do
+        |letter| "#{$1}_#{$2.downcase}#{$3}"
+      end
+      
+      @aliases << nocamel_bindname unless nocamel_bindname == @bindname
+
+      @declaration_template = "!function_prototype!;\n"
+      @definition_template = Templates["FunctionDefinition"]
+      @prototype_template = "VALUE !function_varname! ( VALUE self !function_parameters! )"
+      @initialization_template = Templates["FunctionInitBinding"]
+      
+      add_expansion 'function_aliases', '@aliases.collect { |alii| Templates["FunctionInitAlias"].gsub("!function_alias!", alii) }.join("\n")'
+      add_expansion 'function_prototype', '@prototype_template'
+      add_expansion 'function_parameters', 'ruby_parameters'
+      add_expansion 'function_call', 'stub'
+      add_expansion 'function_varname', 'varname'
+      add_expansion 'function_cname', '@name'
+      add_expansion 'function_paramcount', 'paramcount'
+      add_expansion 'function_bindname', '@bindname'
+      add_expansion 'parent_varname', '@parent.varname'
+    end
+
+    # Adds an alias for the function.
+    # The same C++ function can be bound with more than one name,
+    # as CamelCase names in the methods are bound also  with
+    # ruby_style names, so that the users can choose what to use.
+    def add_alias(name)
+      @aliases << name
+      
+      nocamel_alias = name.gsub(/([^A-Z])([A-Z])([^A-Z])/) do
+        |letter| "#{$1}_#{$2.downcase}#{$3}"
+      end
+      
+      @aliases << nocamel_alias unless nocamel_alias == name
+    end
+
+    # Adds a new parameter to the function
+    def add_parameter(name, type, optional = false)
+      param = Parameter.new(name, type, optional)
+      param.index = @parameters.size+1
+
+      if optional
+        @variable = true 
+        @prototype_template = "VALUE !function_varname! ( int argc, VALUE *argv, VALUE self )"
+        @optional_count += 1
+      end
+      
+      yield param if block_given?
+      
+      @parameters << param
+      
+      return param
+    end
+
+    # Adds a parameter with a default value.
+    # See Rust::Function::DefaultParameter
+    def add_parameter_default(name, type, value)
+      @variable = true
+      @prototype_template = "VALUE !function_varname! ( int argc, VALUE *argv, VALUE self )"
+
+      param = DefaultParameter.new(name, type, value)
+
+      @parameters << param
+
+      return param
+    end
+
+    # Adds a constant parameter, see Rust::Function::StaticParameter
+    def add_static_parameter(value)
+      param = StaticParameter.new(value)
+
+      @parameters << param
+
+      return param
+    end
+
+    # Set different, non-default templates for functions, that can be used
+    # when many functions of the bound C/C++ library contains functions
+    # that require to be handled in a particular way.
+    def set_custom(prototype, definition, argc)
+      @definition_template = definition
+      @prototype_template = prototype
+      @custom_paramcount = argc
+      
+      @variable = true if argc == -1
+    end
+
+    # Gets the parameters' count. For variable-arguments functions,
+    # this returns -1, while for other functions the count depends on
+    # the parameters added, as there might be parameters which are
+    # passed constant values (e.g. the instance parameter for class
+    # wrappers), that are not counted for Ruby-side parameters count.
+    def paramcount
+      return @custom_paramcount if not @custom_paramcount.nil?
+      return -1 if @variable
+
+      paramcount = 0
+      @parameters.each do |param|
+        paramcount = paramcount +1 unless param.respond_to?("value")
+      end
+
+      return paramcount
+    end
+
+    # Provides a string with the parameters that are actually 
+    def ruby_parameters
+      @parameters.collect do |param|
+        next if param.respond_to?("value")
+
+        ", VALUE #{param.argname}"
+      end.join
+    end
+
+    # Returns an array of the valid cases for variable-argument calls.
+    # For instance, a function might need _at least_ three parameters,
+    # and can accept _up to_ nine parameters. In that case the range
+    # would be 3..9.
+    # The upper boundary is always the same of paramcount, while the
+    # lower depends on the first optional parameter found. Parameters
+    # with default are like optional parameters.
+    def arguments_range
+      lower_bound = 0
+      @parameters.each do |param|
+        break if (param.respond_to?("default") or param.optional)
+
+        lower_bound = lower_bound +1
+      end
+
+      return lower_bound..paramcount
+    end
+
+    def params_conversion(nparams = nil)
+      return if @parameters.empty?
+
+      variable_arguments = nparams != nil
+      nparams = paramcount unless nparams
+      
+      ret = ""
+      index = 0
+      @parameters.each do |param|
+        # If we're done with the parameters requested, then we're in
+        # the extra loops, which means we break out unless the current
+        # parameter is a default parameter or a constant parameter.
+        break unless index < nparams or
+          param.respond_to?("default") or
+          param.respond_to?("value")
+
+        case
+        when param.respond_to?("value")
+          ret << param.value
+        when (index < nparams and not variable_arguments)
+          ret << param.conversion
+          index = index +1 # Only increment for ruby parameters consumed
+        when (index < nparams and variable_arguments)
+          ret << param.index_conversion(index)
+          index = index +1 # Only increment for ruby parameters consumed
+        when param.respond_to?("default")
+          ret << param.default
+        end
+
+        ret << ","
+      end
+
+      return ret.chomp!(",")
+    end
+    private :params_conversion
+    
+    def raw_call(nparam = nil)
+      if @parent.kind_of?(Namespace)
+          scope = "#{@parent.cname}::"
+      end
+      
+      "#{scope}#{@name}(#{params_conversion(nparam)})"
+    end
+    private :raw_call
+    
+    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"
+        else
+          "return cxx2ruby( static_cast<#{@return}>(#{raw_call(nparam)}) );\n"
+        end
+      end
+    end
+#     private :bind_call
+    
+    
+    def add_overload(function)
+      argc = function.parameters.size
+      if not @overloads.has_key?(argc)
+        @overloads[argc] = []
+        @variable = true
+        
+        @prototype_template = "VALUE !function_varname! ( int argc, VALUE *argv, VALUE self )"
+        
+      end
+      
+      @overloads[argc] << function
+    end
+    
+    def stub
+      return bind_call unless @variable
+      calls = ""
+      
+      
+      overloads = @overloads.dup
+      
+      key = @parameters.size
+      if not overloads.has_key?(key)
+        overloads[key] = [ self ]
+      else
+        overloads[key] << self
+      end
+      
+      options = []
+      overloads.each { |argc, functions|
+        functions.uniq!
+        functions.each { |function|
+          if function.optional_count > 0
+            option = function.dup
+            
+            option.optional_count.times { |i|
+              option.parameters = []
+              0.upto(function.parameters.size() - i - 1) { |pindex|
+                  option.parameters << function.parameters[pindex].dup
+              }
+              
+              options << option
+            }
+          end
+        }
+      }
+      
+      options.each { |opt|
+        overloads.has_key?(opt.parameters.size) ? overloads[opt.parameters.size] << opt : overloads[opt.parameters.size] = [ opt ] 
+      }
+      
+      overloads.each { |argc, functions|
+        call = "     case #{argc}: {\n"
+        current_function_index = 0
+        
+        functions.each { |func|
+          functions.uniq!
+          call += "// Case #{current_function_index}\n"
+          argc.times { |argindex| # Verify types
+            param = func.parameters[argindex]
+            valid_name = param.to_s
+            
+            if not param.native?
+              valid_name.gsub!("Ptr", "")
+            end
+            
+            if param.array?
+              call += "      if( is_array(argv[#{argindex}]) ) {\n" 
+            else
+              call += "      if( is_#{valid_name}(argv[#{argindex}]) ) {\n" 
+            end
+          }
+        
+          call += "           #{func.bind_call(argc)}"
+          call += "           ok = true;\n"
+    call += "}"*argc # closes if's
+    call += "\n"
+    
+    current_function_index += 1
+        }
+        call += "     } break;\n"
+        
+        calls << call
+      }
+      
+      return Templates["VariableFunctionCall"].gsub("!calls!", calls)
+    end
+  end
+end

data/vendor/rust/rust/namespace.rb

@@ -0,0 +1,61 @@
+# 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/cxxclass"
+require "rust/cwrapper"
+require "rust/constants"
+
+module Rust
+
+  class Namespace < Container
+    attr_reader :name, :cname, :varname
+
+    def initialize(name, cname, parent = nil)
+      super()
+
+      @name = name
+      
+      if parent.kind_of?(Namespace)
+        cname = "#{parent.cname}::#{cname}"
+      end
+      
+      @parent = parent
+      @cname = cname == "" ? nil : cname
+      @varname = "#{@name.gsub("::", "_")}"
+
+      @declaration_template = Templates["ModuleDeclarations"]
+      @definition_template = Templates["ModuleDefinitions"]
+      unless parent.kind_of?(Namespace)
+	  @initialization_template = "r!namespace_varname! = rb_define_module(\"!module_name!\");\n"
+      else
+        # TODO this should use the expansion
+        @initialization_template = "r!namespace_varname! = rb_define_module_under(r#{parent.varname}, \"#{@name}\");\n"
+      end
+
+      add_expansion 'module_name', 'name'
+      add_expansion 'namespace_varname', 'varname'
+    end
+
+  end
+
+end