gecoder-with-gecode 0.7.1-mswin32

data/vendor/rust/README

@@ -0,0 +1,28 @@
+When I wanted to write a GUI tagger for KDE using Korundum (KDE Ruby
+bindings), I discovered to my sadness that most of the tagging
+extensions for Ruby were simple bindings for the C interface of the
+most common TagLib library (that is written in C++ instead); writing
+bindings for the C++ interface was quite a complex task, and boring as
+it was to copy and paste the same code over and over.
+
+For this reason I started first writing a simple extensions generator
+that used a YAML description of the namespaces and the classes to
+write bindings for. This method worked fine for what I was working on
+(RubyTag++), and also allowed me to write quite quickly some Ruby
+bindings for Hunspell too.
+
+Unfortunately this generator was not adaptable enough to write
+bindings for C libraries that used some object oriented interfaces,
+and was a mess to extend to provide bindings more suitable to some
+different cases than the ones I've already used the script for.
+
+For this reason I've started working on Rust: a more flexible
+extensions builder, that allowed to bind even C libraries by faking
+some classes on Ruby (although I haven't implemented this yet).
+
+Hopefully in the future Rust can be used to easily produce Ruby
+bindings for a number of libraries that currently aren't available at
+all.
+
+To contact me, send me patches or comments, just write to
+<flameeyes@gmail.com> .

data/vendor/rust/bin/cxxgenerator.rb

@@ -0,0 +1,93 @@
+
+require 'rust/cppifaceparser'
+
+
+if __FILE__ == $0
+  def usage
+    puts "Use: #{File.basename($0)} [header] [module name] [output file]"
+  end
+  
+  parser = Rust::Cpp::IfaceParser.new
+  
+  if ARGV.size != 3 or not File.exists?(ARGV[0].to_s)
+    usage
+    exit 0
+  end
+  
+  header = ARGV[0]
+  namespace = ARGV[1]
+  outputfile = ARGV[2]
+  outputfile += ".rb" if not outputfile =~ /\.rb$/
+  
+  classes = parser.parseFile(header)
+  
+  rust = %@
+require 'rust'
+
+Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "#{namespace}" do |b|
+  b.include_header '#{header}', Rust::Bindings::HeaderGlobal
+  b.add_namespace "#{namespace}", "" do |ns|
+@
+  classes.each { |klass|
+    rust += %@  ns.add_cxx_class "#{klass[:name]}" do |klass|\n@
+    klass[:constructors].each { |constructor|
+      rust += "    klass.add_constructor "
+      if not constructor[:params].empty? and not constructor[:params].detect { |p| p[:type] =~ /void/ }
+        rust += "do |method|\n"
+        constructor[:params].each { |param|
+          rust += %@      method.add_parameter "#{param[:type]}", "#{param[:name]}"\n@
+        }
+        rust += "    end"
+      end
+      rust += "\n"
+    }
+    
+    klass[:methods].each { |method|
+      comment_method = false
+      if method[:params].detect { |p| p[:type] =~ /\s*\*\s*\*/ }
+        $stderr << "Ignoring method: #{method[:name]}\n"
+        comment_method = true
+      end
+      
+      rust += "# " if comment_method
+      rust += %@    klass.add_method "#{method[:name]}", "#{method[:type]}"@
+      if not method[:params].empty? and not method[:params].detect { |p| p[:type] =~ /void/ }
+        rust += " do |method|\n" if not method[:params].empty?
+        
+        
+        method[:params].each { |param|
+          rust += "# " if comment_method
+          rust += %@      method.add_parameter "#{param[:type]}", "#{param[:name]}"\n@
+        }
+        rust += "# " if comment_method
+        rust += "    end"
+      end
+      
+      rust += "\n"
+    }
+    rust += "    end\n" 
+  }
+  
+  rust += %@
+  end
+end
+@
+  
+  File.open( outputfile, "w" ) { |f|
+    f << rust << "\n"
+  }
+  
+  # Create configure.rb
+  File.open( File.dirname(outputfile)+"/configure.rb", "w" ) { |f|
+    f << %@
+require 'mkmf'
+find_header("rust_conversions.hh", "./include" )
+eval File.open("#{File.basename(outputfile)}").readlines.to_s
+create_makefile("#{namespace}")
+    @
+  }
+  
+end
+
+
+

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
+
+