
    Ng                    n   d dl mZ d dlZ ej        doi dedededededed	ed
edededededededede d dlZd dlZd dlZddlm	Z	 ddlm
Z
 ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZmZ ddlmZmZmZ ddlmZmZ ddlmZ ddlmZmZ dd lmZmZmZm Z  dd!l!m"Z"  G d" d#e          Z# G d$ d%e          Z$ G d& d'e          Z%d(Z&d)Z'd*Z( G d+ d,e          Z) G d- d.e          Z* G d/ d0e          Z+d1 Z,d2 Z-d3 Z.d4 Z/d5 Z0 G d6 d7ee#          Z1 G d8 d9ee#          Z2 G d: d;e          Z3 G d< d=ee#          Z4 G d> d?ee#          Z5 G d@ dAee#          Z6 G dB dCee#          Z7 G dD dEee#          Z8 G dF dGee#          Z9 G dH dIe          Z: G dJ dKe          Z;dL Z< G dM dNe          Z= G dO dPe          Z> G dQ dRe          Z? G dS dTe          Z@ G dU dVee#          ZA G dW dXe          ZB G dY dZe          ZC G d[ d\e          ZD G d] d^e          ZE G d_ d`e          ZF G da dbe          ZG G dc ddee#          ZH G de dfe          ZI G dg dhee#          ZJ G di dje          ZK G dk dle          ZL G dm dne          ZMdS )p    )absolute_importN
PyrexTypesNaming	ExprNodesNodesOptions	UtilNodesLetNode
LetRefNodeTreeFragmentEncodedStringerrorwarningcopyhashlibsys_unicode   )r   )r   )r   )r   )r   )Builtin)Errors)VisitorTransformTreeVisitor)CythonTransformEnvTransformScopeTrackingTransform)r
   r   )r   )r   r   )r   r   CompileErrorInternalError)UtilityCodec                   <    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	S )
SkipDeclarationsa)  
    Variable and function declarations can often have a deep tree structure,
    and yet most transformations don't need to descend to this depth.

    Declaration nodes are removed after AnalyseDeclarationsTransform, so there
    is no need to use this for transformations after that point.
    c                     |S N selfnodes     _/var/www/html/ai-engine/env/lib/python3.11/site-packages/Cython/Compiler/ParseTreeTransforms.pyvisit_CTypeDefNodez#SkipDeclarations.visit_CTypeDefNode)           c                     |S r"   r#   r$   s     r'   visit_CVarDefNodez"SkipDeclarations.visit_CVarDefNode,   r)   r*   c                     |S r"   r#   r$   s     r'   visit_CDeclaratorNodez&SkipDeclarations.visit_CDeclaratorNode/   r)   r*   c                     |S r"   r#   r$   s     r'   visit_CBaseTypeNodez$SkipDeclarations.visit_CBaseTypeNode2   r)   r*   c                     |S r"   r#   r$   s     r'   visit_CEnumDefNodez#SkipDeclarations.visit_CEnumDefNode5   r)   r*   c                     |S r"   r#   r$   s     r'   visit_CStructOrUnionDefNodez,SkipDeclarations.visit_CStructOrUnionDefNode8   r)   r*   c                 F    |j         dk    r|                     |           |S Nextern)
visibilityvisitchildrenr$   s     r'   visit_CppClassNodez#SkipDeclarations.visit_CppClassNode;   s(    ?h&&t$$$r*   N)__name__
__module____qualname____doc__r(   r,   r.   r0   r2   r4   r:   r#   r*   r'   r    r    !   s                         r*   r    c                   `     e Zd ZdZ fdZd Zd ZddZd Zd Z	d	 Z
d
 Zd Zd Zd Z xZS )NormalizeTreea\  
    This transform fixes up a few things after parsing
    in order to make the parse tree more suitable for
    transforms.

    a) After parsing, blocks with only one statement will
    be represented by that statement, not by a StatListNode.
    When doing transforms this is annoying and inconsistent,
    as one cannot in general remove a statement in a consistent
    way and so on. This transform wraps any single statements
    in a StatListNode containing a single statement.

    b) The PassStatNode is a noop and serves no purpose beyond
    plugging such one-statement blocks; i.e., once parsed a
`    "pass" can just as well be represented using an empty
    StatListNode. This means less special cases to worry about
    in subsequent transforms (one always checks to see if a
    StatListNode has no children to see if the block is empty).
    c                 t    t          t          |                               |           d| _        d| _        d S NF)superr@   __init__is_in_statlist
is_in_exprr%   context	__class__s     r'   rD   zNormalizeTree.__init__W   s4    mT""++G444#r*   c                     |                      |           t          |j        t          j                  s&t          j        |j        |j        g          |_        |S Nposstats)r9   
isinstancebodyr   StatListNoderM   r$   s     r'   visit_ModuleNodezNormalizeTree.visit_ModuleNode\   sP    4   $)U%788 	L*tx	{KKKDIr*   c                 Z    | j         }d| _         |                     |           || _         |S NT)rF   r9   )r%   r&   stacktmps      r'   visit_ExprNodezNormalizeTree.visit_ExprNodec   s0    ?4   "r*   Fc                     | j         }|| _         |                     |           || _         | j         s#| j        st          j        |j        |g          S |S rK   )rE   r9   rF   r   rQ   rM   )r%   r&   is_listcontainerrU   s       r'   visit_StatNodezNormalizeTree.visit_StatNodej   sa    &.4   &" 	4? 	%$(4&AAAAKr*   c                 L    d| _         |                     |           d| _         |S NTF)rE   r9   r$   s     r'   visit_StatListNodez NormalizeTree.visit_StatListNodet   s+    "4   #r*   c                 .    |                      |d          S rT   rY   r$   s     r'   visit_ParallelAssignmentNodez*NormalizeTree.visit_ParallelAssignmentNodez       ""4...r*   c                 .    |                      |d          S rT   r^   r$   s     r'   r2   z NormalizeTree.visit_CEnumDefNode}   r`   r*   c                 .    |                      |d          S rT   r^   r$   s     r'   r4   z)NormalizeTree.visit_CStructOrUnionDefNode   r`   r*   c                 J    | j         st          j        |j        g           S g S )zEliminate PassStatNoderL   )rE   r   rQ   rM   r$   s     r'   visit_PassStatNodez NormalizeTree.visit_PassStatNode   s*    " 	%$("====Ir*   c                 n    |j         j        r|                     |          S |                     |          S )z!Eliminate useless string literals)expris_string_literalrd   rY   r$   s     r'   visit_ExprStatNodez NormalizeTree.visit_ExprStatNode   s7    9& 	-**4000&&t,,,r*   c                     |S r"   r#   r$   s     r'   r.   z#NormalizeTree.visit_CDeclaratorNode   r)   r*   F)r;   r<   r=   r>   rD   rR   rV   rY   r\   r_   r2   r4   rd   rh   r.   __classcell__rI   s   @r'   r@   r@   B   s         (         
         / / // / // / /  - - -      r*   r@   c                       e Zd ZdS )PostParseErrorN)r;   r<   r=   r#   r*   r'   rn   rn      s          r*   rn   zHCannot assign default value to fields in cdef classes, structs or unionsz0Invalid buffer defaults specification (see docs)z0Special attributes must not have a type declaredc                   j     e Zd ZdZ f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 xZS )	PostParsea  
    Basic interpretation of the parse tree, as well as validity
    checking that can be done on a very basic level on the parse
    tree (while still not being a problem with the basic syntax,
    as such).

    Specifically:
    - Default values to cdef assignments are turned into single
    assignments following the declaration (everywhere but in class
    bodies, where they raise a compile error)

    - Interpret some node structures into Python runtime values.
    Some nodes take compile-time arguments (currently:
    TemplatedTypeNode[args] and __cythonbufferdefaults__ = {args}),
    which should be interpreted. This happens in a general way
    and other steps should be taken to ensure validity.

    Type arguments cannot be interpreted in this way.

    - For __cythonbufferdefaults__ the arguments are checked for
    validity.

    TemplatedTypeNode has its directives interpreted:
    Any first positional argument goes into the "dtype" attribute,
    any "ndim" keyword argument goes into the "ndim" attribute and
    so on. Also it is checked that the directive combination is valid.
    - __cythonbufferdefaults__ attributes are parsed and put into the
    type information.

    Note: Currently Parsing.py does a lot of interpretation and
    reorganization that can be refactored into this transform
    if a more pure Abstract Syntax Tree is wanted.

    - Some invalid uses of := assignment expressions are detected
    c                 t    t          t          |                               |           d| j        i| _        d S )N__cythonbufferdefaults__)rC   rp   rD   handle_bufferdefaultsspecialattribute_handlersrG   s     r'   rD   zPostParse.__init__   s9    i''000&)C*
&&&r*   c           	         t                      }|                    |j                   |j        s&|j        st          |j        t          j                  r&t          j	        |j        j
        |j                  }n%t          j        |j        j
        |j                  }t          j        |j
        |j        |j        |j        |j        |d           |_        |                     |           |S )Nrf   value)nameargsstar_argstarstar_argrP   doc)YieldNodeCollectorr9   result_expr	has_yield	has_awaitrO   r   YieldExprNoder   ExprStatNoderM   ReturnStatNodeDefNodery   rz   r{   r|   def_node)r%   r&   	collectorrP   s       r'   visit_LambdaNodezPostParse.visit_LambdaNode   s    &((	 0111 	>)"5 	>DDTV_Vm9n9n 	>% $4+;= = =DD ' $D,<> > >DH49T]*4	! ! !
 	4   r*   c                 D   t                      }|                    |j        d dg           t          j        |j        |j        d g d d |j        |j        d	  	        |_        t          
                    |j        | j        dv            |                     |           |S )NiteratorattrsexcludeT)ry   r}   rz   r{   r|   rP   is_async_defis_generator_expressionpyclasscclassscope_is_class)r~   r9   loopr   r   rM   ry   r   r   _AssignmentExpressionChecker	do_checks
scope_typer%   r&   r   s      r'   visit_GeneratorExpressionNodez'PostParse.visit_GeneratorExpressionNode   s    &((		
|LLLH49$d)<$(	* * *
 	%..ty\qIq.rrr4   r*   c                     |j         s6t                      }|                    |j                   |j        rd|_         t
                              |j        | j        dv            |                     |           |S )NTr   r   )has_local_scoper~   r9   r   r   r   r   r   r   s      r'   visit_ComprehensionNodez!PostParse.visit_ComprehensionNode   s}    # 	,*,,I##DI..." ,'+$$..ty\qIq.rrr4   r*   c                     t          |j        t          j                  st	          |j        t                    |j        | j        _        |j        | j        _	        d S r"   )
rO   defaultr   DictNodern   rM   ERR_BUF_DEFAULTS
scope_nodebuffer_defaults_nodebuffer_defaults_pos)r%   decls     r'   rs   zPostParse.handle_bufferdefaults   sJ    $,	(:;; 	= +;<<</3|,.2h+++r*   c           
         	 |                      |           |g}g }|j        D ]h}|}t          |t          j                  r!|j        }t          |t          j                  !t          |t          j                  r|j        | j        dv rt          | j	        t          j
                  rK| j                            |j                  }|r*||urt          |j        t                      ||           t          |j        t"                    | j        dk    }|                    t          j        |j        t)          j        |j        |j                  |j        |                     d |_        |                    |           j||_        |S # t          $ r%}| j                            |           Y d }~d S d }~ww xY w)N)r   r   structmodulery   )lhsrhsfirst)r9   declaratorsrO   r   CPtrDeclaratorNodebaseCNameDeclaratorNoder   r   r   CClassDefNodert   getry   rn   rM   ERR_INVALID_SPECIALATTR_TYPEERR_CDEF_INCLASSappendSingleAssignmentNoder   NameNoderH   nonfatal_error)	r%   r&   rN   newdeclsr   declbasehandlerfirst_assignmentes	            r'   r,   zPostParse.visit_CVarDefNode   s   
	t$$$FEH( & & 5+CDD -'}H !5+CDD -h(ABB 0'3?.MMM)$/5;NOO -*.*H*L*LTY*W*W#* !-'+8';';.<TXGc.d.d(d$+GDMMM$,"0;K"L"LL+/?h+F(U%? ) 248(- P P P ( 08H&J &J &J K K K ,0(%%%%'DL 	 	 	 L''***44444		s   FF 
G G  Gc                 p    |                      |           |                     ||j        |j        g          S r"   )r9   _visit_assignment_noder   r   r$   s     r'   visit_SingleAssignmentNodez$PostParse.visit_SingleAssignmentNode#  s5    4   **4$(DH1EFFFr*   c                 t    |                      |           |                     ||j        |j        gz             S r"   )r9   r   lhs_listr   r$   s     r'   visit_CascadedAssignmentNodez&PostParse.visit_CascadedAssignmentNode'  s7    4   **4$(1KLLLr*   c                    t          d |D                       dk     r|S g }t          ||           g }t          ||           g }|D ]{}|dd         }|d         }t          |          dk    r#t	          j        |j        |d         |          }nt	          j        |j        ||          }|                    |           |t          |          dk    r	|d         }n!t	          j	        |d         j        |	          }|r<d
 |D             }	t          |	           |	ddd         D ]\  }
}t          ||          }|S )zgFlatten parallel assignments into separate single
        assignments or cascaded assignments.
        c                 .    g | ]}|j         s|j        d S r   )is_sequence_constructorrg   .0rf   s     r'   
<listcomp>z4PostParse._visit_assignment_node.<locals>.<listcomp>/  sB     M M Mt0M484JM M M Mr*      Nr   r   r   r   )r   r   rN   c                      g | ]}|j         |fS r#   )
expression)r   temps     r'   r   z4PostParse._visit_assignment_node.<locals>.<listcomp>K  s/     $= $= $=)- '+ot%< $= $= $=r*   )sumflatten_parallel_assignmentseliminate_rhs_duplicateslenr   r   rM   CascadedAssignmentNoder   ParallelAssignmentNodesort_common_subsequencesr
   )r%   r&   	expr_listexpr_list_list	temp_refsnodesr   r   assign_nodeduplicates_and_temps_temp_refs               r'   r   z PostParse._visit_assignment_node+  s     M My M M M N NPQR R K$Y???	 ;;;' 		 		I "~HB-C8}}!!1#'"1+S2 2 2 3CG's4 4 4LLu::??(KK6uQx|USSSK 	=$= $=1:$= $= $= $%9:::3DDbD9 = =8%h<<r*   c                     |j         D ]5}|j        r|                     ||            |                    |           6|S r"   )rz   r   _flatten_sequencer   )r%   seqresultargs       r'   r   zPostParse._flatten_sequenceS  sQ    8 	# 	#C* #&&sF3333c""""r*   c                 f    |                      |           |                     |g           |_        |S r"   )r9   r   rz   r$   s     r'   visit_DelStatNodezPostParse.visit_DelStatNode[  s2    4   **444	r*   c                 |   |j         rt          j        |j        t	          j        |j        j        |j        j                  gd          }t          j        |j        t          j	        |j        |j
        t          j        |j        |g                    g          |_
        |                     |           |S )Nr   T)rz   ignore_nonexistingr   )rP   finally_clause)is_except_asr   DelStatNoderM   r   r   targetry   rQ   TryFinallyStatNoderP   r9   )r%   r&   
del_targets      r'   visit_ExceptClauseNodez PostParse.visit_ExceptClauseNode`  s     	/*(KO$+*:< < < =#'	) ) )J
 */H#(#5)l$, $, $,- - - ./ / /DI 	4   r*   c           	          |j         Wt          j        |j        t	          j        |j        t          d                    |j        dddd          |_         d|_        |                     |           |S )zUExtract the exception raising into a RaiseStatNode to simplify GIL handling.
        NAssertionErrorr   T)exc_type	exc_valueexc_tbcausebuiltin_exc_namewrap_tuple_value)		exceptionr   RaiseStatNoderM   r   r   r   rx   r9   r$   s     r'   visit_AssertStatNodezPostParse.visit_AssertStatNodes  s{     >!"0"+DH=IY;Z;Z[[[*!1!%  DN DJ4   r*   )r;   r<   r=   r>   rD   r   r   r   rs   r,   r   r   r   r   r   r   r   rk   rl   s   @r'   rp   rp      s        " "F
 
 
 
 
  $  	 	 	7 7 7$ $ $ZG G GM M M& & &P    
  &      r*   rp   c                   <     e Zd Z fdZd Zd Zd Zd Zd Z xZ	S )%_AssignmentExpressionTargetNameFinderc                 d    t          t          |                                            i | _        d S r"   )rC   r   rD   target_namesr%   rI   s    r'   rD   z._AssignmentExpressionTargetNameFinder.__init__  s.    3T::CCEEEr*   c                     |j         r|j        gS |j        r6g }|j        D ]*}|                    |                     |                     +|S g S r"   )is_namery   r   rz   extendfind_target_names)r%   r   namesr   s       r'   r  z7_AssignmentExpressionTargetNameFinder.find_target_names  sd    > 	K= + 	E{ : :T33C889999L	r*   c                     t          |                     |j                            | j        |<   |                     |           d S r"   )tupler  r   r   r9   r$   s     r'   visit_ForInStatNodez9_AssignmentExpressionTargetNameFinder.visit_ForInStatNode  sA    "'(>(>t{(K(K"L"L$4     r*   c                     d S r"   r#   r$   s     r'   r   z=_AssignmentExpressionTargetNameFinder.visit_ComprehensionNode      r*   c                     d S r"   r#   r$   s     r'   r   z6_AssignmentExpressionTargetNameFinder.visit_LambdaNode  r
  r*   c                 0    |                      |           d S r"   r9   r$   s     r'   
visit_Nodez0_AssignmentExpressionTargetNameFinder.visit_Node      4     r*   )
r;   r<   r=   rD   r  r  r   r   r  rk   rl   s   @r'   r   r     s            	 	 	! ! !    ! ! ! ! ! ! !r*   r   c                   h     e Zd ZdZ fdZd Zd Zed             Zd Z	d Z
d Zd	 Zd
 Zd Z xZS )r   za
    Enforces rules on AssignmentExpressions within generator expressions and comprehensions
    c                 ~   t          t          |                                            t                      }|                    |           |j        | _        d| _        d| _        || _	        d| _
        t                      | _        | j                                        D ]}| j                            |           d S NFr#   )rC   r   rD   r   visitr   target_names_dictin_iteratorin_nested_generatorr   current_target_namessetall_target_namesvaluesupdate)r%   	loop_noder   target_name_finderr  rI   s        r'   rD   z%_AssignmentExpressionChecker.__init__  s    *D11::<<<BDD  +++!3!@ #( ,$&! #+2244 	0 	0E!((////	0 	0r*   c                     | j         | j        | j        | j        | j        f}d| _        d| _        d| _        t                      | _        |S r  )r  r  r   r  r  r  r%   	old_states     r'   _reset_statez)_AssignmentExpressionChecker._reset_state  sT    %t'?ATVZVkmq  nG  H	#( #$&! #r*   c                 H    |\  | _         | _        | _        | _        | _        d S r"   )r  r  r   r  r  r  s     r'   
_set_statez'_AssignmentExpressionChecker._set_state  s,     }Fy$2D4GI^`d`y`y`yr*   c                 H     | ||          }|                     |           d S r"   )r  )clsr  r   checkers       r'   r   z&_AssignmentExpressionChecker.do_checks  s+    #i00i     r*   c                 6   | j         r|                     |           d S | j        }| j                            |d           }|r| xj        |z  c_        d| _        |                     |j                   d| _        |                     |d           || _        d S )NTF)r   r   )r  r9   r  r  r   r  r  r   )r%   r&   r  target_names       r'   r  z0_AssignmentExpressionChecker.visit_ForInStatNode  s    # 	t$$$F#8,00t<< 	5%%4%%

4=!!! 4777$8!!!r*   c                 *   | j         rt          |j        d           | j        rt          |j        d           |j        | j        v rt          |j        d|j        z             d S |j        | j        v rt          |j        d|j        z             d S d S )NzKassignment expression cannot be used in a comprehension iterable expressionzKassignment expression within a comprehension cannot be used in a class bodyzIassignment expression cannot rebind comprehension iteration variable '%s'zHcomprehension inner loop cannot rebind assignment expression target '%s')r  r   rM   r   r)  r  r  r$   s     r'   visit_AssignmentExpressionNodez;_AssignmentExpressionChecker.visit_AssignmentExpressionNode  s     	k$(ijjj 	k$(ijjjt888$(g"# $ $ $ $ $!666$(f"# $ $ $ $ $ 76r*   c                     |                                  }|                     |j                   |                     |           d S r"   )r!  r  r   r#  )r%   r&   r   s      r'   r   z-_AssignmentExpressionChecker.visit_LambdaNode  sB     %%''	

4#$$$	"""""r*   c                 Z    | j         }d| _         |                     |           || _         d S rT   )r  r9   r%   r&   r  s      r'   r   z4_AssignmentExpressionChecker.visit_ComprehensionNode  s5    "6#' 4   #6   r*   c                 d    | j         }d| _         |                     |j                   || _         d S rT   )r  r  r   r.  s      r'   r   z:_AssignmentExpressionChecker.visit_GeneratorExpressionNode  s5    "6#' 

49#6   r*   c                 0    |                      |           d S r"   r  r$   s     r'   r  z'_AssignmentExpressionChecker.visit_Node  r  r*   )r;   r<   r=   r>   rD   r!  r#  classmethodr   r  r+  r   r   r   r  rk   rl   s   @r'   r   r     s         0 0 0 0 0  F F F ! ! [!9 9 9"
$ 
$ 
$# # #7 7 77 7 7! ! ! ! ! ! !r*   r   c                    t                      i fd| D ]}|d         } |           sdS fdD ]0}|j        r't          t          |j                            |_        1| D ]} |d                   |d<   dS )zReplace rhs items by LetRefNodes if they appear more than once.
    Creates a sequence of LetRefNodes that set up the required temps
    and appends them to ref_node_sequence.  The input list is modified
    in-place.
    c                     | j         s| j        rd S | v r1| vr+t          |           }|| <                       |           d S d S                     |            | j        r| j        D ]} |           d S d S r"   )
is_literalr  r   r   addr   rz   )r&   ref_nodeitemfind_duplicatesref_node_sequence	ref_nodes
seen_nodess      r'   r8  z1eliminate_rhs_duplicates.<locals>.find_duplicates  s    ? 	dl 	 F:9$$%d++"*	$!((22222 %$
 NN4   + * I * *D#OD))))* ** *r*   r   Nc                 |    | v r|          S | j         r't          t          | j                            | _        | S r"   )r   listmaprz   )r&   r:  substitute_nodess    r'   r?  z2eliminate_rhs_duplicates.<locals>.substitute_nodes  sD    9T?") 	?S!149==>>DIr*   )r  r   r=  r>  rz   )	r   r9  r   r   r&   r8  r:  r;  r?  s	    `   @@@@r'   r   r     s    JI* * * * * * * *  $  	m        ? ?' 	?S!149==>>DI $ 8 8	((277	"8 8r*   c                    fdfd}t          |           D ]m\  }}|d         }|}t          |dz
  dd          D ]} ||| |         d                   r|}||k    r't          ||d          D ]}| |dz
           | |<   || |<   ndS )a  Sort items/subsequences so that all items and subsequences that
    an item contains appear before the item itself.  This is needed
    because each rhs item must only be evaluated once, so its value
    must be evaluated first and then reused when packing sequences
    that contain it.

    This implies a partial order, and the sort must be stable to
    preserve the original order as much as possible, so we use a
    simple insertion sort (which is very fast for short sequences, the
    normal case in practice).
    c                 V    | D ]$}||u r dS |j         r |j        |          r dS %dS r[   r   rz   )r   xr7  containss      r'   rD  z*sort_common_subsequences.<locals>.contains5  sO     	 	Dqyytt- ((49a2H2H ttur*   c                 4    |j         o |j        |           S r"   rB  )abrD  s     r'   
lower_thanz,sort_common_subsequences.<locals>.lower_than<  s    (@XXafa-@-@@r*   r   r   r   N)	enumeraterange)itemsrH  rM   r7  keynew_posirD  s          @r'   r   r   )  s        A A A A A u%% 	" 	"	T1gs1ub"%% 	 	Az#uQx{++ c>>3,, & & 1:a!E'N	" 	"r*   c                     g }| j         }| j        }| j        }|j        }|D ].} ||          }|                     ||||                     /|S )N)rx   constant_result)rM   rI   rx   r   )literalcharsrM   stypesval	sval_typecharcvals           r'   #unpack_string_to_character_literalsrX  J  sm    E
+CE=DI C CyUU3dDAAABBBBLr*   c                    | d         }|j         st          |t          j                  r!t	          d | d d         D                       s|                    |            d S g }|j         r|j        }n|j        rt          |          }t          |          }d t          |          D             }g }| d d         D ]g}|j         s2|j        rt          |j        d           |                    |           <t          |j                  }	t	          d |j        D                       }
|
dk    r-t          |j        d           |                    ||g           |	|
z
  |k    r:t          |j        d||dk    rd	pd
fz             |                    ||g           |
rt          |||j        |           |	|k     r3t          |j        d|	|fz             |                    ||g           7t          ||j                  D ]\  }}|                    |           i|r*|                    |           |                    |           t          ||          D ],\  }}|r%|                    |           t!          ||           -|D ]5}|d         j         rt!          ||            |                    |           6d S )Nr   c                     g | ]	}|j         
S r#   )r   )r   r   s     r'   r   z0flatten_parallel_assignments.<locals>.<listcomp>^  s    JJJ3JJJr*   c                     g | ]}g S r#   r#   )r   r   s     r'   r   z0flatten_parallel_assignments.<locals>.<listcomp>j  s    ///!2///r*   z4starred assignment target must be in a list or tuplec                      g | ]}|j         	d S r   )
is_starredr   s     r'   r   z0flatten_parallel_assignments.<locals>.<listcomp>s  s    IIITIqIIIr*   r   z,more than 1 starred expression in assignmentz#need more than %d value%s to unpacks z/too many values to unpack (expected %d, got %d)r   )r   rO   r   UnicodeNoder   r   rz   rg   rX  r   rJ  r]  r   rM   map_starred_assignmentzipr   )inputoutputr   complete_assignmentsrhs_argsrhs_sizelhs_targetsstarred_assignmentsr   lhs_sizestarred_targetstargetsrf   cascades                 r'   r   r   U  sW    )C( JsI<Q,R,R JJuSbSzJJJKKe
" <8		 <6s;;8}}H//uX///KSbSz % %* 	~ WcgUVVV '',,,sx==IISXIIIJJQ#'IJJJMM3s)$$$'(22#'@A63<"=> ? ? ?MM3s)$$$ 
	%";0C#&8X7 7 7 7  #'Lx() * * *MM3s)$$$!$[#(!;!; % %t$$$$%  ,##C(((*+++ K22 : : 	:NN3(&999 ' # #1:- 	#(&9999MM'""""	# #r*   c                 D   t          t          | |                    D ]=\  }\  }}|j        r|}t          |          |z
  dz
  } n%|                    |           >t          d          t          t          | | d          ||dz   d                              D ]\  }\  }}|                    |           ||         j        }	||d          }
|r|
d |          }
|
r|
d         j        }n|	j        }|                    |	t          j	        ||
          g           d S )Nr   z6no starred arg found when splitting starred assignmentr   )rM   rz   )
rI  rb  r]  r   r   r   r   rM   r   ListNode)rh  ri  lhs_argsrf  rN  rl  rf   starredlhs_remainingr   starred_rhsrM   s               r'   ra  ra    sv    (K(B(BCC V V?GT? 	GMMA-1MEtTUUU (K,H,4Wq[\\,B)D )D E E  ?GTt g%F788$K 3!/M>/2 !n j	"s=== ? @ @ @ @ @r*   c                   6     e Zd ZdZdZdZ fdZd Zd Z xZ	S )PxdPostParsea  
    Basic interpretation/validity checking that should only be
    done on pxd trees.

    A lot of this checking currently happens in the parser; but
    what is listed below happens here.

    - "def" functions are let through only if they fill the
    getbuffer/releasebuffer slots

    - cdef functions are let through only if they are on the
    top level and are declared "inline"
    z>function definition in pxd file must be declared 'cdef inline'z5inline function definition in pxd file cannot be '%s'c                 b    d| _         t          t          |                               |          S )Npxd)r   rC   ru  __call__r%   r&   rI   s     r'   rx  zPxdPostParse.__call__  s(    \4((11$777r*   c                 Z    | j         }d| _         |                     |           || _         |S Nr   )r   r9   )r%   r&   olds      r'   visit_CClassDefNodez PxdPostParse.visit_CClassDefNode  s0    o"4   r*   c                    | j         }t          |t          j                  r| j        dk    r|j        dv rd }t          |t          j                  rPd|j        v r@| j        dv r7d|_        |j	        dk    r| j
        |j	        z  }n|j        r| j
        dz  }n
d }n| j         }|r/| j                            t          |j        |                     d S |S )Nr   )__getbuffer____releasebuffer__inline)rw  r   Tprivateapi)ERR_INLINE_ONLYrO   r   r   r   ry   CFuncDefNode	modifiersinline_in_pxdr8   ERR_NOGO_WITH_INLINEr  rH   r   rn   rM   )r%   r&   errs      r'   visit_FuncDefNodezPxdPostParse.visit_FuncDefNode  s     "tU]++ 	80K0KI!GGGCdE.// 	+T^++O'888%)"?i//3doECCX 3e;CCCC* 	L''tx(E(EFFF4Kr*   )
r;   r<   r=   r>   r  r  rx  r}  r  rk   rl   s   @r'   ru  ru    sn          WOR8 8 8 8 8        r*   ru  c                   8     e Zd Z fdZd Zd Zej        Z xZ	S )TrackNumpyAttributesc                 |    t          t          |                                            t                      | _        d S r"   )rC   r  rD   r  numpy_module_namesr   s    r'   rD   zTrackNumpyAttributes.__init__  s2    "D))22444"%%%r*   c                 ^    |j         dk    r!| j                            |j        pd           |S )Nnumpy)module_namer  r5  as_namer$   s     r'   visit_CImportStatNodez*TrackNumpyAttributes.visit_CImportStatNode  s3    x''#''(@AAAr*   c                     |                      |           |j        }|j        r|j        | j        v s|j        rd|_        |S rT   )r9   objr  ry   r  is_numpy_attribute)r%   r&   r  s      r'   visit_AttributeNodez(TrackNumpyAttributes.visit_AttributeNode  sK    4   hK 	+CH(???CDZ?&*D#r*   )
r;   r<   r=   rD   r  r  r   recurse_to_childrenr  rk   rl   s   @r'   r  r    sT        ( ( ( ( (  
   "5JJJJJr*   r  c            
           e Zd ZdZej        ej        ej         ej        dd           ej        dd           ej        dd           ej        dd          ej	        ej        d	Z
d ej        d          iZh d	Ze                    e
           h d
Zh dZ f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 Z d Z!d Z"d Z#d Z$d  Z%d! Z&d" Z'd# Z(d$ Z)d% Z* xZ+S )&InterpretCompilerDirectivesa+  
    After parsing, directives can be stored in a number of places:
    - #cython-comments at the top of the file (stored in ModuleNode)
    - Command-line arguments overriding these
    - @cython.directivename decorators
    - with cython.directivename: statements
    - replaces "cython.compiled" with BoolNode(value=True)
      allowing unreachable blocks to be removed at a fairly early stage
      before cython typing rules are forced on applied

    This transform is responsible for interpreting these various sources
    and store the directive in two ways:
    - Set the directives attribute of the ModuleNode for global directives.
    - Use a CompilerDirectivesNode to override directives for a subtree.

    (The first one is primarily to not have to modify with the tree
    structure, so that ModuleNode stay on top.)

    The directives are stored in dictionaries from name to value in effect.
    Each such dictionary is always filled in for all possible directives,
    using default values where no value is given by the user.

    The available directives are controlled in Options.py.

    Note that we have to run this prior to analysis, and so some minor
    duplication of functionality has to occur: We manually track cimports
    and which names the "cython" module may have been imported to.
    Tz++z--F)	typeofzoperator.addresszoperator.dereferencezoperator.preincrementzoperator.predecrementzoperator.postincrementzoperator.postdecrementzoperator.typeidaddresszoperator.comma,>   NULLcastunionsizeofr   declarepointertypedefcompiledparallel
fused_type>   viewcimportsoperatorr  dataclasses>   pranger  threadidc                 r   t          t          |                               |           t                      | _        ddi| _        i | _        t          j        t          j
                              }|                                D ])\  }}t          j        |          |t          |          <   *|| _        d S )Nstaticmethod)rC   r  rD   r  cython_module_namesdirective_namesparallel_directivesr   deepcopyr   get_directive_defaultsrK  r   
directives)r%   rH   compilation_directive_defaultsr  rL  rx   rI   s         r'   rD   z$InterpretCompilerDirectives.__init__R  s    )40099'BBB#&55  .?#% ]7#A#C#CDD
8>>@@ 	= 	=JC(,e(<(<Jx}}%%$r*   c           
          t           j                            |d           }|r5||vr1| j                            t          |d|d|d                     dS |t           j        vrt          |d|d           dS )NzThe z& compiler directive is not allowed in z scopeFzInvalid directive: 'z'.T)r   directive_scopesr   rH   r   rn   directive_typesr   )r%   rM   	directivescopelegal_scopess        r'   check_directive_scopez1InterpretCompilerDirectives.check_directive_scope\  s    /33ItDD 	E55L''ssHQ		SXSXSX=Z )[ )[ \ \ \5 777ccDEEE4r*   c                    |                     d          sd S |                    dd          d         }|| j        v rd S d}d d                                d d         D             }|D ]$\  }}|                     d|z             rd	|z  } n%|sB|t          j        v }|s+|                     d
          sddlm}	 t          |	|          }|rd|z  }t          |d|d|rdnd|           d S )Ncython..r   r   r_  c                 6    g | ]}|                                 S r#   )split)r   lines     r'   r   zJInterpretCompilerDirectives._check_valid_cython_module.<locals>.<listcomp>p  s-     
 
 
!DJJLL
 
 
r*   z                imp                  cimports
                cimp                 cimports
                para                 parallel
                parra                parallel
                dataclass            dataclasses
            r   zDid you mean 'cython.%s' ?r   )Shadowz2Instead, use 'import cython' and then 'cython.%s'.'z ' is not a valid cython.* modulez. )

startswithr  valid_cython_submodules
splitlinesr   r  r_  r  hasattrr   )
r%   rM   r  	submoduleextrahintswrongcorrectis_simple_cython_namer  s
             r'   _check_valid_cython_modulez6InterpretCompilerDirectives._check_valid_cython_moduleg  sx   %%i00 	F%%c1--a0	444F
 
& 
SbS&"
 
 
 $ 	 	NE7%%i%&788 4w>  	Y$-1H$H!( C1E1Ec1J1J C &%%%%%(/	(B(B%$ YLyXccKK!DDr!E
 	 	 	 	 	r*   c                 |   t          |j                  D ]B}|                     |j        |d          s$|                     |j        |d           |j        |= C|j        | _        | j                            |j                   | j        |_        | j	        |_	        | 
                    |           | j        |_        |S )Nr   )sorteddirective_commentsr  rM   wrong_scope_errorr  module_scoper  r  r  r9   r  )r%   r&   rL  s      r'   rR   z,InterpretCompilerDirectives.visit_ModuleNode  s    $122 	1 	1C--dhXFF 1&&txh???+C0 Jt6777/#'#; 4   #'#; r*   c                 f    | j         |j         c}| _         |                     |           || _         |S r"   r  r9   r%   r&   old_directivess      r'   visit_CompilerDirectivesNodez8InterpretCompilerDirectives.visit_CompilerDirectivesNode  s4    *./4?'4   (r*   c                 X    |t           j        v p|| j        v pt          j        |          S r"   )r   r  special_methodsr   parse_basic_type)r%   ry   s     r'   is_cython_directivez/InterpretCompilerDirectives.is_cython_directive  s5    // 2,,2+D11	3r*   c                    |dz                        d          }|r|                    d          }|dk    rd| j        d<   nS|dk    r| j        D ]}d|z  | j        |<   n5t	          |          dk    s|d         | j        vrt          |d	|z             | j                            t          j	        d
d                     |S )z
        Checks to see if fullname (e.g. cython.parallel.prange) is a valid
        parallel directive. If it is a star import it also updates the
        parallel_directives.
        r  cython.parallel.cython.parallelr  zcython.parallel.*zcython.parallel.%s   r   zNo such directive: %sInitThreadsModuleSetupCode.c)
r  r  r  valid_parallel_directivesr   r   r  use_utility_coder   load_cached)r%   	full_namerM   r   r  ry   s         r'   is_parallel_directivez1InterpretCompilerDirectives.is_parallel_directive  s     c/--.@AA 	M!,,I...8J(55222 : R RD5JT5QD,T22Ri..A%%B-t'EEEc2Y>???..'7JKKM M M r*   c                    |j         }|dk    rt          |j        d           |                    d          rE|j        r)|j        dk    r|t          d          d          |_         |S t          |j        d           |dk    r#| j                            |j        pd           n|                    d          r|                    d          rt          |j        |j         dz              n|                     |j        |           |d	k    rt|j        r|j        dk    r|| j	        |j        <   n$| j                            d           || j	        d	<   | j
                            t          j        d
d                     n9|j        r|dd          | j        |j        <   n| j                            d           d S |S )Ncython.cimportszGCannot cimport the 'cython.cimports' package directly, only submodules.cython.cimports.cythonzkPython cimports must use 'from cython.cimports... import ...' or 'import ... as ...', not just 'import ...'r  r  z is not a moduler  r  r     )r  r   rM   r  r  r   r  r5  r  r  r  r  r   r  r  r%   r&   r  s      r'   r  z1InterpretCompilerDirectives.visit_CImportStatNode  s   &,,,$(efff!!"566 	D| 	 9 9#.s3F/G/G/H/H#I $(CD D D )##$(()BCCCC##J// 	%%&9:: Gdh 03E EFFFF//+FFF000< FDLI$=$==HD,T\::,00;;;:E ,$68!22+M;NOOQ Q Q Q 85@_$T\22(,,Y777 4r*   c                    |j         }|dk    s|                    d          r'|                     |j        ||j        |j                  S |j        s|dk    s|                    d          r|                     |j        |           |dz   dd          }g }|j        D ]\  }}}||z   }d|z   }	|                     |	|j                  r|	| j        |p|<   8| 	                    |          r|| j
        |p|<   Z|dv r%|| j
        |p|<   |                    |||f           |                    |||f           |sd S ||_        |S )Nr  r  r  r  r  r  )r  typing)r  r  _create_cimport_from_importrM   relative_levelimported_namesr  r  r  r  r  r   )
r%   r&   r  r  newimprM   ry   r  r  qualified_names
             r'   visit_FromCImportStatNodez5InterpretCompilerDirectives.visit_FromCImportStatNode  s   &,,,0F0FGZ0[0[,33+t':D<OQ Q Q$ 	)y((K,B,B:,N,N(++DHkBBB$t+QRR0IF&*&9 8 8"T7%,	!+i!7--ndhGG 8 AOD,W_==--i88 8<ED(D99";;;<ED(D9MM3g"67777MM3g"67777 t"(Dr*   c                    |j         }|j        j        }|dk    s|                    d          r`g }|j        D ]4\  }}|                    |j        |||j        k    rd n|j        f           5|                     |j        ||j	        |          S |dk    s|                    d          r| 
                    |j        j        |           |dz   dd          }g }|j        D ]v\  }}||z   }	d|	z   }
|                     |
|j                  r|
| j        |j        <   :|                     |	          r|	| j        |j        <   _|                    ||f           w|sd S ||_        |S )Nr  r  r  r  r  r  )r   r  rx   r  rK  r   rM   ry   r  levelr  r  r  r  r  )r%   r&   import_noder  r  ry   	name_noder  r  r  r  s              r'   visit_FromImportStatNodez4InterpretCompilerDirectives.visit_FromImportStatNode	  s   k!-3,,,0F0FGZ0[0[,N#': _ _i%%]D$).2H2H$$in]_ _ _ _33+{'8.J J JI%%)?)?
)K)K%++K,C,GUUU$t+QRR0IF#': 5 5i%,	!+i!7--ndhGG 5?MD,Y^<<--i88 5;DD(88MM4"34444 tDJr*   c                     |dk    s|                     d          r$t          |t          d          d                    }|rt          j        |||          S fd|D             S )Nr  r  )r  r  r  c           	      P    g | ]"\  }}}t          j        |||d k              #S )r   )r  r  is_absolute)r   CImportStatNode)r   rM   dotted_namer  r  s       r'   r   zKInterpretCompilerDirectives._create_cimport_from_import.<locals>.<listcomp>1  sS        .Cg % +# %
	, , ,  r*   )r  r   r   r   FromCImportStatNode)r%   node_posr  r  r  s      ` r'   r  z7InterpretCompilerDirectives._create_cimport_from_import%  s    ,,,0F0FGZ0[0[,'C8K4L4L4M4M(NOOK 	,k$-/ / / /    2@   r*   c                 B   t          |j        t          j                  rj|j        j        j        }|dk    r|                    d          s|S t          j        |j	        ||j
        j                  }|                     |          }n|                     |           |S )Nr  r  )r  r  )rO   r   r   
ImportNoder  rx   r  r   r   rM   r   ry   r  r9   r  s      r'   r   z6InterpretCompilerDirectives.visit_SingleAssignmentNode:  s    dh	 455 	%(.4Ki''0F0Fy0Q0Q'({TXT\TabbbD--d33DDt$$$r*   c                 "   |j         r|                     |d           |j        | j        v rd|_        n(| j                            |j                  }|||_        |                                dk    rt          j
        |j        d          S |S )N
annotationTr  rw   )r  
visitchildry   r  is_cython_moduler  r   cython_attributeas_cython_attributer   BoolNoderM   )r%   r&   r  s      r'   visit_NameNodez*InterpretCompilerDirectives.visit_NameNodeG  s    ? 	0OOD,///9000$(D!!,00;;I$(1%##%%33%dhd;;;;r*   c                     |                      |           |                                dk    rt          j        |j        d          S |S )Nr  Trw   )r9   r  r   r  rM   r$   s     r'   r  z/InterpretCompilerDirectives.visit_AttributeNodeU  sJ    4   ##%%33%dhd;;;;r*   c                 H    |j         r|                     |j                    |S r"   )rf   r  r$   s     r'   visit_AnnotationNodez0InterpretCompilerDirectives.visit_AnnotationNode\  s'     9 	"JJty!!!r*   c                 \    |                      |d           |                     |           |S Ncppclass)r  r9   r$   s     r'   visit_NewExprNodez-InterpretCompilerDirectives.visit_NewExprNodec  s/    j)))4   r*   c           	         t          |t          j                  rF|                     |d           |j                                        }|rt          j                            |          }|r|	                                \  }}g }g }||t          ur|j        D ]y}|\  }	}
|d|	j        }t          j                            |          r2|                    |                     ||
gd |j                             d|                    |           z|sd }n||_        |r|s|s|S |                    |                     ||||j        j                             |S nt          |t          j        t          j        f          r|                     |           |                                }|rt          j                            |          }|t&          u r:t          j        |j        d          }|                     ||gd |j                  gS ||t          j        u r|d fgS t-          |j        d|z            d S )Nfunctionr  Trw   z5The '%s' directive should be used as a function call.)rO   r   CallNoder  r  r  r   r  r   explicit_args_kwdsdictkey_value_pairsrx   r   try_to_parse_directiverM   AttributeNoder   r  boolr  DEFER_ANALYSIS_OF_ARGUMENTSrn   )r%   r&   optnamedirectivetyperz   kwdsr  r  keyvaluerL  rx   sub_optnamer   s                r'   try_to_parse_directivesz3InterpretCompilerDirectives.try_to_parse_directivesh  s    dI.// %	eOOD*---m7799G & ' 7 ; ;G D D  &!%!8!8!:!:JD$!#J&(O'M,E,E(,(< A AH)1JC5<WWcii*HK&6::;GG A * 1 1$2M2Mk\a[bdhjrjv2w2w x x x x / 6 6x @ @ @ @. C#'DD3BD0% .d .4 .#--%%d&A&A'4QUW[WdWh&i&ijjj%%y6	8JKLL 	eJJt..00G 	e ' 7 ; ;G D D D((#,TXTBBBC 77#dhWWXX"*mw?b.b.b$dO,,("Y\c"ce e etr*   c                    |dk    r| j         j        st          |d|z            |dk    rt          |          dk    }d}|rv|j        ro|j        d         }t          |j                  dk    rH|j        j        r<|j        j        dk    r,t          |j        t          j
                  r|j        j        }nd}|rt          |d          d|r|d         nd |ffS t          j                            |          }t          |          dk    r;t          |d         t          j                  r|t          j                    |         fS |t           u rW|3t          |          dk    s t          |d         t          j
                  st          |d	|z            ||d         j        fS |t"          u rd|3t          |          dk    s t          |d         t          j                  st          |d
|z            |t#          |d         j                  fS |t&          u rp|?t          |          dk    s,t          |d         t          j        t          j        f          st          |d|z            |t'          |d         j                  fS |t,          u r2|t          |          dk    rt          |d|z            ||d         fS |t.          u r<t          |          dk    rt          |d|z            ||                                fS |t2          u r;|r+t          |j                  dk    rt          |d|z            |d |D             fS t5          |          rz|?t          |          dk    s,t          |d         t          j        t          j        f          st          |d|z            | ||t'          |d         j                            fS |t          j        u r|||r|                                ni ffS J )N
np_pythranz.The %s directive can only be used in C++ mode.	exceptvalr   Tr   checkzYThe exceptval directive takes 0 or 1 positional arguments and the boolean keyword "check"8The %s directive takes one compile-time boolean argumentz8The %s directive takes one compile-time integer argumentz7The %s directive takes one compile-time string argumentz(The %s directive takes one type argumentz1The %s directive takes no prepositional argumentsz+The %s directive takes no keyword argumentsc                 6    g | ]}t          |j                  S r#   )strrx   )r   r   s     r'   r   zFInterpretCompilerDirectives.try_to_parse_directive.<locals>.<listcomp>  s     >>>c#)nn>>>r*   )rH   cpprn   r   r  rL  rg   rx   rO   r   r  r   r  r   NoneNoder  r  intIntNoder+  
StringNoder`  typer  as_python_dictr=  callabler  )	r%   r  rz   r!  rM   	arg_errorr(  kwr   s	            r'   r  z2InterpretCompilerDirectives.try_to_parse_directive  sm   l""4<+;" &VY`&`aaa##D		AIE %, %)!,,--220 357V\W5L5L"28Y-?@@ 6MHNEE $I v$tv v vT";$q''tU!CDD/33G<<t99>>ja)2DEE>G:<<WEEEd""3t99>>DGYM_9`9`>$SNQXXZ Z ZT!W]++c!!3t99>>DGYM^9_9_>$SNQXXZ Z ZSa//00c!!3t99>>Gi2I4IJ:L :L>$SMPWWY Y YSa//00d""3t99>>$S>HJ J JT!W%%d""4yyA~~$SG'QS S SD//1111d"" MD011Q66$SAGKM M M>>>>>>>m$$ 
	3t99>>Gi2I4IJ:L :L>$SMPWWY Y Y]]7CQ4F4FGGHHgAAAdT$ID$7$7$9$9$9rJKKLr*   c                 \   |s|rJ |                      |          S | j        }t          j        |fi |}|t          j        |fi |}n|}||k    r|                      |          S || _        |P||k    rJt	          j        |j        j        t	          j        |j        j        ||j                  g          |_        |                      |          }|| _        t          |t          j                  st	          j        |j        |g          }t	          j        |j        ||          S )N)r  rP   r   )rM   rP   r  )
r  r  r   copy_inherited_directivesr   rQ   rP   rM   CompilerDirectivesNoderO   )r%   r&   r  contents_directivesr  new_directivesnew_contents_directivesretbodys           r'   visit_with_directivesz1InterpretCompilerDirectives.visit_with_directives  si    	)****??4((( :>XXZXX*&-&G'7 '7"5'7 '7## '5#^++??4((((+'>99*	0	#:!Y( ( (  DI //$''('5#566 	D('CCCG+'nF F F 	Fr*   c                 b    |                      |d          \  }}|                     |||          S )Nr  _extract_directivesr=  r%   r&   r  r9  s       r'   r  z-InterpretCompilerDirectives.visit_FuncDefNode  6    *.*B*B4*T*T'
'))$
<OPPPr*   c                    |                      |d          \  }}|                                D ]G\  }}|dk    r||_        |dvr0| j                            t          |j        d|z                       H|                     ||d           S )Nr  locals)finalr  zXCdef functions can only take cython.locals(), staticmethod, or final decorators, got %s.r9  )r@  rK  directive_localsrH   r   rn   rM   r=  )r%   r&   r  r   ry   rx   s         r'   r,   z-InterpretCompilerDirectives.visit_CVarDefNode  s    00zBB
A%++-- 	J 	JKD%x(-%%666++NHACGH-I -I J J J ))$
PT)UUUr*   c                 b    |                      |d          \  }}|                     |||          S r{  r?  rA  s       r'   r}  z/InterpretCompilerDirectives.visit_CClassDefNode  s6    *.*B*B4*R*R'
'))$
<OPPPr*   c                 b    |                      |d          \  }}|                     |||          S r  r?  rA  s       r'   r:   z.InterpretCompilerDirectives.visit_CppClassNode  rB  r*   c                 b    |                      |d          \  }}|                     |||          S )Nclassr?  rA  s       r'   visit_PyClassDefNodez0InterpretCompilerDirectives.visit_PyClassDefNode  s6    *.*B*B4*Q*Q'
'))$
<OPPPr*   c           	         |j         si i fS g }g }g }t          | j                  }t                      }|j         ddd         D ]}}|                     |j                  }	|	H|	D ]B}
|                     |j        |
d         |          r|
\  }}|dv rh|d}n_|\  }}|s3t          |          dk    s t          |d         t          j                  st          |j        d|z            |d         j        }||f}
|                    ||          |k    r:|dk    rd	|v rt          |j        d
           |                    |
           |||<   n"t#          |j        d||d|z  ndd           |
d         dk    r|                    |           |
d         dk    r|dk    rd}Dh|                    |           |ddd         |ddd         z   |_         i }i }|D ]\  }}||v rd||         }t          |t                    r|                    |           n6t          |t&                    r|                    |           n|||<   n|||<   |t*          j        vr|||<   ||fS )z
        Returns two dicts - directives applied to this function/class
        and directives applied to its contents. They aren't always the
        same (since e.g. cfunc should not be applied to inner functions)
        Nr   r   )nogilwith_gilTr   r)  cfuncufuncz=Cannot apply @cfunc to @ufunc, please reverse the decorators.z*Directive does not change previous value (z=%rr_  )r  r   rK  )
decoratorsr  r  objectr$  	decoratorr  rM   r   rO   r   r  rn   rx   r   r   r   r   r  r=  r  r   immediate_decorator_directives)r%   r&   
scope_namer  realdecsbothcurrent_opt_dictmissingdecr:  r  ry   rx   rz   r!  optdictcontents_optdict	old_values                     r'   r@  z/InterpretCompilerDirectives._extract_directives  s     	r6M
00((?44R4( 	% 	%C!99#-HHN)!/ . .I11$(IaL*UU -&/e#888$}(,-2
d#' !E3t99>>DQRGU^UgAhAh>*8B|  @D  CD  +E  +E  %E(,Q)-uI+//g>>%GG#w7>N3N3N %cg/n o o o&--i8885:,T22#CGG $u7Heemmb&P&P.R S S S$Q<>99 KK,,, |x//J'4I4I%-
1.4 $$$$"44R4.4":5% 	/ 	/KD%w#DM	 i.. *$$U++++	400 *$$U++++$)GDMM %7AAA). &(((r*   c                    i }|                      |j                  pg D ]}||j        .| j                            t          |j        d                     ;|\  }}|dv r'd }t          |j        t          j	                  r~t          |j        j                  dk    rat          |j        j                  dk    r|j        j        d         }n| j                            t          |j        d|z                       nOt          |j        t          j                  r0| j                            t          |j        d|z                       t          j        |j        ||j        |          }|                     |          c S |                     |j        |d          r|||<   |r|                     |j        |d           S |                     |          S )	Nz6Compiler directive with statements cannot contain 'as')rN  gilr   r   z6Compiler directive %s accepts one positional argument.)staterP   	conditionzwith statementrF  )r$  managerr   rH   r   rn   rM   rO   r   SimpleCallNoder   rz   GeneralCallNoder   GILStatNoderP   r  r  r=  )r%   r&   directive_dictr  ry   rx   rc  s          r'   visit_WithStatNodez.InterpretCompilerDirectives.visit_WithStatNode]  s   55dlCCIr 	5 	5I$;*L//&tx1ijjl l l l #,KD%///$(	%dlI4LMM {RUVZVbVgRhRhklRlRl"4<#455::,0L,=a,@		 $ ; ;$248=ux|=|$}$}! ! ! !'i6OPP { L77 .tx9qtx9x y y{ { {$0DIajkkk#t4444411$(DBRSS 5/4t, 	c--di]a-bbbt$$$r*   ),r;   r<   r=   r>   r   
TypeofNodeAmpersandNodeDereferenceNodeinc_dec_constructor
TypeidNodeunop_method_nodesc_binop_constructorbinop_method_nodesr  r  r  r  rD   r  r  rR   r  r  r  r  r  r  r  r   r  r  r  r  r$  r  r=  r  r,   r}  r:   rL  r@  ri  rk   rl   s   @r'   r  r    s        : &%3 ) 9"?)"?d"K"K"?)"?d"K"K"?)"?t"L"L"?)"?t"L"L"+"6 *   	"?)"?"D"D  O
 ,---  ! ! !% % % % %	 	 	$ $ $N    3 3 3
  0$ $ $L  B  8  *          
* * *X@ @ @D$F $F $FPQ Q Q
V 
V 
VQ Q QQ Q QQ Q Q@) @) @)F% % % % % % %r*   r  c                        e Zd ZdZdZdZdZdZej	        e
j        ej        dZd Zd Zd Zd Zd	 Zd
 Zd Zd Z fdZ xZS )ParallelRangeTransforma  
    Transform cython.parallel stuff. The parallel_directives come from the
    module node, set there by InterpretCompilerDirectives.

        x = cython.parallel.threadavailable()   -> ParallelThreadAvailableNode
        with nogil, cython.parallel.parallel(): -> ParallelWithBlockNode
            print cython.parallel.threadid()    -> ParallelThreadIdNode
            for i in cython.parallel.prange(...):  -> ParallelRangeNode
                ...
    NF)zcython.parallel.parallelzcython.parallel.threadidzcython.parallel.prangec                 ,    |j         | j        v p|j        S r"   )ry   r  r	  r$   s     r'   node_is_parallel_directivez1ParallelRangeTransform.node_is_parallel_directive  s    yD44M8MMr*   c                    | j         rd                    | j                  }nT| j        | j        d                  }|dd                    | j        dd                   }|                    d          }| j                            |          }|0| j         r| j        d         dk    st          |j        d|z             d| _         d| _        |S )z
        Figure out which parallel directive was used and return the associated
        Node class.

        E.g. for a cython.parallel.prange() call we return ParallelRangeNode
        r  r   r   Nr  zInvalid directive: %sF)	namenode_is_cython_modulejoinparallel_directiver  rstripdirective_to_noder   r   rM   )r%   r&   r  r%  s       r'   get_directive_class_nodez/ParallelRangeTransform.get_directive_class_node  s     ) 	.!899II01H1KLI#,99#&88D,CABB,G#H#H#HJI!((--I$((33; >; $ 7 :j H H$(3i?@@@).&"&
r*   c                 V    |j         r!|j         | _         |                     |          S |S )zd
        If any parallel directives were imported, copy them over and visit
        the AST
        )r  r  r$   s     r'   rR   z'ParallelRangeTransform.visit_ModuleNode  s3    
 # 	)'+'?D$??4((( r*   c                 b    |                      |          r|j        g| _        |j        | _        |S r"   )ru  ry   ry  r	  rw  r$   s     r'   r  z%ParallelRangeTransform.visit_NameNode  s5    **400 	C'+ykD#-1-BD*r*   c                 |    |                      |           | j        r| j                            |j                   |S r"   )r9   ry  r   	attributer$   s     r'   r  z*ParallelRangeTransform.visit_AttributeNode  s?    4   " 	;#**4>:::r*   c                 4   |                      |d           | j        s|                     |d           |S t          |t          j                  r|j        j        }|j        }n	|j        }i }| 	                    |          }|r ||j
        ||          }|S )Nr  )r  r(  )rz   kwargs)r  ry  r9   rO   r   rf  positional_argsrz   keyword_argsr|  rM   )r%   r&   rz   r  parallel_directive_classs        r'   visit_CallNodez%ParallelRangeTransform.visit_CallNode  s    j)))& 	t];;;K
 dI566 	',D&FF9DF#'#@#@#F#F # 	P ,+DH4OOODr*   c                    |                      |j                  }t          |t          j                  rR| j        dk    rt          |j        j        d           d| _        |                     |d          }d| _        ||_	        |S | j
        r>|                     |          }|sdS |t          j        u rt          |j        d           dS |                     |d           |S )z.Rewrite with cython.parallel.parallel() blockszparallel withz*Nested parallel with blocks are disallowedrP   Nz%The parallel directive must be called)r  rd  rO   r   ParallelWithBlockNoderb  r   rM   r  rP   ry  r|  )r%   r&   newnoderP   r  s        r'   ri  z)ParallelRangeTransform.visit_WithStatNode  s    **T\**gu:;; 	z_,,dl&BD D D )DJ??400DDJGLN$ 		'+'D'DT'J'J$+ t'5+FFFdh GHHHtf%%%r*   c                    |                      |d           |                      |d           t          |j        j        t          j                  }| j        }|rr|j        j        }|j        |_        |j        |_        |j	        |_	        |}t          |j        t          j                  st          |j        j        d           d| _        |                      |d           || _        |                      |d           |S )z/Rewrite 'for i in cython.parallel.prange(...):'r   r   z+Can only iterate over an iteration variabler  rP   else_clause)r  rO   r   sequencer   ParallelRangeNoderb  r   rP   r  r   r   r   rM   )r%   r&   	in_prangeprevious_stateparallel_range_nodes        r'   r  z*ParallelRangeTransform.visit_ForInStatNode  s    j)))h'''t}5$68 8	 	" #'-"8)-&'+y$.2.>+&Ddk9+=>> EdkoCE E E "DJf%%%#
m,,,r*   c                 \    |(t          t          |                               |          S dS )zVisit a node that may be NoneN)rC   rs  r  ry  s     r'   r  zParallelRangeTransform.visit$  s0    /66<<TBBB r*   )r;   r<   r=   r>   ry  rw  in_context_manager_sectionrb  r   r  r   ParallelThreadIdNoder  r{  ru  r|  rR   r  r  r  ri  r  r  rk   rl   s   @r'   rs  rs  {  s       	 	  !& "' E &+%@%.%C#(#:	 N N N  2
 
 
      0  :  >C C C C C C C C Cr*   rs  c                   (    e Zd Zd Zd Zej        ZdS )WithTransformc                    |                      |d           |j        |j        }|j        |j        |j        }}}t          j        |          x}|_        t          j        t          j	        t          j
        |          t          |rdnd          d          g d          |_        |r t          j        |j                  |_        |-t          j        t          j        ||          |g	          }t          j        dfd
t%          d          D                       }t          j        t          j        t          j        t          j        t          j        |d||rt          j        d           nd                     t          j                            gd           d d |          }t          j        t          j        ||gd           t          j        t          j        |dt          j        fdt%          d          D                       |rt          j        d           nd                     d          |_        |S )NrP   
__aenter__	__enter__T)r  r  is_special_lookup)r  rz   is_temp)r   )r   	with_noder   c                 8    g | ]}t          j                  S r#   )r   ExcValueNoder   r   rM   s     r'   r   z4WithTransform.visit_WithStatNode.<locals>.<listcomp>C  s7     C; C; C;,-I"3''C; C; C;r*   r  )slowrz   F)	with_stattest_if_runrz   
await_exproperand)rc  rP   )
if_clausesr  )rP   patternr   excinfo_target)rP   except_clausesr  c                 8    g | ]}t          j                  S r#   )r   r-  r  s     r'   r   z4WithTransform.visit_WithStatNode.<locals>.<listcomp>c  s$    "M"M"Mq9#5c#:#:"M"M"Mr*   rz   rv   )rP   r   handle_error_case)r9   rM   is_asyncrP   r   rd  r   	ProxyNodere  r  	CloneNoder   
enter_callAwaitExprNoder   rQ   WithTargetAssignmentStatNode	TupleNoderJ  ExceptClauseNode
IfStatNodeIfClauseNodeNotNodeWithExitCallNodeReraiseStatNoder   TryExceptStatNoder   )	r%   r&   r  rP   r   rd  r  except_clauserM   s	           @r'   ri  z WithTransform.visit_WithStatNode+  s   4(((h= $	4;gf!*!4W!=!==$,#2)1,W55'(QkRR"&( ( (     	P'5ctOOODO%649 9 9  D #,St C; C; C; C;16qC; C; C; < < <.e&&y'8)C #t,1%3U]+g9+B3D+Q+Q+Q+Qcg	*i *i *i(j (j (j #2377  
! !" " " )!
 
 
& ,e-$ -   
 !-)44 $","M"M"M"ME!HH"M"M"MO O OIQ[y6sEEEEW[] ] ]^ ^ ^ $
 
 
	 r*   c                     |S r"   r#   r$   s     r'   rV   zWithTransform.visit_ExprNodei      r*   N)r;   r<   r=   ri  rV   r   r  r  r#   r*   r'   r  r  *  s7        < < <|   "5JJJr*   r  c                   0     e Zd Z fdZd Zd Zd Z xZS )#_GeneratorExpressionArgumentsMarkerc                 d    t          t          |                                            || _        d S r"   )rC   r  rD   gen_expr)r%   r  rI   s     r'   rD   z,_GeneratorExpressionArgumentsMarker.__init__r  s+    1488AACCC r*   c                 h    |j         s|j        rJ | j        |_        |                     |           d S r"   )r4  generator_arg_tagr  r9   r$   s     r'   rV   z2_GeneratorExpressionArgumentsMarker.visit_ExprNodev  s?     	3.///%)]D"4     r*   c                     d S r"   r#   r$   s     r'   r  z._GeneratorExpressionArgumentsMarker.visit_Node}  s	     	r*   c                     | j         |_        d S r"   )r  r  r$   s     r'   r   zA_GeneratorExpressionArgumentsMarker.visit_GeneratorExpressionNode  s    !%r*   )r;   r<   r=   rD   rV   r  r   rk   rl   s   @r'   r  r  p  se        ! ! ! ! !! ! !  
/ / / / / / /r*   r  c                   4    e Zd Zd Zd Zd Zd Zej        Z	dS )_HandleGeneratorArgumentsc                    ddl m} t          |t          j                  sJ || _        t          |j        j                  | _        t          |j	                  | _	        d| _
        i | _        |                     |           | j                                        D ]\  }}|                    |||           | j        |j        _        | j	        |_	        |S )Nr   )Visitorr   )r_  r  rO   r   GeneratorExpressionNodegen_noder=  r   rz   call_parameters	tag_countsubstitutionsr9   rK  recursively_replace_node)r%   r&   r  kvs        r'   rx  z"_HandleGeneratorArguments.__call__  s    $	 ABBBBB+,,	#D$8994   &,,.. 	9 	9DAq ,,T1a8888!Y#3r*   c                 4    |                      |d          }|S )NF)do_visit_children_handle_ExprNode)r%   r&   new_nodes      r'   r   z7_HandleGeneratorArguments.visit_GeneratorExpressionNode  s!    (((GG r*   c                    |j         /| j        '| j        |j         k    r|j        }| j        }| xj        dz  c_        t	          d                    |                    }| j        j        }|j                            |          sddl	m
} t	          t          j        |                    t          |                    z             }t          j        ||          }	|j        }
t%          j        |
d          }
|
|	_        t          j        ||	d d d           }|	j        |_        |
|_        | j                            |           d |_         | j                            |           |                    |j        |          |_        ||j        _        d|j        _        |r+| j        d c}| _        |                     |           || _        t=          j        ||d	          }| j        j        j         j        !                    |j                  |_        |j        j        |_        || j"        |<   |S |r|                     |           |S )
Nr   z.{0})SymtabrM   ry   F)remove_fakeref)rM   
declarator	base_typer   r  T)ry   initialized_check)#r  r  rM   r  r   formatr   local_scopelookup_herer_  r  r   genexpr_arg_prefixpunycodify_namer+  r   r   r1  r   remove_cv_refCArgDeclNodery   rz   r   r  declare_argumententrycname
in_closurer9   r   r   gbodylookupr  )r%   r&   r  rM   name_sourcery   r   r  r  	name_declr1  new_argr  r  s                 r'   r  z*_HandleGeneratorArguments._handle_ExprNode  sA   ".4=3L!777(C .KNNaNN {!;!;<<D}-H'33D99 0$$$$$$%f&?&BXBXY\]hYiYiBjBj&jkk!5#DIII	y "/UKKK!%	,:>Y]_ _ _(~#	  ))))-&$++D111 ( 9 9(:NPW X X&+#+/(  ) +/-'$-""4((( (
 "*3TUSSSI"m4:FMMin]]IO&_1IN'0Dt$ 	%t$$$r*   c                 .    |                      |d          S rT   r  r$   s     r'   rV   z(_HandleGeneratorArguments.visit_ExprNode  s    $$T4000r*   N)
r;   r<   r=   rx  r   r  rV   r   r  r  r#   r*   r'   r  r    sU          ,  ; ; ;z1 1 1 "5JJJr*   r  c                        e Zd ZdZdZ ed           ed           ed          dj        Z fdZd Z	d	 Z
d
 Zd Zed             Zd Zd Zed             Z xZS )DecoratorTransforma  
    Transforms method decorators in cdef classes into nested calls or properties.

    Python-style decorator properties are transformed into a PropertyNode
    with up to the three getter, setter and deleter DefNodes.
    The functional style isn't supported yet.
    N__get____set____del__)gettersetterdeleterc                     | j         g | _         | j                             i            t          t          |                               |          }| j                                          |S r"   )_propertiesr   rC   r  r}  popry  s     r'   r}  z&DecoratorTransform.visit_CClassDefNode  sc    #!D###'..BB4HHr*   c                     t          |j        d         t                    rdnd}t          |j        d|j        z  |           |S )Nr   r   z4'property %s:' syntax is deprecated, use '@property')rO   rM   r+  r   ry   )r%   r&   r  s      r'   visit_PropertyNodez%DecoratorTransform.visit_PropertyNode  sD    S118qPSWS\\^cdddr*   c                 p   |                      |          }|j        s|S | j        dk    s| j        j        dk    rlt          |j                  dk    r2|j        d         j        j        r|j        d         j        j        dk    s t          |j        d         j
        d           |S |}|                     |          }|rO|j        j        r.|                                }|r|                     |||          }nt          |j
        d           |j        r!|                     ||j        d                   S |S )Nr   r7   r   r   r  z0Cdef functions cannot take arbitrary decorators.z*C property decorator can only be @property)r  rS  r   r   r8   r   rU  r  ry   r   rM   _find_property_decoratordeclared_name_add_property_reject_decorated_property)r%   r&   ret_nodedecorator_nodery   s        r'   visit_CFuncDefNodez%DecoratorTransform.visit_CFuncDefNode
  sD   %%d++ 	K_((DO,F(,R,R ((A--$/!2D2N2V-OA&05GGdoa(,.`aaaK66t<< 	X'/ X))++ N#11$nMMHn(*VWWW? 	M2249KLLLr*   c                    | j         }|                     |          }|dk    s|j        s|S |                     |          }||j        }|j        r|                     ||j        |          S |                     |j	                  }|r|j
        j        |j        k    r,t          |j        d|j
        j        d|j        d           nEt          |j                  dk    r|                     ||          S |                     |||          S |j        D ]B}|j        }|j        r2|xj        |j        dk    z  c_        |xj        |j        dk    z  c_        C|j        }d |_        |                     |||j                  S )Nr   z&Mismatching property names, expected 'z', got 'r  r   r1  r  )r   r  rS  r  rU  r  r  ry   _map_property_attributer  r  r   rM   r   r  _add_to_propertyis_classmethodis_staticmethodchain_decorators)r%   r&   r   r  rU  handler_namefuncdecss           r'   visit_DefNodez DecoratorTransform.visit_DefNode$  s   _
%%d++!!!K 66t<<%&0I  Y))$	>JJJ#;;I<OPP 	Y })TY66n00"+-"4"4"4diiiAB B B B T_--11#>>t^TTT#44T<XXX  	D 	DI&D| D##tyM'AA##$$	^(CC$$ $$T4;;;r*   c                     | j         d         }|j        d d d         D ]8}|j        }|j        r|j        dk    r|c S |j        r|j        j        |v r|c S 9d S )Nr   property)r  rS  rU  r  ry   is_attributer  )r%   r&   
propertiesr  rU  s        r'   r  z+DecoratorTransform._find_property_decoratorJ  s    %b)
"oddd3 	& 	&N&0I  &Y^z%A%A%%%%' &IM,>*,L,L%%%%tr*   c                 P    | j         D ]}||k    rt          |j        d           | S )Nz=Property methods with additional decorators are not supported)rS  r   rM   )r&   r  decos      r'   r  z-DecoratorTransform._reject_decorated_propertyV  s;     O 	a 	aD~%%dh _```r*   c                    t          |j                  dk    r|                     ||          S |j                            |           | j        d         }t          |t          j                  }t          j        |j	        |g          }|rZ||v rt          |j	        d           d|j        vrt          |j	        d           t          j        |j	        |j        ||          }n||v r`||         }|j        rt          |j	        d           n9t          d          |_        |j	        |_	        |j        |_        |g|j        _        d S t          d          |_        t          j        |j	        ||j        |	          }|||<   |S )
Nr   r   r   C property redeclaredr  z+C property method must be declared 'inline')r}   ry   rP   r  )ry   r}   rP   )r   rS  r  remover  rO   r   r  rQ   rM   r   r  CPropertyNoder}   is_cpropertyr   ry   rP   rN   PropertyNode)r%   r&   ry   r  r  r  rP   props           r'   r  z DecoratorTransform._add_property^  s   t!##224HHH~...%b)
!$(:;;!$(4&999 	>z!!dh 7888t~--dh MNNN&txTXDtTTTDDZd#D  )dh 78888))44	88#'&	4%i00DI%t> > >D
4r*   c                 H   | j         d         }||j                 }|j        rt          |j        d           d S ||_        |j                            |           |j        j        }t          |          D ]\  }}|j        |k    r|||<    n|
                    |           d S )Nr   r  )r  ry   r  r   rM   rS  r  rP   rN   rI  r   )	r%   r&   ry   rU  r  r  rN   rN  stats	            r'   r  z#DecoratorTransform._add_to_property|  s    %b)
$)$ 	$(34444	y)))	 '' 	 	GAtyD  a ! LLtr*   c                 F   t          j        | j        |          }|ddd         D ]$}t          j        |j        |j        |g          }%t          j        | j        |          }t          j        | j        ||          }t          j        |g          }|| _        | |gS )af  
        Decorators are applied directly in DefNode and PyClassDefNode to avoid
        reassignments to the function/class name - except for cdef class methods.
        For those, the reassignment is required as methods are originally
        defined in the PyMethodDef struct.

        The IndirectionNode allows DefNode to override the decorator.
        r   Nr   r  rz   r   )	r   r   rM   re  rU  r   r   IndirectionNodedecorator_indirection)r&   rS  ry   decorator_resultrU  r  reassignments          r'   r  z#DecoratorTransform.chain_decorators  s     %-dhTBBB#DDbD) 	) 	)I(7",&' )  )  )
 &txd;;;	1H " " "
 ,l^<<%1"l##r*   )r;   r<   r=   r>   r  r   r   r  r}  r  r  r  r  r  r  r  r  r  rk   rl   s   @r'   r  r    s         K  -	**-	** =++  
	         4$< $< $<L
 
 
   \  <  " $ $ \$ $ $ $ $r*   r  c                   (    e Zd ZdZd ZeZeZeZeZdS )CnameDirectivesTransformz
    Only part of the CythonUtilityCode pipeline. Must be run before
    DecoratorTransform in case this is a decorator for a cdef class.
    It filters out @cname('my_cname') decorators and rewrites them to
    CnameDecoratorNodes.
    c                    t          |dd           s|                     |          S t          |j                  D ]\  }}|j        }t          |t          j                  r|j        j	        r|j        j
        dk    r|                                \  }}|rt          d          t          |          dk    rt          d          |d         j        r|d         j        t           j        k    st          d          |d                             d           }|j        |= t'          j        |j        ||          } n|                     |          S )	NrS  r  z/cname decorator does not take keyword argumentsr   z*cname decorator takes exactly one argumentr   z4argument to cname decorator must be a string literal)rM   r&   r  )getattrr  rI  rS  rU  rO   r   r  r  r  ry   r  r   r   r4  r1  r   str_typecompile_time_valuer   CnameDecoratorNoderM   )r%   r&   rN  rU  rz   r  r  s          r'   handle_functionz(CnameDirectivesTransform.handle_function  sy   t\400 	)??4(((%do66 	 	LAy!+I9i&899 &.&+w66(;;==f O(MO O O t99>>(HJ J J Q* TQ(888(RT T T Q22488OA&/DH46;= = =t$$$r*   N)	r;   r<   r=   r>   r)  r  r}  r2   r4   r#   r*   r'   r#  r#    sD         % % %B ()("1r*   r#  c                   B    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
S )ForwardDeclareTypesz
    Declare all global cdef names that we allow referencing in other places,
    before declaring everything (else) in source code order.
    c                 r    | j         }|j        }|j        |_        |                     |           ||_        |S r"   )r  r  r9   )r%   r&   envr|  s       r'   r  z0ForwardDeclareTypes.visit_CompilerDirectivesNode  s:    n4   r*   c                 j    |j         | _        |j        | j        _        |                     |           |S r"   )r  r  r  r9   r$   s     r'   rR   z$ForwardDeclareTypes.visit_ModuleNode  s2     J'+$4   r*   c                 x    | j         j        }d| j         _        |                     |           || j         _        |S Nr   )r  in_cincluder9   )r%   r&   old_cinclude_flags      r'   visit_CDefExternNodez(ForwardDeclareTypes.visit_CDefExternNode  s=     -9()%4   (9%r*   c                 :    |                     | j                   |S r"   )r  r  r$   s     r'   r2   z&ForwardDeclareTypes.visit_CEnumDefNode  s    T&'''r*   c                 `    |j         | j        j        vr|                    | j                   |S r"   )ry   r  entriesr  r$   s     r'   r4   z/ForwardDeclareTypes.visit_CStructOrUnionDefNode  s/    9D-555LL*+++r*   c                 @   |j         | j        j        vr|                    | j                   | j        j        |j                  j        }|R|j        rK|j        sD|j        r=|j        }|j        D ].}|j        r%|j        j	        r|j        
                                 /|S r"   )
class_namer  r6  r  r1  is_extension_typeis_builtin_typer  cfunc_entriesis_fused"get_all_specialized_function_types)r%   r&   r1  r  r  s        r'   r}  z'ForwardDeclareTypes.visit_CClassDefNode  s    ?$"3";;;LL*+++ (9> 6t?SX\XbJE, D D: D%*"5 DJAACCCr*   c                     |S r"   r#   r$   s     r'   r  z%ForwardDeclareTypes.visit_FuncDefNode  r  r*   c                     |S r"   r#   r$   s     r'   rL  z(ForwardDeclareTypes.visit_PyClassDefNode  r  r*   N)r;   r<   r=   r>   r  rR   r3  r2   r4   r}  r  rL  r#   r*   r'   r+  r+    s         
          

 
 
      r*   r+  c                       e Zd Z edd ed          g          Z edd ed          g          Z edd ed          g          Z ed ed          g          Z ed	 ed          g          Z	dZ
d
Z f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 f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( xZ)S )(AnalyseDeclarationsTransformzr
property NAME:
    def __get__(self):
        return ATTR
    def __set__(self, value):
        ATTR = value
    c_classNr  pipelinez
property NAME:
    def __get__(self):
        return ATTR
    def __set__(self, value):
        ATTR = value
    def __del__(self):
        ATTR = None
    z?
property NAME:
    def __get__(self):
        return ATTR
    a  
cdef class NAME:
    cdef TYPE value
    def __init__(self, MEMBER=None):
        cdef int count
        count = 0
        INIT_ASSIGNMENTS
        if IS_UNION and count > 1:
            raise ValueError, "At most one union member should be specified."
    def __str__(self):
        return STR_FORMAT % MEMBER_TUPLE
    def __repr__(self):
        return REPR_FORMAT % MEMBER_TUPLE
    )rD  z;
if VALUE is not None:
    ATTR = VALUE
    count += 1
    r   c                     g | _         t                      | _        t          t          |           }|j        | _        |                    |          S r"   )seen_vars_stackr  fused_error_funcsrC   rA  r  _super_visit_FuncDefNoderx  )r%   rootsuper_classrI   s      r'   rx  z%AnalyseDeclarationsTransform.__call__A  sF    !!$8$??(3(E%##D)))r*   c                 P    | j         d                             |j                   |S Nr   )rF  r5  ry   r$   s     r'   r  z+AnalyseDeclarationsTransform.visit_NameNodeI  s%    R $$TY///r*   c                 R   g | _         | j                            t                                 |                    |                                            |                     |           | j                                         |j        j	        
                    | j                    |S r"   )extra_module_declarationsrF  r   r  analyse_declarationscurrent_envr9   r  rP   rN   r  r$   s     r'   rR   z-AnalyseDeclarationsTransform.visit_ModuleNodeM  s    )+&##CEE***!!$"2"2"4"45554     """	t=>>>r*   c                     | xj         dz  c_         |                    |                                            |                     |           | xj         dz  c_         |S r0  )	in_lambdarO  rP  r9   r$   s     r'   r   z-AnalyseDeclarationsTransform.visit_LambdaNodeW  s[    !!!$"2"2"4"45554   !r*   c                    |                      |          }|j        r1d|j        j        v r#ddlm}  |||j        j        d         |            |j        r|j        j        r|j        rg }|j        j        D ]b}|j        rY| 	                    |          }|
                    |j                   |                     |           |                    |           c|r|j        xj        |z  c_        |j        dk    rI|j                            d          s/|j                            d          s|                     |           |S )Ndataclasses.dataclassr   )handle_cclass_dataclassr7   
__reduce____reduce_ex__)visit_ClassDefNoder  r  	DataclassrU  implementedrP   var_entriesneeds_propertycreate_PropertyrO  r  r   rN   r8   r  _inject_pickle_methods)r%   r&   rU  rN   r  r  s         r'   r}  z0AnalyseDeclarationsTransform.visit_CClassDefNode^  sf   &&t,,: 	`1TZ5JJJ::::::##D$**?@W*XZ^___: 	2$*0 	2TY 	2E/ + +' +#33E::H11$*===JJx(((LL*** )	5(8++ J--l;; , J--o>> , ++D111r*   c                    |                                  |j        j        d         du rd S |j        j        d         du }g }|j        j        }d }d }||                    d |j        j        D                        |p|j                            d          }|p3|j                            d          p|j                            d          }|j        }||	                    d 	           |rd S fd
|D             }d |D             }|s|s|r|s|rd}	nG|r#dd
                    d |D                       z  }	n"dd
                    d |D                       z  }	|rt          |j        |	           t          dd|	iz  dt          d           g                              i           }
|
                    |j                   |                     |
           |j        j                            |
           d S |D ]B}|j        j        s4|j                                       |j                                       Cd |D             }t1          |          }d|j        z  }t          d|dd
                    |          z  d
                    |          |j        d
                    d t7          |          D                       t9          |          dz  dt          d           g                              i           }|                    |j        j                   |                     |           | j                            |           t          d||d          d
                    d! |D                       t9          |          d"k    rdnd#z   d$
                    d% |D             pd&g          d'z  dt          d           g                              i           }
|
                    |j                   |                     ||j                   |                     |
           |                                  |j        j                            |
           d S )(Nauto_pickleFTc              3   ,   K   | ]}|j         d v|V  dS ))__weakref____dict__Nr   r   r   s     r'   	<genexpr>zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>  s/      mmQ16QlClClqClClClClmmr*   	__cinit__rV  rW  c                     | j         S r"   r   )r   s    r'   <lambda>zEAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<lambda>  s    qv r*   )rL  c                     g | ]D}|j         j        |j                                       r|j                                       B|ES r#   )r1  is_pyobjectcan_coerce_to_pyobjectcan_coerce_from_pyobject)r   r   r-  s     r'   r   zGAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<listcomp>  sg     
 
 
6%
/0v/L/LS/Q/Q
 34&2Q2QRU2V2V

 
 
r*   c                 *    g | ]}|j         j        |S r#   )r1  is_struct_or_unionrd  s     r'   r   zGAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<listcomp>  s"    GGGQV-FG1GGGr*   z2no default __reduce__ due to non-trivial __cinit__z6%s cannot be converted to a Python object for picklingr  c              3   *   K   | ]}d |j         z  V  dS zself.%sNr   rd  s     r'   re  zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>  s-      Y}Y}qrZcfgflZlY}Y}Y}Y}Y}Y}r*   zZPickling of struct members such as %s must be explicitly requested with @auto_pickle(True)c              3   *   K   | ]}d |j         z  V  dS rp  r   rd  s     r'   re  zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>  s*      ;`;`STI<N;`;`;`;`;`;`r*   z
                def __reduce_cython__(self):
                    raise TypeError, "%(msg)s"
                def __setstate_cython__(self, __pyx_state):
                    raise TypeError, "%(msg)s"
                msgrB  rC  c                     g | ]	}|j         
S r#   r   rd  s     r'   r   zGAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<listcomp>  s     = = =A = = =r*   z__pyx_unpickle_%sa  
                def %(unpickle_func_name)s(__pyx_type, long __pyx_checksum, __pyx_state):
                    cdef object __pyx_PickleError
                    cdef object __pyx_result
                    if __pyx_checksum not in %(checksums)s:
                        from pickle import PickleError as __pyx_PickleError
                        raise __pyx_PickleError, "Incompatible checksums (0x%%x vs %(checksums)s = (%(members)s))" %% __pyx_checksum
                    __pyx_result = %(class_name)s.__new__(__pyx_type)
                    if __pyx_state is not None:
                        %(unpickle_func_name)s__set_state(<%(class_name)s> __pyx_result, __pyx_state)
                    return __pyx_result

                cdef %(unpickle_func_name)s__set_state(%(class_name)s __pyx_result, tuple __pyx_state):
                    %(assignments)s
                    if len(__pyx_state) > %(num_members)d and hasattr(__pyx_result, '__dict__'):
                        __pyx_result.__dict__.update(__pyx_state[%(num_members)d])
                z(%s)z, z; c              3   .   K   | ]\  }}d |d|dV  dS )z__pyx_result.z = __pyx_state[]Nr#   )r   ixr  s      r'   re  zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>  sS       -C -C!B @Aqq"""E-C -C -C -C -C -Cr*   )unpickle_func_name	checksumsmembersr8  assignmentsnum_membersr   ap  
                def __reduce_cython__(self):
                    cdef tuple state
                    cdef object _dict
                    cdef bint use_setstate
                    state = (%(members)s)
                    _dict = getattr(self, '__dict__', None)
                    if _dict is not None:
                        state += (_dict,)
                        use_setstate = True
                    else:
                        use_setstate = %(any_notnone_members)s
                    if use_setstate:
                        return %(unpickle_func_name)s, (type(self), %(checksum)s, None), state
                    else:
                        return %(unpickle_func_name)s, (type(self), %(checksum)s, state)

                def __setstate_cython__(self, __pyx_state):
                    %(unpickle_func_name)s__set_state(self, __pyx_state)
                r   c              3       K   | ]	}d |z  V  
dS rp  r#   )r   r  s     r'   re  zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>  s&      (R(R1Q(R(R(R(R(R(Rr*   r   r_  z or c                 :    g | ]}|j         j        d |j        z  S )zself.%s is not None)r1  rj  ry   rd  s     r'   r   zGAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<listcomp>  sH      9D  9D  9D\]pqpv  qC  9D9NQRQW9W  9D  9D  9Dr*   False)rw  checksumry  any_notnone_members) rP  r  r  r  r1  r  r[  r  r  sortrx  r   rM   r   r@   
substituterO  r  rP   rN   r   rj  create_to_py_utility_codecreate_from_py_utility_code_calculate_pickle_checksumspunycode_class_namer8  rI  r   rN  enter_scope
exit_scope)r%   r&   auto_pickle_forcedall_membersr%  cinitinherited_reducenon_pystructsrr  pickle_funcr   all_members_namesrx  rw  unpickle_funcr-  s                   @r'   r^  z3AnalyseDeclarationsTransform._inject_pickle_methodss  su     : /588F!Z2=ATIjoomm#)*?mmmmmm:SY--k::E/v393C3CL3Q3QvUXU^UeUefuUvUv-C	 o
 	--... 	 F
 
 
 
"
 
 
 HGkGGG e	0F e	0w e	0/A e	0 
bJ bNQTQYQYY}Y}v|Y}Y}Y}Q}Q}}
13688;`;`X_;`;`;`3`3`a " %dh$$$& (
 cl(#  =+>+>*?A A A BLB  ,,TZ888JJ{###IO"";///// ! < <v) <F44S999F66s;;; = = = = =34EFFI!4t7O!O ) *" +=!'$))I*>*>!>#yy):;;"&/#'99 -C -C%./@%A%A-C -C -C $C $C $''8#9#9	 	!*2 "]4-@-@,A3C C C2 DN:b>>3 4 ..tz/?@@@JJ}%%%*11-@@@& (( += )!#yy(R(R@Q(R(R(RRR]`ar]s]swx]x]xVYVY  A   B,2KK  9D  9Dal  9D  9D  9D  9Q  IP  HQ  -R  -R '(4  =+>+>*?5A A A4 BLB5 6 ,,TZ888T4:...JJ{###OOIO"";/////r*   c                 J   g }|D ]H}|j         }|j        r#|j        dvs|                    |j                  r|                    |           I|rSt          | j                  }|j        }|                    |||j                  \  }	}
|
	                    |           ||
g}|S )zd
        Create function calls to the decorators and reassignments to
        the function.
        )r  r1  )
rU  r  ry   r  r   r  rH   r&   r  rO  )r%   old_decoratorsr-  r&   rS  rU  r
  	transformr   r   reassignmentss              r'   _handle_fused_def_decoratorsz9AnalyseDeclarationsTransform._handle_fused_def_decorators  s     
' 	- 	-I&DL -I%DDDOODI.. E !!),,, 	)*4<88IyH(99*hm 5  5A}..s333-(Dr*   c                    |j                             d|j                   |                     |d           |                    |           d|j        j        j        _        t          j	        
                    |j        d          }t          j        |                    |                    }||_        |                     |j        t          j        |          |          |_        |r|                     |||          }|S )z#Handle def or cpdef fused functionsr   py_funcFT)binding)rN   insertr  r  update_fused_defnode_entryr  	signatureuse_fastcallr   PyCFunctionNodefrom_defnoder  coerce_to_tempresulting_fused_function_create_assignmentr  fused_func_assignmentr  )r%   rS  r-  r&   pycfuncs        r'   _handle_defz(AnalyseDeclarationsTransform._handle_def	  s     	
!T\***i((('',,,49$1+88t8TT%g&<&<S&A&ABB(/%%)%<%<L)-g66&= &="  	L44ZdKKDr*   c                 p   ddl m} | j        s| j        r| j        | j        vr2| j        rt          |j        d           nt          |j        d           | j                            | j                   t          j	        |j                  |_
        |j        D ]2}|j        j        r$|j                                        d         |_        3|S t          |dd          }|                    ||          }|| _        |                     |           d| _        |j        r|                     |||          }|S )z:Create a fused function for a DefNode with fused argumentsr   )	FusedNodezFused lambdas not allowedzCannot nest fused functionsr   rS  N)r_  r  fused_functionrR  rG  r   rM   r5  r   PassStatNoderP   rz   r1  r<  get_fused_typesr%  FusedCFuncDefNoder9   r  r  )r%   r-  r&   r  r   rS  s         r'   _create_fused_functionz3AnalyseDeclarationsTransform._create_fused_function(	  sI    	$. 	"$*@@@> C$($?@@@@$($ABBB"&&t':;;;*4844DIy = =8$ ="x7799!<CHKT<66
**455"4   "< 	;##JT::Dr*   c                     |j         r[|j        rTd|_        t          |j        d           t	          j        |j        g t	          j        |j                            |_        |j        S )NFzFused generators not supported)rN   rP   )is_generatorhas_fused_argumentsr   rM   r   rQ   r  r  r$   s     r'   _handle_fusedz*AnalyseDeclarationsTransform._handle_fusedF	  sr     	O!9 	O',D$$(<===+DH24161CDH1M1MO O ODJ ''r*   c                 0   |                                  }| j                            t                                 |j        }|                    |           |j                                        D ]\  }}|                    |          ss|	                    |          }|r(|j
        r!|j        r|                    |j                  }|r|                    |||j                   xt          |j        d           |                     |          r|                     ||          }n/|j                            |           |                     |           | j                                         d|j        v rddlm} |                    |          S |S )a  
        Analyse a function and its body, as that hasn't happened yet.  Also
        analyse the directive_locals set by @cython.locals().

        Then, if we are a function with fused arguments, replace the function
        (after it has declared itself in the symbol table!) with a
        FusedCFuncDefNode, and analyse its children (which are in turn normal
        functions). If we're a normal function, just analyse the body of the
        function.
        
Not a typerQ  r   )UFuncs)rP  rF  r   r  r  declare_argumentsrG  rK  r  analyse_as_typer<  fused_to_specific
specializedeclare_varrM   r   r  r  rP   rO  rH  r  r  r_  r  convert_to_ufunc)r%   r&   r-  lenvvar	type_noder1  r  s           r'   r  z.AnalyseDeclarationsTransform.visit_FuncDefNodeP	  s      ##CEE***t$$$ #399;; 	7 	7NC##C(( 7 0066 CDM Cd.D C??4+ABBD 7$$S$	>>>>)-666d## 	0..sD99DDI**4000))$///  """do%%      **4000r*   c                    |                      |          }|                                 }t          |t          j                  r#|j        s|j        s|                    |          s|S ||                     ||          gS r"   )	r  rP  rO   r   r   fused_py_funcis_generator_bodyneeds_assignment_synthesis_synthesize_assignmentr%   r&   r-  s      r'   r  z*AnalyseDeclarationsTransform.visit_DefNodey	  s    %%d++  4// 	"	&*&<	33C88	 Kd11$<<==r*   c                 ,    |                      |          S r"   )r  r$   s     r'   visit_GeneratorBodyDefNodez7AnalyseDeclarationsTransform.visit_GeneratorBodyDefNode	  s    %%d+++r*   c                    |}|j         s|j        r|j        }|j         |j        |j        rAt	          j        |j        ||j        j        t	          j	        |                    x}|_
        n^| j                            d          }t          j                            ||          }|j        |_        |j        r|j        |j        _        |j         rd|_        |j        |_        |                     |||          S )N)r   pymethdef_cnamecode_objectr  T)is_py_class_scopeis_c_class_scopeouter_scopeis_closure_scoper   InnerFunctionNoderM   r  r  CodeObjectNodepy_cfunc_nodecurrent_directivesr   r  r  r  r  r  r  is_cyfunctionr  )r%   r&   r-  genvr   r  s         r'   r  z3AnalyseDeclarationsTransform._synthesize_assignment	  s   $ 	$(= 	$#D $ 	$(= 	$   
	:'0'B4 $
 :%4T::(< (< (< <C$$$
 -11)<<G+88wGGC"D  :)-)9
&  	CK [&&tS#666r*   c                 *   |j         r<|j         d d d         D ]$}t          j        |j        |j        |g          }%d |_         t          j        |j        t          j        |j        |j                  |          }|	                    |           |S )Nr   r  r   r   )
rS  r   re  rM   rU  r   r   r   ry   rO  )r%   r   r   r-  rU  assmts         r'   r  z/AnalyseDeclarationsTransform._create_assignment	  s     	'%026 " "	.M(25" " " #'H*L"8<hmDDD   	""3'''r*   c                     | j                                         }t          t          |                               |           | j                             |           d S r"   )rF  r  rC   rA  visit_func_outer_attrsr   )r%   r&   stackrI   s      r'   r  z3AnalyseDeclarationsTransform.visit_func_outer_attrs	  sS    $((***D11HHNNN##E*****r*   c                    |                                  }|                    |           |j        r| j                            t          | j        d                              |                     ||j                   |                    |j                   |                     |           | 	                                 | j        
                                 n*|                    |           |                     |           |S rL  )rP  rO  
expr_scoperF  r   r  r  analyse_scoped_declarationsr9   r  r  r  s      r'   visit_ScopedExprNodez1AnalyseDeclarationsTransform.visit_ScopedExprNode	  s      !!#&&&? 
	% ''D,@,D(E(EFFFT4?333,,T_===t$$$OO $$&&&& ,,S111t$$$r*   c                 ~    |                      |           |                    |                                            |S r"   r9   rO  rP  r$   s     r'   visit_TempResultFromStatNodez9AnalyseDeclarationsTransform.visit_TempResultFromStatNode	  ;    4   !!$"2"2"4"4555r*   c                 F    |j         dk    rd S |                     |          S r6   )r8   rX  r$   s     r'   r:   z/AnalyseDeclarationsTransform.visit_CppClassNode	  s(    ?h&&4**4000r*   c                     	 d S r"   )*r   r  rM   r   r   r  r1  r  r[  r   ry   rb  init_assignmentr  r   struct_or_union_wrapperr   rQ   r  	is_structr  r0  replacerN   r8  shadowrP   rO   r  CSimpleBaseTypeNoder   rz   kw_onlyr   r  r  rj  basic_pyobject_propertybasic_propertyrO  rP  r}  )r%   r&   
self_valuer[  
attributesr  init_assignmentsattr
str_formatwrapper_class
class_bodyinit_methodarg_templater   templater  s                   r'   r4   z8AnalyseDeclarationsTransform.visit_CStructOrUnionDefNode	  s    	4r*   c                 0    |                      |           |S r"   r  r$   s     r'   r.   z2AnalyseDeclarationsTransform.visit_CDeclaratorNode
  s    4   r*   c                     |S r"   r#   r$   s     r'   r(   z/AnalyseDeclarationsTransform.visit_CTypeDefNode"
  r)   r*   c                     d S r"   r#   r$   s     r'   r0   z0AnalyseDeclarationsTransform.visit_CBaseTypeNode%
  s    tr*   c                      |j         dk    r|S d S )Npublic)r8   r$   s     r'   r2   z/AnalyseDeclarationsTransform.visit_CEnumDefNode(
  s    ?h&&K4r*   c                    |j         | j        d         v rb|                                                     |j                   }||j        dk    r)|j        j        st          |j        d|j         z             | 	                    |           |S )Nr   r7   z,cdef variable '%s' declared after it is used)
ry   rF  rP  r  r8   r  r  r   rM   r9   )r%   r&   r  s      r'   visit_CNameDeclaratorNodez6AnalyseDeclarationsTransform.visit_CNameDeclaratorNode.
  s    9,R000$$&&--di88E!1X!=!=!K8 ">dh NQUQZ Z[[[4   r*   c                 0    |                      |           d S r"   r  r$   s     r'   r,   z.AnalyseDeclarationsTransform.visit_CVarDefNode7
  s    4   tr*   c                     |                      |d          }|sd S t          |          t          u r|d         |_        |g|dd          z   S |S )Nr&   r   r   )r  r1  r=  r&   )r%   r&   
child_nodes      r'   visit_CnameDecoratorNodez5AnalyseDeclarationsTransform.visit_CnameDecoratorNode<
  sZ    __T622
 	4
t##"1DI6JqrrN**r*   c           
      j   |j         dk    r|j        j        r| j        }n| j        }n|j         dk    r| j        }|                    dt          j        |j	        t          j
        |j	        d          |j                  i|j	                  j        d         }|j        |_        |j        |_        |S )	Nr  readonlyATTRr%   r  )rM   r  r  )rM   r   )r8   r1  rj  r  r  basic_property_ror  r   r  rM   r   ry   rN   r}   )r%   r  r  r  s       r'   r]  z,AnalyseDeclarationsTransform.create_PropertyE
  s    x''z% /7.++-H&&0UY5>5GEI\b5c5c5c;@:G G G( 9	 '   $A	'
 
yr*   c                 ~    |                      |           |                    |                                            |S r"   r  r$   s     r'   r+  z;AnalyseDeclarationsTransform.visit_AssignmentExpressionNodeV
  r  r*   )*r;   r<   r=   r   r@   r  r  r  r  r  r  rR  rx  r  rR   r   r}  r^  r  r  r  r  r  r  r  r  r  r  r  r  r:   r4   r.   r(   r0   r2   r  r,   r  r]  r+  rk   rl   s   @r'   rA  rA    s       !\ # MM$$7$7#8: : :N +l , MM$$7$7#8: : : % & MM$$7$7#8	: : : +l , !=&&') ) ) #l $ !=&&'	) ) )O NI* * * * *        *E0 E0 E0N  4  (  <( ( (' ' 'R> > >, , ,7 7 70   + + + + +  "  
1 1 1H7 H7 H7\  
          
    "      r*   rA  c                 b   d                     |                               d          }t          j        dk    rddini }g }dD ]k}	 t	          t
          |          } ||fi |                                }n# t          t          f$ r Y Gw xY w|	                    d|d d         z              l|S )	N zutf-8)r  	   usedforsecurityF)sha256sha1md50xr  )
rx  encoder   version_infor%  r   	hexdigestAttributeError
ValueErrorr   )member_namesmember_names_stringhash_kwargsrx  	algo_name
mkchecksumr  s          r'   r  r  \
  s     ((<0077@@030@F0J0J$e,,PRKI. . .		 )44J!z"5EEEEOOQQHH
+ 	 	 	H	 	!,----s   0A77B
Bc                   h     e Zd ZdZdZdZ fdZddZd Zd Z	d Z
d	 Zd
 Zd Zd Zd Zd Z xZS ) CalculateQualifiedNamesTransformz^
    Calculate and store the '__qualname__' and the global
    module name on some nodes.
    Fc                     |                                  j        | _        g | _        t          t          |           }|j        | _        |j        | _        | 	                    |           |S r"   )
global_scoper  r  rC   r  r  rH  rX  _super_visit_ClassDefNoder9   )r%   r&   _superrI   s      r'   rR   z1CalculateQualifiedNamesTransform.visit_ModuleNodev
  sa    ,,..= 7>>(.(@%)/)B&4   r*   Nc                     |r%| j         d d          }|                    |           n| j         }t          d                    |                    |_        | j        |_        d S )Nr  )r  r   r   rx  qualnamer  )r%   r&   ry   r  s       r'   _set_qualnamez.CalculateQualifiedNamesTransform._set_qualname
  sd     	+*111-HOOD!!!!*H%chhx&8&899+r*   c                 ~    |j         r|j        s|j        g| _        d S | j                            |j                   d S r"   )is_pyglobalis_pyclass_attrry   r  r   )r%   r  s     r'   _append_entryz.CalculateQualifiedNamesTransform._append_entry
  sH     	3U%: 	3#(:,D&&uz22222r*   c                 f    |                      ||j                   |                     |           |S r"   )r  ry   r9   r$   s     r'   visit_ClassNodez0CalculateQualifiedNamesTransform.visit_ClassNode
  s3    4+++4   r*   c                 Z    |                      |           |                     |           |S r"   )r  r9   r$   s     r'   visit_PyClassNamespaceNodez;CalculateQualifiedNamesTransform.visit_PyClassNamespaceNode
  s/    4   4   r*   c                 B   | j         d d          }|j        j        rG| j         r@| j         d         dk    r/| j                                          |                     |           n |                     ||j        j                   |                     |           || _         |S Nr   <locals>)r  r   
is_wrapperr  r  ry   r9   r%   r&   orig_qualified_names      r'   visit_PyCFunctionNodez6CalculateQualifiedNamesTransform.visit_PyCFunctionNode
  s    "1!!!4=# 	9(; 	9@STV@W[e@e@e##%%%t$$$$tT]%78884   1r*   c                 v   |j         r| j        rz| j        d         dk    sJ | j                    | j        d d          }| j                                         |                     |           |                     |           || _        n0|                     ||j                   |                     |           |S r(  )r*  r  r  r  rH  ry   r  r+  s      r'   r  z.CalculateQualifiedNamesTransform.visit_DefNode
  s    ? 		)t2 		)&r*j888$:M888"&"5aaa"8##%%%t$$$))$///"5DtTY///""4(((r*   c                 $   | j         d d          }t          |dd           dk    r| j                             d           n|                     |j                   | j                             d           |                     |           || _         |S )Nry   z<lambda>r)  )r  r%  r   r"  r  rH  r+  s      r'   r  z2CalculateQualifiedNamesTransform.visit_FuncDefNode
  s    "1!!!44&&*44&&z2222tz***"":...%%d+++1r*   c                    |j                             |          }t          j        |j        t          |          |          }t          j        |j        |                                |          }|j        j	        
                    dt          j        |j        ||                              |                                                      d S )Nry   r  )rx   unicode_valuer   r   )r  r  r   r   rM   r   r0  as_utf8_stringrP   rN   r  r   r   analyse_expressionsrP  )r%   r&   ry   rx   r  r   r   s          r'   generate_assignmentz4CalculateQualifiedNamesTransform.generate_assignment
  s    
&&t,, H &&   "H&&((! ! ! 		q%"<H#
 #
 #
 
d..00
1
1		3 	3 	3 	3 	3r*   c           	      D   | j         }d| _         | j        }d| _        | j        d d          }t          |dd           p0|                                                     |j        j                  }|                     |           | 	                    |           | j         r<| 
                    |dt          d                    | j                                       | j        r)| 
                    |dt          | j                             || _        || _         || _        |S )NFr  r=   r  r<   )needs_qualname_assignmentneeds_module_assignmentr  r%  rP  r  r   ry   r"  r  r5  r   rx  r  )r%   r&   orig_needs_qualname_assignmentorig_needs_module_assignmentr,  r  s         r'   rX  z3CalculateQualifiedNamesTransform.visit_ClassDefNode
  s5   )-)G&).&'+'C$',$"1!!!4w-- B!!##//0@AA 	5!!!&&t,,,) 	S$$T>%2388D<O3P3P%Q%QS S S' 	F$$T<%243C%D%DF F F1)G&'C$r*   c                     |                                  }|j        r%|j        dk    rd| _        n|j        dk    rd| _        |S )Nr=   Tr<   )rP  r  ry   r7  r8  )r%   r&   r  s      r'   r  z/CalculateQualifiedNamesTransform.visit_NameNode
  sR      ""! 		4 yN**15..l**/3,r*   r"   )r;   r<   r=   r>   r7  r8  rR   r  r"  r$  r&  r-  r  r  r5  rX  r  rk   rl   s   @r'   r  r  n
  s          !&#    , , , ,3 3 3  
  	 	 	  	 	 	3 3 3   *      r*   r  c                   &    e Zd Zd Zd Zd Zd ZdS )AnalyseExpressionsTransformc                     |j                                          |j                            |j                   |_        |                     |           |S r"   )r  infer_typesrP   r4  r9   r$   s     r'   rR   z,AnalyseExpressionsTransform.visit_ModuleNode
  sH    
   I11$*==	4   r*   c                     |j                                          |j                            |j                   |_        |                     |           |S r"   )r  r?  rP   r4  r9   r$   s     r'   r  z-AnalyseExpressionsTransform.visit_FuncDefNode
  sJ    $$&&&I11$2BCC	4   r*   c                     |j         r3|j                                         |                    |j                  }|                     |           |S r"   )r   r  r?  analyse_scoped_expressionsr9   r$   s     r'   r  z0AnalyseExpressionsTransform.visit_ScopedExprNode
  sP     	DO'')))224?CCD4   r*   c                 d    |                      |           |j        r|j        j        s|j        }|S )a  
        Replace index nodes used to specialize cdef functions with fused
        argument types with the Attribute- or NameNode referring to the
        function. We then need to copy over the specialization properties to
        the attribute or name node.

        Because the indexing might be a Python indexing operation on a fused
        function, or (usually) a Cython indexing operation, we need to
        re-analyse the types.
        )r  is_fused_indexr1  is_errorr   r$   s     r'   visit_IndexNodez+AnalyseExpressionsTransform.visit_IndexNode  s9     	 	ty'9 	9Dr*   N)r;   r<   r=   rR   r  r  rF  r#   r*   r'   r=  r=  
  sP                  r*   r=  c                       e Zd Zd Zd ZdS )FindInvalidUseOfFusedTypesc                     |j         s>|j        s"|j        j        rt	          |j        d           n|                     |           |S )Nz-Return type is not specified as argument type)r  r  return_typer<  r   rM   r9   r$   s     r'   r  z,FindInvalidUseOfFusedTypes.visit_FuncDefNode  sV     ' 	)) )d.>.G )dh OPPPP""4(((r*   c                     |j         r"|j         j        rt          |j        d           n|                     |           |S )Nz6Invalid use of fused types, type cannot be specialized)r1  r<  r   rM   r9   r$   s     r'   rV   z)FindInvalidUseOfFusedTypes.visit_ExprNode#  sG    9 	%+ 	%$(TUUUUt$$$r*   N)r;   r<   r=   r  rV   r#   r*   r'   rH  rH    s2        	 	 	    r*   rH  c                       e Zd Zd Zd ZdS )ExpandInplaceOperatorsc                   	 |j         }|j        }|j        j        r|S t	          |t
          j                  r|S |                                 }d	fd			  	|d          \  }}n# t          $ r |cY S w xY w |j	        di |j
        }t          j        |j        |j        ||d          }|                    |          }|                    |           |                    |           t#          j        |j        ||                    |j        |                    }|                                 |D ]}t+          ||          }|S )	NFc                    | j         r| g fS | j        j        r|st          |           } | | gfS | j        rI | j                  \  }}t          | j                  }t          j        | j	        ||          ||gz   fS | j
        r6 | j                  \  }}t          j        | j	        || j                  |fS t          | t          j                  rt!          d          t          |           } | | gfS )N)r   index)r  r  z@Don't allow things like attributes of buffer indexing operations)r  r1  rj  r   is_subscriptr   rP  r   	IndexNoderM   r  r  r  r  rO   BufferIndexNoder  )r&   settingr   tempsrP  r  side_effect_free_references         r'   rV  zVExpandInplaceOperators.visit_InPlaceAssignmentNode.<locals>.side_effect_free_reference9  s   | $Rx& $w $!$''dV|#" $88CCe"4:.. *48$eLLLeW\V]o]]" $77AA
U .txSDN[[[]bbbD)";<< $ !cddd!$''dV|#r*   T)rT  )r  operand1operand2inplacer   rj   r#   )r   r   r1  is_cpp_classrO   r   rS  rP  r  rI   rc  
binop_noderM   r  analyse_target_typesanalyse_typesanalyse_operationr   r   	coerce_toreverser
   )
r%   r&   r   r   r-  let_ref_nodesdupbinoptrV  s
            @r'   visit_InPlaceAssignmentNodez2ExpandInplaceOperators.visit_InPlaceAssignmentNode.  s   hh8  	Kc9455 	K  	$ 	$ 	$ 	$ 	$ 	$$	!;!;C!N!N!NC 	 	 	KKK	cm++cl++$TX040303-1	3 3 3 &&s++#$$$)H#..0 0 0
 	 	$ 	$A1d##DDs   A& &A54A5c                     |S r"   r#   r$   s     r'   rV   z%ExpandInplaceOperators.visit_ExprNodec  r  r*   N)r;   r<   r=   re  rV   r#   r*   r'   rM  rM  ,  s3        3 3 3j    r*   rM  c                   :    e Zd ZdZdZd Zd Zd Zd Zd Z	d Z
d	S )
AdjustDefByDirectivesz
    Adjust function and class definitions by the decorator directives:

    @cython.cfunc
    @cython.cclass
    @cython.ccall
    @cython.inline
    @cython.nogil
    )r   total_orderingrT  c                 V    |j         | _         d| _        |                     |           |S rB   )r  in_py_classr9   r$   s     r'   rR   z&AdjustDefByDirectives.visit_ModuleNodeu  s,    / 4   r*   c                 d    | j         }|j         | _         |                     |           || _         |S r"   r  r  s      r'   r  z2AdjustDefByDirectives.visit_CompilerDirectivesNode{  s2    /4   (r*   c           	         g }d| j         v r|                    d           | j                             d          }| j                             d          }| j                             d          }|dnd}| j                             d          }|| j         d         r|j        }||d	}n
|d |rdndf}d
| j         v red| j         v rt	          |j        d           |rt	          |j        d           |                    d|||||          }|                     |          S d| j         v rN| j        rt	          |j        d           n1|                    d||||||          }|                     |          S d|v rt	          |j        d           |rt	          |j        d           |rt	          |j        d           | 	                    |           |S )Nr  rN  rO  r'  FTreturnsannotation_typingrT   ccallrP  z-cfunc and ccall directives cannot be combinedz-ccall functions cannot be declared 'with_gil')overridabler  rN  rn  
except_valhas_explicit_exc_clausez#cfunc directive is not allowed here)rq  r  rN  rO  rn  rr  rs  z,Python functions cannot be declared 'inline'z+Python functions cannot be declared 'nogil'z.Python functions cannot be declared 'with_gil')
r  r   r   return_type_annotationr   rM   as_cfunctionr  rk  r9   )r%   r&   r  rN  rO  rr  rs  return_type_nodes           r'   r  z#AdjustDefByDirectives.visit_DefNode  s:   	t&&X&&&##G,,?&&z22_((55
+5+=%%4?..y99#8K(L##:+
0B)
(8 CeDJdo%%$/))dh OPPP Qdh OPPP$$ IU(ZYp % r rD ::d###do%% (dh EFFFF(( %%RZ,]t ) v v zz$'''y  $(JKKK 	K$(IJJJ 	N$(LMMM4   r*   c                     |S r"   r#   r$   s     r'   r   z&AdjustDefByDirectives.visit_LambdaNode  r  r*   c                      t           fd j        D                       r)|                                }                     |          S  j        }d _                             |           | _        |S )Nc              3   *   K   | ]}|j         v V  d S r"   )r  )r   r  r%   s     r'   re  z=AdjustDefByDirectives.visit_PyClassDefNode.<locals>.<genexpr>  s*      UU	yDO+UUUUUUr*   T)anyconverts_to_cclass	as_cclassr  rk  r9   r%   r&   old_in_pyclasss   `  r'   rL  z*AdjustDefByDirectives.visit_PyClassDefNode  s}    UUUUT=TUUUUU 	>>##D::d###!-N#Dt$$$-DKr*   c                 Z    | j         }d| _         |                     |           || _         |S rB   )rk  r9   r}  s      r'   r}  z)AdjustDefByDirectives.visit_CClassDefNode  s3    ) 4   )r*   N)r;   r<   r=   r>   r{  rR   r  r  r   rL  r}  r#   r*   r'   rh  rh  h  s          O    * * *X  	 	 	    r*   rh  c                   2    e Zd ZdZd Zd ZddZd Zd ZdS )	AlignFunctionDefinitionszq
    This class takes the signatures from a .pxd file and applies them to
    the def methods in a .py file.
    c                 H    |j         | _         |                     |           |S r"   )r  r9   r$   s     r'   rR   z)AlignFunctionDefinitions.visit_ModuleNode  s$    Z
4   r*   c                 B   | j                             |j                  }|r}|j        r(|                     |                                |          S |j         r|j         j        s;t          |j        d|j        z             |j        rt          |j        d           d S |S Nz'%s' redeclaredzprevious declaration here)	r  r  ry   	is_cclassr}  r|  is_builtin_scoper   rM   r%   r&   pxd_defs      r'   rL  z-AlignFunctionDefinitions.visit_PyClassDefNode  s    *##DI.. 	  //0@0@'JJJ] '-*H dh 1DI =>>>; D'+'BCCCtr*   Nc                     || j                             |j                  }|r!|j        s|S | j         }|j        j         | _         |                     |           |r|| _         |S r"   r  r  r8  defined_in_pxdr1  r9   r%   r&   r  r  s       r'   r}  z,AlignFunctionDefinitions.visit_CClassDefNode  q    ?j''88G 	,) *K +DJ4    	%$DJr*   c                    | j                             |j                  }|rj|j         r|j         j        sW|j        s;t          |j        d|j        z             |j        rt          |j        d           d S |                    |          }|S r  )r  r  ry   r  is_cfunctionr   rM   ru  r  s      r'   r  z&AlignFunctionDefinitions.visit_DefNode  s    *##DI.. 	.GM 	.1O 	.' dh 1DI =>>>; D'+'BCCCt$$W--D r*   c                     |S r"   r#   r$   s     r'   rV   z'AlignFunctionDefinitions.visit_ExprNode  r  r*   r"   )	r;   r<   r=   r>   rR   rL  r}  r  rV   r#   r*   r'   r  r    sn         
  

 
 
         r*   r  c                   .    e Zd Zd Zd ZddZd Zd ZdS )AutoCpdefFunctionDefinitionsc                     |j         | _         t                      | _        |j        | _        |                     |           |S r"   )r  r  r  r  r9   r$   s     r'   rR   z-AutoCpdefFunctionDefinitions.visit_ModuleNode  s9    /!eeZ
4   r*   c                     | j         j        rJ| j        d         r=|j        | j        vr/|                                r|                    | j                   }|S )N
auto_cpdef)r  )r  is_module_scoper  ry   r  is_cdef_func_compatibleru  r$   s     r'   r  z*AutoCpdefFunctionDefinitions.visit_DefNode  s`    J& 	74?<+H 	7IT%8880022 9 $$4:$66Dr*   Nc                     || j                             |j                  }|r!|j        s|S | j         }|j        j         | _         |                     |           |r|| _         |S r"   r  r  s       r'   r}  z0AutoCpdefFunctionDefinitions.visit_CClassDefNode  r  r*   c                 l    | j         j        r'|j        D ]\  }}| j                            |            |S r"   )r  r  rK  r  r5  )r%   r&   ry   r   s       r'   r  z5AutoCpdefFunctionDefinitions.visit_FromImportStatNode  sE     :% 	.: . .a#''----r*   c                     |S r"   r#   r$   s     r'   rV   z+AutoCpdefFunctionDefinitions.visit_ExprNode"  r  r*   r"   )r;   r<   r=   rR   r  r}  r  rV   r#   r*   r'   r  r    sd                     r*   r  c                   ,    e Zd Zd Zd Zd Zd Zd ZdS )RemoveUnreachableCodec                 X   | j         d         s|S |                     |           t          |j        d          D ]o\  }}|j        rc|t          |j                  k     rB| j         d         r!t          |j        |         j        dd           |j        d |         |_        d|_         np|S )Nremove_unreachabler   warn.unreachableUnreachable coder   T)r  r9   rI  rN   is_terminatorr   r   rM   )r%   r&   idxr  s       r'   r\   z(RemoveUnreachableCode.visit_StatListNode(  s    &';< 	K4   "4:q11 	 	IC! TZ((./AB L
3 35GKKK!%DSD!1DJ%)" r*   c                 V    |                      |           |j        j        rd|_        |S rT   )r9   rP   r  r$   s     r'   visit_IfClauseNodez(RemoveUnreachableCode.visit_IfClauseNode6  s0    4   9" 	&!%Dr*   c                     |                      |           |j        r&|j        j        r|j        D ]}|j        s nd|_        |S rT   )r9   r  r  r  )r%   r&   clauses      r'   visit_IfStatNodez&RemoveUnreachableCode.visit_IfStatNode<  sc    4    	* 0 > 	*/ * *+ E &*"r*   c                     |                      |           |j        j        r6|j        r/| j        d         rt          |j        j        dd           d |_        |S )Nr  r  r   )r9   rP   r  r  r  r   rM   r$   s     r'   visit_TryExceptStatNodez-RemoveUnreachableCode.visit_TryExceptStatNodeF  se    4   9" 	$t'7 	$&'9: E(,.@!DDD#Dr*   c                 V    |                      |           |j        j        rd|_        |S rT   )r9   r   r  r$   s     r'   visit_TryFinallyStatNodez.RemoveUnreachableCode.visit_TryFinallyStatNodeN  s1    4   , 	&!%Dr*   N)r;   r<   r=   r\   r  r  r  r  r#   r*   r'   r  r  '  s_                    r*   r  c                   d     e Zd Zg f fd	Zd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd Zd Z xZS )r~   c                     t          t          |                                            g | _        g | _        g | _        g | _        d| _        d| _        d| _	        || _
        d S rB   )rC   r~   rD   yieldsrn  finallysexceptshas_return_valuer   r   excludes)r%   r  rI   s     r'   rD   zYieldNodeCollector.__init__W  s]     $''00222 % r*   c                 F    || j         vr|                     |           d S d S r"   )r  r9   r$   s     r'   r  zYieldNodeCollector.visit_Nodeb  s1    t}$$t$$$$$ %$r*   c                 r    | j                             |           d| _        |                     |           d S rT   )r  r   r   r9   r$   s     r'   visit_YieldExprNodez&YieldNodeCollector.visit_YieldExprNodef  9    4   4     r*   c                 r    | j                             |           d| _        |                     |           d S rT   )r  r   r   r9   r$   s     r'   visit_AwaitExprNodez&YieldNodeCollector.visit_AwaitExprNodek  r  r*   c                     |                      |           |j        rd| _        | j                            |           d S rT   )r9   rx   r  rn  r   r$   s     r'   visit_ReturnStatNodez'YieldNodeCollector.visit_ReturnStatNodep  sD    4   : 	)$(D!D!!!!!r*   c                 d    |                      |           | j                            |           d S r"   )r9   r  r   r$   s     r'   r  z+YieldNodeCollector.visit_TryFinallyStatNodev  s2    4   T"""""r*   c                 d    |                      |           | j                            |           d S r"   )r9   r  r   r$   s     r'   r  z*YieldNodeCollector.visit_TryExceptStatNodez  s2    4   D!!!!!r*   c                     d S r"   r#   r$   s     r'   rX  z%YieldNodeCollector.visit_ClassDefNode~  r
  r*   c                     d S r"   r#   r$   s     r'   r  z$YieldNodeCollector.visit_FuncDefNode  r
  r*   c                     d S r"   r#   r$   s     r'   r   z#YieldNodeCollector.visit_LambdaNode  r
  r*   c                     t          |j        t          j                  r!|                     |j        j                   d S d S r"   )rO   r   r   _ForInStatNoder  r   r$   s     r'   r   z0YieldNodeCollector.visit_GeneratorExpressionNode  sB    di!566 	+ JJty)*****	+ 	+r*   c                     d S r"   r#   r$   s     r'   visit_CArgDeclNodez%YieldNodeCollector.visit_CArgDeclNode  s	     	r*   )r;   r<   r=   rD   r  r  r  r  r  r  rX  r  r   r   r  rk   rl   s   @r'   r~   r~   U  s         " 	! 	! 	! 	! 	! 	!% % %! ! !
! ! !
" " "# # #" " "      + + +      r*   r~   c                   2    e Zd Zd Zd Zd Zd Zd Zd ZdS )MarkClosureVisitorc                 L    d| _         g | _        |                     |           |S rB   )needs_closurer  r9   r$   s     r'   rR   z#MarkClosureVisitor.visit_ModuleNode  s*    "4   r*   c                    d| _         |                     |           | j         |_         d| _         t          | j                  }|                    |           |j        rSt
          j        }|j        r&t
          j        }|j	        |j
        z   D ]	}d|_        
nl| j        d         rt
          j        }nR|j        r5t          d |j	        D                       }t!          |j        d           |S |j        rt
          j        }n|S t'          |j	        d          D ]\  }}||_        |j
        |j        z   |j        z   D ]	}d|_        
t          j        |j        |j        |j        |j        o|j                  } ||j        |j        |j        |j        |j        |j        |j        ||j         |j!        |j"                  }	|	S )	NFTiterable_coroutinec              3   (   K   | ]}|j         	|V  d S r"   )is_await)r   ys     r'   re  z7MarkClosureVisitor.visit_FuncDefNode.<locals>.<genexpr>  s)      CCq
CCCCCCCr*   z/'await' not allowed in generators (use 'yield')r   )rM   ry   rP   is_async_gen_body)rM   ry   rz   r{   r|   r}   rS  r  lambda_namert  r   )#r  r9   r~   r  r   r   AsyncDefNoder   AsyncGenNoder  rn  in_async_genr  IterableAsyncDefNoder   nextr   rM   GeneratorDefNoderI  	label_numr  r  in_generatorGeneratorBodyDefNodery   rP   rz   r{   r|   r}   rS  r  rt  r   )
r%   r&   r   coroutine_type
yield_exprfoundrN  retnoder  	coroutines
             r'   r  z$MarkClosureVisitor.visit_FuncDefNode  s   "4   !/!&t}55	%%% 	"/N" <!&!3"+"2Y5F"F 3 3J.2J++3()=> <!&!;  	CCI$4CCCCCE%)NOOOK  	"3NNK&y'7;; 	% 	%MAz#$J   (9+==	@QQ 	( 	(G#'G  *tyty"/GI4GI I I #Ntyty]1BT_T%5#'#>$($@B B B	 r*   c                     d| _         |                     |           | j         |_         d| _         |j         r|j        rt          |j        d           |S )NFTz1closures inside cpdef functions not yet supported)r  r9   rq  r   rM   r$   s     r'   r  z%MarkClosureVisitor.visit_CFuncDefNode  s`    "4   !/! 	Q$"2 	Q$(OPPPr*   c                 d    d| _         |                     |           | j         |_         d| _         |S )NFT)r  r9   r$   s     r'   r   z#MarkClosureVisitor.visit_LambdaNode  s6    "4   !/!r*   c                 >    |                      |           d| _        |S rT   )r9   r  r$   s     r'   rX  z%MarkClosureVisitor.visit_ClassDefNode  s#    4   !r*   c                 h   | j         }t          |j        t          j                  r|j        j        g| _         |                     |          }|| _         t          |j        t          j                  s|S |j        j        j        }|j        r|S t          |          
                    |           |S r"   )r  rO   r   r   r  r   r   r  r4  r  r  )r%   r&   r  itseqs       r'   r   z0MarkClosureVisitor.visit_GeneratorExpressionNode  s    =di!566 	1!Y/0DM$$T** $)U%9:: 	 K	"+ 	K+D1177>>>r*   N)	r;   r<   r=   rR   r  r  r   rX  r   r#   r*   r'   r  r    so          ) ) )V      
    r*   r  c                   P     e Zd Z fdZd Zd ZddZd Zd Zd Z	d	 Z
d
 Z xZS )CreateClosureClassesc                 t    t          t          |                               |           g | _        d| _        d S rB   )rC   r  rD   pathrR  rG   s     r'   rD   zCreateClosureClasses.__init__  s4    "D))227;;;	r*   c                 H    |j         | _        |                     |           |S r"   )r  r  r9   r$   s     r'   rR   z%CreateClosureClasses.visit_ModuleNode  s%     J4   r*   c                    g }g }|j                                         D ]a}|j                                        D ]E\  }}|s|j        r|                    ||f           '|j        r|                    ||f           Fb||fS r"   )r  iter_local_scopesr6  rK  from_closurer   r  )r%   r&   r  r  r  ry   r  s          r'   find_entries_used_in_closuresz2CreateClosureClasses.find_entries_used_in_closures  s    
%7799 	5 	5E$}2244 5 5e % 5 ''u6666% 5%%tUm4445 Z''r*   Nc                    |j         rT|j                                        D ]:}|j                                        D ]}|j        s|j        s|j        sd|_        ;| 	                    |          \  }}|
                                 d|_        d|_        |j        }|j        j        }	|	j        s|	j        r|	j        }	|	j        |	j        |s6| j        s|r-|s|j        st)          d          |j        }d|_        d|_        |j         rn$|s|sd S |sd|_        |	j        |_        d|_        d S |                    t2          j                  d|j        j                            dd          }
t;          |
          }
|                    |
|j        dd          }d|j         _!        ||_        |j         j        }d|_"        d|_#        |j$        s|j         r
d|j%        d<   tL          j'        rtL          j'        |j%        d	<   |rM|	j(        sJ |)                    |j        t2          j*        t2          j*        |	j        j         d
           d|_        |D ]J\  }}|)                    |j        |j+        s|j,        nd |j        |j         d
          }|j-        rd|_-        Kd|_        |.                    |j                   d S )NTFz%DefNode does not have assignment noder   r  __)ry   rM   definingimplementingno_gc_clearfreelist)rM   ry   r  r1  is_cdefr   )/r  r  r  r6  r  r  r   
is_cglobalr  r  r  r  needs_outer_scoper  r  r  r  r  r  r  r   needs_closure_codeis_passthroughscope_classnext_idr   closure_class_prefixr  r  r   declare_c_classrM   r1  is_final_typeis_internalis_closure_class_scoper   r  r   closure_freelist_sizer  r  outer_scope_cnamein_subscopery   is_declared_genericcheck_c_class)r%   r&   target_module_scope
inner_noder  r  r  r  
func_scopecscoper  class_scopery   closure_entrys                 r'   create_class_from_scopez,CreateClosureClasses.create_class_from_scope  sZ    	0);;== 0 0"]1133 0 0E!. 0%2C 0uGW 0+/(0 $(#E#Ed#K#K j #!&%
!& 	(&*A 	('F & 	(&*A 	(  	+ 	+j 	+ 0) Q'(OPPP!/
,1J)%*D" 	 	L 	F 	(,J%%+%7J"%)D"F  ''(CDDDDJ$$S...0  ((#33dh 4   $(
 !&
j&"&-1* 	9 1 	948K"=1( 	O181NK":. 	*****##)/)A*0*B)/);)@,0	 $ 2 2 2
 &*D"% 	6 	6KD%'33I','8BUZZdkZ 4  M ( 6451!))**@AAAAAr*   c                     t          |j        t          j                  s|S | j        }d| _        |                     |j        | j        |           |                     |           || _        |S rT   )rO   r   r   r   rR  r  r  r9   )r%   r&   was_in_lambdas      r'   r   z%CreateClosureClasses.visit_LambdaNode]  sh    $-77 	K$$T]D4EtLLL4   &r*   c                 $   | j         r|                     |           |S |j        s| j        rc|                     || j                   | j                            |           |                     |           | j                                         |S r"   )rR  r9   r  r  r  r  r   r  r$   s     r'   r  z&CreateClosureClasses.visit_FuncDefNodei  s    > 	t$$$K 	 	((t/@AAAIT"""t$$$IMMOOOr*   c                 0    |                      |           |S r"   r  r$   s     r'   r  z/CreateClosureClasses.visit_GeneratorBodyDefNodet      4   r*   c                 h    |j         s|                     |          S |                     |           |S r"   )rq  r  r9   r$   s     r'   r  z'CreateClosureClasses.visit_CFuncDefNodex  s:     	))$///t$$$Kr*   c                 Z     t                      |          }|                     |          S r"   )r  r   r$   s     r'   r   z2CreateClosureClasses.visit_GeneratorExpressionNode  s,    *(**400$$T***r*   r"   )r;   r<   r=   rD   rR   r  r  r   r  r  r  r   rk   rl   s   @r'   r  r    s            
  
( ( (PB PB PB PBd
 
 
	 	 	    + + + + + + +r*   r  c                   J    e Zd ZdZdZd ZeZeZd Zd Z	d Z
d Zej        ZdS )	InjectGilHandlinga
  
    Allow certain Python operations inside of nogil blocks by implicitly acquiring the GIL.

    Must run before the AnalyseDeclarationsTransform to make sure the GILStatNodes get
    set up, parallel sections know that the GIL is acquired inside of them, etc.
    Fc                 L    | j         rt          j        |j        d|          }|S )zYAllow the (Python statement) node in nogil sections by wrapping it in a 'with gil' block.ra  rb  rP   )rN  r   rg  rM   r$   s     r'   _inject_gil_in_nogilz&InjectGilHandling._inject_gil_in_nogil  s+    : 	G$TXUFFFDr*   c                 l    | j         }|j        dk    | _         |                     |           || _         |S )NrN  )rN  rb  r9   r%   r&   	was_nogils      r'   visit_GILStatNodez#InjectGilHandling.visit_GILStatNode  s7    J	jG+
4   
r*   c                     | j         }t          |j        t          j                  r|j        j         o|j        j         | _         |                     |           || _         |S r"   )rN  rO   r  r   CFuncDeclaratorNoderO  r9   r  s      r'   r  z$InjectGilHandling.visit_CFuncDefNode  sZ    J	dou'@AA 	P.Ot7O3ODJ4   
r*   c                 d    | j         }|j         | _         |                     |           || _         |S r"   )rN  r9   r  s      r'   visit_ParallelRangeNodez)InjectGilHandling.visit_ParallelRangeNode  s2    J	Z
4   
r*   c                     |S r"   r#   r$   s     r'   rV   z InjectGilHandling.visit_ExprNode  r  r*   N)r;   r<   r=   r>   rN  r  visit_RaiseStatNodevisit_PrintStatNoder  r  r  rV   r   r  r  r#   r*   r'   r  r    s          E   /.         "5JJJr*   r  c                   R     e Zd ZdZ fdZd Zd Zd Zd Zd Z	d Z
d	 Zd
 Z xZS )GilChecka,  
    Call `node.gil_check(env)` on each node to make sure we hold the
    GIL when we need it.  Raise an error when on Python operations
    inside a `nogil` environment.

    Additionally, raise exceptions for closely nested with gil or with nogil
    statements. The latter would abort Python.
    c                     |j         g| _        d| _        d| _        d| _        t          t          |                               |          S rB   )r  	env_stackrN  nogil_declarator_only$current_gilstat_node_knows_gil_staterC   r!  rx  )r%   rI  rI   s     r'   rx  zGilCheck.__call__  sE    *
 &+"491Xt$$--d333r*   c                     | j         }|j        }|rEt          | j                  dk    r-| j        d         j         | _         |                     ||           || _         |                     |d |           || _         d S )Nr   r   )rN  outer_attrsr   r#  r9   )r%   r&   	gil_stater  r(  s        r'   _visit_scoped_childrenzGilCheck._visit_scoped_children  s    J	& 	23t~..22+1DJt[111
4t[AAA


r*   c                 .   | j                             |j                   |j        j        }| j        }|rd| _        |r!|j        r|                    |j                   |                     ||           || _        | j                                          |S rT   )r#  r   r  rN  r$  nogil_checkr*  r  )r%   r&   inner_nogilr$  s       r'   r  zGilCheck.visit_FuncDefNode  s    d.///&, $ : 	.)-D& 	/4+ 	/T-...##D+666 &;"r*   c                 B   |j         $t          |j         j        d|j        z             |S | j        r|j        r|                                 | j        }|j        dk    }||k    r4| j        s-|st          |j        d           nt          |j        d           | j        rd|_        t          |j	        t          j                  r|j	        j        \  |_	        | j        }d| _        | j        }|j        | _        |                     ||           || _        || _        |S )Nz<Non-constant condition in a `with %s(<condition>)` statementrN  z3Trying to acquire the GIL while it is already held.z;Trying to release the GIL while it was previously released.F)rc  r   rM   rb  rN  r,  r$  scope_gil_state_knownrO   r   r   rQ   rN   r%  r*  )r%   r&   r  is_nogilr$  r%  s         r'   r  zGilCheck.visit_GILStatNode  s\   >%$.$57;zBC C C K: 	$* 	J	J')  )C  8dh !0 1 1 1 1 dh !7 8 8 8% 	/).D&d)5+=>> 	= $(#6#< D $ :%*"/3/X,484N1##D(333%:"4X1r*   c                 h   |j         s| j        rP|j         dc}|_         t          j        |j        d|          }|s| j        rd|_        |                     |          S | j         st          |j        d           d S |                    | j	        d                    | 
                    |           |S )NFrN  r  z)prange() can only be used without the GILr   )rN  r$  r   rg  rM   r/  r  r   r,  r#  r9   )r%   r&   node_was_nogils      r'   r  z GilCheck.visit_ParallelRangeNode  s    : 	03 	0)-U&NDJ$TXW4HHHD! 3d&@ 3 .3*))$///z 	$(GHHH4+,,,4   r*   c                 8   | j         st          |j        d           d S | j        r8t	          j        |j        d|          }d|_        |                     |          S |j        r |                    | j	        d                    | 
                    |           |S )Nz5The parallel section may only be used without the GILrN  r  Fr   )rN  r   rM   r$  r   rg  r/  r  r,  r#  r9   r$   s     r'   visit_ParallelWithBlockNodez$GilCheck.visit_ParallelWithBlockNode&  s    z 	$( & ' ' '4% 	0 $TXW4HHHD).D&))$/// 	1 T^B/0004   r*   c                     | j         rt          |t          j                  r|                     |          S d|_        d|_        |                     |           |S )zM
        Take care of try/finally statements in nogil code sections.
        NT)rN  rO   r   rg  r  r,  is_try_finally_in_nogilr9   r$   s     r'   r  z!GilCheck.visit_TryFinallyStatNode:  s]     z 	)Ze.?@@ 	)??4((('+$4   r*   c                 L    | j         sd|_        |                     |           |S rB   )r%  r/  r9   r$   s     r'   visit_GILExitNodezGilCheck.visit_GILExitNodeF  s.    8 	/).D&4   r*   c                     | j         r.| j        r'|j        r |                    | j         d                    |j        r|                     || j                   n|                     |           | j        rd|_        |S )Nr   T)r#  rN  r,  r(  r*  r9   in_nogil_contextr$   s     r'   r  zGilCheck.visit_NodeL  s    > 	1dj 	1T-= 	1T^B/000 	%''dj9999t$$$: 	)$(D!r*   )r;   r<   r=   r>   rx  r*  r  r  r  r4  r  r8  r  rk   rl   s   @r'   r!  r!    s         	4 	4 	4 	4 	4	 	 	  (# # #J  &  (
 
 
  	 	 	 	 	 	 	r*   r!  c                       e Zd ZdZd Zd ZdS )CoerceCppTempsa  
    For temporary expression that are implemented using std::optional it's necessary the temps are
    assigned using `__pyx_t_x = value;` but accessed using `something = (*__pyx_t_x)`. This transform
    inserts a coercion node to take care of this, and runs absolutely last (once nothing else can be
    inserted into the tree)

    TODO: a possible alternative would be to split ExprNode.result() into ExprNode.rhs_rhs() and ExprNode.lhs_rhs()???
    c                 b    |                                  j        r|                     |           |S r"   )rP  r,  r9   r$   s     r'   rR   zCoerceCppTemps.visit_ModuleNodea  s2    ! 	%t$$$r*   c                     |                      |           |                                 j        d         r3|j        r,|j        j        r |j        j        st          j        |          }|S )N
cpp_locals)	r9   rP  r  r  r1  rZ  is_fake_referencer   CppOptionalTempCoercionr$   s     r'   rV   zCoerceCppTemps.visit_ExprNodeg  so    4   ),7 	;	;!%!7	; I/	; 4T::Dr*   N)r;   r<   r=   r>   rR   rV   r#   r*   r'   r<  r<  X  s<               r*   r<  c                   Z    e 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S )TransformBuiltinMethodszQ
    Replace Cython's own cython.* builtins by the corresponding tree nodes.
    c                 B    |j         rd S |                     |           |S r"   )declaration_onlyr9   r$   s     r'   r   z2TransformBuiltinMethods.visit_SingleAssignmentNodew  s+      	4t$$$Kr*   c                 V    |                      |           |                     |          S r"   )r9   visit_cython_attributer$   s     r'   r  z+TransformBuiltinMethods.visit_AttributeNode~  s*    4   **4000r*   c                 ,    |                      |          S r"   )rG  r$   s     r'   r  z&TransformBuiltinMethods.visit_NameNode  s    **4000r*   c                 B   |                                 }|r|dk    r/ddlm} t          j        |j        t          |                    }n|dk    rt          j        |j                  }n|dv rat          j        |j        t          |          | 	                                
                                                    |                    }nMt          j        |          rn8| j        j                            |          rnt#          |j        d|z             |S )	N__version__r   )rJ  rw   r  )r  	frozensetr  r1  z>'%s' not a valid cython attribute or is being used incorrectly)r  r_  rJ  r   r0  rM   r   NullNoder   rP  builtin_scoper  r   r  rH   cython_scopelookup_qualified_namer   )r%   r&   r  versions       r'   rG  z.TransformBuiltinMethods.visit_cython_attribute  s-   ,,..	 	oN**555555 +DHM'<R<RSSSg%% )$(33EEE )$(y9Q9Q040@0@0B0B0P0P0R0R0^0^_h0i0ik k k,Y77 o*@@KK odh adm mnnnr*   c                    |                                  }|                     |           t          |j                  dk    r}|j                            t          j        |j                             |j        sE|j                            t          j	        |j        | 
                                |                     |S r0  )rP  r9   r   rz   r   r   GlobalsExprNoderM   r  LocalsExprNodecurrent_scope_node)r%   r&   r  s      r'   visit_ExecStatNodez*TransformBuiltinMethods.visit_ExecStatNode  s    !!4   ty>>QIY6tx@@AAA' D	  ,$"9"9";";TC CD D D r*   c                 R  	 |                                  }|                    |          }|r|S |j        	|dv r|dk    rDt          |j                  dk    r,t          | j        dt          |j                  z             |S |dk    r\t          |j                  dk    r*t          | j        dt          |j                  z             t          |j                  dk    r|S t          j        	|                                 |          S t          |j                  dk    r*t          | j        dt          |j                  z             t          |j                  dk    r|S |j	        s|j
        r]|j	        r.|                                 }t          j        |j                  }nt          j        	          }t          j        |          S t          d	 |j                                        D                       }	fd
|D             }t          j        	|          S )N)rD  varsrD  r   zGBuiltin 'locals()' called with wrong number of args, expected 0, got %drW  r   zGBuiltin 'vars()' called with wrong number of args, expected 0-1, got %dzFBuiltin 'dir()' called with wrong number of args, expected 0-1, got %dc              3   2   K   | ]}|j         	|j         V  d S r"   r   )r   r  s     r'   re  z9TransformBuiltinMethods._inject_locals.<locals>.<genexpr>  s+       W Wcch W W W W W W Wr*   c                 <    g | ]}t          j        |           S )rw   )r   IdentifierStringNode)r   r  rM   s     r'   r   z:TransformBuiltinMethods._inject_locals.<locals>.<listcomp>  s9     - - - 3CsCCC - - -r*   r  )rP  r  rM   r   rz   r   r   rS  rT  r  r  r  r  rR  SortedDictKeysNoder  r6  r  ro  )
r%   r&   	func_namer  r  r   locals_dictlocal_namesrK  rM   s
            @r'   _inject_localsz&TransformBuiltinMethods._inject_locals  s7   !!  ++ 	Kh***H$$TY!););dh iDI!' ( ( (f$$ty>>A%%$($m	NN%+ , , ,ty>>A%%K+C1H1H1J1JDQQQ49~~!!dh hDI!' ( ( (49~~!!% A)= A) A"5577G"+"5gl"C"CKK"+";C"@"@K 3K@@@  W WT\5H5H5J5J W W WWWK- - - - +- - -E%c6666r*   c                     |                      |           |j        dv rSt          |j        t          j                  r4|j        j        }t          |t          j                  r|j        }||_        |S )Nnot_in)r9   r  rO   rX  r   r[  r   NoneCheckNode)r%   r&   r   s      r'   visit_PrimaryCmpNodez,TransformBuiltinMethods.visit_PrimaryCmpNode  sl    4   =H$$$-)EFF $m'c9#:;; "'C #r*   c                 ,    |                      |          S r"   )rc  r$   s     r'   visit_CascadedCmpNodez-TransformBuiltinMethods.visit_CascadedCmpNode  s    ((...r*   c                    |                                  }|                    |          }t          |j                  dk    s	|r	|j        s|S |j                            t          j        |j                             |j	        sE|j                            t          j
        |j        |                                 |                     |S r0  )rP  r  r   rz   
is_builtinr   r   rR  rM   r  rS  rT  )r%   r&   r\  r  r  s        r'   _inject_evalz$TransformBuiltinMethods._inject_eval  s    !!I&&ty>>Q51AK	248<<===# 	@I(Hd5577? ?@ @ @ r*   c                    |                                  }|                    |          }|s|j        r|S |                                 }t	          |t
          j                  r|j        rt          | j                  dk     r|S | j        d         \  }}|j	        rdd|_
        d|j        _        t          j        |j        |j                  t          j        |j        |j        d         j                  g|_        nb|j        r[t          j        |j        |j        j        |j                  t          j        |j        |j        d         j                  g|_        |S )Nr   r'  T)r  r   r   r1  )rP  r  rz   rT  rO   r   r   r   r#  r  requires_classobj
class_cell	is_activer   ClassCellNoderM   r  r   ry   r  r  r  )r%   r&   r\  r  r  r   
class_noder  s           r'   _inject_superz%TransformBuiltinMethods._inject_super  se   !!  ++ 	DI 	K**,,(EM22 	(- 	3t~K^K^abKbKbK"&."4
K( 	)-H&.2J!+'H8+@B B B"48(-2B2GHHHDII
 ) 	"H:#3#8$*, , , "48(-2B2GHHH	DI r*   c                 	   |j                                         }|r|t          j        v rjt	          |j                  dk    rt          |j         j        d|z             nt          j        |         |j         j        |j        d                   }n|t          j        v rvt	          |j                  dk    rt          |j         j        d|z             nRt          j        |         |j         j        |j        d         |j        d                   }n|dk    rt	          |j                  dk    rt          |j         j        d	           n|j        d         	                    | 
                                          }|r/t          j        |j         j        ||j        d         d
          }nvt          |j        d         j        d           nT|dk    rt	          |j                  dk    rt          |j         j        d           n|j        d         	                    | 
                                          }|r"t          j        |j         j        |          }nt          j        |j         j        |j        d                   }n|dk    rtt	          |j                  dk    rt          |j         j        d           n]t          j        |j         j        d|j        d         |j        d                   }d|_        n|dk    rrt	          |j                  dk    rt          |j         j        d           nt          j        |j         j        d|j        d         |j        d                   }d|_        n|dk    r.t          j        |j        t%          d                    |_         nq|dk    r.t          j        |j        t%          d                    |_         n=| j        j                            |          rnt          |j         j        d|z             |                     |           t/          |t          j                  rj|j         j        r^|j         j        }|dv r|                     ||          S |dk    r|                     ||          S |dk    r|                     ||          S |S )Nr   z%s() takes exactly one argumentr   r  r   z %s() takes exactly two arguments)rW  rX  r  Dcast() takes exactly two arguments and an optional typecheck keywordFr1  r  	typecheckr  r  z#sizeof() takes exactly one argument)arg_typecmodz"cmod() takes exactly two arguments%Tcdivz"cdiv() takes exactly two arguments/r  r   r  z*'%s' not a valid cython language construct)dirrD  rW  evalrC   )r  r  r  ro  r   rz   r   rM   rq  r  rP  r   TypecastNodeSizeofTypeNodeSizeofVarNoder[  	cdivisionr   r   rH   rN  rO  r9   rO   re  r  ry   r_  rh  ro  )r%   r&   r  r1  r\  s        r'   visit_SimpleCallNodez,TransformBuiltinMethods.visit_SimpleCallNode   s   =4466 5	P6HHHty>>Q&&$-+-ORZ-Z[[[[6HR)49Q<A A ADD8KKKty>>Q&&$-+-PS[-[\\\\6I(S)DIaL49UV<Y Y YDDW$$ty>>Q&&$-+ac c c c  9Q<778H8H8J8JKKD >(5 M-D$)A,Z_ a  a  a dil.====Y&&ty>>Q&&$-+-STTTT9Q<778H8H8J8JKKD `(78ITXYYY(6t}7HRVR[\]R^___V##ty>>Q&&$-+-RSSSS$/0A3	RSVZV_`aVbccD%)DNNV##ty>>Q&&$-+-RSSSS$/0A3	RSVZV_`aVbccD%)DNNV## ) 248-PUBVBV W W W_,, ) 248-P^B_B_ ` ` `*@@JJ Pdm'ChNP P P 	4   dI455 	;$-:O 	;*I555**4;;;F""((y999G##))$	:::r*   c                 ~   |j                                         }|dk    r|j        j        }|j                            d           }t          |          dk    s*t          |          dk    st          |          dk    rd|vrt          |j         j        d           n|d         	                    | 
                                          }|r?|                    dd          }t          j        |j         j        ||d         |          }nt          |d         j        d	           |                     |           |S )
Nr  r   r   rs  rq  r   Frr  r  )r  r  r  rz   r  r'  r   r   rM   r  rP  r   r   r{  r9   )r%   r&   r  rz   r  r1  rs  s          r'   visit_GeneralCallNodez-TransformBuiltinMethods.visit_GeneralCallNodeF  s>   =4466w',D&99$??FD		Q#f++//[[A%%+V*C*Cdm']_ _ _ _ Aw..t/?/?/A/ABB 5 &

; > >I$1)d1gQZ\ \ \DD $q'+|4444   r*   N)r;   r<   r=   r>   r   r  r  rG  rU  r_  rc  re  rh  ro  r  r  r#   r*   r'   rC  rC  r  s           1 1 11 1 1  &	 	 	%7 %7 %7N	 	 	/ / /    6D D DL    r*   rC  c                   @     e Zd ZdZ fdZd Zd Zd Zd Zd Z	 xZ
S )ReplaceFusedTypeChecksa0  
    This is not a transform in the pipeline. It is invoked on the specific
    versions of a cdef function with fused argument types. It filters out any
    type branches that don't match. e.g.

        if fused_t is mytype:
            ...
        elif fused_t in other_fused_type:
            ...
    c                     t          t          |                                            || _        ddlm}  |d          | _        d S )Nr   )ConstantFoldingT)
reevaluate)rC   r  rD   r  Optimizer  r  )r%   r  r  rI   s      r'   rD   zReplaceFusedTypeChecks.__init__h  sR    $d++44666&------(D999r*   c                 V    |                      |           |                     |          S )zc
        Filters out any if clauses with false compile time type check
        expression.
        r9   r  r$   s     r'   r  z'ReplaceFusedTypeChecks.visit_IfStatNodeo  s*    
 	4   ~~d###r*   c                 V    |                      |           |                     |          S )z9
        Fold constant condition of GILStatNode.
        r  r$   s     r'   r  z(ReplaceFusedTypeChecks.visit_GILStatNodew  s*     	4   ~~d###r*   c                    t          j        d          5  |j                            | j                  }|j                            | j                  }d d d            n# 1 swxY w Y   |rW|rTt          j        |j        d          }t          j        |j        d          }| 	                    ||j        j                  }|j
        }|dv rD| 	                    ||j        j                  }|                    |          }|dv }|r|s|s|s|S n|dv rt          |t          j                  r|j        }|j        rt#          |j        j        d           nf|j        st#          |j        j        d	           nDt          j        |          }	|	D ]%}
|                    |
          r|d
k    r|c S |c S &|dk    r|S |S |S )NT)ignoreFrw   )isis_not==z!=)r  r  )inra  zType is fusedz-Can only use 'in' or 'not in' on a fused typer  ra  )r   local_errorsrW  r  r  rX  r   r  rM   specialize_typer  same_asrO   r   CTypedefTypetypedef_base_typer<  r   get_specialized_types)r%   r&   type1type2
false_node	true_nodeopis_sameeqtypesspecialized_types              r'   rc  z+ReplaceFusedTypeChecks.visit_PrimaryCmpNode~  sf    --- 	D 	DM11$2BCCEM11$2BCCE	D 	D 	D 	D 	D 	D 	D 	D 	D 	D 	D 	D 	D 	D 	D  )	U )	"+DHEBBBJ!*484@@@I((0ABBEB111,,UDM4EFF--..<' % %G %B %$$''' eZ%<== 4!3E> )$-+_==== )$-+IK K K K '<UCCE,1 2 2( ==)9:: 2!Tzz'0 0 0 0'1 1 1 1	2 X~~((s   ?A!!A%(A%c                     	 |                     | j        j                  S # t          $ r t	          |d           |cY S w xY w)NzType is not specific)r  r  r  KeyErrorr   )r%   r1  rM   s      r'   r  z&ReplaceFusedTypeChecks.specialize_type  sT    	??4#3#EFFF 	 	 	#-...KKK	s   ! A A c                 0    |                      |           |S r"   r  r$   s     r'   r  z!ReplaceFusedTypeChecks.visit_Node  r  r*   )r;   r<   r=   r>   rD   r  r  rc  r  r  rk   rl   s   @r'   r  r  ]  s        	 	: : : : :$ $ $$ $ $0 0 0d        r*   r  c                   F     e Zd ZdZ fdZd Zd Zd Zd Zd Z	d Z
 xZS )	DebugTransformz9
    Write debug information for this Cython module.
    c                     t          t          |                               |           t                      | _        | j        j        | _        |j        | _	        g | _
        d| _        d S rB   )rC   r  rD   r  visitedrH   gdb_debug_outputwritertbc_filec_output_filenested_funcdefsregister_stepinto)r%   rH   optionsr   rI   s       r'   rD   zDebugTransform.__init__  s^    nd##,,W555uu ,5#]  " "'r*   c                 4   |j         | j        _        t          |j         |j        d         j        | j                  }| j                            d|           | j                            d           |                     |           | j	        D ]}| 
                    |           d| _        |                     |           d| _        | j                            d           | j                            d           i }|j        j                                        D ]J\  }}|j        | j        vr7|j                            d          s|j        j        s|j        j        s|||<   K|                     |           | j                            d           |S )	Nr   )r  filename
c_filenameModule	FunctionsTFGlobals__pyx_)full_module_namer  r  r  rM   r  r  startr9   r  r  r   serialize_modulenode_as_functionendr  r6  rK  r  r  ry   r  r1  r  r9  serialize_local_variables)r%   r&   r   nested_funcdefr6  r  r  s          r'   rR   zDebugTransform.visit_ModuleNode  s   "3-Xa[))+ + +
 	h&&& 	k"""4    #2 	3 	3N"">2222!%--d333!&K    	i   J&,,.. 	 	DAq 44F%%h// 5F' 5 F, 5 
&&w///I r*   c           
         | j                             |j        j                   t	          |dd          r|S | j        r| j                            |           |S |j        d}n|j        j	        j
        }|j	        j        p|j	        j
        }t          |j	        j        pt	          |dd          |||j        j        t          |j        d                             }| j                            d|	           | j                            d
           |                     |j        j                   | j                            d
           | j                            d           |j        j        D ]@}| j                            |j                   | j                            |j                   A| j                            d           | j                            d           d| _        |                     |           d| _        | j                            d           | j                            d           |S )Nr*  Fr_  ry   z	<unknown>r   )ry   r  pf_cnamer  linenoFunctionr   Locals	ArgumentsStepIntoFunctionsT)r  r5  r  r  r%  r  r  r   r  r  
func_cnamepyfunc_cnamer  ry   r+  rM   r  r  r  r6  r  arg_entriesr9   )r%   r&   r  r  r   r   s         r'   r  z DebugTransform.visit_FuncDefNode  s   )89994u-- 	K! 	 ''---K <HH|)4H
 
'@4:+@FGD&+$F$F+:tx{##% % % 	j...h&&t'7'?@@@Hk"""#/ 	" 	"CGMM#(###GKK!!!!K   )***!%4   !&'(((Jr*   c                 >   | j         r|j        y|j        j        rmt          |dd          r\|j        j        Pt          |j        j                  }| j                            d|           | j        	                    d           | 
                    |           |S )N	is_calledFr   StepIntoFunctionr  )r  r1  r  r%  r  r  r  r  r  r  r9   r%   r&   r   s      r'   r  zDebugTransform.visit_NameNode*  s    " 	,	%	& &k511 & 
%1 dj3444EGMM,EM:::GKK*+++4   r*   c                     |                      |t          |j                            d          d         |                                dddd                     dS )z
        Serialize the module-level code as a function so the debugger will know
        it's a "relevant frame" and it will know where to set the breakpoint
        for 'break modulename'.
        r  r   r_  1True)ry   r  r  r  r  is_initmodule_functionN)!_serialize_modulenode_as_functionr  r  
rpartitionmodule_init_func_cnamer$   s     r'   r  z/DebugTransform.serialize_modulenode_as_function<  so     	..tT&11#66r:--// #)	6
 	6
 	6
 		 		 		 		 		r*   c                 .   | j                             d|           | j                             d           |                     |j        j                   | j                             d           | j                             d           | j                             d           | j                             d           d| _        |                     |           d| _        | j                             d           | j                             d           d S )Nr  r  r  r  r  TF)r  r  r  r  r6  r  r  r9   r  s      r'   r  z0DebugTransform._serialize_modulenode_as_functionM  s    j...h&&tz'9:::Hk"""K   )***!%4   !&'(((Jr*   c                 J   |                                 D ]}|j        s|j        j        rd}nd}|j        rDt
          j        d|j        j        }|j        j	        j
        d|j        j        d|j        }n3|j        rt
          j        d|j        }|j
        }n|j        }|j
        }|j        sd}nt          |j        d                   }t          |j        ||||          }| j                            d|           | j                            d           d S )	NPythonObjectCObjectz->r  0r   )ry   r  r  r1  r  LocalVar)r  r  r1  rj  r  r   cur_scope_cnameouter_entryr  r  r  ry   r  rM   r+  r  r  r  r  )r%   r6  r  vartyper  qnamer  r   s           r'   r  z(DebugTransform.serialize_local_variables_  sc   ^^%% *	$ *	$E; z% $(#! - %+$:$:$:$)$5$;$;= ',k&=&L&L&L&+k&6&6&6&+jj2 ! -$*$:$:$:$)KK1,,9 + UYq\**Z$  E GMM*e,,,GKK
####U*	$ *	$r*   )r;   r<   r=   r>   rD   rR   r  r  r  r  r  rk   rl   s   @r'   r  r    s         ' ' ' ' ' & & &P/ / /b  $  "     $+$ +$ +$ +$ +$ +$ +$r*   r  r#   )N
__future__r   r  r  rT  r   r   r   r_  r   r   r   r   r   r   r   r  r   r   r   r   r   r	   r
   r   r   StringEncodingr   r   r   r   r   r   Coder   r    r@   rn   r   r   r   rp   r   r   r   r   rX  r   ra  ru  r  r  rs  r  r  r  r  r#  r+  rA  r  r  r=  rH  rM  rh  r  r  r  r~   r  r  r  r!  r<  rC  r  r  r#   r*   r'   <module>r     s	   ' & & & & &        &&    66    v )/ 9?  & /5v EKV  V  &,V  39&  CI&  OUf  	      



                                           2 2 2 2 2 2 2 2 J J J J J J J J J J * * * * * * * * & & & & & & 3 3 3 3 3 3 3 3 ? ? ? ? ? ? ? ? ? ? ? ?          v   BP P P P PO P P Pf ) ( ( ( (\ ( ( ( ^ E Q g g g g g& g g gR! ! ! ! !K ! ! !<V! V! V! V! V!; V! V! V!r,8 ,8 ,8\" " "B	 	 	C# C# C#J!@ !@ !@H6 6 6 6 6?$4 6 6 6r6 6 6 6 6+-= 6 6 6*l	% l	% l	% l	% l	%/ l	% l	% l	%^lC lC lC lC lC_.> lC lC lC^C6 C6 C6 C6 C6$&6 C6 C6 C6L/ / / / /+7G / / /2`6 `6 `6 `6 `6 02B `6 `6 `6Fz$ z$ z$ z$ z$/1A z$ z$ z$z,2 ,2 ,2 ,2 ,20@ ,2 ,2 ,2^6 6 6 6 6/ 6 6 6rH	 H	 H	 H	 H	< H	 H	 H	V  $    |   D# # # # #/ # # #L       ,9 9 9 9 9\ 9 9 9xZ Z Z Z ZO-= Z Z Zz3 3 3 3 3 3 3 3l) ) ) ) )? ) ) )X+ + + + +O + + +\< < < < < < < <~Y Y Y Y Y Y Y YxQ+ Q+ Q+ Q+ Q+? Q+ Q+ Q+h36 36 36 36 36(*: 36 36 36l[ [ [ [ [ [ [ [|    \#3   4h h h h hl h h hV\ \ \ \ \- \ \ \~N$ N$ N$ N$ N$_ N$ N$ N$ N$ N$r*   