o
    f                    @   s	  d dl mZ d dlZejdi 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edede d dlZd dlZd dlmZ ddl	m
Z
 ddlmZmZmZmZ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mZmZmZmZmZmZm Z 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+m,Z, d%d&l-m.Z.m/Z/ ej0d  d'kre1Z2ne1e3fZ2d(d)hZ4d*d+ Z5d,d- Z6d.d/ Z7G d0d1 d1e8Z9G d2d3 d3e8Z:d4d5 Z;e;G d6d7 d7eZ<G d8d9 d9e<Z=G d:d; d;eZ>G d<d= d=e<Z?G d>d? d?e<Z@G d@dA dAe@ZAG dBdC dCe<ZBG dDdE dEeBZCG dFdG dGeBZDG dHdI dIeBZEG dJdK dKeEZFG dLdM dMeEZGG dNdO dOeBZHG dPdQ dQeBZIG dRdS dSeBZJG dTdU dUe<ZKG dVdW dWe<ZLG dXdY dYe<ZMG dZd[ d[eLZNG d\d] d]eLZOG d^d_ d_eLZPG d`da daeLZQG dbdc dceLZRG ddde deeLZSG dfdg dgeLZTG dhdi dieLZUG djdk dke@ZVG dldm dme@ZWG dndo doeWe>ZXG dpdq dqe@ZYG drds dse@ZZG dtdu due@Z[G dvdw dwe@e>Z\G dxdy dye\Z]G dzd{ d{e<Z^G d|d} d}e<Z_G d~d de\Z`G dd de\ZaG dd de`ZbG dd debZcG dd decZdG dd decZeG dd de`ZfG dd de@ZgG dd de@e>ZhG dd dehZiG dd dehZjG dd de@ZkG dd de@ZlG dd de@ZmG dd de@ZnG dd de@ZoG dd de@ZpG dd depZqG dd depZrG dd depZsG dd depZtG dd de@ZuG dd de@ZvG dd de@ZwG dd de@ZxG dd de?ZyG dd de@ZzG dd de@Z{G dd de@Z|G dd de@Z}G dd de@Z~G dd de@ZG dd de@ZG dd de<ZG ddÄ de@ZG ddń de@ZG ddǄ deZG ddɄ dee@ZG dd˄ de<ZG dd̈́ de<Zddτ ZG ddф dee@ZG ddӄ deZG ddՄ deZG ddׄ dee@ZG ddل de@ZG ddۄ depZG dd݄ de@ZG dd߄ de<ZG dd de@ZG dd deZG dd deZG dd de@ZG dd deZdd Zdd dd edZdddZdd ZG dd de@ZG dd de@ZG dd de@ZG dd de<ZG dd de@eZG dd  d eZG dd deZG dd de@Ze'jr>dZndZe#ddZe#d	dZe#d
dZe#ddZe#ddZe#ddZe#ddZe#ddZe#ddegdZdS (      )absolute_importNsysoscopyBuiltinerrorwarningNaming
PyrexTypespy_object_typeModuleScope
LocalScopeClosureScopeStructOrUnionScopePyClassScopeCppClassScopeUtilityCodeEncodedString
error_type_py_int_types)chain   )r   )r   r   InternalErrorCompileErrorCannotSpecialize)r	   )r
   )	TypeSlots)r   r   )r   r   r   PropertyScoper   r   r   TemplateScopeGeneratorExpressionScopeCppScopedEnumScopepunycodify_name)r   r   )Future)Options)
DebugFlags)has_np_pythranpythran_typeis_pythran_buffer   )add_metaclassstr_to_number   __init_subclass____class_getitem__c                 C   s   | d   | d fS Nr   r   )get_filenametable_entrypos r2   Q/var/www/html/mig_web/myenv/lib/python3.10/site-packages/Cython/Compiler/Nodes.pyrelative_position.   s   r4   c                 C   s   t js|S dt|  }|d u rt|S |j}|d ur-z|| W n ty,   d }Y nw |s4t|}nt|d | }||_|S )NzFile: %s (starting at line %s)
)r#   embed_pos_in_docstringr4   r   encodingencodeUnicodeEncodeError)r1   	docstringpos_liner7   docr2   r2   r3   embed_position2   s"   
r=   c                        fdd}|S )Nc                     s   t | dkr`t| d  r`| d d \}}dd|j |jjj|jdd  f }| }|jj	 }| jd7  _| i |}| jd8  _||jj	 kr^|
|ddd |
| |S | i |S )Nr   r(   z(                    /* %s -> %s.%s %s */    z->z<-)len
isinstance
call_level	__class____name__r1   insertion_pointbufferstreamtellputlnreplace)argskwdsnodecodemarkerrF   startrescodewriter_classfuncr2   r3   fM   s$   
zwrite_func_call.<locals>.fr2   )rU   rT   rV   r2   rS   r3   write_func_callL   s   rW   c                       s   e Zd Z fddZ  ZS )VerboseCodeWriterc                    s`   ddl m} ddlm} t|}| D ]\}}t||r$t||||< qtt	| 
| |||S )Nr   FunctionTyper   )CCodeWriter)typesrZ   Coder[   dictitemsrB   rW   superrX   __new__)clsnamebasesattrsrZ   r[   mnamemrD   r2   r3   ra   i   s   
zVerboseCodeWriter.__new__)rE   
__module____qualname__ra   __classcell__r2   r2   rh   r3   rX   f   s    rX   c                       s,   e Zd ZdZeh dZ fddZ  ZS )CheckAnalyserszCMetaclass to check that type analysis functions return a node.
    >   analyse_typesanalyse_expressionsanalyse_target_typesc                    sf   ddl m} dd }t|}| D ]\}}t||r'|| jv r'|||||< qtt| | |||S )Nr   rY   c                    r>   )Nc                     s,    | i |}|d u rt d| |f  |S )Nz%s %s %s)print)rL   kwargsretvalrU   rc   r2   r3   call   s   z3CheckAnalysers.__new__.<locals>.check.<locals>.callr2   )rc   rU   rt   r2   rs   r3   check~   s   z%CheckAnalysers.__new__.<locals>.check)	r\   rZ   r^   r_   rB   methodsr`   rl   ra   )rb   rc   rd   re   rZ   ru   rf   rg   rh   r2   r3   ra   |   s   zCheckAnalysers.__new__)rE   ri   rj   __doc__	frozensetrv   ra   rk   r2   r2   rh   r3   rl   s   s    rl   c                 C   s   t jr	tt| S | S N)r$   debug_trace_code_generationr)   rX   )rb   r2   r2   r3   _with_metaclass   s   r{   c                   @   s   e Zd ZdZdZdZdZdZdZdZ	dZ
dZdZdZdZdZdd ZdZdZdZd ddZdZd	d
 Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zd!ddZd"ddZdS )#Noder   FNc                 K   s   || _ | j| d S ry   )r1   __dict__update)selfr1   kwr2   r2   r3   __init__   s   zNode.__init__	Operationc                 C      t | jd| j  d S )Nz%s not allowed without gil)r   r1   gil_messager   envr2   r2   r3   	gil_error      zNode.gil_errorc                 C   s   |  s
|   d S d S ry   )is_cpp	cpp_errorr   r2   r2   r3   	cpp_check      zNode.cpp_checkc                 C   r   )Nz%s only allowed in c++)r   r1   cpp_messager   r2   r2   r3   r      r   zNode.cpp_errorc                 C   sD   t  | }|jD ]}t||}t|trt||dd |D  q|S )ac  Clone the node. This is defined as a shallow copy, except for member lists
           amongst the child attributes (from get_child_accessors) which are also
           copied. Lists containing child nodes are thus seen as a way for the node
           to hold multiple children directly; the list is not treated as a separate
           level in the tree.c                 S   s   g | ]}|qS r2   r2   ).0xr2   r2   r3   
<listcomp>   s    z#Node.clone_node.<locals>.<listcomp>)r   child_attrsgetattrrB   listsetattr)r   resultattrnamevaluer2   r2   r3   
clone_node   s   



zNode.clone_nodec                 C      d S ry   r2   r   r2   r2   r3   analyse_declarations      zNode.analyse_declarationsc                 C      t d| jj )Nz*analyse_expressions not implemented for %sr   rD   rE   r   r2   r2   r3   rn         zNode.analyse_expressionsc                 C   r   )Nz$generate_code not implemented for %sr   r   rO   r2   r2   r3   generate_code   r   zNode.generate_codec                 C   s   t | tr| j| d S d S ry   )rB   	BlockNodebodyannotater   r2   r2   r3   r      s   
zNode.annotatec              	   C   s   z| j W S  tyH   | j}| js|| _ | Y S | jD ]%}t| |}|d u r'qt|tr9|D ]	}t|| }q.qt|| }q|| _ | Y S w ry   )	_end_posAttributeErrorr1   r   r   rB   r   maxend_pos)r   r1   attrchildcr2   r2   r3   r      s&   


zNode.end_posr0   d   c           
   	      s    dkrdS du rt  t| v rd| jjt| f S t|   fddfdd| j D }t|dkrId	| jjt| f S d
| }d| jjt| f }|D ]\}}	|d|||	|d f 7 }qY|d| 7 }|S )zYDebug helper method that returns a recursive string representation of this node.
        r   z<...nesting level cutoff...>Nz<%s (0x%x) -- already output>c                    sN   t | tr|  d S t | tr#dd fdd| D  S t| S )Nr   z[%s], c                    s   g | ]} |qS r2   r2   )r   item)
dump_childlevelr2   r3   r   "      z1Node.dump.<locals>.dump_child.<locals>.<listcomp>)rB   r|   dumpr   joinrepr)r   r   cutoffr   encountered
filter_outr   r3   r     s
   

zNode.dump.<locals>.dump_childc                    s    g | ]\}}| vr||fqS r2   r2   )r   keyr   )r   r2   r3   r   &  s     zNode.dump.<locals>.<listcomp>z<%s (0x%x)>z  z<%s (0x%x)
z%s  %s: %s
r   z%s>)setidrD   rE   addr}   r_   rA   )
r   r   r   r   r   re   indentrR   r   r   r2   r   r3   r     s"   z	Node.dump(#)c           	      C   s   | j sdS | j \}}}|jddd}|td|d | }|d }|r1|d| | ||d  }| d	 |d< ||||d
  7 }d| ||d|f S )z[Debug helper method that returns the source code context of this node as a string.
         ASCIIignore)r7   error_handlingr   r+   Nz             # <<<<<<<<<<<<<<
r(   z"%s":%d:%d
%s
)r1   	get_linesr   rstripget_escaped_descriptionr   )	r   mark_columnrP   source_desclinecolcontentslinescurrentr2   r2   r3   dump_pos1  s   zNode.dump_posry   )r   r0   r   N)Fr   ) rE   ri   rj   is_nameis_noneis_nonecheck
is_literalis_terminator
is_wrapperis_cpropertyis_templated_type_nodetempsr   outer_attrscf_statecoercion_typer   r   nogil_checkin_nogil_contextr   r   r   r   r   r   rn   r   r   r   r   r   r2   r2   r2   r3   r|      s<    
%
r|   c                   @   >   e Zd ZdZdgZdd Zdd Zdd Zd	d
 Zdd Z	dS )CompilerDirectivesNodez9
    Sets compiler directives for the children nodes
    r   c                 C   s$   |j }| j |_ | j| ||_ d S ry   )
directivesr   r   r   r   oldr2   r2   r3   r   L  s   
z+CompilerDirectivesNode.analyse_declarationsc                 C   s&   |j }| j |_ | j|| _||_ | S ry   )r   r   rn   r   r2   r2   r3   rn   R  s
   z*CompilerDirectivesNode.analyse_expressionsc                 C   s8   |j }|jj }| j |j_ | j|| ||_ ||j_ d S ry   )r   globalstater   generate_function_definitions)r   r   rO   env_oldcode_oldr2   r2   r3   r   Y  s   
z4CompilerDirectivesNode.generate_function_definitionsc                 C   *   |j j}| j|j _| j| ||j _d S ry   )r   r   r   generate_execution_coder   rO   r   r2   r2   r3   r   a     
z.CompilerDirectivesNode.generate_execution_codec                 C   r   ry   )r   r   r   r   r   r2   r2   r3   r   g  r   zCompilerDirectivesNode.annotateN)
rE   ri   rj   rw   r   r   rn   r   r   r   r2   r2   r2   r3   r   C  s    r   c                   @      e Zd Zdd Zdd ZdS )r   c                 C   s.   |  j}|D ]}|j| q|d d = d S ry   )global_scopeundeclared_cached_builtinsr   add_cached_builtin_decl)r   r   rO   entriesentryr2   r2   r3   generate_cached_builtins_declsq  s   
z(BlockNode.generate_cached_builtins_declsc                 C   s   |j D ]}||| qd S ry   )lambda_defsr   )r   r   rO   rN   r2   r2   r3   generate_lambda_definitionsw     
z%BlockNode.generate_lambda_definitionsN)rE   ri   rj   r   r   r2   r2   r2   r3   r   n  s    r   c                   @   sF   e Zd ZdgZedd Zdd Zdd Zdd	 Zd
d Z	dd Z
dS )StatListNodestatsc                 K   s   t | fi |}|S ry   )r   )r1   r   r   rN   r2   r2   r3   create_analysed  s   zStatListNode.create_analysedc                 C      | j D ]}|| qd S ry   r   r   r   r   statr2   r2   r3   r     s   
z!StatListNode.analyse_declarationsc                    s    fdd| j D | _ | S )Nc                       g | ]}|  qS r2   rn   r   r   r   r2   r3   r     s    z4StatListNode.analyse_expressions.<locals>.<listcomp>r   r   r2   r   r3   rn     s   
z StatListNode.analyse_expressionsc                 C      | j D ]}||| qd S ry   r   r   r   r   rO   r   r2   r2   r3   r     s   
z*StatListNode.generate_function_definitionsc                 C   s&   | j D ]}||j || qd S ry   )r   mark_posr1   r   r   rO   r   r2   r2   r3   r     s   
z$StatListNode.generate_execution_codec                 C   r   ry   r   r   r  r2   r2   r3   r        
zStatListNode.annotateN)rE   ri   rj   r   staticmethodr   r   rn   r   r   r   r2   r2   r2   r3   r   |  s    
r   c                   @   r   )StatNodec                 C   r   ry   r2   r   r   rO   r2   r2   r3   r     r   z&StatNode.generate_function_definitionsc                 C   r   )Nz.generate_execution_code not implemented for %sr   r   r2   r2   r3   r     r   z StatNode.generate_execution_codeN)rE   ri   rj   r   r   r2   r2   r2   r3   r	    s    r	  c                   @   :   e Zd ZdgZdd Zdd Zdd Zdd	 Zd
d ZdS )CDefExternNoder   c                 C   sx   |j }d|_ | j| ||_ | js| jr:| jj}|jd s!d}n|s&d}n	tdd |D }|| j| j| d S d S )Nr   preliminary_late_includes_cy28Fc                 s   s    | ]}t |tV  qd S ry   )rB   CVarDefNode)r   rN   r2   r2   r3   	<genexpr>      z6CDefExternNode.analyse_declarations.<locals>.<genexpr>)	in_cincluder   r   include_fileverbatim_includer   r   alladd_include_file)r   r   old_cinclude_flagr   later2   r2   r3   r     s   
z#CDefExternNode.analyse_declarationsc                 C      | j || _ | S ry   r   rn   r   r2   r2   r3   rn        z"CDefExternNode.analyse_expressionsc                 C      | j || d S ry   r   r   r
  r2   r2   r3   r        z,CDefExternNode.generate_function_definitionsc                 C   r   ry   r2   r   r2   r2   r3   r     r   z&CDefExternNode.generate_execution_codec                 C      | j | d S ry   r   r   r   r2   r2   r3   r        zCDefExternNode.annotateN	rE   ri   rj   r   r   rn   r   r   r   r2   r2   r2   r3   r    s    r  c                   @   $   e Zd Zg ZdZdd Zdd ZdS )CDeclaratorNoder   c                 C   r   ry   r2   r   r2   r2   r3   declared_name  r   zCDeclaratorNode.declared_namec                 C   r   ry   r2   r   r2   r2   r3   analyse_templates  s   z!CDeclaratorNode.analyse_templatesN)rE   ri   rj   r   calling_conventionr$  r%  r2   r2   r2   r3   r#    s
    r#  c                   @   s(   e Zd ZdgZdZdd Zd	ddZdS )
CNameDeclaratorNodedefaultNc                 C      | j S ry   rc   r   r2   r2   r3   r$        z!CNameDeclaratorNode.declared_namer   Fc                 C   s   |r,| j dkr,|js|js|jrt| jd n|jr!t| jd n|jdddd| _ t}|j	rM|j
rMz||j
}W n tyL   t| jd| j   Y nw || _| |fS )Nr   Missing argument nameJUse spam() rather than spam(void) to declare a function with no arguments.r   )for_displaypyrexR'%s' cannot be specialized since its type is not a fused argument to this function)rc   is_ptris_array	is_bufferr   r1   is_voiddeclaration_coder   is_fusedfused_to_specific
specializer   type)r   	base_typer   nonempty
visibilityin_pxdr2   r2   r3   analyse  s&   zCNameDeclaratorNode.analyser   NF)rE   ri   rj   r   r(  r$  r>  r2   r2   r2   r3   r'    s
    r'  c                   @   s,   e Zd ZdgZdd Zdd Zdd	d
ZdS )CPtrDeclaratorNodebasec                 C   
   | j  S ry   rA  r$  r   r2   r2   r3   r$       
z CPtrDeclaratorNode.declared_namec                 C   rB  ry   rA  r%  r   r2   r2   r3   r%  "  rD  z$CPtrDeclaratorNode.analyse_templatesr   NFc                 C   2   |j r	t| jd t|}| jj|||||dS )Nz+Pointer base type cannot be a Python objectr;  r<  r=  )is_pyobjectr   r1   r
   
c_ptr_typerA  r>  )r   r:  r   r;  r<  r=  ptr_typer2   r2   r3   r>  %     
zCPtrDeclaratorNode.analyser?  )rE   ri   rj   r   r$  r%  r>  r2   r2   r2   r3   r@    s
    r@  c                   @   s"   e Zd ZdgZdd Zdd ZdS )_CReferenceDeclaratorBaseNoderA  c                 C   rB  ry   rC  r   r2   r2   r3   r$  /  rD  z+_CReferenceDeclaratorBaseNode.declared_namec                 C   rB  ry   rE  r   r2   r2   r3   r%  2  rD  z/_CReferenceDeclaratorBaseNode.analyse_templatesN)rE   ri   rj   r   r$  r%  r2   r2   r2   r3   rL  ,  s    rL  c                   @      e Zd ZdddZdS )CReferenceDeclaratorNoder   NFc                 C   rF  )Nz-Reference base type cannot be a Python objectrG  )rH  r   r1   r
   
c_ref_typerA  r>  r   r:  r   r;  r<  r=  ref_typer2   r2   r3   r>  7  rK  z CReferenceDeclaratorNode.analyser?  rE   ri   rj   r>  r2   r2   r2   r3   rN  6      rN  c                   @   rM  ) CppRvalueReferenceDeclaratorNoder   NFc                 C   rF  )Nz4Rvalue-reference base type cannot be a Python objectrG  )rH  r   r1   r
   cpp_rvalue_ref_typerA  r>  rP  r2   r2   r3   r>  ?  rK  z(CppRvalueReferenceDeclaratorNode.analyser?  rR  r2   r2   r2   r3   rT  >  rS  rT  c                   @   s   e Zd ZddgZdddZdS )	CArrayDeclaratorNoderA  	dimensionr   NFc                    sf  |j r| s|js|jrRddlm} t| j|r| jj}n| jf} fdd|D }d |v r?|	d }	t
||	 jd t}n|| j |}| jj| |||dS | jr| j | _| jjjsht
| jjd | j }
|
d urzt|
}
W n ty   Y nw nd }
| st
| jd|  |jrt
| jd	 |jrt
| jd
 t||
}| jj| |||dS )Nr   	TupleNodec                    r   r2   )analyse_as_type)r   vr   r2   r3   r   U  r   z0CArrayDeclaratorNode.analyse.<locals>.<listcomp>zTemplate parameter not a typerG  zArray dimension not integerz%Array element type '%s' is incompletez'Array element cannot be a Python objectz"Array element cannot be a function)is_cpp_classis_template_typeis_cfunctionpython_type_constructor_name	ExprNodesrY  rB   rW  rL   indexr   r1   r   specialize_hererA  r>  analyse_const_expressionr9  is_intget_constant_c_result_codeint
ValueErroris_completerH  r
   c_array_type)r   r:  r   r;  r<  r=  rY  rL   valuesixsize
array_typer2   r   r3   r>  L  sJ   



zCArrayDeclaratorNode.analyser?  rE   ri   rj   r   r>  r2   r2   r2   r3   rV  F      rV  c                   @   sH   e Zd Zg dZdZdZdZdZdd Zdd Z	dd	d
Z
dddZdS )CFuncDeclaratorNode)rA  rL   exception_valuer   Nc                 C   rB  ry   rC  r   r2   r2   r3   r$    rD  z!CFuncDeclaratorNode.declared_namec                 C   s   t | jtrRddlm}m} | jj}t ||r|j}nt ||r$|g}nt|j	d d S g | _
|D ]}t ||rC| j
t|j q1t|j	d q1| jj| _| j
S d S )Nr   )rY  NameNodez*Template arguments must be a list of names)rB   rA  rV  r`  rY  rr  rW  rL   r   r1   	templatesappendr
   TemplatePlaceholderTyperc   )r   rY  rr  template_nodetemplate_nodestemplater2   r2   r3   r%    s"   



z%CFuncDeclaratorNode.analyse_templatesFc                    s(  |d u ri }|r|d8 }g }t jD ]\}}	|	j ||dko& jo&d jvd\}
}|
j}||v r`|| }| }|d u rFt|jd n|t	j
ur^||s^tjjd t|jd n|}|
jritjd |dkrv jrv|jrv j}|jrt	|j}|jrt|	jd	 |t	|||	j |	jr jd7  _qjrtjd
 qd }d} jd r|js҈js҈jr|dkr҈  jv r|rd_tjddd jdkr d  d  d  d n	|jrjrd_|jrjsjrjdkrtjd n|jr'js'|dkr'jr'tjdd njd u r`jr`jdkr`|jd ur`|dkr`|s` js`t jt!s`ddl"m#} |j|j|d_jrjdkrj$ _jj%}|j&s|js|j'r|j(js|jr|t	j)krjj*dkstjjd j}ndj+ ,| $ _j- }|d u rtjjd |.jj%stjjd |dkr|j/s|j0rj1 rzt2|j3}W n
 t4y   Y nw jj5|krtjdjj5  j}|j'rtjd t	j6||j7j||jj8j9j:j;j<j=d }jrF|j>r@ fd!d"}||_?n@|   jd# }|rf|j8}|rc||krctjd$||f  ||_8|j(jArrtjd%d |jD ]}|j%jAr|B stjd&d qujj| ||d'S )(Nr   r   r  r;  is_self_arg
Not a type2Signature does not agree with previous declarationPrevious declaration herez2Function argument cannot have C name specificationr-  z-Non-default argument follows default argumentlegacy_implicit_noexceptexternFzdImplicit noexcept declaration is deprecated. Function declaration should contain 'noexcept' keyword.r(   r   +iosnew	stdexcepttypeinfozAException clause not allowed for function returning Python objectz?noexcept clause is ignored for function returning Python object	ConstNoder   r9  *zTException value must be a Python exception, or C++ function with no arguments, or *.z Exception value must be constantz6Exception value incompatible with function return typez;Ambiguous exception value, same as default return value: %rz!Function cannot return a function)	optional_arg_countrq  exception_checkr&  nogilwith_gilis_overridableis_const_methodrs  c                    s    |  | d S ry   )declare_optional_arg_struct)	func_typefused_cnamer   r   r2   r3   declare_opt_arg_struct.  r  z;CFuncDeclaratorNode.analyse.<locals>.declare_opt_arg_structcallspecz2cannot have both '%s' and '%s' calling conventionsz6Rvalue-reference as function return type not supportedz3Rvalue-reference as function argument not supportedr<  r=  )C	enumeraterL   r>  is_c_class_scoper   rc   rZ  r   r1   r
   r   same_asrA  cnameis_unspecifiedparent_typer2  rI  r:  r4  rt  CFuncTypeArgr(  r  rH  has_explicit_exc_clauser  r$  r   r   r  rq  rB   r@  r`  r  rc  r9  is_errorr^  return_typec_char_typer   rm   	coerce_tore  assignable_fromrd  is_floathas_constant_resultfloatdefault_valuerg  constant_result	CFuncTypehas_varargsr&  r  r  overridabler  rs  r6  r  r  is_rvalue_referenceis_forwarding_reference)r   r  r   r;  directive_localsr<  r=  func_type_argsiarg_nodename_declaratorr9  rc   	type_node
other_typeexc_val	exc_checkr  exc_val_typetype_default_valuer  r  r  r   argr2   r  r3   r>    s8  







" 



	


zCFuncDeclaratorNode.analysec           	      C   s   t  }dtj }||tj| j |jt|j| j	 d D ]}|j|j
|j|jddd q|tj| jj
}|durAt||}| j|d|d| j|d}d|_d|_t|j|_dS )	a  
        Declares the optional argument struct (the struct used to hold the
        values for optional arguments). For fused cdef functions, this is
        deferred as analyse_declarations is called only once (on the fused
        cdef function).
        z%snNT)allow_pyobjectallow_memoryviewstructr   )rc   kindscopetypedef_flagr1   r  r   )r   r	   pyrex_prefixdeclare_varr
   
c_int_typer1   rL   rA   r  rc   r9  mangleopt_arg_prefixrA  get_fused_cnamer   declare_struct_or_uniondefined_in_pxdusedrI  op_arg_struct)	r   r  r   r  r  arg_count_memberr  struct_cnameop_args_structr2   r2   r3   r  E  s&   
z/CFuncDeclaratorNode.declare_optional_arg_struct)r   NNFry   )rE   ri   rj   r   r  r  r  rs  r$  r%  r>  r  r2   r2   r2   r3   rp  t  s    
 &rp  c                   @   s   e Zd ZdgZdddZdS )CConstDeclaratorNoderA  r   NFc                 C   rF  )Nz)Const base type cannot be a Python objectrG  )rH  r   r1   r
   c_const_typerA  r>  )r   r:  r   r;  r<  r=  constr2   r2   r3   r>  k  s   
zCConstDeclaratorNode.analyser?  rn  r2   r2   r2   r3   r  f      r  c                   @   s   e Zd Zg dZddg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d	 Zed
d Zedd ZdddZdd Zdd Zdd ZdddZdS )CArgDeclNode)r:  
declaratorr(  
annotationr(  r  r   r   FNc                 C   rB  ry   r  r$  r   r2   r2   r3   r$    rD  zCArgDeclNode.declared_namec                 C   rB  ry   )rc   as_c_string_literalr   r2   r2   r3   name_cstring     
zCArgDeclNode.name_cstringc                 C   s*   | j rttj| jj S ttj| jj S ry   )needs_conversionr    r	   
arg_prefixr   rc   
var_prefixr   r2   r2   r3   	hdr_cname  s   zCArgDeclNode.hdr_cnamec                 C   sf  |r	| | j _| _| jd ur| j| jfS t| jtrH| jjdkrH|rE| j jr3| j j	|dd}|
 }n| j j}t|| j_d | j _d| j _d}nd}d| j _| j j	||d}t| j dd }|rc|| j_|jrt| j trt| jtr| j}	t|	jtr|	j}	t|	jts{| j j|	_|j }| jr|r|jd rt| j dd d u r| |}
|
d ur|
}| jj	|||dS )	Nr   T)could_be_nameFarg_nameannotation_typingrc   r;  )r:  rz  r9  r  rB   r  r'  rc   is_basic_c_typer>  empty_declaration_coder   is_argr   r2  TemplatedTypeNoderV  rA  array_declaratorr  r   inject_type_from_annotations)r   r   r;  rz  r9  r  r  r:  base_arg_namer  arg_typer2   r2   r3   r>    sJ   





zCArgDeclNode.analysec                 C   s   | j }|sd S |j|| jd\}}|d urt|j|dd| _|rld|v r6| }|r1| s1	 |S d| _|S |t	u r?d| _|S | jrb| jj
rb| sM|jrb| sT|j}| js`t| jd d| _|S | jsl| rld| _|S )N)assigned_valueT)r9  r  typing.OptionalzIPEP-484 recommends 'typing.Optional[...]' for arguments that can be None.)r  analyse_type_annotationr(  CAnalysedBaseTypeNoder1   r:  resolvecan_be_optionalor_noner   r   equivalent_typer   not_none)r   r   r  	modifiersr  r2   r2   r3   r    s:   z)CArgDeclNode.inject_type_from_annotationsc                 C   sJ   | j d u r"| jr"| jjr| j| | j| j S || j| _ | j S ry   )r  r(  r   generate_evaluation_coder9  	cast_coder   get_argument_default_constr   r2   r2   r3   calculate_default_value_code  s   
z)CArgDeclNode.calculate_default_value_codec                 C      | j r| j | d S d S ry   )r(  r   r   r2   r2   r3   r        zCArgDeclNode.annotatec                 C   s   | j }|d u s
|jrd S |d u r| |}|| || |r%| n|| j}|d||f  |	| | j |
| || d S N%s = %s;)r(  r   r  r  make_owned_referencer   	result_asr9  rJ   put_giverefgenerate_post_assignment_code
free_temps)r   rO   targetoverloaded_assignmentr(  r   r2   r2   r3   generate_assignment_code  s   



z%CArgDeclNode.generate_assignment_code)r   FNF)rE   ri   rj   r   r   rz  is_type_arg
is_genericis_special_method_optionalkw_onlypos_onlyr  r  r9  r  r  r  
is_dynamicr$  propertyr  r  r>  r  r  r   r   r2   r2   r2   r3   r  s  s4    


	2#
r  c                   @   s   e Zd Zdd ZdS )CBaseTypeNodec                 C   s
   |  |S ry   r>  r   r2   r2   r3   rZ  #  rD  zCBaseTypeNode.analyse_as_typeN)rE   ri   rj   rZ  r2   r2   r2   r3   r	    s    r	  c                   @   s   e Zd Zg ZdddZdS )r  Fc                 C   r)  ry   r9  )r   r   r  r2   r2   r3   r>  ,  r+  zCAnalysedBaseTypeNode.analyseNFrn  r2   r2   r2   r3   r  '  s    r  c                   @   s.   e Zd Zg ZdZg ZdZdZdZdddZ	dS )CSimpleBaseTypeNodeNFc           	      C   s>  d }| j rt| j| j| j}|st| jd n| jdkr#| js#t	}n| jd u r5| j
r2|jr2|j}nt	}n|}| jr| jD ]%}||}|d urW|jsR|jrW|jjrW|jj}q=|r`|jr`|j}q=d } |d u rt| jdkrddlm} || jd }|r|jr||j}|d u r|| j| j}|r|jr| }|| j}|d urn7|r| j
r|jr|j}nt	}t| j| _n"| jr| j| jvrt| jd| j  t| j}n	t| jd| j  |r|jr|jr| |j}| j!r|j"r|j#rt| jd t$|}|%| n|tj&u rtj'}|%| d| _!|stj(}|S )	Nz&Unrecognised type modifier combinationobjectr   )'get_known_standard_library_module_scoper   z'%s' is not a type identifierz#can only complexify c numeric typesT))r  r
   simple_c_typesignedlongnessrc   r   r1   module_pathr   rz  r  r  lookupr\  is_typer9  r  	as_modulerA   r   r  known_standard_library_importfind_imported_moduler   lookup_typer   r  rs  ru  r6  r7  r8  complex
is_numeric
is_complexCComplexTypecreate_declaration_utility_codecomplex_typec_double_complex_typer   )	r   r   r  r9  r  r   r   r  found_entryr2   r2   r3   r>  A  s   








zCSimpleBaseTypeNode.analyser  )
rE   ri   rj   r   r  r  r  r  rz  r>  r2   r2   r2   r3   r  0  s    
r  c                   @   s*   e Zd ZdZddgZd
ddZdd Zd	S )MemoryViewSliceTypeNode
memoryviewbase_type_nodeaxesFc              
   C   s   | j |}|jr|S ddlm} z	||| j}W n! ty; } zt|j	|j
 t | _| jW  Y d }~S d }~ww || j|sIt| _| jS t||| _| j| j | | | jS Nr   
MemoryView)r$  r>  r  r   r(  get_axes_specsr%  r   r   positionmessage_onlyr
   	ErrorTyper9  validate_axesr1   r   MemoryViewSliceTypevalidate_memslice_dtypeuse_memview_utilities)r   r   r  r:  r(  
axes_specser2   r2   r3   r>    s$   


zMemoryViewSliceTypeNode.analysec                 C   s   ddl m} ||j d S r&  )r   r(  use_utility_codeview_utility_code)r   r   r(  r2   r2   r3   r0       z-MemoryViewSliceTypeNode.use_memview_utilitiesNr  )rE   ri   rj   rc   r   r>  r0  r2   r2   r2   r3   r"    s
    
r"  c                   @   s   e Zd ZdgZdddZdS )CNestedBaseTypeNoder:  Nc                 C   sr   | j |}|tju rtjS |jst| jd|  tjS |j| j	}|r(|j
s6t| jd|| j	f  tjS |jS )Nz'%s' is not a valid type scopez '%s.%s' is not a type identifier)r:  r>  r
   r   r\  r   r1   r  lookup_hererc   r  r9  )r   r   r  r:  
type_entryr2   r2   r3   r>    s   

zCNestedBaseTypeNode.analysery   rn  r2   r2   r2   r3   r6    s    r6  c                   @   s:   e Zd Zg dZdZdZdZdd ZdddZd	d
 Z	dS )r  )r$  positional_argskeyword_args
dtype_nodeTNc           	   	   C   s   |j dk}|j dk}|jo| }g }| jD ]Y}||pt|t ||}W d    n1 s1w   Y  |d u rF|jrEt|j	d t
}n#|rK|jrQ|ri| si|jr\| s\|j}nt|j	d|j |f  t
}|| q|S )Nr  zdataclasses.ClassVarz!unknown type in template argumentz$%s[...] cannot be applied to type %s)r_  in_c_type_contextr9  new_c_type_contextrB   r	  rZ  r\  r   r1   r   rH  r  r  as_cython_attributert  )	r   r   r:  require_optional_typesrequire_python_typesr<  template_typesrv  ttyper2   r2   r3   _analyse_template_types  s.   


z)TemplatedTypeNode._analyse_template_typesFc           
      C   s  |d u r
| j |}|jr|S |jr| s|jrF| jr6| jjr6|jr%dnd}t| j	d|  t
j| _| jS | ||}|| j	||| _n|jrddlm} || j	|| j| j|j}tjd dk rntdd	 | D }t
j|fi || _t|rt| jrt
t| j| j| _n<t| j	d
d d}t| jdks| jjrt| j	d t
j| _n| jsd }	n| jd }	t | j	||	d| _!| j!||d | _| jr| jj"r|j#rz| j$|j#| _W | jS  t%y   t| j	d| j&  Y | jS w | jS )Nzc++ templateszindexed typesz %s cannot take keyword argumentsr   Bufferr   r+   c                 S   s   g | ]\}}| d |fqS )r   )r8   )r   rc   r   r2   r2   r3   r         z-TemplatedTypeNode.analyse.<locals>.<listcomp>r   rc   r  zinvalid array declaration)rA  rW  r0  )'r$  r>  r  r\  r]  r_  r:  key_value_pairsr   r1   r
   r   r9  rC  rb  rH  r   rE  analyse_buffer_optionsr9  buffer_defaultsr   version_infor^   r_   
BufferTyper%   r'   PythranExprr&   r'  rA   rV  r  r6  r7  r8  r   rc   )
r   r   r  r:  tprA  rE  optionsempty_declaratorrW  r2   r2   r3   r>    sp   


zTemplatedTypeNode.analysec                 C   sn   g }| }|j r5|jr5t|jdkr5| j|}|jr#|jr#||j |jd }|j r5|jr5t|jdks|S )Nr   r   )r   r$  rA   r9  rZ  r_  modifier_namert  )r   r   r  modifier_nodemodifier_typer2   r2   r3   analyse_pytyping_modifiers=  s   
z,TemplatedTypeNode.analyse_pytyping_modifiers)FN)
rE   ri   rj   r   r   r;  rc   rC  r>  rT  r2   r2   r2   r3   r    s    	
Br  c                   @   s   e Zd ZddgZdddZdS )CComplexBaseTypeNoder:  r  Fc                 C   s$   | j ||}| j||\}}|S ry   )r:  r>  r  )r   r   r  rA  _r9  r2   r2   r3   r>  Q  s   zCComplexBaseTypeNode.analyseNr  rn  r2   r2   r2   r3   rU  K  ro  rU  c                   @      e Zd ZdgZdddZdS )CTupleBaseTypeNode
componentsFc                 C   sX   g }| j D ]}||}|jrt|jd t  S || q|| j|}d|_|j	S )Nz/Tuple types can't (yet) contain Python objects.T)
rY  r>  rH  r   r1   r   rt  declare_tuple_typer  r9  )r   r   r  component_typesr   r9  r   r2   r2   r3   r>  \  s   

zCTupleBaseTypeNode.analyseNr  rn  r2   r2   r2   r3   rX  W  r  rX  c                   @   s&   e Zd ZdZg Zdd ZdddZdS )	FusedTypeNodea  
    Represents a fused type in a ctypedef statement:

        ctypedef cython.fused_type(int, long, long long) integral

    name            str                     name of this fused type
    types           [CSimpleBaseTypeNode]   is the list of types to be fused
    c                 C   s&   |  |}|| j|| j}d|_d S )NT)r>  declare_typedefrc   r1   r  )r   r   r9  r   r2   r2   r3   r   u  s   

z"FusedTypeNode.analyse_declarationsFc                 C   s\   g }| j D ] }||}|st|jd q||v r t|jd q|| qtj|| jdS )Nr{  zType specified multiple timesr*  )r\   rZ  r   r1   rt  r
   	FusedTyperc   )r   r   r  r\   r  r9  r2   r2   r3   r>  |  s   

zFusedTypeNode.analyseNr  )rE   ri   rj   rw   r   r   r>  r2   r2   r2   r3   r\  i  s
    	r\  c                   @   rW  )CConstOrVolatileTypeNoder:  Fc                 C   s2   | j ||}|jrt| jd t|| j| jS )Nz2Const/volatile base type cannot be a Python object)	r:  r>  rH  r   r1   r
   c_const_or_volatile_typeis_constis_volatile)r   r   r  rA  r2   r2   r3   r>    s   z CConstOrVolatileTypeNode.analyseNr  rn  r2   r2   r2   r3   r_    s    r_  c                   @   s&   e Zd ZddgZdZdZdddZdS )r  r:  declaratorsNc                 C   s6  | j d u ri | _ |s|}|| _| jr| jd  }nd }|d urS| jdkr+t| jd t| jdkr;t| jd jd td|}|j	j
|_
|D ]}||j|| j qG| j|}d }| jjre| j|}|jry| jsy|jsq|jryt| jd tS d | _| j}| jD ]}t| jdkrt|ts|j
d rt|jd	d | jo| jdko|j}	|	rd
|_t|tr|j||| j || jd\}
}n|j|||| jd\}
}| s| jdkr|js|jst|jd|  | jdkr|jrt|jd |
j}|
j }|dkrt|jd  d S |j!r| jdkrt|jd |j"r&| jdkr&t|jd |j#red|j
v r3d|_$|j%|||j|| j| j| j&| j'| jd	| _| jd urVt((| j | j_ |	rd| jj)*| d| j_+q| jrot| jd | j ryt| jd |j,|||j||| j| j&d|d	| _t-j.rt/| j| j0| j_0qd S )Nr   r  zOnly extern functions allowedr   z%Can't multiply declare template typesfunc_templatezFused types not allowed herezwarn.multiple_declaratorszNon-trivial type declarators in shared declaration (e.g. mix of pointers and values). Each pointer declaration should be on its own line.F)r  r<  r=  r  z Variable type '%s' is incompletez'Python object cannot be declared externr   zMissing name in declaration.z8C++ references cannot be declared; use a pointer insteadz(C++ rvalue-references cannot be declaredr  T)r  r<  r=  apir  r  z>Variables cannot be declared with 'cpdef'. Use 'cdef' instead.z,Decorators can only be followed by functions)r  r<  r=  re  is_cdefpytyping_modifiers)1r  
dest_scoperc  r%  r<  r   r1   rA   r   outer_scoper   declare_typerc   r:  r>  r   rT  r6  r=  r  is_module_scoper   r   rB   r'  r   r  rp  rh  r2  is_memoryviewslicerH  r  is_referencer  r^  is_static_methoddeclare_cfunctionre  r  r   r9  create_to_py_utility_codecreate_wrapperr  r#   
docstringsr=   r<   )r   r   rh  rs  template_paramr:  r  r<  r  create_extern_wrapperr  r9  rc   r  r2   r2   r3   r     s   








z CVarDefNode.analyse_declarationsry   )rE   ri   rj   r   
decoratorsr  r   r2   r2   r2   r3   r    s
    r  c                   @   s4   e Zd ZdgZdddZdd Zdd Zd	d
 ZdS )CStructOrUnionDefNode
attributesNc                 C   s2   |j | j| j|| j| j| j| j| j| jd	| _	d S )N)r<  re  packed)
r  rc   r  r  r1   r  r<  re  rx  r   r   r   r  r2   r2   r3   declare   s
   zCStructOrUnionDefNode.declarec                 C   s   d }| j d urt| j}| || | j d urP| jr!|js!d| j_| j D ]}||| q$| j	dkrR|j
D ]}|j}|jrC|j}|js=|| jjkrOt|jd q5d S d S d S )Nr   r  z)Struct cannot contain itself as a member.)rw  r   rc   rz  r=  r  r   r  r   r<  var_entriesr9  r2  r:  r   r1   )r   r   r  r   r9  r2   r2   r3   r   &  s*   





z*CStructOrUnionDefNode.analyse_declarationsc                 C      | S ry   r2   r   r2   r2   r3   rn   8  r   z)CStructOrUnionDefNode.analyse_expressionsc                 C   r   ry   r2   r   r2   r2   r3   r   ;  r   z-CStructOrUnionDefNode.generate_execution_codery   )rE   ri   rj   r   rz  r   rn   r   r2   r2   r2   r3   rv    s    
rv  c                   @   s@   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dS )CppClassNodeNc              	   C   s   | j d u rd }n)dd | j D }tdd | j D }|r1tdd | j d |  D s1t| jd |j| jd | j| jg | j|d| _	d S )Nc                 S      g | ]\}}t || qS r2   r
   ru  r   template_namerequiredr2   r2   r3   r   Q  rF  z(CppClassNode.declare.<locals>.<listcomp>c                 s   s    | ]\}}| V  qd S ry   r2   r   rV  r  r2   r2   r3   r  S  r  z'CppClassNode.declare.<locals>.<genexpr>c                 s   s    | ]\}}|V  qd S ry   r2   r  r2   r2   r3   r  T  s    zGRequired template parameters must precede optional template parameters.)base_classesr<  rs  )
rs  sumr  r   r1   declare_cpp_classrc   r  r<  r   )r   r   rA  num_optional_templatesr2   r2   r3   rz  M  s   
"zCppClassNode.declarec           
   	      sp  j d u r
d  }}ndd j D }dd j D }d jd ur)tj |dfdd}t| fddjD } jjjj|j	|d_
j
d u rUd S d	j
_d urbj
j_g }fd
djd urjry jsyd	j
_jD ]}t|dd }|r| | q|jD ]}	||	 j d urdd| |	_qtj|d__d S )Nc                 S   s   g | ]\}}|qS r2   r2   )r   r  rV  r2   r2   r3   r   ^      z5CppClassNode.analyse_declarations.<locals>.<listcomp>c                 S   r~  r2   r  r  r2   r2   r3   r   _  rF  )rs  c                    s$   | j s| jrdS t jd|   d S )NTz&Base class '%s' not a struct or class.)r\  	is_structr   r1   )
base_classr   r2   r3   base_okd  s   z2CppClassNode.analyse_declarations.<locals>.base_okc                    s   g | ]	}| p	 qS r2   r
  )r   b)r   r  r2   r3   r   i  s    )r<  rs  r   c                 3   sp    | D ]2}t |tr|V  qt |tr  |jjD ]}|V  qqt |tr5|jd ur5 |jD ]}|V  q/qd S ry   )rB   CFuncDefNoder   r   r   r}  rw  )rw  r   sub_attr)func_attributesr2   r3   r  s  s   

z:CppClassNode.analyse_declarations.<locals>.func_attributesrz  ztemplate <typename %s>z, typename r   )rs  rw  r   rc   filterr  r  r1   r  r<  r   r\  r9  r=  r  r  r   rz  r   rt  r   template_declarationr   r   r  )
r   r   rA  template_namesr  base_class_typesdefined_funcsr   rz  rU   r2   )r   r  r  r   r3   r   Z  sJ   












z!CppClassNode.analyse_declarationsc                 C   s   | j | jjj| _ | S ry   )r   rn   r   r9  r  r   r2   r2   r3   rn     s   z CppClassNode.analyse_expressionsc                 C   s   | j | jjj| d S ry   )r   r   r   r9  r  r
  r2   r2   r3   r     s   z*CppClassNode.generate_function_definitionsc                 C   r  ry   r   r   r   r2   r2   r3   r     r   z$CppClassNode.generate_execution_codec                 C   r  ry   r  r   r2   r2   r3   r     r   zCppClassNode.annotate)
rE   ri   rj   ru  rz  r   rn   r   r   r   r2   r2   r2   r3   r}  ?  s    2r}  c                   @   s8   e Zd ZddgZdZdd Zdd Zdd	 Zd
d ZdS )CEnumDefNoder_   underlying_typeNc                 C   sJ   d }t jrt| j| j}|j| j| j| j| j| j	| j
| j| j|d	| _d S )N)r  scopedr  r<  re  rq  r<   )r#   rr  r=   r1   r<   declare_enumrc   r  r  r  r<  re  rq  r   )r   r   r<   r2   r2   r3   rz    s   zCEnumDefNode.declarec                 C   s   d }| j |}|jst| j jd || jj_ | jr/| jd ur/t	| j
|}| jj|_|j|_n|}| jd uri| jr@|js@d| j_| jdk}|rIdnd }| jD ]}||| j| |rhd|jjd ure|jjn| }qNd S d S )Nz'underlying type is not an integral typer   r  r   )r  r>  rd  r   r1   r   r9  r  r_   r   rc   r   r=  r  r  r<  analyse_enum_declarationsenum_int_value)r   r   r  r  is_declared_enumnext_int_enum_valuer   r2   r2   r3   r     s0   





	z!CEnumDefNode.analyse_declarationsc                 C   r|  ry   r2   r   r2   r2   r3   rn     r   z CEnumDefNode.analyse_expressionsc              
   C   s   | j rd S | jdks| jrZ|| j |jjtjdd}| j	j
D ]1}|d||j|||jf  ||tj |dtj|j|||jf  ||tj q |j| d S d S )NpublicT
manage_refz%s = PyInt_FromLong(%s); %sz.if (PyDict_SetItemString(%s, "%s", %s) < 0) %s)r  r<  re  r  r1   	funcstateallocate_tempr
   r   r   enum_valuesrJ   r  error_goto_if_null
put_gotrefr	   moddict_cnamerc   
error_gotoput_decref_clearrelease_temp)r   rO   tempr   r2   r2   r3   r     s*   
z$CEnumDefNode.generate_execution_code)	rE   ri   rj   r   r<   rz  r   rn   r   r2   r2   r2   r3   r    s    r  c                   @   s   e Zd ZdgZdd ZdS )CEnumDefItemNoder   c              
   C   s  | j r| j || _ | j jjs| j tj|| _ | j || _ |jjr,d|j| j	f }n| j}|j
| j	|j| j | j||j|j|joE|j	d u d | _}|}| j ro| j jr[t| j j }n| j jsc| j jrm| j jrm| j jj}nd }|d urv||_|j| |j	r|jj|j	 d S d S )Nz%s::%s)r  r<  re  rq  )r   rc  r9  rd  r  r
   r  is_cpp_enumr  rc   declare_constr1   r<  re  rq  r   r   r*   r   is_attributer  r  rt  rj  )r   r   
enum_entryincremental_int_valuer  r   
enum_valuer2   r2   r3   r    s6   

z*CEnumDefItemNode.analyse_enum_declarationsN)rE   ri   rj   r   r  r2   r2   r2   r3   r    s    r  c                   @   s,   e Zd ZddgZdd Zdd Zdd Zd	S )
CTypeDefNoder:  r  c                 C   sz   | j |}| jj||| j| jd\}}|j}|j}|j||| j|| j| j	d}|j
r.d|_| jr9|js;d|_d S d S d S )Nr  )r  r<  re  Tr   )r:  r>  r  r<  r=  rc   r  r]  r1   re  r6  r  r  )r   r   rA  r  r9  rc   r  r   r2   r2   r3   r   #  s   


z!CTypeDefNode.analyse_declarationsc                 C   r|  ry   r2   r   r2   r2   r3   rn   4  r   z CTypeDefNode.analyse_expressionsc                 C   r   ry   r2   r   r2   r2   r3   r   7  r   z$CTypeDefNode.generate_execution_codeNrE   ri   rj   r   r   rn   r   r2   r2   r2   r3   r    s
    r  c                   @   s   e Zd ZdZdZdZdZdZdZdZ	dZ
dZdZg ZdZdZdZdZdZdZdZdd Zdd Zdd Zd	d
 Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Z dd Z!dd Z"dd  Z#d!d" Z$d#d$ Z%d%d& Z&dS )'FuncDefNodeNFc                 C   s   d}| j D ]D}|jr;d}|jr |j||_|j|j||_q|jr1|jjs0t|j	d d |_qt|j	d d |_q|j
rAd}q|rIt|j	d qd S )Nr   r   z2This argument cannot have a non-None default valuez)This argument cannot have a default valuez/Non-default argument following default argument)rL   r(  r  rm   r  r9  r  r   r   r1   r  )r   r   default_seenr  r2   r2   r3   analyse_default_valuesd  s(   
z"FuncDefNode.analyse_default_valuesc                 C   s<   | j D ]}|jr|j||_q| jr| j|| _d S d S ry   )rL   r  rm   return_type_annotationr   r   r  r2   r2   r3   analyse_annotationsx  s   
zFuncDefNode.analyse_annotationsc                 C   s   | j }|j}|j|v r||j }||}nt|tr2|jr2|jd r2|j}||}|d u r1|S n|S |d u r@t	|j
d |S |turX||sXt	|jj
d t	|j
d |S ||_|jjre|j| |S )Nr  r{  r|  r}  )r  r9  rc   rZ  rB   r  r  r   r  r   r1   r   r  r:  r  r  )r   r   r  r  	orig_typer  r  r2   r2   r3   align_argument_type  s.   


	zFuncDefNode.align_argument_typec                 C      dS Nr   r2   r   lenvr2   r2   r3   need_gil_acquisition  r   z FuncDefNode.need_gil_acquisitionc                 C   s   |}|j s|jr|j}|j s|js| jr(| jrtnt}|| jj||| jj	d}n	t
| jj||d}| j|_| jj}|jrD|joB|j |_|| _|j|_|S )N)rc   ri  parent_scope
scope_name)rc   ri  r  )is_py_class_scoper  ri  needs_closureis_generator_expressionr   r   r   rc   r  r   r  r9  r^  r  r  local_scoper   )r   r   genvrb   r  r9  r2   r2   r3   create_local_scope  s,   zFuncDefNode.create_local_scopec                 C   s   | j | d S ry   r  r
  r2   r2   r3   generate_function_body  r   z"FuncDefNode.generate_function_bodyc           '         sf  ddl m} j}|jr|jsdtjtjf }ntj}|| j	
|| || jjdko7jjj}jjdkoBjjj}|pF|}|rUdjvrUjdg _ }	|jjd }
|jjd }|
si|ry|ro|  |jtd	d
 || | |_|j |j_|j  || |!d |	r|!|	 "||pj#}j$rj$j%||dd j%||d |}|j&s|jr|j'}|j&s|jsňj(r|)|j*j+,tj |!d n'j-r	|jr|)|j*j+,tj |!d |)|j*j+,tj |!d .|| |j/D ]}|j0s!|j1s!|2| qd}j3}|j4r3|j5r3|j6}|j7sW|j8r>d}n|j9rJd|:|j; }|!d|,tj<|f  |= }>| j?}dd |j@D }|jouj(puj-}d d}|s|r|A  d|j_d}n|= |
s|rjBs|C  jDrjDE|nd }|F| |rG| |= }|= }|rƈH| j(r1tIJdd}tIK|j*j+j|}|sd|j*j+jL }|!dtj|j*j+M ||j*j+jLtjNf  |!dtj  |!dtj|j*j+Odf  |PdtQ |!|Rj |!d |Stj|j*j+ |!d j-r{jTrI|!d||j*j+M tjUf  n|!d ||j*j+M tjUf  |jrg|!dtj|f  nj(r{|P||j*j+ |V||j*j+ |
s|rjBsjWrjjd! }njj}|jX|j|jj d" d|j_YZ|| |j[D ]+}|j+j9s|s|j\r|j0s|]| q|j\r|j0s|j^||jjd# q|j/D ]-}|j1r|j\r|j0s|j+j9r|j^||jjd# |j_r|`| q|]| q|j/|j[ D ]}|j+jar#|jbjcjdr#|e|| qf| |j[D ]}|j+jar<|g||j q-|jjhrEd}|rc|jrcd ur[A  d d|j_|i  d|j_j|| |jjdd$ |!d |!d% |jj|jjd u d&|ffd'd(	 j3}j	jks|j8rtj<} d) |l|| n!|j9s|j;}|r|!dtj<|f  n|j7s|!d*tj<  |m|jnrj	jks|o|jp |q|jn |jr D ]\}} d+ |js||d+ d# qtt|d,k} | r4|jtu |!d- |!d.  d+ |!d/ |!d0 |D ]	}|v|| q%|!d1 |j9rIdd2l mw}! |!xtj<| tj<}"ny }"z }#|"d usY|#r d+ |jj{rr|!d3tj|  |!d4tj|  |}jj~ |jj{r|!d ntjjd5jj~ d,  d+ |jj~ |j;}$|"d u r|$r|$}"|"d ur|"tj<kr|!dtj<|"f  n|j7s|!d*tj<  |rֈ d+ | |= f fd6d7	}%| s|s|j9rd+ s|j9sJ |o|j n|%  nd8d7 }%|m|jps|m|jnsf|q|jp |D ]} d) |v|| q|r6 d) | |j9rf||tj<}&|!d9|&  d) sS|A  |!d: d) sa|i  |!d |m|jrv|%  |q|j |j/D ].}|jdr|j0rqy|j+jr|j1r|j\sqy|j+jr d) |j|d) d# qy|j[D ]0}|j0rq|j+j9r|j\sqn|s|j\sȐq|j+jrш d) |j|d) d# qj(r d) |tj|j*j+ |js	|j;}$y }"|"d u r|$r|$}"|tj<| jjr$jjd;kr$ d) |!d<tj<tj<f  |
s*|rLd|j_YjBsL|j8rB|jtj<d)  d" n
|jdd)  d" |jjhrh|  |jjj| d= |jd)  d" |st|jr|d) r||i  d|j_|j7s|!d>tj<  |!d |	r|!d?|	  ||j |  j$rj$
|| | d S )@Nr   rD  z%s->%s__getbuffer____releasebuffer__cython_unusedprofile	linetraceProfilez	Profile.cr   Twith_pymethdef
proto_only)r  ;z = NULL = %s%s;c                 S   s   g | ]}|j r|qS r2   r  )r   r   r2   r2   r3   r     r   z=FuncDefNode.generate_function_definitions.<locals>.<listcomp>Ftp_newra   z
%s->tp_newz%s = (%s)%s(%s, %s, NULL);if (unlikely(!%s)) {r  Py_None} else {}z*%s = (%s) __Pyx_CyFunction_GetClosure(%s);z%s = (%s) %s;z
 (wrapper)r  have_giltrace/* function exit code */)successr   gil_state_declaredc                    s<    |  s d s   d d< |jdd d | < d S d S )Nr  TFdeclare_gilstate)r  put_ensure_gil)	code_pathrO   )	gil_ownedgilstate_declr2   r3   
assure_gil  s   z=FuncDefNode.generate_function_definitions.<locals>.assure_gilr  z!__Pyx_pretend_to_initialize(&%s);r   r   z0{ PyObject *__pyx_type, *__pyx_value, *__pyx_tb;__Pyx_PyThreadState_declare__Pyx_PyThreadState_assignz5__Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);z5__Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}r'  zint %s = 0; /* StopIteration */
if (!%s) {z&Unraisable exception in function '%s'.c                    s^   d r d| d nd r|    dd< d d ks-J djd d f d S )Nr  r   rO   Fz$%s: error path %s != success path %s)put_release_ensured_gilr1   r  )r  r  r   r2   r3   $align_error_path_gil_to_success_path	  s   zWFuncDefNode.generate_function_definitions.<locals>.align_error_path_gil_to_success_pathc                   S   r   ry   r2   r2   r2   r2   r3   r  !	  s    	if (%s) {zOPyErr_SetString(PyExc_TypeError, "Memoryview return value is not initialized");__hash__z5if (unlikely(%s == -1) && !PyErr_Occurred()) %s = -2;)acquire_gil
return %s;#endif /*!(%s)*/)r   rE  r  is_closure_scopeis_passthroughr	   cur_scope_cnameouter_scope_cnamemangle_closure_cnamesr   r   r   r   rc   r  r  r  get_preprocessor_guardr   r   use_fast_gil_utility_coder3  r   load_cachedenter_cfunc_scope	new_labelreturn_from_error_cleanup_labelr  r  r  r  r1   r   rJ   needs_assignment_synthesispymethdef_requiredpy_funcgenerate_function_headerr  ri  r  putscope_classr9  r5  needs_outer_scopegenerate_argument_declarationsr{  
in_closurer  put_var_declarationr  is_cv_qualifiedra  cv_base_typer4  rH  rl  literal_coder  retval_cnamerF   generate_keyword_listr  buffer_entriesr  is_generatorput_trace_declarationscode_objectcalculate_result_codeput_trace_frame_initgetbuffer_checkgetbuffer_initr   ConstructorSlotget_slot_functiontypeptr_cnamer  empty_tupler  
put_increfr   r  r  is_cyfunction
self_cnamer  r   put_trace_call	can_tracegenerate_argument_parsing_codearg_entriescf_is_reassignedput_var_increfput_var_incref_memoryviewslicexdecref_cleanupput_var_xincrefr3  
buffer_auxbuflocal_nd_varr  put_init_varsgenerate_argument_type_testsput_acquire_arg_bufferneeds_refnannyr  r  r   put_init_to_py_none
label_usederror_labelput_gotoreturn_label	put_labelall_managed_tempsput_xdecrefrA   restore_exception_utility_codeput_release_buffer_coder(  put_init_entryerror_valuecaller_will_check_exceptionserror_without_exceptionerror_without_exception_cnameput_add_tracebackqualified_namer   put_unraisablegetbuffer_error_cleanupgetbuffer_normal_cleanupunlikelyerror_conditionneeds_refcountingrefcounting_needs_gilput_var_xdecref
put_decrefput_xgiveref
is_specialput_trace_returnput_declare_refcount_contextput_setup_refcount_contextput_finish_refcount_contextput_temp_declarationsexit_cfunc_scopegenerate_wrapper_functions)'r   r   rO   rE  r  r  is_getbuffer_slotis_releasebuffer_slotis_buffer_slotpreprocessor_guardr  r  r  cenvr   initr  tempvardecl_coder  used_buffer_entriesvar_decls_definitely_need_gilvar_decls_need_gilr  refnanny_decl_coderefnanny_setup_codetp_slotslot_func_cname
trace_namelhsvalr  r9  buffers_presentr(  err_valr  default_retvalr  condr2   )r  r  r  r   r3   r     s  


































	
























z)FuncDefNode.generate_function_definitionsc                 C   sh   |j jrt|jd n|j  s!|j js!|j js!t|jd|j   ||j|j |j}|j	r2|j	|_	|S )NzInvalid use of 'void'z Argument type '%s' is incomplete)
r9  r4  r   r1   rh  r2  rl  declare_argrc   r  )r   r   r  r   r2   r2   r3   declare_argument	  s   zFuncDefNode.declare_argumentc                 C   sx   |j  r4|jtdd |j j}d|jj }|	d|||j
|j|j jo)|j j||jf  d S t|jd d S )NArgTypeTestFunctionArguments.c((PyObject *)%s)z8if (unlikely(!__Pyx_ArgTypeTest(%s, %s, %d, %s, %s))) %szICannot test type of extern C class without type object name specification)r9  typeobj_is_availabler   r3  r   r  r  r   r  rJ   accept_noner  is_builtin_typerequire_exactr  r1   r   )r   r  rO   r  arg_coder2   r2   r3   generate_arg_type_test	  s"   


	z"FuncDefNode.generate_arg_type_testc                 C   sd   |j jrd|jj }n|jj}|d|  |dtdt|j|j||j	f  |d d S )Nz
%s.memviewz,if (unlikely(((PyObject *)%s) == Py_None)) {zKPyErr_Format(PyExc_TypeError, "Argument '%%.%ds' must not be None", %s); %s   r  )
r9  rl  r   r  rJ   r   rA   r  r  r1   )r   r  rO   r  r2   r2   r3   generate_arg_none_check	  s   
z#FuncDefNode.generate_arg_none_checkc                 C   r   ry   r2   r   r2   r2   r3   rP  	  r   z&FuncDefNode.generate_wrapper_functionsc                 C   s6   | | j | js| jD ]}|js|| qd S d S ry   )r  r1   r   rL   r  r   r   rO   r  r2   r2   r3   r   	  s   

z#FuncDefNode.generate_execution_codec              	   C   sJ   | j jd }z|jjjjd j}W ||fS  ttfy$   d }Y ||fS w )Nr   obj)r  r"  r9  r:  r  r   r   KeyError)r   	py_bufferobj_typer2   r2   r3   _get_py_buffer_info	  s   zFuncDefNode._get_py_buffer_infoc                 C   sB   |   \}}|j}|d|  |d |d |d d S )Nzif (unlikely(%s == NULL)) {zZPyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");z
return -1;r  )rx  r  rJ   )r   rO   rv  rV  viewr2   r2   r3   r  	  s   

zFuncDefNode.getbuffer_checkc                 C   sR   |   \}}|j}|r |jr |d| | |d| | d S |d|  d S )N%s->objz%s->obj = NULL;)rx  r  rH  r.  r  rJ   r   rO   rv  rw  ry  r2   r2   r3   r  	  s   
zFuncDefNode.getbuffer_initc                 C   sj   |   \}}|j}|r,|jr,|d|  |d| | |d| | |d d S |d|  d S )Nzif (%s->obj != NULL) {rz  r  zPy_CLEAR(%s->obj);rx  r  rH  rJ   r  r  r{  r2   r2   r3   r@  	  s   
z#FuncDefNode.getbuffer_error_cleanupc                 C   s`   |   \}}|j}|r,|jr.|d|  |d| | |d| | |d d S d S d S )Nzif (%s->obj == Py_None) {rz  r  r|  r{  r2   r2   r3   rA   
  s   
z$FuncDefNode.getbuffer_normal_cleanupc                 C   sh   | j jsd S | j j}t| jj|}|sd S |dkr%| j j	ds%d S |dv r0| j jj
r0d S | S )N__long____int__r  r  )r   rI  rc   r   get_slot_tabler  r   get_slot_by_method_namer  r7  r  preprocessor_guard_code)r   rc   slotr2   r2   r3   r  	
  s   z"FuncDefNode.get_preprocessor_guard)'rE   ri   rj   r  r  r  r  r  r  is_coroutineis_asyncgenis_generator_bodyis_async_defr  has_fused_argumentsstar_argstarstar_argr  r  r  r   r  r  r  r  r  r  r   rg  rp  rr  rP  r   rx  r  r  r@  rA  r  r2   r2   r2   r3   r  ;  sP       i
			r  c                       s   e Zd Zg dZddgZdZdZdZdZdZ	dZ
dZdZdd Zdd	 Zed
d Zdd Zdd Zdd Zd4ddZdd Zdd Zdd Zdd Zd5ddZd6d d!Zd"d# Zd$d% Zd&d' Zd(d) Zd*d+ Z fd,d-Z d.d/ Z!d0d1 Z"d2d3 Z#  Z$S )7r  )r:  r  r   ru  py_func_statru  r  FNc                 C      | j jS ry   )r   rc   r   r2   r2   r3   unqualified_name;
     zCFuncDefNode.unqualified_namec                 C   rB  ry   r  r   r2   r2   r3   r$  >
  rD  zCFuncDefNode.declared_namec                 C   s   | j r| j jS d S ry   )r  r  r   r2   r2   r3   r  A
  s   zCFuncDefNode.code_objectc                 C   sV  |j | _| jd u ri | _| j|jdi  | jd ur1| j|}|d u r0t| jj	d t
j}n| j|}d|jv oA|d | _t| jtr^| jj||d| jd u | j| jd\}}n| jj||d| jd u | jd\}}|jsyt| j	d || _| j|_| j}t|ds|j}t|dr|| _|j| _| jj}| jd	ks| jr|rt| jj	d
 |jdkr| jdkr|j r|j j!rt| j	d nt"| j	dd t#| j|jD ][\}}| $|| |j|_|j%|_%|j&|_&| '|j|j	| |jj(rd| _)|jj*r
d| j+v r
t"|j	dd |jj*s|jj,r-| jj-r t|j	d qd| j+v r-t"|j	dd q| '|j.| j	| |j%}	|j&}
| j/|_/| j|_|j0|	|| j	|
| j| j| jd u| j+| j| j1d
| _2|j.| _.| j.j3rs| jdkrst| j	d | j.j4r| j.5| j	d | jr|j6s| jst7| jdk s| jd jj8sd| _| 9| | :| d S )Nlocalsr{  r  r(   )r;  r  r<  )r;  r<  z*Suite attached to non-function declarationrL   r  zBFunction with optional arguments may not be declared public or apir  r  z/Only extern functions can throw C++ exceptions.Tinlinez$Buffer unpacking not optimized away.r   zUBuffer may not be acquired without the GIL. Consider using memoryview slices instead.)r  r<  re  definingr  r  r=  zFunction cannot return an arrayzused as a return valuer   F);r  is_c_class_methodr  r~   r   getdirective_returnsrZ  r   r1   r
   r   r:  r>  r7  rn  rB   r  rp  r   r<  r^  r9  r  r  hasattrrA  cfunc_declaratorrL   r  re  r  rq  r   r   zipr  rc   r  _validate_type_visibilityr6  r  r3  r  is_pythran_exprr  r  r  ro  inline_in_pxdr   r2  r\  check_nullary_constructorrk  rA   rH  declare_cpdef_wrapperr  )r   r   r:  r  typr  opt_arg_count
formal_argtype_argrc   r  r2   r2   r3   r   F
  s   







 
z!CFuncDefNode.analyse_declarationsc                 C   sp  | j sd S | jrt| jd | jj}| j|jd}| jr:ddlm	} t
| j|| jtdddg}|d j| ng }t| j| jj| jd d | j||dd		| _|j| j_| j| d
| jj_t| j| jgd| _tj| j_| jj| j_d
 | j_| jj_| j|j|< | jjs|jrtjr| jr| jj sJ | j| j_d S t!| j| jd| _t| j| j| j"gd| _"d S d S d S )Nz&static cpdef methods not yet supported)rk  r   rr  r  r*  	decoratorr   )	r1   rc   rL   r  r  r<   r   ru  r   Tr   )r  )#r  rn  r   r1   r   rc   call_self_noderk  r`  rr  DecoratorNoder   r  rm   DefNoderL   r<   r  r   r  r   r  r
   r   r9  as_variabler  r   is_final_cmethodr#   lookup_module_cpdefoverrideis_fused_specializedOverrideCheckNoder   )r   r   rc   py_func_bodyrr  ru  r2   r2   r3   r  
  sP   
	

z"CFuncDefNode.declare_cpdef_wrapperc                 C   sf   | j dkp| j}t|dd}|r'|r)|jr+|j dv s-|js/|js1t|d dS dS dS dS dS dS dS )zo
        Ensure that types used in cdef functions are public or api, or
        defined in a C header.
        r  r   N)r  r  z:Function declared public or api may not have private types)r<  re  r   rk  r  r   )r   r9  r1   r   public_or_apir   r2   r2   r3   r  
  s   
z&CFuncDefNode._validate_type_visibilityr   c                    s*  ddl m  jj}|r|d t|jj  }dd |D }|r1 jjjj	d}|}t
j}nCjjrUjjjj} jj|j	d}	||	_ jj|	jj	d}d}njjd jj}
 jj|
j	d}|
|_ jj|jj	d}| pyt
j} jj| fd	d|D |d
}tjtj|dS )Nr   r`  c                 S      g | ]}|j qS r2   r*  r   r  r2   r2   r3   r   
      z/CFuncDefNode.call_self_node.<locals>.<listcomp>r*  )rt  	attributeTr   c                    s   g | ]
} j j|d qS r*  )rr  r1   )r   nr`  r   r2   r3   r   
      )functionrL   wrapper_call)r1   r  r   )r   r`  r9  rL   rA   r  rr  r1   r   rc   r#   r  rn  r  r  AttributeNodeSimpleCallNodeReturnStatNoder
   r   )r   omit_optional_argsrk  rL   	arg_namescfunccall_arg_namesskip_dispatchclass_entry
class_noder8  r  c_callr2   r  r3   r  
  s6   zCFuncDefNode.call_self_nodec                 C   s0   | j jD ]}|jst|jd | || qd S )Nr,  )r9  rL   rc   r   r1   rg  r  r2   r2   r3   declare_arguments  s
   zCFuncDefNode.declare_argumentsc                 C   r  ry   )r9  r  r  r2   r2   r3   r    r  z!CFuncDefNode.need_gil_acquisitionc                 C   s^   | j }|j}|jr)|s+|jjrt| jd | jjD ]}|j jr(|j	s(t| jd qd S d S d S )Nz9Function with Python return type cannot be declared nogilz8Function declared nogil has Python locals or temporaries)
r9  r  r  r  rH  r   r1   r  r{  in_with_gil_block)r   r   r9  r  r   r2   r2   r3   r   
  s   
zCFuncDefNode.nogil_checkc                 C   sd   |j | j_ | jd ur| j|| _n| jd ur| j|| _n
| | | | | | j| _| S ry   )	r   r  r  rn   r  r  r  r  r  r   r2   r2   r3   rn     s   




z CFuncDefNode.analyse_expressionsc                 C   r  r  r2   r
  r2   r2   r3   r  #  r   z'CFuncDefNode.needs_assignment_synthesisr   c                 C   s  | j }g }| j}|jd t|j|j  D ]}	|	 }
||	j}|js(d|
 }
|	|
 q|rJ| j
rJtjtj}| jrC|	| n|	d|  |jrY|rY|	|jtj |jra|	d |sfdg}|d u rn| jj}||d|}| jjdkrd|vrd}nd}d }|| jj}| jj||d	}| jp| jj}| jr|r|jjd
  | j | | j |r|jjd
  d|||f  | d|||f  d S )NzCYTHON_UNUSED %sz...voidr   privatez::zstatic r   )dll_linkagemodule_declarationsz%s%s%s; /* proto*/z%s%s%s {)!r  r9  rL   rA   r  r5  r  rc   cf_usedrt  r  r
   r  r	   skip_dispatch_cnamer  r  optional_args_cnamer  r   
func_cnamefunction_header_coder   r<  build_function_modifiersfunc_modifiersr  r  r   r  r   partsrJ   )r   rO   r  with_opt_argswith_dispatchr  r  	arg_declsr9  r  arg_declr   dispatch_argentitystorage_classr  r  headerneeds_protor2   r2   r3   r  &  sR   


z%CFuncDefNode.generate_function_headerc                 C   sZ   | j }| jD ]$}|jr*||j}| js|jr*||}|d|j	
|j|f  qd S r  )r  rL   r(  r  rc   r  r  r  rJ   r9  r5  r  )r   r   rO   r  r  r   r   r2   r2   r3   r  S  s   

z+CFuncDefNode.generate_argument_declarationsc                 C   r   ry   r2   r   r2   r2   r3   r  ]  r   z"CFuncDefNode.generate_keyword_listc           
   	      s
  d}d}| j }| jjrndtj  | jD ]F  jr\| j	}| j
s'|jrXdtjtj|f   j}t|dsC|j}t|dr;d jtj| j|j	f  |d7 }|d7 }qt|D ]}d qad  fdd	}	| jD ]
 |	| j	 qxd S )
Nr   r  zif (%s->%sn > %s) {rc   z%s = %s->%s;r   r  c                    s`   | j r, js.d| j| jf  | jjr | j| jd d S |  	|  d S d S d S )Nr  T)
r	  r(  rJ   r  original_cnamer9  rl  generate_incref_memoryviewslicer$  put_var_giverefr   r  rO   r2   r3   put_into_closurez  s   
zECFuncDefNode.generate_argument_parsing_code.<locals>.put_into_closure)r  r9  r  rJ   r	   r  rL   r(  r  rc   r  r  r  r  r  rA  r  opt_arg_cnameranger7  )
r   r   rO   r  r  r  r   r  rV  r  r2   r  r3   r!  `  sB   




z+CFuncDefNode.generate_argument_parsing_codec                 C   r   ry   r2   r   r2   r2   r3   !generate_argument_conversion_code  r   z.CFuncDefNode.generate_argument_conversion_codec                 C   s@   | j jD ]}|jr| || q|j jr|js| || qd S ry   )r9  rL   needs_type_testrp  rH  rl  rr  rs  r2   r2   r3   r+    s   z)CFuncDefNode.generate_argument_type_testsc                    sL   |j jd r|| j |d tt| | | jr$| j| d S d S )Nr  r   )	r   r   r  r1   rJ   r`   r  r   r  r   rh   r2   r3   r     s   
z$CFuncDefNode.generate_execution_codec                 C   s   | j jrdS | jjjS )N0)r  rH  r   r9  rq  r   r2   r2   r3   r9    s   
zCFuncDefNode.error_valuec                 C   
   | j jjS ry   )r   r9  r  r   r2   r2   r3   r:    rD  z)CFuncDefNode.caller_will_check_exceptionsc                 C   s$  d}| j }|j}|jd ur|d7 }|j}d| j jtj|f |_|  | j|d|jj|jj	|jd | j
js;|d | jj}dd |d t|| jj	  D }|jjr[|tj n|jrc|d |jj	rn|tj n|j	rv|d	 |d
| j jd|f  |d |jd usd S d S )Nr   r   z%s%swrap_%s)r  r  r  zreturn c                 S   r  r2   )r  r  r2   r2   r3   r     r  z;CFuncDefNode.generate_wrapper_functions.<locals>.<listcomp>r  NULL%s(%s);r   r  )r   r9  
prev_entryr  r	   r  rJ   r  r  r  r  r4  r  rL   rA   rt  r  r  r   )r   rO   kr   r  rL   arglistr2   r2   r3   rP    s:   

"


z'CFuncDefNode.generate_wrapper_functions)r   r   ry   )r   r   N)%rE   ri   rj   r   r   r  ru  r  r  r  r  r  r  r  r$  r  r  r   r  r  r  r  r  r   rn   r  r  r  r  r!  r  r+  r   r9  r:  rP  rk   r2   r2   rh   r3   r  
  sD    
e+


-
&	r  c                   @   s    e Zd Zg ZdZdZdd ZdS )PyArgDeclNodeFc                 C   r  ry   )r   r   r
  r2   r2   r3   r     r  z+PyArgDeclNode.generate_function_definitionsN)rE   ri   rj   r   rz  r  r   r2   r2   r2   r3   r    s
    r  c                   @   s   e Zd ZdgZdS )r  r  N)rE   ri   rj   r   r2   r2   r2   r3   r    s    
r  c                   @   s"  e Zd Zg dZddg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	d
 Z		d3ddZdd Zdd Zdd Zdd Zdd Z dd Z!dd Z"dd Z#dd Z$dd  Z%d4d!d"Z&d#d$ Z'd%d& Z(d'd( Z)d5d)d*Z*d+d, Z+d-d. Z,d/d0 Z-d1d2 Z.dS )6r  )rL   r  r  r   ru  r  ru  r  FNr  r   Tc                 K   s   t j| |fi | d } } }}| jD ]}|jr|d7 }|jr,|d7 }|js,|d7 }|js3|d7 }q|| _|| _|| _|| _	d S r.   )
r  r   rL   r  r  r(  num_posonly_argsnum_kwonly_argsnum_required_kw_argsnum_required_args)r   r1   rM   pr  rkrr  r2   r2   r3   r     s    

zDefNode.__init__c
                 C   s   | j r
t| j jd | jrt| jjd |pd\}
}|p|	}|d u rXg }| jD ]}|j|dd\}}|tj|j	d |j
t|jd q'tjt|dd |||	|d}t| j|d	}nR|d u r_|j}|j}t| jt|jkso|jr{t| jd
 t|jd tt| j|jD ]%\}\}}|j|d|dko|jd\}}|d u s|tju r|j|_||_q|
d u r|jd urddlm} || j|j|jd}
t| jt| j| j	d d| jd|j|
||j|jd	}t| j|pg t | j|jd	|| j!| j"|j#||j|jddt$|di |dS )Nz'cdef function cannot have star argumentz+cdef function cannot have starstar argumentr  r   r  )rc   r  r  r9  r1   F)r  rL   r  rq  r  r  r  r  r  zwrong number of argumentszprevious declaration herer   ry  r  r  rG  )rA  rL   r  r  rq  r  r  r  r  r  )r  r:  r  r   r<   r  r9  r  r  r<  re  r  r  )%r  r   r1   r  rL   r>  rt  r
   r  rc   r  r   r  r  r  r9  rA   r  r  r  r  r  rq  r`  r  r  rp  r'  r  r  r  r  r  r   r<   r  r   )r   r  r  r  returns
except_valr  r  r  r  rq  r  
cfunc_argsr  r  r9  
cfunc_typer  r  r  r  r2   r2   r3   as_cfunction  s   


	
zDefNode.as_cfunctionc                 C   s   | j rdS | js| jrdS dS )zDetermines if the function's signature is compatible with a
        cdef function.  This can be used before calling
        .as_cfunction() to see if that will be successful.
        FT)r  r  r  r   r2   r2   r3   is_cdef_func_compatiblea  s
   zDefNode.is_cdef_func_compatiblec              	   C   s  | j r#| j D ]}|j}|jr"|  j|jdkO  _|  j|jdkO  _q| jr.|dr.d| _| jr9|dr9d| _|js?|jr| jdkrK|jrKd| _n9| jdkrZ|jrZt	| j
d n*| jtv r| jsd| _dd	lm} | j pog | _ | j d
t| j
|| j
tddd | | | jdkr| | n| | | | | jj | _| jtu r| jr|jd r| jjs| j|\}}|r|jr|| _| | t| j
| | jj| j | j!| j"| jd| _#| j#$| d S )Nclassmethodr  Fra   Tr,   z7'__init_subclass__' is not supported by extension classr   r  r   r*  r  <lambda>r  )r  rc   rL   r  r  r  )%ru  r  r   is_classmethodrc   is_staticmethodr7  r  r  r   r1   IMPLICIT_CLASSMETHODSr`  rr  insertr  r   analyse_argument_typesdeclare_lambda_functiondeclare_pyfunctionanalyse_signaturer   	signaturer  r   r  r   rI  r  rH  r  DefNodeWrapperrL   r  r  
py_wrapperr   )r   r   r  rU   rr  rV  r  r2   r2   r3   r   l  sZ   







zDefNode.analyse_declarationsc                 C   s  |j di | _|j d }|j}d |_| jD ]}t|dr d }n%|j|}t|r5|j	r5t
||jg}|j||\}}|j|_||_| || |rV|jrVt| jd |j |_d |_d|_d|_d|_|jjst|jjst|jjr|jr{d|_nE|jrd|_n>|jjs|jj s|jjs|jjr|j!r|j!j"d u rd|_n!||_nd|_n|jj#sd|_|jrt|jd	 |jrt|jd
 |jj$rd| _%q||_t|rdd t&| jD | _'d S g | _'d S )Nr  allow_none_for_extension_argsrc   z9Python function argument cannot have C name specificationr   r   TFz.Only Python type arguments can have 'not None'z-Only Python type arguments can have 'or None'c                 S   s   g | ]
\}}|j jr|qS r2   )r9  is_numpy_buffer)r   r  ar2   r2   r3   r     r  z2DefNode.analyse_argument_types.<locals>.<listcomp>)(r   r  r  r7  rL   r  r:  r>  r%   r  r
   r^  
org_bufferr  rc   r9  r  r  r   r1   as_argument_typehdr_typer  r  r  rH  r3  rl  r  rl  r  is_extension_typerm  r(  r  r  r6  r  r  np_args_idx)r   r   r  f2sr  r  r:  r9  r2   r2   r3   r    sh   




zDefNode.analyse_argument_typesc           	      C   s  | j jr| jrt| jd t| jdko| jp| j | j _	nr| js| js|j
d r3tdd | jD r| j jtju rbt| jdkrGtj| j _nIt| jdkra| jd jd u ra| jd jsatj| j _n.| j jtju rt| jdkrvtj| j _nt| jdkr| jd jd u r| jd jstj| j _| j j}| }| }|tju r|dkrt| jdkr| jrtj }| j _d| _d }}| jr|jrd }}d| _t| | j _}d	|_d|_d|_| js| jr| jr|jr| j j!d d = t"t#|t| jD ]X}| j| }d|_$||krd|_%|&|r2| js2| jr$d|_'t(j) |_*|_+n
d|_&|j, |_*|_+d|_-q|.||_*|j+/|j*sQ|j*j0rN|j+j0rNd|_1qd|_-q|t| jkr`| 2  d S |t| jk r|jsp| 2  | jD ]}|j$r|j+j3s|j+j4rd|_1qs|5 }|rtj6|v r| j js| jrd}| jD ]}|j$r|js|j&s|j'sd
}qnd
}|s|7  }| j _d S d S d S d S d S )Nz8special functions of cdef classes cannot have decoratorsr   always_allow_keywordsc                 S   r  r2   r  r  r2   r2   r3   r     r  z-DefNode.analyse_signature.<locals>.<listcomp>r   r(   Tr  F)8r   rI  ru  r   r1   rA   rL   r  r  trivial_signaturer   r  r  r   pyfunction_signaturepyfunction_noargsr(  r  pyfunction_oneargpymethod_signature	unaryfuncibinaryfuncmax_num_fixed_argsmin_num_fixed_argsself_in_starargr  r  r   fixed_arg_formathas_generic_argsr  r  decorator_indirectionr   r  minr  r  rz  r  r   	type_typer  r9  r  r  fixed_arg_typer  rH  r  bad_signaturer  rm  method_flagsmethod_varargswith_fastcall)	r   r   signfixed
min_nfixedr  r  mfuses_args_tupler2   r2   r3   r    s   "





zDefNode.analyse_signaturec                 C   s   | j j}d|  }|jr|d7 }n|jr|d|  7 }| j}|dr-|dr-d}nd}t	| j
d|| jt| j|f  d S )Nz%dz or morez to %d__zSpecial methodMethodz>%s %s has wrong number of arguments (%d declared, %s expected))r   r  r  r  optional_object_arg_countr  rc   
startswithendswithr   r1   rA   rL   )r   r'  expected_strrc   descr2   r2   r3   r#  J  s   
zDefNode.bad_signaturec                 C   s  | j }||}|r(|jr|jjst| jd |jjr(|j	s(| j
s(t| jdd |j|| j| j
 d}|| _||j}ttj| | | j_tjrt| j| j|_ttj| | |_|jr|j tjv sr|jrr|j dv rw|jd rwd |_d S ttj| | |_d S d S d |_d S )Nz:Only final types can have final Python (def/cpdef) methodsz'Overriding cdef method with def method.   )allow_redefine__getattr__fast_getattr) rc   r7  r  r  is_final_typer   r1   r9  r^  is_builtin_cmethodr   r   r  r   next_idscope_prefixr    r	   pyfunc_prefixpyfunc_cnamer#   rr  r=   r<   funcdoc_prefix	doc_cnamerI  r   	invisibler   wrapperbase_cnamewrapperbase_prefix)r   r   rc   r   prefixr2   r2   r3   r  Y  s*   


zDefNode.declare_pyfunctionc                 C   s*   | | j| j}d |_|| _|j| j_d S ry   )r  lambda_namer1   r<   r   r  r<  )r   r   r   r2   r2   r3   r  r  s   zDefNode.declare_lambda_functionc                 C   s   | j D ]6}|jst|jd |jr%||j|j|j|_|jjr$d|j_	n| 
|||_d|j_d|j_|j|j_q| || j | || j d S )Nr,  r  r   )rL   rc   r   r1   r  r  r9  r   rH  rV  rg  r  r  rz  declare_python_argr  r  r  r2   r2   r3   r  x  s   
zDefNode.declare_argumentsc                 C   sV   |r)|j d dkrtj}nt}||j||j}d|_d|_d|_	d|_
||_d S d S )Ninfer_typesFr   r  )r   r
   unspecified_typer   r  rc   r1   r  r  rV  r&  r   )r   r   r  r9  r   r2   r2   r3   rD    s   
zDefNode.declare_python_argc                 C   sb   |j | j_ | | | | | |s)| jr)| jd d d D ]	}|j||_q| j	| | S )Nr   )
r   r  r  r  r  ru  r  rn   r  prepare_argument_coercion)r   r   r  r2   r2   r3   rn     s   


zDefNode.analyse_expressionsc                 C   sv   | j rdS | js| jjrdS | jrdS | jjrdS | jjrdS |js%|jr5|d u r/| j	j
d S |jj
d S |jp:|jS )NTFbinding)r  specialized_cpdefsr   r  no_assignment_synthesisrI  is_anonymousrk  r  r  r   r   r  r  r
  r2   r2   r3   r    s   z"DefNode.needs_assignment_synthesisc                 C   r  ry   )r   r  r9  r   r2   r2   r3   r9    rD  zDefNode.error_valuec                 C   r  ry   )r   r  r  r   r2   r2   r3   r:    rD  z$DefNode.caller_will_check_exceptionsc                 C   sJ   | j r| j | | | jr| jj| j_| j|| t| || d S ry   )defaults_getterr   r   py_wrapper_requiredr   r  r  r  r
  r2   r2   r3   r     s   z%DefNode.generate_function_definitionsc                 C   s  |r| j r| j||d d S g }| jjjr'dtj }| js"d| }|	| dd }| j
D ]	}|	|| q.| jrC|	|| j | jrN|	|| j |rVd|}nd}| j| jj}	|jd }
|  }|rp|
| |
d	|	|f  |r|
d
 |d|	|f  d S )NTPyObject *%sCYTHON_UNUSED c                 S   s8   | j }|jr
|j}n|j}|j|}|jsd| }|S )NrO  )r   r	  r  r  r9  r5  r  )r  r   r  declr2   r2   r3   arg_decl_code  s   z7DefNode.generate_function_header.<locals>.arg_decl_coder   r  declszstatic %s(%s); /* proto */#endifzstatic %s(%s) {)rM  r  r  r   r  has_dummy_argr	   r  r  rt  rL   r  r  r   r  r5  r<  r   r  rJ   )r   rO   r  r  arg_code_listself_argrQ  r  ro  dc
decls_coderT  r2   r2   r3   r    sB   







z DefNode.generate_function_headerc                 C   r   ry   r2   r
  r2   r2   r3   r    r   z&DefNode.generate_argument_declarationsc                 C   r   ry   r2   r   r2   r2   r3   r    r   zDefNode.generate_keyword_listc                    sF    fdd}| j D ]}||j q	| j| jfD ]	}|r ||j qd S )Nc                    s   | j rZ| jjr%| jjd usJ  jtdd  d	| j
| j n d| j
| jf  | jjr?| j | j
d d S | jrN |   |  d S  |   |  d S d S )NIncludeStringHzStringTools.czmemcpy({0}, {1}, sizeof({0}));r  T)r	  r9  r2  rl  r   r3  r   r  rJ   formatr  r  rl  r  r&  r'  put_var_xgiverefr$  r  r  r  r2   r3   r    s   

z@DefNode.generate_argument_parsing_code.<locals>.put_into_closure)rL   r   r  r  )r   r   rO   r  r  r2   r  r3   r!    s   

z&DefNode.generate_argument_parsing_codec                 C   r   ry   r2   r   r2   r2   r3   r+    r   z$DefNode.generate_argument_type_tests)	NNTNNFNFFry   r   )/rE   ri   rj   r   r   r  r  rC  reqd_kw_flags_cnamer   rJ  ru  r  r   r  r  py_cfunc_noderequires_classobjdefaults_structr<   fused_py_funcrI  r  rM  r  rL  r   r  r  r   r  r  r#  r  r  r  rD  rn   r  r9  r:  r   r  r  r  r!  r+  r2   r2   r2   r3   r    s^    
E7@g

.r  c                   @   s   e Zd ZdZdZdZdd Zdd Zdd Zd	d
 Z	dd Z
dd Zdd Zd8ddZdd Zdd Zdd Zdd Zdd Zdd Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd*d+ Zd,d- Zd.d/ Zd0d1 Zd2d3 Zd4d5 Zd6d7 ZdS )9r  NFc                 O   sT   t j| g|R i | | jj| _| jj| _| jj| _| jj| _| jj| _d | _d S ry   )	r  r   r  r  r  r  r  r  r  )r   rL   rq   r2   r2   r3   r   #  s   





zDefNodeWrapper.__init__c                 C   sX   | j j}| j}||j}ttj| | |_ttj	| | |_
|j| _| j j| _d S ry   )r  r   rc   r9  r:  r    r	   pywrap_prefixr  pymethdef_prefixpymethdef_cnamer  r  )r   r   target_entryrc   rB  r2   r2   r3   r   ,  s   z#DefNodeWrapper.analyse_declarationsc                 C   s   | j D ]}|jjs|j|s	 q|jr|jjs|j|s	 q| jr@| jjjsB| jj}d|_	|j
D ]}|js?|jjr?d|j_q2d S d S d S )Nr   T)rL   r9  rH  create_from_py_utility_coder  rp  r  r   r  r&  cf_assignmentsr  r`  r   cf_maybe_null)r   r   r  r   assr2   r2   r3   rG  7  s$   

z(DefNodeWrapper.prepare_argument_coercionc                 C   s:   t | j}|dks|dkr| jd js| jd jrdS dS r.   )rA   rL   rz  r  )r   argcountr2   r2   r3   signature_has_nongeneric_argsM  s   

z,DefNodeWrapper.signature_has_nongeneric_argsc                 C   r  ry   )r  r  r   r2   r2   r3   signature_has_generic_argsU  r  z)DefNodeWrapper.signature_has_generic_argsc                 C   s  g }| j jr|tj | jD ]<}|jjr)|j	t
dd |d|jj  q|jrD|jjsD|jjsD|jjsD||j|jj q||jj q| jrW|| jjj | jrb|| jjj d|}| jjss|dtj  |d| jjj|f  d S )NMoveIfSupportedCppSupport.cpp__PYX_STD_MOVE_IF_SUPPORTED(%s)r   z%s = r  )r  rT  rt  r	   r  rL   r9  r\  r   r3  r   r  r   r  r  rl  r  r  r  r  r  r   r  r4  r  r  rJ   r  r<  )r   rO   rL   r  r2   r2   r3   r  X  s4   



z%DefNodeWrapper.generate_function_bodyc                 C   sv  | j j}|| j |d |d | j  }|r || || | |_| j 	||p4| j j
}| || | || | }| jjrLd}nd}| jjs`|d| jtj|f  |  |td| j  | ||| | | | | ||j || j |d |d |j|jv r||j  |!|j |j" D ]
\}}	|#||	 q| $ }
|
d ur|dtj|
f  |!|j  |j%D ]}|j&r|j'r|(| q|)| qt*|j%}| j+D ]}|j,js|j-|vr|j-j'r|(|j- q|)|j- q| .| |/  | jjs$|dtj  |d	 |0  |r9|d
|  d S d S )Nr   z/* Python wrapper */z = 0r  z%s (wrapper)r  r  r  r  r  )1r  r  r  r1   rJ   r  r  r  r   r  r  r  r  rF   r  rH  r4  r5  r	   r  rK  rL  r   rc   r!  r+  r  rN  r  r0  labels_usedr1  r2  r3  r4  r5  r9  r{  r  r&  rF  put_var_decrefr   rL   r9  r   %generate_argument_values_cleanup_coderM  rO  )r   r   rO   r  rT  r  rW  retval_initr  r9  rc  r   var_entries_setr  r2   r2   r3   r   s  s~   

















z,DefNodeWrapper.generate_function_definitionsr   c                 C   sx  g }| j }|js| jrdtj }|jsd| }|| | jD ]}|js=|js*|j	r3|d|j
  q||j|j
 q| jj}|jsR| tjgkrR|d |jrydtjtjf }	|jrtdtjtjtjf }
|d|
|	f  n||	 |jrtt| j| D ]	}|d|  qd|}d	}|jd
v r|jjrd}d}| j|j }d|||f }|!d|  |r| jj"r| jj"j#||dd d S t$j%r|j&r| jj"s|jj's|jr|j(r|j&}|j)r|* }|jr|jd
v s|!d|j+|, f  |jr|!d |!d|j(  |!d |s!| jj"r3|-d|j.  |j/| jjddd |!d|  d S )NrN  rO  zCYTHON_UNUSED PyObject *unusedzPyObject *%s, PyObject *%sz0PyObject *const *%s, Py_ssize_t %s, PyObject *%sz-
#if CYTHON_METH_FASTCALL
%s
#else
%s
#endif
z%CYTHON_UNUSED PyObject *unused_arg_%sr   r   r  Fz%sstatic %s(%s)z%s; /*proto*/T)r  zPyDoc_STRVAR(%s, %s); #if CYTHON_UPDATE_DESCRIPTOR_DOCzstruct wrapperbase %s;rS  zstatic PyMethodDef %s = r  )
allow_skipz%s {)0r  rT  r  r	   r  rt  rL   r  rz  r  r  r  r5  r  r   rI  r$  r   method_noargsr  
args_cname
kwds_cnameuse_fastcallnargs_cnamer  rA   r  r   rc   r  r  r  r  rJ   ra  r  r#   rr  r<   is_property_scoper@  
is_unicodeas_utf8_stringr>  r  r  rd  put_pymethoddef)r   rO   r  r  rU  r'  ro  r  r   varargs_argsfastcall_argsr  r*  rW  r  docstrr2   r2   r3   r    s   








z'DefNodeWrapper.generate_function_headerc                 C   s   | j D ]}|jr|jr|d|j  q||j q|jD ]
}|jr(|| q| 	 rKdt
j }| jjrF|d || |d n|| |dt
j  d S )NzPyObject *%s = 0;zCYTHON_UNUSED Py_ssize_t %s;#if !CYTHON_METH_FASTCALLrS  z"CYTHON_UNUSED PyObject *const *%s;)rL   r  r  rJ   r  r
  r   r{  r  rl  r	   r{  r  rz  kwvalues_cname)r   r   rO   r  r   
nargs_coder2   r2   r3   r    s$   






z-DefNodeWrapper.generate_argument_declarationsc           
   	   C   sV  |  }|j}|d}| jdk}| jd up| jd up|}| jD ]}	|	jjs-|	j	|s-	 q | 
 rs| jjr;|d |d |dtjtjf  |d |dtjtj|dtj |  f  |d	 | jjrs|d	 |jtd
d |dtj| jjtjtjf  | 
 s|rt| jd | | n|  s| | n| | j|| d| _||_| |r| |s|!| |"| | #| |r| $| j| | jr| jj%j&r|'| jj% n|(| jj% | jD ]}	|	jjs|	jj)r|*|	j% q|+| j,j%j- |.  |d|    | |r)|"| d S d S )Nargument_unpacking_doner   r  z#if CYTHON_ASSUME_SAFE_MACROSz%s = PyTuple_GET_SIZE(%s);#elsez)%s = PyTuple_Size(%s); if (%s) return %s;z%s < 0rS  fastcallri  z%s = __Pyx_KwValues_%s(%s, %s);z.This method cannot have * or keyword argumentsTr  )/new_error_labelr0  r  r  r  r  rL   r9  rH  rf  rl  r  rz  rJ   r	   r{  rx  rB  r9  r   r3  r   r  r  fastvarr   r1   r  rk  generate_stararg_copy_code'generate_tuple_and_keyword_parsing_codeneeds_values_cleanupr/  r1  r3  rr  generate_arg_decrefr   r&  put_var_xdecref_clearput_var_decref_clearrD  rF  r=  r  r>  rM  )
r   r   rO   	decl_codeold_error_labelour_error_label	end_labelhas_kwonly_argshas_star_or_kw_argsr  r2   r2   r3   r!  -  s   















z-DefNodeWrapper.generate_argument_parsing_codec                 C      |r
| |j d S d S ry   )r  r   r   r  rO   r2   r2   r3   generate_arg_xdecref}     z#DefNodeWrapper.generate_arg_xdecrefc                 C   r  ry   )r  r   r  r2   r2   r3   r    r  z"DefNodeWrapper.generate_arg_decrefc              	   C   s  | j s*|jtdd |dtj  |d| j	
 tj|  f  |d | jrA| j s5| jjjs;dtj }ndtj }ndtj| jjtjf }|jtd	d |d
|tj| j	
 t| j|  f  | jr| jjjr|d|  |d| jjj| jjtjtjf  |d| jjj|  f  || jjjt |d |d| jjjf  |d| jjj|  f  || jj d| jj_|d | jrb| jjsb| jjrJ |d| j jjtj|| j jj| jf  || j j |tj t |!tj t |d| j jjtj f  |j"j#t$j%dd}|d||tj|f  |dtj&|f  |dt |!dt |d| j jj|f  |d |j"'| d| j j_d S | j r| jjrmJ |tj&t |d| j jjtj&f  d| j j_d S d S )NRaiseArgTupleInvalidri  zif (unlikely(%s > 0)) {z7__Pyx_RaiseArgtupleInvalid(%s, 1, 0, 0, %s); return %s;r  zunlikely(%s)%sz&unlikely(%s) && __Pyx_NumKwargs_%s(%s)KeywordStringCheckzFif (%s && unlikely(!__Pyx_CheckKeywordStrings(%s, %s, %d))) return %s;r  z#%s = __Pyx_KwargsAsDict_%s(%s, %s);zif (unlikely(!%s)) return %s;r  z%s = PyDict_New();Fz%s = PyTuple_New(%s + 1); %szPyTuple_SET_ITEM(%s, 0, %s);r  zfor (%s=0; %s < %s; %s++) {z*PyObject* item = PyTuple_GET_ITEM(%s, %s);r   z!PyTuple_SET_ITEM(%s, %s+1, item);r   r  )(r  r   r3  r   r  rJ   r	   r{  r  rc   r  r9  r  r   r  ry  r  r  boolr  r  r  r   put_var_gotrefr&  r  r  r  rz  r  r1   r  r  r  r  r  r
   c_py_ssize_t_typerx  r  )r   rO   kwarg_checkr  r2   r2   r3   r    s   








z)DefNodeWrapper.generate_stararg_copy_codec                    sb   j tdd | j } d}g }g }g }d}	|D ]8}
|
jrV|
jr;|
j	s:|
j
s:|
jr5||
 n||
 n|
jrD||
 n|
j	sO|
j
sO||
 |
jrV|	d7 }	q|| }| j| j }t|dkru|d j	sq|d j
ru|d8 }t|}| j o||k}t|}| js| jr| |   d t|t| }dd |D }d	 fd
d|D dg } dtj|f  | | | |p| j}|rtj}ndtj| jjtjf }| jdkrd| } d|  |r| ||||||  n) j tdd  dtjtjtj| jr| jj j!nddd| "| j#f  | jr+|dks0||krN||kr<| js<d}nd} dtj$||f   %| | jr||krj| jsj dtj$|f   %|  d t&|D ]/\}}
|
js '|
j j} j tdd  (d| j|f    "| j#  nqsn d ||krt&|D ]\}}
 d|| jjtj)|f  qn dtj$  | jr؈ d t*t&|d d d }|D ]1\}}
||d kr||d d kr d  (d|d    d|| jjtj)|f  q|dkr& d  (d   d! | jrK|rJt+|d ddD ]
} d"|  q: %| n
 (d#  %|  d$  d$ t&|D ]\}}
| ,|
d%|   qc d$  -|r d&} %|  .|  j td'd  d(||||tj$ "| j#f   .| d S d S ))Nr  ri  argtuple_errorr   r   {c                 S   s   g | ]}|j s|qS r2   r  r  r2   r2   r3   r     r   zJDefNodeWrapper.generate_tuple_and_keyword_parsing_code.<locals>.<listcomp>,c                    s   g | ]}d   |jj qS &%s)intern_identifierr   rc   r  r  r2   r3   r     s    r  zPyObject **%s[] = {%s};z %s && __Pyx_NumKwargs_%s(%s) > 0z
likely(%s)r  ParseKeywordszKif (likely(__Pyx_ParseOptionalKeywords(%s, %s, %s, %s, %s, %s, %s) < 0)) %srj  z!=<z } else if (unlikely(%s %s %d)) {z} else if (unlikely(%s > %d)) {r  RaiseKeywordRequiredz&__Pyx_RaiseKeywordRequired("%s", %s); "values[%d] = __Pyx_Arg_%s(%s, %d);switch (%s) {default:r   CYTHON_FALLTHROUGH;
case %2d: 	case  0: break;	case %2d:	default: r  z
values[%d]skipr  z2__Pyx_RaiseArgtupleInvalid(%s, %d, %d, %d, %s); %s)/r   r3  r   r  rc   r  r  r  r(  rz  r  r  rt  r  r  r  rA   r  r  r  generate_stararg_init_coderJ   tupler   r	   pykwdlist_cname#generate_argument_values_setup_codery  r  r  generate_keyword_unpacking_coder  r   r  r  r1   r{  r1  r  r  r  rx  r   r  generate_arg_assignmentr/  r3  )r   rL   rO   r  self_name_csafeargtuple_error_labelr9  required_kw_only_argsoptional_kw_only_argsnum_pos_only_argsr  kw_only_argsmin_positional_argsmax_positional_argshas_fixed_positional_counthas_kw_only_argsall_argsnon_posonly_argsnon_pos_args_idaccept_kwd_argskw_unpacking_conditioncomparer  pystring_cnamereversed_argsskip_error_handlingr2   r  r3   r    s2  




 




























z6DefNodeWrapper.generate_tuple_and_keyword_parsing_codec                 C   s   |j jr|jrt|j tj|}|j}|d|j|f  d S |j j	rg|j
r-|d|  ||j ||jj|j| |j
re|d |d|jj||f  |j jr^|j|jdd |d d S d S t|jd|j   d S )Nr  r  r  Tr  r  2Cannot convert Python object argument to type '%s')r9  rH  r  r
   typecastr   r   rJ   r  from_py_functionr(  from_py_call_coder1   r  rl  r%  r   )r   r  r   rO   r   r2   r2   r3   r    s,   

	z&DefNodeWrapper.generate_arg_assignmentc                 C   s&  | j r!d| j j_|d| j jj| j jj|  f  || j j | jrd| jj_|dkrI| jj	r3J |
tjt |d| jjjtjf  d S |d| jjj| jjtj|tjf  |d| jjj| jjj  | j rv|| j j |  |d|    |d || jj d S d S )Nr   z0%s = PyDict_New(); if (unlikely(!%s)) return %s;r  z$%s = __Pyx_ArgsSlice_%s(%s, %d, %s);r  r  r  )r  r   r&  rJ   r  r9  r  r  r  rz  r  r	   rx  r   r  r{  r9  nullcheck_stringr  rM  )r   r  rO   r2   r2   r3   r    s8   



z)DefNodeWrapper.generate_stararg_init_codec              	   C   s   t |}|d|dd| f  | jjr'|d| jjtj| jjtjf  t|D ] \}}|j	rK|j
jrK||}|d|| jj|j
|f  q+d S )NzPyObject* values[%d] = {%s};r  r  z+%s *%s = __Pyx_CyFunction_Defaults(%s, %s);z%values[%d] = __Pyx_Arg_NewRef_%s(%s);)rA   rJ   r   r  r`  r	   dynamic_args_cnamer  r  r(  r9  rH  r  r  r  as_pyobject)r   rL   rO   r  max_argsr  r  r  r2   r2   r3   r    s"   


z2DefNodeWrapper.generate_argument_values_setup_codec                 C   sj   | j sd S tj}|d |d|  |d|||f  |d| jj|f  |d |d d S )Nr  zPy_ssize_t %s;zGfor (%s=0; %s < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++%s) {z!__Pyx_Arg_XDECREF_%s(values[%s]);r  )r  r	   quick_temp_cnamerJ   r  r  )r   rO   loop_varr2   r2   r3   rr    s   

z4DefNodeWrapper.generate_argument_values_cleanup_codec                 C   sX  d }}	t |D ]\}
}|jr|	d7 }	|js|d7 }q|d |dtj  | jr0|d t|d |d dD ]}
|d|
d   |d|
| j	j
tj|
f  |d	 q:|dkr|d|  t|d ddD ]}
|d|
| j	j
tj|
f  ql|d
 t|d ddD ]}
|d|
d   |d	 q|d |dkr|d
 n|| | js|d || |d | j }|d| j	j
tjf  | js|dkr!d}t |D ]	\}
}|js|
}q||k r|d }||	kr|dtj  t ||	|d  |	D ]\}
}||	kr8|
|kr8|
|	kr"|d	 | jr1|
|kr1|d n|d|
  ||jj}|jrz|jrIq	|d |d| j	j
tjtj|f  |d|
| j	j
f  |d|| j  |d q	|d|
| j	j
tjtj|f  |d| j	j
|
f  |d |d |d|| j  |
|k r|
dkr|d || q	|d |jtdd |d|||||
f  ||| j |d q	|jr|d |jtdd |d||f  ||| j |d q	||	kr!|d |r*| || |d |	dkrB|d tj|	tj|	f  n|dkrO|d!tj  |dkrWd"}n| jrk|d#||	 ||	 f  d$}nd%}|	t|k ryd&|	 }nd'}|jtd(d |d)tjtjtj| jr| jjjpd"||||| jf  |d d S )*Nr   r   zPy_ssize_t kw_args;r  r  r   r  r  r  r  r(   r  r  r  z!kw_args = __Pyx_NumKwargs_%s(%s);r  zif (kw_args > 0) {z2PyObject* value = __Pyx_GetKwValue_%s(%s, %s, %s);zBif (value) { values[%d] = __Pyx_Arg_NewRef_%s(value); kw_args--; }'else if (unlikely(PyErr_Occurred())) %szBif (likely((values[%d] = __Pyx_GetKwValue_%s(%s, %s, %s)) != 0)) {z&(void)__Pyx_Arg_NewRef_%s(values[%d]);z
kw_args--;zelse else {r  ri  z0__Pyx_RaiseArgtupleInvalid(%s, %d, %d, %d, %d); r  z$__Pyx_RaiseKeywordRequired(%s, %s); zif (unlikely(kw_args > 0)) {zBconst Py_ssize_t kwd_pos_args = (unlikely(%s < %d)) ? 0 : %s - %d;z#const Py_ssize_t kwd_pos_args = %s;r  zIconst Py_ssize_t used_pos_args = (kwd_pos_args < %d) ? kwd_pos_args : %d;used_pos_argskwd_pos_argszvalues + %drj  r  zMif (unlikely(__Pyx_ParseOptionalKeywords(%s, %s, %s, %s, %s, %s, %s) < 0)) %s) r  r  r(  rJ   r	   r{  r  r  r  r  r  rx  r1  rc   r  ry  r  r  r   r  r  r  r1   r   r3  r   r  ,generate_optional_kwonly_args_unpacking_coderA   r  r  r  )r   r  r  r  r  r  r  rO   num_required_posonly_argsr  r  r  r  last_required_argr  pos_arg_countvalues_arrayr2   r2   r3   r    s  










 






















	z.DefNodeWrapper.generate_keyword_unpacking_codec           	      C   sF  g }d}d}t |D ]\}}|jr|d7 }|jr|jsq
|s |}||j q
|dkr0d| }nd}|rt|dkr^|d| j rCdpDdt|f  |d |d	||t| f  n|d
 |d|  |d| j	j
tjtjtj|f  |d| j	j
  |d|| j  t|dkr|d |d d S d S )Nr   r   r   z-%dr   z'if (kw_args > 0 && %s(kw_args <= %d)) {likelyzPy_ssize_t index;z6for (index = %d; index < %d && kw_args > 0; index++) {zif (kw_args == 1) {zconst Py_ssize_t index = %d;z<PyObject* value = __Pyx_GetKwValue_%s(%s, %s, *%s[index%s]);zEif (value) { values[index] = __Pyx_Arg_NewRef_%s(value); kw_args--; }r  r  )r  r  r  r(  rt  rc   rA   rJ   r  r  r  r	   ry  r  r  r  r1   )	r   r  rO   optional_argsfirst_optional_argr  r  r  posonly_correctionr2   r2   r3   r    sR   




z;DefNodeWrapper.generate_optional_kwonly_args_unpacking_codec                 C   s"   | j D ]}|jr| || qd S ry   )rL   r  generate_arg_conversionrs  r2   r2   r3   r    s
   
z0DefNodeWrapper.generate_argument_conversion_codec                 C   s   |j }|j}|jr*|jr|d|j  n|d|j  | || |d d S |jr5| || d S ||rH|d|j	j
|jf  d S t|jd||f  d S )Nr  zassert(%s); {r  r  z+Cannot convert 1 argument from '%s' to '%s')r  r9  rH  r(  rJ   r  %generate_arg_conversion_from_pyobject#generate_arg_conversion_to_pyobjectr  r   r  r   r1   )r   r  rO   old_typenew_typer2   r2   r3   r    s   
z&DefNodeWrapper.generate_arg_conversionc                 C   sB   |j }|jr|||j|jj|j| d S t|jd|  d S )Nr  )	r9  r  rJ   r  r  r   r  r1   r   )r   r  rO   r  r2   r2   r3   r    s   
z4DefNodeWrapper.generate_arg_conversion_from_pyobjectc              
   C   s^   |j }|j}|r%|d|jj||j||jj|jf  ||j d S t	|jd|  d S )Nz%s = %s(%s); %sz5Cannot convert argument of type '%s' to Python object)
r  to_py_functionrJ   r   r  r  r  r1   r  r   )r   r  rO   r  rU   r2   r2   r3   r    s   z2DefNodeWrapper.generate_arg_conversion_to_pyobjectc                 C   s\  | j D ]!}|jr| || q|js$|jjs|jjs|jjr$| || q| j	j
jrttt| j | j D ]A}| j	j
jdkrE|d |d|  |d| j	j
j| j |f  |d|| j  |d | j	j
jdkrx|d q7| j	j
jdkrt| j dkr|d	 |d
| j	j
j  |d|| j  |d d S d S d S d S )N__ipow__z #if PY_VERSION_HEX >= 0x03080000z)if (unlikely(unused_arg_%s != Py_None)) {zNPyErr_SetString(PyExc_TypeError, "%s() takes %s arguments but %s were given");%s;r  z'#endif /*PY_VERSION_HEX >= 0x03080000*/r(   z$if ((PY_VERSION_HEX < 0x03080000)) {zYPyErr_SetString(PyExc_NotImplementedError, "3-argument %s cannot be used in Python<3.8");)rL   r  rp  rl  r9  rH  r3  rl  rr  r  r   rI  reversedr  rA   r  r  rc   rJ   r>  r  r1   )r   rO   r  r  r2   r2   r3   r+    sJ   





z+DefNodeWrapper.generate_argument_type_testsc                 C   r  ry   )r  r9  r   r2   r2   r3   r9  /  r  zDefNodeWrapper.error_valuer\  ) rE   ri   rj   defnoder  r  r   r   rG  rk  rl  r  r   r  r  r!  r  r  r  r  r  r  r  rr  r  r  r  r  r  r  r+  r9  r2   r2   r2   r3   r    s@    	
NSPN A  6,*r  c                       sX   e Zd ZdZdZdZdZejdg Z fddZ	 fddZ
d	d
 Z fddZ  ZS )GeneratorDefNodeTF	Generatorgbodyc                    s.   t |g dd|d< tt| j|fi | d S )NT)r   r   r   )r   r`   r  r   r   r1   rq   rh   r2   r3   r   @  s   zGeneratorDefNode.__init__c                    s*   t t| | | j| j_| j| d S ry   )r`   r  r   r  r  r   rh   r2   r3   r   E  s   
z%GeneratorDefNode.analyse_declarationsc                 C   s   | j jj}|| j}|| j}|| j}|d |d| j|| j	r+| j	
|ndtj||||d| jf  |tjt | jr]d}|d|tjf  ||t ||t |  |d |d d S )	Nr  zk__pyx_CoroutineObject *gen = __Pyx_%s_New((__pyx_coroutine_body_t) %s, %s, (PyObject *) %s, %s, %s, %s); %sr  genzgen->classobjz&%s = __Pyx_CyFunction_GetClassObj(%s);zreturn (PyObject *) gen;r  )r  r   r  r  rc   qualnamemodule_namerJ   gen_type_namer  r  r	   r  r  r1   rG  r   r_  r  r  r  rM  )r   r   rO   
body_cnamerc   r  r  classobj_cnamer2   r2   r3   r  J  s.   



z'GeneratorDefNode.generate_function_bodyc                    sH   | t| jd | jj|dd tt| || | j|| d S )NCoroutine.cT)proto)	r3  r   r  r  r  r  r`   r  r   r
  rh   r2   r3   r   b  s   z.GeneratorDefNode.generate_function_definitions)rE   ri   rj   r  is_iterable_coroutiner  r  r  r   r   r   r  r   rk   r2   r2   rh   r3   r  3  s    r  c                   @      e Zd ZdZdZdS )AsyncDefNode	CoroutineTN)rE   ri   rj   r  r  r2   r2   r2   r3   r  i      r  c                   @   r  )IterableAsyncDefNodeIterableCoroutineTN)rE   ri   rj   r  r  r2   r2   r2   r3   r   n  r  r   c                   @   r  )AsyncGenNodeAsyncGenTN)rE   ri   rj   r  r  r2   r2   r2   r3   r  s  r  r  c                       sP   e Zd ZdZdZdZdZd fdd	Zdd Zdd	 Z	dd
dZ
dd Z  ZS )GeneratorBodyDefNodeTFNc              
      s$   t t| j||||d g d d d d S )N)r1   r   rc   is_async_gen_bodyr<   rL   r  r  )r`   r  r   )r   r1   rc   r   r  rh   r2   r3   r     s   

zGeneratorBodyDefNode.__init__c                 C   s\   | |j}| d}tj| | }|jd t| j|dd}||_t| j	|_
d|_|| _d S )N	generatorr  )r  r<  T)r9  r:  r	   genbody_prefixr  r   r1   r  r   rc   r>  r  r   )r   r   rB  rc   r  r   r2   r2   r3   declare_generator_body  s   

z+GeneratorBodyDefNode.declare_generator_bodyc                 C   s   |  | | | d S ry   )r  r  r   r2   r2   r3   r     s   
z)GeneratorBodyDefNode.analyse_declarationsc                 C   sB   d| j jtjtjtjf }|r|d|  d S |d|  d S )Nz]static PyObject *%s(__pyx_CoroutineObject *%s, CYTHON_UNUSED PyThreadState *%s, PyObject *%s)z%s; /* proto */z%s /* generator body */
{)r   r  r	   generator_cnamelocal_tstate_cnamesent_value_cnamerJ   )r   rO   r  r  r2   r2   r3   r    s   z-GeneratorBodyDefNode.generate_function_headerc              	   C   s  | j }| j|| || | |_|| j | || |	d | 
| | }|	dtj  | }|  || jjpG| jj |jjd }|jjd }|sY|rq|  d|j_| jrj| j|nd }|| |j|jjj | }	|d}
||
 | |
 |	d|!tj"| j  | j#r| j$d ur| j$}|t%j&u rd}n|t%j'u rd	}n|t%j(u rd
}nt)d| |	dtj||!tj| jf  |*tjt+ | ,|| |jjjj-r|	d|jj.tj/|jj0dtj1 f  |	dtj/  |s|rd|j_|| j |	d |	d | j#sE| jj2sE| j3r8|j4t56dd |	d| j3rAdnd  |7|j8r| jj2sW|9|j: | |j8 | j#rn| j$d urn|;tjt+ t<j=|> j?j@v r|j4t56dd |	dtA| j3  |jB D ]\}}|C|| q|D| jj | |j: | j#r|Etjt+ n|;tjt+ |	d |	dtj1  |	d |	dtj1  |	dtj1  |s|r|jFtj|jjG d |H  |	dtj  |	d  |I|j |s|r|	jJ| jj| j|jjG d |		d!tj1  |		d"|
  |jKD ]\}}|		d#||f  q-|		d$ |sG|rQ|	jFd%|jjG d |	H  |		d& |		d  |L  d S )'Nr   zPyObject *%s = NULL;r  r  T	first_runr  zPyList_New(0)zPySet_New(NULL)zPyDict_New()z)invalid type of inlined comprehension: %sz%s = %s; %sr  z%s->closurezCYTHON_MAYBE_UNUSED_VAR(%s);Fr  StopAsyncIterationr  zPyErr_SetNone(%s);__Pyx_PyExc_StopAsyncIterationPyExc_StopIterationpep479z*__Pyx_Generator_Replace_StopIteration(%d);z#if !CYTHON_USE_EXC_INFO_STACKz+__Pyx_Coroutine_ResetAndClearException(%s);rS  z%s->resume_label = -1;z%__Pyx_Coroutine_clear((PyObject*)%s);r  r  r  zswitch (%s->resume_label) {zcase 0: goto %s;zcase %d: goto %s;z2default: /* CPython raises the right error here */r  zreturn NULL;)Mr  r   r   r  r  r   r  r1   r   rJ   r  rF   r	   r  rK  rL  r   rc   r>  r   r   r  r  r   r  r  r  init_closure_tempsr  r9  r  	use_labelr3  r  r  
is_inlinedinlined_comprehension_typer   	list_typeset_type	dict_typer   r  r   r  r{  r5  r  r  r	  r   r  r3  r   r  r/  r0  r1  r2  put_xdecref_clearr"   generator_stopr   contextfuture_directivesr  r4  r5  r=  rH  rJ  r  rM  rN  r  yield_labelsrO  )r   r   rO   r  closure_init_coderW  r  r  r  resume_codefirst_run_labeltarget_type	comp_initr  r9  r  labelr2   r2   r3   r     s   





















z2GeneratorBodyDefNode.generate_function_definitions)NNNFr  )rE   ri   rj   r  r  r  r  r   r  r   r  r   rk   r2   r2   rh   r3   r  x  s    
r  c                   @   s&   e Zd ZdgZdZdd Zdd ZdS )r  r   Nc                    s   |j _jjrd}nd}ddlm   jt_	 j
jj	 fddj|d  D d}|jjs:|jjrOtjtj|dtjd dgd	_ntj|d_j|_S )
Nr   r   r  c                    s   g | ]} j j|jd qS r  )rr  r1   rc   r  r  r2   r3   r   H  s    z9OverrideCheckNode.analyse_expressions.<locals>.<listcomp>r  rL   )exprr   r   )r"  rL   r  rk  r   r`  RawCNameExprNoder1   r   	func_noder  r  r4  is_returncoder   ExprStatNoder  r   rn   )r   r   	first_arg	call_noder2   r  r3   rn   >  s(   z%OverrideCheckNode.analyse_expressionsc              
   C   s<  | j jr	| j jjn| j j}||j}| j jrdtj }nd| jd j	 }|
d |
dtj  |
d | j jrA|
d n	|
d||f  |
d |jtd	d
 |
dtjtjf  |
d|tjtjf  |
dtj|f  |
d |jjtdd}| j| |jtdd
 |
d|||||| jf  ||t |
d||jf  | j| |
d |
d |
dtj|f  |
dtj|f  |
dtjtjf  |
dtjtjf  |
d |
d ||tj |j | |
d |
d |
d |
d d S )Nrj  r   z /* Check if called by wrapper */zif (unlikely(%s)) ;z#/* Check if overridden in Python */r  zelse if (unlikely((Py_TYPE(%s)->tp_dictoffset != 0) || __Pyx_PyType_HasFeature(Py_TYPE(%s), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) {zQ#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTSPyDictVersioningObjectHandling.czNstatic PY_UINT64_T %s = __PYX_DICT_VERSION_INIT, %s = __PYX_DICT_VERSION_INIT;z?if (unlikely(!__Pyx_object_dict_version_matches(%s, %s, %s))) {z/PY_UINT64_T %s = __Pyx_get_tp_dict_version(%s);rS  Tr  PyObjectGetAttrStrz*%s = __Pyx_PyObject_GetAttrStr(%s, %s); %sz-if (!__Pyx_IsSameCFunction(%s, (void*) %s)) {r  z#%s = __Pyx_get_tp_dict_version(%s);z'%s = __Pyx_get_object_dict_version(%s);zif (unlikely(%s != %s)) {z"%s = %s = __PYX_DICT_VERSION_INIT;)!r  ra  r   r  rc   rk  r	   module_cnamerL   r  rJ   r  r   r3  r   r  tp_dict_version_tempobj_dict_version_temptype_dict_guard_tempr  r  r   r'  	set_cnamer  r1   r  r  r   r   r  r
   r  )r   rO   method_entryinterned_attr_cnamerV  func_node_tempr2   r2   r3   r   S  s|   













z)OverrideCheckNode.generate_execution_code)rE   ri   rj   r   r   rn   r   r2   r2   r2   r3   r  0  s
    
r  c                   @      e Zd ZdS )ClassDefNodeNrE   ri   rj   r2   r2   r2   r3   r8        r8  c                   @   s   e Zd Zg dZdZdZdZdZdZdZ	dZ
		dddZdd Zdd	 Zd
d ZeejedejdgZdd Zdd Zdd ZdS )PyClassDefNode)doc_noder   r^   	metaclassmkwrd   class_resultr  
class_cellru  
orig_basesNFc	              	   C   s  t | | || _|| _|| _|| _|| _ddlm}	 | jr;t	j
r;t| j| j}|	j||d}
|	jtdt|d| _nd }
| }|rd}d| _|jr|jr{tt|jd d d D ]\}}|jjd	krv| jd urnt|jd
 |j| _|j|= qY|| _n| jd usJ n|	|| _|s| js| js| jr| jd u r|r|js| j}nd }|s| jjr| jjsn|	j|| d| _d}nd}|	j |||
| d| _!|	j"||| |
|||d| _#n|	j$|g d| _!|	j%||| |
d| _#|	j||d| _&|	'| j| _(d S )Nr   r  r%  rw   )rc   r9  r1   FTr   r=  z2keyword argument 'metaclass' passed multiple times)class_def_node)rc   r<   rB  )rc   rB  r<   calculate_metaclassallow_py2_metaclass
force_typerH  )rc   rB  r<   r*  ))r	  r   rc   r<   r   ru  rd   r   r`  r#   rr  r=   r1   
StringNoderr  r   r   r<  is_py3_style_classis_dict_literalrH  r   r  r   r   r=  r   r>  	ProxyNodeis_sequence_constructorrL   PyClassMetaclassNodePyClassNamespaceNoder^   Py3ClassNodeclassobjDictNode	ClassNoder  ClassCellInjectorNoder@  )r   r1   rc   rd   r<   r   ru  r:  force_py3_semanticsr`  r<  rD  r  r   mkdictneeds_metaclass_calculationr2   r2   r3   r     sv    



zPyClassDefNode.__init__c                 C   sZ   | j rt| jjd dS ddlm} t| jdd| j| jp#|j	| jg d| j
| jd| jd	S )	zO
        Return this node as if it were declared as an extension class
        z7Python3 style class could not be represented as C classNr   r  r  rL   F)r<  r  
class_namerd   ru  r   r=  r<   )rH  r   rO  r1   r   r`  CClassDefNoderc   rd   rY  ru  r   r<   r   r`  r2   r2   r3   	as_cclass  s   zPyClassDefNode.as_cclassc                 C   s:   |}|j s|jr|j}|j s|jst| j|d }| _|S )N)rc   ri  )r  r  ri  r   rc   r  )r   r   r  rU  r2   r2   r3   create_scope   s   zPyClassDefNode.create_scopec                 C   s   | j  }}| jr&ddlm} | jd d d D ]}||j|j|gd}qd | _|| _| jr2| j| | j	r;| j	| | j| | j
| | |}|j|_| j
jj|_| jr_| j| | j| || d S )Nr   )r  r   r#  )rO  ru  r`  r  r1   r  r?  rd   r   r>  r  analyse_target_declarationr[  r   r   r  class_obj_cnamer<  r   r  )r   r   unwrapped_class_resultr?  r  r  rU  r2   r2   r3   r   '  s0   

z#PyClassDefNode.analyse_declarationsrd   c                 C   s   | j r3| j jrt| j jdks3ddlm}m} | j |}||jd| j	t
dd||gd| _ || _| j r=| j || _ | jrG| j|| _| jrQ| j|| _| j|| _| j|| _| j}| j|| _| j|| j| _| j|| _| S )Nr   r   )PythonCapiCallNode	CloneNode__Pyx_PEP560_update_basesPy3UpdateBasesr-  )function_namer  utility_coderL   )rd   rK  rA   rL   r`  r_  r`  rn   r1   update_bases_functyper   r  rA  r>  r=  r^   r?  r  r   r  analyse_target_expressionrO  r@  )r   r   r_  r`  rA  rU  r2   r2   r3   rn   E  s.   
z"PyClassDefNode.analyse_expressionsc                 C   s"   |  | j| | j| j| d S ry   )r   r  r   r   r
  r2   r2   r3   r   ^  s   z,PyClassDefNode.generate_function_definitionsc                 C   s  | | j |j|  | j}| jr| j| | jr!| j| | jr*| j| | j	r3| j	| | j
| | jrp|d| j | j f  ||d| j
 | j f | j |d | j| | j| | j
  |_|_| j}|d ur|jsd }|d ur|| | j| | j| |d ur||| j  |d ur|| || | j  |_|_| j| j| | j
| | j
| | j	r| j	| | j	| | jr| j| | j| | jr| j| | j| |j  d S )Nzif (%s != %s) {z.PyDict_SetItemString(%s, "__orig_bases__", %s)r  )r  r1   pyclass_stackrt  r  rA  r  rd   r>  r=  r^   rJ   r   error_goto_if_neggenerate_disposal_coder  namespace_cnamer]  r@  	is_activer   r   r?  generate_injection_coderO  r  r   pop)r   rO   rU  r@  r2   r2   r3   r   b  sj   




z&PyClassDefNode.generate_execution_code)NNF)rE   ri   rj   r   ru  r?  rH  r=  r>  r<  rA  r   rZ  r[  r   r
   r  r   r  re  rn   r   r   r2   r2   r2   r3   r;    s.    
Ir;  c                   @   s   e Zd ZdgZdZdZdZdZdZdZ	dZ
dZdZedd Zdd Zdd	 Zd
d Zdd Zdd Zdd Zdd ZedddZdd ZdS )rX  r   NFc                 C   s
   t | jS ry   )r    rW  r   r2   r2   r3   punycode_class_name  r  z!CClassDefNode.punycode_class_namec                 C   sH   t | ds!ddlm} | jr|j| j|g | jdd| _| jS d | _| jS )N_buffer_defaultsr   rD  F)need_complete)r  r   rE  buffer_defaults_noderI  buffer_defaults_posro  )r   r   rE  r2   r2   r3   rJ    s   
zCClassDefNode.buffer_defaultsc                 C   s   | j r| jdkr| j d}||| j}|sd S n|}|j| j| jdd| j d | j| j| j| j	| j
| j| || jd| _| jrOt| jjdkrQd| jj_d S d S d S )Nr  .r   )rc   r1   r  implementingr  r:  objstruct_cnametypeobj_cnamer<  r  
check_sizere  rJ  shadowr   T)r  r<  splitr  r1   declare_c_classrW  objstruct_nametypeobj_namer  rw  re  rJ  rx  r   rd   rA   rL   r9  multiple_bases)r   r   r  
home_scoper2   r2   r3   rz    s4   zCClassDefNode.declarec                 C   s   i }| j s|S ddlm} g }| j D ]V}|j}d }t||jr$|}|j}t||}|dkr;|r6t	|j
d d|d< q|dkrcd }	i }
|r\t||jrO|j}	n|jj}	|j}|r\| }
|	|
f||< q|| q|rst	|d j
d	 || _ |S )
Nr   r  zfunctools.total_orderingz total_ordering cannot be called.Ttotal_orderingdataclasses.dataclassr   z8Cdef functions/classes cannot take arbitrary decorators.)ru  r   r`  r  rB   CallNoder  r   'exprnode_to_known_standard_library_namer   r1   r  rL   r9  r:  as_python_dictrt  )r   r   extra_directivesr`  remaining_decoratorsoriginal_decoratorr  decorator_call
known_namerL   rM   kwds_r2   r2   r3   _handle_cclass_decorators  sD   
z'CClassDefNode._handle_cclass_decoratorsc                    sr   j rjstjd  }d _jrAd _ jD ]}|j	jkr(|_qjd u rAt
jd  j_dj_ j jjrۈjjd }| }|tjtjtjfv rb | j}|d u rpt|jdj  nV|tjkrxd }nN|js|jr|jst|jd|  n<| st|jd|j	jf  n+|jr|jjr|j rt|jd|jf  n|jr|j	dv rt|jd	|j	  n|_ j!d
ddkr|tjkrt"jdd j#d u}|rjrjjsjj$% fdd d S jrj&dkrj'd} (|j}	|	sd S n }	j&dkr=jdkr=jt)j*v r= j+d d dkr=t"jdj d |	j,jj|oHj-|oNj- jjjj.j/j&j0j12 j3d_4jrzt5jjdkrzdj4j_6j3rj4|	j_7|	 urj&dkr 8jj4j j4jj _}
|
d ur|r j9 |
_|
j:| n j|
_d|
jv rd}|
jd }|r|d }|!d}|o|j;o|j<}|rdnd|
_=j>rt?j@rtAjj>|
_>|r1j#B|
 jCd}|r&|jDr&|
jEs&|
jFs&jGd|_HjId|j>|j j-r.d|
_End|
_Ft5jjdkr|rAj-rKtjjd jd jjdd  D ]}| rat|jd qSdj4j_JddlKmL} |jMj|jNjjdj|jOjg dgd _PnjrjjQpjjJj4j_Jd _Pndj4j_Jd _P Rj4 j4jj$D ]}|  qd S )!NzTObject struct name specification required for C class defined in 'extern from' blockr   r   z+First base of '%s' is not an extension typez'%s' is not an extension typez*Base class '%s' of type '%s' is incompletez%Base class '%s' of type '%s' is final)r  byteszGinheritance from PyVarObject types like '%s' is not currently supportedfreelistzIfreelists cannot be used on subtypes, only the base class can manage themc                      s
     S ry   )r   r2   r  r2   r3   <lambda>I  s   
 z4CClassDefNode.analyse_declarations.<locals>.<lambda>r  rs  __builtin__   zcpython.z %s already a builtin Cython type)rc   r1   r  rt  r  r:  ru  rv  rw  r<  r  re  rJ  rx  Tr  Ffrozenr}   __dict__getterz'Only declare first base in declaration.z+Only one extension type base class allowed.r  r%  rF  rV  )Sr  r{  r   r1   r  r:  r  modulecimported_modulesrc   r   r  has_extern_classadd_imported_modulerd   rL   rZ  r
   r  c_long_typec_float_typer  sign_and_namer9  rW  r   r  rm  ru  rh  r  r   r7  r  r   r   defered_declarationsrt  r<  ry  r  r   builtin_typesr>  rz  r=  r|  rw  r  re  rJ  rx  r   rA   r}  r  add_imported_entryr   r~   r   r   is_c_dataclass_scoper<   r#   rr  r=   r   r7  is_variabledefinedimplementedmangle_internalgetter_cnamedeclare_property
early_initr   r`  rY  IdentifierStringNoderP  type_init_argsis_externalallocate_vtable_names)r   r   r  r  rA  r:  base_class_scopehas_bodyr  r~  r  	is_frozendataclass_configdecorator_kwargsfrozen_flag
dict_entry
other_baser`  thunkr2   r  r3   r     s  

















z"CClassDefNode.analyse_declarationsc                 C   s4   | j r| jjj}| j || _ | jr| j| | S ry   )r   r   r9  r  rn   r  ry  r2   r2   r3   rn     s   
z!CClassDefNode.analyse_expressionsc                 C   s,   | j r| | j| | j | j| d S d S ry   )r   r   r  r   r
  r2   r2   r3   r     s   z+CClassDefNode.generate_function_definitionsc                 C   s  | | j | jjjsd }| jr|jjtj	dd}| j
| |d|| j f  ||tj	 d| }|jjtj	dd}|d|| j f  |||| j ||t	 |d||f  d| }|d|  |d	|  |d
 |d |d |d ||| j |d ||tj	 |j| | j| | j| | j| j||dd |d ur||tj	 |j| | jr| j| d S d S )NTr  z%s = PyTuple_GET_ITEM(%s, 1);z(((PyTypeObject*)PyTuple_GET_ITEM(%s, 0))zQ%s = __Pyx_PyType_GetSlot(&PyType_Type, tp_new, newfunc)(&PyType_Type, %s, NULL);zMif (__Pyx_PyType_GetSlot((PyTypeObject*) %s, tp_base, PyTypeObject*) != %s) {z@__Pyx_PyType_GetSlot((PyTypeObject*) %s, tp_base, PyTypeObject*)z4__Pyx_TypeName base_name = __Pyx_PyType_GetName(%s);z4__Pyx_TypeName type_name = __Pyx_PyType_GetName(%s);zxPyErr_Format(PyExc_TypeError, "best base '" __Pyx_FMT_TYPENAME "' must be equal to first base '" __Pyx_FMT_TYPENAME "'",z#             base_name, type_name);z!__Pyx_DECREF_TypeName(base_name);z!__Pyx_DECREF_TypeName(type_name);r  )bases_tuple_cnamecheck_heap_type_bases)r  r1   r   r9  r  r  r  r  r
   r   r  rJ   r   r  r  r  r  r  r  ri  r  generate_type_ready_coder   r   )r   rO   rd   
first_base
trial_typetrial_type_baser2   r2   r3   r     sL   






z%CClassDefNode.generate_execution_codec              
   C   sX  | j }|j}|j}|sd S | jdkr'|jr%|jrJ |d|j|jf  d S |s+J |js0J d|j }|d d }|sb|jjrb|jj	t
dd}|d||jjj||| jf  ||t
 |sf|r|r|jtdd	 || jd
|td|j||p|f  |d|tj||p|f  |r|j|t
d |j| |||| j n|d|tj|||| jf  td|jj}	|	|sC|d |d||	j|	|f  dD ];}
t|jj|
}	|	|dkrt||	s|d||	j|||	jf  |d||	j||	jf  |d q|d |d |d |d |d |d |d |jtdd	 || jd||f  |d |rv| |t
 |!|t
 |d |j|f  |d||jf  |d |j}|r|j"r|j#d!ks|d"|j$rd#nd$|j#|j$rd#nd$|j#f  |jtd%d	 || jd&|jj  |d n|j}|s|d t|jjD ]	}|%|| q|d |d' |jtd(d	 || jd)|  |d |d* |d+|  |d t&|d,}t&|d}|dkrf|dkrf|d |j'r<d-}d.}nd/}d0}|jt|d1 |d2||f  |d3||f  |d |d | j jj(D ]}|j)dv }|j*rt+j,r|j-r|st| j jj|j)}|r|. nd }|r|| |d4 |d5 |d6||j)|d7| jf  |d8 |d9|j-  |d:|j-|j/f  |d;|j-  |d |d |d |r|d qk|j0r(|jtd<d= || jd>||j1f  |d |jtd?d= || jd@|  |d |jj2sF|jj3dAsF|| jdBtj|4|j5|f  |j6sO|7dCnd }|r~|j t
u rxdD| }|j$rf|j#}ndE|j# }|dF||||j8f  nt9|jdG |j6s|7dHrnd S |jtdId	 |d || jdJ|  |d d S d S )KNr  z	%s = &%s;z%s_specz#if CYTHON_USE_TYPE_SPECSTr  z(%s = PyTuple_Pack(1, (PyObject *)%s); %sValidateBasesTuplezExtensionTypes.cz+__Pyx_validate_bases_tuple(%s.name, %s, %s)tp_dictoffsetzB%s = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(%s, &%s, %s);r  zG%s = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(%s, &%s, NULL); %stp_as_bufferz$#if !CYTHON_COMPILING_IN_LIMITED_APIz%s->%s = %s;r  r  zZif (!%s->tp_as_buffer->%s && %s->tp_base->tp_as_buffer && %s->tp_base->tp_as_buffer->%s) {z5%s->tp_as_buffer->%s = %s->tp_base->tp_as_buffer->%s;r  z>#elif defined(Py_bf_getbuffer) && defined(Py_bf_releasebuffer)zB/* PY_VERSION_HEX >= 0x03090000 || Py_LIMITED_API >= 0x030B0000 */z#elif defined(_MSC_VER)zU#pragma message ("The buffer protocol is not supported in the Limited C-API < 3.11.")r  zL#warning "The buffer protocol is not supported in the Limited C-API < 3.11."rS  FixUpExtensionTypez.__Pyx_fix_up_extension_type_from_spec(&%s, %s)z%s.tp_bases = %s;PyTypeObjectz#if (sizeof(%s%s) != sizeof(%s%s)) {r   zstruct ValidateExternBasez__Pyx_validate_extern_base(%s)z#if !CYTHON_USE_TYPE_SPECSPyType_Readyz__Pyx_PyType_Ready(%s)z#if PY_MAJOR_VERSION < 3z%s->tp_print = 0;tp_getattro#__Pyx_PyObject_GenericGetAttrNoDictPyObject_GenericGetAttrNoDict__Pyx_PyObject_GenericGetAttrPyObject_GenericGetAttrr-  zif ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!%s->tp_dictoffset && %s->tp_getattro == PyObject_GenericGetAttr)) {z%s->tp_getattro = %s;ru  r  zDPyObject *wrapper = PyObject_GetAttrString((PyObject *)%s, "%s"); %swrapperz3if (__Pyx_IS_TYPE(wrapper, &PyWrapperDescr_Type)) {z0%s = *((PyWrapperDescrObject *)wrapper)->d_base;z%s.doc = %s;z0((PyWrapperDescrObject *)wrapper)->d_base = &%s;	SetVTableImportExport.cz__Pyx_SetVtable(%s, %s)MergeVTablesz__Pyx_MergeVtables(%s)internalz)PyObject_SetAttr(%s, %s, (PyObject *) %s)__weakref__z%s->tp_weaklistoffsetz	struct %sz#if (%s == 0) %s = offsetof(%s, %s);z)__weakref__ slot must be of type 'object'__reduce_cython__SetupReducez#__Pyx_setup_reduce((PyObject *) %s)):r9  r  r  r<  rv  rJ   r  r:  r  r  r   r  r1   r  r   r3  r   r  put_error_if_negr   get_slot_by_namer   	slot_coder	   r/  r  r  is_empty	slot_namer  r  get_base_slot_functionr  r  r  ru  r  generate_dynamic_init_codeget_slot_code_by_namer7  pyfunc_entriesrc   rI  r#   rr  r@  r  r>  vtable_cnamevtabptr_cnameis_internalr  r  rW  is_closure_class_scoper7  r  r   )r   rO   r  r  r9  r  r  typespec_cname
tuple_tempbuffer_slotbuffer_method_namer:  r  getattr_slot_funcdictoffset_slot_funcpy_cfuncutility_funcrU   r3  rT  weakref_entrytp_weaklistoffset	objstructr2   r2   r3   r    s  






	












































z&CClassDefNode.generate_type_ready_codec                 C   s,   | j r	| j | | jr| j| d S d S ry   )r  r   r   r   r2   r2   r3   r     s
   zCClassDefNode.annotater  )rE   ri   rj   r   rq  rr  r  re  r{  r|  rw  ru  rx  r  rn  rJ  rz  r  r   rn   r   r   r  r  r   r2   r2   r2   r3   rX    s2    
+ 1 rX  c                   @   r  )PropertyNoder   c                 C   s*   | | j| j| j| _| j| jj d S ry   )r  rc   r<   r1   r   r   r   r  r   r2   r2   r3   r     s   z!PropertyNode.analyse_declarationsc                 C   r  ry   r  r   r2   r2   r3   rn        z PropertyNode.analyse_expressionsc                 C   r  ry   r  r
  r2   r2   r3   r      r  z*PropertyNode.generate_function_definitionsc                 C   r   ry   r2   r   r2   r2   r3   r     r   z$PropertyNode.generate_execution_codec                 C   r  ry   r  r   r2   r2   r3   r     r   zPropertyNode.annotateNr!  r2   r2   r2   r3   r    s    r  c                   @   sN   e Zd ZdZdgZdZedd Zdd Zdd	 Z	d
d Z
dd Zdd ZdS )CPropertyNodezADefinition of a C property, backed by a CFuncDefNode getter.
    r   Tc                 C   s*   | j j}|rt|d tsJ ||d S r  )r   r   rB   r  r   r   r2   r2   r3   r    s   zCPropertyNode.cfuncc                 C   sN   t | j|d}| j| |j| j| j| j| jj|d }| _	| jj	j
|_d S )N)class_scope)ctypeproperty_scope)r   rc   r   r   r  r<   r1   r  r  r   r  r  )r   r   r  r   r2   r2   r3   r     s   z"CPropertyNode.analyse_declarationsc                 C   r  ry   r  r   r2   r2   r3   rn   "  r  z!CPropertyNode.analyse_expressionsc                 C   r  ry   r  r
  r2   r2   r3   r   &  r  z+CPropertyNode.generate_function_definitionsc                 C   r   ry   r2   r   r2   r2   r3   r   )  r   z%CPropertyNode.generate_execution_codec                 C   r  ry   r  r   r2   r2   r3   r   ,  r   zCPropertyNode.annotateN)rE   ri   rj   rw   r   r   r  r  r   rn   r   r   r   r2   r2   r2   r3   r  
  s    
r  c                   @   (   e Zd Zg Zdd Zdd Zdd ZdS )
GlobalNodec                 C      | j D ]	}||| j qd S ry   )namesdeclare_globalr1   r   r   rc   r2   r2   r3   r   7     
zGlobalNode.analyse_declarationsc                 C   r|  ry   r2   r   r2   r2   r3   rn   ;  r   zGlobalNode.analyse_expressionsc                 C   r   ry   r2   r   r2   r2   r3   r   >  r   z"GlobalNode.generate_execution_codeNr  r2   r2   r2   r3   r  0  
    r  c                   @   r  )NonlocalNodec                 C   r  ry   )r  declare_nonlocalr1   r  r2   r2   r3   r   I  r  z!NonlocalNode.analyse_declarationsc                 C   r|  ry   r2   r   r2   r2   r3   rn   M  r   z NonlocalNode.analyse_expressionsc                 C   r   ry   r2   r   r2   r2   r3   r   P  r   z$NonlocalNode.generate_execution_codeNr  r2   r2   r2   r3   r  B  r  r  c                   @   sF   e Zd ZdgZdd Zdd Zdd ZdZd	d
 Zdd Z	dd Z
dS )r)  r$  c           
      C   s   ddl m} | j}t||jrR|j }|dkrP| \}}t|r(t	|j
d |jD ]\}}||}	|	d u r?t	|j
d q+|j|j|	|j
dd q+t| _d S d S t|dd d urr|jrg|| t| _d S |jsm|jrtt| _d S d S d S )	Nr   r  rz  z!Variable names must be specified.Unknown typeT)rf  r  )r   r`  r$  rB   GeneralCallNoder  r>  explicit_args_kwdsrA   r   r1   rH  rZ  r  r   PassStatNoderD   r   r   declare_from_annotationr  is_subscript)
r   r   r`  r$  rU   rL   rM   varr  r9  r2   r2   r3   r   [  s.   





z!ExprStatNode.analyse_declarationsc                 C   s"   d| j _| j || _ d| j _| S r  )r$  result_is_usedrn   r   r2   r2   r3   rn   t  s   z ExprStatNode.analyse_expressionsc                 C   s&   | j jjr| j jr|   d S d S d S ry   )r$  r9  rH  is_tempr   r   r2   r2   r3   r   {  s   zExprStatNode.nogil_checkzDiscarding owned Python objectc                 C   sx   | | j d| j_| j| | jjs.| j r.| j }| jjjs'd| }|	d|  | j
| | j| d S )NFz
(void)(%s)r  )r  r1   r$  r  r  r  r   r9  r4  rJ   ri  r  )r   rO   r   r2   r2   r3   r     s   

z$ExprStatNode.generate_execution_codec                 C   r  ry   )r$  r   r
  r2   r2   r3   r     r  z*ExprStatNode.generate_function_definitionsc                 C   r  ry   )r$  r   r   r2   r2   r3   r     r   zExprStatNode.annotateN)rE   ri   rj   r   r   rn   r   r   r   r   r   r2   r2   r2   r3   r)  T  s    r)  c                   @   s,   e Zd Zdd Zdd Zdd Zdd Zd	S )
AssignmentNodec                 C   sT   |j }|j }|jr"|jjr$|jr&|jjs(t| jd||dd d S d S d S d S d S )Nz4Assigning to '{}' from '{}' discards const qualifierr   r   )r9  r1  r:  ra  r   r1   rZ  )r   r`  rhsrhs_tlhs_tr2   r2   r3   _warn_on_const_assignment  s
   z(AssignmentNode._warn_on_const_assignmentc                 C   s"   t |tr| |j|j d S d S ry   )rB   r  r  r`  r  )r   rN   r2   r2   r3   _check_const_assignment  s   
z&AssignmentNode._check_const_assignmentc                 C   sL   |  |}| | t|tr$t|ts$|jjjr$|j r$t	| j
d |S )Nz9Storing unsafe C derivative of temporary Python reference)rm   r  rB   r  ParallelAssignmentNoder  r9  r1  is_ephemeralr   r1   )r   r   rN   r2   r2   r3   rn     s   

z"AssignmentNode.analyse_expressionsc                 C   s$   | | j | | | | d S ry   )r  r1   generate_rhs_evaluation_coder   r   r2   r2   r3   r     s   
z&AssignmentNode.generate_execution_codeN)rE   ri   rj   r  r  rn   r   r2   r2   r2   r3   r    s
    	r  c                   @   sx   e Zd ZddgZdZdZdZdZdd ZdddZ	d	d
 Z
dd Zdd Zdd Zdd ZdddZdd Zdd ZdS )SingleAssignmentNoder`  r  Fc                 C   sj  ddl m} t| j|jrq| jj }|rq| j \}}|dv rt|dkr2t	|d j
d d S |d urP|d }|dksCd|vrKt	|j
d d S |d }nd	}|d
 |}|d u rgt	|d
 j
d d S | j}	|dkrt|	|jr||	j|	j
fg}
nt|	|jrdd |	jD }
nt	|	j
d d S |
D ]\}}|j|||d|d qt|dkr|d | _nd| _nd| _t|	|jst	|	j
d |j|	j|| j
d	d n|dv rNd| _t|d
ks|d u rt	| jj
d d S g }|jD ]\}}||}|d u rt	|j
d q||j||j
f qt|t|jk rd S t| j|js*t	| jj
d | jj}t|}||||d| jj
 |D ]\}}}|||| q?n#|dkrqd| _|rat	| jjj
d t| jj
| jj|d}|| | jrwd S | jr| j| d S | j| | jjs| jj r| jj!r| jj!j"s| j# }|r|| jj!_"d S d S d S d S d S )Nr   r  )rz  typedefr(   zInvalid positional argument.r  r<  zInvalid keyword argument.r  r   r  rz  c                 S   s   g | ]}|j |jfqS r2   )rc   r1   r   r  r2   r2   r3   r     s    z=SingleAssignmentNode.analyse_declarations.<locals>.<listcomp>zInvalid declarationT)rf  r<  zInvalid declaration.)r<  )r  unionz.Struct or union members must be given by name.F
fused_typez*fused_type does not take keyword arguments)rc   r\   )$r   r`  rB   r  r  r  r>  r  rA   r   r1   compile_time_valuerZ  r`  rr  rc   rY  rL   r  declaration_onlyr]  rH  rt  r   r   r  r\  r   is_assignment_expression0analyse_assignment_expression_target_declarationr\  r  r   r   r  !get_known_standard_library_import)r   r   r`  	func_namerL   rM   kwdictr<  r9  r`  varsr  r1   membersmemberr  rc   r  	fusednodestdlib_import_namer2   r2   r3   r     s   







*
z)SingleAssignmentNode.analyse_declarationsr   c                 C   s  ddl m} | j|| _| |}|r|S | j|| _| j| | |}|r,|S t	| j|j
rC| j| j | j| j| _n| jjjrat	| j|jsa|j| jj| jd d d}||| _| jjjr|| jd| jj| jjg}|r| j}d| _|jj| _|jj| _| jdkr| jd u r|tdd n| j| jj|}n	| j| jj|}|s|js|js|js|jjr||}n	|jjr||}|| _| S )	Nr   r  )rA  rQ   stop=Tr  CppExceptionConversionrn  ) r   r`  r  rm   
unroll_rhsr`  ro   gil_assignment_check
unroll_lhsrB   MemoryViewIndexNodeanalyse_broadcast_operation$analyse_as_memview_scalar_assignmentr9  r2  SliceIndexNoder1   r\  lookup_operator_for_typesis_overloaded_assignmentr  rq  r3  r   r  r  r  r   r   rH  coerce_to_tempcoerce_to_simple)r   r   use_tempr`  unrolled_assignmentr`  opr  r2   r2   r3   rm   *  sR   







z"SingleAssignmentNode.analyse_typesc              	   C   s,  ddl m}m} |}d  } } }	}
|jjr|jj}n|jjs#|jjrt||j	r@|j
s@|js@|j }}t||j	r@|j
s@|jr/t||j	r|j}|j
}|rU|tj|}|j}|rb|tj|}n*|jjr|jjr|j| jt|jjt|jjtr~|jjn|jd}nt| jd d S d }	|	r|	tj|}	dd }z||d ||d ||	d }W n$ ty   t| jd Y d S w |jjr|jj}t|tsd S nd S d S ||krt| jd	||f  d S g }||}|g}|r|js||}|| |r|js||}|| |	r|	js||	}	||	 t|D ]p}|j| jt||tjd
}|	d urU|	 rK|j|	j }|j| jt||d}n
|j| jd|	|d}|d ur| rv| rv|j|j }|j| jt||d}n
|j| jd||d}||j| j|| |d q |
||fS )Nr   )r`  	UtilNodes)r   r  z*C array iteration requires known end indexc                 S   s"   | d u r|S |   r| jS td)NzNot a constant.)r  r  rg  )rN   
none_valuer2   r2   r3   	get_const|  s
   z.SingleAssignmentNode.unroll.<locals>.get_constr   z5C array assignment currently requires known endpointsz=Assignment to/from slice of wrong length, expected %s, got %s)r   r  r9  r  )operatoroperand1operand2r  )rA  ra  )!r   r`  r(  r9  	is_ctuplerl  r1  r2  rB   r   rQ   r  rA  r  r
   r  IntNoder1   strr   constant_value_not_setr   rg  
LetRefNoder   rt  r  r  r  MulNodeAddNode	IndexNoderm   )r   rN   target_sizer   r`  r(  rA  
start_node	stop_node	step_node
check_node
slice_sizer*  r_   refsrk  ix_node
step_valueindex_valuer2   r2   r3   unrollZ  s   

"












"
zSingleAssignmentNode.unrollc              	   C   s   ddl m} g }t||D ]\}}	|t| j||	| jd qt| j|d|}
|r4t	| j||
gd}
|d d d D ]}|
||
}
q;|
S )Nr   )r(  )r`  r  first)r1   r   r   )r   r(  r  rt  r  r1   rA  r  rn   r   LetNode)r   r<  r:  lhs_listrhs_listr   r(  assignmentsr`  r  rN   refr2   r2   r3   unroll_assignments  s   z'SingleAssignmentNode.unroll_assignmentsc                 C   sx   ddl m} t| j|jsd S tdd | jjD rd S | | jt	| jj|}|s,d S |\}}}| 
||| jj||S )Nr   r  c                 s   s    | ]}|j V  qd S ry   )
is_starredr  r2   r2   r3   r    s    z2SingleAssignmentNode.unroll_rhs.<locals>.<genexpr>)r   r`  rB   r`  rY  anyrL   r@  r  rA   rG  )r   r   r`  unrolledr:  r<  r  r2   r2   r3   r    s   
zSingleAssignmentNode.unroll_rhsc                 C   sl   | j jjrd S ddlm} t| j|jsd S | | j t	| jj
|}|s&d S |\}}}| |||| jj
|S Nr   r  )r`  r9  r.  r   r`  rB   r  rY  r@  rA   rL   rG  )r   r   r`  rJ  r:  r<  r`  r2   r2   r3   r    s   

zSingleAssignmentNode.unroll_lhsc                 C   r  ry   r  r  r   r2   r2   r3   r    r   z1SingleAssignmentNode.generate_rhs_evaluation_codec                 C   s<   | j r| jj| j|| j | j| jd d S | j| j| d S )N)r  r  rq  )r"  r`  r   r  r  rq  )r   rO   r  r2   r2   r3   r     s   
z-SingleAssignmentNode.generate_assignment_codec                 C   r  ry   r  r   r
  r2   r2   r3   r     r  z2SingleAssignmentNode.generate_function_definitionsc                 C      | j | | j| d S ry   r`  r   r  r   r2   r2   r3   r     r5  zSingleAssignmentNode.annotateNr\  r  )rE   ri   rj   r   rA  r"  r  r  r   rm   r@  rG  r  r  r  r   r   r   r2   r2   r2   r3   r    s     
^0^
r  c                   @   s\   e Zd Zg dZdZdZdZdd Zdd Zddd	Z	d
d Z
dddZdd Zdd ZdS )CascadedAssignmentNode)rC  r  coerced_valuescloned_valuesNc                 C   s,   t |tr|jD ]}| ||j qd S d S ry   )rB   rP  rC  r  r  )r   rN   r`  r2   r2   r3   r    s
   

z.CascadedAssignmentNode._check_const_assignmentc                 C   r   ry   )rC  r\  )r   r   r`  r2   r2   r3   r     r  z+CascadedAssignmentNode.analyse_declarationsr   c                 C   s  ddl m}m} t }t| jD ]\}}|| }| j|< || ||j	 q| j
|}t|dkrYtt|jrQ|d|| j
g}	|	sP|| |}n|| |}|jsn|jsn|sh|jsh|j	jrn||}n||}|jrz||n|| _
g | _i }
g | _| jD ]9}|j	jo|d|| j
g}| j| |j	|
vr|j	|j	kr|| j
}|s||j	|}| j| ||
|j	< qg | _| jD ]}|
|j	| j
}| j|| q| S )Nr   )r`  rJ  r  )r`  r`  rJ  r   r  rC  ro   r  r   r9  r  rm   rA   nextiterr\  lookup_operatorr  rm  r   r   r  rH  r#  r$  r  rQ  assignment_overloadsrt  rR  r  )r   r   r%  r`  rJ  	lhs_typesr  r`  r  r'  rQ  
overloadedr2   r2   r3   rm     sT   





z$CascadedAssignmentNode.analyse_typesc                 C   r  ry   rL  r   r2   r2   r3   r  B  r   z3CascadedAssignmentNode.generate_rhs_evaluation_codeFc                 C   s   | j D ]}|| qt| j| j| jD ]\}}}|| |j|||d q| j D ]}|| || q*| j	| | j	| d S )N)r  )
rQ  r  r  rC  rR  rV  r   ri  r  r  )r   rO   r  r  r`  overload	rhs_valuer2   r2   r3   r   E  s   



z/CascadedAssignmentNode.generate_assignment_codec                 C   r  ry   rM  r
  r2   r2   r3   r   T  r  z4CascadedAssignmentNode.generate_function_definitionsc                 C   sR   | j D ]}|| qt| j| jD ]\}}|| || q| j| d S ry   )rQ  r   r  rC  rR  r  )r   rO   r  r`  r2   r2   r3   r   W  s   

zCascadedAssignmentNode.annotater\  r  )rE   ri   rj   r   rR  rQ  rV  r  r   rm   r  r   r   r   r2   r2   r2   r3   rP    s    
1
rP  c                   @   r  )r  r   c                 C   r   ry   r   r   r2   r2   r3   r   p  r  z+ParallelAssignmentNode.analyse_declarationsc                    s0    fdd| j D | _ | j D ]}|| q| S )Nc                    s   g | ]	}|j  d dqS )r   )r%  )rm   r   r   r2   r3   r   u      z>ParallelAssignmentNode.analyse_expressions.<locals>.<listcomp>)r   r  r   r2   r   r3   rn   t  s   

z*ParallelAssignmentNode.analyse_expressionsc                 C   s<   | | j | jD ]}|| q	| jD ]}|| qd S ry   )r  r1   r   r  r   r  r2   r2   r3   r     s   

z.ParallelAssignmentNode.generate_execution_codec                 C   r  ry   r  r  r2   r2   r3   r     r   z4ParallelAssignmentNode.generate_function_definitionsc                 C   r   ry   r  r  r2   r2   r3   r     r  zParallelAssignmentNode.annotateN	rE   ri   rj   r   r   rn   r   r   r   r2   r2   r2   r3   r  `  s    r  c                   @   <   e Zd ZddgZdd Zdd Zdd Zd	d
 Zdd ZdS )InPlaceAssignmentNoder`  r  c                 C   r  ry   r`  r\  r   r2   r2   r3   r     r   z*InPlaceAssignmentNode.analyse_declarationsc                 C   sn   | j || _ | j|| _| jjs| jjr"| j | jj|| _ | S | jjjr5| j	dv r5| j t
j|| _ | S )Nz+-)r  rm   r`  ro   is_memview_indexis_buffer_accessr  r9  	is_stringr+  r
   r  r   r2   r2   r3   rm     s   z#InPlaceAssignmentNode.analyse_typesc                 C   s
  | | j | j| j}}|| || | j}|dkr!d}n
|dkr+t| jd |js1|j	rW|j
jr;t| jd |dv rO|j
jrO|jjd sOt| jd |||| n|jrat| jd	 n|d
| || f  || || || || d S )Nz///z**zNo C inplace power operatorzAIn-place operators not allowed on object buffers in this release.)rc  %	cdivisionz;In-place non-c divide operators not allowed on int buffers.z4Inplace operators not supported on memoryview slicesz
%s %s= %s;)r  r1   r`  r  r   generate_subexpr_evaluation_coder+  r   ra  r`  r9  rH  rd  r   r   generate_buffer_setitem_codeis_memview_slicerJ   r   generate_subexpr_disposal_codefree_subexpr_tempsri  r  )r   rO   r`  r  c_opr2   r2   r3   r     s,   




z-InPlaceAssignmentNode.generate_execution_codec                 C   rN  ry   rO  r   r2   r2   r3   r     r5  zInPlaceAssignmentNode.annotatec                 C   s$   ddl m} || j| j| j| jS rK  )r   r`  
binop_noder1   r+  r`  r  rY  r2   r2   r3   create_binop_node  s   z'InPlaceAssignmentNode.create_binop_nodeN)	rE   ri   rj   r   r   rm   r   r   rm  r2   r2   r2   r3   r^    s    r^  c                   @   s>   e Zd ZddgZdd ZejZdZdd Z	dd	 Z
d
d ZdS )PrintStatNode	arg_tuplerH   c                 C   sd   | j r| j |}||| _ | j|}||| _|t t| jjdkr0| jr0|t	 | S )Nr   )
rH   rn   coerce_to_pyobjectro  r3  printing_utility_coderA   rL   append_newlineprinting_one_utility_code)r   r   rH   ro  r2   r2   r3   rn     s   

z!PrintStatNode.analyse_expressionszPython print statementc              	   C   s   | | j | jr| j| | j }nd}t| jjdkrH| jrH| jjd }|| |	d|| |
| jf  || || n%| j| |	d|| j | j|
| jf  | j| | j| | jr~| j| | j| d S d S )Nr  r   r   z"if (__Pyx_PrintOne(%s, %s) < 0) %sz#if (__Pyx_Print(%s, %s, %d) < 0) %s)r  r1   rH   r  	py_resultrA   ro  rL   rr  rJ   r  ri  r  )r   rO   stream_resultr  r2   r2   r3   r     s@   



z%PrintStatNode.generate_execution_codec                 C   s&   | j r
| j || | j|| d S ry   )rH   r   ro  r
  r2   r2   r3   r     s   z+PrintStatNode.generate_function_definitionsc                 C   s"   | j r	| j | | j| d S ry   )rH   r   ro  r   r2   r2   r3   r        zPrintStatNode.annotateN)rE   ri   rj   r   rn   r|   r   r   r   r   r   r   r2   r2   r2   r3   rn    s    !rn  c                   @   s4   e Zd ZdgZdd ZejZdZdd Z	dd Z
d	S )
ExecStatNoderL   c                 C   sB   t | jD ]\}}||}||}|| j|< q|tj | S ry   )r  rL   rn   rp  r3  r   pyexec_utility_coder   r   r  r  r2   r2   r3   rn   #  s   

z ExecStatNode.analyse_expressionszPython exec statementc                 C   s   | | j g }| jD ]}|| ||  qt|ddgd dt|   }|jj	t
jdd}|d|f|   | jD ]}|| || q@|||| j ||t ||t |j| d S )Nr  r+   Tr  z%s = __Pyx_PyExec3(%s, %s, %s);)r  r1   rL   r  rt  rt  r  rA   r  r  r
   r   rJ   ri  r  r  r  r  r  )r   rO   rL   r  temp_resultr2   r2   r3   r   .  s"   

 

z$ExecStatNode.generate_execution_codec                 C   r   ry   rL   r   rs  r2   r2   r3   r   @  r  zExecStatNode.annotateN)rE   ri   rj   r   rn   r|   r   r   r   r   r   r2   r2   r2   r3   rw    s    rw  c                   @   sB   e Zd ZdgZdZdd Zdd Zdd Zd	Zd
d Z	dd Z
dS )DelStatNoderL   Fc                 C   r   ry   )rL   r\  r  r2   r2   r3   r   M  r  z DelStatNode.analyse_declarationsc                 C   s   t | jD ]S\}}||d  }| j|< |jjs|jr-|jjr-|jr,|jjr,t	|j
d q|jjr<|jjjr<| | q|jjrGt	|j
d q|jrR|jjtju rRqt	|j
d q| S )NzDeletion of global C variablezDeletion of non-heap C++ objectz&Deletion of non-Python, non-C++ object)r  rL   rf  r9  rH  r   rl  r   
is_cglobalr   r1   r1  r:  r\  r   r  rA  r   bytearray_typery  r2   r2   r3   rn   Q  s   zDelStatNode.analyse_expressionsc                 C   s    | j D ]
}|jjr|   qd S ry   )rL   r9  rH  r   r  r2   r2   r3   r   b  s
   
zDelStatNode.nogil_checkzDeleting Python objectc                 C   s   | | j | jD ]>}|jjs|jjs|jr&|jjtj	u r&|j
|| jd q	|jjrG|jjjrG|| |d|   || || q	d S )N)ignore_nonexistingz
delete %s;)r  r1   rL   r9  rH  rl  r  rA  r   r~  generate_deletion_coder  r1  r:  r\  r  rJ   r   ri  r  rs  r2   r2   r3   r   i  s$   



z#DelStatNode.generate_execution_codec                 C   r   ry   r{  rs  r2   r2   r3   r   x  r  zDelStatNode.annotateN)rE   ri   rj   r   r  r   rn   r   r   r   r   r2   r2   r2   r3   r|  E  s    r|  c                   @   s    e Zd Zg Zdd Zdd ZdS )r  c                 C   r|  ry   r2   r   r2   r2   r3   rn     r   z PassStatNode.analyse_expressionsc                 C   r   ry   r2   r   r2   r2   r3   r     r   z$PassStatNode.generate_execution_codeN)rE   ri   rj   r   rn   r   r2   r2   r2   r3   r  }  s    r  c                       s    e Zd ZdZ fddZ  ZS )IndirectionNodez
    This adds an indirection so that the node can be shared and a subtree can
    be removed at any time by clearing self.stats.
    c                    s   t t| j|d j|d d S )Nr   r   )r`   r  r   r1   r  rh   r2   r3   r     s   zIndirectionNode.__init__)rE   ri   rj   rw   r   rk   r2   r2   rh   r3   r    s    r  c                   @   r"  )BreakStatNodeTc                 C   r|  ry   r2   r   r2   r2   r3   rn     r   z!BreakStatNode.analyse_expressionsc                 C   s2   | | j |jst| jd d S ||j d S )Nzbreak statement not inside loop)r  r1   break_labelr   r1  r   r2   r2   r3   r     s   z%BreakStatNode.generate_execution_codeNrE   ri   rj   r   r   rn   r   r2   r2   r2   r3   r    
    r  c                   @   r"  )ContinueStatNodeTc                 C   r|  ry   r2   r   r2   r2   r3   rn     r   z$ContinueStatNode.analyse_expressionsc                 C   s2   |j st| jd d S || j ||j  d S )Nz"continue statement not inside loop)continue_labelr   r1   r  r1  r   r2   r2   r3   r     s
   z(ContinueStatNode.generate_execution_codeNr  r2   r2   r2   r3   r    r  r  c                   @   sV   e Zd ZdgZdZdZdZdZdd Zdd Z	dZ
d	d
 Zdd Zdd Zdd ZdS )r  r   TFc                 C   s   |j }|| _ |st| jd | S | jr=| jrt| jd | j|| _|js)|jr2t| jjd | S | j|j || _| S |jsL|j	sL|jsLt| jd | S )Nz!Return not inside a function bodyz$Return with value in async generatorz"Return with value in void functionzReturn value required)
r  r   r1   r   in_async_genrm   r4  r(  r  rH  )r   r   r  r2   r2   r3   rn     s*   z"ReturnStatNode.analyse_expressionsc                 C   s   | j jr
|   d S d S ry   )r  rH  r   r   r2   r2   r3   r     r   zReturnStatNode.nogil_checkzReturning Python objectc                 C   s  | | j | jsd S | j}| jjr!|tj| j |r!|jr!d }|r|	| | jj
rGddlm} |jtj| j|j||| jd || n7| jrf|jtdd |dtj| f  || n|| |dtj|| jf  || || n7| jjr| jr| jr|jtdd |d	 |d
tj  n|tj| j n| jjr| || jj  |j!" D ]
\}}|#|| q|$|j% d S )Nr   r'  )	lhs_cnamelhs_typelhs_posr  rO   r  ReturnWithStopIterationr  z-%s = NULL; __Pyx_ReturnWithStopIteration(%s);r  r  z/PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration); z
%s = NULL;)&r  r1   r  r   rH  r5  r	   r  r   r  rl  r   r(  put_acquire_memoryviewslicer   r  in_generatorr   r3  r   r  rJ   rt  ri  r  r  r  r  r  r.  r(  
put_returnr  r  temps_holding_referencer  r1  r2  )r   rO   r   r(  r  r9  r2   r2   r3   r     sf   







z&ReturnStatNode.generate_execution_codec                 C   s(   | j r|d |dtj|f  d S )Nz%#pragma omp critical(__pyx_returning)r  )in_parallelputln_openmprJ   r	   r  )r   rO   r   r2   r2   r3   r    s   
zReturnStatNode.put_returnc                 C   s    | j d ur| j || d S d S ry   )r   r   r
  r2   r2   r3   r     s   
z,ReturnStatNode.generate_function_definitionsc                 C   r  ry   )r   r   r   r2   r2   r3   r   !  r  zReturnStatNode.annotateN)rE   ri   rj   r   r   r  r  r  rn   r   r   r   r  r   r   r2   r2   r2   r3   r    s    :r  c                   @   sN   e Zd Zg dZdZdZdZdZdd Ze	j
ZdZdd	 Zd
d Zdd ZdS )RaiseStatNode)exc_type	exc_valueexc_tbcauseTNFc           
      C   s  | j r| j |}||| _ | jrD| j|}| jr>|jtju s%|jjs>ddl	m
} ||j||gdd}|j|dd}||| _| jrS| j|}||| _| jrb| j|}||| _| j r| js| js| j }ddlm	} t||jr|js|jd ur|jjs|j}|jr|jjrddlm}	 |j| _| jdkrd | _ | S | jd	kr|jr|jd
kr|jr|jjr| jsd | _ | S )Nr   rX  T)rL   slow)skip_childrenr  )SymtabMemoryErrorStopIteration__next__)r  rm   rp  r  wrap_tuple_valuer9  r   
tuple_typerm  r`  rY  r1   r  r  r   rB   r  rL   ro  r  r   r   
is_builtinr  rc   builtin_exc_nameis_local_scoper  r  in_try_block)
r   r   r  r  rY  r  r  excr`  r  r2   r2   r3   rn   7  sV   



z!RaiseStatNode.analyse_expressionsRaising exceptionc                 C   sz  | | j | jdkr|d|| j  d S | jdkr8| js8|dtj  |d|d   d|j_	d S | jrS| j
| | j }| jjrR|j| jj nd}| jrd| j
| | j }nd}| jru| j
| | j }nd}| jr| j
| | j }nd}|jt |d||||f  | j| j| j| jfD ]}|r|| || q||| j d S )	Nr  zPyErr_NoMemory(); %sr  z%s = 1;r  Tr  z__Pyx_Raise(%s, %s, %s, %s);)r  r1   r  rJ   r  r  r	   r<  r  r;  r  rt  r   r   use_entry_utility_coder   r  r  r  r3  raise_utility_coderi  r  )r   rO   	type_code
value_codetb_code
cause_codert  r2   r2   r3   r   d  sZ   




z%RaiseStatNode.generate_execution_codec                 C   sh   | j d ur| j || | jd ur| j|| | jd ur$| j|| | jd ur2| j|| d S d S ry   )r  r   r  r  r  r
  r2   r2   r3   r     s   



z+RaiseStatNode.generate_function_definitionsc                 C   sP   | j r	| j | | jr| j| | jr| j| | jr&| j| d S d S ry   )r  r   r  r  r  r   r2   r2   r3   r     s   zRaiseStatNode.annotate)rE   ri   rj   r   r   r  r  r  rn   r|   r   r   r   r   r   r   r2   r2   r2   r3   r  &  s    */
r  c                   @   s.   e Zd Zg ZdZdd ZejZdZ	dd Z
dS )ReraiseStatNodeTc                 C   r|  ry   r2   r   r2   r2   r3   rn     r   z#ReraiseStatNode.analyse_expressionsr  c                 C   s   | | j |jj}|rN|jt ||d t ||d t |	|d t |
dt|  |D ]	}|d|  q5|
  |
|| j d S |jtdd |
d|| j  d S )	Nr   r   r(   &__Pyx_ErrRestoreWithState(%s, %s, %s);z%s = 0; ReRaiseExceptionExceptions.cz__Pyx_ReraiseException(); %s)r  r1   r  exc_varsr   r3  r6  r  r   rH  rJ   r  r  r  r   r  )r   rO   r  varnamer2   r2   r3   r     s    
z'ReraiseStatNode.generate_execution_codeN)rE   ri   rj   r   r   rn   r|   r   r   r   r   r2   r2   r2   r3   r    s    r  c                   @   s@   e Zd Zg dZdZdd Zdd Zdd Zd	d
 Zdd Z	dS )AssertStatNode)	conditionr   	exceptionNc                 C   s4   | j d u s	J d| jd usJ d| j| d S )Nz0Message should have been replaced in PostParse())r   r  r   r   r2   r2   r3   r     s   z#AssertStatNode.analyse_declarationsc                 C       | j || _ | j|| _| S ry   )r  analyse_temp_boolean_expressionr  rn   r   r2   r2   r3   rn        z"AssertStatNode.analyse_expressionsc                 C   s   |j tdd |d |d || j | j| |d| j	   | j
| |d | j| | j| |d |d |d|j| jd	d
  |d d S )NAssertionsEnabledr  z!#ifndef CYTHON_WITHOUT_ASSERTIONSz+if (unlikely(__pyx_assertions_enabled())) {r  r  r  zif ((1)); else %sFr  rS  )r   r3  r   r  rJ   r  r1   r  r  r   r  r   ri  r  r  r   r2   r2   r3   r     s,   



z&AssertStatNode.generate_execution_codec                 C       | j || | j|| d S ry   )r  r   r  r
  r2   r2   r3   r        z,AssertStatNode.generate_function_definitionsc                 C   rN  ry   )r  r   r  r   r2   r2   r3   r     r5  zAssertStatNode.annotate)
rE   ri   rj   r   r  r   rn   r   r   r   r2   r2   r2   r3   r    s    r  c                   @   r]  )
IfStatNode
if_clauseselse_clausec                 C   0   | j D ]}|| q| jr| j| d S d S ry   )r  r   r  )r   r   	if_clauser2   r2   r3   r     
   
zIfStatNode.analyse_declarationsc                    s.    fdd| j D | _ | jr| j | _| S )Nc                    r   r2   r   )r   r  r   r2   r3   r     r   z2IfStatNode.analyse_expressions.<locals>.<listcomp>)r  r  rn   r   r2   r   r3   rn     s   zIfStatNode.analyse_expressionsc                 C   s   | | j | }t| j}| js|d8 }t| jD ]\}}|j||||kd q| jrD| | jj |d | j| |d |	| d S )Nr   )is_last
/*else*/ {r  )
r  r1   r  rA   r  r  r  r   rJ   r3  )r   rO   r  lastr  r  r2   r2   r3   r     s   


z"IfStatNode.generate_execution_codec                 C   s8   | j D ]}||| q| jd ur| j|| d S d S ry   )r  r   r  )r   r   rO   clauser2   r2   r3   r     s
   

z(IfStatNode.generate_function_definitionsc                 C   r  ry   )r  r   r  )r   rO   r  r2   r2   r3   r   "  r  zIfStatNode.annotateNr\  r2   r2   r2   r3   r    s    r  c                   @   s@   e Zd ZddgZdZdd Zdd Zdd	 Zd
d Zdd Z	dS )IfClauseNoder  r   Nc                 C   r  ry   )r   r   r   r2   r2   r3   r   2  r   z!IfClauseNode.analyse_declarationsc                 C   r  ry   )r  r  r   rn   r   r2   r2   r3   rn   5  r  z IfClauseNode.analyse_expressionsc                 C   s   | j | || j | j  }| jrd| j|f }|d|  | j | | j | | j	
| |j| jdd |sG| j	jsG|| |d d S )Nz%s(%s)r  Fr  r  )r  r  r  r1   r   branch_hintrJ   ri  r  r   r   r   r1  )r   rO   r  r  r  r2   r2   r3   r   :  s   

z$IfClauseNode.generate_execution_codec                 C   r  ry   )r  r   r   r
  r2   r2   r3   r   I  r  z*IfClauseNode.generate_function_definitionsc                 C   rN  ry   )r  r   r   r   r2   r2   r3   r   M  r5  zIfClauseNode.annotate)
rE   ri   rj   r   r  r   rn   r   r   r   r2   r2   r2   r3   r  )  s    r  c                   @   s4   e Zd ZddgZdd Zdd Zdd Zd	d
 ZdS )SwitchCaseNode
conditionsr   c                 C   r   ry   )r  r  r   rO   re  r2   r2   r3   "generate_condition_evaluation_codeZ  r  z1SwitchCaseNode.generate_condition_evaluation_codec                 C   s   t | j}|jjd }t| jdD ]\}}|d|   ||j |r/||k r/|d q| j	
| |j| jdd |d d S )Nr  r   zcase %s:r  Fr  r  )rA   r  r   r   r  rJ   r   r  r1   r   r   )r   rO   num_conditionsline_tracing_enabledr  re  r2   r2   r3   r   ^  s   

z&SwitchCaseNode.generate_execution_codec                 C   s*   | j D ]}||| q| j|| d S ry   )r  r   r   )r   r   rO   re  r2   r2   r3   r   k     
z,SwitchCaseNode.generate_function_definitionsc                 C   s&   | j D ]}|| q| j| d S ry   )r  r   r   r  r2   r2   r3   r   p  s   
zSwitchCaseNode.annotateN)rE   ri   rj   r   r  r   r   r   r2   r2   r2   r3   r  R  s    r  c                   @   s,   e Zd Zg dZdd Zdd Zdd ZdS )	SwitchStatNode)testcasesr  c                 C   s   | j | | jD ]}|| q	|| j |d| j    | jD ]}|| q$| j	d urB|d | j	| |d n|d |d | j 
| | j | d S )Nr  r  r  zdefault: break;r  )r  r  r  r  r  r1   rJ   r   r   r  ri  r  r   rO   caser2   r2   r3   r     s   





z&SwitchStatNode.generate_execution_codec                 C   F   | j || | jD ]}||| q
| jd ur!| j|| d S d S ry   )r  r   r  r  )r   r   rO   r  r2   r2   r3   r        

z,SwitchStatNode.generate_function_definitionsc                 C   s@   | j | | jD ]}|| q	| jd ur| j| d S d S ry   )r  r   r  r  r  r2   r2   r3   r     s   

zSwitchStatNode.annotateN)rE   ri   rj   r   r   r   r   r2   r2   r2   r3   r  v  s
    r  c                   @   r7  )LoopNodeNr9  r2   r2   r2   r3   r    r:  r  c                   @   s<   e Zd Zg dZdd Zdd Zdd Zdd	 Zd
d ZdS )WhileStatNode)r  r   r  c                 C   s&   | j | | jr| j| d S d S ry   )r   r   r  r   r2   r2   r3   r     s   z"WhileStatNode.analyse_declarationsc                 C   s:   | j r
| j || _ | j|| _| jr| j|| _| S ry   )r  r  r   rn   r  r   r2   r2   r3   rn     s   z!WhileStatNode.analyse_expressionsc                 C   s   | | j | }|d | jr.| j| | j| |d| j   | j| | j	
| ||j |d |j}|| | jra| | jj |d | j
| |d || d S )Nzwhile (1) {zif (!%s) break;r  r  )r  r1   new_loop_labelsrJ   r  r  ri  r   r  r   r   r3  r  r  set_loop_labelsr  )r   rO   old_loop_labelsr  r2   r2   r3   r     s.   



z%WhileStatNode.generate_execution_codec                 C   sB   | j r
| j || | j|| | jd ur| j|| d S d S ry   )r  r   r   r  r
  r2   r2   r3   r     s   
z+WhileStatNode.generate_function_definitionsc                 C   s8   | j r	| j | | j| | jr| j| d S d S ry   )r  r   r   r  r   r2   r2   r3   r     s   zWhileStatNode.annotateNr\  r2   r2   r2   r3   r    s    r  c                   @   sL   e Zd Zg dZd ZZd ZZd ZZ	dd Z
dd Zdd Zd	d
 ZdS )DictIterationNextNode)
dict_objexpected_sizepos_index_varcoerced_key_varcoerced_value_varcoerced_tuple_var
key_targetvalue_targettuple_targetis_dict_flagNc                 C   s(   t j| |j|||||||dtjd d S )NT)	r  r  r  r  r  r  r  r  r9  r|   r   r1   r
   c_bint_type)r   r  r  r  r  r  r  r  r2   r2   r3   r     s   
zDictIterationNextNode.__init__c                 C   s  ddl m} | j|| _| j|| _| jr| j|| _| jr<| j|| _|| jj	t
j| _| j| jj|| _| jr[| j|| _|j| jj	t
jd| _| j| jj|| _| jry| j|| _|| jj	t
j| _| j| jj|| _| j|| _| S Nr   r  r  )r   r`  r  rm   r  r  r  ro   TempNoder1   r
   r   key_refr  r9  r  r  	value_refr  r  	tuple_refr  r  r   r   r`  r2   r2   r3   rn     s&   z)DictIterationNextNode.analyse_expressionsc                 C   r  ry   )r  r   r
  r2   r2   r3   r     r  z3DictIterationNextNode.generate_function_definitionsc           	      C   s  |j tdd | j| g }g }| j| j| jf| j	| j
| jf| j| j| jffD ]$\}}}|d u r7d}n||||f || d|  }|| q+|jtjd}|d|| j | j | j |d |d |d	 | j f  |d
|  ||d| | j |j| |D ]
\}}}|| q|D ]
\}}}|| q|D ]\}}}||| | | qd S )N	dict_iter
Optimize.cr  r  Fz7%s = __Pyx_dict_iter_next(%s, %s, &%s, %s, %s, %s, %s);r   r   r(   if (unlikely(%s == 0)) break;%s == -1)!r   r3  r   r  r  r  r  r  r  r  r  r  r  r  r  rt  allocater   r  r  r
   r  rJ   rt  r  r  r  error_goto_ifr1   r  generate_gotrefr   release)	r   rO   rE  temp_addressesr  r   r  addrresult_tempr2   r2   r3   r     sH   

z-DictIterationNextNode.generate_execution_code)rE   ri   rj   r   r  r  r  r  r  r  r   rn   r   r   r2   r2   r2   r3   r    s    r  c                   @   s<   e Zd Zg dZd ZZdd Zdd Zdd Zd	d
 Z	dS )SetIterationNextNode)set_objr  r  r  r  is_set_flagNc                 C   s$   t j| |j|||||dtjd	 d S )NT)r  r  r  r  r  r  r9  r  )r   r  r  r  r  r  r2   r2   r3   r   I  s   
zSetIterationNextNode.__init__c                 C   s   ddl m} | j|| _| j|| _| j|| _| j|| _|j| jj	t
jd| _| j| jj|| _| j|| _| S r  )r   r`  r  rm   r  r  r  ro   r  r1   r
   r   r  r  r9  r  r  r  r2   r2   r3   rn   T  s   z(SetIterationNextNode.analyse_expressionsc                 C   r  ry   )r  r   r
  r2   r2   r3   r   _  r  z2SetIterationNextNode.generate_function_definitionsc              
   C   s   |j tdd | j| | j}|| |j	t
jd}|d|| j | j | j | | j f  |d|  ||d| | j |j| || | j| | j| j| || d S )Nset_iterr  Fz/%s = __Pyx_set_iter_next(%s, %s, &%s, &%s, %s);r  r  )r   r3  r   r  r  r  r  r  r  r  r
   r  rJ   rt  r  r   r  r  r  r1   r  r  r  r  r   r  )r   rO   r  r  r2   r2   r3   r   b  s(   

z,SetIterationNextNode.generate_execution_code)
rE   ri   rj   r   r  r  r   rn   r   r   r2   r2   r2   r3   r  A  s    r  c                 K   sB   d|v r|d j rt| fi |S t| fi |S t| fi |S )Niterator)is_asyncAsyncForStatNodeForInStatNodeForFromStatNode)r1   r   r2   r2   r3   ForStatNode}  s
   
r  c                   @   sL   e Zd Zg dZdZdZdd Zdd Zdd	 Zd
d Z	dd Z
dd ZdS )_ForInStatNode)r  r   r  r   r  NFc                 C   s   t d)Nz!must be implemented by subclasses)NotImplementedErrorr   r2   r2   r3   _create_item_node  r  z _ForInStatNode._create_item_nodec                 C   s6   | j | | j| | jr| j| |   d S ry   )r  r\  r   r   r  r  r   r2   r2   r3   r     s
   z#_ForInStatNode.analyse_declarationsc                 C   s   | j || _ | j|| _|   | j|| _| js0| jjjs&| jjj	r0| j j
| jjr0n
| j| j j|| _| j|| _| jrK| j|| _| S ry   )r  ro   r  rn   r  r   r  r9  r1  r2  r  r  r   r  r   r2   r2   r3   rn     s"   z"_ForInStatNode.analyse_expressionsc                 C   s2  | | j | }| j| |d | j| | j| j| | j	
| | | j ||j |d | j| | jrH|dnd }|d}|j|jg|g|pY|| jd}| | j |D ]}| j| qf|| | j| | jr|d || | j
| |d || d S )Nz
for (;;) {r  for_elsefor_end)skip_to_labelr1   r  )r  r1   r  r  r  rJ   r   r  r   r   r   r3  r  ri  r  r  label_interceptorr  r  r  )r   rO   r  
else_labelr  label_interceptsrV  r2   r2   r3   r     s<   






z&_ForInStatNode.generate_execution_codec                 C   sJ   | j || | j|| | j|| | jd ur#| j|| d S d S ry   )r  r   r  r   r  r
  r2   r2   r3   r     s   
z,_ForInStatNode.generate_function_definitionsc                 C   sF   | j | | j| | j| | jr| j| | j| d S ry   )r  r   r  r   r  r   r   r2   r2   r3   r     s   z_ForInStatNode.annotate)rE   ri   rj   r   r   r  r  r   rn   r   r   r   r2   r2   r2   r3   r    s    
'r  c                   @      e Zd ZdZdd ZdS )r  Fc                 C   s   ddl m} || j| _d S )Nr   )NextNode)r`  r  r  r   )r   r  r2   r2   r3   r    r5  zForInStatNode._create_item_nodeN)rE   ri   rj   r  r  r2   r2   r2   r3   r    s    r  c                   @   s    e Zd ZdZdd Zdd ZdS )r  Tc                 K   sH   d|vsJ ddl m} |j|d jd d|d< tj| |fi | d S )Nr   r   r  r  )r  )r   r`  AwaitIterNextExprNoder1   r  r   )r   r1   r   r`  r2   r2   r3   r     s   zAsyncForStatNode.__init__c                 C   s    ddl m} || j| j_d S rK  )r   r`  AsyncNextNoder  r   r  rY  r2   r2   r3   r     s   z"AsyncForStatNode._create_item_nodeN)rE   ri   rj   r  r   r  r2   r2   r2   r3   r    s    r  c                   @   sn   e Zd Zg dZdZdZdZdZdZdd Z	dd Z
d	d
 Zdd Zdd ZdddddZdd Zdd ZdS )r   )r  bound1bound2stepr   r  FNz&For-loop using object bounds or targetc                 C   s*   | j | j| jfD ]
}|jjr|   qd S ry   )r  r  r  r9  rH  r   )r   r   r   r2   r2   r3   r      s
   zForFromStatNode.nogil_checkc                 C   s2   | j | | j| | jr| j| d S d S ry   )r  r\  r   r   r  r   r2   r2   r3   r   %  s
   z$ForFromStatNode.analyse_declarationsc                 C   s   ddl m} | j|| _| j|| _| j|| _| jd ur6t| j|j	r/t
| jjdd | j|| _| | | jj}|jsL|jsLt| jjd | j|| _| jr]| j|| _| S )Nr   r  zdProbable infinite loop in for-from-by statement. Consider switching the directions of the relations.r(   z>for-from loop variable must be c numeric type or Python object)r   r`  r  ro   r  rm   r  r  rB   UnaryMinusNoder   r1   set_up_loopr9  rH  r  r   r   rn   r  )r   r   r`  r   r2   r2   r3   rn   +  s$   


z#ForFromStatNode.analyse_expressionsc                 C   st  ddl m} | jj}|jr|}n?|jrt| jjd |jr t	j
nt	j}| jjjs0t	|| jj}| jjjs=t	|| jj}| jd urO| jjjsOt	|| jj}| j||| _| j||| _| jjsj| j|| _| jd ur| j||| _| jjs| j|| _|js|jrd| _t| j|jrt| jd| j| _d | _d S d| _|| j||}|| _|||| _d S )Nr   r  zWInteger loops over enum values are fragile. Please cast to a safe integer type instead.FzEBuffer or memoryview slicing/indexing not allowed as for-loop target.T)r   r`  r  r9  r  is_enumr   r1   rH  r
   r  r  r  widest_numeric_typer  r  r  r   r#  is_py_targetrB   BufferIndexNoder   loopvar_nodepy_loopvar_noder  r`  rp  )r   r   r`  r   	loop_typec_loopvar_noder2   r2   r3   r  @  sB   



zForFromStatNode.set_up_loopc                 C   s  | | j | }| j}| j| | j| | j| j \}}| j	d ur:| j	| | j	
 }d|d |f }nd}ddlm} t| j|jrO| j| t| j|jr\| j| | jjjrdtjn| jj}|ru| jsu|j|d}	n| j
 }	|jr|js| jd dkr|d|	| j
 |||	| j| j
 ||	|f
  n|d	|	| j
 ||	| j| j
 |	|f  | j}
|
d u r|r|| jj||	}
|
d ur|
| | j|
| | j !| |"|j# |sr| jrr| jj$j%rG|&| jjd }|| |'| jj$j(}| jj$j)j*r|j+,t-.d
d d}n|j+,t-.dd d/| jj$j)j0}|||
 ||1|
 | jjf  |2| n| j}|3| jj|| jj$j)}|	|_4|5| | jj$j%rr|6|
 |j |7| |d |s| jr| j| | j| j| |r| js|j8|	 |j9}|:| | j;r|d | j;!| |d |"| | j<| | j=| | j<| | j=| t| j|jr| j7| t| j|jr| j7| | j	d ur| j	<| | j	=| d S d S )Nz%s=%sr   1r   r  F>z-for (%s = %s%s + %s; %s %s %s + %s; ) { %s%s;z!for (%s = %s%s; %s %s %s; %s%s) {GetModuleGlobalNamer-  z%__Pyx_GetModuleGlobalName(%s, %s); %sGetNameInClassz$__Pyx_GetNameInClass(%s, {}, %s); %sr  r  )>r  r1   r  
from_ranger  r  r  relation_table	relation1r  r   r   r`  rB   r  r  r  r  r  r9  r  r
   r  r  r  r  rd  r  	relation2rJ   r&  r   r   r   r3  r  r   is_pyglobal
PyTempNoder  rc   r  rk  r   r3  r   r  rZ  rj  r  r  CoerceFromPyTypeNode	temp_codegenerate_result_coderG  r  r  r  r  r  ri  r  )r   rO   r  r   offsetincopr  r`  loopvar_typeloopvar_namecoerced_loopvar_nodetarget_nodeinterned_cnamelookup_funcfrom_py_noder  r2   r2   r3   r   f  s   

















z'ForFromStatNode.generate_execution_code)r   ++)z+1r2  )r   --)z-1r3  )z<=r  z>=r  c                 C   sp   | j || | j|| | j|| | jd ur!| j|| | j|| | jd ur6| j|| d S d S ry   )r  r   r  r  r  r   r  r
  r2   r2   r3   r     s   

z-ForFromStatNode.generate_function_definitionsc                 C   s\   | j | | j| | j| | jr| j| | j| | jr,| j| d S d S ry   )r  r   r  r  r  r   r  r   r2   r2   r3   r     s   zForFromStatNode.annotate)rE   ri   rj   r   r  r  r  r   r   r   r   rn   r  r   r!  r   r   r2   r2   r2   r3   r     s&    &s
r   c                   @   s@   e Zd ZdZg dZdZdZdd Zdd Zdd	 Z	d
d Z
dS )WithStatNodea  
    Represents a Python with statement.

    Implemented by the WithTransform as follows:

        MGR = EXPR
        EXIT = MGR.__exit__
        VALUE = MGR.__enter__()
        EXC = True
        try:
            try:
                TARGET = VALUE  # optional
                BODY
            except:
                EXC = False
                if not EXIT(*EXCINFO):
                    raise
        finally:
            if EXC:
                EXIT(None, None, None)
            MGR = EXIT = VALUE = None
    )manager
enter_callr  r   Nc                 C   s(   | j | | j| | j| d S ry   )r5  r   r6  r   r   r2   r2   r3   r     s   z!WithStatNode.analyse_declarationsc                 C   sT   | j || _ | j|| _| jr!ddlm} || jj| jj| _| j	
|| _	| S )Nr   )r  )r5  rm   r6  r  r`  r  r1   r9  target_tempr   rn   )r   r   r  r2   r2   r3   rn     s   z WithStatNode.analyse_expressionsc                 C   s.   | j || | j|| | j|| d S ry   )r5  r   r6  r   r
  r2   r2   r3   r   %  s   z*WithStatNode.generate_function_definitionsc              
   C   s  | | j |d | j| |jjtdd| _|j	
tdd |d| j| j |t| jr5dnd|| j| jf  || jt | }|j}| j| | jr|| j| | j| |d	| j | j f  | j| n| j| | j| | j| | j| ||_| j| | |r|! }|"| |#| |$| jt |"| |#| |j%| j |d
 d S )Nz/*with:*/ {Fr  PyObjectLookupSpecialr-  z-%s = __Pyx_PyObject_LookupSpecial(%s, %s); %s	__aexit____exit__r  r  )&r  r1   rJ   r5  r  r  r  r   exit_varr   r3  r   r  rt  r  r   r  r  r  r  r0  r6  r  r7  r  r  r   r  ri  r  r   r   r/  r  r1  r3  r  r  )r   rO   r  intermediate_error_labelstep_over_labelr2   r2   r3   r   *  sJ   






z$WithStatNode.generate_execution_code)rE   ri   rj   rw   r   r6  r7  r   rn   r   r   r2   r2   r2   r3   r4    s    
r4  c                   @   s<   e Zd ZddgZdZdZdd Zdd Zdd	 Zd
d Z	dS )WithTargetAssignmentStatNoder  r`  Nc                 C   r  ry   r_  r   r2   r2   r3   r   i  r   z1WithTargetAssignmentStatNode.analyse_declarationsc                 C   s4   | j || _ | j | | jj| j j|| _| S ry   )r`  ro   r  	with_noder7  r  r9  r  r   r2   r2   r3   rn   l  s   z0WithTargetAssignmentStatNode.analyse_expressionsc                 C   s.   | j | | j| j | | jj| d S ry   )r  r  r`  r   r?  r7  r  r   r2   r2   r3   r   r  s   z4WithTargetAssignmentStatNode.generate_execution_codec                 C   rN  ry   rO  r   r2   r2   r3   r   w  r5  z%WithTargetAssignmentStatNode.annotate)
rE   ri   rj   r   r?  r  r   rn   r   r   r2   r2   r2   r3   r>  [  s    
r>  c                   @   sJ   e Zd Zg dZdZdd Zdd ZejZ	dZ
dd	 Zd
d Zdd ZdS )TryExceptStatNode)r   except_clausesr  Fc                 C   <   | j | | jD ]}|| q	| jr| j| d S d S ry   )r   r   rA  r  )r   r   except_clauser2   r2   r3   r        
z&TryExceptStatNode.analyse_declarationsc                 C   sr   | j || _ d}t| jD ]\}}|| }| j|< |r$t|jd |js)d}q|| _| jr7| j|| _| S )Nr   zdefault 'except:' must be lastr   )	r   rn   r  rA  r   r1   patternhas_default_clauser  )r   r   default_clause_seenr  rC  r2   r2   r3   rn     s   z%TryExceptStatNode.analyse_expressionszTry-except statementc                    sl    | j  d  j} j} j}  } j} d} d} d}	 d}
|r6 dnd }|r? dnd } d} fd	d
t	dD  
 } d |
 _| _| _| j   j | jdd  d  j } |}|r jt | js|d |d |dddd
 D   D ]}||t q fdd}ndd
 D }|dd|  dd }| _|	 _| jj}| jr  | jj  d | j   d |s| jj}|rA|sD ]} |t q |  | |D ]\}} || q jj}|  j_| jD ]	}| | q*| j_| jsA |  j ||||
|	g|||||g|sZ |sZ|nd | jdd}|D ]	}|rk|  qc |r|s |s |  | |r|   |r |  d D ]	} j!| q| _| _| _| _d S )Nr  exception_handledexcept_errorexcept_return
try_return	try_breaktry_continuetry_endc                    s   g | ]	} j td qS r  r  r  r   r   rV  r  r2   r3   r     r[  z=TryExceptStatNode.generate_execution_code.<locals>.<listcomp>r+   
/*try:*/ {Fr  r  r  r  z__Pyx_ExceptionSave(%s);r   c                 S      g | ]}d | qS r  r2   r  r2   r2   r3   r     r  c                     s.   D ]}   | t q dd  d S )Nz__Pyx_ExceptionReset(%s);r   )rH  r   rJ   r   r*  rO   exc_save_varsr2   r3   restore_saved_exception  s
   
zJTryExceptStatNode.generate_execution_code.<locals>.restore_saved_exceptionc                 S   rR  )z	(void)%s;r2   r  r2   r2   r3   r     r  z%s /* mark used */r?   c                   S   r   ry   r2   r2   r2   r2   r3   rU    r   z/*else:*/ {)r  r1   r  )"r  r1   rJ   r2  r  r  r  r0  r  r  rF   r   r   r  all_free_managed_tempsr/  r   r3  reset_exception_utility_coder  r   put_xgotrefr   r   r  r  r1  r3  current_exceptrA  generate_handling_coderF  r  r  )r   rO   old_return_labelold_break_labelold_continue_labelr  r  except_end_labelexcept_error_labelexcept_return_labeltry_return_labeltry_break_labeltry_continue_labeltry_end_labelsave_exctemps_to_clean_up	can_raiser  rU  mark_vars_usednormal_case_terminates	temp_name	temp_typeouter_exceptrC  r
  rV  r  r2   rS  r3   r     s   



















z)TryExceptStatNode.generate_execution_codec                 C   r  ry   )r   r   rA  r  )r   r   rO   rC  r2   r2   r3   r      r  z/TryExceptStatNode.generate_function_definitionsc                 C   rB  ry   )r   r   rA  r  )r   rO   except_noder2   r2   r3   r      rD  zTryExceptStatNode.annotateN)rE   ri   rj   r   r  r   rn   r|   r   r   r   r   r   r   r2   r2   r2   r3   r@  |  s    wr@  c                   @   sH   e Zd Zg dZdZdZdZdd Zdd Zdd	 Z	d
d Z
dd ZdS )ExceptClauseNode)rE  r  r   r  NFc                 C   s"   | j r	| j | | j| d S ry   )r  r\  r   r   r   r2   r2   r3   r   ;   rv  z%ExceptClauseNode.analyse_declarationsc                 C   s   |j | _| jrt| jD ]\}}||}||| j|< q| jr7ddlm} |	| j
| _| j|| j| _| j|| _| S rK  )r>  rc  rE  r  rn   rp  r  r   r`  ExcValueNoder1   r  rf  r   )r   r   r  rE  r`  r2   r2   r3   rn   @   s   
z$ExceptClauseNode.analyse_expressionsc                    s    | j | jr	tdd | jD  }|r: fddtdD } jtdd  	dt
|  |d	 nd  }| jD ]}|  qAd
d | jD }g }r jtdd t|dkrt|d|d	 |d f  n?|fdd|D  n2t|dkr jtdd |d|d	 |d f  n jtdd |dd |D   jjtjdd} 	d|d|f  | jD ]}|  |  q|r 	dt
|   	ddd |D  |D ]}	 j|	 q 	d|   j| n 	d t| jdds=| jd u r=| jd u r= jtdd  	d  |  	d  d S  fd!dtdD } | j  jt d"t
| }
 	d#|
 | jf  |D ]	}  |t! qi| jr| j"#|d  | j"  | j$| j"  | jd urt%|| jj&D ]
\}}|#| q 'd$} jj(}| j_(| j)  | j_(| jj*s|D ]	} +|t! qÈ |  , - |D ]}t.|D ]\}}|dk r j/n j+|t! qqڈ 0| |D ]	}	 j|	 q 	d  d S )%Nc                 s   s&    | ]}|j p| o|j V  qd S ry   )r   	is_simpler  r   rE  r2   r2   r3   r  T   s
    
z:ExceptClauseNode.generate_handling_code.<locals>.<genexpr>c                       g | ]
} j jtd dqS Tr  rO  rP  r  r2   r3   r   Z       z;ExceptClauseNode.generate_handling_code.<locals>.<listcomp>r+   PyErrFetchRestorer  z__Pyx_ErrFetch(&%s, &%s, &%s);r   c                 S   s   g | ]}|  qS r2   )rt  rq  r2   r2   r3   r   d   r  FastTypeChecksModuleSetupCode.cr(   z.__Pyx_PyErr_GivenExceptionMatches2(%s, %s, %s)r   c                 3   s    | ]	}d  |f V  qdS )z)__Pyx_PyErr_GivenExceptionMatches(%s, %s)Nr2   rq  )r  r2   r3   r  o   s
    

z%__Pyx_PyErr_ExceptionMatches2(%s, %s)PyErrExceptionMatchesc                 s   s    | ]}d | V  qdS )z __Pyx_PyErr_ExceptionMatches(%s)Nr2   rq  r2   r2   r3   r  |   s
    
Fr  r  z || __Pyx_ErrRestore(%s, %s, %s);r?   c                 S   rR  %s = 0;r2   r  r2   r2   r3   r      r  r  z/*except:*/ {r   Tz__Pyx_ErrRestore(0,0,0);r  c                    rr  rs  rO  rP  r  r2   r3   r      rt  z&%s, &%s, &%sz"if (__Pyx_GetException(%s) < 0) %sexcept_)1r  r1   rE  r  r  r   r3  r   r  rJ   r  r  rA   rt  extendr  r  r
   r  r   ri  r  r  r   r   excinfo_targetr  r1  r=  rc  get_exception_utility_coder  rX  r   r  set_varr   r  rL   r  r  r   r   r  r  get_loop_labelsr  r  r  )r   rO   r  has_non_literalsr  rE  patterns	exc_tests
match_flagr  exc_argsr  tempvarrN   r  old_exc_varsrV  r  r2   )rO   r  r3   rZ  P   s   




















 
z'ExceptClauseNode.generate_handling_codec                 C   s*   | j d ur| j || | j|| d S ry   )r  r   r   r
  r2   r2   r3   r      r  z.ExceptClauseNode.generate_function_definitionsc                 C   s>   | j r| j D ]}|| q| jr| j| | j| d S ry   )rE  r   r  r   )r   rO   rE  r2   r2   r3   r      s   
zExceptClauseNode.annotate)rE   ri   rj   r   r  r~  is_except_asr   rn   rZ  r   r   r2   r2   r2   r3   rn  $   s    ~rn  c                   @   s   e Zd Zg dZdZdZdZdZdZdZ	e
dd Zdd	 Zd
d ZejZdZdd Zdd Z	dddZdddZdd Zdd ZdS )TryFinallyStatNode)r   finally_clausefinally_except_clauser   TNFc                 C   s   t | ||d}|S )Nr   r  )r  )r1   r   r   r  rN   r2   r2   r3   r      r  z"TryFinallyStatNode.create_analysedc                 C   s6   | j | t| j| _| j| | j| d S ry   )r   r   r   deepcopyr  r  r   r2   r2   r3   r      s   z'TryFinallyStatNode.analyse_declarationsc                 C   sD   | j || _ | j|| _| j|| _|jr |jjs |j| _| S ry   )r   rn   r  r  r  r4  func_return_typer   r2   r2   r3   rn   !  s   z&TryFinallyStatNode.analyse_expressionszTry-finally statementc                    sP    j  d  j}  }  } j}js| _  } jj	}d j_	j
  | j_	 d  j }  jj  d  | jgffdd	}	joa |}
jj }j
js d |	   jjs |  d |
rH |  d js d	 jr   |rt fd
dtdD } jjtttjdd}nd  }}t fddtdD } ||||   } d  jj}|d d  j_j   | j_ d |r%! ||| |r|D ]	} j"| q|r  j"|  |  #  |D ]	}$ | q-|D ]	} j"| q9 d  |  j%}d}t&t'||D ]\}\}} |sgqY||krq|
rqqY d|  d }||krˈjrt fddtdD } g | jjsˈj(rˈjst)jt*sˈ jjj(dd} d|t+j,f  j(j-rˈ dt+j,  |	   ||kr|r dt+j,|f  j(j-r d|   j"| jr! | |D ]	} j"| qjjs |  d qY |  d d S )NrQ  r   r  z/*finally:*/ {c                    s0   | d }t |}| ju r|| d< |S |}|S r  )r   r  r  )_nextrN   	node_copyr   r2   r3   fresh_finally_clause'!  s   

zHTryFinallyStatNode.generate_execution_code.<locals>.fresh_finally_clausez/*normal exit:*/{z/*exception exit:*/{r  c                    s   g | ]} j jtjd dqS Fr  )r  r  r
   r  rP  r  r2   r3   r   C!  s    z>TryFinallyStatNode.generate_execution_code.<locals>.<listcomp>r(   Fr  c                    rr  r  rO  rP  r  r2   r3   r   K!         r  r+   r2   z%s: {c                    rr  r  rO  rP  r  r2   r3   r   y!  r  r  r{  ).r  r1   rJ   r0  all_new_labelsget_all_labelshandle_error_caser  r  in_try_finallyr   r   rV  r  set_all_labelspreserve_exceptionr/  r   r1  r3  r  is_try_finally_in_nogilr  r  r  r  r
   CPtrTyper  r  put_error_catcherr  r  put_error_uncatcherr  r  put_error_cleanerr2  r  r  r  rB   GILExitNoder	   r  rH  )r   rO   r  
old_labels
new_labelsr  catch_labelwas_in_try_finallyrf  r  preserve_errorneeds_success_cleanupexc_lineno_cnamesexc_filename_cnamer  finally_old_labelsr  r  rV  r2  r  r  	old_labelret_tempr2   )rO   r   r3   r   !  s   



























z*TryFinallyStatNode.generate_execution_codec                 C   s8   | j || | j|| | jr| j|| d S d S ry   )r   r   r  r  r
  r2   r2   r3   r   !  s
   z0TryFinallyStatNode.generate_function_definitionsc           	   	   C   s   |j t |j t |j t | jr|jdd |d |ddd |D  |D ]
\}}|	|| q/|d|dd    |d	|d d d
   |D ]}|
|t qT|rs|d|d tj|d tj|tjf  | jr||  d S d S )NFr  r  r?   c                 S   rR  rz  r2   r  r2   r2   r3   r   !  r  z8TryFinallyStatNode.put_error_catcher.<locals>.<listcomp>z>if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&%s, &%s, &%s);r+   zmif ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&%s, &%s, &%s) < 0)) __Pyx_ErrFetch(&%s, &%s, &%s);r(   %s = %s; %s = %s; %s = %s;r   r   )r   r3  r6  r  swap_exception_utility_coder  r  rJ   r   r  rX  r   r	   lineno_cnameclineno_cnamefilename_cnamer  )	r   rO   rf  r  r  r  rj  r9  r  r2   r2   r3   r  !  s4   



z$TryFinallyStatNode.put_error_catcherc              	   C   s  |j t |j t | jr|jdd |d |d |dd  D ]}||t q%|d|dd    |d |d d D ]}||t qD|d|d d   | jr_|	  |d	
d
d |D  |r|dtj|d tj|d tj|f  d S d S )NFr  r  if (PY_MAJOR_VERSION >= 3) {r+   !__Pyx_ExceptionReset(%s, %s, %s);r  ry  r?   c                 S   rR  rz  r2   r  r2   r2   r3   r   !  r  z:TryFinallyStatNode.put_error_uncatcher.<locals>.<listcomp>r  r   r   )r   r3  r6  rW  r  r  rJ   rH  r   r  r   r	   r  r  r  )r   rO   r  r  r  r  r2   r2   r3   r  !  s.   




z&TryFinallyStatNode.put_error_uncatcherc                 C   s   |j t | jr|jdd |d |d |dd  D ]}||t q|d|dd    |d |d d D ]}||t q>| jrN|	  |d
d	gd |dd    d S )
NFr  r  r  r+   r  r  r?   r{  )r   r3  rW  r  r  rJ   rH  r   r  r  r   )r   rO   r  r  r2   r2   r3   r  !  s   


&z$TryFinallyStatNode.put_error_cleanerc                 C   rN  ry   )r   r   r  r   r2   r2   r3   r   !  r5  zTryFinallyStatNode.annotate)NN)rE   ri   rj   r   r  r  r  r  r  r  r  r   r   rn   r|   r   r   r   r   r   r  r  r  r   r2   r2   r2   r3   r     s,    
 

"r  c                   @   s   e Zd ZdZdZdZdS )NogilTryFinallyStatNodezJ
    A try/finally statement that may be used in nogil code sections.
    FN)rE   ri   rj   rw   r  r   r2   r2   r2   r3   r  !  s    r  c                       sR   e Zd Zdgej ZdZdZdddZdd Z fdd	Z	d
d Z
dd Z  ZS )GILStatNoder  NTc              	   C   s<   || _ || _| ||| tj| ||t||| jdd d S )N)state
state_tempr  )r  r  create_state_temp_if_neededr  r   r  r  )r   r1   r  r   r  r2   r2   r3   r   "  s   
zGILStatNode.__init__c                 C   sZ   ddl m} | }|| |jsd S |dkrtj}ntj}ddlm} |	||| _
d S )Nr   )YieldNodeCollectorgilr  )ParseTreeTransformsr  visitchildrenyieldsr
   c_gilstate_typec_threadstate_ptr_typer   r`  r  r  )r   r1   r  r   r  	collectorrk  r`  r2   r2   r3   r  "  s   
z'GILStatNode.create_state_temp_if_neededc                    sB   | j dk|_| j dkrd|_| jd ur| j| tt| |S )Nr  T)r  _in_with_gil_blockhas_with_gil_blockr  r   r`   r  r   rh   r2   r3   r   )"  s   

z GILStatNode.analyse_declarationsc                 C   sR   | tdd | jd ur| j|| _|j}| jdk|_t| |}||_|S )NForceInitThreadsrw  r  )r3  r   r  r  rn   r  r  r  )r   r   	was_nogilrN   r2   r2   r3   rn   3"  s   

zGILStatNode.analyse_expressionsc                 C   s   | | j |  | jr| j| | j }nd }|jj}| jdkr/|j	|d d|j_n|j
|| j d d|j_t| | | jrK| j| ||j_|  d S )Nr  )variableT)r  unknown_gil_stateF)r  r1   begin_blockr  r  r   r  r  r  r  put_release_gilscope_gil_state_knownr  r   r  	end_block)r   rO   r  old_gil_configr2   r2   r3   r   @"  s"   

z#GILStatNode.generate_execution_codery   )rE   ri   rj   r  r   r  r  r   r  r   rn   r   rk   r2   r2   rh   r3   r  "  s    


r  c                   @   s,   e Zd ZdZg ZdZdZdd Zdd ZdS )r  a  
    Used as the 'finally' block in a GILStatNode

    state   string   'gil' or 'nogil'
    #   scope_gil_state_known  bool  For nogil functions this can be False, since they can also be run with gil
    #                           set to False by GilCheck transform
    NTc                 C   r|  ry   r2   r   r2   r2   r3   rn   g"  r   zGILExitNode.analyse_expressionsc                 C   sD   | j r	| j  }nd }| jdkr|| d S |j|| j d d S )Nr  )r  )r  r   r  r  put_acquire_gilr  )r   rO   r  r2   r2   r3   r   j"  s   
z#GILExitNode.generate_execution_code)	rE   ri   rj   rw   r   r  r  rn   r   r2   r2   r2   r3   r  Z"  s    r  c                   @   r  )EnsureGILNodezI
    Ensure the GIL in nogil functions for cleanup before returning.
    c                 C   s   |j dd d S )NFr  )r  r   r2   r2   r3   r   {"  r   z%EnsureGILNode.generate_execution_codeN)rE   ri   rj   rw   r   r2   r2   r2   r3   r  v"  s    r  c                  C   s   ddl m}  | jS r&  )r   r(  r4  r'  r2   r2   r3   cython_view_utility_code"  s   r  c                   C      t ddS NArrayAPIzarrayarray.hr   r  r2   r2   r2   r3   r  "      r  c                   C   r  r  r  r2   r2   r2   r3   r  "  r  )zcpython.arrayzcpython.array.arrayzcython.view)__Pyx_patch_asyncioPatchAsyncIOr  )__Pyx_patch_inspectPatchInspectr  )asyncioinspectc                 C   s   |j jjjD ]=}|j| jkrq|d}|d}|r|jp"|o"|j}|s'|rC|sC|rC|jj	rCt
| jdd |j tdd  d S qd S )Nimport_array_import_arrayzx'numpy.import_array()' has been added automatically since 'numpy' was cimported but 'numpy.import_array' was not called.r   NumpyImportArrayzNumpyImportArray.c)r   module_noder  r  rc   r  r7  r  r9  r^  r   r1   r3  r   r  )rN   rO   modr  r  r  r2   r2   r3   cimport_numpy_check"  s&   


r  c                   @   s,   e Zd Zg ZdZdd Zdd Zdd ZdS )	CImportStatNodeFc           	      C   s  |j st| jd d S |j| j| j| jrdndd}d| jv ridd | jdD }|d }|j|}|}|dd  D ]}||}|	||| j |}q<| j
r[|	| j
|| j n || |	||| j n| j
pn| j}|	||| j}| j|_| jtv r|t| j   d S d S )	N$cimport only allowed at module levelr   r   relative_levelrs  c                 S   s   g | ]}t |qS r2   r!   )r   rc   r2   r2   r3   r   "  r  z8CImportStatNode.analyse_declarations.<locals>.<listcomp>r   )rk  r   r1   find_moduler  is_absolutery  r  find_submoduledeclare_moduleas_namer  r  utility_code_for_cimportsr3  )	r   r   module_scoper  top_nametop_module_scoperc   submodule_scoper   r2   r2   r3   r   "  s2   



z$CImportStatNode.analyse_declarationsc                 C   r|  ry   r2   r   r2   r2   r3   rn   "  r   z#CImportStatNode.analyse_expressionsc                 C      | j dkrt| | d S d S Nnumpyr  r  r   r2   r2   r3   r   "  r   z'CImportStatNode.generate_execution_codeN)rE   ri   rj   r   r  r   rn   r   r2   r2   r2   r3   r  "  s    r  c                   @   s<   e Zd Zg ZdZdZdZdd Zdd Zdd Z	dd	 Z
dS )
FromCImportStatNodeNc                 C   s  |j st| jd d S |jdd }| jr3| j|kr#t| jd d S | j|kr3|js3t| jd d S |j| j| j| jd}|sBd S |j}|	| | j
D ]g\}}}|dkrjt|j D ]\}}	|||	| q]qM||}	|	rud|	_n2| jd uo~| jdk}
|jj||| jd	|
d
}|sqM|j|u r||p||| j n	t|d||f  |	r|p|}|||	| qM|ds|dr|tv r|t|   | j
D ]\}}}d||f }|tv r|t|   qd S d S )Nr  rs  r   z3relative cimport beyond main package is not allowedz:relative cimport from non-package directory is not allowedr  r  r   F)from_moduler1   absolute_fallbackrelative_importz%Name '%s' not declared in module '%s'cpythoncython%s.%s)rk  r   r1   r>  countr  
is_packager  r  r  imported_namesr   r   r_   r  r  r  r  parent_moduler  r/  r  r3  )r   r   qualified_name_componentsr  r  r1   rc   r  
local_namer   is_relative_importr  rV  fqnamer2   r2   r3   r   "  s^   



z(FromCImportStatNode.analyse_declarationsc                 C   sB   |j sdS |j}|dkr|jsdS dS |jsdS ||jkrdS dS )Nr   classr   )r  r9  r  is_struct_or_unionr  )r   r   r  r9  r2   r2   r3   declaration_matches#  s   
z'FromCImportStatNode.declaration_matchesc                 C   r|  ry   r2   r   r2   r2   r3   rn   &#  r   z'FromCImportStatNode.analyse_expressionsc                 C   r  r  r  r   r2   r2   r3   r   )#  r   z+FromCImportStatNode.generate_execution_code)rE   ri   rj   r   r  r  r  r   r  rn   r   r2   r2   r2   r3   r  "  s    2r  c                   @   s.   e Zd ZdgZdZdd Zdd Zdd Zd	S )
FromImportStatNoder  r   c                 C   s   | j D ];\}}|dkr|jst| jd  d S d|_d| _q|| |jr:| d u r9t	d| j
jj|f |j_qd|j_qd S )Nr  z%import * only allowed at module levelr   r  r   )r_   rk  r   r1   has_import_starimport_starr\  r   r  r   r  r  r   r  )r   r   rc   r  r2   r2   r3   r   :#  s    

z'FromImportStatNode.analyse_declarationsc           	   	   C   sH  ddl m} | j|| _|| jt| _g | _| j	D ]\}}|dkr@|j
	 D ]\}}|js>|jjr>|tdd  nq(q||j}|jr|jj|krt|jdr|jj| jjjkr_qz|j| jjj| j| jjd}|jj|jkrwW qW n	 ty   Y nw ||d }|jtu rd }n| j|j|}| j|||f q| S )Nr   r  r  ExtTypeTestr-  r  )r1   r  )r   r`  r  rn   r&  r1   r   r   interned_itemsr_   r   r  r9  r  r3  r   r  r  rc   r  r  r   r  r   r>  r   rf  r  rt  )	r   r   r`  rc   r  rV  r   r  coerced_itemr2   r2   r3   rn   M#  sB   

z&FromImportStatNode.analyse_expressionsc                 C   s.  | | j | j| | jr!|dtj| j || jf  |j	j
tdd}| j| | jr<|jtdd | jD ]C\}}}|d|| j ||||| jf  ||t |d u rl|| j| n|| || ||| ||t q?|j	| | j| | j| d S )Nzif (%s(%s) < 0) %s;Tr  
ImportFromr  z!%s = __Pyx_ImportFrom(%s, %s); %s)r  r1   r  r  r  rJ   r	   rt  r  r  r  r   r   r3  r  r   r3  r   r  r  r  r  r   allocate_temp_resultr(  r  r  ri  r  )r   rO   	item_temprc   r  r	  r2   r2   r3   r   p#  sF   



z*FromImportStatNode.generate_execution_codeN)rE   ri   rj   r   r  r   rn   r   r2   r2   r2   r3   r  .#  s    	#r  c                   @   s   e Zd ZdZdZdS )ParallelNodez4
    Base class for cython.parallel constructs.
    N)rE   ri   rj   rw   r   r2   r2   r2   r3   r  #  s    r  c                       sJ  e Zd ZdZddgZdZdZdZdZdZ	dZ
ejejejfZejejejfZejejejfZdZ fddZd	d
 Zdd Zdd Zdd Zdd Zd;ddZdd Z dd Z!dd Z"dd Z#d<ddZ$d d! Z%d"d# Z&d$d% Z'd&d' Z(d=d(d)Z)d*d+ Z*d,d- Z+d.d/ Z,d0d1 Z-	d>d2d3Z.d4Z/d5Z0d6e/e0f Z1d7d8 Z2d9d: Z3  Z4S )?ParallelStatNodea  
    Base class for 'with cython.parallel.parallel():' and 'for i in prange():'.

    assignments     { Entry(var) : (var.pos, inplace_operator_or_None) }
                    assignments to variables in this parallel section

    parent          parent ParallelStatNode or None
    is_parallel     indicates whether this node is OpenMP parallel
                    (true for #pragma omp parallel for and
                              #pragma omp parallel)

    is_parallel is true for:

        #pragma omp parallel
        #pragma omp parallel for

    sections, but NOT for

        #pragma omp for

    We need this to determine the sharing attributes.

    privatization_insertion_point   a code insertion point used to make temps
                                    private (esp. the "nsteps" temp)

    args         tuple          the arguments passed to the parallel construct
    kwargs       DictNode       the keyword arguments passed to the parallel
                                construct (replaced by its compile time value)
    r   num_threadsNFr   c                    s@   t t| j|fi | |dpi | _t | _i | _g | _d S )NrE  )	r`   r  r   r  rE  r   seen_closure_varsprivatesassigned_nodesr  rh   r2   r3   r   #  s
   
zParallelStatNode.__init__c              
   C   s>  | j | d | _| jr|g }t }| jjD ]?}|jj|v r't| j	d|jj  |
|jj |jjdkr=|jjs<|j| _q| jrO|jjdkrO|jjsN|j| _q|| q|| j_z	| j|| _W n ty{ } zt| jj	d W Y d }~nd }~ww i | _| j D ]\}}|| jvrt| j	d|  qt| || qd S )Nz$Duplicate keyword argument found: %sr  	chunksizez=Only compile-time values may be supplied as keyword argumentszInvalid keyword argument: %s)r   r   r  rq   r   rH  r   r   r   r1   r   r   	is_pranger  rt  r  	Exceptionr_   valid_keyword_argumentsr   )r   r   pairsseendictitemr2  r   ra  r2   r2   r3   r   #  s>   
z%ParallelStatNode.analyse_declarationsc                 C   s   | j r
| j || _ | jr| j|| _| j|| _| | | j d urt| jr9| jj d ur9| jjs9t| jd n%| jrG| jjsGt| jd n| j j	j
r^| j jr^| j |dkr^t| jd | j  rh| j j	jrt| j tj||| _ | S )Nz-num_threads already declared in outer sectionz;num_threads must be declared in the parent parallel sectionr   z.argument to num_threads must be greater than 0)r  rn   r  r   analyse_sharing_attributesparentr  r   r1   r9  rd  r   r  rp  rH  r  r
   r  r#  r   r2   r2   r3   rn   $  s.   


z$ParallelStatNode.analyse_expressionsc                 C   sj   | j  D ]-\}\}}| jr| js|| jj v rt|d q| js(|r(t|d qd}| |||| qdS )z
        Analyse the privates for this block and set them in self.privates.
        This should be called in a post-order fashion during the
        analyse_expressions phase
        z0Cannot assign to private of outer parallel blockz*Reductions not allowed for parallel blocksTN)rE  r_   r  is_parallelr  r   propagate_var_privatization)r   r   r   r1   r'  lastprivater2   r2   r3   r  )$  s   


z+ParallelStatNode.analyse_sharing_attributesc                 C   sx   ||f| j |< |jjrt|d dS | jr6| js#|| jjvr#| jj}n| j}|r8|s,|r:||||| dS dS dS dS )a
  
        Propagate the sharing attributes of a variable. If the privatization is
        determined by a parent scope, done propagate further.

        If we are a prange, we propagate our sharing attributes outwards to
        other pranges. If we are a prange in parallel block and the parallel
        block does not determine the variable private, we propagate to the
        parent of the parent. Recursion stops at parallel blocks, as they have
        no concept of lastprivate or reduction.

        So the following cases propagate:

            sum is a reduction for all loops:

                for i in prange(n):
                    for j in prange(n):
                        for k in prange(n):
                            sum += i * j * k

            sum is a reduction for both loops, local_var is private to the
            parallel with block:

                for i in prange(n):
                    with parallel:
                        local_var = ... # private to the parallel
                        for j in prange(n):
                            sum += i * j

        Nested with parallel blocks are disallowed, because they wouldn't
        allow you to propagate lastprivates or reductions:

            #pragma omp parallel for lastprivate(i)
            for i in prange(n):

                sum = 0

                #pragma omp parallel private(j, sum)
                with parallel:

                    #pragma omp parallel
                    with parallel:

                        #pragma omp for lastprivate(j) reduction(+:sum)
                        for j in prange(n):
                            sum += i

                    # sum and j are well-defined here

                # sum and j are undefined here

            # sum and j are undefined here
        z9Memoryview slices can only be shared in parallel sectionsN)	r  r9  rl  r   r  r  r  rE  r  )r   r   r1   r'  r  r  r2   r2   r3   r  C$  s   5

	z,ParallelStatNode.propagate_var_privatizationc                 C   s   | j r
| j ||S |j| jv r|jS |j|jd}| j|j | j| | j	||jf |
d||jf  ||_dS )zo
        Helper function that allocate a temporary for a closure variable that
        is assigned to.
        Tr  N)r  _allocate_closure_tempr  r  r  r  r9  r   modified_entriesrt  rJ   )r   rO   r   r  r2   r2   r3   r  $  s   
z'ParallelStatNode._allocate_closure_tempc                 C   sp   d}t | j D ],\}\}}|s5|r||kr5|j }|r5|r'|d d}|d|j|j|f  q	d S )NTz4/* Initialize private variables to invalid values */Fr  )sortedr  r_   r9  invalid_valuerJ   r  r  )r   rO   excluderA  r   r'  r  r"  r2   r2   r3   initialize_privates_to_nan$  s   



z+ParallelStatNode.initialize_privates_to_nanc                 C   s0   | j }|jj}||j_|| ||j_| S ry   )1begin_of_parallel_control_block_point_after_declsr  ownerr  r   )r   rO   r$  r   r&  r2   r2   r3   evaluate_before_block$  s   
z&ParallelStatNode.evaluate_before_blockc                 C   s*   | j dur|d| || j   dS dS )zS
        Write self.num_threads if set as the num_threads OpenMP directive
        Nz num_threads(%s))r  r  r'  r   r2   r2   r3   put_num_threads$  s   
z ParallelStatNode.put_num_threadsc                 C   s2   g | _ t| jD ]}|js|jr| || qdS )a  
        If a variable is in a scope object, we need to allocate a temp and
        assign the value from the temp to the variable in the scope object
        after the parallel section. This kind of copying should be done only
        in the outermost parallel section.
        N)r   r!  rE  from_closurer	  r  )r   rO   r   r2   r2   r3   declare_closure_privates$  s   z)ParallelStatNode.declare_closure_privatesc                 C   s<   | j D ]\}}|d||jf  |j|j ||_qdS )z
        Release any temps used for variables in scope objects. As this is the
        outermost parallel block, we don't need to delete the cnames from
        self.seen_closure_vars.
        r  N)r   rJ   r  r  r  )r   rO   r   r  r2   r2   r3   release_closure_privates$  s
   z)ParallelStatNode.release_closure_privatesr2   c           
      C   s   | j }d| _ | jrl|j  | _}g g }}t|D ]\}}|js$|jr*|| q|| q|r<|	dd
|  |rH|	dd
|  | jrntjg}	| jr`|	| j |	d| j  |	dd
|	  dS dS dS )z
        Make any used temporaries private. Before the relevant code block
        code.start_collecting_temps() should have been called.
        Nz private(%s)r    firstprivate(%s)z private(%s, %s, %s)z shared(%s))privatization_insertion_pointr  r  stop_collecting_tempsr   r!  rH  rl  rt  r  r   breaking_label_usedr	   parallel_whyerror_label_usedr}  parallel_excpos_info)
r   rO   exclude_tempsr   r   r  firstprivatesr  r9  shared_varsr2   r2   r3   privatize_temps$  s*   
z ParallelStatNode.privatize_tempsc                 C   sF   | j r| js|d t| jD ]\}}|j||dd qd S d S d S )Nz/* Clean up any temporaries */Fr  )r  is_nested_prangerJ   r!  r   r  )r   rO   r  r9  r2   r2   r3   cleanup_temps$  s   
zParallelStatNode.cleanup_tempsc                 C   sT   |  | _| | _|j| _|jdd|_|  | | _	| | _
| | dS )a  
        Sets up a block that surrounds the parallel block to determine
        how the parallel section was exited. Any kind of return is
        trapped (break, continue, return, exceptions). This is the idea:

        {
            int why = 0;

            #pragma omp parallel
            {
                return # -> goto new_return_label;
                goto end_parallel;

            new_return_label:
                why = 3;
                goto end_parallel;

            end_parallel:;
                #pragma omp flush(why) # we need to flush for every iteration
            }

            if (why == 3)
                goto old_return_label;
        }
        returnr*  N)r  r  r  r  r2  r[  r  r  rF   %begin_of_parallel_control_block_pointr%  "undef_builtin_expect_apple_gcc_bugr   r2   r2   r3   !setup_parallel_control_flow_block %  s   



z2ParallelStatNode.setup_parallel_control_flow_blockc                 C   s   |  | _dS )a  
        Each OpenMP thread in a parallel section that contains a with gil block
        must have the thread-state initialized. The call to
        PyGILState_Release() then deallocates our threadstate. If we wouldn't
        do this, each with gil block would allocate and deallocate one, thereby
        losing exception information before it can be saved before leaving the
        parallel section.
        N)rF   begin_of_parallel_blockr   r2   r2   r3   begin_parallel_block%%  s   	z%ParallelStatNode.begin_parallel_blockc                 C   s   | j }d| _ | jrW|}|d |jdd |d |d |d |d |d |d	 |  |d | | |  |d
 |d |d dS dS )a  
        To ensure all OpenMP threads have thread states, we ensure the GIL
        in each thread (which creates a thread state if it doesn't exist),
        after which we release the GIL.
        On exit, reacquire the GIL and release the thread state.

        If compiled without OpenMP support (at the C level), then we still have
        to acquire the GIL to decref any object temporaries.
        N#ifdef _OPENMPTr  Py_BEGIN_ALLOW_THREADS#endif /* _OPENMP */Py_END_ALLOW_THREADSr  z{
z#ifndef _OPENMPz}
)r>  r1  rJ   r  put_safer9  r  )r   rO   
begin_codeend_coder2   r2   r3   end_parallel_block0%  s(   











z#ParallelStatNode.end_parallel_blockc           	      C   sX  |  }|  }d| _d| _d| _g | _| }|D ]}||r-| jp(||jk| _d| _q| jr6|| t	|D ]D\}}||sDq:||jk}|
| |rR|sk||jkr_d| _| | |dtj|d f  | jry| jry|sy|| q:|| q:| jr| jr| jr|
| | | |
| |r| jr|dtj  dS dS dS dS )a  
        Trap any kind of return inside a parallel construct. 'should_flush'
        indicates whether the variable should be flushed, which is needed by
        prange to skip the loop. It also indicates whether we need to register
        a continue (we need this for parallel blocks, but not for prange
        loops, as it is a direct jump there).

        It uses the same mechanism as try/finally:
            1 continue
            2 break
            3 return
            4 error
        FTz%s = %d;r   #pragma omp flush(%s)N)r  any_label_usedr/  r1  parallel_private_tempsr  r/  r  r1  r  r3  r0  fetch_parallel_exceptionrJ   r	   r0  r  save_parallel_varsr  )	r   rO   should_flushsave_lastprivates_labeldont_return_label
all_labelsr"  r  is_continue_labelr2   r2   r3   trap_parallel_exitQ%  sP   










z#ParallelStatNode.trap_parallel_exitc                 C   s:  d| j  }|d|  t j d7  _ |  | j}d}t| j D ]s\}\}}|r/|jj	r0q#|jj
rE|jjsE|jjd rE|jd}n|j }d| }	|j}
|d7 }|j }|red|j| }nd}|d	||	|f  | j|	|
|jf |jj
r|jtd
d d|
 }
|d|	|
f  q#|  dS )a  
        The following shenanigans are instated when we break, return or
        propagate errors from a prange. In this case we cannot rely on
        lastprivate() to do its job, as no iterations may have executed yet
        in the last thread, leaving the values undefined. It is most likely
        that the breaking thread has well-defined values of the lastprivate
        variables, so we keep those values.
        z__pyx_parallel_lastprivates%dz#pragma omp critical(%s)r   r   
cpp_localsr   z__pyx_parallel_temp%dr  z%s %s%s;rm  rn  ro  r  N)critical_section_counterr  r  r  r;  r!  r  r_   r9  rH  r\  is_fake_referencer   r   cpp_optional_declaration_coder  r  r"  r  rJ   rJ  rt  r3  r   r  r  )r   rO   section_namer   
temp_countr   r'  r  	type_decl
temp_cnameprivate_cnamer"  rV  r2   r2   r3   rL  %  s8   
	


z#ParallelStatNode.save_parallel_varsc                 C   s   |   |jdd |dtj  |dtj  |d| j  tt| j	| j
 }d|j_|dt|  |tjt |d |  |  dS )	a^  
        As each OpenMP thread may raise an exception, we need to fetch that
        exception from the threadstate and save it for after the parallel
        section where it can be re-raised in the master thread.

        Although it would seem that __pyx_filename, __pyx_lineno and
        __pyx_clineno are only assigned to under exception conditions (i.e.,
        when we have the GIL), and thus should be allowed to be shared without
        any race condition, they are in fact subject to the same race
        conditions that they were previously when they were global variables
        and functions were allowed to release the GIL:

            thread A                thread B
                acquire
                set lineno
                release
                                        acquire
                                        set lineno
                                        release
                acquire
                fetch exception
                release
                                        skip the fetch

                deallocate threadstate  deallocate threadstate
        Tr  rH  r  z'__Pyx_ErrFetchWithState(&%s, &%s, &%s);r  r  N)r  r  r  r	   parallel_exc_typerJ   r2  r   r  parallel_pos_infor3  r  uses_error_indicatorr  r  r   r  r  r   rO   r3  r2   r2   r3   rK  %  s    z)ParallelStatNode.fetch_parallel_exceptionc                 C   sj   |   |jdd |tjt |d| j  tt	| j
| j }|dt|  |  |  dS )zRe-raise a parallel exceptionTr  r  r  N)r  r  r  r	   r\  r   rJ   r2  r   r  r3  r]  r  r  r  r_  r2   r2   r3   restore_parallel_exception%  s   z+ParallelStatNode.restore_parallel_exceptionc                 C   s   | | j| j| jf  dS )z
        Restore all old labels. Call this before the 'else' clause to for
        loops and always before ending the parallel control flow block.
        N)r  r  r[  r  r   r2   r2   r3   restore_labels&  s   zParallelStatNode.restore_labelsc           
      C   s  | j }d| _ d| _| jdur| j| | j| | jrG|d| j  |d| j  |dt	j
  |d |dt	j  |d |rM| j}n| j}|r|dt	j  |d	t	j  |dt	j  | jD ]\}}}	|	jryd
| }|d||f  qm|dt	j  |r|d ||j |r|d ||j |r|d ||j | jr|jt |d | | ||j |d |d |  | | dS )a  
        This ends the parallel control flow block and based on how the parallel
        section was exited, takes the corresponding action. The break_ and
        continue_ parameters indicate whether these should be propagated
        outwards:

            for i in prange(...):
                with cython.parallel.parallel():
                    continue

        Here break should be trapped in the parallel block, and propagated to
        the for loop.
        Nz*const char *%s = NULL; int %s = 0, %s = 0;z,PyObject *%s = NULL, *%s = NULL, *%s = NULL;r  zg/* This may have been overridden by a continue, break or return in another thread. Prefer the error. */z%s = 4;r  zint %s;r{  ro  r  r  z    case 1: z    case 2: z    case 3: z    case 4:)r;  r%  r  ri  r  r1  rJ   r]  r2  r	   r\  r0  rI  r/  rJ  r\  r  r1  r  r  r2  r   r3  r6  r`  r0  r  "redef_builtin_expect_apple_gcc_bug)
r   rO   break_	continue_return_r   rI  rZ  r[  rk  r2   r2   r3   end_parallel_control_flow_block&  sf   







z0ParallelStatNode.end_parallel_control_flow_blockz((defined(__APPLE__) || defined(__OSX__))zQ(defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))))z
(%s && %s)c                 C   s   | j s|| j dS dS )z]
        A bug on OS X Lion disallows __builtin_expect macros. This code avoids them
        N)r  undef_builtin_expectredef_conditionr   r2   r2   r3   r<  d&  s   z3ParallelStatNode.undef_builtin_expect_apple_gcc_bugc                 C   s   | j s|| j d S d S ry   )r  redef_builtin_expectrh  r   r2   r2   r3   rb  k&  r  z3ParallelStatNode.redef_builtin_expect_apple_gcc_bugry   )r2   r  )FFF)5rE   ri   rj   rw   r   r   r  r8  r1  r  r  r	   r\  parallel_exc_valueparallel_exc_tbr2  parallel_filenameparallel_linenoparallel_clinenor]  r  r  r  r3  rT  r   r   rn   r  r  r  r$  r'  r(  r*  r+  r7  r9  r=  r?  rG  rR  rL  rK  r`  ra  rf  buggy_platform_macro_conditionhave_expect_conditionrh  r<  rb  rk   r2   r2   rh   r3   r  #  sd    &G

%
!C5.	
Sr  c                       s2   e Zd ZdZdgZdZ fddZdd Z  ZS )ParallelWithBlockNodezI
    This node represents a 'with cython.parallel.parallel():' block
    r  Nc                    s*   t t| | | jrt| jd d S d S )Nz=cython.parallel.parallel() does not take positional arguments)r`   rq  r   rL   r   r1   r   rh   r2   r3   r   y&  s   z*ParallelWithBlockNode.analyse_declarationsc                 C   s$  |  | | | |d |d | jr+dd | jD }|ddt|  | | _| 	| |d |d |
  | | | | |j  | j| | | | | | | |  ||j}||j}||j}| | | j||||d	 | | d S )
Nr@  z#pragma omp parallel c                 S   s   g | ]	}|j js|jqS r2   )r9  rH  r  )r   r2  r2   r2   r3   r   &  s    zAParallelWithBlockNode.generate_execution_code.<locals>.<listcomp>zprivate(%s)r   r   rB  )rc  rd  re  )r*  r=  rJ   r  r  r   r!  rF   r-  r(  r  r?  r$  r  start_collecting_tempsr   r   rR  r7  rG  r  r/  r  r  r2  ra  rf  r+  )r   rO   r  rd  rc  re  r2   r2   r3   r   &  s:   














z-ParallelWithBlockNode.generate_execution_code)	rE   ri   rj   rw   r  r  r   r   rk   r2   r2   rh   r3   rq  p&  s    rq  c                       s   e Zd ZdZg dZd Z Z ZZd Z	 Z
ZdZdZdZg dZ fddZ fdd	Z fd
dZdd Zdd Zdd Z  ZS )ParallelRangeNodez
    This node represents a 'for i in cython.parallel.prange():' construct.

    target       NameNode       the target iteration variable
    else_clause  Node or None   the else clause of this loop
    )r   r  r  rL   r  r  NT)scheduler  r  r  c                    s&   t t| j|fi | t|| _d S ry   )r`   rs  r   r  r  )r   r1   rM   rh   r2   r3   r   &  s   zParallelRangeNode.__init__c                    s   t t| | | j| | jd ur| j| | jr#t| jdkr+t| j	d d S t| jdkr8| j\| _
nt| jdkrG| j\| _| _
n	| j\| _| _
| _| jdvrat| j	d| jf  d S d S )Nr+   z0Invalid number of positional arguments to pranger   r(   )Nstaticdynamicguidedruntimez'Invalid schedule argument to prange: %s)r`   rs  r   r  r\  r  rL   rA   r   r1   r  rQ   r  rt  r   rh   r2   r3   r   &  s   

z&ParallelRangeNode.analyse_declarationsc                    sL  |j }| j r	d|_ | jd u rt| jd | S | j|| _| jjjs7| jjjs2t| jjd| jj  tj	| _
n| jj| _
d| _| j| j| jf}t|| jD ]1\}}|d ur~|| |jjsgt|jd|  qM|jsu||}t| || t| j
|j| _
qM| jd ur| j|| _t| jdd }|r| jjd f| j| jj< tt| |}|jr|jst|jjd n%|jdkrt|jjd	 n|jjjr|jjr|j|d
krt|jjd |j tj!|||_|j r||_ |j"o|j"j#|_$|j$r$|}|j"r|j"j#r|j"}|j"r|j"j#s|j%|j |j&%|j& |j'(|j' |S )NTz/prange() can only be used as part of a for loopzMust be of numeric type, not %s)rQ   r  r  z%s argument must be numericr   z$Must provide schedule with chunksizerx  z,Chunksize not valid for the schedule runtimer   zChunksize must not be negative))r  r  r   r1   ro   r9  r  rH  r
   r  
index_typer  rQ   r  r  r  rm   r   r#  r   r  r  rn   r   rE  r   r`   rs  r  rt  rd  r  r  r  r  r  r8  r~   r  r  r}  )r   r   r  start_stop_steprN   rc   re  r  rh   r2   r3   rn   &  s   










z%ParallelRangeNode.analyse_expressionsc                 C   sP   d}| j | j| j| jf}t||D ]\}}|d ur%|jjr%t|jd|  qd S )N)rQ   r  r  r  z6%s may not be a Python object as we don't have the GIL)	rQ   r  r  r  r  r9  rH  r   r1   )r   r   r  nodesrc   rN   r2   r2   r3   r   +'  s   zParallelRangeNode.nogil_checkc                 C   s   |  | | jjj}|| jj d}| j| j| jf}d}t	|| j
|D ]!\}}}|du r0|}	n|jr8| }	n	|| | }	|	||< q$|j| jd|d< |j| jd|d< | jdurq| j rq| jjdkrqt|jd n|d	  rt|d	 dkr|d
|  | | |d|  |d|  |  | || |  | | | jr| jr| dt!j"  |  |d | j#| |  | $| || j%f D ]}
|
dur|
&| |
'| q|j(|d  |j(|d  | )| dS )a,  
        Generate code in the following steps

            1)  copy any closure variables determined thread-private
                into temporaries

            2)  allocate temps for start, stop and step

            3)  generate a loop that calculates the total number of steps,
                which then computes the target iteration variable for every step:

                    for i in prange(start, stop, step):
                        ...

                becomes

                    nsteps = (stop - start) / step;
                    i = start;

                    #pragma omp parallel for lastprivate(i)
                    for (temp = 0; temp < nsteps; temp++) {
                        i = start + step * temp;
                        ...
                    }

                Note that accumulation of 'i' would have a data dependency
                between iterations.

                Also, you can't do this

                    for (i = start; i < stop; i += step)
                        ...

                as the '<' operator should become '>' for descending loops.
                'for i from x < i < y:' does not suffer from this problem
                as the relational operator is known at compile time!

            4) release our temps and write back any private closure variables
        )r  r   )r  r  r  NFr  nstepsr   z!Iteration with step 0 is invalid.r  zif (((%(step)s) == 0)) abort();zS%(nsteps)s = (%(stop)s - %(start)s + %(step)s - %(step)s/abs(%(step)s)) / %(step)s;zif (%(nsteps)s > 0)if (%s < 2)z
/* else */)*r*  r  r   r  r9  r  rQ   r  r  r  r  r   re  r  r   r  r  ry  r  r  r   r1   isdigitrf  rJ   r=  r  generate_loopr  ra  r  r/  r  r	   r0  r   rf  r  ri  r  r  r+  )r   rO   target_index_cnamefmt_dictrz  defaultsrN   rc   r(  r   r  r2   r2   r3   r   3'  sX   
(




 





z)ParallelRangeNode.generate_execution_codec           
      C   s  | j r	|d n|d | js |d | | _| jj}n3|d | | _| j}|d |d |  | | | j rI|d n|d |d t	| j
 D ]T\}\}}|r|dv r|| jjkr|jjrwt| jd qZ|d	||jf  qZ|| jjkr|d
|j  |d|j  qZ|jjs|rd}nd}|d||jf  qZ| jr| jrd| || j }nd}|d| j|f  | | |d |d |d|  |  | }	|  |d|  | j|| jjd | jr
| j s
|j  | j| | j|dd | jr$| j s$| | | jr0|	dtj   |!  |!  | jrG| "| |!  d S d S )Nz#if 0r@  z#pragma omp forz#pragma omp parallelr   rB  z+*-&^|z#Python objects cannot be reductionsz reduction(%s:%s)r,  z lastprivate(%s)r  r  z %s(%s)z, %sz schedule(%s%s)z,for (%(i)s = 0; %(i)s < %(nsteps)s; %(i)s++)z=%(target)s = (%(target_type)s)(%(start)s + %(step)s * %(i)s);)r#  T)rM  r}  )#r8  rJ   r  r  rF   r-  r  r  r?  r!  r  r_   r  r   r9  rH  r   r1   r  rt  r  r'  r(  r$  r  rr  r   r   rR  r7  r/  r	   r0  r  rG  )
r   rO   r  reduction_codepointr   r'  r  r  r  guard_around_body_codepointr2   r2   r3   r  '  s~   
















zParallelRangeNode.generate_loop)rE   ri   rj   rw   r   r   r  r  rL   rQ   r  r  r  r  rt  r  r   r   rn   r   r   r  rk   r2   r2   rh   r3   rs  &  s    Vvrs  c                   @   r   )CnameDecoratorNodea?  
    This node is for the cname decorator in CythonUtilityCode:

        @cname('the_cname')
        cdef func(...):
            ...

    In case of a cdef class the cname specifies the objstruct_cname.

    node        the node to which the cname decorator is applied
    cname       the cname the node should get
    rN   c                 C   sF  | j | | j }t|tr|jjd }t|t| _t|tt	f}|j
}| jrG| j|_| j|_d|_|jrCd|jv rE| |j|_d S d S d S |rS| j |_|j_d S |j}| j|_| jd |j_tj| j |j_| jd |j_|jj|jj_|jj|j_| jd |_|j D ]\}}|jr| |j|_|jr| |j|_qd S )Nr   Trs  _obj_typerV  )rN   r   rB   r   r   r   r  is_functionrv  r  r   r  r  r  r<  r  r9  r  ru  r	   typeobj_prefixrv  r  rj  r  r:  r   r_   )r   r   rN   is_struct_or_enumr2  r  rc   r   r2   r2   r3   r   (  s>   
z'CnameDecoratorNode.analyse_declarationsc                 C   s$   d|v r| dd }d| j|f S )Nrs  r   z%s_%s)ry  r  )r   r  r2   r2   r3   r  D(  s   zCnameDecoratorNode.manglec                 C   r  ry   )rN   rn   r   r2   r2   r3   rn   J(  r  z&CnameDecoratorNode.analyse_expressionsc                 C   s   | j r:|jr:|jd }t| jtr| jj|ddd nddlm} | jj	}|j
}|j|_
|j|| |dd ||_
| j|| dS )	z=Ensure a prototype for every @cname method in the right placeutility_code_protoFTr  r   )
ModuleNode)
definitionN)r  r  r   rB   rN   r  r  r   r  r   r  r  generate_cfunction_declarationr   r   )r   r   rO   h_coder  r   r  r2   r2   r3   r   N(  s$   
z0CnameDecoratorNode.generate_function_definitionsc                 C   r  ry   )rN   r   r   r2   r2   r3   r   g(  r   z*CnameDecoratorNode.generate_execution_codeN)
rE   ri   rj   rw   r   r   r  rn   r   r   r2   r2   r2   r3   r  (  s    &r  aC  
/* Test for GCC > 2.95 */
#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
  #define likely(x)   __builtin_expect(!!(x), 1)
  #define unlikely(x) __builtin_expect(!!(x), 0)
#else /* !__GNUC__ or GCC < 2.95 */
  #define likely(x)   (x)
  #define unlikely(x) (x)
#endif /* __GNUC__ */
z1
#define likely(x)   (x)
#define unlikely(x) (x)
Printz
Printing.cPrintOneru  r  RaiseExceptionGetExceptionSwapExceptionSaveResetExceptionAddTracebackzR
static PyObject *__Pyx_GetExceptionTuple(PyThreadState *__pyx_tstate); /*proto*/
a1  
static PyObject *__Pyx_GetExceptionTuple(CYTHON_UNUSED PyThreadState *__pyx_tstate) {
    PyObject *type = NULL, *value = NULL, *tb = NULL;
    if (__Pyx_GetException(&type, &value, &tb) == 0) {
        PyObject* exc_info = PyTuple_New(3);
        if (exc_info) {
            Py_INCREF(type);
            Py_INCREF(value);
            Py_INCREF(tb);
            PyTuple_SET_ITEM(exc_info, 0, type);
            PyTuple_SET_ITEM(exc_info, 1, value);
            PyTuple_SET_ITEM(exc_info, 2, tb);
            return exc_info;
        }
    }
    return NULL;
}
)r  implrequiresr2   )
__future__r   r  rz  r  r   r   	itertoolsr   r   r   Errorsr   r   r   r   r   r	   r
   r   r   r   r  r   r   r   r   r   r   r   r   r   r   r    r]   r   StringEncodingr   r"   r#   r$   Pythranr%   r&   r'   Utilsr)   r*   rK  rf  r   longr  r4   r=   rW   r9  rX   rl   r{   r|   r   r   r   r	  r  r#  r'  r@  rL  rN  rT  rV  rp  r  r  r	  r  r  r"  r6  r  rU  rX  r\  r_  r  rv  r}  r  r  r  r  r  r  r  r  r  r  r  r   r  r  r  r8  r;  rX  r  r  r  r  r)  r  r  rP  r  r^  rn  rw  r|  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r4  r>  r@  rn  r  r  r  r  r  r  r  utility_code_for_importsr  r  r  r  r  r  rq  rs  r  gcc_branch_hintsbranch_prediction_macrosr  rq  rs  r6  r  r  r  rW  traceback_utility_code get_exception_tuple_utility_coder2   r2   r2   r3   <module>   s  4 /+%(#
. s )	g!}'s-[U+!     a   /    G        6 9r v    W&@%  >k2GC)8
s 20)$/<\<
`
 pg! ) 9  #	T	-Td     [6  jc