

<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_parser.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_parser.py
#
# CParser class: Parser and AST builder for the C language
#
# Copyright (C) 2008-2015, Eli Bendersky
# License: BSD
#------------------------------------------------------------------------------
import re

from ply import yacc

from . import c_ast
from .c_lexer import CLexer
from .plyparser import PLYParser, Coord, ParseError
from .ast_transforms import fix_switch_cases


class CParser(PLYParser):
    def __init__(
            self,
            lex_optimize=True,
            lextab=&#039;pycparser.lextab&#039;,
            yacc_optimize=True,
            yacctab=&#039;pycparser.yacctab&#039;,
            yacc_debug=False,
            taboutputdir=&#039;&#039;):
        &quot;&quot;&quot; Create a new CParser.

            Some arguments for controlling the debug/optimization
            level of the parser are provided. The defaults are
            tuned for release/performance mode.
            The simple rules for using them are:
            *) When tweaking CParser/CLexer, set these to False
            *) When releasing a stable parser, set to True

            lex_optimize:
                Set to False when you&#039;re modifying the lexer.
                Otherwise, changes in the lexer won&#039;t be used, if
                some lextab.py file exists.
                When releasing with a stable lexer, set to True
                to save the re-generation of the lexer table on
                each run.

            lextab:
                Points to the lex table that&#039;s used for optimized
                mode. Only if you&#039;re modifying the lexer and want
                some tests to avoid re-generating the table, make
                this point to a local lex table file (that&#039;s been
                earlier generated with lex_optimize=True)

            yacc_optimize:
                Set to False when you&#039;re modifying the parser.
                Otherwise, changes in the parser won&#039;t be used, if
                some parsetab.py file exists.
                When releasing with a stable parser, set to True
                to save the re-generation of the parser table on
                each run.

            yacctab:
                Points to the yacc table that&#039;s used for optimized
                mode. Only if you&#039;re modifying the parser, make
                this point to a local yacc table file

            yacc_debug:
                Generate a parser.out file that explains how yacc
                built the parsing table from the grammar.

            taboutputdir:
                Set this parameter to control the location of generated
                lextab and yacctab files.
        &quot;&quot;&quot;
        self.clex = CLexer(
            error_func=self._lex_error_func,
            on_lbrace_func=self._lex_on_lbrace_func,
            on_rbrace_func=self._lex_on_rbrace_func,
            type_lookup_func=self._lex_type_lookup_func)

        self.clex.build(
            optimize=lex_optimize,
            lextab=lextab,
            outputdir=taboutputdir)
        self.tokens = self.clex.tokens

        rules_with_opt = [
            &#039;abstract_declarator&#039;,
            &#039;assignment_expression&#039;,
            &#039;declaration_list&#039;,
            &#039;declaration_specifiers&#039;,
            &#039;designation&#039;,
            &#039;expression&#039;,
            &#039;identifier_list&#039;,
            &#039;init_declarator_list&#039;,
            &#039;initializer_list&#039;,
            &#039;parameter_type_list&#039;,
            &#039;specifier_qualifier_list&#039;,
            &#039;block_item_list&#039;,
            &#039;type_qualifier_list&#039;,
            &#039;struct_declarator_list&#039;
        ]

        for rule in rules_with_opt:
            self._create_opt_rule(rule)

        self.cparser = yacc.yacc(
            module=self,
            start=&#039;translation_unit_or_empty&#039;,
            debug=yacc_debug,
            optimize=yacc_optimize,
            tabmodule=yacctab,
            outputdir=taboutputdir)

        # Stack of scopes for keeping track of symbols. _scope_stack[-1] is
        # the current (topmost) scope. Each scope is a dictionary that
        # specifies whether a name is a type. If _scope_stack[n][name] is
        # True, &#039;name&#039; is currently a type in the scope. If it&#039;s False,
        # &#039;name&#039; is used in the scope but not as a type (for instance, if we
        # saw: int name;
        # If &#039;name&#039; is not a key in _scope_stack[n] then &#039;name&#039; was not defined
        # in this scope at all.
        self._scope_stack = [dict()]

        # Keeps track of the last token given to yacc (the lookahead token)
        self._last_yielded_token = None

    def parse(self, text, filename=&#039;&#039;, debuglevel=0):
        &quot;&quot;&quot; Parses C code and returns an AST.

            text:
                A string containing the C source code

            filename:
                Name of the file being parsed (for meaningful
                error messages)

            debuglevel:
                Debug level to yacc
        &quot;&quot;&quot;
        self.clex.filename = filename
        self.clex.reset_lineno()
        self._scope_stack = [dict()]
        self._last_yielded_token = None
        return self.cparser.parse(
                input=text,
                lexer=self.clex,
                debug=debuglevel)

    ######################--   PRIVATE   --######################

    def _push_scope(self):
        self._scope_stack.append(dict())

    def _pop_scope(self):
        assert len(self._scope_stack) &gt; 1
        self._scope_stack.pop()

    def _add_typedef_name(self, name, coord):
        &quot;&quot;&quot; Add a new typedef name (ie a TYPEID) to the current scope
        &quot;&quot;&quot;
        if not self._scope_stack[-1].get(name, True):
            self._parse_error(
                &quot;Typedef %r previously declared as non-typedef &quot;
                &quot;in this scope&quot; % name, coord)
        self._scope_stack[-1][name] = True

    def _add_identifier(self, name, coord):
        &quot;&quot;&quot; Add a new object, function, or enum member name (ie an ID) to the
            current scope
        &quot;&quot;&quot;
        if self._scope_stack[-1].get(name, False):
            self._parse_error(
                &quot;Non-typedef %r previously declared as typedef &quot;
                &quot;in this scope&quot; % name, coord)
        self._scope_stack[-1][name] = False

    def _is_type_in_scope(self, name):
        &quot;&quot;&quot; Is *name* a typedef-name in the current scope?
        &quot;&quot;&quot;
        for scope in reversed(self._scope_stack):
            # If name is an identifier in this scope it shadows typedefs in
            # higher scopes.
            in_scope = scope.get(name)
            if in_scope is not None: return in_scope
        return False

    def _lex_error_func(self, msg, line, column):
        self._parse_error(msg, self._coord(line, column))

    def _lex_on_lbrace_func(self):
        self._push_scope()

    def _lex_on_rbrace_func(self):
        self._pop_scope()

    def _lex_type_lookup_func(self, name):
        &quot;&quot;&quot; Looks up types that were previously defined with
            typedef.
            Passed to the lexer for recognizing identifiers that
            are types.
        &quot;&quot;&quot;
        is_type = self._is_type_in_scope(name)
        return is_type

    def _get_yacc_lookahead_token(self):
        &quot;&quot;&quot; We need access to yacc&#039;s lookahead token in certain cases.
            This is the last token yacc requested from the lexer, so we
            ask the lexer.
        &quot;&quot;&quot;
        return self.clex.last_token

    # To understand what&#039;s going on here, read sections A.8.5 and
    # A.8.6 of K&amp;R2 very carefully.
    #
    # A C type consists of a basic type declaration, with a list
    # of modifiers. For example:
    #
    # int *c[5];
    #
    # The basic declaration here is &#039;int c&#039;, and the pointer and
    # the array are the modifiers.
    #
    # Basic declarations are represented by TypeDecl (from module c_ast) and the
    # modifiers are FuncDecl, PtrDecl and ArrayDecl.
    #
    # The standard states that whenever a new modifier is parsed, it should be
    # added to the end of the list of modifiers. For example:
    #
    # K&amp;R2 A.8.6.2: Array Declarators
    #
    # In a declaration T D where D has the form
    #   D1 [constant-expression-opt]
    # and the type of the identifier in the declaration T D1 is
    # &quot;type-modifier T&quot;, the type of the
    # identifier of D is &quot;type-modifier array of T&quot;
    #
    # This is what this method does. The declarator it receives
    # can be a list of declarators ending with TypeDecl. It
    # tacks the modifier to the end of this list, just before
    # the TypeDecl.
    #
    # Additionally, the modifier may be a list itself. This is
    # useful for pointers, that can come as a chain from the rule
    # p_pointer. In this case, the whole modifier list is spliced
    # into the new location.
    def _type_modify_decl(self, decl, modifier):
        &quot;&quot;&quot; Tacks a type modifier on a declarator, and returns
            the modified declarator.

            Note: the declarator and modifier may be modified
        &quot;&quot;&quot;
        #~ print &#039;****&#039;
        #~ decl.show(offset=3)
        #~ modifier.show(offset=3)
        #~ print &#039;****&#039;

        modifier_head = modifier
        modifier_tail = modifier

        # The modifier may be a nested list. Reach its tail.
        #
        while modifier_tail.type:
            modifier_tail = modifier_tail.type

        # If the decl is a basic type, just tack the modifier onto
        # it
        #
        if isinstance(decl, c_ast.TypeDecl):
            modifier_tail.type = decl
            return modifier
        else:
            # Otherwise, the decl is a list of modifiers. Reach
            # its tail and splice the modifier onto the tail,
            # pointing to the underlying basic type.
            #
            decl_tail = decl

            while not isinstance(decl_tail.type, c_ast.TypeDecl):
                decl_tail = decl_tail.type

            modifier_tail.type = decl_tail.type
            decl_tail.type = modifier_head
            return decl

    # Due to the order in which declarators are constructed,
    # they have to be fixed in order to look like a normal AST.
    #
    # When a declaration arrives from syntax construction, it has
    # these problems:
    # * The innermost TypeDecl has no type (because the basic
    #   type is only known at the uppermost declaration level)
    # * The declaration has no variable name, since that is saved
    #   in the innermost TypeDecl
    # * The typename of the declaration is a list of type
    #   specifiers, and not a node. Here, basic identifier types
    #   should be separated from more complex types like enums
    #   and structs.
    #
    # This method fixes these problems.
    #
    def _fix_decl_name_type(self, decl, typename):
        &quot;&quot;&quot; Fixes a declaration. Modifies decl.
        &quot;&quot;&quot;
        # Reach the underlying basic type
        #
        type = decl
        while not isinstance(type, c_ast.TypeDecl):
            type = type.type

        decl.name = type.declname
        type.quals = decl.quals

        # The typename is a list of types. If any type in this
        # list isn&#039;t an IdentifierType, it must be the only
        # type in the list (it&#039;s illegal to declare &quot;int enum ..&quot;)
        # If all the types are basic, they&#039;re collected in the
        # IdentifierType holder.
        #
        for tn in typename:
            if not isinstance(tn, c_ast.IdentifierType):
                if len(typename) &gt; 1:
                    self._parse_error(
                        &quot;Invalid multiple types specified&quot;, tn.coord)
                else:
                    type.type = tn
                    return decl

        if not typename:
            # Functions default to returning int
            #
            if not isinstance(decl.type, c_ast.FuncDecl):
                self._parse_error(
                        &quot;Missing type in declaration&quot;, decl.coord)
            type.type = c_ast.IdentifierType(
                    [&#039;int&#039;],
                    coord=decl.coord)
        else:
            # At this point, we know that typename is a list of IdentifierType
            # nodes. Concatenate all the names into a single list.
            #
            type.type = c_ast.IdentifierType(
                [name for id in typename for name in id.names],
                coord=typename[0].coord)
        return decl

    def _add_declaration_specifier(self, declspec, newspec, kind):
        &quot;&quot;&quot; Declaration specifiers are represented by a dictionary
            with the entries:
            * qual: a list of type qualifiers
            * storage: a list of storage type qualifiers
            * type: a list of type specifiers
            * function: a list of function specifiers

            This method is given a declaration specifier, and a
            new specifier of a given kind.
            Returns the declaration specifier, with the new
            specifier incorporated.
        &quot;&quot;&quot;
        spec = declspec or dict(qual=[], storage=[], type=[], function=[])
        spec[kind].insert(0, newspec)
        return spec

    def _build_declarations(self, spec, decls, typedef_namespace=False):
        &quot;&quot;&quot; Builds a list of declarations all sharing the given specifiers.
            If typedef_namespace is true, each declared name is added
            to the &quot;typedef namespace&quot;, which also includes objects,
            functions, and enum constants.
        &quot;&quot;&quot;
        is_typedef = &#039;typedef&#039; in spec[&#039;storage&#039;]
        declarations = []

        # Bit-fields are allowed to be unnamed.
        #
        if decls[0].get(&#039;bitsize&#039;) is not None:
            pass

        # When redeclaring typedef names as identifiers in inner scopes, a
        # problem can occur where the identifier gets grouped into
        # spec[&#039;type&#039;], leaving decl as None.  This can only occur for the
        # first declarator.
        #
        elif decls[0][&#039;decl&#039;] is None:
            if len(spec[&#039;type&#039;]) &lt; 2 or len(spec[&#039;type&#039;][-1].names) != 1 or \
                    not self._is_type_in_scope(spec[&#039;type&#039;][-1].names[0]):
                coord = &#039;?&#039;
                for t in spec[&#039;type&#039;]:
                    if hasattr(t, &#039;coord&#039;):
                        coord = t.coord
                        break
                self._parse_error(&#039;Invalid declaration&#039;, coord)

            # Make this look as if it came from &quot;direct_declarator:ID&quot;
            decls[0][&#039;decl&#039;] = c_ast.TypeDecl(
                declname=spec[&#039;type&#039;][-1].names[0],
                type=None,
                quals=None,
                coord=spec[&#039;type&#039;][-1].coord)
            # Remove the &quot;new&quot; type&#039;s name from the end of spec[&#039;type&#039;]
            del spec[&#039;type&#039;][-1]

        # A similar problem can occur where the declaration ends up looking
        # like an abstract declarator.  Give it a name if this is the case.
        #
        elif not isinstance(decls[0][&#039;decl&#039;],
                (c_ast.Struct, c_ast.Union, c_ast.IdentifierType)):
            decls_0_tail = decls[0][&#039;decl&#039;]
            while not isinstance(decls_0_tail, c_ast.TypeDecl):
                decls_0_tail = decls_0_tail.type
            if decls_0_tail.declname is None:
                decls_0_tail.declname = spec[&#039;type&#039;][-1].names[0]
                del spec[&#039;type&#039;][-1]

        for decl in decls:
            assert decl[&#039;decl&#039;] is not None
            if is_typedef:
                declaration = c_ast.Typedef(
                    name=None,
                    quals=spec[&#039;qual&#039;],
                    storage=spec[&#039;storage&#039;],
                    type=decl[&#039;decl&#039;],
                    coord=decl[&#039;decl&#039;].coord)
            else:
                declaration = c_ast.Decl(
                    name=None,
                    quals=spec[&#039;qual&#039;],
                    storage=spec[&#039;storage&#039;],
                    funcspec=spec[&#039;function&#039;],
                    type=decl[&#039;decl&#039;],
                    init=decl.get(&#039;init&#039;),
                    bitsize=decl.get(&#039;bitsize&#039;),
                    coord=decl[&#039;decl&#039;].coord)

            if isinstance(declaration.type,
                    (c_ast.Struct, c_ast.Union, c_ast.IdentifierType)):
                fixed_decl = declaration
            else:
                fixed_decl = self._fix_decl_name_type(declaration, spec[&#039;type&#039;])

            # Add the type name defined by typedef to a
            # symbol table (for usage in the lexer)
            #
            if typedef_namespace:
                if is_typedef:
                    self._add_typedef_name(fixed_decl.name, fixed_decl.coord)
                else:
                    self._add_identifier(fixed_decl.name, fixed_decl.coord)

            declarations.append(fixed_decl)

        return declarations

    def _build_function_definition(self, spec, decl, param_decls, body):
        &quot;&quot;&quot; Builds a function definition.
        &quot;&quot;&quot;
        assert &#039;typedef&#039; not in spec[&#039;storage&#039;]

        declaration = self._build_declarations(
            spec=spec,
            decls=[dict(decl=decl, init=None)],
            typedef_namespace=True)[0]

        return c_ast.FuncDef(
            decl=declaration,
            param_decls=param_decls,
            body=body,
            coord=decl.coord)

    def _select_struct_union_class(self, token):
        &quot;&quot;&quot; Given a token (either STRUCT or UNION), selects the
            appropriate AST class.
        &quot;&quot;&quot;
        if token == &#039;struct&#039;:
            return c_ast.Struct
        else:
            return c_ast.Union

    ##
    ## Precedence and associativity of operators
    ##
    precedence = (
        (&#039;left&#039;, &#039;LOR&#039;),
        (&#039;left&#039;, &#039;LAND&#039;),
        (&#039;left&#039;, &#039;OR&#039;),
        (&#039;left&#039;, &#039;XOR&#039;),
        (&#039;left&#039;, &#039;AND&#039;),
        (&#039;left&#039;, &#039;EQ&#039;, &#039;NE&#039;),
        (&#039;left&#039;, &#039;GT&#039;, &#039;GE&#039;, &#039;LT&#039;, &#039;LE&#039;),
        (&#039;left&#039;, &#039;RSHIFT&#039;, &#039;LSHIFT&#039;),
        (&#039;left&#039;, &#039;PLUS&#039;, &#039;MINUS&#039;),
        (&#039;left&#039;, &#039;TIMES&#039;, &#039;DIVIDE&#039;, &#039;MOD&#039;)
    )

    ##
    ## Grammar productions
    ## Implementation of the BNF defined in K&amp;R2 A.13
    ##

    # Wrapper around a translation unit, to allow for empty input.
    # Not strictly part of the C99 Grammar, but useful in practice.
    #
    def p_translation_unit_or_empty(self, p):
        &quot;&quot;&quot; translation_unit_or_empty   : translation_unit
                                        | empty
        &quot;&quot;&quot;
        if p[1] is None:
            p[0] = c_ast.FileAST([])
        else:
            p[0] = c_ast.FileAST(p[1])

    def p_translation_unit_1(self, p):
        &quot;&quot;&quot; translation_unit    : external_declaration
        &quot;&quot;&quot;
        # Note: external_declaration is already a list
        #
        p[0] = p[1]

    def p_translation_unit_2(self, p):
        &quot;&quot;&quot; translation_unit    : translation_unit external_declaration
        &quot;&quot;&quot;
        if p[2] is not None:
            p[1].extend(p[2])
        p[0] = p[1]

    # Declarations always come as lists (because they can be
    # several in one line), so we wrap the function definition
    # into a list as well, to make the return value of
    # external_declaration homogenous.
    #
    def p_external_declaration_1(self, p):
        &quot;&quot;&quot; external_declaration    : function_definition
        &quot;&quot;&quot;
        p[0] = [p[1]]

    def p_external_declaration_2(self, p):
        &quot;&quot;&quot; external_declaration    : declaration
        &quot;&quot;&quot;
        p[0] = p[1]

    def p_external_declaration_3(self, p):
        &quot;&quot;&quot; external_declaration    : pp_directive
        &quot;&quot;&quot;
        p[0] = p[1]

    def p_external_declaration_4(self, p):
        &quot;&quot;&quot; external_declaration    : SEMI
        &quot;&quot;&quot;
        p[0] = None

    def p_pp_directive(self, p):
        &quot;&quot;&quot; pp_directive  : PPHASH
        &quot;&quot;&quot;
        self._parse_error(&#039;Directives not supported yet&#039;,
            self._coord(p.lineno(1)))

    # In function definitions, the declarator can be followed by
    # a declaration list, for old &quot;K&amp;R style&quot; function definitios.
    #
    def p_function_definition_1(self, p):
        &quot;&quot;&quot; function_definition : declarator declaration_list_opt compound_statement
        &quot;&quot;&quot;
        # no declaration specifiers - &#039;int&#039; becomes the default type
        spec = dict(
            qual=[],
            storage=[],
            type=[c_ast.IdentifierType([&#039;int&#039;],
                                       coord=self._coord(p.lineno(1)))],
            function=[])

        p[0] = self._build_function_definition(
            spec=spec,
            decl=p[1],
            param_decls=p[2],
            body=p[3])

    def p_function_definition_2(self, p):
        &quot;&quot;&quot; function_definition : declaration_specifiers declarator declaration_list_opt compound_statement
        &quot;&quot;&quot;
        spec = p[1]

        p[0] = self._build_function_definition(
            spec=spec,
            decl=p[2],
            param_decls=p[3],
            body=p[4])

    def p_statement(self, p):
        &quot;&quot;&quot; statement   : labeled_statement
                        | expression_statement
                        | compound_statement
                        | selection_statement
                        | iteration_statement
                        | jump_statement
        &quot;&quot;&quot;
        p[0] = p[1]

    # In C, declarations can come several in a line:
    #   int x, *px, romulo = 5;
    #
    # However, for the AST, we will split them to separate Decl
    # nodes.
    #
    # This rule splits its declarations and always returns a list
    # of Decl nodes, even if it&#039;s one element long.
    #
    def p_decl_body(self, p):
        &quot;&quot;&quot; decl_body : declaration_specifiers init_declarator_list_opt
        &quot;&quot;&quot;
        spec = p[1]

        # p[2] (init_declarator_list_opt) is either a list or None
        #
        if p[2] is None:
            # By the standard, you must have at least one declarator unless
            # declaring a structure tag, a union tag, or the members of an
            # enumeration.
            #
            ty = spec[&#039;type&#039;]
            s_u_or_e = (c_ast.Struct, c_ast.Union, c_ast.Enum)
            if len(ty) == 1 and isinstance(ty[0], s_u_or_e):
                decls = [c_ast.Decl(
                    name=None,
                    quals=spec[&#039;qual&#039;],
                    storage=spec[&#039;storage&#039;],
                    funcspec=spec[&#039;function&#039;],
                    type=ty[0],
                    init=None,
                    bitsize=None,
                    coord=ty[0].coord)]

            # However, this case can also occur on redeclared identifiers in
            # an inner scope.  The trouble is that the redeclared type&#039;s name
            # gets grouped into declaration_specifiers; _build_declarations
            # compensates for this.
            #
            else:
                decls = self._build_declarations(
                    spec=spec,
                    decls=[dict(decl=None, init=None)],
                    typedef_namespace=True)

        else:
            decls = self._build_declarations(
                spec=spec,
                decls=p[2],
                typedef_namespace=True)

        p[0] = decls

    # The declaration has been split to a decl_body sub-rule and
    # SEMI, because having them in a single rule created a problem
    # for defining typedefs.
    #
    # If a typedef line was directly followed by a line using the
    # type defined with the typedef, the type would not be
    # recognized. This is because to reduce the declaration rule,
    # the parser&#039;s lookahead asked for the token after SEMI, which
    # was the type from the next line, and the lexer had no chance
    # to see the updated type symbol table.
    #
    # Splitting solves this problem, because after seeing SEMI,
    # the parser reduces decl_body, which actually adds the new
    # type into the table to be seen by the lexer before the next
    # line is reached.
    def p_declaration(self, p):
        &quot;&quot;&quot; declaration : decl_body SEMI
        &quot;&quot;&quot;
        p[0] = p[1]

    # Since each declaration is a list of declarations, this
    # rule will combine all the declarations and return a single
    # list
    #
    def p_declaration_list(self, p):
        &quot;&quot;&quot; declaration_list    : declaration
                                | declaration_list declaration
        &quot;&quot;&quot;
        p[0] = p[1] if len(p) == 2 else p[1] + p[2]

    def p_declaration_specifiers_1(self, p):
        &quot;&quot;&quot; declaration_specifiers  : type_qualifier declaration_specifiers_opt
        &quot;&quot;&quot;
        p[0] = self._add_declaration_specifier(p[2], p[1], &#039;qual&#039;)

    def p_declaration_specifiers_2(self, p):
        &quot;&quot;&quot; declaration_specifiers  : type_specifier declaration_specifiers_opt
        &quot;&quot;&quot;
        p[0] = self._add_declaration_specifier(p[2], p[1], &#039;type&#039;)

    def p_declaration_specifiers_3(self, p):
        &quot;&quot;&quot; declaration_specifiers  : storage_class_specifier declaration_specifiers_opt
        &quot;&quot;&quot;
        p[0] = self._add_declaration_specifier(p[2], p[1], &#039;storage&#039;)

    def p_declaration_specifiers_4(self, p):
        &quot;&quot;&quot; declaration_specifiers  : function_specifier declaration_specifiers_opt
        &quot;&quot;&quot;
        p[0] = self._add_declaration_specifier(p[2], p[1], &#039;function&#039;)

    def p_storage_class_specifier(self, p):
        &quot;&quot;&quot; storage_class_specifier : AUTO
                                    | REGISTER
                                    | STATIC
                                    | EXTERN
                                    | TYPEDEF
        &quot;&quot;&quot;
        p[0] = p[1]

    def p_function_specifier(self, p):
        &quot;&quot;&quot; function_specifier  : INLINE
        &quot;&quot;&quot;
        p[0] = p[1]

    def p_type_specifier_1(self, p):
        &quot;&quot;&quot; type_specifier  : VOID
                            | _BOOL
                            | CHAR
                            | SHORT
                            | INT
                            | LONG
                            | FLOAT
                            | DOUBLE
                            | _COMPLEX
                            | SIGNED
                            | UNSIGNED
        &quot;&quot;&quot;
        p[0] = c_ast.IdentifierType([p[1]], coord=self._coord(p.lineno(1)))

    def p_type_specifier_2(self, p):
        &quot;&quot;&quot; type_specifier  : typedef_name
                            | enum_specifier
                            | struct_or_union_specifier
        &quot;&quot;&quot;
        p[0] = p[1]

    def p_type_qualifier(self, p):
        &quot;&quot;&quot; type_qualifier  : CONST
                            | RESTRICT
                            | VOLATILE
        &quot;&quot;&quot;
        p[0] = p[1]

    def p_init_declarator_list_1(self, p):
        &quot;&quot;&quot; init_declarator_list    : init_declarator
                                    | init_declarator_list COMMA init_declarator
        &quot;&quot;&quot;
        p[0] = p[1] + [p[3]] if len(p) == 4 else [p[1]]

    # If the code is declaring a variable that was declared a typedef in an
    # outer scope, yacc will think the name is part of declaration_specifiers,
    # not init_declarator, and will then get confused by EQUALS.  Pass None
    # up in place of declarator, and handle this at a higher level.
    #
    def p_init_declarator_list_2(self, p):
        &quot;&quot;&quot; init_declarator_list    : EQUALS initializer
        &quot;&quot;&quot;
        p[0] = [dict(decl=None, init=p[2])]

    # Similarly, if the code contains duplicate typedefs of, for example,
    # array types, the array portion will appear as an abstract declarator.
    #
    def p_init_declarator_list_3(self, p):
        &quot;&quot;&quot; init_declarator_list    : abstract_declarator
        &quot;&quot;&quot;
        p[0] = [dict(decl=p[1], init=None)]

    # Returns a {decl=&lt;declarator&gt; : init=&lt;initializer&gt;} dictionary
    # If there&#039;s no initializer, uses None
    #
    def p_init_declarator(self, p):
        &quot;&quot;&quot; init_declarator : declarator
                            | declarator EQUALS initializer
        &quot;&quot;&quot;
        p[0] = dict(decl=p[1], init=(p[3] if len(p) &gt; 2 else None))

    def p_specifier_qualifier_list_1(self, p):
        &quot;&quot;&quot; specifier_qualifier_list    : type_qualifier specifier_qualifier_list_opt
        &quot;&quot;&quot;
        p[0] = self._add_declaration_specifier(p[2], p[1], &#039;qual&#039;)

    def p_specifier_qualifier_list_2(self, p):
        &quot;&quot;&quot; specifier_qualifier_list    : type_specifier specifier_qualifier_list_opt
        &quot;&quot;&quot;
        p[0] = self._add_declaration_specifier(p[2], p[1], &#039;type&#039;)

    # TYPEID is allowed here (and in other struct/enum related tag names), because
    # struct/enum tags reside in their own namespace and can be named the same as types
    #
    def p_struct_or_union_specifier_1(self, p):
        &quot;&quot;&quot; struct_or_union_specifier   : struct_or_union ID
                                        | struct_or_union TYPEID
        &quot;&quot;&quot;
        klass = self._select_struct_union_class(p[1])
        p[0] = klass(
            name=p[2],
            decls=None,
            coord=self._coord(p.lineno(2)))

    def p_struct_or_union_specifier_2(self, p):
        &quot;&quot;&quot; struct_or_union_specifier : struct_or_union brace_open struct_declaration_list brace_close
        &quot;&quot;&quot;
        klass = self._select_struct_union_class(p[1])
        p[0] = klass(
            name=None,
            decls=p[3],
            coord=self._coord(p.lineno(2)))

    def p_struct_or_union_specifier_3(self, p):
        &quot;&quot;&quot; struct_or_union_specifier   : struct_or_union ID brace_open struct_declaration_list brace_close
                                        | struct_or_union TYPEID brace_open struct_declaration_list brace_close
        &quot;&quot;&quot;
        klass = self._select_struct_union_class(p[1])
        p[0] = klass(
            name=p[2],
            decls=p[4],
            coord=self._coord(p.lineno(2)))

    def p_struct_or_union(self, p):
        &quot;&quot;&quot; struct_or_union : STRUCT
                            | UNION
        &quot;&quot;&quot;
        p[0] = p[1]

    # Combine all declarations into a single list
    #
    def p_struct_declaration_list(self, p):
        &quot;&quot;&quot; struct_declaration_list     : struct_declaration
                                        | struct_declaration_list struct_declaration
        &quot;&quot;&quot;
        p[0] = p[1] if len(p) == 2 else p[1] + p[2]

    def p_struct_declaration_1(self, p):
        &quot;&quot;&quot; struct_declaration : specifier_qualifier_list struct_declarator_list_opt SEMI
        &quot;&quot;&quot;
        spec = p[1]
        assert &#039;typedef&#039; not in spec[&#039;storage&#039;]

        if p[2] is not None:
            decls = self._build_declarations(
                spec=spec,
                decls=p[2])

        elif len(spec[&#039;type&#039;]) == 1:
            # Anonymous struct/union, gcc extension, C1x feature.
            # Although the standard only allows structs/unions here, I see no
            # reason to disallow other types since some compilers have typedefs
            # here, and pycparser isn&#039;t about rejecting all invalid code.
            #
            node = spec[&#039;type&#039;][0]
            if isinstance(node, c_ast.Node):
                decl_type = node
            else:
                decl_type = c_ast.IdentifierType(node)

            decls = self._build_declarations(
                spec=spec,
                decls=[dict(decl=decl_type)])

        else:
            # Structure/union members can have the same names as typedefs.
            # The trouble is that the member&#039;s name gets grouped into
            # specifier_qualifier_list; _build_declarations compensates.
            #
            decls = self._build_declarations(
                spec=spec,
                decls=[dict(decl=None, init=None)])

        p[0] = decls

    def p_struct_declaration_2(self, p):
        &quot;&quot;&quot; struct_declaration : specifier_qualifier_list abstract_declarator SEMI
        &quot;&quot;&quot;
        # &quot;Abstract declarator?!&quot;, you ask?  Structure members can have the
        # same names as typedefs.  The trouble is that the member&#039;s name gets
        # grouped into specifier_qualifier_list, leaving any remainder to
        # appear as an abstract declarator, as in:
        #   typedef int Foo;
        #   struct { Foo Foo[3]; };
        #
        p[0] = self._build_declarations(
                spec=p[1],
                decls=[dict(decl=p[2], init=None)])

    def p_struct_declarator_list(self, p):
        &quot;&quot;&quot; struct_declarator_list  : struct_declarator
                                    | struct_declarator_list COMMA struct_declarator
        &quot;&quot;&quot;
        p[0] = p[1] + [p[3]] if len(p) == 4 else [p[1]]

    # struct_declarator passes up a dict with the keys: decl (for
    # the underlying declarator) and bitsize (for the bitsize)
    #
    def p_struct_declarator_1(self, p):
        &quot;&quot;&quot; struct_declarator : declarator
        &quot;&quot;&quot;
        p[0] = {&#039;decl&#039;: p[1], &#039;bitsize&#039;: None}

    def p_struct_declarator_2(self, p):
        &quot;&quot;&quot; struct_declarator   : declarator COLON constant_expression
                                | COLON constant_expression
        &quot;&quot;&quot;
        if len(p) &gt; 3:
            p[0] = {&#039;decl&#039;: p[1], &#039;bitsize&#039;: p[3]}
        else:
            p[0] = {&#039;decl&#039;: c_ast.TypeDecl(None, None, None), &#039;bitsize&#039;: p[2]}

    def p_enum_specifier_1(self, p):
        &quot;&quot;&quot; enum_specifier  : ENUM ID
                            | ENUM TYPEID
        &quot;&quot;&quot;
        p[0] = c_ast.Enum(p[2], None, self._coord(p.lineno(1)))

    def p_enum_specifier_2(self, p):
        &quot;&quot;&quot; enum_specifier  : ENUM brace_open enumerator_list brace_close
        &quot;&quot;&quot;
        p[0] = c_ast.Enum(None, p[3], self._coord(p.lineno(1)))

    def p_enum_specifier_3(self, p):
        &quot;&quot;&quot; enum_specifier  : ENUM ID brace_open enumerator_list brace_close
                            | ENUM TYPEID brace_open enumerator_list brace_close
        &quot;&quot;&quot;
        p[0] = c_ast.Enum(p[2], p[4], self._coord(p.lineno(1)))

    def p_enumerator_list(self, p):
        &quot;&quot;&quot; enumerator_list : enumerator
                            | enumerator_list COMMA
                            | enumerator_list COMMA enumerator
        &quot;&quot;&quot;
        if len(p) == 2:
            p[0] = c_ast.EnumeratorList([p[1]], p[1].coord)
        elif len(p) == 3:
            p[0] = p[1]
        else:
            p[1].enumerators.append(p[3])
            p[0] = p[1]

    def p_enumerator(self, p):
        &quot;&quot;&quot; enumerator  : ID
                        | ID EQUALS constant_expression
        &quot;&quot;&quot;
        if len(p) == 2:
            enumerator = c_ast.Enumerator(
                        p[1], None,
                        self._coord(p.lineno(1)))
        else:
            enumerator = c_ast.Enumerator(
                        p[1], p[3],
                        self._coord(p.lineno(1)))
        self._add_identifier(enumerator.name, enumerator.coord)

        p[0] = enumerator

    def p_declarator_1(self, p):
        &quot;&quot;&quot; declarator  : direct_declarator
        &quot;&quot;&quot;
        p[0] = p[1]

    def p_declarator_2(self, p):
        &quot;&quot;&quot; declarator  : pointer direct_declarator
        &quot;&quot;&quot;
        p[0] = self._type_modify_decl(p[2], p[1])

    # Since it&#039;s impossible for a type to be specified after a pointer, assume
    # it&#039;s intended to be the name for this declaration.  _add_identifier will
    # raise an error if this TYPEID can&#039;t be redeclared.
    #
    def p_declarator_3(self, p):
        &quot;&quot;&quot; declarator  : pointer TYPEID
        &quot;&quot;&quot;
        decl = c_ast.TypeDecl(
            declname=p[2],
            type=None,
            quals=None,
            coord=self._coord(p.lineno(2)))

        p[0] = self._type_modify_decl(decl, p[1])

    def p_direct_declarator_1(self, p):
        &quot;&quot;&quot; direct_declarator   : ID
        &quot;&quot;&quot;
        p[0] = c_ast.TypeDecl(
            declname=p[1],
            type=None,
            quals=None,
            coord=self._coord(p.lineno(1)))

    def p_direct_declarator_2(self, p):
        &quot;&quot;&quot; direct_declarator   : LPAREN declarator RPAREN
        &quot;&quot;&quot;
        p[0] = p[2]

    def p_direct_declarator_3(self, p):
        &quot;&quot;&quot; direct_declarator   : direct_declarator LBRACKET type_qualifier_list_opt assignment_expression_opt RBRACKET
        &quot;&quot;&quot;
        quals = (p[3] if len(p) &gt; 5 else []) or []
        # Accept dimension qualifiers
        # Per C99 6.7.5.3 p7
        arr = c_ast.ArrayDecl(
            type=None,
            dim=p[4] if len(p) &gt; 5 else p[3],
            dim_quals=quals,
            coord=p[1].coord)

        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)

    def p_direct_declarator_4(self, p):
        &quot;&quot;&quot; direct_declarator   : direct_declarator LBRACKET STATIC type_qualifier_list_opt assignment_expression RBRACKET
                                | direct_declarator LBRACKET type_qualifier_list STATIC assignment_expression RBRACKET
        &quot;&quot;&quot;
        # Using slice notation for PLY objects doesn&#039;t work in Python 3 for the
        # version of PLY embedded with pycparser; see PLY Google Code issue 30.
        # Work around that here by listing the two elements separately.
        listed_quals = [item if isinstance(item, list) else [item]
            for item in [p[3],p[4]]]
        dim_quals = [qual for sublist in listed_quals for qual in sublist
            if qual is not None]
        arr = c_ast.ArrayDecl(
            type=None,
            dim=p[5],
            dim_quals=dim_quals,
            coord=p[1].coord)

        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)

    # Special for VLAs
    #
    def p_direct_declarator_5(self, p):
        &quot;&quot;&quot; direct_declarator   : direct_declarator LBRACKET type_qualifier_list_opt TIMES RBRACKET
        &quot;&quot;&quot;
        arr = c_ast.ArrayDecl(
            type=None,
            dim=c_ast.ID(p[4], self._coord(p.lineno(4))),
            dim_quals=p[3] if p[3] != None else [],
            coord=p[1].coord)

        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)

    def p_direct_declarator_6(self, p):
        &quot;&quot;&quot; direct_declarator   : direct_declarator LPAREN parameter_type_list RPAREN
                                | direct_declarator LPAREN identifier_list_opt RPAREN
        &quot;&quot;&quot;
        func = c_ast.FuncDecl(
            args=p[3],
            type=None,
            coord=p[1].coord)

        # To see why _get_yacc_lookahead_token is needed, consider:
        #   typedef char TT;
        #   void foo(int TT) { TT = 10; }
        # Outside the function, TT is a typedef, but inside (starting and
        # ending with the braces) it&#039;s a parameter.  The trouble begins with
        # yacc&#039;s lookahead token.  We don&#039;t know if we&#039;re declaring or
        # defining a function until we see LBRACE, but if we wait for yacc to
        # trigger a rule on that token, then TT will have already been read
        # and incorrectly interpreted as TYPEID.  We need to add the
        # parameters to the scope the moment the lexer sees LBRACE.
        #
        if self._get_yacc_lookahead_token().type == &quot;LBRACE&quot;:
            if func.args is not None:
                for param in func.args.params:
                    if isinstance(param, c_ast.EllipsisParam): break
                    self._add_identifier(param.name, param.coord)

        p[0] = self._type_modify_decl(decl=p[1], modifier=func)

    def p_pointer(self, p):
        &quot;&quot;&quot; pointer : TIMES type_qualifier_list_opt
                    | TIMES type_qualifier_list_opt pointer
        &quot;&quot;&quot;
        coord = self._coord(p.lineno(1))
        # Pointer decls nest from inside out. This is important when different
        # levels have different qualifiers. For example:
        #
        #  char * const * p;
        #
        # Means &quot;pointer to const pointer to char&quot;
        #
        # While: 
        #
        #  char ** const p;
        #
        # Means &quot;const pointer to pointer to char&quot;
        #
        # So when we construct PtrDecl nestings, the leftmost pointer goes in
        # as the most nested type.
        nested_type = c_ast.PtrDecl(quals=p[2] or [], type=None, coord=coord)
        if len(p) &gt; 3:
            tail_type = p[3]
            while tail_type.type is not None:
                tail_type = tail_type.type
            tail_type.type = nested_type
            p[0] = p[3]
        else:
            p[0] = nested_type

    def p_type_qualifier_list(self, p):
        &quot;&quot;&quot; type_qualifier_list : type_qualifier
                                | type_qualifier_list type_qualifier
        &quot;&quot;&quot;
        p[0] = [p[1]] if len(p) == 2 else p[1] + [p[2]]

    def p_parameter_type_list(self, p):
        &quot;&quot;&quot; parameter_type_list : parameter_list
                                | parameter_list COMMA ELLIPSIS
        &quot;&quot;&quot;
        if len(p) &gt; 2:
            p[1].params.append(c_ast.EllipsisParam(self._coord(p.lineno(3))))

        p[0] = p[1]

    def p_parameter_list(self, p):
        &quot;&quot;&quot; parameter_list  : parameter_declaration
                            | parameter_list COMMA parameter_declaration
        &quot;&quot;&quot;
        if len(p) == 2: # single parameter
            p[0] = c_ast.ParamList([p[1]], p[1].coord)
        else:
            p[1].params.append(p[3])
            p[0] = p[1]

    def p_parameter_declaration_1(self, p):
        &quot;&quot;&quot; parameter_declaration   : declaration_specifiers declarator
        &quot;&quot;&quot;
        spec = p[1]
        if not spec[&#039;type&#039;]:
            spec[&#039;type&#039;] = [c_ast.IdentifierType([&#039;int&#039;],
                coord=self._coord(p.lineno(1)))]
        p[0] = self._build_declarations(
            spec=spec,
            decls=[dict(decl=p[2])])[0]

    def p_parameter_declaration_2(self, p):
        &quot;&quot;&quot; parameter_declaration   : declaration_specifiers abstract_declarator_opt
        &quot;&quot;&quot;
        spec = p[1]
        if not spec[&#039;type&#039;]:
            spec[&#039;type&#039;] = [c_ast.IdentifierType([&#039;int&#039;],
                coord=self._coord(p.lineno(1)))]

        # Parameters can have the same names as typedefs.  The trouble is that
        # the parameter&#039;s name gets grouped into declaration_specifiers, making
        # it look like an old-style declaration; compensate.
        #
        if len(spec[&#039;type&#039;]) &gt; 1 and len(spec[&#039;type&#039;][-1].names) == 1 and \
                self._is_type_in_scope(spec[&#039;type&#039;][-1].names[0]):
            decl = self._build_declarations(
                    spec=spec,
                    decls=[dict(decl=p[2], init=None)])[0]

        # This truly is an old-style parameter declaration
        #
        else:
            decl = c_ast.Typename(
                name=&#039;&#039;,
                quals=spec[&#039;qual&#039;],
                type=p[2] or c_ast.TypeDecl(None, None, None),
                coord=self._coord(p.lineno(2)))
            typename = spec[&#039;type&#039;]
            decl = self._fix_decl_name_type(decl, typename)

        p[0] = decl

    def p_identifier_list(self, p):
        &quot;&quot;&quot; identifier_list : identifier
                            | identifier_list COMMA identifier
        &quot;&quot;&quot;
        if len(p) == 2: # single parameter
            p[0] = c_ast.ParamList([p[1]], p[1].coord)
        else:
            p[1].params.append(p[3])
            p[0] = p[1]

    def p_initializer_1(self, p):
        &quot;&quot;&quot; initializer : assignment_expression
        &quot;&quot;&quot;
        p[0] = p[1]

    def p_initializer_2(self, p):
        &quot;&quot;&quot; initializer : brace_open initializer_list_opt brace_close
                        | brace_open initializer_list COMMA brace_close
        &quot;&quot;&quot;
        if p[2] is None:
            p[0] = c_ast.InitList([], self._coord(p.lineno(1)))
        else:
            p[0] = p[2]

    def p_initializer_list(self, p):
        &quot;&quot;&quot; initializer_list    : designation_opt initializer
                                | initializer_list COMMA designation_opt initializer
        &quot;&quot;&quot;
        if len(p) == 3: # single initializer
            init = p[2] if p[1] is None else c_ast.NamedInitializer(p[1], p[2])
            p[0] = c_ast.InitList([init], p[2].coord)
        else:
            init = p[4] if p[3] is None else c_ast.NamedInitializer(p[3], p[4])
            p[1].exprs.append(init)
            p[0] = p[1]

    def p_designation(self, p):
        &quot;&quot;&quot; designation : designator_list EQUALS
        &quot;&quot;&quot;
        p[0] = p[1]

    # Designators are represented as a list of nodes, in the order in which
    # they&#039;re written in the code.
    #
    def p_designator_list(self, p):
        &quot;&quot;&quot; designator_list : designator
                            | designator_list designator
        &quot;&quot;&quot;
        p[0] = [p[1]] if len(p) == 2 else p[1] + [p[2]]

    def p_designator(self, p):
        &quot;&quot;&quot; designator  : LBRACKET constant_expression RBRACKET
                        | PERIOD identifier
        &quot;&quot;&quot;
        p[0] = p[2]

    def p_type_name(self, p):
        &quot;&quot;&quot; type_name   : specifier_qualifier_list abstract_declarator_opt
        &quot;&quot;&quot;
        #~ print &#039;==========&#039;
        #~ print p[1]
        #~ print p[2]
        #~ print p[2].children()
        #~ print &#039;==========&#039;

        typename = c_ast.Typename(
            name=&#039;&#039;,
            quals=p[1][&#039;qual&#039;],
            type=p[2] or c_ast.TypeDecl(None, None, None),
            coord=self._coord(p.lineno(2)))

        p[0] = self._fix_decl_name_type(typename, p[1][&#039;type&#039;])

    def p_abstract_declarator_1(self, p):
        &quot;&quot;&quot; abstract_declarator     : pointer
        &quot;&quot;&quot;
        dummytype = c_ast.TypeDecl(None, None, None)
        p[0] = self._type_modify_decl(
            decl=dummytype,
            modifier=p[1])

    def p_abstract_declarator_2(self, p):
        &quot;&quot;&quot; abstract_declarator     : pointer direct_abstract_declarator
        &quot;&quot;&quot;
        p[0] = self._type_modify_decl(p[2], p[1])

    def p_abstract_declarator_3(self, p):
        &quot;&quot;&quot; abstract_declarator     : direct_abstract_declarator
        &quot;&quot;&quot;
        p[0] = p[1]

    # Creating and using direct_abstract_declarator_opt here
    # instead of listing both direct_abstract_declarator and the
    # lack of it in the beginning of _1 and _2 caused two
    # shift/reduce errors.
    #
    def p_direct_abstract_declarator_1(self, p):
        &quot;&quot;&quot; direct_abstract_declarator  : LPAREN abstract_declarator RPAREN &quot;&quot;&quot;
        p[0] = p[2]

    def p_direct_abstract_declarator_2(self, p):
        &quot;&quot;&quot; direct_abstract_declarator  : direct_abstract_declarator LBRACKET assignment_expression_opt RBRACKET
        &quot;&quot;&quot;
        arr = c_ast.ArrayDecl(
            type=None,
            dim=p[3],
            dim_quals=[],
            coord=p[1].coord)

        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)

    def p_direct_abstract_declarator_3(self, p):
        &quot;&quot;&quot; direct_abstract_declarator  : LBRACKET assignment_expression_opt RBRACKET
        &quot;&quot;&quot;
        p[0] = c_ast.ArrayDecl(
            type=c_ast.TypeDecl(None, None, None),
            dim=p[2],
            dim_quals=[],
            coord=self._coord(p.lineno(1)))

    def p_direct_abstract_declarator_4(self, p):
        &quot;&quot;&quot; direct_abstract_declarator  : direct_abstract_declarator LBRACKET TIMES RBRACKET
        &quot;&quot;&quot;
        arr = c_ast.ArrayDecl(
            type=None,
            dim=c_ast.ID(p[3], self._coord(p.lineno(3))),
            dim_quals=[],
            coord=p[1].coord)

        p[0] = self._type_modify_decl(decl=p[1], modifier=arr)

    def p_direct_abstract_declarator_5(self, p):
        &quot;&quot;&quot; direct_abstract_declarator  : LBRACKET TIMES RBRACKET
        &quot;&quot;&quot;
        p[0] = c_ast.ArrayDecl(
            type=c_ast.TypeDecl(None, None, None),
            dim=c_ast.ID(p[3], self._coord(p.lineno(3))),
            dim_quals=[],
            coord=self._coord(p.lineno(1)))

    def p_direct_abstract_declarator_6(self, p):
        &quot;&quot;&quot; direct_abstract_declarator  : direct_abstract_declarator LPAREN parameter_type_list_opt RPAREN
        &quot;&quot;&quot;
        func = c_ast.FuncDecl(
            args=p[3],
            type=None,
            coord=p[1].coord)

        p[0] = self._type_modify_decl(decl=p[1], modifier=func)

    def p_direct_abstract_declarator_7(self, p):
        &quot;&quot;&quot; direct_abstract_declarator  : LPAREN parameter_type_list_opt RPAREN
        &quot;&quot;&quot;
        p[0] = c_ast.FuncDecl(
            args=p[2],
            type=c_ast.TypeDecl(None, None, None),
            coord=self._coord(p.lineno(1)))

    # declaration is a list, statement isn&#039;t. To make it consistent, block_item
    # will always be a list
    #
    def p_block_item(self, p):
        &quot;&quot;&quot; block_item  : declaration
                        | statement
        &quot;&quot;&quot;
        p[0] = p[1] if isinstance(p[1], list) else [p[1]]

    # Since we made block_item a list, this just combines lists
    #
    def p_block_item_list(self, p):
        &quot;&quot;&quot; block_item_list : block_item
                            | block_item_list block_item
        &quot;&quot;&quot;
        # Empty block items (plain &#039;;&#039;) produce [None], so ignore them
        p[0] = p[1] if (len(p) == 2 or p[2] == [None]) else p[1] + p[2]

    def p_compound_statement_1(self, p):
        &quot;&quot;&quot; compound_statement : brace_open block_item_list_opt brace_close &quot;&quot;&quot;
        p[0] = c_ast.Compound(
            block_items=p[2],
            coord=self._coord(p.lineno(1)))

    def p_labeled_statement_1(self, p):
        &quot;&quot;&quot; labeled_statement : ID COLON statement &quot;&quot;&quot;
        p[0] = c_ast.Label(p[1], p[3], self._coord(p.lineno(1)))

    def p_labeled_statement_2(self, p):
        &quot;&quot;&quot; labeled_statement : CASE constant_expression COLON statement &quot;&quot;&quot;
        p[0] = c_ast.Case(p[2], [p[4]], self._coord(p.lineno(1)))

    def p_labeled_statement_3(self, p):
        &quot;&quot;&quot; labeled_statement : DEFAULT COLON statement &quot;&quot;&quot;
        p[0] = c_ast.Default([p[3]], self._coord(p.lineno(1)))

    def p_selection_statement_1(self, p):
        &quot;&quot;&quot; selection_statement : IF LPAREN expression RPAREN statement &quot;&quot;&quot;
        p[0] = c_ast.If(p[3], p[5], None, self._coord(p.lineno(1)))

    def p_selection_statement_2(self, p):
        &quot;&quot;&quot; selection_statement : IF LPAREN expression RPAREN statement ELSE statement &quot;&quot;&quot;
        p[0] = c_ast.If(p[3], p[5], p[7], self._coord(p.lineno(1)))

    def p_selection_statement_3(self, p):
        &quot;&quot;&quot; selection_statement : SWITCH LPAREN expression RPAREN statement &quot;&quot;&quot;
        p[0] = fix_switch_cases(
                c_ast.Switch(p[3], p[5], self._coord(p.lineno(1))))

    def p_iteration_statement_1(self, p):
        &quot;&quot;&quot; iteration_statement : WHILE LPAREN expression RPAREN statement &quot;&quot;&quot;
        p[0] = c_ast.While(p[3], p[5], self._coord(p.lineno(1)))

    def p_iteration_statement_2(self, p):
        &quot;&quot;&quot; iteration_statement : DO statement WHILE LPAREN expression RPAREN SEMI &quot;&quot;&quot;
        p[0] = c_ast.DoWhile(p[5], p[2], self._coord(p.lineno(1)))

    def p_iteration_statement_3(self, p):
        &quot;&quot;&quot; iteration_statement : FOR LPAREN expression_opt SEMI expression_opt SEMI expression_opt RPAREN statement &quot;&quot;&quot;
        p[0] = c_ast.For(p[3], p[5], p[7], p[9], self._coord(p.lineno(1)))

    def p_iteration_statement_4(self, p):
        &quot;&quot;&quot; iteration_statement : FOR LPAREN declaration expression_opt SEMI expression_opt RPAREN statement &quot;&quot;&quot;
        p[0] = c_ast.For(c_ast.DeclList(p[3], self._coord(p.lineno(1))),
                         p[4], p[6], p[8], self._coord(p.lineno(1)))

    def p_jump_statement_1(self, p):
        &quot;&quot;&quot; jump_statement  : GOTO ID SEMI &quot;&quot;&quot;
        p[0] = c_ast.Goto(p[2], self._coord(p.lineno(1)))

    def p_jump_statement_2(self, p):
        &quot;&quot;&quot; jump_statement  : BREAK SEMI &quot;&quot;&quot;
        p[0] = c_ast.Break(self._coord(p.lineno(1)))

    def p_jump_statement_3(self, p):
        &quot;&quot;&quot; jump_statement  : CONTINUE SEMI &quot;&quot;&quot;
        p[0] = c_ast.Continue(self._coord(p.lineno(1)))

    def p_jump_statement_4(self, p):
        &quot;&quot;&quot; jump_statement  : RETURN expression SEMI
                            | RETURN SEMI
        &quot;&quot;&quot;
        p[0] = c_ast.Return(p[2] if len(p) == 4 else None, self._coord(p.lineno(1)))

    def p_expression_statement(self, p):
        &quot;&quot;&quot; expression_statement : expression_opt SEMI &quot;&quot;&quot;
        if p[1] is None:
            p[0] = c_ast.EmptyStatement(self._coord(p.lineno(1)))
        else:
            p[0] = p[1]

    def p_expression(self, p):
        &quot;&quot;&quot; expression  : assignment_expression
                        | expression COMMA assignment_expression
        &quot;&quot;&quot;
        if len(p) == 2:
            p[0] = p[1]
        else:
            if not isinstance(p[1], c_ast.ExprList):
                p[1] = c_ast.ExprList([p[1]], p[1].coord)

            p[1].exprs.append(p[3])
            p[0] = p[1]

    def p_typedef_name(self, p):
        &quot;&quot;&quot; typedef_name : TYPEID &quot;&quot;&quot;
        p[0] = c_ast.IdentifierType([p[1]], coord=self._coord(p.lineno(1)))

    def p_assignment_expression(self, p):
        &quot;&quot;&quot; assignment_expression   : conditional_expression
                                    | unary_expression assignment_operator assignment_expression
        &quot;&quot;&quot;
        if len(p) == 2:
            p[0] = p[1]
        else:
            p[0] = c_ast.Assignment(p[2], p[1], p[3], p[1].coord)

    # K&amp;R2 defines these as many separate rules, to encode
    # precedence and associativity. Why work hard ? I&#039;ll just use
    # the built in precedence/associativity specification feature
    # of PLY. (see precedence declaration above)
    #
    def p_assignment_operator(self, p):
        &quot;&quot;&quot; assignment_operator : EQUALS
                                | XOREQUAL
                                | TIMESEQUAL
                                | DIVEQUAL
                                | MODEQUAL
                                | PLUSEQUAL
                                | MINUSEQUAL
                                | LSHIFTEQUAL
                                | RSHIFTEQUAL
                                | ANDEQUAL
                                | OREQUAL
        &quot;&quot;&quot;
        p[0] = p[1]

    def p_constant_expression(self, p):
        &quot;&quot;&quot; constant_expression : conditional_expression &quot;&quot;&quot;
        p[0] = p[1]

    def p_conditional_expression(self, p):
        &quot;&quot;&quot; conditional_expression  : binary_expression
                                    | binary_expression CONDOP expression COLON conditional_expression
        &quot;&quot;&quot;
        if len(p) == 2:
            p[0] = p[1]
        else:
            p[0] = c_ast.TernaryOp(p[1], p[3], p[5], p[1].coord)

    def p_binary_expression(self, p):
        &quot;&quot;&quot; binary_expression   : cast_expression
                                | binary_expression TIMES binary_expression
                                | binary_expression DIVIDE binary_expression
                                | binary_expression MOD binary_expression
                                | binary_expression PLUS binary_expression
                                | binary_expression MINUS binary_expression
                                | binary_expression RSHIFT binary_expression
                                | binary_expression LSHIFT binary_expression
                                | binary_expression LT binary_expression
                                | binary_expression LE binary_expression
                                | binary_expression GE binary_expression
                                | binary_expression GT binary_expression
                                | binary_expression EQ binary_expression
                                | binary_expression NE binary_expression
                                | binary_expression AND binary_expression
                                | binary_expression OR binary_expression
                                | binary_expression XOR binary_expression
                                | binary_expression LAND binary_expression
                                | binary_expression LOR binary_expression
        &quot;&quot;&quot;
        if len(p) == 2:
            p[0] = p[1]
        else:
            p[0] = c_ast.BinaryOp(p[2], p[1], p[3], p[1].coord)

    def p_cast_expression_1(self, p):
        &quot;&quot;&quot; cast_expression : unary_expression &quot;&quot;&quot;
        p[0] = p[1]

    def p_cast_expression_2(self, p):
        &quot;&quot;&quot; cast_expression : LPAREN type_name RPAREN cast_expression &quot;&quot;&quot;
        p[0] = c_ast.Cast(p[2], p[4], self._coord(p.lineno(1)))

    def p_unary_expression_1(self, p):
        &quot;&quot;&quot; unary_expression    : postfix_expression &quot;&quot;&quot;
        p[0] = p[1]

    def p_unary_expression_2(self, p):
        &quot;&quot;&quot; unary_expression    : PLUSPLUS unary_expression
                                | MINUSMINUS unary_expression
                                | unary_operator cast_expression
        &quot;&quot;&quot;
        p[0] = c_ast.UnaryOp(p[1], p[2], p[2].coord)

    def p_unary_expression_3(self, p):
        &quot;&quot;&quot; unary_expression    : SIZEOF unary_expression
                                | SIZEOF LPAREN type_name RPAREN
        &quot;&quot;&quot;
        p[0] = c_ast.UnaryOp(
            p[1],
            p[2] if len(p) == 3 else p[3],
            self._coord(p.lineno(1)))

    def p_unary_operator(self, p):
        &quot;&quot;&quot; unary_operator  : AND
                            | TIMES
                            | PLUS
                            | MINUS
                            | NOT
                            | LNOT
        &quot;&quot;&quot;
        p[0] = p[1]

    def p_postfix_expression_1(self, p):
        &quot;&quot;&quot; postfix_expression  : primary_expression &quot;&quot;&quot;
        p[0] = p[1]

    def p_postfix_expression_2(self, p):
        &quot;&quot;&quot; postfix_expression  : postfix_expression LBRACKET expression RBRACKET &quot;&quot;&quot;
        p[0] = c_ast.ArrayRef(p[1], p[3], p[1].coord)

    def p_postfix_expression_3(self, p):
        &quot;&quot;&quot; postfix_expression  : postfix_expression LPAREN argument_expression_list RPAREN
                                | postfix_expression LPAREN RPAREN
        &quot;&quot;&quot;
        p[0] = c_ast.FuncCall(p[1], p[3] if len(p) == 5 else None, p[1].coord)

    def p_postfix_expression_4(self, p):
        &quot;&quot;&quot; postfix_expression  : postfix_expression PERIOD ID
                                | postfix_expression PERIOD TYPEID
                                | postfix_expression ARROW ID
                                | postfix_expression ARROW TYPEID
        &quot;&quot;&quot;
        field = c_ast.ID(p[3], self._coord(p.lineno(3)))
        p[0] = c_ast.StructRef(p[1], p[2], field, p[1].coord)

    def p_postfix_expression_5(self, p):
        &quot;&quot;&quot; postfix_expression  : postfix_expression PLUSPLUS
                                | postfix_expression MINUSMINUS
        &quot;&quot;&quot;
        p[0] = c_ast.UnaryOp(&#039;p&#039; + p[2], p[1], p[1].coord)

    def p_postfix_expression_6(self, p):
        &quot;&quot;&quot; postfix_expression  : LPAREN type_name RPAREN brace_open initializer_list brace_close
                                | LPAREN type_name RPAREN brace_open initializer_list COMMA brace_close
        &quot;&quot;&quot;
        p[0] = c_ast.CompoundLiteral(p[2], p[5])

    def p_primary_expression_1(self, p):
        &quot;&quot;&quot; primary_expression  : identifier &quot;&quot;&quot;
        p[0] = p[1]

    def p_primary_expression_2(self, p):
        &quot;&quot;&quot; primary_expression  : constant &quot;&quot;&quot;
        p[0] = p[1]

    def p_primary_expression_3(self, p):
        &quot;&quot;&quot; primary_expression  : unified_string_literal
                                | unified_wstring_literal
        &quot;&quot;&quot;
        p[0] = p[1]

    def p_primary_expression_4(self, p):
        &quot;&quot;&quot; primary_expression  : LPAREN expression RPAREN &quot;&quot;&quot;
        p[0] = p[2]

    def p_primary_expression_5(self, p):
        &quot;&quot;&quot; primary_expression  : OFFSETOF LPAREN type_name COMMA identifier RPAREN
        &quot;&quot;&quot;
        coord = self._coord(p.lineno(1))
        p[0] = c_ast.FuncCall(c_ast.ID(p[1], coord),
                              c_ast.ExprList([p[3], p[5]], coord),
                              coord)

    def p_argument_expression_list(self, p):
        &quot;&quot;&quot; argument_expression_list    : assignment_expression
                                        | argument_expression_list COMMA assignment_expression
        &quot;&quot;&quot;
        if len(p) == 2: # single expr
            p[0] = c_ast.ExprList([p[1]], p[1].coord)
        else:
            p[1].exprs.append(p[3])
            p[0] = p[1]

    def p_identifier(self, p):
        &quot;&quot;&quot; identifier  : ID &quot;&quot;&quot;
        p[0] = c_ast.ID(p[1], self._coord(p.lineno(1)))

    def p_constant_1(self, p):
        &quot;&quot;&quot; constant    : INT_CONST_DEC
                        | INT_CONST_OCT
                        | INT_CONST_HEX
                        | INT_CONST_BIN
        &quot;&quot;&quot;
        p[0] = c_ast.Constant(
            &#039;int&#039;, p[1], self._coord(p.lineno(1)))

    def p_constant_2(self, p):
        &quot;&quot;&quot; constant    : FLOAT_CONST
                        | HEX_FLOAT_CONST
        &quot;&quot;&quot;
        p[0] = c_ast.Constant(
            &#039;float&#039;, p[1], self._coord(p.lineno(1)))

    def p_constant_3(self, p):
        &quot;&quot;&quot; constant    : CHAR_CONST
                        | WCHAR_CONST
        &quot;&quot;&quot;
        p[0] = c_ast.Constant(
            &#039;char&#039;, p[1], self._coord(p.lineno(1)))

    # The &quot;unified&quot; string and wstring literal rules are for supporting
    # concatenation of adjacent string literals.
    # I.e. &quot;hello &quot; &quot;world&quot; is seen by the C compiler as a single string literal
    # with the value &quot;hello world&quot;
    #
    def p_unified_string_literal(self, p):
        &quot;&quot;&quot; unified_string_literal  : STRING_LITERAL
                                    | unified_string_literal STRING_LITERAL
        &quot;&quot;&quot;
        if len(p) == 2: # single literal
            p[0] = c_ast.Constant(
                &#039;string&#039;, p[1], self._coord(p.lineno(1)))
        else:
            p[1].value = p[1].value[:-1] + p[2][1:]
            p[0] = p[1]

    def p_unified_wstring_literal(self, p):
        &quot;&quot;&quot; unified_wstring_literal : WSTRING_LITERAL
                                    | unified_wstring_literal WSTRING_LITERAL
        &quot;&quot;&quot;
        if len(p) == 2: # single literal
            p[0] = c_ast.Constant(
                &#039;string&#039;, p[1], self._coord(p.lineno(1)))
        else:
            p[1].value = p[1].value.rstrip()[:-1] + p[2][2:]
            p[0] = p[1]

    def p_brace_open(self, p):
        &quot;&quot;&quot; brace_open  :   LBRACE
        &quot;&quot;&quot;
        p[0] = p[1]

    def p_brace_close(self, p):
        &quot;&quot;&quot; brace_close :   RBRACE
        &quot;&quot;&quot;
        p[0] = p[1]

    def p_empty(self, p):
        &#039;empty : &#039;
        p[0] = None

    def p_error(self, p):
        # If error recovery is added here in the future, make sure
        # _get_yacc_lookahead_token still works!
        #
        if p:
            self._parse_error(
                &#039;before: %s&#039; % p.value,
                self._coord(lineno=p.lineno,
                            column=self.clex.find_tok_column(p)))
        else:
            self._parse_error(&#039;At end of input&#039;, &#039;&#039;)


#------------------------------------------------------------------------------
if __name__ == &quot;__main__&quot;:
    import pprint
    import time, sys

    #t1 = time.time()
    #parser = CParser(lex_optimize=True, yacc_debug=True, yacc_optimize=False)
    #sys.write(time.time() - t1)

    #buf = &#039;&#039;&#039;
        #int (*k)(int);
    #&#039;&#039;&#039;

    ## set debuglevel to 2 for debugging
    #t = parser.parse(buf, &#039;x.c&#039;, debuglevel=0)
    #t.show(showcoord=True)

</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib/python3.6/site-packages/pycparser/c_parser.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>