gecoder-with-gecode 0.7.1

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_type!(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 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,91 @@
+//-*-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) {
+  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!;
+
+!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;
+}

data/vendor/rust/rust/templates/FunctionDefinition.rusttpl

@@ -0,0 +1,9 @@
+//-*-c++-*-
+// Template of a generic C function call
+
+!function_prototype! {
+  !function_call!
+  
+  rb_raise(rb_eArgError, "Mandatory parameters missing"); // FIXME
+  return Qnil; 
+}

data/vendor/rust/rust/templates/FunctionInitAlias.rusttpl

@@ -0,0 +1,5 @@
+//-*-c++-*-
+// Template for the init function snipped registering an alias for a
+// function or a method.
+
+  rb_define_alias(r!parent_varname!, "!function_alias!", "!function_bindname!");

data/vendor/rust/rust/templates/FunctionInitBinding.rusttpl

@@ -0,0 +1,9 @@
+//-*-c++-*-
+// Template for the init function snippet registering a function.
+// Note that in the case of a method, !parent_varname! would be a
+// synonim for !class_varname!.
+
+  rb_define_module_function(r!parent_varname!, "!function_bindname!",
+    RUBY_METHOD_FUNC(!function_varname!), !function_paramcount!);
+
+  !function_aliases!

data/vendor/rust/rust/templates/MethodInitBinding.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!.
+
+  rb_define_method(r!parent_varname!, "!function_bindname!",
+    RUBY_METHOD_FUNC(!function_varname!), !function_paramcount!);
+
+  !function_aliases!

data/vendor/rust/rust/templates/ModuleDeclarations.rusttpl

@@ -0,0 +1,3 @@
+//-*-c++-*-
+
+extern VALUE r!namespace_varname!;

data/vendor/rust/rust/templates/ModuleDefinitions.rusttpl

@@ -0,0 +1,3 @@
+//-*-c++-*-
+
+VALUE r!namespace_varname!;

data/vendor/rust/rust/templates/StandaloneClassDeclarations.rusttpl

@@ -0,0 +1,7 @@
+//-*-c++-*-
+
+typedef std::map<VALUE, !c_class_name!*> T!class_ptrmap!;
+extern T!class_ptrmap! !class_ptrmap!;
+static void !class_varname!_free(void *p);
+static void !class_varname!_mark(void *p);
+static void !class_varname!_free_map_entry(void *p);

data/vendor/rust/rust/templates/VariableFunctionCall.rusttpl

@@ -0,0 +1,14 @@
+//-*-c++-*-
+// Template for a variable arguments function call
+  bool ok = false;
+  
+  switch(argc) {
+!calls!
+  default: ok = false; break;
+  }
+  
+  if ( !ok )
+  {
+	rb_raise(rb_eArgError, "Mantatory parameters missing");
+	return Qnil;
+  }