gecoder-with-gecode 0.7.1

data/vendor/rust/include/rust_checks.hh

@@ -0,0 +1,115 @@
+/* Copyright (c) 2007 David Cuadrado <krawek@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.
+ */
+
+#ifndef __RUST_CHECKS__
+#define __RUST_CHECKS__
+
+#include <ruby.h>
+
+static inline void rust_CheckType(VALUE *a)
+{
+	Check_Type(a[0], NUM2INT(a[1]));
+}
+
+static inline bool isType(VALUE val, int type)
+{
+  int result;
+  if( type == 0x0 ) return false;
+  
+  VALUE args[2];
+  args[0] = (VALUE)val;
+  args[1] = INT2FIX(type);
+  
+  rb_protect( (VALUE(*)(VALUE))rust_CheckType, (VALUE)args, &result);
+  return result == 0;
+}
+
+
+static inline bool is_object(VALUE val)
+{
+  return isType(val, T_OBJECT);
+}
+
+static inline bool is_class(VALUE val)
+{
+  return isType(val, T_CLASS);
+}
+
+static inline bool is_module(VALUE val)
+{
+  return isType(val, T_MODULE);
+}
+
+static inline bool is_fLoat(VALUE val)
+{
+  return isType(val, T_FLOAT);
+}
+
+static inline bool is_string(VALUE val)
+{
+  return isType(val, T_STRING);
+}
+
+static inline bool is_regexp(VALUE val)
+{
+  return isType(val, T_REGEXP);
+}
+
+static inline bool is_array(VALUE val)
+{
+  return isType(val, T_ARRAY);
+}
+
+static inline bool is_int(VALUE val)
+{
+  return isType(val, T_FIXNUM);
+}
+
+static inline bool is_hash(VALUE val)
+{
+  return isType(val, T_HASH);
+}
+
+static inline bool is_symbol(VALUE val)
+{
+  return isType(val, T_SYMBOL);
+}
+
+static inline bool is_bool(VALUE val)
+{
+  return val == Qtrue || val == Qfalse;
+}
+
+static inline bool is_charPtr(VALUE val)
+{
+  char *c = 0;
+  c = reinterpret_cast<char *>(DATA_PTR(val));
+  
+  return c != 0; // FIXME
+}
+
+
+
+
+#endif 
+

data/vendor/rust/include/rust_conversions.hh

@@ -0,0 +1,102 @@
+/* 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.
+ */
+
+#ifndef __RUST_CONVERSIONS__
+#define __RUST_CONVERSIONS__
+
+#include <stdint.h>
+#include <ruby.h>
+
+/* Standard conversions for integer values */
+
+static inline uint32_t ruby2uint(VALUE rval, int argn = -1) {
+  return NUM2UINT(rval);
+}
+
+static inline int32_t ruby2int(VALUE rval, int argn = -1) {
+  return NUM2INT(rval);
+}
+
+static inline VALUE cxx2ruby(int32_t val) {
+  return INT2FIX(val);
+}
+
+static inline VALUE cxx2ruby(uint32_t val) {
+  return INT2FIX(val);
+}
+
+static inline VALUE cxx2ruby(double val) {
+  return rb_float_new(val);
+}
+
+/* Standard conversions for stdint-provided types */
+/* TODO: replace these with something more comples but that properly
+   handle a try to convert a number too big to stay into the size
+   requested.
+*/
+#define ruby2uint32_t ruby2uint
+#define ruby2uint16_t ruby2uint
+#define ruby2uint8_t  ruby2uint
+
+#define ruby2int32_t  ruby2int
+#define ruby2int16_t  ruby2int
+#define ruby2int8_t   ruby2int
+
+/* Conversion for common types (like strings */
+
+static inline int *ruby2intArray(VALUE rval, int argn = -1) {
+  int i;
+  RArray *array = RARRAY(rval);
+  int* ret = (int*)malloc(array->len*sizeof(int)); // FIXME: Leak!!!
+  for(i = 0; i < array->len; i++)
+  {
+    ret[i] = NUM2INT(array->ptr[i]);
+  }
+  return ret;
+}
+
+static inline char *ruby2charPtr(VALUE rval, int argn = -1) {
+  Check_Type(rval, T_STRING);
+  return StringValuePtr(rval);
+}
+
+static inline VALUE cxx2ruby(const char *val) {
+  if ( ! val ) return Qnil;
+  return rb_str_new2(val);
+}
+
+static inline VALUE cxx2ruby(const std::string &str) {
+  return rb_str_new2(str.c_str());
+}
+
+/* Booleans conversion */
+
+static inline VALUE cxx2ruby(bool val) {
+  return val ? Qtrue : Qfalse;
+}
+
+static inline bool ruby2bool(VALUE rval, int argn = -1) {
+  return !( rval == Qnil || rval == Qfalse );
+}
+
+#endif

data/vendor/rust/rust.rb

@@ -0,0 +1,67 @@
+# 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 'pathname'
+
+# Rust is a Ruby bindings generator, developed by Diego Pettenò
+# <flameeyes@gmail.com>, based on a simpler Ruby bindings generator
+# that was used for RubyTag++ and ruby-hunspell.
+#
+# The original bindings generator was designed to permit a 1:1 mapping
+# between C++ classes and Ruby classes, as otherwise writing Ruby
+# bindings for a C++-based library would have consisted of a long
+# series of generic functions to convert the types from one language
+# to the other and to call the methods.
+#
+# Most C bindings, instead, either writes a lot of C code to create
+# "fake" Classes out of a vaguely object-oriented C API, or simply
+# create a module where to put all the C functions to call.
+#
+# The objective of Rust is to allow the description of a C or C++
+# interface, through the creation of 1:1 class mappings or the design
+# of "fake" classes out of C functions, without the need to actually
+# write all the generic code, as that does not really change beside
+# names, types and parameters.
+module Rust
+
+  # The Template singleton class is used to simulate a big hash of
+  # templates, loaded with the data from the templates/ subdirectory.
+  # In truth the templates are loaded only when requested, removing
+  # the one-line comments found inside the files (as they are usually
+  # just for documenting that particular template). 
+  class Templates
+    @cache = { }
+    @tpls_dir = (Pathname.new File.dirname(__FILE__)) + "rust/templates"
+
+    def Templates.[](name)
+      return @cache[name].dup if @cache[name]
+
+      pn = @tpls_dir + "#{name}.rusttpl"
+      raise "Template #{name} not found." unless pn.exist?
+
+      @cache[name] = pn.read.gsub(/\/\/.*$\n?/, '')
+      return @cache[name].dup
+    end
+  end
+end
+
+require 'rust/bindings'

data/vendor/rust/rust/attribute.rb

@@ -0,0 +1,51 @@
+# Copyright (c) 2007 David Cuadrado <krawek@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
+  class Attribute < Element
+    def initialize(name, type, opts)
+      super()
+      
+      @name = name
+      @type = Type.new(type)
+      @options = opts
+      
+      @declaration_template = ""
+      @definition_template = Templates["AttributeDefinition"]
+      @prototype_template = "void set!attribute_bindname!(VALUE self, VALUE val);\nVALUE get!attribute_bindname!(VALUE self);\n"
+      @initialization_template = Templates["AttributeInitBinding"]
+      
+      
+      add_expansion 'parent_varname', "@options[:parent].varname"
+      add_expansion 'attribute_bindname', "@name"
+      add_expansion 'attribute_type', "@type"
+      add_expansion 'attribute_name', "@name"
+    end
+    
+  end
+end
+
+

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