gecoder 0.2.0

data/vendor/rust/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.upcase
+      @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

data/vendor/rust/rust/container.rb

@@ -0,0 +1,110 @@
+# 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 initialize
+      super
+      
+      @functions = {}
+    end
+    
+    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 if block_given?
+
+      register_function(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
+    
+    
+    protected
+    def register_function(func)
+      key = func.name
+      if not @functions.has_key? key
+        @functions[key] = func
+        @children << func
+      else
+        @functions[key].add_overload(func)
+      end
+    end
+
+  end
+end

data/vendor/rust/rust/cppifaceparser.rb

@@ -0,0 +1,129 @@
+
+
+module Rust
+
+module Cpp
+
+class IfaceParser
+  def initialize
+  end
+  
+  def parseFile(path)
+    lines = ""
+    File.open(path) { |f|
+      lines = f.readlines.join
+    }
+    
+    parse(lines)
+  end
+  
+  def parse(cpph)
+    classes = []
+    
+    ignore = true
+    
+    # FIXME: remove \n and split by ";" and "*/"
+    
+    cpph.to_s.split(/$/).each { |line|
+      line = line.split("//").first
+      if line =~ /\/\*/ # open comment
+        ignore = true
+      end
+      
+      if line =~ /\*\// # close comment
+        ignore = false
+      end
+      
+      if line =~ /public:/
+        ignore = false
+      elsif line =~ /private:|protected:/
+        ignore = true
+      elsif line =~ /class\s+(\w+\s+){0,1}(\w+)/ # function
+        if not classes.last.nil?
+          if classes.last[:name] == $2
+            next
+          end
+        end
+        
+        classes << {:name => $2, :methods => [], :constructors => [] }
+      elsif line =~ /namespace\s+(\w+)\s+\{{0,1}/
+        $stderr << "Warning: Namespace will be ignore.\n"
+      end
+      
+      if not ignore and classes.last
+        parseEntity(line, classes.last)
+      end
+    }
+    
+    classes.delete_if { |klass|
+      klass[:methods].empty?
+    }
+    
+    classes
+  end
+  
+  private
+  def parseEntity(line, klass)
+    if line =~ /((\w+::)*\w+)\s+(const\s+){0,1}(\*{0,3}|&){0,1}\s*(\w+)\s*\((.*)\)/
+      type = "#{$1}#{$4}"
+      fname = $5
+      params = []
+      
+      if not $6.nil?
+        $6.strip!
+        if not $6.empty?
+          params = parseParams($6)
+        end
+      end
+      
+      klass[:methods] << { :name => fname, :type => type, :params => params }
+    elsif line =~ /^\s*#{klass[:name]}\s*\((.*)\)/ #constructor
+      params = parseParams($1)
+      klass[:constructors] << { :params => params }
+    end
+  end
+  
+  def parseParams(params)
+    result = []
+    params.split(",").each { |param|
+      param = param.split("=").first
+      param.strip!
+      
+      if param =~ /((\w+::)*\w+)\s*(const){0,1}(\*{0,3}|&){0,1}(const\s+){0,1}\s*(\w*)\s*$/
+        type = "#{$1}#{$2}#{$4}"
+        
+        name = $6
+        if name.empty?
+          name = "par#{result.size}"
+        end
+        result << {:type => type, :name => name}
+      end
+    }
+    
+    result
+  end
+end
+
+end # Cpp
+
+end # Rust
+
+if __FILE__ == $0
+  parser = Rust::Cpp::IfaceParser.new
+  
+  classes = parser.parseFile(ARGV[0].to_s)
+  
+  classes.each { |klass|
+    puts "Class: #{klass[:name]}"
+    klass[:methods].each { |method|
+      params = "("
+      
+      method[:params].each { |par|
+        params += "#{par[:type]} #{par[:name]}, "
+      }
+      params += ")"
+      puts "Method: #{method[:type]} #{method[:name]} #{params};"
+    }
+  }
+end
+

data/vendor/rust/rust/cwrapper.rb

@@ -0,0 +1,72 @@
+# 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.
+
+module Rust
+
+  # C class wrapper class, this is used to provide support for those
+  # wrappers around C libraries that are bound by Rust.
+  class ClassWrapper < Class
+    attr_reader :cleanup_functions
+
+    def initialize(name, type, namespace) # :notnew:
+      super(name, namespace)
+
+      @cname = type
+      @varcname = @cname.sub("*", "Ptr").gsub("::", "_").gsub(' ', '')
+      @cleanup_functions = ""
+
+      @definition_template = Templates["CWrapperClassDefinitions"]
+      @declaration_template << Templates["StandaloneClassDeclarations"]
+
+      add_expansion 'cleanup_functions', '@cleanup_functions'
+    end
+
+    def add_constructor(name)
+      constructor = super()
+
+      constructor.name = name
+
+      return constructor
+    end
+
+    def add_cleanup_function(call)
+      @cleanup_functions << call << "\n"
+    end
+
+    # This class is used to represente the constructor of a C++ class
+    # bound in a Ruby extension.
+    class Constructor < Class::Constructor
+      attr_writer :name
+
+      def raw_call(nparam = nil)
+        "tmp = #{super(nparam)}"
+      end
+    end
+
+    class Method < Class::Method
+      def add_instance_parameter
+        add_static_parameter 'tmp'
+      end
+    end
+  end
+
+end

data/vendor/rust/rust/cxxclass.rb

@@ -0,0 +1,98 @@
+# 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/class'
+
+module Rust
+  class CxxClass < Class
+    # This function initializes the CxxClass instance by setting the
+    # values to the attributes defining its parent, namespace, name
+    # and a few other needed information.
+    #
+    # When a C++ Class is bound that is a child of another class, it
+    # shares its highest anchestor's pointer map (as that is the
+    # more general pointer type it can be referred to with), and
+    # function to call when free()'ing.
+    #
+    # Don't call this function directly, use Namespace.add_cxx_class
+    #
+    # *FIXME*: multiple inheritance can make Rust bail out, badly.
+    def initialize(name, namespace, parent = nil) # :notnew:
+      super(name, namespace)
+      @parent = parent
+
+      @children_classes = []
+
+      @definition_template = Templates["CxxClassDefinitions"]
+
+      @varname = "#{complete_name.gsub("::", "_")}"
+      
+      if @parent
+        @ptrmap = @parent.ptrmap
+        @function_free = @parent.function_free
+        @parent_varname = "r#{@parent.varname}"
+      else
+        @declaration_template << Templates["StandaloneClassDeclarations"]
+        @definition_template << Templates["CxxStandaloneClassDefinitions"]
+      end
+
+      add_expansion 'test_children'
+    end
+    
+    def custom_extends(parent)
+      @parent_varname = parent
+    end
+
+    # This function is used during ruby to C/C++ conversion of the
+    # types, and test for the deepest class the pointer is valid for.
+    def test_children
+      return unless @children_classes
+      
+      ret = ""
+      
+      @children_classes.each do |klass|
+        ret << %@
+     if ( dynamic_cast< #{klass.namespace.cname}::#{klass.name}* >(instance) != NULL )
+     {
+       klass = c#{klass.varname};
+       #{klass.test_children}
+     }
+     @
+      end
+
+      return ret
+    end
+
+    class Method < Class::Method
+      def raw_call(nparam = nil)
+        "tmp->#{super(nparam)}"
+      end
+    end
+
+    class Constructor < Class::Constructor
+      def raw_call(nparam = nil)
+        "tmp = new #{@parent.namespace.cname}::#{super(nparam)}"
+      end
+    end
+
+  end
+end