%PDF- %PDF-
Mini Shell

Mini Shell

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

�

�h�j�V��<�ddlmZddlmZddlmZGd�d�Zy)�)�Callable)�ClassVar�)�c_astc�6
�eZdZUdZeed<eed<dmdeddfd�Zdefd�Z	de
jdefd	�Zde
jdzdefd
�Z
de
jdefd�Zde
j defd
�Zde
j$defd�Zde
j(defd�Zde
j,defd�Zde
j0defd�Zde
j4defd�Zde
j8defd�Zde
j<defd�Zidd�dd�dd�dd�dd�dd �d!d �d"d#�d$d#�d%d#�d&d#�d'd(�d)d(�d*d+�d,d+�d-d.�d/d.�d0d.i�Z e!e"eefed1<de
jFdefd2�Z$de
jJdefd3�Z&de
jNdefd4�Z(de
jdefd5�Z)dmde
jTd6edefd7�Z+de
jXdefd8�Z-de
j\defd9�Z/de
j`defd:�Z1de
jddefd;�Z3de
jhdefd<�Z5de
jldefd=�Z7de
jpdefd>�Z9de
jtdefd?�Z;de
jxdefd@�Z=de
j|defdA�Z?de
j�defdB�ZAde
j�defdC�ZCde
j�defdD�ZEde
j�defdE�ZGde
j�defdF�ZIde
j�defdG�ZKde
j�defdH�ZMde
j�defdI�ZOde
j�defdJ�ZQde
j�defdK�ZSde
j�defdL�ZUde
j�defdM�ZWde
j�defdN�ZYde
j�defdO�Z[de
j�defdP�Z]de
j�defdQ�Z_de
j�defdR�Zade
j�defdS�Zcde
j�defdT�Zede
j�defdU�Zgde
j�defdV�Zide
j�defdW�Zkde
j�defdX�Zmde
j�defdY�Zode
j�defdZ�Zqde
j�defd[�Zsde
j�defd\�Zude
j�e
j�ze
jlzd]edefd^�Zvd_ewe
jdefd`�Zxd_ewe
jtdefda�Zydmde
jdbedefdc�Zzde
jTdefdd�Z{			dnde
jdeewe
jdzdfedgedef
dh�Z|de
jdie}e
jgefdefdj�Z~de
jdefdk�Zde
jdefdl�Z�y)o�
CGeneratorz�Uses the same visitor pattern as c_ast.NodeVisitor, but modified to
    return a value from each visit method, using string accumulation in
    generic_visit.
    �indent_level�reduce_parentheses�returnNc� �d|_||_y)z�Constructs C-code generator

        reduce_parentheses:
            if True, eliminates needless parentheses on binary operators
        rN)r	r
)�selfr
s  �Q/root/parts/certbot/install/lib/python3.12/site-packages/pycparser/c_generator.py�__init__zCGenerator.__init__s�����"4���c� �d|jzS�N� )r	)r
s r�_make_indentzCGenerator._make_indent#s���T�&�&�&�&r�nodec�n�d|jjz}t|||j�|�S)N�visit_)�	__class__�__name__�getattr�
generic_visit)r
r�methods   r�visitzCGenerator.visit&s2���D�N�N�3�3�3��8�w�t�V�T�%7�%7�8��>�>rc�Z��|�ydj�fd�|j�D��S)N�c3�F�K�|]\}}�j|����y�w�N�r)�.0�c_name�cr
s   �r�	<genexpr>z+CGenerator.generic_visit.<locals>.<genexpr>.s�����J�Y�V�Q�4�:�:�a�=�J�s�!)�join�children)r
rs` rrzCGenerator.generic_visit*s&����<���7�7�J�$�-�-�/�J�J�Jr�nc��|jSr!)�value�r
r)s  r�visit_ConstantzCGenerator.visit_Constant0s���w�w�rc��|jSr!��namer,s  r�visit_IDzCGenerator.visit_ID3s���v�v�
rc�F�d}|jr|d|jzz
}|S)Nz#pragmar)�string)r
r)�rets   r�visit_PragmazCGenerator.visit_Pragma6s%�����8�8��3����>�!�C��
rc��|j|j�}|dz|j|j�zdzS)N�[�])�_parenthesize_unless_simpler0r�	subscript)r
r)�arrrefs   r�visit_ArrayRefzCGenerator.visit_ArrayRef<s7���1�1�!�&�&�9����|�d�j�j����5�5��;�;rc��|j|j�}||jz|j|j�zSr!)r9r0�typer�field)r
r)�srefs   r�visit_StructRefzCGenerator.visit_StructRef@s6���/�/����7���a�f�f�}�t�z�z�!�'�'�2�2�2rc��|j|j�}|j�|j|j�nd}|dz|zdzS)Nr�(�))r9r0�argsr)r
r)�frefrEs    r�visit_FuncCallzCGenerator.visit_FuncCallDsG���/�/����7��%&�V�V�%7�t�z�z�!�&�&�!�R���c�z�D� �3�&�&rc����j|j�}dj�fd�|jD��}d|�d|�d�S)N�, c3�@�K�|]}�j|����y�wr!r")r#�ar
s  �rr&z4CGenerator.visit_GenericSelection.<locals>.<genexpr>Ms����� G�1����A�� G���z	_Generic(rD)�_visit_expr�exprr'�associations)r
r)rNrOs`   r�visit_GenericSelectionz!CGenerator.visit_GenericSelectionIsF���������'���y�y� G���� G�G���4�&��<�.��2�2rc��|j�|j|j�nd}|�d|j|j���S)N�defaultz: )r>rrMrN)r
r)�typs   r�visit_GenericAssociationz#CGenerator.visit_GenericAssociationPs@��$%�F�F�$6�d�j�j���� �I����b��)�)�!�&�&�1�2�3�3rc�N�|jxdk(r d|j|j��d�Sxdk(r!|j|j�}|�d�Sdk(r |j|j�}|�d�S	|j|j�}|j�|��S)N�sizeofzsizeof(rDzp++z++zp--z--)�oprrNr9)r
r)�operands   r�
visit_UnaryOpzCGenerator.visit_UnaryOpTs����d�d��!����A�F�F�!3� 4�A�6�6���:�:�1�6�6�B��!��"�~�%���:�:�1�6�6�B��!��"�~�%���:�:�1�6�6�B���$�$���y�)�)rz||rz&&r�|��^��&�z==�z!=�>�z>=�<z<=z>>�z<<�+��-�*�	�/�%�precedence_mapc�����j�j��fd��}�j�j��fd��}|�d�j�d|��S)Nc�����j|�xs]�jxrOt|tj�xr3�j
|j�j
�jk\Sr!��_is_simple_noder
�
isinstancer�BinaryOprlrW��dr)r
s ��r�<lambda>z+CGenerator.visit_BinaryOp.<locals>.<lambda>�sj����(�(��+�O��.�.�O�"�1�e�n�n�5�O��+�+�A�D�D�1�T�5H�5H����5N�N�	�rc�����j|�xs]�jxrOt|tj�xr3�j
|j�j
�jkDSr!rorss ��rruz+CGenerator.visit_BinaryOp.<locals>.<lambda>�sj����(�(��+�N��.�.�N�"�1�e�n�n�5�N��+�+�A�D�D�1�D�4G�4G����4M�M�	�rr)�_parenthesize_if�left�rightrW)r
r)�lval_str�rval_strs``  r�visit_BinaryOpzCGenerator.visit_BinaryOp|s\����(�(�
�F�F�
�

��$�(�(�
�G�G�
�

����1�Q�T�T�F�!�H�:�.�.rc��|j|jd��}|j|j��d|j�d|��S)Nc�6�t|tj�Sr!)rqr�
Assignment)r)s rruz-CGenerator.visit_Assignment.<locals>.<lambda>�s��
�1�e�.>�.>� ?�rr)rw�rvaluer�lvaluerW)r
r)r{s   r�visit_AssignmentzCGenerator.visit_Assignment�sG���(�(�
�H�H�?�
���*�*�Q�X�X�&�'�q�����a��z�:�:rc�8�dj|j�Sr)r'�namesr,s  r�visit_IdentifierTypezCGenerator.visit_IdentifierType�s���x�x���� � rc��|xtjd�x�\d|j|�zdzSxtjd�x�\nxtjd�x�\nnd|j|�zdzS	|j|�S)N��{�}rCrD)r�InitListr�ExprList�Compoundr,s  rrMzCGenerator._visit_expr�sr���!����!��T�Z�Z��]�*�S�0�0�"�!����!�$4�E�N�N�$4�4��T�Z�Z��]�*�S�0�0���z�z�!�}�$r�no_typec��|r|j|jd��n|j|�}|jr!|d|j	|j�zz
}|j
r!|d|j
|j
�zz
}|S)NF)�emit_base_typez : � = )�_generate_typer>�_generate_decl�bitsizer�initrM)r
r)r��ss    r�
visit_DeclzCGenerator.visit_Decl�s���
�
������u��=��$�$�Q�'�	
�

�9�9�
�����A�I�I�.�.�.�A��6�6�
���)�)�!�&�&�1�1�1�A��rc�����j|jd�}t|j�dkDr-|ddj�fd�|jddD��zz
}|S)NrrrIc3�D�K�|]}�j|d�����y�w)T)r�N)r��r#�declr
s  �rr&z,CGenerator.visit_DeclList.<locals>.<genexpr>�s#�����"�8<�����d��3�"�s� )r�decls�lenr'�r
r)r�s`  r�visit_DeclListzCGenerator.visit_DeclList�sc����J�J�q�w�w�q�z�"���q�w�w�<�!��
���	�	�"�@A������"���
�A��rc��d}|jr!|dj|j�dzz
}||j|j�z
}|S)Nrr)�storager'r�r>r�s   r�
visit_TypedefzCGenerator.visit_Typedef�sH�����9�9�
����!�)�)�$�s�*�*�A�	�T�
 �
 ����
(�(���rc��d|j|jd��zdz}|dz|j|j�zS)NrCF��
emit_declnamerDr)r��to_typer9rNr�s   r�
visit_CastzCGenerator.visit_Cast�sC���$�%�%�a�i�i�u�%�E�E��K���3�w��9�9�!�&�&�A�A�Arc��g}|jD]"}|j|j|���$dj|�S�NrI��exprs�appendrMr'�r
r)�visited_subexprsrNs    r�visit_ExprListzCGenerator.visit_ExprList��D�����G�G�	<�D��#�#�D�$4�$4�T�$:�;�	<��y�y�)�*�*rc��g}|jD]"}|j|j|���$dj|�Sr�r�r�s    r�visit_InitListzCGenerator.visit_InitList�r�rc�(�|j|d��S)N�enumr/��_generate_struct_union_enumr,s  r�
visit_EnumzCGenerator.visit_Enum�s���/�/���/�?�?rc�@�d|j|j��d�S)Nz	_Alignas(rD)r�	alignmentr,s  r�
visit_AlignaszCGenerator.visit_Alignas�s���4�:�:�a�k�k�2�3�1�5�5rc���|js|j��|j�d�S|j��|j�d|j|j��d�S)Nz,
r�)r+rr0rr,s  r�visit_EnumeratorzCGenerator.visit_Enumerator�s[���w�w��'�'�)�*�1�6�6�(�#�6�6��'�'�)�*�1�6�6�(�#�d�j�j����6I�5J�#�N�Nrc����j|j�}d�_�j|j�}|jr5dj�fd�|jD��}|dz|zdz|zdzS|dz|zdzS)Nr�;
c3�@�K�|]}�j|����y�wr!r")r#�pr
s  �rr&z+CGenerator.visit_FuncDef.<locals>.<genexpr>�s�����!G�A�$�*�*�Q�-�!G�rL�
)rr�r	�body�param_declsr')r
r)r�r��knrdeclss`    r�
visit_FuncDefzCGenerator.visit_FuncDef�s�����z�z�!�&�&�!������z�z�!�&�&�!���=�=��z�z�!G����!G�G�H��$�;��)�E�1�D�8�4�?�?��$�;��%��,�,rc��d}|jD]v}|xtjd�x�\||j|�z
}�0tjd�x�\||j|�dzz
}�^	||j|�dzz
}�x|S)Nrr�r�r�)�extr�FuncDefr�Pragma)r
r)r�r�s    r�
visit_FileASTzCGenerator.visit_FileAST�s������5�5�	1�C��$�U�]�]�_�����C��(�A�%��\�\�^�����C��4�/�/�A�$������C��5�0�0�A�	1��rc����j�dz}�xjdz
c_|jr'|dj�fd�|jD��z
}�xjdzc_|�j�dzz
}|S)N�{
r[rc3�@�K�|]}�j|����y�wr!��_generate_stmt)r#�stmtr
s  �rr&z,CGenerator.visit_Compound.<locals>.<genexpr>
s�����M�t��,�,�T�2�M�rLz}
)rr	�block_itemsr'r�s`  r�visit_CompoundzCGenerator.visit_Compoundsy�������%�'�����Q����=�=�
����M�q�}�}�M�M�M�A����Q���	�T�
�
�
 �5�
(�(���rc��d|j|j�zdz|j|j�zdzS)NrCz){r�)rr>r�r,s  r�visit_CompoundLiteralz CGenerator.visit_CompoundLiterals6���T�Z�Z����'�'�$�.����A�F�F�1C�C�c�I�Irc��y)N�;r�r,s  r�visit_EmptyStatementzCGenerator.visit_EmptyStatements��rc�L��dj�fd�|jD��S)NrIc3�@�K�|]}�j|����y�wr!r")r#�paramr
s  �rr&z-CGenerator.visit_ParamList.<locals>.<genexpr>s�����A�u����E�*�A�rL)r'�paramsr,s` r�visit_ParamListzCGenerator.visit_ParamLists����y�y�A����A�A�Arc�j�d}|jr!|d|j|j�zz
}|dzS)Nrrr�)rNrr�s   r�visit_ReturnzCGenerator.visit_Returns3�����6�6�
��t�z�z�!�&�&�)�)�)�A��3�w�rc��y)Nzbreak;r�r,s  r�visit_BreakzCGenerator.visit_Breaks��rc��y)Nz	continue;r�r,s  r�visit_ContinuezCGenerator.visit_Continue!s��rc���d|j|j�zdz}|d|j|j�zdzz
}|d|j|j�zdzz
}|S)NrCz) ? z) : rD)rM�cond�iftrue�iffalser�s   r�visit_TernaryOpzCGenerator.visit_TernaryOp$sk���$�"�"�1�6�6�*�*�V�3��	�S�4�#�#�A�H�H�-�
-��
6�6��	�S�4�#�#�A�I�I�.�
.��
4�4���rc�,�d}|jr||j|j�z
}|dz
}||j|jd��z
}|jr6||j�dzz
}||j|jd��z
}|S)Nzif (�)
T��
add_indentzelse
)r�rr�r�r�rr�s   r�visit_IfzCGenerator.visit_If*s������6�6�
����A�F�F�#�#�A�	�U�
��	�T�
 �
 ����d�
 �
;�;���9�9�
��"�"�$�x�/�/�A�
��$�$�Q�Y�Y�4�$�@�@�A��rc�p�d}|jr||j|j�z
}|dz
}|jr!|d|j|j�zz
}|dz
}|jr!|d|j|j�zz
}|dz
}||j	|j
d��z
}|S)Nzfor (r�rr�Tr�)r�rr��nextr�r�r�s   r�	visit_ForzCGenerator.visit_For5s������6�6�
����A�F�F�#�#�A�	�S����6�6�
��t�z�z�!�&�&�)�)�)�A�	�S����6�6�
��t�z�z�!�&�&�)�)�)�A�	�U�
��	�T�
 �
 ����D�
 �
9�9���rc��d}|jr||j|j�z
}|dz
}||j|jd��z
}|S)N�while (r�Tr�)r�rr�r�r�s   r�visit_WhilezCGenerator.visit_WhileCsQ�����6�6�
����A�F�F�#�#�A�	�U�
��	�T�
 �
 ����D�
 �
9�9���rc���d}||j|jd��z
}||j�dzz
}|jr||j	|j�z
}|dz
}|S)Nzdo
Tr�r�z);)r�r�rr�rr�s   r�
visit_DoWhilezCGenerator.visit_DoWhileKsi����	�T�
 �
 ����D�
 �
9�9��	�T�
�
�
 �9�
,�,���6�6�
����A�F�F�#�#�A�	�T�	���rc��d}||j|j�z
}|jr#|dz
}||j|j�z
}|dz
}|S)Nz_Static_assert(rIrD)rr��messager�s   r�visit_StaticAssertzCGenerator.visit_StaticAssertTsS����	�T�Z�Z����
����9�9�
��I�A�
����A�I�I�&�&�A�	�S����rc��d|j|j�zdz}||j|jd��z
}|S)Nzswitch (r�Tr�)rr�r�r�r�s   r�visit_SwitchzCGenerator.visit_Switch]sA������A�F�F�+�+�e�3��	�T�
 �
 ����D�
 �
9�9���rc��d|j|j�zdz}|jD]}||j|d��z
}�|S)Nzcase �:
Tr�)rrN�stmtsr��r
r)r�r�s    r�
visit_CasezCGenerator.visit_CasebsP���d�j�j����(�(�5�0���G�G�	<�D�
��$�$�T�d�$�;�;�A�	<��rc�X�d}|jD]}||j|d��z
}�|S)Nz	default:
Tr�)r�r�r�s    r�
visit_DefaultzCGenerator.visit_Defaulths9�����G�G�	<�D�
��$�$�T�d�$�;�;�A�	<��rc�X�|jdz|j|j�zS)Nr�)r0r�r�r,s  r�visit_LabelzCGenerator.visit_Labelns$���v�v��~�� 3� 3�A�F�F� ;�;�;rc�&�d|jzdzS)Nzgoto r�r/r,s  r�
visit_GotozCGenerator.visit_Gotoqs�������#�%�%rc��y)Nz...r�r,s  r�visit_EllipsisParamzCGenerator.visit_EllipsisParamts��rc�&�|j|d�S)N�structr�r,s  r�visit_StructzCGenerator.visit_Structws���/�/��8�<�<rc�8�|j|j�Sr!)r�r>r,s  r�visit_TypenamezCGenerator.visit_Typenamezs���"�"�1�6�6�*�*rc�&�|j|d�S)N�unionr�r,s  r�visit_UnionzCGenerator.visit_Union}s���/�/��7�;�;rc��d}|jD]I}t|tj�r|d|jzz
}�0|d|j	|�zdzz
}�K|d|j|j�zz
}|S)Nr�.r7r8r�)r0rqr�IDrrMrN)r
r)r�r0s    r�visit_NamedInitializerz!CGenerator.visit_NamedInitializer�s|�����F�F�	2�D��$����)��S�4�9�9�_�$���S�4�:�:�d�+�+�c�1�1��		2�
	
�U�T�%�%�a�f�f�-�
-�-���rc�$�|j|�Sr!�r�r,s  r�visit_FuncDeclzCGenerator.visit_FuncDecl�s���"�"�1�%�%rc�(�|j|d��S�NFr�rr,s  r�visit_ArrayDeclzCGenerator.visit_ArrayDecl�����"�"�1�E�"�:�:rc�(�|j|d��Srrr,s  r�visit_TypeDeclzCGenerator.visit_TypeDecl�rrc�(�|j|d��Srrr,s  r�
visit_PtrDeclzCGenerator.visit_PtrDecl�rrr0c�>�|dvrEt|tjtjf�sJ�|j}|j
}nS|dk(sJ�t|tj�sJ�|j�dn|jj}|j}|dz|jxsdz}|�h|dz
}||j�z
}|xjdz
c_|dz
}|||�z
}|xjdzc_||j�d	zz
}|S)
zlGenerates code for structs, unions, and enums. name should be
        'struct', 'union', or 'enum'.
        )rrr�Nrrr�r[r�r�)
rqr�Struct�Unionr��_generate_struct_union_body�Enum�values�enumerators�_generate_enum_bodyr0rr	)r
r)r0�members�
body_functionr�s      rr�z&CGenerator._generate_struct_union_enum�s���&�&��a�%�,�,����!<�=�=�=��g�g�G� �<�<�M��6�>�!�>��a����,�,�,��h�h�.�d�A�H�H�4H�4H�G� �4�4�M��3�J�!�&�&�,�B�'����
��I�A�
��"�"�$�$�A�����"��
��J�A�
��w�'�'�A�����"��
��"�"�$�s�*�*�A��rr%c�8��dj�fd�|D��S)Nrc3�@�K�|]}�j|����y�wr!r�r�s  �rr&z9CGenerator._generate_struct_union_body.<locals>.<genexpr>�s�����E�T�t�*�*�4�0�E�rL�r'�r
r%s` rr z&CGenerator._generate_struct_union_body�s����w�w�E�W�E�E�Erc�D��dj�fd�|D��dddzS)Nrc3�@�K�|]}�j|����y�wr!r")r#r+r
s  �rr&z1CGenerator._generate_enum_body.<locals>.<genexpr>�s�����>�U�t�z�z�%�(�>�rL���r�r)r*s` rr$zCGenerator._generate_enum_body�s$����w�w�>�g�>�>�s��C�d�J�Jrr�c��|r|xjdz
c_|j�}|r|xjdzc_|xxtjd�x�\�noxtjd�x�\�nVxtj
d�x�\�n=xtjd�x�\�n$xtjd�x�\�nxtjd�x�\n�xtjd�x�\n�xtjd�x�\n�xtjd�x�\n�xtjd�x�\n�xtjd�x�\n{xtjd�x�\ncxtjd�x�\nKxtj d�x�\n3xtj"d�x�\nxtj$d�x�\nn||j'|�zdzSxtj(d�x�\|j'|�Stj*d�x�\||j'|�zS	||j'|�zdzS)z�Generation from a statement node. This method exists as a wrapper
        for individual visit_* methods to handle different treatment of
        some statements in this context.
        r[r�r�r�)r	rr�Declr�Cast�UnaryOprr�	TernaryOp�FuncCall�ArrayRef�	StructRef�Constantr�Typedefr��CompoundLiteral�GenericSelection�StaticAssertrr��If)r
r)r��indents    rr�zCGenerator._generate_stmt�s���
�����"���"�"�$�������"���'���
�
���$�%�"�"�$�$��%�*�*�,�,�!�%�-�-�/�/�"�%�.�.�"�"�#�%�/�/�#�"�%�.�.�"�"�%�.�.�"�#�%�/�/�#�"�%�.�.�"��%�(�(�*�!�%�-�-�/�"�%�.�.�"�)�%�'�'�)�*�%�(�(�*�&�%�$�$�&�'�&��
�
�1�
�-��5�5�!����!�
�z�z�!�}�$�"�������
�
�1�
�-�-�����
�
�1�
�-��4�4rc�b��d}|jrdj|j�dz}|jr!|dj|j�dzz
}|jr*|dj�fd�|jD��dzz
}|�j	|j
�z
}|S)zGeneration from a Decl node.rrc3�@�K�|]}�j|����y�wr!r")r#�alignr
s  �rr&z,CGenerator._generate_decl.<locals>.<genexpr>�s�����A��$�*�*�U�+�A�rL)�funcspecr'r�r?r�r>r�s`  rr�zCGenerator._generate_decl�s�������:�:�������$�s�*�A��9�9�
����!�)�)�$�s�*�*�A��7�7�
����A����A�A�C�G�G�A�	�T�
 �
 ����
(�(���r�	modifiersr�r�c��|�g}|xtjd�x��\d}|rK|jr!|dj|j�dzz
}||j	|j
�z
}|jr|r|jnd}t|�D�]\}}|xtjd�x��\|dk7r(t||dz
tj�rd|zdz}|dz
}|jr!|dj|j�dzz
}|j�||j	|j�z
}|d	z
}��xtjd�x�f\|dk7r(t||dz
tj�rd|zdz}|j�|j	|j�nd}	|d|	zdzz
}��)tjd�x�B\|jr-dj|j�}
|rd|��nd}d
|
�|��}��xd|z}�����|s|S|r|d|zz
}|Sxtjd�x�\|j!|j
�Sxtj"d�x�!\|j%|j
||��Sxtj&d�x�!\dj|j(�dzSxtjd�x�\n3xtjd�x�\nxtjd�x�\nn$|j%|j
||gz||��S	|j	|�S)
a|Recursive generation from a type node. n is the type node.
        modifiers collects the PtrDecl, ArrayDecl and FuncDecl modifiers
        encountered on the way down to a TypeDecl, to allow proper
        generation from it.
        emit_base_type controls whether the shared type specifier and its
        qualifiers are emitted, independently of the declarator parts.
        r�rrrrrCrDr7r8z* rh)r�r�)r�TypeDecl�qualsr'rr>�declname�	enumerate�	ArrayDeclrq�PtrDecl�	dim_quals�dim�FuncDeclrEr/r��Typenamer��IdentifierTyper�)r
r)rAr�r�r��nstr�i�modifierrErD�suffixs            rr�zCGenerator._generate_type�s�����I��!����!���!��w�w��S�X�X�a�g�g�.��4�4������A�F�F�+�+�A�%&�Z�Z�M�q�z�z�r��
$-�Y�#7�2�K�A�x�"�.�U�_�_�.� �A�v�*�Y�q�1�u�5E�u�}�}�*U�'*�T�z�C�'7�� �C�K�D�'�1�1� $�����1C�1C�(D�s�(J� J��'�|�|�7� $��
�
�8�<�<�(@� @�� �C�K�D�/�.�U�^�^�-� �A�v�*�Y�q�1�u�5E�u�}�}�*U�'*�T�z�C�'7��$,�=�=�#<�!%�
�
�8�=�=� 9�%'�!�
!�C�$�J��$4�4�D�.�#�]�]�_�'�~�~�(+������(@��7;�1�T�F����)+�E�7�6�(�';��'*�T�z��
-�)2�6&��K����t��O�A���W"�X������*�*�1�6�6�2�2��!����!��*�*��F�F�"/�#1�+���"�(��%�%�'��x�x����(�3�.�.�(�"����"�_�U�]�]�_�7G�u�~�~�7G�G��*�*��F�F����O�"/�#1�	+�����z�z�!�}�$r�	conditionc�H�|j|�}||�rd|zdzS|S)z�Visits 'n' and returns its string representation, parenthesized
        if the condition function applied to the node returns True.
        rCrD)rM)r
r)rRr�s    rrwzCGenerator._parenthesize_ifDs.��
���Q����Q�<���7�S�=� ��Hrc�.���j|�fd��S)z$Common use case for _parenthesize_ifc�(���j|�Sr!)rp)rtr
s �rruz8CGenerator._parenthesize_unless_simple.<locals>.<lambda>Rs���d�6J�6J�1�6M�2M�r)rwr,s` rr9z&CGenerator._parenthesize_unless_simplePs����$�$�Q�(M�N�Nrc	���t|tjtjtjtj
tjtjf�S)zyReturns True for nodes that are "simple" - i.e. nodes that always
        have higher precedence than operators.
        )rqrr6rr4r5r3r9r,s  rrpzCGenerator._is_simple_nodeTsE���
�����������������&�&�

�

�
	
r)F)NTT)�r�
__module__�__qualname__�__doc__�int�__annotations__�boolr�strrr�Noderrr6r-rr1r�r5r4r<r5rAr3rGr9rP�GenericAssociationrTr1rYrlr�dictrrr|rr�rMr�rMr/r��DeclListr�r7r�r0r�r�r�r�r�r!r��Alignasr��
Enumeratorr�r�r��FileASTr�r�r�r8r��EmptyStatementr��	ParamListr��Returnr��Breakr��Continuer�r2r�r;r��Forr��Whiler��DoWhiler�r:r��Switchr��Caser��Defaultr��Labelr�Gotor�
EllipsisParamrrrrLr
rr
�NamedInitializerrrKrrGrrCrrHrr��listr r$r�r�r�rrwr9rpr�rrrrs����
����	5�4�	5�D�	5�'�c�'�?�%�*�*�?��?�K�%�*�*�t�"3�K��K������3���%�(�(��s���e�l�l��s��<����<�3�<�3����3�S�3�'����'�3�'�
3��(>�(>�3�3�3�4�%�*B�*B�4�s�4�*�u�}�}�*��*�"0�	
�a�0�	
�a�	0�
	�Q�0�	�Q�
0�	�Q�0�	
�a�0�	
�a�0�	�Q�0�	
�a�0�	�Q�0�	
�a�0�	
�a�0�	
�a�0� 	�Q�!0�"	�Q�#0�$	�Q�%0�&	�Q�'0�(	�Q�)0�N�H�T�#�s�(�^�,��.'/����'/�3�'/�R;�%�"2�"2�;�s�;�!�e�&:�&:�!�s�!�%�U�Z�Z�%�C�%��E�J�J����#�������3���u�}�}����B�E�J�J�B�3�B�+����+�3�+�+����+�3�+�@�E�J�J�@�3�@�6�u�}�}�6��6�O�%�"2�"2�O�s�O�-�u�}�}�-��-�
�u�}�}�
��
������3��J�u�'<�'<�J��J��e�&:�&:��s��B����B�S�B��e�l�l��s���U�[�[��S�������3�������S��	�%�(�(�	�s�	��5�9�9�����U�[�[��S���u�}�}�����E�$6�$6��3���e�l�l��s��
�E�J�J��3���u�}�}����<�U�[�[�<�S�<�&�E�J�J�&�3�&��U�%8�%8��S��=�e�l�l�=�s�=�+����+�3�+�<�U�[�[�<�S�<���(>�(>��3��&����&�3�&�;����;�S�;�;����;�3�;�;�u�}�}�;��;��������+�e�j�j�8��@C��	��8F�4��
�
�3C�F��F�K�4��0@�0@�+A�K�c�K�*5��
�
�*5��*5��*5�X
��
�
�
�s�
�.2�"�#�Q%��:�:�Q%���
�
�#�d�*�Q%��	Q%�
�Q%�

�
Q%�f
����
�(0�%�*�*��t�1C�(D�
�	�
�O�U�Z�Z�O�C�O�
����
��
rrN)�collections.abcr�typingrrrrr�rr�<module>rws��%���S	
�S	
r

Zerion Mini Shell 1.0
GEPRES Tracking

República de Moçambique

Ministério da Economia e Finanças