pycparser 3.1__tar.gz → 3.11__tar.gz

{pycparser-3.1/pycparser.egg-info → pycparser-3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycparser
-Version: 3.1
+Version: 3.11
 Summary: C parser in Python
 Author-email: Eli Bendersky <eliben@gmail.com>
 Maintainer-email: Eli Bendersky <eliben@gmail.com>

{pycparser-3.1 → pycparser-3.11}/pycparser/__init__.py

@@ -8,7 +8,7 @@
 # License: BSD
 # -----------------------------------------------------------------
 __all__ = ["c_ast", "c_lexer", "c_parser"]
-__version__ = "3.01"
+__version__ = "3.11"
 
 from subprocess import check_output
 

{pycparser-3.1 → pycparser-3.11}/pycparser/_c_ast.cfg

@@ -50,6 +50,8 @@ Compound: [block_items**]
 CompoundLiteral: [type*, init*]
 
 # type: int, char, float, string, etc.
+# value: source spelling. A string may retain adjacent quoted fragments to
+# preserve escape boundaries, e.g. "\x1" "a".
 #
 Constant: [type, value]
 
@@ -125,6 +127,18 @@ FuncDecl: [args*, type*]
 #
 FuncDef: [decl*, param_decls**, body*]
 
+# One association in a C11 generic selection.
+# type: Typename, or None for the default association
+# expr: the result expression for this association
+#
+GenericAssociation: [type*, expr*]
+
+# A C11 _Generic expression. All associations are preserved in source order.
+# expr: the controlling expression (not evaluated by C)
+# associations: a nonempty sequence of GenericAssociation nodes
+#
+GenericSelection: [expr*, associations**]
+
 Goto: [name]
 
 ID: [name]
@@ -156,6 +170,9 @@ PtrDecl: [quals, type*]
 
 Return: [expr*]
 
+# A static assertion declaration. The condition is preserved without evaluation.
+# message: a string Constant, or None for the message-less extension
+#
 StaticAssert: [cond*, message*]
 
 # name: struct tag name

{pycparser-3.1 → pycparser-3.11}/pycparser/ast_transforms.py

@@ -7,6 +7,7 @@
 # License: BSD
 # ------------------------------------------------------------------------------
 
+from copy import deepcopy
 from typing import Any, cast
 
 from . import c_ast
@@ -111,8 +112,8 @@ def _extract_nested_case(
 
 
 def fix_atomic_specifiers(
-    decl: c_ast.Decl | c_ast.Typedef,
-) -> c_ast.Decl | c_ast.Typedef:
+    decl: c_ast.Decl | c_ast.Typedef | c_ast.Typename,
+) -> c_ast.Decl | c_ast.Typedef | c_ast.Typename:
     """Atomic specifiers like _Atomic(type) are unusually structured,
     conferring a qualifier upon the contained type.
 
@@ -127,17 +128,16 @@ def fix_atomic_specifiers(
         if not found:
             break
 
-    # Make sure to add an _Atomic qual on the topmost decl if needed. Also
-    # restore the declname on the innermost TypeDecl (it gets placed in the
-    # wrong place during construction).
+    # Match the declaration's qualifiers to the innermost TypeDecl, as for
+    # ordinary declarations. Qualifiers moved onto pointers belong only on
+    # those PtrDecl nodes. Also restore the name lost with the wrapper TypeDecl.
     typ: Any = decl
     while not isinstance(typ, c_ast.TypeDecl):
         try:
             typ = typ.type
         except AttributeError:
             return decl
-    if "_Atomic" in typ.quals and "_Atomic" not in decl.quals:
-        decl.quals.append("_Atomic")
+    decl.quals = typ.quals[:]
     if typ.declname is None:
         typ.declname = decl.name
 
@@ -145,8 +145,8 @@ def fix_atomic_specifiers(
 
 
 def _fix_atomic_specifiers_once(
-    decl: c_ast.Decl | c_ast.Typedef,
-) -> tuple[c_ast.Decl | c_ast.Typedef, bool]:
+    decl: c_ast.Decl | c_ast.Typedef | c_ast.Typename,
+) -> tuple[c_ast.Decl | c_ast.Typedef | c_ast.Typename, bool]:
     """Performs one 'fix' round of atomic specifiers.
     Returns (modified_decl, found) where found is True iff a fix was made.
     """
@@ -168,11 +168,17 @@ def _fix_atomic_specifiers_once(
 
     assert isinstance(parent, c_ast.TypeDecl)
     assert grandparent is not None
-    if node.type.coord is None:
+    # Declaration specifiers are shared by comma-separated declarators. Copy
+    # the contained type before attaching qualifiers, coordinates, and a name.
+    typ = deepcopy(node.type)
+    if typ.coord is None:
         # Preserve the declarator coord for _Atomic(T) so TypeDecl doesn't lose
         # its location when we replace the wrapper Typename.
-        node.type.coord = parent.coord
-    cast(Any, grandparent).type = node.type
-    if "_Atomic" not in node.type.quals:
-        node.type.quals.append("_Atomic")
+        typ.coord = parent.coord
+    # Qualifiers outside _Atomic(T) apply to T itself. In particular, const in
+    # const _Atomic(int *) qualifies the pointer, not the pointed-to int.
+    typ.quals = parent.quals + typ.quals
+    if "_Atomic" not in typ.quals:
+        typ.quals.append("_Atomic")
+    cast(Any, grandparent).type = typ
     return decl, True

{pycparser-3.1 → pycparser-3.11}/pycparser/c_ast.py

@@ -831,6 +831,55 @@ class FuncDef(Node):
     attr_names = ()
 
 
+class GenericAssociation(Node):
+    __slots__ = ("type", "expr", "coord", "__weakref__")
+
+    def __init__(self, type, expr, coord=None):
+        self.type = type
+        self.expr = expr
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.type is not None:
+            nodelist.append(("type", self.type))
+        if self.expr is not None:
+            nodelist.append(("expr", self.expr))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.type is not None:
+            yield self.type
+        if self.expr is not None:
+            yield self.expr
+
+    attr_names = ()
+
+
+class GenericSelection(Node):
+    __slots__ = ("expr", "associations", "coord", "__weakref__")
+
+    def __init__(self, expr, associations, coord=None):
+        self.expr = expr
+        self.associations = associations
+        self.coord = coord
+
+    def children(self):
+        nodelist = []
+        if self.expr is not None:
+            nodelist.append(("expr", self.expr))
+        for i, child in enumerate(self.associations or []):
+            nodelist.append((f"associations[{i}]", child))
+        return tuple(nodelist)
+
+    def __iter__(self):
+        if self.expr is not None:
+            yield self.expr
+        yield from self.associations or []
+
+    attr_names = ()
+
+
 class Goto(Node):
     __slots__ = ("name", "coord", "__weakref__")
 

{pycparser-3.1 → pycparser-3.11}/pycparser/c_generator.py

@@ -70,6 +70,17 @@ class CGenerator:
         args = self.visit(n.args) if n.args is not None else ""
         return fref + "(" + args + ")"
 
+    def visit_GenericSelection(self, n: c_ast.GenericSelection) -> str:
+        # The controlling and association expressions are assignment-expressions:
+        # preserve parentheses around comma expressions with _visit_expr.
+        expr = self._visit_expr(n.expr)
+        associations = ", ".join(self.visit(a) for a in n.associations)
+        return f"_Generic({expr}, {associations})"
+
+    def visit_GenericAssociation(self, n: c_ast.GenericAssociation) -> str:
+        typ = self.visit(n.type) if n.type is not None else "default"
+        return f"{typ}: {self._visit_expr(n.expr)}"
+
     def visit_UnaryOp(self, n: c_ast.UnaryOp) -> str:
         match n.op:
             case "sizeof":
@@ -170,10 +181,13 @@ class CGenerator:
                 return self.visit(n)
 
     def visit_Decl(self, n: c_ast.Decl, no_type: bool = False) -> str:
-        # no_type is used when a Decl is part of a DeclList, where the type is
-        # explicitly only for the first declaration in a list.
-        #
-        s = n.name if no_type else self._generate_decl(n)
+        # Later declarations in a DeclList omit the shared specifiers, but
+        # still need their own pointer, array, and function declarator parts.
+        s = (
+            self._generate_type(n.type, emit_base_type=False)
+            if no_type
+            else self._generate_decl(n)
+        )
         if n.bitsize:
             s += " : " + self.visit(n.bitsize)
         if n.init:
@@ -327,7 +341,7 @@ class CGenerator:
         s = "_Static_assert("
         s += self.visit(n.cond)
         if n.message:
-            s += ","
+            s += ", "
             s += self.visit(n.message)
         s += ")"
         return s
@@ -451,10 +465,11 @@ class CGenerator:
                 | c_ast.Typedef()
                 | c_ast.ExprList()
                 | c_ast.CompoundLiteral()
+                | c_ast.GenericSelection()
+                | c_ast.StaticAssert()
             ):
-                # These can also appear in an expression context so no semicolon
-                # is added to them automatically
-                #
+                # These visitors leave the semicolon to the enclosing context,
+                # so they can also be used in expressions or for clauses.
                 return indent + self.visit(n) + ";\n"
             case c_ast.Compound():
                 # No extra indentation required before the opening brace of a
@@ -475,7 +490,7 @@ class CGenerator:
         if n.storage:
             s += " ".join(n.storage) + " "
         if n.align:
-            s += self.visit(n.align[0]) + " "
+            s += " ".join(self.visit(align) for align in n.align) + " "
         s += self._generate_type(n.type)
         return s
 
@@ -484,11 +499,14 @@ class CGenerator:
         n: c_ast.Node,
         modifiers: list[c_ast.Node] | None = None,
         emit_declname: bool = True,
+        emit_base_type: bool = True,
     ) -> str:
         """Recursive generation from a type node. n is the type node.
         modifiers collects the PtrDecl, ArrayDecl and FuncDecl modifiers
         encountered on the way down to a TypeDecl, to allow proper
         generation from it.
+        emit_base_type controls whether the shared type specifier and its
+        qualifiers are emitted, independently of the declarator parts.
         """
         if modifiers is None:
             modifiers = []
@@ -497,9 +515,10 @@ class CGenerator:
         match n:
             case c_ast.TypeDecl():
                 s = ""
-                if n.quals:
-                    s += " ".join(n.quals) + " "
-                s += self.visit(n.type)
+                if emit_base_type:
+                    if n.quals:
+                        s += " ".join(n.quals) + " "
+                    s += self.visit(n.type)
 
                 nstr = n.declname if n.declname and emit_declname else ""
                 # Resolve modifiers.
@@ -533,18 +552,27 @@ class CGenerator:
                                 nstr = f"* {quals}{suffix}"
                             else:
                                 nstr = "*" + nstr
+                if not emit_base_type:
+                    return nstr
                 if nstr:
                     s += " " + nstr
                 return s
             case c_ast.Decl():
                 return self._generate_decl(n.type)
             case c_ast.Typename():
-                return self._generate_type(n.type, emit_declname=emit_declname)
+                return self._generate_type(
+                    n.type,
+                    emit_declname=emit_declname,
+                    emit_base_type=emit_base_type,
+                )
             case c_ast.IdentifierType():
                 return " ".join(n.names) + " "
             case c_ast.ArrayDecl() | c_ast.PtrDecl() | c_ast.FuncDecl():
                 return self._generate_type(
-                    n.type, modifiers + [n], emit_declname=emit_declname
+                    n.type,
+                    modifiers + [n],
+                    emit_declname=emit_declname,
+                    emit_base_type=emit_base_type,
                 )
             case _:
                 return self.visit(n)
@@ -571,5 +599,12 @@ class CGenerator:
         """
         return isinstance(
             n,
-            (c_ast.Constant, c_ast.ID, c_ast.ArrayRef, c_ast.StructRef, c_ast.FuncCall),
+            (
+                c_ast.Constant,
+                c_ast.ID,
+                c_ast.ArrayRef,
+                c_ast.StructRef,
+                c_ast.FuncCall,
+                c_ast.GenericSelection,
+            ),
         )

{pycparser-3.1 → pycparser-3.11}/pycparser/c_lexer.py

@@ -425,6 +425,7 @@ _keywords: tuple[str, ...] = (
     "__INT128",
     "_BOOL",
     "_COMPLEX",
+    "_GENERIC",
     "_NORETURN",
     "_THREAD_LOCAL",
     "_STATIC_ASSERT",
@@ -472,51 +473,55 @@ _bad_octal_constant = "0[0-7]*[89]"
 _unsupported_c_style_comment = r"\/\*"
 _unsupported_cxx_style_comment = r"\/\/"
 
-# character constants (K&R2: A.2.5.2)
-# Note: a-zA-Z and '.-~^_!=&;,' are allowed as escape chars to support #line
-# directives with Windows paths as filenames (..\..\dir\file)
-# For the same reason, decimal_escape allows all digit sequences. We want to
-# parse all correct code, even if it means to sometimes parse incorrect
-# code.
+# Character constants and escape sequences.
 #
-# The original regexes were taken verbatim from the C syntax definition,
-# and were later modified to avoid worst-case exponential running time.
+# Tokens preserve their source spelling; the lexer does not decode escapes or
+# validate Unicode code points. Each complete escape must match as one character
+# in _cconst_char, which is used for both single and multicharacter constants.
+# Matching is deliberately permissive: simple escapes accept extra letters and
+# punctuation, and numeric escapes accept decimal digits, not just octal digits.
 #
-#   simple_escape = r"""([a-zA-Z._~!=&\^\-\\?'"])"""
-#   decimal_escape = r"""(\d+)"""
-#   hex_escape = r"""(x[0-9a-fA-F]+)"""
-#   bad_escape = r"""([\\][^a-zA-Z._~^!=&\^\-\\?'"x0-7])"""
-#
-# The following modifications were made to avoid the ambiguity that allowed
-# backtracking: (https://github.com/eliben/pycparser/issues/61)
-#
-# - \x was removed from simple_escape, unless it was not followed by a hex
-#   digit, to avoid ambiguity with hex_escape.
-# - hex_escape allows one or more hex characters, but requires that the next
-#   character(if any) is not hex
-# - decimal_escape allows one or more decimal characters, but requires that the
-#   next character(if any) is not a decimal
-# - bad_escape does not allow any decimals (8-9), to avoid conflicting with the
-#   permissive decimal_escape.
-#
-# Without this change, python's `re` module would recursively try parsing each
-# ambiguous escape sequence in multiple ways. e.g. `\123` could be parsed as
-# `\1`+`23`, `\12`+`3`, and `\123`.
-
-_simple_escape = r"""([a-wyzA-Z._~!=&\^\-\\?'"]|x(?![0-9a-fA-F]))"""
+# _cconst_char is also repeated in the error patterns. If an escape can match in
+# several ways, long malformed constants can cause exponential backtracking
+# (https://github.com/eliben/pycparser/issues/61). The lookaheads prevent this:
+# - Decimal and hexadecimal escapes consume the whole run of digits. For
+#   example, \123 cannot be split into \1 followed by the characters 2 and 3.
+# - A simple \x escape is allowed only when no hexadecimal digit follows it.
+# - A complete Unicode escape cannot fall back to a simple \u or \U escape.
+# _bad_escape also excludes all decimal digits to agree with this permissiveness.
+
+# Universal character names consume exactly four hex digits after u or eight
+# after U. A following hex digit is a separate character, unlike with \x.
+_unicode_escape = r"(u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})"
+# This lookahead runs immediately after the backslash. If a complete Unicode
+# escape follows, only _unicode_escape may match it: \u00e9 cannot be read as
+# \u followed by 0, 0, e, 9. Incomplete forms retain the permissive behavior
+# of simple escapes.
+_simple_escape = (
+    rf"(?!{_unicode_escape})"
+    r"""([a-wyzA-Z._~!=&\^\-\\?'"]|x(?![0-9a-fA-F]))"""
+)
 _decimal_escape = r"""(\d+)(?!\d)"""
 _hex_escape = r"""(x[0-9a-fA-F]+)(?![0-9a-fA-F])"""
 _bad_escape = r"""([\\][^a-zA-Z._~^!=&\^\-\\?'"x0-9])"""
 
 _escape_sequence = (
-    r"""(\\(""" + _simple_escape + "|" + _decimal_escape + "|" + _hex_escape + "))"
+    r"""(\\("""
+    + _simple_escape
+    + "|"
+    + _decimal_escape
+    + "|"
+    + _hex_escape
+    + "|"
+    + _unicode_escape
+    + "))"
 )
 
-# This complicated regex with lookahead might be slow for strings, so because
-# all of the valid escapes (including \x) allowed
-# 0 or more non-escaped characters after the first character,
-# simple_escape+decimal_escape+hex_escape got simplified to
-
+# Strings do not need to count the characters represented by escapes. Match
+# just the backslash and a permitted following character; _string_char consumes
+# any remaining numeric or Unicode digits as ordinary text. This avoids matching
+# complete escape sequences repeatedly. The permissive spellings also support
+# Windows paths in #line filenames, which are matched with _string_literal.
 _escape_sequence_start_in_string = r"""(\\[0-9a-zA-Z._~!=&\^\-\\?'"])"""
 
 _cconst_char = r"""([^'\\\n]|""" + _escape_sequence + ")"
@@ -531,7 +536,7 @@ _bad_char_const = (
     r"""('""" + _cconst_char + """[^'\n]+')|('')|('""" + _bad_escape + r"""[^'\n]*')"""
 )
 
-# string literals (K&R2: A.2.6)
+# String literals, including wide and Unicode prefixes.
 _string_char = r"""([^"\\\n]|""" + _escape_sequence_start_in_string + ")"
 _string_literal = '"' + _string_char + '*"'
 _wstring_literal = "L" + _string_literal