rbplusplus 0.8 → 0.9

data/lib/rbplusplus/transformers/node.rb

@@ -1,77 +1,70 @@
 module RbGCCXML
-  class Node    
-    # Specifies to not export this node
+  class Node
+
+    # Specify to Rb++ that this node is not to be wrapped
     def ignore
-      @ignored = true
+      cache[:ignored] = true
+    end
+
+    # Un-ignore this node, useful if there's a glob ignore and the wrapper
+    # just wants a few of the classes
+    def unignore
+      cache[:ignored] = false
     end
-    
-    # Returns true if this node is ignored in exporting
+
+    # Has this node been previously declared to not be wrapped?
     def ignored?
-      @ignored || false
+      !!cache[:ignored]
     end
 
     # Specifies that this node has been included somewhere else
-    def moved=(val)
-      @moved = val
+    def moved_to=(val)
+      cache[:moved_to] = val
     end
-    
+
     # Change what the name of this node will be when wrapped into Ruby
     def wrap_as(name)
-      @renamed = name
+      cache[:wrap_as] = name
       self
     end
-    
-    # Returns true if the node has been moved
-    def moved?
-      @moved || false
+
+    # Where has this node moved to?
+    def moved_to
+      cache[:moved_to]
     end
-    
+
     # Has this node been renamed
     def renamed?
-      (@renamed.nil? ? false : true)
+      !!cache[:wrap_as]
     end
 
-    alias_method :rbgccxml_namespaces, :namespaces
-    def namespaces(*args) #:nodoc:
-      nodes = rbgccxml_namespaces(*args)
-      return cache(nodes)
+    alias_method :rbgccxml_name, :name
+    def name #:nodoc:
+      cache[:wrap_as] || rbgccxml_name
     end
-    
-    alias_method :rbgccxml_classes, :classes
-    def classes(*args) #:nodoc:
-      nodes = rbgccxml_classes(*args)
-      return cache(nodes)
+
+    def cpp_name
+      rbgccxml_name
     end
-    
-    alias_method :rbgccxml_functions, :functions
-    def functions(*args) #:nodoc:
-      nodes = rbgccxml_functions(*args)
-      return cache(nodes)
+
+    # In some cases, the automatic typedef lookup of rb++ can end up
+    # doing the wrong thing (for example, it can take a normal class
+    # and end up using the typedef for stl::container<>::value_type).
+    # Flag a given class as ignoring this typedef lookup if this
+    # situation happens.
+    def disable_typedef_lookup
+      cache[:disable_typedef_lookup] = true
     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
+
+    def _disable_typedef_lookup? #:nodoc:
+      !!cache[:disable_typedef_lookup]
     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    
+
+    protected
+
+    # Get this node's settings cache
+    def cache
+      NodeCache.get(self)
     end
-  end  
+  end
 end

data/lib/rbplusplus/transformers/node_cache.rb

@@ -1,18 +1,14 @@
 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']
+    # Retrieves or initializes a node's information cache
+    def self.get(node)
+      demangled = node.attributes['id']
       @@nodes ||= {}
-      if @@nodes[demangled].nil?
-        @@nodes[demangled] = node
-      end
-      return @@nodes[demangled]
+      @@nodes[demangled] ||= {}
     end
     
     # Clears out the cache
-    def clear
+    def self.clear
       @@nodes = {}
     end
   end

data/lib/rbplusplus/writers/multiple_files_writer.rb

@@ -4,120 +4,322 @@ module RbPlusPlus
     # multiple files.
     class MultipleFilesWriter < Base
 
+      # Writing out a multiple-file built is a multi-stage process. This writer
+      # first builds a [working_dir]/.build directory, where new code initially goes.
+      # Once the writing is complete, each file in .build/ is diff-checked by the files
+      # in [working_dir]. If the files are different, the new file is copied into place.
+      # Then, the .build dir is removed.
+      #
+      # We do this to allow for easy and quick-ish work on large wrapping projects. Because
+      # Rice code takes so long to compile, the fewer files one has to compile per change
+      # the better.
       def write
-        @to_from_include = ""
-        write_to_from_ruby
-        _write_node(builder)
+        build_working_dir
+        write_files
+        process_diffs
+        cleanup
+      end
+
+      private
+
+      def build_working_dir
+        @build_dir = File.join(working_dir, ".build")
+
+        # Build our temp dir
+        FileUtils.mkdir_p @build_dir
+      end
+
+      # Go through each file in @build_dir and check them against
+      # the files in @working_dir, copying over only the ones
+      # that differ
+      def process_diffs
+        Dir["#{@build_dir}/*.{cpp,hpp}"].each do |file|
+          FileUtils.cp file, working_dir if files_differ(file)
+        end
+      end
+
+      def files_differ(file)
+        filename = File.basename(file)
+        existing = File.expand_path(File.join(working_dir, filename))
+        new = File.expand_path(File.join(@build_dir, filename))
+        return true if !File.exists?(existing)
+
+        !system("diff #{existing} #{new} > #{@build_dir}/diff_info 2>&1")
       end
 
-      # Write out files that include the auto-generated to_/from_ruby constructs.
-      def write_to_from_ruby
-        # Ignore this if there's nothing to write out
-        return if Builders::TypesManager.body.length == 0
+      def cleanup
+        FileUtils.rm_rf @build_dir
+      end
+
+      # Given our builder, go through nodes and write out files
+      def write_files
+        # Couple of steps here:
+        #  - Split up the code into files according to Modules and Classes
+        #  - Header files need a register_#{name} prototype, source needs
+        #    register_#{name}(#{parent}) method definition
+        #  - All includes for this node go in the header.
+        #  - Source gets an include for the related header
+        #  - Save up all data from global_children and at the end write out
+        #    our rbpp_custom files, making sure all header files include
+        #    rbpp_custom.hpp
+
+        @file_writers = []
+        @global_writer = RbppCustomFileWriter.new
+        @globals_handled = []
 
-        hpp_file = File.join(working_dir, "_to_from_ruby.rb.hpp")
-        cpp_file = File.join(working_dir, "_to_from_ruby.rb.cpp")
+        new_file_for(self.builder)
+        process_globals(self.builder)
 
-        @to_from_include = "#include \"#{hpp_file}\""
+        @global_writer.with_includes(self.builder.additional_includes)
+        @global_writer.write(@build_dir)
 
-        include_guard = "__RICE_GENERATED_TO_FROM_RUBY_HPP__"
+        # Write out from the bottom up, makes sure that children file writers
+        # update their parents as needed
+        @file_writers.each do |fw|
+          fw.write(@build_dir)
+        end
+      end
 
-        File.open(hpp_file, "w+") do |f|
-          f.puts "#ifndef #{include_guard}" 
-          f.puts "#define #{include_guard}" 
-          f.puts ""
-          f.puts Builders::TypesManager.includes.uniq.join("\n")
-          f.puts ""
-          f.puts Builders::TypesManager.prototypes.join("\n")
-          f.puts ""
-          f.puts "#endif // #{include_guard}" 
+      def process_globals(node)
+        # Process the globals
+        node.global_nodes.each do |g|
+          next if @globals_handled.include?(g.qualified_name)
+          @globals_handled << g.qualified_name
+          @global_writer << g
         end
 
-        File.open(cpp_file, "w+") do |f|
-          f.puts @to_from_include
-          f.puts ""
-          f.puts Builders::TypesManager.body.join("\n");
+        node.nodes.each do |b|
+          process_globals(b)
         end
       end
 
-      # How this works:
-      #
-      # We'll recurse through the builder heirarchy, starting at the bottom.
-      # This lets us to properly link up each file so that all classes / modules / 
-      # functions get properly exposed.
-      def _write_node(node)
-        node.builders.each do |b|
-          _write_node(b)
-        end
-
-        filename = if node.parent
-                     "_"+node.qualified_name.gsub(/::/, "_")
-                   else
-                     node.name
-                   end
-                   
-        #templated classes
-        filename.gsub!(/[ ,<>]/,"_")
-        #templates to pointers
-        filename.gsub!("*","Ptr")
-
-        cpp_file = File.join(working_dir, "#{filename}.rb.cpp")
-
-        if node.parent
-          hpp_file = File.join(working_dir, "#{filename}.rb.hpp")
-          hpp_include = "#include \"#{hpp_file}\""
-          register_func = "register_#{filename}"
-
-          include_guard = "__RICE_GENERATED_#{filename}_HPP__"
-
-          register_func_arg = ""
-          register_func_prototype = ""
-
-          if !node.parent.is_a?(Builders::ExtensionBuilder)
-            register_func_arg = node.parent.rice_variable
-            register_func_prototype = "#{node.parent.rice_variable_type} #{register_func_arg}"
+      def new_file_for(node, parent = nil)
+        file_writer = FileWriter.new(node, parent)
+        @file_writers << file_writer
+
+        process_file(file_writer, node)
+      end
+
+      # Recursively run through this node's children
+      # adding them to the given file_writer or spawning
+      # off another file writer depending on the type
+      # of node we hit
+      def process_file(file_writer, node)
+        node.nodes.each do |child|
+          if child.is_a?(Builders::ModuleNode) || child.is_a?(Builders::ClassNode)
+            new_file_for(child, file_writer)
+          else
+            file_writer << child
+            process_file(file_writer, child) if child.has_children?
           end
+        end
+      end
+
+      # For every file to write out, we build an instance of a FileWriter here.
+      # This class needs to be given all the nodes it will be writing out to a file
+      #
+      # To handle parents calling register_#{name}() on their children, it's up to the
+      # children writers to inform the parents of their existence
+      class FileWriter
+
+        attr_reader :base_name, :node
+
+        def initialize(node, parent)
+          @node = node
+          @base_name = node.qualified_name.as_variable
+
+          @header = parent ? "_#{@base_name}.rb.hpp" : nil
+          @source = parent ? "_#{@base_name}.rb.cpp" : "#{@base_name}.rb.cpp"
+          @parent = parent
+
+          @require_custom = false
+
+          @needs_closing = true
+
+          register_with_parent if @parent
+
+          @nodes = [@node]
+        end
+
+        # Add a node to this file writer
+        def <<(node)
+          @nodes << node
+        end
+
+        def write(build_dir)
+          @build_dir = build_dir
+
+          build_source
+          write_header if @header
+          write_source
+        end
+
+        def rice_type
+          @node.rice_variable_type
+        end
+
+        def rice_variable
+          @node.rice_variable
+        end
+
+        def has_rice_variable?
+          !@node.rice_variable.nil?
+        end
 
-          # Changes we need to make to the parent for everything to work across multiple 
-          # files
-          #
-          # * Add an include to the hpp file
-          # * Add a call to the register method
-          node.parent.includes << hpp_include
+        def add_register_method(node_name, header)
+          @register_methods ||= []
+          @register_includes ||= []
 
-          # Register for proper flattening of the inheritance tree
-          node.parent.register_node(node, "#{register_func}(#{register_func_arg});")
+          @register_includes << "#include \"#{header}\""
+          @register_methods << "register_#{node_name}(#{has_rice_variable? ? self.rice_variable : ""});"
+        end
+
+        protected
+
+        def register_with_parent
+          @register_method = "void register_#{@base_name}"
+          @parent.add_register_method @base_name, @header
+        end
+
+        def build_source
+          @includes = []
+          @declarations = []
+          @registrations = []
+
+          @nodes.each do |node|
+            node.write
+            @includes << node.includes
+            @declarations << node.declarations
+            @registrations << node.registrations
+          end
+        end
+
+        def parent_signature
+          if @parent && @parent.has_rice_variable?
+            "#{@parent.rice_type} #{@parent.rice_variable}"
+          else
+            ""
+          end
+        end
 
-          # Modifications to this current node's code:
-          # 
-          # * Add a register prototype to the header file
-          # * Set include in node to the header file
-          # * Wrap the body in a register method
+        def write_header
+          include_guard = "__RICE_GENERATED_#{@base_name}_HPP__"
 
-          File.open(hpp_file, "w+") do |hpp|
+          File.open(File.join(@build_dir, @header), "w+") do |hpp|
             hpp.puts "#ifndef #{include_guard}"
             hpp.puts "#define #{include_guard}"
-            hpp.puts ""
-            hpp.puts @to_from_include
-            hpp.puts ""
-            hpp.puts "void #{register_func}(#{register_func_prototype});"
-            hpp.puts "#endif"
-          end
+            hpp.puts
+
+            custom_name = "_rbpp_custom.rb.hpp"
+            hpp.puts "#include \"#{custom_name}\"" if File.exists?(File.join(@build_dir, custom_name))
 
-          node.includes << hpp_include
+            if @register_method
+              hpp.puts "#{@register_method}(#{parent_signature});"
+            end
 
-          node.body = [
-            "void #{register_func}(#{register_func_prototype}) {",
-            node.body,
-            "}"
-          ]
+            hpp.puts
+            hpp.puts "#endif // #{include_guard}"
+          end
         end
 
-        File.open(cpp_file, "w+") do |cpp|
-          cpp.puts node.to_s
+        def write_source
+          File.open(File.join(@build_dir, @source), "w+") do |cpp|
+            if (incls = @includes.flatten.compact).any?
+              cpp.puts "", incls.uniq.sort.reverse.join("\n"), ""
+            end
+
+            if @register_method
+              cpp.puts "", "#include \"#{@header}\"", ""
+            end
+
+            if @require_custom
+              custom_name = "_rbpp_custom.rb.hpp"
+              cpp.puts "#include \"#{custom_name}\"" if File.exists?(File.join(@build_dir, custom_name))
+            end
+
+            if @register_includes
+              @register_includes.each do |i|
+                cpp.puts i
+              end
+            end
+
+            if (decls = @declarations.flatten.compact).any?
+              cpp.puts "", decls.join("\n"), ""
+            end
+
+            if @register_method
+              cpp.puts "#{@register_method}(#{parent_signature}) {"
+            end
+
+            if (regs = @registrations.flatten.compact).any?
+              cpp.puts regs.join("\n")
+            end
+
+            if @register_methods
+              @register_methods.each do |m|
+                cpp.puts m
+              end
+            end
+
+            # I really need a better way of handling this
+            if @needs_closing
+              cpp.puts "}"
+            end
+          end
         end
+
       end
 
+      class RbppCustomFileWriter < FileWriter
+
+        def initialize
+          @base_name = "rbpp_custom"
+          @header = "_#{@base_name}.rb.hpp"
+          @source = "_#{@base_name}.rb.cpp"
+          @nodes = []
+          @needs_closing = false
+          @additional_includes = []
+          @require_custom = true
+        end
+
+        def with_includes(includes)
+          @additional_includes =
+            includes.flatten.inject([]) do |memo, incl|
+              memo << "#include \"#{incl}\""; memo
+            end
+        end
+
+        protected
+
+        def write_header
+          return unless @registrations.flatten.compact.any?
+
+          include_guard = "__RICE_GENERATED_#{@base_name}_HPP__"
+
+          File.open(File.join(@build_dir, @header), "w+") do |hpp|
+            hpp.puts "#ifndef #{include_guard}"
+            hpp.puts "#define #{include_guard}"
+
+            if (incls = [@includes, @additional_includes].flatten.compact).any?
+              hpp.puts "", incls.uniq.sort.reverse.join("\n"), ""
+            end
+
+            if (decls = @declarations.flatten.compact).any?
+              hpp.puts "", decls.join("\n"), ""
+            end
+            hpp.puts
+            hpp.puts "#endif // #{include_guard}"
+          end
+
+          @declarations = []
+          @includes = []
+        end
+
+        def write_source
+          super if @registrations.flatten.compact.any?
+        end
+
+      end
 
     end
   end

data/lib/rbplusplus/writers/single_file_writer.rb

@@ -4,37 +4,59 @@ module RbPlusPlus
     # one single file
     class SingleFileWriter < Base
 
+      def initialize(builder, working_dir)
+        super
+
+        @includes = []
+        @declarations = []
+        @registrations = []
+
+        # Keep track of the code generated by the global nodes
+        @global_hpp = []
+        @global_cpp = []
+      end
+
       def write
         process_code(builder)
 
-        if Builders::TypesManager.body.length > 0
-          # Handle to_from_ruby constructions
-          builder.declarations << Builders::TypesManager.body
-        end
-
         filename = builder.name
         cpp_file = File.join(working_dir, "#{filename}.rb.cpp")
 
         File.open(cpp_file, "w+") do |cpp|
-          cpp.puts builder.to_s
+
+          cpp.puts @includes.flatten.compact.uniq.sort.reverse.join("\n")
+          cpp.puts @global_hpp.flatten.compact.join("\n")
+          cpp.puts @declarations.flatten.compact.join("\n")
+          cpp.puts @global_cpp.flatten.compact.join("\n")
+          cpp.puts @registrations.flatten.compact.join("\n")
+          cpp.puts "}" # Yeah, need to figure this one out
+
         end
       end
 
       protected
 
       # What we do here is to go through the builder heirarchy
-      # and push all the code from children up to the parent, 
+      # and push all the code from children up to the parent,
       # ending up with all the code in the top-level builder
       def process_code(builder)
-        builder.builders.each do |b|
-          process_code(b)
-        end
+        builder.write
 
-        return unless builder.parent
+        @includes << builder.includes
+        @declarations << builder.declarations
+        @registrations << builder.registrations
 
-        builder.parent.includes << builder.includes
-        builder.parent.body << builder.body
-        builder.parent.declarations << builder.declarations
+        # Process the globals
+        builder.global_nodes.each do |g|
+          g.write
+          @includes << g.includes
+          @global_hpp << g.declarations
+          @global_cpp << g.registrations
+        end
+
+        builder.nodes.each do |b|
+          process_code(b)
+        end
       end
 
     end