easy-swig 1.0

data/lib/generators/generator.rb

@@ -0,0 +1,124 @@
+module EasySwig
+
+  class Generator
+  	include Util
+
+    attr_accessor :namespace_generator
+    attr_accessor :class_generator
+    attr_accessor :hfile_generator
+
+    def self.create_instance(hfiles, api_namespace, config, log)
+      ret = case config.lang
+        when 'csharp'
+          EasySwig::Csharp::CsharpGenerator.new(hfiles, api_namespace, config, log)
+        when 'java'
+          EasySwig::Java::JavaGenerator.new(hfiles, api_namespace, config, log)
+      else
+      EasySwig::Generator.new(hfiles, api_namespace, config, log)
+      end
+      ret
+    end
+
+    def initialize(hfiles, api_namespace, config, log)
+      @config = config
+      @gen_dir = @config.generate_dir + '/' + @config.lang
+      @log = log
+      @hfiles = hfiles
+      @api_namespace = api_namespace
+      @target_name = api_namespace.target_name
+      @native_name = api_namespace.basename
+      @native_gen_dir = "#{@gen_dir}/#{@native_name}"
+      @all_types = {}
+      @all_innerclasses = {}
+      @all_friends = {}
+
+      if Dir.exists?(@native_gen_dir)
+        FileUtils.rm_r @native_gen_dir
+      end
+      FileUtils.mkdir_p @native_gen_dir
+      @log.info { "Created Generator directory for #{@native_name} in #{@native_gen_dir}" }
+
+      init_generators
+    end
+
+    def generate
+      @log.info { 'Generating interface files...' }
+
+      namespace_file = <<-IFILE.escape_heredoc
+		       %module #{@target_name}
+
+		       %include "standard_header.i"
+		       %include "#{@config.custom_file}"
+
+      IFILE
+      namespace_file << @namespace_generator.new(@api_namespace).generate()
+
+      @hfiles.each { |hfile|
+        generate_ifile(hfile)
+        ifile = to_ifile(hfile.name)
+        namespace_file << %Q{%include "#{@native_name}/#{ifile}"\n}
+      }
+      write_file("#{@gen_dir}/#{namespace_filename(@native_name)}.i", namespace_file)
+      @log.info { "Interface file #{@gen_dir}/#{namespace_filename(@native_name)}.i created" }
+      namespace_filename(@native_name)
+    end
+
+    protected
+
+    def init_generators
+      @class_generator = EasySwig::ClassGenerator
+      @namespace_generator = EasySwig::NamespaceGenerator
+      @hfile_generator = EasySwig::HFileGenerator
+    end
+
+    def to_ifile(filename)
+      extension = File.extname(filename)
+      filename.gsub(extension, '.i')
+    end
+
+    def generate_ifile(hfile)
+      swig_file = <<-IFILE.escape_heredoc
+	      %module #{@target_name}
+
+				%include "standard_header.i"
+				%include "custom_config.i"
+
+				// Include headers:
+				%{
+				#include "#{hfile.name}"
+				%}
+
+				// Rename and ignore members:
+
+      IFILE
+
+      @log.debug { "Generating renames for #{hfile.name} ..." }
+
+      swig_file << @hfile_generator.new(hfile).generate
+
+      class_generators = []
+
+      hfile.api_classes.each { |api_cls|
+        class_gen_instance = @class_generator.new(api_cls, @all_types, @all_innerclasses, @all_friends)
+        class_generators << class_gen_instance
+        swig_file << class_gen_instance.process_types
+        swig_file << class_gen_instance.gen_friends
+        swig_file << class_gen_instance.gen_methods
+        swig_file << class_gen_instance.gen_attributes
+        swig_file << class_gen_instance.gen_enums
+        swig_file << class_gen_instance.gen_innerclasses
+        swig_file << class_gen_instance.gen_type_templates
+      }
+      swig_file << %Q{%include "#{hfile.name}"}
+      
+      ifile = to_ifile(hfile.name)
+      write_file(%Q{#{@native_gen_dir}/#{ifile}}, swig_file)
+      @log.info { "Interface file #{@native_name}/#{ifile} created" }
+    end
+
+    def namespace_filename native_name
+      "ns_#{native_name}"
+    end
+
+  end
+end 

data/lib/generators/generator_util.rb

@@ -0,0 +1,135 @@
+module EasySwig
+  module GeneratorUtil
+  	include Util
+  	include Query
+  	
+  	def nested_workaround(innerclass)	# Innerclasses    	
+      return '' if innerclass.abstract?
+      return '' if no_public_constructors?(innerclass) || no_public_destructors?(innerclass)
+      return '' if @all_innerclasses[innerclass.target_name]
+      
+      namespace = @api_class.parent
+    	siblings = namespace.classes + namespace.structs
+      return '' if siblings.any?{ |c| c.basename == innerclass.basename }
+    	swig_file  = ''
+    	own_typedefs = {}
+      
+      swig_file << "namespace #{namespace.name} {\n"
+      swig_file << "\tclass #{innerclass.target_name} {\n"
+      swig_file << "\t\tpublic:\n"
+      innerclass.api_attributes.each { |attr| 
+      	typename = attr.type.name
+      	if is_template?(typename)
+      		typename = typename.gsub('>::type', '>') # TODO only for Ogre
+      	end
+       	swig_file << "\t\t#{attr.static.to_s} #{typename} #{attr.basename};\n"
+      }
+      innerclass.api_methods.each { |meth|
+      	broken = false
+	      type_typename = meth.type.name
+      	if is_template?(type_typename)
+      		type_typename = type_typename.gsub('>::type', '>') # TODO only for Ogre
+      	end
+        param_typenames = ""
+	      n = 1
+        meth.params.map{ |p|
+        	typename = p.type.name
+      		if is_template?(typename)
+      			typename = typename.gsub('>::type', '>') # TODO only for Ogre
+      		end
+      		param_typenames << " #{typename} arg#{n},"
+      		n += 1
+        }
+        next if broken
+        swig_file << "\t\t#{meth.static.to_s} #{type_typename} #{meth.basename}(#{param_typenames.chop});\n"
+      }
+      innerclass.api_enums.each { |enum|
+        swig_file << enum_snippet(enum)
+      }
+      @all_innerclasses[innerclass.target_name] = 1
+      swig_file << "\t};\n}\n"
+      swig_file << "%rename(#{innerclass.target_name}) #{innerclass.basename};\n"
+      swig_file << "%nestedworkaround #{@api_class.name}::#{innerclass.basename};\n"
+      swig_file << "%{\nnamespace #{namespace.name} {\n"
+      swig_file << "\ttypedef #{@api_class.name}::#{innerclass.basename} #{innerclass.target_name};\n"
+      swig_file << "}\n%}\n"
+      swig_file
+    end
+    
+    def process_type(type, klass)
+    	new_type = type.dup
+    	new_type.name = type.escaped_name
+    	new_typename = _process_type(new_type, klass)
+    	type.name = type.name.gsub(type.escaped_name, new_typename)
+    end
+    
+    def _process_type(type, klass)
+    	raise ArgumentError if type.nil?
+    	cached_type = @types[type.escaped_name]
+    	return cached_type unless cached_type.nil?
+    	# Don't instantiate templates for functions with type params
+    	return nil if is_template_param?(type.escaped_name, klass)
+    	
+    	typename = type.escaped_name.dup
+    	if is_template?(typename)
+    	 	nested_typenames_for(typename).each{ |t|
+    	 		nested_type = Doxyparser::Type.new({ name: t, dir: ""})
+        	typename.gsub!(t, _process_type(nested_type, klass))
+      	}
+      	expanded_typename = typename 
+      else
+      	lookedup = lookup_typename(type, klass)  
+      	raise ArgumentError if lookedup.nil?  	
+      	if is_template?(lookedup) # Repeat recursively
+      		lookedup_escaped = escape_const_ref_ptr(lookedup)
+      		lookedup_type = Doxyparser::Type.new({ name: lookedup_escaped, dir: ""})
+      		expanded_typename = lookedup.gsub!(lookedup_escaped, _process_type(lookedup_type, klass))
+      	else
+      		expanded_typename = lookedup
+      	end
+    	end
+    	escaped_typename = escape_const_ref_ptr(expanded_typename)
+    	unless @all_types.has_key?(escaped_typename)
+    	  @all_types[escaped_typename] = 1
+        @types[type.name] = escaped_typename
+      end
+			return expanded_typename	
+    end
+    
+    def template_snippet(typename, expanded)
+    	swig_file = ''
+  	  expanded = expanded.gsub('>::type', '>') # TODO only for Ogre
+    	if is_template?(expanded)
+    		typename = name_for_template(expanded) if is_template?(typename) # TODO reconsider
+      	swig_file << "%template(#{typename}) #{expanded};\n"
+      end
+      swig_file
+    end
+    
+    def enum_snippet(enum)
+      snippet = "\n\t\tenum #{enum.basename} {"
+      aux = ''
+      enum.values.each { |v|
+        aux << "\n\t\t\t#{v.basename}" 
+        if v.initializer
+        	aux << " = #{v.initializer}," 
+        else
+        	aux << ","
+        end
+      }
+      aux.chomp! ','
+      snippet << aux
+      snippet << "\n\t\t};\n"
+      snippet
+    end
+    
+    def ignore_enum_values_snippet(enum)
+      snippet = ""
+      enum.values.each { |v|
+        snippet << "%rename($ignore) #{enum.parent.name}::#{v.basename};\n"
+      }
+      snippet
+    end
+
+  end
+end

data/lib/generators/hfile_generator.rb

@@ -0,0 +1,56 @@
+module EasySwig
+	class HFileGenerator
+		include GeneratorUtil
+
+		def initialize(hfile)
+  		@hfile = hfile
+  	end
+
+		def generate
+			swig_file = generate_functions
+			swig_file << generate_variables
+			swig_file << generate_enums
+			swig_file << generate_classes
+		end
+		
+		def generate_functions
+			swig_file = ''
+			@hfile.ignored_functions.each { |func|
+        swig_file << %Q{%rename("$ignore") #{func.basename};} + "\n"
+      }
+			swig_file
+		end
+		
+		def generate_variables
+			swig_file = ''
+			@hfile.ignored_variables.each { |var|
+        swig_file << %Q{%rename("$ignore") #{var.basename};} + "\n"
+      }
+			swig_file
+		end
+		
+		def generate_enums
+			swig_file = ''
+			@hfile.api_enums.each { |enum|
+      	if anonymous_enum?(enum)  # @Anonymous Enums
+          swig_file << enum_snippet(enum)
+					enum.values.each { |v|
+    	    	swig_file << "%rename($ignore) ::#{v.basename};\n"
+	     		}
+				end
+      }
+			@hfile.ignored_enums.each { |enum|
+        swig_file << %Q{%rename("$ignore") #{enum.basename};} + "\n"
+      }
+			swig_file
+		end
+		
+		def generate_classes
+			swig_file = ''
+			@hfile.ignored_classes.each { |cls|
+        swig_file << %Q{%rename("$ignore") #{cls.name};} + "\n"
+      }
+			swig_file
+		end
+	end
+end

data/lib/generators/namespace_generator.rb

@@ -0,0 +1,58 @@
+module EasySwig
+
+  class NamespaceGenerator
+    include GeneratorUtil
+
+    def initialize(api_ns)
+      @api_ns = api_ns
+    end
+
+    def generate
+      swig_file = generate_functions
+      swig_file << generate_variables
+      swig_file << generate_enums
+    end
+
+    protected
+
+    def generate_functions
+      swig_file = ''
+      @api_ns.ignored_functions.each { |m|
+        swig_file << %Q{%rename("$ignore") #{m.name};} + "\n"
+      }
+      @api_ns.api_functions.each { |m|
+        swig_file << %Q{%rename(#{m.target_name}) #{m.name};} + "\n"
+      }
+      swig_file
+    end
+
+    def generate_variables
+      swig_file = ''
+      @api_ns.ignored_variables.each { |m|
+        swig_file << %Q{%rename("$ignore") #{m.name};} + "\n"
+      }
+      @api_ns.api_variables.each { |m|
+        swig_file << %Q{%rename(#{m.target_name}) #{m.name};} + "\n"
+      }
+      swig_file
+    end
+
+    def generate_enums
+      swig_file = ''
+      @api_ns.ignored_enums.each { |m|
+        swig_file << %Q{%rename("$ignore") #{m.name};} + "\n"
+      }
+      @api_ns.api_enums.each { |enum|
+        if anonymous_enum?(enum)  # @Anonymous Enums
+          swig_file << "\nnamespace #{@api_ns.name} {\n"
+          swig_file << enum_snippet(enum)
+          swig_file << "\n}\n"
+	        swig_file << ignore_enum_values_snippet(enum)
+        else
+          swig_file << %Q{%rename(#{enum.target_name}) #{enum.name};} + "\n"
+        end
+      }
+      swig_file
+    end
+  end
+end

data/lib/generators/properties.rb

@@ -0,0 +1,13 @@
+module EasySwig
+
+  class Properties
+    attr_accessor :class_name
+    attr_accessor :getter
+    attr_accessor :setter
+    attr_accessor :attribute
+    attr_accessor :type_setter
+    attr_accessor :type_getter
+    attr_accessor :ref_type
+    attr_accessor :static
+  end
+end

data/lib/readers/csv_parser.rb

@@ -0,0 +1,127 @@
+module EasySwig
+module Readers
+  class CsvParser
+    
+    attr_accessor :col_headers
+    attr_accessor :table
+
+    def initialize csv_file, lang
+      @lang = lang
+      @csv_file=csv_file
+      @col_headers = {}
+      @table = []
+      parse
+    end
+
+    def parse
+      File.open(@csv_file) { |f|
+        aux = f.readline
+        var = aux.chomp.split(%r{[,\t]})
+        until var[0]==nil || var[0].empty?
+          @col_headers[var[0]] = var[1..-1]
+          var = f.readline.chomp.split(%r{[,\t]})
+        end
+        until f.eof?
+          row = f.readline.chomp.split(%r{[,\t]})
+          row.each { |r| r.strip! }
+          rowtype=row[0]
+          if rowtype.nil? || rowtype.empty?
+            next
+          end
+          row = @col_headers[rowtype].zip(row[1..-1]).flatten
+          lang_features = EasySwig::Features.create_instance @lang 
+          line = Hash['features', lang_features, 'node_type', rowtype, *row].delete_if { |k, v| k=="" || v.nil? || v.empty? }
+          @table << line
+        end
+      }
+    end
+
+    # Generate namespace object representations from an input CSV file
+    def namespaces_from_csv
+      obj=nil
+      namespaces=[]
+      last_ns=nil
+      last_class=nil
+
+      @table.each { |type|
+        ignore = type['ignore']
+        obj=nil
+        case type['node_type']
+          when 'namespace'
+            obj=ApiNamespace.new(type)
+            last_ns=obj
+            namespaces << obj
+          when 'class'
+            type['parent'] = last_ns
+            obj=ApiClass.new(type)
+            last_class=obj            
+            if ignore
+              last_ns.ignored_classes << obj
+            else
+              last_ns.api_classes << obj
+            end
+          when 'enum'
+            type['parent'] = last_ns
+            obj=ApiEnum.new(type)
+            if ignore
+              last_ns.ignored_enums << obj
+            else
+              last_ns.api_enums << obj
+            end            
+          when 'function'
+            type['parent'] = last_ns
+            obj=ApiFunction.new(type)
+            if ignore
+              last_ns.ignored_functions << obj
+            else
+              last_ns.api_functions << obj
+            end
+          when 'variable'
+            type['parent'] = last_ns
+            obj=ApiVariable.new(type)
+            if ignore
+              last_ns.ignored_variables << obj
+            else
+              last_ns.api_variables << obj
+            end
+          when 'method'
+            type['parent'] = last_class
+            obj=ApiMethod.new(type)
+            if ignore
+              last_class.ignored_methods << obj
+            else
+              last_class.api_methods << obj
+            end
+          when 'innerclass'
+            type['parent'] = last_class
+            obj=ApiClass.new(type)
+            if ignore
+              last_class.ignored_innerclasses << obj
+            else
+              last_class.api_innerclasses << obj
+            end            
+          when 'innerenum'
+            type['parent'] = last_class
+            obj=ApiEnum.new(type)
+            if ignore
+              last_class.ignored_enums << obj
+            else
+              last_class.api_enums << obj
+            end
+          when 'attribute'
+            type['parent'] = last_class
+            obj=ApiAttribute.new(type)
+            if ignore
+              last_class.ignored_attributes << obj
+            else
+              last_class.api_attributes << obj
+            end
+          else
+            raise "Malformed CSV Input: Node type " + type["node_type"] + " does not exist"
+        end
+      }
+      namespaces
+    end    
+  end
+end
+end