Your IP : 216.73.216.52


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

�

q[�i�P��8�ddlmZmZmZddlmZGd�d�Zy)�)�Callable�List�Optional�)�c_astc	��	�eZdZUdZeed<eed<djdeddfd�Zdefd�Z	de
jdefd	�Zde
e
jdefd
�Zde
jdefd�Zde
j"defd
�Zde
j&defd�Zde
j*defd�Zde
j.defd�Zde
j2defd�Zde
j6defd�Zidd�dd�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,i�Zde
j<defd/�Zde
j@defd0�Z!de
jDdefd1�Z#de
jdefd2�Z$djde
jJd3edefd4�Z&de
jNdefd5�Z(de
jRdefd6�Z*de
jVdefd7�Z,de
jZdefd8�Z.de
j^defd9�Z0de
jbdefd:�Z2de
jfdefd;�Z4de
jjdefd<�Z6de
jndefd=�Z8de
jrdefd>�Z:de
jvdefd?�Z<de
jzdefd@�Z>de
j~defdA�Z@de
j�defdB�ZBde
j�defdC�ZDde
j�defdD�ZFde
j�defdE�ZHde
j�defdF�ZJde
j�defdG�ZLde
j�defdH�ZNde
j�defdI�ZPde
j�defdJ�ZRde
j�defdK�ZTde
j�defdL�ZVde
j�defdM�ZXde
j�defdN�ZZde
j�defdO�Z\de
j�defdP�Z^de
j�defdQ�Z`de
j�defdR�Zbde
j�defdS�Zdde
j�defdT�Zfde
j�defdU�Zhde
j�defdV�Zjde
j�defdW�Zlde
j�defdX�Znde
j�defdY�Zpde
j�e
j�ze
jbzdZedefd[�Zqd\ere
jdefd]�Zsd\ere
jjdefd^�Ztdjde
jd_edefd`�Zude
jJdefda�Zvgdbfde
jdcere
jddedefde�Zwde
jdfexe
jgefdefdg�Zyde
jdefdh�Zzde
jdefdi�Z{y)k�
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)�selfrs  ��/build/snapcraft-certbot-8ace4148c346cc61c23dfdbf9a13f72e/parts/certbot/install/lib/python3.12/site-packages/pycparser/c_generator.py�__init__zCGenerator.__init__s�����"4���c� �d|jzS�N� )r
)rs r�_make_indentzCGenerator._make_indent"s���T�&�&�&�&r�nodec�n�d|jjz}t|||j�|�S)N�visit_)�	__class__�__name__�getattr�
generic_visit)rr�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�crs   �r�	<genexpr>z+CGenerator.generic_visit.<locals>.<genexpr>-s�����J�Y�V�Q�4�:�:�a�=�J�s�!)�join�children)rrs` rrzCGenerator.generic_visit)s&����<���7�7�J�$�-�-�/�J�J�Jr�nc��|jSr")�value�rr*s  r�visit_ConstantzCGenerator.visit_Constant/s���w�w�rc��|jSr"��namer-s  r�visit_IDzCGenerator.visit_ID2s���v�v�
rc�F�d}|jr|d|jzz
}|S)Nz#pragmar)�string)rr*�rets   r�visit_PragmazCGenerator.visit_Pragma5s%�����8�8��3����>�!�C��
rc��|j|j�}|dz|j|j�zdzS)N�[�])�_parenthesize_unless_simpler1r�	subscript)rr*�arrrefs   r�visit_ArrayRefzCGenerator.visit_ArrayRef;s7���1�1�!�&�&�9����|�d�j�j����5�5��;�;rc��|j|j�}||jz|j|j�zSr")r:r1�typer�field)rr*�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 �(�))r:r1�argsr)rr*�frefrFs    r�visit_FuncCallzCGenerator.visit_FuncCallCsG���/�/����7��%&�V�V�%7�t�z�z�!�&�&�!�R���c�z�D� �3�&�&rc�N�|jxdk(r d|j|j��d�Sxdk(r!|j|j�}|�d�Sdk(r |j|j�}|�d�S	|j|j�}|j�|��S)N�sizeofzsizeof(rEzp++z++zp--z--)�opr�exprr:)rr*�operands   r�
visit_UnaryOpzCGenerator.visit_UnaryOpHs����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<<�+��-�*�	�/�%c�����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�BinaryOp�precedence_maprK��dr*rs ��r�<lambda>z+CGenerator.visit_BinaryOp.<locals>.<lambda>|sg����$�$�Q�'�K��*�*�K��q�%�.�.�1�K��'�'����-��1D�1D�Q�T�T�1J�J�	�rc�����j|�xs]�jxrOt|tj�xr3�j
|j�j
�jkDSr"rcrhs ��rrjz+CGenerator.visit_BinaryOp.<locals>.<lambda>�sg����$�$�Q�'�J��*�*�J��q�%�.�.�1�J��'�'����-��0C�0C�A�D�D�0I�I�	�rr)�_parenthesize_if�left�rightrK)rr*�lval_str�rval_strs``  r�visit_BinaryOpzCGenerator.visit_BinaryOpps\����(�(�
�F�F�
�
�� �(�(�
�G�G�
�
����1�Q�T�T�F�!�H�:�.�.rc��|j|jd��}|j|j��d|j�d|��S)Nc�6�t|tj�Sr")rer�
Assignment)r*s rrjz-CGenerator.visit_Assignment.<locals>.<lambda>�s��
�1�e�.>�.>� ?�rr)rl�rvaluer�lvaluerK)rr*rps   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��{�}rDrE)r�InitListr�ExprList�Compoundr-s  r�_visit_exprzCGenerator._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|jn|j|�}|jr!|d|j|j�zz
}|jr!|d|j|j�zz
}|S)Nz : � = )r1�_generate_decl�bitsizer�initr�)rr*r��ss    r�
visit_DeclzCGenerator.visit_Decl�si���A�F�F�4�#6�#6�q�#9���9�9�
�����A�I�I�.�.�.�A��6�6�
���)�)�!�&�&�1�1�1�A��rc�����j|jd�}t|j�dkDr-|ddj�fd�|jddD��zz
}|S)Nrr�, c3�D�K�|]}�j|d�����y�w)T)r�N)r��r$�declrs  �rr'z,CGenerator.visit_DeclList.<locals>.<genexpr>�s#�����"�8<�����d��3�"�s� )r�decls�lenr(�rr*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)Nr r)�storager(�_generate_typer?r�s   r�
visit_TypedefzCGenerator.visit_Typedef�sH�����9�9�
����!�)�)�$�s�*�*�A�	�T�
 �
 ����
(�(���rc��d|j|jd��zdz}|dz|j|j�zS)NrDF��
emit_declnamerEr)r��to_typer:rLr�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�Nr���exprs�appendr�r(�rr*�visited_subexprsrLs    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�enumr0��_generate_struct_union_enumr-s  r�
visit_EnumzCGenerator.visit_Enum�s���/�/���/�?�?rc�V�dj|j|j��S)Nz_Alignas({}))�formatr�	alignmentr-s  r�
visit_AlignaszCGenerator.visit_Alignas�s ���$�$�T�Z�Z����%<�=�=rc��|js+dj|j�|j��Sdj|j�|j|j	|j���S)Nz{indent}{name},
)�indentr1z{indent}{name} = {value},
)r�r1r,)r,r�rr1rr-s  r�visit_EnumeratorzCGenerator.visit_Enumerator�sq���w�w�&�-�-��(�(�*��V�V�.��
�
1�7�7��(�(�*��V�V��j�j����)�8��
rc����j|j�}d�_�j|j�}|jr5dj�fd�|jD��}|dz|zdz|zdzS|dz|zdzS)Nr�;
c3�@�K�|]}�j|����y�wr"r#)r$�prs  �rr'z+CGenerator.visit_FuncDef.<locals>.<genexpr>�s�����!G�A�$�*�*�Q�-�!G����
)rr�r
�body�param_declsr()rr*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)Nr r|r�r�)�extr�FuncDefr�Pragma)rr*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�{
rPr c3�@�K�|]}�j|����y�wr"��_generate_stmt)r$�stmtrs  �rr'z,CGenerator.visit_Compound.<locals>.<genexpr>�s�����M�t��,�,�T�2�M�r�z}
)rr
�block_itemsr(r�s`  r�visit_CompoundzCGenerator.visit_Compound�sy�������%�'�����Q����=�=�
����M�q�}�}�M�M�M�A����Q���	�T�
�
�
 �5�
(�(���rc��d|j|j�zdz|j|j�zdzS)NrDz){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)Nr�c3�@�K�|]}�j|����y�wr"r#)r$�paramrs  �rr'z-CGenerator.visit_ParamList.<locals>.<genexpr>
s�����A�u����E�*�A�r�)r(�paramsr-s` r�visit_ParamListzCGenerator.visit_ParamList	s����y�y�A����A�A�Arc�j�d}|jr!|d|j|j�zz
}|dzS)Nrrr�)rLrr�s   r�visit_ReturnzCGenerator.visit_Returns3�����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_Continues��rc���d|j|j�zdz}|d|j|j�zdzz
}|d|j|j�zdzz
}|S)NrDz) ? z) : rE)r��cond�iftrue�iffalser�s   r�visit_TernaryOpzCGenerator.visit_TernaryOpsk���$�"�"�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_Ifs������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_For)s������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_While7sQ�����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_DoWhile?si����	�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(�,rE)rr��messager�s   r�visit_StaticAssertzCGenerator.visit_StaticAssertHsS����	�T�Z�Z����
����9�9�
��H�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_SwitchQsA������A�F�F�+�+�e�3��	�T�
 �
 ����D�
 �
9�9���rc��d|j|j�zdz}|jD]}||j|d��z
}�|S)Nzcase �:
Tr�)rrL�stmtsr��rr*r�r�s    r�
visit_CasezCGenerator.visit_CaseVsP���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_Default\s9�����G�G�	<�D�
��$�$�T�d�$�;�;�A�	<��rc�X�|jdz|j|j�zS)Nr�)r1r�r�r-s  r�visit_LabelzCGenerator.visit_Labelbs$���v�v��~�� 3� 3�A�F�F� ;�;�;rc�&�d|jzdzS)Nzgoto r�r0r-s  r�
visit_GotozCGenerator.visit_Gotoes�������#�%�%rc��y)Nz...r|r-s  r�visit_EllipsisParamzCGenerator.visit_EllipsisParamhs��rc�&�|j|d�S)N�structr�r-s  r�visit_StructzCGenerator.visit_Structks���/�/��8�<�<rc�8�|j|j�Sr")r�r?r-s  r�visit_TypenamezCGenerator.visit_Typenamens���"�"�1�6�6�*�*rc�&�|j|d�S)N�unionr�r-s  r�visit_UnionzCGenerator.visit_Unionqs���/�/��7�;�;rc��d}|jD]I}t|tj�r|d|jzz
}�0|d|j	|�zdzz
}�K|d|j|j�zz
}|S)Nr �.r8r9r�)r1rer�IDrr�rL)rr*r�r1s    r�visit_NamedInitializerz!CGenerator.visit_NamedInitializerts|�����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�r
r-s  r�visit_ArrayDeclzCGenerator.visit_ArrayDecl�����"�"�1�E�"�:�:rc�(�|j|d��Srr
r-s  r�visit_TypeDeclzCGenerator.visit_TypeDecl�rrc�(�|j|d��Srr
r-s  r�
visit_PtrDeclzCGenerator.visit_PtrDecl�rrr1c�>�|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'.
        )rrr�Nrr r�rPr�r~)
rer�Struct�Unionr��_generate_struct_union_body�Enum�values�enumerators�_generate_enum_bodyr1rr
)rr*r1�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��rrc�8��dj�fd�|D��S)Nr c3�@�K�|]}�j|����y�wr"r�r�s  �rr'z9CGenerator._generate_struct_union_body.<locals>.<genexpr>�s�����E�T�t�*�*�4�0�E�r��r(�rrs` rrz&CGenerator._generate_struct_union_body�s����w�w�E�W�E�E�Erc�D��dj�fd�|D��dddzS)Nr c3�@�K�|]}�j|����y�wr"r#)r$r,rs  �rr'z1CGenerator._generate_enum_body.<locals>.<genexpr>�s�����>�U�t�z�z�%�(�>�r����r�r#r$s` rrzCGenerator._generate_enum_body�s$����w�w�>�g�>�>�s��C�d�J�Jrr�c��|r|xjdz
c_|j�}|r|xjdzc_|xxtjd�x�\�n$xtjd�x�\�nxtj
d�x�\n�xtjd�x�\n�xtjd�x�\n�xtjd�x�\n�xtjd�x�\n�xtjd�x�\n{xtjd�x�\ncxtjd�x�\nKxtjd�x�\n3xtjd�x�\nxtjd�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.
        rPr|r�r�)r
rr�Declrt�Cast�UnaryOprf�	TernaryOp�FuncCall�ArrayRef�	StructRef�Constantr
�Typedefr�rr��If)rr*r�r�s    rr�zCGenerator._generate_stmt�s]��
�����"���"�"�$�������"���#���
�
���$�%�"�"�$�$��%�*�*�,�!�%�-�-�/�"�%�.�.�"�#�%�/�/�#�"�%�.�.�"�"�%�.�.�"�#�%�/�/�#�"�%�.�.�"��%�(�(�*�!�%�-�-�/�"�%�.�.�"�#�"��
�
�1�
�-��5�5�!����!�
�z�z�!�}�$�"�������
�
�1�
�-�-�����
�
�1�
�-��4�4rc�T�d}|jrdj|j�dz}|jr!|dj|j�dzz
}|jr$||j	|jd�dzz
}||j|j�z
}|S)zGeneration from a Decl node.r rr)�funcspecr(r��alignrr�r?r�s   rr�zCGenerator._generate_decl�s������:�:�������$�s�*�A��9�9�
����!�)�)�$�s�*�*�A��7�7�
����A�G�G�A�J�'�#�-�-�A�	�T�
 �
 ����
(�(���rT�	modifiersr�c�v�|xtjd�x��\d}|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}�����|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)
z�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.
        r|r rrrrDrEr8r9z* r]r�)r�TypeDecl�qualsr(rr?�declname�	enumerate�	ArrayDeclre�PtrDecl�	dim_quals�dim�FuncDeclrFr)r��Typenamer��IdentifierTypery)rr*r6r�r��nstr�i�modifierrFr9�suffixs           rr�zCGenerator._generate_type�s����!����!����7�7�����!�'�'�*�S�0�0�A��T�Z�Z����'�'��%&�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���t��O�A���Q"�R������*�*�1�6�6�2�2��!����!��*�*�1�6�6��*�O�O�"�'��%�%�'��x�x����(�3�.�.�(�"����"�_�U�]�]�_�7G�u�~�~�7G�G��*�*��F�F�I���O�=�+�����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.
        rDrE)r�)rr*rGr�s    rrlzCGenerator._parenthesize_if&s.��
���Q����Q�<���7�S�=� ��Hrc�.���j|�fd��S)z$Common use case for _parenthesize_ifc�(���j|�Sr")rd)rirs �rrjz8CGenerator._parenthesize_unless_simple.<locals>.<lambda>4s���d�6J�6J�1�6M�2M�r)rlr-s` rr:z&CGenerator._parenthesize_unless_simple2s����$�$�Q�(M�N�Nrc��t|tjtjtjtj
tjf�S)zyReturns True for nodes that are "simple" - i.e. nodes that always
        have higher precedence than operators.
        )rerr0r
r.r/r-r-s  rrdzCGenerator._is_simple_node6s6���
�
�^�^�U�X�X�u�~�~�u������W�
�	
r)F)|r�
__module__�__qualname__�__doc__�int�__annotations__�boolr�strrr�Noderrrr0r.r
r2r�r6r.r=r/rBr-rHr+rNrgrfrqrtrwrBrzr�r)r��DeclListr�r1r�r*r�r�r�rr�rr��Alignasr��
Enumeratorr�r�r��FileASTr�r�r��CompoundLiteralr��EmptyStatementr��	ParamListr��Returnr��Breakr��Continuer�r,r�r2r��Forr��Whiler��DoWhiler��StaticAssertr��Switchr��Caser��Defaultr��Labelr��Gotor��
EllipsisParamr�rrrArrr�NamedInitializerrr@rr<rr8rr=rr�rrrr�r�r�rrlr:rdr|rrr	r	s%���
����	5�4�	5�D�	5�'�c�'�?�%�*�*�?��?�K�(�5�:�:�"6�K�3�K������3���%�(�(��s���e�l�l��s��<����<�3�<�3����3�S�3�'����'�3�'�
*�u�}�}�*��*�"�	
�a��	
�a�	�
	�Q��	�Q�
�	�Q��	
�a��	
�a��	�Q��	
�a��	�Q��	
�a��	
�a��	
�a�� 	�Q�!�"	�Q�#�$	�Q�%�&	�Q�'�(	�Q�)�N�.#/����#/�3�#/�J;�%�"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�@�>�u�}�}�>��>��%�"2�"2��s��-�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�T
��
�
�
�s�
�')�"�	A%��:�:�A%���
�
�#�A%��	A%�


�A%�F
����
�(0�%�*�*��t�1C�(D�
�	�
�O�U�Z�Z�O�C�O�
����
��
rr	N)�typingrrrr rr	r|rr�<module>rjs��,�+��o
�o
r