rbind 0.0.26 → 0.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46980738979a4fdad06df4d7e4b0c7575c78fc4e
-  data.tar.gz: 8d9c115d8f4796b04e2454129c0d843c1362f727
+  metadata.gz: 35c0ae5064a1ce8f8300cd4c05a55023ea335709
+  data.tar.gz: 199b59b9b1276492efc6c8dc1ae647f1767948f5
 SHA512:
-  metadata.gz: 1e1f14419e0c7671ba60aecdc2f6b908c07e6f6dd52599e67594cb82021f724e0de826bbda44e48caa15b0f028f62923590aee55d82f4b182d6fe88e788a4c4f
-  data.tar.gz: 6f09249e83aa24141ab16847c4961825f3d3731386e9d69e46ee27326ca7ae298d316d33d65490aaa9aa6466a26c0b7e1815e1ad0cb81232ec6788d15b88d916
+  metadata.gz: 1cdc8e6a92bf75d18c22b51e2bb8f109eba3d40e7ea098ec06ecef746cb42266c6b6fe9970f4287d16ea567eb3770b3909c0103473aca774e386436ed9d66602
+  data.tar.gz: 9a7da3274763ca86e8d898b8f941d58a802daa7b3c6a6dda3fdded7bbe307c8fea0dc423f130f303cfb996e26653d3f2df1c4fd5cf1ca84ff77d7d3cc7a32fb3

data/lib/rbind/core/hooks.rb

@@ -0,0 +1,57 @@
+require 'set'
+
+module Hooks
+    module ClassMethods
+        def define_hook(name)
+            name = name.to_sym
+            @hook_names << name
+            instance_eval %Q{
+                def #{name}(&block)
+                    @hook_callbacks[:#{name}] << block
+                end
+                }
+        end
+
+        def __initialize
+            @hook_names ||= Set.new
+            @hook_callbacks ||= Hash.new do |h,k|
+                h[k] = Array.new
+            end
+        end
+
+        def callbacks_for_hook(name)
+            name = name.to_sym
+            raise ArgumentError,"hook #{name} is not known" unless hook?(name)
+            if @hook_callbacks.has_key?(name)
+                @hook_callbacks[name]
+            else
+                []
+            end
+        end
+
+        def hook?(name)
+            name = name.to_sym
+            if @hook_names.include?(name)
+                true
+            else
+                false
+            end
+        end
+
+        def callback?(name)
+            !callbacks_for_hook(name).empty?
+        end
+
+        def run_hook(name,*args)
+            callbacks = callbacks_for_hook(name)
+            callbacks.map do |c|
+                c.call(*args)
+            end
+        end
+    end
+
+    def self.included(base)
+        base.extend ClassMethods
+        base.__initialize
+    end
+end

data/lib/rbind/core/rcast_operation.rb

@@ -0,0 +1,14 @@
+
+module Rbind
+    class RCastOperation < ROperation
+        extend ::Rbind::Logger
+        def initialize(name,to_class,from_class=nil)
+            para = []
+            if(from_class)
+                @static = true
+                para << RParameter.new("ptr",from_class.to_ptr)
+            end
+            super(name,to_class.to_ptr,para)
+        end
+    end
+end

data/lib/rbind/core/rclass.rb

@@ -3,21 +3,28 @@ module Rbind
     class RClass < RNamespace
         attr_reader :parent_classes
         attr_reader :attributes
+        attr_accessor :polymorphic
         ParentClass = Struct.new(:type,:accessor)
+        ChildClass = Struct.new(:type,:accessor)
 
         def initialize(name,*parent_classes)
+            super(name)
             @parent_classes  = Hash.new
+            @child_classes  = Hash.new
             @attributes = Hash.new
             parent_classes.flatten!
             parent_classes.each do |p|
                 add_parent(p)
             end
-            super(name)
             # we have to disable the type check for classes
             # otherwise derived types cannot be parsed
             @check_type = false
         end
 
+        def polymorphic?
+            !!@polymorphic
+        end
+
         def basic_type?
             false
         end
@@ -50,7 +57,7 @@ module Rbind
         def attributes
             attribs = @attributes.values
             parent_classes.each do |k|
-                others = k.type.attributes
+                others = k.attributes
                 others.delete_if do |other|
                     attribs.inclue? other
                 end
@@ -67,7 +74,7 @@ module Rbind
             attrib = @attributes[name]
             attrib ||= begin
                            p = parent_classes.find do |k|
-                               k.type.attribute(name)
+                               k.attribute(name)
                            end
                            a = p.attribute(name).dup if p
                            a.owner = self if a
@@ -79,7 +86,11 @@ module Rbind
             # temporarily add all base class operations
             own_ops = @operations.dup
             parent_classes.each do |k|
-                k.type.operations.each do |other_ops|
+                add_operation RCastOperation.new("castTo#{k.name}",k)
+                if k.polymorphic?
+                    add_operation RCastOperation.new("castFrom#{k.name}",self,k)
+                end
+                k.operations.each do |other_ops|
                     next if other_ops.empty?
                     ops = if @operations.has_key?(other_ops.first.name)
                             @operations[other_ops.first.name]
@@ -116,7 +127,7 @@ module Rbind
         def used_namespaces
             namespaces = super.clone
             parent_classes.each do |k|
-                namespaces += k.type.used_namespaces
+                namespaces += k.used_namespaces
             end
             namespaces
         end
@@ -128,7 +139,7 @@ module Rbind
                       []
                   end
             parent_classes.each do |k|
-                other_ops = Array(k.type.operation(name,false))
+                other_ops = Array(k.operation(name,false))
                 other_ops.delete_if do |other_op|
                     ops.include? other_op
                 end
@@ -163,10 +174,17 @@ module Rbind
             str = "#{"template " if template?}class #{full_name}"
             unless parent_classes.empty?
                 parents = parent_classes.map do |p|
-                    p.type.full_name
+                    p.full_name
                 end
                 str += " : " +  parents.join(", ")
             end
+            unless child_classes.empty?
+                childs = child_classes.map do |c|
+                    c.full_name
+                end
+                str += " Childs: " +  childs.join(", ")
+            end
+
             str
         end
 
@@ -192,24 +210,89 @@ module Rbind
                              else
                                  [klass,accessor]
                              end
-            if @parent_classes.has_key? klass.name
+            if !klass.name || klass.name.empty?
+                raise ArgumentError, "klass name is empty"
+            end
+            if parent? klass
                 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
             @parent_classes[klass.name] = ParentClass.new(klass,accessor)
+            klass.add_child(self,accessor) unless klass.child?(self)
             self
         end
 
+        def parent?(name)
+            name = if name.respond_to?(:name)
+                       name.name
+                   else
+                       name
+                   end
+            @parent_classes.key?(name)
+        end
+
         def parent_class(name)
+            name = if name.respond_to?(:name)
+                       name.name
+                   else
+                       name
+                   end
             @parent_class[name].type
         end
 
         def parent_classes(accessor = :public)
-            @parent_classes.values.find_all do |k|
-                k.accessor = accessor
+            parents = @parent_classes.values.find_all do |k|
+                k.accessor == accessor
+            end
+            parents.map(&:type)
+        end
+
+        def add_child(klass,accessor=:public)
+            klass,accessor = if klass.is_a?(ChildClass)
+                                 [klass.type,klass.accessor]
+                             else
+                                 [klass,accessor]
+                             end
+            if !klass.name || klass.name.empty?
+                raise ArgumentError, "klass name is empty"
+            end
+            if child? klass
+                raise ArgumentError,"#A child 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 child of its self"
+            end
+            @polymorphic ||= true
+            @child_classes[klass.name] = ChildClass.new(klass,accessor)
+            klass.add_parent(self,accessor) unless klass.parent?(self)
+            self
+        end
+
+        def child?(name)
+            name = if name.respond_to?(:name)
+                       name.name
+                   else
+                       name
+                   end
+            @child_classes.key?(name)
+        end
+
+        def child_class(name)
+            name = if name.respond_to?(:name)
+                       name.name
+                   else
+                       name
+                   end
+            @child_classes[name].type
+        end
+
+        def child_classes(accessor = :public)
+            childs = @child_classes.values.find_all do |k|
+                k.accessor == accessor
             end
+            childs.map(&:type)
         end
     end
 end

data/lib/rbind/core/rnamespace.rb

@@ -203,6 +203,20 @@ module Rbind
             end
         end
 
+        def used_extern_types
+            extern = Set.new
+            each_operation do |op|
+                extern << op.return_type.to_raw if op.return_type && op.return_type.extern?
+                op.parameters.each do |arg|
+                    extern << arg.type.to_raw if arg.type.extern?
+                end
+            end
+            each_container do |type|
+                extern += type.used_extern_types
+            end
+            extern
+        end
+
         def operations
             @operations.values
         end
@@ -341,6 +355,10 @@ module Rbind
             type
         end
 
+        def type?(name,search_owner = true)
+            !type(name,false,search_owner).nil?
+        end
+
         def type(name,raise_ = true,search_owner = true)
             name = name.to_s
             constant = if name =~ /const /
@@ -428,8 +446,8 @@ module Rbind
                       end
                     end
             if !t && raise_
-                if self.class.callbacks_for_hook(:on_type_not_found)
-                    results = self.run_hook(:on_type_not_found,self,name)
+                if RNamespace.callbacks_for_hook(:on_type_not_found)
+                    results = RNamespace.run_hook(:on_type_not_found,self,name)
                     t = results.find do |t|
                         t.respond_to?(:type)
                     end

data/lib/rbind/core.rb

@@ -1,11 +1,12 @@
-require 'hooks'
 require 'rbind/logger.rb'
+require 'rbind/core/hooks.rb'
 require 'rbind/core/rbase.rb'
 require 'rbind/core/rdata_type.rb'
 require 'rbind/core/renum.rb'
 require 'rbind/core/rattribute.rb'
 require 'rbind/core/rparameter.rb'
 require 'rbind/core/roperation.rb'
+require 'rbind/core/rcast_operation.rb'
 require 'rbind/core/rgetter.rb'
 require 'rbind/core/rsetter.rb'
 require 'rbind/core/rnamespace.rb'

data/lib/rbind/default_parser.rb

@@ -61,7 +61,7 @@ module Rbind
             end
         end
 
-        def find_type(owner,type_name)
+        def find_type(owner,type_name,braise=true)
             type_name = unmask_template(type_name)
             t = owner.type(type_name,false)
             return t if t
@@ -81,7 +81,7 @@ module Rbind
             return t if t
 
             #search again even if we know the type is not there to create a proper error message
-            owner.type(type_name,true)
+            owner.type(type_name,true) if braise
         end
 
         def parameter(line_number,string,owner = self)
@@ -113,7 +113,13 @@ module Rbind
             array = flags.shift.split(" ")
             type_name = array[0]
             name = array[1]
-            type = find_type(owner,type_name)
+            type = find_type(owner,type_name,false)
+            # auto embedded types
+            type ||= begin
+                         t = owner.add_type(RClass.new(RBase.normalize(type_name)))
+                         t.extern_package_name = @extern_package_name
+                         t
+                     end
             flags = normalize_flags(line_number,flags,:RW,:R)
             a = RAttribute.new(name,type)
             a.writeable!(true) if flags.include? :RW
@@ -156,25 +162,11 @@ module Rbind
                                  end
                              end
             flags = if flags
-                       normalize_flags(line_number,flags.gsub(" ","").split("/").compact,:Simple)
+                       normalize_flags(line_number,flags.gsub(" ","").split("/").compact,:Simple,:Map)
                     end
             t = RClass.new(name,*parent_classes)
             t.extern_package_name = @extern_package_name
-            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
-                        t.parent_classes.each do |p|
-                            t2.add_parent p
-                        end
-                        t2.extern_package_name = t.extern_package_name
-                        t2
-                    end
-                else
-                    t.name = t.name.gsub(">>","> >")
-                    add_type(t)
-                    t
-                end
+            t = add_type(t)
             line_counter = 1
             lines.each do |line|
                 a = attribute(line_counter+line_number,line,t)
@@ -186,6 +178,24 @@ module Rbind
             raise "input line #{line_number}: #{e}"
         end
 
+        def add_type(klass)
+            if klass2 = type(klass.full_name,false)
+                if !klass2.is_a?(RClass) || (!klass2.parent_classes.empty? && klass2.parent_classes != klass.parent_classes)
+                    raise "Cannot add class #{klass.full_name}. A different type #{klass2} is already registered"
+                else
+                    klass.parent_classes.each do |p|
+                        klass2.add_parent p
+                    end
+                    klass2.extern_package_name = klass.extern_package_name
+                    klass2
+                end
+            else
+                klass.name = klass.name.gsub(">>","> >")
+                super(klass)
+                klass
+            end
+        end
+
         def parse_struct(line_number,string)
             a = string.split("\n")
             first_line = a.shift
@@ -193,7 +203,7 @@ module Rbind
             name = flags.shift.split(" ")[1]
             flags = normalize_flags(line_number,flags)
             klass = RClass.new(name)
-            add_type(klass)
+            klass = add_type(klass)
             line_counter = 1
             a.each do |line|
                 a = attribute(line_counter+line_number,line,klass)
@@ -280,7 +290,9 @@ module Rbind
             @extern_package_name = extern_package_name
 
             a = split(string)
-            a.pop #remove number at the end of the file
+            #remove number at the end of the file
+            a.pop if a.last.to_i != 0
+
             line_number = 1
             a.each do |block|
                 begin
@@ -305,15 +317,20 @@ module Rbind
                     break
                 end
             end
+            a.size
         end
 
         def split(string)
             array = []
-            string.each_line do |line|
-                if !line.empty? && line[0] != " "
-                    array << line
-                else
-                    array[array.size-1] = array.last + line
+            if string
+                string.each_line do |line|
+                    if line == "\n" || line.empty?
+                       next
+                    elsif line[0] != " "
+                        array << line
+                    elsif !array.empty?
+                        array[array.size-1] = array.last + line
+                    end
                 end
             end
             array