easy-swig 1.0

data/lib/tasks/doxygen_task.rb

@@ -0,0 +1,28 @@
+module EasySwig
+
+  class DoxygenTask
+    include EasySwig
+    
+    def initialize config
+    	@config = config
+      if Dir.exists?(@config.doxy_dir)
+        FileUtils.rm_r @config.doxy_dir
+      end
+      FileUtils.mkdir_p @config.doxy_dir
+
+      @log = EasySwig::Logger.doxy_log(@config.doxy_dir)
+      @log.info { "Created Doxygen directory in #{@config.doxy_dir}" }
+    end
+
+    def generate
+      @log.info { "Creating Doxygen documentation in directory: #{@config.doxy_dir} ..." }
+      headers_dirs = [@config.headers_dir]   
+      output = Doxyparser::gen_xml_docs(headers_dirs, @config.doxy_dir, true, @config.includes_dir, @config.html, @config.stl_support)
+      @log.info { 'Doxygen documentation created at: '+ @config.doxy_dir}
+    end
+
+    def dispose
+      @log.close
+    end
+  end
+end

data/lib/tasks/generate_task.rb

@@ -0,0 +1,85 @@
+module EasySwig
+
+  class GenerateTask
+    include Util
+    include Print
+
+    def initialize(config)
+      @config = config
+      @gen_dir = @config.generate_dir+'/'+@config.lang
+      @generators = {}
+
+      FileUtils.rm_r @gen_dir if Dir.exists?(@gen_dir)
+      FileUtils.mkdir_p @gen_dir
+      FileUtils.cp "#{home_dir}/resources/#{@config.lang}/standard_header.i", "#{@gen_dir}/standard_header.i"
+      FileUtils.cp @config.custom_file, "#{@gen_dir}/custom_config.i" if @config.custom_file
+			FileUtils.cp "#{home_dir}/resources/swig-patches/attribute.i", "#{@gen_dir}/attribute.i"
+
+      @log=EasySwig::Logger.gen_log(@gen_dir)
+      @log.info { "Created Generator directory for #{@native_name} in #{@node_gen_dir}" }
+    end
+
+    def generate
+      module_file = <<-IFILE.escape_heredoc
+	      %module #{@config.module_name}
+
+	      %include "standard_header.i"
+	      %include "#{@config.custom_file}"
+	      %include "attribute.i"
+
+      IFILE
+
+      @log.info { "Parsing CSV file #{@csv_file} ..." }
+      csv_parser = EasySwig::Readers::CsvParser.new(@config.csv_file, @config.lang)
+      
+      @log.info { "Parsed CSV file. Number of entries: #{csv_parser.table.size}" }
+
+      @log.info { "Generating Namespaces from CSV file #{@csv_file}..." }
+      api_namespaces = csv_parser.namespaces_from_csv
+      @log.info { "Namespaces generated in memory: \n\t\tNamespaces: " + (api_namespaces.map{|n| n.basename}.join(', ')) }
+      @log.debug { "Namespace contents:\n\t\t\t\t" + print_api_namespaces(api_namespaces) }
+
+      api_namespaces.each do |api_namespace|
+
+        @log.info { "Parsing namespace from C++ files..." }
+        namespace = Doxyparser::parse_namespace(api_namespace.basename, @config.doxy_dir+'/xml')
+        @log.info { "C++ Namespace parsed" }
+
+        @log.info { "Associating namespace tree (classes, structs, enums...) with the corresponding Doxygen tree..." }
+        api_namespace.assoc_with_node(namespace)
+        @log.info { "Namespace Tree associated" }
+        @log.debug { print_api_namespace(api_namespace) }
+        
+        # If there are no classes in this namespace things get a bit tricky
+        conf_doxy_dir = @config.doxy_dir
+				if api_namespace.api_classes.empty?
+					api_namespace.define_singleton_method(:file) { 
+						Doxyparser::parse_file(api_namespace.basename + '.h', conf_doxy_dir+"/xml")
+					}
+				end
+
+        @log.info { "Associating and sorting header files for all sub-nodes of: #{api_namespace.node_type} #{api_namespace.name}..." }
+        hfiles = EasySwig::HFilesManager.assoc_headers(api_namespace)
+        @log.info { "Header files associated" }
+        hfiles = EasySwig::HFilesManager.sort_headers(hfiles)
+        @log.info { "Header files sorted" }
+        @log.debug { print_incl_files(hfiles) }
+
+        native_name = api_namespace.basename # Name of module (C++ namespace)
+        target_name = api_namespace.target_name # Name of target namespace
+
+        @generators[api_namespace] = Generator.create_instance(hfiles, api_namespace, @config, @log)
+
+        @log.info { "Generating SWIG configuration files..." }
+        gen_node_name = @generators[api_namespace].generate
+        @log.info { "SWIG configuration files generated" }
+        module_file << %Q{%include "#{gen_node_name}.i"\n}
+      end
+      write_file(%Q{#{@gen_dir}/#{@config.module_name}.i}, module_file)
+    end
+
+    def dispose
+      @log.close
+    end
+  end
+end

data/lib/tasks/hfiles_manager.rb

@@ -0,0 +1,86 @@
+module EasySwig
+  module HFilesManager
+
+    class << self
+
+      def assoc_headers(api_node)
+        
+        api_nodes = api_node.api_nodes
+        hfile_hash = Hash.new
+
+        api_nodes.each { |api_n|
+          hfile = api_n.file
+
+          next if hfile.nil?
+
+          filename = hfile.name
+
+          if hfile_hash[filename] == nil
+            params = {'node_type' => 'file', 'features' => api_n.features }
+            hfile_hash[filename] = IncFile.new(params).assoc_with_node(hfile)
+            hfile_hash[filename].assoc_inner_node(api_node)
+          end
+          api_n.header_file = hfile_hash[filename]
+          hfile_hash[filename].assoc_inner_node(api_n)
+        }
+        hfile_hash.each_value { |f|
+          f.ignore_inner_nodes
+          puts f.name
+        }
+        hfiles = hfile_hash.values
+        hfiles
+      end
+
+      def sort_headers(files)
+        sorted = []
+        includes = {}
+        while true
+
+          break if files.empty?
+
+          files_aux = files.map { |f| f.name }
+          files = files.sort { |fx,fy| compare(fx, fy, files_aux) }
+          includes = {}
+          while true
+            f = files.shift
+            break if f.nil?
+
+            incs = f.files_included.map { |x| x.name }
+            t1 = files.select { |h| incs.include?(h.name) }
+            t2 = sorted.select { |h| incs.include?(h.name) }
+            t2.select! { |h| compare(h, f, files_aux) > 0}
+            includes[f] = t1
+            includes[f] << t2.flatten
+            t1.each { |v| files.delete(v) }
+            t2.each { |v| sorted.delete(v) }
+            files -= includes[f]
+          end
+          sorted.push(*includes.keys)
+          files = includes.values.flatten
+        end
+        sorted.reverse
+      end
+
+      def compare(fx, fy, files_set)
+        num_incl_by_fx = num_included_by(fx, files_set)
+        num_incl_by_fy = num_included_by(fy, files_set)
+        num_incl_fx = num_includes(fx, files_set)
+        num_incl_fy = num_includes(fy, files_set)
+        if num_incl_by_fx == 0 && num_incl_by_fy == 0
+        return num_incl_fy <=> num_incl_fx
+        end
+        return -1 if num_incl_by_fx == 0
+        return  1 if num_incl_by_fy  == 0
+        return (num_incl_fy - num_incl_by_fy) <=> (num_incl_fx - num_incl_by_fx)
+      end
+
+      def num_includes(file, files_set)
+        file.files_included.map { |f| f.name }.select { |f| files_set.include?(f) }.size
+      end
+
+      def num_included_by(file, files_set)
+        file.files_including.map { |f| f.name }.select{ |f| files_set.include?(f) }.size
+      end
+    end
+  end
+end

data/lib/tasks/swig_task.rb

@@ -0,0 +1,69 @@
+module EasySwig
+  class SwigTask
+
+    def initialize(config)
+    	@config = config
+      @target = @config.target_file
+      @header_dir = @config.headers_dir
+      @out_dir = @config.output_dir
+      @lang = @config.lang
+      @inc_dirs = @config.includes_dir
+
+      if Dir.exists? @out_dir
+        FileUtils.rm_r @out_dir
+      end
+      FileUtils.mkdir_p(@out_dir)
+
+      @log=EasySwig::Logger.swig_log @out_dir
+      @log.info { "Created SWIG output directory in #{@out_dir}" }
+    end
+
+    def run_swig
+
+      swig_opts=%Q{-c++ -#{@lang} -v -Wall -debug-classes} # 
+      saved_dir = Dir.pwd
+      output_dir = @out_dir.clone
+      ifiles = []
+      current_dir = nil
+      if File.directory? @target
+        ifiles = Dir.entries(@target).select { |entry| File.extname(entry)=='.i' }
+        output_dir << "/#{File.basename(@target)}"
+        current_dir = @target
+      else
+        ifiles << File.basename(@target)
+        current_dir = ::File.dirname(@target)
+      end
+
+      ifiles.each { |f|
+        @log.info "\nExecuting SWIG command for file: " + f
+        target_name = File.basename(f, '.i')
+        odir = output_dir + "/#{target_name}"
+        FileUtils.mkdir_p(odir)
+        Dir.chdir current_dir
+        incs = ""
+        Dir.foreach(@header_dir) { |e|
+        	subdir = File.absolute_path(e, @header_dir)
+        	if File.directory?(subdir)
+          	incs << "-I#{subdir} "
+          end
+        }
+        @inc_dirs.each { |idir|
+          incs << "-I#{idir} "
+        }
+        command=%Q{swig #{swig_opts} -namespace #{target_name} -outdir #{odir} #{incs} #{f} > swig_output 2>&1}
+        @log.info command
+        output=IO.popen(command)
+        @log.debug { 'SWIG output:' }
+        @log.debug { output.readlines.join }
+        output.close
+        FileUtils.mv("#{File.basename(f, '.i')}_wrap.cxx", output_dir)
+      }
+      Dir.chdir saved_dir
+    end
+
+    def dispose
+      @log.close
+    end
+
+  end
+end

data/lib/util/logger.rb

@@ -0,0 +1,36 @@
+module EasySwig
+
+  class Logger
+    class << self
+
+      def doxy_log dir
+        file = File.open("#{dir}/doxygen.log", File::WRONLY | File::APPEND | File::CREAT)
+        @doxy_log ||= ::Logger.new(file)
+      end
+
+      def log msg
+        @gen_log.info msg
+      end
+
+      def gen_log dir=nil
+        @gen_log ||= ::Logger.new(File.open("#{dir}/generate.log", File::WRONLY | File::APPEND | File::CREAT))
+      end
+
+      def node_log dir=nil
+        @gen_log
+      end
+
+      def csv_log dir
+        @csv_log ||= ::Logger.new(File.open("#{dir}/generate.log", File::WRONLY | File::APPEND | File::CREAT))
+      end
+
+      def swig_log dir
+        @swig_log ||= ::Logger.new(File.open("#{dir}/swig.log", File::WRONLY | File::APPEND | File::CREAT))
+      end
+
+      def close_logs
+      end
+    end
+
+  end
+end

data/lib/util/print.rb

@@ -0,0 +1,72 @@
+module EasySwig
+  module Print
+
+    def print_incl_files incl_files
+      ret = ''
+      ret << "\nGenerated Include Files: "
+      incl_files.each { |f|
+        ret << "\nincl_file:" + f.basename
+        f.api_classes.each { |c|
+          ret << "\t"+"Api Class:" + c.basename
+          c.api_methods.each { |m|
+            ret << "\t"+"\t"+"Api Method:" + m.basename
+          }
+          c.ignored_methods.each { |m|
+            ret << "\t"+"\t"+"Ignored Method:" + m.basename
+          }
+        }
+        f.ignored_classes.each { |c|
+          ret << "\t"+"Ignored Class:" + c.basename
+        # c.methods.each { |m|
+        #  log "\t"+"\t"+"Ignored Method:" + m.name
+        #}
+        }
+      }
+      ret
+    end
+
+    def print_api_namespaces api_namespaces
+      ret = ''
+      api_namespaces.each { |api_ns|
+        ret <<  print_api_namespace(api_ns)
+      }
+      ret
+    end
+
+    def print_api_namespace api_ns
+      ret = '\n'
+      ret << "\tNamespace: "+ api_ns+"\n"
+      api_ns.api_functions.each { |f|
+        ret <<  "\t\tFunction: "+f.basename+" Assoc: "+f.wrapped_node.to_s + '\n'
+      }
+      api_ns.api_variables.each { |f|
+        ret <<  "\t\tVariable: "+f.basename+" Assoc: "+f.wrapped_node.to_s + '\n'
+      }
+      api_ns.api_enums.each { |f|
+        ret <<  "\t\tEnum: "+f.basename+" Assoc: "+f.wrapped_node.to_s + '\n'
+      }
+      api_ns.api_classes.each { |c|
+        ret << print_api_class(c)
+      }
+      ret
+    end
+
+    def print_api_class c
+      ret = ''
+      ret << "\t\tClass: " + c + "\n"
+      c.api_methods.each { |m|
+        ret << "\t\t\tMethod: "+m.basename+" Assoc: "+m.wrapped_node.to_s + '\n'
+      }
+      c.api_attributes.each { |m|
+        ret << "\t\t\tAttribute : "+m.basename+" Assoc: "+m.wrapped_node.to_s + '\n'
+      }
+      c.api_enums.each { |m|
+        ret << "\t\t\tEnum: "+m.basename+" Assoc: "+m.wrapped_node.to_s + '\n'
+      }
+      c.api_innerclasses.each { |m|
+        ret << "\t\t\tInnerClass: "+m.basename+" Assoc: "+m.wrapped_node.to_s + '\n'
+      }
+      ret
+    end
+  end
+end

data/lib/util/query.rb

@@ -0,0 +1,136 @@
+module EasySwig
+  module Query
+  	
+  	def get_reference_type(type, klass)
+  		if is_primitive?(type.name)
+    		return :ptr
+    	elsif type.name.end_with?('&')
+    		return :ref
+    	elsif type.name == 'std::string'
+    		return :str
+    	else
+    		looked_up = klass.lookup_node(type)
+    		return nil if looked_up.nil?
+    		if type.name.end_with?('*')
+    			if is_primitive?(looked_up.name)
+    				return :prim_ptr
+    			end
+    			return :ptr
+    		end
+    		if looked_up.class == Doxyparser::Enum
+    			return :ptr
+    		else
+    			return :val
+    		end
+    	end  
+    end
+
+    def lookup_typename(type, klass) # Type should not have * & const
+    	escaped_typename = escape_template(type.escaped_name)
+      return type.escaped_name if escaped_typename.include?('::') || is_primitive?(escaped_typename)
+      return type.escaped_name.gsub(escaped_typename, 'std::' + escaped_typename) if is_std?(escaped_typename)      
+      lookedup = klass.lookup_node(type)
+      return nil if lookedup.nil?
+			lookedup.name
+    end 
+    
+    def nested_typenames_for(typename) 
+    	Doxyparser::Type.nested_typenames(typename)
+    end
+    
+    def no_public_constructors?(klass)
+    	klass.constructors(:public).empty? && !klass.constructors(:all).empty?
+    end
+    
+    def no_public_destructors?(klass)
+    	klass.destructors(:public).empty? && !klass.destructors(:all).empty?
+    end
+  	
+  	def name_for_template(template_name)
+    		nested_typenames_for(template_name).map{ |typename|
+    			 del_prefix_class(typename.split(' ').join('')).capitalize 
+    		}.join('')
+    end
+
+    def name_for_operator(typename, num_args)
+      ret = case typename
+        when 'operator+'
+          return num_args == 2 ? '__add__' : '__pos__'
+        when 'operator-'
+          return num_args == 2 ? '__sub__' : '__neg__'
+        when 'operator*'
+          return '__mul__'
+        when 'operator/'
+          return '__div__'
+        when 'operator%'
+          return '__mod__'
+        when 'operator<<'
+          return '__lshift__'
+        when 'operator>>'
+          return '__rshift__'
+        when 'operator&'
+          return '__and__'
+        when 'operator||'
+          return '__or__'
+        when 'operator^'
+          return '__xor__'
+        when 'operator~'
+          return '__invert__'
+        when 'operator<'
+          return '__lt__'
+        when 'operator<='
+          return '__le__'
+        when 'operator>'
+          return '__gt__'
+        when 'operator>='
+          return '__ge__'
+        when 'operator=='
+          return '__eq__'
+        when 'operator()'
+          return '__call__'
+      else
+      return nil
+      end
+    end
+
+    def name_for_friend(typename, num_args = 0)
+      return '_friend_' + typename if num_args == 0
+      result = name_for_operator(typename, num_args)
+      return result.nil? ? '_friend_' + typename : result
+    end
+    
+    def is_template_param?(typename, klass)
+    	class_template_params = klass.template_params.map{|tp| tp.declname}
+    	return if nested_typenames_for(typename).any?{ |t| 
+    		class_template_params.include?(t) 
+    	}
+    end
+    
+    def is_template?(typename)
+    	Doxyparser::Type.template?(typename)
+    end
+    
+    def is_operator?(name)
+    	name =~ /operator\W+/
+    end
+
+    def method_has_blacklisted_types?(method)
+      return true if type_is_blacklisted?(method)
+      return true if method.params.any?{ |p| type_is_blacklisted?(p) }
+      return false
+    end
+
+    def type_is_blacklisted?(p)
+      return p.type.nested_typenames.any?{ |t| typename_is_blacklisted?(t)}
+    end
+
+    def typename_is_blacklisted?(typename)
+      return typename == 'multimap' || typename == 'std::multimap'
+    end
+    
+    def anonymous_enum?(enum)
+      enum.basename =~ /_Enum\d*$/
+    end
+
+  end
+end