rbplusplus 0.8 → 0.9

data/lib/rbplusplus/builders/class.rb

@@ -1,137 +1,151 @@
 module RbPlusPlus
   module Builders
 
-    # This class handles generating source for Class nodes
-    class ClassBuilder < Base
+    # Handles the generation of Rice code to wrap classes
+    class ClassNode < Base
+      include ClassHelpers
+      include EnumerationHelpers
 
-      # Different initializer to keep things clean
-      def initialize(parent, node)
-        super(node.name, node)
-        self.parent = parent
+      def qualified_name
+        @qualified_name || self.code.qualified_name
       end
 
       def build
+        add_child IncludeNode.new(self, "rice/Class.hpp", :system)
+        add_child IncludeNode.new(self, "rice/Data_Type.hpp", :system)
+        add_child IncludeNode.new(self, code.file)
 
-        #Handles templated super classes
-        @typedef_name = node.qualified_name.functionize
-        
-        #Handles templated super classes passing in complex members
-        var_name = node.name
-        var_name.gsub!("::","_")
-        var_name.gsub!(/[ ,<>]/, "_")
-        var_name.gsub!("*", "Ptr")
-        
-        self.rice_variable = "rb_c#{var_name}"
-        self.rice_variable_type = "Rice::Data_Type<#{self.qualified_name} >"
-
-        includes << "#include <rice/Class.hpp>"
-        includes << "#include <rice/Data_Type.hpp>"
-        includes << "#include <rice/Constructor.hpp>"  
-        
-        add_additional_includes
-        add_includes_for node
-        
-        self.declarations.insert(0,"typedef #{node.qualified_name} #{@typedef_name};")
-        
-        @body << class_definition
-        
-        @body += constructors
-        
-        @body += methods
-
-        # Nested Classes
-        build_classes
-
-        # Enumerations
-        build_enumerations
+        typedef = find_typedef
+
+        @short_name, @qualified_name = typedef ? [typedef.name, typedef.qualified_name] : [code.name, code.qualified_name]
+
+        Logger.info "Wrapping class #{@qualified_name}"
+
+        @class_base_type = @qualified_name
+
+        supers = self.code.superclasses(:public)
+        @superclass = supers[0]
+
+        if supers.length > 1
+          if (@superclass = self.code._get_superclass).nil?
+            Logger.warn :mutiple_superclasses, "#{@qualified_name} has multiple public superclasses. " +
+              "Will use first superclass, which is #{supers[0].qualified_name} "
+              "Please use #use_superclass to specify another superclass as needed."
+          end
+        end
+
+        if self.code.needs_director?
+          @director = DirectorNode.new(self.code, self, @qualified_name, @superclass)
+          add_child @director
+
+          @qualified_name = @director.qualified_name
+        end
+
+        self.rice_variable = "rb_c#{@short_name.as_variable}"
+        self.rice_variable_type = "Rice::Data_Type< #{@qualified_name} >"
+
+        with_enumerations
+        with_classes
+        with_constructors
+        with_constants
+        with_variables
+        with_methods
+
+        unless @director
+          check_allocation_strategies
+        end
+
+        # For now, build a const& type converter for all class types until Rice has
+        # better management of to_ruby of class types, if it ever happens
+        add_global_child ConstConverterNode.new(self.code, self)
       end
 
-      # Build the constructors, and return an array of rice code
-      def constructors
-        result = []
-        # There are no constructors on purely virtual classes.
-        node.methods.each do |method|
-          next unless method.is_a? RbGCCXML::Method
-          return [] if method.purely_virtual?
+      def write
+        prefix = "#{rice_variable_type} #{rice_variable} = "
+        ruby_name = @short_name
+        expose_class = @qualified_name
+        superclass = @superclass.qualified_name if @superclass && !do_not_wrap?(@superclass)
+
+        if @director
+          @director.write_class_registration
+          expose_class = @director.qualified_name
+          superclass = @class_base_type
         end
-        # Constructors
-        node.constructors.each do |init|
-          next if init.ignored?
-          next unless init.public?
-          args = [@typedef_name, init.arguments.map {|a| a.cpp_type.to_s(true) }].flatten
-          result << "\t#{rice_variable}.define_constructor(Rice::Constructor<#{args.join(",")}>());"
+
+        class_names = [expose_class]
+        class_names << superclass if superclass
+        class_names = class_names.join(",")
+
+        if parent.rice_variable
+          registrations << "#{prefix} Rice::define_class_under< #{class_names} >" +
+                             "(#{parent.rice_variable}, \"#{ruby_name}\");"
+        else
+          registrations << "#{prefix} Rice::define_class< #{class_names} >(\"#{ruby_name}\");"
         end
-        result
+
+        handle_custom_code
       end
-      
-      # Build the methods, and return an array of rice code
-      def methods
-        result = []
-        # Methods are thrown into a hash table so that we can 
-        # determine overloaded methods
-        methods_hash = {}
-        node.methods.each do |method|
-          next unless method.public?
-  
-          methods_hash[method.qualified_name] ||= []
-          methods_hash[method.qualified_name] << method
+
+      private
+
+      # Here we take the code manually added to the extension via #add_custom_code
+      def handle_custom_code
+
+        # Any declaration code, usually wrapper function definitions
+        self.code._get_custom_declarations.flatten.each do |decl|
+          declarations << decl
+        end
+
+        # And the registration code to hook into Rice
+        self.code._get_custom_wrappings.flatten.each do |wrap|
+          registrations << "#{wrap.gsub(/<class>/, self.rice_variable)}"
         end
-        
-        methods_hash.each do |key, methods|
-          #Add any method with a const return type to the typemanager
-          methods.each do |method|
-            next if method.ignored? || method.moved?
-            if method.return_type.const? || method.const?
-              TypesManager.build_const_converter(method.return_type)
-            end
+      end
+
+      # We need to be sure to inform Rice of classes that may not have public
+      # constructors or destructors. This is because when a class is wrapped, code is generated
+      # to allocate the class directly. If this code tries to use a non-public
+      # constructor, we hit a compiler error.
+      def check_allocation_strategies
+        # Due to the nature of GCC-XML's handling of templated classes, there are some
+        # classes that might not have any gcc-generated constructors or destructors.
+        # We check here if we're one of those classes and completely skip this step
+        return if [self.code.constructors].flatten.empty?
+
+        # Find a public default constructor
+        found = [self.code.constructors.find(:arguments => [], :access => "public")].flatten
+        has_public_constructor = !found.empty?
+
+        # See if the destructor is public
+        has_public_destructor = self.code.destructor && self.code.destructor.public?
+
+        if !has_public_constructor || !has_public_destructor
+          add_global_child AllocationStrategyNode.new(self,
+                            self.code, has_public_constructor, has_public_destructor)
+        end
+      end
+
+      # Wrap up all public methods
+      def with_methods
+        method_names = @director ? @director.methods_wrapped.map {|m| m.name } : []
+        [self.code.methods].flatten.each do |method|
+          next if do_not_wrap?(method)
+          next if method_names.include?(method.name)
+
+          # Ignore methods that have non-public arguments anywhere
+          if !method.arguments.empty? && !method.arguments.select {|a| !a.cpp_type.base_type.public?}.empty?
+            Logger.info "Ignoring method #{method.qualified_name} due to non-public argument type(s)"
+            next
           end
-          #No overloaded methods
-          if methods.length == 1
-            method = methods[0]
-            next if method.ignored? || method.moved?
-            m = "define_method"
-            name = method.qualified_name
-
-            if method.static?
-              m = "define_singleton_method"
-              name = build_function_wrapper(method)
-            end
-
-            result << "\t#{rice_variable}.#{m}(\"#{Inflector.underscore(method.name)}\", &#{name});"  
+
+          if method.static?
+            add_child StaticMethodNode.new(method, self)
           else
-            #Handle overloaded methods
-            #currently we just append an index to them if they have not been renamed
-            #for example getOrigin() and getOrigin(x,y) become
-            #get_origin_0 and get_origin_1
-            methods.each_with_index do |method, i|
-              next if method.ignored? || method.moved?
-              name = build_method_wrapper(node, method, i)
-              m = "define_method"
-              method_name = "#{Inflector.underscore(method.name)}"
-              method_name += "_#{i}" unless method.renamed?
-              result << "\t#{rice_variable}.#{m}(\"#{method_name}\", &#{name});"  
-            end
+            add_child MethodNode.new(method, self)
           end
         end
-        result
-      end
-      
-      # Return a rice string representing Rice's class definition.
-      def class_definition        
-        class_defn = "\t#{rice_variable_type} #{rice_variable} = "
-        
-        class_name = node.name
-        supers = node.super_classes.collect { |s| s.qualified_name }
-        class_names = [@typedef_name, supers].flatten.join(",")
-        
-        if !parent.is_a?(ExtensionBuilder)
-          class_defn += "Rice::define_class_under<#{class_names} >(#{parent.rice_variable}, \"#{class_name}\");"
-        else
-          class_defn += "Rice::define_class<#{class_names} >(\"#{class_name}\");"
-        end
-        class_defn
       end
+
     end
-    
   end
 end

data/lib/rbplusplus/builders/const.rb

@@ -0,0 +1,30 @@
+module RbPlusPlus
+  module Builders
+
+    # Expose a const value
+    class ConstNode < Base
+
+      def build
+        add_child IncludeNode.new(self, code.file)
+      end
+
+      def write
+        # If this constant is initialized in the header, we need to set the constant to the initialized value
+        # If we just use the variable itself, Linux will fail to compile because the linker won't be able to
+        # find the constant.
+        set_to =
+          if init = code.attributes["init"]
+            init
+          else
+            code.qualified_name
+          end
+
+        prefix = parent.rice_variable ? "#{parent.rice_variable}." : "Rice::Module(rb_mKernel)."
+        registrations << "#{prefix}const_set(\"#{code.name}\", to_ruby(#{set_to}));"
+      end
+
+    end
+
+  end
+end
+

data/lib/rbplusplus/builders/const_converter.rb

@@ -0,0 +1,52 @@
+module RbPlusPlus
+  module Builders
+
+    # Handles code generation for to_ruby converters for const& types
+    class ConstConverterNode < Base
+
+      # Used by MultipleFileWriter to only wrap a given type once.
+      def qualified_name
+        "#{self.code.qualified_name}_ConstConverter"
+      end
+
+      def build
+        Logger.debug("Building const converter for #{self.code.qualified_name}")
+      end
+
+      def write
+        full_name = self.code.qualified_name
+
+        # Various reasons we don't want to generate this:
+        # Rice already handles it
+        if full_name =~ /std::string/
+          Logger.debug("Not building const converter for #{full_name}")
+          return
+        end
+
+        Logger.debug("Writing out const converter for #{full_name}")
+
+        includes << "#include <rice/Object.hpp>"
+        includes << "#include <rice/Data_Object.hpp>"
+        includes << "#include <rice/Data_Type.hpp>"
+
+        includes << "#include \"#{self.code.file}\""
+
+        declarations << "template<>"
+        declarations << "Rice::Object to_ruby<#{full_name} >(#{full_name} const & a);"
+
+        build_as = if self.parent.is_a?(EnumerationNode)
+                     "new #{full_name}(a)"
+                   else
+                     "(#{full_name} *)&a"
+                   end
+
+        registrations << "template<>"
+        registrations << "Rice::Object to_ruby<#{full_name} >(#{full_name} const & a) {"
+        registrations << "\treturn Rice::Data_Object<#{full_name} >(#{build_as}, Rice::Data_Type<#{full_name} >::klass(), 0, 0);"
+        registrations << "}"
+      end
+
+    end
+
+  end
+end

data/lib/rbplusplus/builders/constructor.rb

@@ -0,0 +1,19 @@
+module RbPlusPlus
+  module Builders
+
+    # Wrap class constructor(s)
+    class ConstructorNode < Base
+
+      def build
+        add_child IncludeNode.new(self, "rice/Constructor.hpp", :system)
+      end
+
+      def write
+        args = [code.parent.qualified_name, code.arguments.map {|a| a.cpp_type.to_cpp }].flatten.compact
+        registrations << "#{parent.rice_variable}.define_constructor(Rice::Constructor< #{args.join(",")} >());"
+      end
+
+    end
+
+  end
+end

data/lib/rbplusplus/builders/director.rb

@@ -0,0 +1,149 @@
+module RbPlusPlus
+  module Builders
+
+    # This class takes care of the generation of Rice::Director wrapper
+    # classes. It's slightly different than other nodes, as it's self.code
+    # is the class we're wrapping a director around.
+    class DirectorNode < Base
+
+      attr_reader :methods_wrapped
+
+      def initialize(code, parent, class_qualified_name, superclass)
+        super(code, parent)
+
+        @class_qualified_name = class_qualified_name
+        @methods_wrapped = []
+        @superclass = superclass
+        @constructors = []
+
+        @class_base_name = class_qualified_name.split("::")[-1]
+        @name = "#{@class_base_name}Director"
+      end
+
+      def qualified_name
+        @name
+      end
+
+      def build
+        add_child IncludeNode.new(self, "rice/Director.hpp", :global)
+        add_child IncludeNode.new(self, "rice/Constructor.hpp", :global)
+        
+        # To ensure proper compilation, this director class needs
+        # to implement all pure virtual methods found up the
+        # inheritance heirarchy of this class. So here, we traverse
+        # this list and build the nest of required methods
+        wrapped_names = []
+        klass = self.code
+        while klass.is_a?(RbGCCXML::Class) || klass.is_a?(RbGCCXML::Struct)
+          [klass.methods].flatten.each do |method|
+            next if do_not_wrap?(method)
+            if method.virtual? && !wrapped_names.include?(method.name)
+              @methods_wrapped << method
+              wrapped_names << method.name
+
+              add_child DirectorMethodNode.new(method, self.parent, self)
+            end
+          end
+          klass = klass.superclass
+        end
+      end
+
+      def wrap_constructor(constructor)
+        @constructors << constructor
+      end
+
+      def write_class_registration
+        # Need to tell Rice of the base class, while also making sure that if there's a superclass to this class
+        # that we know about it, or attempts to use polymorphism will crash with 'unknown caster for {superclass}
+        class_names = [@class_qualified_name]
+        class_names << @superclass.qualified_name if @superclass && !do_not_wrap?(@superclass)
+        class_names = class_names.join(",")
+
+        self.parent.registrations << "Rice::define_class< #{class_names} >(\"__#{@class_base_name}__\");"
+      end
+
+      def write_constructor(constructor = nil)
+        args = ["Rice::Object self"]
+        types = [@name, "Rice::Object"]
+        supercall_args = []
+
+        if constructor
+          constructor.arguments.each do |arg|
+            type = arg.cpp_type.to_cpp
+            name = arg.name
+
+            args << "#{type} #{name}"
+            types << type
+            supercall_args << name
+          end
+        end
+
+        declarations << "#{@name}(#{args.join(", ")}) : #{@class_qualified_name}(#{supercall_args.join(", ")}), Rice::Director(self) { }"
+        registrations << "#{self.parent.rice_variable}.define_constructor(Rice::Constructor< #{types.join(", ")} >());"
+      end
+
+      def write
+        declarations << "class #{@name} : public #{@class_qualified_name}, public Rice::Director  {"
+        declarations << "public:"
+
+        # Handle constructors
+        if @constructors.empty?
+          write_constructor
+        else
+          @constructors.each {|c| write_constructor(c) }
+        end
+
+        # Each virtual method gets wrapped
+        @methods_wrapped.each do |method|
+
+          cpp_name = method.qualified_name.split("::")[-1]
+          ruby_name = Inflector.underscore(method.name)
+          return_type = method.return_type.to_cpp
+          return_call = return_type != "void" ? "return" : ""
+
+          def_arguments = []
+          call_arguments = []
+          method.arguments.each do |a|
+            def_arg = a.value ? " = #{a.value}" : ""
+            def_arguments << "#{a.cpp_type.to_cpp} #{a.name}#{def_arg}"
+            call_arguments << a.name
+          end
+
+          def_arguments = def_arguments.length == 0 ? "" : def_arguments.join(", ")
+
+          reverse = ""
+          up_or_raise = 
+            if method.default_return_value
+              reverse = "!"
+              "return #{method.default_return_value};"
+            else
+              if method.purely_virtual?
+                "raisePureVirtual()"
+              else
+                "#{return_call} this->#{method.qualified_name}(#{call_arguments.join(", ")})"
+              end
+            end
+
+          call_down = "getSelf().call(\"#{ruby_name}\"#{call_arguments.empty? ? "" : ", "}#{call_arguments.map {|a| "to_ruby(#{a})" }.join(", ")})"
+          call_down = "return from_ruby< #{return_type} >( #{call_down} )" if return_type != "void"
+
+          const = method.const? ? "const" : ""
+
+          declarations << ""
+          declarations << "#{return_type} #{cpp_name}(#{def_arguments}) #{const} {"
+          declarations << "if(#{reverse}callIsFromRuby(\"#{ruby_name}\")) {"
+          declarations << "#{up_or_raise};"
+          declarations << "} else {"
+          declarations << "#{call_down};"
+          declarations << "}"
+          declarations << "}"
+        end
+
+        declarations << "};"
+      end
+
+    end
+
+  end
+end
+

data/lib/rbplusplus/builders/director_method.rb

@@ -0,0 +1,20 @@
+module RbPlusPlus
+  module Builders
+
+    # Expose a director method as an instance method
+    class DirectorMethodNode < MethodNode
+
+      def initialize(method, parent, director)
+        super(method, parent)
+        @director = director
+      end
+
+      def code_path
+        cpp_name = self.code.qualified_name.split("::")[-1]
+        "#{@director.qualified_name}::#{cpp_name}"
+      end
+
+    end
+
+  end
+end

data/lib/rbplusplus/builders/enumeration.rb

@@ -1,37 +1,30 @@
 module RbPlusPlus
   module Builders
 
-    # This class handles generating source for a requested Module
-    class EnumerationBuilder < Base
-      
-      # Different initializer to keep things clean
-      def initialize(parent, node)
-        super(node.name, node)
-        self.parent = parent
-      end
+    # Expose an enumeration.
+    class EnumerationNode < Base
 
       def build
-        includes << "#include <rice/Enum.hpp>"
-        enum_name = node.name
-        full_name = node.qualified_name
-        self.rice_variable = "rb_e#{enum_name}"
-        self.rice_variable_type = "Rice::Enum<#{full_name}>"
-        
-        add_additional_includes
-        
-        defn = "\t#{rice_variable_type} #{rice_variable} = "
-        
-        second_arg = ""
-        if !parent.is_a?(ExtensionBuilder)
-          second_arg = ", #{parent.rice_variable}"
-        end
+        add_child IncludeNode.new(self, "rice/Enum.hpp", :system)
+        add_child IncludeNode.new(self, code.file)
+
+        # See ClassNode
+        add_global_child ConstConverterNode.new(self.code, self)
+
+        self.rice_variable_type = "Rice::Enum<#{code.qualified_name}>"
+        self.rice_variable = "rb_e#{code.name}"
+
+        Logger.info "Wrapping enumeration #{code.qualified_name}"
+      end
 
-        defn += "Rice::define_enum<#{full_name}>(\"#{enum_name}\" #{second_arg});"
+      def write
+        second = parent.rice_variable ? ", #{parent.rice_variable}" : ""
 
-        body << defn
+        registrations << "#{rice_variable_type} #{rice_variable} = " \
+          "Rice::define_enum<#{code.qualified_name}>(\"#{code.name}\"#{second});"
 
-        node.values.each do |v|
-          body << "\t#{rice_variable}.define_value(\"#{v.name}\", #{v.to_s(true)});"
+        code.values.each do |v|
+          registrations << "#{rice_variable}.define_value(\"#{v.name}\", #{v.qualified_name});"
         end
       end