ffi-swig-generator 0.2.1

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-swig-generator_spec.rb

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

data/spec/generator/generator_spec.rb

@@ -0,0 +1,248 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+include FFI
+
+share_examples_for "All specs" do
+  after :all do
+    remove_xml
+  end
+end
+
+describe Generator::Parser do
+  it_should_behave_like 'All specs'
+  before :all do
+    @node = generate_xml_wrap_from('testlib')
+  end
+  it 'should generate ruby ffi wrap code' do
+    Generator::Parser.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 TestStruct3 < FFI::Struct
+    layout(
+           :c, :char
+    )
+  end
+  callback(:cb, [ :string, :string ], :void)
+  class TestStruct2 < FFI::Struct
+    layout(
+           :s, TestStruct,
+           :s_3, TestStruct3,
+           :e, :int,
+           :func, :cb,
+           :u, UnionT
+    )
+  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
+end
+
+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').to_s.should == "CONST_1 = 0x10"
+  end
+end
+
+describe Generator::Enum do
+  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
+
+describe Generator::Type do
+  it_should_behave_like 'All specs'
+  before :all do
+    @node = generate_xml_wrap_from('types')
+  end
+  it 'should generate string type' do
+    Generator::Type.new(:node => (@node / 'cdecl')[0]).to_s.should == ':string'
+  end
+  it 'should generate pointer type' do
+    Generator::Type.new(:node => (@node / 'cdecl')[1]).to_s.should == ':pointer'
+    Generator::Type.new(:node => (@node / 'cdecl')[2]).to_s.should == ':pointer'
+  end
+  it 'should generate array type' do
+    Generator::Type.new(:node => (@node / 'cdecl')[3]).to_s.should == '[:int, 5]'
+    Generator::Type.new(:node => (@node / 'cdecl')[4]).to_s.should == '[:string, 5]'
+  end
+  it 'should generate struct type' do
+    Generator::Type.new(:node => (@node / 'cdecl')[6]).to_s.should == 'TestStruct'
+  end
+  it 'should generate struct array type' do
+    Generator::Type.new(:node => (@node / 'cdecl')[7]).to_s.should == '[TestStruct, 5]'
+  end
+  it 'should generate enum array type' do
+    Generator::Type.new(:node => (@node / 'cdecl')[8]).to_s.should == '[:int, 5]'
+  end
+  it 'should generate const type' do
+    Generator::Type.new(:node => (@node / 'cdecl')[9]).to_s.should == ':int'
+    Generator::Type.new(:node => (@node / 'cdecl')[10]).to_s.should == ':string'
+  end
+  Generator::TYPES.sort.each_with_index do |type, i|
+    it "should generate #{type[0]} type" do
+      Generator::Type.new(:node => (@node / 'cdecl')[i + 11]).to_s.should == type[1]
+    end 
+  end
+end
+
+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 return type' do
+    Generator::Function.new(:node => (@node / 'cdecl')[3]).to_s.should == "attach_function :func_4, [ :int ], :string"
+  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(:callback, [ :float ], :void) ], :void"
+    Generator::Function.new(:node => (@node / 'cdecl')[13]).to_s.should == "attach_function :func_13, [ callback(:callback, [ :double, :float ], :int) ], :void"
+    Generator::Function.new(:node => (@node / 'cdecl')[14]).to_s.should == "attach_function :func_14, [ callback(:callback, [ :string ], :void) ], :void"
+    Generator::Function.new(:node => (@node / 'cdecl')[15]).to_s.should == "attach_function :func_15, [ callback(:callback, [  ], :void) ], :void"
+  end
+end
+
+describe Generator::Structure do
+  it_should_behave_like 'All specs'
+  before :all do
+    @node = generate_xml_wrap_from('structs')
+  end
+  it 'should properly generate the layout of a FFI::Struct class' do
+    Generator::Structure.new(:node => (@node / 'class')[0]).to_s.should == <<EOC
+class TestStruct1 < FFI::Struct
+  layout(
+         :i, :int,
+         :c, :char,
+         :s, :string,
+         :a, [:char, 5]
+  )
+end
+EOC
+
+  end
+  it 'should properly generate the layout of a FFI::Struct containing pointer field' do
+    Generator::Structure.new(:node => (@node / 'class')[1]).to_s.should == <<EOC
+class TestStruct2 < FFI::Struct
+  layout(
+         :ptr, :pointer
+  )
+end
+EOC
+end
+  it 'should properly generate the layout of a FFI::Struct containing array field' do
+    Generator::Structure.new(:node => (@node / 'class')[2]).to_s.should == <<EOC
+class TestStruct3 < FFI::Struct
+  layout(
+         :c, [:char, 5]
+  )
+end
+EOC
+
+  end
+  it 'should properly generate the layout of a FFI::Struct containing array field' do
+    Generator::Structure.new(:node => (@node / 'class')[3]).to_s.should == <<EOC
+class TestStruct4 < FFI::Struct
+  layout(
+         :s, [TestStruct3, 5]
+  )
+end
+EOC
+
+  end
+end
+
+describe Generator::Union do
+  it_should_behave_like 'All specs'
+  before :all do
+    @node = generate_xml_wrap_from('unions')
+  end
+  it 'should properly generate the layout of a FFI::Union class' do
+    Generator::Union.new(:node => (@node / 'class')[0]).to_s.should == <<EOC
+class UnionT < FFI::Union
+  layout(
+         :c, :char,
+         :f, :float
+  )
+end
+EOC
+  end
+end
+

data/spec/generator/swig/constants.i

@@ -0,0 +1,3 @@
+%module constant_wrap
+
+#define CONST_1 0x10

data/spec/generator/swig/enums.i

@@ -0,0 +1,5 @@
+%module enum_test
+
+enum e { ENUM_1, ENUM_2, ENUM_3 };
+enum e_2 { ENUM_21 = 2, ENUM_22, ENUM_23 };
+enum e_3 { ENUM_31, ENUM_32 = 5, ENUM_33 };

data/spec/generator/swig/functions.i

@@ -0,0 +1,24 @@
+%module function_testlib
+
+int func_1(char c, int i);
+unsigned int func_2(int* p1, int* p2, char** p3);
+void func_3(char* str);
+char *func_4(int i);
+extern void func_5();
+void func_6(void** ptr);
+void func_7(enum e e1);
+enum e { E_1, E_2 };
+enum e func_8();
+struct test_struct {
+  char c;
+};
+void func_9(struct test_struct s);
+struct test_struct func_10();
+void func_11(void);
+void func_12(void (*callback)(float));
+void func_13(int (*callback)(double, float));
+void func_14(void (*callback)(char* str));
+void func_15(void (*callback)(void));
+
+
+

data/spec/generator/swig/structs.i

@@ -0,0 +1,25 @@
+%module test_struct
+
+struct test_struct_1 {
+  int i;
+  char c;
+  const char* s;
+  const char a[5];
+};
+
+struct test_struct_2 {
+  int* ptr;
+};
+
+struct test_struct_3 {
+  char c[5];
+};
+
+struct test_struct_4 {
+  struct test_struct_3 s[5];
+};
+
+struct test_struct_5 {
+  struct test_struct_4 s;
+};
+

data/spec/generator/swig/testlib.i

@@ -0,0 +1,48 @@
+%module testlib
+
+%{
+module TestLib
+  extend FFI::Library
+%}
+
+#define CONST_1 0x10
+#define CONST_2 0x20
+
+typedef unsigned char byte;
+typedef enum e_1 { 
+  ENUM_1, ENUM_2, ENUM_3 
+} enum_t;
+
+union union_t {
+  char c;
+  float f;
+};
+
+struct test_struct {
+  int i;
+  char c;
+  byte b;
+};
+
+typedef struct {
+  char c;
+} test_struct_3;
+
+typedef void (*cb)(char*, char*);
+
+struct test_struct_2 {
+  struct test_struct s;
+  test_struct_3 s_3;
+  enum_t e;
+  cb func;
+  union_t u;
+};
+
+int get_int(struct test_struct* s);
+char get_char(struct test_struct* s);
+int func_with_enum(enum e_1 e);
+int func_with_enum_2(enum_t e);
+byte func_with_typedef();
+%{
+end
+%}

data/spec/generator/swig/typedefs.i

@@ -0,0 +1,5 @@
+%module test_typedef
+
+typedef unsigned char byte;
+byte b;
+typedef int *(PTF)(char*, char*)

data/spec/generator/swig/types.i

@@ -0,0 +1,52 @@
+%module types_test
+
+char *string;
+void *ptr;
+char **ptr_2;
+
+int array[5];
+char* ptr_array[5];
+
+struct test_struct {
+  char c;
+};
+
+enum e { E_1, E_2, E_3 };
+
+struct test_struct ts;
+struct test_struct a[5];
+enum e enum_array[5];
+
+const int ci;
+const char* cstring;
+
+char c;
+double d;
+float f;
+int i;
+long l;
+long int li;
+long long ll;
+long long int lli;
+long unsigned int lui;
+short s;
+signed char sc;
+signed int si;
+signed long sl;
+signed long int sli;
+signed long long sll;
+signed long long int slli;
+signed short ss;
+signed short int ssi;
+unsigned char uc;
+unsigned int ui;
+unsigned long ul;
+unsigned long int uli;
+unsigned long long ull;
+unsigned long long int ulli;
+unsigned short us;
+unsigned short int usi;
+void v;
+
+
+