

<div style='background:#ffffff; color:#000; font-family:monospace; padding:0; max-width:900px; margin:20px auto; border:3px solid #000;'><div style='background:#000080; color:#fff; padding:6px 12px; font-weight:bold;'>✏ 编辑: c_generator.py</div><div style='padding:20px;'><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#fff; color:#000; border:2px solid #000; font-family:monospace; padding:10px;'># ------------------------------------------------------------------------------
# pycparser: c_generator.py
#
# C code generator from pycparser AST nodes.
#
# Eli Bendersky [https://eli.thegreenplace.net/]
# License: BSD
# ------------------------------------------------------------------------------
from typing import Callable, List, Optional

from . import c_ast


class CGenerator:
    &quot;&quot;&quot;Uses the same visitor pattern as c_ast.NodeVisitor, but modified to
    return a value from each visit method, using string accumulation in
    generic_visit.
    &quot;&quot;&quot;

    indent_level: int
    reduce_parentheses: bool

    def __init__(self, reduce_parentheses: bool = False) -&gt; None:
        &quot;&quot;&quot;Constructs C-code generator

        reduce_parentheses:
            if True, eliminates needless parentheses on binary operators
        &quot;&quot;&quot;
        # Statements start with indentation of self.indent_level spaces, using
        # the _make_indent method.
        self.indent_level = 0
        self.reduce_parentheses = reduce_parentheses

    def _make_indent(self) -&gt; str:
        return &quot; &quot; * self.indent_level

    def visit(self, node: c_ast.Node) -&gt; str:
        method = &quot;visit_&quot; + node.__class__.__name__
        return getattr(self, method, self.generic_visit)(node)

    def generic_visit(self, node: Optional[c_ast.Node]) -&gt; str:
        if node is None:
            return &quot;&quot;
        else:
            return &quot;&quot;.join(self.visit(c) for c_name, c in node.children())

    def visit_Constant(self, n: c_ast.Constant) -&gt; str:
        return n.value

    def visit_ID(self, n: c_ast.ID) -&gt; str:
        return n.name

    def visit_Pragma(self, n: c_ast.Pragma) -&gt; str:
        ret = &quot;#pragma&quot;
        if n.string:
            ret += &quot; &quot; + n.string
        return ret

    def visit_ArrayRef(self, n: c_ast.ArrayRef) -&gt; str:
        arrref = self._parenthesize_unless_simple(n.name)
        return arrref + &quot;[&quot; + self.visit(n.subscript) + &quot;]&quot;

    def visit_StructRef(self, n: c_ast.StructRef) -&gt; str:
        sref = self._parenthesize_unless_simple(n.name)
        return sref + n.type + self.visit(n.field)

    def visit_FuncCall(self, n: c_ast.FuncCall) -&gt; str:
        fref = self._parenthesize_unless_simple(n.name)
        args = self.visit(n.args) if n.args is not None else &quot;&quot;
        return fref + &quot;(&quot; + args + &quot;)&quot;

    def visit_UnaryOp(self, n: c_ast.UnaryOp) -&gt; str:
        match n.op:
            case &quot;sizeof&quot;:
                # Always parenthesize the argument of sizeof since it can be
                # a name.
                return f&quot;sizeof({self.visit(n.expr)})&quot;
            case &quot;p++&quot;:
                operand = self._parenthesize_unless_simple(n.expr)
                return f&quot;{operand}++&quot;
            case &quot;p--&quot;:
                operand = self._parenthesize_unless_simple(n.expr)
                return f&quot;{operand}--&quot;
            case _:
                operand = self._parenthesize_unless_simple(n.expr)
                return f&quot;{n.op}{operand}&quot;

    # Precedence map of binary operators:
    precedence_map = {
        # Should be in sync with c_parser.CParser.precedence
        # Higher numbers are stronger binding
        &quot;||&quot;: 0,  # weakest binding
        &quot;&amp;&amp;&quot;: 1,
        &quot;|&quot;: 2,
        &quot;^&quot;: 3,
        &quot;&amp;&quot;: 4,
        &quot;==&quot;: 5,
        &quot;!=&quot;: 5,
        &quot;&gt;&quot;: 6,
        &quot;&gt;=&quot;: 6,
        &quot;&lt;&quot;: 6,
        &quot;&lt;=&quot;: 6,
        &quot;&gt;&gt;&quot;: 7,
        &quot;&lt;&lt;&quot;: 7,
        &quot;+&quot;: 8,
        &quot;-&quot;: 8,
        &quot;*&quot;: 9,
        &quot;/&quot;: 9,
        &quot;%&quot;: 9,  # strongest binding
    }

    def visit_BinaryOp(self, n: c_ast.BinaryOp) -&gt; str:
        # Note: all binary operators are left-to-right associative
        #
        # If `n.left.op` has a stronger or equally binding precedence in
        # comparison to `n.op`, no parenthesis are needed for the left:
        # e.g., `(a*b) + c` is equivalent to `a*b + c`, as well as
        #       `(a+b) - c` is equivalent to `a+b - c` (same precedence).
        # If the left operator is weaker binding than the current, then
        # parentheses are necessary:
        # e.g., `(a+b) * c` is NOT equivalent to `a+b * c`.
        lval_str = self._parenthesize_if(
            n.left,
            lambda d: not (
                self._is_simple_node(d)
                or self.reduce_parentheses
                and isinstance(d, c_ast.BinaryOp)
                and self.precedence_map[d.op] &gt;= self.precedence_map[n.op]
            ),
        )
        # If `n.right.op` has a stronger -but not equal- binding precedence,
        # parenthesis can be omitted on the right:
        # e.g., `a + (b*c)` is equivalent to `a + b*c`.
        # If the right operator is weaker or equally binding, then parentheses
        # are necessary:
        # e.g., `a * (b+c)` is NOT equivalent to `a * b+c` and
        #       `a - (b+c)` is NOT equivalent to `a - b+c` (same precedence).
        rval_str = self._parenthesize_if(
            n.right,
            lambda d: not (
                self._is_simple_node(d)
                or self.reduce_parentheses
                and isinstance(d, c_ast.BinaryOp)
                and self.precedence_map[d.op] &gt; self.precedence_map[n.op]
            ),
        )
        return f&quot;{lval_str} {n.op} {rval_str}&quot;

    def visit_Assignment(self, n: c_ast.Assignment) -&gt; str:
        rval_str = self._parenthesize_if(
            n.rvalue, lambda n: isinstance(n, c_ast.Assignment)
        )
        return f&quot;{self.visit(n.lvalue)} {n.op} {rval_str}&quot;

    def visit_IdentifierType(self, n: c_ast.IdentifierType) -&gt; str:
        return &quot; &quot;.join(n.names)

    def _visit_expr(self, n: c_ast.Node) -&gt; str:
        match n:
            case c_ast.InitList():
                return &quot;{&quot; + self.visit(n) + &quot;}&quot;
            case c_ast.ExprList() | c_ast.Compound():
                return &quot;(&quot; + self.visit(n) + &quot;)&quot;
            case _:
                return self.visit(n)

    def visit_Decl(self, n: c_ast.Decl, no_type: bool = False) -&gt; 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)
        if n.bitsize:
            s += &quot; : &quot; + self.visit(n.bitsize)
        if n.init:
            s += &quot; = &quot; + self._visit_expr(n.init)
        return s

    def visit_DeclList(self, n: c_ast.DeclList) -&gt; str:
        s = self.visit(n.decls[0])
        if len(n.decls) &gt; 1:
            s += &quot;, &quot; + &quot;, &quot;.join(
                self.visit_Decl(decl, no_type=True) for decl in n.decls[1:]
            )
        return s

    def visit_Typedef(self, n: c_ast.Typedef) -&gt; str:
        s = &quot;&quot;
        if n.storage:
            s += &quot; &quot;.join(n.storage) + &quot; &quot;
        s += self._generate_type(n.type)
        return s

    def visit_Cast(self, n: c_ast.Cast) -&gt; str:
        s = &quot;(&quot; + self._generate_type(n.to_type, emit_declname=False) + &quot;)&quot;
        return s + &quot; &quot; + self._parenthesize_unless_simple(n.expr)

    def visit_ExprList(self, n: c_ast.ExprList) -&gt; str:
        visited_subexprs = []
        for expr in n.exprs:
            visited_subexprs.append(self._visit_expr(expr))
        return &quot;, &quot;.join(visited_subexprs)

    def visit_InitList(self, n: c_ast.InitList) -&gt; str:
        visited_subexprs = []
        for expr in n.exprs:
            visited_subexprs.append(self._visit_expr(expr))
        return &quot;, &quot;.join(visited_subexprs)

    def visit_Enum(self, n: c_ast.Enum) -&gt; str:
        return self._generate_struct_union_enum(n, name=&quot;enum&quot;)

    def visit_Alignas(self, n: c_ast.Alignas) -&gt; str:
        return &quot;_Alignas({})&quot;.format(self.visit(n.alignment))

    def visit_Enumerator(self, n: c_ast.Enumerator) -&gt; str:
        if not n.value:
            return &quot;{indent}{name},\n&quot;.format(
                indent=self._make_indent(),
                name=n.name,
            )
        else:
            return &quot;{indent}{name} = {value},\n&quot;.format(
                indent=self._make_indent(),
                name=n.name,
                value=self.visit(n.value),
            )

    def visit_FuncDef(self, n: c_ast.FuncDef) -&gt; str:
        decl = self.visit(n.decl)
        self.indent_level = 0
        body = self.visit(n.body)
        if n.param_decls:
            knrdecls = &quot;;\n&quot;.join(self.visit(p) for p in n.param_decls)
            return decl + &quot;\n&quot; + knrdecls + &quot;;\n&quot; + body + &quot;\n&quot;
        else:
            return decl + &quot;\n&quot; + body + &quot;\n&quot;

    def visit_FileAST(self, n: c_ast.FileAST) -&gt; str:
        s = &quot;&quot;
        for ext in n.ext:
            match ext:
                case c_ast.FuncDef():
                    s += self.visit(ext)
                case c_ast.Pragma():
                    s += self.visit(ext) + &quot;\n&quot;
                case _:
                    s += self.visit(ext) + &quot;;\n&quot;
        return s

    def visit_Compound(self, n: c_ast.Compound) -&gt; str:
        s = self._make_indent() + &quot;{\n&quot;
        self.indent_level += 2
        if n.block_items:
            s += &quot;&quot;.join(self._generate_stmt(stmt) for stmt in n.block_items)
        self.indent_level -= 2
        s += self._make_indent() + &quot;}\n&quot;
        return s

    def visit_CompoundLiteral(self, n: c_ast.CompoundLiteral) -&gt; str:
        return &quot;(&quot; + self.visit(n.type) + &quot;){&quot; + self.visit(n.init) + &quot;}&quot;

    def visit_EmptyStatement(self, n: c_ast.EmptyStatement) -&gt; str:
        return &quot;;&quot;

    def visit_ParamList(self, n: c_ast.ParamList) -&gt; str:
        return &quot;, &quot;.join(self.visit(param) for param in n.params)

    def visit_Return(self, n: c_ast.Return) -&gt; str:
        s = &quot;return&quot;
        if n.expr:
            s += &quot; &quot; + self.visit(n.expr)
        return s + &quot;;&quot;

    def visit_Break(self, n: c_ast.Break) -&gt; str:
        return &quot;break;&quot;

    def visit_Continue(self, n: c_ast.Continue) -&gt; str:
        return &quot;continue;&quot;

    def visit_TernaryOp(self, n: c_ast.TernaryOp) -&gt; str:
        s = &quot;(&quot; + self._visit_expr(n.cond) + &quot;) ? &quot;
        s += &quot;(&quot; + self._visit_expr(n.iftrue) + &quot;) : &quot;
        s += &quot;(&quot; + self._visit_expr(n.iffalse) + &quot;)&quot;
        return s

    def visit_If(self, n: c_ast.If) -&gt; str:
        s = &quot;if (&quot;
        if n.cond:
            s += self.visit(n.cond)
        s += &quot;)\n&quot;
        s += self._generate_stmt(n.iftrue, add_indent=True)
        if n.iffalse:
            s += self._make_indent() + &quot;else\n&quot;
            s += self._generate_stmt(n.iffalse, add_indent=True)
        return s

    def visit_For(self, n: c_ast.For) -&gt; str:
        s = &quot;for (&quot;
        if n.init:
            s += self.visit(n.init)
        s += &quot;;&quot;
        if n.cond:
            s += &quot; &quot; + self.visit(n.cond)
        s += &quot;;&quot;
        if n.next:
            s += &quot; &quot; + self.visit(n.next)
        s += &quot;)\n&quot;
        s += self._generate_stmt(n.stmt, add_indent=True)
        return s

    def visit_While(self, n: c_ast.While) -&gt; str:
        s = &quot;while (&quot;
        if n.cond:
            s += self.visit(n.cond)
        s += &quot;)\n&quot;
        s += self._generate_stmt(n.stmt, add_indent=True)
        return s

    def visit_DoWhile(self, n: c_ast.DoWhile) -&gt; str:
        s = &quot;do\n&quot;
        s += self._generate_stmt(n.stmt, add_indent=True)
        s += self._make_indent() + &quot;while (&quot;
        if n.cond:
            s += self.visit(n.cond)
        s += &quot;);&quot;
        return s

    def visit_StaticAssert(self, n: c_ast.StaticAssert) -&gt; str:
        s = &quot;_Static_assert(&quot;
        s += self.visit(n.cond)
        if n.message:
            s += &quot;,&quot;
            s += self.visit(n.message)
        s += &quot;)&quot;
        return s

    def visit_Switch(self, n: c_ast.Switch) -&gt; str:
        s = &quot;switch (&quot; + self.visit(n.cond) + &quot;)\n&quot;
        s += self._generate_stmt(n.stmt, add_indent=True)
        return s

    def visit_Case(self, n: c_ast.Case) -&gt; str:
        s = &quot;case &quot; + self.visit(n.expr) + &quot;:\n&quot;
        for stmt in n.stmts:
            s += self._generate_stmt(stmt, add_indent=True)
        return s

    def visit_Default(self, n: c_ast.Default) -&gt; str:
        s = &quot;default:\n&quot;
        for stmt in n.stmts:
            s += self._generate_stmt(stmt, add_indent=True)
        return s

    def visit_Label(self, n: c_ast.Label) -&gt; str:
        return n.name + &quot;:\n&quot; + self._generate_stmt(n.stmt)

    def visit_Goto(self, n: c_ast.Goto) -&gt; str:
        return &quot;goto &quot; + n.name + &quot;;&quot;

    def visit_EllipsisParam(self, n: c_ast.EllipsisParam) -&gt; str:
        return &quot;...&quot;

    def visit_Struct(self, n: c_ast.Struct) -&gt; str:
        return self._generate_struct_union_enum(n, &quot;struct&quot;)

    def visit_Typename(self, n: c_ast.Typename) -&gt; str:
        return self._generate_type(n.type)

    def visit_Union(self, n: c_ast.Union) -&gt; str:
        return self._generate_struct_union_enum(n, &quot;union&quot;)

    def visit_NamedInitializer(self, n: c_ast.NamedInitializer) -&gt; str:
        s = &quot;&quot;
        for name in n.name:
            if isinstance(name, c_ast.ID):
                s += &quot;.&quot; + name.name
            else:
                s += &quot;[&quot; + self.visit(name) + &quot;]&quot;
        s += &quot; = &quot; + self._visit_expr(n.expr)
        return s

    def visit_FuncDecl(self, n: c_ast.FuncDecl) -&gt; str:
        return self._generate_type(n)

    def visit_ArrayDecl(self, n: c_ast.ArrayDecl) -&gt; str:
        return self._generate_type(n, emit_declname=False)

    def visit_TypeDecl(self, n: c_ast.TypeDecl) -&gt; str:
        return self._generate_type(n, emit_declname=False)

    def visit_PtrDecl(self, n: c_ast.PtrDecl) -&gt; str:
        return self._generate_type(n, emit_declname=False)

    def _generate_struct_union_enum(
        self, n: c_ast.Struct | c_ast.Union | c_ast.Enum, name: str
    ) -&gt; str:
        &quot;&quot;&quot;Generates code for structs, unions, and enums. name should be
        'struct', 'union', or 'enum'.
        &quot;&quot;&quot;
        if name in (&quot;struct&quot;, &quot;union&quot;):
            assert isinstance(n, (c_ast.Struct, c_ast.Union))
            members = n.decls
            body_function = self._generate_struct_union_body
        else:
            assert name == &quot;enum&quot;
            assert isinstance(n, c_ast.Enum)
            members = None if n.values is None else n.values.enumerators
            body_function = self._generate_enum_body
        s = name + &quot; &quot; + (n.name or &quot;&quot;)
        if members is not None:
            # None means no members
            # Empty sequence means an empty list of members
            s += &quot;\n&quot;
            s += self._make_indent()
            self.indent_level += 2
            s += &quot;{\n&quot;
            s += body_function(members)
            self.indent_level -= 2
            s += self._make_indent() + &quot;}&quot;
        return s

    def _generate_struct_union_body(self, members: List[c_ast.Node]) -&gt; str:
        return &quot;&quot;.join(self._generate_stmt(decl) for decl in members)

    def _generate_enum_body(self, members: List[c_ast.Enumerator]) -&gt; str:
        # `[:-2] + '\n'` removes the final `,` from the enumerator list
        return &quot;&quot;.join(self.visit(value) for value in members)[:-2] + &quot;\n&quot;

    def _generate_stmt(self, n: c_ast.Node, add_indent: bool = False) -&gt; str:
        &quot;&quot;&quot;Generation from a statement node. This method exists as a wrapper
        for individual visit_* methods to handle different treatment of
        some statements in this context.
        &quot;&quot;&quot;
        if add_indent:
            self.indent_level += 2
        indent = self._make_indent()
        if add_indent:
            self.indent_level -= 2

        match n:
            case (
                c_ast.Decl()
                | c_ast.Assignment()
                | c_ast.Cast()
                | c_ast.UnaryOp()
                | c_ast.BinaryOp()
                | c_ast.TernaryOp()
                | c_ast.FuncCall()
                | c_ast.ArrayRef()
                | c_ast.StructRef()
                | c_ast.Constant()
                | c_ast.ID()
                | c_ast.Typedef()
                | c_ast.ExprList()
            ):
                # These can also appear in an expression context so no semicolon
                # is added to them automatically
                #
                return indent + self.visit(n) + &quot;;\n&quot;
            case c_ast.Compound():
                # No extra indentation required before the opening brace of a
                # compound - because it consists of multiple lines it has to
                # compute its own indentation.
                #
                return self.visit(n)
            case c_ast.If():
                return indent + self.visit(n)
            case _:
                return indent + self.visit(n) + &quot;\n&quot;

    def _generate_decl(self, n: c_ast.Decl) -&gt; str:
        &quot;&quot;&quot;Generation from a Decl node.&quot;&quot;&quot;
        s = &quot;&quot;
        if n.funcspec:
            s = &quot; &quot;.join(n.funcspec) + &quot; &quot;
        if n.storage:
            s += &quot; &quot;.join(n.storage) + &quot; &quot;
        if n.align:
            s += self.visit(n.align[0]) + &quot; &quot;
        s += self._generate_type(n.type)
        return s

    def _generate_type(
        self,
        n: c_ast.Node,
        modifiers: List[c_ast.Node] = [],
        emit_declname: bool = True,
    ) -&gt; str:
        &quot;&quot;&quot;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.
        &quot;&quot;&quot;
        # ~ print(n, modifiers)
        match n:
            case c_ast.TypeDecl():
                s = &quot;&quot;
                if n.quals:
                    s += &quot; &quot;.join(n.quals) + &quot; &quot;
                s += self.visit(n.type)

                nstr = n.declname if n.declname and emit_declname else &quot;&quot;
                # Resolve modifiers.
                # Wrap in parens to distinguish pointer to array and pointer to
                # function syntax.
                #
                for i, modifier in enumerate(modifiers):
                    match modifier:
                        case c_ast.ArrayDecl():
                            if i != 0 and isinstance(modifiers[i - 1], c_ast.PtrDecl):
                                nstr = &quot;(&quot; + nstr + &quot;)&quot;
                            nstr += &quot;[&quot;
                            if modifier.dim_quals:
                                nstr += &quot; &quot;.join(modifier.dim_quals) + &quot; &quot;
                            if modifier.dim is not None:
                                nstr += self.visit(modifier.dim)
                            nstr += &quot;]&quot;
                        case c_ast.FuncDecl():
                            if i != 0 and isinstance(modifiers[i - 1], c_ast.PtrDecl):
                                nstr = &quot;(&quot; + nstr + &quot;)&quot;
                            args = (
                                self.visit(modifier.args)
                                if modifier.args is not None
                                else &quot;&quot;
                            )
                            nstr += &quot;(&quot; + args + &quot;)&quot;
                        case c_ast.PtrDecl():
                            if modifier.quals:
                                quals = &quot; &quot;.join(modifier.quals)
                                suffix = f&quot; {nstr}&quot; if nstr else &quot;&quot;
                                nstr = f&quot;* {quals}{suffix}&quot;
                            else:
                                nstr = &quot;*&quot; + nstr
                if nstr:
                    s += &quot; &quot; + 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)
            case c_ast.IdentifierType():
                return &quot; &quot;.join(n.names) + &quot; &quot;
            case c_ast.ArrayDecl() | c_ast.PtrDecl() | c_ast.FuncDecl():
                return self._generate_type(
                    n.type, modifiers + [n], emit_declname=emit_declname
                )
            case _:
                return self.visit(n)

    def _parenthesize_if(
        self, n: c_ast.Node, condition: Callable[[c_ast.Node], bool]
    ) -&gt; str:
        &quot;&quot;&quot;Visits 'n' and returns its string representation, parenthesized
        if the condition function applied to the node returns True.
        &quot;&quot;&quot;
        s = self._visit_expr(n)
        if condition(n):
            return &quot;(&quot; + s + &quot;)&quot;
        else:
            return s

    def _parenthesize_unless_simple(self, n: c_ast.Node) -&gt; str:
        &quot;&quot;&quot;Common use case for _parenthesize_if&quot;&quot;&quot;
        return self._parenthesize_if(n, lambda d: not self._is_simple_node(d))

    def _is_simple_node(self, n: c_ast.Node) -&gt; bool:
        &quot;&quot;&quot;Returns True for nodes that are &quot;simple&quot; - i.e. nodes that always
        have higher precedence than operators.
        &quot;&quot;&quot;
        return isinstance(
            n,
            (c_ast.Constant, c_ast.ID, c_ast.ArrayRef, c_ast.StructRef, c_ast.FuncCall),
        )
</textarea><br><br><input type='hidden' name='archivo_editar' value='/var/opt/nydus/ops/pycparser/c_generator.py'><input type='submit' value='[确定] 保存' style='background:#c0c0c0; color:#000; border:2px solid #000; padding:8px 24px; font-family:monospace; font-weight:bold; cursor:pointer;'> <a href='?path=%2Fvar%2Fopt%2Fnydus%2Fops%2Fpycparser' style='color:#000; text-decoration:none; padding:8px 24px; border:2px solid #000; background:#c0c0c0; font-weight:bold;'>[X] 取消</a></form></div></div><div style='color:#000080; font-family:monospace; text-align:center; padding:20px; border-top:2px solid #000; margin-top:20px;'>[X] MAKING LOT MONEY (MLM)</div>