rbplusplus 0.1.1 → 0.8

data/lib/rbplusplus/builders/types_manager.rb

@@ -0,0 +1,93 @@
+module RbPlusPlus
+  module Builders
+
+    # This is a singleton class that takes care of handling any to_ruby and from_ruby 
+    # definitions this wrapper might need. This is pulled out seperate from other builders
+    # because of C++ coding and compiling restrictions. Mainly, 
+    #
+    # 1. All cpp/hpp files where Rice needs to know about a given type needs to know about any to_/from_ruby definitions of that type
+    # 2. The actual definition of these methods can only be in one place or we get compiler redefinition errors.
+    class TypesManager
+      include Singleton
+
+      # Forward off all calls to the singleton instance of this method. 
+      # This allows one to use this class as if it's a bunch of class methods. E.g.:
+      #
+      #   TypesManager.build_const_converter(type)
+      #
+      def self.method_missing(method, *args)
+        if TypesManager.instance.respond_to?(method)
+          TypesManager.instance.send(method, *args)
+        else
+          super
+        end
+      end
+
+      attr_accessor :body, :prototypes, :includes
+
+      def initialize
+        @consts_wrapped = []
+        @body = []
+        @prototypes = []
+        @includes = []
+      end
+
+      # Some libraries have really bad namespace declarations
+      # so we allow for 2 methods of including files
+      # 1.  trace the class definition to the parent file
+      # 2.  explicitly declare which files to include in every generated source
+      #
+      def add_include_for(type)
+        file = type.file_name(false)
+        if Base.sources.include? file
+          @includes << "#include \"#{file}\""
+        else
+          Base.sources.each do |header|
+            @includes << "#include \"#{header}\""
+          end
+        end  
+      end
+      
+      # Rice doesn't automatically handle all to_ / from_ruby conversions for a given type.
+      # A common construct is the +const Type&+ variable, which we need to manually handle.
+      def build_const_converter(type)
+        type = type.is_a?(RbGCCXML::Type) ? type.base_type : type
+
+        # Don't need to deal with fundamental types
+        return if type.is_a?(RbGCCXML::FundamentalType)
+
+        full_name = type.qualified_name
+
+        # Only wrap once
+        # TODO cleaner way of doing this
+        return if @consts_wrapped.include?(full_name)
+
+        # Some types are already handled by Rice, ignore such types
+        return if full_name =~ /std::string/
+
+        @consts_wrapped << full_name
+
+        # Enumerations are handled slightly differently
+        class_type = if type.is_a?(RbGCCXML::Enumeration)
+                       "new #{full_name}(a)"
+                     else
+                       "(#{full_name} *)&a"
+                     end
+
+        @includes << "#include <rice/Object.hpp>"
+        @includes << "#include <rice/Data_Object.hpp>"
+        @includes << "#include <rice/Data_Type.hpp>"
+        add_include_for type
+
+        @body << "template<>"
+        @body << "Rice::Object to_ruby<#{full_name} >(#{full_name} const & a) {"
+        @body << "\treturn Rice::Data_Object<#{full_name} >(#{class_type}, Rice::Data_Type<#{full_name} >::klass(), 0, 0);"
+        @body << "}"
+
+        @prototypes << "template<>"
+        @prototypes << "Rice::Object to_ruby<#{full_name} >(#{full_name} const & a);"
+      end
+
+    end
+  end
+end

data/lib/rbplusplus/extension.rb

@@ -45,20 +45,11 @@ module RbPlusPlus
     # The list of modules to create
     attr_accessor :modules
 
-    # List of extra include directives
-    attr_accessor :includes
-
-    # List of directories for library searching
-    attr_accessor :lib_paths
-
-    # List of libraries to link
-    attr_accessor :libraries
-
-    # List of extra CXXFLAGS that might need to be added to compile lines
-    attr_accessor :cxxflags
-
-    # List of extra LDFLAGS that might need to be added to compile lines
-    attr_accessor :ldflags
+    # Various options given by the user to help with
+    # parsing, linking, compiling, etc.
+    #
+    # See #sources for a list of the possible options 
+    attr_accessor :options
 
     # Create a new Ruby extension with a given name. This name will be
     # the module built into the extension. 
@@ -67,11 +58,18 @@ module RbPlusPlus
       @name = name
       @modules = []
       @writer_mode = :multiple
-      @includes = []
-      @lib_paths = []
-      @libraries = []
-      @cxxflags = []
-      @ldflags = []
+
+      @options = {
+        :include_paths => [],
+        :library_paths => [],
+        :libraries => [],
+        :cxxflags => [],
+        :ldflags => [],
+        :include_source_files => [],
+        :includes => []
+      }
+
+      @node = nil
 
       if block
         build_working_dir(&block)
@@ -84,40 +82,56 @@ module RbPlusPlus
 
     # Define where we can find the header files to parse
     # Can give an array of directories, a glob, or just a string.
-    # All file names should be full paths, not partial.
+    # All file names should be full paths, not relative.
     #
-    # Options can be the following:
+    # Options can be any or all of the following:
     #
-    # * <tt>:include_paths</tt> - An array or string of full paths to be added as -I flags
-    # * <tt>:library_paths</tt> - An array or string of full paths to be added as -L flags
-    # * <tt>:libraries</tt> - An array or string of full paths to be added as -l flags
-    # * <tt>:cxxflags</tt> - An array or string of flags to be added to command line for parsing / compiling
-    # * <tt>:ldflags</tt> - An array or string of flags to be added to command line for linking
+    # * <tt>:include_paths</tt> - Path(s) to be added as -I flags
+    # * <tt>:library_paths</tt> - Path(s) to be added as -L flags
+    # * <tt>:libraries</tt> - Path(s) to be added as -l flags
+    # * <tt>:cxxflags</tt> - Flag(s) to be added to command line for parsing / compiling
+    # * <tt>:ldflags</tt> - Flag(s) to be added to command line for linking
+    # * <tt>:includes</tt> -  Header file(s) to include at the beginning of each .rb.cpp file generated.
+    # * <tt>:include_source_files</tt> - C++ source files that need to be compiled into the extension but not wrapped.
     def sources(dirs, options = {})
       parser_options = {}
 
       if (paths = options.delete(:include_paths))
-        @includes << paths
-        parser_options[:includes] = @includes
+        @options[:include_paths] << paths
+        parser_options[:includes] = paths
       end
 
       if (lib_paths = options.delete(:library_paths))
-        @lib_paths << lib_paths 
+        @options[:library_paths] << lib_paths 
       end
 
       if (libs = options.delete(:libraries))
-        @libraries << libs
+        @options[:libraries] << libs
       end
 
       if (flags = options.delete(:cxxflags))
-        @cxxflags << flags
-        parser_options[:cxxflags] = @cxxflags
+        @options[:cxxflags] << flags
+        parser_options[:cxxflags] = flags
       end
 
       if (flags = options.delete(:ldflags))
-        @ldflags << flags
+        @options[:ldflags] << flags
+      end
+
+      if (files = options.delete(:include_source_files))
+        @options[:include_source_files] << files
+      end
+      
+      if (flags = options.delete(:includes))
+        includes = Dir.glob(flags)
+        if(includes.length == 0)
+          puts "Warning: There were no matches for includes #{flags.inspect}"
+        else
+          @options[:includes] += [*includes]
+        end
       end
 
+      @sources = Dir.glob dirs
       @parser = RbGCCXML.parse(dirs, parser_options)
     end
 
@@ -125,12 +139,18 @@ module RbPlusPlus
     # Specifing a namespace on the Extension itself will mark functions,
     # class, enums, etc to be globally available to Ruby (aka not in it's own
     # module)
+    #
+    # For now, to get access to the underlying RbGCCXML query system, save the
+    # return value of this method:
+    #
+    #   node = namespace "lib::to_wrap"
+    #
     def namespace(name)
       @node = @parser.namespaces(name)
     end
 
     # Mark that this extension needs to create a Ruby module of
-    # a give name. Like Extension, this can be used with or without
+    # a give name. Like Extension.new, this can be used with or without
     # a block.
     def module(name, &block)
       m = RbModule.new(name, @parser, &block)
@@ -145,13 +165,15 @@ module RbPlusPlus
       raise "Unknown writer mode #{mode}" unless [:multiple, :single].include?(mode)
       @writer_mode = mode
     end
-
+    
     # Start the code generation process. 
     def build
       raise ConfigurationError.new("Must specify working directory") unless @working_dir
       raise ConfigurationError.new("Must specify which sources to wrap") unless @parser
 
       @builder = Builders::ExtensionBuilder.new(@name, @node || @parser)
+      Builders::Base.additional_includes  = @options[:includes]
+      Builders::Base.sources              = @sources
       @builder.modules = @modules
       @builder.build
     end
@@ -160,6 +182,7 @@ module RbPlusPlus
     # #build must be called before this step or nothing will be written out
     def write
       prepare_working_dir
+      process_other_source_files
       
       # Create the code
       writer_class = @writer_mode == :multiple ? Writers::MultipleFilesWriter : Writers::SingleFileWriter
@@ -167,11 +190,7 @@ module RbPlusPlus
 
       # Create the extconf.rb
       extconf = Writers::ExtensionWriter.new(@builder, @working_dir)
-      extconf.includes = @includes
-      extconf.library_paths = @lib_paths
-      extconf.libraries = @libraries
-      extconf.cxxflags = @cxxflags
-      extconf.ldflags = @ldflags
+      extconf.options = @options
       extconf.write
     end
 
@@ -192,7 +211,16 @@ module RbPlusPlus
     # and if it does exist, clean it out
     def prepare_working_dir
       FileUtils.mkdir_p @working_dir unless File.directory?(@working_dir)
-      FileUtils.rm_rf "#{@working_dir}/*"
+      FileUtils.rm_rf Dir["#{@working_dir}/*"]
+    end
+
+    # Make sure that any files or globs of files in :include_source_files are copied into the working
+    # directory before compilation
+    def process_other_source_files
+      files = @options[:include_source_files].flatten
+      files.each do |f|
+        FileUtils.cp Dir[f], @working_dir
+      end
     end
 
     # Cool little eval / binding hack, from need.rb

data/lib/rbplusplus/module.rb

@@ -42,8 +42,10 @@ module RbPlusPlus
 
     # Specify a C++ namespace from which the contained code will
     # be wrapped and exposed to Ruby under this Module.
+    #
+    # Also see Extension#namespace
     def namespace(name)
-      @node = @parser.namespaces(name)
+      @node = @parser.namespaces.find(:all, :name => name)
     end
 
     # Register another module to be defined inside of

data/lib/rbplusplus/transformers/class.rb

@@ -0,0 +1,67 @@
+module RbGCCXML
+  class Class
+    # Class can include nested classes and nested structs.
+    #
+    # Class can also include external methods/functions as class level methods
+    # also supports instance level methods
+    #
+    # ex. 
+    #
+    #   math_class.includes node.namespaces("Math").functions("mod")
+    #
+    # or for a instance method:
+    #
+    #   math_class.includes node.namespaces("Math").functions("mod").as_method
+    #
+    # or for nesting a class/struct:
+    #
+    #   math_class.includes node.namespaces("Math").classes("Degree")
+    #
+    def includes(val)
+      if (val.is_a?(RbGCCXML::Struct) || val.is_a?(RbGCCXML::Class))
+        @classes ||= []
+        @classes << RbPlusPlus::NodeReference.new(val)
+      else
+        @methods ||= []
+        @methods << RbPlusPlus::NodeReference.new(val)
+      end
+      val.moved=true 
+    end
+    
+    alias_method :node_methods, :methods
+    def methods(*args) #:nodoc:
+      nodes = node_methods(*args)
+      methods = @methods || QueryResult.new
+      methods << cache(nodes)
+      methods.flatten!
+      return methods if args.empty?
+      return (methods.size == 1 ? methods[0] : methods)
+    end
+
+    alias_method :node_classes, :classes
+    def classes(*args) #:nodoc:
+      [@classes || [], node_classes].flatten
+    end
+      
+    # returns a list of superclasses of this node, including the node's class
+    def super_classes
+      retv = []
+      unless node.attributes['bases'].nil? || node.attributes['bases'] == ""
+        node.attributes['bases'].split.each do |cls_id|
+          c = XMLParsing.find(:type => "Class", :id => cls_id)
+          c = XMLParsing.find(:type => "Struct", :id => cls_id) if c.nil?
+          if c.nil?
+            puts "#{self.qualified_name} cannot find super class for id #{cls_id} "
+            next
+          end
+          c = RbPlusPlus::NodeCache.instance.get(c)
+          retv << c unless c.ignored?
+        end
+      end
+      
+      return retv
+    end
+    
+  end
+end
+

data/lib/rbplusplus/transformers/constructor.rb

@@ -0,0 +1,4 @@
+module RbGCCXML
+  class Constructor #:nodoc:
+  end
+end

data/lib/rbplusplus/transformers/function.rb

@@ -0,0 +1,27 @@
+module RbGCCXML
+  class Function
+    attr_reader :special_qualified_name
+    
+    # always true for functions, false for methods
+    def static?
+      !(@as_method || false)
+    end
+    
+    # Sets this function to be an instance method.
+    # Useful for custom function declaration.
+    def as_instance_method
+      @as_method = true
+      return self
+    end
+    
+    def calls(method_name) 
+      @special_qualified_name = method_name
+      self
+    end
+    
+    alias_method :method_qualified_name, :qualified_name
+    def qualified_name #:nodoc:
+      @special_qualified_name || method_qualified_name
+    end
+  end
+end

data/lib/rbplusplus/transformers/method.rb

@@ -0,0 +1,4 @@
+module RbGCCXML
+  class Method #:nodoc:
+  end
+end

data/lib/rbplusplus/transformers/module.rb

@@ -0,0 +1,71 @@
+module RbPlusPlus
+  class RbModule
+    # Helper function for moving pieces of an API into other Ruby locations, eg from a Class to a Module, 
+    # from global functions to a Class, or from Module to Module.
+    #
+    # Module may include Functions
+    #   e.module "System" do |m|
+    #     m.includes node.functions("print").wrap_as("puts") # Moves the ::print function into the System module
+    #
+    #     m.include node.classes("Vector3") # Explicitly put Vector3 class in the System module
+    #   end
+    #
+    def includes(val)
+      if is_a?(val, RbGCCXML::Function)
+        reference_function(val)
+      elsif is_a?(val, RbGCCXML::Class)
+        reference_class(val)
+      elsif is_a?(val, RbGCCXML::Struct)
+        reference_struct(val)
+      else
+        raise "Cannot use #{self.class}#includes for type '#{val.class}'"
+      end
+    end
+    
+    def functions #:nodoc:
+      functions = @functions || []
+      functions << @node.functions if @node
+      functions.flatten
+    end
+    
+    def classes #:nodoc:
+      classes = @classes || []
+      classes << @node.classes if @node
+      classes.flatten
+    end
+  
+    def structs #:nodoc:
+      structs = @structs || []
+      structs << @node.structs if @node
+      structs.flatten
+    end
+    
+    private
+
+    # Map a function from a different namespace
+    def reference_function(val) #:nodoc:
+      @functions ||= []
+      @functions << NodeReference.new(val)
+      val.moved=true 
+    end
+    
+    # Map a class from a different namespace
+    def reference_class(val) #:nodoc:
+      @classes ||= []
+      @classes << NodeReference.new(val)
+      val.moved=true
+    end
+    
+    def reference_struct(val) #:nodoc:
+      @structs ||= []
+      @structs << NodeReference.new(val)
+      val.moved=true   
+    end
+        
+    def is_a?(val, klass) #:nodoc:
+      return true if val.is_a?(klass)
+      return true if val.is_a?(NodeReference) && val.references?(klass)
+      return false
+    end
+  end
+end

data/lib/rbplusplus/transformers/node.rb

@@ -0,0 +1,77 @@
+module RbGCCXML
+  class Node    
+    # Specifies to not export this node
+    def ignore
+      @ignored = true
+    end
+    
+    # Returns true if this node is ignored in exporting
+    def ignored?
+      @ignored || false
+    end
+
+    # Specifies that this node has been included somewhere else
+    def moved=(val)
+      @moved = val
+    end
+    
+    # Change what the name of this node will be when wrapped into Ruby
+    def wrap_as(name)
+      @renamed = name
+      self
+    end
+    
+    # Returns true if the node has been moved
+    def moved?
+      @moved || false
+    end
+    
+    # Has this node been renamed
+    def renamed?
+      (@renamed.nil? ? false : true)
+    end
+
+    alias_method :rbgccxml_namespaces, :namespaces
+    def namespaces(*args) #:nodoc:
+      nodes = rbgccxml_namespaces(*args)
+      return cache(nodes)
+    end
+    
+    alias_method :rbgccxml_classes, :classes
+    def classes(*args) #:nodoc:
+      nodes = rbgccxml_classes(*args)
+      return cache(nodes)
+    end
+    
+    alias_method :rbgccxml_functions, :functions
+    def functions(*args) #:nodoc:
+      nodes = rbgccxml_functions(*args)
+      return cache(nodes)
+    end
+ 
+    alias_method :rbgccxml_methods, :functions
+    def methods(*args) #:nodoc:
+      nodes = rbgccxml_methods(*args)
+      return cache(nodes)
+    end   
+ 
+    alias_method :rbgccxml_name, :name	
+    def name #:nodoc:
+      @renamed || rbgccxml_name
+    end
+    
+    private
+    # Looks up the objects in the node cache.
+    def cache(nodes)
+     if nodes.is_a?(QueryResult)
+        retv = QueryResult.new 
+        nodes.each do |node| 
+          retv << RbPlusPlus::NodeCache.instance.get(node)
+        end    
+        return retv
+      else
+        return RbPlusPlus::NodeCache.instance.get(nodes)
+      end    
+    end
+  end  
+end

data/lib/rbplusplus/transformers/node_cache.rb

@@ -0,0 +1,19 @@
+module RbPlusPlus
+  class NodeCache #:nodoc:
+    include Singleton
+    # Retrieves a node from the cache based on the node's qualified name
+    def get(node)
+      demangled = node.attributes['demangled']
+      @@nodes ||= {}
+      if @@nodes[demangled].nil?
+        @@nodes[demangled] = node
+      end
+      return @@nodes[demangled]
+    end
+    
+    # Clears out the cache
+    def clear
+      @@nodes = {}
+    end
+  end
+end

data/lib/rbplusplus/transformers/node_reference.rb

@@ -0,0 +1,30 @@
+module RbPlusPlus
+  class NodeReference #:nodoc:
+    # Takes the delegate object as input
+    def initialize(from)
+      @delegate = from
+    end
+    
+    # Delegate
+    def method_missing(name, *args)
+      @delegate.send name, *args
+    end
+    
+    # Always false
+    def moved?
+      false
+    end
+    
+    # Delegate
+    def methods(*args)
+      @delegate.methods *args
+    end
+    
+    # Returns true if the class references the specified class
+    def references?(klass)
+      return true if @delegate.is_a?(klass)
+      return true if @delegate.is_a?(NodeReference) && @delegate.references?(klass)
+      return false
+    end 
+  end
+end

data/lib/rbplusplus/transformers/rbgccxml.rb

@@ -0,0 +1,6 @@
+# In order to facilitate a very clean wrapping and code management API, 
+# Rb++ adds a few helper methods to various RbGCCXML node classes. What
+# is documented here are added on top of the normal RbGCCXML methods
+# documented elsewhere.
+module RbGCCXML
+end