gecoder-with-gecode 0.9.0-x86-mswin32-60

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

data/vendor/rust/rust/templates/AttributeDefinition.rusttpl

@@ -0,0 +1,17 @@
+//-*-c++-*-
+// Template of a generic C function call
+
+VALUE set!parent_varname!!attribute_bindname!(VALUE self, VALUE val) {
+  !c_class_name!* tmp = ruby2!class_varcname!Ptr(self);
+  if ( ! tmp ) return Qnil;
+  
+  tmp->!attribute_name! = ruby2!attribute_convert_name!(val);
+  return Qnil;
+}
+
+VALUE get!parent_varname!!attribute_bindname!(VALUE self) {
+  !c_class_name!* tmp = ruby2!class_varcname!Ptr(self);
+  if ( ! tmp ) return Qnil;
+  
+  return cxx2ruby(static_cast<!attribute_type!>(tmp->!attribute_name!));
+}

data/vendor/rust/rust/templates/AttributeInitBinding.rusttpl

@@ -0,0 +1,9 @@
+//-*-c++-*-
+// Template for the init function snippet registering a method.
+// Note that in the case of a method, !parent_varname! would be a
+// synonim for !class_varname!.
+  
+  // Set
+  rb_define_method(r!parent_varname!, "!attribute_bindname!=", RUBY_METHOD_FUNC(set!parent_varname!!attribute_bindname!), 1);
+  // Get
+  rb_define_method(r!parent_varname!, "!attribute_bindname!", RUBY_METHOD_FUNC(get!parent_varname!!attribute_bindname!), 0);

data/vendor/rust/rust/templates/BindingsHeader.rusttpl

@@ -0,0 +1,24 @@
+//-*-c++-*-
+// General template for the header file (.hh) of the bindings.
+// This is the base that's recursively expanded to create the actual
+// header file.
+//
+// Please note that the ruby header and the C header files coming
+// from the bound library are included with C linkage rules, while
+// the rest of the header follows C++ linkage rules.
+
+extern "C" {
+  #include <ruby.h>
+  !c_includes!
+}
+
+!cxx_includes!
+
+/* This is for the ptrMap */
+#include <map>
+
+namespace Rust_!bindings_name! {
+
+!modules_declaration!
+
+}

data/vendor/rust/rust/templates/BindingsUnit.rusttpl

@@ -0,0 +1,46 @@
+//-*-c++-*-
+// General template for the unit file (.cc) of the bindings.
+// This is the base that's recursively expanded to create the actual
+// header file.
+//
+// Please note that the visibility is set to the Init function only
+// if the build processo found it, so that all the other functions
+// and types are actually considered hidden, and thus not exported by
+// the extension. Unfortunately GCC's libstdc++ does not correctly
+// hide all of its symbols yet.
+
+// This is needed here because I need to put the rust_conversions.hh
+// include inside these bindings' namespace.
+#include <string>
+
+#include "!bindings_name!.hh"
+
+#ifdef DEBUG
+#include <stdio.h> /* Used for fprintf */
+#endif
+
+namespace Rust_!bindings_name! {
+
+#include <rust_conversions.hh>
+#include <rust_checks.hh>
+
+!custom_definition!
+
+!modules_definition!
+
+}
+
+using namespace Rust_!bindings_name!;
+
+extern "C" {
+
+#ifdef HAVE_VISIBILITY
+void Init_!bindings_name!() __attribute__((visibility("default")));
+#endif
+
+void Init_!bindings_name!() {
+!modules_initialization!
+!custom_initialization!
+} /* Init_!bindings_name! */
+
+}

data/vendor/rust/rust/templates/CWrapperClassDefinitions.rusttpl

@@ -0,0 +1,64 @@
+//-*-c++-*-
+
+VALUE r!class_varname!;
+T!class_ptrmap! !class_ptrmap!;
+
+!c_class_name!* ruby2!class_varcname!Ptr(VALUE rval) {
+   !c_class_name!* ptr;
+   Data_Get_Struct(rval, !c_class_name!, ptr);
+
+   if ( ptr ) return reinterpret_cast< !c_class_name!* >(ptr);
+
+   T!class_ptrmap!::iterator it = !class_ptrmap!.find(rval);
+
+   if ( it == !class_ptrmap!.end() ) {
+      rb_raise(rb_eRuntimeError, "Unable to find !c_class_name! instance for value %x (type %d)\\n", rval, TYPE(rval));
+      return NULL;
+   }
+
+   return reinterpret_cast< !c_class_name!* >((*it).second);
+}
+
+
+!c_class_name!& ruby2!class_varcname!Ptr(VALUE rval) {
+  return *ruby2!class_varcname!Ptr(rval);
+}
+
+
+VALUE cxx2ruby(!c_class_name!* instance) {
+  if ( instance == NULL ) return Qnil;
+
+  T!class_ptrmap!::iterator it, eend = !class_ptrmap!.end();
+
+  for(it = !class_ptrmap!.begin(); it != eend; it++)
+     if ( (*it).second == (!c_class_name!*)instance ) break;
+
+   if ( it != !class_ptrmap!.end() )
+      return (*it).first;
+   else {
+      VALUE klass = r!class_varname!;
+
+      VALUE rval = Data_Wrap_Struct(klass, 0, 0, (void*)instance);
+      !class_ptrmap![rval] = instance;
+
+#ifdef DEBUG      
+      fprintf(stderr, "rust: wrapping instance %p in value %x (type %d)\\n", instance, rval, TYPE(rval));
+#endif
+
+      return rval;
+   }
+}
+
+static VALUE !class_varname!_alloc(VALUE self) {
+   return Data_Wrap_Struct(self, 0, !class_free_function!, 0);
+}
+
+static void !class_varname!_free(void *p) {
+  T!class_ptrmap!::iterator it, eend = !class_ptrmap!.end();
+  for(it = !class_ptrmap!.begin(); it != eend; it++)
+     if ( (*it).second == (!c_class_name!*)p ) {
+        !class_ptrmap!.erase(it); break;
+     }
+
+  !cleanup_functions!;
+}

data/vendor/rust/rust/templates/ClassDeclarations.rusttpl

@@ -0,0 +1,7 @@
+//-*-c++-*-
+
+extern VALUE r!class_varname!;
+VALUE cxx2ruby(!c_class_name!* instance, bool free = false, bool create_new_if_needed = true);
+bool is_!class_varname!(VALUE val);
+!c_class_name!* ruby2!class_varcname!Ptr(VALUE rval, int argn = -1);
+!c_class_name!& ruby2!class_varcname!(VALUE rval, int argn = -1);

data/vendor/rust/rust/templates/ClassInitialize.rusttpl

@@ -0,0 +1,6 @@
+//-*-c++-*-
+// Template for the initialization calls for a C/C++ class 
+
+  r!class_varname! = rb_define_class_under(r!namespace_varname!,
+    "!bind_name!", !parent_varname!);
+  rb_define_alloc_func(r!class_varname!, !class_varname!_alloc);

data/vendor/rust/rust/templates/ConstructorStub.rusttpl

@@ -0,0 +1,21 @@
+//-*-c++-*-
+// Template of a C++ Constructor stub, the function used to convert the
+// parameters from Ruby objects to C++, and then call the real C++ constructor.
+
+!function_prototype! {
+  !c_class_name!* tmp;
+  Data_Get_Struct(self, !c_class_name!, tmp);
+
+  /* The exception is thrown already by ruby2* if not found */
+
+  !function_call!;
+
+  DATA_PTR(self) = tmp;
+  !class_ptrmap![self] = tmp;
+
+#ifdef DEBUG
+  fprintf(stderr, "rust: creating new instance of !c_class_name! (%p) with value %x\n", tmp, self);
+#endif
+
+  return self;
+}

data/vendor/rust/rust/templates/CxxClassDefinitions.rusttpl

@@ -0,0 +1,100 @@
+//-*-c++-*-
+
+VALUE r!class_varname!;
+
+bool is_!class_varname!(VALUE val)
+{
+  if ( isType(val, T_DATA) )
+  {
+    !c_class_name! *obj = 0;
+    
+    Data_Get_Struct(val, !c_class_name!, obj);
+    
+    if( obj == 0 ) return false;
+    
+    return rb_obj_is_kind_of(val, r!class_varname!) == Qtrue;
+  }
+  
+  return false;
+}
+
+!c_class_name!* ruby2!class_varcname!Ptr(VALUE rval, int argn) {
+   if(rval == Qnil || rval == 0) return 0;
+
+   if( ! is_!class_varname!(rval) )
+   {
+     VALUE klass = rb_funcall(rval, rb_intern("class"), 0);
+     
+     if( argn > 0)
+       rb_raise(rb_eArgError, "Expecting !c_class_name! given %s for argument %d", RSTRING(rb_funcall(klass, rb_intern("to_s"), 0))->ptr, argn);
+     else
+		rb_raise(rb_eArgError, "Expecting !c_class_name! given %s", RSTRING(rb_funcall(klass, rb_intern("to_s"), 0))->ptr, argn);
+     return 0;
+   }
+   
+   !c_class_name!* ptr;
+   Data_Get_Struct(rval, !c_class_name!, ptr);
+
+   if ( ptr ) return dynamic_cast< !c_class_name!* >(ptr);
+
+   T!class_ptrmap!::iterator it = !class_ptrmap!.find(rval);
+
+   if ( it == !class_ptrmap!.end() ) {
+      rb_raise(rb_eRuntimeError, "Unable to find !c_class_name! instance for value %x (type %d)\\n", rval, TYPE(rval));
+      return NULL;
+   }
+
+   return dynamic_cast< !c_class_name!* >((*it).second);
+}
+
+!c_class_name!& ruby2!class_varcname!(VALUE rval, int argn) {
+  return *ruby2!class_varcname!Ptr(rval, argn);
+}
+
+VALUE cxx2ruby(!c_class_name!* instance, bool free, bool create_new_if_needed) {
+  if ( instance == NULL ) return Qnil;
+
+  T!class_ptrmap!::iterator it, eend = !class_ptrmap!.end();
+
+#ifdef DEBUG      
+  fprintf(stderr, "rust: searching for !c_class_name! %p\n", instance);
+#endif
+
+  for(it = !class_ptrmap!.begin(); it != eend; it++)
+     if ( (*it).second == (!c_class_name!*)instance ) break;
+
+   if ( it != !class_ptrmap!.end() )
+      return (*it).first;
+   else {
+#ifdef DEBUG      
+      fprintf(stderr, "rust: failed to find match for %p\n", instance);
+#endif
+      if(!create_new_if_needed) return Qnil;
+   
+      VALUE klass = r!class_varname!;
+
+!test_children!
+      
+      VALUE rval;
+      if( !free )
+      {
+        rval = Data_Wrap_Struct(klass, 0, !class_map_free_function!, (void*)instance);
+      }
+      else
+      {
+        rval = Data_Wrap_Struct(klass, !class_mark_function!, !class_free_function!, (void*)instance);
+      }
+      
+      !class_ptrmap![rval] = instance;
+
+#ifdef DEBUG      
+      fprintf(stderr, "rust: wrapping instance %p in value %x (type %d)\\n", instance, rval, TYPE(rval));
+#endif
+
+      return rval;
+   }
+}
+
+static VALUE !class_varname!_alloc(VALUE self) {
+   return Data_Wrap_Struct(self, !class_mark_function!, !class_free_function!, 0);
+}

data/vendor/rust/rust/templates/CxxMethodStub.rusttpl

@@ -0,0 +1,12 @@
+//-*-c++-*-
+// Template of a C++ Method stub, the function used to convert the
+// parameters from Ruby objects to C++, and then call the real C++ function.
+
+!function_prototype! {
+  !c_class_name!* tmp = ruby2!class_varcname!Ptr(self);
+  if ( ! tmp ) return Qnil;
+
+  // The exception is thrown already by ruby2*
+
+  !function_call!
+}

data/vendor/rust/rust/templates/CxxStandaloneClassDefinitions.rusttpl

@@ -0,0 +1,26 @@
+//-*-c++-*-
+
+T!class_ptrmap! !class_ptrmap!;
+
+static void !class_varname!_free(void *p) {
+	!class_map_free_function!(p);
+  delete (!c_class_name!*)p;
+}
+
+static void !class_varname!_free_map_entry(void *p) {
+#ifdef DEBUG      
+  fprintf(stderr, "rust: Freeing %p (!class_varname!) \\n", p);
+#endif
+
+  T!class_ptrmap!::iterator it, eend = !class_ptrmap!.end();
+  for(it = !class_ptrmap!.begin(); it != eend; it++)
+     if ( (*it).second == (!c_class_name!*)p ) {
+        !class_ptrmap!.erase(it); break;
+     }
+}
+
+static void !class_varname!_mark(void *p) {
+#ifdef DEBUG      
+  fprintf(stderr, "rust: Marking %p (!class_varname!) \\n", p);
+#endif
+}

data/vendor/rust/rust/templates/EnumDeclarations.rusttpl

@@ -0,0 +1,3 @@
+//-*-c++-*-
+
+!enum_cname! ruby2!enum_varname!(VALUE rval, int argn = -1);

data/vendor/rust/rust/templates/EnumDefinitions.rusttpl

@@ -0,0 +1,29 @@
+//-*-c++-*-
+
+!enum_cname! ruby2!enum_varname!(VALUE rval, int argn) {
+  int cval = ruby2int(rval, argn);
+
+  switch(cval) {
+    !enum_cases!
+      return static_cast<!enum_cname!>(cval);
+    default:
+      if( argn > 0)
+        rb_raise(rb_eArgError, "value %d for enum !enum_name! is out of bound for argument %d", cval, argn);
+      else
+        rb_raise(rb_eArgError, "value %d for enum !enum_name! is out of bound", cval);
+      return static_cast<!enum_cname!>(-1);
+  }
+}
+
+bool is_!enum_varname!(VALUE rval) {
+  if( is_int(rval) )
+  {
+    switch(ruby2int(rval))
+    {
+      !enum_cases!
+        return true;
+    }
+  }
+  
+  return false;
+}