rbplusplus 0.8 → 0.9

data/lib/rbplusplus/builders/extension.rb

@@ -1,73 +1,61 @@
 module RbPlusPlus
   module Builders
 
-    # This class takes in all classes to be wrapped and builds
-    # the top-level extension Init code
-    class ExtensionBuilder < Base
-      
-      # Need to be given the list of modules as they are a special case
-      attr_accessor :modules
+    # Extension node.
+    # There is only ever one of these in a project as this is
+    # the top level node for building a Ruby extension.
+    #
+    # Extensions are effectively Modules with some slightly different
+    # symantics, in that they expose to Kernel and have slightly
+    # different function handling and code generation.
+    class ExtensionNode < ModuleNode
 
-      def build
-        includes << "#include <rice/global_function.hpp>"
+      attr_reader :additional_includes
 
-        add_additional_includes
+      def initialize(name, code, modules)
+        self.name = name
+        self.modules = modules
 
-        body << "extern \"C\""
-        body << "void Init_#{@name}() {"
+        @additional_includes = []
 
-        # Explicitly ignore anything from the :: namespace
-        if @node.name != "::"
-        
-          #Build a hash table to handle overloaded functions
-          func_hash = {}
-          @node.functions.each do |func|
-            next if func.ignored? || func.moved?
-            
-            func_hash[func.name] ||= []
-            func_hash[func.name] << func
-          end
-          #Iterate through the hash table to handle overloaded functions
-          func_hash.each do |key, funcs|
-            funcs.each_with_index do |func, i|
-              add_includes_for func
-              
-              #append _#{i} to overloaded methods
-              #this needs to be done in both the wrapper function and the ruby function
-              func_append = ""
-              func_append = "_#{i}" if funcs.size > 1
-              wrapper_name = func.special_qualified_name || build_function_wrapper(func, func_append)
+        super(code, nil)
+      end
 
-              if func.return_type.const? || func.const?
-                TypesManager.build_const_converter(func.return_type)
-              end
+      def qualified_name
+        name
+      end
 
-              ruby_name = "#{Inflector.underscore(func.name)}#{func_append}"
-              body << "\tdefine_global_function(\"#{ruby_name}\", &#{wrapper_name});"
-            end
-          end
-          
-          build_enumerations
-          build_classes
+      def add_includes(includes)
+        @additional_includes << includes
+        includes.each do |inc|
+          add_child IncludeNode.new(self, inc)
         end
+      end
+
+      def build
+        super
+        self.rice_variable = nil
+        self.rice_variable_type = nil
+      end
 
-        build_modules
+      def write
+        # Let nodes build their code, splitting up code blocks into
+        # includes, declarations, and registrations,
+        # then wrap it up in our own template
+        registrations << "extern \"C\""
+        registrations << "void Init_#{@name}() {"
       end
 
-      def build_modules
-        @modules.each do |mod|
-          builder = ModuleBuilder.new(self, mod)
-          builder.build
-          builders << builder
+      private
+
+      def with_module_functions
+        @code.functions.each do |func|
+          next if do_not_wrap?(func)
+          add_child GlobalFunctionNode.new(func, self)
         end
       end
 
-      # Finish up the required code before doing final output
-      def to_s
-        includes << "using namespace Rice;"
-        
-        super + "\n}"
-      end
     end
+
   end
 end

data/lib/rbplusplus/builders/global_function.rb

@@ -0,0 +1,18 @@
+module RbPlusPlus
+  module Builders
+
+    # Expose a global function
+    class GlobalFunctionNode < MethodBase
+
+      def build
+        add_child IncludeNode.new(self, "rice/global_function.hpp", :system)
+        add_child IncludeNode.new(self, code.file)
+
+        self.prefix = "Rice::"
+        self.rice_method = "define_global_function"
+      end
+
+    end
+
+  end
+end

data/lib/rbplusplus/builders/helpers/class.rb

@@ -0,0 +1,74 @@
+module RbPlusPlus
+  module Builders
+    module ClassHelpers
+
+      # Build up any classes or structs under this module
+      def with_classes
+        [
+          self.code.classes,
+          self.code.structs
+        ].flatten.each do |klass|
+          next if do_not_wrap?(klass)
+          add_child ClassNode.new(klass, self)
+        end
+      end
+
+      # Wrap any constructors for this class
+      def with_constructors
+        # Ignore constructors on classes that have pure virtual methods,
+        # as they aren't constructable
+        return if !@director && self.code.pure_virtual?
+
+        to_use = self.code._get_constructor
+
+        real_constructors = [self.code.constructors].flatten.select {|c| !c.attributes[:artificial]}
+
+        if real_constructors.empty?
+          real_constructors = self.code.constructors
+        else
+          ignore_artificial = true
+        end
+
+        if to_use.nil? && real_constructors.length > 1
+          Logger.warn :multiple_constructors, "#{self.code.qualified_name} has multiple constructors. " +
+            "While the extension will probably compile, Rice only supports one constructor, " +
+            "please use #use_contructor to select which one to use."
+        end
+
+        # First, lets see if we have any non-generated constructors
+
+        [to_use || real_constructors].flatten.each do |constructor|
+          next if do_not_wrap?(constructor)
+
+          if constructor.attributes[:artificial]
+            next if ignore_artificial || constructor.arguments.length == 1
+          end
+
+          if @director
+            @director.wrap_constructor constructor
+          else
+            add_child ConstructorNode.new(constructor, self)
+          end
+        end
+      end
+
+      # Wrap up any class constants
+      def with_constants
+        [self.code.constants].flatten.each do |const|
+          next if do_not_wrap?(const)
+          add_child ConstNode.new(const, self)
+        end
+      end
+
+      # Expose the public variables for this class
+      def with_variables
+        [self.code.variables].flatten.each do |var|
+          next if do_not_wrap?(var)
+
+          add_child InstanceVariableNode.new(var, self)
+        end
+      end
+
+    end
+  end
+end

data/lib/rbplusplus/builders/helpers/enumeration.rb

@@ -0,0 +1,28 @@
+module RbPlusPlus
+  module Builders
+    module EnumerationHelpers
+
+      # Wrap up enumerations for this node.
+      # Anonymous enumerations are a special case. C++ doesn't
+      # see them as a seperate type and instead are just "scoped" constants,
+      # so we have to wrap them as such, constants.
+      def with_enumerations
+        [self.code.enumerations].flatten.each do |enum|
+          next if do_not_wrap?(enum)
+
+          if enum.anonymous?
+            # So for each value of this enumeration, 
+            # expose it as a constant
+            enum.values.each do |value|
+              add_child ConstNode.new(value, self)
+            end
+          else
+            add_child EnumerationNode.new(enum, self)
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/rbplusplus/builders/helpers/module.rb

@@ -0,0 +1,22 @@
+module RbPlusPlus
+  module Builders
+    module ModuleHelpers
+
+      # Build up any user-defined modules for this node
+      def with_modules
+        self.modules.each do |mod|
+          add_child ModuleNode.new(mod, self)
+        end
+      end
+
+      # Expose a function in this module
+      def with_module_functions
+        [self.code.functions].flatten.each do |func|
+          next if do_not_wrap?(func)
+          add_child ModuleFunctionNode.new(func, self)
+        end
+      end
+
+    end
+  end
+end

data/lib/rbplusplus/builders/include.rb

@@ -0,0 +1,32 @@
+module RbPlusPlus
+  module Builders
+
+    # Node for an #include line.
+    # Can be a :local (default) or :system
+    # include declaration.
+    #
+    # Includes have no children
+    class IncludeNode < Base
+
+      def initialize(parent, path, type = :local)
+        super(nil, parent)
+
+        @path = path
+        @type = type
+      end
+
+      def build
+        #nop
+      end
+
+      def write
+        if @path
+          includes << (@type == :local ? "#include \"#{@path}\"" : "#include <#{@path}>")
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/rbplusplus/builders/instance_variable.rb

@@ -0,0 +1,36 @@
+module RbPlusPlus
+  module Builders
+
+    # Wrap up a class instance variable
+    class InstanceVariableNode < Base
+
+      def build
+      end
+
+      def write
+        ruby_name = Inflector.underscore(code.name)
+        parent_name = parent.code.qualified_name.as_variable
+
+        # Setter, only if it isn't const
+        if !code.cpp_type.const?
+          method_name = "wrap_#{parent_name}_#{code.name}_set"
+          declarations << "void #{method_name}(#{parent.code.qualified_name}* self, #{code.cpp_type.base_type.qualified_name} val) {"
+          declarations << "self->#{code.name} = val;"
+          declarations << "}"
+
+          registrations << "#{parent.rice_variable}.define_method(\"#{ruby_name}=\", &#{method_name});"
+        end
+
+        # Getter
+        method_name = "wrap_#{parent_name}_#{code.name}_get"
+        declarations << "#{code.cpp_type.base_type.qualified_name} #{method_name}(#{parent.code.qualified_name}* self) {"
+        declarations << "return self->#{code.name};"
+        declarations << "}"
+
+        registrations << "#{parent.rice_variable}.define_method(\"#{ruby_name}\", &#{method_name});"
+      end
+
+    end
+
+  end
+end

data/lib/rbplusplus/builders/method.rb

@@ -0,0 +1,14 @@
+module RbPlusPlus
+  module Builders
+
+    # Wrap up an indivitual method
+    class MethodNode < MethodBase
+
+      def build
+        self.rice_method = "define_method"
+      end
+
+    end
+
+  end
+end

data/lib/rbplusplus/builders/method_base.rb

@@ -0,0 +1,136 @@
+module RbPlusPlus
+  module Builders
+
+    # Base class for any type of method or function handling
+    class MethodBase < Base
+
+      attr_accessor :prefix, :rice_method, :suffix
+
+      def initialize(code, parent = nil)
+        super
+
+        # Overload checks:
+        #  - If we're the only one, no overload required
+        #  - If we're one of many w/ the same name:
+        #     - Find out which in the list we are
+        #     - Add the number to ruby_name, unless user has renamed
+        #     - Build typedef of the method and use it in the exposure
+        found = [code.parent.methods(code.name)].flatten
+        if found.length > 1 && !code.renamed?
+          num = found.index(code)
+          self.suffix = "_#{num}"
+        end
+      end
+
+      # Wrap up this method making sure that overloads
+      # are properly typedef'd to keep from compiler error from unresolvable types
+      #
+      # Thanks to Py++ for the appropriate C++ syntax for this.
+      def write
+        @ruby_name = Inflector.underscore(code.name)
+
+        self.prefix ||= "#{self.parent.rice_variable}."
+        self.suffix ||= ""
+
+        if self.code.arguments.size == 1 && (fp = self.code.arguments[0].cpp_type.base_type).is_a?(RbGCCXML::FunctionType)
+          wrap_with_function_pointer(fp)
+        else
+          wrap_normal_method
+        end
+      end
+
+      # This method should return the full C++ path to the method you're exposing
+      def code_path
+        self.code.qualified_name
+      end
+
+      protected
+
+      # Handling methods that take function pointers takes a lot of extra custom code.
+      #  - Need a method that acts as the proxy between C and the Ruby proc
+      #  - Need a method that gets wrapped into Ruby to handle type conversions
+      #
+      def wrap_with_function_pointer(func_pointer)
+        Logger.info "Building callback wrapper for #{self.code.qualified_name}"
+
+        base_name = self.code.qualified_name.as_variable
+        return_type = func_pointer.return_type.to_cpp
+        proxy_method_name = "do_yield_on_#{base_name}"
+
+        callback_arguments = []
+        callback_values = [func_pointer.arguments.length]
+
+        func_pointer.arguments.each_with_index do |arg, i|
+          callback_arguments << "#{arg.to_cpp} arg#{i}"
+          callback_values << "to_ruby(arg#{i}).value()"
+        end
+
+        # Build the method that acts as the Proc -> C func pointer proxy (the callback)
+        block_var_name = "_block_for_#{base_name}"
+        declarations << "VALUE #{block_var_name};"
+        declarations << "#{return_type} #{proxy_method_name}(#{callback_arguments.join(", ")}) {"
+
+        funcall = "rb_funcall(#{block_var_name}, rb_intern(\"call\"), #{callback_values.join(", ")})"
+        if return_type == "void"
+          declarations << "#{funcall};"
+        else
+          declarations << "return from_ruby<#{return_type} >(#{funcall});"
+        end
+
+        declarations << "}"
+
+        if self.parent.is_a?(ClassNode)
+          arg = "#{self.parent.qualified_name} *self"
+          callee = "self->#{self.code.qualified_name}"
+        else
+          arg = ""
+          callee = "#{self.code.qualified_name}"
+        end
+
+        wrapper_func = "wrap_for_callback_#{base_name}"
+
+        # Build the wrapper method that gets exposed to Ruby
+        declarations << "VALUE #{wrapper_func}(#{arg}) {"
+        declarations << "\t#{block_var_name} = rb_block_proc();"
+        declarations << "\t#{callee}(&#{proxy_method_name});"
+        declarations << "\treturn Qnil;"
+        declarations << "}"
+
+        registrations << "#{self.prefix}#{self.rice_method}(\"#{@ruby_name + self.suffix}\", &#{wrapper_func});"
+      end
+
+      def wrap_normal_method
+        parts = "#{self.qualified_name}".split("::")
+        usage_ref = "#{parts[-1]}_func_type"
+
+        if self.code.static? || self.code.as_instance_method?
+          method_ref = "*#{usage_ref}"
+        else
+          method_ref = [parts[0..-2], "*#{usage_ref}"].flatten.join("::")
+        end
+
+        default_arguments = []
+        arguments = []
+
+        self.code.arguments.each do |arg|
+          arguments << arg.to_cpp
+          default_arguments << "Rice::Arg(\"#{arg.name}\")#{arg.value ? " = (#{arg.cpp_type.to_cpp})#{arg.value}" : "" }"
+        end
+
+        return_type = find_typedef_for(self.code.return_type).to_cpp
+
+        def_args = default_arguments.any? ? ", (#{default_arguments.join(", ")})" : ""
+
+        registrations << "{"
+
+        registrations << "typedef #{return_type} ( #{method_ref} )( #{arguments.join(", ")} );"
+        registrations << "#{self.prefix}#{self.rice_method}(\"#{@ruby_name + self.suffix}\", " +
+                          "#{usage_ref}( &#{code_path} )#{def_args});"
+
+        registrations << "}"
+      end
+
+    end
+
+  end
+end

data/lib/rbplusplus/builders/module.rb

@@ -1,73 +1,59 @@
 module RbPlusPlus
   module Builders
 
-    # This class handles generating source for a requested Module
-    class ModuleBuilder < Base
+    # Handles code generation dealing with user-defined modules.
+    class ModuleNode < Base
+      include ModuleHelpers
+      include EnumerationHelpers
+      include ClassHelpers
 
-      # Initializer takes the parent object and the RbModule construction
-      def initialize(parent, mod)
-        super(mod.name, mod.node)
-        @module = mod
-        self.parent = parent
-      end
+      # Has a name
+      attr_accessor :name
 
-      def build
-        # Using qualified name with underscores here to allow for nested modules
-        # of the same name
-        self.rice_variable = "rb_m#{self.qualified_name.gsub(/::/, "_")}"
-        self.rice_variable_type = "Rice::Module"
+      # And needs to specially handle any other nexted modules
+      attr_accessor :modules
 
-        includes << "#include <rice/Module.hpp>"
-        
-        add_additional_includes
+      # Node is the RbModule object, it proxies any unknown calls
+      # off to it's internal Node object
+      def initialize(code, parent = nil)
+        super
 
-        mod_defn = "\t#{rice_variable_type} #{rice_variable} = "
-        if !parent.is_a?(ExtensionBuilder)
-          mod_defn += "Rice::define_module_under(#{parent.rice_variable}, \"#{name}\");"
-        else
-          mod_defn += "Rice::define_module(\"#{name}\");"
-        end
+        @name ||= code.name
+        @modules ||= code.modules
+      end
 
-        body << mod_defn
+      def qualified_name
+        self.code.qualified_name
+      end
 
-        # If a namespace has been given to this module, find and wrap the appropriate code
-        if self.node
-          build_enumerations 
-        end
+      def build
+        with_modules
 
-        build_functions unless @module.functions.empty?
-        build_classes(@module.classes) unless @module.classes.empty?
-   
+        add_child IncludeNode.new(self, "rice/Module.hpp", :system)
 
-        # Build each inner module
-        @module.modules.each do |mod|
-          builder = ModuleBuilder.new(self, mod)
-          builder.build
-          builders << builder
+        # Make sure we ignore anything from the :: namespace
+        if self.code && self.code.name != "::"
+          with_module_functions
+          with_enumerations
+          with_classes
         end
-      end
 
-      # Process functions to be added to this module
-      def build_functions
-        @module.functions.each do |func|
-          next if func.ignored? || func.moved? # fine grained function filtering
-          add_includes_for func
+        nodes.flatten!
 
-          func_name = Inflector.underscore(func.name)
-          wrapped_name = func.special_qualified_name || build_function_wrapper(func)
-          body << "\t#{self.rice_variable}.define_module_function(\"#{func_name}\", &#{wrapped_name});"
-        end
+        self.rice_variable_type = "Rice::Module"
+        self.rice_variable = "rb_m#{self.qualified_name.as_variable}"
       end
 
-      # Special name handling. Qualified name is simply the name of this module
-      def qualified_name
-        if parent.is_a?(ModuleBuilder)
-          "#{parent.qualified_name}::#{self.name}"
+      def write
+        prefix = "#{rice_variable_type} #{rice_variable} = "
+
+        if parent.rice_variable
+          registrations << "#{prefix} Rice::define_module_under(#{parent.rice_variable}, \"#{@name}\");"
         else
-          self.name
+          registrations << "#{prefix} Rice::define_module(\"#{@name}\");"
         end
       end
-
     end
+
   end
 end

data/lib/rbplusplus/builders/module_function.rb

@@ -0,0 +1,16 @@
+module RbPlusPlus
+  module Builders
+
+    # Wrap up a method on a Module as a module_function
+    class ModuleFunctionNode < MethodBase
+
+      def build
+        add_child IncludeNode.new(self, code.file)
+
+        self.rice_method = "define_module_function"
+      end
+
+    end
+
+  end
+end

data/lib/rbplusplus/builders/static_method.rb

@@ -0,0 +1,14 @@
+module RbPlusPlus
+  module Builders
+
+    # Wrap up a static method on a class
+    class StaticMethodNode < MethodBase
+
+      def build
+        self.rice_method = "define_singleton_method"
+      end
+
+    end
+
+  end
+end