rbind 0.0.22 → 0.0.23

data/lib/rbind/core/rnamespace.rb

@@ -10,6 +10,7 @@ module Rbind
         class << self
             attr_accessor :default_type_names
             attr_accessor :default_type_alias
+            attr_accessor :default_operator_alias
         end
         # TODO move somewhere else
         self.default_type_names = [:int,:int8,:int32,:int64,:uint,:uint8,:uint32,:uint64,
@@ -22,6 +23,30 @@ module Rbind
                                    :u_long_long => :ulong_long,:u_int => :uint, :uint128 => :uint128,
                                    :char_s => :char}
 
+        self.default_operator_alias = {
+                "()" => "fct",
+                "!=" => "unequal",
+                "==" => "equal",
+                "&=" => "and_set",
+                "+=" => "add",
+                "-=" => "sub",
+                "++"  => "plusplus",
+                "--"  => "minusminus",
+                "[]" => "array",
+                "<=" => "less_or_equal",
+                "<"  => "less",
+                ">=" => "greater_or_equal",
+                "+"  => "plus",
+                "-"  => "minus",
+                "*"  => "mult",
+                "/"  => "div",
+                "!"  => "not",
+                "&"  => "and",
+                ">"  => "greater",
+                "="  => "assign"
+            }
+
+
         attr_reader :operations
         attr_reader :operation_alias
         attr_reader :consts
@@ -222,12 +247,12 @@ module Rbind
                            op.alias
                        elsif op.alias
                            name = "#{op.alias}#{@operations[op.name].size+1}"
-                           ::Rbind.log.debug "name clash: aliasing #{op.alias} --> #{name}"
+                           ::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}"
-                           ::Rbind.log.debug "name clash: #{op.name} --> #{name}"
+                           ::Rbind.log.debug "add_operation: name clash: #{op.name} --> #{name}"
                            name
                        end
             op.index = @operations[op.name].size
@@ -308,11 +333,7 @@ module Rbind
             else
                 type.owner = self
                 if type.alias
-                    if check_exist && type(type.alias,false,false)
-                        raise ArgumentError,"A type with the name alias #{type.alias} already exists"
-                    end
-                    raise ArgumentError,"A type alias with the name #{t.alias} already exists" if(t = @type_alias[type.alias])
-                    @type_alias[type.alias] = type.to_raw
+                    add_type_alias(type, type.alias, check_exist)
                 end
                 raise ArgumentError,"A type with the name #{t.full_name} already exists" if(t = @types[type.name])
                 @types[type.name] = type.to_raw
@@ -377,7 +398,8 @@ module Rbind
             t ||=  if search_owner && name =~ /([:\w]*)<(.*)>$/
                       t = type($1,false) if $1 && !$1.empty?
                       t2 = type($2,false) if $2 && !$2.empty?
-                      if t && t2
+                      # template is known to this library
+                      if t && t2 
                           name = "#{t.name}<#{t2.full_name}>"
                           t3 ||= t.owner.type(name,false,false)
                           t3 ||= begin
@@ -396,9 +418,15 @@ module Rbind
                                          end
                                      end
                                  end
+                      # generic template is unknown
+                      # check if specialised template is known
+                      elsif t2 && $1 && !$1.empty? 
+                          real_name = "#{$1}<#{t2.full_name}>".gsub(">>","> >")
+                          type(real_name,false) if(real_name != name) # prevent stack level too deep
+                      else
+                          nil
                       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)
@@ -484,6 +512,28 @@ module Rbind
             end
         end
 
+        # Adding a type alias in the main namespace, e.g.
+        # to register existing typedefs
+        #
+        # raises if the alias is already register under a given typename
+        def add_type_alias(known_type, alias_name, check_exist = true)
+            if check_exist && type_alias.has_key?(alias_name)
+                existing_type = type(alias_name, false, false)
+                if known_type.name == existing_type.name
+                    ::Rbind.log.warn "Alias: '#{alias_name} for type '#{known_type.name}' already registered'"
+                else
+                    raise ArgumentError, "Cannot register alias: #{alias_name} for type '#{known_type.name}'. Alias already registered with type: '#{existing_type.name}'"
+                end
+            else
+                ::Rbind.log.debug "Alias: '#{alias_name} for type '#{known_type.name}' registered"
+                @type_alias[alias_name] = known_type.to_raw
+            end
+        end
+
+        def self.default_operators
+            default_operator_alias.keys
+        end
+
         def method_missing(m,*args)
             if m != :to_ary && args.empty?
                 t = type(m.to_s,false,false)

data/lib/rbind/core/roperation.rb

@@ -1,6 +1,8 @@
 
 module Rbind
     class ROperation < RBase
+        extend ::Rbind::Logger
+
         attr_accessor :return_type
         attr_accessor :parameters
         attr_accessor :cparameters
@@ -89,6 +91,7 @@ module Rbind
         end
 
         def generate_signatures
+            ROperation.log.debug "ROperation: generate signature for #{return_type}: #{return_type.signature}" unless constructor?
             s = "#{return_type.signature} " unless constructor?
             s = "#{s}#{full_name}(#{parameters.map(&:signature).join(", ")})"
 

data/lib/rbind/core/rtemplate_class.rb

@@ -22,8 +22,14 @@ module Rbind
     end
 
     class RTemplateClass < RClass
+        extend ::Rbind::Logger
+
+        # template parameters in the right order
+        attr_reader :template_parameters
+
         def initialize(name,*parent_classes)
             raise "parent classes for template classes are not supported!" if !parent_classes.empty?
+            @template_parameters =[]
             super
         end
 
@@ -39,11 +45,67 @@ module Rbind
 
         # hook for implementing the specialization
         def specialize(klass,*parameters)
+            RTemplateClass.log.info "RTemplateClass: #{name} default specialized with #{klass} -- specialization parameters: #{parameters}, template parameters: #{template_parameters}"
+            # by default create a dummy implementation without additional arguments
+            if parameters.size != @template_parameters.size
+                raise ArgumentError, "RTemplateClass: template #{name} expects #{@template_parameters.size} parameters"
+            end
+
+            operations.each do |ops|
+                ops.each do |o|
+                    begin
+                        RTemplateClass.log.debug "RTemplateClass: #{name} handle operation: #{o.name}"
+                        op = o.dup
+
+                        if op.kind_of?(RGetter) or op.kind_of?(RSetter)
+                            attr = RAttribute.new(op.attribute.name, resolve_type(parameters, op.attribute.type))
+                            op = op.class.new(attr)
+                            klass.add_operation(op)
+                            next
+                        else
+                            op.return_type = resolve_type(parameters, op.return_type.name)
+                        end
+
+                        op.parameters.each do |p|
+                            rtype = resolve_type(parameters, p.type.name)
+                            RTemplateClass.log.debug "RTemplateClass: #{name} specialized with #{klass} -- resolved #{p.type.name} -> #{rtype}"
+                            p.type = rtype
+                        end
+
+                        klass.add_operation(op)
+                    rescue Exception => e
+                        RTemplateClass.log.warn "RTemplateClass: #{name} could not add parameter #{e} #{e.backtrace}"
+
+                    end
+                end
+            end
+            klass
+        end
+
+        def resolve_type(parameters, param_name)
+            # This resolves
+            resolved_type = type(param_name, false)
+            if not resolved_type
+                raise ArgumentError, "RTemplateClass: template #{name} could not resolve template parameter #{param_name}"
+            end
+
+            if index = @template_parameters.index(resolved_type)
+                resolved_type = type(parameters[index])
+            end
+
+            resolved_type
         end
 
         # hook for generating additional ruby code going to be embedded into the
         # class definition
         def specialize_ruby_specialization(klass)
         end
+
+        def add_type(klass)
+            if klass.kind_of?(RTemplateParameter)
+                @template_parameters << klass
+            end
+            super
+        end
     end
 end

data/lib/rbind/core/rtype_qualifier.rb

@@ -56,5 +56,14 @@ module Rbind
                 str + s
             end
         end
+
+        # Resolve the current delegate to the underlying object
+        def get_base_delegate
+            obj = __getobj__
+            while obj.respond_to?(:__getobj__)
+                obj = obj.__getobj__
+            end
+            obj
+        end
     end
 end

data/lib/rbind/default_parser.rb

@@ -92,7 +92,13 @@ module Rbind
             default = unmask_template(array.join(" "))
             type = find_type(owner,type_name)
             flags = normalize_flags(line_number,flags,:IO,:O)
-            type = if flags.include?(:O) || flags.include?(:IO) || type.basic_type?
+            type = if flags.include?(:O) || flags.include?(:IO)
+                       if type.ptr?
+                           type
+                       else
+                           type.to_ref  # the opencv parser encodes references as flags
+                       end
+                   elsif type.basic_type?
                        type
                    else
                        type.to_const
@@ -232,13 +238,20 @@ module Rbind
                          end
 
             ns = RBase.namespace(name)
-            owner = type(ns,true)
+            owner = type(ns,false)
+            owner ||= add_namespace_name(ns)
             if return_type_name == "explicit"
                 flags << return_type_name
                 return_type_name = nil
             end
+            flags = normalize_flags(line_number,flags,:S,:O)
             return_type = if return_type_name && !return_type_name.empty?
-                              find_type(owner,return_type_name)
+                              t = find_type(owner,return_type_name)
+                              if !t.ptr? && flags.include?(:O)
+                                  t.to_ref
+                              else
+                                  t
+                              end
                           end
             line_counter = 1
             args = a.map do |line|
@@ -248,7 +261,6 @@ module Rbind
             end
             op = ::Rbind::ROperation.new(name,return_type,*args)
             op.alias = alias_name if alias_name && !alias_name.empty?
-            flags = normalize_flags(line_number,flags,:S)
             op = if flags.include?(:S)
                      op.to_static
                  else

data/lib/rbind/generator_c.rb

@@ -194,6 +194,10 @@ module Rbind
                                        if operator? && parameters.size == 1
                                            if return_type.basic_type?
                                                "return *rbind_obj_ #{operator} #{paras};"
+                                           elsif return_type.ref?
+                                               # the returned value is not the owner of the
+                                               # object
+                                               "return toC(&(*rbind_obj_ #{operator} #{paras}),false);"
                                            else
                                                "return toC(new #{return_type.full_name}(*rbind_obj_ #{operator} #{paras}));"
                                            end
@@ -201,6 +205,10 @@ module Rbind
                                            "return #{full_name}(#{paras});"
                                        elsif return_type.ptr?
                                            "return toC(#{full_name}(#{paras}));"
+                                       elsif return_type.ref?
+                                           # the returned value is not the owner of the
+                                           # object
+                                           "return toC(&#{full_name}(#{paras}),false);"
                                        else
                                            "return toC(new #{return_type.full_name}(#{full_name}(#{paras})));"
                                        end

data/lib/rbind/generator_ruby.rb

@@ -117,7 +117,7 @@ module Rbind
 
 
         def self.normalize_type_name(name)
-            name = name.gsub(" ","")
+            name.gsub!(" ","")
 
             # map template classes
             # std::vector<std::string> -> Std::Vector::Std_String
@@ -133,6 +133,12 @@ module Rbind
                 return n if n
             end
 
+            # Parse constant declaration with suffix like 1000000LL
+            if name =~ /^([0-9]+)[uUlL]{0,2}/
+                name = $1
+                return name
+            end
+
             # map all uint ... to Fixnum
             if name =~ /^u?int\d*$/ || name =~ /^u?int\d+_t$/
                 return "Fixnum"
@@ -168,28 +174,31 @@ module Rbind
 
         def self.normalize_alias_method_name(orig_name)
             name = orig_name
+
             #replace operatorX with the correct ruby operator when 
             #there are overloaded operators
             name = if name =~/^operator(.*)/
                         n = $1
                         if n =~ /\(\)/
                             raise "forbbiden method name #{name}"
-                        elsif n=~ /(.*)(\d)/
-                            if $1 == "[]"
-                                "array_operator#{$2}"
-                            elsif $1 == "+"
-                                "plus_operator#{$2}"
-                            elsif $1 == "-"
-                                "minus_operator#{$2}"
-                            elsif $1 == "*"
-                                "mul_operator#{$2}"
-                            elsif $1 == "/"
-                                "div_operator#{$2}"
-                            else
-                                raise "forbbiden method name #{name}"
+                        elsif n =~ /(.*)(\d)/ # check for overloaded operators and use alias name for them
+                            alias_name = RNamespace.default_operator_alias[$1]
+                            if not alias_name
+                                raise ArgumentError, "Normalization failed. Operator: #{$1} unknown"
                             end
+                            "#{alias_name}_operator#{$2}"
                         else
-                            n
+                            # this operators does not exist
+                            if n == "++" || n == "--"
+                                alias_name = RNamespace.default_operator_alias[n]
+                                if not alias_name
+                                    raise ArgumentError, "Normalization failed. Operator: #{$1} unknown"
+                                end
+                                "#{alias_name}_operator"
+                            else
+                                # we can use the c++ name
+                                n
+                            end
                         end
                    else
                       name
@@ -214,11 +223,21 @@ module Rbind
             #remove all remaining #
             name = name.gsub(/#/, '')
             name = normalize_alias_method_name(name)
-            raise "generated empty name for #{orig_name}" if name.empty?
+            raise RuntimeError, "Normalization failed: generated empty name for #{orig_name}" if name.empty?
+            name
+        end
+
+        def self.normalize_enum_name(name)
+            name = GeneratorRuby.normalize_basic_type_name_ffi name
+            #to lower and substitute namespace :: with _
+            name = name.gsub("::","_")
+            name = name.downcase
             name
         end
 
         class HelperBase
+            extend ::Rbind::Logger
+
             attr_accessor :name
             def initialize(name,root)
                 @name = name.to_s
@@ -259,6 +278,10 @@ module Rbind
                 GeneratorRuby.normalize_basic_type_name_ffi name
             end
 
+            def normalize_enum(name)
+                GeneratorRuby.normalize_enum_name(name)
+            end
+
             def normalize_m(name)
                 GeneratorRuby.normalize_method_name name
             end
@@ -292,32 +315,59 @@ module Rbind
                         return_type = if op.constructor?
                                           "#{normalize_t op.owner.full_name}"
                                       else
-                                          if op.return_type.basic_type?
-                                              if op.return_type.ptr?
+                                          op_return_type = op.return_type
+                                          if op_return_type.respond_to?(:get_base_delegate)
+                                              if klass = op_return_type.get_base_delegate
+                                                  op_return_type = klass if klass.kind_of?(REnum)
+                                              end
+                                          end
+
+                                          if op_return_type.basic_type?
+                                              if op_return_type.ptr?
                                                   ":pointer"
+                                              elsif op_return_type.kind_of?(REnum)
+                                                  ":#{normalize_enum op_return_type.to_raw.csignature}"
                                               else
-                                                  ":#{normalize_bt op.return_type.to_raw.csignature}"
+                                                  ":#{normalize_bt op_return_type.to_raw.csignature}"
                                               end
                                           else
-                                              if op.return_type.extern_package_name
-                                                  normalize_t("::#{op.return_type.extern_package_name}::#{op.return_type.to_raw.full_name}")
+                                              if op_return_type.extern_package_name
+                                                  normalize_t("::#{op_return_type.extern_package_name}::#{op_return_type.to_raw.full_name}")
+                                              elsif op_return_type.kind_of?(REnum)
+                                                  ":#{normalize_enum op_return_type.to_raw.full_name}"
                                               else
-                                                  normalize_t op.return_type.to_raw.full_name
+                                                  normalize_t op_return_type.to_raw.full_name
                                               end
                                           end
                                       end
                         args = op.cparameters.map do |p|
-                            if p.type.basic_type?
-                                if p.type.ptr?
+                            p_type = p.type
+                            if p_type.respond_to?(:get_base_delegate)
+                                if klass = p_type.get_base_delegate
+                                    p_type = klass if klass.kind_of?(REnum)
+                                end
+                            end
+                            if p_type.basic_type?
+                                if p_type.ptr? || p.type.ref?
                                     ":pointer"
+                                elsif p.type.kind_of?(REnum)
+                                    # Includes enums, which need to be defined accordingly
+                                    # using ffi:
+                                    # enum :normalized_name, [:first, 1,
+                                    #                         :second,
+                                    #                         :third]
+                                    #
+                                    ":#{normalize_enum p.type.to_raw.csignature}"
                                 else
                                     ":#{normalize_bt p.type.to_raw.csignature}"
                                 end
                             else
-                                if p.type.extern_package_name
-                                    normalize_t("::#{p.type.extern_package_name}::#{p.type.to_raw.full_name}")
+                                if p_type.extern_package_name
+                                    normalize_t("::#{p_type.extern_package_name}::#{p_type.to_raw.full_name}")
+                                elsif p_type.kind_of?(REnum)
+                                    ":#{normalize_enum p_type.to_raw.full_name}"
                                 else
-                                    normalize_t p.type.to_raw.full_name
+                                    normalize_t p_type.to_raw.full_name
                                 end
                             end
                         end
@@ -330,6 +380,25 @@ module Rbind
                 str+"\n"
                 str.gsub(/\n/,"\n        ")
             end
+
+            def add_enums
+                str = "\n"
+                @root.root.each_type do |t|
+                    if t.kind_of?(REnum)
+                        str += "\tenum :#{GeneratorRuby::normalize_enum_name(t.to_raw.csignature)}, ["
+                        t.values.each do |name,value|
+                            if value
+                                str += ":#{name},#{value}, "
+                            else
+                                str += ":#{name}, "
+                            end
+                        end
+                        str += "]\n\n"
+                    end
+                end
+                str
+            end
+
         end
 
         class RTypeTemplateHelper < HelperBase
@@ -451,7 +520,11 @@ module Rbind
                 def generate_param_doc
                     paras = parameters.map do |p|
                         n = GeneratorRuby.normalize_arg_name p.name
-                        t = GeneratorRuby.normalize_type_name(p.type.full_name)
+                        t = if p.type.basic_type? && (p.type.ptr? || p.type.ref?)
+                                "FFI::MemoryPointer"
+                            else
+                                GeneratorRuby.normalize_type_name(p.type.full_name)
+                            end
                         "# @param [#{t}] #{n} #{p.doc}"
                     end
                     if return_type
@@ -583,7 +656,12 @@ module Rbind
             def add_consts(root=@root)
                 str = @root.consts.map do |c|
                     next if c.extern? || c.ignore?
+                    if not c.default_value
+                        HelperBase.log.warn "#{c.name}: no default value"
+                        next
+                    else
                     "    #{c.name} = #{GeneratorRuby::normalize_type_name(c.default_value)}\n"
+                    end
                 end.join
                 return str unless @compact_namespace
 
@@ -610,31 +688,39 @@ module Rbind
                     h[k] = Array.new
                 end
                 root.each_operation do |o|
-                    next if o.constructor? || o.ignore?
-                    op = OperationHelper.new(o)
-                    if op.instance_method?
-                        ops["rbind_instance_#{op.name}"] << op
-                    else
-                        ops["rbind_static_#{op.name}"] << op
+                    begin
+                        next if o.constructor? || o.ignore?
+                        op = OperationHelper.new(o)
+                        if op.instance_method?
+                            ops["rbind_instance_#{op.name}"] << op
+                        else
+                            ops["rbind_static_#{op.name}"] << op
+                        end
+                    rescue Exception => e
+                        HelperBase.log.warn "Operation '#{o}' not added. #{e}"
                     end
                 end
                 # render method
                 str = ""
                 ops.each_value do |o|
-                    if o.size == 1
-                        op = o.first
-                        str += if op.instance_method?
-                                   @method_wrapper.result(op.binding)
-                               else
-                                   @static_method_wrapper.result(op.binding)
-                               end
-                    else
-                        helper = OverloadedOperationHelper.new(o)
-                        str += if o.first.instance_method?
-                                   @overloaded_method_wrapper.result(helper.binding)
-                               else
-                                   @overloaded_static_method_wrapper.result(helper.binding)
-                               end
+                    begin
+                        if o.size == 1
+                            op = o.first
+                            str += if op.instance_method?
+                                       @method_wrapper.result(op.binding)
+                                   else
+                                       @static_method_wrapper.result(op.binding)
+                                   end
+                        else
+                            helper = OverloadedOperationHelper.new(o)
+                            str += if o.first.instance_method?
+                                       @overloaded_method_wrapper.result(helper.binding)
+                                   else
+                                       @overloaded_static_method_wrapper.result(helper.binding)
+                                   end
+                        end
+                    rescue Exception => e
+                        HelperBase.log.warn "Operation '#{o}' could not be rendered. #{e}"
                     end
                 end
                 return str unless @compact_namespace