--- /dev/null
+++ b/lib/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 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'

--- /dev/null
+++ b/lib/rust/bindings.rb
@@ -0,0 +1,159 @@
+# 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
+      @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"))
+    end
+  end
+
+end

--- /dev/null
+++ b/lib/rust/class.rb
@@ -0,0 +1,182 @@
+# 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/function'
+
+module Rust
+  class Class < Container
+    attr_reader :name, :cname
+    attr_reader :varname, :varcname, :ptrmap, :function_free, :parent_varname
+
+    # Rust::Namespace object for the class, used to get the proper C++
+    # name.
+    attr_reader :namespace
+
+    # This function initializes the Class instance by setting the
+    # values to the attributes defining its namespace, name
+    # and a few other needed information.
+    #
+    # Don't call this function directly, use Namespace.add_cxx_class
+    def initialize(name, namespace) # :notnew:
+      super()
+
+      @name = name
+      @namespace = namespace
+
+      @varname = "#{@namespace.name.gsub("::", "_")}_#{@name}"
+      @parent_varname = "rb_cObject"
+      
+      @ptrmap = "#{@namespace.name.gsub("::", "_")}_#{@name}_ptrMap"
+      @function_free = "#{varname}_free"
+
+      @cname = @namespace.cname ? "#{@namespace.cname}::#{@name}" : @name
+      @varcname = @cname.sub("*", "Ptr").gsub("::", "_").gsub(' ', '')
+
+      @declaration_template = Templates["ClassDeclarations"]
+      @initialization_template = Templates["ClassInitialize"]
+
+      add_expansion 'class_varname', 'varname'
+      add_expansion 'class_varcname', 'varcname'
+      add_expansion 'c_class_name', 'cname'
+      add_expansion 'c_class_basename', '@name.split("::").last'
+      add_expansion 'class_ptrmap', 'ptrmap'
+      add_expansion 'class_free_function', '@function_free'
+      add_expansion 'parent_varname', '@parent_varname'
+    end
+
+    # Adds a new constructor for the class.
+    # This function creates a new constructor method for the C/C++
+    # class to bind, and yields it so that parameters can be added
+    # afterward.
+    def add_constructor
+      constructor = self.class::Constructor.new(self)
+
+      begin
+        yield constructor
+      rescue LocalJumpError
+        # Ignore this, we can easily have methods without parameters
+        # or other extra informations.
+      end
+
+      @children << constructor
+
+      return constructor
+    end
+
+    # Adds a new method for the class.
+    # This function adds a new generic method for the class. In the
+    # case of C++ classes, this is an actual method of the bound
+    # class, while in case of Class Wrappers, this is just a function
+    # that expects to find a static parameter that is the instance
+    # pointer itself.
+    def add_method(name, return_value = "void", bindname = name)
+      method = self.class::Method.new({ :name => name,
+                            :bindname => bindname,
+                            :return => return_value,
+                            :klass => self
+                          })
+
+      begin
+        yield method
+      rescue LocalJumpError
+        # Ignore this, we can easily have methods without parameters
+        # or other extra informations.
+      end
+
+      @children << method
+
+      return method
+    end
+
+    # Adds a new variable for the class. It's not an actual variable,
+    # as hopefully there aren't global or class public variables in
+    # any library.
+    # These virtual variables have setter and getter methods, usually
+    # called 'var' and 'setVar' in C++ (or 'getVar' and 'setVar'), and
+    # are mapped to 'var' and 'var=' in Ruby, so that setting the
+    # variable in Ruby will just call the setter method.
+    def add_variable(name, type, getter = nil, setter = nil)
+      getter = name unless getter
+      setter = "set" + name[0..0].capitalize + name[1..-1] unless
+        setter
+
+      method_get = add_method getter, type
+      method_get.add_alias name
+
+      method_set = add_method setter, "void"
+      method_set.add_alias "#{name}="
+
+      begin
+        yield method_get, method_set
+      rescue LocalJumpError
+        # Ignore this, we can easily have methods without parameters
+        # or other extra informations.
+      end
+
+      method_set.add_parameter type, "value"
+
+      return [method_get, method_set]
+    end
+
+    # This class is used to represent a method for a C/C++ class bound
+    # in a Ruby extension. Through an object of this class you can add
+    # parameters and more to the method.
+    class Method < Function
+      
+      # Initialisation function, calls Function.initialize and sets
+      # the important parameters that differs from a generic function
+      def initialize(params) # :notnew:
+        params[:parent] = params[:klass]
+        super
+
+        @varname =
+        "f#{@parent.namespace.name.gsub("::","_")}_#{@parent.name}_#{@name}"
+
+        @definition_template = Templates["CxxMethodStub"]
+        @initialization_template = Templates["MethodInitBinding"]
+      end
+    end
+
+    # This class is used to represente the constructor of a C++ class
+    # bound in a Ruby extension.
+    class Constructor < Function
+      
+      # Initialisation function, calls Function.initialise, but accepts
+      # only a single parameter, the class the constructor belong to.
+      def initialize(klass) # :notnew:
+        super({
+                :parent => klass,
+                :bindname => "initialize",
+                :name => klass.name
+              })
+
+        @definition_template = Templates["ConstructorStub"]
+      end
+
+      def bind_call(nparam = nil)
+        "#{raw_call(nparam)};\n"
+      end
+    end
+
+  end
+end

--- /dev/null
+++ b/lib/rust/constants.rb
@@ -0,0 +1,48 @@
+# 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/element'
+
+module Rust
+  # This class represents a C/C++ constants or enumeration, it is
+  # simply going to map a Ruby constant with the given name under its
+  # parent with the given value
+  class Constant < Element
+    def initialize(name, value, parent)
+      super()
+
+      @name = name
+      @value = value
+      @parent = parent
+
+      @declaration_template = ""
+      @definition_template = ""
+      @initialization_template = 
+        "rb_define_const(r!parent_varname!, \"!name!\", cxx2ruby(!value!));\n"
+
+      add_expansion 'parent_varname', '@parent.varname'
+      add_expansion 'name', '@name'
+      add_expansion 'value', '@value'
+    end
+  end
+
+end

--- /dev/null
+++ b/lib/rust/container.rb
@@ -0,0 +1,92 @@
+# Copyright (c) 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/element'
+require 'rust/enum'
+
+module Rust
+  # This class defines a 'container', an element that can contain
+  # functions, constants and classes. Both modules and classes are
+  # modules, as you can have singleton methods and constants in both
+  # of them
+  class Container < Element
+    def add_cxx_class(name, parent = nil)
+      klass = CxxClass.new(name, self, parent)
+
+      yield klass
+
+      @children << klass
+      return klass
+    end
+
+    def add_class_wrapper(name, type)
+      klass = ClassWrapper.new(name, type, self)
+      
+      yield klass
+
+      @children << klass
+      return klass
+    end
+
+    def add_function(name, return_value = "void", bindname = name)
+      function = Function.new({ :name => name,
+                                :bindname => bindname,
+                                :return => return_value,
+                                :parent => self
+                              })
+
+      begin
+        yield function
+      rescue LocalJumpError
+        # Ignore this, we can easily have methods without parameters
+        # or other extra informations.
+      end
+
+      @children << function
+
+      return function
+    end
+
+    def add_constant(name, value = name)
+      @children << Constant.new(name, value, self)
+    end
+
+    def add_enum(name, ctype = nil)
+      enum = Enum.new(name, self, ctype)
+
+      yield enum
+
+      @children << enum
+
+      return enum
+    end
+
+    def add_namespace(name, cname = name)
+      ns = Namespace.new(name, cname, self)
+
+      yield ns
+
+      @children << ns
+    end
+
+  end
+end