U
    †µ“eà¶ ã                   @   s˜  d dl mZ d dlZejeeeeeeeeeeeeeeeeeeed 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rfe1Z2ne1e3fZ2ddhZ4dd„ Z5dd„ Z6dd„ Z7G dd„ de8ƒZ9G d d!„ d!e8ƒZ:d"d#„ Z;e;G d$d%„ d%eƒƒZ<G d&d'„ d'e<ƒZ=G d(d)„ d)eƒZ>G d*d+„ d+e<ƒZ?G d,d-„ d-e<ƒZ@G d.d/„ d/e@ƒZAG d0d1„ d1e<ƒZBG d2d3„ d3eBƒZCG d4d5„ d5eBƒZDG d6d7„ d7eBƒZEG d8d9„ d9eEƒZFG d:d;„ d;eEƒZGG d<d=„ d=eBƒZHG d>d?„ d?eBƒZIG d@dA„ dAeBƒZJG dBdC„ dCe<ƒZKG dDdE„ dEe<ƒZLG dFdG„ dGe<ƒZMG dHdI„ dIeLƒZNG dJdK„ dKeLƒZOG dLdM„ dMeLƒZPG dNdO„ dOeLƒZQG dPdQ„ dQeLƒZRG dRdS„ dSeLƒZSG dTdU„ dUeLƒZTG dVdW„ dWeLƒZUG dXdY„ dYe@ƒZVG dZd[„ d[e@ƒZWG d\d]„ d]eWe>ƒZXG d^d_„ d_e@ƒZYG d`da„ dae@ƒZZG dbdc„ dce@ƒZ[G ddde„ dee@e>ƒZ\G dfdg„ dge\ƒZ]G dhdi„ die<ƒZ^G djdk„ dke<ƒZ_G dldm„ dme\ƒZ`G dndo„ doe\ƒZaG dpdq„ dqe`ƒZbG drds„ dsebƒZcG dtdu„ duecƒZdG dvdw„ dwecƒZeG dxdy„ dye`ƒZfG dzd{„ d{e@ƒZgG d|d}„ d}e@e>ƒZhG d~d„ dehƒZiG d€d„ dehƒZjG d‚dƒ„ dƒe@ƒZkG d„d…„ d…e@ƒZlG d†d‡„ d‡e@ƒZmG dˆd‰„ d‰e@ƒZnG dŠd‹„ d‹e@ƒZoG dŒd„ de@ƒZpG dŽd„ depƒZqG dd‘„ d‘epƒZrG d’d“„ d“epƒZsG d”d•„ d•epƒZtG d–d—„ d—e@ƒZuG d˜d™„ d™e@ƒZvG dšd›„ d›e@ƒZwG dœd„ de@ƒZxG dždŸ„ dŸe?ƒZyG d d¡„ d¡e@ƒZzG d¢d£„ d£e@ƒZ{G d¤d¥„ d¥e@ƒZ|G d¦d§„ d§e@ƒZ}G d¨d©„ d©e@ƒZ~G dªd«„ d«e@ƒZG d¬d­„ d­e@ƒZ€G d®d¯„ d¯e<ƒZG d°d±„ d±e@ƒZ‚G d²d³„ d³e@ƒZƒG d´dµ„ dµeƒZ„G d¶d·„ d·e„e@ƒZ…G d¸d¹„ d¹e<ƒZ†G dºd»„ d»e<ƒZ‡d¼d½„ ZˆG d¾d¿„ d¿e„e@ƒZ‰G dÀdÁ„ dÁe‰ƒZŠG dÂdÃ„ dÃe‰ƒZ‹G dÄdÅ„ dÅe„e@ƒZŒG dÆdÇ„ dÇe@ƒZG dÈdÉ„ dÉepƒZŽG dÊdË„ dËe@ƒZG dÌdÍ„ dÍe<ƒZG dÎdÏ„ dÏe@ƒZ‘G dÐdÑ„ dÑe‘ƒZ’G dÒdÓ„ dÓe’ƒZ“G dÔdÕ„ dÕe@ƒZ”G dÖd×„ d×e”ƒZ•dØdÙ„ Z–dÚdÛ„ dÜdÛ„ e–dÝœZ—dÞdßdàœZ˜dádâ„ Z™G dãdä„ däe@ƒZšG dådæ„ dæe@ƒZ›G dçdè„ dèe@ƒZœG dédê„ dêe<ƒZG dëdì„ dìe@eƒZžG dídî„ dîežƒZŸG dïdð„ dðežƒZ G dñdò„ dòe@ƒZ¡e'j¢rdóZ£ndôZ£e# ¤dõdö¡Z¥e# ¤d÷dö¡Z¦e# ¤dødù¡Z§e# ¤dúdù¡Z¨e# ¤dûdù¡Z©e# ¤düdù¡Zªe# ¤dýdù¡Z«e# ¤dþdù¡Z¬e#dÿd e©gdZ­d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   )Zget_filenametable_entry©Úpos© r1   ú9/tmp/pip-unpacked-wheel-7k3cqui1/Cython/Compiler/Nodes.pyÚrelative_position.   s    r3   c                 C   s„   t js
|S dt| ƒ }|d kr&t|ƒS |j}|d k	r\z| |¡ W n tk
rZ   d }Y nX |sjt|ƒ}nt|d | ƒ}||_|S )NzFile: %s (starting at line %s)Ú
)r#   Zembed_pos_in_docstringr3   r   ÚencodingÚencodeÚUnicodeEncodeError)r0   Z	docstringZpos_liner5   Údocr1   r1   r2   Úembed_position2   s     

r9   c                    s   ‡ ‡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  _ˆ| |Ž}| jd8  _||jj 	¡ kr¸| 
| ddd¡¡ | 
|¡ |S ˆ| |ŽS d S )Nr   r(   z(                    /* %s -> %s.%s %s */ú é   z->z<-)ÚlenÚ
isinstanceZ
call_levelÚ	__class__Ú__name__r0   Úinsertion_pointÚbufferÚstreamÚtellÚputlnÚreplace)ÚargsÚkwdsÚnodeÚcodeÚmarkerr@   ÚstartÚres©Úcodewriter_classÚfuncr1   r2   ÚfM   s$    ü

zwrite_func_call.<locals>.fr1   )rO   rN   rP   r1   rM   r2   Úwrite_func_callL   s    rQ   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)ÚtypesrT   ÚCoderU   ÚdictÚitemsr=   rQ   ÚsuperrR   Ú__new__)ÚclsÚnameÚbasesÚattrsrT   rU   ÚmnameÚm©r>   r1   r2   r[   i   s    
zVerboseCodeWriter.__new__)r?   Ú
__module__Ú__qualname__r[   Ú__classcell__r1   r1   rb   r2   rR   f   s   rR   c                       s.   e Zd ZdZedddhƒ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kr$|||ƒ||< q$tt| ƒ | |||¡S )Nr   rS   c                    s   ‡ ‡fdd„}|S )Nc                     s(   ˆ | |Ž}|d kr$t dˆ| |f ƒ |S )Nz%s %s %s)Úprint)rF   ÚkwargsÚretval©rO   r]   r1   r2   Úcall   s    
z3CheckAnalysers.__new__.<locals>.check.<locals>.callr1   )r]   rO   rn   r1   rm   r2   Úcheck~   s    z%CheckAnalysers.__new__.<locals>.check)	rV   rT   rX   rY   r=   ÚmethodsrZ   rf   r[   )r\   r]   r^   r_   rT   ro   r`   ra   rb   r1   r2   r[   |   s    zCheckAnalysers.__new__)r?   rc   rd   Ú__doc__Ú	frozensetrp   r[   re   r1   r1   rb   r2   rf   s   s   ýrf   c                 C   s   t jrttƒ| ƒS | S ©N)r$   Zdebug_trace_code_generationr)   rR   )r\   r1   r1   r2   Ú_with_metaclass   s    rt   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 rs   )r0   Ú__dict__Úupdate)Úselfr0   Úkwr1   r1   r2   Ú__init__´   s    zNode.__init__Z	Operationc                 C   s   t | jd| j ƒ d S )Nz%s not allowed without gil)r   r0   Úgil_message©rx   Úenvr1   r1   r2   Ú	gil_error½   s    zNode.gil_errorc                 C   s   |  ¡ s|  ¡  d S rs   )Zis_cppÚ	cpp_errorr|   r1   r1   r2   Ú	cpp_checkÂ   s    zNode.cpp_checkc                 C   s   t | jd| j ƒ d S )Nz%s only allowed in c++)r   r0   Úcpp_message©rx   r1   r1   r2   r   Æ   s    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 r1   r1   )Ú.0Úxr1   r1   r2   Ú
<listcomp>Ó   s     z#Node.clone_node.<locals>.<listcomp>)r   Úchild_attrsÚgetattrr=   ÚlistÚsetattr)rx   ÚresultÚattrnameÚvaluer1   r1   r2   Ú
clone_nodeÉ   s    



zNode.clone_nodec                 C   s   d S rs   r1   r|   r1   r1   r2   Úanalyse_declarationsî   s    zNode.analyse_declarationsc                 C   s   t d| jj ƒ‚d S )Nz*analyse_expressions not implemented for %s©r   r>   r?   r|   r1   r1   r2   rh   ñ   s    ÿzNode.analyse_expressionsc                 C   s   t d| jj ƒ‚d S )Nz$generate_code not implemented for %sr   ©rx   rI   r1   r1   r2   Úgenerate_codeõ   s    ÿzNode.generate_codec                 C   s   t | tƒr| j |¡ d S rs   )r=   Ú	BlockNodeÚbodyÚannotater   r1   r1   r2   r”   ù   s    
zNode.annotatec              	   C   s˜   z| j W S  tk
r’   | j}| js2|| _ | Y S | jD ]J}t| |ƒ}|d krPq8t|tƒrt|D ]}t|| ¡ ƒ}q^q8t|| ¡ ƒ}q8|| _ | Y S X d S rs   )	Z_end_posÚAttributeErrorr0   r†   r‡   r=   rˆ   ÚmaxÚend_pos)rx   r0   ÚattrÚchildÚcr1   r1   r2   r—   þ   s"    


zNode.end_posr/   éd   c           
   	      sì   ˆ dkrdS ˆdkrt ƒ ‰t| ƒˆkr:d| jjt| ƒf S ˆ t| ƒ¡ ‡ ‡‡‡fdd„‰‡fdd„| j ¡ D ƒ}t|ƒdkr’d	| jjt| ƒf S d
| }d| jjt| ƒf }|D ]$\}}	|d||ˆ|	|d ƒf 7 }q²|d| 7 }|S d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                    sR   t | tƒr|  ˆ ˆˆd ˆ¡S t | tƒrFdd ‡‡ fdd„| D ƒ¡ S t| ƒS d S )Nr   z[%s]ú, c                    s   g | ]}ˆ |ˆƒ‘qS r1   r1   )rƒ   Úitem)Ú
dump_childÚlevelr1   r2   r…   "  s     z1Node.dump.<locals>.dump_child.<locals>.<listcomp>)r=   ru   Údumprˆ   ÚjoinÚrepr)r„   rŸ   ©Úcutoffrž   ÚencounteredÚ
filter_out)rŸ   r2   rž     s
    

zNode.dump.<locals>.dump_childc                    s    g | ]\}}|ˆ kr||f‘qS r1   r1   )rƒ   ÚkeyrŒ   )r¦   r1   r2   r…   &  s      zNode.dump.<locals>.<listcomp>z<%s (0x%x)>z  z<%s (0x%x)
z%s  %s: %s
r   z%s>)ÚsetÚidr>   r?   Úaddrv   rY   r<   )
rx   rŸ   r¦   r¤   r¥   r_   ÚindentrL   r§   rŒ   r1   r£   r2   r      s"    z	Node.dumpú(#)c           	      C   s    | j s
dS | j \}}}|jddd}|td|d ƒ|… }|d }|rb|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)r5   Zerror_handlingr   r+   éÿÿÿÿNz             # <<<<<<<<<<<<<<
r(   z"%s":%d:%d
%s
)r0   Ú	get_linesr–   ÚrstripZget_escaped_descriptionr¡   )	rx   Zmark_columnrJ   Zsource_descÚlineÚcolÚcontentsÚlinesÚcurrentr1   r1   r2   Údump_pos1  s        ÿzNode.dump_pos)N)r   r/   r›   N)Fr¬   ) r?   rc   rd   Úis_nameÚis_noneZis_nonecheckÚ
is_literalÚis_terminatorÚ
is_wrapperÚis_cpropertyÚis_templated_type_nodeÚtempsr†   Úouter_attrsZcf_stateZcoercion_typerz   r{   Únogil_checkÚin_nogil_contextr~   r   r€   r   r   rŽ   rh   r‘   r”   r—   r    r¸   r1   r1   r1   r2   ru   ”   s:   
%
ru   c                   @   s>   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 rs   )Ú
directivesr“   rŽ   ©rx   r}   Úoldr1   r1   r2   rŽ   L  s    z+CompilerDirectivesNode.analyse_declarationsc                 C   s&   |j }| j |_ | j |¡| _||_ | S rs   )rÅ   r“   rh   rÆ   r1   r1   r2   rh   R  s
    z*CompilerDirectivesNode.analyse_expressionsc                 C   s8   |j }|jj }| j |j_ | j ||¡ ||_ ||j_ d S rs   )rÅ   Úglobalstater“   Úgenerate_function_definitions)rx   r}   rI   Zenv_oldZcode_oldr1   r1   r2   rÉ   Y  s    
z4CompilerDirectivesNode.generate_function_definitionsc                 C   s*   |j j}| j|j _| j |¡ ||j _d S rs   )rÈ   rÅ   r“   Úgenerate_execution_code©rx   rI   rÇ   r1   r1   r2   rÊ   a  s    
z.CompilerDirectivesNode.generate_execution_codec                 C   s*   |j j}| j|j _| j |¡ ||j _d S rs   )rÈ   rÅ   r“   r”   rË   r1   r1   r2   r”   g  s    
zCompilerDirectivesNode.annotateN)
r?   rc   rd   rq   r†   rŽ   rh   rÉ   rÊ   r”   r1   r1   r1   r2   rÄ   C  s   rÄ   c                   @   s   e Zd Zdd„ Zdd„ ZdS )r’   c                 C   s.   |  ¡ j}|D ]}|j |¡ q|d d …= d S rs   )Úglobal_scopeZundeclared_cached_builtinsrÈ   Zadd_cached_builtin_decl)rx   r}   rI   ÚentriesÚentryr1   r1   r2   Úgenerate_cached_builtins_declsq  s    
z(BlockNode.generate_cached_builtins_declsc                 C   s   |j D ]}| ||¡ qd S rs   )Zlambda_defsrÉ   )rx   r}   rI   rH   r1   r1   r2   Úgenerate_lambda_definitionsw  s    
z%BlockNode.generate_lambda_definitionsN)r?   rc   rd   rÏ   rÐ   r1   r1   r1   r2   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|Ž}|S rs   )rÑ   )r0   r}   ry   rH   r1   r1   r2   Úcreate_analysed  s    zStatListNode.create_analysedc                 C   s   | j D ]}| |¡ qd S rs   ©rÒ   rŽ   ©rx   r}   Ústatr1   r1   r2   rŽ   †  s    
z!StatListNode.analyse_declarationsc                    s   ‡ fdd„| j D ƒ| _ | S )Nc                    s   g | ]}|  ˆ ¡‘qS r1   ©rh   ©rƒ   rÖ   ©r}   r1   r2   r…     s   ÿz4StatListNode.analyse_expressions.<locals>.<listcomp>©rÒ   r|   r1   rÙ   r2   rh   ‹  s    
ÿz StatListNode.analyse_expressionsc                 C   s   | j D ]}| ||¡ qd S rs   ©rÒ   rÉ   ©rx   r}   rI   rÖ   r1   r1   r2   rÉ   ‘  s    
z*StatListNode.generate_function_definitionsc                 C   s&   | j D ]}| |j¡ | |¡ qd S rs   )rÒ   Úmark_posr0   rÊ   ©rx   rI   rÖ   r1   r1   r2   rÊ   –  s    
z$StatListNode.generate_execution_codec                 C   s   | j D ]}| |¡ qd S rs   ©rÒ   r”   rÞ   r1   r1   r2   r”   œ  s    
zStatListNode.annotateN)r?   rc   rd   r†   ÚstaticmethodrÓ   rŽ   rh   rÉ   rÊ   r”   r1   r1   r1   r2   rÑ   |  s   
rÑ   c                   @   s   e Zd Zdd„ Zdd„ ZdS )ÚStatNodec                 C   s   d S rs   r1   ©rx   r}   rI   r1   r1   r2   rÉ   ®  s    z&StatNode.generate_function_definitionsc                 C   s   t d| jj ƒ‚d S )Nz.generate_execution_code not implemented for %sr   r   r1   r1   r2   rÊ   ±  s    ÿz StatNode.generate_execution_codeN)r?   rc   rd   rÉ   rÊ   r1   r1   r1   r2   rá   ¡  s   rá   c                   @   s:   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   st   |j }d|_ | j |¡ ||_ | js*| jrp| jj}|jd sBd}n|sLd}ntdd„ |D ƒƒ}| | j| j|¡ d S )Nr   Zpreliminary_late_includes_cy28Fc                 s   s   | ]}t |tƒV  qd S rs   )r=   ÚCVarDefNode)rƒ   rH   r1   r1   r2   Ú	<genexpr>Ì  s     z6CDefExternNode.analyse_declarations.<locals>.<genexpr>)	Úin_cincluder“   rŽ   Zinclude_fileZverbatim_includerÒ   rÅ   ÚallÚadd_include_file)rx   r}   Zold_cinclude_flagrÒ   Zlater1   r1   r2   rŽ   ½  s    
z#CDefExternNode.analyse_declarationsc                 C   s   | j  |¡| _ | S rs   ©r“   rh   r|   r1   r1   r2   rh   Ï  s    z"CDefExternNode.analyse_expressionsc                 C   s   | j  ||¡ d S rs   ©r“   rÉ   râ   r1   r1   r2   rÉ   Ô  s    z,CDefExternNode.generate_function_definitionsc                 C   s   d S rs   r1   r   r1   r1   r2   rÊ   ×  s    z&CDefExternNode.generate_execution_codec                 C   s   | j  |¡ d S rs   ©r“   r”   r   r1   r1   r2   r”   Ú  s    zCDefExternNode.annotateN©	r?   rc   rd   r†   rŽ   rh   rÉ   rÊ   r”   r1   r1   r1   r2   rã   ¶  s   rã   c                   @   s$   e Zd Zg ZdZdd„ Zdd„ ZdS )ÚCDeclaratorNoder­   c                 C   s   d S rs   r1   r‚   r1   r1   r2   Údeclared_nameï  s    zCDeclaratorNode.declared_namec                 C   s   d S rs   r1   r‚   r1   r1   r2   Úanalyse_templatesò  s    z!CDeclaratorNode.analyse_templatesN)r?   rc   rd   r†   Úcalling_conventionrî   rï   r1   r1   r1   r2   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   s   | j S rs   ©r]   r‚   r1   r1   r2   rî      s    z!CNameDeclaratorNode.declared_namer   Fc                 C   sª   |rX| j dkrX|js |js |jr.t| jdƒ n*|jrBt| jdƒ n|jdddd| _ t}|j	rœ|j
rœz| |j
¡}W n& tk
rš   t| jd| j  ƒ Y nX || _| |fS )Nr­   úMissing argument nameúJUse spam() rather than spam(void) to declare a function with no arguments.r   )Zfor_displayZpyrexúR'%s' cannot be specialized since its type is not a fused argument to this function)r]   Úis_ptrÚis_arrayÚ	is_bufferr   r0   Úis_voidÚdeclaration_coder   Úis_fusedÚfused_to_specificÚ
specializer   Útype)rx   Ú	base_typer}   ÚnonemptyÚ
visibilityÚin_pxdr1   r1   r2   Úanalyse  s$    ÿÿ
zCNameDeclaratorNode.analyse)r   NF)r?   rc   rd   r†   rò   rî   r  r1   r1   r1   r2   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   s
   | j  ¡ S rs   ©r  rî   r‚   r1   r1   r2   rî     s    z CPtrDeclaratorNode.declared_namec                 C   s
   | j  ¡ S rs   ©r  rï   r‚   r1   r1   r2   rï   "  s    z$CPtrDeclaratorNode.analyse_templatesr   NFc                 C   s2   |j rt| jdƒ t |¡}| jj|||||dS )Nz+Pointer base type cannot be a Python object©r  r  r  )Úis_pyobjectr   r0   r
   Ú
c_ptr_typer  r  )rx   r   r}   r  r  r  Zptr_typer1   r1   r2   r  %  s    
zCPtrDeclaratorNode.analyse)r   NF)r?   rc   rd   r†   rî   rï   r  r1   r1   r1   r2   r    s   r  c                   @   s"   e Zd ZdgZdd„ Zdd„ ZdS )Ú_CReferenceDeclaratorBaseNoder  c                 C   s
   | j  ¡ S rs   r  r‚   r1   r1   r2   rî   /  s    z+_CReferenceDeclaratorBaseNode.declared_namec                 C   s
   | j  ¡ S rs   r  r‚   r1   r1   r2   rï   2  s    z/_CReferenceDeclaratorBaseNode.analyse_templatesN)r?   rc   rd   r†   rî   rï   r1   r1   r1   r2   r  ,  s   r  c                   @   s   e Zd Zddd„ZdS )ÚCReferenceDeclaratorNoder   NFc                 C   s2   |j rt| jdƒ t |¡}| jj|||||dS )Nz-Reference base type cannot be a Python objectr	  )r
  r   r0   r
   Z
c_ref_typer  r  ©rx   r   r}   r  r  r  Zref_typer1   r1   r2   r  7  s    
z CReferenceDeclaratorNode.analyse)r   NF©r?   rc   rd   r  r1   r1   r1   r2   r  6  s   r  c                   @   s   e Zd Zddd„ZdS )Ú CppRvalueReferenceDeclaratorNoder   NFc                 C   s2   |j rt| jdƒ t |¡}| jj|||||dS )Nz4Rvalue-reference base type cannot be a Python objectr	  )r
  r   r0   r
   Zcpp_rvalue_ref_typer  r  r  r1   r1   r2   r  ?  s    
z(CppRvalueReferenceDeclaratorNode.analyse)r   NFr  r1   r1   r1   r2   r  >  s   r  c                   @   s   e Zd ZddgZddd„ZdS )	ÚCArrayDeclaratorNoder  Ú	dimensionr   NFc                    st  |j r| ¡ s|js|jr¤ddlm} t| j|ƒr<| jj}n| jf}‡ fdd„|D ƒ}d |kr~| 	d ¡}	t
||	 jdƒ t}n| | jˆ |¡}| jj|ˆ |||dS | jr| j ˆ ¡| _| jjjsÒt
| jjdƒ | j ¡ }
|
d k	rzt|
ƒ}
W n tk
r   Y nX nd }
| ¡ s*t
| jd| ƒ |jr>t
| jd	ƒ |jrRt
| jd
ƒ t ||
¡}| jj|ˆ |||dS )Nr   ©Ú	TupleNodec                    s   g | ]}|  ˆ ¡‘qS r1   )Úanalyse_as_type)rƒ   ÚvrÙ   r1   r2   r…   U  s     z0CArrayDeclaratorNode.analyse.<locals>.<listcomp>zTemplate parameter not a typer	  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Ú	ExprNodesr  r=   r  rF   Úindexr   r0   r   Úspecialize_herer  r  Úanalyse_const_expressionrÿ   Úis_intÚget_constant_c_result_codeÚintÚ
ValueErrorÚis_completer
  r
   Zc_array_type)rx   r   r}   r  r  r  r  rF   ÚvaluesÚixÚsizeZ
array_typer1   rÙ   r2   r  L  sF    ÿþ





zCArrayDeclaratorNode.analyse)r   NF©r?   rc   rd   r†   r  r1   r1   r1   r2   r  F  s   r  c                   @   sJ   e Zd Zdddg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 )ÚCFuncDeclaratorNoder  rF   Úexception_valuer   Nc                 C   s
   | j  ¡ S rs   r  r‚   r1   r1   r2   rî   †  s    z!CFuncDeclaratorNode.declared_namec                 C   s¬   t | jtƒr¤ddlm}m} | jj}t ||ƒr6|j}n"t ||ƒrH|g}nt|j	dƒ d S g | _
|D ]0}t ||ƒr†| j
 t |j¡¡ qbt|j	dƒ qb| jj| _| j
S d S d S )Nr   )r  ÚNameNodez*Template arguments must be a list of names)r=   r  r  r  r  r*  r  rF   r   r0   Ú	templatesÚappendr
   ÚTemplatePlaceholderTyper]   )rx   r  r*  Útemplate_nodeZtemplate_nodesÚtemplater1   r1   r2   rï   ‰  s"    



z%CFuncDeclaratorNode.analyse_templatesFc                    s¼  |d kri }|r|d8 }g }t ˆjƒD ].\}}	|	jˆ ||dkoNˆ joNdˆ jkd\}
}|
j}||krÂ|| }| ˆ ¡}|d krŽt|jdƒ n4|t	j
k	r¾| |¡s¾tˆjjdƒ t|jdƒ n|}|
jrÔtˆjdƒ |dkrîˆ jrî|jrîˆ j}|jrt	 |j¡}|jrt|	jd	ƒ | t	 |||	j¡¡ |	jrDˆ jd7  _q&ˆjr&tˆjd
ƒ q&d }d}ˆjdkr–ˆ  d¡ ˆ  d¡ ˆ  d¡ ˆ  d¡ n|jr¬ˆjr¬dˆ_|jràˆjsÄˆjràˆjdkràtˆjdƒ nÆˆjd krRˆjrRˆjdkrR|jd k	rR|dkrR|sRˆ jsRtˆjtƒsRd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sÎtˆjjdƒ ˆj}nÊˆj 'ˆ ¡ (|ˆ ¡  ˆ ¡ˆ_ˆj )¡ }|d krtˆjjdƒ | *ˆjj!¡s2tˆjjdƒ |dkr |j+sL|j,r ˆj -¡ r zt.|j/ƒ}W n t0k
r|   Y n$X ˆjj1|kr t2ˆjdˆjj1 ƒ ˆj}|j#rºtˆjdƒ t	j3||ˆj4ˆj||ˆjj5ˆj6ˆj7ˆj8ˆj9ˆj:d}ˆjr |j;r‡ ‡fdd„}||_<nˆ =|ˆ ¡ ˆ jd }|r`|j5}|rZ||krZtˆjd||f ƒ ||_5|j$j>rxt2ˆjd dƒ |jD ](}|j!j>r~| ?¡ s~t2ˆjd!dƒ q~ˆjj|ˆ ||d"S )#Nr   r   rà   ©r  Úis_self_argú
Not a typeú2Signature does not agree with previous declarationúPrevious declaration herez2Function argument cannot have C name specificationrõ   z-Non-default argument follows default argumentú+ZiosÚnewZ	stdexceptZtypeinfoFzAException clause not allowed for function returning Python objectÚextern©Ú	ConstNode©rŒ   rÿ   Ú*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_countr)  Úexception_checkrð   ÚnogilÚwith_gilÚis_overridableÚis_const_methodr+  c                    s   ˆ  | ˆ |¡ d S rs   )Údeclare_optional_arg_struct)Ú	func_typeÚfused_cname©r}   rx   r1   r2   Údeclare_opt_arg_struct  s    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  )@Ú	enumeraterF   r  Úis_c_class_scoperÅ   r]   r  r   r0   r
   r   Úsame_asr  ÚcnameÚis_unspecifiedÚparent_typerø   r  r   rú   r,  ÚCFuncTypeArgrò   r<  r=  rè   r
  r)  r=   r  r  r9  r  rÿ   Úis_errorr  Úreturn_typeÚc_char_typerŒ   rg   Ú	coerce_tor   Úassignable_fromr  Zis_floatÚhas_constant_resultÚfloatÚdefault_valuer"  Úconstant_resultr   Ú	CFuncTypeÚhas_varargsrð   r>  r?  ÚoverridablerA  r+  rü   rF  rB  Úis_rvalue_referenceZis_forwarding_reference)rx   rQ  r}   r  Údirective_localsr  r  Zfunc_type_argsÚiZarg_nodeÚname_declaratorrÿ   r]   Ú	type_nodeÚ
other_typeÚexc_valÚ	exc_checkr9  Zexc_val_typeZtype_default_valuerC  rF  rG  r·   Úargr1   rE  r2   r  Ÿ  s*    þ


ÿÿ


ÿÿþ   ÿÿþýüû
úÿ ÿÿ

ÿ
ÿÿþÿ     ù	
ÿ

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k	r‚t ||¡}| ¡ 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)Zallow_pyobjectZallow_memoryviewÚstructr   )r]   ÚkindÚscopeÚtypedef_flagr0   rL  r   )r   r	   Úpyrex_prefixÚdeclare_varr
   Ú
c_int_typer0   rF   r<   r<  r]   rÿ   ÚmangleZopt_arg_prefixr  Zget_fused_cnamerÌ   Údeclare_struct_or_unionÚdefined_in_pxdÚusedr  Úop_arg_struct)	rx   rC  r}   rD  rg  Zarg_count_memberrd  Zstruct_cnameZop_args_structr1   r1   r2   rB  3  s&    
úz/CFuncDeclaratorNode.declare_optional_arg_struct)r   NNF)N)r?   rc   rd   r†   r[  r<  rA  r+  rî   rï   r  rB  r1   r1   r1   r2   r(  t  s   

 r(  c                   @   s   e Zd ZdgZddd„ZdS )ÚCConstDeclaratorNoder  r   NFc                 C   s2   |j rt| jdƒ t |¡}| jj|||||dS )Nz)Const base type cannot be a Python objectr	  )r
  r   r0   r
   Úc_const_typer  r  )rx   r   r}   r  r  r  Úconstr1   r1   r2   r  Y  s    ÿ
zCConstDeclaratorNode.analyse)r   NFr'  r1   r1   r1   r2   rq  T  s   rq  c                   @   s    e Zd Zddddg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 )ÚCArgDeclNoder   Ú
declaratorrò   Ú
annotationr   r   FNc                 C   s
   | j  ¡ S rs   ©ru  rî   r‚   r1   r1   r2   rî   †  s    zCArgDeclNode.declared_namec                 C   s
   | j  ¡ S rs   )r]   Úas_c_string_literalr‚   r1   r1   r2   Úname_cstring‰  s    zCArgDeclNode.name_cstringc                 C   s.   | j rttj| jj ƒS ttj| jj ƒS d S rs   )Úneeds_conversionr    r	   Z
arg_prefixrÎ   r]   Z
var_prefixr‚   r1   r1   r2   Ú	hdr_cname  s    zCArgDeclNode.hdr_cnamec                 C   sn  |r| | j _| _| jd k	r(| j| jfS t| jtƒr| jjdkr|rŠ| j jrf| 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 ƒ}|rÆ|| j_|jrt| j tƒrt| jtƒr| j}	t|	jtƒr|	j}	qð| j j|	_|j }| jr\|r\|jd r\t| j dd ƒd kr\|  |¡}
|
d k	r\|
}| jj	|||dS )	Nr­   T)Úcould_be_nameFÚarg_nameÚannotation_typingr]   ©r  )r   r1  rÿ   r_  r=   ru  rñ   r]   Úis_basic_c_typer  Úempty_declaration_coder   Úis_argr‡   rø   ÚTemplatedTypeNoder  r  Úarray_declaratorrv  rÅ   Úinject_type_from_annotations)rx   r}   r  r1  rÿ   r}  r|  r   Zbase_arg_nameru  Úarg_typer1   r1   r2   r  —  sJ    


ÿ
þ
ý

zCArgDeclNode.analysec                 C   sÒ   | j }|sd S |j|| jd\}}|d k	r<t|j|dd| _|rÎd|krf| ¡ }|r^| ¡ s^qÎd| _nh|t	krvd| _nX| jrº| jj
rº| ¡ s’|jrº| ¡ s |j}| jsÎt| jdƒ d| _n| jsÎ| ¡ rÎd| _|S )N)Zassigned_valueT)rÿ   r‚  útyping.OptionalzIPEP-484 recommends 'typing.Optional[...]' for arguments that can be None.)rv  Úanalyse_type_annotationrò   ÚCAnalysedBaseTypeNoder0   r   ÚresolveÚcan_be_optionalÚor_noner   rº   Úequivalent_typer   Únot_none)rx   r}   rv  Ú	modifiersr†  r1   r1   r2   r…  É  s6      ÿz)CArgDeclNode.inject_type_from_annotationsc                 C   sJ   | j d krD| jrD| jjr6| j |¡ | j | j ¡ ¡S | | j¡| _ | j S rs   )rW  rò   r»   Úgenerate_evaluation_coderÿ   Ú	cast_coderŠ   Zget_argument_default_constr   r1   r1   r2   Úcalculate_default_value_codeì  s    
z)CArgDeclNode.calculate_default_value_codec                 C   s   | j r| j  |¡ d S rs   )rò   r”   r   r1   r1   r2   r”   ö  s    zCArgDeclNode.annotatec                 C   s’   | j }|d ks|jrd S |d kr*|  |¡}| |¡ | |¡ |rJ| ¡ n
| | j¡}| d||f ¡ | 	| ¡ | j¡ | 
|¡ | |¡ d S ©Nú%s = %s;)rò   r»   r’  r  Úmake_owned_referencerŠ   Ú	result_asrÿ   rD   Úput_giverefÚgenerate_post_assignment_codeÚ
free_temps)rx   rI   ÚtargetÚoverloaded_assignmentrò   rŠ   r1   r1   r2   Úgenerate_assignment_codeú  s    



z%CArgDeclNode.generate_assignment_code)r   F)NF)r?   rc   rd   r†   rÁ   r1  Úis_type_argÚ
is_genericÚis_special_method_optionalÚkw_onlyÚpos_onlyrŽ  rŒ  rÿ   r_  rW  rv  Ú
is_dynamicrî   Úpropertyry  r{  r  r…  r’  r”   rœ  r1   r1   r1   r2   rt  a  s2   

	
2#
rt  c                   @   s   e Zd Zdd„ ZdS )ÚCBaseTypeNodec                 C   s
   |   |¡S rs   ©r  r|   r1   r1   r2   r    s    zCBaseTypeNode.analyse_as_typeN)r?   rc   rd   r  r1   r1   r1   r2   r¤  	  s   r¤  c                   @   s   e Zd Zg Zddd„ZdS )r‰  Fc                 C   s   | j S rs   ©rÿ   )rx   r}   r|  r1   r1   r2   r    s    zCAnalysedBaseTypeNode.analyseN)Fr'  r1   r1   r1   r2   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   sn  d }| j r2t | j| j| j¡}|s.t| jdƒ n®| jdkrJ| jsJt	}n–| jd krp| j
rh|jrh|j}nt	}np|}| jr:| jD ]N}| |¡}|d k	r¶|js¬|jr¶|jjr¶|jj}q‚|rÈ|jrÈ|j}q‚d } qÒq‚|d kr t| jƒdkr ddlm} | | jd ¡}|r |jr ||jƒ}|d kr:| | j| j¡}|rà|jrP| ¡ }| | j¡}|d k	rhnx|r˜| j
r†|jr†|j}nt	}t| jƒ| _nH| jrÎ| j| jkrÀt| jd| j ƒ t | j¡}nt| jd| j ƒ |r|jr|jr|  |j¡}| j!r<|j"r|j#r&t| jdƒ t $|¡}| %|¡ n"|tj&kr^tj'}| %|¡ d| _!|sjt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
   Zsimple_c_typeÚsignedZlongnessr]   r   r0   Úmodule_pathr   r1  rJ  rN  Úlookupr  Úis_typerÿ   rg  Z	as_moduler<   r   r©  Úknown_standard_library_importÚfind_imported_modulerÌ   Zlookup_typer   r}  r+  r-  rü   rý   rþ   ÚcomplexÚ
is_numericÚ
is_complexZCComplexTypeÚcreate_declaration_utility_codeZcomplex_typeZc_double_complex_typer   )	rx   r}   r|  rÿ   rg  r   rÎ   r©  Zfound_entryr1   r1   r2   r  /  s€    


ÿþþ






zCSimpleBaseTypeNode.analyse)F)
r?   rc   rd   r†   r}  r«  r€  r°  r1  r  r1   r1   r1   r2   r§    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 nD tk
rx } z&t|j	|j
ƒ t ¡ | _| j W Y ¢S d }~X Y nX | | j|¡st| _n&t ||¡| _| j | j¡ |  |¡ | jS ©Nr   ©Ú
MemoryView)r¶  r  rP  r­   rº  Zget_axes_specsr·  r   r   ÚpositionZmessage_onlyr
   Z	ErrorTyperÿ   Zvalidate_axesr0   r   ZMemoryViewSliceTypeZvalidate_memslice_dtypeÚuse_memview_utilities)rx   r}   r|  r   rº  Z
axes_specsÚer1   r1   r2   r  Š  s      

zMemoryViewSliceTypeNode.analysec                 C   s   ddl m} | |j¡ d S r¸  )r­   rº  Úuse_utility_codeÚview_utility_code)rx   r}   rº  r1   r1   r2   r¼  ¡  s    z-MemoryViewSliceTypeNode.use_memview_utilitiesN)F)r?   rc   rd   r]   r†   r  r¼  r1   r1   r1   r2   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krtjS |js8t| jd| ƒ tjS |j | j	¡}|rP|j
slt| 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   r0   rg  Úlookup_herer]   r­  rÿ   )rx   r}   r|  r   Ú
type_entryr1   r1   r2   r  ®  s    

zCNestedBaseTypeNode.analyse)Nr'  r1   r1   r1   r2   rÀ  ¦  s   rÀ  c                   @   s>   e Zd Zddddg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 ]ž}| |p>t|tƒ¡ | |¡}W 5 Q R X |d krx|jr¾t|j	dƒ t
}nF|r‚|jrŽ|r¾| ¡ s¾|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_contextrÃ  Znew_c_type_contextr=   r¤  r  r  r   r0   r   r
  r‹  r  Úas_cython_attributer,  )	rx   r}   r   Zrequire_optional_typesZrequire_python_typesrÆ  Útemplate_typesr.  Úttyper1   r1   r2   Ú_analyse_template_typesÌ  s*    


þz)TemplatedTypeNode._analyse_template_typesFc           
      C   sú  |d kr| j  |¡}|jr|S |jr,| ¡ s2|jrŽ| jrl| jjrl|jrJdnd}t| j	d| ƒ t
j| _| jS |  ||¡}| | j	||¡| _n|jrddlm} | | j	|| j| j|j¡}tjd dk ràtdd	„ | ¡ D ƒƒ}t
j|f|Ž| _t|ƒrœt| jƒrœt
 t| jƒ| j¡| _n~t| j	d
d d}t| jƒdksH| jjr^t| j	dƒ t
j| _n>| jsld }	n
| jd }	t | j	||	d| _!| j! ||¡d | _| jrô| jj"rô|j#rôz| j $|j#¡| _W n( t%k
rò   t| j	d| j& ƒ Y nX | jS )Nzc++ templateszindexed typesz %s cannot take keyword argumentsr   ©ÚBufferr   r+   c                 S   s   g | ]\}}|  d ¡|f‘qS )r®   )r6   )rƒ   r]   rŒ   r1   r1   r2   r…     s   ÿz-TemplatedTypeNode.analyse.<locals>.<listcomp>r­   ©r]   rL  zinvalid array declaration)r  r  rö   )'r¶  r  rP  r  r  r  rÄ  Úkey_value_pairsr   r0   r
   r   rÿ   rÊ  r  r
  r­   rÌ  Úanalyse_buffer_optionsrÃ  Úbuffer_defaultsr   Úversion_inforX   rY   Z
BufferTyper%   r'   ZPythranExprr&   rñ   r<   r  r„  rü   rý   rþ   r   r]   )
rx   r}   r|  r   ÚtprÈ  rÌ  ÚoptionsZempty_declaratorr  r1   r1   r2   r  é  sj     ÿûÿ

ýÿÿ
zTemplatedTypeNode.analysec                 C   sV   g }| }|j rR|jrRt|jƒdkrR| j |¡}|jrF|jrF| |j¡ |jd }q|S )Nr   r   )r¿   r¶  r<   rÃ  r  r  Zmodifier_namer,  )rx   r}   r  Zmodifier_nodeZmodifier_typer1   r1   r2   Úanalyse_pytyping_modifiers+  s    z,TemplatedTypeNode.analyse_pytyping_modifiers)FN)
r?   rc   rd   r†   r¿   rÅ  r]   rÊ  r  rÔ  r1   r1   r1   r2   rƒ  ¼  s   	 ÿ
Brƒ  c                   @   s   e Zd ZddgZddd„ZdS )ÚCComplexBaseTypeNoder   ru  Fc                 C   s$   | j  ||¡}| j ||¡\}}|S rs   )r   r  ru  )rx   r}   r|  r  Ú_rÿ   r1   r1   r2   r  ?  s    zCComplexBaseTypeNode.analyseN)Fr'  r1   r1   r1   r2   rÕ  9  s   rÕ  c                   @   s   e Zd ZdgZddd„ZdS )ÚCTupleBaseTypeNodeÚ
componentsFc                 C   sX   g }| j D ]2}| |¡}|jr2t|jdƒ t  S | |¡ q
| | j|¡}d|_|j	S )Nz/Tuple types can't (yet) contain Python objects.T)
rØ  r  r
  r   r0   r   r,  Zdeclare_tuple_typero  rÿ   )rx   r}   r|  Zcomponent_typesrš   rÿ   rÎ   r1   r1   r2   r  J  s    

zCTupleBaseTypeNode.analyseN)Fr'  r1   r1   r1   r2   r×  E  s   r×  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_typedefr]   r0   ræ   )rx   r}   rÿ   rÎ   r1   r1   r2   rŽ   c  s    
z"FusedTypeNode.analyse_declarationsFc                 C   s\   g }| j D ]@}| |¡}|s*t|jdƒ q
||kr@t|jdƒ q
| |¡ q
tj|| jdS )Nr2  zType specified multiple timesró   )rV   r  r   r0   r,  r
   Ú	FusedTyper]   )rx   r}   r|  rV   r`  rÿ   r1   r1   r2   r  j  s    

zFusedTypeNode.analyseN)F)r?   rc   rd   rq   r†   rŽ   r  r1   r1   r1   r2   rÙ  W  s   	rÙ  c                   @   s   e Zd ZdgZddd„ZdS )Ú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  r
  r   r0   r
   Zc_const_or_volatile_typeÚis_constZis_volatile)rx   r}   r|  r  r1   r1   r2   r  …  s    ÿz CConstOrVolatileTypeNode.analyseN)Fr'  r1   r1   r1   r2   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   sR  | j d kri | _ |s|}|| _| jr4| jd  ¡ }nd }|d k	r¦| jdkrVt| jdƒ t| jƒdkrvt| jd jdƒ td|ƒ}|j	j
|_
|D ]}| |j|| j¡ qŽ| j |¡}d }| jjrÊ| j |¡}|jrò| jsò|jsâ|jròt| jdƒ tS d | _| j}| jD ]F}t| jƒdkr@t|tƒs@|j
d r@t|jd	dƒ | joX| jdkoX|j}	|	rfd
|_t|tƒr|j||| j || jd\}
}n|j|||| jd\}
}| ¡ sÞ| jdkrÆ|jsÞ|jsÞt|jd| ƒ | jdkrþ|jrþt|jdƒ |
j}|
j }|dkr&t|jdƒ  d S |j!rF| jdkrFt|jdƒ |j"rf| jdkrft|jdƒ |j#räd|j
kr€d|_$|j%|||j|| j| j| j&| j'| jd	| _| jd k	rÆt( (| j ¡| j_ |	rJ| jj) *|¡ d| j_+nf| jrøt| jdƒ | j rt| jdƒ |j,|||j||| j| j&d|d	| _t-j.rt/| j| j0ƒ| j_0qd S )Nr   r7  zOnly extern functions allowedr   z%Can't multiply declare template typesZfunc_templatezFused types not allowed herezwarn.multiple_declaratorsz‰Non-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  rH  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)rL  r  r  Úapir  r[  z>Variables cannot be declared with 'cpdef'. Use 'cdef' instead.z,Decorators can only be followed by functions)rL  r  r  rß  Úis_cdefZpytyping_modifiers)1r]  Ú
dest_scoperÞ  rï   r  r   r0   r<   r   Úouter_scoperÅ   Zdeclare_typer]   r   r  r¿   rÔ  rü   r  rJ  Úis_module_scoper   rÎ   r=   rñ   r   r[  r(  r#  rø   Úis_memoryviewslicer
  rL  Zis_referencer\  r  Úis_static_methodÚdeclare_cfunctionrß  r  r   rÿ   Úcreate_to_py_utility_codeÚcreate_wrapperrj  r#   Ú
docstringsr9   r8   )rx   r}   rá  r+  Ztemplate_paramr   r  r  ru  Zcreate_extern_wrapperr_  rÿ   r]   rL  r1   r1   r2   rŽ      sÜ    



ÿÿþýÿþ    ÿ   ÿ


      ý
      ýz CVarDefNode.analyse_declarations)N)r?   rc   rd   r†   Ú
decoratorsr]  rŽ   r1   r1   r1   r2   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  rß  Úpacked)
rm  r]   rf  rh  r0   rL  r  rß  rí  rÎ   ©rx   r}   rg  r1   r1   r2   Údeclare  s          ýzCStructOrUnionDefNode.declarec                 C   s    d }| j d k	rt| jƒ}|  ||¡ | j d k	rœ| jrB|jsBd| j_| j D ]}| ||¡ qH| j	dkrœ|j
D ]0}|j}|jr‚|j}qt|| jjkrjt|jdƒ qjd S )Nr   r7  z)Struct cannot contain itself as a member.)rì  r   r]   rï  r  ræ   rÎ   rn  rŽ   r  Úvar_entriesrÿ   rø   r   r   r0   )rx   r}   rg  r˜   rÿ   r1   r1   r2   rŽ     s     





z*CStructOrUnionDefNode.analyse_declarationsc                 C   s   | S rs   r1   r|   r1   r1   r2   rh   &  s    z)CStructOrUnionDefNode.analyse_expressionsc                 C   s   d S rs   r1   r   r1   r1   r2   rÊ   )  s    z-CStructOrUnionDefNode.generate_execution_code)N)r?   rc   rd   r†   rï  rŽ   rh   rÊ   r1   r1   r1   r2   rë     s
   
rë  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 krd }nRdd„ | j D ƒ}tdd„ | j D ƒƒ}|rbtdd„ | j d | … D ƒƒsbt| jdƒ |j| jd | j| jg | j|d| _	d S )Nc                 S   s   g | ]\}}t  || ¡‘qS r1   ©r
   r-  ©rƒ   Útemplate_nameÚrequiredr1   r1   r2   r…   ?  s   ÿz(CppClassNode.declare.<locals>.<listcomp>c                 s   s   | ]\}}| V  qd S rs   r1   ©rƒ   rÖ  rõ  r1   r1   r2   rå   A  s     z'CppClassNode.declare.<locals>.<genexpr>c                 s   s   | ]\}}|V  qd S rs   r1   rö  r1   r1   r2   rå   B  s     zGRequired template parameters must precede optional template parameters.)Úbase_classesr  r+  )
r+  Úsumrç   r   r0   Údeclare_cpp_classr]   rL  r  rÎ   )rx   r}   rÈ  Znum_optional_templatesr1   r1   r2   rï  ;  s"    
ÿ"     þzCppClassNode.declarec           
   	      sx  ˆj d krd  }}n dd„ ˆj D ƒ}dd„ ˆj D ƒ}d ‰ˆjd k	rRtˆjˆ |d‰‡fdd„}t|‡ ‡fdd„ˆjD ƒƒ}ˆ jˆjˆˆjˆj|ˆj	|dˆ_
ˆj
d krªd S d	ˆj
_ˆd k	rÄˆj
jˆ_g }‡fd
d„‰ˆjd k	r^ˆjrôˆ jsôd	ˆj
_ˆjD ]*}t|dd ƒ}|r| ˆ¡ | ˆ¡ qúˆˆjƒD ],}	| |	¡ ˆj d k	r0dd |¡ |	_q0tˆj|dˆ_ˆˆ_d S )Nc                 S   s   g | ]\}}|‘qS r1   r1   )rƒ   rô  rÖ  r1   r1   r2   r…   L  s     z5CppClassNode.analyse_declarations.<locals>.<listcomp>c                 S   s   g | ]\}}t  || ¡‘qS r1   rò  ró  r1   r1   r2   r…   M  s   ÿ)r+  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   r0   )Z
base_classr‚   r1   r2   Úbase_okR  s    z2CppClassNode.analyse_declarations.<locals>.base_okc                    s   g | ]}|  ˆpˆ ¡‘qS r1   r¥  )rƒ   Úb)r}   rg  r1   r2   r…   W  s     )r  r+  r   c                 3   sn   | D ]d}t |tƒr|V  qt |tƒr>ˆ |jjƒD ]
}|V  q0qt |tƒr|jd k	rˆ |jƒD ]
}|V  q\qd S rs   )r=   ÚCFuncDefNoderÄ   r“   rÒ   rñ  rì  )rì  r˜   Zsub_attr)Úfunc_attributesr1   r2   rþ  a  s    


z:CppClassNode.analyse_declarations.<locals>.func_attributesrï  ztemplate <typename %s>z, typename rÚ   )r+  rì  r   r]   Úfilterr÷  rù  r0   rL  r  rÎ   r  rÿ   r  ræ   rn  r‡   rï  rŽ   r,  r¡   Útemplate_declarationrÑ   r“   rg  )
rx   r}   rÈ  Ztemplate_namesrû  Zbase_class_typesZdefined_funcsr˜   rï  rO   r1   )r}   rþ  rg  rx   r2   rŽ   H  sR    

ÿ
     þ





z!CppClassNode.analyse_declarationsc                 C   s   | j  | jjj¡| _ | S rs   )r“   rh   rÎ   rÿ   rg  r|   r1   r1   r2   rh   z  s    z CppClassNode.analyse_expressionsc                 C   s   | j  | jjj|¡ d S rs   )r“   rÉ   rÎ   rÿ   rg  râ   r1   r1   r2   rÉ   ~  s    z*CppClassNode.generate_function_definitionsc                 C   s   | j  |¡ d S rs   ©r“   rÊ   r   r1   r1   r2   rÊ     s    z$CppClassNode.generate_execution_codec                 C   s   | j  |¡ d S rs   rë   r   r1   r1   r2   r”   „  s    zCppClassNode.annotate)
r?   rc   rd   rê  rï  rŽ   rh   rÉ   rÊ   r”   r1   r1   r1   r2   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 )ÚCEnumDefNoderY   Úunderlying_typeNc                 C   sJ   d }t jrt| j| jƒ}|j| j| j| j| j| j	| j
| j| j|d	| _d S )N)rL  Úscopedrh  r  rß  rè  r8   )r#   ré  r9   r0   r8   Zdeclare_enumr]   rL  r  rh  r  rß  rè  rÎ   )rx   r}   r8   r1   r1   r2   rï  ™  s       úzCEnumDefNode.declarec                 C   sÖ   d }| j  |¡}|js$t| j jdƒ || jj_ | jr^| jd k	r^t	| j
|ƒ}| jj|_|j|_n|}| jd k	rÒ| jr€|js€d| j_| jdk}|r’dnd }| jD ]4}| || j|¡ |rœd|jjd k	rÊ|jjn| }qœd S )Nz'underlying type is not an integral typer   r7  r   )r  r  r  r   r0   rÎ   rÿ   r  rY   r   r]   rÅ   r  ræ   rn  r  Úanalyse_enum_declarationsÚenum_int_value)rx   r}   rg  r  Zis_declared_enumZnext_int_enum_valuer   r1   r1   r2   rŽ   ¦  s*    





ÿz!CEnumDefNode.analyse_declarationsc                 C   s   | S rs   r1   r|   r1   r1   r2   rh   Å  s    z CEnumDefNode.analyse_expressionsc              
   C   s´   | j r
d S | jdks| jr°| | j¡ |jjtjdd}| j	j
D ]b}| d||j| ||j¡f ¡ | |tj¡ | dtj|j|| |j¡f ¡ | |tj¡ q@|j |¡ d S )NÚpublicT©Z
manage_refz%s = PyInt_FromLong(%s); %sz.if (PyDict_SetItemString(%s, "%s", %s) < 0) %s)r  r  rß  rÝ   r0   Ú	funcstateÚallocate_tempr
   r   rÎ   Úenum_valuesrD   rL  Úerror_goto_if_nullÚ
put_gotrefr	   Zmoddict_cnamer]   Ú
error_gotoÚput_decref_clearÚrelease_temp)rx   rI   Útempr   r1   r1   r2   rÊ   È  s(    ý
üz$CEnumDefNode.generate_execution_code)	r?   rc   rd   r†   r8   rï  rŽ   rh   rÊ   r1   r1   r1   r2   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rXd|j| j	f }n| j}|j
| j	|j| j | j||j|j|joŠ|j	d kd | _}|}| j rÞ| j jr¶t| j j ƒ}n(| j jsÆ| j jrÚ| j jrÚ| j jj}nd }|d k	rì||_|j |¡ |j	r|jj |j	¡ d S )Nz%s::%s)rL  r  rß  rè  )rŒ   r  rÿ   r  rS  r
   rk  Zis_cpp_enumrL  r]   Zdeclare_constr0   r  rß  rè  rÎ   r»   r*   r¹   Úis_attributer  r  r,  r$  )rx   r}   Z
enum_entryZincremental_int_valuerL  rÎ   Z
enum_valuer1   r1   r2   r  ä  s<    
    üz*CEnumDefItemNode.analyse_enum_declarationsN)r?   rc   rd   r†   r  r1   r1   r1   r2   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   ru  c                 C   sr   | j  |¡}| jj||| j| jd\}}|j}|j}|j||| j|| j| j	d}|j
r\d|_| jrn|jsnd|_d S )NrH  )rL  r  rß  Tr   )r   r  ru  r  r  r]   rL  rÚ  r0   rß  rü   ræ   rn  )rx   r}   r  r_  rÿ   r]   rL  rÎ   r1   r1   r2   rŽ     s*       ÿ
    þz!CTypeDefNode.analyse_declarationsc                 C   s   | S rs   r1   r|   r1   r1   r2   rh   "  s    z CTypeDefNode.analyse_expressionsc                 C   s   d S rs   r1   r   r1   r1   r2   rÊ   %  s    z$CTypeDefNode.generate_execution_codeN©r?   rc   rd   r†   rŽ   rh   rÊ   r1   r1   r1   r2   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 ]ˆ}|jrvd}|jr@|j |¡|_|j |j|¡|_q’|jrb|jjstt|j	dƒ d |_q’t|j	dƒ d |_q
|j
r‚d}q
|r
t|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)rF   rò   rž  rg   rS  rÿ   rŸ  rº   r   r0   r   )rx   r}   Zdefault_seenrd  r1   r1   r2   Úanalyse_default_valuesR  s"    
z"FuncDefNode.analyse_default_valuesc                 C   s8   | j D ]}|jr|j |¡|_q| jr4| j |¡| _d S rs   )rF   rv  rg   Úreturn_type_annotation©rx   r}   rd  r1   r1   r2   Úanalyse_annotationsf  s
    
zFuncDefNode.analyse_annotationsc                 C   sÊ   | j }|j}|j|kr,||j }| |¡}n<t|tƒrd|jrd|jd rd|j}| |¡}|d krh|S n|S |d kr~t	|j
dƒ nH|tk	r¬| |¡s¬t	|jj
dƒ t	|j
dƒ n||_|jjrÆ|j |¡ |S )Nr~  r2  r3  r4  )r]  rÿ   r]   r  r=   rt  rv  rÅ   r…  r   r0   r   rK  r   r²  r³  )rx   r}   rd  r]  Ú	orig_typer`  ra  r1   r1   r2   Úalign_argument_typem  s(    


zFuncDefNode.align_argument_typec                 C   s   dS ©Nr   r1   ©rx   Úlenvr1   r1   r2   Úneed_gil_acquisition‡  s    z FuncDefNode.need_gil_acquisitionc                 C   s   |}|j s|jr|j}q| jrF| jr(tnt}|| jj||| jj	d}nt
| jj||d}| j|_| jj}|jr~|joz|j |_|| _|j|_|S )N)r]   râ  Úparent_scopeZ
scope_name)r]   râ  r!  )Úis_py_class_scoperJ  râ  Úneeds_closureÚis_generator_expressionr   r   rÎ   r]   rL  r   rQ  rÿ   r  r>  r?  Úlocal_scoperÅ   )rx   r}   Úgenvr\   r  rÿ   r1   r1   r2   Úcreate_local_scopeŠ  s*    ýþzFuncDefNode.create_local_scopec                 C   s   | j  |¡ d S rs   r  râ   r1   r1   r2   Úgenerate_function_body   s    z"FuncDefNode.generate_function_bodyc           '         sh  ddl m} ˆj}|jr0|js0dtjtjf }ntj}| |¡ ˆj	 
||¡ ˆ ||¡ ˆjjdkonˆjjj}ˆjjdko„ˆjjj}|pŒ|}|rªdˆjkrªˆjdg ˆ_ˆ ¡ }	|jjd }
|jjd }|
sÒ|rò|rÞ| ¡  |j t d	d
¡¡ | |¡ | ¡ |_|j |j_| ˆj¡ ˆ  ||¡ | !d¡ |	rD| !|	¡ ˆ "||¡pVˆj#}ˆj$rrˆj$j%||dd ˆj%||d |}|j&s”|jrž|j'}q„ˆj(rÈ| )|j*j+ ,tj¡¡ | !d¡ nPˆ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rl|j5rl|j6}|j7s´|j8r‚d}n|j9ršd| :|j;¡ }| !d| ,tj<¡|f ¡ | =¡ }ˆ >|¡ ˆj?}dd„ |j@D ƒ}|joðˆj(pðˆj-}d ‰d}|s|r| A¡  d|j_d}n| =¡ ‰|
s0|rbˆjBsb| C¡  ˆjDrTˆjD E|¡nd }| F|¡ |rrˆ G|¡ | =¡ }| =¡ }|r’ˆ H|¡ ˆj(rhtI Jdd¡}tI K|j*j+j|¡}|sÌd|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r˜| !d||j*j+ M¡ tjUf ¡ n| !d ||j*j+ M¡ tjUf ¡ |jrÔ| !dtj|f ¡ n(ˆj(rü| P||j*j+¡ | V||j*j+¡ |
s|rNˆjBsFˆjWr&ˆjjd! }nˆjj}|jX|ˆj|jj d" d|j_Yˆ Z||¡ |j[D ]T}|j+j9s|s||j\r²|j0s²| ]|¡ n"|j\r`|j0s`|j^||jjd# q`|j/D ]X}|j1r¼|j\r¼|j0s¼|j+j9rô|j^||jjd# |j_r| `|¡ n
| ]|¡ q¼|j/|j[ D ](}|j+jar"|jbjcjdr"| e||¡ q"ˆ f|¡ |j[D ] }|j+jar\| g||ˆj¡ q\|jjhrŒd}|rÈ|jrÈˆd k	r¸ˆ A¡  d ‰d|j_| i¡  d|j_ˆ j||¡ |jˆjdd$ | !d¡ | !d%¡ |jj|jjˆd kd&œ‰|f‡‡fd'd(„	‰ ˆj3}ˆj	jks˜|j8rVtj<}ˆ d)ƒ | l||¡ nB|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# qÒtt|ƒd,k} | rj|j tu¡ | !d-¡ | !d.¡ ˆ d+ƒ | !d/¡ | !d0¡ |D ]}| v||¡ qL| !d1¡ |j9r”dd2l mw}! |! xtj<|¡ tj<}"nˆ y¡ }"ˆ z¡ }#|"d k	s´|#	r
ˆ d+ƒ |jj{ræ| !d3tj| ¡ | !d4tj| ¡ | }ˆjj~¡ |jj{	r8| !d¡ n.tˆjjd5ˆjj~ d,ƒ ˆ d+ƒ | €ˆjj~¡ |j;}$|"d k	rR|$	rR|$}"|"d k		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	sðt‚‚| o|j¡ n|%ƒ  nd8d7„ }%| m|jp¡
s*| m|jn¡
sÎ| q|jp¡ |D ]}ˆ d)ƒ | v||¡ 
q:|
rnˆ d)ƒ ˆ ƒ|¡ |j9
rÎ| „| …tj<¡¡}&| !d9|& ¡ ˆd) 
s¨| A¡  | !d:¡ ˆd) 
sÄ| i¡  | !d¡ | m|j¡
rî|%ƒ  | q|j¡ |j/D ]\}|jd
rô|j0r
qô|j+j†r<|j1r*|j\s*
qô|j+j‡r<ˆ d)ƒ |jˆ|ˆd) d# 
qô|j[D ]`}|j0rhqX|j+j9r€|j\s¤qXn$|s’|j\s’qX|j+j†r¤ˆ d)ƒ |jˆ|ˆd) d# qXˆj(rÜˆ d)ƒ | ‰tj|j*j+¡ |js|j;}$ˆ y¡ }"|"d kr|$r|$}"| Štj<|¡ ˆjj‹rJˆjjd;krJˆ d)ƒ | !d<tj<tj<f ¡ |
sV|ršd|j_YˆjBsš|j8r†|jŒtj<ˆd)  d" n|jŒdˆd)  d" |jjhrÒ| ¡  |jŽˆjj| d= |jˆd)  d" |sê|jrúˆd) rú| i¡  d|j_|j7s| !d>tj< ¡ | !d¡ |	r0| !d?|	 ¡ | |j¡ | ‘¡  ˆj$rZˆj$ 
||¡ ˆ ’|¡ d S )@Nr   rË  z%s->%sÚ__getbuffer__Ú__releasebuffer__Zcython_unusedÚprofileÚ	linetraceZProfilez	Profile.cr­   T©Úwith_pymethdefÚ
proto_only)r.  ú;z = NULLú = ú%s%s;c                 S   s   g | ]}|j r|‘qS r1   ©ro  )rƒ   rÎ   r1   r1   r2   r…     s      z=FuncDefNode.generate_function_definitions.<locals>.<listcomp>FZtp_newr[   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                    s8   ˆ |  s4ˆ d s ˆ  ¡  dˆ d< |jdd dˆ | < d S )Nr?  TF©Údeclare_gilstate)rA  Úput_ensure_gil)Z	code_pathrI   )Ú	gil_ownedÚgilstate_declr1   r2   Ú
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sZtdˆjˆd ˆd f ƒ‚d S )Nr>  r   ©rI   Fz$%s: error path %s != success path %s)Úput_release_ensured_gilÚAssertionErrorr0   rI  )rE  rC  rx   r1   r2   Ú$align_error_path_gil_to_success_pathù  s      ÿzWFuncDefNode.generate_function_definitions.<locals>.align_error_path_gil_to_success_pathc                   S   s   d S rs   r1   r1   r1   r1   r2   rL  	  ó    ú	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­   rÌ  r%  Úis_closure_scopeZis_passthroughr	   Úcur_scope_cnameÚouter_scope_cnameZmangle_closure_cnamesr“   rÉ   rÐ   rÎ   r]   rg  rJ  r  Úget_preprocessor_guardrÈ   rÅ   Zuse_fast_gil_utility_coder¾  r   Úload_cachedÚenter_cfunc_scopeÚ	new_labelÚreturn_from_error_cleanup_labelr>  r	  rC  rÝ   r0   rÏ   rD   Úneeds_assignment_synthesisÚpymethdef_requiredÚpy_funcÚgenerate_function_headerr"  râ  r#  ÚputÚscope_classrÿ   rû   Úneeds_outer_scopeÚgenerate_argument_declarationsrð  Ú
in_closurer‚  Úput_var_declarationrQ  Zis_cv_qualifiedrÝ  Zcv_base_typerú   r
  rä  Zliteral_coderW  Úretval_cnamer@   Úgenerate_keyword_listrP  Zbuffer_entriesrB  Úis_generatorÚput_trace_declarationsÚcode_objectÚcalculate_result_codeÚput_trace_frame_initÚgetbuffer_checkÚgetbuffer_initr   ZConstructorSlotZget_slot_functionÚtypeptr_cnamer  Zempty_tupler‘  Ú
put_increfr   r  r  Úis_cyfunctionÚ
self_cnamer—  r½   Úput_trace_callÚ	can_traceÚgenerate_argument_parsing_codeÚarg_entriesZcf_is_reassignedÚput_var_increfÚput_var_incref_memoryviewsliceÚxdecref_cleanupÚput_var_xincrefrù   Z
buffer_auxZbuflocal_nd_varro  Zput_init_varsÚgenerate_argument_type_testsZput_acquire_arg_bufferZneeds_refnannyrJ  r(  r¼   Úput_init_to_py_noneÚ
label_usedÚerror_labelÚput_gotoÚreturn_labelÚ	put_labelÚall_managed_tempsÚput_xdecrefr<   Úrestore_exception_utility_codeZput_release_buffer_coderº  Zput_init_entryÚerror_valueÚcaller_will_check_exceptionsÚerror_without_exceptionÚerror_without_exception_cnameÚput_add_tracebackÚqualified_namer   Zput_unraisableÚgetbuffer_error_cleanuprK  Úgetbuffer_normal_cleanupÚunlikelyZerror_conditionÚneeds_refcountingZ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)'rx   r}   rI   rÌ  r  rU  Zis_getbuffer_slotZis_releasebuffer_slotZis_buffer_slotÚpreprocessor_guardr+  r,  r.  ÚcenvrÎ   ÚinitrQ  Útempvardecl_coderP  Zused_buffer_entriesZvar_decls_definitely_need_gilZvar_decls_need_gilri  Zrefnanny_decl_codeZrefnanny_setup_codeZtp_slotZslot_func_cnameZ
trace_nameÚlhsÚvalrL  rÿ   Zbuffers_presentrº  Úerr_valrc  Zdefault_retvalrL  Úcondr1   )rE  rC  rD  rx   r2   rÉ   £  sÈ   ÿ
ÿÿ

ÿ



ÿ  ÿ




þ




ûþ


ý

ý  ÿ

ÿ


ÿ






ý	







ÿ
ÿþ


ÿ
ÿ
ÿ





 ÿ ÿ ÿ
 ÿ
z)FuncDefNode.generate_function_definitionsc                 C   sh   |j jrt|jdƒ n,|j  ¡ sB|j jsB|j jsBt|jd|j  ƒ | |j|j |j¡}|j	rd|j	|_	|S )NzInvalid use of 'void'z Argument type '%s' is incomplete)
rÿ   rú   r   r0   r#  rø   rä  Zdeclare_argr]   rv  )rx   r}   rd  rÎ   r1   r1   r2   Údeclare_argument‰	  s    zFuncDefNode.declare_argumentc                 C   sv   |j  ¡ rf|j t dd¡¡ |j j}d|jj }| 	d|||j
|j|j joR|j j| |j¡f ¡ nt|jdƒ d S )NZ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)rÿ   Ztypeobj_is_availablerÈ   r¾  r   rW  rn  rÎ   rL  rD   Úaccept_nonery  Úis_builtin_typeZrequire_exactr  r0   r   )rx   rd  rI   rn  Úarg_coder1   r1   r2   Ú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éÈ   r7  )
rÿ   rä  rÎ   rL  rD   r–   r<   ry  r  r0   )rx   rd  rI   rL  r1   r1   r2   Úgenerate_arg_none_check¥	  s     
þz#FuncDefNode.generate_arg_none_checkc                 C   s   d S rs   r1   r   r1   r1   r2   r˜  ²	  s    z&FuncDefNode.generate_wrapper_functionsc                 C   s2   |  | j¡ | js.| jD ]}|js| |¡ qd S rs   )rÝ   r0   r½   rF   r¢  rœ  ©rx   rI   rd  r1   r1   r2   rÊ   µ	  s
    
z#FuncDefNode.generate_execution_codec              	   C   sH   | j jd }z|jjjjd j}W n ttfk
r>   d }Y nX ||fS )Nr   Úobj)r%  ru  rÿ   r   rg  rÍ   r•   ÚKeyError)rx   Ú	py_bufferÚobj_typer1   r1   r2   Ú_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;r7  )r¯  rL  rD   )rx   rI   r­  rÖ  Úviewr1   r1   r2   rl  Ñ	  s    

zFuncDefNode.getbuffer_checkc                 C   sP   |   ¡ \}}|j}|r>|jr>| d| |¡ | d| |¡ n| d| ¡ d S )Nú%s->objz%s->obj = NULL;)r¯  rL  r
  r{  r—  rD   ©rx   rI   r­  r®  r°  r1   r1   r2   rm  Ú	  s    
zFuncDefNode.getbuffer_initc                 C   sh   |   ¡ \}}|j}|rV|jrV| d| ¡ | d| |¡ | d| |¡ | d¡ n| d| ¡ d S )Nzif (%s->obj != NULL) {r±  r7  zPy_CLEAR(%s->obj);©r¯  rL  r
  rD   r  r  r²  r1   r1   r2   rŠ  ã	  s    
z#FuncDefNode.getbuffer_error_cleanupc                 C   sX   |   ¡ \}}|j}|rT|jrT| d| ¡ | d| |¡ | d| |¡ | d¡ d S )Nzif (%s->obj == Py_None) {r±  r7  r³  r²  r1   r1   r2   r‹  î	  s    
z$FuncDefNode.getbuffer_normal_cleanupc                 C   sh   | j jsd S | j j}t | jj¡ |¡}|s0d S |dkrJ| j j 	d¡sJd S |dkr`| j jj
r`d S | ¡ S )NZ__long__Ú__int__©r)  r*  )rÎ   r‘  r]   r   Úget_slot_tabler%  rÅ   Úget_slot_by_method_namerg  rÁ  rJ  Úpreprocessor_guard_code)rx   r]   Úslotr1   r1   r2   rV  ÷	  s    z"FuncDefNode.get_preprocessor_guard)'r?   rc   rd   r]  r#  ra  r\  rg  r$  Úis_coroutineÚis_asyncgenÚis_generator_bodyZis_async_defr  Úhas_fused_argumentsÚstar_argÚstarstar_argrp  ri  r  rÁ   r  r  r  r   r'  r(  rÉ   r¡  r§  r©  r˜  rÊ   r¯  rl  rm  rŠ  r‹  rV  r1   r1   r1   r2   r  )  sN      i
			r  c                       s  e Zd Zdddddg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d6dd„Zdd„ Zdd„ Zdd„ Zdd„ Zd7dd „Zd8d"d#„Zd$d%„ Zd&d'„ Zd(d)„ Zd*d+„ Zd,d-„ Z‡ fd.d/„Z d0d1„ Z!d2d3„ Z"d4d5„ Z#‡  Z$S )9rý  r   ru  r“   rê  Úpy_func_statFNc                 C   s   | j jS rs   )rÎ   r]   r‚   r1   r1   r2   Úunqualified_name)
  s    zCFuncDefNode.unqualified_namec                 C   s
   | j  ¡ S rs   rw  r‚   r1   r1   r2   rî   ,
  s    zCFuncDefNode.declared_namec                 C   s   | j r| j jS d S rs   )r]  ri  r‚   r1   r1   r2   ri  /
  s    zCFuncDefNode.code_objectc                 C   sd  |j | _| jd kri | _| j |j di ¡¡ | jd k	rb| j |¡}|d krnt| jj	dƒ t
j}n| j |¡}d|jko‚| d¡ | _t| jtƒr¼| jj||d| jd k	 | j| jd\}}n$| jj||d| jd k	 | jd\}}|jsòt| j	dƒ || _| j|_| j}t|dƒs|j}q|| _|j| _| jj}| jd	ksF| jrZ|rZt| jj	d
ƒ |jdkr | jdkr |j r’|j j!r’t| j	dƒ nt"| j	ddƒ t#| j|jƒD ]º\}}|  $||¡ |j|_|j%|_%|j&|_&|  '|j|j	|¡ |jj(rüd| _)|jj*r d| j+kr t"|j	ddƒ |jj*s4|jj,r®| jj-rLt|j	dƒ nd| j+kr®t"|j	ddƒ q®|  '|j.| j	|¡ |j%}	|j&}
| j/|_/| j|_|j0|	|| j	|
| j| j| jd k	| j+| j| j1d
| _2|j.| _.| j.j3rô| jdkrôt| j	dƒ | j.j4r| j. 5| j	d¡ | jrL|j6sL| jsLt7| jƒdk sF| jd jj8sLd| _|  9|¡ |  :|¡ d S )NÚlocalsr2  rà   r(   )r  r]  r  )r  r  z*Suite attached to non-function declarationrF   r  zBFunction with optional arguments may not be declared public or apir5  r7  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.)rL  r  rß  Údefiningr  r[  r  zFunction cannot return an arrayzused as a return valuer   F);rJ  Úis_c_class_methodr]  rw   rÅ   ÚgetÚdirective_returnsr  r   r0   r
   r   r   r  rÁ  rå  r=   ru  r(  r“   r  r  rÿ   r[  r@  Úhasattrr  Zcfunc_declaratorrF   r<  rß  r=  r)  r¹   r   Úzipr  r]   rL  Ú_validate_type_visibilityrü   r½  rù   r  Úis_pythran_exprr>  rQ  rA  ræ  Úinline_in_pxdrÎ   rø   r  Zcheck_nullary_constructorrã  r<   r
  Údeclare_cpdef_wrapperr'  )rx   r}   r   r_  Útypru  Zopt_arg_countÚ
formal_argÚtype_argr]   rL  r1   r1   r2   rŽ   4
  s¸    

   þ   ÿ

ÿÿ ÿ

ÿ      ü
 
z!CFuncDefNode.analyse_declarationsc                 C   sp  | j s
d S | jrt| jdƒ | jj}| j|jd}| jrtd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sl|jr tjrl| jrB| jj s6t!‚| j| j_n*t"| j| jd| _t| j| j| j#gd| _#d S )Nz&static cpdef methods not yet supported)rã  r   ©r*  rà   ró   ©Ú	decoratorr   )	r0   r]   rF   r¾  r¿  r8   r“   rê  r½   TrÚ   )r]  )$r[  rå  r   r0   rÎ   r]   Úcall_self_noderã  r  r*  ÚDecoratorNoder   rÓ  rg   ÚDefNoderF   r8   r]  rŽ   r@  rÑ   rÀ  r
   r   rÿ   Úas_variablero  rÍ   Úis_final_cmethodr#   Úlookup_module_cpdefÚoverrideÚis_fused_specializedrK  ÚOverrideCheckNoder“   )rx   r}   r]   Zpy_func_bodyr*  rê  r1   r1   r2   rÍ  ˜
  sN    ø	



ÿÿz"CFuncDefNode.declare_cpdef_wrapperc                 C   sN   | j dkp| j}t|ddƒ}|rJ|rJ|jrJ|j dksJ|jsJ|jsJt|dƒ dS )zo
        Ensure that types used in cdef functions are public or api, or
        defined in a C header.
        r  rÎ   N)r  r7  z:Function declared public or api may not have private types)r  rß  r‡   rã  ræ   r   )rx   rÿ   r0   r}   Zpublic_or_apirÎ   r1   r1   r2   rÊ  Ã
  s    
ÿÿz&CFuncDefNode._validate_type_visibilityr   c                    s*  ddl m‰  ˆjj}|r0|d t|ƒˆjj … }dd„ |D ƒ}|rbˆ jˆjˆjj	d}|}t
j}n†ˆjjrªˆ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}| pòt
j}ˆ jˆj|‡ ‡fd	d„|D ƒ|d
}tˆjtj|dS )Nr   ©r  c                 S   s   g | ]
}|j ‘qS r1   ró   ©rƒ   rd  r1   r1   r2   r…   Ô
  s     z/CFuncDefNode.call_self_node.<locals>.<listcomp>ró   )r«  Ú	attributeTr   c                    s   g | ]}ˆ j ˆj|d ‘qS ©ró   )r*  r0   )rƒ   Ún©r  rx   r1   r2   r…   ê
  s     )ÚfunctionrF   Zwrapper_call)r0   rQ  rŒ   )r­   r  rÿ   rF   r<   r<  r*  r0   rÎ   r]   r#   rÙ  rå  rg  rN  ZAttributeNodeÚSimpleCallNodeÚReturnStatNoder
   r   )rx   Zomit_optional_argsrã  rF   Ú	arg_namesÚcfuncZcall_arg_namesZskip_dispatchZclass_entryZ
class_noderÂ  rÐ  Zc_callr1   râ  r2   rÔ  Ï
  s6    üzCFuncDefNode.call_self_nodec                 C   s0   | j jD ]"}|jst|jdƒ |  ||¡ qd S )Nrô   )rÿ   rF   r]   r   r0   r¡  r  r1   r1   r2   Údeclare_argumentsî
  s    zCFuncDefNode.declare_argumentsc                 C   s   | j jS rs   )rÿ   r?  r  r1   r1   r2   r   ô
  s    z!CFuncDefNode.need_gil_acquisitionc                 C   sV   | j }|j}|jrR|sR|jjr*t| jdƒ | jjD ]}|j jr2|j	s2t| jdƒ q2d S )Nz9Function with Python return type cannot be declared nogilz8Function declared nogil has Python locals or temporaries)
rÿ   r?  r>  rQ  r
  r   r0   r%  rð  Zin_with_gil_block)rx   r}   rÿ   r?  rÎ   r1   r1   r2   rÂ   ÷
  s    
ÿzCFuncDefNode.nogil_checkc                 C   sd   |j | j_ | jd k	r$| j |¡| _n.| jd k	r>| j |¡| _n|  |¡ |  |¡ |  | j¡| _| S rs   )	rÅ   r%  rÀ  rh   r]  r  r  r   rP  r|   r1   r1   r2   rh     s    




z CFuncDefNode.analyse_expressionsc                 C   s   dS ©NFr1   râ   r1   r1   r2   r[    s    z'CFuncDefNode.needs_assignment_synthesisr   c                 C   sª  | j }g }| j}|jd t|jƒ|j … D ]0}	|	 ¡ }
| |	j¡}|jsPd|
 }
| 	|
¡ q*|r”| j
r”tj tj¡}| jr†| 	|¡ n| 	d| ¡ |jr²|r²| 	|j tj¡¡ |jrÂ| 	d¡ |sÌdg}|d krÜ| jj}| |d |¡¡}| jjdkrd|krd}nd}d }| | jj¡}| jj||d	}| jp@| jj}| jrp|rd|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_linkageZmodule_declarationsz%s%s%s; /* proto*/z%s%s%s {)!r%  rÿ   rF   r<   r<  rû   r¬  r]   Úcf_usedr,  r[  r
   rk  r	   Úskip_dispatch_cnamerÚ  rp  Úoptional_args_cnamerZ  rÎ   Ú
func_cnameZfunction_header_coder¡   r  Zbuild_function_modifiersZfunc_modifiersrQ  rÅ  r¾   r   rÈ   ÚpartsrD   )rx   rI   r.  Úwith_opt_argsÚwith_dispatchrL  rg  Z	arg_declsrÿ   rd  Zarg_declrÎ   Zdispatch_argÚentityZstorage_classrì  r  ÚheaderZneeds_protor1   r1   r2   r^    sR    
ÿ

ÿz%CFuncDefNode.generate_function_headerc                 C   sZ   | j }| jD ]H}|jr| |j¡}| js.|jr| |¡}| d|j	 
|j¡|f ¡ qd S r“  )r%  rF   rò   r¬  r]   rÚ  rí  r’  rD   rÿ   rû   rL  )rx   r}   rI   rg  rd  rÎ   rŠ   r1   r1   r2   rb  @  s    

 ÿz+CFuncDefNode.generate_argument_declarationsc                 C   s   d S rs   r1   r   r1   r1   r2   rf  J  s    z"CFuncDefNode.generate_keyword_listc           
   	      s  d}d}| j }| jjrÔˆ dtj ¡ | jD ]„‰ ˆ jr,| ˆ j	¡}| j
sN|jr¨ˆ dtjtj|f ¡ ˆ j}t|dƒs~|j}qlˆ dˆ jtj| j |j	¡f ¡ |d7 }|d7 }q,t|ƒD ]}ˆ d¡ qºˆ d¡ ‡ ‡fdd	„}	| jD ]‰ |	| ˆ j	¡ƒ qèd S )
Nr   rN  zif (%s->%sn > %s) {r]   z%s = %s->%s;r   r7  c                    sV   | j rRˆ jsRˆ d| j| jf ¡ | jjr>| j ˆ| jd¡ nˆ | ¡ ˆ 	| ¡ d S )Nr”  T)
rc  rò   rD   rL  Úoriginal_cnamerÿ   rä  Úgenerate_incref_memoryviewslicerv  Úput_var_giveref©rÎ   ©rd  rI   r1   r2   Úput_into_closureg  s    
zECFuncDefNode.generate_argument_parsing_code.<locals>.put_into_closure)r%  rÿ   r<  rD   r	   rï  rF   rò   r¬  r]   rÚ  rí  ri  ru  rÈ  r  rL  Zopt_arg_cnameÚrangerÁ  )
rx   r}   rI   r^  ro  rg  rÎ   ru  rÖ  rû  r1   rú  r2   rt  M  s>    
 ÿÿ
ÿÿ


z+CFuncDefNode.generate_argument_parsing_codec                 C   s   d S rs   r1   r   r1   r1   r2   Ú!generate_argument_conversion_codes  s    z.CFuncDefNode.generate_argument_conversion_codec                 C   s@   | j jD ]2}|jr |  ||¡ q|j jr|js|  ||¡ qd S rs   )rÿ   rF   Úneeds_type_testr§  r
  r¤  r©  rª  r1   r1   r2   rz  v  s
    z)CFuncDefNode.generate_argument_type_testsc                    sH   |j jd r"| | j¡ | d¡ tt| ƒ |¡ | jrD| j |¡ d S )Nr,  r­   )	rÈ   rÅ   rÝ   r0   rD   rZ   rý  rÊ   rÀ  r   rb   r1   r2   rÊ     s    
z$CFuncDefNode.generate_execution_codec                 C   s   | j jrdS | jjjS d S )NÚ0)rQ  r
  rÎ   rÿ   r)  r‚   r1   r1   r2   r„  ‡  s    zCFuncDefNode.error_valuec                 C   s
   | j jjS rs   )rÎ   rÿ   r=  r‚   r1   r1   r2   r…    s    z)CFuncDefNode.caller_will_check_exceptionsc                 C   s  d}| j }|j}|jd k	r|d7 }|j}d| j jtj|f |_| ¡  | j|d|jj|jj	|jd | j
jsx| d¡ | jj}dd„ |d t|ƒ| jj	 … D ƒ}|jjr¸| tj¡ n|jrÈ| d¡ |jj	rÞ| tj¡ n|j	rî| d	¡ | d
| j jd |¡f ¡ | d¡ qd S )Nr   r   z%s%swrap_%s)ró  rò  rL  zreturn c                 S   s   g | ]
}|j ‘qS r1   )rL  rÞ  r1   r1   r2   r…   £  s     z;CFuncDefNode.generate_wrapper_functions.<locals>.<listcomp>rÿ  ÚNULLú%s(%s);rœ   r7  )rÎ   rÿ   Z
prev_entryrð  r	   ri  rD   r^  r@  r<  rQ  rú   r_  rF   r<   r,  rî  rï  r¡   )rx   rI   ÚkrÎ   rC  rF   Zarglistr1   r1   r2   r˜    s:     ü
"

z'CFuncDefNode.generate_wrapper_functions)r   r   )N)r   r   N)%r?   rc   rd   r†   rÁ   rÌ  rê  r]  rÇ  rÚ  r   rA  rÀ  rÁ  rî   r£  ri  rŽ   rÍ  rÊ  rÔ  rè  r   rÂ   rh   r[  r^  rb  rf  rt  rý  rz  rÊ   r„  r…  r˜  re   r1   r1   rb   r2   rý  
  sB   
d+


-
&	rý  c                   @   s    e Zd Zg ZdZdZdd„ ZdS )ÚPyArgDeclNodeFc                 C   s   | j  ||¡ d S rs   )rÎ   rÉ   râ   r1   r1   r2   rÉ   »  s    z+PyArgDeclNode.generate_function_definitionsN)r?   rc   rd   r†   r1  r  rÉ   r1   r1   r1   r2   r  °  s   r  c                   @   s   e Zd ZdgZdS )rÕ  rÓ  N)r?   rc   rd   r†   r1   r1   r1   r2   rÕ  ¿  s   rÕ  c                   @   s&  e Zd Zddddddg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d6d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%d7d$d%„Z&d&d'„ Z'd(d)„ Z(d*d+„ Z)d8d,d-„Z*d.d/„ Z+d0d1„ Z,d2d3„ Z-d4d5„ Z.dS )9rÖ  rF   r¾  r¿  r“   rê  r  FNrÿ  r   Tc                 K   s€   t j| |f|Ž d } } }}| jD ]<}|jr8|d7 }|jrT|d7 }|jsT|d7 }|js&|d7 }q&|| _|| _|| _|| _	d S r.   )
r  rz   rF   r¡  r   rò   Únum_posonly_argsÚnum_kwonly_argsÚnum_required_kw_argsÚnum_required_args)rx   r0   rG   Úpr  ZrkÚrrd  r1   r1   r2   rz   ø  s    

zDefNode.__init__c	                 C   s  | j rt| j jdƒ | jr(t| jjdƒ |p.d\}	}
|p:|}|d kr°g }| jD ]6}|j|dd\}}| tj|j	d |j
t|jd¡ qNtjt|dd |
|||d}t| j|d	}n¬|d kr¾|j}|j}t| jƒt|jƒksÞ|jröt| jd
ƒ t|jdƒ tt| j|jƒƒD ]R\}\}}|j|d|dko*|jd\}}|d ksJ|tjkr|j|_||_q|	d kr’|jd k	r’ddlm} || j|j|jd}	t| jt| j| j	d d| jd|j|	|j|jd}t| j|pÐg 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  )r]   rL  rv  rÿ   r0   F)rQ  rF   rZ  r)  r=  r>  r?  r@  r¦  zwrong number of argumentszprevious declaration herer   r0  r8  r:  rÍ  )r  rF   rZ  r=  r)  r?  r>  rë  r]  )r  r   ru  r“   r8   r[  rÿ   r?  r>  r  rß  r]  rÇ  )%r¾  r   r0   r¿  rF   r  r,  r
   rO  r]   rv  r   rY  rä   rg  rÿ   r<   rZ  rI  rÉ  rJ  r_  r)  r  r9  rQ  r(  rñ   r=  r?  r>  rý  r‰  r“   r8   r@  r‡   )rx   rç  rg  r[  ZreturnsZ
except_valr  r>  r?  r)  r=  Z
cfunc_argsrÏ  r_  rÿ   Z
cfunc_typer^  rÐ  r9  ru  r1   r1   r2   Úas_cfunction	  sŒ    
ü
ùÿ

  ÿù
ózDefNode.as_cfunctionc                 C   s   | j r
dS | js| jrdS dS )z·Determines 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‚   r1   r1   r2   Úis_cdef_func_compatibleM  s
    zDefNode.is_cdef_func_compatiblec              	   C   sà  | j rF| j D ]8}|j}|jr|  j|jdkO  _|  j|jdkO  _q| jr\| d¡r\d| _| jrr| d¡rrd| _|js€|jr| jdkr˜|jr˜d| _nv| jdkr¶|jr¶t	| j
dƒ nX| jtkr| jsd| _dd	lm} | j päg | _ | j  d
t| j
|| j
tdƒdd¡ |  |¡ | jdkr0|  |¡ n
|  |¡ |  |¡ | jj ¡ | _| jtk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à   Fr[   Tr,   z7'__init_subclass__' is not supported by extension classr   rÑ  r   ró   rÒ  ú<lambda>r~  )rš  r]   rF   r¾  r¿  rQ  )%rê  rÓ  r¹   Úis_classmethodr]   Úis_staticmethodrÁ  r"  rJ  r   r0   ÚIMPLICIT_CLASSMETHODSr  r*  ÚinsertrÕ  r   Úanalyse_argument_typesÚdeclare_lambda_functionÚdeclare_pyfunctionÚanalyse_signaturerÎ   Ú	signaturerQ  r   r  rÅ   r‘  rˆ  r
  r'  ÚDefNodeWrapperrF   r¾  r¿  Ú
py_wrapperrŽ   )rx   r}   rÓ  rO   r*  rÖ  rQ  r1   r1   r2   rŽ   X  sZ    

 ÿ



ùzDefNode.analyse_declarationsc                 C   sÚ  |j  di ¡| _|j d }|j}d |_| jD ]x}t|dƒrBd }nJ|j |¡}t|ƒrl|j	rlt
 ||jg¡}|j ||¡\}}|j|_||_|  ||¡ |r®|jr®t| jdƒ |j ¡ |_d |_d|_d|_d|_|jjsì|jjsì|jjr`|jrúd|_nd|jr
d|_nT|jjs2|jj s2|jjs2|jjrX|j!rP|j!j"d krPd|_n||_nd|_n8|jj#s˜d|_|jr„t|jd	ƒ |jr˜t|jd
ƒ |jj$r,d| _%q,||_t|ƒrÐdd„ t&| jƒD ƒ| _'ng | _'d S )NrÂ  Úallow_none_for_extension_argsr]   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 r1   )rÿ   Zis_numpy_buffer)rƒ   r^  Úar1   r1   r2   r…   Ë  s      z2DefNode.analyse_argument_types.<locals>.<listcomp>)(rÅ   rÆ  r]  rý   rF   rÈ  r   r  r%   rË  r
   rÛ  Z
org_bufferru  r]   rÿ   r  rL  r   r0   Zas_argument_typeÚhdr_typerz  rþ  rž  r
  rù   rä  rŒ  r¤  rŽ  Úis_extension_typer¥  rò   rX  rP  rü   r½  rI  Únp_args_idx)rx   r}   r  Zf2srd  r_  r   rÿ   r1   r1   r2   r    sf    

ýÿ
ÿÿ

zDefNode.analyse_argument_typesc           	      C   s¶  | j jr<| jrt| jdƒ t| jƒdko4| jp2| j | j _	nò| js.| js.|j
d rltdd„ | jD ƒƒr.| j jtjkrÊt| jƒdkr”tj| j _n4t| jƒdkrÈ| jd jd krÈ| jd jsÈtj| j _nd| j jtjkr.t| jƒdkrôtj| j _n:t| jƒdkr.| jd jd kr.| jd js.tj| j _| j j}| ¡ }| ¡ }|tjkr|dkrt| jƒdkr| jrtj }| j _d| _d }}| jrÒ|jrÒd }}d| _t |¡ | j _}d	|_d|_d|_| jsâ| jr | jr |jr | j j!d d …= t"t#|t| jƒƒƒD ]²}| j| }d|_$||kr8d|_%| &|¡r†| js†| jrjd|_'t(j) |_*|_+nd|_&|j, |_*|_+d|_-n>| .|¡|_*|j+ /|j*¡s|j*j0r¾|j+j0r¾d|_1nd|_-q|t| jƒkrä|  2¡  d S |t| jƒk r4|js|  2¡  | jD ](}|j$r
|j+j3s*|j+j4r
d|_1q
| 5¡ }|r²tj6|kr²| j js²| jr˜d}| jD ]*}|j$rj|jsj|j&sj|j'sjd
}qjnd
}|s²| 7¡  }| j _d S )Nz8special functions of cdef classes cannot have decoratorsr   Zalways_allow_keywordsc                 S   s   g | ]
}|j ‘qS r1   ©r¡  rÞ  r1   r1   r2   r…   Ö  s     z-DefNode.analyse_signature.<locals>.<listcomp>r   r(   Tr;  F)8rÎ   r‘  rê  r   r0   r<   rF   r¾  r¿  Ztrivial_signaturerÅ   rç   r  r   Zpyfunction_signatureZpyfunction_noargsrò   r   Zpyfunction_oneargZpymethod_signatureZ	unaryfuncZibinaryfuncÚmax_num_fixed_argsÚmin_num_fixed_argsÚself_in_starargr  rJ  r   Zfixed_arg_formatÚhas_generic_argsr  r½  Zdecorator_indirectionrÒ   rü  Úminrž  rŸ  r1  r  r   Z	type_typer  rÿ   rN  rz  Zfixed_arg_typerK  r
  rþ  Úbad_signaturer  r¥  Úmethod_flagsZmethod_varargsZwith_fastcall)	rx   r}   ÚsigZnfixedZ
min_nfixedr^  rd  ÚmfZuses_args_tupler1   r1   r2   r  Ï  sª    "ÿþ 
ÿÿÿÿ





ÿÿ
zDefNode.analyse_signaturec                 C   s‚   | j j}d| ¡  }|jr$|d7 }n|jr:|d| ¡  7 }| j}| d¡rZ| d¡rZd}nd}t	| j
d|| jt| jƒ|f ƒ d S )Nz%dz or morez to %dÚ__zSpecial methodZMethodz>%s %s has wrong number of arguments (%d declared, %s expected))rÎ   r  r   r"  Zoptional_object_arg_countr  r]   Ú
startswithÚendswithr   r0   r<   rF   )rx   r&  Zexpected_strr]   Údescr1   r1   r2   r$  6  s     
   ÿzDefNode.bad_signaturec                 C   s  | j }| |¡}|rP|jr.|jjs.t| jdƒ |jjrP|j	sP| j
sPt| jddƒ |j|| j| j
 d}|| _| |j¡}ttj| | ƒ| j_tjrt| j| jƒ|_ttj| | ƒ|_|jr|j tjksè|jrè|j dkrð|jd rðd |_nttj| | ƒ|_nd |_d S )Nz:Only final types can have final Python (def/cpdef) methodsz'Overriding cdef method with def method.é   )Zallow_redefineÚ__getattr__Zfast_getattr) r]   rÁ  rØ  rN  Úis_final_typer   r0   rÿ   r  Zis_builtin_cmethodr½   r   r  rÎ   Únext_idÚscope_prefixr    r	   Zpyfunc_prefixÚpyfunc_cnamer#   ré  r9   r8   Zfuncdoc_prefixÚ	doc_cnamer‘  r   Z	invisiblerÅ   Úwrapperbase_cnameZwrapperbase_prefix)rx   r}   r]   rÎ   Úprefixr1   r1   r2   r  E  s.    
ÿÿzDefNode.declare_pyfunctionc                 C   s*   |  | j| j¡}d |_|| _|j| j_d S rs   )r  Úlambda_namer0   r8   rÎ   rL  r1  )rx   r}   rÎ   r1   r1   r2   r  ^  s    zDefNode.declare_lambda_functionc                 C   s”   | j D ]l}|jst|jdƒ |jrJ| |j|j|j¡|_|jjrXd|j_	n|  
||¡|_d|j_d|j_|j|j_q|  || j¡ |  || j¡ d S )Nrô   rÿ  r   )rF   r]   r   r0   rz  rj  rÿ   rÎ   r
  r›  r¡  r‚  ro  r1  Údeclare_python_argr¾  r¿  r  r1   r1   r2   rè  d  s    

zDefNode.declare_argumentsc                 C   sR   |rN|j d dkrtj}nt}| |j||j¡}d|_d|_d|_	d|_
||_d S )NZinfer_typesFr   rÿ  )rÅ   r
   Zunspecified_typer   rj  r]   r0   r‚  ro  r›  rx  rÎ   )rx   r}   rd  rÿ   rÎ   r1   r1   r2   r6  t  s    zDefNode.declare_python_argc                 C   sb   |j | j_ |  |¡ |  |¡ |  |¡sR| jrR| jd d d… D ]}|j |¡|_q>| j 	|¡ | S )Nr°   )
rÅ   r%  r  r  r[  rê  rÓ  rh   r  Úprepare_argument_coercion)rx   r}   rÓ  r1   r1   r2   rh     s    


zDefNode.analyse_expressionsc                 C   sv   | j r
dS | js| jjrdS | jr&dS | jjr2dS | jjr>dS |jsJ|jrj|d kr^| j	j
d S |jj
d S |jpt|jS )NTFZbinding)r  Úspecialized_cpdefsrÎ   rÛ  Úno_assignment_synthesisr‘  Zis_anonymousrã  rJ  r%  rÅ   rÈ   r"  rS  râ   r1   r1   r2   r[    s    z"DefNode.needs_assignment_synthesisc                 C   s
   | j jjS rs   )rÎ   r  r„  r‚   r1   r1   r2   r„  Ÿ  s    zDefNode.error_valuec                 C   s
   | j jjS rs   )rÎ   r  r=  r‚   r1   r1   r2   r…  ¢  s    z$DefNode.caller_will_check_exceptionsc                 C   sJ   | j r| j  | ¡ |¡ | jr8| jj| j_| j ||¡ t | ||¡ d S rs   )Údefaults_getterrÉ   rÌ   Úpy_wrapper_requiredrÎ   rð  r  r  râ   r1   r1   r2   rÉ   ¥  s    z%DefNode.generate_function_definitionsc                 C   s  |r| j r| j ||d¡ d S g }| jjjrNdtj }| jsDd| }| 	|¡ dd„ }| j
D ]}| 	||ƒ¡ q\| jr†| 	|| jƒ¡ | jrœ| 	|| jƒ¡ |r¬d |¡}nd}| j | jj¡}	|jd }
|  ¡ }|rà|
 |¡ |
 d	|	|f ¡ |r|
 d
¡ | d|	|f ¡ d S )NTúPyObject *%súCYTHON_UNUSED c                 S   s8   | j }|jr|j}n|j}|j |¡}|js4d| }|S )Nr=  )rÎ   rc  rö  rL  rÿ   rû   rí  )rd  rÎ   rL  Údeclr1   r1   r2   Úarg_decl_code¾  s    z7DefNode.generate_function_header.<locals>.arg_decl_coderœ   rê  Zdeclszstatic %s(%s); /* proto */ú#endifzstatic %s(%s) {)r;  r  r^  rÎ   r  Úhas_dummy_argr	   rq  ra  r,  rF   r¾  r¿  r¡   rQ  rû   r1  rÈ   rV  rD   )rx   rI   r.  r/  Úarg_code_listÚself_argr?  rd  r¦  ÚdcZ
decls_coder™  r1   r1   r2   r^  ±  sF      ÿ






ÿ
z DefNode.generate_function_headerc                 C   s   d S rs   r1   râ   r1   r1   r2   rb  ß  s    z&DefNode.generate_argument_declarationsc                 C   s   d S rs   r1   r   r1   r1   r2   rf  â  s    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 r¬| jjrJ| jjd k	st‚ˆ j t dd¡¡ ˆ  	d 
| j| j¡¡ nˆ  	d| j| jf ¡ | jjr|| j ˆ | jd¡ n0| jr˜ˆ  | ¡ ˆ  | ¡ nˆ  | ¡ ˆ  | ¡ d S )NZIncludeStringHzStringTools.czmemcpy({0}, {1}, sizeof({0}));r”  T)rc  rÿ   rø   r&  rK  rÈ   r¾  r   rW  rD   ÚformatrL  rö  rä  r÷  rx  ry  Zput_var_xgiverefrv  rø  rù  rI  r1   r2   rû  ç  s    

z@DefNode.generate_argument_parsing_code.<locals>.put_into_closure)rF   rÎ   r¾  r¿  )rx   r}   rI   rû  rd  r1   rI  r2   rt  å  s    
z&DefNode.generate_argument_parsing_codec                 C   s   d S rs   r1   r   r1   r1   r2   rz    s    z$DefNode.generate_argument_type_tests)NNTNNNFF)N)r   )/r?   rc   rd   r†   rÁ   r  r  r5  Zreqd_kw_flags_cnamer½   r9  rê  r  rÎ   rP  r!  Zpy_cfunc_nodeÚrequires_classobjÚdefaults_structr8   Úfused_py_funcr8  r  r;  rð  r:  rz   r
  r  rŽ   r  r  r$  r  r  rè  r6  rh   r[  r„  r…  rÉ   r^  rb  rf  rt  rz  r1   r1   r1   r2   rÖ  Æ  s^       ÿ
D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   sN   t j| f|ž|Ž | jj| _| jj| _| jj| _| jj| _| jj| _d | _d S rs   )	r  rz   rš  r  r  r  r  r!  r  )rx   rF   rk   r1   r1   r2   rz     s    




zDefNodeWrapper.__init__c                 C   sX   | j j}| j}| |j¡}ttj| | ƒ|_ttj	| | ƒ|_
|j| _| j j| _d S rs   )rš  rÎ   r]   r/  r0  r    r	   Zpywrap_prefixrð  Zpymethdef_prefixÚpymethdef_cnamer  r  )rx   r}   Útarget_entryr]   r4  r1   r1   r2   rŽ     s    z#DefNodeWrapper.analyse_declarationsc                 C   s€   | j D ]4}|jjs |j |¡s:q|jr|jjs|j |¡sq| jr|| jjjs|| jj}d|_	|j
D ]}|js`|jjr`d|j_q`d S )Nr   T)rF   rÿ   r
  Úcreate_from_py_utility_coder  rç  r¿  rÎ   rí  rx  Zcf_assignmentsr‚  r  r¹   Zcf_maybe_null)rx   r}   rd  rÎ   Zassr1   r1   r2   r7  #  s    

z(DefNodeWrapper.prepare_argument_coercionc                 C   s:   t | jƒ}|dks2|dkr6| jd js2| jd jr6dS dS r.   )r<   rF   r1  r  )rx   Zargcountr1   r1   r2   Úsignature_has_nongeneric_args9  s    
ÿ
ÿ
þz,DefNodeWrapper.signature_has_nongeneric_argsc                 C   s   | j jS rs   )r  r"  r‚   r1   r1   r2   Úsignature_has_generic_argsA  s    z)DefNodeWrapper.signature_has_generic_argsc                 C   s  g }| j jr| tj¡ | jD ]x}|jjrR|j 	t
 dd¡¡ | d|jj ¡ q|jrˆ|jjsˆ|jjsˆ|jjsˆ| |j |jj¡¡ q| |jj¡ q| jr®| | jjj¡ | jrÄ| | jjj¡ d |¡}| jjsæ| 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  rA  r,  r	   rq  rF   rÿ   r  rÈ   r¾  r   rW  rÎ   rL  r  rä  rú  r²  r‘  r¾  r¿  r¡   rQ  rú   r_  re  rD   rš  r1  )rx   rI   rF   rd  r1   r1   r2   r(  D  s6    

ÿÿþ
 ÿz%DefNodeWrapper.generate_function_bodyc                 C   s€  | j j}| | j¡ | d¡ | d¡ | j  ¡ }|r@| |¡ | |¡ | ¡ |_| j  	||¡ph| j j
}|  ||¡ |  ||¡ | ¡ }| jjr˜d}nd}| jjsÀ| d| j tj¡|f ¡ | ¡  | td| j ƒ¡ |  |||¡ |  |¡ |  |¡ | |j¡ | | j¡ | d¡ | d¡ |j|jkr˜| |j ¡ | !|j¡ |j "¡ D ]\}}	| #||	¡ qZ|  $¡ }
|
d k	r˜| dtj|
f ¡ | !|j ¡ |j%D ],}|j&rª|j'rÊ| (|¡ n
| )|¡ qªt*|j%ƒ}| j+D ]@}|j,jsè|j-|krè|j-j'r| (|j-¡ n| )|j-¡ qè|  .|¡ | /¡  | jjsV| dtj ¡ | d	¡ | 0¡  |r|| d
| ¡ d S )Nr­   z/* Python wrapper */z = 0r2  z%s (wrapper)r=  r”  rQ  r7  rR  )1rš  r%  rÝ   r0   rD   rV  rX  rY  rZ  r[  r\  r^  rb  r@   rQ  r
  rú   rû   r	   re  r“  r”  r   r]   rt  rz  r(  r–  r	  r}  Zlabels_usedr~  r  r€  r  r‚  r„  rð  r‚  rx  rŽ  Zput_var_decrefr¨   rF   rÿ   rÎ   Ú%generate_argument_values_cleanup_coder•  r—  )rx   r}   rI   r  r™  r.  rœ  Zretval_initrL  rÿ   rŸ  rÎ   Zvar_entries_setrd  r1   r1   r2   rÉ   _  sx    





ÿþ











z,DefNodeWrapper.generate_function_definitionsr   c                 C   sŠ  g }| j }|js| jr8dtj }|js.d| }| |¡ | jD ]<}|js>|jsT|j	rf| d|j
 ¡ q>| |j |j
¡¡ q>| jj}|js¤| ¡ tjgkr¤| d¡ |jròdtjtjf }	|jrèdtjtjtjf }
| d|
|	f ¡ n
| |	¡ |jr$tt| jƒ| ¡ ƒD ]}| d| ¡ qd |¡}d	}|jd
krP|jjrPd}d}| j |j ¡}d|||f }| !d| ¡ |r¢| jj"rž| jj"j#||dd d S t$j%rD|j&rD| jj"sD|jj'sD|jrÖ|j(rD|j&}|j)rì| *¡ }|jr |jd
ks| !d|j+| ,¡ f ¡ |jrD| !d¡ | !d|j( ¡ | !d¡ |sT| jj"rx| -d|j. ¡ |j/| jjddd | !d| ¡ d S )Nr<  r=  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;r@  zstatic PyMethodDef %s = r0  )Z
allow_skipz%s {)0r  rA  r!  r	   rq  r,  rF   rž  r1  r  r{  r  rû   rš  rÎ   r‘  r%  r   Zmethod_noargsr"  Ú
args_cnameÚ
kwds_cnameÚuse_fastcallÚnargs_cnamerü  r<   r  r¡   r]   rg  rJ  rQ  rð  rD   rH  r^  r#   ré  r8   Zis_property_scoper3  Z
is_unicodeZas_utf8_stringr2  rx  r_  rI  Zput_pymethoddef)rx   rI   r.  r/  rB  r&  r¦  rd  rÎ   Zvarargs_argsZfastcall_argsrá  r'  rD  rõ  Zdocstrr1   r1   r2   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<|  	¡ r–dt
j }| jjrŒ| d¡ | |¡ | d¡ n
| |¡ | dt
j ¡ d S )NzPyObject *%s = 0;zCYTHON_UNUSED Py_ssize_t %s;ú#if !CYTHON_METH_FASTCALLr@  z"CYTHON_UNUSED PyObject *const *%s;)rF   rž  rz  rD   r{  rd  rÎ   rð  r‚  rM  r	   rV  r  rU  Úkwvalues_cname)rx   r}   rI   rd  rÎ   Z
nargs_coder1   r1   r2   rb     s     





z-DefNodeWrapper.generate_argument_declarationsc           
   	   C   s`  |  ¡ }|j}| d¡}| jdk}| jd k	p8| jd k	p8|}| jD ]}	|	jjs@|	j 	|¡s@q@|  
¡ rä| jjrt| d¡ | d¡ | dtjtjf ¡ | d¡ | dtjtj| dtj ¡|  ¡ f ¡ | d	¡ | jjrä| d	¡ |j t d
d¡¡ | dtj| jjtjtjf ¡ |  
¡ s@|r4t| jdƒ |  |¡ n,|  ¡ sV|  |¡ n|  | j||¡ d| _||_|  |¡rF|  |¡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 )NZargument_unpacking_doner   rW  z#if CYTHON_ASSUME_SAFE_MACROSz%s = PyTuple_GET_SIZE(%s);ú#elsez)%s = PyTuple_Size(%s); if (%s) return %s;z%s < 0r@  Úfastcallr¢  z%s = __Pyx_KwValues_%s(%s, %s);z.This method cannot have * or keyword argumentsTrQ  )/Únew_error_labelr}  rY  r  r¾  r¿  rF   rÿ   r
  rK  rM  r  rU  rD   r	   rV  rS  rŒ  r„  rÈ   r¾  r   rW  rX  Úfastvarr   r0   rý  rL  Úgenerate_stararg_copy_codeÚ'generate_tuple_and_keyword_parsing_codeÚneeds_values_cleanupr|  r~  r€  rQ  Úgenerate_arg_decrefrÎ   rx  Úput_var_xdecref_clearÚput_var_decref_clearr  rŽ  rˆ  rš  r‰  r•  )
rx   r}   rI   Ú	decl_codeÚold_error_labelÚour_error_labelÚ	end_labelZhas_kwonly_argsZhas_star_or_kw_argsrd  r1   r1   r2   rt    sˆ    


ÿÿ


 ÿ
ü


ÿ   ÿ





z-DefNodeWrapper.generate_argument_parsing_codec                 C   s   |r|  |j¡ d S rs   )ra  rÎ   ©rx   rd  rI   r1   r1   r2   Úgenerate_arg_xdecrefi  s    z#DefNodeWrapper.generate_arg_xdecrefc                 C   s   |r|  |j¡ d S rs   )rb  rÎ   rg  r1   r1   r2   r`  m  s    z"DefNodeWrapper.generate_arg_decrefc              	   C   s  | j sT|j t dd¡¡ | dtj ¡ | d| j	 
¡ tj|  ¡ f ¡ | d¡ | jr‚| j sj| jjjsvdtj }q˜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rÈ| jjsÈ| jjrÈt‚| 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_nH| j r| jjrÞt‚|  tj't¡ | d| j jjtj'f ¡ d| j j_d S )NÚRaiseArgTupleInvalidr¢  zif (unlikely(%s > 0)) {z7__Pyx_RaiseArgtupleInvalid(%s, 1, 0, 0, %s); return %s;r7  zunlikely(%s)ú%sz&unlikely(%s) && __Pyx_NumKwargs_%s(%s)ZKeywordStringCheckzFif (%s && unlikely(!__Pyx_CheckKeywordStrings(%s, %s, %d))) return %s;rN  z#%s = __Pyx_KwargsAsDict_%s(%s, %s);zif (unlikely(!%s)) return %s;r6  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È   r¾  r   rW  rD   r	   rV  r_  r]   rx  r„  r¿  rÎ   rí  rT  r  r\  ÚboolrL  rX  r  r   Úput_var_gotrefrx  r!  rš  r  rU  rK  r  r0   ro  rq  r—  r	  r
  r
   Úc_py_ssize_t_typerS  r  )rx   rI   Zkwarg_checkr  r1   r1   r2   r]  q  sÀ    
ÿ  ÿ
  ÿ
ÿ   þÿü ÿ
 ÿ

ý ÿ   ÿ ÿ ÿ
þz)DefNodeWrapper.generate_stararg_copy_codec                    sr  ˆ j  t dd¡¡ | j ¡ }ˆ  d¡}g }g }g }d}	|D ]p}
|
jr<|
jrv|
j	sž|
j
sž|
jrj| |
¡ qž| |
¡ n(|
jrˆ| |
¡ n|
j	sž|
j
sž| |
¡ |
jr<|	d7 }	q<|| }| j| j }t|ƒdkrê|d j	sâ|d j
rê|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}|rªtj}ndtj| jjtjf }| jdkrÔd| }ˆ  d| ¡ |r |  ||||||ˆ ¡ nRˆ j  t dd¡¡ ˆ  dtjtjtj| jr8| jj j!nddd|ˆ  "| j#¡f ¡ | jrd|dksn||krª||kr†| js†d}nd}ˆ  dtj$||f ¡ ˆ  %|¡ | jrZ||krâ| jsâˆ  dtj$|f ¡ ˆ  %|¡ ˆ  d¡ t&|ƒD ]`\}}
|
jsôˆ  '|
j j¡}ˆ j  t dd¡¡ ˆ  (d| j|f ¡ ˆ  ˆ  "| j#¡¡  qÈqônnˆ  d¡ ||kr¢t&|ƒD ]&\}}
ˆ  d|| jjtj)|f ¡ qvn&ˆ  dtj$ ¡ | jrÄˆ  d¡ t*t&|ƒƒd d d… }|D ]b\}}
||d kr"||d d krˆ  d¡ ˆ  (d|d  ¡ ˆ  d|| jjtj)|f ¡ qÞ|dkr`ˆ  d¡ ˆ  (d ¡ ˆ  d!¡ | jrª|r¾t+|d ddƒD ]}ˆ  d"| ¡ qˆˆ  %|¡ nˆ  (d#¡ ˆ  %|¡ ˆ  d$¡ ˆ  d$¡ t&|ƒD ]\}}
|  ,|
d%| ˆ ¡ qÚˆ  d$¡ ˆ  -|¡rnˆ  d&¡}ˆ  %|¡ ˆ  .|¡ ˆ j  t d'd¡¡ ˆ  d(||||tj$ˆ  "| j#¡f ¡ ˆ  .|¡ d S ))NrZ  r¢  Zargtuple_errorr   r   Ú{c                 S   s   g | ]}|j s|‘qS r1   r  rÞ  r1   r1   r2   r…   ë  s      zJDefNodeWrapper.generate_tuple_and_keyword_parsing_code.<locals>.<listcomp>ú,c                    s   g | ]}d ˆ   |jj¡ ‘qS ©ú&%s)Úintern_identifierrÎ   r]   rÞ  rI  r1   r2   r…   í  s     rÿ  zPyObject **%s[] = {%s};z %s && __Pyx_NumKwargs_%s(%s) > 0z
likely(%s)rN  ÚParseKeywordszKif (likely(__Pyx_ParseOptionalKeywords(%s, %s, %s, %s, %s, %s, %s) < 0)) %sr$  z!=ú<z } else if (unlikely(%s %s %d)) {z} else if (unlikely(%s > %d)) {r6  Ú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: r7  z
values[%d]Úskipri  z2__Pyx_RaiseArgtupleInvalid(%s, %d, %d, %d, %s); %s)/rÈ   r¾  r   rW  r]   rx  rY  rž  rò   r1  r  r   r,  r¡  r  r  r<   r¾  rk  r¿  Úgenerate_stararg_init_coderD   Útupler¡   r	   Úpykwdlist_cnameÚ#generate_argument_values_setup_coderT  r  r\  Úgenerate_keyword_unpacking_coderX  rÎ   rL  r  r0   rV  r~  rI  rr  r_  rS  rˆ   rü  Úgenerate_arg_assignmentr|  r€  )rx   rF   rI   rc  Úself_name_csafeÚargtuple_error_labelrÃ  Zrequired_kw_only_argsZoptional_kw_only_argsÚnum_pos_only_argsrd  Zkw_only_argsÚmin_positional_argsÚmax_positional_argsÚhas_fixed_positional_countÚhas_kw_only_argsÚall_argsZnon_posonly_argsZnon_pos_args_idZaccept_kwd_argsZkw_unpacking_conditionÚcomparer^  Úpystring_cnameZreversed_argsZskip_error_handlingr1   rI  r2   r^  ¿  sH   
ÿ



 
ÿ
ÿþ  ÿ     þ
ÿ
ø  ÿ
 ÿ


ÿþ

   ÿ

   ÿ












ÿ  
üz6DefNodeWrapper.generate_tuple_and_keyword_parsing_codec                 C   sÜ   |j jr<|jr t |j tj|¡}|j}| d|j|f ¡ nœ|j j	rÆ|j
rX| d| ¡ | |j  ||jj|j|¡¡ |j
rØ| d¡ | d|jj| |¡f ¡ |j jrº|j|jdd | d¡ nt|jd|j  ƒ d S )Nr”  rN  r6  Tr9  r7  ú2Cannot convert Python object argument to type '%s')rÿ   r
  rž  r
   Ztypecastr   rÎ   rD   rL  Úfrom_py_functionrò   Úfrom_py_call_coder0   r’  rä  rw  r   )rx   rd  r   rI   rÎ   r1   r1   r2   r…    s0    
   ÿ
þz&DefNodeWrapper.generate_arg_assignmentc                 C   s"  | j rBd| j j_| d| j jj| j jj|  ¡ f ¡ | | j j¡ | jrd| jj_|dkr’| jj	rht
‚| tjt¡ | d| jjjtjf ¡ nŒ| d| jjj| jjtj|tjf ¡ | d| jjj | jjj¡ ¡ | j rì| | j j¡ | ¡  | d|  ¡  ¡ | d¡ | | jj¡ d S )Nr   z0%s = PyDict_New(); if (unlikely(!%s)) return %s;r”  z$%s = __Pyx_ArgsSlice_%s(%s, %d, %s);r4  rQ  r7  )r¿  rÎ   rx  rD   rL  r„  rl  r¾  r  rU  rK  ro  r	   rS  r   r\  rV  rÿ   Znullcheck_stringrb  r•  )rx   rŠ  rI   r1   r1   r2   r€  ˜  s<    
ý
   þÿ
z)DefNodeWrapper.generate_stararg_init_codec              	   C   sœ   t |ƒ}| d|d d| ¡f ¡ | jjrN| d| jjtj| jjtjf ¡ t|ƒD ]@\}}|j	rV|j
jrV| |¡}| d|| jj|j
 |¡f ¡ qVd S )NzPyObject* values[%d] = {%s};ro  rÿ  z+%s *%s = __Pyx_CyFunction_Defaults(%s, %s);z%values[%d] = __Pyx_Arg_NewRef_%s(%s);)r<   rD   r¡   rš  rG  r	   Zdynamic_args_cnamerq  rI  rò   rÿ   r
  r’  r  r\  Zas_pyobject)rx   rF   rI   rc  Zmax_argsr^  rd  rW  r1   r1   r2   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 )Nrn  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]);r7  )r_  r	   Zquick_temp_cnamerD   r  r\  )rx   rI   Zloop_varr1   r1   r2   rQ  Í  s    
  ÿ
z4DefNodeWrapper.generate_argument_values_cleanup_codec                 C   sf  d }}	t |ƒD ]$\}
}|jr|	d7 }	|js|d7 }q| d¡ | dtj ¡ | jr`| d¡ t|d |d dƒD ]<}
| d|
d  ¡ | d|
| j	j
tj|
f ¡ | d	¡ qt|dkr| d| ¡ t|d ddƒD ] }
| d|
| j	j
tj|
f ¡ qÚ| d
¡ t|d ddƒD ]"}
| d|
d  ¡ | d	¡ q| d¡ |dkrZ| d
¡ n
| |¡ | js€| d¡ | |¡ | d¡ | j ¡ }| d| j	j
tjf ¡ | js¾|dkrPd}t |ƒD ]\}
}|jsÊ|
}qÊ||k rô|d }||	kr| dtj ¡ t ||	|d … |	ƒD ]\}
}||	kr‚|
|kr‚|
|	krV| d	¡ | jrt|
|krt| d¡ n| d|
 ¡ | |jj¡}|jr|jr¤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¡ | |¡ nR| d¡ |j t dd¡¡ | d|||||
f ¡ | | | j¡¡ | d¡ nT|jr$| d¡ |j t dd¡¡ | d||f ¡ | | | j¡¡ | d¡ q$||	krP| d¡ |rb|  ||¡ | d¡ |	dkr’| d tj|	tj|	f ¡ n|dkr¬| d!tj ¡ |dkr¼d"}n,| jrä| d#||	 ||	 f ¡ d$}nd%}|	t|ƒk r d&|	 }nd'}|j t d(d¡¡ | d)tjtjtj| jr>| jjjp@d"|||| | j¡f ¡ | d¡ d S )*Nr   r   zPy_ssize_t kw_args;rw  rx  r°   rz  rv  ry  r|  r(   r{  r~  r7  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 {ri  r¢  z0__Pyx_RaiseArgtupleInvalid(%s, %d, %d, %d, %d); ru  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;Zused_pos_argsZkwd_pos_argszvalues + %dr$  rs  zMif (unlikely(__Pyx_ParseOptionalKeywords(%s, %s, %s, %s, %s, %s, %s) < 0)) %s) rI  r¡  rò   rD   r	   rV  r¾  rü  r_  r  r\  rS  r~  r]   rx  rT  r  rr  rÎ   r   rX  r  r0   rÈ   r¾  r   rW  Ú,generate_optional_kwonly_args_unpacking_coder<   r‚  r¿  rL  )rx   r‰  rŠ  r‹  rŒ  r  r‡  rI   Znum_required_posonly_argsrˆ  r^  rd  r†  Zlast_required_argr  Zpos_arg_countZvalues_arrayr1   r1   r2   r„  Û  s:   


   ÿ
   ÿ








 ÿ

 


   ÿ ÿ    ÿ






ÿ   þ

ÿ ÿ



  þ


 ÿ

ÿ
ø	z.DefNodeWrapper.generate_keyword_unpacking_codec           	      C   sF  g }d}d}t |ƒD ]8\}}|jr*|d7 }|jr|js8q|s@|}| |j¡ q|dkr`d| }nd}|rBt|ƒdkr¾| d| j rˆdpŠd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r8| d¡ | d¡ d S )Nr°   r   r   z-%dr­   z'if (kw_args > 0 && %s(kw_args <= %d)) {Z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“  r7  )rI  r¡  r   rò   r,  r]   r<   rD   r¿  r  r\  r	   rT  rX  r‚  r  r0   )	rx   r  rI   Zoptional_argsZfirst_optional_argr  r^  rd  Zposonly_correctionr1   r1   r2   r•    sR    
þ
 
ÿ

ûÿ
z;DefNodeWrapper.generate_optional_kwonly_args_unpacking_codec                 C   s"   | j D ]}|jr|  ||¡ qd S rs   )rF   rz  Úgenerate_arg_conversionrª  r1   r1   r2   rý  ¼  s    
z0DefNodeWrapper.generate_argument_conversion_codec                 C   s¢   |j }|j}|jrR|jr*| d|j ¡ n| d|j ¡ |  ||¡ | d¡ nL|jrf|  ||¡ n8| |¡rŠ| d|j	j
|jf ¡ nt|jd||f ƒ d S )NrN  zassert(%s); {r7  r”  z+Cannot convert 1 argument from '%s' to '%s')r  rÿ   r
  rò   rD   r{  Ú%generate_arg_conversion_from_pyobjectÚ#generate_arg_conversion_to_pyobjectrT  rÎ   rL  r   r0   )rx   rd  rI   Úold_typeÚnew_typer1   r1   r2   r–  Ä  s    
z&DefNodeWrapper.generate_arg_conversionc                 C   s@   |j }|jr,| | |j|jj|j|¡¡ nt|jd| ƒ d S )Nr  )	rÿ   r‘  rD   r’  r{  rÎ   rL  r0   r   )rx   rd  rI   rš  r1   r1   r2   r—  ×  s    üz4DefNodeWrapper.generate_arg_conversion_from_pyobjectc              
   C   s\   |j }|j}|rH| d|jj||j| |jj|j¡f ¡ | |j¡ nt	|jd| ƒ d S )Nz%s = %s(%s); %sz5Cannot convert argument of type '%s' to Python object)
r  Zto_py_functionrD   rÎ   rL  r{  r  r0   rl  r   )rx   rd  rI   r™  rO   r1   r1   r2   r˜  ä  s    üz2DefNodeWrapper.generate_arg_conversion_to_pyobjectc                 C   sV  | j D ]B}|jr|  ||¡ q|js|jjs<|jjs<|jjr|  ||¡ q| j	j
jrRttt| j ƒ| j ¡ ƒƒD ]‚}| j	j
jdkrŒ| d¡ | d| ¡ | d| j	j
j| j ¡ |f ¡ | d| | j¡ ¡ | d¡ | j	j
jdkrp| d¡ qp| j	j
jdkrRt| j ƒdkrR| d	¡ | d
| j	j
j ¡ | d| | j¡ ¡ | d¡ 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;r7  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");)rF   rþ  r§  r¤  rÿ   r
  rù   rä  r©  rš  rÎ   r‘  Úreversedrü  r<   r  r  r]   rD   r‰  r  r0   )rx   rI   rd  rá  r1   r1   r2   rz  ñ  sF    
ÿþ
  ÿÿÿ
 
þÿz+DefNodeWrapper.generate_argument_type_testsc                 C   s   | j jS rs   )r  r„  r‚   r1   r1   r2   r„    s    zDefNodeWrapper.error_value)r   ) r?   rc   rd   Zdefnoderš  r_  rz   rŽ   r7  rL  rM  r(  rÉ   r^  rb  rt  rh  r`  r]  r^  r…  r€  rƒ  rQ  r„  r•  rý  r–  r—  r˜  rz  r„  r1   r1   r1   r2   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|Ž d S )NT)rÒ   r¼   r“   )rÑ   rZ   rž  rz   ©rx   r0   rk   rb   r1   r2   rz   ,  s    zGeneratorDefNode.__init__c                    s*   t t| ƒ |¡ | j| j_| j |¡ d S rs   )rZ   rž  rŽ   r%  r   r|   rb   r1   r2   rŽ   1  s    
z%GeneratorDefNode.analyse_declarationsc                 C   sÚ   | j jj}| | j¡}| | j¡}| | j¡}| d¡ | d| j|| j	rV| j	 
|¡ndtj|||| d| j¡f ¡ | tjt¡ | jrºd}| d|tjf ¡ | |t¡ | |t¡ | ¡  | d¡ | d¡ d S )	Nrn  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;r7  )r   rÎ   rð  rr  r]   ÚqualnameÚmodule_namerD   Úgen_type_nameri  rj  r	   rT  r  r0   r  r   rF  rq  ro  r—  r•  )rx   r}   rI   Z
body_cnamer]   r£  r¤  Zclassobj_cnamer1   r1   r2   r(  6  s8    

    üÿ ÿ
z'GeneratorDefNode.generate_function_bodyc                    sH   |  t | jd¡¡ | jj|dd tt| ƒ ||¡ | j ||¡ d S )NúCoroutine.cT)Úproto)	r¾  r   rW  r¥  r   r^  rZ   rž  rÉ   râ   rb   r1   r2   rÉ   N  s    z.GeneratorDefNode.generate_function_definitions)r?   rc   rd   rg  Úis_iterable_coroutiner¥  r#  rÖ  r†   rz   rŽ   r(  rÉ   re   r1   r1   rb   r2   rž    s   rž  c                   @   s   e Zd ZdZdZdS )ÚAsyncDefNodeÚ	CoroutineTN)r?   rc   rd   r¥  rº  r1   r1   r1   r2   r©  U  s   r©  c                   @   s   e Zd ZdZdZdS )ÚIterableAsyncDefNodeZIterableCoroutineTN)r?   rc   rd   r¥  r¨  r1   r1   r1   r2   r«  Z  s   r«  c                   @   s   e Zd ZdZdZdS )ÚAsyncGenNodeZAsyncGenTN)r?   rc   rd   r¥  r»  r1   r1   r1   r2   r¬  _  s   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)r0   r“   r]   Úis_async_gen_bodyr8   rF   r¾  r¿  )rZ   r­  rz   )rx   r0   r]   r“   r®  rb   r1   r2   rz   m  s    
      þzGeneratorBodyDefNode.__init__c                 C   s\   |  |j¡}|  d¡}tj| | }|jd t| j|dd}||_t| j	ƒ|_
d|_|| _d S )NÚ	generatorrë  )rL  r  T)r/  r0  r	   Zgenbody_prefixrj  r   r0   rð  r   r]   r‰  ro  rÎ   )rx   r}   r4  r]   rL  rÎ   r1   r1   r2   Údeclare_generator_bodyr  s    
 ÿz+GeneratorBodyDefNode.declare_generator_bodyc                 C   s   |   |¡ |  |¡ d S rs   )r  r°  r|   r1   r1   r2   rŽ   €  s    
z)GeneratorBodyDefNode.analyse_declarationsc                 C   s@   d| j jtjtjtjf }|r.| d| ¡ n| 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_cnameZlocal_tstate_cnameÚsent_value_cnamerD   )rx   rI   r§  rõ  r1   r1   r2   r^  „  s    üz-GeneratorBodyDefNode.generate_function_headerc              	   C   sÔ  | j }| j ||¡ | |¡ | ¡ |_| | j¡ |  ||¡ | 	d¡ |  
|¡ | ¡ }| 	dtj ¡ | ¡ }| ¡  | | jjpŽ| jj¡ |jjd }|jjd }|s²|râ| ¡  d|j_| jrÔ| j |¡nd }| |¡ |j |jjj¡ | ¡ }	| d¡}
| |
¡ |  |
¡ | 	d| !tj"| j¡ ¡ | j#rÀ| j$d k	rÀ| j$}|t%j&kr`d}n0|t%j'krrd	}n|t%j(kr„d
}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#s”| jj2s”| j3rz|j 4t5 6dd¡¡ | 	d| j3rŒdnd ¡ | 7|j8¡rR| jj2s¸| 9|j:¡ |  |j8¡ | j#ræ| j$d k	ræ| ;tjt+¡ t<j=| >¡ j?j@kr"|j 4t5 6dd¡¡ | 	dtA| j3ƒ ¡ |j B¡ D ]\}}| C||¡ q,| D| jj¡ |  |j:¡ | j#rv| 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 ¡ qd|	 	d$¡ |s˜|r¬|	jFd%|jjG d |	 H¡  |	 	d&¡ |	 	d ¡ | L¡  d S )'Nr­   zPyObject *%s = NULL;r+  r,  TZ	first_runrj  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);Z__Pyx_PyExc_StopAsyncIterationZPyExc_StopIterationZpep479z*__Pyx_Generator_Replace_StopIteration(%d);z#if !CYTHON_USE_EXC_INFO_STACKz+__Pyx_Coroutine_ResetAndClearException(%s);r@  z%s->resume_label = -1;z%__Pyx_Coroutine_clear((PyObject*)%s);r8  rQ  r7  zswitch (%s->resume_label) {zcase 0: goto %s;zcase %d: goto %s;z2default: /* CPython raises the right error here */r5  zreturn NULL;)Mr%  r“   rÉ   rX  rY  rZ  rÝ   r0   rÏ   rD   r^  r@   r	   re  r“  r”  rÎ   r]   r‰  rÈ   rÅ   rh  r	  rs  ri  rj  rk  Zinit_closure_tempsr`  rÿ   rg  Z	use_labelr€  r  r²  Ú
is_inlinedÚinlined_comprehension_typer   Z	list_typeÚset_typeÚ	dict_typer   r  r   r(  rð  rû   rT  r‘  r±  r¼   r®  r¾  r   rW  r|  r}  r~  r  Úput_xdecref_clearr"   Úgenerator_stoprÌ   ÚcontextZfuture_directivesrk  r  r‚  rˆ  r  r’  rC  r•  r–  rr  Zyield_labelsr—  )rx   r}   rI   r  Zclosure_init_coderœ  r+  r,  ri  Zresume_codeZfirst_run_labelÚtarget_typeZ	comp_initrL  rÿ   r^  Úlabelr1   r1   r2   rÉ     sæ    







ÿÿ þ
ÿþ


ÿÿ


ÿ
ÿÿ
ÿ

z2GeneratorBodyDefNode.generate_function_definitions)NNNF)F)r?   rc   rd   r¼  r´  r®  rµ  rz   r°  rŽ   r^  rÉ   re   r1   r1   rb   r2   r­  d  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st|jjržtˆ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à  )r*  r0   r]   rÞ  râ  r1   r2   r…   4  s   ÿz9OverrideCheckNode.analyse_expressions.<locals>.<listcomp>©rã  rF   )Úexpr©rŒ   rÚ   )ru  rF   r]  rã  r­   r  ÚRawCNameExprNoder0   r   Ú	func_noderä  rQ  rú   Úis_returncoderÑ   ÚExprStatNoderå  r“   rh   )rx   r}   Z	first_argZ	call_noder1   râ  r2   rh   *  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r‚| 
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 )Nr£  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_SLOTSZ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);r@  Tr  ZPyObjectGetAttrStrz*%s = __Pyx_PyObject_GetAttrStr(%s, %s); %sz-if (!__Pyx_IsSameCFunction(%s, (void*) %s)) {r7  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]  rH  rÎ   rr  r]   rã  r	   Úmodule_cnamerF   rL  rD   rî  rÈ   r¾  r   rW  Ztp_dict_version_tempZobj_dict_version_tempZtype_dict_guard_tempr	  r
  r   rÁ  Ú	set_cnamer  r0   r  rð  r“   rÊ   r  r
   r  )rx   rI   Zmethod_entryZinterned_attr_cnamerC  Zfunc_node_tempr1   r1   r2   rÊ   ?  s’    

 ÿÿ

ÿ ÿ  ÿ ÿ

ÿ  þ

 ÿ ÿ ÿ ÿ




z)OverrideCheckNode.generate_execution_code)r?   rc   rd   r†   r“   rh   rÊ   r1   r1   r1   r2   rÜ    s   
rÜ  c                   @   s   e Zd ZdS )ÚClassDefNodeN©r?   rc   rd   r1   r1   r1   r2   rÇ  Ž  s   rÇ  c                   @   s˜   e Zd Zddddddddd	d
dg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“   rX   Ú	metaclassÚmkwr^   Úclass_resultrš  Ú
class_cellrê  Ú
orig_basesNFc	              	   C   s  t  | |¡ || _|| _|| _|| _|| _ddlm}	 | jrvt	j
rvt| j| jƒ}|	j||d}
|	jtdƒt|d| _nd }
| }|rd}d| _|jr|jrútt|jƒƒd d d… D ]:\}}|jjd	kr¶| jd k	ràt|jd
ƒ |j| _|j|= q¶|| _n| jd k	st‚n|	 |¡| _|s6| js6| js6| jrÂ| jd krŽ|rX|jsX| j}nd }|sx| jjrx| jjsxn|	j || d| _d}nd}|	j!|||
| d| _"|	j#||| |
|||d| _$n$|	j%|g d| _"|	j&||| |
d| _$|	j||d| _'|	 (| j¡| _)d S )Nr   rÝ  r¿  rq   )r]   rÿ   r0   FTr°   rË  z2keyword argument 'metaclass' passed multiple times)Úclass_def_node)r]   r8   rÐ  )r]   rÐ  r8   Zcalculate_metaclassÚallow_py2_metaclassZ
force_type©rÎ  )r]   rÐ  r8   ró   )*rá   rz   r]   r8   r“   rê  r^   r­   r  r#   ré  r9   r0   Z
StringNoder*  r   r   rÊ  Úis_py3_style_classZis_dict_literalrÎ  rˆ   rI  r§   rŒ   rË  r   rÌ  rK  Ú	ProxyNodeÚis_sequence_constructorrF   ZPyClassMetaclassNodeZPyClassNamespaceNoderX   ZPy3ClassNodeÚclassobjÚDictNodeZ	ClassNoderš  ZClassCellInjectorNoderÎ  )rx   r0   r]   r^   r8   r“   rê  rÄ  Zforce_py3_semanticsr  rÊ  rÑ  r^  r   ZmkdictZneeds_metaclass_calculationr1   r1   r2   rz   °  sˆ     

ÿþ ÿ   ÿ   ü
   ÿzPyClassDefNode.__init__c                 C   sZ   | j rt| jjdƒ dS ddlm} t| jdd| j| jpF|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ë  ©rF   F)r  r¤  Ú
class_namer^   rê  r“   r  r8   )rÓ  r   rÖ  r0   r­   r  ÚCClassDefNoder]   r^   r  rê  r“   r8   ©rx   r  r1   r1   r2   Ú	as_cclassù  s    øzPyClassDefNode.as_cclassc                 C   s0   |}|j s|jr|j}qt| j|d }| _|S )N)r]   râ  )r"  rJ  râ  r   r]   rg  )rx   r}   r&  rš  r1   r1   r2   Úcreate_scope  s
    zPyClassDefNode.create_scopec                 C   sØ   | j  }}| jrLddlm} | jd d d… D ]}||j|j|gd}q,d | _|| _| jrd| j |¡ | j	rv| j	 |¡ | j |¡ | j
 |¡ |  |¡}|j|_| j
jj|_| jr¾| j |¡ | j |¡ | |¡ d S )Nr   )rä  r°   r½  )rÖ  rê  r  rä  r0   rÓ  rÍ  r^   rŽ   rÌ  rš  Úanalyse_target_declarationrÝ  rÅ   rÎ   rL  Úclass_obj_cnamerÊ  r“   r  )rx   r}   Zunwrapped_class_resultrÍ  rä  rÓ  rš  r1   r1   r2   rŽ     s0    
ý
z#PyClassDefNode.analyse_declarationsc                 C   sö   | j rf| j jrt| j jƒdksfddlm}m} | j  |¡}||jd| j	t
 dd¡||ƒgd| _ || _| j rz| j  |¡| _ | jrŽ| j |¡| _| jr¢| j |¡| _| j |¡| _| j |¡| _| j}| j |¡| _| j || j¡| _| j |¡| _| S )Nr   r   )ÚPythonCapiCallNodeÚ	CloneNodeZ__Pyx_PEP560_update_basesZPy3UpdateBasesrÄ  )Úfunction_namerC  Zutility_coderF   )r^   rÕ  r<   rF   r  rà  rá  rh   r0   Úupdate_bases_functyper   rW  rÏ  rÌ  rË  rX   rÍ  rg  r“   rš  Úanalyse_target_expressionrÖ  rÎ  )rx   r}   rà  rá  rÏ  rš  r1   r1   r2   rh   1  s.    
üz"PyClassDefNode.analyse_expressionsc                 C   s"   |   | j|¡ | j | j|¡ d S rs   )rÐ   rg  r“   rÉ   râ   r1   r1   r2   rÉ   J  s    z,PyClassDefNode.generate_function_definitionsc                 C   s  |  | j¡ |j | ¡ | j}| jr0| j |¡ | jrB| j |¡ | jrT| j |¡ | j	rf| j	 |¡ | j
 |¡ | jrà| d| j ¡ | j ¡ f ¡ | | d| j
 ¡ | j ¡ f | j¡¡ | d¡ | j |¡ | j |¡ | j
 ¡  |_|_| j}|d k	r|jsd }|d k	r"| |¡ | j |¡ | j |¡ |d k	rV| || j ¡ ¡ |d k	rt| |¡ | |¡ | 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)r7  )rÝ   r0   Zpyclass_stackr,  rg  rÏ  r  r^   rÌ  rË  rX   rD   rŠ   Zerror_goto_if_negÚgenerate_disposal_coder™  Únamespace_cnamerß  rÎ  Z	is_activer“   rÊ   rÍ  Zgenerate_injection_coderÖ  rš  rœ  Úpop)rx   rI   rš  rÎ  r1   r1   r2   rÊ   N  sn     ÿþÿ



 ÿ


z&PyClassDefNode.generate_execution_code)NNF)r?   rc   rd   r†   rê  rÍ  rÓ  rË  rÌ  rÊ  rÏ  rz   rÜ  rÝ  rŽ   r
   rY  r   rO  rã  rh   rÉ   rÊ   r1   r1   r1   r2   rÉ  ’  s8      ÿ    ÿ
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 )rÚ  r“   NFc                 C   s
   t | jƒS rs   )r    rÙ  r‚   r1   r1   r2   Úpunycode_class_name¨  s    z!CClassDefNode.punycode_class_namec                 C   sD   t | dƒs>ddlm} | jr8|j| j|g | jdd| _nd | _| jS )NÚ_buffer_defaultsr   rË  F)Zneed_complete)rÈ  r­   rÌ  Úbuffer_defaults_noderÏ  Úbuffer_defaults_posré  )rx   r}   rÌ  r1   r1   r2   rÐ  ¬  s    
  ý
zCClassDefNode.buffer_defaultsc                 C   sž   | j r4| jdkr4| j  d¡}| || j¡}|s8d S n|}|j| j| jdd| j d | j| j| j| j	| j
| j|  |¡| jd| _| jršt| jjƒdkršd| jj_d S )Nr7  Ú.r   )r]   r0   rÄ  Úimplementingr¤  r   Úobjstruct_cnameÚtypeobj_cnamer  rh  Ú
check_sizerß  rÐ  Úshadowr   T)r¤  r  Úsplitr¯  r0   Údeclare_c_classrÙ  Úobjstruct_nameÚtypeobj_namerh  rð  rß  rÐ  rñ  rÎ   r^   r<   rF   rÿ   Úmultiple_bases)rx   r}   r«  Ú
home_scoper1   r1   r2   rï  ¸  s0    òzCClassDefNode.declarec                 C   sò   i }| j s|S ddlm} g }| j D ]®}|j}d }t||jƒrH|}|j}t ||¡}|dkrx|rlt	|j
dƒ d|d< q$nP|dkrÈd }	i }
|rºt||jƒr |j}	n|jj}	|j}|rº| ¡ }
|	|
f||< q$| |¡ q$|rèt	|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.)rê  r­   r  rÓ  r=   ÚCallNoderã  r   Z'exprnode_to_known_standard_library_namer   r0   rä  rF   rÃ  rÄ  Zas_python_dictr,  )rx   r}   Úextra_directivesr  Zremaining_decoratorsZoriginal_decoratorrÓ  Zdecorator_callZ
known_namerF   rG   Zkwds_r1   r1   r2   Ú_handle_cclass_decoratorsÓ  sD    
z'CClassDefNode._handle_cclass_decoratorsc                    s  ˆ j rˆjstˆjdƒ ˆ ˆ ¡}d ˆ_ˆjr‚d ˆ_ˆ jD ]}|j	ˆjkr:|ˆ_q:ˆjd kr‚t
ˆjd ˆ jƒˆ_dˆj_ˆ  ˆj¡ ˆjjrÎˆjjd }| ˆ ¡}|tjtjtjfkrÆˆ  | ¡ ¡j}|d krât|jdˆj ƒ n¾|tjkròd }n®|js|jr
|jst|jd| ƒ n„| ¡ s@t|jd|j	ˆjf ƒ n`|jrr|jjrr|j rrt|jd|ˆjf ƒ n.|jrš|j	dkršt|jd	|j	 ƒ n|ˆ_ˆ j !d
d¡dkrÎ|tjkrÎt"ˆjddƒ ˆj#d k	}|rˆjrˆjjsˆjj$ %‡ ‡fdd„¡ d S ˆjrFˆj&dkrFˆj 'd¡}ˆ  (|ˆj¡}	|	sJd S nˆ }	ˆj&dkr˜ˆjdkr˜ˆjt)j*kr˜ˆ j+d d… dkr˜t"ˆjdˆj dƒ |	j,ˆjˆj|o®ˆj-|oºˆj- ˆjˆjˆjˆj.ˆj/ˆj&ˆj0ˆj1ˆ 2ˆ ¡ˆj3dˆ_4ˆjrt5ˆjjƒdkrdˆj4j_6ˆj3r*ˆj4|	 ˆj¡_7|	ˆ k	rTˆj&dkrTˆ  8ˆjˆj4ˆj¡ ˆj4jj ˆ_}
|
d k	rì|rŽˆ j 9¡ |
_|
j :|¡ nˆ j|
_d|
jkrìd}|
jd }|rÜ|d }| !d¡}|oÚ|j;oÚ|j<}|rædnd|
_=ˆj>rt?j@rtAˆjˆj>ƒ|
_>|r€ˆj# B|
¡ ˆj Cd¡}|rj|jDrj|
jEsj|
jFsjˆj Gd¡|_Hˆj Id|j>|j¡ ˆj-rzd|
_End|
_Ft5ˆjjƒdkr0|r ˆj-r´tˆjjd jdƒ ˆjjdd … D ]}| ˆ ¡rÄt|jdƒ qÄdˆj4j_JddlKmL} |jMˆj|jNˆjˆjdˆj|jOˆjg dgd ˆ_Pn8ˆjrXˆjjQpHˆjjJˆj4j_Jd ˆ_Pndˆj4j_Jd ˆ_Pˆ  Rˆj4¡ ˆj4jj$D ]}|ƒ  q~d 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 supportedZfreelistzIfreelists cannot be used on subtypes, only the base class can manage themc                      s
   ˆ  ˆ ¡S rs   )rŽ   r1   rE  r1   r2   Ú<lambda>5  rM  z4CClassDefNode.analyse_declarations.<locals>.<lambda>r7  rì  Ú__builtin__é   zcpython.z %s already a builtin Cython type)r]   r0   rÄ  rí  r¤  r   rî  rï  rð  r  rh  rß  rÐ  rñ  Trù  FÚfrozenrv   Z__dict__getterz'Only declare first base in declaration.z+Only one extension type base class allowed.rÝ  r¿  rÒ  rØ  )Sræ   rô  r   r0   rü  r   r¤  ÚmoduleÚcimported_modulesr]   r   rº  Zhas_extern_classÚadd_imported_moduler^   rF   r  r
   rk  Úc_long_typeZc_float_typer¬  Zsign_and_namerÿ   rÙ  r   r  r¥  rî  r#  rg  rÅ   r.  rÆ  r   r“   Zdefered_declarationsr,  r  rò  r¯  r   Zbuiltin_typesr‰  ró  r  rõ  rð  rh  rß  rÐ  rñ  rÎ   r<   rö  r×  Úadd_imported_entryr   rw   r»   rŒ   Zis_c_dataclass_scoper8   r#   ré  r9   rŽ   rÁ  Zis_variableZdefinedZimplementedZmangle_internalÚgetter_cnameÚdeclare_propertyÚ
early_initr­   r  r  ZIdentifierStringNoder×  Útype_init_argsÚis_externalZallocate_vtable_names)rx   r}   rû  r  r  r   Zbase_class_scopeZhas_bodyr«  r÷  rg  Ú	is_frozenZdataclass_configZdecorator_kwargsZfrozen_flagZ
dict_entryZ
other_baser  Zthunkr1   rE  r2   rŽ   þ  s   





ÿÿ
 ÿ
ÿ ÿ
ÿÿ 

ÿþ
ò




þþ

z"CClassDefNode.analyse_declarationsc                 C   s4   | j r| jjj}| j  |¡| _ | jr0| j |¡ | S rs   )r“   rÎ   rÿ   rg  rh   r
  rî  r1   r1   r2   rh   –  s    
z!CClassDefNode.analyse_expressionsc                 C   s(   | j r$|  | j|¡ | j  | j|¡ d S rs   )r“   rÐ   rg  rÉ   râ   r1   r1   r2   rÉ   ž  s    z+CClassDefNode.generate_function_definitionsc                 C   s¶  |  | j¡ | jjjsžd }| jrf|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 k	rž| |tj	¡ |j |¡ | jr²| j |¡ 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);r7  )Úbases_tuple_cnameÚcheck_heap_type_bases)rÝ   r0   rÎ   rÿ   r	  r
  r	  r
  r
   r   r  rD   rŠ   ro  r  r  r  r  r  rå  r™  Úgenerate_type_ready_coder“   rÊ   )rx   rI   r^   Z
first_baseZ
trial_typeZtrial_type_baser1   r1   r2   rÊ   £  sN     ÿ ÿ





z%CClassDefNode.generate_execution_codec              
   C   sd  | j }|j}|j}|sd S | jdkrN|jrJ|jr4t‚| d|j|jf ¡ d S |sVt‚|js`t‚d|j }| d¡ d }|sÄ|jjrÄ|j	j
tdd}| d||jjj| || j¡f ¡ | |t¡ |sÎ|rj|r|j t dd	¡¡ | | jd
|t d|j¡ |¡|p|f ¡ | d|tj||p,|f ¡ |rT|j|td |j	 |¡ | | || j¡¡ n"| d|tj|| || j¡f ¡ t d|jj¡}	|	 |¡s’| d¡ | d||	j|	 |¡f ¡ dD ]x}
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¡ |rø| !|t¡ | "|t¡ | d |j|f ¡ | d||jf ¡ | d¡ |j}|rª|j#r |j$d!ks | d"|j%rHd#nd$|j$|j%rZd#nd$|j$f ¡ |j t d%d	¡¡ | | jd&|jj ¡ | d¡ qª|j}q| d¡ t |jj¡D ]}| &||¡ qÂ| d¡ | d'¡ |j t d(d	¡¡ | | jd)| ¡ | d¡ | d*¡ | d+| ¡ | d¡ t '|d,¡}t '|d¡}|dkrØ|dkrØ| d¡ |j(r„d-}d.}nd/}d0}|j t |d1¡¡ | d2||f ¡ | d3||f ¡ | d¡ | d¡ | j jj)D ]
}|j*dk}|j+rât,j-râ|j.râ|sât | j jj¡ |j*¡}|r6| /¡ nd }|rJ| |¡ | d4¡ | d5¡ | d6||j*| d7| j¡f ¡ | d8¡ | d9|j. ¡ | d:|j.|j0f ¡ | d;|j. ¡ | d¡ | d¡ | d¡ |râ| d¡ qâ|j1r^|j t d<d=¡¡ | | jd>||j2f ¡ | d¡ |j t d?d=¡¡ | | jd@| ¡ | d¡ |jj3sš|jj 4dA¡sš| | jdBtj| 5|j6¡|f ¡ |j7s¬| 8dC¡nd }|r
|j tkrþdD| }|j%rÚ|j$}n
dE|j$ }| dF||||j9f ¡ nt:|jdGƒ |j7s | 8dH¡r`nd r`|j t dId	¡¡ | d¡ | | jdJ| ¡ | d¡ d S )KNr7  z	%s = &%s;z%s_specz#if CYTHON_USE_TYPE_SPECSTr  z(%s = PyTuple_Pack(1, (PyObject *)%s); %sZValidateBasesTuplezExtensionTypes.cz+__Pyx_validate_bases_tuple(%s.name, %s, %s)Ztp_dictoffsetzB%s = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(%s, &%s, %s);r¦  zG%s = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(%s, &%s, NULL); %sZ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;r7  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.")rY  zL#warning "The buffer protocol is not supported in the Limited C-API < 3.11."r@  ZFixUpExtensionTypez.__Pyx_fix_up_extension_type_from_spec(&%s, %s)z%s.tp_bases = %s;ZPyTypeObjectz#if (sizeof(%s%s) != sizeof(%s%s)) {r­   zstruct ZValidateExternBasez__Pyx_validate_extern_base(%s)z#if !CYTHON_USE_TYPE_SPECSZPyType_Readyz__Pyx_PyType_Ready(%s)z#if PY_MAJOR_VERSION < 3z%s->tp_print = 0;Ztp_getattroZ#__Pyx_PyObject_GenericGetAttrNoDictZPyObject_GenericGetAttrNoDictZ__Pyx_PyObject_GenericGetAttrZPyObject_GenericGetAttrrÄ  z†if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!%s->tp_dictoffset && %s->tp_getattro == PyObject_GenericGetAttr)) {z%s->tp_getattro = %s;rR  rn  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;Z	SetVTableúImportExport.cz__Pyx_SetVtable(%s, %s)ZMergeVTablesz__Pyx_MergeVtables(%s)Z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'Z__reduce_cython__ZSetupReducez#__Pyx_setup_reduce((PyObject *) %s));rÿ   rn  rg  r  rï  rK  rD   rN  r   r	  r
  r   r  r0   r  rÈ   r¾  r   rW  Zput_error_if_negr   Zget_slot_by_namerÅ   Z	slot_coder	   rÅ  r¸  r  Zis_emptyZ	slot_namer¶  r·  Zget_base_slot_functionro  r—  r  rî  rh  Zgenerate_dynamic_init_codeZget_slot_code_by_namer.  Zpyfunc_entriesr]   r‘  r#   ré  r3  r¸  r2  Zvtable_cnameZvtabptr_cnameZis_internalrÆ  rr  rÙ  Zis_closure_class_scoperÁ  rL  r   )rÎ   rI   r  r  rÿ   rn  rg  Ztypespec_cnameZ
tuple_tempZbuffer_slotZbuffer_method_namer   r¹  Zgetattr_slot_funcZdictoffset_slot_funcZpy_cfuncZutility_funcrO   rù   r™  Zweakref_entryZtp_weaklistoffsetZ	objstructr1   r1   r2   r  Ô  sì   

þ


ý

ÿ
ýüüÿ	
ýÿÿ  ýþ  þ







ÿ
 ÿ
þ
  þ
ÿ
ÿ





ÿ



 ÿÿ ÿ


ÿÿÿÿ


ýÿÿÿÿÿÿÿ



ÿ
þ

ÿ


ý
ü

ÿ
z&CClassDefNode.generate_type_ready_codec                 C   s(   | j r| j  |¡ | jr$| j |¡ d S rs   )r
  r”   r“   r   r1   r1   r2   r”   Ó  s    zCClassDefNode.annotate)NF)r?   rc   rd   r†   rê  rë  rh  rß  rô  rõ  rð  rê  rñ  r£  rè  rÐ  rï  rü  rŽ   rh   rÉ   rÊ   rà   r  r”   r1   r1   r1   r2   rÚ  ‡  s2   
+ 1   rÚ  c                   @   s:   e Zd ZdgZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ ZdS )ÚPropertyNoder“   c                 C   s*   |  | j| j| j¡| _| j | jj¡ d S rs   )r  r]   r8   r0   rÎ   r“   rŽ   rg  r|   r1   r1   r2   rŽ   ä  s    z!PropertyNode.analyse_declarationsc                 C   s   | j  |¡| _ | S rs   ré   r|   r1   r1   r2   rh   è  s    z PropertyNode.analyse_expressionsc                 C   s   | j  ||¡ d S rs   rê   râ   r1   r1   r2   rÉ   ì  s    z*PropertyNode.generate_function_definitionsc                 C   s   d S rs   r1   r   r1   r1   r2   rÊ   ï  s    z$PropertyNode.generate_execution_codec                 C   s   | j  |¡ d S rs   rë   r   r1   r1   r2   r”   ò  s    zPropertyNode.annotateNrì   r1   r1   r1   r2   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"t|ƒ‚|d S r  )r“   rÒ   r=   rý  rK  ©rx   rÒ   r1   r1   r2   rç    s    zCPropertyNode.cfuncc                 C   sN   t | j|d}| j |¡ |j| j| j| j| jj|d }| _	| jj	j
|_d S )N)Zclass_scope)ÚctypeZproperty_scope)r   r]   r“   rŽ   r  r8   r0   rç  rQ  rÎ   rL  r  )rx   r}   rg  rÎ   r1   r1   r2   rŽ     s        ÿz"CPropertyNode.analyse_declarationsc                 C   s   | j  |¡| _ | S rs   ré   r|   r1   r1   r2   rh     s    z!CPropertyNode.analyse_expressionsc                 C   s   | j  ||¡ d S rs   rê   râ   r1   r1   r2   rÉ     s    z+CPropertyNode.generate_function_definitionsc                 C   s   d S rs   r1   r   r1   r1   r2   rÊ     s    z%CPropertyNode.generate_execution_codec                 C   s   | j  |¡ d S rs   rë   r   r1   r1   r2   r”     s    zCPropertyNode.annotateN)r?   rc   rd   rq   r†   r¾   r£  rç  rŽ   rh   rÉ   rÊ   r”   r1   r1   r1   r2   r  ö  s   
r  c                   @   s(   e Zd Zg Zdd„ Zdd„ Zdd„ ZdS )Ú
GlobalNodec                 C   s   | j D ]}| || j¡ qd S rs   )ÚnamesZdeclare_globalr0   ©rx   r}   r]   r1   r1   r2   rŽ   #  s    
zGlobalNode.analyse_declarationsc                 C   s   | S rs   r1   r|   r1   r1   r2   rh   '  s    zGlobalNode.analyse_expressionsc                 C   s   d S rs   r1   r   r1   r1   r2   rÊ   *  s    z"GlobalNode.generate_execution_codeNr  r1   r1   r1   r2   r    s   r  c                   @   s(   e Zd Zg Zdd„ Zdd„ Zdd„ ZdS )ÚNonlocalNodec                 C   s   | j D ]}| || j¡ qd S rs   )r  Zdeclare_nonlocalr0   r  r1   r1   r2   rŽ   5  s    
z!NonlocalNode.analyse_declarationsc                 C   s   | S rs   r1   r|   r1   r1   r2   rh   9  s    z NonlocalNode.analyse_expressionsc                 C   s   d S rs   r1   r   r1   r1   r2   rÊ   <  s    z$NonlocalNode.generate_execution_codeNr  r1   r1   r1   r2   r  .  s   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ƒrž|j ¡ }|dkrØ| ¡ \}}t|ƒrPt	|j
dƒ |jD ]>\}}| |¡}	|	d kr~t	|j
dƒ qV|j|j|	|j
dd qVt| _n:t|dd ƒd k	rØ|jrÆ| |¡ t| _n|jsÒ|jrØt| _d S )	Nr   rÝ  rï  z!Variable names must be specified.úUnknown typeT)rà  rv  )r­   r  r¾  r=   ZGeneralCallNoderã  rÇ  Úexplicit_args_kwdsr<   r   r0   rÎ  r  rj  rŒ   ÚPassStatNoder>   r‡   r¹   Zdeclare_from_annotationr  Úis_subscript)
rx   r}   r  r¾  rO   rF   rG   Úvarr`  rÿ   r1   r1   r2   rŽ   G  s(    


z!ExprStatNode.analyse_declarationsc                 C   s"   d| j _| j  |¡| _ d| j _| S ré  )r¾  Úresult_is_usedrh   r|   r1   r1   r2   rh   `  s    z ExprStatNode.analyse_expressionsc                 C   s   | j jjr| j jr|  ¡  d S rs   )r¾  rÿ   r
  Úis_tempr~   r|   r1   r1   r2   rÂ   g  s    zExprStatNode.nogil_checkzDiscarding owned Python objectc                 C   sx   |  | j¡ d| j_| j |¡ | jjs\| j ¡ r\| j ¡ }| jjjsNd| }| 	d| ¡ | j 
|¡ | j |¡ d S )NFz
(void)(%s)rœ  )rÝ   r0   r¾  r   r  r!  rŠ   rÿ   rú   rD   rå  r™  )rx   rI   rŠ   r1   r1   r2   rÊ   m  s    

z$ExprStatNode.generate_execution_codec                 C   s   | j  ||¡ d S rs   )r¾  rÉ   râ   r1   r1   r2   rÉ   y  s    z*ExprStatNode.generate_function_definitionsc                 C   s   | j  |¡ d S rs   )r¾  r”   r   r1   r1   r2   r”   |  s    zExprStatNode.annotateN)r?   rc   rd   r†   rŽ   rh   rÂ   r{   rÊ   rÉ   r”   r1   r1   r1   r2   rÃ  @  s   rÃ  c                   @   s   e Zd Zdd„ Zdd„ ZdS )ÚAssignmentNodec                 C   sB   |   |¡}t|tƒr>t|tƒs>|jjjr>|j ¡ r>t| j	dƒ |S )Nz9Storing unsafe C derivative of temporary Python reference)
rg   r=   r"  ÚParallelAssignmentNodeÚrhsrÿ   r÷   Zis_ephemeralr   r0   )rx   r}   rH   r1   r1   r2   rh   ‰  s
    
z"AssignmentNode.analyse_expressionsc                 C   s$   |  | j¡ |  |¡ |  |¡ d S rs   )rÝ   r0   Úgenerate_rhs_evaluation_coderœ  r   r1   r1   r2   rÊ   ”  s    
z&AssignmentNode.generate_execution_codeN)r?   rc   rd   rh   rÊ   r1   r1   r1   r2   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   sl  ddl m} t| j|jƒrö| jj ¡ }|rö| j ¡ \}}|dkr¬t|ƒdkrft	|d j
dƒ d S |d k	r¢| d ¡}|dksˆd|kr˜t	|j
dƒ d S |d }nd	}|d
  |¡}|d krÐt	|d
 j
dƒ d S | j}	|dkrrt|	|jƒrü|	j|	j
fg}
n0t|	|jƒrdd„ |	jD ƒ}
nt	|	j
dƒ d S |
D ]\}}|j|||d|d q0t|ƒdkrj|d | _nd| _n6d| _t|	|jƒs’t	|	j
dƒ |j|	j|| j
d	d nJ|dkr°d| _t|ƒd
ksÔ|d kræt	| jj
dƒ d S g }|jD ]@\}}| |¡}|d krt	|j
dƒ n| |j||j
f¡ qðt|ƒt|jƒk rJd S t| j|jƒsht	| jj
dƒ | jj}t|ƒ}| |||d| jj
¡ |D ]\}}}| |||¡ q’nF|dkröd| _|rÖt	| jjj
dƒ t| jj
| jj|d}| |¡ | jrd S | jr| j |¡ nP| j |¡ | jjs8| jj rh| jj!rh| jj!j"sh| j #¡ }|rh|| jj!_"d S )Nr   rÝ  )rï  Útypedefr(   zInvalid positional argument.r'  r  zInvalid keyword argument.rë  r   r  rï  c                 S   s   g | ]}|j |jf‘qS r1   )r]   r0   ©rƒ   r  r1   r1   r2   r…   Ê  s     z=SingleAssignmentNode.analyse_declarations.<locals>.<listcomp>zInvalid declarationT)rà  r  zInvalid declaration.)r  )re  Úunionz.Struct or union members must be given by name.FZ
fused_typez*fused_type does not take keyword arguments)r]   rV   )$r­   r  r=   r$  rú  rã  rÇ  r  r<   r   r0   Úcompile_time_valuer  r  r*  r]   r  rF   rj  Údeclaration_onlyrÚ  rÎ  r,  rŒ   r   rm  rÙ  rŽ   Úis_assignment_expressionZ0analyse_assignment_expression_target_declarationrÞ  r  r¹   rÎ   r®  Ú!get_known_standard_library_import)rx   r}   r  Ú	func_namerF   rG   Zkwdictr  rÿ   r  Úvarsr  r0   ÚmembersÚmemberr`  r]   rg  Z	fusednodeZstdlib_import_namer1   r1   r2   rŽ   ­  sš    








ÿ ÿ
*
z)SingleAssignmentNode.analyse_declarationsr   c                 C   s´  ddl m} | j |¡| _|  |¡}|r,|S | j |¡| _| j |¡ |  |¡}|rX|S t	| j|j
ƒr†| j | j¡ | j | j¡| _n<| jjjrÂt	| j|jƒsÂ|j| jj| jd d d}| |¡| _| jjjrP| | jd| jj| jjg¡}|r<| j}d| _|jj| _|jj| _| jdkrN| jd krN| 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Ý  )r  rK   Ústopú=Tr5  ZCppExceptionConversionrO  ) r­   r  r$  rg   Ú
unroll_rhsr  ri   Úgil_assignment_checkÚ
unroll_lhsr=   ZMemoryViewIndexNodeZanalyse_broadcast_operationZ$analyse_as_memview_scalar_assignmentrÿ   rø   ÚSliceIndexNoder0   r  Zlookup_operator_for_typesÚis_overloaded_assignmentr=  r)  r¾  r   rW  rS  r  r¹   r»   r
  Úcoerce_to_tempÚcoerce_to_simple)rx   r}   Úuse_tempr  Zunrolled_assignmentr  Úopr$  r1   r1   r2   rg     sP    




ÿÿþ

z"SingleAssignmentNode.analyse_typesc              	   C   s0  ddl m}m} |}d  } } }	}
|jjr8|jj}nh|jjsJ|jjrœt||j	ƒrn|j
sn|jsn|j }}qJt||j	ƒrr|j}|j
}|rš| tj|¡}|j}|r´| tj|¡}nT|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k
rn   t| jdƒ Y d S X n(|jjr–|jj}t|tƒsšd S nd S nd S ||krÂt| jd	||f ƒ d S g }| |¡}|g}|rø|jsø| |¡}| |¡ |r|js| |¡}| |¡ |	r<|	js<| |	¡}	| |	¡ t|ƒD ]à}|j| jt|ƒ|tjd
}|	d k	r®|	 ¡ rš|j|	j }|j| jt|ƒ|d}n|j| jd|	|d}|d k	r| ¡ rð| ¡ rð|j|j }|j| jt|ƒ|d}n|j| jd||d}| |j| j||  |¡d¡ qD|
||fS )Nr   )r  Ú	UtilNodes)rŒ   rX  z*C array iteration requires known end indexc                 S   s&   | d kr|S |   ¡ r| jS tdƒ‚d S )NzNot a constant.)rU  rX  r"  )rH   Z
none_valuer1   r1   r2   Ú	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Œ   rX  rÿ   r;  )ÚoperatorZoperand1Zoperand2r5  )r  r  )!r­   r  r=  rÿ   Ú	is_ctupler&  r÷   rø   r=   r7  rK   r2  r  rS  r
   rm  ZIntNoder0   Ústrr   Zconstant_value_not_setr   r"  Z
LetRefNoder»   r,  rü  rU  rX  ZMulNodeZAddNodeZ	IndexNoderg   )rx   rH   Ztarget_sizer}   r  r=  r  Z
start_nodeZ	stop_nodeZ	step_nodeÚ
check_nodeZ
slice_sizer>  rY   Úrefsr%  Zix_nodeZ
step_valueZindex_valuer1   r1   r2   Úunroll;  sš     
ý"


 ÿ









   ÿ"zSingleAssignmentNode.unrollc              	   C   sŒ   ddl m} g }t||ƒD ]"\}}	| t| j||	| jd¡ qt| j|d |¡}
|rht	| j||
gd}
|d d d… D ]}| 
||
¡}
qv|
S )Nr   )r=  )r  r$  Úfirst)r0   rÒ   r°   )r­   r=  rÉ  r,  r&  r0   rE  r#  rh   rÑ   ZLetNode)rx   rC  rB  Úlhs_listZrhs_listr}   r=  Úassignmentsr  r$  rH   Úrefr1   r1   r2   Ú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 ƒƒr8d S |  | jt	| jjƒ|¡}|sXd S |\}}}|  
||| jj||¡S )Nr   rÝ  c                 s   s   | ]}|j V  qd S rs   )Z
is_starredrÞ  r1   r1   r2   rå   ©  s     z2SingleAssignmentNode.unroll_rhs.<locals>.<genexpr>)r­   r  r=   r  r  ÚanyrF   rD  r$  r<   rI  )rx   r}   r  ÚunrolledrB  rC  r$  r1   r1   r2   r4  ¥  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
ƒ|¡}|sLd S |\}}}|  |||| jj
|¡S ©Nr   rÝ  )r  rÿ   r@  r­   r  r=   r$  r  rD  r<   rF   rI  )rx   r}   r  rK  rB  rC  r  r1   r1   r2   r6  ²  s    

zSingleAssignmentNode.unroll_lhsc                 C   s   | j  |¡ d S rs   ©r$  r  r   r1   r1   r2   r%  À  s    z1SingleAssignmentNode.generate_rhs_evaluation_codec                 C   s:   | j r&| jj| j|| j | j| jd n| j | j|¡ d S )N)r›  r=  r)  )r8  r  rœ  r$  r=  r)  )rx   rI   r›  r1   r1   r2   rœ  Ã  s    ûz-SingleAssignmentNode.generate_assignment_codec                 C   s   | j  ||¡ d S rs   ©r$  rÉ   râ   r1   r1   r2   rÉ   Î  s    z2SingleAssignmentNode.generate_function_definitionsc                 C   s   | j  |¡ | j |¡ d S rs   ©r  r”   r$  r   r1   r1   r2   r”   Ñ  s    zSingleAssignmentNode.annotateN)r   )F)r?   rc   rd   r†   rE  r8  r,  r+  rŽ   rg   rD  rI  r4  r6  r%  rœ  rÉ   r”   r1   r1   r1   r2   r&  š  s   ^
0^
r&  c                   @   sX   e Zd ZddddgZdZdZdZdd„ Zdd	d
„Zdd„ Z	ddd„Z
dd„ Zdd„ ZdS )ÚCascadedAssignmentNoderF  r$  Úcoerced_valuesÚcloned_valuesNc                 C   s   | j D ]}| |¡ qd S rs   )rF  rÞ  )rx   r}   r  r1   r1   r2   rŽ   é  s    
z+CascadedAssignmentNode.analyse_declarationsr   c                 C   sÆ  ddl m}m} tƒ }t| jƒD ]2\}}| |¡ }| j|< | |¡ | |j	¡ q | j
 |¡}t|ƒdkr²tt|ƒƒjr¢| d|| j
g¡}	|	s²| | ¡ |¡}n| | ¡ |¡}|jsÜ|jsÜ|sÐ|jsÐ|j	jrÜ| |¡}n
| |¡}|jrô||ƒn|| _
g | _i }
g | _| jD ]|}|j	jo.| d|| j
g¡}| j |¡ |j	|
kr|j	|j	kr|| j
ƒ}|st| |j	|¡}| j |¡ ||
|j	< qg | _| jD ]&}|
 |j	| j
¡}| j ||ƒ¡ qš| S )Nr   )rá  rÔ  r3  )r  rá  rÔ  r¨   rI  rF  ri   r5  rª   rÿ   r$  rg   r<   ÚnextÚiterr  Zlookup_operatorrS  rç  r¹   r»   r  r
  r9  r:  r!  rQ  Úassignment_overloadsr,  rR  rÆ  )rx   r}   r;  rá  rÔ  Z	lhs_typesr^  r  r$  r<  rQ  Z
overloadedr1   r1   r2   rg   í  sP    
ÿÿÿ



z$CascadedAssignmentNode.analyse_typesc                 C   s   | j  |¡ d S rs   rM  r   r1   r1   r2   r%    s    z3CascadedAssignmentNode.generate_rhs_evaluation_codeFc                 C   sŠ   | j D ]}| |¡ qt| j| j| jƒD ]$\}}}| |¡ |j|||d q(| j D ]}| |¡ | |¡ qT| j	 |¡ | j	 |¡ d S )N)r›  )
rQ  r  rÉ  rF  rR  rU  rœ  rå  r™  r$  )rx   rI   r›  r$  r  ÚoverloadÚ	rhs_valuer1   r1   r2   rœ  !  s    



z/CascadedAssignmentNode.generate_assignment_codec                 C   s   | j  ||¡ d S rs   rN  râ   r1   r1   r2   rÉ   0  s    z4CascadedAssignmentNode.generate_function_definitionsc                 C   sR   | j D ]}| |¡ qt| j| jƒD ]\}}| |¡ | |¡ q$| j |¡ d S rs   )rQ  r”   rÉ  rF  rR  r$  )rx   rI   r$  r  r1   r1   r2   r”   3  s    

zCascadedAssignmentNode.annotate)r   )F)r?   rc   rd   r†   rR  rQ  rU  rŽ   rg   r%  rœ  rÉ   r”   r1   r1   r1   r2   rP  Ö  s   
1
rP  c                   @   s:   e Zd ZdgZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ ZdS )r#  rÒ   c                 C   s   | j D ]}| |¡ qd S rs   rÔ   rÕ   r1   r1   r2   rŽ   L  s    
z+ParallelAssignmentNode.analyse_declarationsc                    s   ‡ fdd„| j D ƒ| _ | S )Nc                    s   g | ]}|j ˆ d d‘qS )r   )r;  )rg   rØ   rÙ   r1   r2   r…   Q  s   ÿz>ParallelAssignmentNode.analyse_expressions.<locals>.<listcomp>rÚ   r|   r1   rÙ   r2   rh   P  s    
ÿz*ParallelAssignmentNode.analyse_expressionsc                 C   s<   |  | j¡ | jD ]}| |¡ q| jD ]}| |¡ q(d S rs   )rÝ   r0   rÒ   r%  rœ  rÞ   r1   r1   r2   rÊ   [  s
    

z.ParallelAssignmentNode.generate_execution_codec                 C   s   | j D ]}| ||¡ qd S rs   rÛ   rÜ   r1   r1   r2   rÉ   b  s    
z4ParallelAssignmentNode.generate_function_definitionsc                 C   s   | j D ]}| |¡ qd S rs   rß   rÞ   r1   r1   r2   r”   f  s    
zParallelAssignmentNode.annotateN©	r?   rc   rd   r†   rŽ   rh   rÊ   rÉ   r”   r1   r1   r1   r2   r#  <  s   r#  c                   @   s<   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   s   | j  |¡ d S rs   ©r  rÞ  r|   r1   r1   r2   rŽ     s    z*InPlaceAssignmentNode.analyse_declarationsc                 C   sl   | j  |¡| _ | j |¡| _| jjs,| jjrB| j  | jj|¡| _ n&| jjjrh| j	dkrh| j  t
j|¡| _ | S )Nz+-)r$  rg   r  ri   Úis_memview_indexÚis_buffer_accessrS  rÿ   Ú	is_stringr?  r
   rm  r|   r1   r1   r2   rg   ‚  s    z#InPlaceAssignmentNode.analyse_typesc                 C   s
  |  | j¡ | j| j }}| |¡ | |¡ | j}|dkrBd}n|dkrVt| jdƒ |jsb|j	r®|j
jrvt| jdƒ |dkrž|j
jrž|jjd sžt| jdƒ | |||¡ n0|jrÂt| 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.)r^  ú%Z	cdivisionz;In-place non-c divide operators not allowed on int buffers.z4Inplace operators not supported on memoryview slicesz
%s %s= %s;)rÝ   r0   r  r$  r  Z generate_subexpr_evaluation_coder?  r   r\  r[  rÿ   r
  r  rÈ   rÅ   Zgenerate_buffer_setitem_codeZis_memview_slicerD   rŠ   Zgenerate_subexpr_disposal_codeZfree_subexpr_tempsrå  r™  )rx   rI   r  r$  Zc_opr1   r1   r2   rÊ   Ž  s,    




z-InPlaceAssignmentNode.generate_execution_codec                 C   s   | j  |¡ | j |¡ d S rs   rO  r   r1   r1   r2   r”   ©  s    zInPlaceAssignmentNode.annotatec                 C   s$   ddl m} | | j| j| j| j¡S rL  )r­   r  Z
binop_noder0   r?  r  r$  rÛ  r1   r1   r2   Úcreate_binop_node­  s    z'InPlaceAssignmentNode.create_binop_nodeN)	r?   rc   rd   r†   rŽ   rg   rÊ   r”   r`  r1   r1   r1   r2   rY  k  s   rY  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_tuplerB   c                 C   sd   | j r| j  |¡}| |¡| _ | j |¡}| |¡| _| t¡ t| jjƒdkr`| jr`| t	¡ | S )Nr   )
rB   rh   Úcoerce_to_pyobjectrb  r¾  Úprinting_utility_coder<   rF   Úappend_newlineÚprinting_one_utility_code)rx   r}   rB   rb  r1   r1   r2   rh   »  s    

z!PrintStatNode.analyse_expressionszPython print statementc              	   C   sü   |  | j¡ | jr*| j |¡ | j ¡ }nd}t| jjƒdkr| jr| jjd }| |¡ | 	d|| ¡ | 
| j¡f ¡ | |¡ | |¡ nJ| j |¡ | 	d|| j ¡ | j| 
| j¡f ¡ | j |¡ | j |¡ | jrø| j |¡ | j |¡ d S )Nrÿ  r   r   z"if (__Pyx_PrintOne(%s, %s) < 0) %sz#if (__Pyx_Print(%s, %s, %d) < 0) %s)rÝ   r0   rB   r  Ú	py_resultr<   rb  rF   re  rD   r  rå  r™  )rx   rI   Zstream_resultrd  r1   r1   r2   rÊ   É  s>    

ýÿ

üÿz%PrintStatNode.generate_execution_codec                 C   s&   | j r| j  ||¡ | j ||¡ d S rs   )rB   rÉ   rb  râ   r1   r1   r2   rÉ   ê  s    z+PrintStatNode.generate_function_definitionsc                 C   s"   | j r| j  |¡ | j |¡ d S rs   )rB   r”   rb  r   r1   r1   r2   r”   ï  s    zPrintStatNode.annotateN)r?   rc   rd   r†   rh   ru   r~   rÂ   r{   rÊ   rÉ   r”   r1   r1   r1   r2   ra  ²  s   !ra  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 )
ÚExecStatNoderF   c                 C   sB   t | jƒD ]&\}}| |¡}| |¡}|| j|< q
| tj¡ | S rs   )rI  rF   rh   rc  r¾  r   Zpyexec_utility_code©rx   r}   r^  rd  r1   r1   r2   rh   ü  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Ý   r0   rF   r  r,  rg  r  r<   r	  r
  r
   r   rD   rå  r™  r  r  r  r  )rx   rI   rF   rd  Ztemp_resultr1   r1   r2   rÊ     s"    

 

ÿz$ExecStatNode.generate_execution_codec                 C   s   | j D ]}| |¡ qd S rs   ©rF   r”   rª  r1   r1   r2   r”     s    
zExecStatNode.annotateN)r?   rc   rd   r†   rh   ru   r~   rÂ   r{   rÊ   r”   r1   r1   r1   r2   rh  õ  s   rh  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 )ÚDelStatNoderF   Fc                 C   s   | j D ]}| |¡ qd S rs   )rF   rÞ  r  r1   r1   r2   rŽ   &  s    
z DelStatNode.analyse_declarationsc                 C   s¶   t | jƒD ]¦\}}| |d ¡ }| j|< |jjs>|jrZ|jjrZ|jr°|jjr°t	|j
dƒ q
|jjrx|jjjrx|  |¡ q
|jjrŽt	|j
dƒ q
|jr¤|jjtjkr¤q
t	|j
dƒ q
| S )NzDeletion of global C variablezDeletion of non-heap C++ objectz&Deletion of non-Python, non-C++ object)rI  rF   rä  rÿ   r
  r¹   rä  rÎ   Z
is_cglobalr   r0   r÷   r   r  r€   r  r  r   Úbytearray_typeri  r1   r1   r2   rh   *  s    zDelStatNode.analyse_expressionsc                 C   s    | j D ]}|jjr|  ¡  qd S rs   )rF   rÿ   r
  r~   r  r1   r1   r2   rÂ   ;  s    
zDelStatNode.nogil_checkzDeleting Python objectc                 C   s”   |  | j¡ | jD ]|}|jjs:|jjs:|jrL|jjtj	krL|j
|| jd q|jjr|jjjr| |¡ | d| ¡  ¡ | |¡ | |¡ qd S )N)Úignore_nonexistingz
delete %s;)rÝ   r0   rF   rÿ   r
  rä  r  r  r   rl  Zgenerate_deletion_coderm  r÷   r   r  r  rD   rŠ   rå  r™  rª  r1   r1   r2   rÊ   B  s$    
ÿþþ ÿ

z#DelStatNode.generate_execution_codec                 C   s   | j D ]}| |¡ qd S rs   rj  rª  r1   r1   r2   r”   Q  s    
zDelStatNode.annotateN)r?   rc   rd   r†   rm  rŽ   rh   rÂ   r{   rÊ   r”   r1   r1   r1   r2   rk    s   rk  c                   @   s    e Zd Zg Zdd„ Zdd„ ZdS )r  c                 C   s   | S rs   r1   r|   r1   r1   r2   rh   [  s    z PassStatNode.analyse_expressionsc                 C   s   d S rs   r1   r   r1   r1   r2   rÊ   ^  s    z$PassStatNode.generate_execution_codeN)r?   rc   rd   r†   rh   rÊ   r1   r1   r1   r2   r  V  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Ú   )rZ   rn  rz   r0   r  rb   r1   r2   rz   h  s    zIndirectionNode.__init__)r?   rc   rd   rq   rz   re   r1   r1   rb   r2   rn  b  s   rn  c                   @   s$   e Zd Zg ZdZdd„ Zdd„ ZdS )ÚBreakStatNodeTc                 C   s   | S rs   r1   r|   r1   r1   r2   rh   q  s    z!BreakStatNode.analyse_expressionsc                 C   s0   |  | j¡ |js t| jdƒ n| |j¡ d S )Nzbreak statement not inside loop)rÝ   r0   Úbreak_labelr   r~  r   r1   r1   r2   rÊ   t  s    z%BreakStatNode.generate_execution_codeN©r?   rc   rd   r†   r¼   rh   rÊ   r1   r1   r1   r2   ro  l  s   ro  c                   @   s$   e Zd Zg ZdZdd„ Zdd„ ZdS )ÚContinueStatNodeTc                 C   s   | S rs   r1   r|   r1   r1   r2   rh     s    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   r0   rÝ   r~  r   r1   r1   r2   rÊ   „  s
    z(ContinueStatNode.generate_execution_codeNrq  r1   r1   r1   r2   rr  |  s   rr  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rv| jr8t| jdƒ | j |¡| _|jsR|jrbt| jjdƒ q”| j |j |¡| _n|js”|j	s”|js”t| 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)
rQ  r   r0   rŒ   Úin_async_genrg   rú   rÂ  rS  r
  )rx   r}   rQ  r1   r1   r2   rh   œ  s&    ÿþz"ReturnStatNode.analyse_expressionsc                 C   s   | j jr|  ¡  d S rs   )rQ  r
  r~   r|   r1   r1   r2   rÂ   ±  s    zReturnStatNode.nogil_checkzReturning Python objectc                 C   s²  |  | j¡ | jsd S | j}| jjrB| tj| j¡ |rB|jrBd }|r
| 	|¡ | jj
rddlm} |jtj| j|j||| jd | |¡ nn| jrÎ|j t dd¡¡ | dtj| ¡ f ¡ | |¡ n0| |¡ | dtj| | j¡f ¡ | |¡ | |¡ nv| jjrf| jrT| jrB|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¹  )Z	lhs_cnameZlhs_typeZlhs_posr$  rI   r:  ZReturnWithStopIterationr¦  z-%s = NULL; __Pyx_ReturnWithStopIteration(%s);r”  r³  z/PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration); z
%s = NULL;)&rÝ   r0   rQ  rŒ   r
  r‚  r	   re  rº   r  rä  r­   rº  Zput_acquire_memoryviewslicerÃ   r˜  Úin_generatorrÈ   r¾  r   rW  rD   rg  rå  r•  r–  r™  rt  r_  r{  rÂ  Ú
put_returnrW  r	  Ztemps_holding_referencer  r~  r  )rx   rI   rŒ   rº  rL  rÿ   r1   r1   r2   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_openmprD   r	   re  )rx   rI   rŒ   r1   r1   r2   rv  ñ  s    
zReturnStatNode.put_returnc                 C   s   | j d k	r| j  ||¡ d S rs   )rŒ   rÉ   râ   r1   r1   r2   rÉ   ö  s    
z,ReturnStatNode.generate_function_definitionsc                 C   s   | j r| j  |¡ d S rs   )rŒ   r”   r   r1   r1   r2   r”   ú  s    zReturnStatNode.annotateN)r?   rc   rd   r†   r¼   ru  rt  rw  rh   rÂ   r{   rÊ   rv  rÉ   r”   r1   r1   r1   r2   rå  Œ  s   :rå  c                   @   sR   e Zd Zddddg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rˆ| j |¡}| jr||jtjksJ|jjs|ddl	m
} ||j| |¡gdd}|j|dd}| |¡| _| jr¦| j |¡}| |¡| _| jrÄ| j |¡}| |¡| _| j rš| jsš| jsš| j }ddlm	} t||jƒr |js |jd k	r|jjs |j}|jrš|jjršddlm}	 |j| _| jdkrZd | _ n@| jd	krš|jrš|jd
krš|jrš|jjrš| jsšd | _ | S )Nr   r  T)rF   Zslow)Zskip_childrenrÝ  )ÚSymtabÚMemoryErrorÚStopIterationÚ__next__)rz  rg   rc  r{  Úwrap_tuple_valuerÿ   r   Z
tuple_typer¥  r  r  r0   r|  r}  r­   r=   rä  rF   rb  rã  r¹   rÎ   Ú
is_builtinr~  r]   Úbuiltin_exc_nameZis_local_scoper!  rJ  Úin_try_block)
rx   r}   rz  r{  r  r|  r}  Úexcr  r~  r1   r1   r2   rh     s\    ÿÿÿÿÿþþýz!RaiseStatNode.analyse_expressionsúRaising exceptionc                 C   s€  |  | j¡ | jdkr0| d| | j¡ ¡ d S | jdkrp| jsp| dtj ¡ | d| d ¡ ¡ d|j_	d S | jr¦| j 
|¡ | j ¡ }| jjrª|j | jj¡ nd}| jrÈ| j 
|¡ | j ¡ }nd}| jrê| j 
|¡ | j ¡ }nd}| jr| j 
|¡ | j ¡ }nd}|j t¡ | d||||f ¡ | j| j| j| jfD ] }|rH| |¡ | |¡ qH| | | j¡¡ d S )	Nr  zPyErr_NoMemory(); %sr€  z%s = 1;rœ  Trÿ  z__Pyx_Raise(%s, %s, %s, %s);)rÝ   r0   r„  rD   r  rz  r	   r‡  r	  r†  r  rg  r¹   rÈ   Zuse_entry_utility_coderÎ   r{  r|  r}  r¾  Úraise_utility_coderå  r™  )rx   rI   Z	type_codeZ
value_codeZtb_codeZ
cause_coder«  r1   r1   r2   rÊ   =  sV    

üÿ

ÿz%RaiseStatNode.generate_execution_codec                 C   sd   | j d k	r| j  ||¡ | jd k	r0| j ||¡ | jd k	rH| j ||¡ | jd k	r`| j ||¡ d S rs   )rz  rÉ   r{  r|  r}  râ   r1   r1   r2   rÉ   l  s    



z+RaiseStatNode.generate_function_definitionsc                 C   sL   | j r| j  |¡ | jr$| j |¡ | jr6| j |¡ | jrH| j |¡ d S rs   )rz  r”   r{  r|  r}  r   r1   r1   r2   r”   v  s    zRaiseStatNode.annotate)r?   rc   rd   r†   r¼   r„  r‚  r…  rh   ru   r~   rÂ   r{   rÊ   rÉ   r”   r1   r1   r1   r2   ry  ÿ  s   */
ry  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   s   | S rs   r1   r|   r1   r1   r2   rh   †  s    z#ReraiseStatNode.analyse_expressionsr‡  c                 C   sÈ   |  | j¡ |jj}|rš|j t¡ | |d t¡ | |d t¡ | 	|d t¡ | 
dt|ƒ ¡ |D ]}| d| ¡ qj| 
¡  | 
| | j¡¡ n*|j t dd¡¡ | 
d| | j¡ ¡ d S )	Nr   r   r(   ú&__Pyx_ErrRestoreWithState(%s, %s, %s);z%s = 0; ZReRaiseExceptionúExceptions.cz__Pyx_ReraiseException(); %s)rÝ   r0   r	  Úexc_varsrÈ   r¾  rƒ  r—  r   r  rD   r  r_  r  r   rW  )rx   rI   r/  Úvarnamer1   r1   r2   rÊ   Œ  s     
ÿz'ReraiseStatNode.generate_execution_codeN)r?   rc   rd   r†   r¼   rh   ru   r~   rÂ   r{   rÊ   r1   r1   r1   r2   r‰    s   r‰  c                   @   sB   e Zd Zdddg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 kstdƒ‚| jd k	s$tdƒ‚| j |¡ d S )Nz0Message should have been replaced in PostParse())rŒ   rK  r  rŽ   r|   r1   r1   r2   rŽ   ª  s    z#AssertStatNode.analyse_declarationsc                 C   s    | j  |¡| _ | j |¡| _| S rs   )r  Úanalyse_temp_boolean_expressionr  rh   r|   r1   r1   r2   rh   ¯  s    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 )NZAssertionsEnabledr‹  z!#ifndef CYTHON_WITHOUT_ASSERTIONSz+if (unlikely(__pyx_assertions_enabled())) {r4  r7  rY  zif ((1)); else %sFr3  r@  )rÈ   r¾  r   rW  rD   rÝ   r0   r  r  rŠ   r  rÊ   rå  r™  r  r   r1   r1   r2   rÊ   ´  s,    
ÿ

ÿÿÿ
z&AssertStatNode.generate_execution_codec                 C   s    | j  ||¡ | j ||¡ d S rs   )r  rÉ   r  râ   r1   r1   r2   rÉ   É  s    z,AssertStatNode.generate_function_definitionsc                 C   s   | j  |¡ | j |¡ d S rs   )r  r”   r  r   r1   r1   r2   r”   Í  s    zAssertStatNode.annotate)
r?   rc   rd   r†   r  rŽ   rh   rÊ   rÉ   r”   r1   r1   r1   r2   rŽ     s   
rŽ  c                   @   s<   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 )Ú
IfStatNodeÚ
if_clausesÚelse_clausec                 C   s,   | j D ]}| |¡ q| jr(| j |¡ d S rs   )r“  rŽ   r”  )rx   r}   Ú	if_clauser1   r1   r2   rŽ   Ú  s    
zIfStatNode.analyse_declarationsc                    s.   ‡ fdd„| j D ƒ| _ | jr*| j ˆ ¡| _| S )Nc                    s   g | ]}|  ˆ ¡‘qS r1   r×   )rƒ   r•  rÙ   r1   r2   r…   á  s     z2IfStatNode.analyse_expressions.<locals>.<listcomp>)r“  r”  rh   r|   r1   rÙ   r2   rh   à  s    zIfStatNode.analyse_expressionsc                 C   s–   |  | j¡ | ¡ }t| jƒ}| js,|d8 }t| jƒD ]\}}|j||||kd q6| jrˆ|  | jj¡ | d¡ | j |¡ | d¡ | 	|¡ d S )Nr   )Úis_lastú
/*else*/ {r7  )
rÝ   r0   rY  r<   r“  r”  rI  rÊ   rD   r€  )rx   rI   rf  Úlastr^  r•  r1   r1   r2   rÊ   æ  s    


z"IfStatNode.generate_execution_codec                 C   s4   | j D ]}| ||¡ q| jd k	r0| j ||¡ d S rs   )r“  rÉ   r”  )rx   r}   rI   Zclauser1   r1   r2   rÉ   õ  s    

z(IfStatNode.generate_function_definitionsc                 C   s,   | j D ]}| |¡ q| jr(| j |¡ d S rs   )r“  r”   r”  )rx   rI   r•  r1   r1   r2   r”   û  s    
zIfStatNode.annotateNrX  r1   r1   r1   r2   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   s   | j  |¡ d S rs   )r“   rŽ   r|   r1   r1   r2   rŽ     s    z!IfClauseNode.analyse_declarationsc                 C   s    | j  |¡| _ | j |¡| _| S rs   )r  r‘  r“   rh   r|   r1   r1   r2   rh     s    z IfClauseNode.analyse_expressionsc                 C   sœ   | j  |¡ | | j¡ | j  ¡ }| jr6d| j|f }| d| ¡ | j  |¡ | j  |¡ | j	 
|¡ |j| jdd |sŽ| j	jsŽ| |¡ | d¡ d S )Nz%s(%s)rN  Fr;  r7  )r  r  rÝ   r0   rŠ   Úbranch_hintrD   rå  r™  r“   rÊ   r¼   r~  )rx   rI   rf  r–  r  r1   r1   r2   rÊ     s    

z$IfClauseNode.generate_execution_codec                 C   s    | j  ||¡ | j ||¡ d S rs   )r  rÉ   r“   râ   r1   r1   r2   rÉ   "  s    z*IfClauseNode.generate_function_definitionsc                 C   s   | j  |¡ | j |¡ d S rs   )r  r”   r“   r   r1   r1   r2   r”   &  s    zIfClauseNode.annotate)
r?   rc   rd   r†   rš  rŽ   rh   rÊ   rÉ   r”   r1   r1   r1   r2   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   s   | j D ]}| |¡ qd S rs   )rœ  r  ©rx   rI   r   r1   r1   r2   Ú"generate_condition_evaluation_code3  s    
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:ry  Fr;  r|  )r<   rœ  rÈ   rÅ   rI  rD   rŠ   rÝ   r0   r“   rÊ   )rx   rI   Znum_conditionsZline_tracing_enabledr^  r   r1   r1   r2   rÊ   7  s    
z&SwitchCaseNode.generate_execution_codec                 C   s*   | j D ]}| ||¡ q| j ||¡ d S rs   )rœ  rÉ   r“   )rx   r}   rI   r   r1   r1   r2   rÉ   D  s    
z,SwitchCaseNode.generate_function_definitionsc                 C   s&   | j D ]}| |¡ q| j |¡ d S rs   )rœ  r”   r“   r  r1   r1   r2   r”   I  s    
zSwitchCaseNode.annotateN)r?   rc   rd   r†   rž  rÊ   rÉ   r”   r1   r1   r1   r2   r›  +  s
   r›  c                   @   s.   e Zd Zdddg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 ]}| |¡ qH| j	d k	r„| d¡ | j	 |¡ | d¡ n
| d¡ | d¡ | j  
|¡ | j  |¡ d S )Nrw  rx  r|  zdefault: break;r7  )r   r  r¡  rž  rÝ   r0   rD   rŠ   rÊ   r”  rå  r™  ©rx   rI   Úcaser1   r1   r2   rÊ   X  s    





z&SwitchStatNode.generate_execution_codec                 C   sB   | j  ||¡ | jD ]}| ||¡ q| jd k	r>| j ||¡ d S rs   )r   rÉ   r¡  r”  )rx   r}   rI   r£  r1   r1   r2   rÉ   o  s
    

z,SwitchStatNode.generate_function_definitionsc                 C   s<   | j  |¡ | jD ]}| |¡ q| jd k	r8| j |¡ d S rs   )r   r”   r¡  r”  r¢  r1   r1   r2   r”   v  s
    

zSwitchStatNode.annotateN)r?   rc   rd   r†   rÊ   rÉ   r”   r1   r1   r1   r2   rŸ  O  s   
rŸ  c                   @   s   e Zd ZdS )ÚLoopNodeNrÈ  r1   r1   r1   r2   r¤  ~  s   r¤  c                   @   s>   e Zd ZdddgZdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ ZdS )ÚWhileStatNoder  r“   r”  c                 C   s"   | j  |¡ | jr| j |¡ d S rs   )r“   rŽ   r”  r|   r1   r1   r2   rŽ   ‹  s    z"WhileStatNode.analyse_declarationsc                 C   s:   | j r| j  |¡| _ | j |¡| _| jr6| j |¡| _| S rs   )r  r‘  r“   rh   r”  r|   r1   r1   r2   rh     s    z!WhileStatNode.analyse_expressionsc                 C   sÐ   |  | j¡ | ¡ }| d¡ | jr\| j |¡ | j |¡ | d| j ¡  ¡ | j |¡ | j	 
|¡ | |j¡ | d¡ |j}| |¡ | jrÂ|  | jj¡ | d¡ | j 
|¡ | d¡ | |¡ d S )Nzwhile (1) {zif (!%s) break;r7  r—  )rÝ   r0   Únew_loop_labelsrD   r  r  rå  rŠ   r™  r“   rÊ   r€  rs  rp  Úset_loop_labelsr”  )rx   rI   Úold_loop_labelsrp  r1   r1   r2   rÊ   ˜  s.    ÿÿ



z%WhileStatNode.generate_execution_codec                 C   s>   | j r| j  ||¡ | j ||¡ | jd k	r:| j ||¡ d S rs   )r  rÉ   r“   r”  râ   r1   r1   r2   rÉ   ¯  s
    
z+WhileStatNode.generate_function_definitionsc                 C   s4   | j r| j  |¡ | j |¡ | jr0| j |¡ d S rs   )r  r”   r“   r”  r   r1   r1   r2   r”   ¶  s
    zWhileStatNode.annotateNrX  r1   r1   r1   r2   r¥  ‚  s   
r¥  c                
   @   s\   e Zd Zddddddddd	d
g
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!  rÿ   ©ru   rz   r0   r
   Zc_bint_type)rx   rª  r«  r¬  r°  r±  r²  r³  r1   r1   r2   rz   Ê  s     özDictIterationNextNode.__init__c                 C   s  ddl m} | j |¡| _| j |¡| _| jr<| j |¡| _| jrx| j |¡| _| | jj	t
j¡| _| j | jj|¡| _| jr¶| j |¡| _|j| jj	t
jd| _| j | jj|¡| _| jrò| j |¡| _| | jj	t
j¡| _| j | jj|¡| _| j |¡| _| S ©Nr   rÝ  r¦  )r­   r  rª  rg   r«  r¬  r°  ri   ÚTempNoder0   r
   r   Úkey_refrS  rÿ   r­  r±  Ú	value_refr®  r²  Ú	tuple_refr¯  r³  ©rx   r}   r  r1   r1   r2   rh   Ø  s&    z)DictIterationNextNode.analyse_expressionsc                 C   s   | j  ||¡ d S rs   )rª  rÉ   râ   r1   r1   r2   rÉ   í  s    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 ]H\}}}|d krnd}n&| |||f¡ | |¡ d| ¡  }| |¡ qV|j tjd¡}| d|| j ¡ | j ¡ | j ¡ |d |d |d	 | j ¡ f ¡ | d
| ¡ | | d| | j¡¡ |j |¡ |D ]\}}}| |¡ q(|D ]\}}}| |¡ qD|D ]"\}}}| ||¡ |  |¡ q`d S )NZ	dict_iterú
Optimize.cr   rq  Fz7%s = __Pyx_dict_iter_next(%s, %s, &%s, %s, %s, %s, %s);r   r   r(   úif (unlikely(%s == 0)) break;ú%s == -1)!rÈ   r¾  r   rW  rª  r  r·  r­  r°  r¸  r®  r±  r¹  r¯  r²  r,  ÚallocaterŠ   r	  r
  r
   rk  rD   rg  r«  r¬  r³  Úerror_goto_ifr0   r  Úgenerate_gotrefrœ  Úrelease)	rx   rI   rG  Ztemp_addressesr  rŠ   rš  ÚaddrÚresult_tempr1   r1   r2   rÊ   ð  sF    þ
ø
z-DictIterationNextNode.generate_execution_code)r?   rc   rd   r†   r­  r·  r®  r¸  r¯  r¹  rz   rh   rÉ   rÊ   r1   r1   r1   r2   r©  ¾  s         þr©  c                   @   sD   e Zd Zddddddg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!  rÿ   r´  )rx   rÅ  r«  r¬  r±  rÆ  r1   r1   r2   rz   "  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Å  rg   r«  r¬  r±  ri   r¶  r0   r
   r   r¸  rS  rÿ   r®  rÆ  rº  r1   r1   r2   rh   -  s    z(SetIterationNextNode.analyse_expressionsc                 C   s   | j  ||¡ d S rs   )rÅ  rÉ   râ   r1   r1   r2   rÉ   8  s    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 )NZset_iterr»  Fz/%s = __Pyx_set_iter_next(%s, %s, &%s, &%s, %s);r¼  r½  )rÈ   r¾  r   rW  rÅ  r  r¸  r¾  r	  r
  r
   rk  rD   rg  r«  rŠ   r¬  rÆ  r¿  r0   r  rÀ  r®  r±  rœ  rÁ  )rx   rI   r¸  rÃ  r1   r1   r2   rÊ   ;  s(    
ú
z,SetIterationNextNode.generate_execution_code)
r?   rc   rd   r†   r®  r¸  rz   rh   rÉ   rÊ   r1   r1   r1   r2   rÄ    s     ÿrÄ  c                 K   s<   d|kr,|d j rt| f|ŽS t| f|ŽS nt| f|ŽS d S )NÚiterator)Úis_asyncÚAsyncForStatNodeÚForInStatNodeÚForFromStatNode)r0   ry   r1   r1   r2   ÚForStatNodeV  s
    
rÌ  c                   @   sR   e Zd Zdddddg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 )Ú_ForInStatNoderš  r   rÇ  r“   r”  NFc                 C   s   t dƒ‚d S )Nz!must be implemented by subclasses)ÚNotImplementedErrorr‚   r1   r1   r2   Ú_create_item_noden  s    z _ForInStatNode._create_item_nodec                 C   s6   | j  |¡ | j |¡ | jr*| j |¡ |  ¡  d S rs   )rš  rÞ  r“   rŽ   r”  rÏ  r|   r1   r1   r2   rŽ   q  s
    z#_ForInStatNode.analyse_declarationsc                 C   sš   | j  |¡| _ | j |¡| _|  ¡  | j |¡| _| js`| jjjsL| jjj	r`| j j 
| jj¡r`n| j | j j|¡| _| j |¡| _| jr–| j |¡| _| S rs   )rš  ri   rÇ  rh   rÏ  r   rÈ  rÿ   r÷   rø   rT  rS  r“   r”  r|   r1   r1   r2   rh   x  s"    ÿÿþz"_ForInStatNode.analyse_expressionsc                 C   s4  |  | j¡ | ¡ }| j |¡ | d¡ | j |¡ | j | j|¡ | j	 
|¡ |  | j¡ | |j¡ | d¡ | j |¡ | jr| d¡nd }| d¡}|j|jg|g|p²|| jd}|  | j¡ |D ]}| j |¡ qÌ| |¡ | j |¡ | jr&| d¡ | |¡ | j 
|¡ | d¡ | |¡ d S )Nz
for (;;) {r7  Zfor_elseZfor_end)Úskip_to_labelr0   r—  )rÝ   r0   r¦  rÇ  r  rD   r   rš  rœ  r“   rÊ   r€  rs  rå  r”  rY  Úlabel_interceptorrp  r§  r™  )rx   rI   r¨  Z
else_labelrf  Úlabel_interceptsrÖ  r1   r1   r2   rÊ   ‰  s<    


ü



z&_ForInStatNode.generate_execution_codec                 C   sF   | j  ||¡ | j ||¡ | j ||¡ | jd k	rB| j ||¡ d S rs   )rš  rÉ   rÇ  r“   r”  râ   r1   r1   r2   rÉ   °  s
    
z,_ForInStatNode.generate_function_definitionsc                 C   sF   | j  |¡ | j |¡ | j |¡ | jr6| j |¡ | j |¡ d S rs   )rš  r”   rÇ  r“   r”  r   r   r1   r1   r2   r”   ·  s    z_ForInStatNode.annotate)r?   rc   rd   r†   r   rÈ  rÏ  rŽ   rh   rÊ   rÉ   r”   r1   r1   r1   r2   rÍ  `  s   
'rÍ  c                   @   s   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   )rx   rÓ  r1   r1   r2   rÏ  Å  s    zForInStatNode._create_item_nodeN)r?   rc   rd   rÈ  rÏ  r1   r1   r1   r2   rÊ  À  s   rÊ  c                   @   s    e Zd ZdZdd„ Zdd„ ZdS )rÉ  Tc                 K   sD   d|kst ‚ddlm} |j|d jd d|d< tj| |f|Ž d S )Nr   r   rÝ  rÇ  )rd  )rK  r­   r  ZAwaitIterNextExprNoder0   rÍ  rz   )rx   r0   ry   r  r1   r1   r2   rz   Ò  s    zAsyncForStatNode.__init__c                 C   s    ddl m} | | j¡| j_d S rL  )r­   r  ZAsyncNextNoderÇ  r   rd  rÛ  r1   r1   r2   rÏ  Ù  s    z"AsyncForStatNode._create_item_nodeN)r?   rc   rd   rÈ  rz   rÏ  r1   r1   r1   r2   rÉ  Ê  s   rÉ  c                   @   sv   e Zd Zddddddg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 rs   )rš  rÔ  rÕ  rÿ   r
  r~   )rx   r}   r„   r1   r1   r2   rÂ   ù  s    zForFromStatNode.nogil_checkc                 C   s.   | j  |¡ | j |¡ | jr*| j |¡ d S rs   )rš  rÞ  r“   rŽ   r”  r|   r1   r1   r2   rŽ   þ  s    z$ForFromStatNode.analyse_declarationsc                 C   s¾   ddl m} | j |¡| _| j |¡| _| j |¡| _| jd k	rlt| j|j	ƒr^t
| jjddƒ | j |¡| _|  |¡ | jj}|js˜|js˜t| 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š  ri   rÔ  rg   rÕ  rÖ  r=   ZUnaryMinusNoder   r0   Úset_up_looprÿ   r
  r±  r   r“   rh   r”  )rx   r}   r  r»  r1   r1   r2   rh     s$    

ÿ
z#ForFromStatNode.analyse_expressionsc                 C   s|  ddl m} | jj}|jr |}n~|jr4t| jjdƒ |jr@t	j
nt	j}| jjjs`t	 || jj¡}| jjjszt	 || jj¡}| jd k	rž| jjjsžt	 || jj¡}| j ||¡| _| j ||¡| _| jjsÔ| j |¡| _| jd k	r| j ||¡| _| jjs| j |¡| _|js|jrJd| _t| j|jƒr:t| jdƒ‚| j| _d | _n.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š  rÿ   r±  Úis_enumr   r0   r
  r
   r  rk  rÔ  Úwidest_numeric_typerÕ  rÖ  rS  r»   r9  Úis_py_targetr=   ZBufferIndexNoder   Úloopvar_nodeÚpy_loopvar_noder¶  rá  rc  )rx   r}   r  r»  Z	loop_typeZc_loopvar_noder1   r1   r2   r×    sB    ÿ


zForFromStatNode.set_up_loopc                 C   s  |  | j¡ | ¡ }| j}| j |¡ | j |¡ | j| j \}}| j	d k	rt| j	 |¡ | j	 
¡ }d|d |f }nd}ddlm} t| j|jƒrž| j |¡ t| j|jƒr¸| j |¡ | jjjrÈtjn| jj}|rê| jsê|j |d¡}	n
| j 
¡ }	|jrF|jsF| jd dkrF| d|	| j 
¡ |||	| j| j 
¡ ||	|f
 ¡ n,| d	|	| j 
¡ ||	| j| j 
¡ |	|f ¡ | j}
|
d krš|rš| | jj||	¡}
|
d k	r¼|
 |¡ | j |
|¡ | j  !|¡ | "|j#¡ |sð| jrð| jj$j%rš| &| 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%rð| 6| 
¡ |j¡ | 7|¡ | d¡ |s$| jr$| j |¡ | j | j|¡ |r>| js>|j 8|	¡ |j9}| :|¡ | j;rv| d¡ | j; !|¡ | d¡ | "|¡ | j <|¡ | j =|¡ | j <|¡ | j =|¡ t| j|jƒrÌ| j 7|¡ t| j|jƒrè| j 7|¡ | j	d k	r| j	 <|¡ | j	 =|¡ 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) {ZGetModuleGlobalNamerÄ  z%__Pyx_GetModuleGlobalName(%s, %s); %sZGetNameInClassz$__Pyx_GetNameInClass(%s, {}, %s); %sr7  r—  )>rÝ   r0   r¦  Ú
from_rangerÔ  r  rÕ  Úrelation_tableZ	relation1rÖ  rŠ   r­   r  r=   rÛ  r¶  r¾  rÜ  rš  rÿ   rØ  r
   r  rÚ  r	  r
  r  rª  Z	relation2rD   rÀ  rœ  r“   rÊ   r€  rs  rÎ   Zis_pyglobalZ
PyTempNoderr  r]   rg  rã  rÈ   r¾  r   rW  rE  ræ  r  rÀ  ZCoerceFromPyTypeNodeZ	temp_codeÚgenerate_result_coder  rÁ  r  rp  r§  r”  rå  r™  )rx   rI   r¨  rß  ÚoffsetZincoprÖ  r  Zloopvar_typeZloopvar_nameZcoerced_loopvar_nodeZtarget_nodeZinterned_cnameZlookup_funcZfrom_py_noderp  r1   r1   r2   rÊ   ?  sØ    



       ü
    ü



ÿ
ÿ
ÿý  ÿ






z'ForFromStatNode.generate_execution_code)r­   ú++)z+1rã  )r­   ú--)z-1rä  )z<=rt  z>=rÞ  c                 C   sl   | j  ||¡ | j ||¡ | j ||¡ | jd k	rB| j ||¡ | j ||¡ | jd k	rh| j ||¡ d S rs   )rš  rÉ   rÔ  rÕ  rÖ  r“   r”  râ   r1   r1   r2   rÉ   ¸  s    

z-ForFromStatNode.generate_function_definitionsc                 C   sX   | j  |¡ | j |¡ | j |¡ | jr6| j |¡ | j |¡ | jrT| j |¡ d S rs   )rš  r”   rÔ  rÕ  rÖ  r“   r”  r   r1   r1   r2   r”   Â  s    zForFromStatNode.annotate)r?   rc   rd   r†   rÚ  rÛ  rÜ  rß  r{   rÂ   rŽ   rh   r×  rÊ   rà  rÉ   r”   r1   r1   r1   r2   rË  Þ  s$   &sû
rË  c                   @   sD   e Zd ZdZddddg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 rs   )ræ  rŽ   rç  r“   r|   r1   r1   r2   rŽ   ï  s    z!WithStatNode.analyse_declarationsc                 C   sT   | j  |¡| _ | j |¡| _| jrBddlm} || jj| jjƒ| _| j	 
|¡| _	| S )Nr   )r¶  )ræ  rg   rç  rš  r  r¶  r0   rÿ   Útarget_tempr“   rh   )rx   r}   r¶  r1   r1   r2   rh   ô  s    z WithStatNode.analyse_expressionsc                 C   s.   | j  ||¡ | j ||¡ | j ||¡ d S rs   )ræ  rÉ   rç  r“   râ   r1   r1   r2   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rjd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  ZPyObjectLookupSpecialrÄ  z-%s = __Pyx_PyObject_LookupSpecial(%s, %s); %sÚ	__aexit__Ú__exit__r”  r7  )&rÝ   r0   rD   ræ  r  r	  r
  r   Zexit_varrÈ   r¾  r   rW  rg  rr  r   rÈ  r  r  r[  r}  rç  rš  rè  r¾  r•  rŠ   r˜  rå  r™  r“   rÊ   r|  rY  r~  r€  r  r  )rx   rI   rd  Zintermediate_error_labelZstep_over_labelr1   r1   r2   rÊ     sJ    

ÿü



z$WithStatNode.generate_execution_code)r?   rc   rd   rq   r†   rç  rè  rŽ   rh   rÉ   rÊ   r1   r1   r1   r2   rå  Í  s   
rå  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   s   | j  |¡ d S rs   rZ  r|   r1   r1   r2   rŽ   B  s    z1WithTargetAssignmentStatNode.analyse_declarationsc                 C   s4   | j  |¡| _ | j  |¡ | jj | j j|¡| _| S rs   )r  ri   r5  Ú	with_noderè  rS  rÿ   r$  r|   r1   r1   r2   rh   E  s    z0WithTargetAssignmentStatNode.analyse_expressionsc                 C   s.   | j  |¡ | j | j |¡ | jj |¡ d S rs   )r$  r  r  rœ  rì  rè  rÁ  r   r1   r1   r2   rÊ   K  s    z4WithTargetAssignmentStatNode.generate_execution_codec                 C   s   | j  |¡ | j |¡ d S rs   rO  r   r1   r1   r2   r”   P  s    z%WithTargetAssignmentStatNode.annotate)
r?   rc   rd   r†   rì  r$  rŽ   rh   rÊ   r”   r1   r1   r1   r2   rë  4  s   
rë  c                   @   sL   e Zd Zdddg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 )ÚTryExceptStatNoder“   Úexcept_clausesr”  Fc                 C   s8   | j  |¡ | jD ]}| |¡ q| jr4| j |¡ d S rs   )r“   rŽ   rî  r”  )rx   r}   Úexcept_clauser1   r1   r2   rŽ   _  s
    
z&TryExceptStatNode.analyse_declarationsc                 C   sr   | j  |¡| _ d}t| jƒD ]6\}}| |¡ }| j|< |rHt|jdƒ |jsd}q|| _| jrn| j |¡| _| S )Nr   zdefault 'except:' must be lastr   )	r“   rh   rI  rî  r   r0   ÚpatternÚhas_default_clauser”  )rx   r}   Zdefault_clause_seenr^  rï  r1   r1   r2   rh   f  s    z%TryExceptStatNode.analyse_expressionszTry-except statementc                    sx  ˆ   | j¡ ˆ  d¡ ˆ j}ˆ j}ˆ j}ˆ  ¡ }ˆ j}ˆ  d¡}ˆ  d¡}ˆ  d¡}	ˆ  d¡}
|rlˆ  d¡nd }|r~ˆ  d¡nd }ˆ  d¡}‡ fd	d
„t	dƒD ƒ‰ˆ  
¡ }ˆ  d¡ |
ˆ _|ˆ _|ˆ _| j ˆ ¡ ˆ j | jdd ˆ  d¡ ˆ j ¡ }ˆ  |¡}|rtˆ j t¡ | js.| d¡ | d¡ | dd dd
„ ˆD ƒ¡ ¡ ˆD ]}| |t¡ qP‡ ‡fdd„}n*dd
„ ˆD ƒ}| dd |¡ ¡ dd„ }|ˆ _|	ˆ _| jj}| jröˆ   | jj¡ ˆ  d¡ | j ˆ ¡ ˆ  d¡ |sö| jj}|rŽ|s$ˆD ]}ˆ  |t¡ qˆ  |¡ ˆ  |¡ |D ]\}}ˆ  ||¡ q2ˆ jj}| ˆ j_| jD ]}| ˆ |¡ q`|ˆ j_| jsŽˆ  |¡ ˆ j ||||
|	g|||||g|sÀˆ  |¡sÀ|nd | jdd}|D ]}|rÒ|ƒ  qÒˆ  |¡r$|sˆ  |¡sˆ  |¡ ˆ  |¡ |r$|ƒ  ˆ  |¡r:ˆ  |¡ ˆ  d¡ ˆD ]}ˆ j !|¡ qH|ˆ _|ˆ _|ˆ _|ˆ _d S )Nrn  Zexception_handledZexcept_errorZexcept_returnZ
try_returnZ	try_breakZtry_continueZtry_endc                    s   g | ]}ˆ j  td ¡‘qS )F©r	  r
  r   ©rƒ   rÖ  rI  r1   r2   r…   ˆ  s   ÿz=TryExceptStatNode.generate_execution_code.<locals>.<listcomp>r+   ú
/*try:*/ {Fr;  r7  rF  rG  z__Pyx_ExceptionSave(%s);rœ   c                 S   s   g | ]}d | ‘qS rp  r1   r(  r1   r1   r2   r…   ž  s     c                     s.   ˆD ]} ˆ   | t¡ qˆ  dd ˆ¡ ¡ d S )Nz__Pyx_ExceptionReset(%s);rœ   )r  r   rD   r¡   ró   ©rI   Zexc_save_varsr1   r2   Úrestore_saved_exception¢  s
    ÿzJTryExceptStatNode.generate_execution_code.<locals>.restore_saved_exceptionc                 S   s   g | ]}d | ‘qS )z	(void)%s;r1   r(  r1   r1   r2   r…   ª  s     z%s /* mark used */r:   c                   S   s   d S rs   r1   r1   r1   r1   r2   rö  ­  s    z/*else:*/ {)rÐ  r0   r<  )"rÝ   r0   rD   r  rp  rs  r[  r}  rY  rü  r@   r“   rÊ   r	  Úall_free_managed_tempsr|  rÈ   r¾  Úreset_exception_utility_coderu  r¡   Úput_xgotrefr   r¼   r”  r¸  r~  r€  Zcurrent_exceptrî  Úgenerate_handling_coderñ  rÑ  r  )rx   rI   Úold_return_labelZold_break_labelZold_continue_labelrd  re  Zexcept_end_labelZexcept_error_labelZexcept_return_labelZtry_return_labelZtry_break_labelZtry_continue_labelZtry_end_labelZsave_excÚtemps_to_clean_upZ	can_raiser  rö  Zmark_vars_usedZnormal_case_terminatesÚ	temp_nameÚ	temp_typeZouter_exceptrï  rÒ  rÖ  rL  r1   rõ  r2   rÊ   w  sÆ    






ÿÿÿ



ÿÿÿ



û




z)TryExceptStatNode.generate_execution_codec                 C   sB   | j  ||¡ | jD ]}| ||¡ q| jd k	r>| j ||¡ d S rs   )r“   rÉ   rî  r”  )rx   r}   rI   rï  r1   r1   r2   rÉ   î  s
    

z/TryExceptStatNode.generate_function_definitionsc                 C   s8   | j  |¡ | jD ]}| |¡ q| jr4| j |¡ d S rs   )r“   r”   rî  r”  )rx   rI   Zexcept_noder1   r1   r2   r”   õ  s
    
zTryExceptStatNode.annotateN)r?   rc   rd   r†   ru  rŽ   rh   ru   r~   rÂ   r{   rÊ   rÉ   r”   r1   r1   r1   r2   rí  U  s   
wrí  c                   @   sL   e Zd ZddddgZdZdZdZdd„ Zd	d
„ Zdd„ Z	dd„ Z
dd„ ZdS )ÚExceptClauseNoderð  rš  r“   r{  NFc                 C   s"   | j r| j  |¡ | j |¡ d S rs   )rš  rÞ  r“   rŽ   r|   r1   r1   r2   rŽ      s    z%ExceptClauseNode.analyse_declarationsc                 C   s€   |j | _| jr<t| jƒD ]"\}}| |¡}| |¡| j|< q| jrnddlm} | 	| j
¡| _| j || j¡| _| j |¡| _| S rL  )r‰  râ  rð  rI  rh   rc  rš  r­   r  ZExcValueNoder0   r{  rä  r“   )rx   r}   r^  rð  r  r1   r1   r2   rh      s    
z$ExceptClauseNode.analyse_expressionsc                    s&  ˆ   | j¡ | jrtdd„ | jD ƒƒ }|rt‡ fdd„tdƒD ƒ}ˆ j t dd¡¡ ˆ  	dt
|ƒ ¡ |d	 ‰nd  }‰| jD ]}| ˆ ¡ q‚d
d„ | jD ƒ}g }ˆrˆ j t dd¡¡ t|ƒdkrê| dˆ|d	 |d f ¡ n| ‡fdd„|D ƒ¡ nft|ƒdkrBˆ 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 kr„| jd k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!¡ qÜ| jr$| j" #|d ¡ | j" ˆ ¡ | j $| j"ˆ ¡ | jd k	rTt%|| jj&ƒD ]\}}| #|¡ q>ˆ  'd$¡}ˆ jj(}|ˆ j_(| j )ˆ ¡ |ˆ j_(| jj*s®|D ]}ˆ  +|t!¡ qˆ  |¡ ˆ  ,ˆ  -¡ |¡D ]6}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 rs   )r»   Ú	is_simpler!  ©rƒ   rð  r1   r1   r2   rå   -   s   ÿz:ExceptClauseNode.generate_handling_code.<locals>.<genexpr>c                    s   g | ]}ˆ j jtd d‘qS ©Tr  rò  ró  rI  r1   r2   r…   3   s   ÿz;ExceptClauseNode.generate_handling_code.<locals>.<listcomp>r+   ÚPyErrFetchRestorer‹  z__Pyx_ErrFetch(&%s, &%s, &%s);r   c                 S   s   g | ]}|  ¡ ‘qS r1   )rg  r  r1   r1   r2   r…   =   s     Z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)Nr1   r  )rz  r1   r2   rå   H   s   ÿz%__Pyx_PyErr_ExceptionMatches2(%s, %s)ZPyErrExceptionMatchesc                 s   s   | ]}d | V  qdS )z __Pyx_PyErr_ExceptionMatches(%s)Nr1   r  r1   r1   r2   rå   U   s   ÿFr  r”  z || ú__Pyx_ErrRestore(%s, %s, %s);r:   c                 S   s   g | ]}d | ‘qS ©ú%s = 0;r1   r(  r1   r1   r2   r…   b   s     rN  z/*except:*/ {rÒ   Tz__Pyx_ErrRestore(0,0,0);r7  c                    s   g | ]}ˆ j jtd d‘qS r  rò  ró  rI  r1   r2   r…   x   s   ÿz&%s, &%s, &%sz"if (__Pyx_GetException(%s) < 0) %sZexcept_)1rÝ   r0   rð  rç   rü  rÈ   r¾  r   rW  rD   r  r  r<   r,  Úextendr	  r
  r
   rk  r¡   rå  r™  r  r‡   r“   Úexcinfo_targetrš  r~  rˆ  râ  Úget_exception_utility_coder  rù  r   r{  Zset_varrœ  rÉ  rF   r¦  rŒ  rÊ   r¼   r¸  rÑ  Zget_loop_labelsrI  r  r§  )rx   rI   rf  Zhas_non_literalsrŒ  rð  ÚpatternsZ	exc_testsZ
match_flagr  Zexc_argsr  ZtempvarrH   r¨  Úold_exc_varsrÖ  r^  r1   )rI   rz  r2   rú  )   sØ    þ

ÿ


ÿ  ÿ
þ

ÿ ÿ

ÿ
þ

ÿÿ
ÿþ



ÿ 
ÿ


$
ÿz'ExceptClauseNode.generate_handling_codec                 C   s*   | j d k	r| j  ||¡ | j ||¡ d S rs   )rš  rÉ   r“   râ   r1   r1   r2   rÉ   §   s    
z.ExceptClauseNode.generate_function_definitionsc                 C   s>   | j r| j D ]}| |¡ q| jr.| j |¡ | j |¡ d S rs   )rð  r”   rš  r“   )rx   rI   rð  r1   r1   r2   r”   ¬   s    
zExceptClauseNode.annotate)r?   rc   rd   r†   r{  r	  Zis_except_asrŽ   rh   rú  rÉ   r”   r1   r1   r1   r2   rÿ  ý  s   ~rÿ  c                   @   sˆ   e Zd Zdddg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 )ÚTryFinallyStatNoder“   Úfinally_clauseÚfinally_except_clauser   TNFc                 C   s   t | ||d}|S )N©r“   r  )r  )r0   r}   r“   r  rH   r1   r1   r2   rÓ   Ï   s    z"TryFinallyStatNode.create_analysedc                 C   s6   | j  |¡ t | j¡| _| j |¡ | j |¡ d S rs   )r“   rŽ   r   Údeepcopyr  r  r|   r1   r1   r2   rŽ   Ô   s    z'TryFinallyStatNode.analyse_declarationsc                 C   sD   | j  |¡| _ | j |¡| _| j |¡| _|jr@|jjs@|j| _| S rs   )r“   rh   r  r  rQ  rú   Úfunc_return_typer|   r1   r1   r2   rh   Ú   s    z&TryFinallyStatNode.analyse_expressionszTry-finally statementc                    s\  ˆ   ˆj¡ ˆ  d¡ ˆ j}ˆ  ¡ }ˆ  ¡ }ˆ j}ˆjs>|ˆ _ˆ  ¡ }ˆ jj	}dˆ j_	ˆj
 ˆ ¡ |ˆ j_	ˆ  d¡ ˆ j ¡ }ˆ   ˆjj¡ ˆ  d¡ ˆ  |¡ ˆjgf‡fdd„	}	ˆjoÂˆ  |¡}
ˆjj }ˆj
jsˆ  d¡ |	ƒ  ˆ ¡ ˆjjsˆ  |¡ ˆ  d¡ |
ršˆ  |¡ ˆ  d¡ ˆjs8ˆ  d	¡ ˆjrHˆ  ¡  |rˆt‡ 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¡ |rTˆ !ˆ |||¡ |r8|D ]}ˆ j "|¡ q$|rJˆ j "|¡ ˆ  |¡ ˆ  #ˆ  ¡ |¡D ]}ˆ $ˆ |¡ qd|D ]}ˆ j "|¡ q|ˆ  d¡ ˆ  |¡ ˆ j%}d}t&t'||ƒƒD ]„\}\}}ˆ  |¡sÚq¼||krî|
rîq¼ˆ  d| ¡ d }||kr¢ˆjr:t‡ fdd„tdƒD ƒƒ}ˆ ˆ g |¡ ˆjjs¢ˆj(r¢ˆjs¢t)ˆ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s6ˆ  |¡ ˆ  d¡ q¼ˆ  |¡ ˆ  d¡ d S )Nrô  r   r7  z/*finally:*/ {c                    s.   | d }t  |¡}|ˆ jkr&|| d< n|}|S r  )r   r  r  )Ú_nextrH   Z	node_copyr‚   r1   r2   Úfresh_finally_clause !  s    


zHTryFinallyStatNode.generate_execution_code.<locals>.fresh_finally_clausez/*normal exit:*/{z/*exception exit:*/{rF  c                    s   g | ]}ˆ j jtjd d‘qS ©Fr  )r	  r
  r
   rk  ró  rI  r1   r2   r…   !  s   ÿz>TryFinallyStatNode.generate_execution_code.<locals>.<listcomp>r(   Fr  c                    s   g | ]}ˆ j jtd d‘qS r  rò  ró  rI  r1   r2   r…   $!  s   ÿé   rn  r+   r1   z%s: {c                    s   g | ]}ˆ j jtd d‘qS r  rò  ró  rI  r1   r2   r…   R!  s   ÿr”  r  ).rÝ   r0   rD   r}  Zall_new_labelsÚget_all_labelsÚhandle_error_caserY  r	  Zin_try_finallyr“   rÊ   r÷  r  Úset_all_labelsÚpreserve_exceptionr|  r¼   r~  r€  ru  Úis_try_finally_in_nogilrA  r  rü  r
  r
   ZCPtrTyperr  rR  Úput_error_catcherrŒ  r  Úput_error_uncatcherr  rÑ  Úput_error_cleanerr  rI  rÉ  r  r=   ÚGILExitNoder	   re  r
  )rx   rI   rd  Z
old_labelsZ
new_labelsr[  Zcatch_labelZwas_in_try_finallyrü  r  Zpreserve_errorZneeds_success_cleanupÚexc_lineno_cnamesÚexc_filename_cnamerŒ  Zfinally_old_labelsr  rL  rÖ  r  r^  rY  Z	old_labelZret_tempr1   )rI   rx   r2   rÊ   å   sð    














þþþ    ÿ





þ
ÿ
þ ÿ





ÿz*TryFinallyStatNode.generate_execution_codec                 C   s4   | j  ||¡ | j ||¡ | jr0| j ||¡ d S rs   )r“   rÉ   r  r  râ   r1   r1   r2   rÉ   w!  s    z0TryFinallyStatNode.generate_function_definitionsc           	   	   C   sø   |j  t¡ |j  t¡ |j  t¡ | jr6|jdd | d¡ | d dd„ |D ƒ¡¡ |D ]\}}| 	||¡ q^| d|dd …  ¡ | d	|d d… d
  ¡ |D ]}| 
|t¡ q¨|ræ| d|d tj|d tj|tjf ¡ | jrô| ¡  d S )NFr@  rG  r:   c                 S   s   g | ]}d | ‘qS r  r1   r(  r1   r1   r2   r…   ‡!  s     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È   r¾  rƒ  r
  Úswap_exception_utility_coder  rB  rD   r¡   r¸  rù  r   r	   Úlineno_cnameÚclineno_cnameÚfilename_cnamerJ  )	rx   rI   rü  rŒ  r   r!  rý  rÿ   r  r1   r1   r2   r  }!  s8    

ÿü   ýz$TryFinallyStatNode.put_error_catcherc              	   C   sþ   |j  t¡ |j  t¡ | jr*|jdd | d¡ |dd … D ]}| |t¡ q@| d|dd …  ¡ | d¡ |d d… D ]}| |t¡ q~| d|d d…  ¡ | jr´| 	¡  | d 
d	d
„ |D ƒ¡¡ |rú| dtj|d tj|d tj|f ¡ d S )NFr@  úif (PY_MAJOR_VERSION >= 3) {r+   ú!__Pyx_ExceptionReset(%s, %s, %s);r7  r  r:   c                 S   s   g | ]}d | ‘qS r  r1   r(  r1   r1   r2   r…   ´!  s     z:TryFinallyStatNode.put_error_uncatcher.<locals>.<listcomp>r"  r   r   )rÈ   r¾  rƒ  rø  r  rB  rD   r  r   rJ  r¡   r	   r$  r%  r&  )rx   rI   rŒ  r   r!  r  r1   r1   r2   r  Ÿ!  s0    

   ýz&TryFinallyStatNode.put_error_uncatcherc                 C   s¸   |j  t¡ | jr|jdd | d¡ |dd … D ]}| |t¡ q4| d|dd …  ¡ | d¡ |d d… D ]}| |t¡ qr| jr’| 	¡  | d 
dgd ¡|dd …  ¡ d S )	NFr@  r'  r+   r(  r7  r:   r  )rÈ   r¾  rø  r  rB  rD   r  r   r¸  rJ  r¡   )rx   rI   rŒ  r  r1   r1   r2   r  »!  s    

z$TryFinallyStatNode.put_error_cleanerc                 C   s   | j  |¡ | j |¡ d S rs   )r“   r”   r  r   r1   r1   r2   r”   Í!  s    zTryFinallyStatNode.annotate)NN)NN)r?   rc   rd   r†   r  r  r  r  r  ru  rà   rÓ   rŽ   rh   ru   r~   rÂ   r{   rÊ   rÉ   r  r  r  r”   r1   r1   r1   r2   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)r?   rc   rd   rq   r  rÂ   r1   r1   r1   r2   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  rz   r  r,  )rx   r0   r+  r“   r  r1   r1   r2   rz   æ!  s       ÿýzGILStatNode.__init__c                 C   sZ   ddl m} |ƒ }| |¡ |js&d S |dkr6tj}ntj}ddlm} | 	||¡| _
d S )Nr   )ÚYieldNodeCollectorÚgilrÝ  )ZParseTreeTransformsr.  ZvisitchildrenZyieldsr
   Zc_gilstate_typeZc_threadstate_ptr_typer­   r  r¶  r,  )rx   r0   r+  r“   r.  Ú	collectorrþ  r  r1   r1   r2   r-  ð!  s    
z'GILStatNode.create_state_temp_if_neededc                    sB   | j dk|_| j dkrd|_| jd k	r2| j |¡ tt| ƒ |¡S )Nr/  T)r+  Z_in_with_gil_blockZhas_with_gil_blockr  rŽ   rZ   r*  r|   rb   r1   r2   rŽ   þ!  s    

z GILStatNode.analyse_declarationsc                 C   sR   |  t dd¡¡ | jd k	r*| j |¡| _|j}| jdk|_t | |¡}||_|S )NZForceInitThreadsr  r>  )r¾  r   rW  r  rh   r>  r+  r  )rx   r}   Ú	was_nogilrH   r1   r1   r2   rh   "  s    
ÿ
zGILStatNode.analyse_expressionsc                 C   sª   |  | j¡ | ¡  | jr2| j |¡ | j ¡ }nd }|jj}| jdkr^|j	|d d|j_n|j
|| j d d|j_t | |¡ | jr–| j |¡ ||j_| ¡  d S )Nr/  )ÚvariableT)r2  Úunknown_gil_stateF)rÝ   r0   Úbegin_blockr,  r¾  rŠ   r	  rC  r+  rB  Zput_release_gilÚscope_gil_state_knownr  rÊ   rÁ  Ú	end_block)rx   rI   r2  Zold_gil_configr1   r1   r2   rÊ   "  s"    

z#GILStatNode.generate_execution_code)N)r?   rc   rd   r)  r†   r,  r5  rz   r-  rŽ   rh   rÊ   re   r1   r1   rb   r2   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   s   | S rs   r1   r|   r1   r1   r2   rh   <"  s    zGILExitNode.analyse_expressionsc                 C   sB   | j r| j  ¡ }nd }| jdkr,| |¡ n|j|| j d d S )Nr/  )r3  )r,  rŠ   r+  rJ  Zput_acquire_gilr5  )rx   rI   r2  r1   r1   r2   rÊ   ?"  s    
z#GILExitNode.generate_execution_code)	r?   rc   rd   rq   r†   r,  r5  rh   rÊ   r1   r1   r1   r2   r  /"  s   r  c                   @   s   e Zd ZdZdd„ ZdS )ÚEnsureGILNodezI
    Ensure the GIL in nogil functions for cleanup before returning.
    c                 C   s   |j dd d S )NFr@  )rB  r   r1   r1   r2   rÊ   P"  s    z%EnsureGILNode.generate_execution_codeN)r?   rc   rd   rq   rÊ   r1   r1   r1   r2   r7  K"  s   r7  c                  C   s   ddl m}  | jS r¸  )r­   rº  r¿  r¹  r1   r1   r2   Úcython_view_utility_codeT"  s    r8  c                   C   s   t  dd¡S ©NZArrayAPIzarrayarray.h©r   rW  r1   r1   r1   r2   rþ  \"  rM  r  c                   C   s   t  dd¡S r9  r:  r1   r1   r1   r2   rþ  ]"  rM  )zcpython.arrayzcpython.array.arrayzcython.view)Z__Pyx_patch_asyncioZPatchAsyncIOr¦  )Z__Pyx_patch_inspectZPatchInspectr¦  )ZasyncioÚinspectc                 C   sŒ   |j jjjD ]z}|j| jkrq| d¡}| d¡}|r<|jpD|oD|j}|sN|r|s|r|jj	rt
| 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   ZNumpyImportArrayzNumpyImportArray.c)rÈ   Zmodule_noderg  r  r]   r¤  rÁ  ro  rÿ   r  r   r0   r¾  r   rW  )rH   rI   Úmodr<  r=  ro  r1   r1   r2   Úcimport_numpy_checkh"  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krÒdd„ | j d¡D ƒ}|d }|j |¡}|}|dd … D ]"}| |¡}| 	||| j¡ |}qx| j
r¶| 	| j
|| j¡ qö| |¡ | 	||| j¡ n$| j
pÜ| j}| 	||| j¡}| j|_| jtkr| t| j ƒ ¡ d S )	Nú$cimport only allowed at module levelr   r°   ©Úrelative_levelrì  c                 S   s   g | ]}t |ƒ‘qS r1   r!   )rƒ   r]   r1   r1   r2   r…   “"  s     z8CImportStatNode.analyse_declarations.<locals>.<listcomp>r   )rã  r   r0   Úfind_moduler¤  Úis_absoluterò  rº  Zfind_submoduleÚdeclare_moduleÚas_namer  r®  Úutility_code_for_cimportsr¾  )	rx   r}   Úmodule_scoper  Ztop_nameZtop_module_scoper]   Úsubmodule_scoperÎ   r1   r1   r2   rŽ   Œ"  s4      ÿ


z$CImportStatNode.analyse_declarationsc                 C   s   | S rs   r1   r|   r1   r1   r2   rh   §"  s    z#CImportStatNode.analyse_expressionsc                 C   s   | j dkrt| |ƒ d S ©NZnumpy©r¤  r?  r   r1   r1   r2   rÊ   ª"  s    
z'CImportStatNode.generate_execution_codeN)r?   rc   rd   r†   rE  rŽ   rh   rÊ   r1   r1   r1   r2   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rf| j|krFt| jdƒ d S | j|krf|jsft| jdƒ d S |j| j| j| jd}|s„d S |j}| 	|¡ | j
D ]Ö\}}}|dkrÔt|j ¡ ƒD ]\}}	| ||	|¡ qºqš| |¡}	|	rêd|	_nj| jd k	oü| jdk}
|jj||| jd	|
d
}|sqš|j|krB| |p6||| j¡ nt|d||f ƒ |	rš|p`|}| ||	|¡ qš| d¡sŠ| d¡rÞ|tkr¤| t| ƒ ¡ | j
D ]2\}}}d||f }|tkrª| t| ƒ ¡ qªd S )NrA  rì  r   z3relative cimport beyond main package is not allowedz:relative cimport from non-package directory is not allowedrB  r;  r   F)Zfrom_moduler0   Zabsolute_fallbackZrelative_importz%Name '%s' not declared in module '%s'ÚcpythonÚcythonú%s.%s)rã  r   r0   r‰  ÚcountrC  Ú
is_packagerD  r¤  r  Úimported_namesrˆ   rÍ   rY   r  r¬  ro  rº  Úparent_modulerF  r)  rH  r¾  )rx   r}   Zqualified_name_componentsrI  r¤  r0   r]   rG  Z
local_namerÎ   Zis_relative_importrJ  rÖ  Zfqnamer1   r1   r2   rŽ   »"  s\    


    ÿ


z(FromCImportStatNode.analyse_declarationsc                 C   s@   |j s
dS |j}|dkr$|js<dS n|js.dS ||jkr<dS dS )Nr   Úclassr   )r­  rÿ   r  Zis_struct_or_unionrf  )rx   rÎ   rf  rÿ   r1   r1   r2   Údeclaration_matchesí"  s    
z'FromCImportStatNode.declaration_matchesc                 C   s   | S rs   r1   r|   r1   r1   r2   rh   û"  s    z'FromCImportStatNode.analyse_expressionsc                 C   s   | j dkrt| |ƒ d S rK  rL  r   r1   r1   r2   rÊ   þ"  s    
z+FromCImportStatNode.generate_execution_code)r?   rc   rd   r†   r¤  rC  rS  rŽ   rV  rh   rÊ   r1   r1   r1   r2   rM  ¯"  s   2rM  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 ]v\}}|dkr<|js.t| jdƒ  d S d|_d| _q| |¡ |jrt| ¡ d kr|t	d| j
jj|f ƒ|j_qd|j_qd S )Nr;  z%import * only allowed at module levelr   rP  r­   )rY   rã  r   r0   Zhas_import_starÚimport_starrÞ  rÎ   r-  r   r  r¤  rŒ   r®  )rx   r}   r]   rš  r1   r1   r2   rŽ   #  s    
ÿ
z'FromImportStatNode.analyse_declarationsc           	   	   C   sV  ddl m} | j |¡| _| | jt¡| _g | _| j	D ]\}}|dkr‚|j
 	¡ D ],\}}|jsR|jjrR| t dd¡¡  q€qRq6| |j¡}|jr|jj|krt|jdƒr|jj| jjjkrÆq6z2|j| jjj| j| jjd}|jj|jkröW q6W n tk
r   Y nX | |d ¡}|jtkr.d }n| j |j|¡}| j |||f¡ q6| S )Nr   rÝ  r;  ZExtTypeTestrÄ  r¤  )r0   rC  )r­   r  r  rh   rÀ  r0   r   r   Úinterned_itemsrY   rÍ   r­  rÿ   r  r¾  r   rW  r¬  r]   rÈ  r¤  rŒ   rD  rŸ   r‰  r•   rä  rS  r,  )	rx   r}   r  r]   rš  rÖ  rÎ   r  Úcoerced_itemr1   r1   r2   rh   "#  s<    
ÿÿz&FromImportStatNode.analyse_expressionsc                 C   s.  |  | j¡ | j |¡ | jrB| dtj| j ¡ | | j¡f ¡ |j	j
tdd}| j |¡ | jrx|j t dd¡¡ | jD ]†\}}}| d|| j ¡ | |¡| || j¡f ¡ | |t¡ |d krØ| | j|¡ n | |¡ | |¡ | ||¡ | |t¡ q~|j	 |¡ | j |¡ | j |¡ d S )Nzif (%s(%s) < 0) %s;Tr  Z
ImportFromr  z!%s = __Pyx_ImportFrom(%s, %s); %s)rÝ   r0   r  r  rX  rD   r	   rg  r  r	  r
  r   r   rÆ  rY  rÈ   r¾  r   rW  rr  r  r  rœ  Zallocate_temp_resultrá  r  r  rå  r™  )rx   rI   Z	item_tempr]   rš  rZ  r1   r1   r2   rÊ   E#  sF    
ýÿ
ÿüÿ

z*FromImportStatNode.generate_execution_codeN)r?   rc   rd   r†   rX  rŽ   rh   rÊ   r1   r1   r1   r2   rW  #  s
   	#rW  c                   @   s   e Zd ZdZdZdS )ÚParallelNodez4
    Base class for cython.parallel constructs.
    N)r?   rc   rd   rq   rÂ   r1   r1   r1   r2   r[  g#  s   r[  c                       sH  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|Ž | d¡p i | _tƒ | _i | _g | _d S )NrG  )	rZ   r\  rz   rÆ  rG  r¨   Úseen_closure_varsÚprivatesÚassigned_nodesr¡  rb   r1   r2   rz   ®#  s
    zParallelStatNode.__init__c              
   C   sB  | j  |¡ d | _| jrøg }tƒ }| jjD ]~}|jj|krNt| j	d|jj ƒ | 
|jj¡ |jjdkrz|jjs¨|j| _q*| jrž|jjdkrž|jjs¨|j| _q*| |¡ q*|| j_z| j |¡| _W qþ tk
rô } zt| jj	dƒ W 5 d }~X Y qþX ni | _| j ¡ D ]4\}}|| jkr.t| j	d| ƒ nt| ||ƒ qd 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]  rk   r¨   rÎ  r§   rŒ   r   r0   rª   rº   Ú	is_prangera  r,  r*  Ú	ExceptionrY   Úvalid_keyword_argumentsr‰   )rx   r}   ÚpairsÚseenZdictitemr½  ry   rž  r1   r1   r2   rŽ   ¿#  s4    

"z%ParallelStatNode.analyse_declarationsc                 C   sì   | j r| j  |¡| _ | jr(| j |¡| _| j |¡| _|  |¡ | j d k	rè| jrr| jj d k	rr| jjsrt| jdƒ nJ| jrŽ| jjsŽt| jdƒ n.| j j	j
r¼| j jr¼| j  |¡dkr¼t| jdƒ | j  ¡ rÐ| j j	jrè| 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]  rh   ra  r“   Úanalyse_sharing_attributesÚparentrb  r   r0   rÿ   r  r»   r*  r   r
  rS  r
   rk  r9  r|   r1   r1   r2   rh   å#  s2    


ÿþ ÿÿz$ParallelStatNode.analyse_expressionsc                 C   sj   | j  ¡ D ]Z\}\}}| jr:| js:|| jj kr:t|dƒ q
| jsP|rPt|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)rG  rY   rb  Úis_parallelrh  r   Úpropagate_var_privatization)rx   r}   rÎ   r0   r<  Úlastprivater1   r1   r2   rg  þ#  s    


z+ParallelStatNode.analyse_sharing_attributesc                 C   sl   ||f| j |< |jjr$t|dƒ dS | jrh| jsF|| jjkrF| jj}n| j}|rh|sX|rh| ||||¡ 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_  rÿ   rä  r   rb  ri  rh  rG  rj  )rx   rÎ   r0   r<  rk  rh  r1   r1   r2   rj  $  s    5

z,ParallelStatNode.propagate_var_privatizationc                 C   s€   | j r| j  ||¡S |j| jk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)rh  Ú_allocate_closure_temprL  r^  r	  r
  rÿ   rª   Úmodified_entriesr,  rD   )rx   rI   rÎ   rL  r1   r1   r2   rl  _$  s    z'ParallelStatNode._allocate_closure_tempc                 C   sp   d}t | j ¡ ƒD ]X\}\}}|s|r.||kr|j ¡ }|r|rN| d¡ d}| d|j|j |¡f ¡ qd S )NTz4/* Initialize private variables to invalid values */Fr”  )Úsortedr_  rY   rÿ   Úinvalid_valuerD   rL  r‘  )rx   rI   ÚexcluderE  rÎ   r<  rk  ro  r1   r1   r2   Úinitialize_privates_to_nanu$  s    



ÿz+ParallelStatNode.initialize_privates_to_nanc                 C   s0   | j }|jj}||j_| |¡ ||j_| ¡ S rs   )Ú1begin_of_parallel_control_block_point_after_declsr	  Úownerr  rŠ   )rx   rI   r¾  rš   rs  r1   r1   r2   Úevaluate_before_block„$  s    
z&ParallelStatNode.evaluate_before_blockc                 C   s&   | j dk	r"| d|  || j ¡ ¡ dS )zS
        Write self.num_threads if set as the num_threads OpenMP directive
        Nz num_threads(%s))r]  r_  rt  r   r1   r1   r2   Ú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)rm  rn  rG  Zfrom_closurerc  rl  )rx   rI   rÎ   r1   r1   r2   Údeclare_closure_privates˜$  s    z)ParallelStatNode.declare_closure_privatesc                 C   s<   | j D ]0\}}| 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)rm  rD   rL  r	  r  )rx   rI   rÎ   rö  r1   r1   r2   Úrelease_closure_privates¥$  s    z)ParallelStatNode.release_closure_privatesr1   c           
      C   sØ   | j }d| _ | jrÔ|j ¡  | _}g g  }}t|ƒD ]*\}}|jsH|jrT| |¡ q4| |¡ q4|rx| 	dd 
|¡ ¡ |r| 	dd 
|¡ ¡ | jrÔtjg}	| jrÀ|	 | j¡ | 	d| j ¡ | 	dd 
|	¡ ¡ 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_pointri  r	  Zstop_collecting_tempsrÀ   rn  r
  rä  r,  r_  r¡   Úbreaking_label_usedr	   Úparallel_whyÚerror_label_usedr  Úparallel_excÚpos_info)
rx   rI   Zexclude_tempsrš   rÀ   r_  Zfirstprivatesr  rÿ   Zshared_varsr1   r1   r2   Úprivatize_temps°$  s&    
z ParallelStatNode.privatize_tempsc                 C   s>   | j r:| js:| d¡ t| jƒD ]\}}|j||dd q d S )Nz/* Clean up any temporaries */Fr9  )ri  Úis_nested_prangerD   rn  rÀ   r¸  )rx   rI   r  rÿ   r1   r1   r2   Ú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[  rd  r  rû  rY  r4  r@   Ú%begin_of_parallel_control_block_pointrr  Ú"undef_builtin_expect_apple_gcc_bugr   r1   r1   r2   Ú!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)r@   Úbegin_of_parallel_blockr   r1   r1   r2   Úbegin_parallel_blockú$  s    	z%ParallelStatNode.begin_parallel_blockc                 C   s®   | j }d| _ | jrª|}| d¡ |jdd | d¡ | d¡ | d¡ | d¡ | d¡ | d	¡ | ¡  | d¡ |  |¡ | ¡  | d
¡ | d¡ | d¡ 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@  ZPy_BEGIN_ALLOW_THREADSú#endif /* _OPENMP */ZPy_END_ALLOW_THREADSrY  z{
z#ifndef _OPENMPz}
)r†  r|  rD   rB  Zput_safer  rJ  )rx   rI   Z
begin_codeZend_coder1   r1   r2   Úend_parallel_block%  s&    











z#ParallelStatNode.end_parallel_blockc           	      C   sV  |  ¡ }|  ¡ }d| _d| _d| _g | _| ¡ }|D ]&}| |¡r4| jpP||jk| _d| _q4| jrl| |¡ t	|ƒD ]ˆ\}}| |¡sˆqt||jk}| 
|¡ |r¤|sÖ||jkr¾d| _|  |¡ | dtj|d f ¡ | jrò| jrò|sò| |¡ qt| |¡ qt| jrR| jr*| jr*| 
|¡ |  |¡ | 
|¡ |rR| jrR| dtj ¡ 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)rY  Úany_label_usedrz  r|  Úparallel_private_tempsr  r|  rs  r~  rI  r€  r}  Úfetch_parallel_exceptionrD   r	   r{  rb  Úsave_parallel_varsrx  )	rx   rI   Úshould_flushZsave_lastprivates_labelZdont_return_labelZ
all_labelsr¼  r^  Zis_continue_labelr1   r1   r2   Útrap_parallel_exit&%  sJ    
ÿ





ÿ


z#ParallelStatNode.trap_parallel_exitc                 C   s<  d| j  }| d| ¡ t j d7  _ | ¡  | j}d}t| j ¡ ƒD ]è\}\}}|rF|jj	r`qF|jj
rŠ|jjsŠ|jjd rŠ|j d¡}n
|j ¡ }d| }	|j}
|d7 }|j ¡ }|rÊd|j |¡ }nd}| d	||	|f ¡ | j |	|
|jf¡ |jj
r|j t d
d¡¡ d|
 }
| d|	|
f ¡ qF| ¡  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   Z
cpp_localsr­   z__pyx_parallel_temp%dr1  z%s %s%s;rN  rO  rP  r”  N)Úcritical_section_counterrx  r\  r4  rƒ  rn  r_  rY   rÿ   r
  r  Zis_fake_referencerÈ   rÅ   Zcpp_optional_declaration_coder  rL  ro  r‘  rD   r  r,  r¾  r   rW  r6  )rx   rI   Úsection_namerš   Z
temp_countrÎ   r<  rk  Z	type_declÚ
temp_cnameÚprivate_cnamero  r›  r1   r1   r2   r  i%  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@  r‹  rH  z'__Pyx_ErrFetchWithState(&%s, &%s, &%s);r"  r7  N)r4  rB  rx  r	   Úparallel_exc_typerD   r}  r   rÉ  Úparallel_pos_infor~  r	  Zuses_error_indicatorr  r  r   rJ  r6  ©rx   rI   r~  r1   r1   r2   rŽ  ž%  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)r4  rB  r—  r	   r–  r   rD   r}  r   rÉ  r~  r—  r  rJ  r6  r˜  r1   r1   r2   Ú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û  rd  r   r1   r1   r2   Úrestore_labelsÙ%  s    ÿzParallelStatNode.restore_labelsc           
      C   sÊ  | j }d| _ d| _| jdk	r4| j |¡ | j |¡ | jrŽ| d| j ¡ | d| j ¡ | dt	j
 ¡ | d¡ | dt	j ¡ | d¡ |rš| j}n| j}|r´| dt	j ¡ | d	t	j ¡ | dt	j ¡ | jD ]*\}}}	|	jrôd
| }| d||f ¡ qÜ| dt	j ¡ |r4| d¡ | |j¡ |rP| d¡ | |j¡ |rl| 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;rN  zg/* This may have been overridden by a continue, break or return in another thread. Prefer the error. */z%s = 4;r7  zint %s;r  rP  r”  rw  z    case 1: z    case 2: z    case 3: z    case 4:)rƒ  rr  r]  rå  r™  r|  rD   r—  r}  r	   r–  r{  rŒ  rz  r  r  r_  r~  rs  rp  r  rÈ   r¾  rƒ  r™  r}  r6  Ú"redef_builtin_expect_apple_gcc_bug)
rx   rI   Úbreak_Ú	continue_Úreturn_rš   rŒ  r”  r•  rþ  r1   r1   r2   Ú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 )z]
        A bug on OS X Lion disallows __builtin_expect macros. This code avoids them
        N)rh  Zundef_builtin_expectÚredef_conditionr   r1   r1   r2   r„  9&  s    z3ParallelStatNode.undef_builtin_expect_apple_gcc_bugc                 C   s   | j s| | j¡ d S rs   )rh  Zredef_builtin_expectr   r   r1   r1   r2   r›  @&  s    z3ParallelStatNode.redef_builtin_expect_apple_gcc_bug)N)r1   )F)FFF)5r?   rc   rd   rq   r†   r“   rb  r€  r|  r]  ra  r	   r–  Zparallel_exc_valueZparallel_exc_tbr}  Zparallel_filenameZparallel_linenoZparallel_clinenor—  r&  r$  r%  r~  r’  rz   rŽ   rh   rg  rj  rl  rq  rt  ru  rv  rw  r  r  r…  r‡  rŠ  r‘  r  rŽ  r™  rš  rŸ  Zbuggy_platform_macro_conditionZhave_expect_conditionr   r„  r›  re   r1   r1   rb   r2   r\  o#  sf   ýýý&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 )Nz=cython.parallel.parallel() does not take positional arguments)rZ   r¡  rŽ   rF   r   r0   r|   rb   r1   r2   rŽ   N&  s    z*ParallelWithBlockNode.analyse_declarationsc                 C   s$  |   |¡ |  |¡ | d¡ | d¡ | jrVd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 r1   )rÿ   r
  rL  )rƒ   r½  r1   r1   r2   r…   \&  s    ÿzAParallelWithBlockNode.generate_execution_code.<locals>.<listcomp>zprivate(%s)rœ   r­   r‰  )rœ  r  rž  )rv  r…  rD   r_  r_  r¡   rn  r@   ry  ru  r4  r‡  rq  r	  Ústart_collecting_tempsr“   rÊ   r‘  r  rŠ  r6  r|  rs  rp  r  rš  rŸ  rw  )rx   rI   r_  r  rœ  rž  r1   r1   r2   rÊ   T&  s:    














þz-ParallelWithBlockNode.generate_execution_code)	r?   rc   rd   rq   rd  r]  rŽ   rÊ   re   r1   r1   rb   r2   r¡  E&  s
   r¡  c                       s”   e Zd ZdZddddddgZd Z Z ZZd Z	 Z
Zd	ZdZdZd
dddg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”  rF   r]  ra  NTÚscheduler>  c                    s"   t t| ƒj|f|Ž t|ƒ| _d S rs   )rZ   r£  rz   r  rÇ  )rx   r0   rG   rb   r1   r2   rz   ‘&  s    zParallelRangeNode.__init__c                    sÂ   t t| ƒ |¡ | j |¡ | jd k	r2| j |¡ | jrFt| jƒdkrVt| j	dƒ d S t| jƒdkrp| j\| _
n0t| jƒdkrŽ| j\| _| _
n| j\| _| _
| _| jdkr¾t| j	d| jf ƒ d S )Nr+   z0Invalid number of positional arguments to pranger   r(   )NZstaticZdynamicZguidedÚruntimez'Invalid schedule argument to prange: %s)rZ   r£  rŽ   rš  rÞ  r”  rF   r<   r   r0   r2  rK   rÖ  r¤  r|   rb   r1   r2   rŽ   –&  s    

z&ParallelRangeNode.analyse_declarationsc                    sR  |j }| j rd|_ | jd kr,t| jdƒ | S | j |¡| _| jjjsn| jjjsdt| jjd| jj ƒ tj	| _
n
| jj| _
d| _| j| j| jf}t|| jƒD ]b\}}|d k	rš| |¡ |jjsÎt|jd| ƒ qš|jsê| |¡}t| ||ƒ t | j
|j¡| _
qš| jd k	r| j |¡| _t| jdd ƒ}|rB| jjd f| j| jj< tt| ƒ |¡}|jrÜ|jsrt|jjdƒ nR|jdkrŽt|jjd	ƒ n6|jjjrÄ|jjrÄ|j |¡d
krÄt|jjdƒ |j  tj!|¡ |¡|_|j rê||_ |j"oø|j"j#|_$|j$rN|}|j"r$|j"j#r$|j"}q|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)rK   r2  rÖ  z%s argument must be numericrÎ   z$Must provide schedule with chunksizer¥  z,Chunksize not valid for the schedule runtimer   zChunksize must not be negative))r>  rš  r   r0   ri   rÿ   r±  r
  r
   rm  Ú
index_typer  rK   r2  rÖ  rÉ  rg   r»   r9  r‰   rÙ  r”  rh   r‡   rG  rÎ   rZ   r£  ra  r¤  r  r*  rS  rk  rh  rb  r€  rw   r_  r`  r  )rx   r}   r1  Ústart_stop_steprH   r]   rJ  rh  rb   r1   r2   rh   ª&  s†    



ÿ



 ÿÿÿÿþ ÿÿ
z%ParallelRangeNode.analyse_expressionsc                 C   sP   d}| j | j| j| jf}t||ƒD ](\}}|d k	r"|jjr"t|jd| ƒ q"d S )N)rK   r2  rÖ  rš  z6%s may not be a Python object as we don't have the GIL)	rK   r2  rÖ  rš  rÉ  rÿ   r
  r   r0   )rx   r}   r  Znodesr]   rH   r1   r1   r2   rÂ    '  s    ÿzParallelRangeNode.nogil_checkc                 C   s  |   |¡ | jjj}|| jj ¡ dœ}| j| j| jf}d}t	|| j
|ƒD ]B\}}}|dkr`|}	n"|jrp| ¡ }	n| |¡ | ¡ }	|	||< qH|j | jd¡|d< |j | jd¡|d< | jdk	râ| j ¡ râ| jjdkrât|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k	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^  Z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 */)*rv  rš  rÎ   rL  rÿ   r  rK   r2  rÖ  rÉ  r  r»   r   r  rŠ   r	  r
  r¦  rU  rX  r   r0   Úisdigitr!  rD   r…  r4  Úgenerate_loopr6  rš  r”  rz  r_  r	   r{  rÊ   rŸ  ra  rå  r™  r  rw  )rx   rI   Ztarget_index_cnameÚfmt_dictr§  ÚdefaultsrH   r]   rò   rŠ   r  r1   r1   r2   rÊ   '  sV    (


þ


  





z)ParallelRangeNode.generate_execution_codec           
      C   sœ  | j r| d¡ n
| d¡ | js@| d¡ | ¡ | _| jj}nf| d¡ | ¡ | _| j}| d¡ | d¡ | ¡  |  |¡ | j r’| d¡ n
| d¡ | d¡ t	| j
 ¡ ƒD ]²\}\}}|r
|dkr
|| jjkr
|jjrôt| jdƒ n| d	||jf ¡ q´|| jjkr:| d
|j ¡ | d|j ¡ q´|jjs´|rNd}nd}| d||jf ¡ q´| jr¤| jrŒd|  || j¡ }nd}| d| j|f ¡ |  |¡ | d¡ | d¡ | d| ¡ | ¡  | ¡ }	| ¡  | d| ¡ | j|| jjd | jr"| j s"|j ¡  | j |¡ | j|dd | jrV| j sV|  |¡ | jrn|	 dtj  ¡ | !¡  | !¡  | jr˜|  "|¡ | !¡  d S )Nz#if 0rˆ  z#pragma omp forz#pragma omp parallelr­   r‰  z+*-&^|z#Python objects cannot be reductionsz reduction(%s:%s)rx  z lastprivate(%s)rk  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);)rp  T)r  r¨  )#r€  rD   ri  r_  r@   ry  rh  r4  r‡  rn  r_  rY   rš  rÎ   rÿ   r
  r   r0   rL  r¤  ra  rt  ru  rq  r	  r¢  r“   rÊ   r‘  r  rz  r	   r{  r6  rŠ  )
rx   rI   r«  Zreduction_codepointrÎ   r<  rk  rë  ra  Zguard_around_body_codepointr1   r1   r2   rª  ~'  sz    










ÿ





zParallelRangeNode.generate_loop)r?   rc   rd   rq   r†   r“   rš  r”  rF   rK   r2  rÖ  rb  r>  r¤  rd  rz   rŽ   rh   rÂ   rÊ   rª  re   r1   r1   rb   r2   r£  {&  s    
ÿVvr£  c                   @   s>   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 )Ú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
    rH   c                 C   s@  | j  |¡ | j }t|tƒr(|jjd }t|tƒ| _t|tt	fƒ}|j
}| jr„| j|_| j|_d|_|jr‚d|jkr‚|  |j¡|_n¸|rš| j |_|j_n¢|j}| j|_| jd |j_tj| j |j_| jd |j_|jj|jj_|jj|j_| jd |_|j ¡ D ]6\}}|jr"|  |j¡|_|jr|  |j¡|_qd S )Nr   Trì  Ú_objÚ_typerÖ  )rH   rŽ   r=   rÄ   r“   rÒ   r  Úis_functionrë  r  rÎ   rL  rð  ro  r1  rl  rÿ   rg  rî  r	   Ztypeobj_prefixrï  rn  ræ  r×  r0  rÍ   rY   )rx   r}   rH   Zis_struct_or_enumr½  rg  r]   rÎ   r1   r1   r2   rŽ   ó'  s8    
z'CnameDecoratorNode.analyse_declarationsc                 C   s$   d|kr|  d¡d }d| j|f S )Nrì  r°   z%s_%s)rò  rL  )rx   rL  r1   r1   r2   rl  (  s    zCnameDecoratorNode.manglec                 C   s   | j  |¡| _ | S rs   )rH   rh   r|   r1   r1   r2   rh   (  s    z&CnameDecoratorNode.analyse_expressionsc                 C   s†   | j rt|jrt|jd }t| jtƒr6| 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 placeZutility_code_protoFTr-  r   )Ú
ModuleNode)Z
definitionN)r°  rJ  rÈ   r=   rH   rÖ  r^  r­   r±  rÎ   rL  rð  Zgenerate_cfunction_declarationrÌ   rÉ   )rx   r}   rI   Zh_coder±  rÎ   rL  r1   r1   r2   rÉ   #(  s(    
  ÿüz0CnameDecoratorNode.generate_function_definitionsc                 C   s   | j  |¡ d S rs   )rH   rÊ   r   r1   r1   r2   rÊ   <(  s    z*CnameDecoratorNode.generate_execution_codeN)
r?   rc   rd   rq   r†   rŽ   rl  rh   rÉ   rÊ   r1   r1   r1   r2   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)
ZPrintz
Printing.cZPrintOner  r‹  ZRaiseExceptionZGetExceptionZSwapExceptionZSaveResetExceptionZ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Úrequires)®Ú
__future__r   rO  rï  r¨  r   r   Ú	itertoolsr   r­   r   ZErrorsr   r   r   r   r   r	   r
   r   r   r   r~  r   r   r   r   r   r   r   r   r   r   r    rW   r   ZStringEncodingr   r"   r#   r$   ZPythranr%   r&   r'   ZUtilsr)   r*   rÑ  r!  r   Úlongr  r3   r9   rQ   rÿ   rR   rf   rt   ru   rÄ   r’   rÑ   rá   rã   rí   rñ   r  r  r  r  r  r(  rq  rt  r¤  r‰  r§  r´  rÀ  rƒ  rÕ  r×  rÙ  rÜ  rä   rë  rñ  r  r  r  r  rý  r  rÕ  rÖ  r  rž  r©  r«  r¬  r­  rÜ  rÇ  rÉ  rÚ  r  r  r  r  rÃ  r"  r&  rP  r#  rY  ra  rh  rk  r  rn  ro  rr  rå  ry  r‰  rŽ  r’  r™  r›  rŸ  r¤  r¥  r©  rÄ  rÌ  rÍ  rÊ  rÉ  rË  rå  rë  rí  rÿ  r  r)  r*  r  r7  r8  rH  Zutility_code_for_importsr?  r@  rM  rW  r[  r\  r¡  r£  r­  Zgcc_branch_hintsZbranch_prediction_macrosrW  rd  rf  rƒ  rˆ  r
  r#  rø  Ztraceback_utility_codeZ get_exception_tuple_utility_coder1   r1   r1   r2   Ú<module>   sª  
           û4 /+%(#
. a )	g!}'s-[U+!     a   .    F        6 9r v    W&@  >f/GC)8
s 20)$/<\<
`
 pg! ) 9  	T	ûü-Td     [6  jcæ