rbind 0.0.27 → 0.0.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 35c0ae5064a1ce8f8300cd4c05a55023ea335709
-  data.tar.gz: 199b59b9b1276492efc6c8dc1ae647f1767948f5
+SHA256:
+  metadata.gz: eea754672174a0aa6ab449d1df8bea30400e7720f5a0cd701b74bd01d377f60b
+  data.tar.gz: d771496b0cea68ecc142775ff45a4f41397f4f40b114c6748aea8dc67c9118c3
 SHA512:
-  metadata.gz: 1cdc8e6a92bf75d18c22b51e2bb8f109eba3d40e7ea098ec06ecef746cb42266c6b6fe9970f4287d16ea567eb3770b3909c0103473aca774e386436ed9d66602
-  data.tar.gz: 9a7da3274763ca86e8d898b8f941d58a802daa7b3c6a6dda3fdded7bbe307c8fea0dc423f130f303cfb996e26653d3f2df1c4fd5cf1ca84ff77d7d3cc7a32fb3
+  metadata.gz: 4813c2cb91f792c17587adb578d367fe1998f66d8cafea9290e19f3b6d146786b3d1acaebd10f47cb6fd30aaa26764bfa9c33fd8eeed1b95cd80d0da5cc23660
+  data.tar.gz: 1182a9bcf4d35623d50eb866be4fdc48a2ada495d1e1f7e54bc5a61e45341ca89f1ea70b9e0b80110e36d8dfba93cf3b11565b4df829a2033569c75160fb4fa5

data/lib/rbind/core/rbase.rb

@@ -123,7 +123,7 @@ module Rbind
         end
 
         def owner=(obj)
-            raise ArgumentError,"Cannot at self as owner" if obj.object_id == self.object_id
+            raise ArgumentError,"Cannot add self as owner" if obj.object_id == self.object_id
             @owner = obj
             @namespace = nil
         end

data/lib/rbind/core/rcast_operation.rb

@@ -8,6 +8,7 @@ module Rbind
                 @static = true
                 para << RParameter.new("ptr",from_class.to_ptr)
             end
+	    para << RParameter.new("parse_ownership",to_class.type("bool"))
             super(name,to_class.to_ptr,para)
         end
     end

data/lib/rbind/core/rclass.rb

@@ -86,37 +86,43 @@ module Rbind
             # temporarily add all base class operations
             own_ops = @operations.dup
             parent_classes.each do |k|
-                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]
-                          else
-                              []
-                          end
-                    other_ops.delete_if do |other_op|
-                        next true if !other_op || other_op.constructor?
-                        op = ops.find do |o|
-                            o == other_op
-                        end
-                        next false if !op
-                        next true if op.base_class == self
-                        next true if op.base_class == other_op.base_class
-                        # ambiguous name look up due to multi
-                        # inheritance
-                        op.ambiguous_name = true
-                        other_op.ambiguous_name = true
-                        false
-                    end
-                    other_ops = other_ops.map(&:dup)
-                    other_ops.each do |other|
-                        old = other.alias
-                        add_operation other
-                    end
+		add_operation RCastOperation.new("castTo#{k.name.gsub(/[:,<>]/,"_")}",k)
+                if k.polymorphic? && polymorphic?
+                    add_operation RCastOperation.new("castFrom#{k.name.gsub(/[:,<>]/,"_")}",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]
+			  else
+			      []
+			  end
+		    other_ops.delete_if do |other_op|
+			next true if !other_op || other_op.constructor? || other_op.static?
+			#check for name hiding
+			if own_ops.has_key?(other_op.name)
+			    #puts "#{other_op} is shadowed by #{own_ops[other_op.name].first}"
+			    next true
+			end
+			op = ops.find do |o|
+			    o == other_op
+			end
+			next false if !op
+			next true if op.base_class == self
+			next true if op.base_class == other_op.base_class
+
+			# ambiguous name look up due to multi
+			# inheritance
+			op.ambiguous_name = true
+			other_op.ambiguous_name = true
+			false
+		    end
+		    other_ops = other_ops.map(&:dup)
+		    other_ops.each do |other|
+			old = other.alias
+			add_operation other
+		    end
+		end
             end
             # copy embedded arrays other wise they might get modified outside
             result = @operations.values.map(&:dup)
@@ -214,12 +220,15 @@ module Rbind
                 raise ArgumentError, "klass name is empty"
             end
             if parent? klass
-                raise ArgumentError,"#A parent class with the name #{klass.name} already exists"
+                puts "ignore: parent class #{klass.name} was added multiple time to class #{name}"
+                return self
             end
             if klass.full_name == full_name || klass == self
-                raise ArgumentError,"class #{klass.full_name} cannot be parent of its self"
+                puts "ignore: class #{klass.name} cannot be parent class of itself"
+                return self
             end
             @parent_classes[klass.name] = ParentClass.new(klass,accessor)
+	    raise "Cannot use namespace #{klass.full_name} as parent class for #{self.full_name}" unless(klass.respond_to?(:child?))
             klass.add_child(self,accessor) unless klass.child?(self)
             self
         end

data/lib/rbind/core/rgetter.rb

@@ -5,7 +5,7 @@ module Rbind
 
         def initialize(attr)
             @attribute = attr
-            super("get_#{attr.name}",attr.type)
+	    super("get_#{attr.name}",attr.type.to_const)
         end
 
         def attribute?

data/lib/rbind/core/rnamespace.rb

@@ -13,8 +13,8 @@ module Rbind
             attr_accessor :default_operator_alias
         end
         # TODO move somewhere else
-        self.default_type_names = [:int,:int8,:int32,:int64,:uint,:uint8,:uint32,:uint64,
-                                   :int8_t,:int32_t,:int64_t,:uint8_t,:uint32_t,:uint64_t,
+        self.default_type_names = [:int,:int8,:int16,:int32,:int64,:uint,:uint8,:uint16,:uint32,:uint64,
+                                   :int8_t,:int16_t,:int32_t,:int64_t,:uint8_t,:uint16_t,:uint32_t,:uint64_t,
                                    :bool,:double,:float,:void,:char,:size_t,:long,
                                    :uchar, :char16, :char32, :ushort, :ulong, :ulong_long,
                                    :uint128, :short, :long_long, :int128, :long_double,
@@ -132,13 +132,28 @@ module Rbind
             end
         end
 
+        def enum_hash
+            @enum_hash ||= Hash.new     # cache values so that they can be modified
+            @types.each_value do |t|
+                next unless t.is_a? REnum
+                t.values.each do |key,value|
+                    next if @enum_hash.has_key?(key)
+                    p = RParameter.new(key,type("const int"),value)
+                    p.owner = self
+                    @enum_hash[key] = p
+                end
+            end
+            @enum_hash
+        end
+
         def consts
-            @consts.values
+            @consts.values+enum_hash.values
         end
 
         def const(name,raise_ = true,search_owner = true)
-            c = if @consts.has_key?(name)
-                    @consts[name]
+            hash = @consts.merge(enum_hash)
+            c = if hash.has_key?(name)
+                    hash[name]
                 else
                     if !!(ns = RBase.namespace(name))
                         t = type(ns,false)
@@ -260,12 +275,12 @@ module Rbind
             op.alias = if !other
                            op.alias
                        elsif op.alias
-                           name = "#{op.alias}#{@operations[op.name].size+1}"
+                           name = "#{op.alias}__#{@operations[op.name].size+1}"
                            ::Rbind.log.debug "add_operation: name clash: aliasing #{op.alias} --> #{name}"
                            name
                        else
                            op.auto_alias = true
-                           name = "#{op.name}#{@operations[op.name].size+1}"
+                           name = "#{op.name}__#{@operations[op.name].size+1}"
                            ::Rbind.log.debug "add_operation: name clash: #{op.name} --> #{name}"
                            name
                        end
@@ -292,6 +307,11 @@ module Rbind
             current_type
         end
 
+        def add_const_val(name,value)
+            c = RParameter.new(name,type("const int"),value)
+            add_const(c)
+        end
+
         def add_const(const)
             const.const!
             if(c = const(const.full_name,false,false))
@@ -415,10 +435,23 @@ module Rbind
             # under the given name
             t ||=  if search_owner && name =~ /([:\w]*)<(.*)>$/
                       t = type($1,false) if $1 && !$1.empty?
-                      t2 = type($2,false) if $2 && !$2.empty?
+		      t2 = if $2 && !$2.empty?
+			       t2 = $2.split(',')
+			       bok = true
+			       t2 = t2.map do |t3|
+				   t3 = type(t3,false)
+				   bok = false unless t3 
+				   t3
+			       end
+			       if bok
+				   t2
+			       else
+				   nil
+			       end
+			   end
                       # template is known to this library
                       if t && t2 
-                          name = "#{t.name}<#{t2.full_name}>"
+			  name = "#{t.name}<#{t2.map{|t|t.full_name}.join(",")}>"
                           t3 ||= t.owner.type(name,false,false)
                           t3 ||= begin
                                      if !t.template?
@@ -439,7 +472,8 @@ module Rbind
                       # generic template is unknown
                       # check if specialised template is known
                       elsif t2 && $1 && !$1.empty? 
-                          real_name = "#{$1}<#{t2.full_name}>".gsub(">>","> >")
+			  real_name = t2.map{|v|v.full_name}.join(",");
+                          real_name = "#{$1}<#{real_name}>".gsub(">>","> >")
                           type(real_name,false) if(real_name != name) # prevent stack level too deep
                       else
                           nil

data/lib/rbind/core/roperation.rb

@@ -10,6 +10,7 @@ module Rbind
         attr_accessor :ambiguous_name
         attr_accessor :index            # index if overloaded
         attr_accessor :static
+        attr_accessor :blocking
         attr_accessor :cplusplus_alias
 
         def initialize(name,return_type=nil,*args)
@@ -17,6 +18,7 @@ module Rbind
             @return_type = return_type
             @parameters = args.flatten
             @cplusplus_alias = true
+            @blocking = false
         end
 
         # indicates if an alias method shall be added
@@ -25,6 +27,10 @@ module Rbind
             !!@cplusplus_alias
         end
 
+        def blocking?
+            !!@blocking
+        end
+
         def add_parameter(para,&block)
             para = if para.is_a? String
                 raise "No owner. Cannot create parameter" unless owner

data/lib/rbind/core/rparameter.rb

@@ -2,6 +2,7 @@
 module Rbind
     class RParameter < RAttribute
         attr_accessor :default_value
+        attr_accessor :parse_ownership
 
         def initialize(name,type,default_value=nil)
             super(name,type)
@@ -26,6 +27,10 @@ module Rbind
             end
         end
 
+	def parse_ownership?
+	    @parse_ownership != nil
+	end
+
         def to_single_ptr
             t = self.clone
             t.type = type.to_single_ptr

data/lib/rbind/core/rtype_annotation.rb

@@ -93,7 +93,7 @@ module Rbind
         end
 
         def to_ref
-            to_annotation? :ref,true
+            to_annotation :ref,true
         end
 
         def ref?

data/lib/rbind/default_parser.rb

@@ -50,6 +50,7 @@ module Rbind
                 return type_name
             end
 
+            type_name = type_name.gsub("cv::vector","vector") # fix namespace
             if(type_name =~/^vector/ || type_name =~/^Ptr/)
                if(type_name =~ /^([a-zA-Z\d]*)_([_a-zA-Z\d]*) ?(\(?.*)\)? */)
                   "#{$1}<#{unmask_template($2)}>#{$3}"
@@ -89,7 +90,8 @@ module Rbind
             array = flags.shift.split(" ")
             type_name = array.shift
             para_name = array.shift
-            default = unmask_template(array.join(" "))
+            default = unmask_template(array.join(" ").gsub("/C",""))
+            default.gsub!("/Ref","")
             type = find_type(owner,type_name)
             flags = normalize_flags(line_number,flags,:IO,:O)
             type = if flags.include?(:O) || flags.include?(:IO)
@@ -131,14 +133,35 @@ module Rbind
         def parse_class(line_number,string)
             lines = string.split("\n")
             a = lines.shift.rstrip
-            unless a =~ /class ([<>a-zA-Z\.\d_:]*) ?:?([<>a-zA-Z\.\:, \d_]*)(.*)/
+            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|
+                                 classes = parent_classes.gsub(" ","").split(",")
+				 # join templates
+				 classes.each_with_index do |val,i|
+				     next unless val
+				     if val.include?("<")
+					 val = [val]
+					 (i+1).upto(classes.size-1) do |i2|
+					     val2 = classes[i2]
+					     val << val2
+					     classes[i2] = nil
+					     if val2.include?(">")
+						 break
+					     end
+					 end
+					 classes[i] = val.join(",")
+                                     elsif val =="cv::class" # bug in parser
+                                         puts "ignore: parent class #{val} which is invalid for #{$1}"
+					 classes[i] = nil
+				     end
+				 end
+				classes.compact!
+				classes.map do |name|
                                      #TODO this should also call the user callback
                                      t = type(RBase.normalize(name),false)
                                      # remove namespace and try again
@@ -155,6 +178,11 @@ module Rbind
                                            end
                                      # auto add parent class
                                      t ||= begin
+					       # TODO fix error in parser
+					       # the parser always adds the current namespace
+					       # class Blas : public ::cv::Test
+					       # --> cv::::cv::Test
+					       name = name.gsub(/^.*::::/,"")	
                                                t = add_type(RClass.new(RBase.normalize(name)))
                                                t.extern_package_name = @extern_package_name
                                                t
@@ -234,7 +262,50 @@ module Rbind
             [c,1]
         end
 
+        def parse_enum(line_number,string)
+            lines = string.split("\n")
+            a = lines.shift.rstrip.gsub("enum struct ","enum ")
+            a = a.gsub("enum class ","enum ")
+            unless a =~ /enum ([<>a-zA-Z\.\d_:]*)/
+                raise "cannot parse enum#{a}"
+            end
+            name = $1.gsub("<unnamed>","Unknown")
+            renum = REnum.new(name)
+            renum = begin
+                add_type(renum)
+            rescue => e
+                t = type(name)
+                if !t.is_a? REnum || (renum.name != "Unknown" && !renum.values.empty?)
+                    raise "cannot overwrite #{t.class}: #{t} with #{renum.class}: #{renum}. Use forward declaration?"
+                end
+                t
+            end
+
+            line_counter = 1
+            lines.each do |line|
+                line_counter += 1
+                line =~ /const ([<>a-zA-Z\.\d_:]*) (.*) \[\]/
+                val = $2.strip
+                name = $1.strip
+                name = name.gsub("#{renum.full_name.gsub("::",".")}.","")       # bug in hdl_parser giving full name for some of the types
+                name = name.gsub("#{renum.namespace.gsub("::",".")}.","")
+                Set.new(val.split(/[ ><\+\-\*\/\&\|\)\(\~]/)).each do |v|
+                    c = const(v,false)
+                    if c
+                        val.gsub!(v,c.full_name)
+                    elsif renum.values.include? v
+                        val.gsub!(v,renum.values[v])
+                    end
+                end
+                renum.add_value(name,val)
+            end
+            [renum,line_counter]
+        rescue RuntimeError  => e
+            raise "input line #{line_number}: #{e}"
+        end
+
         def parse_operation(line_number,string)
+            string = string.gsub(";"," ")        # strip wrong characters from the parser
             a = string.split("\n")
             line = a.shift
             flags = line.split(" /")
@@ -262,11 +333,17 @@ module Rbind
             flags = normalize_flags(line_number,flags,:S,:O)
             return_type = if return_type_name && !return_type_name.empty?
                               t = find_type(owner,return_type_name)
-                              if !t.ptr? && flags.include?(:O)
-                                  t.to_ref
-                              else
-                                  t
-                              end
+			      if flags.include?(:O)
+				  if t.ptr?
+				     t
+				  else
+				      t.to_ref  # the opencv parser encodes references as flags
+				  end
+			      elsif t.basic_type? && t.name != "c_string"
+				  t
+			      else
+				  t.to_const
+			      end
                           end
             line_counter = 1
             args = a.map do |line|
@@ -303,6 +380,8 @@ module Rbind
                                 parse_class(line_number,block)
                             elsif first == "struct"
                                 parse_struct(line_number,block)
+                            elsif first == "enum"
+                                parse_enum(line_number,block)
                             else
                                 parse_operation(line_number,block)
                             end

data/lib/rbind/generator_c.rb

@@ -187,7 +187,7 @@ module Rbind
                def wrap_parameters
                    cparameters.map do |arg|
                        next if arg.type.basic_type?
-                       "#{arg.type.to_single_ptr.signature} #{arg.name}_ = fromC(#{arg.name});\n\t"
+		       "#{arg.type.to_single_ptr.signature} #{arg.name}_ = fromC(#{arg.name},#{arg.parse_ownership?});\n\t"
                    end.compact.join("")
                end
 
@@ -208,15 +208,24 @@ module Rbind
                                  end
                              end
                          elsif __getobj__.is_a?(RCastOperation)
-                             param = if paras.empty?
-                                        "rbind_obj_"
-                                     else
-                                        paras
-                                     end
-                             str = "#{return_type} *__rbind_temp_ = dynamic_cast<#{return_type}*>(#{param});\n"
-                             str += "\tif(!__rbind_temp_)\n"
-                             str += "\t\t throw std::runtime_error(\"Typecast failed, incompatible types\");\n"
-                             str + "\treturn toC(__rbind_temp_,false);"
+			     param1,param2,param3 = if parameters.size == 1
+						 ["rbind_obj_",paras,"rbind_obj"]
+					     else
+						 a = paras.split(",")
+						 a << parameters.first.name
+						 a
+					     end
+			     str = "#{return_type} *__rbind_temp_ = dynamic_cast<#{return_type}*>(#{param1});\n"
+			     str += "\tif(!__rbind_temp_)\n"
+			     str += "\t\t throw std::runtime_error(\"Typecast failed, incompatible types\");\n"
+			     str += "\tif(#{param2})\n"
+			     str += "\t{\n"
+			     str += "\t\tif(!#{param3}->bowner)\n"
+			     str += "\t\t    throw std::runtime_error(\"Cannot pass ownership. Object is owned by someone else. \");\n"
+			     str += "\t\telse\n"
+			     str += "\t\t    #{param3}->bowner = false;\n"
+			     str += "\t}\n"
+			     str + "\treturn toC(__rbind_temp_,#{param2});"
                          else
                              fct = if !constructor? && (return_type.name != "void" || return_type.ptr?)
                                        # operator+, operator++ etc