rbind 0.0.28 → 0.0.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e930dbda0aa8e1f1acf8758c78fad9324c0019bd
-  data.tar.gz: 62cf7fb25736383555dad7621b1df2fa0ddb5542
+SHA256:
+  metadata.gz: 8dfa66e6b61508d26cc2c07d7a903f26fc1cdafe7cf3b89e01ca3d3d2c88cbea
+  data.tar.gz: f4189a984e30892df84c8fc903a71379ce9e25efffa1cb10de150830c66909bd
 SHA512:
-  metadata.gz: 7b75baa4b7012be3076556b6980addc786630124005f2ff72e258cca0f0aa1e6a04e5623214c2723e159bbef661a0cced3f6b1b7778b0afd98d2794c996c24cc
-  data.tar.gz: 10d0e92af7049191962ea3c3197ffb08eec3f1eb09f88febe61993e78cf054da5f45d4e206071303878f6287b6542b6a62411f1e4fdd3b9f65e547a8c58cb9e8
+  metadata.gz: 9d6bd892f327c156d0285268f72d08da7aff8ebf466763f5a603725b3d603e2340d76bf003ba139ffdfc21498f2c24c5a7c1003fa67f843d39a8c219da642273
+  data.tar.gz: 4af2d861e47900da274e9297b76c25efa0810bfebeaaf9dc016737cf7a833a648a9c42f766ebf0c8cd1acdf365dd2a34c524c77043b90cf87f5c1fa263669517

data/lib/rbind/core/rclass.rb

@@ -220,10 +220,12 @@ 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?))

data/lib/rbind/core/rnamespace.rb

@@ -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)

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,7 @@ 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",""))
             type = find_type(owner,type_name)
             flags = normalize_flags(line_number,flags,:IO,:O)
             type = if flags.include?(:O) || flags.include?(:IO)
@@ -153,6 +154,9 @@ module Rbind
 					     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!
@@ -257,7 +261,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(" /")
@@ -332,6 +379,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_extern.rb

@@ -32,8 +32,10 @@ module Rbind
 
             #write all types so they get parsed first
             @root.each_type do |t|
-                if t.is_a? RClass
+                if t.is_a?(RClass) 
                     file_extern.write "class #{GeneratorExtern.normalize_type_name(t.full_name)}\n"
+                elsif t.is_a?(REnum)
+                    file_extern.write "enum #{GeneratorExtern.normalize_type_name(t.full_name)}\n"
                 end
             end
 

data/lib/rbind/generator_ruby.rb

@@ -133,12 +133,12 @@ module Rbind
             # map template classes
             # std::vector<std::string> -> Std::Vector::Std_String
             if name =~ /([\w:]*)<(.*)>$/
-		name = $1
-		names = $2.split(",")
-		names.map! do |val|
-		    normalize_type_name(val,true).gsub("::","_")
-		end
-		return "#{normalize_type_name(name,true)}::#{names.join("_")}"
+                name = $1
+                names = $2.split(",")
+                names.map! do |val|
+                    normalize_type_name(val,true).gsub("::","_")
+                end
+                return "#{normalize_type_name(name,true)}::#{names.join("_")}"
             else
                 name
             end
@@ -253,6 +253,21 @@ module Rbind
             name
         end
 
+        def self.normalize_const_value(name)
+            name = name.to_s.gsub(" ","")
+            # Parse constant declaration with suffix like 1000000LL
+            if name =~ /^([0-9]+)[uUlL]{0,2}/
+                name = $1
+                return name
+            end
+            # upcase first letter 
+            name = name.gsub(/\w*/) do |n|
+                next unless n.size > 0
+                n[0].upcase+n[1,n.size-1]
+            end
+            name
+        end
+
         class HelperBase
             extend ::Rbind::Logger
 
@@ -406,12 +421,13 @@ module Rbind
                         str += "\tenum :#{GeneratorRuby::normalize_enum_name(t.to_raw.csignature)}, ["
                         t.values.each do |name,value|
                             if value
-                                str += ":#{name},#{value}, "
+                                value = GeneratorRuby.normalize_const_value(value)
+                                str += ":#{name},#{GeneratorRuby.normalize_type_name(value)}, "
                             else
                                 str += ":#{name}, "
                             end
                         end
-                        str += "]\n\n"
+                        str += "]\n"
                     end
                 end
                 str
@@ -676,7 +692,7 @@ module Rbind
             end
 
             def add_consts(root=@root)
-                str = @root.consts.map do |c|
+                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"
@@ -685,13 +701,12 @@ module Rbind
                         val = begin
                                   eval(c.default_value)
                               rescue
-                                  GeneratorRuby::normalize_type_name(c.default_value)
+                                  GeneratorRuby::normalize_const_value(c.default_value)
                               end
                     "    #{c.name} = #{val}\n"
                     end
                 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)

data/lib/rbind/tools/hdr_parser.py

@@ -21,18 +21,20 @@ opencv_hdr_list = [
 ]
 
 """
-Each declaration is [funcname, return_value_type /* in C, not in Python */, <list_of_modifiers>, <list_of_arguments>],
+Each declaration is [funcname, return_value_type /* in C, not in Python */, <list_of_modifiers>, <list_of_arguments>, original_return_type, docstring],
 where each element of <list_of_arguments> is 4-element list itself:
 [argtype, argname, default_value /* or "" if none */, <list_of_modifiers>]
 where the list of modifiers is yet another nested list of strings
    (currently recognized are "/O" for output argument, "/S" for static (i.e. class) methods
    and "/A value" for the plain C arrays with counters)
+original_return_type is None if the original_return_type is the same as return_value_type
 """
 
 class CppHeaderParser(object):
 
-    def __init__(self, generate_umat_decls=False):
+    def __init__(self, generate_umat_decls=False, generate_gpumat_decls=False):
         self._generate_umat_decls = generate_umat_decls
+        self._generate_gpumat_decls = generate_gpumat_decls
 
         self.BLOCK_TYPE = 0
         self.BLOCK_NAME = 1
@@ -104,6 +106,14 @@ class CppHeaderParser(object):
             modlist.append("/CA " + macro_arg)
             arg_str = arg_str[:npos] + arg_str[npos3+1:]
 
+        npos = arg_str.find("const")
+        if npos >= 0:
+            modlist.append("/C")
+
+        npos = arg_str.find("&")
+        if npos >= 0:
+            modlist.append("/Ref")
+
         arg_str = arg_str.strip()
         word_start = 0
         word_list = []
@@ -226,7 +236,7 @@ class CppHeaderParser(object):
             else:
                 prev_val_delta = 0
                 prev_val = val = pv[1].strip()
-            decl.append(["const " + self.get_dotted_name(pv[0].strip()), val, [], []])
+            decl.append(["const " + self.get_dotted_name(pv[0].strip()), val, [], [], None, ""])
         return decl
 
     def parse_class_decl(self, decl_str):
@@ -250,13 +260,13 @@ class CppHeaderParser(object):
             l = l[:npos] + l[npos3+1:]
 
         l = self.batch_replace(l, [("CV_EXPORTS_W", ""), ("CV_EXPORTS", ""), ("public virtual ", " "), ("public ", " "), ("::", ".")]).strip()
-        ll = re.split(r'\s*[,:]?\s*', l)
+        ll = re.split(r'\s+|\s*[,:]\s*', l)
         ll = [le for le in ll if le]
         classname = ll[1]
         bases = ll[2:]
         return classname, bases, modlist
 
-    def parse_func_decl_no_wrap(self, decl_str, static_method = False):
+    def parse_func_decl_no_wrap(self, decl_str, static_method=False, docstring=""):
         decl_str = (decl_str or "").strip()
         virtual_method = False
         explicit_method = False
@@ -299,7 +309,7 @@ class CppHeaderParser(object):
             apos = fdecl.find("(", apos+1)
 
         fname = "cv." + fname.replace("::", ".")
-        decl = [fname, rettype, [], []]
+        decl = [fname, rettype, [], [], None, docstring]
 
         # inline constructor implementation
         implmatch = re.match(r"(\(.*?\))\s*:\s*(\w+\(.*?\),?\s*)+", fdecl[apos:])
@@ -366,11 +376,9 @@ class CppHeaderParser(object):
             decl[2].append("/A")
         if bool(re.match(r".*\)\s*const(\s*=\s*0)?", decl_str)):
             decl[2].append("/C")
-        if "virtual" in decl_str:
-            print(decl_str)
         return decl
 
-    def parse_func_decl(self, decl_str, use_umat=False):
+    def parse_func_decl(self, decl_str, mat="Mat", docstring=""):
         """
         Parses the function or method declaration in the form:
         [([CV_EXPORTS] <rettype>) | CVAPI(rettype)]
@@ -379,12 +387,11 @@ class CppHeaderParser(object):
             [const] {; | <function_body>}
 
         Returns the function declaration entry:
-        [<func name>, <return value C-type>, <list of modifiers>, <list of arguments>] (see above)
+        [<func name>, <return value C-type>, <list of modifiers>, <list of arguments>, <original return type>, <docstring>] (see above)
         """
 
         if self.wrap_mode:
-            if not (("CV_EXPORTS_AS" in decl_str) or ("CV_EXPORTS_W" in decl_str) or \
-                ("CV_WRAP" in decl_str) or ("CV_WRAP_AS" in decl_str)):
+            if not (("CV_EXPORTS_AS" in decl_str) or ("CV_EXPORTS_W" in decl_str) or ("CV_WRAP" in decl_str)):
                 return []
 
         # ignore old API in the documentation check (for now)
@@ -404,12 +411,37 @@ class CppHeaderParser(object):
             arg, npos3 = self.get_macro_arg(decl_str, npos)
             func_modlist.append("="+arg)
             decl_str = decl_str[:npos] + decl_str[npos3+1:]
+        npos = decl_str.find("CV_WRAP_PHANTOM")
+        if npos >= 0:
+            decl_str, _ = self.get_macro_arg(decl_str, npos)
+            func_modlist.append("/phantom")
+        npos = decl_str.find("CV_WRAP_MAPPABLE")
+        if npos >= 0:
+            mappable, npos3 = self.get_macro_arg(decl_str, npos)
+            func_modlist.append("/mappable="+mappable)
+            classname = top[1]
+            return ['.'.join([classname, classname]), None, func_modlist, [], None, None]
+
+        virtual_method = False
+        pure_virtual_method = False
+        const_method = False
 
         # 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, [("virtual", ""), ("static inline", ""), ("inline", ""),\
-            ("CV_EXPORTS_W", ""), ("CV_EXPORTS", ""), ("CV_CDECL", ""), ("CV_WRAP ", " "), ("CV_INLINE", "")]).strip()
+        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()
+
+
+        if decl_str.strip().startswith('virtual'):
+            virtual_method = True
+
+        decl_str = decl_str.replace('virtual' , '')
+
+        end_tokens = decl_str[decl_str.rfind(')'):].split()
+        const_method = 'const' in end_tokens
+        pure_virtual_method = '=' in end_tokens and '0' in end_tokens
 
         static_method = False
         context = top[0]
@@ -484,7 +516,7 @@ class CppHeaderParser(object):
         funcname = self.get_dotted_name(funcname)
 
         if not self.wrap_mode:
-            decl = self.parse_func_decl_no_wrap(decl_str, static_method)
+            decl = self.parse_func_decl_no_wrap(decl_str, static_method, docstring)
             decl[0] = funcname
             return decl
 
@@ -502,8 +534,6 @@ class CppHeaderParser(object):
             t, npos = self.find_next_token(decl_str, ["(", ")", ",", "<", ">"], npos)
             if not t:
                 print("Error: no closing ')' at %d" % (self.lineno,))
-                print(decl_str)
-                print(decl_str[arg_start:])
                 sys.exit(-1)
             if t == "<":
                 angle_balance += 1
@@ -539,8 +569,6 @@ class CppHeaderParser(object):
                         a = a[:eqpos].strip()
                     arg_type, arg_name, modlist, argno = self.parse_arg(a, argno)
                     if self.wrap_mode:
-                        mat = "UMat" if use_umat else "Mat"
-
                         # 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")
@@ -573,11 +601,14 @@ class CppHeaderParser(object):
 
         if static_method:
             func_modlist.append("/S")
+        if const_method:
+            func_modlist.append("/C")
+        if virtual_method:
+            func_modlist.append("/V")
+        if pure_virtual_method:
+            func_modlist.append("/PV")
 
-        if original_type is None:
-            return [funcname, rettype, func_modlist, args]
-        else:
-            return [funcname, rettype, func_modlist, args, original_type]
+        return [funcname, rettype, func_modlist, args, original_type, docstring]
 
     def get_dotted_name(self, name):
         """
@@ -602,8 +633,10 @@ class CppHeaderParser(object):
             block_type, block_name = b[self.BLOCK_TYPE], b[self.BLOCK_NAME]
             if block_type in ["file", "enum"]:
                 continue
-            if block_type not in ["struct", "class", "namespace"]:
-                print("Error at %d: there are non-valid entries in the current block stack " % (self.lineno, self.block_stack))
+            if block_type in ["enum struct", "enum class"] and block_name == name:
+                continue
+            if block_type not in ["struct", "class", "namespace", "enum struct", "enum class"]:
+                print("Error at %d: there are non-valid entries in the current block stack %s" % (self.lineno, self.block_stack))
                 sys.exit(-1)
             if block_name and (block_type == "namespace" or not qualified_name):
                 n += block_name + "."
@@ -612,7 +645,7 @@ class CppHeaderParser(object):
             n = "cv.Algorithm"
         return n
 
-    def parse_stmt(self, stmt, end_token, use_umat=False):
+    def parse_stmt(self, stmt, end_token, mat="Mat", docstring=""):
         """
         parses the statement (ending with ';' or '}') or a block head (ending with '{')
 
@@ -659,7 +692,7 @@ class CppHeaderParser(object):
                     exit(1)
                 if classname.startswith("_Ipl"):
                     classname = classname[1:]
-                decl = [stmt_type + " " + self.get_dotted_name(classname), "", modlist, []]
+                decl = [stmt_type + " " + self.get_dotted_name(classname), "", modlist, [], None, docstring]
                 if bases:
                     decl[1] = ": " + ", ".join([self.get_dotted_name(b).replace(".","::") for b in bases])
                 return stmt_type, classname, True, decl
@@ -674,25 +707,24 @@ class CppHeaderParser(object):
                         exit(1)
                     decl = []
                     if ("CV_EXPORTS_W" in stmt) or ("CV_EXPORTS_AS" in stmt) or (not self.wrap_mode):# and ("CV_EXPORTS" in stmt)):
-                        decl = [stmt_type + " " + self.get_dotted_name(classname), "", modlist, []]
+                        decl = [stmt_type + " " + self.get_dotted_name(classname), "", modlist, [], None, docstring]
                         if bases:
                             decl[1] = ": " + ", ".join([self.get_dotted_name(b).replace(".","::") for b in bases])
                     return stmt_type, classname, True, decl
 
-            if stmt.startswith("enum"):
-                return "enum", "", True, None
-
-            if stmt.startswith("namespace"):
-                stmt_list = stmt.split()
+            if stmt.startswith("enum") or stmt.startswith("namespace"):
+                stmt_list = stmt.rsplit(" ", 1)
                 if len(stmt_list) < 2:
                     stmt_list.append("<unnamed>")
                 return stmt_list[0], stmt_list[1], True, None
+
             if stmt.startswith("extern") and "\"C\"" in stmt:
                 return "namespace", "", True, None
 
-        if end_token == "}" and context == "enum":
+        if end_token == "}" and context.startswith("enum"):
             decl = self.parse_enum(stmt)
-            return "enum", "", False, decl
+            name = stack_top[self.BLOCK_NAME]
+            return context, name, False, decl
 
         if end_token == ";" and stmt.startswith("typedef"):
             # TODO: handle typedef's more intelligently
@@ -704,7 +736,7 @@ class CppHeaderParser(object):
             # since we filtered off the other places where '(' can normally occur:
             #   - code blocks
             #   - function pointer typedef's
-            decl = self.parse_func_decl(stmt, use_umat=use_umat)
+            decl = self.parse_func_decl(stmt, mat=mat, docstring=docstring)
             # we return parse_flag == False to prevent the parser to look inside function/method bodies
             # (except for tracking the nested blocks)
             return stmt_type, "", False, decl
@@ -731,7 +763,7 @@ class CppHeaderParser(object):
     def find_next_token(self, s, tlist, p=0):
         """
         Finds the next token from the 'tlist' in the input 's', starting from position 'p'.
-        Returns the first occured token and its position, or ("", len(s)) when no token is found
+        Returns the first occurred token and its position, or ("", len(s)) when no token is found
         """
         token = ""
         tpos = len(s)
@@ -759,17 +791,19 @@ class CppHeaderParser(object):
         SCAN = 0 # outside of a comment or preprocessor directive
         COMMENT = 1 # inside a multi-line comment
         DIRECTIVE = 2 # inside a multi-line preprocessor directive
+        DOCSTRING = 3 # inside a multi-line docstring
 
         state = SCAN
 
         self.block_stack = [["file", hname, True, True, None]]
         block_head = ""
+        docstring = ""
         self.lineno = 0
         self.wrap_mode = wmode
 
         for l0 in linelist:
             self.lineno += 1
-            #print self.lineno
+            #print(state, self.lineno, l0)
 
             l = l0.strip()
 
@@ -789,8 +823,22 @@ class CppHeaderParser(object):
                 l = l[pos+2:]
                 state = SCAN
 
+            if state == DOCSTRING:
+                pos = l.find("*/")
+                if pos < 0:
+                    docstring += l + "\n"
+                    continue
+                docstring += l[:pos] + "\n"
+                l = l[pos+2:]
+                state = SCAN
+
+            if l.startswith('CV__') or l.startswith('__CV_'): # just ignore these lines
+                #print('IGNORE: ' + l)
+                state = SCAN
+                continue
+
             if state != SCAN:
-                print("Error at %d: invlid state = %d" % (self.lineno, state))
+                print("Error at %d: invalid state = %d" % (self.lineno, state))
                 sys.exit(-1)
 
             while 1:
@@ -798,19 +846,34 @@ class CppHeaderParser(object):
 
                 if not token:
                     block_head += " " + l
-                    break
+                    block_head = block_head.strip()
+                    if len(block_head) > 0 and block_head[-1] == ')' and block_head.startswith('CV_ENUM_FLAGS('):
+                        l = ''
+                        token = ';'
+                    else:
+                        break
 
                 if token == "//":
                     block_head += " " + l[:pos]
-                    break
+                    l = ''
+                    continue
 
                 if token == "/*":
                     block_head += " " + l[:pos]
-                    pos = l.find("*/", pos+2)
-                    if pos < 0:
+                    end_pos = l.find("*/", pos+2)
+                    if len(l) > pos + 2 and l[pos+2] == "*":
+                        # '/**', it's a docstring
+                        if end_pos < 0:
+                            state = DOCSTRING
+                            docstring = l[pos+3:] + "\n"
+                            break
+                        else:
+                            docstring = l[pos+3:end_pos]
+
+                    elif end_pos < 0:
                         state = COMMENT
                         break
-                    l = l[pos+2:]
+                    l = l[end_pos+2:]
                     continue
 
                 if token == "\"":
@@ -830,6 +893,7 @@ class CppHeaderParser(object):
 
                 stmt = (block_head + " " + l[:pos]).strip()
                 stmt = " ".join(stmt.split()) # normalize the statement
+                #print(stmt)
                 stack_top = self.block_stack[-1]
 
                 if stmt.startswith("@"):
@@ -840,22 +904,33 @@ class CppHeaderParser(object):
                 if stack_top[self.PROCESS_FLAG]:
                     # even if stack_top[PUBLIC_SECTION] is False, we still try to process the statement,
                     # since it can start with "public:"
-                    stmt_type, name, parse_flag, decl = self.parse_stmt(stmt, token)
+                    docstring = docstring.strip()
+                    stmt_type, name, parse_flag, decl = self.parse_stmt(stmt, token, docstring=docstring)
                     if decl:
-                        if stmt_type == "enum":
-                            for d in decl:
-                                decls.append(d)
+                        if stmt_type.startswith("enum"):
+                            decls.append([stmt_type + " " + self.get_dotted_name(name), "", [], decl, None, ""])
                         else:
                             decls.append(decl)
 
+                            if self._generate_gpumat_decls and "cv.cuda." in decl[0]:
+                                # 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)
+                                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 self._generate_umat_decls:
                                 # If function takes as one of arguments Mat or vector<Mat> - we want to create the
                                 # same declaration working with UMat (this is important for T-Api access)
                                 args = decl[3]
                                 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, use_umat=True)
+                                    _, _, _, umat_decl = self.parse_stmt(stmt, token, mat="UMat", docstring=docstring)
                                     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))
@@ -887,6 +962,8 @@ class CppHeaderParser(object):
         """
         for d in decls:
             print(d[0], d[1], ";".join(d[2]))
+            # Uncomment below line to see docstrings
+            # print('"""\n' + d[5] + '\n"""')
             for a in d[3]:
                 print("   ", a[0], a[1], a[2], end="")
                 if a[3]:
@@ -895,7 +972,7 @@ class CppHeaderParser(object):
                     print()
 
 if __name__ == '__main__':
-    parser = CppHeaderParser(generate_umat_decls=False)
+    parser = CppHeaderParser(generate_umat_decls=True, generate_gpumat_decls=False)
     decls = []
   #  for hname in opencv_hdr_list:
   #      decls += parser.parse(hname)

data/rbind.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
     s.name              = 'rbind'
-    s.version           = '0.0.28'
-    s.date              = '2018-07-10'
+    s.version           = '0.0.30'
+    s.date              = '2019-06-06'
     s.platform          = Gem::Platform::RUBY
     s.authors           = ['Alexander Duda']
     s.email             = ['Alexander.Duda@me.com']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbind
 version: !ruby/object:Gem::Version
-  version: 0.0.28
+  version: 0.0.30
 platform: ruby
 authors:
 - Alexander Duda
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-10 00:00:00.000000000 Z
+date: 2019-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -123,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Library for genereating automated ffi-bindings for c/c++ libraries