403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.217.85
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/optimizations/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

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

cR�az"����dZddlmZmZddlmZddlmZddlm	Z	m
Z
mZmZddl
mZddlmZddlmZmZdd	lZdd
lmZdd	lZejd��ZGd�d
e��ZGd�de��Zd	S)z< ConstantFolding performs some kind of partial evaluation.  �)�ConstantExpressions�
ASTMatcher)�Transformation)�MODULES)�to_ast�ConversionError�	ToNotEval�mangle)�DamnTooLongPattern)�PythranSyntaxError)�
isintegral�isnumN)�deepcopy�pythranc�`��eZdZdZd�Z�fd�Zd�ZexZZe	j
xZZe	j
xZ
Zd�Z
�xZS)�ConstantFoldingae
    Replace constant expression by their evaluation.

    >>> import gast as ast
    >>> from pythran import passmanager, backend
    >>> node = ast.parse("def foo(): return 1+3")
    >>> pm = passmanager.PassManager("test")
    >>> _, node = pm.apply(ConstantFolding, node)
    >>> print(pm.dump(backend.Python, node))
    def foo():
        return 4
    c�:�tj|t��dS�N�r�__init__r��selfs �H/usr/lib/python3/dist-packages/pythran/optimizations/constant_folding.pyrzConstantFolding.__init__!������&9�:�:�:�:�:�c���t|tj��sJ�dtd��i|_t
D]@}|dkr8t
|��}	t|��|j|<�0#t$rY�<wxYw�Atjd�|jD��g��}tttj|��dd��|j��tt|���|��dS)N�builtins�__dispatch__c�F�g|]}t|tj���|��S�)�
isinstance�ast�Import)�.0�ss  r�
<listcomp>z+ConstantFolding.prepare.<locals>.<listcomp>6s?��#E�#E�#E��*4�Q��
�*C�*C�#E�1�#E�#E�#Erz<constant_folding>�exec)r!r"�Module�
__import__�envrr
�ImportError�body�eval�compile�gast_to_ast�superr�prepare)r�node�module_name�alias_module_name�dummy_module�	__class__s     �rr1zConstantFolding.prepare$s1����$��
�+�+�+�+�+��
�:�.�.�
���#�	�	�K��n�,�,�$*�;�$7�$7�!��2<�[�2I�2I�D�H�.�/�/��"�����D�����	-��z�#E�#E�d�i�#E�#E�#E�"$�&�&��	
�W�S�_�\�2�2�)�6�3�3�
�X�	�	�	�	�o�t�$�$�,�,�T�2�2�2�2�2s�A+�+
A8�7A8c��|Srr �rr2s  r�skipzConstantFolding.skip?s���rc�j�t|tj���r||jv�r�tj|��}ttj|��dd��}	t||j��}t|��}	t|���|��s	d|_|Sn(#t$r}td|d��Yd}~nd}~wwxYwtj||��S#t"$r}td|���d}~wt$$rtj||��cYSt&$rG}t(�d|jdz��tj||��cYd}~Sd}~wt.$rp}d	|jdvrtj||��cYd}~St(�d|jdz��tj||��cYd}~Sd}~wt0$r"}t3t5|��|���d}~wwxYwtj||��S)
Nz<constant folding>r-TzW: z Assume no update happened.zerror in constant folding: z-During constant folding, bailing out due to: rr)r!r"�expr�constant_expressions�
Expressionr.r/r-r*rr�search�updater�printr�
generic_visitrr	�AttributeError�logger�info�args�	NameError�	Exceptionr�str)rr2�	fake_node�code�value�new_node�es       rrAzConstantFolding.generic_visitGs����d�C�H�%�%�$	<�$�$�2K�*K�*K���t�,�,�I��3�?�9�5�5�/��9�9�D�
7��T�4�8�,�,��!�%�=�=��C�%�d�+�+�2�2�8�<�<�(�&*���'��(��*�C�C�C��%��$A�B�B�B�B�B�B�B�B�����C����%�3�D�$�?�?�?��"�
�
�
��3�Q�7�7�7�������
@�
@�
@�%�3�D�$�?�?�?�?�?�!�
@�
@�
@����K��F�1�I�&�'�'�'�%�3�D�$�?�?�?�?�?�?�?�?������
@�
@�
@�"�Q�V�A�Y�.�.�)�7��d�C�C�C�C�C�C�C�C����K��F�1�I�&�'�'�'�%�3�D�$�?�?�?�?�?�?�?�?������
7�
7�
7�(��Q����6�6�6�����
7����"�/��d�;�;�;s��$C,�*B/�.C,�/
C�9C�
C,�C�C,�,
H�6D�"H�+	H�4<E6�0H�6
H�#G.�&H�,<G.�(H�.
H�;H�H)�__name__�
__module__�__qualname__�__doc__rr1r9�visit_Constant�
visit_NamerrA�
visit_List�	visit_Set�
visit_Dict�visit_Tuple�
__classcell__)r6s@rrrs����������;�;�;�3�3�3�3�3�6���#'�&�N�Z�+�9�9�J��-�;�;�J��%<�%<�%<�%<�%<�%<�%<rrc�6�eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	dS)	�PartialConstantFoldinga�
    Replace partially constant expression by their evaluation.

    >>> import gast as ast
    >>> from pythran import passmanager, backend

    >>> node = ast.parse("def foo(n): return [n] * 2")
    >>> pm = passmanager.PassManager("test")
    >>> _, node = pm.apply(PartialConstantFolding, node)
    >>> print(pm.dump(backend.Python, node))
    def foo(n):
        return [n, n]

    >>> node = ast.parse("def foo(n): return 2 * (n,)")
    >>> _, node = pm.apply(PartialConstantFolding, node)
    >>> print(pm.dump(backend.Python, node))
    def foo(n):
        return (n, n)

    >>> node = ast.parse("def foo(n): return [n] + [n]")
    >>> _, node = pm.apply(PartialConstantFolding, node)
    >>> print(pm.dump(backend.Python, node))
    def foo(n):
        return [n, n]

    >>> node = ast.parse("def foo(n, m): return (n,) + (m, n)")
    >>> _, node = pm.apply(PartialConstantFolding, node)
    >>> print(pm.dump(backend.Python, node))
    def foo(n, m):
        return (n, m, n)
    c�:�tj|t��dSrrrs rrzPartialConstantFolding.__init__�rrc��t|jtjtjf��sdSt|j��sdSt|j��std|���t|j	tj
��S�NFz!Multiplying a sequence by a float)r!�leftr"�List�Tupler�rightr
r�op�Multr8s  r�fold_mult_leftz%PartialConstantFolding.fold_mult_left�ss���$�)�c�h��	�%:�;�;�	��5��T�Z� � �	��5��$�*�%�%�	P�$�%H�$�O�O�O��$�'�3�8�,�,�,rc��t|jtjtjf��sdSt|j��sdSt|j��std|���t|j	tj
��Sr])r!rar"r_r`rr^r
rrbrcr8s  r�fold_mult_rightz&PartialConstantFolding.fold_mult_right�ss���$�*�s�x���&;�<�<�	��5��T�Y���	��5��$�)�$�$�	P�$�%H�$�O�O�O��$�'�3�8�,�,�,rc��t|j|��sdSt|j|��sdSt|jtj��S)NF)r!r^rarbr"�Add�rr2�tys   r�fold_addzPartialConstantFolding.fold_add�sH���$�)�R�(�(�	��5��$�*�b�)�)�	��5��$�'�3�7�+�+�+rc�@���|jvr�S|�����|����r=d|_�fd�t	�jj��D���j_�jS|�	���r5d|_�j�jc�_�_|�
���Stjtj
fD]G}|��|��r/d|_�jxj�jjz
c_�jcS�H�S)NTc�L��g|] }�jjD]}t|�����!Sr )r^�eltsr)r$�_�eltr2s   �rr&z6PartialConstantFolding.visit_BinOp.<locals>.<listcomp>�sH���9�9�9�"#�)-���9�9�"%�'�s�m�m�9�9�9�9r)r<rArdr?�rangerarKr^rnrf�visitr"r_r`rkris ` r�visit_BinOpz"PartialConstantFolding.visit_BinOp�s1����4�,�,�,��K��!�!�$�'�'�����t�$�$�	��D�K�9�9�9�9�',�T�Z�-=�'>�'>�9�9�9�D�I�N��9������%�%�	$��D�K�$(�J��	�!�D�I�t�z��:�:�d�#�#�#��8�S�Y�'�	!�	!�B��}�}�T�2�&�&�
!�"����	���$�*�/�1����y� � � �
!�
�rc	�>�|�|��t|jtj��s|St|jjtj��s|St|j��s|S|jj}|j}|j}|jptj	dd��}|j
ptj	dd��}tj|tj��tj|tj
��|����|_d|_|S)a�
        >>> import gast as ast
        >>> from pythran import passmanager, backend
        >>> pm = passmanager.PassManager("test")

        >>> node = ast.parse("def foo(a): a[1:][3]")
        >>> _, node = pm.apply(PartialConstantFolding, node)
        >>> _, node = pm.apply(ConstantFolding, node)
        >>> print(pm.dump(backend.Python, node))
        def foo(a):
            a[4]

        >>> node = ast.parse("def foo(a): a[::2][3]")
        >>> _, node = pm.apply(PartialConstantFolding, node)
        >>> _, node = pm.apply(ConstantFolding, node)
        >>> print(pm.dump(backend.Python, node))
        def foo(a):
            a[6]

        >>> node = ast.parse("def foo(a): a[-4:][5]")
        >>> _, node = pm.apply(PartialConstantFolding, node)
        >>> _, node = pm.apply(ConstantFolding, node)
        >>> print(pm.dump(backend.Python, node))
        def foo(a):
            a[1]
        rN�T)rAr!rKr"�	Subscript�slice�Slicer
�lower�Constant�step�BinOprhrcr?)rr2�slice_�indexryr{s      r�visit_Subscriptz&PartialConstantFolding.visit_Subscript�s���6	
���4� � � ��$�*�c�m�4�4�	��K��$�*�*�C�I�6�6�	��K��$�*�%�%�	��K���!���
���z����5���Q�� 5� 5���{�3�c�l�1�d�3�3���Y�u�"�w�y�y�"�y��),����)-� /� /�0�0��
�
����rN)
rNrOrPrQrrdrfrkrsrr rrrZrZosy��������@;�;�;�-�-�-�-�-�-�,�,�,����20�0�0�0�0rrZ)rQ�pythran.analysesrr�pythran.passmanagerr�pythran.tablesr�pythran.conversionrrr	r
�pythran.analyses.ast_matcherr�pythran.syntaxr�
pythran.utilsr
r�gastr"�copyr�logging�	getLoggerrCrrZr rr�<module>r�sQ��B�B�<�<�<�<�<�<�<�<�.�.�.�.�.�.�"�"�"�"�"�"�I�I�I�I�I�I�I�I�I�I�I�I�;�;�;�;�;�;�-�-�-�-�-�-�+�+�+�+�+�+�+�+���������������	��	�9�	%�	%��Z<�Z<�Z<�Z<�Z<�n�Z<�Z<�Z<�zI�I�I�I�I�^�I�I�I�I�Ir

Youez - 2016 - github.com/yon3zu
LinuXploit