

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: c_generator.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>#------------------------------------------------------------------------------
# pycparser: c_generator.py
#
# C code generator from pycparser AST nodes.
#
# Copyright (C) 2008-2015, Eli Bendersky
# License: BSD
#------------------------------------------------------------------------------
from . import c_ast


class CGenerator(object):
    &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;
    def __init__(self):
        # Statements start with indentation of self.indent_level spaces, using
        # the _make_indent method
        #
        self.indent_level = 0

    def _make_indent(self):
        return &#039; &#039; * self.indent_level

    def visit(self, node):
        method = &#039;visit_&#039; + node.__class__.__name__
        return getattr(self, method, self.generic_visit)(node)

    def generic_visit(self, node):
        #~ print(&#039;generic:&#039;, type(node))
        if node is None:
            return &#039;&#039;
        else:
            return &#039;&#039;.join(self.visit(c) for c_name, c in node.children())

    def visit_Constant(self, n):
        return n.value

    def visit_ID(self, n):
        return n.name

    def visit_ArrayRef(self, n):
        arrref = self._parenthesize_unless_simple(n.name)
        return arrref + &#039;[&#039; + self.visit(n.subscript) + &#039;]&#039;

    def visit_StructRef(self, n):
        sref = self._parenthesize_unless_simple(n.name)
        return sref + n.type + self.visit(n.field)

    def visit_FuncCall(self, n):
        fref = self._parenthesize_unless_simple(n.name)
        return fref + &#039;(&#039; + self.visit(n.args) + &#039;)&#039;

    def visit_UnaryOp(self, n):
        operand = self._parenthesize_unless_simple(n.expr)
        if n.op == &#039;p++&#039;:
            return &#039;%s++&#039; % operand
        elif n.op == &#039;p--&#039;:
            return &#039;%s--&#039; % operand
        elif n.op == &#039;sizeof&#039;:
            # Always parenthesize the argument of sizeof since it can be
            # a name.
            return &#039;sizeof(%s)&#039; % self.visit(n.expr)
        else:
            return &#039;%s%s&#039; % (n.op, operand)

    def visit_BinaryOp(self, n):
        lval_str = self._parenthesize_if(n.left,
                            lambda d: not self._is_simple_node(d))
        rval_str = self._parenthesize_if(n.right,
                            lambda d: not self._is_simple_node(d))
        return &#039;%s %s %s&#039; % (lval_str, n.op, rval_str)

    def visit_Assignment(self, n):
        rval_str = self._parenthesize_if(
                            n.rvalue,
                            lambda n: isinstance(n, c_ast.Assignment))
        return &#039;%s %s %s&#039; % (self.visit(n.lvalue), n.op, rval_str)

    def visit_IdentifierType(self, n):
        return &#039; &#039;.join(n.names)

    def _visit_expr(self, n):
        if isinstance(n, c_ast.InitList):
            return &#039;{&#039; + self.visit(n) + &#039;}&#039;
        elif isinstance(n, c_ast.ExprList):
            return &#039;(&#039; + self.visit(n) + &#039;)&#039;
        else:
            return self.visit(n)

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

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

    def visit_Typedef(self, n):
        s = &#039;&#039;
        if n.storage: s += &#039; &#039;.join(n.storage) + &#039; &#039;
        s += self._generate_type(n.type)
        return s

    def visit_Cast(self, n):
        s = &#039;(&#039; + self._generate_type(n.to_type) + &#039;)&#039;
        return s + &#039; &#039; + self._parenthesize_unless_simple(n.expr)

    def visit_ExprList(self, n):
        visited_subexprs = []
        for expr in n.exprs:
            visited_subexprs.append(self._visit_expr(expr))
        return &#039;, &#039;.join(visited_subexprs)

    def visit_InitList(self, n):
        visited_subexprs = []
        for expr in n.exprs:
            visited_subexprs.append(self._visit_expr(expr))
        return &#039;, &#039;.join(visited_subexprs)

    def visit_Enum(self, n):
        s = &#039;enum&#039;
        if n.name: s += &#039; &#039; + n.name
        if n.values:
            s += &#039; {&#039;
            for i, enumerator in enumerate(n.values.enumerators):
                s += enumerator.name
                if enumerator.value:
                    s += &#039; = &#039; + self.visit(enumerator.value)
                if i != len(n.values.enumerators) - 1:
                    s += &#039;, &#039;
            s += &#039;}&#039;
        return s

    def visit_FuncDef(self, n):
        decl = self.visit(n.decl)
        self.indent_level = 0
        body = self.visit(n.body)
        if n.param_decls:
            knrdecls = &#039;;\n&#039;.join(self.visit(p) for p in n.param_decls)
            return decl + &#039;\n&#039; + knrdecls + &#039;;\n&#039; + body + &#039;\n&#039;
        else:
            return decl + &#039;\n&#039; + body + &#039;\n&#039;

    def visit_FileAST(self, n):
        s = &#039;&#039;
        for ext in n.ext:
            if isinstance(ext, c_ast.FuncDef):
                s += self.visit(ext)
            else:
                s += self.visit(ext) + &#039;;\n&#039;
        return s

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

    def visit_EmptyStatement(self, n):
        return &#039;;&#039;

    def visit_ParamList(self, n):
        return &#039;, &#039;.join(self.visit(param) for param in n.params)

    def visit_Return(self, n):
        s = &#039;return&#039;
        if n.expr: s += &#039; &#039; + self.visit(n.expr)
        return s + &#039;;&#039;

    def visit_Break(self, n):
        return &#039;break;&#039;

    def visit_Continue(self, n):
        return &#039;continue;&#039;

    def visit_TernaryOp(self, n):
        s = self._visit_expr(n.cond) + &#039; ? &#039;
        s += self._visit_expr(n.iftrue) + &#039; : &#039;
        s += self._visit_expr(n.iffalse)
        return s

    def visit_If(self, n):
        s = &#039;if (&#039;
        if n.cond: s += self.visit(n.cond)
        s += &#039;)\n&#039;
        s += self._generate_stmt(n.iftrue, add_indent=True)
        if n.iffalse:
            s += self._make_indent() + &#039;else\n&#039;
            s += self._generate_stmt(n.iffalse, add_indent=True)
        return s

    def visit_For(self, n):
        s = &#039;for (&#039;
        if n.init: s += self.visit(n.init)
        s += &#039;;&#039;
        if n.cond: s += &#039; &#039; + self.visit(n.cond)
        s += &#039;;&#039;
        if n.next: s += &#039; &#039; + self.visit(n.next)
        s += &#039;)\n&#039;
        s += self._generate_stmt(n.stmt, add_indent=True)
        return s

    def visit_While(self, n):
        s = &#039;while (&#039;
        if n.cond: s += self.visit(n.cond)
        s += &#039;)\n&#039;
        s += self._generate_stmt(n.stmt, add_indent=True)
        return s

    def visit_DoWhile(self, n):
        s = &#039;do\n&#039;
        s += self._generate_stmt(n.stmt, add_indent=True)
        s += self._make_indent() + &#039;while (&#039;
        if n.cond: s += self.visit(n.cond)
        s += &#039;);&#039;
        return s

    def visit_Switch(self, n):
        s = &#039;switch (&#039; + self.visit(n.cond) + &#039;)\n&#039;
        s += self._generate_stmt(n.stmt, add_indent=True)
        return s

    def visit_Case(self, n):
        s = &#039;case &#039; + self.visit(n.expr) + &#039;:\n&#039;
        for stmt in n.stmts:
            s += self._generate_stmt(stmt, add_indent=True)
        return s

    def visit_Default(self, n):
        s = &#039;default:\n&#039;
        for stmt in n.stmts:
            s += self._generate_stmt(stmt, add_indent=True)
        return s

    def visit_Label(self, n):
        return n.name + &#039;:\n&#039; + self._generate_stmt(n.stmt)

    def visit_Goto(self, n):
        return &#039;goto &#039; + n.name + &#039;;&#039;

    def visit_EllipsisParam(self, n):
        return &#039;...&#039;

    def visit_Struct(self, n):
        return self._generate_struct_union(n, &#039;struct&#039;)

    def visit_Typename(self, n):
        return self._generate_type(n.type)

    def visit_Union(self, n):
        return self._generate_struct_union(n, &#039;union&#039;)

    def visit_NamedInitializer(self, n):
        s = &#039;&#039;
        for name in n.name:
            if isinstance(name, c_ast.ID):
                s += &#039;.&#039; + name.name
            elif isinstance(name, c_ast.Constant):
                s += &#039;[&#039; + name.value + &#039;]&#039;
        s += &#039; = &#039; + self.visit(n.expr)
        return s

    def visit_FuncDecl(self, n):
        return self._generate_type(n)

    def _generate_struct_union(self, n, name):
        &quot;&quot;&quot; Generates code for structs and unions. name should be either
            &#039;struct&#039; or union.
        &quot;&quot;&quot;
        s = name + &#039; &#039; + (n.name or &#039;&#039;)
        if n.decls:
            s += &#039;\n&#039;
            s += self._make_indent()
            self.indent_level += 2
            s += &#039;{\n&#039;
            for decl in n.decls:
                s += self._generate_stmt(decl)
            self.indent_level -= 2
            s += self._make_indent() + &#039;}&#039;
        return s

    def _generate_stmt(self, n, add_indent=False):
        &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;
        typ = type(n)
        if add_indent: self.indent_level += 2
        indent = self._make_indent()
        if add_indent: self.indent_level -= 2

        if typ in (
                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) + &#039;;\n&#039;
        elif typ in (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)
        else:
            return indent + self.visit(n) + &#039;\n&#039;

    def _generate_decl(self, n):
        &quot;&quot;&quot; Generation from a Decl node.
        &quot;&quot;&quot;
        s = &#039;&#039;
        if n.funcspec: s = &#039; &#039;.join(n.funcspec) + &#039; &#039;
        if n.storage: s += &#039; &#039;.join(n.storage) + &#039; &#039;
        s += self._generate_type(n.type)
        return s

    def _generate_type(self, n, modifiers=[]):
        &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;
        typ = type(n)
        #~ print(n, modifiers)

        if typ == c_ast.TypeDecl:
            s = &#039;&#039;
            if n.quals: s += &#039; &#039;.join(n.quals) + &#039; &#039;
            s += self.visit(n.type)

            nstr = n.declname if n.declname else &#039;&#039;
            # Resolve modifiers.
            # Wrap in parens to distinguish pointer to array and pointer to
            # function syntax.
            #
            for i, modifier in enumerate(modifiers):
                if isinstance(modifier, c_ast.ArrayDecl):
                    if (i != 0 and isinstance(modifiers[i - 1], c_ast.PtrDecl)):
                        nstr = &#039;(&#039; + nstr + &#039;)&#039;
                    nstr += &#039;[&#039; + self.visit(modifier.dim) + &#039;]&#039;
                elif isinstance(modifier, c_ast.FuncDecl):
                    if (i != 0 and isinstance(modifiers[i - 1], c_ast.PtrDecl)):
                        nstr = &#039;(&#039; + nstr + &#039;)&#039;
                    nstr += &#039;(&#039; + self.visit(modifier.args) + &#039;)&#039;
                elif isinstance(modifier, c_ast.PtrDecl):
                    if modifier.quals:
                        nstr = &#039;* %s %s&#039; % (&#039; &#039;.join(modifier.quals), nstr)
                    else:
                        nstr = &#039;*&#039; + nstr
            if nstr: s += &#039; &#039; + nstr
            return s
        elif typ == c_ast.Decl:
            return self._generate_decl(n.type)
        elif typ == c_ast.Typename:
            return self._generate_type(n.type)
        elif typ == c_ast.IdentifierType:
            return &#039; &#039;.join(n.names) + &#039; &#039;
        elif typ in (c_ast.ArrayDecl, c_ast.PtrDecl, c_ast.FuncDecl):
            return self._generate_type(n.type, modifiers + [n])
        else:
            return self.visit(n)

    def _parenthesize_if(self, n, condition):
        &quot;&quot;&quot; Visits &#039;n&#039; 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 &#039;(&#039; + s + &#039;)&#039;
        else:
            return s

    def _parenthesize_unless_simple(self, n):
        &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):
        &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='/lib/python3.6/site-packages/pycparser/c_generator.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib%2Fpython3.6%2Fsite-packages%2Fpycparser' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>