remogatto-ffi-generator 0.1.0

data/lib/ffi-generator.rb

@@ -0,0 +1,49 @@
+
+module FFI
+  module Generator
+    # :stopdoc:
+    VERSION = '0.1.0'
+    LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+    PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+    # :startdoc:
+
+    # Returns the version string for the library.
+    #
+    def self.version
+      VERSION
+    end
+
+    # Returns the library path for the module. If any arguments are given,
+    # they will be joined to the end of the libray path using
+    # <tt>File.join</tt>.
+    #
+    def self.libpath( *args )
+      args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+    end
+
+    # Returns the lpath for the module. If any arguments are given,
+    # they will be joined to the end of the path using
+    # <tt>File.join</tt>.
+    #
+    def self.path( *args )
+      args.empty? ? PATH : ::File.join(PATH, args.flatten)
+    end
+
+    # Utility method used to require all files ending in .rb that lie in the
+    # directory below this file that has the same name as the filename passed
+    # in. Optionally, a specific _directory_ name can be passed in such that
+    # the _filename_ does not have to be equivalent to the directory.
+    #
+    def self.require_all_libs_relative_to( fname, dir = nil )
+      dir ||= ::File.basename(fname, '.*')
+      search_me = ::File.expand_path(
+                                     ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+      Dir.glob(search_me).sort.each {|rb| require rb}
+    end
+  end
+end
+
+FFI::Generator.require_all_libs_relative_to(__FILE__, 'generator')
+
+# EOF

data/lib/generator/application.rb

@@ -0,0 +1,69 @@
+require 'getoptlong'
+
+module FFI
+  module Generator
+    class Application
+      OPTIONS =  [
+                  [ "--help", "-u", GetoptLong::NO_ARGUMENT,
+                    "Display help information." ],
+                  [ "--version", "-v", GetoptLong::NO_ARGUMENT,
+                    "Display the version number and quit." ],
+                 ]
+
+      USAGE_PREAMBLE = <<-EOU
+Usage: ffi-gen [options] <input_file> <output_file>
+
+<input_file> is the xml parse tree generated by swig -xml command.
+<output_file> is the ruby-ffi wrapper file.
+
+EOU
+      class << self
+        def run      
+          process_args
+          if ARGV.size == 2
+            File.open(ARGV[1], 'w') do |file|
+              file << FFI::Generator::Parser.generate(Nokogiri::XML(File.open(ARGV[0])))
+            end
+          else
+            help
+            raise "Invalid number of arguments!"
+          end
+        end
+        private
+        def do_option(option, value = nil)
+          case option
+          when '--help'
+            help
+            exit
+          when '--version'
+            puts "ffi-generator, version #{Generator::VERSION}\n"
+            exit
+          end
+        end
+        def command_line_options
+          OPTIONS.collect { |lst| lst[0..-2] }
+        end
+        def process_args
+          opts = GetoptLong.new(*command_line_options)
+          opts.each { |opt, value| do_option(opt, value) }
+        end
+        def help
+          puts
+          puts USAGE_PREAMBLE
+          puts "Recognized options are:"
+          puts
+          OPTIONS.sort.each do |long, short, mode, desc|
+            if mode == GetoptLong::REQUIRED_ARGUMENT
+              if desc =~ /\b([A-Z]{2,})\b/
+                long = long + "=#{$1}"
+              end
+            end
+            printf "  %-20s (%s)\n", long, short
+            printf "      %s\n", desc
+            puts
+          end
+        end
+      end
+    end
+  end
+end

data/lib/generator/generator.rb

@@ -0,0 +1,304 @@
+require 'rubygems'
+require 'nokogiri'
+
+module FFI
+  module Generator
+    @typedefs = {}
+    TYPES = { 
+      'char' => ':char',
+      'double' => ':double',
+      'float' => ':float',
+      'unsigned long' => ':ulong',
+      'unsigned char' => ':uchar',
+      'signed char' => ':char',
+      'unsigned char' => ':uchar',
+      'short' => ':short',
+      'signed short'     => ':short',
+      'signed short int' => ':short',
+      'unsigned short'     => ':ushort',
+      'unsigned short int' => ':ushort',
+      'int' => ':int',
+      'signed int' => ':int',
+      'unsigned int' => ':uint',
+      'long' => ':long',
+      'long int' => ':long',
+      'signed long' => ':long',
+      'signed long int' => ':long',
+      'unsigned long' => ':ulong',
+      'unsigned long int' => ':ulong',
+      'long unsigned int' => ':ulong',
+      'long long'     => ':long_long',
+      'long long int' => ':long_long',
+      'signed long long'     => ':long_long',
+      'signed long long int' => ':long_long',
+      'unsigned long long'     => ':ulong_long',
+      'unsigned long long int' => ':ulong_long',
+      'void' => ':void'
+    }     
+    class << self
+      attr_reader :typedefs
+      def add_type(ctype, rtype)
+        @typedefs[ctype] = rtype
+      end
+    end
+    class Node
+      attr_reader :symname
+      def initialize(node, indent = 0)
+        @node = node
+        @indent = ' ' * indent
+        @symname = get_attr('name')
+      end
+      def get_attr(name)
+        attr = (@node / "./attributelist/attribute[@name='#{name}']").first
+        attr['value'] if attr
+      end
+    end
+    class Type < Node
+      def initialize(node, indent = 0)
+        super
+        @type = get_attr('type')
+        @decl = get_attr('decl')
+        @statement = @type.to_s + @decl.to_s
+      end
+      def to_s
+        get_type
+      end
+      private
+      def is_native?
+        Generator::TYPES.has_key?(@type)
+      end
+      def is_pointer?
+        @decl and @decl[/(\)\.p|^p)\./]
+      end
+      def is_enum?
+        @type[/^enum/]
+      end
+      def is_array?
+        @decl and @decl[/\w+\(\d+\)/]
+      end
+      def is_struct?
+        @type[/^struct/]
+      end
+      def is_union?
+        @type[/^union/]
+      end
+      def is_constant?
+        @type[/^q\(const\)/]
+      end
+      def native
+        if is_native?
+          @type = Generator::TYPES[@type] 
+          get_type
+        end
+      end
+      def constant
+        if is_constant?
+          @type = @type.scan(/^q\(const\)\.(.+)/).flatten[0]
+          get_type 
+        end
+      end
+      def pointer
+        if is_pointer?
+          if @type[/char/]
+            @type = ':string'
+            @decl.gsub!(/p./, '')
+            get_type
+          else
+            return ':pointer'
+          end
+        end        
+      end
+      def array
+        if is_array?
+          num = @decl.scan(/\w+\((\d+)\)/).flatten[0]
+          @decl.gsub!(/\w+\(\d+\)/, '')
+          "[#{get_type}, #{num}]"
+        end
+      end
+      def struct
+        if is_struct?
+          @type = Structure.camelcase(@type.scan(/^struct\s(\w+)/).flatten[0])
+          get_type
+        end
+      end
+      def union
+        if is_union?
+          @type = Union.camelcase(@type.scan(/^union\s(\w+)/).flatten[0])
+          get_type
+        end
+      end
+      def enum
+        if is_enum?
+          @type = Generator::TYPES['int']
+          get_type
+        end
+      end
+      def typedef
+        if Generator.typedefs.has_key?(@type)
+          @type = Generator.typedefs[@type]
+          get_type
+        end
+      end
+      def get_type
+        constant || pointer || enum || typedef || native || struct || union || array || "#{@type}"
+      end
+    end
+    class Typedef < Type
+      attr_reader :symname, :type
+      def initialize(node, indent = 0)
+        super
+        @symname = get_attr('name')
+        @type = is_pointer? ? ':pointer' : get_attr('type')
+      end
+    end
+    class Constant < Node
+      def initialize(node, indent = 0)
+        super
+        @name, @value = get_attr('sym_name'), get_attr('value')
+      end
+      def to_s
+        @indent + "#{@name} = #{@value}"        
+      end
+    end
+    class Enum < Node
+      def initialize(node, indent = 0)
+        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 + "#{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(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
+    class Structure < Node
+      def self.camelcase(name)
+        name.gsub(/^\w|\_\w/).each {|c| c.upcase }.delete('_')
+      end
+      def initialize(node, indent = 0)
+        super
+        @name = self.class.camelcase(@symname)
+      end
+      def to_s
+        fields_str = fields.inject("") do |str, f|
+          str << @indent + ' ' * 9 << f.join(', ') << ",\n"
+        end
+        code = klass_string + @indent + "  layout(\n" + fields_str.chomp.chomp(',') + "\n" + @indent + "  )\n" + @indent + "end\n"
+      end
+      private
+      def klass_string
+        @indent + "class #{@name} < FFI::Struct\n"
+      end
+      def fields
+        (@node / 'cdecl').inject([]) do |array, field|
+          array << [":#{Node.new(field).symname}", "#{Type.new(field)}"]
+        end
+      end
+    end
+    class Union < Structure
+      private
+      def klass_string
+        @indent + "class #{@name} < FFI::Union\n"
+      end
+    end
+    class Function < Node
+      class Argument < Type
+        def initialize(node, indent = 0)
+          super
+          @decl = @type
+        end
+      end
+      def to_s
+        params = get_params(@node).inject([]) do |array, node|
+          array << Argument.new(node).to_s
+        end.collect { |p| "#{p}" }
+        @indent + "attach_function :#{@symname}, [ #{params.join(', ')} ], #{Type.new(@node).to_s}"
+      end
+      private
+      def get_params(node)
+        parmlist = node / './attributelist/parmlist/parm'
+      end
+    end
+    class Parser
+      @indent = 2
+      class << self
+        def get_verbatim(node)
+          node.xpath("./attributelist/attribute[@name='code']").first['value']
+        end
+        def is_insert_runtime?(node)
+          section = node.xpath("./attributelist/attribute[@name='section']")
+          section.first['value'] == 'runtime' if section.first
+        end
+        def is_constant?(node)
+          node.name == 'constant'
+        end
+        def is_enum?(node)
+          node.name == 'enum'
+        end
+        def is_function_decl?(node)
+          node.name == 'cdecl' and (node / "./attributelist/attribute[@name='kind']").first['value'] == 'function'
+        end
+        def is_struct?(node)
+          node.name == 'class' and (node / "./attributelist/attribute[@name='kind']").first['value'] == 'struct'
+        end
+        def is_union?(node)
+          node.name == 'class' and (node / "./attributelist/attribute[@name='kind']").first['value'] == 'union'
+        end        
+        def is_typedef?(node)
+          node.name == 'cdecl' and (node / "./attributelist/attribute[@name='kind']").first['value'] == 'typedef'
+        end
+        def generate(node)
+          result = ""
+          node.traverse do |node|
+            if is_constant?(node)
+              result << Constant.new(node, @indent).to_s << "\n"
+            elsif is_typedef?(node)
+              typedef = Typedef.new(node)
+              Generator.add_type(typedef.symname, typedef.type)
+            elsif is_enum?(node)
+              e = Enum.new(node, @indent)
+              Generator.add_type(e.symname, Generator::TYPES['int'])
+              result << e.to_s << "\n"
+            elsif is_struct?(node)
+              s = Structure.new(node, @indent)
+              Generator.add_type(s.symname, "struct #{s.symname}")
+              result << s.to_s
+            elsif is_union?(node)
+              s = Union.new(node, @indent)
+              Generator.add_type(s.symname, "union #{s.symname}")
+              result << s.to_s
+            elsif is_function_decl?(node)
+              result << Function.new(node, @indent).to_s << "\n"
+            elsif node.name == 'insert' and not is_insert_runtime?(node)
+              result << get_verbatim(node)
+            end       
+          end
+          result
+        end
+      end
+    end
+  end
+end
+

data/lib/generator/generatortask.rb

@@ -0,0 +1,45 @@
+require 'rake/tasklib'
+
+module FFI
+  module Generator
+    class Task < Rake::TaskLib
+      def initialize(options = {})
+        @options = { :input_fn => '*.i', :output_dir => 'generated/' }.merge(options)
+        namespace 'ffi' do
+          define_generate_task
+          define_clean_task
+        end
+      end
+      private
+      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..."
+          `swig -xml #{xml_fn} #{fn}`
+          puts "Generating #{output_fn} from #{xml_fn}..."
+          File.open(output_fn, 'w') do |file|
+            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")
+          define_file_task(fn, xml_fn, output_fn)
+          output_fns << output_fn
+        end
+      end
+      def define_generate_task
+        (task :generate => define_file_tasks).add_description('Generate all files')
+      end
+      def define_clean_task
+        desc 'Remove all generated files'
+        task :clean do
+          rm_rf @options[:output_dir] unless @options[:output_dir] == '.'
+        end
+      end
+    end
+  end
+end

data/spec/ffi-generator_spec.rb

@@ -0,0 +1,7 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe FFI::Generator do
+end
+
+# EOF