cxxheaderparser 1.7.4__tar.gz → 1.8.0__tar.gz

{cxxheaderparser-1.7.4 → cxxheaderparser-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cxxheaderparser
-Version: 1.7.4
+Version: 1.8.0
 Summary: Modern C++ header parser
 Project-URL: Source code, https://github.com/robotpy/cxxheaderparser
 Author-email: Dustin Spicuzza <robotpy@googlegroups.com>

{cxxheaderparser-1.7.4 → cxxheaderparser-1.8.0}/cxxheaderparser/lexer.py

@@ -111,6 +111,10 @@ class PlyLexer:
         "__inline",
         "inline",
         "int",
+        "__int8",
+        "__int16",
+        "__int32",
+        "__int64",
         "long",
         "mutable",
         "namespace",

{cxxheaderparser-1.7.4 → cxxheaderparser-1.8.0}/cxxheaderparser/parser.py

@@ -273,6 +273,40 @@ class CxxParser:
             if next_end:
                 match_stack.append(next_end)
 
+    def _consume_balanced_tokens_with_inner(
+        self,
+        *init_tokens: LexToken,
+        token_map: typing.Optional[typing.Dict[str, str]] = None,
+    ) -> typing.Tuple[LexTokenList, LexTokenList]:
+        toks = self._consume_balanced_tokens(*init_tokens, token_map=token_map)
+        inner_toks = toks[1:-1]
+
+        # Redundant declarator grouping is valid: int ((*p))(int),
+        # int ((*p))[3], and void ((f))(int). Strip only parens that
+        # enclose the whole inner token list.
+        while (
+            len(inner_toks) >= 2
+            and inner_toks[0].type == "("
+            and inner_toks[-1].type == ")"
+        ):
+            depth = 0
+            encloses_all = True
+            for i, itok in enumerate(inner_toks):
+                if itok.type == "(":
+                    depth += 1
+                elif itok.type == ")":
+                    depth -= 1
+                    if depth == 0 and i != len(inner_toks) - 1:
+                        encloses_all = False
+                        break
+
+            if not encloses_all or depth != 0:
+                break
+
+            inner_toks = inner_toks[1:-1]
+
+        return toks, inner_toks
+
     def _discard_contents(self, start_type: str, end_type: str) -> None:
         # use this instead of consume_balanced_tokens because
         # we don't care at all about the internals
@@ -1677,6 +1711,10 @@ class CxxParser:
         "float",
         "double",
         "char",
+        "__int8",
+        "__int16",
+        "__int32",
+        "__int64",
     }
 
     _fundamentals = _compound_fundamentals | {
@@ -1967,6 +2005,14 @@ class CxxParser:
         if tok:
             param_name = tok.value
 
+        # Function parameter declarations can use function declarator syntax,
+        # e.g. ``bool predicate(const T&)``. In parameter lists, function types
+        # are adjusted to pointers to functions, matching the explicit
+        # ``bool (*predicate)(const T&)`` spelling.
+        if param_name and self.lex.token_if("("):
+            fn_params, vararg, _ = self._parse_parameters(False, False)
+            dtype = Pointer(FunctionType(dtype, fn_params, vararg))
+
         # optional array parameter
         tok = self.lex.token_if("[")
         if tok:
@@ -2460,8 +2506,8 @@ class CxxParser:
                     if not gtok:
                         break
 
-                    toks = self._consume_balanced_tokens(gtok)
-                    self.lex.return_tokens(toks[1:-1])
+                    _, inner_toks = self._consume_balanced_tokens_with_inner(gtok)
+                    self.lex.return_tokens(inner_toks)
 
                 fn_params, vararg, _ = self._parse_parameters(False, False)
 
@@ -2478,14 +2524,26 @@ class CxxParser:
                 if msvc_convention_tok:
                     msvc_convention = msvc_convention_tok.value
 
+                # this might be a grouping paren, so consume it and inspect it
+                toks, inner_toks = self._consume_balanced_tokens_with_inner(tok)
+                member_ptr_idx = next(
+                    (
+                        i
+                        for i, itok in enumerate(inner_toks)
+                        if itok.type == "*"
+                        and i > 0
+                        and inner_toks[i - 1].type == "DBL_COLON"
+                    ),
+                    None,
+                )
+
                 # Check to see if this is a grouping paren or something else
-                if not self.lex.token_peek_if("*", "&"):
-                    self.lex.return_token(tok)
+                if not inner_toks or (
+                    inner_toks[0].type not in ("*", "&") and member_ptr_idx is None
+                ):
+                    self.lex.return_tokens(toks)
                     break
 
-                # this is a grouping paren, so consume it
-                toks = self._consume_balanced_tokens(tok)
-
                 # Now check to see if we have either an array or a function pointer
                 aptok = self.lex.token_if("[", "(")
                 if aptok:
@@ -2502,14 +2560,30 @@ class CxxParser:
                             dtype, fn_params, vararg, msvc_convention=msvc_convention
                         )
 
-                        # the inner tokens must either be a * or a pqname that ends
-                        # with ::* (member function pointer)
-                        # ... TODO member function pointer :(
+                if isinstance(dtype, FunctionType) and member_ptr_idx is not None:
+                    # Keep the * and declarator name for the normal pointer/name
+                    # parsing below, and store the qualified class name on the
+                    # function type.
+                    class_toks = inner_toks[: member_ptr_idx - 1] + [PhonyEnding]
+                    old_lex = self.lex
+                    try:
+                        self.lex = lexer.BoundedTokenStream(class_toks)
+                        classname, _ = self._parse_pqname(
+                            None, compound_ok=False, fn_ok=False, fund_ok=False
+                        )
+                        self._next_token_must_be(PhonyEnding.type)
+                    finally:
+                        self.lex = old_lex
+
+                    dtype.classname = classname
+                    inner_toks = [inner_toks[member_ptr_idx]] + inner_toks[
+                        member_ptr_idx + 1 :
+                    ]
 
                 # return the inner toks and recurse
                 # -> this could return some weird results for invalid code, but
                 #    we don't support that anyways so it's fine?
-                self.lex.return_tokens(toks[1:-1])
+                self.lex.return_tokens(inner_toks)
                 dtype = self._parse_cv_ptr_or_fn(dtype, nonptr_fn)
                 break
 
@@ -2668,7 +2742,7 @@ class CxxParser:
         is_friend: bool,
         attributes: typing.List[Attribute],
     ) -> bool:
-        toks = []
+        toks: LexTokenList = []
 
         # On entry we only have the base type, decorate it
         dtype: typing.Optional[DecoratedType]
@@ -2730,7 +2804,7 @@ class CxxParser:
             if dtype:
                 # if it's not a constructor/destructor, it could be a
                 # grouping paren like "void (name(int x));"
-                toks = self._consume_balanced_tokens(tok)
+                toks, inner_toks = self._consume_balanced_tokens_with_inner(tok)
 
                 # check to see if the next token is an arrow, and thus a trailing return
                 if self.lex.token_peek_if("ARROW"):
@@ -2740,7 +2814,7 @@ class CxxParser:
                     is_guide = True
                 else:
                     # .. not sure what it's grouping, so put it back?
-                    self.lex.return_tokens(toks[1:-1])
+                    self.lex.return_tokens(inner_toks)
 
         if dtype:
             msvc_convention = self.lex.token_if_val(*self._msvc_conventions)

{cxxheaderparser-1.7.4 → cxxheaderparser-1.8.0}/cxxheaderparser/types.py

@@ -272,9 +272,6 @@ class FunctionType:
     return_type: "DecoratedType"
     parameters: typing.List["Parameter"]
 
-    #: If a member function pointer
-    # TODO classname: typing.Optional[PQName]
-
     #: Set to True if ends with ``...``
     vararg: bool = False
 
@@ -293,6 +290,9 @@ class FunctionType:
     #:            calling convention
     msvc_convention: typing.Optional[str] = None
 
+    #: If a member function pointer, the class that owns the member function.
+    classname: typing.Optional[PQName] = None
+
     def format(self) -> str:
         vararg = "..." if self.vararg else ""
         params = ", ".join(p.format() for p in self.parameters)
@@ -379,7 +379,9 @@ class Pointer:
         v = " volatile" if self.volatile else ""
         r = " __restrict__" if self.restrict else ""
         ptr_to = self.ptr_to
-        if isinstance(ptr_to, (Array, FunctionType)):
+        if isinstance(ptr_to, FunctionType) and ptr_to.classname:
+            return ptr_to.format_decl(f"({ptr_to.classname.format()}::*{r}{c}{v})")
+        elif isinstance(ptr_to, (Array, FunctionType)):
             return ptr_to.format_decl(f"(*{r}{c}{v})")
         else:
             return f"{ptr_to.format()}*{r}{c}{v}"
@@ -390,7 +392,11 @@ class Pointer:
         v = " volatile" if self.volatile else ""
         r = " __restrict__" if self.restrict else ""
         ptr_to = self.ptr_to
-        if isinstance(ptr_to, (Array, FunctionType)):
+        if isinstance(ptr_to, FunctionType) and ptr_to.classname:
+            return ptr_to.format_decl(
+                f"({ptr_to.classname.format()}::*{r}{c}{v} {name})"
+            )
+        elif isinstance(ptr_to, (Array, FunctionType)):
             return ptr_to.format_decl(f"(*{r}{c}{v} {name})")
         else:
             return f"{ptr_to.format()}*{r}{c}{v} {name}"

{cxxheaderparser-1.7.4 → cxxheaderparser-1.8.0}/cxxheaderparser/version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.7.4'
-__version_tuple__ = version_tuple = (1, 7, 4)
+__version__ = version = '1.8.0'
+__version_tuple__ = version_tuple = (1, 8, 0)
 
 __commit_id__ = commit_id = None