
    -Ph.             	          d dl Z  e j        dti 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 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 dd lmZmZmZmZ  G d! d"          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. d/e          Z(d0 Z)d1 Z*d2 Z+e j,        d3e-d4e-fd5            Z.e j,        d6e-d7e-d8e-d9e-fd:            Z/ G d; d<ee           Z0 G d= d>ee           Z1 G d? d@e          Z2 G dA dBee           Z3 G dC dDee           Z4 G dE dFee           Z5 G dG dHee           Z6 G dI dJee           Z7 G dK dLee           Z8 G dM dNe          Z9 G dO dPe          Z:dQ Z; G dR dSe          Z< G dT dUe          Z= G dV dWe          Z> G dX dYe          Z? G dZ d[ee           Z@ G d\ d]e          ZA G d^ d_e          ZB G d` dae          ZC G db dce          ZD G dd dee          ZE G df dge          ZF G dh diee           ZG G dj dke          ZH G dl dmee           ZI G dn doe          ZJ G dp dqe          ZK G dr dse          ZLdS )u    N
PyrexTypesNaming	ExprNodesNodesOptions	UtilNodesLetNode
LetRefNodeTreeFragmentEncodedStringerrorwarningcopyhashlibsys
itemgetter)r      )r   )r   )r   )r   )r   )Builtin)Errors)VisitorTransformTreeVisitor)CythonTransformEnvTransformScopeTrackingTransform)r	   r
   )r   )r   )r   r   CompileErrorInternalErrorc                   <    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     c/var/www/html/test/jupyter/venv/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_CBaseTypeNode.   r'   r(   c                     |S r    r!   r"   s     r%   visit_CEnumDefNodez#SkipDeclarations.visit_CEnumDefNode1   r'   r(   c                     |S r    r!   r"   s     r%   visit_CStructOrUnionDefNodez,SkipDeclarations.visit_CStructOrUnionDefNode4   r'   r(   c                 F    |j         dk    r|                     |           |S Nextern)
visibilityvisitchildrenr"   s     r%   visit_CppClassNodez#SkipDeclarations.visit_CppClassNode7   s(    ?h&&t$$$r(   N)__name__
__module____qualname____doc__r&   r*   r,   r.   r0   r2   r8   r!   r(   r%   r   r      s                         r(   r   c                   Z     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 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                 f    t                                          |           d| _        d| _        d S NF)super__init__is_in_statlist
is_in_exprr#   context	__class__s     r%   rB   zNormalizeTree.__init__S   s.    !!!#r(   c                     |                      |           t          |j        t          j                  s&t          j        |j        |j        g          |_        |S Nposstats)r7   
isinstancebodyr   StatListNoderK   r"   s     r%   visit_ModuleNodezNormalizeTree.visit_ModuleNodeX   sP    4   $)U%788 	L*tx	{KKKDIr(   c                 Z    | j         }d| _         |                     |           || _         |S NT)rD   r7   )r#   r$   stacktmps      r%   visit_ExprNodezNormalizeTree.visit_ExprNode_   s0    ?4   "r(   Fc                     | j         }|| _         |                     |           || _         | j         s#| j        st          j        |j        |g          S |S rI   )rC   r7   rD   r   rO   rK   )r#   r$   is_listcontainerrS   s       r%   visit_StatNodezNormalizeTree.visit_StatNodef   sa    &.4   &" 	4? 	%$(4&AAAAKr(   c                 L    d| _         |                     |           d| _         |S NTF)rC   r7   r"   s     r%   visit_StatListNodez NormalizeTree.visit_StatListNodep   s+    "4   #r(   c                 .    |                      |d          S rR   rW   r"   s     r%   visit_ParallelAssignmentNodez*NormalizeTree.visit_ParallelAssignmentNodev       ""4...r(   c                 .    |                      |d          S rR   r\   r"   s     r%   r0   z NormalizeTree.visit_CEnumDefNodey   r^   r(   c                 .    |                      |d          S rR   r\   r"   s     r%   r2   z)NormalizeTree.visit_CStructOrUnionDefNode|   r^   r(   c                     |j         j        rt          j        |j         j                  S |                     |          S )z!Eliminate useless string literals)expris_string_literalr   PassStatNoderK   rW   r"   s     r%   visit_ExprStatNodez NormalizeTree.visit_ExprStatNode   s8    9& 	-%dim444&&t,,,r(   c                     |S r    r!   r"   s     r%   r,   z#NormalizeTree.visit_CDeclaratorNode   r'   r(   F)r9   r:   r;   r<   rB   rP   rT   rW   rZ   r]   r0   r2   re   r,   __classcell__rG   s   @r%   r>   r>   >   s         (         
         / / // / // / /- - -      r(   r>   c                       e Zd ZdS )PostParseErrorN)r9   r:   r;   r!   r(   r%   rk   rk      s          r(   rk   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                        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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                                          |           d| j        i| _        d| _        d S )N__cythonbufferdefaults__F)rA   rB   handle_bufferdefaultsspecialattribute_handlersin_pattern_noderE   s     r%   rB   zPostParse.__init__   s=    !!!&)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rb   value)nameargsstar_argstarstar_argrN   doc)YieldNodeCollectorr7   result_expr	has_yield	has_awaitrM   r   YieldExprNoder   ExprStatNoderK   ReturnStatNodeDefNoderw   rx   ry   rz   def_node)r#   r$   	collectorrN   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)rw   r{   rx   ry   rz   rN   is_async_defis_generator_expressionpyclasscclassscope_is_class)r|   r7   loopr   r   rK   rw   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|   r7   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    )
rM   defaultr   DictNoderk   rK   ERR_BUF_DEFAULTS
scope_nodebuffer_defaults_nodebuffer_defaults_pos)r#   decls     r%   rp   zPostParse.handle_bufferdefaults   sJ    $,	(:;; 	= +;<<</3|,.2h+++r(   c           
         	 |                      |           |g}g }|j        D ]}|}t          |t          j        t          j        f          r-|j        }t          |t          j        t          j        f          -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 |_        |                    |           ||_        |S # t          $ r%}| j                            |           Y d }~d S d }~ww xY w)N)r   r   structmodulerw   )lhsrhsfirst)r7   declaratorsrM   r   CPtrDeclaratorNodeCConstDeclaratorNodebaseCNameDeclaratorNoder   r   r   CClassDefNoderq   getrw   rk   rK   ERR_INVALID_SPECIALATTR_TYPEERR_CDEF_INCLASSappendSingleAssignmentNoder   NameNoderF   nonfatal_error)	r#   r$   rL   newdeclsr   declbasehandlerfirst_assignmentes	            r%   r*   zPostParse.visit_CVarDefNode   s   
	t$$$FEH( & & E,DeF`+abb -'}H !E,DeF`+abb -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8GGc                 p    |                      |           |                     ||j        |j        g          S r    )r7   _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    )r7   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_constructorrc   ).0rb   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   rL   c                      g | ]}|j         |fS r!   )
expression)r   temps     r%   r   z4PostParse._visit_assignment_node.<locals>.<listcomp>A  s/     $= $= $=)- '+ot%< $= $= $=r(   )sumflatten_parallel_assignmentseliminate_rhs_duplicateslenr   r   rK   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    )rx   r   _flatten_sequencer   )r#   seqresultargs       r%   r   zPostParse._flatten_sequenceI  sQ    8 	# 	#C* #&&sF3333c""""r(   c                 f    |                      |           |                     |g           |_        |S r    )r7   r   rx   r"   s     r%   visit_DelStatNodezPostParse.visit_DelStatNodeQ  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)rx   ignore_nonexistingr   )rN   finally_clause)is_except_asr   DelStatNoderK   r   r   targetrw   rO   TryFinallyStatNoderN   r7   )r#   r$   
del_targets      r%   visit_ExceptClauseNodez PostParse.visit_ExceptClauseNodeV  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   RaiseStatNoderK   r   r   r   rv   r7   r"   s     r%   visit_AssertStatNodezPostParse.visit_AssertStatNodei  s{     >!"0"+DH=IY;Z;Z[[[*!1!%  DN DJ4   r(   c                 :    t          |j        |j                   d S r    )r   rK   whatr"   s     r%   visit_ErrorNodezPostParse.visit_ErrorNodez  s    dh	"""tr(   c                 X    |                                  |                     |           |S r    )validate_targetsr7   r"   s     r%   visit_MatchCaseNodezPostParse.visit_MatchCaseNode~  s-    4   r(   c                 X    |                                  |                     |           |S r    )validate_irrefutabler7   r"   s     r%   visit_MatchNodezPostParse.visit_MatchNode  s-    !!###4   r(   c                 \    | j         dc}| _         |                     |           || _         |S rR   )rr   r7   )r#   r$   rr   s      r%   visit_PatternNodezPostParse.visit_PatternNode  s5    040Dd--4   .r(   c                 h    | j         rt          |j        d           |                     |           |S )Nz/f-strings are not accepted for pattern matching)rr   r   rK   r7   r"   s     r%   visit_JoinedStrNodezPostParse.visit_JoinedStrNode  s:     	O$(MNNN4   r(   c                     | j         dk    r*|j        dv r!t          |j        d|j         dd           d S |                     |          S )Nr   )__getreadbuffer____getwritebuffer____getsegcount____getcharbuffer__'zD' relates to the old Python 2 buffer protocol and is no longer used.r   )r   rw   r   rK   visit_FuncDefNoder"   s     r%   visit_DefNodezPostParse.visit_DefNode  sg    Ox''	pppDH -$) - - -./1 1 14%%d+++r(   )r9   r:   r;   r<   rB   r   r   r   rp   r*   r   r   r   r   r   r   r   r   r   r  r  r  r  rh   ri   s   @r%   rm   rm      sY       " "F% % % % %  $  	 	 	7 7 7$ $ $ZG G GM M M& & &P    
  &  "    
  
    , , , , , , ,r(   rm   c                   <     e Zd Z fdZd Zd Zd Zd Zd Z xZ	S )%_AssignmentExpressionTargetNameFinderc                 V    t                                                       i | _        d S r    )rA   rB   target_namesr#   rG   s    r%   rB   z._AssignmentExpressionTargetNameFinder.__init__  s'    r(   c                     |j         r|j        gS |j        r6g }|j        D ]*}|                    |                     |                     +|S g S r    )is_namerw   r   rx   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  r7   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    r7   r"   s     r%   
visit_Nodez0_AssignmentExpressionTargetNameFinder.visit_Node      4     r(   )
r9   r:   r;   rB   r  r  r   r   r   rh   ri   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                 p   t                                                       t                      }|                    |           |j        | _        d| _        d| _        || _        d| _	        t                      | _        | j                                        D ]}| j                            |           d S NFr!   )rA   rB   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  rG   s        r%   rB   z%_AssignmentExpressionChecker.__init__  s    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)  r1  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(  r7   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   rK   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    )r3  r%  r}   r5  )r#   r$   r2  s      r%   r   z-_AssignmentExpressionChecker.visit_LambdaNode  sB     %%''	

4#$$$	"""""r(   c                 Z    | j         }d| _         |                     |           || _         d S rR   )r(  r7   r#   r$   r(  s      r%   r   z4_AssignmentExpressionChecker.visit_ComprehensionNode  s5    "6#' 4   #6   r(   c                 d    | j         }d| _         |                     |j                   || _         d S rR   )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(   )r9   r:   r;   r<   rB   r3  r5  classmethodr   r  r=  r   r   r   r   rh   ri   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   rx   )r$   ref_nodeitemfind_duplicatesref_node_sequence	ref_nodes
seen_nodess      r%   rJ  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maprx   )r$   rL  substitute_nodess    r%   rQ  z2eliminate_rhs_duplicates.<locals>.substitute_nodes2  sD    9T?") 	?S!149==>>DIr(   )r*  r   rO  rP  rx   )	r   rK  r   r   r$   rJ  rL  rM  rQ  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 rY   r   rx   )r   xrI  containss      r%   rV  z*sort_common_subsequences.<locals>.containsN  sO     	 	Dqyytt- ((49a2H2H ttur(   c                 4    |j         o |j        |           S r    rT  )abrV  s     r%   
lower_thanz,sort_common_subsequences.<locals>.lower_thanU  s    (@XXafa-@-@@r(   r   r   r   N)	enumeraterange)itemsrZ  rK   rI  keynew_posirV  s          @r%   r   r   B  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 )Nru   )rK   rG   rv   r   )literalcharsrK   stypesval	sval_typecharcvals           r%   #unpack_string_to_character_literalsri  d  si    E
+CE=DI - -yUU3d+++,,,,Lr(   inputoutputc                    | 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 ]m}|j         s2|j        rt          |j        d           |                    |           <t          |j                  }	d}
|j        D ]}|
t          |j                  z  }
|
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           =t!          ||j                  D ]\  }}|                    |           o|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>z  s    JJJ3JJJr(   c                     g | ]}g S r!   r!   )r   r   s     r%   r   z0flatten_parallel_assignments.<locals>.<listcomp>  s    ///!2///r(   z4starred assignment target must be in a list or tupler   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   rM   r   UnicodeNoder   r   rx   rc   ri  r   r\  
is_starredr   rK   boolmap_starred_assignmentzipr   )rj  rk  r   complete_assignmentsrhs_argsrhs_sizelhs_targetsstarred_assignmentsr   lhs_sizestarred_targetsrb   targetscascades                 r%   r   r   p  sg    )C( JsI<Q,R,R JJuSbSzJJJKKe
" <8		 <6s;; #&h--H//uX///KSbSz % %* 	~ WcgUVVV '',,,sx==H 	5 	5DtDO444OO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(   ry  rz  lhs_argsrw  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   )rK   rx   )
r[  ru  rr  r   r   r   r   rK   r   ListNode)ry  rz  r  rw  r`  r}  rb   starredlhs_remainingr   starred_rhsrK   s               r%   rt  rt    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                 T    d| _         t                                          |          S )Npxd)r   rA   __call__r#   r$   rG   s     r%   r  zPxdPostParse.__call__  s"    ww%%%r(   c                 Z    | j         }d| _         |                     |           || _         |S Nr   )r   r7   )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)r  r   Tprivateapi)ERR_INLINE_ONLYrM   r   r   r   rw   CFuncDefNode	modifiersinline_in_pxdr6   ERR_NOGO_WITH_INLINEr  rF   r   rk   rK   )r#   r$   errs      r%   r  zPxdPostParse.visit_FuncDefNode   s     "tU]++ 	80K0KI!GGGCdE.// 	+DN**O'888%)"?i//3doECCX 3e;CCCC* 	L''tx(E(EFFF4Kr(   )
r9   r:   r;   r<   r  r  r  r  r  rh   ri   s   @r%   r  r    sn          WOR& & & & &        r(   r  c                   8     e Zd Z fdZd Zd Zej        Z xZ	S )TrackNumpyAttributesc                 n    t                                                       t                      | _        d S r    )rA   rB   r*  numpy_module_namesr  s    r%   rB   zTrackNumpyAttributes.__init__  s+    "%%%r(   c                 ^    |j         dk    r!| j                            |j        pd           |S )Nnumpy)module_namer  rG  as_namer"   s     r%   visit_CImportStatNodez*TrackNumpyAttributes.visit_CImportStatNode#  s3    w&&#''(?@@@r(   c                     |                      |           |j        }|j        r|j        | j        v s|j        rd|_        |S rR   )r7   objr  rw   r  is_numpy_attribute)r#   r$   r  s      r%   visit_AttributeNodez(TrackNumpyAttributes.visit_AttributeNode(  sK    4   hK 	+CH(???CDZ?&*D#r(   )
r9   r:   r;   rB   r  r  r   recurse_to_childrenr   rh   ri   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*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                 d   t                                          |           t                      | _        ddi| _        i | _        t          j        t          j	                              }|
                                D ])\  }}t          j        |          |t          |          <   *|| _        d S )Nstaticmethod)rA   rB   r*  cython_module_namesdirective_namesparallel_directivesr   deepcopyr   get_directive_defaultsr]  str
directives)r#   rF   compilation_directive_defaultsr  r^  rv   rG   s         r%   rB   z$InterpretCompilerDirectives.__init__x  s    !!!#&55  .?#% ]7#A#C#CDD
8>>@@ 	8 	8JC#'=#7#7Js3xx  $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   rF   r   rk   directive_typesr   )r#   rK   	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   rp  c                 6    g | ]}|                                 S r!   )split)r   lines     r%   r   zJInterpretCompilerDirectives._check_valid_cython_module.<locals>.<listcomp>  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'.r  z ' is not a valid cython.* modulez. )

startswithr  valid_cython_submodules
splitlinesr   r  rp  r  hasattrr   )
r#   rK   r  	submoduleextrahintswrongcorrectis_simple_cython_namer  s
             r%   _check_valid_cython_modulez6InterpretCompilerDirectives._check_valid_cython_module  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  rK   wrong_scope_errorr  module_scoper  r-  r  r7   r  )r#   r$   r^  s      r%   rP   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  r7   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#   rw   s     r%   is_cython_directivez/InterpretCompilerDirectives.is_cython_directive  s5    // 2,,2+D11	3r(   c                 ,   |dz                        d          }|ry|                    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             |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)r  r  r  valid_parallel_directivesr   r   )r#   	full_namerK   r   r  rw   s         r%   is_parallel_directivez1InterpretCompilerDirectives.is_parallel_directive  s     c/--.@AA 		@!,,I---7H(44111 : Q QD5ID5PD,T22Qi..A%%B-t'EEEc2Y>???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    rG|j        r|j        dk    r|| j	        |j        <   n^| j                            d           || j	        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   rK   r  r  r   r  rG  r  r  r  r#   r$   r  s      r%   r  z1InterpretCompilerDirectives.visit_CImportStatNode  s   &+++$(efff!!"455 	D|  8 8#.s3E/F/F/G/G#H $(CD D D (""$(()ABBBB##I.. 	%%&899 Gdh 03E EFFFF//+FFF///< EDLH$<$<=HD,T\::,00:::9D ,$57 7 75@_$T\22(,,X666 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_importrK   relative_levelimported_namesr  r  r  r  r  r   )
r#   r$   r  r  newimprK   rw   r  r  qualified_names
             r%   visit_FromCImportStatNodez5InterpretCompilerDirectives.visit_FromCImportStatNode	  s   &+++{/E/EFX/Y/Y+33+t':D<OQ Q Q$ 	)x'';+A+A)+L+L'++DHkBBB$s*ABB/IF&*&9 8 8"T7%,	!*Y!6--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  rv   r  r]  r   rK   rw   r  levelr  r  r  r  r  )r#   r$   import_noder  r   rw   	name_noder  r  r  r  s              r%   visit_FromImportStatNodez4InterpretCompilerDirectives.visit_FromImportStatNode*  s   k!-3+++{/E/EFX/Y/Y+N#': _ _i%%]D$).2H2H$$in]_ _ _ _33+{'8.J J JH$$(>(>y(I(I$++K,C,GUUU$s*ABB/IF#': 5 5i%,	!*Y!6--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   rK   dotted_namer  r  s       r%   r   zKInterpretCompilerDirectives._create_cimport_from_import.<locals>.<listcomp>R  sS        .Cg % +# %
	, , ,  r(   )r  r   r   r   FromCImportStatNode)r#   node_posr  r  r   s      ` r%   r  z7InterpretCompilerDirectives._create_cimport_from_importF  s    +++{/E/EFX/Y/Y+'C8J4K4K4L4L(MNNK 	,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  )rM   r   r   
ImportNoder  rv   r  r   r  rK   r   rw   r  r7   r  s      r%   r   z6InterpretCompilerDirectives.visit_SingleAssignmentNode[  s    dh	 455 	%(.4Kh&&{/E/Ei/P/P&({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  ru   )r  
visitchildrw   r  is_cython_moduler  r   cython_attributeas_cython_attributer   BoolNoderK   )r#   r$   r  s      r%   visit_NameNodez*InterpretCompilerDirectives.visit_NameNodeh  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  Tru   )r7   r  r   r  rK   r"   s     r%   r  z/InterpretCompilerDirectives.visit_AttributeNodev  sJ    4   ##%%33%dhd;;;;r(   c                 H    |j         r|                     |j                    |S r    )rb   r%  r"   s     r%   visit_AnnotationNodez0InterpretCompilerDirectives.visit_AnnotationNode}  s'     9 	"JJty!!!r(   c                 \    |                      |d           |                     |           |S Ncppclass)r  r7   r"   s     r%   visit_NewExprNodez-InterpretCompilerDirectives.visit_NewExprNode  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  Tru   z5The '%s' directive should be used as a function call.)rM   r   CallNoder  r"  r  r   r  r   explicit_args_kwdsdictkey_value_pairsrv   r   try_to_parse_directiverK   AttributeNoder   r%  rs  r  DEFER_ANALYSIS_OF_ARGUMENTSrk   )r#   r$   optnamedirectivetyperx   kwdsr  r&  keyvaluer^  rv   sub_optnamer   s                r%   try_to_parse_directivesz3InterpretCompilerDirectives.try_to_parse_directives  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 rd|3t          |          dk    s t          |d         t          j                  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 |t0          u r;|r+t          |j                  dk    rt          |d|z            |d |D             fS t3          |          rn|3t          |          dk    s t          |d         t          j                  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!   )r  rv   )r   r   s     r%   r   zFInterpretCompilerDirectives.try_to_parse_directive.<locals>.<listcomp>  s     >>>c#)nn>>>r(   )rF   cpprk   r   r&  r^  rc   rv   rM   r   r  r   r  r   NoneNoder  rs  intIntNoder  rq  typer%  as_python_dictrO  callabler)  )	r#   r*  rx   r,  rK   	arg_errorr3  kwr+  s	            r%   r'  z2InterpretCompilerDirectives.try_to_parse_directive  sO   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>>DGYMb9c9c>$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>>DGYMb9c9c>$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                  r!|
                    |j                   |j        }t          |t          j                  st	          j        |j        |g          }t	          j        |j        |||j                  S )N)r  rN   r   )rN   r  is_terminator)r   r  r   copy_inherited_directivesr   rO   rN   rK   CompilerDirectivesNoderM   r-  r@  )r#   r$   r  contents_directivesr  new_directivesnew_contents_directivesretbodys           r%   visit_with_directivesz1InterpretCompilerDirectives.visit_with_directives  s    	)****??4((( :>XXZXX*&-&G'7 '7"5'7 '7## '5#^++??4((((+'>99*	0	#:!Y( ( (  DI //$''(gu;<< 	#!!'"4555lG'5#566 	D('CCCG+Kg.PWPeg g g 	gr(   c                 b    |                      |d          \  }}|                     |||          S )Nr"  _extract_directivesrG  r#   r$   r  rC  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.rC  )rJ  r]  directive_localsrF   r   rk   rK   rG  )r#   r$   r  r   rw   rv   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  rI  rK  s       r%   r  z/InterpretCompilerDirectives.visit_CClassDefNode/  s6    *.*B*B4*R*R'
'))$
<OPPPr(   c                 b    |                      |d          \  }}|                     |||          S r  rI  rK  s       r%   r8   z.InterpretCompilerDirectives.visit_CppClassNode3  rL  r(   c                 b    |                      |d          \  }}|                     |||          S )NclassrI  rK  s       r%   visit_PyClassDefNodez0InterpretCompilerDirectives.visit_PyClassDefNode7  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   r4  cfuncufuncz=Cannot apply @cfunc to @ufunc, please reverse the decorators.z*Directive does not change previous value (z=%rrp  )r  r   rU  )
decoratorsr%  r  objectr/  	decoratorr  rK   r   rM   r   r  rk   rv   r   r   r   r   r-  rO  r  r   immediate_decorator_directives)r#   r$   
scope_namer  realdecsbothcurrent_opt_dictmissingdecrD  r  rw   rv   rx   r,  optdictcontents_optdict	old_values                     r%   rJ  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|                     ||          c S |dk    r|\  }}|                     |||          c S | 	                    |j        |d          r|||<   |r| 
                    |j        |d           S |                     |          S )Nz6Compiler directive with statements cannot contain 'as')rX  gilcritical_sectionzwith statementrP  )r/  managerr   rF   r   rk   rK   _transform_with_gil_transform_critical_sectionr  rG  rN   r   )r#   r$   directive_dictr  rw   rv   rx   r,  s           r%   visit_WithStatNodez.InterpretCompilerDirectives.visit_WithStatNode~  s1   55dlCCIr 	- 	-I {&++"48-effh h h#KD%'''//d;;;;;+++"
d77dDIIIII++DHd<LMM -',t$ 	c--di]a-bbbt$$$r(   c                    |dv sJ |j         }d }t          |t          j                  r]|j        rVt          |j                  dk    r0| j                            t          |j	        d|z                       |j        d         }nJt          |t          j
                  r0| j                            t          |j	        d|z                       t          j        |j	        ||j        |          }|                     |          S )N)rk  rX  r   z6Compiler directive %s accepts one positional argument.r   )staterN   	condition)rm  rM   r   SimpleCallNoderx   r   rF   r   rk   rK   GeneralCallNoder   GILStatNoderN   r   )r#   r$   rs  rm  rt  s        r%   rn  z/InterpretCompilerDirectives._transform_with_gil  s   (((((,	gy788 	lW\ 	l7<  1$$++"48-ehm-mnnp p pQII!:;; 	lL''tx)adi)ijjl l l TYR[\\\t$$$r(   c                    t          |          dk     st          |          dk    s|r-| j                            t          |j        d                     t          j        |j        ||j                  }|                     |          S )Nr   r   zBcritical_section directive accepts one or two positional argumentsrx   rN   )	r   rF   r   rk   rK   r   CriticalSectionStatNoderN   r   )r#   r$   rx   r,  s       r%   ro  z7InterpretCompilerDirectives._transform_critical_section  s    t99q==CIIMMTML''tx)mnn   ,H4di
 
 
 t$$$r(   ).r9   r:   r;   r<   r   
TypeofNodeAmpersandNodeDereferenceNodeinc_dec_constructor
TypeidNodeunop_method_nodesc_binop_constructorbinop_method_nodesr  r-  r  r  rB   r  r  rP   r  r  r  r  r  r  r  r   r  r  r  r   r/  r'  rG  r  r*   r  r8   rV  rJ  rq  rn  ro  rh   ri   s   @r%   r  r  2  s        : &%3 ) 9"?)"?d"K"K"?)"?d"K"K"?)"?t"L"L"?)"?t"L"L"+"6 *   	"?)"?"D"D  O
 ,---  ! ! !% % % % %	 	 	$ $ $N    3 3 3
  *" " "H  B  8  *          
* * *X> > >@'g 'g 'gT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    )rw   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   rK   )r#   r$   r  r7  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%   rP   z'ParallelRangeTransform.visit_ModuleNode  s3    
 # 	)'+'?D$??4((( r(   c                 b    |                      |          r|j        g| _        |j        | _        |S r    )r  rw   r  r  r  r"   s     r%   r  z%ParallelRangeTransform.visit_NameNode  s5    **400 	C'+ykD#-1-BD*r(   c                 |    |                      |           | j        r| j                            |j                   |S r    )r7   r  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:  )rx   kwargs)r  r  r7   rM   r   rv  positional_argsrx   keyword_argsr  rK   )r#   r$   rx   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 disallowedrN   Nz%The parallel directive must be called)r%  rm  rM   r   ParallelWithBlockNoders  r   rK   r  rN   r  r  )r#   r$   newnoderN   r  s        r%   rq  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  rN   else_clause)r  rM   r   sequencer   ParallelRangeNoders  r   rN   r  r   r   r   rK   )r#   r$   	in_prangeprevious_stateparallel_range_nodes        r%   r  z*ParallelRangeTransform.visit_ForInStatNode8  s    j)))h'''t}5$68 8	 	" #'-"8)-&'+y$.2.>+&Ddk9+=>> EdkoCE E E "DJf%%%#
m,,,r(   c                 N    |!t                                          |          S dS )zVisit a node that may be NoneN)rA   r%  r  s     r%   r%  zParallelRangeTransform.visitW  s'    77==&&& r(   )r9   r:   r;   r<   r  r  in_context_manager_sectionrs  r   r  r   ParallelThreadIdNoder  r  r  r  rP   r  r  r  rq  r  r%  rh   ri   s   @r%   r  r    s        	 	  !& "' E %*$?$-$B"'"9	 N N N  2
 
 
      0  :  >' ' ' ' ' ' ' ' 'r(   r  c                   (    e Zd Zd Zd Zej        ZdS )WithTransformc                    |                      |dg           |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 )NrN   
__aenter__	__enter__T)r  r  is_special_lookup)r"  rx   is_temp)r   )r   	with_noder   c                 8    g | ]}t          j                  S r!   )r   ExcValueNoder   r   rK   s     r%   r   z4WithTransform.visit_WithStatNode.<locals>.<listcomp>v  s7     C; C; C;,-I"3''C; C; C;r(   r  )slowrx   F)	with_stattest_if_runrx   
await_exproperand)rt  rN   )
if_clausesr  )rN   patternr   excinfo_target)rN   except_clausesr  c                 8    g | ]}t          j                  S r!   )r   r7  r  s     r%   r   z4WithTransform.visit_WithStatNode.<locals>.<listcomp>  s$    "M"M"Mq9#5c#:#:"M"M"Mr(   rx   rt   )rN   r   handle_error_case)r7   rK   is_asyncrN   r   rm  r   	ProxyNoderu  r(  	CloneNoder   
enter_callAwaitExprNoder   rO   WithTargetAssignmentStatNode	TupleNoder\  ExceptClauseNode
IfStatNodeIfClauseNodeNotNodeWithExitCallNodeReraiseStatNoder   TryExceptStatNoder   )	r#   r$   r  rN   r   rm  r  except_clauserK   s	           @r%   rq  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%   rT   zWithTransform.visit_ExprNode      r(   N)r9   r:   r;   rq  rT   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                 V    t                                                       || _        d S r    )rA   rB   gen_expr)r#   r  rG   s     r%   rB   z,_GeneratorExpressionArgumentsMarker.__init__  s$     r(   c                 h    |j         s|j        rJ | j        |_        |                     |           d S r    )rF  generator_arg_tagr  r7   r"   s     r%   rT   z2_GeneratorExpressionArgumentsMarker.visit_ExprNode  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(   )r9   r:   r;   rB   rT   r   r   rh   ri   s   @r%   r  r    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   )rp  r  rM   r   GeneratorExpressionNodegen_noderO  r   rx   call_parameters	tag_countsubstitutionsr7   r]  recursively_replace_node)r#   r$   r  kvs        r%   r  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.{})SymtabrK   rw   F)remove_fakeref)rK   
declarator	base_typer   r  T)rw   initialized_check)#r  r  rK   r  r   formatr   local_scopelookup_hererp  r  r   genexpr_arg_prefixpunycodify_namer  r   r   r:  r   remove_cv_refCArgDeclNoderw   rx   r   r  declare_argumententrycname
in_closurer7   r   r   gbodylookupr  )r#   r$   r  rK   name_sourcerw   r   r  r  	name_declr:  new_argr  r  s                 r%   r  z*_HandleGeneratorArguments._handle_ExprNode  sA   ".4=3L!777(C .KNNaNN k!:!:;;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 rR   r  r"   s     r%   rT   z(_HandleGeneratorArguments.visit_ExprNode  s    $$T4000r(   N)
r9   r:   r;   r  r   r  rT   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                                          |          }| j                                          |S r    )_propertiesr   rA   r  popr  s     r%   r  z&DecoratorTransform.visit_CClassDefNode/  s\    #!D###ww**400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')rM   rK   r  r   rw   )r#   r$   r  s      r%   visit_PropertyNodez%DecoratorTransform.visit_PropertyNode7  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   r5   r   r   r  z0Cdef functions cannot take arbitrary decorators.z*C property decorator can only be @property)r  r]  r   r   r6   r   r_  r  rw   r   rK   _find_property_decoratordeclared_name_add_property_reject_decorated_property)r#   r$   ret_nodedecorator_noderw   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   rC  r  )r   r  r]  r  r_  r  r  rw   _map_property_attributer  r  r   rK   r   r  _add_to_propertyis_classmethodis_staticmethodchain_decorators)r#   r$   r   r  r_  handler_namefuncdecss           r%   r  z DecoratorTransform.visit_DefNodeW  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  r]  r_  r  rw   is_attributer  )r#   r$   
propertiesr  r_  s        r%   r  z+DecoratorTransform._find_property_decorator}  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)r]  r   rK   )r$   r  decos      r%   r  z-DecoratorTransform._reject_decorated_property  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{   rw   rN   r  )rw   r{   rN   )r   r]  r  remover  rM   r   r  rO   rK   r   r  CPropertyNoder{   is_cpropertyr   rw   rN   rL   PropertyNode)r#   r$   rw   r  r   r'  rN   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  rw   r'  r   rK   r]  r%  rN   rL   r[  r   )	r#   r$   rw   r_  r   r)  rL   r`  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"  rx   r   )	r   r   rK   ru  r_  r   r   IndirectionNodedecorator_indirection)r$   r]  rw   decorator_resultr_  r  reassignments          r%   r  z#DecoratorTransform.chain_decorators  s     %-dhTBBB#DDbD) 	) 	)I(7",&' )  )  )
 &txd;;;	1H " " "
 ,l^<<%1"l##r(   )r9   r:   r;   r<   r  r   r   r  r  r  r  r  r  r  r  r  r  r  rh   ri   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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        u st          d          |d                             d           }|j        |= t'          j        |j        ||          } n|                     |          S )	Nr]  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)rK   r$   r  )getattrr   r[  r]  r_  rM   r   r#  r"  r  rw   r$  r   r   rF  r:  r   unicode_typecompile_time_valuer   CnameDecoratorNoderK   )r#   r$   r`  r_  rx   r  r  s          r%   handle_functionz(CnameDirectivesTransform.handle_function  sx   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tAw|w?S/S/S(RT T T Q22488OA&/DH46;= = =t$$$r(   N)
r9   r:   r;   r<   r9  r  r  r0   r2   r*   r!   r(   r%   r3  r3    sJ         % % %@ ()("1'r(   r3  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  r7   )r#   r$   envr  s       r%   r  z0ForwardDeclareTypes.visit_CompilerDirectivesNode  s:    n4   r(   c                 j    |j         | _        |j        | j        _        |                     |           |S r    )r  r  r  r7   r"   s     r%   rP   z$ForwardDeclareTypes.visit_ModuleNode  s2     J'+$4   r(   c                 x    | j         j        }d| j         _        |                     |           || j         _        |S Nr   )r  in_cincluder7   )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%   r0   z&ForwardDeclareTypes.visit_CEnumDefNode&  s    T&'''r(   c                 `    |j         | j        j        vr|                    | j                   |S r    )rw   r  entriesr  r"   s     r%   r2   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  rF  r  r:  is_extension_typeis_builtin_typer  cfunc_entriesis_fused"get_all_specialized_function_types)r#   r$   r:  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%   rV  z(ForwardDeclareTypes.visit_PyClassDefNode?  r  r(   N)r9   r:   r;   r<   r  rP   rC  r0   r2   r  r  rV  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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
    )rT  z;
if VALUE is not None:
    ATTR = VALUE
    count += 1
    r   c                     g | _         t                      | _        t                      }|j        | _        |                    |          S r    )seen_vars_stackr*  fused_error_funcsrA   r  _super_visit_FuncDefNoder  )r#   rootsuper_classrG   s      r%   r  z%AnalyseDeclarationsTransform.__call__t  s?    !!$gg(3(E%##D)))r(   c                 P    | j         d                             |j                   |S Nr   )rV  rG  rw   r"   s     r%   r  z+AnalyseDeclarationsTransform.visit_NameNode|  s%    R $$TY///r(   c                 R   g | _         | j                            t                                 |                    |                                            |                     |           | j                                         |j        j	        
                    | j                    |S r    )extra_module_declarationsrV  r   r*  analyse_declarationscurrent_envr7   r	  rN   rL   r  r"   s     r%   rP   z-AnalyseDeclarationsTransform.visit_ModuleNode  s    )+&##CEE***!!$"2"2"4"45554     """	t=>>>r(   c                     | xj         dz  c_         |                    |                                            |                     |           | xj         dz  c_         |S r@  )	in_lambdar_  r`  r7   r"   s     r%   r   z-AnalyseDeclarationsTransform.visit_LambdaNode  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_dataclassr5   
__reduce____reduce_ex__)visit_ClassDefNoder  r  	Dataclassre  implementedrN   var_entriesneeds_propertycreate_Propertyr_  r%  r   rL   r6   r  _inject_pickle_methods)r#   r$   re  rL   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__rf  rg  c                     | j         S r    r   )r   s    r%   <lambda>zEAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<lambda>  s    qv r(   )r^  c                     g | ]D}|j         j        |j                                       r|j                                       B|ES r!   )r:  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!   )r:  is_struct_or_unionrt  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   rt  s     r%   ru  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 r  r   rt  s     r%   ru  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"
                msgrR  rS  c                     g | ]	}|j         
S r!   r   rt  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%   ru  zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>	  sS       -C -C!B @Aqq"""E-C -C -C -C -C -Cr(   )unpickle_func_name	checksumsmembersrH  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 r  r!   )r   r  s     r%   ru  zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>"	  s&      (R(R1Q(R(R(R(R(R(Rr(   r   rp  z or c                 :    g | ]}|j         j        d |j        z  S )zself.%s is not None)r:  rz  rw   rt  s     r%   r   zGAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<listcomp>$	  sH      9D  9D  9D\]pqpv  qC  9D9NQRQW9W  9D  9D  9Dr(   False)r  checksumr  any_notnone_members) r`  r  r  r  r:  r  rk  r  r  sortr  r   rK   r   r>   
substituter_  r%  rN   rL   r   rz  create_to_py_utility_codecreate_from_py_utility_code_calculate_pickle_checksumspunycode_class_namerH  r[  r   r^  enter_scope
exit_scope)r#   r$   auto_pickle_forcedall_membersr7  cinitinherited_reducenon_pystructsr  pickle_funcr   all_members_namesr  r  unpickle_funcr=  s                   @r%   rn  z3AnalyseDeclarationsTransform._inject_pickle_methods  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  rC  )
r_  r  rw   r  r   r   rF   r$   r  r_  )r#   old_decoratorsr=  r$   r]  r_  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)rL   insertr  r  update_fused_defnode_entryr  	signatureuse_fastcallr   PyCFunctionNodefrom_defnoder  coerce_to_tempresulting_fused_function_create_assignmentr  fused_func_assignmentr  )r#   r]  r=  r$   pycfuncs        r%   _handle_defz(AnalyseDeclarationsTransform._handle_defG	  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   r]  N)rp  r  fused_functionrb  rW  r   rK   rG  r   rd   rN   rx   r:  rL  get_fused_typesr5  FusedCFuncDefNoder7   r  r  )r#   r=  r$   r  r   r]  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         rH|j        rAt          |j        d           d|_        t	          j        |j        g           |j        _        |j        S )NzFused generators not supportedFr   )is_generatorhas_fused_argumentsr   rK   r   rO   r  rN   r"   s     r%   _handle_fusedz*AnalyseDeclarationsTransform._handle_fusedy	  sX     	E!9 	E$(<===',D$#0DDDDJO''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 typer[  r   )UFuncs)r`  rV  r   r*  r  declare_argumentsrQ  r]  r  analyse_as_typerL  fused_to_specific
specializedeclare_varrK   r   r  r  rN   r_  rX  r	  r  rp  r  convert_to_ufunc)r#   r$   r=  lenvvar	type_noder:  r  s           r%   r  z.AnalyseDeclarationsTransform.visit_FuncDefNode	  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## 	7..sD99DDI**40000066D  """do%%      **4000r(   c                 ~   |                      |          }t          |t          j                  s|S |                                 }|j        3t          j        |          |_        |j                            |           |j	        s|j
        r|S |                    |          s|S ||                     ||          gS r    )r  rM   r   r   r`  code_objectr   CodeObjectNoder_  fused_py_funcis_generator_bodyneeds_assignment_synthesis_synthesize_assignmentr#   r$   r=  s      r%   r  z*AnalyseDeclarationsTransform.visit_DefNode	  s    %%d++$.. 	K  #(7==D11#666 	!7 	K..s33 	Kd11$<<==r(   c                     |j         W|j        Pt          j                            |          |_         |j                             |                                            |                     |          S r    )r  r  r   r  	for_cfuncr_  r`  r  r"   s     r%   r  z/AnalyseDeclarationsTransform.visit_CFuncDefNode	  sb    #(<(7AA$GGD11$2B2B2D2DEEE%%d+++r(   c                 ,    |                      |          S r    )r  r"   s     r%   visit_GeneratorBodyDefNodez7AnalyseDeclarationsTransform.visit_GeneratorBodyDefNode	  s    %%d+++r(   c                 R    |                      |          }|j        |j        _        |S r    )r  r  r  )r#   r$   r   s      r%   visit_GeneratorDefNodez3AnalyseDeclarationsTransform.visit_GeneratorDefNode	  s'    ##D))!%!1
r(   c                 r   |}|j         s|j        r|j        }|j         |j        |j         p| j                            d          }|j        r(t          j                            ||          x}|_	        n t          j
                            ||          }|j        |_        |                     |||          S )Nr  )is_py_class_scopeis_c_class_scopeouter_scopecurrent_directivesr   is_closure_scoper   InnerFunctionNoder  py_cfunc_noder  r  is_cyfunctionr  )r#   r$   r=  genvr  r   s         r%   r  z3AnalyseDeclarationsTransform._synthesize_assignment	  s    $ 	$(= 	$#D $ 	$(= 	$ 'Q4+B+F+Fy+Q+Q  	H'0'B'O'OPTV]'^'^^C$$$+88wGGC [&&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   )
r]  r   ru  rK   r_  r   r   r   rw   r_  )r#   r   r   r=  r_  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                                          |           | j                             |           d S r    )rV  r	  rA   visit_func_outer_attrsr   )r#   r$   stackrG   s      r%   r  z3AnalyseDeclarationsTransform.visit_func_outer_attrs	  sL    $((**&&t,,,##E*****r(   c                    |                                  }|                    |           |j        r| j                            t          | j        d                              |                     ||j                   |                    |j                   |                     |           | 	                                 | j        
                                 n*|                    |           |                     |           |S r\  )r`  r_  
expr_scoperV  r   r*  r  analyse_scoped_declarationsr7   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    r7   r_  r`  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 r4   )r6   rh  r"   s     r%   r8   z/AnalyseDeclarationsTransform.visit_CppClassNode
  s(    ?h&&4**4000r(   c                     	 d S r    )*r   r(  rK   r   r   r  r:  r  rk  r   rw   ru  init_assignmentr  r   struct_or_union_wrapperr   rO   r  	is_structr  rq  replacerL   rH  shadowrN   rM   r  CSimpleBaseTypeNoder   rx   kw_onlyr   r  r  rz  basic_pyobject_propertybasic_propertyr_  r`  r  )r#   r$   
self_valuerk  
attributesr  init_assignmentsattr
str_formatwrapper_class
class_bodyinit_methodarg_templater   templater  s                   r%   r2   z8AnalyseDeclarationsTransform.visit_CStructOrUnionDefNode	
  s    	4r(   c                 0    |                      |           |S r    r  r"   s     r%   r,   z2AnalyseDeclarationsTransform.visit_CDeclaratorNodeW
  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%   r.   z0AnalyseDeclarationsTransform.visit_CBaseTypeNode_
  s    tr(   c                      |j         dk    r|S d S )Npublic)r6   r"   s     r%   r0   z/AnalyseDeclarationsTransform.visit_CEnumDefNodeb
  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   r5   z,cdef variable '%s' declared after it is used)
rw   rV  r`  r  r6   r  r  r   rK   r7   )r#   r$   r  s      r%   visit_CNameDeclaratorNodez6AnalyseDeclarationsTransform.visit_CNameDeclaratorNodeh
  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_CVarDefNodeq
  s    4   tr(   c                     |                      |d          }|sd S t          |          t          u r|d         |_        |g|dd          z   S |S )Nr$   r   r   )r  r:  rO  r$   )r#   r$   
child_nodes      r%   visit_CnameDecoratorNodez5AnalyseDeclarationsTransform.visit_CnameDecoratorNodev
  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  )rK   r  r  )rK   r   )r6   r:  rz  r  r  basic_property_ror  r   r(  rK   r   rw   rL   r{   )r#   r  r  r  s       r%   rm  z,AnalyseDeclarationsTransform.create_Property
  s    x''z% /7.++-H&&	/EI4=4F59[a4b4b4b:?*F F F( 9	 '   $A	'
 
yr(   c                 ~    |                      |           |                    |                                            |S r    r  r"   s     r%   r=  z;AnalyseDeclarationsTransform.visit_AssignmentExpressionNode
  r  r(   ),r9   r:   r;   r   r>   r  r  r  r  r  r  rb  r  r  rP   r   r  rn  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r8   r2   r,   r&   r.   r0   r  r*   r  rm  r=  rh   ri   s   @r%   rQ  rQ  D  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 7   + + + + +  "  
1 1 1H7 H7 H7\  
          
    "      r(   rQ  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  )
r  encoder   version_infor5  r   	hexdigestAttributeError
ValueErrorr   )member_namesmember_names_stringhash_kwargsr  	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                      }|j        | _        |j        | _        |                     |           |S r    )	global_scoper  r  rA   r  rX  rh  _super_visit_ClassDefNoder7   )r#   r$   _superrG   s      r%   rP   z1CalculateQualifiedNamesTransform.visit_ModuleNode
  sZ    ,,..= (.(@%)/)B&4   r(   Nc                     |r%| j         d d          }|                    |           n| j         }t          d                    |                    |_        | j        |_        d S )Nr  )r  r   r   r  qualnamer  )r#   r$   rw   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_attrrw   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    )r0  rw   r7   r"   s     r%   visit_ClassNodez0CalculateQualifiedNamesTransform.visit_ClassNode
  s3    4+++4   r(   c                 Z    |                      |           |                     |           |S r    )r0  r7   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	  r0  rw   r7   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	  r0  rX  rw   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 )Nrw   z<lambda>r;  )r  r5  r   r4  r  rX  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          |          |d          }t          j        |j        |          }|j        j        	                    dt          j        |j        ||                              |                                                      d S )NT)rw   r  	is_targetru   r   r   )r  r  r   r   rK   r   rq  rN   rL   r  r   r   analyse_expressionsr`  )r#   r$   rw   rv   r  r   r   s          r%   generate_assignmentz4CalculateQualifiedNamesTransform.generate_assignment
  s    
&&t,, Ht$$	  
 #DHE:::	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  r5  r`  r  r   rw   r4  r,  rE  r   r  r  )r#   r$   orig_needs_qualname_assignmentorig_needs_module_assignmentr>  r  s         r%   rh  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:   )r`  r  rw   rG  rH  )r#   r$   r  s      r%   r  z/CalculateQualifiedNamesTransform.visit_NameNode  sR      ""! 		4 yN**15..l**/3,r(   r    )r9   r:   r;   r<   rG  rH  rP   r0  r4  r6  r8  r?  r  r  rE  rh  r  rh   ri   s   @r%   r)  r)  
  s          !&#    , , , ,3 3 3  
  	 	 	  	 	 	3 3 3  *      r(   r)  c                   8    e Zd Zd Zd Zd Zd Zd Zd Zd Z	dS )	AnalyseExpressionsTransformc                     |j                                          |j                            |j                   |_        |j        hg| _        |                     |           |                     |           |S r    )r  infer_typesrN   rD  rK   	positionsr7   _build_positionsr"   s     r%   rP   z,AnalyseExpressionsTransform.visit_ModuleNode*  si    
   I11$*==	8*4   d###r(   c                    |j                                          |j                            |j                   |_        | j        d                             |j                   |j        r| j        d         }n|j        h}| j                            |           | 	                    |           | 
                    |           |S r\  )r  rO  rN   rD  rP  rG  rK   r<  r   r7   rQ  )r#   r$   local_positionss      r%   r  z-AnalyseExpressionsTransform.visit_FuncDefNode2  s    $$&&&I11$2BCC	rtx(((? 	)"nR0OO#xjOo...4   d###r(   c                     |j         r3|j                                         |                    |j                  }|                     |           |S r    )r   r  rO  analyse_scoped_expressionsrT   r"   s     r%   r  z0AnalyseExpressionsTransform.visit_ScopedExprNodeB  sP     	DO'')))224?CCDD!!!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.
        )rT   is_fused_indexr:  is_errorr   r"   s     r%   visit_IndexNodez+AnalyseExpressionsTransform.visit_IndexNodeI  s;     	D!!! 	ty'9 	9Dr(   c                 z    | j         d                             |j                   |                     |           |S r\  rP  rG  rK   r7   r"   s     r%   rT   z*AnalyseExpressionsTransform.visit_ExprNode\  8    rtx(((4   r(   c                 z    | j         d                             |j                   |                     |           |S r\  r[  r"   s     r%   rW   z*AnalyseExpressionsTransform.visit_StatNodea  r\  r(   c                    t          | j                                        t          dd          d          }d}d}g }|D ].\  }}}|                    |||||k    r|n|dz   f           ||}}/|                                 ||_        |                                 d t          |          D             |j        _	        dS )	zg
        Build the PEP-626 line table and "bytecode-to-position" mapping used for CodeObjects.
        r   r   T)r^  reverser   r   c                     i | ]\  }}||	S r!   r!   )r   r`  positions      r%   
<dictcomp>z@AnalyseExpressionsTransform._build_positions.<locals>.<dictcomp>  s.     :
 :
 :
8 a:
 :
 :
r(   N)
r  rP  r	  r   r   r_  node_positionsr[  r  node_positions_to_offset)	r#   	func_noderP  	next_linenext_column_in_linerangesr   r  start_columns	            r%   rQ  z,AnalyseExpressionsTransform._build_positionsf  s     !N  1a  	
 
 
	 	%. 	@ 	@!At\MM4|DT]L]L]5H5Hcorscstuuu-1<*II#)	 :
 :
(33:
 :
 :
	666r(   N)
r9   r:   r;   rP   r  r  rY  rT   rW   rQ  r!   r(   r%   rM  rM  (  s}                 &  
  

 
 
 
 
r(   rM  c                   &    e Zd Zd Zd Zd Zd ZdS )FindInvalidUseOfFusedTypesc                 >    d| _         |                     |           |S r@   )_in_fused_functionr%  )r#   trees     r%   r  z#FindInvalidUseOfFusedTypes.__call__  s!    "'

4r(   c                 0    |                      |           d S r    r  r"   s     r%   r   z%FindInvalidUseOfFusedTypes.visit_Node  r!  r(   c                     | j         }|j        | _         | j         s(|j        s!|j        j        rt          |j        d           |                     |           || _         d S )Nz-Return type is not specified as argument type)rm  r  r  return_typerL  r   rK   r7   )r#   r$   outer_statuss      r%   r  z,FindInvalidUseOfFusedTypes.visit_FuncDefNode  sr    ."&":& 	Q ) Qd.>.G Qdh OPPP4   ".r(   c                     | j         s*|j        r#|j        j        rt          |j        d           d S |                     |           d S )Nz6Invalid use of fused types, type cannot be specialized)rm  r:  rL  r   rK   r7   r"   s     r%   rT   z)FindInvalidUseOfFusedTypes.visit_ExprNode  sW    & 	%49 	%9K 	%$(TUUUUU t$$$$$r(   N)r9   r:   r;   r  r   r  rT   r!   r(   r%   rk  rk    sP          
! ! !/ / /% % % % %r(   rk  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          }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
        r8 | j        |          \  }}t          j        | j	        || j                  |fS t          | t          j                  rt!          d          t          |           } | | gfS )N)r   indexsetting)r  r  z@Don't allow things like attributes of buffer indexing operations)r  r:  rz  r
   is_subscriptr   rx  r   	IndexNoderK   r  r  r(  r  rM   BufferIndexNoder"  )r$   rz  r   tempsrx  r  side_effect_free_references         r%   r  zVExpandInplaceOperators.visit_InPlaceAssignmentNode.<locals>.side_effect_free_reference  s   | $Rx& $w $!$''dV|#" $88CCe"4:.. *48$eLLLeW\V]o]]" $77'RRR
U .txSDN[[[]bbbD)";<< $ !cddd!$''dV|#r(   Try  )r  operand1operand2inplacer   rg   r!   )r   r   r:  is_cpp_classrM   r   r}  r`  r"  rG   rs  
binop_noderK   r  rC  analyse_target_typesanalyse_typesanalyse_operationr   r   	coerce_tor_  r	   )
r#   r$   r   r   r=  let_ref_nodesdupbinoptr  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%   rT   z%ExpandInplaceOperators.visit_ExprNode  r  r(   N)r9   r:   r;   r  rT   r!   r(   r%   ru  ru    s3        4 4 4l    r(   ru  c                   @    e Zd 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
    @cython.critical_section
    )r   total_orderingrd  c                 V    |j         | _         d| _        |                     |           |S r@   )r  in_py_classr7   r"   s     r%   rP   z&AdjustDefByDirectives.visit_ModuleNode  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}| j                             d
          rd| j         vrt	          |j        d           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  rX  rY  r2  FTreturnsannotation_typingrR   c_compile_guardrZ  z+c_compile_guard only allowed on C functionsccallz-cfunc and ccall directives cannot be combinedz-ccall functions cannot be declared 'with_gil')overridabler  rX  r  
except_valhas_explicit_exc_clausez#cfunc directive is not allowed here)r  r  rX  rY  r  r  r  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   rK   as_cfunctionr%  r  r  )r#   r$   r  rX  rY  r  r  return_type_nodes           r%   r  z#AdjustDefByDirectives.visit_DefNode  ss   	t&&X&&&##G,,?&&z22_((55
+5+=%%4?..y99#8K(L##:+
0B)
(8 CeDJ?011 	KgT_6T6T$(IJJJ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t$$$r(   c                    d| j         v rf| j         d         }|t          |j        d           t          j        |j        t          j        |j        |          g|j                  }||_        |                     |           |S )Nrl  z2critical_section decorator does not take arguments)re  ry  )	r  r   rK   r   rz  r   #FirstArgumentForCriticalSectionNoderN   r7   )r#   r$   rv   new_bodys       r%   r  z'AdjustDefByDirectives.visit_FuncDefNode-  s    00O$67E dh TUUU4CDHX\]]]^Y  H
 !DI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%   ru  z=AdjustDefByDirectives.visit_PyClassDefNode.<locals>.<genexpr>@  s*      UU	yDO+UUUUUUr(   T)anyconverts_to_cclass	as_cclassr%  r  r7   r#   r$   old_in_pyclasss   `  r%   rV  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 r@   )r  r7   r  s      r%   r  z)AdjustDefByDirectives.visit_CClassDefNodeJ  s3    ) 4   )r(   N)r9   r:   r;   r<   r  rP   r  r  r  r   rV  r  r!   r(   r%   r  r    s        	 	 O    , , ,\    	 	 	    r(   r  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  r7   r"   s     r%   rP   z)AlignFunctionDefinitions.visit_ModuleNodeX  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  rw   	is_cclassr  r  is_builtin_scoper   rK   r#   r$   pxd_defs      r%   rV  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  rH  defined_in_pxdr:  r7   r#   r$   r  r  s       r%   r  z,AlignFunctionDefinitions.visit_CClassDefNodei  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  rw   r  is_cfunctionr   rK   r  r  s      r%   r  z&AlignFunctionDefinitions.visit_DefNodev  s    *##DI.. 	.GM 	.1O 	.' dh 1DI =>>>; D'+'BCCCt$$W--D r(   c                     |S r    r!   r"   s     r%   rT   z'AlignFunctionDefinitions.visit_ExprNode  r  r(   r    )	r9   r:   r;   r<   rP   rV  r  r  rT   r!   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  r7   r"   s     r%   rP   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  rw   r   is_cdef_func_compatibler  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  r]  r   rG  )r#   r$   rw   r   s       r%   r  z5AutoCpdefFunctionDefinitions.visit_FromImportStatNode  sE     :% 	.: . .a#''----r(   c                     |S r    r!   r"   s     r%   rT   z+AutoCpdefFunctionDefinitions.visit_ExprNode  r  r(   r    )r9   r:   r;   rP   r  r  r  rT   r!   r(   r%   r  r    sd                     r(   r  c                   2    e Zd Zd Zd Zd Zd Zd Zd ZdS )RemoveUnreachableCodec                 
   | j         d         s|S |                     |           t          |j                  dk    rAt	          |j        d         t
          j                  r|j        d         j        s
|j        d d = 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   r   warn.unreachableUnreachable coder   T)r  r7   r   rL   rM   r   rO   r[  r@  r   rK   )r#   r$   idxr+  s       r%   rZ   z(RemoveUnreachableCode.visit_StatListNode  s   &';< 	K4   tz??aJtz!}e>P$Q$QZ^ZdefZgZm
111"4:q11 	 	IC! TZ((./AB L
3 35GKKK!%DSD!1DJ%)" r(   c                 V    |                      |           |j        j        rd|_        |S rR   )r7   rN   r@  r"   s     r%   visit_IfClauseNodez(RemoveUnreachableCode.visit_IfClauseNode  s0    4   9" 	&!%Dr(   c                     |                      |           |j        r&|j        j        r|j        D ]}|j        s nd|_        |S rR   )r7   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   )r7   rN   r@  r  r  r   rK   r"   s     r%   visit_TryExceptStatNodez-RemoveUnreachableCode.visit_TryExceptStatNode  se    4   9" 	$t'7 	$&'9: E(,.@!DDD#Dr(   c                 V    |                      |           |j        j        rd|_        |S rR   )r7   r   r@  r"   s     r%   visit_TryFinallyStatNodez.RemoveUnreachableCode.visit_TryFinallyStatNode  s1    4   , 	&!%Dr(   c                 V    | j         d         st          j        |j        g           }|S )zEliminate useless PassStatNode	linetracerJ   )r  r   rO   rK   r"   s     r%   visit_PassStatNodez(RemoveUnreachableCode.visit_PassStatNode  s0     &{3 	>%$("===Dr(   N)	r9   r:   r;   rZ   r  r  r  r  r  r!   r(   r%   r  r    sn                       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                                                       g | _        g | _        g | _        g | _        d| _        d| _        d| _        || _	        d S r@   )
rA   rB   yieldsr  finallysexceptshas_return_valuer~   r   excludes)r#   r  rG   s     r%   rB   zYieldNodeCollector.__init__  sV     % r(   c                 F    || j         vr|                     |           d S d S r    )r  r7   r"   s     r%   r   zYieldNodeCollector.visit_Node  s1    t}$$t$$$$$ %$r(   c                 r    | j                             |           d| _        |                     |           d S rR   )r  r   r~   r7   r"   s     r%   visit_YieldExprNodez&YieldNodeCollector.visit_YieldExprNode  9    4   4     r(   c                 r    | j                             |           d| _        |                     |           d S rR   )r  r   r   r7   r"   s     r%   visit_AwaitExprNodez&YieldNodeCollector.visit_AwaitExprNode  r  r(   c                     |                      |           |j        rd| _        | j                            |           d S rR   )r7   rv   r  r  r   r"   s     r%   visit_ReturnStatNodez'YieldNodeCollector.visit_ReturnStatNode  sD    4   : 	)$(D!D!!!!!r(   c                 d    |                      |           | j                            |           d S r    )r7   r  r   r"   s     r%   r  z+YieldNodeCollector.visit_TryFinallyStatNode  s2    4   T"""""r(   c                 d    |                      |           | j                            |           d S r    )r7   r  r   r"   s     r%   r  z*YieldNodeCollector.visit_TryExceptStatNode  s2    4   D!!!!!r(   c                     d S r    r!   r"   s     r%   rh  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    )rM   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(   )r9   r:   r;   rB   r   r  r  r  r  r  rh  r  r   r   r  rh   ri   s   @r%   r|   r|     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 r@   )needs_closurer  r7   r"   s     r%   rP   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        |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%   ru  z7MarkClosureVisitor.visit_FuncDefNode.<locals>.<genexpr>G  s)      CCq
CCCCCCCr(   z/'await' not allowed in generators (use 'yield')r   )rK   rw   rN   is_coroutine_bodyis_async_gen_body)rK   rw   rx   ry   rz   r{   r]  r  lambda_namer  r   )#r  r7   r|   r  r   r   AsyncDefNoder~   AsyncGenNoder  r  in_async_genr  IterableAsyncDefNoder   nextr   rK   GeneratorDefNoder[  	label_numr  r  in_generatorGeneratorBodyDefNoderw   rN   rx   ry   rz   r{   r]  r  r  r   )
r#   r$   r   coroutine_type
yield_exprfoundr`  retnoder  	coroutines
             r%   r  z$MarkClosureVisitor.visit_FuncDefNode5  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  r7   r  r   rK   r"   s     r%   r  z%MarkClosureVisitor.visit_CFuncDefNodea  s`    "4   !/! 	Q$"2 	Q$(OPPPr(   c                 d    d| _         |                     |           | j         |_         d| _         |S )NFT)r  r7   r"   s     r%   r   z#MarkClosureVisitor.visit_LambdaNodej  s6    "4   !/!r(   c                 >    |                      |           d| _        |S rR   )r7   r  r"   s     r%   rh  z%MarkClosureVisitor.visit_ClassDefNodeq  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  rM   r   r   r  r   r   r  rF  r  r%  )r#   r$   r  itseqs       r%   r   z0MarkClosureVisitor.visit_GeneratorExpressionNodev  s    =di!566 	1!Y/0DM$$T** $)U%9:: 	 K	"+ 	K+D1177>>>r(   N)	r9   r:   r;   rP   r  r  r   rh  r   r!   r(   r%   r  r  +  so          * * *X      
    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                 f    t                                          |           g | _        d| _        d S r@   )rA   rB   pathrb  rE   s     r%   rB   zCreateClosureClasses.__init__  s-    !!!	r(   c                 H    |j         | _        |                     |           |S r    )r  r  r7   r"   s     r%   rP   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_scopesrF  r]  from_closurer   r  )r#   r$   r  r  r  rw   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  __)rw   rK   definingimplementingno_gc_clearfreelist)rK   rw   r  r:  is_cdefr   )/r  r  r  rF  r,  r  r2  
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_classrK   r:  is_final_typeis_internalis_closure_class_scoper   r  r   closure_freelist_sizer  r  outer_scope_cnamein_subscoperw   is_declared_genericcheck_c_class)r#   r$   target_module_scope
inner_noder  r  r  r  
func_scopecscoper  class_scoperw   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 rR   )rM   r   r   r   rb  r7  r  r7   )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    )rb  r7   r  r  r7  r  r   r	  r"   s     r%   r  z&CreateClosureClasses.visit_FuncDefNode  s    > 	t$$$K 	 	((t/@AAAIT"""t$$$IMMOOOr(   c                 0    |                      |           |S r    r  r"   s     r%   r  z/CreateClosureClasses.visit_GeneratorBodyDefNode      4   r(   c                 h    |j         s|                     |          S |                     |           |S r    )r  r  r7   r"   s     r%   r  z'CreateClosureClasses.visit_CFuncDefNode  s:     	))$///t$$$Kr(   c                 Z     t                      |          }|                     |          S r    )r  r   r"   s     r%   r   z2CreateClosureClasses.visit_GeneratorExpressionNode  s,    *(**400$$T***r(   r    )r9   r:   r;   rB   rP   r  r7  r   r  r  r  r   rh   ri   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.rk  rs  rN   )rX  r   rw  rK   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 )NrX  )rX  rs  r7   r#   r$   	was_nogils      r%   visit_GILStatNodez#InjectGilHandling.visit_GILStatNode5  s7    J	jG+
4   
r(   c                     | j         }t          |j        t          j                  r|j        j         o|j        j         | _         |                     |           || _         |S r    )rX  rM   r  r   CFuncDeclaratorNoderY  r7   rE  s      r%   r  z$InjectGilHandling.visit_CFuncDefNode<  sZ    J	dou'@AA 	P.Ot7O3ODJ4   
r(   c                 d    | j         }|j         | _         |                     |           || _         |S r    )rX  r7   rE  s      r%   visit_ParallelRangeNodez)InjectGilHandling.visit_ParallelRangeNodeD  s2    J	Z
4   
r(   c                     |S r    r!   r"   s     r%   rT   z InjectGilHandling.visit_ExprNodeK  r  r(   N)r9   r:   r;   r<   rX  rC  visit_RaiseStatNodevisit_PrintStatNoderG  r  rK  rT   r   r  r   r!   r(   r%   r@  r@    s          E   /.         "5JJJr(   r@  c                   d     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 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| _        t          j        j        | _        t          j        j        | _        t                                          |          S r    )	r  	env_stackr   
NoGilStateHasGilnogil_state"nogil_state_at_current_gilstatnoderA   r  )r#   rY  rG   s     r%   r  zGilCheck.__call__\  sB    * +2272B2I/ww%%%r(   c                 @   | j         }|j        }|rgt          | j                  dk    rO| j        d         j        rt
          j        j        nt
          j        j        | _         | 	                    ||           || _         | 	                    |d |           || _         d S )Nr   r   )
rU  outer_attrsr   rR  rX  r   rS  NoGilrT  r7   )r#   r$   rU  rF  rY  s        r%   _visit_scoped_childrenzGilCheck._visit_scoped_childrenc  s    $	& 	23t~..22*..*<*B_ &&HXH_ t[111&4t[AAA$r(   c                 V   | j                             |j                   |j        j        }| j        }|rt
          j        j        | _        |r!|j        r|                    |j                   | 	                    || j                   || _        | j         
                                 |S r    )rR  r   r  rX  rU  r   rS  
NoGilScopenogil_checkr[  r	  )r#   r$   inner_nogilrU  s       r%   r  zGilCheck.visit_FuncDefNodeo  s    d.///&,& 	;$/:D 	/4+ 	/T-...##D$*:;;; 'r(   c                    |j         $t          |j         j        d|j        z             |S | j        r|j        r|                                 | j        }|j        dk    }||k    rG| j        t          j        j        k    s-|st          |j        d           nt          |j        d           | j        t          j        j        k    rd|_	        t          |j        t          j                  r|j        j        \  |_        | j        }| j        | _        |rt          j        j        nt          j        j        }|                     ||           || _        |S )Nz<Non-constant condition in a `with %s(<condition>)` statementrX  z3Trying to acquire the GIL while it is already held.z;Trying to release the GIL while it was previously released.F)rt  r   rK   rs  rU  r^  r   rS  r]  scope_gil_state_knownrM   r   rO   rL   rV  rZ  rT  r[  )r#   r$   rF  is_nogilrV  rU  s         r%   rG  zGilCheck.visit_GILStatNode  st   >%$.$57;zBC C C K 	 0 	$	J')  )9U=M=X)X)X 8dh !0 1 1 1 1 dh !7 8 8 8u/:::).D&d)5+=>> 	= $(#6#< D-1-T*262B/08Ue&,,e>N>U##D+6662T/r(   c                    |j         s| j        t          j        j        k    rc|j         dc}|_         t          j        |j        d|          }|s!| j        t          j        j        k    rd|_        |                     |          S | j        st          |j        d           d S |
                    | j        d                    |                     |           |S )NFrX  rB  z)prange() can only be used without the GILr   )rX  rU  r   rS  r]  rw  rK   ra  rG  r   r^  rR  r7   )r#   r$   node_was_nogils      r%   rK  z GilCheck.visit_ParallelRangeNode  s    : 	0)U-=-HHH)-U&NDJ$TXW4HHHD! 3d&6%:J:U&U&U .3*))$/// 	$(GHHH4+,,,4   r(   c                 ^   | j         st          |j        d           d S | j         t          j        j        k    r8t          j        |j        d|          }d|_        |                     |          S |j	        r |	                    | j
        d                    |                     |           |S )Nz5The parallel section may only be used without the GILrX  rB  Fr   )rU  r   rK   r   rS  r]  rw  ra  rG  r^  rR  r7   r"   s     r%   visit_ParallelWithBlockNodez$GilCheck.visit_ParallelWithBlockNode  s     	$( & ' ' '4u/::: $TXW4HHHD).D&))$/// 	1 T^B/0004   r(   c                     | j         s|                     |          S d|_        d|_        |                     |           |S )zM
        Take care of try/finally statements in nogil code sections.
        NT)rU  r   r^  is_try_finally_in_nogilr7   r"   s     r%   r  z!GilCheck.visit_TryFinallyStatNode  sJ      	)??4((('+$4   r(   c                 ,    |                      |          S r    r   r"   s     r%   visit_CriticalSectionStatNodez&GilCheck.visit_CriticalSectionStatNode      t$$$r(   c                 ,    |                      |          S r    rj  r"   s     r%   visit_CythonLockStatNodez!GilCheck.visit_CythonLockStatNode  rl  r(   c                 r    | j         t          j        j        k    rd|_        |                     |           |S r@   )rV  r   rS  r]  ra  r7   r"   s     r%   visit_GILExitNodezGilCheck.visit_GILExitNode  s7    2e6F6QQQ).D&4   r(   c                    | j         r.| j        r'|j        r |                    | j         d                    |j        r|                     || j                   n|                     |           | j        r| j        |_        |S r\  )rR  rU  r^  rY  r[  r7   in_nogil_contextr"   s     r%   r   zGilCheck.visit_Node  s    > 	1d. 	143C 	1T^B/000 	%''d.>????t$$$ 	5$($4D!r(   c                    |j         r|j         j        j        r|j        j        r|j        j        dk    rt          |j                  dk    r|d }| j        t          j
        j        k    rd}n| j        t          j
        j        k    rd}|r?t          j        |j        |j        j        j        |z   |j        j        |j         g          }|                     |          S )Nacquirer   NogilGilr  )r#   r:  is_cython_lock_typer"  r  r  r   rx   rU  r   rS  rZ  rT  r   PythonCapiCallNoderK   r  r  r   )r#   r$   suffixs      r%   visit_SimpleCallNodezGilCheck.visit_SimpleCallNode  s    I 	$).< 	*	/3}/F)/S/SDI!## F5#3#999 !U%5%<<<  3HM'-6M&)	   t$$$r(   )r9   r:   r;   r<   r  r[  r  rG  rK  rf  r  rk  rn  rp  r   rz  rh   ri   s   @r%   rP  rP  R  s         & & & & &
% 
% 
%  (! ! !F  &  (
 
 
% % %% % %  	 	 	% % % % % % %r(   rP  c                   0    e Zd ZdZd 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_result() and ExprNode.lhs_result()???
    c                 b    |                                  j        r|                     |           |S r    )r`  r6  r7   r"   s     r%   rP   zCoerceCppTemps.visit_ModuleNode  s2    ! 	%t$$$r(   c                     |                      |           |                                 j        d         r@|                                r,|j        j        r |j        j        st          j        |          }|S )N
cpp_locals)	r7   r`  r  result_in_tempr:  r  is_fake_referencer   CppOptionalTempCoercionr"   s     r%   rT   zCoerceCppTemps.visit_ExprNode  sy    4   ),7 	;##%%	;*.)*@	; I/	; 4T::Dr(   c                     |S r    r!   r"   s     r%   visit_CppOptionalTempCoercionz,CoerceCppTemps.visit_CppOptionalTempCoercion!  r'   r(   c                     |S r    r!   r"   s     r%   visit_CppIteratorNodez$CoerceCppTemps.visit_CppIteratorNode$  r'   r(   c                 :    |                      |j                   |S r    )r7   rb   r"   s     r%   re   z!CoerceCppTemps.visit_ExprStatNode'  s    49%%%r(   N)	r9   r:   r;   r<   rP   rT   r  r  re   r!   r(   r%   r|  r|    si                     r(   r|  c                        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 fdZ fdZd Zd Z xZS )TransformBuiltinMethodsz
    Replace Cython's own cython.* builtins by the corresponding tree nodes.
    Also handle some Python special builtin functions (e.g. super()/locals())
    that require introspection by the compiler.
    c                 H     t                      j        |i | i | _        d S r    )rA   rB   def_node_body_insertions)r#   rx   r,  rG   s      r%   rB   z TransformBuiltinMethods.__init__3  s-    $'$'''(*%%%r(   c                 B    |j         rd S |                     |           |S r    )declaration_onlyr7   r"   s     r%   r   z2TransformBuiltinMethods.visit_SingleAssignmentNode7  s+      	4t$$$Kr(   c                 V    |                      |           |                     |          S r    )r7   visit_cython_attributer"   s     r%   r  z+TransformBuiltinMethods.visit_AttributeNode>  s*    4   **4000r(   c                     |j         dk    r@|                                 }|                    d          }|s|                     |          }|                     |          S )NrG   )rw   r`  r  _inject_classr  )r#   r$   r  r  s       r%   r  z&TransformBuiltinMethods.visit_NameNodeB  sb    9$$##%%D$$\22E 0))$//**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   )r  ru   r  )r*  	frozensetr  rw   r  z>'%s' not a valid cython attribute or is being used incorrectly)r  rp  r  r   rq  rK   r   NullNoder   r`  builtin_scoper  r   r  rF   cython_scopelookup_qualified_namer   )r#   r$   r  versions       r%   r  z.TransformBuiltinMethods.visit_cython_attributeJ  s-   ,,..	 	nM))555555 ,TX]7=S=STTTf$$ )$(33BBB )$(y9Q9Q040@0@0B0B0P0P0R0R0^0^_h0i0ik k k,Y77 n*@@KK ndh `cl lmmmr(   c                    |                                  }|                     |           t          |j                  dk    r}|j                            t          j        |j                             |j        sE|j                            t          j	        |j        | 
                                |                     |S r@  )r`  r7   r   rx   r   r   GlobalsExprNoderK   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)rN  varsrN  r   zGBuiltin 'locals()' called with wrong number of args, expected 0, got %dr  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%   ru  z9TransformBuiltinMethods._inject_locals.<locals>.<genexpr>  s+       W Wcch W W W W W W Wr(   c                 <    g | ]}t          j        |           S )ru   )r   IdentifierStringNode)r   r  rK   s     r%   r   z:TransformBuiltinMethods._inject_locals.<locals>.<listcomp>  s9     - - - 3CsCCC - - -r(   r  )r`  r  rK   r   rx   r   r   r  r  r  r  r  r%  r  SortedDictKeysNoder  rF  r,  r  )
r#   r$   	func_namer  r  r   locals_dictlocal_namesr]  rK   s
            @r%   _inject_localsz&TransformBuiltinMethods._inject_localsh  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)r7   r  rM   r  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    )r  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 r@  )r`  r  r   rx   
is_builtinr   r   r  rK   r  r  r  )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           	      B   |                                  }t          |t          j                  s|S d x}x}}t	          | j                  D ]i\  }}t          |t          j                  r|}|} nEt          |t          j                  r|}|j        }|}	Kt          |t          j                  r|}|}	j|r|s|S || j	        vr|j
        j        }
|j        r't          j        |
|j        j        |j                  }n?|j        r6t          j        |
|d u          }|rd|_        nd|_        d|j        _        n|S t          j        |
t          j        |
t1          d                    |          }|                    |	           || j	        vsJ || j	        |<   |S )Nr  r  TrG   r   r   )r  rM   r   FuncDefNodereversedrR  ClassDefNoder  r  r  rN   rK   r  r   r   r  rw   r  r  ClassCellNoderequires_classobj
class_cell	is_activer   r   r_  )r#   r$   current_def_node	fdef_node
class_nodegenerator_node
stack_nodestack_scoper5  
fdef_scoperK   r   r   s                r%   r  z%TransformBuiltinMethods._inject_class  s   2244*E,=>> 	K 376	6J'/'?'? 	) 	)#J*e&899 
)'
)J(>?? )!+&,	(

J(9:: )&	(
 	
 	K D999.$C+   (j&6&;","24 4 4 . -cVZ@Z[[[! 77;N4426I/26
%//4S&s{1K1KLLL  K ,,Z888D$AAAAA7BD))4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   rX  Tr  r   r   r  )r`  r  rx   r  rM   r   r   r   rR  r  r  r  r  r   r  rK   r  r   rw   r  r  r  )r#   r$   r  r  r  r   r  r5  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                             |d           }|rot          |j        t          j                  r"|j        j                            d|           d S t	          j        |j        j        ||j        g          |_        d S d S )Nr   r   )	r  r	  rM   rN   r   rO   rL   r  rK   )r#   r$   body_insertions      r%   _do_body_insertionz*TransformBuiltinMethods._do_body_insertion   s    6::4FF 	R$)U%788 R	&&q.99999!.ty}6Ddi5PR R R					R 	Rr(   c                 t    t                                          |          }|                     |           |S r    )rA   r  r  r  s     r%   r  z)TransformBuiltinMethods.visit_FuncDefNode	  s3    ww((..%%%r(   c                 t    t                                          |          }|                     |           |S r    )rA   r  r  r  s     r%   r  z2TransformBuiltinMethods.visit_GeneratorBodyDefNode  s3    ww11$77%%%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)r  r  r  Dcast() takes exactly two arguments and an optional typecheck keywordFr:  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)dirrN  r  evalrA   )r"  r  r  r  r   rx   r   rK   r  r  r`  r   TypecastNodeSizeofTypeNodeSizeofVarNoder  	cdivisionr   r   rF   r  r  r7   rM   ru  r  rw   r  r  r  )r#   r$   r"  r:  r  s        r%   rz  z,TransformBuiltinMethods.visit_SimpleCallNode  s   =4466 5	O6HHHty>>Q&&$-+-NQY-YZZZZ6HR)49Q<A A ADD8KKKty>>Q&&$-+-ORZ-Z[[[[6I(S)DIaL49UV<Y Y YDDV##ty>>Q&&$-+`b b b b  9Q<778H8H8J8JKKD >(5 M-D$)A,Z_ a  a  a dil.====X%%ty>>Q&&$-+-RSSSS9Q<778H8H8J8JKKD `(78ITXYYY(6t}7HRVR[\]R^___V##ty>>Q&&$-+-QRRRR$/0A3	RSVZV_`aVbccD%)DNNV##ty>>Q&&$-+-QRRRR$/0A3	RSVZV_`aVbccD%)DNNU"" ) 248-PUBVBV W W W^++ ) 248-P^B_B_ ` ` `*@@JJ Odm'BXMO O O 	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   r  r  r   Fr  r  )r"  r  r  rx   r  r7  r   r   rK   r  r`  r   r   r  r7   )r#   r$   r"  rx   r  r:  r  s          r%   visit_GeneralCallNodez-TransformBuiltinMethods.visit_GeneralCallNodeY  s>   =4466v',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(   )r9   r:   r;   r<   rB   r   r  r  r  r  r  r  r  r  r  r  r  r  r  rz  r  rh   ri   s   @r%   r  r  -  sO        
+ + + + +  1 1 11 1 1  &	 	 	%7 %7 %7N	 	 	/ / /  9 9 9v  6R R R    
    
D D DL      r(   r  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                                                       || _        ddlm}  |d          | _        d S )Nr   )ConstantFoldingT)
reevaluate)rA   rB   r  Optimizer  r  )r#   r  r  rG   s      r%   rB   zReplaceFusedTypeChecks.__init__{  sK    &------(D999r(   c                 V    |                      |           |                     |          S )zc
        Filters out any if clauses with false compile time type check
        expression.
        r7   r  r"   s     r%   r  z'ReplaceFusedTypeChecks.visit_IfStatNode  s*    
 	4   ~~d###r(   c                 V    |                      |           |                     |          S )z9
        Fold constant condition of GILStatNode.
        r  r"   s     r%   rG  z(ReplaceFusedTypeChecks.visit_GILStatNode  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)ignoreFru   )isis_not==z!=)r  r  )inr  zType is fusedz-Can only use 'in' or 'not in' on a fused typer  r  )r   local_errorsr  r  r  r  r   r  rK   specialize_typer  same_asrM   r   CTypedefTypetypedef_base_typerL  r   get_specialized_types)r#   r$   type1type2
false_node	true_nodeopis_sameeqtypesspecialized_types              r%   r  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#   r:  rK   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(   )r9   r:   r;   r<   rB   r  rG  r  r  r   rh   ri   s   @r%   r  r  p  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                      | _        | j        j        | _        |j        | _        g | _	        d| _
        d S r@   )rA   rB   r*  visitedrF   gdb_debug_outputwritertbc_filec_output_filenested_funcdefsregister_stepinto)r#   rF   optionsr   rG   s       r%   rB   zDebugTransform.__init__  sX    !!!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%  rK   r  r  startr7   r  r  r   serialize_modulenode_as_functionendr  rF  r]  r  r  rw   r  r:  r  rI  serialize_local_variables)r#   r$   r   nested_funcdefrF  r  r  s          r%   rP   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<  Frp  rw   z	<unknown>r   )rw   r  pf_cnamer  linenoFunctionr   Locals	ArgumentsStepIntoFunctionsT)r  rG  r  r  r5  r  r  r   r  r  
func_cnamepyfunc_cnamer%  rw   r  rK   r  r  r  rF  r  arg_entriesr7   )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  r:  r  r5  r  r  r%  r  r  r  r7   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   rp  1True)rw   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_functionO  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  rF  r  r  r7   r"  s      r%   r'  z0DebugTransform._serialize_modulenode_as_function`  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   )rw   r  r  r:  r  LocalVar)r,  r  r:  rz  r  r   cur_scope_cnameouter_entryr  r  r  rw   r  rK   r  r%  r  r  r  )r#   rF  r  vartyper  qnamer  r   s           r%   r  z(DebugTransform.serialize_local_variablesr  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(   )r9   r:   r;   r<   rB   rP   r  r  r  r'  r  rh   ri   s   @r%   r  r    s         ' ' ' ' ' & & &P/ / /b  $  "     $+$ +$ +$ +$ +$ +$ +$r(   r  r!   )Mr  r  r^  r   r   r   r  r   rp  r   r   r   r   r   r   r   r  r   r   r   r   r   r   r	   r
   r   StringEncodingr   r   r   r   r   r   r>   rk   r   r   r   rm   r  r   r   r   ri  rZ  rO  r   rt  r  r  r  r  r  r  r  r   r3  r;  rQ  r  r)  rM  rk  ru  r  r  r  r  r|   r  r  r@  rP  r|  r  r  r  r!   r(   r%   <module>r5     sP	     " " "&& " "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 * * * * * * * * & & & & & & ) ) ) ) ) ) ? ? ? ? ? ? ? ? ? ? ? ?       BI I I I IO I I IX ) ( ( ( (\ ( ( ( ^ E Q J, J, J, J, J,& J, J, J,Z! ! ! ! !K ! ! !<V! V! V! V! V!; V! V! V!r,8 ,8 ,8\" " "D	 	 	 H# H#d H# H# H# H#V $@ $@4 $@SW $@cg $@ $@ $@ $@N6 6 6 6 6?$4 6 6 6r6 6 6 6 6+-= 6 6 6*y	% y	% y	% y	% y	%/ y	% y	% y	%xl' l' l' l' l'_.> l' l' l'^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,( ,( ,( ,( ,(0@ ,( ,( ,(^6 6 6 6 6/ 6 6 6rO	 O	 O	 O	 O	< O	 O	 O	d  $} } } } }| } } }@]
 ]
 ]
 ]
 ]
/ ]
 ]
 ]
@% % % % % % % %>: : : : :\ : : :zk k k k kO-= k k k\3 3 3 3 3 3 3 3l) ) ) ) )? ) ) )X5 5 5 5 5O 5 5 5p< < < < < < < <~Z Z Z Z Z Z Z Zz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s% s% s% s% s% s% s% s%l" " " " "\#3 " " "J@ @ @ @ @l @ @ @F
\ \ \ \ \- \ \ \~N$ N$ N$ N$ N$_ N$ N$ N$ N$ N$r(   