ffi-swig-generator 0.2.1 → 0.3.0

data/lib/ffi-swig-generator.rb

@@ -1,7 +1,7 @@
 module FFI
   module Generator
     # :stopdoc:
-    VERSION = '0.2.1'
+    VERSION = '0.3.0'
     LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
     PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
     # :startdoc:

data/lib/generator/application.rb

@@ -22,7 +22,7 @@ EOU
           process_args
           if ARGV.size == 2
             File.open(ARGV[1], 'w') do |file|
-              file << FFI::Generator::Parser.generate(Nokogiri::XML(File.open(ARGV[0])))
+              file << FFI::Generator::Parser.new.generate(Nokogiri::XML(File.open(ARGV[0])))
             end
           else
             help

data/lib/generator/constant.rb

@@ -0,0 +1,24 @@
+module FFI
+  module Generator
+    require libpath('generator/node')
+    class Constant < Node
+      def initialize(params = { })
+        super
+        @name, @value = get_attr('sym_name'), get_attr('value')
+      end
+      def to_s
+        @indent_str + "#{@name} = #{sanitize!(@value)}"        
+      end
+      private
+      def sanitize!(value)
+        if @value.match(/\d+U$/) or @value.match(/\d+L$/)
+          result = value.chop
+        elsif @value.match(/\d+UL$/)
+          result = @value.chop.chop
+        else
+          result = @value
+        end
+      end
+    end
+  end
+end

data/lib/generator/enum.rb

@@ -0,0 +1,38 @@
+module FFI
+  module Generator
+    require libpath('generator/node')
+    class Enum < Node
+      def initialize(params = { })
+        super
+        eval_items
+      end
+      def to_s
+        @items.sort { |i1, i2| i1[1] <=> i2[1] }.inject("") do |result, item|
+          result << assignment_str(item[0], item[1]) << "\n"
+        end
+      end
+      private
+      def assignment_str(name, value)
+        @indent_str + "#{name} = #{value}"
+      end
+      def eval_expr(expr)
+        if expr.include?('+')
+          (@items[expr[/\w+/]].to_i + 1).to_s
+        else
+          0.to_s
+        end
+      end
+      def eval_items
+        @items = {}
+        get_items.each do |i|
+          node = Node.new(:node => i)
+          @items[node.get_attr('name')] = node.get_attr('enumvalueex') ? eval_expr(node.get_attr('enumvalueex')) : node.get_attr('enumvalue')
+        end
+        @items
+      end
+      def get_items
+        @node / './enumitem'
+      end
+    end
+  end
+end

data/lib/generator/function.rb

@@ -0,0 +1,71 @@
+module FFI
+  module Generator
+    require libpath('generator/type')
+    class Function < Type
+      class Argument < Type
+        def to_s
+          case get_attr('type')
+          when 'void'
+            nil
+          when 'v(...)'
+            ':varargs'
+          else
+            super
+          end
+        end
+      end
+      def initialize(params = { })
+        super
+        @type = get_attr('type')
+      end
+      def to_s
+        params = get_params(@node).inject([]) do |array, node|
+          array << Argument.new(:node => node, :typedefs => @typedefs).to_s
+        end
+        @indent_str + "attach_function :#{@symname}, [ #{params.join(', ')} ], #{get_rtype}"
+      end
+      private
+      def get_params(node)
+        parmlist = node / './attributelist/parmlist/parm'
+      end
+      def get_rtype
+        pointer = get_attr('decl').scan(/^f\(.*\)\.(p)/).flatten[0]
+        declaration = pointer ? "p.#{get_attr('type')}" : get_attr('type')
+        Type.new(:declaration => declaration, :typedefs => @typedefs).to_s
+      end
+    end
+    class Callback < Function
+      def initialize(params = { })
+        super(params)
+        @inline = true if params[:inline] == true
+      end
+      def to_s
+        unless @inline
+          @indent_str + "callback(:#{@symname}, [ #{get_params.join(', ')} ], #{get_rtype})"
+        else
+          @indent_str + "callback([ #{get_params.join(', ')} ], #{get_rtype})"
+        end
+      end
+      private
+      def get_params
+        params = (@node / './attributelist/parmlist/parm')
+        declaration = decl
+        unless params.empty?
+          result = params.inject([]) do |array, node|
+            declaration.gsub!(/#{Regexp.escape(Type.new(:node => node, :typedefs => @typedefs).get_attr('type'))}/, '')
+            array << Argument.new(:node => node, :typedefs => @typedefs).to_s
+          end
+        else
+          result = @full_decl.scan(/p.f\((.*)\)/).flatten[0].split(',').inject([]) do |array, type|
+            array << (type == 'void' ? '' : Type.new(:declaration => type, :typedefs => @typedefs).to_s)
+          end
+        end
+        @full_decl = declaration + type
+        result
+      end
+      def get_rtype
+        Type.new(:declaration => @full_decl.scan(/f\([a-zA-z0-9,.\s\(\)]*\)\.([a-zA-Z0-9\.,\s\(\)]+)/).flatten[0], :typedefs => @typedefs).to_s
+      end
+    end
+  end
+end

data/lib/generator/generatortask.rb

@@ -3,8 +3,12 @@ require 'rake/tasklib'
 module FFI
   module Generator
     class Task < Rake::TaskLib
-      def initialize(options = {})
+      attr_accessor :input_fn, :output_dir
+      def initialize(options = {}, &blk)
         @options = { :input_fn => '*.i', :output_dir => 'generated/' }.merge(options)
+        @input_fn = @options[:input_fn]
+        @output_dir = @options[:output_dir]
+        yield self if block_given?
         namespace 'ffi' do
           define_generate_task
           define_clean_task
@@ -14,19 +18,27 @@ module FFI
       def define_file_task(fn, xml_fn, output_fn)
         desc "Generate #{output_fn} from #{fn}"
         file output_fn => fn do
-          mkdir_p @options[:output_dir], :verbose => false
-          puts "Generating #{xml_fn} from #{fn} using SWIG..."
+          mkdir_p @output_dir, :verbose => false
+          Logger.info("#{fn} -> #{xml_fn}")
           `swig -xml #{xml_fn} #{fn}`
-          puts "Generating #{output_fn} from #{xml_fn}..."
+          Logger.info("#{xml_fn} -> #{output_fn}")
+          parser = Parser.new
+          config_basename = File.basename(fn, File.extname(fn))
+          config_dir = File.dirname(fn)
+          config_fn = File.join(config_dir, "#{config_basename}.rb")
+          if File.exists?(config_fn)
+            Logger.info("Using configuration in #{config_fn}...")
+            parser.load_config(config_fn)
+          end
           File.open(output_fn, 'w') do |file|
-            file << Parser.generate(Nokogiri::XML(File.open(xml_fn)))
+            file << parser.generate(Nokogiri::XML(File.open(xml_fn)))
           end
         end
       end
       def define_file_tasks
-        Dir.glob(@options[:input_fn]).inject([]) do |output_fns, fn|
-          output_fn = File.join(@options[:output_dir], "#{File.basename(fn, '.i')}_wrap.rb")
-          xml_fn = File.join(@options[:output_dir], "#{File.basename(fn, '.i')}_wrap.xml")
+        Dir.glob(@input_fn).inject([]) do |output_fns, fn|
+          output_fn = File.join(@output_dir, "#{File.basename(fn, '.i')}_wrap.rb")
+          xml_fn = File.join(@output_dir, "#{File.basename(fn, '.i')}_wrap.xml")
           define_file_task(fn, xml_fn, output_fn)
           output_fns << output_fn
         end
@@ -37,7 +49,7 @@ module FFI
       def define_clean_task
         desc 'Remove all generated files'
         task :clean do
-          rm_rf @options[:output_dir] unless @options[:output_dir] == '.'
+          rm_rf @output_dir unless @output_dir == '.'
         end
       end
     end

data/lib/generator/logger.rb

@@ -0,0 +1,29 @@
+require 'logger'
+
+module FFI
+  module Generator
+    module Logger
+      @logger = ::Logger.new(STDOUT)
+      @logger.progname = 'ffi-swig-generator'
+      def self.fatal(message)
+        @logger.fatl(message)
+      end
+      def self.error(message)
+        @logger.error(message)
+      end
+      def self.warn(message)
+        @logger.warn(message)
+      end
+      def self.info(message)
+        @logger.info(message)
+      end
+      def self.debug(message)
+        @logger.debug(message)
+      end
+      def set_level(level)
+        @logger.level = level
+      end
+    end
+  end
+end
+

data/lib/generator/node.rb

@@ -0,0 +1,19 @@
+module FFI
+  module Generator
+    class Node
+      attr_reader :symname
+      def initialize(params = { })
+        params = { :indent => 0 }.merge(params)
+        @node, @indent = params[:node], params[:indent]
+        @indent_str = ' ' * @indent
+        @symname = get_attr('name')
+      end
+      def get_attr(name)
+        if @node
+          attr = (@node / "./attributelist/attribute[@name='#{name}']").first
+          attr['value'] if attr
+        end
+      end
+    end
+  end
+end

data/lib/generator/parser.rb

@@ -0,0 +1,168 @@
+require 'rubygems'
+require 'nokogiri'
+
+module FFI
+  module Generator
+    NestedStructureNotSupported =<<EOM
+Nested structures are not correctly supported at the moment.
+Please check the order of the declarations in the structure below.
+EOM
+    class Parser
+      def initialize(indent = 2)
+        @indent = indent
+        @typedefs = {}
+        @nested_type = {}
+        @nested_structure = {}
+        @ignored = []
+        @ignore_at_second_pass = []
+      end
+      def generate(node)
+        result = ""
+        result = pass(node)
+        result = pass(node) unless @nested_type.empty?
+        result
+      end
+      def ignore(*ignored)
+        @ignored.concat(ignored)
+      end
+      def load_config(fn)
+        eval(File.read(fn), binding)
+      end
+      private
+      def get_attr(node, name)
+        nodes = (node / "./attributelist/attribute[@name='#{name}']")
+        nodes.first['value'] if nodes.first
+      end
+      def get_id(node)
+        node.id
+      end
+      def get_verbatim(node)
+        get_attr(node, 'code')
+      end
+      def add_type(ctype, rtype)
+        @typedefs[ctype] = rtype
+      end
+      def add_nested_structure(symname, id)
+        (@nested_structure[@nested_type[symname]] ||= []) << id
+      end
+      def insert_runtime?(node)
+        get_attr(node, 'section') == 'runtime'
+      end
+      def constant?(node)
+        node.name == 'constant'
+      end
+      def enum?(node)
+        node.name == 'enum'
+      end
+      def function_decl?(node)
+        node.name == 'cdecl' and get_attr(node, 'kind') == 'function'
+      end
+      def struct?(node)
+        node.name == 'class' and get_attr(node, 'kind') == 'struct'
+      end
+      def union?(node)
+        node.name == 'class' and get_attr(node, 'kind') == 'union'
+      end        
+      def typedef?(node)
+        node.name == 'cdecl' and get_attr(node, 'kind') == 'typedef'
+      end
+      def callback?(node)
+        get_attr(node, 'decl') =~ /^p\.f\(/
+      end
+      def nested_type?(node)
+        get_attr(node, 'nested')
+      end
+      def fix_nested_structure(node)
+        result = ""
+        if struct?(node)
+          s = Struct.new(:node => node, :indent => @indent, :typedefs => @typedefs)
+          result << (@nested_structure.has_key?(s.symname) ? fixme(s.to_s, NestedStructureNotSupported) : s.to_s)
+        else
+          u = Union.new(:node => node, :indent => @indent, :typedefs => @typedefs)
+          result << (@nested_structure.has_key?(u.symname) ? fixme(u.to_s, NestedStructureNotSupported) : u.to_s)
+        end
+        result  
+      end
+      # Search for nested structures and fix them.
+      def find_nested_struct(node, id)
+        result = ""
+        nested_node = (node.parent / "class[@id='#{id}']").first
+        if @nested_structure.has_key?(get_attr(nested_node, 'name'))
+          @nested_structure[get_attr(nested_node, 'name')].reverse.each do |id|
+            result << find_nested_struct(nested_node, id)
+          end
+        end
+        result << fix_nested_structure(nested_node) if nested_node
+      end
+      def fixme(code, message)
+        comment('FIXME: ' + message) << comment(code)
+      end
+      def comment(code)
+        code.split(/\n/).map { |line| "# #{line}" }.join("\n") << "\n"
+      end
+      def has_nested_structures?(node, symname)
+        @nested_structure[symname] and not @nested_structure[symname].empty?
+      end
+      def prepend_nested_structures(node, symname)
+        result = ""
+        if has_nested_structures?(node, symname)
+          @nested_structure[symname].reverse.each do |nested_id|
+            result << find_nested_struct(node, nested_id)
+          end
+          @nested_structure[symname].clear
+        end
+        result          
+      end
+      def handle_nested_structure(node, symname)
+        if @nested_type[symname]
+          add_nested_structure(symname, node.attributes['id'])
+          @ignore_at_second_pass << node.attributes['id']
+        end
+        prepend_nested_structures(node, symname)
+      end
+      def pass(node)
+        result = ""
+        node.traverse do |node|
+          unless @ignored.include?(get_attr(node, 'name'))
+            if constant?(node)
+              result << Constant.new(:node => node, :indent => @indent).to_s << "\n"
+            elsif typedef?(node)
+              typedef = Type.new(:node => node)
+              add_type(typedef.symname, typedef.full_decl)
+              if callback?(node)
+                cb = Callback.new(:node => node, :indent => @indent, :typedefs => @typedefs).to_s << "\n"
+                add_type(typedef.symname, "callback #{typedef.symname}")
+                result << cb.to_s
+              end
+            elsif enum?(node)
+              e = Enum.new(:node => node, :indent => @indent)
+              add_type(e.symname, Generator::TYPES['int'])
+              result << e.to_s << "\n"
+            elsif struct?(node)
+              s = Struct.new(:node => node, :indent => @indent, :typedefs => @typedefs)
+              add_type(s.symname, "struct #{s.symname}")
+              unless @ignore_at_second_pass.include? node.attributes['id']
+                nested = handle_nested_structure(node, s.symname)
+                result << (nested.empty? ? s.to_s : nested << fixme(s.to_s, NestedStructureNotSupported))
+              end
+            elsif union?(node)
+              s = Union.new(:node => node, :indent => @indent, :typedefs => @typedefs)
+              add_type(s.symname, "union #{s.symname}")
+              unless @ignore_at_second_pass.include? node.attributes['id']
+                nested = handle_nested_structure(node, s.symname)
+                result << (nested.empty? ? s.to_s : nested << fixme(s.to_s, NestedStructureNotSupported))
+              end
+            elsif function_decl?(node)
+              result << Function.new(:node => node, :indent => @indent, :typedefs => @typedefs).to_s << "\n"
+            elsif nested_type?(node)
+              @nested_type[get_attr(node, 'type')] = get_attr(node, 'nested')
+            elsif node.name == 'insert' and not insert_runtime?(node) and not node.parent.name == 'class'
+              result << get_verbatim(node)
+            end       
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/generator/struct.rb

@@ -0,0 +1,76 @@
+module FFI
+  module Generator
+    require libpath('generator/node')
+    class Struct< Type
+      def self.string_accessors(field_name, indent = 0)
+        result = <<-code
+def #{field_name}=(str)
+  @#{field_name} = FFI::MemoryPointer.from_string(str)
+  self[:#{field_name}] = @#{field_name}
+end
+def #{field_name}
+  @#{field_name}.get_string(0)
+end
+code
+      result.split("\n").map { |line| ' ' * indent + line }.join("\n") << "\n"
+      end
+      def self.callback_accessors(field_name, indent = 0)
+        result = <<-code
+def #{field_name}=(cb)
+  @#{field_name} = cb
+  self[:#{field_name}] = @#{field_name}
+end
+def #{field_name}
+  @#{field_name}
+end
+code
+      result.split("\n").collect { |line| ' ' * indent + line }.join("\n") << "\n"
+      end
+      def self.camelcase(name)
+        name.gsub(/^_?\w|\_\w/) { |c| c.upcase }.delete('_')
+      end
+      def initialize(params = { })
+        super
+        @name = self.class.camelcase(@symname)
+      end
+      def to_s
+        fields_str = fields.inject("") do |str, f|
+          str << @indent_str + ' ' * 9 << f.join(', ') << ",\n"
+        end
+        code = klass_string + @indent_str + "  layout(\n" + fields_str.chomp.chomp(',') + "\n" + @indent_str + "  )\n" + accessors + @indent_str + "end\n"
+      end
+      private
+      def klass_string
+        @indent_str + "class #{@name} < FFI::Struct\n"
+      end
+      def fields
+        (@node / 'cdecl').inject([]) do |array, field|
+          type_node = Type.new(:node => field, :typedefs => @typedefs).to_s
+          type = type_node.to_s
+          array << [":#{Node.new(:node => field).symname}", type == ':string' ? ':pointer' : type]
+        end
+      end
+      def accessors
+        result = ""
+        fields = (@node / 'cdecl').map do |field|
+          [Node.new(:node => field).symname, "#{Type.new(:node => field, :typedefs => @typedefs)}"]
+        end
+        fields.each do |field|
+          if field[1] == ':string'
+            result << self.class.string_accessors(field[0], @indent + 2)
+          elsif field[1] =~ /^callback/ or @typedefs[field[1].delete(':')] =~ /^callback/
+            result << self.class.callback_accessors(field[0], @indent + 2)
+          end
+        end
+        result += "\n" unless result.empty?
+        result
+      end
+    end
+    class Union < FFI::Generator::Struct
+      private
+      def klass_string
+        @indent_str + "class #{@name} < FFI::Union\n"
+      end
+    end
+  end
+end