rbind 0.0.2 → 0.0.3

data/lib/rbind.rb

@@ -3,3 +3,4 @@ require 'rbind/core'
 require 'rbind/default_parser'
 require 'rbind/generator_c'
 require 'rbind/generator_ruby'
+require 'rbind/generator_extern'

data/lib/rbind/core/rbase.rb

@@ -9,6 +9,7 @@ module Rbind
         attr_accessor :version
         attr_accessor :signature
         attr_accessor :csignature
+        attr_accessor :ignore
 
         class << self
             attr_accessor :cprefix
@@ -76,6 +77,10 @@ module Rbind
             ["#{full_name}","#{cname}"]
         end
 
+        def ignore?
+            !!@ignore
+        end
+
         def signature(sig=nil)
             return @signature || generate_signatures[0] unless sig
             @signature = sig

data/lib/rbind/core/rclass.rb

@@ -1,7 +1,7 @@
 
 module Rbind
     class RClass < RStruct
-        attr_accessor :parent_classes
+        attr_reader :parent_classes
 
         def initialize(name,*parent_classes)
             @parent_classes  = Hash.new
@@ -135,6 +135,9 @@ module Rbind
             if @parent_classes.has_key? klass.name
                 raise ArgumentError,"#A parent class with the name #{klass.name} already exists"
             end
+            if klass.full_name == full_name || klass == self
+                raise ArgumentError,"class #{klass.full_name} cannot be parent of its self"
+            end
             # we have to disable the type check for the parent class 
             # otherwise derived types cannot be parsed
             klass.check_type = false

data/lib/rbind/core/rdata_type.rb

@@ -4,13 +4,22 @@ module Rbind
         attr_accessor :ptr,:ref
         attr_accessor :typedef
         attr_accessor :invalid_value
-        attr_accessor :cdelete_method;
-        attr_accessor :check_type;
+        attr_accessor :cdelete_method
+        attr_accessor :check_type
+        attr_accessor :extern_package_name
 
         def initialize(name,*flags)
             super
             @invalid_value = 0
-            @type_check = true
+            @check_type = true
+        end
+
+        def extern?
+           @flags.include? :Extern
+        end
+
+        def valid_flags
+            super << :Extern
         end
 
         def ==(other)
@@ -54,10 +63,12 @@ module Rbind
             !!@typedef
         end
 
+        # elementar type of c
         def basic_type?
             true
         end
 
+        # holds ofther operations, types or consts
         def container?
             false
         end

data/lib/rbind/core/rnamespace.rb

@@ -4,7 +4,7 @@ module Rbind
         class << self
             attr_accessor :default_type_names
         end
-        self.default_type_names = [:uint64,:int,:int64,:bool,:double,:float,:void,:char,:size_t]
+        self.default_type_names = [:uint64,:int,:int64,:bool,:double,:float,:void,:char,:size_t,:uint8_t]
 
         attr_reader :operations
         attr_reader :operation_alias
@@ -46,14 +46,22 @@ module Rbind
             @used_namespaces[namespace.name] = namespace
         end
 
-        def each_type(childs=true,&block)
+        def each_type(childs=true,all=false,&block)
             if block_given?
                 types.each do |t|
+                    next if !all && (t.ignore? || t.extern?)
                     yield t
-                    t.each_type(&block) if childs && t.respond_to?(:each_type)
+                    t.each_type(childs,all,&block) if childs && t.respond_to?(:each_type)
                 end
             else
-                Enumerator.new(self,:each_type,childs)
+                Enumerator.new(self,:each_type,childs,all)
+            end
+        end
+
+        def each_container(all=false,&block)
+            each_type(true,all) do |t|
+                next unless t.container?
+                yield t
             end
         end
 
@@ -83,6 +91,51 @@ module Rbind
             raise RuntimeError,"#{full_name} has no const called #{name}" if raise_ && !c
         end
 
+        def each_const(childs=true,all=false,&block)
+            if block_given?
+                consts.each do |c|
+                    next if !all && (c.ignore? || c.extern?)
+                    yield c
+                end
+                return unless childs
+                each_container(all) do |t|
+                    t.each_const(childs,all,&block)
+                end
+            else
+                Enumerator.new(self,:each_const,childs,all)
+            end
+        end
+
+        def extern?
+            return super() if self.is_a?(RStruct)
+
+            # check if self is container holding only
+            # extern objects
+            each_type(false) do |t|
+                return false if !t.extern?
+            end
+            each_const(false) do |c|
+                return false if !c.extern?
+            end
+            each_operation do |t|
+                return false
+            end
+            true
+        end
+
+        def each_operation(all=false,&block)
+            if block_given?
+                operations.each do |ops|
+                    ops.each do |o|
+                        next if !all && o.ignore?
+                        yield o
+                    end
+                end
+            else
+                Enumerator.new(self,:each_operaion,all)
+            end
+        end
+
         def operations
             @operations.values
         end

data/lib/rbind/default_parser.rb

@@ -12,13 +12,14 @@ module Rbind
 
         def normalize_flags(line_number,flags)
             flags.map do |flag|
+                next if flag.empty?
                 if flag =~ /(\w*)(.*)/
                     DefaultParser.log.debug "input line #{line_number}: ignoring flag #{$2}" unless $2.empty?
                     $1.to_sym
                 else
                     raise "cannot parse flag #{flag.inspect}"
                 end
-            end
+            end.compact
         end
 
         def normalize_default_value(value)
@@ -108,34 +109,45 @@ module Rbind
 
         def parse_class(line_number,string)
             lines = string.split("\n")
-            a = lines.shift.rstrip.split(" : ")
-            name = a[0].split(" ")[1]
-            parents = a[1]
-            parent_classes = if parents
-                                 parents.split(", ").map do |name|
+            a = lines.shift.rstrip
+            unless a =~ /class ([a-zA-Z\.\d_:]*) ?:?([a-zA-Z\.\:, \d_]*)(.*)/
+                raise "cannot parse class #{a}"
+            end
+            name = $1
+            parent_classes = $2
+            flags = $3
+            parent_classes = if parent_classes
+                                 parent_classes.gsub(" ","").split(",").map do |name|
                                      t = type(RBase.normalize(name),false)
                                      # auto add parent class
                                      t ||= add_type(RClass.new(RBase.normalize(name)))
                                  end
                              end
+            flags = if flags
+                       normalize_flags(line_number,flags.gsub(" ","").split("/").compact)
+                    end
             t = RClass.new(name,*parent_classes)
             t = if t2 = type(t.full_name,false)
                     if !t2.is_a?(RClass) || (!t2.parent_classes.empty? && t2.parent_classes != t.parent_classes)
                         raise "Cannot add class #{t.full_name}. A different type #{t2} is already registered"
                     else
-                        t2.parent_classes = t.instance_variable_get(:@parent_classes)
+                        t.parent_classes.each do |p|
+                            t2.add_parent p
+                        end
                         t2
                     end
                 else
                     add_type(t)
                     t
                 end
+            t.flags = flags if flags
             line_counter = 1
             lines.each do |line|
                 a = attribute(line_counter+line_number,line,t)
                 t.add_attribute(a)
                 line_counter += 1
             end
+            t.extern_package_name = @extern_package_name
             [t,line_counter]
         rescue RuntimeError  => e
             raise "input line #{line_number}: #{e}"
@@ -155,6 +167,7 @@ module Rbind
                 klass.add_attribute(a)
                 line_counter += 1
             end
+            klass.extern_package_name = @extern_package_name
             [klass,line_counter]
         rescue RuntimeError  => e
             raise "input line #{line_number}: #{e}"
@@ -162,11 +175,19 @@ module Rbind
 
         def parse_const(line_number,string)
             raise "multi line const are not supported: #{string}" if string.split("\n").size > 1
-            a = string.split(" ")
-            raise "not a constant: #{string}" unless a.shift == "const"
-            name = a.shift
-            value = a.join(" ")
+            unless string =~ /const ([a-zA-Z\.\d_:]*) ?([^\/]*)(.*)/
+                raise "cannot parse const #{string}"
+            end
+            name = $1
+            value = $2.chomp("\n").chomp(" ")
+            flags = $3
+            flags = if flags
+                       normalize_flags(line_number,flags.gsub(" ","").split("/").compact)
+                    end
+
             c = RConst.new(name,value)
+            c.flags = flags if flags
+            c.extern_package_name = @extern_package_name
             add_const(c)
             [c,1]
         end
@@ -211,7 +232,9 @@ module Rbind
             [op,line_counter]
         end
 
-        def parse(string)
+        def parse(string,extern_package_name=nil)
+            @extern_package_name = extern_package_name
+
             a = split(string)
             a.pop #remove number at the end of the file
             line_number = 1

data/lib/rbind/generator_c.rb

@@ -82,13 +82,15 @@ module Rbind
        class ConstsHelper < HelperBase
            def wrap_consts
                str = ""
-               @root.each_type do |type|
-                   next if !type.container?
-                   next if type.consts.empty?
-                   str += "\n\n//constants for #{type.full_name}\n"
-                   str += type.consts.map do |c|
-                       "#{c.csignature};\n"
-                   end.join
+               @root.each_container do |type|
+                   str2 = ""
+                   type.each_const(false) do |c|
+                       str2 += "#{c.csignature};\n"
+                   end
+                   if !str2.empty?
+                        str += "\n\n//constants for #{type.full_name}\n"
+                        str += str2
+                   end
                    str
                end
                str
@@ -131,10 +133,6 @@ module Rbind
                @type_conversion.result(t.binding)
            end
 
-           def check_type?
-               type_check?
-           end
-
            def wrap_conversions
                str = ""
                @root.each_type do |type|
@@ -152,13 +150,11 @@ module Rbind
 
            def wrap_operations
                str = ""
-               @root.each_type do |type|
-                   next unless type.respond_to? :operations
-                   str2 = type.operations.map do |ops|
-                       ops.map do |op|
-                           "#{op.csignature};"
-                       end.join("\n")
-                   end.join("\n")
+               @root.each_container do |type|
+                   str2 = ""
+                   type.each_operation do |op|
+                       str2 += "#{op.csignature};\n"
+                   end
                    if !str2.empty?
                        str += "\n\n///methods for #{type.full_name}\n"
                        str += str2
@@ -252,21 +248,19 @@ module Rbind
 
            def wrap_operations
                str = ""
-               @root.each_type do |type|
-                   next unless type.respond_to? :operations
-                   str += type.operations.map do |ops|
-                       ops.map do |op|
-                           operation_wrapper(op)
-                       end.join("\n")
-                   end.join("\n")
+               @root.each_container do |type|
+                   type.each_operation do |op|
+                       str += operation_wrapper(op)
+                   end
                end
                str
            end
        end
 
        class CMakeListsHelper < HelperBase
-           def initialize(name,pkg_config=Array.new)
-               super
+           def initialize(name,pkg_config=Array.new,libs=Array.new)
+               super(name,pkg_config)
+               @libs = libs
                @find_package = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","find_package.txt")).read)
            end
 
@@ -277,9 +271,10 @@ module Rbind
            end
 
            def libs
-               @root.map do |pkg|
+               str = @root.map do |pkg|
                    "${#{pkg.upcase}_LIBS} ${#{pkg.upcase}_LDFLAGS}"
                end.join(" ")
+               str += " " + @libs.join(" ")
            end
 
            def library_name
@@ -289,6 +284,7 @@ module Rbind
 
        attr_accessor :includes
        attr_accessor :library_name
+       attr_accessor :libs
        attr_accessor :pkg_config
        attr_accessor :generate_cmake
        attr_accessor :output_path
@@ -305,10 +301,12 @@ module Rbind
            @erb_conversions_hdr = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","conversions.hpp")).read)
            @erb_cmakelists = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","CMakeLists.txt")).read)
            @erb_find_package = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","find_package.txt")).read)
+           @erb_pkg_config = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","rbind.pc.in")).read)
            @includes = Array.new
-           @pkgconfig= Array.new
+           @pkg_config= Array.new
            @library_name = library_name
            @generate_cmake = true
+           @libs = []
        end
 
        def generate(path = @output_path)
@@ -321,33 +319,47 @@ module Rbind
            file_operations_hdr = File.new(File.join(path,"operations.h"),"w")
            file_conversions = File.new(File.join(path,"conversions.cc"),"w")
            file_conversions_hdr = File.new(File.join(path,"conversions.hpp"),"w")
-           file_cmakelists = File.new(File.join(path,"CMakeLists.txt"),"w")
+           rbind_pkgs = Rbind.rbind_pkgs(@pkg_config)
 
-           types_hdr = TypesHelperHDR.new("_RBIND_TYPES_H_",@root)
+           types_hdr = TypesHelperHDR.new("_#{library_name.upcase}_TYPES_H_",@root)
+           types_hdr.includes = rbind_pkgs.map do |p|
+               "<#{p}/types.h>"
+           end
            file_types_hdr.write @erb_types_hdr.result(types_hdr.binding)
 
            types = TypesHelper.new("types",@root)
            file_types.write @erb_types.result(types.binding)
 
-           consts = ConstsHelper.new("_RBIND_CONSTS_H_",@root)
+           consts = ConstsHelper.new("_#{library_name.upcase}_CONSTS_H_",@root)
+           consts.includes = rbind_pkgs.map do |p|
+               "<#{p}/constants.h>"
+           end
            file_consts.write @erb_consts.result(consts.binding)
 
-           conversions_hdr = ConversionsHelperHDR.new("_RBIND_CONVERSIONS_H_",@root)
+           conversions_hdr = ConversionsHelperHDR.new("#{library_name.upcase}_CONVERSIONS_H_",@root)
+           conversions_hdr.includes = rbind_pkgs.map do |p|
+               "<#{p}/conversions.hpp>"
+           end
            conversions_hdr.includes += includes
            file_conversions_hdr.write @erb_conversions_hdr.result(conversions_hdr.binding)
 
            conversions = ConversionsHelper.new("conversions",@root)
            file_conversions.write @erb_conversions.result(conversions.binding)
 
-           operations_hdr = OperationsHDRHelper.new("_RBIND_OPERATIONS_H_",@root)
+           operations_hdr = OperationsHDRHelper.new("_#{library_name.upcase}_OPERATIONS_H_",@root)
            file_operations_hdr.write @erb_operations_hdr.result(operations_hdr.binding)
 
            operations = OperationsHelper.new("operations",@root)
            file_operations.write @erb_operations.result(operations.binding)
 
-           if generate_cmake
-               cmakelists = CMakeListsHelper.new(@library_name,@pkg_config)
+           if generate_cmake && !File.exist?(File.join(path,"CMakeLists.txt"))
+               file_cmakelists = File.new(File.join(path,"CMakeLists.txt"),"w")
+               cmakelists = CMakeListsHelper.new(@library_name,@pkg_config,@libs)
                file_cmakelists.write @erb_cmakelists.result(cmakelists.binding)
+               if !File.exist?(File.join(path,"rbind.pc.in"))
+                   file_pkg_config = File.new(File.join(path,"rbind.pc.in"),"w")
+                   file_pkg_config.write @erb_pkg_config.result(Kernel.binding)
+               end
            end
        end
    end

data/lib/rbind/generator_extern.rb

@@ -0,0 +1,39 @@
+require 'yaml'
+
+module Rbind
+    class GeneratorExtern
+        Config = Struct.new(:ruby_module_name)
+
+        attr_accessor :output_path
+        attr_accessor :ruby_module_name
+        def self.normalize_type_name(name)
+            name.gsub('::','.')
+        end
+
+        def initialize(root)
+            @root = root
+        end
+
+        def generate(path = @output_path,ruby_module_name = @ruby_module_name)
+            @output_path = path
+            @ruby_module_name = ruby_module_name
+            FileUtils.mkdir_p(path) if path && !File.directory?(path)
+            file_extern = File.new(File.join(path,"extern.rbind"),"w")
+            file_config = File.new(File.join(path,"config.rbind"),"w")
+
+            @root.each_type do |t|
+                if t.is_a? RClass
+                    file_extern.write "class #{GeneratorExtern.normalize_type_name(t.full_name)} /Extern\n"
+                elsif t.is_a? RStruct
+                    file_extern.write "struct #{GeneratorExtern.normalize_type_name(t.full_name)} /Extern\n"
+                end
+            end
+
+            @root.each_const do |c|
+                file_extern.write "const #{GeneratorExtern.normalize_type_name(c.full_name)} /Extern\n"
+            end
+            file_extern.write("\n")
+            file_config.write Config.new(ruby_module_name).to_yaml
+        end
+    end
+end

data/lib/rbind/generator_ruby.rb

@@ -57,11 +57,20 @@ module Rbind
 
 
         def self.normalize_type_name(name)
-            name.split("::").map do |n|
+            names = name.split("::").map do |n|
                 n.gsub(/^(\w)(.*)/) do 
                     $1.upcase+$2
                 end
-            end.join("::")
+            end
+            n = names.last.split("_").first
+            if n == n.upcase
+                return names.join("::")
+            end
+            names.join("::").split("_").map do |n|
+                n.gsub(/^(\w)(.*)/) do 
+                    $1.upcase+$2
+                end
+            end.join("")
         end
 
         def self.normalize_basic_type_name(name)
@@ -76,21 +85,18 @@ module Rbind
         end
 
         def self.normalize_method_name(name)
-            name = name.to_s.sub(/\A#{RBase.cprefix}?/, "").gsub(/(?<!\A)\p{Lu}/u, '_\0').downcase
+            name = name.to_s.gsub(/\A#{RBase.cprefix}?/, "").gsub(/(?<!\A)\p{Lu}/u, '_\0').downcase
             str = ""
             name.split("_").each_with_index do |n,i|
-                if n.empty?
-                    str += "_"
-                    next
-                end
+                next if n.empty?
                 if n.size == 1 && i > 1
                     str += n
                 else
                     str += "_#{n}"
                 end
             end
-            name = str[1,str.size-1]
-            name = if name =~/^operator(.*)/
+            str = str[1..-1] #remove leading "_"
+            str = if str =~/^operator(.*)/
                         n = $1
                         if n =~ /\(\)/
                             raise "forbbiden method name #{name}"
@@ -112,7 +118,7 @@ module Rbind
                             n
                         end
                    else
-                        name
+                       str
                    end
         end
 
@@ -133,15 +139,20 @@ module Rbind
         end
 
         class RBindHelper < HelperBase
-            #TODO
-            attr_accessor :library_name
+            attr_reader :compact_namespace
 
-            def initialize(name, root)
-                super
+            def initialize(name, root,compact_namespace=false)
+                @compact_namespace = compact_namespace
+                super(name,root)
             end
 
             def normalize_t(name)
-                GeneratorRuby.normalize_type_name name
+                t = GeneratorRuby.normalize_type_name name
+                if compact_namespace
+                    t.gsub(/^#{self.name}::/,"")
+                else
+                    t
+                end
             end
 
             def normalize_bt(name)
@@ -152,9 +163,23 @@ module Rbind
                 GeneratorRuby.normalize_method_name name
             end
 
+            def library_name
+                @root.library_name
+            end
+
+            def required_module_names
+                @root.required_module_names.map do |name|
+                    "require '#{name.downcase}'\n"
+                end.join
+            end
+
+            def file_prefix
+                @root.file_prefix
+            end
+
             def add_accessors
                 str = ""
-                @root.each_type do |t|
+                @root.root.each_type do |t|
                     next if t.basic_type? && !t.is_a?(RNamespace)
                     str += "\n#methods for #{t.full_name}\n"
                     if t.cdelete_method
@@ -163,28 +188,34 @@ module Rbind
                         str += "attach_function :#{normalize_m t.cdelete_method}_struct,"\
                         ":#{t.cdelete_method},[#{normalize_t t.full_name}Struct],:void\n"
                     end
-                    str += t.operations.map do |ops|
-                        ops.map do |op|
-                            return_type = if op.constructor?
-                                              "#{normalize_t op.owner.full_name}"
+                    t.each_operation do |op|
+                        return_type = if op.constructor?
+                                          "#{normalize_t op.owner.full_name}"
+                                      else
+                                          if op.return_type.basic_type?
+                                              ":#{normalize_bt op.return_type.csignature}"
                                           else
-                                              if op.return_type.basic_type?
-                                                  ":#{normalize_bt op.return_type.csignature}"
+                                              if op.return_type.extern_package_name
+                                                  normalize_t("::#{op.return_type.extern_package_name}::#{op.return_type.full_name}")
                                               else
-                                                  "#{normalize_t op.return_type.full_name}"
+                                                  normalize_t op.return_type.full_name
                                               end
                                           end
-                            args = op.cparameters.map do |p|
-                                if p.type.basic_type?
-                                    ":#{normalize_bt p.type.csignature}"
+                                      end
+                        args = op.cparameters.map do |p|
+                            if p.type.basic_type?
+                                ":#{normalize_bt p.type.csignature}"
+                            else
+                                if p.type.extern_package_name
+                                    normalize_t("::#{p.type.extern_package_name}::#{p.type.full_name}")
                                 else
-                                    "#{normalize_t p.type.full_name}"
+                                    normalize_t p.type.full_name
                                 end
                             end
-                            fct_name = normalize_m op.cname
-                            "attach_function :#{fct_name},:#{op.cname},[#{args.join(",")}],#{return_type}\n"
-                        end.join
-                    end.join
+                        end
+                        fct_name = normalize_m op.cname
+                        str += "attach_function :#{fct_name},:#{op.cname},[#{args.join(",")}],#{return_type}\n"
+                    end
                     str+"\n"
                 end
                 str+"\n"
@@ -241,13 +272,14 @@ module Rbind
                 end
             end
 
-            def initialize(name, root)
+            def initialize(name, root,compact_namespace = false)
                 @type_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","rtype.rb")).read,nil,"-")
                 @type_constructor_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","rtype_constructor.rb")).read,nil,"-")
                 @namespace_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","rnamespace.rb")).read,nil,"-")
                 @static_method_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","rstatic_method.rb")).read)
                 @method_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","rmethod.rb")).read,nil,'-')
-                super
+                @compact_namespace = compact_namespace
+                super(name,root)
             end
 
             def name
@@ -275,39 +307,55 @@ module Rbind
                 ops = Array(@root.operation(@root.name,false))
                 return until ops
                 ops.map do |c|
+                    next if c.ignore?
                     ch = OperationHelper.new(c)
                     @type_constructor_wrapper.result(ch.binding)
                 end.join("\n")
             end
 
-            def add_consts
-                @root.consts.map do |c|
+            def add_consts(root=@root)
+                str = @root.consts.map do |c|
+                    next if c.extern? || c.ignore?
                     "    #{c.name} = #{GeneratorRuby::normalize_type_name(c.value)}\n"
                 end.join
+                return str unless @compact_namespace
+
+                root.each_type(false) do |t|
+                    next if t.basic_type? && !t.is_a?(RNamespace)
+                    str += add_consts(t) if name == GeneratorRuby.normalize_type_name(t.full_name)
+                end
+                str
             end
 
-            def add_methods
+            def add_methods(root=@root)
                 str = ""
-                @root.operations.each do |ops|
-                    ops.each do |op|
-                        next if op.constructor?
-                        oph = OperationHelper.new(op)
-                        str += if op.instance_method?
-                                   @method_wrapper.result(oph.binding)
-                               else
-                                   @static_method_wrapper.result(oph.binding)
-                               end
-                    end
+                @root.each_operation do |op|
+                    next if op.constructor?
+                    oph = OperationHelper.new(op)
+                    str += if op.instance_method?
+                               @method_wrapper.result(oph.binding)
+                           else
+                               @static_method_wrapper.result(oph.binding)
+                           end
+                end
+                return str unless @compact_namespace
+
+                root.each_type(false) do |t|
+                    next if t.basic_type? && !t.is_a?(RNamespace)
+                    str += add_methods(t) if name == GeneratorRuby.normalize_type_name(t.full_name)
                 end
                 str
             end
 
-            def add_types
+            def add_types(root = @root)
                 str = ""
-                @root.each_type(false) do |t|
+                root.each_type(false) do |t|
                     next if t.basic_type? && !t.is_a?(RNamespace)
-                    t = RTypeHelper.new(t.name,t)
-                    str += t.result
+                    str += if @compact_namespace && name == GeneratorRuby.normalize_type_name(t.full_name)
+                        add_types(t)
+                    else
+                        RTypeHelper.new(t.name,t).result
+                    end
                 end
                 str
             end
@@ -317,6 +365,7 @@ module Rbind
             end
 
             def result
+                return "" if @root.extern?
                 str = if @root.is_a? RStruct
                           @type_wrapper.result(self.binding)
                       else
@@ -332,27 +381,34 @@ module Rbind
         end
 
         attr_accessor :module_name
+        attr_accessor :required_module_names
         attr_accessor :library_name
         attr_accessor :output_path
+        attr_accessor :file_prefix
+        attr_accessor :compact_namespace
+        attr_reader :root
 
+        def file_prefix
+            @file_prefix || GeneratorRuby.normalize_method_name(module_name)
+        end
 
         def initialize(root,module_name ="Rbind",library_name="rbind_lib")
             @root = root
             @rbind_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","rbind.rb")).read)
             @module_name = module_name
             @library_name = library_name
+            @compact_namespace = false
         end
 
         def generate(path=@output_path)
             @output_path = path
             FileUtils.mkdir_p(path) if path  && !File.directory?(path)
-            file_rbind = File.new(File.join(path,"opencv.rb"),"w")
-            file_types = File.new(File.join(path,"opencv_types.rb"),"w")
+            file_rbind = File.new(File.join(path,"#{file_prefix}.rb"),"w")
+            file_types = File.new(File.join(path,"#{file_prefix}_types.rb"),"w")
 
-            types = RTypeHelper.new(@module_name,@root)
+            types = RTypeHelper.new(@module_name,@root,compact_namespace)
             file_types.write types.result
-            rbind = RBindHelper.new(@module_name,@root)
-            rbind.library_name = @library_name
+            rbind = RBindHelper.new(@module_name,self,compact_namespace)
             file_rbind.write @rbind_wrapper.result(rbind.binding)
         end
     end

data/lib/rbind/rbind.rb

@@ -9,6 +9,33 @@ module Rbind
         attr_accessor :name
         attr_accessor :pkg_config
 
+        def self.pkg_paths(pkg_name)
+            out = IO.popen("pkg-config --cflags-only-I #{pkg_name}")
+            paths = out.read.split("-I").delete_if(&:empty?).map do |i|
+                i.gsub("\n","").gsub(" ","")
+            end
+            raise "Cannot find pkg paths for #{pkg_name}" if paths.empty?
+            paths
+        end
+
+        def self.rbind_pkgs(pkg_names)
+            pkg_names.find_all do |p|
+                !!(p =~ /^rbind_.*/)
+            end
+        end
+
+        def self.rbind_pkg_paths(pkg_names)
+            rbind_packages = rbind_pkgs(pkg_names)
+            rbind_paths = rbind_packages.map do |pkg|
+                paths = pkg_paths(pkg)
+                path = paths.find do |p|
+                    File.exist?(File.join(p,pkg,"extern.rbind"))
+                end
+                raise "cannot find extern.rbind for rbind package #{pkg}" unless path
+                File.join(path,pkg)
+            end
+        end
+
         def initialize(name)
             @name = name
             @includes = []
@@ -17,6 +44,7 @@ module Rbind
             lib_name = "rbind_#{name.downcase}"
             @generator_c = GeneratorC.new(@parser,lib_name)
             @generator_ruby = GeneratorRuby.new(@parser,name,lib_name)
+            @generator_extern = GeneratorExtern.new(@parser)
         end
 
         def parse(*files)
@@ -46,8 +74,18 @@ module Rbind
             end
         end
 
-        def parse_headers(*headers)
-            ::Rbind.log.info "parse header files"
+        # parses other rbind packages
+        def parse_extern
+            paths = Rbind.rbind_pkg_paths(@pkg_config)
+            paths.each do |pkg|
+                config = YAML.load(File.open(File.join(pkg,"config.rbind")).read)
+                path = File.join(pkg,"extern.rbind")
+                ::Rbind.log.info "parsing extern rbind pkg file #{path}"
+                parser.parse(File.open(path).read,config.ruby_module_name)
+            end
+        end
+
+        def parse_headers_dry(*headers)
             check_python
             headers = if headers.empty?
                           includes
@@ -59,7 +97,11 @@ module Rbind
             end
             path = File.join(File.dirname(__FILE__),'tools','hdr_parser.py')
             out = IO.popen("python #{path} #{headers.join(" ")}")
-            parser.parse out.read
+            out.read
+        end
+
+        def parse_headers(*headers)
+            parser.parse parse_headers_dry(*headers)
         end
 
         def build
@@ -82,11 +124,18 @@ module Rbind
 
         def generate(c_path = "src",ruby_path = "ruby/lib/#{name.downcase}")
             generate_c c_path
+            generate_extern c_path
             generate_ruby ruby_path
         end
 
         def generate_ruby(path)
             ::Rbind.log.info "generate ruby ffi wrappers"
+            paths = Rbind.rbind_pkg_paths(@pkg_config)
+            modules = paths.map do |pkg|
+                config = YAML.load(File.open(File.join(pkg,"config.rbind")).read)
+                config.ruby_module_name
+            end
+            @generator_ruby.required_module_names = modules
             @generator_ruby.generate(path)
         end
 
@@ -97,6 +146,10 @@ module Rbind
             @generator_c.generate(path)
         end
 
+        def generate_extern(path)
+            @generator_extern.generate(path,@generator_ruby.module_name)
+        end
+
         def use_namespace(name)
             t = if name.is_a? String
                     parser.type(name)
@@ -114,6 +167,10 @@ module Rbind
             @parser.on_type_not_found(&block)
         end
 
+        def libs
+            @generator_c.libs
+        end
+
         def method_missing(m,*args)
             t = @parser.type(m.to_s,false)
             return t if t

data/lib/rbind/templates/c/CMakeLists.txt

@@ -1,5 +1,4 @@
 cmake_minimum_required(VERSION 2.6)
-
 PROJECT(<%= library_name %> CXX)
 
 include(FindPkgConfig)
@@ -9,3 +8,17 @@ SET(RBIND_SRC types.cc operations.cc conversions.cc)
 ADD_LIBRARY(<%= library_name %> SHARED ${RBIND_SRC})
 
 TARGET_LINK_LIBRARIES(<%= library_name %> <%= libs %>)
+
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/rbind.pc.in ${CMAKE_CURRENT_BINARY_DIR}/<%= library_name %>.pc @ONLY)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/<%= library_name %>.pc DESTINATION lib/pkgconfig)
+
+install(TARGETS <%= library_name %> LIBRARY DESTINATION lib)
+install(FILES types.h operations.h conversions.hpp DESTINATION include/${PROJECT_NAME}/${DIR})
+
+if (EXISTS ${PROJECT_SOURCE_DIR}/extern.rbind)
+    install(FILES ${PROJECT_SOURCE_DIR}/extern.rbind DESTINATION include/${PROJECT_NAME}/${DIR})
+endif()
+
+if (EXISTS ${PROJECT_SOURCE_DIR}/config.rbind)
+    install(FILES ${PROJECT_SOURCE_DIR}/config.rbind DESTINATION include/${PROJECT_NAME}/${DIR})
+endif()

data/lib/rbind/templates/c/rbind.pc.in

@@ -0,0 +1,11 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: @PROJECT_NAME@
+Description: @PROJECT_DESCRIPTION@
+Version: @PROJECT_VERSION@
+Requires: <%= pkg_config.join(" ") %>
+Libs: -L${libdir} -l@PROJECT_NAME@
+Cflags: -I${includedir}

data/lib/rbind/templates/c/type_conversion.cc

@@ -21,19 +21,15 @@ const <%= full_name %>* fromC(const <%= cname %>* ptr)
         throw std::runtime_error(str + static_cast<const std::type_info*>(ptr->type_id)->name()
                     + " but was expecting " + typeid(<%= full_name %>).name());
     }
-
     // check version
     if(ptr->version != <%= version %>)
         throw std::runtime_error("wrong object version for <%= full_name %>");
     <%- end %>
-
     // check size
-    if(sizeof(<%= full_name %>) > ptr->size)
-        throw std::runtime_error("wrong object size for <%= full_name %>");
-
+    if(ptr->size && sizeof(<%= full_name %>) > ptr->size)
+        throw std::runtime_error("wrong object size for <%= full_name %>.");
     if(!ptr->obj_ptr)
         throw std::runtime_error("object for <%= full_name %> was deleted!");
-
     return static_cast<const <%= full_name %>*>(ptr->obj_ptr);
 }
 

data/lib/rbind/templates/ruby/rbind.rb

@@ -1,5 +1,6 @@
 require 'ffi'
-require File.join(File.dirname(__FILE__),'opencv_types')
+require File.join(File.dirname(__FILE__),'<%= file_prefix %>_types.rb')
+<%= required_module_names %>
 
 module <%= name %>
     # low level accessors the wrapped library 

data/lib/rbind/templates/ruby/rtype.rb

@@ -18,7 +18,7 @@ class <%= name %>
     native_type FFI::Type::POINTER
 
     def self.new(*args)
-        if args.first.is_a?(FFI::Pointer)
+        if args.first.is_a?(FFI::Pointer) || args.first.is_a?(<%= name %>Struct)
             raise ArgumentError, "too many arguments for creating #{self.name} from Pointer" unless args.size == 1
             return super(args.first)
         end

data/rbind.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
     s.name              = 'rbind'
-    s.version           = '0.0.2'
-    s.date              = '2013-06-17'
+    s.version           = '0.0.3'
+    s.date              = '2013-06-20'
     s.platform          = Gem::Platform::RUBY
     s.authors           = ['Alexander Duda']
     s.email             = ['Alexander.Duda@dfki.de']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbind
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-17 00:00:00.000000000 Z
+date: 2013-06-20 00:00:00.000000000 Z
 dependencies: []
 description: ''
 email:
@@ -36,6 +36,7 @@ files:
 - lib/rbind/core/rvector.rb
 - lib/rbind/default_parser.rb
 - lib/rbind/generator_c.rb
+- lib/rbind/generator_extern.rb
 - lib/rbind/generator_ruby.rb
 - lib/rbind/logger.rb
 - lib/rbind/rbind.rb
@@ -47,6 +48,7 @@ files:
 - lib/rbind/templates/c/operation_wrapper.cc
 - lib/rbind/templates/c/operations.cc
 - lib/rbind/templates/c/operations.h
+- lib/rbind/templates/c/rbind.pc.in
 - lib/rbind/templates/c/type_conversion.cc
 - lib/rbind/templates/c/type_conversion.hpp
 - lib/rbind/templates/c/type_delete.h