ffi-swig-generator 0.2.1 → 0.3.0

data/lib/generator/type.rb

@@ -0,0 +1,128 @@
+module FFI
+  module Generator
+    require libpath('generator/node')
+    class Type < Node
+      attr_reader :full_decl
+      class Declaration
+        def initialize(declaration)
+          @full_decl = declaration
+        end
+        def is_native?
+          Generator::TYPES.has_key?(@full_decl)
+        end
+        def is_pointer?
+          @full_decl[/^p\./] and not is_inline_callback?
+        end
+        def is_enum?
+          @full_decl[/^enum/]
+        end
+        def is_array?
+          @full_decl and @full_decl[/\w+\(\d+\)/]
+        end
+        def is_struct?
+          @full_decl[/^struct/]
+        end
+        def is_union?
+          @full_decl[/^union/]
+        end
+        def is_constant?
+          @full_decl[/^q\(const\)/]
+        end
+        def is_volatile?
+          @full_decl[/^q\(volatile\)/]
+        end
+        def is_callback?
+          @full_decl[/^callback/]
+        end
+        def is_inline_callback?
+          @full_decl[/^p.f\(/]
+        end
+      end
+      def initialize(params = { })
+        super
+        params = { :declaration => get_full_decl, :typedefs => { } }.merge(params)
+        @full_decl = params[:declaration]
+        @typedefs = params[:typedefs] || { }
+        @declaration = Declaration.new(@full_decl)
+        @is_pointer = 0
+      end
+      def to_s
+        ffi_type_from(@full_decl)
+      end
+      private
+      def get_full_decl
+        get_attr('decl').to_s + get_attr('type').to_s if @node
+      end
+      def decl
+        get_attr('decl').to_s
+      end
+      def type
+        get_attr('type').to_s
+      end
+      def native
+        ffi_type_from(Generator::TYPES[@full_decl]) if @declaration.is_native?
+      end
+      def constant
+        ffi_type_from(@full_decl.scan(/^q\(const\)\.(.+)/).flatten[0]) if @declaration.is_constant?
+      end
+      def volatile
+        ffi_type_from(@full_decl.scan(/^q\(volatile\)\.(.+)/).flatten[0]) if @declaration.is_volatile?
+      end
+      def pointer
+        if @declaration.is_pointer? or @is_pointer > 0
+          @is_pointer += 1
+          if @full_decl.scan(/^p\.(.+)/).flatten[0]
+            ffi_type_from(@full_decl.scan(/^p\.(.+)/).flatten[0])
+          elsif @full_decl == 'char' and @is_pointer == 2
+            ':string'
+          else
+            ':pointer'
+          end
+        end        
+      end
+      def array
+        if @declaration.is_array?
+          num = @full_decl.scan(/\w+\((\d+)\)/).flatten[0]
+          "[#{ffi_type_from(@full_decl.gsub!(/\w+\(\d+\)\./, ''))}, #{num}]"
+        end
+      end
+      def struct
+        Struct.camelcase(@full_decl.scan(/^struct\s(\w+)/).flatten[0]) if @declaration.is_struct?
+      end
+      def union
+        Union.camelcase(@full_decl.scan(/^union\s(\w+)/).flatten[0]) if @declaration.is_union?
+      end
+      def enum
+        ffi_type_from(Generator::TYPES['int']) if @declaration.is_enum?
+      end
+      def callback
+        ":#{@full_decl.scan(/^callback\s(\w+)/).flatten[0]}" if @declaration.is_callback?
+      end
+      def inline_callback
+        Callback.new(:node => @node, :inline => true, :typedefs => @typedefs).to_s if @declaration.is_inline_callback?        
+      end
+      def typedef
+        ffi_type_from(@typedefs[@full_decl]) if @typedefs.has_key?(@full_decl)
+      end
+      def undefined(type)
+        "#{type}"
+      end
+      def ffi_type_from(full_decl)
+        @full_decl = full_decl
+        @declaration = Declaration.new(full_decl)
+        constant             || \
+        volatile             || \
+        typedef              || \
+        pointer              || \
+        enum                 || \
+        native               || \
+        struct               || \
+        union                || \
+        array                || \
+        inline_callback      || \
+        callback             || \
+        undefined(full_decl)
+      end
+    end
+  end
+end

data/lib/generator/types.rb

@@ -0,0 +1,36 @@
+module FFI
+  module Generator
+    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',
+      'size_t' => ':uint',
+      'unsigned long long'     => ':ulong_long',
+      'unsigned long long int' => ':ulong_long',
+      'void' => ':void'
+    }     
+  end
+end

data/spec/generator/constant_spec.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+include FFI
+
+describe Generator::Constant do
+  it_should_behave_like 'All specs'
+  before :all do
+    @node = generate_xml_wrap_from('constants')
+  end
+  it 'should return a ruby constant assignment' do
+    Generator::Constant.new(:node => (@node / 'constant')[0]).to_s.should == "CONST_1 = 0x10"
+  end
+  it 'should ignore constant qualifiers' do
+    Generator::Constant.new(:node => (@node / 'constant')[1]).to_s.should == "CONST_2 = 1234"
+    Generator::Constant.new(:node => (@node / 'constant')[2]).to_s.should == "CONST_3 = 1234"
+    Generator::Constant.new(:node => (@node / 'constant')[3]).to_s.should == "CONST_4 = 1234"
+  end
+end

data/spec/generator/enum_spec.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+include FFI
+
+describe Generator::Enum do
+  it_should_behave_like 'All specs'
+  before :all do
+    @node = generate_xml_wrap_from('enums')
+  end
+  it 'should generate constants' do
+    Generator::Enum.new(:node => (@node / 'enum')[0]).to_s.should == <<EOE
+ENUM_1 = 0
+ENUM_2 = 1
+ENUM_3 = 2
+EOE
+  end
+  it 'should generate constants starting from the latest assignment' do
+    Generator::Enum.new(:node => (@node / 'enum')[1]).to_s.should == <<EOE
+ENUM_21 = 2
+ENUM_22 = 3
+ENUM_23 = 4
+EOE
+    Generator::Enum.new(:node => (@node / 'enum')[2]).to_s.should == <<EOE
+ENUM_31 = 0
+ENUM_32 = 5
+ENUM_33 = 6
+EOE
+  end
+end
+

data/spec/generator/function_spec.rb

@@ -0,0 +1,66 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+include FFI
+
+describe Generator::Function do
+  it_should_behave_like 'All specs'
+  before :all do
+    @node = generate_xml_wrap_from('functions')
+  end
+  it 'should return a properly generated attach_method' do
+    Generator::Function.new(:node => (@node / 'cdecl')[0]).to_s.should == "attach_function :func_1, [ :char, :int ], :int"
+  end
+  it 'should properly generate pointer arguments' do
+    Generator::Function.new(:node => (@node / 'cdecl')[1]).to_s.should == "attach_function :func_2, [ :pointer, :pointer, :pointer ], :uint"
+  end
+  it 'should properly generate string arguments' do
+    Generator::Function.new(:node => (@node / 'cdecl')[2]).to_s.should == "attach_function :func_3, [ :string ], :void"
+  end
+  it 'should properly generate string return type' do
+    Generator::Function.new(:node => (@node / 'cdecl')[3]).to_s.should == "attach_function :func_4, [ :int ], :string"
+  end
+  it 'should generate string type only in case of pointer of type char (char *)' do
+    Generator::Function.new(:node => (@node / 'cdecl')[17]).to_s.should == "attach_function :func_17, [  ], :pointer"
+  end
+  it 'should properly generate void return type' do
+    Generator::Function.new(:node => (@node / 'cdecl')[4]).to_s.should == "attach_function :func_5, [  ], :void"
+  end
+  it 'should properly generate pointer of pointer arguments' do
+    Generator::Function.new(:node => (@node / 'cdecl')[5]).to_s.should == "attach_function :func_6, [ :pointer ], :void"
+  end
+  it 'should properly generate enum arguments' do
+    Generator::Function.new(:node => (@node / 'cdecl')[6]).to_s.should == "attach_function :func_7, [ :int ], :void"
+  end
+  it 'should properly generate enum return type' do
+    Generator::Function.new(:node => (@node / 'cdecl')[7]).to_s.should == "attach_function :func_8, [  ], :int"
+  end
+  it 'should properly generate struct arguments' do
+    Generator::Function.new(:node => (@node / 'cdecl')[9]).to_s.should == "attach_function :func_9, [ TestStruct ], :void"
+  end
+  it 'should properly generate struct return type' do
+    Generator::Function.new(:node => (@node / 'cdecl')[10]).to_s.should == "attach_function :func_10, [  ], TestStruct"
+  end
+  it 'should properly generate a function with no parameters' do
+    Generator::Function.new(:node => (@node / 'cdecl')[11]).to_s.should == "attach_function :func_11, [  ], :void"
+  end
+  it 'should properly generate a function that takes a callback as argument' do
+    Generator::Function.new(:node => (@node / 'cdecl')[12]).to_s.should == "attach_function :func_12, [ callback([ :float ], :void) ], :void"
+    Generator::Function.new(:node => (@node / 'cdecl')[13]).to_s.should == "attach_function :func_13, [ callback([ :double, :float ], :int) ], :void"
+    Generator::Function.new(:node => (@node / 'cdecl')[14]).to_s.should == "attach_function :func_14, [ callback([ :string ], :void) ], :void"
+    Generator::Function.new(:node => (@node / 'cdecl')[15]).to_s.should == "attach_function :func_15, [ callback([  ], :void) ], :void"
+  end
+  it 'should handle const qualifier return type' do
+    Generator::Function.new(:node => (@node / 'cdecl')[16]).to_s.should == "attach_function :func_16, [  ], :string"
+  end
+  it 'should generate a function with variadic args' do
+    Generator::Function.new(:node => (@node / 'cdecl')[18]).to_s.should == "attach_function :func_18, [ :varargs ], :void"
+  end
+  it 'should generate a function with volatile args' do
+    Generator::Function.new(:node => (@node / 'cdecl')[19]).to_s.should == "attach_function :func_19, [ :int ], :void"
+  end
+  it 'should properly generate func_20' do
+    Generator::Function.new(:node => (@node / 'cdecl')[20]).to_s.should == "attach_function :func_20, [ :pointer, callback([ :string, :pointer, :pointer ], :void), :pointer ], :void"
+  end
+  it 'should properly generate func_20' do
+    Generator::Function.new(:node => (@node / 'cdecl')[21]).to_s.should == "attach_function :func_21, [ :pointer, callback([ :uchar, :pointer, :pointer ], :void), :pointer ], :void"
+  end
+end

data/spec/generator/parser_spec.rb

@@ -0,0 +1,250 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+include FFI
+
+describe Generator::Parser do
+  it_should_behave_like 'All specs'
+  before do
+    @node = generate_xml_wrap_from('testlib')
+  end
+  it 'should generate ruby ffi wrap code' do
+    Generator::Parser.new.generate(@node).should == <<EOC
+
+module TestLib
+  extend FFI::Library
+  CONST_1 = 0x10
+  CONST_2 = 0x20
+  ENUM_1 = 0
+  ENUM_2 = 1
+  ENUM_3 = 2
+
+  class UnionT < FFI::Union
+    layout(
+           :c, :char,
+           :f, :float
+    )
+  end
+  class TestStruct < FFI::Struct
+    layout(
+           :i, :int,
+           :c, :char,
+           :b, :uchar
+    )
+  end
+  class CamelCaseStruct < FFI::Struct
+    layout(
+           :i, :int,
+           :c, :char,
+           :b, :uchar
+    )
+  end
+  class TestStruct3 < FFI::Struct
+    layout(
+           :c, :char
+    )
+  end
+  callback(:cb, [ :string, :string ], :void)
+  callback(:cb_2, [ :string, :string ], :pointer)
+  callback(:cb_3, [ :string, CamelCaseStruct ], CamelCaseStruct)
+  class TestStruct2 < FFI::Struct
+    layout(
+           :s, TestStruct,
+           :camel_case_struct, CamelCaseStruct,
+           :s_3, TestStruct3,
+           :e, :int,
+           :func, :cb,
+           :u, UnionT,
+           :callback, :cb,
+           :inline_callback, callback([  ], :void)
+    )
+    def func=(cb)
+      @func = cb
+      self[:func] = @func
+    end
+    def func
+      @func
+    end
+    def callback=(cb)
+      @callback = cb
+      self[:callback] = @callback
+    end
+    def callback
+      @callback
+    end
+    def inline_callback=(cb)
+      @inline_callback = cb
+      self[:inline_callback] = @inline_callback
+    end
+    def inline_callback
+      @inline_callback
+    end
+
+  end
+  class TestStruct4 < FFI::Struct
+    layout(
+           :string, :pointer,
+           :inline_callback, callback([  ], :void)
+    )
+    def string=(str)
+      @string = FFI::MemoryPointer.from_string(str)
+      self[:string] = @string
+    end
+    def string
+      @string.get_string(0)
+    end
+    def inline_callback=(cb)
+      @inline_callback = cb
+      self[:inline_callback] = @inline_callback
+    end
+    def inline_callback
+      @inline_callback
+    end
+
+  end
+  class TestStruct5BigUnionFieldNestedStructField1 < FFI::Struct
+    layout(
+           :a, :int,
+           :b, :int
+    )
+  end
+  class TestStruct5BigUnionFieldNestedStructField2 < FFI::Struct
+    layout(
+           :c, :int,
+           :d, :int
+    )
+  end
+  class TestStruct5BigUnionFieldNestedStructField3 < FFI::Struct
+    layout(
+           :e, :int,
+           :f, :int
+    )
+  end
+  class TestStruct5BigUnionFieldUnionField < FFI::Union
+    layout(
+           :l, :long,
+           :ll, :long_long
+    )
+  end
+# FIXME: Nested structures are not correctly supported at the moment.
+# Please check the order of the declarations in the structure below.
+#   class TestStruct5BigUnionField < FFI::Union
+#     layout(
+#            :f, :float,
+#            :union_field, TestStruct5BigUnionFieldUnionField,
+#            :nested_struct_field_3, TestStruct5BigUnionFieldNestedStructField3,
+#            :nested_struct_field_2, TestStruct5BigUnionFieldNestedStructField2,
+#            :nested_struct_field_1, TestStruct5BigUnionFieldNestedStructField1
+#     )
+#   end
+# FIXME: Nested structures are not correctly supported at the moment.
+# Please check the order of the declarations in the structure below.
+#   class TestStruct5 < FFI::Struct
+#     layout(
+#            :i, :int,
+#            :c, :char,
+#            :big_union_field, TestStruct5BigUnionField
+#     )
+#   end
+  attach_function :get_int, [ :pointer ], :int
+  attach_function :get_char, [ :pointer ], :char
+  attach_function :func_with_enum, [ :int ], :int
+  attach_function :func_with_enum_2, [ :int ], :int
+  attach_function :func_with_typedef, [  ], :uchar
+
+end
+EOC
+  end
+  it 'should ignore given declarations' do
+    parser = Generator::Parser.new    
+    parser.ignore 'CONST_1', 'e_1', 'test_struct', 'test_struct_5'
+    parser.ignore 'func_with_enum_2'
+    parser.generate(@node).should == <<EOC
+
+module TestLib
+  extend FFI::Library
+  CONST_2 = 0x20
+  class UnionT < FFI::Union
+    layout(
+           :c, :char,
+           :f, :float
+    )
+  end
+  class CamelCaseStruct < FFI::Struct
+    layout(
+           :i, :int,
+           :c, :char,
+           :b, :uchar
+    )
+  end
+  class TestStruct3 < FFI::Struct
+    layout(
+           :c, :char
+    )
+  end
+  callback(:cb, [ :string, :string ], :void)
+  callback(:cb_2, [ :string, :string ], :pointer)
+  callback(:cb_3, [ :string, CamelCaseStruct ], CamelCaseStruct)
+  class TestStruct2 < FFI::Struct
+    layout(
+           :s, TestStruct,
+           :camel_case_struct, CamelCaseStruct,
+           :s_3, TestStruct3,
+           :e, :int,
+           :func, :cb,
+           :u, UnionT,
+           :callback, :cb,
+           :inline_callback, callback([  ], :void)
+    )
+    def func=(cb)
+      @func = cb
+      self[:func] = @func
+    end
+    def func
+      @func
+    end
+    def callback=(cb)
+      @callback = cb
+      self[:callback] = @callback
+    end
+    def callback
+      @callback
+    end
+    def inline_callback=(cb)
+      @inline_callback = cb
+      self[:inline_callback] = @inline_callback
+    end
+    def inline_callback
+      @inline_callback
+    end
+
+  end
+  class TestStruct4 < FFI::Struct
+    layout(
+           :string, :pointer,
+           :inline_callback, callback([  ], :void)
+    )
+    def string=(str)
+      @string = FFI::MemoryPointer.from_string(str)
+      self[:string] = @string
+    end
+    def string
+      @string.get_string(0)
+    end
+    def inline_callback=(cb)
+      @inline_callback = cb
+      self[:inline_callback] = @inline_callback
+    end
+    def inline_callback
+      @inline_callback
+    end
+
+  end
+  attach_function :get_int, [ :pointer ], :int
+  attach_function :get_char, [ :pointer ], :char
+  attach_function :func_with_enum, [ :int ], :int
+  attach_function :func_with_typedef, [  ], :uchar
+
+end
+EOC
+  end
+end