
    ڏDj             	          d dl Z  e j                  dwi 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 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/ d0e      Z)d1 Z*d2 Z+d3 Z,e jZ                  d4e.d5e.fd6       Z/e jZ                  d7e.d8e.d9e.d:e.fd;       Z0 G d< d=ee!      Z1 G d> d?ee!      Z2 G d@ dAe      Z3 G dB dCee!      Z4 G dD dEee!      Z5 G dF dGee!      Z6 G dH dIee!      Z7 G dJ dKee!      Z8 G dL dMee!      Z9 G dN dOe      Z: G dP dQe      Z;dR Z< G dS dTe      Z= G dU dVe      Z> G dW dXe      Z? G dY dZe      Z@ G d[ d\ee!      ZA G d] d^e      ZB G d_ d`e      ZC G da dbe      ZD G dc dde      ZE G de dfe      ZF G dg dhe      ZG G di djee!      ZH G dk dle      ZI G dm dnee!      ZJ G do dpe      ZK G dq dre      ZL G ds dte      ZM G du dve      ZNy)x    N
PyrexTypesNaming	ExprNodesNodesOptions	UtilNodesLetNode
LetRefNodeTreeFragmentEncodedStringerrorwarningcopyhashlibsys
itemgetter)r      )Code)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
y	)
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     gC:\Crop_Prediction\Backend\crop-ai-system\venv\Lib\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_CEnumDefNode2   r(   r)   c                     |S r!   r"   r#   s     r&   visit_CStructOrUnionDefNodez,SkipDeclarations.visit_CStructOrUnionDefNode5   r(   r)   c                 F    |j                   dk7  r| j                  |       |S Nextern)
visibilityvisitchildrenr#   s     r&   visit_CppClassNodez#SkipDeclarations.visit_CppClassNode8   s!    ??h&t$r)   N)__name__
__module____qualname____doc__r'   r+   r-   r/   r1   r3   r9   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                 @    t         |   |       d| _        d| _        y NF)super__init__is_in_statlist
is_in_exprr$   context	__class__s     r&   rC   zNormalizeTree.__init__T   s    !#r)   c                     | j                  |       t        |j                  t        j                        s1t        j                  |j
                  |j                  g      |_        |S Nposstats)r8   
isinstancebodyr   StatListNoderL   r#   s     r&   visit_ModuleNodezNormalizeTree.visit_ModuleNodeY   sG    4 $))U%7%78**txx		{KDIr)   c                 \    | j                   }d| _         | j                  |       || _         |S NT)rE   r8   )r$   r%   stacktmps      r&   visit_ExprNodezNormalizeTree.visit_ExprNode`   s,    ??4 "r)   c                     | j                   }|| _         | j                  |       || _         | j                   s.| j                  s"t        j                  |j
                  |g      S |S rJ   )rD   r8   rE   r   rP   rL   )r$   r%   is_listcontainerrT   s       r&   visit_StatNodezNormalizeTree.visit_StatNodeg   sX    &&.4 &""4??%%$((4&AAKr)   c                 D    d| _         | j                  |       d| _         |S NTF)rD   r8   r#   s     r&   visit_StatListNodez NormalizeTree.visit_StatListNodeq   s%    "4 #r)   c                 &    | j                  |d      S rS   rX   r#   s     r&   visit_ParallelAssignmentNodez*NormalizeTree.visit_ParallelAssignmentNodew       ""4..r)   c                 &    | j                  |d      S rS   r]   r#   s     r&   r1   z NormalizeTree.visit_CEnumDefNodez   r_   r)   c                 &    | j                  |d      S rS   r]   r#   s     r&   r3   z)NormalizeTree.visit_CStructOrUnionDefNode}   r_   r)   c                     |j                   j                  r)t        j                  |j                   j                        S | j                  |      S )z!Eliminate useless string literals)expris_string_literalr   PassStatNoderL   rX   r#   s     r&   visit_ExprStatNodez NormalizeTree.visit_ExprStatNode   s9    99&&%%diimm44&&t,,r)   c                     |S r!   r"   r#   s     r&   r-   z#NormalizeTree.visit_CDeclaratorNode   r(   r)   F)r:   r;   r<   r=   rC   rQ   rU   rX   r[   r^   r1   r3   rf   r-   __classcell__rH   s   @r&   r?   r?   ?   s:    ( 
///-r)   r?   c                       e Zd Zy)PostParseErrorN)r:   r;   r<   r"   r)   r&   rl   rl      s    r)   rl   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                 X    t         |   |       d| j                  i| _        d| _        y )N__cythonbufferdefaults__F)rB   rC   handle_bufferdefaultsspecialattribute_handlersin_pattern_noderF   s     r&   rC   zPostParse.__init__   s/    !&)C)C*
&  %r)   c           	      f   t               }|j                  |j                         |j                  s0|j                  s$t        |j                  t        j                        r6t        j                  |j                  j                  |j                        }n5t        j                  |j                  j                  |j                        }t        j                  |j                  |j                  |j                  |j                  |j                   |d       |_        | j                  |       |S )Nrc   value)nameargsstar_argstarstar_argrO   doc)YieldNodeCollectorr8   result_expr	has_yield	has_awaitrN   r   YieldExprNoder   ExprStatNoderL   ReturnStatNodeDefNoderx   ry   rz   r{   def_node)r$   r%   	collectorrO   s       r&   visit_LambdaNodezPostParse.visit_LambdaNode   s    &(	 0 01)"5"5DDTDTV_VmVm9n%%  $$4+;+;=D ''  $$D,<,<>DHH499T]]**4	!
 	4 r)   c                 j   t               }|j                  |j                  d dg       t        j                  |j
                  |j                  d g d d |j                  |j                  d	      |_        t        j                  |j                  | j                  dv        | j                  |       |S )NiteratorattrsexcludeT)rx   r|   ry   rz   r{   rO   is_async_defis_generator_expressionpyclasscclassscope_is_class)r}   r8   loopr   r   rL   rx   r   r   _AssignmentExpressionChecker	do_checks
scope_typer$   r%   r   s      r&   visit_GeneratorExpressionNodez'PostParse.visit_GeneratorExpressionNode   s    &(			
|LHH499$d)<)<$(	*
 	%..tyy\qIq.r4 r)   c                 
   |j                   s8t               }|j                  |j                         |j                  rd|_         t
        j                  |j                  | j                  dv        | j                  |       |S )NTr   r   )has_local_scoper}   r8   r   r   r   r   r   r   s      r&   visit_ComprehensionNodez!PostParse.visit_ComprehensionNode   sj    ##*,I##DII.""'+$$..tyy\qIq.r4 r)   c                     t        |j                  t        j                        st	        |j
                  t              |j                  | j                  _        |j
                  | j                  _	        y r!   )
rN   defaultr   DictNoderl   rL   ERR_BUF_DEFAULTS
scope_nodebuffer_defaults_nodebuffer_defaults_pos)r$   decls     r&   rq   zPostParse.handle_bufferdefaults   sH    $,,	(:(:; +;<</3||,.2hh+r)   c           
      D   	 | j                  |       |g}g }|j                  D ]  }|}t        |t        j                  t        j
                  f      r7|j                  }t        |t        j                  t        j
                  f      r7t        |t        j                        r.|j                  !| j                  dv rt        | j                  t        j                        rO| j                  j                  |j                        }|r(||urt        |j                   t"               ||       t        |j                   t$              | j                  dk7  }|j'                  t        j(                  |j                   t+        j,                  |j                   |j                        |j                  ||j.                               d |_        |j'                  |        ||_        |S # t        $ r%}| j0                  j3                  |       Y d }~y d }~ww xY w)N)r   r   structmodulerx   )lhsrhsfirstfrom_pxd_cvardef)r8   declaratorsrN   r   CPtrDeclaratorNodeCConstDeclaratorNodebaseCNameDeclaratorNoder   r   r   CClassDefNoderr   getrx   rl   rL   ERR_INVALID_SPECIALATTR_TYPEERR_CDEF_INCLASSappendSingleAssignmentNoder   NameNodein_pxdrG   nonfatal_error)	r$   r%   rM   newdeclsr   declbasehandlerfirst_assignmentes	            r&   r+   zPostParse.visit_CVarDefNode   s   
 	t$FEH(( & E,D,DeF`F`+ab'}}H !E,D,DeF`F`+abh(A(AB''3??.MM)$//5;N;NO*.*H*H*L*LTYY*W#*'+8';.<TXXGc.d(d$+DM$,"0;K"LL+/??h+F(U%?%? ) 2 2488(-- P ( 0 08H-1[[&: ; ,0(%+&,  (DL 	 LL''*		s   BG1 E%G1 1	H:HHc                 t    | j                  |       | j                  ||j                  |j                  g      S r!   )r8   _visit_assignment_noder   r   r#   s     r&   visit_SingleAssignmentNodez$PostParse.visit_SingleAssignmentNode  s0    4 **4$((DHH1EFFr)   c                 x    | j                  |       | j                  ||j                  |j                  gz         S r!   )r8   r   lhs_listr   r#   s     r&   visit_CascadedAssignmentNodez&PostParse.visit_CascadedAssignmentNode  s2    4 **4$((1KLLr)   c                    t        |D cg c]  }|j                  s|j                  rd c}      dk  r|S g }t        ||       g }t	        ||       g }|D ]s  }|dd }|d   }t        |      dk(  r&t        j                  |j                  |d   |      }n"t        j                  |j                  ||      }|j                  |       u t        |      dk(  r|d   }	n$t        j                  |d   j                  |      }	|rB|D 
cg c]  }
|
j                  |
f }}
t        |       |ddd   D ]  \  }}t        ||	      }	 |	S c c}w c c}
w )	zgFlatten parallel assignments into separate single
        assignments or cascaded assignments.
        r      Nr   r   r   )r   r   rM   )sumis_sequence_constructorrd   flatten_parallel_assignmentseliminate_rhs_duplicateslenr   r   rL   CascadedAssignmentNoder   ParallelAssignmentNode
expressionsort_common_subsequencesr	   )r$   r%   	expr_listrc   expr_list_list	temp_refsnodesr   r   assign_nodetempduplicates_and_temps_temp_refs                 r&   r   z PostParse._visit_assignment_node#  s}    y Mt00D4J4J  M NPQR K$Y?	 ;' 		I "~HB-C8}!11#''"1+S2 33CGG's4LL		 u:?(K66uQx||USK1:$=)- '+oot%< $=  $=$%9:3DbD9 =8%h<= EM8$=s   !EEc                     |j                   D ]2  }|j                  r| j                  ||       "|j                  |       4 |S r!   )ry   r   _flatten_sequencer   )r$   seqresultargs       r&   r   zPostParse._flatten_sequenceK  sA    88 	#C**&&sF3c"		#
 r)   c                 V    | j                  |       | j                  |g       |_        |S r!   )r8   r   ry   r#   s     r&   visit_DelStatNodezPostParse.visit_DelStatNodeS  s)    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      |_
        | j                  |       |S )Nr   T)ry   ignore_nonexistingr   )rO   finally_clause)is_except_asr   DelStatNoderL   r   r   targetrx   rP   TryFinallyStatNoderO   r8   )r$   r%   
del_targets      r&   visit_ExceptClauseNodez PostParse.visit_ExceptClauseNodeX  s    **((KKOO$++*:*:< =#'	)J
 **//HH#(#5#5)l$,- ./DI 	4 r)   c           	         |j                   dt        j                  |j                  t	        j
                  |j                  t        d            |j                  dddd      |_         d|_        | j                  |       |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   RaiseStatNoderL   r   r   r   rw   r8   r#   s     r&   visit_AssertStatNodezPostParse.visit_AssertStatNodek  sp     >>!"00"++DHH=IY;Z[**!1!%DN DJ4 r)   c                 D    t        |j                  |j                         y r!   )r   rL   whatr#   s     r&   visit_ErrorNodezPostParse.visit_ErrorNode|  s    dhh		"r)   c                 H    |j                          | j                  |       |S r!   )validate_targetsr8   r#   s     r&   visit_MatchCaseNodezPostParse.visit_MatchCaseNode  s!    4 r)   c                 H    |j                          | j                  |       |S r!   )validate_irrefutabler8   r#   s     r&   visit_MatchNodezPostParse.visit_MatchNode  s!    !!#4 r)   c                 ^    | j                   dc}| _         | j                  |       || _         |S rS   )rs   r8   )r$   r%   rs   s      r&   visit_PatternNodezPostParse.visit_PatternNode  s2    040D0Dd--4 .r)   c                 l    | j                   rt        |j                  d       | j                  |       |S )Nz/f-strings are not accepted for pattern matching)rs   r   rL   r8   r#   s     r&   visit_JoinedStrNodezPostParse.visit_JoinedStrNode  s-    $((MN4 r)   c                     | j                   dk(  r4|j                  dv r&t        |j                  d|j                   dd       y | j	                  |      S )Nr   )__getreadbuffer____getwritebuffer____getsegcount____getcharbuffer__'zD' relates to the old Python 2 buffer protocol and is no longer used.r   )r   rx   r   rL   visit_FuncDefNoder#   s     r&   visit_DefNodezPostParse.visit_DefNode  sT    OOx'		ppDHH$)) -- -./1%%d++r)   )r:   r;   r<   r=   rC   r   r   r   rq   r+   r   r   r   r   r   r   r   r   r   r   r  r  r  ri   rj   s   @r&   rn   rn      sl    "F%$	7%\GM&P
&"

,r)   rn   c                   <     e Zd Z fdZd Zd Zd Zd Zd Z xZ	S )%_AssignmentExpressionTargetNameFinderc                 0    t         |           i | _        y r!   )rB   rC   target_namesr$   rH   s    r&   rC   z._AssignmentExpressionTargetNameFinder.__init__  s    r)   c                     |j                   r|j                  gS |j                  r5g }|j                  D ]"  }|j	                  | j                  |             $ |S g S r!   )is_namerx   r   ry   extendfind_target_names)r$   r   namesr   s       r&   r  z7_AssignmentExpressionTargetNameFinder.find_target_names  sW    >>KK= ++E{{ :T33C89:L	r)   c                     t        | j                  |j                              | j                  |<   | j	                  |       y r!   )tupler  r   r  r8   r#   s     r&   visit_ForInStatNodez9_AssignmentExpressionTargetNameFinder.visit_ForInStatNode  s4    "'(>(>t{{(K"L$4 r)   c                      y r!   r"   r#   s     r&   r   z=_AssignmentExpressionTargetNameFinder.visit_ComprehensionNode      r)   c                      y r!   r"   r#   s     r&   r   z6_AssignmentExpressionTargetNameFinder.visit_LambdaNode  r  r)   c                 &    | j                  |       y r!   r8   r#   s     r&   
visit_Nodez0_AssignmentExpressionTargetNameFinder.visit_Node      4 r)   )
r:   r;   r<   rC   r  r  r   r   r  ri   rj   s   @r&   r  r    s!    	!!r)   r  c                   b     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                 D   t         |           t               }|j                  |       |j                  | _        d| _        d| _        || _        d| _	        t               | _        | j
                  j                         D ]  }| j                  j                  |        y NFr"   )rB   rC   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  rH   s        r&   rC   z%_AssignmentExpressionChecker.__init__  s    BD  +!3!@!@ #( ,$&! #++224 	0E!!((/	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  se    %%t'?'?ATATVZVkVkmq  nG  nG  H	#( #$&! #r)   c                 F    |\  | _         | _        | _        | _        | _        y r!   )r&  r'  r   r*  r(  r0  s     r&   
_set_statez'_AssignmentExpressionChecker._set_state  s&     }Fy$2D4GI^`d`yr)   c                 8     | ||      }|j                  |       y r!   )r$  )clsr-  r   checkers       r&   r   z&_AssignmentExpressionChecker.do_checks  s    i0i r)   c                 D   | j                   r| j                  |       y | j                  }| j                  j	                  |d       }|r| xj                  |z  c_        d| _        | j                  |j                         d| _        | j                  |d       || _        y )NTF)r   r   )r'  r8   r(  r%  r   r&  r$  r   )r$   r%   r(  target_names       r&   r  z0_AssignmentExpressionChecker.visit_ForInStatNode  s    ##t$#88,,00t<%%4%

4==! 47$8!r)   c                 |   | j                   rt        |j                  d       | j                  rt        |j                  d       |j                  | j
                  v r$t        |j                  d|j                  z         y |j                  | j                  v r$t        |j                  d|j                  z         y y )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   rL   r   r:  r(  r*  r#   s     r&   visit_AssignmentExpressionNodez;_AssignmentExpressionChecker.visit_AssignmentExpressionNode  s    $((ij$((ijt888$((g""# $!6!66$((f""# $ 7r)   c                 |    | j                         }| j                  |j                         | j                  |       y r!   )r2  r$  r~   r4  )r$   r%   r1  s      r&   r   z-_AssignmentExpressionChecker.visit_LambdaNode  s0     %%'	

4##$	"r)   c                 Z    | j                   }d| _         | j                  |       || _         y rS   )r'  r8   r$   r%   r'  s      r&   r   z4_AssignmentExpressionChecker.visit_ComprehensionNode  s,    "66#' 4 #6 r)   c                 n    | j                   }d| _         | j                  |j                         || _         y rS   )r'  r$  r   r?  s      r&   r   z:_AssignmentExpressionChecker.visit_GeneratorExpressionNode  s.    "66#' 

499#6 r)   c                 &    | j                  |       y r!   r  r#   s     r&   r  z'_AssignmentExpressionChecker.visit_Node  r   r)   )r:   r;   r<   r=   rC   r2  r4  classmethodr   r  r<  r   r   r   r  ri   rj   s   @r&   r   r     sJ    0F ! !9"
$#77!r)   r   c                 
   t               i fd| D ]  }|d   } |        syfdD ]3  }|j                  st        t        |j                              |_        5 | D ]  } |d         |d<    y)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y | v r'| vr"t        |       }|| <   j                  |       y y j	                  |        | j
                  r| j                  D ]
  } |        y y r!   )
is_literalr  r
   r   addr   ry   )r%   ref_nodeitemfind_duplicatesref_node_sequence	ref_nodes
seen_nodess      r&   rI  z1eliminate_rhs_duplicates.<locals>.find_duplicates  s    ??dll :9$%d+"*	$!((2 %
 NN4 ++ II *D#D)* ,r)   r   Nc                 z    | v r|    S | j                   r$t        t        | j                              | _        | S r!   )r   listmapry   )r%   rK  substitute_nodess    r&   rP  z2eliminate_rhs_duplicates.<locals>.substitute_nodes4  s;    9T?"))S!1499=>DIr)   )r)  r   rN  rO  ry   )	r   rJ  r   r   r%   rI  rK  rL  rP  s	    `   @@@@r&   r   r     s     JI*  $ 	m   ?''S!1499=>DI?
 $ 8	(27	"8r)   c                     fdfd}t        |       D ][  \  }}|d   }|}t        |dz
  dd      D ]  } ||| |   d         s|} ||k7  s:t        ||d      D ]  }| |dz
     | |<    || |<   ] y)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                 d    | D ]*  }||u r y|j                   s |j                  |      s* y yrZ   r   ry   )r   xrH  containss      r&   rU  z*sort_common_subsequences.<locals>.containsP  s:     	Dqy--(499a2H		
 r)   c                 F    |j                   xr  |j                  |       S r!   rS  )abrU  s     r&   
lower_thanz,sort_common_subsequences.<locals>.lower_thanW  s    ((@Xaffa-@@r)   r   r   r   N)	enumeraterange)itemsrY  rL   rH  keynew_posirU  s          @r&   r   r   D  s    A u% 	"	T1gs1ub"% 	A#uQx{+	 c>3, & 1:a&!E'N	"r)   c                     g }| j                   }| j                  }| j                  }|j                  }|D ]#  } ||      }|j                   |||             % |S )Nrv   )rL   rH   rw   r   )literalcharsrL   stypesval	sval_typecharcvals           r&   #unpack_string_to_character_literalsrh  f  s_    E
++CE==DI -U3d+,- Lr)   inputoutputc                    | d   }|j                   st        |t        j                        r&t	        | d d D cg c]  }|j                    c}      s|j                  |        y g }|j                   r|j                  }n|j                  rt        |      }t              }t        |      D cg c]  }g  }}g }	| d d D ]t  }|j                   s4|j                  rt        |j                  d       |j                  |       Dt        |j                        }
d}|j                  D ]  }|t        |j                        z  } |dkD  r*t        |j                  d       |j                  ||g       |
|z
  |kD  r:t        |j                  d||dk7  xr dxs dfz         |j                  ||g       |rt        ||	|j                  |       |
|k  r0t        |j                  d	|
|fz         |j                  ||g       Ft!        ||j                        D ]  \  }}|j                  |        w |r"|j                  |       |j                  |       t!        ||      D ]%  \  }}|s	|j                  |       t#        ||       ' |	D ]/  }|d   j                   rt#        ||       |j                  |       1 y c c}w c c}w )
Nr   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   rN   r   UnicodeNoder   r   ry   rd   rh  r   r[  
is_starredr   rL   boolmap_starred_assignmentzipr   )ri  rj  r   r   complete_assignmentsrhs_argsrhs_sizer   lhs_targetsstarred_assignmentslhs_sizestarred_targetsrc   targetscascades                  r&   r   r   r  s    )C((JsI<Q<Q,RuSbzJ33JKe
""88			6s; #&h-H$X/!2/K/Sbz %**~~cggUV '',sxx=HH 	5DtDOO44O	5Q#''IJMM3s)$'(2#''@A63<"=> ?MM3s)$";0C#&88X7 #''Lx() *MM3s)$!$[#((!; %t$%9%> ##C(*+ K2 :NN3(&9: ' #1:--(&9MM'"	#w K 0s   K.	K
rv  rw  lhs_argsrt  c                    t        t        | |            D ]:  \  }\  }}|j                  r|}t        |      |z
  dz
  } n|j	                  |       < t        d      t        t        | | d  ||dz   d              D ]  \  }\  }}|j	                  |        ||   j                  }	||d  }
|r|
d |  }
|
r|
d   j                  }n|	j                  }|j	                  |	t        j                  ||
      g       y )Nr   z6no starred arg found when splitting starred assignmentr   )rL   ry   )
rZ  rr  ro  r   r   r   r   rL   r   ListNode)rv  rw  r|  rt  r_  rz  rc   starredlhs_remainingr   starred_rhsrL   s               r&   rq  rq    s#    (K(BC V?GT??GMA-1MtV TUU (K,H,4Wq[\,B)D E ?GTt
 g%%F78$K!/M>2!n  jj	""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                 0    d| _         t        | 	  |      S )Npxd)r   rB   __call__r$   r%   rH   s     r&   r  zPxdPostParse.__call__  s    w%%r)   c                 \    | j                   }d| _         | j                  |       || _         |S Nr   )r   r8   )r$   r%   olds      r&   visit_CClassDefNodez PxdPostParse.visit_CClassDefNode  s,    oo"4 r)   c                    | j                   }t        |t        j                        r| j                  dk(  r|j
                  dv rd }t        |t        j                        rwd|j                  v r]| j                  dv rOd|_        |j                  dk7  r| j                  |j                  z  }n+|j                  r| j                  dz  }nd }n| j                   }|r0| j                  j                  t        |j                  |             y |S )Nr   )__getbuffer____releasebuffer__inline)r  r   Tprivateapi)ERR_INLINE_ONLYrN   r   r   r   rx   CFuncDefNode	modifiersinline_in_pxdr7   ERR_NOGO_WITH_INLINEr  rG   r   rl   rL   )r$   r%   errs      r&   r  zPxdPostParse.visit_FuncDefNode  s     ""tU]]+80KII!GGCdE../DNN*OO'88%)"??i/33dooECXX33e;CC**LL''txx(EFKr)   )
r:   r;   r<   r=   r  r  r  r  r  ri   rj   s   @r&   r  r    s%     WOR&r)   r  c                   B     e Zd Z fdZd Zd Zej                  Z xZ	S )TrackNumpyAttributesc                 @    t         |           t               | _        y r!   )rB   rC   r)  numpy_module_namesr  s    r&   rC   zTrackNumpyAttributes.__init__!  s    "%%r)   c                 v    |j                   dk(  r)| j                  j                  |j                  xs d       |S )Nnumpy)module_namer  rF  as_namer#   s     r&   visit_CImportStatNodez*TrackNumpyAttributes.visit_CImportStatNode%  s2    w&##''(?@r)   c                     | j                  |       |j                  }|j                  r|j                  | j                  v s|j
                  rd|_        |S rS   )r8   objr  rx   r  is_numpy_attribute)r$   r%   r  s      r&   visit_AttributeNodez(TrackNumpyAttributes.visit_AttributeNode*  sF    4 hhKKCHH(?(??CDZDZ&*D#r)   )
r:   r;   r<   rC   r  r  r   recurse_to_childrenr  ri   rj   s   @r&   r  r    s    (
 "55Jr)   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j                  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                 0   t         |   |       t               | _        ddi| _        i | _        t        j                  t        j                               }|j                         D ]&  \  }}t        j                  |      |t        |      <   ( || _        y )Nstaticmethod)rB   rC   r)  cython_module_namesdirective_namesparallel_directivesr   deepcopyr   get_directive_defaultsr\  str
directives)r$   rG   compilation_directive_defaultsr  r]  rw   rH   s         r&   rC   z$InterpretCompilerDirectives.__init__z  s    !#&5  .?#% ]]7#A#A#CD
8>>@ 	8JC#'==#7Js3x 	8$r)   c           
          t         j                  j                  |d       }|r1||vr-| j                  j	                  t        |d|d|d             y|t         j                  vrt        |d|d       y)NzThe z& compiler directive is not allowed in z scopeFzInvalid directive: 'z'.T)r   directive_scopesr   rG   r   rl   directive_typesr   )r$   rL   	directivescopelegal_scopess        r&   check_directive_scopez1InterpretCompilerDirectives.check_directive_scope  sn    //33ItDE5LL''sHQSX=Z )[ \ 7 77cDEr)   c                    |j                  d      sy |j                  dd      d   }|| j                  v ry d}dj                         d d D cg c]  }|j                          }}|D ]   \  }}|j                  d|z         sd|z  } n |s>|t        j
                  v }	|	s#|j                  d	      sdd
lm}
 t        |
|      }	|	rd|z  }t        |d|d|rdnd|       y c c}w )Ncython..r   r   rm  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. )

startswithsplitvalid_cython_submodules
splitlinesr   r  rm  r  hasattrr   )r$   rL   r  	submoduleextralinehintswrongcorrectis_simple_cython_namer  s              r&   _check_valid_cython_modulez6InterpretCompilerDirectives._check_valid_cython_module  s   %%i0%%c1-a0	444& 
Sb&"
!DJJL
 
 $ 	NE7%%i%&784w>	 $-1H1H$H!(1E1Ec1J &(/	(B%$LyXcDr!
 	/
s   C%c                    t        |j                        D ]J  }| j                  |j                  |d      r!| j	                  |j                  |d       |j                  |= L |j
                  | _        | j                  j                  |j                         | j                  |_        | j                  |_	        | j                  |       | j                  |_        |S )Nr   )sorteddirective_commentsr  rL   wrong_scope_errorr  module_scoper  r,  r  r8   r  )r$   r%   r]  s      r&   rQ   z,InterpretCompilerDirectives.visit_ModuleNode  s    $112 	1C--dhhXF&&txxh?++C0	1
 !JJt667//#'#;#; 4 #'#;#; r)   c                 r    | j                   |j                   c}| _         | j                  |       || _         |S r!   r  r8   r$   r%   old_directivess      r&   visit_CompilerDirectivesNodez8InterpretCompilerDirectives.visit_CompilerDirectivesNode  s2    *.//4??'4 (r)   c                 t    |t         j                  v xs% || j                  v xs t        j                  |      S r!   )r   r  special_methodsr   parse_basic_type)r$   rx   s     r&   is_cython_directivez/InterpretCompilerDirectives.is_cython_directive  s;    /// 2,,,2++D1	3r)   c                 0   |dz   j                  d      }|r|j                  d      }|dk(  rd| j                  d<   |S |dk(  r%| j                  D ]  }d|z  | j                  |<    |S t	        |      dk7  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_namerL   r   r  rx   s         r&   is_parallel_directivez1InterpretCompilerDirectives.is_parallel_directive  s     c/--.@A!,I--7H((4  11 :: QD5ID5PD,,T2Q 	 i.A%B-t'E'EEc2Y>?r)   c                 z   |j                   }|dk(  rt        |j                  d       |j                  d      rF|j                  r$|j                  dk7  r|t        d      d  |_         |S t        |j                  d       |dk(  r+| j                  j                  |j                  xs d       |S |j                  d      r|j                  d      r$t        |j                  |j                   dz          n| j                  |j                  |       |d	k(  r`|j                  r)|j                  dk7  r|| j                  |j                  <   y | j                  j                  d       || j                  d	<   y |j                  r|d
d  | j                  |j                  <   y | j                  j                  d       y |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   rL   r  r  r   r  rF  r  r  r  r$   r%   r  s      r&   r  z1InterpretCompilerDirectives.visit_CImportStatNode  s   &&++$((ef!!"45|| 8#.s3E/F/G#H $((CD ("$$(()AB* ) ##I.%%&89dhh 0 03E EF//+F//<<DLLH$<=HD,,T\\:  ,,00:9D ,,$57  5@_$$T\\2
  ((,,X6 r)   c                    |j                   }|dk(  s|j                  d      r2| j                  |j                  ||j                  |j
                        S |j                  s|dk(  s|j                  d      r| j                  |j                  |       |dz   dd  }g }|j
                  D ]  \  }}}||z   }d|z   }	| j                  |	|j                        r|	| j                  |xs |<   A| j                  |      r|| j                  |xs |<   f|dv r(|| j                  |xs |<   |j                  |||f       |j                  |||f        |sy ||_        |S )Nr  r  r  r  r  r  )r  typing)r  r  _create_cimport_from_importrL   relative_levelimported_namesr  r  r  r  r  r   )
r$   r%   r  r  newimprL   rx   r  r  qualified_names
             r&   visit_FromCImportStatNodez5InterpretCompilerDirectives.visit_FromCImportStatNode  sp   &&++{/E/EFX/Y33+t':':D<O<OQ Q$$x';+A+A)+L++DHHkB$s*AB/IF&*&9&9 8"T7%,	!*Y!6--ndhhG AOD,,W_=--i8<ED((D9";;<ED((D9MM3g"67MM3g"678  "(Dr)   c                 (   |j                   }|j                  j                  }|dk(  s|j                  d      rwg }|j                  D ]>  \  }}|j                  |j                  |||j                  k(  rd n|j                  f       @ | j                  |j                  ||j                  |      S |dk(  s|j                  d      r| j                  |j                  j                  |       |dz   dd  }g }|j                  D ]  \  }}||z   }	d|	z   }
| j                  |
|j                        r|
| j                  |j                  <   F| j                  |	      r|	| j                  |j                  <   q|j                  ||f        |sy ||_        |S )Nr  r  r  r  r  r  )r   r  rw   r  r\  r   rL   rx   r  levelr  r  r  r  r  )r$   r%   import_noder  r  rx   	name_noder  r  r  r  s              r&   visit_FromImportStatNodez4InterpretCompilerDirectives.visit_FromImportStatNode,  s   kk!--33++{/E/EFX/YN#':: _i%%]]D$)..2H$inn]__ 33+{'8'8.J JH$(>(>y(I++K,C,C,G,GU$s*AB/IF#':: 5i%,	!*Y!6--ndhhG?MD,,Y^^<--i8;DD((8MM4"345 DJr)   c                    |dk(  s|j                  d      rt        |t        d      d        }|rt        j                  ||||      S |D cg c]"  \  }}}t        j
                  ||||dk(        $ c}}}S c c}}}w )Nr  r  )r  r  r  r   )r  r  is_absolute)r  r   r   r   FromCImportStatNodeCImportStatNode)r$   node_posr  r  r  rL   dotted_namer  s           r&   r  z7InterpretCompilerDirectives._create_cimport_from_importH  s    ++{/E/EFX/Y'C8J4K4L(MNK,,k$-/ / 2@  .Cg %% +# %
	,  s   'A;c                 r   t        |j                  t        j                        r|j                  j                  j
                  }|dk7  r|j                  d      s|S t        j                  |j                  ||j                  j                        }| j                  |      }|S | j                  |       |S )Nr  r  )r  r  )rN   r   r   
ImportNoder  rw   r  r   r  rL   r   rx   r  r8   r  s      r&   r   z6InterpretCompilerDirectives.visit_SingleAssignmentNode]  s    dhh	 4 45((..44Kh&{/E/Ei/P(({TXT\T\TaTabD--d3D  t$r)   c                 F   |j                   r| j                  |d       |j                  | j                  v rd|_        n.| j
                  j                  |j                        }|||_        |j                         dk(  r!t        j                  |j                  d      S |S )N
annotationTr  rv   )r  
visitchildrx   r  is_cython_moduler  r   cython_attributeas_cython_attributer   BoolNoderL   )r$   r%   r  s      r&   visit_NameNodez*InterpretCompilerDirectives.visit_NameNodej  s    ??OOD,/99000$(D!,,00;I$(1%##%3%%dhhd;;r)   c                     | j                  |       |j                         dk(  r!t        j                  |j                  d      S |S )Nr  Trv   )r8   r  r   r  rL   r#   s     r&   r  z/InterpretCompilerDirectives.visit_AttributeNodex  s=    4 ##%3%%dhhd;;r)   c                 T    |j                   r| j                  |j                          |S r!   )rc   r$  r#   s     r&   visit_AnnotationNodez0InterpretCompilerDirectives.visit_AnnotationNode  s      99JJtyy!r)   c                 L    | j                  |d       | j                  |       |S Ncppclass)r  r8   r#   s     r&   visit_NewExprNodez-InterpretCompilerDirectives.visit_NewExprNode  s#    j)4 r)   c           	         t        |t        j                        rE| j                  |d       |j                  j                         }|rt        j                  j                  |      }|r|j                         \  }}g }g }||t        ur|j                  D ]w  }|\  }	}
|d|	j                  }t        j                  j                  |      r/|j                  | j                  ||
gd |j                               g|j                  |       y |sd }n||_        |r|s|s|S |j                  | j                  ||||j                  j                               |S y t        |t        j                   t        j"                  f      r| j%                  |       |j                         }|rt        j                  j                  |      }|t&        u rAt        j(                  |j                  d      }| j                  ||gd |j                        gS ||t        j*                  u r|d fgS t-        |j                  d|z        y )Nfunctionr  Trv   z5The '%s' directive should be used as a function call.)rN   r   CallNoder  r  r  r   r  r   explicit_args_kwdsdictkey_value_pairsrw   r   try_to_parse_directiverL   AttributeNoder   r$  rp  r  DEFER_ANALYSIS_OF_ARGUMENTSrl   )r$   r%   optnamedirectivetypery   kwdsr  r!  keyvaluer]  rw   sub_optnamer   s                r&   try_to_parse_directivesz3InterpretCompilerDirectives.try_to_parse_directives  s    dI../OOD*-mm779G ' 7 7 ; ;G D !%!8!8!:JD$!#J&(O'M,E(,(<(< AH)1JC5<cii*HK&66::;G * 1 1$2M2Mk\a[bdhjrjvjv2w x / 6 6x @A  /#'D3BD0%d4#--%%d&A&A'4QUW[WdWdWhWh&ij%%  y66	8J8JKLJJt..0G ' 7 7 ; ;G D D(#,,TXXTBC 77#dhhWXX"*mw?b?b.b$dO,,("Y\c"ce er)   c                    |dk(  r%| j                   j                  st        |d|z        |dk(  rt        |      dkD  }d}|r|j                  r|j                  d   }t        |j                        dk(  rj|j
                  j                  rT|j
                  j                  dk(  r;t        |j                  t        j                        r|j                  j                  }nd}|rt        |d      d|r|d   |ffS d |ffS t        j                  j                  |      }t        |      dk(  r6t        |d   t        j                        r|t        j                         |   fS |t         u rM|+t        |      dk7  st        |d   t        j                        st        |d	|z        ||d   j                  fS |t"        u rV|+t        |      dk7  st        |d   t        j$                        st        |d
|z        |t#        |d   j                        fS |t&        u rV|+t        |      dk7  st        |d   t        j(                        st        |d|z        |t'        |d   j                        fS |t*        u r&|t        |      dk7  rt        |d|z        ||d   fS |t,        u r/t        |      dk7  rt        |d|z        ||j/                         fS |t0        u rN|r't        |j                        dk7  rt        |d|z        ||D 	cg c]  }	t'        |	j                         c}	fS t3        |      r]|+t        |      dk7  st        |d   t        j(                        st        |d|z        | ||t'        |d   j                              fS |t        j4                  u r|||r|j/                         ffS i ffS J c c}	w )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 arguments)rG   cpprl   r   r!  r]  rd   rw   rN   r   r  r   r  r   NoneNoder  rp  intIntNoder  rn  typer   as_python_dictrN  callabler$  )
r$   r%  ry   r'  rL   	arg_errorr.  kwr&  r   s
             r&   r"  z2InterpretCompilerDirectives.try_to_parse_directive  s   l"4<<+;+; &VY`&`aa#D	AIE,,))!,,,-200RVV\\W5L"288Y-?-?@HHNNE $I$tv vT$q'U!CDDtU!CDD//33G<t9>ja)2D2DEG::<WEEEd"3t9>DGYM_M_9`$SNQXXZ ZT!W]]++c!3t9>DGYM^M^9_$SNQXXZ ZSa/00c!3t9>DGYMbMb9c$SMPWWY YSa/00d"3t9>$S>HJ JT!W%%d"4yA~$SG'QS SD//111d"D001Q6$SAGKM M>c#))n>>>m$3t9>DGYMbMb9c$SMPWWY Y]7CQ4FGHHgAAAdTD$7$7$9JKKrJKK ?s   Oc                 @   |s|rJ | j                  |      S | j                  }t        j                  |fi |}|t        j                  |fi |}n|}||k(  r| j                  |      S || _        |j||k7  ret	        j
                  |j                  j                  t	        j                  |j                  j                  ||j                        g      |_        | j                  |      }|| _        t        |t        j                        r'|j                  |j                         |j                  }t        |t        j
                        s"t	        j
                  |j                  |g      }t	        j                  |j                  |||j                        S )N)r  rO   r   )rO   r  is_terminator)r  r  r   copy_inherited_directivesr   rP   rO   rL   CompilerDirectivesNoderN   r,  r:  )r$   r%   r  contents_directivesr  new_directivesnew_contents_directivesretbodys           r&   visit_with_directivesz1InterpretCompilerDirectives.visit_with_directives  sh   **??4(( ::>XZX*&-&G&G'7"5'7# '5#^+??4(((+'>9**		00		#:!YY(DI //$'(gu;;<!!'"4"45llG'5#5#56(('CG++KKg.PWPePeg 	gr)   c                 R    | j                  |d      \  }}| j                  |||      S )Nr  _extract_directivesrA  r$   r%   r  r=  s       r&   r  z-InterpretCompilerDirectives.visit_FuncDefNode!  0    *.*B*B4*T'
'))$
<OPPr)   c                    | j                  |d      \  }}|j                         D ]I  \  }}|dk(  r||_        |dvs| j                  j	                  t        |j                  d|z               K | j                  ||d       S )Nr  locals)finalr  zXCdef functions can only take cython.locals(), staticmethod, or final decorators, got %s.r=  )rD  r\  directive_localsrG   r   rl   rL   rA  )r$   r%   r  r   rx   rw   s         r&   r+   z-InterpretCompilerDirectives.visit_CVarDefNode%  s    00zB
A%++- 	JKD%x(-%66++NHHACGH-I J		J ))$
PT)UUr)   c                 R    | j                  |d      \  }}| j                  |||      S r  rC  rE  s       r&   r  z/InterpretCompilerDirectives.visit_CClassDefNode1  s0    *.*B*B4*R'
'))$
<OPPr)   c                 R    | j                  |d      \  }}| j                  |||      S r  rC  rE  s       r&   r9   z.InterpretCompilerDirectives.visit_CppClassNode5  rF  r)   c                 R    | j                  |d      \  }}| j                  |||      S )NclassrC  rE  s       r&   visit_PyClassDefNodez0InterpretCompilerDirectives.visit_PyClassDefNode9  s0    *.*B*B4*Q'
'))$
<OPPr)   c           	         |j                   si i fS g }g }g }t        | j                        }t               }|j                   ddd   D ]c  }| j	                  |j
                        }	|	1|	D ])  }
| j                  |j                  |
d   |      r|
\  }}|dv rc|d}nZ|\  }}|s+t        |      dk7  st        |d   t        j                        st        |j                  d|z        |d   j                  }||f}
|j                  ||      |k7  r6|dk(  rd	|v rt        |j                  d
       |j!                  |
       |||<   n#t#        |j                  d||d|z  ndd       |
d   dk(  r|j!                  |       |
d   dk(  s!|dk(  s(d}, S|j!                  |       f |ddd   |ddd   z   |_         i }i }|D ]  \  }}||v rr||   }t        |t              r|j%                  |       nPt        |t&              r|j)                  |       n.|dk(  r|||   k7  rt        |j                  d       |||<   n|||<   |t*        j,                  vs|||<    ||fS )z
        Returns two dicts - directives applied to this function/class
        and directives applied to its contents. They aren't always the
        same (since e.g. cfunc should not be applied to inner functions)
        Nr   r   )nogilwith_gilTr   r/  cfuncufuncz=Cannot apply @cfunc to @ufunc, please reverse the decorators.z*Directive does not change previous value (z=%rrm  )r  r   rO  collection_typez4Multiple values of collection_type are not supported)
decoratorsr   r  objectr*  	decoratorr  rL   r   rN   r   r  rl   rw   r   r   r   r   r,  rN  r  r   immediate_decorator_directives)r$   r%   
scope_namer  realdecsbothcurrent_opt_dictmissingdecr>  r  rx   rw   ry   r'  optdictcontents_optdict	old_values                     r&   rD  z/InterpretCompilerDirectives._extract_directives=  s    r6M
0(??4R4( 	%C!99#--HN)!/ .I11$((IaL*U&/e#88$}(,-2
d#'3t9>DQRGU^UgUgAh*8B|  @D  CD  +E  %E(,Q)-uI+//g>%G#w7>N3N %cgg/n o&--i85:,T2#CGG $u7Heemb&P.R S$Q<>9 KK, |x/J'4I%-
1.4 $;	%< #4R4.4":5% 	/KD%w#DM	 i.$$U+	40$$U+00Ugdm5Kdhh(^_$)GDM %7AAA). &!	/" (((r)   c                    i }| j                  |j                        xs g D ]  }||j                  0| j                  j	                  t        |j                  d             B|\  }}|dv r| j                  ||      c S |dk(  r|\  }}| j                  |||      c S | j                  |j                  |d      s|||<    |r| j                  |j                  |d       S | j                  |      S )Nz6Compiler directive with statements cannot contain 'as')rR  gilcritical_sectionzwith statementrJ  )r*  managerr   rG   r   rl   rL   _transform_with_gil_transform_critical_sectionr  rA  rO   r  )r$   r%   directive_dictr  rx   rw   ry   r'  s           r&   visit_WithStatNodez.InterpretCompilerDirectives.visit_WithStatNode  s    55dllCIr 	-I {{&++"488-efh#KD%''//d;;++"
d77dDII++DHHd<LM',t$	-  --dii]a-bbt$$r)   c                 >   |dv sJ |j                   }d }t        |t        j                        rf|j                  rZt        |j                        dkD  r2| j                  j                  t        |j                  d|z               |j                  d   }nLt        |t        j                        r2| j                  j                  t        |j                  d|z               t        j                  |j                  ||j                  |      }| j                  |      S )N)rf  rR  r   z6Compiler directive %s accepts one positional argument.r   )staterO   	condition)rh  rN   r   SimpleCallNodery   r   rG   r   rl   rL   GeneralCallNoder   GILStatNoderO   r  )r$   r%   rn  rh  ro  s        r&   ri  z/InterpretCompilerDirectives._transform_with_gil  s    (((,,	gy778W\\7<< 1$++"488-ehm-mnpQI!:!:;LL''txx)adi)ijl  TYYR[\t$$r)   c                    t        |      dk  st        |      dkD  s|r/| j                  j                  t        |j                  d             t        j                  |j                  ||j                        }| j                  |      S )Nr   r   zBcritical_section directive accepts one or two positional argumentsry   rO   )	r   rG   r   rl   rL   r   CriticalSectionStatNoderO   r  )r$   r%   ry   r'  s       r&   rj  z7InterpretCompilerDirectives._transform_critical_section  sl    t9q=CIMTLL''txx)mn ,,HH4dii
 t$$r)   ).r:   r;   r<   r=   r   
TypeofNodeAmpersandNodeDereferenceNodeinc_dec_constructor
TypeidNodeunop_method_nodesc_binop_constructorbinop_method_nodesr  r,  r  r  rC   r  r  rQ   r  r  r  r  r  r  r  r   r  r  r  r  r*  r"  rA  r  r+   r  r9   rP  rD  rl  ri  rj  ri   rj   s   @r&   r  r  4  sh   : &&%33 ) 9 9"?)"?"?d"K"?)"?"?d"K"?)"?"?t"L"?)"?"?t"L"+"6"6 **  	"?)"?"?"DO
 ,-!%	$N3
*"HB8*
*X>@'gTQ
VQQQB)J%,%%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                 N    |j                   | j                  v xs |j                  S r!   )rx   r  r  r#   s     r&   node_is_parallel_directivez1ParallelRangeTransform.node_is_parallel_directive  s"    yyD444M8M8MMr)   c                    | j                   rdj                  | j                        }nP| j                  | j                  d      }|ddj                  | j                  dd       }|j	                  d      }| j
                  j                  |      }|7| j                   r| j                  d   dk7  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   rL   )r$   r%   r  r6  s       r&   get_directive_class_nodez/ParallelRangeTransform.get_directive_class_node  s     ))!8!89I001H1H1KLI#,#&88D,C,CAB,G#HJI!((-I$$((3; > > $ 7 7 :j H$((3i?@).&"&
r)   c                 b    |j                   r"|j                   | _         | j                  |      S |S )zd
        If any parallel directives were imported, copy them over and visit
        the AST
        )r  r  r#   s     r&   rQ   z'ParallelRangeTransform.visit_ModuleNode  s1    
 ##'+'?'?D$??4(( r)   c                 n    | j                  |      r#|j                  g| _        |j                  | _        |S r!   )r  rx   r  r  r  r#   s     r&   r  z%ParallelRangeTransform.visit_NameNode  s1    **40'+yykD#-1-B-BD*r)   c                     | j                  |       | j                  r%| j                  j                  |j                         |S r!   )r8   r  r   	attributer#   s     r&   r  z*ParallelRangeTransform.visit_AttributeNode  s6    4 ""##**4>>:r)   c                 R   | j                  |d       | j                  s| j                  |d       |S t        |t        j
                        r#|j                  j                  }|j                  }n|j                  }i }| j                  |      }|r ||j                  ||      }|S )Nr  )r  r9  )ry   kwargs)r  r  r8   rN   r   rq  positional_argsry   keyword_argsr  rL   )r$   r%   ry   r  parallel_directive_classs        r&   visit_CallNodez%ParallelRangeTransform.visit_CallNode  s    j)&&t];K
 dI556'',,D&&F99DF#'#@#@#F # ,DHH4ODr)   c                    | j                  |j                        }t        |t        j                        rX| j
                  dk(  r t        |j                  j                  d       d| _        | j                  |d      }d| _        ||_	        |S | j                  r=| j                  |      }|sy|t        j                  u rt        |j                  d       y| j                  |d       |S )z.Rewrite with cython.parallel.parallel() blockszparallel withz*Nested parallel with blocks are disallowedrO   Nz%The parallel directive must be called)r$  rh  rN   r   ParallelWithBlockNodern  r   rL   r  rO   r  r  )r$   r%   newnoderO   r  s        r&   rl  z)ParallelRangeTransform.visit_WithStatNode  s    **T\\*gu::;zz_,dll&&BD )DJ??40DDJGLN$$'+'D'DT'J$+'5+F+FFdhh GHf%r)   c                 H   | j                  |d       | j                  |d       t        |j                  j                  t        j
                        }| j                  }|r|j                  j                  }|j                  |_        |j                  |_        |j                  |_	        |}t        |j                  t        j                        s t        |j                  j                  d       d| _        | j                  |d       || _        | j                  |d       |S )z/Rewrite 'for i in cython.parallel.prange(...):'r   r   z+Can only iterate over an iteration variabler  rO   else_clause)r  rN   r   sequencer   ParallelRangeNodern  r   rO   r  r   r   r   rL   )r$   r%   	in_prangeprevious_stateparallel_range_nodes        r&   r  z*ParallelRangeTransform.visit_ForInStatNode<  s    j)h't}}55$668	 #'--"8"8)-&'+yy$.2.>.>+&Ddkk9+=+=>dkkooCE "DJf%#
m,r)   c                 (    |t         |   |      S y)zVisit a node that may be NoneN)rB   r$  r  s     r&   r$  zParallelRangeTransform.visit[  s    7=&& r)   )r:   r;   r<   r=   r  r  in_context_manager_sectionrn  r   r  r   ParallelThreadIdNoder  r  r  r  rQ   r  r  r  rl  r  r$  ri   rj   s   @r&   r  r    s    	  !& "' E %*$?$?$-$B$B"'"9"9	N2
0:>' 'r)   r  c                   0    e Zd Zd Zd Zej                  Zy)WithTransformc                    | j                  |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t%        d
      D cg c]  }t        j&                  |       c}      }t        j(                  |t        j*                  |t        j,                  |t        j.                  |t        j0                  ||d||rt        j                  |d       nd             t        j2                  |            gd       d d |      }	t        j4                  |t        j6                  |||	gd       t        j8                  |t        j0                  ||dt        j"                  |t%        d
      D cg c]  }t        j:                  |       c}      |rt        j                  |d       nd             d      |_        |S c c}w c c}w )NrO   
__aenter__	__enter__T)r  r  is_special_lookup)r  ry   is_temp)r   )r   	with_noder   r  )slowry   F)	with_stattest_if_runry   
await_exproperand)ro  rO   )
if_clausesr  )rO   patternr   excinfo_target)rO   except_clausesr  ry   ru   )rO   r   handle_error_case)r8   rL   is_asyncrO   r   rh  r   	ProxyNoderp  r#  	CloneNoder   
enter_callAwaitExprNoder   rP   WithTargetAssignmentStatNode	TupleNoder[  ExcValueNodeExceptClauseNode
IfStatNodeIfClauseNodeNotNodeWithExitCallNodeReraiseStatNoder   TryExceptStatNoder   r1  )
r$   r%   rL   r  rO   r   rh  r   r  except_clauses
             r&   rl  z WithTransform.visit_WithStatNodeb  s|   4&*hh== $		4;;gf!*!4!4W!==$,#22)11,,W5'kR"&(  '55ctODO%%6649D #,,St16qC;,-I""3'C; <..e&&&&y'8'8)C)C #t,1%3U]9+B+B3D+Qcg	*i(j #2237
! !" )!
& ,,e--$ - 
 !--)444 $",,E!H"Mq9#5#5c#:"MOIQy66sEW[]^ $
	 IC;@ #Ns   8J9$J>"c                     |S r!   r"   r#   s     r&   rU   zWithTransform.visit_ExprNode      r)   N)r:   r;   r<   rl  rU   r   r  r  r"   r)   r&   r  r  a  s    <| "55Jr)   r  c                   0     e Zd Z fdZd Zd Zd Z xZS )#_GeneratorExpressionArgumentsMarkerc                 0    t         |           || _        y r!   )rB   rC   gen_expr)r$   r  rH   s     r&   rC   z,_GeneratorExpressionArgumentsMarker.__init__  s     r)   c                 |    |j                   s|j                  rJ | j                  |_        | j                  |       y r!   )rE  generator_arg_tagr  r8   r#   s     r&   rU   z2_GeneratorExpressionArgumentsMarker.visit_ExprNode  s/    ../%)]]D"4 r)   c                      y r!   r"   r#   s     r&   r  z._GeneratorExpressionArgumentsMarker.visit_Node  s     	r)   c                 &    | j                   |_        y r!   )r  r  r#   s     r&   r   zA_GeneratorExpressionArgumentsMarker.visit_GeneratorExpressionNode  s    !%r)   )r:   r;   r<   rC   rU   r  r   ri   rj   s   @r&   r  r    s    !!
/r)   r  c                   <    e Zd Zd Zd Zd Zd Zej                  Z	y)_HandleGeneratorArgumentsc                    ddl m} t        |t        j                        sJ || _        t        |j                  j                        | _        t        |j                        | _	        d| _
        i | _        | j                  |       | j                  j                         D ]  \  }}|j                  |||        | j                  |j                  _        | j                  |_	        |S )Nr   )Visitorr   )rm  r  rN   r   GeneratorExpressionNodegen_noderN  r   ry   call_parameters	tag_countsubstitutionsr8   r\  recursively_replace_node)r$   r%   r  kvs        r&   r  z"_HandleGeneratorArguments.__call__  s    $	 A ABB++,	#D$8$894 &&,,. 	9DAq ,,T1a8		9 "YY#33r)   c                 ,    | j                  |d      }|S )NF)do_visit_children_handle_ExprNode)r$   r%   new_nodes      r&   r   z7_HandleGeneratorArguments.visit_GeneratorExpressionNode  s    (((G r)   c                 T   |j                   | j                  z| j                  |j                   k(  r`|j                  }| j                  }| xj                  dz  c_        t	        dj                  |            }| j                  j                  }|j                  j                  |      s-ddl	m
} t	        t        j                  |j                  t        |            z         }t        j                   ||      }	|j"                  }
t%        j&                  |
d      }
|
|	_        t        j(                  ||	d d d       }|	j*                  |_        |
|_        | j,                  j/                  |       d |_         | j0                  j/                  |       |j3                  |j                  |      |_        ||j4                  _        d|j4                  _        |r,| j                  d c}| _        | j;                  |       || _        t=        j>                  ||d	      }| j                  j                  j@                  j                  jC                  |j*                        |_        |j4                  j"                  |_        || jD                  |<   |S |r| j;                  |       |S )
Nr   z.{})SymtabrL   rx   F)remove_fakeref)rL   
declarator	base_typer   r  T)rx   initialized_check)#r  r  rL   r  r   formatr   local_scopelookup_hererm  r  r   genexpr_arg_prefixpunycodify_namer  r   r   r4  r   remove_cv_refCArgDeclNoderx   ry   r   r  declare_argumententrycname
in_closurer8   r   r   gbodylookupr  )r$   r%   r  rL   name_sourcerx   r   r  r  	name_declr4  new_argr  r  s                 r&   r  z*_HandleGeneratorArguments._handle_ExprNode  s   "".4==3L!7!77((C ..KNNaN k!:;D}}--H''33D9$%f&?&?&BXBXY\]hYiBj&jk!55#DI	yy "//UK!%	,,:>Y]_(~~#		  ))-&$$++D1 ( 9 9(:N:NPW X&+#+/(  +/--'$-""4( (
 "**3TUSI"mm44::FFMMinn]IO&__11IN'0Dt$t$r)   c                 &    | j                  |d      S rS   r  r#   s     r&   rU   z(_HandleGeneratorArguments.visit_ExprNode  s    $$T400r)   N)
r:   r;   r<   r  r   r  rU   r   r  r  r"   r)   r&   r  r    s$    ,;z1 "55Jr)   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                   j                  i        t        |   |      }| j                   j	                          |S r!   )_propertiesr   rB   r  popr  s     r&   r  z&DecoratorTransform.visit_CClassDefNode3  sQ    #!D#w*4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')rN   rL   r  r   rx   )r$   r%   r  s      r&   visit_PropertyNodez%DecoratorTransform.visit_PropertyNode;  s=    S1qPSWS\S\\^cdr)   c                    | j                  |      }|j                  s|S | j                  dk7  s| j                  j                  dk7  rt        |j                        dk(  rI|j                  d   j                  j                  r&|j                  d   j                  j                  dk(  s#t        |j                  d   j                  d       |S |}| j                  |      }|rR|j                  j                  r&|j                         }|r*| j                  |||      }nt        |j                  d       |j                  r| j                  ||j                  d         S |S )Nr   r6   r   r   r  z0Cdef functions cannot take arbitrary decorators.z*C property decorator can only be @property)r  rX  r   r   r7   r   rZ  r  rx   r   rL   _find_property_decoratordeclared_name_add_property_reject_decorated_property)r$   r%   ret_nodedecorator_noderx   s        r&   visit_CFuncDefNodez%DecoratorTransform.visit_CFuncDefNodeA  s&   %%d+K__(DOO,F,F(,R (A-$//!2D2N2N2V2VOOA&0055Gdooa(,,.`aK66t<''//))+#11$nMHn((*VW??2249KLLr)   c                    | j                   }| j                  |      }|dk7  s|j                  s|S | j                  |      }||j                  }|j
                  r| j                  ||j                  |      S | j                  |j                        }|r|j                  j                  |j                  k7  r<t        |j                  d|j                  j                  d|j                  d       n=t        |j                        dkD  r| j                  ||      S | j                  |||      S |j                  D ]_  }|j                  }|j
                  s|xj                   |j                  dk(  z  c_        |xj"                  |j                  dk(  z  c_        a |j                  }d |_        | j%                  |||j                        S )Nr   z&Mismatching property names, expected 'z', got 'r
  r   rB  r  )r   r  rX  r  rZ  r  r  rx   _map_property_attributer  r  r   rL   r   r  _add_to_propertyis_classmethodis_staticmethodchain_decorators)r$   r%   r   r
  rZ  handler_namefuncdecss           r&   r  z DecoratorTransform.visit_DefNode[  s   __
%%d+!K 66t<%&00I  ))$		>JJ#;;I<O<OP }}))TYY6n00"+--"4"4diiAB T__-1#>>t^TT#44T<XX  	DI&&D||##tyyM'AA#$$		^(CC$		D $$T4;;r)   c                     | j                   d   }|j                  d d d   D ]V  }|j                  }|j                  r|j                  dk(  r|c S |j
                  s;|j                  j                  |v sT|c S  y )Nr   property)r   rX  rZ  r  rx   is_attributer  )r$   r%   
propertiesr
  rZ  s        r&   r  z+DecoratorTransform._find_property_decorator  sx    %%b)
"oodd3 	&N&00I  Y^^z%A%%''IMM,>,>*,L%%	& r)   c                 `    | j                   D ]  }||k7  s	t        |j                  d         | S )Nz=Property methods with additional decorators are not supported)rX  r   rL   )r%   r
  decos      r&   r  z-DecoratorTransform._reject_decorated_property  s7     OO 	aD~%dhh _`	a r)   c                 h   t        |j                        dkD  r| j                  ||      S |j                  j                  |       | j                  d   }t        |t        j                        }t        j                  |j                  |g      }|rl||v rt        |j                  d       d|j                  vrt        |j                  d       t        j                  |j                  |j                  ||      }n||v rm||   }|j                  rt        |j                  d       y t        d      |_        |j                  |_	        |j                  |_        |g|j"                  _        y t        d      |_        t        j&                  |j                  ||j                  |	      }|||<   |S )
Nr   r   r   C property redeclaredr  z+C property method must be declared 'inline')r|   rx   rO   r  )rx   r|   rO   )r   rX  r  remover   rN   r   r  rP   rL   r   r  CPropertyNoder|   is_cpropertyr   rx   rO   rM   PropertyNode)r$   r%   rx   r
  r  r  rO   props           r&   r  z DecoratorTransform._add_property  sd   t!#224HH~.%%b)
!$(:(:;!!$((4&9z!dhh 78t~~-dhh MN&&txxTXXDtTDZd#D  dhh 78 	 *)4	8888#'&		%i0DI%%t>D
4r)   c                 j   | j                   d   }||j                     }|j                  rt        |j                  d       y ||_        |j
                  j                  |       |j                  j                  }t        |      D ]  \  }}|j                  |k(  s|||<    y  |j                  |       y )Nr   r  )r   rx   r  r   rL   rX  r  rO   rM   rZ  r   )	r$   r%   rx   rZ  r  r!  rM   r_  stats	            r&   r  z#DecoratorTransform._add_to_property  s    %%b)
$))$$((34	y)		 ' 	GAtyyD a 	
 LLr)   c                    t        j                  | j                  |      }|ddd   D ]/  }t        j                  |j                  |j                  |g      }1 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  ry   r   )	r   r   rL   rp  rZ  r   r   IndirectionNodedecorator_indirection)r%   rX  rx   decorator_resultrZ  r  reassignments          r&   r  z#DecoratorTransform.chain_decorators  s     %--dhhTB#DbD) 	)I(77",,&' )	) &&txxd;	11HH "
 ,,l^<%1"l##r)   )r:   r;   r<   r=   r   r   r   r  r  r  r  r  r  r  r  r  r  r  ri   rj   s   @r&   r  r  #  s     K  	*	* + 
c	 4$<L
  <" $ $r)   r  c                   *    e Zd ZdZd ZeZeZeZeZeZ	y)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| j                  |      S t        |j                        D ]  \  }}|j                  }t        |t        j                        s.|j                  j                  sE|j                  j                  dk(  s_|j                         \  }}|rt        d      t        |      dk7  rt        d      |d   j                  r|d   j                  t         j"                  u st        d      |d   j%                  d       }|j                  |= t'        j(                  |j*                  ||      } n | j                  |      S )	NrX  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)rL   r%   r  )getattrr  rZ  rX  rZ  rN   r   r  r  r  rx   r  r   r   rE  r4  r   unicode_typecompile_time_valuer   CnameDecoratorNoderL   )r$   r%   r_  rZ  ry   r  r  s          r&   handle_functionz(CnameDirectivesTransform.handle_function  sD   t\40??4((%doo6 	LAy!++I9i&8&89&&..&&++w6(;;=f(MO O t9>(HJ J Q**tAw||w?S?S/S(RT T Q2248OOA&//DHH46;=1	4 t$$r)   N)
r:   r;   r<   r=   r1  r  r  r1   r3   r+   r"   r)   r&   r+  r+    s-    %@ ()("1'r)   r+  c                   @    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	 Zy
)ForwardDeclareTypesz
    Declare all global cdef names that we allow referencing in other places,
    before declaring everything (else) in source code order.
    c                     | j                   }|j                  }|j                  |_        | j                  |       ||_        |S r!   )r  r  r8   )r$   r%   envr  s       r&   r  z0ForwardDeclareTypes.visit_CompilerDirectivesNode  s;    nn4 r)   c                     |j                   | _        |j                  | j                  _        | j                  |       |S r!   )r  r  r  r8   r#   s     r&   rQ   z$ForwardDeclareTypes.visit_ModuleNode  s3     JJ'+$4 r)   c                     | j                   j                  }d| j                   _        | j                  |       || j                   _        |S Nr   )r  in_cincluder8   )r$   r%   old_cinclude_flags      r&   visit_CDefExternNodez(ForwardDeclareTypes.visit_CDefExternNode#  sC     --99()%4 (9%r)   c                 <    |j                  | j                         |S r!   )r  r  r#   s     r&   r1   z&ForwardDeclareTypes.visit_CEnumDefNode*  s    T&&'r)   c                     |j                   | j                  j                  vr|j                  | j                         |S r!   )rx   r  entriesr  r#   s     r&   r3   z/ForwardDeclareTypes.visit_CStructOrUnionDefNode.  s1    99D--555LL**+r)   c                    |j                   | j                  j                  vr|j                  | j                         | j                  j                  |j                      j                  }||j
                  rs|j                  sg|j                  r[|j                  }|j                  D ]@  }|j                  s|j                  j                  s'|j                  j                          B |S r!   )
class_namer  r>  r  r4  is_extension_typeis_builtin_typer  cfunc_entriesis_fused"get_all_specialized_function_types)r$   r%   r4  r  r  s        r&   r  z'ForwardDeclareTypes.visit_CClassDefNode3  s    ??$"3"3";";;LL**+  ((9>> 6 6t?S?SX\XbXbJJE,, D::%**"5"5JJAACD r)   c                     |S r!   r"   r#   s     r&   r  z%ForwardDeclareTypes.visit_FuncDefNode?  r  r)   c                     |S r!   r"   r#   s     r&   rP  z(ForwardDeclareTypes.visit_PyClassDefNodeC  r  r)   N)r:   r;   r<   r=   r  rQ   r;  r1   r3   r  r  rP  r"   r)   r&   r3  r3    s/    


r)   r3  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
    )rL  z;
if VALUE is not None:
    ATTR = VALUE
    count += 1
    r   c                     g | _         t               | _        t               }|j                  | _        |j                  |      S r!   )seen_vars_stackr)  fused_error_funcsrB   r  _super_visit_FuncDefNoder  )r$   rootsuper_classrH   s      r&   r  z%AnalyseDeclarationsTransform.__call__x  s;    !!$g(3(E(E%##D))r)   c                 V    | j                   d   j                  |j                         |S Nr   )rN  rF  rx   r#   s     r&   r  z+AnalyseDeclarationsTransform.visit_NameNode  s$    R $$TYY/r)   c                 L   g | _         | j                  j                  t                      |j	                  | j                                | j                  |       | j                  j                          |j                  j                  j                  | j                          |S r!   )extra_module_declarationsrN  r   r)  analyse_declarationscurrent_envr8   r  rO   rM   r  r#   s     r&   rQ   z-AnalyseDeclarationsTransform.visit_ModuleNode  sx    )+&##CE*!!$"2"2"454   "		t==>r)   c                     | xj                   dz  c_         |j                  | j                                | j                  |       | xj                   dz  c_         |S r8  )	in_lambdarW  rX  r8   r#   s     r&   r   z-AnalyseDeclarationsTransform.visit_LambdaNode  sH    !!!$"2"2"454 !r)   c                    | j                  |      }|j                  r?d|j                  j                  v r'ddlm}  |||j                  j                  d   |        |j                  r|j                  j
                  r|j                  rg }|j                  j                  D ]]  }|j                  s| j                  |      }|j                  |j                         | j                  |       |j                  |       _ |r|j                  xj                  |z  c_        |j                  dk7  rG|j                  j                  d      s,|j                  j                  d      s| j!                  |       |S )Ndataclasses.dataclassr   )handle_cclass_dataclassr6   
__reduce____reduce_ex__)visit_ClassDefNoder  r  	Dataclassr]  implementedrO   var_entriesneeds_propertycreate_PropertyrW  r$  r   rM   r7   r  _inject_pickle_methods)r$   r%   r]  rM   r  r  s         r&   r  z0AnalyseDeclarationsTransform.visit_CClassDefNode  s   &&t,::1TZZ5J5JJ:#D$***?*?@W*XZ^_::$**00TYYE// +''#33E:H11$**=JJx(LL*+ 		5(8+ JJ--l; JJ--o>++D1r)   c                    | j                         }|j                  j                  d   du ry |j                  j                  d   du }g }|j                  j                  }d }d }||j                  d |j                  j                  D               |xs |j                  j                  d      }|xs8 |j                  j                  d      xs |j                  j                  d      }|j                  }||j                  d 	       |ry |D cg c]P  }|j                  j                  s8|j                  j                  |      r|j                  j                  |      s|R }	}|D cg c]  }|j                  j                  s| }
}|s|	s|
r|s|rd
}n9|	rddj                  d |	D              z  }nddj                  d |
D              z  }|rt        |j                   |       t#        dd|iz  dt%        d       g      j'                  i       }|j)                  |j                         | j+                  |       |j,                  j.                  j1                  |       y |D ]O  }|j                  j                  r|j                  j3                  |       |j                  j5                  |       Q |D cg c]  }|j6                   }}dj                  t9        |      D cg c]  \  }}d|d|d c}}      }t;        |      }t=        |      dk7  r||d   dz  gz   d d }d|j>                   }t=        |      }|jA                  tB        jD                  jG                  dd             d| dd j                  |       d d j                  |      jI                  d!      d"|jJ                   d#| d$|jJ                   d%| d&|jJ                   d'| d(|d)d*}|jA                  tB        jD                  jG                  d+d             t#        |d,t%        d       g      j'                  i       }|j)                  |j                  j                         | j+                  |       | jL                  j1                  |       d j                  d- |D              t=        |      d.k(  rdnd/z   }d0j                  |D cg c])  }|j                  j                  sd1|j6                   d2+ c}xs d3g      }d4| d5| d6| d7|d8    d9| d7|d8    d:| d;}t#        |dt%        d       g      j'                  i       }|j)                  |j                         | jO                  ||j                         | j+                  |       | jQ                          |j,                  j.                  j1                  |       y c c}w c c}w c c}w c c}}w c c}w )<Nauto_pickleFTc              3   >   K   | ]  }|j                   d vs|  yw))__weakref____dict__Nr   .0r   s     r&   	<genexpr>zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>  s     mQ166QlClqms   	__cinit__r^  r_  c                     | j                   S r!   r   )r   s    r&   <lambda>zEAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<lambda>  s
    qvv r)   )r]  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    ywzself.%sNr   rl  s     r&   rn  zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>  s     Y}qrZcfgflflZlY}   zZPickling of struct members such as %s must be explicitly requested with @auto_pickle(True)c              3   :   K   | ]  }d |j                   z    ywrs  r   rl  s     r&   rn  zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>  s     ;`STI<N;`rt  z
                def __reduce_cython__(self):
                    raise TypeError, "%(msg)s"
                def __setstate_cython__(self, __pyx_state):
                    raise TypeError, "%(msg)s"
                msgrJ  rK  z; z__pyx_result.z = __pyx_state[]r  r   r   __pyx_unpickle_UpdateUnpickledDictzExtensionTypes.cz
                cdef extern from *:
                    int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1
                    int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1

                def z(__pyx_type, long __pyx_checksum, tuple __pyx_state):
                    cdef object __pyx_result
                    __Pyx_CheckUnpickleChecksum(__pyx_checksum, z, zUTF-8z%)
                    __pyx_result = z].__new__(__pyx_type)
                    if __pyx_state is not None:
                        z__set_state(<z[> __pyx_result, __pyx_state)
                    return __pyx_result

                cdef z__set_state(z8 __pyx_result, __pyx_state: tuple):
                    zJ
                    __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, dz)
            CheckUnpickleChecksumr   c              3   &   K   | ]	  }d |   yw)self.Nr"   )rm  r  s     r&   rn  zFAnalyseDeclarationsTransform._inject_pickle_methods.<locals>.<genexpr>	  s     G%sGs   r   rm  z or r}  z is not NoneFalsez
                def __reduce_cython__(self):
                    cdef tuple state
                    cdef object _dict
                    cdef bint use_setstate
                    state = (a	  )
                    _dict = getattr(self, '__dict__', None)
                    if _dict is not None and _dict:
                        state += (_dict,)
                        use_setstate = True
                    else:
                        use_setstate = zE
                    if use_setstate:
                        return z, (type(self), r   zH, None), state
                    else:
                        return zZ, state)

                def __setstate_cython__(self, __pyx_state):
                    z+__set_state(self, __pyx_state)
            ))rX  r  r  r  r4  r  rc  r  r  sortis_pyobjectcan_coerce_to_pyobjectcan_coerce_from_pyobjectis_struct_or_unionr  r   rL   r   r?   
substituterW  r$  rO   rM   r   create_to_py_utility_codecreate_from_py_utility_coderx   rZ  _calculate_pickle_checksumsr   punycode_class_nameuse_utility_coder   UtilityCodeload_cachedencoder@  rV  enter_scope
exit_scope)r$   r%   r5  auto_pickle_forcedall_membersr6  cinitinherited_reducer   non_pystructsrv  pickle_funcall_members_namesixr  assignments	checksumsunpickle_func_namenum_membersunpickle_codeunpickle_funcmembersany_notnone_memberspickle_codes                            r&   rf  z3AnalyseDeclarationsTransform._inject_pickle_methods  s    ::  /58!ZZ22=ATIjjooom#))*?*?mm:SYY--k:E/v3993C3CL3QvUXU^U^UeUefuUv--C	 o
 	-.  #
66%%qvv/L/LS/Q23&&2Q2QRU2V 
 
 *GQVV-F-F1GGFw/AJNQTQYQYY}v|Y}Q}}
13688;`X_;`3`a "dhh$& (
 cl(#  =+>*?A BLB  ,,TZZ8JJ{#IIOO"";/ ! <vv))FF44S9FF66s;<
 2= =A = =))&'89%B 89"=% K 44EFI9~"&)B-!*;)<<bqA	#243K3K2L!M/0K  !1!1!=!=>SUg!hi!
 (( )AAE9AU@VVXY]YbYbctYuY|Y|  ~E  ZF  YI I$$(OO#4 5+,M$//9J K ))doo5F G M "JJUVW YM$   !1!1!=!=>UWi!jk(hR_`dReQfgrrsuvM..tzz/?/?@JJ}%**11-@iiG5FGGRUVgRhlmRm3suvG"(++U`.wPQdedjdjdvdvqvvhl/K.w  /E  }D  |E  #F
 &Y '( )<'< =  23?9Q<. Q  23?9Q<. Q (( )%K* '{)}]aObNcdooprsK,,TZZ8T4::.JJ{#OOIIOO"";/g
 HF !>%X /xs+   AW1WWW5W
W!+W!c                 n   g }|D ]U  }|j                   }|j                  r*|j                  dvs|j                  |j                        sE|j	                  |       W |rVt        | j                        }|j                  }|j                  |||j                        \  }	}
|
j                  |       ||
g}|S )zd
        Create function calls to the decorators and reassignments to
        the function.
        )r  rB  )
rZ  r  rx   r  r   r  rG   r%   r  rW  )r$   old_decoratorsr5  r%   rX  rZ  r  	transformr   r   reassignmentss              r&   _handle_fused_def_decoratorsz9AnalyseDeclarationsTransform._handle_fused_def_decorators7	  s     
' 	-I&&DLLII%DDOODII.!!),	- *4<<8IyyH(99*hmm 5A}..s3-(Dr)   c                 "   |j                   j                  d|j                         | j                  |d       |j	                  |       d|j                  j
                  j                  _        t        j                  j                  |j                  d      }t        j                  |j                  |            }||_        | j                  |j                  t        j                  |      |      |_        |r| j#                  |||      }|S )z#Handle def or cpdef fused functionsr   py_funcFT)binding)rM   insertr  r  update_fused_defnode_entryr  	signatureuse_fastcallr   PyCFunctionNodefrom_defnoder  coerce_to_tempresulting_fused_function_create_assignmentr  fused_func_assignmentr  )r$   rX  r5  r%   pycfuncs        r&   _handle_defz(AnalyseDeclarationsTransform._handle_defQ	  s     	

!T\\*i('',49$$1++88t8T%%g&<&<S&AB(/%%)%<%<LL)--g6&=" 44ZdKDr)   c                    ddl m} | j                  s| j                  r| j                  | j                  vr9| j                  rt        |j                  d       nt        |j                  d       | j                  j                  | j                         t        j                  |j                        |_
        |j                  D ];  }|j                  j                  s|j                  j                         d   |_        = |S t        |dd      }|j!                  ||      }|| _        | j#                  |       d| _        |j$                  r| j'                  |||      }|S )z:Create a fused function for a DefNode with fused argumentsr   )	FusedNodezFused lambdas not allowedzCannot nest fused functionsr   rX  N)rm  r  fused_functionrZ  rO  r   rL   rF  r   re   rO   ry   r4  rD  get_fused_typesr-  FusedCFuncDefNoder8   r  r  )r$   r5  r%   r  r   rX  s         r&   _create_fused_functionz3AnalyseDeclarationsTransform._create_fused_functione	  s   $..""$*@*@@>>$(($?@$(($AB""&&t':':;**4884DIyy =88$$"xx779!<CH= KT<6
**45"4 "<<##JT:Dr)   c                     |j                   rY|j                  rMt        |j                  d       d|_        t	        j
                  |j                  g       |j                  _        |j                  S )NzFused generators not supportedFr   )is_generatorhas_fused_argumentsr   rL   r   rP   r  rO   r#   s     r&   _handle_fusedz*AnalyseDeclarationsTransform._handle_fused	  sR    !9!9$((<=',D$#00DDJJO'''r)   c                 $   | j                         }| j                  j                  t                      |j                  }|j                  |       |j                  j                         D ]  \  }}|j                  |      r|j                  |      }|r3|j                  r'|j                  r|j                  |j                        }|r|j                  |||j                         ~t        |j                  d        | j!                  |      r| j#                  ||      }n,|j$                  j'                  |       | j)                  |      }| j                  j+                          d|j,                  v rddlm} |j3                  |      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 typerU  r   )UFuncs)rX  rN  r   r)  r  declare_argumentsrK  r\  r  analyse_as_typerD  fused_to_specific
specializedeclare_varrL   r   r  r  rO   rW  rP  r  r  rm  r  convert_to_ufunc)r$   r%   r5  lenvvar	type_noder4  r  s           r&   r  z.AnalyseDeclarationsTransform.visit_FuncDefNode	  sJ     ##CE*t$ #3399; 	7NC##C( 006DMMd.D.D??4+A+ABD$$S$	>)--6	7 d#..sD9DII**40006D  "doo% **400r)   c                    | j                  |      }t        |t        j                        s|S | j	                         }|j
                  5t        j                  |      |_        |j
                  j                  |       |j                  s|j                  r|S |j                  |      s|S || j                  ||      gS r!   )r  rN   r   r   rX  code_objectr   CodeObjectNoderW  fused_py_funcis_generator_bodyneeds_assignment_synthesis_synthesize_assignmentr$   r%   r5  s      r&   r  z*AnalyseDeclarationsTransform.visit_DefNode	  s    %%d+$.K #(77=D11#6!7!7K..s3Kd11$<==r)   c                     |j                   Y|j                  Mt        j                  j	                  |      |_         |j                   j                  | j                                | j                  |      S r!   )r  r  r   r  	for_cfuncrW  rX  r  r#   s     r&   r  z/AnalyseDeclarationsTransform.visit_CFuncDefNode	  s^    #(<(77AA$GD11$2B2B2DE%%d++r)   c                 $    | j                  |      S r!   )r  r#   s     r&   visit_GeneratorBodyDefNodez7AnalyseDeclarationsTransform.visit_GeneratorBodyDefNode	  s    %%d++r)   c                 ^    | j                  |      }|j                  |j                  _        |S r!   )r  r  r  )r$   r%   r   s      r&   visit_GeneratorDefNodez3AnalyseDeclarationsTransform.visit_GeneratorDefNode	  s)    ##D)!%!1!1

r)   c                    |}|j                   s|j                  r&|j                  }|j                   r|j                  r&|j                   xs | j                  j	                  d      }|j
                  r(t        j                  j                  ||      x}|_	        n t        j                  j                  ||      }|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%   r5  genvr  r   s         r&   r  z3AnalyseDeclarationsTransform._synthesize_assignment	  s    $$(=(=##D $$(=(= ''Q4+B+B+F+Fy+Q  '0'B'B'O'OPTV]'^^C$$++88wGC [[&&tS#66r)   c                 l   |j                   rK|j                   d d d   D ]/  }t        j                  |j                  |j                  |g      }1 d |_         t        j                  |j                  t        j                  |j                  |j                        |      }|j                  |       |S )Nr   r%  r   r   )
rX  r   rp  rL   rZ  r   r   r   rx   rW  )r$   r   r   r5  rZ  assmts         r&   r  z/AnalyseDeclarationsTransform._create_assignment	  s    %0026 "	..MM(225""
 #'H**LL""8<<hmmD 	""3'r)   c                     | j                   j                         }t        |   |       | j                   j	                  |       y r!   )rN  r  rB   visit_func_outer_attrsr   )r$   r%   stackrH   s      r&   r  z3AnalyseDeclarationsTransform.visit_func_outer_attrs	  s8    $$((*&t,##E*r)   c                    | j                         }|j                  |       |j                  r| j                  j	                  t        | j                  d                | j                  ||j                         |j                  |j                         | j                  |       | j                          | j                  j                          |S |j                  |       | j                  |       |S rT  )rX  rW  
expr_scoperN  r   r)  r  analyse_scoped_declarationsr8   r  r  r  s      r&   visit_ScopedExprNodez1AnalyseDeclarationsTransform.visit_ScopedExprNode	  s     !!#&??  ''D,@,@,D(EFT4??3,,T__=t$OO  $$&
  ,,S1t$r)   c                 f    | j                  |       |j                  | j                                |S r!   r8   rW  rX  r#   s     r&   visit_TempResultFromStatNodez9AnalyseDeclarationsTransform.visit_TempResultFromStatNode
  ,    4 !!$"2"2"45r)   c                 D    |j                   dk(  ry | j                  |      S r5   )r7   r`  r#   s     r&   r9   z/AnalyseDeclarationsTransform.visit_CppClassNode
  s"    ??h&**400r)   c                      	 y r!   )*r   r#  rL   r   r   r  r4  r  rc  r   rx   rr  init_assignmentr  r   struct_or_union_wrapperr   rP   r  	is_structr  rn  replacerM   r@  shadowrO   rN   r  CSimpleBaseTypeNoder   ry   kw_onlyr   r  r  r  basic_pyobject_propertybasic_propertyrW  rX  r  )r$   r%   
self_valuerc  
attributesr  init_assignmentsattr
str_formatwrapper_class
class_bodyinit_methodarg_templater   templater  s                   r&   r3   z8AnalyseDeclarationsTransform.visit_CStructOrUnionDefNode
  s
     r)   c                 (    | j                  |       |S r!   r  r#   s     r&   r-   z2AnalyseDeclarationsTransform.visit_CDeclaratorNodei
  s    4 r)   c                     |S r!   r"   r#   s     r&   r'   z/AnalyseDeclarationsTransform.visit_CTypeDefNoden
  r(   r)   c                      y r!   r"   r#   s     r&   r/   z0AnalyseDeclarationsTransform.visit_CBaseTypeNodeq
  s    r)   c                 &    |j                   dk(  r|S y )Npublic)r7   r#   s     r&   r1   z/AnalyseDeclarationsTransform.visit_CEnumDefNodet
  s    ??h&Kr)   c                 D   |j                   | j                  d   v rs| j                         j                  |j                         }|%|j                  dk7  r9|j
                  j                  s#t        |j                  d|j                   z         | j                  |       |S )Nr   r6   z,cdef variable '%s' declared after it is used)
rx   rN  rX  r  r7   r  r  r   rL   r8   r$   r%   r  s      r&   visit_CNameDeclaratorNodez6AnalyseDeclarationsTransform.visit_CNameDeclaratorNodez
  s    99,,R00$$&--dii8E!1!1X!=!KK88dhh NQUQZQZ Z[4 r)   c                 &    | j                  |       y r!   r  r#   s     r&   r+   z.AnalyseDeclarationsTransform.visit_CVarDefNode
  s    4 r)   c                 x    | j                  |d      }|sy t        |      t        u r|d   |_        |g|dd  z   S |S )Nr%   r   r   )r  r4  rN  r%   )r$   r%   
child_nodes      r&   visit_CnameDecoratorNodez5AnalyseDeclarationsTransform.visit_CnameDecoratorNode
  sH    __T62

t#"1DI6JqrN**r)   c           
         |j                   dk(  r0|j                  j                  r| j                  }n(| j                  }n|j                   dk(  r| j
                  }j                  dt        j                  |j                  t        j                  |j                  d      |j                        i|j                        j                  d   }|j                  |_        |j                  |_        |S )	Nr	  readonlyATTRr$   r  )rL   r  r  )rL   r   )r7   r4  r  r  r  basic_property_ror  r   r#  rL   r   rx   rM   r|   )r$   r  r  r  s       r&   re  z,AnalyseDeclarationsTransform.create_Property
  s    x'zz%%77..+--H&&	//EII4=4F4F599[a4b:?**F
 		 ' 
 % 

yyr)   c                 f    | j                  |       |j                  | j                                |S r!   r  r#   s     r&   r<  z;AnalyseDeclarationsTransform.visit_AssignmentExpressionNode
  r  r)   ),r:   r;   r<   r   r?   r  r  r  r  r  r  rZ  r  r  rQ   r   r  rf  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r9   r3   r-   r'   r/   r1   r  r+   r  re  r<  ri   rj   s   @r&   rI  rI  H  sL   ! # M$$7#8:N + , M$$7#8: % & M$$7#8	: + , !&') # $ !&'	)O NI**K0Z4(<('R>,,7 +"
1P7l

(r)   rI  c                 2   dj                  |       j                  d      }t        j                  dk\  rddini }g }dD ]A  }	 t	        t
        |      } ||fi |j                         }|j                  d|d d z          C |S # t        t        f$ r Y Ww xY w)	N zutf-8)r  	   usedforsecurityF)sha256sha1md50xr  )
r  r  r   version_infor-  r   	hexdigestAttributeError
ValueErrorr   )member_namesmember_names_stringhash_kwargsr  	algo_name
mkchecksumchecksums          r&   r  r  
  s     ((<077@030@0@F0J$e,PRKI. .		 )4J!"5EEOOQH 	!,-. 	 
+ 		s   'B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                         j                  | _        g | _        t               }|j                  | _        |j                  | _        | j                  |       |S r!   )	global_scoper  r  rB   r  rP  r`  _super_visit_ClassDefNoder8   )r$   r%   _superrH   s      r&   rQ   z1CalculateQualifiedNamesTransform.visit_ModuleNode
  sX    ,,.== (.(@(@%)/)B)B&4 r)   c                     |r!| j                   d d  }|j                  |       n| j                   }t        dj                  |            |_        | j
                  |_        y )Nr  )r  r   r   r  qualnamer  )r$   r%   rx   r/  s       r&   _set_qualnamez.CalculateQualifiedNamesTransform._set_qualname
  sO    **1-HOOD!**H%chhx&89++r)   c                     |j                   r|j                  s|j                  g| _        y | j                  j	                  |j                         y r!   )is_pyglobalis_pyclass_attrrx   r  r   )r$   r  s     r&   _append_entryz.CalculateQualifiedNamesTransform._append_entry
  s9    U%:%:#(::,D&&uzz2r)   c                 `    | j                  ||j                         | j                  |       |S r!   )r0  rx   r8   r#   s     r&   visit_ClassNodez0CalculateQualifiedNamesTransform.visit_ClassNode
  s)    4+4 r)   c                 J    | j                  |       | j                  |       |S r!   )r0  r8   r#   s     r&   visit_PyClassNamespaceNodez;CalculateQualifiedNamesTransform.visit_PyClassNamespaceNode
  s#    4 4 r)   c                 `   | j                   d d  }|j                  j                  rJ| j                   r>| j                   d   dk(  r,| j                   j                          | j	                  |       n&| j	                  ||j                  j
                         | j                  |       || _         |S Nr   <locals>)r  r   
is_wrapperr  r0  rx   r8   r$   r%   orig_qualified_names      r&   visit_PyCFunctionNodez6CalculateQualifiedNamesTransform.visit_PyCFunctionNode
  s    "11!4==##(;(;@S@STV@W[e@e##%t$tT]]%7%784 1r)   c                 ~   |j                   r| j                  rw| j                  d   dk(  sJ | j                         | j                  d d  }| j                  j                          | j                  |       | j	                  |       || _        |S | j                  ||j
                         | j                  |       |S r:  )r<  r  r  r0  rP  rx   r  r=  s      r&   r  z.CalculateQualifiedNamesTransform.visit_DefNode
  s    ??t22&&r*j8M$:M:MM"&"5"5a"8##%t$))$/"5D  tTYY/""4(r)   c                    | j                   d d  }t        |dd       dk(  r| j                   j                  d       n| j                  |j                         | j                   j                  d       | j                  |       || _         |S )Nrx   z<lambda>r;  )r  r-  r   r4  r  rP  r=  s      r&   r  z2CalculateQualifiedNamesTransform.visit_FuncDefNode   sy    "11!44&*4&&z2tzz*"":.%%d+1r)   c                    |j                   j                  |      }t        j                  |j                  t        |      |d      }t        j                  |j                  |      }|j                  j                  j                  dt        j                  |j                  ||      j                  | j                                      y )NT)rx   r  	is_targetrv   r   r   )r  r  r   r   rL   r   rn  rO   rM   r  r   r   analyse_expressionsrX  )r$   r%   rx   rw   r  r   r   s          r&   generate_assignmentz4CalculateQualifiedNamesTransform.generate_assignment  s    

&&t,  HHt$	
 ##DHHE:		q%"<"<HH#
 
d..0
1		3r)   c           	      H   | j                   }d| _         | j                  }d| _        | j                  d d  }t        |dd       xs3 | j	                         j                  |j                  j                        }| j                  |       | j                  |       | j                   r5| j                  |dt        dj                  | j                                     | j                  r&| j                  |dt        | j                               || _        || _         || _        |S )NFr  r<   r  r;   )needs_qualname_assignmentneeds_module_assignmentr  r-  rX  r  r   rx   r4  r,  rE  r   r  r  )r$   r%   orig_needs_qualname_assignmentorig_needs_module_assignmentr>  r  s         r&   r`  z3CalculateQualifiedNamesTransform.visit_ClassDefNode  s	   )-)G)G&).&'+'C'C$',$"11!4w- B!!#//0@0@A 	5!&&t,))$$T>%2388D<O<O3P%QS''$$T<%243C3C%DF1)G&'C$r)   c                     | j                         }|j                  r.|j                  dk(  r	d| _        |S |j                  dk(  rd| _        |S )Nr<   Tr;   )rX  r  rx   rG  rH  )r$   r%   r  s      r&   r  z/CalculateQualifiedNamesTransform.visit_NameNode.  sQ      "!! yyN*15.  l*/3,r)   r!   )r:   r;   r<   r=   rG  rH  rQ   r0  r4  r6  r8  r?  r  r  rE  r`  r  ri   rj   s   @r&   r)  r)  
  sM     !&#,3
		3*r)   r)  c                   6    e Zd Zd Zd Zd Zd Zd Zd Zd Z	y)	AnalyseExpressionsTransformc                     |j                   j                          |j                  j                  |j                         |_        |j                  hg| _        | j                  |       | j                  |       |S r!   )r  infer_typesrO   rD  rL   	positionsr8   _build_positionsr#   s     r&   rQ   z,AnalyseExpressionsTransform.visit_ModuleNode?  s\    

 II11$**=	88*4 d#r)   c                    |j                   j                          |j                  j                  |j                         |_        | j                  d   j                  |j                         |j                  r| j                  d   }n|j                  h}| j                  j                  |       | j                  |       | j                  |       |S rT  )r  rO  rO   rD  rP  rF  rL   r<  r   r8   rQ  )r$   r%   local_positionss      r&   r  z-AnalyseExpressionsTransform.visit_FuncDefNodeG  s    $$&II11$2B2BC	rtxx(??"nnR0O#xxjOo.4 d#r)   c                     |j                   r5|j                  j                          |j                  |j                        }| j	                  |       |S r!   )r   r  rO  analyse_scoped_expressionsrU   r#   s     r&   r  z0AnalyseExpressionsTransform.visit_ScopedExprNodeW  sB    OO'')224??CDD!r)   c                     | j                  |       |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.
        )rU   is_fused_indexr4  is_errorr   r#   s     r&   visit_IndexNodez+AnalyseExpressionsTransform.visit_IndexNode^  s5     	D!tyy'9'999Dr)   c                 x    | j                   d   j                  |j                         | j                  |       |S rT  rP  rF  rL   r8   r#   s     r&   rU   z*AnalyseExpressionsTransform.visit_ExprNodeq  0    rtxx(4 r)   c                 x    | j                   d   j                  |j                         | j                  |       |S rT  r[  r#   s     r&   rX   z*AnalyseExpressionsTransform.visit_StatNodev  r\  r)   c                    t        | j                  j                         t        dd      d      }d}d}g }|D ])  \  }}}|j	                  |||||k(  r|n|dz   f       ||}}+ |j                          ||_        |j                          t        |      D 	
ci c]  \  }	}
|
|	
 c}
}	|j                  _	        yc c}
}	w )zg
        Build the PEP-626 line table and "bytecode-to-position" mapping used for CodeObjects.
        r   r   T)r]  reverser   r   N)
r  rP  r  r   r   r_  node_positionsrZ  r  node_positions_to_offset)r$   	func_noderP  	next_linenext_column_in_linerangesr   r  start_columnr_  positions              r&   rQ  z,AnalyseExpressionsTransform._build_positions{  s     !NN 1a 	
	 	%. 	@!At\MM4|DT]L]5Hcorscstu-1<*I	@ 	#)	   )3:
8 aK:
	6 :
s   B;N)
r:   r;   r<   rQ   r  r  rY  rU   rX   rQ  r"   r)   r&   rM  rM  =  s%     &


r)   rM  c                   $    e Zd Zd Zd Zd Zd Zy)FindInvalidUseOfFusedTypesc                 6    d| _         | j                  |       |S rA   )_in_fused_functionr$  )r$   trees     r&   r  z#FindInvalidUseOfFusedTypes.__call__  s    "'

4r)   c                 &    | j                  |       y r!   r  r#   s     r&   r  z%FindInvalidUseOfFusedTypes.visit_Node  r   r)   c                     | j                   }|j                  | _         | j                   s8|j                  s,|j                  j                  rt        |j                  d       | j                  |       || _         y )Nz-Return type is not specified as argument type)rk  r  r  return_typerD  r   rL   r8   )r$   r%   outer_statuss      r&   r  z,FindInvalidUseOfFusedTypes.visit_FuncDefNode  sb    .."&":":&& ))d.>.>.G.Gdhh OP4 ".r)   c                     | j                   s9|j                  r-|j                  j                  rt        |j                  d       y | j                  |       y )Nz6Invalid use of fused types, type cannot be specialized)rk  r4  rD  r   rL   r8   r#   s     r&   rU   z)FindInvalidUseOfFusedTypes.visit_ExprNode  s<    &&4999K9K$((TU t$r)   N)r:   r;   r<   r  r  r  rU   r"   r)   r&   ri  ri    s    
!/%r)   ri  c                       e Zd Zd Zd Zy)ExpandInplaceOperatorsc                   	 |j                   }|j                  }|j                  j                  r|S t	        |t
        j                        r|S | j                         }d	fd			  	|d      \  }} |j                  di |j                  }t        j                  |j                  |j                  ||d      }d|_        |j                  |      }|j!                  |       |j#                  |       t%        j&                  |j                  ||j)                  |j                  |            }|j+                          |D ]  }t-        ||      } |S # t        $ r |cY S w xY w)Nc                 <   | j                   r| g fS | j                  j                  r|st        |       } | | gfS | j                  rR | j
                        \  }}t        | j                        }t        j                  | j                  ||      ||gz   fS | j                  rE | 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  r4  r  r
   is_subscriptr   rv  r   	IndexNoderL   r  r  r#  r  rN   BufferIndexNoder!  )r%   rx  r   tempsrv  r  side_effect_free_references         r&   r}  zVExpandInplaceOperators.visit_InPlaceAssignmentNode.<locals>.side_effect_free_reference  s    ||Rx&&w!$'dV|#""8Ce"4::. **488$eLeW\V]o]]""7'R
U ..txxSDNN[]bbbD)";";< !cdd!$'dV|#r)   Trw  )r  operand1operand2inplacer   rh   r"   )r   r   r4  is_cpp_classrN   r   r{  rX  r!  rH   rk  
binop_noderL   r  rC  analyse_target_typesanalyse_typesanalyse_operationr   r   	coerce_tor_  r	   )
r$   r%   r   r   r5  let_ref_nodesdupbinoptr}  s
            @r&   visit_InPlaceAssignmentNodez2ExpandInplaceOperators.visit_InPlaceAssignmentNode  sI   hhhh88  Kc9445K 	$$	!;C!NC cmm+cll+$$TXX040303-1	3 &&s+#$))HH#.0
 	 	$A1d#D	$+  	K	s   %E E%$E%c                     |S r!   r"   r#   s     r&   rU   z%ExpandInplaceOperators.visit_ExprNode  r  r)   N)r:   r;   r<   r  rU   r"   r)   r&   rs  rs    s    4lr)   rs  c                   >    e Zd ZdZdZd Zd Zd Zd Zd Z	d Z
d	 Zy
)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_orderingr\  c                 X    |j                   | _         d| _        | j                  |       |S rA   )r  in_py_classr8   r#   s     r&   rQ   z&AdjustDefByDirectives.visit_ModuleNode  s(    // 4 r)   c                 p    | j                   }|j                   | _         | j                  |       || _         |S r!   r  r  s      r&   r  z2AdjustDefByDirectives.visit_CompilerDirectivesNode  s0    //4 (r)   c           	      T   g }d| j                   v r|j                  d       | j                   j                  d      }| j                   j                  d      }| j                   j                  d      }|dnd}| j                   j                  d      }|"| j                   d   r|j                  }||d	}n
|d |rdndf}| j                   j                  d
      r$d| j                   vrt	        |j
                  d       d| j                   v rdd| j                   v rt	        |j
                  d       |rt	        |j
                  d       |j                  d|||||      }| j                  |      S d| j                   v rL| j                  rt	        |j
                  d       n)|j                  d||||||      }| j                  |      S d|v rt	        |j
                  d       |rt	        |j
                  d       |rt	        |j
                  d       | j                  |       |S )Nr  rR  rS  r-  FTreturnsannotation_typingrS   c_compile_guardrT  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  rR  r  
except_valhas_explicit_exc_clausez#cfunc directive is not allowed here)r  r  rR  rS  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   rL   as_cfunctionr$  r  r  )r$   r%   r  rR  rS  r  r  return_type_nodes           r&   r  z#AdjustDefByDirectives.visit_DefNode  s	   	t&X&##G,??&&z2__((5
+5+=%4??..y9#8K(L#::+
0B)
(8eDJ??01gT__6T$((IJdoo%$//)dhh OPdhh OP$$ IU(ZYp % rD ::d##doo%dhh EF(( %%RZ,]t ) v zz$''y $((JK$((IJ$((LMt$r)   c                 8   d| j                   v rz| j                   d   }|t        |j                  d       t        j                  |j                  t        j                  |j                  |      g|j                        }||_        | j                  |       |S )Nrg  z2critical_section decorator does not take arguments)rb  rt  )	r  r   rL   r   ru  r   #FirstArgumentForCriticalSectionNoderO   r8   )r$   r%   rw   new_bodys       r&   r  z'AdjustDefByDirectives.visit_FuncDefNodeB  s    0OO$67E dhh TU44CCDHHX\]^YYH
 !DI4 r)   c                     |S r!   r"   r#   s     r&   r   z&AdjustDefByDirectives.visit_LambdaNodeP  r  r)   c                      t         fd j                  D              r!|j                         } j                  |      S  j                  }d _         j                  |       | _        |S )Nc              3   :   K   | ]  }|j                   v   y wr!   )r  )rm  r  r$   s     r&   rn  z=AdjustDefByDirectives.visit_PyClassDefNode.<locals>.<genexpr>U  s     U	yDOO+Us   T)anyconverts_to_cclass	as_cclassr$  r  r8   r$   r%   old_in_pyclasss   `  r&   rP  z*AdjustDefByDirectives.visit_PyClassDefNodeT  s`    UT=T=TUU>>#D::d##!--N#Dt$-DKr)   c                 \    | j                   }d| _         | j                  |       || _         |S rA   )r  r8   r  s      r&   r  z)AdjustDefByDirectives.visit_CClassDefNode_  s0    )) 4 )r)   N)r:   r;   r<   r=   r  rQ   r  r  r  r   rP  r  r"   r)   r&   r  r    s4    	 O,\	r)   r  c                   0    e Zd ZdZd Zd ZddZd Zd Zy)	AlignFunctionDefinitionszq
    This class takes the signatures from a .pxd file and applies them to
    the def methods in a .py file.
    c                 J    |j                   | _         | j                  |       |S r!   )r  r8   r#   s     r&   rQ   z)AlignFunctionDefinitions.visit_ModuleNodem  s     ZZ
4 r)   c                 |   | j                   j                  |j                        }|r|j                  r | j	                  |j                         |      S |j                   r|j                   j                  sFt        |j                  d|j                  z         |j                  rt        |j                  d       y |S Nz'%s' redeclaredzprevious declaration here)	r  r  rx   	is_cclassr  r  is_builtin_scoper   rL   r$   r%   pxd_defs      r&   rP  z-AlignFunctionDefinitions.visit_PyClassDefNoder  s    **##DII.  //0@'JJ]]'--*H*Hdhh 1DII =>;;'++'BCr)   Nc                     |%| j                   j                  |j                        }|r5|j                  s|S | j                   }|j                  j                   | _         | j                  |       |r| _         |S r!   r  r  r@  defined_in_pxdr4  r8   r$   r%   r  r  s       r&   r  z,AlignFunctionDefinitions.visit_CClassDefNode~  g    ?jj''8G))**K ++DJ4 $DJr)   c                 ^   | j                   j                  |j                        }|r|j                   r|j                   j                  sc|j                  sFt        |j                  d|j                  z         |j                  rt        |j                  d       y |j                  |      }|S r  )r  r  rx   r  is_cfunctionr   rL   r  r  s      r&   r  z&AlignFunctionDefinitions.visit_DefNode  s    **##DII.GMM1O1O''dhh 1DII =>;;'++'BC$$W-D r)   c                     |S r!   r"   r#   s     r&   rU   z'AlignFunctionDefinitions.visit_ExprNode  r  r)   r!   )	r:   r;   r<   r=   rQ   rP  r  r  rU   r"   r)   r&   r  r  g  s     


r)   r  c                   ,    e Zd Zd Zd ZddZd Zd Zy)AutoCpdefFunctionDefinitionsc                     |j                   | _         t               | _        |j                  | _        | j	                  |       |S r!   )r  r)  r  r  r8   r#   s     r&   rQ   z-AutoCpdefFunctionDefinitions.visit_ModuleNode  s5    //!eZZ
4 r)   c                     | j                   j                  rS| j                  d   rD|j                  | j                  vr,|j                         r|j                  | j                         }|S )N
auto_cpdef)r  )r  is_module_scoper  rx   r  is_cdef_func_compatibler  r#   s     r&   r  z*AutoCpdefFunctionDefinitions.visit_DefNode  sT    JJ&&4??<+HIIT%8%88002$$4::$6Dr)   Nc                     |%| j                   j                  |j                        }|r5|j                  s|S | j                   }|j                  j                   | _         | j                  |       |r| _         |S r!   r  r  s       r&   r  z0AutoCpdefFunctionDefinitions.visit_CClassDefNode  r  r)   c                     | j                   j                  r/|j                  D ]   \  }}| j                  j	                  |       " |S r!   )r  r  r\  r  rF  )r$   r%   rx   r   s       r&   r  z5AutoCpdefFunctionDefinitions.visit_FromImportStatNode  sA     ::%%:: .a##''-.r)   c                     |S r!   r"   r#   s     r&   rU   z+AutoCpdefFunctionDefinitions.visit_ExprNode  r  r)   r!   )r:   r;   r<   rQ   r  r  r  rU   r"   r)   r&   r  r    s    r)   r  c                   0    e Zd Zd Zd Zd Zd Zd Zd Zy)RemoveUnreachableCodec                 >   | j                   d   s|S | j                  |       t        |j                        dk(  rOt	        |j                  d   t
        j                        r(|j                  d   j                  s|j                  d d = t        |j                  d      D ]z  \  }}|j                  s|t        |j                        k  rG| j                   d   r$t        |j                  |   j                  dd       |j                  d | |_        d|_         |S  |S )Nremove_unreachabler   r   warn.unreachableUnreachable coder   T)r  r8   r   rM   rN   r   rP   rZ  r:  r   rL   )r$   r%   idxr#  s       r&   r[   z(RemoveUnreachableCode.visit_StatListNode  s    &&';<K4 tzz?aJtzz!}e>P>P$QZ^ZdZdefZgZmZm

1"4::q1 	IC!!TZZ(../AB

3 3 35GK!%DS!1DJ%)"	 r)   c                 b    | j                  |       |j                  j                  rd|_        |S rS   )r8   rO   r:  r#   s     r&   visit_IfClauseNodez(RemoveUnreachableCode.visit_IfClauseNode  s*    4 99""!%Dr)   c                     | j                  |       |j                  r=|j                  j                  r'|j                  D ]  }|j                  r |S  d|_        |S rS   )r8   r  r:  r  )r$   r%   clauses      r&   visit_IfStatNodez&RemoveUnreachableCode.visit_IfStatNode  s\    4  0 0 > >// *++ * &*"r)   c                     | j                  |       |j                  j                  rC|j                  r7| j                  d   r!t        |j                  j                  dd       d |_        |S )Nr  r  r   )r8   rO   r:  r  r  r   rL   r#   s     r&   visit_TryExceptStatNodez-RemoveUnreachableCode.visit_TryExceptStatNode  sZ    4 99""t'7'7&&'9:((,,.@!D#Dr)   c                 b    | j                  |       |j                  j                  rd|_        |S rS   )r8   r   r:  r#   s     r&   visit_TryFinallyStatNodez.RemoveUnreachableCode.visit_TryFinallyStatNode  s,    4 ,,!%Dr)   c                 f    | j                   d   s!t        j                  |j                  g       }|S )zEliminate useless PassStatNode	linetracerK   )r  r   rP   rL   r#   s     r&   visit_PassStatNodez(RemoveUnreachableCode.visit_PassStatNode  s-     &&{3%%$(("=Dr)   N)	r:   r;   r<   r[   r  r  r  r  r  r"   r)   r&   r  r    s      r)   r  c                   d     e Zd Zg f fd	Zd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd Zd Z xZS )r}   c                     t         |           g | _        g | _        g | _        g | _        d| _        d| _        d| _        || _	        y rA   )
rB   rC   yieldsr  finallysexceptshas_return_valuer   r   excludes)r$   r  rH   s     r&   rC   zYieldNodeCollector.__init__  sG     % r)   c                 D    || j                   vr| j                  |       y y r!   )r  r8   r#   s     r&   r  zYieldNodeCollector.visit_Node  s!    t}}$t$ %r)   c                 j    | j                   j                  |       d| _        | j                  |       y rS   )r  r   r   r8   r#   s     r&   visit_YieldExprNodez&YieldNodeCollector.visit_YieldExprNode  )    4 4 r)   c                 j    | j                   j                  |       d| _        | j                  |       y rS   )r  r   r   r8   r#   s     r&   visit_AwaitExprNodez&YieldNodeCollector.visit_AwaitExprNode  r  r)   c                     | j                  |       |j                  rd| _        | j                  j	                  |       y rS   )r8   rw   r  r  r   r#   s     r&   visit_ReturnStatNodez'YieldNodeCollector.visit_ReturnStatNode  s1    4 ::$(D!D!r)   c                 \    | j                  |       | j                  j                  |       y r!   )r8   r  r   r#   s     r&   r  z+YieldNodeCollector.visit_TryFinallyStatNode"  s"    4 T"r)   c                 \    | j                  |       | j                  j                  |       y r!   )r8   r  r   r#   s     r&   r  z*YieldNodeCollector.visit_TryExceptStatNode&  s"    4 D!r)   c                      y r!   r"   r#   s     r&   r`  z%YieldNodeCollector.visit_ClassDefNode*  r  r)   c                      y r!   r"   r#   s     r&   r  z$YieldNodeCollector.visit_FuncDefNode-  r  r)   c                      y r!   r"   r#   s     r&   r   z#YieldNodeCollector.visit_LambdaNode0  r  r)   c                     t        |j                  t        j                        r&| j	                  |j                  j
                         y y r!   )rN   r   r   _ForInStatNoder$  r   r#   s     r&   r   z0YieldNodeCollector.visit_GeneratorExpressionNode3  s3    dii!5!56 JJtyy))* 7r)   c                      y r!   r"   r#   s     r&   visit_CArgDeclNodez%YieldNodeCollector.visit_CArgDeclNode:  s     	r)   )r:   r;   r<   rC   r  r  r  r  r  r  r`  r  r   r   r  ri   rj   s   @r&   r}   r}     sB     " 	!%!
!
"#"+r)   r}   c                   0    e Zd Zd Zd Zd Zd Zd Zd Zy)MarkClosureVisitorc                 D    d| _         g | _        | j                  |       |S rA   )needs_closurer  r8   r#   s     r&   rQ   z#MarkClosureVisitor.visit_ModuleNodeD  s$    "4 r)   c                    d| _         | j                  |       | j                   |_         d| _         t        | j                        }|j                  |       |j                  rrt
        j                  }|j                  r6t
        j                  }|j                  |j                  z   D ]	  }d|_         n| j                  d   rpt
        j                  }n_|j                  r4t        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        j0                  |j"                  |j2                  |j4                  |j                  |j                  xr |j                        } ||j"                  |j2                  |j6                  |j8                  |j:                  |j<                  |j>                  ||j@                  |jB                  |jD                        }	|	S )	NFTiterable_coroutinec              3   :   K   | ]  }|j                   s|  y wr!   )is_await)rm  ys     r&   rn  z7MarkClosureVisitor.visit_FuncDefNode.<locals>.<genexpr>\  s     Cq

Cs   z/'await' not allowed in generators (use 'yield')r   )rL   rx   rO   is_coroutine_bodyis_async_gen_body)rL   rx   ry   rz   r{   r|   rX  r  lambda_namer  r   )#r  r8   r}   r  r   r   AsyncDefNoder   AsyncGenNoder  r  in_async_genr  IterableAsyncDefNoder   nextr   rL   GeneratorDefNoderZ  	label_numr  r  in_generatorGeneratorBodyDefNoderx   rO   ry   rz   r{   r|   rX  r  r  r   )
r$   r%   r   coroutine_type
yield_exprfoundr_  retnoder  	coroutines
             r&   r  z$MarkClosureVisitor.visit_FuncDefNodeJ  s   "4 !//!&t}}5	%"//N""!&!3!3"+"2"2Y5F5F"F 3J.2J+3(()=>!&!;!;  CI$4$4CCE%))NOK  "33NK&y'7'7; 	%MAz#$J 	% ((9+=+==	@Q@QQ 	(G#'G 	( **tyytyy"//"//GI4G4GI #tyytyy]]1B1BT__T%5%5#'#>#>$($@$@B	 r)   c                     d| _         | j                  |       | j                   |_         d| _         |j                   r"|j                  rt        |j                  d       |S )NFTz1closures inside cpdef functions not yet supported)r  r8   r  r   rL   r#   s     r&   r  z%MarkClosureVisitor.visit_CFuncDefNodev  sS    "4 !//!$"2"2$((OPr)   c                 f    d| _         | j                  |       | j                   |_         d| _         |S )NFT)r  r8   r#   s     r&   r   z#MarkClosureVisitor.visit_LambdaNode  s3    "4 !//!r)   c                 6    | j                  |       d| _        |S rS   )r8   r  r#   s     r&   r`  z%MarkClosureVisitor.visit_ClassDefNode  s    4 !r)   c                    | j                   }t        |j                  t        j                        r|j                  j
                  g| _         | j                  |      }|| _         t        |j                  t        j                        s|S |j                  j
                  j                  }|j                  r|S t        |      j                  |       |S r!   )r  rN   r   r   r  r   r   r  rE  r  r$  )r$   r%   r  itseqs       r&   r   z0MarkClosureVisitor.visit_GeneratorExpressionNode  s    ==dii!5!56!YY//0DM$$T* $))U%9%9: K		""++K+D177>r)   N)	r:   r;   r<   rQ   r  r  r   r`  r   r"   r)   r&   r  r  @  s!    *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                 @    t         |   |       g | _        d| _        y rA   )rB   rC   pathrZ  rF   s     r&   rC   zCreateClosureClasses.__init__  s    !	r)   c                 J    |j                   | _        | j                  |       |S r!   )r  r  r8   r#   s     r&   rQ   z%CreateClosureClasses.visit_ModuleNode  s!     JJ4 r)   c                    g }g }|j                   j                         D ]g  }|j                  j                         D ]H  \  }}|s	|j                  r|j                  ||f       )|j                  s6|j                  ||f       J i ||fS r!   )r  iter_local_scopesr>  r\  from_closurer   r  )r$   r%   r  r  r  rx   r  s          r&   find_entries_used_in_closuresz2CreateClosureClasses.find_entries_used_in_closures  s    
%%779 	5E$}}224 5e%% ''u6%%%%tUm45	5 Z''r)   c                    |j                   rl|j                  j                         D ]O  }|j                  j	                         D ]0  }|j
                  r|j                  r|j                  r*d|_        2 Q | j                  |      \  }}|j                          d|_        d|_        |j                  }|j                  j                  }	|	j                  s|	j                   r&|	j"                  }	|	j                  r|	j                   r&|sA| j$                  s|r3|s#|j&                  st)        d      |j&                  }d|_        d|_        |j                   rn'|s|sy |s d|_        |	j.                  |_        d|_        y |j1                  t2        j4                        d|j                  j6                  j9                  dd      }
t;        |
      }
|j=                  |
|j>                  dd      }d|j@                  _!        ||_        |j@                  j                  }d|_"        d|_#        |jH                  s|j                   rd|jJ                  d<   tL        jN                  rtL        jN                  |jJ                  d	<   |re|	jP                  sJ |jS                  |j>                  t2        jT                  t2        jT                  |	j.                  j@                  d
       d|_        |D ]e  \  }}|jS                  |j>                  |jV                  s|jX                  nd |j6                  |j@                  d
      }|jZ                  s_d|_-        g d|_        |j]                  |j.                         y )NTFz%DefNode does not have assignment noder   r  __)rx   rL   definingimplementingno_gc_clearfreelist)rL   rx   r  r4  is_cdefr   )/r  r  r  r>  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_classrL   r4  is_final_typeis_internalis_closure_class_scoper   r  r   closure_freelist_sizer  r  outer_scope_cnamein_subscoperx   is_declared_genericcheck_c_class)r$   r%   target_module_scope
inner_noder  r  r  r  
func_scopecscoper  class_scoperx   closure_entrys                 r&   create_class_from_scopez,CreateClosureClasses.create_class_from_scope  s   ));;= 0"]]113 0E!..%2C2CuGWGW+/(00
 $(#E#Ed#K j #!&%%
!!&&&*A*A''F &&&*A*A j))'(OPP!//
,1J)%*D"L(,J%%+%7%7J"%)D"  ''(C(CDJJ$$S.0  (#33dhh 4  $(

 !&
jj&&"&-1* 1 148K""=1((181N1NK"":.***##)/)A)A*0*B*B)/););)@)@,0	 $ 2
 &*D"% 	6KD%'33II','8'8UZZdkkZZ 4 M ((451	6 "))**@*@Ar)   c                     t        |j                  t        j                        s|S | j                  }d| _        | j                  |j                  | j                  |       | j                  |       || _        |S rS   )rN   r   r   r   rZ  r5  r  r8   )r$   r%   was_in_lambdas      r&   r   z%CreateClosureClasses.visit_LambdaNode
  s_    $--7K$$T]]D4E4EtL4 &r)   c                 8   | j                   r| j                  |       |S |j                  s| j                  rb| j	                  || j
                         | j                  j                  |       | j                  |       | j                  j                          |S r!   )rZ  r8   r  r  r5  r  r   r  r#   s     r&   r  z&CreateClosureClasses.visit_FuncDefNode  ss    >>t$K((t/@/@AIIT"t$IIMMOr)   c                 (    | j                  |       |S r!   r  r#   s     r&   r  z/CreateClosureClasses.visit_GeneratorBodyDefNode!      4 r)   c                 b    |j                   s| j                  |      S | j                  |       |S r!   )r  r  r8   r#   s     r&   r  z'CreateClosureClasses.visit_CFuncDefNode%  s/    ))$//t$Kr)   c                 D     t               |      }| j                  |      S r!   )r  r   r#   s     r&   r   z2CreateClosureClasses.visit_GeneratorExpressionNode,  s#    *(*40$$T**r)   r!   )r:   r;   r<   rC   rQ   r  r5  r   r  r  r  r   ri   rj   s   @r&   r  r    s3    

(PBd
	+r)   r  c                   R    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y)	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                 b    | j                   r"t        j                  |j                  d|      }|S )zYAllow the (Python statement) node in nogil sections by wrapping it in a 'with gil' block.rf  rn  rO   )rR  r   rr  rL   r#   s     r&   _inject_gil_in_nogilz&InjectGilHandling._inject_gil_in_nogil<  s&    ::$$TXXUFDr)   c                 v    | j                   }|j                  dk(  | _         | j                  |       || _         |S )NrR  )rR  rn  r8   r$   r%   	was_nogils      r&   visit_GILStatNodez#InjectGilHandling.visit_GILStatNodeJ  s5    JJ	jjG+
4 
r)   c                     | j                   }t        |j                  t        j                        r4|j                  j                   xr |j                  j
                   | _         | j                  |       || _         |S r!   )rR  rN   r  r   CFuncDeclaratorNoderS  r8   rC  s      r&   r  z$InjectGilHandling.visit_CFuncDefNodeQ  s\    JJ	doou'@'@A..Ot7O7O3ODJ4 
r)   c                 p    | j                   }|j                   | _         | j                  |       || _         |S r!   )rR  r8   rC  s      r&   visit_ParallelRangeNodez)InjectGilHandling.visit_ParallelRangeNodeY  s0    JJ	ZZ
4 
r)   c                     |S r!   r"   r#   s     r&   rU   z InjectGilHandling.visit_ExprNode`  r  r)   N)r:   r;   r<   r=   rR  rA  visit_RaiseStatNodevisit_PrintStatNoderE  r  rI  rU   r   r  r  r"   r)   r&   r>  r>  1  sB     E /. "55Jr)   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_gilstatnoderB   r  )r$   rQ  rH   s     r&   r  zGilCheck.__call__q  sH    ** ++22272B2B2I2I/w%%r)   c                 t   | j                   }|j                  }|r|t        | j                        dkD  rd| j                  d   j                  rt
        j                  j                  nt
        j                  j                  | _         | j                  ||       || _         | j                  |d |       || _         y )Nr   r   )
rS  outer_attrsr   rP  rR  r   rQ  NoGilrR  r8   )r$   r%   rS  rD  rW  s        r&   _visit_scoped_childrenzGilCheck._visit_scoped_childrenx  s    $$	&&3t~~.2*...*<*B*B  &&HXHXH_H_ t[1&4t[A$r)   c                    | j                   j                  |j                         |j                  j                  }| j                  }|rt
        j                  j                  | _        |r'|j                  r|j                  |j                         | j                  || j                         || _        | j                   j                          |S r!   )rP  r   r  rR  rS  r   rQ  
NoGilScopenogil_checkrY  r  )r$   r%   inner_nogilrS  s       r&   r  zGilCheck.visit_FuncDefNode  s    d../&&,,&&$//::D4++T--.##D$*:*:; 'r)   c                 n   |j                   /t        |j                   j                  d|j                  z         |S | j                  r|j
                  r|j                          | j                  }|j                  dk(  }||k(  rV| 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                   }| j#                  ||       || _        |S )Nz<Non-constant condition in a `with %s(<condition>)` statementrR  z3Trying to acquire the GIL while it is already held.z;Trying to release the GIL while it was previously released.F)ro  r   rL   rn  rS  r\  r   rQ  r[  scope_gil_state_knownrN   r   rP   rM   rT  rX  rR  rY  )r$   r%   rD  is_nogilrT  rS  s         r&   rE  zGilCheck.visit_GILStatNode  se   >>%$..$$57;zzBC K 0 0$$	JJ') )9)9U=M=M=X=X)Xdhh !0 1 dhh !7 8u//:::).D&d))5+=+=> $(#6#6#<#< D-1-T-T*262B2B/08e&&,,e>N>N>U>U##D+62T/r)   c                    |j                   s'| j                  t        j                  j                  k(  rw|j                   dc}|_         t        j
                  |j                  d|      }|s.| j                  t        j                  j                  k(  rd|_        | j                  |      S | j                  st        |j                  d       y |j                  | j                  d          | j                  |       |S )NFrR  r@  z)prange() can only be used without the GILr   )rR  rS  r   rQ  r[  rr  rL   r_  rE  r   r\  rP  r8   )r$   r%   node_was_nogils      r&   rI  z GilCheck.visit_ParallelRangeNode  s    ::))U-=-=-H-HH)-U&NDJ$$TXXW4HD!d&6&6%:J:J:U:U&U .3*))$//$((GH+,4 r)   c                    | j                   st        |j                  d       y | j                   t        j                  j
                  k(  r:t        j                  |j                  d|      }d|_        | j                  |      S |j                  r|j                  | j                  d          | j                  |       |S )Nz5The parallel section may only be used without the GILrR  r@  Fr   )rS  r   rL   r   rQ  r[  rr  r_  rE  r\  rP  r8   r#   s     r&   visit_ParallelWithBlockNodez$GilCheck.visit_ParallelWithBlockNode  s    $(( & 'u//::: $$TXXW4HD).D&))$// T^^B/04 r)   c                 ~    | j                   s| j                  |      S d|_        d|_        | j	                  |       |S )zM
        Take care of try/finally statements in nogil code sections.
        NT)rS  r  r\  is_try_finally_in_nogilr8   r#   s     r&   r  z!GilCheck.visit_TryFinallyStatNode  s?     ??4(('+$4 r)   c                 $    | j                  |      S r!   r  r#   s     r&   visit_CriticalSectionStatNodez&GilCheck.visit_CriticalSectionStatNode      t$$r)   c                 $    | j                  |      S r!   rh  r#   s     r&   visit_CythonLockStatNodez!GilCheck.visit_CythonLockStatNode  rj  r)   c                     | j                   t        j                  j                  k(  rd|_        | j                  |       |S rA   )rT  r   rQ  r[  r_  r8   r#   s     r&   visit_GILExitNodezGilCheck.visit_GILExitNode  s7    22e6F6F6Q6QQ).D&4 r)   c                 8   | j                   r6| j                  r*|j                  r|j                  | j                   d          |j                  r| j	                  || j                         n| j                  |       | j                  r| j                  |_        |S rT  )rP  rS  r\  rW  rY  r8   in_nogil_contextr#   s     r&   r  zGilCheck.visit_Node  sy    >>d..43C3CT^^B/0''d.>.>?t$$($4$4D!r)   c                    |j                   r"|j                   j                  j                  r|j                  j                  r|j                  j
                  dk(  rt        |j                        dk(  rd }| j                  t        j                  j                  k(  rd}n)| j                  t        j                  j                  k(  rd}|rct        j                  |j                  |j                  j                   j"                  |z   |j                  j                  |j                   g      }| j%                  |      S )Nacquirer   NogilGilr  )r$   r4  is_cython_lock_typer  r  r  r   ry   rS  r   rQ  rX  rR  r   PythonCapiCallNoderL   r  r  r  )r$   r%   suffixs      r&   visit_SimpleCallNodezGilCheck.visit_SimpleCallNode  s    II$))..<<**t}}/F/F)/SDII!# F5#3#3#9#99 !!U%5%5%<%<< 33HHMM''--6MM&&))	 t$$r)   )r:   r;   r<   r=   r  rY  r  rE  rI  rd  r  ri  rl  rn  r  rx  ri   rj   s   @r&   rN  rN  g  sE    &
%(!F&(
%%	%r)   rN  c                   .    e Zd ZdZd Zd Zd Zd Zd Zy)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                 \    | j                         j                  r| j                  |       |S r!   )rX  r0  r8   r#   s     r&   rQ   zCoerceCppTemps.visit_ModuleNode&  s'    !!t$r)   c                    | j                  |       | j                         j                  d   rQ|j                         rA|j                  j
                  r+|j                  j                  st        j                  |      }|S )N
cpp_locals)	r8   rX  r  result_in_tempr4  r  is_fake_referencer   CppOptionalTempCoercionr#   s     r&   rU   zCoerceCppTemps.visit_ExprNode,  sa    4 )),7##%$))*@*@II//44T:Dr)   c                     |S r!   r"   r#   s     r&   visit_CppOptionalTempCoercionz,CoerceCppTemps.visit_CppOptionalTempCoercion6  r(   r)   c                     |S r!   r"   r#   s     r&   visit_CppIteratorNodez$CoerceCppTemps.visit_CppIteratorNode9  r(   r)   c                 <    | j                  |j                         |S r!   )r8   rc   r#   s     r&   rf   z!CoerceCppTemps.visit_ExprStatNode<  s    499%r)   N)	r:   r;   r<   r=   rQ   rU   r  r  rf   r"   r)   r&   rz  rz    s     r)   rz  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                 2    t        |   |i | i | _        y r!   )rB   rC   def_node_body_insertions)r$   ry   r'  rH   s      r&   rC   z TransformBuiltinMethods.__init__H  s    $'$'(*%r)   c                 B    |j                   ry | j                  |       |S r!   )declaration_onlyr8   r#   s     r&   r   z2TransformBuiltinMethods.visit_SingleAssignmentNodeL  s!      t$Kr)   c                 F    | j                  |       | j                  |      S r!   )r8   visit_cython_attributer#   s     r&   r  z+TransformBuiltinMethods.visit_AttributeNodeS  s!    4 **400r)   c                     |j                   dk(  r4| j                         }|j                  d      }|s| j                  |      }| j	                  |      S )NrH   )rx   rX  r  _inject_classr  )r$   r%   r  r  s       r&   r  z&TransformBuiltinMethods.visit_NameNodeW  sP    99$##%D$$\2E))$/**400r)   c                 P   |j                         }|r|dk(  r2ddlm} t        j                  |j
                  t        |            }|S |dk(  r!t        j                  |j
                        }|S |dv rXt        j                  |j
                  t        |      | j                         j                         j                  |            }|S t        j                  |      r	 |S | j                  j                  j!                  |      r	 |S t#        |j
                  d|z         |S )	N__version__r   )r  rv   r  )r)  	frozensetr  rx   r  z>'%s' not a valid cython attribute or is being used incorrectly)r  rm  r  r   rn  rL   r   NullNoder   rX  builtin_scoper  r   r  rG   cython_scopelookup_qualified_namer   )r$   r%   r  versions       r&   r  z.TransformBuiltinMethods.visit_cython_attribute_  s   ,,.	M)5 ,,TXX]7=ST  f$ ))$((3  BB ))$((y9Q040@0@0B0P0P0R0^0^_h0ik  ,,Y7
 	 **@@K  dhh `cl lmr)   c                    | j                         }| j                  |       t        |j                        dk(  r|j                  j	                  t        j                  |j                               |j                  sH|j                  j	                  t        j                  |j                  | j                         |             |S r8  )rX  r8   r   ry   r   r   GlobalsExprNoderL   r  LocalsExprNodecurrent_scope_node)r$   r%   r  s      r&   visit_ExecStatNodez*TransformBuiltinMethods.visit_ExecStatNoder  s    !4 tyy>QIIY66txx@A''		  ,,$"9"9";TCD r)   c                    | j                         }|j                  |      }|r|S |j                  }|dv r|dk(  rFt        |j                        dkD  r.t        | j                  dt        |j                        z         |S |dk(  r^t        |j                        dkD  r,t        | j                  dt        |j                        z         t        |j                        dkD  r|S t        j                  || j                         |      S t        |j                        dkD  r,t        | j                  dt        |j                        z         t        |j                        dkD  r|S |j                  s|j                  rf|j                  r0| j                         }t        j                  |j                        }nt        j                  |      }t        j                  |      S t        d	 |j                   j#                         D              }|D 	cg c]  }	t        j$                  ||	
       }
}	t        j&                  ||
      S c c}	w )N)rH  varsrH  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   N   K   | ]  }|j                   s|j                     y wr!   r   )rm  r  s     r&   rn  z9TransformBuiltinMethods._inject_locals.<locals>.<genexpr>  s      Wcchh Ws   %%rv   r  )rX  r  rL   r   ry   r   r   r  r  r  r  r  r   r  SortedDictKeysNoder  r>  r+  IdentifierStringNoder~  )r$   r%   	func_namer  r  rL   r   locals_dictlocal_namesr  r\  s              r&   _inject_localsz&TransformBuiltinMethods._inject_locals}  s   !  +Khh**H$TYY!);dhh iDII!' (f$tyy>A%$(($m		N%+ ,tyy>A%K++C1H1H1JDQQ499~!dhh hDII!' (499~!%%)=)=))"557G"+"5"5gll"CK"+";";C"@K 33K@@  WT\\5H5H5J WWK +- 33CsC -E -%%c66-s   I
c                    | j                  |       |j                  dv rgt        |j                  t        j
                        rC|j                  j                  }t        |t        j                        r|j                  }||_        |S )Nnot_in)r8   r  rN   r  r   r  r   NoneCheckNode)r$   r%   r   s      r&   visit_PrimaryCmpNodez,TransformBuiltinMethods.visit_PrimaryCmpNode  sd    4 ==H$$--)E)EFmm''c9#:#:;''C #r)   c                 $    | j                  |      S r!   )r  r#   s     r&   visit_CascadedCmpNodez-TransformBuiltinMethods.visit_CascadedCmpNode  s    ((..r)   c                    | j                         }|j                  |      }t        |j                        dk7  s|r|j                  s|S |j                  j                  t        j                  |j                               |j                  sH|j                  j                  t        j                  |j                  | j                         |             |S r8  )rX  r  r   ry   
is_builtinr   r   r  rL   r  r  r  )r$   r%   r  r  r  s        r&   _inject_evalz$TransformBuiltinMethods._inject_eval  s    !I&tyy>Q51A1AK		22488<=##II((HHd557?@ r)   c           	         | j                         }t        |t        j                        s|S d x}x}}t	        | j
                        D ]o  \  }}t        |t        j                        r|}|} nLt        |t        j                        r|}|j                  }|}	Qt        |t        j                        sl|}|}	q |r|s|S || j                  vr	|j                  j                  }
j                  r7t        j                  |
|j                  j                   |j"                        }nJ|j$                  r<t        j&                  |
|d u      }|rd|_        nd|_        d|j*                  _        n|S t        j.                  |
t        j                  |
t1        d            |      }|j3                  	       || j                  vsJ || j                  |<   |S )Nr  r  TrH   r   r   )r  rN   r   FuncDefNodereversedrP  ClassDefNoder  r  r  rO   rL   r  r   r   r  rx   r  r  ClassCellNoderequires_classobj
class_cell	is_activer   r   rW  )r$   r%   current_def_node	fdef_node
class_nodegenerator_node
stack_nodestack_scoper3  
fdef_scoperL   r   r   s                r&   r  z%TransformBuiltinMethods._inject_class  s   224*E,=,=>K 376	6J'/'? 	)#J*e&8&89'
)J(>(>?!+&,,	(
J(9(9:&	(
	) 
K D999..$$C++  ((j&6&6&;&;","2"24 ..--cVZ@Z[!7;N426I/26
%%/44S&&s{1KLK ,,Z8D$A$AAA7BD)))4r)   c                 Z   | j                         }|j                  |      }|s|j                  r|S | j                         }t	        |t
        j                        r$|j                  rt        | j                        dk  r|S | j                  d   \  }}|j                  rd|_
        d|j                  _        t        j                  |j                  |j                         t        j"                  |j                  |j                  d   j$                        g|_        |S |j&                  r}t        j"                  |j                  |j(                  j$                  |j*                        t        j"                  |j                  |j                  d   j$                        g|_        |S )Nr   rV  Tr  r   r   r  )rX  r  ry   r  rN   r   r   r   rP  r  r  r  r  r   r  rL   r  r   rx   r  r  r  )r$   r%   r  r  r  r   r  r3  s           r&   _inject_superz%TransformBuiltinMethods._inject_super  sU   !  +DIIK**,(EMM2(--3t~~K^abKbK"&.."4
K(()-H&.2J!!+''HH8+@+@B""488(--2B2G2GHDI  ))""HH:#3#3#8#8$**, ""488(--2B2G2GH	DI r)   c                 P   | j                   j                  |d       }|rt        |j                  t        j
                        r'|j                  j                  j                  d|       y t	        j
                  |j                  j                  ||j                  g      |_        y y )Nr   r   )	r  r  rN   rO   r   rP   rM   r  rL   )r$   r%   body_insertions      r&   _do_body_insertionz*TransformBuiltinMethods._do_body_insertion  sw    66::4F$))U%7%78		&&q.9!..tyy}}6Ddii5PR		 r)   c                 H    t         |   |      }| j                  |       |S r!   )rB   r  r  r  s     r&   r  z)TransformBuiltinMethods.visit_FuncDefNode  s%    w(.%r)   c                 H    t         |   |      }| j                  |       |S r!   )rB   r  r  r  s     r&   r  z2TransformBuiltinMethods.visit_GeneratorBodyDefNode#  s%    w1$7%r)   c                 
   |j                   j                         }|r|t        j                  v rzt	        |j
                        dk7  r%t        |j                   j                  d|z         nGt        j                  |   |j                   j                  |j
                  d         }n
|t        j                  v rt	        |j
                        dk7  r%t        |j                   j                  d|z         nt        j                  |   |j                   j                  |j
                  d   |j
                  d         }np|dk(  rt	        |j
                        dk7  r"t        |j                   j                  d	       n1|j
                  d   j                  | j                               }|r<t        j                  |j                   j                  ||j
                  d   d
      }nt        |j
                  d   j                  d       n|dk(  rt	        |j
                        dk7  r"t        |j                   j                  d       nc|j
                  d   j                  | j                               }|r-t        j                  |j                   j                  |      }nt        j                  |j                   j                  |j
                  d         }n|dk(  rt	        |j
                        dk7  r"t        |j                   j                  d       nt        j                  |j                   j                  d|j
                  d   |j
                  d         }d|_        n@|dk(  rt	        |j
                        dk7  r"t        |j                   j                  d       nt        j                  |j                   j                  d|j
                  d   |j
                  d         }d|_        n|dk(  r0t        j"                  |j                  t%        d            |_         n~|dk(  r0t        j"                  |j                  t%        d            |_         nI| j&                  j(                  j+                  |      rn#t        |j                   j                  d|z         | j-                  |       t/        |t        j0                        rp|j                   j2                  rZ|j                   j4                  }|dv r| j7                  ||      S |dk(  r| j9                  ||      S |dk(  r| j;                  ||      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r4  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)dirrH  r  evalrB   )r  r  r  r{  r   ry   r   rL   r}  r  rX  r   TypecastNodeSizeofTypeNodeSizeofVarNoder  	cdivisionr   r   rG   r  r  r8   rN   rp  r  rx   r  r  r  )r$   r%   r  r4  r  s        r&   rx  z,TransformBuiltinMethods.visit_SimpleCallNode(  s   ==4466HHHtyy>Q&$--++-NQY-YZ6HHR))499Q<AD8KKKtyy>Q&$--++-ORZ-Z[6II(S))DIIaL499UV<YDV#tyy>Q&$--++`b  99Q<778H8H8JKD(55 MM--D$))A,Z_ a diil..=X%tyy>Q&$--++-RS99Q<778H8H8JKD(778I8ITXY(66t}}7H7HRVR[R[\]R^_V#tyy>Q&$--++-QR$//0A0A3		RSVZV_V_`aVbcD%)DNV#tyy>Q&$--++-QR$//0A0A3		RSVZV_V_`aVbcD%)DNU" ) 2 2488-PUBV W^+ ) 2 2488-P^B_ `**@@Jdmm''BXMO 	4 dI445$--:O:O**I55**4;;F"((y99G#))$	::r)   c                 h   |j                   j                         }|dk(  r |j                  j                  }|j                  j                  d       }t        |      dk7  s t        |      dkD  st        |      dk(  r%d|vr!t        |j                   j                  d       n|d   j                  | j                               }|rC|j                  dd      }t        j                  |j                   j                  ||d   |      }nt        |d   j                  d	       | j                  |       |S )
Nr  r   r   r  r  r   Fr  r  )r  r  r  ry   r  r/  r   r   rL   r  rX  r   r   r  r8   )r$   r%   r  ry   r  r4  r  s          r&   visit_GeneralCallNodez-TransformBuiltinMethods.visit_GeneralCallNoden  s   ==446v'',,D&&99$?FD	Q#f+/[A%+V*Cdmm''\^ Aw..t/?/?/AB &

; >I$11))d1gQZ\D $q'++|44 r)   )r:   r;   r<   r=   rC   r   r  r  r  r  r  r  r  r  r  r  r  r  r  rx  r  ri   rj   s   @r&   r  r  B  sb    
+11&	%7N	/9v6R

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                 X    t         |           || _        ddlm}  |d      | _        y )Nr   )ConstantFoldingT)
reevaluate)rB   rC   r  Optimizer  r  )r$   r  r  rH   s      r&   rC   zReplaceFusedTypeChecks.__init__  s%    &-(D9r)   c                 F    | j                  |       | j                  |      S )zc
        Filters out any if clauses with false compile time type check
        expression.
        r8   r  r#   s     r&   r  z'ReplaceFusedTypeChecks.visit_IfStatNode  s!    
 	4 ~~d##r)   c                 F    | j                  |       | j                  |      S )z9
        Fold constant condition of GILStatNode.
        r  r#   s     r&   rE  z(ReplaceFusedTypeChecks.visit_GILStatNode  s!     	4 ~~d##r)   c                    t        j                  d      5  |j                  j                  | j                        }|j
                  j                  | j                        }d d d        rrt        j                  |j                  d      }t        j                  |j                  d      }| j                  ||j                  j                        }|j                  }|dv rG| j                  ||j
                  j                        }|j                  |      }|dv }|r|s|s|s|S |S |dv rt        |t        j                        r|j                  }|j                   r"t#        |j                  j                  d       |S |j                   s"t#        |j
                  j                  d	       |S t        j$                  |      }	|	D ]   }
|j                  |
      s|d
k(  r|c S |c S  |dk(  r|S |S |S # 1 sw Y   xY w)NT)ignoreFrv   )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  rL   specialize_typer  same_asrN   r   CTypedefTypetypedef_base_typerD  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  s     - 	DMM11$2B2BCEMM11$2B2BCE	D U"++DHHEBJ!**4884@I((0A0ABEB11,,UDMM4E4EF--.<'GB$$6 3 '' eZ%<%<=!33E>>$--++_=" ! $--++IK  '<<UCE,1 2( ==)9:!Tz'0 0'1 12 X~((_	D 	Ds   AG::Hc                     	 |j                  | j                  j                        S # t        $ r t	        |d       |cY S w xY w)NzType is not specific)r  r  r  KeyErrorr   )r$   r4  rL   s      r&   r  z&ReplaceFusedTypeChecks.specialize_type  sA    	??4#3#3#E#EFF 	#-.K	s   $' A Ac                 (    | j                  |       |S r!   r  r#   s     r&   r  z!ReplaceFusedTypeChecks.visit_Node  r:  r)   )r:   r;   r<   r=   rC   r  rE  r  r  r  ri   rj   s   @r&   r  r    s'    	:$$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| _
        y rA   )rB   rC   r)  visitedrG   gdb_debug_outputwritertbc_filec_output_filenested_funcdefsregister_stepinto)r$   rG   optionsr   rH   s       r&   rC   zDebugTransform.__init__  sL    !u ,,55#]]  " "'r)   c                    |j                   | j                  _        t        |j                   |j                  d   j
                  | j                        }| j                  j                  d|       | j                  j                  d       | j                  |       | j                  D ]  }| j                  |        d| _        | j                  |       d| _        | j                  j                  d       | j                  j                  d       i }|j                  j                  j!                         D ]m  \  }}|j"                  | j$                  vs|j&                  j)                  d      r;|j*                  j,                  rR|j*                  j.                  ri|||<   o | j1                  |       | j                  j                  d       |S )	Nr   )r  filename
c_filenameModule	FunctionsTFGlobals__pyx_)full_module_namer  r  r   rL   r  r   startr8   r  r  r   serialize_modulenode_as_functionendr  r>  r\  r  r  rx   r  r4  r  rA  serialize_local_variables)r$   r%   r   nested_funcdefr>  r  r  s          r&   rQ   zDebugTransform.visit_ModuleNode  su   "33--XXa[))))+
 	h& 	k"4  #22 	3N"">2	3 "&--d3!&K  	i JJ&&,,. 	DAq  4FF%%h/FF''FF,,
	 	&&w/I r)   c           
      N   | j                   j                  |j                  j                         t	        |dd      r|S | j
                  r| j                  j                  |       |S |j                  d}n |j                  j                  j                  }|j                  j                  xs |j                  j                  }t        |j                  j                  xs t	        |dd      |||j                  j                  t        |j                  d               }| j                   j#                  d|	       | j                   j#                  d
       | j%                  |j                  j&                         | j                   j)                  d
       | j                   j#                  d       |j                  j*                  D ]L  }| j                   j#                  |j                         | j                   j)                  |j                         N | j                   j)                  d       | j                   j#                  d       d| _        | j-                  |       d| _        | j                   j)                  d       | j                   j)                  d       |S )Nr<  Frm  rx   z	<unknown>r   )rx   r  pf_cnamer  linenoFunctionr   Locals	ArgumentsStepIntoFunctionsT)r  rF  r  r  r-  r  r  r   r  r  
func_cnamepyfunc_cnamer   rx   r  rL   r  r  r  r>  r  arg_entriesr8   )r$   r%   r  r  r   r   s         r&   r  z DebugTransform.visit_FuncDefNode!  s   ))8894u-K!!  ''-K <<H||))44H
 

''@4::+@+@FGD&+$F++::txx{#% 	j.h&&t'7'7'?'?@Hk"##// 	"CGGMM#((#GGKK!	" 	K )*!%4 !&'(Jr)   c                 z   | j                   r|j                  |j                  j                  r{t        |dd      rn|j                  j
                  Xt        |j                  j
                        }| j                  j                  d|       | j                  j                  d       | j                  |       |S )N	is_calledFr   StepIntoFunctionr  )r  r4  r  r-  r  r  r   r  r  r  r8   r$   r%   r   s      r&   r  zDebugTransform.visit_NameNodeR  s    ""		%		&&k51

%%1 djj334EGGMM,EM:GGKK*+4 r)   c                     | j                  |t        |j                  j                  d      d   |j	                         dddd             y)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   rm  1True)rx   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_functiond  sN     	..tT&&11#6r:--/ #)	6
 		r)   c                 @   | j                   j                  d|       | j                   j                  d       | j                  |j                  j                         | j                   j                  d       | j                   j                  d       | j                   j                  d       | j                   j                  d       d| _        | j                  |       d| _        | j                   j                  d       | j                   j                  d       y )Nr  r  r  r  r  TF)r  r  r  r  r>  r  r  r8   r  s      r&   r$  z0DebugTransform._serialize_modulenode_as_functionu  s    j.h&&tzz'9'9:Hk"K )*!%4 !&'(Jr)   c                 
   |j                         D ]o  }|j                  s|j                  j                  rd}nd}|j                  rpt
        j                  d|j                  j                  }|j                  j                  j                  d|j                  j                  d|j                  }nP|j                  r,t
        j                  d|j                  }|j                  }n|j                  }|j                  }|j                  sd}nt        |j                  d         }t        |j                  ||||      }| j                   j#                  d|       | j                   j%                  d       r y )	NPythonObjectCObjectz->r  0r   )rx   r  r  r4  r  LocalVar)r+  r  r4  r  r  r   cur_scope_cnameouter_entryr  r  r  rx   r  rL   r  r   r  r  r  )r$   r>  r  vartyper  qnamer  r   s           r&   r  z(DebugTransform.serialize_local_variables  s6   ^^% *	$E;;zz%%(#!! %+$:$:$)$5$5$;$;= ',kk&=&=&L&L&+kk&6&6&+jj2 !!$*$:$:$)KK1,,,,99 UYYq\*ZZ$E GGMM*e,GGKK
#U*	$r)   )r:   r;   r<   r=   rC   rQ   r  r  r  r$  r  ri   rj   s   @r&   r  r    s-    ' &P/b$" $+$r)   r  c                   v     e Zd ZdZ fdZdefdZd Zd Zd Z	d Z
d	 Zd
 Zd Zd Zd Zd Zd Zd Z xZS )HasNoExceptionHandlingVisitorz
    Used by finalExceptClauseNode to work out if the body
    needs to handle exceptions at all. This includes:

    1. Can raise an exception.
    2. May try to access the traceback.
    c                 >    d| _         d | _        t        |           y rS   )uses_no_exceptionsassignment_lhsrB   rC   r  s    r&   rC   z&HasNoExceptionHandlingVisitor.__init__  s    "&"r)   returnc                 <    | j                  |       | j                  S r!   )r$  r4  r#   s     r&   r  z&HasNoExceptionHandlingVisitor.__call__  s    

4&&&r)   c                     d| _         y rA   r4  r#   s     r&   r  z(HasNoExceptionHandlingVisitor.visit_Node  s
    "'r)   c                 &    | j                  |       y r!   r  r#   s     r&   rf   z0HasNoExceptionHandlingVisitor.visit_ExprStatNode  r   r)   c                 &    | j                  |       y r!   r  r#   s     r&   r[   z0HasNoExceptionHandlingVisitor.visit_StatListNode  r   r)   c                 ,    |j                   sd| _        y y rA   )rE  r4  r#   s     r&   rU   z,HasNoExceptionHandlingVisitor.visit_ExprNode  s    &+D# r)   c                     d| _         y rA   r9  r#   s     r&   r  z,HasNoExceptionHandlingVisitor.visit_CallNode  s     #(r)   c                      y r!   r"   r#   s     r&   r  z0HasNoExceptionHandlingVisitor.visit_PassStatNode  r  r)   c                 @    | j                   sy | j                  |       y r!   )r4  r8   r#   s     r&   r  z2HasNoExceptionHandlingVisitor.visit_ReturnStatNode  s    &&4 r)   c                 H   | j                   sy |j                  | _        | j                  |j                         d | _        |j                  j
                  }|j                  s|j                  s|j                  sd| _         | j                   sy | j                  |dg       y )NFr   r9  )
r4  r   r5  r$  r   r4  
is_numericr  is_memoryviewslicer8   )r$   r%   rhs_types      r&   r   z8HasNoExceptionHandlingVisitor.visit_SingleAssignmentNode  s    &&"hh

488"88==##x';';x?Z?Z ',D#&&4%1r)   c                    | j                   sy |j                  }| j                  |u rI|j                  s<|j                  s/|j
                  s"|j                  s|j                  sd| _         y y y y y y |j                  r"|j                  r|j                  rd| _         y y y |j                  s$|j
                  s|j                  s|j                  r8|j                  s|j                  r|j                  j                  sd| _         y y y d| _         y rA   )r4  r  r5  r  is_argis_localr  r  is_cpp_optionalr  
cf_is_nullcf_maybe_nullr4  rA  r  s      r&   r  z,HasNoExceptionHandlingVisitor.visit_NameNode  s    &&

$&$$NNe&6&6%:L:L*/' ;M&6N )5$
 ((T-C-C.3D+ .D( 53C3CuGYGYOOt'9'9499CWCW /4D+ DX'9 +0'r)   c                 |   |j                   rd| _        nA|j                  j                  s|j                  j
                  r| j                  |urd| _        |j                  j                  s3|j                  j                  s|j                  j                  sd| _        | j                  r| j                  |       y y rA   )

is_py_attrr4  r4  rB  r  rG  r5  r  rA  r8   r#   s     r&   r  z1HasNoExceptionHandlingVisitor.visit_AttributeNode
  s    ??&+D#ii**djj.H.HdNaNaimNm ',D#		%%)=)=A]A]&+D#""t$ #r)   c                     |j                   j                  j                  s'|j                   j                  j                  sd| _        | j                  sy | j                  |       y rA   )r   r4  is_arrayis_ptrr4  r8   r#   s     r&   rY  z-HasNoExceptionHandlingVisitor.visit_IndexNode  sE    		''499>>+@+@&+D#&&4 r)   c                 &    | j                  |       y r!   r  r#   s     r&   visit_CoerceToTempNodez4HasNoExceptionHandlingVisitor.visit_CoerceToTempNode  r   r)   )r:   r;   r<   r=   rC   rp  r  r  rf   r[   rU   r  r  r  r   r  r  rY  rP  ri   rj   s   @r&   r2  r2    sU    
' '(!!,(
!
26%!!r)   r2  r"   )Or  r  rY  r   r   r   r  r   rm  r   r   r   r   r   r   r   r   r  r   r   r   r   r   r   r	   r
   r   StringEncodingr   r   r   r   r   r   r?   rl   r   r   r   rn   r  r   r   r   rh  rT  rN  r   rq  r  r  r  r  r  r  r  r  r+  r3  rI  r  r)  rM  ri  rs  r  r  r  r  r}   r  r  r>  rN  rz  r  r  r  r2  r"   r)   r&   <module>rR     s     "& " "6 " "")/"9?" "/5"EK" " &," 39" CI" OU" !	"   
          2 J J * & ) ? ? BIO IX )\ ( ^ E Q K,& K,\!K !<V!; V!r,8\"D	 H# H#d H# H#V $@ $@4 $@SW $@cg $@ $@N6?$4 6r6+-= 6*{	%/ {	%|l'_.> l'^C6$&6 C6L/+7G /2`6 02B `6Fz$/1A z$z,(0@ ,(^6/ 6r`	< `	F$}| }@]
/ ]
@% %>:\ :zkO-= k\3 3l)? )X5O 5p< <~Z ZzQ+? Q+h36(*: 36ls% s%l"\#3 "J@l @F
\- \~N$_ N$bk!K k!r)   