403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.216.115
Web Server : Apache
System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64
User : sws1074145052 ( 1074145052)
PHP Version : 8.3.32
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /usr/lib/python3/dist-packages/pythran/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /usr/lib/python3/dist-packages/pythran/__pycache__/backend.cpython-311.pyc
�

cR�aE���j�dZddlmZmZmZddlmZmZmZmZddlm	Z	m
Z
mZddlmZm
Z
ddlmZmZmZmZddlmZmZmZmZmZddlmZmZmZmZdd	lmZmZmZmZm Z dd
lm!Z!m"Z"m#Z#m$Z$m%Z%m&Z&ddl'm(Z(ddl)m*Z*dd
l+m,Z,ddl-m.Z.m/Z/ddl-m0Z0ddl1m2Z2m3Z3ddl4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:m;Z;ddl6m<Z<m=Z=ddl>m?Z?m@Z@ddlAmBZBmCZCddlDZEddlFZFddlGmHZHddlIZIGd�de*��ZJd'd�ZKd�ZLGd�d��ZMd�ZN	d(d�ZO	d'd �ZPGd!�d"eEjQ��ZRGd#�d$eR��ZSGd%�d&e*��ZTdS))z~
This module contains all pythran backends.
    * Cxx dumps the AST into C++ code
    * Python dumps the AST into Python code
�)�LocalNodeDeclarations�GlobalDeclarations�Scope)�YieldPoints�
IsAssigned�
ASTMatcher�AST_any)�RangeValues�PureExpressions�Dependencies)�
Immediates�	Ancestors)�Template�Include�	Namespace�CompilationUnit)�	Statement�Block�AnnotatedStatement�Typedef�Label)�Value�FunctionDeclaration�EmptyStatement�Nop)�FunctionBody�Line�ReturnStatement�Struct�Assign)�For�While�	TryExcept�
ExceptHandler�If�AutoFor)�OMPDirective)�Backend)�PythranSyntaxError)�operator_to_lambda�update_operator_to_lambda)�pythran_ward)�PYTYPE_TO_CTYPE_TABLE�TYPE_TO_SUFFIX)�Types)�attr_to_path�pushpop�cxxid�isstr�isnum)�
isextslice�ispowi)�metadata�unparse)�isnan�isinfN)�reducec�(��eZdZdZ�fd�Zd�Z�xZS)�Pythona
    Produces a Python representation of the AST.

    >>> import gast as ast, pythran.passmanager as passmanager
    >>> node = ast.parse("print('hello world')")
    >>> pm = passmanager.PassManager('test')
    >>> print(pm.dump(Python, node))
    print('hello world')
    c�d��d|_tt|�����dS�N�)�result�superr=�__init__��self�	__class__s ��1/usr/lib/python3/dist-packages/pythran/backend.pyrCzPython.__init__-s,������
�f�d���$�$�&�&�&�&�&�c��tj��}tj||��|���|_dS�N)�io�StringIOr8�Unparser�getvaluerA)rE�node�outputs   rG�visitzPython.visit1s5����������v�&�&�&��o�o�'�'����rH)�__name__�
__module__�__qualname__�__doc__rCrQ�
__classcell__�rFs@rGr=r="sQ���������'�'�'�'�'�(�(�(�(�(�(�(rHr=c��|sdgt|��z}|r(td�t||��D��|��S|S)Nc�n�g|]2\}}d�||rd�|��nd����3S)ztypename {0} {1}�= {0}r@��format)�.0�t�ds   rG�
<listcomp>ztemplatize.<locals>.<listcomp><sR��
4�
4�
4���A� �
&�
&�q�q�*H�'�.�.��*;�*;�*;�b�
I�
I�
4�
4�
4rH)�lenr�zip)rO�types�
default_typess   rG�
templatizere7sf���,����U���+�
����
4�
4��U�M�2�2�
4�
4�
4����	�
�rHc����fd�}|S)a�
    Decorator for loop node (For and While) to handle "else" branching.

    Decorated node will save flags for a goto statement used instead of usual
    break and add this flag at the end of the else statements.

    Examples
    --------
    >> for i in range(12):
    >>     if i == 5:
    >>         break
    >> else:
    >>     ... some code ...

    Becomes

    >> for(type i : range(12))
    >>     if(i==5)
    >>         goto __no_breaking0;
    >> ... some code ...
    >> __no_breaking0;
    c�����|js;t�jd��5��|��}ddd��n#1swxYwY|Sd�t	|����}t�j|��5��|��}ddd��n#1swxYwY�fd�|jD��}|�jvrt
|��g}ng}t|g|z|z��S)zw
        New decorate function.

        It push the breaking flag, run the visitor and add "else" statements.
        Nz__no_breaking{0}c�:��g|]}��|����S��rQ�r]�stmtrEs  �rGr`z2cxx_loop.<locals>.loop_visitor.<locals>.<listcomp>js%���;�;�;�t�$�*�*�T�"�"�;�;�;rH)�orelser1�break_handlersr\�id�
used_breakrr)rErO�res�
break_handlerrm�orelse_labelrQs`     �rG�loop_visitorzcxx_loop.<locals>.loop_visitorZsz�����{�	���,�d�3�3�
(�
(��e�D�$�'�'��
(�
(�
(�
(�
(�
(�
(�
(�
(�
(�
(����
(�
(�
(�
(��J�*�1�1�"�T�(�(�;�;�
�
�T�(�-�
8�
8�	$�	$��%��d�#�#�C�	$�	$�	$�	$�	$�	$�	$�	$�	$�	$�	$����	$�	$�	$�	$�<�;�;�;�t�{�;�;�;���D�O�+�+�!�-�0�0�1�L�L��L��c�U�V�^�l�2�3�3�3s�
8�<�<�<
B�B�Bri)rQrts` rG�cxx_loopruCs$���.4�4�4�4�4�,�rHc�"�eZdZdd�Zd�Zd�ZdS)�CachedTypeVisitorNc�4�|�;t��|_t��|_t��|_dS|j���|_|j���|_|j���|_dSrJ)�dict�cache�rcache�mapping�copy)rE�others  rGrCzCachedTypeVisitor.__init__uso���=����D�J��&�&�D�K��6�6�D�L�L�L���)�)�+�+�D�J��,�+�+�-�-�D�K� �=�-�-�/�/�D�L�L�LrHc��||jvr�|�|��}||jvrz||jvrA|j|j||j|<|j|j||j|<n0||j|<t	|j��|j|<||j|<d�|j|��S)Nz	__type{0})r|�generater{rzrar\)rErOr^s   rG�__call__zCachedTypeVisitor.__call__s����t�|�#�#��
�
�d�#�#�A��4�<�'�'����#�#�)-��d�k�!�n�)E�D�L��&�'+�z�$�+�a�.�'A�D�J�t�$�$�%)�D�K��N�),�T�\�):�):�D�L��&�'(�D�J�t�$��!�!�$�,�t�"4�5�5�5rHc	�l�t|j���d����}t��}t	��}|D]k\}}||vrbdt|��z}|�tt|j	||������|�
|���l|S)Nc��|dS)N�ri��xs rG�<lambda>z,CachedTypeVisitor.typedefs.<locals>.<lambda>�s
���!��rH��key�__type)�sortedr|�items�list�set�str�appendrrrz�add)rE�kv�L�visited�k�v�typenames       rG�typedefszCachedTypeVisitor.typedefs�s���
�D�L�&�&�(�(�n�n�
=�
=�
=���F�F���%�%���	�	�D�A�q�����#�c�!�f�f�,�������t�z�!�}�h�!?�!?�@�@�A�A�A����A������rHrJ)rRrSrTrCr�r�rirHrGrwrwssF������0�0�0�0�6�6�6�	�	�	�	�	rHrwc�4�|rd�|��ndS)NrZr@r[)r_s rG�make_defaultr��s�� !�)�7�>�>�!����r�)rHc
��|�dgt|��z}|�g}t��}t|jj��t|jj��z
}	t	t|||����D]r\}
\}}}
t
|t��s|
|	krd}nd}t||zd�	|t|
������}|�|���stt||��|g|�R�S)Nr@z&&�{0}{1})
rar��args�defaults�	enumeraterb�
isinstance�CxxGeneratorrr\r�r�r)rErO�rtype�name�ftypes�fargsr��
attributes�	arguments�
first_default�ir^�ar_�
rvalue_ref�arguments                rG�make_function_declarationr��s�����6�C��K�K�'�����
����I���	��'�'�#�d�i�.@�*A�*A�A�M�!�#�f�e�X�">�">�?�?�#�#���9�A�q�!��d�L�)�)�	�Q�-�-?�-?��J�J��J���Z������L��O�O�)L�)L�M�M������"�"�"�"��u�U�D�1�1�9�J�z�J�J�J�JrHc
�0�t|||||||dg��S)N�const)r�)rErOr�r�r�r�r�s       rG�make_const_function_declarationr��s'��$�T�4���f�e�%-��y�:�:�:rHc�v��eZdZdZd�Zd�Zd�Zd�Z�fd�Zd7d�Z	d	�Z
d
�Zd�Zd�Z
d
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zed���Zed���Zd�Zd�Zd�Z d�Z!d �Z"d!�Z#d"�Z$d#�Z%d$�Z&d%�Z'd&�Z(d'�Z)d(�Z*d)�Z+d*�Z,d+�Z-d,�Z.d-�Z/d.�Z0d/�Z1d0�Z2d1�Z3d2�Z4d3�Z5d4�Z6d5�Z7d6�Z8�xZ9S)8�CxxFunctionaz
    Attributes
    ----------
    ldecls : {str}
        set of local declarations.
    break_handler : [str]
        It contains flags for goto statements to jump on break in case of
        orelse statement in loop. None means there are no orelse statement so
        no jump are requiered.
        (else in loop means : don't execute if loop is terminated with a break)
    c�|�||_g|_t��|_d|_t��|_dS�z4 Basic initialiser gathering analysis informations. N)�parentrnr�rp�ldecls�openmp_deps)rEr�s  rGrCzCxxFunction.__init__�s5����� ����%�%�������5�5����rHc�,�t|j|��SrJ)�getattrr�)rE�attrs  rG�__getattr__zCxxFunction.__getattr__�s���t�{�D�)�)�)rHc��|j|�|��}|�|j��}|s|Sg}|D]O}|�|��}t	d�||����}|�|���P|j�|��t||gz��S)z�
        Declare variable local to node and insert declaration before.

        Not possible for function yielding values.
        �{} {})
�scope�
differencer��typeofrr\r�r��difference_updater)	rErO�node_visited�skipped�
local_vars�locals_visited�varname�vartype�decls	         rG�process_localszCxxFunction.process_locals�s����Z��%�0�0��9�9�
��*�*�4�+;�<�<�
��	 �����!�	(�	(�G��k�k�'�*�*�G��W�^�^�G�W�=�=�>�>�D��!�!�$�'�'�'�'���%�%�j�1�1�1��^�|�n�4�5�5�5rHc��|j�d�|jD����|j�d�|jD����dS)Nc3�$K�|]}|jV��dSrJ�ro�r]r_s  rG�	<genexpr>z1CxxFunction.visit_OMPDirective.<locals>.<genexpr>�s$����@�@����@�@�@�@�@�@rHc3�$K�|]}|jV��dSrJr�r�s  rGr�z1CxxFunction.visit_OMPDirective.<locals>.<genexpr>�s$����?�?����?�?�?�?�?�?rH)r��update�private_deps�shared_deps�rErOs  rG�visit_OMPDirectivezCxxFunction.visit_OMPDirective�sZ������@�@�d�.?�@�@�@�@�@�@�����?�?�d�.>�?�?�?�?�?�?�?�?rHc�~��tj||��tt|���|��SrJ)r7rQrBr��rErOrFs  �rGrQzCxxFunction.visit�s3�����t�T�"�"�"��[�$�'�'�-�-�d�3�3�3rHNc���tj|t��}|rlt��}|D]/}�fd�|jD��|_|�|���0|�t
||��}nt
|||��||<|S)z�
        Add OpenMP pragma on the correct stmt in the correct order.

        stmt may be a list. On this case, index have to be specify to add
        OpenMP on the correct statement.
        c�:��g|]}��|����Srirj)r]�deprEs  �rGr`z8CxxFunction.process_omp_attachements.<locals>.<listcomp>�s#���!L�!L�!L�c�$�*�*�S�/�/�!L�!L�!LrH)r7�getr'r��depsr�r)rErOrl�index�omp_directives�
directives�	directives`      rG�process_omp_attachementsz$CxxFunction.process_omp_attachements�s����"��d�L�9�9���	J����J�+�
-�
-�	�!L�!L�!L�!L�Y�^�!L�!L�!L�	���!�!�)�,�,�,�,��}�)�$�
�;�;���0��e��j�I�I��U���rHc��t|t��r |�|j|��S|�|j|��SrJ)r�r�r��local_names�lctxrcr�s  rGr�zCxxFunction.typeof�sG���d�C� � �	/��;�;�t�/��5�6�6�6��9�9�T�Z��-�.�.�.rHc���|jj}d�|D��}d�tt|����D��}t��t
|����}d�|D���_�j�d�|D����t���_	d�|D���_
�fd�|jD��}|||fS)Nc�6�g|]}t|j����Sri)r2ro�r]�args  rGr`z;CxxFunction.prepare_functiondef_context.<locals>.<listcomp>s ��6�6�6��u�S�V�}�}�6�6�6rHc�2�g|]}dt|��z��S)�
argument_type)r�)r]r�s  rGr`z;CxxFunction.prepare_functiondef_context.<locals>.<listcomp>s#��L�L�L�Q��#�a�&�&�0�L�L�LrHc��i|]
}|j|��Srir�)r]�syms  rG�
<dictcomp>z;CxxFunction.prepare_functiondef_context.<locals>.<dictcomp>s��?�?�?�C�C�F�C�?�?�?rHc��i|]
}|j|��Srir�r�s  rGr�z;CxxFunction.prepare_functiondef_context.<locals>.<dictcomp>s�� >� >� >����� >� >� >rHc��h|]	}|j��
Srir��r]�ns  rG�	<setcomp>z:CxxFunction.prepare_functiondef_context.<locals>.<setcomp>s��1�1�1��q�t�1�1�1rHc�:��g|]}��|����Srirjrks  �rGr`z;CxxFunction.prepare_functiondef_context.<locals>.<listcomp>s%���7�7�7�T��
�
�4� � �7�7�7rH)r��rangerar��gatherrr�r�rwr�r��body)rErOr��formal_args�formal_types�local_declsr�s`      rG�prepare_functiondef_contextz'CxxFunction.prepare_functiondef_contexts�����	���6�6��6�6�6��L�L�%��E�
�
�:K�:K�L�L�L���$�+�+�&;�T�B�B�C�C��?�?�;�?�?�?������� >� >�� >� >� >�?�?�?�%�'�'��	�1�1�[�1�1�1���7�7�7�7�T�Y�7�7�7���\�;�.�.rHc���dgt|jj��t|jj��z
z�fd�|jjD��z}dgt|jj��t|jj��z
z�fd�|jjD��z}�j|d}t	tdd����}|�jvrt	tdd����n
t��}|||||fS)Nc�:��g|]}��|����Srirj�r]r�rEs  �rGr`z-CxxFunction.prepare_types.<locals>.<listcomp>s#���7�7�7�q�T�Z�Z��]�]�7�7�7rHc�*��g|]}�j|��Sri)rcr�s  �rGr`z-CxxFunction.prepare_types.<locals>.<listcomp>s���7�7�7�q�T�Z��]�7�7�7rHr�void�callable�pure)rar�r�rcrr�pure_expressionsr)rErO�	dflt_argv�	dflt_argt�result_type�
callable_type�	pure_types`      rG�
prepare_typeszCxxFunction.prepare_typess����F�c�$�)�.�)�)�C��	�0B�,C�,C�C�D�7�7�7�7�D�I�$6�7�7�7�
8�	��F�c�$�)�.�)�)�C��	�0B�,C�,C�C�D�7�7�7�7�D�I�$6�7�7�7�
8�	�
�j��&�q�)����f�j� 9� 9�:�:�
��� 5�5�5��U�6�6�2�2�3�3�3�;I�;K�;K�	��)�[�-��J�JrHc����t|j���_��|��}|\}}}��|��}|\}}}}	}
d�|r(d�d�|����nd��}d��j|��}tt�|d�|��d|||��||��t��g}
t�|d�|��d��j��||��}t�j�����fd	��jD��}��
��}tt||��t||z|z����}t����fd
��j|dD��t#t%�|��d����gz}��
��|z}tt'd
|��||��g}t'�j|	|
g|z|
z��}|g|gfS)Nz	type{0}::�<{0}>�, r@z{0}::{1}ztypename {0}result_type�
operator()�{0}::operator()c���g|]Q}td���j�j|��t	|��������RS�z{0} {1})rr\rcr�r2�r]r��ctxrEs  ��rGr`z1CxxFunction.visit_FunctionDef.<locals>.<listcomp>Ism���
#�
#�
#���y�'�'���D�J�t�/��2�3�4�4�e�A�h�h�@�@�A�A�
#�
#�
#rHc	�f��g|]-}tt�|��|j������.Sri�rrr��r]r^rs  �rGr`z1CxxFunction.visit_FunctionDef.<locals>.<listcomp>WsE���
+�
+�
+���U�3�3�q�6�6�1�6�*�*�
+�
+�
+�
+�
+rHr�r�type)r2r��fnamer�rr\�joinrer�rrwr�r�r�rrrcrrr)rErO�tmp�
operator_bodyr�r�rrrrr�fscope�ffscope�operator_declaration�operator_signature�operator_local_declarations�dependent_typedefs�operator_definition�extra_typedefs�return_declaration�	topstructrs`                    @rG�visit_FunctionDefzCxxFunction.visit_FunctionDef's������4�9�%�%��
��.�.�t�4�4��36�0�
�|�[�� � ��&�&��FI�C�	�9�k�=�)��#�#�'3�%,�G�N�N�4�9�9�\�3J�3J�$K�$K�$K�)+�-�-���#�#�D�J��7�7��
�/��$�-�4�4�V�<�<� � �+�y�	:�:�
��
�
�
���
 ��=��$�%�,�,�W�5�5��$�$�T�Z�0�0��+�	'�'��
 ��	�*�*��
#�
#�
#�
#�
#��k�
#�
#�
#�	$�
!�\�\�^�^��*��)�<�8�8��$�-�.�� �
!�
!���� �!�!��
+�
+�
+�
+��j��&�q�)�
+�
+�
+�
�U���K� � ���� � �
!�
!�	������.�8����v�~�.�.���
�
����4�:�)�9�5�-�.�/�0�1�1�	�
�{�0�1�1�1rHc�R�|�|j��}tj|tj��rJd�|j��}ttd|z|��td��g��}nt|��}|�
||��S)Nztypename {}::type::result_typezstatic %s tmp_global�
tmp_global)rQ�valuer7r��StaticReturnr\rrr rr�)rErOr&r�rls     rG�visit_ReturnzCxxFunction.visit_Returnls����
�
�4�:�&�&���<��h�3�4�4�
	*�5�;�;�D�J�G�G�E��&�!7�%�!?��G�G�)�,�7�7�9�:�:�D�D�#�5�)�)�D��,�,�T�4�8�8�8rHc��t��SrJ�r�rE�_s  rG�visit_DeletezCxxFunction.visit_Delete{����u�u�rHc	���td�|jD����std|�����|j��}�fd�|jD��}d�|��}t
|��dko\t|jdtj	��o7|jdj
�j|vo|jdj
�jv}|�r��j
�d�|jD�����j|jd���r6d���|jd��|��}�n3t�j|jd�jjj��rdd��jj��jj�d	�|������|��}n�t�j|jd�jjj��sJ�d��jj��jj�d	�|������|��}t1||��}��||��S)
ar
        Create Assign node for final Cxx representation.

        It tries to handle multi assignment like:

        >> a = b = c = 2

        If only one local variable is assigned, typing is added:

        >> int a = 2;

        TODO: Handle case of multi-assignement for some local variables.

        Finally, process OpenMP clause like #pragma omp atomic
        c3�bK�|]*}t|tjtjf��V��+dSrJ)r��ast�Name�	Subscriptr�s  rGr�z+CxxFunction.visit_Assign.<locals>.<genexpr>�sI����*�*���a�#�(�C�M�!:�;�;�*�*�*�*�*�*rHz+Must assign to an identifier or a subscriptc�:��g|]}��|����Srirj�r]r^rEs  �rGr`z,CxxFunction.visit_Assign.<locals>.<listcomp>��#���7�7�7�Q�4�:�:�a�=�=�7�7�7rH�= r�rc3�$K�|]}|jV��dSrJr��r]r^s  rGr�z+CxxFunction.visit_Assign.<locals>.<genexpr>�s$����)E�)E�1�!�$�)E�)E�)E�)E�)E�)ErHr�zdecltype({}))�all�targetsr)rQr&rrar�r1r2ror�r�r�r�rc�
iscombinedr\r��builder�
Assignable�AssignableNoEscape�	NamedType�Lazyr r�)rErOr&r;�
alltargets�islocalrls`      rG�visit_AssignzCxxFunction.visit_Assign~s���� �*�*� �L�*�*�*�*�*�	�$�=����
��
�
�4�:�&�&��7�7�7�7�$�,�7�7�7���Y�Y�w�'�'�
��w�<�<�1�$�>��d�l�1�o�s�x�8�8�>��<��?�%���D�)9�9�>��<��?�%�T�-=�=�	��	 ��K�)�)�)E�)E���)E�)E�)E�E�E�E��z�$�,�q�/�*�5�5�7�7�
 �$�^�^�D�K�K���Q��,H�,H�,6�8�8�
�
��D�J�t�|�A��7� �J�.�9�;�;�
 �$�^�^��J�&�9�9��
�*�4�4�*�1�1�%�8�8�:�:�;�;��	 � �
�
�"�$�*�T�\�!�_�"=�"&�*�"4�"9�;�;�;�;�;�$�^�^��J�&�+�+��
�*�4�4�*�1�1�%�8�8�:�:�;�;��	 � �
�
�j�%�(�(���,�,�T�4�8�8�8rHc��|�|j��}|�|j��}tt	|j��}t
|||��dd���}|�||��S)Nr����)rQr&�targetr+r�oprr�)rErOr&rGrHrls      rG�visit_AugAssignzCxxFunction.visit_AugAssign�sr���
�
�4�:�&�&�����D�K�(�(��
&�t�D�G�}�}�
5�����F�E�*�*�1�R�4�0�1�1���,�,�T�4�8�8�8rHc�����fd�|jD��}td�|jrdndd�|������}��||��S)Nc�:��g|]}��|����Srirjr�s  �rGr`z+CxxFunction.visit_Print.<locals>.<listcomp>��#���5�5�5�A�$�*�*�Q�-�-�5�5�5rHz!pythonic::builtins::print{0}({1})r@�_nonlr
)�valuesrr\�nlrr�)rErOrNrls`   rG�visit_PrintzCxxFunction.visit_Print�su���5�5�5�5���5�5�5���<�C�C��'�&�B�B�w��I�I�f���������,�,�T�4�8�8�8rHc��t|j|��D]b}t|tj��sdStj|t��D](}d|jvr||j	vrtd|���dS�)�cJd���)NF�collapsez@not pure expression used as loop target inside a collapse clauseTzunreachable state)�reversed�	ancestorsr�r1r!r7r�r'�srr))rE�looprO�ancestorr�s     rG�is_in_collapsezCxxFunction.is_in_collapse�s��� ����!5�6�6�	 �	 �H��h���0�0�
��u�u�%�\�(�L�A�A�
 �
 �	����,�,��4�#8�8�8�0�.� �"�"�"� �4�4�4�-�
 �	*�)�)�)�)rHc	��d�t|����}|jj�|��}|jj|jvo)|jj|j|vot|d��}|r'd}	|j	�
|jj��nd}	td�|	||����}
|�|||��}td�|��d�||��d�|��t|
|g����}|�||��gS)	ao
        Create For representation on iterator for Cxx generation.

        Examples
        --------
        >> "omp parallel for"
        >> for i in range(10):
        >>     ... do things ...

        Becomes

        >> "omp parallel for shared(__iterX)"
        >> for(decltype(__iterX)::iterator __targetX = __iterX.begin();
               __targetX < __iterX.end(); ++__targetX)
        >>         auto&& i = *__targetX;
        >>     ... do things ...

        It the case of not local variable, typing for `i` disappear and typing
        is removed for iterator in case of yields statement in function.
        �__target{0}�yieldszauto&&r@z
{} {}= *{}z
{}.begin()z{0} < {1}.end()z++{0})r\rorcr=�IteratorOfTyperGr�r��hasattrr��remover�make_assignr!rr�)
rErOrG�
local_iter�local_iter_decl�	loop_body�local_target�local_target_declrC�
local_type�loop_body_prelude�assignrVs
             rG�gen_forzCxxFunction.gen_for�s_��,%�+�+�B�t�H�H�5�5�� �J�.�=�=�o�N�N���;�>��)9�9�/��;�>�T�Z��%5�5�/��t�X�.�.�.�	�
�	�!�J��K���t�{�~�.�.�.�.��J�&�l�&9�&9�*�:@�:F�'H�'H�I�I��
�!�!�"3�\�:�N�N���<�&�&�v�.�.�$�+�+�L�*�E�E��>�>�,�/�/��+�Y�7�8�8�:�:���-�-�d�D�9�9�:�:rHc��t|��dkrd}n�t|d��r%ddt|dj��dkzz}nit|d��rRt|d��r=ddt|dj��t|dj��kzz}nd}|dkrdnd}|�||��}|S)zm
        Handle comparison for real loops.

        Add the correct comparison operator if possible.
        �r�rFrz{} < {}z{} > {})rar4�intr&r\)rEr�rG�upper_bound�order�
comparisons      rG�handle_real_loop_comparisonz'CxxFunction.handle_real_loop_comparisons����t�9�9��>�>��E�E�
�4��7�^�^�	���c�$�q�'�-�0�0�1�4�5�5�E�E�
�4��7�^�^�	��d�1�g���	���c�$�q�'�-�0�0�3�t�A�w�}�3E�3E�E�F�F�E�E��E�"'�1�*�*�Y�Y�)�
��&�&�v�{�;�;�
��rHc	�t�|jj}t|��dkrdn|�|d��}t|��dkrd}d}n|�|d��}d}dx}}	|�||��}
|�|||��r|
}n"d�t
|����}|jj|jvo)|jj|j	|vot|d��}|r3t��}
|j�
|jj��nHd	}	td
�||��td�||������g}
|�|||��}t#d�|	||��|d
�||��|��}|
�d|�||����||
urg}n'|�|||
��}t|��g}||
fS)a)
        Create C For representation for Cxx generation.

        Examples
        --------
        >> for i in range(10):
        >>     ... do things ...

        Becomes

        >> for(long i = 0, __targetX = 10; i < __targetX; i += 1)
        >>     ... do things ...

        Or

        >> for i in range(10, 0, -1):
        >>     ... do things ...

        Becomes

        >> for(long i = 10, __targetX = 0; i > __targetX; i += -1)
        >>     ... do things ...


        It the case of not local variable, typing for `i` disappear
        rj�1Lr��0Lrzlong rZr[r@z{} == {}z{} -= {}z{0} {1}={2}z
{0} += {1})�iterr�rarQrXr\rorGr�r�r]r�r�r^r%rror!�insertr�r_)rErOr`rbr��step�lower_bound�	upper_arg�
upper_type�	iter_type�upper_valuerlrCrVrn�forloop�header�assgnts                  rG�	gen_c_forzCxxFunction.gen_c_forsJ��6�y�~���4�y�y�A�~�~�t�t�4�:�:�d�1�g�+>�+>���t�9�9��>�>��K��I�I��*�*�T�!�W�-�-�K��I�!(�(�
�Y��j�j��i��1�1�����t�T�)�_�5�5�	9�%�K�K�'�.�.�r�$�x�x�8�8�K��;�>��)9�9�/��;�>�T�Z��%5�5�/��t�X�.�.�.�	��	E��6�6�D��K���t�{�~�.�.�.�.��I��z�(�(��[�A�A��j�/�/�
�D�A�A�B�B�D�D�E�D��5�5�d�J�6A�C�C�
��m�*�*�9�j�+�N�N� �"�)�)�*�d�;�;��!�!��
	
���A�t�4�4�T�7�C�C�D�D�D��+�%�%��F�F��%�%�j�+�{�K�K�F���'�'�(�F��t�|�rHc	�:���tj|t��D�]|�t�fd�dD����ru�xjdz
c_�j�tj|tj	��dd�����j
��jd��|j�t�tj��sJ�d�jv}d�jv}t�fd��jD����}|r�|r�|r��j|j|vrz�xjd	z
c_�j�tj�jtj	��dd�����j��jd����~dS)
a"
        Fix OpenMP directives on For loops.

        Add the target as private variable as a new variable may have been
        introduce to handle cxx iterator.

        Also, add the iterator as shared variable as all 'parallel for chunck'
        have to use the same iterator.
        c3�*�K�|]
}|�jvV��dSrJ)rU)r]r�r�s  �rGr�z-CxxFunction.handle_omp_for.<locals>.<genexpr>ms*�����J�J�#�3�)�+�%�J�J�J�J�J�JrH)z
 parallel z task z shared({})NrF�for�defaultc3�l�K�|].}t|tj��o|j�jkV��/dSrJ)r�r1r2ro)r]r�rGs  �rGr�z-CxxFunction.handle_omp_for.<locals>.<genexpr>ys\�����H�H�34�(��3�8�4�4�/��T�V�Y�.�H�H�H�H�H�HrHz private({}))r7r�r'�anyrUr�r�r1r2�Loadr�rGr�r:ror�r�)rErOr`�hasfor�	nodefault�
noindexrefr�rGs      @@rG�handle_omp_forzCxxFunction.handle_omp_forbs�����"��d�L�9�9�	B�	B�I��J�J�J�J�1I�J�J�J�J�J�
A����}�,�����%�%�c�h�z�3�8�:�:�/3�T�';�';�<�<�<��%�,�,�Y�^�B�-?�@�@�@��[�F��f�c�h�/�/�/�/�/��i�k�)�F�!���4�I��H�H�H�H�8A��H�H�H�H�H�J��
B�9�
B��
B��I�T�Z��%5�5�5����~�-�����%�%�c�h�v�y�#�(�*�*�/3�T�';�';�<�<�<��&�-�-�i�n�R�.@�A�A�A��-	B�	BrHc���t|jtj��o+|jj|j|vo|jj|jv}|tj|t��z}|S)aN
        Check if given for Node can use autoFor syntax.

        To use auto_for:
            - iterator should have local scope
            - yield should not be use
            - OpenMP pragma should not be use

        TODO : Yield should block only if it is use in the for loop, not in the
               whole function.
        )
r�rGr1r2ror�r�r7r�r')rErO�auto_fors   rG�can_use_autoforzCxxFunction.can_use_autofor�sf���t�{�C�H�5�5�;��K�N�d�j��&6�6�;��K�N�$�*:�:�	�	���T�<�8�8�8�8���rHc
��t|jtj��sJ�tjtjtjdtj��dd��dtj�����t��g���}t��}|j	D]:}|�
d�|�t|��D�����;t|���|j��}|j|vs|jj|vrdS|jj}t%|��dkrd	St'|d
��rd	SdS)z�
        Check if a for loop can use classic C syntax.

        To use C syntax:
            - target should not be assign in the loop
            - range should be use as iterator
            - order have to be known at compile time
        �builtinsNr�)r&r�r)�funcr��keywordsc��h|]	}|j��
Srir�r�s  rGr�z,CxxFunction.can_use_c_for.<locals>.<setcomp>�s��L�L�L����L�L�LrHF�Trj)r�rGr1r2�Call�	Attributer�r	r�r�r�r�rr�searchrsror�rar4)rErO�
pattern_range�is_assignedrl�nodesr�s       rG�
can_use_c_forzCxxFunction.can_use_c_for�s>���$�+�s�x�0�0�0�0�0���c�m��(�:�s�x�z�z�4��>�>��c�h�j�j�'*�'*�'*����R�)�)�)�
��e�e���I�	N�	N�D����L�L�d�k�k�*�d�.K�.K�L�L�L�M�M�M�M��=�)�)�0�0���;�;���9�E�!�!�T�[�^�{�%B�%B��5��y�~���t�9�9�q�=�=��4���a��>�>�	��4��urHc�0�d�|||��S)Nz
{0} {1} = {2}r[)rErar`�iterables    rGr_zCxxFunction.make_assign�s���%�%�o�z�8�L�L�LrHc	���t|jtj��st	d|j�����|j��}t
�fd�|jD����}��|||jj	��}��|j
��}��|��r��|||��\}}�n��
|��rOg}�j�|jj	��t!|||��}��||��g}n�d�t|����}�jj��j|j
��}	��||����|	||��}
t1|
��g}��||||	|��}t5j|t4j��D]=}|�t1d�|j|�������>t
||z��S)a�
        Create For representation for Cxx generation.

        Examples
        --------
        >> for i in range(10):
        >>     ... work ...

        Becomes

        >> typename returnable<decltype(builtins.range(10))>::type __iterX
           = builtins.range(10);
        >> ... possible container size reservation ...
        >> for (auto&& i: __iterX)
        >>     ... the work ...

        This function also handle assignment for local variables.

        We can notice that three kind of loop are possible:
        - Normal for loop on iterator
        - Autofor loop.
        - Normal for loop using integer variable iteration
        Kind of loop used depend on OpenMP, yield use and variable scope.
        z7Using something other than an identifier as loop targetc�:��g|]}��|����Srirjrks  �rGr`z)CxxFunction.visit_For.<locals>.<listcomp>�s%���B�B�B��4�:�:�d�+�+�B�B�BrHz	__iter{0}z!pythonic::utils::reserve({0},{1}))r�rGr1r2r)rQrr�r�rorsr�r~r�r�r^r&r�r\rcr=r>r�r_rrhr7r��
Comprehensionr�)rErOrGrbr�r|rV�autoforr`ra�asgnt�comps`           rG�	visit_ForzCxxFunction.visit_For�sI���4�$�+�s�x�0�0�	�$�I�����
����D�K�(�(���B�B�B�B��	�B�B�B�C�C�	��'�'��i����H�H�	��:�:�d�i�(�(�����d�#�#�	/��>�>�$��	�B�B�L�F�D�D��#�#�D�)�)�
/�����"�"�4�;�>�2�2�2�!�&�(�I�>�>���5�5�d�G�D�D�E���)�/�/��4���9�9�
�"&�*�"4�"?�"?��J�t�y�)�#+�#+���#�#�D�*�5�5�5�
�(�(��*�h�O�O��#�E�*�*�+���|�|�D�&�*�o�$-�/�/��
�L��x�'=�>�>�	�	�D��M�M�)�$G�$N�$N����%�%���
�
�
�
��V�d�]�#�#�#rHc������|j��}�fd�|jD��}t|t	|����}��||��S)zh
        Create While node for Cxx generation.

        It is a cxx_loop to handle else clause.
        c�:��g|]}��|����Srirjr�s  �rGr`z+CxxFunction.visit_While.<locals>.<listcomp>�#���1�1�1�!��
�
�1�
�
�1�1�1rH)rQ�testr�r"rr�)rErOr�r�rls`    rG�visit_WhilezCxxFunction.visit_While�s^����z�z�$�)�$�$��1�1�1�1�t�y�1�1�1���T�5��;�;�'�'���,�,�T�4�8�8�8rHc�����fd�|jD��}t��}|jD]*}|���|�����+tt
|��|��S)Nc�:��g|]}��|����Srirjr�s  �rGr`z)CxxFunction.visit_Try.<locals>.<listcomp>r�rH)r�r��handlers�extendrQr#r)rErOr��except_r�s`    rG�	visit_TryzCxxFunction.visit_Trysm���1�1�1�1�t�y�1�1�1���&�&����	*�	*�A��N�N�4�:�:�a�=�=�)�)�)�)���t���g�.�.�.rHc�D����|jr��|j��nd��fd�|jD���t|jt
j��r��fd�|jjD��St|jo|jj	t������gS)Nc�:��g|]}��|����Srirj)r]�mrEs  �rGr`z3CxxFunction.visit_ExceptHandler.<locals>.<listcomp>r�rHc�V��g|]%}t|jt��������&Sri)r$r�r)r]�pr�r�s  ��rGr`z3CxxFunction.visit_ExceptHandler.<locals>.<listcomp>s=���-�-�-��"�!�&�%��+�+�t�<�<�-�-�-rH)r�rQr�r�rr1�Tuple�eltsr$r�r)rErOr�r�s` @@rG�visit_ExceptHandlerzCxxFunction.visit_ExceptHandlers������(,�	�;�t�z�z�$�)�$�$�$�t��1�1�1�1�t�y�1�1�1���d�i���+�+�	�-�-�-�-�-�!�Y�^�-�-�-�
-�"��	�,�d�i�n��d�������
rHc�����|j��}�fd�|jD��}�fd�|jD��}t	|j��r |jjdkrt
|��}n/t|t
|��|rt
|��nd��}��|��	||����S)Nc�:��g|]}��|����Srirjr�s  �rGr`z(CxxFunction.visit_If.<locals>.<listcomp> r�rHc�:��g|]}��|����Srirjr�s  �rGr`z(CxxFunction.visit_If.<locals>.<listcomp>!rLrHr�)
rQr�r�rmr4r&rr%r�r�)rErOr�r�rmrls`     rG�visit_IfzCxxFunction.visit_Ifs�����z�z�$�)�$�$��1�1�1�1�t�y�1�1�1��5�5�5�5���5�5�5�������	L��	��1� 4� 4���;�;�D�D��d�E�$�K�K�&�)J��v����d�K�K�D��"�"�4�#'�#@�#@��t�#L�#L�N�N�	NrHc��|jo|�|j��}td�|pd����S)Nz	throw {0}r@)�excrQrr\)rErOr�s   rG�visit_RaisezCxxFunction.visit_Raise*s<���h�/�4�:�:�d�h�/�/����+�+�C�I�2�6�6�7�7�7rHc��|�|j��|jo|�|j��g}d�d�|D����}t	d�|����S)Nr
c3�K�|]}|�|V��	dSrJri)r]�_fs  rGr�z+CxxFunction.visit_Assert.<locals>.<genexpr>0s'����6�6�2�2�6�B�6�6�6�6�6�6rHzpythonic::pythran_assert({0}))rQr��msgrrr\)rErO�params�sparamss    rG�visit_AssertzCxxFunction.visit_Assert.sl���*�*�T�Y�'�'���)J�d�j�j���6J�6J�K���)�)�6�6��6�6�6�6�6���8�?�?��H�H�I�I�IrHc��t��SrJr*r+s  rG�visit_ImportzCxxFunction.visit_Import3r.rHc��Jd���)NFz0should be filtered out by the expand_import passrir+s  rG�visit_ImportFromzCxxFunction.visit_ImportFrom6s��H�H�H�H�HrHc��t|�|j����}|�||�||����SrJ)rrQr&r�r��rErOrls   rG�
visit_ExprzCxxFunction.visit_Expr9sM������D�J�/�/�0�0���"�"�4�#'�#@�#@��t�#L�#L�N�N�	NrHc�J�t��}|�||��SrJ)rr�r�s   rG�
visit_PasszCxxFunction.visit_Pass>s#�������,�,�T�4�8�8�8rHc���|jr_|jdrR|j�|jd��td�|jd����Std��S)zp
        Generate break statement in most case and goto for orelse clause.

        See Also : cxx_loop
        rF�goto {0}�break)rnrpr�rr\r+s  rG�visit_BreakzCxxFunction.visit_BreakBsn����	&�4�#6�r�#:�	&��O���� 3�B� 7�8�8�8��Z�.�.�t�/B�2�/F�G�G�H�H�H��W�%�%�%rHc� �td��S)N�continue)rr+s  rG�visit_ContinuezCxxFunction.visit_ContinueNs����$�$�$rHc����fd�|jD��}tt|j��}t	||��S)Nc�:��g|]}��|����Srirj)r]r&rEs  �rGr`z,CxxFunction.visit_BoolOp.<locals>.<listcomp>Ss%���=�=�=��$�*�*�U�#�#�=�=�=rH)rNr*rrHr;)rErOrNrHs`   rG�visit_BoolOpzCxxFunction.visit_BoolOpRs@���=�=�=�=���=�=�=��
��T�W�
�
�
.���b�&�!�!�!rHc��|�|j��}|�|j��}t|��rd�|jj��}t
|j��rd�|��}n)t
|j��rd�|��}tt|j	��||��S)Nz$std::integral_constant<long, {}>{{}}�pythonic::types::str({}))
rQ�left�rightr6r\r&r3r*rrH)rErOr�r�s    rG�visit_BinOpzCxxFunction.visit_BinOpWs����z�z�$�)�$�$���
�
�4�:�&�&���$�<�<�	"�:�A�A��
� �"�"�E������	=�-�4�4�T�:�:�D�D�
�4�:�
�
�	=�.�5�5�e�<�<�E�!�$�t�w�-�-�0��u�=�=�=rHc��|�|j��}tt|j��|��SrJ)rQ�operandr*rrH)rErOr�s   rG�
visit_UnaryOpzCxxFunction.visit_UnaryOpds0���*�*�T�\�*�*��!�$�t�w�-�-�0��9�9�9rHc���|�|j��}|�|j��}|�|j��}d�|||��S)Nz�(((bool){0}) ? typename __combined<decltype({1}), decltype({2})>::type({1}) : typename __combined<decltype({1}), decltype({2})>::type({2})))rQr�r�rmr\)rErOr�r�rms     rG�visit_IfExpzCxxFunction.visit_IfExphsY���z�z�$�)�$�$���z�z�$�)�$�$�����D�K�(�(��
N��&��t�V�
$�
$�		%rHc���|js d��j|��S�fd�|jD��}�j|}t|��dkrLd����jj�|����|d��Sd����jj�|����d�|����S)Nz!{}(pythonic::types::empty_list())c�:��g|]}��|����Srirjr�s  �rGr`z*CxxFunction.visit_List.<locals>.<listcomp>w�#���5�5�5�a�D�J�J�q�M�M�5�5�5rHr��){0}({1}, pythonic::types::single_value())rz{0}({{{1}}})r
)r�r\rcrar�r=r>r�rErOr��	node_types`   rG�
visit_ListzCxxFunction.visit_Listrs�����y�	%�6�=�=�d�j��>N�O�O�O�6�5�5�5�4�9�5�5�5�D��
�4�(�I��4�y�y�A�~�~�B�I�I��I�I�d�j�0�;�;�I�F�F�G�G���G����&�,�,��I�I�d�j�0�;�;�I�F�F�G�G��I�I�d�O�O�%�%�%rHc����|js d��j|��S�fd�|jD��}�jj��j|���t|��dkrLd����jj������|d��Sd��d��fd�|D������S)	Nz {}(pythonic::types::empty_set())c�:��g|]}��|����Srirjr�s  �rGr`z)CxxFunction.visit_Set.<locals>.<listcomp>�r�rHr�r�r�{0}{{{{{1}}}}}r
c3�D�K�|]}d��|��V��dS)zstatic_cast<{}::value_type>({})Nr[)r]�eltr�s  �rGr�z(CxxFunction.visit_Set.<locals>.<genexpr>�sO�����G�G�:=�@�%�v�i��5�5�G�G�G�G�G�GrH)r�r\rcr=r>rar�rr�s`  @rG�	visit_SetzCxxFunction.visit_Set�s�����y�	H�5�<�<�T�Z��=M�N�N�N�5�5�5�5�4�9�5�5�5�D��
�*�5�5�d�j��6F�G�G�I��4�y�y�A�~�~�B�I�I��I�I�d�j�0�;�;�I�F�F�G�G���G����(�.�.���I�I�G�G�G�G�AE�G�G�G�G�G�H�H�HrHc
�p��|js d��j|��S�fd�|jD��}�fd�|jD��}d��jj��j|��d�d�t||��D������S)Nz!{}(pythonic::types::empty_dict())c�:��g|]}��|����Srirjr�s  �rGr`z*CxxFunction.visit_Dict.<locals>.<listcomp>�r�rHc�:��g|]}��|����Srirjr�s  �rGr`z*CxxFunction.visit_Dict.<locals>.<listcomp>�s#���9�9�9��d�j�j��m�m�9�9�9rHr�r
c3�HK�|]\}}d�||��V��dS)z{{ {0}, {1} }}Nr[�r]r�r�s   rGr�z)CxxFunction.visit_Dict.<locals>.<genexpr>�sJ����9�9�"�a��+�1�1�!�Q�7�7�9�9�9�9�9�9rH)�keysr\rcrNr=r>rrb)rErOr�rNs`   rG�
visit_DictzCxxFunction.visit_Dict�s�����y�	:�6�=�=�d�j��>N�O�O�O�5�5�5�5�4�9�5�5�5�D�9�9�9�9�T�[�9�9�9�F�#�*�*��
�"�-�-�d�j��.>�?�?��	�	�9�9�&)�$��&7�&7�9�9�9�9�9�:�:�
:rHc�(���fd�|jD��}�j|}d�d�|����}t	|�jjj��r)d���|��|��S|S)Nc�:��g|]}��|����Srirj�r]r�rEs  �rGr`z+CxxFunction.visit_Tuple.<locals>.<listcomp>�s#���5�5�5�C��
�
�3���5�5�5rHz pythonic::types::make_tuple({0})r
�({}){})r�rcr\rr�r=�
CombinedTypesr�)rErOr��
tuple_typerAs`    rG�visit_TuplezCxxFunction.visit_Tuple�s����5�5�5�5�4�9�5�5�5���Z��%�
�3�:�:�4�9�9�T�?�?�K�K���j�$�*�"4�"B�C�C�	��?�?�4�9�9�Z�#8�#8�&�A�A�A��MrHc�����|j��}d�|jD��}�fd�|jD��}t	|g|dd�z||��}d�d�|D����S)Nc�B�g|]}tt|����Sri)r*rr�s  rGr`z-CxxFunction.visit_Compare.<locals>.<listcomp>�s$��=�=�=�q�!�$�q�'�'�*�=�=�=rHc�:��g|]}��|����Srirjr�s  �rGr`z-CxxFunction.visit_Compare.<locals>.<listcomp>�s#���?�?�?��t�z�z�!�}�}�?�?�?rHrFz and c3�6K�|]\}}}|||��V��dSrJri)r]r�rH�ys    rGr�z,CxxFunction.visit_Compare.<locals>.<genexpr>�s2����>�>���B��B�B�q�!�H�H�>�>�>�>�>�>rH)rQr��ops�comparatorsrbr)rErOr�rr�all_cmpss`     rG�
visit_ComparezCxxFunction.visit_Compare�s�����z�z�$�)�$�$��=�=�D�H�=�=�=��?�?�?�?�d�.>�?�?�?����v��C�R�C� 0�0�#�{�C�C���|�|�>�>�X�>�>�>�>�>�>rHc����fd�|jD��}��|j��}|dkrBd�d|jdj���z|d��}n)d�|d�|����}t�j�	|���jj
j��r4d	����j|��|��S|S)
Nc�:��g|]}��|����Srirjr�s  �rGr`z*CxxFunction.visit_Call.<locals>.<listcomp>�r�rHz&pythonic::builtins::functor::getattr{}z'pythonic::builtins::getattr({}{{}}, {})zpythonic::types::attr::r�rz{}({})r
r�)
r�rQr�r\r&�upperrr�rcr�r=r�r�)rErOr�r�rAs`    rG�
visit_CallzCxxFunction.visit_Call�s����1�1�1�1�t�y�1�1�1���z�z�$�)�$�$���;�;�;�?��V�5�"�i��l�0�6�6�8�8�9� ��G�%�%�
�F�
�_�_�T�4�9�9�T�?�?�;�;�F��d�j�n�n�T�*�*�D�J�,>�,L�M�M�	��?�?�4�9�9�T�Z��-=�#>�#>�#)�+�+�
+��MrHc�0�|j�d}�n�t|jt��r(t|j�����}�nYt|jt��ro|j�dd���dd��}t
|j��dkr|�dd��}d	|zd
z}n�d|zdz}n�t|jt��r<d
�tt|jj
|jj��}nzt|j��rd}nct|j��r|jdkrdnddz}n<t|j��tjt#|j��d��z}||jvrft|jt&��sJ�dtt#|j���dt|j������d�S|S)N�pythonic::builtins::None�"z\"�
z\nr��'z\'zpythonic::types::chr('z')zpythonic::types::str("z")z
{0}({1}, {2})zpythonic::numpy::nanr�+�-zpythonic::numpy::infr@zstd::integral_constant<r
z>{})r&r��boolr��lower�replacera�complexr\r-�real�imagr9r:�reprr.r�r�
immediatesrk)rErO�ret�quoteds    rG�visit_ConstantzCxxFunction.visit_Constant�s����:��,�C�C�
��
�D�
)�
)�	N��d�j�/�/�'�'�)�)�C�C�
��
�C�
(�
(�	N��Z�'�'��U�3�3�;�;�D�%�H�H�F��4�:���!�#�#�����U�3�3��/�&�8�5�@���.��7�$�>���
��
�G�
,�
,�
	N�!�(�(�%�g�.��
���
��!�!�C�C��4�:�
�
�	N�(�C�C�
�4�:�
�
�	N��*��/�/�3�3�s�6L�L�C�C��t�z�"�"�^�%7��T�Z�8H�8H�"�%M�%M�M�C��4�?�"�"��d�j�#�.�.�.�.�.�.�%�d�4�:�&6�&6�7�7�7��T�Z���9N�9N�9P�9P�9P�9P�R�
R��
rHc��t|��\}}d�tt|����}|���s|dz
}|S)Nz::z{})r0r�mapr2�	isliteral)rErO�obj�path�sattrs     rG�visit_AttributezCxxFunction.visit_Attribute�sL�� ��&�&�	��T��	�	�#�e�T�*�*�+�+���}�}���	��T�M�E��rHc���t|tj��r t�fd�|jD����S�j|jdkS)Nc3�D�K�|]}�j|jdkV��dS)rN)�range_values�lowr�s  �rGr�z+CxxFunction.all_positive.<locals>.<genexpr>�sG�����-�-���(��-�1�Q�6�-�-�-�-�-�-rHr)r�r1r�r:r�r$r%r�s` rG�all_positivezCxxFunction.all_positive�sg����d�C�I�&�&�	-��-�-�-�-�"&�)�-�-�-�-�-�
-�� ��&�*�a�/�/rHc������|j��}t|j��rd�|��}t	|j��rO|jjdkr?t
|jjt��r d�|jj|��S��|j��r0��|j��}d�||��St|j��rA�fd�|jj
D��}d�d�|��|��S��|j��}d�||��S)	Nr�rzstd::get<{0}>({1})z
{1}.fast({0})c�:��g|]}��|����Srirjr�s  �rGr`z/CxxFunction.visit_Subscript.<locals>.<listcomp>�s#���A�A�A�#�d�j�j��o�o�A�A�ArHz{1}({0})�,z{1}[{0}])rQr&r3r\r4�slicer�rkr&r5r�r)rErOr&�slice_�slicess`    rG�visit_SubscriptzCxxFunction.visit_Subscript�sL����
�
�4�:�&�&�������	=�.�5�5�e�<�<�E��$�*���	4���!�Q�&�&��4�:�+�S�1�1�'�'�.�.�t�z�/?��G�G�G�
�
�
�t�z�
*�
*�
	4��Z�Z��
�+�+�F�"�)�)�&�%�8�8�8�
��
�
#�
#�	4�A�A�A�A����A�A�A�F��$�$�S�X�X�f�%5�%5�u�=�=�=��Z�Z��
�+�+�F��$�$�V�U�3�3�3rHc���|j|jvrt|j��S|j|jvr'd�t|j����St|j��S)Nz{0}())ror�r2�global_declarationsr\r�s  rG�
visit_NamezCxxFunction.visit_NamesX���7�d�&�&�&����>�>�!�
�W��0�
0�
0��>�>�%���.�.�1�1�1����>�>�!rHc��g}dD]@}t||��}|r|�|��nd}|�|���A|j�$t	|j��rk|jjdkr[|�|j��r|�|j��rd}nd}|�	|d|d��Sdj	|�S)N)rrrur
r�z-pythonic::types::fast_contiguous_slice({},{})z(pythonic::types::contiguous_slice({},{})rz pythonic::types::slice({},{},{}))
r�rQr�rur4r&r&rrr\)rErOr��field�nfieldr�r=s       rG�visit_SlicezCxxFunction.visit_Slices�����/�	�	�E��T�5�)�)�F�)/�3�4�:�:�f�%�%�%�2�
��K�K�������9���t�y�!1�!1��d�i�o��6J�6J�� � ���,�,�
E��1B�1B�4�:�1N�1N�
E�I���D���>�>�$�q�'�4��7�3�3�3�<�5�<�d�C�CrHrJ):rRrSrTrUrCr�r�r�rQr�r�r�rr#r(r-rDrIrPrXrhror~r�r�r�r_rur�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrrr!r&r-r0r4rVrWs@rGr�r��s��������
�
�!�!�!�*�*�*�6�6�6�&@�@�@�4�4�4�4�4�����&/�/�/�/�/�/�"K�K�K�&C2�C2�C2�J
9�
9�
9����39�39�39�j9�9�9�9�9�9�
*�
*�
*�/;�/;�/;�b���*I�I�I�V B� B� B�D���$���:M�M�M��F$�F$��X�F$�P�	9�	9��X�	9�/�/�/�
�
�
�
N�
N�
N�8�8�8�J�J�J�
���I�I�I�N�N�N�
9�9�9�
&�
&�
&�%�%�%�"�"�"�
>�>�>�:�:�:�%�%�%�%�%�%�$H�H�H�$	:�	:�	:����?�?�?����&���:���0�0�0�4�4�4�."�"�"�D�D�D�D�D�D�DrHr�c�X��eZdZdZdZdZd�Z�fd�Zd�Zd�Z	d�Z
d	�Zd
�Z�fd�Z
�xZS)r��__generator_state�__generator_value�that_is_all_folksc��|SrJri)rErOr�r�s    rGr�zCxxGenerator.process_locals*s���rHc����g|_d�t|�t|����D��|_tt|���|��S)Nc�P�i|]#\}}|d|zd�d|z��f��$S)r�zyield_point{0}r[)r]r�r�s   rGr�z<CxxGenerator.prepare_functiondef_context.<locals>.<dictcomp>1sL��B�B�B�f�q�!�q�1�q�5�"2�"9�"9�!�a�%�"@�"@�A�B�B�BrH)�extra_declarationsr�r�rr[rBr�r�r�s  �rGr�z(CxxGenerator.prepare_functiondef_context-sd���"$���B�B� ����[�$�!?�!?�@�@�B�B�B����\�4�(�(�D�D�T�J�J�JrHc�`���d�_��|��}|\}}}��|��}|\}}}}	}
d�t	|j����}d�||r(d�d�|����nd��}�jr,|�ttj
����|�td����ttdd	��g��t��g}
tttd|��g��t!d
����g}|r�|rt#|��rt%��}|�tt'�|d||||��t!d�d�dgd
�|D��z����������tttdd��g��t)td��g����tttd�|��d��gd��t)t+tj��g����tttd�|��d��g��t)td��t+d�|����g����tttd�|��d��g��t)t+d�|����g����g}t/ttd�|��d�|����g��|��}|}|�dtd�tjd�d�t5�j���d����D����������t;�j���d �t?||��D����fd!��j D��zd"��j!D��ztd#�|tj����gz}�fd$��j"|d%D��}tGtd�|r)d&�|d�|����n|��d'����tGt�|��d(����g}tGt�|��d����g}��$��|z|z|z}t/tK|||z|z|z|
zd)��|��}t|t)|����}t/tM�||d*|||��||��t��g}tM�||d+�t	|j����||��}tt/||��t)t+d,�|d�|������g����}t/tKd-|��|��}tKt	|j��||	|
g|z��}||g||gfS).NFz__generator__{0}r�r	r
r@zreturn result_type()r�nextz: pythonic::yielder() {}z: {0} {{ }}zpythonic::yielder()c�8�g|]}d�|����S)z{0}({0})r[r�s  rGr`z2CxxGenerator.visit_FunctionDef.<locals>.<listcomp>]s6��7�7�7�#&� *�0�0��5�5�7�7�7rHr�z
operator++znext()ztypename {0}::result_typez	operator*r�z(pythonic::types::generator_iterator<{0}>�beginz/pythonic::types::generator_iterator<{0}>(*this)�endz*pythonic::types::generator_iterator<{0}>()z	{0}::nextrzswitch({0}) {{ {1} }}� c3�HK�|]\}}d�||��V��dS)zcase {0}: goto {1};Nr[)r]�num�wheres   rGr�z1CxxGenerator.visit_FunctionDef.<locals>.<genexpr>�sJ����.�.�%�#�u�+�1�1�#�u�=�=�.�.�.�.�.�.rHc��|dS)Nrrir�s rGr�z0CxxGenerator.visit_FunctionDef.<locals>.<lambda>�s
��q��t�rHr�c�Z�g|](\}}td�||������)Sr�rr\)r]�ft�fas   rGr`z2CxxGenerator.visit_FunctionDef.<locals>.<listcomp>�sJ��I�I�I�%�b�"�#�9�#3�#3�B��#;�#;�<�<�I�I�IrHc���g|]D}td���j�j|��|������ESr)rr\rcr�rs  ��rGr`z2CxxGenerator.visit_FunctionDef.<locals>.<listcomp>�sf���/�/�/��#�9�#3�#3��C��
�4�+;�A�+>� ?�@�@��$�$� � �/�/�/rHc�Z�g|](\}}td�||������)SrrHr�s   rGr`z2CxxGenerator.visit_FunctionDef.<locals>.<listcomp>�sD��>�>�>�!�Q��#�9�#3�#3�A�q�#9�#9�:�:�>�>�>rHztypename {0}::result_type {1}c	�f��g|]-}tt�|��|j������.Srirrs  �rGr`z2CxxGenerator.visit_FunctionDef.<locals>.<listcomp>�sE���9�9�9� �#�5���Q�����#8�#8�9�9�9�9�9rHr�z{0}<{1}>�iterator�
value_typezpythonic::yielderrrz{0}({1})r)'�returnsr�rr\r2r�rr�rr��FinalStatementrrrrrrr:r�r�rr�
StateValuerert�StateHolderr�r[rNrwr�rbr�r<rcrr�rr�)rErOrrr�r�rrrrr�	next_name�instanciated_next_name�next_declaration�next_constructors�
next_iterator�next_signature�	next_body�next_members�extern_typedefs�iterator_typedef�result_typedefr �next_struct�next_definitionrrr�topstruct_typer"rs`                             @rGr#zCxxGenerator.visit_FunctionDef6sN��������.�.�t�4�4��36�0�
�|�[�� � ��&�&��FI�C�	�9�k�=�)�'�-�-�e�D�I�.>�.>�?�?�	�!)����7C�K�G�N�N�4�9�9�\�2�2�3�3�3��"M�"M���<�	E�� � ��|�'B�!C�!C�D�D�D����Y�'=�>�>�?�?�?�
 ��m�V� <� <�b�A�A������
�#�E�"�i�$8�$8�"�=�=��/�0�0�
�
���
�
	��
+�S��^�^�
+�$(�F�F�!��$�$�\�)�$��b�)�*6��*3�5�5��]�)�)��I�I�4�5�7�7�*5�7�7�7�7�8�8�9�9�:�:�	&�&�
�
�
�
�#�E�&�,�$?�$?��D�D��y��*�*�+�,�,�
.�
.�
�#��5�<�<�.�0�0�#�%�%���	!�!�
�#�$�/�1�1�2�3�3�

4�
4�
�#��D�!�6�)�,�,�!�#�#��	��
�y��*�*�&�%�%+�V�I�%6�%6�8�8�9�:�:�
	
;�	
;�
�#��D�!�6�)�,�,��!�!��	��
��@��V�I�&�&�(�(�)�*�*�

+�
+�/ �
�B$���/�6�6�.�0�0��&�&�'=�>�>�@�@��
�
�
����"�	�����I�&=�&D�&D��$��H�H�.�.�)/���+�+�-�-�+�^�*-�*-�*-�.�.�.�
.�
.�'/�'/�0�0�	1�	1�	1� ��	�*�*��I�I�),�\�;�)G�)G�I�I�I�/�/�/�/�/�#'�+�/�/�/�/�>�>�%)�%<�>�>�>�
>�#�;�B�B� 6� ,� 7�9�9�:�:�;�;��9�9�9�9�$(�J�t�$4�Q�$7�9�9�9��
��@�G�G�#�3�J�%�%�i����<�1H�1H�I�I�I�)2�4�4�� � �
!�
!�

�E�#�#�k�*�*�&�(�(�
)�
)�
*��
�E�#�#�k�*�*�M�:�:�;�;�=���,�,�.�.�)�*�*�+�)�)��
!��9�!�� �$�%�!�!�$�	$�&9�
:�
:�
����'�~�u�Y�7G�7G�H�H��
�/��$� 6� � �+�y�:�:���

�
�
��� ��=��$�.��$�$�U�4�9�%5�%5�6�6��+�'�'��+��)�<�8�8��?�:�#4�#4�&��	�	�+�&�&�$(�$(�)�)�*�
+�
+����$��6�>�*�*�������$�)���
�]�I�6� �
!�"�"�	�
�Y�'�/�;N�)O�O�OrHc���d|_ttd�tj����td�tj����g��S)NTz{0} = -1r�)rPrrr\r�rSrQr�s  rGr(zCxxGenerator.visit_Return�sW������i�
� 1� 1�,�2J� K� K�L�L��
� 1� 1�,�2M� N� N�O�O����	rHc��|j|\}}d�d�tttj|��t
d�tj|�	|j
������td�|����g�����D����S)Nr@c3�K�|]}|V��dSrJrir�s  rGr�z+CxxGenerator.visit_Yield.<locals>.<genexpr>�s2������Q�q������rHz	{0} = {1}z{0}:)
r[rrr r�rSrr\rRrQr&rr�)rErOrD�labels    rG�visit_YieldzCxxGenerator.visit_Yield�s����[��&�
��U��w�w���%��<�+�S�1�1��K�.�.�|�/F�/3�z�z�$�*�/E�/E�G�G�
H�
H��f�m�m�E�*�*�+�+�	)�#�#�
�x�z�z������	rHc������|j��}�fd�|jD��}d�|��}t	||��}��||��S)Nc�:��g|]}��|����Srirjr5s  �rGr`z-CxxGenerator.visit_Assign.<locals>.<listcomp>�r6rHr7)rQr&r;rr r�)rErOr&r;rBrls`     rGrDzCxxGenerator.visit_Assign�sg����
�
�4�:�&�&��7�7�7�7�$�,�7�7�7���Y�Y�w�'�'�
��j�%�(�(���,�,�T�4�8�8�8rHc��dS)zx
        TODO : Yield should block only if it is use in the for loop, not in the
               whole function.
        Frir�s  rGr�zCxxGenerator.can_use_autofor�s	��
�urHc���|j�||f��tt|���d||��Sr?)r<r�rBr�r_)rErar`r�rFs    �rGr_zCxxGenerator.make_assign�sA�����&�&�
�O�'E�F�F�F��\�4�(�(�4�4�R��X�N�N�NrH)rRrSrTrSrRrQr�r�r#r(rfrDr�r_rVrWs@rGr�r�!s��������&�K�$�J�(�N����K�K�K�K�K�cP�cP�cP�J������9�9�9����O�O�O�O�O�O�O�O�OrHr�c�.��eZdZdZ�fd�Zd�Zd�Z�xZS)�Cxxa�
    Produces a C++ representation of the AST.

    >>> import gast as ast, pythran.passmanager as passmanager, os
    >>> node = ast.parse("def foo(): return 'hello world'")
    >>> pm = passmanager.PassManager('test')
    >>> r = pm.dump(Cxx, node)
    >>> print(str(r).replace(os.sep, '/'))
    #include <pythonic/include/types/str.hpp>
    #include <pythonic/types/str.hpp>
    namespace __pythran_test
    {
      struct foo
      {
        typedef void callable;
        typedef void pure;
        struct type
        {
          typedef pythonic::types::str __type0;
          typedef typename pythonic::returnable<__type0>::type __type1;
          typedef __type1 result_type;
        }  ;
        inline
        typename type::result_type operator()() const;
        ;
      }  ;
      inline
      typename foo::type::result_type foo::operator()() const
      {
        return pythonic::types::str("hello world");
      }
    }
    c
����d|_tt|���tt
tttttt��dSr�)rArBrlrCrrr/rr
rr
rrDs �rGrCzCxx.__init__"sI������
�c�4���!�!�,�0B�E�"'��o�",�i�	9�	9�	9�	9�	9rHc�x��t�j��}d�|D��}|d�|D��z
}ttd�fd�|jD������}|r	t|�nggf\}}d�||zD��}t
t�jj	z|��}t||gz���_dS)z Build a compilation unit. c	�v�g|]6}td�ddgd�|D��z��dz����7S)�/�pythonic�includec�,�g|]}t|����Sri�r2�r]r�s  rGr`z/Cxx.visit_Module.<locals>.<listcomp>.<listcomp>/s��$9�$9�$9�!�U�1�X�X�$9�$9�$9rH�.hpp�rrr9s  rGr`z$Cxx.visit_Module.<locals>.<listcomp>.sj��)�)�)���3�8�8�Z��$;�$9�$9�q�$9�$9�$9�%:�;�;�=C�D�E�E�)�)�)rHc	�t�g|]5}td�dgd�|D��z��dz����6S)rprqc�,�g|]}t|����Srirtrus  rGr`z/Cxx.visit_Module.<locals>.<listcomp>.<listcomp>1s��4I�4I�4I�!�U�1�X�X�4I�4I�4IrHrvrwr9s  rGr`z$Cxx.visit_Module.<locals>.<listcomp>1s^��*�*�*���C�H�H�j�\�4I�4I�q�4I�4I�4I�%I�J�J�$�%�&�&�*�*�*rHNc3�B�K�|]}��|��V��dSrJrjrks  �rGr�z#Cxx.visit_Module.<locals>.<genexpr>5s?�����+/�+/��4�:�:�d�+;�+;�+/�+/�+/�+/�+/�+/rHc��g|]	}|D]}|���
Sriri)r]�lsrUs   rGr`z$Cxx.visit_Module.<locals>.<listcomp>9s%��8�8�8��R�8�8��!�8�8�8�8rH)r��dependenciesr��filterr�rbrr,�passmanager�module_namerrA)	rErO�header_deps�headers�
decls_n_defns�decls�defns�nsbody�nss	`        rG�visit_ModulezCxx.visit_Module*s����T�.�/�/��)�)�'�)�)�)��	�*�*�(�*�*�*�	*���V�D�+/�+/�+/�+/�$(�I�+/�+/�+/�0�0�1�1�
�.;�I�s�M�*�*�"�b����u�8�8�e�e�m�8�8�8��
�|�d�&6�&B�B�F�
K�
K��%�g���n�5�5����rHc��|�t|��}|rtnt|��}|�|��SrJ)r�rr�r�rQ)rErOr[�visitors    rGr#zCxx.visit_FunctionDef=s?�����[�$�/�/��:�6�:�<�<�{�D�A�A���}�}�T�"�"�"rH)rRrSrTrUrCr�r#rVrWs@rGrlrl�sa������� � �D9�9�9�9�9�6�6�6�&#�#�#�#�#�#�#rHrlrJ)NN)UrU�pythran.analysesrrrrrrr	r
rrr
r�pythran.cxxgenrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&�pythran.openmpr'�pythran.passmanagerr(�pythran.syntaxr)�pythran.tablesr*r+r,�pythran.types.conversionr-r.�pythran.types.typesr/�
pythran.utilsr0r1r2r3r4r5r6�pythranr7r8�mathr9r:�gastr1�os�	functoolsr;rKr=rerurwr�r�r��NodeVisitorr�r�rlrirHrG�<module>r�s�����N�M�M�M�M�M�M�M�M�M�I�I�I�I�I�I�I�I�I�I�I�I�G�G�G�G�G�G�G�G�G�G�2�2�2�2�2�2�2�2�H�H�H�H�H�H�H�H�H�H�H�H�O�O�O�O�O�O�O�O�O�O�O�O�O�O�J�J�J�J�J�J�J�J�J�J�J�J�N�N�N�N�N�N�N�N�N�N�N�N�N�N�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�'�'�'�'�'�'�'�'�'�'�'�'�-�-�-�-�-�-�H�H�H�H�H�H�H�H�'�'�'�'�'�'�J�J�J�J�J�J�J�J�%�%�%�%�%�%�D�D�D�D�D�D�D�D�D�D�D�D�D�D�,�,�,�,�,�,�,�,�%�%�%�%�%�%�%�%�������������	�	�	�	�������	�	�	�	�(�(�(�(�(�W�(�(�(�*	�	�	�	�-�-�-�`"�"�"�"�"�"�"�"�J*�*�*�
9=�K�K�K�K�*.2�:�:�:�:�h
D�h
D�h
D�h
D�h
D�#�/�h
D�h
D�h
D�VZO�ZO�ZO�ZO�ZO�;�ZO�ZO�ZO�zB#�B#�B#�B#�B#�'�B#�B#�B#�B#�B#rH

Youez - 2016 - github.com/yon3zu
LinuXploit