rbind 0.0.32 → 0.0.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09c41b56b4789ecc979d67b35ba15190c619000ed14273c3c3f2470e9fbe6a19'
-  data.tar.gz: 9346a8964a020a5f518c2a7df144c973d03bae03055d83aad537a67a3dcae250
+  metadata.gz: '0892dada4084e4b38bcb49d3dca8106a038e5a2c82a4a87d420532327ac942e7'
+  data.tar.gz: 482377fb03e5b125550de5596365a01be1762e5bcc5596dec3b37dec5f27a0aa
 SHA512:
-  metadata.gz: 772d21a2abaa065e5a7ce4c0ba6751d11393144f34820b203bf16a682c42d199db3e478ab9df2dc60306c2b174af681ad5f5949e479c83a54dfb941830c254b9
-  data.tar.gz: f29591791fbf86c4cbd0bb609de4b9b2bd52c1cd4c9e4f2c337ed1072c9eea932ad08bd8e16bdbf08fe50adb8d32fb5a09cb1f5e6d0f8f3bbbfc3d32eaa06624
+  metadata.gz: 19adf245b190083bac225917b50ac8169deef19137364196a3623f7e3d547fb5a9c773ff59193589a204ff2666184c1805e4d359abd76a05aa504bf0165667a7
+  data.tar.gz: a0e111070064d5a1baca4bfb7799dc98dd6ed034d3a207a04e5005db254beb7016f50038b3dae51748fe9834fcb1edbb2344969a8a88242502fbd951c684dabf

data/lib/rbind/core/rbase.rb

@@ -208,5 +208,27 @@ module Rbind
                 @specialize_ruby.call
             end
         end
+
+        # overwrite c 
+	# depends on type
+	# at the moment only operations can be overwritten
+        def overwrite_c(&block)
+            if block
+                @overwrite_c = block
+            elsif @overwrite_c
+                @overwrite_c.call
+            end
+        end
+
+        # overwrite ruby
+	# depends on type
+	# at the moment only rbind_from_native can be overwritten
+        def overwrite_ruby(&block)
+            if block
+                @overwrite_ruby = block
+            elsif @overwrite_ruby
+                @overwrite_ruby.call
+            end
+        end
     end
 end

data/lib/rbind/core/rclass.rb

@@ -108,8 +108,8 @@ module Rbind
 			    o == other_op
 			end
 			next false if !op
-			next true if o.base_class == self
-			next true if o.base_class == other_op.base_class
+			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

data/lib/rbind/default_parser.rb

@@ -133,7 +133,7 @@ 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
@@ -367,7 +367,8 @@ module Rbind
             @extern_package_name = extern_package_name
 
             a = split(string)
-            #remove number at the end of the file
+            #remove namespances and number at the end of the file
+            a.pop if (a.last =~/namespaces:/) == 0
             a.pop if a.last.to_i != 0
 
             line_number = 1

data/lib/rbind/generator_c.rb

@@ -192,6 +192,8 @@ module Rbind
                end
 
                def wrap_call
+		   str = overwrite_c()
+		   return str if str
                    paras = parameters.map do |arg|
                        "#{"*" if (!arg.type.ptr? && !arg.type.basic_type?)}#{arg.name}#{"_" if !arg.type.basic_type?}"
                    end.join(", ")

data/lib/rbind/generator_ruby.rb

@@ -657,6 +657,13 @@ module Rbind
                 GeneratorRuby.normalize_method_name(@root.cdelete_method)
             end
 
+	    def rbind_from_native
+		overwrite = @root.overwrite_ruby
+		return overwrite if overwrite
+		"#{name}.new(ptr)"
+	    end
+
+
             def add_specializing(root = @root)
                 str = root.specialize_ruby.to_s
                 root.each_type(false) do |t|

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

@@ -5,10 +5,13 @@
     {
         <%= wrap_parameters %><%= wrap_call %>
     }
-    catch(std::exception &error){strncpy(&last_error_message[0],error.what(),255);}
-    catch(...){strncpy(&last_error_message[0],"Unknown Exception",255);}
+    catch(std::exception &error){strncpy(&last_error_message[0],error.what(),254);}
+    catch(...){strncpy(&last_error_message[0],"Unknown Exception",254);}
     <%- if !return_type || return_type.ptr? || !return_type.basic_type? -%>
     return NULL;
+    <%- elsif return_type.ref? -%>
+    static <%= return_type.cname %> invalid;
+    return invalid;
     <%- elsif return_type.name != "void"  -%>
     return (<%= return_type.cname %>) <%= return_type.invalid_value %>;
     <%- end -%>

data/lib/rbind/templates/c/type_delete.h

@@ -8,7 +8,7 @@ void <%= cdelete_method %>(<%= cname %> *ptr)
             delete fromC(ptr);
         ptr->obj_ptr = NULL;
     }
-    catch(std::exception &error){strncpy(&last_error_message[0],error.what(),255);}
-    catch(...){strncpy(&last_error_message[0],"Unknown Exception",255);}
+    catch(std::exception &error){strncpy(&last_error_message[0],error.what(),254);}
+    catch(...){strncpy(&last_error_message[0],"Unknown Exception",254);}
     delete ptr;
 }

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

@@ -55,7 +55,7 @@ class <%= name %>
 
     # @private
     def self.rbind_from_native(ptr,context)
-        <%= name %>.new(ptr)
+        <%= rbind_from_native %>
     end
 
     # @private

data/lib/rbind/tools/hdr_parser.py

@@ -52,13 +52,13 @@ class CppHeaderParser(object):
     def get_macro_arg(self, arg_str, npos):
         npos2 = npos3 = arg_str.find("(", npos)
         if npos2 < 0:
-            print("Error: no arguments for the macro at %d" % (self.lineno,))
+            print("Error: no arguments for the macro at %s:%d" % (self.hname, self.lineno))
             sys.exit(-1)
         balance = 1
         while 1:
             t, npos3 = self.find_next_token(arg_str, ['(', ')'], npos3+1)
             if npos3 < 0:
-                print("Error: no matching ')' in the macro call at %d" % (self.lineno,))
+                print("Error: no matching ')' in the macro call at %s:%d" % (self.hname, self.lineno))
                 sys.exit(-1)
             if t == '(':
                 balance += 1
@@ -110,6 +110,11 @@ class CppHeaderParser(object):
         if npos >= 0:
             modlist.append("/C")
 
+        npos = arg_str.find("&&")
+        if npos >= 0:
+            arg_str = arg_str.replace("&&", '')
+            modlist.append("/RRef")
+
         npos = arg_str.find("&")
         if npos >= 0:
             modlist.append("/Ref")
@@ -160,7 +165,7 @@ class CppHeaderParser(object):
                 angle_stack.append(0)
             elif w == "," or w == '>':
                 if not angle_stack:
-                    print("Error at %d: argument contains ',' or '>' not within template arguments" % (self.lineno,))
+                    print("Error at %s:%d: argument contains ',' or '>' not within template arguments" % (self.hname, self.lineno))
                     sys.exit(-1)
                 if w == ",":
                     arg_type += "_and_"
@@ -190,7 +195,7 @@ class CppHeaderParser(object):
             p1 = arg_name.find("[")
             p2 = arg_name.find("]",p1+1)
             if p2 < 0:
-                print("Error at %d: no closing ]" % (self.lineno,))
+                print("Error at %s:%d: no closing ]" % (self.hname, self.lineno))
                 sys.exit(-1)
             counter_str = arg_name[p1+1:p2].strip()
             if counter_str == "":
@@ -254,6 +259,8 @@ class CppHeaderParser(object):
             l = l.replace("CV_EXPORTS_W_SIMPLE", "")
             modlist.append("/Simple")
         npos = l.find("CV_EXPORTS_AS")
+        if npos < 0:
+            npos = l.find('CV_WRAP_AS')
         if npos >= 0:
             macro_arg, npos3 = self.get_macro_arg(l, npos)
             modlist.append("=" + macro_arg)
@@ -429,10 +436,18 @@ class CppHeaderParser(object):
         # filter off some common prefixes, which are meaningless for Python wrappers.
         # note that we do not strip "static" prefix, which does matter;
         # it means class methods, not instance methods
-        decl_str = self.batch_replace(decl_str, [("static inline", ""), ("inline", ""),\
-            ("CV_EXPORTS_W", ""), ("CV_EXPORTS", ""), ("CV_CDECL", ""), ("CV_WRAP ", " "), ("CV_INLINE", ""),
-            ("CV_DEPRECATED", ""), ("CV_DEPRECATED_EXTERNAL", "")]).strip()
-
+        decl_str = self.batch_replace(decl_str, [("static inline", ""),
+                                                 ("inline", ""),
+                                                 ("explicit ", ""),
+                                                 ("CV_EXPORTS_W", ""),
+                                                 ("CV_EXPORTS", ""),
+                                                 ("CV_CDECL", ""),
+                                                 ("CV_WRAP ", " "),
+                                                 ("CV_INLINE", ""),
+                                                 ("CV_DEPRECATED", ""),
+                                                 ("CV_DEPRECATED_EXTERNAL", ""),
+                                                 ("CV_NODISCARD_STD", ""),
+                                                 ("CV_NODISCARD", "")]).strip()
 
         if decl_str.strip().startswith('virtual'):
             virtual_method = True
@@ -570,8 +585,8 @@ class CppHeaderParser(object):
                     arg_type, arg_name, modlist, argno = self.parse_arg(a, argno)
                     if self.wrap_mode:
                         # TODO: Vectors should contain UMat, but this is not very easy to support and not very needed
-                        vector_mat = "vector_{}".format("Mat")
-                        vector_mat_template = "vector<{}>".format("Mat")
+                        vector_mat = "vector_{}".format(mat)
+                        vector_mat_template = "vector<{}>".format(mat)
 
                         if arg_type == "InputArray":
                             arg_type = mat
@@ -656,6 +671,10 @@ class CppHeaderParser(object):
         stack_top = self.block_stack[-1]
         context = stack_top[self.BLOCK_TYPE]
 
+        if stmt.startswith('inline namespace'):
+            # emulate anonymous namespace
+            return "namespace", "", True, None
+
         stmt_type = ""
         if end_token == "{":
             stmt_type = "block"
@@ -713,6 +732,8 @@ class CppHeaderParser(object):
                     return stmt_type, classname, True, decl
 
             if stmt.startswith("enum") or stmt.startswith("namespace"):
+                # NB: Drop inheritance syntax for enum
+                stmt = stmt.split(':')[0]
                 stmt_list = stmt.rsplit(" ", 1)
                 if len(stmt_list) < 2:
                     stmt_list.append("<unnamed>")
@@ -792,6 +813,7 @@ class CppHeaderParser(object):
         COMMENT = 1 # inside a multi-line comment
         DIRECTIVE = 2 # inside a multi-line preprocessor directive
         DOCSTRING = 3 # inside a multi-line docstring
+        DIRECTIVE_IF_0 = 4 # inside a '#if 0' directive
 
         state = SCAN
 
@@ -801,19 +823,56 @@ class CppHeaderParser(object):
         self.lineno = 0
         self.wrap_mode = wmode
 
+        depth_if_0 = 0
+
         for l0 in linelist:
             self.lineno += 1
             #print(state, self.lineno, l0)
 
             l = l0.strip()
 
+            # G-API specific aliases
+            l = self.batch_replace(l, [
+                    ("GAPI_EXPORTS", "CV_EXPORTS"),
+                    ("GAPI_EXPORTS_W", "CV_EXPORTS_W"),
+                    ("GAPI_EXPORTS_W_SIMPLE","CV_EXPORTS_W_SIMPLE"),
+                    ("GAPI_WRAP", "CV_WRAP"),
+                    ("GAPI_PROP", "CV_PROP"),
+                    ("GAPI_PROP_RW", "CV_PROP_RW"),
+                    ('defined(GAPI_STANDALONE)', '0'),
+                ])
+
             if state == SCAN and l.startswith("#"):
                 state = DIRECTIVE
                 # fall through to the if state == DIRECTIVE check
 
             if state == DIRECTIVE:
-                if not l.endswith("\\"):
-                    state = SCAN
+                if l.endswith("\\"):
+                    continue
+                state = SCAN
+                l = re.sub(r'//(.+)?', '', l).strip()  # drop // comment
+                if l in [
+                    '#if 0',
+                    '#if defined(__OPENCV_BUILD)', '#ifdef __OPENCV_BUILD',
+                    '#if !defined(OPENCV_BINDING_PARSER)', '#ifndef OPENCV_BINDING_PARSER',
+                ]:
+                    state = DIRECTIVE_IF_0
+                    depth_if_0 = 1
+                continue
+
+            if state == DIRECTIVE_IF_0:
+                if l.startswith('#'):
+                    l = l[1:].strip()
+                    if l.startswith("if"):
+                        depth_if_0 += 1
+                        continue
+                    if l.startswith("endif"):
+                        depth_if_0 -= 1
+                        if depth_if_0 == 0:
+                            state = SCAN
+                else:
+                    # print('---- {:30s}:{:5d}: {}'.format(hname[-30:], self.lineno, l))
+                    pass
                 continue
 
             if state == COMMENT:
@@ -826,7 +885,7 @@ class CppHeaderParser(object):
             if state == DOCSTRING:
                 pos = l.find("*/")
                 if pos < 0:
-                    docstring += l + "\n"
+                    docstring += l0
                     continue
                 docstring += l[:pos] + "\n"
                 l = l[pos+2:]
@@ -842,7 +901,12 @@ class CppHeaderParser(object):
                 sys.exit(-1)
 
             while 1:
-                token, pos = self.find_next_token(l, [";", "\"", "{", "}", "//", "/*"])
+                # NB: Avoid parsing '{' for case:
+                # foo(Obj&& = {});
+                if re.search(r'=\s*\{\s*\}', l):
+                    token, pos = ';', len(l)
+                else:
+                    token, pos = self.find_next_token(l, [";", "\"", "{", "}", "//", "/*"])
 
                 if not token:
                     block_head += " " + l
@@ -912,14 +976,17 @@ class CppHeaderParser(object):
                         else:
                             decls.append(decl)
 
-                            if self._generate_gpumat_decls and "cv.cuda." in decl[0]:
+                            if self._generate_gpumat_decls and ("cv.cuda" in decl[0] or decl[0] in [
+                                "cv.imshow", # https://github.com/opencv/opencv/issues/18553
+                            ]):
                                 # If function takes as one of arguments Mat or vector<Mat> - we want to create the
-                                # same declaration working with GpuMat (this is important for T-Api access)
+                                # same declaration working with GpuMat
                                 args = decl[3]
                                 has_mat = len(list(filter(lambda x: x[0] in {"Mat", "vector_Mat"}, args))) > 0
                                 if has_mat:
                                     _, _, _, gpumat_decl = self.parse_stmt(stmt, token, mat="cuda::GpuMat", docstring=docstring)
-                                    decls.append(gpumat_decl)
+                                    if gpumat_decl != decl:
+                                        decls.append(gpumat_decl)
 
                             if self._generate_umat_decls:
                                 # If function takes as one of arguments Mat or vector<Mat> - we want to create the
@@ -928,12 +995,13 @@ class CppHeaderParser(object):
                                 has_mat = len(list(filter(lambda x: x[0] in {"Mat", "vector_Mat"}, args))) > 0
                                 if has_mat:
                                     _, _, _, umat_decl = self.parse_stmt(stmt, token, mat="UMat", docstring=docstring)
-                                    decls.append(umat_decl)
+                                    if umat_decl != decl:
+                                        decls.append(umat_decl)
 
                         docstring = ""
                     if stmt_type == "namespace":
                         chunks = [block[1] for block in self.block_stack if block[0] == 'namespace'] + [name]
-                        self.namespaces.add('.'.join(chunks))
+                        self.namespaces.add('.'.join(filter(lambda c: len(c)> 0, chunks)))
                 else:
                     stmt_type, name, parse_flag = "block", "", False
 
@@ -972,13 +1040,12 @@ class CppHeaderParser(object):
                     print()
 
 if __name__ == '__main__':
-    parser = CppHeaderParser(generate_umat_decls=True, generate_gpumat_decls=False)
+    parser = CppHeaderParser(generate_umat_decls=False, generate_gpumat_decls=False)
     decls = []
-  #  for hname in opencv_hdr_list:
-  #      decls += parser.parse(hname)
-    if len(sys.argv) > 2:
-        for hname in sys.argv[1:]:
-            decls += parser.parse(hname)
-    else:
-        decls += parser.parse(sys.argv[1])
+    # for hname in opencv_hdr_list:
+       # decls += parser.parse(hname)
+    for hname in sys.argv[1:]:
+        decls += parser.parse(hname, wmode=True)
     parser.print_decls(decls)
+    print(len(decls))
+    print("namespaces:", " ".join(sorted(parser.namespaces)))

data/lib/rbind/types/std_map.rb

@@ -18,11 +18,42 @@ module Rbind
             klass.add_operation ROperation.new("size",type("size_t"))
             klass.add_operation ROperation.new("clear",type("void"))
             klass.add_operation ROperation.new("empty",type("bool"))
-            klass.add_operation ROperation.new("operator[]",map_value_type, RParameter.new("key_type", map_key_type))
+            klass.add_operation ROperation.new("operator[]",map_value_type.to_ref, RParameter.new("key_type", map_key_type))
+            klass.add_operation ROperation.new("add",type("void"), RParameter.new("key", map_key_type),RParameter.new("value", map_value_type.to_ref.to_const))
+            klass.operation("add").overwrite_c do
+                "(*rbind_obj_)[#{map_key_type.basic_type? ? "key" : "*key_"}] = #{map_value_type.basic_type? ? "value" : "*value_"};"
+            end
+
             klass.add_operation ROperation.new("at",map_value_type, RParameter.new("key_type",map_key_type))
             klass.add_operation ROperation.new("erase",type("void"), RParameter.new("key_type",map_key_type))
+            klass.add_operation ROperation.new("getKeys",type("std::vector<#{map_key_type}>"))
+            klass.operation("getKeys").overwrite_c do
+                str = %{
+                    auto keys = new std::vector<#{map_key_type}>();
+                    std::transform(std::begin(*rbind_obj_), std::end(*rbind_obj_), std::back_inserter(*keys), 
+                            [](std::pair<#{map_key_type},#{map_value_type}> const& pair) {
+                        return pair.first;
+                    }); 
+                    return toC(keys);
+                }
+            end
+	        klass
+        end
 
-            klass
+        # called from RTemplate when ruby_specialize is called for the instance
+        def specialize_ruby_specialization(klass)
+            %Q$ 
+            def to_hash
+	            hash = Hash.new
+	    	    keys = get_keys
+                keys.each do |k|
+                    hash[k] = self[k]
+                end
+		        hash
+            end
+            def []=(key,val)
+		        add(key,val)
+            end$
         end
     end
 end

data/lib/rbind/types/std_vector.rb

@@ -11,7 +11,12 @@ module Rbind
 
             para = Array.new
             para <<  RParameter.new("size",type("size_t"))
-            para <<  RParameter.new("val",vector_type).default_value(vector_type.full_name+"()").to_const
+            if vector_type.is_a? REnum 
+                para <<  RParameter.new("val",vector_type)
+            else
+               para <<  RParameter.new("val",vector_type).default_value(vector_type.full_name+"()").to_const
+            end
+
             klass.add_operation ROperation.new("resize",type("void"),para)
             klass.add_operation ROperation.new("size",type("size_t"))
             klass.add_operation ROperation.new("clear",type("void"))

data/rbind.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
     s.name              = 'rbind'
-    s.version           = '0.0.32'
-    s.date              = '2020-02-29'
+    s.version           = '0.0.35'
+    s.date              = '2022-06-18'
     s.platform          = Gem::Platform::RUBY
     s.authors           = ['Alexander Duda']
     s.email             = ['Alexander.Duda@me.com']

metadata

@@ -1,35 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: rbind
 version: !ruby/object:Gem::Version
-  version: 0.0.32
+  version: 0.0.35
 platform: ruby
 authors:
 - Alexander Duda
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-29 00:00:00.000000000 Z
+date: 2022-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.9.0
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.9.0
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.0
 description: Rbind is developed to automatically generate ruby bindings for OpenCV
   but is not tight to this library.This gem is still under heavy development and the
   API might change in the future.
@@ -128,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.3.5
 signing_key: 
 specification_version: 4
 summary: Library for genereating automated ffi-bindings for c/c++ libraries