%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /snap/certbot/5911/lib64/python3.12/site-packages/pycparser/__pycache__/
Upload File :
Create Path :
Current File : //snap/certbot/5911/lib64/python3.12/site-packages/pycparser/__pycache__/c_parser.cpython-312.pyc

�

�h�js����ddlmZddlmZmZmZmZmZmZddl	m
Z
ddlmZm
Z
ddlmZmZeGd�d��ZGd	�d
e�ZGd�d�Zhd
�Zidd�dd�dd�dd�dd�dd�dd�dd�dd�dd�dd�dd�d d�d!d"�d#d"�d$d%�d&d%�d'd%i�Zhd(�Zd)d*hZhd+�Zhd,�Zeezezezhd-�zZhd.�Zhd/�Zd0d1hZhd2�Zhd3�Z eezezeze zZ!hd4�Z"Gd5�d6�Z#Gd7�d8e�Z$ed9Z%Gd:�d;e�Z&y<)=�)�	dataclass)�Any�Literal�NoReturn�Optional�	TypedDict�cast�)�c_ast)�fix_atomic_specifiers�fix_switch_cases)�CLexer�Tokenc�F�eZdZUdZeed<eed<dZedzed<defd�Zy)�CoordzkCoordinates of a syntactic element. Consists of:
    - File name
    - Line number
    - Column number
    �file�lineN�column�returnc�x�|j�d|j��}|j�|d|j��z
}|S)N�:�rrr)�self�texts  �N/root/parts/certbot/install/lib/python3.12/site-packages/pycparser/c_parser.py�__str__z
Coord.__str__$s>���)�)��A�d�i�i�[�)���;�;�"��a����}�%�%�D���)	�__name__�
__module__�__qualname__�__doc__�str�__annotations__�intrr�rrrrs-����I�

�I��F�C�$�J����rrc��eZdZy)�
ParseErrorN)rrr r%rrr'r'+s��rr'c��eZdZdZdedddddfdedeed	ed
ededed
eddfd�Z	d�dededede	jfd�Zd�dededzde
fd�Zdede
ezdzdefd�Zd�d�Zd�d�Zdede
dzddfd�Zdede
dzddfd�Zdedefd �Zded!ededdfd"�Zd�d#�Zd�d$�Zdedefd%�Zd&ed'ede	j6fd(�Zd&e	j:e	j<ze	j>zd)e ede	j:e	j<ze	j>zfd*�Z!	d�d+e"d,d-ed.d/d0edd,f
d1�Z#	d�d2d,d3e d4d5ede e	j6fd6�Z$d2d,d&e	j6d7e e	j6dzd8e	j6de	j6f
d9�Z%d:edefd;�Z&d�d<ede'dzfd=�Z(d�d<ededzfd>�Z)de'fd?�Z*d@ede'dzfdA�Z+d@ede'fdB�Z,defdC�Z-dDeddfdE�Z.dFe'de
fdG�Z/d�dFe'dzdefdH�Z0d�dFe'dzdefdI�Z1defdJ�Z2d�dKedefdL�Z3de4edzeffdM�Z5	d�dNedOede4e	j6dzeffdP�Z6de4edzeffdQ�Z7defdR�Z8defdS�Z9de4e	j>ee'fdzfdT�Z:de	jfdU�Z;de e	j6fdV�Z<de e	j6fdW�Z=de e	j6fdX�Z>de e	j6fdY�Z?d2d,dZede e	j6fd[�Z@de e	j6fd\�ZA	d�d]ede4d,ee
dzffd^�ZBd�d_�ZCde efd`�ZDde	j6fda�ZEde	j6fdb�ZF	d�dce"d4dKede d4fdd�ZGd�dKedd4fde�ZHde	j6fdf�ZIde e	j6fdg�ZJde e	j6dzfdh�ZKde d4fdi�ZLd�dj�ZMde	j6fdk�ZNde	j6fdl�ZOde	j6fdm�ZPde	j6fdn�ZQde	j6fdo�ZRde	j6fdp�ZSde	j6fdq�ZTd.edrede	j6fds�ZU	d�d.edrede	j6fdt�ZVd&e	j6de	j6fdu�ZWdve	j6de	j6fdw�ZX	d�dxe	j6dzde
dzde	j6fdy�ZYdve	j6de	j6fdz�ZZde	j6dzfd{�Z[de	j�fd|�Z]de	j�fd}�Z^de	j6fd~�Z_d2d,d&e	j6dzde
dzde	j6fd��Z`de	j6dzfd��Zade	j6fd��Zbde	j>fd��Zcde	j6dzfd��Zdde	j6fd��Zede	j�dzfd��Zfde	j6fd��Zgde	j6fd��Zhde	j6fd��Zide	j6e e	j6zfd��Zjde e	j6fd��Zkde	j6fd��Zlde	j6fd��Zmde	j6fd��Znde	j6fd��Zode	j6fd��Zpde	j6fd��Zqde	j6dzfd��Zrde	j6fd��Zsde	j6fd��Ztde	j6fd��Zu	d�d�ed�e	j6dzde	j6fd��Zvde	j6fd��Zwde	j6fd��Zxde	j6fd��Zyde	j6fd��Zzde	j�fd��Z|de	j�fd��Z~de	j6fd��Zde	j6fd��Z�de	j6fd��Z�de	j6fd��Z�de	j6fd��Z�de	j6fd��Z�de	�j
fd��Z�e�d�ed�edefd���Z�de	j6fd��Z�de	j6fd��Z�de	j6fd��Z�de e	j6fd��Z�de e	j6fd��Z�de	j6fd��Z�defd��Z�de	j6fd��Z�de e	j6fd��Z�de	�j$fd��Z�y)��CParseraFRecursive-descent C parser.

    Usage:
        parser = CParser()
        ast = parser.parse(text, filename)

    The `lexer` parameter lets you inject a lexer class (defaults to CLexer).
    The parameters after `lexer` are accepted for backward compatibility with
    the old PLY-based parser and are otherwise unused.
    Tzpycparser.lextabzpycparser.yacctabF��lex_optimize�lexer�lextab�
yacc_optimize�yacctab�
yacc_debug�taboutputdirrNc��||j|j|j|j��|_ig|_t
|j�|_y)N)�
error_func�on_lbrace_func�on_rbrace_func�type_lookup_func)�_lex_error_func�_lex_on_lbrace_func�_lex_on_rbrace_func�_lex_type_lookup_func�clex�_scope_stack�_TokenStream�_tokens)rr+r,r-r.r/r0r1s        r�__init__zCParser.__init__;sP��"��+�+��3�3��3�3�!�7�7�	
��	�57�4���%1�$�)�)�%<��rr�filename�debugc�"�ig|_|jj||�t|j�|_|j�}|j
�}|�.|jd|j��|j|��|S)a!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)

        debug:
            Deprecated debug flag (unused); for backwards compatibility.
        �before: )
r<r;�inputr=r>� _parse_translation_unit_or_empty�_peek�_parse_error�value�
_tok_coord)rrr@rA�ast�toks      r�parsez
CParser.parseWsw�� �D����	�	����h�'�#�D�I�I�.����3�3�5���j�j�l���?���������4�d�o�o�c�6J�K��
r�linenorc�F�t|jj||��S)Nr)rr;r@)rrMrs   r�_coordzCParser._coordrs���$�)�)�,�,�6�&�I�Ir�msg�coordc�"�t|�d|����)Nz: )r')rrPrQs   rrGzCParser._parse_errorus���E�7�"�S�E�*�+�+rc�:�|jji�y�N)r<�append�rs r�_push_scopezCParser._push_scopexs����� � ��$rc�~�t|j�dkrtd��|jj�y)Nr
z
Unmatched '}')�lenr<r'�poprVs r�
_pop_scopezCParser._pop_scope{s2���t� � �!�Q�&��_�-�-������r�namec��|jdj|d�s|jd|�d�|�d|jd|<y)z9Add a new typedef name (ie a TYPEID) to the current scope���TzTypedef z1 previously declared as non-typedef in this scopeN�r<�getrG�rr\rQs   r�_add_typedef_namezCParser._add_typedef_name�sR��� � ��$�(�(��t�4�����4�(�"S�T��
�'+����"��d�#rc��|jdj|d�r|jd|�d�|�d|jd|<y)z`Add a new object, function, or enum member name (ie an ID) to the
        current scope
        r^FzNon-typedef z- previously declared as typedef in this scopeNr_ras   r�_add_identifierzCParser._add_identifier�sT�����R� �$�$�T�5�1�����t�h�&S�T��
�',����"��d�#rc�N�t|j�D]
}||vs�||cSy)z.Is *name* a typedef-name in the current scope?F)�reversedr<)rr\�scopes   r�_is_type_in_scopezCParser._is_type_in_scope�s4���d�/�/�0�	#�E��u�}��T�{�"�		#�
rrc�H�|j||j||��yrT)rGrO)rrPrrs    rr7zCParser._lex_error_func�s�����#�t�{�{�4��8�9rc�$�|j�yrT)rWrVs rr8zCParser._lex_on_lbrace_func�s�����rc�$�|j�yrT)r[rVs rr9zCParser._lex_on_rbrace_func�s�����rc�$�|j|�S)z�Looks up types that were previously defined with typedef.

        Passed to the lexer for recognizing identifiers that are types.
        )rh)rr\s  rr:zCParser._lex_type_lookup_func�s��
�%�%�d�+�+r�decl�modifierc�|�|}|}|jr|j}|jr�t|tj�r	||_|S|}t|jtj�s1|j}t|jtj�s�1|j|_||_|S)z�Tacks a type modifier on a declarator, and returns
        the modified declarator.

        Note: the declarator and modifier may be modified
        )�type�
isinstancer�TypeDecl)rrmrn�
modifier_head�
modifier_tail�	decl_tails      r�_type_modify_declzCParser._type_modify_decl�s���!�
� �
�� � �)�.�.�M�� � ��d�E�N�N�+�!%�M���O�
�I� �������@�%�N�N�	�!�������@�"+���M��*�I�N��Kr�typenamec��|}t|tj�s'|j}t|tj�s�'|j|_|jdd|_|D][}t|tj�r�t|�dkDr|jd|j��I||_t|�cS|sit|jtj�s|jd|j�tjdg|j��|_|Stj|D��cgc]}|jD]}|���c}}|dj��|_|Scc}}w)z#Fixes a declaration. Modifies decl.Nr
z Invalid multiple types specified�Missing type in declarationr$�rQr)rqrrrrp�declnamer\�quals�IdentifierTyperYrGrQr�FuncDecl�names)rrmrw�typ�tn�idr\s       r�_fix_decl_name_typezCParser._fix_decl_name_type�s9�����S�%�.�.�1��(�(�C��S�%�.�.�1��L�L��	��J�J�q�M��	��	7�B��b�%�"6�"6�7��x�=�1�$��%�%�&H�"�(�(�S�!�C�H�1��6�6�	7���d�i�i����8��!�!�"?����L��+�+�U�G�4�:�:�F�C�H����+�+� (�>�"�R�X�X�>�T��>��>�h�q�k�FW�FW��C�H����?s�F
�declspec�	_DeclSpec�newspec�kind�
_DeclSpecKindrUc�z�|�	gggggd�}n|}|r||j|�|S||jd|�|S)z2See _DeclSpec for the specifier dictionary layout.��qual�storagerp�function�	alignmentr)rU�insert)rr�r�r�rU�specs      r�_add_declaration_specifierz"CParser._add_declaration_specifier%s^����������D��D����J���g�&���
��J���a��)��rr��decls�	_DeclInfo�typedef_namespacec
�r�d|dv}g}|djd����|dd��t|d�dksBt|dd	j�d
k7s$|j|dd	jd�s8d}|dD]}t	|d�s�|j
}n|j
d
|�tj|dd	jddd|d|dd	j
��|dd<|dd	=n�t|ddtjtjtjtjf�s�tt|dd�}t|tj�s'|j }t|tj�s�'|j"� |dd	jd|_|dd	=|D�]a}	|	d�J�|r1tj$d|d|d|	d|	dj
��}
nXtj&d|d|d|d|d|	d|	jd�|	jd�|	dj
��	}
t|
j tjtjtjtjf�r|
}n|j)|
|d�}|rO|r'|j+|j,|j
�n&|j/|j,|j
�|j1|���d|S)z�Builds a list of declarations all sharing the given specifiers.
        If typedef_namespace is true, each declared name is added
        to the "typedef namespace", which also includes objects,
        functions, and enum constants.
        �typedefr�r�bitsizeNrmrp�r^r
�?rQ�Invalid declarationr��r{rpr|�alignrQr�)r\r|r�rprQr��init�	r\r|r�r��funcspecrpr�r�rQ)r`rYrrh�hasattrrQrGrrrrq�Enum�Struct�Unionr}r	rrpr{�Typedef�Declr�rbr\rdrU)rr�r�r��
is_typedef�declarationsrQ�t�decls_0_tailrm�declaration�
fixed_decls            r�_build_declarationszCParser._build_declarations?s'���$�y�/�1�
�����8�<�<�	�"�*�
�Q�x���'���V��%��)��4��<��+�1�1�2�a�7��1�1�$�v�,�r�2B�2H�2H��2K�L��E�!�&�\�"��"�1�g�.�$%�G�G�E�!�"��%�%�&;�U�C�$)�>�>�!�&�\�"�-�3�3�A�6����{�+��v�,�r�*�0�0�$��a��� ���L��$� ��a��� ����U�\�\�5�;�;��8L�8L�M�� $�C��q��&�)9�:��$�\�5�>�>�B�#/�#4�#4�L�%�\�5�>�>�B��(�(�0�,0��L��,<�,B�,B�1�,E�L�)��V��R�(��'	,�D���<�+�+�+��#�m�m���v�,� ��O��f���v�,�,�,���$�j�j���v�,��{�+� ��O�!�*�-��f�����&�)� �H�H�Y�/��v�,�,�,�
���� � ����U�\�\�5�;�;��8L�8L�M��)�
�!�5�5�k�4��<�P�
�!���*�*�:�?�?�J�<L�<L�M��(�(����*�:J�:J�K����
�+�O'	,�R�r�param_decls�bodyc���d|dvr|jd|j�|j||ddd�gd��d}tj||||j�	�S)
zBuilds a function definition.r�r�zInvalid typedefN�rmr�r�T�r�r�r�r)rmr�r�rQ)rGrQr�r�FuncDef)rr�rmr�r�r�s      r�_build_function_definitionz"CParser._build_function_definition�sw����Y��'����/����<��.�.�� �$�4�@�A�"�/�
��	
���}�}��+�D��
�
�
�	
r�tokenc�L�|dk(rtjStjS)z[Given a token (either STRUCT or UNION), selects the
        appropriate AST class.
        �struct)rr�r�)rr�s  r�_select_struct_union_classz"CParser._select_struct_union_class�s ���H���<�<���;�;�r�kc�8�|jj|�S)z:Return the k-th next token without consuming it (1-based).)r>�peek�rr�s  rrFz
CParser._peek�s���|�|� � ��#�#rc�D�|j|�}|�|jSdS)zDReturn the type of the k-th next token, or None if absent (1-based).N)rFrp)rr�rKs   r�
_peek_typezCParser._peek_type�s"���j�j��m���?�s�x�x�4��4rc��|jj�}|�'|jd|jj�y|S)N�At end of input)r>�nextrGr;r@�rrKs  r�_advancezCParser._advance�s9���l�l���!���;����/����1C�1C�D��Jr�
token_typec�f�|j�}|�|j|k(r|j�Sy)z�Conditionally consume next token, only if it's of token_type.

        If it is of the expected type, consume and return it.
        Otherwise, leaves the token intact and returns None.
        N)rFrpr��rr�rKs   r�_acceptzCParser._accept�s.���j�j�l���?�s�x�x�:�5��=�=�?�"�rc��|j�}|j|k7r.|jd|j��|j	|��|S)NrC)r�rprGrHrIr�s   r�_expectzCParser._expect�sB���m�m�o���8�8�z�!���������4�d�o�o�c�6J�K��
rc�6�|jj�SrT)r>�markrVs r�_markz
CParser._mark�s���|�|� � �"�"rr�c�:�|jj|�yrT)r>�reset�rr�s  r�_resetzCParser._reset�s�������4� rrKc�N�|j|j|j�SrT)rOrMrr�s  rrIzCParser._tok_coord�s���{�{�3�:�:�s�z�z�2�2rc�T�|xs|j�}|�y|jtvS�NF)rFrp�_DECL_STARTr�s  r�_starts_declarationzCParser._starts_declaration�s)���!�T�Z�Z�\���;���x�x�;�&�&rc�T�|xs|j�}|�y|jtvSr�)rFrp�_STARTS_EXPRESSIONr�s  r�_starts_expressionzCParser._starts_expression�s*���!�T�Z�Z�\���;���x�x�-�-�-rc�Z�|j�}|�y|tvry|j�S)NFT)r��_STARTS_STATEMENTr��r�tok_types  r�_starts_statementzCParser._starts_statement�s2���?�?�$������(�(���&�&�(�(r�id_onlyc�H�|j�}|�y|dvry|r|dk(S|dvS)NF>�TIMES�LPARENT�ID>r��TYPEID�r�)rr�r�s   r�_starts_declaratorzCParser._starts_declarators=���?�?�$������*�*����t�#�#��+�+�+rc�r�|j�}|j�\}}|j|�||fSrT)r��_scan_declarator_name_infor�)rr�r��	saw_parens    r�_peek_declarator_name_infoz"CParser._peek_declarator_name_infos7���z�z�|��"�=�=�?���)����D����"�"r�allow_abstract�typeid_paren_as_abstractc��|j�\}}|�	|rh|dk(rc|ra|sK|j�}|�|j|�n|jj}|jd|�|j
�}|dfS|dk(r*|r|j�}|dfS|j�}|dfS|j�}|dfS)Nr�zInvalid declaratorFT)
r�rFrIr;r@rG�_parse_abstract_declarator_opt� _parse_typeid_noparen_declarator�_parse_typeid_declarator�_parse_id_declarator)rr�r��	name_typer�rKrQrms        r�_parse_any_declaratorzCParser._parse_any_declarators��� $�>�>�@��	�9���$��h�)>�9�!��j�j�l��03������,�T�Y�Y�EW�EW���!�!�"6��>��6�6�8�D���;���� �'��<�<�>��
�T�z���4�4�6���T�z���,�,�.�D��T�z�rc��d}|jd�rO|j�tvr'|j�|j�tvr�'|jd�r�O|j	�}|�d|fS|j
dvr|j�|j
|fS|j
dk(r�d}|j�|j
�\}}|rd}d}	|j	�}|�d|fS|j
dk(r|dz
}n/|j
dk(r |dz}|j�|dk(r	||fS�[|j��kd|fS)	NFr�>r�r�r�Tr
�RPARENr)r�r��_TYPE_QUALIFIERr�rFrpr�)rr�rKr��nested_paren�depths      rr�z"CParser._scan_declarator_name_info-sK���	��l�l�7�#��/�/�#��6��
�
���/�/�#��6��l�l�7�#��j�j�l���;���?�"��8�8�'�'��M�M�O��8�8�Y�&�&��8�8�x���I��M�M�O�%)�%D�%D�%F�"�H�l�� �	��E���j�j�l���;���?�*��8�8�x�'��Q�J�E��X�X��)��Q�J�E��M�M�O���z���Y�&�&���
�
����Y��rc�&�|j�dvS)N>r��LBRACKETr�rVs r�"_starts_direct_abstract_declaratorz*CParser._starts_direct_abstract_declaratorPs����� �$:�:�:rc�R�|j�}|duxr|jtvSrT)rFrp�_ASSIGNMENT_OPSr�s  r�_is_assignment_opzCParser._is_assignment_opSs%���j�j�l���$��>�3�8�8��#>�>rc��|j�}|jd�}|�y|j�s|j|�y|j	�}|jd��|j|�y|||fS)abParse and return a parenthesized type name if present.

        Returns (typ, mark, lparen_tok) when the next tokens look like
        '(' type_name ')', where typ is the parsed type name, mark is the
        token-stream position before parsing, and lparen_tok is the LPAREN
        token. Returns None if no parenthesized type name is present.
        r�Nr�)r�r�r�r��_parse_type_name)rr��
lparen_tokr�s    r�_try_parse_paren_type_namez"CParser._try_parse_paren_type_nameWsz���z�z�|���\�\�(�+�
�����'�'�)��K�K�����#�#�%���<�<��!�)��K�K�����D�*�$�$rc��|j��tjg�Stj|j��SrT)rFr�FileAST�_parse_translation_unitrVs rrEz(CParser._parse_translation_unit_or_emptyrs5���:�:�<���=�=��$�$��}�}�T�9�9�;�<�<rc��g}|j��0|j|j��|j���0|SrT)rF�extend�_parse_external_declaration)r�exts  rrzCParser._parse_translation_unitxs;�����j�j�l�&��J�J�t�7�7�9�:��j�j�l�&��
rc�T�|j�}|�gS|jdk(r|j�gS|jdvr|j�gS|j	d�rgS|jdk(r|j�gS|j
|�s�|j�}d}|j�dk7r|jd|j�gggtjdg|j��ggd	�}|j||||j��
�}|gS|jd��\}}}|j!�\}}	|d
k7r%|j#||�}
|j%d�|
S|j�}|j�dk(s|j
�r�d}|j
�r|j'�}|j�dk7r|jd|j�|dstjdg|��g|d<|j||||j��
�}|gS|ddd�}|j	d�r|j)�|d<|j+|��}
|j-||
d��}
|j%d�|
S)N�PPHASH>�_PRAGMA�PPPRAGMA�SEMI�_STATIC_ASSERT�LBRACEzInvalid function definitionr$rz)r�r�r�rpr�)r�rmr�r�T��
allow_no_typer�rpr��EQUALSr�)�firstr�)rFrp�_parse_pp_directive�_parse_pppragma_directiver��_parse_static_assertr�r�r�rGrQrr}r��_parse_compound_statement�_parse_declaration_specifiersr��_parse_decl_body_with_specr��_parse_declaration_list�_parse_initializer�_parse_init_declarator_listr�)rrKrmr�r��func�saw_type�
spec_coordr��_r��	decl_dicts            rrz#CParser._parse_external_declaration�s����j�j�l���;��I��8�8�x���$�$�&��I��8�8�.�.��2�2�4�5�5��<�<����I��8�8�'�'��-�-�/�0�0��'�'��,��,�,�.�D��K���� �H�,��!�!�"?����L�����-�-�u�g�T�Z�Z�H�I���D��2�2���'��3�3�5�	3��D��6�M�&*�%G�%G��&H�&
�"��h�
��6�6�8��	�1�����3�3�D�(�C�E��L�L�� ��L��(�(�*���?�?���(�D�,D�,D�,F��K��'�'�)�"�:�:�<����� �H�,��!�!�"?����L���<� %� 4� 4�e�W�J� O�P��V���2�2���'��3�3�5�	3��D��6�M�(,�d�t�L�	��<�<��!� $� 7� 7� 9�I�f���0�0�y�0�A���(�(�d�%�SW�(�X�����V���rc��|j�dk(r|j�gS|j�}|jd�|S)Nr
r)r�r�_parse_decl_bodyr��rr�s  r�_parse_declarationzCParser._parse_declaration�sC���?�?�� 0�0��-�-�/�0�0��%�%�'�����V���rc�R�|jd��\}}}|j||�S)NTr)rr)rr�rrs    rr"zCParser._parse_decl_body�s/�� �>�>�T�>�R���h���.�.�t�X�>�>rrc��d}|r!|j�r5|j�}n$|jd��r|jd��}|��|d}tjtjtj
f}t
|�dk(rLt|d|�r=tjd|d|d|d|d	|ddd|dj�
�	g}|S|j|dddd�gd��}|S|j||d��}|S)
NT�r�rpr
rr�r�r�r�r�r�r�)r�rrr�r�r�rYrqr�rQr�)rr�r�
decl_infos�ty�s_u_or_er�s       rrz"CParser._parse_decl_body_with_spec�s4��
.2�
���&�&�(�!�=�=�?�
��&�&�t�&�4�!�=�=�d�=�K�
����f��B����e�k�k�5�:�:�>�H��2�w�!�|�
�2�a�5�(� ;��J�J�!�"�6�l�"�;�/� $�Y��!%�j�!1���U�!� $� ��e�k�k�
���0���0�0��$(�$�4�H�I�&*�1�����	�,�,���t�-��E��rc��g}|j�r0|j|j��|j�r�0|SrT)r�rr$r#s  rrzCParser._parse_declaration_lists;�����&�&�(��L�L��0�0�2�3��&�&�(��rrc	��d}d}d}	|j�}|��n*|jdk(r7|�|j|�}|j||j	�dd��}�[|jdk(rM|jd�d	k(r9|�|j|�}|j||j
�d
d��}d}��|jtvrB|�|j|�}|j||j�jdd��}��|jtvrB|�|j|�}|j||j�jdd��}��_|jtvrB|�|j|�}|j||j�jd
d��}���|jtvrk|�|j|�}|j�}|j|tj|jg|j|���d
d��}d}��0|jdk(rn|rn�|�|j|�}|j�}|j|tj|jg|j|���d
d��}d}���|jdvr:|�|j|�}|j||j�d
d��}d}���|jdk(r:|�|j|�}|j||j!�d
d��}d}��>	|�&|j#d|j$j&�|s|s|j#d|�|||fS)a�Parse declaration-specifier sequence.

        allow_no_type:
            If True, allow a missing type specifier without error.

        Returns:
            (spec, saw_type, first_coord) where spec is a dict with
            qual/storage/type/function/alignment entries, saw_type is True
            if a type specifier was consumed, and first_coord is the coord
            of the first specifier token (used for diagnostics).
        NFT�_ALIGNASr��rU�_ATOMICr�r�rpr�r�r�rzr�>�UNION�STRUCT�ENUMr�ry)rFrprIr��_parse_alignment_specifierr��_parse_atomic_specifierr�r�rH�_STORAGE_CLASS�_FUNCTION_SPEC�_TYPE_SPEC_SIMPLErr}� _parse_struct_or_union_specifier�_parse_enum_specifierrGr;r@)rrr�r�first_coordrKs      rrz%CParser._parse_declaration_specifiers!s�����������*�*�,�C��{���x�x�:�%��&�"&�/�/�#�"6�K��6�6��$�9�9�;�[�QU�7�����x�x�9�$�����);�x�)G��&�"&�/�/�#�"6�K��6�6��$�6�6�8�&��7��� ����x�x�?�*��&�"&�/�/�#�"6�K��6�6��$�-�-�/�/�/���7�����x�x�>�)��&�"&�/�/�#�"6�K��6�6��$�-�-�/�/�/��4�7�����x�x�>�)��&�"&�/�/�#�"6�K��6�6��$�-�-�/�/�/��D�7�����x�x�,�,��&�"&�/�/�#�"6�K��m�m�o���6�6���(�(�#�)�)��D�O�O�C�<P�Q���	7��� ����x�x�8�#����&�"&�/�/�#�"6�K��m�m�o���6�6���(�(�#�)�)��D�O�O�C�<P�Q���	7��� ����x�x�.�.��&�"&�/�/�#�"6�K��6�6��$�?�?�A�6�RV�7��� ����x�x�6�!��&�"&�/�/�#�"6�K��6�6��$�4�4�6��t�7��� �����<����3�T�Y�Y�5G�5G�H��
����;�[�I��X�{�*�*rc	��d}d}d}d}	|j�}|��n�|jdk(r9|�|j|�}|j||j	�dd��}d}�]|jdk(rM|jd�dk(r9|�|j|�}|j||j
�d	d��}d}��|jtvrB|�|j|�}|j||j�jd
d��}��
|jtvrk|�|j|�}|j�}|j|tj|jg|j|���d	d��}d}���|jdk(rn|rn�|�|j|�}|j�}|j|tj|jg|j|���d	d��}d}��|jd
vr:|�|j|�}|j||j�d	d��}d}��O|jdk(r:|�|j|�}|j||j�d	d��}d}���	|�&|jd|j j"�|s|s|jd|�|j%d��g|d<|j%d��g|d<|S)NFTr-r�r.r/r�r�rpr�rzr�>r0r1r2zInvalid specifier listryr�r�)rFrprIr�r3r�r4r�r�rHr7rr}r8r9rGr;r@r`)rr�r�
saw_alignmentr:rKs      r�_parse_specifier_qualifier_listz'CParser._parse_specifier_qualifier_list�s,�������
�����*�*�,�C��{���x�x�:�%��&�"&�/�/�#�"6�K��6�6��$�9�9�;�[�QU�7���!%�
���x�x�9�$�����);�x�)G��&�"&�/�/�#�"6�K��6�6��$�6�6�8�&��7��� ����x�x�?�*��&�"&�/�/�#�"6�K��6�6��$�-�-�/�/�/���7�����x�x�,�,��&�"&�/�/�#�"6�K��m�m�o���6�6���(�(�#�)�)��D�O�O�C�<P�Q���	7��� ����x�x�8�#����&�"&�/�/�#�"6�K��m�m�o���6�6���(�(�#�)�)��D�O�O�C�<P�Q���	7��� ����x�x�.�.��&�"&�/�/�#�"6�K��6�6��$�?�?�A�6�RV�7��� ����x�x�6�!��&�"&�/�/�#�"6�K��6�6��$�4�4�6��t�7��� �����<����6��	�	�8J�8J�K��
����;�[�I��8�8�I��&� �D��O��8�8�J��'�!�D����rc��g}|j�tvr@|j|j�j�|j�tvr�@|SrT)r�r�rUr�rH)rr|s  r�_parse_type_qualifier_listz"CParser._parse_type_qualifier_list�sD�����o�o��?�2��L�L�����.�.�/��o�o��?�2��rc�~�|jd�}|jd�|j�rF|j�}|jd�tj||j|��S|j
�}|jd�tj||j|��S)Nr-r�r�)r�r�r�r�AlignasrI�_parse_constant_expression�rrKr��exprs    rr3z"CParser._parse_alignment_specifiers����l�l�:�&�����X���#�#�%��'�'�)�C��L�L��"��=�=��d�o�o�c�&:�;�;��.�.�0�����X���}�}�T�4�?�?�3�#7�8�8rc���|jd�|jd�|j�}|jd�|jjd�|S)Nr/r�r��_Atomic)r�r�r|rU)rr�s  rr4zCParser._parse_atomic_specifiersK�����Y�����X���#�#�%�����X���	�	����#��
rrc��|�|gn|j|��g}|jd�r3|j|j|���|jd�r�3|S)Nr'�COMMA)�_parse_init_declaratorr�rU)rrr�r�s    rrz#CParser._parse_init_declarator_listse��
� ��G��-�-�g�-�>�?�	��l�l�7�#��L�L��4�4�W�4�E�F��l�l�7�#��rc��|r|j�n|j�}d}|jd�r|j�}||dd�S)Nrr�)r��_parse_declaratorr�r)rr�rmr�s    rrIzCParser._parse_init_declarator+sI��.5�t�(�(�*�4�;Q�;Q�;S�����<�<��!��*�*�,�D��d�t�<�<rc�t�|j�}|j|j�}|j�dvr�|j�}|j�dk(r�|j�|j	d�r$||jg|j|���S|j
�}|jd�||j||j|���S||jd|j|���S|j�dk(rv|j�}|j	d�r|dg|j|���S|j
�}|jd�|d||j|���S|jd|j|��y)N>r�r�r�RBRACE)r\r�rQz Invalid struct/union declaration)	r�r�rHr�r�rI�_parse_struct_declaration_listr�rG)rrK�klass�name_tokr��	brace_toks      rr8z(CParser._parse_struct_or_union_specifier7sm���m�m�o���/�/��	�	�:���?�?�� 0�0��}�}��H���� �H�,��
�
���<�<��)� �%�^�^�2�T�_�_�X�=V����;�;�=�����X�&��!���u�D�O�O�H�<U�����^�^�4�t���x�7P��
��?�?���(��
�
��I��|�|�H�%��$�b����	�8R�S�S��7�7�9�E��L�L��"��d�%�t���y�7Q�R�R����<�d�o�o�c�>R�Src��g}|j�dvr7|j�}|��%|j|�|j�dvr�7|S�N>NrM)r��_parse_struct_declarationr)rr��itemss   rrNz&CParser._parse_struct_declaration_listXsR�����o�o��'7�7��2�2�4�E��}���L�L���	�o�o��'7�7�
�rc��|j�dk(r|j�gS|j�dk(r|j�y|j�dvr|j�gS|j	�}d|jdg�vsJ�d}|j
�s|j�dk(r|j�}|�$|jd�|j||��St|d�d	k(rc|dd
}t|tj�r|}ntj|�}|jd�|j||ddd�g��S|jd�|j|dddd�g��S)Nr
r>r
rr�r��COLON�r�r�rpr
rr�)r�rr�rr=r`r��_parse_struct_declarator_listr�r�rYrqr�Noder})rr�r��node�	decl_types     rrTz!CParser._parse_struct_declarationds����?�?�� 0�0��-�-�/�0�0��?�?���&��M�M�O���?�?�� 7�7��2�2�4�5�5��3�3�5�������B� 7�7�7�7����"�"�$����(9�W�(D��6�6�8�E����L�L�� ��+�+��U�+�C�C��t�F�|���!���<��?�D��$��
�
�+� �	�!�0�0��6�	��L�L�� ��+�+�� )�4�D�I�J�,��
�
	
���V���'�'��t�T�d�K�L�(�
�	
rc��|j�g}|jd�r1|j|j��|jd�r�1|S�NrH)�_parse_struct_declaratorr�rUr#s  rrYz%CParser._parse_struct_declarator_list�sG���.�.�0�1���l�l�7�#��L�L��6�6�8�9��l�l�7�#��rc��|jd�r,|j�}tjdddd�d|d�S|j	�}|jd�r|j�}|d|d�S|ddd�S)NrWr�)r�rBrrrrK)rr�rms   rr_z CParser._parse_struct_declarator�s����<�<�� ��5�5�7�G����t�T�4��>��"��
��%�%�'���<�<�� ��5�5�7�G� �$�7�C�C��d�t�<�<rc�`�|jd�}|j�dvr�|j�}|j�dk(ra|j�|j�}|jd�t	j
|j||j|��St	j
|jd|j|��S|jd�|j�}|jd�t	j
d||j|��S)Nr2>r�r�rrM)r�r�r��_parse_enumerator_listrr�rHrI)rrKrP�enumss    rr9zCParser._parse_enum_specifier�s����l�l�6�"���?�?�� 0�0��}�}��H���� �H�,��
�
���3�3�5�����X�&��z�z�(�.�.�%�����9M�N�N��:�:�h�n�n�d�D�O�O�C�4H�I�I����X���+�+�-�����X���z�z�$��t���s�';�<�<rc�0�|j�}tj|g|j�}|j	d�rS|j�dk(r	|S|j�}|jj|�|j	d�r�S|S)NrHrM)�_parse_enumeratorr�EnumeratorListrQr�r��enumeratorsrU)r�enum�	enum_lists   rrbzCParser._parse_enumerator_list�s����%�%�'���(�(�$�����<�	��l�l�7�#���� �H�,�����)�)�+�D��!�!�(�(��.�	�l�l�7�#�
�rc��|jd�}|jd�r|j�}nd}tj|j
||j
|��}|j|j|j�|S)Nr�r)
r�r�rBr�
EnumeratorrHrIrdr\rQ)rrPrHrhs    rrezCParser._parse_enumerator�sm���<�<��%���<�<��!��3�3�5�E��E��������t���x�7P�Q�����T�Y�Y��
�
�3��rc�:�|jdd��\}}|�J�|S)NF�r�r�)r�)rrmrs   rrKzCParser._parse_declarator�s3���,�,� �5�-�
���a������rc�(�|jdd��S)Nr�T�r��allow_paren��_parse_declarator_kindrVs rr�zCParser._parse_id_declarator�s���*�*��$�*�G�Grc�(�|jdd��S)N�typeidTrorqrVs rr�z CParser._parse_typeid_declarator�s���*�*��d�*�K�Krc�(�|jdd��S)NrtFrorqrVs rr�z(CParser._parse_typeid_noparen_declarator�s���*�*��e�*�L�Lrrpc��d}|j�dk(r|j�}|j||��}|�|j||�S|S)Nr��rp)r��_parse_pointer�_parse_direct_declaratorrv)rr�rp�ptr�directs     rrrzCParser._parse_declarator_kind�sV�����?�?���'��%�%�'�C��.�.�t��.�M���?��)�)�&�#�6�6��
rc	�J�|r6|jd�r%|j|d��}|jd�n[|dk(r|jd�}n|jd�}tj|j
ddd|j
|���}|j|�S)	Nr�Trwr�r�r�r�r�)r�rrr�rrrrHrI�_parse_decl_suffixes)rr�rprmrPs     rryz CParser._parse_direct_declarator�s����4�<�<��1��.�.�t��.�F�D��L�L��"��t�|��<�<��-���<�<��1���>�>�!�������o�o�h�/��D��(�(��.�.rc���	|j�dk(r"|j||j|��}�6|j�dk(r$|j|�}|j||�}�m	|S)zAParse a chain of array/function suffixes and attach them to decl.r�r�)r�rv�_parse_array_decl�_parse_function_decl)rrmrs   rr}zCParser._parse_decl_suffixessp������ �J�.��-�-�d�D�4J�4J�4�4P�Q������ �H�,��0�0��6���-�-�d�D�9�����r�	base_declc�<�|jd|j��S�N)�	base_typerQ)�_parse_array_decl_commonrQ)rr�s  rrzCParser._parse_array_decls���,�,�t�9�?�?�,�S�Srr�c�6���|jd�}��|j|����fd�}|jd�rBdg|j�xsgz}|j	�}|jd�|||�S|j�tvr�|j�xsg}|jd�r0|dgz}|j	�}|jd�|||�S|jd�}|rI|jd�tj|j|j|��}|||�Sd}|j�r|j	�}|jd�|||�S|jd�}|rI|jd�tj|j|j|��}||g�Sd}|j�r|j	�}|jd�||g�S)a9Parse an array declarator suffix and return an ArrayDecl node.

        base_type:
            Base declarator node to attach (None for direct-declarator parsing,
            TypeDecl for abstract declarators).

        coord:
            Coordinate to use for the ArrayDecl. If None, uses the '[' token.
        r�Nc�6��tj�||���S)N)rp�dim�	dim_qualsrQ)r�	ArrayDecl)r�r�r�rQs  ��r�make_array_declz9CParser._parse_array_decl_common.<locals>.make_array_decl#s����?�?��C�9�E��
r�STATIC�static�RBRACKETr�)r�rIr�r?�_parse_assignment_expressionr�r�rr�rHr�)rr�rQ�
lbrack_tokr�r�r��	times_toks ``     rr�z CParser._parse_array_decl_commons�����\�\�*�-�
��=��O�O�J�/�E�	�
�<�<��!�!�
�d�&E�&E�&G�&M�2�N�I��3�3�5�C��L�L��$�"�3�	�2�2��?�?���/��7�7�9�?�R�I��|�|�H�%�%��
�2�	��7�7�9�����Z�(�&�s�I�6�6����W�-�I�����Z�(��h�h�y������	�0J�K��&�s�I�6�6��C��&�&�(��7�7�9���L�L��$�"�3�	�2�2��L�L��)�	���L�L��$��(�(�9�?�?�D�O�O�I�,F�G�C�"�3��+�+����"�"�$��3�3�5�C����Z� ��s�B�'�'rc��|jd�|jd�rd}nA|j�r|j�n|j	�}|jd�tj|d|j��}|j�dk(rp|j�d|jjD]K}t|t
j�r|St|dd�}|s�0|j||j��M|S)Nr�r���argsrprQrr\)r�r�r��_parse_parameter_type_list�_parse_identifier_list_optrr~rQr�r��paramsrq�
EllipsisParam�getattrrd)rr�r�r�paramr\s      rr�zCParser._parse_function_declMs������X���<�<��!��D��+�+�-��/�/�1��4�4�6�
�

�L�L��"��~�~�4�d�)�/�/�J���?�?���(�T�Y�Y�-B����)�)�
<���e�U�%8�%8�9��
��	�u�f�d�3����(�(��u�{�{�;�
<��rc��g}|jd�}|rJ|j�xsg}|j||j|�f�|jd�}|r�J|syd}|D]\}}t	j
|||��}�|S)Nr�)r|rprQ)r�r?rUrIr�PtrDecl)r�starsr�r|rzrQs      rrxzCParser._parse_pointerfs������L�L��)�	���3�3�5�;��E��L�L�%�����!;�<�=����W�-�I��
����!�	D�L�E�5��-�-�e�#�U�C�C�	D��
rc�.�|j�}|j�dk(rq|jd�dk(r]|j�|j�}|jj	tj|j|���|S�NrHr��ELLIPSIS)�_parse_parameter_listr�r�r�rUrr�rI)rr��ell_toks   rr�z"CParser._parse_parameter_type_listwsn���+�+�-���?�?���'�D�O�O�A�,>�*�,L��M�M�O��m�m�o�G��M�M� � ��!4�!4�T�_�_�W�5M�!N�O��
rc�x�|j�}tj|g|j�}|j	�dk(ru|j	d�dk7ra|j�|jj|j��|j	�dk(r|j	d�dk7r�a|Sr�)�_parse_parameter_declarationr�	ParamListrQr�r�r�rU�rrr�s   rr�zCParser._parse_parameter_list�s����1�1�3�����%��%�+�+�6���o�o��7�*�t���q�/A�Z�/O��M�M�O��M�M� � ��!B�!B�!D�E��o�o��7�*�t���q�/A�Z�/O��
rc�b�|jd��\}}}|dstjdg|��g|d<|j�rF|j	dd��\}}|r|j||ddd�g��d	S|j
|||�S|j�}|j
|||�S)
NTrrpr$rzrmr�rXr)rrr}r�r�r��_build_parameter_declarationr�)rr�rrrm�is_nameds      rr�z$CParser._parse_parameter_declaration�s���"�@�@�t�@�T���a���F�|�!�0�0�%��
�K�L�D��L��"�"�$�!�7�7�#�d�8��N�D�(���/�/��$(�$�4�H�I�0������4�4�T�4��L�L��2�2�4���0�0��t�Z�H�Hrrc�v�t|d�dkDr]t|ddj�dk(r?|j|ddjd�r|j||ddd�g��dSt	j
d|dd|xst	jdddd�|�	�}|j||d�S)
Nrpr
r^rr�rXr*r��r\r|r�rprQ)rYrrhr�r�Typenamerrr�)rr�rmrs    rr�z$CParser._build_parameter_declaration�s���
��V����!��D��L��$�*�*�+�q�0��&�&�t�F�|�B�'7�'=�'=�a�'@�A��+�+��4��$�"O�!P�,����
��~�~���v�,���?�����d�D�$�?��
���'�'��d�6�l�;�;rc�J�|j�dk(ry|j�S�Nr�)r��_parse_identifier_listrVs rr�z"CParser._parse_identifier_list_opt�s#���?�?���(���*�*�,�,rc��|j�}tj|g|j�}|j	d�r;|j
j
|j��|j	d�r�;|Sr^)�_parse_identifierrr�rQr�r�rUr�s   rr�zCParser._parse_identifier_list�s`���&�&�(�����%��%�+�+�6���l�l�7�#��M�M� � ��!7�!7�!9�:��l�l�7�#��
rc�`�|j�}|j�}d}|�
|j}n|dr|ddj}tjd|dddd|xstj
dddd�|��}t
tj|j||d��S)Nrprr*r�r�)r=r�rQrr�rrr	r�)rr�rmrQrws     rr�zCParser._parse_type_name�s����3�3�5���2�2�4�������J�J�E�
�&�\���L��O�)�)�E��>�>���v�,�q�/���?�����d�D�$�?��
���E�N�N�D�$<�$<�X�t�F�|�$T�U�Urc�(�|j�dk(r_|j�}|j�r|j�}nt	j
dddd�}|�J�|j
||�S|j�r|j�Sy)Nr�)r�rxr��!_parse_direct_abstract_declaratorrrrrv)rrzrms   rr�z&CParser._parse_abstract_declarator_opt�s����?�?���'��%�%�'�C��6�6�8��=�=�?���~�~�d�D�$��=���?�"�?��)�)�$��4�4��2�2�4��9�9�;�;�rc	�,�|jd�}|r�|j�s|j�dk(r_|j�}|j	d�tj|tjdddd�|j|���}no|j�}|j	d�|�LJ�|j�dk(r|j�}n&|jd|jj�|j�S)Nr�r�r�r�zInvalid abstract declarator)r�r�r��_parse_parameter_type_list_optr�rr~rrrIr��_parse_abstract_array_baserGr;r@r})rr�r�rms    rr�z)CParser._parse_direct_abstract_declarator�s����\�\�(�+�
���'�'�)�T�_�_�->�(�-J��<�<�>�����X�&��~�~������d�D�$�?��/�/�*�5����:�:�<�����X�&��'�'�'�
�_�_�
�*�
,��2�2�4�D����;�T�Y�Y�=O�=O�P��(�(��.�.rc�J�|j�dk(ry|j�Sr�)r�r�rVs rr�z&CParser._parse_parameter_type_list_opts#���?�?���(���.�.�0�0rc�T�|jtjdddd�d��Sr�)r�rrrrVs rr�z"CParser._parse_abstract_array_bases.���,�,��n�n�T�4��t�<�D�-�
�	
rc�0�|j�}|xxdk(rnxdk(rnn|j�Sxdk(r%|jd�dk(r|j�Sxdk(r|j�Sxxdk(rnxdk(rnn|j�Sxxd	k(rnxd
k(rnxdk(rnn|j	�Sxxdk(rnxd
k(rnxdk(rnxdk(rnn|j�Sxdk(rnxdk(rnn|j
�S	|j�S)N�CASE�DEFAULTr�r�rWr�IF�SWITCH�WHILE�DO�FOR�GOTO�BREAK�CONTINUE�RETURNrr
)r��_parse_labeled_statementr�_parse_selection_statement�_parse_iteration_statement�_parse_jump_statementr�_parse_expression_statementr�s  r�_parse_statementzCParser._parse_statements����?�?�$���#��)�#��4�4�6�6������+�w�6���4�4�6�6���5�5�7�7� �����6�6�8�8�'��4�%�'��6�6�8�8�9��'�J��9��1�1�3�3��i�'��5�5�7�7���7�7�9�9rc���|j�dvrH|j�}|j�}tj||gz|dj
��S|j�S)N>r
rr��block_itemsrQ)r��_parse_pppragma_directive_listr�r�CompoundrQ)r�pragmas�stmts   r�_parse_pragmacomp_or_statementz&CParser._parse_pragmacomp_or_statement)s_���?�?�� 7�7��9�9�;�G��(�(�*�D��>�>�g���.>�g�a�j�FV�FV�W�W��$�$�&�&rc��|j�dk(r|j�S|j�r|j�S|j	�S)Nr
)r�rr�r$r�rVs r�_parse_block_itemzCParser._parse_block_item1sK���?�?�� 0�0��,�,�.�.��#�#�%��*�*�,�,��$�$�&�&rc��g}|j�dvrf|j�}t|tj�r|j|�n|dgk7r|j
|�|j�dvr�f|SrS)r�r�rqrrZrUr)rrU�items   r�_parse_block_item_listzCParser._parse_block_item_list9sm��"$���o�o��'7�7��)�)�+�D��$��
�
�+����T�"��$������T�"��o�o��'7�7��rc� �|jd�}|jd�r&tjd|j	|���S|j�}|jd�tj||j	|���S)NrrMr�)r�r�rr�rIr�)r�
lbrace_tokr�s   rrz!CParser._parse_compound_statementDso���\�\�(�+�
��<�<��!��>�>�d�$�/�/�*�:U�V�V��1�1�3�����X���~�~�#�4�?�?�:�+F�
�	
rc��|j�}|xdk(r�|j�}|jd�|j�r|j	�}n$tj|j|��}tj|j||j|��Sxdk(r�|j�}|j�}|jd�|j�r|j	�}n$tj|j|��}tj||g|j|��Sdk(r�|j�}|jd�|j�r|j	�}n$tj|j|��}tj|g|j|��S	|jd|jj�y)Nr�rWr�r�zInvalid labeled statement)r�r�r�r�r�r�EmptyStatementrI�LabelrHrB�Case�DefaultrGr;r@)rr�rPr��case_tokrD�def_toks       rr�z CParser._parse_labeled_statementQs~���?�?�$�����=�=�?�����W�%��)�)�+��>�>�@�D� �/�/�����0I�J�D��{�{�8�>�>�4�����9R�S�S���=�=�?���6�6�8�����W�%��)�)�+��>�>�@�D� �/�/�����0I�J�D��z�z�$�������0I�J�J���-�-�/�����W�%��)�)�+��>�>�@�D� �/�/�����0H�I�D��}�}�d�V�T�_�_�W�-E�F�F���!�!�"=�t�y�y�?Q�?Q�Rrc	���|j�}|jxdk(r�|jd�|j�}|jd�|j	�}|jd�r7|j	�}t
j||||j|��St
j||d|j|��Sdk(rq|jd�|j�}|jd�|j	�}tt
j|||j|���S	|jd|j|��y)Nr�r�r��ELSEr�zInvalid selection statement)r�rpr��_parse_expressionr�r�r�IfrIr
�SwitchrG)rrK�cond�	then_stmt�	else_stmtrDr�s       rr�z"CParser._parse_selection_statementrs���m�m�o���h�h�����X�&��-�-�/�����X�&� �?�?�A�	��<�<��'� $� C� C� E�I� �8�8�D�)�Y����PS�@T�U�U��x�x��i��t���s�7K�L�L�����X�&��-�-�/�����X�&��:�:�<��'����T�4����QT�AU�(V�W�W���!�!�"?����QT�AU�Vrc	��|j�}|jxdk(ri|jd�|j�}|jd�|j	�}tj|||j|��Sxdk(r�|j	�}|jd�|jd�|j�}|jd�|jd�tj|||j|��Sdk(�r~|jd�|j�dk(s|j�r�|j�}tj||j|��}|j�}|jd�|j�}|jd�|j	�}tj|||||j|��S|j�}|jd�|j�}|jd�|j�}|jd�|j	�}tj|||||j|��S	|jd|j|��y)	Nr�r�r�r�rr�r
zInvalid iteration statement)r�rpr�r�r�r�WhilerI�DoWhiler�r�r$�DeclList�_parse_expression_opt�ForrG)rrKr�r�r�r��	next_exprs       rr�z"CParser._parse_iteration_statement�s ���m�m�o���h�h�����X�&��-�-�/�����X�&��:�:�<���{�{�4��t���s�/C�D�D���:�:�<�����W�%����X�&��-�-�/�����X�&����V�$��}�}�T�4�����1E�F�F�����X�&��?�?�$�(8�8�D�<T�<T�<V� �3�3�5�E� �>�>�%�����1E�F�D��5�5�7�D��L�L��(� $� :� :� <�I��L�L��*��>�>�@�D� �9�9�T�4��D�$�/�/�RU�BV�W�W��1�1�3�����V�$��1�1�3�����V�$� �6�6�8�	����X�&��:�:�<���y�y��t�Y��d�o�o�c�>R�S�S���!�!�"?����QT�AU�Vrc��|j�}|jxdk(rR|jd�}|jd�tj|j
|j
|��Sxdk(r6|jd�tj|j
|��Sxdk(r6|jd�tj|j
|��Sdk(r||jd�r%tjd|j
|��S|j�}|jd�tj||j
|��S	|jd|j
|��y)Nr�r�rr�r�r�zInvalid jump statement)
r�rpr�r�GotorHrI�Break�Continuer��Returnr�rG)rrKrPrDs    rr�zCParser._parse_jump_statement�s���m�m�o���h�h���<�<��-�����V�$��z�z�(�.�.�$�/�/�#�2F�G�G�����V�$��{�{�4�?�?�3�#7�8�8�����V�$��~�~�d�o�o�c�&:�;�;���<�<��'� �<�<��d�o�o�c�.B�C�C��-�-�/�����V�$��|�|�D�$�/�/�#�*>�?�?���!�!�":�D�O�O�C�<P�Qrc��|j�}|jd�}|�$tj|j	|��S|S)Nr)r�r�rr�rI)rrD�semi_toks   rr�z#CParser._parse_expression_statement�sB���)�)�+���<�<��'���<��'�'�����(A�B�B��rc�D�|j�r|j�SyrT)r�r�rVs rr�zCParser._parse_expression_opt�s ���"�"�$��)�)�+�+�rc�0�|j�}|jd�s|S||j�g}|jd�r1|j|j��|jd�r�1tj||j
�Sr^�r�r�rUr�ExprListrQ�rrD�exprss   rr�zCParser._parse_expression�sx���0�0�2���|�|�G�$��K��t�8�8�:�;���l�l�7�#��L�L��:�:�<�=��l�l�7�#��~�~�e�T�Z�Z�0�0rc��|j�dk(rG|jd�dk(r3|j�|j�}|jd�|S|j	�}|j�rL|j�j}|j�}tj||||j�S|S)Nr�r�rr�)r�r�rr��_parse_conditional_expressionr�rHr�r�
AssignmentrQ)r�comprD�op�rhss     rr�z$CParser._parse_assignment_expression�s����?�?���(�T�_�_�Q�-?�8�-K��M�M�O��1�1�3�D��L�L��"��K��1�1�3���!�!�#�����&�&�B��3�3�5�C��#�#�B��c�4�:�:�>�>��rc���|j�}|jd�rS|j�}|jd�|j	�}tj||||j�S|S)N�CONDOPrW)�_parse_binary_expressionr�r�r�r�r�	TernaryOprQ)rrD�iftrue�iffalses    rr�z%CParser._parse_conditional_expression�sb���,�,�.���<�<��!��+�+�-�F��L�L��!��8�8�:�G��?�?�4���$�*�*�E�E��r�min_prec�lhsc���|�|j�}	|j�}|�|jtvr	|St|j}||kr	|S|j}|j�|j�}	|j�}|�|jtvrn-t|j}||kDr|j
||�}nn�Rtj||||j�}��rT)
�_parse_cast_expressionrFrp�_BINARY_PRECEDENCErHr�rr�BinaryOprQ)	rr
rrK�precrr�next_tok�	next_precs	         rrz CParser._parse_binary_expressions����;��-�-�/�C���*�*�,�C��{�c�h�h�.@�@��*�
�)&�c�h�h�/�D��h���$�
�!���B��M�M�O��-�-�/�C���:�:�<���#�x�}�}�<N�'N��.�x�}�}�=�	��t�#��7�7�	�3�G�C����.�.��S�#�s�y�y�9�C�-rc�&�|j�}|�p|\}}}|j�dk(r!|j|�|j�S|j�}t	j
|||j
|��S|j�S)Nr)rr�r�r
r�CastrI�_parse_unary_expression)r�resultr�r�r�rDs      rr
zCParser._parse_cast_expression$s����0�0�2����$*�!�C��z���� �H�,����D�!��+�+�-�-��2�2�4���z�z�#�t�T�_�_�Z�-H�I�I��+�+�-�-rc��|j�}|dvrK|j�}|j�}tj|j
||j�S|dvrK|j�}|j�}tj|j
||j�S|dk(r�|j�}|j�}|�6|\}}}tj|j
||j|��S|j�}tj|j
||j|��S|dk(rr|j�}|jd�|j�}|jd�tj|j
||j|��S|j�S)N>�PLUSPLUS�
MINUSMINUS>�AND�NOT�LNOT�PLUS�MINUSr��SIZEOF�_ALIGNOFr�r�)
r�r�rr�UnaryOprHrQr
rrIr�r��_parse_postfix_expression)rr�rKrDrr�rs       rrzCParser._parse_unary_expression9sp���?�?�$���1�1��-�-�/�C��/�/�1�D��=�=����D�$�*�*�=�=��G�G��-�-�/�C��.�.�0�D��=�=����D�$�*�*�=�=��x���-�-�/�C��4�4�6�F��!�"�	��Q���}�}�S�Y�Y��T�_�_�S�5I�J�J��/�/�1�D��=�=����D�$�/�/�#�2F�G�G��z�!��-�-�/�C��L�L��"��'�'�)�C��L�L��"��=�=����C�����1E�F�F��-�-�/�/rc	��|j�}|��|\}}}|jd�}|��|jd�r9tj|tjg|j|���S|j
�}|jd�|jd�tj||�S|j|�|j�}	|jd�rC|j�}|jd�tj|||j�}�U|jd�ri|j�dk(r|j�d}	n!|j�}	|jd�tj ||	|j�}��|j�dvr�|j�}
|j�}|j"d	vr!|j%d
|j|��tj&|j(|j|��}tj*||
j(||j�}���|j�dvr@|j�}
tj,d|
j(z||j�}���	|S)
NrrMrHr�r�r�r�>�ARROW�PERIOD>r�r�zInvalid struct reference>rr�p)rr�r�CompoundLiteral�InitListrI�_parse_initializer_listr�r��_parse_primary_expressionr��ArrayRefrQr�r��_parse_argument_expression_list�FuncCallrprGr�rH�	StructRefr!)rrr�r�rr�r�rD�subr��op_tokrP�fieldrKs              rr"z!CParser._parse_postfix_expressionYs3���0�0�2����!�L�C��q����h�/�J��%��<�<��)� �0�0��U�^�^�B����
�0K�L����3�3�5�����W�%����X�&��,�,�S�$�7�7����D�!��-�-�/����|�|�J�'��,�,�.�����Z�(��~�~�d�C����<����|�|�H�%��?�?�$��0��M�M�O��D��?�?�A�D��L�L��*��~�~�d�D�$�*�*�=������ �$7�7�������=�=�?���=�=�(8�8��%�%�2�D�O�O�H�4M������������1J�K�����t�V�\�\�5�$�*�*�M������ �$>�>��m�m�o���}�}�S�3�9�9�_�d�D�J�J�G�����rc�<�|j�}|dk(r|j�S|tvs|tvs|tvr|j�S|tvr|j�S|dk(r3|j�|j�}|jd�|S|dk(r|j�S|dk(r�|j�}|jd�|j�}|jd�|j�}|jd�|j|�}tj tj"|j$|�tj&||g|�|�S|j)d|j*j,�y)Nr�r�r��_GENERIC�OFFSETOFrHzInvalid expression)r�r��
_INT_CONST�_FLOAT_CONST�_CHAR_CONST�_parse_constant�_STRING_LITERAL�_parse_unified_string_literalr�r�r��_parse_generic_selectionr��!_parse_offsetof_member_designatorrIrr-r�rHr�rGr;r@)rr�rD�off_tokr��
designatorrQs       rr*z!CParser._parse_primary_expression�sa���?�?�$���t���)�)�+�+��
�"��<�'��;�&��'�'�)�)���&��5�5�7�7��x���M�M�O��)�)�+�D��L�L��"��K��z�!��0�0�2�2��z�!��m�m�o�G��L�L��"��'�'�)�C��L�L��!��?�?�A�J��L�L��"��O�O�G�,�E��>�>��������.�����Z�0�%�8���
�	
���.��	�	�0B�0B�Crc��|jd�}|jd�|j�}|jd�|j�g}|jd�r1|j	|j��|jd�r�1|jd�tj|||j|��S)Nr3r�rHr�)r�r��_parse_generic_associationr�rUr�GenericSelectionrI)rrKrD�associationss    rr;z CParser._parse_generic_selection�s����l�l�:�&�����X���0�0�2�����W���7�7�9�:���l�l�7�#����� ?� ?� A�B��l�l�7�#����X���%�%�d�L�$�/�/�#�:N�O�Orc�F�|j�}|�&|jd|jj�|j	d�rdn|j�}|j
d�|j�}tj|||j|��S)Nr�r�rW)rFrGr;r@r�r�r�r�r�GenericAssociationrIrCs    rr@z"CParser._parse_generic_association�s����j�j�l���;����/����1C�1C�D��l�l�9�-�d�4�3H�3H�3J�����W���0�0�2���'�'��T�4�?�?�3�3G�H�Hrc�Z�|j�}	|jd�r3|j�}tj|d||j�}�E|jd�rC|j�}|j
d�tj|||j�}��	|S)Nr%�.r�r�)�_parse_identifier_or_typeidr�rr.rQr�r�r+)rr[r1rDs    rr<z)CParser._parse_offsetof_member_designator�s����/�/�1����|�|�H�%��8�8�:�����t�S�%����D����|�|�J�'��-�-�/�����Z�(��~�~�d�D�$�*�*�=�����rc���|j�}|g}|jd�r1|j|j��|jd�r�1tj||j
�Sr^r�r�s   rr,z'CParser._parse_argument_expression_list�s[���0�0�2������l�l�7�#��L�L��:�:�<�=��l�l�7�#��~�~�e�T�Z�Z�0�0rc�"�|j�SrT)r�rVs rrBz"CParser._parse_constant_expression�s���1�1�3�3rc��|jd�}tj|j|j	|��S)Nr�)r�rr�rHrIr�s  rr�zCParser._parse_identifier�s.���l�l�4� ���x�x��	�	�4�?�?�3�#7�8�8rc���|j�}|jdvr!|jd|j|��t	j
|j|j|��S)N>r�r�zExpected identifier)r�rprGrIrr�rHr�s  rrGz#CParser._parse_identifier_or_typeid�sR���m�m�o���8�8�+�+����3�T�_�_�S�5I�J��x�x��	�	�4�?�?�3�#7�8�8rc��|j�}|jtvr�d}d}|jddD]}|dvr|dz
}�
|dvs�|dz
}�|dkDrt	d��|dkDrt	d��d	|zd
|zz}tj|dz|j|j|��S|jtvrZ|jdd
vrd}n|jddvrd}nd}tj||j|j|��S|jtvr0tjd|j|j|��S|jd|j|��y)Nr���)�l�Lr
)�u�Uz.Constant cannot have more than one u/U suffix.r�z.Constant cannot have more than two l/L suffix.z	unsigned zlong r$r^)�f�F�floatzlong double�double�charzInvalid constant)r�rpr5rH�
ValueErrorr�ConstantrIr6r7rG)rrK�u_count�l_count�ch�prefixr�s       rr8zCParser._parse_constant�s_���m�m�o���8�8�z�!��G��G��i�i���n�
!����#��q�L�G��:�%��q�L�G�	
!�
��{� �!Q�R�R���{� �!Q�R�R� �7�*�W�w�->�>�F��>�>�&�5�.�#�)�)�T�_�_�S�=Q�R�R��8�8�|�#��y�y��}�
�*������2��*�,�!�����>�>�!�S�Y�Y�����0D�E�E��8�8�{�"��>�>�&�#�)�)�T�_�_�S�5I�J�J����,�d�o�o�c�.B�Crc��|j�}|jtvr!|jd|j	|��|j
j
dd�\}}|ddg}|j�tvr�|j�}|j
j
dd�\}}|xs|}|dd}|j|d|�r|j|�n
|dxx|z
cc<|j�tvr��|dzdj|�zdz}tjd||j	|��S)NzInvalid string literal�"r
r^z" "�string)
r�rpr9rGrIrH�splitr��_string_literal_needs_separatorrU�joinrrX)	rrKr\�contents�parts�tok2�next_prefix�
next_contentsrHs	         rr:z%CParser._parse_unified_string_literals%���m�m�o���8�8�?�*����6�����8L�M��9�9�?�?�3��2�����#�2�����o�o��?�2��=�=�?�D�)-���)9�)9�#�q�)A�&�K���*�{�F�)�#�2�.�M��3�3�E�"�I�}�M����]�+��b�	�]�*�	��o�o��?�2�$���u�z�z�%�0�0�3�6���~�~�h��t���s�/C�D�Dr�left�rightc�����|r|sy|dd|ddz�t�fd�dD��ry|jd�}|d	k(ry|}|d
kDr!||dz
dk(r|dz}|d
kDr||dz
dk(r�||z
dzdzd
k(ry||dzd}|jd�r"d
�|d
�vxrt�fd�|ddD��Sdt	|�cxkxrdkncxrtd�|D��xr|d
dvS)zAWhether joining two literal bodies would change their C spelling.F���Nr�c3�,�K�|]}d|z�v���
y�w)z??Nr%)�.0r[�boundarys  �r�	<genexpr>z:CParser._string_literal_needs_separator.<locals>.<genexpr>Fs�����;��t�b�y�H�$�;�s�z	=/'()!<>-T�\r^rr
�x�0123456789abcdefABCDEFc3�&�K�|]}|�v���
y�wrTr%)rmr[�
hex_digitss  �rroz:CParser._string_literal_needs_separator.<locals>.<genexpr>Zs�����1X�r�"�
�2B�1X�s��c3�$K�|]}|dv���
y�w)�01234567Nr%)rmr[s  rroz:CParser._string_literal_needs_separator.<locals>.<genexpr>`s����6��B�*�$�6�s�rw)�any�rfind�
startswith�allrY)rhri�escape_start�	run_start�escapernrts     @@rraz'CParser._string_literal_needs_separator=s3����5�����9�u�R�a�y�(���;�{�;�;���z�z�$�'���2���!�	��!�m��Y��]� 3�t� ;���N�I��!�m��Y��]� 3�t� ;��9�$�q�(�A�-��2���l�Q�&�(�)�����S�!�1�J���8�z�)�X�c�1X�V�TU�TV�Z�1X�.X�X�

��V�� �q� �
'��6�v�6�6�
'��a��J�&�	
rc��|jd�}|rj|jd�r%tjg|j|��S|j	�}|jd�|jd�|S|j
�S)NrrMrH)r�rr(rIr)r�r�)rr��	init_lists   rrzCParser._parse_initializerjst���\�\�(�+�
���|�|�H�%��~�~�b�$�/�/�*�*E�F�F��4�4�6�I��L�L��!��L�L��"����0�0�2�2rc��|j�g}|jd�rE|j�dk(rn1|j|j��|jd�r�Et	j
||dj�S)NrHrMr)�_parse_initializer_itemr�r�rUrr(rQ)rrUs  rr)zCParser._parse_initializer_listwso���-�-�/�0���l�l�7�#���� �H�,���L�L��5�5�7�8��l�l�7�#��~�~�e�U�1�X�^�^�4�4rc��d}|j�dvr|j�}|j�}|�tj||�S|S�N>r%r�)r��_parse_designationrr�NamedInitializer)r�designationr�s   rr�zCParser._parse_initializer_item�sQ�����?�?�� 6�6��1�1�3�K��&�&�(���"��)�)�+�t�<�<��rc�H�|j�}|jd�|S)Nr)�_parse_designator_listr��r�designatorss  rr�zCParser._parse_designation�s"���1�1�3�����X���rc��g}|j�dvr2|j|j��|j�dvr�2|Sr�)r�rU�_parse_designatorr�s  rr�zCParser._parse_designator_list�sF�����o�o��#9�9����t�5�5�7�8��o�o��#9�9��rc��|jd�r#|j�}|jd�|S|jd�r|j�S|j	d|j
j�y)Nr�r�r%zInvalid designator)r�rBr�rGrGr;r@)rrDs  rr�zCParser._parse_designator�sc���<�<�
�#��2�2�4�D��L�L��$��K��<�<��!��3�3�5�5����.��	�	�0B�0B�Crc�h�|jd�}|jd|j|��y)Nr	zDirectives not supported yet)r�rGrIr�s  rrzCParser._parse_pp_directive�s*���l�l�8�$�����8�$�/�/�#�:N�Orc�x�|j�dk(r�|j�}|j�dk(r?|j�}tj|j|j|��Stjd|j|��S|j�dk(rg|j�}|j
d�}|j�}|j
d�tj||j|��S|jd|jj�y)Nr�PPPRAGMASTRr*r
r�r�zInvalid pragma)r�r�r�PragmarHrIr�r:rGr;r@)rrK�str_tok�lparen�literals     rrz!CParser._parse_pppragma_directive�s����?�?��
�*��-�-�/�C���� �M�1��-�-�/���|�|�G�M�M�4�?�?�7�3K�L�L��<�<��D�O�O�C�$8�9�9��?�?��	�)��-�-�/�C��\�\�(�+�F��8�8�:�G��L�L��"��<�<������)@�A�A����*�D�I�I�,>�,>�?rc��g}|j�dvr2|j|j��|j�dvr�2|S)N>r
r)r�rUr)rr�s  rr�z&CParser._parse_pppragma_directive_list�sC�����o�o��#:�:��N�N�4�9�9�;�<��o�o��#:�:��rc�<�|jd�}|jd�|j�}d}|jd�r|j�}|jd�|jd�t	j
|||j
|��S)Nr
r�rHr�r)r�rBr�r:r�StaticAssertrI)rrKr�rPs    rrzCParser._parse_static_assert�s����l�l�+�,�����X���.�.�0�����<�<�� ��4�4�6�C����X�����V���!�!�$��T�_�_�S�-A�B�Br)r*FrT)rN)F�r
)FF)rr�r�)rr�)T)rN)�rrr r!r�boolrpr"r?rrrLr$rrOrrGrWr[rbrdrhr7r8r9r:rrZrvr�r�r��listr�rr�r�r�r�rrFr�r�r�r�r�r�rIr�r�r�r��tupler�r�r�r�r�rrErrr$r"rrrr=r?r3r4rrIr8rNrTrYr_r9rbrerKr�r�r�rrryr}rr�r�rxr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr�r�r�r�r�r�r�r�r�rr
rr"r*rAr;rDr@r<r,rBr�rGr8rXr:�staticmethodrarr)r�r�r�r�rrr�r�rr%rrr)r)/s8��	�"�$�(�"�*� ��=��=��F�|�=��	=�
�=��
=��=��=�
�=�:<A����#&��48��	����6J�S�J�#��*�J��J�,��,�E�C�K�$�,>�,�8�,�%� �
+�c�+�%�$�,�+�4�+�	,�C�	,����	,��	,��c��d��:�3�:�c�:�3�:�4�:���,�#�,�$�,�R�c��S��U�Z�Z��X(��j�j�5�=�=�(�5�>�>�9�(��s�)�(�
���e�m�m�	#�e�n�n�	4�	(�^���;�'�����	�
��
�
�<#(�	b��b��K� �b� �	b�

�e�j�j�	�b�H
��
��j�j�
��%�*�*�%��,�	
�
�j�j�
�
���

�*�����$�s�$�5�4�<�$�5�C�5��d�
�5�
�%��	�#�	�%�$�,�	��#��%��#�s�#�!�3�!�4�!�3�e�3��3�'�u�t�|�'�t�'�.�e�d�l�.�d�.�)�4�)�,�$�,�4�,�#�E�#��*�d�2B�,C�#�NS��"��FJ��	�u�z�z�D� �$�&�	'��6!�E�#��*�d�2B�,C�!�F;�D�;�?�4�?�%�	�u�~�~�s�E�)�	*�T�	1�%�6=�%�-�-�=���e�j�j�)9��M�T�%�*�*�-=�M�n�D����$4��?�$�u�z�z�"2�?�*��*�+/�*�	
�e�j�j�	�*�Z��e�j�j�)9��%*�v+�!�v+�	�{�D�%�$�,�.�	/�v+�v`�F�D��I��9�E�J�J�9������DI���k�*��<@��	
�k�	��=�d�=�{�=�T�%�*�*�T�B��U�Z�Z�0@��"
�4��
�
�+;�d�+B�"
�J�t�K�/@��=�$=�u�z�z�=�"��
�
���5�:�:���5�:�:��H�e�j�j�H�L�%�*�*�L�M�%�*�*�M��3��T��e�j�j��.2�/��/�&*�/�	���/�*������
�
��T�5�:�:�T�%�*�*�T�CG�7(����d�*�7(�38�4�<�7(�	���7(�t�e�j�j��U�Z�Z��2��
�
�T� 1��"�E�O�O���u����I�e�j�j�I�(<��<�',�z�z�D�'8�<�FK�d�l�<�	���<�,-�E�J�J��,=�-���
�
��V�%�.�.�V�(
��
�
�T�0A�
�$/�5�:�:�/�.1����$�0F�1�
�E�J�J�
�:�%�*�*�:�*'��
�
�'�'�5�:�:��U�Z�Z�0@�#@�'���U�Z�Z�(8��
�5�:�:�
�S�%�*�*�S�BW�E�J�J�W�2&W�E�J�J�&W�TR�u�z�z�R�.�U�Z�Z���u�z�z�D�'8��1�5�:�:�1��e�j�j�� �u�z�z��;?����&+�j�j�4�&7��	����D.��
�
�.�*0����0�@4�5�:�:�4�p!D�5�:�:�!D�J	P�%�*@�*@�	P�I�E�,D�,D�I�
�5�:�:�
� 1����1�4�E�J�J�4�9�5�:�:�9�
9�U�Z�Z�9�D����D�D E�u�~�~� E�D�$
�c�$
�#�$
�$�$
��$
�X
3�E�J�J�
3�5����5�������D����$4����U�Z�Z�(8��D�5�:�:�D�P�X�P�@�5�:�:�@�$��U�Z�Z�0@��	C�e�&8�&8�	Crr)>r�OREQUAL�ANDEQUAL�DIVEQUAL�MODEQUAL�XOREQUAL�	PLUSEQUAL�
MINUSEQUAL�
TIMESEQUAL�LSHIFTEQUAL�RSHIFTEQUAL�LOR�LAND�ORr��XORrur��EQ��NE�GT��GE�LT�LE�RSHIFT��LSHIFTr�rr��	�DIVIDE�MOD>�AUTO�EXTERNr��TYPEDEF�REGISTER�
_THREAD_LOCAL�INLINE�	_NORETURN>�CONSTr/�RESTRICT�VOLATILE>�INT�CHAR�LONG�VOID�FLOAT�SHORT�_BOOL�DOUBLE�SIGNED�UNSIGNED�_COMPLEX�__INT128>r2r0r1r�r/r->r�rrrrrr�r�rr4rr r3r>�
INT_CONST_BIN�
INT_CONST_DEC�
INT_CONST_HEX�
INT_CONST_OCT�INT_CONST_CHAR�FLOAT_CONST�HEX_FLOAT_CONST>�
CHAR_CONST�WCHAR_CONST�U8CHAR_CONST�
U16CHAR_CONST�
U32CHAR_CONST>�STRING_LITERAL�WSTRING_LITERAL�U8STRING_LITERAL�U16STRING_LITERAL�U32STRING_LITERAL>r�r�r�r�r�rr�r�rr�r�r�r
r�rc�v�eZdZdZdeddfd�Zddededzfd�Zdedzfd�Z	defd	�Z
d
eddfd�Zdeddfd
�Zy)r=z�Wraps a lexer to provide convenient, buffered access to the underlying
    token stream. The lexer is expected to be initialized with the input
    string already.
    r,rNc�.�||_g|_d|_y)Nr)�_lexer�_buffer�_index)rr,s  rr?z_TokenStream.__init__]	s�����+-�����rr�c�n�|dkry|j|�|j|j|zdz
S)z�Peek at the k-th next token in the stream, without consuming it.

        Examples:
            k=1 returns the immediate next token.
            k=2 returns the token after that.
        rNr
��_fillr�r�r�s  rr�z_TokenStream.peekb	s5��
��6���
�
�1�
��|�|�D�K�K�!�O�a�/�0�0rc��|jd�|j|j}|xjdz
c_|S)z%Consume a single token and return it.r
r�r�s  rr�z_TokenStream.nextn	s2���
�
�1�
��l�l�4�;�;�'�����q����
rc��|jSrT�r�rVs rr�z_TokenStream.markz	s���{�{�rr�c��||_yrTr�r�s  rr�z_TokenStream.reset}	s	����r�nc��t|j�|j|zkr_|jj	�}|jj|�|�yt|j�|j|zkr�^yyrT)rYr�r�r�r�rU)rr�rKs   rr�z_TokenStream._fill�	sb���$�,�,��$�+�+��/�1��+�+�#�#�%�C��L�L����$��{��	�$�,�,��$�+�+��/�1rr�)
rrr r!rr?r$rr�r�r�r�r�r%rrr=r=W	ss���
�f����

1�c�
1�%�$�,�
1��e�d�l���c���#��$���s��t�rr=c�^�eZdZUeeed<eeed<eeed<eeed<eeed<y)r�r�r�rpr�r�N)rrr r�rr#r%rrr�r��	s2��
�s�)�O�
�#�Y��
�s�)�O��3�i���C�y�rr�r�c�z�eZdZUejdzed<ejdzed<ejdzed<y)r�Nrmr�r�)rrr rrZr#r%rrr�r��	s1��
�*�*�t�
��
�*�*�t�
��
�Z�Z�$�
�rr�N)'�dataclassesr�typingrrrrrr	r*r�ast_transformsrr
�c_lexerrrr�	Exceptionr'r)r�rr5r6r�r7r��_EXPR_STARTr5r6r7r9r�r�r=r�r�r�r%rr�<module>r�s��"����C�"������$	��	�`"C�`"C�FE��"�	�1��
�A��	�!��
�1�	�

�1��	�!�
�	�!��	�!��	�!��	�!��	�!��
�a��
�a���A���Q�� �Q�!�"
�a�#�$
�1�%��*V���K�(��>��
�� �������C�	C����"�
��0�1�������*��|�+�k�9�O�K����&.�.�n�	���J�K�
��	�r

Zerion Mini Shell 1.0
GEPRES Tracking

República de Moçambique

Ministério da Economia e Finanças